webpack 5.100.2 → 5.101.1

package/lib/javascript/JavascriptParser.js

@@ -118,7 +118,7 @@ const ALLOWED_MEMBER_TYPES_ALL = 0b11;
 const LEGACY_ASSERT_ATTRIBUTES = Symbol("assert");
 
 /** @type {(BaseParser: typeof AcornParser) => typeof AcornParser} */
-const importAssertions = Parser =>
+const importAssertions = (Parser) =>
 	class extends Parser {
 		/**
 		 * @this {InstanceType<AcornParser>}
@@ -189,7 +189,7 @@ let parser = AcornParser.extend(importAssertions);
  * @param {ImportDeclaration | ExportNamedDeclaration | ExportAllDeclaration | ImportExpression} node node with assertions
  * @returns {ImportAttributes | undefined} import attributes
  */
-const getImportAttributes = node => {
+const getImportAttributes = (node) => {
 	if (node.type === "ImportExpression") {
 		if (
 			node.options &&
@@ -361,7 +361,7 @@ const objectAndMembersToName = (object, membersReversed) => {
  * @param {Expression | SpreadElement | Super} expression expression
  * @returns {string | "this" | undefined} name or variable info
  */
-const getRootName = expression => {
+const getRootName = (expression) => {
 	switch (expression.type) {
 		case "Identifier":
 			return expression.name;
@@ -607,7 +607,7 @@ class JavascriptParser extends Parser {
 	}
 
 	_initializeEvaluating() {
-		this.hooks.evaluate.for("Literal").tap(CLASS_NAME, _expr => {
+		this.hooks.evaluate.for("Literal").tap(CLASS_NAME, (_expr) => {
 			const expr = /** @type {Literal} */ (_expr);
 
 			switch (typeof expr.value) {
@@ -639,7 +639,7 @@ class JavascriptParser extends Parser {
 					.setRange(/** @type {Range} */ (expr.range));
 			}
 		});
-		this.hooks.evaluate.for("NewExpression").tap(CLASS_NAME, _expr => {
+		this.hooks.evaluate.for("NewExpression").tap(CLASS_NAME, (_expr) => {
 			const expr = /** @type {NewExpression} */ (_expr);
 			const callee = expr.callee;
 			if (callee.type !== "Identifier") return;
@@ -704,7 +704,7 @@ class JavascriptParser extends Parser {
 				.setRegExp(flags ? new RegExp(regExp, flags) : new RegExp(regExp))
 				.setRange(/** @type {Range} */ (expr.range));
 		});
-		this.hooks.evaluate.for("LogicalExpression").tap(CLASS_NAME, _expr => {
+		this.hooks.evaluate.for("LogicalExpression").tap(CLASS_NAME, (_expr) => {
 			const expr = /** @type {LogicalExpression} */ (_expr);
 
 			const left = this.evaluateExpression(expr.left);
@@ -822,7 +822,7 @@ class JavascriptParser extends Parser {
 			}
 		};
 
-		this.hooks.evaluate.for("BinaryExpression").tap(CLASS_NAME, _expr => {
+		this.hooks.evaluate.for("BinaryExpression").tap(CLASS_NAME, (_expr) => {
 			const expr = /** @type {BinaryExpression} */ (_expr);
 
 			/**
@@ -831,7 +831,7 @@ class JavascriptParser extends Parser {
 			 * @param {(leftOperand: T, rightOperand: T) => boolean | number | bigint | string} operandHandler the handler for the operation (e.g. (a, b) => a + b)
 			 * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
 			 */
-			const handleConstOperation = operandHandler => {
+			const handleConstOperation = (operandHandler) => {
 				const left = this.evaluateExpression(expr.left);
 				if (!left.isCompileTimeValue()) return;
 
@@ -871,7 +871,7 @@ class JavascriptParser extends Parser {
 				 * @param {BasicEvaluatedExpression[]} parts parts
 				 * @returns {string} value
 				 */
-				const getPrefix = parts => {
+				const getPrefix = (parts) => {
 					let value = "";
 					for (const p of parts) {
 						const v = p.asString();
@@ -884,7 +884,7 @@ class JavascriptParser extends Parser {
 				 * @param {BasicEvaluatedExpression[]} parts parts
 				 * @returns {string} value
 				 */
-				const getSuffix = parts => {
+				const getSuffix = (parts) => {
 					let value = "";
 					for (let i = parts.length - 1; i >= 0; i--) {
 						const v = parts[i].asString();
@@ -927,7 +927,7 @@ class JavascriptParser extends Parser {
 			 * @param {boolean} eql true for "===" and false for "!=="
 			 * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
 			 */
-			const handleStrictEqualityComparison = eql => {
+			const handleStrictEqualityComparison = (eql) => {
 				const left = this.evaluateExpression(expr.left);
 				const right = this.evaluateExpression(expr.right);
 				const res = new BasicEvaluatedExpression();
@@ -989,7 +989,7 @@ class JavascriptParser extends Parser {
 			 * @param {boolean} eql true for "==" and false for "!="
 			 * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
 			 */
-			const handleAbstractEqualityComparison = eql => {
+			const handleAbstractEqualityComparison = (eql) => {
 				const left = this.evaluateExpression(expr.left);
 				const right = this.evaluateExpression(expr.right);
 				const res = new BasicEvaluatedExpression();
@@ -1225,7 +1225,7 @@ class JavascriptParser extends Parser {
 				return handleConstOperation((l, r) => l >= r);
 			}
 		});
-		this.hooks.evaluate.for("UnaryExpression").tap(CLASS_NAME, _expr => {
+		this.hooks.evaluate.for("UnaryExpression").tap(CLASS_NAME, (_expr) => {
 			const expr = /** @type {UnaryExpression} */ (_expr);
 
 			/**
@@ -1234,7 +1234,7 @@ class JavascriptParser extends Parser {
 			 * @param {(operand: T) => boolean | number | bigint | string} operandHandler handler for the operand
 			 * @returns {BasicEvaluatedExpression | undefined} evaluated expression
 			 */
-			const handleConstOperation = operandHandler => {
+			const handleConstOperation = (operandHandler) => {
 				const argument = this.evaluateExpression(expr.argument);
 				if (!argument.isCompileTimeValue()) return;
 				const result = operandHandler(
@@ -1341,22 +1341,22 @@ class JavascriptParser extends Parser {
 					.setSideEffects(argument.couldHaveSideEffects())
 					.setRange(/** @type {Range} */ (expr.range));
 			} else if (expr.operator === "~") {
-				return handleConstOperation(v => ~v);
+				return handleConstOperation((v) => ~v);
 			} else if (expr.operator === "+") {
 				// eslint-disable-next-line no-implicit-coercion
-				return handleConstOperation(v => +v);
+				return handleConstOperation((v) => +v);
 			} else if (expr.operator === "-") {
-				return handleConstOperation(v => -v);
+				return handleConstOperation((v) => -v);
 			}
 		});
 		this.hooks.evaluateTypeof
 			.for("undefined")
-			.tap(CLASS_NAME, expr =>
+			.tap(CLASS_NAME, (expr) =>
 				new BasicEvaluatedExpression()
 					.setString("undefined")
 					.setRange(/** @type {Range} */ (expr.range))
 			);
-		this.hooks.evaluate.for("Identifier").tap(CLASS_NAME, expr => {
+		this.hooks.evaluate.for("Identifier").tap(CLASS_NAME, (expr) => {
 			if (/** @type {Identifier} */ (expr).name === "undefined") {
 				return new BasicEvaluatedExpression()
 					.setUndefined()
@@ -1373,7 +1373,7 @@ class JavascriptParser extends Parser {
 			let cachedExpression;
 			/** @type {GetInfoResult | undefined} */
 			let cachedInfo;
-			this.hooks.evaluate.for(exprType).tap(CLASS_NAME, expr => {
+			this.hooks.evaluate.for(exprType).tap(CLASS_NAME, (expr) => {
 				const expression =
 					/** @type {Identifier | ThisExpression | MemberExpression} */ (expr);
 
@@ -1382,12 +1382,12 @@ class JavascriptParser extends Parser {
 					return this.callHooksForInfoWithFallback(
 						this.hooks.evaluateIdentifier,
 						info.name,
-						_name => {
+						(_name) => {
 							cachedExpression = expression;
 							cachedInfo = info;
 							return undefined;
 						},
-						name => {
+						(name) => {
 							const hook = this.hooks.evaluateDefinedIdentifier.get(name);
 							if (hook !== undefined) {
 								return hook.call(expression);
@@ -1399,7 +1399,7 @@ class JavascriptParser extends Parser {
 			});
 			this.hooks.evaluate
 				.for(exprType)
-				.tap({ name: CLASS_NAME, stage: 100 }, expr => {
+				.tap({ name: CLASS_NAME, stage: 100 }, (expr) => {
 					const expression =
 						/** @type {Identifier | ThisExpression | MemberExpression} */
 						(expr);
@@ -1422,7 +1422,7 @@ class JavascriptParser extends Parser {
 				cachedExpression = cachedInfo = undefined;
 			});
 		};
-		tapEvaluateWithVariableInfo("Identifier", expr => {
+		tapEvaluateWithVariableInfo("Identifier", (expr) => {
 			const info = this.getVariableInfo(/** @type {Identifier} */ (expr).name);
 			if (
 				typeof info === "string" ||
@@ -1437,7 +1437,7 @@ class JavascriptParser extends Parser {
 				};
 			}
 		});
-		tapEvaluateWithVariableInfo("ThisExpression", _expr => {
+		tapEvaluateWithVariableInfo("ThisExpression", (_expr) => {
 			const info = this.getVariableInfo("this");
 			if (
 				typeof info === "string" ||
@@ -1452,7 +1452,7 @@ class JavascriptParser extends Parser {
 				};
 			}
 		});
-		this.hooks.evaluate.for("MetaProperty").tap(CLASS_NAME, expr => {
+		this.hooks.evaluate.for("MetaProperty").tap(CLASS_NAME, (expr) => {
 			const metaProperty = /** @type {MetaProperty} */ (expr);
 
 			return this.callHooksForName(
@@ -1462,14 +1462,14 @@ class JavascriptParser extends Parser {
 				metaProperty
 			);
 		});
-		tapEvaluateWithVariableInfo("MemberExpression", expr =>
+		tapEvaluateWithVariableInfo("MemberExpression", (expr) =>
 			this.getMemberExpressionInfo(
 				/** @type {MemberExpression} */ (expr),
 				ALLOWED_MEMBER_TYPES_EXPRESSION
 			)
 		);
 
-		this.hooks.evaluate.for("CallExpression").tap(CLASS_NAME, _expr => {
+		this.hooks.evaluate.for("CallExpression").tap(CLASS_NAME, (_expr) => {
 			const expr = /** @type {CallExpression} */ (_expr);
 			if (
 				expr.callee.type === "MemberExpression" &&
@@ -1641,7 +1641,7 @@ class JavascriptParser extends Parser {
 			};
 		};
 
-		this.hooks.evaluate.for("TemplateLiteral").tap(CLASS_NAME, _node => {
+		this.hooks.evaluate.for("TemplateLiteral").tap(CLASS_NAME, (_node) => {
 			const node = /** @type {TemplateLiteral} */ (_node);
 
 			const { quasis, parts } = getSimplifiedTemplateResult("cooked", node);
@@ -1654,7 +1654,7 @@ class JavascriptParser extends Parser {
 		});
 		this.hooks.evaluate
 			.for("TaggedTemplateExpression")
-			.tap(CLASS_NAME, _node => {
+			.tap(CLASS_NAME, (_node) => {
 				const node = /** @type {TaggedTemplateExpression} */ (_node);
 				const tag = this.evaluateExpression(node.tag);
 
@@ -1767,44 +1767,46 @@ class JavascriptParser extends Parser {
 					.setSideEffects(param.couldHaveSideEffects())
 					.setRange(/** @type {Range} */ (expr.range));
 			});
-		this.hooks.evaluate.for("ConditionalExpression").tap(CLASS_NAME, _expr => {
-			const expr = /** @type {ConditionalExpression} */ (_expr);
-
-			const condition = this.evaluateExpression(expr.test);
-			const conditionValue = condition.asBool();
-			let res;
-			if (conditionValue === undefined) {
-				const consequent = this.evaluateExpression(expr.consequent);
-				const alternate = this.evaluateExpression(expr.alternate);
-				res = new BasicEvaluatedExpression();
-				if (consequent.isConditional()) {
-					res.setOptions(
-						/** @type {BasicEvaluatedExpression[]} */ (consequent.options)
-					);
+		this.hooks.evaluate
+			.for("ConditionalExpression")
+			.tap(CLASS_NAME, (_expr) => {
+				const expr = /** @type {ConditionalExpression} */ (_expr);
+
+				const condition = this.evaluateExpression(expr.test);
+				const conditionValue = condition.asBool();
+				let res;
+				if (conditionValue === undefined) {
+					const consequent = this.evaluateExpression(expr.consequent);
+					const alternate = this.evaluateExpression(expr.alternate);
+					res = new BasicEvaluatedExpression();
+					if (consequent.isConditional()) {
+						res.setOptions(
+							/** @type {BasicEvaluatedExpression[]} */ (consequent.options)
+						);
+					} else {
+						res.setOptions([consequent]);
+					}
+					if (alternate.isConditional()) {
+						res.addOptions(
+							/** @type {BasicEvaluatedExpression[]} */ (alternate.options)
+						);
+					} else {
+						res.addOptions([alternate]);
+					}
 				} else {
-					res.setOptions([consequent]);
-				}
-				if (alternate.isConditional()) {
-					res.addOptions(
-						/** @type {BasicEvaluatedExpression[]} */ (alternate.options)
+					res = this.evaluateExpression(
+						conditionValue ? expr.consequent : expr.alternate
 					);
-				} else {
-					res.addOptions([alternate]);
+					if (condition.couldHaveSideEffects()) res.setSideEffects();
 				}
-			} else {
-				res = this.evaluateExpression(
-					conditionValue ? expr.consequent : expr.alternate
-				);
-				if (condition.couldHaveSideEffects()) res.setSideEffects();
-			}
-			res.setRange(/** @type {Range} */ (expr.range));
-			return res;
-		});
-		this.hooks.evaluate.for("ArrayExpression").tap(CLASS_NAME, _expr => {
+				res.setRange(/** @type {Range} */ (expr.range));
+				return res;
+			});
+		this.hooks.evaluate.for("ArrayExpression").tap(CLASS_NAME, (_expr) => {
 			const expr = /** @type {ArrayExpression} */ (_expr);
 
 			const items = expr.elements.map(
-				element =>
+				(element) =>
 					element !== null &&
 					element.type !== "SpreadElement" &&
 					this.evaluateExpression(element)
@@ -1814,7 +1816,7 @@ class JavascriptParser extends Parser {
 				.setItems(/** @type {BasicEvaluatedExpression[]} */ (items))
 				.setRange(/** @type {Range} */ (expr.range));
 		});
-		this.hooks.evaluate.for("ChainExpression").tap(CLASS_NAME, _expr => {
+		this.hooks.evaluate.for("ChainExpression").tap(CLASS_NAME, (_expr) => {
 			const expr = /** @type {ChainExpression} */ (_expr);
 			/** @type {Expression[]} */
 			const optionalExpressionsStack = [];
@@ -2680,7 +2682,7 @@ class JavascriptParser extends Parser {
 			this.prevStatement = prev;
 			this.blockPreWalkStatement(statement.declaration);
 			let index = 0;
-			this.enterDeclaration(statement.declaration, def => {
+			this.enterDeclaration(statement.declaration, (def) => {
 				this.hooks.exportSpecifier.call(statement, def, def, index++);
 			});
 		}
@@ -3061,7 +3063,7 @@ class JavascriptParser extends Parser {
 		this.inBlockScope(() => {
 			// Error binding is optional in catch clause since ECMAScript 2019
 			if (catchClause.param !== null) {
-				this.enterPattern(catchClause.param, ident => {
+				this.enterPattern(catchClause.param, (ident) => {
 					this.defineVariable(ident);
 				});
 				this.walkPattern(catchClause.param);
@@ -3620,7 +3622,7 @@ class JavascriptParser extends Parser {
 		 * @param {Expression | SpreadElement} argOrThis arg or this
 		 * @returns {string | VariableInfo | undefined} var info
 		 */
-		const getVarInfo = argOrThis => {
+		const getVarInfo = (argOrThis) => {
 			const renameIdentifier = this.getRenameIdentifier(argOrThis);
 			if (
 				renameIdentifier &&
@@ -3702,8 +3704,8 @@ class JavascriptParser extends Parser {
 		 * @param {FunctionExpression | ArrowFunctionExpression} fn function
 		 * @returns {boolean} true when simple function
 		 */
-		const isSimpleFunction = fn =>
-			fn.params.every(p => p.type === "Identifier");
+		const isSimpleFunction = (fn) =>
+			fn.params.every((p) => p.type === "Identifier");
 		if (
 			expression.callee.type === "MemberExpression" &&
 			expression.callee.object.type.endsWith("FunctionExpression") &&
@@ -3976,7 +3978,7 @@ class JavascriptParser extends Parser {
 				hookMap,
 				members.length === 0 ? exprName.rootInfo : exprName.name,
 				fallback &&
-					(name => fallback(name, exprName.rootInfo, exprName.getMembers)),
+					((name) => fallback(name, exprName.rootInfo, exprName.getMembers)),
 				defined && (() => defined(exprName.name)),
 				...args
 			);
@@ -4110,7 +4112,7 @@ class JavascriptParser extends Parser {
 
 		this.undefineVariable("this");
 
-		this.enterPatterns(params, ident => {
+		this.enterPatterns(params, (ident) => {
 			this.defineVariable(ident);
 		});
 
@@ -4142,7 +4144,7 @@ class JavascriptParser extends Parser {
 			this.undefineVariable("this");
 		}
 
-		this.enterPatterns(params, ident => {
+		this.enterPatterns(params, (ident) => {
 			this.defineVariable(ident);
 		});
 
@@ -4174,7 +4176,7 @@ class JavascriptParser extends Parser {
 			this.undefineVariable("this");
 		}
 
-		this.enterPatterns(params, ident => {
+		this.enterPatterns(params, (ident) => {
 			this.defineVariable(ident);
 		});
 
@@ -4513,7 +4515,7 @@ class JavascriptParser extends Parser {
 			ast = JavascriptParser._parse(source, {
 				sourceType: this.sourceType,
 				onComment: comments,
-				onInsertedSemicolon: pos => semicolons.add(pos)
+				onInsertedSemicolon: (pos) => semicolons.add(pos)
 			});
 		}
 
@@ -4596,7 +4598,7 @@ class JavascriptParser extends Parser {
 					return false;
 				}
 				const items = expr.body.body;
-				return items.every(item => {
+				return items.every((item) => {
 					if (item.type === "StaticBlock") {
 						return false;
 					}
@@ -4649,7 +4651,7 @@ class JavascriptParser extends Parser {
 				return true;
 
 			case "VariableDeclaration":
-				return expr.declarations.every(decl =>
+				return expr.declarations.every((decl) =>
 					this.isPure(decl.init, /** @type {Range} */ (decl.range)[0])
 				);
 
@@ -4673,7 +4675,7 @@ class JavascriptParser extends Parser {
 				);
 
 			case "SequenceExpression":
-				return expr.expressions.every(expr => {
+				return expr.expressions.every((expr) => {
 					const pureFlag = this.isPure(expr, commentsStartPos);
 					commentsStartPos = /** @type {Range} */ (expr.range)[1];
 					return pureFlag;
@@ -4686,13 +4688,13 @@ class JavascriptParser extends Parser {
 						commentsStartPos,
 						/** @type {Range} */ (expr.range)[0]
 					]).some(
-						comment =>
+						(comment) =>
 							comment.type === "Block" &&
 							/^\s*(#|@)__PURE__\s*$/.test(comment.value)
 					);
 				if (!pureFlag) return false;
 				commentsStartPos = /** @type {Range} */ (expr.callee.range)[1];
-				return expr.arguments.every(arg => {
+				return expr.arguments.every((arg) => {
 					if (arg.type === "SpreadElement") return false;
 					const pureFlag = this.isPure(arg, commentsStartPos);
 					commentsStartPos = /** @type {Range} */ (arg.range)[1];

package/lib/javascript/JavascriptParserHelpers.js

@@ -21,7 +21,7 @@ module.exports.approve = () => true;
  * @param {boolean} value the boolean value
  * @returns {(expression: Expression) => BasicEvaluatedExpression} plugin function
  */
-module.exports.evaluateToBoolean = value =>
+module.exports.evaluateToBoolean = (value) =>
 	function booleanExpression(expr) {
 		return new BasicEvaluatedExpression()
 			.setBoolean(value)
@@ -65,7 +65,7 @@ module.exports.evaluateToIdentifier = (
  * @param {number} value the number value
  * @returns {(expression: Expression) => BasicEvaluatedExpression} plugin function
  */
-module.exports.evaluateToNumber = value =>
+module.exports.evaluateToNumber = (value) =>
 	function stringExpression(expr) {
 		return new BasicEvaluatedExpression()
 			.setNumber(value)
@@ -76,7 +76,7 @@ module.exports.evaluateToNumber = value =>
  * @param {string} value the string value
  * @returns {(expression: Expression) => BasicEvaluatedExpression} plugin function
  */
-module.exports.evaluateToString = value =>
+module.exports.evaluateToString = (value) =>
 	function stringExpression(expr) {
 		return new BasicEvaluatedExpression()
 			.setString(value)

package/lib/javascript/StartupHelpers.js

@@ -54,7 +54,7 @@ module.exports.generateEntryStartup = (
 	 * @param {ModuleId} id id
 	 * @returns {string} fn to execute
 	 */
-	const runModule = id => `__webpack_exec__(${JSON.stringify(id)})`;
+	const runModule = (id) => `__webpack_exec__(${JSON.stringify(id)})`;
 	/**
 	 * @param {Chunks} chunks chunks
 	 * @param {ModuleIds} moduleIds module ids
@@ -74,7 +74,7 @@ module.exports.generateEntryStartup = (
 					passive
 						? RuntimeGlobals.onChunksLoaded
 						: RuntimeGlobals.startupEntrypoint
-				}(0, ${JSON.stringify(Array.from(chunks, c => c.id))}, ${fn});`
+				}(0, ${JSON.stringify(Array.from(chunks, (c) => c.id))}, ${fn});`
 			);
 			if (final && passive) {
 				runtime.push(`${EXPORT_PREFIX}${RuntimeGlobals.onChunksLoaded}();`);

package/lib/json/JsonGenerator.js

@@ -29,13 +29,13 @@ const RuntimeGlobals = require("../RuntimeGlobals");
  * @param {JsonValue} data Raw JSON data
  * @returns {undefined|string} stringified data
  */
-const stringifySafe = data => {
+const stringifySafe = (data) => {
 	const stringified = JSON.stringify(data);
 	if (!stringified) {
 		return; // Invalid JSON
 	}
 
-	return stringified.replace(/\u2028|\u2029/g, str =>
+	return stringified.replace(/\u2028|\u2029/g, (str) =>
 		str === "\u2029" ? "\\u2029" : "\\u2028"
 	); // invalid in JavaScript but valid JSON
 };

package/lib/json/JsonModulesPlugin.js

@@ -51,13 +51,13 @@ class JsonModulesPlugin {
 			(compilation, { normalModuleFactory }) => {
 				normalModuleFactory.hooks.createParser
 					.for(JSON_MODULE_TYPE)
-					.tap(PLUGIN_NAME, parserOptions => {
+					.tap(PLUGIN_NAME, (parserOptions) => {
 						validate(parserOptions);
 						return new JsonParser(parserOptions);
 					});
 				normalModuleFactory.hooks.createGenerator
 					.for(JSON_MODULE_TYPE)
-					.tap(PLUGIN_NAME, generatorOptions => {
+					.tap(PLUGIN_NAME, (generatorOptions) => {
 						validateGenerator(generatorOptions);
 						return new JsonGenerator(generatorOptions);
 					});

package/lib/library/AbstractLibraryPlugin.js

@@ -19,6 +19,8 @@ const JavascriptModulesPlugin = require("../javascript/JavascriptModulesPlugin")
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").ModuleRenderContext} ModuleRenderContext */
 /** @typedef {import("../util/Hash")} Hash */
 
 const COMMON_LIBRARY_NAME_MESSAGE =
@@ -58,7 +60,7 @@ class AbstractLibraryPlugin {
 	 */
 	apply(compiler) {
 		const { _pluginName } = this;
-		compiler.hooks.thisCompilation.tap(_pluginName, compilation => {
+		compiler.hooks.thisCompilation.tap(_pluginName, (compilation) => {
 			compilation.hooks.finishModules.tap(
 				{ name: _pluginName, stage: 10 },
 				() => {
@@ -95,7 +97,7 @@ class AbstractLibraryPlugin {
 			 * @param {Chunk} chunk chunk
 			 * @returns {T | false} options for the chunk
 			 */
-			const getOptionsForChunk = chunk => {
+			const getOptionsForChunk = (chunk) => {
 				if (compilation.chunkGraph.getNumberOfEntryModules(chunk) === 0) {
 					return false;
 				}
@@ -162,7 +164,7 @@ class AbstractLibraryPlugin {
 				this.strictRuntimeBailout !==
 				AbstractLibraryPlugin.prototype.strictRuntimeBailout
 			) {
-				hooks.strictRuntimeBailout.tap(_pluginName, renderContext => {
+				hooks.strictRuntimeBailout.tap(_pluginName, (renderContext) => {
 					const options = getOptionsForChunk(renderContext.chunk);
 					if (options === false) return;
 					return this.strictRuntimeBailout(renderContext, {
@@ -173,6 +175,20 @@ class AbstractLibraryPlugin {
 				});
 			}
 
+			if (
+				this.renderModuleContent !==
+				AbstractLibraryPlugin.prototype.renderModuleContent
+			) {
+				hooks.renderModuleContent.tap(
+					_pluginName,
+					(source, module, renderContext) =>
+						this.renderModuleContent(source, module, renderContext, {
+							compilation,
+							chunkGraph: compilation.chunkGraph
+						})
+				);
+			}
+
 			if (
 				this.renderStartup !== AbstractLibraryPlugin.prototype.renderStartup
 			) {
@@ -288,6 +304,17 @@ class AbstractLibraryPlugin {
 		return source;
 	}
 
+	/**
+	 * @param {Source} source source
+	 * @param {Module} module module
+	 * @param {ModuleRenderContext} renderContext render context
+	 * @param {Omit<LibraryContext<T>, 'options'>} libraryContext context
+	 * @returns {Source} source with library export
+	 */
+	renderModuleContent(source, module, renderContext, libraryContext) {
+		return source;
+	}
+
 	/**
 	 * @param {Chunk} chunk the chunk
 	 * @param {Hash} hash hash

package/lib/library/AmdLibraryPlugin.js

@@ -85,13 +85,13 @@ class AmdLibraryPlugin extends AbstractLibraryPlugin {
 		const modules = chunkGraph
 			.getChunkModules(chunk)
 			.filter(
-				m =>
+				(m) =>
 					m instanceof ExternalModule &&
 					(m.externalType === "amd" || m.externalType === "amd-require")
 			);
 		const externals = /** @type {ExternalModule[]} */ (modules);
 		const externalsDepsArray = JSON.stringify(
-			externals.map(m =>
+			externals.map((m) =>
 				typeof m.request === "object" && !Array.isArray(m.request)
 					? m.request.amd
 					: m.request
@@ -99,7 +99,7 @@ class AmdLibraryPlugin extends AbstractLibraryPlugin {
 		);
 		const externalsArguments = externals
 			.map(
-				m =>
+				(m) =>
 					`__WEBPACK_EXTERNAL_MODULE_${Template.toIdentifier(
 						`${chunkGraph.getModuleId(m)}`
 					)}__`

package/lib/library/AssignLibraryPlugin.js

@@ -35,7 +35,7 @@ const IDENTIFIER_REGEX =
  * @param {string} name name to be validated
  * @returns {boolean} true, when valid
  */
-const isNameValid = name =>
+const isNameValid = (name) =>
 	!KEYWORD_REGEX.test(name) && IDENTIFIER_REGEX.test(name);
 
 /**
@@ -197,7 +197,7 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 					...(Array.isArray(options.name) ? options.name : [options.name])
 				]
 			: prefix;
-		return fullName.map(n =>
+		return fullName.map((n) =>
 			compilation.getPath(n, {
 				chunk
 			})

package/lib/library/EnableLibraryPlugin.js

@@ -21,7 +21,7 @@ const enabledTypes = new WeakMap();
  * @param {Compiler} compiler the compiler instance
  * @returns {Set<LibraryType>} enabled types
  */
-const getEnabledTypes = compiler => {
+const getEnabledTypes = (compiler) => {
 	let set = enabledTypes.get(compiler);
 	if (set === undefined) {
 		set = new Set();
@@ -243,7 +243,7 @@ class EnableLibraryPlugin {
 							apply(compiler) {
 								compiler.hooks.thisCompilation.tap(
 									"WarnFalseIifeUmdPlugin",
-									compilation => {
+									(compilation) => {
 										const FalseIIFEUmdWarning = require("../FalseIIFEUmdWarning");
 
 										compilation.warnings.push(new FalseIIFEUmdWarning());