@karmaniverous/get-dotenv 4.3.0 → 4.3.2

package/dist/index.cjs

@@ -1,33 +1,32 @@
 'use strict';
 
-var require$$0 = require('events');
-var require$$1 = require('child_process');
-var require$$0$1 = require('path');
-var require$$0$2 = require('fs');
-var require$$4$1 = require('process');
+var require$$0 = require('node:events');
+var require$$1 = require('node:child_process');
+var path$s = require('node:path');
+var fs$v = require('node:fs');
+var process$3 = require('node:process');
 var node_url = require('node:url');
-var node_child_process = require('node:child_process');
 var node_string_decoder = require('node:string_decoder');
 var tty = require('node:tty');
 var node_util = require('node:util');
-var fs$v = require('node:fs');
-var process$3 = require('node:process');
-var path$s = require('node:path');
+var require$$0$3 = require('child_process');
+var require$$0$2 = require('path');
+var require$$0$1 = require('fs');
 var promises = require('node:timers/promises');
 var node_os = require('node:os');
 var node_stream = require('node:stream');
 var node_buffer = require('node:buffer');
-var node_events = require('node:events');
 var promises$1 = require('node:stream/promises');
-var require$$0$3 = require('constants');
-var require$$0$4 = require('stream');
-var require$$0$5 = require('util');
+var require$$0$4 = require('constants');
+var require$$0$5 = require('stream');
+var require$$0$6 = require('util');
 var require$$5 = require('assert');
 var node_crypto = require('node:crypto');
 var url = require('url');
 var fsPromises = require('node:fs/promises');
 var require$$2 = require('os');
 var require$$3 = require('crypto');
