webpack 5.97.1 → 5.104.1

package/lib/DefinePlugin.js

@@ -5,10 +5,11 @@
 
 "use strict";
 
+const { SyncWaterfallHook } = require("tapable");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
-	JAVASCRIPT_MODULE_TYPE_ESM,
-	JAVASCRIPT_MODULE_TYPE_DYNAMIC
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+	JAVASCRIPT_MODULE_TYPE_ESM
 } = require("./ModuleTypeConstants");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const WebpackError = require("./WebpackError");
@@ -24,17 +25,18 @@ const createHash = require("./util/createHash");
 /** @typedef {import("estree").Expression} Expression */
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Module").BuildInfo} BuildInfo */
+/** @typedef {import("./Module").ValueCacheVersion} ValueCacheVersion */
 /** @typedef {import("./Module").ValueCacheVersions} ValueCacheVersions */
 /** @typedef {import("./NormalModule")} NormalModule */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("./javascript/JavascriptParser").DestructuringAssignmentProperty} DestructuringAssignmentProperty */
+/** @typedef {import("./javascript/JavascriptParser").DestructuringAssignmentProperties} DestructuringAssignmentProperties */
 /** @typedef {import("./javascript/JavascriptParser").Range} Range */
 /** @typedef {import("./logging/Logger").Logger} Logger */
-/** @typedef {import("./util/createHash").Algorithm} Algorithm */
+/** @typedef {import("./Compilation")} Compilation */
 
-/** @typedef {null|undefined|RegExp|Function|string|number|boolean|bigint|undefined} CodeValuePrimitive */
-/** @typedef {RecursiveArrayOrRecord<CodeValuePrimitive|RuntimeValue>} CodeValue */
+/** @typedef {null | undefined | RegExp | EXPECTED_FUNCTION | string | number | boolean | bigint | undefined} CodeValuePrimitive */
+/** @typedef {RecursiveArrayOrRecord<CodeValuePrimitive | RuntimeValue>} CodeValue */
 
 /**
  * @typedef {object} RuntimeValueOptions
@@ -42,11 +44,10 @@ const createHash = require("./util/createHash");
  * @property {string[]=} contextDependencies
  * @property {string[]=} missingDependencies
  * @property {string[]=} buildDependencies
- * @property {string|function(): string=} version
+ * @property {string | (() => string)=} version
  */
 
