webpack 5.40.0 → 5.42.1

package/README.md

@@ -287,7 +287,7 @@ Contributions go far beyond pull requests and commits. Although we love giving y
 - [Blogging, speaking about, or creating tutorials](https://github.com/webpack-contrib/awesome-webpack) about one of webpack's many features.
 - Helping others in our webpack [gitter channel](https://gitter.im/webpack/webpack).
 
-To get started have a look at our [documentation on contributing](https://github.com/webpack/webpack/blob/master/CONTRIBUTING.md).
+To get started have a look at our [documentation on contributing](https://github.com/webpack/webpack/blob/main/CONTRIBUTING.md).
 
 If you are worried or don't know where to start, you can **always** reach out to [Sean Larkin (@TheLarkInn) on Twitter](https://twitter.com/thelarkinn) or simply submit an issue and a maintainer can help give you guidance!
 
@@ -715,11 +715,11 @@ src="https://static.monei.net/monei-logo.svg" height="30" alt="MONEI"></a>
 [node-url]: https://nodejs.org
 [deps]: https://img.shields.io/david/webpack/webpack.svg
 [deps-url]: https://david-dm.org/webpack/webpack
-[tests]: https://img.shields.io/travis/webpack/webpack/master.svg
+[tests]: https://img.shields.io/travis/webpack/webpack/main.svg
 [tests-url]: https://travis-ci.org/webpack/webpack
 [prs]: https://img.shields.io/badge/PRs-welcome-brightgreen.svg
 [prs-url]: https://webpack.js.org/contribute/
-[builds-url]: https://ci.appveyor.com/project/sokra/webpack/branch/master
+[builds-url]: https://ci.appveyor.com/project/sokra/webpack/branch/main
 [builds]: https://ci.appveyor.com/api/projects/status/github/webpack/webpack?svg=true
 [builds2]: https://dev.azure.com/webpack/webpack/_apis/build/status/webpack.webpack
 [builds2-url]: https://dev.azure.com/webpack/webpack/_build/latest?definitionId=3

package/lib/Compiler.js

@@ -260,6 +260,8 @@ class Compiler {
 
 		/** @type {Compilation} */
 		this._lastCompilation = undefined;
+		/** @type {NormalModuleFactory} */
+		this._lastNormalModuleFactory = undefined;
 
 		/** @private @type {WeakMap<Source, { sizeOnlySource: SizeOnlySource, writtenTo: Map<string, number> }>} */
 		this._assetEmittingSourceCache = new WeakMap();
@@ -375,6 +377,14 @@ class Compiler {
 		}
 	}
 
+	// TODO webpack 6: solve this in a better way
+	_cleanupLastNormalModuleFactory() {
+		if (this._lastNormalModuleFactory !== undefined) {
+			this._lastNormalModuleFactory.cleanupForCache();
+			this._lastNormalModuleFactory = undefined;
+		}
+	}
+
 	/**
 	 * @param {WatchOptions} watchOptions the watcher's options
 	 * @param {Callback<Stats>} handler signals when the call finishes
@@ -1036,6 +1046,7 @@ ${other}`);
 	}
 
 	createNormalModuleFactory() {
+		this._cleanupLastNormalModuleFactory();
 		const normalModuleFactory = new NormalModuleFactory({
 			context: this.options.context,
 			fs: this.inputFileSystem,
@@ -1044,6 +1055,7 @@ ${other}`);
 			associatedObjectForCache: this.root,
 			layers: this.options.experiments.layers
 		});
+		this._lastNormalModuleFactory = normalModuleFactory;
 		this.hooks.normalModuleFactory.call(normalModuleFactory);
 		return normalModuleFactory;
 	}
@@ -1122,8 +1134,9 @@ ${other}`);
 			if (err) return callback(err);
 			// Get rid of reference to last compilation to avoid leaking memory
 			// We can't run this._cleanupLastCompilation() as the Stats to this compilation
-			// might be still in use. We try to get rid for the reference to the cache instead.
+			// might be still in use. We try to get rid of the reference to the cache instead.
 			this._lastCompilation = undefined;
+			this._lastNormalModuleFactory = undefined;
 			this.cache.shutdown(callback);
 		});
 	}

package/lib/ConditionalInitFragment.js

@@ -31,6 +31,9 @@ const wrapInCondition = (condition, source) => {
 	}
 };
 
+/**
+ * @typedef {GenerateContext} Context
+ */
 class ConditionalInitFragment extends InitFragment {
 	/**
 	 * @param {string|Source} content the source code that will be included as initialization code
@@ -53,16 +56,16 @@ class ConditionalInitFragment extends InitFragment {
 	}
 
 	/**
-	 * @param {GenerateContext} generateContext context for generate
+	 * @param {Context} context context
 	 * @returns {string|Source} the source code that will be included as initialization code
 	 */
-	getContent(generateContext) {
+	getContent(context) {
 		if (this.runtimeCondition === false || !this.content) return "";
 		if (this.runtimeCondition === true) return this.content;
-		const expr = generateContext.runtimeTemplate.runtimeConditionExpression({
-			chunkGraph: generateContext.chunkGraph,
-			runtimeRequirements: generateContext.runtimeRequirements,
-			runtime: generateContext.runtime,
+		const expr = context.runtimeTemplate.runtimeConditionExpression({
+			chunkGraph: context.chunkGraph,
+			runtimeRequirements: context.runtimeRequirements,
+			runtime: context.runtime,
 			runtimeCondition: this.runtimeCondition
 		});
 		if (expr === "true") return this.content;
@@ -70,16 +73,16 @@ class ConditionalInitFragment extends InitFragment {
 	}
 
 	/**
-	 * @param {GenerateContext} generateContext context for generate
+	 * @param {Context} context context
 	 * @returns {string|Source=} the source code that will be included at the end of the module
 	 */
-	getEndContent(generateContext) {
+	getEndContent(context) {
 		if (this.runtimeCondition === false || !this.endContent) return "";
 		if (this.runtimeCondition === true) return this.endContent;
-		const expr = generateContext.runtimeTemplate.runtimeConditionExpression({
-			chunkGraph: generateContext.chunkGraph,
-			runtimeRequirements: generateContext.runtimeRequirements,
-			runtime: generateContext.runtime,
+		const expr = context.runtimeTemplate.runtimeConditionExpression({
+			chunkGraph: context.chunkGraph,
+			runtimeRequirements: context.runtimeRequirements,
+			runtime: context.runtime,
 			runtimeCondition: this.runtimeCondition
 		});
 		if (expr === "true") return this.endContent;

package/lib/DependencyTemplate.js

@@ -11,7 +11,8 @@
 /** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./Dependency").RuntimeSpec} RuntimeSpec */
 /** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./InitFragment")} InitFragment */
+/** @typedef {import("./Generator").GenerateContext} GenerateContext */
+/** @template T @typedef {import("./InitFragment")<T>} InitFragment */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
@@ -25,7 +26,7 @@
  * @property {Set<string>} runtimeRequirements the requirements for runtime
  * @property {Module} module current module
  * @property {RuntimeSpec} runtime current runtimes, for which code is generated
- * @property {InitFragment[]} initFragments mutable array of init fragments for the current module
+ * @property {InitFragment<GenerateContext>[]} initFragments mutable array of init fragments for the current module
  * @property {ConcatenationScope=} concatenationScope when in a concatenated module, information about other concatenated modules
  */
 

package/lib/ExternalModule.js

@@ -7,6 +7,8 @@
 
 const { OriginalSource, RawSource } = require("webpack-sources");
 const ConcatenationScope = require("./ConcatenationScope");
+const { UsageState } = require("./ExportsInfo");
+const InitFragment = require("./InitFragment");
 const Module = require("./Module");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const Template = require("./Template");
@@ -22,6 +24,7 @@ const propertyAccess = require("./util/propertyAccess");
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./ExportsInfo")} ExportsInfo */
 /** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
@@ -31,16 +34,28 @@ const propertyAccess = require("./util/propertyAccess");
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("./WebpackError")} WebpackError */
+/** @typedef {import("./javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
 /** @typedef {import("./util/Hash")} Hash */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
 /**
  * @typedef {Object} SourceData
  * @property {boolean=} iife
  * @property {string=} init
  * @property {string} expression
+ * @property {InitFragment<ChunkRenderContext>[]=} chunkInitFragments
+ * @property {ReadonlySet<string>=} runtimeRequirements
  */
 
+const TYPES = new Set(["javascript"]);
+const RUNTIME_REQUIREMENTS = new Set([RuntimeGlobals.module]);
+const RUNTIME_REQUIREMENTS_FOR_SCRIPT = new Set([RuntimeGlobals.loadScript]);
+const RUNTIME_REQUIREMENTS_FOR_MODULE = new Set([
+	RuntimeGlobals.definePropertyGetters
+]);
+const EMPTY_RUNTIME_REQUIREMENTS = new Set([]);
+
 /**
  * @param {string|string[]} variableName the variable name or path
  * @param {string} type the module system
@@ -67,7 +82,7 @@ const getSourceForGlobalVariableExternal = (variableName, type) => {
 const getSourceForCommonJsExternal = moduleAndSpecifiers => {
 	if (!Array.isArray(moduleAndSpecifiers)) {
 		return {
-			expression: `require(${JSON.stringify(moduleAndSpecifiers)});`
+			expression: `require(${JSON.stringify(moduleAndSpecifiers)})`
 		};
 	}
 	const moduleName = moduleAndSpecifiers[0];
@@ -75,7 +90,37 @@ const getSourceForCommonJsExternal = moduleAndSpecifiers => {
 		expression: `require(${JSON.stringify(moduleName)})${propertyAccess(
 			moduleAndSpecifiers,
 			1
-		)};`
+		)}`
+	};
+};
+
+/**
+ * @param {string|string[]} moduleAndSpecifiers the module request
+ * @returns {SourceData} the generated source
+ */
+const getSourceForCommonJsExternalInNodeModule = moduleAndSpecifiers => {
+	const chunkInitFragments = [
+		new InitFragment(
+			'import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "module";\n',
+			InitFragment.STAGE_HARMONY_IMPORTS,
+			0,
+			"external module node-commonjs"
+		)
+	];
+	if (!Array.isArray(moduleAndSpecifiers)) {
+		return {
+			expression: `__WEBPACK_EXTERNAL_createRequire(import.meta.url)(${JSON.stringify(
+				moduleAndSpecifiers
+			)})`,
+			chunkInitFragments
+		};
+	}
+	const moduleName = moduleAndSpecifiers[0];
+	return {
+		expression: `__WEBPACK_EXTERNAL_createRequire(import.meta.url)(${JSON.stringify(
+			moduleName
+		)})${propertyAccess(moduleAndSpecifiers, 1)}`,
+		chunkInitFragments
 	};
 };
 
@@ -112,6 +157,91 @@ const getSourceForImportExternal = (moduleAndSpecifiers, runtimeTemplate) => {
 	};
 };
 
+class ModuleExternalInitFragment extends InitFragment {
+	constructor(id, request) {
+		const identifier = `__WEBPACK_EXTERNAL_MODULE_${Template.toIdentifier(
+			`${id}`
+		)}__`;
+		super(
+			`import * as ${identifier} from ${JSON.stringify(request)};\n`,
+			InitFragment.STAGE_HARMONY_IMPORTS,
+			0,
+			`external module import ${id}`
+		);
+		this._identifier = identifier;
+	}
+
+	getNamespaceIdentifier() {
+		return this._identifier;
+	}
+}
+
+const generateModuleRemapping = (input, exportsInfo, runtime) => {
+	if (exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused) {
+		const properties = [];
+		for (const exportInfo of exportsInfo.orderedExports) {
+			const used = exportInfo.getUsedName(exportInfo.name, runtime);
+			if (!used) continue;
+			const nestedInfo = exportInfo.getNestedExportsInfo();
+			if (nestedInfo) {
+				const nestedExpr = generateModuleRemapping(
+					`${input}${propertyAccess([exportInfo.name])}`,
+					nestedInfo
+				);
+				if (nestedExpr) {
+					properties.push(`[${JSON.stringify(used)}]: y(${nestedExpr})`);
+					continue;
+				}
+			}
+			properties.push(
+				`[${JSON.stringify(used)}]: () => ${input}${propertyAccess([
+					exportInfo.name
+				])}`
+			);
+		}
+		return `x({ ${properties.join(", ")} })`;
+	}
+};
+
+/**
+ * @param {string|number} id the module id
+ * @param {string|string[]} moduleAndSpecifiers the module request
+ * @param {ExportsInfo} exportsInfo exports info of this module
+ * @param {RuntimeSpec} runtime the runtime
+ * @returns {SourceData} the generated source
+ */
+const getSourceForModuleExternal = (
+	id,
+	moduleAndSpecifiers,
+	exportsInfo,
+	runtime
+) => {
+	if (!Array.isArray(moduleAndSpecifiers))
+		moduleAndSpecifiers = [moduleAndSpecifiers];
+	const initFragment = new ModuleExternalInitFragment(
+		id,
+		moduleAndSpecifiers[0]
+	);
+	const baseAccess = `${initFragment.getNamespaceIdentifier()}${propertyAccess(
+		moduleAndSpecifiers,
+		1
+	)}`;
+	const moduleRemapping = generateModuleRemapping(
+		baseAccess,
+		exportsInfo,
+		runtime
+	);
+	let expression = moduleRemapping || baseAccess;
+	return {
+		expression,
+		init: `var x = y => { var x = {}; ${RuntimeGlobals.definePropertyGetters}(x, y); return x; }\nvar y = x => () => x`,
+		runtimeRequirements: moduleRemapping
+			? RUNTIME_REQUIREMENTS_FOR_MODULE
+			: undefined,
+		chunkInitFragments: [initFragment]
+	};
+};
+
 /**
  * @param {string|string[]} urlAndGlobal the script request
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
@@ -144,7 +274,8 @@ const getSourceForScriptExternal = (urlAndGlobal, runtimeTemplate) => {
 			]
 		)}).then(${runtimeTemplate.returningFunction(
 			`${globalName}${propertyAccess(urlAndGlobal, 2)}`
-		)})`
+		)})`,
+		runtimeRequirements: RUNTIME_REQUIREMENTS_FOR_SCRIPT
 	};
 };
 
@@ -210,14 +341,6 @@ const getSourceForDefaultCase = (optional, request, runtimeTemplate) => {
 	};
 };
 
-const TYPES = new Set(["javascript"]);
-const RUNTIME_REQUIREMENTS = new Set([RuntimeGlobals.module]);
-const RUNTIME_REQUIREMENTS_FOR_SCRIPT = new Set([
-	RuntimeGlobals.module,
-	RuntimeGlobals.loadScript
-]);
-const RUNTIME_REQUIREMENTS_CONCATENATED = new Set([]);
-
 class ExternalModule extends Module {
 	constructor(request, type, userRequest) {
 		super("javascript/dynamic", null);
@@ -293,32 +416,49 @@ class ExternalModule extends Module {
 			exportsType: undefined
 		};
 		this.buildInfo = {
-			strict: this.externalType !== "this",
-			topLevelDeclarations: new Set()
+			strict: true,
+			topLevelDeclarations: new Set(),
+			module: compilation.outputOptions.module
 		};
+		const { request, externalType } = this._getRequestAndExternalType();
 		this.buildMeta.exportsType = "dynamic";
 		let canMangle = false;
 		this.clearDependenciesAndBlocks();
-		switch (this.externalType) {
+		switch (externalType) {
+			case "this":
+				this.buildInfo.strict = false;
+				break;
 			case "system":
-				if (!Array.isArray(this.request) || this.request.length === 1) {
+				if (!Array.isArray(request) || request.length === 1) {
 					this.buildMeta.exportsType = "namespace";
 					canMangle = true;
 				}
 				break;
+			case "module":
+				if (this.buildInfo.module) {
+					if (!Array.isArray(request) || request.length === 1) {
+						this.buildMeta.exportsType = "namespace";
+						canMangle = true;
+					}
+				} else {
+					this.buildMeta.async = true;
+					if (!Array.isArray(request) || request.length === 1) {
+						this.buildMeta.exportsType = "namespace";
+						canMangle = false;
+					}
+				}
+				break;
+			case "script":
 			case "promise":
 				this.buildMeta.async = true;
 				break;
 			case "import":
 				this.buildMeta.async = true;
-				if (!Array.isArray(this.request) || this.request.length === 1) {
+				if (!Array.isArray(request) || request.length === 1) {
 					this.buildMeta.exportsType = "namespace";
 					canMangle = false;
 				}
 				break;
-			case "script":
-				this.buildMeta.async = true;
-				break;
 		}
 		this.addDependency(new StaticExportsDependency(true, canMangle));
 		callback();
@@ -341,12 +481,16 @@ class ExternalModule extends Module {
 		return undefined;
 	}
 
-	getSourceData(runtimeTemplate, moduleGraph, chunkGraph) {
-		const request =
-			typeof this.request === "object" && !Array.isArray(this.request)
-				? this.request[this.externalType]
-				: this.request;
-		switch (this.externalType) {
+	_getRequestAndExternalType() {
+		let { request, externalType } = this;
+		if (typeof request === "object" && !Array.isArray(request))
+			request = request[externalType];
+		return { request, externalType };
+	}
+
+	_getSourceData(runtimeTemplate, moduleGraph, chunkGraph, runtime) {
+		const { request, externalType } = this._getRequestAndExternalType();
+		switch (externalType) {
 			case "this":
 			case "window":
 			case "self":
@@ -360,6 +504,10 @@ class ExternalModule extends Module {
 			case "commonjs2":
 			case "commonjs-module":
 				return getSourceForCommonJsExternal(request);
+			case "node-commonjs":
+				return this.buildInfo.module
+					? getSourceForCommonJsExternalInNodeModule(request)
+					: getSourceForCommonJsExternal(request);
 			case "amd":
 			case "amd-require":
 			case "umd":
@@ -377,12 +525,28 @@ class ExternalModule extends Module {
 			case "script":
 				return getSourceForScriptExternal(request, runtimeTemplate);
 			case "module":
+				if (!this.buildInfo.module) {
+					if (!runtimeTemplate.supportsDynamicImport()) {
+						throw new Error(
+							"The target environment doesn't support dynamic import() syntax so it's not possible to use external type 'module' within a script" +
+								(runtimeTemplate.supportsEcmaScriptModuleSyntax()
+									? "\nDid you mean to build a EcmaScript Module ('output.module: true')?"
+									: "")
+						);
+					}
+					return getSourceForImportExternal(request, runtimeTemplate);
+				}
 				if (!runtimeTemplate.supportsEcmaScriptModuleSyntax()) {
 					throw new Error(
 						"The target environment doesn't support EcmaScriptModule syntax so it's not possible to use external type 'module'"
 					);
 				}
-				throw new Error("Module external type is not implemented yet");
+				return getSourceForModuleExternal(
+					chunkGraph.getModuleId(this),
+					request,
+					moduleGraph.getExportsInfo(this),
+					runtime
+				);
 			case "var":
 			case "promise":
 			case "const":
@@ -405,12 +569,14 @@ class ExternalModule extends Module {
 		runtimeTemplate,
 		moduleGraph,
 		chunkGraph,
+		runtime,
 		concatenationScope
 	}) {
-		const sourceData = this.getSourceData(
+		const sourceData = this._getSourceData(
 			runtimeTemplate,
 			moduleGraph,
-			chunkGraph
+			chunkGraph,
+			runtime
 		);
 
 		let sourceString = sourceData.expression;
@@ -428,6 +594,12 @@ class ExternalModule extends Module {
 		}
 		if (sourceData.init) sourceString = `${sourceData.init}\n${sourceString}`;
 
+		let data = undefined;
+		if (sourceData.chunkInitFragments) {
+			data = new Map();
+			data.set("chunkInitFragments", sourceData.chunkInitFragments);
+		}
+
 		const sources = new Map();
 		if (this.useSourceMap || this.useSimpleSourceMap) {
 			sources.set(
@@ -438,13 +610,21 @@ class ExternalModule extends Module {
 			sources.set("javascript", new RawSource(sourceString));
 		}
 
+		let runtimeRequirements = sourceData.runtimeRequirements;
+		if (!concatenationScope) {
+			if (!runtimeRequirements) {
+				runtimeRequirements = RUNTIME_REQUIREMENTS;
+			} else {
+				const set = new Set(runtimeRequirements);
+				set.add(RuntimeGlobals.module);
+				runtimeRequirements = set;
+			}
+		}
+
 		return {
 			sources,
-			runtimeRequirements: concatenationScope
-				? RUNTIME_REQUIREMENTS_CONCATENATED
-				: this.externalType === "script"
-				? RUNTIME_REQUIREMENTS_FOR_SCRIPT
-				: RUNTIME_REQUIREMENTS
+			runtimeRequirements: runtimeRequirements || EMPTY_RUNTIME_REQUIREMENTS,
+			data
 		};
 	}
 

package/lib/ExternalModuleFactoryPlugin.js

@@ -172,13 +172,14 @@ class ExternalModuleFactoryPlugin {
 								cb
 							);
 						} else {
+							const dependencyType = dependency.category || "";
 							const promise = externals(
 								{
 									context,
 									request: dependency.request,
+									dependencyType,
 									contextInfo,
 									getResolve: options => (context, request, callback) => {
-										const dependencyType = dependency.category || "";
 										const resolveContext = {
 											fileDependencies: data.fileDependencies,
 											missingDependencies: data.missingDependencies,

package/lib/InitFragment.js

@@ -30,6 +30,9 @@ const sortFragmentWithIndex = ([a, i], [b, j]) => {
 	return i - j;
 };
 
+/**
+ * @template Context
+ */
 class InitFragment {
 	/**
 	 * @param {string|Source} content the source code that will be included as initialization code
@@ -47,22 +50,22 @@ class InitFragment {
 	}
 
 	/**
-	 * @param {GenerateContext} generateContext context for generate
+	 * @param {Context} context context
 	 * @returns {string|Source} the source code that will be included as initialization code
 	 */
-	getContent(generateContext) {
+	getContent(context) {
 		return this.content;
 	}
 
 	/**
-	 * @param {GenerateContext} generateContext context for generate
+	 * @param {Context} context context
 	 * @returns {string|Source=} the source code that will be included at the end of the module
 	 */
-	getEndContent(generateContext) {
+	getEndContent(context) {
 		return this.endContent;
 	}
 
-	static addToSource(source, initFragments, generateContext) {
+	static addToSource(source, initFragments, context) {
 		if (initFragments.length > 0) {
 			// Sort fragments by position. If 2 fragments have the same position,
 			// use their index.
@@ -104,8 +107,8 @@ class InitFragment {
 				if (Array.isArray(fragment)) {
 					fragment = fragment[0].mergeAll(fragment);
 				}
-				concatSource.add(fragment.getContent(generateContext));
-				const endContent = fragment.getEndContent(generateContext);
+				concatSource.add(fragment.getContent(context));
+				const endContent = fragment.getEndContent(context);
 				if (endContent) {
 					endContents.push(endContent);
 				}

package/lib/MainTemplate.js

@@ -20,7 +20,7 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./Module")} Module} */
 /** @typedef {import("./util/Hash")} Hash} */
 /** @typedef {import("./DependencyTemplates")} DependencyTemplates} */
-/** @typedef {import("./ModuleTemplate").RenderContext} RenderContext} */
+/** @typedef {import("./javascript/JavascriptModulesPlugin").RenderContext} RenderContext} */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate} */
 /** @typedef {import("./ModuleGraph")} ModuleGraph} */
 /** @typedef {import("./ChunkGraph")} ChunkGraph} */

package/lib/ModuleTemplate.js

@@ -22,15 +22,6 @@ const getJavascriptModulesPlugin = memoize(() =>
 	require("./javascript/JavascriptModulesPlugin")
 );
 
-/**
- * @typedef {Object} RenderContext
- * @property {Chunk} chunk the chunk
- * @property {DependencyTemplates} dependencyTemplates the dependency templates
- * @property {RuntimeTemplate} runtimeTemplate the runtime template
- * @property {ModuleGraph} moduleGraph the module graph
- * @property {ChunkGraph} chunkGraph the chunk graph
- */
-
 // TODO webpack 6: remove this class
 class ModuleTemplate {
 	/**

package/lib/NormalModuleFactory.js

@@ -13,8 +13,10 @@ const {
 	SyncHook,
 	HookMap
 } = require("tapable");
+const ChunkGraph = require("./ChunkGraph");
 const Module = require("./Module");
 const ModuleFactory = require("./ModuleFactory");
+const ModuleGraph = require("./ModuleGraph");
 const NormalModule = require("./NormalModule");
 const BasicEffectRulePlugin = require("./rules/BasicEffectRulePlugin");
 const BasicMatcherRulePlugin = require("./rules/BasicMatcherRulePlugin");
@@ -257,8 +259,8 @@ class NormalModuleFactory extends ModuleFactory {
 		this.parserCache = new Map();
 		/** @type {Map<string, WeakMap<Object, Generator>>} */
 		this.generatorCache = new Map();
-		/** @type {WeakSet<Module>} */
-		this._restoredUnsafeCacheEntries = new WeakSet();
+		/** @type {Set<Module>} */
+		this._restoredUnsafeCacheEntries = new Set();
 
 		const cacheParseResource = parseResource.bindCache(
 			associatedObjectForCache
@@ -661,6 +663,14 @@ class NormalModuleFactory extends ModuleFactory {
 		);
 	}
 
+	cleanupForCache() {
+		for (const module of this._restoredUnsafeCacheEntries) {
+			ChunkGraph.clearChunkGraphForModule(module);
+			ModuleGraph.clearModuleGraphForModule(module);
+			module.cleanupForCache();
+		}
+	}
+
 	/**
 	 * @param {ModuleFactoryCreateData} data data object
 	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
@@ -756,6 +766,7 @@ class NormalModuleFactory extends ModuleFactory {
 					if (!unsafeCacheData.has(module)) {
 						unsafeCacheData.set(module, module.getUnsafeCacheData());
 					}
+					this._restoredUnsafeCacheEntries.add(module);
 				}
 
 				callback(null, factoryResult);