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

package/lib/config/defaults.js

@@ -36,51 +36,57 @@ const { cleverMerge } = require("../util/cleverMerge");
 const {
 	getDefaultTarget,
 	getTargetProperties,
+	getTargetsBrowsers,
 	getTargetsProperties
 } = require("./target");
 
-/** @typedef {import("../../declarations/WebpackOptions").CacheOptionsNormalized} CacheOptionsNormalized */
-/** @typedef {import("../../declarations/WebpackOptions").Context} Context */
-/** @typedef {import("../../declarations/WebpackOptions").DevTool} Devtool */
-/** @typedef {import("../../declarations/WebpackOptions").CssGeneratorOptions} CssGeneratorOptions */
-/** @typedef {import("../../declarations/WebpackOptions").EntryDescription} EntryDescription */
-/** @typedef {import("../../declarations/WebpackOptions").EntryNormalized} Entry */
-/** @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").GeneratorOptionsByModuleTypeKnown} GeneratorOptionsByModuleTypeKnown */
-/** @typedef {import("../../declarations/WebpackOptions").InfrastructureLogging} InfrastructureLogging */
-/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
-/** @typedef {import("../../declarations/WebpackOptions").JsonGeneratorOptions} JsonGeneratorOptions */
-/** @typedef {import("../../declarations/WebpackOptions").Library} Library */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryName} LibraryName */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
-/** @typedef {import("../../declarations/WebpackOptions").Loader} Loader */
-/** @typedef {import("../../declarations/WebpackOptions").Mode} Mode */
-/** @typedef {import("../../declarations/WebpackOptions").HashFunction} HashFunction */
-/** @typedef {import("../../declarations/WebpackOptions").HashSalt} HashSalt */
-/** @typedef {import("../../declarations/WebpackOptions").HashDigest} HashDigest */
-/** @typedef {import("../../declarations/WebpackOptions").HashDigestLength} HashDigestLength */
-/** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
-/** @typedef {import("../../declarations/WebpackOptions").Node} WebpackNode */
-/** @typedef {import("../../declarations/WebpackOptions").OptimizationNormalized} 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").RuleSetRule} RuleSetRule */
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetRules} RuleSetRules */
-/** @typedef {import("../../declarations/WebpackOptions").SnapshotOptions} SnapshotOptions */
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptionsNormalized */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../javascript/EnableChunkLoadingPlugin").ChunkLoadingTypes} ChunkLoadingTypes */
-/** @typedef {import("../wasm/EnableWasmLoadingPlugin").WasmLoadingTypes} WasmLoadingTypes */
-/** @typedef {import("./target").PlatformTargetProperties} PlatformTargetProperties */
-/** @typedef {import("./target").TargetProperties} TargetProperties */
+/**
+ * @import {
+ * 	CacheOptionsNormalized,
+ * 	Context,
+ * 	DevTool as Devtool,
+ * 	CssGeneratorOptions,
+ * 	EntryDescription,
+ * 	EntryNormalized as Entry,
+ * 	Environment,
+ * 	Experiments,
+ * 	ExperimentsNormalized,
+ * 	ExternalsPresets,
+ * 	ExternalsType,
+ * 	FileCacheOptions,
+ * 	GeneratorOptionsByModuleTypeKnown,
+ * 	InfrastructureLogging,
+ * 	JavascriptParserOptions,
+ * 	JsonGeneratorOptions,
+ * 	Library,
+ * 	LibraryName,
+ * 	LibraryType,
+ * 	Loader,
+ * 	Mode,
+ * 	HashFunction,
+ * 	HashSalt,
+ * 	ModuleOptionsNormalized as ModuleOptions,
+ * 	Node as WebpackNode,
+ * 	OptimizationMinimizeOptions,
+ * 	OptimizationNormalized as Optimization,
+ * 	OptimizationSplitChunksOptions,
+ * 	OutputNormalized as Output,
+ * 	ParserOptionsByModuleTypeKnown,
+ * 	Performance,
+ * 	ResolveOptions,
+ * 	RuleSetRules,
+ * 	SnapshotOptions,
+ * 	WebpackOptionsNormalized
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import Module from "../Module" */
+/**
+ * @import {
+ * 	ChunkLoadingTypes
+ * } from "../javascript/EnableChunkLoadingPlugin"
+ */
+/** @import { WasmLoadingTypes } from "../wasm/EnableWasmLoadingPlugin" */
+/** @import { PlatformTargetProperties, TargetProperties } from "./target" */
 
 /**
  * Defines the recursive non nullable type used by this module.
@@ -361,30 +367,6 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 		rules: options.module.rules
 	});
 
-	// After experiments are resolved: the default dev source map depends on the
-	// (possibly "auto"-resolved) `experiments.css` value.
-	F(
-		options,
-		"devtool",
-		() =>
-			/** @type {Devtool} */ (
-				development
-					? [
-							options.experiments.css
-								? {
-										type: "css",
-										use: "source-map"
-									}
-								: undefined,
-							{
-								type: "javascript",
-								use: "eval"
-							}
-						].filter(Boolean)
-					: false
-			)
-	);
-
 	const futureDefaults =
 		/** @type {NonNullable<ExperimentsNormalized["futureDefaults"]>} */
 		(options.experiments.futureDefaults);
