webpack 5.100.2 → 5.101.1

package/lib/index.js

@@ -49,14 +49,21 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./Compiler").AssetEmittedInfo} AssetEmittedInfo */
 /** @typedef {import("./Entrypoint")} Entrypoint */
 /** @typedef {import("./MultiCompiler").MultiCompilerOptions} MultiCompilerOptions */
+/** @typedef {import("./MultiCompiler").MultiWebpackOptions} MultiConfiguration */
 /** @typedef {import("./MultiStats")} MultiStats */
+/** @typedef {import("./MultiStats").MultiStatsOptions} MultiStatsOptions */
 /** @typedef {import("./NormalModuleFactory").ResolveData} ResolveData */
 /** @typedef {import("./Parser").ParserState} ParserState */
 /** @typedef {import("./ResolverFactory").ResolvePluginInstance} ResolvePluginInstance */
 /** @typedef {import("./ResolverFactory").Resolver} Resolver */
+/** @typedef {import("./Template").RenderManifestEntry} RenderManifestEntry */
+/** @typedef {import("./Template").RenderManifestOptions} RenderManifestOptions */
+/** @typedef {import("./TemplatedPathPlugin").TemplatePath} TemplatePath */
 /** @typedef {import("./Watching")} Watching */
 /** @typedef {import("./cli").Argument} Argument */
 /** @typedef {import("./cli").Problem} Problem */
+/** @typedef {import("./cli").Colors} Colors */
+/** @typedef {import("./cli").ColorsOptions} ColorsOptions */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsAsset} StatsAsset */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsChunk} StatsChunk */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsChunkGroup} StatsChunkGroup */
@@ -71,6 +78,8 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModuleTraceDependency} StatsModuleTraceDependency */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModuleTraceItem} StatsModuleTraceItem */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsProfile} StatsProfile */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */
 
@@ -79,7 +88,7 @@ const memoize = require("./util/memoize");
  * @param {() => T} factory factory function
  * @returns {T} function
  */
