webpack 5.111.1 → 5.112.1

package/lib/dependencies/{HarmonyImportSpecifierDependency.js → esm/ESMImportSpecifierDependency.js}

@@ -5,69 +5,69 @@
 
 "use strict";
 
-const Dependency = require("../Dependency");
-const InitFragment = require("../InitFragment");
-const Template = require("../Template");
+const Dependency = require("../../graph/Dependency");
 const {
-	InlinedUsedName,
 	isExportInlined,
 	isInlineEnabled,
-	isInlineExportsEnabled
-} = require("../optimize/InlineExports");
+	isInlineExportsEnabled,
+	isInlinedUsedName
+} = require("../../optimize/InlineExports");
 const {
 	getDependencyUsedByExportsCondition
-} = require("../optimize/InnerGraph");
-const { getTrimmedIdsAndRange } = require("../util/chainedImports");
-const makeSerializable = require("../util/makeSerializable");
-const { propertyAccess } = require("../util/property");
-const traverseDestructuringAssignmentProperties = require("../util/traverseDestructuringAssignmentProperties");
-const HarmonyImportDependency = require("./HarmonyImportDependency");
-const HarmonyImportGuard = require("./HarmonyImportGuard");
-const { ImportPhaseUtils } = require("./ImportPhase");
+} = require("../../optimize/InnerGraph");
+const InitFragment = require("../../template/InitFragment");
+const Template = require("../../template/Template");
+const makeSerializable = require("../../util/makeSerializable");
+const { propertyAccess } = require("../../util/property");
+const { ImportPhaseUtils } = require("../core/ImportPhase");
+const { getTrimmedIdsAndRange } = require("../helpers/chainedImports");
+const traverseDestructuringAssignmentProperties = require("../helpers/traverseDestructuringAssignmentProperties");
+const ESMImportDependency = require("./ESMImportDependency");
+const ESMImportGuard = require("./ESMImportGuard");
 
 /** @import { ReplaceSource } from "webpack-sources" */
-/** @import { GetConditionFn, ReferencedExports, UpdateHashContext } from "../Dependency" */
-/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
-/** @import Module, { BuildMeta } from "../Module" */
-/** @import ModuleGraph from "../ModuleGraph" */
-/** @import Hash from "../util/Hash" */
+/** @import { GetConditionFn, ReferencedExports, UpdateHashContext, DependencyKinds } from "../../graph/Dependency" */
+/** @import { DependencyTemplateContext } from "../../template/DependencyTemplate" */
+/** @import Module, { BuildMeta } from "../../module/Module" */
+/** @import ModuleGraph from "../../graph/ModuleGraph" */
+/** @import Hash from "../../util/Hash" */
 /**
  * @import ModuleGraphConnection, {
  * 	ConnectionState
- * } from "../ModuleGraphConnection"
+ * } from "../../graph/ModuleGraphConnection"
  */
-/** @import WebpackError from "../errors/WebpackError" */
+/** @import WebpackError from "../../errors/WebpackError" */
 /**
  * @import {
  * 	DestructuringAssignmentProperties,
  * 	ImportAttributes,
  * 	Range
- * } from "../javascript/JavascriptParser"
+ * } from "../../javascript/JavascriptParser"
  */
-/** @import { UsedByExports } from "../optimize/InnerGraph" */
+/** @import { UsedByExports } from "../../optimize/InnerGraph" */
 /**
  * @import {
  * 	ObjectDeserializerContext,
  * 	ObjectSerializerContext
- * } from "../serialization/ObjectMiddleware"
+ * } from "../../serialization/ObjectMiddleware"
  */
