webpack 5.108.3 → 5.109.0

package/lib/dependencies/ImportMetaPlugin.js

@@ -22,9 +22,11 @@ const {
 	evaluateToString,
 	toConstantDependency
 } = require("../javascript/JavascriptParserHelpers");
+const { getInnerGraphUtils } = require("../optimize/InnerGraph");
 const createHooksRegistry = require("../util/createHooksRegistry");
 const { propertyAccess } = require("../util/property");
 const ConstDependency = require("./ConstDependency");
+const ImportMetaResolveDependency = require("./ImportMetaResolveDependency");
 const ModuleInitFragmentDependency = require("./ModuleInitFragmentDependency");
 
 // Loaded at module scope, not inside the parser handler: the async resolver
@@ -36,9 +38,15 @@ const WEBPACK_VERSION = Number.parseInt(
 
 /** @typedef {import("estree").MemberExpression} MemberExpression */
 /** @typedef {import("estree").Identifier} Identifier */
+/** @typedef {import("estree").CallExpression} CallExpression */
+/** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").Super} Super */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../DefinePlugin").MergedDefinitionNode} MergedDefinitionNode */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../Module").ValueCacheVersion} ValueCacheVersion */
+/** @typedef {import("../NormalModule").NormalModuleBuildInfo} NormalModuleBuildInfo */
 /** @typedef {import("../NormalModule")} NormalModule */
 /** @typedef {import("../javascript/JavascriptParser")} Parser */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
@@ -55,6 +63,19 @@ const IMPORT_META_MAIN = "import.meta.main";
 const IMPORT_META_ENV = "import.meta.env";
 const IMPORT_META_DIRNAME = "import.meta.dirname";
 const IMPORT_META_FILENAME = "import.meta.filename";
+const IMPORT_META_RESOLVE = "import.meta.resolve";
+
+const IMPORT_META_FIELDS = new Set([
+	"url",
+	"webpack",
+	"main",
+	"env",
+	"dirname",
+	"filename",
+	"resolve",
+	"webpackContext",
+	"webpackHot"
+]);
 
 // Single source of truth for `import.meta` accesses that only exist in ES modules
 // and therefore mark a module as ESM (consumed by HarmonyDetectionParserPlugin).
@@ -68,39 +89,115 @@ const IMPORT_META_NAMES = [
 	IMPORT_META_MAIN,
 	IMPORT_META_ENV,
 	IMPORT_META_DIRNAME,
-	IMPORT_META_FILENAME
+	IMPORT_META_FILENAME,
+	IMPORT_META_RESOLVE
 ];
 
-/** @type {WeakMap<Compilation, { stringify: string, env: Record<string, string> }>} */
-const compilationMetaEnvMap = new WeakMap();
+// Ordering contract for import.meta parser hooks across plugins: ESM detection
+// (HarmonyDetectionParserPlugin, non-bailing) must observe every access before
+// any bailing replacement; the merged replacements here must run before
+// DefinePlugin object defines (default stage 0) and its nested destructuring
+// handler (stage 100).
+const IMPORT_META_STAGE_ESM_DETECTION = -1000;
+const IMPORT_META_STAGE_REPLACEMENT = -100;
 
 /**
- * Collect import.meta.env definitions from DefinePlugin and build JSON string
+ * import.meta definitions collected from DefinePlugin's merged view.
+ * @typedef {object} ImportMetaDefinitions
+ * @property {MergedDefinitionNode | undefined} envNode `import.meta.env` node (a map unless custom-defined)
+ * @property {Map<string, MergedDefinitionNode>} customProps custom (non-field) property nodes
+ */
+
+/** @type {WeakMap<Compilation, ImportMetaDefinitions>} */
+const compilationMetaDefinitionsMap = new WeakMap();
+
+/**
+ * Returns true if unknown import.meta properties should be preserved.
+ * @param {JavascriptParserOptions["importMeta"]} importMeta parser option
+ * @returns {boolean} true when unknown properties should be preserved
+ */
+const preserveUnknown = (importMeta) =>
+	importMeta === "preserve-unknown" ||
+	(Boolean(importMeta) && typeof importMeta === "object");
+
+/**
+ * Checks whether webpack should handle an import.meta field.
+ * @param {JavascriptParserOptions["importMeta"]} importMeta parser option
+ * @param {string} field field name
+ * @returns {boolean} true when the field should be handled
+ */
+const isImportMetaFieldEnabled = (importMeta, field) => {
+	if (importMeta === false) {
+		return false;
+	}
+	return !(
+		Boolean(importMeta) &&
+		typeof importMeta === "object" &&
+		/** @type {Record<string, boolean | undefined>} */ (importMeta)[field] ===
+			false
+	);
+};
+
+/**
+ * Checks whether the callee is the `import.meta.resolve` member.
+ * @param {Expression | Super} callee call callee
+ * @returns {boolean} true when the callee is `import.meta.resolve`
+ */
+const isImportMetaResolveCallee = (callee) =>
+	callee.type === "MemberExpression" &&
+	callee.object.type === "MetaProperty" &&
+	callee.object.meta.name === "import" &&
+	callee.object.property.name === "meta" &&
+	(callee.computed
+		? callee.property.type === "Literal" && callee.property.value === "resolve"
+		: callee.property.type === "Identifier" &&
+			callee.property.name === "resolve");
+
+/**
+ * Only a single statically known specifier maps to an asset.
+ * @param {CallExpression} call the call expression
+ * @param {Parser} parser the parser
+ * @returns {string | undefined} the resolved static specifier, if any
+ */
+const getImportMetaResolveRequest = (call, parser) => {
+	if (call.arguments.length !== 1) return undefined;
+	const [arg] = call.arguments;
+	if (arg.type === "SpreadElement") return undefined;
+	return parser.evaluateExpression(arg).asString();
+};
+
+/**
+ * Collects import.meta definitions from DefinePlugin's merged view
+ * (object form and dotted keys of every instance).
  * @param {Compilation} compilation the compilation
- * @returns {{ stringify: string, env: Record<string, string> }} env object as JSON string
+ * @returns {ImportMetaDefinitions} collected definitions
  */
