Initial commit

node_modules/webpack-cli/LICENSE

@@ -0,0 +1,20 @@
+Copyright JS Foundation and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/webpack-cli/README.md

@@ -0,0 +1,145 @@
+<div align="center">
+    <a href="https://github.com/webpack/webpack-cli">
+        <img width="200" height="200" src="https://webpack.js.org/assets/icon-square-big.svg">
+    </a>
+</div>
+
+# webpack CLI
+
+The official CLI of webpack
+
+## About
+
+webpack CLI provides a flexible set of commands for developers to increase speed when setting up a custom webpack project. As of webpack v4, webpack is not expecting a configuration file, but often developers want to create a more custom webpack configuration based on their use-cases and needs. webpack CLI addresses these needs by providing a set of tools to improve the setup of custom webpack configuration.
+
+## How to install
+
+When you have followed the [Getting Started](https://webpack.js.org/guides/getting-started/) guide of webpack then webpack CLI is already installed!
+
+Otherwise
+
+```bash
+npm install --save-dev webpack-cli
+```
+
+or
+
+```bash
+yarn add webpack-cli --dev
+```
+
+## Supported arguments and commands
+
+### Usage
+
+All interactions with webpack-cli are of the form
+
+```bash
+npx webpack-cli [command] [options]
+```
+
+If no command is specified then `bundle` command is used by default
+
+### Help Usage
+
+To display basic commands and arguments -
+
+```bash
+npx webpack-cli --help
+```
+
+To display all supported commands and arguments -
+
+```bash
+npx webpack-cli --help=verbose
+```
+
+or
+
+```bash
+npx webpack-cli --help verbose
+```
+
+### Available Commands
+
+```
+  build|bundle|b [entries...] [options]                 Run webpack (default command, can be omitted).
+  configtest|t [config-path]                            Validate a webpack configuration.
+  help|h [command] [option]                             Display help for commands and options.
+  info|i [options]                                      Outputs information about your system.
+  init|create|new|c|n [generation-path] [options]       Initialize a new webpack project.
+  loader|l [output-path] [options]                      Scaffold a loader.
+  plugin|p [output-path] [options]                      Scaffold a plugin.
+  serve|server|s [entries...] [options]                 Run the webpack dev server.
+  version|v [commands...]                               Output the version number of 'webpack', 'webpack-cli' and 'webpack-dev-server' and commands.
+  watch|w [entries...] [options]                        Run webpack and watch for files changes.
+```
+
+### Available Options
+
+```
+Options:
+  -c, --config <value...>                          Provide path to a webpack configuration file e.g. ./webpack.config.js.
+  --config-name <value...>                         Name of the configuration to use.
+  -m, --merge                                      Merge two or more configurations using 'webpack-merge'.
+  --disable-interpret                              Disable interpret for loading the config file.
+  --env <value...>                                 Environment passed to the configuration when it is a function.
+  --node-env <value>                               Sets process.env.NODE_ENV to the specified value.
+  --define-process-env-node-env <value>            Sets process.env.NODE_ENV to the specified value. (Currently an alias for `--node-env`)
+  --analyze                                        It invokes webpack-bundle-analyzer plugin to get bundle information.
+  --progress [value]                               Print compilation progress during build.
+  -j, --json [value]                               Prints result as JSON or store it in a file.
+  --fail-on-warnings                               Stop webpack-cli process with non-zero exit code on warnings from webpack
+  -d, --devtool <value>                            A developer tool to enhance debugging (false | eval | [inline-|hidden-|eval-][nosources-][cheap-[module-]]source-map).
+  --no-devtool                                     Negative 'devtool' option.
+  --entry <value...>                               A module that is loaded upon startup. Only the last one is exported.
+  --mode <value>                                   Enable production optimizations or development hints.
+  --name <value>                                   Name of the configuration. Used when loading multiple configurations.
+  -o, --output-path <value>                        The output directory as **absolute path** (required).
+  --stats [value]                                  Stats options object or preset name.
+  --no-stats                                       Negative 'stats' option.
+  -t, --target <value...>                          Environment to build for. Environment to build for. An array of environments to build for all of them when possible.
+  --no-target                                      Negative 'target' option.
+  -w, --watch                                      Enter watch mode, which rebuilds on file change.
+  --no-watch                                       Negative 'watch' option.
+  --watch-options-stdin                            Stop watching when stdin stream has ended.
+  --no-watch-options-stdin                         Negative 'watch-options-stdin' option.
+
+Global options:
+  --color                                          Enable colors on console.
+  --no-color                                       Disable colors on console.
+  -v, --version                                    Output the version number of 'webpack', 'webpack-cli' and 'webpack-dev-server' and commands.
+  -h, --help [verbose]                             Display help for commands and options.
+```
+
+Checkout [`OPTIONS.md`](https://github.com/webpack/webpack-cli/blob/master/OPTIONS.md) to see list of all available options.
+
+## Exit codes and their meanings
+
+| Exit Code | Description                                        |
+| --------- | -------------------------------------------------- |
+| `0`       | Success                                            |
+| `1`       | Errors from webpack                                |
+| `2`       | Configuration/options problem or an internal error |
+
+## CLI Environment Variables
+
+| Environment Variable                | Description                                                         |
+| ----------------------------------- | ------------------------------------------------------------------- |
+| `WEBPACK_CLI_SKIP_IMPORT_LOCAL`     | when `true` it will skip using the local instance of `webpack-cli`. |
+| `WEBPACK_CLI_FORCE_LOAD_ESM_CONFIG` | when `true` it will force load the ESM config.                      |
+| `WEBPACK_PACKAGE`                   | Use a custom webpack version in CLI.                                |
+| `WEBPACK_DEV_SERVER_PACKAGE`        | Use a custom webpack-dev-server version in CLI.                     |
+| `WEBPACK_CLI_HELP_WIDTH`            | Use custom width for help output.                                   |
+
+## Configuration Environment Variables
+
+You can use the following environment variables inside your webpack configuration:
+
+| Environment Variable | Description                                  |
+| -------------------- | -------------------------------------------- |
+| `WEBPACK_SERVE`      | `true` if `serve\|s` is being used.          |
+| `WEBPACK_BUILD`      | `true` if `build\|bundle\|b` is being used.  |
+| `WEBPACK_WATCH`      | `true` if `--watch\|watch\|w` is being used. |
+
+Checkout [webpack.js.org](https://webpack.js.org/api/cli/) for more detailed documentation of `webpack-cli`.

node_modules/webpack-cli/bin/cli.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const importLocal = require("import-local");
+const runCLI = require("../lib/bootstrap");
+
+if (!process.env.WEBPACK_CLI_SKIP_IMPORT_LOCAL) {
+  // Prefer the local installation of `webpack-cli`
+  if (importLocal(__filename)) {
+    return;
+  }
+}
+
+process.title = "webpack";
+
+runCLI(process.argv);

node_modules/webpack-cli/lib/bootstrap.d.ts

@@ -0,0 +1 @@
+export {};

node_modules/webpack-cli/lib/bootstrap.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const WebpackCLI = require("./webpack-cli");
+const runCLI = async (args) => {
+    // Create a new instance of the CLI object
+    const cli = new WebpackCLI();
+    try {
+        await cli.run(args);
+    }
+    catch (error) {
+        cli.logger.error(error);
+        process.exit(2);
+    }
+};
+module.exports = runCLI;

node_modules/webpack-cli/lib/index.d.ts

@@ -0,0 +1 @@
+export type * from "./types";

node_modules/webpack-cli/lib/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const CLI = require("./webpack-cli");
+module.exports = CLI;

node_modules/webpack-cli/lib/plugins/cli-plugin.d.ts

@@ -0,0 +1,12 @@
+import { type Compiler } from "webpack";
+import { type CLIPluginOptions } from "../types";
+export declare class CLIPlugin {
+    #private;
+    logger: ReturnType<Compiler["getInfrastructureLogger"]>;
+    options: CLIPluginOptions;
+    constructor(options: CLIPluginOptions);
+    setupBundleAnalyzerPlugin(compiler: Compiler): Promise<void>;
+    setupProgressPlugin(compiler: Compiler): void;
+    setupHelpfulOutput(compiler: Compiler): void;
+    apply(compiler: Compiler): void;
+}

node_modules/webpack-cli/lib/plugins/cli-plugin.js

@@ -0,0 +1,108 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _a, _CLIPlugin_progressStates;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIPlugin = void 0;
+class CLIPlugin {
+    constructor(options) {
+        this.options = options;
+    }
+    async setupBundleAnalyzerPlugin(compiler) {
+        // eslint-disable-next-line node/no-extraneous-require,@typescript-eslint/no-var-requires
+        const { BundleAnalyzerPlugin } = require("webpack-bundle-analyzer");
+        const bundleAnalyzerPlugin = Boolean(compiler.options.plugins.find((plugin) => plugin instanceof BundleAnalyzerPlugin));
+        if (!bundleAnalyzerPlugin) {
+            new BundleAnalyzerPlugin().apply(compiler);
+        }
+    }
+    setupProgressPlugin(compiler) {
+        const { ProgressPlugin } = compiler.webpack || require("webpack");
+        const progressPlugin = Boolean(compiler.options.plugins.find((plugin) => plugin instanceof ProgressPlugin));
+        if (progressPlugin) {
+            return;
+        }
+        const isProfile = this.options.progress === "profile";
+        const options = {
+            profile: isProfile,
+        };
+        if (this.options.isMultiCompiler && ProgressPlugin.createDefaultHandler) {
+            const handler = ProgressPlugin.createDefaultHandler(isProfile, compiler.getInfrastructureLogger("webpack.Progress"));
+            const idx = __classPrivateFieldGet(CLIPlugin, _a, "f", _CLIPlugin_progressStates).length;
+            __classPrivateFieldGet(CLIPlugin, _a, "f", _CLIPlugin_progressStates)[idx] = [0];
+            options.handler = (p, msg, ...args) => {
+                __classPrivateFieldGet(CLIPlugin, _a, "f", _CLIPlugin_progressStates)[idx] = [p, msg, ...args];
+                let sum = 0;
+                for (const [p] of __classPrivateFieldGet(CLIPlugin, _a, "f", _CLIPlugin_progressStates)) {
+                    sum += p;
+                }
+                handler(sum / __classPrivateFieldGet(CLIPlugin, _a, "f", _CLIPlugin_progressStates).length, `[${compiler.name ? compiler.name : idx}] ${msg}`, ...args);
+            };
+        }
+        new ProgressPlugin(options).apply(compiler);
+    }
+    setupHelpfulOutput(compiler) {
+        const pluginName = "webpack-cli";
+        const getCompilationName = () => (compiler.name ? `'${compiler.name}'` : "");
+        const logCompilation = (message) => {
+            if (process.env.WEBPACK_CLI_START_FINISH_FORCE_LOG) {
+                process.stderr.write(message);
+            }
+            else {
+                this.logger.log(message);
+            }
+        };
+        const { configPath } = this.options;
+        compiler.hooks.run.tap(pluginName, () => {
+            const name = getCompilationName();
+            logCompilation(`Compiler${name ? ` ${name}` : ""} starting... `);
+            if (configPath) {
+                this.logger.log(`Compiler${name ? ` ${name}` : ""} is using config: ${configPath
+                    .map((path) => `'${path}'`)
+                    .join(", ")}`);
+            }
+        });
+        compiler.hooks.watchRun.tap(pluginName, (compiler) => {
+            const { bail, watch } = compiler.options;
+            if (bail && watch) {
+                this.logger.warn('You are using "bail" with "watch". "bail" will still exit webpack when the first error is found.');
+            }
+            const name = getCompilationName();
+            logCompilation(`Compiler${name ? ` ${name}` : ""} starting... `);
+            if (configPath) {
+                this.logger.log(`Compiler${name ? ` ${name}` : ""} is using config: '${configPath}'`);
+            }
+        });
+        compiler.hooks.invalid.tap(pluginName, (filename, changeTime) => {
+            const date = new Date(changeTime);
+            this.logger.log(`File '${filename}' was modified`);
+            this.logger.log(`Changed time is ${date} (timestamp is ${changeTime})`);
+        });
+        (compiler.webpack ? compiler.hooks.afterDone : compiler.hooks.done).tap(pluginName, () => {
+            const name = getCompilationName();
+            logCompilation(`Compiler${name ? ` ${name}` : ""} finished`);
+            process.nextTick(() => {
+                if (compiler.watchMode) {
+                    this.logger.log(`Compiler${name ? `${name}` : ""} is watching files for updates...`);
+                }
+            });
+        });
+    }
+    apply(compiler) {
+        this.logger = compiler.getInfrastructureLogger("webpack-cli");
+        if (this.options.progress) {
+            this.setupProgressPlugin(compiler);
+        }
+        if (this.options.analyze) {
+            this.setupBundleAnalyzerPlugin(compiler);
+        }
+        this.setupHelpfulOutput(compiler);
+    }
+}
+exports.CLIPlugin = CLIPlugin;
+_a = CLIPlugin;
+_CLIPlugin_progressStates = { value: [] };
+module.exports = CLIPlugin;

node_modules/webpack-cli/lib/types.d.ts

@@ -0,0 +1,230 @@
+/// <reference types="node" />
+import type { EntryOptions, Stats, Configuration, WebpackError, StatsOptions, WebpackOptionsNormalized, Compiler, MultiCompiler, Problem, Argument, AssetEmittedInfo, FileCacheOptions } from "webpack";
+import type webpack from "webpack";
+import type { ClientConfiguration, Configuration as DevServerConfig } from "webpack-dev-server";
+import { type Colorette } from "colorette";
+import { type Command, type CommandOptions, type Option, type ParseOptions } from "commander";
+import { type prepare } from "rechoir";
+import { type stringifyStream } from "@discoveryjs/json-ext";
+/**
+ * Webpack CLI
+ */
+interface IWebpackCLI {
+    colors: WebpackCLIColors;
+    logger: WebpackCLILogger;
+    isColorSupportChanged: boolean | undefined;
+    webpack: typeof webpack;
+    builtInOptionsCache: WebpackCLIBuiltInOption[] | undefined;
+    program: WebpackCLICommand;
+    isMultipleCompiler(compiler: WebpackCompiler): compiler is MultiCompiler;
+    isPromise<T>(value: Promise<T>): value is Promise<T>;
+    isFunction(value: unknown): value is CallableFunction;
+    getLogger(): WebpackCLILogger;
+    createColors(useColors?: boolean): WebpackCLIColors;
+    toKebabCase: StringFormatter;
+    capitalizeFirstLetter: StringFormatter;
+    checkPackageExists(packageName: string): boolean;
+    getAvailablePackageManagers(): PackageManager[];
+    getDefaultPackageManager(): PackageManager | undefined;
+    doInstall(packageName: string, options?: PackageInstallOptions): Promise<string>;
+    loadJSONFile<T = unknown>(path: Path, handleError: boolean): Promise<T>;
+    tryRequireThenImport<T = unknown>(module: ModuleName, handleError: boolean): Promise<T>;
+    getInfoOptions(): WebpackCLIBuiltInOption[];
+    getInfoOutput(options: {
+        output: string;
+        additionalPackage: string[];
+    }): Promise<string>;
+    makeCommand(commandOptions: WebpackCLIOptions, options: WebpackCLICommandOptions, action: CommandAction): Promise<WebpackCLICommand | undefined>;
+    makeOption(command: WebpackCLICommand, option: WebpackCLIBuiltInOption): void;
+    run(args: Parameters<WebpackCLICommand["parseOptions"]>[0], parseOptions?: ParseOptions): Promise<void>;
+    getBuiltInOptions(): WebpackCLIBuiltInOption[];
+    loadWebpack(handleError?: boolean): Promise<typeof webpack>;
+    loadConfig(options: Partial<WebpackDevServerOptions>): Promise<WebpackCLIConfig>;
+    buildConfig(config: WebpackCLIConfig, options: WebpackDevServerOptions): Promise<WebpackCLIConfig>;
+    isValidationError(error: Error): error is WebpackError;
+    createCompiler(options: Partial<WebpackDevServerOptions>, callback?: Callback<[Error | undefined, WebpackCLIStats | undefined]>): Promise<WebpackCompiler>;
+    needWatchStdin(compiler: Compiler | MultiCompiler): boolean;
+    runWebpack(options: WebpackRunOptions, isWatchCommand: boolean): Promise<void>;
+}
+interface WebpackCLIColors extends Colorette {
+    isColorSupported: boolean;
+}
+interface WebpackCLILogger {
+    error: LogHandler;
+    warn: LogHandler;
+    info: LogHandler;
+    success: LogHandler;
+    log: LogHandler;
+    raw: LogHandler;
+}
+interface WebpackCLICommandOption extends CommanderOption {
+    helpLevel?: "minimum" | "verbose";
+}
+interface WebpackCLIConfig {
+    options: WebpackConfiguration | WebpackConfiguration[];
+    path: WeakMap<object, string[]>;
+}
+interface WebpackCLICommand extends Command {
+    pkg: string | undefined;
+    forHelp: boolean | undefined;
+    _args: WebpackCLICommandOption[];
+}
+interface WebpackCLIStats extends Stats {
+    presetToOptions?: (item: string | boolean) => StatsOptions;
+}
+type WebpackCLIMainOption = Pick<WebpackCLIBuiltInOption, "valueName" | "description" | "defaultValue" | "multiple"> & {
+    flags: string;
+    type: Set<BooleanConstructor | StringConstructor | NumberConstructor>;
+};
+interface WebpackCLIOptions extends CommandOptions {
+    name: string;
+    alias: string | string[];
+    description?: string;
+    usage?: string;
+    dependencies?: string[];
+    pkg?: string;
+    argsDescription?: {
+        [argName: string]: string;
+    };
+}
+type WebpackCLICommandOptions = WebpackCLIBuiltInOption[] | (() => Promise<WebpackCLIBuiltInOption[]>);
+interface WebpackCLIBuiltInFlag {
+    name: string;
+    alias?: string;
+    type?: (value: string, previous: Record<string, BasicPrimitive | object>) => Record<string, BasicPrimitive | object>;
+    configs?: Partial<FlagConfig>[];
+    negative?: boolean;
+    multiple?: boolean;
+    valueName?: string;
+    description: string;
+    describe?: string;
+    negatedDescription?: string;
+    defaultValue?: string;
+    helpLevel: "minimum" | "verbose";
+}
+interface WebpackCLIBuiltInOption extends WebpackCLIBuiltInFlag {
+    hidden?: boolean;
+    group?: "core";
+}
+type WebpackCLIExternalCommandInfo = Pick<WebpackCLIOptions, "name" | "alias" | "description"> & {
+    pkg: string;
+};
+/**
+ * Webpack dev server
+ */
+type WebpackDevServerOptions = DevServerConfig & WebpackConfiguration & ClientConfiguration & AssetEmittedInfo & WebpackOptionsNormalized & FileCacheOptions & Argv & {
+    nodeEnv?: "string";
+    watchOptionsStdin?: boolean;
+    progress?: boolean | "profile" | undefined;
+    analyze?: boolean;
+    prefetch?: string;
+    json?: boolean;
+    entry: EntryOptions;
+    merge?: boolean;
+    config: string[];
+    configName?: string[];
+    disableInterpret?: boolean;
+    extends?: string[];
+    argv: Argv;
+};
+type Callback<T extends unknown[]> = (...args: T) => void;
+/**
+ * Webpack
+ */
+type WebpackConfiguration = Configuration;
+type ConfigOptions = PotentialPromise<WebpackConfiguration | CallableOption>;
+type CallableOption = (env: Env | undefined, argv: Argv) => WebpackConfiguration;
+type WebpackCompiler = Compiler | MultiCompiler;
+type FlagType = boolean | "enum" | "string" | "path" | "number" | "boolean" | "RegExp" | "reset";
+type FlagConfig = {
+    negatedDescription: string;
+    type: FlagType;
+    values: FlagType[];
+};
+type FileSystemCacheOptions = WebpackConfiguration & {
+    cache: FileCacheOptions & {
+        defaultConfig: string[];
+    };
+};
+type ProcessedArguments = Record<string, BasicPrimitive | RegExp | (BasicPrimitive | RegExp)[]>;
+type CommandAction = Parameters<WebpackCLICommand["action"]>[0];
+interface WebpackRunOptions extends WebpackOptionsNormalized {
+    progress?: boolean | "profile";
+    json?: boolean;
+    argv?: Argv;
+    env: Env;
+    failOnWarnings?: boolean;
+    isWatchingLikeCommand?: boolean;
+}
+/**
+ * Package management
+ */
+type PackageManager = "pnpm" | "yarn" | "npm";
+interface PackageInstallOptions {
+    preMessage?: () => void;
+}
+interface BasicPackageJsonContent {
+    name: string;
+    version: string;
+    description: string;
+    license: string;
+}
+/**
+ * Plugins and util types
+ */
+interface CLIPluginOptions {
+    isMultiCompiler?: boolean;
+    configPath?: string[];
+    helpfulOutput: boolean;
+    hot?: boolean | "only";
+    progress?: boolean | "profile";
+    prefetch?: string;
+    analyze?: boolean;
+}
+type BasicPrimitive = string | boolean | number;
+type Instantiable<InstanceType = unknown, ConstructorParameters extends unknown[] = unknown[]> = {
+    new (...args: ConstructorParameters): InstanceType;
+};
+type PotentialPromise<T> = T | Promise<T>;
+type ModuleName = string;
+type Path = string;
+type LogHandler = (value: any) => void;
+type StringFormatter = (value: string) => string;
+interface Argv extends Record<string, any> {
+    env?: Env;
+}
+interface Env {
+    WEBPACK_BUNDLE?: boolean;
+    WEBPACK_BUILD?: boolean;
+    WEBPACK_WATCH?: boolean;
+    WEBPACK_SERVE?: boolean;
+    WEBPACK_PACKAGE?: string;
+    WEBPACK_DEV_SERVER_PACKAGE?: string;
+}
+type DynamicImport<T> = (url: string) => Promise<{
+    default: T;
+}>;
+interface ImportLoaderError extends Error {
+    code?: string;
+}
+/**
+ * External libraries types
+ */
+type OptionConstructor = new (flags: string, description?: string) => Option;
+type CommanderOption = InstanceType<OptionConstructor>;
+interface Rechoir {
+    prepare: typeof prepare;
+}
+interface JsonExt {
+    stringifyStream: typeof stringifyStream;
+}
+interface RechoirError extends Error {
+    failures: RechoirError[];
+    error: Error;
+}
+interface PromptOptions {
+    message: string;
+    defaultResponse: string;
+    stream: NodeJS.WritableStream;
+}
+export { IWebpackCLI, WebpackCLICommandOption, WebpackCLIBuiltInOption, WebpackCLIBuiltInFlag, WebpackCLIColors, WebpackCLIStats, WebpackCLIConfig, WebpackCLIExternalCommandInfo, WebpackCLIOptions, WebpackCLICommand, WebpackCLICommandOptions, WebpackCLIMainOption, WebpackCLILogger, WebpackDevServerOptions, WebpackRunOptions, WebpackCompiler, WebpackConfiguration, Argv, Argument, BasicPrimitive, BasicPackageJsonContent, CallableOption, Callback, CLIPluginOptions, CommandAction, CommanderOption, CommandOptions, ConfigOptions, DynamicImport, FileSystemCacheOptions, FlagConfig, ImportLoaderError, Instantiable, JsonExt, ModuleName, PackageInstallOptions, PackageManager, Path, ProcessedArguments, PromptOptions, Problem, PotentialPromise, Rechoir, RechoirError, };

node_modules/webpack-cli/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/webpack-cli/lib/utils/dynamic-import-loader.d.ts

@@ -0,0 +1 @@
+export {};

node_modules/webpack-cli/lib/utils/dynamic-import-loader.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function dynamicImportLoader() {
+    let importESM;
+    try {
+        importESM = new Function("id", "return import(id);");
+    }
+    catch (e) {
+        importESM = null;
+    }
+    return importESM;
+}
+module.exports = dynamicImportLoader;

node_modules/webpack-cli/lib/webpack-cli.d.ts

@@ -0,0 +1 @@
+export {};

node_modules/webpack-cli/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "webpack-cli",
+  "version": "5.1.4",
+  "description": "CLI for webpack & friends",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/webpack/webpack-cli.git"
+  },
+  "homepage": "https://github.com/webpack/webpack-cli/tree/master/packages/webpack-cli",
+  "bugs": "https://github.com/webpack/webpack-cli/issues",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/webpack"
+  },
+  "bin": {
+    "webpack-cli": "./bin/cli.js"
+  },
+  "main": "./lib/index.js",
+  "engines": {
+    "node": ">=14.15.0"
+  },
+  "keywords": [
+    "webpack",
+    "cli",
+    "scaffolding",
+    "module",
+    "bundler",
+    "web"
+  ],
+  "files": [
+    "bin",
+    "lib",
+    "!**/*__tests__"
+  ],
+  "dependencies": {
+    "@discoveryjs/json-ext": "^0.5.0",
+    "@webpack-cli/configtest": "^2.1.1",
+    "@webpack-cli/info": "^2.0.2",
+    "@webpack-cli/serve": "^2.0.5",
+    "colorette": "^2.0.14",
+    "commander": "^10.0.1",
+    "cross-spawn": "^7.0.3",
+    "envinfo": "^7.7.3",
+    "fastest-levenshtein": "^1.0.12",
+    "import-local": "^3.0.2",
+    "interpret": "^3.1.1",
+    "rechoir": "^0.8.0",
+    "webpack-merge": "^5.7.3"
+  },
+  "devDependencies": {
+    "@types/envinfo": "^7.8.1"
+  },
+  "peerDependencies": {
+    "webpack": "5.x.x"
+  },
+  "peerDependenciesMeta": {
+    "@webpack-cli/generators": {
+      "optional": true
+    },
+    "webpack-bundle-analyzer": {
+      "optional": true
+    },
+    "webpack-dev-server": {
+      "optional": true
+    }
+  },
+  "gitHead": "e07f0e58df103011435524d757102534b75a6796"
+}