webpack 5.106.2 → 5.107.0

package/lib/library/ModuleLibraryPlugin.js

@@ -11,6 +11,7 @@ const ExternalModule = require("../ExternalModule");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const HarmonyExportImportedSpecifierDependency = require("../dependencies/HarmonyExportImportedSpecifierDependency");
+const JavascriptModulesPlugin = require("../javascript/JavascriptModulesPlugin");
 const ConcatenatedModule = require("../optimize/ConcatenatedModule");
 const { propertyAccess } = require("../util/property");
 const { getEntryRuntime, getRuntimeKey } = require("../util/runtime");
@@ -80,6 +81,8 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			const { onDemandExportsGeneration } =
 				ConcatenatedModule.getCompilationHooks(compilation);
+			const javascriptHooks =
+				JavascriptModulesPlugin.getCompilationHooks(compilation);
 			onDemandExportsGeneration.tap(
 				PLUGIN_NAME,
 				(module, runtimes, source, finalName) => {
@@ -105,6 +108,77 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 					return true;
 				}
 			);
+
+			// `ModuleLibraryPlugin` stashes the on-demand exports source via
+			// `onDemandExportsGeneration` and only re-emits it when the
+			// module is wrapped in an IIFE/factory. When a single concatenated
+			// entry is inlined directly, the stashed source — and the
+			// `definePropertyGetters` / `requireScope` runtime helpers it
+			// pulled in — never make it into the output. Drop those helpers
+			// from the chunk's set in that simple shape so the bundle stays
+			// clean.
+			compilation.hooks.additionalChunkRuntimeRequirements.tap(
+				PLUGIN_NAME,
+				(chunk, set, { chunkGraph, codeGenerationResults }) => {
+					if (!set.has(RuntimeGlobals.definePropertyGetters)) return;
+
+					// Only handle the simple "single concatenated entry"
+					// shape. Anything else (additional modules, multiple
+					// entries, sibling runtime chunks, or chunk-level
+					// requirements that disable inline startup) forces the
+					// module through factory/IIFE rendering, which re-emits
+					// the source.
+					if (chunkGraph.getNumberOfChunkModules(chunk) !== 1) return;
+					if (chunkGraph.getNumberOfEntryModules(chunk) !== 1) return;
+					if (chunkGraph.hasChunkEntryDependentChunks(chunk)) return;
+					if (
+						set.has(RuntimeGlobals.moduleFactories) ||
+						set.has(RuntimeGlobals.moduleCache) ||
+						set.has(RuntimeGlobals.interceptModuleExecution) ||
+						set.has(RuntimeGlobals.module) ||
+						set.has(RuntimeGlobals.thisAsExports)
+					) {
+						return;
+					}
+					// Anyone tapping `inlineInRuntimeBailout` may force factory
+					// rendering at render time, so conservatively bail out.
+					if (javascriptHooks.inlineInRuntimeBailout.isUsed()) return;
+
+					const [module] = chunkGraph.getChunkEntryModulesIterable(chunk);
+					const exportsSourceByRuntime =
+						module.buildMeta && module.buildMeta.exportsSourceByRuntime;
+					if (
+						!exportsSourceByRuntime ||
+						!exportsSourceByRuntime.has(getRuntimeKey(chunk.runtime))
+					) {
+						return;
+					}
+					// If the generated source references any
+					// `__webpack_require__.<helper>` (the on-demand `.d(...)`
+					// is stashed, but `.r(__webpack_exports__)` from the ESM
+					// compat flag, namespace objects, deferred externals, ...
+					// stay in the result) the helpers and the require scope
+					// they live in are still needed. The dot in the substring
+					// avoids matching the bare `"__webpack_require__"` string
+					// literals that some test fixtures include.
+					const codeGenResult = codeGenerationResults.get(
+						module,
+						chunk.runtime
+					);
+					const jsSource =
+						codeGenResult && codeGenResult.sources.get("javascript");
+					if (
+						jsSource &&
+						String(jsSource.source()).includes(`${RuntimeGlobals.require}.`)
+					) {
+						return;
+					}
+
+					set.delete(RuntimeGlobals.definePropertyGetters);
+					set.delete(RuntimeGlobals.exports);
+					set.delete(RuntimeGlobals.requireScope);
+				}
+			);
 		});
 	}
 

