webpack 5.99.5 → 5.99.7

package/lib/serialization/FileMiddleware.js

@@ -22,14 +22,8 @@ const SerializerMiddleware = require("./SerializerMiddleware");
 /** @typedef {typeof import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").IStats} IStats */
 /** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
-/** @typedef {import("./SerializerMiddleware").Context} Context */
 /** @typedef {import("./types").BufferSerializableType} BufferSerializableType */
 
-/**
- * @template LAZY_RESULT
- * @typedef {import("./SerializerMiddleware").LazyFunction<LAZY_RESULT>} LazyFunction
- */
-
 /*
 Format:
 
@@ -95,9 +89,14 @@ const readUInt64LE = Buffer.prototype.readBigUInt64LE
  * @property {BackgroundJob=} backgroundJob
  */
 
+/** @typedef {{ name: string, size: number }} LazyOptions */
+/**
+ * @typedef {import("./SerializerMiddleware").LazyFunction<BufferSerializableType[], Buffer, FileMiddleware, LazyOptions>} LazyFunction
+ */
+
 /**
  * @param {FileMiddleware} middleware this
- * @param {BufferSerializableType[] | Promise<BufferSerializableType[]>} data data to be serialized
+ * @param {(BufferSerializableType | LazyFunction)[]} data data to be serialized
  * @param {string | boolean} name file base name
  * @param {(name: string | false, buffers: Buffer[], size: number) => Promise<void>} writeFile writes a file
  * @param {string | Hash} hashFunction hash function to use
@@ -112,7 +111,7 @@ const serialize = async (
 ) => {
 	/** @type {(Buffer[] | Buffer | Promise<SerializeResult>)[]} */
 	const processedData = [];
-	/** @type {WeakMap<SerializeResult, LazyFunction<BufferSerializableType[]>>} */
+	/** @type {WeakMap<SerializeResult, LazyFunction>} */
 	const resultToLazy = new WeakMap();
 	/** @type {Buffer[] | undefined} */
 	let lastBuffers;
