webpack 5.90.3 → 5.92.0

package/lib/javascript/JavascriptParserHelpers.js

@@ -18,7 +18,7 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 /**
  * @param {JavascriptParser} parser the parser
  * @param {string} value the const value
- * @param {string[]=} runtimeRequirements runtime requirements
+ * @param {(string[] | null)=} runtimeRequirements runtime requirements
  * @returns {function(Expression): true} plugin function
  */
 exports.toConstantDependency = (parser, value, runtimeRequirements) => {

package/lib/javascript/StartupHelpers.js

@@ -12,8 +12,10 @@ const { getAllChunks } = require("./ChunkHelpers");
 
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Chunk").ChunkId} ChunkId */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Entrypoint")} Entrypoint */
 /** @typedef {import("../ChunkGraph").EntryModuleWithChunkGroup} EntryModuleWithChunkGroup */
 /** @typedef {import("../ChunkGroup")} ChunkGroup */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
@@ -73,9 +75,15 @@ exports.generateEntryStartup = (
 	let currentModuleIds = undefined;
 
 	for (const [module, entrypoint] of entries) {
-		const runtimeChunk = entrypoint.getRuntimeChunk();
+		const runtimeChunk =
+			/** @type {Entrypoint} */
+			(entrypoint).getRuntimeChunk();
 		const moduleId = chunkGraph.getModuleId(module);
-		const chunks = getAllChunks(entrypoint, chunk, runtimeChunk);
+		const chunks = getAllChunks(
+			/** @type {Entrypoint} */ (entrypoint),
+			chunk,
+			runtimeChunk
+		);
 		if (
 			currentChunks &&
 			currentChunks.size === chunks.size &&
@@ -108,11 +116,18 @@ exports.generateEntryStartup = (
  */
 exports.updateHashForEntryStartup = (hash, chunkGraph, entries, chunk) => {
 	for (const [module, entrypoint] of entries) {
-		const runtimeChunk = entrypoint.getRuntimeChunk();
+		const runtimeChunk =
+			/** @type {Entrypoint} */
+			(entrypoint).getRuntimeChunk();
 		const moduleId = chunkGraph.getModuleId(module);
 		hash.update(`${moduleId}`);
-		for (const c of getAllChunks(entrypoint, chunk, runtimeChunk))
+		for (const c of getAllChunks(
+			/** @type {Entrypoint} */ (entrypoint),
+			chunk,
+			/** @type {Chunk} */ (runtimeChunk)
+		)) {
 			hash.update(`${c.id}`);
+		}
 	}
 };
 
@@ -126,7 +141,9 @@ exports.getInitialChunkIds = (chunk, chunkGraph, filterFn) => {
 	const initialChunkIds = new Set(chunk.ids);
 	for (const c of chunk.getAllInitialChunks()) {
 		if (c === chunk || filterFn(c, chunkGraph)) continue;
-		for (const id of c.ids) initialChunkIds.add(id);
+		for (const id of /** @type {ChunkId[]} */ (c.ids)) {
+			initialChunkIds.add(id);
+		}
 	}
 	return initialChunkIds;
 };

package/lib/library/AbstractLibraryPlugin.js

@@ -26,7 +26,7 @@ const COMMON_LIBRARY_NAME_MESSAGE =
 
 /**
  * @template T
- * @typedef {Object} LibraryContext
+ * @typedef {object} LibraryContext
  * @property {Compilation} compilation
  * @property {ChunkGraph} chunkGraph
  * @property {T} options
@@ -37,7 +37,7 @@ const COMMON_LIBRARY_NAME_MESSAGE =
  */
 class AbstractLibraryPlugin {
 	/**
-	 * @param {Object} options options
+	 * @param {object} options options
 	 * @param {string} options.pluginName name of the plugin
 	 * @param {LibraryType} options.type used library type
 	 */

package/lib/library/AmdLibraryPlugin.js

@@ -21,13 +21,13 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
 
 /**
- * @typedef {Object} AmdLibraryPluginOptions
+ * @typedef {object} AmdLibraryPluginOptions
  * @property {LibraryType} type
  * @property {boolean=} requireAsWrapper
  */
 
 /**
- * @typedef {Object} AmdLibraryPluginParsed
+ * @typedef {object} AmdLibraryPluginParsed
  * @property {string} name
  * @property {string} amdContainer
  */

package/lib/library/AssignLibraryPlugin.js

@@ -91,7 +91,7 @@ const accessWithInit = (accessor, existingLength, initLast = false) => {
 };
 
 /**
- * @typedef {Object} AssignLibraryPluginOptions
+ * @typedef {object} AssignLibraryPluginOptions
  * @property {LibraryType} type
  * @property {string[] | "global"} prefix name prefix
  * @property {string | false} declare declare name as variable
@@ -100,7 +100,7 @@ const accessWithInit = (accessor, existingLength, initLast = false) => {
  */
 
 /**
- * @typedef {Object} AssignLibraryPluginParsed
+ * @typedef {object} AssignLibraryPluginParsed
  * @property {string | string[]} name
  * @property {string | string[] | undefined} export
  */
@@ -323,7 +323,7 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 					true
 				)};\n`
 			);
-			/** @type {String} */
+			/** @type {string} */
 			let exports = RuntimeGlobals.exports;
 			if (exportAccess) {
 				result.add(

package/lib/library/ExportPropertyLibraryPlugin.js

@@ -22,12 +22,12 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
 
 /**
- * @typedef {Object} ExportPropertyLibraryPluginParsed
+ * @typedef {object} ExportPropertyLibraryPluginParsed
  * @property {string | string[]} export
  */
 
 /**
- * @typedef {Object} ExportPropertyLibraryPluginOptions
+ * @typedef {object} ExportPropertyLibraryPluginOptions
  * @property {LibraryType} type
  * @property {boolean} nsObjectUsed the namespace object is used
  */

package/lib/library/JsonpLibraryPlugin.js

@@ -19,12 +19,12 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
 
 /**
- * @typedef {Object} JsonpLibraryPluginOptions
+ * @typedef {object} JsonpLibraryPluginOptions
  * @property {LibraryType} type
  */
 
 /**
- * @typedef {Object} JsonpLibraryPluginParsed
+ * @typedef {object} JsonpLibraryPluginParsed
  * @property {string} name
  */
 

package/lib/library/ModuleLibraryPlugin.js

@@ -23,12 +23,12 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
 
 /**
- * @typedef {Object} ModuleLibraryPluginOptions
+ * @typedef {object} ModuleLibraryPluginOptions
  * @property {LibraryType} type
  */
 
 /**
- * @typedef {Object} ModuleLibraryPluginParsed
+ * @typedef {object} ModuleLibraryPluginParsed
  * @property {string} name
  */
 

package/lib/library/SystemLibraryPlugin.js

@@ -23,12 +23,12 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
 
 /**
- * @typedef {Object} SystemLibraryPluginOptions
+ * @typedef {object} SystemLibraryPluginOptions
  * @property {LibraryType} type
  */
 
 /**
- * @typedef {Object} SystemLibraryPluginParsed
+ * @typedef {object} SystemLibraryPluginParsed
  * @property {string} name
  */
 

package/lib/library/UmdLibraryPlugin.js

@@ -18,8 +18,13 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
+/** @typedef {import("../ExternalModule").RequestRecord} RequestRecord */
 /** @typedef {import("../util/Hash")} Hash */
-/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
+/**
+ * @template T
+ * @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>}
+ * LibraryContext<T>
+ */
 
 /**
  * @param {string[]} accessor the accessor to convert to path
@@ -53,13 +58,13 @@ const accessorAccess = (base, accessor, joinWith = ", ") => {
 /** @typedef {string | string[] | LibraryCustomUmdObject} UmdLibraryPluginName */
 
 /**
- * @typedef {Object} UmdLibraryPluginOptions
+ * @typedef {object} UmdLibraryPluginOptions
  * @property {LibraryType} type
  * @property {boolean=} optionalAmdExternalAsGlobal
  */
 
 /**
- * @typedef {Object} UmdLibraryPluginParsed
+ * @typedef {object} UmdLibraryPluginParsed
  * @property {string | string[]} name
  * @property {LibraryCustomUmdObject} names
  * @property {string | LibraryCustomUmdCommentObject} auxiliaryComment
@@ -158,24 +163,38 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 			});
 		};
 
+		/**
+		 * @param {ExternalModule[]} modules external modules
+		 * @returns {string} result
+		 */
 		const externalsDepsArray = modules => {
 			return `[${replaceKeys(
 				modules
 					.map(m =>
 						JSON.stringify(
-							typeof m.request === "object" ? m.request.amd : m.request
+							typeof m.request === "object"
+								? /** @type {RequestRecord} */
+									(m.request).amd
+								: m.request
 						)
 					)
 					.join(", ")
 			)}]`;
 		};
 
+		/**
+		 * @param {ExternalModule[]} modules external modules
+		 * @returns {string} result
+		 */
 		const externalsRootArray = modules => {
 			return replaceKeys(
 				modules
 					.map(m => {
 						let request = m.request;
-						if (typeof request === "object") request = request.root;
+						if (typeof request === "object")
+							request =
+								/** @type {RequestRecord} */
+								(request).root;
 						return `root${accessorToObjectAccess([].concat(request))}`;
 					})
 					.join(", ")
@@ -194,7 +213,7 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 						let request = m.request;
 						if (typeof request === "object") {
 							request =
-								/** @type {Record<string, string | string[]>} */
+								/** @type {RequestRecord} */
 								(request)[type];
 						}
 						if (request === undefined) {
@@ -233,8 +252,14 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 				.join(", ");
 		};
 
+		/**
+		 * @param {string| string[]} library library name
+		 * @returns {string} stringified library name
+		 */
 		const libraryName = library => {
-			return JSON.stringify(replaceKeys([].concat(library).pop()));
+			return JSON.stringify(
+				replaceKeys(/** @type {string[]} */ ([]).concat(library).pop())
+			);
 		};
 
 		let amdFactory;
@@ -313,11 +338,7 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 							"	else\n" +
 							"		" +
 							replaceKeys(
-								accessorAccess(
-									"root",
-									/** @type {string | string[]} */ (names.root) ||
-										/** @type {string} */ (names.commonjs)
-								)
+								accessorAccess("root", names.root || names.commonjs)
 							) +
 							" = factory(" +
 							externalsRootArray(externals) +

package/lib/logging/Logger.js

@@ -95,19 +95,32 @@ class WebpackLogger {
 		this[LOG_SYMBOL](LogType.groupEnd, args);
 	}
 
+	/**
+	 * @param {string=} label label
+	 */
 	profile(label) {
 		this[LOG_SYMBOL](LogType.profile, [label]);
 	}
 
+	/**
+	 * @param {string=} label label
+	 */
 	profileEnd(label) {
 		this[LOG_SYMBOL](LogType.profileEnd, [label]);
 	}
 
+	/**
+	 * @param {string} label label
+	 */
 	time(label) {
+		/** @type {Map<string | undefined, [number, number]>} */
 		this[TIMERS_SYMBOL] = this[TIMERS_SYMBOL] || new Map();
 		this[TIMERS_SYMBOL].set(label, process.hrtime());
 	}
 
+	/**
+	 * @param {string=} label label
+	 */
 	timeLog(label) {
 		const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
 		if (!prev) {
@@ -117,16 +130,23 @@ class WebpackLogger {
 		this[LOG_SYMBOL](LogType.time, [label, ...time]);
 	}
 
+	/**
+	 * @param {string=} label label
+	 */
 	timeEnd(label) {
 		const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
 		if (!prev) {
 			throw new Error(`No such label '${label}' for WebpackLogger.timeEnd()`);
 		}
 		const time = process.hrtime(prev);
-		this[TIMERS_SYMBOL].delete(label);
+		/** @type {Map<string | undefined, [number, number]>} */
+		(this[TIMERS_SYMBOL]).delete(label);
 		this[LOG_SYMBOL](LogType.time, [label, ...time]);
 	}
 
+	/**
+	 * @param {string=} label label
+	 */
 	timeAggregate(label) {
 		const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
 		if (!prev) {
@@ -135,7 +155,9 @@ class WebpackLogger {
 			);
 		}
 		const time = process.hrtime(prev);
-		this[TIMERS_SYMBOL].delete(label);
+		/** @type {Map<string | undefined, [number, number]>} */
+		(this[TIMERS_SYMBOL]).delete(label);
+		/** @type {Map<string | undefined, [number, number]>} */
 		this[TIMERS_AGGREGATES_SYMBOL] =
 			this[TIMERS_AGGREGATES_SYMBOL] || new Map();
 		const current = this[TIMERS_AGGREGATES_SYMBOL].get(label);
@@ -151,6 +173,9 @@ class WebpackLogger {
 		this[TIMERS_AGGREGATES_SYMBOL].set(label, time);
 	}
 
+	/**
+	 * @param {string=} label label
+	 */
 	timeAggregateEnd(label) {
 		if (this[TIMERS_AGGREGATES_SYMBOL] === undefined) return;
 		const time = this[TIMERS_AGGREGATES_SYMBOL].get(label);

package/lib/logging/createConsoleLogger.js

@@ -12,9 +12,10 @@ const { LogType } = require("./Logger");
 /** @typedef {import("./Logger").LogTypeEnum} LogTypeEnum */
 
 /** @typedef {function(string): boolean} FilterFunction */
+/** @typedef {function(string, LogTypeEnum, any[]): void} LoggingFunction */
 
 /**
- * @typedef {Object} LoggerConsole
+ * @typedef {object} LoggerConsole
  * @property {function(): void} clear
  * @property {function(): void} trace
  * @property {(...args: any[]) => void} info
@@ -32,7 +33,7 @@ const { LogType } = require("./Logger");
  */
 
 /**
- * @typedef {Object} LoggerOptions
+ * @typedef {object} LoggerOptions
  * @property {false|true|"none"|"error"|"warn"|"info"|"log"|"verbose"} level loglevel
  * @property {FilterTypes|boolean} debug filter for debug logging
  * @property {LoggerConsole} console the console to log to
@@ -40,7 +41,7 @@ const { LogType } = require("./Logger");
 
 /**
  * @param {FilterItemTypes} item an input item
- * @returns {FilterFunction} filter function
+ * @returns {FilterFunction | undefined} filter function
  */
 const filterToFunction = item => {
 	if (typeof item === "string") {
@@ -76,15 +77,18 @@ const LogLevel = {
 
 /**
  * @param {LoggerOptions} options options object
- * @returns {function(string, LogTypeEnum, any[]): void} logging function
+ * @returns {LoggingFunction} logging function
  */
 module.exports = ({ level = "info", debug = false, console }) => {
 	const debugFilters =
-		typeof debug === "boolean"
-			? [() => debug]
-			: /** @type {FilterItemTypes[]} */ ([])
-					.concat(debug)
-					.map(filterToFunction);
+		/** @type {FilterFunction[]} */
+		(
+			typeof debug === "boolean"
+				? [() => debug]
+				: /** @type {FilterItemTypes[]} */ ([])
+						.concat(debug)
+						.map(filterToFunction)
+		);
 	/** @type {number} */
 	const loglevel = LogLevel[`${level}`] || 0;
 

package/lib/node/CommonJsChunkLoadingPlugin.js

@@ -11,7 +11,8 @@ const StartupChunkDependenciesPlugin = require("../runtime/StartupChunkDependenc
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
-/** @typedef {Object} CommonJsChunkLoadingPluginOptions
+/**
+ * @typedef {object} CommonJsChunkLoadingPluginOptions
  * @property {boolean} [asyncChunkLoading] enable async chunk loading
  */
 

package/lib/node/NodeEnvironmentPlugin.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const CachedInputFileSystem = require("enhanced-resolve/lib/CachedInputFileSystem");
+const CachedInputFileSystem = require("enhanced-resolve").CachedInputFileSystem;
 const fs = require("graceful-fs");
 const createConsoleLogger = require("../logging/createConsoleLogger");
 const NodeWatchFileSystem = require("./NodeWatchFileSystem");
@@ -13,10 +13,11 @@ const nodeConsole = require("./nodeConsole");
 
 /** @typedef {import("../../declarations/WebpackOptions").InfrastructureLogging} InfrastructureLogging */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 
 class NodeEnvironmentPlugin {
 	/**
-	 * @param {Object} options options
+	 * @param {object} options options
 	 * @param {InfrastructureLogging} options.infrastructureLogging infrastructure logging options
 	 */
 	constructor(options) {
@@ -38,18 +39,23 @@ class NodeEnvironmentPlugin {
 				nodeConsole({
 					colors: infrastructureLogging.colors,
 					appendOnly: infrastructureLogging.appendOnly,
-					stream: infrastructureLogging.stream
+					stream:
+						/** @type {NodeJS.WritableStream} */
+						(infrastructureLogging.stream)
 				})
 		});
 		compiler.inputFileSystem = new CachedInputFileSystem(fs, 60000);
-		const inputFileSystem = compiler.inputFileSystem;
+		const inputFileSystem =
+			/** @type {InputFileSystem} */
+			(compiler.inputFileSystem);
 		compiler.outputFileSystem = fs;
 		compiler.intermediateFileSystem = fs;
-		compiler.watchFileSystem = new NodeWatchFileSystem(
-			compiler.inputFileSystem
-		);
+		compiler.watchFileSystem = new NodeWatchFileSystem(inputFileSystem);
 		compiler.hooks.beforeRun.tap("NodeEnvironmentPlugin", compiler => {
-			if (compiler.inputFileSystem === inputFileSystem) {
+			if (
+				compiler.inputFileSystem === inputFileSystem &&
+				inputFileSystem.purge
+			) {
 				compiler.fsStartTime = Date.now();
 				inputFileSystem.purge();
 			}

package/lib/node/NodeTemplatePlugin.js

@@ -11,7 +11,7 @@ const EnableChunkLoadingPlugin = require("../javascript/EnableChunkLoadingPlugin
 /** @typedef {import("../Compiler")} Compiler */
 
 /**
- * @typedef {Object} NodeTemplatePluginOptions
+ * @typedef {object} NodeTemplatePluginOptions
  * @property {boolean} [asyncChunkLoading] enable async chunk loading
  */
 

package/lib/node/NodeWatchFileSystem.js

@@ -10,11 +10,15 @@ const Watchpack = require("watchpack");
 
 /** @typedef {import("../../declarations/WebpackOptions").WatchOptions} WatchOptions */
 /** @typedef {import("../FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("../util/fs").WatchFileSystem} WatchFileSystem */
 /** @typedef {import("../util/fs").WatchMethod} WatchMethod */
 /** @typedef {import("../util/fs").Watcher} Watcher */
 
 class NodeWatchFileSystem {
+	/**
+	 * @param {InputFileSystem} inputFileSystem input filesystem
+	 */
 	constructor(inputFileSystem) {
 		this.inputFileSystem = inputFileSystem;
 		this.watcherOptions = {
@@ -26,10 +30,10 @@ class NodeWatchFileSystem {
 	/**
 	 * @param {Iterable<string>} files watched files
 	 * @param {Iterable<string>} directories watched directories
-	 * @param {Iterable<string>} missing watched exitance entries
+	 * @param {Iterable<string>} missing watched existence entries
 	 * @param {number} startTime timestamp of start time
 	 * @param {WatchOptions} options options object
-	 * @param {function((Error | null)=, Map<string, FileSystemInfoEntry>, Map<string, FileSystemInfoEntry>, Set<string>, Set<string>): void} callback aggregated callback
+	 * @param {function(Error | null, Map<string, FileSystemInfoEntry>, Map<string, FileSystemInfoEntry>, Set<string>, Set<string>): void} callback aggregated callback
 	 * @param {function(string, number): void} callbackUndelayed callback when the first change was detected
 	 * @returns {Watcher} a watcher
 	 */
@@ -81,28 +85,35 @@ class NodeWatchFileSystem {
 			}
 			return { fileTimeInfoEntries, contextTimeInfoEntries };
 		};
-		this.watcher.once("aggregated", (changes, removals) => {
-			// pause emitting events (avoids clearing aggregated changes and removals on timeout)
-			this.watcher.pause();
+		this.watcher.once(
+			"aggregated",
+			/**
+			 * @param {Set<string>} changes changes
+			 * @param {Set<string>} removals removals
+			 */
+			(changes, removals) => {
+				// pause emitting events (avoids clearing aggregated changes and removals on timeout)
+				this.watcher.pause();
 
-			if (this.inputFileSystem && this.inputFileSystem.purge) {
 				const fs = this.inputFileSystem;
-				for (const item of changes) {
-					fs.purge(item);
-				}
-				for (const item of removals) {
-					fs.purge(item);
+				if (fs && fs.purge) {
+					for (const item of changes) {
+						fs.purge(item);
+					}
+					for (const item of removals) {
+						fs.purge(item);
+					}
 				}
+				const { fileTimeInfoEntries, contextTimeInfoEntries } = fetchTimeInfo();
+				callback(
+					null,
+					fileTimeInfoEntries,
+					contextTimeInfoEntries,
+					changes,
+					removals
+				);
 			}
-			const { fileTimeInfoEntries, contextTimeInfoEntries } = fetchTimeInfo();
-			callback(
-				null,
-				fileTimeInfoEntries,
-				contextTimeInfoEntries,
-				changes,
-				removals
-			);
-		});
+		);
 
 		this.watcher.watch({ files, directories, missing, startTime });
 
@@ -124,8 +135,8 @@ class NodeWatchFileSystem {
 			getAggregatedRemovals: util.deprecate(
 				() => {
 					const items = this.watcher && this.watcher.aggregatedRemovals;
-					if (items && this.inputFileSystem && this.inputFileSystem.purge) {
-						const fs = this.inputFileSystem;
+					const fs = this.inputFileSystem;
+					if (items && fs && fs.purge) {
 						for (const item of items) {
 							fs.purge(item);
 						}
@@ -138,8 +149,8 @@ class NodeWatchFileSystem {
 			getAggregatedChanges: util.deprecate(
 				() => {
 					const items = this.watcher && this.watcher.aggregatedChanges;
-					if (items && this.inputFileSystem && this.inputFileSystem.purge) {
-						const fs = this.inputFileSystem;
+					const fs = this.inputFileSystem;
+					if (items && fs && fs.purge) {
 						for (const item of items) {
 							fs.purge(item);
 						}
@@ -166,8 +177,8 @@ class NodeWatchFileSystem {
 			getInfo: () => {
 				const removals = this.watcher && this.watcher.aggregatedRemovals;
 				const changes = this.watcher && this.watcher.aggregatedChanges;
-				if (this.inputFileSystem && this.inputFileSystem.purge) {
-					const fs = this.inputFileSystem;
+				const fs = this.inputFileSystem;
+				if (fs && fs.purge) {
 					if (removals) {
 						for (const item of removals) {
 							fs.purge(item);

package/lib/node/ReadFileChunkLoadingRuntimeModule.js

@@ -18,10 +18,11 @@ const { getUndoPath } = require("../util/identifier");
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
 
 class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 	/**
-	 * @param {ReadonlySet<string>} runtimeRequirements runtime requirements
+	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements runtime requirements
 	 */
 	constructor(runtimeRequirements) {
 		super("readFile chunk loading", RuntimeModule.STAGE_ATTACH);

package/lib/node/ReadFileCompileWasmPlugin.js

@@ -14,7 +14,7 @@ const WasmChunkLoadingRuntimeModule = require("../wasm-sync/WasmChunkLoadingRunt
 /** @typedef {import("../Compiler")} Compiler */
 
 /**
- * @typedef {Object} ReadFileCompileWasmPluginOptions
+ * @typedef {object} ReadFileCompileWasmPluginOptions
  * @property {boolean} [mangleImports] mangle imports
  */
 

package/lib/node/RequireChunkLoadingRuntimeModule.js

@@ -18,10 +18,11 @@ const { getUndoPath } = require("../util/identifier");
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
 
 class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 	/**
-	 * @param {ReadonlySet<string>} runtimeRequirements runtime requirements
+	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements runtime requirements
 	 */
 	constructor(runtimeRequirements) {
 		super("require chunk loading", RuntimeModule.STAGE_ATTACH);