webpack 2.2.0 → 2.2.1

package/lib/dependencies/CommonJsRequireDependencyParserPlugin.js

@@ -2,90 +2,88 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-var ConstDependency = require("./ConstDependency");
-var CommonJsRequireDependency = require("./CommonJsRequireDependency");
-var CommonJsRequireContextDependency = require("./CommonJsRequireContextDependency");
-var RequireHeaderDependency = require("./RequireHeaderDependency");
-var LocalModuleDependency = require("./LocalModuleDependency");
-var ContextDependencyHelpers = require("./ContextDependencyHelpers");
-var LocalModulesHelpers = require("./LocalModulesHelpers");
+"use strict";
 
-function CommonJsRequireDependencyParserPlugin(options) {
-	this.options = options;
-}
+const CommonJsRequireDependency = require("./CommonJsRequireDependency");
+const CommonJsRequireContextDependency = require("./CommonJsRequireContextDependency");
+const RequireHeaderDependency = require("./RequireHeaderDependency");
+const LocalModuleDependency = require("./LocalModuleDependency");
+const ContextDependencyHelpers = require("./ContextDependencyHelpers");
+const LocalModulesHelpers = require("./LocalModulesHelpers");
+const ParserHelpers = require("../ParserHelpers");
 
-module.exports = CommonJsRequireDependencyParserPlugin;
+class CommonJsRequireDependencyParserPlugin {
+	constructor(options) {
+		this.options = options;
+	}
 
-CommonJsRequireDependencyParserPlugin.prototype.apply = function(parser) {
-	var options = this.options;
-	parser.plugin("expression require.cache", function(expr) {
-		var dep = new ConstDependency("__webpack_require__.c", expr.range);
-		dep.loc = expr.loc;
-		this.state.current.addDependency(dep);
-		return true;
-	});
-	parser.plugin("expression require", function(expr) {
-		var dep = new CommonJsRequireContextDependency(options.unknownContextRequest, options.unknownContextRecursive, options.unknownContextRegExp, expr.range);
-		dep.critical = options.unknownContextCritical && "require function is used in a way in which dependencies cannot be statically extracted";
-		dep.loc = expr.loc;
-		dep.optional = !!this.scope.inTry;
-		this.state.current.addDependency(dep);
-		return true;
-	});
-	parser.plugin("call require", function(expr) {
-		if(expr.arguments.length !== 1) return;
-		var localModule, dep;
-		var param = this.evaluateExpression(expr.arguments[0]);
-		if(param.isConditional()) {
-			var isExpression = false;
-			var prevLength = this.state.current.dependencies.length;
-			dep = new RequireHeaderDependency(expr.callee.range);
+	apply(parser) {
+		const options = this.options;
+		parser.plugin("expression require.cache", ParserHelpers.toConstantDependency("__webpack_require__.c"));
+		parser.plugin("expression require", (expr) => {
+			const dep = new CommonJsRequireContextDependency(options.unknownContextRequest, options.unknownContextRecursive, options.unknownContextRegExp, expr.range);
+			dep.critical = options.unknownContextCritical && "require function is used in a way in which dependencies cannot be statically extracted";
 			dep.loc = expr.loc;
-			this.state.current.addDependency(dep);
-			param.options.forEach(function(param) {
-				var result = this.applyPluginsBailResult("call require:commonjs:item", expr, param);
-				if(result === undefined) {
-					isExpression = true;
+			dep.optional = !!parser.scope.inTry;
+			parser.state.current.addDependency(dep);
+			return true;
+		});
+		parser.plugin("call require", (expr) => {
+			if(expr.arguments.length !== 1) return;
+			let localModule, dep;
+			const param = parser.evaluateExpression(expr.arguments[0]);
+			if(param.isConditional()) {
+				let isExpression = false;
+				const prevLength = parser.state.current.dependencies.length;
+				dep = new RequireHeaderDependency(expr.callee.range);
+				dep.loc = expr.loc;
+				parser.state.current.addDependency(dep);
+				param.options.forEach(function(param) {
+					const result = parser.applyPluginsBailResult("call require:commonjs:item", expr, param);
+					if(result === undefined) {
+						isExpression = true;
+					}
+				});
+				if(isExpression) {
+					parser.state.current.dependencies.length = prevLength;
+				} else {
+					return true;
 				}
-			}, this);
-			if(isExpression) {
-				this.state.current.dependencies.length = prevLength;
+			}
+			if(param.isString() && (localModule = LocalModulesHelpers.getLocalModule(parser.state, param.string))) {
+				dep = new LocalModuleDependency(localModule, expr.range);
+				dep.loc = expr.loc;
+				parser.state.current.addDependency(dep);
+				return true;
 			} else {
+				const result = parser.applyPluginsBailResult("call require:commonjs:item", expr, param);
+				if(result === undefined) {
+					parser.applyPluginsBailResult("call require:commonjs:context", expr, param);
+				} else {
+					dep = new RequireHeaderDependency(expr.callee.range);
+					dep.loc = expr.loc;
+					parser.state.current.addDependency(dep);
+				}
 				return true;
 			}
-		}
-		if(param.isString() && (localModule = LocalModulesHelpers.getLocalModule(this.state, param.string))) {
-			dep = new LocalModuleDependency(localModule, expr.range);
-			dep.loc = expr.loc;
-			this.state.current.addDependency(dep);
-			return true;
-		} else {
-			var result = this.applyPluginsBailResult("call require:commonjs:item", expr, param);
-			if(result === undefined) {
-				this.applyPluginsBailResult("call require:commonjs:context", expr, param);
-			} else {
-				dep = new RequireHeaderDependency(expr.callee.range);
+		});
+		parser.plugin("call require:commonjs:item", (expr, param) => {
+			if(param.isString()) {
+				const dep = new CommonJsRequireDependency(param.string, param.range);
 				dep.loc = expr.loc;
-				this.state.current.addDependency(dep);
+				dep.optional = !!parser.scope.inTry;
+				parser.state.current.addDependency(dep);
+				return true;
 			}
-			return true;
-		}
-	});
-	parser.plugin("call require:commonjs:item", function(expr, param) {
-		if(param.isString()) {
-			var dep = new CommonJsRequireDependency(param.string, param.range);
+		});
+		parser.plugin("call require:commonjs:context", (expr, param) => {
+			const dep = ContextDependencyHelpers.create(CommonJsRequireContextDependency, expr.range, param, expr, options);
+			if(!dep) return;
 			dep.loc = expr.loc;
-			dep.optional = !!this.scope.inTry;
-			this.state.current.addDependency(dep);
+			dep.optional = !!parser.scope.inTry;
+			parser.state.current.addDependency(dep);
 			return true;
-		}
-	});
-	parser.plugin("call require:commonjs:context", function(expr, param) {
-		var dep = ContextDependencyHelpers.create(CommonJsRequireContextDependency, expr.range, param, expr, options);
-		if(!dep) return;
-		dep.loc = expr.loc;
-		dep.optional = !!this.scope.inTry;
-		this.state.current.addDependency(dep);
-		return true;
-	});
-};
+		});
+	}
+}
+module.exports = CommonJsRequireDependencyParserPlugin;

package/lib/dependencies/ContextDependencyTemplateAsId.js

@@ -2,27 +2,30 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-function ContextDependencyTemplateAsId() {}
-module.exports = ContextDependencyTemplateAsId;
+"use strict";
+
+class ContextDependencyTemplateAsId {
 
-ContextDependencyTemplateAsId.prototype.apply = function(dep, source, outputOptions, requestShortener) {
-	var comment = "";
-	if(outputOptions.pathinfo) comment = "/*! " + requestShortener.shorten(dep.request) + " */ ";
-	if(dep.module && dep.module.dependencies && dep.module.dependencies.length > 0) {
-		if(dep.valueRange) {
-			if(Array.isArray(dep.replaces)) {
-				for(var i = 0; i < dep.replaces.length; i++) {
-					var rep = dep.replaces[i];
-					source.replace(rep.range[0], rep.range[1] - 1, rep.value);
+	apply(dep, source, outputOptions, requestShortener) {
+		let comment = "";
+		if(outputOptions.pathinfo) comment = "/*! " + requestShortener.shorten(dep.request) + " */ ";
+		if(dep.module && dep.module.dependencies && dep.module.dependencies.length > 0) {
+			if(dep.valueRange) {
+				if(Array.isArray(dep.replaces)) {
+					for(let i = 0; i < dep.replaces.length; i++) {
+						const rep = dep.replaces[i];
+						source.replace(rep.range[0], rep.range[1] - 1, rep.value);
+					}
 				}
+				source.replace(dep.valueRange[1], dep.range[1] - 1, ")");
+				source.replace(dep.range[0], dep.valueRange[0] - 1, "__webpack_require__(" + comment + JSON.stringify(dep.module.id) + ").resolve(" + (typeof dep.prepend === "string" ? JSON.stringify(dep.prepend) : "") + "");
+			} else {
+				source.replace(dep.range[0], dep.range[1] - 1, "__webpack_require__(" + comment + JSON.stringify(dep.module.id) + ").resolve");
 			}
-			source.replace(dep.valueRange[1], dep.range[1] - 1, ")");
-			source.replace(dep.range[0], dep.valueRange[0] - 1, "__webpack_require__(" + comment + JSON.stringify(dep.module.id) + ").resolve(" + (typeof dep.prepend === "string" ? JSON.stringify(dep.prepend) : "") + "");
 		} else {
-			source.replace(dep.range[0], dep.range[1] - 1, "__webpack_require__(" + comment + JSON.stringify(dep.module.id) + ").resolve");
+			const content = require("./WebpackMissingModule").module(dep.request);
+			source.replace(dep.range[0], dep.range[1] - 1, content);
 		}
-	} else {
-		var content = require("./WebpackMissingModule").module(dep.request);
-		source.replace(dep.range[0], dep.range[1] - 1, content);
 	}
-};
+}
+module.exports = ContextDependencyTemplateAsId;

package/lib/dependencies/ContextDependencyTemplateAsRequireCall.js

@@ -2,38 +2,32 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-function ContextDependencyTemplateAsRequireCall() {}
-module.exports = ContextDependencyTemplateAsRequireCall;
+"use strict";
+
+class ContextDependencyTemplateAsRequireCall {
 
-ContextDependencyTemplateAsRequireCall.prototype.apply = function(dep, source, outputOptions, requestShortener) {
-	var comment = "";
-	if(outputOptions.pathinfo) comment = "/*! " + requestShortener.shorten(dep.request) + " */ ";
-	var containsDeps = dep.module && (dep.module.dependencies && dep.module.dependencies.length > 0);
-	var isAsync = dep.module && dep.module.async;
-	if(dep.module && (isAsync || containsDeps)) {
-		if(dep.valueRange) {
-			if(Array.isArray(dep.replaces)) {
-				for(var i = 0; i < dep.replaces.length; i++) {
-					var rep = dep.replaces[i];
-					source.replace(rep.range[0], rep.range[1] - 1, rep.value);
+	apply(dep, source, outputOptions, requestShortener) {
+		let comment = "";
+		if(outputOptions.pathinfo) comment = "/*! " + requestShortener.shorten(dep.request) + " */ ";
+		const containsDeps = dep.module && dep.module.dependencies && dep.module.dependencies.length > 0;
+		const isAsync = dep.module && dep.module.async;
+		if(dep.module && (isAsync || containsDeps)) {
+			if(dep.valueRange) {
+				if(Array.isArray(dep.replaces)) {
+					for(let i = 0; i < dep.replaces.length; i++) {
+						const rep = dep.replaces[i];
+						source.replace(rep.range[0], rep.range[1] - 1, rep.value);
+					}
 				}
+				source.replace(dep.valueRange[1], dep.range[1] - 1, ")");
+				source.replace(dep.range[0], dep.valueRange[0] - 1, "__webpack_require__(" + comment + JSON.stringify(dep.module.id) + ")(" + (typeof dep.prepend === "string" ? JSON.stringify(dep.prepend) : "") + "");
+			} else {
+				source.replace(dep.range[0], dep.range[1] - 1, "__webpack_require__(" + comment + JSON.stringify(dep.module.id) + ")");
 			}
-			source.replace(dep.valueRange[1], dep.range[1] - 1, ")");
-			source.replace(dep.range[0], dep.valueRange[0] - 1, "__webpack_require__(" + comment + JSON.stringify(dep.module.id) + ")(" + (typeof dep.prepend === "string" ? JSON.stringify(dep.prepend) : "") + "");
 		} else {
-			source.replace(dep.range[0], dep.range[1] - 1, "__webpack_require__(" + comment + JSON.stringify(dep.module.id) + ")");
+			const content = require("./WebpackMissingModule").module(dep.request);
+			source.replace(dep.range[0], dep.range[1] - 1, content);
 		}
-	} else {
-		var content = require("./WebpackMissingModule").module(dep.request);
-		source.replace(dep.range[0], dep.range[1] - 1, content);
 	}
-};
-
-ContextDependencyTemplateAsRequireCall.prototype.applyAsTemplateArgument = function(name, dep, source) {
-	if(dep.valueRange) {
-		source.replace(dep.valueRange[1], dep.range[1] - 1, ")");
-		source.replace(dep.range[0], dep.valueRange[0] - 1, "__webpack_require__(" + name + ")(" + (typeof dep.prepend === "string" ? JSON.stringify(dep.prepend) : "") + "");
-	} else {
-		source.replace(dep.range[0], dep.range[1] - 1, "__webpack_require__(" + name + ")");
-	}
-};
+}
+module.exports = ContextDependencyTemplateAsRequireCall;

package/lib/dependencies/CriticalDependencyWarning.js

@@ -2,13 +2,18 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-function CriticalDependencyWarning(message) {
-	Error.call(this);
-	Error.captureStackTrace(this, CriticalDependencyWarning);
-	this.name = "CriticalDependencyWarning";
-	this.message = "Critical dependency: " + message;
+"use strict";
+
+class CriticalDependencyWarning extends Error {
+
+	constructor(message) {
+		super();
+		if(Error.hasOwnProperty("captureStackTrace")) {
+			Error.captureStackTrace(this, this.constructor);
+		}
+		this.name = "CriticalDependencyWarning";
+		this.message = "Critical dependency: " + message;
+	}
 }
-module.exports = CriticalDependencyWarning;
 
-CriticalDependencyWarning.prototype = Object.create(Error.prototype);
-CriticalDependencyWarning.prototype.constructor = CriticalDependencyWarning;
+module.exports = CriticalDependencyWarning;

package/lib/dependencies/{HarmonyCompatiblilityDependency.js → HarmonyCompatibilityDependency.js}

@@ -5,7 +5,7 @@
 "use strict";
 const NullDependency = require("./NullDependency");
 
-class HarmonyCompatiblilityDependency extends NullDependency {
+class HarmonyCompatibilityDependency extends NullDependency {
 	constructor(originModule) {
 		super();
 		this.originModule = originModule;
@@ -16,7 +16,7 @@ class HarmonyCompatiblilityDependency extends NullDependency {
 	}
 }
 
-HarmonyCompatiblilityDependency.Template = class HarmonyExportDependencyTemplate {
+HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate {
 	apply(dep, source) {
 		const usedExports = dep.originModule.usedExports;
 		if(usedExports && !Array.isArray(usedExports)) {
@@ -27,4 +27,4 @@ HarmonyCompatiblilityDependency.Template = class HarmonyExportDependencyTemplate
 	}
 };
 
-module.exports = HarmonyCompatiblilityDependency;
+module.exports = HarmonyCompatibilityDependency;

package/lib/dependencies/HarmonyDetectionParserPlugin.js

@@ -4,7 +4,7 @@
 */
 "use strict";
 
-const HarmonyCompatiblilityDependency = require("./HarmonyCompatiblilityDependency");
+const HarmonyCompatibilityDependency = require("./HarmonyCompatibilityDependency");
 
 module.exports = class HarmonyDetectionParserPlugin {
 	apply(parser) {
@@ -14,7 +14,7 @@ module.exports = class HarmonyDetectionParserPlugin {
 			});
 			if(isHarmony) {
 				let module = parser.state.module;
-				const dep = new HarmonyCompatiblilityDependency(module);
+				const dep = new HarmonyCompatibilityDependency(module);
 				dep.loc = {
 					start: {
 						line: -1,

package/lib/dependencies/HarmonyModulesPlugin.js

@@ -2,66 +2,68 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-var HarmonyImportDependency = require("./HarmonyImportDependency");
-var HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
-var HarmonyCompatiblilityDependency = require("./HarmonyCompatiblilityDependency");
-var HarmonyExportHeaderDependency = require("./HarmonyExportHeaderDependency");
-var HarmonyExportExpressionDependency = require("./HarmonyExportExpressionDependency");
-var HarmonyExportSpecifierDependency = require("./HarmonyExportSpecifierDependency");
-var HarmonyExportImportedSpecifierDependency = require("./HarmonyExportImportedSpecifierDependency");
-var HarmonyAcceptDependency = require("./HarmonyAcceptDependency");
-var HarmonyAcceptImportDependency = require("./HarmonyAcceptImportDependency");
-
-var NullFactory = require("../NullFactory");
-
-var HarmonyDetectionParserPlugin = require("./HarmonyDetectionParserPlugin");
-var HarmonyImportDependencyParserPlugin = require("./HarmonyImportDependencyParserPlugin");
-var HarmonyExportDependencyParserPlugin = require("./HarmonyExportDependencyParserPlugin");
-
-function HarmonyModulesPlugin() {}
-module.exports = HarmonyModulesPlugin;
+"use strict";
+const HarmonyImportDependency = require("./HarmonyImportDependency");
+const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
+const HarmonyCompatiblilityDependency = require("./HarmonyCompatibilityDependency");
+const HarmonyExportHeaderDependency = require("./HarmonyExportHeaderDependency");
+const HarmonyExportExpressionDependency = require("./HarmonyExportExpressionDependency");
+const HarmonyExportSpecifierDependency = require("./HarmonyExportSpecifierDependency");
+const HarmonyExportImportedSpecifierDependency = require("./HarmonyExportImportedSpecifierDependency");
+const HarmonyAcceptDependency = require("./HarmonyAcceptDependency");
+const HarmonyAcceptImportDependency = require("./HarmonyAcceptImportDependency");
+
+const NullFactory = require("../NullFactory");
+
+const HarmonyDetectionParserPlugin = require("./HarmonyDetectionParserPlugin");
+const HarmonyImportDependencyParserPlugin = require("./HarmonyImportDependencyParserPlugin");
+const HarmonyExportDependencyParserPlugin = require("./HarmonyExportDependencyParserPlugin");
 
-HarmonyModulesPlugin.prototype.apply = function(compiler) {
-	compiler.plugin("compilation", function(compilation, params) {
-		var normalModuleFactory = params.normalModuleFactory;
+class HarmonyModulesPlugin {
 
-		compilation.dependencyFactories.set(HarmonyImportDependency, normalModuleFactory);
-		compilation.dependencyTemplates.set(HarmonyImportDependency, new HarmonyImportDependency.Template());
+	apply(compiler) {
+		compiler.plugin("compilation", (compilation, params) => {
+			const normalModuleFactory = params.normalModuleFactory;
 
-		compilation.dependencyFactories.set(HarmonyImportSpecifierDependency, new NullFactory());
-		compilation.dependencyTemplates.set(HarmonyImportSpecifierDependency, new HarmonyImportSpecifierDependency.Template());
+			compilation.dependencyFactories.set(HarmonyImportDependency, normalModuleFactory);
+			compilation.dependencyTemplates.set(HarmonyImportDependency, new HarmonyImportDependency.Template());
 
-		compilation.dependencyFactories.set(HarmonyCompatiblilityDependency, new NullFactory());
-		compilation.dependencyTemplates.set(HarmonyCompatiblilityDependency, new HarmonyCompatiblilityDependency.Template());
+			compilation.dependencyFactories.set(HarmonyImportSpecifierDependency, new NullFactory());
+			compilation.dependencyTemplates.set(HarmonyImportSpecifierDependency, new HarmonyImportSpecifierDependency.Template());
 
-		compilation.dependencyFactories.set(HarmonyExportHeaderDependency, new NullFactory());
-		compilation.dependencyTemplates.set(HarmonyExportHeaderDependency, new HarmonyExportHeaderDependency.Template());
+			compilation.dependencyFactories.set(HarmonyCompatiblilityDependency, new NullFactory());
+			compilation.dependencyTemplates.set(HarmonyCompatiblilityDependency, new HarmonyCompatiblilityDependency.Template());
 
-		compilation.dependencyFactories.set(HarmonyExportExpressionDependency, new NullFactory());
-		compilation.dependencyTemplates.set(HarmonyExportExpressionDependency, new HarmonyExportExpressionDependency.Template());
+			compilation.dependencyFactories.set(HarmonyExportHeaderDependency, new NullFactory());
+			compilation.dependencyTemplates.set(HarmonyExportHeaderDependency, new HarmonyExportHeaderDependency.Template());
 
-		compilation.dependencyFactories.set(HarmonyExportSpecifierDependency, new NullFactory());
-		compilation.dependencyTemplates.set(HarmonyExportSpecifierDependency, new HarmonyExportSpecifierDependency.Template());
+			compilation.dependencyFactories.set(HarmonyExportExpressionDependency, new NullFactory());
+			compilation.dependencyTemplates.set(HarmonyExportExpressionDependency, new HarmonyExportExpressionDependency.Template());
 
-		compilation.dependencyFactories.set(HarmonyExportImportedSpecifierDependency, new NullFactory());
-		compilation.dependencyTemplates.set(HarmonyExportImportedSpecifierDependency, new HarmonyExportImportedSpecifierDependency.Template());
+			compilation.dependencyFactories.set(HarmonyExportSpecifierDependency, new NullFactory());
+			compilation.dependencyTemplates.set(HarmonyExportSpecifierDependency, new HarmonyExportSpecifierDependency.Template());
 
-		compilation.dependencyFactories.set(HarmonyAcceptDependency, new NullFactory());
-		compilation.dependencyTemplates.set(HarmonyAcceptDependency, new HarmonyAcceptDependency.Template());
+			compilation.dependencyFactories.set(HarmonyExportImportedSpecifierDependency, new NullFactory());
+			compilation.dependencyTemplates.set(HarmonyExportImportedSpecifierDependency, new HarmonyExportImportedSpecifierDependency.Template());
 
-		compilation.dependencyFactories.set(HarmonyAcceptImportDependency, normalModuleFactory);
-		compilation.dependencyTemplates.set(HarmonyAcceptImportDependency, new HarmonyAcceptImportDependency.Template());
+			compilation.dependencyFactories.set(HarmonyAcceptDependency, new NullFactory());
+			compilation.dependencyTemplates.set(HarmonyAcceptDependency, new HarmonyAcceptDependency.Template());
 
-		params.normalModuleFactory.plugin("parser", function(parser, parserOptions) {
+			compilation.dependencyFactories.set(HarmonyAcceptImportDependency, normalModuleFactory);
+			compilation.dependencyTemplates.set(HarmonyAcceptImportDependency, new HarmonyAcceptImportDependency.Template());
 
-			if(typeof parserOptions.harmony !== "undefined" && !parserOptions.harmony)
-				return;
+			params.normalModuleFactory.plugin("parser", (parser, parserOptions) => {
 
-			parser.apply(
-				new HarmonyDetectionParserPlugin(),
-				new HarmonyImportDependencyParserPlugin(),
-				new HarmonyExportDependencyParserPlugin()
-			);
+				if(typeof parserOptions.harmony !== "undefined" && !parserOptions.harmony)
+					return;
+
+				parser.apply(
+					new HarmonyDetectionParserPlugin(),
+					new HarmonyImportDependencyParserPlugin(),
+					new HarmonyExportDependencyParserPlugin()
+				);
+			});
 		});
-	});
-};
+	}
+}
+module.exports = HarmonyModulesPlugin;

package/lib/dependencies/ImportParserPlugin.js

@@ -2,34 +2,37 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-var ImportContextDependency = require("./ImportContextDependency");
-var ImportDependenciesBlock = require("./ImportDependenciesBlock");
-var ContextDependencyHelpers = require("./ContextDependencyHelpers");
+"use strict";
 
-function ImportParserPlugin(options) {
-	this.options = options;
-}
+const ImportContextDependency = require("./ImportContextDependency");
+const ImportDependenciesBlock = require("./ImportDependenciesBlock");
+const ContextDependencyHelpers = require("./ContextDependencyHelpers");
 
-module.exports = ImportParserPlugin;
+class ImportParserPlugin {
+	constructor(options) {
+		this.options = options;
+	}
 
-ImportParserPlugin.prototype.apply = function(parser) {
-	var options = this.options;
-	parser.plugin(["call System.import", "import-call"], function(expr) {
-		if(expr.arguments.length !== 1)
-			throw new Error("Incorrect number of arguments provided to 'import(module: string) -> Promise'.");
-		var dep;
-		var param = this.evaluateExpression(expr.arguments[0]);
-		if(param.isString()) {
-			var depBlock = new ImportDependenciesBlock(param.string, expr.range, this.state.module, expr.loc);
-			this.state.current.addBlock(depBlock);
-			return true;
-		} else {
-			dep = ContextDependencyHelpers.create(ImportContextDependency, expr.range, param, expr, options);
-			if(!dep) return;
-			dep.loc = expr.loc;
-			dep.optional = !!this.scope.inTry;
-			this.state.current.addDependency(dep);
-			return true;
-		}
-	});
-};
+	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'.");
+			let dep;
+			const param = parser.evaluateExpression(expr.arguments[0]);
+			if(param.isString()) {
+				const depBlock = new ImportDependenciesBlock(param.string, expr.range, parser.state.module, expr.loc);
+				parser.state.current.addBlock(depBlock);
+				return true;
+			} else {
+				dep = ContextDependencyHelpers.create(ImportContextDependency, expr.range, param, expr, options);
+				if(!dep) return;
+				dep.loc = expr.loc;
+				dep.optional = !!parser.scope.inTry;
+				parser.state.current.addDependency(dep);
+				return true;
+			}
+		});
+	}
+}
+module.exports = ImportParserPlugin;

package/lib/dependencies/ImportPlugin.js

@@ -2,35 +2,39 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-var ImportDependency = require("./ImportDependency");
-var ImportContextDependency = require("./ImportContextDependency");
-var ImportParserPlugin = require("./ImportParserPlugin");
+"use strict";
 
-function ImportPlugin(options) {
-	this.options = options;
-}
-module.exports = ImportPlugin;
+const ImportDependency = require("./ImportDependency");
+const ImportContextDependency = require("./ImportContextDependency");
+const ImportParserPlugin = require("./ImportParserPlugin");
+
+class ImportPlugin {
+	constructor(options) {
+		this.options = options;
+	}
 
-ImportPlugin.prototype.apply = function(compiler) {
-	var options = this.options;
-	compiler.plugin("compilation", function(compilation, params) {
-		var normalModuleFactory = params.normalModuleFactory;
-		var contextModuleFactory = params.contextModuleFactory;
+	apply(compiler) {
+		const options = this.options;
+		compiler.plugin("compilation", (compilation, params) => {
+			const normalModuleFactory = params.normalModuleFactory;
+			const contextModuleFactory = params.contextModuleFactory;
 
-		compilation.dependencyFactories.set(ImportDependency, normalModuleFactory);
-		compilation.dependencyTemplates.set(ImportDependency, new ImportDependency.Template());
+			compilation.dependencyFactories.set(ImportDependency, normalModuleFactory);
+			compilation.dependencyTemplates.set(ImportDependency, new ImportDependency.Template());
 
-		compilation.dependencyFactories.set(ImportContextDependency, contextModuleFactory);
-		compilation.dependencyTemplates.set(ImportContextDependency, new ImportContextDependency.Template());
+			compilation.dependencyFactories.set(ImportContextDependency, contextModuleFactory);
+			compilation.dependencyTemplates.set(ImportContextDependency, new ImportContextDependency.Template());
 
-		params.normalModuleFactory.plugin("parser", function(parser, parserOptions) {
+			params.normalModuleFactory.plugin("parser", (parser, parserOptions) => {
 
-			if(typeof parserOptions.import !== "undefined" && !parserOptions.import)
-				return;
+				if(typeof parserOptions.import !== "undefined" && !parserOptions.import)
+					return;
 
-			parser.apply(
-				new ImportParserPlugin(options)
-			);
+				parser.apply(
+					new ImportParserPlugin(options)
+				);
+			});
 		});
-	});
-};
+	}
+}
+module.exports = ImportPlugin;

package/lib/dependencies/LocalModule.js

@@ -2,18 +2,22 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-function LocalModule(module, name, idx) {
-	this.module = module;
-	this.name = name;
-	this.idx = idx;
-	this.used = false;
-}
-module.exports = LocalModule;
+"use strict";
+
+class LocalModule {
+	constructor(module, name, idx) {
+		this.module = module;
+		this.name = name;
+		this.idx = idx;
+		this.used = false;
+	}
 
-LocalModule.prototype.flagUsed = function() {
-	this.used = true;
-};
+	flagUsed() {
+		this.used = true;
+	}
 
-LocalModule.prototype.variableName = function() {
-	return "__WEBPACK_LOCAL_MODULE_" + this.idx + "__";
-};
+	variableName() {
+		return "__WEBPACK_LOCAL_MODULE_" + this.idx + "__";
+	}
+}
+module.exports = LocalModule;