webpack 5.99.6 → 5.99.8

package/lib/AutomaticPrefetchPlugin.js

@@ -11,6 +11,8 @@ const PrefetchDependency = require("./dependencies/PrefetchDependency");
 
 /** @typedef {import("./Compiler")} Compiler */
 
+const PLUGIN_NAME = "AutomaticPrefetchPlugin";
+
 class AutomaticPrefetchPlugin {
 	/**
 	 * Apply the plugin
@@ -19,7 +21,7 @@ class AutomaticPrefetchPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"AutomaticPrefetchPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					PrefetchDependency,
@@ -29,7 +31,7 @@ class AutomaticPrefetchPlugin {
 		);
 		/** @type {{context: string | null, request: string}[] | null} */
 		let lastModules = null;
-		compiler.hooks.afterCompile.tap("AutomaticPrefetchPlugin", compilation => {
+		compiler.hooks.afterCompile.tap(PLUGIN_NAME, compilation => {
 			lastModules = [];
 
 			for (const m of compilation.modules) {
@@ -41,26 +43,23 @@ class AutomaticPrefetchPlugin {
 				}
 			}
 		});
-		compiler.hooks.make.tapAsync(
-			"AutomaticPrefetchPlugin",
-			(compilation, callback) => {
-				if (!lastModules) return callback();
-				asyncLib.each(
-					lastModules,
-					(m, callback) => {
-						compilation.addModuleChain(
-							m.context || compiler.context,
-							new PrefetchDependency(`!!${m.request}`),
-							callback
-						);
-					},
-					err => {
-						lastModules = null;
-						callback(err);
-					}
-				);
-			}
-		);
+		compiler.hooks.make.tapAsync(PLUGIN_NAME, (compilation, callback) => {
+			if (!lastModules) return callback();
+			asyncLib.each(
+				lastModules,
+				(m, callback) => {
+					compilation.addModuleChain(
+						m.context || compiler.context,
+						new PrefetchDependency(`!!${m.request}`),
+						callback
+					);
+				},
+				err => {
+					lastModules = null;
+					callback(err);
+				}
+			);
+		});
 	}
 }
 module.exports = AutomaticPrefetchPlugin;

package/lib/BannerPlugin.js

@@ -44,6 +44,8 @@ const wrapComment = str => {
 		.trimEnd()}\n */`;
 };
 
+const PLUGIN_NAME = "BannerPlugin";
+
 class BannerPlugin {
 	/**
 	 * @param {BannerPluginArgument} options options object
@@ -91,47 +93,41 @@ class BannerPlugin {
 		const stage =
 			this.options.stage || Compilation.PROCESS_ASSETS_STAGE_ADDITIONS;
 
-		compiler.hooks.compilation.tap("BannerPlugin", compilation => {
-			compilation.hooks.processAssets.tap(
-				{
-					name: "BannerPlugin",
-					stage
-				},
-				() => {
-					for (const chunk of compilation.chunks) {
-						if (options.entryOnly && !chunk.canBeInitial()) {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+			compilation.hooks.processAssets.tap({ name: PLUGIN_NAME, stage }, () => {
+				for (const chunk of compilation.chunks) {
+					if (options.entryOnly && !chunk.canBeInitial()) {
+						continue;
+					}
+
+					for (const file of chunk.files) {
+						if (!matchObject(file)) {
 							continue;
 						}
 
-						for (const file of chunk.files) {
-							if (!matchObject(file)) {
-								continue;
+						/** @type {PathData} */
+						const data = { chunk, filename: file };
+
+						const comment = compilation.getPath(
+							/** @type {TemplatePath} */
+							(banner),
+							data
+						);
+
+						compilation.updateAsset(file, old => {
+							const cached = cache.get(old);
+							if (!cached || cached.comment !== comment) {
+								const source = options.footer
+									? new ConcatSource(old, "\n", comment)
+									: new ConcatSource(comment, "\n", old);
+								cache.set(old, { source, comment });
+								return source;
 							}
-
-							/** @type {PathData} */
-							const data = { chunk, filename: file };
-
-							const comment = compilation.getPath(
-								/** @type {TemplatePath} */
-								(banner),
-								data
-							);
-
-							compilation.updateAsset(file, old => {
-								const cached = cache.get(old);
-								if (!cached || cached.comment !== comment) {
-									const source = options.footer
-										? new ConcatSource(old, "\n", comment)
-										: new ConcatSource(comment, "\n", old);
-									cache.set(old, { source, comment });
-									return source;
-								}
-								return cached.source;
-							});
-						}
+							return cached.source;
+						});
 					}
 				}
-			);
+			});
 		});
 	}
 }

package/lib/CleanPlugin.js

@@ -296,6 +296,8 @@ const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
 /** @type {WeakMap<Compilation, CleanPluginCompilationHooks>} */
 const compilationHooksMap = new WeakMap();
 
+const PLUGIN_NAME = "CleanPlugin";
+
 class CleanPlugin {
 	/**
 	 * @param {Compilation} compilation the compilation
@@ -349,18 +351,18 @@ class CleanPlugin {
 
 		compiler.hooks.emit.tapAsync(
 			{
-				name: "CleanPlugin",
+				name: PLUGIN_NAME,
 				stage: 100
 			},
 			(compilation, callback) => {
 				const hooks = CleanPlugin.getCompilationHooks(compilation);
-				const logger = compilation.getLogger("webpack.CleanPlugin");
+				const logger = compilation.getLogger(`webpack.${PLUGIN_NAME}`);
 				const fs = /** @type {OutputFileSystem} */ (compiler.outputFileSystem);
 
 				if (!fs.readdir) {
 					return callback(
 						new Error(
-							"CleanPlugin: Output filesystem doesn't support listing directories (readdir)"
+							`${PLUGIN_NAME}: Output filesystem doesn't support listing directories (readdir)`
 						)
 					);
 				}

