webpack 5.98.0 → 5.99.1

package/lib/serialization/FileMiddleware.js

@@ -13,6 +13,7 @@ const {
 	createGunzip,
 	constants: zConstants
 } = require("zlib");
+const { DEFAULTS } = require("../config/defaults");
 const createHash = require("../util/createHash");
 const { dirname, join, mkdirp } = require("../util/fs");
 const memoize = require("../util/memoize");
@@ -21,8 +22,14 @@ 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:
 
@@ -58,7 +65,7 @@ const hashForName = (buffers, hashFunction) => {
 const COMPRESSION_CHUNK_SIZE = 100 * 1024 * 1024;
 const DECOMPRESSION_CHUNK_SIZE = 100 * 1024 * 1024;
 
-/** @type {function(Buffer, number, number): void} */
+/** @type {(buffer: Buffer, value: number, offset: number) => void} */
 const writeUInt64LE = Buffer.prototype.writeBigUInt64LE
 	? (buf, value, offset) => {
 			buf.writeBigUInt64LE(BigInt(value), offset);
@@ -70,7 +77,7 @@ const writeUInt64LE = Buffer.prototype.writeBigUInt64LE
 			buf.writeUInt32LE(high, offset + 4);
 		};
 
-/** @type {function(Buffer, number): void} */
+/** @type {(buffer: Buffer, offset: number) => void} */
 const readUInt64LE = Buffer.prototype.readBigUInt64LE
 	? (buf, offset) => Number(buf.readBigUInt64LE(offset))
 	: (buf, offset) => {
@@ -79,18 +86,20 @@ const readUInt64LE = Buffer.prototype.readBigUInt64LE
 			return high * 0x100000000 + low;
 		};
 
+/** @typedef {Promise<void | void[]>} BackgroundJob */
+
 /**
  * @typedef {object} SerializeResult
  * @property {string | false} name
  * @property {number} size
- * @property {Promise<any>=} backgroundJob
+ * @property {BackgroundJob=} backgroundJob
  */
 
 /**
  * @param {FileMiddleware} middleware this
  * @param {BufferSerializableType[] | Promise<BufferSerializableType[]>} data data to be serialized
  * @param {string | boolean} name file base name
- * @param {function(string | false, Buffer[], number): Promise<void>} writeFile writes a file
+ * @param {(name: string | false, buffers: Buffer[], size: number) => Promise<void>} writeFile writes a file
  * @param {string | Hash} hashFunction hash function to use
  * @returns {Promise<SerializeResult>} resulting file pointer and promise
  */
@@ -99,11 +108,11 @@ const serialize = async (
 	data,
 	name,
 	writeFile,
-	hashFunction = "md4"
+	hashFunction = DEFAULTS.HASH_FUNCTION
 ) => {
-	/** @type {(Buffer[] | Buffer | SerializeResult | Promise<SerializeResult>)[]} */
+	/** @type {(Buffer[] | Buffer | Promise<SerializeResult>)[]} */
 	const processedData = [];
-	/** @type {WeakMap<SerializeResult, function(): any | Promise<any>>} */
+	/** @type {WeakMap<SerializeResult, LazyFunction<BufferSerializableType[]>>} */
 	const resultToLazy = new WeakMap();
 	/** @type {Buffer[] | undefined} */
 	let lastBuffers;
@@ -129,7 +138,10 @@ const serialize = async (
 			} else {
 				const content = item();
 				if (content) {
-					const options = SerializerMiddleware.getLazyOptions(item);
+					const options = SerializerMiddleware.getLazyOptions(
+						/** @type {LazyFunction<Buffer[]>} */
+						(item)
+					);
 					processedData.push(
 						serialize(
 							middleware,
@@ -138,8 +150,13 @@ const serialize = async (
 							writeFile,
 							hashFunction
 						).then(result => {
-							/** @type {any} */ (item).options.size = result.size;
-							resultToLazy.set(result, item);
+							/** @type {LazyFunction<Buffer[]>} */
+							(item).options.size = result.size;
+							resultToLazy.set(
+								result,
+								/** @type {LazyFunction<Buffer[]>} */
+								(item)
+							);
 							return result;
 						})
 					);
@@ -160,24 +177,24 @@ const serialize = async (
 			throw new Error("Unexpected falsy value in items array");
 		}
 	}
-	/** @type {Promise<any>[]} */
+	/** @type {BackgroundJob[]} */
 	const backgroundJobs = [];
-	const resolvedData = (
-		await Promise.all(
-			/** @type {Promise<Buffer[] | Buffer | SerializeResult>[]} */
-			(processedData)
-		)
-	).map(item => {
+	const resolvedData = (await Promise.all(processedData)).map(item => {
 		if (Array.isArray(item) || Buffer.isBuffer(item)) return item;
 
-		backgroundJobs.push(item.backgroundJob);
+		backgroundJobs.push(
+			/** @type {BackgroundJob} */
+			(item.backgroundJob)
+		);
 		// create pointer buffer from size and name
 		const name = /** @type {string} */ (item.name);
 		const nameBuffer = Buffer.from(name);
 		const buf = Buffer.allocUnsafe(8 + nameBuffer.length);
 		writeUInt64LE(buf, item.size, 0);
 		nameBuffer.copy(buf, 8, 0);
-		const lazy = resultToLazy.get(item);
+		const lazy =
+			/** @type {LazyFunction<BufferSerializableType[]>} */
+			(resultToLazy.get(item));
 		SerializerMiddleware.setLazySerializedValue(lazy, buf);
 		return buf;
 	});
@@ -225,14 +242,14 @@ const serialize = async (
 		backgroundJob:
 			backgroundJobs.length === 1
 				? backgroundJobs[0]
-				: Promise.all(backgroundJobs)
+				: /** @type {BackgroundJob} */ (Promise.all(backgroundJobs))
 	};
 };
 
 /**
  * @param {FileMiddleware} middleware this
  * @param {string | false} name filename
- * @param {function(string | false): Promise<Buffer[]>} readFile read content of a file
+ * @param {(name: string | false) => Promise<Buffer[]>} readFile read content of a file
  * @returns {Promise<BufferSerializableType[]>} deserialized data
  */
 const deserialize = async (middleware, name, readFile) => {
@@ -334,6 +351,7 @@ const deserialize = async (middleware, name, readFile) => {
 			lastLengthPositive = valuePositive;
 		}
 	}
+	/** @type {(Buffer | LazyFunction<BufferSerializableType[]>)[]} */
 	const result = [];
 	for (let length of lengths) {
 		if (length < 0) {
@@ -341,17 +359,14 @@ const deserialize = async (middleware, name, readFile) => {
 			const size = Number(readUInt64LE(slice, 0));
 			const nameBuffer = slice.slice(8);
 			const name = nameBuffer.toString();
-			result.push(
-				SerializerMiddleware.createLazy(
-					memoize(() => deserialize(middleware, name, readFile)),
-					middleware,
-					{
-						name,
-						size
-					},
-					slice
-				)
+			/** @type {LazyFunction<BufferSerializableType[]>} */
+			const lazy = SerializerMiddleware.createLazy(
+				memoize(() => deserialize(middleware, name, readFile)),
+				middleware,
+				{ name, size },
+				slice
 			);
+			result.push(lazy);
 		} else {
 			if (contentPosition === contentItemLength) {
 				nextContent();
@@ -420,7 +435,7 @@ class FileMiddleware extends SerializerMiddleware {
 	 * @param {IntermediateFileSystem} fs filesystem
 	 * @param {string | Hash} hashFunction hash function to use
 	 */
-	constructor(fs, hashFunction = "md4") {
+	constructor(fs, hashFunction = DEFAULTS.HASH_FUNCTION) {
 		super();
 		this.fs = fs;
 		this._hashFunction = hashFunction;
@@ -428,8 +443,8 @@ class FileMiddleware extends SerializerMiddleware {
 
 	/**
 	 * @param {DeserializedType} data data
-	 * @param {object} context context object
-	 * @returns {SerializedType|Promise<SerializedType>} serialized data
+	 * @param {Context} context context object
+	 * @returns {SerializedType | Promise<SerializedType> | null} serialized data
 	 */
 	serialize(data, context) {
 		const { filename, extension = "" } = context;
@@ -483,7 +498,7 @@ class FileMiddleware extends SerializerMiddleware {
 								stream.on("finish", () => resolve());
 							}
 							// split into chunks for WRITE_LIMIT_CHUNK size
-							/** @type {TODO[]} */
+							/** @type {Buffer[]} */
 							const chunks = [];
 							for (const b of content) {
 								if (b.length < WRITE_LIMIT_CHUNK) {
@@ -590,14 +605,14 @@ class FileMiddleware extends SerializerMiddleware {
 
 	/**
 	 * @param {SerializedType} data data
-	 * @param {object} context context object
-	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
+	 * @param {Context} context context object
+	 * @returns {DeserializedType | Promise<DeserializedType>} deserialized data
 	 */
 	deserialize(data, context) {
 		const { filename, extension = "" } = context;
 		/**
 		 * @param {string | boolean} name name
-		 * @returns {Promise<TODO>} result
+		 * @returns {Promise<Buffer[]>} result
 		 */
 		const readFile = name =>
 			new Promise((resolve, reject) => {
@@ -614,7 +629,7 @@ class FileMiddleware extends SerializerMiddleware {
 					let currentBuffer;
 					/** @type {number | undefined} */
 					let currentBufferUsed;
-					/** @type {any[]} */
+					/** @type {Buffer[]} */
 					const buf = [];
 					/** @type {import("zlib").Zlib & import("stream").Transform | undefined} */
 					let decompression;
@@ -628,7 +643,12 @@ class FileMiddleware extends SerializerMiddleware {
 						});
 					}
 					if (decompression) {
+						/** @typedef {(value: Buffer[] | PromiseLike<Buffer[]>) => void} NewResolve */
+						/** @typedef {(reason?: Error) => void} NewReject */
+
+						/** @type {NewResolve | undefined} */
 						let newResolve;
+						/** @type {NewReject | undefined} */
 						let newReject;
 						resolve(
 							Promise.all([
@@ -636,15 +656,21 @@ class FileMiddleware extends SerializerMiddleware {
 									newResolve = rs;
 									newReject = rj;
 								}),
-								new Promise((resolve, reject) => {
-									decompression.on("data", chunk => buf.push(chunk));
-									decompression.on("end", () => resolve());
-									decompression.on("error", err => reject(err));
-								})
+								new Promise(
+									/**
+									 * @param {(value?: undefined) => void} resolve resolve
+									 * @param {(reason?: Error) => void} reject reject
+									 */
+									(resolve, reject) => {
+										decompression.on("data", chunk => buf.push(chunk));
+										decompression.on("end", () => resolve());
+										decompression.on("error", err => reject(err));
+									}
+								)
 							]).then(() => buf)
 						);
-						resolve = newResolve;
-						reject = newReject;
+						resolve = /** @type {NewResolve} */ (newResolve);
+						reject = /** @type {NewReject} */ (newReject);
 					}
 					this.fs.open(file, "r", (err, _fd) => {
 						if (err) {
@@ -694,12 +720,16 @@ class FileMiddleware extends SerializerMiddleware {
 									remaining -= bytesRead;
 									if (
 										currentBufferUsed ===
-										/** @type {Buffer} */ (currentBuffer).length
+										/** @type {Buffer} */
+										(currentBuffer).length
 									) {
 										if (decompression) {
 											decompression.write(currentBuffer);
 										} else {
-											buf.push(currentBuffer);
+											buf.push(
+												/** @type {Buffer} */
+												(currentBuffer)
+											);
 										}
 										currentBuffer = undefined;
 										if (remaining === 0) {

package/lib/serialization/ObjectMiddleware.js

@@ -4,6 +4,7 @@
 
 "use strict";
 
+const { DEFAULTS } = require("../config/defaults");
 const createHash = require("../util/createHash");
 const ArraySerializer = require("./ArraySerializer");
 const DateObjectSerializer = require("./DateObjectSerializer");
@@ -16,10 +17,16 @@ const SerializerMiddleware = require("./SerializerMiddleware");
 const SetObjectSerializer = require("./SetObjectSerializer");
 
 /** @typedef {typeof import("../util/Hash")} Hash */
+/** @typedef {import("./SerializerMiddleware").Context} Context */
 /** @typedef {import("./types").ComplexSerializableType} ComplexSerializableType */
 /** @typedef {import("./types").PrimitiveSerializableType} PrimitiveSerializableType */
 
-/** @typedef {new (...params: any[]) => any} Constructor */
+/** @typedef {new (...params: EXPECTED_ANY[]) => EXPECTED_ANY} Constructor */
+
+/**
+ * @template LAZY_RESULT
+ * @typedef {import("./SerializerMiddleware").LazyFunction<LAZY_RESULT>} LazyFunction
+ */
 
 /*
 
@@ -43,24 +50,36 @@ Technically any value can be used.
 
 */
 
+/**
+ * @typedef {object} ObjectSerializerSnapshot
+ * @property {number} length
+ * @property {number} cycleStackSize
+ * @property {number} referenceableSize
+ * @property {number} currentPos
+ * @property {number} objectTypeLookupSize
+ * @property {number} currentPosTypeLookup
+ */
+
 /**
  * @typedef {object} ObjectSerializerContext
- * @property {function(any): void} write
- * @property {(function(any): void)=} writeLazy
- * @property {(function(any, object=): (() => Promise<any> | any))=} writeSeparate
- * @property {function(any): void} setCircularReference
+ * @property {(value: any) => void} write
+ * @property {(value: any) => void} setCircularReference
+ * @property {() => ObjectSerializerSnapshot} snapshot
+ * @property {(snapshot: ObjectSerializerSnapshot) => void} rollback
+ * @property {((item: any) => void)=} writeLazy
+ * @property {((item: any, obj?: TODO) => (() => Promise<any> | any))=} writeSeparate
  */
 
 /**
  * @typedef {object} ObjectDeserializerContext
- * @property {function(): any} read
- * @property {function(any): void} setCircularReference
+ * @property {() => any} read
+ * @property {(value: any) => void} setCircularReference
  */
 
 /**
  * @typedef {object} ObjectSerializer
- * @property {function(any, ObjectSerializerContext): void} serialize
- * @property {function(ObjectDeserializerContext): any} deserialize
+ * @property {(value: any, context: ObjectSerializerContext) => void} serialize
+ * @property {(context: ObjectDeserializerContext) => any} deserialize
  */
 
 /**
@@ -109,7 +128,10 @@ const ESCAPE_UNDEFINED = false;
 
 const CURRENT_VERSION = 2;
 
-/** @type {Map<Constructor, { request?: string, name?: string | number | null, serializer?: ObjectSerializer }>} */
+/** @typedef {{ request?: string, name?: string | number | null, serializer?: ObjectSerializer }} SerializerConfig */
+/** @typedef {{ request?: string, name?: string | number | null, serializer: ObjectSerializer }} SerializerConfigWithSerializer */
+
+/** @type {Map<Constructor, SerializerConfig>} */
 const serializers = new Map();
 /** @type {Map<string | number, ObjectSerializer>} */
 const serializerInversed = new Map();
@@ -119,6 +141,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());
@@ -134,14 +158,14 @@ jsTypes.set(ReferenceError, new ErrorObjectSerializer(ReferenceError));
 jsTypes.set(SyntaxError, new ErrorObjectSerializer(SyntaxError));
 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
+// 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, n/exports-style
-	const Obj = /** @type {typeof Object} */ (exports.constructor);
-	const Fn = /** @type {typeof Function} */ (Obj.constructor);
+	// eslint-disable-next-line n/exports-style
+	const Obj = /** @type {ObjectConstructor} */ (exports.constructor);
+	const Fn = /** @type {FunctionConstructor} */ (Obj.constructor);
 	for (const [type, config] of Array.from(jsTypes)) {
 		if (type) {
 			const Type = new Fn(`return ${type.name};`)();
@@ -178,10 +202,10 @@ const loaders = new Map();
  */
 class ObjectMiddleware extends SerializerMiddleware {
 	/**
-	 * @param {function(any): void} extendContext context extensions
+	 * @param {(context: ObjectSerializerContext | ObjectDeserializerContext) => void} extendContext context extensions
 	 * @param {string | Hash} hashFunction hash function to use
 	 */
-	constructor(extendContext, hashFunction = "md4") {
+	constructor(extendContext, hashFunction = DEFAULTS.HASH_FUNCTION) {
 		super();
 		this.extendContext = extendContext;
 		this._hashFunction = hashFunction;
@@ -189,7 +213,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 
 	/**
 	 * @param {RegExp} regExp RegExp for which the request is tested
-	 * @param {function(string): boolean} loader loader to load the request, returns true when successful
+	 * @param {(request: string) => boolean} loader loader to load the request, returns true when successful
 	 * @returns {void}
 	 */
 	static registerLoader(regExp, loader) {
@@ -241,6 +265,10 @@ class ObjectMiddleware extends SerializerMiddleware {
 		serializers.set(Constructor, NOT_SERIALIZABLE);
 	}
 
+	/**
+	 * @param {TODO} object for serialization
+	 * @returns {SerializerConfigWithSerializer} Serializer config
+	 */
 	static getSerializerFor(object) {
 		const proto = Object.getPrototypeOf(object);
 		let c;
@@ -260,12 +288,12 @@ class ObjectMiddleware extends SerializerMiddleware {
 		if (!config) throw new Error(`No serializer registered for ${c.name}`);
 		if (config === NOT_SERIALIZABLE) throw NOT_SERIALIZABLE;
 
-		return config;
+		return /** @type {SerializerConfigWithSerializer} */ (config);
 	}
 
 	/**
 	 * @param {string} request request
-	 * @param {TODO} name name
+	 * @param {string} name name
 	 * @returns {ObjectSerializer} serializer
 	 */
 	static getDeserializerFor(request, name) {
@@ -292,14 +320,18 @@ class ObjectMiddleware extends SerializerMiddleware {
 
 	/**
 	 * @param {DeserializedType} data data
-	 * @param {object} context context object
-	 * @returns {SerializedType|Promise<SerializedType>} serialized data
+	 * @param {Context} context context object
+	 * @returns {SerializedType | Promise<SerializedType> | null} serialized data
 	 */
 	serialize(data, context) {
-		/** @type {any[]} */
+		/** @type {Item[]} */
 		let result = [CURRENT_VERSION];
 		let currentPos = 0;
+		/** @type {Map<Item, number>} */
 		let referenceable = new Map();
+		/**
+		 * @param {Item} item referenceable item
+		 */
 		const addReferenceable = item => {
 			referenceable.set(item, currentPos++);
 		};
@@ -368,6 +400,10 @@ class ObjectMiddleware extends SerializerMiddleware {
 		let currentPosTypeLookup = 0;
 		let objectTypeLookup = new Map();
 		const cycleStack = new Set();
+		/**
+		 * @param {Item} item item to stack
+		 * @returns {string} stack
+		 */
 		const stackToString = item => {
 			const arr = Array.from(cycleStack);
 			arr.push(item);
@@ -411,15 +447,16 @@ class ObjectMiddleware extends SerializerMiddleware {
 					try {
 						return `${item}`;
 					} catch (err) {
-						return `(${err.message})`;
+						return `(${/** @type {Error} */ (err).message})`;
 					}
 				})
 				.join(" -> ");
 		};
 		/** @type {WeakSet<Error>} */
 		let hasDebugInfoAttached;
+		/** @type {ObjectSerializerContext} */
 		let ctx = {
-			write(value, key) {
+			write(value) {
 				try {
 					process(value);
 				} catch (err) {
@@ -459,6 +496,9 @@ class ObjectMiddleware extends SerializerMiddleware {
 			...context
 		};
 		this.extendContext(ctx);
+		/**
+		 * @param {Item} item item to serialize
+		 */
 		const process = item => {
 			if (Buffer.isBuffer(item)) {
 				// check if we can emit a reference
@@ -599,8 +639,8 @@ class ObjectMiddleware extends SerializerMiddleware {
 
 	/**
 	 * @param {SerializedType} data data
-	 * @param {object} context context object
-	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
+	 * @param {Context} context context object
+	 * @returns {DeserializedType | Promise<DeserializedType>} deserialized data
 	 */
 	deserialize(data, context) {
 		let currentDataPos = 0;
@@ -615,14 +655,20 @@ class ObjectMiddleware extends SerializerMiddleware {
 			throw new Error("Version mismatch, serializer changed");
 
 		let currentPos = 0;
+		/** @type {Item[]} */
 		let referenceable = [];
+		/**
+		 * @param {Item} item referenceable item
+		 */
 		const addReferenceable = item => {
 			referenceable.push(item);
 			currentPos++;
 		};
 		let currentPosTypeLookup = 0;
+		/** @type {ObjectSerializer[]} */
 		let objectTypeLookup = [];
 		let result = [];
+		/** @type {ObjectDeserializerContext} */
 		let ctx = {
 			read() {
 				return decodeValue();
@@ -745,8 +791,11 @@ class ObjectMiddleware extends SerializerMiddleware {
 				return item;
 			} else if (typeof item === "function") {
 				return SerializerMiddleware.deserializeLazy(
-					item,
-					data => this.deserialize(data, context)[0]
+					/** @type {LazyFunction<SerializedType>} */
+					(item),
+					data =>
+						/** @type {[DeserializedType]} */
+						(this.deserialize(data, context))[0]
 				);
 			} else {
 				return item;

package/lib/serialization/PlainObjectSerializer.js

@@ -7,7 +7,7 @@
 /** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
-/** @typedef {(arg0?: any) => void} CacheAssoc */
+/** @typedef {EXPECTED_FUNCTION} CacheAssoc */
 
 /**
  * @template T

package/lib/serialization/Serializer.js

@@ -4,6 +4,8 @@
 
 "use strict";
 
+/** @typedef {import("./SerializerMiddleware").Context} Context */
+
 /**
  * @template T, K
  * @typedef {import("./SerializerMiddleware")<T, K>} SerializerMiddleware
@@ -12,7 +14,7 @@
 class Serializer {
 	/**
 	 * @param {SerializerMiddleware<any, any>[]} middlewares serializer middlewares
-	 * @param {TODO=} context context
+	 * @param {Context} [context] context
 	 */
 	constructor(middlewares, context) {
 		this.serializeMiddlewares = middlewares.slice();
@@ -21,16 +23,18 @@ class Serializer {
 	}
 
 	/**
-	 * @param {any} obj object
-	 * @param {TODO} context content
-	 * @returns {Promise<any>} result
+	 * @param {TODO | Promise<TODO>} obj object
+	 * @param {Context} context context object
+	 * @returns {Promise<TODO>} result
 	 */
 	serialize(obj, context) {
 		const ctx = { ...context, ...this.context };
 		let current = obj;
 		for (const middleware of this.serializeMiddlewares) {
 			if (current && typeof current.then === "function") {
-				current = current.then(data => data && middleware.serialize(data, ctx));
+				current =
+					/** @type {Promise<TODO>} */
+					(current).then(data => data && middleware.serialize(data, ctx));
 			} else if (current) {
 				try {
 					current = middleware.serialize(current, ctx);
@@ -43,18 +47,19 @@ class Serializer {
 	}
 
 	/**
-	 * @param {any} value value
-	 * @param {TODO} context context
-	 * @returns {Promise<any>} result
+	 * @param {TODO | Promise<TODO>} value value
+	 * @param {Context} context object
+	 * @returns {Promise<TODO>} result
 	 */
 	deserialize(value, context) {
 		const ctx = { ...context, ...this.context };
-		/** @type {any} */
 		let current = value;
 		for (const middleware of this.deserializeMiddlewares) {
 			current =
 				current && typeof current.then === "function"
-					? current.then(data => middleware.deserialize(data, ctx))
+					? /** @type {Promise<TODO>} */ (current).then(data =>
+							middleware.deserialize(data, ctx)
+						)
 					: middleware.deserialize(current, ctx);
 		}
 		return current;