webpack 5.64.3 → 5.67.0

package/lib/ids/SyncModuleIdsPlugin.js

@@ -0,0 +1,140 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { WebpackError } = require("..");
+const { getUsedModuleIdsAndModules } = require("./IdHelpers");
+
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+
+const plugin = "SyncModuleIdsPlugin";
+
+class SyncModuleIdsPlugin {
+	/**
+	 * @param {Object} options options
+	 * @param {string} options.path path to file
+	 * @param {string=} options.context context for module names
+	 * @param {function(Module): boolean} options.test selector for modules
+	 * @param {"read" | "create" | "merge" | "update"=} options.mode operation mode (defaults to merge)
+	 */
+	constructor({ path, context, test, mode }) {
+		this._path = path;
+		this._context = context;
+		this._test = test || (() => true);
+		const readAndWrite = !mode || mode === "merge" || mode === "update";
+		this._read = readAndWrite || mode === "read";
+		this._write = readAndWrite || mode === "create";
+		this._prune = mode === "update";
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		/** @type {Map<string, string | number>} */
+		let data;
+		let dataChanged = false;
+		if (this._read) {
+			compiler.hooks.readRecords.tapAsync(plugin, callback => {
+				const fs = compiler.intermediateFileSystem;
+				fs.readFile(this._path, (err, buffer) => {
+					if (err) {
+						if (err.code !== "ENOENT") {
+							return callback(err);
+						}
+						return callback();
+					}
+					const json = JSON.parse(buffer.toString());
+					data = new Map();
+					for (const key of Object.keys(json)) {
+						data.set(key, json[key]);
+					}
+					dataChanged = false;
+					return callback();
+				});
+			});
+		}
+		if (this._write) {
+			compiler.hooks.emitRecords.tapAsync(plugin, callback => {
+				if (!data || !dataChanged) return callback();
+				const json = {};
+				const sorted = Array.from(data).sort(([a], [b]) => (a < b ? -1 : 1));
+				for (const [key, value] of sorted) {
+					json[key] = value;
+				}
+				const fs = compiler.intermediateFileSystem;
+				fs.writeFile(this._path, JSON.stringify(json), callback);
+			});
+		}
+		compiler.hooks.thisCompilation.tap(plugin, compilation => {
+			const associatedObjectForCache = compiler.root;
+			const context = this._context || compiler.context;
+			if (this._read) {
+				compilation.hooks.reviveModules.tap(plugin, (_1, _2) => {
+					if (!data) return;
+					const { chunkGraph } = compilation;
+					const [usedIds, modules] = getUsedModuleIdsAndModules(
+						compilation,
+						this._test
+					);
+					for (const module of modules) {
+						const name = module.libIdent({
+							context,
+							associatedObjectForCache
+						});
+						if (!name) continue;
+						const id = data.get(name);
+						const idAsString = `${id}`;
+						if (usedIds.has(idAsString)) {
+							const err = new WebpackError(
+								`SyncModuleIdsPlugin: Unable to restore id '${id}' from '${this._path}' as it's already used.`
+							);
+							err.module = module;
+							compilation.errors.push(err);
+						}
+						chunkGraph.setModuleId(module, id);
+						usedIds.add(idAsString);
+					}
+				});
+			}
+			if (this._write) {
+				compilation.hooks.recordModules.tap(plugin, modules => {
+					const { chunkGraph } = compilation;
+					let oldData = data;
+					if (!oldData) {
+						oldData = data = new Map();
+					} else if (this._prune) {
+						data = new Map();
+					}
+					for (const module of modules) {
+						if (this._test(module)) {
+							const name = module.libIdent({
+								context,
+								associatedObjectForCache
+							});
+							if (!name) continue;
+							const id = chunkGraph.getModuleId(module);
+							if (id === null) continue;
+							const oldId = oldData.get(name);
+							if (oldId !== id) {
+								dataChanged = true;
+							} else if (data === oldData) {
+								continue;
+							}
+							data.set(name, id);
+						}
+					}
+					if (data.size !== oldData.size) dataChanged = true;
+				});
+			}
+		});
+	}
+}
+
+module.exports = SyncModuleIdsPlugin;

