webpack 5.92.1 → 5.94.0

package/lib/serialization/ObjectMiddleware.js

@@ -137,8 +137,9 @@ jsTypes.set(TypeError, new ErrorObjectSerializer(TypeError));
 // 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.
+// eslint-disable-next-line n/exports-style
 if (exports.constructor !== Object) {
-	// eslint-disable-next-line jsdoc/check-types
+	// eslint-disable-next-line jsdoc/check-types, n/exports-style
 	const Obj = /** @type {typeof Object} */ (exports.constructor);
 	const Fn = /** @type {typeof Function} */ (Obj.constructor);
 	for (const [type, config] of Array.from(jsTypes)) {
@@ -185,6 +186,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 		this.extendContext = extendContext;
 		this._hashFunction = hashFunction;
 	}
+
 	/**
 	 * @param {RegExp} regExp RegExp for which the request is tested
 	 * @param {function(string): boolean} loader loader to load the request, returns true when successful
@@ -202,7 +204,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 	 * @returns {void}
 	 */
 	static register(Constructor, request, name, serializer) {
-		const key = request + "/" + name;
+		const key = `${request}/${name}`;
 
 		if (serializers.has(Constructor)) {
 			throw new Error(
@@ -267,7 +269,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 	 * @returns {ObjectSerializer} serializer
 	 */
 	static getDeserializerFor(request, name) {
-		const key = request + "/" + name;
+		const key = `${request}/${name}`;
 		const serializer = serializerInversed.get(key);
 
 		if (serializer === undefined) {
@@ -283,7 +285,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 	 * @returns {ObjectSerializer} serializer
 	 */
 	static _getDeserializerForWithoutError(request, name) {
-		const key = request + "/" + name;
+		const key = `${request}/${name}`;
 		const serializer = serializerInversed.get(key);
 		return serializer;
 	}
@@ -316,17 +318,16 @@ class ObjectMiddleware extends SerializerMiddleware {
 					}
 					bufferDedupeMap.set(len, [entry, buf]);
 					return buf;
-				} else {
-					const hash = toHash(entry, this._hashFunction);
-					const newMap = new Map();
-					newMap.set(hash, entry);
-					bufferDedupeMap.set(len, newMap);
-					const hashBuf = toHash(buf, this._hashFunction);
-					if (hash === hashBuf) {
-						return entry;
-					}
-					return buf;
 				}
+				const hash = toHash(entry, this._hashFunction);
+				const newMap = new Map();
+				newMap.set(hash, entry);
+				bufferDedupeMap.set(len, newMap);
+				const hashBuf = toHash(buf, this._hashFunction);
+				if (hash === hashBuf) {
+					return entry;
+				}
+				return buf;
 			} else if (Array.isArray(entry)) {
 				if (entry.length < 16) {
 					for (const item of entry) {
@@ -336,32 +337,29 @@ class ObjectMiddleware extends SerializerMiddleware {
 					}
 					entry.push(buf);
 					return buf;
-				} else {
-					const newMap = new Map();
-					const hash = toHash(buf, this._hashFunction);
-					let found;
-					for (const item of entry) {
-						const itemHash = toHash(item, this._hashFunction);
-						newMap.set(itemHash, item);
-						if (found === undefined && itemHash === hash) found = item;
-					}
-					bufferDedupeMap.set(len, newMap);
-					if (found === undefined) {
-						newMap.set(hash, buf);
-						return buf;
-					} else {
-						return found;
-					}
 				}
-			} else {
+				const newMap = new Map();
 				const hash = toHash(buf, this._hashFunction);
-				const item = entry.get(hash);
-				if (item !== undefined) {
-					return item;
+				let found;
+				for (const item of entry) {
+					const itemHash = toHash(item, this._hashFunction);
+					newMap.set(itemHash, item);
+					if (found === undefined && itemHash === hash) found = item;
 				}
-				entry.set(hash, buf);
-				return buf;
+				bufferDedupeMap.set(len, newMap);
+				if (found === undefined) {
+					newMap.set(hash, buf);
+					return buf;
+				}
+				return found;
+			}
+			const hash = toHash(buf, this._hashFunction);
+			const item = entry.get(hash);
+			if (item !== undefined) {
+				return item;
 			}
+			entry.set(hash, buf);
+			return buf;
 		};
 		let currentPosTypeLookup = 0;
 		let objectTypeLookup = new Map();
@@ -385,7 +383,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 						if (request) {
 							return `${request}${name ? `.${name}` : ""}`;
 						}
-					} catch (e) {
+					} catch (_err) {
 						// ignore -> fallback
 					}
 					if (typeof item === "object" && item !== null) {
@@ -408,8 +406,8 @@ class ObjectMiddleware extends SerializerMiddleware {
 					}
 					try {
 						return `${item}`;
-					} catch (e) {
-						return `(${e.message})`;
+					} catch (err) {
+						return `(${err.message})`;
 					}
 				})
 				.join(" -> ");
@@ -419,16 +417,16 @@ class ObjectMiddleware extends SerializerMiddleware {
 			write(value, key) {
 				try {
 					process(value);
-				} catch (e) {
-					if (e !== NOT_SERIALIZABLE) {
+				} catch (err) {
+					if (err !== NOT_SERIALIZABLE) {
 						if (hasDebugInfoAttached === undefined)
 							hasDebugInfoAttached = new WeakSet();
-						if (!hasDebugInfoAttached.has(e)) {
-							e.message += `\nwhile serializing ${stackToString(value)}`;
-							hasDebugInfoAttached.add(e);
+						if (!hasDebugInfoAttached.has(err)) {
+							err.message += `\nwhile serializing ${stackToString(value)}`;
+							hasDebugInfoAttached.add(err);
 						}
 					}
-					throw e;
+					throw err;
 				}
 			},
 			setCircularReference(ref) {
@@ -491,7 +489,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 
 				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.`
+						"This is a circular references. To serialize circular references use 'setCircularReference' somewhere in the circle during serialize and deserialize."
 					);
 				}
 
@@ -542,7 +540,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 				result.push(item);
 			} else if (typeof item === "function") {
 				if (!SerializerMiddleware.isLazy(item))
-					throw new Error("Unexpected function " + item);
+					throw new Error(`Unexpected function ${item}`);
 				/** @type {SerializedType} */
 				const serializedData =
 					SerializerMiddleware.getLazySerializedValue(item);
@@ -573,10 +571,10 @@ class ObjectMiddleware extends SerializerMiddleware {
 				process(item);
 			}
 			return result;
-		} catch (e) {
-			if (e === NOT_SERIALIZABLE) return null;
+		} catch (err) {
+			if (err === NOT_SERIALIZABLE) return null;
 
-			throw e;
+			throw err;
 		} finally {
 			// Get rid of these references to avoid leaking memory
 			// This happens because the optimized code v8 generates
@@ -637,7 +635,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 				if (nextItem === ESCAPE_ESCAPE_VALUE) {
 					return ESCAPE;
 				} else if (nextItem === ESCAPE_UNDEFINED) {
-					return undefined;
+					// Nothing
 				} else if (nextItem === ESCAPE_END_OBJECT) {
 					throw new Error(
 						`Unexpected end of object at position ${currentDataPos - 1}`
@@ -670,11 +668,9 @@ class ObjectMiddleware extends SerializerMiddleware {
 							if (request && !loadedRequests.has(request)) {
 								let loaded = false;
 								for (const [regExp, loader] of loaders) {
-									if (regExp.test(request)) {
-										if (loader(request)) {
-											loaded = true;
-											break;
-										}
+									if (regExp.test(request) && loader(request)) {
+										loaded = true;
+										break;
 									}
 								}
 								if (!loaded) {

package/lib/serialization/PlainObjectSerializer.js

@@ -7,19 +7,36 @@
 /** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
+/** @typedef {(arg0?: any) => void} CacheAssoc */
+
+/**
+ * @template T
+ * @typedef {WeakMap<CacheAssoc, ObjectStructure<T>>}
+ */
 const cache = new WeakMap();
 
+/**
+ * @template T
+ */
 class ObjectStructure {
 	constructor() {
 		this.keys = undefined;
 		this.children = undefined;
 	}
 
+	/**
+	 * @param {keyof T[]} keys keys
+	 * @returns {keyof T[]} keys
+	 */
 	getKeys(keys) {
 		if (this.keys === undefined) this.keys = keys;
 		return this.keys;
 	}
 
+	/**
+	 * @param {keyof T} key key
+	 * @returns {ObjectStructure<T>} object structure
+	 */
 	key(key) {
 		if (this.children === undefined) this.children = new Map();
 		const child = this.children.get(key);
@@ -30,6 +47,12 @@ class ObjectStructure {
 	}
 }
 
+/**
+ * @template T
+ * @param {(keyof T)[]} keys keys
+ * @param {CacheAssoc} cacheAssoc cache assoc fn
+ * @returns {(keyof T)[]} keys
+ */
 const getCachedKeys = (keys, cacheAssoc) => {
 	let root = cache.get(cacheAssoc);
 	if (root === undefined) {
@@ -45,11 +68,12 @@ const getCachedKeys = (keys, cacheAssoc) => {
 
 class PlainObjectSerializer {
 	/**
-	 * @param {object} obj plain object
+	 * @template {object} T
+	 * @param {T} obj plain object
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(obj, context) {
-		const keys = Object.keys(obj);
+		const keys = /** @type {(keyof T)[]} */ (Object.keys(obj));
 		if (keys.length > 128) {
 			// Objects with so many keys are unlikely to share structure
 			// with other objects
@@ -70,19 +94,21 @@ class PlainObjectSerializer {
 			context.write(null);
 		}
 	}
+
 	/**
+	 * @template {object} T
 	 * @param {ObjectDeserializerContext} context context
-	 * @returns {object} plain object
+	 * @returns {T} plain object
 	 */
 	deserialize(context) {
 		const keys = context.read();
-		const obj = {};
+		const obj = /** @type {T} */ ({});
 		if (Array.isArray(keys)) {
 			for (const key of keys) {
-				obj[key] = context.read();
+				obj[/** @type {keyof T} */ (key)] = context.read();
 			}
 		} else if (keys !== null) {
-			obj[keys] = context.read();
+			obj[/** @type {keyof T} */ (keys)] = context.read();
 		}
 		return obj;
 	}

package/lib/serialization/RegExpObjectSerializer.js

@@ -16,6 +16,7 @@ class RegExpObjectSerializer {
 		context.write(obj.source);
 		context.write(obj.flags);
 	}
+
 	/**
 	 * @param {ObjectDeserializerContext} context context
 	 * @returns {RegExp} regexp

package/lib/serialization/Serializer.js

@@ -52,11 +52,10 @@ class Serializer {
 		/** @type {any} */
 		let current = value;
 		for (const middleware of this.deserializeMiddlewares) {
-			if (current && typeof current.then === "function") {
-				current = current.then(data => middleware.deserialize(data, ctx));
-			} else {
-				current = middleware.deserialize(current, ctx);
-			}
+			current =
+				current && typeof current.then === "function"
+					? current.then(data => middleware.deserialize(data, ctx))
+					: middleware.deserialize(current, ctx);
 		}
 		return current;
 	}

package/lib/serialization/SerializerMiddleware.js

@@ -45,7 +45,7 @@ class SerializerMiddleware {
 	 * @param {any=} serializedValue serialized value
 	 * @returns {function(): Promise<any> | any} lazy function
 	 */
-	static createLazy(value, target, options = {}, serializedValue) {
+	static createLazy(value, target, options = {}, serializedValue = undefined) {
 		if (SerializerMiddleware.isLazy(value, target)) return value;
 		const fn = typeof value === "function" ? value : () => value;
 		fn[LAZY_TARGET] = target;
@@ -62,24 +62,24 @@ class SerializerMiddleware {
 	static isLazy(fn, target) {
 		if (typeof fn !== "function") return false;
 		const t = fn[LAZY_TARGET];
-		return target ? t === target : !!t;
+		return target ? t === target : Boolean(t);
 	}
 
 	/**
 	 * @param {function(): Promise<any> | any} fn lazy function
-	 * @returns {object} options
+	 * @returns {object | undefined} options
 	 */
 	static getLazyOptions(fn) {
-		if (typeof fn !== "function") return undefined;
+		if (typeof fn !== "function") return;
 		return /** @type {any} */ (fn).options;
 	}
 
 	/**
 	 * @param {function(): Promise<any> | any} fn lazy function
-	 * @returns {any} serialized value
+	 * @returns {any | undefined} serialized value
 	 */
 	static getLazySerializedValue(fn) {
-		if (typeof fn !== "function") return undefined;
+		if (typeof fn !== "function") return;
 		return fn[LAZY_SERIALIZED_VALUE];
 	}
 

package/lib/serialization/SetObjectSerializer.js

@@ -19,6 +19,7 @@ class SetObjectSerializer {
 			context.write(value);
 		}
 	}
+
 	/**
 	 * @template T
 	 * @param {ObjectDeserializerContext} context context
@@ -26,7 +27,7 @@ class SetObjectSerializer {
 	 */
 	deserialize(context) {
 		/** @type {number} */
-		let size = context.read();
+		const size = context.read();
 		/** @type {Set<T>} */
 		const set = new Set();
 		for (let i = 0; i < size; i++) {

package/lib/sharing/ConsumeSharedModule.js

@@ -207,26 +207,31 @@ class ConsumeSharedModule extends Module {
 				});
 			}
 		}
-		let fn = "load";
-		const args = [JSON.stringify(shareScope), JSON.stringify(shareKey)];
+
+		const args = [
+			JSON.stringify(shareScope),
+			JSON.stringify(shareKey),
+			JSON.stringify(eager)
+		];
 		if (requiredVersion) {
-			if (strictVersion) {
-				fn += "Strict";
-			}
-			if (singleton) {
-				fn += "Singleton";
-			}
 			args.push(stringifyHoley(requiredVersion));
-			fn += "VersionCheck";
-		} else {
-			if (singleton) {
-				fn += "Singleton";
-			}
 		}
 		if (fallbackCode) {
-			fn += "Fallback";
 			args.push(fallbackCode);
 		}
+
+		let fn;
+
+		if (requiredVersion) {
+			if (strictVersion) {
+				fn = singleton ? "loadStrictSingletonVersion" : "loadStrictVersion";
+			} else {
+				fn = singleton ? "loadSingletonVersion" : "loadVersion";
+			}
+		} else {
+			fn = singleton ? "loadSingleton" : "load";
+		}
+
 		const code = runtimeTemplate.returningFunction(`${fn}(${args.join(", ")})`);
 		const sources = new Map();
 		sources.set("consume-shared", new RawSource(code));