@depup/webpack 5.111.1-depup.2 → 5.112.0-depup.0

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

@@ -5,31 +5,34 @@
 
 "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 {
@@ -44,22 +47,23 @@ const { ImportPhaseUtils, createGetImportPhase } = require("./ImportPhase");
 /**
  * @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,
  * 	WriteStatement
- * } from "../javascript/JavascriptParser"
+ * } 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
@@ -69,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
@@ -78,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) => {
@@ -100,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);
@@ -116,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) {
@@ -147,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":
@@ -176,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) {
@@ -196,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
 	 */
@@ -204,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) {
@@ -238,9 +240,9 @@ class HarmonyImportDependencyParserPlugin {
 		);
 
 		// Parsers are reused across modules, so all three are reset per program.
-		/** @type {HarmonySettings[]} */
+		/** @type {ESMSettings[]} */
 		const declaredSpecifiers = [];
-		/** @type {HarmonyImportSideEffectDependency | undefined} */
+		/** @type {ESMImportSideEffectDependency | undefined} */
 		let lastSideEffectDependency;
 		/** @type {Identifier | MemberExpression | undefined} */
 		let assignmentTarget;
@@ -253,7 +255,18 @@ class HarmonyImportDependencyParserPlugin {
 		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,
@@ -286,7 +299,7 @@ class HarmonyImportDependencyParserPlugin {
 			if (
 				parser.isVariableDefined(expr.name) ||
 				markUsed(
-					/** @type {HarmonySettings | undefined} */
+					/** @type {ESMSettings | undefined} */
 					(parser.getTagData(expr.name, harmonySpecifierTag))
 				)
 			) {
@@ -294,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])
 					? ";"
@@ -323,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
 			);
@@ -341,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;
 			}
 		);
