summaryrefslogtreecommitdiffstats
path: root/node_modules/webpack-cli/bin
diff options
context:
space:
mode:
Diffstat (limited to 'node_modules/webpack-cli/bin')
-rw-r--r--node_modules/webpack-cli/bin/.eslintrc.js63
-rwxr-xr-xnode_modules/webpack-cli/bin/cli.js366
-rw-r--r--node_modules/webpack-cli/bin/config/config-yargs.js504
-rw-r--r--node_modules/webpack-cli/bin/config/optionsSchema.json1989
-rw-r--r--node_modules/webpack-cli/bin/config/webpackConfigurationSchema.json20
-rw-r--r--node_modules/webpack-cli/bin/utils/constants.js28
-rw-r--r--node_modules/webpack-cli/bin/utils/convert-argv.js562
-rw-r--r--node_modules/webpack-cli/bin/utils/errorHelpers.js33
-rw-r--r--node_modules/webpack-cli/bin/utils/prepareOptions.js24
-rw-r--r--node_modules/webpack-cli/bin/utils/prompt-command.js142
-rw-r--r--node_modules/webpack-cli/bin/utils/validate-options.js21
11 files changed, 0 insertions, 3752 deletions
diff --git a/node_modules/webpack-cli/bin/.eslintrc.js b/node_modules/webpack-cli/bin/.eslintrc.js
deleted file mode 100644
index b32868d..0000000
--- a/node_modules/webpack-cli/bin/.eslintrc.js
+++ /dev/null
@@ -1,63 +0,0 @@
-module.exports = {
- root: true,
- plugins: ["node"],
- extends: ["../.eslintrc.js", "plugin:node/recommended"],
- env: {
- node: true,
- es6: true,
- jest: true
- },
- parserOptions: { ecmaVersion: 2017, sourceType: "module" },
- rules: {
- "node/no-unsupported-features": ["error", { version: 6 }],
- "node/no-deprecated-api": "error",
- "node/no-missing-import": "error",
- "node/no-missing-require": [
- "error",
- {
- resolvePaths: ["./packages"],
- allowModules: [
- "webpack",
- "@webpack-cli/generators",
- "@webpack-cli/init",
- "@webpack-cli/migrate",
- "@webpack-cli/utils",
- "@webpack-cli/generate-loader",
- "@webpack-cli/generate-plugin",
- "@webpack-cli/webpack-scaffold"
- ]
- }
- ],
- "node/no-unpublished-bin": "error",
- "node/no-unpublished-require": [
- "error",
- {
- allowModules: [
- "webpack",
- "webpack-dev-server",
- "@webpack-cli/generators",
- "@webpack-cli/init",
- "@webpack-cli/migrate",
- "@webpack-cli/utils",
- "@webpack-cli/generate-loader",
- "@webpack-cli/generate-plugin",
- "@webpack-cli/webpack-scaffold"
- ]
- }
- ],
- "node/no-extraneous-require": [
- "error",
- {
- allowModules: [
- "@webpack-cli/migrate",
- "@webpack-cli/generators",
- "@webpack-cli/utils",
- "@webpack-cli/generate-loader",
- "@webpack-cli/generate-plugin",
- "@webpack-cli/webpack-scaffold"
- ]
- }
- ],
- "node/process-exit-as-throw": "error"
- }
-};
diff --git a/node_modules/webpack-cli/bin/cli.js b/node_modules/webpack-cli/bin/cli.js
deleted file mode 100755
index 79f667b..0000000
--- a/node_modules/webpack-cli/bin/cli.js
+++ /dev/null
@@ -1,366 +0,0 @@
-#!/usr/bin/env node
-
-/*
- MIT License http://www.opensource.org/licenses/mit-license.php
- Author Tobias Koppers @sokra
-*/
-
-const { NON_COMPILATION_ARGS } = require("./utils/constants");
-
-(function() {
- // wrap in IIFE to be able to use return
-
- const importLocal = require("import-local");
- // Prefer the local installation of webpack-cli
- if (importLocal(__filename)) {
- return;
- }
-
- require("v8-compile-cache");
-
- const ErrorHelpers = require("./utils/errorHelpers");
-
- const NON_COMPILATION_CMD = process.argv.find(arg => {
- if (arg === "serve") {
- global.process.argv = global.process.argv.filter(a => a !== "serve");
- process.argv = global.process.argv;
- }
- return NON_COMPILATION_ARGS.find(a => a === arg);
- });
-
- if (NON_COMPILATION_CMD) {
- return require("./utils/prompt-command")(NON_COMPILATION_CMD, ...process.argv);
- }
-
- const yargs = require("yargs").usage(`webpack-cli ${require("../package.json").version}
-
-Usage: webpack-cli [options]
- webpack-cli [options] --entry <entry> --output <output>
- webpack-cli [options] <entries...> --output <output>
- webpack-cli <command> [options]
-
-For more information, see https://webpack.js.org/api/cli/.`);
-
- require("./config/config-yargs")(yargs);
-
- // yargs will terminate the process early when the user uses help or version.
- // This causes large help outputs to be cut short (https://github.com/nodejs/node/wiki/API-changes-between-v0.10-and-v4#process).
- // To prevent this we use the yargs.parse API and exit the process normally
- yargs.parse(process.argv.slice(2), (err, argv, output) => {
- Error.stackTraceLimit = 30;
-
- // arguments validation failed
- if (err && output) {
- console.error(output);
- process.exitCode = 1;
- return;
- }
-
- // help or version info
- if (output) {
- console.log(output);
- return;
- }
-
- if (argv.verbose) {
- argv["display"] = "verbose";
- }
-
- let options;
- try {
- options = require("./utils/convert-argv")(argv);
- } catch (err) {
- if (err.code === "MODULE_NOT_FOUND") {
- const moduleName = err.message.split("'")[1];
- let instructions = "";
- let errorMessage = "";
-
- if (moduleName === "webpack") {
- errorMessage = `\n${moduleName} not installed`;
- instructions = `Install webpack to start bundling: \u001b[32m\n $ npm install --save-dev ${moduleName}\n`;
-
- if (process.env.npm_execpath !== undefined && process.env.npm_execpath.includes("yarn")) {
- instructions = `Install webpack to start bundling: \u001b[32m\n $ yarn add ${moduleName} --dev\n`;
- }
- Error.stackTraceLimit = 1;
- console.error(`${errorMessage}\n\n${instructions}`);
- process.exitCode = 1;
- return;
- }
- }
-
- if (err.name !== "ValidationError") {
- throw err;
- }
-
- const stack = ErrorHelpers.cleanUpWebpackOptions(err.stack, err.message);
- const message = err.message + "\n" + stack;
-
- if (argv.color) {
- console.error(`\u001b[1m\u001b[31m${message}\u001b[39m\u001b[22m`);
- } else {
- console.error(message);
- }
-
- process.exitCode = 1;
- return;
- }
-
- /**
- * When --silent flag is present, an object with a no-op write method is
- * used in place of process.stout
- */
- const stdout = argv.silent ? { write: () => {} } : process.stdout;
-
- function ifArg(name, fn, init) {
- if (Array.isArray(argv[name])) {
- if (init) init();
- argv[name].forEach(fn);
- } else if (typeof argv[name] !== "undefined") {
- if (init) init();
- fn(argv[name], -1);
- }
- }
-
- function processOptions(options) {
- // process Promise
- if (typeof options.then === "function") {
- options.then(processOptions).catch(function(err) {
- console.error(err.stack || err);
- // eslint-disable-next-line no-process-exit
- process.exit(1);
- });
- return;
- }
-
- const firstOptions = [].concat(options)[0];
- const statsPresetToOptions = require("webpack").Stats.presetToOptions;
-
- let outputOptions = options.stats;
- if (typeof outputOptions === "boolean" || typeof outputOptions === "string") {
- outputOptions = statsPresetToOptions(outputOptions);
- } else if (!outputOptions) {
- outputOptions = {};
- }
-
- ifArg("display", function(preset) {
- outputOptions = statsPresetToOptions(preset);
- });
-
- outputOptions = Object.create(outputOptions);
- if (Array.isArray(options) && !outputOptions.children) {
- outputOptions.children = options.map(o => o.stats);
- }
- if (typeof outputOptions.context === "undefined") outputOptions.context = firstOptions.context;
-
- ifArg("env", function(value) {
- if (outputOptions.env) {
- outputOptions._env = value;
- }
- });
-
- ifArg("json", function(bool) {
- if (bool) {
- outputOptions.json = bool;
- outputOptions.modules = bool;
- }
- });
-
- if (typeof outputOptions.colors === "undefined") outputOptions.colors = require("supports-color").stdout;
-
- ifArg("sort-modules-by", function(value) {
- outputOptions.modulesSort = value;
- });
-
- ifArg("sort-chunks-by", function(value) {
- outputOptions.chunksSort = value;
- });
-
- ifArg("sort-assets-by", function(value) {
- outputOptions.assetsSort = value;
- });
-
- ifArg("display-exclude", function(value) {
- outputOptions.exclude = value;
- });
-
- if (!outputOptions.json) {
- if (typeof outputOptions.cached === "undefined") outputOptions.cached = false;
- if (typeof outputOptions.cachedAssets === "undefined") outputOptions.cachedAssets = false;
-
- ifArg("display-chunks", function(bool) {
- if (bool) {
- outputOptions.modules = false;
- outputOptions.chunks = true;
- outputOptions.chunkModules = true;
- }
- });
-
- ifArg("display-entrypoints", function(bool) {
- outputOptions.entrypoints = bool;
- });
-
- ifArg("display-reasons", function(bool) {
- if (bool) outputOptions.reasons = true;
- });
-
- ifArg("display-depth", function(bool) {
- if (bool) outputOptions.depth = true;
- });
-
- ifArg("display-used-exports", function(bool) {
- if (bool) outputOptions.usedExports = true;
- });
-
- ifArg("display-provided-exports", function(bool) {
- if (bool) outputOptions.providedExports = true;
- });
-
- ifArg("display-optimization-bailout", function(bool) {
- if (bool) outputOptions.optimizationBailout = bool;
- });
-
- ifArg("display-error-details", function(bool) {
- if (bool) outputOptions.errorDetails = true;
- });
-
- ifArg("display-origins", function(bool) {
- if (bool) outputOptions.chunkOrigins = true;
- });
-
- ifArg("display-max-modules", function(value) {
- outputOptions.maxModules = +value;
- });
-
- ifArg("display-cached", function(bool) {
- if (bool) outputOptions.cached = true;
- });
-
- ifArg("display-cached-assets", function(bool) {
- if (bool) outputOptions.cachedAssets = true;
- });
-
- if (!outputOptions.exclude) outputOptions.exclude = ["node_modules", "bower_components", "components"];
-
- if (argv["display-modules"]) {
- outputOptions.maxModules = Infinity;
- outputOptions.exclude = undefined;
- outputOptions.modules = true;
- }
- }
-
- ifArg("hide-modules", function(bool) {
- if (bool) {
- outputOptions.modules = false;
- outputOptions.chunkModules = false;
- }
- });
-
- ifArg("info-verbosity", function(value) {
- outputOptions.infoVerbosity = value;
- });
-
- ifArg("build-delimiter", function(value) {
- outputOptions.buildDelimiter = value;
- });
-
- const webpack = require("webpack");
-
- let lastHash = null;
- let compiler;
- try {
- compiler = webpack(options);
- } catch (err) {
- if (err.name === "WebpackOptionsValidationError") {
- if (argv.color) console.error(`\u001b[1m\u001b[31m${err.message}\u001b[39m\u001b[22m`);
- else console.error(err.message);
- // eslint-disable-next-line no-process-exit
- process.exit(1);
- }
-
- throw err;
- }
-
- if (argv.progress) {
- const ProgressPlugin = require("webpack").ProgressPlugin;
- new ProgressPlugin({
- profile: argv.profile
- }).apply(compiler);
- }
- if (outputOptions.infoVerbosity === "verbose") {
- if (argv.w) {
- compiler.hooks.watchRun.tap("WebpackInfo", compilation => {
- const compilationName = compilation.name ? compilation.name : "";
- console.error("\nCompilation " + compilationName + " starting…\n");
- });
- } else {
- compiler.hooks.beforeRun.tap("WebpackInfo", compilation => {
- const compilationName = compilation.name ? compilation.name : "";
- console.error("\nCompilation " + compilationName + " starting…\n");
- });
- }
- compiler.hooks.done.tap("WebpackInfo", compilation => {
- const compilationName = compilation.name ? compilation.name : "";
- console.error("\nCompilation " + compilationName + " finished\n");
- });
- }
-
- function compilerCallback(err, stats) {
- if (!options.watch || err) {
- // Do not keep cache anymore
- compiler.purgeInputFileSystem();
- }
- if (err) {
- lastHash = null;
- console.error(err.stack || err);
- if (err.details) console.error(err.details);
- process.exitCode = 1;
- return;
- }
- if (outputOptions.json) {
- stdout.write(JSON.stringify(stats.toJson(outputOptions), null, 2) + "\n");
- } else if (stats.hash !== lastHash) {
- lastHash = stats.hash;
- if (stats.compilation && stats.compilation.errors.length !== 0) {
- const errors = stats.compilation.errors;
- if (errors[0].name === "EntryModuleNotFoundError") {
- console.error("\n\u001b[1m\u001b[31mInsufficient number of arguments or no entry found.");
- console.error(
- "\u001b[1m\u001b[31mAlternatively, run 'webpack(-cli) --help' for usage info.\u001b[39m\u001b[22m\n"
- );
- }
- }
- const statsString = stats.toString(outputOptions);
- const delimiter = outputOptions.buildDelimiter ? `${outputOptions.buildDelimiter}\n` : "";
- if (statsString) stdout.write(`${statsString}\n${delimiter}`);
- }
- if (!options.watch && stats.hasErrors()) {
- process.exitCode = 2;
- }
- }
- if (firstOptions.watch || options.watch) {
- const watchOptions =
- firstOptions.watchOptions || options.watchOptions || firstOptions.watch || options.watch || {};
- if (watchOptions.stdin) {
- process.stdin.on("end", function(_) {
- process.exit(); // eslint-disable-line
- });
- process.stdin.resume();
- }
- compiler.watch(watchOptions, compilerCallback);
- if (outputOptions.infoVerbosity !== "none") console.error("\nwebpack is watching the files…\n");
- } else {
- compiler.run((err, stats) => {
- if (compiler.close) {
- compiler.close(err2 => {
- compilerCallback(err || err2, stats);
- });
- } else {
- compilerCallback(err, stats);
- }
- });
- }
- }
- processOptions(options);
- });
-})();
diff --git a/node_modules/webpack-cli/bin/config/config-yargs.js b/node_modules/webpack-cli/bin/config/config-yargs.js
deleted file mode 100644
index dc78f95..0000000
--- a/node_modules/webpack-cli/bin/config/config-yargs.js
+++ /dev/null
@@ -1,504 +0,0 @@
-const optionsSchema = require("../config/optionsSchema.json");
-
-const { GROUPS } = require("../utils/constants");
-
-const {
- CONFIG_GROUP,
- BASIC_GROUP,
- MODULE_GROUP,
- OUTPUT_GROUP,
- ADVANCED_GROUP,
- RESOLVE_GROUP,
- OPTIMIZE_GROUP,
- DISPLAY_GROUP
-} = GROUPS;
-
-const nestedProperties = ["anyOf", "oneOf", "allOf"];
-
-const resolveSchema = schema => {
- let current = schema;
- if (schema && typeof schema === "object" && "$ref" in schema) {
- const path = schema.$ref.split("/");
- for (const element of path) {
- if (element === "#") {
- current = optionsSchema;
- } else {
- current = current[element];
- }
- }
- }
- return current;
-};
-
-const findPropertyInSchema = (schema, property, subProperty) => {
- if (!schema) return null;
- if (subProperty) {
- if (schema[property] && typeof schema[property] === "object" && subProperty in schema[property]) {
- return resolveSchema(schema[property][subProperty]);
- }
- } else {
- if (property in schema) return resolveSchema(schema[property]);
- }
- for (const name of nestedProperties) {
- if (schema[name]) {
- for (const item of schema[name]) {
- const resolvedItem = resolveSchema(item);
- const result = findPropertyInSchema(resolvedItem, property, subProperty);
- if (result) return result;
- }
- }
- }
- return undefined;
-};
-
-const getSchemaInfo = (path, property, subProperty) => {
- const pathSegments = path.split(".");
- let current = optionsSchema;
- for (const segment of pathSegments) {
- if (segment === "*") {
- current = findPropertyInSchema(current, "additionalProperties") || findPropertyInSchema(current, "items");
- } else {
- current = findPropertyInSchema(current, "properties", segment);
- }
- if (!current) return undefined;
- }
- return findPropertyInSchema(current, property, subProperty);
-};
-
-module.exports = function(yargs) {
- yargs
- .help("help")
- .alias("help", "h")
- .version()
- .alias("version", "v")
- .options({
- config: {
- type: "string",
- describe: "Path to the config file",
- group: CONFIG_GROUP,
- defaultDescription: "webpack.config.js or webpackfile.js",
- requiresArg: true
- },
- "config-register": {
- type: "array",
- alias: "r",
- describe: "Preload one or more modules before loading the webpack configuration",
- group: CONFIG_GROUP,
- defaultDescription: "module id or path",
- requiresArg: true
- },
- "config-name": {
- type: "string",
- describe: "Name of the config to use",
- group: CONFIG_GROUP,
- requiresArg: true
- },
- env: {
- describe: "Environment passed to the config, when it is a function",
- group: CONFIG_GROUP
- },
- mode: {
- type: getSchemaInfo("mode", "type"),
- choices: getSchemaInfo("mode", "enum"),
- describe: getSchemaInfo("mode", "description"),
- group: CONFIG_GROUP,
- requiresArg: true
- },
- context: {
- type: getSchemaInfo("context", "type"),
- describe: getSchemaInfo("context", "description"),
- group: BASIC_GROUP,
- defaultDescription: "The current directory",
- requiresArg: true
- },
- entry: {
- type: "string",
- describe: getSchemaInfo("entry", "description"),
- group: BASIC_GROUP,
- requiresArg: true
- },
- "no-cache": {
- type: "boolean",
- describe: "Disables cached builds",
- group: BASIC_GROUP
- },
- "module-bind": {
- type: "string",
- describe: "Bind an extension to a loader",
- group: MODULE_GROUP,
- requiresArg: true
- },
- "module-bind-post": {
- type: "string",
- describe: "Bind an extension to a post loader",
- group: MODULE_GROUP,
- requiresArg: true
- },
- "module-bind-pre": {
- type: "string",
- describe: "Bind an extension to a pre loader",
- group: MODULE_GROUP,
- requiresArg: true
- },
- output: {
- alias: "o",
- describe: "The output path and file for compilation assets",
- group: OUTPUT_GROUP,
- requiresArg: true
- },
- "output-path": {
- type: "string",
- describe: getSchemaInfo("output.path", "description"),
- group: OUTPUT_GROUP,
- defaultDescription: "The current directory",
- requiresArg: true
- },
- "output-filename": {
- type: "string",
- describe: getSchemaInfo("output.filename", "description"),
- group: OUTPUT_GROUP,
- defaultDescription: "[name].js",
- requiresArg: true
- },
- "output-chunk-filename": {
- type: "string",
- describe: getSchemaInfo("output.chunkFilename", "description"),
- group: OUTPUT_GROUP,
- defaultDescription: "filename with [id] instead of [name] or [id] prefixed",
- requiresArg: true
- },
- "output-source-map-filename": {
- type: "string",
- describe: getSchemaInfo("output.sourceMapFilename", "description"),
- group: OUTPUT_GROUP,
- requiresArg: true
- },
- "output-public-path": {
- type: "string",
- describe: getSchemaInfo("output.publicPath", "description"),
- group: OUTPUT_GROUP,
- requiresArg: true
- },
- "output-jsonp-function": {
- type: "string",
- describe: getSchemaInfo("output.jsonpFunction", "description"),
- group: OUTPUT_GROUP,
- requiresArg: true
- },
- "output-pathinfo": {
- type: "boolean",
- describe: getSchemaInfo("output.pathinfo", "description"),
- group: OUTPUT_GROUP
- },
- "output-library": {
- type: "array",
- describe: "Expose the exports of the entry point as library",
- group: OUTPUT_GROUP,
- requiresArg: true
- },
- "output-library-target": {
- type: "string",
- describe: getSchemaInfo("output.libraryTarget", "description"),
- choices: getSchemaInfo("output.libraryTarget", "enum"),
- group: OUTPUT_GROUP,
- requiresArg: true
- },
- "records-input-path": {
- type: "string",
- describe: getSchemaInfo("recordsInputPath", "description"),
- group: ADVANCED_GROUP,
- requiresArg: true
- },
- "records-output-path": {
- type: "string",
- describe: getSchemaInfo("recordsOutputPath", "description"),
- group: ADVANCED_GROUP,
- requiresArg: true
- },
- "records-path": {
- type: "string",
- describe: getSchemaInfo("recordsPath", "description"),
- group: ADVANCED_GROUP,
- requiresArg: true
- },
- define: {
- type: "string",
- describe: "Define any free var in the bundle",
- group: ADVANCED_GROUP,
- requiresArg: true
- },
- target: {
- type: "string",
- describe: getSchemaInfo("target", "description"),
- group: ADVANCED_GROUP,
- requiresArg: true
- },
- cache: {
- type: "boolean",
- describe: getSchemaInfo("cache", "description"),
- default: null,
- group: ADVANCED_GROUP,
- defaultDescription: "It's enabled by default when watching"
- },
- watch: {
- type: "boolean",
- alias: "w",
- describe: getSchemaInfo("watch", "description"),
- group: BASIC_GROUP
- },
- "watch-stdin": {
- type: "boolean",
- alias: "stdin",
- describe: getSchemaInfo("watchOptions.stdin", "description"),
- group: ADVANCED_GROUP
- },
- "watch-aggregate-timeout": {
- describe: getSchemaInfo("watchOptions.aggregateTimeout", "description"),
- type: getSchemaInfo("watchOptions.aggregateTimeout", "type"),
- group: ADVANCED_GROUP,
- requiresArg: true
- },
- "watch-poll": {
- type: "string",
- describe: getSchemaInfo("watchOptions.poll", "description"),
- group: ADVANCED_GROUP
- },
- hot: {
- type: "boolean",
- describe: "Enables Hot Module Replacement",
- group: ADVANCED_GROUP
- },
- debug: {
- type: "boolean",
- describe: "Switch loaders to debug mode",
- group: BASIC_GROUP
- },
- devtool: {
- type: "string",
- describe: getSchemaInfo("devtool", "description"),
- group: BASIC_GROUP,
- requiresArg: true
- },
- "resolve-alias": {
- type: "string",
- describe: getSchemaInfo("resolve.alias", "description"),
- group: RESOLVE_GROUP,
- requiresArg: true
- },
- "resolve-extensions": {
- type: "array",
- describe: getSchemaInfo("resolve.alias", "description"),
- group: RESOLVE_GROUP,
- requiresArg: true
- },
- "resolve-loader-alias": {
- type: "string",
- describe: "Setup a loader alias for resolving",
- group: RESOLVE_GROUP,
- requiresArg: true
- },
- "optimize-max-chunks": {
- describe: "Try to keep the chunk count below a limit",
- group: OPTIMIZE_GROUP,
- requiresArg: true
- },
- "optimize-min-chunk-size": {
- describe: getSchemaInfo("optimization.splitChunks.minSize", "description"),
- group: OPTIMIZE_GROUP,
- requiresArg: true
- },
- "optimize-minimize": {
- type: "boolean",
- describe: getSchemaInfo("optimization.minimize", "description"),
- group: OPTIMIZE_GROUP
- },
- prefetch: {
- type: "string",
- describe: "Prefetch this request (Example: --prefetch ./file.js)",
- group: ADVANCED_GROUP,
- requiresArg: true
- },
- provide: {
- type: "string",
- describe: "Provide these modules as free vars in all modules (Example: --provide jQuery=jquery)",
- group: ADVANCED_GROUP,
- requiresArg: true
- },
- "labeled-modules": {
- type: "boolean",
- describe: "Enables labeled modules",
- group: ADVANCED_GROUP
- },
- plugin: {
- type: "string",
- describe: "Load this plugin",
- group: ADVANCED_GROUP,
- requiresArg: true
- },
- bail: {
- type: getSchemaInfo("bail", "type"),
- describe: getSchemaInfo("bail", "description"),
- group: ADVANCED_GROUP,
- default: null
- },
- profile: {
- type: "boolean",
- describe: getSchemaInfo("profile", "description"),
- group: ADVANCED_GROUP,
- default: null
- },
- d: {
- type: "boolean",
- describe: "shortcut for --debug --devtool eval-cheap-module-source-map --output-pathinfo",
- group: BASIC_GROUP
- },
- p: {
- type: "boolean",
- // eslint-disable-next-line quotes
- describe: 'shortcut for --optimize-minimize --define process.env.NODE_ENV="production"',
- group: BASIC_GROUP
- },
- silent: {
- type: "boolean",
- describe: "Prevent output from being displayed in stdout"
- },
- json: {
- type: "boolean",
- alias: "j",
- describe: "Prints the result as JSON."
- },
- progress: {
- type: "boolean",
- describe: "Print compilation progress in percentage",
- group: BASIC_GROUP
- },
- color: {
- type: "boolean",
- alias: "colors",
- default: function supportsColor() {
- return require("supports-color").stdout;
- },
- group: DISPLAY_GROUP,
- describe: "Force colors on the console"
- },
- "no-color": {
- type: "boolean",
- alias: "no-colors",
- group: DISPLAY_GROUP,
- describe: "Force no colors on the console"
- },
- "sort-modules-by": {
- type: "string",
- group: DISPLAY_GROUP,
- describe: "Sorts the modules list by property in module"
- },
- "sort-chunks-by": {
- type: "string",
- group: DISPLAY_GROUP,
- describe: "Sorts the chunks list by property in chunk"
- },
- "sort-assets-by": {
- type: "string",
- group: DISPLAY_GROUP,
- describe: "Sorts the assets list by property in asset"
- },
- "hide-modules": {
- type: "boolean",
- group: DISPLAY_GROUP,
- describe: "Hides info about modules"
- },
- "display-exclude": {
- type: "string",
- group: DISPLAY_GROUP,
- describe: "Exclude modules in the output"
- },
- "display-modules": {
- type: "boolean",
- group: DISPLAY_GROUP,
- describe: "Display even excluded modules in the output"
- },
- "display-max-modules": {
- type: "number",
- group: DISPLAY_GROUP,
- describe: "Sets the maximum number of visible modules in output"
- },
- "display-chunks": {
- type: "boolean",
- group: DISPLAY_GROUP,
- describe: "Display chunks in the output"
- },
- "display-entrypoints": {
- type: "boolean",
- group: DISPLAY_GROUP,
- describe: "Display entry points in the output"
- },
- "display-origins": {
- type: "boolean",
- group: DISPLAY_GROUP,
- describe: "Display origins of chunks in the output"
- },
- "display-cached": {
- type: "boolean",
- group: DISPLAY_GROUP,
- describe: "Display also cached modules in the output"
- },
- "display-cached-assets": {
- type: "boolean",
- group: DISPLAY_GROUP,
- describe: "Display also cached assets in the output"
- },
- "display-reasons": {
- type: "boolean",
- group: DISPLAY_GROUP,
- describe: "Display reasons about module inclusion in the output"
- },
- "display-depth": {
- type: "boolean",
- group: DISPLAY_GROUP,
- describe: "Display distance from entry point for each module"
- },
- "display-used-exports": {
- type: "boolean",
- group: DISPLAY_GROUP,
- describe: "Display information about used exports in modules (Tree Shaking)"
- },
- "display-provided-exports": {
- type: "boolean",
- group: DISPLAY_GROUP,
- describe: "Display information about exports provided from modules"
- },
- "display-optimization-bailout": {
- type: "boolean",
- group: DISPLAY_GROUP,
- describe: "Display information about why optimization bailed out for modules"
- },
- "display-error-details": {
- type: "boolean",
- group: DISPLAY_GROUP,
- describe: "Display details about errors"
- },
- display: {
- type: "string",
- choices: ["", "verbose", "detailed", "normal", "minimal", "errors-only", "none"],
- group: DISPLAY_GROUP,
- describe: "Select display preset"
- },
- verbose: {
- type: "boolean",
- group: DISPLAY_GROUP,
- describe: "Show more details"
- },
- "info-verbosity": {
- type: "string",
- default: "info",
- choices: ["none", "info", "verbose"],
- group: DISPLAY_GROUP,
- describe: "Controls the output of lifecycle messaging e.g. Started watching files..."
- },
- "build-delimiter": {
- type: "string",
- group: DISPLAY_GROUP,
- describe: "Display custom text after build output"
- }
- });
-};
diff --git a/node_modules/webpack-cli/bin/config/optionsSchema.json b/node_modules/webpack-cli/bin/config/optionsSchema.json
deleted file mode 100644
index 8e95e1b..0000000
--- a/node_modules/webpack-cli/bin/config/optionsSchema.json
+++ /dev/null
@@ -1,1989 +0,0 @@
-{
- "additionalProperties": false,
- "definitions": {
- "common.pluginFunction": {
- "description": "Function acting as plugin",
- "instanceof": "Function",
- "properties": {
- "apply": {
- "description": "The run point of the plugin, required method.",
- "instanceof": "Function"
- }
- },
- "additionalProperties": true,
- "required": [
- "apply"
- ]
- },
- "common.pluginObject": {
- "description": "Plugin instance",
- "type": "object",
- "properties": {
- "apply": {
- "description": "The run point of the plugin, required method.",
- "instanceof": "Function"
- }
- },
- "additionalProperties": true,
- "required": [
- "apply"
- ]
- },
- "common.arrayOfStringOrStringArrayValues": {
- "items": {
- "description": "string or array of strings",
- "anyOf": [
- {
- "minLength": 1,
- "type": "string"
- },
- {
- "items": {
- "description": "A non-empty string",
- "minLength": 1,
- "type": "string"
- },
- "type": "array"
- }
- ]
- },
- "type": "array"
- },
- "common.arrayOfStringValues": {
- "items": {
- "description": "A non-empty string",
- "minLength": 1,
- "type": "string"
- },
- "type": "array"
- },
- "common.nonEmptyArrayOfUniqueStringValues": {
- "items": {
- "description": "A non-empty string",
- "minLength": 1,
- "type": "string"
- },
- "minItems": 1,
- "type": "array",
- "uniqueItems": true
- },
- "entry": {
- "oneOf": [
- {
- "minProperties": 1,
- "additionalProperties": {
- "description": "An entry point with name",
- "oneOf": [
- {
- "description": "The string is resolved to a module which is loaded upon startup.",
- "minLength": 1,
- "type": "string"
- },
- {
- "description": "All modules are loaded upon startup. The last one is exported.",
- "anyOf": [
- {
- "$ref": "#/definitions/common.nonEmptyArrayOfUniqueStringValues"
- }
- ]
- }
- ]
- },
- "description": "Multiple entry bundles are created. The key is the chunk name. The value can be a string or an array.",
- "type": "object"
- },
- {
- "description": "An entry point without name. The string is resolved to a module which is loaded upon startup.",
- "minLength": 1,
- "type": "string"
- },
- {
- "description": "An entry point without name. All modules are loaded upon startup. The last one is exported.",
- "anyOf": [
- {
- "$ref": "#/definitions/common.nonEmptyArrayOfUniqueStringValues"
- }
- ]
- },
- {
- "description": "A Function returning an entry object, an entry string, an entry array or a promise to these things.",
- "instanceof": "Function"
- }
- ]
- },
- "externals": {
- "anyOf": [
- {
- "description": "An exact matched dependency becomes external. The same string is used as external dependency.",
- "type": "string"
- },
- {
- "additionalProperties": {
- "description": "The dependency used for the external",
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "object"
- },
- {
- "type": "boolean"
- }
- ]
- },
- "description": "If an dependency matches exactly a property of the object, the property value is used as dependency.",
- "type": "object"
- },
- {
- "description": "`function(context, request, callback(err, result))` The function is called on each dependency.",
- "instanceof": "Function"
- },
- {
- "description": "Every matched dependency becomes external.",
- "instanceof": "RegExp"
- },
- {
- "items": {
- "description": "External configuration",
- "anyOf": [
- {
- "$ref": "#/definitions/externals"
- }
- ]
- },
- "type": "array"
- }
- ]
- },
- "module": {
- "additionalProperties": false,
- "properties": {
- "exprContextCritical": {
- "description": "Enable warnings for full dynamic dependencies",
- "type": "boolean"
- },
- "exprContextRecursive": {
- "description": "Enable recursive directory lookup for full dynamic dependencies",
- "type": "boolean"
- },
- "exprContextRegExp": {
- "description": "Sets the default regular expression for full dynamic dependencies",
- "anyOf": [
- {
- "type": "boolean"
- },
- {
- "instanceof": "RegExp"
- }
- ]
- },
- "exprContextRequest": {
- "description": "Set the default request for full dynamic dependencies",
- "type": "string"
- },
- "noParse": {
- "description": "Don't parse files matching. It's matched against the full resolved request.",
- "anyOf": [
- {
- "items": {
- "description": "A regular expression, when matched the module is not parsed",
- "instanceof": "RegExp"
- },
- "minItems": 1,
- "type": "array"
- },
- {
- "instanceof": "RegExp"
- },
- {
- "instanceof": "Function"
- },
- {
- "items": {
- "description": "An absolute path, when the module starts with this path it is not parsed",
- "type": "string",
- "absolutePath": true
- },
- "minItems": 1,
- "type": "array"
- },
- {
- "type": "string",
- "absolutePath": true
- }
- ]
- },
- "rules": {
- "allOf": [
- {
- "$ref": "#/definitions/ruleSet-rules"
- }
- ],
- "description": "An array of rules applied for modules."
- },
- "defaultRules": {
- "description": "An array of rules applied by default for modules.",
- "anyOf": [
- {
- "$ref": "#/definitions/ruleSet-rules"
- }
- ]
- },
- "unknownContextCritical": {
- "description": "Enable warnings when using the require function in a not statically analyse-able way",
- "type": "boolean"
- },
- "unknownContextRecursive": {
- "description": "Enable recursive directory lookup when using the require function in a not statically analyse-able way",
- "type": "boolean"
- },
- "unknownContextRegExp": {
- "description": "Sets the regular expression when using the require function in a not statically analyse-able way",
- "anyOf": [
- {
- "type": "boolean"
- },
- {
- "instanceof": "RegExp"
- }
- ]
- },
- "unknownContextRequest": {
- "description": "Sets the request when using the require function in a not statically analyse-able way",
- "type": "string"
- },
- "unsafeCache": {
- "description": "Cache the resolving of module requests",
- "anyOf": [
- {
- "type": "boolean"
- },
- {
- "instanceof": "Function"
- }
- ]
- },
- "wrappedContextCritical": {
- "description": "Enable warnings for partial dynamic dependencies",
- "type": "boolean"
- },
- "wrappedContextRecursive": {
- "description": "Enable recursive directory lookup for partial dynamic dependencies",
- "type": "boolean"
- },
- "wrappedContextRegExp": {
- "description": "Set the inner regular expression for partial dynamic dependencies",
- "instanceof": "RegExp"
- },
- "strictExportPresence": {
- "description": "Emit errors instead of warnings when imported names don't exist in imported module",
- "type": "boolean"
- },
- "strictThisContextOnImports": {
- "description": "Handle the this context correctly according to the spec for namespace objects",
- "type": "boolean"
- }
- },
- "type": "object"
- },
- "output": {
- "additionalProperties": false,
- "properties": {
- "auxiliaryComment": {
- "description": "Add a comment in the UMD wrapper.",
- "anyOf": [
- {
- "description": "Append the same comment above each import style.",
- "type": "string"
- },
- {
- "additionalProperties": false,
- "description": "Set explicit comments for `commonjs`, `commonjs2`, `amd`, and `root`.",
- "properties": {
- "amd": {
- "description": "Set comment for `amd` section in UMD",
- "type": "string"
- },
- "commonjs": {
- "description": "Set comment for `commonjs` (exports) section in UMD",
- "type": "string"
- },
- "commonjs2": {
- "description": "Set comment for `commonjs2` (module.exports) section in UMD",
- "type": "string"
- },
- "root": {
- "description": "Set comment for `root` (global variable) section in UMD",
- "type": "string"
- }
- },
- "type": "object"
- }
- ]
- },
- "chunkFilename": {
- "description": "The filename of non-entry chunks as relative path inside the `output.path` directory.",
- "type": "string",
- "absolutePath": false
- },
- "webassemblyModuleFilename": {
- "description": "The filename of WebAssembly modules as relative path inside the `output.path` directory.",
- "type": "string",
- "absolutePath": false
- },
- "globalObject": {
- "description": "An expression which is used to address the global object/scope in runtime code",
- "type": "string",
- "minLength": 1
- },
- "crossOriginLoading": {
- "description": "This option enables cross-origin loading of chunks.",
- "enum": [
- false,
- "anonymous",
- "use-credentials"
- ]
- },
- "jsonpScriptType": {
- "description": "This option enables loading async chunks via a custom script type, such as script type=\"module\"",
- "enum": [
- false,
- "text/javascript",
- "module"
- ]
- },
- "chunkLoadTimeout": {
- "description": "Number of milliseconds before chunk request expires",
- "type": "number"
- },
- "devtoolFallbackModuleFilenameTemplate": {
- "description": "Similar to `output.devtoolModuleFilenameTemplate`, but used in the case of duplicate module identifiers.",
- "anyOf": [
- {
- "type": "string"
- },
- {
- "instanceof": "Function"
- }
- ]
- },
- "devtoolLineToLine": {
- "description": "Enable line to line mapped mode for all/specified modules. Line to line mapped mode uses a simple SourceMap where each line of the generated source is mapped to the same line of the original source. It’s a performance optimization. Only use it if your performance need to be better and you are sure that input lines match which generated lines.",
- "anyOf": [
- {
- "description": "`true` enables it for all modules (not recommended)",
- "type": "boolean"
- },
- {
- "description": "An object similar to `module.loaders` enables it for specific files.",
- "type": "object"
- }
- ]
- },
- "devtoolModuleFilenameTemplate": {
- "description": "Filename template string of function for the sources array in a generated SourceMap.",
- "anyOf": [
- {
- "type": "string"
- },
- {
- "instanceof": "Function"
- }
- ]
- },
- "devtoolNamespace": {
- "description": "Module namespace to use when interpolating filename template string for the sources array in a generated SourceMap. Defaults to `output.library` if not set. It's useful for avoiding runtime collisions in sourcemaps from multiple webpack projects built as libraries.",
- "type": "string"
- },
- "filename": {
- "description": "Specifies the name of each output file on disk. You must **not** specify an absolute path here! The `output.path` option determines the location on disk the files are written to, filename is used solely for naming the individual files.",
- "anyOf": [
- {
- "type": "string"
- },
- {
- "instanceof": "Function"
- }
- ],
- "absolutePath": false
- },
- "hashDigest": {
- "description": "Digest type used for the hash",
- "enum": [
- "latin1",
- "hex",
- "base64"
- ]
- },
- "hashDigestLength": {
- "description": "Number of chars which are used for the hash",
- "minimum": 1,
- "type": "number"
- },
- "hashFunction": {
- "description": "Algorithm used for generation the hash (see node.js crypto package)",
- "anyOf": [
- {
- "type": "string",
- "minLength": 1
- },
- {
- "instanceof": "Function"
- }
- ]
- },
- "hashSalt": {
- "description": "Any string which is added to the hash to salt it",
- "minLength": 1,
- "type": "string"
- },
- "hotUpdateChunkFilename": {
- "description": "The filename of the Hot Update Chunks. They are inside the output.path directory.",
- "anyOf": [
- {
- "type": "string"
- },
- {
- "instanceof": "Function"
- }
- ],
- "absolutePath": false
- },
- "hotUpdateFunction": {
- "description": "The JSONP function used by webpack for async loading of hot update chunks.",
- "type": "string"
- },
- "hotUpdateMainFilename": {
- "description": "The filename of the Hot Update Main File. It is inside the `output.path` directory.",
- "anyOf": [
- {
- "type": "string"
- },
- {
- "instanceof": "Function"
- }
- ],
- "absolutePath": false
- },
- "jsonpFunction": {
- "description": "The JSONP function used by webpack for async loading of chunks.",
- "type": "string"
- },
- "chunkCallbackName": {
- "description": "The callback function name used by webpack for loading of chunks in WebWorkers.",
- "type": "string"
- },
- "library": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "items": {
- "description": "A part of the library name",
- "type": "string"
- },
- "type": "array"
- },
- {
- "type": "object",
- "additionalProperties": false,
- "properties": {
- "root": {
- "description": "Name of the property exposed globally by a UMD library",
- "anyOf": [
- {
- "type": "string"
- },
- {
- "$ref": "#/definitions/common.arrayOfStringValues"
- }
- ]
- },
- "amd": {
- "description": "Name of the exposed AMD library in the UMD",
- "type": "string"
- },
- "commonjs": {
- "description": "Name of the exposed commonjs export in the UMD",
- "type": "string"
- }
- }
- }
- ],
- "description": "If set, export the bundle as library. `output.library` is the name."
- },
- "libraryTarget": {
- "description": "Type of library",
- "enum": [
- "var",
- "assign",
- "this",
- "window",
- "self",
- "global",
- "commonjs",
- "commonjs2",
- "commonjs-module",
- "amd",
- "umd",
- "umd2",
- "jsonp"
- ]
- },
- "libraryExport": {
- "description": "Specify which export should be exposed as library",
- "anyOf": [
- {
- "type": "string"
- },
- {
- "$ref": "#/definitions/common.arrayOfStringValues"
- }
- ]
- },
- "path": {
- "description": "The output directory as **absolute path** (required).",
- "type": "string",
- "absolutePath": true
- },
- "pathinfo": {
- "description": "Include comments with information about the modules.",
- "type": "boolean"
- },
- "publicPath": {
- "description": "The `publicPath` specifies the public URL address of the output files when referenced in a browser.",
- "anyOf": [
- {
- "type": "string"
- },
- {
- "instanceof": "Function"
- }
- ]
- },
- "sourceMapFilename": {
- "description": "The filename of the SourceMaps for the JavaScript files. They are inside the `output.path` directory.",
- "type": "string",
- "absolutePath": false
- },
- "sourcePrefix": {
- "description": "Prefixes every line of the source in the bundle with this string.",
- "type": "string"
- },
- "strictModuleExceptionHandling": {
- "description": "Handles exceptions in module loading correctly at a performance cost.",
- "type": "boolean"
- },
- "umdNamedDefine": {
- "description": "If `output.libraryTarget` is set to umd and `output.library` is set, setting this to true will name the AMD module.",
- "type": "boolean"
- }
- },
- "type": "object"
- },
- "resolve": {
- "additionalProperties": false,
- "properties": {
- "alias": {
- "description": "Redirect module requests",
- "anyOf": [
- {
- "additionalProperties": {
- "description": "New request",
- "type": "string"
- },
- "type": "object"
- },
- {
- "items": {
- "description": "Alias configuration",
- "additionalProperties": false,
- "properties": {
- "alias": {
- "description": "New request",
- "type": "string"
- },
- "name": {
- "description": "Request to be redirected",
- "type": "string"
- },
- "onlyModule": {
- "description": "Redirect only exact matching request",
- "type": "boolean"
- }
- },
- "type": "object"
- },
- "type": "array"
- }
- ]
- },
- "aliasFields": {
- "description": "Fields in the description file (package.json) which are used to redirect requests inside the module",
- "anyOf": [
- {
- "$ref": "#/definitions/common.arrayOfStringOrStringArrayValues"
- }
- ]
- },
- "cachePredicate": {
- "description": "Predicate function to decide which requests should be cached",
- "instanceof": "Function"
- },
- "cacheWithContext": {
- "description": "Include the context information in the cache identifier when caching",
- "type": "boolean"
- },
- "descriptionFiles": {
- "description": "Filenames used to find a description file",
- "anyOf": [
- {
- "$ref": "#/definitions/common.arrayOfStringValues"
- }
- ]
- },
- "enforceExtension": {
- "description": "Enforce using one of the extensions from the extensions option",
- "type": "boolean"
- },
- "enforceModuleExtension": {
- "description": "Enforce using one of the module extensions from the moduleExtensions option",
- "type": "boolean"
- },
- "extensions": {
- "description": "Extensions added to the request when trying to find the file",
- "anyOf": [
- {
- "$ref": "#/definitions/common.arrayOfStringValues"
- }
- ]
- },
- "fileSystem": {
- "description": "Filesystem for the resolver"
- },
- "mainFields": {
- "description": "Field names from the description file (package.json) which are used to find the default entry point",
- "anyOf": [
- {
- "$ref": "#/definitions/common.arrayOfStringOrStringArrayValues"
- }
- ]
- },
- "mainFiles": {
- "description": "Filenames used to find the default entry point if there is no description file or main field",
- "anyOf": [
- {
- "$ref": "#/definitions/common.arrayOfStringValues"
- }
- ]
- },
- "moduleExtensions": {
- "description": "Extensions added to the module request when trying to find the module",
- "anyOf": [
- {
- "$ref": "#/definitions/common.arrayOfStringValues"
- }
- ]
- },
- "modules": {
- "description": "Folder names or directory paths where to find modules",
- "anyOf": [
- {
- "$ref": "#/definitions/common.arrayOfStringValues"
- }
- ]
- },
- "plugins": {
- "description": "Plugins for the resolver",
- "type": "array",
- "items": {
- "description": "Plugin of type object or instanceof Function",
- "anyOf": [
- {
- "$ref": "#/definitions/common.pluginObject"
- },
- {
- "$ref": "#/definitions/common.pluginFunction"
- }
- ]
- }
- },
- "resolver": {
- "description": "Custom resolver"
- },
- "symlinks": {
- "description": "Enable resolving symlinks to the original location",
- "type": "boolean"
- },
- "concord": {
- "description": "Enable concord resolving extras",
- "type": "boolean"
- },
- "unsafeCache": {
- "description": "Enable caching of successfully resolved requests",
- "anyOf": [
- {
- "type": "boolean"
- },
- {
- "additionalProperties": true,
- "type": "object"
- }
- ]
- },
- "useSyncFileSystemCalls": {
- "description": "Use synchronous filesystem calls for the resolver",
- "type": "boolean"
- }
- },
- "type": "object"
- },
- "ruleSet-condition": {
- "anyOf": [
- {
- "instanceof": "RegExp"
- },
- {
- "minLength": 1,
- "type": "string"
- },
- {
- "instanceof": "Function"
- },
- {
- "$ref": "#/definitions/ruleSet-conditions"
- },
- {
- "additionalProperties": false,
- "properties": {
- "and": {
- "description": "Logical AND",
- "anyOf": [
- {
- "$ref": "#/definitions/ruleSet-conditions"
- }
- ]
- },
- "exclude": {
- "description": "Exclude all modules matching any of these conditions",
- "anyOf": [
- {
- "$ref": "#/definitions/ruleSet-condition"
- }
- ]
- },
- "include": {
- "description": "Exclude all modules matching not any of these conditions",
- "anyOf": [
- {
- "$ref": "#/definitions/ruleSet-condition"
- }
- ]
- },
- "not": {
- "description": "Logical NOT",
- "anyOf": [
- {
- "$ref": "#/definitions/ruleSet-conditions"
- }
- ]
- },
- "or": {
- "description": "Logical OR",
- "anyOf": [
- {
- "$ref": "#/definitions/ruleSet-conditions"
- }
- ]
- },
- "test": {
- "description": "Exclude all modules matching any of these conditions",
- "anyOf": [
- {
- "$ref": "#/definitions/ruleSet-condition"
- }
- ]
- }
- },
- "type": "object"
- }
- ]
- },
- "ruleSet-conditions": {
- "items": {
- "description": "A rule condition",
- "anyOf": [
- {
- "$ref": "#/definitions/ruleSet-condition"
- }
- ]
- },
- "type": "array"
- },
- "ruleSet-loader": {
- "minLength": 1,
- "type": "string"
- },
- "ruleSet-query": {
- "anyOf": [
- {
- "type": "object"
- },
- {
- "type": "string"
- }
- ]
- },
- "ruleSet-rule": {
- "additionalProperties": false,
- "properties": {
- "enforce": {
- "description": "Enforce this rule as pre or post step",
- "enum": [
- "pre",
- "post"
- ]
- },
- "exclude": {
- "description": "Shortcut for resource.exclude",
- "allOf": [
- {
- "$ref": "#/definitions/ruleSet-condition"
- },
- {
- "absolutePath": true
- }
- ]
- },
- "include": {
- "description": "Shortcut for resource.include",
- "allOf": [
- {
- "$ref": "#/definitions/ruleSet-condition"
- },
- {
- "absolutePath": true
- }
- ]
- },
- "issuer": {
- "description": "Match the issuer of the module (The module pointing to this module)",
- "allOf": [
- {
- "$ref": "#/definitions/ruleSet-condition"
- },
- {
- "absolutePath": true
- }
- ]
- },
- "loader": {
- "description": "Shortcut for use.loader",
- "anyOf": [
- {
- "$ref": "#/definitions/ruleSet-loader"
- },
- {
- "$ref": "#/definitions/ruleSet-use"
- }
- ]
- },
- "loaders": {
- "description": "Shortcut for use.loader",
- "anyOf": [
- {
- "$ref": "#/definitions/ruleSet-use"
- }
- ]
- },
- "oneOf": {
- "description": "Only execute the first matching rule in this array",
- "anyOf": [
- {
- "$ref": "#/definitions/ruleSet-rules"
- }
- ]
- },
- "options": {
- "description": "Shortcut for use.options",
- "anyOf": [
- {
- "$ref": "#/definitions/ruleSet-query"
- }
- ]
- },
- "parser": {
- "description": "Options for parsing",
- "additionalProperties": true,
- "type": "object"
- },
- "resolve": {
- "description": "Options for the resolver",
- "type": "object",
- "anyOf": [
- {
- "$ref": "#/definitions/resolve"
- }
- ]
- },
- "sideEffects": {
- "description": "Flags a module as with or without side effects",
- "type": "boolean"
- },
- "query": {
- "description": "Shortcut for use.query",
- "anyOf": [
- {
- "$ref": "#/definitions/ruleSet-query"
- }
- ]
- },
- "type": {
- "description": "Module type to use for the module",
- "enum": [
- "javascript/auto",
- "javascript/dynamic",
- "javascript/esm",
- "json",
- "webassembly/experimental"
- ]
- },
- "resource": {
- "description": "Match the resource path of the module",
- "allOf": [
- {
- "$ref": "#/definitions/ruleSet-condition"
- },
- {
- "absolutePath": true
- }
- ]
- },
- "resourceQuery": {
- "description": "Match the resource query of the module",
- "anyOf": [
- {
- "$ref": "#/definitions/ruleSet-condition"
- }
- ]
- },
- "compiler": {
- "description": "Match the child compiler name",
- "anyOf": [
- {
- "$ref": "#/definitions/ruleSet-condition"
- }
- ]
- },
- "rules": {
- "description": "Match and execute these rules when this rule is matched",
- "anyOf": [
- {
- "$ref": "#/definitions/ruleSet-rules"
- }
- ]
- },
- "test": {
- "description": "Shortcut for resource.test",
- "allOf": [
- {
- "$ref": "#/definitions/ruleSet-condition"
- },
- {
- "absolutePath": true
- }
- ]
- },
- "use": {
- "description": "Modifiers applied to the module when rule is matched",
- "anyOf": [
- {
- "$ref": "#/definitions/ruleSet-use"
- }
- ]
- }
- },
- "type": "object"
- },
- "ruleSet-rules": {
- "items": {
- "description": "A rule",
- "anyOf": [
- {
- "$ref": "#/definitions/ruleSet-rule"
- }
- ]
- },
- "type": "array"
- },
- "ruleSet-use": {
- "anyOf": [
- {
- "$ref": "#/definitions/ruleSet-use-item"
- },
- {
- "instanceof": "Function"
- },
- {
- "items": {
- "description": "An use item",
- "anyOf": [
- {
- "$ref": "#/definitions/ruleSet-use-item"
- }
- ]
- },
- "type": "array"
- }
- ]
- },
- "ruleSet-use-item": {
- "anyOf": [
- {
- "$ref": "#/definitions/ruleSet-loader"
- },
- {
- "instanceof": "Function"
- },
- {
- "additionalProperties": false,
- "properties": {
- "loader": {
- "description": "Loader name",
- "anyOf": [
- {
- "$ref": "#/definitions/ruleSet-loader"
- }
- ]
- },
- "options": {
- "description": "Loader options",
- "anyOf": [
- {
- "$ref": "#/definitions/ruleSet-query"
- }
- ]
- },
- "ident": {
- "description": "Unique loader identifier",
- "type": "string"
- },
- "query": {
- "description": "Loader query",
- "anyOf": [
- {
- "$ref": "#/definitions/ruleSet-query"
- }
- ]
- }
- },
- "type": "object"
- }
- ]
- },
- "filter-item-types": {
- "anyOf": [
- {
- "instanceof": "RegExp"
- },
- {
- "type": "string"
- },
- {
- "instanceof": "Function"
- }
- ]
- },
- "filter-types": {
- "anyOf": [
- {
- "$ref": "#/definitions/filter-item-types"
- },
- {
- "type": "array",
- "items": {
- "description": "Rule to filter",
- "anyOf": [
- {
- "$ref": "#/definitions/filter-item-types"
- }
- ]
- }
- }
- ]
- }
- },
- "properties": {
- "mode": {
- "description": "Enable production optimizations or development hints.",
- "enum": [
- "development",
- "production",
- "none"
- ]
- },
- "amd": {
- "description": "Set the value of `require.amd` and `define.amd`."
- },
- "bail": {
- "description": "Report the first error as a hard error instead of tolerating it.",
- "type": "boolean"
- },
- "cache": {
- "description": "Cache generated modules and chunks to improve performance for multiple incremental builds.",
- "anyOf": [
- {
- "description": "You can pass `false` to disable it.",
- "type": "boolean"
- },
- {
- "description": "You can pass an object to enable it and let webpack use the passed object as cache. This way you can share the cache object between multiple compiler calls.",
- "type": "object"
- }
- ]
- },
- "context": {
- "description": "The base directory (absolute path!) for resolving the `entry` option. If `output.pathinfo` is set, the included pathinfo is shortened to this directory.",
- "type": "string",
- "absolutePath": true
- },
- "dependencies": {
- "description": "References to other configurations to depend on.",
- "items": {
- "description": "References to another configuration to depend on.",
- "type": "string"
- },
- "type": "array"
- },
- "devServer": {
- "description": "Options for the webpack-dev-server",
- "type": "object"
- },
- "devtool": {
- "description": "A developer tool to enhance debugging.",
- "anyOf": [
- {
- "type": "string"
- },
- {
- "enum": [
- false
- ]
- }
- ]
- },
- "entry": {
- "description": "The entry point(s) of the compilation.",
- "anyOf": [
- {
- "$ref": "#/definitions/entry"
- }
- ]
- },
- "externals": {
- "description": "Specify dependencies that shouldn't be resolved by webpack, but should become dependencies of the resulting bundle. The kind of the dependency depends on `output.libraryTarget`.",
- "anyOf": [
- {
- "$ref": "#/definitions/externals"
- }
- ]
- },
- "loader": {
- "description": "Custom values available in the loader context.",
- "type": "object"
- },
- "module": {
- "description": "Options affecting the normal modules (`NormalModuleFactory`).",
- "anyOf": [
- {
- "$ref": "#/definitions/module"
- }
- ]
- },
- "name": {
- "description": "Name of the configuration. Used when loading multiple configurations.",
- "type": "string"
- },
- "node": {
- "description": "Include polyfills or mocks for various node stuff.",
- "anyOf": [
- {
- "enum": [
- false
- ]
- },
- {
- "additionalProperties": {
- "description": "Include a polyfill for the node.js module",
- "enum": [
- false,
- true,
- "mock",
- "empty"
- ]
- },
- "properties": {
- "Buffer": {
- "description": "Include a polyfill for the 'Buffer' variable",
- "enum": [
- false,
- true,
- "mock"
- ]
- },
- "__dirname": {
- "description": "Include a polyfill for the '__dirname' variable",
- "enum": [
- false,
- true,
- "mock"
- ]
- },
- "__filename": {
- "description": "Include a polyfill for the '__filename' variable",
- "enum": [
- false,
- true,
- "mock"
- ]
- },
- "console": {
- "description": "Include a polyfill for the 'console' variable",
- "enum": [
- false,
- true,
- "mock"
- ]
- },
- "global": {
- "description": "Include a polyfill for the 'global' variable",
- "type": "boolean"
- },
- "process": {
- "description": "Include a polyfill for the 'process' variable",
- "enum": [
- false,
- true,
- "mock"
- ]
- }
- },
- "type": "object"
- }
- ]
- },
- "output": {
- "description": "Options affecting the output of the compilation. `output` options tell webpack how to write the compiled files to disk.",
- "anyOf": [
- {
- "$ref": "#/definitions/output"
- }
- ]
- },
- "optimization": {
- "description": "Enables/Disables integrated optimizations",
- "type": "object",
- "additionalProperties": false,
- "properties": {
- "removeAvailableModules": {
- "description": "Removes modules from chunks when these modules are already included in all parents",
- "type": "boolean"
- },
- "removeEmptyChunks": {
- "description": "Remove chunks which are empty",
- "type": "boolean"
- },
- "mergeDuplicateChunks": {
- "description": "Merge chunks which contain the same modules",
- "type": "boolean"
- },
- "flagIncludedChunks": {
- "description": "Also flag chunks as loaded which contain a subset of the modules",
- "type": "boolean"
- },
- "occurrenceOrder": {
- "description": "Figure out a order of modules which results in the smallest initial bundle",
- "type": "boolean"
- },
- "sideEffects": {
- "description": "Skip over modules which are flagged to contain no side effects when exports are not used",
- "type": "boolean"
- },
- "providedExports": {
- "description": "Figure out which exports are provided by modules to generate more efficient code",
- "type": "boolean"
- },
- "usedExports": {
- "description": "Figure out which exports are used by modules to mangle export names, omit unused exports and generate more efficient code",
- "type": "boolean"
- },
- "concatenateModules": {
- "description": "Concatenate modules when possible to generate less modules, more efficient code and enable more optimizations by the minimizer",
- "type": "boolean"
- },
- "splitChunks": {
- "description": "Optimize duplication and caching by splitting chunks by shared modules and cache group",
- "oneOf": [
- {
- "enum": [
- false
- ]
- },
- {
- "type": "object",
- "additionalProperties": false,
- "properties": {
- "chunks": {
- "description": "Select chunks for determining shared modules (defaults to \"async\", \"initial\" and \"all\" requires adding these chunks to the HTML)",
- "oneOf": [
- {
- "enum": [
- "initial",
- "async",
- "all"
- ]
- },
- {
- "instanceof": "Function"
- }
- ]
- },
- "minSize": {
- "description": "Minimal size for the created chunk",
- "type": "number",
- "minimum": 0
- },
- "minChunks": {
- "description": "Minimum number of times a module has to be duplicated until it's considered for splitting",
- "type": "number",
- "minimum": 1
- },
- "maxAsyncRequests": {
- "description": "Maximum number of requests which are accepted for on-demand loading",
- "type": "number",
- "minimum": 1
- },
- "maxInitialRequests": {
- "description": "Maximum number of initial chunks which are accepted for an entry point",
- "type": "number",
- "minimum": 1
- },
- "name": {
- "description": "Give chunks created a name (chunks with equal name are merged)",
- "oneOf": [
- {
- "type": "boolean"
- },
- {
- "instanceof": "Function"
- },
- {
- "type": "string"
- }
- ]
- },
- "filename": {
- "description": "Sets the template for the filename for created chunks (Only works for initial chunks)",
- "type": "string",
- "minLength": 1
- },
- "automaticNameDelimiter": {
- "description": "Sets the name delimiter for created chunks",
- "type": "string",
- "minLength": 1
- },
- "cacheGroups": {
- "description": "Assign modules to a cache group (modules from different cache groups are tried to keep in separate chunks)",
- "type": "object",
- "additionalProperties": {
- "description": "Configuration for a cache group",
- "anyOf": [
- {
- "enum": [
- false
- ]
- },
- {
- "instanceof": "Function"
- },
- {
- "type": "string"
- },
- {
- "instanceof": "RegExp"
- },
- {
- "type": "object",
- "additionalProperties": false,
- "properties": {
- "test": {
- "description": "Assign modules to a cache group",
- "oneOf": [
- {
- "instanceof": "Function"
- },
- {
- "type": "string"
- },
- {
- "instanceof": "RegExp"
- }
- ]
- },
- "chunks": {
- "description": "Select chunks for determining cache group content (defaults to \"initial\", \"initial\" and \"all\" requires adding these chunks to the HTML)",
- "oneOf": [
- {
- "enum": [
- "initial",
- "async",
- "all"
- ]
- },
- {
- "instanceof": "Function"
- }
- ]
- },
- "enforce": {
- "description": "Ignore minimum size, minimum chunks and maximum requests and always create chunks for this cache group",
- "type": "boolean"
- },
- "priority": {
- "description": "Priority of this cache group",
- "type": "number"
- },
- "minSize": {
- "description": "Minimal size for the created chunk",
- "type": "number",
- "minimum": 0
- },
- "minChunks": {
- "description": "Minimum number of times a module has to be duplicated until it's considered for splitting",
- "type": "number",
- "minimum": 1
- },
- "maxAsyncRequests": {
- "description": "Maximum number of requests which are accepted for on-demand loading",
- "type": "number",
- "minimum": 1
- },
- "maxInitialRequests": {
- "description": "Maximum number of initial chunks which are accepted for an entry point",
- "type": "number",
- "minimum": 1
- },
- "reuseExistingChunk": {
- "description": "Try to reuse existing chunk (with name) when it has matching modules",
- "type": "boolean"
- },
- "name": {
- "description": "Give chunks for this cache group a name (chunks with equal name are merged)",
- "oneOf": [
- {
- "type": "boolean"
- },
- {
- "instanceof": "Function"
- },
- {
- "type": "string"
- }
- ]
- },
- "filename": {
- "description": "Sets the template for the filename for created chunks (Only works for initial chunks)",
- "type": "string",
- "minLength": 1
- }
- }
- }
- ]
- }
- }
- }
- }
- ]
- },
- "runtimeChunk": {
- "description": "Create an additional chunk which contains only the webpack runtime and chunk hash maps",
- "oneOf": [
- {
- "type": "boolean"
- },
- {
- "enum": [
- "single",
- "multiple"
- ]
- },
- {
- "type": "object",
- "additionalProperties": false,
- "properties": {
- "name": {
- "description": "The name or name factory for the runtime chunks",
- "oneOf": [
- {
- "type": "string"
- },
- {
- "instanceof": "Function"
- }
- ]
- }
- }
- }
- ]
- },
- "noEmitOnErrors": {
- "description": "Avoid emitting assets when errors occur",
- "type": "boolean"
- },
- "namedModules": {
- "description": "Use readable module identifiers for better debugging",
- "type": "boolean"
- },
- "namedChunks": {
- "description": "Use readable chunk identifiers for better debugging",
- "type": "boolean"
- },
- "portableRecords": {
- "description": "Generate records with relative paths to be able to move the context folder",
- "type": "boolean"
- },
- "minimize": {
- "description": "Enable minimizing the output. Uses optimization.minimizer.",
- "type": "boolean"
- },
- "minimizer": {
- "description": "Minimizer(s) to use for minimizing the output",
- "type": "array",
- "items": {
- "description": "Plugin of type object or instanceof Function",
- "anyOf": [
- {
- "$ref": "#/definitions/common.pluginObject"
- },
- {
- "$ref": "#/definitions/common.pluginFunction"
- }
- ]
- }
- },
- "nodeEnv": {
- "description": "Set process.env.NODE_ENV to a specific value",
- "anyOf": [
- {
- "enum": [
- false
- ]
- },
- {
- "type": "string"
- }
- ]
- }
- }
- },
- "parallelism": {
- "description": "The number of parallel processed modules in the compilation.",
- "minimum": 1,
- "type": "number"
- },
- "performance": {
- "description": "Configuration for web performance recommendations.",
- "anyOf": [
- {
- "enum": [
- false
- ]
- },
- {
- "additionalProperties": false,
- "properties": {
- "assetFilter": {
- "description": "Filter function to select assets that are checked",
- "instanceof": "Function"
- },
- "hints": {
- "description": "Sets the format of the hints: warnings, errors or nothing at all",
- "enum": [
- false,
- "warning",
- "error"
- ]
- },
- "maxEntrypointSize": {
- "description": "Total size of an entry point (in bytes)",
- "type": "number"
- },
- "maxAssetSize": {
- "description": "Filesize limit (in bytes) when exceeded, that webpack will provide performance hints",
- "type": "number"
- }
- },
- "type": "object"
- }
- ]
- },
- "plugins": {
- "description": "Add additional plugins to the compiler.",
- "type": "array",
- "items": {
- "description": "Plugin of type object or instanceof Function",
- "anyOf": [
- {
- "$ref": "#/definitions/common.pluginObject"
- },
- {
- "$ref": "#/definitions/common.pluginFunction"
- }
- ]
- }
- },
- "profile": {
- "description": "Capture timing information for each module.",
- "type": "boolean"
- },
- "recordsInputPath": {
- "description": "Store compiler state to a json file.",
- "type": "string",
- "absolutePath": true
- },
- "recordsOutputPath": {
- "description": "Load compiler state from a json file.",
- "type": "string",
- "absolutePath": true
- },
- "recordsPath": {
- "description": "Store/Load compiler state from/to a json file. This will result in persistent ids of modules and chunks. An absolute path is expected. `recordsPath` is used for `recordsInputPath` and `recordsOutputPath` if they left undefined.",
- "type": "string",
- "absolutePath": true
- },
- "resolve": {
- "description": "Options for the resolver",
- "anyOf": [
- {
- "$ref": "#/definitions/resolve"
- }
- ]
- },
- "resolveLoader": {
- "description": "Options for the resolver when resolving loaders",
- "anyOf": [
- {
- "$ref": "#/definitions/resolve"
- }
- ]
- },
- "serve": {
- "description": "Options for webpack-dev-server",
- "type": "object"
- },
- "stats": {
- "description": "Used by the webpack CLI program to pass stats options.",
- "anyOf": [
- {
- "type": "object",
- "additionalProperties": false,
- "properties": {
- "all": {
- "type": "boolean",
- "description": "fallback value for stats options when an option is not defined (has precedence over local webpack defaults)"
- },
- "context": {
- "type": "string",
- "description": "context directory for request shortening",
- "absolutePath": true
- },
- "hash": {
- "type": "boolean",
- "description": "add the hash of the compilation"
- },
- "version": {
- "type": "boolean",
- "description": "add webpack version information"
- },
- "timings": {
- "type": "boolean",
- "description": "add timing information"
- },
- "builtAt": {
- "type": "boolean",
- "description": "add built at time information"
- },
- "performance": {
- "type": "boolean",
- "description": "add performance hint flags"
- },
- "depth": {
- "type": "boolean",
- "description": "add module depth in module graph"
- },
- "assets": {
- "type": "boolean",
- "description": "add assets information"
- },
- "env": {
- "type": "boolean",
- "description": "add --env information"
- },
- "colors": {
- "description": "Enables/Disables colorful output",
- "oneOf": [
- {
- "type": "boolean",
- "description": "`webpack --colors` equivalent"
- },
- {
- "type": "object",
- "additionalProperties": false,
- "properties": {
- "bold": {
- "description": "Custom color for bold text",
- "type": "string"
- },
- "red": {
- "description": "Custom color for red text",
- "type": "string"
- },
- "green": {
- "description": "Custom color for green text",
- "type": "string"
- },
- "cyan": {
- "description": "Custom color for cyan text",
- "type": "string"
- },
- "magenta": {
- "description": "Custom color for magenta text",
- "type": "string"
- },
- "yellow": {
- "description": "Custom color for yellow text",
- "type": "string"
- }
- }
- }
- ]
- },
- "maxModules": {
- "type": "number",
- "description": "Set the maximum number of modules to be shown"
- },
- "chunks": {
- "type": "boolean",
- "description": "add chunk information"
- },
- "chunkModules": {
- "type": "boolean",
- "description": "add built modules information to chunk information"
- },
- "modules": {
- "type": "boolean",
- "description": "add built modules information"
- },
- "nestedModules": {
- "type": "boolean",
- "description": "add information about modules nested in other modules (like with module concatenation)"
- },
- "moduleAssets": {
- "type": "boolean",
- "description": "add information about assets inside modules"
- },
- "children": {
- "type": "boolean",
- "description": "add children information"
- },
- "cached": {
- "type": "boolean",
- "description": "add also information about cached (not built) modules"
- },
- "cachedAssets": {
- "type": "boolean",
- "description": "Show cached assets (setting this to `false` only shows emitted files)"
- },
- "reasons": {
- "type": "boolean",
- "description": "add information about the reasons why modules are included"
- },
- "source": {
- "type": "boolean",
- "description": "add the source code of modules"
- },
- "warnings": {
- "type": "boolean",
- "description": "add warnings"
- },
- "errors": {
- "type": "boolean",
- "description": "add errors"
- },
- "warningsFilter": {
- "description": "Suppress warnings that match the specified filters. Filters can be Strings, RegExps or Functions",
- "anyOf": [
- {
- "$ref": "#/definitions/filter-types"
- }
- ]
- },
- "excludeAssets": {
- "description": "Suppress assets that match the specified filters. Filters can be Strings, RegExps or Functions",
- "anyOf": [
- {
- "$ref": "#/definitions/filter-types"
- }
- ]
- },
- "excludeModules": {
- "description": "Suppress modules that match the specified filters. Filters can be Strings, RegExps, Booleans or Functions",
- "anyOf": [
- {
- "$ref": "#/definitions/filter-types"
- },
- {
- "type": "boolean"
- }
- ]
- },
- "exclude": {
- "description": "Please use excludeModules instead.",
- "anyOf": [
- {
- "$ref": "#/definitions/filter-types"
- },
- {
- "type": "boolean"
- }
- ]
- },
- "entrypoints": {
- "type": "boolean",
- "description": "Display the entry points with the corresponding bundles"
- },
- "chunkGroups": {
- "type": "boolean",
- "description": "Display all chunk groups with the corresponding bundles"
- },
- "errorDetails": {
- "type": "boolean",
- "description": "add details to errors (like resolving log)"
- },
- "chunkOrigins": {
- "type": "boolean",
- "description": "add the origins of chunks and chunk merging info"
- },
- "modulesSort": {
- "type": "string",
- "description": "sort the modules by that field"
- },
- "moduleTrace": {
- "type": "boolean",
- "description": "add dependencies and origin of warnings/errors"
- },
- "chunksSort": {
- "type": "string",
- "description": "sort the chunks by that field"
- },
- "assetsSort": {
- "type": "string",
- "description": "sort the assets by that field"
- },
- "publicPath": {
- "type": "boolean",
- "description": "Add public path information"
- },
- "outputPath": {
- "type": "boolean",
- "description": "Add output path information"
- },
- "providedExports": {
- "type": "boolean",
- "description": "show exports provided by modules"
- },
- "usedExports": {
- "type": "boolean",
- "description": "show exports used by modules"
- },
- "optimizationBailout": {
- "type": "boolean",
- "description": "show reasons why optimization bailed out for modules"
- }
- }
- },
- {
- "type": "boolean"
- },
- {
- "enum": [
- "none",
- "errors-only",
- "minimal",
- "normal",
- "detailed",
- "verbose"
- ]
- }
- ]
- },
- "target": {
- "description": "Environment to build for",
- "anyOf": [
- {
- "enum": [
- "web",
- "webworker",
- "node",
- "async-node",
- "node-webkit",
- "electron-main",
- "electron-renderer"
- ]
- },
- {
- "instanceof": "Function"
- }
- ]
- },
- "watch": {
- "description": "Enter watch mode, which rebuilds on file change.",
- "type": "boolean"
- },
- "watchOptions": {
- "description": "Options for the watcher",
- "additionalProperties": false,
- "properties": {
- "aggregateTimeout": {
- "description": "Delay the rebuilt after the first change. Value is a time in ms.",
- "type": "number"
- },
- "ignored": {
- "description": "Ignore some files from watching"
- },
- "stdin": {
- "description": "Stop watching when stdin stream has ended",
- "type": "boolean"
- },
- "poll": {
- "description": "Enable polling mode for watching",
- "anyOf": [
- {
- "description": "`true`: use polling.",
- "type": "boolean"
- },
- {
- "description": "`number`: use polling with specified interval.",
- "type": "number"
- }
- ]
- }
- },
- "type": "object"
- }
- },
- "type": "object"
- }
- \ No newline at end of file
diff --git a/node_modules/webpack-cli/bin/config/webpackConfigurationSchema.json b/node_modules/webpack-cli/bin/config/webpackConfigurationSchema.json
deleted file mode 100644
index e05f443..0000000
--- a/node_modules/webpack-cli/bin/config/webpackConfigurationSchema.json
+++ /dev/null
@@ -1,20 +0,0 @@
-{
- "anyOf": [
- {
- "type": "object",
- "description": "A webpack configuration object."
- },
- {
- "type": "array",
- "description": "An array of webpack configuration objects.",
- "items": {
- "description": "A webpack configuration object.",
- "type": "object"
- }
- },
- {
- "instanceof": "Promise",
- "description": "A promise that resolves with a configuration object, or an array of configuration objects."
- }
- ]
-}
diff --git a/node_modules/webpack-cli/bin/utils/constants.js b/node_modules/webpack-cli/bin/utils/constants.js
deleted file mode 100644
index 5531369..0000000
--- a/node_modules/webpack-cli/bin/utils/constants.js
+++ /dev/null
@@ -1,28 +0,0 @@
-const NON_COMPILATION_ARGS = ["init", "migrate", "serve", "generate-loader", "generate-plugin", "info"];
-
-const CONFIG_GROUP = "Config options:";
-const BASIC_GROUP = "Basic options:";
-const MODULE_GROUP = "Module options:";
-const OUTPUT_GROUP = "Output options:";
-const ADVANCED_GROUP = "Advanced options:";
-const RESOLVE_GROUP = "Resolving options:";
-const OPTIMIZE_GROUP = "Optimizing options:";
-const DISPLAY_GROUP = "Stats options:";
-const GROUPS = {
- CONFIG_GROUP,
- BASIC_GROUP,
- MODULE_GROUP,
- OUTPUT_GROUP,
- ADVANCED_GROUP,
- RESOLVE_GROUP,
- OPTIMIZE_GROUP,
- DISPLAY_GROUP
-};
-
-const WEBPACK_OPTIONS_FLAG = "WEBPACK_OPTIONS";
-
-module.exports = {
- NON_COMPILATION_ARGS,
- GROUPS,
- WEBPACK_OPTIONS_FLAG
-};
diff --git a/node_modules/webpack-cli/bin/utils/convert-argv.js b/node_modules/webpack-cli/bin/utils/convert-argv.js
deleted file mode 100644
index 8b61e17..0000000
--- a/node_modules/webpack-cli/bin/utils/convert-argv.js
+++ /dev/null
@@ -1,562 +0,0 @@
-const path = require("path");
-const fs = require("fs");
-fs.existsSync = fs.existsSync || path.existsSync;
-const interpret = require("interpret");
-const prepareOptions = require("./prepareOptions");
-const findup = require("findup-sync");
-const validateOptions = require("./validate-options");
-
-module.exports = function(...args) {
- const argv = args[1] || args[0];
- const options = [];
- // Shortcuts
- if (argv.d) {
- argv.debug = true;
- argv["output-pathinfo"] = true;
- if (!argv.devtool) {
- argv.devtool = "eval-cheap-module-source-map";
- }
- if (!argv.mode) {
- argv.mode = "development";
- }
- }
- if (argv.p) {
- argv["optimize-minimize"] = true;
- // eslint-disable-next-line quotes
- argv["define"] = [].concat(argv["define"] || []).concat('process.env.NODE_ENV="production"');
- if (!argv.mode) {
- argv.mode = "production";
- }
- }
-
- if (argv.output) {
- let output = argv.output;
- if (!path.isAbsolute(argv.o)) {
- output = path.resolve(process.cwd(), output);
- }
- argv["output-filename"] = path.basename(output);
- argv["output-path"] = path.dirname(output);
- }
-
- let configFileLoaded = false;
- let configFiles = [];
- const extensions = Object.keys(interpret.extensions).sort(function(a, b) {
- return a === ".js" ? -1 : b === ".js" ? 1 : a.length - b.length;
- });
-
- let i;
- if (argv.config) {
- const getConfigExtension = function getConfigExtension(configPath) {
- for (i = extensions.length - 1; i >= 0; i--) {
- const tmpExt = extensions[i];
- if (configPath.indexOf(tmpExt, configPath.length - tmpExt.length) > -1) {
- return tmpExt;
- }
- }
- return path.extname(configPath);
- };
-
- const mapConfigArg = function mapConfigArg(configArg) {
- const resolvedPath = path.resolve(configArg);
- const extension = getConfigExtension(resolvedPath);
- return {
- path: resolvedPath,
- ext: extension
- };
- };
-
- const configArgList = Array.isArray(argv.config) ? argv.config : [argv.config];
- configFiles = configArgList.map(mapConfigArg);
- } else {
- const defaultConfigFileNames = ["webpack.config", "webpackfile"].join("|");
- const webpackConfigFileRegExp = `(${defaultConfigFileNames})(${extensions.join("|")})`;
- const pathToWebpackConfig = findup(webpackConfigFileRegExp);
-
- if (pathToWebpackConfig) {
- const resolvedPath = path.resolve(pathToWebpackConfig);
- const actualConfigFileName = path.basename(resolvedPath);
- const ext = actualConfigFileName.replace(new RegExp(defaultConfigFileNames), "");
- configFiles.push({
- path: resolvedPath,
- ext
- });
- }
- }
- if (configFiles.length > 0) {
- const registerCompiler = function registerCompiler(moduleDescriptor) {
- if (moduleDescriptor) {
- if (typeof moduleDescriptor === "string") {
- require(moduleDescriptor);
- } else if (!Array.isArray(moduleDescriptor)) {
- moduleDescriptor.register(require(moduleDescriptor.module));
- } else {
- for (let i = 0; i < moduleDescriptor.length; i++) {
- try {
- registerCompiler(moduleDescriptor[i]);
- break;
- } catch (e) {
- // do nothing
- }
- }
- }
- }
- };
-
- const requireConfig = function requireConfig(configPath) {
- let options = (function WEBPACK_OPTIONS() {
- if (argv.configRegister && argv.configRegister.length) {
- module.paths.unshift(path.resolve(process.cwd(), "node_modules"), process.cwd());
- argv.configRegister.forEach(dep => {
- require(dep);
- });
- return require(path.resolve(process.cwd(), configPath));
- } else {
- return require(path.resolve(process.cwd(), configPath));
- }
- })();
- options = prepareOptions(options, argv);
- return options;
- };
-
- configFiles.forEach(function(file) {
- registerCompiler(interpret.extensions[file.ext]);
- options.push(requireConfig(file.path));
- });
- configFileLoaded = true;
- }
-
- if (!configFileLoaded) {
- return processConfiguredOptions();
- } else if (options.length === 1) {
- return processConfiguredOptions(options[0]);
- } else {
- return processConfiguredOptions(options);
- }
-
- function processConfiguredOptions(options) {
- if (options) {
- validateOptions(options);
- } else {
- options = {};
- }
-
- // process Promise
- if (typeof options.then === "function") {
- return options.then(processConfiguredOptions);
- }
-
- // process ES6 default
- if (typeof options === "object" && typeof options.default === "object") {
- return processConfiguredOptions(options.default);
- }
-
- // filter multi-config by name
- if (Array.isArray(options) && argv["config-name"]) {
- const namedOptions = options.filter(function(opt) {
- return opt.name === argv["config-name"];
- });
- if (namedOptions.length === 0) {
- console.error("Configuration with name '" + argv["config-name"] + "' was not found.");
- process.exit(-1); // eslint-disable-line
- } else if (namedOptions.length === 1) {
- return processConfiguredOptions(namedOptions[0]);
- }
- options = namedOptions;
- }
-
- if (Array.isArray(options)) {
- options.forEach(processOptions);
- } else {
- processOptions(options);
- }
-
- if (argv.context) {
- options.context = path.resolve(argv.context);
- }
- if (!options.context) {
- options.context = process.cwd();
- }
-
- if (argv.watch) {
- options.watch = true;
- }
-
- if (argv["watch-aggregate-timeout"]) {
- options.watchOptions = options.watchOptions || {};
- options.watchOptions.aggregateTimeout = +argv["watch-aggregate-timeout"];
- }
-
- if (typeof argv["watch-poll"] !== "undefined") {
- options.watchOptions = options.watchOptions || {};
- if (argv["watch-poll"] === "true" || argv["watch-poll"] === "") options.watchOptions.poll = true;
- else if (!isNaN(argv["watch-poll"])) options.watchOptions.poll = +argv["watch-poll"];
- }
-
- if (argv["watch-stdin"]) {
- options.watchOptions = options.watchOptions || {};
- options.watchOptions.stdin = true;
- options.watch = true;
- }
-
- return options;
- }
-
- function processOptions(options) {
- function ifArg(name, fn, init, finalize) {
- const isArray = Array.isArray(argv[name]);
- const isSet = typeof argv[name] !== "undefined" && argv[name] !== null;
- if (!isArray && !isSet) return;
-
- init && init();
- if (isArray) argv[name].forEach(fn);
- else if (isSet) fn(argv[name], -1);
- finalize && finalize();
- }
-
- function ifArgPair(name, fn, init, finalize) {
- ifArg(
- name,
- function(content, idx) {
- const i = content.indexOf("=");
- if (i < 0) {
- return fn(null, content, idx);
- } else {
- return fn(content.substr(0, i), content.substr(i + 1), idx);
- }
- },
- init,
- finalize
- );
- }
-
- function ifBooleanArg(name, fn) {
- ifArg(name, function(bool) {
- if (bool) {
- fn();
- }
- });
- }
-
- function mapArgToBoolean(name, optionName) {
- ifArg(name, function(bool) {
- if (bool === true) options[optionName || name] = true;
- else if (bool === false) options[optionName || name] = false;
- });
- }
-
- function loadPlugin(name) {
- const loadUtils = require("loader-utils");
- let args;
- try {
- const p = name && name.indexOf("?");
- if (p > -1) {
- args = loadUtils.parseQuery(name.substring(p));
- name = name.substring(0, p);
- }
- } catch (e) {
- console.log("Invalid plugin arguments " + name + " (" + e + ").");
- process.exit(-1); // eslint-disable-line
- }
-
- let path;
- try {
- const resolve = require("enhanced-resolve");
- path = resolve.sync(process.cwd(), name);
- } catch (e) {
- console.log("Cannot resolve plugin " + name + ".");
- process.exit(-1); // eslint-disable-line
- }
- let Plugin;
- try {
- Plugin = require(path);
- } catch (e) {
- console.log("Cannot load plugin " + name + ". (" + path + ")");
- throw e;
- }
- try {
- return new Plugin(args);
- } catch (e) {
- console.log("Cannot instantiate plugin " + name + ". (" + path + ")");
- throw e;
- }
- }
-
- function ensureObject(parent, name, force) {
- if (force || typeof parent[name] !== "object" || parent[name] === null) {
- parent[name] = {};
- }
- }
-
- function ensureArray(parent, name) {
- if (!Array.isArray(parent[name])) {
- parent[name] = [];
- }
- }
-
- function addPlugin(options, plugin) {
- ensureArray(options, "plugins");
- options.plugins.unshift(plugin);
- }
-
- ifArg("mode", function(value) {
- options.mode = value;
- });
-
- ifArgPair(
- "entry",
- function(name, entry) {
- if (typeof options.entry[name] !== "undefined" && options.entry[name] !== null) {
- options.entry[name] = [].concat(options.entry[name]).concat(entry);
- } else {
- options.entry[name] = entry;
- }
- },
- function() {
- ensureObject(options, "entry", true);
- }
- );
-
- function bindRules(arg) {
- ifArgPair(
- arg,
- function(name, binding) {
- if (name === null) {
- name = binding;
- binding += "-loader";
- }
- const rule = {
- test: new RegExp("\\." + name.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&") + "$"), // eslint-disable-line no-useless-escape
- loader: binding
- };
- if (arg === "module-bind-pre") {
- rule.enforce = "pre";
- } else if (arg === "module-bind-post") {
- rule.enforce = "post";
- }
- options.module.rules.push(rule);
- },
- function() {
- ensureObject(options, "module");
- ensureArray(options.module, "rules");
- }
- );
- }
- bindRules("module-bind");
- bindRules("module-bind-pre");
- bindRules("module-bind-post");
-
- let defineObject;
- ifArgPair(
- "define",
- function(name, value) {
- if (name === null) {
- name = value;
- value = true;
- }
- defineObject[name] = value;
- },
- function() {
- defineObject = {};
- },
- function() {
- const DefinePlugin = require("webpack").DefinePlugin;
- addPlugin(options, new DefinePlugin(defineObject));
- }
- );
-
- ifArg("output-path", function(value) {
- ensureObject(options, "output");
- options.output.path = path.resolve(value);
- });
-
- ifArg("output-filename", function(value) {
- ensureObject(options, "output");
-
- options.output.filename = value;
- });
-
- ifArg("output-chunk-filename", function(value) {
- ensureObject(options, "output");
- options.output.chunkFilename = value;
- });
-
- ifArg("output-source-map-filename", function(value) {
- ensureObject(options, "output");
- options.output.sourceMapFilename = value;
- });
-
- ifArg("output-public-path", function(value) {
- ensureObject(options, "output");
- options.output.publicPath = value;
- });
-
- ifArg("output-jsonp-function", function(value) {
- ensureObject(options, "output");
- options.output.jsonpFunction = value;
- });
-
- ifBooleanArg("output-pathinfo", function() {
- ensureObject(options, "output");
- options.output.pathinfo = true;
- });
-
- ifArg("output-library", function(value) {
- ensureObject(options, "output");
- ensureArray(options.output, "library");
- options.output.library.push(value);
- });
-
- ifArg("output-library-target", function(value) {
- ensureObject(options, "output");
- options.output.libraryTarget = value;
- });
-
- ifArg("records-input-path", function(value) {
- options.recordsInputPath = path.resolve(value);
- });
-
- ifArg("records-output-path", function(value) {
- options.recordsOutputPath = path.resolve(value);
- });
-
- ifArg("records-path", function(value) {
- options.recordsPath = path.resolve(value);
- });
-
- ifArg("target", function(value) {
- options.target = value;
- });
-
- mapArgToBoolean("cache");
-
- ifBooleanArg("hot", function() {
- const HotModuleReplacementPlugin = require("webpack").HotModuleReplacementPlugin;
- addPlugin(options, new HotModuleReplacementPlugin());
- });
-
- ifBooleanArg("no-cache", function() {
- options.cache = false;
- });
-
- ifBooleanArg("debug", function() {
- const LoaderOptionsPlugin = require("webpack").LoaderOptionsPlugin;
- addPlugin(
- options,
- new LoaderOptionsPlugin({
- debug: true
- })
- );
- });
-
- ifArg("devtool", function(value) {
- options.devtool = value;
- });
-
- function processResolveAlias(arg, key) {
- ifArgPair(arg, function(name, value) {
- if (!name) {
- throw new Error("--" + arg + " <string>=<string>");
- }
- ensureObject(options, key);
- ensureObject(options[key], "alias");
- options[key].alias[name] = value;
- });
- }
- processResolveAlias("resolve-alias", "resolve");
- processResolveAlias("resolve-loader-alias", "resolveLoader");
-
- ifArg("resolve-extensions", function(value) {
- ensureObject(options, "resolve");
- if (Array.isArray(value)) {
- options.resolve.extensions = value;
- } else {
- options.resolve.extensions = value.split(/,\s*/);
- }
- });
-
- ifArg("optimize-max-chunks", function(value) {
- const LimitChunkCountPlugin = require("webpack").optimize.LimitChunkCountPlugin;
- addPlugin(
- options,
- new LimitChunkCountPlugin({
- maxChunks: parseInt(value, 10)
- })
- );
- });
-
- ifArg("optimize-min-chunk-size", function(value) {
- const MinChunkSizePlugin = require("webpack").optimize.MinChunkSizePlugin;
- addPlugin(
- options,
- new MinChunkSizePlugin({
- minChunkSize: parseInt(value, 10)
- })
- );
- });
-
- ifBooleanArg("optimize-minimize", function() {
- const LoaderOptionsPlugin = require("webpack").LoaderOptionsPlugin;
- addPlugin(
- options,
- new LoaderOptionsPlugin({
- minimize: true
- })
- );
- });
-
- ifArg("prefetch", function(request) {
- const PrefetchPlugin = require("webpack").PrefetchPlugin;
- addPlugin(options, new PrefetchPlugin(request));
- });
-
- ifArg("provide", function(value) {
- const idx = value.indexOf("=");
- let name;
- if (idx >= 0) {
- name = value.substr(0, idx);
- value = value.substr(idx + 1);
- } else {
- name = value;
- }
- const ProvidePlugin = require("webpack").ProvidePlugin;
- addPlugin(options, new ProvidePlugin(name, value));
- });
-
- ifArg("plugin", function(value) {
- addPlugin(options, loadPlugin(value));
- });
-
- mapArgToBoolean("bail");
-
- mapArgToBoolean("profile");
-
- if (argv._.length > 0) {
- ensureObject(options, "entry", true);
-
- const addTo = function addTo(name, entry) {
- if (options.entry[name]) {
- if (!Array.isArray(options.entry[name])) {
- options.entry[name] = [options.entry[name]];
- }
- options.entry[name].push(entry);
- } else {
- options.entry[name] = entry;
- }
- };
- argv._.forEach(function(content) {
- const i = content.indexOf("=");
- const j = content.indexOf("?");
- if (i < 0 || (j >= 0 && j < i)) {
- const resolved = path.resolve(content);
- if (fs.existsSync(resolved)) {
- addTo("main", `${resolved}${fs.statSync(resolved).isDirectory() ? path.sep : ""}`);
- } else {
- addTo("main", content);
- }
- } else {
- addTo(content.substr(0, i), content.substr(i + 1));
- }
- });
- }
- }
-};
diff --git a/node_modules/webpack-cli/bin/utils/errorHelpers.js b/node_modules/webpack-cli/bin/utils/errorHelpers.js
deleted file mode 100644
index 96fe950..0000000
--- a/node_modules/webpack-cli/bin/utils/errorHelpers.js
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- MIT License http://www.opensource.org/licenses/mit-license.php
- Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const { WEBPACK_OPTIONS_FLAG } = require("./constants");
-
-exports.cutOffByFlag = (stack, flag) => {
- stack = stack.split("\n");
- for (let i = 0; i < stack.length; i++) if (stack[i].indexOf(flag) >= 0) stack.length = i;
- return stack.join("\n");
-};
-
-exports.cutOffWebpackOptions = stack => exports.cutOffByFlag(stack, WEBPACK_OPTIONS_FLAG);
-
-exports.cutOffMultilineMessage = (stack, message) => {
- stack = stack.split("\n");
- message = message.split("\n");
-
- return stack
- .reduce(
- (acc, line, idx) => (line === message[idx] || line === `Error: ${message[idx]}` ? acc : acc.concat(line)),
- []
- )
- .join("\n");
-};
-
-exports.cleanUpWebpackOptions = (stack, message) => {
- stack = exports.cutOffWebpackOptions(stack);
- stack = exports.cutOffMultilineMessage(stack, message);
- return stack;
-};
diff --git a/node_modules/webpack-cli/bin/utils/prepareOptions.js b/node_modules/webpack-cli/bin/utils/prepareOptions.js
deleted file mode 100644
index 97d3085..0000000
--- a/node_modules/webpack-cli/bin/utils/prepareOptions.js
+++ /dev/null
@@ -1,24 +0,0 @@
-"use strict";
-
-module.exports = function prepareOptions(options, argv) {
- argv = argv || {};
- options = handleExport(options);
-
- return Array.isArray(options)
- ? options.map(_options => handleFunction(_options, argv))
- : handleFunction(options, argv);
-};
-
-function handleExport(options) {
- const isES6DefaultExported =
- typeof options === "object" && options !== null && typeof options.default !== "undefined";
-
- return isES6DefaultExported ? options.default : options;
-}
-
-function handleFunction(options, argv) {
- if (typeof options === "function") {
- options = options(argv.env, argv);
- }
- return options;
-}
diff --git a/node_modules/webpack-cli/bin/utils/prompt-command.js b/node_modules/webpack-cli/bin/utils/prompt-command.js
deleted file mode 100644
index 20a99a1..0000000
--- a/node_modules/webpack-cli/bin/utils/prompt-command.js
+++ /dev/null
@@ -1,142 +0,0 @@
-// based on https://github.com/webpack/webpack/blob/master/bin/webpack.js
-
-/**
- * @param {string} command process to run
- * @param {string[]} args commandline arguments
- * @returns {Promise<void>} promise
- */
-const runCommand = (command, args) => {
- const cp = require("child_process");
- return new Promise((resolve, reject) => {
- const executedCommand = cp.spawn(command, args, {
- stdio: "inherit",
- shell: true
- });
-
- executedCommand.on("error", error => {
- reject(error);
- });
-
- executedCommand.on("exit", code => {
- if (code === 0) {
- resolve();
- } else {
- reject();
- }
- });
- });
-};
-
-const npmGlobalRoot = () => {
- const cp = require("child_process");
- return new Promise((resolve, reject) => {
- const command = cp.spawn("npm", ["root", "-g"]);
- command.on("error", error => reject(error));
- command.stdout.on("data", data => resolve(data.toString()));
- command.stderr.on("data", data => reject(data));
- });
-};
-
-const runWhenInstalled = (packages, pathForCmd, ...args) => {
- const currentPackage = require(pathForCmd);
- const func = currentPackage.default;
- if (typeof func !== "function") {
- throw new Error(`@webpack-cli/${packages} failed to export a default function`);
- }
- return func(...args);
-};
-
-module.exports = function promptForInstallation(packages, ...args) {
- const nameOfPackage = "@webpack-cli/" + packages;
- let packageIsInstalled = false;
- let pathForCmd;
- try {
- const path = require("path");
- const fs = require("fs");
- pathForCmd = path.resolve(process.cwd(), "node_modules", "@webpack-cli", packages);
- if (!fs.existsSync(pathForCmd)) {
- const globalModules = require("global-modules");
- pathForCmd = globalModules + "/@webpack-cli/" + packages;
- require.resolve(pathForCmd);
- } else {
- require.resolve(pathForCmd);
- }
- packageIsInstalled = true;
- } catch (err) {
- packageIsInstalled = false;
- }
- if (!packageIsInstalled) {
- const path = require("path");
- const fs = require("fs");
- const readLine = require("readline");
- const isYarn = fs.existsSync(path.resolve(process.cwd(), "yarn.lock"));
-
- const packageManager = isYarn ? "yarn" : "npm";
- const options = ["install", "-D", nameOfPackage];
-
- if (isYarn) {
- options[0] = "add";
- }
-
- if (packages === "init") {
- if (isYarn) {
- options.splice(1, 1); // remove '-D'
- options.splice(0, 0, "global");
- } else {
- options[1] = "-g";
- }
- }
-
- const commandToBeRun = `${packageManager} ${options.join(" ")}`;
-
- const question = `Would you like to install ${packages}? (That will run ${commandToBeRun}) (yes/NO) : `;
-
- console.error(`The command moved into a separate package: ${nameOfPackage}`);
- const questionInterface = readLine.createInterface({
- input: process.stdin,
- output: process.stdout
- });
- questionInterface.question(question, answer => {
- questionInterface.close();
- switch (answer.toLowerCase()) {
- case "y":
- case "yes":
- case "1": {
- runCommand(packageManager, options)
- .then(_ => {
- if (packages === "init") {
- npmGlobalRoot()
- .then(root => {
- const pathtoInit = path.resolve(root.trim(), "@webpack-cli", "init");
- return pathtoInit;
- })
- .then(pathForInit => {
- return require(pathForInit).default(...args);
- })
- .catch(error => {
- console.error(error);
- process.exitCode = 1;
- });
- return;
- }
-
- pathForCmd = path.resolve(process.cwd(), "node_modules", "@webpack-cli", packages);
- return runWhenInstalled(packages, pathForCmd, ...args);
- })
- .catch(error => {
- console.error(error);
- process.exitCode = 1;
- });
- break;
- }
- default: {
- console.error(`${nameOfPackage} needs to be installed in order to run the command.`);
- process.exitCode = 1;
- break;
- }
- }
- });
- } else {
- return runWhenInstalled(packages, pathForCmd, ...args);
- }
-};
diff --git a/node_modules/webpack-cli/bin/utils/validate-options.js b/node_modules/webpack-cli/bin/utils/validate-options.js
deleted file mode 100644
index 4452e54..0000000
--- a/node_modules/webpack-cli/bin/utils/validate-options.js
+++ /dev/null
@@ -1,21 +0,0 @@
-const webpackConfigurationSchema = require("../config/webpackConfigurationSchema.json");
-const validateSchema = require("webpack").validateSchema;
-
-module.exports = function validateOptions(options) {
- let error;
- try {
- const errors = validateSchema(webpackConfigurationSchema, options);
- if (errors && errors.length > 0) {
- const { WebpackOptionsValidationError } = require("webpack");
- error = new WebpackOptionsValidationError(errors);
- }
- } catch (err) {
- error = err;
- }
-
- if (error) {
- console.error(error.message);
- // eslint-disable-next-line no-process-exit
- process.exit(-1);
- }
-};