package/lib/Compilation.js

@@ -130,7 +130,7 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModule} StatsModule */
 /** @typedef {import("./TemplatedPathPlugin").TemplatePath} TemplatePath */
 /** @typedef {import("./util/Hash")} Hash */
-/** @typedef {import("./util/createHash").Algorithm} Algorithm */
+/** @typedef {import("../declarations/WebpackOptions").HashFunction} HashFunction */
 /**
  * @template T
  * @typedef {import("./util/deprecation").FakeHook<T>} FakeHook<T>
@@ -973,9 +973,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			/** @type {SyncBailHook<[string, LogEntry], boolean | void>} */
 			log: new SyncBailHook(["origin", "logEntry"]),
 
-			/** @type {SyncWaterfallHook<[WebpackError[]]>} */
+			/** @type {SyncWaterfallHook<[Error[]]>} */
 			processWarnings: new SyncWaterfallHook(["warnings"]),
-			/** @type {SyncWaterfallHook<[WebpackError[]]>} */
+			/** @type {SyncWaterfallHook<[Error[]]>} */
 			processErrors: new SyncWaterfallHook(["errors"]),
 
 			/** @type {HookMap<SyncHook<[Partial<NormalizedStatsOptions>, CreateStatsOptionsContext]>>} */
@@ -1143,9 +1143,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.assetsInfo = new Map();
 		/** @type {Map<string, Map<string, Set<string>>>} */
 		this._assetsRelatedIn = new Map();
-		/** @type {WebpackError[]} */
+		/** @type {Error[]} */
 		this.errors = [];
-		/** @type {WebpackError[]} */
+		/** @type {Error[]} */
 		this.warnings = [];
 		/** @type {Compilation[]} */
 		this.children = [];
@@ -1520,7 +1520,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					this.options,
 					this,
 					this.resolverFactory.get("normal", module.resolveOptions),
