webpack 5.99.9 → 5.100.0

package/lib/optimize/EnsureChunkConditionsPlugin.js

@@ -11,6 +11,8 @@ const { STAGE_BASIC } = require("../OptimizationStages");
 /** @typedef {import("../ChunkGroup")} ChunkGroup */
 /** @typedef {import("../Compiler")} Compiler */
 
+const PLUGIN_NAME = "EnsureChunkConditionsPlugin";
+
 class EnsureChunkConditionsPlugin {
 	/**
 	 * Apply the plugin
@@ -18,71 +20,69 @@ class EnsureChunkConditionsPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"EnsureChunkConditionsPlugin",
-			compilation => {
-				/**
-				 * @param {Iterable<Chunk>} chunks the chunks
-				 */
-				const handler = chunks => {
-					const chunkGraph = compilation.chunkGraph;
-					// These sets are hoisted here to save memory
-					// They are cleared at the end of every loop
-					/** @type {Set<Chunk>} */
-					const sourceChunks = new Set();
-					/** @type {Set<ChunkGroup>} */
-					const chunkGroups = new Set();
-					for (const module of compilation.modules) {
-						if (!module.hasChunkCondition()) continue;
-						for (const chunk of chunkGraph.getModuleChunksIterable(module)) {
-							if (!module.chunkCondition(chunk, compilation)) {
-								sourceChunks.add(chunk);
-								for (const group of chunk.groupsIterable) {
-									chunkGroups.add(group);
-								}
+		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+			/**
+			 * @param {Iterable<Chunk>} chunks the chunks
+			 */
+			const handler = chunks => {
+				const chunkGraph = compilation.chunkGraph;
+				// These sets are hoisted here to save memory
+				// They are cleared at the end of every loop
+				/** @type {Set<Chunk>} */
+				const sourceChunks = new Set();
+				/** @type {Set<ChunkGroup>} */
+				const chunkGroups = new Set();
+				for (const module of compilation.modules) {
+					if (!module.hasChunkCondition()) continue;
+					for (const chunk of chunkGraph.getModuleChunksIterable(module)) {
+						if (!module.chunkCondition(chunk, compilation)) {
+							sourceChunks.add(chunk);
+							for (const group of chunk.groupsIterable) {
+								chunkGroups.add(group);
 							}
 						}
-						if (sourceChunks.size === 0) continue;
-						/** @type {Set<Chunk>} */
-						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, compilation)) {
-									targetChunks.add(chunk);
-									continue chunkGroupLoop;
-								}
-							}
-							// We reached the entrypoint: fail
-							if (chunkGroup.isInitial()) {
-								throw new Error(
-									`Cannot fulfil chunk condition of ${module.identifier()}`
-								);
-							}
-							// Try placing in all parents
-							for (const group of chunkGroup.parentsIterable) {
-								chunkGroups.add(group);
+					}
+					if (sourceChunks.size === 0) continue;
+					/** @type {Set<Chunk>} */
+					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, compilation)) {
+								targetChunks.add(chunk);
+								continue chunkGroupLoop;
 							}
 						}
-						for (const sourceChunk of sourceChunks) {
-							chunkGraph.disconnectChunkAndModule(sourceChunk, module);
+						// We reached the entrypoint: fail
+						if (chunkGroup.isInitial()) {
+							throw new Error(
+								`Cannot fulfil chunk condition of ${module.identifier()}`
+							);
 						}
-						for (const targetChunk of targetChunks) {
-							chunkGraph.connectChunkAndModule(targetChunk, module);
+						// Try placing in all parents
+						for (const group of chunkGroup.parentsIterable) {
+							chunkGroups.add(group);
 						}
-						sourceChunks.clear();
-						chunkGroups.clear();
 					}
-				};
-				compilation.hooks.optimizeChunks.tap(
-					{
-						name: "EnsureChunkConditionsPlugin",
-						stage: STAGE_BASIC
-					},
-					handler
-				);
-			}
-		);
+					for (const sourceChunk of sourceChunks) {
+						chunkGraph.disconnectChunkAndModule(sourceChunk, module);
+					}
+					for (const targetChunk of targetChunks) {
+						chunkGraph.connectChunkAndModule(targetChunk, module);
+					}
+					sourceChunks.clear();
+					chunkGroups.clear();
+				}
+			};
+			compilation.hooks.optimizeChunks.tap(
+				{
+					name: PLUGIN_NAME,
+					stage: STAGE_BASIC
+				},
+				handler
+			);
+		});
 	}
 }
