webpack 4.10.1 → 4.10.2

package/lib/Parser.js

@@ -117,17 +117,18 @@ class Parser extends Tapable {
 				const regexp = HOOK_MAP_COMPAT_CONFIG[name];
 				const match = regexp.exec(options.name);
 				if (match) {
-					if (match[1])
+					if (match[1]) {
 						this.hooks[name].tap(
 							match[1],
 							options.fn.name || "unnamed compat plugin",
 							options.fn.bind(this)
 						);
-					else
+					} else {
 						this.hooks[name].tap(
 							options.fn.name || "unnamed compat plugin",
 							options.fn.bind(this)
 						);
+					}
 					return true;
 				}
 			}
@@ -156,12 +157,14 @@ class Parser extends Tapable {
 						.setBoolean(expr.value)
 						.setRange(expr.range);
 			}
-			if (expr.value === null)
+			if (expr.value === null) {
 				return new BasicEvaluatedExpression().setNull().setRange(expr.range);
-			if (expr.value instanceof RegExp)
+			}
+			if (expr.value instanceof RegExp) {
 				return new BasicEvaluatedExpression()
 					.setRegExp(expr.value)
 					.setRange(expr.range);
+			}
 		});
 		this.hooks.evaluate.for("LogicalExpression").tap("Parser", expr => {
 			let left;
@@ -411,22 +414,26 @@ class Parser extends Tapable {
 						.setRange(expr.range);
 				}
 				const arg = this.evaluateExpression(expr.argument);
-				if (arg.isString() || arg.isWrapped())
+				if (arg.isString() || arg.isWrapped()) {
 					return new BasicEvaluatedExpression()
 						.setString("string")
 						.setRange(expr.range);
-				else if (arg.isNumber())
+				}
+				if (arg.isNumber()) {
 					return new BasicEvaluatedExpression()
 						.setString("number")
 						.setRange(expr.range);
-				else if (arg.isBoolean())
+				}
+				if (arg.isBoolean()) {
 					return new BasicEvaluatedExpression()
 						.setString("boolean")
 						.setRange(expr.range);
-				else if (arg.isArray() || arg.isConstArray() || arg.isRegExp())
+				}
+				if (arg.isArray() || arg.isConstArray() || arg.isRegExp()) {
 					return new BasicEvaluatedExpression()
 						.setString("object")
 						.setRange(expr.range);
+				}
 			} else if (expr.operator === "!") {
 				const argument = this.evaluateExpression(expr.argument);
 				if (!argument) return;
@@ -434,19 +441,23 @@ class Parser extends Tapable {
 					return new BasicEvaluatedExpression()
 						.setBoolean(!argument.bool)
 						.setRange(expr.range);
-				} else if (argument.isTruthy()) {
+				}
+				if (argument.isTruthy()) {
 					return new BasicEvaluatedExpression()
 						.setBoolean(false)
 						.setRange(expr.range);
-				} else if (argument.isFalsy()) {
+				}
+				if (argument.isFalsy()) {
 					return new BasicEvaluatedExpression()
 						.setBoolean(true)
 						.setRange(expr.range);
-				} else if (argument.isString()) {
+				}
+				if (argument.isString()) {
 					return new BasicEvaluatedExpression()
 						.setBoolean(!argument.string)
 						.setRange(expr.range);
-				} else if (argument.isNumber()) {
+				}
+				if (argument.isNumber()) {
 					return new BasicEvaluatedExpression()
 						.setBoolean(!argument.number)
 						.setRange(expr.range);
@@ -696,7 +707,9 @@ class Parser extends Tapable {
 					result = param.string.split(arg.string);
 				} else if (arg.isRegExp()) {
 					result = param.string.split(arg.regExp);
-				} else return;
+				} else {
+					return;
+				}
 				return new BasicEvaluatedExpression()
 					.setArray(result)
 					.setRange(expr.range);
@@ -710,10 +723,16 @@ class Parser extends Tapable {
 				const alternate = this.evaluateExpression(expr.alternate);
 				if (!consequent || !alternate) return;
 				res = new BasicEvaluatedExpression();
-				if (consequent.isConditional()) res.setOptions(consequent.options);
-				else res.setOptions([consequent]);
-				if (alternate.isConditional()) res.addOptions(alternate.options);
-				else res.addOptions([alternate]);
+				if (consequent.isConditional()) {
+					res.setOptions(consequent.options);
+				} else {
+					res.setOptions([consequent]);
+				}
+				if (alternate.isConditional()) {
+					res.addOptions(alternate.options);
+				} else {
+					res.addOptions([alternate]);
+				}
 			} else {
 				res = this.evaluateExpression(
 					conditionValue ? expr.consequent : expr.alternate
@@ -735,9 +754,9 @@ class Parser extends Tapable {
 
 	getRenameIdentifier(expr) {
 		const result = this.evaluateExpression(expr);
-		if (!result) return;
-		if (result.isIdentifier()) return result.identifier;
-		return;
+		if (result && result.isIdentifier()) {
+			return result.identifier;
+		}
 	}
 
 	walkClass(classy) {
@@ -746,17 +765,21 @@ class Parser extends Tapable {
 			const wasTopLevel = this.scope.topLevelScope;
 			this.scope.topLevelScope = false;
 			for (const methodDefinition of classy.body.body) {
-				if (methodDefinition.type === "MethodDefinition")
+				if (methodDefinition.type === "MethodDefinition") {
 					this.walkMethodDefinition(methodDefinition);
+				}
 			}
 			this.scope.topLevelScope = wasTopLevel;
 		}
 	}
 
 	walkMethodDefinition(methodDefinition) {
-		if (methodDefinition.computed && methodDefinition.key)
+		if (methodDefinition.computed && methodDefinition.key) {
 			this.walkExpression(methodDefinition.key);
-		if (methodDefinition.value) this.walkExpression(methodDefinition.value);
+		}
+		if (methodDefinition.value) {
+			this.walkExpression(methodDefinition.value);
+		}
 	}
 
 	// Prewalking iterates the scope for variable declarations
@@ -912,7 +935,9 @@ class Parser extends Tapable {
 
 	prewalkIfStatement(statement) {
 		this.prewalkStatement(statement.consequent);
-		if (statement.alternate) this.prewalkStatement(statement.alternate);
+		if (statement.alternate) {
+			this.prewalkStatement(statement.alternate);
+		}
 	}
 
 	walkIfStatement(statement) {
@@ -920,10 +945,15 @@ class Parser extends Tapable {
 		if (result === undefined) {
 			this.walkExpression(statement.test);
 			this.walkStatement(statement.consequent);
-			if (statement.alternate) this.walkStatement(statement.alternate);
+			if (statement.alternate) {
+				this.walkStatement(statement.alternate);
+			}
 		} else {
-			if (result) this.walkStatement(statement.consequent);
-			else if (statement.alternate) this.walkStatement(statement.alternate);
+			if (result) {
+				this.walkStatement(statement.consequent);
+			} else if (statement.alternate) {
+				this.walkStatement(statement.alternate);
+			}
 		}
 	}
 
@@ -1006,26 +1036,34 @@ class Parser extends Tapable {
 
 	prewalkForStatement(statement) {
 		if (statement.init) {
-			if (statement.init.type === "VariableDeclaration")
+			if (statement.init.type === "VariableDeclaration") {
 				this.prewalkStatement(statement.init);
+			}
 		}
 		this.prewalkStatement(statement.body);
 	}
 
 	walkForStatement(statement) {
 		if (statement.init) {
-			if (statement.init.type === "VariableDeclaration")
+			if (statement.init.type === "VariableDeclaration") {
 				this.walkStatement(statement.init);
-			else this.walkExpression(statement.init);
+			} else {
+				this.walkExpression(statement.init);
+			}
+		}
+		if (statement.test) {
+			this.walkExpression(statement.test);
+		}
+		if (statement.update) {
+			this.walkExpression(statement.update);
 		}
-		if (statement.test) this.walkExpression(statement.test);
-		if (statement.update) this.walkExpression(statement.update);
 		this.walkStatement(statement.body);
 	}
 
 	prewalkForInStatement(statement) {
-		if (statement.left.type === "VariableDeclaration")
+		if (statement.left.type === "VariableDeclaration") {
 			this.prewalkVariableDeclaration(statement.left);
+		}
 		this.prewalkStatement(statement.body);
 	}
 
@@ -1142,7 +1180,7 @@ class Parser extends Tapable {
 				switch (specifier.type) {
 					case "ExportSpecifier": {
 						const name = specifier.exported.name;
-						if (source)
+						if (source) {
 							this.hooks.exportImportSpecifier.call(
 								statement,
 								source,
@@ -1150,13 +1188,14 @@ class Parser extends Tapable {
 								name,
 								specifierIndex
 							);
-						else
+						} else {
 							this.hooks.exportSpecifier.call(
 								statement,
 								specifier.local.name,
 								name,
 								specifierIndex
 							);
+						}
 						break;
 					}
 				}
@@ -1445,11 +1484,15 @@ class Parser extends Tapable {
 	}
 
 	walkArrayExpression(expression) {
-		if (expression.elements) this.walkExpressions(expression.elements);
+		if (expression.elements) {
+			this.walkExpressions(expression.elements);
+		}
 	}
 
 	walkSpreadElement(expression) {
-		if (expression.argument) this.walkExpression(expression.argument);
+		if (expression.argument) {
+			this.walkExpression(expression.argument);
+		}
 	}
 
 	walkObjectExpression(expression) {
@@ -1463,10 +1506,16 @@ class Parser extends Tapable {
 				this.walkExpression(prop.argument);
 				continue;
 			}
-			if (prop.computed) this.walkExpression(prop.key);
-			if (prop.shorthand) this.scope.inShorthand = true;
+			if (prop.computed) {
+				this.walkExpression(prop.key);
+			}
+			if (prop.shorthand) {
+				this.scope.inShorthand = true;
+			}
 			this.walkExpression(prop.value);
-			if (prop.shorthand) this.scope.inShorthand = false;
+			if (prop.shorthand) {
+				this.scope.inShorthand = false;
+			}
 		}
 	}
 
@@ -1576,10 +1625,15 @@ class Parser extends Tapable {
 		if (result === undefined) {
 			this.walkExpression(expression.test);
 			this.walkExpression(expression.consequent);
-			if (expression.alternate) this.walkExpression(expression.alternate);
+			if (expression.alternate) {
+				this.walkExpression(expression.alternate);
+			}
 		} else {
-			if (result) this.walkExpression(expression.consequent);
-			else if (expression.alternate) this.walkExpression(expression.alternate);
+			if (result) {
+				this.walkExpression(expression.consequent);
+			} else if (expression.alternate) {
+				this.walkExpression(expression.alternate);
+			}
 		}
 	}
 
@@ -1596,21 +1650,30 @@ class Parser extends Tapable {
 		}
 
 		this.walkExpression(expression.callee);
-		if (expression.arguments) this.walkExpressions(expression.arguments);
+		if (expression.arguments) {
+			this.walkExpressions(expression.arguments);
+		}
 	}
 
 	walkYieldExpression(expression) {
-		if (expression.argument) this.walkExpression(expression.argument);
+		if (expression.argument) {
+			this.walkExpression(expression.argument);
+		}
 	}
 
 	walkTemplateLiteral(expression) {
-		if (expression.expressions) this.walkExpressions(expression.expressions);
+		if (expression.expressions) {
+			this.walkExpressions(expression.expressions);
+		}
 	}
 
 	walkTaggedTemplateExpression(expression) {
-		if (expression.tag) this.walkExpression(expression.tag);
-		if (expression.quasi && expression.quasi.expressions)
+		if (expression.tag) {
+			this.walkExpression(expression.tag);
+		}
+		if (expression.quasi && expression.quasi.expressions) {
 			this.walkExpressions(expression.quasi.expressions);
+		}
 	}
 
 	walkClassExpression(expression) {
@@ -1624,8 +1687,9 @@ class Parser extends Tapable {
 				const hook = this.hooks.canRename.get(renameIdentifier);
 				if (hook !== undefined && hook.call(argOrThis)) {
 					const hook = this.hooks.rename.get(renameIdentifier);
-					if (hook === undefined || !hook.call(argOrThis))
+					if (hook === undefined || !hook.call(argOrThis)) {
 						return renameIdentifier;
+					}
 				}
 			}
 			this.walkExpression(argOrThis);
@@ -1852,11 +1916,12 @@ class Parser extends Tapable {
 	parseString(expression) {
 		switch (expression.type) {
 			case "BinaryExpression":
-				if (expression.operator === "+")
+				if (expression.operator === "+") {
 					return (
 						this.parseString(expression.left) +
 						this.parseString(expression.right)
 					);
+				}
 				break;
 			case "Literal":
 				return expression.value + "";
@@ -1903,12 +1968,20 @@ class Parser extends Tapable {
 				const consequent = this.parseCalculatedString(expression.consequent);
 				const alternate = this.parseCalculatedString(expression.alternate);
 				const items = [];
-				if (consequent.conditional) items.push(...consequent.conditional);
-				else if (!consequent.code) items.push(consequent);
-				else break;
-				if (alternate.conditional) items.push(...alternate.conditional);
-				else if (!alternate.code) items.push(alternate);
-				else break;
+				if (consequent.conditional) {
+					items.push(...consequent.conditional);
+				} else if (!consequent.code) {
+					items.push(consequent);
+				} else {
+					break;
+				}
+				if (alternate.conditional) {
+					items.push(...alternate.conditional);
+				} else if (!alternate.code) {
+					items.push(alternate);
+				} else {
+					break;
+				}
 				return {
 					range: undefined,
 					value: "",
@@ -1975,8 +2048,9 @@ class Parser extends Tapable {
 			sourceType: this.sourceType,
 			locations: false
 		});
-		if (ast.body.length !== 1 || ast.body[0].type !== "ExpressionStatement")
+		if (ast.body.length !== 1 || ast.body[0].type !== "ExpressionStatement") {
 			throw new Error("evaluate: Source is not a expression");
+		}
 		return this.evaluateExpression(ast.body[0].expression);
 	}
 
@@ -2029,8 +2103,12 @@ class Parser extends Tapable {
 			return null;
 		}
 		let prefix = "";
-		for (let i = exprName.length - 1; i >= 2; i--) prefix += exprName[i] + ".";
-		if (exprName.length > 1) prefix += exprName[1];
+		for (let i = exprName.length - 1; i >= 2; i--) {
+			prefix += exprName[i] + ".";
+		}
+		if (exprName.length > 1) {
+			prefix += exprName[1];
+		}
 		const name = prefix ? prefix + "." + exprName[0] : exprName[0];
 		const nameGeneral = prefix;
 		return {

package/lib/ParserHelpers.js

@@ -72,8 +72,11 @@ ParserHelpers.evaluateToIdentifier = (identifier, truthy) => {
 		let evex = new BasicEvaluatedExpression()
 			.setIdentifier(identifier)
 			.setRange(expr.range);
-		if (truthy === true) evex = evex.setTruthy();
-		else if (truthy === false) evex = evex.setFalsy();
+		if (truthy === true) {
+			evex = evex.setTruthy();
+		} else if (truthy === false) {
+			evex = evex.setFalsy();
+		}
 		return evex;
 	};
 };

package/lib/ProgressPlugin.js

@@ -101,7 +101,7 @@ class ProgressPlugin {
 
 			const update = module => {
 				handler(
-					0.1 + doneModules / Math.max(lastModulesCount, moduleCount) * 0.6,
+					0.1 + (doneModules / Math.max(lastModulesCount, moduleCount)) * 0.6,
 					"building modules",
 					`${doneModules}/${moduleCount} modules`,
 					`${activeModules.length} active`,
@@ -187,7 +187,7 @@ class ProgressPlugin {
 				const numberOfHooks = Object.keys(hooks).length;
 				Object.keys(hooks).forEach((name, idx) => {
 					const title = hooks[name];
-					const percentage = idx / numberOfHooks * 0.25 + 0.7;
+					const percentage = (idx / numberOfHooks) * 0.25 + 0.7;
 					compilation.hooks[name].intercept({
 						name: "ProgressPlugin",
 						context: true,

package/lib/RawModule.js

@@ -42,9 +42,11 @@ module.exports = class RawModule extends Module {
 	}
 
 	source() {
-		if (this.useSourceMap)
+		if (this.useSourceMap) {
 			return new OriginalSource(this.sourceStr, this.identifier());
-		else return new RawSource(this.sourceStr);
+		} else {
+			return new RawSource(this.sourceStr);
+		}
 	}
 
 	updateHash(hash) {

package/lib/RecordIdsPlugin.js

@@ -56,18 +56,20 @@ class RecordIdsPlugin {
 							module.id = id;
 						}
 					}
-					if (Array.isArray(records.modules.usedIds))
+					if (Array.isArray(records.modules.usedIds)) {
 						compilation.usedModuleIds = new Set(records.modules.usedIds);
+					}
 				}
 			);
 
 			const getModuleIdentifier = module => {
-				if (portableIds)
+				if (portableIds) {
 					return identifierUtils.makePathsRelative(
 						compiler.context,
 						module.identifier(),
 						compilation.cache
 					);
+				}
 				return module.identifier();
 			};
 
@@ -77,26 +79,27 @@ class RecordIdsPlugin {
 					const index = chunkGroup.chunks.indexOf(chunk);
 					for (const origin of chunkGroup.origins) {
 						if (origin.module) {
-							if (origin.request)
+							if (origin.request) {
 								sources.push(
 									`${index} ${getModuleIdentifier(origin.module)} ${
 										origin.request
 									}`
 								);
-							else if (typeof origin.loc === "string")
+							} else if (typeof origin.loc === "string") {
 								sources.push(
 									`${index} ${getModuleIdentifier(origin.module)} ${origin.loc}`
 								);
-							else if (
+							} else if (
 								origin.loc &&
 								typeof origin.loc === "object" &&
 								origin.loc.start
-							)
+							) {
 								sources.push(
 									`${index} ${getModuleIdentifier(
 										origin.module
 									)} ${JSON.stringify(origin.loc.start)}`
 								);
+							}
 						}
 					}
 				}
@@ -152,8 +155,9 @@ class RecordIdsPlugin {
 							}
 						}
 					}
-					if (Array.isArray(records.chunks.usedIds))
+					if (Array.isArray(records.chunks.usedIds)) {
 						compilation.usedChunkIds = new Set(records.chunks.usedIds);
+					}
 				}
 			);
 		});

package/lib/RequestShortener.js

@@ -23,8 +23,9 @@ const createRegExpForPath = path => {
 class RequestShortener {
 	constructor(directory) {
 		directory = normalizeBackSlashDirection(directory);
-		if (SEPARATOR_REGEXP.test(directory))
+		if (SEPARATOR_REGEXP.test(directory)) {
 			directory = directory.substr(0, directory.length - 1);
+		}
 
 		if (directory) {
 			this.currentDirectoryRegExp = createRegExpForPath(directory);
@@ -54,16 +55,22 @@ class RequestShortener {
 	shorten(request) {
 		if (!request) return request;
 		const cacheEntry = this.cache.get(request);
-		if (cacheEntry !== undefined) return cacheEntry;
+		if (cacheEntry !== undefined) {
+			return cacheEntry;
+		}
 		let result = normalizeBackSlashDirection(request);
-		if (this.buildinsAsModule && this.buildinsRegExp)
+		if (this.buildinsAsModule && this.buildinsRegExp) {
 			result = result.replace(this.buildinsRegExp, "!(webpack)");
-		if (this.currentDirectoryRegExp)
+		}
+		if (this.currentDirectoryRegExp) {
 			result = result.replace(this.currentDirectoryRegExp, "!.");
-		if (this.parentDirectoryRegExp)
+		}
+		if (this.parentDirectoryRegExp) {
 			result = result.replace(this.parentDirectoryRegExp, "!..");
-		if (!this.buildinsAsModule && this.buildinsRegExp)
+		}
+		if (!this.buildinsAsModule && this.buildinsRegExp) {
 			result = result.replace(this.buildinsRegExp, "!(webpack)");
+		}
 		result = result.replace(INDEX_JS_REGEXP, "$1");
 		result = result.replace(FRONT_OR_BACK_BANG_REGEXP, "");
 		this.cache.set(request, result);