webpack 5.99.5 → 5.99.7

package/README.md

@@ -676,5 +676,5 @@ Before we started using OpenCollective, donations were made anonymously. Now tha
 [builds2-url]: https://dev.azure.com/webpack/webpack/_build/latest?definitionId=3&branchName=main
 [dependency-review-url]: https://github.com/webpack/webpack/actions/workflows/dependency-review.yml
 [dependency-review]: https://github.com/webpack/webpack/actions/workflows/dependency-review.yml/badge.svg
-[cover]: https://codecov.io/gh/webpack/webpack/branch/master/graph/badge.svg?token=mDP3mQJNnn
+[cover]: https://codecov.io/gh/webpack/webpack/graph/badge.svg?token=mDP3mQJNnn
 [cover-url]: https://codecov.io/gh/webpack/webpack

package/lib/APIPlugin.js

@@ -134,12 +134,12 @@ const PLUGIN_NAME = "APIPlugin";
 
 /**
  * @typedef {object} APIPluginOptions
- * @property {boolean} [module] the output filename
+ * @property {boolean=} module the output filename
  */
 
 class APIPlugin {
 	/**
-	 * @param {APIPluginOptions} [options] options
+	 * @param {APIPluginOptions=} options options
 	 */
 	constructor(options = {}) {
 		this.options = options;

package/lib/AutomaticPrefetchPlugin.js

@@ -11,6 +11,8 @@ const PrefetchDependency = require("./dependencies/PrefetchDependency");
 
 /** @typedef {import("./Compiler")} Compiler */
 
+const PLUGIN_NAME = "AutomaticPrefetchPlugin";
+
 class AutomaticPrefetchPlugin {
 	/**
 	 * Apply the plugin
@@ -19,7 +21,7 @@ class AutomaticPrefetchPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"AutomaticPrefetchPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					PrefetchDependency,
@@ -29,7 +31,7 @@ class AutomaticPrefetchPlugin {
 		);
 		/** @type {{context: string | null, request: string}[] | null} */
 		let lastModules = null;
-		compiler.hooks.afterCompile.tap("AutomaticPrefetchPlugin", compilation => {
+		compiler.hooks.afterCompile.tap(PLUGIN_NAME, compilation => {
 			lastModules = [];
 
 			for (const m of compilation.modules) {
@@ -41,26 +43,23 @@ class AutomaticPrefetchPlugin {
 				}
 			}
 		});
-		compiler.hooks.make.tapAsync(
-			"AutomaticPrefetchPlugin",
-			(compilation, callback) => {
-				if (!lastModules) return callback();
-				asyncLib.each(
-					lastModules,
-					(m, callback) => {
-						compilation.addModuleChain(
-							m.context || compiler.context,
-							new PrefetchDependency(`!!${m.request}`),
-							callback
-						);
-					},
-					err => {
-						lastModules = null;
-						callback(err);
-					}
-				);
-			}
-		);
+		compiler.hooks.make.tapAsync(PLUGIN_NAME, (compilation, callback) => {
+			if (!lastModules) return callback();
+			asyncLib.each(
+				lastModules,
+				(m, callback) => {
+					compilation.addModuleChain(
+						m.context || compiler.context,
+						new PrefetchDependency(`!!${m.request}`),
+						callback
+					);
+				},
+				err => {
+					lastModules = null;
+					callback(err);
+				}
+			);
+		});
 	}
 }
 module.exports = AutomaticPrefetchPlugin;

package/lib/BannerPlugin.js

@@ -44,6 +44,8 @@ const wrapComment = str => {
 		.trimEnd()}\n */`;
 };
 
+const PLUGIN_NAME = "BannerPlugin";
+
 class BannerPlugin {
 	/**
 	 * @param {BannerPluginArgument} options options object
@@ -91,47 +93,41 @@ class BannerPlugin {
 		const stage =
 			this.options.stage || Compilation.PROCESS_ASSETS_STAGE_ADDITIONS;
 
-		compiler.hooks.compilation.tap("BannerPlugin", compilation => {
-			compilation.hooks.processAssets.tap(
-				{
-					name: "BannerPlugin",
-					stage
-				},
-				() => {
-					for (const chunk of compilation.chunks) {
-						if (options.entryOnly && !chunk.canBeInitial()) {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+			compilation.hooks.processAssets.tap({ name: PLUGIN_NAME, stage }, () => {
+				for (const chunk of compilation.chunks) {
+					if (options.entryOnly && !chunk.canBeInitial()) {
+						continue;
+					}
+
+					for (const file of chunk.files) {
+						if (!matchObject(file)) {
 							continue;
 						}
 
-						for (const file of chunk.files) {
-							if (!matchObject(file)) {
-								continue;
+						/** @type {PathData} */
+						const data = { chunk, filename: file };
+
+						const comment = compilation.getPath(
+							/** @type {TemplatePath} */
+							(banner),
+							data
+						);
+
+						compilation.updateAsset(file, old => {
+							const cached = cache.get(old);
+							if (!cached || cached.comment !== comment) {
+								const source = options.footer
+									? new ConcatSource(old, "\n", comment)
+									: new ConcatSource(comment, "\n", old);
+								cache.set(old, { source, comment });
+								return source;
 							}
-
-							/** @type {PathData} */
-							const data = { chunk, filename: file };
-
-							const comment = compilation.getPath(
-								/** @type {TemplatePath} */
-								(banner),
-								data
-							);
-
-							compilation.updateAsset(file, old => {
-								const cached = cache.get(old);
-								if (!cached || cached.comment !== comment) {
-									const source = options.footer
-										? new ConcatSource(old, "\n", comment)
-										: new ConcatSource(comment, "\n", old);
-									cache.set(old, { source, comment });
-									return source;
-								}
-								return cached.source;
-							});
-						}
+							return cached.source;
+						});
 					}
 				}
-			);
+			});
 		});
 	}
 }

package/lib/Cache.js

@@ -26,7 +26,7 @@ const {
  * @returns {void}
  */
 
-/** @typedef {TODO} Data */
+/** @typedef {EXPECTED_ANY} Data */
 
 /**
  * @callback GotHandler

package/lib/Chunk.js

@@ -34,7 +34,9 @@ const { mergeRuntime } = require("./util/runtime");
 /** @typedef {import("./util/Hash")} Hash */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
+/** @typedef {string | null} ChunkName */
 /** @typedef {number | string} ChunkId */
+/** @typedef {SortableSet<string>} IdNameHints */
 
 const ChunkFilesSet = createArrayToSetDeprecationSet("chunk.files");
 
@@ -46,9 +48,9 @@ const ChunkFilesSet = createArrayToSetDeprecationSet("chunk.files");
 /**
  * @deprecated
  * @typedef {object} ChunkMaps
- * @property {Record<string|number, string>} hash
- * @property {Record<string|number, Record<string, string>>} contentHash
- * @property {Record<string|number, string>} name
+ * @property {Record<string | number, string>} hash
+ * @property {Record<string | number, Record<string, string>>} contentHash
+ * @property {Record<string | number, string>} name
  */
 
 /**
@@ -66,7 +68,7 @@ let debugId = 1000;
  */
 class Chunk {
 	/**
-	 * @param {(string | null)=} name of chunk being created, is optional (for subclasses)
+	 * @param {ChunkName=} name of chunk being created, is optional (for subclasses)
 	 * @param {boolean} backCompat enable backward-compatibility
 	 */
 	constructor(name, backCompat = true) {
@@ -76,9 +78,9 @@ class Chunk {
 		this.ids = null;
 		/** @type {number} */
 		this.debugId = debugId++;
-		/** @type {string | null | undefined} */
+		/** @type {ChunkName | undefined} */
 		this.name = name;
-		/** @type {SortableSet<string>} */
+		/** @type {IdNameHints} */
 		this.idNameHints = new SortableSet();
 		/** @type {boolean} */
 		this.preventIntegration = false;
@@ -696,7 +698,7 @@ class Chunk {
 	/**
 	 * @param {ChunkGraph} chunkGraph the chunk graph
 	 * @param {ChunkFilterPredicate=} filterFn function used to filter chunks
-	 * @returns {Record<string, (string | number)[]>} a record object of names to lists of child ids(?)
+	 * @returns {Record<string, ChunkId[]>} a record object of names to lists of child ids(?)
 	 */
 	getChildIdsByOrders(chunkGraph, filterFn) {
 		/** @type {Map<string, {order: number, group: ChunkGroup}[]>} */
@@ -717,7 +719,8 @@ class Chunk {
 									/** @type {number} */
 									(
 										childGroup.options[
-											/** @type {keyof ChunkGroupOptions} */ (key)
+											/** @type {keyof ChunkGroupOptions} */
+											(key)
 										]
 									),
 								group: childGroup
@@ -735,7 +738,7 @@ class Chunk {
 				if (cmp !== 0) return cmp;
 				return a.group.compareTo(chunkGraph, b.group);
 			});
-			/** @type {Set<string | number>} */
+			/** @type {Set<ChunkId>} */
 			const chunkIdSet = new Set();
 			for (const item of list) {
 				for (const chunk of item.group.chunks) {

package/lib/CleanPlugin.js

@@ -296,6 +296,8 @@ const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
 /** @type {WeakMap<Compilation, CleanPluginCompilationHooks>} */
 const compilationHooksMap = new WeakMap();
 
+const PLUGIN_NAME = "CleanPlugin";
+
 class CleanPlugin {
 	/**
 	 * @param {Compilation} compilation the compilation
@@ -349,18 +351,18 @@ class CleanPlugin {
 
 		compiler.hooks.emit.tapAsync(
 			{
-				name: "CleanPlugin",
+				name: PLUGIN_NAME,
 				stage: 100
 			},
 			(compilation, callback) => {
 				const hooks = CleanPlugin.getCompilationHooks(compilation);
-				const logger = compilation.getLogger("webpack.CleanPlugin");
+				const logger = compilation.getLogger(`webpack.${PLUGIN_NAME}`);
 				const fs = /** @type {OutputFileSystem} */ (compiler.outputFileSystem);
 
 				if (!fs.readdir) {
 					return callback(
 						new Error(
-							"CleanPlugin: Output filesystem doesn't support listing directories (readdir)"
+							`${PLUGIN_NAME}: Output filesystem doesn't support listing directories (readdir)`
 						)
 					);
 				}

