webpack 3.8.1 → 3.11.0

package/lib/dependencies/HarmonyCompatibilityDependency.js

@@ -1,30 +1,30 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-const NullDependency = require("./NullDependency");
-
-class HarmonyCompatibilityDependency extends NullDependency {
-	constructor(originModule) {
-		super();
-		this.originModule = originModule;
-	}
-
-	get type() {
-		return "harmony export header";
-	}
-}
-
-HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate {
-	apply(dep, source) {
-		const usedExports = dep.originModule.usedExports;
-		if(usedExports && !Array.isArray(usedExports)) {
-			const exportName = dep.originModule.exportsArgument || "exports";
-			const content = `Object.defineProperty(${exportName}, "__esModule", { value: true });\n`;
-			source.insert(-10, content);
-		}
-	}
-};
-
-module.exports = HarmonyCompatibilityDependency;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const NullDependency = require("./NullDependency");
+
+class HarmonyCompatibilityDependency extends NullDependency {
+	constructor(originModule) {
+		super();
+		this.originModule = originModule;
+	}
+
+	get type() {
+		return "harmony export header";
+	}
+}
+
+HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate {
+	apply(dep, source) {
+		const usedExports = dep.originModule.usedExports;
+		if(usedExports && !Array.isArray(usedExports)) {
+			const exportName = dep.originModule.exportsArgument || "exports";
+			const content = `Object.defineProperty(${exportName}, "__esModule", { value: true });\n`;
+			source.insert(-10, content);
+		}
+	}
+};
+
+module.exports = HarmonyCompatibilityDependency;

package/lib/dependencies/HarmonyDetectionParserPlugin.js

