W260426/14.webpack/node_modules/webpack/lib/DefinePlugin.js

/*
	MIT License http://www.opensource.org/licenses/mit-license.php
	Author Tobias Koppers @sokra
*/

"use strict";

const { SyncWaterfallHook } = require("tapable");
const {
	JAVASCRIPT_MODULE_TYPE_AUTO,
	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
	JAVASCRIPT_MODULE_TYPE_ESM
} = require("./ModuleTypeConstants");
const RuntimeGlobals = require("./RuntimeGlobals");
const ConstDependency = require("./dependencies/ConstDependency");
const WebpackError = require("./errors/WebpackError");
const BasicEvaluatedExpression = require("./javascript/BasicEvaluatedExpression");
const { VariableInfo } = require("./javascript/JavascriptParser");
const {
	evaluateToString,
	toConstantDependency
} = require("./javascript/JavascriptParserHelpers");
const createHash = require("./util/createHash");
const createHooksRegistry = require("./util/createHooksRegistry");

/** @import { Expression, MemberExpression } from "estree" */
/** @import Compiler from "./Compiler" */
/**
 * @import {
 * 	BuildInfo,
 * 	ValueCacheVersion,
 * 	ValueCacheVersions
 * } from "./Module"
 */
/** @import NormalModule, { NormalModuleBuildInfo } from "./NormalModule" */
/** @import RuntimeTemplate from "./RuntimeTemplate" */
/**
 * @import JavascriptParser, {
 * 	DestructuringAssignmentProperties,
 * 	Members,
 * 	Range
 * } from "./javascript/JavascriptParser"
 */
/** @import { Logger } from "./logging/Logger" */
/** @import Compilation from "./Compilation" */

/** @typedef {null | undefined | RegExp | EXPECTED_FUNCTION | string | number | boolean | bigint | undefined} CodeValuePrimitive */
/** @typedef {RecursiveArrayOrRecord<CodeValuePrimitive | RuntimeValue>} CodeValue */

/**
 * Defines the runtime value options type used by this module.
 * @typedef {object} RuntimeValueOptions
 * @property {string[]=} fileDependencies
 * @property {string[]=} contextDependencies
 * @property {string[]=} missingDependencies
 * @property {string[]=} buildDependencies
 * @property {string | (() => string)=} version
 */

/** @typedef {(value: { module: NormalModule, key: string, readonly version: ValueCacheVersion }) => CodeValuePrimitive} GeneratorFn */

class RuntimeValue {
	/**
	 * Creates an instance of RuntimeValue.
	 * @param {GeneratorFn} fn generator function
	 * @param {true | string[] | RuntimeValueOptions=} options options
	 */
	constructor(fn, options) {
		/** @type {GeneratorFn} */
		this.fn = fn;
		if (Array.isArray(options)) {
			options = {
				fileDependencies: options
			};
		}
		/** @type {true | RuntimeValueOptions} */
		this.options = options || {};
	}

	get fileDependencies() {
		return this.options === true ? true : this.options.fileDependencies;
	}

	/**
	 * Returns code.
	 * @param {JavascriptParser} parser the parser
	 * @param {ValueCacheVersions} valueCacheVersions valueCacheVersions
	 * @param {string} key the defined key
	 * @returns {CodeValuePrimitive} code
	 */
	exec(parser, valueCacheVersions, key) {
		const buildInfo = /** @type {BuildInfo} */ (parser.state.module.buildInfo);
		if (this.options === true) {
			buildInfo.cacheable = false;
			const reasons =
				buildInfo.notCacheableReasons || (buildInfo.notCacheableReasons = []);
			const reason = `DefinePlugin runtime value ${key}`;
			if (!reasons.includes(reason)) reasons.push(reason);
		} else {
			if (this.options.fileDependencies) {
				for (const dep of this.options.fileDependencies) {
					/** @type {NonNullable<BuildInfo["fileDependencies"]>} */
					(buildInfo.fileDependencies).add(dep);
				}
			}
			if (this.options.contextDependencies) {
				for (const dep of this.options.contextDependencies) {
					/** @type {NonNullable<BuildInfo["contextDependencies"]>} */
					(buildInfo.contextDependencies).add(dep);
				}
			}
			if (this.options.missingDependencies) {
				for (const dep of this.options.missingDependencies) {
					/** @type {NonNullable<BuildInfo["missingDependencies"]>} */
					(buildInfo.missingDependencies).add(dep);
				}
			}
			if (this.options.buildDependencies) {
				for (const dep of this.options.buildDependencies) {
					/** @type {NonNullable<BuildInfo["buildDependencies"]>} */
					(buildInfo.buildDependencies).add(dep);
				}
			}
		}

		return this.fn({
			module: parser.state.module,
			key,
			get version() {
				return /** @type {ValueCacheVersion} */ (
					valueCacheVersions.get(VALUE_DEP_PREFIX + key)
				);
			}
		});
	}

