webpack 5.97.1 → 5.104.1

package/lib/javascript/JavascriptModulesPlugin.js

@@ -5,42 +5,45 @@
 
 "use strict";
 
-const eslintScope = require("eslint-scope");
-const { SyncWaterfallHook, SyncHook, SyncBailHook } = require("tapable");
 const vm = require("vm");
+const eslintScope = require("eslint-scope");
+const { SyncBailHook, SyncHook, SyncWaterfallHook } = require("tapable");
 const {
+	CachedSource,
 	ConcatSource,
 	OriginalSource,
 	PrefixSource,
 	RawSource,
-	CachedSource,
 	ReplaceSource
 } = require("webpack-sources");
 const Compilation = require("../Compilation");
 const { tryRunOrWebpackError } = require("../HookWebpackError");
 const HotUpdateChunk = require("../HotUpdateChunk");
 const InitFragment = require("../InitFragment");
+const { JAVASCRIPT_TYPE } = require("../ModuleSourceTypeConstants");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
 	JAVASCRIPT_MODULE_TYPE_ESM,
 	WEBPACK_MODULE_TYPE_RUNTIME
 } = require("../ModuleTypeConstants");
+const NormalModule = require("../NormalModule");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const { last, someInIterable } = require("../util/IterableHelpers");
 const StringXor = require("../util/StringXor");
-const { compareModulesByIdentifier } = require("../util/comparators");
+const { compareModulesByIdOrIdentifier } = require("../util/comparators");
 const {
-	getPathInAst,
-	getAllReferences,
 	RESERVED_NAMES,
-	findNewName,
 	addScopeSymbols,
+	findNewName,
+	getAllReferences,
+	getPathInAst,
 	getUsedNamesInScopeInfo
 } = require("../util/concatenate");
 const createHash = require("../util/createHash");
 const nonNumericOnlyHash = require("../util/nonNumericOnlyHash");
+const removeBOM = require("../util/removeBOM");
 const { intersectRuntime } = require("../util/runtime");
 const JavascriptGenerator = require("./JavascriptGenerator");
 const JavascriptParser = require("./JavascriptParser");
@@ -48,13 +51,14 @@ const JavascriptParser = require("./JavascriptParser");
 /** @typedef {import("eslint-scope").Reference} Reference */
 /** @typedef {import("eslint-scope").Scope} Scope */
 /** @typedef {import("eslint-scope").Variable} Variable */
+/** @typedef {import("estree").Program} Program */
 /** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").Output} OutputOptions */
+/** @typedef {import("../config/defaults").OutputNormalizedWithDefaults} OutputOptions */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
 /** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
-/** @typedef {import("../Compilation").ModuleObject} ModuleObject */
+/** @typedef {import("../Compilation").ExecuteModuleObject} ExecuteModuleObject */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../Entrypoint")} Entrypoint */
@@ -66,7 +70,6 @@ const JavascriptParser = require("./JavascriptParser");
 /** @typedef {import("../WebpackError")} WebpackError */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/createHash").Algorithm} Algorithm */
 
 /**
  * @param {Chunk} chunk a chunk
@@ -77,7 +80,7 @@ const chunkHasJs = (chunk, chunkGraph) => {
 	if (chunkGraph.getNumberOfEntryModules(chunk) > 0) return true;
 
 	return Boolean(
-		chunkGraph.getChunkModulesIterableBySourceType(chunk, "javascript")
+		chunkGraph.getChunkModulesIterableBySourceType(chunk, JAVASCRIPT_TYPE)
 	);
 };
 
@@ -92,11 +95,12 @@ const chunkHasRuntimeOrJs = (chunk, chunkGraph) => {
 			chunk,
 			WEBPACK_MODULE_TYPE_RUNTIME
 		)
-	)
+	) {
 		return true;
+	}
 
 	return Boolean(
-		chunkGraph.getChunkModulesIterableBySourceType(chunk, "javascript")
+		chunkGraph.getChunkModulesIterableBySourceType(chunk, JAVASCRIPT_TYPE)
 	);
 };
 
@@ -113,10 +117,10 @@ const printGeneratedCodeForStack = (module, code) => {
 			/**
 			 * @param {string} line the line
 			 * @param {number} i the index
-			 * @param {string[]} lines the lines
+			 * @param {string[]} _lines the lines
 			 * @returns {string} the line with line number
 			 */
