webpack 5.76.1 → 5.88.0

package/lib/dependencies/CssUrlDependency.js

@@ -18,6 +18,9 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
@@ -26,13 +29,13 @@ const getRawDataUrlModule = memoize(() => require("../asset/RawDataUrlModule"));
 class CssUrlDependency extends ModuleDependency {
 	/**
 	 * @param {string} request request
-	 * @param {[number, number]} range range of the argument
-	 * @param {string} cssFunctionKind kind of css function, e. g. url(), image()
+	 * @param {Range} range range of the argument
+	 * @param {"string" | "url"} urlType dependency type e.g. url() or string
 	 */
-	constructor(request, range, cssFunctionKind) {
+	constructor(request, range, urlType) {
 		super(request);
 		this.range = range;
-		this.cssFunctionKind = cssFunctionKind;
+		this.urlType = urlType;
 	}
 
 	get type() {
@@ -45,26 +48,36 @@ class CssUrlDependency extends ModuleDependency {
 
 	/**
 	 * @param {string} context context directory
-	 * @returns {Module} a module
+	 * @returns {Module | null} a module
 	 */
 	createIgnoredModule(context) {
 		const RawDataUrlModule = getRawDataUrlModule();
 		return new RawDataUrlModule("data:,", `ignored-asset`, `(ignored asset)`);
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
-		write(this.cssFunctionKind);
+		write(this.urlType);
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
-		this.cssFunctionKind = read();
+		this.urlType = read();
 		super.deserialize(context);
 	}
 }
 
+/**
+ * @param {string} str string
+ * @returns {string} string in quotes if needed
+ */
 const cssEscapeString = str => {
 	let countWhiteOrBracket = 0;
 	let countQuotation = 0;
@@ -108,21 +121,38 @@ CssUrlDependency.Template = class CssUrlDependencyTemplate extends (
 	apply(
 		dependency,
 		source,
-		{ runtime, moduleGraph, runtimeTemplate, codeGenerationResults }
+		{ moduleGraph, runtimeTemplate, codeGenerationResults }
 	) {
 		const dep = /** @type {CssUrlDependency} */ (dependency);
 
+		/** @type {string | undefined} */
+		let newValue;
+
+		switch (dep.urlType) {
+			case "string":
+				newValue = cssEscapeString(
+					runtimeTemplate.assetUrl({
+						publicPath: "",
+						module: /** @type {Module} */ (moduleGraph.getModule(dep)),
+						codeGenerationResults
+					})
+				);
+				break;
+			case "url":
+				newValue = `url(${cssEscapeString(
+					runtimeTemplate.assetUrl({
+						publicPath: "",
+						module: /** @type {Module} */ (moduleGraph.getModule(dep)),
+						codeGenerationResults
+					})
+				)})`;
+				break;
+		}
+
 		source.replace(
 			dep.range[0],
 			dep.range[1] - 1,
-			`${dep.cssFunctionKind}(${cssEscapeString(
-				runtimeTemplate.assetUrl({
-					publicPath: "",
-					runtime,
-					module: moduleGraph.getModule(dep),
-					codeGenerationResults
-				})
-			)})`
+			/** @type {string} */ (newValue)
 		);
 	}
 };

package/lib/dependencies/DelegatedSourceDependency.js

@@ -9,6 +9,9 @@ const makeSerializable = require("../util/makeSerializable");
 const ModuleDependency = require("./ModuleDependency");
 
 class DelegatedSourceDependency extends ModuleDependency {
+	/**
+	 * @param {string} request the request string
+	 */
 	constructor(request) {
 		super(request);
 	}

package/lib/dependencies/DllEntryDependency.js

@@ -8,7 +8,15 @@
 const Dependency = require("../Dependency");
 const makeSerializable = require("../util/makeSerializable");
 
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("./EntryDependency")} EntryDependency */
+
 class DllEntryDependency extends Dependency {
+	/**
+	 * @param {EntryDependency[]} dependencies dependencies
+	 * @param {string} name name
+	 */
 	constructor(dependencies, name) {
 		super();
 
@@ -20,6 +28,9 @@ class DllEntryDependency extends Dependency {
 		return "dll entry";
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 
@@ -29,6 +40,9 @@ class DllEntryDependency extends Dependency {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 

package/lib/dependencies/DynamicExports.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Parser").ParserState} ParserState */
 
 /** @type {WeakMap<ParserState, boolean>} */
@@ -18,8 +19,9 @@ exports.bailout = parserState => {
 	const value = parserStateExportsState.get(parserState);
 	parserStateExportsState.set(parserState, false);
 	if (value === true) {
-		parserState.module.buildMeta.exportsType = undefined;
-		parserState.module.buildMeta.defaultObject = false;
+		const buildMeta = /** @type {BuildMeta} */ (parserState.module.buildMeta);
+		buildMeta.exportsType = undefined;
+		buildMeta.defaultObject = false;
 	}
 };
 
@@ -32,8 +34,9 @@ exports.enable = parserState => {
 	if (value === false) return;
 	parserStateExportsState.set(parserState, true);
 	if (value !== true) {
-		parserState.module.buildMeta.exportsType = "default";
-		parserState.module.buildMeta.defaultObject = "redirect";
+		const buildMeta = /** @type {BuildMeta} */ (parserState.module.buildMeta);
+		buildMeta.exportsType = "default";
+		buildMeta.defaultObject = "redirect";
 	}
 };
 
@@ -44,7 +47,7 @@ exports.enable = parserState => {
 exports.setFlagged = parserState => {
 	const value = parserStateExportsState.get(parserState);
 	if (value !== true) return;
-	const buildMeta = parserState.module.buildMeta;
+	const buildMeta = /** @type {BuildMeta} */ (parserState.module.buildMeta);
 	if (buildMeta.exportsType === "dynamic") return;
 	buildMeta.exportsType = "flagged";
 };
@@ -56,7 +59,8 @@ exports.setFlagged = parserState => {
 exports.setDynamic = parserState => {
 	const value = parserStateExportsState.get(parserState);
 	if (value !== true) return;
-	parserState.module.buildMeta.exportsType = "dynamic";
+	/** @type {BuildMeta} */
+	(parserState.module.buildMeta).exportsType = "dynamic";
 };
 
 /**

package/lib/dependencies/ExportsInfoDependency.js

@@ -16,6 +16,9 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
@@ -48,19 +51,23 @@ const getProperty = (moduleGraph, module, exportName, property, runtime) => {
 	switch (property) {
 		case "canMangle": {
 			const exportsInfo = moduleGraph.getExportsInfo(module);
-			const exportInfo = exportsInfo.getExportInfo(exportName);
+			const exportInfo = exportsInfo.getExportInfo(
+				/** @type {string} */ (exportName)
+			);
 			if (exportInfo) return exportInfo.canMangle;
 			return exportsInfo.otherExportsInfo.canMangle;
 		}
 		case "used":
 			return (
-				moduleGraph.getExportsInfo(module).getUsed(exportName, runtime) !==
+				moduleGraph
+					.getExportsInfo(module)
+					.getUsed(/** @type {string} */ (exportName), runtime) !==
 				UsageState.Unused
 			);
 		case "useInfo": {
 			const state = moduleGraph
 				.getExportsInfo(module)
-				.getUsed(exportName, runtime);
+				.getUsed(/** @type {string} */ (exportName), runtime);
 			switch (state) {
 				case UsageState.Used:
 				case UsageState.OnlyPropertiesUsed:
@@ -76,12 +83,19 @@ const getProperty = (moduleGraph, module, exportName, property, runtime) => {
 			}
 		}
 		case "provideInfo":
-			return moduleGraph.getExportsInfo(module).isExportProvided(exportName);
+			return moduleGraph
+				.getExportsInfo(module)
+				.isExportProvided(/** @type {string} */ (exportName));
 	}
 	return undefined;
 };
 
 class ExportsInfoDependency extends NullDependency {
+	/**
+	 * @param {Range} range range
+	 * @param {TODO} exportName export name
+	 * @param {string | null} property property
+	 */
 	constructor(range, exportName, property) {
 		super();
 		this.range = range;
@@ -89,6 +103,9 @@ class ExportsInfoDependency extends NullDependency {
 		this.property = property;
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 		write(this.range);
@@ -97,6 +114,10 @@ class ExportsInfoDependency extends NullDependency {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {ExportsInfoDependency} ExportsInfoDependency
+	 */
 	static deserialize(context) {
 		const obj = new ExportsInfoDependency(
 			context.read(),

package/lib/dependencies/HarmonyAcceptDependency.js

@@ -13,11 +13,14 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("./HarmonyAcceptImportDependency")} HarmonyAcceptImportDependency */
 
 class HarmonyAcceptDependency extends NullDependency {
 	/**
-	 * @param {[number, number]} range expression range
+	 * @param {Range} range expression range
 	 * @param {HarmonyAcceptImportDependency[]} dependencies import dependencies
 	 * @param {boolean} hasCallback true, if the range wraps an existing callback
 	 */
@@ -32,6 +35,9 @@ class HarmonyAcceptDependency extends NullDependency {
 		return "accepted harmony modules";
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 		write(this.range);
@@ -40,6 +46,9 @@ class HarmonyAcceptDependency extends NullDependency {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 		this.range = read();

package/lib/dependencies/HarmonyAcceptImportDependency.js

@@ -14,6 +14,9 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 
 class HarmonyAcceptImportDependency extends HarmonyImportDependency {
+	/**
+	 * @param {string} request the request string
+	 */
 	constructor(request) {
 		super(request, NaN);
 		this.weak = true;

package/lib/dependencies/HarmonyCompatibilityDependency.js

@@ -15,6 +15,7 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 
 class HarmonyCompatibilityDependency extends NullDependency {
 	get type() {
@@ -80,7 +81,7 @@ HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate
 					0,
 					undefined,
 					`\n__webpack_async_result__();\n} catch(e) { __webpack_async_result__(e); } }${
-						module.buildMeta.async ? ", 1" : ""
+						/** @type {BuildMeta} */ (module.buildMeta).async ? ", 1" : ""
 					});`
 				)
 			);

package/lib/dependencies/HarmonyDetectionParserPlugin.js

@@ -5,19 +5,32 @@
 
 "use strict";
 
+const { JAVASCRIPT_MODULE_TYPE_ESM } = require("../ModuleTypeConstants");
 const DynamicExports = require("./DynamicExports");
 const HarmonyCompatibilityDependency = require("./HarmonyCompatibilityDependency");
 const HarmonyExports = require("./HarmonyExports");
 
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("./HarmonyModulesPlugin").HarmonyModulesPluginOptions} HarmonyModulesPluginOptions */
+
 module.exports = class HarmonyDetectionParserPlugin {
+	/**
+	 * @param {HarmonyModulesPluginOptions} options options
+	 */
 	constructor(options) {
 		const { topLevelAwait = false } = options || {};
 		this.topLevelAwait = topLevelAwait;
 	}
 
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
+	 */
 	apply(parser) {
 		parser.hooks.program.tap("HarmonyDetectionParserPlugin", ast => {
-			const isStrictHarmony = parser.state.module.type === "javascript/esm";
+			const isStrictHarmony =
+				parser.state.module.type === JAVASCRIPT_MODULE_TYPE_ESM;
 			const isHarmony =
 				isStrictHarmony ||
 				ast.body.some(
@@ -60,15 +73,22 @@ module.exports = class HarmonyDetectionParserPlugin {
 					"Top-level-await is only supported in EcmaScript Modules"
 				);
 			}
-			module.buildMeta.async = true;
+			/** @type {BuildMeta} */
+			(module.buildMeta).async = true;
 		});
 
+		/**
+		 * @returns {boolean | undefined} true if in harmony
+		 */
 		const skipInHarmony = () => {
 			if (HarmonyExports.isEnabled(parser.state)) {
 				return true;
 			}
 		};
 
+		/**
+		 * @returns {null | undefined} null if in harmony
+		 */
 		const nullInHarmony = () => {
 			if (HarmonyExports.isEnabled(parser.state)) {
 				return null;

package/lib/dependencies/HarmonyEvaluatedImportSpecifierDependency.js

@@ -12,6 +12,12 @@ const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDepend
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../javascript/JavascriptParser").Assertions} Assertions */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
 /**
  * Dependency for static evaluating import specifier. e.g.
@@ -21,8 +27,17 @@ const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDepend
  * a.x !== undefined; // if x value statically analyzable
  */
 class HarmonyEvaluatedImportSpecifierDependency extends HarmonyImportSpecifierDependency {
+	/**
+	 * @param {string} request the request string
+	 * @param {number} sourceOrder source order
+	 * @param {TODO} ids ids
+	 * @param {TODO} name name
+	 * @param {Range} range location in source code
+	 * @param {Assertions} assertions assertions
+	 * @param {string} operator operator
+	 */
 	constructor(request, sourceOrder, ids, name, range, assertions, operator) {
-		super(request, sourceOrder, ids, name, range, false, assertions);
+		super(request, sourceOrder, ids, name, range, false, assertions, []);
 		this.operator = operator;
 	}
 
@@ -30,12 +45,18 @@ class HarmonyEvaluatedImportSpecifierDependency extends HarmonyImportSpecifierDe
 		return `evaluated X ${this.operator} harmony import specifier`;
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		super.serialize(context);
 		const { write } = context;
 		write(this.operator);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		super.deserialize(context);
 		const { read } = context;
@@ -66,15 +87,20 @@ HarmonyEvaluatedImportSpecifierDependency.Template = class HarmonyEvaluatedImpor
 		// Skip rendering depending when dependency is conditional
 		if (connection && !connection.isTargetActive(runtime)) return;
 
-		const exportsInfo = moduleGraph.getExportsInfo(connection.module);
+		const exportsInfo = moduleGraph.getExportsInfo(
+			/** @type {ModuleGraphConnection} */ (connection).module
+		);
 		const ids = dep.getIds(moduleGraph);
 
 		let value;
 
-		const exportsType = connection.module.getExportsType(
-			moduleGraph,
-			module.buildMeta.strictHarmonyModule
-		);
+		const exportsType =
+			/** @type {ModuleGraphConnection} */
+			(connection).module.getExportsType(
+				moduleGraph,
+				/** @type {BuildMeta} */
+				(module.buildMeta).strictHarmonyModule
+			);
 		switch (exportsType) {
 			case "default-with-named": {
 				if (ids[0] === "default") {

package/lib/dependencies/HarmonyExportDependencyParserPlugin.js

@@ -18,9 +18,14 @@ const {
 } = require("./HarmonyImportDependencyParserPlugin");
 const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDependency");
 
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+
 const { HarmonyStarExportsList } = HarmonyExportImportedSpecifierDependency;
 
 module.exports = class HarmonyExportDependencyParserPlugin {
+	/**
+	 * @param {import("../../declarations/WebpackOptions").JavascriptParserOptions} options options
+	 */
 	constructor(options) {
 		this.exportPresenceMode =
 			options.reexportExportsPresence !== undefined

package/lib/dependencies/HarmonyExportExpressionDependency.js

@@ -8,6 +8,7 @@
 const ConcatenationScope = require("../ConcatenationScope");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const makeSerializable = require("../util/makeSerializable");
+const propertyAccess = require("../util/propertyAccess");
 const HarmonyExportInitFragment = require("./HarmonyExportInitFragment");
 const NullDependency = require("./NullDependency");
 
@@ -17,8 +18,17 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
 class HarmonyExportExpressionDependency extends NullDependency {
+	/**
+	 * @param {Range} range range
+	 * @param {Range} rangeStatement range statement
+	 * @param {string} prefix prefix
+	 * @param {string | { range: Range, prefix: string, suffix: string }} [declarationId] declaration id
+	 */
 	constructor(range, rangeStatement, prefix, declarationId) {
 		super();
 		this.range = range;
@@ -54,6 +64,9 @@ class HarmonyExportExpressionDependency extends NullDependency {
 		return false;
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 		write(this.range);
@@ -63,6 +76,9 @@ class HarmonyExportExpressionDependency extends NullDependency {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 		this.range = read();
@@ -135,6 +151,7 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 				`/* harmony default export */ ${dep.prefix}`
 			);
 		} else {
+			/** @type {string} */
 			let content;
 			const name = ConcatenationScope.DEFAULT_EXPORT;
 			if (runtimeTemplate.supportsConst()) {
@@ -164,9 +181,9 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 				if (used) {
 					runtimeRequirements.add(RuntimeGlobals.exports);
 					// This is a little bit incorrect as TDZ is not correct, but we can't use const.
-					content = `/* harmony default export */ ${exportsName}[${JSON.stringify(
-						used
-					)}] = `;
+					content = `/* harmony default export */ ${exportsName}${propertyAccess(
+						typeof used === "string" ? [used] : used
+					)} = `;
 				} else {
 					content = `/* unused harmony default export */ var ${name} = `;
 				}

package/lib/dependencies/HarmonyExportHeaderDependency.js

@@ -11,8 +11,15 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
 class HarmonyExportHeaderDependency extends NullDependency {
+	/**
+	 * @param {Range} range range
+	 * @param {Range} rangeStatement range statement
+	 */
 	constructor(range, rangeStatement) {
 		super();
 		this.range = range;
@@ -23,6 +30,9 @@ class HarmonyExportHeaderDependency extends NullDependency {
 		return "harmony export header";
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 		write(this.range);
@@ -30,6 +40,9 @@ class HarmonyExportHeaderDependency extends NullDependency {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 		this.range = read();