package/lib/Compilation.js

@@ -94,10 +94,13 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
 /** @typedef {import("./Cache")} Cache */
 /** @typedef {import("./CacheFacade")} CacheFacade */
+/** @typedef {import("./Chunk").ChunkName} ChunkName */
 /** @typedef {import("./Chunk").ChunkId} ChunkId */
 /** @typedef {import("./ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Compiler").CompilationParams} CompilationParams */
+/** @typedef {import("./Compiler").MemCache} MemCache */
+/** @typedef {import("./Compiler").WeakReferences} WeakReferences */
 /** @typedef {import("./Compiler").ModuleMemCachesItem} ModuleMemCachesItem */
 /** @typedef {import("./DependenciesBlock")} DependenciesBlock */
 /** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
@@ -106,6 +109,7 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
 /** @typedef {import("./Module").BuildInfo} BuildInfo */
 /** @typedef {import("./Module").ValueCacheVersions} ValueCacheVersions */
+/** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */
 /** @typedef {import("./NormalModule").NormalModuleCompilationHooks} NormalModuleCompilationHooks */
 /** @typedef {import("./Module").FactoryMeta} FactoryMeta */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
@@ -132,7 +136,6 @@ const { isSourceEqual } = require("./util/source");
  * @typedef {import("./util/deprecation").FakeHook<T>} FakeHook<T>
  */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
