JavaScriptExample
diff --git a/‎lib/optimize/MinChunkSizePlugin.js‎
Lines changed: 23 additions & 22 deletions b/‎lib/optimize/MinChunkSizePlugin.js‎
Lines changed: 23 additions & 22 deletions
@@ -17,43 +17,44 @@ class MinChunkSizePlugin {
 		const minChunkSize = options.minChunkSize;
 		compiler.plugin("compilation", (compilation) => {
 			compilation.plugin("optimize-chunks-advanced", (chunks) => {
-
-				let combinations = [];
-				chunks.forEach((a, idx) => {
-					for(let i = 0; i < idx; i++) {
-						const b = chunks[i];
-						combinations.push([b, a]);
-					}
-				});
-
 				const equalOptions = {
 					chunkOverhead: 1,
 					entryChunkMultiplicator: 1
 				};
-				combinations = combinations.filter((pair) => {
-					return pair[0].size(equalOptions) < minChunkSize || pair[1].size(equalOptions) < minChunkSize;
-				});
 
-				combinations.forEach((pair) => {
+				const sortedSizeFilteredExtendedPairCombinations = chunks.reduce((combinations, a, idx) => {
+					// create combination pairs
+					for(let i = 0; i < idx; i++) {
+						const b = chunks[i];
+						combinations.push([b, a]);
+					}
+					return combinations;
+				}, []).filter((pair) => {
+					// check if one of the chunks sizes is smaller than the minChunkSize
+					const p0SmallerThanMinChunkSize = pair[0].size(equalOptions) < minChunkSize;
+					const p1mallerThanMinChunkSize = pair[1].size(equalOptions) < minChunkSize;
+					return p0SmallerThanMinChunkSize || p1mallerThanMinChunkSize;
+				}).map((pair) => {
+					// extend combination pairs with size and integrated size
 					const a = pair[0].size(options);
 					const b = pair[1].size(options);
 					const ab = pair[0].integratedSize(pair[1], options);
 					pair.unshift(a + b - ab, ab);
-				});
-
-				combinations = combinations.filter((pair) => {
+					return [a + b - ab, ab, pair[0], pair[1]];
+				}).filter((pair) => {
+					// filter pairs that do not have an integratedSize
+					// meaning they can NOT be integrated!
 					return pair[1] !== false;
-				});
-
-				if(combinations.length === 0) return;
-
-				combinations.sort((a, b) => {
+				}).sort((a, b) => { // sadly javascript does an inplace sort here
+					// sort by size
 					const diff = b[0] - a[0];
 					if(diff !== 0) return diff;
 					return a[1] - b[1];
 				});
 
-				const pair = combinations[0];
+				if(sortedSizeFilteredExtendedPairCombinations.length === 0) return;
+
+				const pair = sortedSizeFilteredExtendedPairCombinations[0];
 
 				pair[2].integrate(pair[3], "min-size");
 				chunks.splice(chunks.indexOf(pair[3]), 1);