webpack 5.102.1 → 5.103.0

package/lib/NormalModule.js

@@ -96,7 +96,6 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("../declarations/WebpackOptions").HashFunction} HashFunction */
 /** @typedef {import("./util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */
-/** @typedef {import("../declarations/WebpackOptions").RuleSetRule["extractSourceMap"]} ExtractSourceMapOptions */
 /**
  * @template T
  * @typedef {import("./util/deprecation").FakeHook<T>} FakeHook
@@ -255,7 +254,7 @@ makeSerializable(
  * @property {Generator} generator the generator used
  * @property {GeneratorOptions=} generatorOptions the options of the generator used
  * @property {ResolveOptions=} resolveOptions options used for resolving requests from this module
- * @property {boolean=} extractSourceMap enable/disable extracting source map
+ * @property {boolean} extractSourceMap enable/disable extracting source map
  */
 
 /**
@@ -353,34 +352,36 @@ class NormalModule extends Module {
 		super(type, context || getContext(resource), layer);
 
 		// Info from Factory
-		/** @type {string} */
+		/** @type {NormalModuleCreateData['request']} */
 		this.request = request;
-		/** @type {string} */
+		/** @type {NormalModuleCreateData['userRequest']} */
 		this.userRequest = userRequest;
-		/** @type {string} */
+		/** @type {NormalModuleCreateData['rawRequest']} */
 		this.rawRequest = rawRequest;
 		/** @type {boolean} */
 		this.binary = /^(asset|webassembly)\b/.test(type);
-		/** @type {undefined | Parser} */
+		/** @type {NormalModuleCreateData['parser'] | undefined} */
 		this.parser = parser;
-		/** @type {undefined | ParserOptions} */
+		/** @type {NormalModuleCreateData['parserOptions']} */
 		this.parserOptions = parserOptions;
-		/** @type {undefined | Generator} */
+		/** @type {NormalModuleCreateData['generator'] | undefined} */
 		this.generator = generator;
-		/** @type {undefined | GeneratorOptions} */
+		/** @type {NormalModuleCreateData['generatorOptions']} */
 		this.generatorOptions = generatorOptions;
-		/** @type {string} */
+		/** @type {NormalModuleCreateData['resource']} */
 		this.resource = resource;
+		/** @type {NormalModuleCreateData['resourceResolveData']} */
 		this.resourceResolveData = resourceResolveData;
-		/** @type {string | undefined} */
+		/** @type {NormalModuleCreateData['matchResource']} */
 		this.matchResource = matchResource;
-		/** @type {LoaderItem[]} */
+		/** @type {NormalModuleCreateData['loaders']} */
 		this.loaders = loaders;
 		if (resolveOptions !== undefined) {
 			// already declared in super class
+			/** @type {NormalModuleCreateData['resolveOptions']} */
 			this.resolveOptions = resolveOptions;
 		}
-		/** @type {ExtractSourceMapOptions} */
+		/** @type {NormalModuleCreateData['extractSourceMap']} */
 		this.extractSourceMap = extractSourceMap;
 
 		// Info from Build
@@ -487,6 +488,7 @@ class NormalModule extends Module {
 		this.context = m.context;
 		this.matchResource = m.matchResource;
 		this.loaders = m.loaders;
+		this.extractSourceMap = m.extractSourceMap;
 	}
 
 	/**
@@ -1721,7 +1723,6 @@ class NormalModule extends Module {
 		write(this._lastSuccessfulBuildMeta);
 		write(this._forceBuild);
 		write(this._codeGeneratorData);
-		write(this.extractSourceMap);
 		super.serialize(context);
 	}
 
@@ -1746,7 +1747,8 @@ class NormalModule extends Module {
 			parserOptions: /** @type {EXPECTED_ANY} */ (null),
 			generator: /** @type {EXPECTED_ANY} */ (null),
 			generatorOptions: /** @type {EXPECTED_ANY} */ (null),
-			resolveOptions: /** @type {EXPECTED_ANY} */ (null)
+			resolveOptions: /** @type {EXPECTED_ANY} */ (null),
+			extractSourceMap: /** @type {EXPECTED_ANY} */ (null)
 		});
 		obj.deserialize(context);
 		return obj;