	getCacheVersion() {
		return this.options === true
			? undefined
			: (typeof this.options.version === "function"
					? this.options.version()
					: this.options.version) || "unset";
	}
}

/**
 * Returns used keys.
 * @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));
}

/**
 * Whether a value is a nested definition (plain object/array) to recurse into.
 * @param {CodeValue} code code value
 * @returns {code is Definitions} true for a plain object or array
 */
const isObjectDefinition = (code) =>
	Boolean(code) &&
	typeof code === "object" &&
	!(code instanceof RuntimeValue) &&
	!(code instanceof RegExp);

/**
 * Walks a member chain up, dropping its last `count` members.
 * @param {Expression} node member expression
 * @param {number} count members to drop
 * @returns {Expression} the chain without them
 */
const dropTrailingMembers = (node, count) => {
	while (count--) {
		node = /** @type {Expression} */ (
			/** @type {MemberExpression} */ (node).object
		);
	}
	return node;
};

/** @typedef {Set<string> | null} ObjKeys */
/** @typedef {boolean | undefined | null} AsiSafe */

/**
 * Returns code converted to string that evaluates.
 * @param {EXPECTED_ANY[] | { [k: string]: EXPECTED_ANY }} obj obj
 * @param {JavascriptParser} parser Parser
 * @param {ValueCacheVersions} valueCacheVersions valueCacheVersions
 * @param {string} key the defined key
 * @param {RuntimeTemplate} runtimeTemplate the runtime template
 * @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 = (
	obj,
	parser,
	valueCacheVersions,
	key,
	runtimeTemplate,
	logger,
	asiSafe,
	objKeys
) => {
	/** @type {string} */
	let code;
	const arr = Array.isArray(obj);
	if (arr) {
		code = `[${obj
			.map((code) =>
				toCode(
					code,
					parser,
					valueCacheVersions,
					key,
					runtimeTemplate,
					logger,
					null
				)
			)
			.join(",")}]`;
	} else {
		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 `${toPropertyKey(key)}:${toCode(
					code,
					parser,
					valueCacheVersions,
					key,
					runtimeTemplate,
					logger,
					null
				)}`;
			})
			.join(",")}}`;
	}

	switch (asiSafe) {
		case null:
			return code;
		case true:
			return arr ? code : `(${code})`;
		case false:
			return arr ? `;${code}` : `;(${code})`;
		default:
			return `/*#__PURE__*/Object(${code})`;
	}
};

/**
 * Convert code to a string that evaluates
 * @param {CodeValue} code Code to evaluate
 * @param {JavascriptParser} parser Parser
 * @param {ValueCacheVersions} valueCacheVersions valueCacheVersions
 * @param {string} key the defined key
 * @param {RuntimeTemplate} runtimeTemplate the runtime template
 * @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 = (
	code,
	parser,
	valueCacheVersions,
	key,
	runtimeTemplate,
	logger,
	asiSafe,
	objKeys
) => {
	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;
};

/**
 * Returns result.
 * @param {CodeValue} code code
 * @returns {string | undefined} result
 */
const toCacheVersion = (code) => {
	if (code === null) {
		return "null";
	}
	if (code === undefined) {
		return "undefined";
	}
	if (Object.is(code, -0)) {
		return "-0";
	}
	if (code instanceof RuntimeValue) {
		return code.getCacheVersion();
	}
	if (code instanceof RegExp && code.toString) {
		return code.toString();
	}
	if (typeof code === "function" && code.toString) {
		return `(${code.toString()})`;
	}
	if (typeof code === "object") {
		const items = Object.keys(code).map((key) => ({
			key,
			value: toCacheVersion(
				/** @type {Record<string, CodeValue>} */
				(code)[key]
			)
		}));
		if (items.some(({ value }) => value === undefined)) return;
		return `{${items.map(({ key, value }) => `${key}: ${value}`).join(", ")}}`;
	}
	if (typeof code === "bigint") {
		return `${code}n`;
	}
	return `${code}`;
};

const PLUGIN_NAME = "DefinePlugin";
const VALUE_DEP_PREFIX = `webpack/${PLUGIN_NAME} `;
const VALUE_DEP_MAIN = `webpack/${PLUGIN_NAME}_hash`;

// Keys webpack injects itself are not the user's to remove, so `performance.unusedDefines`
// never sees them.
/** @type {WeakSet<DefinePlugin>} */
const INTERNAL_PLUGINS = new WeakSet();
/** @type {WeakMap<Compilation, Set<string>>} */
const DECLARED_KEYS = new WeakMap();
const TYPEOF_OPERATOR_REGEXP = /^typeof\s+/;
const EMPTY_OBJECT = {};

/** @typedef {Map<string, MergedDefinitionNode>} MergedDefinitionMap */
/** @typedef {CodeValue | MergedDefinitionMap} MergedDefinitionNode */

/**
 * Merged view of the definitions of every DefinePlugin instance.
 * @typedef {object} MergedDefinitions
 * @property {Compilation} compilation the compilation
 * @property {Definitions} definitions flat definitions
 * @property {MergedDefinitionMap} root nested view (dotted keys expanded)
 * @property {Map<string, Set<string>>} finalByNestedKey final key segments by nested object key
 * @property {Map<string, Set<string>>} nestedByFinalKey nested object keys by final key segment
 * @property {Map<string, string[]>} keysByPrefix definition keys below each dotted-key prefix
 * @property {boolean} hasRuntimeValue renders are module-dependent (RuntimeValue present)
 * @property {WeakMap<MergedDefinitionMap, string>} codeCache rendered code per node (static trees only)
 * @property {Logger} logger the logger
 */

/** @type {WeakMap<Compilation, MergedDefinitions>} */
const mergedDefinitionsMap = new WeakMap();

/**
 * Whether a definition value is a plain object to expand into the nested view.
 * @param {CodeValue} code definition value
 * @returns {code is Definitions} true for a plain object
 */
const isPlainObjectDefinition = (code) => {
	if (!code || typeof code !== "object" || Array.isArray(code)) return false;
	const proto = Object.getPrototypeOf(code);
	return proto === Object.prototype || proto === null;
};

/**
 * Object literal key code; `__proto__` must be computed to stay an own property.
 * @param {string} key property key
 * @returns {string} property key code
 */
const toPropertyKey = (key) =>
	key === "__proto__" ? '["__proto__"]' : JSON.stringify(key);

/**
 * Whether a definition value contains a RuntimeValue (module-dependent code).
 * @param {CodeValue} value definition value
 * @returns {boolean} true when a RuntimeValue is contained
 */
const containsRuntimeValue = (value) => {
	if (value instanceof RuntimeValue) return true;
	if (isObjectDefinition(value)) {
		for (const key of Object.keys(value)) {
			if (containsRuntimeValue(value[key])) return true;
		}
	}
	return false;
};

/**
 * Sets a definition value on a node of the nested view, merging plain objects.
 * @param {MergedDefinitionMap} node node
 * @param {string} key key
 * @param {CodeValue} value definition value
 */
const setMergedValue = (node, key, value) => {
	const existing = node.get(key);
	if (isPlainObjectDefinition(value)) {
		const map =
			existing instanceof Map
				? existing
				: /** @type {MergedDefinitionMap} */ (new Map());
		if (map !== existing) node.set(key, map);
		for (const k of Object.keys(value)) setMergedValue(map, k, value[k]);
	} else {
		node.set(key, value);
	}
};

/**
 * Inserts a definition key path into the nested view.
 * @param {MergedDefinitionMap} root root node
 * @param {string[]} path dot-separated key path
 * @param {CodeValue} value definition value
 */
const insertMergedDefinition = (root, path, value) => {
	let node = root;
	for (let i = 0; i < path.length - 1; i++) {
		let next = node.get(path[i]);
		if (next === undefined && !node.has(path[i])) {
			next = /** @type {MergedDefinitionMap} */ (new Map());
			node.set(path[i], next);
		} else if (!(next instanceof Map)) {
			// deeper keys cannot merge into a non-object value
			return;
		}
		node = next;
	}
	setMergedValue(node, path[path.length - 1], value);
};

/**
 * Returns the merged view of all definitions (built once per compilation).
 * @param {Compilation} compilation the compilation
 * @returns {MergedDefinitions} merged definitions
 */
const getMergedDefinitions = (compilation) => {
	const cached = mergedDefinitionsMap.get(compilation);
	if (cached) return cached;

	const definitions = DefinePlugin.getCompilationHooks(
		compilation
	).definitions.call({});
	/** @type {MergedDefinitionMap} */
	const root = new Map();
	/** @type {Map<string, Set<string>>} */
	const finalByNestedKey = new Map();
	/** @type {Map<string, Set<string>>} */
	const nestedByFinalKey = new Map();
	/**
	 * @param {Map<string, Set<string>>} map map
	 * @param {string} key key
	 * @param {string} value value
	 */
	const addToMap = (map, key, value) => {
		const set = map.get(key);
		if (set) {
			set.add(value);
		} else {
			map.set(key, new Set([value]));
		}
	};
	let hasRuntimeValue = false;
	/** @type {Map<string, string[]>} */
	const keysByPrefix = new Map();
	for (const key of Object.keys(definitions)) {
		if (TYPEOF_OPERATOR_REGEXP.test(key)) continue;
		const code = definitions[key];
		insertMergedDefinition(root, key.split("."), code);
		if (!hasRuntimeValue && containsRuntimeValue(code)) hasRuntimeValue = true;
		// group this key under every ancestor prefix (value deps of object reads)
		for (
			let idx = key.indexOf(".");
			idx !== -1;
			idx = key.indexOf(".", idx + 1)
		) {
			const prefix = key.slice(0, idx);
			const keys = keysByPrefix.get(prefix);
			if (keys) {
				keys.push(key);
			} else {
				keysByPrefix.set(prefix, [key]);
			}
		}
		if (!code || typeof code === "object") 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);
	}
	const result = {
		compilation,
		definitions,
		root,
		finalByNestedKey,
		nestedByFinalKey,
		keysByPrefix,
		hasRuntimeValue,
		codeCache: new WeakMap(),
		logger: compilation.getLogger("webpack.DefinePlugin")
	};
	mergedDefinitionsMap.set(compilation, result);
	return result;
};

/**
 * Returns the merged definition node for a definition key.
 * @param {Compilation} compilation the compilation
 * @param {string} key definition key
 * @returns {MergedDefinitionNode | undefined} merged node
 */
const getMergedDefinitionNode = (compilation, key) => {
	/** @type {MergedDefinitionNode | undefined} */
	let node = getMergedDefinitions(compilation).root;
	for (const part of key.split(".")) {
		if (!(node instanceof Map)) return;
		node = node.get(part);
	}
	return node;
};

/**
 * Returns a merged map node converted to an object literal code string
 * (no ASI wrapping). Static renders (no key filter, no RuntimeValue) are
 * cached per compilation.
 * @param {MergedDefinitions} merged merged definitions
 * @param {MergedDefinitionMap} node merged map node
 * @param {JavascriptParser} parser Parser
 * @param {string} key the defined key
 * @param {ObjKeys=} objKeys used keys
 * @returns {string} code
 */
const stringifyMergedNode = (merged, node, parser, key, objKeys) => {
	const cacheable = objKeys === undefined && !merged.hasRuntimeValue;
	if (cacheable) {
		const cached = merged.codeCache.get(node);
		if (cached !== undefined) return cached;
	}
	let keys = [...node.keys()];
	if (objKeys) {
		keys = objKeys.size === 0 ? [] : keys.filter((k) => objKeys.has(k));
	}
	const code = `{${keys
		.map((k) => {
			const value = /** @type {MergedDefinitionNode} */ (node.get(k));
			return `${toPropertyKey(k)}:${
				value instanceof Map
					? stringifyMergedNode(merged, value, parser, k)
					: toCode(
							value,
							parser,
							merged.compilation.valueCacheVersions,
							k,
							merged.compilation.runtimeTemplate,
							merged.logger,
							null
						)
			}`;
		})
		.join(",")}}`;
	if (cacheable) merged.codeCache.set(node, code);
	return code;
};

/**
 * Renders a merged definition node to raw code (object literal for map nodes).
 * @param {Compilation} compilation the compilation
 * @param {JavascriptParser} parser Parser
 * @param {MergedDefinitionNode} node merged node
 * @param {string} key the defined key
 * @param {ObjKeys=} objKeys used keys
 * @returns {string} code
 */
const stringifyMergedDefinition = (compilation, parser, node, key, objKeys) => {
	const merged = getMergedDefinitions(compilation);
	return node instanceof Map
		? stringifyMergedNode(merged, node, parser, key, objKeys)
		: toCode(
				node,
				parser,
				compilation.valueCacheVersions,
				key,
				compilation.runtimeTemplate,
				merged.logger,
				null
			);
};

const WEBPACK_REQUIRE_FUNCTION_REGEXP = new RegExp(
	`${RuntimeGlobals.require}\\s*(!?\\.)`
);

/**
 * Runtime requirements of replacement code referencing the require function.
 * @param {string} code replacement code
 * @returns {string[] | undefined} runtime requirements
 */
const getRuntimeRequirements = (code) => {
	// fast path: most replacement code never references the require function
	if (!code.includes(RuntimeGlobals.require)) return;
	return WEBPACK_REQUIRE_FUNCTION_REGEXP.test(code)
		? [RuntimeGlobals.require]
		: [RuntimeGlobals.requireScope];
};

const createCompilationHooks = () => ({
	/**
	 * @type {SyncWaterfallHook<[Record<string, CodeValue>]>}
	 * @since 5.104.0
	 */
	definitions: new SyncWaterfallHook(["definitions"])
});

/**
 * Prefixes an evaluation error with the offending define key so a bare
 * "Unexpected token" becomes actionable. The original error is mutated and
 * returned (not re-wrapped) so its `loc`/`stack` survive for ModuleParseError's
 * code frame instead of being dumped into the message.
 * @param {string} key the defined key
 * @param {CodeValue} code the defined value
 * @param {unknown} error the original evaluation error
 * @returns {Error} the annotated error
 */
const annotateEvaluationError = (key, code, error) => {
	const value = typeof code === "string" ? code : JSON.stringify(code);
	const prefix = `DefinePlugin: failed to evaluate value for "${key}" (\`${value}\`)`;
	if (error instanceof Error) {
		error.message = `${prefix}: ${error.message}`;
		return error;
	}
	return new WebpackError(`${prefix}: ${error}`);
};