+
 module.exports = EnsureChunkConditionsPlugin;

package/lib/optimize/FlagIncludedChunksPlugin.js

@@ -78,8 +78,9 @@ class FlagIncludedChunksPlugin {
 							bestModule === undefined ||
 							chunkGraph.getNumberOfModuleChunks(bestModule) >
 								chunkGraph.getNumberOfModuleChunks(module)
-						)
+						) {
 							bestModule = module;
+						}
 					}
 					loopB: for (const chunkB of chunkGraph.getModuleChunksIterable(
 						/** @type {Module} */ (bestModule)
@@ -122,4 +123,5 @@ class FlagIncludedChunksPlugin {
 		});
 	}
 }
+
 module.exports = FlagIncludedChunksPlugin;

package/lib/optimize/InnerGraph.js

@@ -30,6 +30,17 @@ const { UsageState } = require("../ExportsInfo");
 
 /** @typedef {false|StateObject} State */
 
+class TopLevelSymbol {
+	/**
+	 * @param {string} name name of the variable
+	 */
+	constructor(name) {
+		this.name = name;
+	}
+}
+
+module.exports.TopLevelSymbol = TopLevelSymbol;
+
 /** @type {WeakMap<ParserState, State>} */
 const parserStateMap = new WeakMap();
 const topLevelSymbolTag = Symbol("top level symbol");
@@ -42,39 +53,6 @@ function getState(parserState) {
 	return parserStateMap.get(parserState);
 }
 