@@ -1762,7 +1764,6 @@ class NormalModule extends Module {
 		this._lastSuccessfulBuildMeta = read();
 		this._forceBuild = read();
 		this._codeGeneratorData = read();
-		this.extractSourceMap = read();
 		super.deserialize(context);
 	}
 }

package/lib/RuntimeGlobals.js

@@ -78,11 +78,29 @@ module.exports.createScript = "__webpack_require__.ts";
  */
 module.exports.createScriptUrl = "__webpack_require__.tu";
 
+/**
+ * merge multiple CSS stylesheets (CSSStyleSheet or string) into one CSS text string
+ * Arguments: (sheets: Array<CSSStyleSheet | string> | CSSStyleSheet | string) => string
+ */
+module.exports.cssMergeStyleSheets = "__webpack_require__.mcs";
+
 /**
  * The current scope when getting a module from a remote
  */
 module.exports.currentRemoteGetScope = "__webpack_require__.R";
 
+/**
+ * resolve async transitive dependencies for deferred module
+ */
+module.exports.deferredModuleAsyncTransitiveDependencies =
+	"__webpack_require__.zT";
+
+/**
+ * the internal symbol for getting the async transitive dependencies for deferred module
+ */
+module.exports.deferredModuleAsyncTransitiveDependenciesSymbol =
+	"__webpack_require__.zS";
+
 /**
  * the exported property define getters function
  */
@@ -258,14 +276,14 @@ module.exports.loadScript = "__webpack_require__.l";
 module.exports.makeDeferredNamespaceObject = "__webpack_require__.z";
 
 /**
- * the internal symbol that makeDeferredNamespaceObject is using.
+ * define compatibility on export
  */
-module.exports.makeDeferredNamespaceObjectSymbol = "__webpack_require__.zS";
+module.exports.makeNamespaceObject = "__webpack_require__.r";
 
 /**
- * define compatibility on export
+ * make a optimized deferred namespace object
  */
