webpack 5.102.1 → 5.104.0

package/lib/RuntimeTemplate.js

@@ -11,15 +11,24 @@ const Template = require("./Template");
 const {
 	getOutgoingAsyncModules
 } = require("./async-modules/AsyncModuleHelpers");
+const { ImportPhaseUtils } = require("./dependencies/ImportPhase");
 const {
 	getMakeDeferredNamespaceModeFromExportsType,
 	getOptimizedDeferredModule
 } = require("./runtime/MakeDeferredNamespaceObjectRuntime");
 const { equals } = require("./util/ArrayHelpers");
 const compileBooleanMatcher = require("./util/compileBooleanMatcher");
+const memoize = require("./util/memoize");
 const propertyAccess = require("./util/propertyAccess");
 const { forEachRuntime, subtractRuntime } = require("./util/runtime");
 
+const getHarmonyImportDependency = memoize(() =>
+	require("./dependencies/HarmonyImportDependency")
+);
+const getImportDependency = memoize(() =>
+	require("./dependencies/ImportDependency")
+);
+
 /** @typedef {import("./config/defaults").OutputNormalizedWithDefaults} OutputOptions */
 /** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
 /** @typedef {import("./Chunk")} Chunk */
@@ -32,6 +41,8 @@ const { forEachRuntime, subtractRuntime } = require("./util/runtime");
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./dependencies/ImportPhase").ImportPhaseType} ImportPhaseType */
+/** @typedef {import("./NormalModuleFactory").ModuleDependency} ModuleDependency */
 
 /**
  * @param {Module} module the module
@@ -116,6 +127,10 @@ class RuntimeTemplate {
 		return this.outputOptions.environment.const;
 	}
 
+	supportsMethodShorthand() {
+		return this.outputOptions.environment.methodShorthand;
+	}
+
 	supportsArrowFunction() {
 		return this.outputOptions.environment.arrowFunction;
 	}
@@ -617,6 +632,7 @@ class RuntimeTemplate {
 	 * @param {string} options.message a message for the comment
 	 * @param {boolean=} options.strict if the current module is in strict esm mode
 	 * @param {boolean=} options.weak if the dependency is weak (will create a nice error message)
+	 * @param {Dependency} options.dependency dependency
 	 * @param {RuntimeRequirements} options.runtimeRequirements if set, will be filled with runtime requirements
 	 * @returns {string} the promise expression
 	 */
