webpack 4.9.1 → 4.10.2

package/lib/ExternalModuleFactoryPlugin.js

@@ -1,110 +1,110 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const ExternalModule = require("./ExternalModule");
-
-class ExternalModuleFactoryPlugin {
-	constructor(type, externals) {
-		this.type = type;
-		this.externals = externals;
-	}
-
-	apply(normalModuleFactory) {
-		const globalType = this.type;
-		normalModuleFactory.hooks.factory.tap(
-			"ExternalModuleFactoryPlugin",
-			factory => (data, callback) => {
-				const context = data.context;
-				const dependency = data.dependencies[0];
-
-				const handleExternal = (value, type, callback) => {
-					if (typeof type === "function") {
-						callback = type;
-						type = undefined;
-					}
-					if (value === false) return factory(data, callback);
-					if (value === true) value = dependency.request;
-					if (typeof type === "undefined" && /^[a-z0-9]+ /.test(value)) {
-						const idx = value.indexOf(" ");
-						type = value.substr(0, idx);
-						value = value.substr(idx + 1);
-					}
-					callback(
-						null,
-						new ExternalModule(value, type || globalType, dependency.request)
-					);
-					return true;
-				};
-
-				const handleExternals = (externals, callback) => {
-					if (typeof externals === "string") {
-						if (externals === dependency.request) {
-							return handleExternal(dependency.request, callback);
-						}
-					} else if (Array.isArray(externals)) {
-						let i = 0;
-						const next = () => {
-							let asyncFlag;
-							const handleExternalsAndCallback = (err, module) => {
-								if (err) return callback(err);
-								if (!module) {
-									if (asyncFlag) {
-										asyncFlag = false;
-										return;
-									}
-									return next();
-								}
-								callback(null, module);
-							};
-
-							do {
-								asyncFlag = true;
-								if (i >= externals.length) return callback();
-								handleExternals(externals[i++], handleExternalsAndCallback);
-							} while (!asyncFlag); // eslint-disable-line keyword-spacing
-							asyncFlag = false;
-						};
-
-						next();
-						return;
-					} else if (externals instanceof RegExp) {
-						if (externals.test(dependency.request)) {
-							return handleExternal(dependency.request, callback);
-						}
-					} else if (typeof externals === "function") {
-						externals.call(
-							null,
-							context,
-							dependency.request,
-							(err, value, type) => {
-								if (err) return callback(err);
-								if (typeof value !== "undefined") {
-									handleExternal(value, type, callback);
-								} else {
-									callback();
-								}
-							}
-						);
-						return;
-					} else if (
-						typeof externals === "object" &&
-						Object.prototype.hasOwnProperty.call(externals, dependency.request)
-					) {
-						return handleExternal(externals[dependency.request], callback);
-					}
-					callback();
-				};
-
-				handleExternals(this.externals, (err, module) => {
-					if (err) return callback(err);
-					if (!module) return handleExternal(false, callback);
-					return callback(null, module);
-				});
-			}
-		);
-	}
-}
-module.exports = ExternalModuleFactoryPlugin;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const ExternalModule = require("./ExternalModule");
+
+class ExternalModuleFactoryPlugin {
+	constructor(type, externals) {
+		this.type = type;
+		this.externals = externals;
+	}
+
+	apply(normalModuleFactory) {
+		const globalType = this.type;
+		normalModuleFactory.hooks.factory.tap(
+			"ExternalModuleFactoryPlugin",
+			factory => (data, callback) => {
+				const context = data.context;
+				const dependency = data.dependencies[0];
+
+				const handleExternal = (value, type, callback) => {
+					if (typeof type === "function") {
+						callback = type;
+						type = undefined;
+					}
+					if (value === false) return factory(data, callback);
+					if (value === true) value = dependency.request;
+					if (typeof type === "undefined" && /^[a-z0-9]+ /.test(value)) {
+						const idx = value.indexOf(" ");
+						type = value.substr(0, idx);
+						value = value.substr(idx + 1);
+					}
+					callback(
+						null,
+						new ExternalModule(value, type || globalType, dependency.request)
+					);
+					return true;
+				};
+
+				const handleExternals = (externals, callback) => {
+					if (typeof externals === "string") {
+						if (externals === dependency.request) {
+							return handleExternal(dependency.request, callback);
+						}
+					} else if (Array.isArray(externals)) {
+						let i = 0;
+						const next = () => {
+							let asyncFlag;
+							const handleExternalsAndCallback = (err, module) => {
+								if (err) return callback(err);
+								if (!module) {
+									if (asyncFlag) {
+										asyncFlag = false;
+										return;
+									}
+									return next();
+								}
+								callback(null, module);
+							};
+
+							do {
+								asyncFlag = true;
+								if (i >= externals.length) return callback();
+								handleExternals(externals[i++], handleExternalsAndCallback);
+							} while (!asyncFlag); // eslint-disable-line keyword-spacing
+							asyncFlag = false;
+						};
+
+						next();
+						return;
+					} else if (externals instanceof RegExp) {
+						if (externals.test(dependency.request)) {
+							return handleExternal(dependency.request, callback);
+						}
+					} else if (typeof externals === "function") {
+						externals.call(
+							null,
+							context,
+							dependency.request,
+							(err, value, type) => {
+								if (err) return callback(err);
+								if (typeof value !== "undefined") {
+									handleExternal(value, type, callback);
+								} else {
+									callback();
+								}
+							}
+						);
+						return;
+					} else if (
+						typeof externals === "object" &&
+						Object.prototype.hasOwnProperty.call(externals, dependency.request)
+					) {
+						return handleExternal(externals[dependency.request], callback);
+					}
+					callback();
+				};
+
+				handleExternals(this.externals, (err, module) => {
+					if (err) return callback(err);
+					if (!module) return handleExternal(false, callback);
+					return callback(null, module);
+				});
+			}
+		);
+	}
+}
+module.exports = ExternalModuleFactoryPlugin;

