webpack 2.3.3 → 2.5.1

package/lib/dependencies/ContextDependencyHelpers.js

@@ -2,7 +2,9 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-var ContextDependencyHelpers = exports;
+"use strict";
+
+const ContextDependencyHelpers = exports;
 
 /**
  * Escapes regular expression metacharacters
@@ -13,8 +15,15 @@ function quotemeta(str) {
 	return str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
 }
 
-ContextDependencyHelpers.create = function(Dep, range, param, expr, options) {
-	var dep, prefix, postfix, prefixRange, valueRange, idx, context, regExp;
+ContextDependencyHelpers.create = function(Dep, range, param, expr, options, chunkName) {
+	let dep;
+	let prefix;
+	let postfix;
+	let prefixRange;
+	let valueRange;
+	let idx;
+	let context;
+	let regExp;
 	if(param.isTemplateString()) {
 		prefix = param.quasis[0].string;
 		postfix = param.quasis.length > 1 ? param.quasis[param.quasis.length - 1].string : "";
@@ -24,14 +33,11 @@ ContextDependencyHelpers.create = function(Dep, range, param, expr, options) {
 		context = ".";
 		if(idx >= 0) {
 			context = prefix.substr(0, idx);
-			prefix = "." + prefix.substr(idx);
+			prefix = `.${prefix.substr(idx)}`;
 		}
 		// If there are more than two quasis, maybe the generated RegExp can be more precise?
-		regExp = new RegExp("^" +
-			quotemeta(prefix) +
-			options.wrappedContextRegExp.source +
-			quotemeta(postfix) + "$");
-		dep = new Dep(context, options.wrappedContextRecursive, regExp, range, valueRange);
+		regExp = new RegExp(`^${quotemeta(prefix)}${options.wrappedContextRegExp.source}${quotemeta(postfix)}$`);
+		dep = new Dep(context, options.wrappedContextRecursive, regExp, range, valueRange, chunkName);
 		dep.loc = expr.loc;
 		dep.replaces = [{
 			range: prefixRange,
@@ -48,19 +54,16 @@ ContextDependencyHelpers.create = function(Dep, range, param, expr, options) {
 		context = ".";
 		if(idx >= 0) {
 			context = prefix.substr(0, idx);
-			prefix = "." + prefix.substr(idx);
+			prefix = `.${prefix.substr(idx)}`;
 		}
-		regExp = new RegExp("^" +
-			quotemeta(prefix) +
-			options.wrappedContextRegExp.source +
-			quotemeta(postfix) + "$");
-		dep = new Dep(context, options.wrappedContextRecursive, regExp, range, valueRange);
+		regExp = new RegExp(`^${quotemeta(prefix)}${options.wrappedContextRegExp.source}${quotemeta(postfix)}$`);
+		dep = new Dep(context, options.wrappedContextRecursive, regExp, range, valueRange, chunkName);
 		dep.loc = expr.loc;
 		dep.prepend = param.prefix && param.prefix.isString() ? prefix : null;
 		dep.critical = options.wrappedContextCritical && "a part of the request of a dependency is an expression";
 		return dep;
 	} else {
-		dep = new Dep(options.exprContextRequest, options.exprContextRecursive, options.exprContextRegExp, range, param.range);
+		dep = new Dep(options.exprContextRequest, options.exprContextRecursive, options.exprContextRegExp, range, param.range, chunkName);
 		dep.loc = expr.loc;
 		dep.critical = options.exprContextCritical && "the request of a dependency is an expression";
 		return dep;

package/lib/dependencies/CriticalDependencyWarning.js

@@ -4,12 +4,15 @@
 */
 "use strict";
 