@@ -628,6 +644,7 @@ class RuntimeTemplate {
 		message,
 		strict,
 		weak,
+		dependency,
 		runtimeRequirements
 	}) {
 		if (!module) {
@@ -684,42 +701,45 @@ class RuntimeTemplate {
 				type: "statements"
 			})} } `;
 		}
-		const moduleIdExpr = this.moduleId({
-			module,
-			chunkGraph,
-			request,
-			weak
-		});
 		const exportsType = module.getExportsType(chunkGraph.moduleGraph, strict);
-		let fakeType = 16;
-		switch (exportsType) {
-			case "namespace":
+
+		const isModuleDeferred =
+			(dependency instanceof getHarmonyImportDependency() ||
+				dependency instanceof getImportDependency()) &&
+			ImportPhaseUtils.isDefer(dependency.phase) &&
+			!(/** @type {BuildMeta} */ (module.buildMeta).async);
+
+		if (isModuleDeferred) {
+			runtimeRequirements.add(RuntimeGlobals.makeDeferredNamespaceObject);
+			const mode = getMakeDeferredNamespaceModeFromExportsType(exportsType);
+			const asyncDeps = Array.from(
+				getOutgoingAsyncModules(chunkGraph.moduleGraph, module),
+				(m) => chunkGraph.getModuleId(m)
+			).filter((id) => id !== null);
+			if (asyncDeps.length) {
 				if (header) {
-					const rawModule = this.moduleRaw({
-						module,
-						chunkGraph,
-						request,
-						weak,
-						runtimeRequirements
-					});
 					appending = `.then(${this.basicFunction(
 						"",
-						`${header}return ${rawModule};`
+						`${header}return ${RuntimeGlobals.deferredModuleAsyncTransitiveDependencies}(${JSON.stringify(asyncDeps)});`
 					)})`;
 				} else {
 					runtimeRequirements.add(RuntimeGlobals.require);
-					appending = `.then(${RuntimeGlobals.require}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}))`;
+					appending = `.then(${this.returningFunction(`${RuntimeGlobals.deferredModuleAsyncTransitiveDependencies}(${JSON.stringify(asyncDeps)})`)})`;
 				}
-				break;
-			case "dynamic":
-				fakeType |= 4;
-			/* fall through */
-			case "default-with-named":
-				fakeType |= 2;
-			/* fall through */
-			case "default-only":
-				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
-				if (chunkGraph.moduleGraph.isAsync(module)) {
+				appending += `.then(${RuntimeGlobals.makeDeferredNamespaceObject}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}, ${mode}))`;
+			} else if (header) {
+				appending = `.then(${this.basicFunction(
+					"",
+					`${header}return ${RuntimeGlobals.makeDeferredNamespaceObject}(${comment}${idExpr}, ${mode});`
+				)})`;
+			} else {
+				runtimeRequirements.add(RuntimeGlobals.require);
+				appending = `.then(${RuntimeGlobals.makeDeferredNamespaceObject}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}, ${mode}))`;
+			}
+		} else {
+			let fakeType = 16;
+			switch (exportsType) {
+				case "namespace":
 					if (header) {
 						const rawModule = this.moduleRaw({
 							module,
@@ -736,23 +756,56 @@ class RuntimeTemplate {
 						runtimeRequirements.add(RuntimeGlobals.require);
 						appending = `.then(${RuntimeGlobals.require}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}))`;
 					}
-					appending += `.then(${this.returningFunction(
-						`${RuntimeGlobals.createFakeNamespaceObject}(m, ${fakeType})`,
-						"m"
-					)})`;
-				} else {
-					fakeType |= 1;
-					if (header) {
-						const returnExpression = `${RuntimeGlobals.createFakeNamespaceObject}(${moduleIdExpr}, ${fakeType})`;
-						appending = `.then(${this.basicFunction(
-							"",
-							`${header}return ${returnExpression};`
+					break;
+				case "dynamic":
+					fakeType |= 4;
+				/* fall through */
+				case "default-with-named":
+					fakeType |= 2;
+				/* fall through */
+				case "default-only":
+					runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
+					if (chunkGraph.moduleGraph.isAsync(module)) {
+						if (header) {
+							const rawModule = this.moduleRaw({
+								module,
+								chunkGraph,
+								request,
+								weak,
+								runtimeRequirements
+							});
+							appending = `.then(${this.basicFunction(
+								"",
+								`${header}return ${rawModule};`
+							)})`;
+						} else {
+							runtimeRequirements.add(RuntimeGlobals.require);
+							appending = `.then(${RuntimeGlobals.require}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}))`;
+						}
+						appending += `.then(${this.returningFunction(
+							`${RuntimeGlobals.createFakeNamespaceObject}(m, ${fakeType})`,
+							"m"
 						)})`;
 					} else {
-						appending = `.then(${RuntimeGlobals.createFakeNamespaceObject}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}, ${fakeType}))`;
+						fakeType |= 1;
+						if (header) {
+							const moduleIdExpr = this.moduleId({
+								module,
+								chunkGraph,
+								request,
+								weak
+							});
+							const returnExpression = `${RuntimeGlobals.createFakeNamespaceObject}(${moduleIdExpr}, ${fakeType})`;
+							appending = `.then(${this.basicFunction(
+								"",
+								`${header}return ${returnExpression};`
+							)})`;
+						} else {
+							appending = `.then(${RuntimeGlobals.createFakeNamespaceObject}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}, ${fakeType}))`;
+						}
 					}
-				}
-				break;
+					break;
+			}
 		}
 
 		return `${promise || "Promise.resolve()"}${appending}`;
