webpack 5.35.0 → 5.36.2

package/lib/InitFragment.js

@@ -73,13 +73,25 @@ class InitFragment {
 			// Deduplicate fragments. If a fragment has no key, it is always included.
 			const keyedFragments = new Map();
 			for (const [fragment] of sortedFragments) {
-				if (typeof fragment.merge === "function") {
+				if (typeof fragment.mergeAll === "function") {
+					if (!fragment.key) {
+						throw new Error(
+							`InitFragment with mergeAll function must have a valid key: ${fragment.constructor.name}`
+						);
+					}
+					const oldValue = keyedFragments.get(fragment.key);
+					if (oldValue === undefined) {
+						keyedFragments.set(fragment.key, fragment);
+					} else if (Array.isArray(oldValue)) {
+						oldValue.push(fragment);
+					} else {
+						keyedFragments.set(fragment.key, [oldValue, fragment]);
+					}
+					continue;
+				} else if (typeof fragment.merge === "function") {
 					const oldValue = keyedFragments.get(fragment.key);
 					if (oldValue !== undefined) {
-						keyedFragments.set(
-							fragment.key || Symbol(),
-							fragment.merge(oldValue)
-						);
+						keyedFragments.set(fragment.key, fragment.merge(oldValue));
 						continue;
 					}
 				}
@@ -88,7 +100,10 @@ class InitFragment {
 
 			const concatSource = new ConcatSource();
 			const endContents = [];
-			for (const fragment of keyedFragments.values()) {
+			for (let fragment of keyedFragments.values()) {
+				if (Array.isArray(fragment)) {
+					fragment = fragment[0].mergeAll(fragment);
+				}
 				concatSource.add(fragment.getContent(generateContext));
 				const endContent = fragment.getEndContent(generateContext);
 				if (endContent) {

package/lib/ModuleGraph.js

@@ -25,7 +25,7 @@ const WeakTupleMap = require("./util/WeakTupleMap");
  * @returns {string}
  */
 
-const EMPTY_ARRAY = [];
+const EMPTY_SET = new Set();
 
 /**
  * @param {SortableSet<ModuleGraphConnection>} set input
@@ -82,20 +82,9 @@ class ModuleGraphModule {
 	}
 }
 
-class ModuleGraphDependency {
-	constructor() {
-		/** @type {ModuleGraphConnection} */
-		this.connection = undefined;
-		/** @type {Module} */
-		this.parentModule = undefined;
-		/** @type {DependenciesBlock} */
-		this.parentBlock = undefined;
-	}
-}
-
 class ModuleGraph {
 	constructor() {
-		/** @type {Map<Dependency, ModuleGraphDependency>} */
+		/** @type {Map<Dependency, ModuleGraphConnection>} */
 		this._dependencyMap = new Map();
 		/** @type {Map<Module, ModuleGraphModule>} */
 		this._moduleMap = new Map();
@@ -137,23 +126,6 @@ class ModuleGraph {
 		return mgm;
 	}
 
-	/**
-	 * @param {Dependency} dependency the dependency
-	 * @returns {ModuleGraphDependency} the internal dependency
-	 */
-	_getModuleGraphDependency(dependency) {
-		if (this._cacheModuleGraphDependencyKey === dependency)
-			return this._cacheModuleGraphDependencyValue;
-		let mgd = this._dependencyMap.get(dependency);
-		if (mgd === undefined) {
-			mgd = new ModuleGraphDependency();
-			this._dependencyMap.set(dependency, mgd);
-		}
-		this._cacheModuleGraphDependencyKey = dependency;
-		this._cacheModuleGraphDependencyValue = mgd;
-		return mgd;
-	}
-
 	/**
 	 * @param {Dependency} dependency the dependency
 	 * @param {DependenciesBlock} block parent block
@@ -161,9 +133,8 @@ class ModuleGraph {
 	 * @returns {void}
 	 */
 	setParents(dependency, block, module) {
-		const mgd = this._getModuleGraphDependency(dependency);
-		mgd.parentBlock = block;
-		mgd.parentModule = module;
+		dependency._parentDependenciesBlock = block;
+		dependency._parentModule = module;
 	}
 
 	/**
@@ -171,8 +142,7 @@ class ModuleGraph {
 	 * @returns {Module} parent module
 	 */
 	getParentModule(dependency) {
-		const mgd = this._getModuleGraphDependency(dependency);
-		return mgd.parentModule;
+		return dependency._parentModule;
 	}
 
 	/**
@@ -180,8 +150,7 @@ class ModuleGraph {
 	 * @returns {DependenciesBlock} parent block
 	 */
 	getParentBlock(dependency) {
-		const mgd = this._getModuleGraphDependency(dependency);
-		return mgd.parentBlock;
+		return dependency._parentDependenciesBlock;
 	}
 
 	/**
@@ -199,8 +168,7 @@ class ModuleGraph {
 			dependency.weak,
 			dependency.getCondition(this)
 		);
-		const mgd = this._getModuleGraphDependency(dependency);
-		mgd.connection = connection;
+		this._dependencyMap.set(dependency, connection);
 		const connections = this._getModuleGraphModule(module).incomingConnections;
 		connections.add(connection);
 		const mgm = this._getModuleGraphModule(originModule);
@@ -216,12 +184,11 @@ class ModuleGraph {
 	 * @returns {void}
 	 */
 	updateModule(dependency, module) {
-		const mgd = this._getModuleGraphDependency(dependency);
-		if (mgd.connection.module === module) return;
-		const { connection } = mgd;
+		const connection = this._dependencyMap.get(dependency);
+		if (connection.module === module) return;
 		const newConnection = connection.clone();
 		newConnection.module = module;
-		mgd.connection = newConnection;
+		this._dependencyMap.set(dependency, newConnection);
 		connection.setActive(false);
 		const originMgm = this._getModuleGraphModule(connection.originModule);
 		originMgm.outgoingConnections.add(newConnection);
@@ -234,13 +201,12 @@ class ModuleGraph {
 	 * @returns {void}
 	 */
 	removeConnection(dependency) {
-		const mgd = this._getModuleGraphDependency(dependency);
-		const { connection } = mgd;
+		const connection = this._dependencyMap.get(dependency);
 		const targetMgm = this._getModuleGraphModule(connection.module);
 		targetMgm.incomingConnections.delete(connection);
 		const originMgm = this._getModuleGraphModule(connection.originModule);
 		originMgm.outgoingConnections.delete(connection);
-		mgd.connection = undefined;
+		this._dependencyMap.delete(dependency);
 	}
 
 	/**
@@ -249,7 +215,7 @@ class ModuleGraph {
 	 * @returns {void}
 	 */
 	addExplanation(dependency, explanation) {
-		const { connection } = this._getModuleGraphDependency(dependency);
+		const connection = this._dependencyMap.get(dependency);
 		connection.addExplanation(explanation);
 	}
 
@@ -375,7 +341,7 @@ class ModuleGraph {
 	 * @returns {Module} the referenced module
 	 */
 	getResolvedModule(dependency) {
-		const { connection } = this._getModuleGraphDependency(dependency);
+		const connection = this._dependencyMap.get(dependency);
 		return connection !== undefined ? connection.resolvedModule : null;
 	}
 
@@ -384,7 +350,7 @@ class ModuleGraph {
 	 * @returns {ModuleGraphConnection | undefined} the connection
 	 */
 	getConnection(dependency) {
-		const { connection } = this._getModuleGraphDependency(dependency);
+		const connection = this._dependencyMap.get(dependency);
 		return connection;
 	}
 
@@ -393,7 +359,7 @@ class ModuleGraph {
 	 * @returns {Module} the referenced module
 	 */
 	getModule(dependency) {
-		const { connection } = this._getModuleGraphDependency(dependency);
+		const connection = this._dependencyMap.get(dependency);
 		return connection !== undefined ? connection.module : null;
 	}
 
@@ -402,7 +368,7 @@ class ModuleGraph {
 	 * @returns {Module} the referencing module
 	 */
 	getOrigin(dependency) {
-		const { connection } = this._getModuleGraphDependency(dependency);
+		const connection = this._dependencyMap.get(dependency);
 		return connection !== undefined ? connection.originModule : null;
 	}
 
@@ -411,7 +377,7 @@ class ModuleGraph {
 	 * @returns {Module} the original referencing module
 	 */
 	getResolvedOrigin(dependency) {
-		const { connection } = this._getModuleGraphDependency(dependency);
+		const connection = this._dependencyMap.get(dependency);
 		return connection !== undefined ? connection.resolvedOriginModule : null;
 	}
 
@@ -430,7 +396,7 @@ class ModuleGraph {
 	 */
 	getOutgoingConnections(module) {
 		const connections = this._getModuleGraphModule(module).outgoingConnections;
-		return connections === undefined ? EMPTY_ARRAY : connections;
+		return connections === undefined ? EMPTY_SET : connections;
 	}
 
 	/**

package/lib/NormalModuleFactory.js

@@ -520,29 +520,33 @@ class NormalModuleFactory extends ModuleFactory {
 								)
 							);
 						}
-						Object.assign(data.createData, {
-							layer:
-								layer === undefined ? contextInfo.issuerLayer || null : layer,
-							request: stringifyLoadersAndResource(
-								allLoaders,
-								resourceData.resource
-							),
-							userRequest,
-							rawRequest: request,
-							loaders: allLoaders,
-							resource: resourceData.resource,
-							matchResource: matchResourceData
-								? matchResourceData.resource
-								: undefined,
-							resourceResolveData: resourceData.data,
-							settings,
-							type,
-							parser: this.getParser(type, settings.parser),
-							parserOptions: settings.parser,
-							generator: this.getGenerator(type, settings.generator),
-							generatorOptions: settings.generator,
-							resolveOptions
-						});
+						try {
+							Object.assign(data.createData, {
+								layer:
+									layer === undefined ? contextInfo.issuerLayer || null : layer,
+								request: stringifyLoadersAndResource(
+									allLoaders,
+									resourceData.resource
+								),
+								userRequest,
+								rawRequest: request,
+								loaders: allLoaders,
+								resource: resourceData.resource,
+								matchResource: matchResourceData
+									? matchResourceData.resource
+									: undefined,
+								resourceResolveData: resourceData.data,
+								settings,
+								type,
+								parser: this.getParser(type, settings.parser),
+								parserOptions: settings.parser,
+								generator: this.getGenerator(type, settings.generator),
+								generatorOptions: settings.generator,
+								resolveOptions
+							});
+						} catch (e) {
+							return callback(e);
+						}
 						callback();
 					});
 					this.resolveRequestArray(

package/lib/WebpackOptionsApply.js

@@ -569,6 +569,7 @@ class WebpackOptionsApply extends OptionsApply {
 									),
 									snapshot: options.snapshot,
 									maxAge: cacheOptions.maxAge,
+									profile: cacheOptions.profile,
 									allowCollectingMemory: cacheOptions.allowCollectingMemory
 								}),
 								cacheOptions.idleTimeout,

package/lib/buildChunkGraph.js

@@ -997,10 +997,15 @@ const visitModules = (
 	};
 
 	const processChunkGroupsForCombining = () => {
-		loop: for (const info of chunkGroupsForCombining) {
+		for (const info of chunkGroupsForCombining) {
 			for (const source of info.availableSources) {
-				if (!source.minAvailableModules) continue loop;
+				if (!source.minAvailableModules) {
+					chunkGroupsForCombining.delete(info);
+					break;
+				}
 			}
+		}
+		for (const info of chunkGroupsForCombining) {
 			const availableModules = /** @type {ModuleSetPlus} */ (new Set());
 			availableModules.plus = EMPTY_SET;
 			const mergeSet = set => {

package/lib/cache/PackFileCacheStrategy.js

@@ -561,7 +561,40 @@ class PackContentItems {
 		this.map = map;
 	}
 
-	serialize({ write, snapshot, rollback, logger }) {
+	serialize({ write, snapshot, rollback, logger, profile }) {
+		if (profile) {
+			write(false);
+			for (const [key, value] of this.map) {
+				const s = snapshot();
+				try {
+					write(key);
+					const start = process.hrtime();
+					write(value);
+					const durationHr = process.hrtime(start);
+					const duration = durationHr[0] * 1000 + durationHr[1] / 1e6;
+					if (duration > 1) {
+						if (duration > 500)
+							logger.error(`Serialization of '${key}': ${duration} ms`);
+						else if (duration > 50)
+							logger.warn(`Serialization of '${key}': ${duration} ms`);
+						else if (duration > 10)
+							logger.info(`Serialization of '${key}': ${duration} ms`);
+						else if (duration > 5)
+							logger.log(`Serialization of '${key}': ${duration} ms`);
+						else logger.debug(`Serialization of '${key}': ${duration} ms`);
+					}
+				} catch (e) {
+					rollback(s);
+					if (e === NOT_SERIALIZABLE) continue;
+					logger.warn(
+						`Skipped not serializable cache item '${key}': ${e.message}`
+					);
+					logger.debug(e.stack);
+				}
+			}
+			write(null);
+			return;
+		}
 		// Try to serialize all at once
 		const s = snapshot();
 		try {
@@ -590,9 +623,32 @@ class PackContentItems {
 		}
 	}
 
-	deserialize({ read }) {
+	deserialize({ read, logger, profile }) {
 		if (read()) {
 			this.map = read();
+		} else if (profile) {
+			const map = new Map();
+			let key = read();
+			while (key !== null) {
+				const start = process.hrtime();
+				const value = read();
+				const durationHr = process.hrtime(start);
+				const duration = durationHr[0] * 1000 + durationHr[1] / 1e6;
+				if (duration > 1) {
+					if (duration > 100)
+						logger.error(`Deserialization of '${key}': ${duration} ms`);
+					else if (duration > 20)
+						logger.warn(`Deserialization of '${key}': ${duration} ms`);
+					else if (duration > 5)
+						logger.info(`Deserialization of '${key}': ${duration} ms`);
+					else if (duration > 2)
+						logger.log(`Deserialization of '${key}': ${duration} ms`);
+					else logger.debug(`Deserialization of '${key}': ${duration} ms`);
+				}
+				map.set(key, value);
+				key = read();
+			}
+			this.map = map;
 		} else {
 			const map = new Map();
 			let key = read();
@@ -787,6 +843,7 @@ class PackFileCacheStrategy {
 	 * @param {Logger} options.logger a logger
 	 * @param {SnapshotOptions} options.snapshot options regarding snapshotting
 	 * @param {number} options.maxAge max age of cache items
+	 * @param {boolean} options.profile track and log detailed timing information for individual cache items
 	 * @param {boolean} options.allowCollectingMemory allow to collect unused memory created during deserialization
 	 */
 	constructor({
@@ -798,6 +855,7 @@ class PackFileCacheStrategy {
 		logger,
 		snapshot,
 		maxAge,
+		profile,
 		allowCollectingMemory
 	}) {
 		this.fileSerializer = createFileSerializer(fs);
@@ -812,6 +870,7 @@ class PackFileCacheStrategy {
 		this.version = version;
 		this.logger = logger;
 		this.maxAge = maxAge;
+		this.profile = profile;
 		this.allowCollectingMemory = allowCollectingMemory;
 		this.snapshot = snapshot;
 		/** @type {Set<string>} */
@@ -840,7 +899,7 @@ class PackFileCacheStrategy {
 	 * @returns {Promise<Pack>} the pack
 	 */
 	_openPack() {
-		const { logger, cacheLocation, version } = this;
+		const { logger, profile, cacheLocation, version } = this;
 		/** @type {Snapshot} */
 		let buildSnapshot;
 		/** @type {Set<string>} */
@@ -857,6 +916,7 @@ class PackFileCacheStrategy {
 				filename: `${cacheLocation}/index.pack`,
 				extension: ".pack",
 				logger,
+				profile,
 				retainedBuffer: this.allowCollectingMemory
 					? allowCollectingMemory
 					: undefined
@@ -1172,7 +1232,8 @@ class PackFileCacheStrategy {
 						.serialize(content, {
 							filename: `${this.cacheLocation}/index.pack`,
 							extension: ".pack",
-							logger: this.logger
+							logger: this.logger,
+							profile: this.profile
 						})
 						.then(() => {
 							for (const dep of newBuildDependencies) {

package/lib/config/defaults.js

@@ -293,6 +293,7 @@ const applyCacheDefaults = (cache, { name, mode, development }) => {
 			);
 			D(cache, "hashAlgorithm", "md4");
 			D(cache, "store", "pack");
+			D(cache, "profile", false);
 			D(cache, "idleTimeout", 60000);
 			D(cache, "idleTimeoutForInitialStore", 0);
 			D(cache, "maxMemoryGenerations", development ? 5 : Infinity);
@@ -948,7 +949,7 @@ const applyOptimizationDefaults = (
 		A(splitChunks, "defaultSizeTypes", () => ["javascript", "unknown"]);
 		D(splitChunks, "hidePathInfo", production);
 		D(splitChunks, "chunks", "async");
-		D(splitChunks, "usedExports", true);
+		D(splitChunks, "usedExports", optimization.usedExports === true);
 		D(splitChunks, "minChunks", 1);
 		F(splitChunks, "minSize", () => (production ? 20000 : 10000));
 		F(splitChunks, "minRemainingSize", () => (development ? 0 : undefined));

package/lib/config/normalization.js

@@ -131,6 +131,7 @@ const getNormalizedWebpackOptions = config => {
 						type: "filesystem",
 						maxMemoryGenerations: cache.maxMemoryGenerations,
 						maxAge: cache.maxAge,
+						profile: cache.profile,
 						buildDependencies: cloneObject(cache.buildDependencies),
 						cacheDirectory: cache.cacheDirectory,
 						cacheLocation: cache.cacheLocation,

package/lib/dependencies/HarmonyExportInitFragment.js

@@ -48,6 +48,53 @@ class HarmonyExportInitFragment extends InitFragment {
 		this.unusedExports = unusedExports;
 	}
 
+	/**
+	 * @param {HarmonyExportInitFragment[]} fragments all fragments to merge
+	 * @returns {HarmonyExportInitFragment} merged fragment
+	 */
+	mergeAll(fragments) {
+		let exportMap;
+		let exportMapOwned = false;
+		let unusedExports;
+		let unusedExportsOwned = false;
+
+		for (const fragment of fragments) {
+			if (fragment.exportMap.size !== 0) {
+				if (exportMap === undefined) {
+					exportMap = fragment.exportMap;
+					exportMapOwned = false;
+				} else {
+					if (!exportMapOwned) {
+						exportMap = new Map(exportMap);
+						exportMapOwned = true;
+					}
+					for (const [key, value] of fragment.exportMap) {
+						if (!exportMap.has(key)) exportMap.set(key, value);
+					}
+				}
+			}
+			if (fragment.unusedExports.size !== 0) {
+				if (unusedExports === undefined) {
+					unusedExports = fragment.unusedExports;
+					unusedExportsOwned = false;
+				} else {
+					if (!unusedExportsOwned) {
+						unusedExports = new Set(unusedExports);
+						unusedExportsOwned = true;
+					}
+					for (const value of fragment.unusedExports) {
+						unusedExports.add(value);
+					}
+				}
+			}
+		}
+		return new HarmonyExportInitFragment(
+			this.exportsArgument,
+			exportMap,
+			unusedExports
+		);
+	}
+
 	merge(other) {
 		let exportMap;
 		if (this.exportMap.size === 0) {

package/lib/dependencies/NullDependency.js

@@ -19,14 +19,6 @@ class NullDependency extends Dependency {
 	get type() {
 		return "null";
 	}
-
-	serialize({ write }) {
-		write(this.loc);
-	}
-
-	deserialize({ read }) {
-		this.loc = read();
-	}
 }
 
 NullDependency.Template = class NullDependencyTemplate extends (

package/lib/dependencies/WorkerPlugin.js

@@ -9,9 +9,9 @@ const { pathToFileURL } = require("url");
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const CommentCompilationWarning = require("../CommentCompilationWarning");
 const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
-const formatLocation = require("../formatLocation");
 const EnableChunkLoadingPlugin = require("../javascript/EnableChunkLoadingPlugin");
 const { equals } = require("../util/ArrayHelpers");
+const createHash = require("../util/createHash");
 const { contextify } = require("../util/identifier");
 const EnableWasmLoadingPlugin = require("../wasm/EnableWasmLoadingPlugin");
 const ConstDependency = require("./ConstDependency");
@@ -27,6 +27,7 @@ const WorkerDependency = require("./WorkerDependency");
 /** @typedef {import("estree").SpreadElement} SpreadElement */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Entrypoint").EntryOptions} EntryOptions */
+/** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("./HarmonyImportDependencyParserPlugin").HarmonySettings} HarmonySettings */
@@ -42,6 +43,9 @@ const DEFAULT_SYNTAX = [
 	"Worker from worker_threads"
 ];
 
+/** @type {WeakMap<ParserState, number>} */
+const workerIndexMap = new WeakMap();
+
 class WorkerPlugin {
 	constructor(chunkLoading, wasmLoading) {
 		this._chunkLoading = chunkLoading;
@@ -264,9 +268,20 @@ class WorkerPlugin {
 						}
 
 						if (!entryOptions.runtime) {
-							entryOptions.runtime = `${cachedContextify(
+							let i = workerIndexMap.get(parser.state) || 0;
+							workerIndexMap.set(parser.state, i + 1);
+							let name = `${cachedContextify(
 								parser.state.module.identifier()
-							)}|${formatLocation(expr.loc)}`;
+							)}|${i}`;
+							const hash = createHash(compilation.outputOptions.hashFunction);
+							hash.update(name);
+							const digest = /** @type {string} */ (hash.digest(
+								compilation.outputOptions.hashDigest
+							));
+							entryOptions.runtime = digest.slice(
+								0,
+								compilation.outputOptions.hashDigestLength
+							);
 						}
 
 						const block = new AsyncDependenciesBlock({

package/lib/javascript/ArrayPushCallbackChunkFormatPlugin.js

@@ -124,6 +124,13 @@ class ArrayPushCallbackChunkFormatPlugin {
 											}
 										)
 									);
+									if (
+										chunkGraph
+											.getChunkRuntimeRequirements(chunk)
+											.has(RuntimeGlobals.returnExportsFromRuntime)
+									) {
+										runtime.add("return __webpack_exports__;\n");
+									}
 								}
 								runtime.add("}\n");
 								source.add(",\n");

package/lib/javascript/JavascriptModulesPlugin.js

@@ -625,8 +625,9 @@ class JavascriptModulesPlugin {
 			) || []
 		);
 
+		const hasEntryModules = chunkGraph.getNumberOfEntryModules(chunk) > 0;
 		let inlinedModules;
-		if (bootstrap.allowInlineStartup) {
+		if (bootstrap.allowInlineStartup && hasEntryModules) {
 			inlinedModules = new Set(chunkGraph.getChunkEntryModulesIterable(chunk));
 		}
 
@@ -836,7 +837,10 @@ class JavascriptModulesPlugin {
 				)
 			);
 		}
-		if (runtimeRequirements.has(RuntimeGlobals.returnExportsFromRuntime)) {
+		if (
+			hasEntryModules &&
+			runtimeRequirements.has(RuntimeGlobals.returnExportsFromRuntime)
+		) {
 			source.add(`${prefix}return __webpack_exports__;\n`);
 		}
 		if (iife) {