webpack 5.53.0 → 5.56.0

package/lib/FileSystemInfo.js

@@ -16,6 +16,7 @@ const processAsyncTree = require("./util/processAsyncTree");
 
 /** @typedef {import("./WebpackError")} WebpackError */
 /** @typedef {import("./logging/Logger").Logger} Logger */
+/** @typedef {typeof import("./util/Hash")} Hash */
 /** @typedef {import("./util/fs").IStats} IStats */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
@@ -453,12 +454,14 @@ class SnapshotOptimization {
 	 * @param {function(Snapshot): boolean} has has value
 	 * @param {function(Snapshot): Map<string, T> | Set<string>} get get value
 	 * @param {function(Snapshot, Map<string, T> | Set<string>): void} set set value
+	 * @param {boolean=} useStartTime use the start time of snapshots
 	 * @param {boolean=} isSet value is an Set instead of a Map
 	 */
-	constructor(has, get, set, isSet = false) {
+	constructor(has, get, set, useStartTime = true, isSet = false) {
 		this._has = has;
 		this._get = get;
 		this._set = set;
+		this._useStartTime = useStartTime;
 		this._isSet = isSet;
 		/** @type {Map<string, SnapshotOptimizationEntry>} */
 		this._map = new Map();
@@ -488,24 +491,12 @@ class SnapshotOptimization {
 		this._statReusedSharedSnapshots = 0;
 	}
 
-	storeUnsharedSnapshot(snapshot, locations) {
-		if (locations === undefined) return;
-		const optimizationEntry = {
-			snapshot,
-			shared: 0,
-			snapshotContent: undefined,
-			children: undefined
-		};
-		for (const path of locations) {
-			this._map.set(path, optimizationEntry);
-		}
-	}
-
-	optimize(capturedFiles, startTime, children) {
-		/** @type {Set<string>} */
-		const unsetOptimizationEntries = new Set();
-		/** @type {Set<SnapshotOptimizationEntry>} */
-		const checkedOptimizationEntries = new Set();
+	/**
+	 * @param {Snapshot} newSnapshot snapshot
+	 * @param {Set<string>} capturedFiles files to snapshot/share
+	 * @returns {void}
+	 */
+	optimize(newSnapshot, capturedFiles) {
 		/**
 		 * @param {SnapshotOptimizationEntry} entry optimization entry
 		 * @returns {void}
@@ -530,22 +521,43 @@ class SnapshotOptimization {
 				capturedFiles.delete(path);
 			}
 		};
+
+		/** @type {SnapshotOptimizationEntry} */
+		let newOptimizationEntry = undefined;
+
 		const capturedFilesSize = capturedFiles.size;
-		capturedFiles: for (const path of capturedFiles) {
+
+		/** @type {Set<SnapshotOptimizationEntry> | undefined} */
+		const optimizationEntries = new Set();
+
+		for (const path of capturedFiles) {
 			const optimizationEntry = this._map.get(path);
 			if (optimizationEntry === undefined) {
-				unsetOptimizationEntries.add(path);
+				if (newOptimizationEntry === undefined) {
+					newOptimizationEntry = {
+						snapshot: newSnapshot,
+						shared: 0,
+						snapshotContent: undefined,
+						children: undefined
+					};
+				}
+				this._map.set(path, newOptimizationEntry);
 				continue;
+			} else {
+				optimizationEntries.add(optimizationEntry);
 			}
-			if (checkedOptimizationEntries.has(optimizationEntry)) continue;
+		}
+
+		optimizationEntries: for (const optimizationEntry of optimizationEntries) {
 			const snapshot = optimizationEntry.snapshot;
 			if (optimizationEntry.shared > 0) {
 				// It's a shared snapshot
 				// We can't change it, so we can only use it when all files match
 				// and startTime is compatible
 				if (
-					startTime &&
-					(!snapshot.startTime || snapshot.startTime > startTime)
+					this._useStartTime &&
+					newSnapshot.startTime &&
+					(!snapshot.startTime || snapshot.startTime > newSnapshot.startTime)
 				) {
 					continue;
 				}
@@ -557,8 +569,7 @@ class SnapshotOptimization {
 						if (!snapshotEntries.has(path)) {
 							// File is not shared and can't be removed from the snapshot
 							// because it's in a child of the snapshot
-							checkedOptimizationEntries.add(optimizationEntry);
-							continue capturedFiles;
+							continue optimizationEntries;
 						}
 						nonSharedFiles.add(path);
 						continue;
@@ -567,7 +578,7 @@ class SnapshotOptimization {
 				if (nonSharedFiles.size === 0) {
 					// The complete snapshot is shared
 					// add it as child
-					children.add(snapshot);
+					newSnapshot.addChild(snapshot);
 					increaseSharedAndStoreOptimizationEntry(optimizationEntry);
 					this._statReusedSharedSnapshots++;
 				} else {
@@ -575,8 +586,7 @@ class SnapshotOptimization {
 					const sharedCount = snapshotContent.size - nonSharedFiles.size;
 					if (sharedCount < MIN_COMMON_SNAPSHOT_SIZE) {
 						// Common part it too small
-						checkedOptimizationEntries.add(optimizationEntry);
-						continue capturedFiles;
+						continue optimizationEntries;
 					}
 					// Extract common timestamps from both snapshots
 					let commonMap;
@@ -598,9 +608,11 @@ class SnapshotOptimization {
 					}
 					// Create and attach snapshot
 					const commonSnapshot = new Snapshot();
-					commonSnapshot.setMergedStartTime(startTime, snapshot);
+					if (this._useStartTime) {
+						commonSnapshot.setMergedStartTime(newSnapshot.startTime, snapshot);
+					}
 					this._set(commonSnapshot, commonMap);
-					children.add(commonSnapshot);
+					newSnapshot.addChild(commonSnapshot);
 					snapshot.addChild(commonSnapshot);
 					// Create optimization entry
 					const newEntry = {
@@ -620,6 +632,10 @@ class SnapshotOptimization {
 				// We can extract a common shared snapshot
 				// with all common files
 				const snapshotEntries = this._get(snapshot);
+				if (snapshotEntries === undefined) {
+					// Incomplete snapshot, that can't be used
+					continue optimizationEntries;
+				}
 				let commonMap;
 				if (this._isSet) {
 					commonMap = new Set();
@@ -645,14 +661,15 @@ class SnapshotOptimization {
 
 				if (commonMap.size < MIN_COMMON_SNAPSHOT_SIZE) {
 					// Common part it too small
-					checkedOptimizationEntries.add(optimizationEntry);
-					continue capturedFiles;
+					continue optimizationEntries;
 				}
 				// Create and attach snapshot
 				const commonSnapshot = new Snapshot();
-				commonSnapshot.setMergedStartTime(startTime, snapshot);
+				if (this._useStartTime) {
+					commonSnapshot.setMergedStartTime(newSnapshot.startTime, snapshot);
+				}
 				this._set(commonSnapshot, commonMap);
-				children.add(commonSnapshot);
+				newSnapshot.addChild(commonSnapshot);
 				snapshot.addChild(commonSnapshot);
 				// Remove files from snapshot
 				for (const path of commonMap.keys()) snapshotEntries.delete(path);
@@ -668,12 +685,10 @@ class SnapshotOptimization {
 				});
 				this._statSharedSnapshots++;
 			}
-			checkedOptimizationEntries.add(optimizationEntry);
 		}
 		const unshared = capturedFiles.size;
 		this._statItemsUnshared += unshared;
 		this._statItemsShared += capturedFilesSize - unshared;
-		return unsetOptimizationEntries;
 	}
 }
 
@@ -842,12 +857,22 @@ class FileSystemInfo {
 	 * @param {Iterable<string>=} options.managedPaths paths that are only managed by a package manager
 	 * @param {Iterable<string>=} options.immutablePaths paths that are immutable
 	 * @param {Logger=} options.logger logger used to log invalid snapshots
+	 * @param {string | Hash=} options.hashFunction the hash function to use
 	 */
-	constructor(fs, { managedPaths = [], immutablePaths = [], logger } = {}) {
+	constructor(
+		fs,
+		{
+			managedPaths = [],
+			immutablePaths = [],
+			logger,
+			hashFunction = "md4"
+		} = {}
+	) {
 		this.fs = fs;
 		this.logger = logger;
 		this._remainingLogs = logger ? 40 : 0;
 		this._loggedPaths = logger ? new Set() : undefined;
+		this._hashFunction = hashFunction;
 		/** @type {WeakMap<Snapshot, boolean | (function(WebpackError=, boolean=): void)[]>} */
 		this._snapshotCache = new WeakMap();
 		this._fileTimestampsOptimization = new SnapshotOptimization(
@@ -858,7 +883,8 @@ class FileSystemInfo {
 		this._fileHashesOptimization = new SnapshotOptimization(
 			s => s.hasFileHashes(),
 			s => s.fileHashes,
-			(s, v) => s.setFileHashes(v)
+			(s, v) => s.setFileHashes(v),
+			false
 		);
 		this._fileTshsOptimization = new SnapshotOptimization(
 			s => s.hasFileTshs(),
@@ -873,7 +899,8 @@ class FileSystemInfo {
 		this._contextHashesOptimization = new SnapshotOptimization(
 			s => s.hasContextHashes(),
 			s => s.contextHashes,
-			(s, v) => s.setContextHashes(v)
+			(s, v) => s.setContextHashes(v),
+			false
 		);
 		this._contextTshsOptimization = new SnapshotOptimization(
 			s => s.hasContextTshs(),
@@ -883,29 +910,34 @@ class FileSystemInfo {
 		this._missingExistenceOptimization = new SnapshotOptimization(
 			s => s.hasMissingExistence(),
 			s => s.missingExistence,
-			(s, v) => s.setMissingExistence(v)
+			(s, v) => s.setMissingExistence(v),
+			false
 		);
 		this._managedItemInfoOptimization = new SnapshotOptimization(
 			s => s.hasManagedItemInfo(),
 			s => s.managedItemInfo,
-			(s, v) => s.setManagedItemInfo(v)
+			(s, v) => s.setManagedItemInfo(v),
+			false
 		);
 		this._managedFilesOptimization = new SnapshotOptimization(
 			s => s.hasManagedFiles(),
 			s => s.managedFiles,
 			(s, v) => s.setManagedFiles(v),
+			false,
 			true
 		);
 		this._managedContextsOptimization = new SnapshotOptimization(
 			s => s.hasManagedContexts(),
 			s => s.managedContexts,
 			(s, v) => s.setManagedContexts(v),
+			false,
 			true
 		);
 		this._managedMissingOptimization = new SnapshotOptimization(
 			s => s.hasManagedMissing(),
 			s => s.managedMissing,
 			(s, v) => s.setManagedMissing(v),
+			false,
 			true
 		);
 		/** @type {StackedCacheMap<string, FileSystemInfoEntry | "ignore" | null>} */
@@ -1869,22 +1901,8 @@ class FileSystemInfo {
 		/** @type {Set<Snapshot>} */
 		const children = new Set();
 
-		/** @type {Set<string>} */
-		let unsharedFileTimestamps;
-		/** @type {Set<string>} */
-		let unsharedFileHashes;
-		/** @type {Set<string>} */
-		let unsharedFileTshs;
-		/** @type {Set<string>} */
-		let unsharedContextTimestamps;
-		/** @type {Set<string>} */
-		let unsharedContextHashes;
-		/** @type {Set<string>} */
-		let unsharedContextTshs;
-		/** @type {Set<string>} */
-		let unsharedMissingExistence;
-		/** @type {Set<string>} */
-		let unsharedManagedItemInfo;
+		const snapshot = new Snapshot();
+		if (startTime) snapshot.setStartTime(startTime);
 
 		/** @type {Set<string>} */
 		const managedItems = new Set();
@@ -1895,101 +1913,41 @@ class FileSystemInfo {
 		let jobs = 1;
 		const jobDone = () => {
 			if (--jobs === 0) {
-				const snapshot = new Snapshot();
-				if (startTime) snapshot.setStartTime(startTime);
 				if (fileTimestamps.size !== 0) {
 					snapshot.setFileTimestamps(fileTimestamps);
-					this._fileTimestampsOptimization.storeUnsharedSnapshot(
-						snapshot,
-						unsharedFileTimestamps
-					);
 				}
 				if (fileHashes.size !== 0) {
 					snapshot.setFileHashes(fileHashes);
-					this._fileHashesOptimization.storeUnsharedSnapshot(
-						snapshot,
-						unsharedFileHashes
-					);
 				}
 				if (fileTshs.size !== 0) {
 					snapshot.setFileTshs(fileTshs);
-					this._fileTshsOptimization.storeUnsharedSnapshot(
-						snapshot,
-						unsharedFileTshs
-					);
 				}
 				if (contextTimestamps.size !== 0) {
 					snapshot.setContextTimestamps(contextTimestamps);
-					this._contextTimestampsOptimization.storeUnsharedSnapshot(
-						snapshot,
-						unsharedContextTimestamps
-					);
 				}
 				if (contextHashes.size !== 0) {
 					snapshot.setContextHashes(contextHashes);
-					this._contextHashesOptimization.storeUnsharedSnapshot(
-						snapshot,
-						unsharedContextHashes
-					);
 				}
 				if (contextTshs.size !== 0) {
 					snapshot.setContextTshs(contextTshs);
-					this._contextTshsOptimization.storeUnsharedSnapshot(
-						snapshot,
-						unsharedContextTshs
-					);
 				}
 				if (missingExistence.size !== 0) {
 					snapshot.setMissingExistence(missingExistence);
-					this._missingExistenceOptimization.storeUnsharedSnapshot(
-						snapshot,
-						unsharedMissingExistence
-					);
 				}
 				if (managedItemInfo.size !== 0) {
 					snapshot.setManagedItemInfo(managedItemInfo);
-					this._managedItemInfoOptimization.storeUnsharedSnapshot(
-						snapshot,
-						unsharedManagedItemInfo
-					);
 				}
-				const unsharedManagedFiles = this._managedFilesOptimization.optimize(
-					managedFiles,
-					undefined,
-					children
-				);
+				this._managedFilesOptimization.optimize(snapshot, managedFiles);
 				if (managedFiles.size !== 0) {
 					snapshot.setManagedFiles(managedFiles);
-					this._managedFilesOptimization.storeUnsharedSnapshot(
-						snapshot,
-						unsharedManagedFiles
-					);
 				}
-				const unsharedManagedContexts =
-					this._managedContextsOptimization.optimize(
-						managedContexts,
-						undefined,
-						children
-					);
+				this._managedContextsOptimization.optimize(snapshot, managedContexts);
 				if (managedContexts.size !== 0) {
 					snapshot.setManagedContexts(managedContexts);
-					this._managedContextsOptimization.storeUnsharedSnapshot(
-						snapshot,
-						unsharedManagedContexts
-					);
 				}
-				const unsharedManagedMissing =
-					this._managedMissingOptimization.optimize(
-						managedMissing,
-						undefined,
-						children
-					);
+				this._managedMissingOptimization.optimize(snapshot, managedMissing);
 				if (managedMissing.size !== 0) {
 					snapshot.setManagedMissing(managedMissing);
-					this._managedMissingOptimization.storeUnsharedSnapshot(
-						snapshot,
-						unsharedManagedMissing
-					);
 				}
 				if (children.size !== 0) {
 					snapshot.setChildren(children);
@@ -2037,11 +1995,7 @@ class FileSystemInfo {
 			const capturedFiles = captureNonManaged(files, managedFiles);
 			switch (mode) {
 				case 3:
-					unsharedFileTshs = this._fileTshsOptimization.optimize(
-						capturedFiles,
-						undefined,
-						children
-					);
+					this._fileTshsOptimization.optimize(snapshot, capturedFiles);
 					for (const path of capturedFiles) {
 						const cache = this._fileTshs.get(path);
 						if (cache !== undefined) {
@@ -2065,11 +2019,7 @@ class FileSystemInfo {
 					}
 					break;
 				case 2:
-					unsharedFileHashes = this._fileHashesOptimization.optimize(
-						capturedFiles,
-						undefined,
-						children
-					);
+					this._fileHashesOptimization.optimize(snapshot, capturedFiles);
 					for (const path of capturedFiles) {
 						const cache = this._fileHashes.get(path);
 						if (cache !== undefined) {
@@ -2093,11 +2043,7 @@ class FileSystemInfo {
 					}
 					break;
 				case 1:
-					unsharedFileTimestamps = this._fileTimestampsOptimization.optimize(
-						capturedFiles,
-						startTime,
-						children
-					);
+					this._fileTimestampsOptimization.optimize(snapshot, capturedFiles);
 					for (const path of capturedFiles) {
 						const cache = this._fileTimestamps.get(path);
 						if (cache !== undefined) {
@@ -2131,11 +2077,7 @@ class FileSystemInfo {
 			);
 			switch (mode) {
 				case 3:
-					unsharedContextTshs = this._contextTshsOptimization.optimize(
-						capturedDirectories,
-						undefined,
-						children
-					);
+					this._contextTshsOptimization.optimize(snapshot, capturedDirectories);
 					for (const path of capturedDirectories) {
 						const cache = this._contextTshs.get(path);
 						let resolved;
@@ -2168,10 +2110,9 @@ class FileSystemInfo {
 					}
 					break;
 				case 2:
-					unsharedContextHashes = this._contextHashesOptimization.optimize(
-						capturedDirectories,
-						undefined,
-						children
+					this._contextHashesOptimization.optimize(
+						snapshot,
+						capturedDirectories
 					);
 					for (const path of capturedDirectories) {
 						const cache = this._contextHashes.get(path);
@@ -2205,12 +2146,10 @@ class FileSystemInfo {
 					}
 					break;
 				case 1:
-					unsharedContextTimestamps =
-						this._contextTimestampsOptimization.optimize(
-							capturedDirectories,
-							startTime,
-							children
-						);
+					this._contextTimestampsOptimization.optimize(
+						snapshot,
+						capturedDirectories
+					);
 					for (const path of capturedDirectories) {
 						const cache = this._contextTimestamps.get(path);
 						let resolved;
@@ -2246,11 +2185,7 @@ class FileSystemInfo {
 		}
 		if (missing) {
 			const capturedMissing = captureNonManaged(missing, managedMissing);
-			unsharedMissingExistence = this._missingExistenceOptimization.optimize(
-				capturedMissing,
-				startTime,
-				children
-			);
+			this._missingExistenceOptimization.optimize(snapshot, capturedMissing);
 			for (const path of capturedMissing) {
 				const cache = this._fileTimestamps.get(path);
 				if (cache !== undefined) {
@@ -2275,11 +2210,7 @@ class FileSystemInfo {
 				}
 			}
 		}
-		unsharedManagedItemInfo = this._managedItemInfoOptimization.optimize(
-			managedItems,
-			undefined,
-			children
-		);
+		this._managedItemInfoOptimization.optimize(snapshot, managedItems);
 		for (const path of managedItems) {
 			const cache = this._managedItems.get(path);
 			if (cache !== undefined) {
@@ -2873,7 +2804,7 @@ class FileSystemInfo {
 				return callback(err);
 			}
 
-			const hash = createHash("md4");
+			const hash = createHash(this._hashFunction);
 
 			hash.update(content);
 
@@ -3056,7 +2987,7 @@ class FileSystemInfo {
 				reduce: (files, tsEntries) => {
 					let symlinks = undefined;
 
-					const hash = createHash("md4");
+					const hash = createHash(this._hashFunction);
 
 					for (const file of files) hash.update(file);
 					let safeTime = 0;
@@ -3124,7 +3055,7 @@ class FileSystemInfo {
 			},
 			err => {
 				if (err) return callback(err);
-				const hash = createHash("md4");
+				const hash = createHash(this._hashFunction);
 				hash.update(entry.timestampHash);
 				if (entry.safeTime) {
 					safeTime = Math.max(safeTime, entry.safeTime);
@@ -3174,7 +3105,7 @@ class FileSystemInfo {
 				 */
 				reduce: (files, fileHashes) => {
 					let symlinks = undefined;
-					const hash = createHash("md4");
+					const hash = createHash(this._hashFunction);
 
 					for (const file of files) hash.update(file);
 					for (const entry of fileHashes) {
@@ -3223,7 +3154,7 @@ class FileSystemInfo {
 			},
 			err => {
 				if (err) return callback(err);
-				const hash = createHash("md4");
+				const hash = createHash(this._hashFunction);
 				hash.update(entry.hash);
 				hashes.sort();
 				for (const h of hashes) {
@@ -3301,8 +3232,8 @@ class FileSystemInfo {
 						reduce: (files, results) => {
 							let symlinks = undefined;
 
-							const tsHash = createHash("md4");
-							const hash = createHash("md4");
+							const tsHash = createHash(this._hashFunction);
+							const hash = createHash(this._hashFunction);
 
 							for (const file of files) {
 								tsHash.update(file);
@@ -3380,8 +3311,8 @@ class FileSystemInfo {
 			},
 			err => {
 				if (err) return callback(err);
-				const hash = createHash("md4");
-				const tsHash = createHash("md4");
+				const hash = createHash(this._hashFunction);
+				const tsHash = createHash(this._hashFunction);
 				hash.update(entry.hash);
 				if (entry.timestampHash) tsHash.update(entry.timestampHash);
 				if (entry.safeTime) {

package/lib/FlagDependencyExportsPlugin.js

@@ -34,12 +34,15 @@ class FlagDependencyExportsPlugin {
 						const logger = compilation.getLogger(
 							"webpack.FlagDependencyExportsPlugin"
 						);
+						let statRestoredFromMemCache = 0;
 						let statRestoredFromCache = 0;
 						let statNoExports = 0;
 						let statFlaggedUncached = 0;
 						let statNotCached = 0;
 						let statQueueItemsProcessed = 0;
 
+						const { moduleMemCaches } = compilation;
+
 						/** @type {Queue<Module>} */
 						const queue = new Queue();
 
@@ -58,16 +61,20 @@ class FlagDependencyExportsPlugin {
 										return callback();
 									}
 								}
-								if (
-									module.buildInfo.cacheable !== true ||
-									typeof module.buildInfo.hash !== "string"
-								) {
+								if (typeof module.buildInfo.hash !== "string") {
 									statFlaggedUncached++;
 									// Enqueue uncacheable module for determining the exports
 									queue.enqueue(module);
 									exportsInfo.setHasProvideInfo();
 									return callback();
 								}
+								const memCache = moduleMemCaches && moduleMemCaches.get(module);
+								const memCacheValue = memCache && memCache.get(this);
+								if (memCacheValue !== undefined) {
+									statRestoredFromMemCache++;
+									exportsInfo.restoreProvided(memCacheValue);
+									return callback();
+								}
 								cache.get(
 									module.identifier(),
 									module.buildInfo.hash,
@@ -76,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
@@ -340,11 +345,12 @@ class FlagDependencyExportsPlugin {
 								logger.log(
 									`${Math.round(
 										(100 * (statFlaggedUncached + statNotCached)) /
-											(statRestoredFromCache +
+											(statRestoredFromMemCache +
+												statRestoredFromCache +
 												statNotCached +
 												statFlaggedUncached +
 												statNoExports)
-									)}% of exports of modules have been determined (${statNoExports} no declared exports, ${statNotCached} not cached, ${statFlaggedUncached} flagged uncacheable, ${statRestoredFromCache} from cache, ${
+									)}% of exports of modules have been determined (${statNoExports} no declared exports, ${statNotCached} not cached, ${statFlaggedUncached} flagged uncacheable, ${statRestoredFromCache} from cache, ${statRestoredFromMemCache} from mem cache, ${
 										statQueueItemsProcessed -
 										statNotCached -
 										statFlaggedUncached
@@ -355,19 +361,22 @@ class FlagDependencyExportsPlugin {
 								asyncLib.each(
 									modulesToStore,
 									(module, callback) => {
-										if (
-											module.buildInfo.cacheable !== true ||
-											typeof module.buildInfo.hash !== "string"
-										) {
+										if (typeof module.buildInfo.hash !== "string") {
 											// not cacheable
 											return callback();
 										}
+										const cachedData = moduleGraph
+											.getExportsInfo(module)
+											.getRestoreProvidedData();
+										const memCache =
+											moduleMemCaches && moduleMemCaches.get(module);
+										if (memCache) {
+											memCache.set(this, cachedData);
+										}
 										cache.store(
 											module.identifier(),
 											module.buildInfo.hash,
-											moduleGraph
-												.getExportsInfo(module)
-												.getRestoreProvidedData(),
+											cachedData,
 											callback
 										);
 									},

package/lib/JavascriptMetaInfoPlugin.js

@@ -28,7 +28,12 @@ class JavascriptMetaInfoPlugin {
 					parser.hooks.call.for("eval").tap("JavascriptMetaInfoPlugin", () => {
 						parser.state.module.buildInfo.moduleConcatenationBailout = "eval()";
 						parser.state.module.buildInfo.usingEval = true;
-						InnerGraph.bailout(parser.state);
+						const currentSymbol = InnerGraph.getTopLevelSymbol(parser.state);
+						if (currentSymbol) {
+							InnerGraph.addUsage(parser.state, null, currentSymbol);
+						} else {
+							InnerGraph.bailout(parser.state);
+						}
 					});
 					parser.hooks.finish.tap("JavascriptMetaInfoPlugin", () => {
 						let topLevelDeclarations =

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
  */
 
 /**