webpack 3.6.0 → 3.8.1

package/lib/dependencies/RequireContextPlugin.js

@@ -1,96 +1,96 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const RequireContextDependency = require("./RequireContextDependency");
-const ContextElementDependency = require("./ContextElementDependency");
-
-const RequireContextDependencyParserPlugin = require("./RequireContextDependencyParserPlugin");
-
-class RequireContextPlugin {
-	constructor(modulesDirectories, extensions, mainFiles) {
-		if(!Array.isArray(modulesDirectories))
-			throw new Error("modulesDirectories must be an array");
-		if(!Array.isArray(extensions))
-			throw new Error("extensions must be an array");
-		this.modulesDirectories = modulesDirectories;
-		this.extensions = extensions;
-		this.mainFiles = mainFiles;
-	}
-
-	apply(compiler) {
-		compiler.plugin("compilation", (compilation, params) => {
-			const contextModuleFactory = params.contextModuleFactory;
-			const normalModuleFactory = params.normalModuleFactory;
-
-			compilation.dependencyFactories.set(RequireContextDependency, contextModuleFactory);
-			compilation.dependencyTemplates.set(RequireContextDependency, new RequireContextDependency.Template());
-
-			compilation.dependencyFactories.set(ContextElementDependency, normalModuleFactory);
-
-			params.normalModuleFactory.plugin("parser", (parser, parserOptions) => {
-
-				if(typeof parserOptions.requireContext !== "undefined" && !parserOptions.requireContext)
-					return;
-
-				parser.apply(new RequireContextDependencyParserPlugin());
-			});
-
-			params.contextModuleFactory.plugin("alternatives", (items, callback) => {
-				if(items.length === 0) return callback(null, items);
-
-				callback(null, items.map((obj) => {
-					return this.extensions.filter((ext) => {
-						const l = obj.request.length;
-						return l > ext.length && obj.request.substr(l - ext.length, l) === ext;
-					}).map((ext) => {
-						const l = obj.request.length;
-						return {
-							context: obj.context,
-							request: obj.request.substr(0, l - ext.length)
-						};
-					}).concat(obj);
-				}).reduce((a, b) => a.concat(b), []));
-			});
-
-			params.contextModuleFactory.plugin("alternatives", (items, callback) => {
-				if(items.length === 0) return callback(null, items);
-
-				callback(null, items.map((obj) => {
-					return this.mainFiles.filter((mainFile) => {
-						const l = obj.request.length;
-						return l > mainFile.length + 1 && obj.request.substr(l - mainFile.length - 1, l) === "/" + mainFile;
-					}).map((mainFile) => {
-						const l = obj.request.length;
-						return [{
-							context: obj.context,
-							request: obj.request.substr(0, l - mainFile.length)
-						}, {
-							context: obj.context,
-							request: obj.request.substr(0, l - mainFile.length - 1)
-						}];
-					}).reduce((a, b) => a.concat(b), []).concat(obj);
-				}).reduce((a, b) => a.concat(b), []));
-			});
-
-			params.contextModuleFactory.plugin("alternatives", (items, callback) => {
-				if(items.length === 0) return callback(null, items);
-
-				callback(null, items.map((obj) => {
-					for(let i = 0; i < this.modulesDirectories.length; i++) {
-						const dir = this.modulesDirectories[i];
-						const idx = obj.request.indexOf("./" + dir + "/");
-						if(idx === 0) {
-							obj.request = obj.request.slice(dir.length + 3);
-							break;
-						}
-					}
-					return obj;
-				}));
-			});
-		});
-	}
-}
-module.exports = RequireContextPlugin;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const RequireContextDependency = require("./RequireContextDependency");
+const ContextElementDependency = require("./ContextElementDependency");
+
+const RequireContextDependencyParserPlugin = require("./RequireContextDependencyParserPlugin");
+
+class RequireContextPlugin {
+	constructor(modulesDirectories, extensions, mainFiles) {
+		if(!Array.isArray(modulesDirectories))
+			throw new Error("modulesDirectories must be an array");
+		if(!Array.isArray(extensions))
+			throw new Error("extensions must be an array");
+		this.modulesDirectories = modulesDirectories;
+		this.extensions = extensions;
+		this.mainFiles = mainFiles;
+	}
+
+	apply(compiler) {
+		compiler.plugin("compilation", (compilation, params) => {
+			const contextModuleFactory = params.contextModuleFactory;
+			const normalModuleFactory = params.normalModuleFactory;
+
+			compilation.dependencyFactories.set(RequireContextDependency, contextModuleFactory);
+			compilation.dependencyTemplates.set(RequireContextDependency, new RequireContextDependency.Template());
+
+			compilation.dependencyFactories.set(ContextElementDependency, normalModuleFactory);
+
+			params.normalModuleFactory.plugin("parser", (parser, parserOptions) => {
+
+				if(typeof parserOptions.requireContext !== "undefined" && !parserOptions.requireContext)
+					return;
+
+				parser.apply(new RequireContextDependencyParserPlugin());
+			});
+
+			params.contextModuleFactory.plugin("alternatives", (items, callback) => {
+				if(items.length === 0) return callback(null, items);
+
+				callback(null, items.map((obj) => {
+					return this.extensions.filter((ext) => {
+						const l = obj.request.length;
+						return l > ext.length && obj.request.substr(l - ext.length, l) === ext;
+					}).map((ext) => {
+						const l = obj.request.length;
+						return {
+							context: obj.context,
+							request: obj.request.substr(0, l - ext.length)
+						};
+					}).concat(obj);
+				}).reduce((a, b) => a.concat(b), []));
+			});
+
+			params.contextModuleFactory.plugin("alternatives", (items, callback) => {
+				if(items.length === 0) return callback(null, items);
+
+				callback(null, items.map((obj) => {
+					return this.mainFiles.filter((mainFile) => {
+						const l = obj.request.length;
+						return l > mainFile.length + 1 && obj.request.substr(l - mainFile.length - 1, l) === "/" + mainFile;
+					}).map((mainFile) => {
+						const l = obj.request.length;
+						return [{
+							context: obj.context,
+							request: obj.request.substr(0, l - mainFile.length)
+						}, {
+							context: obj.context,
+							request: obj.request.substr(0, l - mainFile.length - 1)
+						}];
+					}).reduce((a, b) => a.concat(b), []).concat(obj);
+				}).reduce((a, b) => a.concat(b), []));
+			});
+
+			params.contextModuleFactory.plugin("alternatives", (items, callback) => {
+				if(items.length === 0) return callback(null, items);
+
+				callback(null, items.map((obj) => {
+					for(let i = 0; i < this.modulesDirectories.length; i++) {
+						const dir = this.modulesDirectories[i];
+						const idx = obj.request.indexOf("./" + dir + "/");
+						if(idx === 0) {
+							obj.request = obj.request.slice(dir.length + 3);
+							break;
+						}
+					}
+					return obj;
+				}));
+			});
+		});
+	}
+}
+module.exports = RequireContextPlugin;

