@depup/webpack 5.110.1-depup.0 → 5.111.1-depup.0

package/lib/config/defaults.js

@@ -179,6 +179,7 @@ const {
  * portableRecords: NonNullable<Optimization["portableRecords"]>,
  * realContentHash: NonNullable<Optimization["realContentHash"]>,
  * minimize: NonNullable<Optimization["minimize"]>,
+ * minimizeOptions: NonNullable<Optimization["minimizeOptions"]>,
  * minimizer: NonNullable<Exclude<Optimization["minimizer"], "...">>,
  * nodeEnv: NonNullable<Optimization["nodeEnv"]>,
  * }} OptimizationNormalizedWithDefaults
@@ -302,6 +303,15 @@ const A = (obj, prop, factory) => {
 	}
 };
 
+/**
+ * Whether the library type emits an ECMAScript module, which only `output.module`
+ * output can carry — every other type is written into a script.
+ * @param {LibraryType | undefined} type library type
+ * @returns {boolean} true, when the type is only emitted as an ECMAScript module
+ */
+const isModuleLibraryType = (type) =>
+	type === "module" || type === "modern-module";
+
 /**
  * Apply webpack options base defaults.
  * @param {WebpackOptionsNormalized} options options to be modified
@@ -363,7 +373,6 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 	applyExperimentsDefaults(options.experiments, {
 		production,
 		development,
-		targetProperties,
 		rules: options.module.rules
 	});
 
@@ -407,9 +416,6 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 			(typeof target === "string" && target.startsWith("browserslist")) ||
 			(Array.isArray(target) &&
 				target.some((target) => target.startsWith("browserslist"))),
-		outputModule:
-			/** @type {NonNullable<ExperimentsNormalized["outputModule"]>} */
-			(options.experiments.outputModule),
 		development,
 		entry: options.entry,
 		futureDefaults,
@@ -422,9 +428,7 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 	// is read by another bundler, where an eval wrapper hides `import.meta` from it.
 	const noDevSourceMap = /** @type {LibraryType[]} */ (
 		options.output.enabledLibraryTypes
-	).some(
-		(type) => futureDefaults || type === "module" || type === "modern-module"
-	);
+	).some((type) => futureDefaults || isModuleLibraryType(type));
 
 	F(
 		options,
@@ -488,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) {
@@ -629,13 +632,12 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
  * @param {object} options options
  * @param {boolean} options.production is production
  * @param {boolean} options.development is development mode
- * @param {TargetProperties | false} options.targetProperties target properties
  * @param {RuleSetRules} options.rules user `module.rules`, used to resolve the css/html/asyncWebAssembly/typescript "auto" defaults
  * @returns {void}
  */
 const applyExperimentsDefaults = (
 	experiments,
-	{ production, development, targetProperties, rules }
+	{ production, development, rules }
 ) => {
 	D(experiments, "futureDefaults", false);
 	D(experiments, "backCompat", !experiments.futureDefaults);
@@ -646,23 +648,6 @@ const applyExperimentsDefaults = (
 		"asyncWebAssembly",
 		experiments.futureDefaults ? true : "auto"
 	);
-	// the universal target (web + node, neither specific) only works as ESM —
-	// unless the target cannot read one, which no output format can repair, so
-	// leave `output.chunkFormat` to say so rather than emitting a module the
-	// target has already reported it will not load
-	const universal =
-		Boolean(targetProperties) &&
-		/** @type {TargetProperties} */ (targetProperties).node === null &&
-		/** @type {TargetProperties} */ (targetProperties).web === null &&
-		/** @type {TargetProperties} */ (targetProperties).module !== false;
-	// the deno and bun targets only emit ECMAScript modules
-	const deno =
-		Boolean(targetProperties) &&
-		/** @type {TargetProperties} */ (targetProperties).deno === true;
-	const bun =
-		Boolean(targetProperties) &&
-		/** @type {TargetProperties} */ (targetProperties).bun === true;
-	D(experiments, "outputModule", universal || deno || bun);
 	D(experiments, "lazyCompilation", undefined);
 	D(experiments, "buildHttp", undefined);
 	D(experiments, "cacheUnaffected", experiments.futureDefaults);
@@ -674,14 +659,12 @@ 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).
+	// 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 webpack 6: css/html default to `true`, drop the `"auto"` marker.
 	if (experiments.css === "auto") {
 		experiments.css =
@@ -918,6 +901,7 @@ const applyJavascriptParserOptionsDefaults = (
 	D(parserOptions, "wrappedContextRecursive", true);
 	D(parserOptions, "wrappedContextCritical", false);
 	D(parserOptions, "strictThisContextOnImports", false);
+	D(parserOptions, "specNamespaceObject", false);
 	D(parserOptions, "importMeta", outputModule ? "preserve-unknown" : true);
 	D(parserOptions, "dynamicImportMode", "lazy");
 	D(parserOptions, "dynamicImportPrefetch", false);
@@ -1240,18 +1224,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]>} */
@@ -1385,11 +1364,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/,
@@ -1432,16 +1409,16 @@ const applyModuleDefaults = (
 				type: HTML_MODULE_TYPE,
 				resolve
 			});
