webpack 5.97.1 → 5.104.1

package/lib/FileSystemInfo.js

@@ -5,29 +5,28 @@
 
 "use strict";
 
-const { create: createResolver } = require("enhanced-resolve");
 const nodeModule = require("module");
-const asyncLib = require("neo-async");
 const { isAbsolute } = require("path");
+const { create: createResolver } = require("enhanced-resolve");
+const asyncLib = require("neo-async");
+const { DEFAULTS } = require("./config/defaults");
 const AsyncQueue = require("./util/AsyncQueue");
 const StackedCacheMap = require("./util/StackedCacheMap");
 const createHash = require("./util/createHash");
-const { join, dirname, relative, lstatReadlinkAbsolute } = require("./util/fs");
+const { dirname, join, lstatReadlinkAbsolute, relative } = require("./util/fs");
 const makeSerializable = require("./util/makeSerializable");
+const memoize = require("./util/memoize");
 const processAsyncTree = require("./util/processAsyncTree");
 
-/** @typedef {import("enhanced-resolve").Resolver} Resolver */
 /** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */
 /** @typedef {import("enhanced-resolve").ResolveFunctionAsync} ResolveFunctionAsync */
 /** @typedef {import("./WebpackError")} WebpackError */
 /** @typedef {import("./logging/Logger").Logger} Logger */
 /** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-/** @typedef {typeof import("./util/Hash")} Hash */
+/** @typedef {import("../declarations/WebpackOptions").HashFunction} HashFunction */
 /** @typedef {import("./util/fs").IStats} IStats */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("./util/fs").PathLike} PathLike */
-/** @typedef {import("./util/fs").StringCallback} StringCallback */
 /**
  * @template T
  * @typedef {import("./util/AsyncQueue").Callback<T>} ProcessorCallback
@@ -46,8 +45,8 @@ let FS_ACCURACY = 2000;
 
 const EMPTY_SET = new Set();
 
-const RBDT_RESOLVE_CJS = 0;
-const RBDT_RESOLVE_ESM = 1;
+const RBDT_RESOLVE_INITIAL = 0;
+const RBDT_RESOLVE_FILE = 1;
 const RBDT_RESOLVE_DIRECTORY = 2;
 const RBDT_RESOLVE_CJS_FILE = 3;
 const RBDT_RESOLVE_CJS_FILE_AS_CHILD = 4;
@@ -57,7 +56,7 @@ const RBDT_FILE = 7;
 const RBDT_DIRECTORY_DEPENDENCIES = 8;
 const RBDT_FILE_DEPENDENCIES = 9;
 
-/** @typedef {RBDT_RESOLVE_CJS | RBDT_RESOLVE_ESM | RBDT_RESOLVE_DIRECTORY | RBDT_RESOLVE_CJS_FILE | RBDT_RESOLVE_CJS_FILE_AS_CHILD | RBDT_RESOLVE_ESM_FILE | RBDT_DIRECTORY | RBDT_FILE | RBDT_DIRECTORY_DEPENDENCIES | RBDT_FILE_DEPENDENCIES} JobType */
+/** @typedef {RBDT_RESOLVE_INITIAL | RBDT_RESOLVE_FILE | RBDT_RESOLVE_DIRECTORY | RBDT_RESOLVE_CJS_FILE | RBDT_RESOLVE_CJS_FILE_AS_CHILD | RBDT_RESOLVE_ESM_FILE | RBDT_DIRECTORY | RBDT_FILE | RBDT_DIRECTORY_DEPENDENCIES | RBDT_FILE_DEPENDENCIES} JobType */
 
 const INVALID = Symbol("invalid");
 
@@ -73,12 +72,14 @@ const INVALID = Symbol("invalid");
  * @property {string=} timestampHash
  */
 
+/** @typedef {Set<string>} Symlinks */
+
 /**
  * @typedef {object} ContextFileSystemInfoEntry
  * @property {number} safeTime
  * @property {string=} timestampHash
  * @property {ResolvedContextFileSystemInfoEntry=} resolved
- * @property {Set<string>=} symlinks
+ * @property {Symlinks=} symlinks
  */
 
 /**
@@ -95,8 +96,6 @@ const INVALID = Symbol("invalid");
  * @property {string} hash
  */
 
-/** @typedef {Set<string>} Symlinks */
-
 /**
  * @typedef {object} ContextTimestampAndHash
  * @property {number} safeTime
@@ -123,16 +122,26 @@ const INVALID = Symbol("invalid");
  * @property {Set<SnapshotOptimizationEntry> | undefined} children
  */
 
+/** @typedef {Map<string, string | false | undefined>} ResolveResults */
+
+/** @typedef {Set<string>} Files */
+/** @typedef {Set<string>} Directories */
+/** @typedef {Set<string>} Missing */
+
+/**
+ * @typedef {object} ResolveDependencies
+ * @property {Files} files list of files
+ * @property {Directories} directories list of directories
+ * @property {Missing} missing list of missing entries
+ */
+
 /**
  * @typedef {object} ResolveBuildDependenciesResult
- * @property {Set<string>} files list of files
- * @property {Set<string>} directories list of directories
- * @property {Set<string>} missing list of missing entries
- * @property {Map<string, string | false | undefined>} resolveResults stored resolve results
- * @property {object} resolveDependencies dependencies of the resolving
- * @property {Set<string>} resolveDependencies.files list of files
- * @property {Set<string>} resolveDependencies.directories list of directories
- * @property {Set<string>} resolveDependencies.missing list of missing entries
+ * @property {Files} files list of files
+ * @property {Directories} directories list of directories
+ * @property {Missing} missing list of missing entries
+ * @property {ResolveResults} resolveResults stored resolve results
+ * @property {ResolveDependencies} resolveDependencies dependencies of the resolving
  */
 
 /**
@@ -157,13 +166,17 @@ class SnapshotIterator {
 }
 
 /**
- * @typedef {(snapshot: Snapshot) => (Map<string, any> | Set<string> | undefined)[]} GetMapsFunction
+ * @template T
+ * @typedef {(snapshot: Snapshot) => T[]} GetMapsFunction
  */
 