package/lib/node/NodeEnvironmentPlugin.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const CachedInputFileSystem = require("enhanced-resolve").CachedInputFileSystem;
+const { CachedInputFileSystem } = require("enhanced-resolve");
 const fs = require("graceful-fs");
 const createConsoleLogger = require("../logging/createConsoleLogger");
 const NodeWatchFileSystem = require("./NodeWatchFileSystem");
@@ -50,9 +50,11 @@ class NodeEnvironmentPlugin {
 					appendOnly: infrastructureLogging.appendOnly,
 					stream:
 						/** @type {NodeJS.WritableStream} */
-						(infrastructureLogging.stream)
+						(infrastructureLogging.stream),
+					compiler
 				})
 		});
+		// @ts-expect-error need to fix on enhanced-resolve side
 		compiler.inputFileSystem = new CachedInputFileSystem(fs, 60000);
 		const inputFileSystem =
 			/** @type {InputFileSystem} */

package/lib/node/nodeConsole.js

@@ -7,9 +7,45 @@
 
 const util = require("util");
 const truncateArgs = require("../logging/truncateArgs");
+const memoize = require("../util/memoize");
 
+const getCli = memoize(() => require("../cli"));
+
+const ESC = "\u001B[";
+const CURSOR_UP = `${ESC}1A`;
+const CLEAR_LINE = `${ESC}2K\r`;
+
+/** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../config/defaults").InfrastructureLoggingNormalizedWithDefaults} InfrastructureLoggingNormalizedWithDefaults */
 /** @typedef {import("../logging/createConsoleLogger").LoggerConsole} LoggerConsole */
+/**
+ * @typedef {object} StatusMessageState
+ * @property {string[] | undefined} currentMessage current status message
+ * @property {number} currentLines current status message rows
+ */
+
+/** @type {WeakMap<Compiler, StatusMessageState>} */
+const logStatusStateByCompiler = new WeakMap();
+/** @type {Set<StatusMessageState>} */
+const logStatusStates = new Set();
+
+/**
+ * Returns status state
+ * @param {Compiler} compiler compiler
+ * @returns {StatusMessageState} status state
+ */
+const getLogStatusState = (compiler) => {
+	let state = logStatusStateByCompiler.get(compiler);
+	if (state === undefined) {
+		state = {
+			currentMessage: undefined,
+			currentLines: 0
+		};
+		logStatusStateByCompiler.set(compiler, state);
+		logStatusStates.add(state);
+	}
+	return state;
+};
 
 /* eslint-disable no-console */
 
@@ -19,12 +55,13 @@ const truncateArgs = require("../logging/truncateArgs");
  * @param {boolean=} options.colors colors
  * @param {boolean=} options.appendOnly append only
  * @param {InfrastructureLoggingNormalizedWithDefaults["stream"]} options.stream stream
+ * @param {Compiler} options.compiler compiler
  * @returns {LoggerConsole} logger function
  */
