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

package/lib/library/ExportPropertyLibraryPlugin.js

@@ -21,25 +21,30 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
 /**
+ * Defines the shared type used by this module.
  * @template T
  * @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T>
  */
 
 /**
+ * Defines the export property library plugin parsed type used by this module.
  * @typedef {object} ExportPropertyLibraryPluginParsed
  * @property {LibraryExport=} export
  */
 
 /**
+ * Defines the export property library plugin options type used by this module.
  * @typedef {object} ExportPropertyLibraryPluginOptions
  * @property {LibraryType} type
  */
 /**
+ * Represents the export property library plugin runtime component.
  * @typedef {ExportPropertyLibraryPluginParsed} T
  * @extends {AbstractLibraryPlugin<ExportPropertyLibraryPluginParsed>}
  */
 class ExportPropertyLibraryPlugin extends AbstractLibraryPlugin {
 	/**
+	 * Creates an instance of ExportPropertyLibraryPlugin.
 	 * @param {ExportPropertyLibraryPluginOptions} options options
 	 */
 	constructor({ type }) {
@@ -50,6 +55,7 @@ class ExportPropertyLibraryPlugin extends AbstractLibraryPlugin {
 	}
 
 	/**
+	 * Returns preprocess as needed by overriding.
 	 * @param {LibraryOptions} library normalized library option
 	 * @returns {T} preprocess as needed by overriding
 	 */
@@ -60,6 +66,7 @@ class ExportPropertyLibraryPlugin extends AbstractLibraryPlugin {
 	}
 
 	/**
+	 * Finish entry module.
 	 * @param {Module} module the exporting entry module
 	 * @param {string} entryName the name of the entrypoint
 	 * @param {LibraryContext<T>} libraryContext context
@@ -78,6 +85,7 @@ class ExportPropertyLibraryPlugin extends AbstractLibraryPlugin {
 			);
 			exportsInfo.setUsed(UsageState.Used, runtime);
 			exportsInfo.canMangleUse = false;
+			exportsInfo.canInlineUse = false;
 		} else {
 			const exportsInfo = moduleGraph.getExportsInfo(module);
 			exportsInfo.setUsedInUnknownWay(runtime);
@@ -86,6 +94,7 @@ class ExportPropertyLibraryPlugin extends AbstractLibraryPlugin {
 	}
 
 	/**
+	 * Processes the provided chunk.
 	 * @param {Chunk} chunk the chunk
 	 * @param {RuntimeRequirements} set runtime requirements
 	 * @param {LibraryContext<T>} libraryContext context
@@ -96,6 +105,7 @@ class ExportPropertyLibraryPlugin extends AbstractLibraryPlugin {
 	}
 
 	/**
+	 * Renders source with library export.
 	 * @param {Source} source source
 	 * @param {Module} module module
 	 * @param {StartupRenderContext} renderContext render context

package/lib/{FalseIIFEUmdWarning.js → library/FalseIIFEUmdWarning.js}

@@ -5,13 +5,14 @@
 
 "use strict";
 
-const WebpackError = require("./WebpackError");
+const WebpackError = require("../errors/WebpackError");
 
 class FalseIIFEUmdWarning extends WebpackError {
 	constructor() {
 		super();
 		/** @type {string} */
 		this.name = "FalseIIFEUmdWarning";
+		/** @type {string} */
 		this.message =
 			"Configuration:\nSetting 'output.iife' to 'false' is incompatible with 'output.library.type' set to 'umd'. This configuration may cause unexpected behavior, as UMD libraries are expected to use an IIFE (Immediately Invoked Function Expression) to support various module formats. Consider setting 'output.iife' to 'true' or choosing a different 'library.type' to ensure compatibility.\nLearn more: https://webpack.js.org/configuration/output/";
 	}

package/lib/library/JsonpLibraryPlugin.js

@@ -17,26 +17,31 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @typedef {import("../util/Hash")} Hash */
 
 /**
+ * Defines the shared type used by this module.
  * @template T
  * @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T>
  */
 
 /**
+ * Defines the jsonp library plugin options type used by this module.
  * @typedef {object} JsonpLibraryPluginOptions
  * @property {LibraryType} type
  */
 
 /**
+ * Defines the jsonp library plugin parsed type used by this module.
  * @typedef {object} JsonpLibraryPluginParsed
  * @property {string} name
  */
 
 /**
+ * Represents the jsonp library plugin runtime component.
  * @typedef {JsonpLibraryPluginParsed} T
  * @extends {AbstractLibraryPlugin<JsonpLibraryPluginParsed>}
  */
 class JsonpLibraryPlugin extends AbstractLibraryPlugin {
 	/**
+	 * Creates an instance of JsonpLibraryPlugin.
 	 * @param {JsonpLibraryPluginOptions} options the plugin options
 	 */
 	constructor(options) {
@@ -47,6 +52,7 @@ class JsonpLibraryPlugin extends AbstractLibraryPlugin {
 	}
 
 	/**
+	 * Returns preprocess as needed by overriding.
 	 * @param {LibraryOptions} library normalized library option
 	 * @returns {T} preprocess as needed by overriding
 	 */
@@ -64,6 +70,7 @@ class JsonpLibraryPlugin extends AbstractLibraryPlugin {
 	}
 
 	/**
+	 * Returns source with library export.
 	 * @param {Source} source source
 	 * @param {RenderContext} renderContext render context
 	 * @param {LibraryContext<T>} libraryContext context
@@ -77,6 +84,7 @@ class JsonpLibraryPlugin extends AbstractLibraryPlugin {
 	}
 
 	/**
+	 * Processes the provided chunk.
 	 * @param {Chunk} chunk the chunk
 	 * @param {Hash} hash hash
 	 * @param {ChunkHashContext} chunkHashContext chunk hash context

package/lib/library/ModuleLibraryPlugin.js

@@ -11,7 +11,10 @@ const ExternalModule = require("../ExternalModule");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 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 { getEntryRuntime, getRuntimeKey } = require("../util/runtime");
 const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
@@ -30,18 +33,22 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @typedef {import("../javascript/JavascriptModulesPlugin").ModuleRenderContext} ModuleRenderContext */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../javascript/JavascriptModule").JavascriptModuleBuildMeta} JavascriptModuleBuildMeta */
 
 /**
+ * Defines the shared type used by this module.
  * @template T
  * @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T>
  */
 
 /**
+ * Defines the module library plugin options type used by this module.
  * @typedef {object} ModuleLibraryPluginOptions
  * @property {LibraryType} type
  */
 
 /**
+ * Defines the module library plugin parsed type used by this module.
  * @typedef {object} ModuleLibraryPluginParsed
  * @property {string} name
  * @property {LibraryExport=} export
@@ -50,11 +57,13 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 const PLUGIN_NAME = "ModuleLibraryPlugin";
 
 /**
+ * Represents the module library plugin runtime component.
  * @typedef {ModuleLibraryPluginParsed} T
  * @extends {AbstractLibraryPlugin<ModuleLibraryPluginParsed>}
  */
 class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 	/**
+	 * Creates an instance of ModuleLibraryPlugin.
 	 * @param {ModuleLibraryPluginOptions} options the plugin options
 	 */
 	constructor(options) {
@@ -65,7 +74,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -75,6 +84,8 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			const { onDemandExportsGeneration } =
 				ConcatenatedModule.getCompilationHooks(compilation);
+			const javascriptHooks =
+				JavascriptModulesPlugin.getCompilationHooks(compilation);
 			onDemandExportsGeneration.tap(
 				PLUGIN_NAME,
 				(module, runtimes, source, finalName) => {
@@ -100,10 +111,88 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 					return true;
 				}
 			);
+
+			// `ModuleLibraryPlugin` stashes the on-demand exports source via
+			// `onDemandExportsGeneration` and only re-emits it when the
+			// module is wrapped in an IIFE/factory. When the entry is
+			// inlined directly, the stashed source — and the
+			// `definePropertyGetters` / `requireScope` runtime helpers it
+			// pulled in — never make it into the output. Drop those helpers
+			// from the chunk's set so the bundle stays clean.
+			compilation.hooks.additionalChunkRuntimeRequirements.tap(
+				PLUGIN_NAME,
+				(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) ||
+						set.has(RuntimeGlobals.interceptModuleExecution) ||
+						set.has(RuntimeGlobals.module) ||
+						set.has(RuntimeGlobals.thisAsExports)
+					) {
+						return;
+					}
+					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 codeGenResult = codeGenerationResults.get(
+						module,
+						chunk.runtime
+					);
+					const jsSource =
+						codeGenResult && codeGenResult.sources.get("javascript");
+					if (
+						jsSource &&
+						String(jsSource.source()).includes(`${RuntimeGlobals.require}.`)
+					) {
+						return;
+					}
+
+					// Check whether any other module in the chunk still needs
+					// the helpers we want to remove.
+					let otherNeedsDefine = 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;
+						}
+						if (otherNeedsDefine) break;
+					}
+
+					if (otherNeedsDefine) return;
+					set.delete(RuntimeGlobals.definePropertyGetters);
+					if (!otherNeedsExports) set.delete(RuntimeGlobals.exports);
+					if (!otherNeedsRequireScope) set.delete(RuntimeGlobals.requireScope);
+				}
+			);
 		});
 	}
 
 	/**
+	 * Finish entry module.
 	 * @param {Module} module the exporting entry module
 	 * @param {string} entryName the name of the entrypoint
 	 * @param {LibraryContext<T>} libraryContext context
@@ -122,24 +211,31 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 			);
 			exportsInfo.setUsed(UsageState.Used, runtime);
 			exportsInfo.canMangleUse = false;
+			exportsInfo.canInlineUse = false;
 		} else {
 			const exportsInfo = moduleGraph.getExportsInfo(module);
 
 			if (
 				// If the entry module is commonjs, its exports cannot be mangled
-				(module.buildMeta && module.buildMeta.treatAsCommonJs) ||
+				(module.buildMeta &&
+					/** @type {JavascriptModuleBuildMeta} */ (module.buildMeta)
+						.treatAsCommonJs) ||
 				// The entry module provides unknown exports
 				exportsInfo._otherExportsInfo.provided === null
 			) {
 				exportsInfo.setUsedInUnknownWay(runtime);
 			} else {
 				exportsInfo.setAllKnownExportsUsed(runtime);
+				for (const exportInfo of exportsInfo.ownedExports) {
+					exportInfo.canInlineUse = false;
+				}
 			}
 		}
 		moduleGraph.addExtraReason(module, "used as library export");
 	}
 
 	/**
+	 * Returns preprocess as needed by overriding.
 	 * @param {LibraryOptions} library normalized library option
 	 * @returns {T} preprocess as needed by overriding
 	 */