@@ -806,7 +859,7 @@ class RuntimeTemplate {
 	 * @param {Module} options.originModule module in which the statement is emitted
 	 * @param {boolean=} options.weak true, if this is a weak dependency
 	 * @param {RuntimeRequirements} options.runtimeRequirements if set, will be filled with runtime requirements
-	 * @param {boolean=} options.defer if set, the module will be deferred
+	 * @param {ModuleDependency} options.dependency module dependency
 	 * @returns {[string, string]} the import statement and the compat statement
 	 */
 	importStatement({
@@ -818,7 +871,7 @@ class RuntimeTemplate {
 		importVar,
 		originModule,
 		weak,
-		defer,
+		dependency,
 		runtimeRequirements
 	}) {
 		if (!module) {
@@ -866,15 +919,22 @@ class RuntimeTemplate {
 		);
 		runtimeRequirements.add(RuntimeGlobals.require);
 		let importContent;
-		if (defer && !(/** @type {BuildMeta} */ (module.buildMeta).async)) {
+
+		const isModuleDeferred =
+			(dependency instanceof getHarmonyImportDependency() ||
+				dependency instanceof getImportDependency()) &&
+			ImportPhaseUtils.isDefer(dependency.phase) &&
+			!(/** @type {BuildMeta} */ (module.buildMeta).async);
+
+		if (isModuleDeferred) {
 			/** @type {Set<Module>} */
 			const outgoingAsyncModules = getOutgoingAsyncModules(moduleGraph, module);
 
 			importContent = `/* deferred harmony import */ ${optDeclaration}${importVar} = ${getOptimizedDeferredModule(
-				this,
-				exportsType,
 				moduleId,
-				Array.from(outgoingAsyncModules, (mod) => chunkGraph.getModuleId(mod))
+				exportsType,
+				Array.from(outgoingAsyncModules, (mod) => chunkGraph.getModuleId(mod)),
+				runtimeRequirements
 			)};\n`;
 
 			return [importContent, ""];
@@ -900,7 +960,7 @@ class RuntimeTemplate {
 	 * @param {string} options.request the request
 	 * @param {string | string[]} options.exportName the export name
 	 * @param {Module} options.originModule the origin module
-	 * @param {boolean|undefined} options.asiSafe true, if location is safe for ASI, a bracket can be emitted
+	 * @param {boolean | undefined} options.asiSafe true, if location is safe for ASI, a bracket can be emitted
 	 * @param {boolean} options.isCall true, if expression will be called
 	 * @param {boolean | null} options.callContext when false, call context will not be preserved
 	 * @param {boolean} options.defaultInterop when true and accessing the default exports, interop code will be generated
@@ -908,7 +968,7 @@ class RuntimeTemplate {
 	 * @param {InitFragment<GenerateContext>[]} options.initFragments init fragments will be added here
 	 * @param {RuntimeSpec} options.runtime runtime for which this code will be generated
 	 * @param {RuntimeRequirements} options.runtimeRequirements if set, will be filled with runtime requirements
-	 * @param {boolean=} options.defer if true, the module will be deferred.
+	 * @param {ModuleDependency} options.dependency module dependency
 	 * @returns {string} expression
 	 */
 	exportFromImport({
@@ -926,7 +986,7 @@ class RuntimeTemplate {
 		initFragments,
 		runtime,
 		runtimeRequirements,
-		defer
+		dependency
 	}) {
 		if (!module) {
 			return this.missingModule({
@@ -942,13 +1002,16 @@ class RuntimeTemplate {
 			(originModule.buildMeta).strictHarmonyModule
 		);
 
-		const isDeferred =
-			defer && !(/** @type {BuildMeta} */ (module.buildMeta).async);
+		const isModuleDeferred =
+			(dependency instanceof getHarmonyImportDependency() ||
+				dependency instanceof getImportDependency()) &&
+			ImportPhaseUtils.isDefer(dependency.phase) &&
+			!(/** @type {BuildMeta} */ (module.buildMeta).async);
 
 		if (defaultInterop) {
 			// when the defaultInterop is used (when a ESM imports a CJS module),
 			if (exportName.length > 0 && exportName[0] === "default") {
-				if (isDeferred && exportsType !== "namespace") {
+				if (isModuleDeferred && exportsType !== "namespace") {
 					const exportsInfo = moduleGraph.getExportsInfo(module);
 					const name = exportName.slice(1);
 					const used = exportsInfo.getUsedName(name, runtime);
@@ -1002,7 +1065,7 @@ class RuntimeTemplate {
 				) {
 					return "/* __esModule */true";
 				}
-			} else if (isDeferred) {
+			} else if (isModuleDeferred) {
 				// now exportName.length is 0
 				// fall through to the end of this function, create the namespace there.
 			} else if (
@@ -1045,7 +1108,7 @@ class RuntimeTemplate {
 				? ""
 				: `${Template.toNormalComment(propertyAccess(exportName))} `;
 			const access = `${importVar}${
-				isDeferred ? ".a" : ""
+				isModuleDeferred ? ".a" : ""
 			}${comment}${propertyAccess(used)}`;
 			if (isCall && callContext === false) {
 				return asiSafe
@@ -1056,7 +1119,7 @@ class RuntimeTemplate {
 			}
 			return access;
 		}
-		if (isDeferred) {
+		if (isModuleDeferred) {
 			initFragments.push(
 				new InitFragment(
 					`var ${importVar}_deferred_namespace_cache;\n`,

package/lib/SourceMapDevToolPlugin.js

@@ -20,6 +20,7 @@ const { makePathsAbsolute } = require("./util/identifier");
 /** @typedef {import("webpack-sources").MapOptions} MapOptions */
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../declarations/plugins/SourceMapDevToolPlugin").SourceMapDevToolPluginOptions} SourceMapDevToolPluginOptions */
+/** @typedef {import("../declarations/plugins/SourceMapDevToolPlugin").Rules} Rules */
 /** @typedef {import("./CacheFacade").ItemCacheFacade} ItemCacheFacade */
 /** @typedef {import("./Chunk")} Chunk */
 /** @typedef {import("./Compilation").Asset} Asset */
@@ -433,6 +434,25 @@ class SourceMapDevToolPlugin {
 										moduleToSourceNameMapping.get(m)
 									);
 									sourceMap.sources = /** @type {string[]} */ (moduleFilenames);
+									sourceMap.ignoreList = options.ignoreList
+										? sourceMap.sources.reduce(
+												/** @type {(acc: number[], sourceName: string, idx: number) => number[]} */ (
+													(acc, sourceName, idx) => {
+														const rule = /** @type {Rules} */ (
+															options.ignoreList
+														);
+														if (
+															ModuleFilenameHelpers.matchPart(sourceName, rule)
+														) {
+															acc.push(idx);
+														}
+														return acc;
+													}
+												),
+												[]
+											)
+										: [];
+
 									if (options.noSources) {
 										sourceMap.sourcesContent = undefined;
 									}
@@ -476,7 +496,12 @@ class SourceMapDevToolPlugin {
 									if (options.debugIds) {
 										const debugId = generateDebugId(source, sourceMap.file);
 										sourceMap.debugId = debugId;
-										currentSourceMappingURLComment = `\n//# debugId=${debugId}${currentSourceMappingURLComment}`;
+
+										const debugIdComment = `\n//# debugId=${debugId}`;
+										currentSourceMappingURLComment =
+											currentSourceMappingURLComment
+												? `${debugIdComment}${currentSourceMappingURLComment}`
+												: debugIdComment;
 									}
 
 									const sourceMapString = JSON.stringify(sourceMap);

package/lib/Template.js

@@ -280,7 +280,7 @@ class Template {
 	/**
 	 * @param {ChunkRenderContext} renderContext render context
 	 * @param {Module[]} modules modules to render (should be ordered by identifier)
-	 * @param {(module: Module) => Source | null} renderModule function to render a module
+	 * @param {(module: Module, renderInArray?: boolean) => Source | null} renderModule function to render a module
 	 * @param {string=} prefix applying prefix strings
 	 * @returns {Source | null} rendered chunk modules in a Source object or null if no modules
 	 */
@@ -290,12 +290,20 @@ class Template {
 		if (modules.length === 0) {
 			return null;
 		}
+		/** @type {{ id: ModuleId, module: Module }[]} */
+		const modulesWithId = modules.map((m) => ({
+			id: /** @type {ModuleId} */ (chunkGraph.getModuleId(m)),
+			module: m
+		}));
+		const bounds = Template.getModulesArrayBounds(modulesWithId);
+		const renderInObject = bounds === false;
+
 		/** @type {{ id: ModuleId, source: Source | "false" }[]} */
-		const allModules = modules.map((module) => ({
-			id: /** @type {ModuleId} */ (chunkGraph.getModuleId(module)),
-			source: renderModule(module) || "false"
+		const allModules = modulesWithId.map(({ id, module }) => ({
+			id,
+			source: renderModule(module, renderInObject) || "false"
 		}));
-		const bounds = Template.getModulesArrayBounds(allModules);
+
 		if (bounds) {
 			// Render a spare array
 			const minId = bounds[0];
@@ -332,7 +340,9 @@ class Template {
 				if (i !== 0) {
 					source.add(",\n");
 				}
-				source.add(`\n/***/ ${JSON.stringify(module.id)}:\n`);
+				source.add(
+					`\n/***/ ${JSON.stringify(module.id)}${renderContext.runtimeTemplate.supportsMethodShorthand() && module.source !== "false" ? "" : ":"}\n`
+				);
 				source.add(module.source);
 			}
 			source.add(`\n\n${prefix}}`);
@@ -363,6 +373,7 @@ class Template {
 					moduleGraph: renderContext.moduleGraph,
 					runtimeTemplate: renderContext.runtimeTemplate,
 					runtime: renderContext.chunk.runtime,
+					runtimes: [renderContext.chunk.runtime],
 					codeGenerationResults
 				});
 				if (!codeGenResult) continue;

package/lib/TemplatedPathPlugin.js

@@ -20,10 +20,7 @@ const { parseResource } = require("./util/identifier");
 
 const REGEXP = /\[\\*([\w:]+)\\*\]/gi;
 
-/**
- * @param {string | number} id id
- * @returns {string | number} result
- */
+/** @type {PathData["prepareId"]} */
 const prepareId = (id) => {
 	if (typeof id !== "string") return id;
 
@@ -303,7 +300,7 @@ const replacePathVariables = (path, data, assetInfo) => {
 		const module = data.module;
 
 		const idReplacer = replacer(() =>
-			prepareId(
+			(data.prepareId || prepareId)(
 				module instanceof Module
 					? /** @type {ModuleId} */
 						(/** @type {ChunkGraph} */ (chunkGraph).getModuleId(module))
@@ -353,7 +350,9 @@ const replacePathVariables = (path, data, assetInfo) => {
 	if (typeof data.runtime === "string") {
 		replacements.set(
 			"runtime",
-			replacer(() => prepareId(/** @type {string} */ (data.runtime)))
+			replacer(() =>
+				(data.prepareId || prepareId)(/** @type {string} */ (data.runtime))
+			)
 		);
 	} else {
 		replacements.set("runtime", replacer("_"));

package/lib/WebpackError.js

@@ -21,7 +21,6 @@ class WebpackError extends Error {
 	 * @param {{ cause?: unknown }} options error options
 	 */
 	constructor(message, options = {}) {
-		// @ts-expect-error ES2018 doesn't `Error.cause`, but it can be used by developers
 		super(message, options);
 
 		/** @type {string=} */

package/lib/WebpackOptionsApply.js

@@ -18,6 +18,7 @@ const FlagDependencyExportsPlugin = require("./FlagDependencyExportsPlugin");
 
 const JavascriptMetaInfoPlugin = require("./JavascriptMetaInfoPlugin");
 
+const NodeStuffPlugin = require("./NodeStuffPlugin");
 const OptionsApply = require("./OptionsApply");
 
 const RecordIdsPlugin = require("./RecordIdsPlugin");
@@ -109,7 +110,15 @@ class WebpackOptionsApply extends OptionsApply {
 		if (options.externalsPresets.node) {
 			const NodeTargetPlugin = require("./node/NodeTargetPlugin");
 
-			new NodeTargetPlugin().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) {
@@ -126,7 +135,9 @@ class WebpackOptionsApply extends OptionsApply {
 							if (dependencyType === "url") {
 								return callback(null, `asset ${request}`);
 							} else if (
-								dependencyType === "css-import" &&
+								(dependencyType === "css-import" ||
+									dependencyType === "css-import-local-module" ||
+									dependencyType === "css-import-global-module") &&
 								options.experiments.css
 							) {
 								return callback(null, `css-import ${request}`);
@@ -149,7 +160,9 @@ class WebpackOptionsApply extends OptionsApply {
 					if (dependencyType === "url") {
 						return callback(null, `asset ${request}`);
 					} else if (
-						dependencyType === "css-import" &&
+						(dependencyType === "css-import" ||
+							dependencyType === "css-import-local-module" ||
+							dependencyType === "css-import-global-module") &&
 						options.experiments.css
 					) {
 						return callback(null, `css-import ${request}`);
@@ -294,6 +307,14 @@ class WebpackOptionsApply extends OptionsApply {
 			).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");
@@ -387,6 +408,39 @@ class WebpackOptionsApply extends OptionsApply {
 				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"
@@ -394,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,
@@ -444,11 +493,11 @@ class WebpackOptionsApply extends OptionsApply {
 		}
 		new CommonJsPlugin().apply(compiler);
 		new LoaderPlugin().apply(compiler);
-		if (options.node !== false) {
-			const NodeStuffPlugin = require("./NodeStuffPlugin");
-
-			new NodeStuffPlugin(options.node).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);
@@ -667,8 +716,11 @@ 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) {