webpack 5.104.1 → 5.105.4

package/lib/dependencies/CommonJsRequireContextDependency.js

@@ -18,8 +18,8 @@ class CommonJsRequireContextDependency extends ContextDependency {
 	/**
 	 * @param {ContextDependencyOptions} options options for the context module
 	 * @param {Range} range location in source code
-	 * @param {Range | undefined} valueRange location of the require call
-	 * @param {boolean | string} inShorthand true or name
+	 * @param {Range=} valueRange location of the require call
+	 * @param {boolean | string=} inShorthand true or name
 	 * @param {string=} context context
 	 */
 	constructor(options, range, valueRange, inShorthand, context) {

package/lib/dependencies/CommonJsSelfReferenceDependency.js

@@ -118,6 +118,7 @@ CommonJsSelfReferenceDependency.Template = class CommonJsSelfReferenceDependency
 			);
 		}
 
+		/** @type {string} */
 		let base;
 		switch (dep.base) {
 			case "exports":

package/lib/dependencies/ConstDependency.js

@@ -33,6 +33,7 @@ class ConstDependency extends NullDependency {
 		this.runtimeRequirements = runtimeRequirements
 			? new Set(runtimeRequirements)
 			: null;
+		/** @type {undefined | string} */
 		this._hashUpdate = undefined;
 	}
 

package/lib/dependencies/ContextDependencyHelpers.js

@@ -26,7 +26,7 @@ const quoteMeta = (str) => str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
 
 /**
  * @param {string} prefix prefix
- * @returns {{prefix: string, context: string}} result
+ * @returns {{ prefix: string, context: string }} result
  */
 const splitContextFromPrefix = (prefix) => {
 	const idx = prefix.lastIndexOf("/");
@@ -42,17 +42,23 @@ const splitContextFromPrefix = (prefix) => {
 };
 
 /** @typedef {Partial<Omit<ContextDependencyOptions, "resource">>} PartialContextDependencyOptions */
-/** @typedef {{ new(options: ContextDependencyOptions, range: Range, valueRange: Range, ...args: EXPECTED_ANY[]): ContextDependency }} ContextDependencyConstructor */
+/** @typedef {{ new (options: ContextDependencyOptions, range: Range, valueRange: Range, ...args: EXPECTED_ANY[]): ContextDependency }} ContextDependencyConstructor */
 
 /**
- * @param {ContextDependencyConstructor} Dep the Dependency class
+ * @template T
+ * @typedef {T extends new (options: ContextDependencyOptions, range: Range, valueRange: Range, ...remains: infer R) => EXPECTED_ANY ? R : []} GetAdditionalDepArgs
+ */
+
+/**
+ * @template {ContextDependencyConstructor} T
+ * @param {T} Dep the Dependency class
  * @param {Range} range source range
  * @param {BasicEvaluatedExpression} param context param
  * @param {Expression} expr expr
  * @param {Pick<JavascriptParserOptions, `${"expr" | "wrapped"}Context${"Critical" | "Recursive" | "RegExp"}` | "exprContextRequest">} options options for context creation
  * @param {PartialContextDependencyOptions} contextOptions options for the ContextModule
  * @param {JavascriptParser} parser the parser
- * @param {...EXPECTED_ANY} depArgs depArgs
+ * @param {GetAdditionalDepArgs<T>} depArgs depArgs
  * @returns {ContextDependency} the created Dependency
  */
 module.exports.create = (
@@ -216,6 +222,7 @@ module.exports.create = (
 			...depArgs
 		);
 		dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+		/** @type {Replaces} */
 		const replaces = [];
 		if (prefixRange) {
 			replaces.push({

package/lib/dependencies/ContextElementDependency.js

@@ -82,6 +82,7 @@ class ContextElementDependency extends ModuleDependency {
 	 */
 	getReferencedExports(moduleGraph, runtime) {
 		if (!this.referencedExports) return Dependency.EXPORTS_OBJECT_REFERENCED;
+		/** @type {ReferencedExports} */
 		const refs = [];
 		for (const referencedExport of this.referencedExports) {
 			if (

package/lib/dependencies/CreateRequireParserPlugin.js

@@ -0,0 +1,356 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { fileURLToPath } = require("url");
+const WebpackError = require("../WebpackError");
+const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
+const { VariableInfo } = require("../javascript/JavascriptParser");
+const {
+	evaluateToString,
+	expressionIsUnsupported,
+	toConstantDependency
+} = require("../javascript/JavascriptParserHelpers");
+const CommonJsImportsParserPlugin = require("./CommonJsImportsParserPlugin");
+const ConstDependency = require("./ConstDependency");
+
+/** @typedef {import("estree").CallExpression} CallExpression */
+/** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").ImportSource} ImportSource */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+/**
+ * @typedef {object} CommonJsImportSettings
+ * @property {string=} name
+ * @property {string} context
+ */
+
+const createRequireSpecifierTag = Symbol("createRequire");
+const createdRequireIdentifierTag = Symbol("createRequire()");
+
+const PLUGIN_NAME = "CreateRequireParserPlugin";
+
+const {
+	createProcessResolveHandler,
+	createRequireAsExpressionHandler,
+	createRequireCacheDependency,
+	createRequireHandler
+} = CommonJsImportsParserPlugin;
+
+class CreateRequireParserPlugin {
+	/**
+	 * @param {JavascriptParserOptions} options parser options
+	 */
+	constructor(options) {
+		this.options = options;
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
+	 */
+	apply(parser) {
+		const options = this.options;
+		if (!options.createRequire) return;
+
+		const getContext = () => {
+			if (parser.currentTagData) {
+				const { context } =
+					/** @type {CommonJsImportSettings} */
+					(parser.currentTagData);
+				return context;
+			}
+		};
+
+		/**
+		 * @param {string | symbol} tag tag
+		 */
+		const tapRequireExpressionTag = (tag) => {
+			parser.hooks.typeof
+				.for(tag)
+				.tap(
+					PLUGIN_NAME,
+					toConstantDependency(parser, JSON.stringify("function"))
+				);
+			parser.hooks.evaluateTypeof
+				.for(tag)
+				.tap(PLUGIN_NAME, evaluateToString("function"));
+		};
+
+		/**
+		 * @param {Expression} expr expression
+		 * @returns {boolean} true when set undefined
+		 */
+		const defineUndefined = (expr) => {
+			const dep = new ConstDependency(
+				"undefined",
+				/** @type {Range} */ (expr.range)
+			);
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			parser.state.module.addPresentationalDependency(dep);
+			return false;
+		};
+
+		const requireCache = createRequireCacheDependency(parser);
+		const requireAsExpressionHandler = createRequireAsExpressionHandler(
+			parser,
+			options,
+			getContext
+		);
+		const createRequireCallHandler = createRequireHandler(
+			parser,
+			options,
+			getContext
+		);
+		const processResolve = createProcessResolveHandler(
+			parser,
+			options,
+			getContext
+		);
+
+		/** @type {ImportSource[]} */
+		let moduleNames = [];
+		/** @type {string | undefined} */
+		let specifierName;
+
+		if (options.createRequire === true) {
+			moduleNames = ["module", "node:module"];
+			specifierName = "createRequire";
+		} else if (typeof options.createRequire === "string") {
+			/** @type {undefined | string} */
+			let parsedModuleName;
+			const match = /^(.*) from (.*)$/.exec(options.createRequire);
+			if (match) {
+				[, specifierName, parsedModuleName] = match;
+			}
+			if (!specifierName || !parsedModuleName) {
+				const err = new WebpackError(
+					`Parsing javascript parser option "createRequire" failed, got ${JSON.stringify(
+						options.createRequire
+					)}`
+				);
+				err.details =
+					'Expected string in format "createRequire from module", where "createRequire" is specifier name and "module" name of the module';
+				throw err;
+			}
+			moduleNames = [parsedModuleName];
+		} else {
+			return;
+		}
+
+		/**
+		 * @param {CallExpression} expr call expression
+		 * @returns {string | void} context
+		 */
+		const parseCreateRequireArguments = (expr) => {
+			const args = expr.arguments;
+			if (args.length !== 1) {
+				const err = new WebpackError(
+					"module.createRequire supports only one argument."
+				);
+				err.loc = /** @type {DependencyLocation} */ (expr.loc);
+				parser.state.module.addWarning(err);
+				return;
+			}
+			const arg = args[0];
+			const evaluated = parser.evaluateExpression(arg);
+			if (!evaluated.isString()) {
+				const err = new WebpackError(
+					"module.createRequire failed parsing argument."
+				);
+				err.loc = /** @type {DependencyLocation} */ (arg.loc);
+				parser.state.module.addWarning(err);
+				return;
+			}
+			const ctx = /** @type {string} */ (evaluated.string).startsWith("file://")
+				? fileURLToPath(/** @type {string} */ (evaluated.string))
+				: /** @type {string} */ (evaluated.string);
+			// argument always should be a filename
+			return ctx.slice(0, ctx.lastIndexOf(ctx.startsWith("/") ? "/" : "\\"));
+		};
+
+		tapRequireExpressionTag(createdRequireIdentifierTag);
+		tapRequireExpressionTag(createRequireSpecifierTag);
+
+		parser.hooks.evaluateCallExpression
+			.for(createRequireSpecifierTag)
+			.tap(PLUGIN_NAME, (expr) => {
+				const context = parseCreateRequireArguments(expr);
+				if (context === undefined) return;
+				const ident = parser.evaluatedVariable({
+					tag: createdRequireIdentifierTag,
+					data: { context },
+					next: undefined
+				});
+
+				return new BasicEvaluatedExpression()
+					.setIdentifier(ident, ident, () => [])
+					.setSideEffects(false)
+					.setRange(/** @type {Range} */ (expr.range));
+			});
+
+		parser.hooks.unhandledExpressionMemberChain
+			.for(createdRequireIdentifierTag)
+			.tap(PLUGIN_NAME, (expr, members) =>
+				expressionIsUnsupported(
+					parser,
+					`createRequire().${members.join(".")} is not supported by webpack.`
+				)(expr)
+			);
+		parser.hooks.canRename
+			.for(createdRequireIdentifierTag)
+			.tap(PLUGIN_NAME, () => true);
+		parser.hooks.canRename
+			.for(createRequireSpecifierTag)
+			.tap(PLUGIN_NAME, () => true);
+		parser.hooks.rename
+			.for(createRequireSpecifierTag)
+			.tap(PLUGIN_NAME, defineUndefined);
+		parser.hooks.expression
+			.for(createdRequireIdentifierTag)
+			.tap(PLUGIN_NAME, requireAsExpressionHandler);
+		parser.hooks.call
+			.for(createdRequireIdentifierTag)
+			.tap(PLUGIN_NAME, createRequireCallHandler(false));
+
+		parser.hooks.import.tap(
+			{
+				name: PLUGIN_NAME,
+				stage: -10
+			},
+			(statement, source) => {
+				if (
+					!moduleNames.includes(source) ||
+					statement.specifiers.length !== 1 ||
+					statement.specifiers[0].type !== "ImportSpecifier" ||
+					statement.specifiers[0].imported.type !== "Identifier" ||
+					statement.specifiers[0].imported.name !== specifierName
+				) {
+					return;
+				}
+				// clear for 'import { createRequire as x } from "module"'
+				// if any other specifier was used import module
+				const clearDep = new ConstDependency(
+					parser.isAsiPosition(/** @type {Range} */ (statement.range)[0])
+						? ";"
+						: "",
+					/** @type {Range} */ (statement.range)
+				);
+				clearDep.loc = /** @type {DependencyLocation} */ (statement.loc);
+				parser.state.module.addPresentationalDependency(clearDep);
+				parser.unsetAsiPosition(/** @type {Range} */ (statement.range)[1]);
+				return true;
+			}
+		);
+		parser.hooks.importSpecifier.tap(
+			{
+				name: PLUGIN_NAME,
+				stage: -10
+			},
+			(statement, source, id, name) => {
+				if (!moduleNames.includes(source) || id !== specifierName) return;
+				parser.tagVariable(name, createRequireSpecifierTag);
+				return true;
+			}
+		);
+		parser.hooks.preDeclarator.tap(PLUGIN_NAME, (declarator) => {
+			if (
+				declarator.id.type !== "Identifier" ||
+				!declarator.init ||
+				declarator.init.type !== "CallExpression" ||
+				declarator.init.callee.type !== "Identifier"
+			) {
+				return;
+			}
+			const variableInfo = parser.getVariableInfo(declarator.init.callee.name);
+			if (
+				variableInfo instanceof VariableInfo &&
+				variableInfo.tagInfo &&
+				variableInfo.tagInfo.tag === createRequireSpecifierTag
+			) {
+				const context = parseCreateRequireArguments(declarator.init);
+				if (context === undefined) return;
+				parser.tagVariable(declarator.id.name, createdRequireIdentifierTag, {
+					name: declarator.id.name,
+					context
+				});
+				return true;
+			}
+		});
+
+		parser.hooks.memberChainOfCallMemberChain
+			.for(createRequireSpecifierTag)
+			.tap(PLUGIN_NAME, (expr, calleeMembers, callExpr, members) => {
+				if (
+					calleeMembers.length !== 0 ||
+					members.length !== 1 ||
+					members[0] !== "cache"
+				) {
+					return;
+				}
+				// createRequire().cache
+				const context = parseCreateRequireArguments(callExpr);
+				if (context === undefined) return;
+				return requireCache(expr);
+			});
+		parser.hooks.callMemberChainOfCallMemberChain
+			.for(createRequireSpecifierTag)
+			.tap(PLUGIN_NAME, (expr, calleeMembers, innerCallExpression, members) => {
+				if (
+					calleeMembers.length !== 0 ||
+					members.length !== 1 ||
+					members[0] !== "resolve"
+				) {
+					return;
+				}
+				// createRequire().resolve()
+				return processResolve(expr, false);
+			});
+		parser.hooks.expressionMemberChain
+			.for(createdRequireIdentifierTag)
+			.tap(PLUGIN_NAME, (expr, members) => {
+				// require.cache
+				if (members.length === 1 && members[0] === "cache") {
+					return requireCache(expr);
+				}
+			});
+		parser.hooks.callMemberChain
+			.for(createdRequireIdentifierTag)
+			.tap(PLUGIN_NAME, (expr, members) => {
+				// require.resolve()
+				if (members.length === 1 && members[0] === "resolve") {
+					return processResolve(expr, false);
+				}
+			});
+		parser.hooks.expression
+			.for(createRequireSpecifierTag)
+			.tap(PLUGIN_NAME, (expr) => {
+				const clearDep = new ConstDependency(
+					"/* createRequire */ undefined",
+					/** @type {Range} */ (expr.range)
+				);
+				clearDep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				parser.state.module.addPresentationalDependency(clearDep);
+				return true;
+			});
+		parser.hooks.call
+			.for(createRequireSpecifierTag)
+			.tap(PLUGIN_NAME, (expr) => {
+				const clearDep = new ConstDependency(
+					"/* createRequire() */ undefined",
+					/** @type {Range} */ (expr.range)
+				);
+				clearDep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				parser.state.module.addPresentationalDependency(clearDep);
+				return true;
+			});
+	}
+}
+
+module.exports = CreateRequireParserPlugin;

package/lib/dependencies/CriticalDependencyWarning.js

@@ -15,6 +15,7 @@ class CriticalDependencyWarning extends WebpackError {
 	constructor(message) {
 		super();
 
+		/** @type {string} */
 		this.name = "CriticalDependencyWarning";
 		this.message = `Critical dependency: ${message}`;
 	}

package/lib/dependencies/CssIcssExportDependency.js

@@ -37,6 +37,8 @@ const getCssParser = memoize(() => require("../css/CssParser"));
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../css/CssParser").Range} Range */
 
+/** @typedef {(name: string) => string} ExportsConventionFn */
+
 /**
  * @param {string} local css local
  * @param {CssModule} module module
@@ -60,7 +62,7 @@ const getLocalIdent = (local, module, chunkGraph, runtimeTemplate) => {
 
 	let localIdentHash = "";
 
-	if (/\[(fullhash|hash)\]/.test(localIdentName)) {
+	if (/\[(?:fullhash|hash)\]/.test(localIdentName)) {
 		const hashSalt = generator.options.localIdentHashSalt;
 		const hashDigest =
 			/** @type {string} */
@@ -113,8 +115,8 @@ const getLocalIdent = (local, module, chunkGraph, runtimeTemplate) => {
 			if (typeof id !== "string") return id;
 
 			return id
-				.replace(/^([.-]|[^a-zA-Z0-9_-])+/, "")
-				.replace(/[^a-zA-Z0-9_-]+/g, "_");
+				.replace(/^([.-]|[^a-z0-9_-])+/i, "")
+				.replace(/[^a-z0-9_-]+/gi, "_");
 		},
 		filename: relativeResourcePath,
 		hash: localIdentHash,
@@ -135,7 +137,7 @@ const getLocalIdent = (local, module, chunkGraph, runtimeTemplate) => {
 	}
 
 	// Protect the first character from unsupported values
-	return localIdent.replace(/^((-?[0-9])|--)/, "_$1");
+	return localIdent.replace(/^((-?\d)|--)/, "_$1");
 };
 
 // 0 - replace, 1 - replace, 2 - append,  2 - once
@@ -170,6 +172,7 @@ class CssIcssExportDependency extends NullDependency {
 		this.interpolate = interpolate;
 		this.exportMode = exportMode;
 		this.exportType = exportType;
+		/** @type {undefined | string} */
 		this._hashUpdate = undefined;
 	}
 

package/lib/dependencies/CssIcssSymbolDependency.js

@@ -36,6 +36,7 @@ class CssIcssSymbolDependency extends NullDependency {
 		this.symbol = symbol;
 		this.range = range;
 		this.isReference = isReference;
+		/** @type {undefined | string} */
 		this._hashUpdate = undefined;
 	}
 

package/lib/dependencies/CssUrlDependency.js

@@ -16,6 +16,7 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("../Module").CodeGenerationResultData} CodeGenerationResultData */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
@@ -173,9 +174,7 @@ CssUrlDependency.Template = class CssUrlDependencyTemplate extends (
 			return "data:,";
 		}
 		const codeGen = codeGenerationResults.get(module, runtime);
-		const data =
-			/** @type {NonNullable<CodeGenerationResult["data"]>} */
-			(codeGen.data);
+		const data = codeGen.data;
 		if (!data) return "data:,";
 		const url = data.get("url");
 		if (!url || !url["css-url"]) return "data:,";

package/lib/dependencies/ExternalModuleInitFragment.js

@@ -13,7 +13,8 @@ const makeSerializable = require("../util/makeSerializable");
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {{ name: string, value?: string }[]} ArrayImportSpecifiers */
-/** @typedef {Map<string, Set<string>>} ImportSpecifiers */
+/** @typedef {Set<string>} ImportSpecifier */
+/** @typedef {Map<string, ImportSpecifier>} ImportSpecifiers */
 
 /**
  * @extends {InitFragment<GenerateContext>}
@@ -38,6 +39,7 @@ class ExternalModuleInitFragment extends InitFragment {
 			for (const { name, value } of specifiers) {
 				let specifiers = this.specifiers.get(name);
 				if (!specifiers) {
+					/** @type {ImportSpecifier} */
 					specifiers = new Set();
 					this.specifiers.set(name, specifiers);
 				}
@@ -77,6 +79,7 @@ class ExternalModuleInitFragment extends InitFragment {
 	 * @returns {string | Source | undefined} the source code that will be included as initialization code
 	 */
 	getContent({ runtimeRequirements }) {
+		/** @type {string[]} */
 		const namedImports = [];
 
 		for (const [name, specifiers] of this.specifiers) {

package/lib/dependencies/ExternalModuleInitFragmentDependency.js

@@ -31,15 +31,6 @@ class ExternalModuleInitFragmentDependency extends NullDependency {
 		this.default = defaultImport;
 	}
 
-	/**
-	 * @returns {string} hash update
-	 */
-	_createHashUpdate() {
-		return `${this.importedModule}${JSON.stringify(this.specifiers)}${
-			this.default || "null"
-		}`;
-	}
-
 	/**
 	 * @param {ObjectSerializerContext} context context
 	 */

package/lib/dependencies/HarmonyAcceptDependency.js

@@ -114,8 +114,11 @@ HarmonyAcceptDependency.Template = class HarmonyAcceptDependencyTemplate extends
 		 * @returns {HarmonyImportDependency[]} array of related harmony import dependencies
 		 */
 		const getHarmonyImportDependencies = (dependency) => {
+			/** @type {HarmonyImportDependency[]} */
 			const result = [];
+			/** @type {HarmonyImportDependency | null} */
 			let deferDependency = null;
+			/** @type {HarmonyImportDependency | null} */
 			let noDeferredDependency = null;
 
 			for (const d of module.dependencies) {

package/lib/dependencies/HarmonyEvaluatedImportSpecifierDependency.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const makeSerializable = require("../util/makeSerializable");
+const { ExportPresenceModes } = require("./HarmonyImportDependency");
 const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
 const { ImportPhase } = require("./ImportPhase");
 
@@ -44,7 +45,7 @@ class HarmonyEvaluatedImportSpecifierDependency extends HarmonyImportSpecifierDe
 			ids,
 			name,
 			range,
-			false,
+			ExportPresenceModes.NONE,
 			ImportPhase.Evaluation,
 			attributes,
 			[]
@@ -103,6 +104,7 @@ HarmonyEvaluatedImportSpecifierDependency.Template = class HarmonyEvaluatedImpor
 		);
 		const ids = dep.getIds(moduleGraph);
 
+		/** @type {boolean | undefined | null} */
 		let value;
 
 		const exportsType =

package/lib/dependencies/HarmonyExportDependencyParserPlugin.js

@@ -39,14 +39,10 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 	 */
 	constructor(options) {
 		this.options = options;
-		this.exportPresenceMode =
-			options.reexportExportsPresence !== undefined
-				? ExportPresenceModes.fromUserOption(options.reexportExportsPresence)
-				: options.exportsPresence !== undefined
-					? ExportPresenceModes.fromUserOption(options.exportsPresence)
-					: options.strictExportPresence
-						? ExportPresenceModes.ERROR
-						: ExportPresenceModes.AUTO;
+		this.exportPresenceMode = ExportPresenceModes.resolveFromOptions(
+			options.reexportExportsPresence,
+			options
+		);
 	}
 
 	/**

package/lib/dependencies/HarmonyExportExpressionDependency.js

@@ -21,6 +21,7 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("./HarmonyExportInitFragment").ExportMap} ExportMap */
 
 class HarmonyExportExpressionDependency extends NullDependency {
 	/**
@@ -120,6 +121,7 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 		const { declarationId } = dep;
 		const exportsName = module.exportsArgument;
 		if (declarationId) {
+			/** @type {string} */
 			let name;
 			if (typeof declarationId === "string") {
 				name = declarationId;
@@ -139,6 +141,7 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 					.getExportsInfo(module)
 					.getUsedName("default", runtime);
 				if (used) {
+					/** @type {ExportMap} */
 					const map = new Map();
 					map.set(used, `/* export default binding */ ${name}`);
 					initFragments.push(new HarmonyExportInitFragment(exportsName, map));
@@ -164,6 +167,7 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 						.getUsedName("default", runtime);
 					if (used) {
 						runtimeRequirements.add(RuntimeGlobals.exports);
+						/** @type {ExportMap} */
 						const map = new Map();
 						map.set(used, name);
 						initFragments.push(new HarmonyExportInitFragment(exportsName, map));