webpack 5.21.0 → 5.23.0

package/lib/javascript/JavascriptModulesPlugin.js

@@ -18,6 +18,7 @@ const { tryRunOrWebpackError } = require("../HookWebpackError");
 const HotUpdateChunk = require("../HotUpdateChunk");
 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 createHash = require("../util/createHash");
@@ -37,19 +38,6 @@ const JavascriptParser = require("./JavascriptParser");
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../util/Hash")} Hash */
 
-/**
- * @template T
- * @param {Iterable<T>} iterable iterable
- * @param {function(T): boolean} filter predicate
- * @returns {boolean} true, if some items match the filter predicate
- */
-const someInIterable = (iterable, filter) => {
-	for (const item of iterable) {
-		if (filter(item)) return true;
-	}
-	return false;
-};
-
 /**
  * @param {Chunk} chunk a chunk
  * @param {ChunkGraph} chunkGraph the chunk graph
@@ -93,6 +81,8 @@ const chunkHasJs = (chunk, chunkGraph) => {
  * @property {string} hash hash to be used for render call
  */
 
+/** @typedef {RenderContext & { inlined: boolean }} StartupRenderContext */
+
 /**
  * @typedef {Object} CompilationHooks
  * @property {SyncWaterfallHook<[Source, Module, RenderContext]>} renderModuleContent
@@ -101,7 +91,10 @@ const chunkHasJs = (chunk, chunkGraph) => {
  * @property {SyncWaterfallHook<[Source, RenderContext]>} renderChunk
  * @property {SyncWaterfallHook<[Source, RenderContext]>} renderMain
  * @property {SyncWaterfallHook<[Source, RenderContext]>} render
+ * @property {SyncWaterfallHook<[Source, Module, StartupRenderContext]>} renderStartup
  * @property {SyncWaterfallHook<[string, RenderBootstrapContext]>} renderRequire
+ * @property {SyncBailHook<[Module, RenderBootstrapContext], string>} inlineInRuntimeBailout
+ * @property {SyncBailHook<[Module, RenderContext], string>} embedInRuntimeBailout
  * @property {SyncHook<[Chunk, Hash, ChunkHashContext]>} chunkHash
  * @property {SyncBailHook<[Chunk, RenderContext], boolean>} useSourceMap
  */
@@ -139,9 +132,16 @@ class JavascriptModulesPlugin {
 					"renderContext"
 				]),
 				render: new SyncWaterfallHook(["source", "renderContext"]),
+				renderStartup: new SyncWaterfallHook([
+					"source",
+					"module",
+					"startupRenderContext"
+				]),
 				renderChunk: new SyncWaterfallHook(["source", "renderContext"]),
 				renderMain: new SyncWaterfallHook(["source", "renderContext"]),
 				renderRequire: new SyncWaterfallHook(["code", "renderContext"]),
+				inlineInRuntimeBailout: new SyncBailHook(["module", "renderContext"]),
+				embedInRuntimeBailout: new SyncBailHook(["module", "renderContext"]),
 				chunkHash: new SyncHook(["chunk", "hash", "context"]),
 				useSourceMap: new SyncBailHook(["chunk", "renderContext"])
 			};
@@ -641,6 +641,9 @@ class JavascriptModulesPlugin {
 					)
 				);
 			}
