webpack 2.5.0 → 2.7.0

package/lib/Compiler.js

@@ -88,7 +88,7 @@ Watching.prototype._done = function(err, compilation) {
 	this.running = false;
 	if(this.invalid) return this._go();
 
-	var stats = this._getStats(compilation);
+	var stats = compilation ? this._getStats(compilation) : null;
 	if(err) {
 		this.compiler.applyPlugins("failed", err);
 		this.handler(err, stats);

package/lib/ContextModule.js

@@ -8,16 +8,18 @@ const Module = require("./Module");
 const OriginalSource = require("webpack-sources").OriginalSource;
 const RawSource = require("webpack-sources").RawSource;
 const AsyncDependenciesBlock = require("./AsyncDependenciesBlock");
+const DepBlockHelpers = require("./dependencies/DepBlockHelpers");
+const Template = require("./Template");
 
 class ContextModule extends Module {
-	constructor(resolveDependencies, context, recursive, regExp, addon, isAsync, chunkName) {
+	constructor(resolveDependencies, context, recursive, regExp, addon, asyncMode, chunkName) {
 		super();
 		this.resolveDependencies = resolveDependencies;
 		this.context = context;
 		this.recursive = recursive;
 		this.regExp = regExp;
 		this.addon = addon;
-		this.async = !!isAsync;
+		this.async = asyncMode;
 		this.cacheable = true;
 		this.contextDependencies = [context];
 		this.built = false;
@@ -44,7 +46,7 @@ class ContextModule extends Module {
 	identifier() {
 		let identifier = this.context;
 		if(this.async)
-			identifier += " async";
+			identifier += ` ${this.async}`;
 		if(!this.recursive)
 			identifier += " nonrecursive";
 		if(this.addon)
@@ -58,7 +60,7 @@ class ContextModule extends Module {
 	readableIdentifier(requestShortener) {
 		let identifier = requestShortener.shorten(this.context);
 		if(this.async)
-			identifier += " async";
+			identifier += ` ${this.async}`;
 		if(!this.recursive)
 			identifier += " nonrecursive";
 		if(this.addon)
@@ -72,7 +74,7 @@ class ContextModule extends Module {
 	libIdent(options) {
 		let identifier = this.contextify(options.context, this.context);
 		if(this.async)
-			identifier += " async";
+			identifier += ` ${this.async}`;
 		if(this.recursive)
 			identifier += " recursive";
 		if(this.addon)
@@ -103,42 +105,67 @@ class ContextModule extends Module {
 		this.resolveDependencies(fs, this.context, this.recursive, this.regExp, (err, dependencies) => {
 			if(err) return callback(err);
 
+			// Reset children
+			this.dependencies = [];
+			this.blocks = [];
+
+			// abort if something failed
+			// this will create an empty context
 			if(!dependencies) {
-				this.dependencies = [];
 				callback();
 				return;
 			}
 
-			// enhance dependencies
+			// enhance dependencies with meta info
 			dependencies.forEach(dep => {
 				dep.loc = dep.userRequest;
 				dep.request = this.addon + dep.request;
 			});
 
-			// if these we are not a async context
-			// add dependencies and continue
-			if(!this.async) {
+			if(!this.async || this.async === "eager") {
+
+				// if we have an sync or eager context
+				// just add all dependencies and continue
 				this.dependencies = dependencies;
-				callback();
-				return;
-			}
 
-			// if we are async however create a new async dependency block
-			// and add that block to this context
-			dependencies.forEach(dep => {
-				const block = new AsyncDependenciesBlock(this.chunkName, dep.module, dep.loc);
-				block.addDependency(dep);
-				this.addBlock(block);
-			});
+			} else if(this.async === "lazy-once") {
+
+				// for the lazy-once mode create a new async dependency block
+				// and add that block to this context
+				if(dependencies.length > 0) {
+					const block = new AsyncDependenciesBlock(this.chunkName, this);
+					dependencies.forEach(dep => {
+						block.addDependency(dep);
+					});
+					this.addBlock(block);
+				}
+
+			} else {
+
+				// if we are lazy create a new async dependency block per dependency
+				// and add all blocks to this context
+				dependencies.forEach((dep, idx) => {
+					let chunkName = this.chunkName;
+					if(chunkName) {
+						if(!/\[(index|request)\]/.test(chunkName))
+							chunkName += "[index]";
+						chunkName = chunkName.replace(/\[index\]/g, idx);
+						chunkName = chunkName.replace(/\[request\]/g, Template.toPath(dep.userRequest));
+					}
+					const block = new AsyncDependenciesBlock(chunkName, dep.module, dep.loc);
+					block.addDependency(dep);
+					this.addBlock(block);
+				});
+			}
 			callback();
 		});
 	}
 
-	getSourceWithDependencies(dependencies, id) {
+	getUserRequestMap(dependencies) {
 		// if we filter first we get a new array
 		// therefor we dont need to create a clone of dependencies explicitly
 		// therefore the order of this is !important!
-		const map = dependencies
+		return dependencies
 			.filter(dependency => dependency.module)
 			.sort((a, b) => {
 				if(a.userRequest === b.userRequest) {
@@ -149,6 +176,10 @@ class ContextModule extends Module {
 				map[dep.userRequest] = dep.module.id;
 				return map;
 			}, Object.create(null));
+	}
+
+	getSyncSource(dependencies, id) {
+		const map = this.getUserRequestMap(dependencies);
 		return `var map = ${JSON.stringify(map, null, "\t")};
 function webpackContext(req) {
 	return __webpack_require__(webpackContextResolve(req));
@@ -167,7 +198,53 @@ module.exports = webpackContext;
 webpackContext.id = ${JSON.stringify(id)};`;
 	}
 
-	getSourceWithBlocks(blocks, id) {
+	getEagerSource(dependencies, id) {
+		const map = this.getUserRequestMap(dependencies);
+		return `var map = ${JSON.stringify(map, null, "\t")};
+function webpackAsyncContext(req) {
+	return webpackAsyncContextResolve(req).then(__webpack_require__);
+};
+function webpackAsyncContextResolve(req) {
+	return new Promise(function(resolve, reject) {
+		var id = map[req];
+		if(!(id + 1)) // check for number or string
+			reject(new Error("Cannot find module '" + req + "'."));
+		else
+			resolve(id);
+	});
+};
+webpackAsyncContext.keys = function webpackAsyncContextKeys() {
+	return Object.keys(map);
+};
+webpackAsyncContext.resolve = webpackAsyncContextResolve;
+module.exports = webpackAsyncContext;
+webpackAsyncContext.id = ${JSON.stringify(id)};`;
+	}
+
+	getLazyOnceSource(block, dependencies, id, outputOptions, requestShortener) {
+		const promise = DepBlockHelpers.getDepBlockPromise(block, outputOptions, requestShortener, "lazy-once context");
+		const map = this.getUserRequestMap(dependencies);
+		return `var map = ${JSON.stringify(map, null, "\t")};
+function webpackAsyncContext(req) {
+	return webpackAsyncContextResolve(req).then(__webpack_require__);
+};
+function webpackAsyncContextResolve(req) {
+	return ${promise}.then(function() {
+		var id = map[req];
+		if(!(id + 1)) // check for number or string
+			throw new Error("Cannot find module '" + req + "'.");
+		return id;
+	});
+};
+webpackAsyncContext.keys = function webpackAsyncContextKeys() {
+	return Object.keys(map);
+};
+webpackAsyncContext.resolve = webpackAsyncContextResolve;
+module.exports = webpackAsyncContext;
+webpackAsyncContext.id = ${JSON.stringify(id)};`;
+	}
+
+	getLazySource(blocks, id) {
 		let hasMultipleOrNoChunks = false;
 		const map = blocks
 			.filter(block => block.dependencies[0].module)
@@ -219,15 +296,38 @@ module.exports = webpackEmptyContext;
 webpackEmptyContext.id = ${JSON.stringify(id)};`;
 	}
 
-	getSourceString() {
-		if(this.dependencies && this.dependencies.length > 0) {
-			return this.getSourceWithDependencies(this.dependencies, this.id);
-		}
+	getSourceForEmptyAsyncContext(id) {
+		return `function webpackEmptyAsyncContext(req) {
+	return new Promise(function(resolve, reject) { reject(new Error("Cannot find module '" + req + "'.")); });
+}
+webpackEmptyAsyncContext.keys = function() { return []; };
+webpackEmptyAsyncContext.resolve = webpackEmptyAsyncContext;
+module.exports = webpackEmptyAsyncContext;
+webpackEmptyAsyncContext.id = ${JSON.stringify(id)};`;
+	}
 
-		if(this.blocks && this.blocks.length > 0) {
-			return this.getSourceWithBlocks(this.blocks, this.id);
+	getSourceString(asyncMode, outputOptions, requestShortener) {
+		if(asyncMode === "lazy") {
+			if(this.blocks && this.blocks.length > 0) {
+				return this.getLazySource(this.blocks, this.id);
+			}
+			return this.getSourceForEmptyAsyncContext(this.id);
+		}
+		if(asyncMode === "eager") {
+			if(this.dependencies && this.dependencies.length > 0) {
+				return this.getEagerSource(this.dependencies, this.id);
+			}
+			return this.getSourceForEmptyAsyncContext(this.id);
+		} else if(asyncMode === "lazy-once") {
+			const block = this.blocks[0];
+			if(block) {
+				return this.getLazyOnceSource(block, block.dependencies, this.id, outputOptions, requestShortener);
+			}
+			return this.getSourceForEmptyAsyncContext(this.id);
+		}
+		if(this.dependencies && this.dependencies.length > 0) {
+			return this.getSyncSource(this.dependencies, this.id);
 		}
-
 		return this.getSourceForEmptyContext(this.id);
 	}
 
@@ -238,9 +338,9 @@ webpackEmptyContext.id = ${JSON.stringify(id)};`;
 		return new RawSource(sourceString);
 	}
 
-	source() {
+	source(dependencyTemplates, outputOptions, requestShortener) {
 		return this.getSource(
-			this.getSourceString()
+			this.getSourceString(this.async, outputOptions, requestShortener)
 		);
 	}
 

package/lib/EvalSourceMapDevToolModuleTemplatePlugin.js

@@ -10,7 +10,7 @@ const ModuleFilenameHelpers = require("./ModuleFilenameHelpers");
 class EvalSourceMapDevToolModuleTemplatePlugin {
 	constructor(compilation, options) {
 		this.compilation = compilation;
-		this.sourceMapComment = options.append || "//# sourceMappingURL=[url]";
+		this.sourceMapComment = options.append || "//# sourceURL=[module]\n//# sourceMappingURL=[url]";
 		this.moduleFilenameTemplate = options.moduleFilenameTemplate || "webpack:///[resource-path]?[hash]";
 		this.options = options;
 	}
@@ -61,13 +61,14 @@ class EvalSourceMapDevToolModuleTemplatePlugin {
 			sourceMap.sourceRoot = options.sourceRoot || "";
 			sourceMap.file = `${module.id}.js`;
 
-			const footer = self.sourceMapComment.replace(/\[url\]/g, `data:application/json;charset=utf-8;base64,${new Buffer(JSON.stringify(sourceMap), "utf8").toString("base64")}`); //eslint-disable-line
+			const footer = self.sourceMapComment.replace(/\[url\]/g, `data:application/json;charset=utf-8;base64,${new Buffer(JSON.stringify(sourceMap), "utf8").toString("base64")}`) + //eslint-disable-line
+				`\n//# sourceURL=webpack-internal:///${module.id}\n`; // workaround for chrome bug
 			source.__EvalSourceMapDevToolData = new RawSource(`eval(${JSON.stringify(content + footer)});`);
 			return source.__EvalSourceMapDevToolData;
 		});
 		moduleTemplate.plugin("hash", function(hash) {
 			hash.update("eval-source-map");
-			hash.update("1");
+			hash.update("2");
 		});
 	}
 }

package/lib/FunctionModuleTemplatePlugin.js

@@ -28,7 +28,7 @@ class FunctionModuleTemplatePlugin {
 				if(Array.isArray(module.providedExports))
 					source.add("/* exports provided: " + module.providedExports.join(", ") + " */\n");
 				else if(module.providedExports)
-					source.add("/* unknown exports provided */\n");
+					source.add("/* no static exports found */\n");
 				if(Array.isArray(module.usedExports))
 					source.add("/* exports used: " + module.usedExports.join(", ") + " */\n");
 				else if(module.usedExports)

package/lib/HotModuleReplacement.runtime.js

@@ -578,6 +578,8 @@ module.exports = function() {
 		}
 
 		hotSetStatus("idle");
-		return Promise.resolve(outdatedModules);
+		return new Promise(function(resolve) {
+			resolve(outdatedModules);
+		});
 	}
 };

package/lib/JsonpMainTemplatePlugin.js

@@ -28,7 +28,7 @@ class JsonpMainTemplatePlugin {
 			const chunkFilename = this.outputOptions.chunkFilename;
 			const chunkMaps = chunk.getChunkMaps();
 			const crossOriginLoading = this.outputOptions.crossOriginLoading;
-			const chunkLoadTimeout = this.outputOptions.chunkLoadTimeout || 120000;
+			const chunkLoadTimeout = this.outputOptions.chunkLoadTimeout;
 			const scriptSrcPath = this.applyPluginsWaterfall("asset-path", JSON.stringify(chunkFilename), {
 				hash: `" + ${this.renderCurrentHashCode(hash)} + "`,
 				hashWithLength: length => `" + ${this.renderCurrentHashCode(hash, length)} + "`,
@@ -79,26 +79,27 @@ class JsonpMainTemplatePlugin {
 		});
 		mainTemplate.plugin("require-ensure", function(_, chunk, hash) {
 			return this.asString([
-				"if(installedChunks[chunkId] === 0) {",
+				"var installedChunkData = installedChunks[chunkId];",
+				"if(installedChunkData === 0) {",
 				this.indent([
-					"return Promise.resolve();"
+					"return new Promise(function(resolve) { resolve(); });"
 				]),
 				"}",
 				"",
 				"// a Promise means \"currently loading\".",
-				"if(installedChunks[chunkId]) {",
+				"if(installedChunkData) {",
 				this.indent([
-					"return installedChunks[chunkId][2];"
+					"return installedChunkData[2];"
 				]),
 				"}",
 				"",
 				"// setup Promise in chunk cache",
 				"var promise = new Promise(function(resolve, reject) {",
 				this.indent([
-					"installedChunks[chunkId] = [resolve, reject];"
+					"installedChunkData = installedChunks[chunkId] = [resolve, reject];"
 				]),
 				"});",
-				"installedChunks[chunkId][2] = promise;",
+				"installedChunkData[2] = promise;",
 				"",
 				"// start chunk loading",
 				"var head = document.getElementsByTagName('head')[0];",

package/lib/Parser.js

@@ -636,6 +636,9 @@ class Parser extends Tapable {
 	}
 
 	walkFunctionDeclaration(statement) {
+		statement.params.forEach(param => {
+			this.walkPattern(param);
+		});
 		this.inScope(statement.params, function() {
 			if(statement.body.type === "BlockStatement") {
 				this.prewalkStatement(statement.body);
@@ -797,24 +800,15 @@ class Parser extends Tapable {
 			switch(declarator.type) {
 				case "VariableDeclarator":
 					{
-						const renameIdentifier = declarator.init && this.getRenameIdentifier(declarator.init);
-						if(renameIdentifier && declarator.id.type === "Identifier" && this.applyPluginsBailResult1("can-rename " + renameIdentifier, declarator.init)) {
-							// renaming with "var a = b;"
-							if(!this.applyPluginsBailResult1("rename " + renameIdentifier, declarator.init)) {
-								this.scope.renames["$" + declarator.id.name] = this.scope.renames["$" + renameIdentifier] || renameIdentifier;
-								const idx = this.scope.definitions.indexOf(declarator.id.name);
-								if(idx >= 0) this.scope.definitions.splice(idx, 1);
-							}
-						} else {
-							this.enterPattern(declarator.id, (name, decl) => {
-								if(!this.applyPluginsBailResult1("var-" + declarator.kind + " " + name, decl)) {
-									if(!this.applyPluginsBailResult1("var " + name, decl)) {
-										this.scope.renames["$" + name] = undefined;
+						this.enterPattern(declarator.id, (name, decl) => {
+							if(!this.applyPluginsBailResult1("var-" + declarator.kind + " " + name, decl)) {
+								if(!this.applyPluginsBailResult1("var " + name, decl)) {
+									this.scope.renames["$" + name] = undefined;
+									if(this.scope.definitions.indexOf(name) < 0)
 										this.scope.definitions.push(name);
-									}
 								}
-							});
-						}
+							}
+						});
 						break;
 					}
 			}
@@ -827,7 +821,14 @@ class Parser extends Tapable {
 				case "VariableDeclarator":
 					{
 						const renameIdentifier = declarator.init && this.getRenameIdentifier(declarator.init);
-						if(!renameIdentifier || declarator.id.type !== "Identifier" || !this.applyPluginsBailResult1("can-rename " + renameIdentifier, declarator.init)) {
+						if(renameIdentifier && declarator.id.type === "Identifier" && this.applyPluginsBailResult1("can-rename " + renameIdentifier, declarator.init)) {
+							// renaming with "var a = b;"
+							if(!this.applyPluginsBailResult1("rename " + renameIdentifier, declarator.init)) {
+								this.scope.renames["$" + declarator.id.name] = this.scope.renames["$" + renameIdentifier] || renameIdentifier;
+								const idx = this.scope.definitions.indexOf(declarator.id.name);
+								if(idx >= 0) this.scope.definitions.splice(idx, 1);
+							}
+						} else {
 							this.walkPattern(declarator.id);
 							if(declarator.init)
 								this.walkExpression(declarator.init);
@@ -845,6 +846,11 @@ class Parser extends Tapable {
 			this["walk" + pattern.type](pattern);
 	}
 
+	walkAssignmentPattern(pattern) {
+		this.walkExpression(pattern.right);
+		this.walkPattern(pattern.left);
+	}
+
 	walkObjectPattern(pattern) {
 		for(let i = 0, len = pattern.properties.length; i < len; i++) {
 			const prop = pattern.properties[i];
@@ -912,6 +918,9 @@ class Parser extends Tapable {
 	}
 
 	walkFunctionExpression(expression) {
+		expression.params.forEach(param => {
+			this.walkPattern(param);
+		});
 		this.inScope(expression.params, function() {
 			if(expression.body.type === "BlockStatement") {
 				this.prewalkStatement(expression.body);
@@ -923,6 +932,9 @@ class Parser extends Tapable {
 	}
 
 	walkArrowFunctionExpression(expression) {
+		expression.params.forEach(param => {
+			this.walkPattern(param);
+		});
 		this.inScope(expression.params, function() {
 			if(expression.body.type === "BlockStatement") {
 				this.prewalkStatement(expression.body);
@@ -993,8 +1005,10 @@ class Parser extends Tapable {
 			}
 		} else {
 			this.walkExpression(expression.right);
-			this.scope.renames["$" + expression.left.name] = undefined;
-			this.walkExpression(expression.left);
+			this.walkPattern(expression.left);
+			this.enterPattern(expression.left, (name, decl) => {
+				this.scope.renames["$" + name] = undefined;
+			});
 		}
 	}
 
@@ -1191,7 +1205,6 @@ class Parser extends Tapable {
 
 	enterAssignmentPattern(pattern, onIdent) {
 		this.enterPattern(pattern.left, onIdent);
-		this.walkExpression(pattern.right);
 	}
 
 	evaluateExpression(expression) {

package/lib/SourceMapDevToolPlugin.js

@@ -5,6 +5,7 @@
 "use strict";
 
 const path = require("path");
+const crypto = require("crypto");
 const RequestShortener = require("./RequestShortener");
 const ConcatSource = require("webpack-sources").ConcatSource;
 const RawSource = require("webpack-sources").RawSource;
@@ -131,6 +132,7 @@ class SourceMapDevToolPlugin {
 					if(currentSourceMappingURLComment !== false && /\.css($|\?)/i.test(file)) {
 						currentSourceMappingURLComment = currentSourceMappingURLComment.replace(/^\n\/\/(.*)$/, "\n/*$1*/");
 					}
+					const sourceMapString = JSON.stringify(sourceMap);
 					if(sourceMapFilename) {
 						let filename = file;
 						let query = "";
@@ -139,22 +141,25 @@ class SourceMapDevToolPlugin {
 							query = filename.substr(idx);
 							filename = filename.substr(0, idx);
 						}
-						const sourceMapFile = compilation.getPath(sourceMapFilename, {
+						let sourceMapFile = compilation.getPath(sourceMapFilename, {
 							chunk,
 							filename,
 							query,
 							basename: basename(filename)
 						});
+						if(sourceMapFile.indexOf("[contenthash]") !== -1) {
+							sourceMapFile = sourceMapFile.replace(/\[contenthash\]/g, crypto.createHash("md5").update(sourceMapString).digest("hex"));
+						}
 						const sourceMapUrl = path.relative(path.dirname(file), sourceMapFile).replace(/\\/g, "/");
 						if(currentSourceMappingURLComment !== false) {
 							asset.__SourceMapDevToolData[file] = compilation.assets[file] = new ConcatSource(new RawSource(source), currentSourceMappingURLComment.replace(/\[url\]/g, sourceMapUrl));
 						}
-						asset.__SourceMapDevToolData[sourceMapFile] = compilation.assets[sourceMapFile] = new RawSource(JSON.stringify(sourceMap));
+						asset.__SourceMapDevToolData[sourceMapFile] = compilation.assets[sourceMapFile] = new RawSource(sourceMapString);
 						chunk.files.push(sourceMapFile);
 					} else {
 						asset.__SourceMapDevToolData[file] = compilation.assets[file] = new ConcatSource(new RawSource(source), currentSourceMappingURLComment
-							.replace(/\[map\]/g, () => JSON.stringify(sourceMap))
-							.replace(/\[url\]/g, () => `data:application/json;charset=utf-8;base64,${new Buffer(JSON.stringify(sourceMap), "utf-8").toString("base64")}`) // eslint-disable-line
+							.replace(/\[map\]/g, () => sourceMapString)
+							.replace(/\[url\]/g, () => `data:application/json;charset=utf-8;base64,${new Buffer(sourceMapString, "utf-8").toString("base64")}`) // eslint-disable-line
 						);
 					}
 				});

package/lib/Template.js

@@ -26,6 +26,11 @@ module.exports = class Template extends Tapable {
 		return str.replace(/^[^a-zA-Z$_]/, "_").replace(/[^a-zA-Z0-9$_]/g, "_");
 	}
 
+	static toPath(str) {
+		if(typeof str !== "string") return "";
+		return str.replace(/[^a-zA-Z0-9_!§$()=\-\^°]+/g, "-").replace(/^-|-$/, "");
+	}
+
 	// map number to a single character a-z, A-Z or <_ + number> if number is too big
 	static numberToIdentifer(n) {
 		// lower case

package/lib/WebpackOptionsDefaulter.js

@@ -60,6 +60,7 @@ class WebpackOptionsDefaulter extends OptionsDefaulter {
 		this.set("output.hotUpdateChunkFilename", "[id].[hash].hot-update.js");
 		this.set("output.hotUpdateMainFilename", "[hash].hot-update.json");
 		this.set("output.crossOriginLoading", false);
+		this.set("output.chunkLoadTimeout", 120000);
 		this.set("output.hashFunction", "md5");
 		this.set("output.hashDigest", "hex");
 		this.set("output.hashDigestLength", 20);

package/lib/dependencies/DepBlockHelpers.js

@@ -33,7 +33,7 @@ DepBlockHelpers.getDepBlockPromise = function(depBlock, outputOptions, requestSh
 				"])";
 		}
 	}
-	return "Promise.resolve()";
+	return "new Promise(function(resolve) { resolve(); })";
 };
 
 function asComment(str) {

package/lib/dependencies/HarmonyCompatibilityDependency.js

@@ -22,7 +22,7 @@ HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate
 		if(usedExports && !Array.isArray(usedExports)) {
 			const exportName = dep.originModule.exportsArgument || "exports";
 			const content = `Object.defineProperty(${exportName}, \"__esModule\", { value: true });\n`;
-			source.insert(-1, content);
+			source.insert(-10, content);
 		}
 	}
 };

package/lib/dependencies/HarmonyExportDependencyParserPlugin.js

@@ -45,7 +45,7 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 			} else {
 				const immutable = statement.declaration && isImmutableStatement(statement.declaration);
 				const hoisted = statement.declaration && isHoistedStatement(statement.declaration);
-				dep = new HarmonyExportSpecifierDependency(parser.state.module, id, name, !immutable || hoisted ? -0.5 : (statement.range[1] + 0.5), immutable);
+				dep = new HarmonyExportSpecifierDependency(parser.state.module, id, name, !immutable || hoisted ? -2 : (statement.range[1] + 0.5), immutable);
 			}
 			dep.loc = Object.create(statement.loc);
 			dep.loc.index = idx;

package/lib/dependencies/ImportContextDependency.js

@@ -12,7 +12,6 @@ class ImportContextDependency extends ContextDependency {
 		super(request, recursive, regExp);
 		this.range = range;
 		this.valueRange = valueRange;
-		this.async = true;
 		this.chunkName = chunkName;
 	}
 

package/lib/dependencies/ImportDependency.js

@@ -44,7 +44,7 @@ ImportDependency.Template = class ImportDependencyTemplate {
 
 		if(dep.module) {
 			const stringifiedId = JSON.stringify(dep.module.id);
-			return `Promise.resolve(__webpack_require__(${comment}${stringifiedId}))`;
+			return `new Promise(function(resolve) { resolve(__webpack_require__(${comment}${stringifiedId})); })`;
 		}
 
 		return webpackMissingPromiseModule(dep.request);

package/lib/dependencies/ImportEagerContextDependency.js

@@ -0,0 +1,22 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const ImportContextDependency = require("./ImportContextDependency");
+const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
+
+class ImportEagerContextDependency extends ImportContextDependency {
+	constructor(request, recursive, regExp, range, valueRange, chunkName) {
+		super(request, recursive, regExp, range, valueRange, chunkName);
+		this.async = "eager";
+	}
+
+	get type() {
+		return "import() context eager";
+	}
+}
+
+ImportEagerContextDependency.Template = ContextDependencyTemplateAsRequireCall;
+
+module.exports = ImportEagerContextDependency;

package/lib/dependencies/ImportEagerDependency.js

@@ -0,0 +1,46 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const ModuleDependency = require("./ModuleDependency");
+const webpackMissingPromiseModule = require("./WebpackMissingModule").promise;
+
+class ImportEagerDependency extends ModuleDependency {
+	constructor(request, range) {
+		super(request);
+		this.range = range;
+	}
+
+	get type() {
+		return "import()";
+	}
+}
+
+ImportEagerDependency.Template = class ImportEagerDependencyTemplate {
+	apply(dep, source, outputOptions, requestShortener) {
+		const comment = this.getOptionalComment(outputOptions.pathinfo, requestShortener.shorten(dep.request));
+
+		const content = this.getContent(dep, comment);
+		source.replace(dep.range[0], dep.range[1] - 1, content);
+	}
+
+	getOptionalComment(pathinfo, shortenedRequest) {
+		if(!pathinfo) {
+			return "";
+		}
+
+		return `/*! ${shortenedRequest} */ `;
+	}
+
+	getContent(dep, comment) {
+		if(dep.module) {
+			const stringifiedId = JSON.stringify(dep.module.id);
+			return `new Promise(function(resolve) { resolve(__webpack_require__(${comment}${stringifiedId})); })`;
+		}
+
+		return webpackMissingPromiseModule(dep.request);
+	}
+};
+
+module.exports = ImportEagerDependency;

package/lib/dependencies/ImportLazyContextDependency.js

@@ -0,0 +1,22 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const ImportContextDependency = require("./ImportContextDependency");
+const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
+
+class ImportLazyContextDependency extends ImportContextDependency {
+	constructor(request, recursive, regExp, range, valueRange, chunkName) {
+		super(request, recursive, regExp, range, valueRange, chunkName);
+		this.async = "lazy";
+	}
+
+	get type() {
+		return "import() context lazy";
+	}
+}
+
+ImportLazyContextDependency.Template = ContextDependencyTemplateAsRequireCall;
+
+module.exports = ImportLazyContextDependency;

package/lib/dependencies/ImportLazyOnceContextDependency.js

@@ -0,0 +1,22 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const ImportContextDependency = require("./ImportContextDependency");
+const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
+
+class ImportLazyOnceContextDependency extends ImportContextDependency {
+	constructor(request, recursive, regExp, range, valueRange, chunkName) {
+		super(request, recursive, regExp, range, valueRange, chunkName);
+		this.async = "lazy-once";
+	}
+
+	get type() {
+		return "import() context lazy-once";
+	}
+}
+
+ImportLazyOnceContextDependency.Template = ContextDependencyTemplateAsRequireCall;
+
+module.exports = ImportLazyOnceContextDependency;

package/lib/dependencies/ImportParserPlugin.js

@@ -4,9 +4,13 @@
 */
 "use strict";
 
-const ImportContextDependency = require("./ImportContextDependency");
+const ImportEagerContextDependency = require("./ImportEagerContextDependency");
+const ImportLazyOnceContextDependency = require("./ImportLazyOnceContextDependency");
+const ImportLazyContextDependency = require("./ImportLazyContextDependency");
 const ImportDependenciesBlock = require("./ImportDependenciesBlock");
+const ImportEagerDependency = require("./ImportEagerDependency");
 const ContextDependencyHelpers = require("./ContextDependencyHelpers");
+const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
 
 class ImportParserPlugin {
 	constructor(options) {
@@ -23,22 +27,49 @@ class ImportParserPlugin {
 			const param = parser.evaluateExpression(expr.arguments[0]);
 
 			let chunkName = null;
+			let mode = "lazy";
 
 			const importOptions = parser.getCommentOptions(expr.range);
 			if(importOptions) {
 				if(typeof importOptions.webpackChunkName !== "undefined") {
 					if(typeof importOptions.webpackChunkName !== "string")
-						throw new Error(`\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`);
-					chunkName = importOptions.webpackChunkName;
+						parser.state.module.warnings.push(new UnsupportedFeatureWarning(parser.state.module, `\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`));
+					else
+						chunkName = importOptions.webpackChunkName;
+				}
+				if(typeof importOptions.webpackMode !== "undefined") {
+					if(typeof importOptions.webpackMode !== "string")
+						parser.state.module.warnings.push(new UnsupportedFeatureWarning(parser.state.module, `\`webpackMode\` expected a string, but received: ${importOptions.webpackMode}.`));
+					else
+						mode = importOptions.webpackMode;
 				}
 			}
 
 			if(param.isString()) {
-				const depBlock = new ImportDependenciesBlock(param.string, expr.range, chunkName, parser.state.module, expr.loc);
-				parser.state.current.addBlock(depBlock);
+				if(mode !== "lazy" && mode !== "eager") {
+					parser.state.module.warnings.push(new UnsupportedFeatureWarning(parser.state.module, `\`webpackMode\` expected 'lazy' or 'eager', but received: ${mode}.`));
+				}
+
+				if(mode === "eager") {
+					const dep = new ImportEagerDependency(param.string, expr.range);
+					parser.state.current.addDependency(dep);
+				} else {
+					const depBlock = new ImportDependenciesBlock(param.string, expr.range, chunkName, parser.state.module, expr.loc);
+					parser.state.current.addBlock(depBlock);
+				}
 				return true;
 			} else {
-				const dep = ContextDependencyHelpers.create(ImportContextDependency, expr.range, param, expr, options, chunkName);
+				if(mode !== "lazy" && mode !== "lazy-once" && mode !== "eager") {
+					parser.state.module.warnings.push(new UnsupportedFeatureWarning(parser.state.module, `\`webpackMode\` expected 'lazy', 'lazy-once' or 'eager', but received: ${mode}.`));
+				}
+
+				let Dep = ImportLazyContextDependency;
+				if(mode === "eager") {
+					Dep = ImportEagerContextDependency;
+				} else if(mode === "lazy-once") {
+					Dep = ImportLazyOnceContextDependency;
+				}
+				const dep = ContextDependencyHelpers.create(Dep, expr.range, param, expr, options, chunkName);
 				if(!dep) return;
 				dep.loc = expr.loc;
 				dep.optional = !!parser.scope.inTry;

package/lib/dependencies/ImportPlugin.js

@@ -5,7 +5,10 @@
 "use strict";
 
 const ImportDependency = require("./ImportDependency");
-const ImportContextDependency = require("./ImportContextDependency");
+const ImportEagerDependency = require("./ImportEagerDependency");
+const ImportEagerContextDependency = require("./ImportEagerContextDependency");
+const ImportLazyOnceContextDependency = require("./ImportLazyOnceContextDependency");
+const ImportLazyContextDependency = require("./ImportLazyContextDependency");
 const ImportParserPlugin = require("./ImportParserPlugin");
 
 class ImportPlugin {
@@ -22,8 +25,17 @@ class ImportPlugin {
 			compilation.dependencyFactories.set(ImportDependency, normalModuleFactory);
 			compilation.dependencyTemplates.set(ImportDependency, new ImportDependency.Template());
 
-			compilation.dependencyFactories.set(ImportContextDependency, contextModuleFactory);
-			compilation.dependencyTemplates.set(ImportContextDependency, new ImportContextDependency.Template());
+			compilation.dependencyFactories.set(ImportEagerDependency, normalModuleFactory);
+			compilation.dependencyTemplates.set(ImportEagerDependency, new ImportEagerDependency.Template());
+
+			compilation.dependencyFactories.set(ImportEagerContextDependency, contextModuleFactory);
+			compilation.dependencyTemplates.set(ImportEagerContextDependency, new ImportEagerContextDependency.Template());
+
+			compilation.dependencyFactories.set(ImportLazyOnceContextDependency, contextModuleFactory);
+			compilation.dependencyTemplates.set(ImportLazyOnceContextDependency, new ImportLazyOnceContextDependency.Template());
+
+			compilation.dependencyFactories.set(ImportLazyContextDependency, contextModuleFactory);
+			compilation.dependencyTemplates.set(ImportLazyContextDependency, new ImportLazyContextDependency.Template());
 
 			params.normalModuleFactory.plugin("parser", (parser, parserOptions) => {
 

package/lib/dependencies/RequireEnsureDependenciesBlock.js

@@ -11,14 +11,8 @@ module.exports = class RequireEnsureDependenciesBlock extends AsyncDependenciesB
 		super(chunkName, module, loc);
 		this.expr = expr;
 		const successBodyRange = successExpression && successExpression.body && successExpression.body.range;
-		const errorBodyRange = errorExpression && errorExpression.body && errorExpression.body.range;
-		this.range = null;
 		if(successBodyRange) {
-			if(errorBodyRange) {
-				this.range = [successBodyRange[0] + 1, errorBodyRange[1] - 1];
-			} else {
-				this.range = [successBodyRange[0] + 1, successBodyRange[1] - 1];
-			}
+			this.range = [successBodyRange[0] + 1, successBodyRange[1] - 1];
 		}
 		this.chunkNameRange = chunkNameRange;
 		const dep = new RequireEnsureDependency(this);

package/lib/node/NodeSourcePlugin.js

@@ -2,83 +2,85 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-var AliasPlugin = require("enhanced-resolve/lib/AliasPlugin");
-var ParserHelpers = require("../ParserHelpers");
-var nodeLibsBrowser = require("node-libs-browser");
+"use strict";
+const AliasPlugin = require("enhanced-resolve/lib/AliasPlugin");
+const ParserHelpers = require("../ParserHelpers");
+const nodeLibsBrowser = require("node-libs-browser");
 
-function NodeSourcePlugin(options) {
-	this.options = options;
-}
-module.exports = NodeSourcePlugin;
-NodeSourcePlugin.prototype.apply = function(compiler) {
-	var options = this.options;
-
-	function getPathToModule(module, type) {
-		if(type === true || (type === undefined && nodeLibsBrowser[module])) {
-			if(!nodeLibsBrowser[module]) throw new Error("No browser version for node.js core module '" + module + "' available");
-			return nodeLibsBrowser[module];
-		} else if(type === "mock") {
-			return require.resolve("node-libs-browser/mock/" + module);
-		} else if(type === "empty") {
-			return require.resolve("node-libs-browser/mock/empty");
-		} else return module;
+module.exports = class NodeSourcePlugin {
+	constructor(options) {
+		this.options = options;
 	}
+	apply(compiler) {
+		const options = this.options;
 
-	function addExpression(parser, name, module, type, suffix) {
-		suffix = suffix || "";
-		parser.plugin("expression " + name, function() {
-			if(this.state.module && this.state.module.resource === getPathToModule(module, type)) return;
-			var mockModule = ParserHelpers.requireFileAsExpression(this.state.module.context, getPathToModule(module, type));
-			return ParserHelpers.addParsedVariableToModule(this, name, mockModule + suffix);
-		});
-	}
+		function getPathToModule(module, type) {
+			if(type === true || (type === undefined && nodeLibsBrowser[module])) {
+				if(!nodeLibsBrowser[module]) throw new Error(`No browser version for node.js core module ${module} available`);
+				return nodeLibsBrowser[module];
+			} else if(type === "mock") {
+				return require.resolve(`node-libs-browser/mock/${module}`);
+			} else if(type === "empty") {
+				return require.resolve("node-libs-browser/mock/empty");
+			} else return module;
+		}
 
-	compiler.plugin("compilation", function(compilation, params) {
-		params.normalModuleFactory.plugin("parser", function(parser, parserOptions) {
+		function addExpression(parser, name, module, type, suffix) {
+			suffix = suffix || "";
+			parser.plugin(`expression ${name}`, function() {
+				if(this.state.module && this.state.module.resource === getPathToModule(module, type)) return;
+				const mockModule = ParserHelpers.requireFileAsExpression(this.state.module.context, getPathToModule(module, type));
+				return ParserHelpers.addParsedVariableToModule(this, name, mockModule + suffix);
+			});
+		}
 
-			if(parserOptions.node === false)
-				return;
+		compiler.plugin("compilation", function(compilation, params) {
+			params.normalModuleFactory.plugin("parser", function(parser, parserOptions) {
 
-			var localOptions = options;
-			if(parserOptions.node)
-				localOptions = Object.assign({}, localOptions, parserOptions.node);
+				if(parserOptions.node === false)
+					return;
 
-			if(localOptions.global) {
-				parser.plugin("expression global", function() {
-					var retrieveGlobalModule = ParserHelpers.requireFileAsExpression(this.state.module.context, require.resolve("../../buildin/global.js"));
-					return ParserHelpers.addParsedVariableToModule(this, "global", retrieveGlobalModule);
-				});
-			}
-			if(localOptions.process) {
-				var processType = localOptions.process;
-				addExpression(parser, "process", "process", processType);
-			}
-			if(localOptions.console) {
-				var consoleType = localOptions.console;
-				addExpression(parser, "console", "console", consoleType);
-			}
-			var bufferType = localOptions.Buffer;
-			if(bufferType) {
-				addExpression(parser, "Buffer", "buffer", bufferType, ".Buffer");
-			}
-			if(localOptions.setImmediate) {
-				var setImmediateType = localOptions.setImmediate;
-				addExpression(parser, "setImmediate", "timers", setImmediateType, ".setImmediate");
-				addExpression(parser, "clearImmediate", "timers", setImmediateType, ".clearImmediate");
-			}
+				let localOptions = options;
+				if(parserOptions.node)
+					localOptions = Object.assign({}, localOptions, parserOptions.node);
+
+				if(localOptions.global) {
+					parser.plugin("expression global", function() {
+						const retrieveGlobalModule = ParserHelpers.requireFileAsExpression(this.state.module.context, require.resolve("../../buildin/global.js"));
+						return ParserHelpers.addParsedVariableToModule(this, "global", retrieveGlobalModule);
+					});
+				}
+				if(localOptions.process) {
+					const processType = localOptions.process;
+					addExpression(parser, "process", "process", processType);
+				}
+				if(localOptions.console) {
+					const consoleType = localOptions.console;
+					addExpression(parser, "console", "console", consoleType);
+				}
+				const bufferType = localOptions.Buffer;
+				if(bufferType) {
+					addExpression(parser, "Buffer", "buffer", bufferType, ".Buffer");
+				}
+				if(localOptions.setImmediate) {
+					const setImmediateType = localOptions.setImmediate;
+					addExpression(parser, "setImmediate", "timers", setImmediateType, ".setImmediate");
+					addExpression(parser, "clearImmediate", "timers", setImmediateType, ".clearImmediate");
+				}
+			});
 		});
-	});
-	compiler.plugin("after-resolvers", function(compiler) {
-		Object.keys(nodeLibsBrowser).forEach(function(lib) {
-			if(options[lib] !== false) {
-				compiler.resolvers.normal.apply(
-					new AliasPlugin("described-resolve", {
-						name: lib,
-						onlyModule: true,
-						alias: getPathToModule(lib, options[lib])
-					}, "resolve")
-				);
-			}
+		compiler.plugin("after-resolvers", (compiler) => {
+			Object.keys(nodeLibsBrowser).forEach((lib) => {
+				if(options[lib] !== false) {
+					compiler.resolvers.normal.apply(
+						new AliasPlugin("described-resolve", {
+							name: lib,
+							onlyModule: true,
+							alias: getPathToModule(lib, options[lib])
+						}, "resolve")
+					);
+				}
+			});
 		});
-	});
+	}
 };

package/lib/webworker/WebWorkerMainTemplatePlugin.js

@@ -29,22 +29,26 @@ class WebWorkerMainTemplatePlugin {
 		mainTemplate.plugin("require-ensure", function(_, chunk, hash) {
 			const chunkFilename = this.outputOptions.chunkFilename;
 			return this.asString([
-				"// \"1\" is the signal for \"already loaded\"",
-				"if(!installedChunks[chunkId]) {",
+				"return new Promise(function(resolve) {",
 				this.indent([
-					"importScripts(" +
-					this.applyPluginsWaterfall("asset-path", JSON.stringify(chunkFilename), {
-						hash: "\" + " + this.renderCurrentHashCode(hash) + " + \"",
-						hashWithLength: function(length) {
-							return "\" + " + this.renderCurrentHashCode(hash, length) + " + \"";
-						}.bind(this),
-						chunk: {
-							id: "\" + chunkId + \""
-						}
-					}) + ");"
+					"// \"1\" is the signal for \"already loaded\"",
+					"if(!installedChunks[chunkId]) {",
+					this.indent([
+						"importScripts(" +
+						this.applyPluginsWaterfall("asset-path", JSON.stringify(chunkFilename), {
+							hash: "\" + " + this.renderCurrentHashCode(hash) + " + \"",
+							hashWithLength: function(length) {
+								return "\" + " + this.renderCurrentHashCode(hash, length) + " + \"";
+							}.bind(this),
+							chunk: {
+								id: "\" + chunkId + \""
+							}
+						}) + ");"
+					]),
+					"}",
+					"resolve();"
 				]),
-				"}",
-				"return Promise.resolve();"
+				"});"
 			]);
 		});
 		mainTemplate.plugin("bootstrap", function(source, chunk, hash) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "2.5.0",
+  "version": "2.7.0",
   "author": "Tobias Koppers @sokra",
   "description": "Packs CommonJs/AMD modules for the browser. Allows to split your codebase into multiple bundles, which can be loaded on demand. Support loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "dependencies": {
@@ -9,7 +9,7 @@
     "ajv": "^4.7.0",
     "ajv-keywords": "^1.1.1",
     "async": "^2.1.2",
-    "enhanced-resolve": "^3.0.0",
+    "enhanced-resolve": "^3.3.0",
     "interpret": "^1.0.0",
     "json-loader": "^0.5.4",
     "json5": "^0.5.1",
@@ -21,9 +21,9 @@
     "source-map": "^0.5.3",
     "supports-color": "^3.1.0",
     "tapable": "~0.2.5",
-    "uglify-js": "^2.8.5",
+    "uglify-js": "^2.8.27",
     "watchpack": "^1.3.1",
-    "webpack-sources": "^0.2.3",
+    "webpack-sources": "^1.0.1",
     "yargs": "^6.0.0"
   },
   "license": "MIT",
@@ -88,13 +88,13 @@
     "schemas/"
   ],
   "scripts": {
-    "test": "mocha test/*.test.js --harmony --check-leaks",
+    "test": "mocha test/*.test.js --max_old_space_size=4096 --harmony --check-leaks",
     "travis:test": "npm run cover:min",
     "travis:lint": "npm run lint-files && npm run nsp",
     "travis:benchmark": "npm run benchmark",
-    "appveyor:test": "node --max_old_space_size=4096 node_modules\\mocha\\bin\\mocha --harmony test/*.test.js",
+    "appveyor:test": "node node_modules\\mocha\\bin\\mocha --max_old_space_size=4096 --harmony test/*.test.js",
     "appveyor:benchmark": "npm run benchmark",
-    "circleci:test": "node --max_old_space_size=4096 node_modules/mocha/bin/mocha --harmony test/*.test.js",
+    "circleci:test": "node node_modules/mocha/bin/mocha --max_old_space_size=4096 --harmony test/*.test.js",
     "circleci:lint": "npm run lint-files && npm run nsp",
     "build:examples": "cd examples && node buildAll.js",
     "pretest": "npm run lint-files",
@@ -102,9 +102,9 @@
     "lint": "eslint lib bin hot buildin \"test/**/webpack.config.js\" \"test/binCases/**/test.js\" \"examples/**/webpack.config.js\"",
     "beautify-lint": "beautify-lint \"lib/**/*.js\" \"hot/**/*.js\" \"bin/**/*.js\" \"benchmark/*.js\" \"test/*.js\"",
     "nsp": "nsp check --output summary",
-    "benchmark": "mocha test/*.benchmark.js --harmony -R spec",
-    "cover": "node --harmony ./node_modules/istanbul/lib/cli.js cover -x '**/*.runtime.js' node_modules/mocha/bin/_mocha -- test/*.test.js",
-    "cover:min": "node --harmony ./node_modules/.bin/istanbul cover -x '**/*.runtime.js' --report lcovonly node_modules/mocha/bin/_mocha -- test/*.test.js",
+    "benchmark": "mocha --max_old_space_size=4096 --harmony test/*.benchmark.js -R spec",
+    "cover": "node --max_old_space_size=4096 --harmony ./node_modules/istanbul/lib/cli.js cover -x '**/*.runtime.js' node_modules/mocha/bin/_mocha -- test/*.test.js",
+    "cover:min": "node --max_old_space_size=4096 --harmony ./node_modules/.bin/istanbul cover -x '**/*.runtime.js' --report lcovonly node_modules/mocha/bin/_mocha -- test/*.test.js",
     "publish-patch": "npm run lint && npm run beautify-lint && mocha && npm version patch && git push && git push --tags && npm publish"
   }
 }

package/schemas/webpackOptionsSchema.json

@@ -270,6 +270,10 @@
             "use-credentials"
           ]
         },
+        "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": [
@@ -455,6 +459,9 @@
         "cachePredicate": {
           "instanceof": "Function"
         },
+        "cacheWithContext": {
+          "type": "boolean"
+        },
         "descriptionFiles": {
           "$ref": "#/definitions/common.arrayOfStringValues"
         },