@depup/webpack 5.111.1-depup.1 → 5.112.0-depup.0

package/lib/{ModuleGraph.js → graph/ModuleGraph.js}

@@ -6,29 +6,29 @@
 "use strict";
 
 const util = require("util");
+const { ImportPhaseUtils } = require("../dependencies/core/ImportPhase");
+const SortableSet = require("../util/SortableSet");
+const WeakTupleMap = require("../util/WeakTupleMap");
+const { sortWithSourceOrder } = require("../util/comparators");
 const ExportsInfo = require("./ExportsInfo");
 const ModuleGraphConnection = require("./ModuleGraphConnection");
-const HarmonyImportDependency = require("./dependencies/HarmonyImportDependency");
-const { ImportPhaseUtils } = require("./dependencies/ImportPhase");
-const SortableSet = require("./util/SortableSet");
-const WeakTupleMap = require("./util/WeakTupleMap");
-const { sortWithSourceOrder } = require("./util/comparators");
+const isDependencyKind = require("./isDependencyKind");
 
-/** @import { ModuleMemCaches } from "./Compilation" */
+/** @import { ModuleMemCaches } from "../Compilation" */
 /** @import DependenciesBlock from "./DependenciesBlock" */
 /** @import Dependency, { ExportInfoName } from "./Dependency" */
 /** @import { ExportInfo } from "./ExportsInfo" */
-/** @import Module from "./Module" */
-/** @import ModuleProfile from "./ModuleProfile" */
-/** @import RequestShortener from "./RequestShortener" */
-/** @import { RuntimeSpec } from "./util/runtime" */
-/** @import HarmonyImportSideEffectDependency from "./dependencies/HarmonyImportSideEffectDependency" */
+/** @import Module from "../module/Module" */
+/** @import ModuleProfile from "../module/ModuleProfile" */
+/** @import RequestShortener from "../util/RequestShortener" */
+/** @import { RuntimeSpec } from "../util/runtime" */
+/** @import ESMImportSideEffectDependency from "../dependencies/esm/ESMImportSideEffectDependency" */
 /**
- * @import HarmonyImportSpecifierDependency, {
- * 	idsSymbol as HarmonyImportSpecifierDependencyIDsSymbol
- * } from "./dependencies/HarmonyImportSpecifierDependency"
+ * @import ESMImportSpecifierDependency, {
+ * 	idsSymbol as ESMImportSpecifierDependencyIDsSymbol
+ * } from "../dependencies/esm/ESMImportSpecifierDependency"
  */
-/** @import { DependencySourceOrder } from "./util/comparators" */
+/** @import { DependencySourceOrder } from "../util/comparators" */
 
 /**
  * Defines the optimization bailout function callback.
@@ -130,12 +130,12 @@ class ModuleGraphModule {
 /**
  * @import {
  * 	idsSymbol as CommonJsExportRequireDependencyIDsSymbol
- * } from "./dependencies/CommonJsExportRequireDependency"
+ * } from "../dependencies/commonjs/CommonJsExportRequireDependency"
  */
 /**
  * @import {
- * 	idsSymbol as HarmonyExportImportedSpecifierDependencyIDsSymbol
- * } from "./dependencies/HarmonyExportImportedSpecifierDependency"
+ * 	idsSymbol as ESMExportImportedSpecifierDependencyIDsSymbol
+ * } from "../dependencies/esm/ESMExportImportedSpecifierDependency"
  */
 
 /**
@@ -146,7 +146,7 @@ class ModuleGraphModule {
  * @property {boolean=} onDemandExports generate export definitions on demand
  */
 