package/lib/index.js

@@ -19,6 +19,7 @@ const memoize = require("./util/memoize");
 /** @typedef {import("../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("../declarations/WebpackOptions").RuleSetUse} RuleSetUse */
 /** @typedef {import("../declarations/WebpackOptions").RuleSetUseItem} RuleSetUseItem */
+/** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptions} Configuration */
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptionsNormalized */
 /** @typedef {import("../declarations/WebpackOptions").WebpackPluginFunction} WebpackPluginFunction */
@@ -27,6 +28,8 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./Compilation").AssetInfo} AssetInfo */
 /** @typedef {import("./MultiStats")} MultiStats */
 /** @typedef {import("./Parser").ParserState} ParserState */
+/** @typedef {import("./ResolverFactory").ResolvePluginInstance} ResolvePluginInstance */
+/** @typedef {import("./ResolverFactory").Resolver} Resolver */
 /** @typedef {import("./Watching")} Watching */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsAsset} StatsAsset */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsChunk} StatsChunk */
@@ -561,6 +564,11 @@ module.exports = mergeExports(fn, {
 			get HttpUriPlugin() {
 				return require("./schemes/HttpUriPlugin");
 			}
+		},
+		ids: {
+			get SyncModuleIdsPlugin() {
+				return require("./ids/SyncModuleIdsPlugin");
+			}
 		}
 	}
 });

package/lib/javascript/ArrayPushCallbackChunkFormatPlugin.js

@@ -45,7 +45,7 @@ class ArrayPushCallbackChunkFormatPlugin {
 						const { chunk, chunkGraph, runtimeTemplate } = renderContext;
 						const hotUpdateChunk =
 							chunk instanceof HotUpdateChunk ? chunk : null;
-						const globalObject = runtimeTemplate.outputOptions.globalObject;
+						const globalObject = runtimeTemplate.globalObject;
 						const source = new ConcatSource();
 						const runtimeModules =
 							chunkGraph.getChunkRuntimeModulesInOrder(chunk);
@@ -138,7 +138,7 @@ class ArrayPushCallbackChunkFormatPlugin {
 					(chunk, hash, { chunkGraph, runtimeTemplate }) => {
 						if (chunk.hasRuntime()) return;
 						hash.update(
-							`ArrayPushCallbackChunkFormatPlugin1${runtimeTemplate.outputOptions.chunkLoadingGlobal}${runtimeTemplate.outputOptions.hotUpdateGlobal}${runtimeTemplate.outputOptions.globalObject}`
+							`ArrayPushCallbackChunkFormatPlugin1${runtimeTemplate.outputOptions.chunkLoadingGlobal}${runtimeTemplate.outputOptions.hotUpdateGlobal}${runtimeTemplate.globalObject}`
 						);
 						const entries = Array.from(
 							chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)

package/lib/javascript/ChunkHelpers.js

@@ -0,0 +1,33 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const Entrypoint = require("../Entrypoint");
+
+/** @typedef {import("../Chunk")} Chunk */
+
+/**
+ * @param {Entrypoint} entrypoint a chunk group
+ * @param {Chunk} excludedChunk1 current chunk which is excluded
+ * @param {Chunk} excludedChunk2 runtime chunk which is excluded
+ * @returns {Set<Chunk>} chunks
+ */
+const getAllChunks = (entrypoint, excludedChunk1, excludedChunk2) => {
+	const queue = new Set([entrypoint]);
+	const chunks = new Set();
+	for (const entrypoint of queue) {
+		for (const chunk of entrypoint.chunks) {
+			if (chunk === excludedChunk1) continue;
+			if (chunk === excludedChunk2) continue;
+			chunks.add(chunk);
+		}
+		for (const parent of entrypoint.parentsIterable) {
+			if (parent instanceof Entrypoint) queue.add(parent);
+		}
+	}
+	return chunks;
+};
+exports.getAllChunks = getAllChunks;

package/lib/javascript/JavascriptGenerator.js

@@ -199,6 +199,7 @@ class JavascriptGenerator extends Generator {
 			runtime: generateContext.runtime,
 			runtimeRequirements: generateContext.runtimeRequirements,
 			concatenationScope: generateContext.concatenationScope,
+			codeGenerationResults: generateContext.codeGenerationResults,
 			initFragments
 		};
 

package/lib/javascript/JavascriptParser.js

@@ -935,6 +935,13 @@ class JavascriptParser extends Parser {
 				.setString("undefined")
 				.setRange(expr.range);
 		});
+		this.hooks.evaluate.for("Identifier").tap("JavascriptParser", expr => {
+			if (/** @type {IdentifierNode} */ (expr).name === "undefined") {
+				return new BasicEvaluatedExpression()
+					.setUndefined()
+					.setRange(expr.range);
+			}
+		});
 		/**
 		 * @param {string} exprType expression type name
 		 * @param {function(ExpressionNode): GetInfoResult | undefined} getInfo get info
@@ -1189,14 +1196,15 @@ class JavascriptParser extends Parser {
 				const node = /** @type {TaggedTemplateExpressionNode} */ (_node);
 				const tag = this.evaluateExpression(node.tag);
 
-				if (tag.isIdentifier() && tag.identifier !== "String.raw") return;
-				const { quasis, parts } = getSimplifiedTemplateResult(
-					"raw",
-					node.quasi
-				);
-				return new BasicEvaluatedExpression()
-					.setTemplateString(quasis, parts, "raw")
-					.setRange(node.range);
+				if (tag.isIdentifier() && tag.identifier === "String.raw") {
+					const { quasis, parts } = getSimplifiedTemplateResult(
+						"raw",
+						node.quasi
+					);
+					return new BasicEvaluatedExpression()
+						.setTemplateString(quasis, parts, "raw")
+						.setRange(node.range);
+				}
 			});
 
 		this.hooks.evaluateCallExpressionMember