-module.exports = ({ colors, appendOnly, stream }) => {
-	/** @type {string[] | undefined} */
-	let currentStatusMessage;
-	let hasStatusMessage = false;
+module.exports = ({ colors, appendOnly, stream, compiler }) => {
+	const c = getCli().createColors({ useColor: Boolean(colors) });
+	const logStatusState = getLogStatusState(compiler);
+
 	let currentIndent = "";
 	let currentCollapsed = 0;
 
@@ -32,98 +69,113 @@ module.exports = ({ colors, appendOnly, stream }) => {
 	 * Returns indented string.
 	 * @param {string} str string
 	 * @param {string} prefix prefix
-	 * @param {string} colorPrefix color prefix
-	 * @param {string} colorSuffix color suffix
+	 * @param {(line: string) => string} colorFn color function
 	 * @returns {string} indented string
 	 */
-	const indent = (str, prefix, colorPrefix, colorSuffix) => {
+	const indent = (str, prefix, colorFn) => {
 		if (str === "") return str;
 		prefix = currentIndent + prefix;
-		if (colors) {
-			return (
-				prefix +
-				colorPrefix +
-				str.replace(/\n/g, `${colorSuffix}\n${prefix}${colorPrefix}`) +
-				colorSuffix
-			);
-		}
-
-		return prefix + str.replace(/\n/g, `\n${prefix}`);
+		return (
+			prefix +
+			str
+				.split("\n")
+				.map((line) => colorFn(line))
+				.join(`\n${prefix}`)
+		);
 	};
 
 	const clearStatusMessage = () => {
-		if (hasStatusMessage) {
-			stream.write("\u001B[2K\r");
-			hasStatusMessage = false;
+		let lines = 0;
+		for (const state of logStatusStates) {
+			if (state.currentLines) {
+				lines += state.currentLines;
+				state.currentLines = 0;
+			}
+		}
+		for (let i = 0; i < lines; i++) {
+			if (i > 0) stream.write(CURSOR_UP);
+			stream.write(CLEAR_LINE);
 		}
 	};
 
 	const writeStatusMessage = () => {
-		if (!currentStatusMessage) return;
-		const l = stream.columns || 40;
-		const args = truncateArgs(currentStatusMessage, l - 1);
-		const str = args.join(" ");
-		const coloredStr = `\u001B[1m${str}\u001B[39m\u001B[22m`;
-		stream.write(`\u001B[2K\r${coloredStr}`);
-		hasStatusMessage = true;
+		const column = stream.columns || 40;
+		/** @type {string[]} */
+		const all = [];
+
+		for (const state of logStatusStates) {
+			if (!state.currentMessage) continue;
+			/** @type {string[][]} */
+			const lines = [[]];
+			for (const item of state.currentMessage) {
+				const parts = item.split("\n");
+				lines[lines.length - 1].push(parts[0]);
+				for (let i = 1; i < parts.length; i++) {
+					lines.push([parts[i]]);
+				}
+			}
+			const truncateLines = lines.map((args) =>
+				truncateArgs(args, column - 1).join(" ")
+			);
+			state.currentLines = truncateLines.length;
+			for (const line of truncateLines) all.push(line);
+		}
+		if (all.length === 0) return;
+
+		const coloredLines = all.map((str) => c.bold(str));
+		stream.write(`${CLEAR_LINE}${coloredLines.join(`\n${CLEAR_LINE}`)}`);
+	};
+
+	/**
+	 * @param {EXPECTED_ANY[]} statusMessage status message
+	 * @returns {void}
+	 */
+	const setStatusMessage = (statusMessage) => {
+		clearStatusMessage();
+		logStatusState.currentMessage = statusMessage.map((item) => `${item}`);
+		writeStatusMessage();
 	};
 
 	/**
 	 * Returns function to write with colors.
 	 * @template T
 	 * @param {string} prefix prefix
-	 * @param {string} colorPrefix color prefix
-	 * @param {string} colorSuffix color suffix
+	 * @param {(line: string) => string} colorFn color function
 	 * @returns {(...args: T[]) => void} function to write with colors
 	 */
 	const writeColored =
-		(prefix, colorPrefix, colorSuffix) =>
+		(prefix, colorFn) =>
 		(...args) => {
 			if (currentCollapsed > 0) return;
 			clearStatusMessage();
-			const str = indent(
-				util.format(...args),
-				prefix,
-				colorPrefix,
-				colorSuffix
-			);
+			const str = indent(util.format(...args), prefix, colorFn);
 			stream.write(`${str}\n`);
 			writeStatusMessage();
 		};
 
 	/** @type {<T extends unknown[]>(...args: T) => void} */
-	const writeGroupMessage = writeColored(
-		"<-> ",
-		"\u001B[1m\u001B[36m",
-		"\u001B[39m\u001B[22m"
-	);
+	const writeGroupMessage = writeColored("<-> ", (str) => c.bold(c.cyan(str)));
 
 	/** @type {<T extends unknown[]>(...args: T) => void} */
-	const writeGroupCollapsedMessage = writeColored(
-		"<+> ",
-		"\u001B[1m\u001B[36m",
-		"\u001B[39m\u001B[22m"
+	const writeGroupCollapsedMessage = writeColored("<+> ", (str) =>
+		c.bold(c.cyan(str))
 	);
 
 	return {
 		/** @type {LoggerConsole["log"]} */
-		log: writeColored("    ", "\u001B[1m", "\u001B[22m"),
+		log: writeColored("    ", c.bold),
 		/** @type {LoggerConsole["debug"]} */
-		debug: writeColored("    ", "", ""),
+		debug: writeColored("    ", String),
 		/** @type {LoggerConsole["trace"]} */
-		trace: writeColored("    ", "", ""),
+		trace: writeColored("    ", String),
 		/** @type {LoggerConsole["info"]} */
-		info: writeColored("<i> ", "\u001B[1m\u001B[32m", "\u001B[39m\u001B[22m"),
+		info: writeColored("<i> ", (str) => c.bold(c.green(str))),
 		/** @type {LoggerConsole["warn"]} */
-		warn: writeColored("<w> ", "\u001B[1m\u001B[33m", "\u001B[39m\u001B[22m"),
+		warn: writeColored("<w> ", (str) => c.bold(c.yellow(str))),
 		/** @type {LoggerConsole["error"]} */
-		error: writeColored("<e> ", "\u001B[1m\u001B[31m", "\u001B[39m\u001B[22m"),
+		error: writeColored("<e> ", (str) => c.bold(c.red(str))),
 		/** @type {LoggerConsole["logTime"]} */
-		logTime: writeColored(
-			"<t> ",
-			"\u001B[1m\u001B[35m",
-			"\u001B[39m\u001B[22m"
-		),
+		logTime: writeColored("<t> ", (str) => c.bold(c.magenta(str))),
 		/** @type {LoggerConsole["group"]} */
 		group: (...args) => {
 			writeGroupMessage(...args);
@@ -164,24 +216,21 @@ module.exports = ({ colors, appendOnly, stream }) => {
 			),
 		/** @type {LoggerConsole["status"]} */
 		status: appendOnly
-			? writeColored("<s> ", "", "")
+			? writeColored("<s> ", String)
 			: (name, ...args) => {
 					args = args.filter(Boolean);
 					if (name === undefined && args.length === 0) {
 						clearStatusMessage();
-						currentStatusMessage = undefined;
+						logStatusState.currentMessage = undefined;
 					} else if (
 						typeof name === "string" &&
 						name.startsWith("[webpack.Progress] ")
 					) {
-						currentStatusMessage = [name.slice(19), ...args];
-						writeStatusMessage();
+						setStatusMessage([name.slice(19), ...args]);
 					} else if (name === "[webpack.Progress]") {
-						currentStatusMessage = [...args];
-						writeStatusMessage();
+						setStatusMessage([...args]);
 					} else {
-						currentStatusMessage = [name, ...args];
-						writeStatusMessage();
+						setStatusMessage([name, ...args]);
 					}
 				}
 	};

package/lib/optimize/ConcatenatedModule.js

@@ -14,6 +14,7 @@ const {
 	ReplaceSource
 } = require("webpack-sources");
 const ConcatenationScope = require("../ConcatenationScope");
+const Dependency = require("../Dependency");
 const { UsageState } = require("../ExportsInfo");
 const Module = require("../Module");
 const {
@@ -24,7 +25,6 @@ const { JAVASCRIPT_MODULE_TYPE_ESM } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const { DEFAULTS } = require("../config/defaults");
-const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
 const { ImportPhaseUtils } = require("../dependencies/ImportPhase");
 const JavascriptParser = require("../javascript/JavascriptParser");
 const {
@@ -55,15 +55,14 @@ const {
 	subtractRuntimeCondition
 } = require("../util/runtime");
 
-/** @typedef {import("eslint-scope").Reference} Reference */
-/** @typedef {import("eslint-scope").Scope} Scope */
-/** @typedef {import("eslint-scope").Variable} Variable */
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../dependencies/ModuleDependency")} ModuleDependency */
+/** @typedef {import("../dependencies/HarmonyImportDependency")} HarmonyImportDependency */
 /** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
 /** @typedef {import("../Module").BuildCallback} BuildCallback */
@@ -86,6 +85,9 @@ const {
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").Scope} Scope */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").Reference} Reference */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").Variable} Variable */
 /** @typedef {import("../javascript/JavascriptParser").Program} Program */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
@@ -362,6 +364,20 @@ const getFinalBinding = (
 				switch (exportName[0]) {
 					case "default":
 						exportName = exportName.slice(1);
+						if (deferred) {
+							// `ns.default` for a deferred default-with-named external
+							// module must read through the optimized `.a` getter
+							// (which lazily evaluates the module and returns its
+							// exports), not the proxy namespace itself — otherwise
+							// `typeof ns.default` / `ns.default instanceof X`
+							// observe the proxy instead of the actual default.
+							return {
+								info,
+								rawName: `${info.deferredName}.a`,
+								ids: exportName,
+								exportName
+							};
+						}
 						break;
 					case "__esModule":
 						return {
@@ -392,6 +408,18 @@ const getFinalBinding = (
 						exportName
 					};
 				}
+				if (deferred) {
+					// As with default-with-named above, `ns.default` for a
+					// deferred default-only external must read through the
+					// optimized `.a` getter so that `typeof` / `instanceof`
+					// observe the actual default value rather than the proxy.
+					return {
+						info,
+						rawName: `${info.deferredName}.a`,
+						ids: exportName,
+						exportName
+					};
+				}
 				break;
 			}
 			case "dynamic":
@@ -890,7 +918,7 @@ class ConcatenatedModule extends Module {
 			// populate dependencies
 			for (const d of m.dependencies.filter(
 				(dep) =>
-					!(dep instanceof HarmonyImportDependency) ||
+					!Dependency.canConcatenate(dep) ||
 					!this._modules.has(
 						/** @type {Module} */
 						(compilation.moduleGraph.getModule(dep))
@@ -898,6 +926,20 @@ class ConcatenatedModule extends Module {
 			)) {
 				this.dependencies.push(d);
 			}
+			// populate codeGenerationDependencies — the inner modules'
+			// templates are applied during ConcatenatedModule.codeGeneration,
+			// so the referenced modules must have been code-generated by then.
+			// Skip references that point back into the concat set itself.
+			if (m.codeGenerationDependencies !== undefined) {
+				for (const d of m.codeGenerationDependencies) {
+					const referenced =
+						/** @type {Module} */
+						(compilation.moduleGraph.getModule(d));
+					if (!this._modules.has(referenced)) {
+						this.addCodeGenerationDependency(d);
+					}
+				}
+			}
 			// populate blocks
 			for (const d of m.blocks) {
 				this.blocks.push(d);
@@ -1008,7 +1050,10 @@ class ConcatenatedModule extends Module {
 			 */
 			const references = connections
 				.filter((connection) => {
-					if (!(connection.dependency instanceof HarmonyImportDependency)) {
+					if (
+						!connection.dependency ||
+						!Dependency.canConcatenate(connection.dependency)
+					) {
 						return false;
 					}
 					if (

package/lib/optimize/InnerGraph.js

@@ -145,7 +145,7 @@ module.exports.getDependencyUsedByExportsCondition = (
 			/** @type {Module} */
 			(moduleGraph.getParentModule(dependency));
 		const exportsInfo = moduleGraph.getExportsInfo(selfModule);
-		return (connections, runtime) => {
+		return (_connections, runtime) => {
 			for (const exportName of usedByExports) {
 				if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused) {
 					return true;

package/lib/optimize/InnerGraphPlugin.js

@@ -9,6 +9,7 @@ const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_ESM
 } = require("../ModuleTypeConstants");
+const RuntimeGlobals = require("../RuntimeGlobals");
 const PureExpressionDependency = require("../dependencies/PureExpressionDependency");
 const InnerGraph = require("./InnerGraph");
 
@@ -29,6 +30,7 @@ const InnerGraph = require("./InnerGraph");
 const { topLevelSymbolTag } = InnerGraph;
 
 const PLUGIN_NAME = "InnerGraphPlugin";
+const impureVariableDeclarationKinds = new Set(["using", "await using"]);
 
 class InnerGraphPlugin {
 	/**
@@ -200,14 +202,22 @@ class InnerGraphPlugin {
 						}
 					});
 
-					parser.hooks.preDeclarator.tap(PLUGIN_NAME, (decl, _statement) => {
+					parser.hooks.preDeclarator.tap(PLUGIN_NAME, (decl, statement) => {
 						if (!InnerGraph.isEnabled(parser.state)) return;
+						if (impureVariableDeclarationKinds.has(statement.kind)) return;
 						if (
 							parser.scope.topLevelScope === true &&
 							decl.init &&
 							decl.id.type === "Identifier"
 						) {
 							const name = decl.id.name;
+							// Skip webpack runtime variables handled by CompatibilityPlugin
+							if (
+								name === RuntimeGlobals.require ||
+								name === RuntimeGlobals.exports
+							) {
+								return;
+							}
 							if (
 								decl.init.type === "ClassExpression" &&
 								parser.isPure(

package/lib/optimize/MinMaxSizeWarning.js

@@ -5,8 +5,8 @@
 
 "use strict";
 
-const SizeFormatHelpers = require("../SizeFormatHelpers");
-const WebpackError = require("../WebpackError");
+const WebpackError = require("../errors/WebpackError");
+const formatSize = require("../util/formatSize");
 
 class MinMaxSizeWarning extends WebpackError {
 	/**
@@ -26,8 +26,8 @@ class MinMaxSizeWarning extends WebpackError {
 		super(
 			"SplitChunksPlugin\n" +
 				`${keysMessage}\n` +
-				`Configured minSize (${SizeFormatHelpers.formatSize(minSize)}) is ` +
-				`bigger than maxSize (${SizeFormatHelpers.formatSize(maxSize)}).\n` +
+				`Configured minSize (${formatSize(minSize)}) is ` +
+				`bigger than maxSize (${formatSize(maxSize)}).\n` +
 				"This seem to be a invalid optimization.splitChunks configuration."
 		);
 	}

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -7,10 +7,11 @@
 
 const asyncLib = require("neo-async");
 const ChunkGraph = require("../ChunkGraph");
+const Dependency = require("../Dependency");
+const Module = require("../Module");
 const ModuleGraph = require("../ModuleGraph");
 const { JAVASCRIPT_TYPE } = require("../ModuleSourceTypeConstants");
 const { STAGE_DEFAULT } = require("../OptimizationStages");
-const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
 const { compareModulesByIdentifier } = require("../util/comparators");
 const {
 	filterRuntime,
@@ -23,7 +24,6 @@ const ConcatenatedModule = require("./ConcatenatedModule");
 
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").BuildInfo} BuildInfo */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
@@ -228,6 +228,12 @@ class ModuleConcatenationPlugin {
 							canBeRoot = false;
 						}
 
+						// TODO: ConcatenatedModule.getSourceTypes only javascript now
+						const basicTypes = Module.getSourceBasicTypes(module);
+						if (basicTypes.size !== 1 || !basicTypes.has(JAVASCRIPT_TYPE)) {
+							canBeRoot = false;
+						}
+
 						// Module must not be an entry point
 						if (chunkGraph.isEntryModule(module)) {
 							setInnerBailoutReason(module, "Module is an entry point");
@@ -460,7 +466,8 @@ class ModuleConcatenationPlugin {
 											(c) =>
 												c.originModule === m &&
 												!(
-													c.dependency instanceof HarmonyImportDependency &&
+													c.dependency &&
+													Dependency.canConcatenate(c.dependency) &&
 													modules.has(c.module)
 												)
 										);
@@ -503,7 +510,8 @@ class ModuleConcatenationPlugin {
 										const otherModule =
 											c.module === rootModule ? c.originModule : c.module;
 										const innerConnection =
-											c.dependency instanceof HarmonyImportDependency &&
+											c.dependency &&
+											Dependency.canConcatenate(c.dependency) &&
 											modules.has(/** @type {Module} */ (otherModule));
 										return !innerConnection;
 									}
@@ -538,8 +546,8 @@ class ModuleConcatenationPlugin {
 		/** @type {Set<Module>} */
 		const set = new Set();
 		for (const dep of module.dependencies) {
-			// Get reference info only for harmony Dependencies
-			if (!(dep instanceof HarmonyImportDependency)) continue;
+			// Get reference info only for dependencies that support concatenation
+			if (!Dependency.canConcatenate(dep)) continue;
 
 			const connection = moduleGraph.getConnection(dep);
 			// Reference is valid and has a module
@@ -757,7 +765,7 @@ class ModuleConcatenationPlugin {
 			const selected = connections.filter(
 				(connection) =>
 					!connection.dependency ||
-					!(connection.dependency instanceof HarmonyImportDependency)
+					!Dependency.canConcatenate(connection.dependency)
 			);
 			if (selected.length > 0) {
 				nonHarmonyConnections.set(originModule, connections);