webpack 5.58.2 → 5.59.0

package/lib/Compilation.js

@@ -1883,7 +1883,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					creatingModuleDuringBuildSet
 				);
 			}
-			creatingModuleDuringBuildSet.add(originModule);
+			creatingModuleDuringBuildSet.add(module);
 
 			// When building is blocked by another module
 			// search for a cycle, cancel the cycle by throwing
@@ -4687,21 +4687,18 @@ This prevents using hashes of each other and should be avoided.`);
 			 * @returns {void}
 			 */
 			(module, push, callback) => {
-				this.addModuleQueue.waitFor(module, err => {
+				this.buildQueue.waitFor(module, err => {
 					if (err) return callback(err);
-					this.buildQueue.waitFor(module, err => {
+					this.processDependenciesQueue.waitFor(module, err => {
 						if (err) return callback(err);
-						this.processDependenciesQueue.waitFor(module, err => {
-							if (err) return callback(err);
-							for (const {
-								module: m
-							} of this.moduleGraph.getOutgoingConnections(module)) {
-								const size = modules.size;
-								modules.add(m);
-								if (modules.size !== size) push(m);
-							}
-							callback();
-						});
+						for (const { module: m } of this.moduleGraph.getOutgoingConnections(
+							module
+						)) {
+							const size = modules.size;
+							modules.add(m);
+							if (modules.size !== size) push(m);
+						}
+						callback();
 					});
 				});
 			},

package/lib/Compiler.js

@@ -219,9 +219,9 @@ class Compiler {
 		/** @type {string|null} */
 		this.recordsOutputPath = null;
 		this.records = {};
-		/** @type {Set<string>} */
+		/** @type {Set<string | RegExp>} */
 		this.managedPaths = new Set();
-		/** @type {Set<string>} */
+		/** @type {Set<string | RegExp>} */
 		this.immutablePaths = new Set();
 
 		/** @type {ReadonlySet<string>} */

package/lib/DefinePlugin.js

@@ -151,7 +151,7 @@ const stringifyObj = (
 		case false:
 			return arr ? `;${code}` : `;(${code})`;
 		default:
-			return `Object(${code})`;
+			return `/*#__PURE__*/Object(${code})`;
 	}
 };
 

package/lib/FileSystemInfo.js

@@ -853,8 +853,8 @@ class FileSystemInfo {
 	/**
 	 * @param {InputFileSystem} fs file system
 	 * @param {Object} options options
-	 * @param {Iterable<string>=} options.managedPaths paths that are only managed by a package manager
-	 * @param {Iterable<string>=} options.immutablePaths paths that are immutable
+	 * @param {Iterable<string | RegExp>=} options.managedPaths paths that are only managed by a package manager
+	 * @param {Iterable<string | RegExp>=} options.immutablePaths paths that are immutable
 	 * @param {Logger=} options.logger logger used to log invalid snapshots
 	 * @param {string | Hash=} options.hashFunction the hash function to use
 	 */
@@ -996,12 +996,19 @@ class FileSystemInfo {
 			processor: this._getManagedItemDirectoryInfo.bind(this)
 		});
 		this.managedPaths = Array.from(managedPaths);
-		this.managedPathsWithSlash = this.managedPaths.map(p =>
-			join(fs, p, "_").slice(0, -1)
+		this.managedPathsWithSlash = /** @type {string[]} */ (
+			this.managedPaths.filter(p => typeof p === "string")
+		).map(p => join(fs, p, "_").slice(0, -1));
+
+		this.managedPathsRegExps = /** @type {RegExp[]} */ (
+			this.managedPaths.filter(p => typeof p !== "string")
 		);
 		this.immutablePaths = Array.from(immutablePaths);
-		this.immutablePathsWithSlash = this.immutablePaths.map(p =>
-			join(fs, p, "_").slice(0, -1)
+		this.immutablePathsWithSlash = /** @type {string[]} */ (
+			this.immutablePaths.filter(p => typeof p === "string")
+		).map(p => join(fs, p, "_").slice(0, -1));
+		this.immutablePathsRegExps = /** @type {RegExp[]} */ (
+			this.immutablePaths.filter(p => typeof p !== "string")
 		);
 
 		this._cachedDeprecatedFileTimestamps = undefined;
@@ -1966,12 +1973,29 @@ class FileSystemInfo {
 			}
 		};
 		const checkManaged = (path, managedSet) => {
+			for (const immutablePath of this.immutablePathsRegExps) {
+				if (immutablePath.test(path)) {
+					managedSet.add(path);
+					return true;
+				}
+			}
 			for (const immutablePath of this.immutablePathsWithSlash) {
 				if (path.startsWith(immutablePath)) {
 					managedSet.add(path);
 					return true;
 				}
 			}
+			for (const managedPath of this.managedPathsRegExps) {
+				const match = managedPath.exec(path);
+				if (match) {
+					const managedItem = getManagedItem(managedPath[1], path);
+					if (managedItem) {
+						managedItems.add(managedItem);
+						managedSet.add(path);
+						return true;
+					}
+				}
+			}
 			for (const managedPath of this.managedPathsWithSlash) {
 				if (path.startsWith(managedPath)) {
 					const managedItem = getManagedItem(managedPath, path);
@@ -2923,10 +2947,29 @@ class FileSystemInfo {
 				files,
 				(file, callback) => {
 					const child = join(this.fs, path, file);
+					for (const immutablePath of this.immutablePathsRegExps) {
+						if (immutablePath.test(path)) {
+							// ignore any immutable path for timestamping
+							return callback(null, fromImmutablePath(path));
+						}
+					}
 					for (const immutablePath of this.immutablePathsWithSlash) {
 						if (path.startsWith(immutablePath)) {
 							// ignore any immutable path for timestamping
-							return callback(null, fromImmutablePath(immutablePath));
+							return callback(null, fromImmutablePath(path));
+						}
+					}
+					for (const managedPath of this.managedPathsRegExps) {
+						const match = managedPath.exec(path);
+						if (match) {
+							const managedItem = getManagedItem(managedPath[1], path);
+							if (managedItem) {
+								// construct timestampHash from managed info
+								return this.managedItemQueue.add(managedItem, (err, info) => {
+									if (err) return callback(err);
+									return callback(null, fromManagedItem(info));
+								});
+							}
 						}
 					}
 					for (const managedPath of this.managedPathsWithSlash) {

package/lib/NormalModule.js

@@ -187,6 +187,8 @@ makeSerializable(
  * @typedef {Object} NormalModuleCompilationHooks
  * @property {SyncHook<[object, NormalModule]>} loader
  * @property {SyncHook<[LoaderItem[], NormalModule, object]>} beforeLoaders
+ * @property {SyncHook<[NormalModule]>} beforeParse
+ * @property {SyncHook<[NormalModule]>} beforeSnapshot
  * @property {HookMap<AsyncSeriesBailHook<[string, NormalModule], string | Buffer>>} readResourceForScheme
  * @property {HookMap<AsyncSeriesBailHook<[object], string | Buffer>>} readResource
  * @property {AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>} needBuild
@@ -211,6 +213,8 @@ class NormalModule extends Module {
 			hooks = {
 				loader: new SyncHook(["loaderContext", "module"]),
 				beforeLoaders: new SyncHook(["loaders", "module", "loaderContext"]),
+				beforeParse: new SyncHook(["module"]),
+				beforeSnapshot: new SyncHook(["module"]),
 				// TODO webpack 6 deprecate
 				readResourceForScheme: new HookMap(scheme => {
 					const hook = hooks.readResource.for(scheme);
@@ -387,6 +391,7 @@ class NormalModule extends Module {
 		this.generator = m.generator;
 		this.generatorOptions = m.generatorOptions;
 		this.resource = m.resource;
+		this.resourceResolveData = m.resourceResolveData;
 		this.context = m.context;
 		this.matchResource = m.matchResource;
 		this.loaders = m.loaders;
@@ -488,9 +493,10 @@ class NormalModule extends Module {
 	 * @param {WebpackOptions} options webpack options
 	 * @param {Compilation} compilation the compilation
 	 * @param {InputFileSystem} fs file system from reading
+	 * @param {NormalModuleCompilationHooks} hooks the hooks
 	 * @returns {NormalModuleLoaderContext} loader context
 	 */
-	createLoaderContext(resolver, options, compilation, fs) {
+	_createLoaderContext(resolver, options, compilation, fs, hooks) {
 		const { requestShortener } = compilation.runtimeTemplate;
 		const getCurrentLoaderName = () => {
 			const currentLoader = this.getCurrentLoader(loaderContext);
@@ -659,10 +665,7 @@ class NormalModule extends Module {
 
 		Object.assign(loaderContext, options.loader);
 
-		NormalModule.getCompilationHooks(compilation).loader.call(
-			loaderContext,
-			this
-		);
+		hooks.loader.call(loaderContext, this);
 
 		return loaderContext;
 	}
@@ -723,15 +726,17 @@ class NormalModule extends Module {
 	 * @param {Compilation} compilation the compilation
 	 * @param {ResolverWithOptions} resolver the resolver
 	 * @param {InputFileSystem} fs the file system
+	 * @param {NormalModuleCompilationHooks} hooks the hooks
 	 * @param {function(WebpackError=): void} callback callback function
 	 * @returns {void}
 	 */
-	doBuild(options, compilation, resolver, fs, callback) {
-		const loaderContext = this.createLoaderContext(
+	_doBuild(options, compilation, resolver, fs, hooks, callback) {
+		const loaderContext = this._createLoaderContext(
 			resolver,
 			options,
 			compilation,
-			fs
+			fs,
+			hooks
 		);
 
 		const processResult = (err, result) => {
@@ -785,8 +790,6 @@ class NormalModule extends Module {
 			return callback();
 		};
 
-		const hooks = NormalModule.getCompilationHooks(compilation);
-
 		this.buildInfo.fileDependencies = new LazySet();
 		this.buildInfo.contextDependencies = new LazySet();
 		this.buildInfo.missingDependencies = new LazySet();
@@ -942,7 +945,9 @@ class NormalModule extends Module {
 
 		const startTime = compilation.compiler.fsStartTime || Date.now();
 
-		return this.doBuild(options, compilation, resolver, fs, err => {
+		const hooks = NormalModule.getCompilationHooks(compilation);
+
+		return this._doBuild(options, compilation, resolver, fs, hooks, err => {
 			// if we have an error mark module as failed and exit
 			if (err) {
 				this.markModuleAsErrored(err);
@@ -974,6 +979,13 @@ class NormalModule extends Module {
 			};
 
 			const handleBuildDone = () => {
+				try {
+					hooks.beforeSnapshot.call(this);
+				} catch (err) {
+					this.markModuleAsErrored(err);
+					return callback();
+				}
+
 				const snapshotOptions = compilation.options.snapshot.module;
 				if (!this.buildInfo.cacheable || !snapshotOptions) {
 					return callback();
@@ -1038,6 +1050,14 @@ class NormalModule extends Module {
 				);
 			};
 
+			try {
+				hooks.beforeParse.call(this);
+			} catch (err) {
+				this.markModuleAsErrored(err);
+				this._initBuildHash(compilation);
+				return callback();
+			}
+
 			// check if this module should !not! be parsed.
 			// if so, exit here;
 			const noParseRule = options.module && options.module.noParse;

package/lib/RuntimeTemplate.js

@@ -807,7 +807,7 @@ class RuntimeTemplate {
 					? `(0,${access})`
 					: asiSafe === false
 					? `;(0,${access})`
-					: `Object(${access})`;
+					: `/*#__PURE__*/Object(${access})`;
 			}
 			return access;
 		} else {

package/lib/WebpackOptionsApply.js

@@ -279,8 +279,6 @@ class WebpackOptionsApply extends OptionsApply {
 		if (options.experiments.buildHttp) {
 			const HttpUriPlugin = require("./schemes/HttpUriPlugin");
 			const httpOptions = options.experiments.buildHttp;
-			if (httpOptions === true)
-				throw new Error("Unexpected due to normalization");
 			new HttpUriPlugin(httpOptions).apply(compiler);
 		}
 

package/lib/cache/AddManagedPathsPlugin.js

@@ -9,8 +9,8 @@
 
 class AddManagedPathsPlugin {
 	/**
-	 * @param {Iterable<string>} managedPaths list of managed paths
-	 * @param {Iterable<string>} immutablePaths list of immutable paths
+	 * @param {Iterable<string | RegExp>} managedPaths list of managed paths
+	 * @param {Iterable<string | RegExp>} immutablePaths list of immutable paths
 	 */
 	constructor(managedPaths, immutablePaths) {
 		this.managedPaths = new Set(managedPaths);

package/lib/cache/PackFileCacheStrategy.js

@@ -370,8 +370,8 @@ class Pack {
 			for (const identifier of content.items) {
 				mergedItems.add(identifier);
 			}
-			for (const identifer of content.used) {
-				mergedUsedItems.add(identifer);
+			for (const identifier of content.used) {
+				mergedUsedItems.add(identifier);
 			}
 			addToMergedMap.push(async map => {
 				// unpack existing content

package/lib/config/defaults.js

@@ -19,6 +19,7 @@ const {
 /** @typedef {import("../../declarations/WebpackOptions").EntryDescription} EntryDescription */
 /** @typedef {import("../../declarations/WebpackOptions").EntryNormalized} Entry */
 /** @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").InfrastructureLogging} InfrastructureLogging */
@@ -161,6 +162,8 @@ const applyWebpackOptionsDefaults = options => {
 
 	applyExperimentsDefaults(options.experiments, { production, development });
 
+	const futureDefaults = options.experiments.futureDefaults;
+
 	F(options, "cache", () =>
 		development ? { type: /** @type {"memory"} */ ("memory") } : false
 	);
@@ -172,7 +175,10 @@ const applyWebpackOptionsDefaults = options => {
 	});
 	const cache = !!options.cache;
 
-	applySnapshotDefaults(options.snapshot, { production });
+	applySnapshotDefaults(options.snapshot, {
+		production,
+		futureDefaults
+	});
 
 	applyModuleDefaults(options.module, {
 		cache,
@@ -192,7 +198,7 @@ const applyWebpackOptionsDefaults = options => {
 		development,
 		entry: options.entry,
 		module: options.module,
-		futureDefaults: options.experiments.futureDefaults
+		futureDefaults
 	});
 
 	applyExternalsPresetsDefaults(options.externalsPresets, {
@@ -252,7 +258,7 @@ const applyWebpackOptionsDefaults = options => {
 };
 
 /**
- * @param {Experiments} experiments options
+ * @param {ExperimentsNormalized} experiments options
  * @param {Object} options options
  * @param {boolean} options.production is production
  * @param {boolean} options.development is development mode
@@ -265,14 +271,14 @@ const applyExperimentsDefaults = (experiments, { production, development }) => {
 	D(experiments, "outputModule", false);
 	D(experiments, "asset", false);
 	D(experiments, "layers", false);
-	D(experiments, "lazyCompilation", false);
-	D(experiments, "buildHttp", false);
+	D(experiments, "lazyCompilation", undefined);
+	D(experiments, "buildHttp", undefined);
 	D(experiments, "futureDefaults", false);
 	D(experiments, "cacheUnaffected", experiments.futureDefaults);
 
 	if (typeof experiments.buildHttp === "object") {
 		D(experiments.buildHttp, "frozen", production);
-		D(experiments.buildHttp, "upgrade", development);
+		D(experiments.buildHttp, "upgrade", false);
 	}
 };
 
@@ -348,49 +354,65 @@ const applyCacheDefaults = (
  * @param {SnapshotOptions} snapshot options
  * @param {Object} options options
  * @param {boolean} options.production is production
+ * @param {boolean} options.futureDefaults is future defaults enabled
  * @returns {void}
  */
-const applySnapshotDefaults = (snapshot, { production }) => {
-	A(snapshot, "managedPaths", () => {
-		if (process.versions.pnp === "3") {
-			const match =
-				/^(.+?)[\\/]cache[\\/]watchpack-npm-[^\\/]+\.zip[\\/]node_modules[\\/]/.exec(
-					require.resolve("watchpack")
-				);
-			if (match) {
-				return [path.resolve(match[1], "unplugged")];
-			}
-		} else {
-			const match = /^(.+?[\\/]node_modules)[\\/]/.exec(
-				// eslint-disable-next-line node/no-extraneous-require
-				require.resolve("watchpack")
-			);
-			if (match) {
-				return [match[1]];
-			}
-		}
-		return [];
-	});
-	A(snapshot, "immutablePaths", () => {
-		if (process.versions.pnp === "1") {
-			const match =
-				/^(.+?[\\/]v4)[\\/]npm-watchpack-[^\\/]+-[\da-f]{40}[\\/]node_modules[\\/]/.exec(
+const applySnapshotDefaults = (snapshot, { production, futureDefaults }) => {
+	if (futureDefaults) {
+		F(snapshot, "managedPaths", () =>
+			process.versions.pnp === "3"
+				? [
+						/^(.+?(?:[\\/]\.yarn[\\/]unplugged[\\/][^\\/]+)?[\\/]node_modules[\\/])/
+				  ]
+				: [/^(.+?[\\/]node_modules[\\/])/]
+		);
+		F(snapshot, "immutablePaths", () =>
+			process.versions.pnp === "3"
+				? [/^(.+?[\\/]cache[\\/][^\\/]+\.zip[\\/]node_modules[\\/])/]
+				: []
+		);
+	} else {
+		A(snapshot, "managedPaths", () => {
+			if (process.versions.pnp === "3") {
+				const match =
+					/^(.+?)[\\/]cache[\\/]watchpack-npm-[^\\/]+\.zip[\\/]node_modules[\\/]/.exec(
+						require.resolve("watchpack")
+					);
+				if (match) {
+					return [path.resolve(match[1], "unplugged")];
+				}
+			} else {
+				const match = /^(.+?[\\/]node_modules)[\\/]/.exec(
+					// eslint-disable-next-line node/no-extraneous-require
 					require.resolve("watchpack")
 				);
-			if (match) {
-				return [match[1]];
+				if (match) {
+					return [match[1]];
+				}
 			}
-		} else if (process.versions.pnp === "3") {
-			const match =
-				/^(.+?)[\\/]watchpack-npm-[^\\/]+\.zip[\\/]node_modules[\\/]/.exec(
-					require.resolve("watchpack")
-				);
-			if (match) {
-				return [match[1]];
+			return [];
+		});
+		A(snapshot, "immutablePaths", () => {
+			if (process.versions.pnp === "1") {
+				const match =
+					/^(.+?[\\/]v4)[\\/]npm-watchpack-[^\\/]+-[\da-f]{40}[\\/]node_modules[\\/]/.exec(
+						require.resolve("watchpack")
+					);
+				if (match) {
+					return [match[1]];
+				}
+			} else if (process.versions.pnp === "3") {
+				const match =
+					/^(.+?)[\\/]watchpack-npm-[^\\/]+\.zip[\\/]node_modules[\\/]/.exec(
+						require.resolve("watchpack")
+					);
+				if (match) {
+					return [match[1]];
+				}
 			}
-		}
-		return [];
-	});
+			return [];
+		});
+	}
 	F(snapshot, "resolveBuildDependencies", () => ({
 		timestamp: true,
 		hash: true

package/lib/config/normalization.js

@@ -174,7 +174,12 @@ const getNormalizedWebpackOptions = config => {
 		experiments: nestedConfig(config.experiments, experiments => ({
 			...experiments,
 			buildHttp: optionalNestedConfig(experiments.buildHttp, options =>
-				options === true ? {} : options
+				Array.isArray(options) ? { allowedUris: options } : options
+			),
+			lazyCompilation: optionalNestedConfig(
+				experiments.lazyCompilation,
+				options =>
+					options === true ? {} : options === false ? undefined : options
 			)
 		})),
 		externals: config.externals,

package/lib/optimize/ConcatenatedModule.js

@@ -564,7 +564,7 @@ const getFinalName = (
 				? `(0,${reference})`
 				: asiSafe === false
 				? `;(0,${reference})`
-				: `Object(${reference})`;
+				: `/*#__PURE__*/Object(${reference})`;
 		}
 		return reference;
 	}

package/lib/optimize/SplitChunksPlugin.js

@@ -59,6 +59,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {ChunkFilterFunction=} chunksFilter
  * @property {boolean=} enforce
  * @property {SplitChunksSizes} minSize
+ * @property {SplitChunksSizes} minSizeReduction
  * @property {SplitChunksSizes} minRemainingSize
  * @property {SplitChunksSizes} enforceSizeThreshold
  * @property {SplitChunksSizes} maxAsyncSize
@@ -80,6 +81,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {GetName=} getName
  * @property {ChunkFilterFunction=} chunksFilter
  * @property {SplitChunksSizes} minSize
+ * @property {SplitChunksSizes} minSizeReduction
  * @property {SplitChunksSizes} minRemainingSize
  * @property {SplitChunksSizes} enforceSizeThreshold
  * @property {SplitChunksSizes} maxAsyncSize
@@ -132,6 +134,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {ChunkFilterFunction} chunksFilter
  * @property {string[]} defaultSizeTypes
  * @property {SplitChunksSizes} minSize
+ * @property {SplitChunksSizes} minSizeReduction
  * @property {SplitChunksSizes} minRemainingSize
  * @property {SplitChunksSizes} enforceSizeThreshold
  * @property {SplitChunksSizes} maxInitialSize
@@ -336,6 +339,21 @@ const checkMinSize = (sizes, minSize) => {
 	return true;
 };
 
+/**
+ * @param {SplitChunksSizes} sizes the sizes
+ * @param {SplitChunksSizes} minSizeReduction the min sizes
+ * @param {number} chunkCount number of chunks
+ * @returns {boolean} true if there are sizes and all existing sizes are at least `minSizeReduction`
+ */
+const checkMinSizeReduction = (sizes, minSizeReduction, chunkCount) => {
+	for (const key of Object.keys(minSizeReduction)) {
+		const size = sizes[key];
+		if (size === undefined || size === 0) continue;
+		if (size * chunkCount < minSizeReduction[key]) return false;
+	}
+	return true;
+};
+
 /**
  * @param {SplitChunksSizes} sizes the sizes
  * @param {SplitChunksSizes} minSize the min sizes
@@ -548,6 +566,10 @@ const checkModuleLayer = (test, module) => {
  */
 const createCacheGroupSource = (options, key, defaultSizeTypes) => {
 	const minSize = normalizeSizes(options.minSize, defaultSizeTypes);
+	const minSizeReduction = normalizeSizes(
+		options.minSizeReduction,
+		defaultSizeTypes
+	);
 	const maxSize = normalizeSizes(options.maxSize, defaultSizeTypes);
 	return {
 		key,
@@ -556,6 +578,7 @@ const createCacheGroupSource = (options, key, defaultSizeTypes) => {
 		chunksFilter: normalizeChunksFilter(options.chunks),
 		enforce: options.enforce,
 		minSize,
+		minSizeReduction,
 		minRemainingSize: mergeSizes(
 			normalizeSizes(options.minRemainingSize, defaultSizeTypes),
 			minSize
@@ -594,6 +617,10 @@ module.exports = class SplitChunksPlugin {
 		];
 		const fallbackCacheGroup = options.fallbackCacheGroup || {};
 		const minSize = normalizeSizes(options.minSize, defaultSizeTypes);
+		const minSizeReduction = normalizeSizes(
+			options.minSizeReduction,
+			defaultSizeTypes
+		);
 		const maxSize = normalizeSizes(options.maxSize, defaultSizeTypes);
 
 		/** @type {SplitChunksOptions} */
@@ -601,6 +628,7 @@ module.exports = class SplitChunksPlugin {
 			chunksFilter: normalizeChunksFilter(options.chunks || "all"),
 			defaultSizeTypes,
 			minSize,
+			minSizeReduction,
 			minRemainingSize: mergeSizes(
 				normalizeSizes(options.minRemainingSize, defaultSizeTypes),
 				minSize
@@ -668,6 +696,10 @@ module.exports = class SplitChunksPlugin {
 			cacheGroupSource.minSize,
 			cacheGroupSource.enforce ? undefined : this.options.minSize
 		);
+		const minSizeReduction = mergeSizes(
+			cacheGroupSource.minSizeReduction,
+			cacheGroupSource.enforce ? undefined : this.options.minSizeReduction
+		);
 		const minRemainingSize = mergeSizes(
 			cacheGroupSource.minRemainingSize,
 			cacheGroupSource.enforce ? undefined : this.options.minRemainingSize
@@ -681,6 +713,7 @@ module.exports = class SplitChunksPlugin {
 			priority: cacheGroupSource.priority || 0,
 			chunksFilter: cacheGroupSource.chunksFilter || this.options.chunksFilter,
 			minSize,
+			minSizeReduction,
 			minRemainingSize,
 			enforceSizeThreshold,
 			maxAsyncSize: mergeSizes(
@@ -1244,6 +1277,14 @@ module.exports = class SplitChunksPlugin {
 					for (const [key, info] of chunksInfoMap) {
 						if (removeMinSizeViolatingModules(info)) {
 							chunksInfoMap.delete(key);
+						} else if (
+							!checkMinSizeReduction(
+								info.sizes,
+								info.cacheGroup.minSizeReduction,
+								info.chunks.size
+							)
+						) {
+							chunksInfoMap.delete(key);
 						}
 					}
 
@@ -1531,7 +1572,14 @@ module.exports = class SplitChunksPlugin {
 										chunksInfoMap.delete(key);
 										continue;
 									}
-									if (removeMinSizeViolatingModules(info)) {
+									if (
+										removeMinSizeViolatingModules(info) ||
+										!checkMinSizeReduction(
+											info.sizes,
+											info.cacheGroup.minSizeReduction,
+											info.chunks.size
+										)
+									) {
 										chunksInfoMap.delete(key);
 										continue;
 									}