webpack 5.99.6 → 5.99.8

package/lib/optimize/FlagIncludedChunksPlugin.js

@@ -12,6 +12,8 @@ const { compareIds } = require("../util/comparators");
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
 
+const PLUGIN_NAME = "FlagIncludedChunksPlugin";
+
 class FlagIncludedChunksPlugin {
 	/**
 	 * Apply the plugin
@@ -19,111 +21,104 @@ class FlagIncludedChunksPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap("FlagIncludedChunksPlugin", compilation => {
-			compilation.hooks.optimizeChunkIds.tap(
-				"FlagIncludedChunksPlugin",
-				chunks => {
-					const chunkGraph = compilation.chunkGraph;
-
-					// prepare two bit integers for each module
-					// 2^31 is the max number represented as SMI in v8
-					// we want the bits distributed this way:
-					// the bit 2^31 is pretty rar and only one module should get it
-					// so it has a probability of 1 / modulesCount
-					// the first bit (2^0) is the easiest and every module could get it
-					// if it doesn't get a better bit
-					// from bit 2^n to 2^(n+1) there is a probability of p
-					// so 1 / modulesCount == p^31
-					// <=> p = sqrt31(1 / modulesCount)
-					// so we use a modulo of 1 / sqrt31(1 / modulesCount)
-					/** @type {WeakMap<Module, number>} */
-					const moduleBits = new WeakMap();
-					const modulesCount = compilation.modules.size;
-
-					// precalculate the modulo values for each bit
-					const modulo = 1 / (1 / modulesCount) ** (1 / 31);
-					const modulos = Array.from(
-						{ length: 31 },
-						(x, i) => (modulo ** i) | 0
-					);
-
-					// iterate all modules to generate bit values
-					let i = 0;
-					for (const module of compilation.modules) {
-						let bit = 30;
-						while (i % modulos[bit] !== 0) {
-							bit--;
-						}
-						moduleBits.set(module, 1 << bit);
-						i++;
+		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+			compilation.hooks.optimizeChunkIds.tap(PLUGIN_NAME, chunks => {
+				const chunkGraph = compilation.chunkGraph;
+
+				// prepare two bit integers for each module
+				// 2^31 is the max number represented as SMI in v8
+				// we want the bits distributed this way:
+				// the bit 2^31 is pretty rar and only one module should get it
+				// so it has a probability of 1 / modulesCount
+				// the first bit (2^0) is the easiest and every module could get it
+				// if it doesn't get a better bit
+				// from bit 2^n to 2^(n+1) there is a probability of p
+				// so 1 / modulesCount == p^31
+				// <=> p = sqrt31(1 / modulesCount)
+				// so we use a modulo of 1 / sqrt31(1 / modulesCount)
+				/** @type {WeakMap<Module, number>} */
+				const moduleBits = new WeakMap();
+				const modulesCount = compilation.modules.size;
+
+				// precalculate the modulo values for each bit
+				const modulo = 1 / (1 / modulesCount) ** (1 / 31);
+				const modulos = Array.from({ length: 31 }, (x, i) => (modulo ** i) | 0);
+
+				// iterate all modules to generate bit values
+				let i = 0;
+				for (const module of compilation.modules) {
+					let bit = 30;
+					while (i % modulos[bit] !== 0) {
+						bit--;
 					}
+					moduleBits.set(module, 1 << bit);
+					i++;
+				}
 
-					// iterate all chunks to generate bitmaps
-					/** @type {WeakMap<Chunk, number>} */
-					const chunkModulesHash = new WeakMap();
-					for (const chunk of chunks) {
-						let hash = 0;
-						for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
-							hash |= /** @type {number} */ (moduleBits.get(module));
-						}
-						chunkModulesHash.set(chunk, hash);
+				// iterate all chunks to generate bitmaps
+				/** @type {WeakMap<Chunk, number>} */
+				const chunkModulesHash = new WeakMap();
+				for (const chunk of chunks) {
+					let hash = 0;
+					for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+						hash |= /** @type {number} */ (moduleBits.get(module));
+					}
+					chunkModulesHash.set(chunk, hash);
+				}
+
+				for (const chunkA of chunks) {
+					const chunkAHash =
+						/** @type {number} */
+						(chunkModulesHash.get(chunkA));
+					const chunkAModulesCount = chunkGraph.getNumberOfChunkModules(chunkA);
+					if (chunkAModulesCount === 0) continue;
+					let bestModule;
+					for (const module of chunkGraph.getChunkModulesIterable(chunkA)) {
+						if (
+							bestModule === undefined ||
+							chunkGraph.getNumberOfModuleChunks(bestModule) >
+								chunkGraph.getNumberOfModuleChunks(module)
+						)
+							bestModule = module;
 					}
+					loopB: for (const chunkB of chunkGraph.getModuleChunksIterable(
+						/** @type {Module} */ (bestModule)
+					)) {
+						// as we iterate the same iterables twice
+						// skip if we find ourselves
+						if (chunkA === chunkB) continue;
 
-					for (const chunkA of chunks) {
-						const chunkAHash =
+						const chunkBModulesCount =
+							chunkGraph.getNumberOfChunkModules(chunkB);
+
+						// ids for empty chunks are not included
+						if (chunkBModulesCount === 0) continue;
+
+						// instead of swapping A and B just bail
+						// as we loop twice the current A will be B and B then A
+						if (chunkAModulesCount > chunkBModulesCount) continue;
+
+						// is chunkA in chunkB?
+
+						// we do a cheap check for the hash value
+						const chunkBHash =
 							/** @type {number} */
-							(chunkModulesHash.get(chunkA));
-						const chunkAModulesCount =
-							chunkGraph.getNumberOfChunkModules(chunkA);
-						if (chunkAModulesCount === 0) continue;
-						let bestModule;
-						for (const module of chunkGraph.getChunkModulesIterable(chunkA)) {
-							if (
-								bestModule === undefined ||
-								chunkGraph.getNumberOfModuleChunks(bestModule) >
-									chunkGraph.getNumberOfModuleChunks(module)
-							)
-								bestModule = module;
-						}
-						loopB: for (const chunkB of chunkGraph.getModuleChunksIterable(
-							/** @type {Module} */ (bestModule)
-						)) {
-							// as we iterate the same iterables twice
-							// skip if we find ourselves
-							if (chunkA === chunkB) continue;
-
-							const chunkBModulesCount =
-								chunkGraph.getNumberOfChunkModules(chunkB);
-
-							// ids for empty chunks are not included
-							if (chunkBModulesCount === 0) continue;
-
-							// instead of swapping A and B just bail
-							// as we loop twice the current A will be B and B then A
-							if (chunkAModulesCount > chunkBModulesCount) continue;
-
-							// is chunkA in chunkB?
-
-							// we do a cheap check for the hash value
-							const chunkBHash =
-								/** @type {number} */
-								(chunkModulesHash.get(chunkB));
-							if ((chunkBHash & chunkAHash) !== chunkAHash) continue;
-
-							// compare all modules
-							for (const m of chunkGraph.getChunkModulesIterable(chunkA)) {
-								if (!chunkGraph.isModuleInChunk(m, chunkB)) continue loopB;
-							}
-
-							/** @type {ChunkId[]} */
-							(chunkB.ids).push(/** @type {ChunkId} */ (chunkA.id));
-							// https://github.com/webpack/webpack/issues/18837
-							/** @type {ChunkId[]} */
-							(chunkB.ids).sort(compareIds);
+							(chunkModulesHash.get(chunkB));
+						if ((chunkBHash & chunkAHash) !== chunkAHash) continue;
+
+						// compare all modules
+						for (const m of chunkGraph.getChunkModulesIterable(chunkA)) {
+							if (!chunkGraph.isModuleInChunk(m, chunkB)) continue loopB;
 						}
+
+						/** @type {ChunkId[]} */
+						(chunkB.ids).push(/** @type {ChunkId} */ (chunkA.id));
+						// https://github.com/webpack/webpack/issues/18837
+						/** @type {ChunkId[]} */
+						(chunkB.ids).sort(compareIds);
 					}
 				}
-			);
+			});
 		});
 	}
 }

