@depup/webpack 5.110.1-depup.0 → 5.111.1-depup.0

package/lib/cache/MemoryCachePlugin.js

@@ -31,13 +31,13 @@ class MemoryCachePlugin {
 				const cacheEntry = cache.get(identifier);
 				// A recorded miss: the whole chain was asked for this identifier already.
 				if (cacheEntry === null) return null;
-				// Etags are compared by identity — a lazy one is interned per source
-				// object, so equal content reached through a second object is a
+				// WHY: etags are compared by identity, and a lazy one is interned per
+				// source object, so equal content reached through a second object is a
 				// different etag. Hashing to tell those apart would cost every hit what
 				// laziness saves, so a mismatch falls through to the next stage instead:
 				// the file cache compares etags by value and can still answer. Returning
-				// `null` here would bail the hook and lose that (`Cache.get` maps it to
-				// `undefined` regardless, so it buys the caller nothing).
+				// `null` here would bail the hook and lose that, and `Cache.get` maps it
+				// to `undefined` regardless, so it buys the caller nothing.
 				if (cacheEntry !== undefined && cacheEntry.etag === etag) {
 					return cacheEntry.data;
 				}

package/lib/cache/MemoryWithGcCachePlugin.js

@@ -79,10 +79,9 @@ class MemoryWithGcCachePlugin {
 					continue;
 				}
 				if (entry !== undefined) {
-					// We don't delete the cache entry, but set it to undefined instead
-					// This reserves the location in the data table and avoids rehashing
-					// when constantly adding and removing entries.
-					// It will be deleted when removed from oldCache.
+					// Set to undefined rather than deleted, reserving the slot and sparing
+					// a rehash as entries come and go. It goes for good once `oldCache`
+					// drops it.
 					cache.set(identifier, undefined);
 					oldCache.delete(identifier);
 					oldCache.set(identifier, {
@@ -105,13 +104,13 @@ class MemoryWithGcCachePlugin {
 				const cacheEntry = cache.get(identifier);
 				// A recorded miss: the whole chain was asked for this identifier already.
 				if (cacheEntry === null) return null;
-				// Etags are compared by identity — a lazy one is interned per source
-				// object, so equal content reached through a second object is a
+				// WHY: etags are compared by identity, and a lazy one is interned per
+				// source object, so equal content reached through a second object is a
 				// different etag. Hashing to tell those apart would cost every hit what
 				// laziness saves, so a mismatch falls through to the next stage instead:
 				// the file cache compares etags by value and can still answer. Returning
-				// `null` here would bail the hook and lose that (`Cache.get` maps it to
-				// `undefined` regardless, so it buys the caller nothing).
+				// `null` here would bail the hook and lose that, and `Cache.get` maps it
+				// to `undefined` regardless, so it buys the caller nothing.
 				let known = cacheEntry !== undefined;
 				if (cacheEntry !== undefined) {
 					if (cacheEntry.etag === etag) return cacheEntry.data;

package/lib/cache/PackFileCacheStrategy.js

@@ -901,24 +901,9 @@ makeSerializable(
 /** @typedef {(() => Promise<PackContentItems> | PackContentItems) & Partial<{ options: { size?: number } }>} LazyFunction */
 
 class PackContent {
-	/*
-		This class can be in these states:
-		   |   this.lazy    | this.content | this.outdated | state
-		A1 |   undefined    |     Map      |     false     | fresh content
-		A2 |   undefined    |     Map      |     true      | (will not happen)
-		B1 | lazy () => {}  |  undefined   |     false     | not deserialized
-		B2 | lazy () => {}  |  undefined   |     true      | not deserialized, but some items has been removed
-		C1 | lazy* () => {} |     Map      |     false     | deserialized
-		C2 | lazy* () => {} |     Map      |     true      | deserialized, and some items has been removed
-
-		this.used is a subset of this.items.
-		this.items is a subset of this.content.keys() resp. this.lazy().map.keys()
-		When this.outdated === false, this.items === this.content.keys() resp. this.lazy().map.keys()
-		When this.outdated === true, this.items should be used to recreated this.lazy/this.content.
-		When this.lazy and this.content is set, they contain the same data.
-		this.get must only be called with a valid item from this.items.
-		In state C this.lazy is unMemoized
-	*/
+	// `used` is a subset of `items`, itself a subset of the content's keys, and the
+	// two coincide while `outdated` is false. `lazy` and `content` hold the same
+	// data whenever both are set, and `get` takes only an item of `items`.
 
 	/**
 	 * Creates an instance of PackContent.
@@ -1263,6 +1248,8 @@ class PackFileCacheStrategy {
 		this.buildDependencies = new Set();
 		/** @type {FileSystemDependencies} */
 		this.newBuildDependencies = new LazySet();
+		/** @type {FileSystemDependencies} */
+		this.newOptionalBuildDependencies = new LazySet();
 		/** @type {InstanceType<Snapshot> | undefined} */
 		this.resolveBuildDependenciesSnapshot = undefined;
 		/** @type {ResolveResults | undefined} */
@@ -1492,10 +1479,13 @@ class PackFileCacheStrategy {
 	/**
 	 * Stores build dependencies.
 	 * @param {FileSystemDependencies | Iterable<string>} dependencies dependencies to store
+	 * @param {FileSystemDependencies | Iterable<string>} optionalDependencies optional dependencies to store
+	 * @returns {void}
 	 */
-	storeBuildDependencies(dependencies) {
+	storeBuildDependencies(dependencies, optionalDependencies) {
 		if (this.readonly) return;
 		this.newBuildDependencies.addAll(dependencies);
+		this.newOptionalBuildDependencies.addAll(optionalDependencies);
 	}
 
 	afterAllStored() {
@@ -1512,9 +1502,14 @@ class PackFileCacheStrategy {
 				let promise;
 				/** @type {Set<string>} */
 				const newBuildDependencies = new Set();
+				/** @type {Set<string>} */
+				const optionalBuildDependencies = new Set();
 				for (const dep of this.newBuildDependencies) {
 					if (!this.buildDependencies.has(dep)) {
 						newBuildDependencies.add(dep);
+						if (this.newOptionalBuildDependencies.has(dep)) {
+							optionalBuildDependencies.add(dep);
+						}
 					}
 				}
 				if (newBuildDependencies.size > 0 || !this.buildSnapshot) {
@@ -1533,6 +1528,7 @@ class PackFileCacheStrategy {
 							this.fileSystemInfo.resolveBuildDependencies(
 								this.context,
 								newBuildDependencies,
+								optionalBuildDependencies,
 								(err, result) => {
 									this.logger.timeEnd("resolve build dependencies");
 									if (err) return reject(err);
@@ -1667,6 +1663,7 @@ class PackFileCacheStrategy {
 								this.buildDependencies.add(dep);
 							}
 							this.newBuildDependencies.clear();
+							this.newOptionalBuildDependencies.clear();
 							this.logger.timeEnd("store pack");
 							const stats = pack.getContentStats();
 							this.logger.log(
@@ -1887,6 +1884,7 @@ class PackFileCacheStrategy {
 		this.fileSystemInfo.clear();
 		this.buildDependencies.clear();
 		this.newBuildDependencies.clear();
+		this.newOptionalBuildDependencies.clear();
 		this.resolveBuildDependenciesSnapshot = undefined;
 		this.resolveResults = undefined;
 		this.buildSnapshot = undefined;

package/lib/cache/getLazyHashedEtag.js

@@ -42,11 +42,9 @@ class LazyHashedEtag {
 			/** @type {HashableObject} */
 			(this._obj).updateHash(hash);
 			this._hash = hash.digest("base64");
-			// Drop the captured object once the hash is memoized. The hash is
-			// never reset, so we never need `_obj` again — and many callers
-			// (e.g. `SourceMapDevToolPlugin`, `RealContentHashPlugin`) capture
-			// a heavy `CachedSource` here that would otherwise stay reachable
-			// through this etag for the lifetime of the compilation cache.
+			// Drop the captured object once the hash is memoized: the hash never
+			// resets, and callers often capture a heavy `CachedSource` that would
+			// otherwise stay reachable for the compilation cache's lifetime.
 			this._obj = undefined;
 		}
 		return this._hash;

package/lib/config/browserslistTargetHandler.js

@@ -422,12 +422,25 @@ const resolve = (browsers) => {
 			ios_saf: [15, 4],
 			samsung: 17,
 			android: 93,
-			// and_qq: Not supported
-			// baidu: Not supported
-			// and_uc: Not supported
-			// kaios: Not supported
+			// and_qq, baidu, and_uc and kaios are not supported.
 			node: [16, 9]
 		}),
+		topLevelAwait: rawChecker({
+			chrome: 89,
+			and_chr: 89,
+			edge: 89,
+			firefox: 89,
+			and_ff: 89,
+			// ie: Not supported,
+			opera: 75,
+			op_mob: 63,
+			safari: 15,
+			ios_saf: 15,
+			samsung: 15,
+			android: 89,
+			// and_qq, baidu, and_uc and kaios are not supported.
+			node: [14, 8]
+		}),
 		spread: rawChecker({
 			chrome: 60,
 			and_chr: 60,