-const lazyFunction = factory => {
+const lazyFunction = (factory) => {
 	const fac = memoize(factory);
 	const f = /** @type {unknown} */ (
 		/**
@@ -132,25 +141,25 @@ module.exports = mergeExports(fn, {
 		return require("./webpack");
 	},
 	/**
-	 * @returns {(configuration: Configuration | Configuration[]) => void} validate fn
+	 * @returns {(configuration: Configuration | MultiConfiguration) => void} validate fn
 	 */
 	get validate() {
 		const webpackOptionsSchemaCheck =
-			/** @type {(configuration: Configuration | Configuration[]) => boolean} */
+			/** @type {(configuration: Configuration | MultiConfiguration) => boolean} */
 			(require("../schemas/WebpackOptions.check"));
 
 		const getRealValidate = memoize(
 			/**
-			 * @returns {(configuration: Configuration | Configuration[]) => void} validate fn
+			 * @returns {(configuration: Configuration | MultiConfiguration) => void} validate fn
 			 */
 			() => {
 				const validateSchema = require("./validateSchema");
 				const webpackOptionsSchema = require("../schemas/WebpackOptions.json");
 
-				return options => validateSchema(webpackOptionsSchema, options);
+				return (options) => validateSchema(webpackOptionsSchema, options);
 			}
 		);
-		return options => {
+		return (options) => {
 			if (!webpackOptionsSchemaCheck(options)) {
 				getRealValidate()(options);
 			}
@@ -284,6 +293,9 @@ module.exports = mergeExports(fn, {
 	get Module() {
 		return require("./Module");
 	},
+	get ModuleFactory() {
+		return require("./ModuleFactory");
+	},
 	get ModuleFilenameHelpers() {
 		return require("./ModuleFilenameHelpers");
 	},

package/lib/javascript/ArrayPushCallbackChunkFormatPlugin.js

@@ -27,7 +27,7 @@ class ArrayPushCallbackChunkFormatPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, compilation => {
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			compilation.hooks.additionalChunkRuntimeRequirements.tap(
 				PLUGIN_NAME,
 				(chunk, set, { chunkGraph }) => {

package/lib/javascript/BasicEvaluatedExpression.js

@@ -463,7 +463,7 @@ class BasicEvaluatedExpression {
 	setItems(items) {
 		this.type = TypeArray;
 		this.items = items;
-		this.sideEffects = items.some(i => i.couldHaveSideEffects());
+		this.sideEffects = items.some((i) => i.couldHaveSideEffects());
 		return this;
 	}
 
@@ -492,7 +492,7 @@ class BasicEvaluatedExpression {
 		this.quasis = quasis;
 		this.parts = parts;
 		this.templateStringKind = kind;
-		this.sideEffects = parts.some(p => p.sideEffects);
+		this.sideEffects = parts.some((p) => p.sideEffects);
 		return this;
 	}
 
@@ -557,7 +557,7 @@ class BasicEvaluatedExpression {
  * @param {string} flags regexp flags
  * @returns {boolean} is valid flags
  */
-BasicEvaluatedExpression.isValidRegExpFlags = flags => {
+BasicEvaluatedExpression.isValidRegExpFlags = (flags) => {
 	const len = flags.length;
 
 	if (len === 0) return true;

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 */
@@ -31,7 +32,7 @@ class CommonJsChunkFormatPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, compilation => {
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			compilation.hooks.additionalChunkRuntimeRequirements.tap(
 				PLUGIN_NAME,
 				(chunk, set, { chunkGraph }) => {
@@ -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/EnableChunkLoadingPlugin.js

@@ -15,7 +15,7 @@ const enabledTypes = new WeakMap();
  * @param {Compiler} compiler compiler
  * @returns {Set<ChunkLoadingType>} enabled types
  */
-const getEnabledTypes = compiler => {
+const getEnabledTypes = (compiler) => {
 	let set = enabledTypes.get(compiler);
 	if (set === undefined) {
 		set = new Set();

package/lib/javascript/JavascriptGenerator.js

@@ -88,7 +88,7 @@ class JavascriptGenerator extends Generator {
 			module.buildMeta.exportsType !== "namespace" ||
 			module.presentationalDependencies === undefined ||
 			!module.presentationalDependencies.some(
-				d => d instanceof HarmonyCompatibilityDependency
+				(d) => d instanceof HarmonyCompatibilityDependency
 			)
 		) {
 			return "Module is not an ECMAScript module";

package/lib/javascript/JavascriptModulesPlugin.js

@@ -173,20 +173,45 @@ 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
  * @property {SyncWaterfallHook<[Source, RenderContext]>} render
  * @property {SyncWaterfallHook<[Source, Module, StartupRenderContext]>} renderStartup
  * @property {SyncWaterfallHook<[string, RenderBootstrapContext]>} renderRequire
- * @property {SyncBailHook<[Module, RenderBootstrapContext], string | void>} inlineInRuntimeBailout
+ * @property {SyncBailHook<[Module, Partial<RenderBootstrapContext>], string | void>} inlineInRuntimeBailout
  * @property {SyncBailHook<[Module, RenderContext], string | void>} embedInRuntimeBailout
  * @property {SyncBailHook<[RenderContext], string | void>} strictRuntimeBailout
  * @property {SyncHook<[Chunk, Hash, ChunkHashContext]>} chunkHash
@@ -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"]),
@@ -274,7 +299,7 @@ class JavascriptModulesPlugin {
 				]) {
 					normalModuleFactory.hooks.createParser
 						.for(type)
-						.tap(PLUGIN_NAME, _options => {
+						.tap(PLUGIN_NAME, (_options) => {
 							switch (type) {
 								case JAVASCRIPT_MODULE_TYPE_AUTO: {
 									return new JavascriptParser("auto");
@@ -417,7 +442,7 @@ class JavascriptModulesPlugin {
 						);
 					}
 				});
-				compilation.hooks.contentHash.tap(PLUGIN_NAME, chunk => {
+				compilation.hooks.contentHash.tap(PLUGIN_NAME, (chunk) => {
 					const {
 						chunkGraph,
 						codeGenerationResults,
@@ -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);
@@ -713,7 +738,7 @@ class JavascriptModulesPlugin {
 		let allStrict = renderContext.strictMode;
 		if (
 			!allStrict &&
-			allModules.every(m => /** @type {BuildInfo} */ (m.buildInfo).strict)
+			allModules.every((m) => /** @type {BuildInfo} */ (m.buildInfo).strict)
 		) {
 			const strictBailout = hooks.strictRuntimeBailout.call(renderContext);
 			strictHeader = strictBailout
@@ -728,8 +753,12 @@ class JavascriptModulesPlugin {
 			strictMode: allStrict
 		};
 		const moduleSources =
-			Template.renderChunkModules(chunkRenderContext, allModules, module =>
-				this.renderModule(module, chunkRenderContext, hooks, true)
+			Template.renderChunkModules(chunkRenderContext, allModules, (module) =>
+				this.renderModule(
+					module,
+					{ ...chunkRenderContext, factory: true },
+					hooks
+				)
 			) || new RawSource("{}");
 		let source = tryRunOrWebpackError(
 			() => hooks.renderChunk.call(moduleSources, chunkRenderContext),
@@ -812,7 +841,7 @@ class JavascriptModulesPlugin {
 		let allStrict = renderContext.strictMode;
 		if (
 			!allStrict &&
-			allModules.every(m => /** @type {BuildInfo} */ (m.buildInfo).strict)
+			allModules.every((m) => /** @type {BuildInfo} */ (m.buildInfo).strict)
 		) {
 			const strictBailout = hooks.strictRuntimeBailout.call(renderContext);
 			if (strictBailout) {
@@ -838,10 +867,15 @@ class JavascriptModulesPlugin {
 			chunkRenderContext,
 			inlinedModules
 				? allModules.filter(
-						m => !(/** @type {Set<Module>} */ (inlinedModules).has(m))
+						(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) {
@@ -1011,7 +1063,7 @@ class JavascriptModulesPlugin {
 			const toSource = useSourceMap
 				? (content, name) =>
 						new OriginalSource(Template.asString(content), name)
-				: content => new RawSource(Template.asString(content));
+				: (content) => new RawSource(Template.asString(content));
 			source.add(
 				new PrefixSource(
 					prefix,
@@ -1229,7 +1281,7 @@ class JavascriptModulesPlugin {
 					}
 					const chunks =
 						/** @type {Entrypoint} */
-						(entrypoint).chunks.filter(c => c !== chunk);
+						(entrypoint).chunks.filter((c) => c !== chunk);
 					if (result.allowInlineStartup && chunks.length > 0) {
 						buf2.push(
 							"// This entry module depends on other loaded chunks and execution need to be delayed"
@@ -1242,10 +1294,10 @@ class JavascriptModulesPlugin {
 							moduleGraph.getIncomingConnectionsByOriginModule(entryModule),
 							([originModule, connections]) =>
 								originModule &&
-								connections.some(c => c.isTargetActive(chunk.runtime)) &&
+								connections.some((c) => c.isTargetActive(chunk.runtime)) &&
 								someInIterable(
 									chunkGraph.getModuleRuntimes(originModule),
-									runtime =>
+									(runtime) =>
 										intersectRuntime(runtime, chunk.runtime) !== undefined
 								)
 						)
@@ -1309,7 +1361,7 @@ class JavascriptModulesPlugin {
 							`${i === 0 ? `var ${RuntimeGlobals.exports} = ` : ""}${
 								RuntimeGlobals.onChunksLoaded
 							}(undefined, ${JSON.stringify(
-								chunks.map(c => c.id)
+								chunks.map((c) => c.id)
 							)}, ${runtimeTemplate.returningFunction(
 								`${RuntimeGlobals.require}(${moduleIdExpr})`
 							)})`
@@ -1554,10 +1606,9 @@ class JavascriptModulesPlugin {
 	) {
 		const innerStrict =
 			!allStrict &&
-			allModules.every(m => /** @type {BuildInfo} */ (m.buildInfo).strict);
+			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;
@@ -1639,7 +1693,7 @@ class JavascriptModulesPlugin {
 
 			const info = /** @type {Info} */ (inlinedModulesToInfo.get(m));
 			const allUsedNames = new Set(
-				Array.from(info.through, v => v.identifier.name)
+				Array.from(info.through, (v) => v.identifier.name)
 			);
 
 			for (const variable of usedInNonInlined) {
@@ -1660,7 +1714,7 @@ class JavascriptModulesPlugin {
 				if (allUsedNames.has(name) || usedNames.has(name)) {
 					const references = getAllReferences(variable);
 					const allIdentifiers = new Set([
-						...references.map(r => r.identifier),
+						...references.map((r) => r.identifier),
 						...variable.identifiers
 					]);
 					for (const ref of references) {