webpack 5.0.0 → 5.1.3

package/lib/Compilation.js

@@ -2660,17 +2660,44 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		 * this is needed as the "hasRuntime()" chunks are dependent on the
 		 * hashes of the non-runtime chunks.
 		 */
-		chunks.sort((a, b) => {
-			const aEntry = a.hasRuntime();
-			const bEntry = b.hasRuntime();
-			if (aEntry && !bEntry) return 1;
-			if (!aEntry && bEntry) return -1;
-			return byId(a, b);
+		const runtimeChunks = [];
+		const otherChunks = [];
+		for (const c of chunks) {
+			if (c.hasRuntime()) {
+				runtimeChunks.push({
+					chunk: c,
+					referencedChunks: new Set(
+						Array.from(c.getAllReferencedAsyncEntrypoints()).map(
+							e => e.chunks[e.chunks.length - 1]
+						)
+					)
+				});
+			} else {
+				otherChunks.push(c);
+			}
+		}
+		otherChunks.sort(byId);
+		runtimeChunks.sort((a, b) => {
+			const aDependOnB = a.referencedChunks.has(b.chunk);
+			const bDependOnA = b.referencedChunks.has(a.chunk);
+			if (aDependOnB && bDependOnA) {
+				const err = new WebpackError(
+					`Circular dependency between chunks with runtime (${
+						a.chunk.name || a.chunk.id
+					} and ${b.chunk.name || b.chunk.id}).
+This prevents using hashes of each other and should be avoided.`
+				);
+				err.chunk = a.chunk;
+				this.warnings.push(err);
+				return byId(a.chunk, b.chunk);
+			}
+			if (aDependOnB) return 1;
+			if (bDependOnA) return -1;
+			return byId(a.chunk, b.chunk);
 		});
 		this.logger.timeEnd("hashing: sort chunks");
 		const fullHashChunks = new Set();
-		for (let i = 0; i < chunks.length; i++) {
-			const chunk = chunks[i];
+		const processChunk = chunk => {
 			// Last minute module hash generation for modules that depend on chunk hashes
 			this.logger.time("hashing: hash runtime modules");
 			for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
@@ -2722,7 +2749,10 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 				this.errors.push(new ChunkRenderError(chunk, "", err));
 			}
 			this.logger.timeAggregate("hashing: hash chunks");
-		}
+		};
+		otherChunks.forEach(processChunk);
+		for (const { chunk } of runtimeChunks) processChunk(chunk);
+
 		this.logger.timeAggregateEnd("hashing: hash runtime modules");
 		this.logger.timeAggregateEnd("hashing: hash chunks");
 		this.logger.time("hashing: hash digest");
@@ -2965,6 +2995,12 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 				}
 			}
 		}
+		// TODO If this becomes a performance problem
+		// store a reverse mapping from asset to chunk
+		for (const chunk of this.chunks) {
+			chunk.files.delete(file);
+			chunk.auxiliaryFiles.delete(file);
+		}
 	}
 
 	getAssets() {
@@ -3407,14 +3443,14 @@ Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE = 1000;
 Compilation.PROCESS_ASSETS_STAGE_DEV_TOOLING = 2000;
 
 /**
- * Optimize the transfer of existing assets, e. g. by preparing a compressed (gzip) file as separate asset.
+ * Optimize the hashes of the assets, e. g. by generating real hashes of the asset content.
  */
-Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER = 3000;
+Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_HASH = 2500;
 
 /**
- * Optimize the hashes of the assets, e. g. by generating real hashes of the asset content.
+ * Optimize the transfer of existing assets, e. g. by preparing a compressed (gzip) file as separate asset.
  */
-Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_HASH = 3500;
+Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER = 3000;
 
 /**
  * Analyse existing assets.

package/lib/Compiler.js

@@ -14,6 +14,7 @@ const {
 	AsyncSeriesHook
 } = require("tapable");
 const { SizeOnlySource } = require("webpack-sources");
+const webpack = require("./");
 const Cache = require("./Cache");
 const CacheFacade = require("./CacheFacade");
 const Compilation = require("./Compilation");
@@ -170,6 +171,8 @@ class Compiler {
 			entryOption: new SyncBailHook(["context", "entry"])
 		});
 
+		this.webpack = webpack;
+
 		/** @type {string=} */
 		this.name = undefined;
 		/** @type {Compilation=} */

package/lib/Dependency.js

@@ -104,8 +104,8 @@ class Dependency {
 	}
 
 	/**
-	 * @deprecated
 	 * Returns the referenced module and export
+	 * @deprecated
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @returns {never} throws error
 	 */

package/lib/EntryOptionPlugin.js

@@ -6,6 +6,7 @@
 "use strict";
 
 /** @typedef {import("../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescription */
+/** @typedef {import("../declarations/WebpackOptions").EntryNormalized} Entry */
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
 
@@ -16,27 +17,37 @@ class EntryOptionPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.entryOption.tap("EntryOptionPlugin", (context, entry) => {
-			if (typeof entry === "function") {
-				const DynamicEntryPlugin = require("./DynamicEntryPlugin");
-				new DynamicEntryPlugin(context, entry).apply(compiler);
-			} else {
-				const EntryPlugin = require("./EntryPlugin");
-				for (const name of Object.keys(entry)) {
-					const desc = entry[name];
-					const options = EntryOptionPlugin.entryDescriptionToOptions(
-						compiler,
-						name,
-						desc
-					);
-					for (const entry of desc.import) {
-						new EntryPlugin(context, entry, options).apply(compiler);
-					}
-				}
-			}
+			EntryOptionPlugin.applyEntryOption(compiler, context, entry);
 			return true;
 		});
 	}
 
