@depup/webpack 5.109.2-depup.0 → 5.110.3-depup.0

package/lib/optimize/ConstExportsPlugin.js

@@ -15,15 +15,19 @@ const { VariableInfoFlags } = require("../javascript/JavascriptParser");
 const {
 	InlinedUsedName,
 	enableInlineExports,
+	findModulesInCycles,
 	toInlinedValue
 } = require("./InlineExports");
 
-/** @typedef {import("./InlineExports").InlinedValue} InlinedValue */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../ExportsInfo")} ExportsInfo */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("../javascript/JavascriptModule").JavascriptModuleBuildInfo} JavascriptModuleBuildInfo */
-/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @import { InlinedValue } from "./InlineExports" */
+/** @import Compiler from "../Compiler" */
+/** @import ExportsInfo from "../ExportsInfo" */
+/** @import JavascriptParser from "../javascript/JavascriptParser" */
+/**
+ * @import {
+ * 	JavascriptModuleBuildInfo
+ * } from "../javascript/JavascriptModule"
+ */
 
 /** @typedef {{ inlineExports: boolean }} ConstValueParserPluginOptions */
 
@@ -159,11 +163,15 @@ class ConstExportsPlugin {
 
 				const moduleGraph = compilation.moduleGraph;
 				compilation.hooks.optimizeDependencies.tap(PLUGIN_NAME, (modules) => {
+					// A cycle peer may read an export during its temporal dead zone,
+					// where the binding must throw and a literal would answer.
+					const inCycle = findModulesInCycles(moduleGraph, modules);
 					/** @type {Set<ExportsInfo>} */
 					const visited = new Set();
 					/** @type {ExportsInfo[]} */
 					let queue = [];
 					for (const module of modules) {
+						if (inCycle.has(module)) continue;
 						queue.push(moduleGraph.getExportsInfo(module));
 					}
 					while (queue.length > 0) {
@@ -207,5 +215,6 @@ class ConstExportsPlugin {
 	}
 }
 
+ConstExportsPlugin.CONST_BINDING_TAG = CONST_BINDING_TAG;
+
 module.exports = ConstExportsPlugin;
-module.exports.CONST_BINDING_TAG = CONST_BINDING_TAG;

package/lib/optimize/EnsureChunkConditionsPlugin.js

@@ -7,9 +7,9 @@
 
 const { STAGE_BASIC } = require("../OptimizationStages");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../Compiler")} Compiler */
+/** @import Chunk from "../Chunk" */
+/** @import ChunkGroup from "../ChunkGroup" */
+/** @import Compiler from "../Compiler" */
 
 const PLUGIN_NAME = "EnsureChunkConditionsPlugin";
 

package/lib/optimize/FlagIncludedChunksPlugin.js

@@ -7,10 +7,9 @@
 
 const { compareIds } = require("../util/comparators");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Chunk").ChunkId} ChunkId */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
+/** @import Chunk, { ChunkId } from "../Chunk" */
+/** @import Compiler from "../Compiler" */
+/** @import Module from "../Module" */
 
 const PLUGIN_NAME = "FlagIncludedChunksPlugin";
 

package/lib/optimize/InlineExports.js

@@ -8,11 +8,15 @@
 const makeSerializable = require("../util/makeSerializable");
 const { propertyAccess } = require("../util/property");
 
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/**
+ * @import {
+ * 	ObjectDeserializerContext,
+ * 	ObjectSerializerContext
+ * } from "../serialization/ObjectMiddleware"
+ */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import Module from "../Module" */
+/** @import { RuntimeSpec } from "../util/runtime" */
 
 const MAX_INLINE_BYTES = 6;
 
@@ -168,10 +172,131 @@ const isExportInlined = (moduleGraph, module, ids, runtime) => {
 	return moduleGraph.getExportsInfo(module).hasInlinedUsedName(ids, runtime);
 };
 
+/**
+ * Collects, by an iterative Tarjan pass, the modules a cycle peer may read in
+ * their dead zone. A cycle of bare side-effect imports still inlines.
+ * @param {ModuleGraph} moduleGraph module graph
+ * @param {Iterable<Module>} modules all modules of the compilation
+ * @returns {Set<Module>} modules whose exports must not be inlined
+ */
+const findModulesInCycles = (moduleGraph, modules) => {
+	const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
+	const HarmonyImportSideEffectDependency = require("../dependencies/HarmonyImportSideEffectDependency");
+
+	/** @type {Set<Module>} */
+	const inCycle = new Set();
+	/** @type {[Module, Module][]} */
+	const bindingReads = [];
+	/** @type {Map<Module, number>} */
+	const componentOf = new Map();
+	let nextComponent = 0;
+	/** @type {Map<Module, number>} */
+	const index = new Map();
+	/** @type {Map<Module, number>} */
+	const low = new Map();
+	/** @type {Set<Module>} */
+	const onStack = new Set();
+	/** @type {Module[]} */
+	const componentStack = [];
+	let counter = 0;
+	/**
+	 * @param {Module} module the module
+	 * @returns {Module[]} modules it imports, self included when self-importing
+	 */
+	const targetsOf = (module) => {
+		const connections = moduleGraph.getOutgoingConnectionsByModule(module);
+		if (!connections) return [];
+		/** @type {Module[]} */
+		const targets = [];
+		for (const [target, moduleConnections] of connections) {
+			if (
+				!target ||
+				!moduleConnections.some(
+					(c) => c.dependency instanceof HarmonyImportDependency
+				)
+			) {
+				continue;
+			}
+			// Anything but a bare side-effect import may observe the binding.
+			if (
+				moduleConnections.some(
+					(c) =>
+						c.dependency instanceof HarmonyImportDependency &&
+						!(c.dependency instanceof HarmonyImportSideEffectDependency)
+				)
+			) {
+				bindingReads.push([module, target]);
+			}
+			targets.push(target);
+		}
+		return targets;
+	};
+	/** @type {{ node: Module, targets: Module[], i: number }[]} */
+	const work = [];
+	/**
+	 * @param {Module} node node to open
+	 */
+	const open = (node) => {
+		index.set(node, counter);
+		low.set(node, counter);
+		counter++;
+		componentStack.push(node);
+		onStack.add(node);
+		work.push({ node, targets: targetsOf(node), i: 0 });
+	};
+	for (const seed of modules) {
+		if (index.has(seed)) continue;
+		open(seed);
+		while (work.length > 0) {
+			const frame = work[work.length - 1];
+			if (frame.i < frame.targets.length) {
+				const next = frame.targets[frame.i++];
+				if (!index.has(next)) {
+					open(next);
+				} else if (onStack.has(next)) {
+					const nodeLow = /** @type {number} */ (low.get(frame.node));
+					const nextIndex = /** @type {number} */ (index.get(next));
+					if (nextIndex < nodeLow) low.set(frame.node, nextIndex);
+				}
+				continue;
+			}
+			work.pop();
+			const node = frame.node;
+			const nodeLow = /** @type {number} */ (low.get(node));
+			if (work.length > 0) {
+				const parent = work[work.length - 1].node;
+				if (nodeLow < /** @type {number} */ (low.get(parent))) {
+					low.set(parent, nodeLow);
+				}
+			}
+			if (nodeLow === index.get(node)) {
+				const id = nextComponent++;
+				let member;
+				do {
+					member = /** @type {Module} */ (componentStack.pop());
+					onStack.delete(member);
+					componentOf.set(member, id);
+				} while (member !== node);
+			}
+		}
+	}
+	// Reader and target evaluate together exactly when they share a component.
+	for (const [origin, target] of bindingReads) {
+		if (
+			origin === target ||
+			componentOf.get(origin) === componentOf.get(target)
+		) {
+			inCycle.add(target);
+		}
+	}
+	return inCycle;
+};
+
 module.exports.InlinedUsedName = InlinedUsedName;
 module.exports.InlinedValue = InlinedValue;
 module.exports.MAX_INLINE_BYTES = MAX_INLINE_BYTES;
 module.exports.enableInlineExports = enableInlineExports;
+module.exports.findModulesInCycles = findModulesInCycles;
 module.exports.isExportInlined = isExportInlined;
 module.exports.isInlineEnabled = isInlineEnabled;
 module.exports.isInlineExportsEnabled = isInlineExportsEnabled;

package/lib/optimize/InnerGraph.js

@@ -8,13 +8,12 @@
 const { UsageState } = require("../ExportsInfo");
 const JavascriptParser = require("../javascript/JavascriptParser");
 
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../Parser").ParserState} ParserState */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @import Compilation from "../Compilation" */
+/** @import Dependency, { GetConditionFn } from "../Dependency" */
+/** @import Module from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import { ParserState } from "../Parser" */
+/** @import { RuntimeSpec } from "../util/runtime" */
 
 /** @typedef {boolean | ((compilation: Compilation, module: Module) => boolean)} PureCondition */
 /** @typedef {Set<string | TopLevelSymbol>} InnerGraphValueSet */
@@ -135,6 +134,15 @@ function isDependencyUsedByExports(
 	return true;
 }
 
+/**
+ * One condition per module graph rather than per dependency. The dependency the
+ * condition was built for is always the one on the connection it is called with
+ * (`ModuleGraph#setResolvedModule` is the only caller of `getCondition`, and it
+ * pairs the two), so it can be read off the connection instead of captured.
+ * @type {WeakMap<ModuleGraph, GetConditionFn>}
+ */
+const usedByExportsConditions = new WeakMap();
+
 /**
  * Returns dependency condition
  * @param {Dependency} dependency the dependency
@@ -152,14 +160,22 @@ module.exports.getDependencyUsedByExportsCondition = (
 			return false;
 		case true:
 			return null;
-		default:
-			return (_connections, runtime) =>
-				isDependencyUsedByExports(
-					dependency,
-					/** @type {DependencyWithUsedByExports} */ (dependency).usedByExports,
+		default: {
+			const existing = usedByExportsConditions.get(moduleGraph);
+			if (existing !== undefined) return existing;
+			/** @type {GetConditionFn} */
+			const condition = (connection, runtime) => {
+				const dep = /** @type {Dependency} */ (connection.dependency);
+				return isDependencyUsedByExports(
+					dep,
+					/** @type {DependencyWithUsedByExports} */ (dep).usedByExports,
 					moduleGraph,
 					runtime
 				);
+			};
+			usedByExportsConditions.set(moduleGraph, condition);
+			return condition;
+		}
 	}
 };
 

package/lib/optimize/InnerGraphPlugin.js

@@ -17,24 +17,29 @@ const HarmonyImportSideEffectDependency = require("../dependencies/HarmonyImport
 const PureExpressionDependency = require("../dependencies/PureExpressionDependency");
 const { getInnerGraphUtils, topLevelSymbolTag } = require("./InnerGraph");
 
-/** @typedef {import("estree").CallExpression} CallExpression */
-/** @typedef {import("estree").ClassDeclaration} ClassDeclaration */
-/** @typedef {import("estree").ClassExpression} ClassExpression */
-/** @typedef {import("estree").Expression} Expression */
-/** @typedef {import("estree").MaybeNamedClassDeclaration} MaybeNamedClassDeclaration */
-/** @typedef {import("estree").MaybeNamedFunctionDeclaration} MaybeNamedFunctionDeclaration */
-/** @typedef {import("estree").Node} Node */
-/** @typedef {import("estree").VariableDeclarator} VariableDeclarator */
-/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("./InnerGraph").TopLevelSymbol} TopLevelSymbol */
+/**
+ * @import {
+ * 	CallExpression,
+ * 	ClassDeclaration,
+ * 	ClassExpression,
+ * 	Expression,
+ * 	MaybeNamedClassDeclaration,
+ * 	MaybeNamedFunctionDeclaration,
+ * 	Node,
+ * 	VariableDeclarator
+ * } from "estree"
+ */
+/**
+ * @import {
+ * 	JavascriptParserOptions
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import Compilation from "../Compilation" */
+/** @import Compiler from "../Compiler" */
+/** @import Dependency from "../Dependency" */
+/** @import Module from "../Module" */
+/** @import JavascriptParser, { Range } from "../javascript/JavascriptParser" */
+/** @import { TopLevelSymbol } from "./InnerGraph" */
 
 const PLUGIN_NAME = "InnerGraphPlugin";
 const impureVariableDeclarationKinds = new Set(["using", "await using"]);

package/lib/optimize/LimitChunkCountPlugin.js

@@ -9,9 +9,13 @@ const { STAGE_ADVANCED } = require("../OptimizationStages");
 const LazyBucketSortedSet = require("../util/LazyBucketSortedSet");
 const { compareChunks } = require("../util/comparators");
 
-/** @typedef {import("../../declarations/plugins/optimize/LimitChunkCountPlugin").LimitChunkCountPluginOptions} LimitChunkCountPluginOptions */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
+/**
+ * @import {
+ * 	LimitChunkCountPluginOptions
+ * } from "../../declarations/plugins/optimize/LimitChunkCountPlugin"
+ */
+/** @import Chunk from "../Chunk" */
+/** @import Compiler from "../Compiler" */
 
 /**
  * Defines the chunk combination type used by this module.

package/lib/optimize/MangleExportsPlugin.js

@@ -14,10 +14,9 @@ const {
 const { assignDeterministicIds } = require("../ids/IdHelpers");
 const { compareSelect, compareStringsNumeric } = require("../util/comparators");
 
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../ExportsInfo")} ExportsInfo */
-/** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
-/** @typedef {import("../util/concatenate").UsedNames} UsedNames */
+/** @import Compiler from "../Compiler" */
+/** @import ExportsInfo, { ExportInfo } from "../ExportsInfo" */
+/** @import { UsedNames } from "../util/concatenate" */
 
 /**
  * Defines the comparator type used by this module.
@@ -44,7 +43,7 @@ const canMangle = (exportsInfo) => {
 };
 
 // Sort by name
-/** @type {Comparator<ExportInfo>} */
+/** @type {Comparator<InstanceType<ExportInfo>>} */
 const comparator = compareSelect((e) => e.name, compareStringsNumeric);
 /**
  * Mangle exports info.
@@ -57,7 +56,7 @@ const mangleExportsInfo = (deterministic, exportsInfo, isNamespace) => {
 	if (!canMangle(exportsInfo)) return;
 	/** @type {UsedNames} */
 	const usedNames = new Set();
-	/** @type {ExportInfo[]} */
+	/** @type {InstanceType<ExportInfo>[]} */
 	const mangleableExports = [];
 
 	// Avoid to renamed exports that are not provided when
@@ -130,9 +129,9 @@ const mangleExportsInfo = (deterministic, exportsInfo, isNamespace) => {
 			usedNames.size
 		);
 	} else {
-		/** @type {ExportInfo[]} */
+		/** @type {InstanceType<ExportInfo>[]} */
 		const usedExports = [];
-		/** @type {ExportInfo[]} */
+		/** @type {InstanceType<ExportInfo>[]} */
 		const unusedExports = [];
 		for (const exportInfo of mangleableExports) {
 			if (exportInfo.getUsed(undefined) === UsageState.Unused) {

package/lib/optimize/MergeDuplicateChunksPlugin.js

@@ -8,9 +8,13 @@
 const { STAGE_BASIC } = require("../OptimizationStages");
 const { runtimeEqual } = require("../util/runtime");
 
-/** @typedef {import("../../declarations/plugins/optimize/MergeDuplicateChunksPlugin").MergeDuplicateChunksPluginOptions} MergeDuplicateChunksPluginOptions */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Chunk")} Chunk */
+/**
+ * @import {
+ * 	MergeDuplicateChunksPluginOptions
+ * } from "../../declarations/plugins/optimize/MergeDuplicateChunksPlugin"
+ */
+/** @import Compiler from "../Compiler" */
+/** @import Chunk from "../Chunk" */
 
 const PLUGIN_NAME = "MergeDuplicateChunksPlugin";
 

package/lib/optimize/MinChunkSizePlugin.js

@@ -7,9 +7,13 @@
 
 const { STAGE_ADVANCED } = require("../OptimizationStages");
 
-/** @typedef {import("../../declarations/plugins/optimize/MinChunkSizePlugin").MinChunkSizePluginOptions} MinChunkSizePluginOptions */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
+/**
+ * @import {
+ * 	MinChunkSizePluginOptions
+ * } from "../../declarations/plugins/optimize/MinChunkSizePlugin"
+ */
+/** @import Chunk from "../Chunk" */
+/** @import Compiler from "../Compiler" */
 
 const PLUGIN_NAME = "MinChunkSizePlugin";
 

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -12,10 +12,10 @@ const Module = require("../Module");
 const ModuleGraph = require("../ModuleGraph");
 const { JAVASCRIPT_TYPE } = require("../ModuleSourceTypeConstants");
 const { STAGE_DEFAULT } = require("../OptimizationStages");
-const CommonJsSelfReferenceDependency = require("../dependencies/CommonJsSelfReferenceDependency");
 const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
 const { ImportPhaseUtils } = require("../dependencies/ImportPhase");
 const { compareModulesByIdentifier } = require("../util/comparators");
+const { isCommonJsConcatenationEnabled } = require("../util/concatenate");
 const {
 	filterRuntime,
 	intersectRuntime,
@@ -25,13 +25,12 @@ const {
 } = require("../util/runtime");
 const ConcatenatedModule = require("./ConcatenatedModule");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module").BuildInfo} BuildInfo */
-/** @typedef {import("../Module").BuildMeta} BuildMeta */
-/** @typedef {import("../RequestShortener")} RequestShortener */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @import Chunk from "../Chunk" */
+/** @import Compilation from "../Compilation" */
+/** @import Compiler from "../Compiler" */
+/** @import { BuildInfo, BuildMeta } from "../Module" */
+/** @import RequestShortener from "../RequestShortener" */
+/** @import { RuntimeSpec } from "../util/runtime" */
 
 /** @typedef {Module | ((requestShortener: RequestShortener) => string)} Problem */
 
@@ -87,12 +86,19 @@ const cacheFailure = (failureCache, statistics, statKey, module, problem) => {
 	return problem;
 };
 
+// Read back by `performance.scopeHoistingBailouts` to tell these reasons apart
+// from the other kinds `getOptimizationBailout` collects.
+const BAILOUT_PREFIX = "ModuleConcatenation bailout: ";
+
+// A root's reason for rejecting another module, rather than the module's own.
+const REJECTED_PREFIX = "Cannot concat with ";
+
 /**
  * Format bailout reason.
  * @param {string} msg message
  * @returns {string} formatted message
  */
-const formatBailoutReason = (msg) => `ModuleConcatenation bailout: ${msg}`;
+const formatBailoutReason = (msg) => `${BAILOUT_PREFIX}${msg}`;
 
 const PLUGIN_NAME = "ModuleConcatenationPlugin";
 
@@ -160,7 +166,7 @@ class ModuleConcatenationPlugin {
 			const formatBailoutWarning = (module, problem) => (requestShortener) => {
 				if (typeof problem === "function") {
 					return formatBailoutReason(
-						`Cannot concat with ${module.readableIdentifier(
+						`${REJECTED_PREFIX}${module.readableIdentifier(
 							requestShortener
 						)}: ${problem(requestShortener)}`
 					);
@@ -169,13 +175,13 @@ class ModuleConcatenationPlugin {
 				const reasonWithPrefix = reason ? `: ${reason}` : "";
 				if (module === problem) {
 					return formatBailoutReason(
-						`Cannot concat with ${module.readableIdentifier(
+						`${REJECTED_PREFIX}${module.readableIdentifier(
 							requestShortener
 						)}${reasonWithPrefix}`
 					);
 				}
 				return formatBailoutReason(
-					`Cannot concat with ${module.readableIdentifier(
+					`${REJECTED_PREFIX}${module.readableIdentifier(
 						requestShortener
 					)} because of ${problem.readableIdentifier(
 						requestShortener
@@ -197,16 +203,14 @@ class ModuleConcatenationPlugin {
 					const relevantModules = [];
 					/** @type {Set<Module>} */
 					const possibleInners = new Set();
-					const concatenateModules =
-						compilation.options.optimization.concatenateModules;
+					// commonjs concatenation defaults to on; { commonjs: false } opts out
+					const concatenateCommonJsModules = isCommonJsConcatenationEnabled(
+						compilation.options.optimization.concatenateModules
+					);
 					const context = {
 						chunkGraph,
 						moduleGraph,
-						// commonjs concatenation defaults to on; { commonjs: false } opts out
-						concatenateCommonJsModules:
-							typeof concatenateModules === "object"
-								? concatenateModules.commonjs !== false
-								: concatenateModules === true
+						concatenateCommonJsModules
 					};
 					const deferEnabled = compilation.options.experiments.deferImport;
 					logger.time("select relevant modules");
@@ -531,7 +535,10 @@ class ModuleConcatenationPlugin {
 												c.originModule === m &&
 												!(
 													c.dependency &&
-													Dependency.canConcatenate(c.dependency) &&
+													Dependency.canConcatenate(
+														c.dependency,
+														concatenateCommonJsModules
+													) &&
 													modules.has(c.module)
 												)
 										);
@@ -575,7 +582,10 @@ class ModuleConcatenationPlugin {
 											c.module === rootModule ? c.originModule : c.module;
 										const innerConnection =
 											c.dependency &&
-											Dependency.canConcatenate(c.dependency) &&
+											Dependency.canConcatenate(
+												c.dependency,
+												concatenateCommonJsModules
+											) &&
 											modules.has(/** @type {Module} */ (otherModule));
 										return !innerConnection;
 									}
@@ -627,11 +637,14 @@ class ModuleConcatenationPlugin {
 	 */
 	_getImports(compilation, module, runtime) {
 		const moduleGraph = compilation.moduleGraph;
+		const concatenateCommonJsModules = isCommonJsConcatenationEnabled(
+			compilation.options.optimization.concatenateModules
+		);
 		/** @type {Set<Module>} */
 		const set = new Set();
 		for (const dep of module.dependencies) {
 			// Get reference info only for dependencies that support concatenation
-			if (!Dependency.canConcatenate(dep)) continue;
+			if (!Dependency.canConcatenate(dep, concatenateCommonJsModules)) continue;
 
 			const connection = moduleGraph.getConnection(dep);
 			// Reference is valid and has a module
@@ -821,7 +834,7 @@ class ModuleConcatenationPlugin {
 			}
 		}
 
-		/** @type {Map<Module, ReadonlyArray<ModuleGraph.ModuleGraphConnection>>} */
+		/** @type {Map<Module, ReadonlyArray<InstanceType<ModuleGraph.ModuleGraphConnection>>>} */
 		const incomingConnectionsFromModules = new Map();
 		for (const [originModule, connections] of incomingConnections) {
 			if (originModule) {
@@ -883,32 +896,32 @@ class ModuleConcatenationPlugin {
 			);
 		}
 
-		/** @type {Map<Module, ReadonlyArray<ModuleGraph.ModuleGraphConnection>>} */
-		const nonHarmonyConnections = new Map();
+		const concatenateCommonJsModules = isCommonJsConcatenationEnabled(
+			compilation.options.optimization.concatenateModules
+		);
+		/** @type {Map<Module, ReadonlyArray<InstanceType<ModuleGraph.ModuleGraphConnection>>>} */
+		const nonTargetConnections = new Map();
 		for (const [originModule, connections] of incomingConnectionsFromModules) {
 			const selected = connections.filter(
 				(connection) =>
 					!connection.dependency ||
-					(!Dependency.canConcatenate(connection.dependency) &&
-						// exports self-references of a concatenated CommonJS module
-						// are rewritten in place, so they don't block concatenation
-						!(
-							originModule === module &&
-							connection.dependency instanceof CommonJsSelfReferenceDependency
-						))
+					!Dependency.canConcatenate(
+						connection.dependency,
+						concatenateCommonJsModules
+					)
 			);
 			if (selected.length > 0) {
-				nonHarmonyConnections.set(originModule, connections);
+				nonTargetConnections.set(originModule, selected);
 			}
 		}
-		if (nonHarmonyConnections.size > 0) {
+		if (nonTargetConnections.size > 0) {
 			/**
 			 * Returns problem description.
 			 * @param {RequestShortener} requestShortener request shortener
 			 * @returns {string} problem description
 			 */
 			const problem = (requestShortener) => {
-				const names = [...nonHarmonyConnections]
+				const names = [...nonTargetConnections]
 					.map(
 						([originModule, connections]) =>
 							`${originModule.readableIdentifier(
@@ -1142,4 +1155,7 @@ class ConcatConfiguration {
 	}
 }
 
+ModuleConcatenationPlugin.BAILOUT_PREFIX = BAILOUT_PREFIX;
+ModuleConcatenationPlugin.REJECTED_PREFIX = REJECTED_PREFIX;
+
 module.exports = ModuleConcatenationPlugin;