webpack 5.97.1 → 5.104.1

package/lib/Compiler.js

@@ -8,13 +8,12 @@
 const parseJson = require("json-parse-even-better-errors");
 const asyncLib = require("neo-async");
 const {
-	SyncHook,
-	SyncBailHook,
 	AsyncParallelHook,
-	AsyncSeriesHook
+	AsyncSeriesHook,
+	SyncBailHook,
+	SyncHook
 } = require("tapable");
 const { SizeOnlySource } = require("webpack-sources");
-const webpack = require(".");
 const Cache = require("./Cache");
 const CacheFacade = require("./CacheFacade");
 const ChunkGraph = require("./ChunkGraph");
@@ -29,36 +28,40 @@ const Stats = require("./Stats");
 const Watching = require("./Watching");
 const WebpackError = require("./WebpackError");
 const { Logger } = require("./logging/Logger");
-const { join, dirname, mkdirp } = require("./util/fs");
+const { dirname, join, mkdirp } = require("./util/fs");
 const { makePathsRelative } = require("./util/identifier");
 const { isSourceEqual } = require("./util/source");
+const webpack = require(".");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../declarations/WebpackOptions").EntryNormalized} Entry */
 /** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputOptions */
 /** @typedef {import("../declarations/WebpackOptions").WatchOptions} WatchOptions */
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
+/** @typedef {import("../declarations/WebpackOptions").Plugins} Plugins */
+/** @typedef {import("../declarations/WebpackOptions").WebpackPluginFunction} WebpackPluginFunction */
 /** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./Compilation").References} References */
 /** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
+/** @typedef {import("./HotModuleReplacementPlugin").ChunkHashes} ChunkHashes */
+/** @typedef {import("./HotModuleReplacementPlugin").ChunkModuleHashes} ChunkModuleHashes */
+/** @typedef {import("./HotModuleReplacementPlugin").ChunkModuleIds} ChunkModuleIds */
+/** @typedef {import("./HotModuleReplacementPlugin").ChunkRuntime} ChunkRuntime */
+/** @typedef {import("./HotModuleReplacementPlugin").FullHashChunkModuleHashes} FullHashChunkModuleHashes */
+/** @typedef {import("./HotModuleReplacementPlugin").HotIndex} HotIndex */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./Module").BuildInfo} BuildInfo */
+/** @typedef {import("./RecordIdsPlugin").RecordsChunks} RecordsChunks */
+/** @typedef {import("./RecordIdsPlugin").RecordsModules} RecordsModules */
 /** @typedef {import("./config/target").PlatformTargetProperties} PlatformTargetProperties */
 /** @typedef {import("./logging/createConsoleLogger").LoggingFunction} LoggingFunction */
+/** @typedef {import("./optimize/AggressiveSplittingPlugin").SplitData} SplitData */
 /** @typedef {import("./util/fs").IStats} IStats */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("./util/fs").IntermediateFileSystem} IntermediateFileSystem */
 /** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */
+/** @typedef {import("./util/fs").TimeInfoEntries} TimeInfoEntries */
 /** @typedef {import("./util/fs").WatchFileSystem} WatchFileSystem */
 
-/**
- * @template {any[]} T
- * @template V
- * @typedef {import("./util/WeakTupleMap")<T, V>} WeakTupleMap
- */
-
 /**
  * @typedef {object} CompilationParams
  * @property {NormalModuleFactory} normalModuleFactory
@@ -67,25 +70,36 @@ const { isSourceEqual } = require("./util/source");
 
 /**
  * @template T
- * @callback RunCallback
- * @param {Error | null} err
- * @param {T=} result
+ * @template [R=void]
+ * @typedef {import("./webpack").Callback<T, R>} Callback
  */
 
-/**
- * @template T
- * @callback Callback
- * @param {(Error | null)=} err
- * @param {T=} result
- */
+/** @typedef {import("./webpack").ErrorCallback} ErrorCallback */
 
 /**
  * @callback RunAsChildCallback
  * @param {Error | null} err
  * @param {Chunk[]=} entries
  * @param {Compilation=} compilation
+ * @returns {void}
  */
 
