webpack 3.8.0 → 3.8.1

package/lib/ContextReplacementPlugin.js

@@ -1,111 +1,111 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const path = require("path");
-const ContextElementDependency = require("./dependencies/ContextElementDependency");
-
-class ContextReplacementPlugin {
-	constructor(resourceRegExp, newContentResource, newContentRecursive, newContentRegExp) {
-		this.resourceRegExp = resourceRegExp;
-
-		if(typeof newContentResource === "function") {
-			this.newContentCallback = newContentResource;
-		} else if(typeof newContentResource === "string" && typeof newContentRecursive === "object") {
-			this.newContentResource = newContentResource;
-			this.newContentCreateContextMap = (fs, callback) => {
-				callback(null, newContentRecursive);
-			};
-		} else if(typeof newContentResource === "string" && typeof newContentRecursive === "function") {
-			this.newContentResource = newContentResource;
-			this.newContentCreateContextMap = newContentRecursive;
-		} else {
-			if(typeof newContentResource !== "string") {
-				newContentRegExp = newContentRecursive;
-				newContentRecursive = newContentResource;
-				newContentResource = undefined;
-			}
-			if(typeof newContentRecursive !== "boolean") {
-				newContentRegExp = newContentRecursive;
-				newContentRecursive = undefined;
-			}
-			this.newContentResource = newContentResource;
-			this.newContentRecursive = newContentRecursive;
-			this.newContentRegExp = newContentRegExp;
-		}
-	}
-
-	apply(compiler) {
-		const resourceRegExp = this.resourceRegExp;
-		const newContentCallback = this.newContentCallback;
-		const newContentResource = this.newContentResource;
-		const newContentRecursive = this.newContentRecursive;
-		const newContentRegExp = this.newContentRegExp;
-		const newContentCreateContextMap = this.newContentCreateContextMap;
-
-		compiler.plugin("context-module-factory", (cmf) => {
-			cmf.plugin("before-resolve", (result, callback) => {
-				if(!result) return callback();
-				if(resourceRegExp.test(result.request)) {
-					if(typeof newContentResource !== "undefined")
-						result.request = newContentResource;
-					if(typeof newContentRecursive !== "undefined")
-						result.recursive = newContentRecursive;
-					if(typeof newContentRegExp !== "undefined")
-						result.regExp = newContentRegExp;
-					if(typeof newContentCallback === "function") {
-						newContentCallback(result);
-					} else {
-						result.dependencies.forEach((d) => {
-							if(d.critical)
-								d.critical = false;
-						});
-					}
-				}
-				return callback(null, result);
-			});
-			cmf.plugin("after-resolve", (result, callback) => {
-				if(!result) return callback();
-				if(resourceRegExp.test(result.resource)) {
-					if(typeof newContentResource !== "undefined")
-						result.resource = path.resolve(result.resource, newContentResource);
-					if(typeof newContentRecursive !== "undefined")
-						result.recursive = newContentRecursive;
-					if(typeof newContentRegExp !== "undefined")
-						result.regExp = newContentRegExp;
-					if(typeof newContentCreateContextMap === "function")
-						result.resolveDependencies = createResolveDependenciesFromContextMap(newContentCreateContextMap);
-					if(typeof newContentCallback === "function") {
-						const origResource = result.resource;
-						newContentCallback(result);
-						if(result.resource !== origResource) {
-							result.resource = path.resolve(origResource, result.resource);
-						}
-					} else {
-						result.dependencies.forEach((d) => {
-							if(d.critical)
-								d.critical = false;
-						});
-					}
-				}
-				return callback(null, result);
-			});
-		});
-	}
-}
-
-const createResolveDependenciesFromContextMap = (createContextMap) => {
-	return function resolveDependenciesFromContextMap(fs, resource, recursive, regExp, callback) {
-		createContextMap(fs, (err, map) => {
-			if(err) return callback(err);
-			const dependencies = Object.keys(map).map((key) => {
-				return new ContextElementDependency(map[key], key);
-			});
-			callback(null, dependencies);
-		});
-	};
-};
-
-module.exports = ContextReplacementPlugin;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const path = require("path");
+const ContextElementDependency = require("./dependencies/ContextElementDependency");
+
+class ContextReplacementPlugin {
+	constructor(resourceRegExp, newContentResource, newContentRecursive, newContentRegExp) {
+		this.resourceRegExp = resourceRegExp;
+
+		if(typeof newContentResource === "function") {
+			this.newContentCallback = newContentResource;
+		} else if(typeof newContentResource === "string" && typeof newContentRecursive === "object") {
+			this.newContentResource = newContentResource;
+			this.newContentCreateContextMap = (fs, callback) => {
+				callback(null, newContentRecursive);
+			};
+		} else if(typeof newContentResource === "string" && typeof newContentRecursive === "function") {
+			this.newContentResource = newContentResource;
+			this.newContentCreateContextMap = newContentRecursive;
+		} else {
+			if(typeof newContentResource !== "string") {
+				newContentRegExp = newContentRecursive;
+				newContentRecursive = newContentResource;
+				newContentResource = undefined;
+			}
+			if(typeof newContentRecursive !== "boolean") {
+				newContentRegExp = newContentRecursive;
+				newContentRecursive = undefined;
+			}
+			this.newContentResource = newContentResource;
+			this.newContentRecursive = newContentRecursive;
+			this.newContentRegExp = newContentRegExp;
+		}
+	}
+
+	apply(compiler) {
+		const resourceRegExp = this.resourceRegExp;
+		const newContentCallback = this.newContentCallback;
+		const newContentResource = this.newContentResource;
+		const newContentRecursive = this.newContentRecursive;
+		const newContentRegExp = this.newContentRegExp;
+		const newContentCreateContextMap = this.newContentCreateContextMap;
+
+		compiler.plugin("context-module-factory", (cmf) => {
+			cmf.plugin("before-resolve", (result, callback) => {
+				if(!result) return callback();
+				if(resourceRegExp.test(result.request)) {
+					if(typeof newContentResource !== "undefined")
+						result.request = newContentResource;
+					if(typeof newContentRecursive !== "undefined")
+						result.recursive = newContentRecursive;
+					if(typeof newContentRegExp !== "undefined")
+						result.regExp = newContentRegExp;
+					if(typeof newContentCallback === "function") {
+						newContentCallback(result);
+					} else {
+						result.dependencies.forEach((d) => {
+							if(d.critical)
+								d.critical = false;
+						});
+					}
+				}
+				return callback(null, result);
+			});
+			cmf.plugin("after-resolve", (result, callback) => {
+				if(!result) return callback();
+				if(resourceRegExp.test(result.resource)) {
+					if(typeof newContentResource !== "undefined")
+						result.resource = path.resolve(result.resource, newContentResource);
+					if(typeof newContentRecursive !== "undefined")
+						result.recursive = newContentRecursive;
+					if(typeof newContentRegExp !== "undefined")
+						result.regExp = newContentRegExp;
+					if(typeof newContentCreateContextMap === "function")
+						result.resolveDependencies = createResolveDependenciesFromContextMap(newContentCreateContextMap);
+					if(typeof newContentCallback === "function") {
+						const origResource = result.resource;
+						newContentCallback(result);
+						if(result.resource !== origResource) {
+							result.resource = path.resolve(origResource, result.resource);
+						}
+					} else {
+						result.dependencies.forEach((d) => {
+							if(d.critical)
+								d.critical = false;
+						});
+					}
+				}
+				return callback(null, result);
+			});
+		});
+	}
+}
+
+const createResolveDependenciesFromContextMap = (createContextMap) => {
+	return function resolveDependenciesFromContextMap(fs, resource, recursive, regExp, callback) {
+		createContextMap(fs, (err, map) => {
+			if(err) return callback(err);
+			const dependencies = Object.keys(map).map((key) => {
+				return new ContextElementDependency(map[key], key);
+			});
+			callback(null, dependencies);
+		});
+	};
+};
+
+module.exports = ContextReplacementPlugin;