@@ -158,6 +254,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 	}
 
 	/**
+	 * Analyze unknown provided exports.
 	 * @param {Source} source source
 	 * @param {Module} module module
 	 * @param {ModuleGraph} moduleGraph moduleGraph
@@ -177,10 +274,11 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		const result = new ConcatSource(source);
 		/** @type {Set<string>} */
 		const moduleRequests = new Set();
-		/** @type {Map<string, string>} */
+		/** @type {Map<string, string | InlinedUsedName>} */
 		const unknownProvidedExports = new Map();
 
 		/**
+		 * Resolves dynamic star reexport.
 		 * @param {Module} module the module
 		 * @param {boolean} isDynamicReexport if module is dynamic reexported
 		 */
@@ -218,7 +316,9 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 								continue;
 							}
 							const originalName = exportInfo.name;
-							const usedName = exportInfo.getUsedName(originalName, runtime);
+							const usedName =
+								/** @type {string | InlinedUsedName | false} */
+								(exportInfo.getUsedName(originalName, runtime));
 
 							if (!alreadyRenderedExports.has(originalName) && usedName) {
 								unknownProvidedExports.set(originalName, usedName);
@@ -238,7 +338,13 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		for (const [origin, used] of unknownProvidedExports) {
 			exports.push([
 				origin,
-				`${RuntimeGlobals.exports}${propertyAccess([used])}`
+				used instanceof InlinedUsedName
+					? used.render(
+							Template.toNormalComment(
+								`inlined export ${propertyAccess([origin])}`
+							)
+						)
+					: `${RuntimeGlobals.exports}${propertyAccess([used])}`
 			]);
 		}
 
@@ -246,6 +352,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 	}
 
 	/**
+	 * Renders source with library export.
 	 * @param {Source} source source
 	 * @param {Module} module module
 	 * @param {StartupRenderContext} renderContext render context
@@ -295,9 +402,38 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		const isAsync = moduleGraph.isAsync(module);
 
 		const treatAsCommonJs =
-			module.buildMeta && module.buildMeta.treatAsCommonJs;
+			module.buildMeta &&
+			/** @type {JavascriptModuleBuildMeta} */ (module.buildMeta)
+				.treatAsCommonJs;
 		const skipRenderDefaultExport = Boolean(treatAsCommonJs);
 
