webpack 5.111.0 → 5.112.0

package/lib/dependencies/{HarmonyImportDependencyParserPlugin.js → esm/ESMImportDependencyParserPlugin.js}

@@ -5,58 +5,65 @@
 
 "use strict";
 
-const ImportedBindingAssignmentError = require("../errors/ImportedBindingAssignmentError");
-const WebpackError = require("../errors/WebpackError");
-const getParserHooks = require("../hmr/parserHooks");
+const ImportedBindingAssignmentError = require("../../errors/ImportedBindingAssignmentError");
+const WebpackError = require("../../errors/WebpackError");
+const getParserHooks = require("../../hmr/parserHooks");
 const {
-	VariableInfo,
-	getImportAttributes
-} = require("../javascript/JavascriptParser");
-const { getInnerGraphUtils } = require("../optimize/InnerGraph");
-const ConstDependency = require("./ConstDependency");
-const HarmonyAcceptDependency = require("./HarmonyAcceptDependency");
-const HarmonyAcceptImportDependency = require("./HarmonyAcceptImportDependency");
-const HarmonyEvaluatedImportSpecifierDependency = require("./HarmonyEvaluatedImportSpecifierDependency");
-const HarmonyExports = require("./HarmonyExports");
-const HarmonyImportBareSideEffectDependency = require("./HarmonyImportBareSideEffectDependency");
+	getImportAttributes,
+	isVariableInfo
+} = require("../../javascript/JavascriptParser");
+const { getInnerGraphUtils } = require("../../optimize/InnerGraph");
+const ConstDependency = require("../core/ConstDependency");
+const {
+	ImportPhaseUtils,
+	createGetImportPhase
+} = require("../core/ImportPhase");
+const ESMAcceptDependency = require("./ESMAcceptDependency");
+const ESMAcceptImportDependency = require("./ESMAcceptImportDependency");
+const ESMEvaluatedImportSpecifierDependency = require("./ESMEvaluatedImportSpecifierDependency");
+const ESMExports = require("./ESMExports");
+const ESMImportBareSideEffectDependency = require("./ESMImportBareSideEffectDependency");
 const {
 	ExportPresenceModes,
 	getNonOptionalPart
-} = require("./HarmonyImportDependency");
+} = require("./ESMImportDependency");
 const {
 	attachDependencyGuards,
 	isPresentByGuards
-} = require("./HarmonyImportGuard");
-const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDependency");
-const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
-const { ImportPhaseUtils, createGetImportPhase } = require("./ImportPhase");
+} = require("./ESMImportGuard");
+const ESMImportSideEffectDependency = require("./ESMImportSideEffectDependency");
+const ESMImportSpecifierDependency = require("./ESMImportSpecifierDependency");
 
 /**
  * @import {
  * 	Expression,
  * 	PrivateIdentifier,
  * 	Identifier,
- * 	MemberExpression
+ * 	MemberExpression,
+ * 	Pattern,
+ * 	UpdateExpression
  * } from "estree"
  */
 /**
  * @import {
  * 	JavascriptParserOptions
- * } from "../../declarations/WebpackOptions"
+ * } from "../../../declarations/WebpackOptions"
  */
-/** @import Module from "../Module" */
-/** @import { JavascriptModuleBuildInfo } from "../javascript/JavascriptModule" */
+/** @import Module from "../../module/Module" */
+/** @import { JavascriptModuleBuildInfo } from "../../javascript/JavascriptModule" */
 /**
  * @import JavascriptParser, {
  * 	ImportAttributes,
  * 	Range,
- * 	Members
- * } from "../javascript/JavascriptParser"
+ * 	Members,
+ * 	WriteStatement
+ * } from "../../javascript/JavascriptParser"
  */
-/** @import { Ids, ExportPresenceMode } from "./HarmonyImportDependency" */
-/** @import { ImportPhaseType } from "./ImportPhase" */
-/** @import { GuardFrame } from "./HarmonyImportGuard" */
+/** @import { Ids, ExportPresenceMode } from "./ESMImportDependency" */
+/** @import { ImportPhaseType } from "../core/ImportPhase" */
+/** @import { GuardFrame } from "./ESMImportGuard" */
 
+// TODO in the next major release: rename to `esmSpecifierTag`
 const harmonySpecifierTag = Symbol("harmony import");
 
 // Shared placeholder: plain specifier references have no member ranges, so they
