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

package/lib/library/ModuleLibraryPlugin.js

@@ -6,27 +6,30 @@
 "use strict";
 
 const { ConcatSource } = require("webpack-sources");
-const { UsageState } = require("../ExportsInfo");
-const ExternalModule = require("../ExternalModule");
-const { JAVASCRIPT_TYPE } = require("../ModuleSourceTypeConstants");
-const RuntimeGlobals = require("../RuntimeGlobals");
-const Template = require("../Template");
-const HarmonyExportExpressionDependency = require("../dependencies/HarmonyExportExpressionDependency");
-const HarmonyExportImportedSpecifierDependency = require("../dependencies/HarmonyExportImportedSpecifierDependency");
-const HarmonyExportSpecifierDependency = require("../dependencies/HarmonyExportSpecifierDependency");
 const ExternalStarReexportError = require("../errors/ExternalStarReexportError");
+const { UsageState } = require("../graph/ExportsInfo");
+const isDependencyKind = require("../graph/isDependencyKind");
 const JavascriptModulesPlugin = require("../javascript/JavascriptModulesPlugin");
-const ConcatenatedModule = require("../optimize/ConcatenatedModule");
-const { InlinedUsedName } = require("../optimize/InlineExports");
-const { toJsStringLiteral } = require("../util/identifier");
+const {
+	getMergedExports,
+	mergedEntryModules
+} = require("../javascript/MergedEntryExports");
+const { JAVASCRIPT_TYPE } = require("../module/ModuleSourceTypeConstants");
+const { isInlinedUsedName } = require("../optimize/InlineExports");
+const RuntimeGlobals = require("../runtime/RuntimeGlobals");
+const Template = require("../template/Template");
+const { someInIterable } = require("../util/IterableHelpers");
+const { renameIdentifiers } = require("../util/concatenate");
 const {
 	RESERVED_IDENTIFIER,
 	SAFE_IDENTIFIER,
 	propertyAccess
 } = require("../util/property");
-const { getEntryRuntime } = require("../util/runtime");
+const { getEntryRuntime, intersectRuntime } = require("../util/runtime");
 const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 
+/** @import ExternalModule from "../externals/ExternalModule" */
+/** @import { InlinedUsedName } from "../optimize/InlineExports" */
 /** @import { Source } from "webpack-sources" */
 /**
  * @import {
@@ -35,18 +38,17 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
  * 	LibraryExport
  * } from "../../declarations/WebpackOptions"
  */
-/** @import Chunk from "../Chunk" */
+/** @import CodeGenerationResults from "../module/CodeGenerationResults" */
 /** @import Compilation from "../Compilation" */
 /** @import Compiler from "../Compiler" */
-/** @import ModuleGraph from "../ModuleGraph" */
-/** @import Module from "../Module" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
+/** @import Module from "../module/Module" */
 /**
  * @import {
  * 	StartupRenderContext,
  * 	ModuleRenderContext
  * } from "../javascript/JavascriptModulesPlugin"
  */
-/** @import { ImportAttributes } from "../javascript/JavascriptParser" */
 /** @import { RuntimeSpec } from "../util/runtime" */
 /**
  * @import {
@@ -83,37 +85,19 @@ const PLUGIN_NAME = "ModuleLibraryPlugin";
 const libraryEntryModules = new WeakMap();
 
 /**
- * Whether every export the module defines is a binding the library can export
- * natively, so the definitions written into the exports object are read by nobody.
- * A re-export or a renamed import is not: `renderStartup` reads those back off the
- * object, and `treatAsCommonJs` hands the object out as the default export.
+ * Whether the library reads every export of the entry off its exports object, never
+ * binding one to a declaration of the inlined body, so no definition can be left out.
  * @param {Module} module the entry module
  * @param {ModuleGraph} moduleGraph the module graph
- * @returns {boolean} true when the definitions may be taken over
+ * @returns {boolean} true when the entry has no export the library exposes natively
  */
