webpack 4.9.1 → 4.10.2

package/lib/optimize/EnsureChunkConditionsPlugin.js

@@ -1,70 +1,70 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const GraphHelpers = require("../GraphHelpers");
-
-class EnsureChunkConditionsPlugin {
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"EnsureChunkConditionsPlugin",
-			compilation => {
-				const handler = chunks => {
-					let changed = false;
-					for (const module of compilation.modules) {
-						if (!module.chunkCondition) continue;
-						const sourceChunks = new Set();
-						const chunkGroups = new Set();
-						for (const chunk of module.chunksIterable) {
-							if (!module.chunkCondition(chunk)) {
-								sourceChunks.add(chunk);
-								for (const group of chunk.groupsIterable) {
-									chunkGroups.add(group);
-								}
-							}
-						}
-						if (sourceChunks.size === 0) continue;
-						const targetChunks = new Set();
-						chunkGroupLoop: for (const chunkGroup of chunkGroups) {
-							// Can module be placed in a chunk of this group?
-							for (const chunk of chunkGroup.chunks) {
-								if (module.chunkCondition(chunk)) {
-									targetChunks.add(chunk);
-									continue chunkGroupLoop;
-								}
-							}
-							// We reached the entrypoint: fail
-							if (chunkGroup.isInitial()) {
-								throw new Error(
-									"Cannot fullfil chunk condition of " + module.identifier()
-								);
-							}
-							// Try placing in all parents
-							for (const group of chunkGroup.parentsIterable) {
-								chunkGroups.add(group);
-							}
-						}
-						for (const sourceChunk of sourceChunks) {
-							GraphHelpers.disconnectChunkAndModule(sourceChunk, module);
-						}
-						for (const targetChunk of targetChunks) {
-							GraphHelpers.connectChunkAndModule(targetChunk, module);
-						}
-					}
-					if (changed) return true;
-				};
-				compilation.hooks.optimizeChunksBasic.tap(
-					"EnsureChunkConditionsPlugin",
-					handler
-				);
-				compilation.hooks.optimizeExtractedChunksBasic.tap(
-					"EnsureChunkConditionsPlugin",
-					handler
-				);
-			}
-		);
-	}
-}
-module.exports = EnsureChunkConditionsPlugin;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const GraphHelpers = require("../GraphHelpers");
+
+class EnsureChunkConditionsPlugin {
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"EnsureChunkConditionsPlugin",
+			compilation => {
+				const handler = chunks => {
+					let changed = false;
+					for (const module of compilation.modules) {
+						if (!module.chunkCondition) continue;
+						const sourceChunks = new Set();
+						const chunkGroups = new Set();
+						for (const chunk of module.chunksIterable) {
+							if (!module.chunkCondition(chunk)) {
+								sourceChunks.add(chunk);
+								for (const group of chunk.groupsIterable) {
+									chunkGroups.add(group);
+								}
+							}
+						}
+						if (sourceChunks.size === 0) continue;
+						const targetChunks = new Set();
+						chunkGroupLoop: for (const chunkGroup of chunkGroups) {
+							// Can module be placed in a chunk of this group?
+							for (const chunk of chunkGroup.chunks) {
+								if (module.chunkCondition(chunk)) {
+									targetChunks.add(chunk);
+									continue chunkGroupLoop;
+								}
+							}
+							// We reached the entrypoint: fail
+							if (chunkGroup.isInitial()) {
+								throw new Error(
+									"Cannot fullfil chunk condition of " + module.identifier()
+								);
+							}
+							// Try placing in all parents
+							for (const group of chunkGroup.parentsIterable) {
+								chunkGroups.add(group);
+							}
+						}
+						for (const sourceChunk of sourceChunks) {
+							GraphHelpers.disconnectChunkAndModule(sourceChunk, module);
+						}
+						for (const targetChunk of targetChunks) {
+							GraphHelpers.connectChunkAndModule(targetChunk, module);
+						}
+					}
+					if (changed) return true;
+				};
+				compilation.hooks.optimizeChunksBasic.tap(
+					"EnsureChunkConditionsPlugin",
+					handler
+				);
+				compilation.hooks.optimizeExtractedChunksBasic.tap(
+					"EnsureChunkConditionsPlugin",
+					handler
+				);
+			}
+		);
+	}
+}
+module.exports = EnsureChunkConditionsPlugin;

