webpack 5.59.0 → 5.94.0

package/lib/optimize/ConcatenatedModule.js

@@ -7,6 +7,7 @@
 
 const eslintScope = require("eslint-scope");
 const Referencer = require("eslint-scope/lib/referencer");
+const { SyncBailHook } = require("tapable");
 const {
 	CachedSource,
 	ConcatSource,
@@ -15,17 +16,20 @@ const {
 const ConcatenationScope = require("../ConcatenationScope");
 const { UsageState } = require("../ExportsInfo");
 const Module = require("../Module");
+const { JAVASCRIPT_MODULE_TYPE_ESM } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
 const JavascriptParser = require("../javascript/JavascriptParser");
 const { equals } = require("../util/ArrayHelpers");
 const LazySet = require("../util/LazySet");
-const { concatComparators, keepOriginalOrder } = require("../util/comparators");
+const { concatComparators } = require("../util/comparators");
 const createHash = require("../util/createHash");
 const { makePathsRelative } = require("../util/identifier");
 const makeSerializable = require("../util/makeSerializable");
+const { getAllReferences, getPathInAst } = require("../util/mergeScope");
 const propertyAccess = require("../util/propertyAccess");
+const { propertyName } = require("../util/propertyName");
 const {
 	filterRuntime,
 	intersectRuntime,
@@ -35,43 +39,63 @@ 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("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
-/** @template T @typedef {import("../InitFragment")<T>} InitFragment */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
+/** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../ModuleParseError")} ModuleParseError */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../WebpackError")} WebpackError */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
+/** @typedef {import("../javascript/JavascriptParser").Program} Program */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {typeof import("../util/Hash")} HashConstructor */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
+/**
+ * @template T
+ * @typedef {import("../InitFragment")<T>} InitFragment
+ */
+
+/**
+ * @template T
+ * @typedef {import("../util/comparators").Comparator<T>} Comparator
+ */
+
 // fix eslint-scope to support class properties correctly
 // cspell:word Referencer
-const ReferencerClass = Referencer;
+const ReferencerClass = /** @type {any} */ (Referencer);
 if (!ReferencerClass.prototype.PropertyDefinition) {
 	ReferencerClass.prototype.PropertyDefinition =
 		ReferencerClass.prototype.Property;
 }
 
 /**
- * @typedef {Object} ReexportInfo
+ * @typedef {object} ReexportInfo
  * @property {Module} module
  * @property {string[]} export
  */
@@ -79,7 +103,7 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
 /** @typedef {RawBinding | SymbolBinding} Binding */
 
 /**
- * @typedef {Object} RawBinding
+ * @typedef {object} RawBinding
  * @property {ModuleInfo} info
  * @property {string} rawName
  * @property {string=} comment
@@ -88,7 +112,7 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
  */
 
 /**
- * @typedef {Object} SymbolBinding
+ * @typedef {object} SymbolBinding
  * @property {ConcatenatedModuleInfo} info
  * @property {string} name
  * @property {string=} comment
@@ -100,52 +124,54 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
 /** @typedef {ConcatenatedModuleInfo | ExternalModuleInfo | ReferenceToModuleInfo } ModuleInfoOrReference */
 
 /**
- * @typedef {Object} ConcatenatedModuleInfo
+ * @typedef {object} ConcatenatedModuleInfo
  * @property {"concatenated"} type
  * @property {Module} module
  * @property {number} index
- * @property {Object} ast
- * @property {Source} internalSource
+ * @property {Program | undefined} ast
+ * @property {Source | undefined} internalSource
  * @property {ReplaceSource} source
  * @property {InitFragment<ChunkRenderContext>[]=} chunkInitFragments
- * @property {Iterable<string>} runtimeRequirements
- * @property {Scope} globalScope
- * @property {Scope} moduleScope
+ * @property {ReadOnlyRuntimeRequirements | undefined} runtimeRequirements
+ * @property {Scope | undefined} globalScope
+ * @property {Scope | undefined} moduleScope
  * @property {Map<string, string>} internalNames
- * @property {Map<string, string>} exportMap
- * @property {Map<string, string>} rawExportMap
+ * @property {Map<string, string> | undefined} exportMap
+ * @property {Map<string, string> | undefined} rawExportMap
  * @property {string=} namespaceExportSymbol
- * @property {string} namespaceObjectName
+ * @property {string | undefined} namespaceObjectName
  * @property {boolean} interopNamespaceObjectUsed
- * @property {string} interopNamespaceObjectName
+ * @property {string | undefined} interopNamespaceObjectName
  * @property {boolean} interopNamespaceObject2Used
- * @property {string} interopNamespaceObject2Name
+ * @property {string | undefined} interopNamespaceObject2Name
  * @property {boolean} interopDefaultAccessUsed
- * @property {string} interopDefaultAccessName
+ * @property {string | undefined} interopDefaultAccessName
  */
 
 /**
- * @typedef {Object} ExternalModuleInfo
+ * @typedef {object} ExternalModuleInfo
  * @property {"external"} type
  * @property {Module} module
  * @property {RuntimeSpec | boolean} runtimeCondition
  * @property {number} index
- * @property {string} name
+ * @property {string | undefined} name
  * @property {boolean} interopNamespaceObjectUsed
- * @property {string} interopNamespaceObjectName
+ * @property {string | undefined} interopNamespaceObjectName
  * @property {boolean} interopNamespaceObject2Used
- * @property {string} interopNamespaceObject2Name
+ * @property {string | undefined} interopNamespaceObject2Name
  * @property {boolean} interopDefaultAccessUsed
- * @property {string} interopDefaultAccessName
+ * @property {string | undefined} interopDefaultAccessName
  */
 
 /**
- * @typedef {Object} ReferenceToModuleInfo
+ * @typedef {object} ReferenceToModuleInfo
  * @property {"reference"} type
  * @property {RuntimeSpec | boolean} runtimeCondition
  * @property {ConcatenatedModuleInfo | ExternalModuleInfo} target
  */
 
+/** @typedef {Set<string>} UsedNames */
+
 const RESERVED_NAMES = new Set(
 	[
 		// internal names (should always be renamed)
@@ -184,24 +210,45 @@ const RESERVED_NAMES = new Set(
 		.split(",")
 );
 
-const bySourceOrder = (a, b) => {
-	const aOrder = a.sourceOrder;
-	const bOrder = b.sourceOrder;
-	if (isNaN(aOrder)) {
-		if (!isNaN(bOrder)) {
+/**
+ * @template T
+ * @param {string} property property
+ * @param {function(T[keyof T], T[keyof T]): 0 | 1 | -1} comparator comparator
+ * @returns {Comparator<T>} comparator
+ */
+const createComparator = (property, comparator) => (a, b) =>
+	comparator(
+		a[/** @type {keyof T} */ (property)],
+		b[/** @type {keyof T} */ (property)]
+	);
+
+/**
+ * @param {number} a a
+ * @param {number} b b
+ * @returns {0 | 1 | -1} result
+ */
+const compareNumbers = (a, b) => {
+	if (Number.isNaN(a)) {
+		if (!Number.isNaN(b)) {
 			return 1;
 		}
 	} else {
-		if (isNaN(bOrder)) {
+		if (Number.isNaN(b)) {
 			return -1;
 		}
-		if (aOrder !== bOrder) {
-			return aOrder < bOrder ? -1 : 1;
+		if (a !== b) {
+			return a < b ? -1 : 1;
 		}
 	}
 	return 0;
 };
+const bySourceOrder = createComparator("sourceOrder", compareNumbers);
+const byRangeStart = createComparator("rangeStart", compareNumbers);
 
+/**
+ * @param {Iterable<string>} iterable iterable object
+ * @returns {string} joined iterable object
+ */
 const joinIterableWithComma = iterable => {
 	// This is more performant than Array.from().join(", ")
 	// as it doesn't create an array
@@ -219,7 +266,7 @@ const joinIterableWithComma = iterable => {
 };
 
 /**
- * @typedef {Object} ConcatenationEntry
+ * @typedef {object} ConcatenationEntry
  * @property {"concatenated" | "external"} type
  * @property {Module} module
  * @property {RuntimeSpec | boolean} runtimeCondition
@@ -235,7 +282,7 @@ const joinIterableWithComma = iterable => {
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
  * @param {Set<ConcatenatedModuleInfo>} neededNamespaceObjects modules for which a namespace object should be generated
  * @param {boolean} asCall asCall
- * @param {boolean} strictHarmonyModule strictHarmonyModule
+ * @param {boolean | undefined} strictHarmonyModule strictHarmonyModule
  * @param {boolean | undefined} asiSafe asiSafe
  * @param {Set<ExportInfo>} alreadyVisited alreadyVisited
  * @returns {Binding} the final variable
@@ -264,7 +311,7 @@ const getFinalBinding = (
 				info.interopNamespaceObject2Used = true;
 				return {
 					info,
-					rawName: info.interopNamespaceObject2Name,
+					rawName: /** @type {string} */ (info.interopNamespaceObject2Name),
 					ids: exportName,
 					exportName
 				};
@@ -272,7 +319,7 @@ const getFinalBinding = (
 				info.interopNamespaceObjectUsed = true;
 				return {
 					info,
-					rawName: info.interopNamespaceObjectName,
+					rawName: /** @type {string} */ (info.interopNamespaceObjectName),
 					ids: exportName,
 					exportName
 				};
@@ -330,10 +377,10 @@ const getFinalBinding = (
 						const defaultExport = asCall
 							? `${info.interopDefaultAccessName}()`
 							: asiSafe
-							? `(${info.interopDefaultAccessName}())`
-							: asiSafe === false
-							? `;(${info.interopDefaultAccessName}())`
-							: `${info.interopDefaultAccessName}.a`;
+								? `(${info.interopDefaultAccessName}())`
+								: asiSafe === false
+									? `;(${info.interopDefaultAccessName}())`
+									: `${info.interopDefaultAccessName}.a`;
 						return {
 							info,
 							rawName: defaultExport,
@@ -360,12 +407,21 @@ const getFinalBinding = (
 				neededNamespaceObjects.add(info);
 				return {
 					info,
-					rawName: info.namespaceObjectName,
+					rawName:
+						/** @type {NonNullable<ConcatenatedModuleInfo["namespaceObjectName"]>} */
+						(info.namespaceObjectName),
 					ids: exportName,
 					exportName
 				};
 			case "external":
-				return { info, rawName: info.name, ids: exportName, exportName };
+				return {
+					info,
+					rawName:
+						/** @type {NonNullable<ExternalModuleInfo["name"]>} */
+						(info.name),
+					ids: exportName,
+					exportName
+				};
 		}
 	}
 	const exportsInfo = moduleGraph.getExportsInfo(info.module);
@@ -387,7 +443,7 @@ const getFinalBinding = (
 				neededNamespaceObjects.add(info);
 				return {
 					info,
-					rawName: info.namespaceObjectName,
+					rawName: /** @type {string} */ (info.namespaceObjectName),
 					ids: exportName,
 					exportName
 				};
@@ -439,7 +495,7 @@ const getFinalBinding = (
 				const refInfo = moduleToInfoMap.get(reexport.module);
 				return getFinalBinding(
 					moduleGraph,
-					refInfo,
+					/** @type {ModuleInfo} */ (refInfo),
 					reexport.export
 						? [...reexport.export, ...exportName.slice(1)]
 						: exportName.slice(1),
@@ -449,7 +505,8 @@ const getFinalBinding = (
 					runtimeTemplate,
 					neededNamespaceObjects,
 					asCall,
-					info.module.buildMeta.strictHarmonyModule,
+					/** @type {BuildMeta} */
+					(info.module.buildMeta).strictHarmonyModule,
 					asiSafe,
 					alreadyVisited
 				);
@@ -460,7 +517,7 @@ const getFinalBinding = (
 				);
 				return {
 					info,
-					rawName: info.namespaceObjectName,
+					rawName: /** @type {string} */ (info.namespaceObjectName),
 					ids: usedName,
 					exportName
 				};
@@ -502,8 +559,8 @@ const getFinalBinding = (
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
  * @param {Set<ConcatenatedModuleInfo>} neededNamespaceObjects modules for which a namespace object should be generated
  * @param {boolean} asCall asCall
- * @param {boolean} callContext callContext
- * @param {boolean} strictHarmonyModule strictHarmonyModule
+ * @param {boolean | undefined} callContext callContext
+ * @param {boolean | undefined} strictHarmonyModule strictHarmonyModule
  * @param {boolean | undefined} asiSafe asiSafe
  * @returns {string} the final name
  */
@@ -563,13 +620,19 @@ const getFinalName = (
 			return asiSafe
 				? `(0,${reference})`
 				: asiSafe === false
-				? `;(0,${reference})`
-				: `/*#__PURE__*/Object(${reference})`;
+					? `;(0,${reference})`
+					: `/*#__PURE__*/Object(${reference})`;
 		}
 		return reference;
 	}
 };
 
+/**
+ * @param {Scope | null} s scope
+ * @param {UsedNames} nameSet name set
+ * @param {TODO} scopeSet1 scope set 1
+ * @param {TODO} scopeSet2 scope set 2
+ */
 const addScopeSymbols = (s, nameSet, scopeSet1, scopeSet2) => {
 	let scope = s;
 	while (scope) {
@@ -583,71 +646,23 @@ const addScopeSymbols = (s, nameSet, scopeSet1, scopeSet2) => {
 	}
 };
 
-const getAllReferences = variable => {
-	let set = variable.references;
-	// Look for inner scope variables too (like in class Foo { t() { Foo } })
-	const identifiers = new Set(variable.identifiers);
-	for (const scope of variable.scope.childScopes) {
-		for (const innerVar of scope.variables) {
-			if (innerVar.identifiers.some(id => identifiers.has(id))) {
-				set = set.concat(innerVar.references);
-				break;
-			}
-		}
-	}
-	return set;
-};
-
-const getPathInAst = (ast, node) => {
-	if (ast === node) {
-		return [];
-	}
-
-	const nr = node.range;
-
-	const enterNode = n => {
-		if (!n) return undefined;
-		const r = n.range;
-		if (r) {
-			if (r[0] <= nr[0] && r[1] >= nr[1]) {
-				const path = getPathInAst(n, node);
-				if (path) {
-					path.push(n);
-					return path;
-				}
-			}
-		}
-		return undefined;
-	};
+const TYPES = new Set(["javascript"]);
 
-	if (Array.isArray(ast)) {
-		for (let i = 0; i < ast.length; i++) {
-			const enterResult = enterNode(ast[i]);
-			if (enterResult !== undefined) return enterResult;
-		}
-	} else if (ast && typeof ast === "object") {
-		const keys = Object.keys(ast);
-		for (let i = 0; i < keys.length; i++) {
-			const value = ast[keys[i]];
-			if (Array.isArray(value)) {
-				const pathResult = getPathInAst(value, node);
-				if (pathResult !== undefined) return pathResult;
-			} else if (value && typeof value === "object") {
-				const enterResult = enterNode(value);
-				if (enterResult !== undefined) return enterResult;
-			}
-		}
-	}
-};
+/**
+ * @typedef {object} ConcatenateModuleHooks
+ * @property {SyncBailHook<[Record<string, string>], boolean>} exportsDefinitions
+ */
 
-const TYPES = new Set(["javascript"]);
+/** @type {WeakMap<Compilation, ConcatenateModuleHooks>} */
+const compilationHooksMap = new WeakMap();
 
 class ConcatenatedModule extends Module {
 	/**
 	 * @param {Module} rootModule the root module of the concatenation
 	 * @param {Set<Module>} modules all modules in the concatenation (including the root module)
 	 * @param {RuntimeSpec} runtime the runtime
-	 * @param {Object=} associatedObjectForCache object for caching
+	 * @param {Compilation} compilation the compilation
+	 * @param {object=} associatedObjectForCache object for caching
 	 * @param {string | HashConstructor=} hashFunction hash function to use
 	 * @returns {ConcatenatedModule} the module
 	 */
@@ -655,6 +670,7 @@ class ConcatenatedModule extends Module {
 		rootModule,
 		modules,
 		runtime,
+		compilation,
 		associatedObjectForCache,
 		hashFunction = "md4"
 	) {
@@ -668,19 +684,36 @@ class ConcatenatedModule extends Module {
 			identifier,
 			rootModule,
 			modules,
-			runtime
+			runtime,
+			compilation
 		});
 	}
 
 	/**
-	 * @param {Object} options options
+	 * @param {Compilation} compilation the compilation
+	 * @returns {ConcatenateModuleHooks} the attached hooks
+	 */
+	static getCompilationHooks(compilation) {
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				exportsDefinitions: new SyncBailHook(["definitions"])
+			};
+			compilationHooksMap.set(compilation, hooks);
+		}
+		return hooks;
+	}
+
+	/**
+	 * @param {object} options options
 	 * @param {string} options.identifier the identifier of the module
 	 * @param {Module=} options.rootModule the root module of the concatenation
 	 * @param {RuntimeSpec} options.runtime the selected runtime
 	 * @param {Set<Module>=} options.modules all concatenated modules
+	 * @param {Compilation} options.compilation the compilation
 	 */
-	constructor({ identifier, rootModule, modules, runtime }) {
-		super("javascript/esm", null, rootModule && rootModule.layer);
+	constructor({ identifier, rootModule, modules, runtime, compilation }) {
+		super(JAVASCRIPT_MODULE_TYPE_ESM, null, rootModule && rootModule.layer);
 
 		// Info from Factory
 		/** @type {string} */
@@ -691,6 +724,8 @@ class ConcatenatedModule extends Module {
 		this._modules = modules;
 		this._runtime = runtime;
 		this.factoryMeta = rootModule && rootModule.factoryMeta;
+		/** @type {Compilation | undefined} */
+		this.compilation = compilation;
 	}
 
 	/**
@@ -705,7 +740,7 @@ class ConcatenatedModule extends Module {
 	}
 
 	/**
-	 * @returns {Set<string>} types available (do not mutate)
+	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
 		return TYPES;
@@ -727,10 +762,9 @@ class ConcatenatedModule extends Module {
 	 * @returns {string} a user readable identifier of the module
 	 */
 	readableIdentifier(requestShortener) {
-		return (
-			this.rootModule.readableIdentifier(requestShortener) +
-			` + ${this._modules.size - 1} modules`
-		);
+		return `${this.rootModule.readableIdentifier(
+			requestShortener
+		)} + ${this._modules.size - 1} modules`;
 	}
 
 	/**
@@ -766,11 +800,14 @@ class ConcatenatedModule extends Module {
 	 */
 	build(options, compilation, resolver, fs, callback) {
 		const { rootModule } = this;
+		const { moduleArgument, exportsArgument } =
+			/** @type {BuildInfo} */
+			(rootModule.buildInfo);
 		this.buildInfo = {
 			strict: true,
 			cacheable: true,
-			moduleArgument: rootModule.buildInfo.moduleArgument,
-			exportsArgument: rootModule.buildInfo.exportsArgument,
+			moduleArgument,
+			exportsArgument,
 			fileDependencies: new LazySet(),
 			contextDependencies: new LazySet(),
 			missingDependencies: new LazySet(),
@@ -783,7 +820,7 @@ class ConcatenatedModule extends Module {
 
 		for (const m of this._modules) {
 			// populate cacheable
-			if (!m.buildInfo.cacheable) {
+			if (!(/** @type {BuildInfo} */ (m.buildInfo).cacheable)) {
 				this.buildInfo.cacheable = false;
 			}
 
@@ -791,7 +828,9 @@ class ConcatenatedModule extends Module {
 			for (const d of m.dependencies.filter(
 				dep =>
 					!(dep instanceof HarmonyImportDependency) ||
-					!this._modules.has(compilation.moduleGraph.getModule(dep))
+					!this._modules.has(
+						/** @type {Module} */ (compilation.moduleGraph.getModule(dep))
+					)
 			)) {
 				this.dependencies.push(d);
 			}
@@ -816,15 +855,14 @@ class ConcatenatedModule extends Module {
 				}
 			}
 
+			const { assets, assetsInfo, topLevelDeclarations } =
+				/** @type {BuildInfo} */ (m.buildInfo);
+
 			// populate topLevelDeclarations
-			if (m.buildInfo.topLevelDeclarations) {
+			if (topLevelDeclarations) {
 				const topLevelDeclarations = this.buildInfo.topLevelDeclarations;
 				if (topLevelDeclarations !== undefined) {
-					for (const decl of m.buildInfo.topLevelDeclarations) {
-						// reserved names will always be renamed
-						if (RESERVED_NAMES.has(decl)) continue;
-						// TODO actually this is incorrect since with renaming there could be more
-						// We should do the renaming during build
+					for (const decl of topLevelDeclarations) {
 						topLevelDeclarations.add(decl);
 					}
 				}
@@ -833,17 +871,24 @@ class ConcatenatedModule extends Module {
 			}
 
 			// populate assets
-			if (m.buildInfo.assets) {
+			if (assets) {
 				if (this.buildInfo.assets === undefined) {
 					this.buildInfo.assets = Object.create(null);
 				}
-				Object.assign(this.buildInfo.assets, m.buildInfo.assets);
+				Object.assign(
+					/** @type {NonNullable<BuildInfo["assets"]>} */
+					(
+						/** @type {BuildInfo} */
+						(this.buildInfo).assets
+					),
+					assets
+				);
 			}
-			if (m.buildInfo.assetsInfo) {
+			if (assetsInfo) {
 				if (this.buildInfo.assetsInfo === undefined) {
 					this.buildInfo.assetsInfo = new Map();
 				}
-				for (const [key, value] of m.buildInfo.assetsInfo) {
+				for (const [key, value] of assetsInfo) {
 					this.buildInfo.assetsInfo.set(key, value);
 				}
 			}
@@ -883,11 +928,16 @@ class ConcatenatedModule extends Module {
 		 * @returns {Iterable<{ connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | true }>} imported modules in order
 		 */
 		const getConcatenatedImports = module => {
-			let connections = Array.from(moduleGraph.getOutgoingConnections(module));
+			const connections = Array.from(
+				moduleGraph.getOutgoingConnections(module)
+			);
 			if (module === rootModule) {
 				for (const c of moduleGraph.getOutgoingConnections(this))
 					connections.push(c);
 			}
+			/**
+			 * @type {Array<{ connection: ModuleGraphConnection, sourceOrder: number, rangeStart: number }>}
+			 */
 			const references = connections
 				.filter(connection => {
 					if (!(connection.dependency instanceof HarmonyImportDependency))
@@ -899,15 +949,33 @@ class ConcatenatedModule extends Module {
 						connection.isTargetActive(runtime)
 					);
 				})
-				.map(connection => ({
-					connection,
-					sourceOrder: /** @type {HarmonyImportDependency} */ (
+				.map(connection => {
+					const dep = /** @type {HarmonyImportDependency} */ (
 						connection.dependency
-					).sourceOrder
-				}));
-			references.sort(
-				concatComparators(bySourceOrder, keepOriginalOrder(references))
-			);
+					);
+					return {
+						connection,
+						sourceOrder: dep.sourceOrder,
+						rangeStart: dep.range && dep.range[0]
+					};
+				});
+			/**
+			 * bySourceOrder
+			 * @example
+			 * import a from "a"; // sourceOrder=1
+			 * import b from "b"; // sourceOrder=2
+			 *
+			 * byRangeStart
+			 * @example
+			 * import {a, b} from "a"; // sourceOrder=1
+			 * a.a(); // first range
+			 * b.b(); // second range
+			 *
+			 * If there is no reexport, we have the same source.
+			 * If there is reexport, but module has side effects, this will lead to reexport module only.
+			 * If there is side-effects-free reexport, we can get simple deterministic result with range start comparison.
+			 */
+			references.sort(concatComparators(bySourceOrder, byRangeStart));
 			/** @type {Map<Module, { connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | true }>} */
 			const referencesMap = new Map();
 			for (const { connection } of references) {
@@ -1022,7 +1090,7 @@ class ConcatenatedModule extends Module {
 	/**
 	 * @param {Module} rootModule the root module of the concatenation
 	 * @param {Set<Module>} modules all modules in the concatenation (including the root module)
-	 * @param {Object=} associatedObjectForCache object for caching
+	 * @param {object=} associatedObjectForCache object for caching
 	 * @param {string | HashConstructor=} hashFunction hash function to use
 	 * @returns {string} the identifier
 	 */
@@ -1033,17 +1101,17 @@ class ConcatenatedModule extends Module {
 		hashFunction = "md4"
 	) {
 		const cachedMakePathsRelative = makePathsRelative.bindContextCache(
-			rootModule.context,
+			/** @type {string} */ (rootModule.context),
 			associatedObjectForCache
 		);
-		let identifiers = [];
+		const identifiers = [];
 		for (const module of modules) {
 			identifiers.push(cachedMakePathsRelative(module.identifier()));
 		}
 		identifiers.sort();
 		const hash = createHash(hashFunction);
 		hash.update(identifiers.join(" "));
-		return rootModule.identifier() + "|" + hash.digest("hex");
+		return `${rootModule.identifier()}|${hash.digest("hex")}`;
 	}
 
 	/**
@@ -1077,7 +1145,8 @@ class ConcatenatedModule extends Module {
 		runtimeTemplate,
 		moduleGraph,
 		chunkGraph,
-		runtime: generationRuntime
+		runtime: generationRuntime,
+		codeGenerationResults
 	}) {
 		/** @type {Set<string>} */
 		const runtimeRequirements = new Set();
@@ -1104,20 +1173,23 @@ class ConcatenatedModule extends Module {
 				runtimeTemplate,
 				moduleGraph,
 				chunkGraph,
-				runtime
+				runtime,
+				codeGenerationResults
 			);
 		}
 
 		// List of all used names to avoid conflicts
 		const allUsedNames = new Set(RESERVED_NAMES);
+		// Updated Top level declarations are created by renaming
+		const topLevelDeclarations = new Set();
 
 		// List of additional names in scope for module references
-		/** @type {Map<string, { usedNames: Set<string>, alreadyCheckedScopes: Set<TODO> }>} */
+		/** @type {Map<string, { usedNames: UsedNames, alreadyCheckedScopes: Set<TODO> }>} */
 		const usedNamesInScopeInfo = new Map();
 		/**
 		 * @param {string} module module identifier
 		 * @param {string} id export id
-		 * @returns {{ usedNames: Set<string>, alreadyCheckedScopes: Set<TODO> }} info
+		 * @returns {{ usedNames: UsedNames, alreadyCheckedScopes: Set<TODO> }} info
 		 */
 		const getUsedNamesInScopeInfo = (module, id) => {
 			const key = `${module}-${id}`;
@@ -1147,6 +1219,10 @@ class ConcatenatedModule extends Module {
 				// We get ranges of all super class expressions to make
 				// renaming to work correctly
 				const superClassCache = new WeakMap();
+				/**
+				 * @param {Scope} scope scope
+				 * @returns {TODO} result
+				 */
 				const getSuperClassExpressions = scope => {
 					const cacheEntry = superClassCache.get(scope);
 					if (cacheEntry !== undefined) return cacheEntry;
@@ -1189,7 +1265,8 @@ class ConcatenatedModule extends Module {
 								runtimeTemplate,
 								neededNamespaceObjects,
 								false,
-								info.module.buildMeta.strictHarmonyModule,
+								/** @type {BuildMeta} */
+								(info.module.buildMeta).strictHarmonyModule,
 								true
 							);
 							if (!binding.ids) continue;
@@ -1200,8 +1277,10 @@ class ConcatenatedModule extends Module {
 								);
 							for (const expr of getSuperClassExpressions(reference.from)) {
 								if (
-									expr.range[0] <= reference.identifier.range[0] &&
-									expr.range[1] >= reference.identifier.range[1]
+									expr.range[0] <=
+										/** @type {Range} */ (reference.identifier.range)[0] &&
+									expr.range[1] >=
+										/** @type {Range} */ (reference.identifier.range)[1]
 								) {
 									for (const variable of expr.variables) {
 										usedNames.add(variable.name);
@@ -1254,13 +1333,18 @@ class ConcatenatedModule extends Module {
 							);
 							allUsedNames.add(newName);
 							info.internalNames.set(name, newName);
+							topLevelDeclarations.add(newName);
 							const source = info.source;
 							const allIdentifiers = new Set(
 								references.map(r => r.identifier).concat(variable.identifiers)
 							);
 							for (const identifier of allIdentifiers) {
-								const r = identifier.range;
-								const path = getPathInAst(info.ast, identifier);
+								const r = /** @type {Range} */ (identifier.range);
+								const path = getPathInAst(
+									/** @type {NonNullable<ConcatenatedModuleInfo["ast"]>} */
+									(info.ast),
+									identifier
+								);
 								if (path && path.length > 1) {
 									const maybeProperty =
 										path[1].type === "AssignmentPattern" &&
@@ -1280,6 +1364,7 @@ class ConcatenatedModule extends Module {
 						} else {
 							allUsedNames.add(name);
 							info.internalNames.set(name, name);
+							topLevelDeclarations.add(name);
 						}
 					}
 					let namespaceObjectName;
@@ -1296,7 +1381,10 @@ class ConcatenatedModule extends Module {
 						);
 						allUsedNames.add(namespaceObjectName);
 					}
-					info.namespaceObjectName = namespaceObjectName;
+					info.namespaceObjectName =
+						/** @type {string} */
+						(namespaceObjectName);
+					topLevelDeclarations.add(namespaceObjectName);
 					break;
 				}
 				case "external": {
@@ -1308,10 +1396,12 @@ class ConcatenatedModule extends Module {
 					);
 					allUsedNames.add(externalName);
 					info.name = externalName;
+					topLevelDeclarations.add(externalName);
 					break;
 				}
 			}
-			if (info.module.buildMeta.exportsType !== "namespace") {
+			const buildMeta = /** @type {BuildMeta} */ (info.module.buildMeta);
+			if (buildMeta.exportsType !== "namespace") {
 				const externalNameInterop = this.findNewName(
 					"namespaceObject",
 					allUsedNames,
@@ -1320,10 +1410,11 @@ class ConcatenatedModule extends Module {
 				);
 				allUsedNames.add(externalNameInterop);
 				info.interopNamespaceObjectName = externalNameInterop;
+				topLevelDeclarations.add(externalNameInterop);
 			}
 			if (
-				info.module.buildMeta.exportsType === "default" &&
-				info.module.buildMeta.defaultObject !== "redirect"
+				buildMeta.exportsType === "default" &&
+				buildMeta.defaultObject !== "redirect"
 			) {
 				const externalNameInterop = this.findNewName(
 					"namespaceObject2",
@@ -1333,11 +1424,9 @@ class ConcatenatedModule extends Module {
 				);
 				allUsedNames.add(externalNameInterop);
 				info.interopNamespaceObject2Name = externalNameInterop;
+				topLevelDeclarations.add(externalNameInterop);
 			}
-			if (
-				info.module.buildMeta.exportsType === "dynamic" ||
-				!info.module.buildMeta.exportsType
-			) {
+			if (buildMeta.exportsType === "dynamic" || !buildMeta.exportsType) {
 				const externalNameInterop = this.findNewName(
 					"default",
 					allUsedNames,
@@ -1346,13 +1435,15 @@ class ConcatenatedModule extends Module {
 				);
 				allUsedNames.add(externalNameInterop);
 				info.interopDefaultAccessName = externalNameInterop;
+				topLevelDeclarations.add(externalNameInterop);
 			}
 		}
 
 		// Find and replace references to modules
 		for (const info of moduleToInfoMap.values()) {
 			if (info.type === "concatenated") {
-				for (const reference of info.globalScope.through) {
+				const globalScope = /** @type {Scope} */ (info.globalScope);
+				for (const reference of globalScope.through) {
 					const name = reference.identifier.name;
 					const match = ConcatenationScope.matchModuleReference(name);
 					if (match) {
@@ -1370,10 +1461,11 @@ class ConcatenatedModule extends Module {
 							neededNamespaceObjects,
 							match.call,
 							!match.directImport,
-							info.module.buildMeta.strictHarmonyModule,
+							/** @type {BuildMeta} */
+							(info.module.buildMeta).strictHarmonyModule,
 							match.asiSafe
 						);
-						const r = reference.identifier.range;
+						const r = /** @type {Range} */ (reference.identifier.range);
 						const source = info.source;
 						// range is extended by 2 chars to cover the appended "._"
 						source.replace(r[0], r[1] + 1, finalName);
@@ -1393,8 +1485,12 @@ class ConcatenatedModule extends Module {
 		const rootInfo = /** @type {ConcatenatedModuleInfo} */ (
 			moduleToInfoMap.get(this.rootModule)
 		);
-		const strictHarmonyModule = rootInfo.module.buildMeta.strictHarmonyModule;
+		const strictHarmonyModule =
+			/** @type {BuildMeta} */
+			(rootInfo.module.buildMeta).strictHarmonyModule;
 		const exportsInfo = moduleGraph.getExportsInfo(rootInfo.module);
+		/** @type {Record<string, string>} */
+		const exportsFinalName = {};
 		for (const exportInfo of exportsInfo.orderedExports) {
 			const name = exportInfo.name;
 			if (exportInfo.provided === false) continue;
@@ -1419,12 +1515,15 @@ class ConcatenatedModule extends Module {
 						strictHarmonyModule,
 						true
 					);
+					exportsFinalName[used] = finalName;
 					return `/* ${
 						exportInfo.isReexport() ? "reexport" : "binding"
 					} */ ${finalName}`;
-				} catch (e) {
-					e.message += `\nwhile generating the root export '${name}' (used name: '${used}')`;
-					throw e;
+				} catch (err) {
+					/** @type {Error} */
+					(err).message +=
+						`\nwhile generating the root export '${name}' (used name: '${used}')`;
+					throw err;
 				}
 			});
 		}
@@ -1432,37 +1531,55 @@ class ConcatenatedModule extends Module {
 		const result = new ConcatSource();
 
 		// add harmony compatibility flag (must be first because of possible circular dependencies)
+		let shouldAddHarmonyFlag = false;
 		if (
 			moduleGraph.getExportsInfo(this).otherExportsInfo.getUsed(runtime) !==
 			UsageState.Unused
 		) {
-			result.add(`// ESM COMPAT FLAG\n`);
-			result.add(
-				runtimeTemplate.defineEsModuleFlagStatement({
-					exportsArgument: this.exportsArgument,
-					runtimeRequirements
-				})
-			);
+			shouldAddHarmonyFlag = true;
 		}
 
 		// define exports
 		if (exportsMap.size > 0) {
-			runtimeRequirements.add(RuntimeGlobals.exports);
-			runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+			const { exportsDefinitions } = ConcatenatedModule.getCompilationHooks(
+				/** @type {Compilation} */ (this.compilation)
+			);
+
 			const definitions = [];
 			for (const [key, value] of exportsMap) {
 				definitions.push(
-					`\n  ${JSON.stringify(key)}: ${runtimeTemplate.returningFunction(
+					`\n  ${propertyName(key)}: ${runtimeTemplate.returningFunction(
 						value(requestShortener)
 					)}`
 				);
 			}
-			result.add(`\n// EXPORTS\n`);
-			result.add(
-				`${RuntimeGlobals.definePropertyGetters}(${
-					this.exportsArgument
-				}, {${definitions.join(",")}\n});\n`
-			);
+			const shouldSkipRenderDefinitions =
+				exportsDefinitions.call(exportsFinalName);
+
+			if (!shouldSkipRenderDefinitions) {
+				runtimeRequirements.add(RuntimeGlobals.exports);
+				runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+
+				if (shouldAddHarmonyFlag) {
+					result.add("// ESM COMPAT FLAG\n");
+					result.add(
+						runtimeTemplate.defineEsModuleFlagStatement({
+							exportsArgument: this.exportsArgument,
+							runtimeRequirements
+						})
+					);
+				}
+
+				result.add("\n// EXPORTS\n");
+				result.add(
+					`${RuntimeGlobals.definePropertyGetters}(${
+						this.exportsArgument
+					}, {${definitions.join(",")}\n});\n`
+				);
+			} else {
+				/** @type {BuildMeta} */
+				(this.buildMeta).exportsFinalName = exportsFinalName;
+			}
 		}
 
 		// list unused exports
@@ -1493,13 +1610,14 @@ class ConcatenatedModule extends Module {
 						neededNamespaceObjects,
 						false,
 						undefined,
-						info.module.buildMeta.strictHarmonyModule,
+						/** @type {BuildMeta} */
+						(info.module.buildMeta).strictHarmonyModule,
 						true
 					);
 					nsObj.push(
-						`\n  ${JSON.stringify(
-							usedName
-						)}: ${runtimeTemplate.returningFunction(finalName)}`
+						`\n  ${propertyName(usedName)}: ${runtimeTemplate.returningFunction(
+							finalName
+						)}`
 					);
 				}
 			}
@@ -1508,7 +1626,7 @@ class ConcatenatedModule extends Module {
 				nsObj.length > 0
 					? `${RuntimeGlobals.definePropertyGetters}(${name}, {${nsObj.join(
 							","
-					  )}\n});\n`
+						)}\n});\n`
 					: "";
 			if (nsObj.length > 0)
 				runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
@@ -1578,7 +1696,7 @@ ${defineGetters}`
 						result.add(`if (${condition}) {\n`);
 					}
 					result.add(
-						`var ${info.name} = __webpack_require__(${JSON.stringify(
+						`var ${info.name} = ${RuntimeGlobals.require}(${JSON.stringify(
 							chunkGraph.getModuleId(info.module)
 						)});`
 					);
@@ -1615,6 +1733,7 @@ ${defineGetters}`
 		const data = new Map();
 		if (chunkInitFragments.length > 0)
 			data.set("chunkInitFragments", chunkInitFragments);
+		data.set("topLevelDeclarations", topLevelDeclarations);
 
 		/** @type {CodeGenerationResult} */
 		const resultEntry = {
@@ -1634,6 +1753,7 @@ ${defineGetters}`
 	 * @param {ModuleGraph} moduleGraph moduleGraph
 	 * @param {ChunkGraph} chunkGraph chunkGraph
 	 * @param {RuntimeSpec} runtime runtime
+	 * @param {CodeGenerationResults} codeGenerationResults codeGenerationResults
 	 */
 	_analyseModule(
 		modulesMap,
@@ -1642,7 +1762,8 @@ ${defineGetters}`
 		runtimeTemplate,
 		moduleGraph,
 		chunkGraph,
-		runtime
+		runtime,
+		codeGenerationResults
 	) {
 		if (info.type === "concatenated") {
 			const m = info.module;
@@ -1657,9 +1778,13 @@ ${defineGetters}`
 					moduleGraph,
 					chunkGraph,
 					runtime,
-					concatenationScope
+					concatenationScope,
+					codeGenerationResults,
+					sourceTypes: TYPES
 				});
-				const source = codeGenResult.sources.get("javascript");
+				const source = /** @type {Source} */ (
+					codeGenResult.sources.get("javascript")
+				);
 				const data = codeGenResult.data;
 				const chunkInitFragments = data && data.get("chunkInitFragments");
 				const code = source.source().toString();
@@ -1668,7 +1793,8 @@ ${defineGetters}`
 					ast = JavascriptParser._parse(code, {
 						sourceType: "module"
 					});
-				} catch (err) {
+				} catch (_err) {
+					const err = /** @type {TODO} */ (_err);
 					if (
 						err.loc &&
 						typeof err.loc === "object" &&
@@ -1676,11 +1802,9 @@ ${defineGetters}`
 					) {
 						const lineNumber = err.loc.line;
 						const lines = code.split("\n");
-						err.message +=
-							"\n| " +
-							lines
-								.slice(Math.max(0, lineNumber - 3), lineNumber + 2)
-								.join("\n| ");
+						err.message += `\n| ${lines
+							.slice(Math.max(0, lineNumber - 3), lineNumber + 2)
+							.join("\n| ")}`;
 					}
 					throw err;
 				}
@@ -1691,7 +1815,7 @@ ${defineGetters}`
 					ignoreEval: true,
 					impliedStrict: true
 				});
-				const globalScope = scopeManager.acquire(ast);
+				const globalScope = /** @type {Scope} */ (scopeManager.acquire(ast));
 				const moduleScope = globalScope.childScopes[0];
 				const resultSource = new ReplaceSource(source);
 				info.runtimeRequirements = codeGenResult.runtimeRequirements;
@@ -1702,7 +1826,9 @@ ${defineGetters}`
 				info.globalScope = globalScope;
 				info.moduleScope = moduleScope;
 			} catch (err) {
-				err.message += `\nwhile analysing module ${m.identifier()} for concatenation`;
+				/** @type {Error} */
+				(err).message +=
+					`\nwhile analyzing module ${m.identifier()} for concatenation`;
 				throw err;
 			}
 		}
@@ -1770,21 +1896,30 @@ ${defineGetters}`
 							`Unsupported concatenation entry type ${info.type}`
 						);
 				}
-				map.set(item.module, item);
-				return item;
-			} else {
-				/** @type {ReferenceToModuleInfo} */
-				const ref = {
-					type: "reference",
-					runtimeCondition: info.runtimeCondition,
-					target: item
-				};
-				return ref;
+				map.set(
+					/** @type {ModuleInfo} */ (item).module,
+					/** @type {ModuleInfo} */ (item)
+				);
+				return /** @type {ModuleInfo} */ (item);
 			}
+			/** @type {ReferenceToModuleInfo} */
+			const ref = {
+				type: "reference",
+				runtimeCondition: info.runtimeCondition,
+				target: item
+			};
+			return ref;
 		});
 		return [list, map];
 	}
 
+	/**
+	 * @param {string} oldName old name
+	 * @param {UsedNames} usedNamed1 used named 1
+	 * @param {UsedNames} usedNamed2 used named 2
+	 * @param {string} extraInfo extra info
+	 * @returns {string} found new name
+	 */
 	findNewName(oldName, usedNamed1, usedNamed2, extraInfo) {
 		let name = oldName;
 
@@ -1803,7 +1938,7 @@ ${defineGetters}`
 
 		const splittedInfo = extraInfo.split("/");
 		while (splittedInfo.length) {
-			name = splittedInfo.pop() + (name ? "_" + name : "");
+			name = splittedInfo.pop() + (name ? `_${name}` : "");
 			const nameIdent = Template.toIdentifier(name);
 			if (
 				!usedNamed1.has(nameIdent) &&
@@ -1816,6 +1951,7 @@ ${defineGetters}`
 		let nameWithNumber = Template.toIdentifier(`${name}_${i}`);
 		while (
 			usedNamed1.has(nameWithNumber) ||
+			// eslint-disable-next-line no-unmodified-loop-condition
 			(usedNamed2 && usedNamed2.has(nameWithNumber))
 		) {
 			i++;
@@ -1850,12 +1986,17 @@ ${defineGetters}`
 		super.updateHash(hash, context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {ConcatenatedModule} ConcatenatedModule
+	 */
 	static deserialize(context) {
 		const obj = new ConcatenatedModule({
 			identifier: undefined,
 			rootModule: undefined,
 			modules: undefined,
-			runtime: undefined
+			runtime: undefined,
+			compilation: undefined
 		});
 		obj.deserialize(context);
 		return obj;