webpack 2.2.0-rc.6 → 2.2.1

package/lib/dependencies/ModuleDependencyTemplateAsId.js

@@ -2,22 +2,20 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-function ModuleDependencyTemplateAsId() {}
-module.exports = ModuleDependencyTemplateAsId;
+"use strict";
 
-ModuleDependencyTemplateAsId.prototype.apply = function(dep, source, outputOptions, requestShortener) {
-	if(!dep.range) return;
-	var comment = "";
-	if(outputOptions.pathinfo) comment = "/*! " + requestShortener.shorten(dep.request) + " */ ";
-	var content;
-	if(dep.module)
-		content = comment + JSON.stringify(dep.module.id);
-	else
-		content = require("./WebpackMissingModule").module(dep.request);
-	source.replace(dep.range[0], dep.range[1] - 1, content);
-};
+class ModuleDependencyTemplateAsId {
 
-ModuleDependencyTemplateAsId.prototype.applyAsTemplateArgument = function(name, dep, source) {
-	if(!dep.range) return;
-	source.replace(dep.range[0], dep.range[1] - 1, name);
-};
+	apply(dep, source, outputOptions, requestShortener) {
+		if(!dep.range) return;
+		let comment = "";
+		if(outputOptions.pathinfo) comment = `/*! ${requestShortener.shorten(dep.request)} */ `;
+		let content;
+		if(dep.module)
+			content = comment + JSON.stringify(dep.module.id);
+		else
+			content = require("./WebpackMissingModule").module(dep.request);
+		source.replace(dep.range[0], dep.range[1] - 1, content);
+	}
+}
+module.exports = ModuleDependencyTemplateAsId;

package/lib/dependencies/ModuleDependencyTemplateAsRequireId.js

@@ -2,22 +2,20 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-function ModuleDependencyTemplateAsRequireId() {}
-module.exports = ModuleDependencyTemplateAsRequireId;
+"use strict";
 
-ModuleDependencyTemplateAsRequireId.prototype.apply = function(dep, source, outputOptions, requestShortener) {
-	if(!dep.range) return;
-	var comment = "";
-	if(outputOptions.pathinfo) comment = "/*! " + requestShortener.shorten(dep.request) + " */ ";
-	var content;
-	if(dep.module)
-		content = "__webpack_require__(" + comment + JSON.stringify(dep.module.id) + ")";
-	else
-		content = require("./WebpackMissingModule").module(dep.request);
-	source.replace(dep.range[0], dep.range[1] - 1, content);
-};
+class ModuleDependencyTemplateAsRequireId {
 
-ModuleDependencyTemplateAsRequireId.prototype.applyAsTemplateArgument = function(name, dep, source) {
-	if(!dep.range) return;
-	source.replace(dep.range[0], dep.range[1] - 1, "(__webpack_require__(" + name + "))");
-};
+	apply(dep, source, outputOptions, requestShortener) {
+		if(!dep.range) return;
+		let comment = "";
+		if(outputOptions.pathinfo) comment = `/*! ${requestShortener.shorten(dep.request)} */ `;
+		let content;
+		if(dep.module)
+			content = `__webpack_require__(${comment}${JSON.stringify(dep.module.id)})`;
+		else
+			content = require("./WebpackMissingModule").module(dep.request);
+		source.replace(dep.range[0], dep.range[1] - 1, content);
+	}
+}
+module.exports = ModuleDependencyTemplateAsRequireId;

package/lib/dependencies/RequireContextPlugin.js

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

package/lib/dependencies/RequireEnsurePlugin.js

@@ -3,42 +3,38 @@
 	Author Tobias Koppers @sokra
 */
 "use strict";
-var RequireEnsureItemDependency = require("./RequireEnsureItemDependency");
-var RequireEnsureDependency = require("./RequireEnsureDependency");
-var ConstDependency = require("./ConstDependency");
 
-var NullFactory = require("../NullFactory");
+const RequireEnsureItemDependency = require("./RequireEnsureItemDependency");
+const RequireEnsureDependency = require("./RequireEnsureDependency");
 
