webpack 3.6.0 → 3.8.1

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;

package/lib/dependencies/ImportWeakContextDependency.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 ImportWeakContextDependency extends ImportContextDependency {
-	constructor(request, recursive, regExp, range, valueRange, chunkName) {
-		super(request, recursive, regExp, range, valueRange, chunkName);
-		this.async = "async-weak";
-	}
-
-	get type() {
-		return "import() context weak";
-	}
-}
-
-ImportWeakContextDependency.Template = ContextDependencyTemplateAsRequireCall;
-
-module.exports = ImportWeakContextDependency;
+/*
+	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 ImportWeakContextDependency extends ImportContextDependency {
+	constructor(request, recursive, regExp, range, valueRange, chunkName) {
+		super(request, recursive, regExp, range, valueRange, chunkName);
+		this.async = "async-weak";
+	}
+
+	get type() {
+		return "import() context weak";
+	}
+}
+
+ImportWeakContextDependency.Template = ContextDependencyTemplateAsRequireCall;
+
+module.exports = ImportWeakContextDependency;

package/lib/dependencies/LoaderDependency.js

@@ -1,18 +1,18 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-const ModuleDependency = require("./ModuleDependency");
-
-class LoaderDependency extends ModuleDependency {
-	constructor(request) {
-		super(request);
-	}
-
-	get type() {
-		return "loader";
-	}
-}
-
-module.exports = LoaderDependency;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const ModuleDependency = require("./ModuleDependency");
+
+class LoaderDependency extends ModuleDependency {
+	constructor(request) {
+		super(request);
+	}
+
+	get type() {
+		return "loader";
+	}
+}
+
+module.exports = LoaderDependency;

package/lib/dependencies/LoaderPlugin.js

@@ -1,60 +1,60 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const LoaderDependency = require("./LoaderDependency");
-
-class LoaderPlugin {
-
-	apply(compiler) {
-		compiler.plugin("compilation", (compilation, params) => {
-			const normalModuleFactory = params.normalModuleFactory;
-
-			compilation.dependencyFactories.set(LoaderDependency, normalModuleFactory);
-		});
-		compiler.plugin("compilation", (compilation) => {
-			compilation.plugin("normal-module-loader", (loaderContext, module) => {
-				loaderContext.loadModule = function loadModule(request, callback) {
-					const dep = new LoaderDependency(request);
-					dep.loc = request;
-					compilation.addModuleDependencies(module, [
-						[dep]
-					], true, "lm", false, (err) => {
-						if(err) return callback(err);
-
-						if(!dep.module) return callback(new Error("Cannot load the module"));
-						if(dep.module.building) dep.module.building.push(next);
-						else next();
-
-						function next(err) {
-							if(err) return callback(err);
-
-							if(dep.module.error) return callback(dep.module.error);
-							if(!dep.module._source) throw new Error("The module created for a LoaderDependency must have a property _source");
-							let source, map;
-							const moduleSource = dep.module._source;
-							if(moduleSource.sourceAndMap) {
-								const sourceAndMap = moduleSource.sourceAndMap();
-								map = sourceAndMap.map;
-								source = sourceAndMap.source;
-							} else {
-								map = moduleSource.map();
-								source = moduleSource.source();
-							}
-							if(dep.module.fileDependencies) {
-								dep.module.fileDependencies.forEach((dep) => loaderContext.addDependency(dep));
-							}
-							if(dep.module.contextDependencies) {
-								dep.module.contextDependencies.forEach((dep) => loaderContext.addContextDependency(dep));
-							}
-							return callback(null, source, map, dep.module);
-						}
-					});
-				};
-			});
-		});
-	}
-}
-module.exports = LoaderPlugin;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const LoaderDependency = require("./LoaderDependency");
+
+class LoaderPlugin {
+
+	apply(compiler) {
+		compiler.plugin("compilation", (compilation, params) => {
+			const normalModuleFactory = params.normalModuleFactory;
+
+			compilation.dependencyFactories.set(LoaderDependency, normalModuleFactory);
+		});
+		compiler.plugin("compilation", (compilation) => {
+			compilation.plugin("normal-module-loader", (loaderContext, module) => {
+				loaderContext.loadModule = function loadModule(request, callback) {
+					const dep = new LoaderDependency(request);
+					dep.loc = request;
+					compilation.addModuleDependencies(module, [
+						[dep]
+					], true, "lm", false, (err) => {
+						if(err) return callback(err);
+
+						if(!dep.module) return callback(new Error("Cannot load the module"));
+						if(dep.module.building) dep.module.building.push(next);
+						else next();
+
+						function next(err) {
+							if(err) return callback(err);
+
+							if(dep.module.error) return callback(dep.module.error);
+							if(!dep.module._source) throw new Error("The module created for a LoaderDependency must have a property _source");
+							let source, map;
+							const moduleSource = dep.module._source;
+							if(moduleSource.sourceAndMap) {
+								const sourceAndMap = moduleSource.sourceAndMap();
+								map = sourceAndMap.map;
+								source = sourceAndMap.source;
+							} else {
+								map = moduleSource.map();
+								source = moduleSource.source();
+							}
+							if(dep.module.fileDependencies) {
+								dep.module.fileDependencies.forEach((dep) => loaderContext.addDependency(dep));
+							}
+							if(dep.module.contextDependencies) {
+								dep.module.contextDependencies.forEach((dep) => loaderContext.addContextDependency(dep));
+							}
+							return callback(null, source, map, dep.module);
+						}
+					});
+				};
+			});
+		});
+	}
+}
+module.exports = LoaderPlugin;

package/lib/dependencies/LocalModule.js

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

package/lib/dependencies/LocalModuleDependency.js

@@ -1,24 +1,24 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-const NullDependency = require("./NullDependency");
-
-class LocalModuleDependency extends NullDependency {
-	constructor(localModule, range) {
-		super();
-		localModule.flagUsed();
-		this.localModule = localModule;
-		this.range = range;
-	}
-}
-
-LocalModuleDependency.Template = class LocalModuleDependencyTemplate {
-	apply(dep, source) {
-		if(!dep.range) return;
-		source.replace(dep.range[0], dep.range[1] - 1, dep.localModule.variableName());
-	}
-};
-
-module.exports = LocalModuleDependency;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const NullDependency = require("./NullDependency");
+
+class LocalModuleDependency extends NullDependency {
+	constructor(localModule, range) {
+		super();
+		localModule.flagUsed();
+		this.localModule = localModule;
+		this.range = range;
+	}
+}
+
+LocalModuleDependency.Template = class LocalModuleDependencyTemplate {
+	apply(dep, source) {
+		if(!dep.range) return;
+		source.replace(dep.range[0], dep.range[1] - 1, dep.localModule.variableName());
+	}
+};
+
+module.exports = LocalModuleDependency;