webpack 5.76.1 → 5.88.2

package/lib/config/defaults.js

@@ -7,6 +7,18 @@
 
 const fs = require("fs");
 const path = require("path");
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JSON_MODULE_TYPE,
+	WEBASSEMBLY_MODULE_TYPE_ASYNC,
+	JAVASCRIPT_MODULE_TYPE_ESM,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+	WEBASSEMBLY_MODULE_TYPE_SYNC,
+	ASSET_MODULE_TYPE,
+	CSS_MODULE_TYPE_AUTO,
+	CSS_MODULE_TYPE,
+	CSS_MODULE_TYPE_MODULE
+} = require("../ModuleTypeConstants");
 const Template = require("../Template");
 const { cleverMerge } = require("../util/cleverMerge");
 const {
@@ -16,30 +28,39 @@ const {
 } = require("./target");
 
 /** @typedef {import("../../declarations/WebpackOptions").CacheOptionsNormalized} CacheOptions */
+/** @typedef {import("../../declarations/WebpackOptions").Context} Context */
 /** @typedef {import("../../declarations/WebpackOptions").CssExperimentOptions} CssExperimentOptions */
 /** @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 */
 /** @typedef {import("../../declarations/WebpackOptions").ExternalsPresets} ExternalsPresets */
 /** @typedef {import("../../declarations/WebpackOptions").ExternalsType} ExternalsType */
+/** @typedef {import("../../declarations/WebpackOptions").FileCacheOptions} FileCacheOptions */
 /** @typedef {import("../../declarations/WebpackOptions").InfrastructureLogging} InfrastructureLogging */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @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").ModuleOptionsNormalized} ModuleOptions */
 /** @typedef {import("../../declarations/WebpackOptions").Node} WebpackNode */
 /** @typedef {import("../../declarations/WebpackOptions").Optimization} Optimization */
+/** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksOptions} OptimizationSplitChunksOptions */
 /** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} Output */
+/** @typedef {import("../../declarations/WebpackOptions").ParserOptionsByModuleTypeKnown} ParserOptionsByModuleTypeKnown */
 /** @typedef {import("../../declarations/WebpackOptions").Performance} Performance */
 /** @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").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 /** @typedef {import("./target").TargetProperties} TargetProperties */
 
 const NODE_MODULES_REGEXP = /[\\/]node_modules[\\/]/i;
@@ -91,7 +112,7 @@ const A = (obj, prop, factory) => {
 	if (value === undefined) {
 		obj[prop] = factory();
 	} else if (Array.isArray(value)) {
-		/** @type {any[]} */
+		/** @type {any[] | undefined} */
 		let newArray = undefined;
 		for (let i = 0; i < value.length; i++) {
 			const item = value[i];
@@ -129,7 +150,7 @@ const applyWebpackOptionsBaseDefaults = options => {
 const applyWebpackOptionsDefaults = options => {
 	F(options, "context", () => process.cwd());
 	F(options, "target", () => {
-		return getDefaultTarget(options.context);
+		return getDefaultTarget(/** @type {string} */ (options.context));
 	});
 
 	const { mode, name, target } = options;
@@ -138,8 +159,11 @@ const applyWebpackOptionsDefaults = options => {
 		target === false
 			? /** @type {false} */ (false)
 			: typeof target === "string"
-			? getTargetProperties(target, options.context)
-			: getTargetsProperties(target, options.context);
+			? getTargetProperties(target, /** @type {Context} */ (options.context))
+			: getTargetsProperties(
+					/** @type {string[]} */ (target),
+					/** @type {Context} */ (options.context)
+			  );
 
 	const development = mode === "development";
 	const production = mode === "production" || !mode;
@@ -167,7 +191,9 @@ const applyWebpackOptionsDefaults = options => {
 		targetProperties
 	});
 
-	const futureDefaults = options.experiments.futureDefaults;
+	const futureDefaults =
+		/** @type {NonNullable<ExperimentsNormalized["futureDefaults"]>} */
+		(options.experiments.futureDefaults);
 
 	F(options, "cache", () =>
 		development ? { type: /** @type {"memory"} */ ("memory") } : false
@@ -187,22 +213,30 @@ const applyWebpackOptionsDefaults = options => {
 
 	applyModuleDefaults(options.module, {
 		cache,
-		syncWebAssembly: options.experiments.syncWebAssembly,
-		asyncWebAssembly: options.experiments.asyncWebAssembly,
-		css: options.experiments.css,
+		syncWebAssembly:
+			/** @type {NonNullable<ExperimentsNormalized["syncWebAssembly"]>} */
+			(options.experiments.syncWebAssembly),
+		asyncWebAssembly:
+			/** @type {NonNullable<ExperimentsNormalized["asyncWebAssembly"]>} */
+			(options.experiments.asyncWebAssembly),
+		css:
+			/** @type {NonNullable<ExperimentsNormalized["css"]>} */
+			(options.experiments.css),
 		futureDefaults,
 		isNode: targetProperties && targetProperties.node === true
 	});
 
 	applyOutputDefaults(options.output, {
-		context: options.context,
+		context: /** @type {Context} */ (options.context),
 		targetProperties,
 		isAffectedByBrowserslist:
 			target === undefined ||
 			(typeof target === "string" && target.startsWith("browserslist")) ||
 			(Array.isArray(target) &&
 				target.some(target => target.startsWith("browserslist"))),
-		outputModule: options.experiments.outputModule,
+		outputModule:
+			/** @type {NonNullable<ExperimentsNormalized["outputModule"]>} */
+			(options.experiments.outputModule),
 		development,
 		entry: options.entry,
 		module: options.module,
@@ -214,7 +248,10 @@ const applyWebpackOptionsDefaults = options => {
 		buildHttp: !!options.experiments.buildHttp
 	});
 
-	applyLoaderDefaults(options.loader, { targetProperties });
+	applyLoaderDefaults(
+		/** @type {NonNullable<WebpackOptions["loader"]>} */ (options.loader),
+		{ targetProperties, environment: options.output.environment }
+	);
 
 	F(options, "externalsType", () => {
 		const validExternalTypes = require("../../schemas/WebpackOptions.json")
@@ -228,7 +265,9 @@ const applyWebpackOptionsDefaults = options => {
 	});
 
 	applyNodeDefaults(options.node, {
-		futureDefaults: options.experiments.futureDefaults,
+		futureDefaults:
+			/** @type {NonNullable<WebpackOptions["experiments"]["futureDefaults"]>} */
+			(options.experiments.futureDefaults),
 		targetProperties
 	});
 
@@ -239,23 +278,32 @@ const applyWebpackOptionsDefaults = options => {
 			? {}
 			: false
 	);
-	applyPerformanceDefaults(options.performance, {
-		production
-	});
+	applyPerformanceDefaults(
+		/** @type {NonNullable<WebpackOptions["performance"]>} */
+		(options.performance),
+		{
+			production
+		}
+	);
 
 	applyOptimizationDefaults(options.optimization, {
 		development,
 		production,
-		css: options.experiments.css,
+		css:
+			/** @type {NonNullable<ExperimentsNormalized["css"]>} */
+			(options.experiments.css),
 		records: !!(options.recordsInputPath || options.recordsOutputPath)
 	});
 
 	options.resolve = cleverMerge(
 		getResolveDefaults({
 			cache,
-			context: options.context,
+			context: /** @type {Context} */ (options.context),
 			targetProperties,
-			mode: options.mode
+			mode: /** @type {Mode} */ (options.mode),
+			css:
+				/** @type {NonNullable<ExperimentsNormalized["css"]>} */
+				(options.experiments.css)
 		}),
 		options.resolve
 	);
@@ -280,7 +328,6 @@ const applyExperimentsDefaults = (
 ) => {
 	D(experiments, "futureDefaults", false);
 	D(experiments, "backCompat", !experiments.futureDefaults);
-	D(experiments, "topLevelAwait", experiments.futureDefaults);
 	D(experiments, "syncWebAssembly", false);
 	D(experiments, "asyncWebAssembly", experiments.futureDefaults);
 	D(experiments, "outputModule", false);
@@ -290,6 +337,13 @@ const applyExperimentsDefaults = (
 	D(experiments, "cacheUnaffected", experiments.futureDefaults);
 	F(experiments, "css", () => (experiments.futureDefaults ? {} : 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);
@@ -308,9 +362,9 @@ const applyExperimentsDefaults = (
  * @param {CacheOptions} cache options
  * @param {Object} options options
  * @param {string} options.name name
- * @param {string} options.mode mode
+ * @param {Mode} options.mode mode
  * @param {boolean} options.development is development mode
- * @param {boolean} options.cacheUnaffected the cacheUnaffected experiment is enabled
+ * @param {Experiments["cacheUnaffected"]} options.cacheUnaffected the cacheUnaffected experiment is enabled
  * @returns {void}
  */
 const applyCacheDefaults = (
@@ -324,6 +378,7 @@ const applyCacheDefaults = (
 			D(cache, "version", "");
 			F(cache, "cacheDirectory", () => {
 				const cwd = process.cwd();
+				/** @type {string | undefined} */
 				let dir = cwd;
 				for (;;) {
 					try {
@@ -348,7 +403,11 @@ const applyCacheDefaults = (
 				}
 			});
 			F(cache, "cacheLocation", () =>
-				path.resolve(cache.cacheDirectory, cache.name)
+				path.resolve(
+					/** @type {NonNullable<FileCacheOptions["cacheDirectory"]>} */
+					(cache.cacheDirectory),
+					/** @type {NonNullable<FileCacheOptions["name"]>} */ (cache.name)
+				)
 			);
 			D(cache, "hashAlgorithm", "md4");
 			D(cache, "store", "pack");
@@ -361,9 +420,13 @@ const applyCacheDefaults = (
 			D(cache, "maxAge", 1000 * 60 * 60 * 24 * 60); // 1 month
 			D(cache, "allowCollectingMemory", development);
 			D(cache, "memoryCacheUnaffected", development && cacheUnaffected);
-			D(cache.buildDependencies, "defaultWebpack", [
-				path.resolve(__dirname, "..") + path.sep
-			]);
+			D(cache, "readonly", false);
+			D(
+				/** @type {NonNullable<FileCacheOptions["buildDependencies"]>} */
+				(cache.buildDependencies),
+				"defaultWebpack",
+				[path.resolve(__dirname, "..") + path.sep]
+			);
 			break;
 		case "memory":
 			D(cache, "maxGenerations", Infinity);
@@ -475,6 +538,7 @@ const applyJavascriptParserOptionsDefaults = (
 	D(parserOptions, "dynamicImportMode", "lazy");
 	D(parserOptions, "dynamicImportPrefetch", false);
 	D(parserOptions, "dynamicImportPreload", false);
+	D(parserOptions, "dynamicImportFetchPriority", false);
 	D(parserOptions, "createRequire", isNode);
 	if (futureDefaults) D(parserOptions, "exportsPresence", "error");
 };
@@ -495,29 +559,57 @@ const applyModuleDefaults = (
 	{ cache, syncWebAssembly, asyncWebAssembly, css, futureDefaults, isNode }
 ) => {
 	if (cache) {
-		D(module, "unsafeCache", module => {
-			const name = module.nameForCondition();
-			return name && NODE_MODULES_REGEXP.test(name);
-		});
+		D(
+			module,
+			"unsafeCache",
+			/**
+			 * @param {Module} module module
+			 * @returns {boolean | null | string} true, if we want to cache the module
+			 */
+			module => {
+				const name = module.nameForCondition();
+				return name && NODE_MODULES_REGEXP.test(name);
+			}
+		);
 	} else {
 		D(module, "unsafeCache", false);
 	}
 
-	F(module.parser, "asset", () => ({}));
-	F(module.parser.asset, "dataUrlCondition", () => ({}));
-	if (typeof module.parser.asset.dataUrlCondition === "object") {
-		D(module.parser.asset.dataUrlCondition, "maxSize", 8096);
+	F(module.parser, ASSET_MODULE_TYPE, () => ({}));
+	F(
+		/** @type {NonNullable<ParserOptionsByModuleTypeKnown["asset"]>} */
+		(module.parser.asset),
+		"dataUrlCondition",
+		() => ({})
+	);
+	if (
+		typeof (
+			/** @type {NonNullable<ParserOptionsByModuleTypeKnown["asset"]>} */
+			(module.parser.asset).dataUrlCondition
+		) === "object"
+	) {
+		D(
+			/** @type {NonNullable<ParserOptionsByModuleTypeKnown["asset"]>} */
+			(module.parser.asset).dataUrlCondition,
+			"maxSize",
+			8096
+		);
 	}
 
 	F(module.parser, "javascript", () => ({}));
-	applyJavascriptParserOptionsDefaults(module.parser.javascript, {
-		futureDefaults,
-		isNode
-	});
+
+	applyJavascriptParserOptionsDefaults(
+		/** @type {NonNullable<ParserOptionsByModuleTypeKnown["javascript"]>} */
+		(module.parser.javascript),
+		{
+			futureDefaults,
+			isNode
+		}
+	);
 
 	A(module, "defaultRules", () => {
 		const esm = {
-			type: "javascript/esm",
+			type: JAVASCRIPT_MODULE_TYPE_ESM,
 			resolve: {
 				byDependency: {
 					esm: {
@@ -527,21 +619,21 @@ const applyModuleDefaults = (
 			}
 		};
 		const commonjs = {
-			type: "javascript/dynamic"
+			type: JAVASCRIPT_MODULE_TYPE_DYNAMIC
 		};
 		/** @type {RuleSetRules} */
 		const rules = [
 			{
 				mimetype: "application/node",
-				type: "javascript/auto"
+				type: JAVASCRIPT_MODULE_TYPE_AUTO
 			},
 			{
 				test: /\.json$/i,
-				type: "json"
+				type: JSON_MODULE_TYPE
 			},
 			{
 				mimetype: "application/json",
-				type: "json"
+				type: JSON_MODULE_TYPE
 			},
 			{
 				test: /\.mjs$/i,
@@ -574,7 +666,7 @@ const applyModuleDefaults = (
 		];
 		if (asyncWebAssembly) {
 			const wasm = {
-				type: "webassembly/async",
+				type: WEBASSEMBLY_MODULE_TYPE_ASYNC,
 				rules: [
 					{
 						descriptionData: {
@@ -596,7 +688,7 @@ const applyModuleDefaults = (
 			});
 		} else if (syncWebAssembly) {
 			const wasm = {
-				type: "webassembly/sync",
+				type: WEBASSEMBLY_MODULE_TYPE_SYNC,
 				rules: [
 					{
 						descriptionData: {
@@ -618,38 +710,24 @@ const applyModuleDefaults = (
 			});
 		}
 		if (css) {
-			const cssRule = {
-				type: "css",
-				resolve: {
-					fullySpecified: true,
-					preferRelative: true
-				}
-			};
-			const cssModulesRule = {
-				type: "css/module",
-				resolve: {
-					fullySpecified: true
-				}
+			const resolve = {
+				fullySpecified: true,
+				preferRelative: true
 			};
 			rules.push({
 				test: /\.css$/i,
-				oneOf: [
-					{
-						test: /\.module\.css$/i,
-						...cssModulesRule
-					},
-					{
-						...cssRule
-					}
-				]
+				type: CSS_MODULE_TYPE_AUTO,
+				resolve
 			});
 			rules.push({
 				mimetype: "text/css+module",
-				...cssModulesRule
+				type: CSS_MODULE_TYPE_MODULE,
+				resolve
 			});
 			rules.push({
 				mimetype: "text/css",
-				...cssRule
+				type: CSS_MODULE_TYPE,
+				resolve
 			});
 		}
 		rules.push(
@@ -667,7 +745,7 @@ const applyModuleDefaults = (
 			},
 			{
 				assert: { type: "json" },
-				type: "json"
+				type: JSON_MODULE_TYPE
 			}
 		);
 		return rules;
@@ -711,7 +789,7 @@ const applyOutputDefaults = (
 			!Array.isArray(library) &&
 			"type" in library
 				? library.name
-				: /** @type {LibraryName=} */ (library);
+				: /** @type {LibraryName} */ (library);
 		if (Array.isArray(libraryName)) {
 			return libraryName.join(".");
 		} else if (typeof libraryName === "object") {
@@ -738,8 +816,11 @@ const applyOutputDefaults = (
 			const packageInfo = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
 			return packageInfo.name || "";
 		} catch (e) {
-			if (e.code !== "ENOENT") {
-				e.message += `\nwhile determining default 'output.uniqueName' from 'name' in ${pkgPath}`;
+			if (/** @type {Error & { code: string }} */ (e).code !== "ENOENT") {
+				/** @type {Error & { code: string }} */
+				(
+					e
+				).message += `\nwhile determining default 'output.uniqueName' from 'name' in ${pkgPath}`;
 				throw e;
 			}
 			return "";
@@ -752,7 +833,9 @@ const applyOutputDefaults = (
 	D(output, "importFunctionName", "import");
 	D(output, "importMetaName", "import.meta");
 	F(output, "chunkFilename", () => {
-		const filename = output.filename;
+		const filename =
+			/** @type {NonNullable<Output["chunkFilename"]>} */
+			(output.filename);
 		if (typeof filename !== "function") {
 			const hasName = filename.includes("[name]");
 			const hasId = filename.includes("[id]");
@@ -766,14 +849,18 @@ const applyOutputDefaults = (
 		return output.module ? "[id].mjs" : "[id].js";
 	});
 	F(output, "cssFilename", () => {
-		const filename = output.filename;
+		const filename =
+			/** @type {NonNullable<Output["cssFilename"]>} */
+			(output.filename);
 		if (typeof filename !== "function") {
 			return filename.replace(/\.[mc]?js(\?|$)/, ".css$1");
 		}
 		return "[id].css";
 	});
 	F(output, "cssChunkFilename", () => {
-		const chunkFilename = output.chunkFilename;
+		const chunkFilename =
+			/** @type {NonNullable<Output["cssChunkFilename"]>} */
+			(output.chunkFilename);
 		if (typeof chunkFilename !== "function") {
 			return chunkFilename.replace(/\.[mc]?js(\?|$)/, ".css$1");
 		}
@@ -785,12 +872,18 @@ const applyOutputDefaults = (
 	D(output, "charset", true);
 	F(output, "hotUpdateGlobal", () =>
 		Template.toIdentifier(
-			"webpackHotUpdate" + Template.toIdentifier(output.uniqueName)
+			"webpackHotUpdate" +
+				Template.toIdentifier(
+					/** @type {NonNullable<Output["uniqueName"]>} */ (output.uniqueName)
+				)
 		)
 	);
 	F(output, "chunkLoadingGlobal", () =>
 		Template.toIdentifier(
-			"webpackChunk" + Template.toIdentifier(output.uniqueName)
+			"webpackChunk" +
+				Template.toIdentifier(
+					/** @type {NonNullable<Output["uniqueName"]>} */ (output.uniqueName)
+				)
 		)
 	);
 	F(output, "globalObject", () => {
@@ -916,32 +1009,87 @@ const applyOutputDefaults = (
 			? "auto"
 			: ""
 	);
+	D(output, "workerPublicPath", "");
 	D(output, "chunkLoadTimeout", 120000);
 	D(output, "hashFunction", futureDefaults ? "xxhash64" : "md4");
 	D(output, "hashDigest", "hex");
 	D(output, "hashDigestLength", futureDefaults ? 16 : 20);
 	D(output, "strictModuleExceptionHandling", false);
 
+	const environment = /** @type {Environment} */ (output.environment);
+	/**
+	 * @param {boolean | undefined} v value
+	 * @returns {boolean} true, when v is truthy or undefined
+	 */
 	const optimistic = v => v || v === undefined;
+	/**
+	 * @param {boolean | undefined} v value
+	 * @param {boolean | undefined} c condition
+	 * @returns {boolean | undefined} true, when v is truthy or undefined, or c is truthy
+	 */
 	const conditionallyOptimistic = (v, c) => (v === undefined && c) || v;
+
+	F(
+		environment,
+		"globalThis",
+		() => /** @type {boolean | undefined} */ (tp && tp.globalThis)
+	);
+	F(
+		environment,
+		"bigIntLiteral",
+		() => /** @type {boolean | undefined} */ (tp && tp.bigIntLiteral)
+	);
+	F(
+		environment,
+		"const",
+		() => tp && optimistic(/** @type {boolean | undefined} */ (tp.const))
+	);
 	F(
-		output.environment,
+		environment,
 		"arrowFunction",
-		() => tp && optimistic(tp.arrowFunction)
+		() =>
+			tp && optimistic(/** @type {boolean | undefined} */ (tp.arrowFunction))
 	);
-	F(output.environment, "const", () => tp && optimistic(tp.const));
 	F(
-		output.environment,
+		environment,
+		"forOf",
+		() => tp && optimistic(/** @type {boolean | undefined} */ (tp.forOf))
+	);
+	F(
+		environment,
 		"destructuring",
-		() => tp && optimistic(tp.destructuring)
+		() =>
+			tp && optimistic(/** @type {boolean | undefined} */ (tp.destructuring))
 	);
-	F(output.environment, "forOf", () => tp && optimistic(tp.forOf));
-	F(output.environment, "bigIntLiteral", () => tp && tp.bigIntLiteral);
-	F(output.environment, "dynamicImport", () =>
-		conditionallyOptimistic(tp && tp.dynamicImport, output.module)
+	F(
+		environment,
+		"optionalChaining",
+		() =>
+			tp && optimistic(/** @type {boolean | undefined} */ (tp.optionalChaining))
+	);
+	F(
+		environment,
+		"templateLiteral",
+		() =>
+			tp && optimistic(/** @type {boolean | undefined} */ (tp.templateLiteral))
+	);
+	F(environment, "dynamicImport", () =>
+		conditionallyOptimistic(
+			/** @type {boolean | undefined} */ (tp && tp.dynamicImport),
+			output.module
+		)
+	);
+	F(environment, "dynamicImportInWorker", () =>
+		conditionallyOptimistic(
+			/** @type {boolean | undefined} */ (tp && tp.dynamicImportInWorker),
+			output.module
+		)
 	);
-	F(output.environment, "module", () =>
-		conditionallyOptimistic(tp && tp.module, output.module)
+	F(environment, "module", () =>
+		conditionallyOptimistic(
+			/** @type {boolean | undefined} */ (tp && tp.module),
+			output.module
+		)
 	);
 
 	const { trustedTypes } = output;
@@ -950,8 +1098,10 @@ const applyOutputDefaults = (
 			trustedTypes,
 			"policyName",
 			() =>
-				output.uniqueName.replace(/[^a-zA-Z0-9\-#=_/@.%]+/g, "_") || "webpack"
+				/** @type {NonNullable<Output["uniqueName"]>} */
+				(output.uniqueName).replace(/[^a-zA-Z0-9\-#=_/@.%]+/g, "_") || "webpack"
 		);
+		D(trustedTypes, "onPolicyCreationFailure", "stop");
 	}
 
 	/**
@@ -960,10 +1110,11 @@ const applyOutputDefaults = (
 	 */
 	const forEachEntry = fn => {
 		for (const name of Object.keys(entry)) {
-			fn(entry[name]);
+			fn(/** @type {{[k: string] : EntryDescription}} */ (entry)[name]);
 		}
 	};
 	A(output, "enabledLibraryTypes", () => {
+		/** @type {LibraryType[]} */
 		const enabledLibraryTypes = [];
 		if (output.library) {
 			enabledLibraryTypes.push(output.library.type);
@@ -1023,35 +1174,56 @@ const applyExternalsPresetsDefaults = (
 	D(
 		externalsPresets,
 		"web",
-		!buildHttp && targetProperties && targetProperties.web
+		/** @type {boolean | undefined} */
+		(!buildHttp && targetProperties && targetProperties.web)
+	);
+	D(
+		externalsPresets,
+		"node",
+		/** @type {boolean | undefined} */
+		(targetProperties && targetProperties.node)
+	);
+	D(
+		externalsPresets,
+		"nwjs",
+		/** @type {boolean | undefined} */
+		(targetProperties && targetProperties.nwjs)
 	);
-	D(externalsPresets, "node", targetProperties && targetProperties.node);
-	D(externalsPresets, "nwjs", targetProperties && targetProperties.nwjs);
 	D(
 		externalsPresets,
 		"electron",
-		targetProperties && targetProperties.electron
+		/** @type {boolean | undefined} */
+		(targetProperties && targetProperties.electron)
 	);
 	D(
 		externalsPresets,
 		"electronMain",
-		targetProperties &&
-			targetProperties.electron &&
-			targetProperties.electronMain
+		/** @type {boolean | undefined} */
+		(
+			targetProperties &&
+				targetProperties.electron &&
+				targetProperties.electronMain
+		)
 	);
 	D(
 		externalsPresets,
 		"electronPreload",
-		targetProperties &&
-			targetProperties.electron &&
-			targetProperties.electronPreload
+		/** @type {boolean | undefined} */
+		(
+			targetProperties &&
+				targetProperties.electron &&
+				targetProperties.electronPreload
+		)
 	);
 	D(
 		externalsPresets,
 		"electronRenderer",
-		targetProperties &&
-			targetProperties.electron &&
-			targetProperties.electronRenderer
+		/** @type {boolean | undefined} */
+		(
+			targetProperties &&
+				targetProperties.electron &&
+				targetProperties.electronRenderer
+		)
 	);
 };
 
@@ -1059,9 +1231,10 @@ const applyExternalsPresetsDefaults = (
  * @param {Loader} loader options
  * @param {Object} options options
  * @param {TargetProperties | false} options.targetProperties target properties
+ * @param {Environment} options.environment environment
  * @returns {void}
  */
-const applyLoaderDefaults = (loader, { targetProperties }) => {
+const applyLoaderDefaults = (loader, { targetProperties, environment }) => {
 	F(loader, "target", () => {
 		if (targetProperties) {
 			if (targetProperties.electron) {
@@ -1075,6 +1248,7 @@ const applyLoaderDefaults = (loader, { targetProperties }) => {
 			if (targetProperties.web) return "web";
 		}
 	});
+	D(loader, "environment", environment);
 };
 
 /**
@@ -1192,7 +1366,9 @@ const applyOptimizationDefaults = (
 		F(splitChunks, "maxAsyncRequests", () => (production ? 30 : Infinity));
 		F(splitChunks, "maxInitialRequests", () => (production ? 30 : Infinity));
 		D(splitChunks, "automaticNameDelimiter", "-");
-		const { cacheGroups } = splitChunks;
+		const cacheGroups =
+			/** @type {NonNullable<OptimizationSplitChunksOptions["cacheGroups"]>} */
+			(splitChunks.cacheGroups);
 		F(cacheGroups, "default", () => ({
 			idHint: "",
 			reuseExistingChunk: true,
@@ -1214,9 +1390,16 @@ const applyOptimizationDefaults = (
  * @param {string} options.context build context
  * @param {TargetProperties | false} options.targetProperties target properties
  * @param {Mode} options.mode mode
+ * @param {CssExperimentOptions|false} options.css is css enabled
  * @returns {ResolveOptions} resolve options
  */
-const getResolveDefaults = ({ cache, context, targetProperties, mode }) => {
+const getResolveDefaults = ({
+	cache,
+	context,
+	targetProperties,
+	mode,
+	css
+}) => {
 	/** @type {string[]} */
 	const conditions = ["webpack"];
 
@@ -1284,6 +1467,24 @@ const getResolveDefaults = ({ cache, context, targetProperties, mode }) => {
 		}
 	};
 
+	if (css) {
+		const styleConditions = [];
+
+		styleConditions.push("webpack");
+		styleConditions.push(mode === "development" ? "development" : "production");
+		styleConditions.push("style");
+
+		resolveOptions.byDependency["css-import"] = {
+			// 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
+			mainFiles: [],
+			mainFields: ["style", "..."],
+			conditionNames: styleConditions,
+			extensions: [".css"]
+		};
+	}
+
 	return resolveOptions;
 };