+			// Exactly `text/html` — a string condition matches by prefix, which
+			// would make a `data:text/htmlx,` module (JavaScript) a page.
 			rules.push({
-				mimetype: "text/html",
+				mimetype: /^text\/html$/i,
 				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: {
@@ -1450,12 +1427,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: {
@@ -1592,7 +1566,6 @@ const applyModuleDefaults = (
  * @param {string} options.context context
  * @param {TargetProperties | false} options.targetProperties target properties
  * @param {boolean} options.isAffectedByBrowserslist is affected by browserslist
- * @param {boolean} options.outputModule is outputModule experiment enabled
  * @param {boolean} options.development is development mode
  * @param {Entry} options.entry entry option
  * @param {boolean} options.futureDefaults is future defaults enabled
@@ -1605,7 +1578,6 @@ const applyOutputDefaults = (
 		context,
 		targetProperties: tp,
 		isAffectedByBrowserslist,
-		outputModule,
 		development,
 		entry,
 		futureDefaults,
@@ -1661,7 +1633,65 @@ const applyOutputDefaults = (
 		}
 	});
 
-	F(output, "module", () => Boolean(outputModule));
+	/**
+	 * Processes the provided fn.
+	 * @param {(entryDescription: EntryDescription) => void} fn iterator
+	 * @returns {void}
+	 */
+	const forEachEntry = (fn) => {
+		for (const name of Object.keys(entry)) {
+			fn(/** @type {{ [k: string]: EntryDescription }} */ (entry)[name]);
+		}
+	};
+
+	/**
+	 * Every library type the configuration states, wherever it was declared.
+	 * @returns {LibraryType[]} the declared library types
+	 */
+	const declaredLibraryTypes = () => {
+		/** @type {LibraryType[]} */
+		const types = [];
+		if (output.library && output.library.type) types.push(output.library.type);
+		// A plugin (`ModuleFederationPlugin`) pushed its type here before the defaults;
+		// `"..."` is the extend placeholder `A` resolves, never a type of its own.
+		if (output.enabledLibraryTypes) {
+			for (const type of output.enabledLibraryTypes) {
+				if (type !== "...") types.push(type);
+			}
+		}
+		forEachEntry((desc) => {
+			if (desc.library && desc.library.type) types.push(desc.library.type);
+		});
+		return types;
+	};
+
+	const libraryTypes = declaredLibraryTypes();
+
+	// A library type that is an ECMAScript module is another spelling of
+	// `output.module`, so it turns it on rather than disagreeing with it.
+	if (libraryTypes.some(isModuleLibraryType)) {
+		output.module = true;
+	}
+
+	// Every other library type is read out of a script, which is a statement that
+	// the output is not an ECMAScript module — so it holds the default below back.
+	const hasScriptLibrary = libraryTypes.some(
+		(type) => !isModuleLibraryType(type)
+	);
+
+	// the universal target (web + node, neither specific), deno and bun only work
+	// as ESM, unless `module: false` says the target cannot read one
+	F(output, "module", () =>
+		Boolean(
+			tp &&
+			((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
+				// query (or `esX`/`nodeX`) without ESM support keeps script output
+				(futureDefaults && tp.module !== false && !hasScriptLibrary))
+		)
+	);
 
 	const environment = /** @type {Environment} */ (output.environment);
 	/**
@@ -1705,12 +1735,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),
@@ -1747,6 +1776,12 @@ const applyOutputDefaults = (
 		"generator",
 		() => tp && optimistic(/** @type {boolean | undefined} */ (tp.generator))
 	);
+	F(
+		environment,
+		"topLevelAwait",
+		() =>
+			tp && optimistic(/** @type {boolean | undefined} */ (tp.topLevelAwait))
+	);
 	F(
 		environment,
 		"forOf",
@@ -1836,10 +1871,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 = {};
 	}
@@ -1893,13 +1927,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)/;
 	/**
@@ -1946,11 +1976,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"
@@ -1981,7 +2009,7 @@ const applyOutputDefaults = (
 					"For the selected environment is no default script chunk format available:\n" +
 						`${
 							tp.module
-								? "Module ('module') can be chosen when ES modules are available (please set 'experiments.outputModule' and 'output.module' to `true`)"
+								? "Module ('module') can be chosen when ES modules are available (please set 'output.module' to `true`)"
 								: ""
 						}\n` +
 						"JSONP Array push ('array-push') can be chosen when 'document' or 'importScripts' is available.\n" +
@@ -2128,16 +2156,6 @@ const applyOutputDefaults = (
 		D(trustedTypes, "onPolicyCreationFailure", "stop");
 	}
 
-	/**
-	 * Processes the provided fn.
-	 * @param {(entryDescription: EntryDescription) => void} fn iterator
-	 * @returns {void}
-	 */
-	const forEachEntry = (fn) => {
-		for (const name of Object.keys(entry)) {
-			fn(/** @type {{ [k: string]: EntryDescription }} */ (entry)[name]);
-		}
-	};
 	A(output, "enabledLibraryTypes", () => {
 		/** @type {LibraryType[]} */
 		const enabledLibraryTypes = [];
@@ -2388,6 +2406,7 @@ const applyPerformanceDefaults = (performance, { production }) => {
 	// Stands in for every check left unset, so an explicit one still wins.
 	const all = performance.all !== undefined ? performance.all : false;
 
+	D(performance, "analyzableBailouts", all);
 	D(performance, "asyncChunkWaterfalls", all);
 	D(performance, "broadContexts", all);
 	D(performance, "cacheEffectiveness", all);
@@ -2396,8 +2415,6 @@ const applyPerformanceDefaults = (performance, { production }) => {
 	D(performance, "duplicateModules", all);
 	D(performance, "duplicatePackages", all);
 	D(performance, "dynamicExports", all);
-	D(performance, "entrypointOverlap", all);
-	D(performance, "embeddedSourceMaps", all);
 	D(performance, "evalUsage", all);
 	D(performance, "hotspots", all);
 	D(performance, "legacyJavascript", all);
@@ -2410,14 +2427,13 @@ const applyPerformanceDefaults = (performance, { production }) => {
 	D(performance, "redundantDynamicImports", all);
 	D(performance, "scopeHoistingBailouts", all);
 	D(performance, "splitChunksCapped", all);
+	D(performance, "sourceMaps", all);
 	D(performance, "tinyChunks", all);
 	D(performance, "topLevelThis", all);
 	D(performance, "unsplitVendors", all);
-	D(performance, "unusedAliases", all);
-	D(performance, "unusedDefines", all);
-	D(performance, "unusedExternals", all);
-	D(performance, "unusedReexports", all);
-	D(performance, "unusedRules", all);
+	D(performance, "unusedAssets", all);
+	D(performance, "unusedConfig", all);
+	D(performance, "unusedModules", all);
 	F(performance, "hints", () => (production ? "warning" : false));
 };
 
@@ -2463,20 +2479,28 @@ const applyOptimizationDefaults = (
 	D(optimization, "mangleWasmImports", false);
 	D(optimization, "portableRecords", records);
 	D(optimization, "realContentHash", production);
-	F(optimization, "minimize", () => (production ? {} : false));
-	// A plugin can assign the `true` shorthand in `apply()`, which runs after
-	// `getNormalizedOptimizationMinimize` and so never gets normalized. The
-	// normalized type does not allow it, hence the cast.
-	if (/** @type {unknown} */ (optimization.minimize) === true) {
-		optimization.minimize = {};
+	// A plugin assigning the object shorthand in `apply()` runs after
+	// normalization: it replaces `minimizeOptions`, keeping `minimize` boolean.
+	const minimizeAssignedInApply = /** @type {unknown} */ (
+		optimization.minimize
+	);
+	if (typeof minimizeAssignedInApply === "object") {
+		optimization.minimizeOptions = /** @type {OptimizationMinimizeOptions} */ (
+			minimizeAssignedInApply
+		);
+		optimization.minimize = true;
 	}
-	const { minimize } = optimization;
-	if (minimize) {
-		// Canonicalize the object form: the JS minimizer's defaults become
-		// visible in the resolved config rather than hidden in the wiring.
-		F(minimize, "javascript", () => ({ compress: { passes: 2 } }));
-		F(minimize, "css", () => ({}));
-		F(minimize, "html", () => ({}));
+	D(optimization, "minimize", production);
+	F(optimization, "minimizeOptions", () => ({}));
+	const minimizeOptions =
+		/** @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 } }));
+		F(minimizeOptions, "css", () => ({}));
+		F(minimizeOptions, "html", () => ({}));
 	}
 	A(optimization, "minimizer", () => [
 		{
@@ -2484,27 +2508,24 @@ const applyOptimizationDefaults = (
 				// 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.
+				// 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.
+
+				// 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
 				);
 
-				// Normalized + defaulted `optimization.minimize` is the per-asset-type
-				// object here: `false` disables a type, an object is its options.
+				// Per asset type: `false` disables that type, an object is its options.
 				const minimizeByType = /** @type {OptimizationMinimizeOptions} */ (
-					compiler.options.optimization.minimize
+					compiler.options.optimization.minimizeOptions
 				);
 				const terserOptions = minimizeByType.javascript || {
 					compress: { passes: 2 }
@@ -2573,10 +2594,9 @@ const applyOptimizationDefaults = (
 				}
 				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.
+					// `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,

package/lib/config/getClaimedAssetTypes.js

@@ -17,19 +17,18 @@ 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, 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.
 	const { test, include } = options;
 	return (
 		(test !== undefined && matchObject({ test }, file)) ||