/**
 * @typedef {ReturnType<typeof createCompilationHooks>} DefinePluginHooks
 */

/** @typedef {Record<string, CodeValue>} Definitions */

class DefinePlugin {
	/**
	 * Create a new define plugin
	 * @param {Definitions} definitions A map of global object definitions
	 */
	constructor(definitions) {
		/** @type {Definitions} */
		this.definitions = definitions;
	}

	/**
	 * Returns runtime value.
	 * @param {GeneratorFn} fn generator function
	 * @param {true | string[] | RuntimeValueOptions=} options options
	 * @returns {RuntimeValue} runtime value
	 */
	static runtimeValue(fn, options) {
		return new RuntimeValue(fn, options);
	}

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 * @param {Compiler} compiler the compiler instance
	 * @returns {void}
	 */
	apply(compiler) {
		compiler.hooks.compilation.tap(
			PLUGIN_NAME,
			(compilation, { normalModuleFactory }) => {
				const definitions = this.definitions;
				const { performance } = compilation.options;
				// Only `performance.unusedDefines` reads these, so a build without it
				// collects nothing.
				const collectDeclared =
					performance !== false &&
					performance.unusedDefines === true &&
					!INTERNAL_PLUGINS.has(this);
				/** @type {Set<string> | undefined} */
				let declaredKeys;
				if (collectDeclared) {
					declaredKeys = DECLARED_KEYS.get(compilation);
					if (declaredKeys === undefined) {
						declaredKeys = new Set();
						DECLARED_KEYS.set(compilation, declaredKeys);
					}
				}
				const hooks = DefinePlugin.getCompilationHooks(compilation);

				hooks.definitions.tap(PLUGIN_NAME, (previousDefinitions) => ({
					...previousDefinitions,
					...definitions
				}));

				const logger = compilation.getLogger("webpack.DefinePlugin");
				compilation.dependencyTemplates.set(
					ConstDependency,
					new ConstDependency.Template()
				);
				const { runtimeTemplate } = compilation;

				const mainHash = createHash(compilation.outputOptions.hashFunction);
				mainHash.update(
					/** @type {string} */
					(compilation.valueCacheVersions.get(VALUE_DEP_MAIN)) || ""
				);

				/**
				 * Handles the hook callback for this code path.
				 * @param {JavascriptParser} parser Parser
				 * @returns {void}
				 */
				const handler = (parser) => {
					// built lazily here: every definitions hook is tapped by the time
					// parsers are created, and the result is cached per compilation
					const mergedDefinitions = getMergedDefinitions(compilation);
					/** @type {Set<string>} */
					const hooked = new Set();
					const mainValue =
						/** @type {ValueCacheVersion} */
						(compilation.valueCacheVersions.get(VALUE_DEP_MAIN));
					parser.hooks.program.tap(PLUGIN_NAME, () => {
						const buildInfo = /** @type {NormalModuleBuildInfo} */ (
							parser.state.module.buildInfo
						);
						if (!buildInfo.valueDependencies) {
							buildInfo.valueDependencies = new Map();
						}
						buildInfo.valueDependencies.set(VALUE_DEP_MAIN, mainValue);
					});

					/**
					 * Adds value dependency.
					 * @param {string} key key
					 */
					const addValueDependency = (key) => {
						const buildInfo =
							/** @type {NormalModuleBuildInfo} */
							(parser.state.module.buildInfo);
						/** @type {NonNullable<NormalModuleBuildInfo["valueDependencies"]>} */
						(buildInfo.valueDependencies).set(
							VALUE_DEP_PREFIX + key,
							/** @type {ValueCacheVersion} */
							(compilation.valueCacheVersions.get(VALUE_DEP_PREFIX + key))
						);
					};

					/**
					 * With value dependency.
					 * @template T
					 * @param {string} key key
					 * @param {(expression: Expression) => T} fn fn
					 * @returns {(expression: Expression) => T} result
					 */
					const withValueDependency =
						(key, fn) =>
						(...args) => {
							addValueDependency(key);
							return fn(...args);
						};

					/**
					 * Processes the provided definition.
					 * @param {Definitions} definitions Definitions map
					 * @param {string} prefix Prefix string
					 * @returns {void}
					 */
					const walkDefinitions = (definitions, prefix) => {
						for (const key of Object.keys(definitions)) {
							const code = definitions[key];
							if (isObjectDefinition(code)) {
								walkDefinitions(
									/** @type {Definitions} */ (code),
									`${prefix + key}.`
								);
								applyObjectDefine(prefix + key, code);
								continue;
							}
							applyDefineKey(prefix, key);
							applyDefine(prefix + key, code);
						}
					};

					/**
					 * Processes the provided prefix.
					 * @param {string} prefix Prefix
					 * @param {string} key Key
					 * @returns {void}
					 */
					const applyDefineKey = (prefix, key) => {
						const splittedKey = key.split(".");
						const firstKey = splittedKey[0];
						for (const [i, _] of splittedKey.slice(1).entries()) {
							const fullKey = prefix + splittedKey.slice(0, i + 1).join(".");
							// `import.meta` is a MetaProperty, not an identifier that can be
							// aliased: an alias declaration would keep the raw MetaProperty
							// in the output, so never enable renaming for its prefixes
							if (fullKey === "import" || fullKey === "import.meta") continue;
							parser.hooks.canRename.for(fullKey).tap(PLUGIN_NAME, () => {
								addValueDependency(key);
								if (
									parser.scope.definitions.get(firstKey) instanceof VariableInfo
								) {
									return false;
								}
								return true;
							});
						}
						if (prefix === "") {
							const final = splittedKey[splittedKey.length - 1];
							// aggregated over all instances so keys split across
							// several DefinePlugins can still be destructured together
							const nestedSet = mergedDefinitions.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 {Definitions} */
											const obj = Object.create(null);
											const finalSet =
												mergedDefinitions.finalByNestedKey.get(nested);
											for (const { id } of destructed) {
												const fullKey = `${nested}.${id}`;
												if (
													!finalSet ||
													!finalSet.has(id) ||
													!mergedDefinitions.definitions[fullKey]
												) {
													return;
												}
												addValueDependency(fullKey);
												obj[id] = mergedDefinitions.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);
										}
									);
								}
							}
						}
					};

