webpack 5.97.1 → 5.104.1

package/lib/optimize/InnerGraph.js

@@ -6,19 +6,20 @@
 "use strict";
 
 const { UsageState } = require("../ExportsInfo");
+const JavascriptParser = require("../javascript/JavascriptParser");
 
-/** @typedef {import("estree").Node} AnyNode */
 /** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("../Parser").ParserState} ParserState */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-/** @typedef {Map<TopLevelSymbol | null, Set<string | TopLevelSymbol> | true | undefined>} InnerGraph */
-/** @typedef {function(boolean | Set<string> | undefined): void} UsageCallback */
+/** @typedef {Set<string | TopLevelSymbol>} InnerGraphValueSet */
+/** @typedef {InnerGraphValueSet | true} InnerGraphValue */
+/** @typedef {TopLevelSymbol | null} InnerGraphKey */
+/** @typedef {Map<InnerGraphKey, InnerGraphValue | undefined>} InnerGraph */
+/** @typedef {(value: boolean | Set<string> | undefined) => void} UsageCallback */
 
 /**
  * @typedef {object} StateObject
@@ -27,7 +28,18 @@ const { UsageState } = require("../ExportsInfo");
  * @property {Map<TopLevelSymbol, Set<UsageCallback>>} usageCallbackMap
  */
 
-/** @typedef {false|StateObject} State */
+/** @typedef {false | StateObject} State */
+
+class TopLevelSymbol {
+	/**
+	 * @param {string} name name of the variable
+	 */
+	constructor(name) {
+		this.name = name;
+	}
+}
+
+module.exports.TopLevelSymbol = TopLevelSymbol;
 
 /** @type {WeakMap<ParserState, State>} */
 const parserStateMap = new WeakMap();
@@ -41,43 +53,10 @@ function getState(parserState) {
 	return parserStateMap.get(parserState);
 }
 
-/**
- * @param {ParserState} parserState parser state
- * @returns {void}
- */
-module.exports.bailout = parserState => {
-	parserStateMap.set(parserState, false);
-};
-
-/**
- * @param {ParserState} parserState parser state
- * @returns {void}
- */
-module.exports.enable = parserState => {
-	const state = parserStateMap.get(parserState);
-	if (state === false) {
-		return;
-	}
-	parserStateMap.set(parserState, {
-		innerGraph: new Map(),
-		currentTopLevelSymbol: undefined,
-		usageCallbackMap: new Map()
-	});
-};
-
-/**
- * @param {ParserState} parserState parser state
- * @returns {boolean} true, when enabled
- */
-module.exports.isEnabled = parserState => {
-	const state = parserStateMap.get(parserState);
-	return Boolean(state);
-};
-
 /**
  * @param {ParserState} state parser state
  * @param {TopLevelSymbol | null} symbol the symbol, or null for all symbols
- * @param {string | TopLevelSymbol | true} usage usage data
+ * @param {Usage} usage usage data
  * @returns {void}
  */
 module.exports.addUsage = (state, symbol, usage) => {
@@ -96,10 +75,12 @@ module.exports.addUsage = (state, symbol, usage) => {
 	}
 };
 
+/** @typedef {string | TopLevelSymbol | true} Usage */
+
 /**
  * @param {JavascriptParser} parser the parser
  * @param {string} name name of variable
- * @param {string | TopLevelSymbol | true} usage usage data
+ * @param {Usage} usage usage data
  * @returns {void}
  */
 module.exports.addVariableUsage = (parser, name, usage) => {
@@ -112,11 +93,78 @@ module.exports.addVariableUsage = (parser, name, usage) => {
 	}
 };
 
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {void}
+ */
+module.exports.bailout = (parserState) => {
+	parserStateMap.set(parserState, false);
+};
+
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {void}
+ */
+module.exports.enable = (parserState) => {
+	const state = parserStateMap.get(parserState);
+	if (state === false) {
+		return;
+	}
+	parserStateMap.set(parserState, {
+		innerGraph: new Map(),
+		currentTopLevelSymbol: undefined,
+		usageCallbackMap: new Map()
+	});
+};
+
+/** @typedef {Set<string> | boolean} UsedByExports */
+
+/**
+ * @param {Dependency} dependency the dependency
+ * @param {UsedByExports | undefined} usedByExports usedByExports info
+ * @param {ModuleGraph} moduleGraph moduleGraph
+ * @returns {null | false | GetConditionFn} function to determine if the connection is active
+ */
+module.exports.getDependencyUsedByExportsCondition = (
+	dependency,
+	usedByExports,
+	moduleGraph
+) => {
+	if (usedByExports === false) return false;
+	if (usedByExports !== true && usedByExports !== undefined) {
+		const selfModule =
+			/** @type {Module} */
+			(moduleGraph.getParentModule(dependency));
+		const exportsInfo = moduleGraph.getExportsInfo(selfModule);
+		return (connections, runtime) => {
+			for (const exportName of usedByExports) {
+				if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused) {
+					return true;
+				}
+			}
+			return false;
+		};
+	}
+	return null;
+};
+
+/**
+ * @param {ParserState} state parser state
+ * @returns {TopLevelSymbol | void} usage data
+ */
+module.exports.getTopLevelSymbol = (state) => {
+	const innerGraphState = getState(state);
+
+	if (innerGraphState) {
+		return innerGraphState.currentTopLevelSymbol;
+	}
+};
+
 /**
  * @param {ParserState} state parser state
  * @returns {void}
  */
