webpack 5.57.1 → 5.59.0

package/lib/NormalModuleFactory.js

@@ -466,49 +466,68 @@ class NormalModuleFactory extends ModuleFactory {
 							: "") +
 						stringifyLoadersAndResource(loaders, resourceData.resource);
 
-					const resourceDataForRules = matchResourceData || resourceData;
-					const result = this.ruleSet.exec({
-						resource: resourceDataForRules.path,
-						realResource: resourceData.path,
-						resourceQuery: resourceDataForRules.query,
-						resourceFragment: resourceDataForRules.fragment,
-						scheme,
-						assertions,
-						mimetype: matchResourceData ? "" : resourceData.data.mimetype || "",
-						dependency: dependencyType,
-						descriptionData: matchResourceData
-							? undefined
-							: resourceData.data.descriptionFileData,
-						issuer: contextInfo.issuer,
-						compiler: contextInfo.compiler,
-						issuerLayer: contextInfo.issuerLayer || ""
-					});
 					const settings = {};
 					const useLoadersPost = [];
 					const useLoaders = [];
 					const useLoadersPre = [];
-					for (const r of result) {
-						if (r.type === "use") {
-							if (!noAutoLoaders && !noPrePostAutoLoaders) {
-								useLoaders.push(r.value);
-							}
-						} else if (r.type === "use-post") {
-							if (!noPrePostAutoLoaders) {
-								useLoadersPost.push(r.value);
-							}
-						} else if (r.type === "use-pre") {
-							if (!noPreAutoLoaders && !noPrePostAutoLoaders) {
-								useLoadersPre.push(r.value);
+
+					// handle .webpack[] suffix
+					let resource;
+					let match;
+					if (
+						matchResourceData &&
+						typeof (resource = matchResourceData.resource) === "string" &&
+						(match = /\.webpack\[([^\]]+)\]$/.exec(resource))
+					) {
+						settings.type = match[1];
+						matchResourceData.resource = matchResourceData.resource.slice(
+							0,
+							-settings.type.length - 10
+						);
+					} else {
+						settings.type = "javascript/auto";
+						const resourceDataForRules = matchResourceData || resourceData;
+						const result = this.ruleSet.exec({
+							resource: resourceDataForRules.path,
+							realResource: resourceData.path,
+							resourceQuery: resourceDataForRules.query,
+							resourceFragment: resourceDataForRules.fragment,
+							scheme,
+							assertions,
+							mimetype: matchResourceData
+								? ""
+								: resourceData.data.mimetype || "",
+							dependency: dependencyType,
+							descriptionData: matchResourceData
+								? undefined
+								: resourceData.data.descriptionFileData,
+							issuer: contextInfo.issuer,
+							compiler: contextInfo.compiler,
+							issuerLayer: contextInfo.issuerLayer || ""
+						});
+						for (const r of result) {
+							if (r.type === "use") {
+								if (!noAutoLoaders && !noPrePostAutoLoaders) {
+									useLoaders.push(r.value);
+								}
+							} else if (r.type === "use-post") {
+								if (!noPrePostAutoLoaders) {
+									useLoadersPost.push(r.value);
+								}
+							} else if (r.type === "use-pre") {
+								if (!noPreAutoLoaders && !noPrePostAutoLoaders) {
+									useLoadersPre.push(r.value);
+								}
+							} else if (
+								typeof r.value === "object" &&
+								r.value !== null &&
+								typeof settings[r.type] === "object" &&
+								settings[r.type] !== null
+							) {
+								settings[r.type] = cachedCleverMerge(settings[r.type], r.value);
+							} else {
+								settings[r.type] = r.value;
 							}
-						} else if (
-							typeof r.value === "object" &&
-							r.value !== null &&
-							typeof settings[r.type] === "object" &&
-							settings[r.type] !== null
-						) {
-							settings[r.type] = cachedCleverMerge(settings[r.type], r.value);
-						} else {
-							settings[r.type] = r.value;
 						}
 					}
 
@@ -528,23 +547,6 @@ class NormalModuleFactory extends ModuleFactory {
 						}
 						for (const loader of preLoaders) allLoaders.push(loader);
 						let type = settings.type;
-						if (!type) {
-							let resource;
-							let match;
-							if (
-								matchResourceData &&
-								typeof (resource = matchResourceData.resource) === "string" &&
-								(match = /\.webpack\[([^\]]+)\]$/.exec(resource))
-							) {
-								type = match[1];
-								matchResourceData.resource = matchResourceData.resource.slice(
-									0,
-									-type.length - 10
-								);
-							} else {
-								type = "javascript/auto";
-							}
-						}
 						const resolveOptions = settings.resolve;
 						const layer = settings.layer;
 						if (layer !== undefined && !layers) {

package/lib/RuntimeTemplate.js

@@ -807,7 +807,7 @@ class RuntimeTemplate {
 					? `(0,${access})`
 					: asiSafe === false
 					? `;(0,${access})`
-					: `Object(${access})`;
+					: `/*#__PURE__*/Object(${access})`;
 			}
 			return access;
 		} else {

package/lib/WebpackOptionsApply.js

@@ -279,8 +279,6 @@ class WebpackOptionsApply extends OptionsApply {
 		if (options.experiments.buildHttp) {
 			const HttpUriPlugin = require("./schemes/HttpUriPlugin");
 			const httpOptions = options.experiments.buildHttp;
-			if (httpOptions === true)
-				throw new Error("Unexpected due to normalization");
 			new HttpUriPlugin(httpOptions).apply(compiler);
 		}
 

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/cache/AddManagedPathsPlugin.js

@@ -9,8 +9,8 @@
 
 class AddManagedPathsPlugin {
 	/**
-	 * @param {Iterable<string>} managedPaths list of managed paths
-	 * @param {Iterable<string>} immutablePaths list of immutable paths
+	 * @param {Iterable<string | RegExp>} managedPaths list of managed paths
+	 * @param {Iterable<string | RegExp>} immutablePaths list of immutable paths
 	 */
 	constructor(managedPaths, immutablePaths) {
 		this.managedPaths = new Set(managedPaths);

package/lib/cache/PackFileCacheStrategy.js

@@ -370,8 +370,8 @@ class Pack {
 			for (const identifier of content.items) {
 				mergedItems.add(identifier);
 			}
-			for (const identifer of content.used) {
-				mergedUsedItems.add(identifer);
+			for (const identifier of content.used) {
+				mergedUsedItems.add(identifier);
 			}
 			addToMergedMap.push(async map => {
 				// unpack existing content