mathjs 10.5.0 → 10.5.3

package/examples/node_modules/webpack-cli/lib/webpack-cli.js

@@ -1,2343 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-const { pathToFileURL } = require("url");
-const util = require("util");
-
-const { program, Option } = require("commander");
-
-const WEBPACK_PACKAGE = process.env.WEBPACK_PACKAGE || "webpack";
-const WEBPACK_DEV_SERVER_PACKAGE = process.env.WEBPACK_DEV_SERVER_PACKAGE || "webpack-dev-server";
-
-class WebpackCLI {
-  constructor() {
-    this.colors = this.createColors();
-    this.logger = this.getLogger();
-
-    // Initialize program
-    this.program = program;
-    this.program.name("webpack");
-    this.program.configureOutput({
-      writeErr: this.logger.error,
-      outputError: (str, write) =>
-        write(`Error: ${this.capitalizeFirstLetter(str.replace(/^error:/, "").trim())}`),
-    });
-  }
-
-  capitalizeFirstLetter(str) {
-    if (typeof str !== "string") {
-      return "";
-    }
-
-    return str.charAt(0).toUpperCase() + str.slice(1);
-  }
-
-  toKebabCase(str) {
-    return str.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
-  }
-
-  createColors(useColor) {
-    const { createColors, isColorSupported } = require("colorette");
-
-    let shouldUseColor;
-
-    if (useColor) {
-      shouldUseColor = useColor;
-    } else {
-      shouldUseColor = isColorSupported;
-    }
-
-    return { ...createColors({ useColor: shouldUseColor }), isColorSupported: shouldUseColor };
-  }
-
-  getLogger() {
-    return {
-      error: (val) => console.error(`[webpack-cli] ${this.colors.red(util.format(val))}`),
-      warn: (val) => console.warn(`[webpack-cli] ${this.colors.yellow(val)}`),
-      info: (val) => console.info(`[webpack-cli] ${this.colors.cyan(val)}`),
-      success: (val) => console.log(`[webpack-cli] ${this.colors.green(val)}`),
-      log: (val) => console.log(`[webpack-cli] ${val}`),
-      raw: (val) => console.log(val),
-    };
-  }
-
-  checkPackageExists(packageName) {
-    if (process.versions.pnp) {
-      return true;
-    }
-
-    let dir = __dirname;
-
-    do {
-      try {
-        if (fs.statSync(path.join(dir, "node_modules", packageName)).isDirectory()) {
-          return true;
-        }
-      } catch (_error) {
-        // Nothing
-      }
-    } while (dir !== (dir = path.dirname(dir)));
-
-    return false;
-  }
-
-  getAvailablePackageManagers() {
-    const { sync } = require("execa");
-    const installers = ["npm", "yarn", "pnpm"];
-    const hasPackageManagerInstalled = (packageManager) => {
-      try {
-        sync(packageManager, ["--version"]);
-
-        return packageManager;
-      } catch (err) {
-        return false;
-      }
-    };
-    const availableInstallers = installers.filter((installer) =>
-      hasPackageManagerInstalled(installer),
-    );
-
-    if (!availableInstallers.length) {
-      this.logger.error("No package manager found.");
-
-      process.exit(2);
-    }
-
-    return availableInstallers;
-  }
-
-  getDefaultPackageManager() {
-    const { sync } = require("execa");
-    const hasLocalNpm = fs.existsSync(path.resolve(process.cwd(), "package-lock.json"));
-
-    if (hasLocalNpm) {
-      return "npm";
-    }
-
-    const hasLocalYarn = fs.existsSync(path.resolve(process.cwd(), "yarn.lock"));
-
-    if (hasLocalYarn) {
-      return "yarn";
-    }
-
-    const hasLocalPnpm = fs.existsSync(path.resolve(process.cwd(), "pnpm-lock.yaml"));
-
-    if (hasLocalPnpm) {
-      return "pnpm";
-    }
-
-    try {
-      // the sync function below will fail if npm is not installed,
-      // an error will be thrown
-      if (sync("npm", ["--version"])) {
-        return "npm";
-      }
-    } catch (e) {
-      // Nothing
-    }
-
-    try {
-      // the sync function below will fail if yarn is not installed,
-      // an error will be thrown
-      if (sync("yarn", ["--version"])) {
-        return "yarn";
-      }
-    } catch (e) {
-      // Nothing
-    }
-
-    try {
-      // the sync function below will fail if pnpm is not installed,
-      // an error will be thrown
-      if (sync("pnpm", ["--version"])) {
-        return "pnpm";
-      }
-    } catch (e) {
-      this.logger.error("No package manager found.");
-
-      process.exit(2);
-    }
-  }
-
-  async doInstall(packageName, options = {}) {
-    const packageManager = this.getDefaultPackageManager();
-
-    if (!packageManager) {
-      this.logger.error("Can't find package manager");
-
-      process.exit(2);
-    }
-
-    if (options.preMessage) {
-      options.preMessage();
-    }
-
-    // yarn uses 'add' command, rest npm and pnpm both use 'install'
-    const commandToBeRun = `${packageManager} ${[
-      packageManager === "yarn" ? "add" : "install",
-      "-D",
-      packageName,
-    ].join(" ")}`;
-
-    const prompt = ({ message, defaultResponse, stream }) => {
-      const readline = require("readline");
-      const rl = readline.createInterface({
-        input: process.stdin,
-        output: stream,
-      });
-
-      return new Promise((resolve) => {
-        rl.question(`${message} `, (answer) => {
-          // Close the stream
-          rl.close();
-
-          const response = (answer || defaultResponse).toLowerCase();
-
-          // Resolve with the input response
-          if (response === "y" || response === "yes") {
-            resolve(true);
-          } else {
-            resolve(false);
-          }
-        });
-      });
-    };
-
-    let needInstall;
-
-    try {
-      needInstall = await prompt({
-        message: `[webpack-cli] Would you like to install '${this.colors.green(
-          packageName,
-        )}' package? (That will run '${this.colors.green(commandToBeRun)}') (${this.colors.yellow(
-          "Y/n",
-        )})`,
-        defaultResponse: "Y",
-        stream: process.stderr,
-      });
-    } catch (error) {
-      this.logger.error(error);
-
-      process.exit(error);
-    }
-
-    if (needInstall) {
-      const execa = require("execa");
-
-      try {
-        await execa(commandToBeRun, [], { stdio: "inherit", shell: true });
-      } catch (error) {
-        this.logger.error(error);
-
-        process.exit(2);
-      }
-
-      return packageName;
-    }
-
-    process.exit(2);
-  }
-
-  async tryRequireThenImport(module, handleError = true) {
-    let result;
-
-    try {
-      result = require(module);
-    } catch (error) {
-      const dynamicImportLoader = require("./utils/dynamic-import-loader")();
-      if (
-        (error.code === "ERR_REQUIRE_ESM" || process.env.WEBPACK_CLI_FORCE_LOAD_ESM_CONFIG) &&
-        pathToFileURL &&
-        dynamicImportLoader
-      ) {
-        const urlForConfig = pathToFileURL(module);
-
-        result = await dynamicImportLoader(urlForConfig);
-        result = result.default;
-
-        return result;
-      }
-
-      if (handleError) {
-        this.logger.error(error);
-        process.exit(2);
-      } else {
-        throw error;
-      }
-    }
-
-    // For babel/typescript
-    if (result && typeof result === "object" && "default" in result) {
-      result = result.default || {};
-    }
-
-    return result || {};
-  }
-
-  loadJSONFile(pathToFile, handleError = true) {
-    let result;
-
-    try {
-      result = require(pathToFile);
-    } catch (error) {
-      if (handleError) {
-        this.logger.error(error);
-        process.exit(2);
-      } else {
-        throw error;
-      }
-    }
-
-    return result;
-  }
-
-  async makeCommand(commandOptions, options, action) {
-    const alreadyLoaded = this.program.commands.find(
-      (command) =>
-        command.name() === commandOptions.name.split(" ")[0] ||
-        command.aliases().includes(commandOptions.alias),
-    );
-
-    if (alreadyLoaded) {
-      return;
-    }
-
-    const command = this.program.command(commandOptions.name, {
-      noHelp: commandOptions.noHelp,
-      hidden: commandOptions.hidden,
-      isDefault: commandOptions.isDefault,
-    });
-
-    if (commandOptions.description) {
-      command.description(commandOptions.description, commandOptions.argsDescription);
-    }
-
-    if (commandOptions.usage) {
-      command.usage(commandOptions.usage);
-    }
-
-    if (Array.isArray(commandOptions.alias)) {
-      command.aliases(commandOptions.alias);
-    } else {
-      command.alias(commandOptions.alias);
-    }
-
-    if (commandOptions.pkg) {
-      command.pkg = commandOptions.pkg;
-    } else {
-      command.pkg = "webpack-cli";
-    }
-
-    const { forHelp } = this.program;
-
-    let allDependenciesInstalled = true;
-
-    if (commandOptions.dependencies && commandOptions.dependencies.length > 0) {
-      for (const dependency of commandOptions.dependencies) {
-        const isPkgExist = this.checkPackageExists(dependency);
-
-        if (isPkgExist) {
-          continue;
-        } else if (!isPkgExist && forHelp) {
-          allDependenciesInstalled = false;
-          continue;
-        }
-
-        let skipInstallation = false;
-
-        // Allow to use `./path/to/webpack.js` outside `node_modules`
-        if (dependency === WEBPACK_PACKAGE && fs.existsSync(WEBPACK_PACKAGE)) {
-          skipInstallation = true;
-        }
-
-        // Allow to use `./path/to/webpack-dev-server.js` outside `node_modules`
-        if (dependency === WEBPACK_DEV_SERVER_PACKAGE && fs.existsSync(WEBPACK_PACKAGE)) {
-          skipInstallation = true;
-        }
-
-        if (skipInstallation) {
-          continue;
-        }
-
-        await this.doInstall(dependency, {
-          preMessage: () => {
-            this.logger.error(
-              `For using '${this.colors.green(
-                commandOptions.name.split(" ")[0],
-              )}' command you need to install: '${this.colors.green(dependency)}' package.`,
-            );
-          },
-        });
-      }
-    }
-
-    if (options) {
-      if (typeof options === "function") {
-        if (forHelp && !allDependenciesInstalled) {
-          command.description(
-            `${
-              commandOptions.description
-            } To see all available options you need to install ${commandOptions.dependencies
-              .map((dependency) => `'${dependency}'`)
-              .join(", ")}.`,
-          );
-          options = [];
-        } else {
-          options = await options();
-        }
-      }
-
-      options.forEach((optionForCommand) => {
-        this.makeOption(command, optionForCommand);
-      });
-    }
-
-    command.action(action);
-
-    return command;
-  }
-
-  makeOption(command, option) {
-    let mainOption;
-    let negativeOption;
-
-    if (option.configs) {
-      let needNegativeOption = false;
-      let negatedDescription;
-      const mainOptionType = new Set();
-
-      option.configs.forEach((config) => {
-        // Possible value: "enum" | "string" | "path" | "number" | "boolean" | "RegExp" | "reset"
-        switch (config.type) {
-          case "reset":
-            mainOptionType.add(Boolean);
-            break;
-          case "boolean":
-            if (!needNegativeOption) {
-              needNegativeOption = true;
-              negatedDescription = config.negatedDescription;
-            }
-
-            mainOptionType.add(Boolean);
-            break;
-          case "number":
-            mainOptionType.add(Number);
-            break;
-          case "string":
-          case "path":
-          case "RegExp":
-            mainOptionType.add(String);
-            break;
-          case "enum": {
-            let hasFalseEnum = false;
-
-            const enumTypes = config.values.map((value) => {
-              switch (typeof value) {
-                case "string":
-                  mainOptionType.add(String);
-                  break;
-                case "number":
-                  mainOptionType.add(Number);
-                  break;
-                case "boolean":
-                  if (!hasFalseEnum && value === false) {
-                    hasFalseEnum = true;
-                    break;
-                  }
-
-                  mainOptionType.add(Boolean);
-                  break;
-              }
-            });
-
-            if (!needNegativeOption) {
-              needNegativeOption = hasFalseEnum;
-              negatedDescription = config.negatedDescription;
-            }
-
-            return enumTypes;
-          }
-        }
-      });
-
-      mainOption = {
-        flags: option.alias ? `-${option.alias}, --${option.name}` : `--${option.name}`,
-        description: option.description || "",
-        type: mainOptionType,
-        multiple: option.multiple,
-        defaultValue: option.defaultValue,
-      };
-
-      if (needNegativeOption) {
-        negativeOption = {
-          flags: `--no-${option.name}`,
-          description:
-            negatedDescription || option.negatedDescription || `Negative '${option.name}' option.`,
-        };
-      }
-    } else {
-      mainOption = {
-        flags: option.alias ? `-${option.alias}, --${option.name}` : `--${option.name}`,
-        // TODO `describe` used by `webpack-dev-server@3`
-        description: option.description || option.describe || "",
-        type: option.type
-          ? new Set(Array.isArray(option.type) ? option.type : [option.type])
-          : new Set([Boolean]),
-        multiple: option.multiple,
-        defaultValue: option.defaultValue,
-      };
-
-      if (option.negative) {
-        negativeOption = {
-          flags: `--no-${option.name}`,
-          description: option.negatedDescription
-            ? option.negatedDescription
-            : `Negative '${option.name}' option.`,
-        };
-      }
-    }
-
-    if (mainOption.type.size > 1 && mainOption.type.has(Boolean)) {
-      mainOption.flags = `${mainOption.flags} [value${mainOption.multiple ? "..." : ""}]`;
-    } else if (mainOption.type.size > 0 && !mainOption.type.has(Boolean)) {
-      mainOption.flags = `${mainOption.flags} <value${mainOption.multiple ? "..." : ""}>`;
-    }
-
-    if (mainOption.type.size === 1) {
-      if (mainOption.type.has(Number)) {
-        let skipDefault = true;
-
-        const optionForCommand = new Option(mainOption.flags, mainOption.description)
-          .argParser((value, prev = []) => {
-            if (mainOption.defaultValue && mainOption.multiple && skipDefault) {
-              prev = [];
-              skipDefault = false;
-            }
-
-            return mainOption.multiple ? [].concat(prev).concat(Number(value)) : Number(value);
-          })
-          .default(mainOption.defaultValue);
-
-        optionForCommand.helpLevel = option.helpLevel;
-
-        command.addOption(optionForCommand);
-      } else if (mainOption.type.has(String)) {
-        let skipDefault = true;
-
-        const optionForCommand = new Option(mainOption.flags, mainOption.description)
-          .argParser((value, prev = []) => {
-            if (mainOption.defaultValue && mainOption.multiple && skipDefault) {
-              prev = [];
-              skipDefault = false;
-            }
-
-            return mainOption.multiple ? [].concat(prev).concat(value) : value;
-          })
-          .default(mainOption.defaultValue);
-
-        optionForCommand.helpLevel = option.helpLevel;
-
-        command.addOption(optionForCommand);
-      } else if (mainOption.type.has(Boolean)) {
-        const optionForCommand = new Option(mainOption.flags, mainOption.description).default(
-          mainOption.defaultValue,
-        );
-
-        optionForCommand.helpLevel = option.helpLevel;
-
-        command.addOption(optionForCommand);
-      } else {
-        const optionForCommand = new Option(mainOption.flags, mainOption.description)
-          .argParser(Array.from(mainOption.type)[0])
-          .default(mainOption.defaultValue);
-
-        optionForCommand.helpLevel = option.helpLevel;
-
-        command.addOption(optionForCommand);
-      }
-    } else if (mainOption.type.size > 1) {
-      let skipDefault = true;
-
-      const optionForCommand = new Option(
-        mainOption.flags,
-        mainOption.description,
-        mainOption.defaultValue,
-      )
-        .argParser((value, prev = []) => {
-          if (mainOption.defaultValue && mainOption.multiple && skipDefault) {
-            prev = [];
-            skipDefault = false;
-          }
-
-          if (mainOption.type.has(Number)) {
-            const numberValue = Number(value);
-
-            if (!isNaN(numberValue)) {
-              return mainOption.multiple ? [].concat(prev).concat(numberValue) : numberValue;
-            }
-          }
-
-          if (mainOption.type.has(String)) {
-            return mainOption.multiple ? [].concat(prev).concat(value) : value;
-          }
-
-          return value;
-        })
-        .default(mainOption.defaultValue);
-
-      optionForCommand.helpLevel = option.helpLevel;
-
-      command.addOption(optionForCommand);
-    } else if (mainOption.type.size === 0 && negativeOption) {
-      const optionForCommand = new Option(mainOption.flags, mainOption.description);
-
-      // Hide stub option
-      optionForCommand.hideHelp();
-      optionForCommand.helpLevel = option.helpLevel;
-
-      command.addOption(optionForCommand);
-    }
-
-    if (negativeOption) {
-      const optionForCommand = new Option(negativeOption.flags, negativeOption.description);
-
-      optionForCommand.helpLevel = option.helpLevel;
-
-      command.addOption(optionForCommand);
-    }
-  }
-
-  getBuiltInOptions() {
-    if (this.builtInOptionsCache) {
-      return this.builtInOptionsCache;
-    }
-
-    const minimumHelpFlags = [
-      "config",
-      "config-name",
-      "merge",
-      "env",
-      "mode",
-      "watch",
-      "watch-options-stdin",
-      "stats",
-      "devtool",
-      "entry",
-      "target",
-      "progress",
-      "json",
-      "name",
-      "output-path",
-      "node-env",
-    ];
-
-    const builtInFlags = [
-      // For configs
-      {
-        name: "config",
-        alias: "c",
-        configs: [
-          {
-            type: "string",
-          },
-        ],
-        multiple: true,
-        description: "Provide path to a webpack configuration file e.g. ./webpack.config.js.",
-      },
-      {
-        name: "config-name",
-        configs: [
-          {
-            type: "string",
-          },
-        ],
-        multiple: true,
-        description: "Name of the configuration to use.",
-      },
-      {
-        name: "merge",
-        alias: "m",
-        configs: [
-          {
-            type: "enum",
-            values: [true],
-          },
-        ],
-        description: "Merge two or more configurations using 'webpack-merge'.",
-      },
-      // Complex configs
-      {
-        name: "env",
-        type: (value, previous = {}) => {
-          // for https://github.com/webpack/webpack-cli/issues/2642
-          if (value.endsWith("=")) {
-            value.concat('""');
-          }
-
-          // This ensures we're only splitting by the first `=`
-          const [allKeys, val] = value.split(/=(.+)/, 2);
-          const splitKeys = allKeys.split(/\.(?!$)/);
-
-          let prevRef = previous;
-
-          splitKeys.forEach((someKey, index) => {
-            if (!prevRef[someKey]) {
-              prevRef[someKey] = {};
-            }
-
-            if (typeof prevRef[someKey] === "string") {
-              prevRef[someKey] = {};
-            }
-
-            if (index === splitKeys.length - 1) {
-              if (typeof val === "string") {
-                prevRef[someKey] = val;
-              } else {
-                prevRef[someKey] = true;
-              }
-            }
-
-            prevRef = prevRef[someKey];
-          });
-
-          return previous;
-        },
-        multiple: true,
-        description: "Environment passed to the configuration when it is a function.",
-      },
-      {
-        name: "node-env",
-        configs: [
-          {
-            type: "string",
-          },
-        ],
-        multiple: false,
-        description: "Sets process.env.NODE_ENV to the specified value.",
-      },
-
-      // Adding more plugins
-      {
-        name: "hot",
-        alias: "h",
-        configs: [
-          {
-            type: "string",
-          },
-          {
-            type: "boolean",
-          },
-        ],
-        negative: true,
-        description: "Enables Hot Module Replacement",
-        negatedDescription: "Disables Hot Module Replacement.",
-      },
-      {
-        name: "analyze",
-        configs: [
-          {
-            type: "enum",
-            values: [true],
-          },
-        ],
-        multiple: false,
-        description: "It invokes webpack-bundle-analyzer plugin to get bundle information.",
-      },
-      {
-        name: "progress",
-        configs: [
-          {
-            type: "string",
-          },
-          {
-            type: "enum",
-            values: [true],
-          },
-        ],
-        description: "Print compilation progress during build.",
-      },
-      {
-        name: "prefetch",
-        configs: [
-          {
-            type: "string",
-          },
-        ],
-        description: "Prefetch this request.",
-      },
-
-      // Output options
-      {
-        name: "json",
-        configs: [
-          {
-            type: "string",
-          },
-          {
-            type: "enum",
-            values: [true],
-          },
-        ],
-        alias: "j",
-        description: "Prints result as JSON or store it in a file.",
-      },
-
-      // For webpack@4
-      {
-        name: "entry",
-        configs: [
-          {
-            type: "string",
-          },
-        ],
-        multiple: true,
-        description: "The entry point(s) of your application e.g. ./src/main.js.",
-      },
-      {
-        name: "output-path",
-        alias: "o",
-        configs: [
-          {
-            type: "string",
-          },
-        ],
-        description: "Output location of the file generated by webpack e.g. ./dist/.",
-      },
-      {
-        name: "target",
-        alias: "t",
-        configs: [
-          {
-            type: "string",
-          },
-        ],
-        multiple: this.webpack.cli !== undefined,
-        description: "Sets the build target e.g. node.",
-      },
-      {
-        name: "devtool",
-        configs: [
-          {
-            type: "string",
-          },
-          {
-            type: "enum",
-            values: [false],
-          },
-        ],
-        negative: true,
-        alias: "d",
-        description: "Determine source maps to use.",
-        negatedDescription: "Do not generate source maps.",
-      },
-      {
-        name: "mode",
-        configs: [
-          {
-            type: "string",
-          },
-        ],
-        description: "Defines the mode to pass to webpack.",
-      },
-      {
-        name: "name",
-        configs: [
-          {
-            type: "string",
-          },
-        ],
-        description: "Name of the configuration. Used when loading multiple configurations.",
-      },
-      {
-        name: "stats",
-        configs: [
-          {
-            type: "string",
-          },
-          {
-            type: "boolean",
-          },
-        ],
-        negative: true,
-        description: "It instructs webpack on how to treat the stats e.g. verbose.",
-        negatedDescription: "Disable stats output.",
-      },
-      {
-        name: "watch",
-        configs: [
-          {
-            type: "boolean",
-          },
-        ],
-        negative: true,
-        alias: "w",
-        description: "Watch for files changes.",
-        negatedDescription: "Do not watch for file changes.",
-      },
-      {
-        name: "watch-options-stdin",
-        configs: [
-          {
-            type: "boolean",
-          },
-        ],
-        negative: true,
-        description: "Stop watching when stdin stream has ended.",
-        negatedDescription: "Do not stop watching when stdin stream has ended.",
-      },
-    ];
-
-    // Extract all the flags being exported from core.
-    // A list of cli flags generated by core can be found here https://github.com/webpack/webpack/blob/master/test/__snapshots__/Cli.test.js.snap
-    const coreFlags = this.webpack.cli
-      ? Object.entries(this.webpack.cli.getArguments()).map(([flag, meta]) => {
-          const inBuiltIn = builtInFlags.find((builtInFlag) => builtInFlag.name === flag);
-
-          if (inBuiltIn) {
-            return {
-              ...meta,
-              name: flag,
-              group: "core",
-              ...inBuiltIn,
-              configs: meta.configs || [],
-            };
-          }
-
-          return { ...meta, name: flag, group: "core" };
-        })
-      : [];
-
-    const options = []
-      .concat(
-        builtInFlags.filter(
-          (builtInFlag) => !coreFlags.find((coreFlag) => builtInFlag.name === coreFlag.name),
-        ),
-      )
-      .concat(coreFlags)
-      .map((option) => {
-        option.helpLevel = minimumHelpFlags.includes(option.name) ? "minimum" : "verbose";
-
-        return option;
-      });
-
-    this.builtInOptionsCache = options;
-
-    return options;
-  }
-
-  async loadWebpack(handleError = true) {
-    return this.tryRequireThenImport(WEBPACK_PACKAGE, handleError);
-  }
-
-  async run(args, parseOptions) {
-    // Built-in internal commands
-    const buildCommandOptions = {
-      name: "build [entries...]",
-      alias: ["bundle", "b"],
-      description: "Run webpack (default command, can be omitted).",
-      usage: "[entries...] [options]",
-      dependencies: [WEBPACK_PACKAGE],
-    };
-    const watchCommandOptions = {
-      name: "watch [entries...]",
-      alias: "w",
-      description: "Run webpack and watch for files changes.",
-      usage: "[entries...] [options]",
-      dependencies: [WEBPACK_PACKAGE],
-    };
-    const versionCommandOptions = {
-      name: "version [commands...]",
-      alias: "v",
-      description:
-        "Output the version number of 'webpack', 'webpack-cli' and 'webpack-dev-server' and commands.",
-    };
-    const helpCommandOptions = {
-      name: "help [command] [option]",
-      alias: "h",
-      description: "Display help for commands and options.",
-    };
-    // Built-in external commands
-    const externalBuiltInCommandsInfo = [
-      {
-        name: "serve [entries...]",
-        alias: ["server", "s"],
-        pkg: "@webpack-cli/serve",
-      },
-      {
-        name: "info",
-        alias: "i",
-        pkg: "@webpack-cli/info",
-      },
-      {
-        name: "init",
-        alias: ["create", "new", "c", "n"],
-        pkg: "@webpack-cli/generators",
-      },
-      {
-        name: "loader",
-        alias: "l",
-        pkg: "@webpack-cli/generators",
-      },
-      {
-        name: "plugin",
-        alias: "p",
-        pkg: "@webpack-cli/generators",
-      },
-      {
-        name: "migrate",
-        alias: "m",
-        pkg: "@webpack-cli/migrate",
-      },
-      {
-        name: "configtest [config-path]",
-        alias: "t",
-        pkg: "@webpack-cli/configtest",
-      },
-    ];
-
-    const knownCommands = [
-      buildCommandOptions,
-      watchCommandOptions,
-      versionCommandOptions,
-      helpCommandOptions,
-      ...externalBuiltInCommandsInfo,
-    ];
-    const getCommandName = (name) => name.split(" ")[0];
-    const isKnownCommand = (name) =>
-      knownCommands.find(
-        (command) =>
-          getCommandName(command.name) === name ||
-          (Array.isArray(command.alias) ? command.alias.includes(name) : command.alias === name),
-      );
-    const isCommand = (input, commandOptions) => {
-      const longName = getCommandName(commandOptions.name);
-
-      if (input === longName) {
-        return true;
-      }
-
-      if (commandOptions.alias) {
-        if (Array.isArray(commandOptions.alias)) {
-          return commandOptions.alias.includes(input);
-        } else {
-          return commandOptions.alias === input;
-        }
-      }
-
-      return false;
-    };
-    const findCommandByName = (name) =>
-      this.program.commands.find(
-        (command) => name === command.name() || command.aliases().includes(name),
-      );
-    const isOption = (value) => value.startsWith("-");
-    const isGlobalOption = (value) =>
-      value === "--color" ||
-      value === "--no-color" ||
-      value === "-v" ||
-      value === "--version" ||
-      value === "-h" ||
-      value === "--help";
-
-    const loadCommandByName = async (commandName, allowToInstall = false) => {
-      const isBuildCommandUsed = isCommand(commandName, buildCommandOptions);
-      const isWatchCommandUsed = isCommand(commandName, watchCommandOptions);
-
-      if (isBuildCommandUsed || isWatchCommandUsed) {
-        await this.makeCommand(
-          isBuildCommandUsed ? buildCommandOptions : watchCommandOptions,
-          async () => {
-            this.webpack = await this.loadWebpack();
-
-            return isWatchCommandUsed
-              ? this.getBuiltInOptions().filter((option) => option.name !== "watch")
-              : this.getBuiltInOptions();
-          },
-          async (entries, options) => {
-            if (entries.length > 0) {
-              options.entry = [...entries, ...(options.entry || [])];
-            }
-
-            await this.runWebpack(options, isWatchCommandUsed);
-          },
-        );
-      } else if (isCommand(commandName, helpCommandOptions)) {
-        // Stub for the `help` command
-        this.makeCommand(helpCommandOptions, [], () => {});
-      } else if (isCommand(commandName, versionCommandOptions)) {
-        // Stub for the `version` command
-        this.makeCommand(versionCommandOptions, [], () => {});
-      } else {
-        const builtInExternalCommandInfo = externalBuiltInCommandsInfo.find(
-          (externalBuiltInCommandInfo) =>
-            getCommandName(externalBuiltInCommandInfo.name) === commandName ||
-            (Array.isArray(externalBuiltInCommandInfo.alias)
-              ? externalBuiltInCommandInfo.alias.includes(commandName)
-              : externalBuiltInCommandInfo.alias === commandName),
-        );
-
-        let pkg;
-
-        if (builtInExternalCommandInfo) {
-          ({ pkg } = builtInExternalCommandInfo);
-        } else {
-          pkg = commandName;
-        }
-
-        if (pkg !== "webpack-cli" && !this.checkPackageExists(pkg)) {
-          if (!allowToInstall) {
-            return;
-          }
-
-          pkg = await this.doInstall(pkg, {
-            preMessage: () => {
-              this.logger.error(
-                `For using this command you need to install: '${this.colors.green(pkg)}' package.`,
-              );
-            },
-          });
-        }
-
-        let loadedCommand;
-
-        try {
-          loadedCommand = await this.tryRequireThenImport(pkg, false);
-        } catch (error) {
-          // Ignore, command is not installed
-
-          return;
-        }
-
-        let command;
-
-        try {
-          command = new loadedCommand();
-
-          await command.apply(this);
-        } catch (error) {
-          this.logger.error(`Unable to load '${pkg}' command`);
-          this.logger.error(error);
-          process.exit(2);
-        }
-      }
-    };
-
-    // Register own exit
-    this.program.exitOverride(async (error) => {
-      if (error.exitCode === 0) {
-        process.exit(0);
-      }
-
-      if (error.code === "executeSubCommandAsync") {
-        process.exit(2);
-      }
-
-      if (error.code === "commander.help") {
-        process.exit(0);
-      }
-
-      if (error.code === "commander.unknownOption") {
-        let name = error.message.match(/'(.+)'/);
-
-        if (name) {
-          name = name[1].substr(2);
-
-          if (name.includes("=")) {
-            name = name.split("=")[0];
-          }
-
-          const { operands } = this.program.parseOptions(this.program.args);
-          const operand =
-            typeof operands[0] !== "undefined"
-              ? operands[0]
-              : getCommandName(buildCommandOptions.name);
-
-          if (operand) {
-            const command = findCommandByName(operand);
-
-            if (!command) {
-              this.logger.error(`Can't find and load command '${operand}'`);
-              this.logger.error("Run 'webpack --help' to see available commands and options");
-              process.exit(2);
-            }
-
-            const levenshtein = require("fastest-levenshtein");
-
-            command.options.forEach((option) => {
-              if (!option.hidden && levenshtein.distance(name, option.long.slice(2)) < 3) {
-                this.logger.error(`Did you mean '--${option.name()}'?`);
-              }
-            });
-          }
-        }
-      }
-
-      // Codes:
-      // - commander.unknownCommand
-      // - commander.missingArgument
-      // - commander.missingMandatoryOptionValue
-      // - commander.optionMissingArgument
-
-      this.logger.error("Run 'webpack --help' to see available commands and options");
-      process.exit(2);
-    });
-
-    // Default `--color` and `--no-color` options
-    const cli = this;
-    this.program.option("--color", "Enable colors on console.");
-    this.program.on("option:color", function () {
-      const { color } = this.opts();
-
-      cli.isColorSupportChanged = color;
-      cli.colors = cli.createColors(color);
-    });
-    this.program.option("--no-color", "Disable colors on console.");
-    this.program.on("option:no-color", function () {
-      const { color } = this.opts();
-
-      cli.isColorSupportChanged = color;
-      cli.colors = cli.createColors(color);
-    });
-
-    // Make `-v, --version` options
-    // Make `version|v [commands...]` command
-    const outputVersion = async (options) => {
-      // Filter `bundle`, `watch`, `version` and `help` commands
-      const possibleCommandNames = options.filter(
-        (option) =>
-          !isCommand(option, buildCommandOptions) &&
-          !isCommand(option, watchCommandOptions) &&
-          !isCommand(option, versionCommandOptions) &&
-          !isCommand(option, helpCommandOptions),
-      );
-
-      possibleCommandNames.forEach((possibleCommandName) => {
-        if (!isOption(possibleCommandName)) {
-          return;
-        }
-
-        this.logger.error(`Unknown option '${possibleCommandName}'`);
-        this.logger.error("Run 'webpack --help' to see available commands and options");
-        process.exit(2);
-      });
-
-      if (possibleCommandNames.length > 0) {
-        await Promise.all(
-          possibleCommandNames.map((possibleCommand) => loadCommandByName(possibleCommand)),
-        );
-
-        for (const possibleCommandName of possibleCommandNames) {
-          const foundCommand = findCommandByName(possibleCommandName);
-
-          if (!foundCommand) {
-            this.logger.error(`Unknown command '${possibleCommandName}'`);
-            this.logger.error("Run 'webpack --help' to see available commands and options");
-            process.exit(2);
-          }
-
-          try {
-            const { name, version } = this.loadJSONFile(`${foundCommand.pkg}/package.json`);
-
-            this.logger.raw(`${name} ${version}`);
-          } catch (e) {
-            this.logger.error(`Error: External package '${foundCommand.pkg}' not found`);
-            process.exit(2);
-          }
-        }
-      }
-
-      let webpack;
-
-      try {
-        webpack = await this.loadWebpack(false);
-      } catch (_error) {
-        // Nothing
-      }
-
-      this.logger.raw(`webpack: ${webpack ? webpack.version : "not installed"}`);
-
-      const pkgJSON = this.loadJSONFile("../package.json");
-
-      this.logger.raw(`webpack-cli: ${pkgJSON.version}`);
-
-      let devServer;
-
-      try {
-        devServer = await this.loadJSONFile("webpack-dev-server/package.json", false);
-      } catch (_error) {
-        // Nothing
-      }
-
-      this.logger.raw(`webpack-dev-server ${devServer ? devServer.version : "not installed"}`);
-
-      process.exit(0);
-    };
-    this.program.option(
-      "-v, --version",
-      "Output the version number of 'webpack', 'webpack-cli' and 'webpack-dev-server' and commands.",
-    );
-
-    const outputHelp = async (options, isVerbose, isHelpCommandSyntax, program) => {
-      const { bold } = this.colors;
-      const outputIncorrectUsageOfHelp = () => {
-        this.logger.error("Incorrect use of help");
-        this.logger.error(
-          "Please use: 'webpack help [command] [option]' | 'webpack [command] --help'",
-        );
-        this.logger.error("Run 'webpack --help' to see available commands and options");
-        process.exit(2);
-      };
-
-      const isGlobalHelp = options.length === 0;
-      const isCommandHelp = options.length === 1 && !isOption(options[0]);
-
-      if (isGlobalHelp || isCommandHelp) {
-        program.configureHelp({
-          sortSubcommands: true,
-          // Support multiple aliases
-          commandUsage: (command) => {
-            let parentCmdNames = "";
-
-            for (let parentCmd = command.parent; parentCmd; parentCmd = parentCmd.parent) {
-              parentCmdNames = `${parentCmd.name()} ${parentCmdNames}`;
-            }
-
-            if (isGlobalHelp) {
-              return `${parentCmdNames}${command.usage()}\n${bold(
-                "Alternative usage to run commands:",
-              )} ${parentCmdNames}[command] [options]`;
-            }
-
-            return `${parentCmdNames}${command.name()}|${command
-              .aliases()
-              .join("|")} ${command.usage()}`;
-          },
-          // Support multiple aliases
-          subcommandTerm: (command) => {
-            const humanReadableArgumentName = (argument) => {
-              const nameOutput = argument.name + (argument.variadic === true ? "..." : "");
-
-              return argument.required ? "<" + nameOutput + ">" : "[" + nameOutput + "]";
-            };
-            const args = command._args.map((arg) => humanReadableArgumentName(arg)).join(" ");
-
-            return `${command.name()}|${command.aliases().join("|")}${args ? ` ${args}` : ""}${
-              command.options.length > 0 ? " [options]" : ""
-            }`;
-          },
-          visibleOptions: function visibleOptions(command) {
-            return command.options.filter((option) => {
-              if (option.hidden) {
-                return false;
-              }
-
-              switch (option.helpLevel) {
-                case "verbose":
-                  return isVerbose;
-                case "minimum":
-                default:
-                  return true;
-              }
-            });
-          },
-          padWidth(command, helper) {
-            return Math.max(
-              helper.longestArgumentTermLength(command, helper),
-              helper.longestOptionTermLength(command, helper),
-              // For global options
-              helper.longestOptionTermLength(program, helper),
-              helper.longestSubcommandTermLength(isGlobalHelp ? program : command, helper),
-            );
-          },
-          formatHelp: (command, helper) => {
-            const termWidth = helper.padWidth(command, helper);
-            const helpWidth = helper.helpWidth || process.env.WEBPACK_CLI_HELP_WIDTH || 80;
-            const itemIndentWidth = 2;
-            const itemSeparatorWidth = 2; // between term and description
-
-            const formatItem = (term, description) => {
-              if (description) {
-                const fullText = `${term.padEnd(termWidth + itemSeparatorWidth)}${description}`;
-
-                return helper.wrap(
-                  fullText,
-                  helpWidth - itemIndentWidth,
-                  termWidth + itemSeparatorWidth,
-                );
-              }
-
-              return term;
-            };
-
-            const formatList = (textArray) =>
-              textArray.join("\n").replace(/^/gm, " ".repeat(itemIndentWidth));
-
-            // Usage
-            let output = [`${bold("Usage:")} ${helper.commandUsage(command)}`, ""];
-
-            // Description
-            const commandDescription = isGlobalHelp
-              ? "The build tool for modern web applications."
-              : helper.commandDescription(command);
-
-            if (commandDescription.length > 0) {
-              output = output.concat([commandDescription, ""]);
-            }
-
-            // Arguments
-            const argumentList = helper
-              .visibleArguments(command)
-              .map((argument) => formatItem(argument.term, argument.description));
-
-            if (argumentList.length > 0) {
-              output = output.concat([bold("Arguments:"), formatList(argumentList), ""]);
-            }
-
-            // Options
-            const optionList = helper
-              .visibleOptions(command)
-              .map((option) =>
-                formatItem(helper.optionTerm(option), helper.optionDescription(option)),
-              );
-
-            if (optionList.length > 0) {
-              output = output.concat([bold("Options:"), formatList(optionList), ""]);
-            }
-
-            // Global options
-            const globalOptionList = program.options.map((option) =>
-              formatItem(helper.optionTerm(option), helper.optionDescription(option)),
-            );
-
-            if (globalOptionList.length > 0) {
-              output = output.concat([bold("Global options:"), formatList(globalOptionList), ""]);
-            }
-
-            // Commands
-            const commandList = helper
-              .visibleCommands(isGlobalHelp ? program : command)
-              .map((command) =>
-                formatItem(helper.subcommandTerm(command), helper.subcommandDescription(command)),
-              );
-
-            if (commandList.length > 0) {
-              output = output.concat([bold("Commands:"), formatList(commandList), ""]);
-            }
-
-            return output.join("\n");
-          },
-        });
-
-        if (isGlobalHelp) {
-          await Promise.all(
-            knownCommands.map((knownCommand) => {
-              return loadCommandByName(getCommandName(knownCommand.name));
-            }),
-          );
-
-          const buildCommand = findCommandByName(getCommandName(buildCommandOptions.name));
-
-          this.logger.raw(buildCommand.helpInformation());
-        } else {
-          const name = options[0];
-
-          await loadCommandByName(name);
-
-          const command = findCommandByName(name);
-
-          if (!command) {
-            const builtInCommandUsed = externalBuiltInCommandsInfo.find(
-              (command) => command.name.includes(name) || name === command.alias,
-            );
-            if (typeof builtInCommandUsed !== "undefined") {
-              this.logger.error(
-                `For using '${name}' command you need to install '${builtInCommandUsed.pkg}' package.`,
-              );
-            } else {
-              this.logger.error(`Can't find and load command '${name}'`);
-              this.logger.error("Run 'webpack --help' to see available commands and options.");
-            }
-            process.exit(2);
-          }
-
-          this.logger.raw(command.helpInformation());
-        }
-      } else if (isHelpCommandSyntax) {
-        let isCommandSpecified = false;
-        let commandName = getCommandName(buildCommandOptions.name);
-        let optionName;
-
-        if (options.length === 1) {
-          optionName = options[0];
-        } else if (options.length === 2) {
-          isCommandSpecified = true;
-          commandName = options[0];
-          optionName = options[1];
-
-          if (isOption(commandName)) {
-            outputIncorrectUsageOfHelp();
-          }
-        } else {
-          outputIncorrectUsageOfHelp();
-        }
-
-        await loadCommandByName(commandName);
-
-        const command = isGlobalOption(optionName) ? program : findCommandByName(commandName);
-
-        if (!command) {
-          this.logger.error(`Can't find and load command '${commandName}'`);
-          this.logger.error("Run 'webpack --help' to see available commands and options");
-          process.exit(2);
-        }
-
-        const option = command.options.find(
-          (option) => option.short === optionName || option.long === optionName,
-        );
-
-        if (!option) {
-          this.logger.error(`Unknown option '${optionName}'`);
-          this.logger.error("Run 'webpack --help' to see available commands and options");
-          process.exit(2);
-        }
-
-        const nameOutput =
-          option.flags.replace(/^.+[[<]/, "").replace(/(\.\.\.)?[\]>].*$/, "") +
-          (option.variadic === true ? "..." : "");
-        const value = option.required
-          ? "<" + nameOutput + ">"
-          : option.optional
-          ? "[" + nameOutput + "]"
-          : "";
-
-        this.logger.raw(
-          `${bold("Usage")}: webpack${isCommandSpecified ? ` ${commandName}` : ""} ${option.long}${
-            value ? ` ${value}` : ""
-          }`,
-        );
-
-        if (option.short) {
-          this.logger.raw(
-            `${bold("Short:")} webpack${isCommandSpecified ? ` ${commandName}` : ""} ${
-              option.short
-            }${value ? ` ${value}` : ""}`,
-          );
-        }
-
-        if (option.description) {
-          this.logger.raw(`${bold("Description:")} ${option.description}`);
-        }
-
-        if (!option.negate && option.defaultValue) {
-          this.logger.raw(`${bold("Default value:")} ${JSON.stringify(option.defaultValue)}`);
-        }
-
-        const flag = this.getBuiltInOptions().find((flag) => option.long === `--${flag.name}`);
-
-        if (flag && flag.configs) {
-          const possibleValues = flag.configs.reduce((accumulator, currentValue) => {
-            if (currentValue.values) {
-              return accumulator.concat(currentValue.values);
-            } else {
-              return accumulator;
-            }
-          }, []);
-
-          if (possibleValues.length > 0) {
-            this.logger.raw(
-              `${bold("Possible values:")} ${JSON.stringify(possibleValues.join(" | "))}`,
-            );
-          }
-        }
-
-        this.logger.raw("");
-
-        // TODO implement this after refactor cli arguments
-        // logger.raw('Documentation: https://webpack.js.org/option/name/');
-      } else {
-        outputIncorrectUsageOfHelp();
-      }
-
-      this.logger.raw(
-        "To see list of all supported commands and options run 'webpack --help=verbose'.\n",
-      );
-      this.logger.raw(`${bold("Webpack documentation:")} https://webpack.js.org/.`);
-      this.logger.raw(`${bold("CLI documentation:")} https://webpack.js.org/api/cli/.`);
-      this.logger.raw(`${bold("Made with ♥ by the webpack team")}.`);
-      process.exit(0);
-    };
-    this.program.helpOption(false);
-    this.program.addHelpCommand(false);
-    this.program.option("-h, --help [verbose]", "Display help for commands and options.");
-
-    let isInternalActionCalled = false;
-
-    // Default action
-    this.program.usage("[options]");
-    this.program.allowUnknownOption(true);
-    this.program.action(async (options, program) => {
-      if (!isInternalActionCalled) {
-        isInternalActionCalled = true;
-      } else {
-        this.logger.error("No commands found to run");
-        process.exit(2);
-      }
-
-      // Command and options
-      const { operands, unknown } = this.program.parseOptions(program.args);
-      const defaultCommandToRun = getCommandName(buildCommandOptions.name);
-      const hasOperand = typeof operands[0] !== "undefined";
-      const operand = hasOperand ? operands[0] : defaultCommandToRun;
-      const isHelpOption = typeof options.help !== "undefined";
-      const isHelpCommandSyntax = isCommand(operand, helpCommandOptions);
-
-      if (isHelpOption || isHelpCommandSyntax) {
-        let isVerbose = false;
-
-        if (isHelpOption) {
-          if (typeof options.help === "string") {
-            if (options.help !== "verbose") {
-              this.logger.error("Unknown value for '--help' option, please use '--help=verbose'");
-              process.exit(2);
-            }
-
-            isVerbose = true;
-          }
-        }
-
-        this.program.forHelp = true;
-
-        const optionsForHelp = []
-          .concat(isHelpOption && hasOperand ? [operand] : [])
-          // Syntax `webpack help [command]`
-          .concat(operands.slice(1))
-          // Syntax `webpack help [option]`
-          .concat(unknown)
-          .concat(
-            isHelpCommandSyntax && typeof options.color !== "undefined"
-              ? [options.color ? "--color" : "--no-color"]
-              : [],
-          )
-          .concat(
-            isHelpCommandSyntax && typeof options.version !== "undefined" ? ["--version"] : [],
-          );
-
-        await outputHelp(optionsForHelp, isVerbose, isHelpCommandSyntax, program);
-      }
-
-      const isVersionOption = typeof options.version !== "undefined";
-      const isVersionCommandSyntax = isCommand(operand, versionCommandOptions);
-
-      if (isVersionOption || isVersionCommandSyntax) {
-        const optionsForVersion = []
-          .concat(isVersionOption ? [operand] : [])
-          .concat(operands.slice(1))
-          .concat(unknown);
-
-        await outputVersion(optionsForVersion, program);
-      }
-
-      let commandToRun = operand;
-      let commandOperands = operands.slice(1);
-
-      if (isKnownCommand(commandToRun)) {
-        await loadCommandByName(commandToRun, true);
-      } else {
-        const isEntrySyntax = fs.existsSync(operand);
-
-        if (isEntrySyntax) {
-          commandToRun = defaultCommandToRun;
-          commandOperands = operands;
-
-          await loadCommandByName(commandToRun);
-        } else {
-          this.logger.error(`Unknown command or entry '${operand}'`);
-
-          const levenshtein = require("fastest-levenshtein");
-          const found = knownCommands.find(
-            (commandOptions) =>
-              levenshtein.distance(operand, getCommandName(commandOptions.name)) < 3,
-          );
-
-          if (found) {
-            this.logger.error(
-              `Did you mean '${getCommandName(found.name)}' (alias '${
-                Array.isArray(found.alias) ? found.alias.join(", ") : found.alias
-              }')?`,
-            );
-          }
-
-          this.logger.error("Run 'webpack --help' to see available commands and options");
-          process.exit(2);
-        }
-      }
-
-      await this.program.parseAsync([commandToRun, ...commandOperands, ...unknown], {
-        from: "user",
-      });
-    });
-
-    await this.program.parseAsync(args, parseOptions);
-  }
-
-  async loadConfig(options) {
-    const interpret = require("interpret");
-    const loadConfigByPath = async (configPath, argv = {}) => {
-      const ext = path.extname(configPath);
-      const interpreted = Object.keys(interpret.jsVariants).find((variant) => variant === ext);
-
-      if (interpreted) {
-        const rechoir = require("rechoir");
-
-        try {
-          rechoir.prepare(interpret.extensions, configPath);
-        } catch (error) {
-          if (error.failures) {
-            this.logger.error(`Unable load '${configPath}'`);
-            this.logger.error(error.message);
-            error.failures.forEach((failure) => {
-              this.logger.error(failure.error.message);
-            });
-            this.logger.error("Please install one of them");
-            process.exit(2);
-          }
-
-          this.logger.error(error);
-          process.exit(2);
-        }
-      }
-
-      let options;
-
-      try {
-        options = await this.tryRequireThenImport(configPath, false);
-      } catch (error) {
-        this.logger.error(`Failed to load '${configPath}' config`);
-
-        if (this.isValidationError(error)) {
-          this.logger.error(error.message);
-        } else {
-          this.logger.error(error);
-        }
-
-        process.exit(2);
-      }
-
-      if (Array.isArray(options)) {
-        await Promise.all(
-          options.map(async (_, i) => {
-            if (typeof options[i].then === "function") {
-              options[i] = await options[i];
-            }
-
-            // `Promise` may return `Function`
-            if (typeof options[i] === "function") {
-              // when config is a function, pass the env from args to the config function
-              options[i] = await options[i](argv.env, argv);
-            }
-          }),
-        );
-      } else {
-        if (typeof options.then === "function") {
-          options = await options;
-        }
-
-        // `Promise` may return `Function`
-        if (typeof options === "function") {
-          // when config is a function, pass the env from args to the config function
-          options = await options(argv.env, argv);
-        }
-      }
-
-      const isObject = (value) => typeof value === "object" && value !== null;
-
-      if (!isObject(options) && !Array.isArray(options)) {
-        this.logger.error(`Invalid configuration in '${configPath}'`);
-
-        process.exit(2);
-      }
-
-      return { options, path: configPath };
-    };
-
-    const config = { options: {}, path: new WeakMap() };
-
-    if (options.config && options.config.length > 0) {
-      const loadedConfigs = await Promise.all(
-        options.config.map((configPath) =>
-          loadConfigByPath(path.resolve(configPath), options.argv),
-        ),
-      );
-
-      config.options = [];
-
-      loadedConfigs.forEach((loadedConfig) => {
-        const isArray = Array.isArray(loadedConfig.options);
-
-        // TODO we should run webpack multiple times when the `--config` options have multiple values with `--merge`, need to solve for the next major release
-        if (config.options.length === 0) {
-          config.options = loadedConfig.options;
-        } else {
-          if (!Array.isArray(config.options)) {
-            config.options = [config.options];
-          }
-
-          if (isArray) {
-            loadedConfig.options.forEach((item) => {
-              config.options.push(item);
-            });
-          } else {
-            config.options.push(loadedConfig.options);
-          }
-        }
-
-        if (isArray) {
-          loadedConfig.options.forEach((options) => {
-            config.path.set(options, loadedConfig.path);
-          });
-        } else {
-          config.path.set(loadedConfig.options, loadedConfig.path);
-        }
-      });
-
-      config.options = config.options.length === 1 ? config.options[0] : config.options;
-    } else {
-      // Order defines the priority, in decreasing order
-      const defaultConfigFiles = [
-        "webpack.config",
-        ".webpack/webpack.config",
-        ".webpack/webpackfile",
-      ]
-        .map((filename) =>
-          // Since .cjs is not available on interpret side add it manually to default config extension list
-          [...Object.keys(interpret.extensions), ".cjs"].map((ext) => ({
-            path: path.resolve(filename + ext),
-            ext: ext,
-            module: interpret.extensions[ext],
-          })),
-        )
-        .reduce((accumulator, currentValue) => accumulator.concat(currentValue), []);
-
-      let foundDefaultConfigFile;
-
-      for (const defaultConfigFile of defaultConfigFiles) {
-        if (!fs.existsSync(defaultConfigFile.path)) {
-          continue;
-        }
-
-        foundDefaultConfigFile = defaultConfigFile;
-        break;
-      }
-
-      if (foundDefaultConfigFile) {
-        const loadedConfig = await loadConfigByPath(foundDefaultConfigFile.path, options.argv);
-
-        config.options = loadedConfig.options;
-
-        if (Array.isArray(config.options)) {
-          config.options.forEach((item) => {
-            config.path.set(item, loadedConfig.path);
-          });
-        } else {
-          config.path.set(loadedConfig.options, loadedConfig.path);
-        }
-      }
-    }
-
-    if (options.configName) {
-      const notFoundConfigNames = [];
-
-      config.options = options.configName.map((configName) => {
-        let found;
-
-        if (Array.isArray(config.options)) {
-          found = config.options.find((options) => options.name === configName);
-        } else {
-          found = config.options.name === configName ? config.options : undefined;
-        }
-
-        if (!found) {
-          notFoundConfigNames.push(configName);
-        }
-
-        return found;
-      });
-
-      if (notFoundConfigNames.length > 0) {
-        this.logger.error(
-          notFoundConfigNames
-            .map((configName) => `Configuration with the name "${configName}" was not found.`)
-            .join(" "),
-        );
-        process.exit(2);
-      }
-    }
-
-    if (options.merge) {
-      const merge = await this.tryRequireThenImport("webpack-merge");
-
-      // we can only merge when there are multiple configurations
-      // either by passing multiple configs by flags or passing a
-      // single config exporting an array
-      if (!Array.isArray(config.options) || config.options.length <= 1) {
-        this.logger.error("At least two configurations are required for merge.");
-        process.exit(2);
-      }
-
-      const mergedConfigPaths = [];
-
-      config.options = config.options.reduce((accumulator, options) => {
-        const configPath = config.path.get(options);
-        const mergedOptions = merge(accumulator, options);
-
-        mergedConfigPaths.push(configPath);
-
-        return mergedOptions;
-      }, {});
-      config.path.set(config.options, mergedConfigPaths);
-    }
-
-    return config;
-  }
-
-  async buildConfig(config, options) {
-    const runFunctionOnEachConfig = (options, fn) => {
-      if (Array.isArray(options)) {
-        for (let item of options) {
-          item = fn(item);
-        }
-      } else {
-        options = fn(options);
-      }
-
-      return options;
-    };
-
-    if (options.analyze) {
-      if (!this.checkPackageExists("webpack-bundle-analyzer")) {
-        await this.doInstall("webpack-bundle-analyzer", {
-          preMessage: () => {
-            this.logger.error(
-              `It looks like ${this.colors.yellow("webpack-bundle-analyzer")} is not installed.`,
-            );
-          },
-        });
-
-        this.logger.success(
-          `${this.colors.yellow("webpack-bundle-analyzer")} was installed successfully.`,
-        );
-      }
-    }
-
-    if (typeof options.progress === "string" && options.progress !== "profile") {
-      this.logger.error(
-        `'${options.progress}' is an invalid value for the --progress option. Only 'profile' is allowed.`,
-      );
-      process.exit(2);
-    }
-
-    if (typeof options.hot === "string" && options.hot !== "only") {
-      this.logger.error(
-        `'${options.hot}' is an invalid value for the --hot option. Use 'only' instead.`,
-      );
-      process.exit(2);
-    }
-
-    const CLIPlugin = await this.tryRequireThenImport("./plugins/CLIPlugin");
-
-    const internalBuildConfig = (item) => {
-      // Output warnings
-      if (
-        item.watch &&
-        options.argv &&
-        options.argv.env &&
-        (options.argv.env["WEBPACK_WATCH"] || options.argv.env["WEBPACK_SERVE"])
-      ) {
-        this.logger.warn(
-          `No need to use the '${
-            options.argv.env["WEBPACK_WATCH"] ? "watch" : "serve"
-          }' command together with '{ watch: true }' configuration, it does not make sense.`,
-        );
-
-        if (options.argv.env["WEBPACK_SERVE"]) {
-          item.watch = false;
-        }
-      }
-
-      // Apply options
-      if (this.webpack.cli) {
-        const args = this.getBuiltInOptions()
-          .filter((flag) => flag.group === "core")
-          .reduce((accumulator, flag) => {
-            accumulator[flag.name] = flag;
-
-            return accumulator;
-          }, {});
-
-        const values = Object.keys(options).reduce((accumulator, name) => {
-          if (name === "argv") {
-            return accumulator;
-          }
-
-          const kebabName = this.toKebabCase(name);
-
-          if (args[kebabName]) {
-            accumulator[kebabName] = options[name];
-          }
-
-          return accumulator;
-        }, {});
-
-        const problems = this.webpack.cli.processArguments(args, item, values);
-
-        if (problems) {
-          const groupBy = (xs, key) => {
-            return xs.reduce((rv, x) => {
-              (rv[x[key]] = rv[x[key]] || []).push(x);
-
-              return rv;
-            }, {});
-          };
-          const problemsByPath = groupBy(problems, "path");
-
-          for (const path in problemsByPath) {
-            const problems = problemsByPath[path];
-
-            problems.forEach((problem) => {
-              this.logger.error(
-                `${this.capitalizeFirstLetter(problem.type.replace(/-/g, " "))}${
-                  problem.value ? ` '${problem.value}'` : ""
-                } for the '--${problem.argument}' option${
-                  problem.index ? ` by index '${problem.index}'` : ""
-                }`,
-              );
-
-              if (problem.expected) {
-                this.logger.error(`Expected: '${problem.expected}'`);
-              }
-            });
-          }
-
-          process.exit(2);
-        }
-
-        // Setup default cache options
-        if (item.cache && item.cache.type === "filesystem") {
-          const configPath = config.path.get(item);
-
-          if (configPath) {
-            if (!item.cache.buildDependencies) {
-              item.cache.buildDependencies = {};
-            }
-
-            if (!item.cache.buildDependencies.defaultConfig) {
-              item.cache.buildDependencies.defaultConfig = [];
-            }
-
-            if (Array.isArray(configPath)) {
-              configPath.forEach((oneOfConfigPath) => {
-                item.cache.buildDependencies.defaultConfig.push(oneOfConfigPath);
-              });
-            } else {
-              item.cache.buildDependencies.defaultConfig.push(configPath);
-            }
-          }
-        }
-      }
-
-      // Setup legacy logic for webpack@4
-      // TODO respect `--entry-reset` in th next major release
-      // TODO drop in the next major release
-      if (options.entry) {
-        item.entry = options.entry;
-      }
-
-      if (options.outputPath) {
-        item.output = { ...item.output, ...{ path: path.resolve(options.outputPath) } };
-      }
-
-      if (options.target) {
-        item.target = options.target;
-      }
-
-      if (typeof options.devtool !== "undefined") {
-        item.devtool = options.devtool;
-      }
-
-      if (options.name) {
-        item.name = options.name;
-      }
-
-      if (typeof options.stats !== "undefined") {
-        item.stats = options.stats;
-      }
-
-      if (typeof options.watch !== "undefined") {
-        item.watch = options.watch;
-      }
-
-      if (typeof options.watchOptionsStdin !== "undefined") {
-        item.watchOptions = { ...item.watchOptions, ...{ stdin: options.watchOptionsStdin } };
-      }
-
-      if (options.mode) {
-        item.mode = options.mode;
-      }
-
-      // Respect `process.env.NODE_ENV`
-      if (
-        !item.mode &&
-        process.env &&
-        process.env.NODE_ENV &&
-        (process.env.NODE_ENV === "development" ||
-          process.env.NODE_ENV === "production" ||
-          process.env.NODE_ENV === "none")
-      ) {
-        item.mode = process.env.NODE_ENV;
-      }
-
-      // Setup stats
-      // TODO remove after drop webpack@4
-      const statsForWebpack4 = this.webpack.Stats && this.webpack.Stats.presetToOptions;
-
-      if (statsForWebpack4) {
-        if (typeof item.stats === "undefined") {
-          item.stats = {};
-        } else if (typeof item.stats === "boolean") {
-          item.stats = this.webpack.Stats.presetToOptions(item.stats);
-        } else if (
-          typeof item.stats === "string" &&
-          (item.stats === "none" ||
-            item.stats === "verbose" ||
-            item.stats === "detailed" ||
-            item.stats === "normal" ||
-            item.stats === "minimal" ||
-            item.stats === "errors-only" ||
-            item.stats === "errors-warnings")
-        ) {
-          item.stats = this.webpack.Stats.presetToOptions(item.stats);
-        }
-      } else {
-        if (typeof item.stats === "undefined") {
-          item.stats = { preset: "normal" };
-        } else if (typeof item.stats === "boolean") {
-          item.stats = item.stats ? { preset: "normal" } : { preset: "none" };
-        } else if (typeof item.stats === "string") {
-          item.stats = { preset: item.stats };
-        }
-      }
-
-      let colors;
-
-      // From arguments
-      if (typeof this.isColorSupportChanged !== "undefined") {
-        colors = Boolean(this.isColorSupportChanged);
-      }
-      // From stats
-      else if (typeof item.stats.colors !== "undefined") {
-        colors = item.stats.colors;
-      }
-      // Default
-      else {
-        colors = Boolean(this.colors.isColorSupported);
-      }
-
-      // TODO remove after drop webpack v4
-      if (typeof item.stats === "object" && item.stats !== null) {
-        item.stats.colors = colors;
-      }
-
-      // Apply CLI plugin
-      if (!item.plugins) {
-        item.plugins = [];
-      }
-
-      item.plugins.unshift(
-        new CLIPlugin({
-          configPath: config.path.get(item),
-          helpfulOutput: !options.json,
-          hot: options.hot,
-          progress: options.progress,
-          prefetch: options.prefetch,
-          analyze: options.analyze,
-        }),
-      );
-
-      return options;
-    };
-
-    runFunctionOnEachConfig(config.options, internalBuildConfig);
-
-    return config;
-  }
-
-  isValidationError(error) {
-    // https://github.com/webpack/webpack/blob/master/lib/index.js#L267
-    // https://github.com/webpack/webpack/blob/v4.44.2/lib/webpack.js#L90
-    const ValidationError =
-      this.webpack.ValidationError || this.webpack.WebpackOptionsValidationError;
-
-    return error instanceof ValidationError || error.name === "ValidationError";
-  }
-
-  async createCompiler(options, callback) {
-    if (typeof options.nodeEnv === "string") {
-      process.env.NODE_ENV = options.nodeEnv;
-    }
-
-    let config = await this.loadConfig(options);
-    config = await this.buildConfig(config, options);
-
-    let compiler;
-
-    try {
-      compiler = this.webpack(
-        config.options,
-        callback
-          ? (error, stats) => {
-              if (error && this.isValidationError(error)) {
-                this.logger.error(error.message);
-                process.exit(2);
-              }
-
-              callback(error, stats);
-            }
-          : callback,
-      );
-    } catch (error) {
-      if (this.isValidationError(error)) {
-        this.logger.error(error.message);
-      } else {
-        this.logger.error(error);
-      }
-
-      process.exit(2);
-    }
-
-    // TODO webpack@4 return Watching and MultiWatching instead Compiler and MultiCompiler, remove this after drop webpack@4
-    if (compiler && compiler.compiler) {
-      compiler = compiler.compiler;
-    }
-
-    return compiler;
-  }
-
-  needWatchStdin(compiler) {
-    if (compiler.compilers) {
-      return compiler.compilers.some(
-        (compiler) => compiler.options.watchOptions && compiler.options.watchOptions.stdin,
-      );
-    }
-
-    return compiler.options.watchOptions && compiler.options.watchOptions.stdin;
-  }
-
-  async runWebpack(options, isWatchCommand) {
-    // eslint-disable-next-line prefer-const
-    let compiler;
-    let createJsonStringifyStream;
-
-    if (options.json) {
-      const jsonExt = await this.tryRequireThenImport("@discoveryjs/json-ext");
-
-      createJsonStringifyStream = jsonExt.stringifyStream;
-    }
-
-    const callback = (error, stats) => {
-      if (error) {
-        this.logger.error(error);
-        process.exit(2);
-      }
-
-      if (stats.hasErrors()) {
-        process.exitCode = 1;
-      }
-
-      if (!compiler) {
-        return;
-      }
-
-      const statsOptions = compiler.compilers
-        ? {
-            children: compiler.compilers.map((compiler) =>
-              compiler.options ? compiler.options.stats : undefined,
-            ),
-          }
-        : compiler.options
-        ? compiler.options.stats
-        : undefined;
-
-      // TODO webpack@4 doesn't support `{ children: [{ colors: true }, { colors: true }] }` for stats
-      const statsForWebpack4 = this.webpack.Stats && this.webpack.Stats.presetToOptions;
-
-      if (compiler.compilers && statsForWebpack4) {
-        statsOptions.colors = statsOptions.children.some((child) => child.colors);
-      }
-
-      if (options.json && createJsonStringifyStream) {
-        const handleWriteError = (error) => {
-          this.logger.error(error);
-          process.exit(2);
-        };
-
-        if (options.json === true) {
-          createJsonStringifyStream(stats.toJson(statsOptions))
-            .on("error", handleWriteError)
-            .pipe(process.stdout)
-            .on("error", handleWriteError)
-            .on("close", () => process.stdout.write("\n"));
-        } else {
-          createJsonStringifyStream(stats.toJson(statsOptions))
-            .on("error", handleWriteError)
-            .pipe(fs.createWriteStream(options.json))
-            .on("error", handleWriteError)
-            // Use stderr to logging
-            .on("close", () => {
-              process.stderr.write(
-                `[webpack-cli] ${this.colors.green(
-                  `stats are successfully stored as json to ${options.json}`,
-                )}\n`,
-              );
-            });
-        }
-      } else {
-        const printedStats = stats.toString(statsOptions);
-
-        // Avoid extra empty line when `stats: 'none'`
-        if (printedStats) {
-          this.logger.raw(printedStats);
-        }
-      }
-    };
-
-    const env =
-      isWatchCommand || options.watch
-        ? { WEBPACK_WATCH: true, ...options.env }
-        : { WEBPACK_BUNDLE: true, WEBPACK_BUILD: true, ...options.env };
-
-    options.argv = { ...options, env };
-
-    if (isWatchCommand) {
-      options.watch = true;
-    }
-
-    compiler = await this.createCompiler(options, callback);
-
-    if (!compiler) {
-      return;
-    }
-
-    const isWatch = (compiler) =>
-      compiler.compilers
-        ? compiler.compilers.some((compiler) => compiler.options.watch)
-        : compiler.options.watch;
-
-    if (isWatch(compiler) && this.needWatchStdin(compiler)) {
-      process.stdin.on("end", () => {
-        process.exit(0);
-      });
-      process.stdin.resume();
-    }
-  }
-}
-
-module.exports = WebpackCLI;