@depup/webpack 5.109.2-depup.0 → 5.110.3-depup.0

package/lib/library/ModuleLibraryPlugin.js

@@ -8,32 +8,48 @@
 const { ConcatSource } = require("webpack-sources");
 const { UsageState } = require("../ExportsInfo");
 const ExternalModule = require("../ExternalModule");
+const { JAVASCRIPT_TYPE } = require("../ModuleSourceTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
+const HarmonyExportExpressionDependency = require("../dependencies/HarmonyExportExpressionDependency");
 const HarmonyExportImportedSpecifierDependency = require("../dependencies/HarmonyExportImportedSpecifierDependency");
 const HarmonyExportSpecifierDependency = require("../dependencies/HarmonyExportSpecifierDependency");
 const JavascriptModulesPlugin = require("../javascript/JavascriptModulesPlugin");
 const ConcatenatedModule = require("../optimize/ConcatenatedModule");
 const { InlinedUsedName } = require("../optimize/InlineExports");
-const { propertyAccess } = require("../util/property");
+const {
+	RESERVED_IDENTIFIER,
+	SAFE_IDENTIFIER,
+	propertyAccess
+} = require("../util/property");
 const { getEntryRuntime, getRuntimeKey } = require("../util/runtime");
 const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryExport} LibraryExport */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../Module").BuildMeta} BuildMeta */
-/** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").ModuleRenderContext} ModuleRenderContext */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../javascript/JavascriptModule").JavascriptModuleBuildMeta} JavascriptModuleBuildMeta */
+/** @import { Source } from "webpack-sources" */
+/**
+ * @import {
+ * 	LibraryOptions,
+ * 	LibraryType,
+ * 	LibraryExport
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import Chunk from "../Chunk" */
+/** @import Compilation from "../Compilation" */
+/** @import Compiler from "../Compiler" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import Module, { BuildMeta } from "../Module" */
+/**
+ * @import {
+ * 	StartupRenderContext,
+ * 	ModuleRenderContext
+ * } from "../javascript/JavascriptModulesPlugin"
+ */
+/** @import { RuntimeSpec } from "../util/runtime" */
+/**
+ * @import {
+ * 	JavascriptModuleBuildMeta
+ * } from "../javascript/JavascriptModule"
+ */
 
 /**
  * Defines the shared type used by this module.
@@ -56,6 +72,64 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 
 const PLUGIN_NAME = "ModuleLibraryPlugin";
 
+/**
+ * The entry modules this plugin renders `export { … }` for, per compilation — the
+ * only ones whose export definitions may be taken over.
+ * @type {WeakMap<Compilation, WeakSet<Module>>}
+ */
+const libraryEntryModules = new WeakMap();
+
+/**
+ * Whether every export the module defines is a binding the library can export
+ * natively, so the definitions written into the exports object are read by nobody.
+ * A re-export or a renamed import is not: `renderStartup` reads those back off the
+ * object, and `treatAsCommonJs` hands the object out as the default export.
+ * @param {Module} module the entry module
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @returns {boolean} true when the definitions may be taken over
+ */
+const definesOnlyNativeExports = (module, moduleGraph) => {
+	const buildMeta = /** @type {JavascriptModuleBuildMeta} */ (module.buildMeta);
+	if (buildMeta && buildMeta.treatAsCommonJs) return false;
+	// A top-level `await` wraps the body in `__webpack_require__.a`, and the
+	// definitions read declarations inside that wrapper — re-emitting them after the
+	// module would put them out of scope.
+	if (moduleGraph.isAsync(module)) return false;
+	const topLevelDeclarations =
+		module.buildInfo && module.buildInfo.topLevelDeclarations;
+	if (!topLevelDeclarations) return false;
+	for (const dep of module.dependencies) {
+		// A re-export or an `export default` has no declaration of its own to bind to,
+		// so `renderStartup` reads its value back off the exports object.
+		if (
+			dep instanceof HarmonyExportImportedSpecifierDependency ||
+			dep instanceof HarmonyExportExpressionDependency
+		) {
+			return false;
+		}
+		if (!(dep instanceof HarmonyExportSpecifierDependency)) continue;
+		if (!topLevelDeclarations.has(dep.id)) return false;
+	}
+	return true;
+};
+
+/**
+ * An export name is either an identifier name (reserved words included, e.g.
+ * `default`) or a string literal (arbitrary module namespace names).
+ * @param {string} name export name
+ * @returns {string} name as it can be written after `as`
+ */
+const toExportName = (name) =>
+	SAFE_IDENTIFIER.test(name) ? name : JSON.stringify(name);
+
+/**
+ * Whether the export name can also be used as the declared binding name.
+ * @param {string} name export name
+ * @returns {boolean} true, when the name can be declared
+ */
+const isDeclarableExportName = (name) =>
+	SAFE_IDENTIFIER.test(name) && !RESERVED_IDENTIFIER.has(name);
+
 /**
  * Represents the module library plugin runtime component.
  * @typedef {ModuleLibraryPluginParsed} T
@@ -111,6 +185,36 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 					return true;
 				}
 			);
+			// The same for a plain entry, whose definitions come from a dependency template.
+			// Placed after the module body, which its value bindings read.
+			javascriptHooks.onDemandExportsGeneration.tap(
+				PLUGIN_NAME,
+				(module, runtime, source, placeAtEnd) => {
+					const entries = libraryEntryModules.get(compilation);
+					if (!entries || !entries.has(module)) return;
+					if (!definesOnlyNativeExports(module, compilation.moduleGraph)) {
+						return;
+					}
+					/** @type {BuildMeta} */
+					const buildMeta = module.buildMeta || (module.buildMeta = {});
+					const key = getRuntimeKey(runtime);
+					if (placeAtEnd) {
+						const bindings =
+							buildMeta.exportsBindingSourceByRuntime ||
+							(buildMeta.exportsBindingSourceByRuntime = new Map());
+						bindings.set(key, source);
+					} else {
+						const sources =
+							buildMeta.exportsSourceByRuntime ||
+							(buildMeta.exportsSourceByRuntime = new Map());
+						// The `__esModule` marker and the definitions both land here, so
+						// keep whichever arrived first rather than replacing it.
+						const before = sources.get(key);
+						sources.set(key, before ? `${before}${source}` : source);
+					}
+					return true;
+				}
+			);
 
 			// `ModuleLibraryPlugin` stashes the on-demand exports source via
 			// `onDemandExportsGeneration` and only re-emits it when the
