webpack 3.8.1 → 3.11.0

package/lib/dependencies/RequireContextDependency.js

@@ -1,26 +1,26 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-const ContextDependency = require("./ContextDependency");
-const ModuleDependencyTemplateAsRequireId = require("./ModuleDependencyTemplateAsRequireId");
-
-class RequireContextDependency extends ContextDependency {
-	constructor(request, recursive, regExp, asyncMode, range) {
-		super(request, recursive, regExp);
-		this.range = range;
-
-		if(asyncMode) {
-			this.async = asyncMode;
-		}
-	}
-
-	get type() {
-		return "require.context";
-	}
-}
-
-RequireContextDependency.Template = ModuleDependencyTemplateAsRequireId;
-
-module.exports = RequireContextDependency;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const ContextDependency = require("./ContextDependency");
+const ModuleDependencyTemplateAsRequireId = require("./ModuleDependencyTemplateAsRequireId");
+
+class RequireContextDependency extends ContextDependency {
+	constructor(request, recursive, regExp, asyncMode, range) {
+		super(request, recursive, regExp);
+		this.range = range;
+
+		if(asyncMode) {
+			this.async = asyncMode;
+		}
+	}
+
+	get type() {
+		return "require.context";
+	}
+}
+
+RequireContextDependency.Template = ModuleDependencyTemplateAsRequireId;
+
+module.exports = RequireContextDependency;

package/lib/dependencies/RequireContextDependencyParserPlugin.js

@@ -1,50 +1,50 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const RequireContextDependency = require("./RequireContextDependency");
-
-module.exports = class RequireContextDependencyParserPlugin {
-	apply(parser) {
-		parser.plugin("call require.context", expr => {
-			let regExp = /^\.\/.*$/;
-			let recursive = true;
-			let asyncMode;
-			switch(expr.arguments.length) {
-				case 4:
-					{
-						const asyncModeExpr = parser.evaluateExpression(expr.arguments[3]);
-						if(!asyncModeExpr.isString()) return;
-						asyncMode = asyncModeExpr.string;
-					}
-					// falls through
-				case 3:
-					{
-						const regExpExpr = parser.evaluateExpression(expr.arguments[2]);
-						if(!regExpExpr.isRegExp()) return;
-						regExp = regExpExpr.regExp;
-					}
-					// falls through
-				case 2:
-					{
-						const recursiveExpr = parser.evaluateExpression(expr.arguments[1]);
-						if(!recursiveExpr.isBoolean()) return;
-						recursive = recursiveExpr.bool;
-					}
-					// falls through
-				case 1:
-					{
-						const requestExpr = parser.evaluateExpression(expr.arguments[0]);
-						if(!requestExpr.isString()) return;
-						const dep = new RequireContextDependency(requestExpr.string, recursive, regExp, asyncMode, expr.range);
-						dep.loc = expr.loc;
-						dep.optional = parser.scope.inTry;
-						parser.state.current.addDependency(dep);
-						return true;
-					}
-			}
-		});
-	}
-};
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const RequireContextDependency = require("./RequireContextDependency");
+
+module.exports = class RequireContextDependencyParserPlugin {
+	apply(parser) {
+		parser.plugin("call require.context", expr => {
+			let regExp = /^\.\/.*$/;
+			let recursive = true;
+			let asyncMode;
+			switch(expr.arguments.length) {
+				case 4:
+					{
+						const asyncModeExpr = parser.evaluateExpression(expr.arguments[3]);
+						if(!asyncModeExpr.isString()) return;
+						asyncMode = asyncModeExpr.string;
+					}
+					// falls through
+				case 3:
+					{
+						const regExpExpr = parser.evaluateExpression(expr.arguments[2]);
+						if(!regExpExpr.isRegExp()) return;
+						regExp = regExpExpr.regExp;
+					}
+					// falls through
+				case 2:
+					{
+						const recursiveExpr = parser.evaluateExpression(expr.arguments[1]);
+						if(!recursiveExpr.isBoolean()) return;
+						recursive = recursiveExpr.bool;
+					}
+					// falls through
+				case 1:
+					{
+						const requestExpr = parser.evaluateExpression(expr.arguments[0]);
+						if(!requestExpr.isString()) return;
+						const dep = new RequireContextDependency(requestExpr.string, recursive, regExp, asyncMode, expr.range);
+						dep.loc = expr.loc;
+						dep.optional = parser.scope.inTry;
+						parser.state.current.addDependency(dep);
+						return true;
+					}
+			}
+		});
+	}
+};

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;
+					}
+			}
+		});
+	}
+};