webpack 5.111.1 → 5.112.1

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
@@ -87,6 +87,8 @@ const {
  */
 /** @import { WasmLoadingTypes } from "../wasm/EnableWasmLoadingPlugin" */
 /** @import { PlatformTargetProperties, TargetProperties } from "./target" */
+/** @import Compiler from "../Compiler" */
+/** @typedef {Parameters<import("minimizer-webpack-plugin")["apply"]>[0]} MinimizerCompiler */
 
 /**
  * Defines the recursive non nullable type used by this module.
@@ -228,7 +230,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"
 };
 
@@ -279,18 +281,20 @@ const A = (obj, prop, factory) => {
 	if (value === undefined) {
 		obj[prop] = factory();
 	} else if (Array.isArray(value)) {
-		/** @type {EXPECTED_ANY[] | undefined} */
+		/** @type {(T[P] extends (infer E)[] ? E : never)[] | undefined} */
 		let newArray;
 		for (let i = 0; i < value.length; i++) {
 			const item = value[i];
 			if (item === "...") {
 				if (newArray === undefined) {
 					newArray = value.slice(0, i);
-					obj[prop] = /** @type {T[P]} */ (/** @type {unknown} */ (newArray));
+					obj[prop] = /** @type {T[P]} */ (
+						/** @type {T[P] | NonNullable<typeof newArray>} */ (newArray)
+					);
 				}
 				const items =
-					/** @type {EXPECTED_ANY[]} */
-					(/** @type {unknown} */ (factory()));
+					/** @type {NonNullable<typeof newArray>} */
+					(/** @type {T[P] | NonNullable<typeof newArray>} */ (factory()));
 				if (items !== undefined) {
 					for (const item of items) {
 						newArray.push(item);
@@ -386,7 +390,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 +540,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 +583,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 +654,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 +678,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 +707,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 +790,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,13 +1706,13 @@ 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))
 		)
 	);
 
-	const environment = /** @type {Environment} */ (output.environment);
+	const environment = output.environment;
 	/**
 	 * Returns true, when v is truthy or undefined.
 	 * @param {boolean | undefined} v value
@@ -2368,7 +2387,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 +2403,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 +2463,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);
@@ -2481,13 +2502,12 @@ const applyOptimizationDefaults = (
 	D(optimization, "realContentHash", production);
 	// 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
+	const minimizeAssignedInApply =
+		/** @type {Optimization["minimize"] | OptimizationMinimizeOptions} */ (
+			optimization.minimize
 		);
+	if (typeof minimizeAssignedInApply === "object") {
+		optimization.minimizeOptions = minimizeAssignedInApply;
 		optimization.minimize = true;
 	}
 	D(optimization, "minimize", production);
@@ -2496,25 +2516,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 +2558,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 +2581,51 @@ 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 {MinimizerCompiler} */ (
+							/** @type {Compiler | MinimizerCompiler} */ (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 +2639,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,35 +2664,57 @@ 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));
+				}).apply(
+					/** @type {MinimizerCompiler} */ (
+						/** @type {Compiler | MinimizerCompiler} */ (compiler)
+					)
+				);
 			}
 		}
 	]);
@@ -2625,6 +2731,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,14 +5,14 @@
 
 "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<import("terser").MinifyOptions>["minimizer"] }} MinimizerOptions */
 
 /**
- * @param {unknown} candidate a configured plugin or minimizer entry
+ * @param {NonNullable<Compiler["options"]["optimization"]["minimizer"]>[number] | Compiler["options"]["plugins"][number]} candidate a configured plugin or minimizer entry
  * @param {string} file probe filename
  * @returns {boolean} whether the candidate minimizes that file
  */
@@ -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 };
 };

package/lib/config/normalization.js

@@ -7,6 +7,11 @@
 
 const util = require("util");
 const { fileUrlToPath } = require("../util/identifier");
+const memoize = require("../util/memoize");
+
+const getCreatePathGlobRegExp = memoize(
+	() => require("../util/globUtils").createPathGlobRegExp
+);
 
 /**
  * @import {
@@ -24,6 +29,7 @@ const { fileUrlToPath } = require("../util/identifier");
  * 	OptimizationRuntimeChunkNormalized,
  * 	OutputNormalized,
  * 	PluginsNormalized,
+ * 	RawDevTool,
  * 	WebpackOptions,
  * 	WebpackOptionsNormalized
  * } from "../../declarations/WebpackOptions"
@@ -307,6 +313,10 @@ const getNormalizedWebpackOptions = (config) => ({
 		? config.ignoreWarnings.map((ignore) => {
 				if (typeof ignore === "function") return ignore;
 				const i = ignore instanceof RegExp ? { message: ignore } : ignore;
+				const file =
+					typeof i.file === "string"
+						? getCreatePathGlobRegExp()(i.file)
+						: i.file;
 				return (warning, { requestShortener }) => {
 					if (!i.message && !i.module && !i.file) return false;
 					if (i.message && !i.message.test(warning.message)) {
@@ -323,9 +333,9 @@ const getNormalizedWebpackOptions = (config) => ({
 						return false;
 					}
 					if (
-						i.file &&
+						file &&
 						(!(/** @type {WebpackError} */ (warning).file) ||