@@ -124,7 +228,6 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 				(chunk, set, { chunkGraph, codeGenerationResults }) => {
 					if (!set.has(RuntimeGlobals.definePropertyGetters)) return;
 					if (chunkGraph.getNumberOfEntryModules(chunk) !== 1) return;
-					if (chunkGraph.hasChunkEntryDependentChunks(chunk)) return;
 					if (
 						set.has(RuntimeGlobals.moduleFactories) ||
 						set.has(RuntimeGlobals.moduleCache) ||
@@ -137,14 +240,16 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 					if (javascriptHooks.inlineInRuntimeBailout.isUsed()) return;
 
 					const [module] = chunkGraph.getChunkEntryModulesIterable(chunk);
-					const exportsSourceByRuntime =
-						module.buildMeta && module.buildMeta.exportsSourceByRuntime;
-					if (
-						!exportsSourceByRuntime ||
-						!exportsSourceByRuntime.has(getRuntimeKey(chunk.runtime))
-					) {
-						return;
-					}
+					const runtimeKey = getRuntimeKey(chunk.runtime);
+					const buildMeta = module.buildMeta;
+					const takenOver =
+						(buildMeta &&
+							buildMeta.exportsSourceByRuntime &&
+							buildMeta.exportsSourceByRuntime.has(runtimeKey)) ||
+						(buildMeta &&
+							buildMeta.exportsBindingSourceByRuntime &&
+							buildMeta.exportsBindingSourceByRuntime.has(runtimeKey));
+					if (!takenOver) return;
 					const codeGenResult = codeGenerationResults.get(
 						module,
 						chunk.runtime
@@ -158,32 +263,63 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 						return;
 					}
 
-					// Check whether any other module in the chunk still needs
-					// the helpers we want to remove.
+					// Without `avoidEntryIife`, another rendered module wraps the entry in
+					// an IIFE, which re-emits the stashed source — its helpers stay.
+					if (!compilation.options.optimization.avoidEntryIife) {
+						for (const m of chunkGraph.getChunkModulesIterableBySourceType(
+							chunk,
+							JAVASCRIPT_TYPE
+						) || []) {
+							if (m !== module) return;
+						}
+					}
+
+					// The helpers land in the runtime, not in this chunk, so what still
+					// needs them is asked of every chunk sharing the entrypoint — the
+					// runtime chunk, and whatever `splitChunks` moved out of the entry.
+					/** @type {Set<Chunk>} */
+					const siblings = new Set([chunk]);
+					for (const [
+						,
+						entrypoint
+					] of chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)) {
+						if (!entrypoint) continue;
+						for (const sibling of entrypoint.chunks) siblings.add(sibling);
+					}
+
 					let otherNeedsDefine = false;
+					let otherNeedsNamespaceObject = false;
 					let otherNeedsExports = false;
 					let otherNeedsRequireScope = false;
-					for (const m of chunkGraph.getChunkModulesIterable(chunk)) {
-						if (m === module) continue;
-						const requirements = chunkGraph.getModuleRuntimeRequirements(
-							m,
-							chunk.runtime
-						);
-						if (!requirements) continue;
-						if (requirements.has(RuntimeGlobals.definePropertyGetters)) {
-							otherNeedsDefine = true;
-						}
-						if (requirements.has(RuntimeGlobals.exports)) {
-							otherNeedsExports = true;
-						}
-						if (requirements.has(RuntimeGlobals.requireScope)) {
-							otherNeedsRequireScope = true;
+					outer: for (const sibling of siblings) {
+						for (const m of chunkGraph.getChunkModulesIterable(sibling)) {
+							if (m === module) continue;
+							const requirements = chunkGraph.getModuleRuntimeRequirements(
+								m,
+								sibling.runtime
+							);
+							if (!requirements) continue;
+							if (requirements.has(RuntimeGlobals.definePropertyGetters)) {
+								otherNeedsDefine = true;
+							}
+							if (requirements.has(RuntimeGlobals.makeNamespaceObject)) {
+								otherNeedsNamespaceObject = true;
+							}
+							if (requirements.has(RuntimeGlobals.exports)) {
+								otherNeedsExports = true;
+							}
+							if (requirements.has(RuntimeGlobals.requireScope)) {
+								otherNeedsRequireScope = true;
+							}
+							if (otherNeedsDefine) break outer;
 						}
-						if (otherNeedsDefine) break;
 					}
 
 					if (otherNeedsDefine) return;
 					set.delete(RuntimeGlobals.definePropertyGetters);
+					if (!otherNeedsNamespaceObject) {
+						set.delete(RuntimeGlobals.makeNamespaceObject);
+					}
 					if (!otherNeedsExports) set.delete(RuntimeGlobals.exports);
 					if (!otherNeedsRequireScope) set.delete(RuntimeGlobals.requireScope);
 				}
@@ -232,6 +368,12 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 			}
 		}
 		moduleGraph.addExtraReason(module, "used as library export");
