@depup/webpack 5.111.1-depup.2 → 5.112.0-depup.0

package/lib/{WebpackOptionsDefaulter.js → config/WebpackOptionsDefaulter.js}

@@ -5,14 +5,14 @@
 
 "use strict";
 
-const { applyWebpackOptionsDefaults } = require("./config/defaults");
-const { getNormalizedWebpackOptions } = require("./config/normalization");
+const { applyWebpackOptionsDefaults } = require("./defaults");
+const { getNormalizedWebpackOptions } = require("./normalization");
 
 /**
  * @import {
  * 	WebpackOptions,
  * 	WebpackOptionsNormalized
- * } from "../declarations/WebpackOptions"
+ * } from "../../declarations/WebpackOptions"
  */
 
 class WebpackOptionsDefaulter {

package/lib/config/browserslistTargetHandler.js

@@ -122,7 +122,7 @@ const resolve = (browsers) => {
 				return Number(parsedMajor) >= requiredVersion;
 			}
 			return requiredVersion[0] === Number(parsedMajor)
-				? Number(parserMinor) >= requiredVersion[1]
+				? Number(parserMinor || 0) >= requiredVersion[1]
 				: Number(parsedMajor) > requiredVersion[0];
 		});
 	const anyNode = browsers.some((b) => b.startsWith("node "));

package/lib/{cli.js → config/cli.js}

@@ -6,10 +6,7 @@
 "use strict";
 
 const path = require("path");
-const tty = require("tty");
-const webpackSchema =
-	/** @type {EXPECTED_ANY} */
-	(require("../schemas/WebpackOptions.json"));
+const webpackSchema = require("../../schemas/WebpackOptions.json");
 
 /** @import { JSONSchema4, JSONSchema6, JSONSchema7 } from "json-schema" */
 /** @typedef {JSONSchema4 | JSONSchema6 | JSONSchema7} JSONSchema */
@@ -504,7 +501,9 @@ const getArguments = (schema = webpackSchema) => {
 	return flags;
 };
 
-/** @type {WeakMap<EXPECTED_OBJECT, number>} */
+/** @typedef {ObjectConfiguration | ParsedValue | undefined} ConfigurationValue */
+
+/** @type {WeakMap<ConfigurationValue[], number>} */
 const cliAddedItems = new WeakMap();
 
 /** @typedef {string | number} Property */
@@ -522,7 +521,7 @@ const isUnsafeKey = (name) =>
  * @param {ObjectConfiguration} config configuration
  * @param {string} schemaPath path in the config
  * @param {number | undefined} index index of value when multiple values are provided, otherwise undefined
