webpack 5.110.0 → 5.110.1

package/lib/FileSystemInfo.js

@@ -1207,6 +1207,15 @@ const getManagedItem = (managedPath, path) => {
 	return path.slice(0, i);
 };
 
+/**
+ * The managed directory a `snapshot.managedPaths` RegExp matched. The schema
+ * documents it as matching that directory, so a capture-less pattern is it.
+ * @param {RegExpExecArray} match a match of a managed path RegExp
+ * @returns {string} the managed directory
+ */
+const getManagedPathFromMatch = (match) =>
+	match[1] === undefined ? match[0] : match[1];
+
 /**
  * Gets resolved timestamp.
  * @template {ContextFileSystemInfoEntry | ContextTimestampAndHash} T
@@ -2663,7 +2672,10 @@ class FileSystemInfo {
 			for (const managedPath of this.managedPathsRegExps) {
 				const match = managedPath.exec(path);
 				if (match) {
-					const managedItem = getManagedItem(match[1], path);
+					const managedItem = getManagedItem(
+						getManagedPathFromMatch(match),
+						path
+					);
 					if (managedItem) {
 						classificationCache.set(path, managedItem);
 						managedItems.add(managedItem);
@@ -3921,7 +3933,10 @@ class FileSystemInfo {
 					for (const managedPath of this.managedPathsRegExps) {
 						const match = managedPath.exec(path);
 						if (match) {
-							const managedItem = getManagedItem(match[1], path);
+							const managedItem = getManagedItem(
+								getManagedPathFromMatch(match),
+								path
+							);
 							if (managedItem) {
 								// construct timestampHash from managed info
 								return this.managedItemQueue.add(managedItem, (err, info) => {

package/lib/Generator.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const { JAVASCRIPT_TYPE } = require("./ModuleSourceTypeConstants");
+const memoize = require("./util/memoize");
 
 /** @import { Source } from "webpack-sources" */
 /** @import ChunkGraph from "./ChunkGraph" */
@@ -60,6 +61,8 @@ const { JAVASCRIPT_TYPE } = require("./ModuleSourceTypeConstants");
  * @property {RuntimeTemplate=} runtimeTemplate
  */
 