-/** @typedef {string | Set<string>} ValueCacheVersion */
-/** @typedef {function({ module: NormalModule, key: string, readonly version: ValueCacheVersion }): CodeValuePrimitive} GeneratorFn */
+/** @typedef {(value: { module: NormalModule, key: string, readonly version: ValueCacheVersion }) => CodeValuePrimitive} GeneratorFn */
 
 class RuntimeValue {
 	/**
@@ -125,19 +126,19 @@ class RuntimeValue {
 }
 
 /**
- * @param {Set<DestructuringAssignmentProperty> | undefined} properties properties
+ * @param {DestructuringAssignmentProperties | undefined} properties properties
  * @returns {Set<string> | undefined} used keys
  */
 function getObjKeys(properties) {
 	if (!properties) return;
-	return new Set([...properties].map(p => p.id));
+	return new Set([...properties].map((p) => p.id));
 }
 
 /** @typedef {Set<string> | null} ObjKeys */
 /** @typedef {boolean | undefined | null} AsiSafe */
 
 /**
- * @param {any[]|{[k: string]: any}} obj obj
+ * @param {EXPECTED_ANY[] | {[k: string]: EXPECTED_ANY}} obj obj
  * @param {JavascriptParser} parser Parser
  * @param {ValueCacheVersions} valueCacheVersions valueCacheVersions
  * @param {string} key the defined key
@@ -160,30 +161,28 @@ const stringifyObj = (
 	let code;
 	const arr = Array.isArray(obj);
 	if (arr) {
-		code = `[${
-			/** @type {any[]} */ (obj)
-				.map(code =>
-					toCode(
-						code,
-						parser,
-						valueCacheVersions,
-						key,
-						runtimeTemplate,
-						logger,
-						null
-					)
+		code = `[${obj
+			.map((code) =>
+				toCode(
+					code,
+					parser,
+					valueCacheVersions,
+					key,
+					runtimeTemplate,
+					logger,
+					null
 				)
-				.join(",")
-		}]`;
+			)
+			.join(",")}]`;
 	} else {
 		let keys = Object.keys(obj);
 		if (objKeys) {
-			keys = objKeys.size === 0 ? [] : keys.filter(k => objKeys.has(k));
+			keys = objKeys.size === 0 ? [] : keys.filter((k) => objKeys.has(k));
 		}
 		code = `{${keys
-			.map(key => {
-				const code = /** @type {{[k: string]: any}} */ (obj)[key];
-				return `${JSON.stringify(key)}:${toCode(
+			.map((key) => {
+				const code = obj[key];
+				return `${key === "__proto__" ? '["__proto__"]' : JSON.stringify(key)}:${toCode(
 					code,
 					parser,
 					valueCacheVersions,
@@ -288,7 +287,7 @@ const toCode = (
  * @param {CodeValue} code code
  * @returns {string | undefined} result
  */
-const toCacheVersion = code => {
+const toCacheVersion = (code) => {
 	if (code === null) {
 		return "null";
 	}
@@ -308,9 +307,12 @@ const toCacheVersion = code => {
 		return `(${code.toString()})`;
 	}
 	if (typeof code === "object") {
-		const items = Object.keys(code).map(key => ({
+		const items = Object.keys(code).map((key) => ({
 			key,
-			value: toCacheVersion(/** @type {Record<string, any>} */ (code)[key])
+			value: toCacheVersion(
+				/** @type {Record<string, EXPECTED_ANY>} */
+				(code)[key]
+			)
 		}));
 		if (items.some(({ value }) => value === undefined)) return;
 		return `{${items.map(({ key, value }) => `${key}: ${value}`).join(", ")}}`;
@@ -330,7 +332,30 @@ const WEBPACK_REQUIRE_FUNCTION_REGEXP = new RegExp(
 );
 const WEBPACK_REQUIRE_IDENTIFIER_REGEXP = new RegExp(RuntimeGlobals.require);
 
+/**
+ * @typedef {object} DefinePluginHooks
+ * @property {SyncWaterfallHook<[Record<string, CodeValue>]>} definitions
+ */
+
+/** @type {WeakMap<Compilation, DefinePluginHooks>} */
+const compilationHooksMap = new WeakMap();
+
 class DefinePlugin {
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @returns {DefinePluginHooks} the attached hooks
+	 */
+	static getCompilationHooks(compilation) {
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				definitions: new SyncWaterfallHook(["definitions"])
+			};
+			compilationHooksMap.set(compilation, hooks);
+		}
+		return hooks;
+	}
+
 	/**
 	 * Create a new define plugin
 	 * @param {Record<string, CodeValue>} definitions A map of global object definitions
@@ -354,10 +379,26 @@ class DefinePlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		const definitions = this.definitions;
 		compiler.hooks.compilation.tap(
 			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
+				const definitions = this.definitions;
+				const hooks = DefinePlugin.getCompilationHooks(compilation);
+
+				hooks.definitions.tap(PLUGIN_NAME, (previousDefinitions) => ({
+					...previousDefinitions,
+					...definitions
+				}));
+
+				/**
+				 * @type {Map<string, Set<string>>}
+				 */
+				const finalByNestedKey = new Map();
+				/**
+				 * @type {Map<string, Set<string>>}
+				 */
+				const nestedByFinalKey = new Map();
+
 				const logger = compilation.getLogger("webpack.DefinePlugin");
 				compilation.dependencyTemplates.set(
 					ConstDependency,
@@ -365,10 +406,7 @@ class DefinePlugin {
 				);
 				const { runtimeTemplate } = compilation;
 
-				const mainHash = createHash(
-					/** @type {Algorithm} */
-					(compilation.outputOptions.hashFunction)
-				);
+				const mainHash = createHash(compilation.outputOptions.hashFunction);
 				mainHash.update(
 					/** @type {string} */
 					(compilation.valueCacheVersions.get(VALUE_DEP_MAIN)) || ""
@@ -379,7 +417,8 @@ class DefinePlugin {
 				 * @param {JavascriptParser} parser Parser
 				 * @returns {void}
 				 */
-				const handler = parser => {
+				const handler = (parser) => {
+					const hooked = new Set();
 					const mainValue =
 						/** @type {ValueCacheVersion} */
 						(compilation.valueCacheVersions.get(VALUE_DEP_MAIN));
@@ -387,15 +426,16 @@ class DefinePlugin {
 						const buildInfo = /** @type {BuildInfo} */ (
 							parser.state.module.buildInfo
 						);
-						if (!buildInfo.valueDependencies)
+						if (!buildInfo.valueDependencies) {
 							buildInfo.valueDependencies = new Map();
+						}
 						buildInfo.valueDependencies.set(VALUE_DEP_MAIN, mainValue);
 					});
 
 					/**
 					 * @param {string} key key
 					 */
-					const addValueDependency = key => {
+					const addValueDependency = (key) => {
 						const buildInfo =
 							/** @type {BuildInfo} */
 							(parser.state.module.buildInfo);
@@ -408,10 +448,10 @@ class DefinePlugin {
 					};
 
 					/**
-					 * @template {Function} T
+					 * @template T
 					 * @param {string} key key
-					 * @param {T} fn fn
-					 * @returns {function(TODO): TODO} result
+					 * @param {(expression: Expression) => T} fn fn
+					 * @returns {(expression: Expression) => T} result
 					 */
 					const withValueDependency =
 						(key, fn) =>
@@ -468,6 +508,68 @@ class DefinePlugin {
 								return true;
 							});
 						}
+						if (prefix === "") {
+							const final = splittedKey[splittedKey.length - 1];
+							const nestedSet = nestedByFinalKey.get(final);
+							if (!nestedSet || nestedSet.size <= 0) return;
+							for (const nested of /** @type {Set<string>} */ (nestedSet)) {
+								if (nested && !hooked.has(nested)) {
+									// only detect the same nested key once
+									hooked.add(nested);
+									parser.hooks.collectDestructuringAssignmentProperties.tap(
+										PLUGIN_NAME,
+										(expr) => {
+											const nameInfo = parser.getNameForExpression(expr);
+											if (nameInfo && nameInfo.name === nested) return true;
+										}
+									);
+									parser.hooks.expression.for(nested).tap(
+										{
+											name: PLUGIN_NAME,
+											// why 100? Ensures it runs after object define
+											stage: 100
+										},
+										(expr) => {
+											const destructed =
+												parser.destructuringAssignmentPropertiesFor(expr);
+											if (destructed === undefined) {
+												return;
+											}
+											/** @type {Record<string, CodeValue>} */
+											const obj = Object.create(null);
+											const finalSet = finalByNestedKey.get(nested);
+											for (const { id } of destructed) {
+												const fullKey = `${nested}.${id}`;
+												if (
+													!finalSet ||
+													!finalSet.has(id) ||
+													!definitions[fullKey]
+												) {
+													return;
+												}
+												obj[id] = definitions[fullKey];
+											}
+											let strCode = stringifyObj(
+												obj,
+												parser,
+												compilation.valueCacheVersions,
+												key,
+												runtimeTemplate,
+												logger,
+												!parser.isAsiPosition(
+													/** @type {Range} */ (expr.range)[0]
+												),
+												getObjKeys(destructed)
+											);
+											if (parser.scope.inShorthand) {
+												strCode = `${parser.scope.inShorthand}:${strCode}`;
+											}
+											return toConstantDependency(parser, strCode)(expr);
+										}
+									);
+								}
+							}
+						}
 					};
 
 					/**
@@ -489,7 +591,7 @@ class DefinePlugin {
 							});
 							parser.hooks.evaluateIdentifier
 								.for(key)
-								.tap(PLUGIN_NAME, expr => {
+								.tap(PLUGIN_NAME, (expr) => {
 									/**
 									 * this is needed in case there is a recursion in the DefinePlugin
 									 * to prevent an endless recursion
@@ -516,7 +618,7 @@ class DefinePlugin {
 									res.setRange(/** @type {Range} */ (expr.range));
 									return res;
 								});
-							parser.hooks.expression.for(key).tap(PLUGIN_NAME, expr => {
+							parser.hooks.expression.for(key).tap(PLUGIN_NAME, (expr) => {
 								addValueDependency(originalKey);
 								let strCode = toCode(
 									code,
@@ -545,7 +647,7 @@ class DefinePlugin {
 								return toConstantDependency(parser, strCode)(expr);
 							});
 						}
-						parser.hooks.evaluateTypeof.for(key).tap(PLUGIN_NAME, expr => {
+						parser.hooks.evaluateTypeof.for(key).tap(PLUGIN_NAME, (expr) => {
 							/**
 							 * this is needed in case there is a recursion in the DefinePlugin
 							 * to prevent an endless recursion
@@ -572,7 +674,7 @@ class DefinePlugin {
 							res.setRange(/** @type {Range} */ (expr.range));
 							return res;
 						});
-						parser.hooks.typeof.for(key).tap(PLUGIN_NAME, expr => {
+						parser.hooks.typeof.for(key).tap(PLUGIN_NAME, (expr) => {
 							addValueDependency(originalKey);
 							const codeCode = toCode(
 								code,
@@ -604,20 +706,29 @@ class DefinePlugin {
 							addValueDependency(key);
 							return true;
 						});
-						parser.hooks.evaluateIdentifier.for(key).tap(PLUGIN_NAME, expr => {
-							addValueDependency(key);
-							return new BasicEvaluatedExpression()
-								.setTruthy()
-								.setSideEffects(false)
-								.setRange(/** @type {Range} */ (expr.range));
-						});
+						parser.hooks.evaluateIdentifier
+							.for(key)
+							.tap(PLUGIN_NAME, (expr) => {
+								addValueDependency(key);
+								return new BasicEvaluatedExpression()
+									.setTruthy()
+									.setSideEffects(false)
+									.setRange(/** @type {Range} */ (expr.range));
+							});
 						parser.hooks.evaluateTypeof
 							.for(key)
 							.tap(
 								PLUGIN_NAME,
 								withValueDependency(key, evaluateToString("object"))
 							);
-						parser.hooks.expression.for(key).tap(PLUGIN_NAME, expr => {
+						parser.hooks.collectDestructuringAssignmentProperties.tap(
+							PLUGIN_NAME,
+							(expr) => {
+								const nameInfo = parser.getNameForExpression(expr);
+								if (nameInfo && nameInfo.name === key) return true;
+							}
+						);
+						parser.hooks.expression.for(key).tap(PLUGIN_NAME, (expr) => {
 							addValueDependency(key);
 							let strCode = stringifyObj(
 								obj,
@@ -706,14 +817,55 @@ class DefinePlugin {
 					}
 				};
 
+				/**
+				 * @param {Record<string, CodeValue>} definitions Definitions map
+				 * @returns {void}
+				 */
+				const walkDefinitionsForKeys = (definitions) => {
+					/**
+					 * @param {Map<string, Set<string>>} map Map
+					 * @param {string} key key
+					 * @param {string} value v
+					 * @returns {void}
+					 */
+					const addToMap = (map, key, value) => {
+						if (map.has(key)) {
+							/** @type {Set<string>} */
+							(map.get(key)).add(value);
+						} else {
+							map.set(key, new Set([value]));
+						}
+					};
+					for (const key of Object.keys(definitions)) {
+						const code = definitions[key];
+						if (
+							!code ||
+							typeof code === "object" ||
+							TYPEOF_OPERATOR_REGEXP.test(key)
+						) {
+							continue;
+						}
+						const idx = key.lastIndexOf(".");
+						if (idx <= 0 || idx >= key.length - 1) {
+							continue;
+						}
+						const nested = key.slice(0, idx);
+						const final = key.slice(idx + 1);
+						addToMap(finalByNestedKey, nested, final);
+						addToMap(nestedByFinalKey, final, nested);
+					}
+				};
+
+				walkDefinitionsForKeys(definitions);
 				walkDefinitionsForValues(definitions, "");
 
 				compilation.valueCacheVersions.set(
 					VALUE_DEP_MAIN,
-					/** @type {string} */ (mainHash.digest("hex").slice(0, 8))
+					mainHash.digest("hex").slice(0, 8)
 				);
 			}
 		);
 	}
 }
+
 module.exports = DefinePlugin;

package/lib/DelegatedModule.js

@@ -7,39 +7,49 @@
 
 const { OriginalSource, RawSource } = require("webpack-sources");
 const Module = require("./Module");
-const { JS_TYPES } = require("./ModuleSourceTypesConstants");
+const {
+	JAVASCRIPT_TYPE,
+	JAVASCRIPT_TYPES
+} = require("./ModuleSourceTypeConstants");
 const { JAVASCRIPT_MODULE_TYPE_DYNAMIC } = require("./ModuleTypeConstants");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const DelegatedSourceDependency = require("./dependencies/DelegatedSourceDependency");
 const StaticExportsDependency = require("./dependencies/StaticExportsDependency");
 const makeSerializable = require("./util/makeSerializable");
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("../declarations/plugins/DllReferencePlugin").DllReferencePluginOptions} DllReferencePluginOptions */
+/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("./Generator").SourceTypes} SourceTypes */
 /** @typedef {import("./LibManifestPlugin").ManifestModuleData} ManifestModuleData */
+/** @typedef {import("./Module").ModuleId} ModuleId */
+/** @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 */
+/** @typedef {import("./Module").LibIdent} LibIdent */
+/** @typedef {import("./Module").NeedBuildCallback} NeedBuildCallback */
 /** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("./Module").SourceContext} SourceContext */
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./WebpackError")} WebpackError */
-/** @typedef {import("./dependencies/ModuleDependency")} ModuleDependency */
 /** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("./dependencies/StaticExportsDependency").Exports} Exports */
 /** @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 {Exports=} exports exports
+ * @property {ModuleId} id module id
+ */
 
 const RUNTIME_REQUIREMENTS = new Set([
 	RuntimeGlobals.module,
@@ -48,9 +58,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
 	 */
@@ -63,7 +73,6 @@ class DelegatedModule extends Module {
 		this.delegationType = type;
 		this.userRequest = userRequest;
 		this.originalRequest = originalRequest;
-		/** @type {ManifestModuleData | undefined} */
 		this.delegateData = data;
 
 		// Build info
@@ -74,12 +83,12 @@ class DelegatedModule extends Module {
 	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
-		return JS_TYPES;
+		return JAVASCRIPT_TYPES;
 	}
 
 	/**
 	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
+	 * @returns {LibIdent | null} an identifier for library inclusion
 	 */
 	libIdent(options) {
 		return typeof this.originalRequest === "string"
@@ -106,7 +115,7 @@ class DelegatedModule extends Module {
 
 	/**
 	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @param {NeedBuildCallback} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
 	 */
 	needBuild(context, callback) {
@@ -118,7 +127,7 @@ class DelegatedModule extends Module {
 	 * @param {Compilation} compilation the compilation
 	 * @param {ResolverWithOptions} resolver the resolver
 	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
+	 * @param {BuildCallback} callback callback function
 	 * @returns {void}
 	 */
 	build(options, compilation, resolver, fs, callback) {
@@ -171,9 +180,9 @@ class DelegatedModule extends Module {
 
 		const sources = new Map();
 		if (this.useSourceMap || this.useSimpleSourceMap) {
-			sources.set("javascript", new OriginalSource(str, this.identifier()));
+			sources.set(JAVASCRIPT_TYPE, new OriginalSource(str, this.identifier()));
 		} else {
-			sources.set("javascript", new RawSource(str));
+			sources.set(JAVASCRIPT_TYPE, new RawSource(str));
 		}
 
 		return {
@@ -253,7 +262,9 @@ class DelegatedModule extends Module {
 	 */
 	cleanupForCache() {
 		super.cleanupForCache();
-		this.delegateData = undefined;
+		this.delegateData =
+			/** @type {EXPECTED_ANY} */
+			(undefined);
 	}
 }
 

package/lib/DelegatedModuleFactoryPlugin.js

@@ -9,22 +9,24 @@ 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
  * @property {DllReferencePluginOptions["extensions"]} extensions extensions
  * @property {DllReferencePluginOptions["scope"]} scope scope
- * @property {object=} associatedObjectForCache object for caching
+ * @property {AssociatedObjectForCache=} associatedObjectForCache object for caching
  */
 
+const PLUGIN_NAME = "DelegatedModuleFactoryPlugin";
+
 class DelegatedModuleFactoryPlugin {
 	/**
 	 * @param {Options} options options
@@ -43,7 +45,7 @@ class DelegatedModuleFactoryPlugin {
 		const scope = this.options.scope;
 		if (scope) {
 			normalModuleFactory.hooks.factorize.tapAsync(
-				"DelegatedModuleFactoryPlugin",
+				PLUGIN_NAME,
 				(data, callback) => {
 					const [dependency] = data.dependencies;
 					const { request } = dependency;
@@ -57,7 +59,8 @@ class DelegatedModuleFactoryPlugin {
 								new DelegatedModule(
 									this.options.source,
 									resolved,
-									/** @type {Type} */ (this.options.type),
+									/** @type {DelegatedModuleType} */
+									(this.options.type),
 									innerRequest,
 									request
 								)
@@ -76,7 +79,8 @@ class DelegatedModuleFactoryPlugin {
 									new DelegatedModule(
 										this.options.source,
 										resolved,
-										/** @type {Type} */ (this.options.type),
+										/** @type {DelegatedModuleType} */
+										(this.options.type),
 										requestPlusExt,
 										request + extension
 									)
@@ -88,24 +92,23 @@ class DelegatedModuleFactoryPlugin {
 				}
 			);
 		} else {
-			normalModuleFactory.hooks.module.tap(
-				"DelegatedModuleFactoryPlugin",
-				module => {
-					const request = module.libIdent(this.options);
-					if (request && request in this.options.content) {
-						const resolved = this.options.content[request];
-						return new DelegatedModule(
-							this.options.source,
-							resolved,
-							/** @type {Type} */ (this.options.type),
-							request,
-							module
-						);
-					}
-					return module;
+			normalModuleFactory.hooks.module.tap(PLUGIN_NAME, (module) => {
+				const request = module.libIdent(this.options);
+				if (request && request in this.options.content) {
+					const resolved = this.options.content[request];
+					return new DelegatedModule(
+						this.options.source,
+						resolved,
+						/** @type {DelegatedModuleType} */
+						(this.options.type),
+						request,
+						module
+					);
 				}
-			);
+				return module;
+			});
 		}
 	}
 }
+
 module.exports = DelegatedModuleFactoryPlugin;