@depup/webpack 5.106.1-depup.0 → 5.109.2-depup.0

package/lib/serialization/MapObjectSerializer.js

@@ -4,14 +4,12 @@
 
 "use strict";
 
-/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-
 class MapObjectSerializer {
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @template K, V
 	 * @param {Map<K, V>} obj map
-	 * @param {ObjectSerializerContext} context context
+	 * @param {import("./ObjectMiddleware").ObjectSerializerContext<(number | K | V)[]>} context context
 	 */
 	serialize(obj, context) {
 		context.write(obj.size);
@@ -24,22 +22,22 @@ class MapObjectSerializer {
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @template K, V
-	 * @param {ObjectDeserializerContext} context context
+	 * @param {import("./ObjectMiddleware").ObjectDeserializerContext<(number | K | V)[]>} context context
 	 * @returns {Map<K, V>} map
 	 */
 	deserialize(context) {
-		/** @type {number} */
-		const size = context.read();
+		const size = /** @type {number} */ (context.read());
 		/** @type {Map<K, V>} */
 		const map = new Map();
 		/** @type {K[]} */
 		const keys = [];
 		for (let i = 0; i < size; i++) {
-			keys.push(context.read());
+			keys.push(/** @type {K} */ (context.read()));
 		}
 		for (let i = 0; i < size; i++) {
-			map.set(keys[i], context.read());
+			map.set(keys[i], /** @type {V} */ (context.read()));
 		}
 		return map;
 	}

package/lib/serialization/NullPrototypeObjectSerializer.js

@@ -4,16 +4,14 @@
 
 "use strict";
 
-/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-
 /** @typedef {string[]} Keys */
 
 class NullPrototypeObjectSerializer {
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @template {object} T
 	 * @param {T} obj null object
-	 * @param {ObjectSerializerContext} context context
+	 * @param {import("./ObjectMiddleware").ObjectSerializerContext<(string | null | T[keyof T])[]>} context context
 	 */
 	serialize(obj, context) {
 		/** @type {Keys} */
@@ -28,8 +26,9 @@ class NullPrototypeObjectSerializer {
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @template {object} T
-	 * @param {ObjectDeserializerContext} context context
+	 * @param {import("./ObjectMiddleware").ObjectDeserializerContext<(string | null | T[keyof T])[]>} context context
 	 * @returns {T} null object
 	 */
 	deserialize(context) {
@@ -37,14 +36,15 @@ class NullPrototypeObjectSerializer {
 		const obj = Object.create(null);
 		/** @type {Keys} */
 		const keys = [];
-		/** @type {Keys[number] | null} */
-		let key = context.read();
+		let key = /** @type {string | null} */ (context.read());
 		while (key !== null) {
 			keys.push(key);
-			key = context.read();
+			key = /** @type {string | null} */ (context.read());
 		}
 		for (const key of keys) {
-			obj[/** @type {keyof T} */ (key)] = context.read();
+			obj[/** @type {keyof T} */ (key)] = /** @type {T[keyof T]} */ (
+				context.read()
+			);
 		}
 		return obj;
 	}

package/lib/serialization/ObjectMiddleware.js

@@ -48,6 +48,7 @@ Technically any value can be used.
 */
 
 /**
+ * Defines the object serializer snapshot type used by this module.
  * @typedef {object} ObjectSerializerSnapshot
  * @property {number} length
  * @property {number} cycleStackSize
@@ -60,8 +61,23 @@ Technically any value can be used.
 /** @typedef {EXPECTED_OBJECT | string} ReferenceableItem */
 
 /**
+ * First tuple element; element type for an open array; `EXPECTED_ANY` once exhausted.
+ * @template {readonly EXPECTED_ANY[]} T
+ * @typedef {T extends readonly [infer H, ...EXPECTED_ANY[]] ? H : T extends readonly [] ? EXPECTED_ANY : T extends readonly (infer E)[] ? E : never} Head
+ */
+
+/**
+ * Tuple without its first element; unchanged when `T` is an open array.
+ * @template {readonly EXPECTED_ANY[]} T
+ * @typedef {T extends readonly [EXPECTED_ANY, ...infer R] ? R : T} Tail
+ */
+
+/**
+ * Defines the object serializer context type used by this module.
+ * `T` is the tuple of values written in order; each `write` consumes the head.
+ * @template {readonly EXPECTED_ANY[]} [T=readonly EXPECTED_ANY[]]
  * @typedef {object} ObjectSerializerContext
- * @property {(value: EXPECTED_ANY) => void} write
+ * @property {(value: Head<T>) => ObjectSerializerContext<Tail<T>>} write
  * @property {(value: ReferenceableItem) => void} setCircularReference
  * @property {() => ObjectSerializerSnapshot} snapshot
  * @property {(snapshot: ObjectSerializerSnapshot) => void} rollback
@@ -70,18 +86,25 @@ Technically any value can be used.
  */
 
 /**
+ * Defines the object deserializer context type used by this module.
+ * `T` is the tuple of values read in order: `read` returns the head, and `rest`
+ * re-types the same context to `Tail<T>` so successive reads stay positional.
+ * @template {readonly EXPECTED_ANY[]} [T=readonly EXPECTED_ANY[]]
  * @typedef {object} ObjectDeserializerContext
- * @property {() => EXPECTED_ANY} read
+ * @property {() => Head<T>} read
+ * @property {ObjectDeserializerContext<Tail<T>>} rest
  * @property {(value: ReferenceableItem) => void} setCircularReference
  */
 
 /**
+ * Defines the object serializer type used by this module.
  * @typedef {object} ObjectSerializer
- * @property {(value: EXPECTED_ANY, context: ObjectSerializerContext) => void} serialize
- * @property {(context: ObjectDeserializerContext) => EXPECTED_ANY} deserialize
+ * @property {(value: EXPECTED_ANY, context: ObjectSerializerContext<EXPECTED_ANY>) => void} serialize
+ * @property {(context: ObjectDeserializerContext<EXPECTED_ANY>) => EXPECTED_ANY} deserialize
  */
 
 /**
+ * Updates set size using the provided set.
  * @template T
  * @param {Set<T>} set set
  * @param {number} size count of items to keep
@@ -96,6 +119,7 @@ const setSetSize = (set, size) => {
 };
 
 /**
+ * Updates map size using the provided map.
  * @template K, X
  * @param {Map<K, X>} map map
  * @param {number} size count of items to keep
@@ -110,6 +134,7 @@ const setMapSize = (map, size) => {
 };
 
 /**
+ * Returns hash.
  * @param {Buffer} buffer buffer
  * @param {HashFunction} hashFunction hash function to use
  * @returns {string} hash
@@ -207,13 +232,15 @@ const loaders = new Map();
 /** @typedef {PrimitiveSerializableType[]} SerializedType */
 /** @typedef {{ logger: Logger }} Context */
 
-/** @typedef {(context: ObjectSerializerContext | ObjectDeserializerContext) => void} ExtendContext */
+/** @typedef {(context: ObjectSerializerContext<EXPECTED_ANY> | ObjectDeserializerContext<EXPECTED_ANY>) => void} ExtendContext */
 
 /**
+ * Represents ObjectMiddleware.
  * @extends {SerializerMiddleware<DeserializedType, SerializedType, Context>}
  */
 class ObjectMiddleware extends SerializerMiddleware {
 	/**
+	 * Creates an instance of ObjectMiddleware.
 	 * @param {ExtendContext} extendContext context extensions
 	 * @param {HashFunction} hashFunction hash function to use
 	 */
@@ -226,6 +253,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 	}
 
 	/**
+	 * Processes the provided reg exp.
 	 * @param {RegExp} regExp RegExp for which the request is tested
 	 * @param {(request: string) => boolean} loader loader to load the request, returns true when successful
 	 * @returns {void}
@@ -235,6 +263,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 	}
 
 	/**
+	 * Processes the provided constructor.
 	 * @param {Constructor} Constructor the constructor
 	 * @param {string} request the request which will be required when deserializing
 	 * @param {string | null} name the name to make multiple serializer unique when sharing a request
@@ -266,6 +295,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 	}
 
 	/**
+	 * Register not serializable.
 	 * @param {Constructor} Constructor the constructor
 	 * @returns {void}
 	 */
@@ -280,6 +310,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 	}
 
 	/**
+	 * Gets serializer for.
 	 * @param {EXPECTED_ANY} object for serialization
 	 * @returns {SerializerConfigWithSerializer} Serializer config
 	 */
@@ -311,6 +342,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 	}
 
 	/**
+	 * Gets deserializer for.
 	 * @param {string} request request
 	 * @param {string} name name
 	 * @returns {ObjectSerializer} serializer
@@ -327,6 +359,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 	}
 
 	/**
+	 * Get deserializer for without error.
 	 * @param {string} request request
 	 * @param {string} name name
 	 * @returns {ObjectSerializer | undefined} serializer
@@ -338,6 +371,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {DeserializedType} data data
 	 * @param {Context} context context object
 	 * @returns {SerializedType | Promise<SerializedType> | null} serialized data
@@ -349,6 +383,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 		/** @type {Map<ReferenceableItem, number>} */
 		let referenceable = new Map();
 		/**
+		 * Adds referenceable.
 		 * @param {ReferenceableItem} item referenceable item
 		 */
 		const addReferenceable = (item) => {
@@ -357,6 +392,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 		/** @type {Map<number, Buffer | [Buffer, Buffer] | Map<string, Buffer>>} */
 		let bufferDedupeMap = new Map();
 		/**
+		 * Returns deduped buffer.
 		 * @param {Buffer} buf buffer
 		 * @returns {Buffer} deduped buffer
 		 */
@@ -426,6 +462,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 		/** @type {Set<ComplexSerializableType>} */
 		const cycleStack = new Set();
 		/**
+		 * Returns stack.
 		 * @param {ComplexSerializableType} item item to stack
 		 * @returns {string} stack
 		 */
@@ -487,11 +524,11 @@ class ObjectMiddleware extends SerializerMiddleware {
 		};
 		/** @type {undefined | WeakSet<Error>} */
 		let hasDebugInfoAttached;
-		/** @type {ObjectSerializerContext} */
+		/** @type {ObjectSerializerContext<EXPECTED_ANY>} */
 		let ctx = {
 			write(value) {
 				try {
-					process(value);
+					process(/** @type {ComplexSerializableType} */ (value));
 				} catch (err) {
 					if (err !== NOT_SERIALIZABLE) {
 						if (hasDebugInfoAttached === undefined) {
@@ -499,12 +536,14 @@ class ObjectMiddleware extends SerializerMiddleware {
 						}
 						if (!hasDebugInfoAttached.has(/** @type {Error} */ (err))) {
 							/** @type {Error} */
-							(err).message += `\nwhile serializing ${stackToString(value)}`;
+							(err).message +=
+								`\nwhile serializing ${stackToString(/** @type {ComplexSerializableType} */ (value))}`;
 							hasDebugInfoAttached.add(/** @type {Error} */ (err));
 						}
 					}
 					throw err;
 				}
+				return ctx;
 			},
 			setCircularReference(ref) {
 				addReferenceable(ref);
@@ -531,6 +570,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 		};
 		this.extendContext(ctx);
 		/**
+		 * Processes the provided item.
 		 * @param {ComplexSerializableType} item item to serialize
 		 */
 		const process = (item) => {
@@ -605,8 +645,19 @@ class ObjectMiddleware extends SerializerMiddleware {
 					// check if we can emit a reference
 					const ref = referenceable.get(item);
 					if (ref !== undefined) {
-						result.push(ESCAPE, ref - currentPos);
-						return;
+						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);
 				}
@@ -681,6 +732,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {SerializedType} data data
 	 * @param {Context} context context object
 	 * @returns {DeserializedType | Promise<DeserializedType>} deserialized data
@@ -703,6 +755,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 		/** @type {ReferenceableItem[]} */
 		let referenceable = [];
 		/**
+		 * Adds referenceable.
 		 * @param {ReferenceableItem} item referenceable item
 		 */
 		const addReferenceable = (item) => {
@@ -714,10 +767,14 @@ class ObjectMiddleware extends SerializerMiddleware {
 		let objectTypeLookup = [];
 		/** @type {ComplexSerializableType[]} */
 		let result = [];
-		/** @type {ObjectDeserializerContext} */
+		/** @type {ObjectDeserializerContext<EXPECTED_ANY>} */
 		let ctx = {
 			read() {
-				return decodeValue();
+				return /** @type {EXPECTED_ANY} */ (decodeValue());
+			},
+			// type-only cursor advance; same object, retyped to the tuple tail
+			get rest() {
+				return ctx;
 			},
 			setCircularReference(ref) {
 				addReferenceable(ref);
@@ -726,6 +783,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 		};
 		this.extendContext(ctx);
 		/**
+		 * Decodes the provided value.
 		 * @returns {ComplexSerializableType} deserialize value
 		 */
 		const decodeValue = () => {
@@ -836,7 +894,9 @@ class ObjectMiddleware extends SerializerMiddleware {
 				}
 
 				return item;
-			} else if (Buffer.isBuffer(item)) {
+			} else if (typeof item === "object") {
+				// Only non-null objects reach here (ESCAPE/null handled above), and
+				// the stream's only object type is Buffer — avoids a Buffer.isBuffer call
 				addReferenceable(item);
 
 				return item;

package/lib/serialization/PlainObjectSerializer.js

@@ -4,18 +4,17 @@
 
 "use strict";
 
-/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-
 /** @typedef {EXPECTED_FUNCTION} CacheAssoc */
 
 /**
+ * Defines the shared type used by this module.
  * @template T
  * @typedef {WeakMap<CacheAssoc, ObjectStructure<T>>}
  */
 const cache = new WeakMap();
 
 /**
+ * Represents ObjectStructure.
  * @template T
  */
 class ObjectStructure {
@@ -27,6 +26,7 @@ class ObjectStructure {
 	}
 
 	/**
+	 * Returns keys.
 	 * @param {keyof T[]} keys keys
 	 * @returns {keyof T[]} keys
 	 */
@@ -36,6 +36,7 @@ class ObjectStructure {
 	}
 
 	/**
+	 * Returns object structure.
 	 * @param {keyof T} key key
 	 * @returns {ObjectStructure<T>} object structure
 	 */
@@ -50,6 +51,7 @@ class ObjectStructure {
 }
 
 /**
+ * Returns keys.
  * @template T
  * @param {(keyof T)[]} keys keys
  * @param {CacheAssoc} cacheAssoc cache assoc fn
@@ -70,9 +72,10 @@ const getCachedKeys = (keys, cacheAssoc) => {
 
 class PlainObjectSerializer {
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @template {object} T
 	 * @param {T} obj plain object
-	 * @param {ObjectSerializerContext} context context
+	 * @param {import("./ObjectMiddleware").ObjectSerializerContext<((keyof T)[] | keyof T | null | T[keyof T])[]>} context context
 	 */
 	serialize(obj, context) {
 		const keys = /** @type {(keyof T)[]} */ (Object.keys(obj));
@@ -98,19 +101,24 @@ class PlainObjectSerializer {
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @template {object} T
-	 * @param {ObjectDeserializerContext} context context
+	 * @param {import("./ObjectMiddleware").ObjectDeserializerContext<((keyof T)[] | keyof T | null | T[keyof T])[]>} context context
 	 * @returns {T} plain object
 	 */
 	deserialize(context) {
-		const keys = context.read();
+		const keys = /** @type {(keyof T)[] | keyof T | null} */ (context.read());
 		const obj = /** @type {T} */ ({});
 		if (Array.isArray(keys)) {
 			for (const key of keys) {
-				obj[/** @type {keyof T} */ (key)] = context.read();
+				obj[/** @type {keyof T} */ (key)] = /** @type {T[keyof T]} */ (
+					context.read()
+				);
 			}
 		} else if (keys !== null) {
-			obj[/** @type {keyof T} */ (keys)] = context.read();
+			obj[/** @type {keyof T} */ (keys)] = /** @type {T[keyof T]} */ (
+				context.read()
+			);
 		}
 		return obj;
 	}

package/lib/serialization/RegExpObjectSerializer.js

@@ -4,11 +4,12 @@
 
 "use strict";
 
-/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext<[string, string]>} ObjectDeserializerContext */
+/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext<[string, string]>} ObjectSerializerContext */
 
 class RegExpObjectSerializer {
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {RegExp} obj regexp
 	 * @param {ObjectSerializerContext} context context
 	 */
@@ -18,6 +19,7 @@ class RegExpObjectSerializer {
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 * @returns {RegExp} regexp
 	 */

package/lib/serialization/Serializer.js

@@ -5,27 +5,32 @@
 "use strict";
 
 /**
+ * Defines the serializer middleware type used by this module.
  * @template T, K, C
  * @typedef {import("./SerializerMiddleware")<T, K, C>} SerializerMiddleware
  */
 
 /**
+ * Represents Serializer.
  * @template DeserializedValue
  * @template SerializedValue
  * @template Context
  */
 class Serializer {
 	/**
+	 * Creates an instance of Serializer.
 	 * @param {SerializerMiddleware<EXPECTED_ANY, EXPECTED_ANY, EXPECTED_ANY>[]} middlewares serializer middlewares
 	 * @param {Context=} context context
 	 */
 	constructor(middlewares, context) {
 		this.serializeMiddlewares = [...middlewares];
 		this.deserializeMiddlewares = [...middlewares].reverse();
+		/** @type {Context | undefined} */
 		this.context = context;
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @template ExtendedContext
 	 * @param {DeserializedValue | Promise<DeserializedValue>} obj object
 	 * @param {Context & ExtendedContext} context context object
@@ -57,6 +62,7 @@ class Serializer {
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @template ExtendedContext
 	 * @param {SerializedValue | Promise<SerializedValue>} value value
 	 * @param {Context & ExtendedContext} context object

package/lib/serialization/SerializerMiddleware.js

@@ -13,6 +13,7 @@ const LAZY_SERIALIZED_VALUE = Symbol("lazy serialization data");
 /** @typedef {Record<string, EXPECTED_ANY>} LazyOptions */
 
 /**
+ * Defines the lazy function type used by this module.
  * @template InputValue
  * @template OutputValue
  * @template {LazyTarget} InternalLazyTarget
@@ -21,6 +22,7 @@ const LAZY_SERIALIZED_VALUE = Symbol("lazy serialization data");
  */
 
 /**
+ * Represents SerializerMiddleware.
  * @template DeserializedType
  * @template SerializedType
  * @template Context
@@ -28,31 +30,34 @@ const LAZY_SERIALIZED_VALUE = Symbol("lazy serialization data");
 class SerializerMiddleware {
 	/* istanbul ignore next */
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @abstract
 	 * @param {DeserializedType} data data
 	 * @param {Context} context context object
 	 * @returns {SerializedType | Promise<SerializedType> | null} serialized data
 	 */
 	serialize(data, context) {
-		const AbstractMethodError = require("../AbstractMethodError");
+		const AbstractMethodError = require("../errors/AbstractMethodError");
 
 		throw new AbstractMethodError();
 	}
 
 	/* istanbul ignore next */
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @abstract
 	 * @param {SerializedType} data data
 	 * @param {Context} context context object
 	 * @returns {DeserializedType | Promise<DeserializedType>} deserialized data
 	 */
 	deserialize(data, context) {
-		const AbstractMethodError = require("../AbstractMethodError");
+		const AbstractMethodError = require("../errors/AbstractMethodError");
 
 		throw new AbstractMethodError();
 	}
 
 	/**
+	 * Creates a lazy from the provided value.
 	 * @template TLazyInputValue
 	 * @template TLazyOutputValue
 	 * @template {LazyTarget} TLazyTarget
@@ -80,6 +85,7 @@ class SerializerMiddleware {
 	}
 
 	/**
+	 * Checks whether this serializer middleware is lazy.
 	 * @template {LazyTarget} TLazyTarget
 	 * @param {EXPECTED_ANY} fn lazy function
 	 * @param {TLazyTarget=} target target middleware
@@ -92,6 +98,7 @@ class SerializerMiddleware {
 	}
 
 	/**
+	 * Returns options.
 	 * @template TLazyInputValue
 	 * @template TLazyOutputValue
 	 * @template {LazyTarget} TLazyTarget
@@ -105,6 +112,7 @@ class SerializerMiddleware {
 	}
 
 	/**
+	 * Gets lazy serialized value.
 	 * @template TLazyInputValue
 	 * @template TLazyOutputValue
 	 * @template {LazyTarget} TLazyTarget
@@ -118,6 +126,7 @@ class SerializerMiddleware {
 	}
 
 	/**
+	 * Sets lazy serialized value.
 	 * @template TLazyInputValue
 	 * @template TLazyOutputValue
 	 * @template {LazyTarget} TLazyTarget
@@ -131,6 +140,7 @@ class SerializerMiddleware {
 	}
 
 	/**
+	 * Returns new lazy.
 	 * @template TLazyInputValue DeserializedValue
 	 * @template TLazyOutputValue SerializedValue
 	 * @template {LazyTarget} TLazyTarget
@@ -165,6 +175,7 @@ class SerializerMiddleware {
 	}
 
 	/**
+	 * Returns new lazy.
 	 * @template TLazyInputValue SerializedValue
 	 * @template TLazyOutputValue DeserializedValue
 	 * @template {LazyTarget} TLazyTarget
@@ -198,6 +209,7 @@ class SerializerMiddleware {
 	}
 
 	/**
+	 * Returns new lazy.
 	 * @template TLazyInputValue
 	 * @template TLazyOutputValue
 	 * @template {LazyTarget} TLazyTarget

package/lib/serialization/SetObjectSerializer.js

@@ -4,14 +4,12 @@
 
 "use strict";
 
-/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-
 class SetObjectSerializer {
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @template T
 	 * @param {Set<T>} obj set
-	 * @param {ObjectSerializerContext} context context
+	 * @param {import("./ObjectMiddleware").ObjectSerializerContext<(number | T)[]>} context context
 	 */
 	serialize(obj, context) {
 		context.write(obj.size);
@@ -21,17 +19,17 @@ class SetObjectSerializer {
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @template T
-	 * @param {ObjectDeserializerContext} context context
+	 * @param {import("./ObjectMiddleware").ObjectDeserializerContext<(number | T)[]>} context context
 	 * @returns {Set<T>} date
 	 */
 	deserialize(context) {
-		/** @type {number} */
-		const size = context.read();
+		const size = /** @type {number} */ (context.read());
 		/** @type {Set<T>} */
 		const set = new Set();
 		for (let i = 0; i < size; i++) {
-			set.add(context.read());
+			set.add(/** @type {T} */ (context.read()));
 		}
 		return set;
 	}

package/lib/serialization/SingleItemMiddleware.js

@@ -11,10 +11,12 @@ const SerializerMiddleware = require("./SerializerMiddleware");
 /** @typedef {EXPECTED_OBJECT} Context */
 
 /**
+ * Represents SingleItemMiddleware.
  * @extends {SerializerMiddleware<DeserializedType, SerializedType, Context>}
  */
 class SingleItemMiddleware extends SerializerMiddleware {
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {DeserializedType} data data
 	 * @param {Context} context context object
 	 * @returns {SerializedType | Promise<SerializedType> | null} serialized data
@@ -24,6 +26,7 @@ class SingleItemMiddleware extends SerializerMiddleware {
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {SerializedType} data data
 	 * @param {Context} context context object
 	 * @returns {DeserializedType | Promise<DeserializedType>} deserialized data