-class CriticalDependencyWarning extends Error {
+const WebpackError = require("../WebpackError");
 
+class CriticalDependencyWarning extends WebpackError {
 	constructor(message) {
 		super();
+
 		this.name = "CriticalDependencyWarning";
 		this.message = "Critical dependency: " + message;
+
 		Error.captureStackTrace(this, this.constructor);
 	}
 }

package/lib/dependencies/DepBlockHelpers.js

@@ -16,11 +16,11 @@ DepBlockHelpers.getLoadDepBlockWrapper = function(depBlock, outputOptions, reque
 DepBlockHelpers.getDepBlockPromise = function(depBlock, outputOptions, requestShortener, name) {
 	if(depBlock.chunks) {
 		var chunks = depBlock.chunks.filter(function(chunk) {
-			return !chunk.hasRuntime() && typeof chunk.id === "number";
+			return !chunk.hasRuntime() && chunk.id !== null;
 		});
 		if(chunks.length === 1) {
 			var chunk = chunks[0];
-			return "__webpack_require__.e" + asComment(name) + "(" + chunk.id + "" +
+			return "__webpack_require__.e" + asComment(name) + "(" + JSON.stringify(chunk.id) + "" +
 				(outputOptions.pathinfo && depBlock.chunkName ? "/*! " + requestShortener.shorten(depBlock.chunkName) + " */" : "") +
 				asComment(depBlock.chunkReason) + ")";
 		} else if(chunks.length > 0) {
@@ -28,7 +28,7 @@ DepBlockHelpers.getDepBlockPromise = function(depBlock, outputOptions, requestSh
 				(outputOptions.pathinfo && depBlock.chunkName ? "/*! " + requestShortener.shorten(depBlock.chunkName) + " */" : "") +
 				"[" +
 				chunks.map(function(chunk) {
-					return "__webpack_require__.e(" + chunk.id + ")";
+					return "__webpack_require__.e(" + JSON.stringify(chunk.id) + ")";
 				}).join(", ") +
 				"])";
 		}

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

@@ -25,7 +25,7 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 			dep.loc = Object.create(statement.loc);
 			dep.loc.index = -1;
 			parser.state.current.addDependency(dep);
-			parser.state.lastHarmoryImport = dep;
+			parser.state.lastHarmonyImport = dep;
 			return true;
 		});
 		parser.plugin("export expression", (statement, expr) => {
@@ -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;
@@ -53,7 +53,7 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 			return true;
 		});
 		parser.plugin("export import specifier", (statement, source, id, name, idx) => {
-			const dep = new HarmonyExportImportedSpecifierDependency(parser.state.module, parser.state.lastHarmoryImport, HarmonyModulesHelpers.getModuleVar(parser.state, source), id, name);
+			const dep = new HarmonyExportImportedSpecifierDependency(parser.state.module, parser.state.lastHarmonyImport, HarmonyModulesHelpers.getModuleVar(parser.state, source), id, name);
 			dep.loc = Object.create(statement.loc);
 			dep.loc.index = idx;
 			parser.state.current.addDependency(dep);

package/lib/dependencies/ImportContextDependency.js

@@ -8,11 +8,12 @@ const CriticalDependencyWarning = require("./CriticalDependencyWarning");
 const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
 
 class ImportContextDependency extends ContextDependency {
-	constructor(request, recursive, regExp, range, valueRange) {
+	constructor(request, recursive, regExp, range, valueRange, chunkName) {
 		super(request, recursive, regExp);
 		this.range = range;
 		this.valueRange = valueRange;
 		this.async = true;
+		this.chunkName = chunkName;
 	}
 
 	get type() {

package/lib/dependencies/ImportDependenciesBlock.js

@@ -7,8 +7,8 @@ const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const ImportDependency = require("./ImportDependency");
 
 module.exports = class ImportDependenciesBlock extends AsyncDependenciesBlock {
-	constructor(request, range, module, loc) {
-		super(null, module, loc);
+	constructor(request, range, chunkName, module, loc) {
+		super(chunkName, module, loc);
 		this.range = range;
 		const dep = new ImportDependency(request, this);
 		dep.loc = loc;

package/lib/dependencies/ImportParserPlugin.js

@@ -15,16 +15,30 @@ class ImportParserPlugin {
 
 	apply(parser) {
 		const options = this.options;
+
 		parser.plugin(["call System.import", "import-call"], (expr) => {
 			if(expr.arguments.length !== 1)
 				throw new Error("Incorrect number of arguments provided to 'import(module: string) -> Promise'.");
+
 			const param = parser.evaluateExpression(expr.arguments[0]);
+
+			let chunkName = null;
+
+			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;
+				}
+			}
+
 			if(param.isString()) {
-				const depBlock = new ImportDependenciesBlock(param.string, expr.range, parser.state.module, expr.loc);
+				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);
+				const dep = ContextDependencyHelpers.create(ImportContextDependency, expr.range, param, expr, options, chunkName);
 				if(!dep) return;
 				dep.loc = expr.loc;
 				dep.optional = !!parser.scope.inTry;

package/lib/dependencies/RequireEnsureDependenciesBlock.js

@@ -7,11 +7,19 @@ const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const RequireEnsureDependency = require("./RequireEnsureDependency");
 
 module.exports = class RequireEnsureDependenciesBlock extends AsyncDependenciesBlock {
-	constructor(expr, fnExpression, chunkName, chunkNameRange, module, loc) {
+	constructor(expr, successExpression, errorExpression, chunkName, chunkNameRange, module, loc) {
 		super(chunkName, module, loc);
 		this.expr = expr;
-		const bodyRange = fnExpression && fnExpression.body && fnExpression.body.range;
-		this.range = bodyRange && [bodyRange[0] + 1, bodyRange[1] - 1] || null;
+		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.chunkNameRange = chunkNameRange;
 		const dep = new RequireEnsureDependency(this);
 		dep.loc = loc;

package/lib/dependencies/RequireEnsureDependenciesBlockParserPlugin.js

@@ -13,27 +13,48 @@ module.exports = class RequireEnsureDependenciesBlockParserPlugin {
 		parser.plugin("call require.ensure", expr => {
 			let chunkName = null;
 			let chunkNameRange = null;
+			let errorExpressionArg = null;
+			let errorExpression = null;
 			switch(expr.arguments.length) {
-				case 3:
+				case 4:
 					{
-						const chunkNameExpr = parser.evaluateExpression(expr.arguments[2]);
+						const chunkNameExpr = parser.evaluateExpression(expr.arguments[3]);
 						if(!chunkNameExpr.isString()) return;
 						chunkNameRange = chunkNameExpr.range;
 						chunkName = chunkNameExpr.string;
 					}
 					// falls through
+				case 3:
+					{
+						errorExpressionArg = expr.arguments[2];
+						errorExpression = getFunctionExpression(errorExpressionArg);
+
+						if(!errorExpression && !chunkName) {
+							const chunkNameExpr = parser.evaluateExpression(expr.arguments[2]);
+							if(!chunkNameExpr.isString()) return;
+							chunkNameRange = chunkNameExpr.range;
+							chunkName = chunkNameExpr.string;
+						}
+					}
+					// falls through
 				case 2:
 					{
 						const dependenciesExpr = parser.evaluateExpression(expr.arguments[0]);
 						const dependenciesItems = dependenciesExpr.isArray() ? dependenciesExpr.items : [dependenciesExpr];
-						const fnExpressionArg = expr.arguments[1];
-						const fnExpression = getFunctionExpression(fnExpressionArg);
+						const successExpressionArg = expr.arguments[1];
+						const successExpression = getFunctionExpression(successExpressionArg);
 
-						if(fnExpression) {
-							parser.walkExpressions(fnExpression.expressions);
+						if(successExpression) {
+							parser.walkExpressions(successExpression.expressions);
+						}
+						if(errorExpression) {
+							parser.walkExpressions(errorExpression.expressions);
 						}
 
-						const dep = new RequireEnsureDependenciesBlock(expr, fnExpression ? fnExpression.fn : fnExpressionArg, chunkName, chunkNameRange, parser.state.module, expr.loc);
+						const dep = new RequireEnsureDependenciesBlock(expr,
+							successExpression ? successExpression.fn : successExpressionArg,
+							errorExpression ? errorExpression.fn : errorExpressionArg,
+							chunkName, chunkNameRange, parser.state.module, expr.loc);
 						const old = parser.state.current;
 						parser.state.current = dep;
 						try {
@@ -52,18 +73,26 @@ module.exports = class RequireEnsureDependenciesBlockParserPlugin {
 							if(failed) {
 								return;
 							}
-							if(fnExpression) {
-								if(fnExpression.fn.body.type === "BlockStatement")
-									parser.walkStatement(fnExpression.fn.body);
+							if(successExpression) {
+								if(successExpression.fn.body.type === "BlockStatement")
+									parser.walkStatement(successExpression.fn.body);
 								else
-									parser.walkExpression(fnExpression.fn.body);
+									parser.walkExpression(successExpression.fn.body);
 							}
 							old.addBlock(dep);
 						} finally {
 							parser.state.current = old;
 						}
-						if(!fnExpression) {
-							parser.walkExpression(fnExpressionArg);
+						if(!successExpression) {
+							parser.walkExpression(successExpressionArg);
+						}
+						if(errorExpression) {
+							if(errorExpression.fn.body.type === "BlockStatement")
+								parser.walkStatement(errorExpression.fn.body);
+							else
+								parser.walkExpression(errorExpression.fn.body);
+						} else if(errorExpressionArg) {
+							parser.walkExpression(errorExpressionArg);
 						}
 						return true;
 					}

package/lib/dependencies/RequireEnsureDependency.js

@@ -21,10 +21,17 @@ RequireEnsureDependency.Template = class RequireEnsureDependencyTemplate {
 	apply(dep, source, outputOptions, requestShortener) {
 		const depBlock = dep.block;
 		const wrapper = DepBlockHelpers.getLoadDepBlockWrapper(depBlock, outputOptions, requestShortener, "require.ensure");
+		const errorCallbackExists = depBlock.expr.arguments.length === 4 || (!depBlock.chunkName && depBlock.expr.arguments.length === 3);
 		const startBlock = wrapper[0] + "(";
-		const endBlock = `).bind(null, __webpack_require__)${wrapper[1]}__webpack_require__.oe${wrapper[2]}`;
+		const middleBlock = `).bind(null, __webpack_require__)${wrapper[1]}`;
+		const endBlock = `${middleBlock}__webpack_require__.oe${wrapper[2]}`;
 		source.replace(depBlock.expr.range[0], depBlock.expr.arguments[1].range[0] - 1, startBlock);
-		source.replace(depBlock.expr.arguments[1].range[1], depBlock.expr.range[1] - 1, endBlock);
+		if(errorCallbackExists) {
+			source.replace(depBlock.expr.arguments[1].range[1], depBlock.expr.arguments[2].range[0] - 1, middleBlock);
+			source.replace(depBlock.expr.arguments[2].range[1], depBlock.expr.range[1] - 1, wrapper[2]);
+		} else {
+			source.replace(depBlock.expr.arguments[1].range[1], depBlock.expr.range[1] - 1, endBlock);
+		}
 	}
 };
 

package/lib/formatLocation.js

@@ -2,36 +2,53 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-module.exports = function formatLocation(loc) {
-	if(typeof loc === "string")
-		return loc;
-	if(typeof loc === "number")
-		return loc + "";
-	if(loc && typeof loc === "object") {
-		if(loc.start && loc.end) {
-			if(typeof loc.start.line === "number" && typeof loc.end.line === "number" && typeof loc.end.column === "number" && loc.start.line === loc.end.line)
-				return formatPosition(loc.start) + "-" + loc.end.column;
-			return formatPosition(loc.start) + "-" + formatPosition(loc.end);
-		}
-		if(loc.start)
-			return formatPosition(loc.start);
-		return formatPosition(loc);
-	}
-	return "";
 
-	function formatPosition(pos) {
-		if(typeof pos === "string")
+"use strict";
+
+const formatPosition = (pos) => {
+	if(pos === null)
+		return "";
+	const typeOfPos = typeof pos;
+	switch(typeOfPos) {
+		case "string":
 			return pos;
-		if(typeof pos === "number")
-			return pos + "";
-		if(pos && typeof pos === "object") {
+		case "number":
+			return `${pos}`;
+		case "object":
 			if(typeof pos.line === "number" && typeof pos.column === "number")
-				return pos.line + ":" + pos.column;
-			if(typeof pos.line === "number")
-				return pos.line + ":?";
-			if(typeof pos.index === "number")
-				return "+" + pos.index;
-		}
+				return `${pos.line}:${pos.column}`;
+			else if(typeof pos.line === "number")
+				return `${pos.line}:?`;
+			else if(typeof pos.index === "number")
+				return `+${pos.index}`;
+			else
+				return "";
+		default:
+			return "";
+	}
+};
+
+const formatLocation = (loc) => {
+	if(loc === null)
 		return "";
+	const typeOfLoc = typeof loc;
+	switch(typeOfLoc) {
+		case "string":
+			return loc;
+		case "number":
+			return `${loc}`;
+		case "object":
+			if(loc.start && loc.end) {
+				if(typeof loc.start.line === "number" && typeof loc.end.line === "number" && typeof loc.end.column === "number" && loc.start.line === loc.end.line)
+					return `${formatPosition(loc.start)}-${loc.end.column}`;
+				return `${formatPosition(loc.start)}-${formatPosition(loc.end)}`;
+			}
+			if(loc.start)
+				return formatPosition(loc.start);
+			return formatPosition(loc);
+		default:
+			return "";
 	}
 };
+
+module.exports = formatLocation;

package/lib/optimize/AggressiveSplittingPlugin.js

@@ -4,18 +4,7 @@
 */
 "use strict";
 
-let path = require("path");
-
-function makeRelative(context) {
-	return function(module) {
-		const identifier = module.identifier();
-		return identifier.split("|").map((str) => {
-			return str.split("!").map((str) => {
-				return path.relative(context, str);
-			}).join("!");
-		}).join("|");
-	};
-}
+const identifierUtils = require("../util/identifier");
 
 function toIndexOf(list) {
 	return function(item) {
@@ -73,7 +62,7 @@ class AggressiveSplittingPlugin {
 					const splitData = usedSplits[j];
 					for(let i = 0; i < chunks.length; i++) {
 						const chunk = chunks[i];
-						const chunkModuleNames = chunk.modules.map(makeRelative(compiler.context));
+						const chunkModuleNames = chunk.modules.map(m => identifierUtils.makePathsRelative(compiler.context, m.identifier()));
 
 						if(chunkModuleNames.length < splitData.modules.length)
 							continue;
@@ -91,7 +80,9 @@ class AggressiveSplittingPlugin {
 								newChunk._fromAggressiveSplitting = true;
 								if(j < savedSplits.length)
 									newChunk._fromAggressiveSplittingIndex = j;
-								if(typeof splitData.id === "number") newChunk.id = splitData.id;
+								if(splitData.id !== null && splitData.id !== undefined) {
+									newChunk.id = splitData.id;
+								}
 								newChunk.origins = chunk.origins.map(copyWithReason);
 								chunk.origins = chunk.origins.map(copyWithReason);
 								return true;
@@ -99,7 +90,9 @@ class AggressiveSplittingPlugin {
 								if(j < savedSplits.length)
 									chunk._fromAggressiveSplittingIndex = j;
 								chunk.name = null;
-								if(typeof splitData.id === "number") chunk.id = splitData.id;
+								if(splitData.id !== null && splitData.id !== undefined) {
+									chunk.id = splitData.id;
+								}
 							}
 						}
 					}
@@ -144,7 +137,7 @@ class AggressiveSplittingPlugin {
 							newChunk.origins = chunk.origins.map(copyWithReason);
 							chunk.origins = chunk.origins.map(copyWithReason);
 							compilation._aggressiveSplittingSplits = (compilation._aggressiveSplittingSplits || []).concat({
-								modules: newChunk.modules.map(makeRelative(compiler.context))
+								modules: newChunk.modules.map(m => identifierUtils.makePathsRelative(compiler.context, m.identifier()))
 							});
 							return true;
 						} else {
@@ -161,7 +154,7 @@ class AggressiveSplittingPlugin {
 					if(chunk.hasEntryModule()) return;
 					const size = chunk.size(this.options);
 					const incorrectSize = size < minSize;
-					const modules = chunk.modules.map(makeRelative(compiler.context));
+					const modules = chunk.modules.map(m => identifierUtils.makePathsRelative(compiler.context, m.identifier()));
 					if(typeof chunk._fromAggressiveSplittingIndex === "undefined") {
 						if(incorrectSize) return;
 						chunk.recorded = true;

package/lib/optimize/CommonsChunkPlugin.js

@@ -190,7 +190,7 @@ You can however specify the name of the async chunk by passing the desired strin
 
 		// we dont have named chunks specified, so we just take all of them
 		if(asyncOrNoSelectedChunk) {
-			return allChunks;
+			return allChunks.filter(chunk => !chunk.isInitial());
 		}
 
 		/**
@@ -244,7 +244,7 @@ Take a look at the "name"/"names" or async/children option.`);
 		return allChunks.filter((chunk) => {
 			const found = targetChunks.indexOf(chunk);
 			if(found >= currentIndex) return false;
-			return chunk.parents.length === 0;
+			return chunk.hasRuntime();
 		});
 	}
 

package/lib/performance/AssetsOverSizeLimitWarning.js

@@ -3,9 +3,11 @@
 	Author Sean Larkin @thelarkinn
 */
 "use strict";
+
+const WebpackError = require("../WebpackError");
 const SizeFormatHelpers = require("../SizeFormatHelpers");
 
-module.exports = class AssetsOverSizeLimitWarning extends Error {
+module.exports = class AssetsOverSizeLimitWarning extends WebpackError {
 	constructor(assetsOverSizeLimit, assetLimit) {
 		super();
 
@@ -15,6 +17,7 @@ module.exports = class AssetsOverSizeLimitWarning extends Error {
 		this.message = `asset size limit: The following asset(s) exceed the recommended size limit (${SizeFormatHelpers.formatSize(assetLimit)}).
 This can impact web performance.
 Assets: ${assetLists}`;
+
 		Error.captureStackTrace(this, this.constructor);
 	}
 };

package/lib/performance/EntrypointsOverSizeLimitWarning.js

@@ -3,11 +3,14 @@
 	Author Sean Larkin @thelarkinn
 */
 "use strict";
+
+const WebpackError = require("../WebpackError");
 const SizeFormatHelpers = require("../SizeFormatHelpers");
 
-module.exports = class EntrypointsOverSizeLimitWarning extends Error {
+module.exports = class EntrypointsOverSizeLimitWarning extends WebpackError {
 	constructor(entrypoints, entrypointLimit) {
 		super();
+
 		this.name = "EntrypointsOverSizeLimitWarning";
 		this.entrypoints = entrypoints;
 		const entrypointList = this.entrypoints.map(entrypoint => `\n  ${
@@ -19,6 +22,7 @@ module.exports = class EntrypointsOverSizeLimitWarning extends Error {
 		}`).join("");
 		this.message = `entrypoint size limit: The following entrypoint(s) combined asset size exceeds the recommended limit (${SizeFormatHelpers.formatSize(entrypointLimit)}). This can impact web performance.
 Entrypoints:${entrypointList}\n`;
+
 		Error.captureStackTrace(this, this.constructor);
 	}
 };

package/lib/performance/NoAsyncChunksWarning.js

@@ -4,13 +4,17 @@
 */
 "use strict";
 
-module.exports = class NoAsyncChunksWarning extends Error {
+const WebpackError = require("../WebpackError");
+
+module.exports = class NoAsyncChunksWarning extends WebpackError {
 	constructor() {
 		super();
+
 		this.name = "NoAsyncChunksWarning";
 		this.message = "webpack performance recommendations: \n" +
 			"You can limit the size of your bundles by using import() or require.ensure to lazy load some parts of your application.\n" +
 			"For more info visit https://webpack.js.org/guides/code-splitting/";
+
 		Error.captureStackTrace(this, this.constructor);
 	}
 };

package/lib/removeAndDo.js

@@ -2,12 +2,14 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
+"use strict";
+
 module.exports = function removeAndDo(collection, thing, action) {
-	var idx = this[collection].indexOf(thing);
-	if(idx >= 0) {
+	const idx = this[collection].indexOf(thing);
+	const hasThingInCollection = idx >= 0;
+	if(hasThingInCollection) {
 		this[collection].splice(idx, 1);
 		thing[action](this);
-		return true;
 	}
-	return false;
+	return hasThingInCollection;
 };

package/lib/util/identifier.js

@@ -0,0 +1,16 @@
+"use strict";
+const path = require("path");
+
+const looksLikeAbsolutePath = (maybeAbsolutePath) => {
+	return /^(?:[a-z]:\\|\/)/i.test(maybeAbsolutePath);
+};
+
+const normalizePathSeparator = (p) => p.replace(/\\/g, "/");
+
+exports.makePathsRelative = (context, identifier) => {
+	return identifier
+		.split(/([|! ])/)
+		.map(str => looksLikeAbsolutePath(str) ?
+			normalizePathSeparator(path.relative(context, str)) : str)
+		.join("");
+};

package/lib/webpack.js

@@ -40,7 +40,7 @@ function webpack(options, callback) {
 	if(callback) {
 		if(typeof callback !== "function") throw new Error("Invalid argument: callback");
 		if(options.watch === true || (Array.isArray(options) && options.some(o => o.watch))) {
-			const watchOptions = (!Array.isArray(options) ? options : options[0]).watchOptions || {};
+			const watchOptions = Array.isArray(options) ? options.map(o => o.watchOptions || {}) : (options.watchOptions || {});
 			return compiler.watch(watchOptions, callback);
 		}
 		compiler.run(callback);
@@ -102,6 +102,7 @@ exportPlugins(exports, ".", [
 	"DllReferencePlugin",
 	"LoaderOptionsPlugin",
 	"NamedModulesPlugin",
+	"NamedChunksPlugin",
 	"HashedModuleIdsPlugin",
 	"ModuleFilenameHelpers"
 ]);