package/lib/DefinePlugin.js

@@ -1,123 +1,123 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const ConstDependency = require("./dependencies/ConstDependency");
-const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
-const ParserHelpers = require("./ParserHelpers");
-const NullFactory = require("./NullFactory");
-
-class DefinePlugin {
-	constructor(definitions) {
-		this.definitions = definitions;
-	}
-
-	apply(compiler) {
-		const definitions = this.definitions;
-		compiler.plugin("compilation", (compilation, params) => {
-			compilation.dependencyFactories.set(ConstDependency, new NullFactory());
-			compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template());
-
-			params.normalModuleFactory.plugin("parser", (parser) => {
-				(function walkDefinitions(definitions, prefix) {
-					Object.keys(definitions).forEach((key) => {
-						const code = definitions[key];
-						if(code && typeof code === "object" && !(code instanceof RegExp)) {
-							walkDefinitions(code, prefix + key + ".");
-							applyObjectDefine(prefix + key, code);
-							return;
-						}
-						applyDefineKey(prefix, key);
-						applyDefine(prefix + key, code);
-					});
-				}(definitions, ""));
-
-				function stringifyObj(obj) {
-					return "Object({" + Object.keys(obj).map((key) => {
-						const code = obj[key];
-						return JSON.stringify(key) + ":" + toCode(code);
-					}).join(",") + "})";
-				}
-
-				function toCode(code) {
-					if(code === null) return "null";
-					else if(code === undefined) return "undefined";
-					else if(code instanceof RegExp && code.toString) return code.toString();
-					else if(typeof code === "function" && code.toString) return "(" + code.toString() + ")";
-					else if(typeof code === "object") return stringifyObj(code);
-					else return code + "";
-				}
-
-				function applyDefineKey(prefix, key) {
-					const splittedKey = key.split(".");
-					splittedKey.slice(1).forEach((_, i) => {
-						const fullKey = prefix + splittedKey.slice(0, i + 1).join(".");
-						parser.plugin("can-rename " + fullKey, ParserHelpers.approve);
-					});
-				}
-
-				function applyDefine(key, code) {
-					const isTypeof = /^typeof\s+/.test(key);
-					if(isTypeof) key = key.replace(/^typeof\s+/, "");
-					let recurse = false;
-					let recurseTypeof = false;
-					code = toCode(code);
-					if(!isTypeof) {
-						parser.plugin("can-rename " + key, ParserHelpers.approve);
-						parser.plugin("evaluate Identifier " + key, (expr) => {
-							/**
-							 * this is needed in case there is a recursion in the DefinePlugin
-							 * to prevent an endless recursion
-							 * e.g.: new DefinePlugin({
-							 * "a": "b",
-							 * "b": "a"
-							 * });
-							 */
-							if(recurse) return;
-							recurse = true;
-							const res = parser.evaluate(code);
-							recurse = false;
-							res.setRange(expr.range);
-							return res;
-						});
-						parser.plugin("expression " + key, ParserHelpers.toConstantDependency(code));
-					}
-					const typeofCode = isTypeof ? code : "typeof (" + code + ")";
-					parser.plugin("evaluate typeof " + key, (expr) => {
-						/**
-						 * this is needed in case there is a recursion in the DefinePlugin
-						 * to prevent an endless recursion
-						 * e.g.: new DefinePlugin({
-						 * "typeof a": "tyepof b",
-						 * "typeof b": "typeof a"
-						 * });
-						 */
-						if(recurseTypeof) return;
-						recurseTypeof = true;
-						const res = parser.evaluate(typeofCode);
-						recurseTypeof = false;
-						res.setRange(expr.range);
-						return res;
-					});
-					parser.plugin("typeof " + key, (expr) => {
-						const res = parser.evaluate(typeofCode);
-						if(!res.isString()) return;
-						return ParserHelpers.toConstantDependency(JSON.stringify(res.string)).bind(parser)(expr);
-					});
-				}
-
-				function applyObjectDefine(key, obj) {
-					const code = stringifyObj(obj);
-					parser.plugin("can-rename " + key, ParserHelpers.approve);
-					parser.plugin("evaluate Identifier " + key, (expr) => new BasicEvaluatedExpression().setTruthy().setRange(expr.range));
-					parser.plugin("evaluate typeof " + key, ParserHelpers.evaluateToString("object"));
-					parser.plugin("expression " + key, ParserHelpers.toConstantDependency(code));
-					parser.plugin("typeof " + key, ParserHelpers.toConstantDependency(JSON.stringify("object")));
-				}
-			});
-		});
-	}
-}
-module.exports = DefinePlugin;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const ConstDependency = require("./dependencies/ConstDependency");
+const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
+const ParserHelpers = require("./ParserHelpers");
+const NullFactory = require("./NullFactory");
+
+class DefinePlugin {
+	constructor(definitions) {
+		this.definitions = definitions;
+	}
+
+	apply(compiler) {
+		const definitions = this.definitions;
+		compiler.plugin("compilation", (compilation, params) => {
+			compilation.dependencyFactories.set(ConstDependency, new NullFactory());
+			compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template());
+
+			params.normalModuleFactory.plugin("parser", (parser) => {
+				(function walkDefinitions(definitions, prefix) {
+					Object.keys(definitions).forEach((key) => {
+						const code = definitions[key];
+						if(code && typeof code === "object" && !(code instanceof RegExp)) {
+							walkDefinitions(code, prefix + key + ".");
+							applyObjectDefine(prefix + key, code);
+							return;
+						}
+						applyDefineKey(prefix, key);
+						applyDefine(prefix + key, code);
+					});
+				}(definitions, ""));
+
+				function stringifyObj(obj) {
+					return "Object({" + Object.keys(obj).map((key) => {
+						const code = obj[key];
+						return JSON.stringify(key) + ":" + toCode(code);
+					}).join(",") + "})";
+				}
+
+				function toCode(code) {
+					if(code === null) return "null";
+					else if(code === undefined) return "undefined";
+					else if(code instanceof RegExp && code.toString) return code.toString();
+					else if(typeof code === "function" && code.toString) return "(" + code.toString() + ")";
+					else if(typeof code === "object") return stringifyObj(code);
+					else return code + "";
+				}
+
+				function applyDefineKey(prefix, key) {
+					const splittedKey = key.split(".");
+					splittedKey.slice(1).forEach((_, i) => {
+						const fullKey = prefix + splittedKey.slice(0, i + 1).join(".");
+						parser.plugin("can-rename " + fullKey, ParserHelpers.approve);
+					});
+				}
+
+				function applyDefine(key, code) {
+					const isTypeof = /^typeof\s+/.test(key);
+					if(isTypeof) key = key.replace(/^typeof\s+/, "");
+					let recurse = false;
+					let recurseTypeof = false;
+					code = toCode(code);
+					if(!isTypeof) {
+						parser.plugin("can-rename " + key, ParserHelpers.approve);
+						parser.plugin("evaluate Identifier " + key, (expr) => {
+							/**
+							 * this is needed in case there is a recursion in the DefinePlugin
+							 * to prevent an endless recursion
+							 * e.g.: new DefinePlugin({
+							 * "a": "b",
+							 * "b": "a"
+							 * });
+							 */
+							if(recurse) return;
+							recurse = true;
+							const res = parser.evaluate(code);
+							recurse = false;
+							res.setRange(expr.range);
+							return res;
+						});
+						parser.plugin("expression " + key, ParserHelpers.toConstantDependency(code));
+					}
+					const typeofCode = isTypeof ? code : "typeof (" + code + ")";
+					parser.plugin("evaluate typeof " + key, (expr) => {
+						/**
+						 * this is needed in case there is a recursion in the DefinePlugin
+						 * to prevent an endless recursion
+						 * e.g.: new DefinePlugin({
+						 * "typeof a": "tyepof b",
+						 * "typeof b": "typeof a"
+						 * });
+						 */
+						if(recurseTypeof) return;
+						recurseTypeof = true;
+						const res = parser.evaluate(typeofCode);
+						recurseTypeof = false;
+						res.setRange(expr.range);
+						return res;
+					});
+					parser.plugin("typeof " + key, (expr) => {
+						const res = parser.evaluate(typeofCode);
+						if(!res.isString()) return;
+						return ParserHelpers.toConstantDependency(JSON.stringify(res.string)).bind(parser)(expr);
+					});
+				}
+
+				function applyObjectDefine(key, obj) {
+					const code = stringifyObj(obj);
+					parser.plugin("can-rename " + key, ParserHelpers.approve);
+					parser.plugin("evaluate Identifier " + key, (expr) => new BasicEvaluatedExpression().setTruthy().setRange(expr.range));
+					parser.plugin("evaluate typeof " + key, ParserHelpers.evaluateToString("object"));
+					parser.plugin("expression " + key, ParserHelpers.toConstantDependency(code));
+					parser.plugin("typeof " + key, ParserHelpers.toConstantDependency(JSON.stringify("object")));
+				}
+			});
+		});
+	}
+}
+module.exports = DefinePlugin;