@@ -138,25 +137,19 @@ const serialize = async (
 			} else {
 				const content = item();
 				if (content) {
-					const options = SerializerMiddleware.getLazyOptions(
-						/** @type {LazyFunction<Buffer[]>} */
-						(item)
-					);
+					const options = SerializerMiddleware.getLazyOptions(item);
 					processedData.push(
 						serialize(
 							middleware,
-							content,
+							/** @type {BufferSerializableType[]} */
+							(content),
 							(options && options.name) || true,
 							writeFile,
 							hashFunction
 						).then(result => {
-							/** @type {LazyFunction<Buffer[]>} */
-							(item).options.size = result.size;
-							resultToLazy.set(
-								result,
-								/** @type {LazyFunction<Buffer[]>} */
-								(item)
-							);
+							/** @type {LazyOptions} */
+							(item.options).size = result.size;
+							resultToLazy.set(result, item);
 							return result;
 						})
 					);
@@ -193,7 +186,7 @@ const serialize = async (
 		writeUInt64LE(buf, item.size, 0);
 		nameBuffer.copy(buf, 8, 0);
 		const lazy =
-			/** @type {LazyFunction<BufferSerializableType[]>} */
+			/** @type {LazyFunction} */
 			(resultToLazy.get(item));
 		SerializerMiddleware.setLazySerializedValue(lazy, buf);
 		return buf;
@@ -351,7 +344,7 @@ const deserialize = async (middleware, name, readFile) => {
 			lastLengthPositive = valuePositive;
 		}
 	}
-	/** @type {(Buffer | LazyFunction<BufferSerializableType[]>)[]} */
+	/** @type {BufferSerializableType[]} */
 	const result = [];
 	for (let length of lengths) {
 		if (length < 0) {
@@ -359,13 +352,16 @@ const deserialize = async (middleware, name, readFile) => {
 			const size = Number(readUInt64LE(slice, 0));
 			const nameBuffer = slice.slice(8);
 			const name = nameBuffer.toString();
-			/** @type {LazyFunction<BufferSerializableType[]>} */
-			const lazy = SerializerMiddleware.createLazy(
-				memoize(() => deserialize(middleware, name, readFile)),
-				middleware,
-				{ name, size },
-				slice
-			);
+			const lazy =
+				/** @type {LazyFunction} */
+				(
+					SerializerMiddleware.createLazy(
+						memoize(() => deserialize(middleware, name, readFile)),
+						middleware,
+						{ name, size },
+						slice
+					)
+				);
 			result.push(lazy);
 		} else {
 			if (contentPosition === contentItemLength) {
@@ -423,12 +419,12 @@ const deserialize = async (middleware, name, readFile) => {
 	return result;
 };
 
-/** @typedef {{ filename: string, extension?: string }} FileMiddlewareContext */
+/** @typedef {BufferSerializableType[]} DeserializedType */
+/** @typedef {true} SerializedType */
+/** @typedef {{ filename: string, extension?: string }} Context */
 
 /**
- * @typedef {BufferSerializableType[]} DeserializedType
- * @typedef {true} SerializedType
- * @extends {SerializerMiddleware<DeserializedType, SerializedType>}
+ * @extends {SerializerMiddleware<DeserializedType, SerializedType, Context>}
  */
 class FileMiddleware extends SerializerMiddleware {
 	/**

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");
@@ -16,18 +17,14 @@ const RegExpObjectSerializer = require("./RegExpObjectSerializer");
 const SerializerMiddleware = require("./SerializerMiddleware");
 const SetObjectSerializer = require("./SetObjectSerializer");
 
+/** @typedef {import("../logging/Logger").Logger} Logger */
 /** @typedef {typeof import("../util/Hash")} Hash */
-/** @typedef {import("./SerializerMiddleware").Context} Context */
+/** @typedef {import("./SerializerMiddleware").LazyOptions} LazyOptions */
 /** @typedef {import("./types").ComplexSerializableType} ComplexSerializableType */
 /** @typedef {import("./types").PrimitiveSerializableType} PrimitiveSerializableType */
 
 /** @typedef {new (...params: EXPECTED_ANY[]) => EXPECTED_ANY} Constructor */
 
-/**
- * @template LAZY_RESULT
- * @typedef {import("./SerializerMiddleware").LazyFunction<LAZY_RESULT>} LazyFunction
- */
-
 /*
 
 Format:
@@ -59,27 +56,29 @@ Technically any value can be used.
  * @property {number} objectTypeLookupSize
  * @property {number} currentPosTypeLookup
  */
+/** @typedef {TODO} Value */
+/** @typedef {EXPECTED_OBJECT | string} ReferenceableItem */
 
 /**
  * @typedef {object} ObjectSerializerContext
- * @property {(value: any) => void} write
- * @property {(value: any) => void} setCircularReference
+ * @property {(value: Value) => void} write
+ * @property {(value: ReferenceableItem) => void} setCircularReference
  * @property {() => ObjectSerializerSnapshot} snapshot
  * @property {(snapshot: ObjectSerializerSnapshot) => void} rollback
- * @property {((item: any) => void)=} writeLazy
- * @property {((item: any, obj?: TODO) => (() => Promise<any> | any))=} writeSeparate
+ * @property {((item: Value | (() => Value)) => void)=} writeLazy
+ * @property {((item: (Value | (() => Value)), obj: LazyOptions | undefined) => import("./SerializerMiddleware").LazyFunction<EXPECTED_ANY, EXPECTED_ANY, EXPECTED_ANY, LazyOptions>)=} writeSeparate
  */
 
 /**
  * @typedef {object} ObjectDeserializerContext
- * @property {() => any} read
- * @property {(value: any) => void} setCircularReference
+ * @property {() => Value} read
+ * @property {(value: ReferenceableItem) => void} setCircularReference
  */
 
 /**
  * @typedef {object} ObjectSerializer
- * @property {(value: any, context: ObjectSerializerContext) => void} serialize
- * @property {(context: ObjectDeserializerContext) => any} deserialize
+ * @property {(value: Value, context: ObjectSerializerContext) => void} serialize
+ * @property {(context: ObjectDeserializerContext) => Value} deserialize
  */
 
 /**
@@ -141,9 +140,8 @@ const loadedRequests = new Set();
 
 const NOT_SERIALIZABLE = {};
 
-/** @typedef {TODO} Item */
-
 const jsTypes = new Map();
+
 jsTypes.set(Object, new PlainObjectSerializer());
 jsTypes.set(Array, new ArraySerializer());
 jsTypes.set(null, new NullPrototypeObjectSerializer());
@@ -158,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.
@@ -195,10 +204,12 @@ for (const { request, name, serializer } of serializers.values()) {
 /** @type {Map<RegExp, (request: string) => boolean>} */
 const loaders = new Map();
 
+/** @typedef {ComplexSerializableType[]} DeserializedType */
+/** @typedef {PrimitiveSerializableType[]} SerializedType */
+/** @typedef {{ logger: Logger }} Context */
+
 /**
- * @typedef {ComplexSerializableType[]} DeserializedType
- * @typedef {PrimitiveSerializableType[]} SerializedType
- * @extends {SerializerMiddleware<DeserializedType, SerializedType>}
+ * @extends {SerializerMiddleware<DeserializedType, SerializedType, Context>}
  */
 class ObjectMiddleware extends SerializerMiddleware {
 	/**
@@ -266,7 +277,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 	}
 
 	/**
-	 * @param {TODO} object for serialization
+	 * @param {Constructor} object for serialization
 	 * @returns {SerializerConfigWithSerializer} Serializer config
 	 */
 	static getSerializerFor(object) {
@@ -324,13 +335,13 @@ class ObjectMiddleware extends SerializerMiddleware {
 	 * @returns {SerializedType | Promise<SerializedType> | null} serialized data
 	 */
 	serialize(data, context) {
-		/** @type {Item[]} */
+		/** @type {Value[]} */
 		let result = [CURRENT_VERSION];
 		let currentPos = 0;
-		/** @type {Map<Item, number>} */
+		/** @type {Map<ReferenceableItem, number>} */
 		let referenceable = new Map();
 		/**
-		 * @param {Item} item referenceable item
+		 * @param {ReferenceableItem} item referenceable item
 		 */
 		const addReferenceable = item => {
 			referenceable.set(item, currentPos++);
@@ -401,7 +412,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 		let objectTypeLookup = new Map();
 		const cycleStack = new Set();
 		/**
-		 * @param {Item} item item to stack
+		 * @param {Value} item item to stack
 		 * @returns {string} stack
 		 */
 		const stackToString = item => {
@@ -497,7 +508,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 		};
 		this.extendContext(ctx);
 		/**
-		 * @param {Item} item item to serialize
+		 * @param {Value} item item to serialize
 		 */
 		const process = item => {
 			if (Buffer.isBuffer(item)) {
@@ -587,9 +598,11 @@ class ObjectMiddleware extends SerializerMiddleware {
 			} else if (typeof item === "function") {
 				if (!SerializerMiddleware.isLazy(item))
 					throw new Error(`Unexpected function ${item}`);
-				/** @type {SerializedType} */
+
+				/** @type {SerializedType | undefined} */
 				const serializedData =
 					SerializerMiddleware.getLazySerializedValue(item);
+
 				if (serializedData !== undefined) {
 					if (typeof serializedData === "function") {
 						result.push(serializedData);
@@ -655,10 +668,10 @@ class ObjectMiddleware extends SerializerMiddleware {
 			throw new Error("Version mismatch, serializer changed");
 
 		let currentPos = 0;
-		/** @type {Item[]} */
+		/** @type {ReferenceableItem[]} */
 		let referenceable = [];
 		/**
-		 * @param {Item} item referenceable item
+		 * @param {Value} item referenceable item
 		 */
 		const addReferenceable = item => {
 			referenceable.push(item);
@@ -791,8 +804,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 				return item;
 			} else if (typeof item === "function") {
 				return SerializerMiddleware.deserializeLazy(
-					/** @type {LazyFunction<SerializedType>} */
-					(item),
+					item,
 					data =>
 						/** @type {[DeserializedType]} */
 						(this.deserialize(data, context))[0]

package/lib/serialization/Serializer.js

@@ -4,17 +4,20 @@
 
 "use strict";
 
-/** @typedef {import("./SerializerMiddleware").Context} Context */
-
 /**
- * @template T, K
- * @typedef {import("./SerializerMiddleware")<T, K>} SerializerMiddleware
+ * @template T, K, C
+ * @typedef {import("./SerializerMiddleware")<T, K, C>} SerializerMiddleware
  */
 
+/**
+ * @template DeserializedValue
+ * @template SerializedValue
+ * @template Context
+ */
 class Serializer {
 	/**
-	 * @param {SerializerMiddleware<any, any>[]} middlewares serializer middlewares
-	 * @param {Context} [context] context
+	 * @param {SerializerMiddleware<EXPECTED_ANY, EXPECTED_ANY, EXPECTED_ANY>[]} middlewares serializer middlewares
+	 * @param {Context=} context context
 	 */
 	constructor(middlewares, context) {
 		this.serializeMiddlewares = middlewares.slice();
@@ -23,17 +26,22 @@ class Serializer {
 	}
 
 	/**
-	 * @param {TODO | Promise<TODO>} obj object
-	 * @param {Context} context context object
-	 * @returns {Promise<TODO>} result
+	 * @template ExtendedContext
+	 * @param {DeserializedValue | Promise<DeserializedValue>} obj object
+	 * @param {Context & ExtendedContext} context context object
+	 * @returns {Promise<SerializedValue>} result
 	 */
 	serialize(obj, context) {
 		const ctx = { ...context, ...this.context };
 		let current = obj;
 		for (const middleware of this.serializeMiddlewares) {
-			if (current && typeof current.then === "function") {
+			if (
+				current &&
+				typeof (/** @type {Promise<DeserializedValue>} */ (current).then) ===
+					"function"
+			) {
 				current =
-					/** @type {Promise<TODO>} */
+					/** @type {Promise<DeserializedValue>} */
 					(current).then(data => data && middleware.serialize(data, ctx));
 			} else if (current) {
 				try {
@@ -43,26 +51,29 @@ class Serializer {
 				}
 			} else break;
 		}
-		return current;
+		return /** @type {Promise<SerializedValue>} */ (current);
 	}
 
 	/**
-	 * @param {TODO | Promise<TODO>} value value
-	 * @param {Context} context object
-	 * @returns {Promise<TODO>} result
+	 * @template ExtendedContext
+	 * @param {SerializedValue | Promise<SerializedValue>} value value
+	 * @param {Context & ExtendedContext} context object
+	 * @returns {Promise<DeserializedValue>} result
 	 */
 	deserialize(value, context) {
 		const ctx = { ...context, ...this.context };
 		let current = value;
 		for (const middleware of this.deserializeMiddlewares) {
 			current =
-				current && typeof current.then === "function"
-					? /** @type {Promise<TODO>} */ (current).then(data =>
+				current &&
+				typeof (/** @type {Promise<SerializedValue>} */ (current).then) ===
+					"function"
+					? /** @type {Promise<SerializedValue>} */ (current).then(data =>
 							middleware.deserialize(data, ctx)
 						)
 					: middleware.deserialize(current, ctx);
 		}
-		return current;
+		return /** @type {Promise<DeserializedValue>} */ (current);
 	}
 }
 

package/lib/serialization/SerializerMiddleware.js

@@ -9,23 +9,21 @@ const memoize = require("../util/memoize");
 const LAZY_TARGET = Symbol("lazy serialization target");
 const LAZY_SERIALIZED_VALUE = Symbol("lazy serialization data");
 
-/** @typedef {TODO} Context */
+/** @typedef {SerializerMiddleware<EXPECTED_ANY, EXPECTED_ANY, Record<string, EXPECTED_ANY>>} LazyTarget */
+/** @typedef {Record<string, EXPECTED_ANY>} LazyOptions */
 
 /**
- * @template LazyResult
- * @typedef {() => LazyResult | Promise<LazyResult>} InternalLazyFunction
- */
-
-/** @typedef {Record<string, any>} LazyOptions */
-
-/**
- * @template LazyResult
- * @typedef {InternalLazyFunction<LazyResult> & { [LAZY_TARGET]: TODO, [LAZY_SERIALIZED_VALUE]?: TODO, options: LazyOptions }} LazyFunction
+ * @template InputValue
+ * @template OutputValue
+ * @template {LazyTarget} InternalLazyTarget
+ * @template {LazyOptions | undefined} InternalLazyOptions
+ * @typedef {(() => InputValue | Promise<InputValue>) & Partial<{ [LAZY_TARGET]: InternalLazyTarget, options: InternalLazyOptions, [LAZY_SERIALIZED_VALUE]?: OutputValue | LazyFunction<OutputValue, InputValue, InternalLazyTarget, InternalLazyOptions> | undefined }>} LazyFunction
  */
 
 /**
  * @template DeserializedType
  * @template SerializedType
+ * @template Context
  */
 class SerializerMiddleware {
 	/* istanbul ignore next */
@@ -53,17 +51,25 @@ class SerializerMiddleware {
 	}
 
 	/**
-	 * @template LazyResult
-	 * @param {LazyFunction<LazyResult> | EXPECTED_ANY} value contained value or function to value
-	 * @param {SerializerMiddleware<any, any>} target target middleware
-	 * @param {LazyOptions=} options lazy options
-	 * @param {any=} serializedValue serialized value
-	 * @returns {LazyFunction<LazyResult>} lazy function
+	 * @template TLazyInputValue
+	 * @template TLazyOutputValue
+	 * @template {LazyTarget} TLazyTarget
+	 * @template {LazyOptions | undefined} TLazyOptions
+	 * @param {TLazyInputValue | (() => TLazyInputValue)} value contained value or function to value
+	 * @param {TLazyTarget} target target middleware
+	 * @param {TLazyOptions=} options lazy options
+	 * @param {TLazyOutputValue=} serializedValue serialized value
+	 * @returns {LazyFunction<TLazyInputValue, TLazyOutputValue, TLazyTarget, TLazyOptions>} lazy function
 	 */
-	static createLazy(value, target, options = {}, serializedValue = undefined) {
+	static createLazy(
+		value,
+		target,
+		options = /** @type {TLazyOptions} */ ({}),
+		serializedValue = undefined
+	) {
 		if (SerializerMiddleware.isLazy(value, target)) return value;
 		const fn =
-			/** @type {LazyFunction<LazyResult>} */
+			/** @type {LazyFunction<TLazyInputValue, TLazyOutputValue, TLazyTarget, TLazyOptions>} */
 			(typeof value === "function" ? value : () => value);
 		fn[LAZY_TARGET] = target;
 		fn.options = options;
@@ -72,9 +78,10 @@ class SerializerMiddleware {
 	}
 
 	/**
+	 * @template {LazyTarget} TLazyTarget
 	 * @param {EXPECTED_ANY} fn lazy function
-	 * @param {SerializerMiddleware<any, any>=} target target middleware
-	 * @returns {boolean} true, when fn is a lazy function (optionally of that target)
+	 * @param {TLazyTarget=} target target middleware
+	 * @returns {fn is LazyFunction<EXPECTED_ANY, EXPECTED_ANY, TLazyTarget, EXPECTED_ANY>} true, when fn is a lazy function (optionally of that target)
 	 */
 	static isLazy(fn, target) {
 		if (typeof fn !== "function") return false;
@@ -83,19 +90,26 @@ class SerializerMiddleware {
 	}
 
 	/**
-	 * @template LazyResult
-	 * @param {LazyFunction<LazyResult>} fn lazy function
+	 * @template TLazyInputValue
+	 * @template TLazyOutputValue
+	 * @template {LazyTarget} TLazyTarget
+	 * @template {Record<string, EXPECTED_ANY>} TLazyOptions
+	 * @template TLazySerializedValue
+	 * @param {LazyFunction<TLazyInputValue, TLazyOutputValue, TLazyTarget, TLazyOptions>} fn lazy function
 	 * @returns {LazyOptions | undefined} options
 	 */
 	static getLazyOptions(fn) {
 		if (typeof fn !== "function") return;
-		return /** @type {any} */ (fn).options;
+		return fn.options;
 	}
 
 	/**
-	 * @template LazyResult
-	 * @param {LazyFunction<LazyResult> | EXPECTED_ANY} fn lazy function
-	 * @returns {any | undefined} serialized value
+	 * @template TLazyInputValue
+	 * @template TLazyOutputValue
+	 * @template {LazyTarget} TLazyTarget
+	 * @template {LazyOptions} TLazyOptions
+	 * @param {LazyFunction<TLazyInputValue, TLazyOutputValue, TLazyTarget, TLazyOptions> | EXPECTED_ANY} fn lazy function
+	 * @returns {TLazyOutputValue | undefined} serialized value
 	 */
 	static getLazySerializedValue(fn) {
 		if (typeof fn !== "function") return;
@@ -103,9 +117,12 @@ class SerializerMiddleware {
 	}
 
 	/**
-	 * @template LazyResult
-	 * @param {LazyFunction<LazyResult>} fn lazy function
-	 * @param {TODO} value serialized value
+	 * @template TLazyInputValue
+	 * @template TLazyOutputValue
+	 * @template {LazyTarget} TLazyTarget
+	 * @template {LazyOptions} TLazyOptions
+	 * @param {LazyFunction<TLazyInputValue, TLazyOutputValue, LazyTarget, LazyOptions>} fn lazy function
+	 * @param {TLazyOutputValue} value serialized value
 	 * @returns {void}
 	 */
 	static setLazySerializedValue(fn, value) {
@@ -113,27 +130,33 @@ class SerializerMiddleware {
 	}
 
 	/**
-	 * @template LazyResult, R
-	 * @param {LazyFunction<LazyResult>} lazy lazy function
-	 * @param {(lazyResult: LazyResult) => Promise<R> | R} serialize serialize function
-	 * @returns {LazyFunction<R>} new lazy
+	 * @template TLazyInputValue DeserializedValue
+	 * @template TLazyOutputValue SerializedValue
+	 * @template {LazyTarget} TLazyTarget
+	 * @template {LazyOptions | undefined} TLazyOptions
+	 * @param {LazyFunction<TLazyInputValue, TLazyOutputValue, TLazyTarget, TLazyOptions>} lazy lazy function
+	 * @param {(value: TLazyInputValue) => TLazyOutputValue} serialize serialize function
+	 * @returns {LazyFunction<TLazyOutputValue, TLazyInputValue, TLazyTarget, TLazyOptions>} new lazy
 	 */
 	static serializeLazy(lazy, serialize) {
-		const fn = /** @type {LazyFunction<R>} */ (
-			memoize(() => {
-				const r = lazy();
-				if (
-					r &&
-					typeof (/** @type {Promise<LazyResult>} */ (r).then) === "function"
-				) {
-					return (
-						/** @type {Promise<LazyResult>} */
-						(r).then(data => data && serialize(data))
-					);
-				}
-				return serialize(/** @type {LazyResult} */ (r));
-			})
-		);
+		const fn =
+			/** @type {LazyFunction<TLazyOutputValue, TLazyInputValue, TLazyTarget, TLazyOptions>} */
+			(
+				memoize(() => {
+					const r = lazy();
+					if (
+						r &&
+						typeof (/** @type {Promise<TLazyInputValue>} */ (r).then) ===
+							"function"
+					) {
+						return (
+							/** @type {Promise<TLazyInputValue>} */
+							(r).then(data => data && serialize(data))
+						);
+					}
+					return serialize(/** @type {TLazyInputValue} */ (r));
+				})
+			);
 		fn[LAZY_TARGET] = lazy[LAZY_TARGET];
 		fn.options = lazy.options;
 		lazy[LAZY_SERIALIZED_VALUE] = fn;
@@ -141,27 +164,33 @@ class SerializerMiddleware {
 	}
 
 	/**
-	 * @template LazyResult, R
-	 * @param {LazyFunction<LazyResult>} lazy lazy function
-	 * @param {(lazyResult: LazyResult) => Promise<R> | R} deserialize deserialize function
-	 * @returns {LazyFunction<R>} new lazy
+	 * @template TLazyInputValue SerializedValue
+	 * @template TLazyOutputValue DeserializedValue
+	 * @template SerializedValue
+	 * @template {LazyTarget} TLazyTarget
+	 * @template {LazyOptions | undefined} TLazyOptions
+	 * @param {LazyFunction<TLazyInputValue, TLazyOutputValue, TLazyTarget, TLazyOptions>} lazy lazy function
+	 * @param {(data: TLazyInputValue) => TLazyOutputValue} deserialize deserialize function
+	 * @returns {LazyFunction<TLazyOutputValue, TLazyInputValue, TLazyTarget, TLazyOptions>} new lazy
 	 */
 	static deserializeLazy(lazy, deserialize) {
-		const fn = /** @type {LazyFunction<R>} */ (
-			memoize(() => {
-				const r = lazy();
-				if (
-					r &&
-					typeof (/** @type {Promise<LazyResult>} */ (r).then) === "function"
-				) {
-					return (
-						/** @type {Promise<LazyResult>} */
-						(r).then(data => deserialize(data))
-					);
-				}
-				return deserialize(/** @type {LazyResult} */ (r));
-			})
-		);
+		const fn =
+			/** @type {LazyFunction<TLazyOutputValue, TLazyInputValue, TLazyTarget, TLazyOptions>} */ (
+				memoize(() => {
+					const r = lazy();
+					if (
+						r &&
+						typeof (/** @type {Promise<TLazyInputValue>} */ (r).then) ===
+							"function"
+					) {
+						return (
+							/** @type {Promise<TLazyInputValue>} */
+							(r).then(data => deserialize(data))
+						);
+					}
+					return deserialize(/** @type {TLazyInputValue} */ (r));
+				})
+			);
 		fn[LAZY_TARGET] = lazy[LAZY_TARGET];
 		fn.options = lazy.options;
 		fn[LAZY_SERIALIZED_VALUE] = lazy;
@@ -169,20 +198,24 @@ class SerializerMiddleware {
 	}
 
 	/**
-	 * @template LazyResult
-	 * @param {LazyFunction<LazyResult> | EXPECTED_ANY} lazy lazy function
-	 * @returns {LazyFunction<LazyResult> | EXPECTED_ANY} new lazy
+	 * @template TLazyInputValue
+	 * @template TLazyOutputValue
+	 * @template {LazyTarget} TLazyTarget
+	 * @template {LazyOptions} TLazyOptions
+	 * @param {LazyFunction<TLazyInputValue | TLazyOutputValue, TLazyInputValue | TLazyOutputValue, TLazyTarget, TLazyOptions> | undefined} lazy lazy function
+	 * @returns {LazyFunction<TLazyInputValue | TLazyOutputValue, TLazyInputValue | TLazyOutputValue, TLazyTarget, TLazyOptions> | undefined} new lazy
 	 */
 	static unMemoizeLazy(lazy) {
 		if (!SerializerMiddleware.isLazy(lazy)) return lazy;
-		/** @type {LazyFunction<LazyResult>} */
+		/** @type {LazyFunction<TLazyInputValue | TLazyOutputValue, TLazyInputValue | TLazyOutputValue, TLazyTarget, TLazyOptions>} */
 		const fn = () => {
 			throw new Error(
 				"A lazy value that has been unmemorized can't be called again"
 			);
 		};
 		fn[LAZY_SERIALIZED_VALUE] = SerializerMiddleware.unMemoizeLazy(
-			lazy[LAZY_SERIALIZED_VALUE]
+			/** @type {LazyFunction<TLazyInputValue | TLazyOutputValue, TLazyInputValue | TLazyOutputValue, TLazyTarget, TLazyOptions>} */
+			(lazy[LAZY_SERIALIZED_VALUE])
 		);
 		fn[LAZY_TARGET] = lazy[LAZY_TARGET];
 		fn.options = lazy.options;