@@ -9,7 +9,7 @@ const HarmonyCompatibilityDependency = require("./HarmonyCompatibilityDependency
 module.exports = class HarmonyDetectionParserPlugin {
 	apply(parser) {
 		parser.plugin("program", (ast) => {
-			var isHarmony = ast.body.some(statement => {
+			const isHarmony = ast.body.some(statement => {
 				return /^(Import|Export).*Declaration$/.test(statement.type);
 			});
 			if(isHarmony) {
@@ -32,7 +32,7 @@ module.exports = class HarmonyDetectionParserPlugin {
 				module.exportsArgument = "__webpack_exports__";
 			}
 		});
-		var nonHarmonyIdentifiers = ["define", "exports"];
+		const nonHarmonyIdentifiers = ["define", "exports"];
 		nonHarmonyIdentifiers.forEach(identifer => {
 			parser.plugin(`evaluate typeof ${identifer}`, nullInHarmony);
 			parser.plugin(`typeof ${identifer}`, skipInHarmony);

package/lib/dependencies/HarmonyExportHeaderDependency.js

@@ -1,28 +1,28 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-const NullDependency = require("./NullDependency");
-
-class HarmonyExportHeaderDependency extends NullDependency {
-	constructor(range, rangeStatement) {
-		super();
-		this.range = range;
-		this.rangeStatement = rangeStatement;
-	}
-
-	get type() {
-		return "harmony export header";
-	}
-}
-
-HarmonyExportHeaderDependency.Template = class HarmonyExportDependencyTemplate {
-	apply(dep, source) {
-		const content = "";
-		const replaceUntil = dep.range ? dep.range[0] - 1 : dep.rangeStatement[1] - 1;
-		source.replace(dep.rangeStatement[0], replaceUntil, content);
-	}
-};
-
-module.exports = HarmonyExportHeaderDependency;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const NullDependency = require("./NullDependency");
+
+class HarmonyExportHeaderDependency extends NullDependency {
+	constructor(range, rangeStatement) {
+		super();
+		this.range = range;
+		this.rangeStatement = rangeStatement;
+	}
+
+	get type() {
+		return "harmony export header";
+	}
+}
+
+HarmonyExportHeaderDependency.Template = class HarmonyExportDependencyTemplate {
+	apply(dep, source) {
+		const content = "";
+		const replaceUntil = dep.range ? dep.range[0] - 1 : dep.rangeStatement[1] - 1;
+		source.replace(dep.rangeStatement[0], replaceUntil, content);
+	}
+};
+
+module.exports = HarmonyExportHeaderDependency;

package/lib/dependencies/HarmonyImportDependency.js

@@ -3,7 +3,7 @@
 	Author Tobias Koppers @sokra
 */
 "use strict";
-var ModuleDependency = require("./ModuleDependency");
+const ModuleDependency = require("./ModuleDependency");
 
 class HarmonyImportDependency extends ModuleDependency {
 	constructor(request, importedVar, range) {

package/lib/dependencies/ImportDependenciesBlock.js

@@ -1,17 +1,17 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
-const ImportDependency = require("./ImportDependency");
-
-module.exports = class ImportDependenciesBlock extends AsyncDependenciesBlock {
-	constructor(request, range, chunkName, module, loc) {
-		super(chunkName, module, loc);
-		this.range = range;
-		const dep = new ImportDependency(request, 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 ImportDependency = require("./ImportDependency");
+
+module.exports = class ImportDependenciesBlock extends AsyncDependenciesBlock {
+	constructor(request, range, chunkName, module, loc) {
+		super(chunkName, module, loc);
+		this.range = range;
+		const dep = new ImportDependency(request, this);
+		dep.loc = loc;
+		this.addDependency(dep);
+	}
+};

package/lib/dependencies/ImportEagerContextDependency.js

@@ -1,22 +1,22 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-const ImportContextDependency = require("./ImportContextDependency");
-const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
-
-class ImportEagerContextDependency extends ImportContextDependency {
-	constructor(request, recursive, regExp, range, valueRange, chunkName) {
-		super(request, recursive, regExp, range, valueRange, chunkName);
-		this.async = "eager";
-	}
-
-	get type() {
-		return "import() context eager";
-	}
-}
-
-ImportEagerContextDependency.Template = ContextDependencyTemplateAsRequireCall;
-
-module.exports = ImportEagerContextDependency;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const ImportContextDependency = require("./ImportContextDependency");
+const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
+
+class ImportEagerContextDependency extends ImportContextDependency {
+	constructor(request, recursive, regExp, range, valueRange, chunkName) {
+		super(request, recursive, regExp, range, valueRange, chunkName);
+		this.async = "eager";
+	}
+
+	get type() {
+		return "import() context eager";
+	}
+}
+
+ImportEagerContextDependency.Template = ContextDependencyTemplateAsRequireCall;
+
+module.exports = ImportEagerContextDependency;

package/lib/dependencies/ImportLazyContextDependency.js

@@ -1,22 +1,22 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-const ImportContextDependency = require("./ImportContextDependency");
-const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
-
-class ImportLazyContextDependency extends ImportContextDependency {
-	constructor(request, recursive, regExp, range, valueRange, chunkName) {
-		super(request, recursive, regExp, range, valueRange, chunkName);
-		this.async = "lazy";
-	}
-
-	get type() {
-		return "import() context lazy";
-	}
-}
-
-ImportLazyContextDependency.Template = ContextDependencyTemplateAsRequireCall;
-
-module.exports = ImportLazyContextDependency;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const ImportContextDependency = require("./ImportContextDependency");
+const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
+
+class ImportLazyContextDependency extends ImportContextDependency {
+	constructor(request, recursive, regExp, range, valueRange, chunkName) {
+		super(request, recursive, regExp, range, valueRange, chunkName);
+		this.async = "lazy";
+	}
+
+	get type() {
+		return "import() context lazy";
+	}
+}
+
+ImportLazyContextDependency.Template = ContextDependencyTemplateAsRequireCall;
+
+module.exports = ImportLazyContextDependency;

package/lib/dependencies/ImportLazyOnceContextDependency.js

@@ -1,22 +1,22 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-const ImportContextDependency = require("./ImportContextDependency");
-const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
-
-class ImportLazyOnceContextDependency extends ImportContextDependency {
-	constructor(request, recursive, regExp, range, valueRange, chunkName) {
-		super(request, recursive, regExp, range, valueRange, chunkName);
-		this.async = "lazy-once";
-	}
-
-	get type() {
-		return "import() context lazy-once";
-	}
-}
-
-ImportLazyOnceContextDependency.Template = ContextDependencyTemplateAsRequireCall;
-
-module.exports = ImportLazyOnceContextDependency;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const ImportContextDependency = require("./ImportContextDependency");
+const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
+
+class ImportLazyOnceContextDependency extends ImportContextDependency {
+	constructor(request, recursive, regExp, range, valueRange, chunkName) {
+		super(request, recursive, regExp, range, valueRange, chunkName);
+		this.async = "lazy-once";
+	}
+
+	get type() {
+		return "import() context lazy-once";
+	}
+}
+
+ImportLazyOnceContextDependency.Template = ContextDependencyTemplateAsRequireCall;
+
+module.exports = ImportLazyOnceContextDependency;

package/lib/dependencies/ImportParserPlugin.js

@@ -1,89 +1,89 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const ImportEagerContextDependency = require("./ImportEagerContextDependency");
-const ImportWeakDependency = require("./ImportWeakDependency");
-const ImportWeakContextDependency = require("./ImportWeakContextDependency");
-const ImportLazyOnceContextDependency = require("./ImportLazyOnceContextDependency");
-const ImportLazyContextDependency = require("./ImportLazyContextDependency");
-const ImportDependenciesBlock = require("./ImportDependenciesBlock");
-const ImportEagerDependency = require("./ImportEagerDependency");
-const ContextDependencyHelpers = require("./ContextDependencyHelpers");
-const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
-
-class ImportParserPlugin {
-	constructor(options) {
-		this.options = options;
-	}
-
-	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'.");
-
-			const param = parser.evaluateExpression(expr.arguments[0]);
-
-			let chunkName = null;
-			let mode = "lazy";
-
-			const importOptions = parser.getCommentOptions(expr.range);
-			if(importOptions) {
-				if(typeof importOptions.webpackChunkName !== "undefined") {
-					if(typeof importOptions.webpackChunkName !== "string")
-						parser.state.module.warnings.push(new UnsupportedFeatureWarning(parser.state.module, `\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`));
-					else
-						chunkName = importOptions.webpackChunkName;
-				}
-				if(typeof importOptions.webpackMode !== "undefined") {
-					if(typeof importOptions.webpackMode !== "string")
-						parser.state.module.warnings.push(new UnsupportedFeatureWarning(parser.state.module, `\`webpackMode\` expected a string, but received: ${importOptions.webpackMode}.`));
-					else
-						mode = importOptions.webpackMode;
-				}
-			}
-
-			if(param.isString()) {
-				if(mode !== "lazy" && mode !== "eager" && mode !== "weak") {
-					parser.state.module.warnings.push(new UnsupportedFeatureWarning(parser.state.module, `\`webpackMode\` expected 'lazy', 'eager' or 'weak', but received: ${mode}.`));
-				}
-
-				if(mode === "eager") {
-					const dep = new ImportEagerDependency(param.string, expr.range);
-					parser.state.current.addDependency(dep);
-				} else if(mode === "weak") {
-					const dep = new ImportWeakDependency(param.string, expr.range);
-					parser.state.current.addDependency(dep);
-				} else {
-					const depBlock = new ImportDependenciesBlock(param.string, expr.range, chunkName, parser.state.module, expr.loc);
-					parser.state.current.addBlock(depBlock);
-				}
-				return true;
-			} else {
-				if(mode !== "lazy" && mode !== "lazy-once" && mode !== "eager" && mode !== "weak") {
-					parser.state.module.warnings.push(new UnsupportedFeatureWarning(parser.state.module, `\`webpackMode\` expected 'lazy', 'lazy-once', 'eager' or 'weak', but received: ${mode}.`));
-				}
-
-				let Dep = ImportLazyContextDependency;
-				if(mode === "eager") {
-					Dep = ImportEagerContextDependency;
-				} else if(mode === "weak") {
-					Dep = ImportWeakContextDependency;
-				} else if(mode === "lazy-once") {
-					Dep = ImportLazyOnceContextDependency;
-				}
-				const dep = ContextDependencyHelpers.create(Dep, expr.range, param, expr, options, chunkName);
-				if(!dep) return;
-				dep.loc = expr.loc;
-				dep.optional = !!parser.scope.inTry;
-				parser.state.current.addDependency(dep);
-				return true;
-			}
-		});
-	}
-}
-module.exports = ImportParserPlugin;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const ImportEagerContextDependency = require("./ImportEagerContextDependency");
+const ImportWeakDependency = require("./ImportWeakDependency");
+const ImportWeakContextDependency = require("./ImportWeakContextDependency");
+const ImportLazyOnceContextDependency = require("./ImportLazyOnceContextDependency");
+const ImportLazyContextDependency = require("./ImportLazyContextDependency");
+const ImportDependenciesBlock = require("./ImportDependenciesBlock");
+const ImportEagerDependency = require("./ImportEagerDependency");
+const ContextDependencyHelpers = require("./ContextDependencyHelpers");
+const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
+
+class ImportParserPlugin {
+	constructor(options) {
+		this.options = options;
+	}
+
+	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'.");
+
+			const param = parser.evaluateExpression(expr.arguments[0]);
+
+			let chunkName = null;
+			let mode = "lazy";
+
+			const importOptions = parser.getCommentOptions(expr.range);
+			if(importOptions) {
+				if(typeof importOptions.webpackChunkName !== "undefined") {
+					if(typeof importOptions.webpackChunkName !== "string")
+						parser.state.module.warnings.push(new UnsupportedFeatureWarning(parser.state.module, `\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`));
+					else
+						chunkName = importOptions.webpackChunkName;
+				}
+				if(typeof importOptions.webpackMode !== "undefined") {
+					if(typeof importOptions.webpackMode !== "string")
+						parser.state.module.warnings.push(new UnsupportedFeatureWarning(parser.state.module, `\`webpackMode\` expected a string, but received: ${importOptions.webpackMode}.`));
+					else
+						mode = importOptions.webpackMode;
+				}
+			}
+
+			if(param.isString()) {
+				if(mode !== "lazy" && mode !== "eager" && mode !== "weak") {
+					parser.state.module.warnings.push(new UnsupportedFeatureWarning(parser.state.module, `\`webpackMode\` expected 'lazy', 'eager' or 'weak', but received: ${mode}.`));
+				}
+
+				if(mode === "eager") {
+					const dep = new ImportEagerDependency(param.string, expr.range);
+					parser.state.current.addDependency(dep);
+				} else if(mode === "weak") {
+					const dep = new ImportWeakDependency(param.string, expr.range);
+					parser.state.current.addDependency(dep);
+				} else {
+					const depBlock = new ImportDependenciesBlock(param.string, expr.range, chunkName, parser.state.module, expr.loc);
+					parser.state.current.addBlock(depBlock);
+				}
+				return true;
+			} else {
+				if(mode !== "lazy" && mode !== "lazy-once" && mode !== "eager" && mode !== "weak") {
+					parser.state.module.warnings.push(new UnsupportedFeatureWarning(parser.state.module, `\`webpackMode\` expected 'lazy', 'lazy-once', 'eager' or 'weak', but received: ${mode}.`));
+				}
+
+				let Dep = ImportLazyContextDependency;
+				if(mode === "eager") {
+					Dep = ImportEagerContextDependency;
+				} else if(mode === "weak") {
+					Dep = ImportWeakContextDependency;
+				} else if(mode === "lazy-once") {
+					Dep = ImportLazyOnceContextDependency;
+				}
+				const dep = ContextDependencyHelpers.create(Dep, expr.range, param, expr, options, chunkName);
+				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

@@ -1,60 +1,60 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const ImportDependency = require("./ImportDependency");
-const ImportEagerDependency = require("./ImportEagerDependency");
-const ImportWeakDependency = require("./ImportWeakDependency");
-const ImportEagerContextDependency = require("./ImportEagerContextDependency");
-const ImportWeakContextDependency = require("./ImportWeakContextDependency");
-const ImportLazyOnceContextDependency = require("./ImportLazyOnceContextDependency");
-const ImportLazyContextDependency = require("./ImportLazyContextDependency");
-const ImportParserPlugin = require("./ImportParserPlugin");
-
-class ImportPlugin {
-	constructor(options) {
-		this.options = options;
-	}
-
-	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(ImportEagerDependency, normalModuleFactory);
-			compilation.dependencyTemplates.set(ImportEagerDependency, new ImportEagerDependency.Template());
-
-			compilation.dependencyFactories.set(ImportWeakDependency, normalModuleFactory);
-			compilation.dependencyTemplates.set(ImportWeakDependency, new ImportWeakDependency.Template());
-
-			compilation.dependencyFactories.set(ImportEagerContextDependency, contextModuleFactory);
-			compilation.dependencyTemplates.set(ImportEagerContextDependency, new ImportEagerContextDependency.Template());
-
-			compilation.dependencyFactories.set(ImportWeakContextDependency, contextModuleFactory);
-			compilation.dependencyTemplates.set(ImportWeakContextDependency, new ImportWeakContextDependency.Template());
-
-			compilation.dependencyFactories.set(ImportLazyOnceContextDependency, contextModuleFactory);
-			compilation.dependencyTemplates.set(ImportLazyOnceContextDependency, new ImportLazyOnceContextDependency.Template());
-
-			compilation.dependencyFactories.set(ImportLazyContextDependency, contextModuleFactory);
-			compilation.dependencyTemplates.set(ImportLazyContextDependency, new ImportLazyContextDependency.Template());
-
-			normalModuleFactory.plugin("parser", (parser, parserOptions) => {
-
-				if(typeof parserOptions.import !== "undefined" && !parserOptions.import)
-					return;
-
-				parser.apply(
-					new ImportParserPlugin(options)
-				);
-			});
-		});
-	}
-}
-module.exports = ImportPlugin;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const ImportDependency = require("./ImportDependency");
+const ImportEagerDependency = require("./ImportEagerDependency");
+const ImportWeakDependency = require("./ImportWeakDependency");
+const ImportEagerContextDependency = require("./ImportEagerContextDependency");
+const ImportWeakContextDependency = require("./ImportWeakContextDependency");
+const ImportLazyOnceContextDependency = require("./ImportLazyOnceContextDependency");
+const ImportLazyContextDependency = require("./ImportLazyContextDependency");
+const ImportParserPlugin = require("./ImportParserPlugin");
+
+class ImportPlugin {
+	constructor(options) {
+		this.options = options;
+	}
+
+	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(ImportEagerDependency, normalModuleFactory);
+			compilation.dependencyTemplates.set(ImportEagerDependency, new ImportEagerDependency.Template());
+
+			compilation.dependencyFactories.set(ImportWeakDependency, normalModuleFactory);
+			compilation.dependencyTemplates.set(ImportWeakDependency, new ImportWeakDependency.Template());
+
+			compilation.dependencyFactories.set(ImportEagerContextDependency, contextModuleFactory);
+			compilation.dependencyTemplates.set(ImportEagerContextDependency, new ImportEagerContextDependency.Template());
+
+			compilation.dependencyFactories.set(ImportWeakContextDependency, contextModuleFactory);
+			compilation.dependencyTemplates.set(ImportWeakContextDependency, new ImportWeakContextDependency.Template());
+
+			compilation.dependencyFactories.set(ImportLazyOnceContextDependency, contextModuleFactory);
+			compilation.dependencyTemplates.set(ImportLazyOnceContextDependency, new ImportLazyOnceContextDependency.Template());
+
+			compilation.dependencyFactories.set(ImportLazyContextDependency, contextModuleFactory);
+			compilation.dependencyTemplates.set(ImportLazyContextDependency, new ImportLazyContextDependency.Template());
+
+			normalModuleFactory.plugin("parser", (parser, parserOptions) => {
+
+				if(typeof parserOptions.import !== "undefined" && !parserOptions.import)
+					return;
+
+				parser.apply(
+					new ImportParserPlugin(options)
+				);
+			});
+		});
+	}
+}
+module.exports = ImportPlugin;