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

package/lib/schemes/HttpUriPlugin.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const EventEmitter = require("events");
+
 const { basename, extname } = require("path");
 const {
 	// eslint-disable-next-line n/no-unsupported-features/node-builtins
@@ -18,21 +19,29 @@ const createHash = require("../util/createHash");
 const { dirname, join, mkdirp } = require("../util/fs");
 const memoize = require("../util/memoize");
 
-/** @typedef {import("http").IncomingMessage} IncomingMessage */
-/** @typedef {import("http").OutgoingHttpHeaders} OutgoingHttpHeaders */
-/** @typedef {import("http").RequestOptions} RequestOptions */
-/** @typedef {import("net").Socket} Socket */
-/** @typedef {import("stream").Readable} Readable */
-/** @typedef {import("../../declarations/plugins/schemes/HttpUriPlugin").HttpUriPluginOptions} HttpUriPluginOptions */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../FileSystemInfo").Snapshot} Snapshot */
-/** @typedef {import("../Module").BuildInfo} BuildInfo */
-/** @typedef {import("../NormalModuleFactory").ResourceDataWithData} ResourceDataWithData */
-/** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
-/** @typedef {import("../NormalModule").NormalModuleBuildInfo} NormalModuleBuildInfo */
+const getHttps = memoize(() => require("https"));
 
 const getHttp = memoize(() => require("http"));
-const getHttps = memoize(() => require("https"));
+
+/**
+ * @import {
+ * 	IncomingMessage,
+ * 	OutgoingHttpHeaders,
+ * 	RequestOptions
+ * } from "http"
+ */
+/** @import { Socket } from "net" */
+/** @import { Readable } from "stream" */
+/**
+ * @import {
+ * 	HttpUriPluginOptions
+ * } from "../../declarations/plugins/schemes/HttpUriPlugin"
+ */
+/** @import Compiler from "../Compiler" */
+/** @import { Snapshot } from "../FileSystemInfo" */
+/** @import { ResourceDataWithData } from "../NormalModuleFactory" */
+/** @import { IntermediateFileSystem } from "../util/fs" */
+/** @import { NormalModuleBuildInfo } from "../NormalModule" */
 
 const MAX_REDIRECTS = 5;
 
@@ -140,7 +149,8 @@ const verifyIntegrity = (content, integrity) => {
 };
 
 /**
- * Parses key value pairs.
+ * Parses key value pairs. Keys are lower-cased because HTTP directive names are
+ * case-insensitive; values are kept verbatim (they may be quoted field lists).
  * @param {string} str input
  * @returns {Record<string, string>} parsed
  */
@@ -150,11 +160,11 @@ const parseKeyValuePairs = (str) => {
 	for (const item of str.split(",")) {
 		const i = item.indexOf("=");
 		if (i >= 0) {
-			const key = item.slice(0, i).trim();
+			const key = item.slice(0, i).trim().toLowerCase();
 			const value = item.slice(i + 1).trim();
 			result[key] = value;
 		} else {
-			const key = item.trim();
+			const key = item.trim().toLowerCase();
 			if (!key) continue;
 			result[key] = key;
 		}
@@ -177,7 +187,9 @@ const parseCacheControl = (cacheControl, requestTime) => {
 	let validUntil = 0;
 	if (cacheControl) {
 		const parsed = parseKeyValuePairs(cacheControl);
-		if (parsed["no-cache"]) storeCache = storeLock = false;
+		if (parsed["no-cache"] || parsed["no-store"]) {
+			storeCache = storeLock = false;
+		}
 		if (parsed["max-age"] && !Number.isNaN(Number(parsed["max-age"]))) {
 			validUntil = requestTime + Number(parsed["max-age"]) * 1000;
 		}
@@ -482,7 +494,7 @@ const cachedWithKey = (fn, forceFn = fn) => {
  * Defines the lockfile cache type used by this module.
  * @typedef {object} LockfileCache
  * @property {Lockfile} lockfile lockfile
- * @property {Snapshot} snapshot snapshot
+ * @property {InstanceType<Snapshot>} snapshot snapshot
  */
 
 /**
@@ -644,7 +656,7 @@ class HttpUriPlugin {
 											: new Lockfile();
 										lockfileCache = {
 											lockfile,
-											snapshot: /** @type {Snapshot} */ (s)
+											snapshot: /** @type {InstanceType<Snapshot>} */ (s)
 										};
 										callback(null, lockfile);
 									}
@@ -975,7 +987,11 @@ class HttpUriPlugin {
 							/** @type {Buffer[]} */
 							const bufferArr = [];
 
-							const contentEncoding = res.headers["content-encoding"];
+							// content codings are case-insensitive tokens
+							const contentEncodingHeader = res.headers["content-encoding"];
+							const contentEncoding =
+								contentEncodingHeader &&
+								contentEncodingHeader.trim().toLowerCase();
 							/** @type {Readable} */
 							let stream = res;
 							if (contentEncoding === "gzip") {
@@ -985,6 +1001,16 @@ class HttpUriPlugin {
 							} else if (contentEncoding === "deflate") {
 								stream = stream.pipe(createInflate());
 							}
+							if (stream !== res) {
+								// a decompressor error never reaches the request's handler
+								stream.once("error", (err) => {
+									logger.log(
+										`GET ${url} [${res.statusCode}] (invalid encoding)`
+									);
+									err.message += `\nwhile decompressing ${url}`;
+									callback(err);
+								});
+							}
 
 							stream.on(
 								"data",

package/lib/schemes/VirtualUrlPlugin.js

@@ -6,21 +6,27 @@
 "use strict";
 
 const NormalModule = require("../NormalModule");
-const ModuleNotFoundError = require("../errors/ModuleNotFoundError");
+
 const { getContext } = require("../loaders/LoaderRunner");
 const { isAbsolute, join } = require("../util/fs");
 const { parseResourceWithoutFragment } = require("../util/identifier");
+const memoize = require("../util/memoize");
+
+const getModuleNotFoundError = memoize(() =>
+	require("../errors/ModuleNotFoundError")
+);
 
 const DEFAULT_SCHEME = "virtual";
 
 const PLUGIN_NAME = "VirtualUrlPlugin";
 
+/** @import Compiler from "../Compiler" */
 /**
- * Defines the compiler type used by this module.
- * @typedef {import("../Compiler")} Compiler
- * @typedef {import("../../declarations/plugins/schemes/VirtualUrlPlugin").VirtualModule} VirtualModuleConfig
- * @typedef {import("../../declarations/plugins/schemes/VirtualUrlPlugin").VirtualModuleContent} VirtualModuleInput
- * @typedef {import("../../declarations/plugins/schemes/VirtualUrlPlugin").VirtualUrlOptions} VirtualUrlOptions
+ * @import {
+ * 	VirtualModule as VirtualModuleConfig,
+ * 	VirtualModuleContent as VirtualModuleInput,
+ * 	VirtualUrlOptions
+ * } from "../../declarations/plugins/schemes/VirtualUrlPlugin"
  */
 
 /** @typedef {(loaderContext: LoaderContext<EXPECTED_ANY>) => Promise<string | Buffer> | string | Buffer} SourceFn */
@@ -271,7 +277,7 @@ class VirtualUrlPlugin {
 	findVirtualModuleConfigById(id) {
 		const config = this.modules[id];
 		if (!config) {
-			throw new ModuleNotFoundError(
+			throw new (getModuleNotFoundError())(
 				null,
 				new Error(`Can't resolve virtual module ${id}`),
 				{

package/lib/serialization/AggregateErrorSerializer.js

@@ -4,7 +4,7 @@
 
 "use strict";
 
-/** @typedef {import("./types").ComplexSerializableType} ComplexSerializableType */
+/** @import { ComplexSerializableType } from "./types" */
 /** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext<ComplexSerializableType[]>} ObjectDeserializerContext */
 /** @typedef {import("./ObjectMiddleware").ObjectSerializerContext<ComplexSerializableType[]>} ObjectSerializerContext */
 

package/lib/serialization/BinaryMiddleware.js

@@ -8,8 +8,8 @@ const { deserialize: v8Deserialize, serialize: v8Serialize } = require("v8");
 const memoize = require("../util/memoize");
 const SerializerMiddleware = require("./SerializerMiddleware");
 
-/** @typedef {import("./types").BufferSerializableType} BufferSerializableType */
 /** @typedef {import("./types").PrimitiveSerializableType} PrimitiveSerializableType */
+/** @import { BufferSerializableType } from "./types" */
 
 /*
 Format:
@@ -579,7 +579,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 	}
 }
 
-module.exports = BinaryMiddleware;
+BinaryMiddleware.MEASURE_END_OPERATION = MEASURE_END_OPERATION;
+BinaryMiddleware.MEASURE_START_OPERATION = MEASURE_START_OPERATION;
 
-module.exports.MEASURE_END_OPERATION = MEASURE_END_OPERATION;
-module.exports.MEASURE_START_OPERATION = MEASURE_START_OPERATION;
+module.exports = BinaryMiddleware;

package/lib/serialization/ErrorObjectSerializer.js

@@ -4,7 +4,7 @@
 
 "use strict";
 
-/** @typedef {import("./types").ComplexSerializableType} ComplexSerializableType */
+/** @import { ComplexSerializableType } from "./types" */
 /** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext<ComplexSerializableType[]>} ObjectDeserializerContext */
 /** @typedef {import("./ObjectMiddleware").ObjectSerializerContext<ComplexSerializableType[]>} ObjectSerializerContext */
 

package/lib/serialization/FileMiddleware.js

@@ -31,10 +31,9 @@ const { dirname, join, mkdirp } = require("../util/fs");
 const memoize = require("../util/memoize");
 const SerializerMiddleware = require("./SerializerMiddleware");
 
-/** @typedef {import("../util/Hash").HashFunction} HashFunction */
-/** @typedef {import("../util/fs").IStats} IStats */
-/** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
-/** @typedef {import("./types").BufferSerializableType} BufferSerializableType */
+/** @import { HashFunction } from "../util/Hash" */
+/** @import { IStats, IntermediateFileSystem } from "../util/fs" */
+/** @import { BufferSerializableType } from "./types" */
 
 /*
 Format:
@@ -550,9 +549,13 @@ class FileMiddleware extends SerializerMiddleware {
 								});
 							}
 							if (compression) {
-								pipeline(compression, stream, reject);
+								// resolve on the pipeline, not on the transform's "finish":
+								// the latter fires before the destination has flushed
+								pipeline(compression, stream, (err) => {
+									if (err) return reject(err);
+									resolve();
+								});
 								stream = compression;
-								stream.on("finish", () => resolve());
 							} else {
 								stream.on("error", (err) => reject(err));
 								stream.on("finish", () => resolve());
@@ -794,6 +797,15 @@ class FileMiddleware extends SerializerMiddleware {
 										});
 										return;
 									}
+									// a file truncated after `stat` reads 0 bytes forever
+									if (bytesRead === 0 && remaining > 0) {
+										this.fs.close(fd, (err) => {
+											reject(
+												err || new Error(`Unexpected end of file ${file}`)
+											);
+										});
+										return;
+									}
 									/** @type {number} */
 									(currentBufferUsed) += bytesRead;
 									remaining -= bytesRead;
@@ -1046,7 +1058,8 @@ const getReferencedFilenames = (fs, file) =>
 		? getReferencedFilenamesCompressed(fs, file)
 		: getReferencedFilenamesUncompressed(fs, file);
 
-module.exports = FileMiddleware;
 // Exposed for testing the content-buffer boundary handling in `deserialize`.
-module.exports._deserialize = deserialize;
-module.exports.getReferencedFilenames = getReferencedFilenames;
+FileMiddleware._deserialize = deserialize;
+FileMiddleware.getReferencedFilenames = getReferencedFilenames;
+
+module.exports = FileMiddleware;

package/lib/serialization/ObjectMiddleware.js

@@ -17,11 +17,15 @@ const RegExpObjectSerializer = require("./RegExpObjectSerializer");
 const SerializerMiddleware = require("./SerializerMiddleware");
 const SetObjectSerializer = require("./SetObjectSerializer");
 
-/** @typedef {import("../logging/Logger").Logger} Logger */
-/** @typedef {import("../util/Hash").HashFunction} HashFunction */
-/** @typedef {import("./SerializerMiddleware").LazyOptions} LazyOptions */
-/** @typedef {import("./types").ComplexSerializableType} ComplexSerializableType */
-/** @typedef {import("./types").PrimitiveSerializableType} PrimitiveSerializableType */
+/** @import { Logger } from "../logging/Logger" */
+/** @import { HashFunction } from "../util/Hash" */
+/** @import { LazyOptions } from "./SerializerMiddleware" */
+/**
+ * @import {
+ * 	ComplexSerializableType,
+ * 	PrimitiveSerializableType
+ * } from "./types"
+ */
 
 /** @typedef {new (...params: EXPECTED_ANY[]) => EXPECTED_ANY} Constructor */
 
@@ -457,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();
@@ -569,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);
+					}
+
+					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)`
+						);
 					}
-					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);
+					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);
 			}
 		};
 
@@ -933,5 +957,6 @@ class ObjectMiddleware extends SerializerMiddleware {
 	}
 }
 
+ObjectMiddleware.NOT_SERIALIZABLE = NOT_SERIALIZABLE;
+
 module.exports = ObjectMiddleware;
-module.exports.NOT_SERIALIZABLE = NOT_SERIALIZABLE;

package/lib/serialization/PlainObjectSerializer.js

@@ -3,32 +3,32 @@
 */
 
 "use strict";
+/** @import { ObjectDeserializerContext, ObjectSerializerContext } from "./ObjectMiddleware" */
 
-/** @typedef {EXPECTED_FUNCTION} CacheAssoc */
+/** @typedef {ObjectSerializerContext<EXPECTED_ANY>["write"]} CacheAssoc */
 
 /**
  * Defines the shared type used by this module.
- * @template T
- * @typedef {WeakMap<CacheAssoc, ObjectStructure<T>>}
+ * @type {WeakMap<CacheAssoc, ObjectStructure<PropertyKey>>}
  */
 const cache = new WeakMap();
 
 /**
  * Represents ObjectStructure.
- * @template T
+ * @template {PropertyKey} K
  */
 class ObjectStructure {
 	constructor() {
-		/** @type {undefined | keyof T[]} */
+		/** @type {undefined | K[]} */
 		this.keys = undefined;
-		/** @type {undefined | Map<keyof T, ObjectStructure<T>>} */
+		/** @type {undefined | Map<K, ObjectStructure<K>>} */
 		this.children = undefined;
 	}
 
 	/**
 	 * Returns keys.
-	 * @param {keyof T[]} keys keys
-	 * @returns {keyof T[]} keys
+	 * @param {K[]} keys keys
+	 * @returns {K[]} keys
 	 */
 	getKeys(keys) {
 		if (this.keys === undefined) this.keys = keys;
@@ -37,13 +37,14 @@ class ObjectStructure {
 
 	/**
 	 * Returns object structure.
-	 * @param {keyof T} key key
-	 * @returns {ObjectStructure<T>} object structure
+	 * @param {K} key key
+	 * @returns {ObjectStructure<K>} object structure
 	 */
 	key(key) {
 		if (this.children === undefined) this.children = new Map();
 		const child = this.children.get(key);
 		if (child !== undefined) return child;
+		/** @type {ObjectStructure<K>} */
 		const newChild = new ObjectStructure();
 		this.children.set(key, newChild);
 		return newChild;
@@ -52,13 +53,15 @@ class ObjectStructure {
 
 /**
  * Returns keys.
- * @template T
- * @param {(keyof T)[]} keys keys
+ * @template {PropertyKey} K
+ * @param {K[]} keys keys
  * @param {CacheAssoc} cacheAssoc cache assoc fn
- * @returns {(keyof T)[]} keys
+ * @returns {K[]} keys
  */
 const getCachedKeys = (keys, cacheAssoc) => {
-	let root = cache.get(cacheAssoc);
+	let root = /** @type {ObjectStructure<K> | undefined} */ (
+		cache.get(cacheAssoc)
+	);
 	if (root === undefined) {
 		root = new ObjectStructure();
 		cache.set(cacheAssoc, root);
@@ -75,7 +78,7 @@ class PlainObjectSerializer {
 	 * Serializes this instance into the provided serializer context.
 	 * @template {object} T
 	 * @param {T} obj plain object
-	 * @param {import("./ObjectMiddleware").ObjectSerializerContext<((keyof T)[] | keyof T | null | T[keyof T])[]>} context context
+	 * @param {ObjectSerializerContext<((keyof T)[] | keyof T | null | T[keyof T])[]>} context context
 	 */
 	serialize(obj, context) {
 		const keys = /** @type {(keyof T)[]} */ (Object.keys(obj));
@@ -103,7 +106,7 @@ class PlainObjectSerializer {
 	/**
 	 * Restores this instance from the provided deserializer context.
 	 * @template {object} T
-	 * @param {import("./ObjectMiddleware").ObjectDeserializerContext<((keyof T)[] | keyof T | null | T[keyof T])[]>} context context
+	 * @param {ObjectDeserializerContext<((keyof T)[] | keyof T | null | T[keyof T])[]>} context context
 	 * @returns {T} plain object
 	 */
 	deserialize(context) {