+			const lastInlinedModule = last(inlinedModules);
+			const startupSource = new ConcatSource();
+			startupSource.add(`var __webpack_exports__ = {};\n`);
 			for (const m of inlinedModules) {
 				const renderedModule = this.renderModule(
 					m,
@@ -650,25 +653,59 @@ class JavascriptModulesPlugin {
 				);
 				if (renderedModule) {
 					const innerStrict = !allStrict && m.buildInfo.strict;
-					const iife = innerStrict || inlinedModules.size > 1 || chunkModules;
-					if (iife) {
-						if (runtimeTemplate.supportsArrowFunction()) {
-							source.add("(() => {\n");
-							if (innerStrict) source.add('"use strict";\n');
-							source.add(renderedModule);
-							source.add("\n})();\n\n");
+					const runtimeRequirements = chunkGraph.getModuleRuntimeRequirements(
+						m,
+						chunk.runtime
+					);
+					const exports = runtimeRequirements.has(RuntimeGlobals.exports);
+					const webpackExports =
+						exports && m.exportsArgument === "__webpack_exports__";
+					let iife = innerStrict
+						? "it need 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 need to be isolated against other entry modules."
+						: chunkModules
+						? "it need 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(
+							`// This entry need to be wrapped in an IIFE because ${iife}\n`
+						);
+						const arrow = runtimeTemplate.supportsArrowFunction();
+						if (arrow) {
+							startupSource.add("(() => {\n");
+							footer = "\n})();\n\n";
 						} else {
-							source.add("!function() {\n");
-							if (innerStrict) source.add('"use strict";\n');
-							source.add(renderedModule);
-							source.add("\n}();\n");
+							startupSource.add("!function() {\n");
+							footer = "\n}();\n";
 						}
+						if (innerStrict) startupSource.add('"use strict";\n');
 					} else {
-						source.add(renderedModule);
-						source.add("\n");
+						footer = "\n";
+					}
+					if (exports) {
+						if (m !== lastInlinedModule)
+							startupSource.add(`var ${m.exportsArgument} = {};\n`);
+						else if (m.exportsArgument !== "__webpack_exports__")
+							startupSource.add(
+								`var ${m.exportsArgument} = __webpack_exports__;\n`
+							);
 					}
+					startupSource.add(renderedModule);
+					startupSource.add(footer);
 				}
 			}
+			source.add(
+				hooks.renderStartup.call(startupSource, lastInlinedModule, {
+					...renderContext,
+					inlined: true
+				})
+			);
 			if (bootstrap.afterStartup.length > 0) {
 				const afterStartup = Template.asString(bootstrap.afterStartup) + "\n";
 				source.add(
@@ -681,21 +718,36 @@ class JavascriptModulesPlugin {
 				);
 			}
 		} else {
-			const startup =
-				Template.asString([
-					...bootstrap.beforeStartup,
-					...bootstrap.startup,
-					...bootstrap.afterStartup
-				]) + "\n";
+			const lastEntryModule = last(
+				chunkGraph.getChunkEntryModulesIterable(chunk)
+			);
+			const toSource = useSourceMap
+				? (content, name) =>
+						new OriginalSource(Template.asString(content), name)
+				: content => new RawSource(Template.asString(content));
 			source.add(
 				new PrefixSource(
 					prefix,
-					useSourceMap
-						? new OriginalSource(startup, "webpack/startup")
-						: new RawSource(startup)
+					new ConcatSource(
+						toSource(bootstrap.beforeStartup, "webpack/before-startup"),
+						"\n",
+						hooks.renderStartup.call(
+							toSource(bootstrap.startup.concat(""), "webpack/startup"),
+							lastEntryModule,
+							{
+								...renderContext,
+								inlined: false
+							}
+						),
+						toSource(bootstrap.afterStartup, "webpack/after-startup"),
+						"\n"
+					)
 				)
 			);
 		}
+		if (runtimeRequirements.has(RuntimeGlobals.returnExportsFromRuntime)) {
+			source.add(`${prefix}return __webpack_exports__;\n`);
+		}
 		if (iife) {
 			source.add("/******/ })()\n");
 		}
@@ -758,23 +810,15 @@ class JavascriptModulesPlugin {
 			RuntimeGlobals.moduleFactories
 		);
 		const moduleUsed = runtimeRequirements.has(RuntimeGlobals.module);
-		const exportsUsed = runtimeRequirements.has(RuntimeGlobals.exports);
 		const requireScopeUsed = runtimeRequirements.has(
 			RuntimeGlobals.requireScope
 		);
 		const interceptModuleExecution = runtimeRequirements.has(
 			RuntimeGlobals.interceptModuleExecution
 		);
-		const returnExportsFromRuntime = runtimeRequirements.has(
-			RuntimeGlobals.returnExportsFromRuntime
-		);
 
 		const useRequire =
-			requireFunction ||
-			interceptModuleExecution ||
-			returnExportsFromRuntime ||
-			moduleUsed ||
-			exportsUsed;
+			requireFunction || interceptModuleExecution || moduleUsed;
 
 		const result = {
 			header: [],
@@ -802,12 +846,6 @@ class JavascriptModulesPlugin {
 			);
 			result.allowInlineStartup = false;
 		}
-		if (result.allowInlineStartup && returnExportsFromRuntime) {
-			startup.push(
-				"// module exports must be returned from runtime so entry inlining is disabled"
-			);
-			result.allowInlineStartup = false;
-		}
 
 		if (useRequire || moduleCache) {
 			buf.push("// The module cache");
@@ -848,7 +886,6 @@ class JavascriptModulesPlugin {
 			buf.push("");
 		}
 
-		const maybeReturn = returnExportsFromRuntime ? "return " : "";
 		if (!runtimeRequirements.has(RuntimeGlobals.startupNoDefault)) {
 			if (chunkGraph.getNumberOfEntryModules(chunk) > 0) {
 				/** @type {string[]} */
@@ -856,11 +893,7 @@ class JavascriptModulesPlugin {
 				const runtimeRequirements = chunkGraph.getTreeRuntimeRequirements(
 					chunk
 				);
-				buf2.push(
-					returnExportsFromRuntime
-						? "// Load entry module and return exports"
-						: "// Load entry module"
-				);
+				buf2.push("// Load entry module and return exports");
 				let i = chunkGraph.getNumberOfEntryModules(chunk);
 				for (const entryModule of chunkGraph.getChunkEntryModulesIterable(
 					chunk
@@ -884,8 +917,29 @@ class JavascriptModulesPlugin {
 						);
 						result.allowInlineStartup = false;
 					}
-					const mayReturn =
-						--i === 0 && returnExportsFromRuntime ? "return " : "";
+					if (
+						result.allowInlineStartup &&
+						(!entryModule.buildInfo ||
+							!entryModule.buildInfo.topLevelDeclarations)
+					) {
+						buf2.push(
+							"// This entry module doesn't tell about it's top-level declarations so it can't be inlined"
+						);
+						result.allowInlineStartup = false;
+					}
+					if (result.allowInlineStartup) {
+						const bailout = hooks.inlineInRuntimeBailout.call(
+							entryModule,
+							renderContext
+						);
+						if (bailout !== undefined) {
+							buf2.push(
+								`// This entry module can't be inlined because ${bailout}`
+							);
+							result.allowInlineStartup = false;
+						}
+					}
+					i--;
 					const moduleId = chunkGraph.getModuleId(entryModule);
 					const entryRuntimeRequirements = chunkGraph.getModuleRuntimeRequirements(
 						entryModule,
@@ -896,45 +950,56 @@ class JavascriptModulesPlugin {
 						moduleIdExpr = `${RuntimeGlobals.entryModuleId} = ${moduleIdExpr}`;
 					}
 					if (useRequire) {
-						buf2.push(`${mayReturn}__webpack_require__(${moduleIdExpr});`);
+						buf2.push(
+							`${
+								i === 0 ? "var __webpack_exports__ = " : ""
+							}__webpack_require__(${moduleIdExpr});`
+						);
 						if (result.allowInlineStartup) {
 							if (entryRuntimeRequirements.has(RuntimeGlobals.module)) {
 								result.allowInlineStartup = false;
 								buf2.push(
 									"// This entry module used 'module' so it can't be inlined"
 								);
-							} else if (entryRuntimeRequirements.has(RuntimeGlobals.exports)) {
-								buf2.push(
-									"// This entry module used 'exports' so it can't be inlined"
-								);
-								result.allowInlineStartup = false;
 							}
 						}
-					} else if (requireScopeUsed) {
-						buf2.push(
-							`__webpack_modules__[${moduleIdExpr}](0, 0, __webpack_require__);`
-						);
 					} else {
-						buf2.push(`__webpack_modules__[${moduleIdExpr}]();`);
+						if (i === 0) buf2.push("var __webpack_exports__ = {};");
+						if (requireScopeUsed) {
+							buf2.push(
+								`__webpack_modules__[${moduleIdExpr}](0, ${
+									i === 0 ? "__webpack_exports__" : "{}"
+								}, __webpack_require__);`
+							);
+						} else if (entryRuntimeRequirements.has(RuntimeGlobals.exports)) {
+							buf2.push(
+								`__webpack_modules__[${moduleIdExpr}](0, ${
+									i === 0 ? "__webpack_exports__" : "{}"
+								});`
+							);
+						} else {
+							buf2.push(`__webpack_modules__[${moduleIdExpr}]();`);
+						}
 					}
 				}
 				if (
 					runtimeRequirements.has(RuntimeGlobals.startup) ||
-					((returnExportsFromRuntime ||
-						runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore)) &&
+					(runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore) &&
 						runtimeRequirements.has(RuntimeGlobals.startupOnlyAfter))
 				) {
 					result.allowInlineStartup = false;
 					buf.push("// the startup function");
 					buf.push(
-						`${RuntimeGlobals.startup} = ${runtimeTemplate.basicFunction(
-							"",
-							buf2
-						)};`
+						`${RuntimeGlobals.startup} = ${runtimeTemplate.basicFunction("", [
+							...buf2,
+							"return __webpack_exports__;"
+						])};`
 					);
 					buf.push("");
 					startup.push("// run startup");
-					startup.push(`${maybeReturn}${RuntimeGlobals.startup}();`);
+					startup.push(
+						`var __webpack_exports__ = ${RuntimeGlobals.startup}();`
+					);
 				} else if (runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore)) {
 					buf.push("// the startup function");
 					buf.push(
@@ -952,7 +1017,7 @@ class JavascriptModulesPlugin {
 					startup.push("// startup");
 					startup.push(Template.asString(buf2));
 					afterStartup.push("// run runtime startup");
-					afterStartup.push(`${maybeReturn}${RuntimeGlobals.startup}();`);
+					afterStartup.push(`${RuntimeGlobals.startup}();`);
 				} else {
 					startup.push("// startup");
 					startup.push(Template.asString(buf2));
@@ -981,7 +1046,7 @@ class JavascriptModulesPlugin {
 				`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()};`
 			);
 			startup.push("// run startup");
-			startup.push(`${maybeReturn}${RuntimeGlobals.startup}();`);
+			startup.push(`var __webpack_exports__ = ${RuntimeGlobals.startup}();`);
 		}
 		return result;
 	}

package/lib/javascript/JavascriptParser.js

@@ -224,6 +224,7 @@ class JavascriptParser extends Parser {
 			varDeclarationConst: new HookMap(() => new SyncBailHook(["declaration"])),
 			/** @type {HookMap<SyncBailHook<[DeclarationNode], boolean | void>>} */
 			varDeclarationVar: new HookMap(() => new SyncBailHook(["declaration"])),
+			/** @type {HookMap<SyncBailHook<[IdentifierNode], boolean | void>>} */
 			pattern: new HookMap(() => new SyncBailHook(["pattern"])),
 			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
 			canRename: new HookMap(() => new SyncBailHook(["initExpression"])),

package/lib/json/JsonGenerator.js

@@ -38,14 +38,13 @@ const stringifySafe = data => {
 const createObjectForExportsInfo = (data, exportsInfo, runtime) => {
 	if (exportsInfo.otherExportsInfo.getUsed(runtime) !== UsageState.Unused)
 		return data;
-	const reducedData = Array.isArray(data) ? [] : {};
-	for (const exportInfo of exportsInfo.exports) {
-		if (exportInfo.name in reducedData) return data;
-	}
+	const isArray = Array.isArray(data);
+	const reducedData = isArray ? [] : {};
 	for (const key of Object.keys(data)) {
 		const exportInfo = exportsInfo.getReadOnlyExportInfo(key);
 		const used = exportInfo.getUsed(runtime);
 		if (used === UsageState.Unused) continue;
+
 		let value;
 		if (used === UsageState.OnlyPropertiesUsed && exportInfo.exportsInfo) {
 			value = createObjectForExportsInfo(
@@ -59,7 +58,13 @@ const createObjectForExportsInfo = (data, exportsInfo, runtime) => {
 		const name = exportInfo.getUsedName(key, runtime);
 		reducedData[name] = value;
 	}
-	if (Array.isArray(reducedData)) {
+	if (isArray) {
+		let arrayLengthWhenUsed =
+			exportsInfo.getReadOnlyExportInfo("length").getUsed(runtime) !==
+			UsageState.Unused
+				? data.length
+				: undefined;
+
 		let sizeObjectMinusArray = 0;
 		for (let i = 0; i < reducedData.length; i++) {
 			if (reducedData[i] === undefined) {
@@ -68,8 +73,24 @@ const createObjectForExportsInfo = (data, exportsInfo, runtime) => {
 				sizeObjectMinusArray += `${i}`.length + 3;
 			}
 		}
-		if (sizeObjectMinusArray < 0) return Object.assign({}, reducedData);
-		for (let i = 0; i < reducedData.length; i++) {
+		if (arrayLengthWhenUsed !== undefined) {
+			sizeObjectMinusArray +=
+				`${arrayLengthWhenUsed}`.length +
+				8 -
+				(arrayLengthWhenUsed - reducedData.length) * 2;
+		}
+		if (sizeObjectMinusArray < 0)
+			return Object.assign(
+				arrayLengthWhenUsed === undefined
+					? {}
+					: { length: arrayLengthWhenUsed },
+				reducedData
+			);
+		const generatedLength =
+			arrayLengthWhenUsed !== undefined
+				? Math.max(arrayLengthWhenUsed, reducedData.length)
+				: reducedData.length;
+		for (let i = 0; i < generatedLength; i++) {
 			if (reducedData[i] === undefined) {
 				reducedData[i] = 0;
 			}
@@ -143,7 +164,7 @@ class JsonGenerator extends Generator {
 		const jsonStr = stringifySafe(finalJson);
 		const jsonExpr =
 			jsonStr.length > 20 && typeof finalJson === "object"
-				? `JSON.parse(${JSON.stringify(jsonStr)})`
+				? `JSON.parse('${jsonStr.replace(/[\\']/g, "\\$&")}')`
 				: jsonStr;
 		let content;
 		if (concatenationScope) {

package/lib/library/AbstractLibraryPlugin.js

@@ -17,8 +17,12 @@ const JavascriptModulesPlugin = require("../javascript/JavascriptModulesPlugin")
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
 /** @typedef {import("../util/Hash")} Hash */
 
+const COMMON_LIBRARY_NAME_MESSAGE =
+	"Common configuration options that specific library names are 'output.library[.name]', 'entry.xyz.library[.name]', 'ModuleFederationPlugin.name' and 'ModuleFederationPlugin.library[.name]'.";
+
 /**
  * @template T
  * @typedef {Object} LibraryContext
@@ -49,28 +53,36 @@ class AbstractLibraryPlugin {
 	apply(compiler) {
 		const { _pluginName } = this;
 		compiler.hooks.thisCompilation.tap(_pluginName, compilation => {
-			compilation.hooks.finishModules.tap(_pluginName, () => {
-				for (const [
-					name,
-					{
-						dependencies: deps,
-						options: { library }
-					}
-				] of compilation.entries) {
-					const options = this._parseOptionsCached(
-						library !== undefined ? library : compilation.outputOptions.library
-					);
-					if (options !== false) {
-						const dep = deps[deps.length - 1];
-						if (dep) {
-							const module = compilation.moduleGraph.getModule(dep);
-							if (module) {
-								this.finishEntryModule(module, name, { options, compilation });
+			compilation.hooks.finishModules.tap(
+				{ name: _pluginName, stage: 10 },
+				() => {
+					for (const [
+						name,
+						{
+							dependencies: deps,
+							options: { library }
+						}
+					] of compilation.entries) {
+						const options = this._parseOptionsCached(
+							library !== undefined
+								? library
+								: compilation.outputOptions.library
+						);
+						if (options !== false) {
+							const dep = deps[deps.length - 1];
+							if (dep) {
+								const module = compilation.moduleGraph.getModule(dep);
+								if (module) {
+									this.finishEntryModule(module, name, {
+										options,
+										compilation
+									});
+								}
 							}
 						}
 					}
 				}
-			});
+			);
 
 			const getOptionsForChunk = chunk => {
 				if (compilation.chunkGraph.getNumberOfEntryModules(chunk) === 0)
@@ -82,23 +94,64 @@ class AbstractLibraryPlugin {
 				);
 			};
 
-			compilation.hooks.additionalChunkRuntimeRequirements.tap(
-				_pluginName,
-				(chunk, set) => {
-					const options = getOptionsForChunk(chunk);
-					if (options !== false) {
-						this.runtimeRequirements(chunk, set, { options, compilation });
+			if (
+				this.render !== AbstractLibraryPlugin.prototype.render ||
+				this.runtimeRequirements !==
+					AbstractLibraryPlugin.prototype.runtimeRequirements
+			) {
+				compilation.hooks.additionalChunkRuntimeRequirements.tap(
+					_pluginName,
+					(chunk, set) => {
+						const options = getOptionsForChunk(chunk);
+						if (options !== false) {
+							this.runtimeRequirements(chunk, set, { options, compilation });
+						}
 					}
-				}
-			);
+				);
+			}
 
 			const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
 
-			hooks.render.tap(_pluginName, (source, renderContext) => {
-				const options = getOptionsForChunk(renderContext.chunk);
-				if (options === false) return source;
-				return this.render(source, renderContext, { options, compilation });
-			});
+			if (this.render !== AbstractLibraryPlugin.prototype.render) {
+				hooks.render.tap(_pluginName, (source, renderContext) => {
+					const options = getOptionsForChunk(renderContext.chunk);
+					if (options === false) return source;
+					return this.render(source, renderContext, { options, compilation });
+				});
+			}
+
+			if (
+				this.embedInRuntimeBailout !==
+				AbstractLibraryPlugin.prototype.embedInRuntimeBailout
+			) {
+				hooks.embedInRuntimeBailout.tap(
+					_pluginName,
+					(module, renderContext) => {
+						const options = getOptionsForChunk(renderContext.chunk);
+						if (options === false) return;
+						return this.embedInRuntimeBailout(module, renderContext, {
+							options,
+							compilation
+						});
+					}
+				);
+			}
+
+			if (
+				this.renderStartup !== AbstractLibraryPlugin.prototype.renderStartup
+			) {
+				hooks.renderStartup.tap(
+					_pluginName,
+					(source, module, renderContext) => {
+						const options = getOptionsForChunk(renderContext.chunk);
+						if (options === false) return source;
+						return this.renderStartup(source, module, renderContext, {
+							options,
+							compilation
+						});
+					}
+				);
+			}
 
 			hooks.chunkHash.tap(_pluginName, (chunk, hash, context) => {
 				const options = getOptionsForChunk(chunk);
@@ -141,6 +194,16 @@ class AbstractLibraryPlugin {
 	 */
 	finishEntryModule(module, entryName, libraryContext) {}
 
+	/**
+	 * @param {Module} module the exporting entry module
+	 * @param {RenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {string | undefined} bailout reason
+	 */
+	embedInRuntimeBailout(module, renderContext, libraryContext) {
+		return undefined;
+	}
+
 	/**
 	 * @param {Chunk} chunk the chunk
 	 * @param {Set<string>} set runtime requirements
@@ -148,7 +211,8 @@ class AbstractLibraryPlugin {
 	 * @returns {void}
 	 */
 	runtimeRequirements(chunk, set, libraryContext) {
-		set.add(RuntimeGlobals.returnExportsFromRuntime);
+		if (this.render !== AbstractLibraryPlugin.prototype.render)
+			set.add(RuntimeGlobals.returnExportsFromRuntime);
 	}
 
 	/**
@@ -161,6 +225,17 @@ class AbstractLibraryPlugin {
 		return source;
 	}
 
+	/**
+	 * @param {Source} source source
+	 * @param {Module} module module
+	 * @param {StartupRenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {Source} source with library export
+	 */
+	renderStartup(source, module, renderContext, libraryContext) {
+		return source;
+	}
+
 	/**
 	 * @param {Chunk} chunk the chunk
 	 * @param {Hash} hash hash
@@ -177,4 +252,5 @@ class AbstractLibraryPlugin {
 	}
 }
 
+AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE = COMMON_LIBRARY_NAME_MESSAGE;
 module.exports = AbstractLibraryPlugin;

package/lib/library/AmdLibraryPlugin.js

@@ -55,11 +55,15 @@ class AmdLibraryPlugin extends AbstractLibraryPlugin {
 		const { name } = library;
 		if (this.requireAsWrapper) {
 			if (name) {
-				throw new Error("AMD library name must be unset");
+				throw new Error(
+					`AMD library name must be unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
+				);
 			}
 		} else {
 			if (name && typeof name !== "string") {
-				throw new Error("AMD library name must be a simple string or unset");
+				throw new Error(
+					`AMD library name must be a simple string or unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
+				);
 			}
 		}
 		return {
@@ -99,10 +103,12 @@ class AmdLibraryPlugin extends AbstractLibraryPlugin {
 			)
 			.join(", ");
 
-		const fnStart = modern
-			? `(${externalsArguments}) => `
-			: `function(${externalsArguments}) { return `;
-		const fnEnd = modern ? "" : "}";
+		const iife = runtimeTemplate.isIIFE();
+		const fnStart =
+			(modern
+				? `(${externalsArguments}) => {`
+				: `function(${externalsArguments}) {`) + (iife ? " return " : "\n");
+		const fnEnd = iife ? ";\n}" : "\n}";
 
 		if (this.requireAsWrapper) {
 			return new ConcatSource(