package/lib/optimize/FlagIncludedChunksPlugin.js

@@ -1,99 +1,99 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-class FlagIncludedChunksPlugin {
-	apply(compiler) {
-		compiler.hooks.compilation.tap("FlagIncludedChunksPlugin", compilation => {
-			compilation.hooks.optimizeChunkIds.tap(
-				"FlagIncludedChunksPlugin",
-				chunks => {
-					// prepare two bit integers for each module
-					// 2^31 is the max number represented as SMI in v8
-					// we want the bits distributed this way:
-					// the bit 2^31 is pretty rar and only one module should get it
-					// so it has a probability of 1 / modulesCount
-					// the first bit (2^0) is the easiest and every module could get it
-					// if it doesn't get a better bit
-					// from bit 2^n to 2^(n+1) there is a probability of p
-					// so 1 / modulesCount == p^31
-					// <=> p = sqrt31(1 / modulesCount)
-					// so we use a modulo of 1 / sqrt31(1 / modulesCount)
-					const moduleBits = new WeakMap();
-					const modulesCount = compilation.modules.length;
-
-					// precalculate the modulo values for each bit
-					const modulo = 1 / Math.pow(1 / modulesCount, 1 / 31);
-					const modulos = Array.from(
-						{ length: 31 },
-						(x, i) => Math.pow(modulo, i) | 0
-					);
-
-					// iterate all modules to generate bit values
-					let i = 0;
-					for (const module of compilation.modules) {
-						let bit = 30;
-						while (i % modulos[bit] !== 0) {
-							bit--;
-						}
-						moduleBits.set(module, 1 << bit);
-						i++;
-					}
-
-					// interate all chunks to generate bitmaps
-					const chunkModulesHash = new WeakMap();
-					for (const chunk of chunks) {
-						let hash = 0;
-						for (const module of chunk.modulesIterable) {
-							hash |= moduleBits.get(module);
-						}
-						chunkModulesHash.set(chunk, hash);
-					}
-
-					for (const chunkA of chunks) {
-						const chunkAHash = chunkModulesHash.get(chunkA);
-						const chunkAModulesCount = chunkA.getNumberOfModules();
-						if (chunkAModulesCount === 0) continue;
-						let bestModule = undefined;
-						for (const module of chunkA.modulesIterable) {
-							if (
-								bestModule === undefined ||
-								bestModule.getNumberOfChunks() > module.getNumberOfChunks()
-							)
-								bestModule = module;
-						}
-						loopB: for (const chunkB of bestModule.chunksIterable) {
-							// as we iterate the same iterables twice
-							// skip if we find ourselves
-							if (chunkA === chunkB) continue;
-
-							const chunkBModulesCount = chunkB.getNumberOfModules();
-
-							// ids for empty chunks are not included
-							if (chunkBModulesCount === 0) continue;
-
-							// instead of swapping A and B just bail
-							// as we loop twice the current A will be B and B then A
-							if (chunkAModulesCount > chunkBModulesCount) continue;
-
-							// is chunkA in chunkB?
-
-							// we do a cheap check for the hash value
-							const chunkBHash = chunkModulesHash.get(chunkB);
-							if ((chunkBHash & chunkAHash) !== chunkAHash) continue;
-
-							// compare all modules
-							for (const m of chunkA.modulesIterable) {
-								if (!chunkB.containsModule(m)) continue loopB;
-							}
-							chunkB.ids.push(chunkA.id);
-						}
-					}
-				}
-			);
-		});
-	}
-}
-module.exports = FlagIncludedChunksPlugin;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+class FlagIncludedChunksPlugin {
+	apply(compiler) {
+		compiler.hooks.compilation.tap("FlagIncludedChunksPlugin", compilation => {
+			compilation.hooks.optimizeChunkIds.tap(
+				"FlagIncludedChunksPlugin",
+				chunks => {
+					// prepare two bit integers for each module
+					// 2^31 is the max number represented as SMI in v8
+					// we want the bits distributed this way:
+					// the bit 2^31 is pretty rar and only one module should get it
+					// so it has a probability of 1 / modulesCount
+					// the first bit (2^0) is the easiest and every module could get it
+					// if it doesn't get a better bit
+					// from bit 2^n to 2^(n+1) there is a probability of p
+					// so 1 / modulesCount == p^31
+					// <=> p = sqrt31(1 / modulesCount)
+					// so we use a modulo of 1 / sqrt31(1 / modulesCount)
+					const moduleBits = new WeakMap();
+					const modulesCount = compilation.modules.length;
+
+					// precalculate the modulo values for each bit
+					const modulo = 1 / Math.pow(1 / modulesCount, 1 / 31);
+					const modulos = Array.from(
+						{ length: 31 },
+						(x, i) => Math.pow(modulo, i) | 0
+					);
+
+					// iterate all modules to generate bit values
+					let i = 0;
+					for (const module of compilation.modules) {
+						let bit = 30;
+						while (i % modulos[bit] !== 0) {
+							bit--;
+						}
+						moduleBits.set(module, 1 << bit);
+						i++;
+					}
+
+					// interate all chunks to generate bitmaps
+					const chunkModulesHash = new WeakMap();
+					for (const chunk of chunks) {
+						let hash = 0;
+						for (const module of chunk.modulesIterable) {
+							hash |= moduleBits.get(module);
+						}
+						chunkModulesHash.set(chunk, hash);
+					}
+
+					for (const chunkA of chunks) {
+						const chunkAHash = chunkModulesHash.get(chunkA);
+						const chunkAModulesCount = chunkA.getNumberOfModules();
+						if (chunkAModulesCount === 0) continue;
+						let bestModule = undefined;
+						for (const module of chunkA.modulesIterable) {
+							if (
+								bestModule === undefined ||
+								bestModule.getNumberOfChunks() > module.getNumberOfChunks()
+							)
+								bestModule = module;
+						}
+						loopB: for (const chunkB of bestModule.chunksIterable) {
+							// as we iterate the same iterables twice
+							// skip if we find ourselves
+							if (chunkA === chunkB) continue;
+
+							const chunkBModulesCount = chunkB.getNumberOfModules();
+
+							// ids for empty chunks are not included
+							if (chunkBModulesCount === 0) continue;
+
+							// instead of swapping A and B just bail
+							// as we loop twice the current A will be B and B then A
+							if (chunkAModulesCount > chunkBModulesCount) continue;
+
+							// is chunkA in chunkB?
+
+							// we do a cheap check for the hash value
+							const chunkBHash = chunkModulesHash.get(chunkB);
+							if ((chunkBHash & chunkAHash) !== chunkAHash) continue;
+
+							// compare all modules
+							for (const m of chunkA.modulesIterable) {
+								if (!chunkB.containsModule(m)) continue loopB;
+							}
+							chunkB.ids.push(chunkA.id);
+						}
+					}
+				}
+			);
+		});
+	}
+}
+module.exports = FlagIncludedChunksPlugin;