+		let entries = libraryEntryModules.get(compilation);
+		if (entries === undefined) {
+			entries = new WeakSet();
+			libraryEntryModules.set(compilation, entries);
+		}
+		entries.add(module);
 	}
 
 	/**
@@ -398,6 +540,23 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		const exports = [];
 		/** @type {Set<string>} */
 		const alreadyRenderedExports = new Set();
+		/** @type {Set<string>} */
+		const usedLocalNames = new Set();
+
+		/**
+		 * `toIdentifier` is lossy, so distinct export names (`"a b"` and `"a-b"`)
+		 * would otherwise be bound to the same generated name twice.
+		 * @param {string} exportName export name
+		 * @returns {string} unique local name for the export
+		 */
+		const toLocalName = (exportName) => {
+			const base = `${RuntimeGlobals.exports}${Template.toIdentifier(exportName)}`;
+			let name = base;
+			let i = 0;
+			while (usedLocalNames.has(name)) name = `${base}_${i++}`;
+			usedLocalNames.add(name);
+			return name;
+		};
 
 		const isAsync = moduleGraph.isAsync(module);
 
@@ -434,6 +593,16 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 			}
 		}
 
+		// Taken over by `onDemandExportsGeneration` above, and re-emitted by
+		// `renderModuleContent` only where the module is wrapped — which is not here.
+		const bindingsTakenOver = Boolean(
+			module.buildMeta &&
+			module.buildMeta.exportsBindingSourceByRuntime &&
+			module.buildMeta.exportsBindingSourceByRuntime.has(
+				getRuntimeKey(chunk.runtime)
+			)
+		);
+
 		const moduleExportsInfo = moduleGraph.getExportsInfo(module);
 
 		// Define ESM compatibility flag will rely on `__webpack_exports__`