+		// A single (non-concatenated) inlined entry is rendered at the top
+		// level, so its own declarations are top-level bindings we can export
+		// directly — keeping ESM live bindings instead of snapshotting
+		// `__webpack_exports__.x` into a `const`. Concatenated entries already
+		// get direct bindings via `definitions` above.
+		/** @type {Map<string, string> | undefined} */
+		let directBindings;
+		if (isInlinedEntryWithoutIIFE && !treatAsCommonJs) {
+			const { data } = codeGenerationResults.get(module, chunk.runtime);
+			const topLevelDeclarations =
+				(data && data.get("topLevelDeclarations")) ||
+				(module.buildInfo && module.buildInfo.topLevelDeclarations);
+			if (topLevelDeclarations) {
+				for (const dep of module.dependencies) {
+					if (
+						dep instanceof HarmonyExportSpecifierDependency &&
+						topLevelDeclarations.has(dep.id)
+					) {
+						(directBindings || (directBindings = new Map())).set(
+							dep.name,
+							dep.id
+						);
+					}
+				}
+			}
+		}
+
 		const moduleExportsInfo = moduleGraph.getExportsInfo(module);
 
 		// Define ESM compatibility flag will rely on `__webpack_exports__`
@@ -340,16 +476,26 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 				}
 			}
 
