@depup/webpack 5.106.1-depup.0 → 5.109.2-depup.0

package/lib/DefinePlugin.js

@@ -12,8 +12,8 @@ const {
 	JAVASCRIPT_MODULE_TYPE_ESM
 } = require("./ModuleTypeConstants");
 const RuntimeGlobals = require("./RuntimeGlobals");
-const WebpackError = require("./WebpackError");
 const ConstDependency = require("./dependencies/ConstDependency");
+const WebpackError = require("./errors/WebpackError");
 const BasicEvaluatedExpression = require("./javascript/BasicEvaluatedExpression");
 const { VariableInfo } = require("./javascript/JavascriptParser");
 const {
@@ -21,6 +21,7 @@ const {
 	toConstantDependency
 } = require("./javascript/JavascriptParserHelpers");
 const createHash = require("./util/createHash");
+const createHooksRegistry = require("./util/createHooksRegistry");
 
 /** @typedef {import("estree").Expression} Expression */
 /** @typedef {import("./Compiler")} Compiler */
@@ -31,14 +32,17 @@ const createHash = require("./util/createHash");
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("./javascript/JavascriptParser").DestructuringAssignmentProperties} DestructuringAssignmentProperties */
+/** @typedef {import("./javascript/JavascriptParser").Members} Members */
 /** @typedef {import("./javascript/JavascriptParser").Range} Range */
 /** @typedef {import("./logging/Logger").Logger} Logger */
 /** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./NormalModule").NormalModuleBuildInfo} NormalModuleBuildInfo */
 
 /** @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
@@ -51,6 +55,7 @@ const createHash = require("./util/createHash");
 
 class RuntimeValue {
 	/**
+	 * Creates an instance of RuntimeValue.
 	 * @param {GeneratorFn} fn generator function
 	 * @param {true | string[] | RuntimeValueOptions=} options options
 	 */
@@ -71,6 +76,7 @@ class RuntimeValue {
 	}
 
 	/**
+	 * Returns code.
 	 * @param {JavascriptParser} parser the parser
 	 * @param {ValueCacheVersions} valueCacheVersions valueCacheVersions
 	 * @param {string} key the defined key
@@ -80,6 +86,10 @@ class RuntimeValue {
 		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) {
@@ -128,6 +138,7 @@ class RuntimeValue {
 }
 
 /**
+ * Returns used keys.
  * @param {DestructuringAssignmentProperties | undefined} properties properties
  * @returns {Set<string> | undefined} used keys
  */
@@ -136,10 +147,22 @@ function getObjKeys(properties) {
 	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);
+
 /** @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
@@ -185,7 +208,7 @@ const stringifyObj = (
 		code = `{${keys
 			.map((key) => {
 				const code = obj[key];
-				return `${key === "__proto__" ? '["__proto__"]' : JSON.stringify(key)}:${toCode(
+				return `${toPropertyKey(key)}:${toCode(
 					code,
 					parser,
 					valueCacheVersions,
@@ -287,6 +310,7 @@ const toCode = (
 };
 
 /**
+ * Returns result.
  * @param {CodeValue} code code
  * @returns {string | undefined} result
  */
@@ -313,7 +337,7 @@ const toCacheVersion = (code) => {
 		const items = Object.keys(code).map((key) => ({
 			key,
 			value: toCacheVersion(
-				/** @type {Record<string, EXPECTED_ANY>} */
+				/** @type {Record<string, CodeValue>} */
 				(code)[key]
 			)
 		}));
@@ -330,37 +354,315 @@ 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);
+const EMPTY_OBJECT = {};
+
+/** @typedef {Map<string, MergedDefinitionNode>} MergedDefinitionMap */
+/** @typedef {CodeValue | MergedDefinitionMap} MergedDefinitionNode */
 
 /**
- * @typedef {object} DefinePluginHooks
- * @property {SyncWaterfallHook<[Record<string, CodeValue>]>} definitions
+ * 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
  */
 
-/** @typedef {Record<string, CodeValue>} Definitions */
+/** @type {WeakMap<Compilation, MergedDefinitions>} */
+const mergedDefinitionsMap = new WeakMap();
 
-/** @type {WeakMap<Compilation, DefinePluginHooks>} */
-const compilationHooksMap = 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;
+};
 