package/lib/javascript/StartupHelpers.js

@@ -5,11 +5,10 @@
 
 "use strict";
 
-const Entrypoint = require("../Entrypoint");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const { isSubset } = require("../util/SetHelpers");
-const { chunkHasJs } = require("./JavascriptModulesPlugin");
+const { getAllChunks } = require("./ChunkHelpers");
 
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../Chunk")} Chunk */
@@ -19,30 +18,6 @@ const { chunkHasJs } = require("./JavascriptModulesPlugin");
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {(string|number)[]} EntryItem */
 
-// TODO move to this file to ../javascript/ChunkHelpers.js
-
-/**
- * @param {Entrypoint} entrypoint a chunk group
- * @param {Chunk} excludedChunk1 current chunk which is excluded
- * @param {Chunk} excludedChunk2 runtime chunk which is excluded
- * @returns {Set<Chunk>} chunks
- */
-const getAllChunks = (entrypoint, excludedChunk1, excludedChunk2) => {
-	const queue = new Set([entrypoint]);
-	const chunks = new Set();
-	for (const entrypoint of queue) {
-		for (const chunk of entrypoint.chunks) {
-			if (chunk === excludedChunk1) continue;
-			if (chunk === excludedChunk2) continue;
-			chunks.add(chunk);
-		}
-		for (const parent of entrypoint.parentsIterable) {
-			if (parent instanceof Entrypoint) queue.add(parent);
-		}
-	}
-	return chunks;
-};
-
 const EXPORT_PREFIX = "var __webpack_exports__ = ";
 
 /**
@@ -143,12 +118,13 @@ exports.updateHashForEntryStartup = (hash, chunkGraph, entries, chunk) => {
 /**
  * @param {Chunk} chunk the chunk
  * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {function(Chunk, ChunkGraph): boolean} filterFn filter function
  * @returns {Set<number | string>} initially fulfilled chunk ids
  */