- * @returns {{ problem?: LocalProblem, object?: ObjectConfiguration, property?: Property, value?: EXPECTED_OBJECT | EXPECTED_ANY[] }} problem or object with property and value
+ * @returns {{ problem?: LocalProblem, object?: ObjectConfiguration, property?: Property, value?: ConfigurationValue }} problem or object with property and value
  */
 const getObjectAndProperty = (config, schemaPath, index = 0) => {
 	if (!schemaPath) return { value: config };
@@ -825,157 +824,5 @@ const processArguments = (args, config, values) => {
 	return problems;
 };
 
-/**
- * Checks whether this object is color supported.
- * @returns {boolean} true when colors supported, otherwise false
- */
-const isColorSupported = () => {
-	const { env = {}, argv = [], platform = "" } = process;
-
-	// Read values instead of using `in`: Deno's and Bun's `process.env` honor
-	// property access but not the `in`/`has` trap, so `"X" in env` is unreliable.
-	const isDisabled = env.NO_COLOR !== undefined || argv.includes("--no-color");
-	const isForced = env.FORCE_COLOR !== undefined || argv.includes("--color");
-	const isWindows = platform === "win32";
-	const isDumbTerminal = env.TERM === "dumb";
-
-	const isCompatibleTerminal = tty.isatty(1) && env.TERM && !isDumbTerminal;
-
-	const isCI =
-		env.CI !== undefined &&
-		(env.GITHUB_ACTIONS !== undefined ||
-			env.GITLAB_CI !== undefined ||
-			env.CIRCLECI !== undefined);
-
-	return (
-		!isDisabled &&
-		(isForced || (isWindows && !isDumbTerminal) || isCompatibleTerminal || isCI)
-	);
-};
-
-/**
- * Returns result.
- * @param {number} index index
- * @param {string} string string
- * @param {string} close close
- * @param {string=} replace replace
- * @param {string=} head head
- * @param {string=} tail tail
- * @param {number=} next next
- * @returns {string} result
- */
-const replaceClose = (
-	index,
-	string,
-	close,
-	replace,
-	head = string.slice(0, Math.max(0, index)) + replace,
-	tail = string.slice(Math.max(0, index + close.length)),
-	next = tail.indexOf(close)
-) => head + (next < 0 ? tail : replaceClose(next, tail, close, replace));
-
-/**
- * Returns result.
- * @param {number} index index to replace
- * @param {string} string string
- * @param {string} open open string
- * @param {string} close close string
- * @param {string=} replace extra replace
- * @returns {string} result
- */
-const clearBleed = (index, string, open, close, replace) =>
-	index < 0
-		? open + string + close
-		: open + replaceClose(index, string, close, replace) + close;
-
-/** @typedef {(value: EXPECTED_ANY) => string} PrintFunction */
-
-/**
- * Returns function to create color.
- * @param {string} open open string
- * @param {string} close close string
- * @param {string=} replace extra replace
- * @param {number=} at at
- * @returns {PrintFunction} function to create color
- */
-const filterEmpty =
-	(open, close, replace = open, at = open.length + 1) =>
-	(string) =>
-		string || !(string === "" || string === undefined)
-			? clearBleed(`${string}`.indexOf(close, at), string, open, close, replace)
-			: "";
-
-/**
- * Returns result.
- * @param {number} open open code
- * @param {number} close close code
- * @param {string=} replace extra replace
- * @returns {PrintFunction} result
- */
-const init = (open, close, replace) =>
-	filterEmpty(`\u001B[${open}m`, `\u001B[${close}m`, replace);
-
-/**
- * Defines the colors type used by this module.
- * @typedef {{ reset: PrintFunction, bold: PrintFunction, dim: PrintFunction, italic: PrintFunction, underline: PrintFunction, inverse: PrintFunction, hidden: PrintFunction, strikethrough: PrintFunction, black: PrintFunction, red: PrintFunction, green: PrintFunction, yellow: PrintFunction, blue: PrintFunction, magenta: PrintFunction, cyan: PrintFunction, white: PrintFunction, gray: PrintFunction, bgBlack: PrintFunction, bgRed: PrintFunction, bgGreen: PrintFunction, bgYellow: PrintFunction, bgBlue: PrintFunction, bgMagenta: PrintFunction, bgCyan: PrintFunction, bgWhite: PrintFunction, blackBright: PrintFunction, redBright: PrintFunction, greenBright: PrintFunction, yellowBright: PrintFunction, blueBright: PrintFunction, magentaBright: PrintFunction, cyanBright: PrintFunction, whiteBright: PrintFunction, bgBlackBright: PrintFunction, bgRedBright: PrintFunction, bgGreenBright: PrintFunction, bgYellowBright: PrintFunction, bgBlueBright: PrintFunction, bgMagentaBright: PrintFunction, bgCyanBright: PrintFunction, bgWhiteBright: PrintFunction }} Colors
- */
-
-/**
- * Defines the colors options type used by this module.
- * @typedef {object} ColorsOptions
- * @property {boolean=} useColor force use colors
- */
-
-/**
- * Creates a colors from the provided colors option.
- * @param {ColorsOptions=} options options
- * @returns {Colors} colors
- */
-const createColors = ({ useColor = isColorSupported() } = {}) => ({
-	reset: useColor ? init(0, 0) : String,
-	bold: useColor ? init(1, 22, "\u001B[22m\u001B[1m") : String,
-	dim: useColor ? init(2, 22, "\u001B[22m\u001B[2m") : String,
-	italic: useColor ? init(3, 23) : String,
-	underline: useColor ? init(4, 24) : String,
-	inverse: useColor ? init(7, 27) : String,
-	hidden: useColor ? init(8, 28) : String,
-	strikethrough: useColor ? init(9, 29) : String,
-	black: useColor ? init(30, 39) : String,
-	red: useColor ? init(31, 39) : String,
-	green: useColor ? init(32, 39) : String,
-	yellow: useColor ? init(33, 39) : String,
-	blue: useColor ? init(34, 39) : String,
-	magenta: useColor ? init(35, 39) : String,
-	cyan: useColor ? init(36, 39) : String,
-	white: useColor ? init(37, 39) : String,
-	gray: useColor ? init(90, 39) : String,
-	bgBlack: useColor ? init(40, 49) : String,
-	bgRed: useColor ? init(41, 49) : String,
-	bgGreen: useColor ? init(42, 49) : String,
-	bgYellow: useColor ? init(43, 49) : String,
-	bgBlue: useColor ? init(44, 49) : String,
-	bgMagenta: useColor ? init(45, 49) : String,
-	bgCyan: useColor ? init(46, 49) : String,
-	bgWhite: useColor ? init(47, 49) : String,
-	blackBright: useColor ? init(90, 39) : String,
-	redBright: useColor ? init(91, 39) : String,
-	greenBright: useColor ? init(92, 39) : String,
-	yellowBright: useColor ? init(93, 39) : String,
-	blueBright: useColor ? init(94, 39) : String,
-	magentaBright: useColor ? init(95, 39) : String,
-	cyanBright: useColor ? init(96, 39) : String,
-	whiteBright: useColor ? init(97, 39) : String,
-	bgBlackBright: useColor ? init(100, 49) : String,
-	bgRedBright: useColor ? init(101, 49) : String,
-	bgGreenBright: useColor ? init(102, 49) : String,
-	bgYellowBright: useColor ? init(103, 49) : String,
-	bgBlueBright: useColor ? init(104, 49) : String,
-	bgMagentaBright: useColor ? init(105, 49) : String,
-	bgCyanBright: useColor ? init(106, 49) : String,
-	bgWhiteBright: useColor ? init(107, 49) : String
-});
-
-module.exports.createColors = createColors;
 module.exports.getArguments = getArguments;
-module.exports.isColorSupported = isColorSupported;
 module.exports.processArguments = processArguments;

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);
 
