webpack 4.24.0 → 4.26.1

package/LICENSE

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

package/SECURITY.md

@@ -1,9 +1,9 @@
-# Reporting Security Issues
-
-If you discover a security issue in webpack, please report it by sending an
-email to [webpack@opencollective.com](mailto:webpack@opencollective.com).
-
-This will allow us to assess the risk, and make a fix available before we add a
-bug report to the GitHub repository.
-
-Thanks for helping make webpack safe for everyone.
+# Reporting Security Issues
+
+If you discover a security issue in webpack, please report it by sending an
+email to [webpack@opencollective.com](mailto:webpack@opencollective.com).
+
+This will allow us to assess the risk, and make a fix available before we add a
+bug report to the GitHub repository.
+
+Thanks for helping make webpack safe for everyone.

package/buildin/amd-define.js

@@ -1,3 +1,3 @@
-module.exports = function() {
-	throw new Error("define cannot be used indirect");
-};
+module.exports = function() {
+	throw new Error("define cannot be used indirect");
+};

package/buildin/amd-options.js

@@ -1,2 +1,2 @@
-/* globals __webpack_amd_options__ */
-module.exports = __webpack_amd_options__;
+/* globals __webpack_amd_options__ */
+module.exports = __webpack_amd_options__;

package/buildin/global.js

