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

package/lib/cache/MemoryWithGcCachePlugin.js

@@ -79,10 +79,9 @@ class MemoryWithGcCachePlugin {
 					continue;
 				}
 				if (entry !== undefined) {
-					// We don't delete the cache entry, but set it to undefined instead
-					// This reserves the location in the data table and avoids rehashing
-					// when constantly adding and removing entries.
-					// It will be deleted when removed from oldCache.
+					// Set to undefined rather than deleted, reserving the slot and sparing
+					// a rehash as entries come and go. It goes for good once `oldCache`
+					// drops it.
 					cache.set(identifier, undefined);
 					oldCache.delete(identifier);
 					oldCache.set(identifier, {
@@ -105,13 +104,13 @@ class MemoryWithGcCachePlugin {
 				const cacheEntry = cache.get(identifier);
 				// A recorded miss: the whole chain was asked for this identifier already.
 				if (cacheEntry === null) return null;
-				// Etags are compared by identity — a lazy one is interned per source
-				// object, so equal content reached through a second object is a
+				// WHY: etags are compared by identity, and a lazy one is interned per
+				// source object, so equal content reached through a second object is a
 				// different etag. Hashing to tell those apart would cost every hit what
 				// laziness saves, so a mismatch falls through to the next stage instead:
 				// the file cache compares etags by value and can still answer. Returning
-				// `null` here would bail the hook and lose that (`Cache.get` maps it to
-				// `undefined` regardless, so it buys the caller nothing).
+				// `null` here would bail the hook and lose that, and `Cache.get` maps it
+				// to `undefined` regardless, so it buys the caller nothing.
 				let known = cacheEntry !== undefined;
 				if (cacheEntry !== undefined) {
 					if (cacheEntry.etag === etag) return cacheEntry.data;

package/lib/cache/PackFileCacheStrategy.js

@@ -901,24 +901,9 @@ makeSerializable(
 /** @typedef {(() => Promise<PackContentItems> | PackContentItems) & Partial<{ options: { size?: number } }>} LazyFunction */
 
 class PackContent {
-	/*
-		This class can be in these states:
-		   |   this.lazy    | this.content | this.outdated | state
-		A1 |   undefined    |     Map      |     false     | fresh content
-		A2 |   undefined    |     Map      |     true      | (will not happen)
-		B1 | lazy () => {}  |  undefined   |     false     | not deserialized
-		B2 | lazy () => {}  |  undefined   |     true      | not deserialized, but some items has been removed
-		C1 | lazy* () => {} |     Map      |     false     | deserialized
-		C2 | lazy* () => {} |     Map      |     true      | deserialized, and some items has been removed
-
-		this.used is a subset of this.items.
-		this.items is a subset of this.content.keys() resp. this.lazy().map.keys()
-		When this.outdated === false, this.items === this.content.keys() resp. this.lazy().map.keys()
-		When this.outdated === true, this.items should be used to recreated this.lazy/this.content.
-		When this.lazy and this.content is set, they contain the same data.
-		this.get must only be called with a valid item from this.items.
-		In state C this.lazy is unMemoized
-	*/
+	// `used` is a subset of `items`, itself a subset of the content's keys, and the
+	// two coincide while `outdated` is false. `lazy` and `content` hold the same
+	// data whenever both are set, and `get` takes only an item of `items`.
 
 	/**
 	 * Creates an instance of PackContent.
@@ -1263,6 +1248,8 @@ class PackFileCacheStrategy {
 		this.buildDependencies = new Set();
 		/** @type {FileSystemDependencies} */
 		this.newBuildDependencies = new LazySet();
+		/** @type {FileSystemDependencies} */
+		this.newOptionalBuildDependencies = new LazySet();
 		/** @type {InstanceType<Snapshot> | undefined} */
 		this.resolveBuildDependenciesSnapshot = undefined;
 		/** @type {ResolveResults | undefined} */
@@ -1492,10 +1479,13 @@ class PackFileCacheStrategy {
 	/**
 	 * Stores build dependencies.
 	 * @param {FileSystemDependencies | Iterable<string>} dependencies dependencies to store
+	 * @param {FileSystemDependencies | Iterable<string>} optionalDependencies optional dependencies to store
+	 * @returns {void}
 	 */
-	storeBuildDependencies(dependencies) {
+	storeBuildDependencies(dependencies, optionalDependencies) {
 		if (this.readonly) return;
 		this.newBuildDependencies.addAll(dependencies);
+		this.newOptionalBuildDependencies.addAll(optionalDependencies);
 	}
 
 	afterAllStored() {
@@ -1512,9 +1502,14 @@ class PackFileCacheStrategy {
 				let promise;
 				/** @type {Set<string>} */
 				const newBuildDependencies = new Set();
+				/** @type {Set<string>} */
+				const optionalBuildDependencies = new Set();
 				for (const dep of this.newBuildDependencies) {
 					if (!this.buildDependencies.has(dep)) {
 						newBuildDependencies.add(dep);
+						if (this.newOptionalBuildDependencies.has(dep)) {
+							optionalBuildDependencies.add(dep);
+						}
 					}
 				}
 				if (newBuildDependencies.size > 0 || !this.buildSnapshot) {
@@ -1533,6 +1528,7 @@ class PackFileCacheStrategy {
 							this.fileSystemInfo.resolveBuildDependencies(
 								this.context,
 								newBuildDependencies,
+								optionalBuildDependencies,
 								(err, result) => {
 									this.logger.timeEnd("resolve build dependencies");
 									if (err) return reject(err);
@@ -1667,6 +1663,7 @@ class PackFileCacheStrategy {
 								this.buildDependencies.add(dep);
 							}
 							this.newBuildDependencies.clear();
+							this.newOptionalBuildDependencies.clear();
 							this.logger.timeEnd("store pack");
 							const stats = pack.getContentStats();
 							this.logger.log(
@@ -1887,6 +1884,7 @@ class PackFileCacheStrategy {
 		this.fileSystemInfo.clear();
 		this.buildDependencies.clear();
 		this.newBuildDependencies.clear();
+		this.newOptionalBuildDependencies.clear();
 		this.resolveBuildDependenciesSnapshot = undefined;
 		this.resolveResults = undefined;
 		this.buildSnapshot = undefined;

package/lib/cache/getLazyHashedEtag.js

@@ -42,11 +42,9 @@ class LazyHashedEtag {
 			/** @type {HashableObject} */
 			(this._obj).updateHash(hash);
 			this._hash = hash.digest("base64");
-			// Drop the captured object once the hash is memoized. The hash is
-			// never reset, so we never need `_obj` again — and many callers
-			// (e.g. `SourceMapDevToolPlugin`, `RealContentHashPlugin`) capture
-			// a heavy `CachedSource` here that would otherwise stay reachable
-			// through this etag for the lifetime of the compilation cache.
+			// Drop the captured object once the hash is memoized: the hash never
+			// resets, and callers often capture a heavy `CachedSource` that would
+			// otherwise stay reachable for the compilation cache's lifetime.
 			this._obj = undefined;
 		}
 		return this._hash;

package/lib/config/browserslistTargetHandler.js

@@ -422,12 +422,25 @@ const resolve = (browsers) => {
 			ios_saf: [15, 4],
 			samsung: 17,
 			android: 93,
-			// and_qq: Not supported
-			// baidu: Not supported
-			// and_uc: Not supported
-			// kaios: Not supported
+			// and_qq, baidu, and_uc and kaios are not supported.
 			node: [16, 9]
 		}),
+		topLevelAwait: rawChecker({
+			chrome: 89,
+			and_chr: 89,
+			edge: 89,
+			firefox: 89,
+			and_ff: 89,
+			// ie: Not supported,
+			opera: 75,
+			op_mob: 63,
+			safari: 15,
+			ios_saf: 15,
+			samsung: 15,
+			android: 89,
+			// and_qq, baidu, and_uc and kaios are not supported.
+			node: [14, 8]
+		}),
 		spread: rawChecker({
 			chrome: 60,
 			and_chr: 60,

package/lib/config/defaults.js

@@ -303,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
@@ -364,7 +373,6 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 	applyExperimentsDefaults(options.experiments, {
 		production,
 		development,
-		targetProperties,
 		rules: options.module.rules
 	});
 
@@ -408,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,
@@ -423,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,
@@ -489,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) {
@@ -630,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);
@@ -647,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);
@@ -675,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 =
@@ -919,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);
@@ -1241,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]>} */
@@ -1386,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/,
@@ -1433,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: {
@@ -1451,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: {
@@ -1593,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
@@ -1606,7 +1578,6 @@ const applyOutputDefaults = (
 		context,
 		targetProperties: tp,
 		isAffectedByBrowserslist,
-		outputModule,
 		development,
 		entry,
 		futureDefaults,
@@ -1662,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);
 	/**
@@ -1706,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),
@@ -1748,8 +1776,12 @@ const applyOutputDefaults = (
 		"generator",
 		() => tp && optimistic(/** @type {boolean | undefined} */ (tp.generator))
 	);
-	// No `topLevelAwait` here: the option is held back from the patch release,
-	// so nothing derives it from `tp` yet. Reapply by reverting #21881.
+	F(
+		environment,
+		"topLevelAwait",
+		() =>
+			tp && optimistic(/** @type {boolean | undefined} */ (tp.topLevelAwait))
+	);
 	F(
 		environment,
 		"forOf",
@@ -1839,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 = {};
 	}
@@ -1896,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)/;
 	/**
@@ -1949,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"
@@ -1984,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" +
@@ -2131,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 = [];
@@ -2391,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);
@@ -2399,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);
@@ -2413,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));
 };
 
@@ -2495,19 +2508,17 @@ 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
 				);
@@ -2583,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,