-					/** @type {InputFileSystem} */ (this.inputFileSystem),
+					/** @type {InputFileSystem} */
+					(this.inputFileSystem),
 					err => {
 						if (currentProfile !== undefined) {
 							currentProfile.markBuildingEnd();
@@ -4313,7 +4314,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	) {
 		let moduleHashDigest;
 		try {
-			const moduleHash = createHash(/** @type {Algorithm} */ (hashFunction));
+			const moduleHash = createHash(/** @type {HashFunction} */ (hashFunction));
 			module.updateHash(moduleHash, {
 				chunkGraph,
 				runtime,
@@ -4341,7 +4342,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		const hashFunction = outputOptions.hashFunction;
 		const hashDigest = outputOptions.hashDigest;
 		const hashDigestLength = outputOptions.hashDigestLength;
-		const hash = createHash(/** @type {Algorithm} */ (hashFunction));
+		const hash = createHash(/** @type {HashFunction} */ (hashFunction));
 		if (outputOptions.hashSalt) {
 			hash.update(outputOptions.hashSalt);
 		}
@@ -4524,7 +4525,9 @@ This prevents using hashes of each other and should be avoided.`);
 			this.logger.timeAggregate("hashing: hash runtime modules");
 			try {
 				this.logger.time("hashing: hash chunks");
-				const chunkHash = createHash(/** @type {Algorithm} */ (hashFunction));
+				const chunkHash = createHash(
+					/** @type {HashFunction} */ (hashFunction)
+				);
 				if (outputOptions.hashSalt) {
 					chunkHash.update(outputOptions.hashSalt);
 				}
@@ -4577,7 +4580,9 @@ This prevents using hashes of each other and should be avoided.`);
 			for (const module of /** @type {Iterable<RuntimeModule>} */ (
 				chunkGraph.getChunkFullHashModulesIterable(chunk)
 			)) {
-				const moduleHash = createHash(/** @type {Algorithm} */ (hashFunction));
+				const moduleHash = createHash(
+					/** @type {HashFunction} */ (hashFunction)
+				);
 				module.updateHash(moduleHash, {
 					chunkGraph,
 					runtime: chunk.runtime,
@@ -4599,7 +4604,7 @@ This prevents using hashes of each other and should be avoided.`);
 					(codeGenerationJobsMap.get(oldHash)).get(module)
 				).hash = moduleHashDigest;
 			}
-			const chunkHash = createHash(/** @type {Algorithm} */ (hashFunction));
+			const chunkHash = createHash(/** @type {HashFunction} */ (hashFunction));
 			chunkHash.update(chunk.hash);
 			chunkHash.update(this.hash);
 			const chunkHashDigest =
@@ -5486,9 +5491,9 @@ This prevents using hashes of each other and should be avoided.`);
 											if (strictModuleExceptionHandling) {
 												if (id) delete moduleCache[id];
 											} else if (strictModuleErrorHandling) {
-												moduleObject.error = /** @type {WebpackError} */ (
-													execErr
-												);
+												moduleObject.error =
+													/** @type {WebpackError} */
+													(execErr);
 											}
 											if (!(/** @type {WebpackError} */ (execErr).module)) {
 												/** @type {WebpackError} */
@@ -5515,7 +5520,8 @@ This prevents using hashes of each other and should be avoided.`);
 										`Execution of module code from module graph (${
 											/** @type {Module} */
 											(module).readableIdentifier(this.requestShortener)
-										}) failed: ${message}`
+										}) failed: ${message}`,
+										{ cause: execErr }
 									);
 									err.stack = stack;
 									err.module = module;

package/lib/Compiler.js

@@ -625,7 +625,8 @@ class Compiler {
 				callback(err, entries, compilation);
 			} catch (runAsChildErr) {
 				const err = new WebpackError(
-					`compiler.runAsChild callback error: ${runAsChildErr}`
+					`compiler.runAsChild callback error: ${runAsChildErr}`,
+					{ cause: runAsChildErr }
 				);
 				err.details = /** @type {Error} */ (runAsChildErr).stack;
 				/** @type {Compilation} */

package/lib/ContextExclusionPlugin.js

@@ -7,6 +7,8 @@
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./ContextModuleFactory")} ContextModuleFactory */
 
+const PLUGIN_NAME = "ContextExclusionPlugin";
+
 class ContextExclusionPlugin {
 	/**
 	 * @param {RegExp} negativeMatcher Matcher regular expression
@@ -21,8 +23,8 @@ class ContextExclusionPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.contextModuleFactory.tap("ContextExclusionPlugin", cmf => {
-			cmf.hooks.contextModuleFiles.tap("ContextExclusionPlugin", files =>
+		compiler.hooks.contextModuleFactory.tap(PLUGIN_NAME, cmf => {
+			cmf.hooks.contextModuleFiles.tap(PLUGIN_NAME, files =>
 				files.filter(filePath => !this.negativeMatcher.test(filePath))
 			);
 		});

package/lib/ContextModule.js

@@ -81,7 +81,7 @@ const makeSerializable = require("./util/makeSerializable");
 
 /**
  * @typedef {object} ContextModuleOptionsExtras
- * @property {false|string|string[]} resource
+ * @property {false | string | string[]} resource
  * @property {string=} resourceQuery
  * @property {string=} resourceFragment
  * @property {ResolveOptions=} resolveOptions

package/lib/ContextModuleFactory.js

@@ -397,8 +397,7 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 															/** @type {string} */
 															(category),
 															referencedExports,
-															/** @type {TODO} */
-															(obj.context),
+															obj.context,
 															attributes
 														);
 														dep.optional = true;

package/lib/ContextReplacementPlugin.js

@@ -14,6 +14,8 @@ const { join } = require("./util/fs");
 
 /** @typedef {Record<string, string>} NewContentCreateContextMap */
 
+const PLUGIN_NAME = "ContextReplacementPlugin";
+
 class ContextReplacementPlugin {
 	/**
 	 * @param {RegExp} resourceRegExp A regular expression that determines which files will be selected
@@ -95,8 +97,8 @@ class ContextReplacementPlugin {
 		const newContentRegExp = this.newContentRegExp;
 		const newContentCreateContextMap = this.newContentCreateContextMap;
 
-		compiler.hooks.contextModuleFactory.tap("ContextReplacementPlugin", cmf => {
-			cmf.hooks.beforeResolve.tap("ContextReplacementPlugin", result => {
+		compiler.hooks.contextModuleFactory.tap(PLUGIN_NAME, cmf => {
+			cmf.hooks.beforeResolve.tap(PLUGIN_NAME, result => {
 				if (!result) return;
 				if (resourceRegExp.test(result.request)) {
 					if (newContentResource !== undefined) {
@@ -118,7 +120,7 @@ class ContextReplacementPlugin {
 				}
 				return result;
 			});
-			cmf.hooks.afterResolve.tap("ContextReplacementPlugin", result => {
+			cmf.hooks.afterResolve.tap(PLUGIN_NAME, result => {
 				if (!result) return;
 				if (resourceRegExp.test(result.resource)) {
 					if (newContentResource !== undefined) {
@@ -188,7 +190,8 @@ const createResolveDependenciesFromContextMap =
 						map[key] + options.resourceQuery + options.resourceFragment,
 						key,
 						options.typePrefix,
-						/** @type {string} */ (options.category),
+						/** @type {string} */
+						(options.category),
 						options.referencedExports
 					)
 			);

package/lib/DefinePlugin.js

@@ -22,6 +22,7 @@ const {
 const createHash = require("./util/createHash");
 
 /** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("../declarations/WebpackOptions").HashFunction} HashFunction */
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Module").BuildInfo} BuildInfo */
 /** @typedef {import("./Module").ValueCacheVersions} ValueCacheVersions */
@@ -31,7 +32,6 @@ const createHash = require("./util/createHash");
 /** @typedef {import("./javascript/JavascriptParser").DestructuringAssignmentProperty} DestructuringAssignmentProperty */
 /** @typedef {import("./javascript/JavascriptParser").Range} Range */
 /** @typedef {import("./logging/Logger").Logger} Logger */
-/** @typedef {import("./util/createHash").Algorithm} Algorithm */
 
 /** @typedef {null | undefined | RegExp | EXPECTED_FUNCTION | string | number | boolean | bigint | undefined} CodeValuePrimitive */
 /** @typedef {RecursiveArrayOrRecord<CodeValuePrimitive | RuntimeValue>} CodeValue */
@@ -367,7 +367,7 @@ class DefinePlugin {
 				const { runtimeTemplate } = compilation;
 
 				const mainHash = createHash(
-					/** @type {Algorithm} */
+					/** @type {HashFunction} */
 					(compilation.outputOptions.hashFunction)
 				);
 				mainHash.update(

package/lib/DelegatedModule.js

@@ -16,6 +16,7 @@ const makeSerializable = require("./util/makeSerializable");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("../declarations/plugins/DllReferencePlugin").DllReferencePluginOptions} DllReferencePluginOptions */
 /** @typedef {import("./ChunkGraph")} ChunkGraph */
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
@@ -23,6 +24,7 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {import("./Generator").SourceTypes} SourceTypes */
 /** @typedef {import("./LibManifestPlugin").ManifestModuleData} ManifestModuleData */
 /** @typedef {import("./Module").BuildCallback} BuildCallback */
+/** @typedef {import("./Module").BuildMeta} BuildMeta */
 /** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
@@ -39,9 +41,16 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {import("./util/Hash")} Hash */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
-/** @typedef {string} SourceRequest */
-/** @typedef {"require" | "object"} Type */
-/** @typedef {TODO} Data */
+/** @typedef {string} DelegatedModuleSourceRequest */
+
+/** @typedef {NonNullable<DllReferencePluginOptions["type"]>} DelegatedModuleType */
+
+/**
+ * @typedef {object} DelegatedModuleData
+ * @property {BuildMeta=} buildMeta build meta
+ * @property {true | string[]=} exports exports
+ * @property {number | string} id module id
+ */
 
 const RUNTIME_REQUIREMENTS = new Set([
 	RuntimeGlobals.module,
@@ -50,9 +59,9 @@ const RUNTIME_REQUIREMENTS = new Set([
 
 class DelegatedModule extends Module {
 	/**
-	 * @param {SourceRequest} sourceRequest source request
-	 * @param {Data} data data
-	 * @param {Type} type type
+	 * @param {DelegatedModuleSourceRequest} sourceRequest source request
+	 * @param {DelegatedModuleData} data data
+	 * @param {DelegatedModuleType} type type
 	 * @param {string} userRequest user request
 	 * @param {string | Module} originalRequest original request
 	 */
@@ -65,7 +74,6 @@ class DelegatedModule extends Module {
 		this.delegationType = type;
 		this.userRequest = userRequest;
 		this.originalRequest = originalRequest;
-		/** @type {ManifestModuleData | undefined} */
 		this.delegateData = data;
 
 		// Build info
@@ -255,7 +263,9 @@ class DelegatedModule extends Module {
 	 */
 	cleanupForCache() {
 		super.cleanupForCache();
-		this.delegateData = undefined;
+		this.delegateData =
+			/** @type {EXPECTED_ANY} */
+			(undefined);
 	}
 }
 

package/lib/DelegatedModuleFactoryPlugin.js

@@ -9,15 +9,14 @@ const DelegatedModule = require("./DelegatedModule");
 
 /** @typedef {import("../declarations/plugins/DllReferencePlugin").DllReferencePluginOptions} DllReferencePluginOptions */
 /** @typedef {import("../declarations/plugins/DllReferencePlugin").DllReferencePluginOptionsContent} DllReferencePluginOptionsContent */
-/** @typedef {import("./DelegatedModule").Data} Data */
-/** @typedef {import("./DelegatedModule").SourceRequest} SourceRequest */
-/** @typedef {import("./DelegatedModule").Type} Type */
+/** @typedef {import("./DelegatedModule").DelegatedModuleSourceRequest} DelegatedModuleSourceRequest */
+/** @typedef {import("./DelegatedModule").DelegatedModuleType} DelegatedModuleType */
 /** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
 /** @typedef {import("./util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */
 
 /**
  * @typedef {object} Options
- * @property {SourceRequest} source source
+ * @property {DelegatedModuleSourceRequest} source source
  * @property {NonNullable<DllReferencePluginOptions["context"]>} context absolute context path to which lib ident is relative to
  * @property {DllReferencePluginOptionsContent} content content
  * @property {DllReferencePluginOptions["type"]} type type
@@ -58,7 +57,8 @@ class DelegatedModuleFactoryPlugin {
 								new DelegatedModule(
 									this.options.source,
 									resolved,
-									/** @type {Type} */ (this.options.type),
+									/** @type {DelegatedModuleType} */
+									(this.options.type),
 									innerRequest,
 									request
 								)
@@ -77,7 +77,8 @@ class DelegatedModuleFactoryPlugin {
 									new DelegatedModule(
 										this.options.source,
 										resolved,
-										/** @type {Type} */ (this.options.type),
+										/** @type {DelegatedModuleType} */
+										(this.options.type),
 										requestPlusExt,
 										request + extension
 									)
@@ -98,7 +99,8 @@ class DelegatedModuleFactoryPlugin {
 						return new DelegatedModule(
 							this.options.source,
 							resolved,
-							/** @type {Type} */ (this.options.type),
+							/** @type {DelegatedModuleType} */
+							(this.options.type),
 							request,
 							module
 						);

package/lib/DelegatedPlugin.js

@@ -11,6 +11,8 @@ const DelegatedSourceDependency = require("./dependencies/DelegatedSourceDepende
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./DelegatedModuleFactoryPlugin").Options} Options */
 
+const PLUGIN_NAME = "DelegatedPlugin";
+
 class DelegatedPlugin {
 	/**
 	 * @param {Options} options options
@@ -26,7 +28,7 @@ class DelegatedPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"DelegatedPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					DelegatedSourceDependency,
@@ -35,7 +37,7 @@ class DelegatedPlugin {
 			}
 		);
 
-		compiler.hooks.compile.tap("DelegatedPlugin", ({ normalModuleFactory }) => {
+		compiler.hooks.compile.tap(PLUGIN_NAME, ({ normalModuleFactory }) => {
 			new DelegatedModuleFactoryPlugin({
 				associatedObjectForCache: compiler.root,
 				...this.options

package/lib/DllEntryPlugin.js

@@ -13,6 +13,8 @@ const EntryDependency = require("./dependencies/EntryDependency");
 /** @typedef {string[]} Entries */
 /** @typedef {{ name: string, filename: TODO }} Options */
 
+const PLUGIN_NAME = "DllEntryPlugin";
+
 class DllEntryPlugin {
 	/**
 	 * @param {string} context context
@@ -32,7 +34,7 @@ class DllEntryPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"DllEntryPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				const dllModuleFactory = new DllModuleFactory();
 				compilation.dependencyFactories.set(
@@ -45,7 +47,7 @@ class DllEntryPlugin {
 				);
 			}
 		);
-		compiler.hooks.make.tapAsync("DllEntryPlugin", (compilation, callback) => {
+		compiler.hooks.make.tapAsync(PLUGIN_NAME, (compilation, callback) => {
 			compilation.addEntry(
 				this.context,
 				new DllEntryDependency(

package/lib/DllPlugin.js

@@ -24,6 +24,8 @@ const validate = createSchemaValidation(
 	}
 );
 
+const PLUGIN_NAME = "DllPlugin";
+
 class DllPlugin {
 	/**
 	 * @param {DllPluginOptions} options options object
@@ -42,7 +44,7 @@ class DllPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.entryOption.tap("DllPlugin", (context, entry) => {
+		compiler.hooks.entryOption.tap(PLUGIN_NAME, (context, entry) => {
 			if (typeof entry !== "function") {
 				for (const name of Object.keys(entry)) {
 					/** @type {Options} */
@@ -55,14 +57,14 @@ class DllPlugin {
 				}
 			} else {
 				throw new Error(
-					"DllPlugin doesn't support dynamic entry (function) yet"
+					`${PLUGIN_NAME} doesn't support dynamic entry (function) yet`
 				);
 			}
 			return true;
 		});
 		new LibManifestPlugin(this.options).apply(compiler);
 		if (!this.options.entryOnly) {
-			new FlagAllModulesAsUsedPlugin("DllPlugin").apply(compiler);
+			new FlagAllModulesAsUsedPlugin(PLUGIN_NAME).apply(compiler);
 		}
 	}
 }