webpack 5.101.0 → 5.101.1

package/lib/javascript/ChunkFormatHelpers.js

@@ -0,0 +1,70 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Natsu @xiaoxiaojx
+*/
+
+"use strict";
+
+const { updateHashForEntryStartup } = require("./StartupHelpers");
+
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Entrypoint")} Entrypoint */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
+
+/**
+ * Gets information about a chunk including its entries and runtime chunk
+ * @param {Chunk} chunk The chunk to get information for
+ * @param {ChunkGraph} chunkGraph The chunk graph containing the chunk
+ * @returns {{entries: Array<[Module, Entrypoint | undefined]>, runtimeChunk: Chunk|null}} Object containing chunk entries and runtime chunk
+ */
+function getChunkInfo(chunk, chunkGraph) {
+	const entries = [
+		...chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
+	];
+	const runtimeChunk =
+		entries.length > 0
+			? /** @type {Entrypoint[][]} */
+				(entries)[0][1].getRuntimeChunk()
+			: null;
+
+	return {
+		entries,
+		runtimeChunk
+	};
+}
+
+/**
+ * Creates a chunk hash handler
+ * @param {string} name The name of the chunk
+ * @returns {(chunk: Chunk, hash: Hash, { chunkGraph }: ChunkHashContext) => void} The chunk hash handler
+ */
+function createChunkHashHandler(name) {
+	/**
+	 * @param {Chunk} chunk The chunk to get information for
+	 * @param {Hash} hash The hash to update
+	 * @param {ChunkHashContext} chunkHashContext The chunk hash context
+	 * @returns {void}
+	 */
+	return (chunk, hash, { chunkGraph }) => {
+		if (chunk.hasRuntime()) return;
+		const { entries, runtimeChunk } = getChunkInfo(chunk, chunkGraph);
+		hash.update(name);
+		hash.update("1");
+		if (runtimeChunk && runtimeChunk.hash) {
+			// https://github.com/webpack/webpack/issues/19439
+			// Any change to runtimeChunk should trigger a hash update,
+			// we shouldn't depend on or inspect its internal implementation.
+			// import __webpack_require__ from "./runtime-main.e9400aee33633a3973bd.js";
+			hash.update(runtimeChunk.hash);
+		}
+		updateHashForEntryStartup(hash, chunkGraph, entries, chunk);
+	};
+}
+
+module.exports = {
+	createChunkHashHandler,
+	getChunkInfo
+};

package/lib/javascript/CommonJsChunkFormatPlugin.js

@@ -9,14 +9,15 @@ const { ConcatSource, RawSource } = require("webpack-sources");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const { getUndoPath } = require("../util/identifier");
+const {
+	createChunkHashHandler,
+	getChunkInfo
+} = require("./ChunkFormatHelpers");
 const {
 	getChunkFilenameTemplate,
 	getCompilationHooks
 } = require("./JavascriptModulesPlugin");
-const {
-	generateEntryStartup,
-	updateHashForEntryStartup
-} = require("./StartupHelpers");
+const { generateEntryStartup } = require("./StartupHelpers");
 
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
@@ -59,13 +60,8 @@ class CommonJsChunkFormatPlugin {
 						Template.renderChunkRuntimeModules(runtimeModules, renderContext)
 					);
 				}
-				const entries = [
-					...chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
-				];
-				if (entries.length > 0) {
-					const runtimeChunk =
-						/** @type {Entrypoint} */
-						(entries[0][1]).getRuntimeChunk();
+				const { entries, runtimeChunk } = getChunkInfo(chunk, chunkGraph);
+				if (runtimeChunk) {
 					const currentOutputName = compilation
 						.getPath(
 							getChunkFilenameTemplate(chunk, compilation.outputOptions),
@@ -144,15 +140,8 @@ class CommonJsChunkFormatPlugin {
 				}
 				return source;
 			});
-			hooks.chunkHash.tap(PLUGIN_NAME, (chunk, hash, { chunkGraph }) => {
-				if (chunk.hasRuntime()) return;
-				hash.update(PLUGIN_NAME);
-				hash.update("1");
-				const entries = [
-					...chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
-				];
-				updateHashForEntryStartup(hash, chunkGraph, entries, chunk);
-			});
+
+			hooks.chunkHash.tap(PLUGIN_NAME, createChunkHashHandler(PLUGIN_NAME));
 		});
 	}
 }

