webpack 5.101.3 → 5.102.1

package/lib/dependencies/ImportParserPlugin.js

@@ -8,7 +8,11 @@
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const CommentCompilationWarning = require("../CommentCompilationWarning");
 const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
-const { getImportAttributes } = require("../javascript/JavascriptParser");
+const {
+	VariableInfo,
+	getImportAttributes
+} = require("../javascript/JavascriptParser");
+const traverseDestructuringAssignmentProperties = require("../util/traverseDestructuringAssignmentProperties");
 const ContextDependencyHelpers = require("./ContextDependencyHelpers");
 const ImportContextDependency = require("./ImportContextDependency");
 const ImportDependency = require("./ImportDependency");
@@ -19,10 +23,144 @@ const ImportWeakDependency = require("./ImportWeakDependency");
 /** @typedef {import("../ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */
 /** @typedef {import("../ContextModule").ContextMode} ContextMode */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../Dependency").RawReferencedExports} RawReferencedExports */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser").ImportExpression} ImportExpression */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../javascript/JavascriptParser").ParserState} ParserState */
+/** @typedef {import("../javascript/JavascriptParser").Members} Members */
+/** @typedef {import("../javascript/JavascriptParser").MembersOptionals} MembersOptionals */
+/** @typedef {import("../javascript/JavascriptParser").ArrowFunctionExpression} ArrowFunctionExpression */
+/** @typedef {import("../javascript/JavascriptParser").FunctionExpression} FunctionExpression */
+/** @typedef {import("../javascript/JavascriptParser").Identifier} Identifier */
+/** @typedef {import("../javascript/JavascriptParser").ObjectPattern} ObjectPattern */
+/** @typedef {import("../javascript/JavascriptParser").CallExpression} CallExpression */
+
+/** @typedef {{ references: RawReferencedExports, expression: ImportExpression }} ImportSettings */
+/** @typedef {WeakMap<ImportExpression, RawReferencedExports>} State */
+
+/** @type {WeakMap<ParserState, State>} */
+const parserStateMap = new WeakMap();
+const dynamicImportTag = Symbol("import()");
+
+/**
+ * @param {JavascriptParser} parser javascript parser
+ * @returns {State} import parser plugin state
+ */
+function getState(parser) {
+	if (!parserStateMap.has(parser.state)) {
+		parserStateMap.set(parser.state, new WeakMap());
+	}
+	return /** @type {State} */ (parserStateMap.get(parser.state));
+}
+
+/**
+ * @param {JavascriptParser} parser javascript parser
+ * @param {ImportExpression} importCall import expression
+ * @param {string} variableName variable name
+ */
+function tagDynamicImportReferenced(parser, importCall, variableName) {
+	const state = getState(parser);
+	/** @type {RawReferencedExports} */
+	const references = state.get(importCall) || [];
+	state.set(importCall, references);
+	parser.tagVariable(
+		variableName,
+		dynamicImportTag,
+		/** @type {ImportSettings} */ ({
+			references,
+			expression: importCall
+		})
+	);
+}
+
+/**
+ * @param {CallExpression} importThen import().then() call
+ * @returns {Identifier | ObjectPattern | undefined} the dynamic imported namespace obj
+ */
+function getFulfilledCallbackNamespaceObj(importThen) {
+	const fulfilledCallback = importThen.arguments[0];
+	if (
+		fulfilledCallback &&
+		(fulfilledCallback.type === "ArrowFunctionExpression" ||
+			fulfilledCallback.type === "FunctionExpression") &&
+		fulfilledCallback.params[0] &&
+		(fulfilledCallback.params[0].type === "Identifier" ||
+			fulfilledCallback.params[0].type === "ObjectPattern")
+	) {
+		return fulfilledCallback.params[0];
+	}
+}
+
+/**
+ * @param {JavascriptParser} parser javascript parser
+ * @param {ImportExpression} importCall import expression
+ * @param {ArrowFunctionExpression | FunctionExpression} fulfilledCallback the fulfilled callback
+ * @param {Identifier | ObjectPattern} namespaceObjArg the argument of namespace object=
+ */
+function walkImportThenFulfilledCallback(
+	parser,
+	importCall,
+	fulfilledCallback,
+	namespaceObjArg
+) {
+	const arrow = fulfilledCallback.type === "ArrowFunctionExpression";
+	const wasTopLevel = parser.scope.topLevelScope;
+	parser.scope.topLevelScope = arrow ? (wasTopLevel ? "arrow" : false) : false;
+	const scopeParams = [...fulfilledCallback.params];
+
+	// Add function name in scope for recursive calls
+	if (!arrow && fulfilledCallback.id) {
+		scopeParams.push(fulfilledCallback.id);
+	}
+
+	parser.inFunctionScope(!arrow, scopeParams, () => {
+		if (namespaceObjArg.type === "Identifier") {
+			tagDynamicImportReferenced(parser, importCall, namespaceObjArg.name);
+		} else {
+			parser.enterDestructuringAssignment(namespaceObjArg, importCall);
+			const referencedPropertiesInDestructuring =
+				parser.destructuringAssignmentPropertiesFor(importCall);
+			if (referencedPropertiesInDestructuring) {
+				const state = getState(parser);
+				const references = /** @type {RawReferencedExports} */ (
+					state.get(importCall)
+				);
+				/** @type {RawReferencedExports} */
+				const refsInDestructuring = [];
+				traverseDestructuringAssignmentProperties(
+					referencedPropertiesInDestructuring,
+					(stack) => refsInDestructuring.push(stack.map((p) => p.id))
+				);
+				for (const ids of refsInDestructuring) {
+					references.push(ids);
+				}
+			}
+		}
+		for (const param of fulfilledCallback.params) {
+			parser.walkPattern(param);
+		}
+		if (fulfilledCallback.body.type === "BlockStatement") {
+			parser.detectMode(fulfilledCallback.body.body);
+			const prev = parser.prevStatement;
+			parser.preWalkStatement(fulfilledCallback.body);
+			parser.prevStatement = prev;
+			parser.walkStatement(fulfilledCallback.body);
+		} else {
+			parser.walkExpression(fulfilledCallback.body);
+		}
+	});
+	parser.scope.topLevelScope = wasTopLevel;
+}
+
+/**
+ * @template T
+ * @param {Iterable<T>} enumerable enumerable
+ * @returns {T[][]} array of array
+ */
+const exportsFromEnumerable = (enumerable) =>
+	Array.from(enumerable, (e) => [e]);
 
 const PLUGIN_NAME = "ImportParserPlugin";
 