+			// The exports of entry module are never inlined
 			const usedName =
 				/** @type {string} */
 				(exportInfo.getUsedName(originalName, chunk.runtime));
 			/** @type {string | undefined} */
 			const definition = definitions[usedName];
 			/** @type {string | undefined} */
+			const directLocal =
+				definition === undefined && directBindings
+					? directBindings.get(originalName)
+					: undefined;
+			/** @type {string | undefined} */
 			let finalName;
 
 			if (definition) {
 				finalName = definition;
+			} else if (directLocal !== undefined) {
+				// Live binding to the inlined entry's own top-level declaration
+				finalName = directLocal;
+				needExportsDeclaration = true;
 			} else {
 				// Fallback to `__webpack_exports__` property access
 				// when no direct export binding was found
@@ -389,7 +535,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 				}
 			} else {
 				shortHandedExports.push(
-					definition && finalName === originalName
+					finalName === originalName
 						? finalName
 						: `${finalName} as ${originalName}`
 				);
@@ -431,6 +577,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 	}
 
 	/**
+	 * Renders module content.
 	 * @param {Source} source source
 	 * @param {Module} module module
 	 * @param {ModuleRenderContext} renderContext render context

package/lib/library/SystemLibraryPlugin.js

@@ -21,26 +21,31 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
 /** @typedef {import("../util/Hash")} Hash */
 /**
+ * Defines the shared type used by this module.
  * @template T
  * @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T>
  */
 
 /**
+ * Defines the system library plugin options type used by this module.
  * @typedef {object} SystemLibraryPluginOptions
  * @property {LibraryType} type
  */
 
 /**
+ * Defines the system library plugin parsed type used by this module.
  * @typedef {object} SystemLibraryPluginParsed
  * @property {string} name
  */
 
 /**
+ * Represents the system library plugin runtime component.
  * @typedef {SystemLibraryPluginParsed} T
  * @extends {AbstractLibraryPlugin<SystemLibraryPluginParsed>}
  */
 class SystemLibraryPlugin extends AbstractLibraryPlugin {
 	/**
+	 * Creates an instance of SystemLibraryPlugin.
 	 * @param {SystemLibraryPluginOptions} options the plugin options
 	 */
 	constructor(options) {
@@ -51,6 +56,7 @@ class SystemLibraryPlugin extends AbstractLibraryPlugin {
 	}
 
 	/**
+	 * Returns preprocess as needed by overriding.
 	 * @param {LibraryOptions} library normalized library option
 	 * @returns {T} preprocess as needed by overriding
 	 */
@@ -68,6 +74,7 @@ class SystemLibraryPlugin extends AbstractLibraryPlugin {
 	}
 
 	/**
+	 * Returns source with library export.
 	 * @param {Source} source source
 	 * @param {RenderContext} renderContext render context
 	 * @param {LibraryContext<T>} libraryContext context
@@ -134,9 +141,9 @@ class SystemLibraryPlugin extends AbstractLibraryPlugin {
 									/** @type {ExportInfoName[]} */
 									const handledNames = [];
 									for (const exportInfo of exportsInfo.orderedExports) {
-										const used = exportInfo.getUsedName(
-											undefined,
-											chunk.runtime
+										// The exports of `ExternalModule` are never inlined
+										const used = /** @type {string | false} */ (
+											exportInfo.getUsedName(undefined, chunk.runtime)
 										);
 										if (used) {
 											if (otherUnused || used !== exportInfo.name) {
@@ -239,6 +246,7 @@ class SystemLibraryPlugin extends AbstractLibraryPlugin {
 	}
 
 	/**
+	 * Processes the provided chunk.
 	 * @param {Chunk} chunk the chunk
 	 * @param {Hash} hash hash
 	 * @param {ChunkHashContext} chunkHashContext chunk hash context

package/lib/library/UmdLibraryPlugin.js

@@ -20,11 +20,13 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @typedef {import("../ExternalModule").RequestRecord} RequestRecord */
 
 /**
+ * Defines the shared type used by this module.
  * @template T
  * @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T>
  */
 
 /**
+ * Accessor to object access.
  * @param {string[]} accessor the accessor to convert to path
  * @returns {string} the path
  */
@@ -34,6 +36,7 @@ const accessorToObjectAccess = (accessor) =>
 /** @typedef {string | string[]} Accessor */
 
 /**
+ * Returns the path.
  * @param {string | undefined} base the path prefix
  * @param {Accessor} accessor the accessor
  * @param {string=} joinWith the element separator
@@ -56,12 +59,14 @@ const accessorAccess = (base, accessor, joinWith = ", ") => {
 };
 
 /**
+ * Defines the umd library plugin options type used by this module.
  * @typedef {object} UmdLibraryPluginOptions
  * @property {LibraryType} type
  * @property {boolean=} optionalAmdExternalAsGlobal
  */
 
 /**
+ * Defines the umd library plugin parsed type used by this module.
  * @typedef {object} UmdLibraryPluginParsed
  * @property {string | string[] | undefined} name
  * @property {LibraryCustomUmdObject} names
@@ -70,11 +75,13 @@ const accessorAccess = (base, accessor, joinWith = ", ") => {
  */
 
 /**
+ * Represents the umd library plugin runtime component.
  * @typedef {UmdLibraryPluginParsed} T
  * @extends {AbstractLibraryPlugin<UmdLibraryPluginParsed>}
  */
 class UmdLibraryPlugin extends AbstractLibraryPlugin {
 	/**
+	 * Creates an instance of UmdLibraryPlugin.
 	 * @param {UmdLibraryPluginOptions} options the plugin option
 	 */
 	constructor(options) {
@@ -88,6 +95,7 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 	}
 
 	/**
+	 * Returns preprocess as needed by overriding.
 	 * @param {LibraryOptions} library normalized library option
 	 * @returns {T} preprocess as needed by overriding
 	 */
@@ -117,6 +125,7 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 	}
 
 	/**
+	 * Returns source with library export.
 	 * @param {Source} source source
 	 * @param {RenderContext} renderContext render context
 	 * @param {LibraryContext<T>} libraryContext context
@@ -153,6 +162,7 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 		}
 
 		/**
+		 * Returns the replaced keys.
 		 * @param {string} str the string to replace
 		 * @returns {string} the replaced keys
 		 */
@@ -162,6 +172,7 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 			});
 
 		/**
+		 * Externals deps array.
 		 * @param {ExternalModule[]} modules external modules
 		 * @returns {string} result
 		 */
@@ -180,6 +191,7 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 			)}]`;
 
 		/**
+		 * Externals root array.
 		 * @param {ExternalModule[]} modules external modules
 		 * @returns {string} result
 		 */
@@ -201,6 +213,7 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 			);
 
 		/**
+		 * Externals require array.
 		 * @param {string} type the type
 		 * @returns {string} external require array
 		 */
@@ -233,6 +246,7 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 			);
 
 		/**
+		 * Externals arguments.
 		 * @param {ExternalModule[]} modules external modules
 		 * @returns {string} arguments
 		 */
@@ -247,6 +261,7 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 				.join(", ");
 
 		/**
+		 * Returns stringified library name.
 		 * @param {Accessor} library library name
 		 * @returns {string} stringified library name
 		 */
@@ -279,6 +294,7 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 		const { auxiliaryComment, namedDefine, names } = options;
 
 		/**
+		 * Gets auxiliary comment.
 		 * @param {keyof LibraryCustomUmdCommentObject} type type
 		 * @returns {string} comment
 		 */