webpack 5.35.1 → 5.37.0

package/lib/Chunk.js

@@ -568,9 +568,15 @@ class Chunk {
 			Array.from(this.groupsIterable, g => new Set(g.chunks))
 		);
 
-		for (const chunkGroup of this.groupsIterable) {
+		const initialQueue = new Set(this.groupsIterable);
+
+		for (const chunkGroup of initialQueue) {
 			for (const child of chunkGroup.childrenIterable) {
-				queue.add(child);
+				if (child instanceof Entrypoint) {
+					initialQueue.add(child);
+				} else {
+					queue.add(child);
+				}
 			}
 		}
 

package/lib/ChunkGraph.js

@@ -1446,17 +1446,37 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 				runtime
 			).toString(16);
 			const connections = this.moduleGraph.getOutgoingConnections(module);
+			/** @type {Set<Module>} */
+			const activeNamespaceModules = new Set();
 			/** @type {Map<string, Module | Set<Module>>} */
 			const connectedModules = new Map();
-			for (const connection of connections) {
-				let stateInfo;
-				if (typeof runtime === "string") {
+			const processConnection = (connection, stateInfo) => {
+				const module = connection.module;
+				stateInfo += module.getExportsType(this.moduleGraph, strict);
+				// cspell:word Tnamespace
+				if (stateInfo === "Tnamespace") activeNamespaceModules.add(module);
+				else {
+					const oldModule = connectedModules.get(stateInfo);
+					if (oldModule === undefined) {
+						connectedModules.set(stateInfo, module);
+					} else if (oldModule instanceof Set) {
+						oldModule.add(module);
+					} else if (oldModule !== module) {
+						connectedModules.set(stateInfo, new Set([oldModule, module]));
+					}
+				}
+			};
+			if (runtime === undefined || typeof runtime === "string") {
+				for (const connection of connections) {
 					const state = connection.getActiveState(runtime);
 					if (state === false) continue;
-					stateInfo = activeStateToString(state);
-				} else {
+					processConnection(connection, state === true ? "T" : "O");
+				}
+			} else {
+				// cspell:word Tnamespace
+				for (const connection of connections) {
 					const states = new Set();
-					stateInfo = "";
+					let stateInfo = "";
 					forEachRuntime(
 						runtime,
 						runtime => {
@@ -1471,46 +1491,49 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 						if (state === false) continue;
 						stateInfo = activeStateToString(state);
 					}
-				}
-				const module = connection.module;
-				stateInfo += module.getExportsType(this.moduleGraph, strict);
-				const oldModule = connectedModules.get(stateInfo);
-				if (oldModule === undefined) {
-					connectedModules.set(stateInfo, module);
-				} else if (oldModule instanceof Set) {
-					oldModule.add(module);
-				} else if (oldModule !== module) {
-					connectedModules.set(stateInfo, new Set([oldModule, module]));
+					processConnection(connection, stateInfo);
 				}
 			}
-			if (connectedModules.size === 0) return graphHash;
+			// cspell:word Tnamespace
+			if (activeNamespaceModules.size === 0 && connectedModules.size === 0)
+				return graphHash;
 			const connectedModulesInOrder =
 				connectedModules.size > 1
 					? Array.from(connectedModules).sort(([a], [b]) => (a < b ? -1 : 1))
 					: connectedModules;
 			const hash = createHash("md4");
+			const addModuleToHash = module => {
+				hash.update(
+					this._getModuleGraphHashBigInt(
+						this._getChunkGraphModule(module),
+						module,
+						runtime
+					).toString(16)
+				);
+			};
+			const addModulesToHash = modules => {
+				let xor = ZERO_BIG_INT;
+				for (const m of modules) {
+					xor =
+						xor ^
+						this._getModuleGraphHashBigInt(
+							this._getChunkGraphModule(m),
+							m,
+							runtime
+						);
+				}
+				hash.update(xor.toString(16));
+			};
+			if (activeNamespaceModules.size === 1)
+				addModuleToHash(activeNamespaceModules.values().next().value);
+			else if (activeNamespaceModules.size > 1)
+				addModulesToHash(activeNamespaceModules);
 			for (const [stateInfo, modules] of connectedModulesInOrder) {
 				hash.update(stateInfo);
 				if (modules instanceof Set) {
-					let xor = ZERO_BIG_INT;
-					for (const m of modules) {
-						xor =
-							xor ^
-							this._getModuleGraphHashBigInt(
-								this._getChunkGraphModule(m),
-								m,
-								runtime
-							);
-					}
-					hash.update(xor.toString(16));
+					addModulesToHash(modules);
 				} else {
-					hash.update(
-						this._getModuleGraphHashBigInt(
-							this._getChunkGraphModule(modules),
-							modules,
-							runtime
-						).toString(16)
-					);
+					addModuleToHash(modules);
 				}
 			}
 			hash.update(graphHash);

package/lib/Compilation.js

@@ -1375,84 +1375,114 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	 * @returns {void}
 	 */
 	_processModuleDependencies(module, callback) {
-		const dependencies = new Map();
-
 		/**
 		 * @type {Array<{factory: ModuleFactory, dependencies: Dependency[], originModule: Module|null}>}
 		 */
 		const sortedDependencies = [];
 
-		let currentBlock = module;
+		/** @type {DependenciesBlock} */
+		let currentBlock;
 
+		/** @type {Map<ModuleFactory, Map<string, Dependency[]>>} */
+		let dependencies;
+		/** @type {DepConstructor} */
 		let factoryCacheKey;
+		/** @type {ModuleFactory} */
+		let factoryCacheKey2;
+		/** @type {Map<string, Dependency[]>} */
 		let factoryCacheValue;
-		let factoryCacheValue2;
-		let listCacheKey;
+		/** @type {string} */
+		let listCacheKey1;
+		/** @type {string} */
+		let listCacheKey2;
+		/** @type {Dependency[]} */
 		let listCacheValue;
 
+		/**
+		 * @param {Dependency} dep dependency
+		 * @returns {void}
+		 */
 		const processDependency = dep => {
 			this.moduleGraph.setParents(dep, currentBlock, module);
 			const resourceIdent = dep.getResourceIdentifier();
-			if (resourceIdent) {
-				// Here webpack is using heuristic that assumes
-				// mostly esm dependencies would be used
-				// so we don't allocate extra string for them
+			if (resourceIdent !== undefined && resourceIdent !== null) {
 				const category = dep.category;
-				const cacheKey =
-					category === esmDependencyCategory
-						? resourceIdent
-						: `${category}${resourceIdent}`;
-				const constructor = dep.constructor;
-				let innerMap;
-				let factory;
+				const constructor = /** @type {DepConstructor} */ (dep.constructor);
 				if (factoryCacheKey === constructor) {
-					innerMap = factoryCacheValue;
-					if (listCacheKey === cacheKey) {
+					// Fast path 1: same constructor as prev item
+					if (listCacheKey1 === category && listCacheKey2 === resourceIdent) {
+						// Super fast path 1: also same resource
 						listCacheValue.push(dep);
 						return;
 					}
 				} else {
-					factory = this.dependencyFactories.get(dep.constructor);
+					const factory = this.dependencyFactories.get(constructor);
 					if (factory === undefined) {
 						throw new Error(
-							`No module factory available for dependency type: ${dep.constructor.name}`
+							`No module factory available for dependency type: ${constructor.name}`
 						);
 					}
-					innerMap = dependencies.get(factory);
-					if (innerMap === undefined) {
-						dependencies.set(factory, (innerMap = new Map()));
+					if (factoryCacheKey2 === factory) {
+						// Fast path 2: same factory as prev item
+						factoryCacheKey = constructor;
+						if (listCacheKey1 === category && listCacheKey2 === resourceIdent) {
+							// Super fast path 2: also same resource
+							listCacheValue.push(dep);
+							return;
+						}
+					} else {
+						// Slow path
+						if (factoryCacheKey2 !== undefined) {
+							// Archive last cache entry
+							if (dependencies === undefined) dependencies = new Map();
+							dependencies.set(factoryCacheKey2, factoryCacheValue);
+							factoryCacheValue = dependencies.get(factory);
+							if (factoryCacheValue === undefined) {
+								factoryCacheValue = new Map();
+							}
+						} else {
+							factoryCacheValue = new Map();
+						}
+						factoryCacheKey = constructor;
+						factoryCacheKey2 = factory;
 					}
-					factoryCacheKey = constructor;
-					factoryCacheValue = innerMap;
-					factoryCacheValue2 = factory;
 				}
-				let list = innerMap.get(cacheKey);
+				// Here webpack is using heuristic that assumes
+				// mostly esm dependencies would be used
+				// so we don't allocate extra string for them
+				const cacheKey =
+					category === esmDependencyCategory
+						? resourceIdent
+						: `${category}${resourceIdent}`;
+				let list = factoryCacheValue.get(cacheKey);
 				if (list === undefined) {
-					innerMap.set(cacheKey, (list = []));
+					factoryCacheValue.set(cacheKey, (list = []));
 					sortedDependencies.push({
-						factory: factoryCacheValue2,
+						factory: factoryCacheKey2,
 						dependencies: list,
 						originModule: module
 					});
 				}
 				list.push(dep);
-				listCacheKey = cacheKey;
+				listCacheKey1 = category;
+				listCacheKey2 = resourceIdent;
 				listCacheValue = list;
 			}
 		};
 
-		const processDependenciesBlock = block => {
-			if (block.dependencies) {
-				currentBlock = block;
-				for (const dep of block.dependencies) processDependency(dep);
-			}
-			if (block.blocks) {
-				for (const b of block.blocks) processDependenciesBlock(b);
-			}
-		};
-
 		try {
-			processDependenciesBlock(module);
+			/** @type {DependenciesBlock[]} */
+			const queue = [module];
+			do {
+				const block = queue.pop();
+				if (block.dependencies) {
+					currentBlock = block;
+					for (const dep of block.dependencies) processDependency(dep);
+				}
+				if (block.blocks) {
+					for (const b of block.blocks) queue.push(b);
+				}
+			} while (queue.length !== 0);
 		} catch (e) {
 			return callback(e);
 		}
@@ -3963,8 +3993,8 @@ This prevents using hashes of each other and should be avoided.`);
 	 * from parent (or top level compiler) and creates a child Compilation
 	 *
 	 * @param {string} name name of the child compiler
-	 * @param {OutputOptions} outputOptions // Need to convert config schema to types for this
-	 * @param {Array<WebpackPluginInstance | WebpackPluginFunction>} plugins webpack plugins that will be applied
+	 * @param {OutputOptions=} outputOptions // Need to convert config schema to types for this
+	 * @param {Array<WebpackPluginInstance | WebpackPluginFunction>=} plugins webpack plugins that will be applied
 	 * @returns {Compiler} creates a child Compiler instance
 	 */
 	createChildCompiler(name, outputOptions, plugins) {

package/lib/Compiler.js

@@ -263,6 +263,8 @@ class Compiler {
 		this._assetEmittingSourceCache = new WeakMap();
 		/** @private @type {Map<string, number>} */
 		this._assetEmittingWrittenFiles = new Map();
+		/** @private @type {Set<string>} */
+		this._assetEmittingPreviousFiles = new Set();
 	}
 
 	/**
@@ -556,6 +558,8 @@ class Compiler {
 			compilation.assets = { ...compilation.assets };
 			/** @type {Map<string, { path: string, source: Source, size: number, waiting: { cacheEntry: any, file: string }[] }>} */
 			const caseInsensitiveMap = new Map();
+			/** @type {Set<string>} */
+			const allTargetPaths = new Set();
 			asyncLib.forEachLimit(
 				assets,
 				15,
@@ -583,6 +587,7 @@ class Compiler {
 							outputPath,
 							targetFile
 						);
+						allTargetPaths.add(targetPath);
 
 						// check if the target file has already been written by this Compiler
 						const targetFileGeneration = this._assetEmittingWrittenFiles.get(
@@ -775,18 +780,22 @@ ${other}`);
 							// check if the Source has been written to this target file
 							const writtenGeneration = cacheEntry.writtenTo.get(targetPath);
 							if (writtenGeneration === targetFileGeneration) {
-								// if yes, we skip writing the file
-								// as it's already there
-								// (we assume one doesn't remove files while the Compiler is running)
+								// if yes, we may skip writing the file
+								// if it's already there
+								// (we assume one doesn't modify files while the Compiler is running, other then removing them)
 
-								compilation.updateAsset(file, cacheEntry.sizeOnlySource, {
-									size: cacheEntry.sizeOnlySource.size()
-								});
-
-								return callback();
-							}
+								if (this._assetEmittingPreviousFiles.has(targetPath)) {
+									// We assume that assets from the last compilation say intact on disk (they are not removed)
+									compilation.updateAsset(file, cacheEntry.sizeOnlySource, {
+										size: cacheEntry.sizeOnlySource.size()
+									});
 
-							if (!immutable) {
+									return callback();
+								} else {
+									// Settings immutable will make it accept file content without comparing when file exist
+									immutable = true;
+								}
+							} else if (!immutable) {
 								if (checkSimilarFile()) return;
 								// We wrote to this file before which has very likely a different content
 								// skip comparing and assume content is different for performance
@@ -822,7 +831,12 @@ ${other}`);
 				err => {
 					// Clear map to free up memory
 					caseInsensitiveMap.clear();
-					if (err) return callback(err);
+					if (err) {
+						this._assetEmittingPreviousFiles.clear();
+						return callback(err);
+					}
+
+					this._assetEmittingPreviousFiles = allTargetPaths;
 
 					this.hooks.afterEmit.callAsync(compilation, err => {
 						if (err) return callback(err);
@@ -917,8 +931,8 @@ ${other}`);
 	 * @param {Compilation} compilation the compilation
 	 * @param {string} compilerName the compiler's name
 	 * @param {number} compilerIndex the compiler's index
-	 * @param {OutputOptions} outputOptions the output options
-	 * @param {WebpackPluginInstance[]} plugins the plugins to apply
+	 * @param {OutputOptions=} outputOptions the output options
+	 * @param {WebpackPluginInstance[]=} plugins the plugins to apply
 	 * @returns {Compiler} a child compiler
 	 */
 	createChildCompiler(

package/lib/Dependency.js

@@ -95,8 +95,13 @@ class Dependency {
 		// TODO check if this can be moved into ModuleDependency
 		/** @type {boolean} */
 		this.optional = false;
-		/** @type {DependencyLocation} */
-		this.loc = undefined;
+		this._locSL = 0;
+		this._locSC = 0;
+		this._locEL = 0;
+		this._locEC = 0;
+		this._locI = undefined;
+		this._locN = undefined;
+		this._loc = undefined;
 	}
 
 	/**
@@ -113,6 +118,56 @@ class Dependency {
 		return "unknown";
 	}
 
+	/**
+	 * @returns {DependencyLocation} location
+	 */
+	get loc() {
+		if (this._loc !== undefined) return this._loc;
+		/** @type {SyntheticDependencyLocation & RealDependencyLocation} */
+		const loc = {};
+		if (this._locSL > 0) {
+			loc.start = { line: this._locSL, column: this._locSC };
+		}
+		if (this._locEL > 0) {
+			loc.end = { line: this._locEL, column: this._locEC };
+		}
+		if (this._locN !== undefined) {
+			loc.name = this._locN;
+		}
+		if (this._locI !== undefined) {
+			loc.index = this._locI;
+		}
+		return (this._loc = loc);
+	}
+
+	set loc(loc) {
+		if ("start" in loc && typeof loc.start === "object") {
+			this._locSL = loc.start.line || 0;
+			this._locSC = loc.start.column || 0;
+		} else {
+			this._locSL = 0;
+			this._locSC = 0;
+		}
+		if ("end" in loc && typeof loc.end === "object") {
+			this._locEL = loc.end.line || 0;
+			this._locEC = loc.end.column || 0;
+		} else {
+			this._locEL = 0;
+			this._locEC = 0;
+		}
+		if ("index" in loc) {
+			this._locI = loc.index;
+		} else {
+			this._locI = undefined;
+		}
+		if ("name" in loc) {
+			this._locN = loc.name;
+		} else {
+			this._locN = undefined;
+		}
+		this._loc = loc;
+	}
+
 	/**
 	 * @returns {string | null} an identifier to merge equal requests
 	 */
@@ -212,13 +267,23 @@ class Dependency {
 	serialize({ write }) {
 		write(this.weak);
 		write(this.optional);
-		write(this.loc);
+		write(this._locSL);
+		write(this._locSC);
+		write(this._locEL);
+		write(this._locEC);
+		write(this._locI);
+		write(this._locN);
 	}
 
 	deserialize({ read }) {
 		this.weak = read();
 		this.optional = read();
-		this.loc = read();
+		this._locSL = read();
+		this._locSC = read();
+		this._locEL = read();
+		this._locEC = read();
+		this._locI = read();
+		this._locN = read();
 	}
 }
 

package/lib/EntryPlugin.js

@@ -17,7 +17,7 @@ class EntryPlugin {
 	 *
 	 * @param {string} context context path
 	 * @param {string} entry entry path
-	 * @param {EntryOptions | string} options entry options (passing a string is deprecated)
+	 * @param {EntryOptions | string=} options entry options (passing a string is deprecated)
 	 */
 	constructor(context, entry, options) {
 		this.context = context;

package/lib/FileSystemInfo.js

@@ -1472,7 +1472,7 @@ class FileSystemInfo {
 							}
 						} else if (supportsEsm && /\.m?js$/.test(path)) {
 							if (!this._warnAboutExperimentalEsmTracking) {
-								this.logger.info(
+								this.logger.log(
 									"Node.js doesn't offer a (nice) way to introspect the ESM dependency graph yet.\n" +
 										"Until a full solution is available webpack uses an experimental ESM tracking based on parsing.\n" +
 										"As best effort webpack parses the ESM files to guess dependencies. But this can lead to expensive and incorrect tracking."

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
@@ -396,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/NormalModule.js

@@ -41,10 +41,12 @@ const { contextify, absolutify } = require("./util/identifier");
 const makeSerializable = require("./util/makeSerializable");
 const memoize = require("./util/memoize");
 
-/** @typedef {import("source-map").RawSourceMap} SourceMap */
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/LoaderContext").NormalModuleLoaderContext} NormalModuleLoaderContext */
+/** @typedef {import("../declarations/WebpackOptions").Mode} Mode */
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
 /** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("./DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("./Generator")} Generator */
@@ -60,10 +62,22 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("./logging/Logger").Logger} WebpackLogger */
 /** @typedef {import("./util/Hash")} Hash */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
+/**
+ * @typedef {Object} SourceMap
+ * @property {number} version
+ * @property {string[]} sources
+ * @property {string} mappings
+ * @property {string=} file
+ * @property {string=} sourceRoot
+ * @property {string[]=} sourcesContent
+ * @property {string[]=} names
+ */
+
 const getInvalidDependenciesModuleWarning = memoize(() =>
 	require("./InvalidDependenciesModuleWarning")
 );
@@ -421,7 +435,7 @@ class NormalModule extends Module {
 	 * @param {WebpackOptions} options webpack options
 	 * @param {Compilation} compilation the compilation
 	 * @param {InputFileSystem} fs file system from reading
-	 * @returns {any} loader context
+	 * @returns {NormalModuleLoaderContext} loader context
 	 */
 	createLoaderContext(resolver, options, compilation, fs) {
 		const { requestShortener } = compilation.runtimeTemplate;

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(