@@ -463,13 +632,16 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 
 			// Try to find all exports from the reexported modules
 			const target = exportInfo.findTarget(moduleGraph, (_m) => true);
-			if (target) {
+			// A namespace object target (`export * as ns from "./module"`) has no
+			// export name, so there is nothing that could be missing
+			if (target && target.export) {
+				const targetExport = target.export[0];
 				const reexportsInfo = moduleGraph.getExportsInfo(target.module);
 				for (const reexportInfo of reexportsInfo.orderedExports) {
 					if (
 						reexportInfo.provided === false &&
 						reexportInfo.name !== "default" &&
-						reexportInfo.name === /** @type {string[]} */ (target.export)[0]
+						reexportInfo.name === targetExport
 					) {
 						continue outer;
 					}
@@ -495,11 +667,13 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 			} else if (directLocal !== undefined) {
 				// Live binding to the inlined entry's own top-level declaration
 				finalName = directLocal;
-				needExportsDeclaration = true;
+				// The declaration is only there for the definitions written into it; with
+				// those taken over (and not re-emitted here) nothing reads the object.
+				if (!bindingsTakenOver) needExportsDeclaration = true;
 			} else {
 				// Fallback to `__webpack_exports__` property access
 				// when no direct export binding was found
-				finalName = `${RuntimeGlobals.exports}${Template.toIdentifier(originalName)}`;
+				finalName = toLocalName(originalName);
 				needExportsDeclaration = true;
 				result.add(
 					`${runtimeTemplate.renderConst()} ${finalName} = ${RuntimeGlobals.exports}${propertyAccess(
@@ -522,11 +696,11 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 						(module.buildInfo && module.buildInfo.topLevelDeclarations);
 
 					if (topLevelDeclarations && topLevelDeclarations.has(originalName)) {
-						const name = `${RuntimeGlobals.exports}${Template.toIdentifier(originalName)}`;
+						const name = toLocalName(originalName);
 						result.add(
 							`${runtimeTemplate.renderConst()} ${name} = ${finalName};\n`
 						);
-						shortHandedExports.push(`${name} as ${originalName}`);
+						shortHandedExports.push(`${name} as ${toExportName(originalName)}`);
 					} else {
 						exports.push([originalName, finalName]);
 					}
@@ -537,21 +711,21 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 				shortHandedExports.push(
 					finalName === originalName
 						? finalName
-						: `${finalName} as ${originalName}`
+						: `${finalName} as ${toExportName(originalName)}`
 				);
 			}
 
 			alreadyRenderedExports.add(originalName);
 		}
 
+		if (shortHandedExports.length > 0) {
+			result.add(`export { ${shortHandedExports.join(", ")} };\n`);
+		}
+
 		// Add default export `__webpack_exports__` statement to keep better compatibility
 		if (treatAsCommonJs) {
 			needExportsDeclaration = true;
-			shortHandedExports.push(`${RuntimeGlobals.exports} as default`);
-		}
-
-		if (shortHandedExports.length > 0) {
-			result.add(`export { ${shortHandedExports.join(", ")} };\n`);
+			result.add(`export default ${RuntimeGlobals.exports};\n`);
 		}
 
 		result = this._analyzeUnknownProvidedExports(
@@ -564,8 +738,16 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		);
 
 		for (const [exportName, final] of exports) {
+			if (isDeclarableExportName(exportName)) {
+				result.add(
+					`export ${runtimeTemplate.renderConst()} ${exportName} = ${final};\n`
+				);
+				continue;
+			}
+			// Bind to a generated name, the export name can't be declared
+			const name = toLocalName(exportName);
 			result.add(
-				`export ${runtimeTemplate.renderConst()} ${exportName} = ${final};\n`
+				`${runtimeTemplate.renderConst()} ${name} = ${final};\nexport { ${name} as ${toExportName(exportName)} };\n`
 			);
 		}
 
@@ -590,15 +772,25 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		{ factory, inlinedInIIFE, chunk },
 		libraryContext
 	) {
+		const runtimeKey = getRuntimeKey(chunk.runtime);
+		const buildMeta = module.buildMeta;
 		const exportsSource =
-			module.buildMeta &&
-			module.buildMeta.exportsSourceByRuntime &&
-			module.buildMeta.exportsSourceByRuntime.get(getRuntimeKey(chunk.runtime));
-
-		// Re-add the module's exports source when rendered in factory
-		// or as an inlined startup module wrapped in an IIFE
-		if ((inlinedInIIFE || factory) && exportsSource) {
-			return new ConcatSource(exportsSource, source);
+			buildMeta &&
+			buildMeta.exportsSourceByRuntime &&
+			buildMeta.exportsSourceByRuntime.get(runtimeKey);
+		const bindingSource =
+			buildMeta &&
+			buildMeta.exportsBindingSourceByRuntime &&
+			buildMeta.exportsBindingSourceByRuntime.get(runtimeKey);
+
+		// Re-add the exports source in a factory or IIFE-wrapped startup module; value
+		// bindings read the declarations above them, so those go after the body.
+		if ((inlinedInIIFE || factory) && (exportsSource || bindingSource)) {
+			return new ConcatSource(
+				...(exportsSource ? [exportsSource] : []),
+				source,
+				...(bindingSource ? ["\n", bindingSource] : [])
+			);
 		}
 		return source;
 	}

package/lib/library/SystemLibraryPlugin.js

@@ -12,14 +12,18 @@ const Template = require("../Template");
 const { propertyAccess } = require("../util/property");
 const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
-/** @typedef {import("../ExportsInfo").ExportInfoName} ExportInfoName */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
-/** @typedef {import("../util/Hash")} Hash */
+/** @import { Source } from "webpack-sources" */
+/**
+ * @import {
+ * 	LibraryOptions,
+ * 	LibraryType
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import Chunk from "../Chunk" */
+/** @import { ChunkHashContext } from "../Compilation" */
+/** @import { ExportInfoName } from "../Dependency" */
+/** @import { RenderContext } from "../javascript/JavascriptModulesPlugin" */
+/** @import Hash from "../util/Hash" */
 /**
  * Defines the shared type used by this module.
  * @template T

package/lib/library/UmdLibraryPlugin.js

@@ -10,14 +10,18 @@ const ExternalModule = require("../ExternalModule");
 const Template = require("../Template");
 const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryCustomUmdCommentObject} LibraryCustomUmdCommentObject */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryCustomUmdObject} LibraryCustomUmdObject */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryName} LibraryName */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
-/** @typedef {import("../ExternalModule").RequestRecord} RequestRecord */
+/** @import { Source } from "webpack-sources" */
+/**
+ * @import {
+ * 	LibraryCustomUmdCommentObject,
+ * 	LibraryCustomUmdObject,
+ * 	LibraryName,
+ * 	LibraryOptions,
+ * 	LibraryType
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import { RenderContext } from "../javascript/JavascriptModulesPlugin" */
+/** @import { RequestRecord } from "../ExternalModule" */
 
 /**
  * Defines the shared type used by this module.
@@ -58,6 +62,24 @@ const accessorAccess = (base, accessor, joinWith = ", ") => {
 		.join(joinWith);
 };
 
+/**
+ * Builds the guard for an AMD-style loader on a container object, e.g. `sap.ui` becomes
+ * `typeof sap !== 'undefined' && sap.ui && typeof sap.ui.define === 'function'`. The path is
+ * walked step by step because `typeof sap.ui` alone throws when `sap` is undeclared, which is
+ * exactly when the branch has to be skipped.
+ * @param {string} container the container object holding `define`
+ * @returns {string} the condition
+ */
+const amdContainerCondition = (container) => {
+	const path = container.split(".");
+	const conditions = [`typeof ${path[0]} !== 'undefined'`];
+	for (let i = 1; i < path.length; i++) {
+		conditions.push(path.slice(0, i + 1).join("."));
+	}
+	conditions.push(`typeof ${container}.define === 'function'`);
+	return conditions.join(" && ");
+};
+
 /**
  * Defines the umd library plugin options type used by this module.
  * @typedef {object} UmdLibraryPluginOptions
@@ -72,6 +94,7 @@ const accessorAccess = (base, accessor, joinWith = ", ") => {
  * @property {LibraryCustomUmdObject} names
  * @property {string | LibraryCustomUmdCommentObject | undefined} auxiliaryComment
  * @property {boolean | undefined} namedDefine
+ * @property {string | undefined} amdContainer
  */
 
 /**
@@ -120,7 +143,8 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 			name,
 			names,
 			auxiliaryComment: library.auxiliaryComment,
-			namedDefine: library.umdNamedDefine
+			namedDefine: library.umdNamedDefine,
+			amdContainer: library.umdAmdContainer
 		};
 	}
 
@@ -233,9 +257,9 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 							);
 						}
 						let expr = Array.isArray(request)
-							? `require(${JSON.stringify(
-									request[0]
-								)})${accessorToObjectAccess(request.slice(1))}`
+							? `require(${JSON.stringify(request[0])})${accessorToObjectAccess(
+									request.slice(1)
+								)}`
 							: `require(${JSON.stringify(request)})`;
 						if (m.isOptional(moduleGraph)) {
 							expr = `(function webpackLoadOptionalExternalModule() { try { return ${expr}; } catch(e) {} }())`;
@@ -291,7 +315,24 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 			amdFactory = "factory";
 		}
 
-		const { auxiliaryComment, namedDefine, names } = options;
+		const { amdContainer, auxiliaryComment, namedDefine, names } = options;
+
+		/**
+		 * Returns a call to an AMD-style define function.
+		 * @param {string} defineFunction the define function to call
+		 * @returns {string} the define call
+		 */
+		const defineCall = (defineFunction) => {
+			const deps =
+				requiredExternals.length > 0
+					? externalsDepsArray(requiredExternals)
+					: "[]";
+			return names.amd && namedDefine === true
+				? `		${defineFunction}(${libraryName(
+						names.amd
+					)}, ${deps}, ${amdFactory});\n`
+				: `		${defineFunction}(${deps}, ${amdFactory});\n`;
+		};
 
 		/**
 		 * Gets auxiliary comment.
@@ -317,18 +358,14 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 						"commonjs2"
 					)});\n${getAuxiliaryComment(
 						"amd"
-					)}	else if(typeof define === 'function' && define.amd)\n${
-						requiredExternals.length > 0
-							? names.amd && namedDefine === true
-								? `		define(${libraryName(names.amd)}, ${externalsDepsArray(
-										requiredExternals
-									)}, ${amdFactory});\n`
-								: `		define(${externalsDepsArray(requiredExternals)}, ${
-										amdFactory
-									});\n`
-							: names.amd && namedDefine === true
-								? `		define(${libraryName(names.amd)}, [], ${amdFactory});\n`
-								: `		define([], ${amdFactory});\n`
+					)}	else if(typeof define === 'function' && define.amd)\n${defineCall(
+						"define"
+					)}${
+						amdContainer
+							? `	else if(${amdContainerCondition(
+									amdContainer
+								)})\n${defineCall(`${amdContainer}.define`)}`
+							: ""
 					}${
 						names.root || names.commonjs
 							? `${getAuxiliaryComment(