package/lib/dependencies/RequireEnsureDependenciesBlock.js

@@ -1,22 +1,22 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
-const RequireEnsureDependency = require("./RequireEnsureDependency");
-
-module.exports = class RequireEnsureDependenciesBlock extends AsyncDependenciesBlock {
-	constructor(expr, successExpression, errorExpression, chunkName, chunkNameRange, module, loc) {
-		super(chunkName, module, loc);
-		this.expr = expr;
-		const successBodyRange = successExpression && successExpression.body && successExpression.body.range;
-		if(successBodyRange) {
-			this.range = [successBodyRange[0] + 1, successBodyRange[1] - 1];
-		}
-		this.chunkNameRange = chunkNameRange;
-		const dep = new RequireEnsureDependency(this);
-		dep.loc = loc;
-		this.addDependency(dep);
-	}
-};
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
+const RequireEnsureDependency = require("./RequireEnsureDependency");
+
+module.exports = class RequireEnsureDependenciesBlock extends AsyncDependenciesBlock {
+	constructor(expr, successExpression, errorExpression, chunkName, chunkNameRange, module, loc) {
+		super(chunkName, module, loc);
+		this.expr = expr;
+		const successBodyRange = successExpression && successExpression.body && successExpression.body.range;
+		if(successBodyRange) {
+			this.range = [successBodyRange[0] + 1, successBodyRange[1] - 1];
+		}
+		this.chunkNameRange = chunkNameRange;
+		const dep = new RequireEnsureDependency(this);
+		dep.loc = loc;
+		this.addDependency(dep);
+	}
+};

