@depup/webpack 5.106.0-depup.0 → 5.109.0-depup.0

package/lib/dependencies/ImportMetaPlugin.js

@@ -7,7 +7,7 @@
 
 const { pathToFileURL } = require("url");
 const { SyncBailHook } = require("tapable");
-const Compilation = require("../Compilation");
+/** @typedef {import("../Compilation")} Compilation */
 const DefinePlugin = require("../DefinePlugin");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
@@ -22,15 +22,31 @@ 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
+// cache tail can run that handler after a test tears down the module registry.
+const WEBPACK_VERSION = Number.parseInt(
+	require("../../package.json").version,
+	10
+);
+
 /** @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 */
@@ -40,69 +56,160 @@ const ModuleInitFragmentDependency = require("./ModuleInitFragmentDependency");
 
 const PLUGIN_NAME = "ImportMetaPlugin";
 
-/** @type {WeakMap<Compilation, { stringify: string, env: Record<string, string> }>} */
-const compilationMetaEnvMap = new WeakMap();
+const IMPORT_META = "import.meta";
+const IMPORT_META_URL = "import.meta.url";
+const IMPORT_META_WEBPACK = "import.meta.webpack";
+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).
+// `dirname`/`filename` are resolved by NodeStuffPlugin, the rest here. The webpack
+// pragmas `import.meta.webpackHot`/`webpackContext` are intentionally excluded:
+// they are usable in CommonJS modules and must not force ESM.
+const IMPORT_META_NAMES = [
+	IMPORT_META,
+	IMPORT_META_URL,
+	IMPORT_META_WEBPACK,
+	IMPORT_META_MAIN,
+	IMPORT_META_ENV,
+	IMPORT_META_DIRNAME,
+	IMPORT_META_FILENAME,
+	IMPORT_META_RESOLVE
+];
+
+// 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;
+
+/**
+ * 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();
+};
 
 /**
- * Collect import.meta.env definitions from DefinePlugin and build JSON string
+ * 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;
 };
 
 /**
+ * Defines the import meta plugin hooks type used by this module.
  * @typedef {object} ImportMetaPluginHooks
  * @property {SyncBailHook<[DestructuringAssignmentProperty], string | void>} propertyInDestructuring
  */
 
-/** @type {WeakMap<Compilation, ImportMetaPluginHooks>} */
-const compilationHooksMap = new WeakMap();
-
 class ImportMetaPlugin {
 	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {ImportMetaPluginHooks} the attached hooks
-	 */
-	static getCompilationHooks(compilation) {
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
-			);
-		}
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				propertyInDestructuring: new SyncBailHook(["property"])
-			};
-			compilationHooksMap.set(compilation, hooks);
-		}
-		return hooks;
-	}
-
-	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler compiler
 	 */
 	apply(compiler) {
@@ -115,59 +222,158 @@ class ImportMetaPlugin {
 					ModuleInitFragmentDependency,
 					new ModuleInitFragmentDependency.Template()
 				);
+				compilation.dependencyFactories.set(
+					ImportMetaResolveDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ImportMetaResolveDependency,
+					new ImportMetaResolveDependency.Template()
+				);
 
 				/**
+				 * Returns file url.
 				 * @param {NormalModule} module module
 				 * @returns {string} file url
 				 */
 				const getUrl = (module) => pathToFileURL(module.resource).toString();
 				/**
+				 * Processes the provided parser.
 				 * @param {Parser} parser parser parser
 				 * @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;
 
 						parser.hooks.expression
-							.for("import.meta")
+							.for(IMPORT_META)
 							.tap(PLUGIN_NAME, (metaProperty) => {
 								const dep = new ConstDependency(
 									/** @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 webpackVersion = Number.parseInt(
-						require("../../package.json").version,
-						10
-					);
 					const importMetaUrl = () =>
 						JSON.stringify(getUrl(parser.state.module));
-					const importMetaWebpackVersion = () => JSON.stringify(webpackVersion);
+					const importMetaWebpackVersion = () =>
+						JSON.stringify(WEBPACK_VERSION);
 					/**
+					 * Import meta unknown property.
 					 * @param {Members} members members
 					 * @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")
+						.for(IMPORT_META)
 						.tap(
 							PLUGIN_NAME,
 							toConstantDependency(parser, JSON.stringify("object"))
@@ -178,8 +384,17 @@ 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")
+						.for(IMPORT_META)
 						.tap(PLUGIN_NAME, (metaProperty) => {
 							/** @type {RawRuntimeRequirements} */
 							const runtimeRequirements = [];
@@ -189,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;
@@ -234,175 +481,283 @@ 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;
 						});
 					parser.hooks.evaluateTypeof
-						.for("import.meta")
+						.for(IMPORT_META)
 						.tap(PLUGIN_NAME, evaluateToString("object"));
-					parser.hooks.evaluateIdentifier.for("import.meta").tap(
+					parser.hooks.evaluateIdentifier.for(IMPORT_META).tap(
 						PLUGIN_NAME,
-						evaluateToIdentifier("import.meta", "import.meta", () => [], true)
+						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(webpackVersion));
+					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")
+						.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;
 							}
 
@@ -420,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;
 						});
@@ -436,6 +791,24 @@ class ImportMetaPlugin {
 								expr.property.type ===
 									(expr.computed ? "Literal" : "Identifier")
 							) {
+								const prop = expr.computed
+									? /** @type {import("estree").Literal} */ (expr.property)
+											.value
+									: /** @type {Identifier} */ (expr.property).name;
+								if (
+									!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));
@@ -454,4 +827,17 @@ class ImportMetaPlugin {
 	}
 }
 
+ImportMetaPlugin.getCompilationHooks = createHooksRegistry(
+	() =>
+		/** @type {ImportMetaPluginHooks} */ ({
+			propertyInDestructuring: new SyncBailHook(["property"])
+		})
+);
+
 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;