webpack 5.99.6 → 5.99.7

package/lib/prefetch/ChunkPrefetchPreloadPlugin.js

@@ -15,83 +15,82 @@ const ChunkPreloadTriggerRuntimeModule = require("./ChunkPreloadTriggerRuntimeMo
 /** @typedef {import("../ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */
 /** @typedef {import("../Compiler")} Compiler */
 
+const PLUGIN_NAME = "ChunkPrefetchPreloadPlugin";
+
 class ChunkPrefetchPreloadPlugin {
 	/**
 	 * @param {Compiler} compiler the compiler
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"ChunkPrefetchPreloadPlugin",
-			compilation => {
-				compilation.hooks.additionalChunkRuntimeRequirements.tap(
-					"ChunkPrefetchPreloadPlugin",
-					(chunk, set, { chunkGraph }) => {
-						if (chunkGraph.getNumberOfEntryModules(chunk) === 0) return;
-						const startupChildChunks = chunk.getChildrenOfTypeInOrder(
-							chunkGraph,
-							"prefetchOrder"
+		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+			compilation.hooks.additionalChunkRuntimeRequirements.tap(
+				PLUGIN_NAME,
+				(chunk, set, { chunkGraph }) => {
+					if (chunkGraph.getNumberOfEntryModules(chunk) === 0) return;
+					const startupChildChunks = chunk.getChildrenOfTypeInOrder(
+						chunkGraph,
+						"prefetchOrder"
+					);
+					if (startupChildChunks) {
+						set.add(RuntimeGlobals.prefetchChunk);
+						set.add(RuntimeGlobals.onChunksLoaded);
+						set.add(RuntimeGlobals.exports);
+						compilation.addRuntimeModule(
+							chunk,
+							new ChunkPrefetchStartupRuntimeModule(startupChildChunks)
 						);
-						if (startupChildChunks) {
-							set.add(RuntimeGlobals.prefetchChunk);
-							set.add(RuntimeGlobals.onChunksLoaded);
-							set.add(RuntimeGlobals.exports);
-							compilation.addRuntimeModule(
-								chunk,
-								new ChunkPrefetchStartupRuntimeModule(startupChildChunks)
-							);
-						}
 					}
-				);
-				compilation.hooks.additionalTreeRuntimeRequirements.tap(
-					"ChunkPrefetchPreloadPlugin",
-					(chunk, set, { chunkGraph }) => {
-						const chunkMap = chunk.getChildIdsByOrdersMap(chunkGraph);
+				}
+			);
+			compilation.hooks.additionalTreeRuntimeRequirements.tap(
+				PLUGIN_NAME,
+				(chunk, set, { chunkGraph }) => {
+					const chunkMap = chunk.getChildIdsByOrdersMap(chunkGraph);
 
-						if (chunkMap.prefetch) {
-							set.add(RuntimeGlobals.prefetchChunk);
-							compilation.addRuntimeModule(
-								chunk,
-								new ChunkPrefetchTriggerRuntimeModule(chunkMap.prefetch)
-							);
-						}
-						if (chunkMap.preload) {
-							set.add(RuntimeGlobals.preloadChunk);
-							compilation.addRuntimeModule(
-								chunk,
-								new ChunkPreloadTriggerRuntimeModule(chunkMap.preload)
-							);
-						}
-					}
-				);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.prefetchChunk)
-					.tap("ChunkPrefetchPreloadPlugin", (chunk, set) => {
+					if (chunkMap.prefetch) {
+						set.add(RuntimeGlobals.prefetchChunk);
 						compilation.addRuntimeModule(
 							chunk,
-							new ChunkPrefetchFunctionRuntimeModule(
-								"prefetch",
-								RuntimeGlobals.prefetchChunk,
-								RuntimeGlobals.prefetchChunkHandlers
-							)
+							new ChunkPrefetchTriggerRuntimeModule(chunkMap.prefetch)
 						);
-						set.add(RuntimeGlobals.prefetchChunkHandlers);
-					});
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.preloadChunk)
-					.tap("ChunkPrefetchPreloadPlugin", (chunk, set) => {
+					}
+					if (chunkMap.preload) {
+						set.add(RuntimeGlobals.preloadChunk);
 						compilation.addRuntimeModule(
 							chunk,
-							new ChunkPrefetchFunctionRuntimeModule(
-								"preload",
-								RuntimeGlobals.preloadChunk,
-								RuntimeGlobals.preloadChunkHandlers
-							)
+							new ChunkPreloadTriggerRuntimeModule(chunkMap.preload)
 						);
-						set.add(RuntimeGlobals.preloadChunkHandlers);
-					});
-			}
-		);
+					}
+				}
+			);
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.prefetchChunk)
+				.tap(PLUGIN_NAME, (chunk, set) => {
+					compilation.addRuntimeModule(
+						chunk,
+						new ChunkPrefetchFunctionRuntimeModule(
+							"prefetch",
+							RuntimeGlobals.prefetchChunk,
+							RuntimeGlobals.prefetchChunkHandlers
+						)
+					);
+					set.add(RuntimeGlobals.prefetchChunkHandlers);
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.preloadChunk)
+				.tap(PLUGIN_NAME, (chunk, set) => {
+					compilation.addRuntimeModule(
+						chunk,
+						new ChunkPrefetchFunctionRuntimeModule(
+							"preload",
+							RuntimeGlobals.preloadChunk,
+							RuntimeGlobals.preloadChunkHandlers
+						)
+					);
+					set.add(RuntimeGlobals.preloadChunkHandlers);
+				});
+		});
 	}
 }
 

package/lib/runtime/StartupChunkDependenciesPlugin.js

@@ -18,6 +18,8 @@ const StartupEntrypointRuntimeModule = require("./StartupEntrypointRuntimeModule
  * @property {boolean=} asyncChunkLoading
  */
 
+const PLUGIN_NAME = "StartupChunkDependenciesPlugin";
+
 class StartupChunkDependenciesPlugin {
 	/**
 	 * @param {Options} options options
@@ -36,53 +38,48 @@ class StartupChunkDependenciesPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"StartupChunkDependenciesPlugin",
-			compilation => {
-				const globalChunkLoading = compilation.outputOptions.chunkLoading;
-				/**
-				 * @param {Chunk} chunk chunk to check
-				 * @returns {boolean} true, when the plugin is enabled for the chunk
-				 */
-				const isEnabledForChunk = chunk => {
-					const options = chunk.getEntryOptions();
-					const chunkLoading =
-						options && options.chunkLoading !== undefined
-							? options.chunkLoading
-							: globalChunkLoading;
-					return chunkLoading === this.chunkLoading;
-				};
-				compilation.hooks.additionalTreeRuntimeRequirements.tap(
-					"StartupChunkDependenciesPlugin",
-					(chunk, set, { chunkGraph }) => {
-						if (!isEnabledForChunk(chunk)) return;
-						if (chunkGraph.hasChunkEntryDependentChunks(chunk)) {
-							set.add(RuntimeGlobals.startup);
-							set.add(RuntimeGlobals.ensureChunk);
-							set.add(RuntimeGlobals.ensureChunkIncludeEntries);
-							compilation.addRuntimeModule(
-								chunk,
-								new StartupChunkDependenciesRuntimeModule(
-									this.asyncChunkLoading
-								)
-							);
-						}
-					}
-				);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.startupEntrypoint)
-					.tap("StartupChunkDependenciesPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.require);
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, compilation => {
+			const globalChunkLoading = compilation.outputOptions.chunkLoading;
+			/**
+			 * @param {Chunk} chunk chunk to check
+			 * @returns {boolean} true, when the plugin is enabled for the chunk
+			 */
+			const isEnabledForChunk = chunk => {
+				const options = chunk.getEntryOptions();
+				const chunkLoading =
+					options && options.chunkLoading !== undefined
+						? options.chunkLoading
+						: globalChunkLoading;
+				return chunkLoading === this.chunkLoading;
+			};
+			compilation.hooks.additionalTreeRuntimeRequirements.tap(
+				PLUGIN_NAME,
+				(chunk, set, { chunkGraph }) => {
+					if (!isEnabledForChunk(chunk)) return;
+					if (chunkGraph.hasChunkEntryDependentChunks(chunk)) {
+						set.add(RuntimeGlobals.startup);
 						set.add(RuntimeGlobals.ensureChunk);
 						set.add(RuntimeGlobals.ensureChunkIncludeEntries);
 						compilation.addRuntimeModule(
 							chunk,
-							new StartupEntrypointRuntimeModule(this.asyncChunkLoading)
+							new StartupChunkDependenciesRuntimeModule(this.asyncChunkLoading)
 						);
-					});
-			}
-		);
+					}
+				}
+			);
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.startupEntrypoint)
+				.tap(PLUGIN_NAME, (chunk, set) => {
+					if (!isEnabledForChunk(chunk)) return;
+					set.add(RuntimeGlobals.require);
+					set.add(RuntimeGlobals.ensureChunk);
+					set.add(RuntimeGlobals.ensureChunkIncludeEntries);
+					compilation.addRuntimeModule(
+						chunk,
+						new StartupEntrypointRuntimeModule(this.asyncChunkLoading)
+					);
+				});
+		});
 	}
 }
 

