webpack 5.97.1 → 5.99.0

package/lib/library/ModuleLibraryPlugin.js

@@ -8,6 +8,7 @@
 const { ConcatSource } = require("webpack-sources");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
+const ConcatenatedModule = require("../optimize/ConcatenatedModule");
 const propertyAccess = require("../util/propertyAccess");
 const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 
@@ -18,9 +19,14 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
 /** @typedef {import("../util/Hash")} Hash */
-/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
+
+/**
+ * @template T
+ * @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T>
+ */
 
 /**
  * @typedef {object} ModuleLibraryPluginOptions
@@ -30,6 +36,7 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /**
  * @typedef {object} ModuleLibraryPluginParsed
  * @property {string} name
+ * @property {string | string[]=} export
  */
 
 /**
@@ -47,6 +54,45 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		});
 	}
 
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		super.apply(compiler);
+
+		compiler.hooks.compilation.tap("ModernModuleLibraryPlugin", compilation => {
+			const { exportsDefinitions } =
+				ConcatenatedModule.getCompilationHooks(compilation);
+			exportsDefinitions.tap(
+				"ModernModuleLibraryPlugin",
+				(definitions, module) => {
+					// If we have connections not all modules were concatenated, so we need the wrapper
+					const connections =
+						compilation.moduleGraph.getIncomingConnections(module);
+
+					for (const connection of connections) {
+						if (connection.originModule) {
+							return false;
+						}
+					}
+
+					// Runtime and splitting chunks now requires the wrapper too
+					for (const chunk of compilation.chunkGraph.getModuleChunksIterable(
+						module
+					)) {
+						if (!chunk.hasRuntime()) {
+							return false;
+						}
+					}
+
+					return true;
+				}
+			);
+		});
+	}
+
 	/**
 	 * @param {LibraryOptions} library normalized library option
 	 * @returns {T | false} preprocess as needed by overriding
@@ -60,7 +106,8 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		}
 		const _name = /** @type {string} */ (name);
 		return {
-			name: _name
+			name: _name,
+			export: library.export
 		};
 	}
 