-module.exports.inferDependencyUsage = state => {
+module.exports.inferDependencyUsage = (state) => {
 	const innerGraphState = getState(state);
 
 	if (!innerGraphState) {
@@ -124,17 +172,19 @@ module.exports.inferDependencyUsage = state => {
 	}
 
 	const { innerGraph, usageCallbackMap } = innerGraphState;
+	/** @type {Map<InnerGraphKey, InnerGraphValueSet | undefined>} */
 	const processed = new Map();
 	// flatten graph to terminal nodes (string, undefined or true)
 	const nonTerminal = new Set(innerGraph.keys());
 	while (nonTerminal.size > 0) {
 		for (const key of nonTerminal) {
-			/** @type {Set<string|TopLevelSymbol> | true} */
+			/** @type {InnerGraphValue} */
 			let newSet = new Set();
 			let isTerminal = true;
 			const value = innerGraph.get(key);
 			let alreadyProcessed = processed.get(key);
 			if (alreadyProcessed === undefined) {
+				/** @type {InnerGraphValueSet} */
 				alreadyProcessed = new Set();
 				processed.set(key, alreadyProcessed);
 			}
@@ -208,6 +258,45 @@ module.exports.inferDependencyUsage = state => {
 	}
 };
 
+/**
+ * @param {Dependency} dependency the dependency
+ * @param {UsedByExports | undefined} usedByExports usedByExports info
+ * @param {ModuleGraph} moduleGraph moduleGraph
+ * @param {RuntimeSpec} runtime runtime
+ * @returns {boolean} false, when unused. Otherwise true
+ */
+module.exports.isDependencyUsedByExports = (
+	dependency,
+	usedByExports,
+	moduleGraph,
+	runtime
+) => {
+	if (usedByExports === false) return false;
+	if (usedByExports !== true && usedByExports !== undefined) {
+		const selfModule =
+			/** @type {Module} */
+			(moduleGraph.getParentModule(dependency));
+		const exportsInfo = moduleGraph.getExportsInfo(selfModule);
+		let used = false;
+		for (const exportName of usedByExports) {
+			if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused) {
+				used = true;
+			}
+		}
+		if (!used) return false;
+	}
+	return true;
+};
+
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {boolean} true, when enabled
+ */
+module.exports.isEnabled = (parserState) => {
+	const state = parserStateMap.get(parserState);
+	return Boolean(state);
+};
+
 /**
  * @param {ParserState} state parser state
  * @param {UsageCallback} onUsageCallback on usage callback
@@ -246,18 +335,6 @@ module.exports.setTopLevelSymbol = (state, symbol) => {
 	}
 };
 
-/**
- * @param {ParserState} state parser state
- * @returns {TopLevelSymbol|void} usage data
- */
-module.exports.getTopLevelSymbol = state => {
-	const innerGraphState = getState(state);
-
-	if (innerGraphState) {
-		return innerGraphState.currentTopLevelSymbol;
-	}
-};
-
 /**
  * @param {JavascriptParser} parser parser
  * @param {string} name name of variable
@@ -277,75 +354,13 @@ module.exports.tagTopLevelSymbol = (parser, name) => {
 	}
 
 	const fn = new TopLevelSymbol(name);
-	parser.tagVariable(name, topLevelSymbolTag, fn);
+	parser.tagVariable(
+		name,
+		topLevelSymbolTag,
+		fn,
+		JavascriptParser.VariableInfoFlags.Normal
+	);
 	return fn;
 };
 
-/**
- * @param {Dependency} dependency the dependency
- * @param {Set<string> | boolean} usedByExports usedByExports info
- * @param {ModuleGraph} moduleGraph moduleGraph
- * @param {RuntimeSpec} runtime runtime
- * @returns {boolean} false, when unused. Otherwise true
- */
-module.exports.isDependencyUsedByExports = (
-	dependency,
-	usedByExports,
-	moduleGraph,
-	runtime
-) => {
-	if (usedByExports === false) return false;
-	if (usedByExports !== true && usedByExports !== undefined) {
-		const selfModule =
-			/** @type {Module} */
-			(moduleGraph.getParentModule(dependency));
-		const exportsInfo = moduleGraph.getExportsInfo(selfModule);
-		let used = false;
-		for (const exportName of usedByExports) {
-			if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused)
-				used = true;
-		}
-		if (!used) return false;
-	}
-	return true;
-};
-
-/**
- * @param {Dependency} dependency the dependency
- * @param {Set<string> | boolean | undefined} usedByExports usedByExports info
- * @param {ModuleGraph} moduleGraph moduleGraph
- * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
- */
-module.exports.getDependencyUsedByExportsCondition = (
-	dependency,
-	usedByExports,
-	moduleGraph
-) => {
-	if (usedByExports === false) return false;
-	if (usedByExports !== true && usedByExports !== undefined) {
-		const selfModule =
-			/** @type {Module} */
-			(moduleGraph.getParentModule(dependency));
-		const exportsInfo = moduleGraph.getExportsInfo(selfModule);
-		return (connections, runtime) => {
-			for (const exportName of usedByExports) {
-				if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused)
-					return true;
-			}
-			return false;
-		};
-	}
-	return null;
-};
-
-class TopLevelSymbol {
-	/**
-	 * @param {string} name name of the variable
-	 */
-	constructor(name) {
-		this.name = name;
-	}
-}
-
-module.exports.TopLevelSymbol = TopLevelSymbol;
 module.exports.topLevelSymbolTag = topLevelSymbolTag;

package/lib/optimize/InnerGraphPlugin.js

@@ -15,16 +15,15 @@ const InnerGraph = require("./InnerGraph");
 /** @typedef {import("estree").ClassDeclaration} ClassDeclaration */
 /** @typedef {import("estree").ClassExpression} ClassExpression */
 /** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").MaybeNamedClassDeclaration} MaybeNamedClassDeclaration */
+/** @typedef {import("estree").MaybeNamedFunctionDeclaration} MaybeNamedFunctionDeclaration */
 /** @typedef {import("estree").Node} Node */
-/** @typedef {import("estree").VariableDeclarator} VariableDeclaratorNode */
+/** @typedef {import("estree").VariableDeclarator} VariableDeclarator */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../dependencies/HarmonyImportSpecifierDependency")} HarmonyImportSpecifierDependency */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("./InnerGraph").InnerGraph} InnerGraph */
 /** @typedef {import("./InnerGraph").TopLevelSymbol} TopLevelSymbol */
 
 const { topLevelSymbolTag } = InnerGraph;
@@ -57,8 +56,8 @@ class InnerGraphPlugin {
 					/**
 					 * @param {Expression} sup sup
 					 */
-					const onUsageSuper = sup => {
-						InnerGraph.onUsage(parser.state, usedByExports => {
+					const onUsageSuper = (sup) => {
+						InnerGraph.onUsage(parser.state, (usedByExports) => {
 							switch (usedByExports) {
 								case undefined:
 								case true:
@@ -98,22 +97,22 @@ class InnerGraphPlugin {
 					// 2. classes (class declaration, class expression)
 					// 3. variable declarators (const x = ...)
 
-					/** @type {WeakMap<Node, TopLevelSymbol>} */
+					/** @type {WeakMap<Node | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration, TopLevelSymbol>} */
 					const statementWithTopLevelSymbol = new WeakMap();
-					/** @type {WeakMap<Node, Node>} */
+					/** @type {WeakMap<Node | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration, Node>} */
 					const statementPurePart = new WeakMap();
 
-					/** @type {WeakMap<ClassExpression | ClassDeclaration, TopLevelSymbol>} */
+					/** @type {WeakMap<ClassExpression | ClassDeclaration | MaybeNamedClassDeclaration, TopLevelSymbol>} */
 					const classWithTopLevelSymbol = new WeakMap();
 
-					/** @type {WeakMap<VariableDeclaratorNode, TopLevelSymbol>} */
+					/** @type {WeakMap<VariableDeclarator, TopLevelSymbol>} */
 					const declWithTopLevelSymbol = new WeakMap();
-					/** @type {WeakSet<VariableDeclaratorNode>} */
+					/** @type {WeakSet<VariableDeclarator>} */
 					const pureDeclarators = new WeakSet();
 
 					// The following hooks are used during prewalking:
 
-					parser.hooks.preStatement.tap(PLUGIN_NAME, statement => {
+					parser.hooks.preStatement.tap(PLUGIN_NAME, (statement) => {
 						if (!InnerGraph.isEnabled(parser.state)) return;
 
 						if (
@@ -129,7 +128,7 @@ class InnerGraphPlugin {
 						}
 					});
 
-					parser.hooks.blockPreStatement.tap(PLUGIN_NAME, statement => {
+					parser.hooks.blockPreStatement.tap(PLUGIN_NAME, (statement) => {
 						if (!InnerGraph.isEnabled(parser.state)) return;
 
 						if (parser.scope.topLevelScope === true) {
@@ -193,7 +192,7 @@ class InnerGraphPlugin {
 						}
 					});
 
-					parser.hooks.preDeclarator.tap(PLUGIN_NAME, (decl, statement) => {
+					parser.hooks.preDeclarator.tap(PLUGIN_NAME, (decl, _statement) => {
 						if (!InnerGraph.isEnabled(parser.state)) return;
 						if (
 							parser.scope.topLevelScope === true &&
@@ -248,7 +247,7 @@ class InnerGraphPlugin {
 
 					// The following hooks are called during walking:
 
-					parser.hooks.statement.tap(PLUGIN_NAME, statement => {
+					parser.hooks.statement.tap(PLUGIN_NAME, (statement) => {
 						if (!InnerGraph.isEnabled(parser.state)) return;
 						if (parser.scope.topLevelScope === true) {
 							InnerGraph.setTopLevelSymbol(parser.state, undefined);
@@ -258,7 +257,7 @@ class InnerGraphPlugin {
 								InnerGraph.setTopLevelSymbol(parser.state, fn);
 								const purePart = statementPurePart.get(statement);
 								if (purePart) {
-									InnerGraph.onUsage(parser.state, usedByExports => {
+									InnerGraph.onUsage(parser.state, (usedByExports) => {
 										switch (usedByExports) {
 											case undefined:
 											case true:
@@ -334,7 +333,7 @@ class InnerGraphPlugin {
 									) {
 										InnerGraph.setTopLevelSymbol(parser.state, fn);
 										if (element.type !== "MethodDefinition" && element.static) {
-											InnerGraph.onUsage(parser.state, usedByExports => {
+											InnerGraph.onUsage(parser.state, (usedByExports) => {
 												switch (usedByExports) {
 													case undefined:
 													case true:
@@ -361,7 +360,7 @@ class InnerGraphPlugin {
 						}
 					);
 
-					parser.hooks.declarator.tap(PLUGIN_NAME, (decl, statement) => {
+					parser.hooks.declarator.tap(PLUGIN_NAME, (decl, _statement) => {
 						if (!InnerGraph.isEnabled(parser.state)) return;
 						const fn = declWithTopLevelSymbol.get(decl);
 
@@ -376,7 +375,7 @@ class InnerGraphPlugin {
 										onUsageSuper(decl.init.superClass);
 									}
 								} else {
-									InnerGraph.onUsage(parser.state, usedByExports => {
+									InnerGraph.onUsage(parser.state, (usedByExports) => {
 										switch (usedByExports) {
 											case undefined:
 											case true:
@@ -397,7 +396,11 @@ class InnerGraphPlugin {
 									});
 								}
 							}
-							parser.walkExpression(decl.init);
+							parser.walkExpression(
+								/** @type {NonNullable<VariableDeclarator["init"]>} */ (
+									decl.init
+								)
+							);
 							InnerGraph.setTopLevelSymbol(parser.state, undefined);
 							return true;
 						} else if (
@@ -427,10 +430,12 @@ class InnerGraphPlugin {
 								currentTopLevelSymbol || true
 							);
 						});
-					parser.hooks.assign.for(topLevelSymbolTag).tap(PLUGIN_NAME, expr => {
-						if (!InnerGraph.isEnabled(parser.state)) return;
-						if (expr.operator === "=") return true;
-					});
+					parser.hooks.assign
+						.for(topLevelSymbolTag)
+						.tap(PLUGIN_NAME, (expr) => {
+							if (!InnerGraph.isEnabled(parser.state)) return;
+							if (expr.operator === "=") return true;
+						});
 				};
 				normalModuleFactory.hooks.parser
 					.for(JAVASCRIPT_MODULE_TYPE_AUTO)

package/lib/optimize/LimitChunkCountPlugin.js

@@ -15,7 +15,7 @@ const createSchemaValidation = require("../util/create-schema-validation");
 /** @typedef {import("../Compiler")} Compiler */
 
 const validate = createSchemaValidation(
-	require("../../schemas/plugins/optimize/LimitChunkCountPlugin.check.js"),
+	require("../../schemas/plugins/optimize/LimitChunkCountPlugin.check"),
 	() => require("../../schemas/plugins/optimize/LimitChunkCountPlugin.json"),
 	{
 		name: "Limit Chunk Count Plugin",
@@ -51,6 +51,8 @@ const addToSetMap = (map, key, value) => {
 	}
 };
 
+const PLUGIN_NAME = "LimitChunkCountPlugin";
+
 class LimitChunkCountPlugin {
 	/**
 	 * @param {LimitChunkCountPluginOptions=} options options object
@@ -66,13 +68,13 @@ class LimitChunkCountPlugin {
 	 */
 	apply(compiler) {
 		const options = this.options;
-		compiler.hooks.compilation.tap("LimitChunkCountPlugin", compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			compilation.hooks.optimizeChunks.tap(
 				{
-					name: "LimitChunkCountPlugin",
+					name: PLUGIN_NAME,
 					stage: STAGE_ADVANCED
 				},
-				chunks => {
+				(chunks) => {
 					const chunkGraph = compilation.chunkGraph;
 					const maxChunks = options.maxChunks;
 					if (!maxChunks) return;
@@ -83,31 +85,51 @@ class LimitChunkCountPlugin {
 
 					// order chunks in a deterministic way
 					const compareChunksWithGraph = compareChunks(chunkGraph);
-					const orderedChunks = Array.from(chunks).sort(compareChunksWithGraph);
+					/** @type {Chunk[]} */
+					const orderedChunks = [...chunks].sort(compareChunksWithGraph);
 
 					// create a lazy sorted data structure to keep all combinations
 					// this is large. Size = chunks * (chunks - 1) / 2
 					// It uses a multi layer bucket sort plus normal sort in the last layer
 					// It's also lazy so only accessed buckets are sorted
+					/** @type {LazyBucketSortedSet<ChunkCombination, number>} */
 					const combinations = new LazyBucketSortedSet(
 						// Layer 1: ordered by largest size benefit
-						c => c.sizeDiff,
+						(c) => c.sizeDiff,
 						(a, b) => b - a,
+
 						// Layer 2: ordered by smallest combined size
 						/**
 						 * @param {ChunkCombination} c combination
 						 * @returns {number} integrated size
 						 */
-						c => c.integratedSize,
+						(c) => c.integratedSize,
+						/**
+						 * @param {number} a a
+						 * @param {number} b b
+						 * @returns {number} result
+						 */
 						(a, b) => a - b,
+
 						// Layer 3: ordered by position difference in orderedChunk (-> to be deterministic)
 						/**
 						 * @param {ChunkCombination} c combination
 						 * @returns {number} position difference
 						 */
-						c => c.bIdx - c.aIdx,
+						(c) => c.bIdx - c.aIdx,
+						/**
+						 * @param {number} a a
+						 * @param {number} b b
+						 * @returns {number} result
+						 */
 						(a, b) => a - b,
+
 						// Layer 4: ordered by position in orderedChunk (-> to be deterministic)
+						/**
+						 * @param {ChunkCombination} a a
+						 * @param {ChunkCombination} b b
+						 * @returns {number} result
+						 */
 						(a, b) => a.bIdx - b.bIdx
 					);
 
@@ -132,6 +154,7 @@ class LimitChunkCountPlugin {
 
 							const aSize = chunkGraph.getChunkSize(a, options);
 							const bSize = chunkGraph.getChunkSize(b, options);
+							/** @type {ChunkCombination} */
 							const c = {
 								deleted: false,
 								sizeDiff: aSize + bSize - integratedSize,
@@ -274,4 +297,5 @@ class LimitChunkCountPlugin {
 		});
 	}
 }
+
 module.exports = LimitChunkCountPlugin;

package/lib/optimize/MangleExportsPlugin.js

@@ -7,9 +7,9 @@
 
 const { UsageState } = require("../ExportsInfo");
 const {
-	numberToIdentifier,
+	NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS,
 	NUMBER_OF_IDENTIFIER_START_CHARS,
-	NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS
+	numberToIdentifier
 } = require("../Template");
 const { assignDeterministicIds } = require("../ids/IdHelpers");
 const { compareSelect, compareStringsNumeric } = require("../util/comparators");
@@ -22,9 +22,10 @@ const { compareSelect, compareStringsNumeric } = require("../util/comparators");
  * @param {ExportsInfo} exportsInfo exports info
  * @returns {boolean} mangle is possible
  */
-const canMangle = exportsInfo => {
-	if (exportsInfo.otherExportsInfo.getUsed(undefined) !== UsageState.Unused)
+const canMangle = (exportsInfo) => {
+	if (exportsInfo.otherExportsInfo.getUsed(undefined) !== UsageState.Unused) {
 		return false;
+	}
 	let hasSomethingToMangle = false;
 	for (const exportInfo of exportsInfo.exports) {
 		if (exportInfo.canMangle === true) {
@@ -35,7 +36,7 @@ const canMangle = exportsInfo => {
 };
 
 // Sort by name
-const comparator = compareSelect(e => e.name, compareStringsNumeric);
+const comparator = compareSelect((e) => e.name, compareStringsNumeric);
 /**
  * @param {boolean} deterministic use deterministic names
  * @param {ExportsInfo} exportsInfo exports info
@@ -99,7 +100,7 @@ const mangleExportsInfo = (deterministic, exportsInfo, isNamespace) => {
 	if (deterministic) {
 		assignDeterministicIds(
 			mangleableExports,
-			e => e.name,
+			(e) => e.name,
 			comparator,
 			(e, id) => {
 				const name = numberToIdentifier(id);
@@ -142,6 +143,8 @@ const mangleExportsInfo = (deterministic, exportsInfo, isNamespace) => {
 	}
 };
 
+const PLUGIN_NAME = "MangleExportsPlugin";
+
 class MangleExportsPlugin {
 	/**
 	 * @param {boolean} deterministic use deterministic names
@@ -157,24 +160,21 @@ class MangleExportsPlugin {
 	 */
 	apply(compiler) {
 		const { _deterministic: deterministic } = this;
-		compiler.hooks.compilation.tap("MangleExportsPlugin", compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			const moduleGraph = compilation.moduleGraph;
-			compilation.hooks.optimizeCodeGeneration.tap(
-				"MangleExportsPlugin",
-				modules => {
-					if (compilation.moduleMemCaches) {
-						throw new Error(
-							"optimization.mangleExports can't be used with cacheUnaffected as export mangling is a global effect"
-						);
-					}
-					for (const module of modules) {
-						const isNamespace =
-							module.buildMeta && module.buildMeta.exportsType === "namespace";
-						const exportsInfo = moduleGraph.getExportsInfo(module);
-						mangleExportsInfo(deterministic, exportsInfo, isNamespace);
-					}
+			compilation.hooks.optimizeCodeGeneration.tap(PLUGIN_NAME, (modules) => {
+				if (compilation.moduleMemCaches) {
+					throw new Error(
+						"optimization.mangleExports can't be used with cacheUnaffected as export mangling is a global effect"
+					);
+				}
+				for (const module of modules) {
+					const isNamespace =
+						module.buildMeta && module.buildMeta.exportsType === "namespace";
+					const exportsInfo = moduleGraph.getExportsInfo(module);
+					mangleExportsInfo(deterministic, exportsInfo, isNamespace);
 				}
-			);
+			});
 		});
 	}
 }