-const collectImportMetaEnvDefinitions = (compilation) => {
-	const cached = compilationMetaEnvMap.get(compilation);
+const collectImportMetaDefinitions = (compilation) => {
+	const cached = compilationMetaDefinitionsMap.get(compilation);
 	if (cached) {
 		return cached;
 	}
 
-	const definePluginHooks = DefinePlugin.getCompilationHooks(compilation);
-	const definitions = definePluginHooks.definitions.call({});
-	/** @type {Record<string, string>} */
-	const env = {};
-	/** @type {string[]} */
-	const pairs = [];
-	for (const key of Object.keys(definitions)) {
-		if (key.startsWith("import.meta.env.")) {
-			const envKey = key.slice("import.meta.env.".length);
-			const value = definitions[key];
-			pairs.push(`${JSON.stringify(envKey)}:${value}`);
-			env[envKey] = /** @type {string} */ (value);
+	const metaNode = DefinePlugin.getMergedDefinitionNode(
+		compilation,
+		IMPORT_META
+	);
+	/** @type {MergedDefinitionNode | undefined} */
+	let envNode;
+	/** @type {Map<string, MergedDefinitionNode>} */
+	const customProps = new Map();
+	if (metaNode instanceof Map) {
+		for (const [prop, node] of metaNode) {
+			if (prop === "env") {
+				envNode = node;
+			} else if (!IMPORT_META_FIELDS.has(prop)) {
+				// fields (url, webpack, …) are handled by their own logic
+				customProps.set(prop, node);
+			}
 		}
 	}
-	const result = { stringify: `{${pairs.join(",")}}`, env };
-	compilationMetaEnvMap.set(compilation, result);
+	const result = { envNode, customProps };
+	compilationMetaDefinitionsMap.set(compilation, result);
 	return result;
 };
 
@@ -125,6 +222,14 @@ class ImportMetaPlugin {
 					ModuleInitFragmentDependency,
 					new ModuleInitFragmentDependency.Template()
 				);
+				compilation.dependencyFactories.set(
+					ImportMetaResolveDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ImportMetaResolveDependency,
+					new ImportMetaResolveDependency.Template()
+				);
 
 				/**
 				 * Returns file url.
@@ -138,7 +243,7 @@ class ImportMetaPlugin {
 				 * @param {JavascriptParserOptions} parserOptions parserOptions
 				 * @returns {void}
 				 */
-				const parserHandler = (parser, { importMeta }) => {
+				const parserHandler = (parser, { importMeta, url }) => {
 					if (importMeta === false) {
 						const { importMetaName } = compilation.outputOptions;
 						if (importMetaName === "import.meta") return;
@@ -150,13 +255,92 @@ class ImportMetaPlugin {
 									/** @type {string} */ (importMetaName),
 									/** @type {Range} */ (metaProperty.range)
 								);
-								dep.loc = /** @type {DependencyLocation} */ (metaProperty.loc);
+								dep.loc = parser.getLocation(metaProperty);
 								parser.state.module.addPresentationalDependency(dep);
 								return true;
 							});
 						return;
 					}
 
+					const { envNode, customProps: allCustomProps } =
+						collectImportMetaDefinitions(compilation);
+					// a non-object definition: DefinePlugin replaces the whole object
+					const envIsCustom =
+						envNode !== undefined && !(envNode instanceof Map);
+					// per-field parser options may disable custom properties too
+					/** @type {Map<string, MergedDefinitionNode>} */
+					const customProps = new Map();
+					for (const [prop, node] of allCustomProps) {
+						if (isImportMetaFieldEnabled(importMeta, prop)) {
+							customProps.set(prop, node);
+						}
+					}
+
+					/** @type {Map<string, ValueCacheVersion>} */
+					const definitionValueDependencies = new Map();
+					/**
+					 * @param {string} name value cache key
+					 */
+					const addDefinitionValueDependency = (name) => {
+						const version = compilation.valueCacheVersions.get(name);
+						// an undefined version would force a rebuild on every build
+						if (version !== undefined) {
+							definitionValueDependencies.set(name, version);
+						}
+					};
+					addDefinitionValueDependency(DefinePlugin.VALUE_DEP_MAIN);
+					if (isImportMetaFieldEnabled(importMeta, "env")) {
+						addDefinitionValueDependency(
+							DefinePlugin.VALUE_DEP_PREFIX + IMPORT_META_ENV
+						);
+						if (envNode instanceof Map) {
+							for (const envKey of envNode.keys()) {
+								addDefinitionValueDependency(
+									`${DefinePlugin.VALUE_DEP_PREFIX + IMPORT_META_ENV}.${envKey}`
+								);
+							}
+						}
+					}
+					for (const prop of customProps.keys()) {
+						addDefinitionValueDependency(
+							`${DefinePlugin.VALUE_DEP_PREFIX + IMPORT_META}.${prop}`
+						);
+					}
+					/**
+					 * Records value dependencies for every inlined definition so
+					 * cached modules rebuild when a definition value changes.
+					 * @returns {void}
+					 */
+					const addDefinitionValueDependencies = () => {
+						if (definitionValueDependencies.size === 0) return;
+						const buildInfo = /** @type {NormalModuleBuildInfo} */ (
+							parser.state.module.buildInfo
+						);
+						const valueDependencies =
+							buildInfo.valueDependencies ||
+							(buildInfo.valueDependencies = new Map());
+						for (const [name, version] of definitionValueDependencies) {
+							valueDependencies.set(name, version);
+						}
+					};
+					/**
+					 * Renders a merged definition node at a use site.
+					 * @param {MergedDefinitionNode | undefined} node node
+					 * @param {string} key definition key
+					 * @param {Set<string>=} objKeys used keys
+					 * @returns {string} code
+					 */
+					const renderDefinition = (node, key, objKeys) =>
+						node === undefined
+							? "{}"
+							: DefinePlugin.stringifyMergedDefinition(
+									compilation,
+									parser,
+									node,
+									key,
+									objKeys
+								);
+
 					// import.meta direct
 					const importMetaUrl = () =>
 						JSON.stringify(getUrl(parser.state.module));
@@ -168,13 +352,25 @@ class ImportMetaPlugin {
 					 * @returns {string} error message
 					 */
 					const importMetaUnknownProperty = (members) => {
-						if (importMeta === "preserve-unknown") {
+						if (
+							preserveUnknown(importMeta) ||
+							(IMPORT_META_FIELDS.has(members[0]) &&
+								!isImportMetaFieldEnabled(importMeta, members[0]))
+						) {
 							return `import.meta${propertyAccess(members, 0)}`;
 						}
 						return `${Template.toNormalComment(
 							`unsupported import.meta.${members.join(".")}`
 						)} undefined${propertyAccess(members, 1)}`;
 					};
+					/**
+					 * @param {string} field field name
+					 * @returns {string} generated property
+					 */
+					const importMetaRuntimeProperty = (field) =>
+						`[${JSON.stringify(field)}]: ${importMetaUnknownProperty([
+							field
+						])},`;
 
 					parser.hooks.typeof
 						.for(IMPORT_META)
@@ -188,6 +384,15 @@ class ImportMetaPlugin {
 							if (expr.type === "MetaProperty") return true;
 						}
 					);
+					// `import.meta` is always replaced by the synthesized object, so it
+					// must never become a variable alias: the alias declaration would keep
+					// the raw MetaProperty. Staged before DefinePlugin's canRename taps.
+					parser.hooks.canRename
+						.for(IMPORT_META)
+						.tap(
+							{ name: PLUGIN_NAME, stage: IMPORT_META_STAGE_REPLACEMENT },
+							() => false
+						);
 					parser.hooks.expression
 						.for(IMPORT_META)
 						.tap(PLUGIN_NAME, (metaProperty) => {
@@ -199,43 +404,75 @@ class ImportMetaPlugin {
 								parser.destructuringAssignmentPropertiesFor(metaProperty);
 							if (!referencedPropertiesInDestructuring) {
 								const varName = "__webpack_import_meta__";
-								const { stringify: envStringify } =
-									collectImportMetaEnvDefinitions(compilation);
-								const knownProps =
-									`{url: ${importMetaUrl()}, ` +
-									`webpack: ${importMetaWebpackVersion()}, ` +
-									`main: ${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}] === ${moduleArgument}, ` +
-									`env: ${envStringify}}`;
-								const initCode =
-									importMeta === "preserve-unknown"
-										? `var ${varName} = Object.assign(import.meta, ${knownProps});\n`
-										: `var ${varName} = ${knownProps};\n`;
+								const knownProps = [];
+								if (isImportMetaFieldEnabled(importMeta, "url")) {
+									knownProps.push(`url: ${importMetaUrl()}`);
+								}
+								if (isImportMetaFieldEnabled(importMeta, "webpack")) {
+									knownProps.push(`webpack: ${importMetaWebpackVersion()}`);
+								}
+								if (isImportMetaFieldEnabled(importMeta, "main")) {
+									knownProps.push(
+										`main: ${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}] === ${moduleArgument}`
+									);
+								}
+								if (isImportMetaFieldEnabled(importMeta, "env")) {
+									addDefinitionValueDependencies();
+									knownProps.push(
+										`env: ${renderDefinition(envNode, IMPORT_META_ENV)}`
+									);
+								}
+								for (const [prop, node] of customProps) {
+									addDefinitionValueDependencies();
+									knownProps.push(
+										`${DefinePlugin.toPropertyKey(prop)}: ${renderDefinition(
+											node,
+											`${IMPORT_META}.${prop}`
+										)}`
+									);
+								}
+								const initCode = preserveUnknown(importMeta)
+									? `var ${varName} = Object.assign(import.meta, {${knownProps.join(
+											", "
+										)}});\n`
+									: `var ${varName} = {${knownProps.join(", ")}};\n`;
+								/** @type {RawRuntimeRequirements} */
+								const initRuntimeRequirements = [
+									RuntimeGlobals.moduleCache,
+									RuntimeGlobals.entryModuleId,
+									RuntimeGlobals.module
+								];
+								const initCodeRequirements =
+									DefinePlugin.getRuntimeRequirements(initCode);
+								if (initCodeRequirements) {
+									initRuntimeRequirements.push(...initCodeRequirements);
+								}
 								const initDep = new ModuleInitFragmentDependency(
 									initCode,
-									[
-										RuntimeGlobals.moduleCache,
-										RuntimeGlobals.entryModuleId,
-										RuntimeGlobals.module
-									],
+									initRuntimeRequirements,
 									varName
 								);
-								initDep.loc = /** @type {DependencyLocation} */ (
-									metaProperty.loc
-								);
+								initDep.loc = parser.getLocation(metaProperty);
 								parser.state.module.addPresentationalDependency(initDep);
 								const dep = new ConstDependency(
 									varName,
 									/** @type {Range} */ (metaProperty.range),
 									runtimeRequirements
 								);
-								dep.loc = /** @type {DependencyLocation} */ (metaProperty.loc);
+								dep.loc = parser.getLocation(metaProperty);
 								parser.state.module.addPresentationalDependency(dep);
 								return true;
 							}
 
 							let str = "";
 							for (const prop of referencedPropertiesInDestructuring) {
-								const value = hooks.propertyInDestructuring.call(prop);
+								const fieldEnabled = isImportMetaFieldEnabled(
+									importMeta,
+									prop.id
+								);
+								const value = fieldEnabled
+									? hooks.propertyInDestructuring.call(prop)
+									: undefined;
 
 								if (value) {
 									str += value;
@@ -244,37 +481,62 @@ class ImportMetaPlugin {
 
 								switch (prop.id) {
 									case "url":
-										str += `url: ${importMetaUrl()},`;
+										str += fieldEnabled
+											? `url: ${importMetaUrl()},`
+											: importMetaRuntimeProperty(prop.id);
 										break;
 									case "webpack":
-										str += `webpack: ${importMetaWebpackVersion()},`;
+										str += fieldEnabled
+											? `webpack: ${importMetaWebpackVersion()},`
+											: importMetaRuntimeProperty(prop.id);
 										break;
 									case "main":
-										str += `main: ${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}] === ${moduleArgument},`;
-										runtimeRequirements.push(
-											RuntimeGlobals.moduleCache,
-											RuntimeGlobals.entryModuleId,
-											RuntimeGlobals.module
-										);
+										if (fieldEnabled) {
+											str += `main: ${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}] === ${moduleArgument},`;
+											runtimeRequirements.push(
+												RuntimeGlobals.moduleCache,
+												RuntimeGlobals.entryModuleId,
+												RuntimeGlobals.module
+											);
+										} else {
+											str += importMetaRuntimeProperty(prop.id);
+										}
 										break;
 									case "env":
-										str += `env: ${
-											collectImportMetaEnvDefinitions(compilation).stringify
-										},`;
+										if (fieldEnabled) {
+											addDefinitionValueDependencies();
+											str += `env: ${renderDefinition(envNode, IMPORT_META_ENV)},`;
+										} else {
+											str += importMetaRuntimeProperty(prop.id);
+										}
 										break;
-									default:
-										str += `[${JSON.stringify(
-											prop.id
-										)}]: ${importMetaUnknownProperty([prop.id])},`;
+									default: {
+										const node = customProps.get(prop.id);
+										if (node !== undefined) {
+											addDefinitionValueDependencies();
+											str += `${DefinePlugin.toPropertyKey(prop.id)}: ${renderDefinition(
+												node,
+												`${IMPORT_META}.${prop.id}`
+											)},`;
+										} else {
+											str += importMetaRuntimeProperty(prop.id);
+										}
 										break;
+									}
 								}
 							}
+							const strCode = `({${str}})`;
+							const codeRequirements =
+								DefinePlugin.getRuntimeRequirements(strCode);
+							if (codeRequirements) {
+								runtimeRequirements.push(...codeRequirements);
+							}
 							const dep = new ConstDependency(
-								`({${str}})`,
+								strCode,
 								/** @type {Range} */ (metaProperty.range),
 								runtimeRequirements
 							);
-							dep.loc = /** @type {DependencyLocation} */ (metaProperty.loc);
+							dep.loc = parser.getLocation(metaProperty);
 							parser.state.module.addPresentationalDependency(dep);
 							return true;
 						});
@@ -286,135 +548,216 @@ class ImportMetaPlugin {
 						evaluateToIdentifier(IMPORT_META, IMPORT_META, () => [], true)
 					);
 
+					// custom import.meta properties defined only via nested dotted keys,
+					// e.g. reading `import.meta.build` with `"import.meta.build.time"` defined
+					if (customProps.size > 0) {
+						parser.hooks.expressionMemberChain
+							.for(IMPORT_META)
+							.tap(PLUGIN_NAME, (expr, members) => {
+								const node = customProps.get(members[0]);
+								if (node === undefined) return;
+								addDefinitionValueDependencies();
+								const strCode = `(${renderDefinition(
+									node,
+									`${IMPORT_META}.${members[0]}`
+								)})${propertyAccess(members, 1)}`;
+								return toConstantDependency(
+									parser,
+									strCode,
+									DefinePlugin.getRuntimeRequirements(strCode)
+								)(expr);
+							});
+					}
+
+					// import.meta.resolve — resolve a static specifier to the emitted
+					// asset URL string (the string form of `new URL(x, import.meta.url)`).
+					if (isImportMetaFieldEnabled(importMeta, "resolve")) {
+						const relative = url === "relative";
+						parser.hooks.call
+							.for(IMPORT_META_RESOLVE)
+							.tap(PLUGIN_NAME, (expr) => {
+								const call = /** @type {CallExpression} */ (expr);
+								// Non-static forms are left untouched for runtime evaluation.
+								const request = getImportMetaResolveRequest(call, parser);
+								if (request === undefined) return;
+								const range = /** @type {Range} */ (call.range);
+								const dep = new ImportMetaResolveDependency(
+									request,
+									range,
+									range,
+									relative
+								);
+								dep.loc = parser.getLocation(call);
+								parser.state.current.addDependency(dep);
+								getInnerGraphUtils(parser.state.compilation).onUsage(
+									parser.state,
+									(e) => (dep.usedByExports = e)
+								);
+								return true;
+							});
+						// Computing a URL string is side-effect free, so an unused result
+						// can be tree-shaken (matching `new URL(..., import.meta.url)`).
+						parser.hooks.isPure
+							.for("CallExpression")
+							.tap(PLUGIN_NAME, (expr) => {
+								const call = /** @type {CallExpression} */ (expr);
+								if (!isImportMetaResolveCallee(call.callee)) return;
+								if (getImportMetaResolveRequest(call, parser) !== undefined) {
+									return true;
+								}
+							});
+					}
+
 					// import.meta.url
-					parser.hooks.typeof
-						.for(IMPORT_META_URL)
-						.tap(
-							PLUGIN_NAME,
-							toConstantDependency(parser, JSON.stringify("string"))
-						);
-					parser.hooks.expression
-						.for(IMPORT_META_URL)
-						.tap(PLUGIN_NAME, (expr) => {
-							const dep = new ConstDependency(
-								importMetaUrl(),
-								/** @type {Range} */ (expr.range)
+					if (isImportMetaFieldEnabled(importMeta, "url")) {
+						parser.hooks.typeof
+							.for(IMPORT_META_URL)
+							.tap(
+								PLUGIN_NAME,
+								toConstantDependency(parser, JSON.stringify("string"))
 							);
-							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-							parser.state.module.addPresentationalDependency(dep);
-							return true;
-						});
-					parser.hooks.evaluateTypeof
-						.for(IMPORT_META_URL)
-						.tap(PLUGIN_NAME, evaluateToString("string"));
-					parser.hooks.evaluateIdentifier
-						.for(IMPORT_META_URL)
-						.tap(PLUGIN_NAME, (expr) =>
-							new BasicEvaluatedExpression()
-								.setString(getUrl(parser.state.module))
-								.setRange(/** @type {Range} */ (expr.range))
-						);
+						parser.hooks.expression
+							.for(IMPORT_META_URL)
+							.tap(PLUGIN_NAME, (expr) => {
+								const dep = new ConstDependency(
+									importMetaUrl(),
+									/** @type {Range} */ (expr.range)
+								);
+								dep.loc = parser.getLocation(expr);
+								parser.state.module.addPresentationalDependency(dep);
+								return true;
+							});
+						parser.hooks.evaluateTypeof
+							.for(IMPORT_META_URL)
+							.tap(PLUGIN_NAME, evaluateToString("string"));
+						parser.hooks.evaluateIdentifier
+							.for(IMPORT_META_URL)
+							.tap(PLUGIN_NAME, (expr) =>
+								new BasicEvaluatedExpression()
+									.setString(getUrl(parser.state.module))
+									.setRange(/** @type {Range} */ (expr.range))
+							);
+					}
 
 					// import.meta.webpack
-					parser.hooks.expression
-						.for(IMPORT_META_WEBPACK)
-						.tap(
-							PLUGIN_NAME,
-							toConstantDependency(parser, importMetaWebpackVersion())
-						);
-					parser.hooks.typeof
-						.for(IMPORT_META_WEBPACK)
-						.tap(
-							PLUGIN_NAME,
-							toConstantDependency(parser, JSON.stringify("number"))
-						);
-					parser.hooks.evaluateTypeof
-						.for(IMPORT_META_WEBPACK)
-						.tap(PLUGIN_NAME, evaluateToString("number"));
-					parser.hooks.evaluateIdentifier
-						.for(IMPORT_META_WEBPACK)
-						.tap(PLUGIN_NAME, evaluateToNumber(WEBPACK_VERSION));
+					if (isImportMetaFieldEnabled(importMeta, "webpack")) {
+						parser.hooks.expression
+							.for(IMPORT_META_WEBPACK)
+							.tap(
+								PLUGIN_NAME,
+								toConstantDependency(parser, importMetaWebpackVersion())
+							);
+						parser.hooks.typeof
+							.for(IMPORT_META_WEBPACK)
+							.tap(
+								PLUGIN_NAME,
+								toConstantDependency(parser, JSON.stringify("number"))
+							);
+						parser.hooks.evaluateTypeof
+							.for(IMPORT_META_WEBPACK)
+							.tap(PLUGIN_NAME, evaluateToString("number"));
+						parser.hooks.evaluateIdentifier
+							.for(IMPORT_META_WEBPACK)
+							.tap(PLUGIN_NAME, evaluateToNumber(WEBPACK_VERSION));
+					}
 
-					parser.hooks.expression
-						.for(IMPORT_META_MAIN)
-						.tap(
-							PLUGIN_NAME,
-							toConstantDependency(
-								parser,
-								`${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}] === ${RuntimeGlobals.module}`,
-								[
-									RuntimeGlobals.moduleCache,
-									RuntimeGlobals.entryModuleId,
-									RuntimeGlobals.module
-								]
-							)
-						);
-					parser.hooks.typeof
-						.for(IMPORT_META_MAIN)
-						.tap(
-							PLUGIN_NAME,
-							toConstantDependency(parser, JSON.stringify("boolean"))
-						);
-					parser.hooks.evaluateTypeof
-						.for(IMPORT_META_MAIN)
-						.tap(PLUGIN_NAME, evaluateToString("boolean"));
+					if (isImportMetaFieldEnabled(importMeta, "main")) {
+						parser.hooks.expression
+							.for(IMPORT_META_MAIN)
+							.tap(
+								PLUGIN_NAME,
+								toConstantDependency(
+									parser,
+									`${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}] === ${RuntimeGlobals.module}`,
+									[
+										RuntimeGlobals.moduleCache,
+										RuntimeGlobals.entryModuleId,
+										RuntimeGlobals.module
+									]
+								)
+							);
+						parser.hooks.typeof
+							.for(IMPORT_META_MAIN)
+							.tap(
+								PLUGIN_NAME,
+								toConstantDependency(parser, JSON.stringify("boolean"))
+							);
+						parser.hooks.evaluateTypeof
+							.for(IMPORT_META_MAIN)
+							.tap(PLUGIN_NAME, evaluateToString("boolean"));
+					}
 
 					// import.meta.env
-					parser.hooks.typeof
-						.for(IMPORT_META_ENV)
-						.tap(
-							PLUGIN_NAME,
-							toConstantDependency(parser, JSON.stringify("object"))
-						);
-					parser.hooks.expressionMemberChain
-						.for(IMPORT_META)
-						.tap(PLUGIN_NAME, (expr, members) => {
-							if (members[0] === "env" && members[1]) {
-								const name = members[1];
-								const { env } = collectImportMetaEnvDefinitions(compilation);
-								if (!Object.prototype.hasOwnProperty.call(env, name)) {
-									const dep = new ConstDependency(
-										"undefined",
-										/** @type {Range} */ (expr.range)
-									);
-									dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-									parser.state.module.addPresentationalDependency(dep);
-									return true;
+					if (isImportMetaFieldEnabled(importMeta, "env")) {
+						parser.hooks.typeof
+							.for(IMPORT_META_ENV)
+							.tap(
+								PLUGIN_NAME,
+								toConstantDependency(parser, JSON.stringify("object"))
+							);
+						parser.hooks.expressionMemberChain
+							.for(IMPORT_META)
+							.tap(PLUGIN_NAME, (expr, members) => {
+								if (members[0] === "env" && members[1]) {
+									// members of a custom definition resolve on it at runtime
+									if (envIsCustom) return;
+									if (!(envNode instanceof Map) || !envNode.has(members[1])) {
+										return toConstantDependency(parser, "undefined")(expr);
+									}
 								}
+							});
+						parser.hooks.expression.for(IMPORT_META_ENV).tap(
+							// before DefinePlugin object defines: merge every definition source
+							{ name: PLUGIN_NAME, stage: IMPORT_META_STAGE_REPLACEMENT },
+							(expr) => {
+								// a custom definition replaces the whole object via DefinePlugin
+								if (envIsCustom) return;
+								addDefinitionValueDependencies();
+								const destructured =
+									parser.destructuringAssignmentPropertiesFor(expr);
+								const objKeys =
+									destructured &&
+									new Set([...destructured].map((prop) => prop.id));
+								const code = renderDefinition(
+									envNode,
+									IMPORT_META_ENV,
+									objKeys
+								);
+								const strCode = parser.isAsiPosition(
+									/** @type {Range} */ (expr.range)[0]
+								)
+									? `;(${code})`
+									: `(${code})`;
+								return toConstantDependency(
+									parser,
+									strCode,
+									DefinePlugin.getRuntimeRequirements(strCode)
+								)(expr);
 							}
-						});
-					parser.hooks.expression
-						.for(IMPORT_META_ENV)
-						.tap(PLUGIN_NAME, (expr) => {
-							const { stringify } =
-								collectImportMetaEnvDefinitions(compilation);
-
-							const dep = new ConstDependency(
-								stringify,
-								/** @type {Range} */ (expr.range)
-							);
-							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-							parser.state.module.addPresentationalDependency(dep);
-							return true;
-						});
-					parser.hooks.evaluateTypeof
-						.for(IMPORT_META_ENV)
-						.tap(PLUGIN_NAME, evaluateToString("object"));
-					parser.hooks.evaluateIdentifier
-						.for(IMPORT_META_ENV)
-						.tap(PLUGIN_NAME, (expr) =>
-							new BasicEvaluatedExpression()
-								.setTruthy()
-								.setSideEffects(false)
-								.setRange(/** @type {Range} */ (expr.range))
 						);
+						parser.hooks.evaluateTypeof
+							.for(IMPORT_META_ENV)
+							.tap(PLUGIN_NAME, evaluateToString("object"));
+						parser.hooks.evaluateIdentifier
+							.for(IMPORT_META_ENV)
+							.tap(PLUGIN_NAME, (expr) =>
+								new BasicEvaluatedExpression()
+									.setTruthy()
+									.setSideEffects(false)
+									.setRange(/** @type {Range} */ (expr.range))
+							);
+					}
 
 					// Unknown properties
 					parser.hooks.unhandledExpressionMemberChain
 						.for(IMPORT_META)
 						.tap(PLUGIN_NAME, (expr, members) => {
 							// unknown import.meta properties should be determined at runtime
-							if (importMeta === "preserve-unknown") {
+							if (
+								preserveUnknown(importMeta) ||
+								(IMPORT_META_FIELDS.has(members[0]) &&
+									!isImportMetaFieldEnabled(importMeta, members[0]))
+							) {
 								return true;
 							}
 
@@ -432,7 +775,7 @@ class ImportMetaPlugin {
 								importMetaUnknownProperty(members),
 								/** @type {Range} */ (expr.range)
 							);
-							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+							dep.loc = parser.getLocation(expr);
 							parser.state.module.addPresentationalDependency(dep);
 							return true;
 						});
@@ -452,14 +795,20 @@ class ImportMetaPlugin {
 									? /** @type {import("estree").Literal} */ (expr.property)
 											.value
 									: /** @type {Identifier} */ (expr.property).name;
-								// dirname/filename are resolved by NodeStuffPlugin; main is a runtime value
 								if (
-									prop === "dirname" ||
-									prop === "filename" ||
-									prop === "main"
+									!isImportMetaFieldEnabled(importMeta, String(prop)) ||
+									(preserveUnknown(importMeta) &&
+										!IMPORT_META_FIELDS.has(String(prop)))
 								) {
 									return;
 								}
+								if (IMPORT_META_FIELDS.has(String(prop))) {
+									return;
+								}
+								// custom-defined properties evaluate via DefinePlugin/runtime
+								if (customProps.has(String(prop))) {
+									return;
+								}
 								return new BasicEvaluatedExpression()
 									.setUndefined()
 									.setRange(/** @type {Range} */ (expr.range));
@@ -489,3 +838,6 @@ module.exports = ImportMetaPlugin;
 module.exports.IMPORT_META_DIRNAME = IMPORT_META_DIRNAME;
 module.exports.IMPORT_META_FILENAME = IMPORT_META_FILENAME;
 module.exports.IMPORT_META_NAMES = IMPORT_META_NAMES;
+module.exports.IMPORT_META_STAGE_ESM_DETECTION =
+	IMPORT_META_STAGE_ESM_DETECTION;
+module.exports.isImportMetaFieldEnabled = isImportMetaFieldEnabled;