@@ -7,7 +7,7 @@ g = (function() {
 
 try {
 	// This works if eval is allowed (see CSP)
-	g = g || Function("return this")() || (1, eval)("this");
+	g = g || new Function("return this")();
 } catch (e) {
 	// This works if the window reference is available
 	if (typeof window === "object") g = window;

package/buildin/module.js

@@ -1,22 +1,22 @@
-module.exports = function(module) {
-	if (!module.webpackPolyfill) {
-		module.deprecate = function() {};
-		module.paths = [];
-		// module.parent = undefined by default
-		if (!module.children) module.children = [];
-		Object.defineProperty(module, "loaded", {
-			enumerable: true,
-			get: function() {
-				return module.l;
-			}
-		});
-		Object.defineProperty(module, "id", {
-			enumerable: true,
-			get: function() {
-				return module.i;
-			}
-		});
-		module.webpackPolyfill = 1;
-	}
-	return module;
-};
+module.exports = function(module) {
+	if (!module.webpackPolyfill) {
+		module.deprecate = function() {};
+		module.paths = [];
+		// module.parent = undefined by default
+		if (!module.children) module.children = [];
+		Object.defineProperty(module, "loaded", {
+			enumerable: true,
+			get: function() {
+				return module.l;
+			}
+		});
+		Object.defineProperty(module, "id", {
+			enumerable: true,
+			get: function() {
+				return module.i;
+			}
+		});
+		module.webpackPolyfill = 1;
+	}
+	return module;
+};

package/buildin/system.js

@@ -1,7 +1,7 @@
-// Provide a "System" global.
-module.exports = {
-	// Make sure import is only used as "System.import"
-	import: function() {
-		throw new Error("System.import cannot be used indirectly");
-	}
-};
+// Provide a "System" global.
+module.exports = {
+	// Make sure import is only used as "System.import"
+	import: function() {
+		throw new Error("System.import cannot be used indirectly");
+	}
+};

package/declarations/plugins/DllPlugin.d.ts

@@ -13,6 +13,10 @@ export interface DllPluginOptions {
 	 * If true, only entry points will be exposed
 	 */
 	entryOnly?: boolean;
+	/**
+	 * If true, manifest json file (output) will be formatted
+	 */
+	format?: boolean;
 	/**
 	 * Name of the exposed dll function (external name, use value of 'output.library')
 	 */

package/declarations/plugins/ProgressPlugin.d.ts

@@ -0,0 +1,42 @@
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY BY HAND.
+ * Run `yarn special-lint-fix` to update
+ */
+
+export type ProgressPluginArgument = ProgressPluginOptions | HandlerFunction;
+/**
+ * Function that executes for every progress step
+ */
+export type HandlerFunction = ((
+	percentage: number,
+	msg: string,
+	...args: string[]
+) => void);
+
+export interface ProgressPluginOptions {
+	/**
+	 * Show active modules count and one active module in progress message
+	 */
+	activeModules?: boolean;
+	/**
+	 * Show entries count in progress message
+	 */
+	entries?: boolean;
+	/**
+	 * Function that executes for every progress step
+	 */
+	handler?: HandlerFunction;
+	/**
+	 * Show modules count in progress message
+	 */
+	modules?: boolean;
+	/**
+	 * Minimum modules count to start with. Only for mode=modules. Default: 500
+	 */
+	modulesCount?: number;
+	/**
+	 * Collect profile data for progress steps. Default: false
+	 */
+	profile?: true | false | null;
+}

package/hot/emitter.js

@@ -1,2 +1,2 @@
-var EventEmitter = require("events");
-module.exports = new EventEmitter();
+var EventEmitter = require("events");
+module.exports = new EventEmitter();

package/lib/BasicEvaluatedExpression.js

@@ -29,11 +29,14 @@ class BasicEvaluatedExpression {
 		this.regExp = null;
 		this.string = null;
 		this.quasis = null;
+		this.parts = null;
 		this.array = null;
 		this.items = null;
 		this.options = null;
 		this.prefix = null;
 		this.postfix = null;
+		this.wrappedInnerExpressions = null;
+		this.expression = null;
 	}
 
 	isNull() {
@@ -105,10 +108,36 @@ class BasicEvaluatedExpression {
 				: undefined;
 		}
 		if (this.isTemplateString()) {
-			for (const quasi of this.quasis) {
-				if (quasi.asBool()) return true;
+			const str = this.asString();
+			if (typeof str === "string") return str !== "";
+		}
+		return undefined;
+	}
+
+	asString() {
+		if (this.isBoolean()) return `${this.bool}`;
+		if (this.isNull()) return "null";
+		if (this.isString()) return this.string;
+		if (this.isNumber()) return `${this.number}`;
+		if (this.isRegExp()) return `${this.regExp}`;
+		if (this.isArray()) {
+			let array = [];
+			for (const item of this.items) {
+				const itemStr = item.asString();
+				if (itemStr === undefined) return undefined;
+				array.push(itemStr);
+			}
+			return `${array}`;
+		}
+		if (this.isConstArray()) return `${this.array}`;
+		if (this.isTemplateString()) {
+			let str = "";
+			for (const part of this.parts) {
+				const partStr = part.asString();
+				if (partStr === undefined) return undefined;
+				str += partStr;
 			}
-			// can't tell if string will be empty without executing
+			return str;
 		}
 		return undefined;
 	}
@@ -148,10 +177,11 @@ class BasicEvaluatedExpression {
 		return this;
 	}
 
-	setWrapped(prefix, postfix) {
+	setWrapped(prefix, postfix, innerExpressions) {
 		this.type = TypeWrapped;
 		this.prefix = prefix;
 		this.postfix = postfix;
+		this.wrappedInnerExpressions = innerExpressions;
 		return this;
 	}
 
@@ -184,9 +214,11 @@ class BasicEvaluatedExpression {
 		return this;
 	}
 
-	setTemplateString(quasis) {
+	setTemplateString(quasis, parts, kind) {
 		this.type = TypeTemplateString;
 		this.quasis = quasis;
+		this.parts = parts;
+		this.templateStringKind = kind;
 		return this;
 	}
 
@@ -206,6 +238,11 @@ class BasicEvaluatedExpression {
 		this.range = range;
 		return this;
 	}
+
+	setExpression(expression) {
+		this.expression = expression;
+		return this;
+	}
 }
 
 module.exports = BasicEvaluatedExpression;

package/lib/Chunk.js

@@ -430,7 +430,7 @@ class Chunk {
 	}
 
 	/**
-	 * @param {Chunk} newChunk the new chunk that will be split out of, and then chunk raphi twil=
+	 * @param {Chunk} newChunk the new chunk that will be split out of the current chunk
 	 * @returns {void}
 	 */
 	split(newChunk) {

package/lib/Compilation.js

@@ -224,6 +224,13 @@ class Compilation extends Tapable {
 			/** @type {SyncHook<Module>} */
 			succeedModule: new SyncHook(["module"]),
 
+			/** @type {SyncHook<Dependency, string>} */
+			addEntry: new SyncHook(["entry", "name"]),
+			/** @type {SyncHook<Dependency, string, Error>} */
+			failedEntry: new SyncHook(["entry", "name", "error"]),
+			/** @type {SyncHook<Dependency, string, Module>} */
+			succeedEntry: new SyncHook(["entry", "name", "module"]),
+
 			/** @type {SyncWaterfallHook<DependencyReference, Dependency, Module>} */
 			dependencyReference: new SyncWaterfallHook([
 				"dependencyReference",
@@ -1041,6 +1048,8 @@ class Compilation extends Tapable {
 	 * @returns {void} returns
 	 */
 	addEntry(context, entry, name, callback) {
+		this.hooks.addEntry.call(entry, name);
+
 		const slot = {
 			name: name,
 			// TODO webpack 5 remove `request`
@@ -1068,6 +1077,7 @@ class Compilation extends Tapable {
 			},
 			(err, module) => {
 				if (err) {
+					this.hooks.failedEntry.call(entry, name, err);
 					return callback(err);
 				}
 
@@ -1079,6 +1089,7 @@ class Compilation extends Tapable {
 						this._preparedEntrypoints.splice(idx, 1);
 					}
 				}
+				this.hooks.succeedEntry.call(entry, name, module);
 				return callback(null, module);
 			}
 		);

package/lib/LibManifestPlugin.js

@@ -67,7 +67,11 @@ class LibManifestPlugin {
 									return obj;
 								}, Object.create(null))
 						};
-						const content = Buffer.from(JSON.stringify(manifest), "utf8");
+						// Apply formatting to content if format flag is true;
+						const manifestContent = this.options.format
+							? JSON.stringify(manifest, null, 2)
+							: JSON.stringify(manifest);
+						const content = Buffer.from(manifestContent, "utf8");
 						compiler.outputFileSystem.mkdirp(path.dirname(targetPath), err => {
 							if (err) return callback(err);
 							compiler.outputFileSystem.writeFile(

package/lib/Parser.js

@@ -216,62 +216,114 @@ class Parser extends Tapable {
 						right.prefix &&
 						right.prefix.isString()
 					) {
+						// "left" + ("prefix" + inner + "postfix")
+						// => ("leftprefix" + inner + "postfix")
 						res.setWrapped(
 							new BasicEvaluatedExpression()
 								.setString(left.string + right.prefix.string)
 								.setRange(joinRanges(left.range, right.prefix.range)),
-							right.postfix
+							right.postfix,
+							right.wrappedInnerExpressions
 						);
 					} else if (right.isWrapped()) {
-						res.setWrapped(
-							new BasicEvaluatedExpression()
-								.setString(left.string)
-								.setRange(left.range),
-							right.postfix
-						);
+						// "left" + ([null] + inner + "postfix")
+						// => ("left" + inner + "postfix")
+						res.setWrapped(left, right.postfix, right.wrappedInnerExpressions);
 					} else {
-						res.setWrapped(left, null);
+						// "left" + expr
+						// => ("left" + expr + "")
+						res.setWrapped(left, null, [right]);
 					}
 				} else if (left.isNumber()) {
 					if (right.isString()) {
 						res.setString(left.number + right.string);
 					} else if (right.isNumber()) {
 						res.setNumber(left.number + right.number);
+					} else {
+						return;
 					}
 				} else if (left.isWrapped()) {
 					if (left.postfix && left.postfix.isString() && right.isString()) {
+						// ("prefix" + inner + "postfix") + "right"
+						// => ("prefix" + inner + "postfixright")
 						res.setWrapped(
 							left.prefix,
 							new BasicEvaluatedExpression()
 								.setString(left.postfix.string + right.string)
-								.setRange(joinRanges(left.postfix.range, right.range))
+								.setRange(joinRanges(left.postfix.range, right.range)),
+							left.wrappedInnerExpressions
 						);
 					} else if (
 						left.postfix &&
 						left.postfix.isString() &&
 						right.isNumber()
 					) {
+						// ("prefix" + inner + "postfix") + 123
+						// => ("prefix" + inner + "postfix123")
 						res.setWrapped(
 							left.prefix,
 							new BasicEvaluatedExpression()
 								.setString(left.postfix.string + right.number)
-								.setRange(joinRanges(left.postfix.range, right.range))
+								.setRange(joinRanges(left.postfix.range, right.range)),
+							left.wrappedInnerExpressions
 						);
 					} else if (right.isString()) {
-						res.setWrapped(left.prefix, right);
+						// ("prefix" + inner + [null]) + "right"
+						// => ("prefix" + inner + "right")
+						res.setWrapped(left.prefix, right, left.wrappedInnerExpressions);
 					} else if (right.isNumber()) {
+						// ("prefix" + inner + [null]) + 123
+						// => ("prefix" + inner + "123")
 						res.setWrapped(
 							left.prefix,
 							new BasicEvaluatedExpression()
 								.setString(right.number + "")
-								.setRange(right.range)
+								.setRange(right.range),
+							left.wrappedInnerExpressions
+						);
+					} else if (right.isWrapped()) {
+						// ("prefix1" + inner1 + "postfix1") + ("prefix2" + inner2 + "postfix2")
+						// ("prefix1" + inner1 + "postfix1" + "prefix2" + inner2 + "postfix2")
+						res.setWrapped(
+							left.prefix,
+							right.postfix,
+							left.wrappedInnerExpressions &&
+								right.wrappedInnerExpressions &&
+								left.wrappedInnerExpressions
+									.concat(left.postfix ? [left.postfix] : [])
+									.concat(right.prefix ? [right.prefix] : [])
+									.concat(right.wrappedInnerExpressions)
 						);
 					} else {
-						res.setWrapped(left.prefix, new BasicEvaluatedExpression());
+						// ("prefix" + inner + postfix) + expr
+						// => ("prefix" + inner + postfix + expr + [null])
+						res.setWrapped(
+							left.prefix,
+							null,
+							left.wrappedInnerExpressions &&
+								left.wrappedInnerExpressions.concat(
+									left.postfix ? [left.postfix, right] : [right]
+								)
+						);
 					}
 				} else {
 					if (right.isString()) {
-						res.setWrapped(null, right);
+						// left + "right"
+						// => ([null] + left + "right")
+						res.setWrapped(null, right, [left]);
+					} else if (right.isWrapped()) {
+						// left + (prefix + inner + "postfix")
+						// => ([null] + left + prefix + inner + "postfix")
+						res.setWrapped(
+							null,
+							right.postfix,
+							right.wrappedInnerExpressions &&
+								(right.prefix ? [left, right.prefix] : [left]).concat(
+									right.wrappedInnerExpressions
+								)
+						);
+					} else {
+						return;
 					}
 				}
 				res.setRange(expr.range);
@@ -602,62 +654,66 @@ class Parser extends Tapable {
 
 		/**
 		 * @param {string} kind "cooked" | "raw"
-		 * @param {TODO[]} quasis quasis
-		 * @param {TODO[]} expressions expressions
-		 * @returns {BasicEvaluatedExpression[]} Simplified template
+		 * @param {TODO} templateLiteralExpr TemplateLiteral expr
+		 * @returns {{quasis: BasicEvaluatedExpression[], parts: BasicEvaluatedExpression[]}} Simplified template
 		 */
-		const getSimplifiedTemplateResult = (kind, quasis, expressions) => {
+		const getSimplifiedTemplateResult = (kind, templateLiteralExpr) => {
+			const quasis = [];
 			const parts = [];
 
-			for (let i = 0; i < quasis.length; i++) {
-				parts.push(
-					new BasicEvaluatedExpression()
-						.setString(quasis[i].value[kind])
-						.setRange(quasis[i].range)
-				);
+			for (let i = 0; i < templateLiteralExpr.quasis.length; i++) {
+				const quasiExpr = templateLiteralExpr.quasis[i];
+				const quasi = quasiExpr.value[kind];
 
 				if (i > 0) {
-					const prevExpr = parts[parts.length - 2],
-						lastExpr = parts[parts.length - 1];
-					const expr = this.evaluateExpression(expressions[i - 1]);
-					if (!(expr.isString() || expr.isNumber())) continue;
-
-					prevExpr.setString(
-						prevExpr.string +
-							(expr.isString() ? expr.string : expr.number) +
-							lastExpr.string
+					const prevExpr = parts[parts.length - 1];
+					const expr = this.evaluateExpression(
+						templateLiteralExpr.expressions[i - 1]
 					);
-					prevExpr.setRange([prevExpr.range[0], lastExpr.range[1]]);
-					parts.pop();
+					const exprAsString = expr.asString();
+					if (typeof exprAsString === "string") {
+						// We can merge quasi + expr + quasi when expr
+						// is a const string
+
+						prevExpr.setString(prevExpr.string + exprAsString + quasi);
+						prevExpr.setRange([prevExpr.range[0], quasiExpr.range[1]]);
+						// We unset the expression as it doesn't match to a single expression
+						prevExpr.setExpression(undefined);
+						continue;
+					}
+					parts.push(expr);
 				}
+
+				const part = new BasicEvaluatedExpression()
+					.setString(quasi)
+					.setRange(quasiExpr.range)
+					.setExpression(quasiExpr);
+				quasis.push(part);
+				parts.push(part);
 			}
-			return parts;
+			return {
+				quasis,
+				parts
+			};
 		};
 
 		this.hooks.evaluate.for("TemplateLiteral").tap("Parser", node => {
-			const parts = getSimplifiedTemplateResult.call(
-				this,
-				"cooked",
-				node.quasis,
-				node.expressions
-			);
+			const { quasis, parts } = getSimplifiedTemplateResult("cooked", node);
 			if (parts.length === 1) {
 				return parts[0].setRange(node.range);
 			}
 			return new BasicEvaluatedExpression()
-				.setTemplateString(parts)
+				.setTemplateString(quasis, parts, "cooked")
 				.setRange(node.range);
 		});
 		this.hooks.evaluate.for("TaggedTemplateExpression").tap("Parser", node => {
 			if (this.evaluateExpression(node.tag).identifier !== "String.raw") return;
-			const parts = getSimplifiedTemplateResult.call(
-				this,
-				"raw",
-				node.quasi.quasis,
-				node.quasi.expressions
-			);
+			const { quasis, parts } = getSimplifiedTemplateResult("raw", node.quasi);
+			if (parts.length === 1) {
+				return parts[0].setRange(node.range);
+			}
 			return new BasicEvaluatedExpression()
-				.setTemplateString(parts)
+				.setTemplateString(quasis, parts, "raw")
 				.setRange(node.range);
 		});
 
@@ -1926,13 +1982,20 @@ class Parser extends Tapable {
 			const hook = this.hooks.evaluate.get(expression.type);
 			if (hook !== undefined) {
 				const result = hook.call(expression);
-				if (result !== undefined) return result;
+				if (result !== undefined) {
+					if (result) {
+						result.setExpression(expression);
+					}
+					return result;
+				}
 			}
 		} catch (e) {
 			console.warn(e);
 			// ignore error
 		}
-		return new BasicEvaluatedExpression().setRange(expression.range);
+		return new BasicEvaluatedExpression()
+			.setRange(expression.range)
+			.setExpression(expression);
 	}
 
 	parseString(expression) {