@@ -78,30 +125,89 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		{ options, compilation }
 	) {
 		const result = new ConcatSource(source);
-		const exportsInfo = moduleGraph.getExportsInfo(module);
+		const exportsInfos = options.export
+			? [
+					moduleGraph.getExportInfo(
+						module,
+						Array.isArray(options.export) ? options.export[0] : options.export
+					)
+				]
+			: moduleGraph.getExportsInfo(module).orderedExports;
+		const definitions =
+			/** @type {BuildMeta} */
+			(module.buildMeta).exportsFinalName || {};
+		const shortHandedExports = [];
 		const exports = [];
 		const isAsync = moduleGraph.isAsync(module);
+
 		if (isAsync) {
 			result.add(
 				`${RuntimeGlobals.exports} = await ${RuntimeGlobals.exports};\n`
 			);
 		}
-		for (const exportInfo of exportsInfo.orderedExports) {
+
+		for (const exportInfo of exportsInfos) {
 			if (!exportInfo.provided) continue;
-			const varName = `${RuntimeGlobals.exports}${Template.toIdentifier(
-				exportInfo.name
-			)}`;
-			result.add(
-				`var ${varName} = ${RuntimeGlobals.exports}${propertyAccess([
-					/** @type {string} */
-					(exportInfo.getUsedName(exportInfo.name, chunk.runtime))
-				])};\n`
+
+			let shouldContinue = false;
+
+			const reexport = exportInfo.findTarget(moduleGraph, _m => true);
+
+			if (reexport) {
+				const exp = moduleGraph.getExportsInfo(reexport.module);
+
+				for (const reexportInfo of exp.orderedExports) {
+					if (
+						reexportInfo.provided === false &&
+						reexportInfo.name === /** @type {string[]} */ (reexport.export)[0]
+					) {
+						shouldContinue = true;
+					}
+				}
+			}
+
+			if (shouldContinue) continue;
+
+			const webpackExportsProperty = exportInfo.getUsedName(
+				exportInfo.name,
+				chunk.runtime
 			);
-			exports.push(`${varName} as ${exportInfo.name}`);
+			const definition =
+				definitions[/** @type {string} */ (webpackExportsProperty)];
+			const finalName =
+				definition ||
+				`${RuntimeGlobals.exports}${Template.toIdentifier(exportInfo.name)}`;
+
+			if (!definition) {
+				result.add(
+					`var ${finalName} = ${RuntimeGlobals.exports}${propertyAccess([
+						/** @type {string} */
+						(exportInfo.getUsedName(exportInfo.name, chunk.runtime))
+					])}\n`
+				);
+			}
+
+			if (finalName && (finalName.includes(".") || finalName.includes("["))) {
+				exports.push([exportInfo.name, finalName]);
+			} else {
+				shortHandedExports.push(
+					definition && finalName === exportInfo.name
+						? finalName
+						: `${finalName} as ${exportInfo.name}`
+				);
+			}
 		}
-		if (exports.length > 0) {
-			result.add(`export { ${exports.join(", ")} };\n`);
+
+		if (shortHandedExports.length > 0) {
+			result.add(`export { ${shortHandedExports.join(", ")} };\n`);
 		}
+
+		for (const [exportName, final] of exports) {
+			result.add(
+				`export ${compilation.outputOptions.environment.const ? "const" : "var"} ${exportName} = ${final};\n`
+			);
+		}
+
 		return result;
 	}
 }

package/lib/logging/Logger.js

@@ -37,8 +37,8 @@ const TIMERS_AGGREGATES_SYMBOL = Symbol("webpack logger aggregated times");
 
 class WebpackLogger {
 	/**
-	 * @param {function(LogTypeEnum, EXPECTED_ANY[]=): void} log log function
-	 * @param {function(string | function(): string): WebpackLogger} getChildLogger function to create child logger
+	 * @param {(type: LogTypeEnum, args?: EXPECTED_ANY[]) => void} log log function
+	 * @param {(name: string | (() => string)) => WebpackLogger} getChildLogger function to create child logger
 	 */
 	constructor(log, getChildLogger) {
 		this[LOG_SYMBOL] = log;

package/lib/logging/createConsoleLogger.js

@@ -11,13 +11,13 @@ const { LogType } = require("./Logger");
 /** @typedef {import("../../declarations/WebpackOptions").FilterTypes} FilterTypes */
 /** @typedef {import("./Logger").LogTypeEnum} LogTypeEnum */
 
-/** @typedef {function(string): boolean} FilterFunction */
-/** @typedef {function(string, LogTypeEnum, EXPECTED_ANY[]=): void} LoggingFunction */
+/** @typedef {(item: string) => boolean} FilterFunction */
+/** @typedef {(value: string, type: LogTypeEnum, args?: EXPECTED_ANY[]) => void} LoggingFunction */
 
 /**
  * @typedef {object} LoggerConsole
- * @property {function(): void} clear
- * @property {function(): void} trace
+ * @property {() => void} clear
+ * @property {() => void} trace
  * @property {(...args: EXPECTED_ANY[]) => void} info
  * @property {(...args: EXPECTED_ANY[]) => void} log
  * @property {(...args: EXPECTED_ANY[]) => void} warn

package/lib/node/NodeEnvironmentPlugin.js

@@ -15,10 +15,14 @@ const nodeConsole = require("./nodeConsole");
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 
+/**
+ * @typedef {object} NodeEnvironmentPluginOptions
+ * @property {InfrastructureLogging} infrastructureLogging infrastructure logging options
+ */
+
 class NodeEnvironmentPlugin {
 	/**
-	 * @param {object} options options
-	 * @param {InfrastructureLogging} options.infrastructureLogging infrastructure logging options
+	 * @param {NodeEnvironmentPluginOptions} options options
 	 */
 	constructor(options) {
 		this.options = options;

package/lib/node/ReadFileCompileAsyncWasmPlugin.js

@@ -50,8 +50,7 @@ class ReadFileCompileAsyncWasmPlugin {
 			};
 
 			/**
-			 * @param {string} path path to wasm file
-			 * @returns {string} generated code to load the wasm file
+			 * @type {(path: string) => string} callback to generate code to load the wasm file
 			 */
 			const generateLoadBinaryCode = this._import
 				? path =>

package/lib/node/ReadFileCompileWasmPlugin.js

@@ -53,8 +53,7 @@ class ReadFileCompileWasmPlugin {
 			};
 
 			/**
-			 * @param {string} path path to wasm file
-			 * @returns {string} generated code to load the wasm file
+			 * @type {(path: string) => string} callback to generate code to load the wasm file
 			 */
 			const generateLoadBinaryCode = this.options.import
 				? path =>

package/lib/node/nodeConsole.js

@@ -10,6 +10,8 @@ const truncateArgs = require("../logging/truncateArgs");
 
 /** @typedef {import("../logging/createConsoleLogger").LoggerConsole} LoggerConsole */
 
+/* eslint-disable no-console */
+
 /**
  * @param {object} options options
  * @param {boolean=} options.colors colors
@@ -67,7 +69,7 @@ module.exports = ({ colors, appendOnly, stream }) => {
 	 * @param {string} prefix prefix
 	 * @param {string} colorPrefix color prefix
 	 * @param {string} colorSuffix color suffix
-	 * @returns {(function(...EXPECTED_ANY[]): void)} function to write with colors
+	 * @returns {(...args: EXPECTED_ANY[]) => void} function to write with colors
 	 */
 	const writeColored =
 		(prefix, colorPrefix, colorSuffix) =>

package/lib/optimize/AggressiveSplittingPlugin.js

@@ -44,7 +44,7 @@ const moveModuleBetween = (chunkGraph, oldChunk, newChunk) => module => {
 /**
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @param {Chunk} chunk the chunk
- * @returns {function(Module): boolean} filter for entry module
+ * @returns {(module: Module) => boolean} filter for entry module
  */
 const isNotAEntryModule = (chunkGraph, chunk) => module =>
 	!chunkGraph.isEntryModuleInChunk(module, chunk);

package/lib/optimize/ConcatenatedModule.js

@@ -20,6 +20,7 @@ const { JS_TYPES } = require("../ModuleSourceTypesConstants");
 const { JAVASCRIPT_MODULE_TYPE_ESM } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
+const { DEFAULTS } = require("../config/defaults");
 const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
 const JavascriptParser = require("../javascript/JavascriptParser");
 const { equals } = require("../util/ArrayHelpers");
@@ -60,6 +61,7 @@ const {
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
+/** @typedef {import("../Module").BuildCallback} BuildCallback */
 /** @typedef {import("../Module").BuildInfo} BuildInfo */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
@@ -84,6 +86,7 @@ const {
 /** @typedef {typeof import("../util/Hash")} HashConstructor */
 /** @typedef {import("../util/concatenate").UsedNames} UsedNames */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("../util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 /**
@@ -98,7 +101,7 @@ const {
 
 // fix eslint-scope to support class properties correctly
 // cspell:word Referencer
-const ReferencerClass = /** @type {any} */ (Referencer);
+const ReferencerClass = /** @type {EXPECTED_ANY} */ (Referencer);
 if (!ReferencerClass.prototype.PropertyDefinition) {
 	ReferencerClass.prototype.PropertyDefinition =
 		ReferencerClass.prototype.Property;
@@ -600,7 +603,7 @@ const getFinalName = (
 
 /**
  * @typedef {object} ConcatenateModuleHooks
- * @property {SyncBailHook<[Record<string, string>], boolean | void>} exportsDefinitions
+ * @property {SyncBailHook<[Record<string, string>, ConcatenatedModule], boolean | void>} exportsDefinitions
  */
 
 /** @type {WeakMap<Compilation, ConcatenateModuleHooks>} */
@@ -612,7 +615,7 @@ class ConcatenatedModule extends Module {
 	 * @param {Set<Module>} modules all modules in the concatenation (including the root module)
 	 * @param {RuntimeSpec} runtime the runtime
 	 * @param {Compilation} compilation the compilation
-	 * @param {object=} associatedObjectForCache object for caching
+	 * @param {AssociatedObjectForCache=} associatedObjectForCache object for caching
 	 * @param {string | HashConstructor=} hashFunction hash function to use
 	 * @returns {ConcatenatedModule} the module
 	 */
@@ -622,7 +625,7 @@ class ConcatenatedModule extends Module {
 		runtime,
 		compilation,
 		associatedObjectForCache,
-		hashFunction = "md4"
+		hashFunction = DEFAULTS.HASH_FUNCTION
 	) {
 		const identifier = ConcatenatedModule._createIdentifier(
 			rootModule,
@@ -647,7 +650,7 @@ class ConcatenatedModule extends Module {
 		let hooks = compilationHooksMap.get(compilation);
 		if (hooks === undefined) {
 			hooks = {
-				exportsDefinitions: new SyncBailHook(["definitions"])
+				exportsDefinitions: new SyncBailHook(["definitions", "module"])
 			};
 			compilationHooksMap.set(compilation, hooks);
 		}
@@ -745,7 +748,7 @@ class ConcatenatedModule extends Module {
 	 * @param {Compilation} compilation the compilation
 	 * @param {ResolverWithOptions} resolver the resolver
 	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
+	 * @param {BuildCallback} callback callback function
 	 * @returns {void}
 	 */
 	build(options, compilation, resolver, fs, callback) {
@@ -1040,7 +1043,7 @@ class ConcatenatedModule extends Module {
 	/**
 	 * @param {Module} rootModule the root module of the concatenation
 	 * @param {Set<Module>} modules all modules in the concatenation (including the root module)
-	 * @param {object=} associatedObjectForCache object for caching
+	 * @param {AssociatedObjectForCache=} associatedObjectForCache object for caching
 	 * @param {string | HashConstructor=} hashFunction hash function to use
 	 * @returns {string} the identifier
 	 */
@@ -1048,7 +1051,7 @@ class ConcatenatedModule extends Module {
 		rootModule,
 		modules,
 		associatedObjectForCache,
-		hashFunction = "md4"
+		hashFunction = DEFAULTS.HASH_FUNCTION
 	) {
 		const cachedMakePathsRelative = makePathsRelative.bindContextCache(
 			/** @type {string} */ (rootModule.context),
@@ -1418,7 +1421,7 @@ class ConcatenatedModule extends Module {
 		}
 
 		// Map with all root exposed used exports
-		/** @type {Map<string, function(RequestShortener): string>} */
+		/** @type {Map<string, (requestShortener: RequestShortener) => string>} */
 		const exportsMap = new Map();
 
 		// Set with all root exposed unused exports
@@ -1485,7 +1488,8 @@ class ConcatenatedModule extends Module {
 		// define exports
 		if (exportsMap.size > 0) {
 			const { exportsDefinitions } = ConcatenatedModule.getCompilationHooks(
-				/** @type {Compilation} */ (this.compilation)
+				/** @type {Compilation} */
+				(this.compilation)
 			);
 
 			const definitions = [];
@@ -1496,8 +1500,11 @@ class ConcatenatedModule extends Module {
 					)}`
 				);
 			}
-			const shouldSkipRenderDefinitions =
-				exportsDefinitions.call(exportsFinalName);
+
+			const shouldSkipRenderDefinitions = exportsDefinitions.call(
+				exportsFinalName,
+				this
+			);
 
 			if (!shouldSkipRenderDefinitions) {
 				runtimeRequirements.add(RuntimeGlobals.exports);

package/lib/optimize/InnerGraph.js

@@ -9,6 +9,7 @@ const { UsageState } = require("../ExportsInfo");
 
 /** @typedef {import("estree").Node} AnyNode */
 /** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
@@ -18,7 +19,7 @@ const { UsageState } = require("../ExportsInfo");
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 /** @typedef {Map<TopLevelSymbol | null, Set<string | TopLevelSymbol> | true | undefined>} InnerGraph */
-/** @typedef {function(boolean | Set<string> | undefined): void} UsageCallback */
+/** @typedef {(value: boolean | Set<string> | undefined) => void} UsageCallback */
 
 /**
  * @typedef {object} StateObject
@@ -314,7 +315,7 @@ module.exports.isDependencyUsedByExports = (
  * @param {Dependency} dependency the dependency
  * @param {Set<string> | boolean | undefined} usedByExports usedByExports info
  * @param {ModuleGraph} moduleGraph moduleGraph
- * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
+ * @returns {null | false | GetConditionFn} function to determine if the connection is active
  */
 module.exports.getDependencyUsedByExportsCondition = (
 	dependency,

package/lib/optimize/InnerGraphPlugin.js

@@ -15,8 +15,10 @@ const InnerGraph = require("./InnerGraph");
 /** @typedef {import("estree").ClassDeclaration} ClassDeclaration */
 /** @typedef {import("estree").ClassExpression} ClassExpression */
 /** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").MaybeNamedClassDeclaration} MaybeNamedClassDeclaration */
+/** @typedef {import("estree").MaybeNamedFunctionDeclaration} MaybeNamedFunctionDeclaration */
 /** @typedef {import("estree").Node} Node */
-/** @typedef {import("estree").VariableDeclarator} VariableDeclaratorNode */
+/** @typedef {import("estree").VariableDeclarator} VariableDeclarator */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Dependency")} Dependency */
@@ -98,17 +100,17 @@ class InnerGraphPlugin {
 					// 2. classes (class declaration, class expression)
 					// 3. variable declarators (const x = ...)
 
-					/** @type {WeakMap<Node, TopLevelSymbol>} */
+					/** @type {WeakMap<Node | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration, TopLevelSymbol>} */
 					const statementWithTopLevelSymbol = new WeakMap();
-					/** @type {WeakMap<Node, Node>} */
+					/** @type {WeakMap<Node | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration, Node>} */
 					const statementPurePart = new WeakMap();
 
-					/** @type {WeakMap<ClassExpression | ClassDeclaration, TopLevelSymbol>} */
+					/** @type {WeakMap<ClassExpression | ClassDeclaration | MaybeNamedClassDeclaration, TopLevelSymbol>} */
 					const classWithTopLevelSymbol = new WeakMap();
 
-					/** @type {WeakMap<VariableDeclaratorNode, TopLevelSymbol>} */
+					/** @type {WeakMap<VariableDeclarator, TopLevelSymbol>} */
 					const declWithTopLevelSymbol = new WeakMap();
-					/** @type {WeakSet<VariableDeclaratorNode>} */
+					/** @type {WeakSet<VariableDeclarator>} */
 					const pureDeclarators = new WeakSet();
 
 					// The following hooks are used during prewalking:
@@ -397,7 +399,11 @@ class InnerGraphPlugin {
 									});
 								}
 							}
-							parser.walkExpression(decl.init);
+							parser.walkExpression(
+								/** @type {NonNullable<VariableDeclarator["init"]>} */ (
+									decl.init
+								)
+							);
 							InnerGraph.setTopLevelSymbol(parser.state, undefined);
 							return true;
 						} else if (

package/lib/optimize/LimitChunkCountPlugin.js

@@ -89,25 +89,44 @@ class LimitChunkCountPlugin {
 					// this is large. Size = chunks * (chunks - 1) / 2
 					// It uses a multi layer bucket sort plus normal sort in the last layer
 					// It's also lazy so only accessed buckets are sorted
+					/** @type {LazyBucketSortedSet<ChunkCombination, number>} */
 					const combinations = new LazyBucketSortedSet(
 						// Layer 1: ordered by largest size benefit
 						c => c.sizeDiff,
 						(a, b) => b - a,
+
 						// Layer 2: ordered by smallest combined size
 						/**
 						 * @param {ChunkCombination} c combination
 						 * @returns {number} integrated size
 						 */
 						c => c.integratedSize,
+						/**
+						 * @param {number} a a
+						 * @param {number} b b
+						 * @returns {number} result
+						 */
 						(a, b) => a - b,
+
 						// Layer 3: ordered by position difference in orderedChunk (-> to be deterministic)
 						/**
 						 * @param {ChunkCombination} c combination
 						 * @returns {number} position difference
 						 */
 						c => c.bIdx - c.aIdx,
+						/**
+						 * @param {number} a a
+						 * @param {number} b b
+						 * @returns {number} result
+						 */
 						(a, b) => a - b,
+
 						// Layer 4: ordered by position in orderedChunk (-> to be deterministic)
+						/**
+						 * @param {ChunkCombination} a a
+						 * @param {ChunkCombination} b b
+						 * @returns {number} result
+						 */
 						(a, b) => a.bIdx - b.bIdx
 					);
 
@@ -132,6 +151,7 @@ class LimitChunkCountPlugin {
 
 							const aSize = chunkGraph.getChunkSize(a, options);
 							const bSize = chunkGraph.getChunkSize(b, options);
+							/** @type {ChunkCombination} */
 							const c = {
 								deleted: false,
 								sizeDiff: aSize + bSize - integratedSize,

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -8,6 +8,7 @@
 const asyncLib = require("neo-async");
 const ChunkGraph = require("../ChunkGraph");
 const ModuleGraph = require("../ModuleGraph");
+const { JS_TYPE } = require("../ModuleSourceTypesConstants");
 const { STAGE_DEFAULT } = require("../OptimizationStages");
 const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
 const { compareModulesByIdentifier } = require("../util/comparators");
@@ -101,7 +102,7 @@ class ModuleConcatenationPlugin {
 
 			/**
 			 * @param {Module} module the module
-			 * @param {Module | function(RequestShortener): string} problem the problem
+			 * @param {Module | ((requestShortener: RequestShortener) => string)} problem the problem
 			 * @returns {(requestShortener: RequestShortener) => string} the reason
 			 */
 			const formatBailoutWarning = (module, problem) => requestShortener => {
@@ -452,7 +453,7 @@ class ModuleConcatenationPlugin {
 												chunkGraph.disconnectChunkAndModule(chunk, m);
 											} else {
 												const newSourceTypes = new Set(sourceTypes);
-												newSourceTypes.delete("javascript");
+												newSourceTypes.delete(JS_TYPE);
 												chunkGraph.setChunkModuleSourceTypes(
 													chunk,
 													m,
@@ -543,11 +544,11 @@ class ModuleConcatenationPlugin {
 	 * @param {RuntimeSpec} activeRuntime the runtime scope of the root module
 	 * @param {Set<Module>} possibleModules modules that are candidates
 	 * @param {Set<Module>} candidates list of potential candidates (will be added to)
-	 * @param {Map<Module, Module | function(RequestShortener): string>} failureCache cache for problematic modules to be more performant
+	 * @param {Map<Module, Module | ((requestShortener: RequestShortener) => string)>} failureCache cache for problematic modules to be more performant
 	 * @param {ChunkGraph} chunkGraph the chunk graph
 	 * @param {boolean} avoidMutateOnFailure avoid mutating the config when adding fails
 	 * @param {Statistics} statistics gathering metrics
-	 * @returns {null | Module | function(RequestShortener): string} the problematic module
+	 * @returns {null | Module | ((requestShortener: RequestShortener) => string)} the problematic module
 	 */
 	_tryToAdd(
 		compilation,
@@ -846,6 +847,8 @@ class ModuleConcatenationPlugin {
 	}
 }
 
+/** @typedef {Module | ((requestShortener: RequestShortener) => string)} Problem */
+
 class ConcatConfiguration {
 	/**
 	 * @param {Module} rootModule the root module
@@ -857,7 +860,7 @@ class ConcatConfiguration {
 		/** @type {Set<Module>} */
 		this.modules = new Set();
 		this.modules.add(rootModule);
-		/** @type {Map<Module, Module | function(RequestShortener): string>} */
+		/** @type {Map<Module, Problem>} */
 		this.warnings = new Map();
 	}
 
@@ -882,14 +885,14 @@ class ConcatConfiguration {
 
 	/**
 	 * @param {Module} module the module
-	 * @param {Module | function(RequestShortener): string} problem the problem
+	 * @param {Problem} problem the problem
 	 */
 	addWarning(module, problem) {
 		this.warnings.set(module, problem);
 	}
 
 	/**
-	 * @returns {Map<Module, Module | function(RequestShortener): string>} warnings
+	 * @returns {Map<Module, Problem>} warnings
 	 */
 	getWarningsSorted() {
 		return new Map(

package/lib/optimize/RealContentHashPlugin.js

@@ -38,7 +38,7 @@ const addToList = (itemOrItems, list) => {
 /**
  * @template T
  * @param {T[]} input list
- * @param {function(T): Buffer} fn map function
+ * @param {(item: T) => Buffer} fn map function
  * @returns {Buffer[]} buffers without duplicates
  */
 const mapAndDeduplicateBuffers = (input, fn) => {
@@ -107,6 +107,12 @@ const toCachedSource = source => {
 /** @type {WeakMap<Compilation, CompilationHooks>} */
 const compilationHooksMap = new WeakMap();
 
+/**
+ * @typedef {object} RealContentHashPluginOptions
+ * @property {string | Hash} hashFunction the hash function to use
+ * @property {string=} hashDigest the hash digest to use
+ */
+
 class RealContentHashPlugin {
 	/**
 	 * @param {Compilation} compilation the compilation
@@ -129,9 +135,7 @@ class RealContentHashPlugin {
 	}
 
 	/**
-	 * @param {object} options options object
-	 * @param {string | Hash} options.hashFunction the hash function to use
-	 * @param {string} options.hashDigest the hash digest to use
+	 * @param {RealContentHashPluginOptions} options options
 	 */
 	constructor({ hashFunction, hashDigest }) {
 		this._hashFunction = hashFunction;