-module.exports.makeNamespaceObject = "__webpack_require__.r";
+module.exports.makeOptimizedDeferredNamespaceObject = "__webpack_require__.zO";
 
 /**
  * the internal module object

package/lib/RuntimePlugin.js

@@ -24,7 +24,10 @@ const GetTrustedTypesPolicyRuntimeModule = require("./runtime/GetTrustedTypesPol
 const GlobalRuntimeModule = require("./runtime/GlobalRuntimeModule");
 const HasOwnPropertyRuntimeModule = require("./runtime/HasOwnPropertyRuntimeModule");
 const LoadScriptRuntimeModule = require("./runtime/LoadScriptRuntimeModule");
-const MakeDeferredNamespaceObjectRuntime = require("./runtime/MakeDeferredNamespaceObjectRuntime");
+const {
+	MakeDeferredNamespaceObjectRuntimeModule,
+	MakeOptimizedDeferredNamespaceObjectRuntimeModule
+} = require("./runtime/MakeDeferredNamespaceObjectRuntime");
 const MakeNamespaceObjectRuntimeModule = require("./runtime/MakeNamespaceObjectRuntimeModule");
 const NonceRuntimeModule = require("./runtime/NonceRuntimeModule");
 const OnChunksLoadedRuntimeModule = require("./runtime/OnChunksLoadedRuntimeModule");
@@ -78,6 +81,7 @@ const GLOBALS_ON_REQUIRE = [
 	RuntimeGlobals.loadScript,
 	RuntimeGlobals.systemContext,
 	RuntimeGlobals.onChunksLoaded,
+	RuntimeGlobals.makeOptimizedDeferredNamespaceObject,
 	RuntimeGlobals.makeDeferredNamespaceObject
 ];
 
@@ -96,11 +100,11 @@ const TREE_DEPENDENCIES = {
 		RuntimeGlobals.makeNamespaceObject,
 		RuntimeGlobals.require
 	],
+	[RuntimeGlobals.makeOptimizedDeferredNamespaceObject]: [
+		RuntimeGlobals.require
+	],
 	[RuntimeGlobals.makeDeferredNamespaceObject]: [
-		RuntimeGlobals.definePropertyGetters,
-		RuntimeGlobals.makeNamespaceObject,
 		RuntimeGlobals.createFakeNamespaceObject,
-		RuntimeGlobals.hasOwnProperty,
 		RuntimeGlobals.require
 	],
 	[RuntimeGlobals.initializeSharing]: [RuntimeGlobals.shareScopeMap],
@@ -190,12 +194,23 @@ class RuntimePlugin {
 					);
 					return true;
 				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.makeOptimizedDeferredNamespaceObject)
+				.tap("RuntimePlugin", (chunk, runtimeRequirement) => {
+					compilation.addRuntimeModule(
+						chunk,
+						new MakeOptimizedDeferredNamespaceObjectRuntimeModule(
+							runtimeRequirement.has(RuntimeGlobals.asyncModule)
+						)
+					);
+					return true;
+				});
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.makeDeferredNamespaceObject)
 				.tap("RuntimePlugin", (chunk, runtimeRequirement) => {
 					compilation.addRuntimeModule(
 						chunk,
-						new MakeDeferredNamespaceObjectRuntime(
+						new MakeDeferredNamespaceObjectRuntimeModule(
 							runtimeRequirement.has(RuntimeGlobals.asyncModule)
 						)
 					);
@@ -238,7 +253,13 @@ class RuntimePlugin {
 
 					if (publicPath === "auto") {
 						const module = new AutoPublicPathRuntimeModule();
-						if (scriptType !== "module") set.add(RuntimeGlobals.global);
+						if (
+							scriptType !== "module" &&
+							!outputOptions.environment.globalThis
+						) {
+							set.add(RuntimeGlobals.global);
+						}
+
 						compilation.addRuntimeModule(chunk, module);
 					} else {
 						const module = new PublicPathRuntimeModule(publicPath);

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
@@ -617,6 +628,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 +640,7 @@ class RuntimeTemplate {
 		message,
 		strict,
 		weak,
+		dependency,
 		runtimeRequirements
 	}) {
 		if (!module) {
@@ -684,42 +697,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 +752,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 +855,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 +867,7 @@ class RuntimeTemplate {
 		importVar,
 		originModule,
 		weak,
-		defer,
+		dependency,
 		runtimeRequirements
 	}) {
 		if (!module) {
@@ -866,15 +915,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, ""];
@@ -908,7 +964,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 +982,7 @@ class RuntimeTemplate {
 		initFragments,
 		runtime,
 		runtimeRequirements,
-		defer
+		dependency
 	}) {
 		if (!module) {
 			return this.missingModule({
@@ -942,13 +998,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 +1061,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 +1104,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 +1115,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;
 									}

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 шt 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");
@@ -444,11 +465,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 +688,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) {

package/lib/asset/AssetBytesGenerator.js

@@ -66,7 +66,7 @@ class AssetSourceGenerator extends Generator {
 					} = ${RuntimeGlobals.toBinary}(${JSON.stringify(encodedSource)});`;
 				} else {
 					runtimeRequirements.add(RuntimeGlobals.module);
-					sourceContent = `${RuntimeGlobals.module}.exports = ${RuntimeGlobals.toBinary}(${JSON.stringify(
+					sourceContent = `${module.moduleArgument}.exports = ${RuntimeGlobals.toBinary}(${JSON.stringify(
 						encodedSource
 					)});`;
 				}

package/lib/asset/AssetGenerator.js

@@ -380,7 +380,6 @@ class AssetGenerator extends Generator {
 		}
 
 		return {
-			// eslint-disable-next-line object-shorthand
 			assetPath: /** @type {string} */ (assetPath),
 			assetInfo: { sourceFilename, ...assetInfo }
 		};
@@ -614,7 +613,7 @@ class AssetGenerator extends Generator {
 
 			runtimeRequirements.add(RuntimeGlobals.module);
 
-			return new RawSource(`${RuntimeGlobals.module}.exports = ${content};`);
+			return new RawSource(`${module.moduleArgument}.exports = ${content};`);
 		} else if (type === "css-url") {
 			return null;
 		}