-class DefinePlugin {
+/**
+ * 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 {Compilation} compilation the compilation
-	 * @returns {DefinePluginHooks} the attached hooks
+	 * @param {Map<string, Set<string>>} map map
+	 * @param {string} key key
+	 * @param {string} value value
 	 */
-	static getCompilationHooks(compilation) {
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				definitions: new SyncWaterfallHook(["definitions"])
-			};
-			compilationHooksMap.set(compilation, hooks);
+	const addToMap = (map, key, value) => {
+		const set = map.get(key);
+		if (set) {
+			set.add(value);
+		} else {
+			map.set(key, new Set([value]));
 		}
-		return hooks;
+	};
+	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
@@ -371,6 +673,7 @@ class DefinePlugin {
 	}
 
 	/**
+	 * Returns runtime value.
 	 * @param {GeneratorFn} fn generator function
 	 * @param {true | string[] | RuntimeValueOptions=} options options
 	 * @returns {RuntimeValue} runtime value
@@ -380,7 +683,7 @@ class DefinePlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -396,15 +699,6 @@ class DefinePlugin {
 					...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,
@@ -419,18 +713,21 @@ class DefinePlugin {
 				);
 
 				/**
-				 * Handler
+				 * 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 {BuildInfo} */ (
+						const buildInfo = /** @type {NormalModuleBuildInfo} */ (
 							parser.state.module.buildInfo
 						);
 						if (!buildInfo.valueDependencies) {
@@ -440,13 +737,14 @@ class DefinePlugin {
 					});
 
 					/**
+					 * Adds value dependency.
 					 * @param {string} key key
 					 */
 					const addValueDependency = (key) => {
 						const buildInfo =
-							/** @type {BuildInfo} */
+							/** @type {NormalModuleBuildInfo} */
 							(parser.state.module.buildInfo);
-						/** @type {NonNullable<BuildInfo["valueDependencies"]>} */
+						/** @type {NonNullable<NormalModuleBuildInfo["valueDependencies"]>} */
 						(buildInfo.valueDependencies).set(
 							VALUE_DEP_PREFIX + key,
 							/** @type {ValueCacheVersion} */
@@ -455,6 +753,7 @@ class DefinePlugin {
 					};
 
 					/**
+					 * With value dependency.
 					 * @template T
 					 * @param {string} key key
 					 * @param {(expression: Expression) => T} fn fn
@@ -468,7 +767,7 @@ class DefinePlugin {
 						};
 
 					/**
-					 * Walk definitions
+					 * Processes the provided definition.
 					 * @param {Definitions} definitions Definitions map
 					 * @param {string} prefix Prefix string
 					 * @returns {void}
@@ -476,12 +775,7 @@ class DefinePlugin {
 					const walkDefinitions = (definitions, prefix) => {
 						for (const key of Object.keys(definitions)) {
 							const code = definitions[key];
-							if (
-								code &&
-								typeof code === "object" &&
-								!(code instanceof RuntimeValue) &&
-								!(code instanceof RegExp)
-							) {
+							if (isObjectDefinition(code)) {
 								walkDefinitions(
 									/** @type {Definitions} */ (code),
 									`${prefix + key}.`
@@ -495,7 +789,7 @@ class DefinePlugin {
 					};
 
 					/**
-					 * Apply define key
+					 * Processes the provided prefix.
 					 * @param {string} prefix Prefix
 					 * @param {string} key Key
 					 * @returns {void}
@@ -505,6 +799,10 @@ class DefinePlugin {
 						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 (
@@ -517,7 +815,9 @@ class DefinePlugin {
 						}
 						if (prefix === "") {
 							const final = splittedKey[splittedKey.length - 1];
-							const nestedSet = nestedByFinalKey.get(final);
+							// 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)) {
@@ -544,17 +844,19 @@ class DefinePlugin {
 											}
 											/** @type {Definitions} */
 											const obj = Object.create(null);
-											const finalSet = finalByNestedKey.get(nested);
+											const finalSet =
+												mergedDefinitions.finalByNestedKey.get(nested);
 											for (const { id } of destructed) {
 												const fullKey = `${nested}.${id}`;
 												if (
 													!finalSet ||
 													!finalSet.has(id) ||
-													!definitions[fullKey]
+													!mergedDefinitions.definitions[fullKey]
 												) {
 													return;
 												}
-												obj[id] = definitions[fullKey];
+												addValueDependency(fullKey);
+												obj[id] = mergedDefinitions.definitions[fullKey];
 											}
 											let strCode = stringifyObj(
 												obj,
@@ -580,7 +882,7 @@ class DefinePlugin {
 					};
 
 					/**
-					 * Apply Code
+					 * Processes the provided key.
 					 * @param {string} key Key
 					 * @param {CodeValue} code Code
 					 * @returns {void}
@@ -642,16 +944,11 @@ class DefinePlugin {
 									strCode = `${parser.scope.inShorthand}:${strCode}`;
 								}
 
-								if (WEBPACK_REQUIRE_FUNCTION_REGEXP.test(strCode)) {
-									return toConstantDependency(parser, strCode, [
-										RuntimeGlobals.require
-									])(expr);
-								} else if (WEBPACK_REQUIRE_IDENTIFIER_REGEXP.test(strCode)) {
-									return toConstantDependency(parser, strCode, [
-										RuntimeGlobals.requireScope
-									])(expr);
-								}
-								return toConstantDependency(parser, strCode)(expr);
+								return toConstantDependency(
+									parser,
+									strCode,
+									getRuntimeRequirements(strCode)
+								)(expr);
 							});
 						}
 						parser.hooks.evaluateTypeof.for(key).tap(PLUGIN_NAME, (expr) => {
@@ -683,17 +980,23 @@ class DefinePlugin {
 						});
 						parser.hooks.typeof.for(key).tap(PLUGIN_NAME, (expr) => {
 							addValueDependency(originalKey);
-							const codeCode = toCode(
-								code,
-								parser,
-								compilation.valueCacheVersions,
-								originalKey,
-								runtimeTemplate,
-								logger,
-								null
-							);
-							const typeofCode = isTypeof ? codeCode : `typeof (${codeCode})`;
-							const res = parser.evaluate(typeofCode);
+							/** @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,
@@ -703,12 +1006,33 @@ class DefinePlugin {
 					};
 
 					/**
-					 * Apply Object
+					 * 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;
@@ -736,33 +1060,144 @@ class DefinePlugin {
 							}
 						);
 						parser.hooks.expression.for(key).tap(PLUGIN_NAME, (expr) => {
-							addValueDependency(key);
-							let strCode = stringifyObj(
-								obj,
-								parser,
-								compilation.valueCacheVersions,
-								key,
-								runtimeTemplate,
-								logger,
-								!parser.isAsiPosition(/** @type {Range} */ (expr.range)[0]),
-								getObjKeys(parser.destructuringAssignmentPropertiesFor(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}`;
 							}
 
-							if (WEBPACK_REQUIRE_FUNCTION_REGEXP.test(strCode)) {
-								return toConstantDependency(parser, strCode, [
-									RuntimeGlobals.require
-								])(expr);
-							} else if (WEBPACK_REQUIRE_IDENTIFIER_REGEXP.test(strCode)) {
-								return toConstantDependency(parser, strCode, [
-									RuntimeGlobals.requireScope
-								])(expr);
-							}
-							return toConstantDependency(parser, strCode)(expr);
+							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);
+						/**
+						 * Whether a member chain 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 {boolean} true when the access resolves to `undefined`
+						 */
+						const isUndefinedMemberAccess = (members, deps) => {
+							if (members.length <= chainPrefix.length) return false;
+							for (let i = 0; i < chainPrefix.length; i++) {
+								if (members[i] !== chainPrefix[i]) return false;
+							}
+							/** @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 false;
+									} else {
+										return true;
+									}
+								} 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 true;
+									}
+								} else {
+									// a leaf with members left is a real property access on a value
+									return false;
+								}
+								path = nextPath;
+							}
+							return false;
+						};
+						parser.hooks.expressionMemberChain
+							.for(chainRoot)
+							.tap(PLUGIN_NAME, (expr, members) => {
+								const deps = [key];
+								if (!isUndefinedMemberAccess(members, deps)) return;
+								for (const dep of deps) addValueDependency(dep);
+								return toConstantDependency(parser, "undefined")(expr);
+							});
+						// In a call, replace only the callee so the call itself is kept:
+						// `x.MISSING()` stays a (throwing) call and `x.MISSING?.()`
+						// short-circuits, with the object never inlined.
+						parser.hooks.callMemberChain
+							.for(chainRoot)
+							.tap(PLUGIN_NAME, (expr, members) => {
+								const deps = [key];
+								if (!isUndefinedMemberAccess(members, deps)) return;
+								for (const dep of deps) addValueDependency(dep);
+								toConstantDependency(
+									parser,
+									"undefined"
+								)(/** @type {Expression} */ (expr.callee));
+								parser.walkExpressions(expr.arguments);
+								return true;
+							});
 						parser.hooks.typeof
 							.for(key)
 							.tap(
@@ -788,7 +1223,7 @@ class DefinePlugin {
 					.tap(PLUGIN_NAME, handler);
 
 				/**
-				 * Walk definitions
+				 * Processes the provided definition.
 				 * @param {Definitions} definitions Definitions map
 				 * @param {string} prefix Prefix string
 				 * @returns {void}
@@ -810,12 +1245,7 @@ class DefinePlugin {
 							warning.hideStack = true;
 							compilation.warnings.push(warning);
 						}
-						if (
-							code &&
-							typeof code === "object" &&
-							!(code instanceof RuntimeValue) &&
-							!(code instanceof RegExp)
-						) {
+						if (isObjectDefinition(code)) {
 							walkDefinitionsForValues(
 								/** @type {Definitions} */ (code),
 								`${prefix + key}.`
@@ -824,46 +1254,6 @@ class DefinePlugin {
 					}
 				};
 
-				/**
-				 * @param {Definitions} 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(
@@ -875,4 +1265,12 @@ class DefinePlugin {
 	}
 }
 
+DefinePlugin.getCompilationHooks = createHooksRegistry(createCompilationHooks);
+
 module.exports = DefinePlugin;
+module.exports.VALUE_DEP_MAIN = VALUE_DEP_MAIN;
+module.exports.VALUE_DEP_PREFIX = VALUE_DEP_PREFIX;
+module.exports.getMergedDefinitionNode = getMergedDefinitionNode;
+module.exports.getRuntimeRequirements = getRuntimeRequirements;
+module.exports.stringifyMergedDefinition = stringifyMergedDefinition;
+module.exports.toPropertyKey = toPropertyKey;