-/**
- * @param {ParserState} parserState parser state
- * @returns {void}
- */
-module.exports.bailout = parserState => {
-	parserStateMap.set(parserState, false);
-};
-
-/**
- * @param {ParserState} parserState parser state
- * @returns {void}
- */
-module.exports.enable = parserState => {
-	const state = parserStateMap.get(parserState);
-	if (state === false) {
-		return;
-	}
-	parserStateMap.set(parserState, {
-		innerGraph: new Map(),
-		currentTopLevelSymbol: undefined,
-		usageCallbackMap: new Map()
-	});
-};
-
-/**
- * @param {ParserState} parserState parser state
- * @returns {boolean} true, when enabled
- */
-module.exports.isEnabled = parserState => {
-	const state = parserStateMap.get(parserState);
-	return Boolean(state);
-};
-
 /**
  * @param {ParserState} state parser state
  * @param {TopLevelSymbol | null} symbol the symbol, or null for all symbols
@@ -113,6 +91,71 @@ module.exports.addVariableUsage = (parser, name, usage) => {
 	}
 };
 
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {void}
+ */
+module.exports.bailout = parserState => {
+	parserStateMap.set(parserState, false);
+};
+
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {void}
+ */
+module.exports.enable = parserState => {
+	const state = parserStateMap.get(parserState);
+	if (state === false) {
+		return;
+	}
+	parserStateMap.set(parserState, {
+		innerGraph: new Map(),
+		currentTopLevelSymbol: undefined,
+		usageCallbackMap: new Map()
+	});
+};
+
+/**
+ * @param {Dependency} dependency the dependency
+ * @param {Set<string> | boolean | undefined} usedByExports usedByExports info
+ * @param {ModuleGraph} moduleGraph moduleGraph
+ * @returns {null | false | GetConditionFn} function to determine if the connection is active
+ */
+module.exports.getDependencyUsedByExportsCondition = (
+	dependency,
+	usedByExports,
+	moduleGraph
+) => {
+	if (usedByExports === false) return false;
+	if (usedByExports !== true && usedByExports !== undefined) {
+		const selfModule =
+			/** @type {Module} */
+			(moduleGraph.getParentModule(dependency));
+		const exportsInfo = moduleGraph.getExportsInfo(selfModule);
+		return (connections, runtime) => {
+			for (const exportName of usedByExports) {
+				if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused) {
+					return true;
+				}
+			}
+			return false;
+		};
+	}
+	return null;
+};
+
+/**
+ * @param {ParserState} state parser state
+ * @returns {TopLevelSymbol|void} usage data
+ */
+module.exports.getTopLevelSymbol = state => {
+	const innerGraphState = getState(state);
+
+	if (innerGraphState) {
+		return innerGraphState.currentTopLevelSymbol;
+	}
+};
+
 /**
  * @param {ParserState} state parser state
  * @returns {void}
@@ -209,6 +252,45 @@ module.exports.inferDependencyUsage = state => {
 	}
 };
 
+/**
+ * @param {Dependency} dependency the dependency
+ * @param {Set<string> | boolean} usedByExports usedByExports info
+ * @param {ModuleGraph} moduleGraph moduleGraph
+ * @param {RuntimeSpec} runtime runtime
+ * @returns {boolean} false, when unused. Otherwise true
+ */
+module.exports.isDependencyUsedByExports = (
+	dependency,
+	usedByExports,
+	moduleGraph,
+	runtime
+) => {
+	if (usedByExports === false) return false;
+	if (usedByExports !== true && usedByExports !== undefined) {
+		const selfModule =
+			/** @type {Module} */
+			(moduleGraph.getParentModule(dependency));
+		const exportsInfo = moduleGraph.getExportsInfo(selfModule);
+		let used = false;
+		for (const exportName of usedByExports) {
+			if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused) {
+				used = true;
+			}
+		}
+		if (!used) return false;
+	}
+	return true;
+};
+
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {boolean} true, when enabled
+ */
+module.exports.isEnabled = parserState => {
+	const state = parserStateMap.get(parserState);
+	return Boolean(state);
+};
+
 /**
  * @param {ParserState} state parser state
  * @param {UsageCallback} onUsageCallback on usage callback
@@ -247,18 +329,6 @@ module.exports.setTopLevelSymbol = (state, symbol) => {
 	}
 };
 
-/**
- * @param {ParserState} state parser state
- * @returns {TopLevelSymbol|void} usage data
- */
-module.exports.getTopLevelSymbol = state => {
-	const innerGraphState = getState(state);
-
-	if (innerGraphState) {
-		return innerGraphState.currentTopLevelSymbol;
-	}
-};
-
 /**
  * @param {JavascriptParser} parser parser
  * @param {string} name name of variable
@@ -282,71 +352,4 @@ module.exports.tagTopLevelSymbol = (parser, name) => {
 	return fn;
 };
 
-/**
- * @param {Dependency} dependency the dependency
- * @param {Set<string> | boolean} usedByExports usedByExports info
- * @param {ModuleGraph} moduleGraph moduleGraph
- * @param {RuntimeSpec} runtime runtime
- * @returns {boolean} false, when unused. Otherwise true
- */
-module.exports.isDependencyUsedByExports = (
-	dependency,
-	usedByExports,
-	moduleGraph,
-	runtime
-) => {
-	if (usedByExports === false) return false;
-	if (usedByExports !== true && usedByExports !== undefined) {
-		const selfModule =
-			/** @type {Module} */
-			(moduleGraph.getParentModule(dependency));
-		const exportsInfo = moduleGraph.getExportsInfo(selfModule);
-		let used = false;
-		for (const exportName of usedByExports) {
-			if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused)
-				used = true;
-		}
-		if (!used) return false;
-	}
-	return true;
-};
-
-/**
- * @param {Dependency} dependency the dependency
- * @param {Set<string> | boolean | undefined} usedByExports usedByExports info
- * @param {ModuleGraph} moduleGraph moduleGraph
- * @returns {null | false | GetConditionFn} function to determine if the connection is active
- */
-module.exports.getDependencyUsedByExportsCondition = (
-	dependency,
-	usedByExports,
-	moduleGraph
-) => {
-	if (usedByExports === false) return false;
-	if (usedByExports !== true && usedByExports !== undefined) {
-		const selfModule =
-			/** @type {Module} */
-			(moduleGraph.getParentModule(dependency));
-		const exportsInfo = moduleGraph.getExportsInfo(selfModule);
-		return (connections, runtime) => {
-			for (const exportName of usedByExports) {
-				if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused)
-					return true;
-			}
-			return false;
-		};
-	}
-	return null;
-};
-
-class TopLevelSymbol {
-	/**
-	 * @param {string} name name of the variable
-	 */
-	constructor(name) {
-		this.name = name;
-	}
-}
-
-module.exports.TopLevelSymbol = TopLevelSymbol;
 module.exports.topLevelSymbolTag = topLevelSymbolTag;

package/lib/optimize/InnerGraphPlugin.js

