webpack 5.104.1 → 5.105.1

package/lib/logging/Logger.js

@@ -37,14 +37,18 @@ const TIMERS_SYMBOL = Symbol("webpack logger times");
 const TIMERS_AGGREGATES_SYMBOL = Symbol("webpack logger aggregated times");
 
 /** @typedef {EXPECTED_ANY[]} Args */
+/** @typedef {(type: LogTypeEnum, args?: Args) => void} LogFn */
+/** @typedef {(name: string | (() => string)) => WebpackLogger} GetChildLogger */
 
 class WebpackLogger {
 	/**
-	 * @param {(type: LogTypeEnum, args?: Args) => void} log log function
-	 * @param {(name: string | (() => string)) => WebpackLogger} getChildLogger function to create child logger
+	 * @param {LogFn} log log function
+	 * @param {GetChildLogger} getChildLogger function to create child logger
 	 */
 	constructor(log, getChildLogger) {
+		/** @type {LogFn} */
 		this[LOG_SYMBOL] = log;
+		/** @type {GetChildLogger} */
 		this.getChildLogger = getChildLogger;
 	}
 
@@ -84,11 +88,11 @@ class WebpackLogger {
 	}
 
 	/**
-	 * @param {EXPECTED_ANY} assertion assertion
+	 * @param {boolean=} condition condition
 	 * @param {Args} args args
 	 */
-	assert(assertion, ...args) {
-		if (!assertion) {
+	assert(condition, ...args) {
+		if (!condition) {
 			this[LOG_SYMBOL](LogType.error, args);
 		}
 	}

package/lib/logging/createConsoleLogger.js

@@ -99,6 +99,10 @@ module.exports = ({ level = "info", debug = false, console }) => {
 	 * @returns {void}
 	 */
 	const logger = (name, type, args) => {
+		/**
+		 * @template T
+		 * @returns {[string?, ...T[]]} labeled args
+		 */
 		const labeledArgs = () => {
 			if (Array.isArray(args)) {
 				if (args.length > 0 && typeof args[0] === "string") {

package/lib/logging/truncateArgs.js

@@ -16,7 +16,7 @@ const arraySum = (array) => {
 };
 
 /**
- * @param {EXPECTED_ANY[]} args items to be truncated
+ * @param {string[]} args items to be truncated
  * @param {number} maxLength maximum length of args including spaces between
  * @returns {string[]} truncated args
  */

package/lib/node/CommonJsChunkLoadingPlugin.js

@@ -24,7 +24,8 @@ class CommonJsChunkLoadingPlugin {
 	 * @param {CommonJsChunkLoadingPluginOptions=} options options
 	 */
 	constructor(options = {}) {
-		this._asyncChunkLoading = options.asyncChunkLoading;
+		/** @type {CommonJsChunkLoadingPluginOptions} */
+		this.options = options;
 	}
 
 	/**
@@ -33,15 +34,15 @@ class CommonJsChunkLoadingPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		const ChunkLoadingRuntimeModule = this._asyncChunkLoading
+		const ChunkLoadingRuntimeModule = this.options.asyncChunkLoading
 			? require("./ReadFileChunkLoadingRuntimeModule")
 			: require("./RequireChunkLoadingRuntimeModule");
-		const chunkLoadingValue = this._asyncChunkLoading
+		const chunkLoadingValue = this.options.asyncChunkLoading
 			? "async-node"
 			: "require";
 		new StartupChunkDependenciesPlugin({
 			chunkLoading: chunkLoadingValue,
-			asyncChunkLoading: this._asyncChunkLoading
+			asyncChunkLoading: this.options.asyncChunkLoading
 		}).apply(compiler);
 		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			const globalChunkLoading = compilation.outputOptions.chunkLoading;
@@ -57,6 +58,7 @@ class CommonJsChunkLoadingPlugin {
 						: globalChunkLoading;
 				return chunkLoading === chunkLoadingValue;
 			};
+			/** @type {WeakSet<Chunk>} */
 			const onceForChunkSet = new WeakSet();
 			/**
 			 * @param {Chunk} chunk chunk

package/lib/node/NodeEnvironmentPlugin.js

@@ -27,6 +27,7 @@ class NodeEnvironmentPlugin {
 	 * @param {NodeEnvironmentPluginOptions} options options
 	 */
 	constructor(options) {
+		/** @type {NodeEnvironmentPluginOptions} */
 		this.options = options;
 	}
 

package/lib/node/NodeTargetPlugin.js

@@ -77,6 +77,7 @@ class NodeTargetPlugin {
 	 * @param {ExternalsType} type default external type
 	 */
 	constructor(type = "node-commonjs") {
+		/** @type {ExternalsType} */
 		this.type = type;
 	}
 
@@ -86,7 +87,15 @@ class NodeTargetPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		new ExternalsPlugin(this.type, builtins).apply(compiler);
+		new ExternalsPlugin((dependency) => {
+			// When `require` node.js built-in modules with module output
+			// we should still emit `createRequire` for compatibility
+			if (dependency.category === "commonjs") {
+				return "node-commonjs";
+			}
+
+			return this.type;
+		}, builtins).apply(compiler);
 	}
 }
 

package/lib/node/NodeTemplatePlugin.js

@@ -20,6 +20,7 @@ class NodeTemplatePlugin {
 	 * @param {NodeTemplatePluginOptions=} options options object
 	 */
 	constructor(options = {}) {
+		/** @type {NodeTemplatePluginOptions} */
 		this._options = options;
 	}
 

package/lib/node/NodeWatchFileSystem.js

@@ -8,6 +8,8 @@
 const util = require("util");
 const Watchpack = require("watchpack");
 
+/** @typedef {import("watchpack").TimeInfoEntries} TimeInfoEntries */
+/** @typedef {import("watchpack").WatchOptions} WatchOptions */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("../util/fs").WatchMethod} WatchMethod */
 /** @typedef {import("../util/fs").Changes} Changes */
@@ -18,7 +20,9 @@ class NodeWatchFileSystem {
 	 * @param {InputFileSystem} inputFileSystem input filesystem
 	 */
 	constructor(inputFileSystem) {
+		/** @type {InputFileSystem} */
 		this.inputFileSystem = inputFileSystem;
+		/** @type {WatchOptions} */
 		this.watcherOptions = {
 			aggregateTimeout: 0
 		};
@@ -65,7 +69,9 @@ class NodeWatchFileSystem {
 		}
 
 		const fetchTimeInfo = () => {
+			/** @type {TimeInfoEntries} */
 			const fileTimeInfoEntries = new Map();
+			/** @type {TimeInfoEntries} */
 			const contextTimeInfoEntries = new Map();
 			if (this.watcher) {
 				this.watcher.collectTimeInfoEntries(

package/lib/node/ReadFileChunkLoadingRuntimeModule.js

@@ -30,6 +30,7 @@ class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 	 */
 	constructor(runtimeRequirements) {
 		super("readFile chunk loading", RuntimeModule.STAGE_ATTACH);
+		/** @type {ReadOnlyRuntimeRequirements} */
 		this.runtimeRequirements = runtimeRequirements;
 	}
 

package/lib/node/ReadFileCompileAsyncWasmPlugin.js

@@ -25,6 +25,7 @@ class ReadFileCompileAsyncWasmPlugin {
 	 * @param {ReadFileCompileAsyncWasmPluginOptions=} options options object
 	 */
 	constructor({ import: useImport = false } = {}) {
+		/** @type {boolean} */
 		this._import = useImport;
 	}
 

package/lib/node/ReadFileCompileWasmPlugin.js

@@ -26,6 +26,7 @@ class ReadFileCompileWasmPlugin {
 	 * @param {ReadFileCompileWasmPluginOptions=} options options object
 	 */
 	constructor(options = {}) {
+		/** @type {ReadFileCompileWasmPluginOptions} */
 		this.options = options;
 	}
 

package/lib/node/RequireChunkLoadingRuntimeModule.js

@@ -30,6 +30,7 @@ class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 	 */
 	constructor(runtimeRequirements) {
 		super("require chunk loading", RuntimeModule.STAGE_ATTACH);
+		/** @type {ReadOnlyRuntimeRequirements} */
 		this.runtimeRequirements = runtimeRequirements;
 	}
 

package/lib/node/nodeConsole.js

@@ -67,10 +67,11 @@ module.exports = ({ colors, appendOnly, stream }) => {
 	};
 
 	/**
+	 * @template T
 	 * @param {string} prefix prefix
 	 * @param {string} colorPrefix color prefix
 	 * @param {string} colorSuffix color suffix
-	 * @returns {(...args: EXPECTED_ANY[]) => void} function to write with colors
+	 * @returns {(...args: T[]) => void} function to write with colors
 	 */
 	const writeColored =
 		(prefix, colorPrefix, colorSuffix) =>
@@ -87,12 +88,14 @@ module.exports = ({ colors, appendOnly, stream }) => {
 			writeStatusMessage();
 		};
 
+	/** @type {<T extends unknown[]>(...args: T) => void} */
 	const writeGroupMessage = writeColored(
 		"<-> ",
 		"\u001B[1m\u001B[36m",
 		"\u001B[39m\u001B[22m"
 	);
 
+	/** @type {<T extends unknown[]>(...args: T) => void} */
 	const writeGroupCollapsedMessage = writeColored(
 		"<+> ",
 		"\u001B[1m\u001B[36m",
@@ -100,17 +103,25 @@ module.exports = ({ colors, appendOnly, stream }) => {
 	);
 
 	return {
+		/** @type {LoggerConsole["log"]} */
 		log: writeColored("    ", "\u001B[1m", "\u001B[22m"),
+		/** @type {LoggerConsole["debug"]} */
 		debug: writeColored("    ", "", ""),
+		/** @type {LoggerConsole["trace"]} */
 		trace: writeColored("    ", "", ""),
+		/** @type {LoggerConsole["info"]} */
 		info: writeColored("<i> ", "\u001B[1m\u001B[32m", "\u001B[39m\u001B[22m"),
+		/** @type {LoggerConsole["warn"]} */
 		warn: writeColored("<w> ", "\u001B[1m\u001B[33m", "\u001B[39m\u001B[22m"),
+		/** @type {LoggerConsole["error"]} */
 		error: writeColored("<e> ", "\u001B[1m\u001B[31m", "\u001B[39m\u001B[22m"),
+		/** @type {LoggerConsole["logTime"]} */
 		logTime: writeColored(
 			"<t> ",
 			"\u001B[1m\u001B[35m",
 			"\u001B[39m\u001B[22m"
 		),
+		/** @type {LoggerConsole["group"]} */
 		group: (...args) => {
 			writeGroupMessage(...args);
 			if (currentCollapsed > 0) {
@@ -119,10 +130,12 @@ module.exports = ({ colors, appendOnly, stream }) => {
 				currentIndent += "  ";
 			}
 		},
+		/** @type {LoggerConsole["groupCollapsed"]} */
 		groupCollapsed: (...args) => {
 			writeGroupCollapsedMessage(...args);
 			currentCollapsed++;
 		},
+		/** @type {LoggerConsole["groupEnd"]} */
 		groupEnd: () => {
 			if (currentCollapsed > 0) {
 				currentCollapsed--;
@@ -130,8 +143,11 @@ module.exports = ({ colors, appendOnly, stream }) => {
 				currentIndent = currentIndent.slice(0, -2);
 			}
 		},
+		/** @type {LoggerConsole["profile"]} */
 		profile: console.profile && ((name) => console.profile(name)),
+		/** @type {LoggerConsole["profileEnd"]} */
 		profileEnd: console.profileEnd && ((name) => console.profileEnd(name)),
+		/** @type {LoggerConsole["clear"]} */
 		clear:
 			/** @type {() => void} */
 			(
@@ -143,6 +159,7 @@ module.exports = ({ colors, appendOnly, stream }) => {
 						writeStatusMessage();
 					})
 			),
+		/** @type {LoggerConsole["status"]} */
 		status: appendOnly
 			? writeColored("<s> ", "", "")
 			: (name, ...args) => {

package/lib/optimize/AggressiveMergingPlugin.js

@@ -30,6 +30,7 @@ class AggressiveMergingPlugin {
 				"Argument should be an options object. To use defaults, pass in nothing.\nFor more info on options, see https://webpack.js.org/plugins/"
 			);
 		}
+		/** @type {AggressiveMergingPluginOptions} */
 		this.options = options || {};
 	}
 
@@ -50,7 +51,7 @@ class AggressiveMergingPlugin {
 				},
 				(chunks) => {
 					const chunkGraph = compilation.chunkGraph;
-					/** @type {{a: Chunk, b: Chunk, improvement: number}[]} */
+					/** @type {{ a: Chunk, b: Chunk, improvement: number }[]} */
 					const combinations = [];
 					for (const a of chunks) {
 						if (a.canBeInitial()) continue;

package/lib/optimize/AggressiveSplittingPlugin.js

@@ -50,7 +50,7 @@ const moveModuleBetween = (chunkGraph, oldChunk, newChunk) => (module) => {
 const isNotAEntryModule = (chunkGraph, chunk) => (module) =>
 	!chunkGraph.isEntryModuleInChunk(module, chunk);
 
-/** @typedef {{ id?: NonNullable<Chunk["id"]>, hash?: NonNullable<Chunk["hash"]>, modules: Module[], size: number }} SplitData */
+/** @typedef {{ id?: NonNullable<Chunk["id"]>, hash?: NonNullable<Chunk["hash"]>, modules: string[], size: number }} SplitData */
 
 /** @type {WeakSet<Chunk>} */
 const recordedChunks = new WeakSet();
@@ -64,16 +64,21 @@ class AggressiveSplittingPlugin {
 	constructor(options = {}) {
 		validate(options);
 
+		/** @type {AggressiveSplittingPluginOptions} */
 		this.options = options;
+
 		if (typeof this.options.minSize !== "number") {
 			this.options.minSize = 30 * 1024;
 		}
+
 		if (typeof this.options.maxSize !== "number") {
 			this.options.maxSize = 50 * 1024;
 		}
+
 		if (typeof this.options.chunkOverhead !== "number") {
 			this.options.chunkOverhead = 0;
 		}
+
 		if (typeof this.options.entryChunkMultiplicator !== "number") {
 			this.options.entryChunkMultiplicator = 1;
 		}
@@ -114,7 +119,9 @@ class AggressiveSplittingPlugin {
 				(chunks) => {
 					const chunkGraph = compilation.chunkGraph;
 					// Precompute stuff
+					/** @type {Map<string, Module>} */
 					const nameToModuleMap = new Map();
+					/** @type {Map<Module, string>} */
 					const moduleToNameMap = new Map();
 					const makePathsRelative =
 						identifierUtils.makePathsRelative.bindContextCache(
@@ -128,10 +135,10 @@ class AggressiveSplittingPlugin {
 					}
 
 					// Check used chunk ids
-					/** @typedef {Set<ChunkId>} */
+					/** @type {Set<ChunkId>} */
 					const usedIds = new Set();
 					for (const chunk of chunks) {
-						usedIds.add(chunk.id);
+						usedIds.add(/** @type {ChunkId} */ (chunk.id));
 					}
 
 					const recordedSplits =
@@ -154,8 +161,8 @@ class AggressiveSplittingPlugin {
 						}
 
 						// Get module objects from names
-						const selectedModules = splitData.modules.map((name) =>
-							nameToModuleMap.get(name)
+						const selectedModules = splitData.modules.map(
+							(name) => /** @type {Module} */ (nameToModuleMap.get(name))
 						);
 
 						// Does the modules exist at all?
@@ -240,6 +247,7 @@ class AggressiveSplittingPlugin {
 							const modules = chunkGraph
 								.getOrderedChunkModules(chunk, compareModulesByIdentifier)
 								.filter(isNotAEntryModule(chunkGraph, chunk));
+							/** @type {Module[]} */
 							const selectedModules = [];
 							let selectedModulesSize = 0;
 							for (let k = 0; k < modules.length; k++) {
@@ -255,7 +263,7 @@ class AggressiveSplittingPlugin {
 							/** @type {SplitData} */
 							const splitData = {
 								modules: selectedModules
-									.map((m) => moduleToNameMap.get(m))
+									.map((m) => /** @type {string} */ (moduleToNameMap.get(m)))
 									.sort(),
 								size: selectedModulesSize
 							};
@@ -271,6 +279,7 @@ class AggressiveSplittingPlugin {
 			);
 			compilation.hooks.recordHash.tap(PLUGIN_NAME, (records) => {
 				// 4. save made splittings to records
+				/** @type {Set<SplitData>} */
 				const allSplits = new Set();
 				/** @type {Set<SplitData>} */
 				const invalidSplits = new Set();

package/lib/optimize/ConcatenatedModule.js

@@ -72,6 +72,7 @@ const {
 /** @typedef {import("../Module").FileSystemDependencies} FileSystemDependencies */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("../Module").CodeGenerationResultData} CodeGenerationResultData */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
 /** @typedef {import("../Module").LibIdent} LibIdent */
@@ -90,7 +91,8 @@ const {
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../util/Hash")} Hash */
-/** @typedef {typeof import("../util/Hash")} HashConstructor */
+/** @typedef {import("../util/Hash").HashFunction} HashFunction */
+/** @typedef {import("../util/concatenate").UsedNames} UsedNames */
 /** @typedef {import("../util/concatenate").ScopeInfo} ScopeInfo */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("../util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */
@@ -227,6 +229,7 @@ const compareNumbers = (a, b) => {
 	}
 	return 0;
 };
+
 const bySourceOrder = createComparator("sourceOrder", compareNumbers);
 const byRangeStart = createComparator("rangeStart", compareNumbers);
 
@@ -653,7 +656,9 @@ const getFinalName = (
 	);
 	{
 		const { ids, comment } = binding;
+		/** @type {string} */
 		let reference;
+		/** @type {boolean} */
 		let isPropertyAccess;
 		if ("rawName" in binding) {
 			reference = `${binding.rawName}${comment || ""}${propertyAccess(ids)}`;
@@ -705,7 +710,7 @@ class ConcatenatedModule extends Module {
 	 * @param {RuntimeSpec} runtime the runtime
 	 * @param {Compilation} compilation the compilation
 	 * @param {AssociatedObjectForCache=} associatedObjectForCache object for caching
-	 * @param {string | HashConstructor=} hashFunction hash function to use
+	 * @param {HashFunction=} hashFunction hash function to use
 	 * @returns {ConcatenatedModule} the module
 	 */
 	static create(
@@ -854,6 +859,7 @@ class ConcatenatedModule extends Module {
 		const { moduleArgument, exportsArgument } =
 			/** @type {BuildInfo} */
 			(rootModule.buildInfo);
+		/** @type {BuildInfo} */
 		this.buildInfo = {
 			strict: true,
 			cacheable: true,
@@ -872,8 +878,7 @@ class ConcatenatedModule extends Module {
 		for (const m of this._modules) {
 			// populate cacheable
 			if (!(/** @type {BuildInfo} */ (m.buildInfo).cacheable)) {
-				/** @type {BuildInfo} */
-				(this.buildInfo).cacheable = false;
+				this.buildInfo.cacheable = false;
 			}
 
 			// populate dependencies
@@ -911,7 +916,7 @@ class ConcatenatedModule extends Module {
 			const { assets, assetsInfo, topLevelDeclarations, needCreateRequire } =
 				/** @type {BuildInfo} */ (m.buildInfo);
 
-			const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
+			const buildInfo = this.buildInfo;
 
 			// populate topLevelDeclarations
 			if (topLevelDeclarations) {
@@ -1209,7 +1214,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 {AssociatedObjectForCache=} associatedObjectForCache object for caching
-	 * @param {string | HashConstructor=} hashFunction hash function to use
+	 * @param {HashFunction=} hashFunction hash function to use
 	 * @returns {string} the identifier
 	 */
 	static _createIdentifier(
@@ -1222,6 +1227,7 @@ class ConcatenatedModule extends Module {
 			/** @type {string} */ (rootModule.context),
 			associatedObjectForCache
 		);
+		/** @type {string[]} */
 		const identifiers = [];
 		for (const module of modules) {
 			identifiers.push(cachedMakePathsRelative(module.identifier()));
@@ -1316,6 +1322,7 @@ class ConcatenatedModule extends Module {
 		const usedNamesInScopeInfo = new Map();
 
 		// Set of already checked scopes
+		/** @type {Set<Scope>} */
 		const ignoredScopes = new Set();
 
 		// get all global names
@@ -1329,14 +1336,17 @@ class ConcatenatedModule extends Module {
 				// The super class expression in class scopes behaves weird
 				// We get ranges of all super class expressions to make
 				// renaming to work correctly
+				/** @typedef {{ range: Range, variables: Variable[] }} ClassInfo */
+				/** @type {WeakMap<Scope, ClassInfo[]>} */
 				const superClassCache = new WeakMap();
 				/**
 				 * @param {Scope} scope scope
-				 * @returns {{ range: Range, variables: Variable[] }[]} result
+				 * @returns {ClassInfo[]} result
 				 */
 				const getSuperClassExpressions = (scope) => {
 					const cacheEntry = superClassCache.get(scope);
 					if (cacheEntry !== undefined) return cacheEntry;
+					/** @type {ClassInfo[]} */
 					const superClassExpressions = [];
 					for (const childScope of scope.childScopes) {
 						if (childScope.type !== "class") continue;
@@ -1462,6 +1472,7 @@ class ConcatenatedModule extends Module {
 					info.module.identifier(),
 					name
 				);
+			/** @type {UsedNames} */
 			const referencesUsedNames = new Set();
 			for (const ref of references) {
 				addScopeSymbols(
@@ -1533,11 +1544,12 @@ class ConcatenatedModule extends Module {
 							topLevelDeclarations.add(name);
 						}
 					}
+					/** @type {string} */
 					let namespaceObjectName;
 					if (info.namespaceExportSymbol) {
-						namespaceObjectName = info.internalNames.get(
-							info.namespaceExportSymbol
-						);
+						namespaceObjectName =
+							/** @type {string} */
+							(info.internalNames.get(info.namespaceExportSymbol));
 					} else {
 						namespaceObjectName = findNewName(
 							"namespaceObject",
@@ -1547,13 +1559,8 @@ class ConcatenatedModule extends Module {
 						);
 						allUsedNames.add(namespaceObjectName);
 					}
-					info.namespaceObjectName =
-						/** @type {string} */
-						(namespaceObjectName);
-					topLevelDeclarations.add(
-						/** @type {string} */
-						(namespaceObjectName)
-					);
+					info.namespaceObjectName = namespaceObjectName;
+					topLevelDeclarations.add(namespaceObjectName);
 					break;
 				}
 				case "external": {
@@ -1636,13 +1643,15 @@ class ConcatenatedModule extends Module {
 			if (info.type === "concatenated") {
 				const globalScope = /** @type {Scope} */ (info.globalScope);
 				// group references by name
+				/** @type {Map<string, Reference[]>} */
 				const referencesByName = new Map();
 				for (const reference of globalScope.through) {
 					const name = reference.identifier.name;
 					if (!referencesByName.has(name)) {
 						referencesByName.set(name, []);
 					}
-					referencesByName.get(name).push(reference);
+					/** @type {Reference[]} */
+					(referencesByName.get(name)).push(reference);
 				}
 				for (const [name, references] of referencesByName) {
 					const match = ConcatenationScope.matchModuleReference(name);
@@ -1775,6 +1784,7 @@ class ConcatenatedModule extends Module {
 
 		// define exports
 		if (exportsMap.size > 0) {
+			/** @type {string[]} */
 			const definitions = [];
 			for (const [key, value] of exportsMap) {
 				definitions.push(
@@ -1826,9 +1836,11 @@ class ConcatenatedModule extends Module {
 		}
 
 		// generate namespace objects
+		/** @type {Map<ConcatenatedModuleInfo, string>} */
 		const namespaceObjectSources = new Map();
 		for (const info of neededNamespaceObjects) {
 			if (info.namespaceExportSymbol) continue;
+			/** @type {string[]} */
 			const nsObj = [];
 			const exportsInfo = moduleGraph.getExportsInfo(info.module);
 			for (const exportInfo of exportsInfo.orderedExports) {
@@ -1924,6 +1936,7 @@ ${defineGetters}`
 
 		// evaluate modules in order
 		for (const rawInfo of modulesWithInfo) {
+			/** @type {undefined | string} */
 			let name;
 			let isConditional = false;
 			const info = rawInfo.type === "reference" ? rawInfo.target : rawInfo;
@@ -2012,6 +2025,7 @@ ${defineGetters}`
 			}
 		}
 
+		/** @type {CodeGenerationResultData} */
 		const data = new Map();
 		if (chunkInitFragments.length > 0) {
 			data.set("chunkInitFragments", chunkInitFragments);
@@ -2038,7 +2052,7 @@ ${defineGetters}`
 	 * @param {RuntimeSpec} runtime runtime
 	 * @param {RuntimeSpec[]} runtimes runtimes
 	 * @param {CodeGenerationResults} codeGenerationResults codeGenerationResults
-	 * @param {Set<string>} usedNames used names
+	 * @param {UsedNames} usedNames used names
 	 */
 	_analyseModule(
 		modulesMap,

package/lib/optimize/FlagIncludedChunksPlugin.js

@@ -42,7 +42,16 @@ class FlagIncludedChunksPlugin {
 
 				// precalculate the modulo values for each bit
 				const modulo = 1 / (1 / modulesCount) ** (1 / 31);
-				const modulos = Array.from({ length: 31 }, (x, i) => (modulo ** i) | 0);
+				/** @type {number[]} */
+				const modulos = Array.from(
+					{ length: 31 },
+					/**
+					 * @param {number} x x
+					 * @param {number} i i
+					 * @returns {number} result
+					 */
+					(x, i) => (modulo ** i) | 0
+				);
 
 				// iterate all modules to generate bit values
 				let i = 0;
@@ -72,6 +81,7 @@ class FlagIncludedChunksPlugin {
 						(chunkModulesHash.get(chunkA));
 					const chunkAModulesCount = chunkGraph.getNumberOfChunkModules(chunkA);
 					if (chunkAModulesCount === 0) continue;
+					/** @type {undefined | Module} */
 					let bestModule;
 					for (const module of chunkGraph.getChunkModulesIterable(chunkA)) {
 						if (

package/lib/optimize/InnerGraph.js

@@ -35,6 +35,7 @@ class TopLevelSymbol {
 	 * @param {string} name name of the variable
 	 */
 	constructor(name) {
+		/** @type {string} */
 		this.name = name;
 	}
 }
@@ -310,6 +311,7 @@ module.exports.onUsage = (state, onUsageCallback) => {
 			let callbacks = usageCallbackMap.get(currentTopLevelSymbol);
 
 			if (callbacks === undefined) {
+				/** @type {Set<UsageCallback>} */
 				callbacks = new Set();
 				usageCallbackMap.set(currentTopLevelSymbol, callbacks);
 			}
@@ -353,14 +355,14 @@ module.exports.tagTopLevelSymbol = (parser, name) => {
 		return existingTag;
 	}
 
-	const fn = new TopLevelSymbol(name);
+	const symbol = new TopLevelSymbol(name);
 	parser.tagVariable(
 		name,
 		topLevelSymbolTag,
-		fn,
+		symbol,
 		JavascriptParser.VariableInfoFlags.Normal
 	);
-	return fn;
+	return symbol;
 };
 
 module.exports.topLevelSymbolTag = topLevelSymbolTag;