webpack 5.97.1 → 5.104.1

package/lib/config/defaults.js

@@ -8,36 +8,40 @@
 const fs = require("fs");
 const path = require("path");
 const {
-	JAVASCRIPT_MODULE_TYPE_AUTO,
-	JAVASCRIPT_MODULE_TYPE_ESM,
-	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
-	JSON_MODULE_TYPE,
-	WEBASSEMBLY_MODULE_TYPE_ASYNC,
-	WEBASSEMBLY_MODULE_TYPE_SYNC,
+	CSS_TYPE,
+	JAVASCRIPT_TYPE,
+	UNKNOWN_TYPE
+} = require("../ModuleSourceTypeConstants");
+const {
 	ASSET_MODULE_TYPE,
+	ASSET_MODULE_TYPE_BYTES,
 	ASSET_MODULE_TYPE_INLINE,
 	ASSET_MODULE_TYPE_RESOURCE,
-	CSS_MODULE_TYPE_AUTO,
+	ASSET_MODULE_TYPE_SOURCE,
 	CSS_MODULE_TYPE,
+	CSS_MODULE_TYPE_AUTO,
+	CSS_MODULE_TYPE_GLOBAL,
 	CSS_MODULE_TYPE_MODULE,
-	CSS_MODULE_TYPE_GLOBAL
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+	JAVASCRIPT_MODULE_TYPE_ESM,
+	JSON_MODULE_TYPE,
+	WEBASSEMBLY_MODULE_TYPE_ASYNC,
+	WEBASSEMBLY_MODULE_TYPE_SYNC
 } = require("../ModuleTypeConstants");
 const Template = require("../Template");
 const { cleverMerge } = require("../util/cleverMerge");
 const {
-	getTargetsProperties,
+	getDefaultTarget,
 	getTargetProperties,
-	getDefaultTarget
+	getTargetsProperties
 } = require("./target");
 
-/** @typedef {import("../../declarations/WebpackOptions").CacheOptions} CacheOptions */
 /** @typedef {import("../../declarations/WebpackOptions").CacheOptionsNormalized} CacheOptionsNormalized */
 /** @typedef {import("../../declarations/WebpackOptions").Context} Context */
 /** @typedef {import("../../declarations/WebpackOptions").CssGeneratorOptions} CssGeneratorOptions */
-/** @typedef {import("../../declarations/WebpackOptions").CssParserOptions} CssParserOptions */
 /** @typedef {import("../../declarations/WebpackOptions").EntryDescription} EntryDescription */
 /** @typedef {import("../../declarations/WebpackOptions").EntryNormalized} Entry */
-/** @typedef {import("../../declarations/WebpackOptions").EntryStaticNormalized} EntryStaticNormalized */
 /** @typedef {import("../../declarations/WebpackOptions").Environment} Environment */
 /** @typedef {import("../../declarations/WebpackOptions").Experiments} Experiments */
 /** @typedef {import("../../declarations/WebpackOptions").ExperimentsNormalized} ExperimentsNormalized */
