webpack 5.59.0 → 5.94.0

package/lib/DefinePlugin.js

@@ -5,10 +5,16 @@
 
 "use strict";
 
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_ESM,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC
+} = require("./ModuleTypeConstants");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const WebpackError = require("./WebpackError");
 const ConstDependency = require("./dependencies/ConstDependency");
 const BasicEvaluatedExpression = require("./javascript/BasicEvaluatedExpression");
+
 const {
 	evaluateToString,
 	toConstantDependency
@@ -16,16 +22,22 @@ const {
 const createHash = require("./util/createHash");
 
 /** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("./Compilation").ValueCacheVersion} ValueCacheVersion */
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Module").BuildInfo} BuildInfo */
 /** @typedef {import("./NormalModule")} NormalModule */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
+/** @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|Function|string|number|boolean|bigint|undefined} CodeValuePrimitive */
 /** @typedef {RecursiveArrayOrRecord<CodeValuePrimitive|RuntimeValue>} CodeValue */
 
 /**
- * @typedef {Object} RuntimeValueOptions
+ * @typedef {object} RuntimeValueOptions
  * @property {string[]=} fileDependencies
  * @property {string[]=} contextDependencies
  * @property {string[]=} missingDependencies
@@ -33,9 +45,11 @@ const createHash = require("./util/createHash");
  * @property {string|function(): string=} version
  */
 
+/** @typedef {function({ module: NormalModule, key: string, readonly version: ValueCacheVersion }): CodeValuePrimitive} GeneratorFn */
+
 class RuntimeValue {
 	/**
-	 * @param {function({ module: NormalModule, key: string, readonly version: string | undefined }): CodeValuePrimitive} fn generator function
+	 * @param {GeneratorFn} fn generator function
 	 * @param {true | string[] | RuntimeValueOptions=} options options
 	 */
 	constructor(fn, options) {
@@ -54,33 +68,37 @@ class RuntimeValue {
 
 	/**
 	 * @param {JavascriptParser} parser the parser
-	 * @param {Map<string, string | Set<string>>} valueCacheVersions valueCacheVersions
+	 * @param {Map<string, ValueCacheVersion>} valueCacheVersions valueCacheVersions
 	 * @param {string} key the defined key
 	 * @returns {CodeValuePrimitive} code
 	 */
 	exec(parser, valueCacheVersions, key) {
-		const buildInfo = parser.state.module.buildInfo;
+		const buildInfo = /** @type {BuildInfo} */ (parser.state.module.buildInfo);
 		if (this.options === true) {
 			buildInfo.cacheable = false;
 		} else {
 			if (this.options.fileDependencies) {
 				for (const dep of this.options.fileDependencies) {
-					buildInfo.fileDependencies.add(dep);
+					/** @type {NonNullable<BuildInfo["fileDependencies"]>} */
+					(buildInfo.fileDependencies).add(dep);
 				}
 			}
 			if (this.options.contextDependencies) {
 				for (const dep of this.options.contextDependencies) {
-					buildInfo.contextDependencies.add(dep);
+					/** @type {NonNullable<BuildInfo["contextDependencies"]>} */
+					(buildInfo.contextDependencies).add(dep);
 				}
 			}
 			if (this.options.missingDependencies) {
 				for (const dep of this.options.missingDependencies) {
-					buildInfo.missingDependencies.add(dep);
+					/** @type {NonNullable<BuildInfo["missingDependencies"]>} */
+					(buildInfo.missingDependencies).add(dep);
 				}
 			}
 			if (this.options.buildDependencies) {
 				for (const dep of this.options.buildDependencies) {
-					buildInfo.buildDependencies.add(dep);
+					/** @type {NonNullable<BuildInfo["buildDependencies"]>} */
+					(buildInfo.buildDependencies).add(dep);
 				}
 			}
 		}
@@ -89,9 +107,7 @@ class RuntimeValue {
 			module: parser.state.module,
 			key,
 			get version() {
-				return /** @type {string} */ (
-					valueCacheVersions.get(VALUE_DEP_PREFIX + key)
-				);
+				return valueCacheVersions.get(VALUE_DEP_PREFIX + key);
 			}
 		});
 	}
@@ -105,13 +121,27 @@ class RuntimeValue {
 	}
 }
 
+/**
+ * @param {Set<DestructuringAssignmentProperty> | undefined} properties properties
+ * @returns {Set<string> | undefined} used keys
+ */
+function getObjKeys(properties) {
+	if (!properties) return;
+	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 {JavascriptParser} parser Parser
- * @param {Map<string, string | Set<string>>} valueCacheVersions valueCacheVersions
+ * @param {Map<string, ValueCacheVersion>} valueCacheVersions valueCacheVersions
  * @param {string} key the defined key
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
- * @param {boolean|undefined|null=} asiSafe asi safe (undefined: unknown, null: unneeded)
+ * @param {Logger} logger the logger object
+ * @param {AsiSafe=} asiSafe asi safe (undefined: unknown, null: unneeded)
+ * @param {ObjKeys=} objKeys used keys
  * @returns {string} code converted to string that evaluates
  */
 const stringifyObj = (
@@ -120,25 +150,45 @@ const stringifyObj = (
 	valueCacheVersions,
 	key,
 	runtimeTemplate,
-	asiSafe
+	logger,
+	asiSafe,
+	objKeys
 ) => {
 	let code;
-	let arr = Array.isArray(obj);
+	const arr = Array.isArray(obj);
 	if (arr) {
-		code = `[${obj
-			.map(code =>
-				toCode(code, parser, valueCacheVersions, key, runtimeTemplate, null)
-			)
-			.join(",")}]`;
+		code = `[${
+			/** @type {any[]} */ (obj)
+				.map(code =>
+					toCode(
+						code,
+						parser,
+						valueCacheVersions,
+						key,
+						runtimeTemplate,
+						logger,
+						null
+					)
+				)
+				.join(",")
+		}]`;
 	} else {
-		code = `{${Object.keys(obj)
+		let keys = Object.keys(obj);
+		if (objKeys) {
+			keys = objKeys.size === 0 ? [] : keys.filter(k => objKeys.has(k));
+		}
+		code = `{${keys
 			.map(key => {
-				const code = obj[key];
-				return (
-					JSON.stringify(key) +
-					":" +
-					toCode(code, parser, valueCacheVersions, key, runtimeTemplate, null)
-				);
+				const code = /** @type {{[k: string]: any}} */ (obj)[key];
+				return `${JSON.stringify(key)}:${toCode(
+					code,
+					parser,
+					valueCacheVersions,
+					key,
+					runtimeTemplate,
+					logger,
+					null
+				)}`;
 			})
 			.join(",")}}`;
 	}
@@ -159,10 +209,12 @@ const stringifyObj = (
  * Convert code to a string that evaluates
  * @param {CodeValue} code Code to evaluate
  * @param {JavascriptParser} parser Parser
- * @param {Map<string, string | Set<string>>} valueCacheVersions valueCacheVersions
+ * @param {Map<string, ValueCacheVersion>} valueCacheVersions valueCacheVersions
  * @param {string} key the defined key
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
- * @param {boolean|undefined|null=} asiSafe asi safe (undefined: unknown, null: unneeded)
+ * @param {Logger} logger the logger object
+ * @param {boolean | undefined | null=} asiSafe asi safe (undefined: unknown, null: unneeded)
+ * @param {ObjKeys=} objKeys used keys
  * @returns {string} code converted to string that evaluates
  */
 const toCode = (
@@ -171,51 +223,68 @@ const toCode = (
 	valueCacheVersions,
 	key,
 	runtimeTemplate,
-	asiSafe
+	logger,
+	asiSafe,
+	objKeys
 ) => {
-	if (code === null) {
-		return "null";
-	}
-	if (code === undefined) {
-		return "undefined";
-	}
-	if (Object.is(code, -0)) {
-		return "-0";
-	}
-	if (code instanceof RuntimeValue) {
-		return toCode(
-			code.exec(parser, valueCacheVersions, key),
-			parser,
-			valueCacheVersions,
-			key,
-			runtimeTemplate,
-			asiSafe
-		);
-	}
-	if (code instanceof RegExp && code.toString) {
-		return code.toString();
-	}
-	if (typeof code === "function" && code.toString) {
-		return "(" + code.toString() + ")";
-	}
-	if (typeof code === "object") {
-		return stringifyObj(
-			code,
-			parser,
-			valueCacheVersions,
-			key,
-			runtimeTemplate,
-			asiSafe
-		);
-	}
-	if (typeof code === "bigint") {
-		return runtimeTemplate.supportsBigIntLiteral()
-			? `${code}n`
-			: `BigInt("${code}")`;
-	}
-	return code + "";
+	const transformToCode = () => {
+		if (code === null) {
+			return "null";
+		}
+		if (code === undefined) {
+			return "undefined";
+		}
+		if (Object.is(code, -0)) {
+			return "-0";
+		}
+		if (code instanceof RuntimeValue) {
+			return toCode(
+				code.exec(parser, valueCacheVersions, key),
+				parser,
+				valueCacheVersions,
+				key,
+				runtimeTemplate,
+				logger,
+				asiSafe
+			);
+		}
+		if (code instanceof RegExp && code.toString) {
+			return code.toString();
+		}
+		if (typeof code === "function" && code.toString) {
+			return `(${code.toString()})`;
+		}
+		if (typeof code === "object") {
+			return stringifyObj(
+				code,
+				parser,
+				valueCacheVersions,
+				key,
+				runtimeTemplate,
+				logger,
+				asiSafe,
+				objKeys
+			);
+		}
+		if (typeof code === "bigint") {
+			return runtimeTemplate.supportsBigIntLiteral()
+				? `${code}n`
+				: `BigInt("${code}")`;
+		}
+		return `${code}`;
+	};
+
+	const strCode = transformToCode();
+
+	logger.debug(`Replaced "${key}" with "${strCode}"`);
+
+	return strCode;
 };
 
+/**
+ * @param {CodeValue} code code
+ * @returns {string | undefined} result
+ */
 const toCacheVersion = code => {
 	if (code === null) {
 		return "null";
@@ -233,24 +302,30 @@ const toCacheVersion = code => {
 		return code.toString();
 	}
 	if (typeof code === "function" && code.toString) {
-		return "(" + code.toString() + ")";
+		return `(${code.toString()})`;
 	}
 	if (typeof code === "object") {
 		const items = Object.keys(code).map(key => ({
 			key,
-			value: toCacheVersion(code[key])
+			value: toCacheVersion(/** @type {Record<string, any>} */ (code)[key])
 		}));
-		if (items.some(({ value }) => value === undefined)) return undefined;
+		if (items.some(({ value }) => value === undefined)) return;
 		return `{${items.map(({ key, value }) => `${key}: ${value}`).join(", ")}}`;
 	}
 	if (typeof code === "bigint") {
 		return `${code}n`;
 	}
-	return code + "";
+	return `${code}`;
 };
 
-const VALUE_DEP_PREFIX = "webpack/DefinePlugin ";
-const VALUE_DEP_MAIN = "webpack/DefinePlugin_hash";
+const PLUGIN_NAME = "DefinePlugin";
+const VALUE_DEP_PREFIX = `webpack/${PLUGIN_NAME} `;
+const VALUE_DEP_MAIN = `webpack/${PLUGIN_NAME}_hash`;
+const TYPEOF_OPERATOR_REGEXP = /^typeof\s+/;
+const WEBPACK_REQUIRE_FUNCTION_REGEXP = new RegExp(
+	`${RuntimeGlobals.require}\\s*(!?\\.)`
+);
+const WEBPACK_REQUIRE_IDENTIFIER_REGEXP = new RegExp(RuntimeGlobals.require);
 
 class DefinePlugin {
 	/**
@@ -262,7 +337,7 @@ class DefinePlugin {
 	}
 
 	/**
-	 * @param {function({ module: NormalModule, key: string, readonly version: string | undefined }): CodeValuePrimitive} fn generator function
+	 * @param {GeneratorFn} fn generator function
 	 * @param {true | string[] | RuntimeValueOptions=} options options
 	 * @returns {RuntimeValue} runtime value
 	 */
@@ -278,19 +353,22 @@ class DefinePlugin {
 	apply(compiler) {
 		const definitions = this.definitions;
 		compiler.hooks.compilation.tap(
-			"DefinePlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
+				const logger = compilation.getLogger("webpack.DefinePlugin");
 				compilation.dependencyTemplates.set(
 					ConstDependency,
 					new ConstDependency.Template()
 				);
 				const { runtimeTemplate } = compilation;
 
-				const mainHash = createHash(compilation.outputOptions.hashFunction);
+				const mainHash = createHash(
+					/** @type {Algorithm} */
+					(compilation.outputOptions.hashFunction)
+				);
 				mainHash.update(
-					/** @type {string} */ (
-						compilation.valueCacheVersions.get(VALUE_DEP_MAIN)
-					) || ""
+					/** @type {string} */
+					(compilation.valueCacheVersions.get(VALUE_DEP_MAIN)) || ""
 				);
 
 				/**
@@ -300,21 +378,35 @@ class DefinePlugin {
 				 */
 				const handler = parser => {
 					const mainValue = compilation.valueCacheVersions.get(VALUE_DEP_MAIN);
-					parser.hooks.program.tap("DefinePlugin", () => {
-						const { buildInfo } = parser.state.module;
+					parser.hooks.program.tap(PLUGIN_NAME, () => {
+						const buildInfo = /** @type {BuildInfo} */ (
+							parser.state.module.buildInfo
+						);
 						if (!buildInfo.valueDependencies)
 							buildInfo.valueDependencies = new Map();
 						buildInfo.valueDependencies.set(VALUE_DEP_MAIN, mainValue);
 					});
 
+					/**
+					 * @param {string} key key
+					 */
 					const addValueDependency = key => {
-						const { buildInfo } = parser.state.module;
-						buildInfo.valueDependencies.set(
+						const buildInfo =
+							/** @type {BuildInfo} */
+							(parser.state.module.buildInfo);
+						/** @type {NonNullable<BuildInfo["valueDependencies"]>} */
+						(buildInfo.valueDependencies).set(
 							VALUE_DEP_PREFIX + key,
 							compilation.valueCacheVersions.get(VALUE_DEP_PREFIX + key)
 						);
 					};
 
+					/**
+					 * @template {Function} T
+					 * @param {string} key key
+					 * @param {T} fn fn
+					 * @returns {function(TODO): TODO} result
+					 */
 					const withValueDependency =
 						(key, fn) =>
 						(...args) => {
@@ -324,12 +416,12 @@ class DefinePlugin {
 
 					/**
 					 * Walk definitions
-					 * @param {Object} definitions Definitions map
+					 * @param {Record<string, CodeValue>} definitions Definitions map
 					 * @param {string} prefix Prefix string
 					 * @returns {void}
 					 */
 					const walkDefinitions = (definitions, prefix) => {
-						Object.keys(definitions).forEach(key => {
+						for (const key of Object.keys(definitions)) {
 							const code = definitions[key];
 							if (
 								code &&
@@ -337,13 +429,16 @@ class DefinePlugin {
 								!(code instanceof RuntimeValue) &&
 								!(code instanceof RegExp)
 							) {
-								walkDefinitions(code, prefix + key + ".");
+								walkDefinitions(
+									/** @type {Record<string, CodeValue>} */ (code),
+									`${prefix + key}.`
+								);
 								applyObjectDefine(prefix + key, code);
-								return;
+								continue;
 							}
 							applyDefineKey(prefix, key);
 							applyDefine(prefix + key, code);
-						});
+						}
 					};
 
 					/**
@@ -354,13 +449,13 @@ class DefinePlugin {
 					 */
 					const applyDefineKey = (prefix, key) => {
 						const splittedKey = key.split(".");
-						splittedKey.slice(1).forEach((_, i) => {
+						for (const [i, _] of splittedKey.slice(1).entries()) {
 							const fullKey = prefix + splittedKey.slice(0, i + 1).join(".");
-							parser.hooks.canRename.for(fullKey).tap("DefinePlugin", () => {
+							parser.hooks.canRename.for(fullKey).tap(PLUGIN_NAME, () => {
 								addValueDependency(key);
 								return true;
 							});
-						});
+						}
 					};
 
 					/**
@@ -371,18 +466,18 @@ class DefinePlugin {
 					 */
 					const applyDefine = (key, code) => {
 						const originalKey = key;
-						const isTypeof = /^typeof\s+/.test(key);
-						if (isTypeof) key = key.replace(/^typeof\s+/, "");
+						const isTypeof = TYPEOF_OPERATOR_REGEXP.test(key);
+						if (isTypeof) key = key.replace(TYPEOF_OPERATOR_REGEXP, "");
 						let recurse = false;
 						let recurseTypeof = false;
 						if (!isTypeof) {
-							parser.hooks.canRename.for(key).tap("DefinePlugin", () => {
+							parser.hooks.canRename.for(key).tap(PLUGIN_NAME, () => {
 								addValueDependency(originalKey);
 								return true;
 							});
 							parser.hooks.evaluateIdentifier
 								.for(key)
-								.tap("DefinePlugin", expr => {
+								.tap(PLUGIN_NAME, expr => {
 									/**
 									 * this is needed in case there is a recursion in the DefinePlugin
 									 * to prevent an endless recursion
@@ -401,37 +496,44 @@ class DefinePlugin {
 											compilation.valueCacheVersions,
 											key,
 											runtimeTemplate,
+											logger,
 											null
 										)
 									);
 									recurse = false;
-									res.setRange(expr.range);
+									res.setRange(/** @type {Range} */ (expr.range));
 									return res;
 								});
-							parser.hooks.expression.for(key).tap("DefinePlugin", expr => {
+							parser.hooks.expression.for(key).tap(PLUGIN_NAME, expr => {
 								addValueDependency(originalKey);
-								const strCode = toCode(
+								let strCode = toCode(
 									code,
 									parser,
 									compilation.valueCacheVersions,
 									originalKey,
 									runtimeTemplate,
-									!parser.isAsiPosition(expr.range[0])
+									logger,
+									!parser.isAsiPosition(/** @type {Range} */ (expr.range)[0]),
+									null
 								);
-								if (/__webpack_require__\s*(!?\.)/.test(strCode)) {
+
+								if (parser.scope.inShorthand) {
+									strCode = `${parser.scope.inShorthand}:${strCode}`;
+								}
+
+								if (WEBPACK_REQUIRE_FUNCTION_REGEXP.test(strCode)) {
 									return toConstantDependency(parser, strCode, [
 										RuntimeGlobals.require
 									])(expr);
-								} else if (/__webpack_require__/.test(strCode)) {
+								} else if (WEBPACK_REQUIRE_IDENTIFIER_REGEXP.test(strCode)) {
 									return toConstantDependency(parser, strCode, [
 										RuntimeGlobals.requireScope
 									])(expr);
-								} else {
-									return toConstantDependency(parser, strCode)(expr);
 								}
+								return toConstantDependency(parser, strCode)(expr);
 							});
 						}
-						parser.hooks.evaluateTypeof.for(key).tap("DefinePlugin", 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
@@ -449,17 +551,16 @@ class DefinePlugin {
 								compilation.valueCacheVersions,
 								originalKey,
 								runtimeTemplate,
+								logger,
 								null
 							);
-							const typeofCode = isTypeof
-								? codeCode
-								: "typeof (" + codeCode + ")";
+							const typeofCode = isTypeof ? codeCode : `typeof (${codeCode})`;
 							const res = parser.evaluate(typeofCode);
 							recurseTypeof = false;
-							res.setRange(expr.range);
+							res.setRange(/** @type {Range} */ (expr.range));
 							return res;
 						});
-						parser.hooks.typeof.for(key).tap("DefinePlugin", expr => {
+						parser.hooks.typeof.for(key).tap(PLUGIN_NAME, expr => {
 							addValueDependency(originalKey);
 							const codeCode = toCode(
 								code,
@@ -467,11 +568,10 @@ class DefinePlugin {
 								compilation.valueCacheVersions,
 								originalKey,
 								runtimeTemplate,
+								logger,
 								null
 							);
-							const typeofCode = isTypeof
-								? codeCode
-								: "typeof (" + codeCode + ")";
+							const typeofCode = isTypeof ? codeCode : `typeof (${codeCode})`;
 							const res = parser.evaluate(typeofCode);
 							if (!res.isString()) return;
 							return toConstantDependency(
@@ -484,56 +584,59 @@ class DefinePlugin {
 					/**
 					 * Apply Object
 					 * @param {string} key Key
-					 * @param {Object} obj Object
+					 * @param {object} obj Object
 					 * @returns {void}
 					 */
 					const applyObjectDefine = (key, obj) => {
-						parser.hooks.canRename.for(key).tap("DefinePlugin", () => {
+						parser.hooks.canRename.for(key).tap(PLUGIN_NAME, () => {
 							addValueDependency(key);
 							return true;
 						});
-						parser.hooks.evaluateIdentifier
-							.for(key)
-							.tap("DefinePlugin", expr => {
-								addValueDependency(key);
-								return new BasicEvaluatedExpression()
-									.setTruthy()
-									.setSideEffects(false)
-									.setRange(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(
-								"DefinePlugin",
+								PLUGIN_NAME,
 								withValueDependency(key, evaluateToString("object"))
 							);
-						parser.hooks.expression.for(key).tap("DefinePlugin", expr => {
+						parser.hooks.expression.for(key).tap(PLUGIN_NAME, expr => {
 							addValueDependency(key);
-							const strCode = stringifyObj(
+							let strCode = stringifyObj(
 								obj,
 								parser,
 								compilation.valueCacheVersions,
 								key,
 								runtimeTemplate,
-								!parser.isAsiPosition(expr.range[0])
+								logger,
+								!parser.isAsiPosition(/** @type {Range} */ (expr.range)[0]),
+								getObjKeys(parser.destructuringAssignmentPropertiesFor(expr))
 							);
 
-							if (/__webpack_require__\s*(!?\.)/.test(strCode)) {
+							if (parser.scope.inShorthand) {
+								strCode = `${parser.scope.inShorthand}:${strCode}`;
+							}
+
+							if (WEBPACK_REQUIRE_FUNCTION_REGEXP.test(strCode)) {
 								return toConstantDependency(parser, strCode, [
 									RuntimeGlobals.require
 								])(expr);
-							} else if (/__webpack_require__/.test(strCode)) {
+							} else if (WEBPACK_REQUIRE_IDENTIFIER_REGEXP.test(strCode)) {
 								return toConstantDependency(parser, strCode, [
 									RuntimeGlobals.requireScope
 								])(expr);
-							} else {
-								return toConstantDependency(parser, strCode)(expr);
 							}
+							return toConstantDependency(parser, strCode)(expr);
 						});
 						parser.hooks.typeof
 							.for(key)
 							.tap(
-								"DefinePlugin",
+								PLUGIN_NAME,
 								withValueDependency(
 									key,
 									toConstantDependency(parser, JSON.stringify("object"))
@@ -545,33 +648,33 @@ class DefinePlugin {
 				};
 
 				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("DefinePlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
 				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("DefinePlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+					.tap(PLUGIN_NAME, handler);
 				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("DefinePlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, handler);
 
 				/**
 				 * Walk definitions
-				 * @param {Object} definitions Definitions map
+				 * @param {Record<string, CodeValue>} definitions Definitions map
 				 * @param {string} prefix Prefix string
 				 * @returns {void}
 				 */
 				const walkDefinitionsForValues = (definitions, prefix) => {
-					Object.keys(definitions).forEach(key => {
+					for (const key of Object.keys(definitions)) {
 						const code = definitions[key];
 						const version = toCacheVersion(code);
 						const name = VALUE_DEP_PREFIX + prefix + key;
-						mainHash.update("|" + prefix + key);
+						mainHash.update(`|${prefix}${key}`);
 						const oldVersion = compilation.valueCacheVersions.get(name);
 						if (oldVersion === undefined) {
 							compilation.valueCacheVersions.set(name, version);
 						} else if (oldVersion !== version) {
 							const warning = new WebpackError(
-								`DefinePlugin\nConflicting values for '${prefix + key}'`
+								`${PLUGIN_NAME}\nConflicting values for '${prefix + key}'`
 							);
 							warning.details = `'${oldVersion}' !== '${version}'`;
 							warning.hideStack = true;
@@ -583,9 +686,12 @@ class DefinePlugin {
 							!(code instanceof RuntimeValue) &&
 							!(code instanceof RegExp)
 						) {
-							walkDefinitionsForValues(code, prefix + key + ".");
+							walkDefinitionsForValues(
+								/** @type {Record<string, CodeValue>} */ (code),
+								`${prefix + key}.`
+							);
 						}
-					});
+					}
 				};
 
 				walkDefinitionsForValues(definitions, "");