webpack 5.112.0 → 5.112.1

package/lib/optimize/SideEffectsFlagPlugin.js

@@ -38,12 +38,7 @@ const { STAGE_DEFAULT } = require("./OptimizationStages");
  */
 /** @import ESMExportImportedSpecifierDependency from "../dependencies/esm/ESMExportImportedSpecifierDependency" */
 /** @import Compiler from "../Compiler" */
-/** @import Module, { BuildMeta, BuildInfo } from "../module/Module" */
-/**
- * @import {
- * 	JavascriptModuleBuildInfo
- * } from "../javascript/JavascriptModule"
- */
+/** @import Module from "../module/Module" */
 /** @import ModuleGraphConnection from "../graph/ModuleGraphConnection" */
 /** @import { ExportInfo, TargetItemWithConnection } from "../graph/ExportsInfo" */
 /** @import JavascriptParser, { Range } from "../javascript/JavascriptParser" */
@@ -407,7 +402,7 @@ class SideEffectsFlagPlugin {
 						const hasSideEffects = SideEffectsFlagPlugin.moduleHasSideEffects(
 							resolved.relativePath,
 							resolved.sideEffects,
-							/** @type {CacheItem} */ (cache)
+							cache
 						);
 						module.factoryMeta.sideEffectFree = !hasSideEffects;
 					}