					/**
					 * Processes the provided key.
					 * @param {string} key Key
					 * @param {CodeValue} code Code
					 * @returns {void}
					 */
					const applyDefine = (key, code) => {
						const originalKey = key;
						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(PLUGIN_NAME, () => {
								addValueDependency(originalKey);
								return true;
							});
							parser.hooks.evaluateIdentifier
								.for(key)
								.tap(PLUGIN_NAME, (expr) => {
									/**
									 * this is needed in case there is a recursion in the DefinePlugin
									 * to prevent an endless recursion
									 * e.g.: new DefinePlugin({
									 * "a": "b",
									 * "b": "a"
									 * });
									 */
									if (recurse) return;
									addValueDependency(originalKey);
									recurse = true;
									const res = parser.evaluate(
										toCode(
											code,
											parser,
											compilation.valueCacheVersions,
											key,
											runtimeTemplate,
											logger,
											null
										)
									);
									recurse = false;
									res.setRange(/** @type {Range} */ (expr.range));
									return res;
								});
							parser.hooks.expression.for(key).tap(PLUGIN_NAME, (expr) => {
								addValueDependency(originalKey);
								let strCode = toCode(
									code,
									parser,
									compilation.valueCacheVersions,
									originalKey,
									runtimeTemplate,
									logger,
									!parser.isAsiPosition(/** @type {Range} */ (expr.range)[0]),
									null
								);

								if (parser.scope.inShorthand) {
									strCode = `${parser.scope.inShorthand}:${strCode}`;
								}

								return toConstantDependency(
									parser,
									strCode,
									getRuntimeRequirements(strCode)
								)(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
							 * e.g.: new DefinePlugin({
							 * "typeof a": "typeof b",
							 * "typeof b": "typeof a"
							 * });
							 */
							if (recurseTypeof) return;
							recurseTypeof = true;
							addValueDependency(originalKey);
							const codeCode = toCode(
								code,
								parser,
								compilation.valueCacheVersions,
								originalKey,
								runtimeTemplate,
								logger,
								null
							);
							const typeofCode = isTypeof ? codeCode : `typeof (${codeCode})`;
							const res = parser.evaluate(typeofCode);
							recurseTypeof = false;
							res.setRange(/** @type {Range} */ (expr.range));
							return res;
						});
						parser.hooks.typeof.for(key).tap(PLUGIN_NAME, (expr) => {
							addValueDependency(originalKey);
							/** @type {BasicEvaluatedExpression} */
							let res;
							try {
								const codeCode = toCode(
									code,
									parser,
									compilation.valueCacheVersions,
									originalKey,
									runtimeTemplate,
									logger,
									null
								);
								const typeofCode = isTypeof ? codeCode : `typeof (${codeCode})`;
								res = parser.evaluate(typeofCode);
							} catch (err) {
								throw annotateEvaluationError(originalKey, code, err);
							}
							if (!res.isString()) return;
							return toConstantDependency(
								parser,
								JSON.stringify(res.string)
							).bind(parser)(expr);
						});
					};

					/**
					 * Processes the provided key.
					 * @param {string} key Key
					 * @param {object} obj Object
					 * @returns {void}
					 */
					const applyObjectDefine = (key, obj) => {
						const mergedNode = getMergedDefinitionNode(compilation, key);
						/** @type {MergedDefinitionNode} */
						const definition =
							mergedNode === undefined
								? /** @type {CodeValue} */ (obj)
								: mergedNode;
						// value dependencies of a whole-object read: the key itself and
						// every dotted definition key below it (from any instance)
						/** @type {[string, ValueCacheVersion][]} */
						const objectValueDependencies = [];
						for (const defKey of [
							key,
							...(mergedDefinitions.keysByPrefix.get(key) || [])
						]) {
							const name = VALUE_DEP_PREFIX + defKey;
							objectValueDependencies.push([
								name,
								/** @type {ValueCacheVersion} */
								(compilation.valueCacheVersions.get(name))
							]);
						}
						parser.hooks.canRename.for(key).tap(PLUGIN_NAME, () => {
							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.evaluateTypeof
							.for(key)
							.tap(
								PLUGIN_NAME,
								withValueDependency(key, evaluateToString("object"))
							);
						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) => {
							const valueDependencies =
								/** @type {NonNullable<NormalModuleBuildInfo["valueDependencies"]>} */
								(
									/** @type {NormalModuleBuildInfo} */
									(parser.state.module.buildInfo).valueDependencies
								);
							for (const [name, version] of objectValueDependencies) {
								valueDependencies.set(name, version);
							}
							// render the merged view so dotted keys (of any instance)
							// are part of whole-object and destructured reads
							const objKeys = getObjKeys(
								parser.destructuringAssignmentPropertiesFor(expr)
							);
							const asiSafe = !parser.isAsiPosition(
								/** @type {Range} */ (expr.range)[0]
							);
							let strCode;
							if (definition instanceof Map) {
								const code = stringifyMergedNode(
									mergedDefinitions,
									definition,
									parser,
									key,
									objKeys
								);
								strCode = asiSafe ? `(${code})` : `;(${code})`;
							} else {
								strCode = toCode(
									definition,
									parser,
									compilation.valueCacheVersions,
									key,
									runtimeTemplate,
									logger,
									asiSafe,
									objKeys
								);
							}

							if (parser.scope.inShorthand) {
								strCode = `${parser.scope.inShorthand}:${strCode}`;
							}

							return toConstantDependency(
								parser,
								strCode,
								getRuntimeRequirements(strCode)
							)(expr);
						});
						// A property access not defined on the object resolves to `undefined`
						// and the whole object is never inlined (issue #15559). Keyed by the
						// chain root so dotted object keys (e.g. `a.b`) are also covered.
						const chainParts = key.split(".");
						// `import.meta` is one chain root (a MetaProperty), not two members.
						const isMeta =
							chainParts[0] === "import" && chainParts[1] === "meta";
						const chainRoot = isMeta ? "import.meta" : chainParts[0];
						const chainPrefix = chainParts.slice(isMeta ? 2 : 1);
						/**
						 * Finds the member of a chain that reads a property that is not defined.
						 * Walks the merged view so dotted keys of every instance count.
						 * Collects every define key consulted so the caller can record a
						 * value dependency on each (a sibling key like `OBJECT.SUB2` affects
						 * the result even though `OBJECT` registered the handler).
						 * Inherited members (e.g. `toString`) stay defined.
						 * @param {Members} members chain members (after the root)
						 * @param {string[]} deps consulted define keys (mutated)
						 * @returns {number} index of the member resolving to `undefined`, or -1
						 */
						const findUndefinedMemberAccess = (members, deps) => {
							if (members.length <= chainPrefix.length) return -1;
							for (let i = 0; i < chainPrefix.length; i++) {
								if (members[i] !== chainPrefix[i]) return -1;
							}
							/** @type {MergedDefinitionNode | undefined} */
							let value = definition;
							let path = key;
							for (let i = chainPrefix.length; i < members.length; i++) {
								const member = members[i];
								const nextPath = `${path}.${member}`;
								if (value instanceof Map) {
									if (value.has(member)) {
										deps.push(nextPath);
										value = value.get(member);
									} else if (member in EMPTY_OBJECT) {
										return -1;
									} else {
										return i;
									}
								} else if (isObjectDefinition(value)) {
									// non-expandable object leaf (e.g. an array)
									if (member in value) {
										value = /** @type {Definitions} */ (value)[member];
									} else if (
										Object.prototype.hasOwnProperty.call(
											mergedDefinitions.definitions,
											nextPath
										)
									) {
										// defined via a dotted sibling key, e.g. `OBJECT.SUB2`
										deps.push(nextPath);
										value = mergedDefinitions.definitions[nextPath];
									} else {
										return i;
									}
								} else {
									// a leaf with members left is a real property access on a value
									return -1;
								}
								path = nextPath;
							}
							return -1;
						};
						parser.hooks.expressionMemberChain
							.for(chainRoot)
							.tap(PLUGIN_NAME, (expr, members) => {
								const deps = [key];
								if (findUndefinedMemberAccess(members, deps) === -1) return;
								for (const dep of deps) addValueDependency(dep);
								return toConstantDependency(parser, "undefined")(expr);
							});
						// Cut the chain at the undefined member, so what follows still
						// throws; an optional link there takes the call, arguments unevaluated.
						parser.hooks.callMemberChain
							.for(chainRoot)
							.tap(PLUGIN_NAME, (expr, members, membersOptionals) => {
								const deps = [key];
								const undefinedIndex = findUndefinedMemberAccess(members, deps);
								if (undefinedIndex === -1) return;
								for (const dep of deps) addValueDependency(dep);
								if (membersOptionals[undefinedIndex + 1]) {
									return toConstantDependency(parser, "undefined")(expr);
								}
								toConstantDependency(
									parser,
									"undefined"
								)(
									dropTrailingMembers(
										/** @type {Expression} */ (expr.callee),
										members.length - 1 - undefinedIndex
									)
								);
								parser.walkExpressions(expr.arguments);
								return true;
							});
						parser.hooks.typeof
							.for(key)
							.tap(
								PLUGIN_NAME,
								withValueDependency(
									key,
									toConstantDependency(parser, JSON.stringify("object"))
								)
							);
					};

					walkDefinitions(definitions, "");
				};

