webpack 5.97.1 → 5.104.1

package/lib/WebpackOptionsApply.js

@@ -5,63 +5,83 @@
 
 "use strict";
 
-const OptionsApply = require("./OptionsApply");
+const APIPlugin = require("./APIPlugin");
 
-const AssetModulesPlugin = require("./asset/AssetModulesPlugin");
-const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin");
-const JsonModulesPlugin = require("./json/JsonModulesPlugin");
+const CompatibilityPlugin = require("./CompatibilityPlugin");
 
-const ChunkPrefetchPreloadPlugin = require("./prefetch/ChunkPrefetchPreloadPlugin");
+const ConstPlugin = require("./ConstPlugin");
 
 const EntryOptionPlugin = require("./EntryOptionPlugin");
+
+const ExportsInfoApiPlugin = require("./ExportsInfoApiPlugin");
+const FlagDependencyExportsPlugin = require("./FlagDependencyExportsPlugin");
+
+const JavascriptMetaInfoPlugin = require("./JavascriptMetaInfoPlugin");
+
+const NodeStuffPlugin = require("./NodeStuffPlugin");
+const OptionsApply = require("./OptionsApply");
+
 const RecordIdsPlugin = require("./RecordIdsPlugin");
 
 const RuntimePlugin = require("./RuntimePlugin");
 
-const APIPlugin = require("./APIPlugin");
-const CompatibilityPlugin = require("./CompatibilityPlugin");
-const ConstPlugin = require("./ConstPlugin");
-const ExportsInfoApiPlugin = require("./ExportsInfoApiPlugin");
-const WebpackIsIncludedPlugin = require("./WebpackIsIncludedPlugin");
-
 const TemplatedPathPlugin = require("./TemplatedPathPlugin");
+
 const UseStrictPlugin = require("./UseStrictPlugin");
+
 const WarnCaseSensitiveModulesPlugin = require("./WarnCaseSensitiveModulesPlugin");
 
-const DataUriPlugin = require("./schemes/DataUriPlugin");
-const FileUriPlugin = require("./schemes/FileUriPlugin");
+const WebpackIsIncludedPlugin = require("./WebpackIsIncludedPlugin");
+
+const AssetModulesPlugin = require("./asset/AssetModulesPlugin");
+
+const InferAsyncModulesPlugin = require("./async-modules/InferAsyncModulesPlugin");
 
 const ResolverCachePlugin = require("./cache/ResolverCachePlugin");
 
 const CommonJsPlugin = require("./dependencies/CommonJsPlugin");
+
 const HarmonyModulesPlugin = require("./dependencies/HarmonyModulesPlugin");
+
 const ImportMetaContextPlugin = require("./dependencies/ImportMetaContextPlugin");
 const ImportMetaPlugin = require("./dependencies/ImportMetaPlugin");
+
 const ImportPlugin = require("./dependencies/ImportPlugin");
 const LoaderPlugin = require("./dependencies/LoaderPlugin");
+
 const RequireContextPlugin = require("./dependencies/RequireContextPlugin");
 const RequireEnsurePlugin = require("./dependencies/RequireEnsurePlugin");
 const RequireIncludePlugin = require("./dependencies/RequireIncludePlugin");
+
 const SystemPlugin = require("./dependencies/SystemPlugin");
+
 const URLPlugin = require("./dependencies/URLPlugin");
+
 const WorkerPlugin = require("./dependencies/WorkerPlugin");
 
-const InferAsyncModulesPlugin = require("./async-modules/InferAsyncModulesPlugin");
+const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin");
+
+const JsonModulesPlugin = require("./json/JsonModulesPlugin");
+
+const ChunkPrefetchPreloadPlugin = require("./prefetch/ChunkPrefetchPreloadPlugin");
+
+const DataUriPlugin = require("./schemes/DataUriPlugin");
+const FileUriPlugin = require("./schemes/FileUriPlugin");
 
-const JavascriptMetaInfoPlugin = require("./JavascriptMetaInfoPlugin");
 const DefaultStatsFactoryPlugin = require("./stats/DefaultStatsFactoryPlugin");
 const DefaultStatsPresetPlugin = require("./stats/DefaultStatsPresetPlugin");
 const DefaultStatsPrinterPlugin = require("./stats/DefaultStatsPrinterPlugin");
 
 const { cleverMerge } = require("./util/cleverMerge");
 
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
 /** @typedef {import("../declarations/WebpackOptions").WebpackPluginFunction} WebpackPluginFunction */
