webpack 5.95.0 → 5.96.0

package/lib/optimize/ConcatenatedModule.js

@@ -16,6 +16,7 @@ const {
 const ConcatenationScope = require("../ConcatenationScope");
 const { UsageState } = require("../ExportsInfo");
 const Module = require("../Module");
+const { JS_TYPES } = require("../ModuleSourceTypesConstants");
 const { JAVASCRIPT_MODULE_TYPE_ESM } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
@@ -24,10 +25,17 @@ const JavascriptParser = require("../javascript/JavascriptParser");
 const { equals } = require("../util/ArrayHelpers");
 const LazySet = require("../util/LazySet");
 const { concatComparators } = require("../util/comparators");
+const {
+	RESERVED_NAMES,
+	findNewName,
+	addScopeSymbols,
+	getAllReferences,
+	getPathInAst,
+	getUsedNamesInScopeInfo
+} = require("../util/concatenate");
 const createHash = require("../util/createHash");
 const { makePathsRelative } = require("../util/identifier");
 const makeSerializable = require("../util/makeSerializable");
-const { getAllReferences, getPathInAst } = require("../util/mergeScope");
 const propertyAccess = require("../util/propertyAccess");
 const { propertyName } = require("../util/propertyName");
 const {
@@ -58,6 +66,7 @@ const {
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
 /** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
+/** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
@@ -73,6 +82,7 @@ const {
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {typeof import("../util/Hash")} HashConstructor */
+/** @typedef {import("../util/concatenate").UsedNames} UsedNames */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
@@ -130,7 +140,7 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
  * @property {number} index
  * @property {Program | undefined} ast
  * @property {Source | undefined} internalSource
- * @property {ReplaceSource} source
+ * @property {ReplaceSource | undefined} source
  * @property {InitFragment<ChunkRenderContext>[]=} chunkInitFragments
  * @property {ReadOnlyRuntimeRequirements | undefined} runtimeRequirements
  * @property {Scope | undefined} globalScope
@@ -167,55 +177,16 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
  * @typedef {object} ReferenceToModuleInfo
  * @property {"reference"} type
  * @property {RuntimeSpec | boolean} runtimeCondition
- * @property {ConcatenatedModuleInfo | ExternalModuleInfo} target
+ * @property {ModuleInfo} target
  */
 
-/** @typedef {Set<string>} UsedNames */
-
-const RESERVED_NAMES = new Set(
-	[
-		// internal names (should always be renamed)
-		ConcatenationScope.DEFAULT_EXPORT,
-		ConcatenationScope.NAMESPACE_OBJECT_EXPORT,
-
-		// keywords
-		"abstract,arguments,async,await,boolean,break,byte,case,catch,char,class,const,continue",
-		"debugger,default,delete,do,double,else,enum,eval,export,extends,false,final,finally,float",
-		"for,function,goto,if,implements,import,in,instanceof,int,interface,let,long,native,new,null",
-		"package,private,protected,public,return,short,static,super,switch,synchronized,this,throw",
-		"throws,transient,true,try,typeof,var,void,volatile,while,with,yield",
-
-		// commonjs/amd
-		"module,__dirname,__filename,exports,require,define",
-
-		// js globals
-		"Array,Date,eval,function,hasOwnProperty,Infinity,isFinite,isNaN,isPrototypeOf,length,Math",
-		"NaN,name,Number,Object,prototype,String,toString,undefined,valueOf",
-
-		// browser globals
-		"alert,all,anchor,anchors,area,assign,blur,button,checkbox,clearInterval,clearTimeout",
-		"clientInformation,close,closed,confirm,constructor,crypto,decodeURI,decodeURIComponent",
-		"defaultStatus,document,element,elements,embed,embeds,encodeURI,encodeURIComponent,escape",
-		"event,fileUpload,focus,form,forms,frame,innerHeight,innerWidth,layer,layers,link,location",
-		"mimeTypes,navigate,navigator,frames,frameRate,hidden,history,image,images,offscreenBuffering",
-		"open,opener,option,outerHeight,outerWidth,packages,pageXOffset,pageYOffset,parent,parseFloat",
-		"parseInt,password,pkcs11,plugin,prompt,propertyIsEnum,radio,reset,screenX,screenY,scroll",
-		"secure,select,self,setInterval,setTimeout,status,submit,taint,text,textarea,top,unescape",
-		"untaint,window",
-
-		// window events
-		"onblur,onclick,onerror,onfocus,onkeydown,onkeypress,onkeyup,onmouseover,onload,onmouseup,onmousedown,onsubmit"
-	]
-		.join(",")
-		.split(",")
-);
-
 /**
  * @template T
  * @param {string} property property
  * @param {function(T[keyof T], T[keyof T]): 0 | 1 | -1} comparator comparator
  * @returns {Comparator<T>} comparator
  */
+
 const createComparator = (property, comparator) => (a, b) =>
 	comparator(
 		a[/** @type {keyof T} */ (property)],
@@ -627,30 +598,9 @@ const getFinalName = (
 	}
 };
 
-/**
- * @param {Scope | null} s scope
- * @param {UsedNames} nameSet name set
- * @param {TODO} scopeSet1 scope set 1
- * @param {TODO} scopeSet2 scope set 2
- */
-const addScopeSymbols = (s, nameSet, scopeSet1, scopeSet2) => {
-	let scope = s;
-	while (scope) {
-		if (scopeSet1.has(scope)) break;
-		if (scopeSet2.has(scope)) break;
-		scopeSet1.add(scope);
-		for (const variable of scope.variables) {
-			nameSet.add(variable.name);
-		}
-		scope = scope.upper;
-	}
-};
-
-const TYPES = new Set(["javascript"]);
-
 /**
  * @typedef {object} ConcatenateModuleHooks
- * @property {SyncBailHook<[Record<string, string>], boolean>} exportsDefinitions
+ * @property {SyncBailHook<[Record<string, string>], boolean | void>} exportsDefinitions
  */
 
 /** @type {WeakMap<Compilation, ConcatenateModuleHooks>} */
@@ -707,9 +657,9 @@ class ConcatenatedModule extends Module {
 	/**
 	 * @param {object} options options
 	 * @param {string} options.identifier the identifier of the module
-	 * @param {Module=} options.rootModule the root module of the concatenation
+	 * @param {Module} options.rootModule the root module of the concatenation
 	 * @param {RuntimeSpec} options.runtime the selected runtime
-	 * @param {Set<Module>=} options.modules all concatenated modules
+	 * @param {Set<Module>} options.modules all concatenated modules
 	 * @param {Compilation} options.compilation the compilation
 	 */
 	constructor({ identifier, rootModule, modules, runtime, compilation }) {
@@ -743,7 +693,7 @@ class ConcatenatedModule extends Module {
 	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
-		return TYPES;
+		return JS_TYPES;
 	}
 
 	get modules() {
@@ -1148,7 +1098,7 @@ class ConcatenatedModule extends Module {
 		runtime: generationRuntime,
 		codeGenerationResults
 	}) {
-		/** @type {Set<string>} */
+		/** @type {RuntimeRequirements} */
 		const runtimeRequirements = new Set();
 		const runtime = intersectRuntime(generationRuntime, this._runtime);
 
@@ -1174,7 +1124,8 @@ class ConcatenatedModule extends Module {
 				moduleGraph,
 				chunkGraph,
 				runtime,
-				codeGenerationResults
+				/** @type {CodeGenerationResults} */
+				(codeGenerationResults)
 			);
 		}
 
@@ -1191,18 +1142,6 @@ class ConcatenatedModule extends Module {
 		 * @param {string} id export id
 		 * @returns {{ usedNames: UsedNames, alreadyCheckedScopes: Set<TODO> }} info
 		 */
-		const getUsedNamesInScopeInfo = (module, id) => {
-			const key = `${module}-${id}`;
-			let info = usedNamesInScopeInfo.get(key);
-			if (info === undefined) {
-				info = {
-					usedNames: new Set(),
-					alreadyCheckedScopes: new Set()
-				};
-				usedNamesInScopeInfo.set(key, info);
-			}
-			return info;
-		};
 
 		// Set of already checked scopes
 		const ignoredScopes = new Set();
@@ -1272,6 +1211,7 @@ class ConcatenatedModule extends Module {
 							if (!binding.ids) continue;
 							const { usedNames, alreadyCheckedScopes } =
 								getUsedNamesInScopeInfo(
+									usedNamesInScopeInfo,
 									binding.info.module.identifier(),
 									"name" in binding ? binding.name : ""
 								);
@@ -1304,14 +1244,17 @@ class ConcatenatedModule extends Module {
 		// generate names for symbols
 		for (const info of moduleToInfoMap.values()) {
 			const { usedNames: namespaceObjectUsedNames } = getUsedNamesInScopeInfo(
+				usedNamesInScopeInfo,
 				info.module.identifier(),
 				""
 			);
 			switch (info.type) {
 				case "concatenated": {
-					for (const variable of info.moduleScope.variables) {
+					const variables = /** @type {Scope} */ (info.moduleScope).variables;
+					for (const variable of variables) {
 						const name = variable.name;
 						const { usedNames, alreadyCheckedScopes } = getUsedNamesInScopeInfo(
+							usedNamesInScopeInfo,
 							info.module.identifier(),
 							name
 						);
@@ -1325,7 +1268,7 @@ class ConcatenatedModule extends Module {
 									ignoredScopes
 								);
 							}
-							const newName = this.findNewName(
+							const newName = findNewName(
 								name,
 								allUsedNames,
 								usedNames,
@@ -1334,7 +1277,7 @@ class ConcatenatedModule extends Module {
 							allUsedNames.add(newName);
 							info.internalNames.set(name, newName);
 							topLevelDeclarations.add(newName);
-							const source = info.source;
+							const source = /** @type {ReplaceSource} */ (info.source);
 							const allIdentifiers = new Set(
 								references.map(r => r.identifier).concat(variable.identifiers)
 							);
@@ -1373,7 +1316,7 @@ class ConcatenatedModule extends Module {
 							info.namespaceExportSymbol
 						);
 					} else {
-						namespaceObjectName = this.findNewName(
+						namespaceObjectName = findNewName(
 							"namespaceObject",
 							allUsedNames,
 							namespaceObjectUsedNames,
@@ -1388,7 +1331,7 @@ class ConcatenatedModule extends Module {
 					break;
 				}
 				case "external": {
-					const externalName = this.findNewName(
+					const externalName = findNewName(
 						"",
 						allUsedNames,
 						namespaceObjectUsedNames,
@@ -1402,7 +1345,7 @@ class ConcatenatedModule extends Module {
 			}
 			const buildMeta = /** @type {BuildMeta} */ (info.module.buildMeta);
 			if (buildMeta.exportsType !== "namespace") {
-				const externalNameInterop = this.findNewName(
+				const externalNameInterop = findNewName(
 					"namespaceObject",
 					allUsedNames,
 					namespaceObjectUsedNames,
@@ -1416,7 +1359,7 @@ class ConcatenatedModule extends Module {
 				buildMeta.exportsType === "default" &&
 				buildMeta.defaultObject !== "redirect"
 			) {
-				const externalNameInterop = this.findNewName(
+				const externalNameInterop = findNewName(
 					"namespaceObject2",
 					allUsedNames,
 					namespaceObjectUsedNames,
@@ -1427,7 +1370,7 @@ class ConcatenatedModule extends Module {
 				topLevelDeclarations.add(externalNameInterop);
 			}
 			if (buildMeta.exportsType === "dynamic" || !buildMeta.exportsType) {
-				const externalNameInterop = this.findNewName(
+				const externalNameInterop = findNewName(
 					"default",
 					allUsedNames,
 					namespaceObjectUsedNames,
@@ -1466,7 +1409,7 @@ class ConcatenatedModule extends Module {
 							match.asiSafe
 						);
 						const r = /** @type {Range} */ (reference.identifier.range);
-						const source = info.source;
+						const source = /** @type {ReplaceSource} */ (info.source);
 						// range is extended by 2 chars to cover the appended "._"
 						source.replace(r[0], r[1] + 1, finalName);
 					}
@@ -1662,7 +1605,7 @@ ${defineGetters}`
 					result.add(
 						`\n;// ${info.module.readableIdentifier(requestShortener)}\n`
 					);
-					result.add(info.source);
+					result.add(/** @type {ReplaceSource} */ (info.source));
 					if (info.chunkInitFragments) {
 						for (const f of info.chunkInitFragments) chunkInitFragments.push(f);
 					}
@@ -1778,7 +1721,7 @@ ${defineGetters}`
 					runtime,
 					concatenationScope,
 					codeGenerationResults,
-					sourceTypes: TYPES
+					sourceTypes: JS_TYPES
 				});
 				const source = /** @type {Source} */ (
 					codeGenResult.sources.get("javascript")
@@ -1816,7 +1759,9 @@ ${defineGetters}`
 				const globalScope = /** @type {Scope} */ (scopeManager.acquire(ast));
 				const moduleScope = globalScope.childScopes[0];
 				const resultSource = new ReplaceSource(source);
-				info.runtimeRequirements = codeGenResult.runtimeRequirements;
+				info.runtimeRequirements =
+					/** @type {ReadOnlyRuntimeRequirements} */
+					(codeGenResult.runtimeRequirements);
 				info.ast = ast;
 				info.internalSource = source;
 				info.source = resultSource;
@@ -1911,53 +1856,6 @@ ${defineGetters}`
 		return [list, map];
 	}
 
-	/**
-	 * @param {string} oldName old name
-	 * @param {UsedNames} usedNamed1 used named 1
-	 * @param {UsedNames} usedNamed2 used named 2
-	 * @param {string} extraInfo extra info
-	 * @returns {string} found new name
-	 */
-	findNewName(oldName, usedNamed1, usedNamed2, extraInfo) {
-		let name = oldName;
-
-		if (name === ConcatenationScope.DEFAULT_EXPORT) {
-			name = "";
-		}
-		if (name === ConcatenationScope.NAMESPACE_OBJECT_EXPORT) {
-			name = "namespaceObject";
-		}
-
-		// Remove uncool stuff
-		extraInfo = extraInfo.replace(
-			/\.+\/|(\/index)?\.([a-zA-Z0-9]{1,4})($|\s|\?)|\s*\+\s*\d+\s*modules/g,
-			""
-		);
-
-		const splittedInfo = extraInfo.split("/");
-		while (splittedInfo.length) {
-			name = splittedInfo.pop() + (name ? `_${name}` : "");
-			const nameIdent = Template.toIdentifier(name);
-			if (
-				!usedNamed1.has(nameIdent) &&
-				(!usedNamed2 || !usedNamed2.has(nameIdent))
-			)
-				return nameIdent;
-		}
-
-		let i = 0;
-		let nameWithNumber = Template.toIdentifier(`${name}_${i}`);
-		while (
-			usedNamed1.has(nameWithNumber) ||
-			// eslint-disable-next-line no-unmodified-loop-condition
-			(usedNamed2 && usedNamed2.has(nameWithNumber))
-		) {
-			i++;
-			nameWithNumber = Template.toIdentifier(`${name}_${i}`);
-		}
-		return nameWithNumber;
-	}
-
 	/**
 	 * @param {Hash} hash the hash used to track dependencies
 	 * @param {UpdateHashContext} context context
@@ -1990,11 +1888,11 @@ ${defineGetters}`
 	 */
 	static deserialize(context) {
 		const obj = new ConcatenatedModule({
-			identifier: undefined,
-			rootModule: undefined,
-			modules: undefined,
+			identifier: /** @type {EXPECTED_ANY} */ (undefined),
+			rootModule: /** @type {EXPECTED_ANY} */ (undefined),
+			modules: /** @type {EXPECTED_ANY} */ (undefined),
 			runtime: undefined,
-			compilation: undefined
+			compilation: /** @type {EXPECTED_ANY} */ (undefined)
 		});
 		obj.deserialize(context);
 		return obj;

package/lib/optimize/FlagIncludedChunksPlugin.js

@@ -5,6 +5,8 @@
 
 "use strict";
 
+const { compareIds } = require("../util/comparators");
+
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Chunk").ChunkId} ChunkId */
 /** @typedef {import("../Compiler")} Compiler */
@@ -112,8 +114,12 @@ class FlagIncludedChunksPlugin {
 							for (const m of chunkGraph.getChunkModulesIterable(chunkA)) {
 								if (!chunkGraph.isModuleInChunk(m, chunkB)) continue loopB;
 							}
+
 							/** @type {ChunkId[]} */
 							(chunkB.ids).push(/** @type {ChunkId} */ (chunkA.id));
+							// https://github.com/webpack/webpack/issues/18837
+							/** @type {ChunkId[]} */
+							(chunkB.ids).sort(compareIds);
 						}
 					}
 				}

package/lib/optimize/InnerGraphPlugin.js

@@ -12,8 +12,9 @@ const {
 const PureExpressionDependency = require("../dependencies/PureExpressionDependency");
 const InnerGraph = require("./InnerGraph");
 
-/** @typedef {import("estree").ClassDeclaration} ClassDeclarationNode */
-/** @typedef {import("estree").ClassExpression} ClassExpressionNode */
+/** @typedef {import("estree").ClassDeclaration} ClassDeclaration */
+/** @typedef {import("estree").ClassExpression} ClassExpression */
+/** @typedef {import("estree").Expression} Expression */
 /** @typedef {import("estree").Node} Node */
 /** @typedef {import("estree").VariableDeclarator} VariableDeclaratorNode */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
@@ -53,6 +54,9 @@ class InnerGraphPlugin {
 				 * @returns {void}
 				 */
 				const handler = (parser, parserOptions) => {
+					/**
+					 * @param {Expression} sup sup
+					 */
 					const onUsageSuper = sup => {
 						InnerGraph.onUsage(parser.state, usedByExports => {
 							switch (usedByExports) {
@@ -60,8 +64,11 @@ class InnerGraphPlugin {
 								case true:
 									return;
 								default: {
-									const dep = new PureExpressionDependency(sup.range);
-									dep.loc = sup.loc;
+									const dep = new PureExpressionDependency(
+										/** @type {Range} */
+										(sup.range)
+									);
+									dep.loc = /** @type {DependencyLocation} */ (sup.loc);
 									dep.usedByExports = usedByExports;
 									parser.state.module.addDependency(dep);
 									break;
@@ -96,7 +103,7 @@ class InnerGraphPlugin {
 					/** @type {WeakMap<Node, Node>} */
 					const statementPurePart = new WeakMap();
 
-					/** @type {WeakMap<ClassExpressionNode | ClassDeclarationNode, TopLevelSymbol>} */
+					/** @type {WeakMap<ClassExpression | ClassDeclaration, TopLevelSymbol>} */
 					const classWithTopLevelSymbol = new WeakMap();
 
 					/** @type {WeakMap<VariableDeclaratorNode, TopLevelSymbol>} */
@@ -114,7 +121,9 @@ class InnerGraphPlugin {
 							statement.type === "FunctionDeclaration"
 						) {
 							const name = statement.id ? statement.id.name : "*default*";
-							const fn = InnerGraph.tagTopLevelSymbol(parser, name);
+							const fn =
+								/** @type {TopLevelSymbol} */
+								(InnerGraph.tagTopLevelSymbol(parser, name));
 							statementWithTopLevelSymbol.set(statement, fn);
 							return true;
 						}
@@ -132,22 +141,40 @@ class InnerGraphPlugin {
 								)
 							) {
 								const name = statement.id ? statement.id.name : "*default*";
-								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
+								const fn = /** @type {TopLevelSymbol} */ (
+									InnerGraph.tagTopLevelSymbol(parser, name)
+								);
 								classWithTopLevelSymbol.set(statement, fn);
 								return true;
 							}
 							if (statement.type === "ExportDefaultDeclaration") {
 								const name = "*default*";
-								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
+								const fn =
+									/** @type {TopLevelSymbol} */
+									(InnerGraph.tagTopLevelSymbol(parser, name));
 								const decl = statement.declaration;
 								if (
 									(decl.type === "ClassExpression" ||
 										decl.type === "ClassDeclaration") &&
-									parser.isPure(decl, /** @type {Range} */ (decl.range)[0])
+									parser.isPure(
+										/** @type {ClassExpression | ClassDeclaration} */
+										(decl),
+										/** @type {Range} */
+										(decl.range)[0]
+									)
 								) {
-									classWithTopLevelSymbol.set(decl, fn);
+									classWithTopLevelSymbol.set(
+										/** @type {ClassExpression | ClassDeclaration} */
+										(decl),
+										fn
+									);
 								} else if (
-									parser.isPure(decl, /** @type {Range} */ (statement.range)[0])
+									parser.isPure(
+										/** @type {Expression} */
+										(decl),
+										/** @type {Range} */
+										(statement.range)[0]
+									)
 								) {
 									statementWithTopLevelSymbol.set(statement, fn);
 									if (
@@ -155,7 +182,11 @@ class InnerGraphPlugin {
 										!decl.type.endsWith("Declaration") &&
 										decl.type !== "Literal"
 									) {
-										statementPurePart.set(statement, decl);
+										statementPurePart.set(
+											statement,
+											/** @type {Expression} */
+											(decl)
+										);
 									}
 								}
 							}
@@ -177,7 +208,9 @@ class InnerGraphPlugin {
 									/** @type {Range} */ (decl.id.range)[1]
 								)
 							) {
-								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
+								const fn =
+									/** @type {TopLevelSymbol} */
+									(InnerGraph.tagTopLevelSymbol(parser, name));
 								classWithTopLevelSymbol.set(decl.init, fn);
 							} else if (
 								parser.isPure(
@@ -185,7 +218,9 @@ class InnerGraphPlugin {
 									/** @type {Range} */ (decl.id.range)[1]
 								)
 							) {
-								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
+								const fn =
+									/** @type {TopLevelSymbol} */
+									(InnerGraph.tagTopLevelSymbol(parser, name));
 								declWithTopLevelSymbol.set(decl, fn);
 								if (
 									!decl.init.type.endsWith("FunctionExpression") &&
@@ -333,7 +368,10 @@ class InnerGraphPlugin {
 						if (fn) {
 							InnerGraph.setTopLevelSymbol(parser.state, fn);
 							if (pureDeclarators.has(decl)) {
-								if (decl.init.type === "ClassExpression") {
+								if (
+									/** @type {ClassExpression} */
+									(decl.init).type === "ClassExpression"
+								) {
 									if (decl.init.superClass) {
 										onUsageSuper(decl.init.superClass);
 									}
@@ -345,7 +383,10 @@ class InnerGraphPlugin {
 												return;
 											default: {
 												const dep = new PureExpressionDependency(
-													/** @type {Range} */ (decl.init.range)
+													/** @type {Range} */ (
+														/** @type {ClassExpression} */
+														(decl.init).range
+													)
 												);
 												dep.loc = /** @type {DependencyLocation} */ (decl.loc);
 												dep.usedByExports = usedByExports;

package/lib/optimize/LimitChunkCountPlugin.js

@@ -57,7 +57,7 @@ class LimitChunkCountPlugin {
 	 */
 	constructor(options) {
 		validate(options);
-		this.options = options;
+		this.options = /** @type {LimitChunkCountPluginOptions} */ (options);
 	}
 
 	/**
@@ -74,9 +74,7 @@ class LimitChunkCountPlugin {
 				},
 				chunks => {
 					const chunkGraph = compilation.chunkGraph;
-					const maxChunks =
-						/** @type {LimitChunkCountPluginOptions} */
-						(options).maxChunks;
+					const maxChunks = options.maxChunks;
 					if (!maxChunks) return;
 					if (maxChunks < 1) return;
 					if (compilation.chunks.size <= maxChunks) return;

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -395,8 +395,10 @@ class ModuleConcatenationPlugin {
 								newModule.build(
 									compiler.options,
 									compilation,
-									null,
-									null,
+									/** @type {TODO} */
+									(null),
+									/** @type {TODO} */
+									(null),
 									err => {
 										if (err) {
 											if (!err.module) {

package/lib/optimize/RealContentHashPlugin.js

@@ -101,7 +101,7 @@ const toCachedSource = source => {
 
 /**
  * @typedef {object} CompilationHooks
- * @property {SyncBailHook<[Buffer[], string], string>} updateHash
+ * @property {SyncBailHook<[Buffer[], string], string | void>} updateHash
  */
 
 /** @type {WeakMap<Compilation, CompilationHooks>} */

package/lib/optimize/SideEffectsFlagPlugin.js

@@ -24,6 +24,7 @@ const formatLocation = require("../formatLocation");
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../NormalModuleFactory").ModuleSettings} ModuleSettings */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
@@ -112,11 +113,12 @@ class SideEffectsFlagPlugin {
 					return module;
 				});
 				normalModuleFactory.hooks.module.tap(PLUGIN_NAME, (module, data) => {
-					if (typeof data.settings.sideEffects === "boolean") {
+					const settings = /** @type {ModuleSettings} */ (data.settings);
+					if (typeof settings.sideEffects === "boolean") {
 						if (module.factoryMeta === undefined) {
 							module.factoryMeta = {};
 						}
-						module.factoryMeta.sideEffectFree = !data.settings.sideEffects;
+						module.factoryMeta.sideEffectFree = !settings.sideEffects;
 					}
 					return module;
 				});
@@ -212,7 +214,8 @@ class SideEffectsFlagPlugin {
 									case "ExportDefaultDeclaration":
 										if (
 											!parser.isPure(
-												statement.declaration,
+												/** @type {TODO} */
+												(statement.declaration),
 												/** @type {Range} */ (statement.range)[0]
 											)
 										) {

package/lib/rules/RuleSetCompiler.js

@@ -10,7 +10,7 @@ const { SyncHook } = require("tapable");
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetRules} RuleSetRules */
 
-/** @typedef {function(string): boolean} RuleConditionFunction */
+/** @typedef {function(string | EffectData): boolean} RuleConditionFunction */
 
 /**
  * @typedef {object} RuleCondition
@@ -106,7 +106,7 @@ class RuleSetCompiler {
 						}
 					}
 					if (current !== undefined) {
-						if (!condition.fn(/** @type {string} */ (current))) return false;
+						if (!condition.fn(current)) return false;
 						continue;
 					}
 				} else if (p in data) {

package/lib/runtime/GetChunkFilenameRuntimeModule.js

@@ -20,7 +20,7 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 	 * @param {string} contentType the contentType to use the content hash for
 	 * @param {string} name kind of filename
 	 * @param {string} global function name to be assigned
-	 * @param {function(Chunk): TemplatePath} getFilenameForChunk functor to get the filename or function
+	 * @param {function(Chunk): TemplatePath | false} getFilenameForChunk functor to get the filename or function
 	 * @param {boolean} allChunks when false, only async chunks are included
 	 */
 	constructor(contentType, name, global, getFilenameForChunk, allChunks) {
@@ -244,7 +244,7 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 				hashWithLength: length =>
 					`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
 				chunk: {
-					id: `" + chunkId + "`,
+					id: '" + chunkId + "',
 					hash: mapExpr(c => /** @type {string} */ (c.renderedHash)),
 					hashWithLength: mapExprWithLength(
 						c => /** @type {string} */ (c.renderedHash)