				normalModuleFactory.hooks.parser
					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
					.tap(PLUGIN_NAME, handler);
				normalModuleFactory.hooks.parser
					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
					.tap(PLUGIN_NAME, handler);
				normalModuleFactory.hooks.parser
					.for(JAVASCRIPT_MODULE_TYPE_ESM)
					.tap(PLUGIN_NAME, handler);

				/**
				 * Processes the provided definition.
				 * @param {Definitions} definitions Definitions map
				 * @param {string} prefix Prefix string
				 * @returns {void}
				 */
				const walkDefinitionsForValues = (definitions, prefix) => {
					for (const key of Object.keys(definitions)) {
						const code = definitions[key];
						const version = /** @type {string} */ (toCacheVersion(code));
						const name = VALUE_DEP_PREFIX + 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(
								`${PLUGIN_NAME}\nConflicting values for '${prefix + key}'`
							);
							warning.details = `'${oldVersion}' !== '${version}'`;
							warning.hideStack = true;
							compilation.warnings.push(warning);
						}
						// Leaves only: an object key counts as used whenever any of its
						// members is, which would report the parent as unused. An object
						// with no members has none, and still substitutes.
						const isLeaf =
							!isObjectDefinition(code) ||
							Object.keys(/** @type {Definitions} */ (code)).length === 0;

						if (declaredKeys !== undefined && isLeaf) {
							declaredKeys.add(prefix + key);
						}

						if (isObjectDefinition(code)) {
							walkDefinitionsForValues(
								/** @type {Definitions} */ (code),
								`${prefix + key}.`
							);
						}
					}
				};

				walkDefinitionsForValues(definitions, "");

				compilation.valueCacheVersions.set(
					VALUE_DEP_MAIN,
					mainHash.digest("hex").slice(0, 8)
				);
			}
		);
	}
}