-/** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
+/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("./util/fs").IntermediateFileSystem} IntermediateFileSystem */
 
+const CLASS_NAME = "WebpackOptionsApply";
+
 class WebpackOptionsApply extends OptionsApply {
 	constructor() {
 		super();
@@ -73,7 +93,7 @@ class WebpackOptionsApply extends OptionsApply {
 	 * @returns {WebpackOptions} options object
 	 */
 	process(options, compiler) {
-		compiler.outputPath = /** @type {string} */ (options.output.path);
+		compiler.outputPath = options.output.path;
 		compiler.recordsInputPath = options.recordsInputPath || null;
 		compiler.recordsOutputPath = options.recordsOutputPath || null;
 		compiler.name = options.name;
@@ -81,6 +101,7 @@ class WebpackOptionsApply extends OptionsApply {
 		if (options.externals) {
 			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 			const ExternalsPlugin = require("./ExternalsPlugin");
+
 			new ExternalsPlugin(options.externalsType, options.externals).apply(
 				compiler
 			);
@@ -88,99 +109,106 @@ class WebpackOptionsApply extends OptionsApply {
 
 		if (options.externalsPresets.node) {
 			const NodeTargetPlugin = require("./node/NodeTargetPlugin");
-			new NodeTargetPlugin().apply(compiler);
-		}
-		if (options.externalsPresets.electronMain) {
-			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-			const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin");
-			new ElectronTargetPlugin("main").apply(compiler);
-		}
-		if (options.externalsPresets.electronPreload) {
-			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-			const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin");
-			new ElectronTargetPlugin("preload").apply(compiler);
-		}
-		if (options.externalsPresets.electronRenderer) {
-			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-			const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin");
-			new ElectronTargetPlugin("renderer").apply(compiler);
-		}
-		if (
-			options.externalsPresets.electron &&
-			!options.externalsPresets.electronMain &&
-			!options.externalsPresets.electronPreload &&
-			!options.externalsPresets.electronRenderer
-		) {
-			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-			const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin");
-			new ElectronTargetPlugin().apply(compiler);
-		}
-		if (options.externalsPresets.nwjs) {
-			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-			const ExternalsPlugin = require("./ExternalsPlugin");
-			new ExternalsPlugin("node-commonjs", "nw.gui").apply(compiler);
+
+			// Some older versions of Node.js don't support all built-in modules via import, only via `require`,
+			// but it seems like there shouldn't be a warning here since these versions are rarely used in real applications
+			new NodeTargetPlugin(
+				options.output.module &&
+					compiler.platform.node === null &&
+					compiler.platform.web === null
+					? "module-import"
+					: "node-commonjs"
+			).apply(compiler);
+
+			// Handle external CSS `@import` and `url()`
+			if (options.experiments.css) {
+				// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+				const ExternalsPlugin = require("./ExternalsPlugin");
+
+				new ExternalsPlugin(
+					"module",
+					({ request, dependencyType, contextInfo }, callback) => {
+						if (
+							/\.css(\?|$)/.test(contextInfo.issuer) &&
+							/^(\/\/|https?:\/\/|#)/.test(request)
+						) {
+							if (dependencyType === "url") {
+								return callback(null, `asset ${request}`);
+							} else if (
+								(dependencyType === "css-import" ||
+									dependencyType === "css-import-local-module" ||
+									dependencyType === "css-import-global-module") &&
+								options.experiments.css
+							) {
+								return callback(null, `css-import ${request}`);
+							}
+						}
+
+						callback();
+					}
+				).apply(compiler);
+			}
 		}
-		if (options.externalsPresets.webAsync) {
-			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-			const ExternalsPlugin = require("./ExternalsPlugin");
-			new ExternalsPlugin("import", ({ request, dependencyType }, callback) => {
-				if (dependencyType === "url") {
-					if (/^(\/\/|https?:\/\/|#)/.test(/** @type {string} */ (request)))
-						return callback(null, `asset ${request}`);
-				} else if (options.experiments.css && dependencyType === "css-import") {
-					if (/^(\/\/|https?:\/\/|#)/.test(/** @type {string} */ (request)))
-						return callback(null, `css-import ${request}`);
-				} else if (
-					options.experiments.css &&
-					/^(\/\/|https?:\/\/|std:)/.test(/** @type {string} */ (request))
-				) {
-					if (/^\.css(\?|$)/.test(/** @type {string} */ (request)))
-						return callback(null, `css-import ${request}`);
-					return callback(null, `import ${request}`);
-				}
-				callback();
-			}).apply(compiler);
-		} else if (options.externalsPresets.web) {
+		if (options.externalsPresets.webAsync || options.externalsPresets.web) {
+			const type = options.externalsPresets.webAsync ? "import" : "module";
+
 			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 			const ExternalsPlugin = require("./ExternalsPlugin");
-			new ExternalsPlugin("module", ({ request, dependencyType }, callback) => {
-				if (dependencyType === "url") {
-					if (/^(\/\/|https?:\/\/|#)/.test(/** @type {string} */ (request)))
+
+			new ExternalsPlugin(type, ({ request, dependencyType }, callback) => {
+				if (/^(\/\/|https?:\/\/|#|std:|jsr:|npm:)/.test(request)) {
+					if (dependencyType === "url") {
 						return callback(null, `asset ${request}`);
-				} else if (options.experiments.css && dependencyType === "css-import") {
-					if (/^(\/\/|https?:\/\/|#)/.test(/** @type {string} */ (request)))
+					} else if (
+						(dependencyType === "css-import" ||
+							dependencyType === "css-import-local-module" ||
+							dependencyType === "css-import-global-module") &&
+						options.experiments.css
+					) {
 						return callback(null, `css-import ${request}`);
-				} else if (
-					/^(\/\/|https?:\/\/|std:)/.test(/** @type {string} */ (request))
-				) {
-					if (
-						options.experiments.css &&
-						/^\.css((\?)|$)/.test(/** @type {string} */ (request))
-					)
-						return callback(null, `css-import ${request}`);
-					return callback(null, `module ${request}`);
+					} else if (/^(\/\/|https?:\/\/|std:|jsr:|npm:)/.test(request)) {
+						return callback(null, `${type} ${request}`);
+					}
 				}
+
 				callback();
 			}).apply(compiler);
-		} else if (options.externalsPresets.node && options.experiments.css) {
+		}
+		if (options.externalsPresets.electron) {
+			if (options.externalsPresets.electronMain) {
+				// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+				const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin");
+
+				new ElectronTargetPlugin("main").apply(compiler);
+			}
+			if (options.externalsPresets.electronPreload) {
+				// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+				const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin");
+
+				new ElectronTargetPlugin("preload").apply(compiler);
+			}
+			if (options.externalsPresets.electronRenderer) {
+				// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+				const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin");
+
+				new ElectronTargetPlugin("renderer").apply(compiler);
+			}
+			if (
+				!options.externalsPresets.electronMain &&
+				!options.externalsPresets.electronPreload &&
+				!options.externalsPresets.electronRenderer
+			) {
+				// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+				const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin");
+
+				new ElectronTargetPlugin().apply(compiler);
+			}
+		}
+		if (options.externalsPresets.nwjs) {
 			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 			const ExternalsPlugin = require("./ExternalsPlugin");
-			new ExternalsPlugin("module", ({ request, dependencyType }, callback) => {
-				if (dependencyType === "url") {
-					if (/^(\/\/|https?:\/\/|#)/.test(/** @type {string} */ (request)))
-						return callback(null, `asset ${request}`);
-				} else if (dependencyType === "css-import") {
-					if (/^(\/\/|https?:\/\/|#)/.test(/** @type {string} */ (request)))
-						return callback(null, `css-import ${request}`);
-				} else if (
-					/^(\/\/|https?:\/\/|std:)/.test(/** @type {string} */ (request))
-				) {
-					if (/^\.css(\?|$)/.test(/** @type {string} */ (request)))
-						return callback(null, `css-import ${request}`);
-					return callback(null, `module ${request}`);
-				}
-				callback();
-			}).apply(compiler);
+
+			new ExternalsPlugin("node-commonjs", "nw.gui").apply(compiler);
 		}
 
 		new ChunkPrefetchPreloadPlugin().apply(compiler);
@@ -189,16 +217,19 @@ class WebpackOptionsApply extends OptionsApply {
 			switch (options.output.chunkFormat) {
 				case "array-push": {
 					const ArrayPushCallbackChunkFormatPlugin = require("./javascript/ArrayPushCallbackChunkFormatPlugin");
+
 					new ArrayPushCallbackChunkFormatPlugin().apply(compiler);
 					break;
 				}
 				case "commonjs": {
 					const CommonJsChunkFormatPlugin = require("./javascript/CommonJsChunkFormatPlugin");
+
 					new CommonJsChunkFormatPlugin().apply(compiler);
 					break;
 				}
 				case "module": {
 					const ModuleChunkFormatPlugin = require("./esm/ModuleChunkFormatPlugin");
+
 					new ModuleChunkFormatPlugin().apply(compiler);
 					break;
 				}
@@ -216,6 +247,7 @@ class WebpackOptionsApply extends OptionsApply {
 		if (enabledChunkLoadingTypes.length > 0) {
 			for (const type of enabledChunkLoadingTypes) {
 				const EnableChunkLoadingPlugin = require("./javascript/EnableChunkLoadingPlugin");
+
 				new EnableChunkLoadingPlugin(type).apply(compiler);
 			}
 		}
@@ -227,6 +259,7 @@ class WebpackOptionsApply extends OptionsApply {
 		if (enabledWasmLoadingTypes.length > 0) {
 			for (const type of enabledWasmLoadingTypes) {
 				const EnableWasmLoadingPlugin = require("./wasm/EnableWasmLoadingPlugin");
+
 				new EnableWasmLoadingPlugin(type).apply(compiler);
 			}
 		}
@@ -236,14 +269,31 @@ class WebpackOptionsApply extends OptionsApply {
 			(options.output.enabledLibraryTypes);
 
 		if (enabledLibraryTypes.length > 0) {
+			let once = true;
 			for (const type of enabledLibraryTypes) {
 				const EnableLibraryPlugin = require("./library/EnableLibraryPlugin");
-				new EnableLibraryPlugin(type).apply(compiler);
+
+				new EnableLibraryPlugin(type, {
+					// eslint-disable-next-line no-loop-func
+					additionalApply: () => {
+						if (!once) return;
+						once = false;
+						// We rely on `exportInfo` to generate the `export statement` in certain library bundles.
+						// Therefore, we ignore the disabling of `optimization.providedExport` and continue to apply `FlagDependencyExportsPlugin`.
+						if (
+							["module", "commonjs-static", "modern-module"].includes(type) &&
+							!options.optimization.providedExports
+						) {
+							new FlagDependencyExportsPlugin().apply(compiler);
+						}
+					}
+				}).apply(compiler);
 			}
 		}
 
 		if (options.output.pathinfo) {
 			const ModuleInfoHeaderPlugin = require("./ModuleInfoHeaderPlugin");
+
 			new ModuleInfoHeaderPlugin(options.output.pathinfo !== true).apply(
 				compiler
 			);
@@ -251,11 +301,20 @@ class WebpackOptionsApply extends OptionsApply {
 
 		if (options.output.clean) {
 			const CleanPlugin = require("./CleanPlugin");
+
 			new CleanPlugin(
 				options.output.clean === true ? {} : options.output.clean
 			).apply(compiler);
 		}
 
+		if (options.dotenv) {
+			const DotenvPlugin = require("./DotenvPlugin");
+
+			new DotenvPlugin(
+				typeof options.dotenv === "boolean" ? {} : options.dotenv
+			).apply(compiler);
+		}
+
 		if (options.devtool) {
 			if (options.devtool.includes("source-map")) {
 				const hidden = options.devtool.includes("hidden");
@@ -282,6 +341,7 @@ class WebpackOptionsApply extends OptionsApply {
 				}).apply(compiler);
 			} else if (options.devtool.includes("eval")) {
 				const EvalDevToolModulePlugin = require("./EvalDevToolModulePlugin");
+
 				new EvalDevToolModulePlugin({
 					moduleFilenameTemplate: options.output.devtoolModuleFilenameTemplate,
 					namespace: options.output.devtoolNamespace
@@ -321,6 +381,7 @@ class WebpackOptionsApply extends OptionsApply {
 
 		if (options.experiments.syncWebAssembly) {
 			const WebAssemblyModulesPlugin = require("./wasm-sync/WebAssemblyModulesPlugin");
+
 			new WebAssemblyModulesPlugin({
 				mangleImports: options.optimization.mangleWasmImports
 			}).apply(compiler);
@@ -328,6 +389,7 @@ class WebpackOptionsApply extends OptionsApply {
 
 		if (options.experiments.asyncWebAssembly) {
 			const AsyncWebAssemblyModulesPlugin = require("./wasm-async/AsyncWebAssemblyModulesPlugin");
+
 			new AsyncWebAssemblyModulesPlugin({
 				mangleImports: options.optimization.mangleWasmImports
 			}).apply(compiler);
@@ -335,15 +397,50 @@ class WebpackOptionsApply extends OptionsApply {
 
 		if (options.experiments.css) {
 			const CssModulesPlugin = require("./css/CssModulesPlugin");
+
 			new CssModulesPlugin().apply(compiler);
 		}
 
 		if (options.experiments.lazyCompilation) {
 			const LazyCompilationPlugin = require("./hmr/LazyCompilationPlugin");
+
 			const lazyOptions =
 				typeof options.experiments.lazyCompilation === "object"
 					? options.experiments.lazyCompilation
 					: {};
+			const isUniversalTarget =
+				options.output.module &&
+				compiler.platform.node === null &&
+				compiler.platform.web === null;
+
+			if (isUniversalTarget) {
+				const emitter = require.resolve("../hot/emitter-event-target.js");
+
+				const NormalModuleReplacementPlugin = require("./NormalModuleReplacementPlugin");
+
+				// Override emitter that using `EventEmitter` to `EventTarget`
+				// TODO webpack6 - migrate to `EventTarget` by default
+				new NormalModuleReplacementPlugin(/emitter(\.js)?$/, (result) => {
+					if (
+						/webpack[/\\]hot|webpack-dev-server[/\\]client|webpack-hot-middleware[/\\]client/.test(
+							result.context
+						)
+					) {
+						result.request = emitter;
+					}
+
+					return result;
+				}).apply(compiler);
+			}
+
+			const backend = require.resolve(
+				isUniversalTarget
+					? "../hot/lazy-compilation-universal.js"
+					: `../hot/lazy-compilation-${
+							options.externalsPresets.node ? "node" : "web"
+						}.js`
+			);
+
 			new LazyCompilationPlugin({
 				backend:
 					typeof lazyOptions.backend === "function"
@@ -351,12 +448,7 @@ class WebpackOptionsApply extends OptionsApply {
 						: require("./hmr/lazyCompilationBackend")({
 								...lazyOptions.backend,
 								client:
-									(lazyOptions.backend && lazyOptions.backend.client) ||
-									require.resolve(
-										`../hot/lazy-compilation-${
-											options.externalsPresets.node ? "node" : "web"
-										}.js`
-									)
+									(lazyOptions.backend && lazyOptions.backend.client) || backend
 							}),
 				entries: !lazyOptions || lazyOptions.entries !== false,
 				imports: !lazyOptions || lazyOptions.imports !== false,
@@ -366,16 +458,20 @@ class WebpackOptionsApply extends OptionsApply {
 
 		if (options.experiments.buildHttp) {
 			const HttpUriPlugin = require("./schemes/HttpUriPlugin");
+
 			const httpOptions = options.experiments.buildHttp;
 			new HttpUriPlugin(httpOptions).apply(compiler);
 		}
 
+		if (options.experiments.deferImport) {
+			const JavascriptParser = require("./javascript/JavascriptParser");
+			const importPhases = require("acorn-import-phases");
+
+			JavascriptParser.extend(importPhases({ source: false }));
+		}
+
 		new EntryOptionPlugin().apply(compiler);
-		compiler.hooks.entryOption.call(
-			/** @type {string} */
-			(options.context),
-			options.entry
-		);
+		compiler.hooks.entryOption.call(options.context, options.entry);
 
 		new RuntimePlugin().apply(compiler);
 
@@ -386,23 +482,23 @@ class WebpackOptionsApply extends OptionsApply {
 
 		new CompatibilityPlugin().apply(compiler);
 		new HarmonyModulesPlugin({
-			topLevelAwait: options.experiments.topLevelAwait
+			deferImport: options.experiments.deferImport
 		}).apply(compiler);
 		if (options.amd !== false) {
 			const AMDPlugin = require("./dependencies/AMDPlugin");
 			const RequireJsStuffPlugin = require("./RequireJsStuffPlugin");
+
 			new AMDPlugin(options.amd || {}).apply(compiler);
 			new RequireJsStuffPlugin().apply(compiler);
 		}
 		new CommonJsPlugin().apply(compiler);
-		new LoaderPlugin({}).apply(compiler);
-		if (options.node !== false) {
-			const NodeStuffPlugin = require("./NodeStuffPlugin");
-			new NodeStuffPlugin(options.node).apply(compiler);
-		}
-		new APIPlugin({
-			module: options.output.module
+		new LoaderPlugin().apply(compiler);
+		new NodeStuffPlugin({
+			global: options.node ? options.node.global : false,
+			__dirname: options.node ? options.node.__dirname : false,
+			__filename: options.node ? options.node.__filename : false
 		}).apply(compiler);
+		new APIPlugin().apply(compiler);
 		new ExportsInfoApiPlugin().apply(compiler);
 		new WebpackIsIncludedPlugin().apply(compiler);
 		new ConstPlugin().apply(compiler);
@@ -430,74 +526,85 @@ class WebpackOptionsApply extends OptionsApply {
 
 		if (typeof options.mode !== "string") {
 			const WarnNoModeSetPlugin = require("./WarnNoModeSetPlugin");
+
 			new WarnNoModeSetPlugin().apply(compiler);
 		}
 
 		const EnsureChunkConditionsPlugin = require("./optimize/EnsureChunkConditionsPlugin");
+
 		new EnsureChunkConditionsPlugin().apply(compiler);
 		if (options.optimization.removeAvailableModules) {
 			const RemoveParentModulesPlugin = require("./optimize/RemoveParentModulesPlugin");
+
 			new RemoveParentModulesPlugin().apply(compiler);
 		}
 		if (options.optimization.removeEmptyChunks) {
 			const RemoveEmptyChunksPlugin = require("./optimize/RemoveEmptyChunksPlugin");
+
 			new RemoveEmptyChunksPlugin().apply(compiler);
 		}
 		if (options.optimization.mergeDuplicateChunks) {
 			const MergeDuplicateChunksPlugin = require("./optimize/MergeDuplicateChunksPlugin");
+
 			new MergeDuplicateChunksPlugin().apply(compiler);
 		}
 		if (options.optimization.flagIncludedChunks) {
 			const FlagIncludedChunksPlugin = require("./optimize/FlagIncludedChunksPlugin");
+
 			new FlagIncludedChunksPlugin().apply(compiler);
 		}
 		if (options.optimization.sideEffects) {
 			const SideEffectsFlagPlugin = require("./optimize/SideEffectsFlagPlugin");
+
 			new SideEffectsFlagPlugin(
 				options.optimization.sideEffects === true
 			).apply(compiler);
 		}
 		if (options.optimization.providedExports) {
-			const FlagDependencyExportsPlugin = require("./FlagDependencyExportsPlugin");
 			new FlagDependencyExportsPlugin().apply(compiler);
 		}
 		if (options.optimization.usedExports) {
 			const FlagDependencyUsagePlugin = require("./FlagDependencyUsagePlugin");
+
 			new FlagDependencyUsagePlugin(
 				options.optimization.usedExports === "global"
 			).apply(compiler);
 		}
 		if (options.optimization.innerGraph) {
 			const InnerGraphPlugin = require("./optimize/InnerGraphPlugin");
+
 			new InnerGraphPlugin().apply(compiler);
 		}
 		if (options.optimization.mangleExports) {
 			const MangleExportsPlugin = require("./optimize/MangleExportsPlugin");
+
 			new MangleExportsPlugin(
 				options.optimization.mangleExports !== "size"
 			).apply(compiler);
 		}
 		if (options.optimization.concatenateModules) {
 			const ModuleConcatenationPlugin = require("./optimize/ModuleConcatenationPlugin");
+
 			new ModuleConcatenationPlugin().apply(compiler);
 		}
 		if (options.optimization.splitChunks) {
 			const SplitChunksPlugin = require("./optimize/SplitChunksPlugin");
+
 			new SplitChunksPlugin(options.optimization.splitChunks).apply(compiler);
 		}
 		if (options.optimization.runtimeChunk) {
 			const RuntimeChunkPlugin = require("./optimize/RuntimeChunkPlugin");
-			new RuntimeChunkPlugin(
-				/** @type {{ name?: (entrypoint: { name: string }) => string }} */
-				(options.optimization.runtimeChunk)
-			).apply(compiler);
+
+			new RuntimeChunkPlugin(options.optimization.runtimeChunk).apply(compiler);
 		}
 		if (!options.optimization.emitOnErrors) {
 			const NoEmitOnErrorsPlugin = require("./NoEmitOnErrorsPlugin");
+
 			new NoEmitOnErrorsPlugin().apply(compiler);
 		}
 		if (options.optimization.realContentHash) {
 			const RealContentHashPlugin = require("./optimize/RealContentHashPlugin");
+
 			new RealContentHashPlugin({
 				hashFunction:
 					/** @type {NonNullable<WebpackOptions["output"]["hashFunction"]>} */
@@ -509,6 +616,7 @@ class WebpackOptionsApply extends OptionsApply {
 		}
 		if (options.optimization.checkWasmTypes) {
 			const WasmFinalizeExportsPlugin = require("./wasm-sync/WasmFinalizeExportsPlugin");
+
 			new WasmFinalizeExportsPlugin().apply(compiler);
 		}
 		const moduleIds = options.optimization.moduleIds;
@@ -516,17 +624,20 @@ class WebpackOptionsApply extends OptionsApply {
 			switch (moduleIds) {
 				case "natural": {
 					const NaturalModuleIdsPlugin = require("./ids/NaturalModuleIdsPlugin");
+
 					new NaturalModuleIdsPlugin().apply(compiler);
 					break;
 				}
 				case "named": {
 					const NamedModuleIdsPlugin = require("./ids/NamedModuleIdsPlugin");
+
 					new NamedModuleIdsPlugin().apply(compiler);
 					break;
 				}
 				case "hashed": {
 					const WarnDeprecatedOptionPlugin = require("./WarnDeprecatedOptionPlugin");
 					const HashedModuleIdsPlugin = require("./ids/HashedModuleIdsPlugin");
+
 					new WarnDeprecatedOptionPlugin(
 						"optimization.moduleIds",
 						"hashed",
@@ -539,11 +650,13 @@ class WebpackOptionsApply extends OptionsApply {
 				}
 				case "deterministic": {
 					const DeterministicModuleIdsPlugin = require("./ids/DeterministicModuleIdsPlugin");
+
 					new DeterministicModuleIdsPlugin().apply(compiler);
 					break;
 				}
 				case "size": {
 					const OccurrenceModuleIdsPlugin = require("./ids/OccurrenceModuleIdsPlugin");
+
 					new OccurrenceModuleIdsPlugin({
 						prioritiseInitial: true
 					}).apply(compiler);
@@ -560,22 +673,26 @@ class WebpackOptionsApply extends OptionsApply {
 			switch (chunkIds) {
 				case "natural": {
 					const NaturalChunkIdsPlugin = require("./ids/NaturalChunkIdsPlugin");
+
 					new NaturalChunkIdsPlugin().apply(compiler);
 					break;
 				}
 				case "named": {
 					const NamedChunkIdsPlugin = require("./ids/NamedChunkIdsPlugin");
+
 					new NamedChunkIdsPlugin().apply(compiler);
 					break;
 				}
 				case "deterministic": {
 					const DeterministicChunkIdsPlugin = require("./ids/DeterministicChunkIdsPlugin");
+
 					new DeterministicChunkIdsPlugin().apply(compiler);
 					break;
 				}
 				case "size": {
 					// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 					const OccurrenceChunkIdsPlugin = require("./ids/OccurrenceChunkIdsPlugin");
+
 					new OccurrenceChunkIdsPlugin({
 						prioritiseInitial: true
 					}).apply(compiler);
@@ -584,6 +701,7 @@ class WebpackOptionsApply extends OptionsApply {
 				case "total-size": {
 					// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 					const OccurrenceChunkIdsPlugin = require("./ids/OccurrenceChunkIdsPlugin");
+
 					new OccurrenceChunkIdsPlugin({
 						prioritiseInitial: false
 					}).apply(compiler);
@@ -597,14 +715,16 @@ class WebpackOptionsApply extends OptionsApply {
 		}
 		if (options.optimization.nodeEnv) {
 			const DefinePlugin = require("./DefinePlugin");
+
+			const defValue = JSON.stringify(options.optimization.nodeEnv);
+
 			new DefinePlugin({
-				"process.env.NODE_ENV": JSON.stringify(options.optimization.nodeEnv)
+				"process.env.NODE_ENV": defValue,
+				"import.meta.env.NODE_ENV": defValue
 			}).apply(compiler);
 		}
 		if (options.optimization.minimize) {
-			for (const minimizer of /** @type {(WebpackPluginInstance | WebpackPluginFunction | "...")[]} */ (
-				options.optimization.minimizer
-			)) {
+			for (const minimizer of options.optimization.minimizer) {
 				if (typeof minimizer === "function") {
 					/** @type {WebpackPluginFunction} */
 					(minimizer).call(compiler, compiler);
@@ -616,6 +736,7 @@ class WebpackOptionsApply extends OptionsApply {
 
 		if (options.performance) {
 			const SizeLimitsPlugin = require("./performance/SizeLimitsPlugin");
+
 			new SizeLimitsPlugin(options.performance).apply(compiler);
 		}
 
@@ -628,6 +749,7 @@ class WebpackOptionsApply extends OptionsApply {
 		new WarnCaseSensitiveModulesPlugin().apply(compiler);
 
 		const AddManagedPathsPlugin = require("./cache/AddManagedPathsPlugin");
+
 		new AddManagedPathsPlugin(
 			/** @type {NonNullable<WebpackOptions["snapshot"]["managedPaths"]>} */
 			(options.snapshot.managedPaths),
@@ -644,6 +766,7 @@ class WebpackOptionsApply extends OptionsApply {
 					if (Number.isFinite(cacheOptions.maxGenerations)) {
 						// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 						const MemoryWithGcCachePlugin = require("./cache/MemoryWithGcCachePlugin");
+
 						new MemoryWithGcCachePlugin({
 							maxGenerations:
 								/** @type {number} */
@@ -652,6 +775,7 @@ class WebpackOptionsApply extends OptionsApply {
 					} else {
 						// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 						const MemoryCachePlugin = require("./cache/MemoryCachePlugin");
+
 						new MemoryCachePlugin().apply(compiler);
 					}
 					if (cacheOptions.cacheUnaffected) {
@@ -666,7 +790,7 @@ class WebpackOptionsApply extends OptionsApply {
 				}
 				case "filesystem": {
 					const AddBuildDependenciesPlugin = require("./cache/AddBuildDependenciesPlugin");
-					// eslint-disable-next-line guard-for-in
+
 					for (const key in cacheOptions.buildDependencies) {
 						const list = cacheOptions.buildDependencies[key];
 						new AddBuildDependenciesPlugin(list).apply(compiler);
@@ -674,10 +798,12 @@ class WebpackOptionsApply extends OptionsApply {
 					if (!Number.isFinite(cacheOptions.maxMemoryGenerations)) {
 						// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 						const MemoryCachePlugin = require("./cache/MemoryCachePlugin");
+
 						new MemoryCachePlugin().apply(compiler);
 					} else if (cacheOptions.maxMemoryGenerations !== 0) {
 						// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 						const MemoryWithGcCachePlugin = require("./cache/MemoryWithGcCachePlugin");
+
 						new MemoryWithGcCachePlugin({
 							maxGenerations:
 								/** @type {number} */
@@ -696,13 +822,14 @@ class WebpackOptionsApply extends OptionsApply {
 						case "pack": {
 							const IdleFileCachePlugin = require("./cache/IdleFileCachePlugin");
 							const PackFileCacheStrategy = require("./cache/PackFileCacheStrategy");
+
 							new IdleFileCachePlugin(
 								new PackFileCacheStrategy({
 									compiler,
 									fs:
 										/** @type {IntermediateFileSystem} */
 										(compiler.intermediateFileSystem),
-									context: /** @type {string} */ (options.context),
+									context: options.context,
 									cacheLocation:
 										/** @type {string} */
 										(cacheOptions.cacheLocation),
@@ -740,6 +867,7 @@ class WebpackOptionsApply extends OptionsApply {
 
 		if (options.ignoreWarnings && options.ignoreWarnings.length > 0) {
 			const IgnoreWarningsPlugin = require("./IgnoreWarningsPlugin");
+
 			new IgnoreWarningsPlugin(options.ignoreWarnings).apply(compiler);
 		}
 
@@ -749,7 +877,7 @@ class WebpackOptionsApply extends OptionsApply {
 		}
 		compiler.resolverFactory.hooks.resolveOptions
 			.for("normal")
-			.tap("WebpackOptionsApply", resolveOptions => {
+			.tap(CLASS_NAME, (resolveOptions) => {
 				resolveOptions = cleverMerge(options.resolve, resolveOptions);
 				resolveOptions.fileSystem =
 					/** @type {InputFileSystem} */
@@ -758,7 +886,7 @@ class WebpackOptionsApply extends OptionsApply {
 			});
 		compiler.resolverFactory.hooks.resolveOptions
 			.for("context")
-			.tap("WebpackOptionsApply", resolveOptions => {
+			.tap(CLASS_NAME, (resolveOptions) => {
 				resolveOptions = cleverMerge(options.resolve, resolveOptions);
 				resolveOptions.fileSystem =
 					/** @type {InputFileSystem} */
@@ -768,7 +896,7 @@ class WebpackOptionsApply extends OptionsApply {
 			});
 		compiler.resolverFactory.hooks.resolveOptions
 			.for("loader")
-			.tap("WebpackOptionsApply", resolveOptions => {
+			.tap(CLASS_NAME, (resolveOptions) => {
 				resolveOptions = cleverMerge(options.resolveLoader, resolveOptions);
 				resolveOptions.fileSystem =
 					/** @type {InputFileSystem} */