+var require$$0$7 = require('events');
 
 // like String.prototype.search but returns the last index
 const searchLast = (str, rgx) => {
@@ -122,7 +121,6 @@ var error$1 = {};
 
 /**
  * CommanderError class
- * @class
  */
 
 let CommanderError$3 = class CommanderError extends Error {
@@ -131,7 +129,6 @@ let CommanderError$3 = class CommanderError extends Error {
    * @param {number} exitCode suggested exit code which could be used with process.exit
    * @param {string} code an id string representing the error
    * @param {string} message human-readable description of the error
-   * @constructor
    */
   constructor(exitCode, code, message) {
     super(message);
@@ -146,13 +143,11 @@ let CommanderError$3 = class CommanderError extends Error {
 
 /**
  * InvalidArgumentError class
- * @class
  */
 let InvalidArgumentError$4 = class InvalidArgumentError extends CommanderError$3 {
   /**
    * Constructs the InvalidArgumentError class
    * @param {string} [message] explanation of why argument is invalid
-   * @constructor
    */
   constructor(message) {
     super(1, 'commander.invalidArgument', message);
@@ -217,7 +212,7 @@ let Argument$3 = class Argument {
   }
 
   /**
-   * @package internal use only
+   * @package
    */
 
   _concatValue(value, previous) {
@@ -265,7 +260,9 @@ let Argument$3 = class Argument {
     this.argChoices = values.slice();
     this.parseArg = (arg, previous) => {
       if (!this.argChoices.includes(arg)) {
-        throw new InvalidArgumentError$3(`Allowed choices are ${this.argChoices.join(', ')}.`);
+        throw new InvalidArgumentError$3(
+          `Allowed choices are ${this.argChoices.join(', ')}.`,
+        );
       }
       if (this.variadic) {
         return this._concatValue(arg, previous);
@@ -277,6 +274,8 @@ let Argument$3 = class Argument {
 
   /**
    * Make argument required.
+   *
+   * @returns {Argument}
    */
   argRequired() {
     this.required = true;
@@ -285,6 +284,8 @@ let Argument$3 = class Argument {
 
   /**
    * Make argument optional.
+   *
+   * @returns {Argument}
    */
   argOptional() {
     this.required = false;
@@ -303,9 +304,7 @@ let Argument$3 = class Argument {
 function humanReadableArgName$2(arg) {
   const nameOutput = arg.name() + (arg.variadic === true ? '...' : '');
 
-  return arg.required
-    ? '<' + nameOutput + '>'
-    : '[' + nameOutput + ']';
+  return arg.required ? '<' + nameOutput + '>' : '[' + nameOutput + ']';
 }
 
 argument.Argument = Argument$3;
@@ -342,14 +341,14 @@ let Help$3 = class Help {
    */
 
   visibleCommands(cmd) {
-    const visibleCommands = cmd.commands.filter(cmd => !cmd._hidden);
+    const visibleCommands = cmd.commands.filter((cmd) => !cmd._hidden);
     const helpCommand = cmd._getHelpCommand();
     if (helpCommand && !helpCommand._hidden) {
       visibleCommands.push(helpCommand);
     }
     if (this.sortSubcommands) {
       visibleCommands.sort((a, b) => {
-        // @ts-ignore: overloaded return type
+        // @ts-ignore: because overloaded return type
         return a.name().localeCompare(b.name());
       });
     }
@@ -361,12 +360,14 @@ let Help$3 = class Help {
    *
    * @param {Option} a
    * @param {Option} b
-   * @returns number
+   * @returns {number}
    */
   compareOptions(a, b) {
     const getSortKey = (option) => {
       // WYSIWYG for order displayed in help. Short used for comparison if present. No special handling for negated.
-      return option.short ? option.short.replace(/^-/, '') : option.long.replace(/^--/, '');
+      return option.short
+        ? option.short.replace(/^-/, '')
+        : option.long.replace(/^--/, '');
     };
     return getSortKey(a).localeCompare(getSortKey(b));
   }
@@ -389,9 +390,13 @@ let Help$3 = class Help {
       if (!removeShort && !removeLong) {
         visibleOptions.push(helpOption); // no changes needed
       } else if (helpOption.long && !removeLong) {
-        visibleOptions.push(cmd.createOption(helpOption.long, helpOption.description));
+        visibleOptions.push(
+          cmd.createOption(helpOption.long, helpOption.description),
+        );
       } else if (helpOption.short && !removeShort) {
-        visibleOptions.push(cmd.createOption(helpOption.short, helpOption.description));
+        visibleOptions.push(
+          cmd.createOption(helpOption.short, helpOption.description),
+        );
       }
     }
     if (this.sortOptions) {
@@ -411,8 +416,14 @@ let Help$3 = class Help {
     if (!this.showGlobalOptions) return [];
 
     const globalOptions = [];
-    for (let ancestorCmd = cmd.parent; ancestorCmd; ancestorCmd = ancestorCmd.parent) {
-      const visibleOptions = ancestorCmd.options.filter((option) => !option.hidden);
+    for (
+      let ancestorCmd = cmd.parent;
+      ancestorCmd;
+      ancestorCmd = ancestorCmd.parent
+    ) {
+      const visibleOptions = ancestorCmd.options.filter(
+        (option) => !option.hidden,
+      );
       globalOptions.push(...visibleOptions);
     }
     if (this.sortOptions) {
@@ -431,13 +442,14 @@ let Help$3 = class Help {
   visibleArguments(cmd) {
     // Side effect! Apply the legacy descriptions before the arguments are displayed.
     if (cmd._argsDescription) {
-      cmd.registeredArguments.forEach(argument => {
-        argument.description = argument.description || cmd._argsDescription[argument.name()] || '';
+      cmd.registeredArguments.forEach((argument) => {
+        argument.description =
+          argument.description || cmd._argsDescription[argument.name()] || '';
       });
     }
 
     // If there are any arguments with a description then return all the arguments.
-    if (cmd.registeredArguments.find(argument => argument.description)) {
+    if (cmd.registeredArguments.find((argument) => argument.description)) {
       return cmd.registeredArguments;
     }
     return [];
@@ -452,11 +464,15 @@ let Help$3 = class Help {
 
   subcommandTerm(cmd) {
     // Legacy. Ignores custom usage string, and nested commands.
-    const args = cmd.registeredArguments.map(arg => humanReadableArgName$1(arg)).join(' ');
-    return cmd._name +
+    const args = cmd.registeredArguments
+      .map((arg) => humanReadableArgName$1(arg))
+      .join(' ');
+    return (
+      cmd._name +
       (cmd._aliases[0] ? '|' + cmd._aliases[0] : '') +
       (cmd.options.length ? ' [options]' : '') + // simplistic check for non-help option
-      (args ? ' ' + args : '');
+      (args ? ' ' + args : '')
+    );
   }
 
   /**
@@ -551,7 +567,11 @@ let Help$3 = class Help {
       cmdName = cmdName + '|' + cmd._aliases[0];
     }
     let ancestorCmdNames = '';
-    for (let ancestorCmd = cmd.parent; ancestorCmd; ancestorCmd = ancestorCmd.parent) {
+    for (
+      let ancestorCmd = cmd.parent;
+      ancestorCmd;
+      ancestorCmd = ancestorCmd.parent
+    ) {
       ancestorCmdNames = ancestorCmd.name() + ' ' + ancestorCmdNames;
     }
     return ancestorCmdNames + cmdName + ' ' + cmd.usage();
@@ -565,7 +585,7 @@ let Help$3 = class Help {
    */
 
   commandDescription(cmd) {
-    // @ts-ignore: overloaded return type
+    // @ts-ignore: because overloaded return type
     return cmd.description();
   }
 
@@ -578,7 +598,7 @@ let Help$3 = class Help {
    */
 
   subcommandDescription(cmd) {
-    // @ts-ignore: overloaded return type
+    // @ts-ignore: because overloaded return type
     return cmd.summary() || cmd.description();
   }
 
@@ -595,15 +615,20 @@ let Help$3 = class Help {
     if (option.argChoices) {
       extraInfo.push(
         // use stringify to match the display of the default value
-        `choices: ${option.argChoices.map((choice) => JSON.stringify(choice)).join(', ')}`);
+        `choices: ${option.argChoices.map((choice) => JSON.stringify(choice)).join(', ')}`,
+      );
     }
     if (option.defaultValue !== undefined) {
       // default for boolean and negated more for programmer than end user,
       // but show true/false for boolean option as may be for hand-rolled env or config processing.
-      const showDefault = option.required || option.optional ||
+      const showDefault =
+        option.required ||
+        option.optional ||
         (option.isBoolean() && typeof option.defaultValue === 'boolean');
       if (showDefault) {
-        extraInfo.push(`default: ${option.defaultValueDescription || JSON.stringify(option.defaultValue)}`);
+        extraInfo.push(
+          `default: ${option.defaultValueDescription || JSON.stringify(option.defaultValue)}`,
+        );
       }
     }
     // preset for boolean and negated are more for programmer than end user
@@ -632,10 +657,13 @@ let Help$3 = class Help {
     if (argument.argChoices) {
       extraInfo.push(
         // use stringify to match the display of the default value
-        `choices: ${argument.argChoices.map((choice) => JSON.stringify(choice)).join(', ')}`);
+        `choices: ${argument.argChoices.map((choice) => JSON.stringify(choice)).join(', ')}`,
+      );
     }
     if (argument.defaultValue !== undefined) {
-      extraInfo.push(`default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`);
+      extraInfo.push(
+        `default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`,
+      );
     }
     if (extraInfo.length > 0) {
       const extraDescripton = `(${extraInfo.join(', ')})`;
@@ -663,7 +691,11 @@ let Help$3 = class Help {
     function formatItem(term, description) {
       if (description) {
         const fullText = `${term.padEnd(termWidth + itemSeparatorWidth)}${description}`;
-        return helper.wrap(fullText, helpWidth - itemIndentWidth, termWidth + itemSeparatorWidth);
+        return helper.wrap(
+          fullText,
+          helpWidth - itemIndentWidth,
+          termWidth + itemSeparatorWidth,
+        );
       }
       return term;
     }
@@ -677,12 +709,18 @@ let Help$3 = class Help {
     // Description
     const commandDescription = helper.commandDescription(cmd);
     if (commandDescription.length > 0) {
-      output = output.concat([helper.wrap(commandDescription, helpWidth, 0), '']);
+      output = output.concat([
+        helper.wrap(commandDescription, helpWidth, 0),
+        '',
+      ]);
     }
 
     // Arguments
     const argumentList = helper.visibleArguments(cmd).map((argument) => {
-      return formatItem(helper.argumentTerm(argument), helper.argumentDescription(argument));
+      return formatItem(
+        helper.argumentTerm(argument),
+        helper.argumentDescription(argument),
+      );
     });
     if (argumentList.length > 0) {
       output = output.concat(['Arguments:', formatList(argumentList), '']);
@@ -690,24 +728,39 @@ let Help$3 = class Help {
 
     // Options
     const optionList = helper.visibleOptions(cmd).map((option) => {
-      return formatItem(helper.optionTerm(option), helper.optionDescription(option));
+      return formatItem(
+        helper.optionTerm(option),
+        helper.optionDescription(option),
+      );
     });
     if (optionList.length > 0) {
       output = output.concat(['Options:', formatList(optionList), '']);
     }
 
     if (this.showGlobalOptions) {
-      const globalOptionList = helper.visibleGlobalOptions(cmd).map((option) => {
-        return formatItem(helper.optionTerm(option), helper.optionDescription(option));
-      });
+      const globalOptionList = helper
+        .visibleGlobalOptions(cmd)
+        .map((option) => {
+          return formatItem(
+            helper.optionTerm(option),
+            helper.optionDescription(option),
+          );
+        });
       if (globalOptionList.length > 0) {
-        output = output.concat(['Global Options:', formatList(globalOptionList), '']);
+        output = output.concat([
+          'Global Options:',
+          formatList(globalOptionList),
+          '',
+        ]);
       }
     }
 
     // Commands
     const commandList = helper.visibleCommands(cmd).map((cmd) => {
-      return formatItem(helper.subcommandTerm(cmd), helper.subcommandDescription(cmd));
+      return formatItem(
+        helper.subcommandTerm(cmd),
+        helper.subcommandDescription(cmd),
+      );
     });
     if (commandList.length > 0) {
       output = output.concat(['Commands:', formatList(commandList), '']);
@@ -729,7 +782,7 @@ let Help$3 = class Help {
       helper.longestOptionTermLength(cmd, helper),
       helper.longestGlobalOptionTermLength(cmd, helper),
       helper.longestSubcommandTermLength(cmd, helper),
-      helper.longestArgumentTermLength(cmd, helper)
+      helper.longestArgumentTermLength(cmd, helper),
     );
   }
 
@@ -747,7 +800,8 @@ let Help$3 = class Help {
 
   wrap(str, width, indent, minColumnWidth = 40) {
     // Full \s characters, minus the linefeeds.
-    const indents = ' \\f\\t\\v\u00a0\u1680\u2000-\u200a\u202f\u205f\u3000\ufeff';
+    const indents =
+      ' \\f\\t\\v\u00a0\u1680\u2000-\u200a\u202f\u205f\u3000\ufeff';
     // Detect manually wrapped and indented strings by searching for line break followed by spaces.
     const manualIndent = new RegExp(`[\\n][${indents}]+`);
     if (str.match(manualIndent)) return str;
@@ -762,12 +816,20 @@ let Help$3 = class Help {
     const breaks = `\\s${zeroWidthSpace}`;
     // Match line end (so empty lines don't collapse),
     // or as much text as will fit in column, or excess text up to first break.
-    const regex = new RegExp(`\n|.{1,${columnWidth - 1}}([${breaks}]|$)|[^${breaks}]+?([${breaks}]|$)`, 'g');
+    const regex = new RegExp(
+      `\n|.{1,${columnWidth - 1}}([${breaks}]|$)|[^${breaks}]+?([${breaks}]|$)`,
+      'g',
+    );
     const lines = columnText.match(regex) || [];
-    return leadingStr + lines.map((line, i) => {
-      if (line === '\n') return ''; // preserve empty lines
-      return ((i > 0) ? indentString : '') + line.trimEnd();
-    }).join('\n');
+    return (
+      leadingStr +
+      lines
+        .map((line, i) => {
+          if (line === '\n') return ''; // preserve empty lines
+          return (i > 0 ? indentString : '') + line.trimEnd();
+        })
+        .join('\n')
+    );
   }
 };
 
@@ -870,7 +932,7 @@ let Option$3 = class Option {
    *   .addOption(new Option('--log', 'write logging information to file'))
    *   .addOption(new Option('--trace', 'log extra details').implies({ log: 'trace.txt' }));
    *
-   * @param {Object} impliedOptionValues
+   * @param {object} impliedOptionValues
    * @return {Option}
    */
   implies(impliedOptionValues) {
@@ -935,7 +997,7 @@ let Option$3 = class Option {
   }
 
   /**
-   * @package internal use only
+   * @package
    */
 
   _concatValue(value, previous) {
@@ -957,7 +1019,9 @@ let Option$3 = class Option {
     this.argChoices = values.slice();
     this.parseArg = (arg, previous) => {
       if (!this.argChoices.includes(arg)) {
-        throw new InvalidArgumentError$2(`Allowed choices are ${this.argChoices.join(', ')}.`);
+        throw new InvalidArgumentError$2(
+          `Allowed choices are ${this.argChoices.join(', ')}.`,
+        );
       }
       if (this.variadic) {
         return this._concatValue(arg, previous);
@@ -996,7 +1060,7 @@ let Option$3 = class Option {
    *
    * @param {string} arg
    * @return {boolean}
-   * @package internal use only
+   * @package
    */
 
   is(arg) {
@@ -1009,7 +1073,7 @@ let Option$3 = class Option {
    * Options are one of boolean, negated, required argument, or optional argument.
    *
    * @return {boolean}
-   * @package internal use only
+   * @package
    */
 
   isBoolean() {
@@ -1032,7 +1096,7 @@ let DualOptions$1 = class DualOptions {
     this.positiveOptions = new Map();
     this.negativeOptions = new Map();
     this.dualOptions = new Set();
-    options.forEach(option => {
+    options.forEach((option) => {
       if (option.negate) {
         this.negativeOptions.set(option.attributeName(), option);
       } else {
@@ -1059,7 +1123,7 @@ let DualOptions$1 = class DualOptions {
 
     // Use the value to deduce if (probably) came from the option.
     const preset = this.negativeOptions.get(optionKey).presetArg;
-    const negativeValue = (preset !== undefined) ? preset : false;
+    const negativeValue = preset !== undefined ? preset : false;
     return option.negate === (negativeValue === value);
   }
 };
@@ -1090,7 +1154,8 @@ function splitOptionFlags(flags) {
   // Use original very loose parsing to maintain backwards compatibility for now,
   // which allowed for example unintended `-sw, --short-word` [sic].
   const flagParts = flags.split(/[ |,]+/);
-  if (flagParts.length > 1 && !/^[[<]/.test(flagParts[1])) shortFlag = flagParts.shift();
+  if (flagParts.length > 1 && !/^[[<]/.test(flagParts[1]))
+    shortFlag = flagParts.shift();
   longFlag = flagParts.shift();
   // Add support for lone short flag without significantly changing parsing!
   if (!shortFlag && /^-[^-]$/.test(longFlag)) {
@@ -1113,7 +1178,8 @@ function editDistance(a, b) {
   // (Simple implementation.)
 
   // Quick early exit, return worst case.
-  if (Math.abs(a.length - b.length) > maxDistance) return Math.max(a.length, b.length);
+  if (Math.abs(a.length - b.length) > maxDistance)
+    return Math.max(a.length, b.length);
 
   // distance between prefix substrings of a and b
   const d = [];
@@ -1139,7 +1205,7 @@ function editDistance(a, b) {
       d[i][j] = Math.min(
         d[i - 1][j] + 1, // deletion
         d[i][j - 1] + 1, // insertion
-        d[i - 1][j - 1] + cost // substitution
+        d[i - 1][j - 1] + cost, // substitution
       );
       // transposition
       if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
@@ -1167,7 +1233,7 @@ function suggestSimilar$1(word, candidates) {
   const searchingOptions = word.startsWith('--');
   if (searchingOptions) {
     word = word.slice(2);
-    candidates = candidates.map(candidate => candidate.slice(2));
+    candidates = candidates.map((candidate) => candidate.slice(2));
   }
 
   let similar = [];
@@ -1192,7 +1258,7 @@ function suggestSimilar$1(word, candidates) {
 
   similar.sort((a, b) => a.localeCompare(b));
   if (searchingOptions) {
-    similar = similar.map(candidate => `--${candidate}`);
+    similar = similar.map((candidate) => `--${candidate}`);
   }
 
   if (similar.length > 1) {
@@ -1208,9 +1274,9 @@ suggestSimilar$2.suggestSimilar = suggestSimilar$1;
 
 const EventEmitter = require$$0.EventEmitter;
 const childProcess = require$$1;
-const path$r = require$$0$1;
-const fs$u = require$$0$2;
-const process$2 = require$$4$1;
+const path$r = path$s;
+const fs$u = fs$v;
+const process$2 = process$3;
 
 const { Argument: Argument$2, humanReadableArgName } = argument;
 const { CommanderError: CommanderError$2 } = error$1;
@@ -1268,9 +1334,11 @@ let Command$2 = class Command extends EventEmitter {
     this._outputConfiguration = {
       writeOut: (str) => process$2.stdout.write(str),
       writeErr: (str) => process$2.stderr.write(str),
-      getOutHelpWidth: () => process$2.stdout.isTTY ? process$2.stdout.columns : undefined,
-      getErrHelpWidth: () => process$2.stderr.isTTY ? process$2.stderr.columns : undefined,
-      outputError: (str, write) => write(str)
+      getOutHelpWidth: () =>
+        process$2.stdout.isTTY ? process$2.stdout.columns : undefined,
+      getErrHelpWidth: () =>
+        process$2.stderr.isTTY ? process$2.stderr.columns : undefined,
+      outputError: (str, write) => write(str),
     };
 
     this._hidden = false;
@@ -1297,7 +1365,8 @@ let Command$2 = class Command extends EventEmitter {
     this._helpConfiguration = sourceCommand._helpConfiguration;
     this._exitCallback = sourceCommand._exitCallback;
     this._storeOptionsAsProperties = sourceCommand._storeOptionsAsProperties;
-    this._combineFlagAndOptionalValue = sourceCommand._combineFlagAndOptionalValue;
+    this._combineFlagAndOptionalValue =
+      sourceCommand._combineFlagAndOptionalValue;
     this._allowExcessArguments = sourceCommand._allowExcessArguments;
     this._enablePositionalOptions = sourceCommand._enablePositionalOptions;
     this._showHelpAfterError = sourceCommand._showHelpAfterError;
@@ -1313,6 +1382,7 @@ let Command$2 = class Command extends EventEmitter {
 
   _getCommandAndAncestors() {
     const result = [];
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
     for (let command = this; command; command = command.parent) {
       result.push(command);
     }
@@ -1339,8 +1409,8 @@ let Command$2 = class Command extends EventEmitter {
    *   .command('stop [service]', 'stop named service, or all if no name supplied');
    *
    * @param {string} nameAndArgs - command name and arguments, args are `<required>` or `[optional]` and last may also be `variadic...`
-   * @param {(Object|string)} [actionOptsOrExecDesc] - configuration options (for action), or description (for executable)
-   * @param {Object} [execOpts] - configuration options (for executable)
+   * @param {(object | string)} [actionOptsOrExecDesc] - configuration options (for action), or description (for executable)
+   * @param {object} [execOpts] - configuration options (for executable)
    * @return {Command} returns new command for action handler, or `this` for executable command
    */
 
@@ -1400,8 +1470,8 @@ let Command$2 = class Command extends EventEmitter {
    * You can customise the help by overriding Help properties using configureHelp(),
    * or with a subclass of Help by overriding createHelp().
    *
-   * @param {Object} [configuration] - configuration options
-   * @return {(Command|Object)} `this` command for chaining, or stored configuration
+   * @param {object} [configuration] - configuration options
+   * @return {(Command | object)} `this` command for chaining, or stored configuration
    */
 
   configureHelp(configuration) {
@@ -1426,8 +1496,8 @@ let Command$2 = class Command extends EventEmitter {
    *     // functions based on what is being written out
    *     outputError(str, write) // used for displaying errors, and not used for displaying help
    *
-   * @param {Object} [configuration] - configuration options
-   * @return {(Command|Object)} `this` command for chaining, or stored configuration
+   * @param {object} [configuration] - configuration options
+   * @return {(Command | object)} `this` command for chaining, or stored configuration
    */
 
   configureOutput(configuration) {
@@ -1466,7 +1536,7 @@ let Command$2 = class Command extends EventEmitter {
    * See .command() for creating an attached subcommand which inherits settings from its parent.
    *
    * @param {Command} cmd - new subcommand
-   * @param {Object} [opts] - configuration options
+   * @param {object} [opts] - configuration options
    * @return {Command} `this` command for chaining
    */
 
@@ -1542,9 +1612,12 @@ let Command$2 = class Command extends EventEmitter {
    */
 
   arguments(names) {
-    names.trim().split(/ +/).forEach((detail) => {
-      this.argument(detail);
-    });
+    names
+      .trim()
+      .split(/ +/)
+      .forEach((detail) => {
+        this.argument(detail);
+      });
     return this;
   }
 
@@ -1557,10 +1630,18 @@ let Command$2 = class Command extends EventEmitter {
   addArgument(argument) {
     const previousArgument = this.registeredArguments.slice(-1)[0];
     if (previousArgument && previousArgument.variadic) {
-      throw new Error(`only the last argument can be variadic '${previousArgument.name()}'`);
+      throw new Error(
+        `only the last argument can be variadic '${previousArgument.name()}'`,
+      );
     }
-    if (argument.required && argument.defaultValue !== undefined && argument.parseArg === undefined) {
-      throw new Error(`a default value for a required argument is never used: '${argument.name()}'`);
+    if (
+      argument.required &&
+      argument.defaultValue !== undefined &&
+      argument.parseArg === undefined
+    ) {
+      throw new Error(
+        `a default value for a required argument is never used: '${argument.name()}'`,
+      );
     }
     this.registeredArguments.push(argument);
     return this;
@@ -1569,6 +1650,7 @@ let Command$2 = class Command extends EventEmitter {
   /**
    * Customise or override default help command. By default a help command is automatically added if your command has subcommands.
    *
+   * @example
    *    program.helpCommand('help [cmd]');
    *    program.helpCommand('help [cmd]', 'show help');
    *    program.helpCommand(false); // suppress default help command
@@ -1627,8 +1709,11 @@ let Command$2 = class Command extends EventEmitter {
    * @package
    */
   _getHelpCommand() {
-    const hasImplicitHelpCommand = this._addImplicitHelpCommand ??
-      (this.commands.length && !this._actionHandler && !this._findCommand('help'));
+    const hasImplicitHelpCommand =
+      this._addImplicitHelpCommand ??
+      (this.commands.length &&
+        !this._actionHandler &&
+        !this._findCommand('help'));
 
     if (hasImplicitHelpCommand) {
       if (this._helpCommand === undefined) {
@@ -1774,14 +1859,18 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * Register option if no conflicts found, or throw on conflict.
    *
    * @param {Option} option
-   * @api private
+   * @private
    */
 
   _registerOption(option) {
-    const matchingOption = (option.short && this._findOption(option.short)) ||
+    const matchingOption =
+      (option.short && this._findOption(option.short)) ||
       (option.long && this._findOption(option.long));
     if (matchingOption) {
-      const matchingFlag = (option.long && this._findOption(option.long)) ? option.long : option.short;
+      const matchingFlag =
+        option.long && this._findOption(option.long)
+          ? option.long
+          : option.short;
       throw new Error(`Cannot add option '${option.flags}'${this._name && ` to command '${this._name}'`} due to conflicting flag '${matchingFlag}'
 -  already used by option '${matchingOption.flags}'`);
     }
@@ -1794,7 +1883,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * Register command if no conflicts found, or throw on conflict.
    *
    * @param {Command} command
-   * @api private
+   * @private
    */
 
   _registerCommand(command) {
@@ -1802,11 +1891,15 @@ Expecting one of '${allowedValues.join("', '")}'`);
       return [cmd.name()].concat(cmd.aliases());
     };
 
-    const alreadyUsed = knownBy(command).find((name) => this._findCommand(name));
+    const alreadyUsed = knownBy(command).find((name) =>
+      this._findCommand(name),
+    );
     if (alreadyUsed) {
       const existingCmd = knownBy(this._findCommand(alreadyUsed)).join('|');
       const newCmd = knownBy(command).join('|');
-      throw new Error(`cannot add command '${newCmd}' as already have command '${existingCmd}'`);
+      throw new Error(
+        `cannot add command '${newCmd}' as already have command '${existingCmd}'`,
+      );
     }
 
     this.commands.push(command);
@@ -1829,7 +1922,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
       // --no-foo is special and defaults foo to true, unless a --foo option is already defined
       const positiveLongFlag = option.long.replace(/^--no-/, '--');
       if (!this._findOption(positiveLongFlag)) {
-        this.setOptionValueWithSource(name, option.defaultValue === undefined ? true : option.defaultValue, 'default');
+        this.setOptionValueWithSource(
+          name,
+          option.defaultValue === undefined ? true : option.defaultValue,
+          'default',
+        );
       }
     } else if (option.defaultValue !== undefined) {
       this.setOptionValueWithSource(name, option.defaultValue, 'default');
@@ -1882,11 +1979,14 @@ Expecting one of '${allowedValues.join("', '")}'`);
   /**
    * Internal implementation shared by .option() and .requiredOption()
    *
+   * @return {Command} `this` command for chaining
    * @private
    */
   _optionEx(config, flags, description, fn, defaultValue) {
     if (typeof flags === 'object' && flags instanceof Option$2) {
-      throw new Error('To add an Option object use addOption() instead of option() or requiredOption()');
+      throw new Error(
+        'To add an Option object use addOption() instead of option() or requiredOption()',
+      );
     }
     const option = this.createOption(flags, description);
     option.makeOptionMandatory(!!config.mandatory);
@@ -1934,20 +2034,26 @@ Expecting one of '${allowedValues.join("', '")}'`);
   }
 
   /**
-  * Add a required option which must have a value after parsing. This usually means
-  * the option must be specified on the command line. (Otherwise the same as .option().)
-  *
-  * The `flags` string contains the short and/or long flags, separated by comma, a pipe or space.
-  *
-  * @param {string} flags
-  * @param {string} [description]
-  * @param {(Function|*)} [parseArg] - custom option processing function or default value
-  * @param {*} [defaultValue]
-  * @return {Command} `this` command for chaining
-  */
+   * Add a required option which must have a value after parsing. This usually means
+   * the option must be specified on the command line. (Otherwise the same as .option().)
+   *
+   * The `flags` string contains the short and/or long flags, separated by comma, a pipe or space.
+   *
+   * @param {string} flags
+   * @param {string} [description]
+   * @param {(Function|*)} [parseArg] - custom option processing function or default value
+   * @param {*} [defaultValue]
+   * @return {Command} `this` command for chaining
+   */
 
   requiredOption(flags, description, parseArg, defaultValue) {
-    return this._optionEx({ mandatory: true }, flags, description, parseArg, defaultValue);
+    return this._optionEx(
+      { mandatory: true },
+      flags,
+      description,
+      parseArg,
+      defaultValue,
+    );
   }
 
   /**
@@ -1958,7 +2064,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * program.combineFlagAndOptionalValue(true);  // `-f80` is treated like `--flag=80`, this is the default behaviour
    * program.combineFlagAndOptionalValue(false) // `-fb` is treated like `-f -b`
    *
-   * @param {boolean} [combine=true] - if `true` or omitted, an optional value can be specified directly after the flag.
+   * @param {boolean} [combine] - if `true` or omitted, an optional value can be specified directly after the flag.
+   * @return {Command} `this` command for chaining
    */
   combineFlagAndOptionalValue(combine = true) {
     this._combineFlagAndOptionalValue = !!combine;
@@ -1968,8 +2075,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
   /**
    * Allow unknown options on the command line.
    *
-   * @param {boolean} [allowUnknown=true] - if `true` or omitted, no error will be thrown
-   * for unknown options.
+   * @param {boolean} [allowUnknown] - if `true` or omitted, no error will be thrown for unknown options.
+   * @return {Command} `this` command for chaining
    */
   allowUnknownOption(allowUnknown = true) {
     this._allowUnknownOption = !!allowUnknown;
@@ -1979,8 +2086,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
   /**
    * Allow excess command-arguments on the command line. Pass false to make excess arguments an error.
    *
-   * @param {boolean} [allowExcess=true] - if `true` or omitted, no error will be thrown
-   * for excess arguments.
+   * @param {boolean} [allowExcess] - if `true` or omitted, no error will be thrown for excess arguments.
+   * @return {Command} `this` command for chaining
    */
   allowExcessArguments(allowExcess = true) {
     this._allowExcessArguments = !!allowExcess;
@@ -1992,7 +2099,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * subcommands reuse the same option names, and also enables subcommands to turn on passThroughOptions.
    * The default behaviour is non-positional and global options may appear anywhere on the command line.
    *
-   * @param {boolean} [positional=true]
+   * @param {boolean} [positional]
+   * @return {Command} `this` command for chaining
    */
   enablePositionalOptions(positional = true) {
     this._enablePositionalOptions = !!positional;
@@ -2005,8 +2113,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * positional options to have been enabled on the program (parent commands).
    * The default behaviour is non-positional and options may appear before or after command-arguments.
    *
-   * @param {boolean} [passThrough=true]
-   * for unknown options.
+   * @param {boolean} [passThrough] for unknown options.
+   * @return {Command} `this` command for chaining
    */
   passThroughOptions(passThrough = true) {
     this._passThroughOptions = !!passThrough;
@@ -2019,25 +2127,33 @@ Expecting one of '${allowedValues.join("', '")}'`);
    */
 
   _checkForBrokenPassThrough() {
-    if (this.parent && this._passThroughOptions && !this.parent._enablePositionalOptions) {
-      throw new Error(`passThroughOptions cannot be used for '${this._name}' without turning on enablePositionalOptions for parent command(s)`);
+    if (
+      this.parent &&
+      this._passThroughOptions &&
+      !this.parent._enablePositionalOptions
+    ) {
+      throw new Error(
+        `passThroughOptions cannot be used for '${this._name}' without turning on enablePositionalOptions for parent command(s)`,
+      );
     }
   }
 
   /**
-    * Whether to store option values as properties on command object,
-    * or store separately (specify false). In both cases the option values can be accessed using .opts().
-    *
-    * @param {boolean} [storeAsProperties=true]
-    * @return {Command} `this` command for chaining
-    */
+   * Whether to store option values as properties on command object,
+   * or store separately (specify false). In both cases the option values can be accessed using .opts().
+   *
+   * @param {boolean} [storeAsProperties=true]
+   * @return {Command} `this` command for chaining
+   */
 
   storeOptionsAsProperties(storeAsProperties = true) {
     if (this.options.length) {
       throw new Error('call .storeOptionsAsProperties() before adding options');
     }
     if (Object.keys(this._optionValues).length) {
-      throw new Error('call .storeOptionsAsProperties() before setting option values');
+      throw new Error(
+        'call .storeOptionsAsProperties() before setting option values',
+      );
     }
     this._storeOptionsAsProperties = !!storeAsProperties;
     return this;
@@ -2047,7 +2163,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * Retrieve option value.
    *
    * @param {string} key
-   * @return {Object} value
+   * @return {object} value
    */
 
   getOptionValue(key) {
@@ -2061,7 +2177,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * Store option value.
    *
    * @param {string} key
-   * @param {Object} value
+   * @param {object} value
    * @return {Command} `this` command for chaining
    */
 
@@ -2070,13 +2186,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
   }
 
   /**
-    * Store option value and where the value came from.
-    *
-    * @param {string} key
-    * @param {Object} value
-    * @param {string} source - expected values are default/config/env/cli/implied
-    * @return {Command} `this` command for chaining
-    */
+   * Store option value and where the value came from.
+   *
+   * @param {string} key
+   * @param {object} value
+   * @param {string} source - expected values are default/config/env/cli/implied
+   * @return {Command} `this` command for chaining
+   */
 
   setOptionValueWithSource(key, value, source) {
     if (this._storeOptionsAsProperties) {
@@ -2089,24 +2205,24 @@ Expecting one of '${allowedValues.join("', '")}'`);
   }
 
   /**
-    * Get source of option value.
-    * Expected values are default | config | env | cli | implied
-    *
-    * @param {string} key
-    * @return {string}
-    */
+   * Get source of option value.
+   * Expected values are default | config | env | cli | implied
+   *
+   * @param {string} key
+   * @return {string}
+   */
 
   getOptionValueSource(key) {
     return this._optionValueSources[key];
   }
 
   /**
-    * Get source of option value. See also .optsWithGlobals().
-    * Expected values are default | config | env | cli | implied
-    *
-    * @param {string} key
-    * @return {string}
-    */
+   * Get source of option value. See also .optsWithGlobals().
+   * Expected values are default | config | env | cli | implied
+   *
+   * @param {string} key
+   * @return {string}
+   */
 
   getOptionValueSourceWithGlobals(key) {
     // global overwrites local, like optsWithGlobals
@@ -2132,17 +2248,30 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     parseOptions = parseOptions || {};
 
-    // Default to using process.argv
-    if (argv === undefined) {
-      argv = process$2.argv;
-      // @ts-ignore: unknown property
-      if (process$2.versions && process$2.versions.electron) {
+    // auto-detect argument conventions if nothing supplied
+    if (argv === undefined && parseOptions.from === undefined) {
+      if (process$2.versions?.electron) {
         parseOptions.from = 'electron';
       }
+      // check node specific options for scenarios where user CLI args follow executable without scriptname
+      const execArgv = process$2.execArgv ?? [];
+      if (
+        execArgv.includes('-e') ||
+        execArgv.includes('--eval') ||
+        execArgv.includes('-p') ||
+        execArgv.includes('--print')
+      ) {
+        parseOptions.from = 'eval'; // internal usage, not documented
+      }
+    }
+
+    // default to using process.argv
+    if (argv === undefined) {
+      argv = process$2.argv;
     }
     this.rawArgs = argv.slice();
 
-    // make it a little easier for callers by supporting various argv conventions
+    // extract the user args and scriptPath
     let userArgs;
     switch (parseOptions.from) {
       case undefined:
@@ -2151,7 +2280,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         userArgs = argv.slice(2);
         break;
       case 'electron':
-        // @ts-ignore: unknown property
+        // @ts-ignore: because defaultApp is an unknown property
         if (process$2.defaultApp) {
           this._scriptPath = argv[1];
           userArgs = argv.slice(2);
@@ -2162,12 +2291,18 @@ Expecting one of '${allowedValues.join("', '")}'`);
       case 'user':
         userArgs = argv.slice(0);
         break;
+      case 'eval':
+        userArgs = argv.slice(1);
+        break;
       default:
-        throw new Error(`unexpected parse option { from: '${parseOptions.from}' }`);
+        throw new Error(
+          `unexpected parse option { from: '${parseOptions.from}' }`,
+        );
     }
 
     // Find default name for program from arguments.
-    if (!this._name && this._scriptPath) this.nameFromFilename(this._scriptPath);
+    if (!this._name && this._scriptPath)
+      this.nameFromFilename(this._scriptPath);
     this._name = this._name || 'program';
 
     return userArgs;
@@ -2176,16 +2311,22 @@ Expecting one of '${allowedValues.join("', '")}'`);
   /**
    * Parse `argv`, setting options and invoking commands when defined.
    *
-   * The default expectation is that the arguments are from node and have the application as argv[0]
-   * and the script being run in argv[1], with user parameters after that.
+   * Use parseAsync instead of parse if any of your action handlers are async.
+   *
+   * Call with no parameters to parse `process.argv`. Detects Electron and special node options like `node --eval`. Easy mode!
+   *
+   * Or call with an array of strings to parse, and optionally where the user arguments start by specifying where the arguments are `from`:
+   * - `'node'`: default, `argv[0]` is the application and `argv[1]` is the script being run, with user arguments after that
+   * - `'electron'`: `argv[0]` is the application and `argv[1]` varies depending on whether the electron application is packaged
+   * - `'user'`: just user arguments
    *
    * @example
-   * program.parse(process.argv);
-   * program.parse(); // implicitly use process.argv and auto-detect node vs electron conventions
+   * program.parse(); // parse process.argv and auto-detect electron and special node flags
+   * program.parse(process.argv); // assume argv[0] is app and argv[1] is script
    * program.parse(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]
    *
    * @param {string[]} [argv] - optional, defaults to process.argv
-   * @param {Object} [parseOptions] - optionally specify style of options with from: node/user/electron
+   * @param {object} [parseOptions] - optionally specify style of options with from: node/user/electron
    * @param {string} [parseOptions.from] - where the args are from: 'node', 'user', 'electron'
    * @return {Command} `this` command for chaining
    */
@@ -2200,18 +2341,20 @@ Expecting one of '${allowedValues.join("', '")}'`);
   /**
    * Parse `argv`, setting options and invoking commands when defined.
    *
-   * Use parseAsync instead of parse if any of your action handlers are async. Returns a Promise.
+   * Call with no parameters to parse `process.argv`. Detects Electron and special node options like `node --eval`. Easy mode!
    *
-   * The default expectation is that the arguments are from node and have the application as argv[0]
-   * and the script being run in argv[1], with user parameters after that.
+   * Or call with an array of strings to parse, and optionally where the user arguments start by specifying where the arguments are `from`:
+   * - `'node'`: default, `argv[0]` is the application and `argv[1]` is the script being run, with user arguments after that
+   * - `'electron'`: `argv[0]` is the application and `argv[1]` varies depending on whether the electron application is packaged
+   * - `'user'`: just user arguments
    *
    * @example
-   * await program.parseAsync(process.argv);
-   * await program.parseAsync(); // implicitly use process.argv and auto-detect node vs electron conventions
+   * await program.parseAsync(); // parse process.argv and auto-detect electron and special node flags
+   * await program.parseAsync(process.argv); // assume argv[0] is app and argv[1] is script
    * await program.parseAsync(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]
    *
    * @param {string[]} [argv]
-   * @param {Object} [parseOptions]
+   * @param {object} [parseOptions]
    * @param {string} parseOptions.from - where the args are from: 'node', 'user', 'electron'
    * @return {Promise}
    */
@@ -2243,7 +2386,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
       if (sourceExt.includes(path$r.extname(baseName))) return undefined;
 
       // Try all the extensions.
-      const foundExt = sourceExt.find(ext => fs$u.existsSync(`${localBin}${ext}`));
+      const foundExt = sourceExt.find((ext) =>
+        fs$u.existsSync(`${localBin}${ext}`),
+      );
       if (foundExt) return `${localBin}${foundExt}`;
 
       return undefined;
@@ -2254,7 +2399,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
     this._checkForConflictingOptions();
 
     // executableFile and executableDir might be full path, or just a name
-    let executableFile = subcommand._executableFile || `${this._name}-${subcommand._name}`;
+    let executableFile =
+      subcommand._executableFile || `${this._name}-${subcommand._name}`;
     let executableDir = this._executableDir || '';
     if (this._scriptPath) {
       let resolvedScriptPath; // resolve possible symlink for installed npm binary
@@ -2263,7 +2409,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
       } catch (err) {
         resolvedScriptPath = this._scriptPath;
       }
-      executableDir = path$r.resolve(path$r.dirname(resolvedScriptPath), executableDir);
+      executableDir = path$r.resolve(
+        path$r.dirname(resolvedScriptPath),
+        executableDir,
+      );
     }
 
     // Look for a local file in preference to a command in PATH.
@@ -2272,9 +2421,15 @@ Expecting one of '${allowedValues.join("', '")}'`);
 
       // Legacy search using prefix of script name instead of command name
       if (!localFile && !subcommand._executableFile && this._scriptPath) {
-        const legacyName = path$r.basename(this._scriptPath, path$r.extname(this._scriptPath));
+        const legacyName = path$r.basename(
+          this._scriptPath,
+          path$r.extname(this._scriptPath),
+        );
         if (legacyName !== this._name) {
-          localFile = findFile(executableDir, `${legacyName}-${subcommand._name}`);
+          localFile = findFile(
+            executableDir,
+            `${legacyName}-${subcommand._name}`,
+          );
         }
       }
       executableFile = localFile || executableFile;
@@ -2300,12 +2455,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
       proc = childProcess.spawn(process$2.execPath, args, { stdio: 'inherit' });
     }
 
-    if (!proc.killed) { // testing mainly to avoid leak warnings during unit tests with mocked spawn
+    if (!proc.killed) {
+      // testing mainly to avoid leak warnings during unit tests with mocked spawn
       const signals = ['SIGUSR1', 'SIGUSR2', 'SIGTERM', 'SIGINT', 'SIGHUP'];
       signals.forEach((signal) => {
-        // @ts-ignore
         process$2.on(signal, () => {
           if (proc.killed === false && proc.exitCode === null) {
+            // @ts-ignore because signals not typed to known strings
             proc.kill(signal);
           }
         });
@@ -2314,16 +2470,22 @@ Expecting one of '${allowedValues.join("', '")}'`);
 
     // By default terminate process when spawned process terminates.
     const exitCallback = this._exitCallback;
-    proc.on('close', (code, _signal) => {
+    proc.on('close', (code) => {
       code = code ?? 1; // code is null if spawned process terminated due to a signal
       if (!exitCallback) {
         process$2.exit(code);
       } else {
-        exitCallback(new CommanderError$2(code, 'commander.executeSubCommandAsync', '(close)'));
+        exitCallback(
+          new CommanderError$2(
+            code,
+            'commander.executeSubCommandAsync',
+            '(close)',
+          ),
+        );
       }
     });
     proc.on('error', (err) => {
-      // @ts-ignore
+      // @ts-ignore: because err.code is an unknown property
       if (err.code === 'ENOENT') {
         const executableDirMessage = executableDir
           ? `searched for local subcommand relative to directory '${executableDir}'`
@@ -2333,14 +2495,18 @@ Expecting one of '${allowedValues.join("', '")}'`);
  - if the default executable name is not suitable, use the executableFile option to supply a custom name or path
  - ${executableDirMessage}`;
         throw new Error(executableMissing);
-      // @ts-ignore
+        // @ts-ignore: because err.code is an unknown property
       } else if (err.code === 'EACCES') {
         throw new Error(`'${executableFile}' not executable`);
       }
       if (!exitCallback) {
         process$2.exit(1);
       } else {
-        const wrappedError = new CommanderError$2(1, 'commander.executeSubCommandAsync', '(error)');
+        const wrappedError = new CommanderError$2(
+          1,
+          'commander.executeSubCommandAsync',
+          '(error)',
+        );
         wrappedError.nestedError = err;
         exitCallback(wrappedError);
       }
@@ -2359,7 +2525,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
     if (!subCommand) this.help({ error: true });
 
     let promiseChain;
-    promiseChain = this._chainOrCallSubCommandHook(promiseChain, subCommand, 'preSubcommand');
+    promiseChain = this._chainOrCallSubCommandHook(
+      promiseChain,
+      subCommand,
+      'preSubcommand',
+    );
     promiseChain = this._chainOrCall(promiseChain, () => {
       if (subCommand._executableHandler) {
         this._executeSubCommand(subCommand, operands.concat(unknown));
@@ -2387,9 +2557,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
 
     // Fallback to parsing the help flag to invoke the help.
-    return this._dispatchSubcommand(subcommandName, [], [
-      this._getHelpOption()?.long ?? this._getHelpOption()?.short ?? '--help'
-    ]);
+    return this._dispatchSubcommand(
+      subcommandName,
+      [],
+      [this._getHelpOption()?.long ?? this._getHelpOption()?.short ?? '--help'],
+    );
   }
 
   /**
@@ -2406,7 +2578,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
       }
     });
     // too many
-    if (this.registeredArguments.length > 0 && this.registeredArguments[this.registeredArguments.length - 1].variadic) {
+    if (
+      this.registeredArguments.length > 0 &&
+      this.registeredArguments[this.registeredArguments.length - 1].variadic
+    ) {
       return;
     }
     if (this.args.length > this.registeredArguments.length) {
@@ -2426,7 +2601,12 @@ Expecting one of '${allowedValues.join("', '")}'`);
       let parsedValue = value;
       if (value !== null && argument.parseArg) {
         const invalidValueMessage = `error: command-argument value '${value}' is invalid for argument '${argument.name()}'.`;
-        parsedValue = this._callParseArg(argument, value, previous, invalidValueMessage);
+        parsedValue = this._callParseArg(
+          argument,
+          value,
+          previous,
+          invalidValueMessage,
+        );
       }
       return parsedValue;
     };
@@ -2491,8 +2671,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
     const hooks = [];
     this._getCommandAndAncestors()
       .reverse()
-      .filter(cmd => cmd._lifeCycleHooks[event] !== undefined)
-      .forEach(hookedCommand => {
+      .filter((cmd) => cmd._lifeCycleHooks[event] !== undefined)
+      .forEach((hookedCommand) => {
         hookedCommand._lifeCycleHooks[event].forEach((callback) => {
           hooks.push({ hookedCommand, callback });
         });
@@ -2548,14 +2728,26 @@ Expecting one of '${allowedValues.join("', '")}'`);
     if (operands && this._findCommand(operands[0])) {
       return this._dispatchSubcommand(operands[0], operands.slice(1), unknown);
     }
-    if (this._getHelpCommand() && operands[0] === this._getHelpCommand().name()) {
+    if (
+      this._getHelpCommand() &&
+      operands[0] === this._getHelpCommand().name()
+    ) {
       return this._dispatchHelpCommand(operands[1]);
     }
     if (this._defaultCommandName) {
       this._outputHelpIfRequested(unknown); // Run the help for default command from parent rather than passing to default command
-      return this._dispatchSubcommand(this._defaultCommandName, operands, unknown);
+      return this._dispatchSubcommand(
+        this._defaultCommandName,
+        operands,
+        unknown,
+      );
     }
-    if (this.commands.length && this.args.length === 0 && !this._actionHandler && !this._defaultCommandName) {
+    if (
+      this.commands.length &&
+      this.args.length === 0 &&
+      !this._actionHandler &&
+      !this._defaultCommandName
+    ) {
       // probably missing subcommand and no handler, user needs help (and exit)
       this.help({ error: true });
     }
@@ -2578,7 +2770,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
 
       let promiseChain;
       promiseChain = this._chainOrCallHooks(promiseChain, 'preAction');
-      promiseChain = this._chainOrCall(promiseChain, () => this._actionHandler(this.processedArgs));
+      promiseChain = this._chainOrCall(promiseChain, () =>
+        this._actionHandler(this.processedArgs),
+      );
       if (this.parent) {
         promiseChain = this._chainOrCall(promiseChain, () => {
           this.parent.emit(commandEvent, operands, unknown); // legacy
@@ -2592,7 +2786,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
       this._processArguments();
       this.parent.emit(commandEvent, operands, unknown); // legacy
     } else if (operands.length) {
-      if (this._findCommand('*')) { // legacy default command
+      if (this._findCommand('*')) {
+        // legacy default command
         return this._dispatchSubcommand('*', operands, unknown);
       }
       if (this.listenerCount('command:*')) {
@@ -2619,10 +2814,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * Find matching command.
    *
    * @private
+   * @return {Command | undefined}
    */
   _findCommand(name) {
     if (!name) return undefined;
-    return this.commands.find(cmd => cmd._name === name || cmd._aliases.includes(name));
+    return this.commands.find(
+      (cmd) => cmd._name === name || cmd._aliases.includes(name),
+    );
   }
 
   /**
@@ -2630,11 +2828,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
    *
    * @param {string} arg
    * @return {Option}
-   * @package internal use only
+   * @package
    */
 
   _findOption(arg) {
-    return this.options.find(option => option.is(arg));
+    return this.options.find((option) => option.is(arg));
   }
 
   /**
@@ -2648,7 +2846,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
     // Walk up hierarchy so can call in subcommand after checking for displaying help.
     this._getCommandAndAncestors().forEach((cmd) => {
       cmd.options.forEach((anOption) => {
-        if (anOption.mandatory && (cmd.getOptionValue(anOption.attributeName()) === undefined)) {
+        if (
+          anOption.mandatory &&
+          cmd.getOptionValue(anOption.attributeName()) === undefined
+        ) {
           cmd.missingMandatoryOptionValue(anOption);
         }
       });
@@ -2661,23 +2862,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @private
    */
   _checkForConflictingLocalOptions() {
-    const definedNonDefaultOptions = this.options.filter(
-      (option) => {
-        const optionKey = option.attributeName();
-        if (this.getOptionValue(optionKey) === undefined) {
-          return false;
-        }
-        return this.getOptionValueSource(optionKey) !== 'default';
+    const definedNonDefaultOptions = this.options.filter((option) => {
+      const optionKey = option.attributeName();
+      if (this.getOptionValue(optionKey) === undefined) {
+        return false;
       }
-    );
+      return this.getOptionValueSource(optionKey) !== 'default';
+    });
 
     const optionsWithConflicting = definedNonDefaultOptions.filter(
-      (option) => option.conflictsWith.length > 0
+      (option) => option.conflictsWith.length > 0,
     );
 
     optionsWithConflicting.forEach((option) => {
       const conflictingAndDefined = definedNonDefaultOptions.find((defined) =>
-        option.conflictsWith.includes(defined.attributeName())
+        option.conflictsWith.includes(defined.attributeName()),
       );
       if (conflictingAndDefined) {
         this._conflictingOption(option, conflictingAndDefined);
@@ -2757,7 +2956,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
               value = args.shift();
             }
             this.emit(`option:${option.name()}`, value);
-          } else { // boolean flag
+          } else {
+            // boolean flag
             this.emit(`option:${option.name()}`);
           }
           activeVariadicOption = option.variadic ? option : null;
@@ -2769,7 +2969,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
       if (arg.length > 2 && arg[0] === '-' && arg[1] !== '-') {
         const option = this._findOption(`-${arg[1]}`);
         if (option) {
-          if (option.required || (option.optional && this._combineFlagAndOptionalValue)) {
+          if (
+            option.required ||
+            (option.optional && this._combineFlagAndOptionalValue)
+          ) {
             // option with value following in same argument
             this.emit(`option:${option.name()}`, arg.slice(2));
           } else {
@@ -2800,12 +3003,19 @@ Expecting one of '${allowedValues.join("', '")}'`);
       }
 
       // If using positionalOptions, stop processing our options at subcommand.
-      if ((this._enablePositionalOptions || this._passThroughOptions) && operands.length === 0 && unknown.length === 0) {
+      if (
+        (this._enablePositionalOptions || this._passThroughOptions) &&
+        operands.length === 0 &&
+        unknown.length === 0
+      ) {
         if (this._findCommand(arg)) {
           operands.push(arg);
           if (args.length > 0) unknown.push(...args);
           break;
-        } else if (this._getHelpCommand() && arg === this._getHelpCommand().name()) {
+        } else if (
+          this._getHelpCommand() &&
+          arg === this._getHelpCommand().name()
+        ) {
           operands.push(arg);
           if (args.length > 0) operands.push(...args);
           break;
@@ -2833,7 +3043,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
   /**
    * Return an object containing local option values as key-value pairs.
    *
-   * @return {Object}
+   * @return {object}
    */
   opts() {
     if (this._storeOptionsAsProperties) {
@@ -2843,7 +3053,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
 
       for (let i = 0; i < len; i++) {
         const key = this.options[i].attributeName();
-        result[key] = key === this._versionOptionName ? this._version : this[key];
+        result[key] =
+          key === this._versionOptionName ? this._version : this[key];
       }
       return result;
     }
@@ -2854,13 +3065,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
   /**
    * Return an object containing merged local and global option values as key-value pairs.
    *
-   * @return {Object}
+   * @return {object}
    */
   optsWithGlobals() {
     // globals overwrite locals
     return this._getCommandAndAncestors().reduce(
       (combinedOptions, cmd) => Object.assign(combinedOptions, cmd.opts()),
-      {}
+      {},
     );
   }
 
@@ -2868,13 +3079,16 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * Display error message and exit (or call exitOverride).
    *
    * @param {string} message
-   * @param {Object} [errorOptions]
+   * @param {object} [errorOptions]
    * @param {string} [errorOptions.code] - an id string representing the error
    * @param {number} [errorOptions.exitCode] - used with process.exit
    */
   error(message, errorOptions) {
     // output handling
-    this._outputConfiguration.outputError(`${message}\n`, this._outputConfiguration.writeErr);
+    this._outputConfiguration.outputError(
+      `${message}\n`,
+      this._outputConfiguration.writeErr,
+    );
     if (typeof this._showHelpAfterError === 'string') {
       this._outputConfiguration.writeErr(`${this._showHelpAfterError}\n`);
     } else if (this._showHelpAfterError) {
@@ -2900,11 +3114,18 @@ Expecting one of '${allowedValues.join("', '")}'`);
       if (option.envVar && option.envVar in process$2.env) {
         const optionKey = option.attributeName();
         // Priority check. Do not overwrite cli or options from unknown source (client-code).
-        if (this.getOptionValue(optionKey) === undefined || ['default', 'config', 'env'].includes(this.getOptionValueSource(optionKey))) {
-          if (option.required || option.optional) { // option can take a value
+        if (
+          this.getOptionValue(optionKey) === undefined ||
+          ['default', 'config', 'env'].includes(
+            this.getOptionValueSource(optionKey),
+          )
+        ) {
+          if (option.required || option.optional) {
+            // option can take a value
             // keep very simple, optional always takes value
             this.emit(`optionEnv:${option.name()}`, process$2.env[option.envVar]);
-          } else { // boolean
+          } else {
+            // boolean
             // keep very simple, only care that envVar defined and not the value
             this.emit(`optionEnv:${option.name()}`);
           }
@@ -2921,17 +3142,30 @@ Expecting one of '${allowedValues.join("', '")}'`);
   _parseOptionsImplied() {
     const dualHelper = new DualOptions(this.options);
     const hasCustomOptionValue = (optionKey) => {
-      return this.getOptionValue(optionKey) !== undefined && !['default', 'implied'].includes(this.getOptionValueSource(optionKey));
+      return (
+        this.getOptionValue(optionKey) !== undefined &&
+        !['default', 'implied'].includes(this.getOptionValueSource(optionKey))
+      );
     };
     this.options
-      .filter(option => (option.implied !== undefined) &&
-        hasCustomOptionValue(option.attributeName()) &&
-        dualHelper.valueFromOption(this.getOptionValue(option.attributeName()), option))
+      .filter(
+        (option) =>
+          option.implied !== undefined &&
+          hasCustomOptionValue(option.attributeName()) &&
+          dualHelper.valueFromOption(
+            this.getOptionValue(option.attributeName()),
+            option,
+          ),
+      )
       .forEach((option) => {
         Object.keys(option.implied)
-          .filter(impliedKey => !hasCustomOptionValue(impliedKey))
-          .forEach(impliedKey => {
-            this.setOptionValueWithSource(impliedKey, option.implied[impliedKey], 'implied');
+          .filter((impliedKey) => !hasCustomOptionValue(impliedKey))
+          .forEach((impliedKey) => {
+            this.setOptionValueWithSource(
+              impliedKey,
+              option.implied[impliedKey],
+              'implied',
+            );
           });
       });
   }
@@ -2985,12 +3219,18 @@ Expecting one of '${allowedValues.join("', '")}'`);
     const findBestOptionFromValue = (option) => {
       const optionKey = option.attributeName();
       const optionValue = this.getOptionValue(optionKey);
-      const negativeOption = this.options.find(target => target.negate && optionKey === target.attributeName());
-      const positiveOption = this.options.find(target => !target.negate && optionKey === target.attributeName());
-      if (negativeOption && (
-        (negativeOption.presetArg === undefined && optionValue === false) ||
-        (negativeOption.presetArg !== undefined && optionValue === negativeOption.presetArg)
-      )) {
+      const negativeOption = this.options.find(
+        (target) => target.negate && optionKey === target.attributeName(),
+      );
+      const positiveOption = this.options.find(
+        (target) => !target.negate && optionKey === target.attributeName(),
+      );
+      if (
+        negativeOption &&
+        ((negativeOption.presetArg === undefined && optionValue === false) ||
+          (negativeOption.presetArg !== undefined &&
+            optionValue === negativeOption.presetArg))
+      ) {
         return negativeOption;
       }
       return positiveOption || option;
@@ -3024,11 +3264,14 @@ Expecting one of '${allowedValues.join("', '")}'`);
     if (flag.startsWith('--') && this._showSuggestionAfterError) {
       // Looping to pick up the global options too
       let candidateFlags = [];
+      // eslint-disable-next-line @typescript-eslint/no-this-alias
       let command = this;
       do {
-        const moreFlags = command.createHelp().visibleOptions(command)
-          .filter(option => option.long)
-          .map(option => option.long);
+        const moreFlags = command
+          .createHelp()
+          .visibleOptions(command)
+          .filter((option) => option.long)
+          .map((option) => option.long);
         candidateFlags = candidateFlags.concat(moreFlags);
         command = command.parent;
       } while (command && !command._enablePositionalOptions);
@@ -3050,7 +3293,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
     if (this._allowExcessArguments) return;
 
     const expected = this.registeredArguments.length;
-    const s = (expected === 1) ? '' : 's';
+    const s = expected === 1 ? '' : 's';
     const forSubcommand = this.parent ? ` for '${this.name()}'` : '';
     const message = `error: too many arguments${forSubcommand}. Expected ${expected} argument${s} but got ${receivedArgs.length}.`;
     this.error(message, { code: 'commander.excessArguments' });
@@ -3068,11 +3311,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
 
     if (this._showSuggestionAfterError) {
       const candidateNames = [];
-      this.createHelp().visibleCommands(this).forEach((command) => {
-        candidateNames.push(command.name());
-        // just visible alias
-        if (command.alias()) candidateNames.push(command.alias());
-      });
+      this.createHelp()
+        .visibleCommands(this)
+        .forEach((command) => {
+          candidateNames.push(command.name());
+          // just visible alias
+          if (command.alias()) candidateNames.push(command.alias());
+        });
       suggestion = suggestSimilar(unknownName, candidateNames);
     }
 
@@ -3113,11 +3358,12 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * Set the description.
    *
    * @param {string} [str]
-   * @param {Object} [argsDescription]
+   * @param {object} [argsDescription]
    * @return {(string|Command)}
    */
   description(str, argsDescription) {
-    if (str === undefined && argsDescription === undefined) return this._description;
+    if (str === undefined && argsDescription === undefined)
+      return this._description;
     this._description = str;
     if (argsDescription) {
       this._argsDescription = argsDescription;
@@ -3150,18 +3396,27 @@ Expecting one of '${allowedValues.join("', '")}'`);
     if (alias === undefined) return this._aliases[0]; // just return first, for backwards compatibility
 
     /** @type {Command} */
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
     let command = this;
-    if (this.commands.length !== 0 && this.commands[this.commands.length - 1]._executableHandler) {
+    if (
+      this.commands.length !== 0 &&
+      this.commands[this.commands.length - 1]._executableHandler
+    ) {
       // assume adding alias for last added executable subcommand, rather than this
       command = this.commands[this.commands.length - 1];
     }
 
-    if (alias === command._name) throw new Error('Command alias can\'t be the same as its name');
+    if (alias === command._name)
+      throw new Error("Command alias can't be the same as its name");
     const matchingCommand = this.parent?._findCommand(alias);
     if (matchingCommand) {
       // c.f. _registerCommand
-      const existingCmd = [matchingCommand.name()].concat(matchingCommand.aliases()).join('|');
-      throw new Error(`cannot add alias '${alias}' to command '${this.name()}' as already have command '${existingCmd}'`);
+      const existingCmd = [matchingCommand.name()]
+        .concat(matchingCommand.aliases())
+        .join('|');
+      throw new Error(
+        `cannot add alias '${alias}' to command '${this.name()}' as already have command '${existingCmd}'`,
+      );
     }
 
     command._aliases.push(alias);
@@ -3199,11 +3454,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
       const args = this.registeredArguments.map((arg) => {
         return humanReadableArgName(arg);
       });
-      return [].concat(
-        (this.options.length || (this._helpOption !== null) ? '[options]' : []),
-        (this.commands.length ? '[command]' : []),
-        (this.registeredArguments.length ? args : [])
-      ).join(' ');
+      return []
+        .concat(
+          this.options.length || this._helpOption !== null ? '[options]' : [],
+          this.commands.length ? '[command]' : [],
+          this.registeredArguments.length ? args : [],
+        )
+        .join(' ');
     }
 
     this._usage = str;
@@ -3270,7 +3527,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
   helpInformation(contextOptions) {
     const helper = this.createHelp();
     if (helper.helpWidth === undefined) {
-      helper.helpWidth = (contextOptions && contextOptions.error) ? this._outputConfiguration.getErrHelpWidth() : this._outputConfiguration.getOutHelpWidth();
+      helper.helpWidth =
+        contextOptions && contextOptions.error
+          ? this._outputConfiguration.getErrHelpWidth()
+          : this._outputConfiguration.getOutHelpWidth();
     }
     return helper.formatHelp(this, helper);
   }
@@ -3309,13 +3569,18 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     const context = this._getHelpContext(contextOptions);
 
-    this._getCommandAndAncestors().reverse().forEach(command => command.emit('beforeAllHelp', context));
+    this._getCommandAndAncestors()
+      .reverse()
+      .forEach((command) => command.emit('beforeAllHelp', context));
     this.emit('beforeHelp', context);
 
     let helpInformation = this.helpInformation(context);
     if (deprecatedCallback) {
       helpInformation = deprecatedCallback(helpInformation);
-      if (typeof helpInformation !== 'string' && !Buffer.isBuffer(helpInformation)) {
+      if (
+        typeof helpInformation !== 'string' &&
+        !Buffer.isBuffer(helpInformation)
+      ) {
         throw new Error('outputHelp callback must return a string or a Buffer');
       }
     }
@@ -3325,7 +3590,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
       this.emit(this._getHelpOption().long); // deprecated
     }
     this.emit('afterHelp', context);
-    this._getCommandAndAncestors().forEach(command => command.emit('afterAllHelp', context));
+    this._getCommandAndAncestors().forEach((command) =>
+      command.emit('afterAllHelp', context),
+    );
   }
 
   /**
@@ -3365,7 +3632,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * Returns null if has been disabled with .helpOption(false).
    *
    * @returns {(Option | null)} the help option
-   * @package internal use only
+   * @package
    */
   _getHelpOption() {
     // Lazy create help option on demand.
@@ -3398,7 +3665,12 @@ Expecting one of '${allowedValues.join("', '")}'`);
   help(contextOptions) {
     this.outputHelp(contextOptions);
     let exitCode = process$2.exitCode || 0;
-    if (exitCode === 0 && contextOptions && typeof contextOptions !== 'function' && contextOptions.error) {
+    if (
+      exitCode === 0 &&
+      contextOptions &&
+      typeof contextOptions !== 'function' &&
+      contextOptions.error
+    ) {
       exitCode = 1;
     }
     // message: do not have all displayed text available so only passing placeholder.
@@ -3446,7 +3718,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
 
   _outputHelpIfRequested(args) {
     const helpOption = this._getHelpOption();
-    const helpRequested = helpOption && args.find(arg => helpOption.is(arg));
+    const helpRequested = helpOption && args.find((arg) => helpOption.is(arg));
     if (helpRequested) {
       this.outputHelp();
       // (Do not have all displayed text available so only passing placeholder.)
@@ -3479,7 +3751,9 @@ function incrementNodeInspectorPort(args) {
     if ((match = arg.match(/^(--inspect(-brk)?)$/)) !== null) {
       // e.g. --inspect
       debugOption = match[1];
-    } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+)$/)) !== null) {
+    } else if (
+      (match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+)$/)) !== null
+    ) {
       debugOption = match[1];
       if (/^\d+$/.test(match[3])) {
         // e.g. --inspect=1234
@@ -3488,7 +3762,9 @@ function incrementNodeInspectorPort(args) {
         // e.g. --inspect=localhost
         debugHost = match[3];
       }
-    } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+):(\d+)$/)) !== null) {
+    } else if (
+      (match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+):(\d+)$/)) !== null
+    ) {
       // e.g. --inspect=localhost:1234
       debugOption = match[1];
       debugHost = match[3];
@@ -3532,8 +3808,6 @@ commander.InvalidOptionArgumentError = InvalidArgumentError$1; // Deprecated
 (function (module, exports) {
 	const commander$1 = commander;
 
-	// @ts-check
-
 	exports = module.exports = {};
 
 	// Return a different global program than commander,
@@ -3556,8 +3830,10 @@ commander.InvalidOptionArgumentError = InvalidArgumentError$1; // Deprecated
 	// methods on the global program due to the (deprecated) legacy default export.
 	// Here we roll our own, the way Commander might in future.
 	exports.createCommand = (name) => new commander$1.Command(name);
-	exports.createOption = (flags, description) => new commander$1.Option(flags, description);
-	exports.createArgument = (name, description) => new commander$1.Argument(name, description); 
+	exports.createOption = (flags, description) =>
+	  new commander$1.Option(flags, description);
+	exports.createArgument = (name, description) =>
+	  new commander$1.Argument(name, description); 
 } (extraTypings, extraTypings.exports));
 
 var extraTypingsExports = extraTypings.exports;
@@ -3575,7 +3851,7 @@ const {
   Command,
   Argument,
   Option,
-  Help
+  Help,
 } = extraTypingsCommander;
 
 function isPlainObject(value) {
@@ -3820,7 +4096,7 @@ const parseExpression = expression => {
 		return getSubprocessResult(expression);
 	}
 
-	if (expression instanceof node_child_process.ChildProcess || Object.prototype.toString.call(expression) === '[object Promise]') {
+	if (expression instanceof require$$1.ChildProcess || Object.prototype.toString.call(expression) === '[object Promise]') {
 		// eslint-disable-next-line no-template-curly-in-string
 		throw new TypeError('Unexpected subprocess in template expression. Please use ${await subprocess} instead of ${subprocess}.');
 	}
@@ -4441,7 +4717,7 @@ function requireWindows () {
 	windows = isexe;
 	isexe.sync = sync;
 
-	var fs = require$$0$2;
+	var fs = require$$0$1;
 
 	function checkPathExt (path, options) {
 	  var pathext = options.pathExt !== undefined ?
@@ -4492,7 +4768,7 @@ function requireMode () {
 	mode = isexe;
 	isexe.sync = sync;
 
-	var fs = require$$0$2;
+	var fs = require$$0$1;
 
 	function isexe (path, options, cb) {
 	  fs.stat(path, function (er, stat) {
@@ -4594,7 +4870,7 @@ const isWindows = process.platform === 'win32' ||
     process.env.OSTYPE === 'cygwin' ||
     process.env.OSTYPE === 'msys';
 
-const path$q = require$$0$1;
+const path$q = require$$0$2;
 const COLON = isWindows ? ';' : ':';
 const isexe = isexe_1;
 
@@ -4735,7 +5011,7 @@ pathKey$2.exports.default = pathKey$1;
 
 var pathKeyExports = pathKey$2.exports;
 
-const path$p = require$$0$1;
+const path$p = require$$0$2;
 const which = which_1;
 const getPathKey = pathKeyExports;
 
@@ -4853,7 +5129,7 @@ var shebangCommand$1 = (string = '') => {
 	return argument ? `${binary} ${argument}` : binary;
 };
 
-const fs$t = require$$0$2;
+const fs$t = require$$0$1;
 const shebangCommand = shebangCommand$1;
 
 function readShebang$1(command) {
@@ -4875,7 +5151,7 @@ function readShebang$1(command) {
 
 var readShebang_1 = readShebang$1;
 
-const path$o = require$$0$1;
+const path$o = require$$0$2;
 const resolveCommand = resolveCommand_1;
 const escape = _escape;
 const readShebang = readShebang_1;
@@ -5023,7 +5299,7 @@ var enoent$1 = {
     notFoundError,
 };
 
-const cp = require$$1;
+const cp = require$$0$3;
 const parse$5 = parse_1$3;
 const enoent = enoent$1;
 
@@ -8691,8 +8967,8 @@ const getAllSync = ([, stdout, stderr], options) => {
 //  - `error` being emitted multiple times
 const waitForExit = async subprocess => {
 	const [spawnPayload, exitPayload] = await Promise.allSettled([
-		node_events.once(subprocess, 'spawn'),
-		node_events.once(subprocess, 'exit'),
+		require$$0.once(subprocess, 'spawn'),
+		require$$0.once(subprocess, 'exit'),
 	]);
 
 	if (spawnPayload.status === 'rejected') {
@@ -8706,7 +8982,7 @@ const waitForExit = async subprocess => {
 
 const waitForSubprocessExit = async subprocess => {
 	try {
-		return await node_events.once(subprocess, 'exit');
+		return await require$$0.once(subprocess, 'exit');
 	} catch {
 		return waitForSubprocessExit(subprocess);
 	}
@@ -8856,7 +9132,7 @@ const runSubprocessSync = ({file, commandArguments, options, command, escapedCom
 	try {
 		addInputOptionsSync(fileDescriptors, options);
 		const normalizedOptions = normalizeSpawnSyncOptions(options);
-		return node_child_process.spawnSync(file, commandArguments, normalizedOptions);
+		return require$$1.spawnSync(file, commandArguments, normalizedOptions);
 	} catch (error) {
 		return makeEarlyError({
 			error,
@@ -8903,7 +9179,7 @@ const getSyncResult = ({error, exitCode, signal, timedOut, isMaxBuffer, stdio, a
 const handleEarlyError = ({error, command, escapedCommand, fileDescriptors, options, startTime, verboseInfo}) => {
 	cleanupCustomStreams(fileDescriptors);
 
-	const subprocess = new node_child_process.ChildProcess();
+	const subprocess = new require$$1.ChildProcess();
 	createDummyStreams(subprocess, fileDescriptors);
 	Object.assign(subprocess, {readable, writable, duplex});
 
@@ -9106,7 +9382,7 @@ const onMergedStreamEnd = async (passThroughStream, {signal}) => {
 };
 
 const onInputStreamsUnpipe = async (passThroughStream, streams, unpipeEvent, {signal}) => {
-	for await (const [unpipedStream] of node_events.on(passThroughStream, 'unpipe', {signal})) {
+	for await (const [unpipedStream] of require$$0.on(passThroughStream, 'unpipe', {signal})) {
 		if (streams.has(unpipedStream)) {
 			unpipedStream.emit(unpipeEvent);
 		}
@@ -9195,10 +9471,10 @@ const onInputStreamEnd = async ({passThroughStream, stream, streams, ended, abor
 };
 
 const onInputStreamUnpipe = async ({stream, streams, ended, aborted, unpipeEvent, controller: {signal}}) => {
-	await node_events.once(stream, unpipeEvent, {signal});
+	await require$$0.once(stream, unpipeEvent, {signal});
 
 	if (!stream.readable) {
-		return node_events.once(signal, 'abort', {signal});
+		return require$$0.once(signal, 'abort', {signal});
 	}
 
 	streams.delete(stream);
@@ -9264,7 +9540,7 @@ const incrementMaxListeners = (eventEmitter, maxListenersIncrement, signal) => {
 	}
 
 	eventEmitter.setMaxListeners(maxListeners + maxListenersIncrement);
-	node_events.addAbortListener(signal, () => {
+	require$$0.addAbortListener(signal, () => {
 		eventEmitter.setMaxListeners(eventEmitter.getMaxListeners() - maxListenersIncrement);
 	});
 };
@@ -9711,7 +9987,7 @@ const cleanupOnExit = (subprocess, {cleanup, detached}, {signal}) => {
 	const removeExitHandler = onExit(() => {
 		subprocess.kill();
 	});
-	node_events.addAbortListener(signal, () => {
+	require$$0.addAbortListener(signal, () => {
 		removeExitHandler();
 	});
 };
@@ -10066,7 +10342,7 @@ const stopReadingOnStreamEnd = async (onStreamEnd, controller, stream) => {
 };
 
 const iterateOnStream = ({stream, controller, binary, shouldEncode, encoding, shouldSplit, preserveNewlines}) => {
-	const onStdoutChunk = node_events.on(stream, 'data', {
+	const onStdoutChunk = require$$0.on(stream, 'data', {
 		signal: controller.signal,
 		highWaterMark: HIGH_WATER_MARK,
 		// Backward compatibility with older name for this option
@@ -10483,7 +10759,7 @@ const waitForCustomStreamsEnd = (fileDescriptors, streamInfo) => fileDescriptors
 
 // Fails when the subprocess emits an `error` event
 const throwOnSubprocessError = async (subprocess, {signal}) => {
-	const [error] = await node_events.once(subprocess, 'error', {signal});
+	const [error] = await require$$0.once(subprocess, 'error', {signal});
 	throw error;
 };
 
@@ -10922,7 +11198,7 @@ const handleAsyncOptions = ({timeout, signal, cancelSignal, ...options}) => {
 const spawnSubprocessAsync = ({file, commandArguments, options, startTime, verboseInfo, command, escapedCommand, fileDescriptors}) => {
 	let subprocess;
 	try {
-		subprocess = node_child_process.spawn(file, commandArguments, options);
+		subprocess = require$$1.spawn(file, commandArguments, options);
 	} catch (error) {
 		return handleEarlyError({
 			error,
@@ -10936,7 +11212,7 @@ const spawnSubprocessAsync = ({file, commandArguments, options, startTime, verbo
 	}
 
 	const controller = new AbortController();
-	node_events.setMaxListeners(Number.POSITIVE_INFINITY, controller.signal);
+	require$$0.setMaxListeners(Number.POSITIVE_INFINITY, controller.signal);
 
 	const originalStreams = [...subprocess.stdio];
 	pipeOutputAsync(subprocess, fileDescriptors, controller);
@@ -28398,7 +28674,7 @@ universalify$1.fromPromise = function (fn) {
   }, 'name', { value: fn.name })
 };
 
-var constants$5 = require$$0$3;
+var constants$5 = require$$0$4;
 
 var origCwd = process.cwd;
 var cwd = null;
@@ -28754,7 +29030,7 @@ function patch$1 (fs) {
   }
 }
 
-var Stream$1 = require$$0$4.Stream;
+var Stream$1 = require$$0$5.Stream;
 
 var legacyStreams = legacy$1;
 
@@ -28895,12 +29171,12 @@ function clone$1 (obj) {
   return copy
 }
 
-var fs$r = require$$0$2;
+var fs$r = require$$0$1;
 var polyfills = polyfills$1;
 var legacy = legacyStreams;
 var clone = clone_1;
 
-var util$2 = require$$0$5;
+var util$2 = require$$0$6;
 
 /* istanbul ignore next - node 0.x polyfill */
 var gracefulQueue;
@@ -29490,7 +29766,7 @@ var makeDir$1 = {};
 
 var utils$m = {};
 
-const path$n = require$$0$1;
+const path$n = require$$0$2;
 
 // https://github.com/nodejs/node/issues/8987
 // https://github.com/libuv/libuv/pull/1088
@@ -29595,7 +29871,7 @@ var utimes = {
 };
 
 const fs$n = fs$s;
-const path$m = require$$0$1;
+const path$m = require$$0$2;
 const u$b = universalify$1.fromPromise;
 
 function getStats$1 (src, dest, opts) {
@@ -29752,7 +30028,7 @@ var stat$5 = {
 };
 
 const fs$m = fs$s;
-const path$l = require$$0$1;
+const path$l = require$$0$2;
 const { mkdirs: mkdirs$1 } = mkdirs$2;
 const { pathExists: pathExists$5 } = pathExists_1;
 const { utimesMillis } = utimes;
@@ -29928,7 +30204,7 @@ async function onLink$1 (destStat, src, dest, opts) {
 var copy_1 = copy$2;
 
 const fs$l = gracefulFs;
-const path$k = require$$0$1;
+const path$k = require$$0$2;
 const mkdirsSync$1 = mkdirs$2.mkdirsSync;
 const utimesMillisSync = utimes.utimesMillisSync;
 const stat$3 = stat$5;
@@ -30111,7 +30387,7 @@ var remove_1 = {
 
 const u$8 = universalify$1.fromPromise;
 const fs$j = fs$s;
-const path$j = require$$0$1;
+const path$j = require$$0$2;
 const mkdir$3 = mkdirs$2;
 const remove$1 = remove_1;
 
@@ -30148,7 +30424,7 @@ var empty = {
 };
 
 const u$7 = universalify$1.fromPromise;
-const path$i = require$$0$1;
+const path$i = require$$0$2;
 const fs$i = fs$s;
 const mkdir$2 = mkdirs$2;
 
@@ -30213,7 +30489,7 @@ var file = {
 };
 
 const u$6 = universalify$1.fromPromise;
-const path$h = require$$0$1;
+const path$h = require$$0$2;
 const fs$h = fs$s;
 const mkdir$1 = mkdirs$2;
 const { pathExists: pathExists$4 } = pathExists_1;
@@ -30275,7 +30551,7 @@ var link = {
   createLinkSync: createLinkSync$1
 };
 
-const path$g = require$$0$1;
+const path$g = require$$0$2;
 const fs$g = fs$s;
 const { pathExists: pathExists$3 } = pathExists_1;
 
@@ -30409,7 +30685,7 @@ var symlinkType_1 = {
 };
 
 const u$3 = universalify$1.fromPromise;
-const path$f = require$$0$1;
+const path$f = require$$0$2;
 const fs$e = fs$s;
 
 const { mkdirs, mkdirsSync } = mkdirs$2;
@@ -30515,7 +30791,7 @@ let _fs;
 try {
   _fs = gracefulFs;
 } catch (_) {
-  _fs = require$$0$2;
+  _fs = require$$0$1;
 }
 const universalify = universalify$1;
 const { stringify: stringify$7, stripBom } = utils$l;
@@ -30612,7 +30888,7 @@ var jsonfile = {
 
 const u$2 = universalify$1.fromPromise;
 const fs$d = fs$s;
-const path$e = require$$0$1;
+const path$e = require$$0$2;
 const mkdir = mkdirs$2;
 const pathExists$1 = pathExists_1.pathExists;
 
@@ -30678,7 +30954,7 @@ jsonFile.readJSONSync = jsonFile.readJsonSync;
 var json = jsonFile;
 
 const fs$c = fs$s;
-const path$d = require$$0$1;
+const path$d = require$$0$2;
 const { copy } = copy$1;
 const { remove } = remove_1;
 const { mkdirp } = mkdirs$2;
@@ -30736,7 +31012,7 @@ async function moveAcrossDevice$1 (src, dest, overwrite) {
 var move_1 = move$1;
 
 const fs$b = gracefulFs;
-const path$c = require$$0$1;
+const path$c = require$$0$2;
 const copySync = copy$1.copySync;
 const removeSync = remove_1.removeSync;
 const mkdirpSync = mkdirs$2.mkdirpSync;
@@ -30906,7 +31182,7 @@ const getDotenvCliOptions2Options = ({ paths, pathsDelimiter, pathsDelimiterPatt
 const resolveGetDotenvOptions = async (customOptions) => {
     const localPkgDir = await packageDirectory();
     const localOptionsPath = localPkgDir
-        ? require$$0$1.join(localPkgDir, getDotenvOptionsFilename)
+        ? require$$0$2.join(localPkgDir, getDotenvOptionsFilename)
         : undefined;
     const localOptions = (localOptionsPath && (await fs$a.exists(localOptionsPath))
         ? JSON.parse((await fs$a.readFile(localOptionsPath)).toString())
@@ -31001,8 +31277,8 @@ var require$$4 = {
 	browser: browser
 };
 
-const fs$9 = require$$0$2;
-const path$b = require$$0$1;
+const fs$9 = require$$0$1;
+const path$b = require$$0$2;
 const os$1 = require$$2;
 const crypto = require$$3;
 const packageJson = require$$4;
@@ -31392,16 +31668,16 @@ const getDotenv = async (options = {}) => {
         ? await paths.reduce(async (e, p) => {
             const publicGlobal = excludePublic || excludeGlobal
                 ? Promise.resolve({})
-                : readDotenv(require$$0$1.resolve(p, dotenvToken));
+                : readDotenv(require$$0$2.resolve(p, dotenvToken));
             const publicEnv = excludePublic || excludeEnv || (!env && !defaultEnv)
                 ? Promise.resolve({})
-                : readDotenv(require$$0$1.resolve(p, `${dotenvToken}.${env ?? defaultEnv ?? ''}`));
+                : readDotenv(require$$0$2.resolve(p, `${dotenvToken}.${env ?? defaultEnv ?? ''}`));
             const privateGlobal = excludePrivate || excludeGlobal
                 ? Promise.resolve({})
-                : readDotenv(require$$0$1.resolve(p, `${dotenvToken}.${privateToken}`));
+                : readDotenv(require$$0$2.resolve(p, `${dotenvToken}.${privateToken}`));
             const privateEnv = excludePrivate || excludeEnv || (!env && !defaultEnv)
                 ? Promise.resolve({})
-                : readDotenv(require$$0$1.resolve(p, `${dotenvToken}.${env ?? defaultEnv ?? ''}.${privateToken}`));
+                : readDotenv(require$$0$2.resolve(p, `${dotenvToken}.${env ?? defaultEnv ?? ''}.${privateToken}`));
             const [eResolved, publicGlobalResolved, publicEnvResolved, privateGlobalResolved, privateEnvResolved,] = await Promise.all([
                 e,
                 publicGlobal,
@@ -31426,7 +31702,7 @@ const getDotenv = async (options = {}) => {
     }, { progressive: true });
     // Process dynamic variables.
     if (dynamicPath && !excludeDynamic) {
-        const absDynamicPath = require$$0$1.resolve(dynamicPath);
+        const absDynamicPath = require$$0$2.resolve(dynamicPath);
         if (await fs$a.exists(absDynamicPath)) {
             try {
                 const { default: dynamic } = (await import(url.pathToFileURL(absDynamicPath).toString()));
@@ -31470,7 +31746,7 @@ const getDotenv = async (options = {}) => {
  * Copyright (c) 2014-2020 Teambition
  * Licensed under the MIT license.
  */
-const Stream = require$$0$4;
+const Stream = require$$0$5;
 const PassThrough = Stream.PassThrough;
 const slice = Array.prototype.slice;
 
@@ -31670,7 +31946,7 @@ var path$a = {};
 Object.defineProperty(path$a, "__esModule", { value: true });
 path$a.convertPosixPathToPattern = path$a.convertWindowsPathToPattern = path$a.convertPathToPattern = path$a.escapePosixPath = path$a.escapeWindowsPath = path$a.escape = path$a.removeLeadingDotSegment = path$a.makeAbsolute = path$a.unixify = void 0;
 const os = require$$2;
-const path$9 = require$$0$1;
+const path$9 = require$$0$2;
 const IS_WINDOWS_PLATFORM = os.platform() === 'win32';
 const LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2; // ./ or .\\
 /**
@@ -31910,7 +32186,7 @@ var isGlob$1 = function isGlob(str, options) {
 };
 
 var isGlob = isGlob$1;
-var pathPosixDirname = require$$0$1.posix.dirname;
+var pathPosixDirname = require$$0$2.posix.dirname;
 var isWin32 = require$$2.platform() === 'win32';
 
 var slash$1 = '/';
@@ -32407,7 +32683,7 @@ var toRegexRange_1 = toRegexRange$1;
  * Licensed under the MIT License.
  */
 
-const util$1 = require$$0$5;
+const util$1 = require$$0$6;
 const toRegexRange = toRegexRange_1;
 
 const isObject$1 = val => val !== null && typeof val === 'object' && !Array.isArray(val);
@@ -33372,7 +33648,7 @@ var braces_1 = braces$1;
 
 var utils$f = {};
 
-const path$8 = require$$0$1;
+const path$8 = require$$0$2;
 const WIN_SLASH = '\\\\/';
 const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
 
@@ -33552,7 +33828,7 @@ var constants$3 = {
 
 (function (exports) {
 
-	const path = require$$0$1;
+	const path = require$$0$2;
 	const win32 = process.platform === 'win32';
 	const {
 	  REGEX_BACKSLASH,
@@ -35096,7 +35372,7 @@ parse$1.fastpaths = (input, options) => {
 
 var parse_1 = parse$1;
 
-const path$7 = require$$0$1;
+const path$7 = require$$0$2;
 const scan = scan_1;
 const parse = parse_1;
 const utils$c = utils$f;
@@ -35439,7 +35715,7 @@ var picomatch_1 = picomatch$2;
 
 var picomatch$1 = picomatch_1;
 
-const util = require$$0$5;
+const util = require$$0$6;
 const braces = braces_1;
 const picomatch = picomatch$1;
 const utils$b = utils$f;
@@ -35907,7 +36183,7 @@ var micromatch_1 = micromatch$1;
 
 Object.defineProperty(pattern$1, "__esModule", { value: true });
 pattern$1.removeDuplicateSlashes = pattern$1.matchAny = pattern$1.convertPatternsToRe = pattern$1.makeRe = pattern$1.getPatternParts = pattern$1.expandBraceExpansion = pattern$1.expandPatternsWithBraceExpansion = pattern$1.isAffectDepthOfReadingPattern = pattern$1.endsWithSlashGlobStar = pattern$1.hasGlobStar = pattern$1.getBaseDirectory = pattern$1.isPatternRelatedToParentDirectory = pattern$1.getPatternsOutsideCurrentDirectory = pattern$1.getPatternsInsideCurrentDirectory = pattern$1.getPositivePatterns = pattern$1.getNegativePatterns = pattern$1.isPositivePattern = pattern$1.isNegativePattern = pattern$1.convertToNegativePattern = pattern$1.convertToPositivePattern = pattern$1.isDynamicPattern = pattern$1.isStaticPattern = void 0;
-const path$6 = require$$0$1;
+const path$6 = require$$0$2;
 const globParent = globParent$1;
 const micromatch = micromatch_1;
 const GLOBSTAR = '**';
@@ -36338,7 +36614,7 @@ var fs$6 = {};
 (function (exports) {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
-	const fs = require$$0$2;
+	const fs = require$$0$1;
 	exports.FILE_SYSTEM_ADAPTER = {
 	    lstat: fs.lstat,
 	    stat: fs.stat,
@@ -36689,7 +36965,7 @@ var fs$2 = {};
 (function (exports) {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
-	const fs = require$$0$2;
+	const fs = require$$0$1;
 	exports.FILE_SYSTEM_ADAPTER = {
 	    lstat: fs.lstat,
 	    stat: fs.stat,
@@ -36708,7 +36984,7 @@ var fs$2 = {};
 } (fs$2));
 
 Object.defineProperty(settings$2, "__esModule", { value: true });
-const path$4 = require$$0$1;
+const path$4 = require$$0$2;
 const fsStat$3 = out$1;
 const fs$1 = fs$2;
 let Settings$1 = class Settings {
@@ -37150,7 +37426,7 @@ let Reader$1 = class Reader {
 reader$1.default = Reader$1;
 
 Object.defineProperty(async$4, "__esModule", { value: true });
-const events_1 = require$$0;
+const events_1 = require$$0$7;
 const fsScandir$2 = out$2;
 const fastq = queueExports;
 const common$1 = common$3;
@@ -37279,7 +37555,7 @@ function callSuccessCallback(callback, entries) {
 var stream$2 = {};
 
 Object.defineProperty(stream$2, "__esModule", { value: true });
-const stream_1$5 = require$$0$4;
+const stream_1$5 = require$$0$5;
 const async_1$3 = async$4;
 class StreamProvider {
     constructor(_root, _settings) {
@@ -37392,7 +37668,7 @@ sync$3.default = SyncProvider;
 var settings$1 = {};
 
 Object.defineProperty(settings$1, "__esModule", { value: true });
-const path$3 = require$$0$1;
+const path$3 = require$$0$2;
 const fsScandir = out$2;
 class Settings {
     constructor(_options = {}) {
@@ -37454,7 +37730,7 @@ function getSettings(settingsOrOptions = {}) {
 var reader = {};
 
 Object.defineProperty(reader, "__esModule", { value: true });
-const path$2 = require$$0$1;
+const path$2 = require$$0$2;
 const fsStat$2 = out$1;
 const utils$6 = utils$k;
 class Reader {
@@ -37489,7 +37765,7 @@ reader.default = Reader;
 var stream$1 = {};
 
 Object.defineProperty(stream$1, "__esModule", { value: true });
-const stream_1$3 = require$$0$4;
+const stream_1$3 = require$$0$5;
 const fsStat$1 = out$1;
 const fsWalk$2 = out$3;
 const reader_1$2 = reader;
@@ -37842,7 +38118,7 @@ class EntryTransformer {
 entry.default = EntryTransformer;
 
 Object.defineProperty(provider, "__esModule", { value: true });
-const path$1 = require$$0$1;
+const path$1 = require$$0$2;
 const deep_1 = deep;
 const entry_1 = entry$1;
 const error_1 = error;
@@ -37915,7 +38191,7 @@ async$7.default = ProviderAsync;
 var stream = {};
 
 Object.defineProperty(stream, "__esModule", { value: true });
-const stream_1$1 = require$$0$4;
+const stream_1$1 = require$$0$5;
 const stream_2 = stream$1;
 const provider_1$1 = provider;
 class ProviderStream extends provider_1$1.default {
@@ -38020,7 +38296,7 @@ var settings = {};
 (function (exports) {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
-	const fs = require$$0$2;
+	const fs = require$$0$1;
 	const os = require$$2;
 	/**
 	 * The `os.cpus` method can return zero. We expect the number of cores to be greater than zero.
@@ -38184,8 +38460,8 @@ var dirGlob$1 = {exports: {}};
 
 var pathType$1 = {};
 
-const {promisify} = require$$0$5;
-const fs = require$$0$2;
+const {promisify} = require$$0$6;
+const fs = require$$0$1;
 
 async function isType(fsStatType, statsMethodName, filePath) {
 	if (typeof filePath !== 'string') {
@@ -38227,7 +38503,7 @@ pathType$1.isFileSync = isTypeSync.bind(null, 'statSync', 'isFile');
 pathType$1.isDirectorySync = isTypeSync.bind(null, 'statSync', 'isDirectory');
 pathType$1.isSymlinkSync = isTypeSync.bind(null, 'lstatSync', 'isSymbolicLink');
 
-const path = require$$0$1;
+const path = require$$0$2;
 const pathType = pathType$1;
 
 const getExtensions = extensions => extensions.length > 1 ? `{${extensions.join(',')}}` : extensions[0];
@@ -39191,7 +39467,7 @@ const globPaths = async ({ globs, logger, pkgCwd, rootPath, }) => {
         }
         cwd = pkgDir;
     }
-    const absRootPath = require$$0$1.posix.join(cwd.split(require$$0$1.sep).join(require$$0$1.posix.sep), rootPath.split(require$$0$1.sep).join(require$$0$1.posix.sep));
+    const absRootPath = require$$0$2.posix.join(cwd.split(require$$0$2.sep).join(require$$0$2.posix.sep), rootPath.split(require$$0$2.sep).join(require$$0$2.posix.sep));
     const paths = await globby(globs.split(/\s+/), {
         cwd: absRootPath,
         expandDirectories: false,
@@ -39354,14 +39630,14 @@ const resolveGetDotenvCliGenerateOptions = async ({ importMetaUrl, ...customOpti
         })
         : undefined;
     const globalOptionsPath = globalPkgDir
-        ? require$$0$1.join(globalPkgDir, getDotenvOptionsFilename)
+        ? require$$0$2.join(globalPkgDir, getDotenvOptionsFilename)
         : undefined;
     const globalOptions = (globalOptionsPath && (await fs$a.exists(globalOptionsPath))
         ? JSON.parse((await fs$a.readFile(globalOptionsPath)).toString())
         : {});
     const localPkgDir = await packageDirectory();
     const localOptionsPath = localPkgDir
-        ? require$$0$1.join(localPkgDir, getDotenvOptionsFilename)
+        ? require$$0$2.join(localPkgDir, getDotenvOptionsFilename)
         : undefined;
     const localOptions = (localOptionsPath &&
         localOptionsPath !== globalOptionsPath &&