-var RequireEnsureDependenciesBlockParserPlugin = require("./RequireEnsureDependenciesBlockParserPlugin");
+const NullFactory = require("../NullFactory");
+
+const RequireEnsureDependenciesBlockParserPlugin = require("./RequireEnsureDependenciesBlockParserPlugin");
 
 const ParserHelpers = require("../ParserHelpers");
 
-function RequireEnsurePlugin() {}
-module.exports = RequireEnsurePlugin;
+class RequireEnsurePlugin {
 
-RequireEnsurePlugin.prototype.apply = function(compiler) {
-	compiler.plugin("compilation", function(compilation, params) {
-		var normalModuleFactory = params.normalModuleFactory;
+	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(RequireEnsureItemDependency, normalModuleFactory);
+			compilation.dependencyTemplates.set(RequireEnsureItemDependency, new RequireEnsureItemDependency.Template());
 
-		compilation.dependencyFactories.set(RequireEnsureDependency, new NullFactory());
-		compilation.dependencyTemplates.set(RequireEnsureDependency, new RequireEnsureDependency.Template());
+			compilation.dependencyFactories.set(RequireEnsureDependency, new NullFactory());
+			compilation.dependencyTemplates.set(RequireEnsureDependency, new RequireEnsureDependency.Template());
 
-		params.normalModuleFactory.plugin("parser", function(parser, parserOptions) {
+			params.normalModuleFactory.plugin("parser", (parser, parserOptions) => {
 
-			if(typeof parserOptions.requireEnsure !== "undefined" && !parserOptions.requireEnsure)
-				return;
+				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", function(expr) {
-				var dep = new ConstDependency("'function'", expr.range);
-				dep.loc = expr.loc;
-				this.state.current.addDependency(dep);
-				return true;
+				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;

package/lib/dependencies/RequireIncludePlugin.js

@@ -3,36 +3,31 @@
 	Author Tobias Koppers @sokra
 */
 "use strict";
-var RequireIncludeDependency = require("./RequireIncludeDependency");
-var RequireIncludeDependencyParserPlugin = require("./RequireIncludeDependencyParserPlugin");
-var ConstDependency = require("./ConstDependency");
+
+const RequireIncludeDependency = require("./RequireIncludeDependency");
+const RequireIncludeDependencyParserPlugin = require("./RequireIncludeDependencyParserPlugin");
 
 const ParserHelpers = require("../ParserHelpers");
 
-function RequireIncludePlugin() {}
-module.exports = RequireIncludePlugin;
+class RequireIncludePlugin {
 
-RequireIncludePlugin.prototype.apply = function(compiler) {
-	compiler.plugin("compilation", function(compilation, params) {
-		var normalModuleFactory = params.normalModuleFactory;
+	apply(compiler) {
+		compiler.plugin("compilation", (compilation, params) => {
+			const normalModuleFactory = params.normalModuleFactory;
 
-		compilation.dependencyFactories.set(RequireIncludeDependency, normalModuleFactory);
-		compilation.dependencyTemplates.set(RequireIncludeDependency, new RequireIncludeDependency.Template());
+			compilation.dependencyFactories.set(RequireIncludeDependency, normalModuleFactory);
+			compilation.dependencyTemplates.set(RequireIncludeDependency, new RequireIncludeDependency.Template());
 
-		params.normalModuleFactory.plugin("parser", function(parser, parserOptions) {
+			params.normalModuleFactory.plugin("parser", (parser, parserOptions) => {
 
-			if(typeof parserOptions.requireInclude !== "undefined" && !parserOptions.requireInclude)
-				return;
+				if(typeof parserOptions.requireInclude !== "undefined" && !parserOptions.requireInclude)
+					return;
 
-			parser.apply(new RequireIncludeDependencyParserPlugin());
-			parser.plugin("evaluate typeof require.include", ParserHelpers.evaluateToString("function"));
-			parser.plugin("typeof require.include", function(expr) {
-				var dep = new ConstDependency("'function'", expr.range);
-				dep.loc = expr.loc;
-				this.state.current.addDependency(dep);
-				return true;
+				parser.apply(new RequireIncludeDependencyParserPlugin());
+				parser.plugin("evaluate typeof require.include", ParserHelpers.evaluateToString("function"));
+				parser.plugin("typeof require.include", ParserHelpers.toConstantDependency(JSON.stringify("function")));
 			});
-
 		});
-	});
-};
+	}
+}
+module.exports = RequireIncludePlugin;

package/lib/dependencies/RequireResolveDependencyParserPlugin.js

@@ -2,68 +2,71 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-var RequireResolveDependency = require("./RequireResolveDependency");
-var RequireResolveContextDependency = require("./RequireResolveContextDependency");
-var RequireResolveHeaderDependency = require("./RequireResolveHeaderDependency");
-var ContextDependencyHelpers = require("./ContextDependencyHelpers");
+"use strict";
 
-function RequireResolveDependencyParserPlugin(options) {
-	this.options = options;
-}
+const RequireResolveDependency = require("./RequireResolveDependency");
+const RequireResolveContextDependency = require("./RequireResolveContextDependency");
+const RequireResolveHeaderDependency = require("./RequireResolveHeaderDependency");
+const ContextDependencyHelpers = require("./ContextDependencyHelpers");
 
-module.exports = RequireResolveDependencyParserPlugin;
+class RequireResolveDependencyParserPlugin {
+	constructor(options) {
+		this.options = options;
+	}
 
-RequireResolveDependencyParserPlugin.prototype.apply = function(parser) {
-	var options = this.options;
-	parser.plugin("call require.resolve", function(expr) {
-		return this.applyPluginsBailResult("call require.resolve(Weak)", expr, false);
-	});
-	parser.plugin("call require.resolveWeak", function(expr) {
-		return this.applyPluginsBailResult("call require.resolve(Weak)", expr, true);
-	});
-	parser.plugin("call require.resolve(Weak)", function(expr, weak) {
-		if(expr.arguments.length !== 1) return;
-		var param = this.evaluateExpression(expr.arguments[0]);
-		var dep;
-		if(param.isConditional()) {
-			param.options.forEach(function(option) {
-				var result = this.applyPluginsBailResult("call require.resolve(Weak):item", expr, option, weak);
+	apply(parser) {
+		const options = this.options;
+		parser.plugin("call require.resolve", (expr) => {
+			return parser.applyPluginsBailResult("call require.resolve(Weak)", expr, false);
+		});
+		parser.plugin("call require.resolveWeak", (expr) => {
+			return parser.applyPluginsBailResult("call require.resolve(Weak)", expr, true);
+		});
+		parser.plugin("call require.resolve(Weak)", (expr, weak) => {
+			if(expr.arguments.length !== 1) return;
+			const param = parser.evaluateExpression(expr.arguments[0]);
+			let dep;
+			if(param.isConditional()) {
+				param.options.forEach((option) => {
+					const result = parser.applyPluginsBailResult("call require.resolve(Weak):item", expr, option, weak);
+					if(result === undefined) {
+						parser.applyPluginsBailResult("call require.resolve(Weak):context", expr, option, weak);
+					}
+				});
+				dep = new RequireResolveHeaderDependency(expr.callee.range);
+				dep.loc = expr.loc;
+				parser.state.current.addDependency(dep);
+				return true;
+			} else {
+				const result = parser.applyPluginsBailResult("call require.resolve(Weak):item", expr, param, weak);
 				if(result === undefined) {
-					this.applyPluginsBailResult("call require.resolve(Weak):context", expr, option, weak);
+					parser.applyPluginsBailResult("call require.resolve(Weak):context", expr, param, weak);
 				}
-			}, this);
-			dep = new RequireResolveHeaderDependency(expr.callee.range);
-			dep.loc = expr.loc;
-			this.state.current.addDependency(dep);
-			return true;
-		} else {
-			var result = this.applyPluginsBailResult("call require.resolve(Weak):item", expr, param, weak);
-			if(result === undefined) {
-				this.applyPluginsBailResult("call require.resolve(Weak):context", expr, param, weak);
+				dep = new RequireResolveHeaderDependency(expr.callee.range);
+				dep.loc = expr.loc;
+				parser.state.current.addDependency(dep);
+				return true;
 			}
-			dep = new RequireResolveHeaderDependency(expr.callee.range);
-			dep.loc = expr.loc;
-			this.state.current.addDependency(dep);
-			return true;
-		}
-	});
-	parser.plugin("call require.resolve(Weak):item", function(expr, param, weak) {
-		if(param.isString()) {
-			var dep = new RequireResolveDependency(param.string, param.range);
+		});
+		parser.plugin("call require.resolve(Weak):item", (expr, param, weak) => {
+			if(param.isString()) {
+				const dep = new RequireResolveDependency(param.string, param.range);
+				dep.loc = expr.loc;
+				dep.optional = !!parser.scope.inTry;
+				dep.weak = weak;
+				parser.state.current.addDependency(dep);
+				return true;
+			}
+		});
+		parser.plugin("call require.resolve(Weak):context", (expr, param, weak) => {
+			const dep = ContextDependencyHelpers.create(RequireResolveContextDependency, param.range, param, expr, options);
+			if(!dep) return;
 			dep.loc = expr.loc;
-			dep.optional = !!this.scope.inTry;
+			dep.optional = !!parser.scope.inTry;
 			dep.weak = weak;
-			this.state.current.addDependency(dep);
+			parser.state.current.addDependency(dep);
 			return true;
-		}
-	});
-	parser.plugin("call require.resolve(Weak):context", function(expr, param, weak) {
-		var dep = ContextDependencyHelpers.create(RequireResolveContextDependency, param.range, param, expr, options);
-		if(!dep) return;
-		dep.loc = expr.loc;
-		dep.optional = !!this.scope.inTry;
-		dep.weak = weak;
-		this.state.current.addDependency(dep);
-		return true;
-	});
-};
+		});
+	}
+}
+module.exports = RequireResolveDependencyParserPlugin;

package/lib/dependencies/SystemPlugin.js

@@ -2,43 +2,41 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-var ConstDependency = require("./ConstDependency");
-var ParserHelpers = require("../ParserHelpers");
+"use strict";
 
-function SystemPlugin(options) {
-	this.options = options;
-}
-module.exports = SystemPlugin;
+const ParserHelpers = require("../ParserHelpers");
+
+class SystemPlugin {
+	constructor(options) {
+		this.options = options;
+	}
+
+	apply(compiler) {
+		compiler.plugin("compilation", (compilation, params) => {
+			params.normalModuleFactory.plugin("parser", (parser, parserOptions) => {
+
+				if(typeof parserOptions.system !== "undefined" && !parserOptions.system)
+					return;
 
-SystemPlugin.prototype.apply = function(compiler) {
-	compiler.plugin("compilation", function(compilation, params) {
-		params.normalModuleFactory.plugin("parser", function(parser, parserOptions) {
-
-			if(typeof parserOptions.system !== "undefined" && !parserOptions.system)
-				return;
-
-			function setNotSupported(name) {
-				parser.plugin("evaluate typeof " + name, ParserHelpers.evaluateToString("undefined"));
-				parser.plugin("expression " + name,
-					ParserHelpers.expressionIsUnsupported(name + " is not supported by webpack.")
-				);
-			}
-
-			parser.plugin("typeof System", ParserHelpers.toConstantDependency("object"));
-			parser.plugin("evaluate typeof System", ParserHelpers.evaluateToString("object"));
-
-			parser.plugin("typeof System.import", ParserHelpers.toConstantDependency("function"));
-			parser.plugin("evaluate typeof System.import", ParserHelpers.evaluateToString("function"));
-
-			setNotSupported("System.set");
-			setNotSupported("System.get");
-			setNotSupported("System.register");
-			parser.plugin("expression System", function(expr) {
-				var dep = new ConstDependency("{}", expr.range);
-				dep.loc = expr.loc;
-				this.state.current.addDependency(dep);
-				return true;
+				function setNotSupported(name) {
+					parser.plugin("evaluate typeof " + name, ParserHelpers.evaluateToString("undefined"));
+					parser.plugin("expression " + name,
+						ParserHelpers.expressionIsUnsupported(name + " is not supported by webpack.")
+					);
+				}
+
+				parser.plugin("typeof System", ParserHelpers.toConstantDependency(JSON.stringify("object")));
+				parser.plugin("evaluate typeof System", ParserHelpers.evaluateToString("object"));
+
+				parser.plugin("typeof System.import", ParserHelpers.toConstantDependency(JSON.stringify("function")));
+				parser.plugin("evaluate typeof System.import", ParserHelpers.evaluateToString("function"));
+
+				setNotSupported("System.set");
+				setNotSupported("System.get");
+				setNotSupported("System.register");
+				parser.plugin("expression System", ParserHelpers.toConstantDependency("{}"));
 			});
 		});
-	});
-};
+	}
+}
+module.exports = SystemPlugin;

package/lib/dependencies/WebpackMissingModule.js

@@ -2,30 +2,22 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-exports.module = function(request) {
-	return "!(function webpackMissingModule() { " +
-		exports.moduleCode(request) +
-		" }())";
-};
+"use strict";
+const toErrorCode = err => `var e = new Error(${JSON.stringify(err)}); e.code = 'MODULE_NOT_FOUND';`;
+
+exports.module = request => `!(function webpackMissingModule() { ${exports.moduleCode(request)} }())`;
 
 exports.promise = function(request) {
-	return "Promise.reject(function webpackMissingModule() { " +
-		"var e = new Error(" + JSON.stringify("Cannot find module \"" + request + "\"") + "); " +
-		"e.code = 'MODULE_NOT_FOUND'; " +
-		"return e; " +
-		"}())";
+	const errorCode = toErrorCode(`Cannot find module "${request}"`);
+	return `Promise.reject(function webpackMissingModule() { ${errorCode}; return e; }())`;
 };
 
 exports.moduleCode = function(request) {
-	return "var e = new Error(" + JSON.stringify("Cannot find module \"" + request + "\"") + "); " +
-		"e.code = 'MODULE_NOT_FOUND'; " +
-		"throw e;";
+	const errorCode = toErrorCode(`Cannot find module "${request}"`);
+	return `${errorCode}; throw e;`;
 };
 
 exports.moduleMetaInfo = function(request) {
-	return "!(function webpackMissingModuleMetaInfo() { " +
-		"var e = new Error(" + JSON.stringify("Module cannot be imported because no meta info about exports is available \"" + request + "\"") + "); " +
-		"e.code = 'MODULE_NOT_FOUND'; " +
-		"throw e; " +
-		"}())";
+	const errorCode = toErrorCode(`Module cannot be imported because no meta info about exports is available "${request}"`);
+	return `!(function webpackMissingModuleMetaInfo() { ${errorCode}; throw e; }())`;
 };

package/lib/node/NodeTargetPlugin.js

@@ -2,11 +2,14 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-var ExternalsPlugin = require("../ExternalsPlugin");
+"use strict";
 
-function NodeTargetPlugin() {}
+const ExternalsPlugin = require("../ExternalsPlugin");
+
+class NodeTargetPlugin {
+	apply(compiler) {
+		new ExternalsPlugin("commonjs", Object.keys(process.binding("natives"))).apply(compiler);
+	}
+}
 
 module.exports = NodeTargetPlugin;
-NodeTargetPlugin.prototype.apply = function(compiler) {
-	new ExternalsPlugin("commonjs", Object.keys(process.binding("natives"))).apply(compiler);
-};