-							!i.file.test(/** @type {WebpackError} */ (warning).file))
+							!file.test(/** @type {WebpackError} */ (warning).file))
 					) {
 						return false;
 					}
@@ -344,7 +354,7 @@ const getNormalizedWebpackOptions = (config) => ({
 				unsafeCache: module.unsafeCache,
 				parser: keyedNestedConfig(module.parser, cloneObject, {
 					javascript: (parserOptions) => ({
-						// TODO webpack 6 remove from `ModuleOptions`, keep only `*ByModuleType`
+						// TODO in the next major release: remove from `ModuleOptions`, keep only `*ByModuleType`
 						unknownContextRequest: module.unknownContextRequest,
 						unknownContextRegExp: module.unknownContextRegExp,
 						unknownContextRecursive: module.unknownContextRecursive,
@@ -390,7 +400,7 @@ const getNormalizedWebpackOptions = (config) => ({
 					cacheGroups: cloneObject(splitChunks.cacheGroups)
 				}
 		),
-		// TODO webpack 6: normalize `minimize` to the per-asset-type object and
+		// TODO in the next major release: normalize `minimize` to the per-asset-type object and
 		// drop `minimizeOptions` — a breaking change for what plugins read back.
 		minimize:
 			typeof optimization.minimize === "object" ? true : optimization.minimize,
@@ -475,7 +485,7 @@ const getNormalizedWebpackOptions = (config) => ({
 			importFunctionName: output.importFunctionName,
 			importMetaName: output.importMetaName,
 			scriptType: output.scriptType,
-			// TODO webpack 6 remove `libraryTarget`/`auxiliaryComment`/`amdContainer`/etc in favor of the `library` option
+			// TODO in the next major release: remove `libraryTarget`/`auxiliaryComment`/`amdContainer`/etc in favor of the `library` option
 			library: libraryBase && {
 				type:
 					output.libraryTarget !== undefined
@@ -493,6 +503,7 @@ const getNormalizedWebpackOptions = (config) => ({
 					output.libraryExport !== undefined
 						? output.libraryExport
 						: libraryBase.export,
+				entryExports: libraryBase.entryExports,
 				name: libraryBase.name,
 				umdAmdContainer: libraryBase.umdAmdContainer,
 				umdNamedDefine:
@@ -745,7 +756,7 @@ const applyWebpackOptionsInterception = (options) => {
 		};
 	}
 
-	// TODO webpack 6 - remove compatibility logic and move `devtools` fully into `devtool` with multi-type support
+	// TODO in the next major release: remove compatibility logic and move `devtools` fully into `devtool` with multi-type support
 	let _devtool = options.devtool;
 	/** @type {WebpackOptionsNormalized["devtool"]} */
 	let cached;
@@ -756,7 +767,7 @@ const applyWebpackOptionsInterception = (options) => {
 			// Prefer `all`, then `javascript`, then `css`
 			const match = ["all", "javascript", "css"]
 				.map((type) =>
-					/** @type {Extract<WebpackOptionsNormalized["devtool"], EXPECTED_ANY[]>} */ (
+					/** @type {Exclude<WebpackOptionsNormalized["devtool"], RawDevTool | undefined>} */ (
 						_devtool
 					).find((item) => item.type === type)
 				)

package/lib/config/target.js

@@ -12,12 +12,22 @@ const getBrowserslistTargetHandler = memoize(() =>
 	require("./browserslistTargetHandler")
 );
 
+// The half of browserslist that finds a config, the same module instance the
+// queries use, so its caches stay shared and a request for one costs nothing
+// twice. browserslist's own entry requires it, so it resolves wherever that does
+const getBrowserslistConfigLoader = memoize(() => require("browserslist/node"));
+
 /**
  * Gets default target.
  * @param {string} context the context directory
  * @returns {string} default target
  */
 const getDefaultTarget = (context) => {
+	// WHY: the default only turns on whether a browserslist config exists, and
+	// the config half answers that without the caniuse data the queries read —
+	// 1.3 MB that a build with no such config never uses.
+	const config = getBrowserslistConfigLoader().loadConfig({ path: context });
+	if (!config) return "web";
 	const browsers = getBrowserslistTargetHandler().load(undefined, context);
 	return browsers ? "browserslist" : "web";
 };
@@ -110,7 +120,7 @@ const getDefaultTarget = (context) => {
  */
 const versionDependent = (major, minor) => {
 	if (!major) {
-		return () => /** @type {undefined} */ (undefined);
+		return () => undefined;
 	}
 	/** @type {number} */
 	const nMajor = Number(major);

package/lib/container/ContainerEntryDependency.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const Dependency = require("../Dependency");
+const Dependency = require("../graph/Dependency");
 const makeSerializable = require("../util/makeSerializable");
 
 /** @import { ExposesList } from "./ContainerEntryModule" */