webpack 5.56.1 → 5.58.1

package/lib/buildChunkGraph.js

@@ -43,7 +43,7 @@ const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
  * @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 {Set<[Module, ConnectionState]>=} 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
@@ -70,97 +70,106 @@ 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;
+const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
+	let blockCache;
+	let modules;
+
+	const arrays = [];
+
+	const queue = [module];
+	while (queue.length > 0) {
+		const block = queue.pop();
+		const arr = [];
+		arrays.push(arr);
+		blockModulesMap.set(block, arr);
+		for (const b of block.blocks) {
+			queue.push(b);
+		}
 	}
-	return merged;
-};
 
-/**
- * Extracts block to modules mapping from all modules
- * @param {Compilation} compilation the compilation
- * @returns {Map<DependenciesBlock, Map<Module, ModuleGraphConnection[]>>} the mapping block to modules
- */
-const extractBlockModulesMap = compilation => {
-	const { moduleGraph } = compilation;
-
-	/** @type {Map<DependenciesBlock, Map<Module, ModuleGraphConnection[]>>} */
-	const blockModulesMap = new Map();
-
-	const blockQueue = new Set();
-
-	for (const module of compilation.modules) {
-		/** @type {WeakMap<Dependency, ModuleGraphConnection>} */
-		let moduleMap;
-
-		for (const connection of moduleGraph.getOutgoingConnections(module)) {
-			const d = connection.dependency;
-			// We skip connections without dependency
-			if (!d) continue;
-			const m = connection.module;
-			// We skip connections without Module pointer
-			if (!m) continue;
-			// We skip weak connections
-			if (connection.weak) continue;
-			const state = connection.getActiveState(undefined);
-			// We skip inactive connections
-			if (state === false) continue;
-			// Store Dependency to Module mapping in local map
-			// to allow to access it faster compared to
-			// moduleGraph.getConnection()
-			if (moduleMap === undefined) {
-				moduleMap = new WeakMap();
-			}
-			moduleMap.set(connection.dependency, connection);
+	for (const connection of moduleGraph.getOutgoingConnections(module)) {
+		const d = connection.dependency;
+		// We skip connections without dependency
+		if (!d) continue;
+		const m = connection.module;
+		// We skip connections without Module pointer
+		if (!m) continue;
+		// We skip weak connections
+		if (connection.weak) continue;
+		const state = connection.getActiveState(runtime);
+		// We skip inactive connections
+		if (state === false) continue;
+
+		const block = moduleGraph.getParentBlock(d);
+		let index = moduleGraph.getParentBlockIndex(d);
+
+		// deprecated fallback
+		if (index < 0) {
+			index = block.dependencies.indexOf(d);
 		}
 
-		blockQueue.clear();
-		blockQueue.add(module);
-		for (const block of blockQueue) {
-			let modules;
-
-			if (moduleMap !== undefined && block.dependencies) {
-				for (const dep of block.dependencies) {
-					const connection = moduleMap.get(dep);
-					if (connection !== undefined) {
-						const { module } = connection;
-						if (modules === undefined) {
-							modules = new Map();
-							blockModulesMap.set(block, modules);
-						}
-						const old = modules.get(module);
-						if (old !== undefined) {
-							old.push(connection);
-						} else {
-							modules.set(module, [connection]);
-						}
+		if (blockCache !== block) {
+			modules = blockModulesMap.get((blockCache = block));
+		}
+
+		const i = index << 2;
+		modules[i] = m;
+		modules[i + 1] = state;
+	}
+
+	for (const modules of arrays) {
+		if (modules.length === 0) continue;
+		let indexMap;
+		let length = 0;
+		outer: for (let j = 0; j < modules.length; j += 2) {
+			const m = modules[j];
+			if (m === undefined) continue;
+			const state = modules[j + 1];
+			if (indexMap === undefined) {
+				let i = 0;
+				for (; i < length; i += 2) {
+					if (modules[i] === m) {
+						const merged = modules[i + 1];
+						if (merged === true) continue outer;
+						modules[i + 1] = ModuleGraphConnection.addConnectionStates(
+							merged,
+							state
+						);
 					}
 				}
-			}
-
-			if (block.blocks) {
-				for (const b of block.blocks) {
-					blockQueue.add(b);
+				modules[length] = m;
+				length++;
+				modules[length] = state;
+				length++;
+				if (length > 30) {
+					// To avoid worse case performance, we will use an index map for
+					// linear cost access, which allows to maintain O(n) complexity
+					// while keeping allocations down to a minimum
+					indexMap = new Map();
+					for (let i = 0; i < length; i += 2) {
+						indexMap.set(modules[i], i + 1);
+					}
+				}
+			} else {
+				const idx = indexMap.get(m);
+				if (idx !== undefined) {
+					const merged = modules[idx];
+					if (merged === true) continue outer;
+					modules[idx] = ModuleGraphConnection.addConnectionStates(
+						merged,
+						state
+					);
+				} else {
+					modules[length] = m;
+					length++;
+					modules[length] = state;
+					indexMap.set(m, length);
+					length++;
 				}
 			}
 		}
+		modules.length = length;
 	}
-
-	return blockModulesMap;
 };
 
 /**
@@ -182,10 +191,55 @@ const visitModules = (
 	blocksWithNestedBlocks,
 	allCreatedChunkGroups
 ) => {
-	const { moduleGraph, chunkGraph } = compilation;
+	const { moduleGraph, chunkGraph, moduleMemCaches } = compilation;
 
-	logger.time("visitModules: prepare");
-	const blockModulesMap = extractBlockModulesMap(compilation);
+	const blockModulesRuntimeMap = new Map();
+
+	/** @type {RuntimeSpec | false} */
+	let blockModulesMapRuntime = false;
+	let blockModulesMap;
+
+	/**
+	 *
+	 * @param {DependenciesBlock} block block
+	 * @param {RuntimeSpec} runtime runtime
+	 * @returns {(Module | ConnectionState)[]} block modules in flatten tuples
+	 */
+	const getBlockModules = (block, runtime) => {
+		if (blockModulesMapRuntime !== runtime) {
+			blockModulesMap = blockModulesRuntimeMap.get(runtime);
+			if (blockModulesMap === undefined) {
+				blockModulesMap = new Map();
+				blockModulesRuntimeMap.set(runtime, blockModulesMap);
+			}
+		}
+		let blockModules = blockModulesMap.get(block);
+		if (blockModules !== undefined) return blockModules;
+		const module = /** @type {Module} */ (block.getRootBlock());
+		const memCache = moduleMemCaches && moduleMemCaches.get(module);
+		if (memCache !== undefined) {
+			const map = memCache.provide(
+				"bundleChunkGraph.blockModules",
+				runtime,
+				() => {
+					logger.time("visitModules: prepare");
+					const map = new Map();
+					extractBlockModules(module, moduleGraph, runtime, map);
+					logger.timeAggregate("visitModules: prepare");
+					return map;
+				}
+			);
+			for (const [block, blockModules] of map)
+				blockModulesMap.set(block, blockModules);
+			return map.get(block);
+		} else {
+			logger.time("visitModules: prepare");
+			extractBlockModules(module, moduleGraph, runtime, blockModulesMap);
+			blockModules = blockModulesMap.get(block);
+			logger.timeAggregate("visitModules: prepare");
+			return blockModules;
+		}
+	};
 
 	let statProcessedQueueItems = 0;
 	let statProcessedBlocks = 0;
@@ -308,9 +362,7 @@ const visitModules = (
 	/** @type {QueueItem[]} */
 	let queueDelayed = [];
 
-	logger.timeEnd("visitModules: prepare");
-
-	/** @type {[Module, ModuleGraphConnection[]][]} */
+	/** @type {[Module, ConnectionState][]} */
 	const skipConnectionBuffer = [];
 	/** @type {Module[]} */
 	const skipBuffer = [];
@@ -478,21 +530,23 @@ const visitModules = (
 	const processBlock = block => {
 		statProcessedBlocks++;
 		// get prepared block info
-		const blockModules = blockModulesMap.get(block);
+		const blockModules = getBlockModules(block, chunkGroupInfo.runtime);
 
 		if (blockModules !== undefined) {
-			const { minAvailableModules, runtime } = chunkGroupInfo;
+			const { minAvailableModules } = chunkGroupInfo;
 			// Buffer items because order need to be reversed to get indices correct
 			// Traverse all referenced modules
-			for (const entry of blockModules) {
-				const [refModule, connections] = entry;
+			for (let i = 0; i < blockModules.length; i += 2) {
+				const refModule = /** @type {Module} */ (blockModules[i]);
 				if (chunkGraph.isModuleInChunk(refModule, chunk)) {
 					// skip early if already connected
 					continue;
 				}
-				const activeState = getActiveStateOfConnections(connections, runtime);
+				const activeState = /** @type {ConnectionState} */ (
+					blockModules[i + 1]
+				);
 				if (activeState !== true) {
-					skipConnectionBuffer.push(entry);
+					skipConnectionBuffer.push([refModule, activeState]);
 					if (activeState === false) continue;
 				}
 				if (
@@ -562,12 +616,15 @@ const visitModules = (
 	const processEntryBlock = block => {
 		statProcessedBlocks++;
 		// get prepared block info
-		const blockModules = blockModulesMap.get(block);
+		const blockModules = getBlockModules(block, chunkGroupInfo.runtime);
 
 		if (blockModules !== undefined) {
 			// Traverse all referenced modules
-			for (const [refModule, connections] of blockModules) {
-				const activeState = getActiveStateOfConnections(connections, undefined);
+			for (let i = 0; i < blockModules.length; i += 2) {
+				const refModule = /** @type {Module} */ (blockModules[i]);
+				const activeState = /** @type {ConnectionState} */ (
+					blockModules[i + 1]
+				);
 				// enqueue, then add and enter to be in the correct order
 				// this is relevant with circular dependencies
 				queueBuffer.push({
@@ -1059,10 +1116,9 @@ const visitModules = (
 
 			// 2. Reconsider skipped connections
 			if (info.skippedModuleConnections !== undefined) {
-				const { minAvailableModules, runtime } = info;
+				const { minAvailableModules } = info;
 				for (const entry of info.skippedModuleConnections) {
-					const [module, connections] = entry;
-					const activeState = getActiveStateOfConnections(connections, runtime);
+					const [module, activeState] = entry;
 					if (activeState === false) continue;
 					if (activeState === true) {
 						info.skippedModuleConnections.delete(entry);
@@ -1114,6 +1170,7 @@ const visitModules = (
 	while (queue.length || queueConnect.size) {
 		logger.time("visitModules: visiting");
 		processQueue();
+		logger.timeAggregateEnd("visitModules: prepare");
 		logger.timeEnd("visitModules: visiting");
 
 		if (chunkGroupsForCombining.size > 0) {

package/lib/javascript/ArrayPushCallbackChunkFormatPlugin.js

@@ -137,11 +137,9 @@ class ArrayPushCallbackChunkFormatPlugin {
 					"ArrayPushCallbackChunkFormatPlugin",
 					(chunk, hash, { chunkGraph, runtimeTemplate }) => {
 						if (chunk.hasRuntime()) return;
-						hash.update("ArrayPushCallbackChunkFormatPlugin");
-						hash.update("1");
-						hash.update(`${runtimeTemplate.outputOptions.chunkLoadingGlobal}`);
-						hash.update(`${runtimeTemplate.outputOptions.hotUpdateGlobal}`);
-						hash.update(`${runtimeTemplate.outputOptions.globalObject}`);
+						hash.update(
+							`ArrayPushCallbackChunkFormatPlugin1${runtimeTemplate.outputOptions.chunkLoadingGlobal}${runtimeTemplate.outputOptions.hotUpdateGlobal}${runtimeTemplate.outputOptions.globalObject}`
+						);
 						const entries = Array.from(
 							chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
 						);

package/lib/logging/Logger.js

@@ -155,6 +155,7 @@ class WebpackLogger {
 		if (this[TIMERS_AGGREGATES_SYMBOL] === undefined) return;
 		const time = this[TIMERS_AGGREGATES_SYMBOL].get(label);
 		if (time === undefined) return;
+		this[TIMERS_AGGREGATES_SYMBOL].delete(label);
 		this[LOG_SYMBOL](LogType.time, [label, ...time]);
 	}
 }

package/lib/node/NodeTargetPlugin.js

@@ -19,6 +19,7 @@ const builtins = [
 	"constants",
 	"crypto",
 	"dgram",
+	"diagnostics_channel",
 	"dns",
 	"dns/promises",
 	"domain",

package/lib/optimize/EnsureChunkConditionsPlugin.js

@@ -30,6 +30,7 @@ class EnsureChunkConditionsPlugin {
 					/** @type {Set<ChunkGroup>} */
 					const chunkGroups = new Set();
 					for (const module of compilation.modules) {
+						if (!module.hasChunkCondition()) continue;
 						for (const chunk of chunkGraph.getModuleChunksIterable(module)) {
 							if (!module.chunkCondition(chunk, compilation)) {
 								sourceChunks.add(chunk);

package/lib/optimize/MangleExportsPlugin.js

@@ -157,6 +157,11 @@ class MangleExportsPlugin {
 			compilation.hooks.optimizeCodeGeneration.tap(
 				"MangleExportsPlugin",
 				modules => {
+					if (compilation.moduleMemCaches) {
+						throw new Error(
+							"optimization.mangleExports can't be used with cacheUnaffected as export mangling is a global effect"
+						);
+					}
 					for (const module of modules) {
 						const isNamespace =
 							module.buildMeta && module.buildMeta.exportsType === "namespace";

package/lib/schemes/FileUriPlugin.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const { URL, fileURLToPath } = require("url");
+const { NormalModule } = require("..");
 
 /** @typedef {import("../Compiler")} Compiler */
 
@@ -32,6 +33,14 @@ class FileUriPlugin {
 						resourceData.resource = path + query + fragment;
 						return true;
 					});
+				const hooks = NormalModule.getCompilationHooks(compilation);
+				hooks.readResource
+					.for(undefined)
+					.tapAsync("FileUriPlugin", (loaderContext, callback) => {
+						const { resourcePath } = loaderContext;
+						loaderContext.addDependency(resourcePath);
+						loaderContext.fs.readFile(resourcePath, callback);
+					});
 			}
 		);
 	}

package/lib/util/StringXor.js

@@ -8,41 +8,47 @@
 class StringXor {
 	constructor() {
 		this._value = undefined;
-		this._buffer = undefined;
 	}
 
+	/**
+	 * @param {string} str string
+	 * @returns {void}
+	 */
 	add(str) {
-		let buf = this._buffer;
-		let value;
-		if (buf === undefined) {
-			buf = this._buffer = Buffer.from(str, "latin1");
-			this._value = Buffer.from(buf);
+		const len = str.length;
+		const value = this._value;
+		if (value === undefined) {
+			const newValue = (this._value = Buffer.allocUnsafe(len));
+			for (let i = 0; i < len; i++) {
+				newValue[i] = str.charCodeAt(i);
+			}
 			return;
-		} else if (buf.length !== str.length) {
-			value = this._value;
-			buf = this._buffer = Buffer.from(str, "latin1");
-			if (value.length < buf.length) {
-				this._value = Buffer.allocUnsafe(buf.length);
-				value.copy(this._value);
-				this._value.fill(0, value.length);
-				value = this._value;
+		}
+		const valueLen = value.length;
+		if (valueLen < len) {
+			const newValue = (this._value = Buffer.allocUnsafe(len));
+			let i;
+			for (i = 0; i < valueLen; i++) {
+				newValue[i] = value[i] ^ str.charCodeAt(i);
+			}
+			for (; i < len; i++) {
+				newValue[i] = str.charCodeAt(i);
 			}
 		} else {
-			value = this._value;
-			buf.write(str, "latin1");
-		}
-		const len = buf.length;
-		for (let i = 0; i < len; i++) {
-			value[i] = value[i] ^ buf[i];
+			for (let i = 0; i < len; i++) {
+				value[i] = value[i] ^ str.charCodeAt(i);
+			}
 		}
 	}
 
 	toString() {
-		return this._value === undefined ? "" : this._value.toString("latin1");
+		const value = this._value;
+		return value === undefined ? "" : value.toString("latin1");
 	}
 
 	updateHash(hash) {
-		if (this._value !== undefined) hash.update(this._value);
+		const value = this._value;
+		if (value !== undefined) hash.update(value);
 	}
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "5.56.1",
+  "version": "5.58.1",
   "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",

package/types.d.ts

@@ -335,7 +335,6 @@ declare class AsyncDependenciesBlock extends DependenciesBlock {
 	};
 	loc?: SyntheticDependencyLocation | RealDependencyLocation;
 	request?: string;
-	parent: DependenciesBlock;
 	chunkName: string;
 	module: any;
 }
@@ -1460,7 +1459,8 @@ declare class Compilation {
 	chunkTemplate: ChunkTemplate;
 	runtimeTemplate: RuntimeTemplate;
 	moduleTemplates: { javascript: ModuleTemplate };
-	moduleMemCaches?: WeakMap<Module, WeakTupleMap<any, any>>;
+	moduleMemCaches?: Map<Module, WeakTupleMap<any, any>>;
+	moduleMemCaches2?: Map<Module, WeakTupleMap<any, any>>;
 	moduleGraph: ModuleGraph;
 	chunkGraph: ChunkGraph;
 	codeGenerationResults: CodeGenerationResults;
@@ -1645,6 +1645,7 @@ declare class Compilation {
 	 */
 	addChunk(name?: string): Chunk;
 	assignDepth(module: Module): void;
+	assignDepths(modules: Set<Module>): void;
 	getDependencyReferencedExports(
 		dependency: Dependency,
 		runtime: RuntimeSpec
@@ -1907,10 +1908,10 @@ declare class Compiler {
 	context: string;
 	requestShortener: RequestShortener;
 	cache: Cache;
-	moduleMemCaches?: WeakMap<
+	moduleMemCaches?: Map<
 		Module,
 		{
-			hash: string;
+			buildInfo: object;
 			references: WeakMap<Dependency, Module>;
 			memCache: WeakTupleMap<any, any>;
 		}
@@ -2543,6 +2544,8 @@ declare interface DepConstructor {
 declare abstract class DependenciesBlock {
 	dependencies: Dependency[];
 	blocks: AsyncDependenciesBlock[];
+	parent: DependenciesBlock;
+	getRootBlock(): DependenciesBlock;
 
 	/**
 	 * Adds a DependencyBlock to DependencyBlock relationship.
@@ -3741,6 +3744,10 @@ declare class ExternalModule extends Module {
 	request: string | string[] | Record<string, string | string[]>;
 	externalType: string;
 	userRequest: string;
+	restoreFromUnsafeCache(
+		unsafeCacheData?: any,
+		normalModuleFactory?: any
+	): void;
 }
 declare interface ExternalModuleInfo {
 	index: number;
@@ -6495,6 +6502,7 @@ declare class Module extends DependenciesBlock {
 	getSideEffectsConnectionState(moduleGraph: ModuleGraph): ConnectionState;
 	codeGeneration(context: CodeGenerationContext): CodeGenerationResult;
 	chunkCondition(chunk: Chunk, compilation: Compilation): boolean;
+	hasChunkCondition(): boolean;
 
 	/**
 	 * Assuming this module is in the cache. Update the (cached) module with
@@ -6664,10 +6672,12 @@ declare class ModuleGraph {
 	setParents(
 		dependency: Dependency,
 		block: DependenciesBlock,
-		module: Module
+		module: Module,
+		indexInBlock?: number
 	): void;
 	getParentModule(dependency: Dependency): Module;
 	getParentBlock(dependency: Dependency): DependenciesBlock;
+	getParentBlockIndex(dependency: Dependency): number;
 	setResolvedModule(
 		originModule: Module,
 		dependency: Dependency,
@@ -6699,7 +6709,10 @@ declare class ModuleGraph {
 	getOutgoingConnections(module: Module): Iterable<ModuleGraphConnection>;
 	getIncomingConnectionsByOriginModule(
 		module: Module
-	): Map<Module, ReadonlyArray<ModuleGraphConnection>>;
+	): Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
+	getOutgoingConnectionsByModule(
+		module: Module
+	): undefined | Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
 	getProfile(module: Module): null | ModuleProfile;
 	setProfile(module: Module, profile: null | ModuleProfile): void;
 	getIssuer(module: Module): null | Module;
@@ -6740,7 +6753,7 @@ declare class ModuleGraph {
 		...args: T
 	): V;
 	setModuleMemCaches(
-		moduleMemCaches: WeakMap<Module, WeakTupleMap<any, any>>
+		moduleMemCaches: Map<Module, WeakTupleMap<any, any>>
 	): void;
 	dependencyCacheProvide(dependency: Dependency, ...args: any[]): any;
 	static getModuleGraphForModule(
@@ -7373,6 +7386,7 @@ declare interface NormalModuleCompilationHooks {
 	readResourceForScheme: HookMap<
 		AsyncSeriesBailHook<[string, NormalModule], string | Buffer>
 	>;
+	readResource: HookMap<AsyncSeriesBailHook<[object], string | Buffer>>;
 	needBuild: AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>;
 }
 declare abstract class NormalModuleFactory extends ModuleFactory {