+/**
+ * @typedef {object} KnownRecords
+ * @property {SplitData[]=} aggressiveSplits
+ * @property {RecordsChunks=} chunks
+ * @property {RecordsModules=} modules
+ * @property {string=} hash
+ * @property {HotIndex=} hotIndex
+ * @property {FullHashChunkModuleHashes=} fullHashChunkModuleHashes
+ * @property {ChunkModuleHashes=} chunkModuleHashes
+ * @property {ChunkHashes=} chunkHashes
+ * @property {ChunkRuntime=} chunkRuntime
+ * @property {ChunkModuleIds=} chunkModuleIds
+ */
+
+/** @typedef {KnownRecords & Record<string, KnownRecords[]> & Record<string, EXPECTED_ANY>} Records */
+
 /**
  * @typedef {object} AssetEmittedInfo
  * @property {Buffer} content
@@ -96,15 +110,18 @@ const { isSourceEqual } = require("./util/source");
  */
 
 /** @typedef {{ sizeOnlySource: SizeOnlySource | undefined, writtenTo: Map<string, number> }} CacheEntry */
-/** @typedef {{ path: string, source: Source, size: number | undefined, waiting: ({ cacheEntry: any, file: string }[] | undefined) }} SimilarEntry */
+/** @typedef {{ path: string, source: Source, size: number | undefined, waiting: ({ cacheEntry: CacheEntry, file: string }[] | undefined) }} SimilarEntry */
 
-/** @typedef {{ buildInfo: BuildInfo, references: References | undefined, memCache: WeakTupleMap<any, any> }} ModuleMemCachesItem */
+/** @typedef {WeakMap<Dependency, Module>} WeakReferences */
+/** @typedef {import("./util/WeakTupleMap")<EXPECTED_ANY[], EXPECTED_ANY>} MemCache */
+/** @typedef {{ buildInfo: BuildInfo, references: WeakReferences | undefined, memCache: MemCache }} ModuleMemCachesItem */
 
 /**
- * @param {string[]} array an array
+ * @template T
+ * @param {T[]} array an array
  * @returns {boolean} true, if the array is sorted
  */