@@ -47,15 +51,18 @@ const {
 /** @typedef {import("../../declarations/WebpackOptions").GeneratorOptionsByModuleTypeKnown} GeneratorOptionsByModuleTypeKnown */
 /** @typedef {import("../../declarations/WebpackOptions").InfrastructureLogging} InfrastructureLogging */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../../declarations/WebpackOptions").JsonGeneratorOptions} JsonGeneratorOptions */
 /** @typedef {import("../../declarations/WebpackOptions").Library} Library */
 /** @typedef {import("../../declarations/WebpackOptions").LibraryName} LibraryName */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
 /** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
 /** @typedef {import("../../declarations/WebpackOptions").Loader} Loader */
 /** @typedef {import("../../declarations/WebpackOptions").Mode} Mode */
+/** @typedef {import("../../declarations/WebpackOptions").HashSalt} HashSalt */
+/** @typedef {import("../../declarations/WebpackOptions").HashSalt} HashDigest */
+/** @typedef {import("../../declarations/WebpackOptions").HashDigestLength} HashDigestLength */
 /** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
 /** @typedef {import("../../declarations/WebpackOptions").Node} WebpackNode */
-/** @typedef {import("../../declarations/WebpackOptions").Optimization} Optimization */
+/** @typedef {import("../../declarations/WebpackOptions").OptimizationNormalized} Optimization */
 /** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksOptions} OptimizationSplitChunksOptions */
 /** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} Output */
 /** @typedef {import("../../declarations/WebpackOptions").ParserOptionsByModuleTypeKnown} ParserOptionsByModuleTypeKnown */
@@ -63,14 +70,150 @@ const {
 /** @typedef {import("../../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetRules} RuleSetRules */
 /** @typedef {import("../../declarations/WebpackOptions").SnapshotOptions} SnapshotOptions */
-/** @typedef {import("../../declarations/WebpackOptions").Target} Target */
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptions} WebpackOptions */
 /** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptionsNormalized */
-/** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("./target").PlatformTargetProperties} PlatformTargetProperties */
 /** @typedef {import("./target").TargetProperties} TargetProperties */
 
+/**
+ * @template T
+ * @typedef {{ [P in keyof T]-?: T[P] extends object ? RecursiveNonNullable<NonNullable<T[P]>> : NonNullable<T[P]> }} RecursiveNonNullable
+ */
+
+/**
+ * @typedef {Output & {
+ * uniqueName: NonNullable<Output["uniqueName"]>,
+ * filename: NonNullable<Output["filename"]>,
+ * cssFilename: NonNullable<Output["cssFilename"]>,
+ * chunkFilename: NonNullable<Output["chunkFilename"]>,
+ * cssChunkFilename: NonNullable<Output["cssChunkFilename"]>,
+ * hotUpdateChunkFilename: NonNullable<Output["hotUpdateChunkFilename"]>,
+ * hotUpdateGlobal: NonNullable<Output["hotUpdateGlobal"]>,
+ * assetModuleFilename: NonNullable<Output["assetModuleFilename"]>,
+ * webassemblyModuleFilename: NonNullable<Output["webassemblyModuleFilename"]>
+ * sourceMapFilename: NonNullable<Output["sourceMapFilename"]>,
+ * hotUpdateMainFilename: NonNullable<Output["hotUpdateMainFilename"]>,
+ * devtoolNamespace: NonNullable<Output["devtoolNamespace"]>,
+ * publicPath: NonNullable<Output["publicPath"]>
+ * workerPublicPath: NonNullable<Output["workerPublicPath"]>
+ * workerWasmLoading: NonNullable<Output["workerWasmLoading"]>
+ * workerChunkLoading: NonNullable<Output["workerChunkLoading"]>
+ * chunkFormat: NonNullable<Output["chunkFormat"]>,
+ * module: NonNullable<Output["module"]>,
+ * asyncChunks: NonNullable<Output["asyncChunks"]>,
+ * charset: NonNullable<Output["charset"]>,
+ * iife: NonNullable<Output["iife"]>,
+ * globalObject: NonNullable<Output["globalObject"]>,
+ * scriptType: NonNullable<Output["scriptType"]>,
+ * path: NonNullable<Output["path"]>,
+ * pathinfo: NonNullable<Output["pathinfo"]>,
+ * hashFunction: NonNullable<Output["hashFunction"]>,
+ * hashDigest: NonNullable<Output["hashDigest"]>,
+ * hashDigestLength: NonNullable<Output["hashDigestLength"]>,
+ * chunkLoadTimeout: NonNullable<Output["chunkLoadTimeout"]>,
+ * chunkLoading: NonNullable<Output["chunkLoading"]>,
+ * chunkLoadingGlobal: NonNullable<Output["chunkLoadingGlobal"]>,
+ * compareBeforeEmit: NonNullable<Output["compareBeforeEmit"]>,
+ * strictModuleErrorHandling: NonNullable<Output["strictModuleErrorHandling"]>,
+ * strictModuleExceptionHandling: NonNullable<Output["strictModuleExceptionHandling"]>,
+ * importFunctionName: NonNullable<Output["importFunctionName"]>,
+ * importMetaName: NonNullable<Output["importMetaName"]>,
+ * environment: RecursiveNonNullable<Output["environment"]>,
+ * crossOriginLoading: NonNullable<Output["crossOriginLoading"]>,
+ * wasmLoading: NonNullable<Output["wasmLoading"]>,
+ * }} OutputNormalizedWithDefaults
+ */
+
+/**
+ * @typedef {SnapshotOptions & {
+ * managedPaths: NonNullable<SnapshotOptions["managedPaths"]>,
+ * unmanagedPaths: NonNullable<SnapshotOptions["unmanagedPaths"]>,
+ * immutablePaths: NonNullable<SnapshotOptions["immutablePaths"]>,
+ * resolveBuildDependencies: NonNullable<SnapshotOptions["resolveBuildDependencies"]>,
+ * buildDependencies: NonNullable<SnapshotOptions["buildDependencies"]>,
+ * module: NonNullable<SnapshotOptions["module"]>,
+ * resolve: NonNullable<SnapshotOptions["resolve"]>,
+ * }} SnapshotNormalizedWithDefaults
+ */
+
+/**
+ * @typedef {Optimization & {
+ * runtimeChunk: NonNullable<Optimization["runtimeChunk"]>,
+ * splitChunks: NonNullable<Optimization["splitChunks"]>,
+ * mergeDuplicateChunks: NonNullable<Optimization["mergeDuplicateChunks"]>,
+ * removeAvailableModules: NonNullable<Optimization["removeAvailableModules"]>,
+ * removeEmptyChunks: NonNullable<Optimization["removeEmptyChunks"]>,
+ * flagIncludedChunks: NonNullable<Optimization["flagIncludedChunks"]>,
+ * moduleIds: NonNullable<Optimization["moduleIds"]>,
+ * chunkIds: NonNullable<Optimization["chunkIds"]>,
+ * sideEffects: NonNullable<Optimization["sideEffects"]>,
+ * providedExports: NonNullable<Optimization["providedExports"]>,
+ * usedExports: NonNullable<Optimization["usedExports"]>,
+ * mangleExports: NonNullable<Optimization["mangleExports"]>,
+ * innerGraph: NonNullable<Optimization["innerGraph"]>,
+ * concatenateModules: NonNullable<Optimization["concatenateModules"]>,
+ * avoidEntryIife: NonNullable<Optimization["avoidEntryIife"]>,
+ * emitOnErrors: NonNullable<Optimization["emitOnErrors"]>,
+ * checkWasmTypes: NonNullable<Optimization["checkWasmTypes"]>,
+ * mangleWasmImports: NonNullable<Optimization["mangleWasmImports"]>,
+ * portableRecords: NonNullable<Optimization["portableRecords"]>,
+ * realContentHash: NonNullable<Optimization["realContentHash"]>,
+ * minimize: NonNullable<Optimization["minimize"]>,
+ * minimizer: NonNullable<Exclude<Optimization["minimizer"], "...">>,
+ * nodeEnv: NonNullable<Optimization["nodeEnv"]>,
+ * }} OptimizationNormalizedWithDefaults
+ */
+
+/**
+ * @typedef {ExternalsPresets & {
+ * web: NonNullable<ExternalsPresets["web"]>,
+ * node: NonNullable<ExternalsPresets["node"]>,
+ * nwjs: NonNullable<ExternalsPresets["nwjs"]>,
+ * electron: NonNullable<ExternalsPresets["electron"]>,
+ * electronMain: NonNullable<ExternalsPresets["electronMain"]>,
+ * electronPreload: NonNullable<ExternalsPresets["electronPreload"]>,
+ * electronRenderer: NonNullable<ExternalsPresets["electronRenderer"]>,
+ * }} ExternalsPresetsNormalizedWithDefaults
+ */
+
+/**
+ * @typedef {InfrastructureLogging & {
+ * stream: NonNullable<InfrastructureLogging["stream"]>,
+ * level: NonNullable<InfrastructureLogging["level"]>,
+ * debug: NonNullable<InfrastructureLogging["debug"]>,
+ * colors: NonNullable<InfrastructureLogging["colors"]>,
+ * appendOnly: NonNullable<InfrastructureLogging["appendOnly"]>,
+ * }} InfrastructureLoggingNormalizedWithDefaults
+ */
+
+/**
+ * @typedef {WebpackOptionsNormalized
+ * & { context: NonNullable<WebpackOptionsNormalized["context"]> }
+ * & { infrastructureLogging: InfrastructureLoggingNormalizedWithDefaults }
+ * } WebpackOptionsNormalizedWithBaseDefaults
+ */
+
+/**
+ * @typedef {WebpackOptionsNormalizedWithBaseDefaults
+ * & { target: NonNullable<WebpackOptionsNormalized["target"]> }
+ * & { output: OutputNormalizedWithDefaults }
+ * & { optimization: OptimizationNormalizedWithDefaults }
+ * & { devtool: NonNullable<WebpackOptionsNormalized["devtool"]> }
+ * & { stats: NonNullable<WebpackOptionsNormalized["stats"]>  }
+ * & { node: NonNullable<WebpackOptionsNormalized["node"]> }
+ * & { profile: NonNullable<WebpackOptionsNormalized["profile"]> }
+ * & { parallelism: NonNullable<WebpackOptionsNormalized["parallelism"]> }
+ * & { snapshot: SnapshotNormalizedWithDefaults }
+ * & { externalsPresets: ExternalsPresetsNormalizedWithDefaults }
+ * & { externalsType: NonNullable<WebpackOptionsNormalized["externalsType"]> }
+ * & { watch: NonNullable<WebpackOptionsNormalized["watch"]> }
+ * & { performance: NonNullable<WebpackOptionsNormalized["performance"]> }
+ * & { recordsInputPath: NonNullable<WebpackOptionsNormalized["recordsInputPath"]> }
+ * & { recordsOutputPath: NonNullable<WebpackOptionsNormalized["recordsOutputPath"]>
+ * & { dotenv: NonNullable<WebpackOptionsNormalized["dotenv"]> }
+ * }} WebpackOptionsNormalizedWithDefaults
+ */
+
 /**
  * @typedef {object} ResolvedOptions
  * @property {PlatformTargetProperties | false} platform - platform target properties
@@ -78,6 +221,10 @@ const {
 
 const NODE_MODULES_REGEXP = /[\\/]node_modules[\\/]/i;
 const DEFAULT_CACHE_NAME = "default";
+const DEFAULTS = {
+	// TODO webpack 6 - use xxhash64
+	HASH_FUNCTION: "md4"
+};
 
 /**
  * Sets a constant default value when undefined
@@ -100,7 +247,7 @@ const D = (obj, prop, value) => {
  * @template {keyof T} P
  * @param {T} obj an object
  * @param {P} prop a property of this object
- * @param {function(): T[P]} factory a default value factory for the property
+ * @param {() => T[P]} factory a default value factory for the property
  * @returns {void}
  */
 const F = (obj, prop, factory) => {
@@ -118,7 +265,7 @@ const F = (obj, prop, factory) => {
  * @template {keyof T} P
  * @param {T} obj an object
  * @param {P} prop a property of this object
- * @param {function(): T[P]} factory a default value factory for the property
+ * @param {() => T[P]} factory a default value factory for the property
  * @returns {void}
  */
 const A = (obj, prop, factory) => {
@@ -135,9 +282,9 @@ const A = (obj, prop, factory) => {
 					newArray = value.slice(0, i);
 					obj[prop] = /** @type {T[P]} */ (/** @type {unknown} */ (newArray));
 				}
-				const items = /** @type {EXPECTED_ANY[]} */ (
-					/** @type {unknown} */ (factory())
-				);
+				const items =
+					/** @type {EXPECTED_ANY[]} */
+					(/** @type {unknown} */ (factory()));
 				if (items !== undefined) {
 					for (const item of items) {
 						newArray.push(item);
@@ -154,14 +301,14 @@ const A = (obj, prop, factory) => {
  * @param {WebpackOptionsNormalized} options options to be modified
  * @returns {void}
  */
-const applyWebpackOptionsBaseDefaults = options => {
+const applyWebpackOptionsBaseDefaults = (options) => {
 	F(options, "context", () => process.cwd());
 	applyInfrastructureLoggingDefaults(options.infrastructureLogging);
 };
 
 /**
  * @param {WebpackOptionsNormalized} options options to be modified
- * @param {number} [compilerIndex] index of compiler
+ * @param {number=} compilerIndex index of compiler
  * @returns {ResolvedOptions} Resolved options after apply defaults
  */
 const applyWebpackOptionsDefaults = (options, compilerIndex) => {
@@ -220,6 +367,7 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 		mode: mode || "production",
 		development,
 		cacheUnaffected: options.experiments.cacheUnaffected,
+		futureDefaults,
 		compilerIndex
 	});
 	const cache = Boolean(options.cache);
@@ -236,7 +384,7 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 			target === undefined ||
 			(typeof target === "string" && target.startsWith("browserslist")) ||
 			(Array.isArray(target) &&
-				target.some(target => target.startsWith("browserslist"))),
+				target.some((target) => target.startsWith("browserslist"))),
 		outputModule:
 			/** @type {NonNullable<ExperimentsNormalized["outputModule"]>} */
 			(options.experiments.outputModule),
@@ -250,6 +398,15 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 
 	applyModuleDefaults(options.module, {
 		cache,
+		hashSalt: /** @type {NonNullable<Output["hashSalt"]>} */ (
+			options.output.hashSalt
+		),
+		hashDigest: /** @type {NonNullable<Output["hashDigest"]>} */ (
+			options.output.hashDigest
+		),
+		hashDigestLength: /** @type {NonNullable<Output["hashDigestLength"]>} */ (
+			options.output.hashDigestLength
+		),
 		syncWebAssembly:
 			/** @type {NonNullable<ExperimentsNormalized["syncWebAssembly"]>} */
 			(options.experiments.syncWebAssembly),
@@ -259,15 +416,22 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 		css:
 			/** @type {NonNullable<ExperimentsNormalized["css"]>} */
 			(options.experiments.css),
+		deferImport:
+			/** @type {NonNullable<ExperimentsNormalized["deferImport"]>} */
+			(options.experiments.deferImport),
 		futureDefaults,
 		isNode: targetProperties && targetProperties.node === true,
-		uniqueName: options.output.uniqueName,
-		targetProperties
+		uniqueName: /** @type {string} */ (options.output.uniqueName),
+		targetProperties,
+		mode: options.mode
 	});
 
 	applyExternalsPresetsDefaults(options.externalsPresets, {
 		targetProperties,
-		buildHttp: Boolean(options.experiments.buildHttp)
+		buildHttp: Boolean(options.experiments.buildHttp),
+		outputModule:
+			/** @type {NonNullable<WebpackOptionsNormalized["output"]["module"]>} */
+			(options.output.module)
 	});
 
 	applyLoaderDefaults(
@@ -280,6 +444,7 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 	F(options, "externalsType", () => {
 		const validExternalTypes = require("../../schemas/WebpackOptions.json")
 			.definitions.ExternalsType.enum;
+
 		return options.output.library &&
 			validExternalTypes.includes(options.output.library.type)
 			? /** @type {ExternalsType} */ (options.output.library.type)
@@ -369,22 +534,16 @@ const applyExperimentsDefaults = (
 ) => {
 	D(experiments, "futureDefaults", false);
 	D(experiments, "backCompat", !experiments.futureDefaults);
+	// TODO do we need sync web assembly in webpack@6?
 	D(experiments, "syncWebAssembly", false);
 	D(experiments, "asyncWebAssembly", experiments.futureDefaults);
 	D(experiments, "outputModule", false);
-	D(experiments, "layers", false);
 	D(experiments, "lazyCompilation", undefined);
 	D(experiments, "buildHttp", undefined);
 	D(experiments, "cacheUnaffected", experiments.futureDefaults);
+	D(experiments, "deferImport", false);
 	F(experiments, "css", () => (experiments.futureDefaults ? true : undefined));
 
-	// TODO webpack 6: remove this. topLevelAwait should be enabled by default
-	let shouldEnableTopLevelAwait = true;
-	if (typeof experiments.topLevelAwait === "boolean") {
-		shouldEnableTopLevelAwait = experiments.topLevelAwait;
-	}
-	D(experiments, "topLevelAwait", shouldEnableTopLevelAwait);
-
 	if (typeof experiments.buildHttp === "object") {
 		D(experiments.buildHttp, "frozen", production);
 		D(experiments.buildHttp, "upgrade", false);
@@ -396,14 +555,15 @@ const applyExperimentsDefaults = (
  * @param {object} options options
  * @param {string} options.name name
  * @param {Mode} options.mode mode
+ * @param {boolean} options.futureDefaults is future defaults enabled
  * @param {boolean} options.development is development mode
- * @param {number} [options.compilerIndex] index of compiler
+ * @param {number=} options.compilerIndex index of compiler
  * @param {Experiments["cacheUnaffected"]} options.cacheUnaffected the cacheUnaffected experiment is enabled
  * @returns {void}
  */
 const applyCacheDefaults = (
 	cache,
-	{ name, mode, development, cacheUnaffected, compilerIndex }
+	{ name, mode, development, cacheUnaffected, compilerIndex, futureDefaults }
 ) => {
 	if (cache === false) return;
 	switch (cache.type) {
@@ -446,7 +606,7 @@ const applyCacheDefaults = (
 					/** @type {NonNullable<FileCacheOptions["name"]>} */ (cache.name)
 				)
 			);
-			D(cache, "hashAlgorithm", "md4");
+			D(cache, "hashAlgorithm", futureDefaults ? "xxhash64" : "md4");
 			D(cache, "store", "pack");
 			D(cache, "compression", false);
 			D(cache, "profile", false);
@@ -543,6 +703,7 @@ const applySnapshotDefaults = (snapshot, { production, futureDefaults }) => {
 	F(snapshot, "module", () =>
 		production ? { timestamp: true, hash: true } : { timestamp: true }
 	);
+	F(snapshot, "contextModule", () => ({ timestamp: true }));
 	F(snapshot, "resolve", () =>
 		production ? { timestamp: true, hash: true } : { timestamp: true }
 	);
@@ -552,12 +713,13 @@ const applySnapshotDefaults = (snapshot, { production, futureDefaults }) => {
  * @param {JavascriptParserOptions} parserOptions parser options
  * @param {object} options options
  * @param {boolean} options.futureDefaults is future defaults enabled
+ * @param {boolean} options.deferImport is defer import enabled
  * @param {boolean} options.isNode is node target platform
  * @returns {void}
  */
 const applyJavascriptParserOptionsDefaults = (
 	parserOptions,
-	{ futureDefaults, isNode }
+	{ futureDefaults, deferImport, isNode }
 ) => {
 	D(parserOptions, "unknownContextRequest", ".");
 	D(parserOptions, "unknownContextRegExp", false);
@@ -577,9 +739,19 @@ const applyJavascriptParserOptionsDefaults = (
 	D(parserOptions, "dynamicImportPreload", false);
 	D(parserOptions, "dynamicImportFetchPriority", false);
 	D(parserOptions, "createRequire", isNode);
+	D(parserOptions, "dynamicUrl", true);
+	D(parserOptions, "deferImport", deferImport);
 	if (futureDefaults) D(parserOptions, "exportsPresence", "error");
 };
 
+/**
+ * @param {JsonGeneratorOptions} generatorOptions generator options
+ * @returns {void}
+ */
+const applyJsonGeneratorOptionsDefaults = (generatorOptions) => {
+	D(generatorOptions, "JSONParse", true);
+};
+
 /**
  * @param {CssGeneratorOptions} generatorOptions generator options
  * @param {object} options options
@@ -608,12 +780,20 @@ const applyCssGeneratorOptionsDefaults = (
  * @param {boolean} options.futureDefaults is future defaults enabled
  * @param {string} options.uniqueName the unique name
  * @param {boolean} options.isNode is node target platform
+ * @param {boolean} options.deferImport is defer import enabled
  * @param {TargetProperties | false} options.targetProperties target properties
+ * @param {Mode | undefined} options.mode mode
+ * @param {HashSalt} options.hashSalt hash salt
+ * @param {HashDigest} options.hashDigest hash digest
+ * @param {HashDigestLength} options.hashDigestLength hash digest length
  * @returns {void}
  */
 const applyModuleDefaults = (
 	module,
 	{
+		hashSalt,
+		hashDigest,
+		hashDigestLength,
 		cache,
 		syncWebAssembly,
 		asyncWebAssembly,
@@ -621,7 +801,9 @@ const applyModuleDefaults = (
 		futureDefaults,
 		isNode,
 		uniqueName,
-		targetProperties
+		targetProperties,
+		mode,
+		deferImport
 	}
 ) => {
 	if (cache) {
@@ -630,11 +812,14 @@ const applyModuleDefaults = (
 			"unsafeCache",
 			/**
 			 * @param {Module} module module
-			 * @returns {boolean | null | string} true, if we want to cache the module
+			 * @returns {boolean} true, if we want to cache the module
 			 */
-			module => {
+			(module) => {
 				const name = module.nameForCondition();
-				return name && NODE_MODULES_REGEXP.test(name);
+				if (!name) {
+					return false;
+				}
+				return NODE_MODULES_REGEXP.test(name);
 			}
 		);
 	} else {
@@ -643,19 +828,19 @@ const applyModuleDefaults = (
 
 	F(module.parser, ASSET_MODULE_TYPE, () => ({}));
 	F(
-		/** @type {NonNullable<ParserOptionsByModuleTypeKnown["asset"]>} */
+		/** @type {NonNullable<ParserOptionsByModuleTypeKnown[ASSET_MODULE_TYPE]>} */
 		(module.parser[ASSET_MODULE_TYPE]),
 		"dataUrlCondition",
 		() => ({})
 	);
 	if (
 		typeof (
-			/** @type {NonNullable<ParserOptionsByModuleTypeKnown["asset"]>} */
+			/** @type {NonNullable<ParserOptionsByModuleTypeKnown[ASSET_MODULE_TYPE]>} */
 			(module.parser[ASSET_MODULE_TYPE]).dataUrlCondition
 		) === "object"
 	) {
 		D(
-			/** @type {NonNullable<ParserOptionsByModuleTypeKnown["asset"]>} */
+			/** @type {NonNullable<ParserOptionsByModuleTypeKnown[ASSET_MODULE_TYPE]>} */
 			(module.parser[ASSET_MODULE_TYPE]).dataUrlCondition,
 			"maxSize",
 			8096
@@ -663,53 +848,158 @@ const applyModuleDefaults = (
 	}
 
 	F(module.parser, "javascript", () => ({}));
+	F(module.parser, JSON_MODULE_TYPE, () => ({}));
+	D(
+		/** @type {NonNullable<ParserOptionsByModuleTypeKnown[JSON_MODULE_TYPE]>} */
+		(module.parser[JSON_MODULE_TYPE]),
+		"exportsDepth",
+		mode === "development" ? 1 : Infinity
+	);
 
 	applyJavascriptParserOptionsDefaults(
 		/** @type {NonNullable<ParserOptionsByModuleTypeKnown["javascript"]>} */
 		(module.parser.javascript),
 		{
 			futureDefaults,
+			deferImport,
 			isNode
 		}
 	);
 
+	F(module.generator, "json", () => ({}));
+	applyJsonGeneratorOptionsDefaults(
+		/** @type {NonNullable<GeneratorOptionsByModuleTypeKnown["json"]>} */
+		(module.generator.json)
+	);
+
 	if (css) {
 		F(module.parser, CSS_MODULE_TYPE, () => ({}));
 
-		D(module.parser[CSS_MODULE_TYPE], "import", true);
-		D(module.parser[CSS_MODULE_TYPE], "url", true);
-		D(module.parser[CSS_MODULE_TYPE], "namedExports", true);
+		D(
+			/** @type {NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE]>} */
+			(module.parser[CSS_MODULE_TYPE]),
+			"import",
+			true
+		);
+		D(
+			/** @type {NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE]>} */
+			(module.parser[CSS_MODULE_TYPE]),
+			"url",
+			true
+		);
+		D(
+			/** @type {NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE]>} */
+			(module.parser[CSS_MODULE_TYPE]),
+			"namedExports",
+			true
+		);
+
+		for (const type of [
+			CSS_MODULE_TYPE_AUTO,
+			CSS_MODULE_TYPE_MODULE,
+			CSS_MODULE_TYPE_GLOBAL
+		]) {
+			F(module.parser, type, () => ({}));
+
+			D(
+				/** @type {NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_AUTO]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_GLOBAL]>} */
+				(module.parser[type]),
+				"animation",
+				true
+			);
+			D(
+				/** @type {NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_AUTO]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_GLOBAL]>} */
+				(module.parser[type]),
+				"container",
+				true
+			);
+			D(
+				/** @type {NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_AUTO]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_GLOBAL]>} */
+				(module.parser[type]),
+				"customIdents",
+				true
+			);
+			D(
+				/** @type {NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_AUTO]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_GLOBAL]>} */
+				(module.parser[type]),
+				"dashedIdents",
+				true
+			);
+			D(
+				/** @type {NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_AUTO]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_GLOBAL]>} */
+				(module.parser[type]),
+				"function",
+				true
+			);
+			D(
+				/** @type {NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_AUTO]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_GLOBAL]>} */
+				(module.parser[type]),
+				"grid",
+				true
+			);
+		}
 
 		F(module.generator, CSS_MODULE_TYPE, () => ({}));
 
 		applyCssGeneratorOptionsDefaults(
-			/** @type {NonNullable<GeneratorOptionsByModuleTypeKnown["css"]>} */
+			/** @type {NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE]>} */
 			(module.generator[CSS_MODULE_TYPE]),
 			{ targetProperties }
 		);
 
 		const localIdentName =
-			uniqueName.length > 0 ? "[uniqueName]-[id]-[local]" : "[id]-[local]";
+			mode === "development"
+				? uniqueName.length > 0
+					? "[uniqueName]-[id]-[local]"
+					: "[id]-[local]"
+				: "[fullhash]";
+		const localIdentHashSalt = hashSalt;
+		const localIdentHashDigest = "base64url";
+		const localIdentHashDigestLength = 6;
+		const exportsConvention = "as-is";
+
+		for (const type of [
+			CSS_MODULE_TYPE_AUTO,
+			CSS_MODULE_TYPE_MODULE,
+			CSS_MODULE_TYPE_GLOBAL
+		]) {
+			F(module.generator, type, () => ({}));
+
+			D(
+				/** @type {NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_AUTO]> | NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]> | NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_GLOBAL]>} */
+				(module.generator[type]),
+				"localIdentName",
+				localIdentName
+			);
 
-		F(module.generator, CSS_MODULE_TYPE_AUTO, () => ({}));
-		D(module.generator[CSS_MODULE_TYPE_AUTO], "localIdentName", localIdentName);
-		D(module.generator[CSS_MODULE_TYPE_AUTO], "exportsConvention", "as-is");
+			D(
+				/** @type {NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_AUTO]> | NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]> | NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_GLOBAL]>} */
+				(module.generator[type]),
+				"localIdentHashSalt",
+				localIdentHashSalt
+			);
 
-		F(module.generator, CSS_MODULE_TYPE_MODULE, () => ({}));
-		D(
-			module.generator[CSS_MODULE_TYPE_MODULE],
-			"localIdentName",
-			localIdentName
-		);
-		D(module.generator[CSS_MODULE_TYPE_MODULE], "exportsConvention", "as-is");
+			D(
+				/** @type {NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_AUTO]> | NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]> | NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]>} */
+				(module.generator[type]),
+				"localIdentHashDigest",
+				localIdentHashDigest
+			);
 
-		F(module.generator, CSS_MODULE_TYPE_GLOBAL, () => ({}));
-		D(
-			module.generator[CSS_MODULE_TYPE_GLOBAL],
-			"localIdentName",
-			localIdentName
-		);
-		D(module.generator[CSS_MODULE_TYPE_GLOBAL], "exportsConvention", "as-is");
+			D(
+				/** @type {NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_AUTO]> | NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]> | NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]>} */
+				(module.generator[type]),
+				"localIdentHashDigestLength",
+				localIdentHashDigestLength
+			);
+
+			D(
+				/** @type {NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_AUTO]> | NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]> | NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_GLOBAL]>} */
+				(module.generator[type]),
+				"exportsConvention",
+				exportsConvention
+			);
+		}
 	}
 
 	A(module, "defaultRules", () => {
@@ -834,6 +1124,35 @@ const applyModuleDefaults = (
 				type: CSS_MODULE_TYPE,
 				resolve
 			});
+			// For CSS modules, i.e. `.class { composes: className from "./style.css" }`
+			// We inherit for such constructions
+			rules.push({
+				dependency: /css-import-local-module/,
+				type: CSS_MODULE_TYPE_MODULE,
+				resolve
+			});
+			rules.push({
+				dependency: /css-import-global-module/,
+				type: CSS_MODULE_TYPE_GLOBAL,
+				resolve
+			});
+
+			rules.push(
+				{
+					with: { type: "css" },
+					parser: {
+						exportType: "css-style-sheet"
+					},
+					resolve
+				},
+				{
+					assert: { type: "css" },
+					parser: {
+						exportType: "css-style-sheet"
+					},
+					resolve
+				}
+			);
 		}
 		rules.push(
 			{
@@ -848,13 +1167,23 @@ const applyModuleDefaults = (
 					}
 				]
 			},
+			{
+				with: { type: JSON_MODULE_TYPE },
+				type: JSON_MODULE_TYPE,
+				parser: { namedExports: false }
+			},
 			{
 				assert: { type: JSON_MODULE_TYPE },
-				type: JSON_MODULE_TYPE
+				type: JSON_MODULE_TYPE,
+				parser: { namedExports: false }
 			},
 			{
-				with: { type: JSON_MODULE_TYPE },
-				type: JSON_MODULE_TYPE
+				with: { type: "text" },
+				type: ASSET_MODULE_TYPE_SOURCE
+			},
+			{
+				with: { type: "bytes" },
+				type: ASSET_MODULE_TYPE_BYTES
 			}
 		);
 		return rules;
@@ -891,7 +1220,7 @@ const applyOutputDefaults = (
 	 * @param {Library=} library the library option
 	 * @returns {string} a readable library name
 	 */
-	const getLibraryName = library => {
+	const getLibraryName = (library) => {
 		const libraryName =
 			typeof library === "object" &&
 			library &&
@@ -922,7 +1251,7 @@ const applyOutputDefaults = (
 		if (libraryName) return libraryName;
 		const pkgPath = path.resolve(context, "package.json");
 		try {
-			const packageInfo = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+			const packageInfo = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
 			return packageInfo.name || "";
 		} catch (err) {
 			if (/** @type {Error & { code: string }} */ (err).code !== "ENOENT") {
@@ -942,7 +1271,7 @@ const applyOutputDefaults = (
 	 * @param {boolean | undefined} v value
 	 * @returns {boolean} true, when v is truthy or undefined
 	 */
-	const optimistic = v => v || v === undefined;
+	const optimistic = (v) => v || v === undefined;
 	/**
 	 * @param {boolean | undefined} v value
 	 * @param {boolean | undefined} c condition
@@ -966,6 +1295,12 @@ const applyOutputDefaults = (
 		"const",
 		() => tp && optimistic(/** @type {boolean | undefined} */ (tp.const))
 	);
+	F(
+		environment,
+		"methodShorthand",
+		() =>
+			tp && optimistic(/** @type {boolean | undefined} */ (tp.methodShorthand))
+	);
 	F(
 		environment,
 		"arrowFunction",
@@ -1004,6 +1339,13 @@ const applyOutputDefaults = (
 				/** @type {boolean | undefined} */ (tp.nodePrefixForCoreModules)
 			)
 	);
+	F(
+		environment,
+		"importMetaDirnameAndFilename",
+		() =>
+			// No optimistic, because it is new
+			tp && /** @type {boolean | undefined} */ (tp.importMetaDirnameAndFilename)
+	);
 	F(
 		environment,
 		"templateLiteral",
@@ -1072,10 +1414,10 @@ const applyOutputDefaults = (
 		}
 		return "[id].css";
 	});
-	D(output, "assetModuleFilename", "[hash][ext][query]");
+	D(output, "assetModuleFilename", "[hash][ext][query][fragment]");
 	D(output, "webassemblyModuleFilename", "[hash].module.wasm");
 	D(output, "compareBeforeEmit", true);
-	D(output, "charset", true);
+	D(output, "charset", !futureDefaults);
 	const uniqueNameId = Template.toIdentifier(
 		/** @type {NonNullable<Output["uniqueName"]>} */ (output.uniqueName)
 	);
@@ -1085,6 +1427,8 @@ const applyOutputDefaults = (
 		if (tp) {
 			if (tp.global) return "global";
 			if (tp.globalThis) return "globalThis";
+			// For universal target (i.e. code can be run in browser/node/worker etc.)
+			if (tp.web === null && tp.node === null && tp.module) return "globalThis";
 		}
 		return "self";
 	});
@@ -1110,8 +1454,13 @@ const applyOutputDefaults = (
 				if (tp.importScripts) return "array-push";
 				throw new Error(
 					"For the selected environment is no default script chunk format available:\n" +
-						"JSONP Array push can be chosen when 'document' or 'importScripts' is available.\n" +
-						`CommonJs exports can be chosen when 'require' or node builtins are available.\n${
+						`${
+							tp.module
+								? "Module ('module') can be chosen when ES modules are available (please set 'experiments.outputModule' and 'output.module' to `true`)"
+								: ""
+						}\n` +
+						"JSONP Array push ('array-push') can be chosen when 'document' or 'importScripts' is available.\n" +
+						`CommonJs exports ('commonjs') can be chosen when 'require' or node builtins are available.\n${
 							helpMessage
 						}`
 				);
@@ -1169,7 +1518,7 @@ const applyOutputDefaults = (
 					tp.nodeBuiltins === null ||
 					tp.importScriptsInWorker === null) &&
 				output.module &&
-				environment.dynamicImport
+				environment.dynamicImportInWorker
 			) {
 				return "universal";
 			}
@@ -1182,7 +1531,6 @@ const applyOutputDefaults = (
 			if (tp.nodeBuiltins) return "async-node";
 			if (
 				(tp.nodeBuiltins === null || tp.fetchWasm === null) &&
-				asyncWebAssembly &&
 				output.module &&
 				environment.dynamicImport
 			) {
@@ -1204,7 +1552,11 @@ const applyOutputDefaults = (
 		"hotUpdateChunkFilename",
 		`[id].[fullhash].hot-update.${output.module ? "mjs" : "js"}`
 	);
-	D(output, "hotUpdateMainFilename", "[runtime].[fullhash].hot-update.json");
+	D(
+		output,
+		"hotUpdateMainFilename",
+		`[runtime].[fullhash].hot-update.${output.module ? "json.mjs" : "json"}`
+	);
 	D(output, "crossOriginLoading", false);
 	F(output, "scriptType", () => (output.module ? "module" : false));
 	D(
@@ -1216,7 +1568,14 @@ const applyOutputDefaults = (
 	);
 	D(output, "workerPublicPath", "");
 	D(output, "chunkLoadTimeout", 120000);
-	D(output, "hashFunction", futureDefaults ? "xxhash64" : "md4");
+	F(output, "hashFunction", () => {
+		if (futureDefaults) {
+			DEFAULTS.HASH_FUNCTION = "xxhash64";
+			return "xxhash64";
+		}
+
+		return "md4";
+	});
 	D(output, "hashDigest", "hex");
 	D(output, "hashDigestLength", futureDefaults ? 16 : 20);
 	D(output, "strictModuleErrorHandling", false);
@@ -1235,12 +1594,12 @@ const applyOutputDefaults = (
 	}
 
 	/**
-	 * @param {function(EntryDescription): void} fn iterator
+	 * @param {(entryDescription: EntryDescription) => void} fn iterator
 	 * @returns {void}
 	 */
-	const forEachEntry = fn => {
+	const forEachEntry = (fn) => {
 		for (const name of Object.keys(entry)) {
-			fn(/** @type {{[k: string] : EntryDescription}} */ (entry)[name]);
+			fn(/** @type {{ [k: string]: EntryDescription }} */ (entry)[name]);
 		}
 	};
 	A(output, "enabledLibraryTypes", () => {
@@ -1249,7 +1608,7 @@ const applyOutputDefaults = (
 		if (output.library) {
 			enabledLibraryTypes.push(output.library.type);
 		}
-		forEachEntry(desc => {
+		forEachEntry((desc) => {
 			if (desc.library) {
 				enabledLibraryTypes.push(desc.library.type);
 			}
@@ -1265,12 +1624,12 @@ const applyOutputDefaults = (
 		if (output.workerChunkLoading) {
 			enabledChunkLoadingTypes.add(output.workerChunkLoading);
 		}
-		forEachEntry(desc => {
+		forEachEntry((desc) => {
 			if (desc.chunkLoading) {
 				enabledChunkLoadingTypes.add(desc.chunkLoading);
 			}
 		});
-		return Array.from(enabledChunkLoadingTypes);
+		return [...enabledChunkLoadingTypes];
 	});
 
 	A(output, "enabledWasmLoadingTypes", () => {
@@ -1281,12 +1640,12 @@ const applyOutputDefaults = (
 		if (output.workerWasmLoading) {
 			enabledWasmLoadingTypes.add(output.workerWasmLoading);
 		}
-		forEachEntry(desc => {
+		forEachEntry((desc) => {
 			if (desc.wasmLoading) {
 				enabledWasmLoadingTypes.add(desc.wasmLoading);
 			}
 		});
-		return Array.from(enabledWasmLoadingTypes);
+		return [...enabledWasmLoadingTypes];
 	});
 };
 
@@ -1295,35 +1654,47 @@ const applyOutputDefaults = (
  * @param {object} options options
  * @param {TargetProperties | false} options.targetProperties target properties
  * @param {boolean} options.buildHttp buildHttp experiment enabled
+ * @param {boolean} options.outputModule is output type is module
  * @returns {void}
  */
 const applyExternalsPresetsDefaults = (
 	externalsPresets,
-	{ targetProperties, buildHttp }
+	{ targetProperties, buildHttp, outputModule }
 ) => {
+	/**
+	 * @param {keyof TargetProperties} key a key
+	 * @returns {boolean} true when target is universal, otherwise false
+	 */
+	const isUniversal = (key) =>
+		Boolean(outputModule && targetProperties && targetProperties[key] === null);
+
 	D(
 		externalsPresets,
 		"web",
 		/** @type {boolean | undefined} */
-		(!buildHttp && targetProperties && targetProperties.web)
+		(
+			!buildHttp &&
+				targetProperties &&
+				(targetProperties.web || isUniversal("node"))
+		)
 	);
 	D(
 		externalsPresets,
 		"node",
 		/** @type {boolean | undefined} */
-		(targetProperties && targetProperties.node)
+		(targetProperties && (targetProperties.node || isUniversal("node")))
 	);
 	D(
 		externalsPresets,
 		"nwjs",
 		/** @type {boolean | undefined} */
-		(targetProperties && targetProperties.nwjs)
+		(targetProperties && (targetProperties.nwjs || isUniversal("nwjs")))
 	);
 	D(
 		externalsPresets,
 		"electron",
 		/** @type {boolean | undefined} */
-		(targetProperties && targetProperties.electron)
+		((targetProperties && targetProperties.electron) || isUniversal("electron"))
 	);
 	D(
 		externalsPresets,
@@ -1332,7 +1703,7 @@ const applyExternalsPresetsDefaults = (
 		(
 			targetProperties &&
 				targetProperties.electron &&
-				targetProperties.electronMain
+				(targetProperties.electronMain || isUniversal("electronMain"))
 		)
 	);
 	D(
@@ -1342,7 +1713,7 @@ const applyExternalsPresetsDefaults = (
 		(
 			targetProperties &&
 				targetProperties.electron &&
-				targetProperties.electronPreload
+				(targetProperties.electronPreload || isUniversal("electronPreload"))
 		)
 	);
 	D(
@@ -1352,7 +1723,7 @@ const applyExternalsPresetsDefaults = (
 		(
 			targetProperties &&
 				targetProperties.electron &&
-				targetProperties.electronRenderer
+				(targetProperties.electronRenderer || isUniversal("electronRenderer"))
 		)
 	);
 };
@@ -1397,14 +1768,28 @@ const applyNodeDefaults = (
 
 	F(node, "global", () => {
 		if (targetProperties && targetProperties.global) return false;
-		// TODO webpack 6 should always default to false
+		// We use `warm` because overriding `global` with `globalThis` (or a polyfill) is sometimes safe (global.URL), sometimes unsafe (global.process), but we need to warn about it
 		return futureDefaults ? "warn" : true;
 	});
 
 	const handlerForNames = () => {
-		if (targetProperties && targetProperties.node)
-			return outputModule ? "node-module" : "eval-only";
-		// TODO webpack 6 should always default to false
+		// TODO webpack@6 remove `node-module` in favor of `eval-only`
+		if (targetProperties) {
+			if (targetProperties.node) {
+				return "eval-only";
+			}
+
+			// For the "universal" target we only evaluate these values
+			if (
+				outputModule &&
+				targetProperties.node === null &&
+				targetProperties.web === null
+			) {
+				return "eval-only";
+			}
+		}
+
+		// TODO webpack@6 should we use `warn-even-only`?
 		return futureDefaults ? "warn-mock" : "mock";
 	};
 
@@ -1468,16 +1853,17 @@ const applyOptimizationDefaults = (
 	D(optimization, "minimize", production);
 	A(optimization, "minimizer", () => [
 		{
-			apply: compiler => {
+			apply: (compiler) => {
 				// Lazy load the Terser plugin
 				const TerserPlugin = require("terser-webpack-plugin");
+
 				new TerserPlugin({
 					terserOptions: {
 						compress: {
 							passes: 2
 						}
 					}
-				}).apply(compiler);
+				}).apply(/** @type {EXPECTED_ANY} */ (compiler));
 			}
 		}
 	]);
@@ -1489,7 +1875,9 @@ const applyOptimizationDefaults = (
 	const { splitChunks } = optimization;
 	if (splitChunks) {
 		A(splitChunks, "defaultSizeTypes", () =>
-			css ? ["javascript", "css", "unknown"] : ["javascript", "unknown"]
+			css
+				? [JAVASCRIPT_TYPE, CSS_TYPE, UNKNOWN_TYPE]
+				: [JAVASCRIPT_TYPE, UNKNOWN_TYPE]
 		);
 		D(splitChunks, "hidePathInfo", production);
 		D(splitChunks, "chunks", "async");
@@ -1554,14 +1942,14 @@ const getResolveDefaults = ({
 	const browserField =
 		tp && tp.web && (!tp.node || (tp.electron && tp.electronRenderer));
 
-	/** @type {function(): ResolveOptions} */
+	/** @type {() => ResolveOptions} */
 	const cjsDeps = () => ({
 		aliasFields: browserField ? ["browser"] : [],
 		mainFields: browserField ? ["browser", "module", "..."] : ["module", "..."],
 		conditionNames: ["require", "module", "..."],
 		extensions: [...jsExtensions]
 	});
-	/** @type {function(): ResolveOptions} */
+	/** @type {() => ResolveOptions} */
 	const esmDeps = () => ({
 		aliasFields: browserField ? ["browser"] : [],
 		mainFields: browserField ? ["browser", "module", "..."] : ["module", "..."],
@@ -1610,7 +1998,8 @@ const getResolveDefaults = ({
 		styleConditions.push(mode === "development" ? "development" : "production");
 		styleConditions.push("style");
 
-		resolveOptions.byDependency["css-import"] = {
+		/** @type {ResolveOptions} */
+		const cssResolveOptions = {
 			// We avoid using any main files because we have to be consistent with CSS `@import`
 			// and CSS `@import` does not handle `main` files in directories,
 			// you should always specify the full URL for styles
@@ -1620,6 +2009,17 @@ const getResolveDefaults = ({
 			extensions: [".css"],
 			preferRelative: true
 		};
+
+		/** @type {NonNullable<ResolveOptions["byDependency"]>} */
+		(resolveOptions.byDependency)["css-import"] = cssResolveOptions;
+		// For CSS modules, i.e. `.class { composes: className from "./style.css" }`
+		// We inherit for such constructions
+		/** @type {NonNullable<ResolveOptions["byDependency"]>} */
+		(resolveOptions.byDependency)["css-import-local-module"] =
+			cssResolveOptions;
+		/** @type {NonNullable<ResolveOptions["byDependency"]>} */
+		(resolveOptions.byDependency)["css-import-global-module"] =
+			cssResolveOptions;
 	}
 
 	return resolveOptions;
@@ -1648,17 +2048,18 @@ const getResolveLoaderDefaults = ({ cache }) => {
  * @param {InfrastructureLogging} infrastructureLogging options
  * @returns {void}
  */
-const applyInfrastructureLoggingDefaults = infrastructureLogging => {
+const applyInfrastructureLoggingDefaults = (infrastructureLogging) => {
 	F(infrastructureLogging, "stream", () => process.stderr);
 	const tty =
-		/** @type {any} */ (infrastructureLogging.stream).isTTY &&
-		process.env.TERM !== "dumb";
+		/** @type {NonNullable<InfrastructureLogging["stream"]>} */
+		(infrastructureLogging.stream).isTTY && process.env.TERM !== "dumb";
 	D(infrastructureLogging, "level", "info");
 	D(infrastructureLogging, "debug", false);
 	D(infrastructureLogging, "colors", tty);
 	D(infrastructureLogging, "appendOnly", !tty);
 };
 
+module.exports.DEFAULTS = DEFAULTS;
 module.exports.applyWebpackOptionsBaseDefaults =
 	applyWebpackOptionsBaseDefaults;
 module.exports.applyWebpackOptionsDefaults = applyWebpackOptionsDefaults;