webpack 5.1.2 → 5.1.3

package/lib/Compilation.js

@@ -3443,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/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/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/optimize/ConcatenatedModule.js

@@ -1508,7 +1508,7 @@ ${defineGetters}`
 		const orderedConcatenationList = this._createConcatenationList(
 			this.rootModule,
 			this._modules,
-			undefined,
+			runtime,
 			moduleGraph
 		);
 		return orderedConcatenationList.map((info, index) => {

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.1.2",
+  "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",
@@ -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.
@@ -3076,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>;