-const isSorted = array => {
+const isSorted = (array) => {
 	for (let i = 1; i < array.length; i++) {
 		if (array[i - 1] > array[i]) return false;
 	}
@@ -112,13 +129,13 @@ const isSorted = array => {
 };
 
 /**
- * @param {{[key: string]: any}} obj an object
- * @param {string[]} keys the keys of the object
- * @returns {{[key: string]: any}} the object with properties sorted by property name
+ * @template {object} T
+ * @param {T} obj an object
+ * @param {(keyof T)[]} keys the keys of the object
+ * @returns {T} the object with properties sorted by property name
  */
 const sortObject = (obj, keys) => {
-	/** @type {{[key: string]: any}} */
-	const o = {};
+	const o = /** @type {T} */ ({});
 	for (const k of keys.sort()) {
 		o[k] = obj[k];
 	}
@@ -133,7 +150,7 @@ const sortObject = (obj, keys) => {
 const includesHash = (filename, hashes) => {
 	if (!hashes) return false;
 	if (Array.isArray(hashes)) {
-		return hashes.some(hash => filename.includes(hash));
+		return hashes.some((hash) => filename.includes(hash));
 	}
 	return filename.includes(hashes);
 };
@@ -203,7 +220,7 @@ class Compiler {
 			/** @type {AsyncSeriesHook<[]>} */
 			shutdown: new AsyncSeriesHook([]),
 
-			/** @type {SyncBailHook<[string, string, any[] | undefined], true | void>} */
+			/** @type {SyncBailHook<[string, string, EXPECTED_ANY[] | undefined], true | void>} */
 			infrastructureLog: new SyncBailHook(["origin", "type", "args"]),
 
 			// TODO the following hooks are weirdly located here
@@ -242,11 +259,11 @@ class Compiler {
 		/** @type {WatchFileSystem | null} */
 		this.watchFileSystem = null;
 
-		/** @type {string|null} */
+		/** @type {string | null} */
 		this.recordsInputPath = null;
-		/** @type {string|null} */
+		/** @type {string | null} */
 		this.recordsOutputPath = null;
-		/** @type {Record<string, TODO>} */
+		/** @type {Records} */
 		this.records = {};
 		/** @type {Set<string | RegExp>} */
 		this.managedPaths = new Set();
@@ -259,9 +276,9 @@ class Compiler {
 		this.modifiedFiles = undefined;
 		/** @type {ReadonlySet<string> | undefined} */
 		this.removedFiles = undefined;
-		/** @type {ReadonlyMap<string, FileSystemInfoEntry | "ignore" | null> | undefined} */
+		/** @type {TimeInfoEntries | undefined} */
 		this.fileTimestamps = undefined;
-		/** @type {ReadonlyMap<string, FileSystemInfoEntry | "ignore" | null> | undefined} */
+		/** @type {TimeInfoEntries | undefined} */
 		this.contextTimestamps = undefined;
 		/** @type {number | undefined} */
 		this.fsStartTime = undefined;
@@ -341,7 +358,7 @@ class Compiler {
 	}
 
 	/**
-	 * @param {string | (function(): string)} name name of the logger, or function called once to get the logger name
+	 * @param {string | (() => string)} name name of the logger, or function called once to get the logger name
 	 * @returns {Logger} a logger with that name
 	 */
 	getInfrastructureLogger(name) {
@@ -367,7 +384,7 @@ class Compiler {
 					this.infrastructureLogger(name, type, args);
 				}
 			},
-			childName => {
+			(childName) => {
 				if (typeof name === "function") {
 					if (typeof childName === "function") {
 						return this.getInfrastructureLogger(() => {
@@ -457,12 +474,13 @@ class Compiler {
 
 	/**
 	 * @param {WatchOptions} watchOptions the watcher's options
-	 * @param {RunCallback<Stats>} handler signals when the call finishes
-	 * @returns {Watching} a compiler watcher
+	 * @param {Callback<Stats>} handler signals when the call finishes
+	 * @returns {Watching | undefined} a compiler watcher
 	 */
 	watch(watchOptions, handler) {
 		if (this.running) {
-			return handler(new ConcurrentCompilationError());
+			handler(new ConcurrentCompilationError());
+			return;
 		}
 
 		this.running = true;
@@ -472,12 +490,13 @@ class Compiler {
 	}
 
 	/**
-	 * @param {RunCallback<Stats>} callback signals when the call finishes
+	 * @param {Callback<Stats>} callback signals when the call finishes
 	 * @returns {void}
 	 */
 	run(callback) {
 		if (this.running) {
-			return callback(new ConcurrentCompilationError());
+			callback(new ConcurrentCompilationError());
+			return;
 		}
 
 		/** @type {Logger | undefined} */
@@ -519,7 +538,7 @@ class Compiler {
 				compilation.startTime = startTime;
 				compilation.endTime = Date.now();
 				const stats = new Stats(compilation);
-				this.hooks.done.callAsync(stats, err => {
+				this.hooks.done.callAsync(stats, (err) => {
 					if (err) return finalCallback(err);
 					return finalCallback(null, stats);
 				});
@@ -529,7 +548,7 @@ class Compiler {
 			process.nextTick(() => {
 				logger = compilation.getLogger("webpack.Compiler");
 				logger.time("emitAssets");
-				this.emitAssets(compilation, err => {
+				this.emitAssets(compilation, (err) => {
 					/** @type {Logger} */
 					(logger).timeEnd("emitAssets");
 					if (err) return finalCallback(err);
@@ -542,12 +561,12 @@ class Compiler {
 						/** @type {Logger} */
 						(logger).time("done hook");
 						const stats = new Stats(compilation);
-						this.hooks.done.callAsync(stats, err => {
+						this.hooks.done.callAsync(stats, (err) => {
 							/** @type {Logger} */
 							(logger).timeEnd("done hook");
 							if (err) return finalCallback(err);
 
-							this.hooks.additionalPass.callAsync(err => {
+							this.hooks.additionalPass.callAsync((err) => {
 								if (err) return finalCallback(err);
 								this.compile(onCompiled);
 							});
@@ -557,7 +576,7 @@ class Compiler {
 
 					/** @type {Logger} */
 					(logger).time("emitRecords");
-					this.emitRecords(err => {
+					this.emitRecords((err) => {
 						/** @type {Logger} */
 						(logger).timeEnd("emitRecords");
 						if (err) return finalCallback(err);
@@ -567,13 +586,13 @@ class Compiler {
 						/** @type {Logger} */
 						(logger).time("done hook");
 						const stats = new Stats(compilation);
-						this.hooks.done.callAsync(stats, err => {
+						this.hooks.done.callAsync(stats, (err) => {
 							/** @type {Logger} */
 							(logger).timeEnd("done hook");
 							if (err) return finalCallback(err);
 							this.cache.storeBuildDependencies(
 								compilation.buildDependencies,
-								err => {
+								(err) => {
 									if (err) return finalCallback(err);
 									return finalCallback(null, stats);
 								}
@@ -585,13 +604,13 @@ class Compiler {
 		};
 
 		const run = () => {
-			this.hooks.beforeRun.callAsync(this, err => {
+			this.hooks.beforeRun.callAsync(this, (err) => {
 				if (err) return finalCallback(err);
 
-				this.hooks.run.callAsync(this, err => {
+				this.hooks.run.callAsync(this, (err) => {
 					if (err) return finalCallback(err);
 
-					this.readRecords(err => {
+					this.readRecords((err) => {
 						if (err) return finalCallback(err);
 
 						this.compile(onCompiled);
@@ -601,7 +620,7 @@ class Compiler {
 		};
 
 		if (this.idle) {
-			this.cache.endIdle(err => {
+			this.cache.endIdle((err) => {
 				if (err) return finalCallback(err);
 
 				this.idle = false;
@@ -629,7 +648,8 @@ class Compiler {
 				callback(err, entries, compilation);
 			} catch (runAsChildErr) {
 				const err = new WebpackError(
-					`compiler.runAsChild callback error: ${runAsChildErr}`
+					`compiler.runAsChild callback error: ${runAsChildErr}`,
+					{ cause: runAsChildErr }
 				);
 				err.details = /** @type {Error} */ (runAsChildErr).stack;
 				/** @type {Compilation} */
@@ -673,7 +693,7 @@ class Compiler {
 
 	/**
 	 * @param {Compilation} compilation the compilation
-	 * @param {Callback<void>} callback signals when the assets are emitted
+	 * @param {ErrorCallback} callback signals when the assets are emitted
 	 * @returns {void}
 	 */
 	emitAssets(compilation, callback) {
@@ -684,7 +704,7 @@ class Compiler {
 		 * @param {Error=} err error
 		 * @returns {void}
 		 */
-		const emitFiles = err => {
+		const emitFiles = (err) => {
 			if (err) return callback(err);
 
 			const assets = compilation.getAssets();
@@ -699,9 +719,9 @@ class Compiler {
 				({ name: file, source, info }, callback) => {
 					let targetFile = file;
 					let immutable = info.immutable;
-					const queryStringIdx = targetFile.indexOf("?");
-					if (queryStringIdx >= 0) {
-						targetFile = targetFile.slice(0, queryStringIdx);
+					const queryOrHashStringIdx = targetFile.search(/[?#]/);
+					if (queryOrHashStringIdx >= 0) {
+						targetFile = targetFile.slice(0, queryOrHashStringIdx);
 						// We may remove the hash, which is in the query string
 						// So we recheck if the file is immutable
 						// This doesn't cover all cases, but immutable is only a performance optimization anyway
@@ -717,7 +737,7 @@ class Compiler {
 					 * @param {Error=} err error
 					 * @returns {void}
 					 */
-					const writeOut = err => {
+					const writeOut = (err) => {
 						if (err) return callback(err);
 						const targetPath = join(
 							/** @type {OutputFileSystem} */
@@ -816,9 +836,9 @@ ${other}`);
 						 * @param {Buffer} content content to be written
 						 * @returns {void}
 						 */
-						const doWrite = content => {
+						const doWrite = (content) => {
 							/** @type {OutputFileSystem} */
-							(this.outputFileSystem).writeFile(targetPath, content, err => {
+							(this.outputFileSystem).writeFile(targetPath, content, (err) => {
 								if (err) return callback(err);
 
 								// information marker that the asset has been emitted
@@ -849,7 +869,7 @@ ${other}`);
 						/**
 						 * @param {number} size size
 						 */
-						const updateWithReplacementSource = size => {
+						const updateWithReplacementSource = (size) => {
 							updateFileWithReplacementSource(
 								file,
 								/** @type {CacheEntry} */ (cacheEntry),
@@ -893,7 +913,7 @@ ${other}`);
 						 * @param {IStats} stats stats
 						 * @returns {void}
 						 */
-						const processExistingFile = stats => {
+						const processExistingFile = (stats) => {
 							// skip emitting if it's already there and an immutable file
 							if (immutable) {
 								updateWithReplacementSource(/** @type {number} */ (stats.size));
@@ -993,7 +1013,7 @@ ${other}`);
 						writeOut();
 					}
 				},
-				err => {
+				(err) => {
 					// Clear map to free up memory
 					caseInsensitiveMap.clear();
 					if (err) {
@@ -1003,16 +1023,16 @@ ${other}`);
 
 					this._assetEmittingPreviousFiles = allTargetPaths;
 
-					this.hooks.afterEmit.callAsync(compilation, err => {
+					this.hooks.afterEmit.callAsync(compilation, (err) => {
 						if (err) return callback(err);
 
-						return callback();
+						return callback(null);
 					});
 				}
 			);
 		};
 
-		this.hooks.emit.callAsync(compilation, err => {
+		this.hooks.emit.callAsync(compilation, (err) => {
 			if (err) return callback(err);
 			outputPath = compilation.getPath(this.outputPath, {});
 			mkdirp(
@@ -1024,7 +1044,7 @@ ${other}`);
 	}
 
 	/**
-	 * @param {Callback<void>} callback signals when the call finishes
+	 * @param {ErrorCallback} callback signals when the call finishes
 	 * @returns {void}
 	 */
 	emitRecords(callback) {
@@ -1032,10 +1052,10 @@ ${other}`);
 			if (this.recordsOutputPath) {
 				asyncLib.parallel(
 					[
-						cb => this.hooks.emitRecords.callAsync(cb),
+						(cb) => this.hooks.emitRecords.callAsync(cb),
 						this._emitRecords.bind(this)
 					],
-					err => callback(err)
+					(err) => callback(err)
 				);
 			} else {
 				this.hooks.emitRecords.callAsync(callback);
@@ -1043,12 +1063,12 @@ ${other}`);
 		} else if (this.recordsOutputPath) {
 			this._emitRecords(callback);
 		} else {
-			callback();
+			callback(null);
 		}
 	}
 
 	/**
-	 * @param {Callback<void>} callback signals when the call finishes
+	 * @param {ErrorCallback} callback signals when the call finishes
 	 * @returns {void}
 	 */
 	_emitRecords(callback) {
@@ -1078,8 +1098,10 @@ ${other}`);
 		};
 
 		const recordsOutputPathDirectory = dirname(
-			/** @type {OutputFileSystem} */ (this.outputFileSystem),
-			/** @type {string} */ (this.recordsOutputPath)
+			/** @type {OutputFileSystem} */
+			(this.outputFileSystem),
+			/** @type {string} */
+			(this.recordsOutputPath)
 		);
 		if (!recordsOutputPathDirectory) {
 			return writeFile();
@@ -1087,7 +1109,7 @@ ${other}`);
 		mkdirp(
 			/** @type {OutputFileSystem} */ (this.outputFileSystem),
 			recordsOutputPathDirectory,
-			err => {
+			(err) => {
 				if (err) return callback(err);
 				writeFile();
 			}
@@ -1095,7 +1117,7 @@ ${other}`);
 	}
 
 	/**
-	 * @param {Callback<void>} callback signals when the call finishes
+	 * @param {ErrorCallback} callback signals when the call finishes
 	 * @returns {void}
 	 */
 	readRecords(callback) {
@@ -1103,10 +1125,10 @@ ${other}`);
 			if (this.recordsInputPath) {
 				asyncLib.parallel(
 					[
-						cb => this.hooks.readRecords.callAsync(cb),
+						(cb) => this.hooks.readRecords.callAsync(cb),
 						this._readRecords.bind(this)
 					],
-					err => callback(err)
+					(err) => callback(err)
 				);
 			} else {
 				this.records = {};
@@ -1116,34 +1138,35 @@ ${other}`);
 			this._readRecords(callback);
 		} else {
 			this.records = {};
-			callback();
+			callback(null);
 		}
 	}
 
 	/**
-	 * @param {Callback<void>} callback signals when the call finishes
+	 * @param {ErrorCallback} callback signals when the call finishes
 	 * @returns {void}
 	 */
 	_readRecords(callback) {
 		if (!this.recordsInputPath) {
 			this.records = {};
-			return callback();
+			return callback(null);
 		}
 		/** @type {InputFileSystem} */
-		(this.inputFileSystem).stat(this.recordsInputPath, err => {
+		(this.inputFileSystem).stat(this.recordsInputPath, (err) => {
 			// It doesn't exist
 			// We can ignore this.
-			if (err) return callback();
+			if (err) return callback(null);
 
 			/** @type {InputFileSystem} */
 			(this.inputFileSystem).readFile(
-				/** @type {string} */ (this.recordsInputPath),
+				/** @type {string} */
+				(this.recordsInputPath),
 				(err, content) => {
 					if (err) return callback(err);
 
 					try {
 						this.records = parseJson(
-							/** @type {Buffer} */ (content).toString("utf-8")
+							/** @type {Buffer} */ (content).toString("utf8")
 						);
 					} catch (parseErr) {
 						return callback(
@@ -1153,7 +1176,7 @@ ${other}`);
 						);
 					}
 
-					return callback();
+					return callback(null);
 				}
 			);
 		});
@@ -1164,7 +1187,7 @@ ${other}`);
 	 * @param {string} compilerName the compiler's name
 	 * @param {number} compilerIndex the compiler's index
 	 * @param {Partial<OutputOptions>=} outputOptions the output options
-	 * @param {WebpackPluginInstance[]=} plugins the plugins to apply
+	 * @param {Plugins=} plugins the plugins to apply
 	 * @returns {Compiler} a child compiler
 	 */
 	createChildCompiler(
@@ -1204,7 +1227,9 @@ ${other}`);
 			this.records[relativeCompilerName] = [];
 		}
 		if (this.records[relativeCompilerName][compilerIndex]) {
-			childCompiler.records = this.records[relativeCompilerName][compilerIndex];
+			childCompiler.records =
+				/** @type {Records} */
+				(this.records[relativeCompilerName][compilerIndex]);
 		} else {
 			this.records[relativeCompilerName].push((childCompiler.records = {}));
 		}
@@ -1213,7 +1238,10 @@ ${other}`);
 		childCompiler.root = this.root;
 		if (Array.isArray(plugins)) {
 			for (const plugin of plugins) {
-				if (plugin) {
+				if (typeof plugin === "function") {
+					/** @type {WebpackPluginFunction} */
+					(plugin).call(childCompiler, childCompiler);
+				} else if (plugin) {
 					plugin.apply(childCompiler);
 				}
 			}
@@ -1234,11 +1262,12 @@ ${other}`);
 				childCompiler.hooks[
 					/** @type {keyof Compiler["hooks"]} */
 					(name)
-				].taps =
-					this.hooks[
+				].taps = [
+					...this.hooks[
 						/** @type {keyof Compiler["hooks"]} */
 						(name)
-					].taps.slice();
+					].taps
+				];
 			}
 		}
 
@@ -1284,8 +1313,7 @@ ${other}`);
 			fs: /** @type {InputFileSystem} */ (this.inputFileSystem),
 			resolverFactory: this.resolverFactory,
 			options: this.options.module,
-			associatedObjectForCache: this.root,
-			layers: this.options.experiments.layers
+			associatedObjectForCache: this.root
 		});
 		this._lastNormalModuleFactory = normalModuleFactory;
 		this.hooks.normalModuleFactory.call(normalModuleFactory);
@@ -1307,12 +1335,12 @@ ${other}`);
 	}
 
 	/**
-	 * @param {RunCallback<Compilation>} callback signals when the compilation finishes
+	 * @param {Callback<Compilation>} callback signals when the compilation finishes
 	 * @returns {void}
 	 */
 	compile(callback) {
 		const params = this.newCompilationParams();
-		this.hooks.beforeCompile.callAsync(params, err => {
+		this.hooks.beforeCompile.callAsync(params, (err) => {
 			if (err) return callback(err);
 
 			this.hooks.compile.call(params);
@@ -1322,28 +1350,28 @@ ${other}`);
 			const logger = compilation.getLogger("webpack.Compiler");
 
 			logger.time("make hook");
-			this.hooks.make.callAsync(compilation, err => {
+			this.hooks.make.callAsync(compilation, (err) => {
 				logger.timeEnd("make hook");
 				if (err) return callback(err);
 
 				logger.time("finish make hook");
-				this.hooks.finishMake.callAsync(compilation, err => {
+				this.hooks.finishMake.callAsync(compilation, (err) => {
 					logger.timeEnd("finish make hook");
 					if (err) return callback(err);
 
 					process.nextTick(() => {
 						logger.time("finish compilation");
-						compilation.finish(err => {
+						compilation.finish((err) => {
 							logger.timeEnd("finish compilation");
 							if (err) return callback(err);
 
 							logger.time("seal compilation");
-							compilation.seal(err => {
+							compilation.seal((err) => {
 								logger.timeEnd("seal compilation");
 								if (err) return callback(err);
 
 								logger.time("afterCompile hook");
-								this.hooks.afterCompile.callAsync(compilation, err => {
+								this.hooks.afterCompile.callAsync(compilation, (err) => {
 									logger.timeEnd("afterCompile hook");
 									if (err) return callback(err);
 
@@ -1358,18 +1386,18 @@ ${other}`);
 	}
 
 	/**
-	 * @param {RunCallback<void>} callback signals when the compiler closes
+	 * @param {ErrorCallback} callback signals when the compiler closes
 	 * @returns {void}
 	 */
 	close(callback) {
 		if (this.watching) {
 			// When there is still an active watching, close this first
-			this.watching.close(err => {
+			this.watching.close((_err) => {
 				this.close(callback);
 			});
 			return;
 		}
-		this.hooks.shutdown.callAsync(err => {
+		this.hooks.shutdown.callAsync((err) => {
 			if (err) return callback(err);
 			// Get rid of reference to last compilation to avoid leaking memory
 			// We can't run this._cleanupLastCompilation() as the Stats to this compilation