-const definesOnlyNativeExports = (module, moduleGraph) => {
+const noNativeExports = (module, moduleGraph) => {
 	const buildMeta = /** @type {JavascriptModuleBuildMeta} */ (module.buildMeta);
-	if (buildMeta && buildMeta.treatAsCommonJs) return false;
+	if (buildMeta && buildMeta.treatAsCommonJs) return true;
 	// A top-level `await` wraps the body in `__webpack_require__.a`, and the
 	// definitions read declarations inside that wrapper — re-emitting them after the
 	// module would put them out of scope.
-	if (moduleGraph.isAsync(module)) return false;
-	const topLevelDeclarations =
-		module.buildInfo && module.buildInfo.topLevelDeclarations;
-	if (!topLevelDeclarations) return false;
-	for (const dep of module.dependencies) {
-		// A re-export or an `export default` has no declaration of its own to bind to,
-		// so `renderStartup` reads its value back off the exports object.
-		if (
-			dep instanceof HarmonyExportImportedSpecifierDependency ||
-			dep instanceof HarmonyExportExpressionDependency
-		) {
-			return false;
-		}
-		if (!(dep instanceof HarmonyExportSpecifierDependency)) continue;
-		if (!topLevelDeclarations.has(dep.id)) return false;
-	}
-	return true;
+	return moduleGraph.isAsync(module);
 };
 
 /**
@@ -125,18 +109,6 @@ const definesOnlyNativeExports = (module, moduleGraph) => {
 const toExportName = (name) =>
 	SAFE_IDENTIFIER.test(name) ? name : JSON.stringify(name);
 
-/**
- * Renders the import attributes of a reexport in the syntax the author wrote,
- * since a legacy `assert` clause and a `with` clause are not interchangeable.
- * @param {ImportAttributes | undefined} attributes the import attributes
- * @returns {string} the attributes clause, empty when there are none
- */
-const toAttributesClause = (attributes) => {
-	if (!attributes) return "";
-	const { _isLegacyAssert: isLegacyAssert, ...values } = attributes;
-	return ` ${isLegacyAssert ? "assert" : "with"} ${JSON.stringify(values)}`;
-};
-
 /**
  * Whether the export name can also be used as the declared binding name.
  * @param {string} name export name
@@ -182,13 +154,9 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 					for (const dep of dependencies) {
 						const module = dep && moduleGraph.getModule(dep);
 						if (!module) continue;
-						const root =
-							module instanceof ConcatenatedModule ? module.rootModule : module;
+						const root = module.getRootModule();
 						if (!entries.has(root)) continue;
-						if (
-							root === module &&
-							!definesOnlyNativeExports(module, moduleGraph)
-						) {
+						if (root === module && noNativeExports(module, moduleGraph)) {
 							continue;
 						}
 						moduleGraph.getMeta(module).onDemandExports = true;
@@ -201,6 +169,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 			compilation.hooks.additionalChunkRuntimeRequirements.tap(
 				PLUGIN_NAME,
 				(chunk, set, { chunkGraph, codeGenerationResults }) => {
+					const { moduleGraph, runtimeTemplate } = compilation;
 					if (!set.has(RuntimeGlobals.definePropertyGetters)) return;
 					if (chunkGraph.getNumberOfEntryModules(chunk) !== 1) return;
 					if (
@@ -215,6 +184,48 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 					if (javascriptHooks.inlineInRuntimeBailout.isUsed()) return;
 
 					const [module] = chunkGraph.getChunkEntryModulesIterable(chunk);
+					if (chunk.hasRuntime()) {
+						// The startup inlines the entry only where nothing else loads with
+						// it: another chunk of the entrypoint delays the execution, and a
+						// module reading the entry needs it in the registry.
+						for (const [
+							,
+							entrypoint
+						] of chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)) {
+							if (entrypoint && entrypoint.chunks.some((c) => c !== chunk)) {
+								return;
+							}
+						}
+						if (
+							someInIterable(
+								moduleGraph.getIncomingConnectionsByOriginModule(module),
+								([originModule, connections]) =>
+									originModule &&
+									originModule !== module &&
+									connections.some((c) => c.isTargetActive(chunk.runtime)) &&
+									someInIterable(
+										chunkGraph.getModuleRuntimes(originModule),
+										(runtime) =>
+											intersectRuntime(runtime, chunk.runtime) !== undefined
+									)
+							)
+						) {
+							return;
+						}
+					} else if (
+						// A chunk whose runtime is elsewhere lifts its entry to the top
+						// level under the same conditions, and renders it into the module
+						// registry otherwise.
+						JavascriptModulesPlugin._getEsmEntryModuleToInline({
+							chunk,
+							chunkGraph,
+							moduleGraph,
+							runtimeTemplate,
+							codeGenerationResults
+						}) !== module
+					) {
+						return;
+					}
 					const codeGenResult = codeGenerationResults.get(
 						module,
 						chunk.runtime
@@ -243,45 +254,32 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 						}
 					}
 
-					// The helpers land in the runtime, not in this chunk, so what still
-					// needs them is asked of every chunk sharing the entrypoint — the
-					// runtime chunk, and whatever `splitChunks` moved out of the entry.
-					/** @type {Set<Chunk>} */
-					const siblings = new Set([chunk]);
-					for (const [
-						,
-						entrypoint
-					] of chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)) {
-						if (!entrypoint) continue;
-						for (const sibling of entrypoint.chunks) siblings.add(sibling);
-					}
-
+					// The entrypoint loads as this chunk alone, so what still needs the
+					// helpers is whatever else it holds beside the entry.
 					let otherNeedsDefine = false;
 					let otherNeedsNamespaceObject = false;
 					let otherNeedsExports = false;
 					let otherNeedsRequireScope = false;