+	/**
+	 * @param {Compiler} compiler the compiler
+	 * @param {string} context context directory
+	 * @param {Entry} entry request
+	 * @returns {void}
+	 */
+	static applyEntryOption(compiler, context, entry) {
+		if (typeof entry === "function") {
+			const DynamicEntryPlugin = require("./DynamicEntryPlugin");
+			new DynamicEntryPlugin(context, entry).apply(compiler);
+		} else {
+			const EntryPlugin = require("./EntryPlugin");
+			for (const name of Object.keys(entry)) {
+				const desc = entry[name];
+				const options = EntryOptionPlugin.entryDescriptionToOptions(
+					compiler,
+					name,
+					desc
+				);
+				for (const entry of desc.import) {
+					new EntryPlugin(context, entry, options).apply(compiler);
+				}
+			}
+		}
+	}
+
 	/**
 	 * @param {Compiler} compiler the compiler
 	 * @param {string} name entry name

package/lib/ExportsInfo.js

@@ -416,7 +416,7 @@ class ExportsInfo {
 
 	/**
 	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {boolean} true, when the module is used in any way
+	 * @returns {boolean} true, when the module exports are used in any way
 	 */
 	isUsed(runtime) {
 		if (this._redirectTo !== undefined) {
@@ -436,6 +436,17 @@ class ExportsInfo {
 		return false;
 	}
 
+	/**
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {boolean} true, when the module is used in any way
+	 */
+	isModuleUsed(runtime) {
+		if (this.isUsed(runtime)) return true;
+		if (this._sideEffectsOnlyInfo.getUsed(runtime) !== UsageState.Unused)
+			return true;
+		return false;
+	}
+
 	/**
 	 * @param {RuntimeSpec} runtime the runtime
 	 * @returns {SortableSet<string> | boolean | null} set of used exports, or true (when namespace object is used), or false (when unused), or null (when unknown)
@@ -752,6 +763,8 @@ class ExportInfo {
 		this.name = name;
 		/** @private @type {string | null} */
 		this._usedName = initFrom ? initFrom._usedName : null;
+		/** @private @type {UsageStateType} */
+		this._globalUsed = initFrom ? initFrom._globalUsed : undefined;
 		/** @private @type {Map<string, RuntimeUsageStateType>} */
 		this._usedInRuntime =
 			initFrom && initFrom._usedInRuntime
@@ -907,7 +920,17 @@ class ExportInfo {
 	 * @returns {boolean} true when something has changed
 	 */
 	setUsedConditionally(condition, newValue, runtime) {
-		if (this._usedInRuntime === undefined) {
+		if (runtime === undefined) {
+			if (this._globalUsed === undefined) {
+				this._globalUsed = newValue;
+				return true;
+			} else {
+				if (this._globalUsed !== newValue && condition(this._globalUsed)) {
+					this._globalUsed = newValue;
+					return true;
+				}
+			}
+		} else if (this._usedInRuntime === undefined) {
 			if (newValue !== UsageState.Unused && condition(UsageState.Unused)) {
 				this._usedInRuntime = new Map();
 				forEachRuntime(runtime, runtime =>
@@ -944,7 +967,12 @@ class ExportInfo {
 	 * @returns {boolean} true when something has changed
 	 */
 	setUsed(newValue, runtime) {
-		if (this._usedInRuntime === undefined) {
+		if (runtime === undefined) {
+			if (this._globalUsed !== newValue) {
+				this._globalUsed = newValue;
+				return true;
+			}
+		} else if (this._usedInRuntime === undefined) {
 			if (newValue !== UsageState.Unused) {
 				this._usedInRuntime = new Map();
 				forEachRuntime(runtime, runtime =>
@@ -1023,6 +1051,7 @@ class ExportInfo {
 	 */
 	getUsed(runtime) {
 		if (!this._hasUseInRuntimeInfo) return UsageState.NoInfo;
+		if (this._globalUsed !== undefined) return this._globalUsed;
 		if (this._usedInRuntime === undefined) {
 			return UsageState.Unused;
 		} else if (typeof runtime === "string") {
@@ -1062,18 +1091,22 @@ class ExportInfo {
 	 */
 	getUsedName(fallbackName, runtime) {
 		if (this._hasUseInRuntimeInfo) {
-			if (this._usedInRuntime === undefined) return false;
-			if (typeof runtime === "string") {
-				if (!this._usedInRuntime.has(runtime)) {
-					return false;
-				}
-			} else if (runtime !== undefined) {
-				if (
-					Array.from(runtime).every(
-						runtime => !this._usedInRuntime.has(runtime)
-					)
-				) {
-					return false;
+			if (this._globalUsed !== undefined) {
+				if (this._globalUsed === UsageState.Unused) return false;
+			} else {
+				if (this._usedInRuntime === undefined) return false;
+				if (typeof runtime === "string") {
+					if (!this._usedInRuntime.has(runtime)) {
+						return false;
+					}
+				} else if (runtime !== undefined) {
+					if (
+						Array.from(runtime).every(
+							runtime => !this._usedInRuntime.has(runtime)
+						)
+					) {
+						return false;
+					}
 				}
 			}
 		}
@@ -1282,7 +1315,20 @@ class ExportInfo {
 	}
 
 	getUsedInfo() {
-		if (this._usedInRuntime !== undefined) {
+		if (this._globalUsed !== undefined) {
+			switch (this._globalUsed) {
+				case UsageState.Unused:
+					return "unused";
+				case UsageState.NoInfo:
+					return "no usage info";
+				case UsageState.Unknown:
+					return "maybe used (runtime-defined)";
+				case UsageState.Used:
+					return "used";
+				case UsageState.OnlyPropertiesUsed:
+					return "only properties used";
+			}
+		} else if (this._usedInRuntime !== undefined) {
 			/** @type {Map<RuntimeUsageStateType, string[]>} */
 			const map = new Map();
 			for (const [runtime, used] of this._usedInRuntime) {

package/lib/FlagDependencyUsagePlugin.js

@@ -7,13 +7,10 @@
 
 const Dependency = require("./Dependency");
 const { UsageState } = require("./ExportsInfo");
+const ModuleGraphConnection = require("./ModuleGraphConnection");
 const { STAGE_DEFAULT } = require("./OptimizationStages");
 const TupleQueue = require("./util/TupleQueue");
-const {
-	getEntryRuntime,
-	mergeRuntime,
-	mergeRuntimeOwned
-} = require("./util/runtime");
+const { getEntryRuntime, mergeRuntimeOwned } = require("./util/runtime");
 
 /** @typedef {import("./Chunk")} Chunk */
 /** @typedef {import("./ChunkGroup")} ChunkGroup */
@@ -63,9 +60,15 @@ class FlagDependencyUsagePlugin {
 					 * @param {Module} module module to process
 					 * @param {(string[] | ReferencedExport)[]} usedExports list of used exports
 					 * @param {RuntimeSpec} runtime part of which runtime
+					 * @param {boolean} forceSideEffects always apply side effects
 					 * @returns {void}
 					 */
-					const processReferencedModule = (module, usedExports, runtime) => {
+					const processReferencedModule = (
+						module,
+						usedExports,
+						runtime,
+						forceSideEffects
+					) => {
 						const exportsInfo = moduleGraph.getExportsInfo(module);
 						if (usedExports.length > 0) {
 							if (!module.buildMeta || !module.buildMeta.exportsType) {
@@ -143,10 +146,12 @@ class FlagDependencyUsagePlugin {
 							// This module won't be evaluated in this case
 							// TODO webpack 6 remove this check
 							if (
+								!forceSideEffects &&
 								module.factoryMeta !== undefined &&
 								module.factoryMeta.sideEffectFree
-							)
+							) {
 								return;
+							}
 							if (exportsInfo.setUsedForSideEffectsOnly(runtime)) {
 								queue.enqueue(module, runtime);
 							}
@@ -166,7 +171,11 @@ class FlagDependencyUsagePlugin {
 						const queue = [module];
 						for (const block of queue) {
 							for (const b of block.blocks) {
-								if (b.groupOptions && b.groupOptions.entryOptions) {
+								if (
+									!this.global &&
+									b.groupOptions &&
+									b.groupOptions.entryOptions
+								) {
 									processModule(b, b.groupOptions.entryOptions.runtime);
 								} else {
 									queue.push(b);
@@ -174,14 +183,16 @@ class FlagDependencyUsagePlugin {
 							}
 							for (const dep of block.dependencies) {
 								const connection = moduleGraph.getConnection(dep);
-								if (
-									!connection ||
-									!connection.module ||
-									!connection.isTargetActive(runtime)
-								) {
+								if (!connection || !connection.module) {
 									continue;
 								}
+								const activeState = connection.getActiveState(runtime);
+								if (activeState === false) continue;
 								const { module } = connection;
+								if (activeState === ModuleGraphConnection.TRANSITIVE_ONLY) {
+									processModule(module, runtime);
+									continue;
+								}
 								const oldReferencedExports = map.get(module);
 								if (oldReferencedExports === EXPORTS_OBJECT_REFERENCED) {
 									continue;
@@ -242,12 +253,18 @@ class FlagDependencyUsagePlugin {
 
 						for (const [module, referencedExports] of map) {
 							if (Array.isArray(referencedExports)) {
-								processReferencedModule(module, referencedExports, runtime);
+								processReferencedModule(
+									module,
+									referencedExports,
+									runtime,
+									false
+								);
 							} else {
 								processReferencedModule(
 									module,
 									Array.from(referencedExports.values()),
-									runtime
+									runtime,
+									false
 								);
 							}
 						}
@@ -270,8 +287,12 @@ class FlagDependencyUsagePlugin {
 					const processEntryDependency = (dep, runtime) => {
 						const module = moduleGraph.getModule(dep);
 						if (module) {
-							processReferencedModule(module, NO_EXPORTS_REFERENCED, runtime);
-							queue.enqueue(module, runtime);
+							processReferencedModule(
+								module,
+								NO_EXPORTS_REFERENCED,
+								runtime,
+								true
+							);
 						}
 					};
 					/** @type {RuntimeSpec} */
@@ -305,31 +326,6 @@ class FlagDependencyUsagePlugin {
 					logger.timeEnd("trace exports usage in graph");
 				}
 			);
-			if (!this.global) {
-				compilation.hooks.afterChunks.tap("FlagDependencyUsagePlugin", () => {
-					/** @type {Map<Chunk, string>} */
-					const runtimeChunks = new Map();
-					for (const entrypoint of compilation.entrypoints.values()) {
-						runtimeChunks.set(
-							entrypoint.getRuntimeChunk(),
-							entrypoint.options.runtime
-						);
-					}
-					for (const entrypoint of compilation.asyncEntrypoints) {
-						runtimeChunks.set(
-							entrypoint.getRuntimeChunk(),
-							entrypoint.options.runtime
-						);
-					}
-
-					for (const [runtimeChunk, runtimeName] of runtimeChunks) {
-						const runtime = runtimeName || runtimeChunk.name;
-						for (const chunk of runtimeChunk.getAllReferencedChunks()) {
-							chunk.runtime = mergeRuntime(chunk.runtime, runtime);
-						}
-					}
-				});
-			}
 		});
 	}
 }

package/lib/ModuleTemplate.js

@@ -126,7 +126,7 @@ class ModuleTemplate {
 					(options, fn) => {
 						compilation.hooks.fullHash.tap(options, fn);
 					},
-					"ModuleTemplate.hooks.package is deprecated (use Compilation.hooks.fullHash instead)",
+					"ModuleTemplate.hooks.hash is deprecated (use Compilation.hooks.fullHash instead)",
 					"DEP_MODULE_TEMPLATE_HASH"
 				)
 			}

package/lib/NormalModule.js

@@ -154,7 +154,7 @@ makeSerializable(
 /**
  * @typedef {Object} NormalModuleCompilationHooks
  * @property {SyncHook<[object, NormalModule]>} loader
- * @property {SyncHook<[LoaderItem[], object, NormalModule]>} beforeLoaders
+ * @property {SyncHook<[LoaderItem[], NormalModule, object]>} beforeLoaders
  * @property {HookMap<AsyncSeriesBailHook<[string, NormalModule], string | Buffer>>} readResourceForScheme
  */
 

package/lib/buildChunkGraph.js

@@ -8,6 +8,7 @@
 const AsyncDependencyToInitialChunkError = require("./AsyncDependencyToInitialChunkError");
 const { connectChunkGroupParentAndChild } = require("./GraphHelpers");
 const ModuleGraphConnection = require("./ModuleGraphConnection");
+const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
 
 /** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
 /** @typedef {import("./Chunk")} Chunk */
@@ -20,6 +21,7 @@ const ModuleGraphConnection = require("./ModuleGraphConnection");
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("./logging/Logger").Logger} Logger */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
 /**
  * @typedef {Object} QueueItem
@@ -36,10 +38,12 @@ const ModuleGraphConnection = require("./ModuleGraphConnection");
 /**
  * @typedef {Object} ChunkGroupInfo
  * @property {ChunkGroup} chunkGroup the chunk group
+ * @property {RuntimeSpec} runtime the runtimes
  * @property {ModuleSetPlus} minAvailableModules current minimal set of modules available at this point
  * @property {boolean} minAvailableModulesOwned true, if minAvailableModules is owned and can be modified
  * @property {ModuleSetPlus[]} availableModulesToBeMerged enqueued updates to the minimal set of available modules
  * @property {Set<Module>=} skippedItems modules that were skipped because module is already available in parent chunks (need to reconsider when minAvailableModules is shrinking)
+ * @property {Set<[Module, ModuleGraphConnection[]]>=} skippedModuleConnections referenced modules that where skipped because they were not active in this runtime
  * @property {ModuleSetPlus} resultingAvailableModules set of modules available including modules from this chunk group
  * @property {Set<ChunkGroupInfo>} children set of children chunk groups, that will be revisited when availableModules shrink
  * @property {Set<ChunkGroupInfo>} availableSources set of chunk groups that are the source for minAvailableModules
@@ -66,21 +70,41 @@ const bySetSize = (a, b) => {
 	return b.size + b.plus.size - a.size - a.plus.size;
 };
 
+/**
+ *
+ * @param {ModuleGraphConnection[]} connections list of connections
+ * @param {RuntimeSpec} runtime for which runtime
+ * @returns {ConnectionState} connection state
+ */
+const getActiveStateOfConnections = (connections, runtime) => {
+	let merged = connections[0].getActiveState(runtime);
+	if (merged === true) return true;
+	for (let i = 1; i < connections.length; i++) {
+		const c = connections[i];
+		merged = ModuleGraphConnection.addConnectionStates(
+			merged,
+			c.getActiveState(runtime)
+		);
+		if (merged === true) return true;
+	}
+	return merged;
+};
+
 /**
  * Extracts block to modules mapping from all modules
  * @param {Compilation} compilation the compilation
- * @returns {Map<DependenciesBlock, Map<Module, Exclude<ConnectionState, false>>>} the mapping block to modules
+ * @returns {Map<DependenciesBlock, Map<Module, ModuleGraphConnection[]>>} the mapping block to modules
  */
 const extractBlockModulesMap = compilation => {
 	const { moduleGraph } = compilation;
 
-	/** @type {Map<DependenciesBlock, Map<Module, Exclude<ConnectionState, false>>>} */
+	/** @type {Map<DependenciesBlock, Map<Module, ModuleGraphConnection[]>>} */
 	const blockModulesMap = new Map();
 
 	const blockQueue = new Set();
 
 	for (const module of compilation.modules) {
-		/** @type {WeakMap<Dependency, [Module, Exclude<ConnectionState, false>]>} */
+		/** @type {WeakMap<Dependency, ModuleGraphConnection>} */
 		let moduleMap;
 
 		for (const connection of moduleGraph.getOutgoingConnections(module)) {
@@ -101,7 +125,7 @@ const extractBlockModulesMap = compilation => {
 			if (moduleMap === undefined) {
 				moduleMap = new WeakMap();
 			}
-			moduleMap.set(connection.dependency, [m, state]);
+			moduleMap.set(connection.dependency, connection);
 		}
 
 		blockQueue.clear();
@@ -111,27 +135,19 @@ const extractBlockModulesMap = compilation => {
 
 			if (moduleMap !== undefined && block.dependencies) {
 				for (const dep of block.dependencies) {
-					const map = moduleMap.get(dep);
-					if (map !== undefined) {
-						const [module, state] = map;
+					const connection = moduleMap.get(dep);
+					if (connection !== undefined) {
+						const { module } = connection;
 						if (modules === undefined) {
 							modules = new Map();
 							blockModulesMap.set(block, modules);
 						}
-						let merged = state;
-						if (merged !== true) {
-							const old = modules.get(module);
-							if (old !== undefined) {
-								merged = /** @type {Exclude<ConnectionState, false>} */ (ModuleGraphConnection.addConnectionStates(
-									old,
-									merged
-								));
-								if (merged === old) {
-									continue;
-								}
-							}
+						const old = modules.get(module);
+						if (old !== undefined) {
+							old.push(connection);
+						} else {
+							modules.set(module, [connection]);
 						}
-						modules.set(module, merged);
 					}
 				}
 			}
@@ -216,9 +232,15 @@ const visitModules = (
 	// Fill queue with entrypoint modules
 	// Create ChunkGroupInfo for entrypoints
 	for (const [chunkGroup, modules] of inputEntrypointsAndModules) {
+		const runtime = getEntryRuntime(
+			compilation,
+			chunkGroup.name,
+			chunkGroup.options
+		);
 		/** @type {ChunkGroupInfo} */
 		const chunkGroupInfo = {
 			chunkGroup,
+			runtime,
 			minAvailableModules: undefined,
 			minAvailableModulesOwned: false,
 			availableModulesToBeMerged: [],
@@ -288,6 +310,8 @@ const visitModules = (
 
 	logger.timeEnd("visitModules: prepare");
 
+	/** @type {[Module, ModuleGraphConnection[]][]} */
+	const skipConnectionBuffer = [];
 	/** @type {Module[]} */
 	const skipBuffer = [];
 	/** @type {QueueItem[]} */
@@ -332,6 +356,7 @@ const visitModules = (
 					entrypoint.index = nextChunkGroupIndex++;
 					cgi = {
 						chunkGroup: entrypoint,
+						runtime: entrypoint.options.runtime || entrypoint.name,
 						minAvailableModules: EMPTY_SET,
 						minAvailableModulesOwned: false,
 						availableModulesToBeMerged: [],
@@ -377,6 +402,7 @@ const visitModules = (
 					c.index = nextChunkGroupIndex++;
 					cgi = {
 						chunkGroup: c,
+						runtime: chunkGroupInfo.runtime,
 						minAvailableModules: undefined,
 						minAvailableModulesOwned: undefined,
 						availableModulesToBeMerged: [],
@@ -455,17 +481,24 @@ const visitModules = (
 		const blockModules = blockModulesMap.get(block);
 
 		if (blockModules !== undefined) {
-			const { minAvailableModules } = chunkGroupInfo;
+			const { minAvailableModules, runtime } = chunkGroupInfo;
 			// Buffer items because order need to be reversed to get indices correct
 			// Traverse all referenced modules
-			for (const [refModule, activeState] of blockModules) {
+			for (const entry of blockModules) {
+				const [refModule, connections] = entry;
 				if (chunkGraph.isModuleInChunk(refModule, chunk)) {
 					// skip early if already connected
 					continue;
 				}
+				const activeState = getActiveStateOfConnections(connections, runtime);
+				if (activeState !== true) {
+					skipConnectionBuffer.push(entry);
+					if (activeState === false) continue;
+				}
 				if (
-					minAvailableModules.has(refModule) ||
-					minAvailableModules.plus.has(refModule)
+					activeState === true &&
+					(minAvailableModules.has(refModule) ||
+						minAvailableModules.plus.has(refModule))
 				) {
 					// already in parent chunks, skip it for now
 					skipBuffer.push(refModule);
@@ -483,6 +516,16 @@ const visitModules = (
 				});
 			}
 			// Add buffered items in reverse order
+			if (skipConnectionBuffer.length > 0) {
+				let { skippedModuleConnections } = chunkGroupInfo;
+				if (skippedModuleConnections === undefined) {
+					chunkGroupInfo.skippedModuleConnections = skippedModuleConnections = new Set();
+				}
+				for (let i = skipConnectionBuffer.length - 1; i >= 0; i--) {
+					skippedModuleConnections.add(skipConnectionBuffer[i]);
+				}
+				skipConnectionBuffer.length = 0;
+			}
 			if (skipBuffer.length > 0) {
 				let { skippedItems } = chunkGroupInfo;
 				if (skippedItems === undefined) {
@@ -522,7 +565,8 @@ const visitModules = (
 
 		if (blockModules !== undefined) {
 			// Traverse all referenced modules
-			for (const [refModule, activeState] of blockModules) {
+			for (const [refModule, connections] of blockModules) {
+				const activeState = getActiveStateOfConnections(connections, undefined);
 				// enqueue, then add and enter to be in the correct order
 				// this is relevant with circular dependencies
 				queueBuffer.push({
@@ -692,10 +736,18 @@ const visitModules = (
 				chunkGroupInfo
 			);
 
+			const runtime = chunkGroupInfo.runtime;
+
 			// 3. Update chunk group info
 			for (const target of targets) {
 				target.availableModulesToBeMerged.push(resultingAvailableModules);
 				chunkGroupsForMerging.add(target);
+				const oldRuntime = target.runtime;
+				const newRuntime = mergeRuntime(oldRuntime, runtime);
+				if (oldRuntime !== newRuntime) {
+					target.runtime = newRuntime;
+					outdatedChunkGroupInfo.add(target);
+				}
 			}
 
 			statConnectedChunkGroups += targets.size;
@@ -1000,6 +1052,35 @@ const visitModules = (
 				}
 			}
 
+			// 2. Reconsider skipped connections
+			if (info.skippedModuleConnections !== undefined) {
+				const { minAvailableModules, runtime } = info;
+				for (const entry of info.skippedModuleConnections) {
+					const [module, connections] = entry;
+					const activeState = getActiveStateOfConnections(connections, runtime);
+					if (activeState === false) continue;
+					if (activeState === true) {
+						info.skippedModuleConnections.delete(entry);
+					}
+					if (
+						activeState === true &&
+						(minAvailableModules.has(module) ||
+							minAvailableModules.plus.has(module))
+					) {
+						info.skippedItems.add(module);
+						continue;
+					}
+					queue.push({
+						action: activeState === true ? ADD_AND_ENTER_MODULE : PROCESS_BLOCK,
+						block: module,
+						module,
+						chunk: info.chunkGroup.chunks[0],
+						chunkGroup: info.chunkGroup,
+						chunkGroupInfo: info
+					});
+				}
+			}
+
 			// 2. Reconsider children chunk groups
 			if (info.children !== undefined) {
 				statChildChunkGroupsReconnected += info.children.size;
@@ -1213,6 +1294,11 @@ const buildChunkGraph = (compilation, inputEntrypointsAndModules) => {
 	);
 	logger.timeEnd("connectChunkGroups");
 
+	for (const [chunkGroup, chunkGroupInfo] of chunkGroupInfoMap) {
+		for (const chunk of chunkGroup.chunks)
+			chunk.runtime = mergeRuntime(chunk.runtime, chunkGroupInfo.runtime);
+	}
+
 	// Cleanup work
 
 	logger.time("cleanup");

package/lib/dependencies/CommonJsImportsParserPlugin.js

@@ -238,6 +238,7 @@ class CommonJsImportsParserPlugin {
 					members
 				);
 				dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
+				dep.optional = !!parser.scope.inTry;
 				dep.loc = expr.loc;
 				parser.state.module.addDependency(dep);
 				return true;
@@ -254,6 +255,7 @@ class CommonJsImportsParserPlugin {
 				);
 				dep.call = true;
 				dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
+				dep.optional = !!parser.scope.inTry;
 				dep.loc = expr.callee.loc;
 				parser.state.module.addDependency(dep);
 				parser.walkExpressions(expr.arguments);

package/lib/index.js

@@ -137,6 +137,12 @@ module.exports = mergeExports(fn, {
 	get DllReferencePlugin() {
 		return require("./DllReferencePlugin");
 	},
+	get DynamicEntryPlugin() {
+		return require("./DynamicEntryPlugin");
+	},
+	get EntryOptionPlugin() {
+		return require("./EntryOptionPlugin");
+	},
 	get EntryPlugin() {
 		return require("./EntryPlugin");
 	},
@@ -480,6 +486,9 @@ module.exports = mergeExports(fn, {
 		},
 		get serialization() {
 			return require("./util/serialization");
+		},
+		get cleverMerge() {
+			return require("./util/cleverMerge").cachedCleverMerge;
 		}
 	},
 

package/lib/optimize/ConcatenatedModule.js

@@ -308,14 +308,6 @@ const getFinalBinding = (
 		};
 	}
 	alreadyVisited.add(exportInfo);
-	if (exportInfo.getUsed(runtime) === UsageState.Unused) {
-		return {
-			info,
-			rawName: "/* unused export */ undefined",
-			ids: exportName.slice(1),
-			exportName
-		};
-	}
 	switch (info.type) {
 		case "concatenated": {
 			const exportId = exportName[0];
@@ -335,6 +327,14 @@ const getFinalBinding = (
 					exportName,
 					runtime
 				));
+				if (!usedName) {
+					return {
+						info,
+						rawName: "/* unused export */ undefined",
+						ids: exportName.slice(1),
+						exportName
+					};
+				}
 				return {
 					info,
 					name: directExport,
@@ -404,6 +404,14 @@ const getFinalBinding = (
 				exportName,
 				runtime
 			));
+			if (!used) {
+				return {
+					info,
+					rawName: "/* unused export */ undefined",
+					ids: exportName.slice(1),
+					exportName
+				};
+			}
 			const comment = equals(used, exportName)
 				? ""
 				: Template.toNormalComment(`${exportName.join(".")}`);
@@ -1500,7 +1508,7 @@ ${defineGetters}`
 		const orderedConcatenationList = this._createConcatenationList(
 			this.rootModule,
 			this._modules,
-			undefined,
+			runtime,
 			moduleGraph
 		);
 		return orderedConcatenationList.map((info, index) => {

package/lib/optimize/InnerGraph.js

@@ -116,6 +116,7 @@ exports.inferDependencyUsage = state => {
 	}
 
 	const { innerGraph, usageCallbackMap } = innerGraphState;
+	const processed = new Map();
 	// flatten graph to terminal nodes (string, undefined or true)
 	const nonTerminal = new Set(innerGraph.keys());
 	while (nonTerminal.size > 0) {
@@ -124,7 +125,15 @@ exports.inferDependencyUsage = state => {
 			let newSet = new Set();
 			let isTerminal = true;
 			const value = innerGraph.get(key);
+			let alreadyProcessed = processed.get(key);
+			if (alreadyProcessed === undefined) {
+				alreadyProcessed = new Set();
+				processed.set(key, alreadyProcessed);
+			}
 			if (value !== true && value !== undefined) {
+				for (const item of value) {
+					alreadyProcessed.add(item);
+				}
 				for (const item of value) {
 					if (typeof item === "string") {
 						newSet.add(item);
@@ -137,7 +146,7 @@ exports.inferDependencyUsage = state => {
 						if (itemValue !== undefined) {
 							for (const i of itemValue) {
 								if (i === key) continue;
-								if (value.has(i)) continue;
+								if (alreadyProcessed.has(i)) continue;
 								newSet.add(i);
 								if (typeof i !== "string") {
 									isTerminal = false;

package/lib/stats/StatsPrinter.js

@@ -46,9 +46,9 @@ class StatsPrinter {
 	}
 
 	/**
+	 * get all level hooks
 	 * @private
 	 * @template {Hook} T
-	 * get all level hooks
 	 * @param {HookMap<T>} hookMap HookMap
 	 * @param {string} type type
 	 * @returns {T[]} hooks
@@ -79,10 +79,10 @@ class StatsPrinter {
 	}
 
 	/**
+	 * Run `fn` for each level
 	 * @private
 	 * @template T
 	 * @template R
-	 * Run `fn` for each level
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap HookMap
 	 * @param {string} type type
 	 * @param {(hook: SyncBailHook<T, R>) => R} fn function

package/lib/util/Hash.js

@@ -8,8 +8,8 @@
 class Hash {
 	/* istanbul ignore next */
 	/**
-	 * @abstract
 	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+	 * @abstract
 	 * @param {string|Buffer} data data
 	 * @param {string=} inputEncoding data encoding
 	 * @returns {this} updated hash
@@ -21,8 +21,8 @@ class Hash {
 
 	/* istanbul ignore next */
 	/**
-	 * @abstract
 	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+	 * @abstract
 	 * @param {string=} encoding encoding of the return value
 	 * @returns {string|Buffer} digest
 	 */

package/lib/util/LazyBucketSortedSet.js

@@ -8,16 +8,16 @@
 const SortableSet = require("./SortableSet");
 
 /**
+ * Multi layer bucket sorted set:
+ * Supports adding non-existing items (DO NOT ADD ITEM TWICE),
+ * Supports removing exiting items (DO NOT REMOVE ITEM NOT IN SET),
+ * Supports popping the first items according to defined order,
+ * Supports iterating all items without order,
+ * Supports updating an item in an efficient way,
+ * Supports size property, which is the number of items,
+ * Items are lazy partially sorted when needed
  * @template T
  * @template K
- * Multi layer bucket sorted set
- * Supports adding non-existing items (DO NOT ADD ITEM TWICE)
- * Supports removing exiting items (DO NOT REMOVE ITEM NOT IN SET)
- * Supports popping the first items according to defined order
- * Supports iterating all items without order
- * Supports updating an item in an efficient way
- * Supports size property, which is the number of items
- * Items are lazy partially sorted when needed
  */
 class LazyBucketSortedSet {
 	/**

package/lib/util/cleverMerge.js

@@ -12,9 +12,9 @@ const setPropertyCache = new WeakMap();
 const DELETE = Symbol("DELETE");
 
 /**
+ * Merges two given objects and caches the result to avoid computation if same objects passed as arguments again.
  * @template T
  * @template O
- * Merges two given objects and caches the result to avoid computation if same objects passed as arguments again.
  * @example
  * // performs cleverMerge(first, second), stores the result in WeakMap and returns result
  * cachedCleverMerge({a: 1}, {a: 2})

package/lib/util/runtime.js

@@ -44,7 +44,7 @@ exports.getEntryRuntime = (compilation, name, options) => {
 				result = mergeRuntimeOwned(result, runtime || name);
 			}
 		}
-		return result;
+		return result || name;
 	} else {
 		return runtime || name;
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "5.0.0",
+  "version": "5.1.3",
   "author": "Tobias Koppers @sokra",
   "description": "Packs CommonJs/AMD modules for the browser. Allows to split your codebase into multiple bundles, which can be loaded on demand. Support loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "license": "MIT",
@@ -26,7 +26,7 @@
     "pkg-dir": "^4.2.0",
     "schema-utils": "^3.0.0",
     "tapable": "^2.0.0",
-    "terser-webpack-plugin": "^4.1.0",
+    "terser-webpack-plugin": "^5.0.0",
     "watchpack": "^2.0.0",
     "webpack-sources": "^2.0.1"
   },
@@ -75,7 +75,7 @@
     "lodash": "^4.17.19",
     "lodash-es": "^4.17.15",
     "memfs": "^3.2.0",
-    "mini-css-extract-plugin": "^0.10.0",
+    "mini-css-extract-plugin": "^1.0.0",
     "mini-svg-data-uri": "^1.2.3",
     "open-cli": "^6.0.1",
     "prettier": "^2.0.5",

package/types.d.ts

@@ -1547,14 +1547,14 @@ declare class Compilation {
 	static PROCESS_ASSETS_STAGE_DEV_TOOLING: number;
 
 	/**
-	 * Optimize the transfer of existing assets, e. g. by preparing a compressed (gzip) file as separate asset.
+	 * Optimize the hashes of the assets, e. g. by generating real hashes of the asset content.
 	 */
-	static PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER: number;
+	static PROCESS_ASSETS_STAGE_OPTIMIZE_HASH: number;
 
 	/**
-	 * Optimize the hashes of the assets, e. g. by generating real hashes of the asset content.
+	 * Optimize the transfer of existing assets, e. g. by preparing a compressed (gzip) file as separate asset.
 	 */
-	static PROCESS_ASSETS_STAGE_OPTIMIZE_HASH: number;
+	static PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER: number;
 
 	/**
 	 * Analyse existing assets.
@@ -1618,6 +1618,7 @@ declare class Compiler {
 		afterResolvers: SyncHook<[Compiler], void>;
 		entryOption: SyncBailHook<[string, EntryNormalized], boolean>;
 	}>;
+	webpack: typeof exports;
 	name: string;
 	parentCompilation: Compilation;
 	root: Compiler;
@@ -2222,6 +2223,10 @@ declare class Dependency {
 	readonly type: string;
 	readonly category: string;
 	getResourceIdentifier(): string;
+
+	/**
+	 * Returns the referenced module and export
+	 */
 	getReference(moduleGraph: ModuleGraph): never;
 
 	/**
@@ -2545,6 +2550,16 @@ type DllReferencePluginOptionsSourceType =
 	| "umd2"
 	| "jsonp"
 	| "system";
+declare class DynamicEntryPlugin {
+	constructor(context: string, entry: () => Promise<EntryStaticNormalized>);
+	context: string;
+	entry: () => Promise<EntryStaticNormalized>;
+
+	/**
+	 * Apply the plugin
+	 */
+	apply(compiler: Compiler): void;
+}
 declare interface Effect {
 	type: string;
 	value: any;
@@ -2700,6 +2715,28 @@ type EntryNormalized =
 declare interface EntryObject {
 	[index: string]: string | [string, ...string[]] | EntryDescription;
 }
+declare class EntryOptionPlugin {
+	constructor();
+	apply(compiler: Compiler): void;
+	static applyEntryOption(
+		compiler: Compiler,
+		context: string,
+		entry: EntryNormalized
+	): void;
+	static entryDescriptionToOptions(
+		compiler: Compiler,
+		name: string,
+		desc: EntryDescriptionNormalized
+	): { name?: string } & Pick<
+		EntryDescriptionNormalized,
+		| "filename"
+		| "chunkLoading"
+		| "dependOn"
+		| "library"
+		| "runtime"
+		| "wasmLoading"
+	>;
+}
 declare class EntryPlugin {
 	/**
 	 * An entry plugin which will handle
@@ -3039,6 +3076,7 @@ declare abstract class ExportsInfo {
 	setAllKnownExportsUsed(runtime: string | SortableSet<string>): boolean;
 	setUsedForSideEffectsOnly(runtime: string | SortableSet<string>): boolean;
 	isUsed(runtime: string | SortableSet<string>): boolean;
+	isModuleUsed(runtime: string | SortableSet<string>): boolean;
 	getUsedExports(
 		runtime: string | SortableSet<string>
 	): boolean | SortableSet<string>;
@@ -3566,7 +3604,15 @@ declare interface HandleModuleCreationOptions {
 }
 declare class Hash {
 	constructor();
+
+	/**
+	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+	 */
 	update(data: string | Buffer, inputEncoding?: string): Hash;
+
+	/**
+	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+	 */
 	digest(encoding?: string): string | Buffer;
 }
 type HashFunction = string | typeof Hash;
@@ -5551,7 +5597,7 @@ declare class NormalModule extends Module {
 }
 declare interface NormalModuleCompilationHooks {
 	loader: SyncHook<[any, NormalModule], void>;
-	beforeLoaders: SyncHook<[LoaderItem[], any, NormalModule], void>;
+	beforeLoaders: SyncHook<[LoaderItem[], NormalModule, any], void>;
 	readResourceForScheme: HookMap<
 		AsyncSeriesBailHook<[string, NormalModule], string | Buffer>
 	>;
@@ -10254,6 +10300,7 @@ declare namespace exports {
 			export let createFileSerializer: (fs?: any) => Serializer;
 			export { MEASURE_START_OPERATION, MEASURE_END_OPERATION };
 		}
+		export const cleverMerge: <T, O>(first: T, second: O) => T & O;
 	}
 	export namespace sources {
 		export {
@@ -10295,6 +10342,8 @@ declare namespace exports {
 		Dependency,
 		DllPlugin,
 		DllReferencePlugin,
+		DynamicEntryPlugin,
+		EntryOptionPlugin,
 		EntryPlugin,
 		EnvironmentPlugin,
 		EvalDevToolModulePlugin,