Tryag File Manager

/home/yanggyein/yanggyein/yang_ai/node_modules/webpack-cli/bin/cli.js

#!/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 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;

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");

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");
				});
			}