DefinePlugin.getCompilationHooks = createHooksRegistry(createCompilationHooks);

/**
 * Marks an instance as webpack's own, so `performance.unusedDefines` never
 * reports the keys it declares against the user.
 * @param {DefinePlugin} plugin the instance webpack constructed itself
 * @returns {DefinePlugin} the same instance
 */
const markInternal = (plugin) => {
	INTERNAL_PLUGINS.add(plugin);
	return plugin;
};

/**
 * The keys the configuration declared, webpack's own excluded.
 * @param {Compilation} compilation the compilation
 * @returns {Set<string> | undefined} the keys, or undefined when none were collected
 */
const getDeclaredKeys = (compilation) => DECLARED_KEYS.get(compilation);

DefinePlugin.VALUE_DEP_MAIN = VALUE_DEP_MAIN;
DefinePlugin.VALUE_DEP_PREFIX = VALUE_DEP_PREFIX;
DefinePlugin.getDeclaredKeys = getDeclaredKeys;
DefinePlugin.getMergedDefinitionNode = getMergedDefinitionNode;
DefinePlugin.getRuntimeRequirements = getRuntimeRequirements;
DefinePlugin.markInternal = markInternal;
DefinePlugin.stringifyMergedDefinition = stringifyMergedDefinition;
DefinePlugin.toPropertyKey = toPropertyKey;

module.exports = DefinePlugin;