-/** @import { RuntimeSpec } from "../util/runtime" */
-/** @import { IdRanges } from "../util/chainedImports" */
-/** @import { ExportPresenceMode } from "./HarmonyImportDependency" */
-/** @typedef {HarmonyImportDependency.Ids} Ids */
-/** @import { ImportPhaseType } from "./ImportPhase" */
-/** @import { DependencyGuard } from "./HarmonyImportGuard" */
+/** @import { RuntimeSpec } from "../../util/runtime" */
+/** @import { IdRanges } from "../helpers/chainedImports" */
+/** @import { ExportPresenceMode } from "./ESMImportDependency" */
+/** @typedef {ESMImportDependency.Ids} Ids */
+/** @import { ImportPhaseType } from "../core/ImportPhase" */
+/** @import { DependencyGuard } from "./ESMImportGuard" */
 /**
  * @import {
  * 	JavascriptModuleBuildMeta
- * } from "../javascript/JavascriptModule"
+ * } from "../../javascript/JavascriptModule"
  */
 
 const idsSymbol = /** @type {symbol} */ (
-	Symbol("HarmonyImportSpecifierDependency.ids")
+	Symbol("ESMImportSpecifierDependency.ids")
 );
 
-const { ExportPresenceModes } = HarmonyImportDependency;
+const { ExportPresenceModes } = ESMImportDependency;
 
 /**
  * One condition closure per module graph and variant rather than per dependency.
@@ -79,14 +79,9 @@ const { ExportPresenceModes } = HarmonyImportDependency;
  */
 const conditionsByModuleGraph = new WeakMap();
 
-class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
-	// read by `HarmonyImportGuard` in place of `instanceof`, which would cycle
-	get isHarmonyImportSpecifier() {
-		return true;
-	}
-
+class ESMImportSpecifierDependency extends ESMImportDependency {
 	/**
-	 * Creates an instance of HarmonyImportSpecifierDependency.
+	 * Creates an instance of ESMImportSpecifierDependency.
 	 * @param {string} request request
 	 * @param {number} sourceOrder source order
 	 * @param {Ids} ids ids
@@ -106,7 +101,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		exportPresenceMode,
 		phase,
 		attributes,
-		idRanges // TODO webpack 6 make this non-optional. It must always be set to properly trim ids.
+		idRanges // TODO in the next major release: make this non-optional. It must always be set to properly trim ids.
 	) {
 		super(request, sourceOrder, phase, attributes);
 		/** @type {Ids} */
@@ -138,7 +133,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		this.assignment = undefined;
 	}
 
-	// TODO webpack 6 remove
+	// TODO in the next major release: remove
 	/**
 	 * Returns id.
 	 * @deprecated
@@ -147,7 +142,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		throw new Error("id was renamed to ids and type changed to string[]");
 	}
 
-	// TODO webpack 6 remove
+	// TODO in the next major release: remove
 	/**
 	 * Returns id.
 	 * @deprecated
@@ -156,7 +151,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		throw new Error("id was renamed to ids and type changed to string[]");
 	}
 
-	// TODO webpack 6 remove
+	// TODO in the next major release: remove
 	/**
 	 * Updates id.
 	 * @deprecated
@@ -173,8 +168,11 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	 * Returns the export name this dependency requests from its target module (lazy barrel optimization).
 	 * @returns {string | true | null} export name, true for all exports, null for none
 	 */