-			(line, i, lines) => {
+			(line, i, _lines) => {
 				const iStr = `${i + 1}`;
 				return `${" ".repeat(n - iStr.length)}${iStr} | ${line}`;
 			}
@@ -169,20 +173,46 @@ 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
+ * @property {boolean=} renderInObject render module in object container
+ */
 
 /**
  * @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
@@ -213,17 +243,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"]),
@@ -248,7 +278,7 @@ class JavascriptModulesPlugin {
 
 	constructor(options = {}) {
 		this.options = options;
-		/** @type {WeakMap<Source, TODO>} */
+		/** @type {WeakMap<Source, { source: Source, needModule:boolean, needExports: boolean, needRequire: boolean, needThisAsExports: boolean, needStrict: boolean | undefined, renderShorthand: boolean }>} */
 		this._moduleFactoryCache = new WeakMap();
 	}
 
@@ -262,24 +292,49 @@ class JavascriptModulesPlugin {
 			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
-				normalModuleFactory.hooks.createParser
-					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
-					.tap(PLUGIN_NAME, options => new JavascriptParser("auto"));
-				normalModuleFactory.hooks.createParser
-					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
-					.tap(PLUGIN_NAME, options => new JavascriptParser("script"));
-				normalModuleFactory.hooks.createParser
-					.for(JAVASCRIPT_MODULE_TYPE_ESM)
-					.tap(PLUGIN_NAME, options => new JavascriptParser("module"));
-				normalModuleFactory.hooks.createGenerator
-					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
-					.tap(PLUGIN_NAME, () => new JavascriptGenerator());
-				normalModuleFactory.hooks.createGenerator
-					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
-					.tap(PLUGIN_NAME, () => new JavascriptGenerator());
-				normalModuleFactory.hooks.createGenerator
-					.for(JAVASCRIPT_MODULE_TYPE_ESM)
-					.tap(PLUGIN_NAME, () => new JavascriptGenerator());
+
+				for (const type of [
+					JAVASCRIPT_MODULE_TYPE_AUTO,
+					JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+					JAVASCRIPT_MODULE_TYPE_ESM
+				]) {
+					normalModuleFactory.hooks.createParser
+						.for(type)
+						.tap(PLUGIN_NAME, (options) => {
+							switch (type) {
+								case JAVASCRIPT_MODULE_TYPE_AUTO: {
+									return new JavascriptParser("auto", { parse: options.parse });
+								}
+								case JAVASCRIPT_MODULE_TYPE_DYNAMIC: {
+									return new JavascriptParser("script", {
+										parse: options.parse
+									});
+								}
+								case JAVASCRIPT_MODULE_TYPE_ESM: {
+									return new JavascriptParser("module", {
+										parse: options.parse
+									});
+								}
+							}
+						});
+					normalModuleFactory.hooks.createGenerator
+						.for(type)
+						.tap(PLUGIN_NAME, () => new JavascriptGenerator());
+
+					NormalModule.getCompilationHooks(compilation).processResult.tap(
+						PLUGIN_NAME,
+						(result, module) => {
+							if (module.type === type) {
+								const [source, ...rest] = result;
+
+								return [removeBOM(source), ...rest];
+							}
+
+							return result;
+						}
+					);
+				}
+
 				compilation.hooks.renderManifest.tap(PLUGIN_NAME, (result, options) => {
 					const {
 						hash,
@@ -392,10 +447,9 @@ class JavascriptModulesPlugin {
 						);
 					}
 				});
-				compilation.hooks.contentHash.tap(PLUGIN_NAME, chunk => {
+				compilation.hooks.contentHash.tap(PLUGIN_NAME, (chunk) => {
 					const {
 						chunkGraph,
-						codeGenerationResults,
 						moduleGraph,
 						runtimeTemplate,
 						outputOptions: {
@@ -405,7 +459,10 @@ class JavascriptModulesPlugin {
 							hashFunction
 						}
 					} = compilation;
-					const hash = createHash(/** @type {Algorithm} */ (hashFunction));
+					const codeGenerationResults =
+						/** @type {CodeGenerationResults} */
+						(compilation.codeGenerationResults);
+					const hash = createHash(hashFunction);
 					if (hashSalt) hash.update(hashSalt);
 					if (chunk.hasRuntime()) {
 						this.updateHashWithBootstrap(
@@ -432,7 +489,7 @@ class JavascriptModulesPlugin {
 					});
 					const modules = chunkGraph.getChunkModulesIterableBySourceType(
 						chunk,
-						"javascript"
+						JAVASCRIPT_TYPE
 					);
 					if (modules) {
 						const xor = new StringXor();
@@ -452,11 +509,10 @@ class JavascriptModulesPlugin {
 						}
 						xor.updateHash(hash);
 					}
-					const digest = /** @type {string} */ (hash.digest(hashDigest));
+					const digest = hash.digest(hashDigest);
 					chunk.contentHash.javascript = nonNumericOnlyHash(
 						digest,
-						/** @type {number} */
-						(hashDigestLength)
+						hashDigestLength
 					);
 				});
 				compilation.hooks.additionalTreeRuntimeRequirements.tap(
@@ -473,7 +529,8 @@ class JavascriptModulesPlugin {
 					}
 				);
 				compilation.hooks.executeModule.tap(PLUGIN_NAME, (options, context) => {
-					const source = options.codeGenerationResult.sources.get("javascript");
+					const source =
+						options.codeGenerationResult.sources.get(JAVASCRIPT_TYPE);
 					if (source === undefined) return;
 					const { module } = options;
 					const code = source.source();
@@ -487,7 +544,7 @@ class JavascriptModulesPlugin {
 					);
 
 					const moduleObject =
-						/** @type {ModuleObject} */
+						/** @type {ExecuteModuleObject} */
 						(options.moduleObject);
 
 					try {
@@ -541,37 +598,39 @@ class JavascriptModulesPlugin {
 		if (chunk.filenameTemplate) {
 			return chunk.filenameTemplate;
 		} else if (chunk instanceof HotUpdateChunk) {
-			return /** @type {TemplatePath} */ (outputOptions.hotUpdateChunkFilename);
+			return outputOptions.hotUpdateChunkFilename;
 		} else if (chunk.canBeInitial()) {
-			return /** @type {TemplatePath} */ (outputOptions.filename);
+			return outputOptions.filename;
 		}
-		return /** @type {TemplatePath} */ (outputOptions.chunkFilename);
+		return outputOptions.chunkFilename;
 	}
 
 	/**
 	 * @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,
+			renderInObject
 		} = renderContext;
 		try {
 			const codeGenResult = codeGenerationResults.get(module, chunk.runtime);
-			const moduleSource = codeGenResult.sources.get("javascript");
+			const moduleSource = codeGenResult.sources.get(JAVASCRIPT_TYPE);
 			if (!moduleSource) return null;
 			if (codeGenResult.data !== undefined) {
 				const chunkInitFragments = codeGenResult.data.get("chunkInitFragments");
 				if (chunkInitFragments) {
-					for (const i of chunkInitFragments)
+					for (const i of chunkInitFragments) {
 						renderContext.chunkInitFragments.push(i);
+					}
 				}
 			}
 			const moduleSourcePostContent = tryRunOrWebpackError(
@@ -599,6 +658,8 @@ class JavascriptModulesPlugin {
 				const cacheEntry = this._moduleFactoryCache.get(
 					moduleSourcePostContent
 				);
+				const renderShorthand =
+					renderInObject === true && runtimeTemplate.supportsMethodShorthand();
 				let source;
 				if (
 					cacheEntry &&
@@ -606,35 +667,46 @@ class JavascriptModulesPlugin {
 					cacheEntry.needExports === needExports &&
 					cacheEntry.needRequire === needRequire &&
 					cacheEntry.needThisAsExports === needThisAsExports &&
-					cacheEntry.needStrict === needStrict
+					cacheEntry.needStrict === needStrict &&
+					cacheEntry.renderShorthand === renderShorthand
 				) {
 					source = cacheEntry.source;
 				} else {
 					const factorySource = new ConcatSource();
 					const args = [];
-					if (needExports || needRequire || needModule)
+					if (needExports || needRequire || needModule) {
 						args.push(
 							needModule
 								? module.moduleArgument
 								: `__unused_webpack_${module.moduleArgument}`
 						);
-					if (needExports || needRequire)
+					}
+					if (needExports || needRequire) {
 						args.push(
 							needExports
 								? module.exportsArgument
 								: `__unused_webpack_${module.exportsArgument}`
 						);
+					}
 					if (needRequire) args.push(RuntimeGlobals.require);
-					if (!needThisAsExports && runtimeTemplate.supportsArrowFunction()) {
+
+					if (renderShorthand) {
+						// we can optimize function to methodShorthand if render module factory in object
+						factorySource.add(`(${args.join(", ")}) {\n\n`);
+					} else if (
+						!needThisAsExports &&
+						runtimeTemplate.supportsArrowFunction()
+					) {
 						factorySource.add(`/***/ ((${args.join(", ")}) => {\n\n`);
 					} else {
 						factorySource.add(`/***/ (function(${args.join(", ")}) {\n\n`);
 					}
+
 					if (needStrict) {
 						factorySource.add('"use strict";\n');
 					}
 					factorySource.add(moduleSourcePostContent);
-					factorySource.add("\n\n/***/ })");
+					factorySource.add(`\n\n/***/ }${renderShorthand ? "" : ")"}`);
 					source = new CachedSource(factorySource);
 					this._moduleFactoryCache.set(moduleSourcePostContent, {
 						source,
@@ -642,7 +714,8 @@ class JavascriptModulesPlugin {
 						needExports,
 						needRequire,
 						needThisAsExports,
-						needStrict
+						needStrict,
+						renderShorthand
 					});
 				}
 				moduleSourcePostContainer = tryRunOrWebpackError(
@@ -677,15 +750,15 @@ class JavascriptModulesPlugin {
 		const { chunk, chunkGraph } = renderContext;
 		const modules = chunkGraph.getOrderedChunkModulesIterableBySourceType(
 			chunk,
-			"javascript",
-			compareModulesByIdentifier
+			JAVASCRIPT_TYPE,
+			compareModulesByIdOrIdentifier(chunkGraph)
 		);
-		const allModules = modules ? Array.from(modules) : [];
+		const allModules = modules ? [...modules] : [];
 		let strictHeader;
 		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
@@ -700,8 +773,15 @@ class JavascriptModulesPlugin {
 			strictMode: allStrict
 		};
 		const moduleSources =
-			Template.renderChunkModules(chunkRenderContext, allModules, module =>
-				this.renderModule(module, chunkRenderContext, hooks, true)
+			Template.renderChunkModules(
+				chunkRenderContext,
+				allModules,
+				(module, renderInObject) =>
+					this.renderModule(
+						module,
+						{ ...chunkRenderContext, factory: true, renderInObject },
+						hooks
+					)
 			) || new RawSource("{}");
 		let source = tryRunOrWebpackError(
 			() => hooks.renderChunk.call(moduleSources, chunkRenderContext),
@@ -753,13 +833,14 @@ class JavascriptModulesPlugin {
 		const bootstrap = this.renderBootstrap(renderContext, hooks);
 		const useSourceMap = hooks.useSourceMap.call(chunk, renderContext);
 
-		const allModules = Array.from(
-			chunkGraph.getOrderedChunkModulesIterableBySourceType(
+		/** @type {Module[]} */
+		const allModules = [
+			...(chunkGraph.getOrderedChunkModulesIterableBySourceType(
 				chunk,
-				"javascript",
-				compareModulesByIdentifier
-			) || []
-		);
+				JAVASCRIPT_TYPE,
+				compareModulesByIdOrIdentifier(chunkGraph)
+			) || [])
+		];
 
 		const hasEntryModules = chunkGraph.getNumberOfEntryModules(chunk) > 0;
 		/** @type {Set<Module> | undefined} */
@@ -783,7 +864,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) {
@@ -809,10 +890,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, renderInObject) =>
+				this.renderModule(
+					module,
+					{ ...chunkRenderContext, factory: true, renderInObject },
+					hooks
+				),
 			prefix
 		);
 		if (
@@ -884,8 +970,11 @@ class JavascriptModulesPlugin {
 			const avoidEntryIife = compilation.options.optimization.avoidEntryIife;
 			/** @type {Map<Module, Source> | false} */
 			let renamedInlinedModule = false;
+			let inlinedInIIFE = false;
+
 			if (avoidEntryIife) {
-				renamedInlinedModule = this.getRenamedInlineModule(
+				renamedInlinedModule = this._getRenamedInlineModule(
+					compilation,
 					allModules,
 					renderContext,
 					inlinedModules,
@@ -897,31 +986,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(
@@ -940,12 +1044,13 @@ class JavascriptModulesPlugin {
 						footer = "\n";
 					}
 					if (exports) {
-						if (m !== lastInlinedModule)
+						if (m !== lastInlinedModule) {
 							startupSource.add(`var ${m.exportsArgument} = {};\n`);
-						else if (m.exportsArgument !== RuntimeGlobals.exports)
+						} else if (m.exportsArgument !== RuntimeGlobals.exports) {
 							startupSource.add(
 								`var ${m.exportsArgument} = ${RuntimeGlobals.exports};\n`
 							);
+						}
 					}
 					startupSource.add(renderedModule);
 					startupSource.add(footer);
@@ -959,7 +1064,8 @@ class JavascriptModulesPlugin {
 			source.add(
 				hooks.renderStartup.call(startupSource, lastInlinedModule, {
 					...renderContext,
-					inlined: true
+					inlined: true,
+					inlinedInIIFE
 				})
 			);
 			if (bootstrap.afterStartup.length > 0) {
@@ -977,11 +1083,11 @@ class JavascriptModulesPlugin {
 			const lastEntryModule =
 				/** @type {Module} */
 				(last(chunkGraph.getChunkEntryModulesIterable(chunk)));
-			/** @type {function(string[], string): Source} */
+			/** @type {(content: string[], name: string) => Source} */
 			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,
@@ -989,7 +1095,7 @@ class JavascriptModulesPlugin {
 						toSource(bootstrap.beforeStartup, "webpack/before-startup"),
 						"\n",
 						hooks.renderStartup.call(
-							toSource(bootstrap.startup.concat(""), "webpack/startup"),
+							toSource([...bootstrap.startup, ""], "webpack/startup"),
 							lastEntryModule,
 							{
 								...renderContext,
@@ -1138,6 +1244,16 @@ class JavascriptModulesPlugin {
 			buf.push("");
 		}
 
+		if (runtimeRequirements.has(RuntimeGlobals.makeDeferredNamespaceObject)) {
+			// in order to optimize of DeferredNamespaceObject, we remove all proxy handlers after the module initialize
+			// (see MakeDeferredNamespaceObjectRuntimeModule)
+			// This requires all deferred imports to a module can get the module export object before the module
+			// is evaluated.
+			buf.push("// The deferred module cache");
+			buf.push("var __webpack_module_deferred_exports__ = {};");
+			buf.push("");
+		}
+
 		if (useRequire) {
 			buf.push("// The require function");
 			buf.push(`function ${RuntimeGlobals.require}(moduleId) {`);
@@ -1183,13 +1299,15 @@ class JavascriptModulesPlugin {
 					entryModule,
 					entrypoint
 				] of chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)) {
-					if (!chunkGraph.getModuleSourceTypes(entryModule).has("javascript")) {
+					if (
+						!chunkGraph.getModuleSourceTypes(entryModule).has(JAVASCRIPT_TYPE)
+					) {
 						i--;
 						continue;
 					}
 					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"
@@ -1202,10 +1320,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
 								)
 						)
@@ -1264,12 +1382,22 @@ class JavascriptModulesPlugin {
 							"// This entry module used 'module' so it can't be inlined"
 						);
 					}
+					if (
+						result.allowInlineStartup &&
+						entryRuntimeRequirements.has(RuntimeGlobals.thisAsExports)
+					) {
+						buf2.push(
+							"// This entry module used `this` as exports so it can't be inlined"
+						);
+						result.allowInlineStartup = false;
+					}
+
 					if (chunks.length > 0) {
 						buf2.push(
 							`${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})`
 							)})`
@@ -1282,21 +1410,33 @@ class JavascriptModulesPlugin {
 						);
 					} else {
 						if (i === 0) buf2.push(`var ${RuntimeGlobals.exports} = {};`);
-						if (requireScopeUsed) {
-							buf2.push(
-								`__webpack_modules__[${moduleIdExpr}](0, ${
-									i === 0 ? RuntimeGlobals.exports : "{}"
-								}, ${RuntimeGlobals.require});`
-							);
-						} else if (entryRuntimeRequirements.has(RuntimeGlobals.exports)) {
-							buf2.push(
-								`__webpack_modules__[${moduleIdExpr}](0, ${
-									i === 0 ? RuntimeGlobals.exports : "{}"
-								});`
-							);
-						} else {
-							buf2.push(`__webpack_modules__[${moduleIdExpr}]();`);
+						const needThisAsExports = entryRuntimeRequirements.has(
+							RuntimeGlobals.thisAsExports
+						);
+
+						/** @type {string[]} */
+						const args = [];
+						if (
+							requireScopeUsed ||
+							entryRuntimeRequirements.has(RuntimeGlobals.exports)
+						) {
+							const exportsArg = i === 0 ? RuntimeGlobals.exports : "{}";
+							args.push("0", exportsArg);
+							if (requireScopeUsed) {
+								args.push(RuntimeGlobals.require);
+							}
 						}
+						buf2.push(
+							Template.asString(
+								(() => {
+									if (needThisAsExports) {
+										const comma = args.length ? "," : "";
+										return `__webpack_modules__[${moduleIdExpr}].call(${RuntimeGlobals.exports}${comma}${args.join(",")});`;
+									}
+									return `__webpack_modules__[${moduleIdExpr}](${args.join(",")});`;
+								})()
+							)
+						);
 					}
 				}
 				if (runtimeRequirements.has(RuntimeGlobals.onChunksLoaded)) {
@@ -1407,6 +1547,9 @@ class JavascriptModulesPlugin {
 		const needModuleLoaded = runtimeRequirements.has(
 			RuntimeGlobals.moduleLoaded
 		);
+		const needModuleDefer = runtimeRequirements.has(
+			RuntimeGlobals.makeDeferredNamespaceObject
+		);
 		const content = Template.asString([
 			"// Check if module is in cache",
 			"var cachedModule = __webpack_module_cache__[moduleId];",
@@ -1418,12 +1561,27 @@ class JavascriptModulesPlugin {
 					])
 				: Template.indent("return cachedModule.exports;"),
 			"}",
+			// Add helpful error message in development mode when module is not found
+			...(outputOptions.pathinfo
+				? [
+						"// Check if module exists (development only)",
+						"if (__webpack_modules__[moduleId] === undefined) {",
+						Template.indent([
+							'var e = new Error("Cannot find module \'" + moduleId + "\'");',
+							"e.code = 'MODULE_NOT_FOUND';",
+							"throw e;"
+						]),
+						"}"
+					]
+				: []),
 			"// Create a new module (and put it into the cache)",
 			"var module = __webpack_module_cache__[moduleId] = {",
 			Template.indent([
 				needModuleId ? "id: moduleId," : "// no module.id needed",
 				needModuleLoaded ? "loaded: false," : "// no module.loaded needed",
-				"exports: {}"
+				needModuleDefer
+					? "exports: __webpack_module_deferred_exports__[moduleId] || {}"
+					: "exports: {}"
 			]),
 			"};",
 			"",
@@ -1432,7 +1590,13 @@ class JavascriptModulesPlugin {
 						"// Execute the module function",
 						"var threw = true;",
 						"try {",
-						Template.indent([moduleExecution, "threw = false;"]),
+						Template.indent([
+							moduleExecution,
+							"threw = false;",
+							...(needModuleDefer
+								? ["delete __webpack_module_deferred_exports__[moduleId];"]
+								: [])
+						]),
 						"} finally {",
 						Template.indent([
 							"if(threw) delete __webpack_module_cache__[moduleId];"
@@ -1443,14 +1607,24 @@ class JavascriptModulesPlugin {
 					? Template.asString([
 							"// Execute the module function",
 							"try {",
-							Template.indent(moduleExecution),
+							Template.indent(
+								needModuleDefer
+									? [
+											moduleExecution,
+											"delete __webpack_module_deferred_exports__[moduleId];"
+										]
+									: moduleExecution
+							),
 							"} catch(e) {",
 							Template.indent(["module.error = e;", "throw e;"]),
 							"}"
 						])
 					: Template.asString([
 							"// Execute the module function",
-							moduleExecution
+							moduleExecution,
+							...(needModuleDefer
+								? ["delete __webpack_module_deferred_exports__[moduleId];"]
+								: [])
 						]),
 			needModuleLoaded
 				? Template.asString([
@@ -1470,6 +1644,7 @@ class JavascriptModulesPlugin {
 	}
 
 	/**
+	 * @param {Compilation} compilation compilation
 	 * @param {Module[]} allModules allModules
 	 * @param {MainRenderContext} renderContext renderContext
 	 * @param {Set<Module>} inlinedModules inlinedModules
@@ -1479,7 +1654,8 @@ class JavascriptModulesPlugin {
 	 * @param {boolean} hasChunkModules hasChunkModules
 	 * @returns {Map<Module, Source> | false} renamed inlined modules
 	 */
-	getRenamedInlineModule(
+	_getRenamedInlineModule(
+		compilation,
 		allModules,
 		renderContext,
 		inlinedModules,
@@ -1490,10 +1666,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
@@ -1506,27 +1681,35 @@ class JavascriptModulesPlugin {
 		const renamedInlinedModules = new Map();
 		const { runtimeTemplate } = renderContext;
 
-		/** @typedef {{ source: Source, module: Module, ast: any, variables: Set<Variable>, through: Set<Reference>, usedInNonInlined: Set<Variable>, moduleScope: Scope }} Info */
+		/** @typedef {{ source: Source, module: Module, ast: Program, variables: Set<Variable>, through: Set<Reference>, usedInNonInlined: Set<Variable>, moduleScope: Scope }} Info */
 		/** @type {Map<Module, Info>} */
 		const inlinedModulesToInfo = new Map();
 		/** @type {Set<string>} */
 		const nonInlinedModuleThroughIdentifiers = new Set();
-		/** @type {Map<Module, Source>} */
 
 		for (const m of allModules) {
 			const isInlinedModule = inlinedModules && inlinedModules.has(m);
 			const moduleSource = this.renderModule(
 				m,
-				chunkRenderContext,
-				hooks,
-				!isInlinedModule
+				{
+					...chunkRenderContext,
+					factory: !isInlinedModule,
+					inlinedInIIFE: false
+				},
+				hooks
 			);
 
 			if (!moduleSource) continue;
 			const code = /** @type {string} */ (moduleSource.source());
-			const ast = JavascriptParser._parse(code, {
-				sourceType: "auto"
-			});
+
+			const { ast } = JavascriptParser._parse(
+				code,
+				{
+					sourceType: "auto",
+					ranges: true
+				},
+				JavascriptParser._getModuleParseFunction(compilation, m)
+			);
 
 			const scopeManager = eslintScope.analyze(ast, {
 				ecmaVersion: 6,
@@ -1575,7 +1758,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) {
@@ -1583,12 +1766,6 @@ class JavascriptModulesPlugin {
 			}
 
 			for (const variable of info.variables) {
-				allUsedNames.add(variable.name);
-				const references = getAllReferences(variable);
-				const allIdentifiers = new Set(
-					references.map(r => r.identifier).concat(variable.identifiers)
-				);
-
 				const usedNamesInScopeInfo = new Map();
 				const ignoredScopes = new Set();
 
@@ -1601,6 +1778,10 @@ class JavascriptModulesPlugin {
 
 				if (allUsedNames.has(name) || usedNames.has(name)) {
 					const references = getAllReferences(variable);
+					const allIdentifiers = new Set([
+						...references.map((r) => r.identifier),
+						...variable.identifiers
+					]);
 					for (const ref of references) {
 						addScopeSymbols(
 							ref.from,
@@ -1635,9 +1816,8 @@ class JavascriptModulesPlugin {
 						}
 						source.replace(r[0], r[1] - 1, newName);
 					}
-				} else {
-					allUsedNames.add(name);
 				}
+				allUsedNames.add(name);
 			}
 
 			renamedInlinedModules.set(m, source);