@@ -536,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, {
@@ -575,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)
 	});
 
@@ -641,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,
@@ -665,7 +674,7 @@ const applyExperimentsDefaults = (
 
 	// Enabled implicitly the value stays `"auto"`, and the plugins then step
 	// aside per module for requests loaders were applied to.
-	// TODO webpack 6: css/html default to `true`, drop the `"auto"` marker.
+	// TODO in the next major release: css/html/asyncWebAssembly default to `true`, drop the `"auto"` marker.
 	if (experiments.css === "auto") {
 		experiments.css =
 			!(
@@ -694,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") {
@@ -776,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":
@@ -1687,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))
 		)
@@ -2368,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";
@@ -2384,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";
 	};
 
@@ -2444,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);
@@ -2496,25 +2513,36 @@ 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");
+				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`: terser 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.
+				// 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
@@ -2527,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;
@@ -2541,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;
+				}
+				// 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 TerserPlugin.terserMinify | typeof import("../css/cssMinify") | typeof import("../html/htmlMinify"))[]} */
+				/** @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 = [];
@@ -2564,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:
@@ -2580,32 +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"));
+					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));
@@ -2625,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
@@ -26,14 +26,12 @@ const claims = (candidate, file) => {
 	// so reading those as minimizers would disable minification.
 	const { options } = /** @type {{ options?: MinimizerOptions }} */ (candidate);
 	if (!options || !options.minimizer) return false;
-	// `test` and `include` say which types it handles, while `exclude` only
-	// narrows the files within them: honoring that narrowing would let a minimizer
-	// scoped to a subdirectory claim nothing, and webpack would then race it.
+	// `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);
 };
 
 /**
@@ -44,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 =
@@ -58,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 };
 };