@@ -66,7 +73,7 @@ const EMPTY_ID_RANGES = [];
 
 /**
  * Defines the harmony settings type used by this module.
- * @typedef {object} HarmonySettings
+ * @typedef {object} ESMSettings
  * @property {Ids} ids
  * @property {string} source
  * @property {number} sourceOrder
@@ -75,15 +82,15 @@ const EMPTY_ID_RANGES = [];
  * @property {ImportAttributes=} attributes
  * @property {ImportPhaseType} phase
  * @property {boolean} used whether the binding is referenced anywhere
- * @property {HarmonyImportSideEffectDependency | undefined} dependency the statement's own dependency
+ * @property {ESMImportSideEffectDependency | undefined} dependency the statement's own dependency
  */
 
-const PLUGIN_NAME = "HarmonyImportDependencyParserPlugin";
+const PLUGIN_NAME = "ESMImportDependencyParserPlugin";
 
 /**
  * Records that an import binding is referenced, so it is not reported as an
  * unused specifier naming a missing export.
- * @param {HarmonySettings | undefined} settings settings of the referenced tag
+ * @param {ESMSettings | undefined} settings settings of the referenced tag
  * @returns {boolean} true when the reference was a harmony import specifier
  */
 const markUsed = (settings) => {
@@ -97,7 +104,7 @@ const markUsed = (settings) => {
  * @param {JavascriptParser} parser the parser
  * @param {PrivateIdentifier | Expression} left left expression
  * @param {Expression} right right expression
- * @returns {{ leftPart: string, members: Members, settings: HarmonySettings } | undefined} info
+ * @returns {{ leftPart: string, members: Members, settings: ESMSettings } | undefined} info
  */
 const getInOperatorHarmonyImportInfo = (parser, left, right) => {
 	const leftPartEvaluated = parser.evaluateExpression(left);
@@ -113,12 +120,12 @@ const getInOperatorHarmonyImportInfo = (parser, left, right) => {
 	const root =
 		typeof rootInfo === "string"
 			? rootInfo
-			: rootInfo instanceof VariableInfo
+			: isVariableInfo(rootInfo)
 				? rootInfo.name
 				: undefined;
 	if (!root) return;
 
-	const settings = /** @type {HarmonySettings | undefined} */ (
+	const settings = /** @type {ESMSettings | undefined} */ (
 		parser.getTagData(root, harmonySpecifierTag)
 	);
 	if (!settings) {
@@ -144,7 +151,7 @@ const findImportSpecifier = (parser, node) => {
 	switch (node.type) {
 		case "Identifier":
 			return markUsed(
-				/** @type {HarmonySettings | undefined} */
+				/** @type {ESMSettings | undefined} */
 				(parser.getTagData(node.name, harmonySpecifierTag))
 			);
 		case "UnaryExpression":
@@ -173,9 +180,9 @@ const findImportSpecifier = (parser, node) => {
 	}
 };
 
-class HarmonyImportDependencyParserPlugin {
+class ESMImportDependencyParserPlugin {
 	/**
-	 * Creates an instance of HarmonyImportDependencyParserPlugin.
+	 * Creates an instance of ESMImportDependencyParserPlugin.
 	 * @param {JavascriptParserOptions} options options
 	 */
 	constructor(options) {
@@ -193,7 +200,7 @@ class HarmonyImportDependencyParserPlugin {
 	/**
 	 * Gets export presence mode.
 	 * @param {JavascriptParser} parser the parser
-	 * @param {HarmonySettings} settings settings
+	 * @param {ESMSettings} settings settings
 	 * @param {Ids} ids ids
 	 * @returns {ExportPresenceMode} exportPresenceMode
 	 */
@@ -201,9 +208,7 @@ class HarmonyImportDependencyParserPlugin {
 		// Guards only apply to namespace imports
 		if (settings.ids.length) return this.exportPresenceMode;
 
-		const harmonySettings = /** @type {HarmonySettings=} */ (
-			parser.currentTagData
-		);
+		const harmonySettings = /** @type {ESMSettings=} */ (parser.currentTagData);
 		if (!harmonySettings) return this.exportPresenceMode;
 
 		if (this.exportPresenceMode === ExportPresenceModes.NONE) {
@@ -234,20 +239,34 @@ class HarmonyImportDependencyParserPlugin {
 			this.options.sourceImport
 		);
 
-		// Parsers are reused across modules, so both are reset per program.
-		/** @type {HarmonySettings[]} */
+		// Parsers are reused across modules, so all three are reset per program.
+		/** @type {ESMSettings[]} */
 		const declaredSpecifiers = [];
-		/** @type {HarmonyImportSideEffectDependency | undefined} */
+		/** @type {ESMImportSideEffectDependency | undefined} */
 		let lastSideEffectDependency;
+		/** @type {Identifier | MemberExpression | undefined} */
+		let assignmentTarget;
 
 		parser.hooks.program.tap(PLUGIN_NAME, () => {
 			declaredSpecifiers.length = 0;
 			lastSideEffectDependency = undefined;
+			assignmentTarget = undefined;
 		});
 		parser.hooks.finish.tap(PLUGIN_NAME, () => {
 			for (const settings of declaredSpecifiers) {
 				const dependency = settings.dependency;
-				if (dependency === undefined || settings.used) continue;
+				if (dependency === undefined) continue;
+				// A namespace import names no export, so no reference site answers for
+				// it. Recorded whatever the devtool is: a module the cache restores is
+				// never parsed again, and the option reading it is chosen afterwards.
+				if (settings.ids.length === 0) {
+					if (dependency.namespaceSpecifiers === undefined) {
+						dependency.namespaceSpecifiers = [];
+					}
+					dependency.namespaceSpecifiers.push(settings.name);
+					continue;
+				}
+				if (settings.used) continue;
 				if (dependency.unusedSpecifiers === undefined) {
 					dependency.unusedSpecifiers = {
 						exportPresenceMode: this.exportPresenceMode,
@@ -261,6 +280,7 @@ class HarmonyImportDependencyParserPlugin {
 			}
 			declaredSpecifiers.length = 0;
 			lastSideEffectDependency = undefined;
+			assignmentTarget = undefined;
 		});
 
 		/**
@@ -279,7 +299,7 @@ class HarmonyImportDependencyParserPlugin {
 			if (
 				parser.isVariableDefined(expr.name) ||
 				markUsed(
-					/** @type {HarmonySettings | undefined} */
+					/** @type {ESMSettings | undefined} */
 					(parser.getTagData(expr.name, harmonySpecifierTag))
 				)
 			) {
@@ -287,8 +307,8 @@ class HarmonyImportDependencyParserPlugin {
 			}
 		});
 		parser.hooks.import.tap(PLUGIN_NAME, (statement, source) => {
-			parser.state.lastHarmonyImportOrder =
-				(parser.state.lastHarmonyImportOrder || 0) + 1;
+			parser.state.lastESMImportOrder =
+				(parser.state.lastESMImportOrder || 0) + 1;
 			const clearDep = new ConstDependency(
 				parser.isAsiPosition(/** @type {Range} */ (statement.range)[0])
 					? ";"
@@ -316,11 +336,11 @@ class HarmonyImportDependencyParserPlugin {
 			// which for a module emitting its own file is that file.
 			const SideEffectDependency =
 				statement.specifiers.length === 0
-					? HarmonyImportBareSideEffectDependency
-					: HarmonyImportSideEffectDependency;
+					? ESMImportBareSideEffectDependency
+					: ESMImportSideEffectDependency;
 			const sideEffectDep = new SideEffectDependency(
 				/** @type {string} */ (source),
-				parser.state.lastHarmonyImportOrder,
+				parser.state.lastESMImportOrder,
 				phase,
 				attributes
 			);
@@ -334,20 +354,18 @@ class HarmonyImportDependencyParserPlugin {
 			(statement, source, id, name) => {
 				const ids = id === null ? [] : [id];
 				const phase = getImportPhase(parser, statement);
-				const settings = /** @type {HarmonySettings} */ ({
+				const settings = /** @type {ESMSettings} */ ({
 					name,
 					source,
 					ids,
-					sourceOrder: parser.state.lastHarmonyImportOrder,
+					sourceOrder: parser.state.lastESMImportOrder,
 					attributes: getImportAttributes(statement),
 					phase,
 					used: false,
 					dependency: lastSideEffectDependency
 				});
 				parser.tagVariable(name, harmonySpecifierTag, settings);
-				// The statement's dependency carries them, so a never-referenced
-				// one still resolves; a namespace import names no export.
-				if (ids.length !== 0) declaredSpecifiers.push(settings);
+				declaredSpecifiers.push(settings);
 				return true;
 			}
 		);
@@ -361,7 +379,7 @@ class HarmonyImportDependencyParserPlugin {
 			if (!info) return;
 
 			const { leftPart, members, settings } = info;
-			const dep = new HarmonyEvaluatedImportSpecifierDependency(
+			const dep = new ESMEvaluatedImportSpecifierDependency(
 				settings.source,
 				settings.sourceOrder,
 				[...settings.ids, ...members, leftPart],
@@ -388,10 +406,10 @@ class HarmonyImportDependencyParserPlugin {
 				const nameInfo = parser.getNameForExpression(expr);
 				if (
 					nameInfo &&
-					nameInfo.rootInfo instanceof VariableInfo &&
+					isVariableInfo(nameInfo.rootInfo) &&
 					nameInfo.rootInfo.name &&
 					markUsed(
-						/** @type {HarmonySettings | undefined} */
+						/** @type {ESMSettings | undefined} */
 						(parser.getTagData(nameInfo.rootInfo.name, harmonySpecifierTag))
 					)
 				) {
@@ -399,14 +417,48 @@ class HarmonyImportDependencyParserPlugin {
 				}
 			}
 		);
-		// Concatenation would turn the binding into a plain local, losing the
-		// getter-only property whose write throws.
-		parser.hooks.assign.for(harmonySpecifierTag).tap(PLUGIN_NAME, (expr) => {
-			const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
-			markUsed(settings);
+		/**
+		 * The reference a write lands on, which is a pattern for a
+		 * destructuring write.
+		 * @param {WriteStatement} node the construct performing the write
+		 * @returns {Pattern | MemberExpression} the written reference
+		 */
+		const writeTargetOf = (node) =>
+			/** @type {Pattern | MemberExpression} */ (
+				node.type === "UpdateExpression" ? node.argument : node.left
+			);
+
+		/**
+		 * Whether a member write lands on the namespace object itself, which is
+		 * read-only. A property of an imported object is an ordinary write.
+		 * @param {ESMSettings} settings the specifier's settings
+		 * @param {Members} members the member chain
+		 * @returns {boolean} true when the write targets a namespace member
+		 */
+		const isNamespaceMemberWrite = (settings, members) =>
+			settings.ids.length === 0 && members.length === 1;
+
+		/**
+		 * Keeps the module whole, for a write whose reference the output has no
+		 * way to flag.
+		 * @returns {void}
+		 */
+		const bailOutOfConcatenation = () => {
 			/** @type {JavascriptModuleBuildInfo} */
 			(parser.state.module.buildInfo).moduleConcatenationBailout =
 				"assignment to an imported binding";
+		};
+
+		/**
+		 * Records the write target of an assignment or update to an imported
+		 * binding, so the reference walked next renders as a throwing write.
+		 * @param {WriteStatement} expr the write
+		 * @param {Identifier | MemberExpression | undefined} target the written reference, if any
+		 * @returns {void}
+		 */
+		const markImportedBindingWrite = (expr, target) => {
+			const settings = /** @type {ESMSettings} */ (parser.currentTagData);
+			markUsed(settings);
 			// A named import is written through the namespace's getter-only
 			// property, which throws on its own. A namespace one is the binding
 			// itself, and nothing webpack can emit for it throws, so report it.
@@ -414,15 +466,55 @@ class HarmonyImportDependencyParserPlugin {
 				const error = new ImportedBindingAssignmentError(settings.name);
 				error.loc = parser.getLocation(expr);
 				parser.state.module.addError(error);
+			} else if (target) {
+				assignmentTarget = target;
+			} else {
+				// A destructuring target emits no reference to flag, so the whole
+				// module stays out of concatenation.
+				bailOutOfConcatenation();
 			}
+		};
+
+		parser.hooks.assign.for(harmonySpecifierTag).tap(PLUGIN_NAME, (expr) => {
+			markImportedBindingWrite(
+				expr,
+				expr.left.type === "Identifier" ? expr.left : undefined
+			);
+		});
+		parser.hooks.write.for(harmonySpecifierTag).tap(PLUGIN_NAME, (node) => {
+			const written = writeTargetOf(node);
+			const target =
+				written.type === "Identifier"
+					? /** @type {Identifier} */ (written)
+					: undefined;
+			markImportedBindingWrite(node, target);
+			// A loop's binding walks nothing on its own, so the reference the
+			// write renders as has to be walked here to exist at all.
+			if (!target || node.type === "UpdateExpression") return;
+			parser.walkExpression(target);
+			return true;
 		});
+		// A namespace member is written through the reference its member chain
+		// emits, so both write forms flag that reference rather than the binding.
+		parser.hooks.writeMemberChain
+			.for(harmonySpecifierTag)
+			.tap(PLUGIN_NAME, (node, members) => {
+				const settings = /** @type {ESMSettings} */ (parser.currentTagData);
+				if (!isNamespaceMemberWrite(settings, members)) return;
+				const written = writeTargetOf(node);
+				if (written.type === "MemberExpression") {
+					assignmentTarget = written;
+				} else {
+					bailOutOfConcatenation();
+				}
+			});
 		parser.hooks.expression
 			.for(harmonySpecifierTag)
 			.tap(PLUGIN_NAME, (expr) => {
-				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
+				const settings = /** @type {ESMSettings} */ (parser.currentTagData);
 				settings.used = true;
 
-				const dep = new HarmonyImportSpecifierDependency(
+				const dep = new ESMImportSpecifierDependency(
 					settings.source,
 					settings.sourceOrder,
 					settings.ids,
@@ -443,6 +535,10 @@ class HarmonyImportDependencyParserPlugin {
 				);
 				dep.loc = parser.getLocation(expr);
 				dep.call = parser.scope.inTaggedTemplateTag;
+				if (assignmentTarget === expr) {
+					dep.assignment = true;
+					assignmentTarget = undefined;
+				}
 				parser.state.module.addDependency(dep);
 				attachDependencyGuards(parser, dep);
 				getInnerGraphUtils(parser.state.compilation).onUsage(
@@ -457,18 +553,21 @@ class HarmonyImportDependencyParserPlugin {
 				PLUGIN_NAME,
 				(expression, members, membersOptionals, memberRanges) => {
 					const settings =
-						/** @type {HarmonySettings} */
+						/** @type {ESMSettings} */
 						(parser.currentTagData);
 					settings.used = true;
 					const nonOptionalMembers = getNonOptionalPart(
 						members,
 						membersOptionals
 					);
+					const rangeCount =
+						memberRanges.length - (members.length - nonOptionalMembers.length);
+					// Nothing left to record is the common case, so share one array.
 					/** @type {Range[]} */
-					const ranges = memberRanges.slice(
-						0,
-						memberRanges.length - (members.length - nonOptionalMembers.length)
-					);
+					const ranges =
+						rangeCount > 0
+							? memberRanges.slice(0, rangeCount)
+							: EMPTY_ID_RANGES;
 					const expr =
 						nonOptionalMembers !== members
 							? getNonOptionalMemberChain(
@@ -477,7 +576,7 @@ class HarmonyImportDependencyParserPlugin {
 								)
 							: expression;
 					const ids = [...settings.ids, ...nonOptionalMembers];
-					const dep = new HarmonyImportSpecifierDependency(
+					const dep = new ESMImportSpecifierDependency(
 						settings.source,
 						settings.sourceOrder,
 						ids,
@@ -496,6 +595,10 @@ class HarmonyImportDependencyParserPlugin {
 						(expr.range)[0]
 					);
 					dep.loc = parser.getLocation(expr);
+					if (assignmentTarget === expression) {
+						dep.assignment = true;
+						assignmentTarget = undefined;
+					}
 					parser.state.module.addDependency(dep);
 					attachDependencyGuards(parser, dep);
 					getInnerGraphUtils(parser.state.compilation).onUsage(
@@ -512,19 +615,20 @@ class HarmonyImportDependencyParserPlugin {
 				(expression, members, membersOptionals, memberRanges) => {
 					const { arguments: args } = expression;
 					const callee = /** @type {MemberExpression} */ (expression.callee);
-					const settings = /** @type {HarmonySettings} */ (
-						parser.currentTagData
-					);
+					const settings = /** @type {ESMSettings} */ (parser.currentTagData);
 					settings.used = true;
 					const nonOptionalMembers = getNonOptionalPart(
 						members,
 						membersOptionals
 					);
+					const rangeCount =
+						memberRanges.length - (members.length - nonOptionalMembers.length);
+					// Nothing left to record is the common case, so share one array.
 					/** @type {Range[]} */
-					const ranges = memberRanges.slice(
-						0,
-						memberRanges.length - (members.length - nonOptionalMembers.length)
-					);
+					const ranges =
+						rangeCount > 0
+							? memberRanges.slice(0, rangeCount)
+							: EMPTY_ID_RANGES;
 					const expr =
 						nonOptionalMembers !== members
 							? getNonOptionalMemberChain(
@@ -533,7 +637,7 @@ class HarmonyImportDependencyParserPlugin {
 								)
 							: callee;
 					const ids = [...settings.ids, ...nonOptionalMembers];
-					const dep = new HarmonyImportSpecifierDependency(
+					const dep = new ESMImportSpecifierDependency(
 						settings.source,
 						settings.sourceOrder,
 						ids,
@@ -564,19 +668,17 @@ class HarmonyImportDependencyParserPlugin {
 					return true;
 				}
 			);
-		// Per the TC39 import-defer spec, [[Set]] on a Module Namespace
-		// Exotic Object returns false without triggering evaluation. The
-		// default expressionMemberChain path produces `<importVar>.a.foo`
-		// whose `.a` getter eagerly requires (and thus evaluates) the
-		// deferred module. For top-level `ns.foo = value`, walk only the
-		// bare `ns` identifier so it gets replaced with the deferred
-		// namespace proxy (whose set trap returns false), and leave the
-		// `.foo = value` part as plain code.
+		// `[[Set]]` on a Module Namespace returns false without evaluating, yet the
+		// member-chain path emits `<importVar>.a.foo`, whose getter evaluates. So
+		// only the bare `ns` is walked, leaving `.foo = value` as plain code.
 		parser.hooks.assignMemberChain
 			.for(harmonySpecifierTag)
 			.tap(PLUGIN_NAME, (expression, members) => {
-				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
+				const settings = /** @type {ESMSettings} */ (parser.currentTagData);
 				settings.used = true;
+				if (isNamespaceMemberWrite(settings, members)) {
+					assignmentTarget = /** @type {MemberExpression} */ (expression.left);
+				}
 				if (!ImportPhaseUtils.isDefer(settings.phase)) return;
 				if (expression.operator !== "=") return;
 				if (members.length !== 1) return;
@@ -589,18 +691,18 @@ class HarmonyImportDependencyParserPlugin {
 		const { hotAcceptCallback, hotAcceptWithoutCallback } =
 			getParserHooks(parser);
 		hotAcceptCallback.tap(PLUGIN_NAME, (expr, requests) => {
-			if (!HarmonyExports.isEnabled(parser.state)) {
+			if (!ESMExports.isEnabled(parser.state)) {
 				// This is not a harmony module, skip it
 				return;
 			}
 			const dependencies = requests.map((request) => {
-				const dep = new HarmonyAcceptImportDependency(request);
+				const dep = new ESMAcceptImportDependency(request);
 				dep.loc = parser.getLocation(expr);
 				parser.state.module.addDependency(dep);
 				return dep;
 			});
 			if (dependencies.length > 0) {
-				const dep = new HarmonyAcceptDependency(
+				const dep = new ESMAcceptDependency(
 					/** @type {Range} */
 					(expr.range),
 					dependencies,
@@ -611,18 +713,18 @@ class HarmonyImportDependencyParserPlugin {
 			}
 		});
 		hotAcceptWithoutCallback.tap(PLUGIN_NAME, (expr, requests) => {
-			if (!HarmonyExports.isEnabled(parser.state)) {
+			if (!ESMExports.isEnabled(parser.state)) {
 				// This is not a harmony module, skip it
 				return;
 			}
 			const dependencies = requests.map((request) => {
-				const dep = new HarmonyAcceptImportDependency(request);
+				const dep = new ESMAcceptImportDependency(request);
 				dep.loc = parser.getLocation(expr);
 				parser.state.module.addDependency(dep);
 				return dep;
 			});
 			if (dependencies.length > 0) {
-				const dep = new HarmonyAcceptDependency(
+				const dep = new ESMAcceptDependency(
 					/** @type {Range} */
 					(expr.range),
 					dependencies,
@@ -660,6 +762,6 @@ class HarmonyImportDependencyParserPlugin {
 	}
 }
 
-HarmonyImportDependencyParserPlugin.harmonySpecifierTag = harmonySpecifierTag;
+ESMImportDependencyParserPlugin.harmonySpecifierTag = harmonySpecifierTag;
 
-module.exports = HarmonyImportDependencyParserPlugin;
+module.exports = ESMImportDependencyParserPlugin;