package/lib/javascript/JavascriptModulesPlugin.js

@@ -173,13 +173,38 @@ const printGeneratedCodeForStack = (module, code) => {
  * @property {string} hash hash to be used for render call
  */
 
-/** @typedef {RenderContext & { inlined: boolean }} StartupRenderContext */
+/**
+ * @typedef {object} StartupRenderContext
+ * @property {Chunk} chunk the chunk
+ * @property {DependencyTemplates} dependencyTemplates the dependency templates
+ * @property {RuntimeTemplate} runtimeTemplate the runtime template
+ * @property {ModuleGraph} moduleGraph the module graph
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ * @property {CodeGenerationResults} codeGenerationResults results of code generation
+ * @property {boolean | undefined} strictMode rendering in strict context
+ * @property {boolean } inlined inlined
+ * @property {boolean=} inlinedInIIFE the inlined entry module is wrapped in an IIFE
+ */
+
+/**
+ * @typedef {object} ModuleRenderContext
+ * @property {Chunk} chunk the chunk
+ * @property {DependencyTemplates} dependencyTemplates the dependency templates
+ * @property {RuntimeTemplate} runtimeTemplate the runtime template
+ * @property {ModuleGraph} moduleGraph the module graph
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ * @property {CodeGenerationResults} codeGenerationResults results of code generation
+ * @property {InitFragment<ChunkRenderContext>[]} chunkInitFragments init fragments for the chunk
+ * @property {boolean | undefined} strictMode rendering in strict context
+ * @property {boolean} factory true: renders as factory method, false: pure module content
+ * @property {boolean=} inlinedInIIFE the inlined entry module is wrapped in an IIFE, existing only when `factory` is set to false
+ */
 
 /**
  * @typedef {object} CompilationHooks
- * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModuleContent
- * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModuleContainer
- * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModulePackage
+ * @property {SyncWaterfallHook<[Source, Module, ModuleRenderContext]>} renderModuleContent
+ * @property {SyncWaterfallHook<[Source, Module, ModuleRenderContext]>} renderModuleContainer
+ * @property {SyncWaterfallHook<[Source, Module, ModuleRenderContext]>} renderModulePackage
  * @property {SyncWaterfallHook<[Source, RenderContext]>} renderChunk
  * @property {SyncWaterfallHook<[Source, RenderContext]>} renderMain
  * @property {SyncWaterfallHook<[Source, RenderContext]>} renderContent
@@ -217,17 +242,17 @@ class JavascriptModulesPlugin {
 				renderModuleContent: new SyncWaterfallHook([
 					"source",
 					"module",
-					"renderContext"
+					"moduleRenderContext"
 				]),
 				renderModuleContainer: new SyncWaterfallHook([
 					"source",
 					"module",
-					"renderContext"
+					"moduleRenderContext"
 				]),
 				renderModulePackage: new SyncWaterfallHook([
 					"source",
 					"module",
-					"renderContext"
+					"moduleRenderContext"
 				]),
 				render: new SyncWaterfallHook(["source", "renderContext"]),
 				renderContent: new SyncWaterfallHook(["source", "renderContext"]),
@@ -575,18 +600,18 @@ class JavascriptModulesPlugin {
 
 	/**
 	 * @param {Module} module the rendered module
-	 * @param {ChunkRenderContext} renderContext options object
+	 * @param {ModuleRenderContext} renderContext options object
 	 * @param {CompilationHooks} hooks hooks
-	 * @param {boolean} factory true: renders as factory method, false: pure module content
 	 * @returns {Source | null} the newly generated source from rendering
 	 */
-	renderModule(module, renderContext, hooks, factory) {
+	renderModule(module, renderContext, hooks) {
 		const {
 			chunk,
 			chunkGraph,
 			runtimeTemplate,
 			codeGenerationResults,
-			strictMode
+			strictMode,
+			factory
 		} = renderContext;
 		try {
 			const codeGenResult = codeGenerationResults.get(module, chunk.runtime);
@@ -729,7 +754,11 @@ class JavascriptModulesPlugin {
 		};
 		const moduleSources =
 			Template.renderChunkModules(chunkRenderContext, allModules, (module) =>
-				this.renderModule(module, chunkRenderContext, hooks, true)
+				this.renderModule(
+					module,
+					{ ...chunkRenderContext, factory: true },
+					hooks
+				)
 			) || new RawSource("{}");
 		let source = tryRunOrWebpackError(
 			() => hooks.renderChunk.call(moduleSources, chunkRenderContext),
@@ -841,7 +870,12 @@ class JavascriptModulesPlugin {
 						(m) => !(/** @type {Set<Module>} */ (inlinedModules).has(m))
 					)
 				: allModules,
-			(module) => this.renderModule(module, chunkRenderContext, hooks, true),
+			(module) =>
+				this.renderModule(
+					module,
+					{ ...chunkRenderContext, factory: true },
+					hooks
+				),
 			prefix
 		);
 		if (
@@ -913,6 +947,8 @@ class JavascriptModulesPlugin {
 			const avoidEntryIife = compilation.options.optimization.avoidEntryIife;
 			/** @type {Map<Module, Source> | false} */
 			let renamedInlinedModule = false;
+			let inlinedInIIFE = false;
+
 			if (avoidEntryIife) {
 				renamedInlinedModule = this.getRenamedInlineModule(
 					allModules,
@@ -926,31 +962,46 @@ class JavascriptModulesPlugin {
 			}
 
 			for (const m of inlinedModules) {
+				const runtimeRequirements = chunkGraph.getModuleRuntimeRequirements(
+					m,
+					chunk.runtime
+				);
+				const exports = runtimeRequirements.has(RuntimeGlobals.exports);
+				const webpackExports =
+					exports && m.exportsArgument === RuntimeGlobals.exports;
+
+				const innerStrict =
+					!allStrict && /** @type {BuildInfo} */ (m.buildInfo).strict;
+
+				const iife = innerStrict
+					? "it needs to be in strict mode."
+					: inlinedModules.size > 1
+						? // TODO check globals and top-level declarations of other entries and chunk modules
+							// to make a better decision
+							"it needs to be isolated against other entry modules."
+						: chunkModules && !renamedInlinedModule
+							? "it needs to be isolated against other modules in the chunk."
+							: exports && !webpackExports
+								? `it uses a non-standard name for the exports (${m.exportsArgument}).`
+								: hooks.embedInRuntimeBailout.call(m, renderContext);
+
+				if (iife) {
+					inlinedInIIFE = true;
+				}
+
 				const renderedModule = renamedInlinedModule
 					? renamedInlinedModule.get(m)
-					: this.renderModule(m, chunkRenderContext, hooks, false);
+					: this.renderModule(
+							m,
+							{
+								...chunkRenderContext,
+								factory: false,
+								inlinedInIIFE
+							},
+							hooks
+						);
 
 				if (renderedModule) {
-					const innerStrict =
-						!allStrict && /** @type {BuildInfo} */ (m.buildInfo).strict;
-					const runtimeRequirements = chunkGraph.getModuleRuntimeRequirements(
-						m,
-						chunk.runtime
-					);
-					const exports = runtimeRequirements.has(RuntimeGlobals.exports);
-					const webpackExports =
-						exports && m.exportsArgument === RuntimeGlobals.exports;
-					const iife = innerStrict
-						? "it needs to be in strict mode."
-						: inlinedModules.size > 1
-							? // TODO check globals and top-level declarations of other entries and chunk modules
-								// to make a better decision
-								"it needs to be isolated against other entry modules."
-							: chunkModules && !renamedInlinedModule
-								? "it needs to be isolated against other modules in the chunk."
-								: exports && !webpackExports
-									? `it uses a non-standard name for the exports (${m.exportsArgument}).`
-									: hooks.embedInRuntimeBailout.call(m, renderContext);
 					let footer;
 					if (iife !== undefined) {
 						startupSource.add(
@@ -989,7 +1040,8 @@ class JavascriptModulesPlugin {
 			source.add(
 				hooks.renderStartup.call(startupSource, lastInlinedModule, {
 					...renderContext,
-					inlined: true
+					inlined: true,
+					inlinedInIIFE
 				})
 			);
 			if (bootstrap.afterStartup.length > 0) {
@@ -1557,7 +1609,6 @@ class JavascriptModulesPlugin {
 			allModules.every((m) => /** @type {BuildInfo} */ (m.buildInfo).strict);
 		const isMultipleEntries = inlinedModules.size > 1;
 		const singleEntryWithModules = inlinedModules.size === 1 && hasChunkModules;
-
 		// TODO:
 		// This step is before the IIFE reason calculation. Ideally, it should only be executed when this function can optimize the
 		// IIFE reason. Otherwise, it should directly return false. There are four reasons now, we have skipped two already, the left
@@ -1581,9 +1632,12 @@ class JavascriptModulesPlugin {
 			const isInlinedModule = inlinedModules && inlinedModules.has(m);
 			const moduleSource = this.renderModule(
 				m,
-				chunkRenderContext,
-				hooks,
-				!isInlinedModule
+				{
+					...chunkRenderContext,
+					factory: !isInlinedModule,
+					inlinedInIIFE: false
+				},
+				hooks
 			);
 
 			if (!moduleSource) continue;

package/lib/library/AbstractLibraryPlugin.js

@@ -19,6 +19,8 @@ const JavascriptModulesPlugin = require("../javascript/JavascriptModulesPlugin")
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").ModuleRenderContext} ModuleRenderContext */
 /** @typedef {import("../util/Hash")} Hash */
 
 const COMMON_LIBRARY_NAME_MESSAGE =
@@ -173,6 +175,20 @@ class AbstractLibraryPlugin {
 				});
 			}
 
+			if (
+				this.renderModuleContent !==
+				AbstractLibraryPlugin.prototype.renderModuleContent
+			) {
+				hooks.renderModuleContent.tap(
+					_pluginName,
+					(source, module, renderContext) =>
+						this.renderModuleContent(source, module, renderContext, {
+							compilation,
+							chunkGraph: compilation.chunkGraph
+						})
+				);
+			}
+
 			if (
 				this.renderStartup !== AbstractLibraryPlugin.prototype.renderStartup
 			) {
@@ -288,6 +304,17 @@ class AbstractLibraryPlugin {
 		return source;
 	}
 
+	/**
+	 * @param {Source} source source
+	 * @param {Module} module module
+	 * @param {ModuleRenderContext} renderContext render context
+	 * @param {Omit<LibraryContext<T>, 'options'>} libraryContext context
+	 * @returns {Source} source with library export
+	 */
+	renderModuleContent(source, module, renderContext, libraryContext) {
+		return source;
+	}
+
 	/**
 	 * @param {Chunk} chunk the chunk
 	 * @param {Hash} hash hash

package/lib/library/ModuleLibraryPlugin.js

@@ -8,7 +8,7 @@
 const { ConcatSource } = require("webpack-sources");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
-const JavascriptModulesPlugin = require("../javascript/JavascriptModulesPlugin");
+const CommonJsSelfReferenceDependency = require("../dependencies/CommonJsSelfReferenceDependency");
 const ConcatenatedModule = require("../optimize/ConcatenatedModule");
 const propertyAccess = require("../util/propertyAccess");
 const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
@@ -22,6 +22,7 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").ModuleRenderContext} ModuleRenderContext */
 /** @typedef {import("../util/Hash")} Hash */
 
 /**
@@ -66,37 +67,9 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		super.apply(compiler);
 
 		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
-			const { exportsDefinitions } =
+			const { onDemandExportsGeneration } =
 				ConcatenatedModule.getCompilationHooks(compilation);
-			exportsDefinitions.tap(PLUGIN_NAME, (definitions, module) => {
-				const bailout = JavascriptModulesPlugin.getCompilationHooks(
-					compilation
-				).inlineInRuntimeBailout.call(module, {});
-				if (bailout) return false;
-				// If we have connections not all modules were concatenated, so we need the wrapper
-				const connections =
-					compilation.moduleGraph.getIncomingConnections(module);
-
-				for (const connection of connections) {
-					if (connection.originModule) {
-						return false;
-					}
-				}
-
-				// Runtime and splitting chunks now requires the wrapper too
-				for (const chunk of compilation.chunkGraph.getModuleChunksIterable(
-					module
-				)) {
-					if (
-						!chunk.hasRuntime() ||
-						compilation.chunkGraph.getNumberOfEntryModules(chunk) > 1
-					) {
-						return false;
-					}
-				}
-
-				return true;
-			});
+			onDemandExportsGeneration.tap(PLUGIN_NAME, (_module) => true);
 		});
 	}
 
@@ -128,10 +101,21 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 	renderStartup(
 		source,
 		module,
-		{ moduleGraph, chunk, codeGenerationResults },
+		{ moduleGraph, chunk, codeGenerationResults, inlined, inlinedInIIFE },
 		{ options, compilation }
 	) {
 		const result = new ConcatSource(source);
+
+		if (!module.buildMeta || !module.buildMeta.exportsType) {
+			for (const dependency of module.dependencies) {
+				if (dependency instanceof CommonJsSelfReferenceDependency) {
+					result.add(`export { ${RuntimeGlobals.exports} as default }`);
+					break;
+				}
+			}
+			return result;
+		}
+
 		const exportsInfo = options.export
 			? [
 					moduleGraph.getExportInfo(
@@ -141,8 +125,11 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 				]
 			: moduleGraph.getExportsInfo(module).orderedExports;
 		const definitions =
-			/** @type {BuildMeta} */
-			(module.buildMeta).exportsFinalName || {};
+			inlined && !inlinedInIIFE
+				? (module.buildMeta &&
+						/** @type {GenerationMeta} */ module.buildMeta.exportsFinalName) ||
+					{}
+				: {};
 		/** @type {string[]} */
 		const shortHandedExports = [];
 		/** @type {[string, string][]} */
@@ -241,6 +228,32 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 
 		return result;
 	}
+
+	/**
+	 * @param {Source} source source
+	 * @param {Module} module module
+	 * @param {ModuleRenderContext} renderContext render context
+	 * @param {Omit<LibraryContext<T>, 'options'>} libraryContext context
+	 * @returns {Source} source with library export
+	 */
+	renderModuleContent(
+		source,
+		module,
+		{ factory, inlinedInIIFE },
+		libraryContext
+	) {
+		const result = new ConcatSource(source);
+		// Re-add `factoryExportsBinding` to the source
+		// when the module is rendered as a factory or treated as an inlined (startup) module but wrapped in an IIFE
+		if (
+			(inlinedInIIFE || factory) &&
+			module.buildMeta &&
+			module.buildMeta.factoryExportsBinding
+		) {
+			result.add(module.buildMeta.factoryExportsBinding);
+		}
+		return result;
+	}
 }
 
 module.exports = ModuleLibraryPlugin;

package/lib/node/RequireChunkLoadingRuntimeModule.js

@@ -158,11 +158,16 @@ class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 												? "if(true) { // all chunks have JS"
 												: `if(${hasJsMatcher("chunkId")}) {`,
 											Template.indent([
-												`installChunk(require(${JSON.stringify(
+												// The require function loads and runs a chunk. When the chunk is being run,
+												// it can call __webpack_require__.C to directly complete installed.
+												`var installedChunk = require(${JSON.stringify(
 													rootOutputDir
 												)} + ${
 													RuntimeGlobals.getChunkScriptFilename
-												}(chunkId)));`
+												}(chunkId));`,
+												"if (!installedChunks[chunkId]) {",
+												Template.indent(["installChunk(installedChunk);"]),
+												"}"
 											]),
 											"} else installedChunks[chunkId] = 1;",
 											""

package/lib/optimize/ConcatenatedModule.js

@@ -668,7 +668,7 @@ const getFinalName = (
 
 /**
  * @typedef {object} ConcatenateModuleHooks
- * @property {SyncBailHook<[Record<string, string>, ConcatenatedModule], boolean | void>} exportsDefinitions
+ * @property {SyncBailHook<[ConcatenatedModule], boolean>} onDemandExportsGeneration
  * @property {SyncBailHook<[Partial<ConcatenatedModuleInfo>, ConcatenatedModuleInfo], boolean | void>} concatenatedModuleInfo
  */
 
@@ -716,7 +716,7 @@ class ConcatenatedModule extends Module {
 		let hooks = compilationHooksMap.get(compilation);
 		if (hooks === undefined) {
 			hooks = {
-				exportsDefinitions: new SyncBailHook(["definitions", "module"]),
+				onDemandExportsGeneration: new SyncBailHook(["module"]),
 				concatenatedModuleInfo: new SyncBailHook([
 					"updatedInfo",
 					"concatenatedModuleInfo"
@@ -1692,11 +1692,6 @@ class ConcatenatedModule extends Module {
 
 		// define exports
 		if (exportsMap.size > 0) {
-			const { exportsDefinitions } = ConcatenatedModule.getCompilationHooks(
-				/** @type {Compilation} */
-				(this.compilation)
-			);
-
 			const definitions = [];
 			for (const [key, value] of exportsMap) {
 				definitions.push(
@@ -1706,34 +1701,39 @@ class ConcatenatedModule extends Module {
 				);
 			}
 
-			const shouldSkipRenderDefinitions = exportsDefinitions.call(
-				exportsFinalName,
-				this
-			);
+			const { onDemandExportsGeneration } =
+				ConcatenatedModule.getCompilationHooks(
+					/** @type {Compilation} */
+					(this.compilation)
+				);
 
-			if (!shouldSkipRenderDefinitions) {
-				runtimeRequirements.add(RuntimeGlobals.exports);
-				runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+			runtimeRequirements.add(RuntimeGlobals.exports);
+			runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
 
-				if (shouldAddHarmonyFlag) {
-					result.add("// ESM COMPAT FLAG\n");
-					result.add(
-						runtimeTemplate.defineEsModuleFlagStatement({
-							exportsArgument: this.exportsArgument,
-							runtimeRequirements
-						})
-					);
-				}
+			if (shouldAddHarmonyFlag) {
+				result.add("// ESM COMPAT FLAG\n");
+				result.add(
+					runtimeTemplate.defineEsModuleFlagStatement({
+						exportsArgument: this.exportsArgument,
+						runtimeRequirements
+					})
+				);
+			}
 
+			if (onDemandExportsGeneration.call(this)) {
+				/** @type {BuildMeta} */ (this.buildMeta).factoryExportsBinding =
+					`${RuntimeGlobals.definePropertyGetters}(${
+						this.exportsArgument
+					}, {${definitions.join(",")}\n});\n`;
+				/** @type {BuildMeta} */ (this.buildMeta).exportsFinalName =
+					exportsFinalName;
+			} else {
 				result.add("\n// EXPORTS\n");
 				result.add(
 					`${RuntimeGlobals.definePropertyGetters}(${
 						this.exportsArgument
 					}, {${definitions.join(",")}\n});\n`
 				);
-			} else {
-				/** @type {BuildMeta} */
-				(this.buildMeta).exportsFinalName = exportsFinalName;
 			}
 		}
 

package/lib/runtime/GetChunkFilenameRuntimeModule.js

@@ -107,6 +107,10 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 				)) {
 					addChunk(c);
 				}
+				includedChunksMessages.push("chunks that the entrypoint depends on");
+				for (const c of chunkGraph.getChunkEntryDependOnChunksIterable(chunk)) {
+					addChunk(c);
+				}
 			}
 		}
 		for (const entrypoint of chunk.getAllReferencedAsyncEntrypoints()) {

package/lib/serialization/FileMiddleware.js

@@ -272,6 +272,7 @@ const deserialize = async (middleware, name, readFile) => {
 		while (contentItemLength - contentPosition < n) {
 			const remaining = contentItem.slice(contentPosition);
 			let lengthFromNext = n - remaining.length;
+			/** @type {Buffer[]} */
 			const buffers = [remaining];
 			for (let i = contentsIndex + 1; i < contents.length; i++) {
 				const l = contents[i].length;

package/lib/util/fs.js

@@ -65,7 +65,7 @@ const path = require("path");
 
 /** @typedef {string | number | boolean | null} JsonPrimitive */
 /** @typedef {JsonValue[]} JsonArray */
-/** @typedef {{[Key in string]: JsonValue} & {[Key in string]?: JsonValue | undefined}} JsonObject */
+/** @typedef {{ [Key in string]?: JsonValue }} JsonObject */
 /** @typedef {JsonPrimitive | JsonObject | JsonArray} JsonValue */
 
 /** @typedef {(err: NodeJS.ErrnoException | null) => void} NoParamCallback */

package/lib/wasm-sync/WebAssemblyGenerator.js

@@ -43,7 +43,7 @@ const WebAssemblyUtils = require("./WebAssemblyUtils");
 /**
  * @template T
  * @param {((prev: ArrayBuffer) => ArrayBuffer)[]} fns transforms
- * @returns {ArrayBufferTransform} composed transform
+ * @returns {(buf: ArrayBuffer) => ArrayBuffer} composed transform
  */
 const compose = (...fns) =>
 	fns.reduce(
@@ -514,8 +514,7 @@ class WebAssemblyGenerator extends Generator {
 			})
 		);
 
-		const newBin = transform(bin);
-
+		const newBin = transform(/** @type {ArrayBuffer} */ (bin.buffer));
 		const newBuf = Buffer.from(newBin);
 
 		return new RawSource(newBuf);