package/lib/optimize/LimitChunkCountPlugin.js

@@ -51,6 +51,8 @@ const addToSetMap = (map, key, value) => {
 	}
 };
 
+const PLUGIN_NAME = "LimitChunkCountPlugin";
+
 class LimitChunkCountPlugin {
 	/**
 	 * @param {LimitChunkCountPluginOptions=} options options object
@@ -66,10 +68,10 @@ 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 => {

package/lib/optimize/MangleExportsPlugin.js

@@ -142,6 +142,8 @@ const mangleExportsInfo = (deterministic, exportsInfo, isNamespace) => {
 	}
 };
 
+const PLUGIN_NAME = "MangleExportsPlugin";
+
 class MangleExportsPlugin {
 	/**
 	 * @param {boolean} deterministic use deterministic names
@@ -157,24 +159,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);
 				}
-			);
+			});
 		});
 	}
 }

package/lib/optimize/MinChunkSizePlugin.js

@@ -21,6 +21,8 @@ const validate = createSchemaValidation(
 	}
 );
 
+const PLUGIN_NAME = "MinChunkSizePlugin";
+
 class MinChunkSizePlugin {
 	/**
 	 * @param {MinChunkSizePluginOptions} options options object
@@ -38,10 +40,10 @@ class MinChunkSizePlugin {
 	apply(compiler) {
 		const options = this.options;
 		const minChunkSize = options.minChunkSize;
-		compiler.hooks.compilation.tap("MinChunkSizePlugin", compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
 			compilation.hooks.optimizeChunks.tap(
 				{
-					name: "MinChunkSizePlugin",
+					name: PLUGIN_NAME,
 					stage: STAGE_ADVANCED
 				},
 				chunks => {

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -48,6 +48,8 @@ const ConcatenatedModule = require("./ConcatenatedModule");
  */
 const formatBailoutReason = msg => `ModuleConcatenation bailout: ${msg}`;
 
+const PLUGIN_NAME = "ModuleConcatenationPlugin";
+
 class ModuleConcatenationPlugin {
 	/**
 	 * Apply the plugin
@@ -56,7 +58,7 @@ class ModuleConcatenationPlugin {
 	 */
 	apply(compiler) {
 		const { _backCompat: backCompat } = compiler;
-		compiler.hooks.compilation.tap("ModuleConcatenationPlugin", compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
 			if (compilation.moduleMemCaches) {
 				throw new Error(
 					"optimization.concatenateModules can't be used with cacheUnaffected as module concatenation is a global effect"
@@ -133,7 +135,7 @@ class ModuleConcatenationPlugin {
 
 			compilation.hooks.optimizeChunkModules.tapAsync(
 				{
-					name: "ModuleConcatenationPlugin",
+					name: PLUGIN_NAME,
 					stage: STAGE_DEFAULT
 				},
 				(allChunks, modules, callback) => {
@@ -396,9 +398,9 @@ class ModuleConcatenationPlugin {
 								newModule.build(
 									compiler.options,
 									compilation,
-									/** @type {TODO} */
+									/** @type {EXPECTED_ANY} */
 									(null),
-									/** @type {TODO} */
+									/** @type {EXPECTED_ANY} */
 									(null),
 									err => {
 										if (err) {

package/lib/optimize/RealContentHashPlugin.js

@@ -113,6 +113,8 @@ const compilationHooksMap = new WeakMap();
  * @property {string=} hashDigest the hash digest to use
  */
 
+const PLUGIN_NAME = "RealContentHashPlugin";
+
 class RealContentHashPlugin {
 	/**
 	 * @param {Compilation} compilation the compilation
@@ -148,7 +150,7 @@ class RealContentHashPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap("RealContentHashPlugin", compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
 			const cacheAnalyse = compilation.getCache(
 				"RealContentHashPlugin|analyse"
 			);
@@ -158,7 +160,7 @@ class RealContentHashPlugin {
 			const hooks = RealContentHashPlugin.getCompilationHooks(compilation);
 			compilation.hooks.processAssets.tapPromise(
 				{
-					name: "RealContentHashPlugin",
+					name: PLUGIN_NAME,
 					stage: Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_HASH
 				},
 				async () => {

package/lib/optimize/RemoveEmptyChunksPlugin.js

@@ -10,6 +10,8 @@ const { STAGE_BASIC, STAGE_ADVANCED } = require("../OptimizationStages");
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
+const PLUGIN_NAME = "RemoveEmptyChunksPlugin";
+
 class RemoveEmptyChunksPlugin {
 	/**
 	 * Apply the plugin
@@ -17,7 +19,7 @@ class RemoveEmptyChunksPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap("RemoveEmptyChunksPlugin", compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
 			/**
 			 * @param {Iterable<Chunk>} chunks the chunks array
 			 * @returns {void}
@@ -39,14 +41,14 @@ class RemoveEmptyChunksPlugin {
 			// TODO do it once
 			compilation.hooks.optimizeChunks.tap(
 				{
-					name: "RemoveEmptyChunksPlugin",
+					name: PLUGIN_NAME,
 					stage: STAGE_BASIC
 				},
 				handler
 			);
 			compilation.hooks.optimizeChunks.tap(
 				{
-					name: "RemoveEmptyChunksPlugin",
+					name: PLUGIN_NAME,
 					stage: STAGE_ADVANCED
 				},
 				handler

package/lib/optimize/RemoveParentModulesPlugin.js

@@ -59,13 +59,15 @@ function* getModulesFromMask(mask, ordinalModules) {
 	}
 }
 
+const PLUGIN_NAME = "RemoveParentModulesPlugin";
+
 class RemoveParentModulesPlugin {
 	/**
 	 * @param {Compiler} compiler the compiler
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap("RemoveParentModulesPlugin", compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
 			/**
 			 * @param {Iterable<Chunk>} chunks the chunks
 			 * @param {ChunkGroup[]} chunkGroups the chunk groups
@@ -193,7 +195,7 @@ class RemoveParentModulesPlugin {
 			};
 			compilation.hooks.optimizeChunks.tap(
 				{
-					name: "RemoveParentModulesPlugin",
+					name: PLUGIN_NAME,
 					stage: STAGE_BASIC
 				},
 				handler

package/lib/optimize/RuntimeChunkPlugin.js

@@ -9,16 +9,17 @@
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Entrypoint")} Entrypoint */
 
+const PLUGIN_NAME = "RuntimeChunkPlugin";
+
+/** @typedef {(entrypoint: { name: string }) => string} RuntimeChunkFunction */
+
 class RuntimeChunkPlugin {
 	/**
-	 * @param {{ name?: (entrypoint: { name: string }) => string }} options options
+	 * @param {{ name?: RuntimeChunkFunction }=} options options
 	 */
 	constructor(options) {
 		this.options = {
-			/**
-			 * @param {Entrypoint} entrypoint entrypoint name
-			 * @returns {string} runtime chunk name
-			 */
+			/** @type {RuntimeChunkFunction} */
 			name: entrypoint => `runtime~${entrypoint.name}`,
 			...options
 		};
@@ -30,26 +31,23 @@ class RuntimeChunkPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.thisCompilation.tap("RuntimeChunkPlugin", compilation => {
-			compilation.hooks.addEntry.tap(
-				"RuntimeChunkPlugin",
-				(_, { name: entryName }) => {
-					if (entryName === undefined) return;
-					const data =
-						/** @type {EntryData} */
-						(compilation.entries.get(entryName));
-					if (data.options.runtime === undefined && !data.options.dependOn) {
-						// Determine runtime chunk name
-						let name =
-							/** @type {string | ((entrypoint: { name: string }) => string)} */
-							(this.options.name);
-						if (typeof name === "function") {
-							name = name({ name: entryName });
-						}
-						data.options.runtime = name;
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, compilation => {
+			compilation.hooks.addEntry.tap(PLUGIN_NAME, (_, { name: entryName }) => {
+				if (entryName === undefined) return;
+				const data =
+					/** @type {EntryData} */
+					(compilation.entries.get(entryName));
+				if (data.options.runtime === undefined && !data.options.dependOn) {
+					// Determine runtime chunk name
+					let name =
+						/** @type {string | RuntimeChunkFunction} */
+						(this.options.name);
+					if (typeof name === "function") {
+						name = name({ name: entryName });
 					}
+					data.options.runtime = name;
 				}
-			);
+			});
 		});
 	}
 }

package/lib/optimize/SideEffectsFlagPlugin.js

@@ -145,7 +145,8 @@ class SideEffectsFlagPlugin {
 										if (
 											!parser.isPure(
 												statement.expression,
-												/** @type {Range} */ (statement.range)[0]
+												/** @type {Range} */
+												(statement.range)[0]
 											)
 										) {
 											sideEffectsStatement = statement;
@@ -157,7 +158,8 @@ class SideEffectsFlagPlugin {
 										if (
 											!parser.isPure(
 												statement.test,
-												/** @type {Range} */ (statement.range)[0]
+												/** @type {Range} */
+												(statement.range)[0]
 											)
 										) {
 											sideEffectsStatement = statement;
@@ -193,7 +195,8 @@ class SideEffectsFlagPlugin {
 										if (
 											!parser.isPure(
 												statement.discriminant,
-												/** @type {Range} */ (statement.range)[0]
+												/** @type {Range} */
+												(statement.range)[0]
 											)
 										) {
 											sideEffectsStatement = statement;
@@ -216,9 +219,9 @@ class SideEffectsFlagPlugin {
 									case "ExportDefaultDeclaration":
 										if (
 											!parser.isPure(
-												/** @type {TODO} */
-												(statement.declaration),
-												/** @type {Range} */ (statement.range)[0]
+												statement.declaration,
+												/** @type {Range} */
+												(statement.range)[0]
 											)
 										) {
 											sideEffectsStatement = statement;

package/lib/optimize/SplitChunksPlugin.js

@@ -21,6 +21,7 @@ const { makePathsRelative } = require("../util/identifier");
 const memoize = require("../util/memoize");
 const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 
+/** @typedef {import("../../declarations/WebpackOptions").HashFunction} HashFunction */
 /** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksCacheGroup} OptimizationSplitChunksCacheGroup */
 /** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksGetCacheGroups} OptimizationSplitChunksGetCacheGroups */
 /** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksOptions} OptimizationSplitChunksOptions */
@@ -33,7 +34,6 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../TemplatedPathPlugin").TemplatePath} TemplatePath */
-/** @typedef {import("../util/createHash").Algorithm} Algorithm */
 /** @typedef {import("../util/deterministicGrouping").GroupedItems<Module>} DeterministicGroupingGroupedItemsForModule */
 /** @typedef {import("../util/deterministicGrouping").Options<Module>} DeterministicGroupingOptionsForModule */
 
@@ -184,7 +184,7 @@ const hashFilename = (name, outputOptions) => {
 	const digest =
 		/** @type {string} */
 		(
-			createHash(/** @type {Algorithm} */ (outputOptions.hashFunction))
+			createHash(/** @type {HashFunction} */ (outputOptions.hashFunction))
 				.update(name)
 				.digest(outputOptions.hashDigest)
 		);
@@ -631,6 +631,8 @@ const createCacheGroupSource = (options, key, defaultSizeTypes) => {
 	};
 };
 
+const PLUGIN_NAME = "SplitChunksPlugin";
+
 module.exports = class SplitChunksPlugin {
 	/**
 	 * @param {OptimizationSplitChunksOptions=} options plugin options
@@ -822,15 +824,15 @@ module.exports = class SplitChunksPlugin {
 			compiler.context,
 			compiler.root
 		);
-		compiler.hooks.thisCompilation.tap("SplitChunksPlugin", compilation => {
-			const logger = compilation.getLogger("webpack.SplitChunksPlugin");
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, compilation => {
+			const logger = compilation.getLogger(`webpack.${PLUGIN_NAME}`);
 			let alreadyOptimized = false;
-			compilation.hooks.unseal.tap("SplitChunksPlugin", () => {
+			compilation.hooks.unseal.tap(PLUGIN_NAME, () => {
 				alreadyOptimized = false;
 			});
 			compilation.hooks.optimizeChunks.tap(
 				{
-					name: "SplitChunksPlugin",
+					name: PLUGIN_NAME,
 					stage: STAGE_ADVANCED
 				},
 				chunks => {
@@ -1171,7 +1173,7 @@ module.exports = class SplitChunksPlugin {
 										alreadyReportedErrors.add(name);
 										compilation.errors.push(
 											new WebpackError(
-												"SplitChunksPlugin\n" +
+												`${PLUGIN_NAME}\n` +
 													`Cache group "${cacheGroup.key}" conflicts with existing chunk.\n` +
 													`Both have the same name "${name}" and existing chunk is not a parent of the selected modules.\n` +
 													"Use a different name for the cache group or make sure that the existing chunk is a parent (e. g. via dependOn).\n" +

package/lib/performance/SizeLimitsPlugin.js

@@ -41,6 +41,8 @@ const isOverSizeLimitSet = new WeakSet();
  */
 const excludeSourceMap = (name, source, info) => !info.development;
 
+const PLUGIN_NAME = "SizeLimitsPlugin";
+
 module.exports = class SizeLimitsPlugin {
 	/**
 	 * @param {PerformanceOptions} options the plugin options
@@ -71,7 +73,7 @@ module.exports = class SizeLimitsPlugin {
 		const hints = this.hints;
 		const assetFilter = this.assetFilter || excludeSourceMap;
 
-		compiler.hooks.afterEmit.tap("SizeLimitsPlugin", compilation => {
+		compiler.hooks.afterEmit.tap(PLUGIN_NAME, compilation => {
 			/** @type {WebpackError[]} */
 			const warnings = [];