@@ -195,7 +195,7 @@ class InnerGraphPlugin {
 						}
 					});
 
-					parser.hooks.preDeclarator.tap(PLUGIN_NAME, (decl, statement) => {
+					parser.hooks.preDeclarator.tap(PLUGIN_NAME, (decl, _statement) => {
 						if (!InnerGraph.isEnabled(parser.state)) return;
 						if (
 							parser.scope.topLevelScope === true &&
@@ -363,7 +363,7 @@ class InnerGraphPlugin {
 						}
 					);
 
-					parser.hooks.declarator.tap(PLUGIN_NAME, (decl, statement) => {
+					parser.hooks.declarator.tap(PLUGIN_NAME, (decl, _statement) => {
 						if (!InnerGraph.isEnabled(parser.state)) return;
 						const fn = declWithTopLevelSymbol.get(decl);
 

package/lib/optimize/LimitChunkCountPlugin.js

@@ -15,7 +15,7 @@ const createSchemaValidation = require("../util/create-schema-validation");
 /** @typedef {import("../Compiler")} Compiler */
 
 const validate = createSchemaValidation(
-	require("../../schemas/plugins/optimize/LimitChunkCountPlugin.check.js"),
+	require("../../schemas/plugins/optimize/LimitChunkCountPlugin.check"),
 	() => require("../../schemas/plugins/optimize/LimitChunkCountPlugin.json"),
 	{
 		name: "Limit Chunk Count Plugin",
@@ -85,7 +85,8 @@ class LimitChunkCountPlugin {
 
 					// order chunks in a deterministic way
 					const compareChunksWithGraph = compareChunks(chunkGraph);
-					const orderedChunks = Array.from(chunks).sort(compareChunksWithGraph);
+					/** @type {Chunk[]} */
+					const orderedChunks = [...chunks].sort(compareChunksWithGraph);
 
 					// create a lazy sorted data structure to keep all combinations
 					// this is large. Size = chunks * (chunks - 1) / 2
@@ -296,4 +297,5 @@ class LimitChunkCountPlugin {
 		});
 	}
 }
+
 module.exports = LimitChunkCountPlugin;

package/lib/optimize/MangleExportsPlugin.js

@@ -7,9 +7,9 @@
 
 const { UsageState } = require("../ExportsInfo");
 const {
-	numberToIdentifier,
+	NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS,
 	NUMBER_OF_IDENTIFIER_START_CHARS,
-	NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS
+	numberToIdentifier
 } = require("../Template");
 const { assignDeterministicIds } = require("../ids/IdHelpers");
 const { compareSelect, compareStringsNumeric } = require("../util/comparators");
@@ -23,8 +23,9 @@ const { compareSelect, compareStringsNumeric } = require("../util/comparators");
  * @returns {boolean} mangle is possible
  */
 const canMangle = exportsInfo => {
-	if (exportsInfo.otherExportsInfo.getUsed(undefined) !== UsageState.Unused)
+	if (exportsInfo.otherExportsInfo.getUsed(undefined) !== UsageState.Unused) {
 		return false;
+	}
 	let hasSomethingToMangle = false;
 	for (const exportInfo of exportsInfo.exports) {
 		if (exportInfo.canMangle === true) {

package/lib/optimize/MergeDuplicateChunksPlugin.js

@@ -13,7 +13,7 @@ const { runtimeEqual } = require("../util/runtime");
 /** @typedef {import("../Compiler")} Compiler */
 
 const validate = createSchemaValidation(
-	require("../../schemas/plugins/optimize/MergeDuplicateChunksPlugin.check.js"),
+	require("../../schemas/plugins/optimize/MergeDuplicateChunksPlugin.check"),
 	() =>
 		require("../../schemas/plugins/optimize/MergeDuplicateChunksPlugin.json"),
 	{
@@ -22,6 +22,8 @@ const validate = createSchemaValidation(
 	}
 );
 
+const PLUGIN_NAME = "MergeDuplicateChunksPlugin";
+
 class MergeDuplicateChunksPlugin {
 	/**
 	 * @param {MergeDuplicateChunksPluginOptions} options options object
@@ -36,100 +38,97 @@ class MergeDuplicateChunksPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"MergeDuplicateChunksPlugin",
-			compilation => {
-				compilation.hooks.optimizeChunks.tap(
-					{
-						name: "MergeDuplicateChunksPlugin",
-						stage: this.options.stage
-					},
-					chunks => {
-						const { chunkGraph, moduleGraph } = compilation;
+		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+			compilation.hooks.optimizeChunks.tap(
+				{
+					name: PLUGIN_NAME,
+					stage: this.options.stage
+				},
+				chunks => {
+					const { chunkGraph, moduleGraph } = compilation;
 
-						// remember already tested chunks for performance
-						const notDuplicates = new Set();
+					// 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 chunkGraph.getChunkModulesIterable(chunk)) {
-								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 chunkGraph.getModuleChunksIterable(
-										module
-									)) {
-										if (
-											dup !== chunk &&
-											chunkGraph.getNumberOfChunkModules(chunk) ===
-												chunkGraph.getNumberOfChunkModules(dup) &&
-											!notDuplicates.has(dup)
-										) {
-											// delay allocating the new Set until here, reduce memory pressure
-											if (possibleDuplicates === undefined) {
-												possibleDuplicates = new Set();
-											}
-											possibleDuplicates.add(dup);
+					// for each chunk
+					for (const chunk of chunks) {
+						// track a Set of all chunk that could be duplicates
+						let possibleDuplicates;
+						for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+							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 chunkGraph.getModuleChunksIterable(module)) {
+									if (
+										dup !== chunk &&
+										chunkGraph.getNumberOfChunkModules(chunk) ===
+											chunkGraph.getNumberOfChunkModules(dup) &&
+										!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 (!chunkGraph.isModuleInChunk(module, dup)) {
-											possibleDuplicates.delete(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 (!chunkGraph.isModuleInChunk(module, dup)) {
+										possibleDuplicates.delete(dup);
 									}
-									// when all chunks has been removed we can break here
-									if (possibleDuplicates.size === 0) break;
 								}
+								// 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
-							) {
-								outer: for (const otherChunk of possibleDuplicates) {
-									if (otherChunk.hasRuntime() !== chunk.hasRuntime()) continue;
-									if (chunkGraph.getNumberOfEntryModules(chunk) > 0) continue;
-									if (chunkGraph.getNumberOfEntryModules(otherChunk) > 0)
-										continue;
-									if (!runtimeEqual(chunk.runtime, otherChunk.runtime)) {
-										for (const module of chunkGraph.getChunkModulesIterable(
-											chunk
-										)) {
-											const exportsInfo = moduleGraph.getExportsInfo(module);
-											if (
-												!exportsInfo.isEquallyUsed(
-													chunk.runtime,
-													otherChunk.runtime
-												)
-											) {
-												continue outer;
-											}
+						// when we found duplicates
+						if (
+							possibleDuplicates !== undefined &&
+							possibleDuplicates.size > 0
+						) {
+							outer: for (const otherChunk of possibleDuplicates) {
+								if (otherChunk.hasRuntime() !== chunk.hasRuntime()) continue;
+								if (chunkGraph.getNumberOfEntryModules(chunk) > 0) continue;
+								if (chunkGraph.getNumberOfEntryModules(otherChunk) > 0) {
+									continue;
+								}
+								if (!runtimeEqual(chunk.runtime, otherChunk.runtime)) {
+									for (const module of chunkGraph.getChunkModulesIterable(
+										chunk
+									)) {
+										const exportsInfo = moduleGraph.getExportsInfo(module);
+										if (
+											!exportsInfo.isEquallyUsed(
+												chunk.runtime,
+												otherChunk.runtime
+											)
+										) {
+											continue outer;
 										}
 									}
-									// merge them
-									if (chunkGraph.canChunksBeIntegrated(chunk, otherChunk)) {
-										chunkGraph.integrateChunks(chunk, otherChunk);
-										compilation.chunks.delete(otherChunk);
-									}
+								}
+								// merge them
+								if (chunkGraph.canChunksBeIntegrated(chunk, otherChunk)) {
+									chunkGraph.integrateChunks(chunk, otherChunk);
+									compilation.chunks.delete(otherChunk);
 								}
 							}
-
-							// don't check already processed chunks twice
-							notDuplicates.add(chunk);
 						}
+
+						// don't check already processed chunks twice
+						notDuplicates.add(chunk);
 					}
-				);
-			}
-		);
+				}
+			);
+		});
 	}
 }
+
 module.exports = MergeDuplicateChunksPlugin;