@@ -436,6 +418,36 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 			(options.experiments.asyncWebAssembly)
 	});
 
+	// Placed after `applyOutputDefaults`, which settles `enabledLibraryTypes`. A library
+	// 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"
+	);
+
+	F(
+		options,
+		"devtool",
+		() =>
+			/** @type {Devtool} */ (
+				development && !noDevSourceMap
+					? [
+							options.experiments.css
+								? {
+										type: "css",
+										use: "source-map"
+									}
+								: undefined,
+							{
+								type: "javascript",
+								use: "eval"
+							}
+						].filter(Boolean)
+					: false
+			)
+	);
+
 	applyModuleDefaults(options.module, {
 		cache,
 		hashSalt: /** @type {NonNullable<Output["hashSalt"]>} */ (
@@ -511,7 +523,13 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 		/** @type {NonNullable<WebpackOptionsNormalized["loader"]>} */ (
 			options.loader
 		),
-		{ targetProperties, environment: options.output.environment }
+		{
+			targetProperties,
+			environment: options.output.environment,
+			outputModule:
+				/** @type {NonNullable<WebpackOptionsNormalized["output"]["module"]>} */
+				(options.output.module)
+		}
 	);
 
 	F(options, "externalsType", () => {
@@ -628,11 +646,15 @@ const applyExperimentsDefaults = (
 		"asyncWebAssembly",
 		experiments.futureDefaults ? true : "auto"
 	);
-	// the universal target (web + node, neither specific) only works as ESM
+	// 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).web === null &&
+		/** @type {TargetProperties} */ (targetProperties).module !== false;
 	// the deno and bun targets only emit ECMAScript modules
 	const deno =
 		Boolean(targetProperties) &&
@@ -1683,6 +1705,9 @@ 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.
@@ -1727,6 +1752,14 @@ const applyOutputDefaults = (
 		"forOf",
 		() => tp && optimistic(/** @type {boolean | undefined} */ (tp.forOf))
 	);
+	// Stage 3 syntax, so these are the one pair read pessimistically: a preset that
+	// says nothing means unavailable, and the phase keeps webpack's own form.
+	F(environment, "deferImport", () =>
+		Boolean(tp && /** @type {boolean | undefined} */ (tp.deferImport))
+	);
+	F(environment, "sourceImport", () =>
+		Boolean(tp && /** @type {boolean | undefined} */ (tp.sourceImport))
+	);
 	F(
 		environment,
 		"destructuring",
@@ -1811,6 +1844,7 @@ const applyOutputDefaults = (
 		output.resourceHints = {};
 	}
 	if (output.resourceHints) {
+		D(output.resourceHints, "dedupe", false);
 		if (output.module) D(output.resourceHints, "initial", true);
 		// `modulePreloadPolyfill` defaults from the target's modulepreload
 		// support: inject the polyfill iff the environment lacks it.
@@ -1912,10 +1946,15 @@ const applyOutputDefaults = (
 		if (tp) {
 			if (tp.global) return "global";
 			if (tp.globalThis) return "globalThis";
-			// Universal target (web + node) with no reported accessor: `globalThis`
-			// is the only one defined everywhere (`null` = mixed support → `self`).
-			if (tp.web === null && tp.node === null && tp.globalThis === undefined) {
-				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.
+			if (tp.web === null && tp.node === null) {
+				return tp.globalThis === undefined
+					? "globalThis"
+					: 'typeof self !== "undefined" ? self : global';
 			}
 		}
 		return "self";
@@ -2048,7 +2087,9 @@ const applyOutputDefaults = (
 		"hotUpdateMainFilename",
 		// Only `chunkLoading: "import"` loads the manifest via `import()` (needs an
 		// `export default` ES module); every other loader fetches it as raw JSON.
-		`[runtime].[fullhash].hot-update.${output.chunkLoading === "import" ? "json.mjs" : "json"}`
+		`[runtime].[fullhash].hot-update.${
+			output.chunkLoading === "import" ? "json.mjs" : "json"
+		}`
 	);
 	D(output, "crossOriginLoading", false);
 	F(output, "scriptType", () => (output.module ? "module" : false));
@@ -2189,6 +2230,8 @@ const applyExternalsPresetsDefaults = (
 					isUniversal("node"))
 		)
 	);
+	// Opt-in only: never auto-externalize installed packages, it would change existing builds.
+	D(externalsPresets, "nodeModules", false);
 	D(
 		externalsPresets,
 		"deno",
@@ -2251,9 +2294,13 @@ const applyExternalsPresetsDefaults = (
  * @param {object} options options
  * @param {TargetProperties | false} options.targetProperties target properties
  * @param {Environment} options.environment environment
+ * @param {boolean} options.outputModule is output type is module
  * @returns {void}
  */
-const applyLoaderDefaults = (loader, { targetProperties, environment }) => {
+const applyLoaderDefaults = (
+	loader,
+	{ targetProperties, environment, outputModule }
+) => {
 	F(loader, "target", () => {
 		if (targetProperties) {
 			if (targetProperties.electron) {
@@ -2267,6 +2314,15 @@ const applyLoaderDefaults = (loader, { targetProperties, environment }) => {
 			if (targetProperties.bun) return "bun";
 			if (targetProperties.node) return "node";
 			if (targetProperties.web) return "web";
+			// no single platform to report: the bundle runs on both (target
+			// `"universal"` / `["web", "node"]`), so loaders get `"universal"`
+			if (
+				outputModule &&
+				targetProperties.node === null &&
+				targetProperties.web === null
+			) {
+				return "universal";
+			}
 		}
 	});
 	D(loader, "environment", environment);
@@ -2329,6 +2385,39 @@ const applyPerformanceDefaults = (performance, { production }) => {
 	if (performance === false) return;
 	D(performance, "maxAssetSize", 250000);
 	D(performance, "maxEntrypointSize", 250000);
+	// Stands in for every check left unset, so an explicit one still wins.
+	const all = performance.all !== undefined ? performance.all : false;
+
+	D(performance, "asyncChunkWaterfalls", all);
+	D(performance, "broadContexts", all);
+	D(performance, "cacheEffectiveness", all);
+	D(performance, "circularDependencies", all);
+	D(performance, "conflictingResourceHints", all);
+	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);
+	D(performance, "largeModules", all);
+	D(performance, "inlinedAssets", all);
+	D(performance, "mixedExports", all);
+	D(performance, "missingSideEffects", all);
+	D(performance, "osDependentRules", all);
+	D(performance, "pureAnnotations", all);
+	D(performance, "redundantDynamicImports", all);
+	D(performance, "scopeHoistingBailouts", all);
+	D(performance, "splitChunksCapped", 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);
 	F(performance, "hints", () => (production ? "warning" : false));
 };
 
@@ -2374,19 +2463,131 @@ const applyOptimizationDefaults = (
 	D(optimization, "mangleWasmImports", false);
 	D(optimization, "portableRecords", records);
 	D(optimization, "realContentHash", production);
-	D(optimization, "minimize", 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 = {};
+	}
+	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", () => ({}));
+	}
 	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 claimedByOtherMinimizer = require("./getClaimedAssetTypes")(
+					compiler
+				);
+
+				// Normalized + defaulted `optimization.minimize` is the per-asset-type
+				// object here: `false` disables a type, an object is its options.
+				const minimizeByType = /** @type {OptimizationMinimizeOptions} */ (
+					compiler.options.optimization.minimize
+				);
+				const terserOptions = minimizeByType.javascript || {
+					compress: { passes: 2 }
+				};
+
+				const { css, html } = compiler.options.experiments;
+				const minifyJs = minimizeByType.javascript !== false;
+				const minifyCss =
+					Boolean(css) &&
+					!claimedByOtherMinimizer.css &&
+					minimizeByType.css !== false;
+				const minifyHtml =
+					Boolean(html) &&
+					!claimedByOtherMinimizer.html &&
+					minimizeByType.html !== false;
+				if (!minifyJs && !minifyCss && !minifyHtml) return;
+				if (minifyJs && !minifyCss && !minifyHtml) {
+					new TerserPlugin({ terserOptions }).apply(
+						/** @type {EXPECTED_ANY} */ (compiler)
+					);
+					return;
+				}
+				/** @type {(typeof TerserPlugin.terserMinify | typeof import("../css/cssMinify") | typeof import("../html/htmlMinify"))[]} */
+				const minify = [];
+				/** @type {EXPECTED_OBJECT[]} */
+				const minimizerOptions = [];
+				/** @type {string[]} */
+				const extensions = [];
+				// `minimize.css` follows the CSS minifier wherever it runs: the HTML
+				// entry gets the same options, like the shared environment below.
+				const cssOptions =
+					typeof minimizeByType.css === "object"
+						? minimizeByType.css
+						: undefined;
+				// The browserslist selection, when the target is one. It decides both the
+				// 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
+					? getTargetsBrowsers(
+							Array.isArray(target) ? target : [target],
+							/** @type {Context} */ (compiler.options.context)
+						)
+					: undefined;
+				const cssEnvironment = {
+					browsers,
+					vendorPrefixes:
+						cssOptions === undefined || cssOptions.vendorPrefixes !== false
+				};
+				const htmlOptions =
+					typeof minimizeByType.html === "object"
+						? minimizeByType.html
+						: undefined;
+				if (minifyJs) {
+					minify.push(TerserPlugin.terserMinify);
+					minimizerOptions.push(terserOptions);
+					extensions.push("[cm]?js");
+				}
+				if (minifyCss) {
+					minify.push(require("../css/cssMinify"));
+					minimizerOptions.push({
+						environment: cssEnvironment,
+						...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.
+					minimizerOptions.push({
+						environment: cssEnvironment,
+						css: cssOptions,
+						...htmlOptions
+					});
+					extensions.push("html");
+				}
 				new TerserPlugin({
-					terserOptions: {
-						compress: {
-							passes: 2
-						}
-					}
+					test: new RegExp(`\\.(?:${extensions.join("|")})(\\?.*)?$`, "i"),
+					minify,
+					minimizerOptions
 				}).apply(/** @type {EXPECTED_ANY} */ (compiler));
 			}
 		}

package/lib/config/defineConfig.js

@@ -5,8 +5,16 @@
 
 "use strict";
 
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptions} Configuration */
-/** @typedef {import("../MultiCompiler").MultiWebpackOptions} MultiConfiguration */
+/**
+ * @import {
+ * 	WebpackOptions as Configuration
+ * } from "../../declarations/WebpackOptions"
+ */
+/**
+ * @import {
+ * 	MultiWebpackOptions as MultiConfiguration
+ * } from "../MultiCompiler"
+ */
 
 /**
  * @template T

package/lib/config/getClaimedAssetTypes.js

@@ -0,0 +1,65 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author sheo13666q @sheo13666q
+*/
+
+"use strict";
+
+const { matchObject } = require("../ModuleFilenameHelpers");
+
+/** @import Compiler from "../Compiler" */
+/** @import { MatchObject } from "../ModuleFilenameHelpers" */
+/** @typedef {MatchObject & { minimizer?: EXPECTED_OBJECT }} MinimizerOptions */
+
+/**
+ * @param {unknown} candidate a configured plugin or minimizer entry
+ * @param {string} file probe filename
+ * @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.
+	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.
+	const { test, include } = options;
+	return (
+		(test !== undefined && matchObject({ test }, file)) ||
+		(include !== undefined && matchObject({ include }, file))
+	);
+};
+
+/**
+ * Which asset types the user's own configuration already minimizes, so webpack's
+ * default minimizer can leave those alone instead of racing the user's plugin
+ * for them (the loser is skipped via `minimized` asset info, so without this
+ * whichever tapped first would win). Deliberately coarse: it reads a plugin's
+ * 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
+ */
+module.exports = (compiler) => {
+	const { optimization, plugins } = compiler.options;
+	let css = false;
+	let html = 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 =
+		/** @type {NonNullable<typeof optimization.minimizer>} */
+		(optimization.minimizer);
+	for (const candidate of [...minimizer, ...plugins]) {
+		if (!css) css = claims(candidate, "file.css");
+		if (!html) html = claims(candidate, "file.html");
+		if (css && html) break;
+	}
+	return { css, html };
+};

package/lib/config/normalization.js

@@ -7,22 +7,27 @@
 
 const util = require("util");
 
-/** @typedef {import("../../declarations/WebpackOptions").CacheOptionsNormalized} CacheOptions */
-/** @typedef {import("../../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescriptionNormalized */
-/** @typedef {import("../../declarations/WebpackOptions").EntryStatic} EntryStatic */
-/** @typedef {import("../../declarations/WebpackOptions").EntryStaticNormalized} EntryStaticNormalized */
-/** @typedef {import("../../declarations/WebpackOptions").Externals} Externals */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryName} LibraryName */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptionsNormalized */
-/** @typedef {import("../../declarations/WebpackOptions").OptimizationNormalized} OptimizationNormalized */
-/** @typedef {import("../../declarations/WebpackOptions").OptimizationRuntimeChunk} OptimizationRuntimeChunk */
-/** @typedef {import("../../declarations/WebpackOptions").OptimizationRuntimeChunkNormalized} OptimizationRuntimeChunkNormalized */
-/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputNormalized */
-/** @typedef {import("../../declarations/WebpackOptions").PluginsNormalized} PluginsNormalized */
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptions} WebpackOptions */
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptionsNormalized */
-/** @typedef {import("../errors/WebpackError")} WebpackError */
+/**
+ * @import {
+ * 	CacheOptionsNormalized as CacheOptions,
+ * 	EntryDescriptionNormalized,
+ * 	EntryStatic,
+ * 	EntryStaticNormalized,
+ * 	Externals,
+ * 	LibraryName,
+ * 	LibraryOptions,
+ * 	ModuleOptionsNormalized,
+ * 	Optimization,
+ * 	OptimizationNormalized,
+ * 	OptimizationRuntimeChunk,
+ * 	OptimizationRuntimeChunkNormalized,
+ * 	OutputNormalized,
+ * 	PluginsNormalized,
+ * 	WebpackOptions,
+ * 	WebpackOptionsNormalized
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import WebpackError from "../errors/WebpackError" */
 
 /**
  * Defines the webpack options interception type used by this module.
@@ -326,6 +331,7 @@ const getNormalizedWebpackOptions = (config) => ({
 					cacheGroups: cloneObject(splitChunks.cacheGroups)
 				}
 		),
+		minimize: getNormalizedOptimizationMinimize(optimization.minimize),
 		minimizer:
 			optimization.minimizer !== undefined
 				? /** @type {OptimizationNormalized["minimizer"]} */ (
@@ -419,6 +425,7 @@ const getNormalizedWebpackOptions = (config) => ({
 						? output.libraryExport
 						: libraryBase.export,
 				name: libraryBase.name,
+				umdAmdContainer: libraryBase.umdAmdContainer,
 				umdNamedDefine:
 					output.umdNamedDefine !== undefined
 						? output.umdNamedDefine
@@ -604,6 +611,19 @@ const getNormalizedEntryStatic = (entry) => {
 	return result;
 };
 
+/**
+ * Gets normalized optimization minimize: the `true` shorthand becomes an empty
+ * per-asset-type object, so downstream only sees `false` or the object form.
+ * @param {Optimization["minimize"]} minimize minimize option
+ * @returns {OptimizationNormalized["minimize"]} normalized minimize option
+ */
+const getNormalizedOptimizationMinimize = (minimize) => {
+	if (minimize === undefined) return;
+	if (minimize === false) return false;
+	if (minimize === true) return {};
+	return cloneObject(minimize);
+};
+
 /**
  * Gets normalized optimization runtime chunk.
  * @param {OptimizationRuntimeChunk=} runtimeChunk runtimeChunk option