+const getModuleParseError = memoize(() => require("./errors/ModuleParseError"));
+
 class Generator {
 	/**
 	 * Returns generator by type.
@@ -70,6 +73,20 @@ class Generator {
 		return new ByTypeGenerator(map);
 	}
 
+	/**
+	 * Returns the statement a module that failed to build throws when executed.
+	 * @param {Error} error the build error
+	 * @param {string=} parseErrorConstructor constructor for a rejected source, defaults to `SyntaxError` (WebAssembly rejects with `WebAssembly.CompileError` instead)
+	 * @returns {string} javascript statement
+	 */
+	static throwBuildErrorCode(error, parseErrorConstructor = "SyntaxError") {
+		// A source the parser rejected throws what a native load of it would.
+		const name =
+			error instanceof getModuleParseError() ? parseErrorConstructor : "Error";
+
+		return `throw new ${name}(${JSON.stringify(error.message)});`;
+	}
+
 	/* istanbul ignore next */
 	/**
 	 * Returns the source types available for this module.

package/lib/NormalModule.js

@@ -55,6 +55,8 @@ const parseJson = require("./util/parseJson");
 
 const getValidate = memoize(() => require("schema-utils").validate);
 
+const getGenerator = memoize(() => require("./Generator"));
+
 const getExtractSourceMap = memoize(() => require("./util/extractSourceMap"));
 
 const getInvalidDependenciesModuleWarning = memoize(() =>
@@ -1913,9 +1915,7 @@ class NormalModule extends Module {
 							getData,
 							type
 						})
-					: new RawSource(
-							`throw new Error(${JSON.stringify(this.error.message)});`
-						)
+					: new RawSource(getGenerator().throwBuildErrorCode(this.error))
 				: generator.generate(this, {
 						dependencyTemplates,
 						runtimeTemplate,

package/lib/asset/AssetBytesGenerator.js

@@ -114,9 +114,7 @@ class AssetBytesGenerator extends Generator {
 	generateError(error, module, generateContext) {
 		switch (generateContext.type) {
 			case JAVASCRIPT_TYPE: {
-				return new RawSource(
-					`throw new Error(${JSON.stringify(error.message)});`
-				);
+				return new RawSource(Generator.throwBuildErrorCode(error));
 			}
 			default:
 				return null;

package/lib/asset/AssetGenerator.js

@@ -777,9 +777,7 @@ class AssetGenerator extends Generator {
 				return new RawSource(error.message);
 			}
 			case JAVASCRIPT_TYPE: {
-				return new RawSource(
-					`throw new Error(${JSON.stringify(error.message)});`
-				);
+				return new RawSource(Generator.throwBuildErrorCode(error));
 			}
 			default:
 				return null;

package/lib/asset/AssetSourceGenerator.js

@@ -158,9 +158,7 @@ class AssetSourceGenerator extends Generator {
 	generateError(error, module, generateContext) {
 		switch (generateContext.type) {
 			case JAVASCRIPT_TYPE: {
-				return new RawSource(
-					`throw new Error(${JSON.stringify(error.message)});`
-				);
+				return new RawSource(Generator.throwBuildErrorCode(error));
 			}
 			default:
 				return null;

package/lib/config/defaults.js

@@ -2464,6 +2464,12 @@ const applyOptimizationDefaults = (
 	D(optimization, "portableRecords", records);
 	D(optimization, "realContentHash", production);
 	F(optimization, "minimize", () => (production ? {} : false));
+	// A plugin can assign the `true` shorthand in `apply()`, which runs after
+	// `getNormalizedOptimizationMinimize` and so never gets normalized. The
+	// normalized type does not allow it, hence the cast.
+	if (/** @type {unknown} */ (optimization.minimize) === true) {
+		optimization.minimize = {};
+	}
 	const { minimize } = optimization;
 	if (minimize) {
 		// Canonicalize the object form: the JS minimizer's defaults become

package/lib/css/CssGenerator.js

@@ -617,9 +617,7 @@ class CssGenerator extends Generator {
 	generateError(error, module, generateContext) {
 		switch (generateContext.type) {
 			case JAVASCRIPT_TYPE: {
-				return new RawSource(
-					`throw new Error(${JSON.stringify(error.message)});`
-				);
+				return new RawSource(Generator.throwBuildErrorCode(error));
 			}
 			case CSS_TYPE: {
 				return new RawSource(`/**\n ${error.message} \n**/`);

package/lib/html/HtmlGenerator.js

@@ -1648,7 +1648,7 @@ class HtmlGenerator extends Generator {
 				.replace(/-{2,}/g, (m) => `${"-".repeat(m.length - 1)} `);
 			return new RawSource(`<!-- webpack error: ${safe} -->`);
 		}
-		return new RawSource(`throw new Error(${JSON.stringify(error.message)});`);
+		return new RawSource(Generator.throwBuildErrorCode(error));
 	}
 
 	/**

package/lib/javascript/JavascriptGenerator.js

@@ -332,7 +332,7 @@ class JavascriptGenerator extends Generator {
 	 * @returns {Source | null} generated code
 	 */
 	generateError(error, module, generateContext) {
-		return new RawSource(`throw new Error(${JSON.stringify(error.message)});`);
+		return new RawSource(Generator.throwBuildErrorCode(error));
 	}
 }
 

package/lib/json/JsonGenerator.js

@@ -259,7 +259,7 @@ class JsonGenerator extends Generator {
 	 * @returns {Source | null} generated code
 	 */
 	generateError(error, module, generateContext) {
-		return new RawSource(`throw new Error(${JSON.stringify(error.message)});`);
+		return new RawSource(Generator.throwBuildErrorCode(error));
 	}
 
 	/**

package/lib/serialization/ObjectMiddleware.js

@@ -461,7 +461,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 			return buf;
 		};
 		let currentPosTypeLookup = 0;
-		/** @type {Map<ComplexSerializableType, number>} */
+		/** @type {Map<SerializerConfigWithSerializer, number>} */
 		let objectTypeLookup = new Map();
 		/** @type {Set<ComplexSerializableType>} */
 		const cycleStack = new Set();
@@ -573,140 +573,160 @@ class ObjectMiddleware extends SerializerMiddleware {
 			...context
 		};
 		this.extendContext(ctx);
+		// Dispatched on `typeof` first: two thirds of the items are numbers,
+		// booleans and `undefined`, and only 3% are buffers.
 		/**
 		 * Processes the provided item.
 		 * @param {ComplexSerializableType} item item to serialize
 		 */
 		const process = (item) => {
-			if (Buffer.isBuffer(item)) {
-				// check if we can emit a reference
-				const ref = referenceable.get(item);
-				if (ref !== undefined) {
-					result.push(ESCAPE, ref - currentPos);
+			switch (typeof item) {
+				case "number":
+				case "boolean":
+					result.push(item);
 					return;
-				}
-				const alreadyUsedBuffer = dedupeBuffer(item);
-				if (alreadyUsedBuffer !== item) {
-					const ref = referenceable.get(alreadyUsedBuffer);
-					if (ref !== undefined) {
-						referenceable.set(item, ref);
-						result.push(ESCAPE, ref - currentPos);
-						return;
+				case "string": {
+					if (item.length > 1) {
+						// short strings are shorter when not emitting a reference (this saves 1 byte per empty string)
+						// check if we can emit a reference
+						const ref = referenceable.get(item);
+						if (ref !== undefined) {
+							const offset = ref - currentPos;
+							if (
+								// One far ref → 5 bytes (`null` + offset), one near ref -> 2/3 bytes
+								offset >= -32768 ||
+								// long enough that the ref wins, keep it
+								item.length >= 4 ||
+								// multibyte → inline would be even bigger, keep it
+								Buffer.byteLength(item) !== item.length
+							) {
+								// A back-reference is `null` + the offset.
+								result.push(ESCAPE, offset);
+								return;
+							}
+						}
+						addReferenceable(item);
 					}
-					item = alreadyUsedBuffer;
-				}
-				addReferenceable(item);
 
-				result.push(/** @type {Buffer} */ (item));
-			} else if (item === ESCAPE) {
-				result.push(ESCAPE, ESCAPE_ESCAPE_VALUE);
-			} else if (
-				typeof item === "object"
-				// We don't have to check for null as ESCAPE is null and this has been checked before
-			) {
-				// check if we can emit a reference
-				const ref = referenceable.get(item);
-				if (ref !== undefined) {
-					result.push(ESCAPE, ref - currentPos);
+					if (item.length > 102400 && context.logger) {
+						context.logger.warn(
+							`Serializing big strings (${Math.round(
+								item.length / 1024
+							)}kiB) impacts deserialization performance (consider using Buffer instead and decode when needed)`
+						);
+					}
+
+					result.push(item);
 					return;
 				}
+				case "undefined":
+					result.push(ESCAPE, ESCAPE_UNDEFINED);
+					return;
+				case "object": {
+					// ESCAPE is null, so this covers null too
+					if (item === ESCAPE) {
+						result.push(ESCAPE, ESCAPE_ESCAPE_VALUE);
+						return;
+					}
 
-				if (cycleStack.has(item)) {
-					throw new Error(
-						"This is a circular references. To serialize circular references use 'setCircularReference' somewhere in the circle during serialize and deserialize."
-					);
-				}
+					if (Buffer.isBuffer(item)) {
+						// check if we can emit a reference
+						const ref = referenceable.get(item);
+						if (ref !== undefined) {
+							result.push(ESCAPE, ref - currentPos);
+							return;
+						}
+						const alreadyUsedBuffer = dedupeBuffer(item);
+						if (alreadyUsedBuffer !== item) {
+							const ref = referenceable.get(alreadyUsedBuffer);
+							if (ref !== undefined) {
+								referenceable.set(item, ref);
+								result.push(ESCAPE, ref - currentPos);
+								return;
+							}
+							item = alreadyUsedBuffer;
+						}
+						addReferenceable(item);
 
-				const { request, name, serializer } = ObjectMiddleware.getSerializerFor(
-					/** @type {Constructor} */
-					(item)
-				);
-				const key = `${request}/${name}`;
-				const lastIndex = objectTypeLookup.get(key);
+						result.push(/** @type {Buffer} */ (item));
+						return;
+					}
 
-				if (lastIndex === undefined) {
-					objectTypeLookup.set(key, currentPosTypeLookup++);
+					// check if we can emit a reference
+					const ref = referenceable.get(item);
+					if (ref !== undefined) {
+						result.push(ESCAPE, ref - currentPos);
+						return;
+					}
 
-					result.push(ESCAPE, request, name);
-				} else {
-					result.push(ESCAPE, currentPosTypeLookup - lastIndex);
-				}
+					if (cycleStack.has(item)) {
+						throw new Error(
+							"This is a circular references. To serialize circular references use 'setCircularReference' somewhere in the circle during serialize and deserialize."
+						);
+					}
 
-				cycleStack.add(item);
+					// Keyed by the registration itself: one per class, so it stands in for
+					// `${request}/${name}` without building that string per object.
+					const config = ObjectMiddleware.getSerializerFor(
+						/** @type {Constructor} */
+						(item)
+					);
+					const { request, name, serializer } = config;
+					const lastIndex = objectTypeLookup.get(config);
 
-				try {
-					serializer.serialize(item, ctx);
-				} finally {
-					cycleStack.delete(item);
-				}
+					if (lastIndex === undefined) {
+						objectTypeLookup.set(config, currentPosTypeLookup++);
 
-				result.push(ESCAPE, ESCAPE_END_OBJECT);
+						result.push(ESCAPE, request, name);
+					} else {
+						result.push(ESCAPE, currentPosTypeLookup - lastIndex);
+					}
 
-				addReferenceable(item);
-			} else if (typeof item === "string") {
-				if (item.length > 1) {
-					// short strings are shorter when not emitting a reference (this saves 1 byte per empty string)
-					// check if we can emit a reference
-					const ref = referenceable.get(item);
-					if (ref !== undefined) {
-						const offset = ref - currentPos;
-						if (
-							// One far ref → 5 bytes (`null` + offset), one near ref -> 2/3 bytes
-							offset >= -32768 ||
-							// long enough that the ref wins, keep it
-							item.length >= 4 ||
-							// multibyte → inline would be even bigger, keep it
-							Buffer.byteLength(item) !== item.length
-						) {
-							// A back-reference is `null` + the offset.
-							result.push(ESCAPE, offset);
-							return;
-						}
+					cycleStack.add(item);
+
+					try {
+						serializer.serialize(item, ctx);
+					} finally {
+						cycleStack.delete(item);
 					}
-					addReferenceable(item);
-				}
 
-				if (item.length > 102400 && context.logger) {
-					context.logger.warn(
-						`Serializing big strings (${Math.round(
-							item.length / 1024
-						)}kiB) impacts deserialization performance (consider using Buffer instead and decode when needed)`
-					);
-				}
+					result.push(ESCAPE, ESCAPE_END_OBJECT);
 
-				result.push(item);
-			} else if (typeof item === "function") {
-				if (!SerializerMiddleware.isLazy(item)) {
-					throw new Error(`Unexpected function ${item}`);
+					addReferenceable(item);
+					return;
 				}
+				case "function": {
+					if (!SerializerMiddleware.isLazy(item)) {
+						throw new Error(`Unexpected function ${item}`);
+					}
 
-				/** @type {SerializedType | undefined} */
-				const serializedData =
-					SerializerMiddleware.getLazySerializedValue(item);
+					/** @type {SerializedType | undefined} */
+					const serializedData =
+						SerializerMiddleware.getLazySerializedValue(item);
 
-				if (serializedData !== undefined) {
-					if (typeof serializedData === "function") {
-						result.push(serializedData);
-					} else {
+					if (serializedData !== undefined) {
+						if (typeof serializedData === "function") {
+							result.push(serializedData);
+						} else {
+							throw new Error("Not implemented");
+						}
+					} else if (SerializerMiddleware.isLazy(item, this)) {
 						throw new Error("Not implemented");
+					} else {
+						const data =
+							/** @type {() => PrimitiveSerializableType[] | Promise<PrimitiveSerializableType[]>} */
+							(
+								SerializerMiddleware.serializeLazy(item, (data) =>
+									this.serialize([data], context)
+								)
+							);
+						SerializerMiddleware.setLazySerializedValue(item, data);
+						result.push(data);
 					}
-				} else if (SerializerMiddleware.isLazy(item, this)) {
-					throw new Error("Not implemented");
-				} else {
-					const data =
-						/** @type {() => PrimitiveSerializableType[] | Promise<PrimitiveSerializableType[]>} */
-						(
-							SerializerMiddleware.serializeLazy(item, (data) =>
-								this.serialize([data], context)
-							)
-						);
-					SerializerMiddleware.setLazySerializedValue(item, data);
-					result.push(data);
+					return;
 				}
-			} else if (item === undefined) {
-				result.push(ESCAPE, ESCAPE_UNDEFINED);
-			} else {
-				result.push(item);
+				default:
+					result.push(item);
 			}
 		};
 

package/lib/wasm-async/AsyncWebAssemblyJavascriptGenerator.js

@@ -302,7 +302,9 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 	 * @returns {Source | null} generated code
 	 */
 	generateError(error, module, generateContext) {
-		return new RawSource(`throw new Error(${JSON.stringify(error.message)});`);
+		return new RawSource(
+			Generator.throwBuildErrorCode(error, "WebAssembly.CompileError")
+		);
 	}
 }
 

package/lib/wasm-sync/WebAssemblyJavascriptGenerator.js

@@ -231,7 +231,9 @@ class WebAssemblyJavascriptGenerator extends Generator {
 	 * @returns {Source | null} generated code
 	 */
 	generateError(error, module, generateContext) {
-		return new RawSource(`throw new Error(${JSON.stringify(error.message)});`);
+		return new RawSource(
+			Generator.throwBuildErrorCode(error, "WebAssembly.CompileError")
+		);
 	}
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "5.110.0",
+  "version": "5.110.1",
   "description": "Packs ECMAScript/CommonJs/AMD modules for the browser. Allows you to split your codebase into multiple bundles, which can be loaded on demand. Supports loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "homepage": "https://github.com/webpack/webpack",
   "bugs": "https://github.com/webpack/webpack/issues",

package/types.d.ts

@@ -9482,6 +9482,14 @@ declare class Generator {
 	static byType(map: {
 		[index: string]: undefined | Generator;
 	}): ByTypeGenerator;
+
+	/**
+	 * Returns the statement a module that failed to build throws when executed.
+	 */
+	static throwBuildErrorCode(
+		error: Error,
+		parseErrorConstructor?: string
+	): string;
 }
 declare interface GeneratorOptions {
 	[index: string]: any;