webpack 5.90.3 → 5.91.0

package/lib/HookWebpackError.js

@@ -12,7 +12,7 @@ const WebpackError = require("./WebpackError");
 /**
  * @template T
  * @callback Callback
- * @param {Error=} err
+ * @param {Error | null} err
  * @param {T=} stats
  * @returns {void}
  */
@@ -51,7 +51,7 @@ module.exports.makeWebpackError = makeWebpackError;
 
 /**
  * @template T
- * @param {function((WebpackError | null)=, T=): void} callback webpack error callback
+ * @param {function(WebpackError | null, T=): void} callback webpack error callback
  * @param {string} hook name of hook
  * @returns {Callback<T>} generic callback
  */

package/lib/InitFragment.js

@@ -40,7 +40,7 @@ const sortFragmentWithIndex = ([a, i], [b, j]) => {
  */
 class InitFragment {
 	/**
-	 * @param {string | Source} content the source code that will be included as initialization code
+	 * @param {string | Source | undefined} content the source code that will be included as initialization code
 	 * @param {number} stage category of initialization code (contribute to order)
 	 * @param {number} position position in the category (contribute to order)
 	 * @param {string=} key unique key to avoid emitting the same initialization code twice
@@ -56,7 +56,7 @@ class InitFragment {
 
 	/**
 	 * @param {GenerateContext} context context
-	 * @returns {string | Source} the source code that will be included as initialization code
+	 * @returns {string | Source | undefined} the source code that will be included as initialization code
 	 */
 	getContent(context) {
 		return this.content;
@@ -171,7 +171,9 @@ class InitFragment {
 
 makeSerializable(InitFragment, "webpack/lib/InitFragment");
 
-InitFragment.prototype.merge = undefined;
+InitFragment.prototype.merge =
+	/** @type {TODO} */
+	(undefined);
 
 InitFragment.STAGE_CONSTANTS = 10;
 InitFragment.STAGE_ASYNC_BOUNDARY = 20;

package/lib/LibManifestPlugin.js

@@ -12,6 +12,7 @@ const { compareModulesById } = require("./util/comparators");
 const { dirname, mkdirp } = require("./util/fs");
 
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Compiler").IntermediateFileSystem} IntermediateFileSystem */
 /** @typedef {import("./Module").BuildMeta} BuildMeta */
 
 /**
@@ -52,6 +53,8 @@ class LibManifestPlugin {
 			},
 			(compilation, callback) => {
 				const moduleGraph = compilation.moduleGraph;
+				// store used paths to detect issue and output an error. #18200
+				const usedPaths = new Set();
 				asyncLib.forEach(
 					Array.from(compilation.chunks),
 					(chunk, callback) => {
@@ -63,6 +66,11 @@ class LibManifestPlugin {
 						const targetPath = compilation.getPath(this.options.path, {
 							chunk
 						});
+						if (usedPaths.has(targetPath)) {
+							callback(new Error(`each chunk must have a unique path`));
+							return;
+						}
+						usedPaths.add(targetPath);
 						const name =
 							this.options.name &&
 							compilation.getPath(this.options.name, {
@@ -113,16 +121,16 @@ class LibManifestPlugin {
 							? JSON.stringify(manifest, null, 2)
 							: JSON.stringify(manifest);
 						const buffer = Buffer.from(manifestContent, "utf8");
+						const intermediateFileSystem =
+							/** @type {IntermediateFileSystem} */ (
+								compiler.intermediateFileSystem
+							);
 						mkdirp(
-							compiler.intermediateFileSystem,
-							dirname(compiler.intermediateFileSystem, targetPath),
+							intermediateFileSystem,
+							dirname(intermediateFileSystem, targetPath),
 							err => {
 								if (err) return callback(err);
-								compiler.intermediateFileSystem.writeFile(
-									targetPath,
-									buffer,
-									callback
-								);
+								intermediateFileSystem.writeFile(targetPath, buffer, callback);
 							}
 						);
 					},

package/lib/Module.js

@@ -64,7 +64,7 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {RuntimeSpec} runtime the runtime code should be generated for
  * @property {RuntimeSpec[]} [runtimes] the runtimes code should be generated for
  * @property {ConcatenationScope=} concatenationScope when in concatenated module, information about other concatenated modules
- * @property {CodeGenerationResults} codeGenerationResults code generation results of other modules (need to have a codeGenerationDependency to use that)
+ * @property {CodeGenerationResults | undefined} codeGenerationResults code generation results of other modules (need to have a codeGenerationDependency to use that)
  * @property {Compilation=} compilation the compilation
  * @property {ReadonlySet<string>=} sourceTypes source types
  */
@@ -75,11 +75,14 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {ChunkGraph} chunkGraph the chunk graph
  */
 
+/** @typedef {Set<string>} RuntimeRequirements */
+/** @typedef {ReadonlySet<string>} ReadOnlyRuntimeRequirements */
+
 /**
  * @typedef {Object} CodeGenerationResult
  * @property {Map<string, Source>} sources the resulting sources for all source types
  * @property {Map<string, any>=} data the resulting data for all source types
- * @property {ReadonlySet<string>} runtimeRequirements the runtime requirements
+ * @property {ReadOnlyRuntimeRequirements} runtimeRequirements the runtime requirements
  * @property {string=} hash a hash of the code generation result (will be automatically calculated from sources and runtimeRequirements if not provided)
  */
 
@@ -270,6 +273,9 @@ class Module extends DependenciesBlock {
 		).setProfile(this, value);
 	}
 
+	/**
+	 * @returns {number | null} the pre order index
+	 */
 	get index() {
 		return ModuleGraph.getModuleGraphForModule(
 			this,
@@ -278,6 +284,9 @@ class Module extends DependenciesBlock {
 		).getPreOrderIndex(this);
 	}
 
+	/**
+	 * @param {number} value the pre order index
+	 */
 	set index(value) {
 		ModuleGraph.getModuleGraphForModule(
 			this,
@@ -286,6 +295,9 @@ class Module extends DependenciesBlock {
 		).setPreOrderIndex(this, value);
 	}
 
+	/**
+	 * @returns {number | null} the post order index
+	 */
 	get index2() {
 		return ModuleGraph.getModuleGraphForModule(
 			this,
@@ -294,6 +306,9 @@ class Module extends DependenciesBlock {
 		).getPostOrderIndex(this);
 	}
 
+	/**
+	 * @param {number} value the post order index
+	 */
 	set index2(value) {
 		ModuleGraph.getModuleGraphForModule(
 			this,
@@ -302,6 +317,9 @@ class Module extends DependenciesBlock {
 		).setPostOrderIndex(this, value);
 	}
 
+	/**
+	 * @returns {number | null} the depth
+	 */
 	get depth() {
 		return ModuleGraph.getModuleGraphForModule(
 			this,
@@ -310,6 +328,9 @@ class Module extends DependenciesBlock {
 		).getDepth(this);
 	}
 
+	/**
+	 * @param {number} value the depth
+	 */
 	set depth(value) {
 		ModuleGraph.getModuleGraphForModule(
 			this,
@@ -318,6 +339,9 @@ class Module extends DependenciesBlock {
 		).setDepth(this, value);
 	}
 
+	/**
+	 * @returns {Module | null | undefined} issuer
+	 */
 	get issuer() {
 		return ModuleGraph.getModuleGraphForModule(
 			this,
@@ -326,6 +350,9 @@ class Module extends DependenciesBlock {
 		).getIssuer(this);
 	}
 
+	/**
+	 * @param {Module | null} value issuer
+	 */
 	set issuer(value) {
 		ModuleGraph.getModuleGraphForModule(
 			this,
@@ -872,6 +899,7 @@ class Module extends DependenciesBlock {
 			codeGenerationResults: undefined
 		};
 		const sources = this.codeGeneration(codeGenContext).sources;
+
 		return type ? sources.get(type) : sources.get(first(this.getSourceTypes()));
 	}
 

package/lib/ModuleFilenameHelpers.js

@@ -115,7 +115,7 @@ const asRegExp = test => {
  * @template T
  * Returns a lazy object. The object is lazy in the sense that the properties are
  * only evaluated when they are accessed. This is only obtained by setting a function as the value for each key.
- * @param {Record<string, () => T>} obj the object to covert to a lazy access object
+ * @param {Record<string, () => T>} obj the object to convert to a lazy access object
  * @returns {Object} the lazy access object
  */
 const lazyObject = obj => {

package/lib/ModuleGraph.js

@@ -89,13 +89,16 @@ const getConnectionsByModule = set => {
 	return map;
 };
 
+/** @typedef {SortableSet<ModuleGraphConnection>} IncomingConnections */
+/** @typedef {SortableSet<ModuleGraphConnection>} OutgoingConnections */
+
 class ModuleGraphModule {
 	constructor() {
-		/** @type {SortableSet<ModuleGraphConnection>} */
+		/** @type {IncomingConnections} */
 		this.incomingConnections = new SortableSet();
-		/** @type {SortableSet<ModuleGraphConnection> | undefined} */
+		/** @type {OutgoingConnections | undefined} */
 		this.outgoingConnections = undefined;
-		/** @type {Module | null} */
+		/** @type {Module | null | undefined} */
 		this.issuer = undefined;
 		/** @type {(string | OptimizationBailoutFunction)[]} */
 		this.optimizationBailout = [];
@@ -107,31 +110,47 @@ class ModuleGraphModule {
 		this.postOrderIndex = null;
 		/** @type {number | null} */
 		this.depth = null;
-		/** @type {ModuleProfile | undefined | null} */
+		/** @type {ModuleProfile | undefined} */
 		this.profile = undefined;
 		/** @type {boolean} */
 		this.async = false;
-		/** @type {ModuleGraphConnection[]} */
+		/** @type {ModuleGraphConnection[] | undefined} */
 		this._unassignedConnections = undefined;
 	}
 }
 
 class ModuleGraph {
 	constructor() {
-		/** @type {WeakMap<Dependency, ModuleGraphConnection | null>} */
+		/**
+		 * @type {WeakMap<Dependency, ModuleGraphConnection | null>}
+		 * @private
+		 */
 		this._dependencyMap = new WeakMap();
-		/** @type {Map<Module, ModuleGraphModule>} */
+		/**
+		 * @type {Map<Module, ModuleGraphModule>}
+		 * @private
+		 */
 		this._moduleMap = new Map();
-		/** @type {WeakMap<any, Object>} */
+		/**
+		 * @type {WeakMap<any, Object>}
+		 * @private
+		 */
 		this._metaMap = new WeakMap();
-
-		/** @type {WeakTupleMap<any[], any> | undefined} */
+		/**
+		 * @type {WeakTupleMap<any[], any> | undefined}
+		 * @private
+		 */
 		this._cache = undefined;
-
-		/** @type {Map<Module, WeakTupleMap<any, any>>} */
+		/**
+		 * @type {Map<Module, WeakTupleMap<any, any>> | undefined}
+		 * @private
+		 */
 		this._moduleMemCaches = undefined;
 
-		/** @type {string | undefined} */
+		/**
+		 * @type {string | undefined}
+		 * @private
+		 */
 		this._cacheStage = undefined;
 	}
 
@@ -163,7 +182,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Dependency} dependency the dependency
-	 * @returns {Module} parent module
+	 * @returns {Module | undefined} parent module
 	 */
 	getParentModule(dependency) {
 		return dependency._parentModule;
@@ -171,7 +190,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Dependency} dependency the dependency
-	 * @returns {DependenciesBlock} parent block
+	 * @returns {DependenciesBlock | undefined} parent block
 	 */
 	getParentBlock(dependency) {
 		return dependency._parentDependenciesBlock;
@@ -186,7 +205,7 @@ class ModuleGraph {
 	}
 
 	/**
-	 * @param {Module} originModule the referencing module
+	 * @param {Module | null} originModule the referencing module
 	 * @param {Dependency} dependency the referencing dependency
 	 * @param {Module} module the referenced module
 	 * @returns {void}
@@ -231,8 +250,11 @@ class ModuleGraph {
 		newConnection.module = module;
 		this._dependencyMap.set(dependency, newConnection);
 		connection.setActive(false);
-		const originMgm = this._getModuleGraphModule(connection.originModule);
-		originMgm.outgoingConnections.add(newConnection);
+		const originMgm = this._getModuleGraphModule(
+			/** @type {Module} */ (connection.originModule)
+		);
+		/** @type {OutgoingConnections} */
+		(originMgm.outgoingConnections).add(newConnection);
 		const targetMgm = this._getModuleGraphModule(module);
 		targetMgm.incomingConnections.add(newConnection);
 	}
@@ -242,11 +264,16 @@ class ModuleGraph {
 	 * @returns {void}
 	 */
 	removeConnection(dependency) {
-		const connection = this.getConnection(dependency);
+		const connection =
+			/** @type {ModuleGraphConnection} */
+			(this.getConnection(dependency));
 		const targetMgm = this._getModuleGraphModule(connection.module);
 		targetMgm.incomingConnections.delete(connection);
-		const originMgm = this._getModuleGraphModule(connection.originModule);
-		originMgm.outgoingConnections.delete(connection);
+		const originMgm = this._getModuleGraphModule(
+			/** @type {Module} */ (connection.originModule)
+		);
+		/** @type {OutgoingConnections} */
+		(originMgm.outgoingConnections).delete(connection);
 		this._dependencyMap.set(dependency, null);
 	}
 
@@ -256,7 +283,9 @@ class ModuleGraph {
 	 * @returns {void}
 	 */
 	addExplanation(dependency, explanation) {
-		const connection = this.getConnection(dependency);
+		const connection =
+			/** @type {ModuleGraphConnection} */
+			(this.getConnection(dependency));
 		connection.addExplanation(explanation);
 	}
 
@@ -468,7 +497,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Module} module the module
-	 * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]>} reasons why a module is included, in a map by source module
+	 * @returns {readonly Map<Module | undefined | null, readonly ModuleGraphConnection[]>} reasons why a module is included, in a map by source module
 	 */
 	getIncomingConnectionsByOriginModule(module) {
 		const connections = this._getModuleGraphModule(module).incomingConnections;
@@ -488,7 +517,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Module} module the module
-	 * @returns {ModuleProfile | null} the module profile
+	 * @returns {ModuleProfile | undefined} the module profile
 	 */
 	getProfile(module) {
 		const mgm = this._getModuleGraphModule(module);
@@ -497,7 +526,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Module} module the module
-	 * @param {ModuleProfile | null} profile the module profile
+	 * @param {ModuleProfile | undefined} profile the module profile
 	 * @returns {void}
 	 */
 	setProfile(module, profile) {
@@ -507,7 +536,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Module} module the module
-	 * @returns {Module | null} the issuer module
+	 * @returns {Module | null | undefined} the issuer module
 	 */
 	getIssuer(module) {
 		const mgm = this._getModuleGraphModule(module);
@@ -789,7 +818,7 @@ class ModuleGraph {
 		const fn = args.pop();
 		if (this._moduleMemCaches && this._cacheStage) {
 			const memCache = this._moduleMemCaches.get(
-				this.getParentModule(dependency)
+				/** @type {Module} */ (this.getParentModule(dependency))
 			);
 			if (memCache !== undefined) {
 				return memCache.provide(dependency, this._cacheStage, ...args, () =>

package/lib/ModuleGraphConnection.js

@@ -6,6 +6,7 @@
 "use strict";
 
 /** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./Dependency").GetConditionFn} GetConditionFn */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
@@ -56,7 +57,7 @@ class ModuleGraphConnection {
 	 * @param {Module} module the referenced module
 	 * @param {string=} explanation some extra detail
 	 * @param {boolean=} weak the reference is weak
-	 * @param {false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState=} condition condition for the connection
+	 * @param {false | null | GetConditionFn | undefined} condition condition for the connection
 	 */
 	constructor(
 		originModule,

package/lib/MultiCompiler.js

@@ -28,7 +28,7 @@ const ArrayQueue = require("./util/ArrayQueue");
 /**
  * @template T
  * @callback Callback
- * @param {(Error | null)=} err
+ * @param {Error | null} err
  * @param {T=} result
  */
 
@@ -50,9 +50,11 @@ module.exports = class MultiCompiler {
 	 */
 	constructor(compilers, options) {
 		if (!Array.isArray(compilers)) {
+			/** @type {Compiler[]} */
 			compilers = Object.keys(compilers).map(name => {
-				compilers[name].name = name;
-				return compilers[name];
+				/** @type {Record<string, Compiler>} */
+				(compilers)[name].name = name;
+				return /** @type {Record<string, Compiler>} */ (compilers)[name];
 			});
 		}
 
@@ -221,10 +223,19 @@ module.exports = class MultiCompiler {
 			}
 			return false;
 		};
+		/**
+		 * @param {{source: Compiler, target: Compiler}} e1 edge 1
+		 * @param {{source: Compiler, target: Compiler}} e2 edge 2
+		 * @returns {number} result
+		 */
 		const sortEdges = (e1, e2) => {
 			return (
-				e1.source.name.localeCompare(e2.source.name) ||
-				e1.target.name.localeCompare(e2.target.name)
+				/** @type {string} */
+				(e1.source.name).localeCompare(
+					/** @type {string} */ (e2.source.name)
+				) ||
+				/** @type {string} */
+				(e1.target.name).localeCompare(/** @type {string} */ (e2.target.name))
 			);
 		};
 		for (const source of this.compilers) {
@@ -290,6 +301,9 @@ module.exports = class MultiCompiler {
 		 * @returns {boolean} when dependency was fulfilled
 		 */
 		const isDependencyFulfilled = d => fulfilledNames.has(d);
+		/**
+		 * @returns {Compiler[]} compilers
+		 */
 		const getReadyCompilers = () => {
 			let readyCompilers = [];
 			let list = remainingCompilers;
@@ -311,7 +325,7 @@ module.exports = class MultiCompiler {
 		 * @returns {void}
 		 */
 		const runCompilers = callback => {
-			if (remainingCompilers.length === 0) return callback();
+			if (remainingCompilers.length === 0) return callback(null);
 			asyncLib.map(
 				getReadyCompilers(),
 				(compiler, callback) => {
@@ -321,7 +335,9 @@ module.exports = class MultiCompiler {
 						runCompilers(callback);
 					});
 				},
-				/** @type {Callback<TODO>} */ (callback)
+				(err, results) => {
+					callback(err, /** @type {TODO} */ (results));
+				}
 			);
 		};
 		runCompilers(callback);
@@ -602,7 +618,9 @@ module.exports = class MultiCompiler {
 			(compiler, callback) => {
 				compiler.close(callback);
 			},
-			callback
+			error => {
+				callback(error);
+			}
 		);
 	}
 };

package/lib/NodeStuffPlugin.js

@@ -32,6 +32,7 @@ const { parseResource } = require("./util/identifier");
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("./javascript/JavascriptParser").Range} Range */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
 const PLUGIN_NAME = "NodeStuffPlugin";
 
@@ -193,7 +194,11 @@ class NodeStuffPlugin {
 								break;
 							case true:
 								setModuleConstant("__filename", module =>
-									relative(compiler.inputFileSystem, context, module.resource)
+									relative(
+										/** @type {InputFileSystem} */ (compiler.inputFileSystem),
+										context,
+										module.resource
+									)
 								);
 								break;
 						}
@@ -227,7 +232,11 @@ class NodeStuffPlugin {
 								break;
 							case true:
 								setModuleConstant("__dirname", module =>
-									relative(compiler.inputFileSystem, context, module.context)
+									relative(
+										/** @type {InputFileSystem} */ (compiler.inputFileSystem),
+										context,
+										/** @type {string} */ (module.context)
+									)
 								);
 								break;
 						}
@@ -236,7 +245,9 @@ class NodeStuffPlugin {
 							.for("__dirname")
 							.tap(PLUGIN_NAME, expr => {
 								if (!parser.state.module) return;
-								return evaluateToString(parser.state.module.context)(expr);
+								return evaluateToString(
+									/** @type {string} */ (parser.state.module.context)
+								)(expr);
 							});
 					}
 					parser.hooks.expression

package/lib/NormalModule.js

@@ -926,6 +926,8 @@ class NormalModule extends Module {
 				loaderContext._compilation =
 					loaderContext._compiler =
 					loaderContext._module =
+					// eslint-disable-next-line no-warning-comments
+					// @ts-ignore
 					loaderContext.fs =
 						undefined;
 
@@ -1352,7 +1354,7 @@ class NormalModule extends Module {
 				? new RawSource(
 						"throw new Error(" + JSON.stringify(this.error.message) + ");"
 					)
-				: this.generator.generate(this, {
+				: /** @type {Generator} */ (this.generator).generate(this, {
 						dependencyTemplates,
 						runtimeTemplate,
 						moduleGraph,

package/lib/NormalModuleFactory.js

@@ -268,7 +268,7 @@ class NormalModuleFactory extends ModuleFactory {
 			resolveInScheme: new HookMap(
 				() => new AsyncSeriesBailHook(["resourceData", "resolveData"])
 			),
-			/** @type {AsyncSeriesBailHook<[ResolveData], Module>} */
+			/** @type {AsyncSeriesBailHook<[ResolveData], Module | undefined>} */
 			factorize: new AsyncSeriesBailHook(["resolveData"]),
 			/** @type {AsyncSeriesBailHook<[ResolveData], false | void>} */
 			beforeResolve: new AsyncSeriesBailHook(["resolveData"]),

package/lib/NormalModuleReplacementPlugin.js

@@ -8,6 +8,8 @@
 const { join, dirname } = require("./util/fs");
 
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+
 /** @typedef {function(import("./NormalModuleFactory").ResolveData): void} ModuleReplacer */
 
 class NormalModuleReplacementPlugin {
@@ -49,7 +51,9 @@ class NormalModuleReplacementPlugin {
 						if (typeof newResource === "function") {
 							newResource(result);
 						} else {
-							const fs = compiler.inputFileSystem;
+							const fs =
+								/** @type {InputFileSystem} */
+								(compiler.inputFileSystem);
 							if (
 								newResource.startsWith("/") ||
 								(newResource.length > 1 && newResource[1] === ":")

package/lib/ProvidePlugin.js

@@ -59,7 +59,9 @@ class ProvidePlugin {
 				 */
 				const handler = (parser, parserOptions) => {
 					Object.keys(definitions).forEach(name => {
-						const request = [].concat(definitions[name]);
+						const request =
+							/** @type {string[]} */
+							([]).concat(definitions[name]);
 						const splittedName = name.split(".");
 						if (splittedName.length > 0) {
 							splittedName.slice(1).forEach((_, i) => {

package/lib/RawModule.js

@@ -19,6 +19,7 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("./Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
 /** @typedef {import("./Module").SourceTypes} SourceTypes */
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
@@ -36,7 +37,7 @@ class RawModule extends Module {
 	 * @param {string} source source code
 	 * @param {string} identifier unique identifier
 	 * @param {string=} readableIdentifier readable identifier
-	 * @param {ReadonlySet<string>=} runtimeRequirements runtime requirements needed for the source code
+	 * @param {ReadOnlyRuntimeRequirements=} runtimeRequirements runtime requirements needed for the source code
 	 */
 	constructor(source, identifier, readableIdentifier, runtimeRequirements) {
 		super(JAVASCRIPT_MODULE_TYPE_DYNAMIC, null);

package/lib/ResolverFactory.js

@@ -61,7 +61,9 @@ const convertToResolveOptions = resolveOptionsWithDepType => {
 		);
 
 	return removeOperations(
-		resolveByProperty(options, "byDependency", dependencyType)
+		resolveByProperty(options, "byDependency", dependencyType),
+		// Keep the `unsafeCache` because it can be a `Proxy`
+		["unsafeCache"]
 	);
 };
 

package/lib/RuntimeModule.js

@@ -47,7 +47,7 @@ class RuntimeModule extends Module {
 		this.chunkGraph = undefined;
 		this.fullHash = false;
 		this.dependentHash = false;
-		/** @type {string | undefined} */
+		/** @type {string | undefined | null} */
 		this._cachedGeneratedCode = undefined;
 	}
 
@@ -113,9 +113,9 @@ class RuntimeModule extends Module {
 			if (this.fullHash || this.dependentHash) {
 				// Do not use getGeneratedCode here, because i. e. compilation hash might be not
 				// ready at this point. We will cache it later instead.
-				hash.update(this.generate());
+				hash.update(/** @type {string} */ (this.generate()));
 			} else {
-				hash.update(this.getGeneratedCode());
+				hash.update(/** @type {string} */ (this.getGeneratedCode()));
 			}
 		} catch (err) {
 			hash.update(/** @type {Error} */ (err).message);
@@ -179,7 +179,7 @@ class RuntimeModule extends Module {
 	 */
 	getGeneratedCode() {
 		if (this._cachedGeneratedCode) {
-			return /** @type {string | null} */ (this._cachedGeneratedCode);
+			return this._cachedGeneratedCode;
 		}
 		return (this._cachedGeneratedCode = this.generate());
 	}