-/** @typedef {WeakMap<Dependency, Module>} References */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /**
  * @callback Callback
@@ -168,12 +171,6 @@ const { isSourceEqual } = require("./util/source");
  * @returns {void}
  */
 
-/**
- * @callback DepBlockVarDependenciesCallback
- * @param {Dependency} dependency
- * @returns {any}
- */
-
 /** @typedef {new (...args: EXPECTED_ANY[]) => Dependency} DepConstructor */
 
 /** @typedef {Record<string, Source>} CompilationAssets */
@@ -235,17 +232,17 @@ const { isSourceEqual } = require("./util/source");
 
 /**
  * @typedef {object} ExecuteModuleObject
- * @property {string} [id] module id
+ * @property {string=} id module id
  * @property {ExecuteModuleExports} exports exports
  * @property {boolean} loaded is loaded
- * @property {Error} [error] error
+ * @property {Error=} error error
  */
 
 /**
  * @typedef {object} ExecuteModuleArgument
  * @property {Module} module
  * @property {ExecuteModuleObject=} moduleObject
- * @property {any} preparedInfo
+ * @property {TODO} preparedInfo
  * @property {CodeGenerationResult} codeGenerationResult
  */
 
@@ -253,7 +250,7 @@ const { isSourceEqual } = require("./util/source");
 
 /**
  * @typedef {object} ExecuteOptions
- * @property {string} [id] module id
+ * @property {string=} id module id
  * @property {ExecuteModuleObject} module module
  * @property {WebpackRequire} require require function
  */
