webpack 5.99.5 → 5.99.6

package/lib/javascript/JavascriptParser.js

@@ -280,10 +280,13 @@ class VariableInfo {
 /**
  * @typedef {object} TagInfo
  * @property {Tag} tag
- * @property {TagData} [data]
+ * @property {TagData=} data
  * @property {TagInfo | undefined} next
  */
 
+const SCOPE_INFO_TERMINATED_RETURN = 1;
+const SCOPE_INFO_TERMINATED_THROW = 2;
+
 /**
  * @typedef {object} ScopeInfo
  * @property {StackedMap<string, VariableInfo | ScopeInfo>} definitions
@@ -293,8 +296,7 @@ class VariableInfo {
  * @property {boolean} inTry
  * @property {boolean} isStrict
  * @property {boolean} isAsmJs
- * @property {boolean} inExecutedPath false for unknown state
- * @property {undefined|"return"|"throw"} terminated
+ * @property {undefined | 1 | 2} terminated
  */
 
 /** @typedef {[number, number]} Range */
@@ -310,9 +312,9 @@ class VariableInfo {
  * Helper function for joining two ranges into a single range. This is useful
  * when working with AST nodes, as it allows you to combine the ranges of child nodes
  * to create the range of the _parent node_.
- * @param {[number, number]} startRange start range to join
- * @param {[number, number]} endRange end range to join
- * @returns {[number, number]} joined range
+ * @param {Range} startRange start range to join
+ * @param {Range} endRange end range to join
+ * @returns {Range} joined range
  * @example
  * ```js
  * 	const startRange = [0, 5];
@@ -827,8 +829,8 @@ class JavascriptParser extends Parser {
 					if (!right.isCompileTimeValue()) return;
 
 					const result = operandHandler(
-						left.asCompileTimeValue(),
-						right.asCompileTimeValue()
+						/** @type {T} */ (left.asCompileTimeValue()),
+						/** @type {T} */ (right.asCompileTimeValue())
 					);
 					return valueAsExpression(
 						result,
@@ -1231,7 +1233,9 @@ class JavascriptParser extends Parser {
 				const handleConstOperation = operandHandler => {
 					const argument = this.evaluateExpression(expr.argument);
 					if (!argument.isCompileTimeValue()) return;
-					const result = operandHandler(argument.asCompileTimeValue());
+					const result = operandHandler(
+						/** @type {T} */ (argument.asCompileTimeValue())
+					);
 					return valueAsExpression(
 						result,
 						expr,
@@ -2171,7 +2175,7 @@ class JavascriptParser extends Parser {
 			this.blockPreWalkStatements(body);
 			this.prevStatement = prev;
 			this.walkStatements(body);
-		}, this.scope.inExecutedPath);
+		}, true);
 	}
 
 	/**
@@ -2211,20 +2215,12 @@ class JavascriptParser extends Parser {
 
 			this.scope.terminated =
 				consequentTerminated && alternateTerminated
-					? this.scope.terminated
+					? alternateTerminated
 					: undefined;
-		} else {
-			const oldState = this.scope.inExecutedPath;
-
-			this.scope.inExecutedPath = true;
-
-			if (result) {
-				this.walkNestedStatement(statement.consequent);
-			} else if (statement.alternate) {
-				this.walkNestedStatement(statement.alternate);
-			}
-
-			this.scope.inExecutedPath = oldState;
+		} else if (result) {
+			this.walkNestedStatement(statement.consequent);
+		} else if (statement.alternate) {
+			this.walkNestedStatement(statement.alternate);
 		}
 	}
 
@@ -2290,7 +2286,9 @@ class JavascriptParser extends Parser {
 		if (this.scope.topLevelScope === true) return;
 		if (this.hooks.terminate.call(statement)) {
 			this.scope.terminated =
-				statement.type === "ReturnStatement" ? "return" : "throw";
+				statement.type === "ReturnStatement"
+					? SCOPE_INFO_TERMINATED_RETURN
+					: SCOPE_INFO_TERMINATED_THROW;
 		}
 	}
 
@@ -2337,14 +2335,20 @@ class JavascriptParser extends Parser {
 		const handlerTerminated = this.scope.terminated;
 		this.scope.terminated = undefined;
 
-		if (statement.finalizer) this.walkStatement(statement.finalizer);
+		if (statement.finalizer) {
+			this.walkStatement(statement.finalizer);
+		}
 
-		if (
-			!this.scope.terminated &&
+		const finalizerTerminated = this.scope.terminated;
+		this.scope.terminated = undefined;
+
+		if (finalizerTerminated) {
+			this.scope.terminated = finalizerTerminated;
+		} else if (
 			tryTerminated &&
 			(statement.handler ? handlerTerminated : true)
 		) {
-			this.scope.terminated = tryTerminated;
+			this.scope.terminated = handlerTerminated || tryTerminated;
 		}
 	}
 
@@ -2412,7 +2416,9 @@ class JavascriptParser extends Parser {
 			if (statement.update) {
 				this.walkExpression(statement.update);
 			}
+
 			const body = statement.body;
+
 			if (body.type === "BlockStatement") {
 				// no need to add additional scope
 				const prev = this.prevStatement;
@@ -2446,8 +2452,11 @@ class JavascriptParser extends Parser {
 			} else {
 				this.walkPattern(statement.left);
 			}
+
 			this.walkExpression(statement.right);
+
 			const body = statement.body;
+
 			if (body.type === "BlockStatement") {
 				// no need to add additional scope
 				const prev = this.prevStatement;
@@ -2484,8 +2493,11 @@ class JavascriptParser extends Parser {
 			} else {
 				this.walkPattern(statement.left);
 			}
+
 			this.walkExpression(statement.right);
+
 			const body = statement.body;
+
 			if (body.type === "BlockStatement") {
 				// no need to add additional scope
 				const prev = this.prevStatement;
@@ -4074,7 +4086,6 @@ class JavascriptParser extends Parser {
 			inTaggedTemplateTag: false,
 			isStrict: oldScope.isStrict,
 			isAsmJs: oldScope.isAsmJs,
-			inExecutedPath: false,
 			terminated: undefined,
 			definitions: oldScope.definitions.createChild()
 		};
@@ -4103,7 +4114,6 @@ class JavascriptParser extends Parser {
 			inTry: false,
 			inShorthand: false,
 			inTaggedTemplateTag: false,
-			inExecutedPath: true,
 			isStrict: oldScope.isStrict,
 			isAsmJs: oldScope.isAsmJs,
 			terminated: undefined,
@@ -4136,7 +4146,6 @@ class JavascriptParser extends Parser {
 			inTry: false,
 			inShorthand: false,
 			inTaggedTemplateTag: false,
-			inExecutedPath: true,
 			isStrict: oldScope.isStrict,
 			isAsmJs: oldScope.isAsmJs,
 			terminated: undefined,
@@ -4168,7 +4177,6 @@ class JavascriptParser extends Parser {
 			inTry: oldScope.inTry,
 			inShorthand: false,
 			inTaggedTemplateTag: false,
-			inExecutedPath,
 			isStrict: oldScope.isStrict,
 			isAsmJs: oldScope.isAsmJs,
 			terminated: oldScope.terminated,
@@ -4179,10 +4187,7 @@ class JavascriptParser extends Parser {
 
 		const terminated = this.scope.terminated;
 
-		if (
-			inExecutedPath &&
-			((this.scope.inTry && terminated === "throw") || terminated === "return")
-		) {
+		if (inExecutedPath && terminated) {
 			oldScope.terminated = terminated;
 		}
 
@@ -4502,7 +4507,6 @@ class JavascriptParser extends Parser {
 			inTry: false,
 			inShorthand: false,
 			inTaggedTemplateTag: false,
-			inExecutedPath: false,
 			isStrict: false,
 			isAsmJs: false,
 			terminated: undefined,

package/lib/library/EnableLibraryPlugin.js

@@ -12,6 +12,11 @@
 /** @type {WeakMap<Compiler, Set<LibraryType>>} */
 const enabledTypes = new WeakMap();
 
+/**
+ * @typedef {object} EnableLibraryPluginOptions
+ * @property {() => void=} additionalApply function that runs when applying the current plugin.
+ */
+
 /**
  * @param {Compiler} compiler the compiler instance
  * @returns {Set<LibraryType>} enabled types
@@ -28,9 +33,13 @@ const getEnabledTypes = compiler => {
 class EnableLibraryPlugin {
 	/**
 	 * @param {LibraryType} type library type that should be available
+	 * @param {EnableLibraryPluginOptions} options options of EnableLibraryPlugin
 	 */
-	constructor(type) {
+	constructor(type, options = {}) {
+		/** @type {LibraryType} */
 		this.type = type;
+		/** @type {EnableLibraryPluginOptions} */
+		this.options = options;
 	}
 
 	/**
@@ -67,13 +76,17 @@ class EnableLibraryPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		const { type } = this;
+		const { type, options } = this;
 
 		// Only enable once
 		const enabled = getEnabledTypes(compiler);
 		if (enabled.has(type)) return;
 		enabled.add(type);
 
+		if (typeof options.additionalApply === "function") {
+			options.additionalApply();
+		}
+
 		if (typeof type === "string") {
 			const enableExportProperty = () => {
 				const ExportPropertyTemplatePlugin = require("./ExportPropertyLibraryPlugin");

package/lib/library/ModuleLibraryPlugin.js

@@ -187,7 +187,12 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 				);
 			}
 
-			if (finalName && (finalName.includes(".") || finalName.includes("["))) {
+			if (
+				finalName &&
+				(finalName.includes(".") ||
+					finalName.includes("[") ||
+					finalName.includes("("))
+			) {
 				exports.push([exportInfo.name, finalName]);
 			} else {
 				shortHandedExports.push(

package/lib/logging/createConsoleLogger.js

@@ -89,7 +89,6 @@ module.exports = ({ level = "info", debug = false, console }) => {
 						.concat(debug)
 						.map(filterToFunction)
 		);
-	/** @type {number} */
 	const loglevel = LogLevel[`${level}`] || 0;
 
 	/**

package/lib/node/CommonJsChunkLoadingPlugin.js

@@ -13,12 +13,12 @@ const StartupChunkDependenciesPlugin = require("../runtime/StartupChunkDependenc
 
 /**
  * @typedef {object} CommonJsChunkLoadingPluginOptions
- * @property {boolean} [asyncChunkLoading] enable async chunk loading
+ * @property {boolean=} asyncChunkLoading enable async chunk loading
  */
 
 class CommonJsChunkLoadingPlugin {
 	/**
-	 * @param {CommonJsChunkLoadingPluginOptions} [options] options
+	 * @param {CommonJsChunkLoadingPluginOptions=} options options
 	 */
 	constructor(options = {}) {
 		this._asyncChunkLoading = options.asyncChunkLoading;

package/lib/node/NodeTemplatePlugin.js

@@ -12,12 +12,12 @@ const EnableChunkLoadingPlugin = require("../javascript/EnableChunkLoadingPlugin
 
 /**
  * @typedef {object} NodeTemplatePluginOptions
- * @property {boolean} [asyncChunkLoading] enable async chunk loading
+ * @property {boolean=} asyncChunkLoading enable async chunk loading
  */
 
 class NodeTemplatePlugin {
 	/**
-	 * @param {NodeTemplatePluginOptions} [options] options object
+	 * @param {NodeTemplatePluginOptions=} options options object
 	 */
 	constructor(options = {}) {
 		this._options = options;

package/lib/node/ReadFileCompileAsyncWasmPlugin.js

@@ -15,14 +15,14 @@ const AsyncWasmLoadingRuntimeModule = require("../wasm-async/AsyncWasmLoadingRun
 
 /**
  * @typedef {object} ReadFileCompileAsyncWasmPluginOptions
- * @property {boolean} [import] use import?
+ * @property {boolean=} import use import?
  */
 
 const PLUGIN_NAME = "ReadFileCompileAsyncWasmPlugin";
 
 class ReadFileCompileAsyncWasmPlugin {
 	/**
-	 * @param {ReadFileCompileAsyncWasmPluginOptions} [options] options object
+	 * @param {ReadFileCompileAsyncWasmPluginOptions=} options options object
 	 */
 	constructor({ import: useImport = false } = {}) {
 		this._import = useImport;

package/lib/node/ReadFileCompileWasmPlugin.js

@@ -15,8 +15,8 @@ const WasmChunkLoadingRuntimeModule = require("../wasm-sync/WasmChunkLoadingRunt
 
 /**
  * @typedef {object} ReadFileCompileWasmPluginOptions
- * @property {boolean} [mangleImports] mangle imports
- * @property {boolean} [import] use import?
+ * @property {boolean=} mangleImports mangle imports
+ * @property {boolean=} import use import?
  */
 
 // TODO webpack 6 remove
@@ -25,7 +25,7 @@ const PLUGIN_NAME = "ReadFileCompileWasmPlugin";
 
 class ReadFileCompileWasmPlugin {
 	/**
-	 * @param {ReadFileCompileWasmPluginOptions} [options] options object
+	 * @param {ReadFileCompileWasmPluginOptions=} options options object
 	 */
 	constructor(options = {}) {
 		this.options = options;

package/lib/optimize/AggressiveMergingPlugin.js

@@ -17,7 +17,7 @@ const { STAGE_ADVANCED } = require("../OptimizationStages");
 
 class AggressiveMergingPlugin {
 	/**
-	 * @param {AggressiveMergingPluginOptions=} [options] options object
+	 * @param {AggressiveMergingPluginOptions=} options options object
 	 */
 	constructor(options) {
 		if (

package/lib/optimize/SplitChunksPlugin.js

@@ -26,6 +26,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 /** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksOptions} OptimizationSplitChunksOptions */
 /** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksSizes} OptimizationSplitChunksSizes */
 /** @typedef {import("../../declarations/WebpackOptions").Output} OutputOptions */
+/** @typedef {import("../Chunk").ChunkName} ChunkName */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../ChunkGroup")} ChunkGroup */
 /** @typedef {import("../Compiler")} Compiler */
@@ -1387,7 +1388,7 @@ module.exports = class SplitChunksPlugin {
 						const item = /** @type {ChunksInfoItem} */ (bestEntry);
 						chunksInfoMap.delete(/** @type {string} */ (bestEntryKey));
 
-						/** @type {Chunk["name"] | undefined} */
+						/** @type {ChunkName | undefined} */
 						let chunkName = item.name;
 						// Variable for the new chunk (lazy created)
 						/** @type {Chunk | undefined} */

package/lib/runtime/GetChunkFilenameRuntimeModule.js

@@ -10,6 +10,7 @@ const Template = require("../Template");
 const { first } = require("../util/SetHelpers");
 
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Chunk").ChunkId} ChunkId */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compilation").AssetInfo} AssetInfo */
@@ -156,14 +157,12 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 				hashWithLength: length =>
 					`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
 				chunk: {
-					id: unquotedStringify(/** @type {number | string} */ (c.id)),
+					id: unquotedStringify(/** @type {ChunkId} */ (c.id)),
 					hash: unquotedStringify(/** @type {string} */ (c.renderedHash)),
 					hashWithLength: unquotedStringifyWithLength(
 						/** @type {string} */ (c.renderedHash)
 					),
-					name: unquotedStringify(
-						c.name || /** @type {number | string} */ (c.id)
-					),
+					name: unquotedStringify(c.name || /** @type {ChunkId} */ (c.id)),
 					contentHash: {
 						[contentType]: unquotedStringify(c.contentHash[contentType])
 					},

package/lib/serialization/BinaryMiddleware.js

@@ -7,15 +7,9 @@
 const memoize = require("../util/memoize");
 const SerializerMiddleware = require("./SerializerMiddleware");
 
-/** @typedef {import("./SerializerMiddleware").Context} Context */
 /** @typedef {import("./types").BufferSerializableType} BufferSerializableType */
 /** @typedef {import("./types").PrimitiveSerializableType} PrimitiveSerializableType */
 
-/**
- * @template LAZY_RESULT
- * @typedef {import("./SerializerMiddleware").LazyFunction<LAZY_RESULT>} LazyFunction
- */
-
 /*
 Format:
 
@@ -141,10 +135,18 @@ const identifyBigInt = n => {
 	return 2;
 };
 
+/** @typedef {PrimitiveSerializableType[]} DeserializedType */
+/** @typedef {BufferSerializableType[]} SerializedType} */
+/** @typedef {{ retainedBuffer?: (x: Buffer) => Buffer }} Context} */
+
 /**
- * @typedef {PrimitiveSerializableType[]} DeserializedType
- * @typedef {BufferSerializableType[]} SerializedType
- * @extends {SerializerMiddleware<DeserializedType, SerializedType>}
+ * @template LazyInputValue
+ * @template LazyOutputValue
+ * @typedef {import("./SerializerMiddleware").LazyFunction<LazyInputValue, LazyOutputValue, BinaryMiddleware, undefined>} LazyFunction
+ */
+
+/**
+ * @extends {SerializerMiddleware<DeserializedType, SerializedType, Context>}
  */
 class BinaryMiddleware extends SerializerMiddleware {
 	/**
@@ -157,9 +159,9 @@ class BinaryMiddleware extends SerializerMiddleware {
 	}
 
 	/**
-	 * @param {LazyFunction<DeserializedType>} fn lazy function
+	 * @param {LazyFunction<DeserializedType, SerializedType>} fn lazy function
 	 * @param {Context} context serialize function
-	 * @returns {LazyFunction<SerializedType>} new lazy
+	 * @returns {LazyFunction<SerializedType, DeserializedType>} new lazy
 	 */
 	_serializeLazy(fn, context) {
 		return SerializerMiddleware.serializeLazy(fn, data =>
@@ -281,7 +283,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 				case "function": {
 					if (!SerializerMiddleware.isLazy(thing))
 						throw new Error(`Unexpected function ${thing}`);
-					/** @type {SerializedType | LazyFunction<SerializedType>} */
+					/** @type {SerializedType | LazyFunction<SerializedType, DeserializedType> | undefined} */
 					let serializedData =
 						SerializerMiddleware.getLazySerializedValue(thing);
 					if (serializedData === undefined) {
@@ -294,18 +296,10 @@ class BinaryMiddleware extends SerializerMiddleware {
 							const data = this._serialize(result, context, allocationScope);
 							leftOverBuffer = allocationScope.leftOverBuffer;
 							allocationScope.leftOverBuffer = null;
-							SerializerMiddleware.setLazySerializedValue(
-								/** @type {LazyFunction<DeserializedType>} */
-								(thing),
-								data
-							);
+							SerializerMiddleware.setLazySerializedValue(thing, data);
 							serializedData = data;
 						} else {
-							serializedData = this._serializeLazy(
-								/** @type {LazyFunction<DeserializedType>} */
-								(thing),
-								context
-							);
+							serializedData = this._serializeLazy(thing, context);
 							flush();
 							buffers.push(serializedData);
 							break;
@@ -666,7 +660,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 	 * @private
 	 * @param {SerializedType} content content
 	 * @param {Context} context context object
-	 * @returns {LazyFunction<DeserializedType>} lazy function
+	 * @returns {LazyFunction<DeserializedType, SerializedType>} lazy function
 	 */
 	_createLazyDeserialized(content, context) {
 		return SerializerMiddleware.createLazy(
@@ -679,9 +673,9 @@ class BinaryMiddleware extends SerializerMiddleware {
 
 	/**
 	 * @private
-	 * @param {LazyFunction<SerializedType>} fn lazy function
+	 * @param {LazyFunction<SerializedType, DeserializedType>} fn lazy function
 	 * @param {Context} context context object
-	 * @returns {LazyFunction<DeserializedType>} new lazy
+	 * @returns {LazyFunction<DeserializedType, SerializedType>} new lazy
 	 */
 	_deserializeLazy(fn, context) {
 		return SerializerMiddleware.deserializeLazy(fn, data =>
@@ -701,7 +695,6 @@ class BinaryMiddleware extends SerializerMiddleware {
 		let currentIsBuffer = Buffer.isBuffer(currentBuffer);
 		let currentPosition = 0;
 
-		/** @type {(x: Buffer) => Buffer} */
 		const retainedBuffer = context.retainedBuffer || (x => x);
 
 		const checkOverflow = () => {
@@ -818,17 +811,14 @@ class BinaryMiddleware extends SerializerMiddleware {
 					return () => {
 						const count = readU32();
 						const lengths = Array.from({ length: count }).map(() => readU32());
-						/** @type {(Buffer | LazyFunction<BufferSerializableType[]>)[]} */
+						/** @type {(Buffer | LazyFunction<SerializedType, DeserializedType>)[]} */
 						const content = [];
 						for (let l of lengths) {
 							if (l === 0) {
 								if (typeof currentBuffer !== "function") {
 									throw new Error("Unexpected non-lazy element in stream");
 								}
-								content.push(
-									/** @type {LazyFunction<BufferSerializableType[]>} */
-									(currentBuffer)
-								);
+								content.push(currentBuffer);
 								currentDataItem++;
 								currentBuffer =
 									currentDataItem < data.length ? data[currentDataItem] : null;
@@ -1144,13 +1134,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 		let result = [];
 		while (currentBuffer !== null) {
 			if (typeof currentBuffer === "function") {
-				result.push(
-					this._deserializeLazy(
-						/** @type {LazyFunction<SerializedType>} */
-						(currentBuffer),
-						context
-					)
-				);
+				result.push(this._deserializeLazy(currentBuffer, context));
 				currentDataItem++;
 				currentBuffer =
 					currentDataItem < data.length ? data[currentDataItem] : null;

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 {
 	/**