+/**
+ * @template T
+ */
 class SnapshotIterable {
 	/**
 	 * @param {Snapshot} snapshot snapshot
-	 * @param {GetMapsFunction} getMaps get maps function
+	 * @param {GetMapsFunction<T>} getMaps get maps function
 	 */
 	constructor(snapshot, getMaps) {
 		this.snapshot = snapshot;
@@ -174,9 +187,9 @@ class SnapshotIterable {
 		let state = 0;
 		/** @type {IterableIterator<string>} */
 		let it;
-		/** @type {(snapshot: Snapshot) => (Map<string, any> | Set<string> | undefined)[]} */
+		/** @type {GetMapsFunction<T>} */
 		let getMaps;
-		/** @type {(Map<string, any> | Set<string> | undefined)[]} */
+		/** @type {T[]} */
 		let maps;
 		/** @type {Snapshot} */
 		let snapshot;
@@ -195,7 +208,9 @@ class SnapshotIterable {
 						if (maps.length > 0) {
 							const map = maps.pop();
 							if (map !== undefined) {
-								it = map.keys();
+								it =
+									/** @type {Set<EXPECTED_ANY> | Map<string, EXPECTED_ANY>} */
+									(map).keys();
 								state = 2;
 							} else {
 								break;
@@ -303,7 +318,7 @@ class Snapshot {
 	 * @param {number} value start value
 	 */
 	setStartTime(value) {
-		this._flags = this._flags | 1;
+		this._flags |= 1;
 		this.startTime = value;
 	}
 
@@ -340,7 +355,7 @@ class Snapshot {
 	 * @param {FileTimestamps} value file timestamps
 	 */
 	setFileTimestamps(value) {
-		this._flags = this._flags | 2;
+		this._flags |= 2;
 		this.fileTimestamps = value;
 	}
 
@@ -352,7 +367,7 @@ class Snapshot {
 	 * @param {FileHashes} value file hashes
 	 */
 	setFileHashes(value) {
-		this._flags = this._flags | 4;
+		this._flags |= 4;
 		this.fileHashes = value;
 	}
 
@@ -364,7 +379,7 @@ class Snapshot {
 	 * @param {FileTshs} value file tshs
 	 */
 	setFileTshs(value) {
-		this._flags = this._flags | 8;
+		this._flags |= 8;
 		this.fileTshs = value;
 	}
 
@@ -376,7 +391,7 @@ class Snapshot {
 	 * @param {ContextTimestamps} value context timestamps
 	 */
 	setContextTimestamps(value) {
-		this._flags = this._flags | 0x10;
+		this._flags |= 0x10;
 		this.contextTimestamps = value;
 	}
 
@@ -388,7 +403,7 @@ class Snapshot {
 	 * @param {ContextHashes} value context hashes
 	 */
 	setContextHashes(value) {
-		this._flags = this._flags | 0x20;
+		this._flags |= 0x20;
 		this.contextHashes = value;
 	}
 
@@ -400,7 +415,7 @@ class Snapshot {
 	 * @param {ContextTshs} value context tshs
 	 */
 	setContextTshs(value) {
-		this._flags = this._flags | 0x40;
+		this._flags |= 0x40;
 		this.contextTshs = value;
 	}
 
@@ -412,7 +427,7 @@ class Snapshot {
 	 * @param {MissingExistence} value context tshs
 	 */
 	setMissingExistence(value) {
-		this._flags = this._flags | 0x80;
+		this._flags |= 0x80;
 		this.missingExistence = value;
 	}
 
@@ -424,7 +439,7 @@ class Snapshot {
 	 * @param {ManagedItemInfo} value managed item info
 	 */
 	setManagedItemInfo(value) {
-		this._flags = this._flags | 0x100;
+		this._flags |= 0x100;
 		this.managedItemInfo = value;
 	}
 
@@ -436,7 +451,7 @@ class Snapshot {
 	 * @param {ManagedFiles} value managed files
 	 */
 	setManagedFiles(value) {
-		this._flags = this._flags | 0x200;
+		this._flags |= 0x200;
 		this.managedFiles = value;
 	}
 
@@ -448,7 +463,7 @@ class Snapshot {
 	 * @param {ManagedContexts} value managed contexts
 	 */
 	setManagedContexts(value) {
-		this._flags = this._flags | 0x400;
+		this._flags |= 0x400;
 		this.managedContexts = value;
 	}
 
@@ -460,7 +475,7 @@ class Snapshot {
 	 * @param {ManagedMissing} value managed missing
 	 */
 	setManagedMissing(value) {
-		this._flags = this._flags | 0x800;
+		this._flags |= 0x800;
 		this.managedMissing = value;
 	}
 
@@ -472,7 +487,7 @@ class Snapshot {
 	 * @param {Children} value children
 	 */
 	setChildren(value) {
-		this._flags = this._flags | 0x1000;
+		this._flags |= 0x1000;
 		this.children = value;
 	}
 
@@ -528,8 +543,9 @@ class Snapshot {
 	}
 
 	/**
-	 * @param {GetMapsFunction} getMaps first
-	 * @returns {Iterable<string>} iterable
+	 * @template T
+	 * @param {GetMapsFunction<T>} getMaps first
+	 * @returns {SnapshotIterable<T>} iterable
 	 */
 	_createIterable(getMaps) {
 		return new SnapshotIterable(this, getMaps);
@@ -540,7 +556,7 @@ class Snapshot {
 	 */
 	getFileIterable() {
 		if (this._cachedFileIterable === undefined) {
-			this._cachedFileIterable = this._createIterable(s => [
+			this._cachedFileIterable = this._createIterable((s) => [
 				s.fileTimestamps,
 				s.fileHashes,
 				s.fileTshs,
@@ -555,7 +571,7 @@ class Snapshot {
 	 */
 	getContextIterable() {
 		if (this._cachedContextIterable === undefined) {
-			this._cachedContextIterable = this._createIterable(s => [
+			this._cachedContextIterable = this._createIterable((s) => [
 				s.contextTimestamps,
 				s.contextHashes,
 				s.contextTshs,
@@ -570,7 +586,7 @@ class Snapshot {
 	 */
 	getMissingIterable() {
 		if (this._cachedMissingIterable === undefined) {
-			this._cachedMissingIterable = this._createIterable(s => [
+			this._cachedMissingIterable = this._createIterable((s) => [
 				s.missingExistence,
 				s.managedMissing
 			]);
@@ -594,9 +610,9 @@ const MIN_COMMON_SNAPSHOT_SIZE = 3;
  */
 class SnapshotOptimization {
 	/**
-	 * @param {function(Snapshot): boolean} has has value
-	 * @param {function(Snapshot): SnapshotOptimizationValue<U, T> | undefined} get get value
-	 * @param {function(Snapshot, SnapshotOptimizationValue<U, T>): void} set set value
+	 * @param {(snapshot: Snapshot) => boolean} has has value
+	 * @param {(snapshot: Snapshot) => SnapshotOptimizationValue<U, T> | undefined} get get value
+	 * @param {(snapshot: Snapshot, value: SnapshotOptimizationValue<U, T>) => void} set set value
 	 * @param {boolean=} useStartTime use the start time of snapshots
 	 * @param {U=} isSet value is an Set instead of a Map
 	 */
@@ -647,11 +663,14 @@ class SnapshotOptimization {
 	 * @returns {void}
 	 */
 	optimize(newSnapshot, capturedFiles) {
+		if (capturedFiles.size === 0) {
+			return;
+		}
 		/**
 		 * @param {SnapshotOptimizationEntry} entry optimization entry
 		 * @returns {void}
 		 */
-		const increaseSharedAndStoreOptimizationEntry = entry => {
+		const increaseSharedAndStoreOptimizationEntry = (entry) => {
 			if (entry.children !== undefined) {
 				for (const child of entry.children) {
 					increaseSharedAndStoreOptimizationEntry(child);
@@ -664,7 +683,7 @@ class SnapshotOptimization {
 		 * @param {SnapshotOptimizationEntry} entry optimization entry
 		 * @returns {void}
 		 */
-		const storeOptimizationEntry = entry => {
+		const storeOptimizationEntry = (entry) => {
 			for (const path of /** @type {SnapshotContent} */ (
 				entry.snapshotContent
 			)) {
@@ -698,7 +717,6 @@ class SnapshotOptimization {
 					};
 				}
 				this._map.set(path, newOptimizationEntry);
-				continue;
 			} else {
 				optimizationEntries.add(optimizationEntry);
 			}
@@ -717,6 +735,7 @@ class SnapshotOptimization {
 				) {
 					continue;
 				}
+				/** @type {Set<string>} */
 				const nonSharedFiles = new Set();
 				const snapshotContent =
 					/** @type {NonNullable<SnapshotOptimizationEntry["snapshotContent"]>} */
@@ -732,7 +751,6 @@ class SnapshotOptimization {
 							continue optimizationEntriesLabel;
 						}
 						nonSharedFiles.add(path);
-						continue;
 					}
 				}
 				if (nonSharedFiles.size === 0) {
@@ -784,8 +802,9 @@ class SnapshotOptimization {
 						snapshotContent: new Set(commonMap.keys()),
 						children: undefined
 					};
-					if (optimizationEntry.children === undefined)
+					if (optimizationEntry.children === undefined) {
 						optimizationEntry.children = new Set();
+					}
 					optimizationEntry.children.add(newEntry);
 					storeOptimizationEntry(newEntry);
 					this._statSharedSnapshots++;
@@ -863,9 +882,10 @@ class SnapshotOptimization {
  * @param {string} str input
  * @returns {string} result
  */
-const parseString = str => {
-	if (str[0] === "'" || str[0] === "`")
+const parseString = (str) => {
+	if (str[0] === "'" || str[0] === "`") {
 		str = `"${str.slice(1, -1).replace(/"/g, '\\"')}"`;
+	}
 	return JSON.parse(str);
 };
 
@@ -873,7 +893,7 @@ const parseString = str => {
 /**
  * @param {number} mtime mtime
  */
-const applyMtime = mtime => {
+const applyMtime = (mtime) => {
 	if (FS_ACCURACY > 1 && mtime % 2 !== 0) FS_ACCURACY = 1;
 	else if (FS_ACCURACY > 10 && mtime % 20 !== 0) FS_ACCURACY = 10;
 	else if (FS_ACCURACY > 100 && mtime % 200 !== 0) FS_ACCURACY = 100;
@@ -919,7 +939,7 @@ const mergeSets = (a, b) => {
  * Finding file or directory to manage
  * @param {string} managedPath path that is managing by {@link FileSystemInfo}
  * @param {string} path path to file or directory
- * @returns {string|null} managed item
+ * @returns {string | null} managed item
  * @example
  * getManagedItem(
  *   '/Users/user/my-project/node_modules/',
@@ -1004,7 +1024,7 @@ const getManagedItem = (managedPath, path) => {
  * @param {T | null} entry entry
  * @returns {T["resolved"] | null | undefined} the resolved entry
  */
-const getResolvedTimestamp = entry => {
+const getResolvedTimestamp = (entry) => {
 	if (entry === null) return null;
 	if (entry.resolved !== undefined) return entry.resolved;
 	return entry.symlinks === undefined ? entry : undefined;
@@ -1014,7 +1034,7 @@ const getResolvedTimestamp = entry => {
  * @param {ContextHash | null} entry entry
  * @returns {string | null | undefined} the resolved entry
  */
-const getResolvedHash = entry => {
+const getResolvedHash = (entry) => {
 	if (entry === null) return null;
 	if (entry.resolved !== undefined) return entry.resolved;
 	return entry.symlinks === undefined ? entry.hash : undefined;
@@ -1029,8 +1049,16 @@ const addAll = (source, target) => {
 	for (const key of source) target.add(key);
 };
 
+const getEsModuleLexer = memoize(() => require("es-module-lexer"));
+
 /** @typedef {Set<string>} LoggedPaths */
 
+/** @typedef {FileSystemInfoEntry | "ignore" | null} FileTimestamp */
+/** @typedef {ContextFileSystemInfoEntry | "ignore" | null} ContextTimestamp */
+/** @typedef {ResolvedContextFileSystemInfoEntry | "ignore" | null} ResolvedContextTimestamp */
+
+/** @typedef {(err?: WebpackError | null, result?: boolean) => void} CheckSnapshotValidCallback */
+
 /**
  * Used to access information about the filesystem in a cached way
  */
@@ -1042,7 +1070,7 @@ class FileSystemInfo {
 	 * @param {Iterable<string | RegExp>=} options.managedPaths paths that are only managed by a package manager
 	 * @param {Iterable<string | RegExp>=} options.immutablePaths paths that are immutable
 	 * @param {Logger=} options.logger logger used to log invalid snapshots
-	 * @param {string | Hash=} options.hashFunction the hash function to use
+	 * @param {HashFunction=} options.hashFunction the hash function to use
 	 */
 	constructor(
 		fs,
@@ -1051,7 +1079,7 @@ class FileSystemInfo {
 			managedPaths = [],
 			immutablePaths = [],
 			logger,
-			hashFunction = "md4"
+			hashFunction = DEFAULTS.HASH_FUNCTION
 		} = {}
 	) {
 		this.fs = fs;
@@ -1060,80 +1088,80 @@ class FileSystemInfo {
 		/** @type {LoggedPaths | undefined} */
 		this._loggedPaths = logger ? new Set() : undefined;
 		this._hashFunction = hashFunction;
-		/** @type {WeakMap<Snapshot, boolean | (function((WebpackError | null)=, boolean=): void)[]>} */
+		/** @type {WeakMap<Snapshot, boolean | CheckSnapshotValidCallback[]>} */
 		this._snapshotCache = new WeakMap();
 		this._fileTimestampsOptimization = new SnapshotOptimization(
-			s => s.hasFileTimestamps(),
-			s => s.fileTimestamps,
+			(s) => s.hasFileTimestamps(),
+			(s) => s.fileTimestamps,
 			(s, v) => s.setFileTimestamps(v)
 		);
 		this._fileHashesOptimization = new SnapshotOptimization(
-			s => s.hasFileHashes(),
-			s => s.fileHashes,
+			(s) => s.hasFileHashes(),
+			(s) => s.fileHashes,
 			(s, v) => s.setFileHashes(v),
 			false
 		);
 		this._fileTshsOptimization = new SnapshotOptimization(
-			s => s.hasFileTshs(),
-			s => s.fileTshs,
+			(s) => s.hasFileTshs(),
+			(s) => s.fileTshs,
 			(s, v) => s.setFileTshs(v)
 		);
 		this._contextTimestampsOptimization = new SnapshotOptimization(
-			s => s.hasContextTimestamps(),
-			s => s.contextTimestamps,
+			(s) => s.hasContextTimestamps(),
+			(s) => s.contextTimestamps,
 			(s, v) => s.setContextTimestamps(v)
 		);
 		this._contextHashesOptimization = new SnapshotOptimization(
-			s => s.hasContextHashes(),
-			s => s.contextHashes,
+			(s) => s.hasContextHashes(),
+			(s) => s.contextHashes,
 			(s, v) => s.setContextHashes(v),
 			false
 		);
 		this._contextTshsOptimization = new SnapshotOptimization(
-			s => s.hasContextTshs(),
-			s => s.contextTshs,
+			(s) => s.hasContextTshs(),
+			(s) => s.contextTshs,
 			(s, v) => s.setContextTshs(v)
 		);
 		this._missingExistenceOptimization = new SnapshotOptimization(
-			s => s.hasMissingExistence(),
-			s => s.missingExistence,
+			(s) => s.hasMissingExistence(),
+			(s) => s.missingExistence,
 			(s, v) => s.setMissingExistence(v),
 			false
 		);
 		this._managedItemInfoOptimization = new SnapshotOptimization(
-			s => s.hasManagedItemInfo(),
-			s => s.managedItemInfo,
+			(s) => s.hasManagedItemInfo(),
+			(s) => s.managedItemInfo,
 			(s, v) => s.setManagedItemInfo(v),
 			false
 		);
 		this._managedFilesOptimization = new SnapshotOptimization(
-			s => s.hasManagedFiles(),
-			s => s.managedFiles,
+			(s) => s.hasManagedFiles(),
+			(s) => s.managedFiles,
 			(s, v) => s.setManagedFiles(v),
 			false,
 			true
 		);
 		this._managedContextsOptimization = new SnapshotOptimization(
-			s => s.hasManagedContexts(),
-			s => s.managedContexts,
+			(s) => s.hasManagedContexts(),
+			(s) => s.managedContexts,
 			(s, v) => s.setManagedContexts(v),
 			false,
 			true
 		);
 		this._managedMissingOptimization = new SnapshotOptimization(
-			s => s.hasManagedMissing(),
-			s => s.managedMissing,
+			(s) => s.hasManagedMissing(),
+			(s) => s.managedMissing,
 			(s, v) => s.setManagedMissing(v),
 			false,
 			true
 		);
-		/** @type {StackedCacheMap<string, FileSystemInfoEntry | "ignore" | null>} */
+		/** @type {StackedCacheMap<string, FileTimestamp>} */
 		this._fileTimestamps = new StackedCacheMap();
 		/** @type {Map<string, string | null>} */
 		this._fileHashes = new Map();
 		/** @type {Map<string, TimestampAndHash | string>} */
 		this._fileTshs = new Map();
-		/** @type {StackedCacheMap<string, ContextFileSystemInfoEntry | "ignore" | null>} */
+		/** @type {StackedCacheMap<string, ContextTimestamp>} */
 		this._contextTimestamps = new StackedCacheMap();
 		/** @type {Map<string, ContextHash>} */
 		this._contextHashes = new Map();
@@ -1183,28 +1211,34 @@ class FileSystemInfo {
 			parallelism: 10,
 			processor: this._getManagedItemDirectoryInfo.bind(this)
 		});
-		const _unmanagedPaths = Array.from(unmanagedPaths);
-		this.unmanagedPathsWithSlash = /** @type {string[]} */ (
-			_unmanagedPaths.filter(p => typeof p === "string")
-		).map(p => join(fs, p, "_").slice(0, -1));
-		this.unmanagedPathsRegExps = /** @type {RegExp[]} */ (
-			_unmanagedPaths.filter(p => typeof p !== "string")
+		const _unmanagedPaths = [...unmanagedPaths];
+		/** @type {string[]} */
+		this.unmanagedPathsWithSlash = _unmanagedPaths
+			.filter((p) => typeof p === "string")
+			.map((p) => join(fs, p, "_").slice(0, -1));
+		/** @type {RegExp[]} */
+		this.unmanagedPathsRegExps = _unmanagedPaths.filter(
+			(p) => typeof p !== "string"
 		);
 
-		this.managedPaths = Array.from(managedPaths);
-		this.managedPathsWithSlash = /** @type {string[]} */ (
-			this.managedPaths.filter(p => typeof p === "string")
-		).map(p => join(fs, p, "_").slice(0, -1));
-
-		this.managedPathsRegExps = /** @type {RegExp[]} */ (
-			this.managedPaths.filter(p => typeof p !== "string")
+		this.managedPaths = [...managedPaths];
+		/** @type {string[]} */
+		this.managedPathsWithSlash = this.managedPaths
+			.filter((p) => typeof p === "string")
+			.map((p) => join(fs, p, "_").slice(0, -1));
+		/** @type {RegExp[]} */
+		this.managedPathsRegExps = this.managedPaths.filter(
+			(p) => typeof p !== "string"
 		);
-		this.immutablePaths = Array.from(immutablePaths);
-		this.immutablePathsWithSlash = /** @type {string[]} */ (
-			this.immutablePaths.filter(p => typeof p === "string")
-		).map(p => join(fs, p, "_").slice(0, -1));
-		this.immutablePathsRegExps = /** @type {RegExp[]} */ (
-			this.immutablePaths.filter(p => typeof p !== "string")
+
+		this.immutablePaths = [...immutablePaths];
+		/** @type {string[]} */
+		this.immutablePathsWithSlash = this.immutablePaths
+			.filter((p) => typeof p === "string")
+			.map((p) => join(fs, p, "_").slice(0, -1));
+		/** @type {RegExp[]} */
+		this.immutablePathsRegExps = this.immutablePaths.filter(
+			(p) => typeof p !== "string"
 		);
 
 		this._cachedDeprecatedFileTimestamps = undefined;
@@ -1310,9 +1344,10 @@ class FileSystemInfo {
 	}
 
 	/**
+	 * @private
 	 * @param {string} path path
 	 * @param {string} reason reason
-	 * @param {any[]} args arguments
+	 * @param {EXPECTED_ANY[]} args arguments
 	 */
 	_log(path, reason, ...args) {
 		const key = path + reason;
@@ -1366,7 +1401,7 @@ class FileSystemInfo {
 	}
 
 	/**
-	 * @param {ReadonlyMap<string, FileSystemInfoEntry | "ignore" | null>} map timestamps
+	 * @param {ReadonlyMap<string, FileTimestamp>} map timestamps
 	 * @param {boolean=} immutable if 'map' is immutable and FileSystemInfo can keep referencing it
 	 * @returns {void}
 	 */
@@ -1376,7 +1411,7 @@ class FileSystemInfo {
 	}
 
 	/**
-	 * @param {ReadonlyMap<string, FileSystemInfoEntry | "ignore" | null>} map timestamps
+	 * @param {ReadonlyMap<string, ContextTimestamp>} map timestamps
 	 * @param {boolean=} immutable if 'map' is immutable and FileSystemInfo can keep referencing it
 	 * @returns {void}
 	 */
@@ -1387,7 +1422,7 @@ class FileSystemInfo {
 
 	/**
 	 * @param {string} path file path
-	 * @param {function((WebpackError | null)=, (FileSystemInfoEntry | "ignore" | null)=): void} callback callback function
+	 * @param {(err?: WebpackError | null, fileTimestamp?: FileTimestamp) => void} callback callback function
 	 * @returns {void}
 	 */
 	getFileTimestamp(path, callback) {
@@ -1398,7 +1433,7 @@ class FileSystemInfo {
 
 	/**
 	 * @param {string} path context path
-	 * @param {function((WebpackError | null)=, (ResolvedContextFileSystemInfoEntry | "ignore" | null)=): void} callback callback function
+	 * @param {(err?: WebpackError | null, resolvedContextTimestamp?: ResolvedContextTimestamp) => void} callback callback function
 	 * @returns {void}
 	 */
 	getContextTimestamp(path, callback) {
@@ -1423,8 +1458,9 @@ class FileSystemInfo {
 	}
 
 	/**
+	 * @private
 	 * @param {string} path context path
-	 * @param {function((WebpackError | null)=, (ContextFileSystemInfoEntry | "ignore" | null)=): void} callback callback function
+	 * @param {(err?: WebpackError | null, contextTimestamp?: ContextTimestamp) => void} callback callback function
 	 * @returns {void}
 	 */
 	_getUnresolvedContextTimestamp(path, callback) {
@@ -1435,7 +1471,7 @@ class FileSystemInfo {
 
 	/**
 	 * @param {string} path file path
-	 * @param {function((WebpackError | null)=, (string | null)=): void} callback callback function
+	 * @param {(err?: WebpackError | null, hash?: string | null) => void} callback callback function
 	 * @returns {void}
 	 */
 	getFileHash(path, callback) {
@@ -1446,30 +1482,33 @@ class FileSystemInfo {
 
 	/**
 	 * @param {string} path context path
-	 * @param {function((WebpackError | null)=, string=): void} callback callback function
+	 * @param {(err?: WebpackError | null, contextHash?: string) => void} callback callback function
 	 * @returns {void}
 	 */
 	getContextHash(path, callback) {
 		const cache = this._contextHashes.get(path);
 		if (cache !== undefined) {
 			const resolved = getResolvedHash(cache);
-			if (resolved !== undefined)
+			if (resolved !== undefined) {
 				return callback(null, /** @type {string} */ (resolved));
+			}
 			return this._resolveContextHash(cache, callback);
 		}
 		this.contextHashQueue.add(path, (err, _entry) => {
 			if (err) return callback(err);
 			const entry = /** @type {ContextHash} */ (_entry);
 			const resolved = getResolvedHash(entry);
-			if (resolved !== undefined)
+			if (resolved !== undefined) {
 				return callback(null, /** @type {string} */ (resolved));
+			}
 			this._resolveContextHash(entry, callback);
 		});
 	}
 
 	/**
+	 * @private
 	 * @param {string} path context path
-	 * @param {function((WebpackError | null)=, (ContextHash | null)=): void} callback callback function
+	 * @param {(err?: WebpackError | null, contextHash?: ContextHash | null) => void} callback callback function
 	 * @returns {void}
 	 */
 	_getUnresolvedContextHash(path, callback) {
@@ -1480,7 +1519,7 @@ class FileSystemInfo {
 
 	/**
 	 * @param {string} path context path
-	 * @param {function((WebpackError | null)=, (ResolvedContextTimestampAndHash | null)=): void} callback callback function
+	 * @param {(err?: WebpackError | null, resolvedContextTimestampAndHash?: ResolvedContextTimestampAndHash | null) => void} callback callback function
 	 * @returns {void}
 	 */
 	getContextTsh(path, callback) {
@@ -1500,8 +1539,9 @@ class FileSystemInfo {
 	}
 
 	/**
+	 * @private
 	 * @param {string} path context path
-	 * @param {function((WebpackError | null)=, (ContextTimestampAndHash | null)=): void} callback callback function
+	 * @param {(err?: WebpackError | null, contextTimestampAndHash?: ContextTimestampAndHash | null) => void} callback callback function
 	 * @returns {void}
 	 */
 	_getUnresolvedContextTsh(path, callback) {
@@ -1541,31 +1581,32 @@ class FileSystemInfo {
 	/**
 	 * @param {string} context context directory
 	 * @param {Iterable<string>} deps dependencies
-	 * @param {function((Error | null)=, ResolveBuildDependenciesResult=): void} callback callback function
+	 * @param {(err?: Error | null, resolveBuildDependenciesResult?: ResolveBuildDependenciesResult) => void} callback callback function
 	 * @returns {void}
 	 */
 	resolveBuildDependencies(context, deps, callback) {
 		const { resolveContext, resolveEsm, resolveCjs, resolveCjsAsChild } =
 			this._createBuildDependenciesResolvers();
 
-		/** @type {Set<string>} */
+		/** @type {Files} */
 		const files = new Set();
-		/** @type {Set<string>} */
+		/** @type {Symlinks} */
 		const fileSymlinks = new Set();
-		/** @type {Set<string>} */
+		/** @type {Directories} */
 		const directories = new Set();
-		/** @type {Set<string>} */
+		/** @type {Symlinks} */
 		const directorySymlinks = new Set();
-		/** @type {Set<string>} */
+		/** @type {Missing} */
 		const missing = new Set();
-		/** @type {Set<string>} */
+		/** @type {ResolveDependencies["files"]} */
 		const resolveFiles = new Set();
-		/** @type {Set<string>} */
+		/** @type {ResolveDependencies["directories"]} */
 		const resolveDirectories = new Set();
-		/** @type {Set<string>} */
+		/** @type {ResolveDependencies["missing"]} */
 		const resolveMissing = new Set();
-		/** @type {Map<string, string | false | undefined>} */
+		/** @type {ResolveResults} */
 		const resolveResults = new Map();
+		/** @type {Set<string>} */
 		const invalidResolveResults = new Set();
 		const resolverContext = {
 			fileDependencies: resolveFiles,
@@ -1576,22 +1617,18 @@ class FileSystemInfo {
 		 * @param {undefined | boolean | string} expected expected result
 		 * @returns {string} expected result
 		 */
-		const expectedToString = expected =>
+		const expectedToString = (expected) =>
 			expected ? ` (expected ${expected})` : "";
 		/** @typedef {{ type: JobType, context: string | undefined, path: string, issuer: Job | undefined, expected: undefined | boolean | string }} Job */
 
 		/**
 		 * @param {Job} job job
-		 * @returns {`resolve commonjs file ${string}${string}`|`resolve esm file ${string}${string}`|`resolve esm ${string}${string}`|`resolve directory ${string}`|`file ${string}`|`unknown ${string} ${string}`|`resolve commonjs ${string}${string}`|`directory ${string}`|`file dependencies ${string}`|`directory dependencies ${string}`} result
+		 * @returns {string} result
 		 */
-		const jobToString = job => {
+		const jobToString = (job) => {
 			switch (job.type) {
-				case RBDT_RESOLVE_CJS:
-					return `resolve commonjs ${job.path}${expectedToString(
-						job.expected
-					)}`;
-				case RBDT_RESOLVE_ESM:
-					return `resolve esm ${job.path}${expectedToString(job.expected)}`;
+				case RBDT_RESOLVE_FILE:
+					return `resolve file ${job.path}${expectedToString(job.expected)}`;
 				case RBDT_RESOLVE_DIRECTORY:
 					return `resolve directory ${job.path}`;
 				case RBDT_RESOLVE_CJS_FILE:
@@ -1617,7 +1654,7 @@ class FileSystemInfo {
 		 * @param {Job} job job
 		 * @returns {string} string value
 		 */
-		const pathToString = job => {
+		const pathToString = (job) => {
 			let result = ` at ${jobToString(job)}`;
 			/** @type {Job | undefined} */
 			(job) = job.issuer;
@@ -1631,9 +1668,9 @@ class FileSystemInfo {
 		processAsyncTree(
 			Array.from(
 				deps,
-				dep =>
+				(dep) =>
 					/** @type {Job} */ ({
-						type: RBDT_RESOLVE_CJS,
+						type: RBDT_RESOLVE_INITIAL,
 						context,
 						path: dep,
 						expected: undefined,
@@ -1647,7 +1684,7 @@ class FileSystemInfo {
 				 * @param {string} path path
 				 * @returns {void}
 				 */
-				const resolveDirectory = path => {
+				const resolveDirectory = (path) => {
 					const key = `d\n${context}\n${path}`;
 					if (resolveResults.has(key)) {
 						return callback();
@@ -1737,27 +1774,23 @@ class FileSystemInfo {
 						}
 					);
 				};
-				switch (type) {
-					case RBDT_RESOLVE_CJS: {
-						const isDirectory = /[\\/]$/.test(path);
-						if (isDirectory) {
-							resolveDirectory(path.slice(0, -1));
-						} else {
-							resolveFile(path, "f", resolveCjs);
-						}
-						break;
-					}
-					case RBDT_RESOLVE_ESM: {
-						const isDirectory = /[\\/]$/.test(path);
-						if (isDirectory) {
-							resolveDirectory(path.slice(0, -1));
-						} else {
-							resolveFile(path);
-						}
+				const resolvedType =
+					type === RBDT_RESOLVE_INITIAL
+						? /[\\/]$/.test(path)
+							? RBDT_RESOLVE_DIRECTORY
+							: RBDT_RESOLVE_FILE
+						: type;
+				switch (resolvedType) {
+					case RBDT_RESOLVE_FILE: {
+						resolveFile(
+							path,
+							"f",
+							/\.mjs$/.test(path) ? resolveEsm : resolveCjs
+						);
 						break;
 					}
 					case RBDT_RESOLVE_DIRECTORY: {
-						resolveDirectory(path);
+						resolveDirectory(RBDT_RESOLVE_INITIAL ? path.slice(0, -1) : path);
 						break;
 					}
 					case RBDT_RESOLVE_CJS_FILE: {
@@ -1835,7 +1868,13 @@ class FileSystemInfo {
 						// Check commonjs cache for the module
 						/** @type {NodeModule | undefined} */
 						const module = require.cache[path];
-						if (module && Array.isArray(module.children)) {
+						if (
+							module &&
+							Array.isArray(module.children) &&
+							// https://github.com/nodejs/node/issues/59868
+							// Force use `es-module-lexer` for mjs
+							!/\.mjs$/.test(path)
+						) {
 							children: for (const child of module.children) {
 								const childPath = child.filename;
 								if (childPath) {
@@ -1868,8 +1907,9 @@ class FileSystemInfo {
 												});
 											}
 											let request = subPath.replace(/\\/g, "/");
-											if (request.endsWith(".js"))
+											if (request.endsWith(".js")) {
 												request = request.slice(0, -3);
+											}
 											push({
 												type: RBDT_RESOLVE_CJS_FILE_AS_CHILD,
 												context,
@@ -1904,7 +1944,9 @@ class FileSystemInfo {
 								);
 								this._warnAboutExperimentalEsmTracking = true;
 							}
-							const lexer = require("es-module-lexer");
+
+							const lexer = getEsModuleLexer();
+
 							lexer.init.then(() => {
 								this.fs.readFile(path, (err, content) => {
 									if (err) return callback(err);
@@ -1912,26 +1954,29 @@ class FileSystemInfo {
 										const context = dirname(this.fs, path);
 										const source = /** @type {Buffer} */ (content).toString();
 										const [imports] = lexer.parse(source);
+										const added = new Set();
 										for (const imp of imports) {
 											try {
 												let dependency;
 												if (imp.d === -1) {
 													// import ... from "..."
 													dependency = parseString(
-														source.substring(imp.s - 1, imp.e + 1)
+														source.slice(imp.s - 1, imp.e + 1)
 													);
 												} else if (imp.d > -1) {
 													// import()
-													const expr = source.substring(imp.s, imp.e).trim();
+													const expr = source.slice(imp.s, imp.e).trim();
 													dependency = parseString(expr);
 												} else {
 													// e.g. import.meta
 													continue;
 												}
 
-												// we should not track Node.js build dependencies
+												// We should not track Node.js build dependencies
 												if (dependency.startsWith("node:")) continue;
 												if (builtinModules.has(dependency)) continue;
+												// Avoid extra jobs for identical imports
+												if (added.has(dependency)) continue;
 
 												push({
 													type: RBDT_RESOLVE_ESM_FILE,
@@ -1940,9 +1985,10 @@ class FileSystemInfo {
 													expected: imp.d > -1 ? false : undefined,
 													issuer: job
 												});
+												added.add(dependency);
 											} catch (err1) {
 												logger.warn(
-													`Parsing of ${path} for build dependencies failed at 'import(${source.substring(
+													`Parsing of ${path} for build dependencies failed at 'import(${source.slice(
 														imp.s,
 														imp.e
 													)})'.\n` +
@@ -2000,7 +2046,8 @@ class FileSystemInfo {
 							let packageData;
 							try {
 								packageData = JSON.parse(
-									/** @type {Buffer} */ (content).toString("utf-8")
+									/** @type {Buffer} */
+									(content).toString("utf8")
 								);
 							} catch (parseErr) {
 								return callback(/** @type {Error} */ (parseErr));
@@ -2038,7 +2085,7 @@ class FileSystemInfo {
 					}
 				}
 			},
-			err => {
+			(err) => {
 				if (err) return callback(err);
 				for (const l of fileSymlinks) files.delete(l);
 				for (const l of directorySymlinks) directories.delete(l);
@@ -2059,8 +2106,8 @@ class FileSystemInfo {
 	}
 
 	/**
-	 * @param {Map<string, string | false>} resolveResults results from resolving
-	 * @param {function((Error | null)=, boolean=): void} callback callback with true when resolveResults resolve the same way
+	 * @param {ResolveResults} resolveResults results from resolving
+	 * @param {(err?: Error | null, result?: boolean) => void} callback callback with true when resolveResults resolve the same way
 	 * @returns {void}
 	 */
 	checkResolveResultsValid(resolveResults, callback) {
@@ -2074,8 +2121,9 @@ class FileSystemInfo {
 				switch (type) {
 					case "d":
 						resolveContext(context, path, {}, (err, _, result) => {
-							if (expectedResult === false)
+							if (expectedResult === false) {
 								return callback(err ? undefined : INVALID);
+							}
 							if (err) return callback(err);
 							const resultPath = /** @type {ResolveRequest} */ (result).path;
 							if (resultPath !== expectedResult) return callback(INVALID);
@@ -2084,8 +2132,9 @@ class FileSystemInfo {
 						break;
 					case "f":
 						resolveCjs(context, path, {}, (err, _, result) => {
-							if (expectedResult === false)
+							if (expectedResult === false) {
 								return callback(err ? undefined : INVALID);
+							}
 							if (err) return callback(err);
 							const resultPath = /** @type {ResolveRequest} */ (result).path;
 							if (resultPath !== expectedResult) return callback(INVALID);
@@ -2094,8 +2143,9 @@ class FileSystemInfo {
 						break;
 					case "c":
 						resolveCjsAsChild(context, path, {}, (err, _, result) => {
-							if (expectedResult === false)
+							if (expectedResult === false) {
 								return callback(err ? undefined : INVALID);
+							}
 							if (err) return callback(err);
 							const resultPath = /** @type {ResolveRequest} */ (result).path;
 							if (resultPath !== expectedResult) return callback(INVALID);
@@ -2104,8 +2154,9 @@ class FileSystemInfo {
 						break;
 					case "e":
 						resolveEsm(context, path, {}, (err, _, result) => {
-							if (expectedResult === false)
+							if (expectedResult === false) {
 								return callback(err ? undefined : INVALID);
+							}
 							if (err) return callback(err);
 							const resultPath = /** @type {ResolveRequest} */ (result).path;
 							if (resultPath !== expectedResult) return callback(INVALID);
@@ -2121,7 +2172,7 @@ class FileSystemInfo {
 			 * @param {Error | typeof INVALID=} err error or invalid flag
 			 * @returns {void}
 			 */
-			err => {
+			(err) => {
 				if (err === INVALID) {
 					return callback(null, false);
 				}
@@ -2135,11 +2186,11 @@ class FileSystemInfo {
 
 	/**
 	 * @param {number | null | undefined} startTime when processing the files has started
-	 * @param {Iterable<string> | null} files all files
-	 * @param {Iterable<string> | null} directories all directories
-	 * @param {Iterable<string> | null} missing all missing files or directories
+	 * @param {Iterable<string> | null | undefined} files all files
+	 * @param {Iterable<string> | null | undefined} directories all directories
+	 * @param {Iterable<string> | null | undefined} missing all missing files or directories
 	 * @param {SnapshotOptions | null | undefined} options options object (for future extensions)
-	 * @param {function(WebpackError | null, Snapshot | null): void} callback callback function
+	 * @param {(err: WebpackError | null, snapshot: Snapshot | null) => void} callback callback function
 	 * @returns {void}
 	 */
 	createSnapshot(startTime, files, directories, missing, options, callback) {
@@ -2234,7 +2285,7 @@ class FileSystemInfo {
 		};
 		/**
 		 * @param {string} path path
-		 * @param {Set<string>} managedSet managed set
+		 * @param {ManagedFiles} managedSet managed set
 		 * @returns {boolean} true when managed
 		 */
 		const checkManaged = (path, managedSet) => {
@@ -2285,6 +2336,7 @@ class FileSystemInfo {
 		 * @returns {Set<string>} result
 		 */
 		const captureNonManaged = (items, managedSet) => {
+			/** @type {Set<string>} */
 			const capturedItems = new Set();
 			for (const path of items) {
 				if (!checkManaged(path, managedSet)) capturedItems.add(path);
@@ -2292,9 +2344,12 @@ class FileSystemInfo {
 			return capturedItems;
 		};
 		/**
-		 * @param {Set<string>} capturedFiles captured files
+		 * @param {ManagedFiles} capturedFiles captured files
 		 */
-		const processCapturedFiles = capturedFiles => {
+		const processCapturedFiles = (capturedFiles) => {
+			if (capturedFiles.size === 0) {
+				return;
+			}
 			switch (mode) {
 				case 3:
 					this._fileTshsOptimization.optimize(snapshot, capturedFiles);
@@ -2380,9 +2435,12 @@ class FileSystemInfo {
 			processCapturedFiles(captureNonManaged(files, managedFiles));
 		}
 		/**
-		 * @param {Set<string>} capturedDirectories captured directories
+		 * @param {ManagedContexts} capturedDirectories captured directories
 		 */
-		const processCapturedDirectories = capturedDirectories => {
+		const processCapturedDirectories = (capturedDirectories) => {
+			if (capturedDirectories.size === 0) {
+				return;
+			}
 			switch (mode) {
 				case 3:
 					this._contextTshsOptimization.optimize(snapshot, capturedDirectories);
@@ -2485,7 +2543,7 @@ class FileSystemInfo {
 							jobs++;
 							/**
 							 * @param {(Error | null)=} err error
-							 * @param {(FileSystemInfoEntry | "ignore" | null)=} entry entry
+							 * @param {FileTimestamp=} entry entry
 							 * @returns {void}
 							 */
 							const callback = (err, entry) => {
@@ -2525,9 +2583,12 @@ class FileSystemInfo {
 			);
 		}
 		/**
-		 * @param {Set<string>} capturedMissing captured missing
+		 * @param {ManagedMissing} capturedMissing captured missing
 		 */
-		const processCapturedMissing = capturedMissing => {
+		const processCapturedMissing = (capturedMissing) => {
+			if (capturedMissing.size === 0) {
+				return;
+			}
 			this._missingExistenceOptimization.optimize(snapshot, capturedMissing);
 			for (const path of capturedMissing) {
 				const cache = this._fileTimestamps.get(path);
@@ -2588,7 +2649,7 @@ class FileSystemInfo {
 						// Fallback to normal snapshotting
 						/**
 						 * @param {Set<string>} set set
-						 * @param {function(Set<string>): void} fn fn
+						 * @param {(set: Set<string>) => void} fn fn
 						 */
 						const process = (set, fn) => {
 							if (set.size === 0) return;
@@ -2697,7 +2758,7 @@ class FileSystemInfo {
 
 	/**
 	 * @param {Snapshot} snapshot the snapshot made
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function
+	 * @param {CheckSnapshotValidCallback} callback callback function
 	 * @returns {void}
 	 */
 	checkSnapshotValid(snapshot, callback) {
@@ -2716,8 +2777,9 @@ class FileSystemInfo {
 	}
 
 	/**
+	 * @private
 	 * @param {Snapshot} snapshot the snapshot made
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function
+	 * @param {CheckSnapshotValidCallback} callback callback function
 	 * @returns {void}
 	 */
 	_checkSnapshotValidNoCache(snapshot, callback) {
@@ -3019,7 +3081,7 @@ class FileSystemInfo {
 					jobs++;
 					/**
 					 * @param {(WebpackError | null)=} err error
-					 * @param {(ResolvedContextFileSystemInfoEntry | "ignore" | null)=} entry entry
+					 * @param {ResolvedContextTimestamp=} entry entry
 					 * @returns {void}
 					 */
 					const callback = (err, entry) => {
@@ -3123,7 +3185,7 @@ class FileSystemInfo {
 						jobs++;
 						/**
 						 * @param {(WebpackError | null)=} err error
-						 * @param {(ResolvedContextFileSystemInfoEntry | "ignore" | null)=} entry entry
+						 * @param {ResolvedContextTimestamp=} entry entry
 						 * @returns {void}
 						 */
 						const callback = (err, entry) => {
@@ -3222,8 +3284,8 @@ class FileSystemInfo {
 	}
 
 	/**
-	 * @type {Processor<string, FileSystemInfoEntry>}
 	 * @private
+	 * @type {Processor<string, FileSystemInfoEntry>}
 	 */
 	_readFileTimestamp(path, callback) {
 		this.fs.stat(path, (err, _stat) => {
@@ -3261,8 +3323,8 @@ class FileSystemInfo {
 	}
 
 	/**
-	 * @type {Processor<string, string>}
 	 * @private
+	 * @type {Processor<string, string>}
 	 */
 	_readFileHash(path, callback) {
 		this.fs.readFile(path, (err, content) => {
@@ -3288,7 +3350,7 @@ class FileSystemInfo {
 
 			hash.update(/** @type {string | Buffer} */ (content));
 
-			const digest = /** @type {string} */ (hash.digest("hex"));
+			const digest = hash.digest("hex");
 
 			this._fileHashes.set(path, digest);
 
@@ -3297,16 +3359,16 @@ class FileSystemInfo {
 	}
 
 	/**
-	 * @param {string} path path
-	 * @param {function(WebpackError | null, TimestampAndHash=) : void} callback callback
 	 * @private
+	 * @param {string} path path
+	 * @param {(err: WebpackError | null, timestampAndHash?: TimestampAndHash | string) => void} callback callback
 	 */
 	_getFileTimestampAndHash(path, callback) {
 		/**
 		 * @param {string} hash hash
 		 * @returns {void}
 		 */
-		const continueWithHash = hash => {
+		const continueWithHash = (hash) => {
 			const cache = this._fileTimestamps.get(path);
 			if (cache !== undefined) {
 				if (cache !== "ignore") {
@@ -3319,7 +3381,7 @@ class FileSystemInfo {
 					return callback(null, result);
 				}
 				this._fileTshs.set(path, hash);
-				return callback(null, /** @type {TODO} */ (hash));
+				return callback(null, hash);
 			}
 			this.fileTimestampQueue.add(path, (err, entry) => {
 				if (err) {
@@ -3349,17 +3411,18 @@ class FileSystemInfo {
 	}
 
 	/**
+	 * @private
 	 * @template T
 	 * @template ItemType
 	 * @param {object} options options
 	 * @param {string} options.path path
-	 * @param {function(string): ItemType} options.fromImmutablePath called when context item is an immutable path
-	 * @param {function(string): ItemType} options.fromManagedItem called when context item is a managed path
-	 * @param {function(string, string, function((WebpackError | null)=, ItemType=): void): void} options.fromSymlink called when context item is a symlink
-	 * @param {function(string, IStats, function((WebpackError | null)=, (ItemType | null)=): void): void} options.fromFile called when context item is a file
-	 * @param {function(string, IStats, function((WebpackError | null)=, ItemType=): void): void} options.fromDirectory called when context item is a directory
-	 * @param {function(string[], ItemType[]): T} options.reduce called from all context items
-	 * @param {function((Error | null)=, (T | null)=): void} callback callback
+	 * @param {(value: string) => ItemType} options.fromImmutablePath called when context item is an immutable path
+	 * @param {(value: string) => ItemType} options.fromManagedItem called when context item is a managed path
+	 * @param {(value: string, result: string, callback: (err?: WebpackError | null, itemType?: ItemType) => void) => void} options.fromSymlink called when context item is a symlink
+	 * @param {(value: string, stats: IStats, callback: (err?: WebpackError | null, itemType?: ItemType | null) => void) => void} options.fromFile called when context item is a file
+	 * @param {(value: string, stats: IStats, callback: (err?: WebpackError | null, itemType?: ItemType) => void) => void} options.fromDirectory called when context item is a directory
+	 * @param {(arr: string[], arr1: ItemType[]) => T} options.reduce called from all context items
+	 * @param {(err?: Error | null, result?: T | null) => void} callback callback
 	 */
 	_readContext(
 		{
@@ -3381,8 +3444,8 @@ class FileSystemInfo {
 				return callback(err);
 			}
 			const files = /** @type {string[]} */ (_files)
-				.map(file => file.normalize("NFC"))
-				.filter(file => !/^\./.test(file))
+				.map((file) => file.normalize("NFC"))
+				.filter((file) => !/^\./.test(file))
 				.sort();
 			asyncLib.map(
 				files,
@@ -3460,8 +3523,8 @@ class FileSystemInfo {
 	}
 
 	/**
-	 * @type {Processor<string, ContextFileSystemInfoEntry>}
 	 * @private
+	 * @type {Processor<string, ContextFileSystemInfoEntry>}
 	 */
 	_readContextTimestamp(path, callback) {
 		this._readContext(
@@ -3470,7 +3533,7 @@ class FileSystemInfo {
 				fromImmutablePath: () =>
 					/** @type {ContextFileSystemInfoEntry | FileSystemInfoEntry | "ignore" | null} */
 					(null),
-				fromManagedItem: info => ({
+				fromManagedItem: (info) => ({
 					safeTime: 0,
 					timestampHash: info
 				}),
@@ -3487,8 +3550,9 @@ class FileSystemInfo {
 				fromFile: (file, stat, callback) => {
 					// Prefer the cached value over our new stat to report consistent results
 					const cache = this._fileTimestamps.get(file);
-					if (cache !== undefined)
+					if (cache !== undefined) {
 						return callback(null, cache === "ignore" ? null : cache);
+					}
 
 					const mtime = Number(stat.mtime);
 
@@ -3554,7 +3618,7 @@ class FileSystemInfo {
 						}
 					}
 
-					const digest = /** @type {string} */ (hash.digest("hex"));
+					const digest = hash.digest("hex");
 					/** @type {ContextFileSystemInfoEntry} */
 					const result = {
 						safeTime,
@@ -3575,8 +3639,9 @@ class FileSystemInfo {
 	}
 
 	/**
+	 * @private
 	 * @param {ContextFileSystemInfoEntry} entry entry
-	 * @param {function((WebpackError | null)=, (ResolvedContextFileSystemInfoEntry | "ignore" | null)=): void} callback callback
+	 * @param {(err?: WebpackError | null, resolvedContextTimestamp?: ResolvedContextTimestamp) => void} callback callback
 	 * @returns {void}
 	 */
 	_resolveContextTimestamp(entry, callback) {
@@ -3601,7 +3666,7 @@ class FileSystemInfo {
 					callback();
 				});
 			},
-			err => {
+			(err) => {
 				if (err) return callback(/** @type {WebpackError} */ (err));
 				const hash = createHash(this._hashFunction);
 				hash.update(/** @type {string} */ (entry.timestampHash));
@@ -3616,7 +3681,7 @@ class FileSystemInfo {
 					null,
 					(entry.resolved = {
 						safeTime,
-						timestampHash: /** @type {string} */ (hash.digest("hex"))
+						timestampHash: hash.digest("hex")
 					})
 				);
 			}
@@ -3624,15 +3689,15 @@ class FileSystemInfo {
 	}
 
 	/**
-	 * @type {Processor<string, ContextHash>}
 	 * @private
+	 * @type {Processor<string, ContextHash>}
 	 */
 	_readContextHash(path, callback) {
 		this._readContext(
 			{
 				path,
 				fromImmutablePath: () => /** @type {ContextHash | ""} */ (""),
-				fromManagedItem: info => info || "",
+				fromManagedItem: (info) => info || "",
 				fromSymlink: (file, target, callback) => {
 					callback(
 						null,
@@ -3678,7 +3743,7 @@ class FileSystemInfo {
 
 					/** @type {ContextHash} */
 					const result = {
-						hash: /** @type {string} */ (hash.digest("hex"))
+						hash: hash.digest("hex")
 					};
 					if (symlinks) result.symlinks = symlinks;
 					return result;
@@ -3694,8 +3759,9 @@ class FileSystemInfo {
 	}
 
 	/**
+	 * @private
 	 * @param {ContextHash} entry context hash
-	 * @param {function(WebpackError | null, string=): void} callback callback
+	 * @param {(err: WebpackError | null, contextHash?: string) => void} callback callback
 	 * @returns {void}
 	 */
 	_resolveContextHash(entry, callback) {
@@ -3716,7 +3782,7 @@ class FileSystemInfo {
 					callback();
 				});
 			},
-			err => {
+			(err) => {
 				if (err) return callback(/** @type {WebpackError} */ (err));
 				const hash = createHash(this._hashFunction);
 				hash.update(entry.hash);
@@ -3724,21 +3790,18 @@ class FileSystemInfo {
 				for (const h of hashes) {
 					hash.update(h);
 				}
-				callback(
-					null,
-					(entry.resolved = /** @type {string} */ (hash.digest("hex")))
-				);
+				callback(null, (entry.resolved = hash.digest("hex")));
 			}
 		);
 	}
 
 	/**
-	 * @type {Processor<string, ContextTimestampAndHash>}
 	 * @private
+	 * @type {Processor<string, ContextTimestampAndHash>}
 	 */
 	_readContextTimestampAndHash(path, callback) {
 		/**
-		 * @param {ContextFileSystemInfoEntry | "ignore" | null} timestamp timestamp
+		 * @param {ContextTimestamp} timestamp timestamp
 		 * @param {ContextHash} hash hash
 		 */
 		const finalize = (timestamp, hash) => {
@@ -3773,22 +3836,20 @@ class FileSystemInfo {
 				{
 					path,
 					fromImmutablePath: () =>
-						/** @type {ContextTimestampAndHash | null} */ (null),
-					fromManagedItem: info => ({
+						/** @type {ContextTimestampAndHash | Omit<ContextTimestampAndHash, "safeTime"> | string | null} */ (
+							null
+						),
+					fromManagedItem: (info) => ({
 						safeTime: 0,
 						timestampHash: info,
 						hash: info || ""
 					}),
 					fromSymlink: (file, target, callback) => {
-						callback(
-							null,
-							/** @type {TODO} */
-							({
-								timestampHash: target,
-								hash: target,
-								symlinks: new Set([target])
-							})
-						);
+						callback(null, {
+							timestampHash: target,
+							hash: target,
+							symlinks: new Set([target])
+						});
 					},
 					fromFile: (file, stat, callback) => {
 						this._getFileTimestampAndHash(file, callback);
@@ -3846,8 +3907,8 @@ class FileSystemInfo {
 						/** @type {ContextTimestampAndHash} */
 						const result = {
 							safeTime,
-							timestampHash: /** @type {string} */ (tsHash.digest("hex")),
-							hash: /** @type {string} */ (hash.digest("hex"))
+							timestampHash: tsHash.digest("hex"),
+							hash: hash.digest("hex")
 						};
 						if (symlinks) result.symlinks = symlinks;
 						return result;
@@ -3864,6 +3925,7 @@ class FileSystemInfo {
 	}
 
 	/**
+	 * @private
 	 * @param {ContextTimestampAndHash} entry entry
 	 * @param {ProcessorCallback<ResolvedContextTimestampAndHash>} callback callback
 	 * @returns {void}
@@ -3893,7 +3955,7 @@ class FileSystemInfo {
 					callback();
 				});
 			},
-			err => {
+			(err) => {
 				if (err) return callback(/** @type {WebpackError} */ (err));
 				const hash = createHash(this._hashFunction);
 				const tsHash = createHash(this._hashFunction);
@@ -3914,8 +3976,8 @@ class FileSystemInfo {
 					null,
 					(entry.resolved = {
 						safeTime,
-						timestampHash: /** @type {string} */ (tsHash.digest("hex")),
-						hash: /** @type {string} */ (hash.digest("hex"))
+						timestampHash: tsHash.digest("hex"),
+						hash: hash.digest("hex")
 					})
 				);
 			}
@@ -3923,8 +3985,8 @@ class FileSystemInfo {
 	}
 
 	/**
-	 * @type {Processor<string, Set<string>>}
 	 * @private
+	 * @type {Processor<string, Set<string>>}
 	 */
 	_getManagedItemDirectoryInfo(path, callback) {
 		this.fs.readdir(path, (err, elements) => {
@@ -3935,7 +3997,7 @@ class FileSystemInfo {
 				return callback(/** @type {WebpackError} */ (err));
 			}
 			const set = new Set(
-				/** @type {string[]} */ (elements).map(element =>
+				/** @type {string[]} */ (elements).map((element) =>
 					join(this.fs, path, element)
 				)
 			);
@@ -3944,8 +4006,8 @@ class FileSystemInfo {
 	}
 
 	/**
-	 * @type {Processor<string, string>}
 	 * @private
+	 * @type {Processor<string, string>}
 	 */
 	_getManagedItemInfo(path, callback) {
 		const dir = dirname(this.fs, path);
@@ -3998,7 +4060,7 @@ class FileSystemInfo {
 				}
 				let data;
 				try {
-					data = JSON.parse(/** @type {Buffer} */ (content).toString("utf-8"));
+					data = JSON.parse(/** @type {Buffer} */ (content).toString("utf8"));
 				} catch (parseErr) {
 					return callback(/** @type {WebpackError} */ (parseErr));
 				}
@@ -4017,8 +4079,10 @@ class FileSystemInfo {
 	}
 
 	getDeprecatedFileTimestamps() {
-		if (this._cachedDeprecatedFileTimestamps !== undefined)
+		if (this._cachedDeprecatedFileTimestamps !== undefined) {
 			return this._cachedDeprecatedFileTimestamps;
+		}
+		/** @type {Map<string, number | null>} */
 		const map = new Map();
 		for (const [path, info] of this._fileTimestamps) {
 			if (info) map.set(path, typeof info === "object" ? info.safeTime : null);
@@ -4027,8 +4091,10 @@ class FileSystemInfo {
 	}
 
 	getDeprecatedContextTimestamps() {
-		if (this._cachedDeprecatedContextTimestamps !== undefined)
+		if (this._cachedDeprecatedContextTimestamps !== undefined) {
 			return this._cachedDeprecatedContextTimestamps;
+		}
+		/** @type {Map<string, number | null>} */
 		const map = new Map();
 		for (const [path, info] of this._contextTimestamps) {
 			if (info) map.set(path, typeof info === "object" ? info.safeTime : null);