-	getForwardId() {
-		return this.ids.length > 0 ? this.ids[0] : true;
+	get forwardId() {
+		// SideEffectsFlagPlugin keeps a call with the namespace as `this` on the
+		// barrel, so the barrel runs whole
+		if (this.ids.length === 0 || this.namespaceObjectAsContext) return true;
+		return this.ids[0];
 	}
 
 	/**
@@ -233,7 +231,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		if (cached !== undefined) return cached;
 		/** @type {GetConditionFn} */
 		const condition = (connection, runtime) => {
-			const dep = /** @type {HarmonyImportSpecifierDependency} */ (
+			const dep = /** @type {ESMImportSpecifierDependency} */ (
 				connection.dependency
 			);
 			if (usedByExportsCondition !== null) {
@@ -255,7 +253,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 			const guards = dep.branchGuards;
 			if (
 				guards !== undefined &&
-				HarmonyImportGuard.isDeadByGuards(guards, moduleGraph, runtime)
+				ESMImportGuard.isDeadByGuards(guards, moduleGraph, runtime)
 			) {
 				return false;
 			}
@@ -282,7 +280,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		const exportsInfo = moduleGraph.getExportsInfo(module);
 		if (!exportsInfo.hasInlinedUsedName(ids, runtime)) return;
 		const usedName = exportsInfo.getUsedName(ids, runtime);
-		if (usedName instanceof InlinedUsedName) {
+		if (isInlinedUsedName(usedName)) {
 			usedName.updateHash(hash);
 		}
 	}
@@ -504,13 +502,15 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	}
 }
 
-makeSerializable(
-	HarmonyImportSpecifierDependency,
+makeSerializable(ESMImportSpecifierDependency, [
+	"webpack/lib/dependencies/esm/ESMImportSpecifierDependency",
+	// TODO in the next major release: remove, it restores the packs written
+	// under the name the file had before the ESM rename
 	"webpack/lib/dependencies/HarmonyImportSpecifierDependency"
-);
+]);
 
-HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependencyTemplate extends (
-	HarmonyImportDependency.Template
+ESMImportSpecifierDependency.Template = class ESMImportSpecifierDependencyTemplate extends (
+	ESMImportDependency.Template
 ) {
 	/**
 	 * Applies the plugin by registering its hooks on the compiler.
@@ -520,7 +520,7 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 	 * @returns {void}
 	 */
 	apply(dependency, source, templateContext) {
-		const dep = /** @type {HarmonyImportSpecifierDependency} */ (dependency);
+		const dep = /** @type {ESMImportSpecifierDependency} */ (dependency);
 		const { moduleGraph, runtime, initFragments } = templateContext;
 		const connection = moduleGraph.getConnection(dep);
 		const ids = dep.getIds(moduleGraph);
@@ -533,7 +533,7 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 			initFragments.push(
 				new InitFragment(
 					`/* unused harmony import specifier */ var ${dep.name};\n`,
-					InitFragment.STAGE_HARMONY_IMPORTS,
+					InitFragment.STAGE_ESM_IMPORTS,
 					0,
 					`unused import specifier ${dep.name}`
 				)
@@ -608,7 +608,7 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 				const used = destructuredExportsInfo.getUsedName(concatedIds, runtime);
 				if (!used) {
 					return;
-				} else if (used instanceof InlinedUsedName) {
+				} else if (isInlinedUsedName(used)) {
 					throw new Error(
 						`Should not inline for destructuring name ${concatedIds.join(".")}`
 					);
@@ -633,7 +633,7 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 
 	/**
 	 * Returns generated code.
-	 * @param {HarmonyImportSpecifierDependency} dep dependency
+	 * @param {ESMImportSpecifierDependency} dep dependency
 	 * @param {ReplaceSource} source source
 	 * @param {DependencyTemplateContext} templateContext context
 	 * @param {Ids} ids ids
@@ -722,11 +722,49 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 					!dep.referencedPropertiesInDestructuring &&
 					!ImportPhaseUtils.isDefer(dep.phase)
 			});
+
+			// Only a bare reference reads exactly what the binding names.
+			if (
+				dep.directImport === true &&
+				templateContext.dependencyTemplates.importBindingScopes
+			) {
+				// A call site drops the `this` a member access would bind, which is
+				// a statement's concern rather than the binding's value.
+				const value = dep.call
+					? runtimeTemplate.exportFromImport({
+							moduleGraph,
+							module: /** @type {Module} */ (moduleGraph.getModule(dep)),
+							chunkGraph: templateContext.chunkGraph,
+							request: dep.request,
+							exportName: ids,
+							originModule: module,
+							asiSafe: true,
+							isCall: false,
+							callContext: false,
+							defaultInterop: true,
+							importVar: dep.getImportVar(moduleGraph),
+							initFragments,
+							runtime,
+							runtimeRequirements,
+							dependency: dep,
+							mangleableNamespace: false
+						})
+					: exportExpr;
+				if (!value.startsWith(";")) {
+					this._recordImportBinding(templateContext, dep.name, value);
+				}
+			}
 		}
 		return exportExpr;
 	}
 };
 
-HarmonyImportSpecifierDependency.idsSymbol = idsSymbol;
+ESMImportSpecifierDependency.idsSymbol = idsSymbol;
+
+/** @type {Set<keyof DependencyKinds>} */
+ESMImportSpecifierDependency.KINDS = new Set([
+	...ESMImportDependency.KINDS,
+	"esm-import-specifier"
+]);
 
-module.exports = HarmonyImportSpecifierDependency;
+module.exports = ESMImportSpecifierDependency;

package/lib/dependencies/esm/ESMLiveExportDependency.js

@@ -0,0 +1,311 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../../runtime/RuntimeGlobals");
+const makeSerializable = require("../../util/makeSerializable");
+const { propertyAccess } = require("../../util/property");
+const { getRuntimeKey } = require("../../util/runtime");
+const NullDependency = require("../core/NullDependency");
+
+// ReplaceSource sorts fractional positions before flooring them to source offsets.
+// Value wrappers open before sync calls and close after them; statement inserts
+// and body closures follow both.
+const SYNC_START_OFFSET = 0.5;
+const VALUE_END_OFFSET = 0.5;
+const AFTER_VALUE_OFFSET = 0.75;
+
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import Dependency, { DependencyKinds, UpdateHashContext } from "../../graph/Dependency" */
+/** @import ModuleGraph, { LiveBinding } from "../../graph/ModuleGraph" */
+/** @import Module from "../../module/Module" */
+/** @import { DependencyTemplateContext } from "../../template/DependencyTemplate" */
+/** @import Hash from "../../util/Hash" */
+/** @import { RuntimeSpec } from "../../util/runtime" */
+/** @typedef {import("../../serialization/ObjectMiddleware").ObjectDeserializerContext<[string[], number[], number[], boolean, boolean, boolean]>} ObjectDeserializerContext */
+/** @typedef {import("../../serialization/ObjectMiddleware").ObjectSerializerContext<[string[], number[], number[], boolean, boolean, boolean]>} ObjectSerializerContext */
+
+/**
+ * The names the chunk's scope declares for a declaration, and how the module keeps them.
+ * @typedef {object} HoistedNames
+ * @property {string[]} names the declared name of each name
+ * @property {boolean} mirrored whether the module keeps its declaration and mirrors each write
+ * @property {boolean} registered whether it mirrors them through the setters a module library registers
+ */
+
+/**
+ * A module-level binding a module library may declare in the chunk's scope under a
+ * reserved name, so the library exports the binding itself; it holds every reference,
+ * and every write a module keeping its declaration mirrors there instead.
+ */
+class ESMLiveExportDependency extends NullDependency {
+	/**
+	 * Creates an instance of ESMLiveExportDependency.
+	 * @param {string[]} names every name the declaration declares
+	 * @param {number[]} occurrences flat triples of start, end and `name index * KINDS_PER_NAME + kind` renaming takes, a kind from {@link ESMLiveExportDependency.REFERENCE}
+	 * @param {number[]} mirrors the same triples for where a module keeping its declaration mirrors a write, a kind from {@link ESMLiveExportDependency.SYNC}
+	 * @param {boolean} readByEval whether the module calls `eval`, which reads the names as written
+	 * @param {boolean} hot whether a hot update replaces the module, which then only mirrors, as renaming cannot reach it
+	 * @param {boolean} earlyUse whether the module uses a `let` or class above its declaration, where only its own declaration throws
+	 */
+	constructor(names, occurrences, mirrors, readByEval, hot, earlyUse) {
+		super();
+		this.names = names;
+		this.occurrences = occurrences;
+		this.mirrors = mirrors;
+		this.readByEval = readByEval;
+		this.hot = hot;
+		this.earlyUse = earlyUse;
+	}
+
+	get type() {
+		return "harmony live export";
+	}
+
+	/**
+	 * Returns the names the chunk's scope declares for this runtime, if it does.
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {RuntimeSpec} runtime the runtime the module is generated for
+	 * @returns {HoistedNames | undefined} the names and how the module keeps them
+	 */
+	getHoistedNames(moduleGraph, runtime) {
+		const meta = moduleGraph.getMetaIfExisting(
+			/** @type {Module} */ (moduleGraph.getParentModule(this))
+		);
+		if (meta === undefined) return;
+		const runtimeKey = getRuntimeKey(runtime);
+		for (const bindings of [meta.liveSetters, meta.liveBindings]) {
+			if (bindings === undefined) continue;
+			const first = bindings.get(this.names[0]);
+			if (first === undefined || !first.runtimes.has(runtimeKey)) continue;
+			return {
+				names: this.names.map(
+					(name) => /** @type {LiveBinding} */ (bindings.get(name)).name
+				),
+				mirrored: bindings === meta.liveSetters,
+				registered: first.registered.has(runtimeKey)
+			};
+		}
+	}
+
+	/**
+	 * Updates the hash with the data contributed by this instance.
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		const hoisted = this.getHoistedNames(
+			context.chunkGraph.moduleGraph,
+			context.runtime
+		);
+		if (hoisted === undefined) return;
+		hash.update(
+			`${hoisted.names.join()}|${hoisted.mirrored}|${hoisted.registered}`
+		);
+	}
+
+	/**
+	 * Serializes this instance into the provided serializer context.
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		context
+			.write(this.names)
+			.write(this.occurrences)
+			.write(this.mirrors)
+			.write(this.readByEval)
+			.write(this.hot)
+			.write(this.earlyUse);
+		super.serialize(context);
+	}
+
+	/**
+	 * Restores this instance from the provided deserializer context.
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		this.names = context.read();
+		const c1 = context.rest;
+		this.occurrences = c1.read();
+		const c2 = c1.rest;
+		this.mirrors = c2.read();
+		const c3 = c2.rest;
+		this.readByEval = c3.read();
+		const c4 = c3.rest;
+		this.hot = c4.read();
+		const c5 = c4.rest;
+		this.earlyUse = c5.read();
+		super.deserialize(c5.rest);
+	}
+}
+
+makeSerializable(
+	ESMLiveExportDependency,
+	"webpack/lib/dependencies/esm/ESMLiveExportDependency"
+);
+
+ESMLiveExportDependency.Template = class ESMLiveExportDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(
+		dependency,
+		source,
+		{ moduleGraph, chunkGraph, module, runtime, runtimeRequirements }
+	) {
+		const dep = /** @type {ESMLiveExportDependency} */ (dependency);
+		const hoisted = dep.getHoistedNames(moduleGraph, runtime);
+		if (hoisted === undefined) return;
+		const { occurrences, mirrors, names } = dep;
+		const kinds = ESMLiveExportDependency.KINDS_PER_NAME;
+		if (hoisted.mirrored) {
+			const id = hoisted.registered
+				? JSON.stringify(chunkGraph.getModuleId(module))
+				: "";
+			if (hoisted.registered) runtimeRequirements.add(RuntimeGlobals.require);
+			/** @type {string[]} */
+			const helpers = [];
+			for (let index = 0; index < names.length; index++) {
+				const name = names[index];
+				const helper = `__webpack_live_sync_${name}__`;
+				helpers.push(helper);
+				// Hoisted, so any write may call it; a value passed with `v` set is what
+				// the binding is about to hold, read before the binding is initialized.
+				const sync = hoisted.registered
+					? `\tvar s = ${RuntimeGlobals.liveExportSetters};\n` +
+						`\ts = s && s[${id}];\n` +
+						`\ts = s && s${propertyAccess([name])};\n` +
+						`\tif (s) for (var i = 0; i < s.length; i++) s[i](v ? r : ${name});\n`
+					: `\t${hoisted.names[index]} = v ? r : ${name};\n`;
+				source.insert(
+					0,
+					`function ${helper}(r, v) {\n${
+						// an eval() call may come before the binding is initialized
+						dep.readByEval
+							? `\ttry {\n\t${sync.replace(/\n\t/g, "\n\t\t")}\t} catch (e) {}\n`
+							: sync
+					}\treturn r;\n}\n`
+				);
+			}
+			for (let i = 0; i < mirrors.length; i += 3) {
+				const start = mirrors[i];
+				const end = mirrors[i + 1];
+				const helper = helpers[Math.floor(mirrors[i + 2] / kinds)];
+				switch (mirrors[i + 2] % kinds) {
+					case ESMLiveExportDependency.SYNC:
+						source.insert(start + SYNC_START_OFFSET, `${helper}(`);
+						source.insert(end, ")");
+						break;
+					case ESMLiveExportDependency.VALUE:
+						source.insert(start, `${helper}((`);
+						source.insert(end + VALUE_END_OFFSET, "), 1)");
+						break;
+					case ESMLiveExportDependency.NAMED_VALUE: {
+						// A property key gives the function or class the name the binding did
+						const name = names[Math.floor(mirrors[i + 2] / kinds)];
+						source.insert(start, `${helper}({ ${name}: `);
+						source.insert(end + VALUE_END_OFFSET, ` }.${name}, 1)`);
+						break;
+					}
+					case ESMLiveExportDependency.UNDEFINED:
+						source.insert(start, ` = ${helper}(void 0, 1)`);
+						break;
+					case ESMLiveExportDependency.STATEMENT:
+						source.insert(start + AFTER_VALUE_OFFSET, `;${helper}();\n`);
+						break;
+					case ESMLiveExportDependency.DECLARATOR:
+						source.insert(
+							start + AFTER_VALUE_OFFSET,
+							`, __webpack_live_synced__ = ${helper}()`
+						);
+						break;
+					default:
+						source.insert(start, `{;${helper}();`);
+						source.insert(end + AFTER_VALUE_OFFSET, "}");
+				}
+			}
+			return;
+		}
+		for (let i = 0; i < occurrences.length; i += 3) {
+			const start = occurrences[i];
+			const end = occurrences[i + 1];
+			const index = Math.floor(occurrences[i + 2] / kinds);
+			switch (occurrences[i + 2] % kinds) {
+				case ESMLiveExportDependency.KEYWORD:
+					source.replace(start, end - 1, "");
+					break;
+				case ESMLiveExportDependency.REFERENCE:
+					source.replace(start, end - 1, hoisted.names[index]);
+					break;
+				case ESMLiveExportDependency.SHORTHAND:
+					source.replace(
+						start,
+						end - 1,
+						`${names[index]}: ${hoisted.names[index]}`
+					);
+					break;
+				case ESMLiveExportDependency.NAMED:
+					// A property key gives the function or class the name the binding did
+					source.insert(start, `{ ${names[index]}: `);
+					source.insert(end, ` }.${names[index]}`);
+					break;
+				case ESMLiveExportDependency.PARENTHESIZED:
+					source.insert(start, "(");
+					source.insert(end, ")");
+					break;
+				default:
+					source.insert(
+						start,
+						`\n${hoisted.names[index]} = ${names[index]};\n`
+					);
+			}
+		}
+	}
+};
+
+/** An occurrence the hoisted name replaces */
+ESMLiveExportDependency.REFERENCE = 0;
+/** A shorthand property, which keeps its key */
+ESMLiveExportDependency.SHORTHAND = 1;
+/** An anonymous function or class the binding names */
+ESMLiveExportDependency.NAMED = 2;
+/** A declaration's `let` or `var`, dropped with the space up to its first name */
+ESMLiveExportDependency.KEYWORD = 3;
+/** A destructuring declarator that, without its keyword, needs parentheses */
+ESMLiveExportDependency.PARENTHESIZED = 4;
+/** Where a function or class declaration, which stays, sets the binding */
+ESMLiveExportDependency.INITIALIZE = 5;
+/** A write a hot module mirrors once it ran, wrapped in the name's sync call */
+ESMLiveExportDependency.SYNC = 6;
+/** A declarator's initializer, mirrored as the value the binding takes */
+ESMLiveExportDependency.VALUE = 7;
+/** An anonymous function or class initializer, mirrored under the name it takes */
+ESMLiveExportDependency.NAMED_VALUE = 8;
+/** A declarator without an initializer, mirrored as `undefined` */
+ESMLiveExportDependency.UNDEFINED = 9;
+/** Where a statement mirrors the binding, after a declaration or a loop's next value */
+ESMLiveExportDependency.STATEMENT = 10;
+/** A loop body that is not a block, wrapped in one mirroring the loop's next value */
+ESMLiveExportDependency.BODY = 11;
+/** The end of a loop's `var` head, where a declarator mirrors what a pattern took */
+ESMLiveExportDependency.DECLARATOR = 12;
+/** How many kinds an occurrence's third number tells apart per name */
+ESMLiveExportDependency.KINDS_PER_NAME = 13;
+
+/** @type {Set<keyof DependencyKinds>} */
+ESMLiveExportDependency.KINDS = new Set([
+	...NullDependency.KINDS,
+	"esm-live-export"
+]);
+
+module.exports = ESMLiveExportDependency;