package/lib/ExternalsPlugin.js

@@ -1,23 +1,23 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const ExternalModuleFactoryPlugin = require("./ExternalModuleFactoryPlugin");
-
-class ExternalsPlugin {
-	constructor(type, externals) {
-		this.type = type;
-		this.externals = externals;
-	}
-	apply(compiler) {
-		compiler.hooks.compile.tap("ExternalsPlugin", ({ normalModuleFactory }) => {
-			new ExternalModuleFactoryPlugin(this.type, this.externals).apply(
-				normalModuleFactory
-			);
-		});
-	}
-}
-
-module.exports = ExternalsPlugin;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const ExternalModuleFactoryPlugin = require("./ExternalModuleFactoryPlugin");
+
+class ExternalsPlugin {
+	constructor(type, externals) {
+		this.type = type;
+		this.externals = externals;
+	}
+	apply(compiler) {
+		compiler.hooks.compile.tap("ExternalsPlugin", ({ normalModuleFactory }) => {
+			new ExternalModuleFactoryPlugin(this.type, this.externals).apply(
+				normalModuleFactory
+			);
+		});
+	}
+}
+
+module.exports = ExternalsPlugin;

package/lib/FlagDependencyExportsPlugin.js

@@ -1,146 +1,146 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const Queue = require("./util/Queue");
-
-const addToSet = (a, b) => {
-	let changed = false;
-	for (const item of b) {
-		if (!a.has(item)) {
-			a.add(item);
-			changed = true;
-		}
-	}
-	return changed;
-};
-
-class FlagDependencyExportsPlugin {
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"FlagDependencyExportsPlugin",
-			compilation => {
-				compilation.hooks.finishModules.tap(
-					"FlagDependencyExportsPlugin",
-					modules => {
-						const dependencies = new Map();
-
-						const queue = new Queue();
-
-						let module;
-						let moduleWithExports;
-						let moduleProvidedExports;
-
-						const processDependenciesBlock = depBlock => {
-							for (const dep of depBlock.dependencies) {
-								if (processDependency(dep)) return true;
-							}
-							for (const variable of depBlock.variables) {
-								for (const dep of variable.dependencies) {
-									if (processDependency(dep)) return true;
-								}
-							}
-							for (const block of depBlock.blocks) {
-								if (processDependenciesBlock(block)) return true;
-							}
-							return false;
-						};
-
-						const processDependency = dep => {
-							const exportDesc = dep.getExports && dep.getExports();
-							if (!exportDesc) return;
-							moduleWithExports = true;
-							const exports = exportDesc.exports;
-							// break early if it's only in the worst state
-							if (module.buildMeta.providedExports === true) {
-								return true;
-							}
-							// break if it should move to the worst state
-							if (exports === true) {
-								module.buildMeta.providedExports = true;
-								notifyDependencies();
-								return true;
-							}
-							// merge in new exports
-							if (Array.isArray(exports)) {
-								if (addToSet(moduleProvidedExports, exports)) {
-									notifyDependencies();
-								}
-							}
-							// store dependencies
-							const exportDeps = exportDesc.dependencies;
-							if (exportDeps) {
-								for (const exportDependency of exportDeps) {
-									// add dependency for this module
-									const set = dependencies.get(exportDependency);
-									if (set === undefined) {
-										dependencies.set(exportDependency, new Set([module]));
-									} else {
-										set.add(module);
-									}
-								}
-							}
-							return false;
-						};
-
-						const notifyDependencies = () => {
-							const deps = dependencies.get(module);
-							if (deps !== undefined) {
-								for (const dep of deps) {
-									queue.enqueue(dep);
-								}
-							}
-						};
-
-						// Start with all modules without provided exports
-						for (const module of modules) {
-							if (!module.buildMeta.providedExports) {
-								queue.enqueue(module);
-							}
-						}
-
-						while (queue.length > 0) {
-							module = queue.dequeue();
-
-							if (module.buildMeta.providedExports !== true) {
-								moduleWithExports =
-									module.buildMeta && module.buildMeta.exportsType;
-								moduleProvidedExports = Array.isArray(
-									module.buildMeta.providedExports
-								)
-									? new Set(module.buildMeta.providedExports)
-									: new Set();
-								processDependenciesBlock(module);
-								if (!moduleWithExports) {
-									module.buildMeta.providedExports = true;
-									notifyDependencies();
-								} else if (module.buildMeta.providedExports !== true) {
-									module.buildMeta.providedExports = Array.from(
-										moduleProvidedExports
-									);
-								}
-							}
-						}
-					}
-				);
-				const providedExportsCache = new WeakMap();
-				compilation.hooks.rebuildModule.tap(
-					"FlagDependencyExportsPlugin",
-					module => {
-						providedExportsCache.set(module, module.buildMeta.providedExports);
-					}
-				);
-				compilation.hooks.finishRebuildingModule.tap(
-					"FlagDependencyExportsPlugin",
-					module => {
-						module.buildMeta.providedExports = providedExportsCache.get(module);
-					}
-				);
-			}
-		);
-	}
-}
-
-module.exports = FlagDependencyExportsPlugin;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const Queue = require("./util/Queue");
+
+const addToSet = (a, b) => {
+	let changed = false;
+	for (const item of b) {
+		if (!a.has(item)) {
+			a.add(item);
+			changed = true;
+		}
+	}
+	return changed;
+};
+
+class FlagDependencyExportsPlugin {
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"FlagDependencyExportsPlugin",
+			compilation => {
+				compilation.hooks.finishModules.tap(
+					"FlagDependencyExportsPlugin",
+					modules => {
+						const dependencies = new Map();
+
+						const queue = new Queue();
+
+						let module;
+						let moduleWithExports;
+						let moduleProvidedExports;
+
+						const processDependenciesBlock = depBlock => {
+							for (const dep of depBlock.dependencies) {
+								if (processDependency(dep)) return true;
+							}
+							for (const variable of depBlock.variables) {
+								for (const dep of variable.dependencies) {
+									if (processDependency(dep)) return true;
+								}
+							}
+							for (const block of depBlock.blocks) {
+								if (processDependenciesBlock(block)) return true;
+							}
+							return false;
+						};
+
+						const processDependency = dep => {
+							const exportDesc = dep.getExports && dep.getExports();
+							if (!exportDesc) return;
+							moduleWithExports = true;
+							const exports = exportDesc.exports;
+							// break early if it's only in the worst state
+							if (module.buildMeta.providedExports === true) {
+								return true;
+							}
+							// break if it should move to the worst state
+							if (exports === true) {
+								module.buildMeta.providedExports = true;
+								notifyDependencies();
+								return true;
+							}
+							// merge in new exports
+							if (Array.isArray(exports)) {
+								if (addToSet(moduleProvidedExports, exports)) {
+									notifyDependencies();
+								}
+							}
+							// store dependencies
+							const exportDeps = exportDesc.dependencies;
+							if (exportDeps) {
+								for (const exportDependency of exportDeps) {
+									// add dependency for this module
+									const set = dependencies.get(exportDependency);
+									if (set === undefined) {
+										dependencies.set(exportDependency, new Set([module]));
+									} else {
+										set.add(module);
+									}
+								}
+							}
+							return false;
+						};
+
+						const notifyDependencies = () => {
+							const deps = dependencies.get(module);
+							if (deps !== undefined) {
+								for (const dep of deps) {
+									queue.enqueue(dep);
+								}
+							}
+						};
+
+						// Start with all modules without provided exports
+						for (const module of modules) {
+							if (!module.buildMeta.providedExports) {
+								queue.enqueue(module);
+							}
+						}
+
+						while (queue.length > 0) {
+							module = queue.dequeue();
+
+							if (module.buildMeta.providedExports !== true) {
+								moduleWithExports =
+									module.buildMeta && module.buildMeta.exportsType;
+								moduleProvidedExports = Array.isArray(
+									module.buildMeta.providedExports
+								)
+									? new Set(module.buildMeta.providedExports)
+									: new Set();
+								processDependenciesBlock(module);
+								if (!moduleWithExports) {
+									module.buildMeta.providedExports = true;
+									notifyDependencies();
+								} else if (module.buildMeta.providedExports !== true) {
+									module.buildMeta.providedExports = Array.from(
+										moduleProvidedExports
+									);
+								}
+							}
+						}
+					}
+				);
+				const providedExportsCache = new WeakMap();
+				compilation.hooks.rebuildModule.tap(
+					"FlagDependencyExportsPlugin",
+					module => {
+						providedExportsCache.set(module, module.buildMeta.providedExports);
+					}
+				);
+				compilation.hooks.finishRebuildingModule.tap(
+					"FlagDependencyExportsPlugin",
+					module => {
+						module.buildMeta.providedExports = providedExportsCache.get(module);
+					}
+				);
+			}
+		);
+	}
+}
+
+module.exports = FlagDependencyExportsPlugin;