webpack 5.111.0 → 5.112.0

package/lib/config/defaults.js

@@ -11,7 +11,7 @@ const {
 	CSS_TYPE,
 	JAVASCRIPT_TYPE,
 	UNKNOWN_TYPE
-} = require("../ModuleSourceTypeConstants");
+} = require("../module/ModuleSourceTypeConstants");
 const {
 	ASSET_MODULE_TYPE,
 	ASSET_MODULE_TYPE_BYTES,
@@ -29,9 +29,9 @@ const {
 	JSON_MODULE_TYPE,
 	WEBASSEMBLY_MODULE_TYPE_ASYNC,
 	WEBASSEMBLY_MODULE_TYPE_SYNC
-} = require("../ModuleTypeConstants");
-const Template = require("../Template");
+} = require("../module/ModuleTypeConstants");
 const RuleSetCompiler = require("../rules/RuleSetCompiler");
+const Template = require("../template/Template");
 const { cleverMerge } = require("../util/cleverMerge");
 const {
 	getDefaultTarget,
@@ -79,7 +79,7 @@ const {
  * 	WebpackOptionsNormalized
  * } from "../../declarations/WebpackOptions"
  */
-/** @import Module from "../Module" */
+/** @import Module from "../module/Module" */
 /**
  * @import {
  * 	ChunkLoadingTypes
@@ -228,7 +228,7 @@ const {
 const NODE_MODULES_REGEXP = /[\\/]node_modules[\\/]/i;
 const DEFAULT_CACHE_NAME = "default";
 const DEFAULTS = {
-	// TODO webpack 6 - use xxhash64
+	// TODO in the next major release: use xxhash64
 	HASH_FUNCTION: "md4"
 };
 
@@ -386,7 +386,7 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 
 	F(options, "validate", () => !(futureDefaults === true && production));
 
-	// Progress lives on infrastructureLogging; webpack@6 shows the interactive
+	// Progress lives on infrastructureLogging; the next major release shows the interactive
 	// bar by default (`"auto"` = TTY only), webpack@5 stays opt-in.
 	D(options.infrastructureLogging, "progress", futureDefaults ? "auto" : false);
 
@@ -492,10 +492,9 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 		library: options.output.library
 	});
 
-	// `output.resourceHints.urlHints` shorthand: fan the project-wide rules out
-	// as the base `urlHints` of every URL-emitting parser (JS `new URL`, CSS
-	// `url()`, HTML `<img src>`). They go first so parser-scoped
-	// `parser.<type>.urlHints` rules — matched later, last-match-wins — override.
+	// `output.resourceHints.urlHints` fans the project-wide rules out as the base
+	// `urlHints` of every URL-emitting parser. They go first, so a parser-scoped
+	// rule matches later and wins.
 	const outputUrlHints =
 		options.output.resourceHints && options.output.resourceHints.urlHints;
 	if (outputUrlHints && outputUrlHints.length > 0) {
@@ -537,15 +536,19 @@ 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)
-			: options.output.module
-				? "module-import"
-				: "var";
+		const libraryType = options.output.library && options.output.library.type;
+		if (libraryType !== undefined) {
+			// The schema states which types are externals types, and reading it
+			// costs 498 KB of objects, so only a build naming one pays for that.
+			const validExternalTypes = require("../../schemas/WebpackOptions.json")
+				.definitions.ExternalsType.enum;
+
+			if (validExternalTypes.includes(libraryType)) {
+				return /** @type {ExternalsType} */ (libraryType);
+			}
+		}
+
+		return options.output.module ? "module-import" : "var";
 	});
 
 	applyNodeDefaults(options.node, {
@@ -576,9 +579,14 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 	applyOptimizationDefaults(options.optimization, {
 		development,
 		production,
+		futureDefaults,
 		css:
 			/** @type {boolean} */
 			(options.experiments.css),
+		esmLibrary:
+			/** @type {string[]} */
+			(options.output.enabledLibraryTypes).length > 0 &&
+			Boolean(options.output.module),
 		records: Boolean(options.recordsInputPath || options.recordsOutputPath)
 	});
 
@@ -642,7 +650,7 @@ const applyExperimentsDefaults = (
 ) => {
 	D(experiments, "futureDefaults", false);
 	D(experiments, "backCompat", !experiments.futureDefaults);
-	// TODO do we need sync web assembly in webpack@6?
+	// TODO in the next major release: do we need sync web assembly?
 	D(experiments, "syncWebAssembly", false);
 	D(
 		experiments,
@@ -660,15 +668,13 @@ const applyExperimentsDefaults = (
 		experiments.futureDefaults ? true : "auto"
 	);
 
-	// Resolve the "auto" default: enable the built-in css/html module type unless
-	// the user already registered a loader (or explicit type) for these files, so
-	// enabling them by default does not break existing css-loader/html-loader setups.
-	// The built-in `/\.css$/i` rule also covers `.module.css`, so a loader scoped to
-	// CSS modules must disable the built-in type too — sample both extensions.
-	// When enabled implicitly the value stays `"auto"` (truthy): Css/HtmlModulesPlugin
-	// then step aside per-module for requests that loaders were applied to
-	// (inline requests or loaders injected via hooks, e.g. html-webpack-plugin).
-	// TODO webpack 6: css/html default to `true`, drop the `"auto"` marker.
+	// Resolve `"auto"`: enable the built-in type unless a loader is already
+	// registered for these files, so the default breaks no existing setup. Both
+	// extensions are sampled, since `/\.css$/i` also covers `.module.css`.
+
+	// Enabled implicitly the value stays `"auto"`, and the plugins then step
+	// aside per module for requests loaders were applied to.
+	// TODO in the next major release: css/html/asyncWebAssembly default to `true`, drop the `"auto"` marker.
 	if (experiments.css === "auto") {
 		experiments.css =
 			!(
@@ -697,7 +703,8 @@ const applyExperimentsDefaults = (
 	if (experiments.asyncWebAssembly === "auto") {
 		experiments.asyncWebAssembly =
 			!experiments.syncWebAssembly &&
-			!RuleSetCompiler.hasRuleForResource(rules, "/file.wasm");
+			!RuleSetCompiler.hasRuleForResource(rules, "/file.wasm") &&
+			"auto";
 	}
 
 	if (typeof experiments.buildHttp === "object") {
@@ -779,7 +786,12 @@ const applyCacheDefaults = (
 				/** @type {NonNullable<FileCacheOptions["buildDependencies"]>} */
 				(cache.buildDependencies),
 				"defaultWebpack",
-				[path.resolve(__dirname, "..") + path.sep]
+				[
+					{
+						dependency: path.resolve(__dirname, "..") + path.sep,
+						optional: false
+					}
+				]
 			);
 			break;
 		case "memory":
@@ -1227,18 +1239,13 @@ const applyModuleDefaults = (
 	}
 
 	if (html) {
-		// `module.generator.html.extract` is intentionally left undefined by
-		// default: HtmlGenerator treats undefined as "extract iff this HTML
-		// module is a compilation entry", which is the HTML-entry-point
-		// behaviour. Setting `extract: true` forces extraction for all HTML
-		// modules (including imported ones); `extract: false` disables it
-		// everywhere.
+		// `extract` is deliberately left undefined, which HtmlGenerator reads as
+		// "extract only a module that is a compilation entry". `true` forces it for
+		// imported modules too, `false` disables it everywhere.
 		F(module.generator, HTML_MODULE_TYPE, () => ({}));
-		// `module.parser.html.sources` defaults to `true` — HtmlParser uses
-		// the built-in source list to extract URL-like attributes (`<img
-		// src>`, `<link href>`, `<script src>`, …) as webpack dependencies.
-		// Users may pass `false` to disable extraction entirely or an array
-		// (with `"..."` to include the defaults) to customize it.
+		// `sources` defaults to `true`, so HtmlParser extracts URL-like attributes
+		// as dependencies from its built-in list. `false` disables extraction, and
+		// an array customizes it, with `"..."` keeping the defaults.
 		F(module.parser, HTML_MODULE_TYPE, () => ({}));
 		D(
 			/** @type {NonNullable<ParserOptionsByModuleTypeKnown[HTML_MODULE_TYPE]>} */
@@ -1372,11 +1379,9 @@ const applyModuleDefaults = (
 				type: CSS_MODULE_TYPE,
 				resolve
 			});
-			// For CSS modules, i.e. `.class { composes: className from "./style.css" }`
-			// We inherit for such constructions, but skip files that are already
-			// detected as CSS modules by extension (`.module.<ext>`) — they get
-			// the same modules-mode behavior from the auto rule, and forcing a
-			// different type stamp here would create a duplicate module instance.
+			// For `composes: className from "./style.css"`. A file already detected as
+			// a CSS module by extension is skipped: it gets modules mode from the auto
+			// rule anyway, and a second type stamp would duplicate the module.
 			const moduleExtension = /\.module\.\w+$/i;
 			rules.push({
 				dependency: /css-import-local-module/,
@@ -1426,11 +1431,9 @@ const applyModuleDefaults = (
 				type: HTML_MODULE_TYPE,
 				resolve
 			});
-			// `<iframe srcdoc>` content is fed back through the HTML pipeline as a
-			// `data:text/html` module. `extract: "inline"` exposes the processed
-			// HTML on the `html` codegen channel that `HtmlInlineHtmlDependency.
-			// Template` reads back into the attribute, without emitting a standalone
-			// `.html` file (the module is never a page on its own).
+			// `<iframe srcdoc>` content goes back through the HTML pipeline as a
+			// `data:text/html` module. `extract: "inline"` exposes it on the `html`
+			// channel without emitting a file: it is never a page on its own.
 			rules.push({
 				dependency: "html-srcdoc",
 				generator: {
@@ -1439,12 +1442,9 @@ const applyModuleDefaults = (
 				resolve
 			});
 			if (css) {
-				// Inline `<style>` content in an HTML module is fed into the
-				// CSS pipeline as a `data:text/css` virtual module. We force
-				// `exportType: "text"` so the CSS module exposes the
-				// processed CSS text on the `css-text` codegen channel that
-				// `HtmlInlineStyleDependency.Template` reads back into the
-				// `<style>` tag.
+				// Inline `<style>` content goes into the CSS pipeline as a
+				// `data:text/css` module. `exportType: "text"` is forced, so the
+				// processed text reaches the `css-text` channel the template reads.
 				rules.push({
 					dependency: "html-style",
 					parser: {
@@ -1702,7 +1702,7 @@ const applyOutputDefaults = (
 			((tp.node === null && tp.web === null && tp.module !== false) ||
 				tp.deno === true ||
 				tp.bun === true ||
-				// webpack@6 emits ESM wherever the target reads one — a browserslist
+				// the next major release emits ESM wherever the target reads one — a browserslist
 				// query (or `esX`/`nodeX`) without ESM support keeps script output
 				(futureDefaults && tp.module !== false && !hasScriptLibrary))
 		)
@@ -1750,12 +1750,11 @@ const applyOutputDefaults = (
 		"const",
 		() => tp && optimistic(/** @type {boolean | undefined} */ (tp.const))
 	);
-	// Only the browserslist target reports these; everywhere else they stay
-	// unset, which `optimistic` reads as the modern spelling being available —
-	// the same policy the JS features above follow.
-	// `let` was added after `const`; targets predating it report only `const`,
-	// so fall back to `const` when `let` is unreported (undefined). Targets that
-	// do report `let` (browserslist, built-ins) keep their own accurate value.
+	// Only the browserslist target reports these; unset elsewhere, which
+	// `optimistic` reads as the modern spelling being available.
+
+	// `let` was added after `const`, so a target predating it reports only
+	// `const` and falls back to it. One reporting `let` keeps its own value.
 	F(environment, "let", () =>
 		conditionallyOptimistic(
 			/** @type {boolean | undefined} */ (tp && tp.let),
@@ -1887,10 +1886,9 @@ const applyOutputDefaults = (
 			tp && optimistic(/** @type {boolean | undefined} */ (tp.modulePreload))
 	);
 
-	// Vite-style default for ESM output (`output.module`): preload the entry's
-	// initial dependency graph, which native `import()` would otherwise fetch in
-	// a waterfall. Classic output loads initial chunks via parallel `<script>`
-	// tags (no waterfall), so it stays opt-in.
+	// For ESM output, preload the entry's initial dependency graph, which native
+	// `import()` would otherwise fetch in a waterfall. Classic output loads its
+	// initial chunks in parallel already, so it stays opt-in.
 	if (output.module && output.resourceHints === undefined) {
 		output.resourceHints = {};
 	}
@@ -1944,13 +1942,9 @@ const applyOutputDefaults = (
 		}
 		return "[id].css";
 	});
-	// Derive html filename defaults from `output.filename` / `output.chunkFilename`
-	// (the same shape the CSS pipeline uses), but if the derived template lacks
-	// any per-module differentiator, fall back to `[name].html` so multiple
-	// extracted HTML modules in one compilation don't collide on the same
-	// emitted file. For example: `output.filename: "bundle.js"` would derive
-	// `bundle.html` — two `.html` modules extracted in the same build would
-	// both want that name and conflict at emit time.
+	// Derive the html filenames from `output.filename`, as the CSS pipeline does.
+	// A derived template with no per-module placeholder falls back to
+	// `[name].html`, or two extracted modules would want the same file.
 	const HAS_PATH_PLACEHOLDER_REGEXP =
 		/\[(name|id|chunkhash|contenthash|fullhash|hash)/;
 	/**
@@ -1997,11 +1991,9 @@ const applyOutputDefaults = (
 		if (tp) {
 			if (tp.global) return "global";
 			if (tp.globalThis) return "globalThis";
-			// Universal target (web + node): no one identifier is defined on both
-			// sides, so `globalThis` where the target reports nothing against it,
-			// and a guarded pair where it does — `self` covers window and worker
-			// scopes, `global` covers Node.js. Naming either alone leaves the other
-			// platform reading an undeclared binding.
+			// A universal target has no identifier defined on both sides, so this is
+			// `globalThis` where nothing argues against it and a guarded pair where
+			// something does: naming one alone leaves the other undeclared.
 			if (tp.web === null && tp.node === null) {
 				return tp.globalThis === undefined
 					? "globalThis"
@@ -2391,7 +2383,7 @@ const applyNodeDefaults = (
 	});
 
 	const handlerForNames = () => {
-		// TODO webpack@6 remove `node-module` in favor of `eval-only`
+		// TODO in the next major release: remove `node-module` in favor of `eval-only`
 		if (targetProperties) {
 			if (targetProperties.node) {
 				return "eval-only";
@@ -2407,7 +2399,7 @@ const applyNodeDefaults = (
 			}
 		}
 
-		// TODO webpack@6 should we use `warn-even-only`?
+		// TODO in the next major release: should we use `warn-even-only`?
 		return futureDefaults ? "warn-mock" : "mock";
 	};
 
@@ -2467,12 +2459,14 @@ const applyPerformanceDefaults = (performance, { production }) => {
  * @param {boolean} options.production is production
  * @param {boolean} options.development is development
  * @param {boolean} options.css is css enabled
+ * @param {boolean} options.esmLibrary whether the output is an ECMAScript module consumed as a library
  * @param {boolean} options.records using records
+ * @param {boolean} options.futureDefaults use defaults of the next major version
  * @returns {void}
  */
 const applyOptimizationDefaults = (
 	optimization,
-	{ production, development, css, records }
+	{ production, development, css, esmLibrary, records, futureDefaults }
 ) => {
 	D(optimization, "removeAvailableModules", false);
 	D(optimization, "removeEmptyChunks", true);
@@ -2519,31 +2513,40 @@ const applyOptimizationDefaults = (
 		/** @type {NonNullable<Optimization["minimizeOptions"]>} */
 		(optimization.minimizeOptions);
 	if (optimization.minimize) {
-		// Canonicalize the per-asset-type options: the JS minimizer's defaults
-		// become visible in the resolved config rather than hidden in the wiring.
-		F(minimizeOptions, "javascript", () => ({ compress: { passes: 2 } }));
+		// Only ESM output carries these annotations, and only a consumer that
+		// re-bundles it reads them; terser drops them everywhere else, which is
+		// what a script-loaded output — a federation container — wants.
+		F(minimizeOptions, "javascript", () =>
+			esmLibrary
+				? {
+						compress: { passes: 2 },
+						// eslint-disable-next-line camelcase
+						format: { preserve_annotations: true }
+					}
+				: { compress: { passes: 2 } }
+		);
 		F(minimizeOptions, "css", () => ({}));
 		F(minimizeOptions, "html", () => ({}));
+		D(minimizeOptions, "json", futureDefaults);
+		if (futureDefaults) F(minimizeOptions, "xml", () => ({}));
 	}
 	A(optimization, "minimizer", () => [
 		{
 			apply: (compiler) => {
 				// Lazy load the minimizer plugin
-				const TerserPlugin = require("minimizer-webpack-plugin");
-
-				// One minimizer instance (one worker-thread pool) handles JS and, when
-				// native CSS / HTML is enabled, those assets too — an array of minify
-				// functions each dispatched by its own `filter` (terser -> JS,
-				// cssMinify -> CSS, htmlMinify -> HTML). The CSS / HTML serializers stay
-				// worker-safe by resolving their parser with `require("webpack/…")` in
-				// the worker, so all three share the same pool. `test` is widened to let
-				// CSS / HTML assets reach the dispatcher.
-				// Step aside for a minimizer the user already configured for these
-				// types: whichever of the two ran first would mark the asset
-				// `minimized` and silently disable the other, so webpack only claims
-				// what nothing else does. Their asset matchers are read directly rather
-				// than resolved per asset — a coarse check, but it keeps the outcome
-				// independent of tap order and of the plugin version in use.
+				const MinimizerPlugin = require("minimizer-webpack-plugin");
+
+				// WHY: one minimizer instance, so one worker-thread pool, handles JS and
+				// — where native CSS and HTML are enabled — those assets too, as an array
+				// of minify functions each dispatched by its own `filter`: the JS one
+				// to JS, `cssMinify` to CSS, `htmlMinify` to HTML. The CSS and
+				// HTML serializers stay worker-safe by resolving their parser with
+				// `require("webpack/…")` in the worker, so all three share the pool, and
+				// `test` is widened to let those assets reach the dispatcher.
+
+				// Step aside for a minimizer the user configured for these types:
+				// whichever ran first would mark the asset `minimized` and silently
+				// disable the other. Matchers are read directly, coarse but stable.
 				const claimedByOtherMinimizer = require("./getClaimedAssetTypes")(
 					compiler
 				);
@@ -2552,9 +2555,18 @@ const applyOptimizationDefaults = (
 				const minimizeByType = /** @type {OptimizationMinimizeOptions} */ (
 					compiler.options.optimization.minimizeOptions
 				);
-				const terserOptions = minimizeByType.javascript || {
+				const javascriptOptions = minimizeByType.javascript || {
 					compress: { passes: 2 }
 				};
+				// webpack's printer, held to what terser writes, replaces terser; until
+				// proven on real builds it is a future default, and terser as the plugin
+				// publishes it minifies JS everywhere else.
+				const javascriptMinify = futureDefaults
+					? require.resolve("../javascript/jsMinify")
+					: {
+							path: require.resolve("minimizer-webpack-plugin"),
+							export: "terserMinify"
+						};
 
 				const { css, html } = compiler.options.experiments;
 				const minifyJs = minimizeByType.javascript !== false;
@@ -2566,16 +2578,47 @@ const applyOptimizationDefaults = (
 					Boolean(html) &&
 					!claimedByOtherMinimizer.html &&
 					minimizeByType.html !== false;
-				if (!minifyJs && !minifyCss && !minifyHtml) return;
-				if (minifyJs && !minifyCss && !minifyHtml) {
-					new TerserPlugin({ terserOptions }).apply(
-						/** @type {EXPECTED_ANY} */ (compiler)
-					);
+				// `=== true` rather than `!== false`: outside `futureDefaults`, JSON is opt-in.
+				const minifyJson =
+					minimizeByType.json === true && !claimedByOtherMinimizer.json;
+				// Off unless asked for: only an object, which futureDefaults supplies.
+				const minifyXml =
+					!claimedByOtherMinimizer.xml &&
+					typeof minimizeByType.xml === "object";
+				if (
+					!minifyJs &&
+					!minifyCss &&
+					!minifyHtml &&
+					!minifyJson &&
+					!minifyXml
+				) {
 					return;
 				}
-				/** @type {(typeof TerserPlugin.terserMinify | typeof import("../css/cssMinify") | typeof import("../html/htmlMinify"))[]} */
+				// An asset name keeps the query and the fragment its filename template
+				// wrote (`[query][fragment]`, `main.js#[contenthash]`), so both may follow.
+				/**
+				 * @param {string[]} extensions extension patterns
+				 * @returns {RegExp} matcher for asset names with those extensions
+				 */
+				const assetNameTest = (extensions) =>
+					new RegExp(`^[^?#]*\\.(?:${extensions.join("|")})(?:[?#].*)?$`, "i");
+				if (
+					minifyJs &&
+					!minifyCss &&
+					!minifyHtml &&
+					!minifyJson &&
+					!minifyXml
+				) {
+					new MinimizerPlugin({
+						test: assetNameTest(["[cm]?js"]),
+						minify: javascriptMinify,
+						minimizerOptions: javascriptOptions
+					}).apply(/** @type {EXPECTED_ANY} */ (compiler));
+					return;
+				}
+				/** @type {(typeof javascriptMinify | string)[]} */
 				const minify = [];
-				/** @type {EXPECTED_OBJECT[]} */
+				/** @type {(typeof javascriptOptions | NonNullable<Parameters<typeof import("../css/cssMinify")>[1]> | NonNullable<Parameters<typeof import("../html/htmlMinify")>[1]> | Record<string, never>)[]} */
 				const minimizerOptions = [];
 				/** @type {string[]} */
 				const extensions = [];
@@ -2589,12 +2632,21 @@ const applyOptimizationDefaults = (
 				// prefixes and every spelling a target can read, so `vendorPrefixes`
 				// turns off the first alone — resolving it is what the second needs.
 				const { target } = compiler.options;
-				const browsers = target
+				const context = /** @type {Context} */ (compiler.options.context);
+				const named = target
 					? getTargetsBrowsers(
 							Array.isArray(target) ? target : [target],
-							/** @type {Context} */ (compiler.options.context)
+							context
 						)
 					: undefined;
+				// A target naming no browsers is still served to some: browserslist's own
+				// `defaults` are them, where none would read as "every current engine" —
+				// unless `dropOverriddenDeclarations` asks for exactly that assumption.
+				const browsers =
+					named ||
+					(cssOptions !== undefined && cssOptions.dropOverriddenDeclarations
+						? undefined
+						: getTargetsBrowsers(["browserslist:defaults"], context));
 				const cssEnvironment = {
 					browsers,
 					vendorPrefixes:
@@ -2605,33 +2657,50 @@ const applyOptimizationDefaults = (
 						? minimizeByType.html
 						: undefined;
 				if (minifyJs) {
-					minify.push(TerserPlugin.terserMinify);
-					minimizerOptions.push(terserOptions);
+					minify.push(javascriptMinify);
+					minimizerOptions.push(javascriptOptions);
 					extensions.push("[cm]?js");
 				}
 				if (minifyCss) {
-					minify.push(require("../css/cssMinify"));
+					minify.push(require.resolve("../css/cssMinify"));
+					// An SVG `data:` URL is minified as the `.svg` assets are, or left alone.
 					minimizerOptions.push({
 						environment: cssEnvironment,
+						svg: minifyXml,
 						...cssOptions
 					});
 					extensions.push("css");
 				}
 				if (minifyHtml) {
-					minify.push(require("../html/htmlMinify"));
-					// `minimize.css` rides along under its own key rather than spread
-					// beside the HTML options: the two name some of the same switches
-					// (`quotes`, `comments`), and one flat object would hand
-					// each language the other's answer.
+					minify.push(require.resolve("../html/htmlMinify"));
+					// `minimize.css` rides under its own key rather than spread beside the
+					// HTML options: the two name some of the same switches, so one flat
+					// object would hand each language the other's answer.
 					minimizerOptions.push({
 						environment: cssEnvironment,
 						css: cssOptions,
+						svg: minifyXml,
 						...htmlOptions
 					});
 					extensions.push("html");
 				}
-				new TerserPlugin({
-					test: new RegExp(`\\.(?:${extensions.join("|")})(\\?.*)?$`, "i"),
+				if (minifyJson) {
+					minify.push(require.resolve("../json/jsonMinify"));
+					minimizerOptions.push({});
+					// A web app manifest is JSON under its own extension.
+					extensions.push("json", "webmanifest");
+				}
+				if (minifyXml) {
+					minify.push(require.resolve("../html/xmlMinify"));
+					minimizerOptions.push({
+						environment: cssEnvironment,
+						css: cssOptions,
+						...minimizeByType.xml
+					});
+					extensions.push("svg", "xml");
+				}
+				new MinimizerPlugin({
+					test: assetNameTest(extensions),
 					minify,
 					minimizerOptions
 				}).apply(/** @type {EXPECTED_ANY} */ (compiler));
@@ -2651,6 +2720,7 @@ const applyOptimizationDefaults = (
 				: [JAVASCRIPT_TYPE, UNKNOWN_TYPE]
 		);
 		D(splitChunks, "hidePathInfo", production);
+		D(splitChunks, "dedupDepth", futureDefaults ? 1 : 0);
 		D(splitChunks, "chunks", "async");
 		D(splitChunks, "usedExports", optimization.usedExports === true);
 		D(splitChunks, "minChunks", 1);

package/lib/config/getClaimedAssetTypes.js

@@ -5,11 +5,11 @@
 
 "use strict";
 
-const { matchObject } = require("../ModuleFilenameHelpers");
+const { matchObject } = require("../devtool/ModuleFilenameHelpers");
 
 /** @import Compiler from "../Compiler" */
-/** @import { MatchObject } from "../ModuleFilenameHelpers" */
-/** @typedef {MatchObject & { minimizer?: EXPECTED_OBJECT }} MinimizerOptions */
+/** @import { MatchObject } from "../devtool/ModuleFilenameHelpers" */
+/** @typedef {MatchObject & { minimizer?: import("minimizer-webpack-plugin").InternalPluginOptions<EXPECTED_ANY>["minimizer"] }} MinimizerOptions */
 
 /**
  * @param {unknown} candidate a configured plugin or minimizer entry
@@ -17,24 +17,21 @@ const { matchObject } = require("../ModuleFilenameHelpers");
  * @returns {boolean} whether the candidate minimizes that file
  */
 const claims = (candidate, file) => {
-	// Every minimizer in the `minimizer-webpack-plugin` family (itself,
-	// `css-minimizer-webpack-plugin`, `html-minimizer-webpack-plugin`, …) keeps
-	// the minify implementation on `options.minimizer` and its asset matcher
-	// alongside it in the shape `matchObject` reads. The matcher alone is not
-	// enough to recognize one: `BannerPlugin` and `SourceMapDevToolPlugin` carry
-	// the same three keys, and `LoaderOptionsPlugin` defaults `test` to match
-	// every file — reading those as minimizers would disable minification.
+	// WHY: every minimizer in the `minimizer-webpack-plugin` family — itself,
+	// `css-minimizer-webpack-plugin`, `html-minimizer-webpack-plugin`, … — keeps
+	// its implementation on `options.minimizer` and its asset matcher alongside
+	// it, in the shape `matchObject` reads. The matcher alone is not enough to
+	// recognize one: `BannerPlugin` and `SourceMapDevToolPlugin` carry the same
+	// three keys, and `LoaderOptionsPlugin` defaults `test` to match every file,
+	// so reading those as minimizers would disable minification.
 	const { options } = /** @type {{ options?: MinimizerOptions }} */ (candidate);
 	if (!options || !options.minimizer) return false;
-	// `test`/`include` say which types it handles, `exclude` only narrows the
-	// files within them — honouring that narrowing would make a minimizer scoped
-	// to a subdirectory claim nothing, and webpack would then race it on the very
-	// files it was configured for.
+	// `test` and `include` say which types it handles, and the minimizer takes a
+	// file only when both match. `exclude` merely narrows the files within them:
+	// honoring it would let a subdirectory-scoped minimizer claim nothing.
 	const { test, include } = options;
-	return (
-		(test !== undefined && matchObject({ test }, file)) ||
-		(include !== undefined && matchObject({ include }, file))
-	);
+	if (test === undefined && include === undefined) return false;
+	return matchObject({ test, include }, file);
 };
 
 /**
@@ -45,12 +42,14 @@ const claims = (candidate, file) => {
  * matcher rather than resolving it per emitted asset, so a minimizer restricted
  * to some of a type's files still claims the whole type.
  * @param {Compiler} compiler the compiler
- * @returns {{ css: boolean, html: boolean }} types another minimizer handles
+ * @returns {{ css: boolean, html: boolean, json: boolean, xml: boolean }} types another minimizer handles
  */
 module.exports = (compiler) => {
 	const { optimization, plugins } = compiler.options;
 	let css = false;
 	let html = false;
+	let json = false;
+	let xml = false;
 	// Both lists are normalized arrays with falsy entries already filtered out,
 	// and `minimizer` was filled in by the defaults before any plugin applies.
 	const minimizer =
@@ -59,7 +58,15 @@ module.exports = (compiler) => {
 	for (const candidate of [...minimizer, ...plugins]) {
 		if (!css) css = claims(candidate, "file.css");
 		if (!html) html = claims(candidate, "file.html");
-		if (css && html) break;
+		// The JSON minifier takes web app manifests too, so claiming either stops it.
+		if (!json) {
+			json =
+				claims(candidate, "file.json") || claims(candidate, "file.webmanifest");
+		}
+		if (!xml) {
+			xml = claims(candidate, "file.svg") || claims(candidate, "file.xml");
+		}
+		if (css && html && json && xml) break;
 	}
-	return { css, html };
+	return { css, html, json, xml };
 };