package/lib/DelegatedModule.js

@@ -1,98 +1,98 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const Module = require("./Module");
-const OriginalSource = require("webpack-sources").OriginalSource;
-const RawSource = require("webpack-sources").RawSource;
-const WebpackMissingModule = require("./dependencies/WebpackMissingModule");
-const DelegatedSourceDependency = require("./dependencies/DelegatedSourceDependency");
-const DelegatedExportsDependency = require("./dependencies/DelegatedExportsDependency");
-
-class DelegatedModule extends Module {
-	constructor(sourceRequest, data, type, userRequest, originalRequest) {
-		super();
-		this.sourceRequest = sourceRequest;
-		this.request = data.id;
-		this.meta = data.meta;
-		this.type = type;
-		this.originalRequest = originalRequest;
-		this.userRequest = userRequest;
-		this.built = false;
-		this.delegated = true;
-		this.delegateData = data;
-	}
-
-	libIdent(options) {
-		return typeof this.originalRequest === "string" ? this.originalRequest : this.originalRequest.libIdent(options);
-	}
-
-	identifier() {
-		return `delegated ${JSON.stringify(this.request)} from ${this.sourceRequest}`;
-	}
-
-	readableIdentifier() {
-		return `delegated ${this.userRequest} from ${this.sourceRequest}`;
-	}
-
-	needRebuild() {
-		return false;
-	}
-
-	build(options, compilation, resolver, fs, callback) {
-		this.built = true;
-		this.builtTime = Date.now();
-		this.cacheable = true;
-		this.dependencies.length = 0;
-		this.addDependency(new DelegatedSourceDependency(this.sourceRequest));
-		this.addDependency(new DelegatedExportsDependency(this, this.delegateData.exports || true));
-		callback();
-	}
-
-	unbuild() {
-		this.built = false;
-		super.unbuild();
-	}
-
-	source() {
-		const sourceModule = this.dependencies[0].module;
-		let str;
-
-		if(!sourceModule) {
-			str = WebpackMissingModule.moduleCode(this.sourceRequest);
-		} else {
-			str = `module.exports = (__webpack_require__(${JSON.stringify(sourceModule.id)}))`;
-
-			switch(this.type) {
-				case "require":
-					str += `(${JSON.stringify(this.request)})`;
-					break;
-				case "object":
-					str += `[${JSON.stringify(this.request)}]`;
-					break;
-			}
-
-			str += ";";
-		}
-
-		if(this.useSourceMap) {
-			return new OriginalSource(str, this.identifier());
-		} else {
-			return new RawSource(str);
-		}
-	}
-
-	size() {
-		return 42;
-	}
-
-	updateHash(hash) {
-		hash.update(this.type);
-		hash.update(JSON.stringify(this.request));
-		super.updateHash(hash);
-	}
-}
-
-module.exports = DelegatedModule;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const Module = require("./Module");
+const OriginalSource = require("webpack-sources").OriginalSource;
+const RawSource = require("webpack-sources").RawSource;
+const WebpackMissingModule = require("./dependencies/WebpackMissingModule");
+const DelegatedSourceDependency = require("./dependencies/DelegatedSourceDependency");
+const DelegatedExportsDependency = require("./dependencies/DelegatedExportsDependency");
+
+class DelegatedModule extends Module {
+	constructor(sourceRequest, data, type, userRequest, originalRequest) {
+		super();
+		this.sourceRequest = sourceRequest;
+		this.request = data.id;
+		this.meta = data.meta;
+		this.type = type;
+		this.originalRequest = originalRequest;
+		this.userRequest = userRequest;
+		this.built = false;
+		this.delegated = true;
+		this.delegateData = data;
+	}
+
+	libIdent(options) {
+		return typeof this.originalRequest === "string" ? this.originalRequest : this.originalRequest.libIdent(options);
+	}
+
+	identifier() {
+		return `delegated ${JSON.stringify(this.request)} from ${this.sourceRequest}`;
+	}
+
+	readableIdentifier() {
+		return `delegated ${this.userRequest} from ${this.sourceRequest}`;
+	}
+
+	needRebuild() {
+		return false;
+	}
+
+	build(options, compilation, resolver, fs, callback) {
+		this.built = true;
+		this.builtTime = Date.now();
+		this.cacheable = true;
+		this.dependencies.length = 0;
+		this.addDependency(new DelegatedSourceDependency(this.sourceRequest));
+		this.addDependency(new DelegatedExportsDependency(this, this.delegateData.exports || true));
+		callback();
+	}
+
+	unbuild() {
+		this.built = false;
+		super.unbuild();
+	}
+
+	source() {
+		const sourceModule = this.dependencies[0].module;
+		let str;
+
+		if(!sourceModule) {
+			str = WebpackMissingModule.moduleCode(this.sourceRequest);
+		} else {
+			str = `module.exports = (__webpack_require__(${JSON.stringify(sourceModule.id)}))`;
+
+			switch(this.type) {
+				case "require":
+					str += `(${JSON.stringify(this.request)})`;
+					break;
+				case "object":
+					str += `[${JSON.stringify(this.request)}]`;
+					break;
+			}
+
+			str += ";";
+		}
+
+		if(this.useSourceMap) {
+			return new OriginalSource(str, this.identifier());
+		} else {
+			return new RawSource(str);
+		}
+	}
+
+	size() {
+		return 42;
+	}
+
+	updateHash(hash) {
+		hash.update(this.type);
+		hash.update(JSON.stringify(this.request));
+		super.updateHash(hash);
+	}
+}
+
+module.exports = DelegatedModule;