webpack 5.97.1 → 5.104.1

package/lib/optimize/RealContentHashPlugin.js

@@ -6,12 +6,14 @@
 "use strict";
 
 const { SyncBailHook } = require("tapable");
-const { RawSource, CachedSource, CompatSource } = require("webpack-sources");
+const { CachedSource, CompatSource, RawSource } = require("webpack-sources");
 const Compilation = require("../Compilation");
 const WebpackError = require("../WebpackError");
 const { compareSelect, compareStrings } = require("../util/comparators");
 const createHash = require("../util/createHash");
 
+/** @typedef {import("../../declarations/WebpackOptions").HashFunction} HashFunction */
+/** @typedef {import("../../declarations/WebpackOptions").HashDigest} HashDigest */
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../Cache").Etag} Etag */
 /** @typedef {import("../Compilation").AssetInfo} AssetInfo */
@@ -38,7 +40,7 @@ const addToList = (itemOrItems, list) => {
 /**
  * @template T
  * @param {T[]} input list
- * @param {function(T): Buffer} fn map function
+ * @param {(item: T) => Buffer} fn map function
  * @returns {Buffer[]} buffers without duplicates
  */
 const mapAndDeduplicateBuffers = (input, fn) => {
@@ -61,7 +63,7 @@ const mapAndDeduplicateBuffers = (input, fn) => {
  * @param {string} str String to quote
  * @returns {string} Escaped string
  */
-const quoteMeta = str => str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
+const quoteMeta = (str) => str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
 
 const cachedSourceMap = new WeakMap();
 
@@ -69,7 +71,7 @@ const cachedSourceMap = new WeakMap();
  * @param {Source} source source
  * @returns {CachedSource} cached source
  */
-const toCachedSource = source => {
+const toCachedSource = (source) => {
 	if (source instanceof CachedSource) {
 		return source;
 	}
@@ -107,6 +109,14 @@ const toCachedSource = source => {
 /** @type {WeakMap<Compilation, CompilationHooks>} */
 const compilationHooksMap = new WeakMap();
 
+/**
+ * @typedef {object} RealContentHashPluginOptions
+ * @property {HashFunction} hashFunction the hash function to use
+ * @property {HashDigest} hashDigest the hash digest to use
+ */
+
+const PLUGIN_NAME = "RealContentHashPlugin";
+
 class RealContentHashPlugin {
 	/**
 	 * @param {Compilation} compilation the compilation
@@ -129,9 +139,7 @@ class RealContentHashPlugin {
 	}
 
 	/**
-	 * @param {object} options options object
-	 * @param {string | Hash} options.hashFunction the hash function to use
-	 * @param {string} options.hashDigest the hash digest to use
+	 * @param {RealContentHashPluginOptions} options options
 	 */
 	constructor({ hashFunction, hashDigest }) {
 		this._hashFunction = hashFunction;
@@ -144,7 +152,7 @@ class RealContentHashPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap("RealContentHashPlugin", compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			const cacheAnalyse = compilation.getCache(
 				"RealContentHashPlugin|analyse"
 			);
@@ -154,7 +162,7 @@ class RealContentHashPlugin {
 			const hooks = RealContentHashPlugin.getCompilationHooks(compilation);
 			compilation.hooks.processAssets.tapPromise(
 				{
-					name: "RealContentHashPlugin",
+					name: PLUGIN_NAME,
 					stage: Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_HASH
 				},
 				async () => {
@@ -199,7 +207,7 @@ class RealContentHashPlugin {
 						"g"
 					);
 					await Promise.all(
-						assetsWithInfo.map(async asset => {
+						assetsWithInfo.map(async (asset) => {
 							const { name, source, content, hashes } = asset;
 							if (Buffer.isBuffer(content)) {
 								asset.referencedHashes = EMPTY_SET;
@@ -208,7 +216,7 @@ class RealContentHashPlugin {
 							}
 							const etag = cacheAnalyse.mergeEtags(
 								cacheAnalyse.getLazyHashedEtag(source),
-								Array.from(hashes).join("|")
+								[...hashes].join("|")
 							);
 							[asset.referencedHashes, asset.ownHashes] =
 								await cacheAnalyse.providePromise(name, etag, () => {
@@ -232,10 +240,10 @@ class RealContentHashPlugin {
 					 * @param {string} hash the hash
 					 * @returns {undefined | ReferencedHashes} the referenced hashes
 					 */
-					const getDependencies = hash => {
+					const getDependencies = (hash) => {
 						const assets = hashToAssets.get(hash);
 						if (!assets) {
-							const referencingAssets = assetsWithInfo.filter(asset =>
+							const referencingAssets = assetsWithInfo.filter((asset) =>
 								/** @type {ReferencedHashes} */ (asset.referencedHashes).has(
 									hash
 								)
@@ -246,7 +254,7 @@ An asset was cached with a reference to another asset (${hash}) that's not in th
 Either the asset was incorrectly cached, or the referenced asset should also be restored from cache.
 Referenced by:
 ${referencingAssets
-	.map(a => {
+	.map((a) => {
 		const match = new RegExp(`.{0,20}${quoteMeta(hash)}.{0,20}`).exec(
 			a.content
 		);
@@ -275,13 +283,14 @@ ${referencingAssets
 					 * @param {string} hash the hash
 					 * @returns {string} the hash info
 					 */
-					const hashInfo = hash => {
+					const hashInfo = (hash) => {
 						const assets = hashToAssets.get(hash);
 						return `${hash} (${Array.from(
 							/** @type {AssetInfoForRealContentHash[]} */ (assets),
-							a => a.name
+							(a) => a.name
 						)})`;
 					};
+					/** @type {Set<string>} */
 					const hashesInOrder = new Set();
 					for (const hash of hashToAssets.keys()) {
 						/**
@@ -310,32 +319,32 @@ ${referencingAssets
 						if (hashesInOrder.has(hash)) continue;
 						add(hash, new Set());
 					}
+					/** @type {Map<string, string>} */
 					const hashToNewHash = new Map();
 					/**
 					 * @param {AssetInfoForRealContentHash} asset asset info
 					 * @returns {Etag} etag
 					 */
-					const getEtag = asset =>
+					const getEtag = (asset) =>
 						cacheGenerate.mergeEtags(
 							cacheGenerate.getLazyHashedEtag(asset.source),
 							Array.from(
 								/** @type {ReferencedHashes} */ (asset.referencedHashes),
-								hash => hashToNewHash.get(hash)
+								(hash) => hashToNewHash.get(hash)
 							).join("|")
 						);
 					/**
 					 * @param {AssetInfoForRealContentHash} asset asset info
 					 * @returns {Promise<void>}
 					 */
-					const computeNewContent = asset => {
+					const computeNewContent = (asset) => {
 						if (asset.contentComputePromise) return asset.contentComputePromise;
 						return (asset.contentComputePromise = (async () => {
 							if (
 								/** @type {OwnHashes} */ (asset.ownHashes).size > 0 ||
-								Array.from(
-									/** @type {ReferencedHashes} */
-									(asset.referencedHashes)
-								).some(hash => hashToNewHash.get(hash) !== hash)
+								[
+									.../** @type {ReferencedHashes} */ (asset.referencedHashes)
+								].some((hash) => hashToNewHash.get(hash) !== hash)
 							) {
 								const identifier = asset.name;
 								const etag = getEtag(asset);
@@ -343,8 +352,9 @@ ${referencingAssets
 									identifier,
 									etag,
 									() => {
-										const newContent = asset.content.replace(hashRegExp, hash =>
-											hashToNewHash.get(hash)
+										const newContent = asset.content.replace(
+											hashRegExp,
+											(hash) => /** @type {string} */ (hashToNewHash.get(hash))
 										);
 										return new RawSource(newContent);
 									}
@@ -356,16 +366,16 @@ ${referencingAssets
 					 * @param {AssetInfoForRealContentHash} asset asset info
 					 * @returns {Promise<void>}
 					 */
-					const computeNewContentWithoutOwn = asset => {
-						if (asset.contentComputeWithoutOwnPromise)
+					const computeNewContentWithoutOwn = (asset) => {
+						if (asset.contentComputeWithoutOwnPromise) {
 							return asset.contentComputeWithoutOwnPromise;
+						}
 						return (asset.contentComputeWithoutOwnPromise = (async () => {
 							if (
 								/** @type {OwnHashes} */ (asset.ownHashes).size > 0 ||
-								Array.from(
-									/** @type {ReferencedHashes} */
-									(asset.referencedHashes)
-								).some(hash => hashToNewHash.get(hash) !== hash)
+								[
+									.../** @type {ReferencedHashes} */ (asset.referencedHashes)
+								].some((hash) => hashToNewHash.get(hash) !== hash)
 							) {
 								const identifier = `${asset.name}|without-own`;
 								const etag = getEtag(asset);
@@ -375,13 +385,14 @@ ${referencingAssets
 									() => {
 										const newContent = asset.content.replace(
 											hashRegExp,
-											hash => {
+											(hash) => {
 												if (
-													/** @type {OwnHashes} */ (asset.ownHashes).has(hash)
+													/** @type {OwnHashes} */
+													(asset.ownHashes).has(hash)
 												) {
 													return "";
 												}
-												return hashToNewHash.get(hash);
+												return /** @type {string} */ (hashToNewHash.get(hash));
 											}
 										);
 										return new RawSource(newContent);
@@ -390,20 +401,20 @@ ${referencingAssets
 							}
 						})());
 					};
-					const comparator = compareSelect(a => a.name, compareStrings);
+					const comparator = compareSelect((a) => a.name, compareStrings);
 					for (const oldHash of hashesInOrder) {
 						const assets =
 							/** @type {AssetInfoForRealContentHash[]} */
 							(hashToAssets.get(oldHash));
 						assets.sort(comparator);
 						await Promise.all(
-							assets.map(asset =>
+							assets.map((asset) =>
 								/** @type {OwnHashes} */ (asset.ownHashes).has(oldHash)
 									? computeNewContentWithoutOwn(asset)
 									: computeNewContent(asset)
 							)
 						);
-						const assetsContent = mapAndDeduplicateBuffers(assets, asset => {
+						const assetsContent = mapAndDeduplicateBuffers(assets, (asset) => {
 							if (/** @type {OwnHashes} */ (asset.ownHashes).has(oldHash)) {
 								return asset.newSourceWithoutOwn
 									? asset.newSourceWithoutOwn.buffer()
@@ -423,22 +434,25 @@ ${referencingAssets
 								hash.update(content);
 							}
 							const digest = hash.digest(this._hashDigest);
-							newHash = /** @type {string} */ (digest.slice(0, oldHash.length));
+							newHash = digest.slice(0, oldHash.length);
 						}
 						hashToNewHash.set(oldHash, newHash);
 					}
 					await Promise.all(
-						assetsWithInfo.map(async asset => {
+						assetsWithInfo.map(async (asset) => {
 							await computeNewContent(asset);
-							const newName = asset.name.replace(hashRegExp, hash =>
-								hashToNewHash.get(hash)
+							const newName = asset.name.replace(
+								hashRegExp,
+								(hash) => /** @type {string} */ (hashToNewHash.get(hash))
 							);
 
 							const infoUpdate = {};
-							const hash = asset.info.contenthash;
+							const hash = /** @type {string} */ (asset.info.contenthash);
 							infoUpdate.contenthash = Array.isArray(hash)
-								? hash.map(hash => hashToNewHash.get(hash))
-								: hashToNewHash.get(hash);
+								? hash.map(
+										(hash) => /** @type {string} */ (hashToNewHash.get(hash))
+									)
+								: /** @type {string} */ (hashToNewHash.get(hash));
 
 							if (asset.newSource !== undefined) {
 								compilation.updateAsset(

package/lib/optimize/RemoveEmptyChunksPlugin.js

@@ -5,11 +5,13 @@
 
 "use strict";
 
-const { STAGE_BASIC, STAGE_ADVANCED } = require("../OptimizationStages");
+const { STAGE_ADVANCED, STAGE_BASIC } = require("../OptimizationStages");
 
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
+const PLUGIN_NAME = "RemoveEmptyChunksPlugin";
+
 class RemoveEmptyChunksPlugin {
 	/**
 	 * Apply the plugin
@@ -17,12 +19,12 @@ class RemoveEmptyChunksPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap("RemoveEmptyChunksPlugin", compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			/**
 			 * @param {Iterable<Chunk>} chunks the chunks array
 			 * @returns {void}
 			 */
-			const handler = chunks => {
+			const handler = (chunks) => {
 				const chunkGraph = compilation.chunkGraph;
 				for (const chunk of chunks) {
 					if (
@@ -39,14 +41,14 @@ class RemoveEmptyChunksPlugin {
 			// TODO do it once
 			compilation.hooks.optimizeChunks.tap(
 				{
-					name: "RemoveEmptyChunksPlugin",
+					name: PLUGIN_NAME,
 					stage: STAGE_BASIC
 				},
 				handler
 			);
 			compilation.hooks.optimizeChunks.tap(
 				{
-					name: "RemoveEmptyChunksPlugin",
+					name: PLUGIN_NAME,
 					stage: STAGE_ADVANCED
 				},
 				handler
@@ -54,4 +56,5 @@ class RemoveEmptyChunksPlugin {
 		});
 	}
 }
+
 module.exports = RemoveEmptyChunksPlugin;

package/lib/optimize/RemoveParentModulesPlugin.js

@@ -59,13 +59,15 @@ function* getModulesFromMask(mask, ordinalModules) {
 	}
 }
 
+const PLUGIN_NAME = "RemoveParentModulesPlugin";
+
 class RemoveParentModulesPlugin {
 	/**
 	 * @param {Compiler} compiler the compiler
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap("RemoveParentModulesPlugin", compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			/**
 			 * @param {Iterable<Chunk>} chunks the chunks
 			 * @param {ChunkGroup[]} chunkGroups the chunk groups
@@ -85,7 +87,7 @@ class RemoveParentModulesPlugin {
 				 * @param {Module} mod the module to get the mask for
 				 * @returns {bigint} the module mask to uniquely identify the module
 				 */
-				const getOrCreateModuleMask = mod => {
+				const getOrCreateModuleMask = (mod) => {
 					let id = maskByModule.get(mod);
 					if (id === undefined) {
 						id = nextModuleMask;
@@ -175,7 +177,7 @@ class RemoveParentModulesPlugin {
 
 					const availableModulesSets = Array.from(
 						chunk.groupsIterable,
-						chunkGroup => availableModulesMap.get(chunkGroup)
+						(chunkGroup) => availableModulesMap.get(chunkGroup)
 					);
 					if (availableModulesSets.includes(undefined)) continue; // No info about this chunk group
 
@@ -193,7 +195,7 @@ class RemoveParentModulesPlugin {
 			};
 			compilation.hooks.optimizeChunks.tap(
 				{
-					name: "RemoveParentModulesPlugin",
+					name: PLUGIN_NAME,
 					stage: STAGE_BASIC
 				},
 				handler
@@ -201,4 +203,5 @@ class RemoveParentModulesPlugin {
 		});
 	}
 }
+
 module.exports = RemoveParentModulesPlugin;

package/lib/optimize/RuntimeChunkPlugin.js

@@ -7,19 +7,19 @@
 
 /** @typedef {import("../Compilation").EntryData} EntryData */
 /** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Entrypoint")} Entrypoint */
+
+const PLUGIN_NAME = "RuntimeChunkPlugin";
+
+/** @typedef {(entrypoint: { name: string }) => string} RuntimeChunkFunction */
 
 class RuntimeChunkPlugin {
 	/**
-	 * @param {{ name?: (entrypoint: { name: string }) => string }} options options
+	 * @param {{ name?: RuntimeChunkFunction }=} options options
 	 */
 	constructor(options) {
 		this.options = {
-			/**
-			 * @param {Entrypoint} entrypoint entrypoint name
-			 * @returns {string} runtime chunk name
-			 */
-			name: entrypoint => `runtime~${entrypoint.name}`,
+			/** @type {RuntimeChunkFunction} */
+			name: (entrypoint) => `runtime~${entrypoint.name}`,
 			...options
 		};
 	}
@@ -30,26 +30,23 @@ class RuntimeChunkPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.thisCompilation.tap("RuntimeChunkPlugin", compilation => {
-			compilation.hooks.addEntry.tap(
-				"RuntimeChunkPlugin",
-				(_, { name: entryName }) => {
-					if (entryName === undefined) return;
-					const data =
-						/** @type {EntryData} */
-						(compilation.entries.get(entryName));
-					if (data.options.runtime === undefined && !data.options.dependOn) {
-						// Determine runtime chunk name
-						let name =
-							/** @type {string | ((entrypoint: { name: string }) => string)} */
-							(this.options.name);
-						if (typeof name === "function") {
-							name = name({ name: entryName });
-						}
-						data.options.runtime = name;
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+			compilation.hooks.addEntry.tap(PLUGIN_NAME, (_, { name: entryName }) => {
+				if (entryName === undefined) return;
+				const data =
+					/** @type {EntryData} */
+					(compilation.entries.get(entryName));
+				if (data.options.runtime === undefined && !data.options.dependOn) {
+					// Determine runtime chunk name
+					let name =
+						/** @type {string | RuntimeChunkFunction} */
+						(this.options.name);
+					if (typeof name === "function") {
+						name = name({ name: entryName });
 					}
+					data.options.runtime = name;
 				}
-			);
+			});
 		});
 	}
 }

package/lib/optimize/SideEffectsFlagPlugin.js

@@ -8,18 +8,19 @@
 const glob2regexp = require("glob-to-regexp");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
-	JAVASCRIPT_MODULE_TYPE_ESM,
-	JAVASCRIPT_MODULE_TYPE_DYNAMIC
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+	JAVASCRIPT_MODULE_TYPE_ESM
 } = require("../ModuleTypeConstants");
 const { STAGE_DEFAULT } = require("../OptimizationStages");
 const HarmonyExportImportedSpecifierDependency = require("../dependencies/HarmonyExportImportedSpecifierDependency");
 const HarmonyImportSpecifierDependency = require("../dependencies/HarmonyImportSpecifierDependency");
 const formatLocation = require("../formatLocation");
 
+/** @typedef {import("estree").MaybeNamedClassDeclaration} MaybeNamedClassDeclaration */
+/** @typedef {import("estree").MaybeNamedFunctionDeclaration} MaybeNamedFunctionDeclaration */
 /** @typedef {import("estree").ModuleDeclaration} ModuleDeclaration */
 /** @typedef {import("estree").Statement} Statement */
 /** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
@@ -35,20 +36,16 @@ const formatLocation = require("../formatLocation");
  * @property {boolean} checked if the export is conditional
  */
 
-/**
- * @typedef {object} ReexportInfo
- * @property {Map<string, ExportInModule[]>} static
- * @property {Map<Module, Set<string>>} dynamic
- */
+/** @typedef {string | boolean | string[] | undefined} SideEffectsFlagValue */
 
 /** @typedef {Map<string, RegExp>} CacheItem */
 
-/** @type {WeakMap<any, CacheItem>} */
+/** @type {WeakMap<Compiler, CacheItem>} */
 const globToRegexpCache = new WeakMap();
 
 /**
  * @param {string} glob the pattern
- * @param {Map<string, RegExp>} cache the glob to RegExp cache
+ * @param {CacheItem} cache the glob to RegExp cache
  * @returns {RegExp} a regular expression
  */
 const globToRegexp = (glob, cache) => {
@@ -103,7 +100,7 @@ class SideEffectsFlagPlugin {
 							}
 							const hasSideEffects = SideEffectsFlagPlugin.moduleHasSideEffects(
 								resolveData.relativePath,
-								sideEffects,
+								/** @type {SideEffectsFlagValue} */ (sideEffects),
 								/** @type {CacheItem} */ (cache)
 							);
 							module.factoryMeta.sideEffectFree = !hasSideEffects;
@@ -127,15 +124,15 @@ class SideEffectsFlagPlugin {
 					 * @param {JavascriptParser} parser the parser
 					 * @returns {void}
 					 */
-					const parserHandler = parser => {
-						/** @type {undefined | Statement | ModuleDeclaration} */
+					const parserHandler = (parser) => {
+						/** @type {undefined | Statement | ModuleDeclaration | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration} */
 						let sideEffectsStatement;
 						parser.hooks.program.tap(PLUGIN_NAME, () => {
 							sideEffectsStatement = undefined;
 						});
 						parser.hooks.statement.tap(
 							{ name: PLUGIN_NAME, stage: -100 },
-							statement => {
+							(statement) => {
 								if (sideEffectsStatement) return;
 								if (parser.scope.topLevelScope !== true) return;
 								switch (statement.type) {
@@ -143,7 +140,8 @@ class SideEffectsFlagPlugin {
 										if (
 											!parser.isPure(
 												statement.expression,
-												/** @type {Range} */ (statement.range)[0]
+												/** @type {Range} */
+												(statement.range)[0]
 											)
 										) {
 											sideEffectsStatement = statement;
@@ -155,7 +153,8 @@ class SideEffectsFlagPlugin {
 										if (
 											!parser.isPure(
 												statement.test,
-												/** @type {Range} */ (statement.range)[0]
+												/** @type {Range} */
+												(statement.range)[0]
 											)
 										) {
 											sideEffectsStatement = statement;
@@ -191,7 +190,8 @@ class SideEffectsFlagPlugin {
 										if (
 											!parser.isPure(
 												statement.discriminant,
-												/** @type {Range} */ (statement.range)[0]
+												/** @type {Range} */
+												(statement.range)[0]
 											)
 										) {
 											sideEffectsStatement = statement;
@@ -214,9 +214,9 @@ class SideEffectsFlagPlugin {
 									case "ExportDefaultDeclaration":
 										if (
 											!parser.isPure(
-												/** @type {TODO} */
-												(statement.declaration),
-												/** @type {Range} */ (statement.range)[0]
+												statement.declaration,
+												/** @type {Range} */
+												(statement.range)[0]
 											)
 										) {
 											sideEffectsStatement = statement;
@@ -270,7 +270,7 @@ class SideEffectsFlagPlugin {
 						name: PLUGIN_NAME,
 						stage: STAGE_DEFAULT
 					},
-					modules => {
+					(modules) => {
 						const logger = compilation.getLogger(
 							"webpack.SideEffectsFlagPlugin"
 						);
@@ -282,7 +282,7 @@ class SideEffectsFlagPlugin {
 						/**
 						 * @param {Module} module module
 						 */
-						const optimizeIncomingConnections = module => {
+						const optimizeIncomingConnections = (module) => {
 							if (optimizedModules.has(module)) return;
 							optimizedModules.add(module);
 							if (module.getSideEffectsConnectionState(moduleGraph) === false) {
@@ -313,8 +313,17 @@ class SideEffectsFlagPlugin {
 												({ module }) =>
 													module.getSideEffectsConnectionState(moduleGraph) ===
 													false,
-												({ module: newModule, export: exportName }) => {
+												({
+													module: newModule,
+													export: exportName,
+													connection: targetConnection
+												}) => {
 													moduleGraph.updateModule(dep, newModule);
+													moduleGraph.updateParent(
+														dep,
+														targetConnection,
+														/** @type {Module} */ (connection.originModule)
+													);
 													moduleGraph.addExplanation(
 														dep,
 														"(skipped side-effect-free modules)"
@@ -346,6 +355,13 @@ class SideEffectsFlagPlugin {
 											if (!target) continue;
 
 											moduleGraph.updateModule(dep, target.module);
+											moduleGraph.updateParent(
+												dep,
+												/** @type {ModuleGraphConnection} */ (
+													target.connection
+												),
+												/** @type {Module} */ (connection.originModule)
+											);
 											moduleGraph.addExplanation(
 												dep,
 												"(skipped side-effect-free modules)"
@@ -365,6 +381,7 @@ class SideEffectsFlagPlugin {
 						for (const module of modules) {
 							optimizeIncomingConnections(module);
 						}
+						moduleGraph.finishUpdateParent();
 						logger.timeEnd("update dependencies");
 					}
 				);
@@ -374,8 +391,8 @@ class SideEffectsFlagPlugin {
 
 	/**
 	 * @param {string} moduleName the module name
-	 * @param {undefined | boolean | string | string[]} flagValue the flag value
-	 * @param {Map<string, RegExp>} cache cache for glob to regexp
+	 * @param {SideEffectsFlagValue} flagValue the flag value
+	 * @param {CacheItem} cache cache for glob to regexp
 	 * @returns {boolean | undefined} true, when the module has side effects, undefined or false when not
 	 */
 	static moduleHasSideEffects(moduleName, flagValue, cache) {
@@ -387,10 +404,11 @@ class SideEffectsFlagPlugin {
 			case "string":
 				return globToRegexp(flagValue, cache).test(moduleName);
 			case "object":
-				return flagValue.some(glob =>
+				return flagValue.some((glob) =>
 					SideEffectsFlagPlugin.moduleHasSideEffects(moduleName, glob, cache)
 				);
 		}
 	}
 }
+
 module.exports = SideEffectsFlagPlugin;