@@ -545,16 +540,13 @@ class SideEffectsFlagPlugin {
 						);
 						parser.hooks.finish.tap(PLUGIN_NAME, () => {
 							if (sideEffectsStatement === undefined) {
-								/** @type {BuildMeta} */
-								(parser.state.module.buildMeta).sideEffectFree = true;
+								parser.state.module.buildMeta.sideEffectFree = true;
 							} else {
 								const type = sideEffectsStatement.type;
 								const loc = parser.getLocation(sideEffectsStatement);
 								const at = formatLocation(loc);
 
-								const buildInfo = /** @type {BuildInfo} */ (
-									parser.state.module.buildInfo
-								);
+								const buildInfo = parser.state.module.buildInfo;
 								recordOptimizationBailout(
 									buildInfo,
 									`Statement (${type}) with side effects in source code at ${at}`
@@ -701,9 +693,7 @@ class SideEffectsFlagPlugin {
 							if (pureFunctions === undefined || pureFunctions.size === 0) {
 								return;
 							}
-							const buildInfo = /** @type {JavascriptModuleBuildInfo} */ (
-								parser.state.module.buildInfo
-							);
+							const buildInfo = parser.state.module.buildInfo;
 							if (buildInfo.pureFunctions) {
 								for (const fn of pureFunctions) {
 									buildInfo.pureFunctions.add(fn);
@@ -838,9 +828,7 @@ class SideEffectsFlagPlugin {
 																candidate.connection
 															)) &&
 														(Boolean(dep.name) ||
-															hasSingleStarReexport(
-																/** @type {Module} */ (candidate.module)
-															)),
+															hasSingleStarReexport(candidate.module)),
 													({
 														module: newModule,
 														export: exportName,
@@ -904,9 +892,7 @@ class SideEffectsFlagPlugin {
 											moduleGraph.updateModule(dep, target.module);
 											moduleGraph.updateParent(
 												dep,
-												/** @type {ModuleGraphConnection} */ (
-													target.connection
-												),
+												target.connection,
 												/** @type {Module} */ (connection.originModule)
 											);
 											moduleGraph.addExplanation(

package/lib/optimize/SplitChunksPlugin.js

@@ -409,7 +409,7 @@ const mergeSizes = (...sizes) => {
  * @returns {boolean} true, if there are sizes > 0
  */
 const hasNonZeroSizes = (sizes) => {
-	for (const key of /** @type {SourceType[]} */ (Object.keys(sizes))) {
+	for (const key of Object.keys(sizes)) {
 		if (sizes[key] > 0) return true;
 	}
 	return false;
@@ -445,7 +445,7 @@ const combineSizes = (a, b, combine) => {
  * @returns {boolean} true if there are sizes and all existing sizes are at least `minSize`
  */
 const checkMinSize = (sizes, minSize) => {
-	for (const key of /** @type {SourceType[]} */ (Object.keys(minSize))) {
+	for (const key of Object.keys(minSize)) {
 		const size = sizes[key];
 		if (size === undefined || size === 0) continue;
 		if (size < minSize[key]) return false;
@@ -461,9 +461,7 @@ const checkMinSize = (sizes, minSize) => {
  * @returns {boolean} true if there are sizes and all existing sizes are at least `minSizeReduction`
  */
 const checkMinSizeReduction = (sizes, minSizeReduction, chunkCount) => {
-	for (const key of /** @type {SourceType[]} */ (
-		Object.keys(minSizeReduction)
-	)) {
+	for (const key of Object.keys(minSizeReduction)) {
 		const size = sizes[key];
 		if (size === undefined || size === 0) continue;
 		if (size * chunkCount < minSizeReduction[key]) return false;
@@ -480,7 +478,7 @@ const checkMinSizeReduction = (sizes, minSizeReduction, chunkCount) => {
 const getViolatingMinSizes = (sizes, minSize) => {
 	/** @type {SourceTypes | undefined} */
 	let list;
-	for (const key of /** @type {SourceType[]} */ (Object.keys(minSize))) {
+	for (const key of Object.keys(minSize)) {
 		const size = sizes[key];
 		if (size === undefined || size === 0) continue;
 		if (size < minSize[key]) {
@@ -498,7 +496,7 @@ const getViolatingMinSizes = (sizes, minSize) => {
  */
 const totalSize = (sizes) => {
 	let size = 0;
-	for (const key of /** @type {SourceType[]} */ (Object.keys(sizes))) {
+	for (const key of Object.keys(sizes)) {
 		size += sizes[key];
 	}
 	return size;
@@ -514,7 +512,7 @@ const normalizeName = (name) => {
 		return () => name;
 	}
 	if (typeof name === "function") {
-		return /** @type {GetNameFn} */ (name);
+		return name;
 	}
 };
 
@@ -1222,8 +1220,7 @@ class SplitChunksPlugin {
 						const sizeByKey = boundsChunkSetSizes ? new Map() : undefined;
 						const groups = boundsChunkSetSizes
 							? /** @type {IntersectionCacheGroup[]} */ (
-									/** @type {IntersectionSettings} */ (intersectionSettings)
-										.groups
+									intersectionSettings.groups
 								)
 							: undefined;
 						for (const module of compilation.modules) {
@@ -1289,9 +1286,7 @@ class SplitChunksPlugin {
 							: undefined;
 						const groups = boundsExportsChunkSetSizes
 							? /** @type {IntersectionCacheGroup[]} */ (
-									/** @type {IntersectionSettings} */ (
-										exportsIntersectionSettings
-									).groups
+									exportsIntersectionSettings.groups
 								)
 							: undefined;
 						for (const module of compilation.modules) {
@@ -2065,11 +2060,7 @@ class SplitChunksPlugin {
 								if (count < cacheGroup.minChunks) continue;
 								// Select chunks by configuration
 								const { chunks: selectedChunks, key: selectedChunksKey } =
-									getSelectedChunks(
-										chunkCombination,
-										/** @type {ChunkFilterFn} */
-										(cacheGroup.chunksFilter)
-									);
+									getSelectedChunks(chunkCombination, cacheGroup.chunksFilter);
 
 								addModuleToChunksInfoMap(
 									cacheGroup,
@@ -2265,9 +2256,7 @@ class SplitChunksPlugin {
 											limit: byAsyncRequests
 												? "maxAsyncRequests"
 												: "maxInitialRequests",
-											maxRequests:
-												/** @type {number} */
-												(maxRequests),
+											maxRequests,
 											modules: item.modules.size
 										});
 									}
@@ -2496,9 +2485,7 @@ class SplitChunksPlugin {
 						if (Object.keys(maxSize).length === 0) {
 							continue;
 						}
-						for (const key of /** @type {SourceType[]} */ (
-							Object.keys(maxSize)
-						)) {
+						for (const key of Object.keys(maxSize)) {
 							const maxSizeValue = maxSize[key];
 							const minSizeValue = minSize[key];
 							if (

package/lib/optimize/TupleQueue.js

@@ -66,7 +66,7 @@ class TupleQueue {
 			}
 			return;
 		}
-		this._set.delete(.../** @type {[...K, V]} */ (result.value));
+		this._set.delete(...result.value);
 		return result.value;
 	}
 }

package/lib/output/CleanPlugin.js

@@ -374,7 +374,9 @@ class CleanPlugin {
 				{
 					name: "Clean Plugin",
 					baseDataPath: "options"
-				}
+				},
+				(options) =>
+					require("../../schemas/plugins/output/CleanOptions.check")(options)
 			);
 		});
 

package/lib/output/CopyPlugin.js

@@ -44,7 +44,7 @@ const createCompilationHooks = () => ({
 /** @import CacheFacade from "../cache/CacheFacade" */
 /** @import { Snapshot } from "../fs/FileSystemInfo" */
 /** @import { Logger } from "../logging/Logger" */
-/** @import { Dirent, InputFileSystem, IStats } from "../fs/fs" */
+/** @import { Dirent, InputFileSystem, IStats, JsonObject } from "../fs/fs" */
 /** @import { GlobMatchOptions } from "../util/globUtils" */
 /** @import { Source } from "webpack-sources" */
 
@@ -62,7 +62,7 @@ const createCompilationHooks = () => ({
  * @returns {string | Buffer | Promise<string | Buffer>} content of the asset
  */
 
-/** @typedef {Record<string, EXPECTED_ANY>} CopyTransformCacheKeys */
+/** @typedef {JsonObject} CopyTransformCacheKeys */
 
 /**
  * @callback CopyTransformCacheKeysFunction
@@ -186,8 +186,7 @@ const mapLimit = (items, limit, fn) =>
  */
 const stat = (fs, filePath) =>
 	new Promise((resolve, reject) => {
-		/** @type {NonNullable<InputFileSystem["stat"]>} */
-		(fs.stat)(filePath, (err, stats) => {
+		fs.stat(filePath, (err, stats) => {
 			if (err) {
 				if (err.code === "ENOENT" || err.code === "ENOTDIR") {
 					return resolve(undefined);

package/lib/performance/EvalUsagePlugin.js

@@ -56,9 +56,7 @@ class EvalUsagePlugin {
 					parser.hooks.call.for("eval").tap(PLUGIN_NAME, () => {
 						// Kept on the module rather than in a map here, so a module the
 						// filesystem cache restores rather than parses still reports.
-						const buildInfo = /** @type {BuildInfo} */ (
-							parser.state.module.buildInfo
-						);
+						const buildInfo = parser.state.module.buildInfo;
 
 						getBuildDiagnostics(buildInfo).usesEval = true;
 					});

package/lib/performance/HotspotsPlugin.js

@@ -12,6 +12,19 @@ const { compareStrings } = require("../util/comparators");
 const { contextify } = require("../util/identifier");
 
 /** @typedef {import("tapable").FullTap} FullTap */
+
+/**
+ * The callback an `async` tap reports its error or result through.
+ * @template R the hook's result
+ * @typedef {(error?: Error | null, result?: R) => void} TapCallback
+ */
+
+/**
+ * An `async` tap's function, the hook's callback after its arguments.
+ * @template {unknown[]} A the hook's arguments
+ * @template R the hook's result
+ * @typedef {(...args: [...A, TapCallback<R>]) => void} AsyncTapFunction
+ */
 /** @typedef {import("../../declarations/WebpackOptions").PerformanceOptions} PerformanceOptions */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Compilation")} Compilation */
@@ -146,15 +159,17 @@ class HotspotsPlugin {
 				return {
 					...tapInfo,
 					/**
-					 * @param {EXPECTED_ANY[]} args the tap's arguments, callback last
-					 * @returns {EXPECTED_ANY} whatever the tap returned
+					 * @template {unknown[]} A the hook's arguments
+					 * @template R the hook's result
+					 * @param {[...A, TapCallback<R>]} args the tap's arguments, callback last
+					 * @returns {void}
 					 */
 					fn: (...args) => {
-						const callback = args.pop();
+						const callback = /** @type {TapCallback<R>} */ (args.pop());
 
 						/**
-						 * @param {EXPECTED_ANY[]} result what the tap reported
-						 * @returns {EXPECTED_ANY} whatever the callback returned
+						 * @param {Parameters<TapCallback<R>>} result what the tap reported
+						 * @returns {void}
 						 */
 						const finish = (...result) =>
 							measure(pluginTime, name, hookName, () => callback(...result));
@@ -162,7 +177,11 @@ class HotspotsPlugin {
 						// The completion callback is the plugin's own code as well, so it
 						// is charged to the plugin rather than to whoever resumed it.
 						return measure(pluginTime, name, hookName, () =>
-							fn(...args, finish)
+							/** @type {AsyncTapFunction<A, R>} */ (fn)(
+								// `pop()` took the callback off, which the tuple type cannot follow.
+								.../** @type {A} */ (/** @type {unknown[]} */ (args)),
+								finish
+							)
 						);
 					}
 				};
@@ -171,10 +190,15 @@ class HotspotsPlugin {
 			return {
 				...tapInfo,
 				/**
-				 * @param {EXPECTED_ANY[]} args the tap's arguments
-				 * @returns {EXPECTED_ANY} whatever the tap returned
+				 * @template {unknown[]} A the hook's arguments
+				 * @template R what the tap returns: the hook's result, or a promise of it
+				 * @param {A} args the tap's arguments
+				 * @returns {R} whatever the tap returned
 				 */
-				fn: (...args) => measure(pluginTime, name, hookName, () => fn(...args))
+				fn: (...args) =>
+					measure(pluginTime, name, hookName, () =>
+						/** @type {(...args: A) => R} */ (fn)(...args)
+					)
 			};
 		};
 

package/lib/performance/PureAnnotationsPlugin.js

@@ -22,6 +22,14 @@ const { CompilerHintNotationRegExp } = require("../util/magicComment");
 /** @import JavascriptParser from "../javascript/JavascriptParser" */
 /** @import { PureAnnotationDetails } from "../errors/PureAnnotationsWarning" */
 
+/** @typedef {{ [Key in string]?: AstValue }} AstFields */
+/** @typedef {AstValue[]} AstArray */
+/**
+ * A value found while walking an estree AST structurally: a node, a field of
+ * one, or a literal's value.
+ * @typedef {string | number | boolean | bigint | RegExp | null | undefined | AstArray | AstFields} AstValue
+ */
+
 const PLUGIN_NAME = "PureAnnotationsPlugin";
 
 // Enough to name the offenders without listing every module.
@@ -46,8 +54,10 @@ const collectStarts = (ast) => {
 	const starts = [];
 	/** @type {Set<number>} */
 	const annotated = new Set();
-	/** @type {unknown[]} */
-	const queue = [ast];
+	/** @type {AstValue[]} */
+	const queue = [
+		/** @type {AstValue} */ (/** @type {Program | AstValue} */ (ast))
+	];
 
 	while (queue.length > 0) {
 		const node = queue.pop();
@@ -55,18 +65,16 @@ const collectStarts = (ast) => {
 		if (!node || typeof node !== "object") continue;
 
 		if (Array.isArray(node)) {
-			for (const item of /** @type {unknown[]} */ (node)) queue.push(item);
+			for (const item of node) queue.push(item);
 			continue;
 		}
 
 		// Walked structurally rather than per node type, so a node the estree
 		// types do not name is still reached.
-		const fields = /** @type {Record<string, unknown>} */ (node);
+		const fields = /** @type {AstFields} */ (node);
 		const { type, range } = fields;
 
-		const start = Array.isArray(range)
-			? /** @type {unknown[]} */ (range)[0]
-			: undefined;
+		const start = Array.isArray(range) ? range[0] : undefined;
 
 		if (typeof type === "string" && typeof start === "number") {
 			starts.push(start);
@@ -151,9 +159,7 @@ class PureAnnotationsPlugin {
 
 						// Kept on the module rather than in a map here, so a module the
 						// filesystem cache restores rather than parses still reports.
-						const buildInfo = /** @type {BuildInfo} */ (
-							parser.state.module.buildInfo
-						);
+						const buildInfo = parser.state.module.buildInfo;
 
 						getBuildDiagnostics(buildInfo).ineffectivePureAnnotations = wasted;
 					});

package/lib/performance/TopLevelThisPlugin.js

@@ -14,13 +14,21 @@ const {
 const { getBuildDiagnostics } = require("../util/buildDiagnostics");
 const { compareStrings } = require("../util/comparators");
 
-/** @import { Expression, PrivateIdentifier, Program } from "estree" */
+/** @import { Program } from "estree" */
 /** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
 /** @import Compiler from "../Compiler" */
 /** @import Module, { BuildInfo } from "../module/Module" */
 /** @import JavascriptParser from "../javascript/JavascriptParser" */
 /** @import { TopLevelThisDetails } from "../errors/TopLevelThisWarning" */
 
+/** @typedef {{ [Key in string]?: AstValue }} AstFields */
+/** @typedef {AstValue[]} AstArray */
+/**
+ * A value found while walking an estree AST structurally: a node, a field of
+ * one, or a literal's value.
+ * @typedef {string | number | boolean | bigint | RegExp | null | undefined | AstArray | AstFields} AstValue
+ */
+
 const PLUGIN_NAME = "TopLevelThisPlugin";
 
 // Enough to name the offenders without listing every module.
@@ -41,8 +49,10 @@ const CLASS_TYPES = new Set(["ClassDeclaration", "ClassExpression"]);
  */
 const countTopLevelThis = (ast) => {
 	let count = 0;
-	/** @type {unknown[]} */
-	const queue = [ast];
+	/** @type {AstValue[]} */
+	const queue = [
+		/** @type {AstValue} */ (/** @type {Program | AstValue} */ (ast))
+	];
 
 	while (queue.length > 0) {
 		const node = queue.pop();
@@ -50,13 +60,13 @@ const countTopLevelThis = (ast) => {
 		if (!node || typeof node !== "object") continue;
 
 		if (Array.isArray(node)) {
-			for (const item of /** @type {unknown[]} */ (node)) queue.push(item);
+			for (const item of node) queue.push(item);
 			continue;
 		}
 
 		// Walked structurally rather than per node type, so a node the estree
 		// types do not name is still reached.
-		const fields = /** @type {Record<string, unknown>} */ (node);
+		const fields = /** @type {AstFields} */ (node);
 		const { type } = fields;
 
 		if (typeof type !== "string") continue;
@@ -71,7 +81,7 @@ const countTopLevelThis = (ast) => {
 			queue.push(fields.superClass);
 
 			const body =
-				/** @type {{ body: { computed?: boolean, key?: Expression | PrivateIdentifier }[] } | null | undefined} */
+				/** @type {{ body: { computed?: boolean, key?: AstValue }[] } | null | undefined} */
 				(fields.body);
 
 			for (const element of (body && body.body) || []) {
@@ -130,9 +140,7 @@ class TopLevelThisPlugin {
 
 						// Kept on the module rather than in a map here, so a module the
 						// filesystem cache restores rather than parses still reports.
-						const buildInfo =
-							/** @type {BuildInfo} */
-							(parser.state.module.buildInfo);
+						const buildInfo = parser.state.module.buildInfo;
 
 						getBuildDiagnostics(buildInfo).topLevelThis = count;
 					});

package/lib/prefetch/ResourceHintPlugin.js

@@ -558,7 +558,7 @@ const collectStartupAssetHintLines = (
 				if (urlDep.mediaAttribute) existing.media = urlDep.mediaAttribute;
 			} else {
 				perAsset.set(key, {
-					assetModule: /** @type {Module} */ (assetModule),
+					assetModule,
 					originModule: module,
 					request: dep.request,
 					preload: Boolean(dep.preload),

package/lib/provide/ProvidedDependency.js

@@ -5,6 +5,8 @@
 
 "use strict";
 
+const AwaitDependenciesInitFragment = require("../async-modules/AwaitDependenciesInitFragment");
+const isGeneratorLowered = require("../async-modules/isGeneratorLowered");
 const ModuleDependency = require("../dependencies/core/ModuleDependency");
 const Dependency = require("../graph/Dependency");
 const { isInlinedUsedName } = require("../optimize/InlineExports");
@@ -16,6 +18,7 @@ const { propertyAccess } = require("../util/property");
 /** @import { ReplaceSource } from "webpack-sources" */
 /**
  * @import {
+ * 	DependencyKinds,
  * 	ReferencedExports,
  * 	UpdateHashContext,
  * 	ExportInfoName
@@ -103,6 +106,9 @@ class ProvidedDependency extends ModuleDependency {
 	}
 }
 
+/** @type {Set<keyof DependencyKinds>} */
+ProvidedDependency.KINDS = new Set([...ModuleDependency.KINDS, "provided"]);
+
 makeSerializable(ProvidedDependency, [
 	"webpack/lib/provide/ProvidedDependency",
 	// TODO in the next major release: remove, they restore pre-move cache packs
@@ -121,6 +127,7 @@ class ProvidedDependencyTemplate extends ModuleDependency.Template {
 		dependency,
 		source,
 		{
+			module,
 			runtime,
 			runtimeTemplate,
 			moduleGraph,
@@ -143,24 +150,49 @@ class ProvidedDependencyTemplate extends ModuleDependency.Template {
 			runtimeRequirements
 		});
 
+		// An async module only exposes its exports once awaited, and only an ESM
+		// consumer is async itself (see `InferAsyncModulesPlugin`).
+		const isAsync =
+			moduleGraph.isAsync(connection.module) && moduleGraph.isAsync(module);
+		const target = isAsync ? dep.identifier : moduleRaw;
 		const provided = !usedName
-			? moduleRaw
+			? target
 			: isInlinedUsedName(usedName)
-				? `(${moduleRaw}, ${usedName.render(
+				? `(${target}, ${usedName.render(
 						Template.toNormalComment(
 							`inlined export ${propertyAccess(dep.ids)}`
 						)
 					)})`
-				: `${moduleRaw}${propertyAccess(/** @type {string[]} */ (usedName), 0)}`;
+				: `${target}${propertyAccess(/** @type {string[]} */ (usedName), 0)}`;
 
 		initFragments.push(
 			new InitFragment(
-				`/* provided dependency */ var ${dep.identifier} = ${provided};\n`,
+				`/* provided dependency */ var ${dep.identifier} = ${
+					isAsync ? moduleRaw : provided
+				};\n`,
 				InitFragment.STAGE_PROVIDES,
 				1,
 				`provided ${dep.identifier}`
 			)
 		);
+		if (isAsync) {
+			initFragments.push(
+				new AwaitDependenciesInitFragment(
+					new Map([[dep.identifier, dep.identifier]]),
+					isGeneratorLowered(module, moduleGraph, runtimeTemplate)
+				)
+			);
+			if (provided !== target) {
+				initFragments.push(
+					new InitFragment(
+						`${dep.identifier} = ${provided};\n`,
+						InitFragment.STAGE_ASYNC_ESM_IMPORTS,
+						1,
+						`provided async ${dep.identifier}`
+					)
+				);
+			}
+		}
 		source.replace(dep.range[0], dep.range[1] - 1, dep.identifier);
 	}
 }

package/lib/rules/BasicEffectRulePlugin.js

@@ -15,7 +15,7 @@
  * @typedef {import("./RuleSetCompiler").KeysOfTypes<T, V>} KeysOfTypes
  */
 
-/** @typedef {KeysOfTypes<RuleSetRule, string | boolean | { [k: string]: EXPECTED_ANY }>} BasicEffectRuleKeys */
+/** @typedef {KeysOfTypes<RuleSetRule, string | boolean | EXPECTED_OBJECT>} BasicEffectRuleKeys */
 
 const PLUGIN_NAME = "BasicEffectRulePlugin";
 

package/lib/rules/RuleSetCompiler.js

@@ -13,6 +13,7 @@ const {
 } = require("../util/identifier");
 
 /** @import { ResolveRequest } from "enhanced-resolve" */
+/** @import { JsonValue } from "../fs/fs" */
 /**
  * @import {
  * 	Falsy,
@@ -84,7 +85,7 @@ const {
  * Defines the effect use type used by this module.
  * @typedef {object} EffectUse
  * @property {EffectUseType} type
- * @property {{ loader: string, options?: string | null | Record<string, EXPECTED_ANY>, ident?: string }} value
+ * @property {{ loader: string, options?: RuleSetLoaderOptions | null, ident?: string }} value
  */
 
 /**
@@ -164,7 +165,7 @@ class RuleSetCompiler {
 			for (const condition of rule.conditions) {
 				const p = condition.property;
 				if (Array.isArray(p)) {
-					/** @type {EXPECTED_ANY} */
+					/** @type {EffectData | EffectData[keyof EffectData] | JsonValue} */
 					let current = data;
 					for (const subProperty of p) {
 						if (
@@ -172,14 +173,22 @@ class RuleSetCompiler {
 							typeof current === "object" &&
 							Object.prototype.hasOwnProperty.call(current, subProperty)
 						) {
-							current = current[/** @type {keyof EffectData} */ (subProperty)];
+							current = /** @type {Record<string, JsonValue>} */ (current)[
+								subProperty
+							];
 						} else {
 							current = undefined;
 							break;
 						}
 					}
 					if (current !== undefined) {
-						if (!condition.fn(current)) return false;
+						if (
+							!condition.fn(
+								/** @type {EffectData[keyof EffectData]} */ (current)
+							)
+						) {
+							return false;
+						}
 						continue;
 					}
 				} else if (p in data) {
@@ -526,8 +535,9 @@ class RuleSetCompiler {
 
 	/**
 	 * Returns an error object.
+	 * @template T
 	 * @param {string} path current path
-	 * @param {EXPECTED_ANY} value value at the error location
+	 * @param {T} value value at the error location
 	 * @param {string} message message explaining the problem
 	 * @returns {Error} an error object
 	 */

package/lib/rules/UseEffectRulePlugin.js

@@ -173,9 +173,7 @@ class UseEffectRulePlugin {
 								);
 							});
 						}
-						return [
-							useToEffect(path, path, /** @type {RuleSetUseItem} */ (items))
-						];
+						return [useToEffect(path, path, items)];
 					};
 
 					if (typeof use === "function") {

package/lib/runtime/AsyncModuleRuntimeModule.js

@@ -9,6 +9,7 @@ const HelperRuntimeModule = require("./HelperRuntimeModule");
 const RuntimeGlobals = require("./RuntimeGlobals");
 
 /** @import Compilation from "../Compilation" */
+/** @import Chunk from "../graph/Chunk" */
 
 class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 	/**
@@ -32,6 +33,11 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 		const { runtimeTemplate } = compilation;
 		const fn = RuntimeGlobals.asyncModule;
 		const defer = this._deferInterop;
+		const exposeExports =
+			defer ||
+			compilation.chunkGraph
+				.getTreeRuntimeRequirements(/** @type {Chunk} */ (this.chunk))
+				.has(RuntimeGlobals.asyncModuleExportSymbol);
 		const strictErrors = this._strictModuleErrorHandling;
 		const moduleCache = this.receivesHotUpdates()
 			? RuntimeGlobals.moduleCache
@@ -54,7 +60,7 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 				: [`${cst} hasSymbol = typeof Symbol === "function";`]),
 			`${cst} webpackQueues = ${renderSymbol("webpack queues", "__webpack_queues__")};`,
 			`${cst} webpackExports = ${
-				defer ? `${RuntimeGlobals.asyncModuleExportSymbol}= ` : ""
+				exposeExports ? `${RuntimeGlobals.asyncModuleExportSymbol}= ` : ""
 			}${renderSymbol("webpack exports", RuntimeGlobals.exports)};`,
 			`${cst} webpackError = ${renderSymbol("webpack error", "__webpack_error__")};`,
 			...(strictErrors ? [`${cst} cycleGroups = {};`] : []),