webpack 5.99.5 → 5.99.6

package/README.md

@@ -676,5 +676,5 @@ Before we started using OpenCollective, donations were made anonymously. Now tha
 [builds2-url]: https://dev.azure.com/webpack/webpack/_build/latest?definitionId=3&branchName=main
 [dependency-review-url]: https://github.com/webpack/webpack/actions/workflows/dependency-review.yml
 [dependency-review]: https://github.com/webpack/webpack/actions/workflows/dependency-review.yml/badge.svg
-[cover]: https://codecov.io/gh/webpack/webpack/branch/master/graph/badge.svg?token=mDP3mQJNnn
+[cover]: https://codecov.io/gh/webpack/webpack/graph/badge.svg?token=mDP3mQJNnn
 [cover-url]: https://codecov.io/gh/webpack/webpack

package/lib/APIPlugin.js

@@ -134,12 +134,12 @@ const PLUGIN_NAME = "APIPlugin";
 
 /**
  * @typedef {object} APIPluginOptions
- * @property {boolean} [module] the output filename
+ * @property {boolean=} module the output filename
  */
 
 class APIPlugin {
 	/**
-	 * @param {APIPluginOptions} [options] options
+	 * @param {APIPluginOptions=} options options
 	 */
 	constructor(options = {}) {
 		this.options = options;

package/lib/Cache.js

@@ -26,7 +26,7 @@ const {
  * @returns {void}
  */
 
-/** @typedef {TODO} Data */
+/** @typedef {EXPECTED_ANY} Data */
 
 /**
  * @callback GotHandler

package/lib/Chunk.js

@@ -34,7 +34,9 @@ const { mergeRuntime } = require("./util/runtime");
 /** @typedef {import("./util/Hash")} Hash */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
+/** @typedef {string | null} ChunkName */
 /** @typedef {number | string} ChunkId */
+/** @typedef {SortableSet<string>} IdNameHints */
 
 const ChunkFilesSet = createArrayToSetDeprecationSet("chunk.files");
 
@@ -46,9 +48,9 @@ const ChunkFilesSet = createArrayToSetDeprecationSet("chunk.files");
 /**
  * @deprecated
  * @typedef {object} ChunkMaps
- * @property {Record<string|number, string>} hash
- * @property {Record<string|number, Record<string, string>>} contentHash
- * @property {Record<string|number, string>} name
+ * @property {Record<string | number, string>} hash
+ * @property {Record<string | number, Record<string, string>>} contentHash
+ * @property {Record<string | number, string>} name
  */
 
 /**
@@ -66,7 +68,7 @@ let debugId = 1000;
  */
 class Chunk {
 	/**
-	 * @param {(string | null)=} name of chunk being created, is optional (for subclasses)
+	 * @param {ChunkName=} name of chunk being created, is optional (for subclasses)
 	 * @param {boolean} backCompat enable backward-compatibility
 	 */
 	constructor(name, backCompat = true) {
@@ -76,9 +78,9 @@ class Chunk {
 		this.ids = null;
 		/** @type {number} */
 		this.debugId = debugId++;
-		/** @type {string | null | undefined} */
+		/** @type {ChunkName | undefined} */
 		this.name = name;
-		/** @type {SortableSet<string>} */
+		/** @type {IdNameHints} */
 		this.idNameHints = new SortableSet();
 		/** @type {boolean} */
 		this.preventIntegration = false;
@@ -696,7 +698,7 @@ class Chunk {
 	/**
 	 * @param {ChunkGraph} chunkGraph the chunk graph
 	 * @param {ChunkFilterPredicate=} filterFn function used to filter chunks
-	 * @returns {Record<string, (string | number)[]>} a record object of names to lists of child ids(?)
+	 * @returns {Record<string, ChunkId[]>} a record object of names to lists of child ids(?)
 	 */
 	getChildIdsByOrders(chunkGraph, filterFn) {
 		/** @type {Map<string, {order: number, group: ChunkGroup}[]>} */
@@ -717,7 +719,8 @@ class Chunk {
 									/** @type {number} */
 									(
 										childGroup.options[
-											/** @type {keyof ChunkGroupOptions} */ (key)
+											/** @type {keyof ChunkGroupOptions} */
+											(key)
 										]
 									),
 								group: childGroup
@@ -735,7 +738,7 @@ class Chunk {
 				if (cmp !== 0) return cmp;
 				return a.group.compareTo(chunkGraph, b.group);
 			});
-			/** @type {Set<string | number>} */
+			/** @type {Set<ChunkId>} */
 			const chunkIdSet = new Set();
 			for (const item of list) {
 				for (const chunk of item.group.chunks) {

package/lib/Compilation.js

@@ -94,10 +94,13 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
 /** @typedef {import("./Cache")} Cache */
 /** @typedef {import("./CacheFacade")} CacheFacade */
+/** @typedef {import("./Chunk").ChunkName} ChunkName */
 /** @typedef {import("./Chunk").ChunkId} ChunkId */
 /** @typedef {import("./ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Compiler").CompilationParams} CompilationParams */
+/** @typedef {import("./Compiler").MemCache} MemCache */
+/** @typedef {import("./Compiler").WeakReferences} WeakReferences */
 /** @typedef {import("./Compiler").ModuleMemCachesItem} ModuleMemCachesItem */
 /** @typedef {import("./DependenciesBlock")} DependenciesBlock */
 /** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
@@ -106,6 +109,7 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
 /** @typedef {import("./Module").BuildInfo} BuildInfo */
 /** @typedef {import("./Module").ValueCacheVersions} ValueCacheVersions */
+/** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */
 /** @typedef {import("./NormalModule").NormalModuleCompilationHooks} NormalModuleCompilationHooks */
 /** @typedef {import("./Module").FactoryMeta} FactoryMeta */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
@@ -132,7 +136,6 @@ const { isSourceEqual } = require("./util/source");
  * @typedef {import("./util/deprecation").FakeHook<T>} FakeHook<T>
  */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
-/** @typedef {WeakMap<Dependency, Module>} References */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /**
  * @callback Callback
@@ -168,12 +171,6 @@ const { isSourceEqual } = require("./util/source");
  * @returns {void}
  */
 
-/**
- * @callback DepBlockVarDependenciesCallback
- * @param {Dependency} dependency
- * @returns {any}
- */
-
 /** @typedef {new (...args: EXPECTED_ANY[]) => Dependency} DepConstructor */
 
 /** @typedef {Record<string, Source>} CompilationAssets */
@@ -235,17 +232,17 @@ const { isSourceEqual } = require("./util/source");
 
 /**
  * @typedef {object} ExecuteModuleObject
- * @property {string} [id] module id
+ * @property {string=} id module id
  * @property {ExecuteModuleExports} exports exports
  * @property {boolean} loaded is loaded
- * @property {Error} [error] error
+ * @property {Error=} error error
  */
 
 /**
  * @typedef {object} ExecuteModuleArgument
  * @property {Module} module
  * @property {ExecuteModuleObject=} moduleObject
- * @property {any} preparedInfo
+ * @property {TODO} preparedInfo
  * @property {CodeGenerationResult} codeGenerationResult
  */
 
@@ -253,7 +250,7 @@ const { isSourceEqual } = require("./util/source");
 
 /**
  * @typedef {object} ExecuteOptions
- * @property {string} [id] module id
+ * @property {string=} id module id
  * @property {ExecuteModuleObject} module module
  * @property {WebpackRequire} require require function
  */
@@ -333,6 +330,8 @@ const { isSourceEqual } = require("./util/source");
  * @property {string=} url
  */
 
+/** @typedef {"module" | "chunk" | "root-of-chunk" | "nested"} ExcludeModulesType */
+
 /**
  * @typedef {object} KnownNormalizedStatsOptions
  * @property {string} context
@@ -349,7 +348,7 @@ const { isSourceEqual } = require("./util/source");
  * @property {boolean} groupAssetsByExtension
  * @property {number} assetsSpace
  * @property {((value: string, asset: StatsAsset) => boolean)[]} excludeAssets
- * @property {((name: string, module: StatsModule, type: "module" | "chunk" | "root-of-chunk" | "nested") => boolean)[]} excludeModules
+ * @property {((name: string, module: StatsModule, type: ExcludeModulesType) => boolean)[]} excludeModules
  * @property {((warning: StatsError, textValue: string) => boolean)[]} warningsFilter
  * @property {boolean} cachedModules
  * @property {boolean} orphanModules
@@ -459,10 +458,10 @@ const compareErrors = concatComparators(byModule, byLocation, byMessage);
 
 /**
  * @typedef {object} KnownUnsafeCacheData
- * @property {FactoryMeta} [factoryMeta] factory meta
- * @property {ResolveOptions} [resolveOptions] resolve options
- * @property {ParserOptions} [parserOptions]
- * @property {GeneratorOptions} [generatorOptions]
+ * @property {FactoryMeta=} factoryMeta factory meta
+ * @property {ResolveOptions=} resolveOptions resolve options
+ * @property {ParserOptions=} parserOptions
+ * @property {GeneratorOptions=} generatorOptions
  */
 
 /** @typedef {KnownUnsafeCacheData & Record<string, EXPECTED_ANY>} UnsafeCacheData */
@@ -477,7 +476,8 @@ const unsafeCacheDependencies = new WeakMap();
 /** @type {WeakMap<ModuleWithRestoreFromUnsafeCache, UnsafeCacheData>} */
 const unsafeCacheData = new WeakMap();
 
-/** @typedef {Map<Module, WeakTupleMap<any, any>>} ModuleMemCaches */
+/** @typedef {{ id: ModuleId, modules?: Map<Module, string | number | undefined>, blocks?: (string | number | null)[] }} References */
+/** @typedef {Map<Module, WeakTupleMap<EXPECTED_ANY[], EXPECTED_ANY>>} ModuleMemCaches */
 
 class Compilation {
 	/**
@@ -690,7 +690,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						processAssetsHook.tapAsync(
 							getOptions(options),
 							(assets, callback) =>
-								/** @type {any} */ (fn)(...getArgs(), callback)
+								/** @type {TODO} */ (fn)(...getArgs(), callback)
 						);
 					},
 					/** @type {AsyncSeriesHook<T>["tapPromise"]} */
@@ -1049,6 +1049,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		};
 		defineRemovedModuleTemplates(this.moduleTemplates);
 
+		// We need to think how implement types here
 		/** @type {ModuleMemCaches | undefined} */
 		this.moduleMemCaches = undefined;
 		/** @type {ModuleMemCaches | undefined} */
@@ -1099,7 +1100,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		 */
 		this.creatingModuleDuringBuild = new WeakMap();
 
-		/** @type {Map<string, EntryData>} */
+		/** @type {Map<Exclude<ChunkName, null>, EntryData>} */
 		this.entries = new Map();
 		/** @type {EntryData} */
 		this.globalEntry = {
@@ -2501,10 +2502,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 		/**
 		 * @param {Module} module module
-		 * @returns {References | undefined} references
+		 * @returns {WeakReferences | undefined} references
 		 */
 		const computeReferences = module => {
-			/** @type {References | undefined} */
+			/** @type {WeakReferences | undefined} */
 			let references;
 			for (const connection of moduleGraph.getOutgoingConnections(module)) {
 				const d = connection.dependency;
@@ -2518,7 +2519,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 		/**
 		 * @param {Module} module the module
-		 * @param {References | undefined} references references
+		 * @param {WeakReferences | undefined} references references
 		 * @returns {boolean} true, when the references differ
 		 */
 		const compareReferences = (module, references) => {
@@ -2540,6 +2541,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				if (buildInfo) {
 					if (cachedMemCache.buildInfo !== buildInfo) {
 						// use a new one
+						/** @type {MemCache} */
 						const memCache = new WeakTupleMap();
 						moduleMemCaches.set(module, memCache);
 						affectedModules.add(module);
@@ -2549,6 +2551,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						statChanged++;
 					} else if (!compareReferences(module, cachedMemCache.references)) {
 						// use a new one
+						/** @type {MemCache} */
 						const memCache = new WeakTupleMap();
 						moduleMemCaches.set(module, memCache);
 						affectedModules.add(module);
@@ -2639,6 +2642,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				} else {
 					affectedModules.add(referencingModule);
 				}
+				/** @type {MemCache} */
 				const memCache = new WeakTupleMap();
 				const cache =
 					/** @type {ModuleMemCachesItem} */
@@ -2671,7 +2675,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		let statNew = 0;
 		/**
 		 * @param {Module} module module
-		 * @returns {{ id: ModuleId, modules?: Map<Module, string | number | undefined>, blocks?: (string | number | null)[] }} references
+		 * @returns {References} references
 		 */
 		const computeReferences = module => {
 			const id = /** @type {ModuleId} */ (chunkGraph.getModuleId(module));
@@ -2741,9 +2745,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		};
 
 		for (const [module, memCache] of moduleMemCaches) {
-			/** @type {{ references: { id: string | number, modules?: Map<Module, string | number | undefined>, blocks?: (string | number | null)[]}, memCache: WeakTupleMap<any[], any> }} */
+			/** @type {{ references: References, memCache: MemCache } | undefined} */
 			const cache = memCache.get(key);
 			if (cache === undefined) {
+				/** @type {WeakTupleMap<Module[], RuntimeRequirements | null> | undefined} */
 				const memCache2 = new WeakTupleMap();
 				memCache.set(key, {
 					references: computeReferences(module),
@@ -2752,6 +2757,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				moduleMemCaches2.set(module, memCache2);
 				statNew++;
 			} else if (!compareReferences(module, cache.references)) {
+				/** @type {WeakTupleMap<Module[], RuntimeRequirements | null> | undefined} */
 				const memCache = new WeakTupleMap();
 				cache.references = computeReferences(module);
 				cache.memCache = memCache;
@@ -3732,7 +3738,8 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 								chunkGraph.addModuleRuntimeRequirements(
 									module,
 									runtime,
-									cached,
+									/** @type {RuntimeRequirements} */
+									(cached),
 									false
 								);
 							}
@@ -3980,7 +3987,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	/**
 	 * This method first looks to see if a name is provided for a new chunk,
 	 * and first looks to see if any named chunks already exist and reuse that chunk instead.
-	 * @param {(string | null)=} name optional chunk name to be provided
+	 * @param {ChunkName=} name optional chunk name to be provided
 	 * @returns {Chunk} create a chunk (invoked during seal event)
 	 */
 	addChunk(name) {
@@ -4237,7 +4244,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 			const memCache = moduleMemCaches2 && moduleMemCaches2.get(module);
 			for (const runtime of chunkGraph.getModuleRuntimes(module)) {
 				if (memCache) {
-					const digest = memCache.get(`moduleHash-${getRuntimeKey(runtime)}`);
+					const digest =
+						/** @type {string} */
+						(memCache.get(`moduleHash-${getRuntimeKey(runtime)}`));
 					if (digest !== undefined) {
 						chunkGraph.setModuleHashes(
 							module,

package/lib/Compiler.js

@@ -40,7 +40,7 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
 /** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
 /** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./Compilation").References} References */
+/** @typedef {import("./ChunkGraph").ModuleId} ModuleId */
 /** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./Module").BuildInfo} BuildInfo */
@@ -90,10 +90,11 @@ const { isSourceEqual } = require("./util/source");
  */
 
 /** @typedef {{ sizeOnlySource: SizeOnlySource | undefined, writtenTo: Map<string, number> }} CacheEntry */
-
 /** @typedef {{ path: string, source: Source, size: number | undefined, waiting: ({ cacheEntry: CacheEntry, file: string }[] | undefined) }} SimilarEntry */
 
-/** @typedef {{ buildInfo: BuildInfo, references: References | undefined, memCache: import("./util/WeakTupleMap")<Module[], string> }} ModuleMemCachesItem */
+/** @typedef {WeakMap<Dependency, Module>} WeakReferences */
+/** @typedef {import("./util/WeakTupleMap")<EXPECTED_ANY[], EXPECTED_ANY>} MemCache */
+/** @typedef {{ buildInfo: BuildInfo, references: WeakReferences | undefined, memCache: MemCache }} ModuleMemCachesItem */
 
 /**
  * @param {string[]} array an array

package/lib/ContextModule.js

@@ -29,6 +29,7 @@ const {
 const makeSerializable = require("./util/makeSerializable");
 
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
 /** @typedef {import("./Chunk")} Chunk */
 /** @typedef {import("./Chunk").ChunkId} ChunkId */
@@ -83,7 +84,7 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {false|string|string[]} resource
  * @property {string=} resourceQuery
  * @property {string=} resourceFragment
- * @property {TODO} resolveOptions
+ * @property {ResolveOptions=} resolveOptions
  */
 
 /** @typedef {ContextOptions & ContextModuleOptionsExtras} ContextModuleOptions */

package/lib/HotModuleReplacementPlugin.js

@@ -376,11 +376,11 @@ class HotModuleReplacementPlugin {
 							);
 					}
 				});
-				/** @type {TupleSet<[Module, Chunk]>} */
+				/** @type {TupleSet<Module, Chunk>} */
 				const updatedModules = new TupleSet();
-				/** @type {TupleSet<[Module, Chunk]>} */
+				/** @type {TupleSet<Module, Chunk>} */
 				const fullHashModules = new TupleSet();
-				/** @type {TupleSet<[Module, RuntimeSpec]>} */
+				/** @type {TupleSet<Module, RuntimeSpec>} */
 				const nonCodeGeneratedModules = new TupleSet();
 				compilation.hooks.fullHash.tap(PLUGIN_NAME, hash => {
 					const chunkGraph = compilation.chunkGraph;

package/lib/Module.js

@@ -42,12 +42,20 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("./util/Hash")} Hash */
-/** @template T @typedef {import("./util/LazySet")<T>} LazySet<T> */
-/** @template T @typedef {import("./util/SortableSet")<T>} SortableSet<T> */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("./util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
+/**
+ * @template T
+ * @typedef {import("./util/LazySet")<T>} LazySet<T>
+ */
+
+/**
+ * @template T
+ * @typedef {import("./util/SortableSet")<T>} SortableSet<T>
+ */
+
 /**
  * @typedef {object} SourceContext
  * @property {DependencyTemplates} dependencyTemplates the dependency templates

package/lib/ModuleFilenameHelpers.js

@@ -262,7 +262,7 @@ ModuleFilenameHelpers.createFilename = (
  * @template T
  * @param {T[]} array the array with duplicates to be replaced
  * @param {(duplicateItem: T, duplicateItemIndex: number, numberOfTimesReplaced: number) => T} fn callback function to generate new values for the duplicate items
- * @param {(firstElement:T, nextElement:T) => -1 | 0 | 1} [comparator] optional comparator function to sort the duplicate items
+ * @param {(firstElement:T, nextElement:T) => -1 | 0 | 1=} comparator optional comparator function to sort the duplicate items
  * @returns {T[]} the array with duplicates replaced
  * @example
  * ```js

package/lib/ModuleGraph.js

@@ -143,7 +143,7 @@ class ModuleGraph {
 		 */
 		this._metaMap = new WeakMap();
 		/**
-		 * @type {WeakTupleMap<any[], any> | undefined}
+		 * @type {WeakTupleMap<EXPECTED_ANY[], EXPECTED_ANY> | undefined}
 		 * @private
 		 */
 		this._cache = undefined;
@@ -797,10 +797,10 @@ class ModuleGraph {
 
 	/**
 	 * @template T
-	 * @template V
-	 * @param {(moduleGraph: ModuleGraph, ...args: T[]) => V} fn computer
+	 * @template R
+	 * @param {(moduleGraph: ModuleGraph, ...args: T[]) => R} fn computer
 	 * @param {...T} args arguments
-	 * @returns {V} computed value or cached
+	 * @returns {R} computed value or cached
 	 */
 	cached(fn, ...args) {
 		if (this._cache === undefined) return fn(this, ...args);
@@ -815,16 +815,21 @@ class ModuleGraph {
 	}
 
 	/**
-	 * @param {Dependency} dependency dependency
-	 * @param {...any} args arguments, last argument is a function called with moduleGraph, dependency, ...args
-	 * @returns {any} computed value or cached
+	 * @template {Dependency} D
+	 * @template {EXPECTED_ANY[]} ARGS
+	 * @template R
+	 * @param {D} dependency dependency
+	 * @param {[...ARGS, (moduleGraph: ModuleGraph, dependency: D, ...args: ARGS) => R]} args arguments, last argument is a function called with moduleGraph, dependency, ...args
+	 * @returns {R} computed value or cached
 	 */
 	dependencyCacheProvide(dependency, ...args) {
-		/** @type {(moduleGraph: ModuleGraph, dependency: Dependency, ...args: any[]) => any} */
-		const fn = args.pop();
+		const fn =
+			/** @type {(moduleGraph: ModuleGraph, dependency: D, ...args: EXPECTED_ANY[]) => R} */
+			(args.pop());
 		if (this._moduleMemCaches && this._cacheStage) {
 			const memCache = this._moduleMemCaches.get(
-				/** @type {Module} */ (this.getParentModule(dependency))
+				/** @type {Module} */
+				(this.getParentModule(dependency))
 			);
 			if (memCache !== undefined) {
 				return memCache.provide(dependency, this._cacheStage, ...args, () =>

package/lib/NormalModule.js

@@ -663,7 +663,7 @@ class NormalModule extends Module {
 		const loaderContext = {
 			version: 2,
 			/**
-			 * @param {import("../declarations/LoaderContext").Schema} [schema] schema
+			 * @param {import("../declarations/LoaderContext").Schema=} schema schema
 			 * @returns {T} options
 			 */
 			getOptions: schema => {

package/lib/PrefetchPlugin.js

@@ -12,7 +12,7 @@ const PrefetchDependency = require("./dependencies/PrefetchDependency");
 class PrefetchPlugin {
 	/**
 	 * @param {string} context context or request if context is not set
-	 * @param {string} [request] request
+	 * @param {string=} request request
 	 */
 	constructor(context, request) {
 		if (request) {

package/lib/RecordIdsPlugin.js

@@ -39,7 +39,7 @@ const identifierUtils = require("./util/identifier");
 
 class RecordIdsPlugin {
 	/**
-	 * @param {RecordIdsPluginOptions} [options] object
+	 * @param {RecordIdsPluginOptions=} options object
 	 */
 	constructor(options) {
 		this.options = options || {};

package/lib/SourceMapDevToolPlugin.js

@@ -133,7 +133,7 @@ const getTaskForFile = (
 
 class SourceMapDevToolPlugin {
 	/**
-	 * @param {SourceMapDevToolPluginOptions} [options] options object
+	 * @param {SourceMapDevToolPluginOptions=} options options object
 	 * @throws {Error} throws error, if got more than 1 arguments
 	 */
 	constructor(options = {}) {

package/lib/Template.js

@@ -250,7 +250,7 @@ class Template {
 
 	/**
 	 * @typedef {object} WithId
-	 * @property {string|number} id
+	 * @property {string | number} id
 	 */
 
 	/**

package/lib/WebpackOptionsApply.js

@@ -48,6 +48,7 @@ const WorkerPlugin = require("./dependencies/WorkerPlugin");
 
 const InferAsyncModulesPlugin = require("./async-modules/InferAsyncModulesPlugin");
 
+const FlagDependencyExportsPlugin = require("./FlagDependencyExportsPlugin");
 const JavascriptMetaInfoPlugin = require("./JavascriptMetaInfoPlugin");
 const DefaultStatsFactoryPlugin = require("./stats/DefaultStatsFactoryPlugin");
 const DefaultStatsPresetPlugin = require("./stats/DefaultStatsPresetPlugin");
@@ -236,9 +237,24 @@ class WebpackOptionsApply extends OptionsApply {
 			(options.output.enabledLibraryTypes);
 
 		if (enabledLibraryTypes.length > 0) {
+			let once = true;
 			for (const type of enabledLibraryTypes) {
 				const EnableLibraryPlugin = require("./library/EnableLibraryPlugin");
-				new EnableLibraryPlugin(type).apply(compiler);
+				new EnableLibraryPlugin(type, {
+					// eslint-disable-next-line no-loop-func
+					additionalApply: () => {
+						if (!once) return;
+						once = false;
+						// We rely on `exportInfo` to generate the `export statement` in certain library bundles.
+						// Therefore, we ignore the disabling of `optimization.providedExport` and continue to apply `FlagDependencyExportsPlugin`.
+						if (
+							["module", "commonjs-static", "modern-module"].includes(type) &&
+							!options.optimization.providedExports
+						) {
+							new FlagDependencyExportsPlugin().apply(compiler);
+						}
+					}
+				}).apply(compiler);
 			}
 		}
 
@@ -458,7 +474,6 @@ class WebpackOptionsApply extends OptionsApply {
 			).apply(compiler);
 		}
 		if (options.optimization.providedExports) {
-			const FlagDependencyExportsPlugin = require("./FlagDependencyExportsPlugin");
 			new FlagDependencyExportsPlugin().apply(compiler);
 		}
 		if (options.optimization.usedExports) {

package/lib/buildChunkGraph.js

@@ -256,6 +256,7 @@ const visitModules = (
 ) => {
 	const { moduleGraph, chunkGraph, moduleMemCaches } = compilation;
 
+	/** @type {Map<RuntimeSpec, BlockModulesMap>} */
 	const blockModulesRuntimeMap = new Map();
 
 	/** @type {BlockModulesMap | undefined} */
@@ -288,11 +289,12 @@ const visitModules = (
 	/**
 	 * @param {DependenciesBlock} block block
 	 * @param {RuntimeSpec} runtime runtime
-	 * @returns {BlockModulesInFlattenTuples} block modules in flatten tuples
+	 * @returns {BlockModulesInFlattenTuples | undefined} block modules in flatten tuples
 	 */
 	const getBlockModules = (block, runtime) => {
 		blockModulesMap = blockModulesRuntimeMap.get(runtime);
 		if (blockModulesMap === undefined) {
+			/** @type {BlockModulesMap} */
 			blockModulesMap = new Map();
 			blockModulesRuntimeMap.set(runtime, blockModulesMap);
 		}
@@ -301,6 +303,7 @@ const visitModules = (
 		const module = /** @type {Module} */ (block.getRootBlock());
 		const memCache = moduleMemCaches && moduleMemCaches.get(module);
 		if (memCache !== undefined) {
+			/** @type {BlockModulesMap} */
 			const map = memCache.provide(
 				"bundleChunkGraph.blockModules",
 				runtime,
@@ -1162,7 +1165,9 @@ const visitModules = (
 			 * @param {BlocksWithNestedBlocks} visited visited dependencies blocks
 			 */
 			const process = (current, visited) => {
-				const blockModules = getBlockModules(current, runtime);
+				const blockModules =
+					/** @type {BlockModulesInFlattenTuples} */
+					(getBlockModules(current, runtime));
 				for (let i = 0, len = blockModules.length; i < len; i += 3) {
 					const activeState = /** @type {ConnectionState} */ (
 						blockModules[i + 1]

package/lib/cache/IdleFileCachePlugin.js

@@ -129,7 +129,7 @@ class IdleFileCachePlugin {
 			}
 		);
 
-		/** @type {Promise<any>} */
+		/** @type {Promise<TODO>} */
 		let currentIdlePromise = resolvedPromise;
 		let isIdle = false;
 		let isInitialStore = true;

package/lib/cache/MemoryCachePlugin.js

@@ -8,6 +8,7 @@
 const Cache = require("../Cache");
 
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Cache").Data} Data */
 /** @typedef {import("../Cache").Etag} Etag */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
@@ -19,7 +20,7 @@ class MemoryCachePlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		/** @type {Map<string, { etag: Etag | null, data: any } | null>} */
+		/** @type {Map<string, { etag: Etag | null, data: Data } | null>} */
 		const cache = new Map();
 		compiler.cache.hooks.store.tap(
 			{ name: "MemoryCachePlugin", stage: Cache.STAGE_MEMORY },