package/lib/optimize/LimitChunkCountPlugin.js

@@ -1,66 +1,66 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const validateOptions = require("schema-utils");
-const schema = require("../../schemas/plugins/optimize/LimitChunkCountPlugin.json");
-
-class LimitChunkCountPlugin {
-	constructor(options) {
-		validateOptions(schema, options || {}, "Limit Chunk Count Plugin");
-		this.options = options || {};
-	}
-	apply(compiler) {
-		const options = this.options;
-		compiler.hooks.compilation.tap("LimitChunkCountPlugin", compilation => {
-			compilation.hooks.optimizeChunksAdvanced.tap(
-				"LimitChunkCountPlugin",
-				chunks => {
-					const maxChunks = options.maxChunks;
-					if (!maxChunks) return;
-					if (maxChunks < 1) return;
-					if (chunks.length <= maxChunks) return;
-
-					const sortedExtendedPairCombinations = 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;
-						}, [])
-						.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);
-							return [a + b - ab, ab, pair[0], pair[1], a, b];
-						})
-						.filter(extendedPair => {
-							// filter pairs that do not have an integratedSize
-							// meaning they can NOT be integrated!
-							return extendedPair[1] !== false;
-						})
-						.sort((a, b) => {
-							// sadly javascript does an inplace sort here
-							// sort them by size
-							const diff = b[0] - a[0];
-							if (diff !== 0) return diff;
-							return a[1] - b[1];
-						});
-
-					const pair = sortedExtendedPairCombinations[0];
-
-					if (pair && pair[2].integrate(pair[3], "limit")) {
-						chunks.splice(chunks.indexOf(pair[3]), 1);
-						return true;
-					}
-				}
-			);
-		});
-	}
-}
-module.exports = LimitChunkCountPlugin;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const validateOptions = require("schema-utils");
+const schema = require("../../schemas/plugins/optimize/LimitChunkCountPlugin.json");
+
+class LimitChunkCountPlugin {
+	constructor(options) {
+		validateOptions(schema, options || {}, "Limit Chunk Count Plugin");
+		this.options = options || {};
+	}
+	apply(compiler) {
+		const options = this.options;
+		compiler.hooks.compilation.tap("LimitChunkCountPlugin", compilation => {
+			compilation.hooks.optimizeChunksAdvanced.tap(
+				"LimitChunkCountPlugin",
+				chunks => {
+					const maxChunks = options.maxChunks;
+					if (!maxChunks) return;
+					if (maxChunks < 1) return;
+					if (chunks.length <= maxChunks) return;
+
+					const sortedExtendedPairCombinations = 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;
+						}, [])
+						.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);
+							return [a + b - ab, ab, pair[0], pair[1], a, b];
+						})
+						.filter(extendedPair => {
+							// filter pairs that do not have an integratedSize
+							// meaning they can NOT be integrated!
+							return extendedPair[1] !== false;
+						})
+						.sort((a, b) => {
+							// sadly javascript does an inplace sort here
+							// sort them by size
+							const diff = b[0] - a[0];
+							if (diff !== 0) return diff;
+							return a[1] - b[1];
+						});
+
+					const pair = sortedExtendedPairCombinations[0];
+
+					if (pair && pair[2].integrate(pair[3], "limit")) {
+						chunks.splice(chunks.indexOf(pair[3]), 1);
+						return true;
+					}
+				}
+			);
+		});
+	}
+}
+module.exports = LimitChunkCountPlugin;