@@ -333,6 +330,8 @@ const { isSourceEqual } = require("./util/source");
  * @property {string=} url
  */
 
+/** @typedef {"module" | "chunk" | "root-of-chunk" | "nested"} ExcludeModulesType */
+
 /**
  * @typedef {object} KnownNormalizedStatsOptions
  * @property {string} context
@@ -349,7 +348,7 @@ const { isSourceEqual } = require("./util/source");
  * @property {boolean} groupAssetsByExtension
  * @property {number} assetsSpace
  * @property {((value: string, asset: StatsAsset) => boolean)[]} excludeAssets
- * @property {((name: string, module: StatsModule, type: "module" | "chunk" | "root-of-chunk" | "nested") => boolean)[]} excludeModules
+ * @property {((name: string, module: StatsModule, type: ExcludeModulesType) => boolean)[]} excludeModules
  * @property {((warning: StatsError, textValue: string) => boolean)[]} warningsFilter
  * @property {boolean} cachedModules
  * @property {boolean} orphanModules
@@ -459,10 +458,10 @@ const compareErrors = concatComparators(byModule, byLocation, byMessage);
 
 /**
  * @typedef {object} KnownUnsafeCacheData
- * @property {FactoryMeta} [factoryMeta] factory meta
- * @property {ResolveOptions} [resolveOptions] resolve options
- * @property {ParserOptions} [parserOptions]
- * @property {GeneratorOptions} [generatorOptions]
+ * @property {FactoryMeta=} factoryMeta factory meta
+ * @property {ResolveOptions=} resolveOptions resolve options
+ * @property {ParserOptions=} parserOptions
+ * @property {GeneratorOptions=} generatorOptions
  */
 
 /** @typedef {KnownUnsafeCacheData & Record<string, EXPECTED_ANY>} UnsafeCacheData */
@@ -477,7 +476,8 @@ const unsafeCacheDependencies = new WeakMap();
 /** @type {WeakMap<ModuleWithRestoreFromUnsafeCache, UnsafeCacheData>} */
 const unsafeCacheData = new WeakMap();
 
-/** @typedef {Map<Module, WeakTupleMap<any, any>>} ModuleMemCaches */
+/** @typedef {{ id: ModuleId, modules?: Map<Module, string | number | undefined>, blocks?: (string | number | null)[] }} References */
+/** @typedef {Map<Module, WeakTupleMap<EXPECTED_ANY[], EXPECTED_ANY>>} ModuleMemCaches */
 
 class Compilation {
 	/**
@@ -690,7 +690,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						processAssetsHook.tapAsync(
 							getOptions(options),
 							(assets, callback) =>
-								/** @type {any} */ (fn)(...getArgs(), callback)
+								/** @type {TODO} */ (fn)(...getArgs(), callback)
 						);
 					},
 					/** @type {AsyncSeriesHook<T>["tapPromise"]} */
@@ -973,9 +973,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			/** @type {SyncBailHook<[string, LogEntry], boolean | void>} */
 			log: new SyncBailHook(["origin", "logEntry"]),
 
-			/** @type {SyncWaterfallHook<[WebpackError[]]>} */
+			/** @type {SyncWaterfallHook<[Error[]]>} */
 			processWarnings: new SyncWaterfallHook(["warnings"]),
-			/** @type {SyncWaterfallHook<[WebpackError[]]>} */
+			/** @type {SyncWaterfallHook<[Error[]]>} */
 			processErrors: new SyncWaterfallHook(["errors"]),
 
 			/** @type {HookMap<SyncHook<[Partial<NormalizedStatsOptions>, CreateStatsOptionsContext]>>} */
@@ -1049,6 +1049,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		};
 		defineRemovedModuleTemplates(this.moduleTemplates);
 
+		// We need to think how implement types here
 		/** @type {ModuleMemCaches | undefined} */
 		this.moduleMemCaches = undefined;
 		/** @type {ModuleMemCaches | undefined} */
@@ -1099,7 +1100,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		 */
 		this.creatingModuleDuringBuild = new WeakMap();
 