-exports.getInitialChunkIds = (chunk, chunkGraph) => {
+exports.getInitialChunkIds = (chunk, chunkGraph, filterFn) => {
 	const initialChunkIds = new Set(chunk.ids);
 	for (const c of chunk.getAllInitialChunks()) {
-		if (c === chunk || chunkHasJs(c, chunkGraph)) continue;
+		if (c === chunk || filterFn(c, chunkGraph)) continue;
 		for (const id of c.ids) initialChunkIds.add(id);
 	}
 	return initialChunkIds;

package/lib/library/AssignLibraryPlugin.js

@@ -92,7 +92,7 @@ const accessWithInit = (accessor, existingLength, initLast = false) => {
  * @property {LibraryType} type
  * @property {string[] | "global"} prefix name prefix
  * @property {string | false} declare declare name as variable
- * @property {"error"|"copy"|"assign"} unnamed behavior for unnamed library name
+ * @property {"error"|"static"|"copy"|"assign"} unnamed behavior for unnamed library name
  * @property {"copy"|"assign"=} named behavior for named library name
  */
 
@@ -174,7 +174,7 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 
 	_getPrefix(compilation) {
 		return this.prefix === "global"
-			? [compilation.outputOptions.globalObject]
+			? [compilation.runtimeTemplate.globalObject]
 			: this.prefix;
 	}
 
@@ -261,19 +261,42 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 	 * @param {LibraryContext<T>} libraryContext context
 	 * @returns {Source} source with library export
 	 */
-	renderStartup(source, module, { chunk }, { options, compilation }) {
+	renderStartup(
+		source,
+		module,
+		{ moduleGraph, chunk },
+		{ options, compilation }
+	) {
 		const fullNameResolved = this._getResolvedFullName(
 			options,
 			chunk,
 			compilation
 		);
+		const staticExports = this.unnamed === "static";
 		const exportAccess = options.export
 			? propertyAccess(
 					Array.isArray(options.export) ? options.export : [options.export]
 			  )
 			: "";
 		const result = new ConcatSource(source);
-		if (options.name ? this.named === "copy" : this.unnamed === "copy") {
+		if (staticExports) {
+			const exportsInfo = moduleGraph.getExportsInfo(module);
+			const exportTarget = accessWithInit(
+				fullNameResolved,
+				this._getPrefix(compilation).length,
+				true
+			);
+			for (const exportInfo of exportsInfo.orderedExports) {
+				if (!exportInfo.provided) continue;
+				const nameAccess = propertyAccess([exportInfo.name]);
+				result.add(
+					`${exportTarget}${nameAccess} = __webpack_exports__${exportAccess}${nameAccess};\n`
+				);
+			}
+			result.add(
+				`Object.defineProperty(${exportTarget}, "__esModule", { value: true });\n`
+			);
+		} else if (options.name ? this.named === "copy" : this.unnamed === "copy") {
 			result.add(
 				`var __webpack_export_target__ = ${accessWithInit(
 					fullNameResolved,
@@ -325,15 +348,10 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 	 */
 	chunkHash(chunk, hash, chunkHashContext, { options, compilation }) {
 		hash.update("AssignLibraryPlugin");
-		const prefix =
-			this.prefix === "global"
-				? [compilation.outputOptions.globalObject]
-				: this.prefix;
-		const fullName = options.name ? prefix.concat(options.name) : prefix;
-		const fullNameResolved = fullName.map(n =>
-			compilation.getPath(n, {
-				chunk
-			})
+		const fullNameResolved = this._getResolvedFullName(
+			options,
+			chunk,
+			compilation
 		);
 		if (options.name ? this.named === "copy" : this.unnamed === "copy") {
 			hash.update("copy");

package/lib/library/EnableLibraryPlugin.js

@@ -167,6 +167,17 @@ class EnableLibraryPlugin {
 					}).apply(compiler);
 					break;
 				}
+				case "commonjs-static": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const AssignLibraryPlugin = require("./AssignLibraryPlugin");
+					new AssignLibraryPlugin({
+						type,
+						prefix: ["exports"],
+						declare: false,
+						unnamed: "static"
+					}).apply(compiler);
+					break;
+				}
 				case "commonjs2":
 				case "commonjs-module": {
 					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697

package/lib/node/NodeWatchFileSystem.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const util = require("util");
 const Watchpack = require("watchpack");
 
 /** @typedef {import("../../declarations/WebpackOptions").WatchOptions} WatchOptions */
@@ -68,7 +69,22 @@ class NodeWatchFileSystem {
 		if (callbackUndelayed) {
 			this.watcher.once("change", callbackUndelayed);
 		}
+
+		const fetchTimeInfo = () => {
+			const fileTimeInfoEntries = new Map();
+			const contextTimeInfoEntries = new Map();
+			if (this.watcher) {
+				this.watcher.collectTimeInfoEntries(
+					fileTimeInfoEntries,
+					contextTimeInfoEntries
+				);
+			}
+			return { fileTimeInfoEntries, contextTimeInfoEntries };
+		};
 		this.watcher.once("aggregated", (changes, removals) => {
+			// pause emitting events (avoids clearing aggregated changes and removals on timeout)
+			this.watcher.pause();
+
 			if (this.inputFileSystem && this.inputFileSystem.purge) {
 				const fs = this.inputFileSystem;
 				for (const item of changes) {
@@ -78,8 +94,14 @@ class NodeWatchFileSystem {
 					fs.purge(item);
 				}
 			}
-			const times = this.watcher.getTimeInfoEntries();
-			callback(null, times, times, changes, removals);
+			const { fileTimeInfoEntries, contextTimeInfoEntries } = fetchTimeInfo();
+			callback(
+				null,
+				fileTimeInfoEntries,
+				contextTimeInfoEntries,
+				changes,
+				removals
+			);
 		});
 
 		this.watcher.watch({ files, directories, missing, startTime });
@@ -99,39 +121,71 @@ class NodeWatchFileSystem {
 					this.watcher.pause();
 				}
 			},
-			getAggregatedRemovals: () => {
-				const items = this.watcher && this.watcher.aggregatedRemovals;
-				if (items && this.inputFileSystem && this.inputFileSystem.purge) {
-					const fs = this.inputFileSystem;
-					for (const item of items) {
-						fs.purge(item);
+			getAggregatedRemovals: util.deprecate(
+				() => {
+					const items = this.watcher && this.watcher.aggregatedRemovals;
+					if (items && this.inputFileSystem && this.inputFileSystem.purge) {
+						const fs = this.inputFileSystem;
+						for (const item of items) {
+							fs.purge(item);
+						}
 					}
-				}
-				return items;
-			},
-			getAggregatedChanges: () => {
-				const items = this.watcher && this.watcher.aggregatedChanges;
-				if (items && this.inputFileSystem && this.inputFileSystem.purge) {
+					return items;
+				},
+				"Watcher.getAggregatedRemovals is deprecated in favor of Watcher.getInfo since that's more performant.",
+				"DEP_WEBPACK_WATCHER_GET_AGGREGATED_REMOVALS"
+			),
+			getAggregatedChanges: util.deprecate(
+				() => {
+					const items = this.watcher && this.watcher.aggregatedChanges;
+					if (items && this.inputFileSystem && this.inputFileSystem.purge) {
+						const fs = this.inputFileSystem;
+						for (const item of items) {
+							fs.purge(item);
+						}
+					}
+					return items;
+				},
+				"Watcher.getAggregatedChanges is deprecated in favor of Watcher.getInfo since that's more performant.",
+				"DEP_WEBPACK_WATCHER_GET_AGGREGATED_CHANGES"
+			),
+			getFileTimeInfoEntries: util.deprecate(
+				() => {
+					return fetchTimeInfo().fileTimeInfoEntries;
+				},
+				"Watcher.getFileTimeInfoEntries is deprecated in favor of Watcher.getInfo since that's more performant.",
+				"DEP_WEBPACK_WATCHER_FILE_TIME_INFO_ENTRIES"
+			),
+			getContextTimeInfoEntries: util.deprecate(
+				() => {
+					return fetchTimeInfo().contextTimeInfoEntries;
+				},
+				"Watcher.getContextTimeInfoEntries is deprecated in favor of Watcher.getInfo since that's more performant.",
+				"DEP_WEBPACK_WATCHER_CONTEXT_TIME_INFO_ENTRIES"
+			),
+			getInfo: () => {
+				const removals = this.watcher && this.watcher.aggregatedRemovals;
+				const changes = this.watcher && this.watcher.aggregatedChanges;
+				if (this.inputFileSystem && this.inputFileSystem.purge) {
 					const fs = this.inputFileSystem;
-					for (const item of items) {
-						fs.purge(item);
+					if (removals) {
+						for (const item of removals) {
+							fs.purge(item);
+						}
+					}
+					if (changes) {
+						for (const item of changes) {
+							fs.purge(item);
+						}
 					}
 				}
-				return items;
-			},
-			getFileTimeInfoEntries: () => {
-				if (this.watcher) {
-					return this.watcher.getTimeInfoEntries();
-				} else {
-					return new Map();
-				}
-			},
-			getContextTimeInfoEntries: () => {
-				if (this.watcher) {
-					return this.watcher.getTimeInfoEntries();
-				} else {
-					return new Map();
-				}
+				const { fileTimeInfoEntries, contextTimeInfoEntries } = fetchTimeInfo();
+				return {
+					changes,
+					removals,
+					fileTimeInfoEntries,
+					contextTimeInfoEntries
+				};
 			}
 		};
 	}

package/lib/node/ReadFileChunkLoadingRuntimeModule.js

@@ -46,7 +46,7 @@ class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 		);
 		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
 		const hasJsMatcher = compileBooleanMatcher(conditionMap);
-		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph);
+		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
 
 		const outputName = this.compilation.getPath(
 			getChunkFilenameTemplate(chunk, this.compilation.outputOptions),

package/lib/node/RequireChunkLoadingRuntimeModule.js

@@ -46,7 +46,7 @@ class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 		);
 		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
 		const hasJsMatcher = compileBooleanMatcher(conditionMap);
-		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph);
+		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
 
 		const outputName = this.compilation.getPath(
 			getChunkFilenameTemplate(chunk, this.compilation.outputOptions),

package/lib/optimize/ConcatenatedModule.js

@@ -39,6 +39,7 @@ const {
 /** @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 */
@@ -1077,7 +1078,8 @@ class ConcatenatedModule extends Module {
 		runtimeTemplate,
 		moduleGraph,
 		chunkGraph,
-		runtime: generationRuntime
+		runtime: generationRuntime,
+		codeGenerationResults
 	}) {
 		/** @type {Set<string>} */
 		const runtimeRequirements = new Set();
@@ -1104,7 +1106,8 @@ class ConcatenatedModule extends Module {
 				runtimeTemplate,
 				moduleGraph,
 				chunkGraph,
-				runtime
+				runtime,
+				codeGenerationResults
 			);
 		}
 
@@ -1634,6 +1637,7 @@ ${defineGetters}`
 	 * @param {ModuleGraph} moduleGraph moduleGraph
 	 * @param {ChunkGraph} chunkGraph chunkGraph
 	 * @param {RuntimeSpec} runtime runtime
+	 * @param {CodeGenerationResults} codeGenerationResults codeGenerationResults
 	 */
 	_analyseModule(
 		modulesMap,
@@ -1642,7 +1646,8 @@ ${defineGetters}`
 		runtimeTemplate,
 		moduleGraph,
 		chunkGraph,
-		runtime
+		runtime,
+		codeGenerationResults
 	) {
 		if (info.type === "concatenated") {
 			const m = info.module;
@@ -1657,7 +1662,8 @@ ${defineGetters}`
 					moduleGraph,
 					chunkGraph,
 					runtime,
-					concatenationScope
+					concatenationScope,
+					codeGenerationResults
 				});
 				const source = codeGenResult.sources.get("javascript");
 				const data = codeGenResult.data;
@@ -1702,7 +1708,7 @@ ${defineGetters}`
 				info.globalScope = globalScope;
 				info.moduleScope = moduleScope;
 			} catch (err) {
-				err.message += `\nwhile analysing module ${m.identifier()} for concatenation`;
+				err.message += `\nwhile analyzing module ${m.identifier()} for concatenation`;
 				throw err;
 			}
 		}