webpack 5.54.0 → 5.56.1

package/lib/Compiler.js

@@ -40,9 +40,10 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
 /** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
 /** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
-/** @typedef {import("./MemCache")} MemCache */
 /** @typedef {import("./Module")} Module */
+/** @typedef {import("./util/WeakTupleMap")} WeakTupleMap */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("./util/fs").IntermediateFileSystem} IntermediateFileSystem */
 /** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */
@@ -248,7 +249,7 @@ class Compiler {
 
 		this.cache = new Cache();
 
-		/** @type {WeakMap<Module, { hash: string, memCache: MemCache }> | undefined} */
+		/** @type {WeakMap<Module, { hash: string, references: WeakMap<Dependency, Module>, memCache: WeakTupleMap }> | undefined} */
 		this.moduleMemCaches = undefined;
 
 		this.compilerPath = "";
@@ -1035,9 +1036,9 @@ ${other}`);
 		return !!this.parentCompilation;
 	}
 
-	createCompilation() {
+	createCompilation(params) {
 		this._cleanupLastCompilation();
-		return (this._lastCompilation = new Compilation(this));
+		return (this._lastCompilation = new Compilation(this, params));
 	}
 
 	/**
@@ -1045,7 +1046,7 @@ ${other}`);
 	 * @returns {Compilation} the created compilation
 	 */
 	newCompilation(params) {
-		const compilation = this.createCompilation();
+		const compilation = this.createCompilation(params);
 		compilation.name = this.name;
 		compilation.records = this.records;
 		this.hooks.thisCompilation.call(compilation, params);

package/lib/DefinePlugin.js

@@ -13,7 +13,7 @@ const {
 	evaluateToString,
 	toConstantDependency
 } = require("./javascript/JavascriptParserHelpers");
-const { provide } = require("./util/MapHelpers");
+const createHash = require("./util/createHash");
 
 /** @typedef {import("estree").Expression} Expression */
 /** @typedef {import("./Compiler")} Compiler */
@@ -250,7 +250,7 @@ const toCacheVersion = code => {
 };
 
 const VALUE_DEP_PREFIX = "webpack/DefinePlugin ";
-const VALUE_DEP_MAIN = "webpack/DefinePlugin";
+const VALUE_DEP_MAIN = "webpack/DefinePlugin_hash";
 
 class DefinePlugin {
 	/**
@@ -286,12 +286,11 @@ class DefinePlugin {
 				);
 				const { runtimeTemplate } = compilation;
 
-				const mainValue = /** @type {Set<string>} */ (
-					provide(
-						compilation.valueCacheVersions,
-						VALUE_DEP_MAIN,
-						() => new Set()
-					)
+				const mainHash = createHash(compilation.outputOptions.hashFunction);
+				mainHash.update(
+					/** @type {string} */ (
+						compilation.valueCacheVersions.get(VALUE_DEP_MAIN)
+					) || ""
 				);
 
 				/**
@@ -300,6 +299,7 @@ class DefinePlugin {
 				 * @returns {void}
 				 */
 				const handler = parser => {
+					const mainValue = compilation.valueCacheVersions.get(VALUE_DEP_MAIN);
 					parser.hooks.program.tap("DefinePlugin", () => {
 						const { buildInfo } = parser.state.module;
 						if (!buildInfo.valueDependencies)
@@ -565,7 +565,7 @@ class DefinePlugin {
 						const code = definitions[key];
 						const version = toCacheVersion(code);
 						const name = VALUE_DEP_PREFIX + prefix + key;
-						mainValue.add(name);
+						mainHash.update("|" + prefix + key);
 						const oldVersion = compilation.valueCacheVersions.get(name);
 						if (oldVersion === undefined) {
 							compilation.valueCacheVersions.set(name, version);
@@ -589,6 +589,11 @@ class DefinePlugin {
 				};
 
 				walkDefinitionsForValues(definitions, "");
+
+				compilation.valueCacheVersions.set(
+					VALUE_DEP_MAIN,
+					/** @type {string} */ (mainHash.digest("hex").slice(0, 8))
+				);
 			}
 		);
 	}

package/lib/Dependency.js

@@ -78,6 +78,8 @@ const memoize = require("./util/memoize");
  * @property {boolean=} canMangle when false, referenced export can not be mangled, defaults to true
  */
 
+const TRANSITIVE = Symbol("transitive");
+
 const getIgnoredModule = memoize(() => {
 	const RawModule = require("./RawModule");
 	return new RawModule("/* (ignored) */", `ignored`, `(ignored)`);
@@ -175,6 +177,13 @@ class Dependency {
 		return null;
 	}
 
+	/**
+	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
+	 */
+	couldAffectReferencingModule() {
+		return TRANSITIVE;
+	}
+
 	/**
 	 * Returns the referenced module and export
 	 * @deprecated
@@ -322,4 +331,6 @@ Object.defineProperty(Dependency.prototype, "disconnect", {
 	}
 });
 
+Dependency.TRANSITIVE = TRANSITIVE;
+
 module.exports = Dependency;

package/lib/FlagDependencyExportsPlugin.js

@@ -28,7 +28,6 @@ class FlagDependencyExportsPlugin {
 			compilation => {
 				const moduleGraph = compilation.moduleGraph;
 				const cache = compilation.getCache("FlagDependencyExportsPlugin");
-				const { moduleMemCaches } = compilation;
 				compilation.hooks.finishModules.tapAsync(
 					"FlagDependencyExportsPlugin",
 					(modules, callback) => {
@@ -42,6 +41,8 @@ class FlagDependencyExportsPlugin {
 						let statNotCached = 0;
 						let statQueueItemsProcessed = 0;
 
+						const { moduleMemCaches } = compilation;
+
 						/** @type {Queue<Module>} */
 						const queue = new Queue();
 
@@ -68,12 +69,10 @@ class FlagDependencyExportsPlugin {
 									return callback();
 								}
 								const memCache = moduleMemCaches && moduleMemCaches.get(module);
-								const memCacheValue = memCache && memCache.get(this, module);
+								const memCacheValue = memCache && memCache.get(this);
 								if (memCacheValue !== undefined) {
 									statRestoredFromMemCache++;
-									moduleGraph
-										.getExportsInfo(module)
-										.restoreProvided(memCacheValue);
+									exportsInfo.restoreProvided(memCacheValue);
 									return callback();
 								}
 								cache.get(
@@ -84,9 +83,7 @@ class FlagDependencyExportsPlugin {
 
 										if (result !== undefined) {
 											statRestoredFromCache++;
-											moduleGraph
-												.getExportsInfo(module)
-												.restoreProvided(result);
+											exportsInfo.restoreProvided(result);
 										} else {
 											statNotCached++;
 											// Without cached info enqueue module for determining the exports
@@ -102,9 +99,7 @@ class FlagDependencyExportsPlugin {
 								if (err) return callback(err);
 
 								/** @type {Set<Module>} */
-								const modulesToStorePersistent = new Set();
-								/** @type {Set<Module>} */
-								const modulesToStoreTransient = new Set();
+								const modulesToStore = new Set();
 
 								/** @type {Map<Module, Set<Module>>} */
 								const dependencies = new Map();
@@ -338,9 +333,7 @@ class FlagDependencyExportsPlugin {
 									}
 
 									if (cacheable) {
-										modulesToStorePersistent.add(module);
-									} else {
-										modulesToStoreTransient.add(module);
+										modulesToStore.add(module);
 									}
 
 									if (changed) {
@@ -366,7 +359,7 @@ class FlagDependencyExportsPlugin {
 
 								logger.time("store provided exports into cache");
 								asyncLib.each(
-									modulesToStorePersistent,
+									modulesToStore,
 									(module, callback) => {
 										if (typeof module.buildInfo.hash !== "string") {
 											// not cacheable
@@ -378,7 +371,7 @@ class FlagDependencyExportsPlugin {
 										const memCache =
 											moduleMemCaches && moduleMemCaches.get(module);
 										if (memCache) {
-											memCache.set(this, module, cachedData);
+											memCache.set(this, cachedData);
 										}
 										cache.store(
 											module.identifier(),
@@ -389,17 +382,6 @@ class FlagDependencyExportsPlugin {
 									},
 									err => {
 										logger.timeEnd("store provided exports into cache");
-										if (moduleMemCaches) {
-											for (const module of modulesToStoreTransient) {
-												const memCache = moduleMemCaches.get(module);
-												if (memCache) {
-													const cachedData = moduleGraph
-														.getExportsInfo(module)
-														.getRestoreProvidedData();
-													memCache.set(this, module, cachedData);
-												}
-											}
-										}
 										callback(err);
 									}
 								);

package/lib/ModuleFactory.js

@@ -15,6 +15,7 @@
  * @property {Set<string>=} fileDependencies
  * @property {Set<string>=} contextDependencies
  * @property {Set<string>=} missingDependencies
+ * @property {boolean=} cacheable allow to use the unsafe cache
  */
 
 /**

package/lib/ModuleGraph.js

@@ -79,19 +79,19 @@ class ModuleGraphModule {
 		this.profile = undefined;
 		/** @type {boolean} */
 		this.async = false;
+		/** @type {ModuleGraphConnection[]} */
+		this._unassignedConnections = undefined;
 	}
 }
 
 class ModuleGraph {
 	constructor() {
-		/** @type {Map<Dependency, ModuleGraphConnection>} */
-		this._dependencyMap = new Map();
+		/** @type {WeakMap<Dependency, ModuleGraphConnection>} */
+		this._dependencyMap = new WeakMap();
 		/** @type {Map<Module, ModuleGraphModule>} */
 		this._moduleMap = new Map();
-		/** @type {Map<Module, Set<ModuleGraphConnection>>} */
-		this._originMap = new Map();
-		/** @type {Map<any, Object>} */
-		this._metaMap = new Map();
+		/** @type {WeakMap<any, Object>} */
+		this._metaMap = new WeakMap();
 
 		// Caching
 		this._cacheModuleGraphModuleKey1 = undefined;
@@ -103,6 +103,9 @@ class ModuleGraph {
 
 		/** @type {WeakTupleMap<any[], any>} */
 		this._cache = undefined;
+
+		/** @type {WeakMap<Module, WeakTupleMap<any, any>>} */
+		this._moduleMemCaches = undefined;
 	}
 
 	/**
@@ -168,14 +171,21 @@ class ModuleGraph {
 			dependency.weak,
 			dependency.getCondition(this)
 		);
-		this._dependencyMap.set(dependency, connection);
 		const connections = this._getModuleGraphModule(module).incomingConnections;
 		connections.add(connection);
-		const mgm = this._getModuleGraphModule(originModule);
-		if (mgm.outgoingConnections === undefined) {
-			mgm.outgoingConnections = new Set();
+		if (originModule) {
+			const mgm = this._getModuleGraphModule(originModule);
+			if (mgm._unassignedConnections === undefined) {
+				mgm._unassignedConnections = [];
+			}
+			mgm._unassignedConnections.push(connection);
+			if (mgm.outgoingConnections === undefined) {
+				mgm.outgoingConnections = new Set();
+			}
+			mgm.outgoingConnections.add(connection);
+		} else {
+			this._dependencyMap.set(dependency, connection);
 		}
-		mgm.outgoingConnections.add(connection);
 	}
 
 	/**
@@ -184,7 +194,7 @@ class ModuleGraph {
 	 * @returns {void}
 	 */
 	updateModule(dependency, module) {
-		const connection = this._dependencyMap.get(dependency);
+		const connection = this.getConnection(dependency);
 		if (connection.module === module) return;
 		const newConnection = connection.clone();
 		newConnection.module = module;
@@ -201,12 +211,12 @@ class ModuleGraph {
 	 * @returns {void}
 	 */
 	removeConnection(dependency) {
-		const connection = this._dependencyMap.get(dependency);
+		const connection = this.getConnection(dependency);
 		const targetMgm = this._getModuleGraphModule(connection.module);
 		targetMgm.incomingConnections.delete(connection);
 		const originMgm = this._getModuleGraphModule(connection.originModule);
 		originMgm.outgoingConnections.delete(connection);
-		this._dependencyMap.delete(dependency);
+		this._dependencyMap.set(dependency, null);
 	}
 
 	/**
@@ -215,7 +225,7 @@ class ModuleGraph {
 	 * @returns {void}
 	 */
 	addExplanation(dependency, explanation) {
-		const connection = this._dependencyMap.get(dependency);
+		const connection = this.getConnection(dependency);
 		connection.addExplanation(explanation);
 	}
 
@@ -341,7 +351,7 @@ class ModuleGraph {
 	 * @returns {Module} the referenced module
 	 */
 	getResolvedModule(dependency) {
-		const connection = this._dependencyMap.get(dependency);
+		const connection = this.getConnection(dependency);
 		return connection !== undefined ? connection.resolvedModule : null;
 	}
 
@@ -351,7 +361,30 @@ class ModuleGraph {
 	 */
 	getConnection(dependency) {
 		const connection = this._dependencyMap.get(dependency);
-		return connection;
+		if (connection === undefined) {
+			const module = this.getParentModule(dependency);
+			if (module !== undefined) {
+				const mgm = this._getModuleGraphModule(module);
+				if (
+					mgm._unassignedConnections &&
+					mgm._unassignedConnections.length !== 0
+				) {
+					let foundConnection;
+					for (const connection of mgm._unassignedConnections) {
+						this._dependencyMap.set(connection.dependency, connection);
+						if (connection.dependency === dependency)
+							foundConnection = connection;
+					}
+					mgm._unassignedConnections.length = 0;
+					if (foundConnection !== undefined) {
+						return foundConnection;
+					}
+				}
+			}
+			this._dependencyMap.set(dependency, null);
+			return undefined;
+		}
+		return connection === null ? undefined : connection;
 	}
 
 	/**
@@ -359,7 +392,7 @@ class ModuleGraph {
 	 * @returns {Module} the referenced module
 	 */
 	getModule(dependency) {
-		const connection = this._dependencyMap.get(dependency);
+		const connection = this.getConnection(dependency);
 		return connection !== undefined ? connection.module : null;
 	}
 
@@ -368,7 +401,7 @@ class ModuleGraph {
 	 * @returns {Module} the referencing module
 	 */
 	getOrigin(dependency) {
-		const connection = this._dependencyMap.get(dependency);
+		const connection = this.getConnection(dependency);
 		return connection !== undefined ? connection.originModule : null;
 	}
 
@@ -377,7 +410,7 @@ class ModuleGraph {
 	 * @returns {Module} the original referencing module
 	 */
 	getResolvedOrigin(dependency) {
-		const connection = this._dependencyMap.get(dependency);
+		const connection = this.getConnection(dependency);
 		return connection !== undefined ? connection.resolvedOriginModule : null;
 	}
 
@@ -669,12 +702,17 @@ class ModuleGraph {
 		return this._metaMap.get(thing);
 	}
 
-	freeze() {
+	/**
+	 * @param {string=} cacheStage a persistent stage name for caching
+	 */
+	freeze(cacheStage) {
 		this._cache = new WeakTupleMap();
+		this._cacheStage = cacheStage;
 	}
 
 	unfreeze() {
 		this._cache = undefined;
+		this._cacheStage = undefined;
 	}
 
 	/**
@@ -689,6 +727,37 @@ class ModuleGraph {
 		return this._cache.provide(fn, ...args, () => fn(this, ...args));
 	}
 
+	/**
+	 * @param {WeakMap<Module, WeakTupleMap<any, any>>} moduleMemCaches mem caches for modules for better caching
+	 */
+	setModuleMemCaches(moduleMemCaches) {
+		this._moduleMemCaches = moduleMemCaches;
+	}
+
+	/**
+	 * @param {Dependency} dependency dependency
+	 * @param {...any} args arguments, last argument is a function called with moduleGraph, dependency, ...args
+	 * @returns {any} computed value or cached
+	 */
+	dependencyCacheProvide(dependency, ...args) {
+		/** @type {(moduleGraph: ModuleGraph, dependency: Dependency, ...args: any[]) => any} */
+		const fn = args.pop();
+		if (this._moduleMemCaches && this._cacheStage) {
+			const memCache = this._moduleMemCaches.get(
+				this.getParentModule(dependency)
+			);
+			if (memCache !== undefined) {
+				return memCache.provide(dependency, this._cacheStage, ...args, () =>
+					fn(this, dependency, ...args)
+				);
+			}
+		}
+		if (this._cache === undefined) return fn(this, dependency, ...args);
+		return this._cache.provide(dependency, ...args, () =>
+			fn(this, dependency, ...args)
+		);
+	}
+
 	// TODO remove in webpack 6
 	/**
 	 * @param {Module} module the module

package/lib/NormalModuleFactory.js

@@ -167,12 +167,6 @@ const deprecationChangedHookMessage = (name, hook) => {
 	);
 };
 
-/** @type {WeakMap<ModuleDependency, ModuleFactoryResult & { module: { restoreFromUnsafeCache: Function }}>} */
-const unsafeCacheDependencies = new WeakMap();
-
-/** @type {WeakMap<Module, object>} */
-const unsafeCacheData = new WeakMap();
-
 const ruleSetCompiler = new RuleSetCompiler([
 	new BasicMatcherRulePlugin("test", "resource"),
 	new BasicMatcherRulePlugin("scheme"),
@@ -256,11 +250,6 @@ class NormalModuleFactory extends ModuleFactory {
 				rules: options.rules
 			}
 		]);
-		this.unsafeCache = !!options.unsafeCache;
-		this.cachePredicate =
-			typeof options.unsafeCache === "function"
-				? options.unsafeCache
-				: () => true;
 		this.context = context || "";
 		this.fs = fs;
 		this._globalParserOptions = options.parser;
@@ -745,18 +734,6 @@ class NormalModuleFactory extends ModuleFactory {
 	 */
 	create(data, callback) {
 		const dependencies = /** @type {ModuleDependency[]} */ (data.dependencies);
-		if (this.unsafeCache) {
-			const cacheEntry = unsafeCacheDependencies.get(dependencies[0]);
-			if (cacheEntry) {
-				const { module } = cacheEntry;
-				if (!this._restoredUnsafeCacheEntries.has(module)) {
-					const data = unsafeCacheData.get(module);
-					module.restoreFromUnsafeCache(data, this);
-					this._restoredUnsafeCacheEntries.add(module);
-				}
-				return callback(null, cacheEntry);
-			}
-		}
 		const context = data.context || this.context;
 		const resolveOptions = data.resolveOptions || EMPTY_RESOLVE_OPTIONS;
 		const dependency = dependencies[0];
@@ -788,7 +765,8 @@ class NormalModuleFactory extends ModuleFactory {
 				return callback(err, {
 					fileDependencies,
 					missingDependencies,
-					contextDependencies
+					contextDependencies,
+					cacheable: false
 				});
 			}
 
@@ -797,7 +775,8 @@ class NormalModuleFactory extends ModuleFactory {
 				return callback(null, {
 					fileDependencies,
 					missingDependencies,
-					contextDependencies
+					contextDependencies,
+					cacheable: resolveData.cacheable
 				});
 			}
 
@@ -814,7 +793,8 @@ class NormalModuleFactory extends ModuleFactory {
 					return callback(err, {
 						fileDependencies,
 						missingDependencies,
-						contextDependencies
+						contextDependencies,
+						cacheable: false
 					});
 				}
 
@@ -822,25 +802,10 @@ class NormalModuleFactory extends ModuleFactory {
 					module,
 					fileDependencies,
 					missingDependencies,
-					contextDependencies
+					contextDependencies,
+					cacheable: resolveData.cacheable
 				};
 
-				if (
-					this.unsafeCache &&
-					resolveData.cacheable &&
-					module &&
-					module.restoreFromUnsafeCache &&
-					this.cachePredicate(module)
-				) {
-					for (const d of dependencies) {
-						unsafeCacheDependencies.set(d, factoryResult);
-					}
-					if (!unsafeCacheData.has(module)) {
-						unsafeCacheData.set(module, module.getUnsafeCacheData());
-					}
-					this._restoredUnsafeCacheEntries.add(module);
-				}
-
 				callback(null, factoryResult);
 			});
 		});

package/lib/dependencies/CommonJsExportRequireDependency.js

@@ -18,6 +18,7 @@ const processExportInfo = require("./processExportInfo");
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
 /** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
@@ -43,6 +44,13 @@ class CommonJsExportRequireDependency extends ModuleDependency {
 		return "cjs export require";
 	}
 
+	/**
+	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
+	 */
+	couldAffectReferencingModule() {
+		return Dependency.TRANSITIVE;
+	}
+
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @returns {string[]} the imported id
@@ -332,15 +340,17 @@ CommonJsExportRequireDependency.Template = class CommonJsExportRequireDependency
 			weak: dep.weak,
 			runtimeRequirements
 		});
-		const ids = dep.getIds(moduleGraph);
-		const usedImported = moduleGraph
-			.getExportsInfo(importedModule)
-			.getUsedName(ids, runtime);
-		if (usedImported) {
-			const comment = equals(usedImported, ids)
-				? ""
-				: Template.toNormalComment(propertyAccess(ids)) + " ";
-			requireExpr += `${comment}${propertyAccess(usedImported)}`;
+		if (importedModule) {
+			const ids = dep.getIds(moduleGraph);
+			const usedImported = moduleGraph
+				.getExportsInfo(importedModule)
+				.getUsedName(ids, runtime);
+			if (usedImported) {
+				const comment = equals(usedImported, ids)
+					? ""
+					: Template.toNormalComment(propertyAccess(ids)) + " ";
+				requireExpr += `${comment}${propertyAccess(usedImported)}`;
+			}
 		}
 
 		switch (type) {

package/lib/dependencies/CommonJsFullRequireDependency.js

@@ -108,15 +108,17 @@ CommonJsFullRequireDependency.Template = class CommonJsFullRequireDependencyTemp
 			weak: dep.weak,
 			runtimeRequirements
 		});
-		const ids = dep.names;
-		const usedImported = moduleGraph
-			.getExportsInfo(importedModule)
-			.getUsedName(ids, runtime);
-		if (usedImported) {
-			const comment = equals(usedImported, ids)
-				? ""
-				: Template.toNormalComment(propertyAccess(ids)) + " ";
-			requireExpr += `${comment}${propertyAccess(usedImported)}`;
+		if (importedModule) {
+			const ids = dep.names;
+			const usedImported = moduleGraph
+				.getExportsInfo(importedModule)
+				.getUsedName(ids, runtime);
+			if (usedImported) {
+				const comment = equals(usedImported, ids)
+					? ""
+					: Template.toNormalComment(propertyAccess(ids)) + " ";
+				requireExpr += `${comment}${propertyAccess(usedImported)}`;
+			}
 		}
 		source.replace(dep.range[0], dep.range[1] - 1, requireExpr);
 	}

package/lib/dependencies/ContextDependency.js

@@ -11,6 +11,7 @@ const makeSerializable = require("../util/makeSerializable");
 const memoize = require("../util/memoize");
 
 /** @typedef {import("../ContextModule").ContextOptions} ContextOptions */
+/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../WebpackError")} WebpackError */
 
@@ -54,6 +55,13 @@ class ContextDependency extends Dependency {
 		return "commonjs";
 	}
 
+	/**
+	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
+	 */
+	couldAffectReferencingModule() {
+		return true;
+	}
+
 	/**
 	 * @returns {string | null} an identifier to merge equal requests
 	 */