package/lib/optimize/MergeDuplicateChunksPlugin.js

@@ -1,75 +1,78 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-class MergeDuplicateChunksPlugin {
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"MergeDuplicateChunksPlugin",
-			compilation => {
-				compilation.hooks.optimizeChunksBasic.tap(
-					"MergeDuplicateChunksPlugin",
-					chunks => {
-						// remember already tested chunks for performance
-						const notDuplicates = new Set();
-
-						// for each chunk
-						for (const chunk of chunks) {
-							// track a Set of all chunk that could be duplicates
-							let possibleDuplicates;
-							for (const module of chunk.modulesIterable) {
-								if (possibleDuplicates === undefined) {
-									// when possibleDuplicates is not yet set,
-									// create a new Set from chunks of the current module
-									// including only chunks with the same number of modules
-									for (const dup of module.chunksIterable) {
-										if (
-											dup !== chunk &&
-											chunk.getNumberOfModules() === dup.getNumberOfModules() &&
-											!notDuplicates.has(dup)
-										) {
-											// delay allocating the new Set until here, reduce memory pressure
-											if (possibleDuplicates === undefined)
-												possibleDuplicates = new Set();
-											possibleDuplicates.add(dup);
-										}
-									}
-									// when no chunk is possible we can break here
-									if (possibleDuplicates === undefined) break;
-								} else {
-									// validate existing possible duplicates
-									for (const dup of possibleDuplicates) {
-										// remove possible duplicate when module is not contained
-										if (!dup.containsModule(module))
-											possibleDuplicates.delete(dup);
-									}
-									// when all chunks has been removed we can break here
-									if (possibleDuplicates.size === 0) break;
-								}
-							}
-
-							// when we found duplicates
-							if (
-								possibleDuplicates !== undefined &&
-								possibleDuplicates.size > 0
-							) {
-								for (const otherChunk of possibleDuplicates) {
-									if (otherChunk.hasRuntime() !== chunk.hasRuntime()) continue;
-									// merge them
-									if (chunk.integrate(otherChunk, "duplicate"))
-										chunks.splice(chunks.indexOf(otherChunk), 1);
-								}
-							}
-
-							// don't check already processed chunks twice
-							notDuplicates.add(chunk);
-						}
-					}
-				);
-			}
-		);
-	}
-}
-module.exports = MergeDuplicateChunksPlugin;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+class MergeDuplicateChunksPlugin {
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"MergeDuplicateChunksPlugin",
+			compilation => {
+				compilation.hooks.optimizeChunksBasic.tap(
+					"MergeDuplicateChunksPlugin",
+					chunks => {
+						// remember already tested chunks for performance
+						const notDuplicates = new Set();
+
+						// for each chunk
+						for (const chunk of chunks) {
+							// track a Set of all chunk that could be duplicates
+							let possibleDuplicates;
+							for (const module of chunk.modulesIterable) {
+								if (possibleDuplicates === undefined) {
+									// when possibleDuplicates is not yet set,
+									// create a new Set from chunks of the current module
+									// including only chunks with the same number of modules
+									for (const dup of module.chunksIterable) {
+										if (
+											dup !== chunk &&
+											chunk.getNumberOfModules() === dup.getNumberOfModules() &&
+											!notDuplicates.has(dup)
+										) {
+											// delay allocating the new Set until here, reduce memory pressure
+											if (possibleDuplicates === undefined) {
+												possibleDuplicates = new Set();
+											}
+											possibleDuplicates.add(dup);
+										}
+									}
+									// when no chunk is possible we can break here
+									if (possibleDuplicates === undefined) break;
+								} else {
+									// validate existing possible duplicates
+									for (const dup of possibleDuplicates) {
+										// remove possible duplicate when module is not contained
+										if (!dup.containsModule(module)) {
+											possibleDuplicates.delete(dup);
+										}
+									}
+									// when all chunks has been removed we can break here
+									if (possibleDuplicates.size === 0) break;
+								}
+							}
+
+							// when we found duplicates
+							if (
+								possibleDuplicates !== undefined &&
+								possibleDuplicates.size > 0
+							) {
+								for (const otherChunk of possibleDuplicates) {
+									if (otherChunk.hasRuntime() !== chunk.hasRuntime()) continue;
+									// merge them
+									if (chunk.integrate(otherChunk, "duplicate")) {
+										chunks.splice(chunks.indexOf(otherChunk), 1);
+									}
+								}
+							}
+
+							// don't check already processed chunks twice
+							notDuplicates.add(chunk);
+						}
+					}
+				);
+			}
+		);
+	}
+}
+module.exports = MergeDuplicateChunksPlugin;