webpack 3.3.0 → 3.5.1

package/lib/DelegatedPlugin.js

@@ -7,6 +7,8 @@
 
 const DelegatedModuleFactoryPlugin = require("./DelegatedModuleFactoryPlugin");
 const DelegatedSourceDependency = require("./dependencies/DelegatedSourceDependency");
+const DelegatedExportsDependency = require("./dependencies/DelegatedExportsDependency");
+const NullFactory = require("./NullFactory");
 
 class DelegatedPlugin {
 	constructor(options) {
@@ -16,6 +18,7 @@ class DelegatedPlugin {
 	apply(compiler) {
 		compiler.plugin("compilation", (compilation, params) => {
 			compilation.dependencyFactories.set(DelegatedSourceDependency, params.normalModuleFactory);
+			compilation.dependencyFactories.set(DelegatedExportsDependency, new NullFactory());
 		});
 
 		compiler.plugin("compile", (params) => {

package/lib/DllReferencePlugin.js

@@ -7,6 +7,8 @@
 const DelegatedSourceDependency = require("./dependencies/DelegatedSourceDependency");
 const DelegatedModuleFactoryPlugin = require("./DelegatedModuleFactoryPlugin");
 const ExternalModuleFactoryPlugin = require("./ExternalModuleFactoryPlugin");
+const DelegatedExportsDependency = require("./dependencies/DelegatedExportsDependency");
+const NullFactory = require("./NullFactory");
 
 class DllReferencePlugin {
 	constructor(options) {
@@ -17,6 +19,7 @@ class DllReferencePlugin {
 		compiler.plugin("compilation", (compilation, params) => {
 			const normalModuleFactory = params.normalModuleFactory;
 			compilation.dependencyFactories.set(DelegatedSourceDependency, normalModuleFactory);
+			compilation.dependencyFactories.set(DelegatedExportsDependency, new NullFactory());
 		});
 
 		compiler.plugin("before-compile", (params, callback) => {

package/lib/ExternalModule.js

@@ -10,14 +10,19 @@ const WebpackMissingModule = require("./dependencies/WebpackMissingModule");
 const Template = require("./Template");
 
 class ExternalModule extends Module {
-	constructor(request, type) {
+	constructor(request, type, userRequest) {
 		super();
 		this.request = request;
+		this.userRequest = userRequest;
 		this.type = type;
 		this.built = false;
 		this.external = true;
 	}
 
+	libIdent() {
+		return this.userRequest;
+	}
+
 	chunkCondition(chunk) {
 		return chunk.hasEntryModule();
 	}

package/lib/ExternalModuleFactoryPlugin.js

@@ -30,7 +30,7 @@ class ExternalModuleFactoryPlugin {
 					type = value.substr(0, idx);
 					value = value.substr(idx + 1);
 				}
-				callback(null, new ExternalModule(value, type || globalType));
+				callback(null, new ExternalModule(value, type || globalType, dependency.request));
 				return true;
 			}
 			(function handleExternals(externals, callback) {

package/lib/HotModuleReplacement.runtime.js

@@ -228,11 +228,19 @@ module.exports = function() {
 		hotDeferred = null;
 		if(!deferred) return;
 		if(hotApplyOnUpdate) {
-			hotApply(hotApplyOnUpdate).then(function(result) {
-				deferred.resolve(result);
-			}, function(err) {
-				deferred.reject(err);
-			});
+			// Wrap deferred object in Promise to mark it as a well-handled Promise to
+			// avoid triggering uncaught exception warning in Chrome.
+			// See https://bugs.chromium.org/p/chromium/issues/detail?id=465666
+			Promise.resolve().then(function() {
+				return hotApply(hotApplyOnUpdate);
+			}).then(
+				function(result) {
+					deferred.resolve(result);
+				},
+				function(err) {
+					deferred.reject(err);
+				}
+			);
 		} else {
 			var outdatedModules = [];
 			for(var id in hotUpdate) {

package/lib/MultiCompiler.js

@@ -46,8 +46,8 @@ module.exports = class MultiCompiler extends Tapable {
 	get outputPath() {
 		let commonPath = this.compilers[0].outputPath;
 		for(const compiler of this.compilers) {
-			while(compiler.outputPath.indexOf(commonPath) !== 0 && /[\/\\]/.test(commonPath)) {
-				commonPath = commonPath.replace(/[\/\\][^\/\\]*$/, "");
+			while(compiler.outputPath.indexOf(commonPath) !== 0 && /[/\\]/.test(commonPath)) {
+				commonPath = commonPath.replace(/[/\\][^/\\]*$/, "");
 			}
 		}
 

package/lib/NormalModule.js

@@ -392,9 +392,16 @@ class NormalModule extends Module {
 		 * These will contain the variable name and its expression.
 		 * The name will be added as a paramter in a IIFE the expression as its value.
 		 */
-		const vars = block.variables.map((variable) => this.sourceVariables(
-				variable, availableVars, dependencyTemplates, outputOptions, requestShortener))
-			.filter(Boolean);
+		const vars = block.variables.reduce((result, value) => {
+			const variable = this.sourceVariables(
+				value, availableVars, dependencyTemplates, outputOptions, requestShortener);
+
+			if(variable) {
+				result.push(variable);
+			}
+
+			return result;
+		}, []);
 
 		/**
 		 * if we actually have variables
@@ -420,15 +427,22 @@ class NormalModule extends Module {
 			const injectionVariableChunks = this.splitVariablesInUniqueNamedChunks(vars);
 
 			// create all the beginnings of IIFEs
-			const functionWrapperStarts = injectionVariableChunks.map((variableChunk) => variableChunk.map(variable => variable.name))
-				.map(names => this.variableInjectionFunctionWrapperStartCode(names));
+			const functionWrapperStarts = injectionVariableChunks.map((variableChunk) => {
+				return this.variableInjectionFunctionWrapperStartCode(
+					variableChunk.map(variable => variable.name)
+				);
+			});
 
 			// and all the ends
-			const functionWrapperEnds = injectionVariableChunks.map((variableChunk) => variableChunk.map(variable => variable.expression))
-				.map(expressions => this.variableInjectionFunctionWrapperEndCode(expressions, block));
+			const functionWrapperEnds = injectionVariableChunks.map((variableChunk) => {
+				return this.variableInjectionFunctionWrapperEndCode(
+					variableChunk.map(variable => variable.expression), block
+				);
+			});
 
 			// join them to one big string
 			const varStartCode = functionWrapperStarts.join("");
+
 			// reverse the ends first before joining them, as the last added must be the inner most
 			const varEndCode = functionWrapperEnds.reverse().join("");
 
@@ -440,8 +454,17 @@ class NormalModule extends Module {
 				source.insert(end + 0.5, "\n/* WEBPACK VAR INJECTION */" + varEndCode);
 			}
 		}
-		block.blocks.forEach((block) => this.sourceBlock(
-			block, availableVars.concat(vars), dependencyTemplates, source, outputOptions, requestShortener));
+
+		block.blocks.forEach((block) =>
+			this.sourceBlock(
+				block,
+				availableVars.concat(vars),
+				dependencyTemplates,
+				source,
+				outputOptions,
+				requestShortener
+			)
+		);
 	}
 
 	source(dependencyTemplates, outputOptions, requestShortener) {

package/lib/NormalModuleFactory.js

@@ -50,173 +50,161 @@ class NormalModuleFactory extends Tapable {
 		this.cachePredicate = typeof options.unsafeCache === "function" ? options.unsafeCache : Boolean.bind(null, options.unsafeCache);
 		this.context = context || "";
 		this.parserCache = {};
-		this.plugin("factory", function() {
-			/* beautify preserve:start */
-            // js-beautify consider to concat "return" and "("
-            // but it сontradicts eslint rule (keyword-spacing)
-			return (result, callback) => {
-				/* beautify preserve:end */
-				let resolver = this.applyPluginsWaterfall0("resolver", null);
+		this.plugin("factory", () => (result, callback) => {
+			let resolver = this.applyPluginsWaterfall0("resolver", null);
 
-				// Ignored
-				if(!resolver) return callback();
-
-				resolver(result, (err, data) => {
-					if(err) return callback(err);
+			// Ignored
+			if(!resolver) return callback();
 
-					// Ignored
-					if(!data) return callback();
+			resolver(result, (err, data) => {
+				if(err) return callback(err);
 
-					// direct module
-					if(typeof data.source === "function")
-						return callback(null, data);
+				// Ignored
+				if(!data) return callback();
 
-					this.applyPluginsAsyncWaterfall("after-resolve", data, (err, result) => {
-						if(err) return callback(err);
+				// direct module
+				if(typeof data.source === "function")
+					return callback(null, data);
 
-						// Ignored
-						if(!result) return callback();
+				this.applyPluginsAsyncWaterfall("after-resolve", data, (err, result) => {
+					if(err) return callback(err);
 
-						let createdModule = this.applyPluginsBailResult("create-module", result);
-						if(!createdModule) {
+					// Ignored
+					if(!result) return callback();
 
-							if(!result.request) {
-								return callback(new Error("Empty dependency (no request)"));
-							}
+					let createdModule = this.applyPluginsBailResult("create-module", result);
+					if(!createdModule) {
 
-							createdModule = new NormalModule(
-								result.request,
-								result.userRequest,
-								result.rawRequest,
-								result.loaders,
-								result.resource,
-								result.parser
-							);
+						if(!result.request) {
+							return callback(new Error("Empty dependency (no request)"));
 						}
 
-						createdModule = this.applyPluginsWaterfall0("module", createdModule);
+						createdModule = new NormalModule(
+							result.request,
+							result.userRequest,
+							result.rawRequest,
+							result.loaders,
+							result.resource,
+							result.parser
+						);
+					}
 
-						return callback(null, createdModule);
-					});
+					createdModule = this.applyPluginsWaterfall0("module", createdModule);
+
+					return callback(null, createdModule);
 				});
-			};
+			});
 		});
-		this.plugin("resolver", function() {
-			/* beautify preserve:start */
-            // js-beautify consider to concat "return" and "("
-            // but it сontradicts eslint rule (keyword-spacing)
-			return (data, callback) => {
-				/* beautify preserve:end */
-				const contextInfo = data.contextInfo;
-				const context = data.context;
-				const request = data.request;
-
-				const noAutoLoaders = /^-?!/.test(request);
-				const noPrePostAutoLoaders = /^!!/.test(request);
-				const noPostAutoLoaders = /^-!/.test(request);
-				let elements = request.replace(/^-?!+/, "").replace(/!!+/g, "!").split("!");
-				let resource = elements.pop();
-				elements = elements.map(identToLoaderRequest);
-
-				asyncLib.parallel([
-					callback => this.resolveRequestArray(contextInfo, context, elements, this.resolvers.loader, callback),
-					callback => {
-						if(resource === "" || resource[0] === "?")
-							return callback(null, {
-								resource
-							});
-
-						this.resolvers.normal.resolve(contextInfo, context, resource, (err, resource, resourceResolveData) => {
-							if(err) return callback(err);
-							callback(null, {
-								resourceResolveData,
-								resource
-							});
+		this.plugin("resolver", () => (data, callback) => {
+			const contextInfo = data.contextInfo;
+			const context = data.context;
+			const request = data.request;
+
+			const noAutoLoaders = /^-?!/.test(request);
+			const noPrePostAutoLoaders = /^!!/.test(request);
+			const noPostAutoLoaders = /^-!/.test(request);
+			let elements = request.replace(/^-?!+/, "").replace(/!!+/g, "!").split("!");
+			let resource = elements.pop();
+			elements = elements.map(identToLoaderRequest);
+
+			asyncLib.parallel([
+				callback => this.resolveRequestArray(contextInfo, context, elements, this.resolvers.loader, callback),
+				callback => {
+					if(resource === "" || resource[0] === "?")
+						return callback(null, {
+							resource
 						});
-					}
-				], (err, results) => {
-					if(err) return callback(err);
-					let loaders = results[0];
-					const resourceResolveData = results[1].resourceResolveData;
-					resource = results[1].resource;
-
-					// translate option idents
-					try {
-						loaders.forEach(item => {
-							if(typeof item.options === "string" && /^\?/.test(item.options)) {
-								item.options = this.ruleSet.findOptionsByIdent(item.options.substr(1));
-							}
+
+					this.resolvers.normal.resolve(contextInfo, context, resource, (err, resource, resourceResolveData) => {
+						if(err) return callback(err);
+						callback(null, {
+							resourceResolveData,
+							resource
 						});
-					} catch(e) {
-						return callback(e);
-					}
+					});
+				}
+			], (err, results) => {
+				if(err) return callback(err);
+				let loaders = results[0];
+				const resourceResolveData = results[1].resourceResolveData;
+				resource = results[1].resource;
+
+				// translate option idents
+				try {
+					loaders.forEach(item => {
+						if(typeof item.options === "string" && /^\?/.test(item.options)) {
+							item.options = this.ruleSet.findOptionsByIdent(item.options.substr(1));
+						}
+					});
+				} catch(e) {
+					return callback(e);
+				}
 
-					if(resource === false) {
-						// ignored
-						return callback(null,
-							new RawModule(
-								"/* (ignored) */",
-								`ignored ${context} ${request}`,
-								`${request} (ignored)`
-							)
-						);
-					}
+				if(resource === false) {
+					// ignored
+					return callback(null,
+						new RawModule(
+							"/* (ignored) */",
+							`ignored ${context} ${request}`,
+							`${request} (ignored)`
+						)
+					);
+				}
 
-					const userRequest = loaders.map(loaderToIdent).concat([resource]).join("!");
+				const userRequest = loaders.map(loaderToIdent).concat([resource]).join("!");
 
-					let resourcePath = resource;
-					let resourceQuery = "";
-					const queryIndex = resourcePath.indexOf("?");
-					if(queryIndex >= 0) {
-						resourceQuery = resourcePath.substr(queryIndex);
-						resourcePath = resourcePath.substr(0, queryIndex);
-					}
+				let resourcePath = resource;
+				let resourceQuery = "";
+				const queryIndex = resourcePath.indexOf("?");
+				if(queryIndex >= 0) {
+					resourceQuery = resourcePath.substr(queryIndex);
+					resourcePath = resourcePath.substr(0, queryIndex);
+				}
 
-					const result = this.ruleSet.exec({
-						resource: resourcePath,
-						resourceQuery,
-						issuer: contextInfo.issuer,
-						compiler: contextInfo.compiler
-					});
-					const settings = {};
-					const useLoadersPost = [];
-					const useLoaders = [];
-					const useLoadersPre = [];
-					result.forEach(r => {
-						if(r.type === "use") {
-							if(r.enforce === "post" && !noPostAutoLoaders && !noPrePostAutoLoaders)
-								useLoadersPost.push(r.value);
-							else if(r.enforce === "pre" && !noPrePostAutoLoaders)
-								useLoadersPre.push(r.value);
-							else if(!r.enforce && !noAutoLoaders && !noPrePostAutoLoaders)
-								useLoaders.push(r.value);
-						} else {
-							settings[r.type] = r.value;
-						}
-					});
-					asyncLib.parallel([
-						this.resolveRequestArray.bind(this, contextInfo, this.context, useLoadersPost, this.resolvers.loader),
-						this.resolveRequestArray.bind(this, contextInfo, this.context, useLoaders, this.resolvers.loader),
-						this.resolveRequestArray.bind(this, contextInfo, this.context, useLoadersPre, this.resolvers.loader)
-					], (err, results) => {
-						if(err) return callback(err);
-						loaders = results[0].concat(loaders, results[1], results[2]);
-						process.nextTick(() => {
-							callback(null, {
-								context: context,
-								request: loaders.map(loaderToIdent).concat([resource]).join("!"),
-								dependencies: data.dependencies,
-								userRequest,
-								rawRequest: request,
-								loaders,
-								resource,
-								resourceResolveData,
-								parser: this.getParser(settings.parser)
-							});
+				const result = this.ruleSet.exec({
+					resource: resourcePath,
+					resourceQuery,
+					issuer: contextInfo.issuer,
+					compiler: contextInfo.compiler
+				});
+				const settings = {};
+				const useLoadersPost = [];
+				const useLoaders = [];
+				const useLoadersPre = [];
+				result.forEach(r => {
+					if(r.type === "use") {
+						if(r.enforce === "post" && !noPostAutoLoaders && !noPrePostAutoLoaders)
+							useLoadersPost.push(r.value);
+						else if(r.enforce === "pre" && !noPrePostAutoLoaders)
+							useLoadersPre.push(r.value);
+						else if(!r.enforce && !noAutoLoaders && !noPrePostAutoLoaders)
+							useLoaders.push(r.value);
+					} else {
+						settings[r.type] = r.value;
+					}
+				});
+				asyncLib.parallel([
+					this.resolveRequestArray.bind(this, contextInfo, this.context, useLoadersPost, this.resolvers.loader),
+					this.resolveRequestArray.bind(this, contextInfo, this.context, useLoaders, this.resolvers.loader),
+					this.resolveRequestArray.bind(this, contextInfo, this.context, useLoadersPre, this.resolvers.loader)
+				], (err, results) => {
+					if(err) return callback(err);
+					loaders = results[0].concat(loaders, results[1], results[2]);
+					process.nextTick(() => {
+						callback(null, {
+							context: context,
+							request: loaders.map(loaderToIdent).concat([resource]).join("!"),
+							dependencies: data.dependencies,
+							userRequest,
+							rawRequest: request,
+							loaders,
+							resource,
+							resourceResolveData,
+							parser: this.getParser(settings.parser)
 						});
 					});
 				});
-			};
+			});
 		});
 	}
 

package/lib/Parser.js

@@ -214,19 +214,10 @@ class Parser extends Tapable {
 					}
 				}
 				if(expr.argument.type === "MemberExpression") {
-					let expression = expr.argument;
-					let exprName = [];
-					while(expression.type === "MemberExpression" && !expression.computed) {
-						exprName.unshift(this.scope.renames["$" + expression.property.name] || expression.property.name);
-						expression = expression.object;
-					}
-					if(expression.type === "Identifier") {
-						exprName.unshift(this.scope.renames["$" + expression.name] || expression.name);
-						if(this.scope.definitions.indexOf(name) === -1) {
-							exprName = exprName.join(".");
-							res = this.applyPluginsBailResult1("evaluate typeof " + exprName, expr);
-							if(res !== undefined) return res;
-						}
+					const exprName = this.getNameForExpression(expr.argument);
+					if(exprName && exprName.free) {
+						res = this.applyPluginsBailResult1("evaluate typeof " + exprName.name, expr);
+						if(res !== undefined) return res;
 					}
 				}
 				if(expr.argument.type === "FunctionExpression") {
@@ -275,24 +266,14 @@ class Parser extends Tapable {
 			}
 		});
 		this.plugin("evaluate MemberExpression", function(expression) {
-			let expr = expression;
-			let exprName = [];
-			while(expr.type === "MemberExpression" && expr.property.type === (expr.computed ? "Literal" : "Identifier")) {
-				exprName.unshift(expr.property.name || expr.property.value);
-				expr = expr.object;
-			}
-			if(expr.type === "Identifier") {
-				const name = this.scope.renames["$" + expr.name] || expr.name;
-				if(this.scope.definitions.indexOf(name) === -1) {
-					exprName.unshift(name);
-					exprName = exprName.join(".");
-					if(this.scope.definitions.indexOf(expr.name) === -1) {
-						const result = this.applyPluginsBailResult1("evaluate Identifier " + exprName, expression);
-						if(result) return result;
-						return new BasicEvaluatedExpression().setIdentifier(exprName).setRange(expression.range);
-					} else {
-						return this.applyPluginsBailResult1("evaluate defined Identifier " + exprName, expression);
-					}
+			let exprName = this.getNameForExpression(expression);
+			if(exprName) {
+				if(exprName.free) {
+					const result = this.applyPluginsBailResult1("evaluate Identifier " + exprName.name, expression);
+					if(result) return result;
+					return new BasicEvaluatedExpression().setIdentifier(exprName.name).setRange(expression.range);
+				} else {
+					return this.applyPluginsBailResult1("evaluate defined Identifier " + exprName.name, expression);
 				}
 			}
 		});
@@ -970,16 +951,9 @@ class Parser extends Tapable {
 
 	walkUnaryExpression(expression) {
 		if(expression.operator === "typeof") {
-			let expr = expression.argument;
-			let exprName = [];
-			while(expr.type === "MemberExpression" && expr.property.type === (expr.computed ? "Literal" : "Identifier")) {
-				exprName.unshift(expr.property.name || expr.property.value);
-				expr = expr.object;
-			}
-			if(expr.type === "Identifier" && this.scope.definitions.indexOf(expr.name) === -1) {
-				exprName.unshift(this.scope.renames["$" + expr.name] || expr.name);
-				exprName = exprName.join(".");
-				const result = this.applyPluginsBailResult1("typeof " + exprName, expression);
+			const exprName = this.getNameForExpression(expression.argument);
+			if(exprName && exprName.free) {
+				const result = this.applyPluginsBailResult1("typeof " + exprName.name, expression);
 				if(result === true)
 					return;
 			}
@@ -1128,7 +1102,7 @@ class Parser extends Tapable {
 				result = this.applyPluginsBailResult1("call " + callee.identifier, expression);
 				if(result === true)
 					return;
-				let identifier = callee.identifier.replace(/\.[^\.]+$/, ".*");
+				let identifier = callee.identifier.replace(/\.[^.]+$/, ".*");
 				if(identifier !== callee.identifier) {
 					result = this.applyPluginsBailResult1("call " + identifier, expression);
 					if(result === true)
@@ -1144,24 +1118,12 @@ class Parser extends Tapable {
 	}
 
 	walkMemberExpression(expression) {
-		let expr = expression;
-		let exprName = [];
-		while(expr.type === "MemberExpression" && expr.property.type === (expr.computed ? "Literal" : "Identifier")) {
-			exprName.unshift(expr.property.name || expr.property.value);
-			expr = expr.object;
-		}
-		if((expr.type === "Identifier" && this.scope.definitions.indexOf(expr.name) === -1) ||
-			(expr.type === "ThisExpression" && this.scope.renames.$this)) {
-			if(expr.type === "ThisExpression") {
-				exprName.unshift(this.scope.renames.$this);
-			} else {
-				exprName.unshift(this.scope.renames["$" + expr.name] || expr.name);
-			}
-			let result = this.applyPluginsBailResult1("expression " + exprName.join("."), expression);
+		const exprName = this.getNameForExpression(expression);
+		if(exprName && exprName.free) {
+			let result = this.applyPluginsBailResult1("expression " + exprName.name, expression);
 			if(result === true)
 				return;
-			exprName[exprName.length - 1] = "*";
-			result = this.applyPluginsBailResult1("expression " + exprName.join("."), expression);
+			result = this.applyPluginsBailResult1("expression " + exprName.nameGeneral, expression);
 			if(result === true)
 				return;
 		}
@@ -1430,6 +1392,38 @@ class Parser extends Tapable {
 		return options.reduce((o, i) => Object.assign(o, i), {});
 	}
 
+	getNameForExpression(expression) {
+		let expr = expression;
+		const exprName = [];
+		while(expr.type === "MemberExpression" && expr.property.type === (expr.computed ? "Literal" : "Identifier")) {
+			exprName.push(expr.computed ? expr.property.value : expr.property.name);
+			expr = expr.object;
+		}
+		let free;
+		if(expr.type === "Identifier") {
+			free = this.scope.definitions.indexOf(expr.name) === -1;
+			exprName.push(this.scope.renames["$" + expr.name] || expr.name);
+		} else if(expr.type === "ThisExpression" && this.scope.renames.$this) {
+			free = true;
+			exprName.push(this.scope.renames.$this);
+		} else if(expr.type === "ThisExpression") {
+			free = false;
+			exprName.push("this");
+		} else {
+			return null;
+		}
+		let prefix = "";
+		for(let i = exprName.length - 1; i >= 1; i--)
+			prefix += exprName[i] + ".";
+		const name = prefix + exprName[0];
+		const nameGeneral = prefix + "*";
+		return {
+			name,
+			nameGeneral,
+			free
+		};
+	}
+
 }
 
 Parser.ECMA_VERSION = ECMA_VERSION;

package/lib/RecordIdsPlugin.js

@@ -47,12 +47,12 @@ class RecordIdsPlugin {
 					const p = block.parent;
 					const idx = p.blocks.indexOf(block);
 					const l = p.blocks.length - 1;
-					ident.unshift(`${idx}/${l}`);
+					ident.push(`${idx}/${l}`);
 					block = block.parent;
 				}
 				if(!block.identifier) return null;
-				ident.unshift(identifierUtils.makePathsRelative(compiler.context, block.identifier()));
-				return ident.join(":");
+				ident.push(identifierUtils.makePathsRelative(compiler.context, block.identifier()));
+				return ident.reverse().join(":");
 			}
 			compilation.plugin("record-chunks", (chunks, records) => {
 				records.nextFreeChunkId = compilation.nextFreeChunkId;