-					outer: for (const sibling of siblings) {
-						for (const m of chunkGraph.getChunkModulesIterable(sibling)) {
-							if (m === module) continue;
-							const requirements = chunkGraph.getModuleRuntimeRequirements(
-								m,
-								sibling.runtime
-							);
-							if (!requirements) continue;
-							if (requirements.has(RuntimeGlobals.definePropertyGetters)) {
-								otherNeedsDefine = true;
-							}
-							if (requirements.has(RuntimeGlobals.makeNamespaceObject)) {
-								otherNeedsNamespaceObject = true;
-							}
-							if (requirements.has(RuntimeGlobals.exports)) {
-								otherNeedsExports = true;
-							}
-							if (requirements.has(RuntimeGlobals.requireScope)) {
-								otherNeedsRequireScope = true;
-							}
-							if (otherNeedsDefine) break outer;
+					for (const m of chunkGraph.getChunkModulesIterable(chunk)) {
+						if (m === module) continue;
+						const requirements = chunkGraph.getModuleRuntimeRequirements(
+							m,
+							chunk.runtime
+						);
+						if (!requirements) continue;
+						if (requirements.has(RuntimeGlobals.definePropertyGetters)) {
+							otherNeedsDefine = true;
+						}
+						if (requirements.has(RuntimeGlobals.makeNamespaceObject)) {
+							otherNeedsNamespaceObject = true;
+						}
+						if (requirements.has(RuntimeGlobals.exports)) {
+							otherNeedsExports = true;
+						}
+						if (requirements.has(RuntimeGlobals.requireScope)) {
+							otherNeedsRequireScope = true;
 						}
+						if (otherNeedsDefine) break;
 					}
 
 					if (otherNeedsDefine) return;
@@ -368,7 +366,8 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 
 				// Only handle star-reexport statement
 				if (
-					!(dep instanceof HarmonyExportImportedSpecifierDependency) ||
+					dep === null ||
+					!isDependencyKind(dep, "esm-reexport") ||
 					dep.name !== null
 				) {
 					continue;
@@ -382,7 +381,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 				) {
 					continue;
 				}
-				if (importedModule instanceof ExternalModule) {
+				if (importedModule.is("external")) {
 					const request = importedModule.getResolvedRequest();
 					if (Array.isArray(request) && request.length > 1) {
 						unsupportedExternals.add(importedModule);
@@ -426,6 +425,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 	 * @param {Module} module module
 	 * @param {ModuleGraph} moduleGraph moduleGraph
 	 * @param {RuntimeSpec} runtime chunk runtime
+	 * @param {CodeGenerationResults} codeGenerationResults the code generation results
 	 * @param {[string, string][]} exports exports
 	 * @param {Set<string>} alreadyRenderedExports already rendered exports
 	 * @returns {ConcatSource} source with null provided exports
@@ -435,6 +435,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		module,
 		moduleGraph,
 		runtime,
+		codeGenerationResults,
 		exports,
 		alreadyRenderedExports
 	) {
@@ -458,7 +459,8 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 
 				// Only handle star-reexport statement
 				if (
-					dep instanceof HarmonyExportImportedSpecifierDependency &&
+					dep !== null &&
+					isDependencyKind(dep, "esm-reexport") &&
 					dep.name === null
 				) {
 					const importedModule = connection.resolvedModule;
@@ -472,21 +474,15 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 						importedModuleExportsInfo._otherExportsInfo.provided === null
 					) {
 						// Handle export * from 'external'
-						if (importedModule instanceof ExternalModule) {
-							const request = importedModule.getResolvedRequest();
-							// A property path is reported by `_checkStarReexportedExternals`,
-							// and an absent one by the external's own build
-							const specifier =
-								typeof request === "string"
-									? request
-									: Array.isArray(request) && request.length === 1
-										? request[0]
-										: undefined;
-							if (specifier !== undefined) {
-								externalReexports.add(
-									`export * from ${toJsStringLiteral(specifier)}${toAttributesClause(dep.attributes)};\n`
-								);
-							}
+						if (importedModule.is("external")) {
+							const from = codeGenerationResults.has(importedModule, runtime)
+								? codeGenerationResults.getData(
+										importedModule,
+										runtime,
+										"externalReexport"
+									)
+								: undefined;
+							if (from) externalReexports.add(`export * ${from};\n`);
 						} else if (!visitedReexportModules.has(importedModule)) {
 							visitedReexportModules.add(importedModule);
 							resolveDynamicStarReexport(importedModule, true);
@@ -522,7 +518,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		for (const [origin, used] of unknownProvidedExports) {
 			exports.push([
 				origin,
-				used instanceof InlinedUsedName
+				isInlinedUsedName(used)
 					? used.render(
 							Template.toNormalComment(
 								`inlined export ${propertyAccess([origin])}`
@@ -547,12 +543,18 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		const {
 			moduleGraph,
 			chunk,
+			chunkGraph,
 			codeGenerationResults,
 			inlined,
 			inlinedInIIFE,
+			exportsAwaited,
 			runtimeTemplate
 		} = renderContext;
 		let result = new ConcatSource(source);
+		// A merged entry exposes what its modules expose together, so the ESM
+		// export list is theirs rather than the last module's alone.
+		const mergedModules = mergedEntryModules(chunk, chunkGraph, compilation);
+		const exportedModules = mergedModules || [module];
 		const exportInfos = options.export
 			? [
 					moduleGraph.getExportInfo(
@@ -560,15 +562,36 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 						Array.isArray(options.export) ? options.export[0] : options.export
 					)
 				]
-			: moduleGraph.getExportsInfo(module).orderedExports;
+			: mergedModules
+				? getMergedExports(
+						mergedModules,
+						moduleGraph,
+						chunk.runtime
+					).exports.map(({ name, module: from }) =>
+						moduleGraph.getExportInfo(from, name)
+					)
+				: moduleGraph.getExportsInfo(module).orderedExports;
 
 		const { data } = codeGenerationResults.get(module, chunk.runtime);
 
 		const isInlinedEntryWithoutIIFE = inlined && !inlinedInIIFE;
-		// Direct export bindings from on-demand concatenation
+		// The binding each export left out on demand reads, exported directly
 		/** @type {Record<string, string>} */
-		const definitions =
+		let definitions =
 			(isInlinedEntryWithoutIIFE && data && data.get("exportsFinalName")) || {};
+		// Inlined beside other modules, the entry's colliding declarations were renamed
+		const { renamedDeclarations } = renderContext;
+		if (renamedDeclarations) {
+			/** @type {Record<string, string>} */
+			const renamed = {};
+			for (const usedName of Object.keys(definitions)) {
+				renamed[usedName] = renameIdentifiers(
+					definitions[usedName],
+					renamedDeclarations
+				);
+			}
+			definitions = renamed;
+		}
 
 		/** @type {string[]} */
 		const shortHandedExports = [];
@@ -594,40 +617,17 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 			return name;
 		};
 
-		const isAsync = moduleGraph.isAsync(module);
-
-		const treatAsCommonJs =
-			module.buildMeta &&
-			/** @type {JavascriptModuleBuildMeta} */ (module.buildMeta)
-				.treatAsCommonJs;
-		const skipRenderDefaultExport = Boolean(treatAsCommonJs);
-
-		// A single inlined entry renders at the top level, so its declarations are
-		// bindings that can be exported directly, keeping ESM live bindings rather
-		// than snapshotting them into a `const`.
-		/** @type {Map<string, string> | undefined} */
-		let directBindings;
-		if (isInlinedEntryWithoutIIFE && !treatAsCommonJs) {
-			const topLevelDeclarations =
-				(data && data.get("topLevelDeclarations")) ||
-				(module.buildInfo && module.buildInfo.topLevelDeclarations);
-			if (topLevelDeclarations) {
-				for (const dep of module.dependencies) {
-					if (
-						dep instanceof HarmonyExportSpecifierDependency &&
-						topLevelDeclarations.has(dep.id)
-					) {
-						(directBindings || (directBindings = new Map())).set(
-							dep.name,
-							dep.id
-						);
-					}
-				}
-			}
-		}
+		// A merged entry is awaited in the bootstrap, so the object here is settled.
+		const isAsync = !mergedModules && moduleGraph.isAsync(module);
 
-		const bindingsTakenOver =
-			data !== undefined && data.has("exportsBindingSource");
+		// One ES module among the merged ones still provides a real `default`, and
+		// the synthetic one below would then be a second export of that name.
+		const treatAsCommonJs = exportedModules.every((m) =>
+			Boolean(
+				m.buildMeta &&
+				/** @type {JavascriptModuleBuildMeta} */ (m.buildMeta).treatAsCommonJs
+			)
+		);
 
 		const moduleExportsInfo = moduleGraph.getExportsInfo(module);
 
@@ -642,7 +642,8 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		let needExportsDeclaration =
 			!isInlinedEntryWithoutIIFE || isAsync || needHarmonyCompatibilityFlag;
 
-		if (isAsync) {
+		// The startup awaits the entry wherever top-level `await` reaches it.
+		if (isAsync && !exportsAwaited) {
 			result.add(
 				`${RuntimeGlobals.exports} = await ${RuntimeGlobals.exports};\n`
 			);
@@ -654,7 +655,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 
 			const originalName = exportInfo.name;
 			// Skip rendering the default export in some cases
-			if (skipRenderDefaultExport && originalName === "default") continue;
+			if (treatAsCommonJs && originalName === "default") continue;
 
 			// Try to find all exports from the reexported modules
 			const target = exportInfo.getTarget(moduleGraph);
@@ -674,7 +675,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 
 			if (
 				target &&
-				target.module instanceof ExternalModule &&
+				target.module.is("external") &&
 				target.export &&
 				target.export.length === 1 &&
 				codeGenerationResults.has(target.module, chunk.runtime)
@@ -685,7 +686,8 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 					"externalReexport"
 				);
 				if (reexport) {
-					if (!bindingsTakenOver) needExportsDeclaration = true;
+					// The getter stays in the body, written into the object
+					needExportsDeclaration = true;
 					result.add(
 						`export { ${toExportName(target.export[0])} as ${toExportName(originalName)} } ${reexport};\n`
 					);
@@ -694,28 +696,19 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 				}
 			}
 
-			// The exports of entry module are never inlined
-			const usedName =
-				/** @type {string} */
-				(exportInfo.getUsedName(originalName, chunk.runtime));
+			// The exports of entry module are never inlined, and a merged exports
+			// object is keyed by the original names rather than the mangled ones.
+			const usedName = mergedModules
+				? originalName
+				: /** @type {string} */
+					(exportInfo.getUsedName(originalName, chunk.runtime));
 			/** @type {string | undefined} */
 			const definition = definitions[usedName];
 			/** @type {string | undefined} */
-			const directLocal =
-				definition === undefined && directBindings
-					? directBindings.get(originalName)
-					: undefined;
-			/** @type {string | undefined} */
 			let finalName;
 
 			if (definition) {
 				finalName = definition;
-			} else if (directLocal !== undefined) {
-				// Live binding to the inlined entry's own top-level declaration
-				finalName = directLocal;
-				// The declaration is only there for the definitions written into it; with
-				// those taken over (and not re-emitted here) nothing reads the object.
-				if (!bindingsTakenOver) needExportsDeclaration = true;
 			} else {
 				// Fallback to `__webpack_exports__` property access
 				// when no direct export binding was found
@@ -778,6 +771,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 			module,
 			moduleGraph,
 			chunk.runtime,
+			codeGenerationResults,
 			exports,
 			alreadyRenderedExports
 		);

package/lib/library/SystemLibraryPlugin.js

@@ -6,12 +6,12 @@
 "use strict";
 
 const { ConcatSource } = require("webpack-sources");
-const { UsageState } = require("../ExportsInfo");
-const ExternalModule = require("../ExternalModule");
-const Template = require("../Template");
+const { UsageState } = require("../graph/ExportsInfo");
+const Template = require("../template/Template");
 const { propertyAccess } = require("../util/property");
 const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 
+/** @import ExternalModule from "../externals/ExternalModule" */
 /** @import { Source } from "webpack-sources" */
 /**
  * @import {
@@ -19,9 +19,9 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
  * 	LibraryType
  * } from "../../declarations/WebpackOptions"
  */
-/** @import Chunk from "../Chunk" */
+/** @import Chunk from "../graph/Chunk" */
 /** @import { ChunkHashContext } from "../Compilation" */
-/** @import { ExportInfoName } from "../Dependency" */
+/** @import { ExportInfoName } from "../graph/Dependency" */
 /** @import { RenderContext } from "../javascript/JavascriptModulesPlugin" */
 /** @import Hash from "../util/Hash" */
 /**
@@ -87,9 +87,7 @@ class SystemLibraryPlugin extends AbstractLibraryPlugin {
 	render(source, { chunkGraph, moduleGraph, chunk }, { options, compilation }) {
 		const modules = chunkGraph
 			.getChunkModules(chunk)
-			.filter(
-				(m) => m instanceof ExternalModule && m.externalType === "system"
-			);
+			.filter((m) => m.is("external") && m.externalType === "system");
 		const externals = /** @type {ExternalModule[]} */ (modules);
 
 		// The name this bundle should be registered as with System

package/lib/library/UmdLibraryPlugin.js

@@ -6,8 +6,7 @@
 "use strict";
 
 const { ConcatSource, OriginalSource } = require("webpack-sources");
-const ExternalModule = require("../ExternalModule");
-const Template = require("../Template");
+const Template = require("../template/Template");
 const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 
 /** @import { Source } from "webpack-sources" */
@@ -21,7 +20,7 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
  * } from "../../declarations/WebpackOptions"
  */
 /** @import { RenderContext } from "../javascript/JavascriptModulesPlugin" */
-/** @import { RequestRecord } from "../ExternalModule" */
+/** @import ExternalModule, { RequestRecord } from "../externals/ExternalModule" */
 
 /**
  * Defines the shared type used by this module.
@@ -164,7 +163,7 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 			.getChunkModules(chunk)
 			.filter(
 				(m) =>
-					m instanceof ExternalModule &&
+					m.is("external") &&
 					(m.externalType === "umd" || m.externalType === "umd2")
 			);
 		let externals = /** @type {ExternalModule[]} */ (modules);

package/lib/{dependencies → loaders}/LoaderDependency.js

@@ -5,10 +5,10 @@
 
 "use strict";
 
-const ModuleDependency = require("./ModuleDependency");
+const ModuleDependency = require("../dependencies/core/ModuleDependency");
 
-/** @import { GetConditionFn } from "../Dependency" */
-/** @import ModuleGraph from "../ModuleGraph" */
+/** @import { GetConditionFn } from "../graph/Dependency" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
 
 class LoaderDependency extends ModuleDependency {
 	/**

package/lib/{dependencies → loaders}/LoaderImportDependency.js

@@ -5,10 +5,10 @@
 
 "use strict";
 
-const ModuleDependency = require("./ModuleDependency");
+const ModuleDependency = require("../dependencies/core/ModuleDependency");
 
-/** @import { GetConditionFn } from "../Dependency" */
-/** @import ModuleGraph from "../ModuleGraph" */
+/** @import { GetConditionFn, DependencyKinds } from "../graph/Dependency" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
 
 class LoaderImportDependency extends ModuleDependency {
 	/**
@@ -39,4 +39,10 @@ class LoaderImportDependency extends ModuleDependency {
 	}
 }
 
+/** @type {Set<keyof DependencyKinds>} */
+LoaderImportDependency.KINDS = new Set([
+	...ModuleDependency.KINDS,
+	"loader-import"
+]);
+
 module.exports = LoaderImportDependency;