package/lib/schemes/DataUriPlugin.js

@@ -37,6 +37,8 @@ const decodeDataURI = uri => {
 	}
 };
 
+const PLUGIN_NAME = "DataUriPlugin";
+
 class DataUriPlugin {
 	/**
 	 * Apply the plugin
@@ -45,11 +47,11 @@ class DataUriPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"DataUriPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				normalModuleFactory.hooks.resolveForScheme
 					.for("data")
-					.tap("DataUriPlugin", resourceData => {
+					.tap(PLUGIN_NAME, resourceData => {
 						const match = URIRegEx.exec(resourceData.resource);
 						if (match) {
 							resourceData.data.mimetype = match[1] || "";
@@ -60,7 +62,7 @@ class DataUriPlugin {
 					});
 				NormalModule.getCompilationHooks(compilation)
 					.readResourceForScheme.for("data")
-					.tap("DataUriPlugin", resource => decodeDataURI(resource));
+					.tap(PLUGIN_NAME, resource => decodeDataURI(resource));
 			}
 		);
 	}

package/lib/schemes/FileUriPlugin.js

@@ -10,6 +10,8 @@ const { NormalModule } = require("..");
 
 /** @typedef {import("../Compiler")} Compiler */
 
+const PLUGIN_NAME = "FileUriPlugin";
+
 class FileUriPlugin {
 	/**
 	 * Apply the plugin
@@ -18,11 +20,11 @@ class FileUriPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"FileUriPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				normalModuleFactory.hooks.resolveForScheme
 					.for("file")
-					.tap("FileUriPlugin", resourceData => {
+					.tap(PLUGIN_NAME, resourceData => {
 						const url = new URL(resourceData.resource);
 						const path = fileURLToPath(url);
 						const query = url.search;
@@ -36,7 +38,7 @@ class FileUriPlugin {
 				const hooks = NormalModule.getCompilationHooks(compilation);
 				hooks.readResource
 					.for(undefined)
-					.tapAsync("FileUriPlugin", (loaderContext, callback) => {
+					.tapAsync(PLUGIN_NAME, (loaderContext, callback) => {
 						const { resourcePath } = loaderContext;
 						loaderContext.addDependency(resourcePath);
 						loaderContext.fs.readFile(resourcePath, callback);

package/lib/schemes/HttpUriPlugin.js

@@ -405,6 +405,8 @@ const cachedWithKey = (fn, forceFn = fn) => {
 /** @typedef {FetchResultMeta & { entry: LockfileEntry, content: Buffer }} ContentFetchResult */
 /** @typedef {RedirectFetchResult | ContentFetchResult} FetchResult */
 
+const PLUGIN_NAME = "HttpUriPlugin";
+
 class HttpUriPlugin {
 	/**
 	 * @param {HttpUriPluginOptions} options options
@@ -440,14 +442,14 @@ class HttpUriPlugin {
 		/** @type {LockfileCache} */
 		let lockfileCache;
 		compiler.hooks.compilation.tap(
-			"HttpUriPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				const intermediateFs =
 					/** @type {IntermediateFileSystem} */
 					(compiler.intermediateFileSystem);
 				const fs = compilation.inputFileSystem;
-				const cache = compilation.getCache("webpack.HttpUriPlugin");
-				const logger = compilation.getLogger("webpack.HttpUriPlugin");
+				const cache = compilation.getCache(`webpack.${PLUGIN_NAME}`);
+				const logger = compilation.getLogger(`webpack.${PLUGIN_NAME}`);
 				/** @type {string} */
 				const lockfileLocation =
 					this._lockfileLocation ||
@@ -1154,19 +1156,16 @@ Run build with un-frozen lockfile to automatically fix lockfile.`
 					};
 					normalModuleFactory.hooks.resolveForScheme
 						.for(scheme)
-						.tapAsync(
-							"HttpUriPlugin",
-							(resourceData, resolveData, callback) => {
-								respondWithUrlModule(
-									new URL(resourceData.resource),
-									resourceData,
-									callback
-								);
-							}
-						);
+						.tapAsync(PLUGIN_NAME, (resourceData, resolveData, callback) => {
+							respondWithUrlModule(
+								new URL(resourceData.resource),
+								resourceData,
+								callback
+							);
+						});
 					normalModuleFactory.hooks.resolveInScheme
 						.for(scheme)
-						.tapAsync("HttpUriPlugin", (resourceData, data, callback) => {
+						.tapAsync(PLUGIN_NAME, (resourceData, data, callback) => {
 							// Only handle relative urls (./xxx, ../xxx, /xxx, //xxx)
 							if (
 								data.dependencyType !== "url" &&
@@ -1183,7 +1182,7 @@ Run build with un-frozen lockfile to automatically fix lockfile.`
 					const hooks = NormalModule.getCompilationHooks(compilation);
 					hooks.readResourceForScheme
 						.for(scheme)
-						.tapAsync("HttpUriPlugin", (resource, module, callback) =>
+						.tapAsync(PLUGIN_NAME, (resource, module, callback) =>
 							getInfo(resource, (err, _result) => {
 								if (err) return callback(err);
 								const result = /** @type {Info} */ (_result);
@@ -1192,33 +1191,27 @@ Run build with un-frozen lockfile to automatically fix lockfile.`
 								callback(null, result.content);
 							})
 						);
-					hooks.needBuild.tapAsync(
-						"HttpUriPlugin",
-						(module, context, callback) => {
-							if (
-								module.resource &&
-								module.resource.startsWith(`${scheme}://`)
-							) {
-								getInfo(module.resource, (err, _result) => {
-									if (err) return callback(err);
-									const result = /** @type {Info} */ (_result);
-									if (
-										result.entry.integrity !==
-										/** @type {BuildInfo} */
-										(module.buildInfo).resourceIntegrity
-									) {
-										return callback(null, true);
-									}
-									callback();
-								});
-							} else {
-								return callback();
-							}
+					hooks.needBuild.tapAsync(PLUGIN_NAME, (module, context, callback) => {
+						if (module.resource && module.resource.startsWith(`${scheme}://`)) {
+							getInfo(module.resource, (err, _result) => {
+								if (err) return callback(err);
+								const result = /** @type {Info} */ (_result);
+								if (
+									result.entry.integrity !==
+									/** @type {BuildInfo} */
+									(module.buildInfo).resourceIntegrity
+								) {
+									return callback(null, true);
+								}
+								callback();
+							});
+						} else {
+							return callback();
 						}
-					);
+					});
 				}
 				compilation.hooks.finishModules.tapAsync(
-					"HttpUriPlugin",
+					PLUGIN_NAME,
 					(modules, callback) => {
 						if (!lockfileUpdates) return callback();
 						const ext = extname(lockfileLocation);

package/lib/serialization/AggregateErrorSerializer.js

@@ -0,0 +1,42 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
+/** @typedef {Error & { cause: unknown, errors: EXPECTED_ANY[] }} AggregateError */
+
+class AggregateErrorSerializer {
+	/**
+	 * @param {AggregateError} obj error
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(obj, context) {
+		context.write(obj.errors);
+		context.write(obj.message);
+		context.write(obj.stack);
+		context.write(obj.cause);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {AggregateError} error
+	 */
+	deserialize(context) {
+		const errors = context.read();
+		// @ts-expect-error ES2018 doesn't `AggregateError`, but it can be used by developers
+		// eslint-disable-next-line n/no-unsupported-features/es-builtins, n/no-unsupported-features/es-syntax
+		const err = new AggregateError(errors);
+
+		err.message = context.read();
+		err.stack = context.read();
+		err.cause = context.read();
+
+		return err;
+	}
+}
+
+module.exports = AggregateErrorSerializer;

package/lib/serialization/ErrorObjectSerializer.js

@@ -7,6 +7,8 @@
 /** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
+/** @typedef {Error & { cause?: unknown }} ErrorWithCause */
+
 class ErrorObjectSerializer {
 	/**
 	 * @param {ErrorConstructor | EvalErrorConstructor | RangeErrorConstructor | ReferenceErrorConstructor | SyntaxErrorConstructor | TypeErrorConstructor} Type error type
@@ -22,7 +24,10 @@ class ErrorObjectSerializer {
 	serialize(obj, context) {
 		context.write(obj.message);
 		context.write(obj.stack);
-		context.write(/** @type {Error & { cause: "unknown" }} */ (obj).cause);
+		context.write(
+			/** @type {ErrorWithCause} */
+			(obj).cause
+		);
 	}
 
 	/**
@@ -34,7 +39,7 @@ class ErrorObjectSerializer {
 
 		err.message = context.read();
 		err.stack = context.read();
-		/** @type {Error & { cause: "unknown" }} */
+		/** @type {ErrorWithCause} */
 		(err).cause = context.read();
 
 		return err;

package/lib/serialization/ObjectMiddleware.js

@@ -6,6 +6,7 @@
 
 const { DEFAULTS } = require("../config/defaults");
 const createHash = require("../util/createHash");
+const AggregateErrorSerializer = require("./AggregateErrorSerializer");
 const ArraySerializer = require("./ArraySerializer");
 const DateObjectSerializer = require("./DateObjectSerializer");
 const ErrorObjectSerializer = require("./ErrorObjectSerializer");
@@ -140,6 +141,7 @@ const loadedRequests = new Set();
 const NOT_SERIALIZABLE = {};
 
 const jsTypes = new Map();
+
 jsTypes.set(Object, new PlainObjectSerializer());
 jsTypes.set(Array, new ArraySerializer());
 jsTypes.set(null, new NullPrototypeObjectSerializer());
@@ -154,6 +156,17 @@ jsTypes.set(ReferenceError, new ErrorObjectSerializer(ReferenceError));
 jsTypes.set(SyntaxError, new ErrorObjectSerializer(SyntaxError));
 jsTypes.set(TypeError, new ErrorObjectSerializer(TypeError));
 
+// @ts-expect-error ES2018 doesn't `AggregateError`, but it can be used by developers
+// eslint-disable-next-line n/no-unsupported-features/es-builtins, n/no-unsupported-features/es-syntax
+if (typeof AggregateError !== "undefined") {
+	jsTypes.set(
+		// @ts-expect-error ES2018 doesn't `AggregateError`, but it can be used by developers
+		// eslint-disable-next-line n/no-unsupported-features/es-builtins, n/no-unsupported-features/es-syntax
+		AggregateError,
+		new AggregateErrorSerializer()
+	);
+}
+
 // If in a sandboxed environment (e.g. jest), this escapes the sandbox and registers
 // real Object and Array types to. These types may occur in the wild too, e.g. when
 // using Structured Clone in postMessage.

package/lib/sharing/ProvideSharedPlugin.js

@@ -36,6 +36,8 @@ const validate = createSchemaValidation(
 
 /** @typedef {Map<string, { config: ProvideOptions, version: string | undefined | false }>} ResolvedProvideMap */
 
+const PLUGIN_NAME = "ProvideSharedPlugin";
+
 class ProvideSharedPlugin {
 	/**
 	 * @param {ProvideSharedPluginOptions} options options
@@ -83,7 +85,7 @@ class ProvideSharedPlugin {
 		const compilationData = new WeakMap();
 
 		compiler.hooks.compilation.tap(
-			"ProvideSharedPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				/** @type {ResolvedProvideMap} */
 				const resolvedProvideMap = new Map();
@@ -156,7 +158,7 @@ class ProvideSharedPlugin {
 					});
 				};
 				normalModuleFactory.hooks.module.tap(
-					"ProvideSharedPlugin",
+					PLUGIN_NAME,
 					(module, { resource, resourceResolveData }, resolveData) => {
 						if (resolvedProvideMap.has(/** @type {string} */ (resource))) {
 							return module;
@@ -194,7 +196,7 @@ class ProvideSharedPlugin {
 				);
 			}
 		);
-		compiler.hooks.finishMake.tapPromise("ProvideSharedPlugin", compilation => {
+		compiler.hooks.finishMake.tapPromise(PLUGIN_NAME, compilation => {
 			const resolvedProvideMap = compilationData.get(compilation);
 			if (!resolvedProvideMap) return Promise.resolve();
 			return Promise.all(
@@ -225,7 +227,7 @@ class ProvideSharedPlugin {
 		});
 
 		compiler.hooks.compilation.tap(
-			"ProvideSharedPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					ProvideForSharedDependency,