@@ -368,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],
@@ -395,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))
 					)
 				) {
@@ -420,7 +431,7 @@ class HarmonyImportDependencyParserPlugin {
 		/**
 		 * 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 {HarmonySettings} settings the specifier's settings
+		 * @param {ESMSettings} settings the specifier's settings
 		 * @param {Members} members the member chain
 		 * @returns {boolean} true when the write targets a namespace member
 		 */
@@ -446,7 +457,7 @@ class HarmonyImportDependencyParserPlugin {
 		 * @returns {void}
 		 */
 		const markImportedBindingWrite = (expr, target) => {
-			const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
+			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
@@ -488,7 +499,7 @@ class HarmonyImportDependencyParserPlugin {
 		parser.hooks.writeMemberChain
 			.for(harmonySpecifierTag)
 			.tap(PLUGIN_NAME, (node, members) => {
-				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
+				const settings = /** @type {ESMSettings} */ (parser.currentTagData);
 				if (!isNamespaceMemberWrite(settings, members)) return;
 				const written = writeTargetOf(node);
 				if (written.type === "MemberExpression") {
@@ -500,10 +511,10 @@ class HarmonyImportDependencyParserPlugin {
 		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,
@@ -542,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(
@@ -562,7 +576,7 @@ class HarmonyImportDependencyParserPlugin {
 								)
 							: expression;
 					const ids = [...settings.ids, ...nonOptionalMembers];
-					const dep = new HarmonyImportSpecifierDependency(
+					const dep = new ESMImportSpecifierDependency(
 						settings.source,
 						settings.sourceOrder,
 						ids,
@@ -601,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(
@@ -622,7 +637,7 @@ class HarmonyImportDependencyParserPlugin {
 								)
 							: callee;
 					const ids = [...settings.ids, ...nonOptionalMembers];
-					const dep = new HarmonyImportSpecifierDependency(
+					const dep = new ESMImportSpecifierDependency(
 						settings.source,
 						settings.sourceOrder,
 						ids,
@@ -659,7 +674,7 @@ class HarmonyImportDependencyParserPlugin {
 		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);
@@ -676,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,
@@ -698,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,
@@ -747,6 +762,6 @@ class HarmonyImportDependencyParserPlugin {
 	}
 }
 
-HarmonyImportDependencyParserPlugin.harmonySpecifierTag = harmonySpecifierTag;
+ESMImportDependencyParserPlugin.harmonySpecifierTag = harmonySpecifierTag;
 
-module.exports = HarmonyImportDependencyParserPlugin;
+module.exports = ESMImportDependencyParserPlugin;

package/lib/dependencies/{HarmonyImportGuard.js → esm/ESMImportGuard.js}

@@ -5,31 +5,32 @@
 
 "use strict";
 
-const { InlinedUsedName } = require("../optimize/InlineExports");
+const isDependencyKind = require("../../graph/isDependencyKind");
+const { isInlinedUsedName } = require("../../optimize/InlineExports");
 
 /** @import { Expression } from "estree" */
-/** @import Dependency from "../Dependency" */
-/** @import Module from "../Module" */
-/** @import ModuleGraph from "../ModuleGraph" */
-/** @import JavascriptParser from "../javascript/JavascriptParser" */
-/** @import { RuntimeSpec } from "../util/runtime" */
-/** @import CommonJsFullRequireDependency from "./CommonJsFullRequireDependency" */
-/** @import CommonJsRequireDependency from "./CommonJsRequireDependency" */
-/** @import HarmonyEvaluatedImportSpecifierDependency from "./HarmonyEvaluatedImportSpecifierDependency" */
-/** @import HarmonyImportSpecifierDependency from "./HarmonyImportSpecifierDependency" */
-/** @import ImportDependency from "./ImportDependency" */
+/** @import Dependency from "../../graph/Dependency" */
+/** @import Module from "../../module/Module" */
+/** @import ModuleGraph from "../../graph/ModuleGraph" */
+/** @import JavascriptParser from "../../javascript/JavascriptParser" */
+/** @import { RuntimeSpec } from "../../util/runtime" */
+/** @import CommonJsFullRequireDependency from "../commonjs/CommonJsFullRequireDependency" */
+/** @import CommonJsRequireDependency from "../commonjs/CommonJsRequireDependency" */
+/** @import ESMEvaluatedImportSpecifierDependency from "./ESMEvaluatedImportSpecifierDependency" */
+/** @import ESMImportSpecifierDependency from "./ESMImportSpecifierDependency" */
+/** @import ImportDependency from "../import/ImportDependency" */
 
 // Tuple-encoded boolean formula over guard dependencies. Split into per-shape
 // aliases so the recursive references resolve through array/object types.
 // `v` = dependency-liveness atom, `p` = `"x" in ns` presence atom.
 /** @typedef {["v", Dependency]} GuardAtom */
-/** @typedef {["p", HarmonyEvaluatedImportSpecifierDependency]} GuardPresenceAtom */
+/** @typedef {["p", ESMEvaluatedImportSpecifierDependency]} GuardPresenceAtom */
 /** @typedef {["?"]} GuardUnknown */
 /** @typedef {["!", GuardFormula]} GuardNot */
 /** @typedef {["&&" | "||" | "??", GuardFormula, GuardFormula]} GuardLogical */
 /** @typedef {GuardAtom | GuardPresenceAtom | GuardUnknown | GuardNot | GuardLogical} GuardFormula */
 /** @typedef {{ formula: GuardFormula, value: boolean }} DependencyGuard branch guard: the dependency is live only when the formula evaluates to `value` */
-/** @typedef {HarmonyImportSpecifierDependency | CommonJsRequireDependency | CommonJsFullRequireDependency | ImportDependency} GuardableDependency */
+/** @typedef {ESMImportSpecifierDependency | CommonJsRequireDependency | CommonJsFullRequireDependency | ImportDependency} GuardableDependency */
 
 /**
  * A guard frame pushed onto `parser.state.guardStack` for the duration of one
@@ -63,7 +64,7 @@ const fromBool = (b) => (b ? TRUE : FALSE);
 /**
  * Build a liveness formula from a conditional test AST.
  * @param {Expression} test conditional test expression
- * @param {Map<number, HarmonyImportSpecifierDependency>} depByRangeStart import-specifier deps in the test, keyed by range start
+ * @param {Map<number, ESMImportSpecifierDependency>} depByRangeStart import-specifier deps in the test, keyed by range start
  * @returns {GuardFormula | null} formula, or null when it has no knowable atom
  */
 const buildLivenessFormula = (test, depByRangeStart) => {
@@ -125,14 +126,14 @@ const hasAtom = (formula) => {
 const evalLivenessFormula = (formula, moduleGraph, runtime) => {
 	switch (formula[0]) {
 		case "v": {
-			const dep = /** @type {HarmonyImportSpecifierDependency} */ (formula[1]);
+			const dep = /** @type {ESMImportSpecifierDependency} */ (formula[1]);
 			const module = moduleGraph.getModule(dep);
 			if (!module) return { t: UNKNOWN, n: UNKNOWN };
 			const used = moduleGraph
 				.getExportsInfo(module)
 				.getUsedName(dep.getIds(moduleGraph), runtime);
 			// Only a bare inlined primitive is knowable; a property suffix is not.
-			if (!(used instanceof InlinedUsedName) || used.suffix.length !== 0) {
+			if (!isInlinedUsedName(used) || used.suffix.length !== 0) {
 				return { t: UNKNOWN, n: UNKNOWN };
 			}
 			const value = used.value;
@@ -207,16 +208,14 @@ const isDeadByGuards = (guards, moduleGraph, runtime) => {
  */
 const buildFrameLivenessFormula = (parser, frame) => {
 	const deps = /** @type {Module} */ (parser.state.module).dependencies;
-	/** @type {Map<number, HarmonyImportSpecifierDependency>} */
+	/** @type {Map<number, ESMImportSpecifierDependency>} */
 	const depByRangeStart = new Map();
 	for (let i = /** @type {number} */ (frame.depStart); i < deps.length; i++) {
-		const dep = /** @type {HarmonyEvaluatedImportSpecifierDependency} */ (
-			deps[i]
-		);
+		const dep = deps[i];
 		// Exclude `"x" in ns` evaluated deps; those feed the presence formula only.
 		if (
-			dep.isHarmonyImportSpecifier === true &&
-			dep.isHarmonyEvaluatedImportSpecifier !== true &&
+			isDependencyKind(dep, "esm-import-specifier") &&
+			!dep.is("esm-evaluated-import-specifier") &&
 			dep.range
 		) {
 			depByRangeStart.set(dep.range[0], dep);
@@ -234,7 +233,7 @@ const buildFrameLivenessFormula = (parser, frame) => {
  * `"x" in ns` presence atoms (plus `&&`/`!`).
  * @param {JavascriptParser} parser the parser
  * @param {Expression} test conditional test expression
- * @param {Map<number, HarmonyEvaluatedImportSpecifierDependency>} depByRangeStart in-operator deps in the test, keyed by range start
+ * @param {Map<number, ESMEvaluatedImportSpecifierDependency>} depByRangeStart in-operator deps in the test, keyed by range start
  * @returns {GuardFormula | null} formula, or null when it has no presence atom
  */
 const buildPresenceFormula = (parser, test, depByRangeStart) => {
@@ -299,7 +298,7 @@ const buildPresenceFormula = (parser, test, depByRangeStart) => {
 const evalPresenceFormula = (formula, name, member, needTruthy) => {
 	switch (formula[0]) {
 		case "p": {
-			const dep = /** @type {HarmonyEvaluatedImportSpecifierDependency} */ (
+			const dep = /** @type {ESMEvaluatedImportSpecifierDependency} */ (
 				formula[1]
 			);
 			return (
@@ -332,13 +331,11 @@ const evalPresenceFormula = (formula, name, member, needTruthy) => {
  */
 const buildFramePresenceFormula = (parser, frame) => {
 	const deps = /** @type {Module} */ (parser.state.module).dependencies;
-	/** @type {Map<number, HarmonyEvaluatedImportSpecifierDependency>} */
+	/** @type {Map<number, ESMEvaluatedImportSpecifierDependency>} */
 	const depByRangeStart = new Map();
 	for (let i = /** @type {number} */ (frame.depStart); i < deps.length; i++) {
-		const dep = /** @type {HarmonyEvaluatedImportSpecifierDependency} */ (
-			deps[i]
-		);
-		if (dep.isHarmonyEvaluatedImportSpecifier === true && dep.range) {
+		const dep = deps[i];
+		if (isDependencyKind(dep, "esm-evaluated-import-specifier") && dep.range) {
 			depByRangeStart.set(dep.range[0], dep);
 		}
 	}