webpack 5.39.1 → 5.42.0

package/README.md

@@ -40,7 +40,7 @@
 	</a>
   <h1>webpack</h1>
   <p>
-    webpack is a module bundler. Its main purpose is to bundle JavaScript files for usage in a browser, yet it is also capable of transforming, bundling, or packaging just about any resource or asset.
+    Webpack is a module bundler. Its main purpose is to bundle JavaScript files for usage in a browser, yet it is also capable of transforming, bundling, or packaging just about any resource or asset.
   </p>
 </div>
 
@@ -77,7 +77,7 @@ yarn add webpack --dev
 
 <h2 align="center">Introduction</h2>
 
-webpack is a bundler for modules. The main purpose is to bundle JavaScript
+Webpack is a bundler for modules. The main purpose is to bundle JavaScript
 files for usage in a browser, yet it is also capable of transforming, bundling,
 or packaging just about any resource or asset.
 
@@ -95,14 +95,14 @@ Check out webpack's quick [**Get Started**](https://webpack.js.org/guides/gettin
 
 ### Browser Compatibility
 
-webpack supports all browsers that are [ES5-compliant](https://kangax.github.io/compat-table/es5/) (IE8 and below are not supported).
-webpack also needs `Promise` for `import()` and `require.ensure()`. If you want to support older browsers, you will need to [load a polyfill](https://webpack.js.org/guides/shimming/) before using these expressions.
+Webpack supports all browsers that are [ES5-compliant](https://kangax.github.io/compat-table/es5/) (IE8 and below are not supported).
+Webpack also needs `Promise` for `import()` and `require.ensure()`. If you want to support older browsers, you will need to [load a polyfill](https://webpack.js.org/guides/shimming/) before using these expressions.
 
 <h2 align="center">Concepts</h2>
 
 ### [Plugins](https://webpack.js.org/plugins/)
 
-webpack has a [rich plugin
+Webpack has a [rich plugin
 interface](https://webpack.js.org/plugins/). Most of the features
 within webpack itself use this plugin interface. This makes webpack very
 **flexible**.
@@ -129,7 +129,7 @@ within webpack itself use this plugin interface. This makes webpack very
 
 ### [Loaders](https://webpack.js.org/loaders/)
 
-webpack enables the use of loaders to preprocess files. This allows you to bundle
+Webpack enables the use of loaders to preprocess files. This allows you to bundle
 **any static resource** way beyond JavaScript. You can easily [write your own
 loaders](https://webpack.js.org/api/loaders/) using Node.js.
 
@@ -249,23 +249,23 @@ or are automatically applied via regex from your webpack configuration.
 
 ### Performance
 
-webpack uses async I/O and has multiple caching levels. This makes webpack fast
+Webpack uses async I/O and has multiple caching levels. This makes webpack fast
 and incredibly **fast** on incremental compilations.
 
 ### Module Formats
 
-webpack supports ES2015+, CommonJS and AMD modules **out of the box**. It performs clever static
+Webpack supports ES2015+, CommonJS and AMD modules **out of the box**. It performs clever static
 analysis on the AST of your code. It even has an evaluation engine to evaluate
 simple expressions. This allows you to **support most existing libraries** out of the box.
 
 ### [Code Splitting](https://webpack.js.org/guides/code-splitting/)
 
-webpack allows you to split your codebase into multiple chunks. Chunks are
+Webpack allows you to split your codebase into multiple chunks. Chunks are
 loaded asynchronously at runtime. This reduces the initial loading time.
 
 ### [Optimizations](https://webpack.js.org/guides/production-build/)
 
-webpack can do many optimizations to **reduce the output size of your
+Webpack can do many optimizations to **reduce the output size of your
 JavaScript** by deduplicating frequently used modules, minifying, and giving
 you full control of what is loaded initially and what is loaded at runtime
 through code splitting. It can also make your code chunks **cache
@@ -287,7 +287,7 @@ Contributions go far beyond pull requests and commits. Although we love giving y
 - [Blogging, speaking about, or creating tutorials](https://github.com/webpack-contrib/awesome-webpack) about one of webpack's many features.
 - Helping others in our webpack [gitter channel](https://gitter.im/webpack/webpack).
 
-To get started have a look at our [documentation on contributing](https://github.com/webpack/webpack/blob/master/CONTRIBUTING.md).
+To get started have a look at our [documentation on contributing](https://github.com/webpack/webpack/blob/main/CONTRIBUTING.md).
 
 If you are worried or don't know where to start, you can **always** reach out to [Sean Larkin (@TheLarkInn) on Twitter](https://twitter.com/thelarkinn) or simply submit an issue and a maintainer can help give you guidance!
 
@@ -715,11 +715,11 @@ src="https://static.monei.net/monei-logo.svg" height="30" alt="MONEI"></a>
 [node-url]: https://nodejs.org
 [deps]: https://img.shields.io/david/webpack/webpack.svg
 [deps-url]: https://david-dm.org/webpack/webpack
-[tests]: https://img.shields.io/travis/webpack/webpack/master.svg
+[tests]: https://img.shields.io/travis/webpack/webpack/main.svg
 [tests-url]: https://travis-ci.org/webpack/webpack
 [prs]: https://img.shields.io/badge/PRs-welcome-brightgreen.svg
 [prs-url]: https://webpack.js.org/contribute/
-[builds-url]: https://ci.appveyor.com/project/sokra/webpack/branch/master
+[builds-url]: https://ci.appveyor.com/project/sokra/webpack/branch/main
 [builds]: https://ci.appveyor.com/api/projects/status/github/webpack/webpack?svg=true
 [builds2]: https://dev.azure.com/webpack/webpack/_apis/build/status/webpack.webpack
 [builds2-url]: https://dev.azure.com/webpack/webpack/_build/latest?definitionId=3

package/lib/Compiler.js

@@ -260,6 +260,8 @@ class Compiler {
 
 		/** @type {Compilation} */
 		this._lastCompilation = undefined;
+		/** @type {NormalModuleFactory} */
+		this._lastNormalModuleFactory = undefined;
 
 		/** @private @type {WeakMap<Source, { sizeOnlySource: SizeOnlySource, writtenTo: Map<string, number> }>} */
 		this._assetEmittingSourceCache = new WeakMap();
@@ -375,6 +377,14 @@ class Compiler {
 		}
 	}
 
+	// TODO webpack 6: solve this in a better way
+	_cleanupLastNormalModuleFactory() {
+		if (this._lastNormalModuleFactory !== undefined) {
+			this._lastNormalModuleFactory.cleanupForCache();
+			this._lastNormalModuleFactory = undefined;
+		}
+	}
+
 	/**
 	 * @param {WatchOptions} watchOptions the watcher's options
 	 * @param {Callback<Stats>} handler signals when the call finishes
@@ -1036,6 +1046,7 @@ ${other}`);
 	}
 
 	createNormalModuleFactory() {
+		this._cleanupLastNormalModuleFactory();
 		const normalModuleFactory = new NormalModuleFactory({
 			context: this.options.context,
 			fs: this.inputFileSystem,
@@ -1044,6 +1055,7 @@ ${other}`);
 			associatedObjectForCache: this.root,
 			layers: this.options.experiments.layers
 		});
+		this._lastNormalModuleFactory = normalModuleFactory;
 		this.hooks.normalModuleFactory.call(normalModuleFactory);
 		return normalModuleFactory;
 	}
@@ -1122,8 +1134,9 @@ ${other}`);
 			if (err) return callback(err);
 			// Get rid of reference to last compilation to avoid leaking memory
 			// We can't run this._cleanupLastCompilation() as the Stats to this compilation
-			// might be still in use. We try to get rid for the reference to the cache instead.
+			// might be still in use. We try to get rid of the reference to the cache instead.
 			this._lastCompilation = undefined;
+			this._lastNormalModuleFactory = undefined;
 			this.cache.shutdown(callback);
 		});
 	}

package/lib/ConditionalInitFragment.js

@@ -31,6 +31,9 @@ const wrapInCondition = (condition, source) => {
 	}
 };
 
+/**
+ * @typedef {GenerateContext} Context
+ */
 class ConditionalInitFragment extends InitFragment {
 	/**
 	 * @param {string|Source} content the source code that will be included as initialization code
@@ -53,16 +56,16 @@ class ConditionalInitFragment extends InitFragment {
 	}
 
 	/**
-	 * @param {GenerateContext} generateContext context for generate
+	 * @param {Context} context context
 	 * @returns {string|Source} the source code that will be included as initialization code
 	 */
-	getContent(generateContext) {
+	getContent(context) {
 		if (this.runtimeCondition === false || !this.content) return "";
 		if (this.runtimeCondition === true) return this.content;
-		const expr = generateContext.runtimeTemplate.runtimeConditionExpression({
-			chunkGraph: generateContext.chunkGraph,
-			runtimeRequirements: generateContext.runtimeRequirements,
-			runtime: generateContext.runtime,
+		const expr = context.runtimeTemplate.runtimeConditionExpression({
+			chunkGraph: context.chunkGraph,
+			runtimeRequirements: context.runtimeRequirements,
+			runtime: context.runtime,
 			runtimeCondition: this.runtimeCondition
 		});
 		if (expr === "true") return this.content;
@@ -70,16 +73,16 @@ class ConditionalInitFragment extends InitFragment {
 	}
 
 	/**
-	 * @param {GenerateContext} generateContext context for generate
+	 * @param {Context} context context
 	 * @returns {string|Source=} the source code that will be included at the end of the module
 	 */
-	getEndContent(generateContext) {
+	getEndContent(context) {
 		if (this.runtimeCondition === false || !this.endContent) return "";
 		if (this.runtimeCondition === true) return this.endContent;
-		const expr = generateContext.runtimeTemplate.runtimeConditionExpression({
-			chunkGraph: generateContext.chunkGraph,
-			runtimeRequirements: generateContext.runtimeRequirements,
-			runtime: generateContext.runtime,
+		const expr = context.runtimeTemplate.runtimeConditionExpression({
+			chunkGraph: context.chunkGraph,
+			runtimeRequirements: context.runtimeRequirements,
+			runtime: context.runtime,
 			runtimeCondition: this.runtimeCondition
 		});
 		if (expr === "true") return this.endContent;

package/lib/DependencyTemplate.js

@@ -11,7 +11,8 @@
 /** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./Dependency").RuntimeSpec} RuntimeSpec */
 /** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./InitFragment")} InitFragment */
+/** @typedef {import("./Generator").GenerateContext} GenerateContext */
+/** @template T @typedef {import("./InitFragment")<T>} InitFragment */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
@@ -25,7 +26,7 @@
  * @property {Set<string>} runtimeRequirements the requirements for runtime
  * @property {Module} module current module
  * @property {RuntimeSpec} runtime current runtimes, for which code is generated
- * @property {InitFragment[]} initFragments mutable array of init fragments for the current module
+ * @property {InitFragment<GenerateContext>[]} initFragments mutable array of init fragments for the current module
  * @property {ConcatenationScope=} concatenationScope when in a concatenated module, information about other concatenated modules
  */
 

package/lib/ExternalModule.js

@@ -7,6 +7,8 @@
 
 const { OriginalSource, RawSource } = require("webpack-sources");
 const ConcatenationScope = require("./ConcatenationScope");
+const { UsageState } = require("./ExportsInfo");
+const InitFragment = require("./InitFragment");
 const Module = require("./Module");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const Template = require("./Template");
@@ -22,6 +24,7 @@ const propertyAccess = require("./util/propertyAccess");
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./ExportsInfo")} ExportsInfo */
 /** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
@@ -31,16 +34,28 @@ const propertyAccess = require("./util/propertyAccess");
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("./WebpackError")} WebpackError */
+/** @typedef {import("./javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
 /** @typedef {import("./util/Hash")} Hash */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
 /**
  * @typedef {Object} SourceData
  * @property {boolean=} iife
  * @property {string=} init
  * @property {string} expression
+ * @property {InitFragment<ChunkRenderContext>[]=} chunkInitFragments
+ * @property {ReadonlySet<string>=} runtimeRequirements
  */
 
+const TYPES = new Set(["javascript"]);
+const RUNTIME_REQUIREMENTS = new Set([RuntimeGlobals.module]);
+const RUNTIME_REQUIREMENTS_FOR_SCRIPT = new Set([RuntimeGlobals.loadScript]);
+const RUNTIME_REQUIREMENTS_FOR_MODULE = new Set([
+	RuntimeGlobals.definePropertyGetters
+]);
+const EMPTY_RUNTIME_REQUIREMENTS = new Set([]);
+
 /**
  * @param {string|string[]} variableName the variable name or path
  * @param {string} type the module system
@@ -67,7 +82,7 @@ const getSourceForGlobalVariableExternal = (variableName, type) => {
 const getSourceForCommonJsExternal = moduleAndSpecifiers => {
 	if (!Array.isArray(moduleAndSpecifiers)) {
 		return {
-			expression: `require(${JSON.stringify(moduleAndSpecifiers)});`
+			expression: `require(${JSON.stringify(moduleAndSpecifiers)})`
 		};
 	}
 	const moduleName = moduleAndSpecifiers[0];
@@ -75,7 +90,37 @@ const getSourceForCommonJsExternal = moduleAndSpecifiers => {
 		expression: `require(${JSON.stringify(moduleName)})${propertyAccess(
 			moduleAndSpecifiers,
 			1
-		)};`
+		)}`
+	};
+};
+
+/**
+ * @param {string|string[]} moduleAndSpecifiers the module request
+ * @returns {SourceData} the generated source
+ */
+const getSourceForCommonJsExternalInNodeModule = moduleAndSpecifiers => {
+	const chunkInitFragments = [
+		new InitFragment(
+			'import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "module";\n',
+			InitFragment.STAGE_HARMONY_IMPORTS,
+			0,
+			"external module node-commonjs"
+		)
+	];
+	if (!Array.isArray(moduleAndSpecifiers)) {
+		return {
+			expression: `__WEBPACK_EXTERNAL_createRequire(import.meta.url)(${JSON.stringify(
+				moduleAndSpecifiers
+			)})`,
+			chunkInitFragments
+		};
+	}
+	const moduleName = moduleAndSpecifiers[0];
+	return {
+		expression: `__WEBPACK_EXTERNAL_createRequire(import.meta.url)(${JSON.stringify(
+			moduleName
+		)})${propertyAccess(moduleAndSpecifiers, 1)}`,
+		chunkInitFragments
 	};
 };
 
@@ -112,6 +157,91 @@ const getSourceForImportExternal = (moduleAndSpecifiers, runtimeTemplate) => {
 	};
 };
 
+class ModuleExternalInitFragment extends InitFragment {
+	constructor(id, request) {
+		const identifier = `__WEBPACK_EXTERNAL_MODULE_${Template.toIdentifier(
+			`${id}`
+		)}__`;
+		super(
+			`import * as ${identifier} from ${JSON.stringify(request)};\n`,
+			InitFragment.STAGE_HARMONY_IMPORTS,
+			0,
+			`external module import ${id}`
+		);
+		this._identifier = identifier;
+	}
+
+	getNamespaceIdentifier() {
+		return this._identifier;
+	}
+}
+
+const generateModuleRemapping = (input, exportsInfo, runtime) => {
+	if (exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused) {
+		const properties = [];
+		for (const exportInfo of exportsInfo.orderedExports) {
+			const used = exportInfo.getUsedName(exportInfo.name, runtime);
+			if (!used) continue;
+			const nestedInfo = exportInfo.getNestedExportsInfo();
+			if (nestedInfo) {
+				const nestedExpr = generateModuleRemapping(
+					`${input}${propertyAccess([exportInfo.name])}`,
+					nestedInfo
+				);
+				if (nestedExpr) {
+					properties.push(`[${JSON.stringify(used)}]: y(${nestedExpr})`);
+					continue;
+				}
+			}
+			properties.push(
+				`[${JSON.stringify(used)}]: () => ${input}${propertyAccess([
+					exportInfo.name
+				])}`
+			);
+		}
+		return `x({ ${properties.join(", ")} })`;
+	}
+};
+
+/**
+ * @param {string|number} id the module id
+ * @param {string|string[]} moduleAndSpecifiers the module request
+ * @param {ExportsInfo} exportsInfo exports info of this module
+ * @param {RuntimeSpec} runtime the runtime
+ * @returns {SourceData} the generated source
+ */
+const getSourceForModuleExternal = (
+	id,
+	moduleAndSpecifiers,
+	exportsInfo,
+	runtime
+) => {
+	if (!Array.isArray(moduleAndSpecifiers))
+		moduleAndSpecifiers = [moduleAndSpecifiers];
+	const initFragment = new ModuleExternalInitFragment(
+		id,
+		moduleAndSpecifiers[0]
+	);
+	const baseAccess = `${initFragment.getNamespaceIdentifier()}${propertyAccess(
+		moduleAndSpecifiers,
+		1
+	)}`;
+	const moduleRemapping = generateModuleRemapping(
+		baseAccess,
+		exportsInfo,
+		runtime
+	);
+	let expression = moduleRemapping || baseAccess;
+	return {
+		expression,
+		init: `var x = y => { var x = {}; ${RuntimeGlobals.definePropertyGetters}(x, y); return x; }\nvar y = x => () => x`,
+		runtimeRequirements: moduleRemapping
+			? RUNTIME_REQUIREMENTS_FOR_MODULE
+			: undefined,
+		chunkInitFragments: [initFragment]
+	};
+};
+
 /**
  * @param {string|string[]} urlAndGlobal the script request
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
@@ -144,7 +274,8 @@ const getSourceForScriptExternal = (urlAndGlobal, runtimeTemplate) => {
 			]
 		)}).then(${runtimeTemplate.returningFunction(
 			`${globalName}${propertyAccess(urlAndGlobal, 2)}`
-		)})`
+		)})`,
+		runtimeRequirements: RUNTIME_REQUIREMENTS_FOR_SCRIPT
 	};
 };
 
@@ -210,14 +341,6 @@ const getSourceForDefaultCase = (optional, request, runtimeTemplate) => {
 	};
 };
 
-const TYPES = new Set(["javascript"]);
-const RUNTIME_REQUIREMENTS = new Set([RuntimeGlobals.module]);
-const RUNTIME_REQUIREMENTS_FOR_SCRIPT = new Set([
-	RuntimeGlobals.module,
-	RuntimeGlobals.loadScript
-]);
-const RUNTIME_REQUIREMENTS_CONCATENATED = new Set([]);
-
 class ExternalModule extends Module {
 	constructor(request, type, userRequest) {
 		super("javascript/dynamic", null);
@@ -293,32 +416,49 @@ class ExternalModule extends Module {
 			exportsType: undefined
 		};
 		this.buildInfo = {
-			strict: this.externalType !== "this",
-			topLevelDeclarations: new Set()
+			strict: true,
+			topLevelDeclarations: new Set(),
+			module: compilation.outputOptions.module
 		};
+		const { request, externalType } = this._getRequestAndExternalType();
 		this.buildMeta.exportsType = "dynamic";
 		let canMangle = false;
 		this.clearDependenciesAndBlocks();
-		switch (this.externalType) {
+		switch (externalType) {
+			case "this":
+				this.buildInfo.strict = false;
+				break;
 			case "system":
-				if (!Array.isArray(this.request) || this.request.length === 1) {
+				if (!Array.isArray(request) || request.length === 1) {
 					this.buildMeta.exportsType = "namespace";
 					canMangle = true;
 				}
 				break;
+			case "module":
+				if (this.buildInfo.module) {
+					if (!Array.isArray(request) || request.length === 1) {
+						this.buildMeta.exportsType = "namespace";
+						canMangle = true;
+					}
+				} else {
+					this.buildMeta.async = true;
+					if (!Array.isArray(request) || request.length === 1) {
+						this.buildMeta.exportsType = "namespace";
+						canMangle = false;
+					}
+				}
+				break;
+			case "script":
 			case "promise":
 				this.buildMeta.async = true;
 				break;
 			case "import":
 				this.buildMeta.async = true;
-				if (!Array.isArray(this.request) || this.request.length === 1) {
+				if (!Array.isArray(request) || request.length === 1) {
 					this.buildMeta.exportsType = "namespace";
 					canMangle = false;
 				}
 				break;
-			case "script":
-				this.buildMeta.async = true;
-				break;
 		}
 		this.addDependency(new StaticExportsDependency(true, canMangle));
 		callback();
@@ -341,12 +481,16 @@ class ExternalModule extends Module {
 		return undefined;
 	}
 
-	getSourceData(runtimeTemplate, moduleGraph, chunkGraph) {
-		const request =
-			typeof this.request === "object" && !Array.isArray(this.request)
-				? this.request[this.externalType]
-				: this.request;
-		switch (this.externalType) {
+	_getRequestAndExternalType() {
+		let { request, externalType } = this;
+		if (typeof request === "object" && !Array.isArray(request))
+			request = request[externalType];
+		return { request, externalType };
+	}
+
+	_getSourceData(runtimeTemplate, moduleGraph, chunkGraph, runtime) {
+		const { request, externalType } = this._getRequestAndExternalType();
+		switch (externalType) {
 			case "this":
 			case "window":
 			case "self":
@@ -360,6 +504,10 @@ class ExternalModule extends Module {
 			case "commonjs2":
 			case "commonjs-module":
 				return getSourceForCommonJsExternal(request);
+			case "node-commonjs":
+				return this.buildInfo.module
+					? getSourceForCommonJsExternalInNodeModule(request)
+					: getSourceForCommonJsExternal(request);
 			case "amd":
 			case "amd-require":
 			case "umd":
@@ -377,12 +525,28 @@ class ExternalModule extends Module {
 			case "script":
 				return getSourceForScriptExternal(request, runtimeTemplate);
 			case "module":
+				if (!this.buildInfo.module) {
+					if (!runtimeTemplate.supportsDynamicImport()) {
+						throw new Error(
+							"The target environment doesn't support dynamic import() syntax so it's not possible to use external type 'module' within a script" +
+								(runtimeTemplate.supportsEcmaScriptModuleSyntax()
+									? "\nDid you mean to build a EcmaScript Module ('output.module: true')?"
+									: "")
+						);
+					}
+					return getSourceForImportExternal(request, runtimeTemplate);
+				}
 				if (!runtimeTemplate.supportsEcmaScriptModuleSyntax()) {
 					throw new Error(
 						"The target environment doesn't support EcmaScriptModule syntax so it's not possible to use external type 'module'"
 					);
 				}
-				throw new Error("Module external type is not implemented yet");
+				return getSourceForModuleExternal(
+					chunkGraph.getModuleId(this),
+					request,
+					moduleGraph.getExportsInfo(this),
+					runtime
+				);
 			case "var":
 			case "promise":
 			case "const":
@@ -405,12 +569,14 @@ class ExternalModule extends Module {
 		runtimeTemplate,
 		moduleGraph,
 		chunkGraph,
+		runtime,
 		concatenationScope
 	}) {
-		const sourceData = this.getSourceData(
+		const sourceData = this._getSourceData(
 			runtimeTemplate,
 			moduleGraph,
-			chunkGraph
+			chunkGraph,
+			runtime
 		);
 
 		let sourceString = sourceData.expression;
@@ -428,6 +594,12 @@ class ExternalModule extends Module {
 		}
 		if (sourceData.init) sourceString = `${sourceData.init}\n${sourceString}`;
 
+		let data = undefined;
+		if (sourceData.chunkInitFragments) {
+			data = new Map();
+			data.set("chunkInitFragments", sourceData.chunkInitFragments);
+		}
+
 		const sources = new Map();
 		if (this.useSourceMap || this.useSimpleSourceMap) {
 			sources.set(
@@ -438,13 +610,21 @@ class ExternalModule extends Module {
 			sources.set("javascript", new RawSource(sourceString));
 		}
 
+		let runtimeRequirements = sourceData.runtimeRequirements;
+		if (!concatenationScope) {
+			if (!runtimeRequirements) {
+				runtimeRequirements = RUNTIME_REQUIREMENTS;
+			} else {
+				const set = new Set(runtimeRequirements);
+				set.add(RuntimeGlobals.module);
+				runtimeRequirements = set;
+			}
+		}
+
 		return {
 			sources,
-			runtimeRequirements: concatenationScope
-				? RUNTIME_REQUIREMENTS_CONCATENATED
-				: this.externalType === "script"
-				? RUNTIME_REQUIREMENTS_FOR_SCRIPT
-				: RUNTIME_REQUIREMENTS
+			runtimeRequirements: runtimeRequirements || EMPTY_RUNTIME_REQUIREMENTS,
+			data
 		};
 	}
 

package/lib/ExternalModuleFactoryPlugin.js

@@ -172,13 +172,14 @@ class ExternalModuleFactoryPlugin {
 								cb
 							);
 						} else {
+							const dependencyType = dependency.category || "";
 							const promise = externals(
 								{
 									context,
 									request: dependency.request,
+									dependencyType,
 									contextInfo,
 									getResolve: options => (context, request, callback) => {
-										const dependencyType = dependency.category || "";
 										const resolveContext = {
 											fileDependencies: data.fileDependencies,
 											missingDependencies: data.missingDependencies,

package/lib/InitFragment.js

@@ -30,6 +30,9 @@ const sortFragmentWithIndex = ([a, i], [b, j]) => {
 	return i - j;
 };
 
+/**
+ * @template Context
+ */
 class InitFragment {
 	/**
 	 * @param {string|Source} content the source code that will be included as initialization code
@@ -47,22 +50,22 @@ class InitFragment {
 	}
 
 	/**
-	 * @param {GenerateContext} generateContext context for generate
+	 * @param {Context} context context
 	 * @returns {string|Source} the source code that will be included as initialization code
 	 */
-	getContent(generateContext) {
+	getContent(context) {
 		return this.content;
 	}
 
 	/**
-	 * @param {GenerateContext} generateContext context for generate
+	 * @param {Context} context context
 	 * @returns {string|Source=} the source code that will be included at the end of the module
 	 */
-	getEndContent(generateContext) {
+	getEndContent(context) {
 		return this.endContent;
 	}
 
-	static addToSource(source, initFragments, generateContext) {
+	static addToSource(source, initFragments, context) {
 		if (initFragments.length > 0) {
 			// Sort fragments by position. If 2 fragments have the same position,
 			// use their index.
@@ -104,8 +107,8 @@ class InitFragment {
 				if (Array.isArray(fragment)) {
 					fragment = fragment[0].mergeAll(fragment);
 				}
-				concatSource.add(fragment.getContent(generateContext));
-				const endContent = fragment.getEndContent(generateContext);
+				concatSource.add(fragment.getContent(context));
+				const endContent = fragment.getEndContent(context);
 				if (endContent) {
 					endContents.push(endContent);
 				}

package/lib/MainTemplate.js

@@ -20,7 +20,7 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./Module")} Module} */
 /** @typedef {import("./util/Hash")} Hash} */
 /** @typedef {import("./DependencyTemplates")} DependencyTemplates} */
-/** @typedef {import("./ModuleTemplate").RenderContext} RenderContext} */
+/** @typedef {import("./javascript/JavascriptModulesPlugin").RenderContext} RenderContext} */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate} */
 /** @typedef {import("./ModuleGraph")} ModuleGraph} */
 /** @typedef {import("./ChunkGraph")} ChunkGraph} */