webpack 5.94.0 → 5.96.0

package/README.md

@@ -39,7 +39,7 @@
   <a href="https://twitter.com/Webpack">
 		<img src="https://img.shields.io/twitter/follow/Webpack?style=social">
 	</a>
-  <a href="https://discord.gg/Tt5cKVwx">
+  <a href="https://discord.gg/5sxFZPdx2k">
 		<img src="https://img.shields.io/discord/1180618526436888586?label=discord&logo=discord&logoColor=white&style=flat">
 	</a>
   <h1>webpack</h1>

package/lib/AsyncDependenciesBlock.js

@@ -39,7 +39,7 @@ class AsyncDependenciesBlock extends DependenciesBlock {
 	}
 
 	/**
-	 * @returns {string | undefined} The name of the chunk
+	 * @returns {string | null | undefined} The name of the chunk
 	 */
 	get chunkName() {
 		return this.groupOptions.name;

package/lib/BannerPlugin.js

@@ -19,7 +19,8 @@ const createSchemaValidation = require("./util/create-schema-validation");
 /** @typedef {import("./TemplatedPathPlugin").TemplatePath} TemplatePath */
 
 const validate = createSchemaValidation(
-	require("../schemas/plugins/BannerPlugin.check.js"),
+	/** @type {(function(typeof import("../schemas/plugins/BannerPlugin.json")): boolean)} */
+	(require("../schemas/plugins/BannerPlugin.check.js")),
 	() => require("../schemas/plugins/BannerPlugin.json"),
 	{
 		name: "Banner Plugin",

package/lib/Chunk.js

@@ -839,6 +839,36 @@ class Chunk {
 
 		return chunkMaps;
 	}
+
+	/**
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @param {string} type option name
+	 * @param {boolean=} includeDirectChildren include direct children (by default only children of async children are included)
+	 * @param {ChunkFilterPredicate=} filterFn function used to filter chunks
+	 * @returns {boolean} true when the child is of type order, otherwise false
+	 */
+	hasChildByOrder(chunkGraph, type, includeDirectChildren, filterFn) {
+		if (includeDirectChildren) {
+			/** @type {Set<Chunk>} */
+			const chunks = new Set();
+			for (const chunkGroup of this.groupsIterable) {
+				for (const chunk of chunkGroup.chunks) {
+					chunks.add(chunk);
+				}
+			}
+			for (const chunk of chunks) {
+				const data = chunk.getChildIdsByOrders(chunkGraph, filterFn);
+				if (data[type] !== undefined) return true;
+			}
+		}
+
+		for (const chunk of this.getAllAsyncChunks()) {
+			const data = chunk.getChildIdsByOrders(chunkGraph, filterFn);
+			if (data[type] !== undefined) return true;
+		}
+
+		return false;
+	}
 }
 
 module.exports = Chunk;

package/lib/ChunkGraph.js

@@ -32,7 +32,9 @@ const {
 /** @typedef {import("./Chunk")} Chunk */
 /** @typedef {import("./Chunk").ChunkId} ChunkId */
 /** @typedef {import("./ChunkGroup")} ChunkGroup */
+/** @typedef {import("./Generator").SourceTypes} SourceTypes */
 /** @typedef {import("./Module")} Module */
+/** @typedef {import("./Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("./RuntimeModule")} RuntimeModule */
@@ -119,7 +121,10 @@ const modulesBySourceType = sourceTypesByModule => set => {
 };
 const defaultModulesBySourceType = modulesBySourceType(undefined);
 
-/** @type {WeakMap<Function, any>} */
+/**
+ * @template T
+ * @type {WeakMap<Function, any>}
+ */
 const createOrderedArrayFunctionMap = new WeakMap();
 
 /**
@@ -624,7 +629,7 @@ class ChunkGraph {
 	/**
 	 * @param {Chunk} chunk chunk
 	 * @param {Module} module chunk module
-	 * @returns {Set<string>} source types
+	 * @returns {SourceTypes} source types
 	 */
 	getChunkModuleSourceTypes(chunk, module) {
 		const cgc = this._getChunkGraphChunk(chunk);
@@ -636,7 +641,7 @@ class ChunkGraph {
 
 	/**
 	 * @param {Module} module module
-	 * @returns {Set<string>} source types
+	 * @returns {SourceTypes} source types
 	 */
 	getModuleSourceTypes(module) {
 		return (
@@ -1526,7 +1531,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	/**
 	 * @param {Module} module the module
 	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {ReadonlySet<string>} runtime requirements
+	 * @returns {ReadOnlyRuntimeRequirements} runtime requirements
 	 */
 	getModuleRuntimeRequirements(module, runtime) {
 		const cgm = this._getChunkGraphModule(module);
@@ -1537,7 +1542,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 
 	/**
 	 * @param {Chunk} chunk the chunk
-	 * @returns {ReadonlySet<string>} runtime requirements
+	 * @returns {ReadOnlyRuntimeRequirements} runtime requirements
 	 */
 	getChunkRuntimeRequirements(chunk) {
 		const cgc = this._getChunkGraphChunk(chunk);
@@ -1734,7 +1739,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 
 	/**
 	 * @param {Chunk} chunk the chunk
-	 * @returns {ReadonlySet<string>} runtime requirements
+	 * @returns {ReadOnlyRuntimeRequirements} runtime requirements
 	 */
 	getTreeRuntimeRequirements(chunk) {
 		const cgc = this._getChunkGraphChunk(chunk);

package/lib/ChunkGroup.js

@@ -31,7 +31,7 @@ const {
  * @property {("low" | "high" | "auto")=} fetchPriority
  */
 
-/** @typedef {RawChunkGroupOptions & { name?: string }} ChunkGroupOptions */
+/** @typedef {RawChunkGroupOptions & { name?: string | null }} ChunkGroupOptions */
 
 let debugId = 5000;
 
@@ -137,7 +137,7 @@ class ChunkGroup {
 
 	/**
 	 * returns the name of current ChunkGroup
-	 * @returns {string | undefined} returns the ChunkGroup name
+	 * @returns {string | null | undefined} returns the ChunkGroup name
 	 */
 	get name() {
 		return this.options.name;

package/lib/CleanPlugin.js

@@ -25,13 +25,13 @@ const processAsyncTree = require("./util/processAsyncTree");
 
 /**
  * @typedef {object} CleanPluginCompilationHooks
- * @property {SyncBailHook<[string], boolean>} keep when returning true the file/directory will be kept during cleaning, returning false will clean it and ignore the following plugins and config
+ * @property {SyncBailHook<[string], boolean | void>} keep when returning true the file/directory will be kept during cleaning, returning false will clean it and ignore the following plugins and config
  */
 
 /**
  * @callback KeepFn
  * @param {string} path path
- * @returns {boolean} true, if the path should be kept
+ * @returns {boolean | void} true, if the path should be kept
  */
 
 const validate = createSchemaValidation(
@@ -149,7 +149,7 @@ const doStat = (fs, filename, callback) => {
  * @param {boolean} dry only log instead of fs modification
  * @param {Logger} logger logger
  * @param {Set<string>} diff filenames of the assets that shouldn't be there
- * @param {function(string): boolean} isKept check if the entry is ignored
+ * @param {function(string): boolean | void} isKept check if the entry is ignored
  * @param {function(Error=, Assets=): void} callback callback
  * @returns {void}
  */
@@ -310,7 +310,6 @@ class CleanPlugin {
 		let hooks = compilationHooksMap.get(compilation);
 		if (hooks === undefined) {
 			hooks = {
-				/** @type {SyncBailHook<[string], boolean>} */
 				keep: new SyncBailHook(["ignore"])
 			};
 			compilationHooksMap.set(compilation, hooks);
@@ -393,7 +392,7 @@ class CleanPlugin {
 
 				/**
 				 * @param {string} path path
-				 * @returns {boolean} true, if needs to be kept
+				 * @returns {boolean | void} true, if needs to be kept
 				 */
 				const isKept = path => {
 					const result = hooks.keep.call(path);

package/lib/CodeGenerationResults.js

@@ -13,6 +13,7 @@ const { runtimeToString, RuntimeSpecMap } = require("./util/runtime");
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("./Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
 /** @typedef {typeof import("./util/Hash")} Hash */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
@@ -42,9 +43,7 @@ class CodeGenerationResults {
 			);
 		}
 		if (runtime === undefined) {
-			if (
-				/** @type {RuntimeSpecMap<CodeGenerationResult>} */ (entry).size > 1
-			) {
+			if (entry.size > 1) {
 				const results = new Set(entry.values());
 				if (results.size !== 1) {
 					throw new Error(
@@ -99,13 +98,15 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	 * @returns {Source} a source
 	 */
 	getSource(module, runtime, sourceType) {
-		return this.get(module, runtime).sources.get(sourceType);
+		return /** @type {Source} */ (
+			this.get(module, runtime).sources.get(sourceType)
+		);
 	}
 
 	/**
 	 * @param {Module} module the module
 	 * @param {RuntimeSpec} runtime runtime(s)
-	 * @returns {ReadonlySet<string>} runtime requirements
+	 * @returns {ReadOnlyRuntimeRequirements | null} runtime requirements
 	 */
 	getRuntimeRequirements(module, runtime) {
 		return this.get(module, runtime).runtimeRequirements;

package/lib/Compilation.js

@@ -98,15 +98,18 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("./ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Compiler").CompilationParams} CompilationParams */
+/** @typedef {import("./Compiler").ModuleMemCachesItem} ModuleMemCachesItem */
 /** @typedef {import("./DependenciesBlock")} DependenciesBlock */
 /** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("./Dependency").ReferencedExport} ReferencedExport */
 /** @typedef {import("./DependencyTemplate")} DependencyTemplate */
 /** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
 /** @typedef {import("./Module").BuildInfo} BuildInfo */
+/** @typedef {import("./Module").ValueCacheVersions} ValueCacheVersions */
 /** @typedef {import("./NormalModule").NormalModuleCompilationHooks} NormalModuleCompilationHooks */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("./ModuleFactory")} ModuleFactory */
+/** @typedef {import("./ChunkGraph").ModuleId} ModuleId */
 /** @typedef {import("./ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("./ModuleFactory").ModuleFactoryCreateDataContextInfo} ModuleFactoryCreateDataContextInfo */
 /** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
@@ -119,6 +122,7 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModule} StatsModule */
 /** @typedef {import("./TemplatedPathPlugin").TemplatePath} TemplatePath */
 /** @typedef {import("./util/Hash")} Hash */
+/** @typedef {import("./util/createHash").Algorithm} Algorithm */
 /**
  * @template T
  * @typedef {import("./util/deprecation").FakeHook<T>} FakeHook<T>
@@ -167,6 +171,7 @@ const { isSourceEqual } = require("./util/source");
  */
 
 /** @typedef {new (...args: any[]) => Dependency} DepConstructor */
+
 /** @typedef {Record<string, Source>} CompilationAssets */
 
 /**
@@ -223,9 +228,12 @@ const { isSourceEqual } = require("./util/source");
  */
 
 /**
+ * @typedef {{ id: string, exports: any, loaded: boolean }} ModuleObject
+ *
+ * /**
  * @typedef {object} ExecuteModuleArgument
  * @property {Module} module
- * @property {{ id: string, exports: any, loaded: boolean }=} moduleObject
+ * @property {ModuleObject=} moduleObject
  * @property {any} preparedInfo
  * @property {CodeGenerationResult} codeGenerationResult
  */
@@ -362,8 +370,6 @@ const { isSourceEqual } = require("./util/source");
 
 /** @typedef {Set<Module>} NotCodeGeneratedModules */
 
-/** @typedef {string | Set<string> | undefined} ValueCacheVersion */
-
 /** @type {AssetInfo} */
 const EMPTY_ASSET_INFO = Object.freeze({});
 
@@ -697,7 +703,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			optimizeChunkModules: new AsyncSeriesBailHook(["chunks", "modules"]),
 			/** @type {SyncHook<[Iterable<Chunk>, Iterable<Module>]>} */
 			afterOptimizeChunkModules: new SyncHook(["chunks", "modules"]),
-			/** @type {SyncBailHook<[], boolean | undefined>} */
+			/** @type {SyncBailHook<[], boolean | void>} */
 			shouldRecord: new SyncBailHook([]),
 
 			/** @type {SyncHook<[Chunk, Set<string>, RuntimeRequirementsContext]>} */
@@ -792,7 +798,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 			/** @type {SyncHook<[]>} */
 			beforeModuleAssets: new SyncHook([]),
-			/** @type {SyncBailHook<[], boolean>} */
+			/** @type {SyncBailHook<[], boolean | void>} */
 			shouldGenerateChunkAssets: new SyncBailHook([]),
 			/** @type {SyncHook<[]>} */
 			beforeChunkAssets: new SyncHook([]),
@@ -840,7 +846,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			/** @type {AsyncSeriesHook<[CompilationAssets]>} */
 			processAdditionalAssets: new AsyncSeriesHook(["assets"]),
 
-			/** @type {SyncBailHook<[], boolean | undefined>} */
+			/** @type {SyncBailHook<[], boolean | void>} */
 			needAdditionalSeal: new SyncBailHook([]),
 			/** @type {AsyncSeriesHook<[]>} */
 			afterSeal: new AsyncSeriesHook([]),
@@ -861,7 +867,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			/** @type {SyncWaterfallHook<[string, object, AssetInfo | undefined]>} */
 			assetPath: new SyncWaterfallHook(["path", "options", "assetInfo"]),
 
-			/** @type {SyncBailHook<[], boolean>} */
+			/** @type {SyncBailHook<[], boolean | void>} */
 			needAdditionalPass: new SyncBailHook([]),
 
 			/** @type {SyncHook<[Compiler, string, number]>} */
@@ -871,7 +877,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				"compilerIndex"
 			]),
 
-			/** @type {SyncBailHook<[string, LogEntry], true>} */
+			/** @type {SyncBailHook<[string, LogEntry], boolean | void>} */
 			log: new SyncBailHook(["origin", "logEntry"]),
 
 			/** @type {SyncWaterfallHook<[WebpackError[]]>} */
@@ -921,7 +927,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				true
 			);
 		}
-		/** @type {Map<string, ValueCacheVersion>} */
+		/** @type {ValueCacheVersions} */
 		this.valueCacheVersions = new Map();
 		this.requestShortener = compiler.requestShortener;
 		this.compilerPath = compiler.compilerPath;
@@ -1074,11 +1080,6 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.codeGeneratedModules = new WeakSet();
 		/** @type {WeakSet<Module>} */
 		this.buildTimeExecutedModules = new WeakSet();
-		/**
-		 * @private
-		 * @type {Map<Module, Callback[]>}
-		 */
-		this._rebuildingModules = new Map();
 		/** @type {Set<string>} */
 		this.emittedAssets = new Set();
 		/** @type {Set<string>} */
@@ -1241,7 +1242,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						typeof console.profile === "function"
 					) {
 						console.profile(
-							`[${name}] ${/** @type {NonNullable<LogEntry["args"]>} */ (logEntry.args)[0]}`
+							`[${name}] ${
+								/** @type {NonNullable<LogEntry["args"]>} */
+								(logEntry.args)[0]
+							}`
 						);
 					}
 				}
@@ -1501,7 +1505,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		let factoryCacheKey;
 		/** @type {ModuleFactory} */
 		let factoryCacheKey2;
-		/** @type {Map<string, Dependency[]>} */
+		/** @typedef {Map<string, Dependency[]>} FactoryCacheValue */
+		/** @type {FactoryCacheValue | undefined} */
 		let factoryCacheValue;
 		/** @type {string} */
 		let listCacheKey1;
@@ -1705,7 +1710,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						if (factoryCacheKey2 !== undefined) {
 							// Archive last cache entry
 							if (dependencies === undefined) dependencies = new Map();
-							dependencies.set(factoryCacheKey2, factoryCacheValue);
+							dependencies.set(
+								factoryCacheKey2,
+								/** @type {FactoryCacheValue} */ (factoryCacheValue)
+							);
 							factoryCacheValue = dependencies.get(factory);
 							if (factoryCacheValue === undefined) {
 								factoryCacheValue = new Map();
@@ -1724,9 +1732,12 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					category === esmDependencyCategory
 						? resourceIdent
 						: `${category}${resourceIdent}`;
-				let list = factoryCacheValue.get(cacheKey);
+				let list = /** @type {FactoryCacheValue} */ (factoryCacheValue).get(
+					cacheKey
+				);
 				if (list === undefined) {
-					factoryCacheValue.set(cacheKey, (list = []));
+					/** @type {FactoryCacheValue} */
+					(factoryCacheValue).set(cacheKey, (list = []));
 					sortedDependencies.push({
 						factory: factoryCacheKey2,
 						dependencies: list,
@@ -1756,7 +1767,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				}
 			} while (queue.length !== 0);
 		} catch (err) {
-			return callback(err);
+			return callback(/** @type {WebpackError} */ (err));
 		}
 
 		if (--inProgressSorting === 0) onDependenciesSorted();
@@ -1852,7 +1863,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			(err, factoryResult) => {
 				const applyFactoryResultDependencies = () => {
 					const { fileDependencies, contextDependencies, missingDependencies } =
-						factoryResult;
+						/** @type {ModuleFactoryResult} */ (factoryResult);
 					if (fileDependencies) {
 						this.fileDependencies.addAll(fileDependencies);
 					}
@@ -1873,7 +1884,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					return callback(err);
 				}
 
-				const newModule = factoryResult.module;
+				const newModule =
+					/** @type {ModuleFactoryResult} */
+					(factoryResult).module;
 
 				if (!newModule) {
 					applyFactoryResultDependencies();
@@ -1901,7 +1914,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 					if (
 						this._unsafeCache &&
-						factoryResult.cacheable !== false &&
+						/** @type {ModuleFactoryResult} */
+						(factoryResult).cacheable !== false &&
 						module.restoreFromUnsafeCache &&
 						this._unsafeCachePredicate(module)
 					) {
@@ -2109,7 +2123,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					const notFoundError = new ModuleNotFoundError(
 						originModule,
 						err,
-						dependencies.map(d => d.loc).find(Boolean)
+						/** @type {DependencyLocation} */
+						(dependencies.map(d => d.loc).find(Boolean))
 					);
 					return callback(notFoundError, factoryResult ? result : undefined);
 				}
@@ -2287,11 +2302,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					this.hooks.failedEntry.call(entry, options, err);
 					return callback(err);
 				}
-				this.hooks.succeedEntry.call(
-					entry,
-					options,
-					/** @type {Module} */ (module)
-				);
+				this.hooks.succeedEntry.call(entry, options, module);
 				return callback(null, module);
 			}
 		);
@@ -2512,7 +2523,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					affectedModules.add(referencingModule);
 				}
 				const memCache = new WeakTupleMap();
-				const cache = moduleMemCacheCache.get(referencingModule);
+				const cache =
+					/** @type {ModuleMemCachesItem} */
+					(moduleMemCacheCache.get(referencingModule));
 				cache.memCache = memCache;
 				moduleMemCaches.set(referencingModule, memCache);
 			}
@@ -2541,10 +2554,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		let statNew = 0;
 		/**
 		 * @param {Module} module module
-		 * @returns {{ id: string | number, modules?: Map<Module, string | number | undefined>, blocks?: (string | number | null)[] }} references
+		 * @returns {{ id: ModuleId, modules?: Map<Module, string | number | undefined>, blocks?: (string | number | null)[] }} references
 		 */
 		const computeReferences = module => {
-			const id = chunkGraph.getModuleId(module);
+			const id = /** @type {ModuleId} */ (chunkGraph.getModuleId(module));
 			/** @type {Map<Module, string | number | undefined> | undefined} */
 			let modules;
 			/** @type {(string | number | null)[] | undefined} */
@@ -2554,7 +2567,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				for (const m of outgoing.keys()) {
 					if (!m) continue;
 					if (modules === undefined) modules = new Map();
-					modules.set(m, chunkGraph.getModuleId(m));
+					modules.set(m, /** @type {ModuleId} */ (chunkGraph.getModuleId(m)));
 				}
 			}
 			if (module.blocks.length > 0) {
@@ -3743,7 +3756,6 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		if (name) {
 			const chunkGroup = this.namedChunkGroups.get(name);
 			if (chunkGroup !== undefined) {
-				chunkGroup.addOptions(groupOptions);
 				if (module) {
 					chunkGroup.addOrigin(
 						module,
@@ -4014,10 +4026,13 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 
 	assignRuntimeIds() {
 		const { chunkGraph } = this;
+		/**
+		 * @param {Entrypoint} ep an entrypoint
+		 */
 		const processEntrypoint = ep => {
-			const runtime = ep.options.runtime || ep.name;
-			const chunk = ep.getRuntimeChunk();
-			chunkGraph.setRuntimeId(runtime, chunk.id);
+			const runtime = /** @type {string} */ (ep.options.runtime || ep.name);
+			const chunk = /** @type {Chunk} */ (ep.getRuntimeChunk());
+			chunkGraph.setRuntimeId(runtime, /** @type {ChunkId} */ (chunk.id));
 		};
 		for (const ep of this.entrypoints.values()) {
 			processEntrypoint(ep);
@@ -4139,7 +4154,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	) {
 		let moduleHashDigest;
 		try {
-			const moduleHash = createHash(hashFunction);
+			const moduleHash = createHash(/** @type {Algorithm} */ (hashFunction));
 			module.updateHash(moduleHash, {
 				chunkGraph,
 				runtime,
@@ -4167,7 +4182,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		const hashFunction = outputOptions.hashFunction;
 		const hashDigest = outputOptions.hashDigest;
 		const hashDigestLength = outputOptions.hashDigestLength;
-		const hash = createHash(hashFunction);
+		const hash = createHash(/** @type {Algorithm} */ (hashFunction));
 		if (outputOptions.hashSalt) {
 			hash.update(outputOptions.hashSalt);
 		}
@@ -4175,7 +4190,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		if (this.children.length > 0) {
 			this.logger.time("hashing: hash child compilations");
 			for (const child of this.children) {
-				hash.update(child.hash);
+				hash.update(/** @type {string} */ (child.hash));
 			}
 			this.logger.timeEnd("hashing: hash child compilations");
 		}
@@ -4236,7 +4251,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					e => e.chunks[e.chunks.length - 1]
 				)
 			)) {
-				const otherInfo = runtimeChunksMap.get(other);
+				const otherInfo =
+					/** @type {RuntimeChunkInfo} */
+					(runtimeChunksMap.get(other));
 				otherInfo.referencedBy.push(info);
 				info.remaining++;
 				remaining++;
@@ -4348,7 +4365,7 @@ This prevents using hashes of each other and should be avoided.`);
 			this.logger.timeAggregate("hashing: hash runtime modules");
 			try {
 				this.logger.time("hashing: hash chunks");
-				const chunkHash = createHash(hashFunction);
+				const chunkHash = createHash(/** @type {Algorithm} */ (hashFunction));
 				if (outputOptions.hashSalt) {
 					chunkHash.update(outputOptions.hashSalt);
 				}
@@ -4401,7 +4418,7 @@ This prevents using hashes of each other and should be avoided.`);
 			for (const module of /** @type {Iterable<RuntimeModule>} */ (
 				chunkGraph.getChunkFullHashModulesIterable(chunk)
 			)) {
-				const moduleHash = createHash(hashFunction);
+				const moduleHash = createHash(/** @type {Algorithm} */ (hashFunction));
 				module.updateHash(moduleHash, {
 					chunkGraph,
 					runtime: chunk.runtime,
@@ -4419,7 +4436,7 @@ This prevents using hashes of each other and should be avoided.`);
 				);
 				codeGenerationJobsMap.get(oldHash).get(module).hash = moduleHashDigest;
 			}
-			const chunkHash = createHash(hashFunction);
+			const chunkHash = createHash(/** @type {Algorithm} */ (hashFunction));
 			chunkHash.update(chunk.hash);
 			chunkHash.update(this.hash);
 			const chunkHashDigest =
@@ -4464,6 +4481,12 @@ This prevents using hashes of each other and should be avoided.`);
 		this._setAssetInfo(file, assetInfo, undefined);
 	}
 
+	/**
+	 * @private
+	 * @param {string} file file name
+	 * @param {AssetInfo} newInfo new asset information
+	 * @param {AssetInfo=} oldInfo old asset information
+	 */
 	_setAssetInfo(file, newInfo, oldInfo = this.assetsInfo.get(file)) {
 		if (newInfo === undefined) {
 			this.assetsInfo.delete(file);
@@ -4751,8 +4774,8 @@ This prevents using hashes of each other and should be avoided.`);
 				try {
 					manifest = this.getRenderManifest({
 						chunk,
-						hash: this.hash,
-						fullHash: this.fullHash,
+						hash: /** @type {string} */ (this.hash),
+						fullHash: /** @type {string} */ (this.fullHash),
 						outputOptions,
 						codeGenerationResults: this.codeGenerationResults,
 						moduleTemplates: this.moduleTemplates,
@@ -4966,7 +4989,7 @@ This prevents using hashes of each other and should be avoided.`);
 	 * a child with different settings and configurations (if desired) applied. It copies all hooks, plugins
 	 * from parent (or top level compiler) and creates a child Compilation
 	 * @param {string} name name of the child compiler
-	 * @param {OutputOptions=} outputOptions // Need to convert config schema to types for this
+	 * @param {Partial<OutputOptions>=} outputOptions // Need to convert config schema to types for this
 	 * @param {Array<WebpackPluginInstance | WebpackPluginFunction>=} plugins webpack plugins that will be applied
 	 * @returns {Compiler} creates a child Compiler instance
 	 */
@@ -5374,7 +5397,7 @@ This prevents using hashes of each other and should be avoided.`);
 
 /**
  * @typedef {object} FactorizeModuleOptions
- * @property {ModuleProfile} currentProfile
+ * @property {ModuleProfile=} currentProfile
  * @property {ModuleFactory} factory
  * @property {Dependency[]} dependencies
  * @property {boolean=} factoryResult return full ModuleFactoryResult instead of only module

package/lib/Compiler.js

@@ -98,6 +98,8 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {{ sizeOnlySource: SizeOnlySource | undefined, writtenTo: Map<string, number> }} CacheEntry */
 /** @typedef {{ path: string, source: Source, size: number | undefined, waiting: ({ cacheEntry: any, file: string }[] | undefined) }} SimilarEntry */
 
+/** @typedef {{ buildInfo: BuildInfo, references: References | undefined, memCache: WeakTupleMap<any, any> }} ModuleMemCachesItem */
+
 /**
  * @param {string[]} array an array
  * @returns {boolean} true, if the array is sorted
@@ -146,7 +148,7 @@ class Compiler {
 			/** @type {SyncHook<[]>} */
 			initialize: new SyncHook([]),
 
-			/** @type {SyncBailHook<[Compilation], boolean | undefined>} */
+			/** @type {SyncBailHook<[Compilation], boolean | void>} */
 			shouldEmit: new SyncBailHook(["compilation"]),
 			/** @type {AsyncSeriesHook<[Stats]>} */
 			done: new AsyncSeriesHook(["stats"]),
@@ -201,7 +203,7 @@ class Compiler {
 			/** @type {AsyncSeriesHook<[]>} */
 			shutdown: new AsyncSeriesHook([]),
 
-			/** @type {SyncBailHook<[string, string, any[] | undefined], true>} */
+			/** @type {SyncBailHook<[string, string, any[] | undefined], true | void>} */
 			infrastructureLog: new SyncBailHook(["origin", "type", "args"]),
 
 			// TODO the following hooks are weirdly located here
@@ -214,7 +216,7 @@ class Compiler {
 			afterPlugins: new SyncHook(["compiler"]),
 			/** @type {SyncHook<[Compiler]>} */
 			afterResolvers: new SyncHook(["compiler"]),
-			/** @type {SyncBailHook<[string, Entry], boolean>} */
+			/** @type {SyncBailHook<[string, Entry], boolean | void>} */
 			entryOption: new SyncBailHook(["context", "entry"])
 		});
 
@@ -288,7 +290,7 @@ class Compiler {
 
 		this.cache = new Cache();
 
-		/** @type {Map<Module, { buildInfo: BuildInfo, references: References | undefined, memCache: WeakTupleMap<any, any> }> | undefined} */
+		/** @type {Map<Module, ModuleMemCachesItem> | undefined} */
 		this.moduleMemCaches = undefined;
 
 		this.compilerPath = "";
@@ -1161,7 +1163,7 @@ ${other}`);
 	 * @param {Compilation} compilation the compilation
 	 * @param {string} compilerName the compiler's name
 	 * @param {number} compilerIndex the compiler's index
-	 * @param {OutputOptions=} outputOptions the output options
+	 * @param {Partial<OutputOptions>=} outputOptions the output options
 	 * @param {WebpackPluginInstance[]=} plugins the plugins to apply
 	 * @returns {Compiler} a child compiler
 	 */