package/lib/dependencies/RequireEnsureDependenciesBlockParserPlugin.js

@@ -1,102 +1,102 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const RequireEnsureDependenciesBlock = require("./RequireEnsureDependenciesBlock");
-const RequireEnsureItemDependency = require("./RequireEnsureItemDependency");
-const getFunctionExpression = require("./getFunctionExpression");
-
-module.exports = class RequireEnsureDependenciesBlockParserPlugin {
-	apply(parser) {
-		parser.plugin("call require.ensure", expr => {
-			let chunkName = null;
-			let chunkNameRange = null;
-			let errorExpressionArg = null;
-			let errorExpression = null;
-			switch(expr.arguments.length) {
-				case 4:
-					{
-						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 successExpressionArg = expr.arguments[1];
-						const successExpression = getFunctionExpression(successExpressionArg);
-
-						if(successExpression) {
-							parser.walkExpressions(successExpression.expressions);
-						}
-						if(errorExpression) {
-							parser.walkExpressions(errorExpression.expressions);
-						}
-
-						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 {
-							let failed = false;
-							parser.inScope([], () => {
-								dependenciesItems.forEach(ee => {
-									if(ee.isString()) {
-										const edep = new RequireEnsureItemDependency(ee.string, ee.range);
-										edep.loc = dep.loc;
-										dep.addDependency(edep);
-									} else {
-										failed = true;
-									}
-								});
-							});
-							if(failed) {
-								return;
-							}
-							if(successExpression) {
-								if(successExpression.fn.body.type === "BlockStatement")
-									parser.walkStatement(successExpression.fn.body);
-								else
-									parser.walkExpression(successExpression.fn.body);
-							}
-							old.addBlock(dep);
-						} finally {
-							parser.state.current = old;
-						}
-						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;
-					}
-			}
-		});
-	}
-};
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const RequireEnsureDependenciesBlock = require("./RequireEnsureDependenciesBlock");
+const RequireEnsureItemDependency = require("./RequireEnsureItemDependency");
+const getFunctionExpression = require("./getFunctionExpression");
+
+module.exports = class RequireEnsureDependenciesBlockParserPlugin {
+	apply(parser) {
+		parser.plugin("call require.ensure", expr => {
+			let chunkName = null;
+			let chunkNameRange = null;
+			let errorExpressionArg = null;
+			let errorExpression = null;
+			switch(expr.arguments.length) {
+				case 4:
+					{
+						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 successExpressionArg = expr.arguments[1];
+						const successExpression = getFunctionExpression(successExpressionArg);
+
+						if(successExpression) {
+							parser.walkExpressions(successExpression.expressions);
+						}
+						if(errorExpression) {
+							parser.walkExpressions(errorExpression.expressions);
+						}
+
+						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 {
+							let failed = false;
+							parser.inScope([], () => {
+								dependenciesItems.forEach(ee => {
+									if(ee.isString()) {
+										const edep = new RequireEnsureItemDependency(ee.string, ee.range);
+										edep.loc = dep.loc;
+										dep.addDependency(edep);
+									} else {
+										failed = true;
+									}
+								});
+							});
+							if(failed) {
+								return;
+							}
+							if(successExpression) {
+								if(successExpression.fn.body.type === "BlockStatement")
+									parser.walkStatement(successExpression.fn.body);
+								else
+									parser.walkExpression(successExpression.fn.body);
+							}
+							old.addBlock(dep);
+						} finally {
+							parser.state.current = old;
+						}
+						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

@@ -1,38 +1,38 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-const NullDependency = require("./NullDependency");
-const DepBlockHelpers = require("./DepBlockHelpers");
-
-class RequireEnsureDependency extends NullDependency {
-	constructor(block) {
-		super();
-		this.block = block;
-	}
-
-	get type() {
-		return "require.ensure";
-	}
-}
-
-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 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);
-		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);
-		}
-	}
-};
-
-module.exports = RequireEnsureDependency;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const NullDependency = require("./NullDependency");
+const DepBlockHelpers = require("./DepBlockHelpers");
+
+class RequireEnsureDependency extends NullDependency {
+	constructor(block) {
+		super();
+		this.block = block;
+	}
+
+	get type() {
+		return "require.ensure";
+	}
+}
+
+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 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);
+		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);
+		}
+	}
+};
+
+module.exports = RequireEnsureDependency;