@@ -40,26 +178,94 @@ class ImportParserPlugin {
 	 */
 	apply(parser) {
 		/**
-		 * @template T
-		 * @param {Iterable<T>} enumerable enumerable
-		 * @returns {T[][]} array of array
+		 * @param {Members} members members
+		 * @param {MembersOptionals} membersOptionals members Optionals
+		 * @returns {string[]} a non optional part
 		 */
-		const exportsFromEnumerable = (enumerable) =>
-			Array.from(enumerable, (e) => [e]);
+		function getNonOptionalPart(members, membersOptionals) {
+			let i = 0;
+			while (i < members.length && membersOptionals[i] === false) i++;
+			return i !== members.length ? members.slice(0, i) : members;
+		}
+
 		parser.hooks.collectDestructuringAssignmentProperties.tap(
 			PLUGIN_NAME,
 			(expr) => {
 				if (expr.type === "ImportExpression") return true;
+				const nameInfo = parser.getNameForExpression(expr);
+				if (
+					nameInfo &&
+					nameInfo.rootInfo instanceof VariableInfo &&
+					nameInfo.rootInfo.name &&
+					parser.getTagData(nameInfo.rootInfo.name, dynamicImportTag)
+				) {
+					return true;
+				}
 			}
 		);
-		parser.hooks.importCall.tap(PLUGIN_NAME, (expr) => {
+		parser.hooks.preDeclarator.tap(PLUGIN_NAME, (decl) => {
+			if (
+				decl.init &&
+				decl.init.type === "AwaitExpression" &&
+				decl.init.argument.type === "ImportExpression" &&
+				decl.id.type === "Identifier"
+			) {
+				parser.defineVariable(decl.id.name);
+				tagDynamicImportReferenced(parser, decl.init.argument, decl.id.name);
+			}
+		});
+		parser.hooks.expression.for(dynamicImportTag).tap(PLUGIN_NAME, (expr) => {
+			const settings = /** @type {ImportSettings} */ (parser.currentTagData);
+			const referencedPropertiesInDestructuring =
+				parser.destructuringAssignmentPropertiesFor(expr);
+			if (referencedPropertiesInDestructuring) {
+				/** @type {RawReferencedExports} */
+				const refsInDestructuring = [];
+				traverseDestructuringAssignmentProperties(
+					referencedPropertiesInDestructuring,
+					(stack) => refsInDestructuring.push(stack.map((p) => p.id))
+				);
+				for (const ids of refsInDestructuring) {
+					settings.references.push(ids);
+				}
+			} else {
+				settings.references.push([]);
+			}
+			return true;
+		});
+		parser.hooks.expressionMemberChain
+			.for(dynamicImportTag)
+			.tap(PLUGIN_NAME, (_expression, members, membersOptionals) => {
+				const settings = /** @type {ImportSettings} */ (parser.currentTagData);
+				const ids = getNonOptionalPart(members, membersOptionals);
+				settings.references.push(ids);
+				return true;
+			});
+		parser.hooks.callMemberChain
+			.for(dynamicImportTag)
+			.tap(PLUGIN_NAME, (expression, members, membersOptionals) => {
+				const { arguments: args } = expression;
+				const settings = /** @type {ImportSettings} */ (parser.currentTagData);
+				let ids = getNonOptionalPart(members, membersOptionals);
+				const directImport = members.length === 0;
+				if (
+					!directImport &&
+					(this.options.strictThisContextOnImports || ids.length > 1)
+				) {
+					ids = ids.slice(0, -1);
+				}
+				settings.references.push(ids);
+				if (args) parser.walkExpressions(args);
+				return true;
+			});
+		parser.hooks.importCall.tap(PLUGIN_NAME, (expr, importThen) => {
 			const param = parser.evaluateExpression(expr.source);
 
 			let chunkName = null;
 			let mode = /** @type {ContextMode} */ (this.options.dynamicImportMode);
 			let include = null;
 			let exclude = null;
-			/** @type {string[][] | null} */
+			/** @type {RawReferencedExports | null} */
 			let exports = null;
 			/** @type {RawChunkGroupOptions} */
 			const groupOptions = {};
@@ -245,7 +451,7 @@ class ImportParserPlugin {
 						!(
 							typeof importOptions.webpackExports === "string" ||
 							(Array.isArray(importOptions.webpackExports) &&
-								/** @type {string[]} */ (importOptions.webpackExports).every(
+								importOptions.webpackExports.every(
 									(item) => typeof item === "string"
 								))
 						)
@@ -281,19 +487,42 @@ class ImportParserPlugin {
 
 			const referencedPropertiesInDestructuring =
 				parser.destructuringAssignmentPropertiesFor(expr);
-			if (referencedPropertiesInDestructuring) {
+			const state = getState(parser);
+			const referencedPropertiesInMember = state.get(expr);
+			const fulfilledNamespaceObj =
+				importThen && getFulfilledCallbackNamespaceObj(importThen);
+			if (
+				referencedPropertiesInDestructuring ||
+				referencedPropertiesInMember ||
+				fulfilledNamespaceObj
+			) {
 				if (exports) {
 					parser.state.module.addWarning(
 						new UnsupportedFeatureWarning(
-							"`webpackExports` could not be used with destructuring assignment.",
+							"You don't need `webpackExports` if the usage of dynamic import is statically analyse-able. You can safely remove the `webpackExports` magic comment.",
 							/** @type {DependencyLocation} */ (expr.loc)
 						)
 					);
 				}
 
-				exports = exportsFromEnumerable(
-					[...referencedPropertiesInDestructuring].map(({ id }) => id)
-				);
+				if (referencedPropertiesInDestructuring) {
+					/** @type {RawReferencedExports} */
+					const refsInDestructuring = [];
+					traverseDestructuringAssignmentProperties(
+						referencedPropertiesInDestructuring,
+						(stack) => refsInDestructuring.push(stack.map((p) => p.id))
+					);
+
+					exports = refsInDestructuring;
+				} else if (referencedPropertiesInMember) {
+					exports = referencedPropertiesInMember;
+				} else {
+					/** @type {RawReferencedExports} */
+					const references = [];
+					state.set(expr, references);
+
+					exports = references;
+				}
 			}
 
 			if (param.isString()) {
@@ -335,39 +564,53 @@ class ImportParserPlugin {
 					depBlock.addDependency(dep);
 					parser.state.current.addBlock(depBlock);
 				}
-				return true;
+			} else {
+				if (mode === "weak") {
+					mode = "async-weak";
+				}
+				const dep = ContextDependencyHelpers.create(
+					ImportContextDependency,
+					/** @type {Range} */ (expr.range),
+					param,
+					expr,
+					this.options,
+					{
+						chunkName,
+						groupOptions,
+						include,
+						exclude,
+						mode,
+						namespaceObject:
+							/** @type {BuildMeta} */
+							(parser.state.module.buildMeta).strictHarmonyModule
+								? "strict"
+								: true,
+						typePrefix: "import()",
+						category: "esm",
+						referencedExports: exports,
+						attributes: getImportAttributes(expr)
+					},
+					parser
+				);
+				if (!dep) return;
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				dep.optional = Boolean(parser.scope.inTry);
+				parser.state.current.addDependency(dep);
 			}
-			if (mode === "weak") {
-				mode = "async-weak";
+
+			if (fulfilledNamespaceObj) {
+				walkImportThenFulfilledCallback(
+					parser,
+					expr,
+					/** @type {ArrowFunctionExpression | FunctionExpression} */
+					(importThen.arguments[0]),
+					fulfilledNamespaceObj
+				);
+				parser.walkExpressions(importThen.arguments.slice(1));
+			} else if (importThen) {
+				parser.walkExpressions(importThen.arguments);
 			}
-			const dep = ContextDependencyHelpers.create(
-				ImportContextDependency,
-				/** @type {Range} */ (expr.range),
-				param,
-				expr,
-				this.options,
-				{
-					chunkName,
-					groupOptions,
-					include,
-					exclude,
-					mode,
-					namespaceObject:
-						/** @type {BuildMeta} */
-						(parser.state.module.buildMeta).strictHarmonyModule
-							? "strict"
-							: true,
-					typePrefix: "import()",
-					category: "esm",
-					referencedExports: exports,
-					attributes: getImportAttributes(expr)
-				},
-				parser
-			);
-			if (!dep) return;
-			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-			dep.optional = Boolean(parser.scope.inTry);
-			parser.state.current.addDependency(dep);
+
 			return true;
 		});
 	}

package/lib/dependencies/ImportWeakDependency.js

@@ -10,19 +10,18 @@ const ImportDependency = require("./ImportDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {ImportDependency.RawReferencedExports} RawReferencedExports */
 
 class ImportWeakDependency extends ImportDependency {
 	/**
 	 * @param {string} request the request
 	 * @param {Range} range expression range
-	 * @param {(string[][] | null)=} referencedExports list of referenced exports
+	 * @param {RawReferencedExports | null=} referencedExports list of referenced exports
 	 * @param {ImportAttributes=} attributes import attributes
 	 */
 	constructor(request, range, referencedExports, attributes) {

package/lib/dependencies/JsonExportsDependency.js

@@ -8,7 +8,6 @@
 const makeSerializable = require("../util/makeSerializable");
 const NullDependency = require("./NullDependency");
 
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Dependency").ExportSpec} ExportSpec */
 /** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */

package/lib/dependencies/LoaderDependency.js

@@ -9,9 +9,6 @@ const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 class LoaderDependency extends ModuleDependency {
 	/**

package/lib/dependencies/LoaderImportDependency.js

@@ -9,9 +9,6 @@ const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 class LoaderImportDependency extends ModuleDependency {
 	/**

package/lib/dependencies/LoaderPlugin.js

@@ -10,18 +10,18 @@ const LazySet = require("../util/LazySet");
 const LoaderDependency = require("./LoaderDependency");
 const LoaderImportDependency = require("./LoaderImportDependency");
 
-/** @typedef {import("../../declarations/LoaderContext").LoaderPluginLoaderContext} LoaderPluginLoaderContext */
-/** @typedef {import("../Compilation").DepConstructor} DepConstructor */
+/** @typedef {import("../Compilation").DependencyConstructor} DependencyConstructor */
 /** @typedef {import("../Compilation").ExecuteModuleExports} ExecuteModuleExports */
 /** @typedef {import("../Compilation").ExecuteModuleResult} ExecuteModuleResult */
 /** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Module").FileSystemDependencies} FileSystemDependencies */
 
 /**
  * @callback ImportModuleCallback
  * @param {(Error | null)=} err error object
  * @param {ExecuteModuleExports=} exports exports of the evaluated module
+ * @returns {void}
  */
 
 /**
@@ -65,7 +65,8 @@ class LoaderPlugin {
 							name: request
 						};
 						const factory = compilation.dependencyFactories.get(
-							/** @type {DepConstructor} */ (dep.constructor)
+							/** @type {DependencyConstructor} */
+							(dep.constructor)
 						);
 						if (factory === undefined) {
 							return callback(
@@ -125,9 +126,13 @@ class LoaderPlugin {
 									map = moduleSource.map();
 									source = moduleSource.source();
 								}
+								/** @type {FileSystemDependencies} */
 								const fileDependencies = new LazySet();
+								/** @type {FileSystemDependencies} */
 								const contextDependencies = new LazySet();
+								/** @type {FileSystemDependencies} */
 								const missingDependencies = new LazySet();
+								/** @type {FileSystemDependencies} */
 								const buildDependencies = new LazySet();
 								referencedModule.addCacheDependencies(
 									fileDependencies,
@@ -165,7 +170,8 @@ class LoaderPlugin {
 							name: request
 						};
 						const factory = compilation.dependencyFactories.get(
-							/** @type {DepConstructor} */ (dep.constructor)
+							/** @type {DependencyConstructor} */
+							(dep.constructor)
 						);
 						if (factory === undefined) {
 							return callback(

package/lib/dependencies/ModuleDecoratorDependency.js

@@ -12,11 +12,9 @@ const makeSerializable = require("../util/makeSerializable");
 const NullDependency = require("./NullDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
@@ -57,7 +55,7 @@ class ModuleDecoratorDependency extends NullDependency {
 	 * Returns list of exports referenced by this dependency
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 * @returns {ReferencedExports} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
 		return this.allowExportsAccess

package/lib/dependencies/ModuleDependency.js

@@ -11,6 +11,7 @@ const DependencyTemplate = require("../DependencyTemplate");
 /** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
@@ -22,11 +23,8 @@ class ModuleDependency extends Dependency {
 		super();
 		this.request = request;
 		this.userRequest = request;
+		/** @type {Range | undefined} */
 		this.range = undefined;
-		// TODO move it to subclasses and rename
-		// assertions must be serialized by subclasses that use it
-		/** @type {ImportAttributes | undefined} */
-		this.assertions = undefined;
 		this._context = undefined;
 	}
 
@@ -41,11 +39,7 @@ class ModuleDependency extends Dependency {
 	 * @returns {string | null} an identifier to merge equal requests
 	 */
 	getResourceIdentifier() {
-		let str = `context${this._context || ""}|module${this.request}`;
-		if (this.assertions !== undefined) {
-			str += JSON.stringify(this.assertions);
-		}
-		return str;
+		return `context${this._context || ""}|module${this.request}`;
 	}
 
 	/**

package/lib/dependencies/NullDependency.js

@@ -12,6 +12,8 @@ const DependencyTemplate = require("../DependencyTemplate");
 /** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 
+/** @typedef {string[]} RawRuntimeRequirements */
+
 class NullDependency extends Dependency {
 	get type() {
 		return "null";

package/lib/dependencies/ProvidedDependency.js

@@ -11,14 +11,12 @@ const makeSerializable = require("../util/makeSerializable");
 const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../ExportsInfo").ExportInfoName} ExportInfoName */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
@@ -26,7 +24,7 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 /**
- * @param {string[]|null} path the property path array
+ * @param {string[] | null} path the property path array
  * @returns {string} the converted path
  */
 const pathToString = (path) =>
@@ -38,7 +36,7 @@ class ProvidedDependency extends ModuleDependency {
 	/**
 	 * @param {string} request request
 	 * @param {string} identifier identifier
-	 * @param {string[]} ids ids
+	 * @param {ExportInfoName[]} ids ids
 	 * @param {Range} range range
 	 */
 	constructor(request, identifier, ids, range) {
@@ -61,7 +59,7 @@ class ProvidedDependency extends ModuleDependency {
 	 * Returns list of exports referenced by this dependency
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 * @returns {ReferencedExports} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
 		const ids = this.ids;
@@ -142,7 +140,7 @@ class ProvidedDependencyTemplate extends ModuleDependency.Template {
 					chunkGraph,
 					request: dep.request,
 					runtimeRequirements
-				})}${pathToString(/** @type {string[]} */ (usedName))};\n`,
+				})}${pathToString(/** @type {string[] | null} */ (usedName))};\n`,
 				InitFragment.STAGE_PROVIDES,
 				1,
 				`provided ${dep.identifier}`

package/lib/dependencies/PureExpressionDependency.js

@@ -11,7 +11,6 @@ const { filterRuntime, runtimeToString } = require("../util/runtime");
 const NullDependency = require("./NullDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Dependency").RuntimeSpec} RuntimeSpec */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */

package/lib/dependencies/RequireEnsureDependenciesBlock.js

@@ -9,7 +9,6 @@ const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const makeSerializable = require("../util/makeSerializable");
 
 /** @typedef {import("../AsyncDependenciesBlock").GroupOptions} GroupOptions */
-/** @typedef {import("../ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 
 class RequireEnsureDependenciesBlock extends AsyncDependenciesBlock {

package/lib/dependencies/RequireEnsureDependenciesBlockParserPlugin.js

@@ -11,7 +11,6 @@ const RequireEnsureItemDependency = require("./RequireEnsureItemDependency");
 const getFunctionExpression = require("./getFunctionExpression");
 
 /** @typedef {import("../AsyncDependenciesBlock").GroupOptions} GroupOptions */
-/** @typedef {import("../ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
@@ -86,7 +85,7 @@ module.exports = class RequireEnsureDependenciesBlockParserPlugin {
 					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 					depBlock.addDependency(dep);
 					const old = parser.state.current;
-					parser.state.current = /** @type {TODO} */ (depBlock);
+					parser.state.current = /** @type {EXPECTED_ANY} */ (depBlock);
 					try {
 						let failed = false;
 						parser.inScope([], () => {