-/** @typedef {KnownMeta & Record<CommonJsExportRequireDependencyIDsSymbol | HarmonyImportSpecifierDependencyIDsSymbol | HarmonyExportImportedSpecifierDependencyIDsSymbol, string[]> & Record<string, EXPECTED_ANY>} Meta */
+/** @typedef {KnownMeta & Record<CommonJsExportRequireDependencyIDsSymbol | ESMImportSpecifierDependencyIDsSymbol | ESMExportImportedSpecifierDependencyIDsSymbol, string[]> & Record<string, EXPECTED_ANY>} Meta */
 
 class ModuleGraph {
 	constructor() {
@@ -346,14 +346,14 @@ class ModuleGraph {
 		// Specifiers of one import statement share its source order, so `a` and `b`
 		// of `import { a, b } from "lib"` both take the statement's index.
 		const currentSourceOrder =
-			/** @type {HarmonyImportSideEffectDependency | HarmonyImportSpecifierDependency} */
+			/** @type {ESMImportSideEffectDependency | ESMImportSpecifierDependency} */
 			(dependency).sourceOrder;
 
 		// lib/index.js (reexport)
 		// import { a } from "lib/a" -> a = 0
 		// import { b } from "lib/b" -> b = 1
 		const originSourceOrder =
-			/** @type {HarmonyImportSideEffectDependency | HarmonyImportSpecifierDependency} */
+			/** @type {ESMImportSideEffectDependency | ESMImportSpecifierDependency} */
 			(originDependency).sourceOrder;
 		if (
 			typeof currentSourceOrder === "number" &&
@@ -381,7 +381,7 @@ class ModuleGraph {
 			return;
 		}
 		for (const mod of this._modulesNeedingSort) {
-			// If dependencies like HarmonyImportSideEffectDependency and HarmonyImportSpecifierDependency have a SourceOrder,
+			// If dependencies like ESMImportSideEffectDependency and ESMImportSpecifierDependency have a SourceOrder,
 			// we sort based on it; otherwise, we preserve the original order.
 			sortWithSourceOrder(
 				mod.dependencies,
@@ -461,7 +461,7 @@ class ModuleGraph {
 				connection
 			);
 		}
-		pending.length = 0;
+		mgm._unassignedConnections = undefined;
 	}
 
 	/**
@@ -739,7 +739,7 @@ class ModuleGraph {
 							foundConnection = connection;
 						}
 					}
-					mgm._unassignedConnections.length = 0;
+					mgm._unassignedConnections = undefined;
 					if (foundConnection !== undefined) {
 						return foundConnection;
 					}
@@ -1087,7 +1087,7 @@ class ModuleGraph {
 		for (const connection of connections) {
 			if (
 				!connection.dependency ||
-				!(connection.dependency instanceof HarmonyImportDependency)
+				!isDependencyKind(connection.dependency, "esm-import")
 			) {
 				continue;
 			}
@@ -1194,7 +1194,7 @@ class ModuleGraph {
 		);
 	}
 
-	// TODO remove in webpack 6
+	// TODO in the next major release: remove
 	/**
 	 * Gets module graph for module.
 	 * @deprecated
@@ -1228,7 +1228,7 @@ class ModuleGraph {
 		return newFn(module);
 	}
 
-	// TODO remove in webpack 6
+	// TODO in the next major release: remove
 	/**
 	 * Sets module graph for module.
 	 * @deprecated
@@ -1240,7 +1240,7 @@ class ModuleGraph {
 		moduleGraphForModuleMap.set(module, moduleGraph);
 	}
 
-	// TODO remove in webpack 6
+	// TODO in the next major release: remove
 	/**
 	 * Clear module graph for module.
 	 * @deprecated
@@ -1252,11 +1252,11 @@ class ModuleGraph {
 	}
 }
 
-// TODO remove in webpack 6
+// TODO in the next major release: remove
 /** @type {WeakMap<Module, ModuleGraph>} */
 const moduleGraphForModuleMap = new WeakMap();
 
-// TODO remove in webpack 6
+// TODO in the next major release: remove
 /** @type {Map<string, (module: Module) => ModuleGraph>} */
 const deprecateMap = new Map();
 

package/lib/{ModuleGraphConnection.js → graph/ModuleGraphConnection.js}

@@ -6,8 +6,8 @@
 "use strict";
 
 /** @import Dependency, { GetConditionFn } from "./Dependency" */
-/** @import Module from "./Module" */
-/** @import { RuntimeSpec } from "./util/runtime" */
+/** @import Module from "../module/Module" */
+/** @import { RuntimeSpec } from "../util/runtime" */
 
 /**
  * Module itself is not connected, but transitive modules are connected transitively.

package/lib/{buildChunkGraph.js → graph/buildChunkGraph.js}

@@ -5,27 +5,27 @@
 
 "use strict";
 
-const ModuleGraphConnection = require("./ModuleGraphConnection");
-const memoize = require("./util/memoize");
+const memoize = require("../util/memoize");
 
-const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
+const { getEntryRuntime, mergeRuntime } = require("../util/runtime");
+const ModuleGraphConnection = require("./ModuleGraphConnection");
 
 const getAsyncDependencyToInitialChunkError = memoize(() =>
-	require("./errors/AsyncDependencyToInitialChunkError")
+	require("../errors/AsyncDependencyToInitialChunkError")
 );
 
 /** @import AsyncDependenciesBlock from "./AsyncDependenciesBlock" */
 /** @import Chunk from "./Chunk" */
 /** @import ChunkGroup from "./ChunkGroup" */
-/** @import Compilation from "./Compilation" */
+/** @import Compilation from "../Compilation" */
 /** @import DependenciesBlock from "./DependenciesBlock" */
 /** @import { DependencyLocation } from "./Dependency" */
 /** @import Entrypoint, { EntryOptions } from "./Entrypoint" */
-/** @import Module from "./Module" */
+/** @import Module from "../module/Module" */
 /** @import ModuleGraph from "./ModuleGraph" */
 /** @import { ConnectionState } from "./ModuleGraphConnection" */
-/** @import { Logger } from "./logging/Logger" */
-/** @import { RuntimeSpec } from "./util/runtime" */
+/** @import { Logger } from "../logging/Logger" */
+/** @import { RuntimeSpec } from "../util/runtime" */
 
 /**
  * Defines the queue item type used by this module.
@@ -43,13 +43,14 @@ const getAsyncDependencyToInitialChunkError = memoize(() =>
  * @typedef {object} ChunkGroupInfo
  * @property {ChunkGroup} chunkGroup the chunk group
  * @property {RuntimeSpec} runtime the runtimes
- * @property {boolean} initialized is this chunk group initialized
  * @property {bigint | undefined} minAvailableModules current minimal set of modules available at this point
  * @property {bigint[]} 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>=} skippedItems modules that were skipped because module is already available in parent chunks (need to reconsider when minAvailableModules changes)
  * @property {Set<[Module, ModuleGraphConnection[]]>=} skippedModuleConnections referenced modules that where skipped because they were not active in this runtime
  * @property {bigint | undefined} resultingAvailableModules set of modules available including modules from this chunk group
- * @property {Set<ChunkGroupInfo> | undefined} children set of children chunk groups, that will be revisited when availableModules shrink
+ * @property {bigint | undefined} connectedAvailableModules resultingAvailableModules last passed to children, to detect when it grows
+ * @property {Set<ChunkGroupInfo> | undefined} children set of children chunk groups, that will be revisited when resultingAvailableModules changes
+ * @property {Set<ChunkGroupInfo> | undefined} parents set of parent chunk groups, whose resultingAvailableModules intersect to minAvailableModules
  * @property {Set<ChunkGroupInfo> | undefined} availableSources set of chunk groups that are the source for minAvailableModules
  * @property {Set<ChunkGroupInfo> | undefined} availableChildren set of chunk groups which depend on the this chunk group as availableSource
  * @property {number} preOrderIndex next pre order index
@@ -358,10 +359,21 @@ const visitModules = (
 		const module = /** @type {Module} */ (block.getRootBlock());
 		const memCache = moduleMemCaches && moduleMemCaches.get(module);
 		if (memCache !== undefined) {
+			// an optimization (e.g. side effects) can flip a connection's active
+			// state without the module changing — key the cache by the states too
+			let stateEtag = "";
+			for (const connection of moduleGraph.getOutgoingConnections(module)) {
+				if (!connection.dependency || !connection.module || connection.weak) {
+					continue;
+				}
+				const state = connection.getActiveState(runtime);
+				stateEtag += state === true ? "T" : state === false ? "F" : "O";
+			}
 			/** @type {BlockModulesMap} */
 			const map = memCache.provide(
 				"bundleChunkGraph.blockModules",
 				runtime,
+				stateEtag,
 				() => {
 					logger.time("visitModules: prepare");
 					const map = new Map();
@@ -421,7 +433,7 @@ const visitModules = (
 	const blockChunkGroups = new Map();
 
 	/** @type {Map<ChunkGroupInfo, Set<DependenciesBlock>>} */
-	const blocksByChunkGroups = new Map();
+	const blocksByChunkGroupInfo = new Map();
 
 	/** @typedef {Map<string, ChunkGroupInfo>} NamedChunkGroup */
 
@@ -452,6 +464,8 @@ const visitModules = (
 	const queueConnect = new Map();
 	/** @type {Set<ChunkGroupInfo>} */
 	const chunkGroupsForCombining = new Set();
+	/** @type {Set<ChunkGroupInfo>} */
+	const chunkGroupsForGrowing = new Set();
 
 	// Fill queue with entrypoint modules
 	// Create ChunkGroupInfo for entrypoints
@@ -465,14 +479,15 @@ const visitModules = (
 		const chunkGroupInfo = {
 			depModule: null,
 			circular: false,
-			initialized: false,
 			chunkGroup,
 			runtime,
 			minAvailableModules: undefined,
 			availableModulesToBeMerged: [],
 			skippedItems: undefined,
 			resultingAvailableModules: undefined,
+			connectedAvailableModules: undefined,
 			children: undefined,
+			parents: undefined,
 			availableSources: undefined,
 			availableChildren: undefined,
 			preOrderIndex: 0,
@@ -597,7 +612,6 @@ const visitModules = (
 						depModule,
 						circular: b.circular,
 						chunkGroup: entrypoint,
-						initialized: false,
 						runtime:
 							entrypoint.options.runtime ||
 							/** @type {string | undefined} */ (entrypoint.name),
@@ -605,7 +619,9 @@ const visitModules = (
 						availableModulesToBeMerged: [],
 						skippedItems: undefined,
 						resultingAvailableModules: undefined,
+						connectedAvailableModules: undefined,
 						children: undefined,
+						parents: undefined,
 						availableSources: undefined,
 						availableChildren: undefined,
 						preOrderIndex: 0,
@@ -700,14 +716,15 @@ const visitModules = (
 					cgi = {
 						depModule,
 						circular: b.circular,
-						initialized: false,
 						chunkGroup: c,
 						runtime: chunkGroupInfo.runtime,
 						minAvailableModules: undefined,
 						availableModulesToBeMerged: [],
 						skippedItems: undefined,
 						resultingAvailableModules: undefined,
+						connectedAvailableModules: undefined,
 						children: undefined,
+						parents: undefined,
 						availableSources: undefined,
 						availableChildren: undefined,
 						preOrderIndex: 0,
@@ -953,6 +970,12 @@ const visitModules = (
 					let chunkMask = /** @type {bigint} */ (maskByChunk.get(chunk));
 					chunkMask |= ONE_BIGINT << BigInt(moduleOrdinal);
 					maskByChunk.set(chunk, chunkMask);
+					if (chunkGroupInfo.resultingAvailableModules !== undefined) {
+						// A later block reached this chunk group after its children read this value,
+						// we clear it and mark outdated so the children reconnect and drop it
+						chunkGroupInfo.resultingAvailableModules = undefined;
+						outdatedChunkGroupInfo.add(chunkGroupInfo);
+					}
 				}
 				// fallthrough
 				case ENTER_MODULE: {
@@ -1009,6 +1032,19 @@ const visitModules = (
 		}
 	};
 
+	/**
+	 * Get the modules in the chunks of a chunk group.
+	 * @param {ChunkGroupInfo} chunkGroupInfo The info object for the chunk group
+	 * @returns {bigint} The mask of modules in the chunks of the chunk group
+	 */
+	const getChunkGroupMask = (chunkGroupInfo) => {
+		let mask = ZERO_BIGINT;
+		for (const chunk of chunkGroupInfo.chunkGroup.chunks) {
+			mask |= /** @type {bigint} */ (maskByChunk.get(chunk));
+		}
+		return mask;
+	};
+
 	/**
 	 * Calculate resulting available modules.
 	 * @param {ChunkGroupInfo} chunkGroupInfo The info object for the chunk group
@@ -1019,18 +1055,9 @@ const visitModules = (
 			return chunkGroupInfo.resultingAvailableModules;
 		}
 
-		let resultingAvailableModules = /** @type {bigint} */ (
-			chunkGroupInfo.minAvailableModules
-		);
-
-		// add the modules from the chunk group to the set
-		for (const chunk of chunkGroupInfo.chunkGroup.chunks) {
-			const mask = /** @type {bigint} */ (maskByChunk.get(chunk));
-			resultingAvailableModules |= mask;
-		}
-
 		return (chunkGroupInfo.resultingAvailableModules =
-			resultingAvailableModules);
+			/** @type {bigint} */ (chunkGroupInfo.minAvailableModules) |
+			getChunkGroupMask(chunkGroupInfo));
 	};
 
 	const processConnectQueue = () => {
@@ -1048,13 +1075,30 @@ const visitModules = (
 			// 2. Calculate resulting available modules
 			const resultingAvailableModules =
 				calculateResultingAvailableModules(chunkGroupInfo);
+			const connectedAvailableModules =
+				chunkGroupInfo.connectedAvailableModules;
+			// Merging only intersects, so when this grew all children need the growing phase
+			if (
+				connectedAvailableModules !== undefined &&
+				resultingAvailableModules !== connectedAvailableModules &&
+				(resultingAvailableModules & ~connectedAvailableModules) !== ZERO_BIGINT
+			) {
+				for (const child of chunkGroupInfo.children) {
+					if (!child.chunkGroup.isInitial()) chunkGroupsForGrowing.add(child);
+				}
+			}
+			chunkGroupInfo.connectedAvailableModules = resultingAvailableModules;
 
 			const runtime = chunkGroupInfo.runtime;
 
 			// 3. Update chunk group info
-			for (const [target, processBlock] of targets) {
+			for (const [target, queueItem] of targets) {
+				if (target.parents === undefined) {
+					target.parents = new Set();
+				}
+				target.parents.add(chunkGroupInfo);
 				target.availableModulesToBeMerged.push(resultingAvailableModules);
-				chunkGroupsForMerging.add([target, processBlock]);
+				chunkGroupsForMerging.add([target, queueItem]);
 				const oldRuntime = target.runtime;
 				const newRuntime = mergeRuntime(oldRuntime, runtime);
 				if (oldRuntime !== newRuntime) {
@@ -1072,7 +1116,7 @@ const visitModules = (
 		statProcessedChunkGroupsForMerging += chunkGroupsForMerging.size;
 
 		// Execute the merge
-		for (const [info, processBlock] of chunkGroupsForMerging) {
+		for (const [info, queueItem] of chunkGroupsForMerging) {
 			const availableModulesToBeMerged = info.availableModulesToBeMerged;
 			const cachedMinAvailableModules = info.minAvailableModules;
 			let minAvailableModules = cachedMinAvailableModules;
@@ -1099,25 +1143,17 @@ const visitModules = (
 				outdatedChunkGroupInfo.add(info);
 			}
 
-			if (processBlock) {
-				let blocks = blocksByChunkGroups.get(info);
-				if (!blocks) {
-					blocksByChunkGroups.set(info, (blocks = new Set()));
-				}
-
-				// Whether to walk block depends on minAvailableModules and input block.
-				// We can treat creating chunk group as a function with 2 input, entry block and minAvailableModules
-				// If input is the same, we can skip re-walk
-				let needWalkBlock = !info.initialized || changed;
-				if (!blocks.has(processBlock.block)) {
-					needWalkBlock = true;
-					blocks.add(processBlock.block);
+			if (queueItem !== null) {
+				let blocks = blocksByChunkGroupInfo.get(info);
+				if (blocks === undefined) {
+					blocks = new Set();
+					blocksByChunkGroupInfo.set(info, blocks);
 				}
 
-				if (needWalkBlock) {
-					info.initialized = true;
-					queueDelayed.push(processBlock);
-				}
+				// A walk depends only on the block and minAvailableModules: skip it when both are seen
+				const newBlock = !blocks.has(queueItem.block);
+				if (newBlock) blocks.add(queueItem.block);
+				if (newBlock || changed) queueDelayed.push(queueItem);
 			}
 		}
 		chunkGroupsForMerging.clear();
@@ -1152,6 +1188,47 @@ const visitModules = (
 		chunkGroupsForCombining.clear();
 	};
 
+	const processChunkGroupsForGrowing = () => {
+		for (const info of chunkGroupsForGrowing) {
+			/** @type {bigint | undefined} */
+			let availableModules;
+			for (const parent of /** @type {Set<ChunkGroupInfo>} */ (info.parents)) {
+				const resultingAvailableModules =
+					calculateResultingAvailableModules(parent);
+				availableModules =
+					availableModules === undefined
+						? resultingAvailableModules
+						: availableModules & resultingAvailableModules;
+				// Each parent covers minAvailableModules, so the intersection cannot drop below it
+				if (availableModules === info.minAvailableModules) break;
+			}
+			if (availableModules === info.minAvailableModules) continue;
+			info.minAvailableModules = availableModules;
+			info.resultingAvailableModules = undefined;
+			outdatedChunkGroupInfo.add(info);
+			// Reverse of revisiting skipped items: move the own modules now available
+			// to skippedItems, where they are added back if it shrinks again
+			for (const chunk of info.chunkGroup.chunks) {
+				let chunkMask = /** @type {bigint} */ (maskByChunk.get(chunk));
+				const coveredModules =
+					chunkMask & /** @type {bigint} */ (availableModules);
+				if (coveredModules === ZERO_BIGINT) continue;
+				if (info.skippedItems === undefined) {
+					info.skippedItems = new Set();
+				}
+				for (const module of chunkGraph.getChunkModules(chunk)) {
+					const ordinal = getModuleOrdinal(module);
+					if (!isOrdinalSetInMask(coveredModules, ordinal)) continue;
+					chunkGraph.disconnectChunkAndModule(chunk, module);
+					chunkMask &= ~(ONE_BIGINT << BigInt(ordinal));
+					info.skippedItems.add(module);
+				}
+				maskByChunk.set(chunk, chunkMask);
+			}
+		}
+		chunkGroupsForGrowing.clear();
+	};
+
 	const processOutdatedChunkGroupInfo = () => {
 		statChunkGroupInfoUpdated += outdatedChunkGroupInfo.size;
 		// Revisit skipped elements
@@ -1209,21 +1286,21 @@ const visitModules = (
 				}
 			}
 
-			// 2. Reconsider children chunk groups
-			if (info.children !== undefined) {
+			// 3. Reconsider children chunk groups
+			if (info.children !== undefined && info.children.size > 0) {
 				statChildChunkGroupsReconnected += info.children.size;
+				let connectList = queueConnect.get(info);
+				if (connectList === undefined) {
+					/** @type {ConnectList} */
+					connectList = new Set();
+					queueConnect.set(info, connectList);
+				}
 				for (const cgi of info.children) {
-					let connectList = queueConnect.get(info);
-					if (connectList === undefined) {
-						/** @type {ConnectList} */
-						connectList = new Set();
-						queueConnect.set(info, connectList);
-					}
 					connectList.add([cgi, null]);
 				}
 			}
 
-			// 3. Reconsider chunk groups for combining
+			// 4. Reconsider chunk groups for combining
 			if (info.availableChildren !== undefined) {
 				for (const cgi of info.availableChildren) {
 					chunkGroupsForCombining.add(cgi);
@@ -1236,7 +1313,12 @@ const visitModules = (
 
 	// Iterative traversal of the Module graph
 	// Recursive would be simpler to write but could result in Stack Overflows
-	while (queue.length || queueConnect.size) {
+	while (
+		queue.length ||
+		queueConnect.size ||
+		outdatedChunkGroupInfo.size ||
+		chunkGroupsForCombining.size
+	) {
 		logger.time("visitModules: visiting");
 		processQueue();
 		logger.timeAggregateEnd("visitModules: prepare");
@@ -1274,12 +1356,25 @@ const visitModules = (
 			queue = queueDelayed.reverse();
 			queueDelayed = tempQueue;
 		}
+
+		// Grow only after the shrinking phase finishes, so growth
+		// reads each parent's final `resultingAvailableModules`
+		if (
+			queue.length === 0 &&
+			queueConnect.size === 0 &&
+			chunkGroupsForCombining.size === 0 &&
+			chunkGroupsForGrowing.size > 0
+		) {
+			logger.time("visitModules: growing available modules");
+			processChunkGroupsForGrowing();
+			logger.timeEnd("visitModules: growing available modules");
+		}
 	}
 
 	for (const info of outdatedOrderIndexChunkGroups) {
 		const { chunkGroup, runtime } = info;
 
-		const blocks = blocksByChunkGroups.get(info);
+		const blocks = blocksByChunkGroupInfo.get(info);
 
 		if (!blocks) {
 			continue;

package/lib/{util → graph}/findGraphRoots.js

@@ -5,6 +5,8 @@
 
 "use strict";
 
+const { first } = require("../util/SetHelpers");
+
 const NO_MARKER = 0;
 const IN_PROGRESS_MARKER = 1;
 const DONE_MARKER = 2;
@@ -13,16 +15,16 @@ const CANDIDATE_MARKER = 3;
 /**
  * Defines the nodes type used by this module.
  * @template T
- * @typedef {Set<Node<T>>} Nodes
+ * @typedef {Set<GraphNode<T>>} Nodes
  */
 
 /**
  * Represents the node runtime component.
  * @template T
  */
-class Node {
+class GraphNode {
 	/**
-	 * Creates an instance of Node.
+	 * Creates an instance of GraphNode.
 	 * @param {T} item the value of the node
 	 */
 	constructor(item) {
@@ -56,8 +58,8 @@ class SCC {
  * Defines the stack entry type used by this module.
  * @template T
  * @typedef {object} StackEntry
- * @property {Node<T>} node
- * @property {Node<T>[]} openEdges
+ * @property {GraphNode<T>} node
+ * @property {GraphNode<T>[]} openEdges
  */
 
 /**
@@ -68,10 +70,10 @@ class SCC {
  * @returns {Iterable<T>} graph roots of the items
  */
 module.exports = (items, getDependencies) => {
-	/** @type {Map<T, Node<T>>} */
+	/** @type {Map<T, GraphNode<T>>} */
 	const itemToNode = new Map();
 	for (const item of items) {
-		const node = new Node(item);
+		const node = new GraphNode(item);
 		itemToNode.set(item, node);
 	}
 
@@ -112,7 +114,7 @@ module.exports = (items, getDependencies) => {
 				// Process one unvisited outgoing edge if available
 				if (topOfStack.openEdges.length > 0) {
 					const dependency =
-						/** @type {Node<T>} */
+						/** @type {GraphNode<T>} */
 						(topOfStack.openEdges.pop());
 					const depSCC = dependency.scc;
 					switch (depSCC.marker) {
@@ -183,6 +185,10 @@ module.exports = (items, getDependencies) => {
 	// For each root SCC, we select node with the most incoming edges
 	// from within the same SCC
 	for (const scc of rootSCCs) {
+		if (scc.nodes.size === 1) {
+			rootNodes.add(/** @type {GraphNode<T>} */ (first(scc.nodes)).item);
+			continue;
+		}
 		let max = 0;
 		/** @type {Nodes<T>} */
 		const nodes = new Set(scc.nodes);

package/lib/graph/isDependencyKind.js

@@ -0,0 +1,23 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+/** @import Dependency, { DependencyKinds } from "./Dependency" */
+
+/**
+ * Returns whether a dependency is of the given kind; use it wherever a plugin's dependency can reach.
+ * A dependency extending another webpack copy's `Dependency` has no `is()` and is of no kind.
+ * @template {keyof DependencyKinds} K
+ * @param {Dependency} dependency a dependency
+ * @param {K} kind a dependency kind
+ * @returns {dependency is DependencyKinds[K]} true when the dependency is of that kind
+ */
+const isDependencyKind = (dependency, kind) =>
+	// TODO in the next major release: remove, require plugin dependencies to extend the current
+	// `Dependency` and call `dependency.is(kind)` directly
+	typeof dependency.is === "function" && dependency.is(kind);
+
+module.exports = isDependencyKind;

package/lib/hmr/HotModuleReplacement.runtime.js

@@ -56,14 +56,14 @@
  * @property {Record<ModuleId, AcceptCallback>} _acceptedDependencies accept callbacks by dependency id
  * @property {Record<ModuleId, AcceptErrorHandler | undefined>} _acceptedErrorHandlers error handlers by dependency id
  * @property {Record<ModuleId, boolean>} _declinedDependencies declined dependency ids
- * @property {boolean | EXPECTED_FUNCTION} _selfAccepted true or the self-accept error handler
+ * @property {boolean | AcceptErrorHandler} _selfAccepted true or the self-accept error handler
  * @property {boolean} _selfDeclined module declined itself
  * @property {boolean} _selfInvalidated module invalidated itself
  * @property {DisposeHandler[]} _disposeHandlers registered dispose handlers
  * @property {boolean} _main module is the entry of the update
  * @property {() => void} _requireSelf re-require the module on apply
  * @property {boolean} active module is not disposed
- * @property {(dep?: ModuleId | ModuleId[] | AcceptCallback, callback?: AcceptCallback, errorHandler?: AcceptErrorHandler) => void} accept accept updates
+ * @property {(dep?: ModuleId | ModuleId[] | AcceptErrorHandler, callback?: AcceptCallback, errorHandler?: AcceptErrorHandler) => void} accept accept updates
  * @property {(dep?: ModuleId | ModuleId[]) => void} decline decline updates
  * @property {(callback: DisposeHandler) => void} dispose add a dispose handler
  * @property {(callback: DisposeHandler) => void} addDisposeHandler add a dispose handler