-		/** @type {Map<string, EntryData>} */
+		/** @type {Map<Exclude<ChunkName, null>, EntryData>} */
 		this.entries = new Map();
 		/** @type {EntryData} */
 		this.globalEntry = {
@@ -1142,9 +1143,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.assetsInfo = new Map();
 		/** @type {Map<string, Map<string, Set<string>>>} */
 		this._assetsRelatedIn = new Map();
-		/** @type {WebpackError[]} */
+		/** @type {Error[]} */
 		this.errors = [];
-		/** @type {WebpackError[]} */
+		/** @type {Error[]} */
 		this.warnings = [];
 		/** @type {Compilation[]} */
 		this.children = [];
@@ -2501,10 +2502,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 		/**
 		 * @param {Module} module module
-		 * @returns {References | undefined} references
+		 * @returns {WeakReferences | undefined} references
 		 */
 		const computeReferences = module => {
-			/** @type {References | undefined} */
+			/** @type {WeakReferences | undefined} */
 			let references;
 			for (const connection of moduleGraph.getOutgoingConnections(module)) {
 				const d = connection.dependency;
@@ -2518,7 +2519,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 		/**
 		 * @param {Module} module the module
-		 * @param {References | undefined} references references
+		 * @param {WeakReferences | undefined} references references
 		 * @returns {boolean} true, when the references differ
 		 */
 		const compareReferences = (module, references) => {
@@ -2540,6 +2541,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				if (buildInfo) {
 					if (cachedMemCache.buildInfo !== buildInfo) {
 						// use a new one
+						/** @type {MemCache} */
 						const memCache = new WeakTupleMap();
 						moduleMemCaches.set(module, memCache);
 						affectedModules.add(module);
@@ -2549,6 +2551,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						statChanged++;
 					} else if (!compareReferences(module, cachedMemCache.references)) {
 						// use a new one
+						/** @type {MemCache} */
 						const memCache = new WeakTupleMap();
 						moduleMemCaches.set(module, memCache);
 						affectedModules.add(module);
@@ -2639,6 +2642,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				} else {
 					affectedModules.add(referencingModule);
 				}
+				/** @type {MemCache} */
 				const memCache = new WeakTupleMap();
 				const cache =
 					/** @type {ModuleMemCachesItem} */
@@ -2671,7 +2675,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		let statNew = 0;
 		/**
 		 * @param {Module} module module
-		 * @returns {{ id: ModuleId, modules?: Map<Module, string | number | undefined>, blocks?: (string | number | null)[] }} references
+		 * @returns {References} references
 		 */
 		const computeReferences = module => {
 			const id = /** @type {ModuleId} */ (chunkGraph.getModuleId(module));
@@ -2741,9 +2745,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		};
 
 		for (const [module, memCache] of moduleMemCaches) {
-			/** @type {{ references: { id: string | number, modules?: Map<Module, string | number | undefined>, blocks?: (string | number | null)[]}, memCache: WeakTupleMap<any[], any> }} */
+			/** @type {{ references: References, memCache: MemCache } | undefined} */
 			const cache = memCache.get(key);
 			if (cache === undefined) {
+				/** @type {WeakTupleMap<Module[], RuntimeRequirements | null> | undefined} */
 				const memCache2 = new WeakTupleMap();
 				memCache.set(key, {
 					references: computeReferences(module),
@@ -2752,6 +2757,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				moduleMemCaches2.set(module, memCache2);
 				statNew++;
 			} else if (!compareReferences(module, cache.references)) {
+				/** @type {WeakTupleMap<Module[], RuntimeRequirements | null> | undefined} */
 				const memCache = new WeakTupleMap();
 				cache.references = computeReferences(module);
 				cache.memCache = memCache;
@@ -3732,7 +3738,8 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 								chunkGraph.addModuleRuntimeRequirements(
 									module,
 									runtime,
-									cached,
+									/** @type {RuntimeRequirements} */
+									(cached),
 									false
 								);
 							}
@@ -3980,7 +3987,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	/**
 	 * This method first looks to see if a name is provided for a new chunk,
 	 * and first looks to see if any named chunks already exist and reuse that chunk instead.
-	 * @param {(string | null)=} name optional chunk name to be provided
+	 * @param {ChunkName=} name optional chunk name to be provided
 	 * @returns {Chunk} create a chunk (invoked during seal event)
 	 */
 	addChunk(name) {
@@ -4237,7 +4244,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 			const memCache = moduleMemCaches2 && moduleMemCaches2.get(module);
 			for (const runtime of chunkGraph.getModuleRuntimes(module)) {
 				if (memCache) {
-					const digest = memCache.get(`moduleHash-${getRuntimeKey(runtime)}`);
+					const digest =
+						/** @type {string} */
+						(memCache.get(`moduleHash-${getRuntimeKey(runtime)}`));
 					if (digest !== undefined) {
 						chunkGraph.setModuleHashes(
 							module,
@@ -5477,9 +5486,9 @@ This prevents using hashes of each other and should be avoided.`);
 											if (strictModuleExceptionHandling) {
 												if (id) delete moduleCache[id];
 											} else if (strictModuleErrorHandling) {
-												moduleObject.error = /** @type {WebpackError} */ (
-													execErr
-												);
+												moduleObject.error =
+													/** @type {WebpackError} */
+													(execErr);
 											}
 											if (!(/** @type {WebpackError} */ (execErr).module)) {
 												/** @type {WebpackError} */
@@ -5506,7 +5515,8 @@ This prevents using hashes of each other and should be avoided.`);
 										`Execution of module code from module graph (${
 											/** @type {Module} */
 											(module).readableIdentifier(this.requestShortener)
-										}) failed: ${message}`
+										}) failed: ${message}`,
+										{ cause: execErr }
 									);
 									err.stack = stack;
 									err.module = module;

package/lib/Compiler.js

@@ -40,7 +40,7 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
 /** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
 /** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./Compilation").References} References */
+/** @typedef {import("./ChunkGraph").ModuleId} ModuleId */
 /** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./Module").BuildInfo} BuildInfo */
@@ -90,10 +90,11 @@ const { isSourceEqual } = require("./util/source");
  */
 
 /** @typedef {{ sizeOnlySource: SizeOnlySource | undefined, writtenTo: Map<string, number> }} CacheEntry */
-
 /** @typedef {{ path: string, source: Source, size: number | undefined, waiting: ({ cacheEntry: CacheEntry, file: string }[] | undefined) }} SimilarEntry */
 
-/** @typedef {{ buildInfo: BuildInfo, references: References | undefined, memCache: import("./util/WeakTupleMap")<Module[], string> }} ModuleMemCachesItem */
+/** @typedef {WeakMap<Dependency, Module>} WeakReferences */
+/** @typedef {import("./util/WeakTupleMap")<EXPECTED_ANY[], EXPECTED_ANY>} MemCache */
+/** @typedef {{ buildInfo: BuildInfo, references: WeakReferences | undefined, memCache: MemCache }} ModuleMemCachesItem */
 
 /**
  * @param {string[]} array an array
@@ -624,7 +625,8 @@ class Compiler {
 				callback(err, entries, compilation);
 			} catch (runAsChildErr) {
 				const err = new WebpackError(
-					`compiler.runAsChild callback error: ${runAsChildErr}`
+					`compiler.runAsChild callback error: ${runAsChildErr}`,
+					{ cause: runAsChildErr }
 				);
 				err.details = /** @type {Error} */ (runAsChildErr).stack;
 				/** @type {Compilation} */

package/lib/ContextExclusionPlugin.js

@@ -7,6 +7,8 @@
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./ContextModuleFactory")} ContextModuleFactory */
 
+const PLUGIN_NAME = "ContextExclusionPlugin";
+
 class ContextExclusionPlugin {
 	/**
 	 * @param {RegExp} negativeMatcher Matcher regular expression
@@ -21,8 +23,8 @@ class ContextExclusionPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.contextModuleFactory.tap("ContextExclusionPlugin", cmf => {
-			cmf.hooks.contextModuleFiles.tap("ContextExclusionPlugin", files =>
+		compiler.hooks.contextModuleFactory.tap(PLUGIN_NAME, cmf => {
+			cmf.hooks.contextModuleFiles.tap(PLUGIN_NAME, files =>
 				files.filter(filePath => !this.negativeMatcher.test(filePath))
 			);
 		});

package/lib/ContextModule.js

@@ -29,6 +29,7 @@ const {
 const makeSerializable = require("./util/makeSerializable");
 
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
 /** @typedef {import("./Chunk")} Chunk */
 /** @typedef {import("./Chunk").ChunkId} ChunkId */
@@ -83,7 +84,7 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {false|string|string[]} resource
  * @property {string=} resourceQuery
  * @property {string=} resourceFragment
- * @property {TODO} resolveOptions
+ * @property {ResolveOptions=} resolveOptions
  */
 
 /** @typedef {ContextOptions & ContextModuleOptionsExtras} ContextModuleOptions */