package/lib/dependencies/RequireEnsureItemDependency.js

@@ -1,21 +1,21 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-const ModuleDependency = require("./ModuleDependency");
-const NullDependency = require("./NullDependency");
-
-class RequireEnsureItemDependency extends ModuleDependency {
-	constructor(request) {
-		super(request);
-	}
-
-	get type() {
-		return "require.ensure item";
-	}
-}
-
-RequireEnsureItemDependency.Template = NullDependency.Template;
-
-module.exports = RequireEnsureItemDependency;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const ModuleDependency = require("./ModuleDependency");
+const NullDependency = require("./NullDependency");
+
+class RequireEnsureItemDependency extends ModuleDependency {
+	constructor(request) {
+		super(request);
+	}
+
+	get type() {
+		return "require.ensure item";
+	}
+}
+
+RequireEnsureItemDependency.Template = NullDependency.Template;
+
+module.exports = RequireEnsureItemDependency;

package/lib/dependencies/RequireEnsurePlugin.js

@@ -1,40 +1,40 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const RequireEnsureItemDependency = require("./RequireEnsureItemDependency");
-const RequireEnsureDependency = require("./RequireEnsureDependency");
-
-const NullFactory = require("../NullFactory");
-
-const RequireEnsureDependenciesBlockParserPlugin = require("./RequireEnsureDependenciesBlockParserPlugin");
-
-const ParserHelpers = require("../ParserHelpers");
-
-class RequireEnsurePlugin {
-
-	apply(compiler) {
-		compiler.plugin("compilation", (compilation, params) => {
-			const normalModuleFactory = params.normalModuleFactory;
-
-			compilation.dependencyFactories.set(RequireEnsureItemDependency, normalModuleFactory);
-			compilation.dependencyTemplates.set(RequireEnsureItemDependency, new RequireEnsureItemDependency.Template());
-
-			compilation.dependencyFactories.set(RequireEnsureDependency, new NullFactory());
-			compilation.dependencyTemplates.set(RequireEnsureDependency, new RequireEnsureDependency.Template());
-
-			params.normalModuleFactory.plugin("parser", (parser, parserOptions) => {
-
-				if(typeof parserOptions.requireEnsure !== "undefined" && !parserOptions.requireEnsure)
-					return;
-
-				parser.apply(new RequireEnsureDependenciesBlockParserPlugin());
-				parser.plugin("evaluate typeof require.ensure", ParserHelpers.evaluateToString("function"));
-				parser.plugin("typeof require.ensure", ParserHelpers.toConstantDependency(JSON.stringify("function")));
-			});
-		});
-	}
-}
-module.exports = RequireEnsurePlugin;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const RequireEnsureItemDependency = require("./RequireEnsureItemDependency");
+const RequireEnsureDependency = require("./RequireEnsureDependency");
+
+const NullFactory = require("../NullFactory");
+
+const RequireEnsureDependenciesBlockParserPlugin = require("./RequireEnsureDependenciesBlockParserPlugin");
+
+const ParserHelpers = require("../ParserHelpers");
+
+class RequireEnsurePlugin {
+
+	apply(compiler) {
+		compiler.plugin("compilation", (compilation, params) => {
+			const normalModuleFactory = params.normalModuleFactory;
+
+			compilation.dependencyFactories.set(RequireEnsureItemDependency, normalModuleFactory);
+			compilation.dependencyTemplates.set(RequireEnsureItemDependency, new RequireEnsureItemDependency.Template());
+
+			compilation.dependencyFactories.set(RequireEnsureDependency, new NullFactory());
+			compilation.dependencyTemplates.set(RequireEnsureDependency, new RequireEnsureDependency.Template());
+
+			params.normalModuleFactory.plugin("parser", (parser, parserOptions) => {
+
+				if(typeof parserOptions.requireEnsure !== "undefined" && !parserOptions.requireEnsure)
+					return;
+
+				parser.apply(new RequireEnsureDependenciesBlockParserPlugin());
+				parser.plugin("evaluate typeof require.ensure", ParserHelpers.evaluateToString("function"));
+				parser.plugin("typeof require.ensure", ParserHelpers.toConstantDependency(JSON.stringify("function")));
+			});
+		});
+	}
+}
+module.exports = RequireEnsurePlugin;