webpack 5.85.0 → 5.88.1

package/lib/Watching.js

@@ -11,6 +11,8 @@ const Stats = require("./Stats");
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
+/** @typedef {import("./WebpackError")} WebpackError */
+/** @typedef {import("./logging/Logger").Logger} Logger */
 
 /**
  * @template T
@@ -58,9 +60,9 @@ class Watching {
 		this._needRecords = true;
 		this.watcher = undefined;
 		this.pausedWatcher = undefined;
-		/** @type {Set<string>} */
+		/** @type {Set<string> | undefined} */
 		this._collectedChangedFiles = undefined;
-		/** @type {Set<string>} */
+		/** @type {Set<string> | undefined} */
 		this._collectedRemovedFiles = undefined;
 		this._done = this._done.bind(this);
 		process.nextTick(() => {
@@ -69,8 +71,8 @@ class Watching {
 	}
 
 	/**
-	 * @param {ReadonlySet<string>} changedFiles changed files
-	 * @param {ReadonlySet<string>} removedFiles removed files
+	 * @param {ReadonlySet<string>=} changedFiles changed files
+	 * @param {ReadonlySet<string>=} removedFiles removed files
 	 */
 	_mergeWithCollected(changedFiles, removedFiles) {
 		if (!changedFiles) return;
@@ -80,11 +82,13 @@ class Watching {
 		} else {
 			for (const file of changedFiles) {
 				this._collectedChangedFiles.add(file);
-				this._collectedRemovedFiles.delete(file);
+				/** @type {Set<string>} */
+				(this._collectedRemovedFiles).delete(file);
 			}
-			for (const file of removedFiles) {
+			for (const file of /** @type {ReadonlySet<string>} */ (removedFiles)) {
 				this._collectedChangedFiles.delete(file);
-				this._collectedRemovedFiles.add(file);
+				/** @type {Set<string>} */
+				(this._collectedRemovedFiles).add(file);
 			}
 		}
 	}
@@ -228,7 +232,7 @@ class Watching {
 	}
 
 	/**
-	 * @param {Error=} err an optional error
+	 * @param {(Error | null)=} err an optional error
 	 * @param {Compilation=} compilation the compilation
 	 * @returns {void}
 	 */
@@ -237,13 +241,18 @@ class Watching {
 
 		const logger = compilation && compilation.getLogger("webpack.Watching");
 
+		/** @type {Stats | null} */
 		let stats = null;
 
+		/**
+		 * @param {Error} err error
+		 * @param {Callback<void>[]=} cbs callbacks
+		 */
 		const handleError = (err, cbs) => {
 			this.compiler.hooks.failed.call(err);
 			this.compiler.cache.beginIdle();
 			this.compiler.idle = true;
-			this.handler(err, stats);
+			this.handler(err, /** @type {Stats} */ (stats));
 			if (!cbs) {
 				cbs = this.callbacks;
 				this.callbacks = [];
@@ -258,11 +267,13 @@ class Watching {
 			!(this._isBlocked() && (this.blocked = true))
 		) {
 			if (compilation) {
-				logger.time("storeBuildDependencies");
+				/** @type {Logger} */
+				(logger).time("storeBuildDependencies");
 				this.compiler.cache.storeBuildDependencies(
 					compilation.buildDependencies,
 					err => {
-						logger.timeEnd("storeBuildDependencies");
+						/** @type {Logger} */
+						(logger).timeEnd("storeBuildDependencies");
 						if (err) return handleError(err);
 						this._go();
 					}
@@ -283,32 +294,42 @@ class Watching {
 
 		const cbs = this.callbacks;
 		this.callbacks = [];
-		logger.time("done hook");
-		this.compiler.hooks.done.callAsync(stats, err => {
-			logger.timeEnd("done hook");
+		/** @type {Logger} */
+		(logger).time("done hook");
+		this.compiler.hooks.done.callAsync(/** @type {Stats} */ (stats), err => {
+			/** @type {Logger} */
+			(logger).timeEnd("done hook");
 			if (err) return handleError(err, cbs);
-			this.handler(null, stats);
-			logger.time("storeBuildDependencies");
+			this.handler(null, /** @type {Stats} */ (stats));
+			/** @type {Logger} */
+			(logger).time("storeBuildDependencies");
 			this.compiler.cache.storeBuildDependencies(
-				compilation.buildDependencies,
+				/** @type {Compilation} */
+				(compilation).buildDependencies,
 				err => {
-					logger.timeEnd("storeBuildDependencies");
+					/** @type {Logger} */
+					(logger).timeEnd("storeBuildDependencies");
 					if (err) return handleError(err, cbs);
-					logger.time("beginIdle");
+					/** @type {Logger} */
+					(logger).time("beginIdle");
 					this.compiler.cache.beginIdle();
 					this.compiler.idle = true;
-					logger.timeEnd("beginIdle");
+					/** @type {Logger} */
+					(logger).timeEnd("beginIdle");
 					process.nextTick(() => {
 						if (!this.closed) {
 							this.watch(
-								compilation.fileDependencies,
-								compilation.contextDependencies,
-								compilation.missingDependencies
+								/** @type {Compilation} */
+								(compilation).fileDependencies,
+								/** @type {Compilation} */
+								(compilation).contextDependencies,
+								/** @type {Compilation} */
+								(compilation).missingDependencies
 							);
 						}
 					});
 					for (const cb of cbs) cb(null);
-					this.compiler.hooks.afterDone.call(stats);
+					this.compiler.hooks.afterDone.call(/** @type {Stats} */ (stats));
 				}
 			);
 		});
@@ -377,6 +398,13 @@ class Watching {
 		this._invalidate();
 	}
 
+	/**
+	 * @param {ReadonlyMap<string, FileSystemInfoEntry | "ignore">=} fileTimeInfoEntries info for files
+	 * @param {ReadonlyMap<string, FileSystemInfoEntry | "ignore">=} contextTimeInfoEntries info for directories
+	 * @param {ReadonlySet<string>=} changedFiles changed files
+	 * @param {ReadonlySet<string>=} removedFiles removed files
+	 * @returns {void}
+	 */
 	_invalidate(
 		fileTimeInfoEntries,
 		contextTimeInfoEntries,
@@ -423,6 +451,10 @@ class Watching {
 			}
 			return;
 		}
+		/**
+		 * @param {(WebpackError | null)=} err error if any
+		 * @param {Compilation=} compilation compilation if any
+		 */
 		const finalCallback = (err, compilation) => {
 			this.running = false;
 			this.compiler.running = false;
@@ -433,9 +465,14 @@ class Watching {
 			this.compiler.fileTimestamps = undefined;
 			this.compiler.contextTimestamps = undefined;
 			this.compiler.fsStartTime = undefined;
+			/**
+			 * @param {(WebpackError | null)=} err error if any
+			 */
 			const shutdown = err => {
 				this.compiler.hooks.watchClose.call();
-				const closeCallbacks = this._closeCallbacks;
+				const closeCallbacks =
+					/** @type {Callback<void>[]} */
+					(this._closeCallbacks);
 				this._closeCallbacks = undefined;
 				for (const cb of closeCallbacks) cb(err);
 			};

package/lib/WebpackError.js

@@ -22,16 +22,17 @@ class WebpackError extends Error {
 	constructor(message) {
 		super(message);
 
+		/** @type {string | undefined} */
 		this.details = undefined;
-		/** @type {Module} */
+		/** @type {Module | undefined | null} */
 		this.module = undefined;
-		/** @type {DependencyLocation} */
+		/** @type {DependencyLocation | undefined} */
 		this.loc = undefined;
-		/** @type {boolean} */
+		/** @type {boolean | undefined} */
 		this.hideStack = undefined;
-		/** @type {Chunk} */
+		/** @type {Chunk | undefined} */
 		this.chunk = undefined;
-		/** @type {string} */
+		/** @type {string | undefined} */
 		this.file = undefined;
 	}
 

package/lib/WebpackIsIncludedPlugin.js

@@ -16,10 +16,12 @@ const {
 	toConstantDependency
 } = require("./javascript/JavascriptParserHelpers");
 
-/** @typedef {import("enhanced-resolve/lib/Resolver")} Resolver */
+/** @typedef {import("enhanced-resolve").Resolver} Resolver */
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("./javascript/JavascriptParser").Range} Range */
 
 const PLUGIN_NAME = "WebpackIsIncludedPlugin";
 
@@ -61,10 +63,10 @@ class WebpackIsIncludedPlugin {
 							if (!request.isString()) return;
 
 							const dep = new WebpackIsIncludedDependency(
-								request.string,
-								expr.range
+								/** @type {string} */ (request.string),
+								/** @type {Range} */ (expr.range)
 							);
-							dep.loc = expr.loc;
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 							parser.state.module.addDependency(dep);
 							return true;
 						});

package/lib/WebpackOptionsApply.js

@@ -368,7 +368,9 @@ class WebpackOptionsApply extends OptionsApply {
 			const NodeStuffPlugin = require("./NodeStuffPlugin");
 			new NodeStuffPlugin(options.node).apply(compiler);
 		}
-		new APIPlugin().apply(compiler);
+		new APIPlugin({
+			module: options.output.module
+		}).apply(compiler);
 		new ExportsInfoApiPlugin().apply(compiler);
 		new WebpackIsIncludedPlugin().apply(compiler);
 		new ConstPlugin().apply(compiler);
@@ -564,7 +566,7 @@ class WebpackOptionsApply extends OptionsApply {
 			for (const minimizer of options.optimization.minimizer) {
 				if (typeof minimizer === "function") {
 					minimizer.call(compiler, compiler);
-				} else if (minimizer !== "...") {
+				} else if (minimizer !== "..." && minimizer) {
 					minimizer.apply(compiler);
 				}
 			}

package/lib/WebpackOptionsDefaulter.js

@@ -8,11 +8,18 @@
 const { applyWebpackOptionsDefaults } = require("./config/defaults");
 const { getNormalizedWebpackOptions } = require("./config/normalization");
 
+/** @typedef {import("./config/normalization").WebpackOptions} WebpackOptions */
+/** @typedef {import("./config/normalization").WebpackOptionsNormalized} WebpackOptionsNormalized */
+
 class WebpackOptionsDefaulter {
+	/**
+	 * @param {WebpackOptions} options webpack options
+	 * @returns {WebpackOptionsNormalized} normalized webpack options
+	 */
 	process(options) {
-		options = getNormalizedWebpackOptions(options);
-		applyWebpackOptionsDefaults(options);
-		return options;
+		const normalizedOptions = getNormalizedWebpackOptions(options);
+		applyWebpackOptionsDefaults(normalizedOptions);
+		return normalizedOptions;
 	}
 }
 

package/lib/asset/AssetGenerator.js

@@ -181,6 +181,7 @@ class AssetGenerator extends Generator {
 			);
 		}
 
+		/** @type {string | boolean | undefined} */
 		let mimeType = this.dataUrlOptions.mimetype;
 		if (mimeType === undefined) {
 			const ext = path.extname(module.nameForCondition());
@@ -213,7 +214,7 @@ class AssetGenerator extends Generator {
 			);
 		}
 
-		return mimeType;
+		return /** @type {string} */ (mimeType);
 	}
 
 	/**

package/lib/asset/AssetParser.js

@@ -9,6 +9,8 @@ const Parser = require("../Parser");
 
 /** @typedef {import("../../declarations/WebpackOptions").AssetParserDataUrlOptions} AssetParserDataUrlOptions */
 /** @typedef {import("../../declarations/WebpackOptions").AssetParserOptions} AssetParserOptions */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
 
@@ -30,22 +32,25 @@ class AssetParser extends Parser {
 		if (typeof source === "object" && !Buffer.isBuffer(source)) {
 			throw new Error("AssetParser doesn't accept preparsed AST");
 		}
-		state.module.buildInfo.strict = true;
-		state.module.buildMeta.exportsType = "default";
-		state.module.buildMeta.defaultObject = false;
+
+		const buildInfo = /** @type {BuildInfo} */ (state.module.buildInfo);
+		buildInfo.strict = true;
+		const buildMeta = /** @type {BuildMeta} */ (state.module.buildMeta);
+		buildMeta.exportsType = "default";
+		buildMeta.defaultObject = false;
 
 		if (typeof this.dataUrlCondition === "function") {
-			state.module.buildInfo.dataUrl = this.dataUrlCondition(source, {
+			buildInfo.dataUrl = this.dataUrlCondition(source, {
 				filename: state.module.matchResource || state.module.resource,
 				module: state.module
 			});
 		} else if (typeof this.dataUrlCondition === "boolean") {
-			state.module.buildInfo.dataUrl = this.dataUrlCondition;
+			buildInfo.dataUrl = this.dataUrlCondition;
 		} else if (
 			this.dataUrlCondition &&
 			typeof this.dataUrlCondition === "object"
 		) {
-			state.module.buildInfo.dataUrl =
+			buildInfo.dataUrl =
 				Buffer.byteLength(source) <=
 				/** @type {NonNullable<AssetParserDataUrlOptions["maxSize"]>} */
 				(this.dataUrlCondition.maxSize);

package/lib/asset/AssetSourceParser.js

@@ -7,6 +7,8 @@
 
 const Parser = require("../Parser");
 
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
 
@@ -21,9 +23,12 @@ class AssetSourceParser extends Parser {
 			throw new Error("AssetSourceParser doesn't accept preparsed AST");
 		}
 		const { module } = state;
-		module.buildInfo.strict = true;
-		module.buildMeta.exportsType = "default";
-		state.module.buildMeta.defaultObject = false;
+		/** @type {BuildInfo} */
+		(module.buildInfo).strict = true;
+		/** @type {BuildMeta} */
+		(module.buildMeta).exportsType = "default";
+		/** @type {BuildMeta} */
+		(state.module.buildMeta).defaultObject = false;
 
 		return state;
 	}

package/lib/async-modules/AwaitDependenciesInitFragment.js

@@ -29,6 +29,10 @@ class AwaitDependenciesInitFragment extends InitFragment {
 		this.promises = promises;
 	}
 
+	/**
+	 * @param {AwaitDependenciesInitFragment} other other AwaitDependenciesInitFragment
+	 * @returns {AwaitDependenciesInitFragment} AwaitDependenciesInitFragment
+	 */
 	merge(other) {
 		const promises = new Set(other.promises);
 		for (const p of this.promises) {

package/lib/buildChunkGraph.js

@@ -16,6 +16,7 @@ const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./DependenciesBlock")} DependenciesBlock */
 /** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("./Entrypoint")} Entrypoint */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
@@ -39,15 +40,15 @@ const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
  * @typedef {Object} ChunkGroupInfo
  * @property {ChunkGroup} chunkGroup the chunk group
  * @property {RuntimeSpec} runtime the runtimes
- * @property {ModuleSetPlus} minAvailableModules current minimal set of modules available at this point
- * @property {boolean} minAvailableModulesOwned true, if minAvailableModules is owned and can be modified
+ * @property {ModuleSetPlus | undefined} minAvailableModules current minimal set of modules available at this point
+ * @property {boolean | undefined} minAvailableModulesOwned true, if minAvailableModules is owned and can be modified
  * @property {ModuleSetPlus[]} availableModulesToBeMerged enqueued updates to the minimal set of available modules
  * @property {Set<Module>=} skippedItems modules that were skipped because module is already available in parent chunks (need to reconsider when minAvailableModules is shrinking)
  * @property {Set<[Module, ConnectionState]>=} skippedModuleConnections referenced modules that where skipped because they were not active in this runtime
- * @property {ModuleSetPlus} resultingAvailableModules set of modules available including modules from this chunk group
- * @property {Set<ChunkGroupInfo>} children set of children chunk groups, that will be revisited when availableModules shrink
- * @property {Set<ChunkGroupInfo>} availableSources set of chunk groups that are the source for minAvailableModules
- * @property {Set<ChunkGroupInfo>} availableChildren set of chunk groups which depend on the this chunk group as availableSource
+ * @property {ModuleSetPlus | undefined} resultingAvailableModules set of modules available including modules from this chunk group
+ * @property {Set<ChunkGroupInfo> | undefined} children set of children chunk groups, that will be revisited when availableModules shrink
+ * @property {Set<ChunkGroupInfo> | undefined} availableSources set of chunk groups that are the source for minAvailableModules
+ * @property {Set<ChunkGroupInfo> | undefined} availableChildren set of chunk groups which depend on the this chunk group as availableSource
  * @property {number} preOrderIndex next pre order index
  * @property {number} postOrderIndex next post order index
  * @property {boolean} chunkLoading has a chunk loading mechanism
@@ -199,6 +200,7 @@ const visitModules = (
 
 	/** @type {RuntimeSpec | false} */
 	let blockModulesMapRuntime = false;
+	/** @type {Map<DependenciesBlock, (Module | ConnectionState)[]>} */
 	let blockModulesMap;
 
 	/**
@@ -239,7 +241,7 @@ const visitModules = (
 			extractBlockModules(module, moduleGraph, runtime, blockModulesMap);
 			blockModules = blockModulesMap.get(block);
 			logger.timeAggregate("visitModules: prepare");
-			return blockModules;
+			return /** @type {(Module | ConnectionState)[]} */ (blockModules);
 		}
 	};
 
@@ -290,7 +292,7 @@ const visitModules = (
 	for (const [chunkGroup, modules] of inputEntrypointsAndModules) {
 		const runtime = getEntryRuntime(
 			compilation,
-			chunkGroup.name,
+			/** @type {string} */ (chunkGroup.name),
 			chunkGroup.options
 		);
 		/** @type {ChunkGroupInfo} */
@@ -352,7 +354,9 @@ const visitModules = (
 		const { chunkGroup } = chunkGroupInfo;
 		chunkGroupInfo.availableSources = new Set();
 		for (const parent of chunkGroup.parentsIterable) {
-			const parentChunkGroupInfo = chunkGroupInfoMap.get(parent);
+			const parentChunkGroupInfo =
+				/** @type {ChunkGroupInfo} */
+				(chunkGroupInfoMap.get(parent));
 			chunkGroupInfo.availableSources.add(parentChunkGroupInfo);
 			if (parentChunkGroupInfo.availableChildren === undefined) {
 				parentChunkGroupInfo.availableChildren = new Set();
@@ -399,15 +403,15 @@ const visitModules = (
 		// 1. We create a chunk group with single chunk in it for this Block
 		// but only once (blockChunkGroups map)
 		let cgi = blockChunkGroups.get(b);
-		/** @type {ChunkGroup} */
+		/** @type {ChunkGroup | undefined} */
 		let c;
-		/** @type {Entrypoint} */
+		/** @type {Entrypoint | undefined} */
 		let entrypoint;
 		const entryOptions = b.groupOptions && b.groupOptions.entryOptions;
 		if (cgi === undefined) {
 			const chunkName = (b.groupOptions && b.groupOptions.name) || b.chunkName;
 			if (entryOptions) {
-				cgi = namedAsyncEntrypoints.get(chunkName);
+				cgi = namedAsyncEntrypoints.get(/** @type {string} */ (chunkName));
 				if (!cgi) {
 					entrypoint = compilation.addAsyncEntrypoint(
 						entryOptions,
@@ -505,7 +509,11 @@ const visitModules = (
 					c = cgi.chunkGroup;
 					if (c.isInitial()) {
 						compilation.errors.push(
-							new AsyncDependencyToInitialChunkError(chunkName, module, b.loc)
+							new AsyncDependencyToInitialChunkError(
+								/** @type {string} */ (chunkName),
+								module,
+								b.loc
+							)
 						);
 						c = chunkGroup;
 					} else {
@@ -515,7 +523,7 @@ const visitModules = (
 				}
 				blockConnections.set(b, []);
 			}
-			blockChunkGroups.set(b, cgi);
+			blockChunkGroups.set(b, /** @type {ChunkGroupInfo} */ (cgi));
 		} else if (entryOptions) {
 			entrypoint = /** @type {Entrypoint} */ (cgi.chunkGroup);
 		} else {
@@ -536,7 +544,7 @@ const visitModules = (
 				connectList = new Set();
 				queueConnect.set(chunkGroupInfo, connectList);
 			}
-			connectList.add(cgi);
+			connectList.add(/** @type {ChunkGroupInfo} */ (cgi));
 
 			// TODO check if this really need to be done for each traversal
 			// or if it is enough when it's queued when created
@@ -547,7 +555,7 @@ const visitModules = (
 				module: module,
 				chunk: c.chunks[0],
 				chunkGroup: c,
-				chunkGroupInfo: cgi
+				chunkGroupInfo: /** @type {ChunkGroupInfo} */ (cgi)
 			});
 		} else if (entrypoint !== undefined) {
 			chunkGroupInfo.chunkGroup.addAsyncEntrypoint(entrypoint);
@@ -690,7 +698,7 @@ const visitModules = (
 	const processQueue = () => {
 		while (queue.length) {
 			statProcessedQueueItems++;
-			const queueItem = queue.pop();
+			const queueItem = /** @type {QueueItem} */ (queue.pop());
 			module = queueItem.module;
 			block = queueItem.block;
 			chunk = queueItem.chunk;
@@ -1087,7 +1095,9 @@ const visitModules = (
 
 	const processChunkGroupsForCombining = () => {
 		for (const info of chunkGroupsForCombining) {
-			for (const source of info.availableSources) {
+			for (const source of /** @type {Set<ChunkGroupInfo>} */ (
+				info.availableSources
+			)) {
 				if (!source.minAvailableModules) {
 					chunkGroupsForCombining.delete(info);
 					break;
@@ -1106,7 +1116,9 @@ const visitModules = (
 				}
 			};
 			// combine minAvailableModules from all resultingAvailableModules
-			for (const source of info.availableSources) {
+			for (const source of /** @type {Set<ChunkGroupInfo>} */ (
+				info.availableSources
+			)) {
 				const resultingAvailableModules =
 					calculateResultingAvailableModules(source);
 				mergeSet(resultingAvailableModules);
@@ -1126,7 +1138,9 @@ const visitModules = (
 		for (const info of outdatedChunkGroupInfo) {
 			// 1. Reconsider skipped items
 			if (info.skippedItems !== undefined) {
-				const { minAvailableModules } = info;
+				const minAvailableModules =
+					/** @type {ModuleSetPlus} */
+					(info.minAvailableModules);
 				for (const module of info.skippedItems) {
 					if (
 						!minAvailableModules.has(module) &&
@@ -1147,7 +1161,9 @@ const visitModules = (
 
 			// 2. Reconsider skipped connections
 			if (info.skippedModuleConnections !== undefined) {
-				const { minAvailableModules } = info;
+				const minAvailableModules =
+					/** @type {ModuleSetPlus} */
+					(info.minAvailableModules);
 				for (const entry of info.skippedModuleConnections) {
 					const [module, activeState] = entry;
 					if (activeState === false) continue;

package/lib/cache/IdleFileCachePlugin.js

@@ -50,7 +50,7 @@ class IdleFileCachePlugin {
 		let timeSpendInStore = 0;
 		let avgTimeSpendInStore = 0;
 
-		/** @type {Map<string | typeof BUILD_DEPENDENCIES_KEY, () => Promise>} */
+		/** @type {Map<string | typeof BUILD_DEPENDENCIES_KEY, () => Promise<void>>} */
 		const pendingIdleTasks = new Map();
 
 		compiler.cache.hooks.store.tap(
@@ -171,6 +171,7 @@ class IdleFileCachePlugin {
 				isInitialStore = false;
 			}
 		};
+		/** @type {ReturnType<typeof setTimeout> | undefined} */
 		let idleTimer = undefined;
 		compiler.cache.hooks.beginIdle.tap(
 			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },