webpack 5.90.3 → 5.92.0

package/lib/optimize/ConcatenatedModule.js

@@ -26,6 +26,7 @@ const { concatComparators } = require("../util/comparators");
 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 {
@@ -37,7 +38,9 @@ const {
 	subtractRuntimeCondition
 } = require("../util/runtime");
 
+/** @typedef {import("eslint-scope").Reference} Reference */
 /** @typedef {import("eslint-scope").Scope} Scope */
+/** @typedef {import("eslint-scope").Variable} Variable */
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
@@ -48,10 +51,12 @@ const {
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
-/** @template T @typedef {import("../InitFragment")<T>} InitFragment */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
@@ -61,21 +66,34 @@ const {
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../WebpackError")} WebpackError */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
+/** @typedef {import("../javascript/JavascriptParser").Program} Program */
+/** @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/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
+/**
+ * @template T
+ * @typedef {import("../InitFragment")<T>} InitFragment
+ */
+
+/**
+ * @template T
+ * @typedef {import("../util/comparators").Comparator<T>} Comparator
+ */
+
 // fix eslint-scope to support class properties correctly
 // cspell:word Referencer
-const ReferencerClass = Referencer;
+const ReferencerClass = /** @type {any} */ (Referencer);
 if (!ReferencerClass.prototype.PropertyDefinition) {
 	ReferencerClass.prototype.PropertyDefinition =
 		ReferencerClass.prototype.Property;
 }
 
 /**
- * @typedef {Object} ReexportInfo
+ * @typedef {object} ReexportInfo
  * @property {Module} module
  * @property {string[]} export
  */
@@ -83,7 +101,7 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
 /** @typedef {RawBinding | SymbolBinding} Binding */
 
 /**
- * @typedef {Object} RawBinding
+ * @typedef {object} RawBinding
  * @property {ModuleInfo} info
  * @property {string} rawName
  * @property {string=} comment
@@ -92,7 +110,7 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
  */
 
 /**
- * @typedef {Object} SymbolBinding
+ * @typedef {object} SymbolBinding
  * @property {ConcatenatedModuleInfo} info
  * @property {string} name
  * @property {string=} comment
@@ -104,32 +122,32 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
 /** @typedef {ConcatenatedModuleInfo | ExternalModuleInfo | ReferenceToModuleInfo } ModuleInfoOrReference */
 
 /**
- * @typedef {Object} ConcatenatedModuleInfo
+ * @typedef {object} ConcatenatedModuleInfo
  * @property {"concatenated"} type
  * @property {Module} module
  * @property {number} index
- * @property {Object} ast
+ * @property {Program | undefined} ast
  * @property {Source} internalSource
  * @property {ReplaceSource} source
  * @property {InitFragment<ChunkRenderContext>[]=} chunkInitFragments
- * @property {Iterable<string>} runtimeRequirements
+ * @property {ReadOnlyRuntimeRequirements} runtimeRequirements
  * @property {Scope} globalScope
  * @property {Scope} moduleScope
  * @property {Map<string, string>} internalNames
- * @property {Map<string, string>} exportMap
- * @property {Map<string, string>} rawExportMap
+ * @property {Map<string, string> | undefined} exportMap
+ * @property {Map<string, string> | undefined} rawExportMap
  * @property {string=} namespaceExportSymbol
- * @property {string} namespaceObjectName
+ * @property {string | undefined} namespaceObjectName
  * @property {boolean} interopNamespaceObjectUsed
- * @property {string} interopNamespaceObjectName
+ * @property {string | undefined} interopNamespaceObjectName
  * @property {boolean} interopNamespaceObject2Used
- * @property {string} interopNamespaceObject2Name
+ * @property {string | undefined} interopNamespaceObject2Name
  * @property {boolean} interopDefaultAccessUsed
- * @property {string} interopDefaultAccessName
+ * @property {string | undefined} interopDefaultAccessName
  */
 
 /**
- * @typedef {Object} ExternalModuleInfo
+ * @typedef {object} ExternalModuleInfo
  * @property {"external"} type
  * @property {Module} module
  * @property {RuntimeSpec | boolean} runtimeCondition
@@ -144,12 +162,14 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
  */
 
 /**
- * @typedef {Object} ReferenceToModuleInfo
+ * @typedef {object} ReferenceToModuleInfo
  * @property {"reference"} type
  * @property {RuntimeSpec | boolean} runtimeCondition
  * @property {ConcatenatedModuleInfo | ExternalModuleInfo} target
  */
 
+/** @typedef {Set<string>} UsedNames */
+
 const RESERVED_NAMES = new Set(
 	[
 		// internal names (should always be renamed)
@@ -190,6 +210,12 @@ const RESERVED_NAMES = new Set(
 
 const createComparator = (property, comparator) => (a, b) =>
 	comparator(a[property], b[property]);
+
+/**
+ * @param {number} a a
+ * @param {number} b b
+ * @returns {0 | 1 | -1} result
+ */
 const compareNumbers = (a, b) => {
 	if (isNaN(a)) {
 		if (!isNaN(b)) {
@@ -208,6 +234,10 @@ const compareNumbers = (a, b) => {
 const bySourceOrder = createComparator("sourceOrder", compareNumbers);
 const byRangeStart = createComparator("rangeStart", compareNumbers);
 
+/**
+ * @param {Iterable<string>} iterable iterable object
+ * @returns {string} joined iterable object
+ */
 const joinIterableWithComma = iterable => {
 	// This is more performant than Array.from().join(", ")
 	// as it doesn't create an array
@@ -225,7 +255,7 @@ const joinIterableWithComma = iterable => {
 };
 
 /**
- * @typedef {Object} ConcatenationEntry
+ * @typedef {object} ConcatenationEntry
  * @property {"concatenated" | "external"} type
  * @property {Module} module
  * @property {RuntimeSpec | boolean} runtimeCondition
@@ -241,7 +271,7 @@ const joinIterableWithComma = iterable => {
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
  * @param {Set<ConcatenatedModuleInfo>} neededNamespaceObjects modules for which a namespace object should be generated
  * @param {boolean} asCall asCall
- * @param {boolean} strictHarmonyModule strictHarmonyModule
+ * @param {boolean | undefined} strictHarmonyModule strictHarmonyModule
  * @param {boolean | undefined} asiSafe asiSafe
  * @param {Set<ExportInfo>} alreadyVisited alreadyVisited
  * @returns {Binding} the final variable
@@ -270,7 +300,7 @@ const getFinalBinding = (
 				info.interopNamespaceObject2Used = true;
 				return {
 					info,
-					rawName: info.interopNamespaceObject2Name,
+					rawName: /** @type {string} */ (info.interopNamespaceObject2Name),
 					ids: exportName,
 					exportName
 				};
@@ -278,7 +308,7 @@ const getFinalBinding = (
 				info.interopNamespaceObjectUsed = true;
 				return {
 					info,
-					rawName: info.interopNamespaceObjectName,
+					rawName: /** @type {string} */ (info.interopNamespaceObjectName),
 					ids: exportName,
 					exportName
 				};
@@ -366,7 +396,7 @@ const getFinalBinding = (
 				neededNamespaceObjects.add(info);
 				return {
 					info,
-					rawName: info.namespaceObjectName,
+					rawName: /** @type {string} */ (info.namespaceObjectName),
 					ids: exportName,
 					exportName
 				};
@@ -393,7 +423,7 @@ const getFinalBinding = (
 				neededNamespaceObjects.add(info);
 				return {
 					info,
-					rawName: info.namespaceObjectName,
+					rawName: /** @type {string} */ (info.namespaceObjectName),
 					ids: exportName,
 					exportName
 				};
@@ -445,7 +475,7 @@ const getFinalBinding = (
 				const refInfo = moduleToInfoMap.get(reexport.module);
 				return getFinalBinding(
 					moduleGraph,
-					refInfo,
+					/** @type {ModuleInfo} */ (refInfo),
 					reexport.export
 						? [...reexport.export, ...exportName.slice(1)]
 						: exportName.slice(1),
@@ -455,7 +485,8 @@ const getFinalBinding = (
 					runtimeTemplate,
 					neededNamespaceObjects,
 					asCall,
-					info.module.buildMeta.strictHarmonyModule,
+					/** @type {BuildMeta} */
+					(info.module.buildMeta).strictHarmonyModule,
 					asiSafe,
 					alreadyVisited
 				);
@@ -466,7 +497,7 @@ const getFinalBinding = (
 				);
 				return {
 					info,
-					rawName: info.namespaceObjectName,
+					rawName: /** @type {string} */ (info.namespaceObjectName),
 					ids: usedName,
 					exportName
 				};
@@ -508,8 +539,8 @@ const getFinalBinding = (
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
  * @param {Set<ConcatenatedModuleInfo>} neededNamespaceObjects modules for which a namespace object should be generated
  * @param {boolean} asCall asCall
- * @param {boolean} callContext callContext
- * @param {boolean} strictHarmonyModule strictHarmonyModule
+ * @param {boolean | undefined} callContext callContext
+ * @param {boolean | undefined} strictHarmonyModule strictHarmonyModule
  * @param {boolean | undefined} asiSafe asiSafe
  * @returns {string} the final name
  */
@@ -576,6 +607,12 @@ 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) {
@@ -589,63 +626,6 @@ const addScopeSymbols = (s, nameSet, scopeSet1, scopeSet2) => {
 	}
 };
 
-const getAllReferences = variable => {
-	let set = variable.references;
-	// Look for inner scope variables too (like in class Foo { t() { Foo } })
-	const identifiers = new Set(variable.identifiers);
-	for (const scope of variable.scope.childScopes) {
-		for (const innerVar of scope.variables) {
-			if (innerVar.identifiers.some(id => identifiers.has(id))) {
-				set = set.concat(innerVar.references);
-				break;
-			}
-		}
-	}
-	return set;
-};
-
-const getPathInAst = (ast, node) => {
-	if (ast === node) {
-		return [];
-	}
-
-	const nr = node.range;
-
-	const enterNode = n => {
-		if (!n) return undefined;
-		const r = n.range;
-		if (r) {
-			if (r[0] <= nr[0] && r[1] >= nr[1]) {
-				const path = getPathInAst(n, node);
-				if (path) {
-					path.push(n);
-					return path;
-				}
-			}
-		}
-		return undefined;
-	};
-
-	if (Array.isArray(ast)) {
-		for (let i = 0; i < ast.length; i++) {
-			const enterResult = enterNode(ast[i]);
-			if (enterResult !== undefined) return enterResult;
-		}
-	} else if (ast && typeof ast === "object") {
-		const keys = Object.keys(ast);
-		for (let i = 0; i < keys.length; i++) {
-			const value = ast[keys[i]];
-			if (Array.isArray(value)) {
-				const pathResult = getPathInAst(value, node);
-				if (pathResult !== undefined) return pathResult;
-			} else if (value && typeof value === "object") {
-				const enterResult = enterNode(value);
-				if (enterResult !== undefined) return enterResult;
-			}
-		}
-	}
-};
-
 const TYPES = new Set(["javascript"]);
 
 class ConcatenatedModule extends Module {
@@ -653,7 +633,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 {RuntimeSpec} runtime the runtime
-	 * @param {Object=} associatedObjectForCache object for caching
+	 * @param {object=} associatedObjectForCache object for caching
 	 * @param {string | HashConstructor=} hashFunction hash function to use
 	 * @returns {ConcatenatedModule} the module
 	 */
@@ -679,7 +659,7 @@ class ConcatenatedModule extends Module {
 	}
 
 	/**
-	 * @param {Object} options options
+	 * @param {object} options options
 	 * @param {string} options.identifier the identifier of the module
 	 * @param {Module=} options.rootModule the root module of the concatenation
 	 * @param {RuntimeSpec} options.runtime the selected runtime
@@ -772,11 +752,14 @@ class ConcatenatedModule extends Module {
 	 */
 	build(options, compilation, resolver, fs, callback) {
 		const { rootModule } = this;
+		const { moduleArgument, exportsArgument } =
+			/** @type {BuildInfo} */
+			(rootModule.buildInfo);
 		this.buildInfo = {
 			strict: true,
 			cacheable: true,
-			moduleArgument: rootModule.buildInfo.moduleArgument,
-			exportsArgument: rootModule.buildInfo.exportsArgument,
+			moduleArgument,
+			exportsArgument,
 			fileDependencies: new LazySet(),
 			contextDependencies: new LazySet(),
 			missingDependencies: new LazySet(),
@@ -789,7 +772,7 @@ class ConcatenatedModule extends Module {
 
 		for (const m of this._modules) {
 			// populate cacheable
-			if (!m.buildInfo.cacheable) {
+			if (!(/** @type {BuildInfo} */ (m.buildInfo).cacheable)) {
 				this.buildInfo.cacheable = false;
 			}
 
@@ -797,7 +780,9 @@ class ConcatenatedModule extends Module {
 			for (const d of m.dependencies.filter(
 				dep =>
 					!(dep instanceof HarmonyImportDependency) ||
-					!this._modules.has(compilation.moduleGraph.getModule(dep))
+					!this._modules.has(
+						/** @type {Module} */ (compilation.moduleGraph.getModule(dep))
+					)
 			)) {
 				this.dependencies.push(d);
 			}
@@ -822,11 +807,14 @@ class ConcatenatedModule extends Module {
 				}
 			}
 
+			const { assets, assetsInfo, topLevelDeclarations } =
+				/** @type {BuildInfo} */ (m.buildInfo);
+
 			// populate topLevelDeclarations
-			if (m.buildInfo.topLevelDeclarations) {
+			if (topLevelDeclarations) {
 				const topLevelDeclarations = this.buildInfo.topLevelDeclarations;
 				if (topLevelDeclarations !== undefined) {
-					for (const decl of m.buildInfo.topLevelDeclarations) {
+					for (const decl of topLevelDeclarations) {
 						topLevelDeclarations.add(decl);
 					}
 				}
@@ -835,17 +823,17 @@ class ConcatenatedModule extends Module {
 			}
 
 			// populate assets
-			if (m.buildInfo.assets) {
+			if (assets) {
 				if (this.buildInfo.assets === undefined) {
 					this.buildInfo.assets = Object.create(null);
 				}
-				Object.assign(this.buildInfo.assets, m.buildInfo.assets);
+				Object.assign(/** @type {BuildInfo} */ (this.buildInfo).assets, assets);
 			}
-			if (m.buildInfo.assetsInfo) {
+			if (assetsInfo) {
 				if (this.buildInfo.assetsInfo === undefined) {
 					this.buildInfo.assetsInfo = new Map();
 				}
-				for (const [key, value] of m.buildInfo.assetsInfo) {
+				for (const [key, value] of assetsInfo) {
 					this.buildInfo.assetsInfo.set(key, value);
 				}
 			}
@@ -1045,7 +1033,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 {object=} associatedObjectForCache object for caching
 	 * @param {string | HashConstructor=} hashFunction hash function to use
 	 * @returns {string} the identifier
 	 */
@@ -1056,7 +1044,7 @@ class ConcatenatedModule extends Module {
 		hashFunction = "md4"
 	) {
 		const cachedMakePathsRelative = makePathsRelative.bindContextCache(
-			rootModule.context,
+			/** @type {string} */ (rootModule.context),
 			associatedObjectForCache
 		);
 		let identifiers = [];
@@ -1139,12 +1127,12 @@ class ConcatenatedModule extends Module {
 		const topLevelDeclarations = new Set();
 
 		// List of additional names in scope for module references
-		/** @type {Map<string, { usedNames: Set<string>, alreadyCheckedScopes: Set<TODO> }>} */
+		/** @type {Map<string, { usedNames: UsedNames, alreadyCheckedScopes: Set<TODO> }>} */
 		const usedNamesInScopeInfo = new Map();
 		/**
 		 * @param {string} module module identifier
 		 * @param {string} id export id
-		 * @returns {{ usedNames: Set<string>, alreadyCheckedScopes: Set<TODO> }} info
+		 * @returns {{ usedNames: UsedNames, alreadyCheckedScopes: Set<TODO> }} info
 		 */
 		const getUsedNamesInScopeInfo = (module, id) => {
 			const key = `${module}-${id}`;
@@ -1174,6 +1162,10 @@ class ConcatenatedModule extends Module {
 				// We get ranges of all super class expressions to make
 				// renaming to work correctly
 				const superClassCache = new WeakMap();
+				/**
+				 * @param {Scope} scope scope
+				 * @returns {TODO} result
+				 */
 				const getSuperClassExpressions = scope => {
 					const cacheEntry = superClassCache.get(scope);
 					if (cacheEntry !== undefined) return cacheEntry;
@@ -1216,7 +1208,8 @@ class ConcatenatedModule extends Module {
 								runtimeTemplate,
 								neededNamespaceObjects,
 								false,
-								info.module.buildMeta.strictHarmonyModule,
+								/** @type {BuildMeta} */
+								(info.module.buildMeta).strictHarmonyModule,
 								true
 							);
 							if (!binding.ids) continue;
@@ -1227,8 +1220,10 @@ class ConcatenatedModule extends Module {
 								);
 							for (const expr of getSuperClassExpressions(reference.from)) {
 								if (
-									expr.range[0] <= reference.identifier.range[0] &&
-									expr.range[1] >= reference.identifier.range[1]
+									expr.range[0] <=
+										/** @type {Range} */ (reference.identifier.range)[0] &&
+									expr.range[1] >=
+										/** @type {Range} */ (reference.identifier.range)[1]
 								) {
 									for (const variable of expr.variables) {
 										usedNames.add(variable.name);
@@ -1287,7 +1282,7 @@ class ConcatenatedModule extends Module {
 								references.map(r => r.identifier).concat(variable.identifiers)
 							);
 							for (const identifier of allIdentifiers) {
-								const r = identifier.range;
+								const r = /** @type {Range} */ (identifier.range);
 								const path = getPathInAst(info.ast, identifier);
 								if (path && path.length > 1) {
 									const maybeProperty =
@@ -1325,7 +1320,9 @@ class ConcatenatedModule extends Module {
 						);
 						allUsedNames.add(namespaceObjectName);
 					}
-					info.namespaceObjectName = namespaceObjectName;
+					info.namespaceObjectName =
+						/** @type {string} */
+						(namespaceObjectName);
 					topLevelDeclarations.add(namespaceObjectName);
 					break;
 				}
@@ -1342,7 +1339,8 @@ class ConcatenatedModule extends Module {
 					break;
 				}
 			}
-			if (info.module.buildMeta.exportsType !== "namespace") {
+			const buildMeta = /** @type {BuildMeta} */ (info.module.buildMeta);
+			if (buildMeta.exportsType !== "namespace") {
 				const externalNameInterop = this.findNewName(
 					"namespaceObject",
 					allUsedNames,
@@ -1354,8 +1352,8 @@ class ConcatenatedModule extends Module {
 				topLevelDeclarations.add(externalNameInterop);
 			}
 			if (
-				info.module.buildMeta.exportsType === "default" &&
-				info.module.buildMeta.defaultObject !== "redirect"
+				buildMeta.exportsType === "default" &&
+				buildMeta.defaultObject !== "redirect"
 			) {
 				const externalNameInterop = this.findNewName(
 					"namespaceObject2",
@@ -1367,10 +1365,7 @@ class ConcatenatedModule extends Module {
 				info.interopNamespaceObject2Name = externalNameInterop;
 				topLevelDeclarations.add(externalNameInterop);
 			}
-			if (
-				info.module.buildMeta.exportsType === "dynamic" ||
-				!info.module.buildMeta.exportsType
-			) {
+			if (buildMeta.exportsType === "dynamic" || !buildMeta.exportsType) {
 				const externalNameInterop = this.findNewName(
 					"default",
 					allUsedNames,
@@ -1404,10 +1399,11 @@ class ConcatenatedModule extends Module {
 							neededNamespaceObjects,
 							match.call,
 							!match.directImport,
-							info.module.buildMeta.strictHarmonyModule,
+							/** @type {BuildMeta} */
+							(info.module.buildMeta).strictHarmonyModule,
 							match.asiSafe
 						);
-						const r = reference.identifier.range;
+						const r = /** @type {Range} */ (reference.identifier.range);
 						const source = info.source;
 						// range is extended by 2 chars to cover the appended "._"
 						source.replace(r[0], r[1] + 1, finalName);
@@ -1427,7 +1423,9 @@ class ConcatenatedModule extends Module {
 		const rootInfo = /** @type {ConcatenatedModuleInfo} */ (
 			moduleToInfoMap.get(this.rootModule)
 		);
-		const strictHarmonyModule = rootInfo.module.buildMeta.strictHarmonyModule;
+		const strictHarmonyModule =
+			/** @type {BuildMeta} */
+			(rootInfo.module.buildMeta).strictHarmonyModule;
 		const exportsInfo = moduleGraph.getExportsInfo(rootInfo.module);
 		for (const exportInfo of exportsInfo.orderedExports) {
 			const name = exportInfo.name;
@@ -1457,7 +1455,9 @@ class ConcatenatedModule extends Module {
 						exportInfo.isReexport() ? "reexport" : "binding"
 					} */ ${finalName}`;
 				} catch (e) {
-					e.message += `\nwhile generating the root export '${name}' (used name: '${used}')`;
+					/** @type {Error} */
+					(e).message +=
+						`\nwhile generating the root export '${name}' (used name: '${used}')`;
 					throw e;
 				}
 			});
@@ -1527,7 +1527,8 @@ class ConcatenatedModule extends Module {
 						neededNamespaceObjects,
 						false,
 						undefined,
-						info.module.buildMeta.strictHarmonyModule,
+						/** @type {BuildMeta} */
+						(info.module.buildMeta).strictHarmonyModule,
 						true
 					);
 					nsObj.push(
@@ -1698,7 +1699,9 @@ ${defineGetters}`
 					codeGenerationResults,
 					sourceTypes: TYPES
 				});
-				const source = codeGenResult.sources.get("javascript");
+				const source = /** @type {Source} */ (
+					codeGenResult.sources.get("javascript")
+				);
 				const data = codeGenResult.data;
 				const chunkInitFragments = data && data.get("chunkInitFragments");
 				const code = source.source().toString();
@@ -1730,7 +1733,7 @@ ${defineGetters}`
 					ignoreEval: true,
 					impliedStrict: true
 				});
-				const globalScope = scopeManager.acquire(ast);
+				const globalScope = /** @type {Scope} */ (scopeManager.acquire(ast));
 				const moduleScope = globalScope.childScopes[0];
 				const resultSource = new ReplaceSource(source);
 				info.runtimeRequirements = codeGenResult.runtimeRequirements;
@@ -1741,7 +1744,9 @@ ${defineGetters}`
 				info.globalScope = globalScope;
 				info.moduleScope = moduleScope;
 			} catch (err) {
-				err.message += `\nwhile analyzing module ${m.identifier()} for concatenation`;
+				/** @type {Error} */
+				(err).message +=
+					`\nwhile analyzing module ${m.identifier()} for concatenation`;
 				throw err;
 			}
 		}
@@ -1809,7 +1814,10 @@ ${defineGetters}`
 							`Unsupported concatenation entry type ${info.type}`
 						);
 				}
-				map.set(item.module, item);
+				map.set(
+					/** @type {ModuleInfo} */ (item).module,
+					/** @type {ModuleInfo} */ (item)
+				);
 				return item;
 			} else {
 				/** @type {ReferenceToModuleInfo} */
@@ -1824,6 +1832,13 @@ ${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;
 
@@ -1889,6 +1904,10 @@ ${defineGetters}`
 		super.updateHash(hash, context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {ConcatenatedModule} ConcatenatedModule
+	 */
 	static deserialize(context) {
 		const obj = new ConcatenatedModule({
 			identifier: undefined,

package/lib/optimize/EnsureChunkConditionsPlugin.js

@@ -56,7 +56,7 @@ class EnsureChunkConditionsPlugin {
 							// We reached the entrypoint: fail
 							if (chunkGroup.isInitial()) {
 								throw new Error(
-									"Cannot fullfil chunk condition of " + module.identifier()
+									"Cannot fulfil chunk condition of " + module.identifier()
 								);
 							}
 							// Try placing in all parents