@depup/webpack 5.105.4-depup.37

package/lib/optimize/EnsureChunkConditionsPlugin.js

@@ -0,0 +1,88 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { STAGE_BASIC } = require("../OptimizationStages");
+
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGroup")} ChunkGroup */
+/** @typedef {import("../Compiler")} Compiler */
+
+const PLUGIN_NAME = "EnsureChunkConditionsPlugin";
+
+class EnsureChunkConditionsPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		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);
+						}
+					}
+					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

@@ -0,0 +1,137 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { compareIds } = require("../util/comparators");
+
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Chunk").ChunkId} ChunkId */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+
+const PLUGIN_NAME = "FlagIncludedChunksPlugin";
+
+class FlagIncludedChunksPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			compilation.hooks.optimizeChunkIds.tap(PLUGIN_NAME, (chunks) => {
+				const chunkGraph = compilation.chunkGraph;
+
+				// 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)
+				/** @type {WeakMap<Module, number>} */
+				const moduleBits = new WeakMap();
+				const modulesCount = compilation.modules.size;
+
+				// precalculate the modulo values for each bit
+				const modulo = 1 / (1 / modulesCount) ** (1 / 31);
+				/** @type {number[]} */
+				const modulos = Array.from(
+					{ length: 31 },
+					/**
+					 * @param {number} x x
+					 * @param {number} i i
+					 * @returns {number} result
+					 */
+					(x, i) => (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++;
+				}
+
+				// iterate all chunks to generate bitmaps
+				/** @type {WeakMap<Chunk, number>} */
+				const chunkModulesHash = new WeakMap();
+				for (const chunk of chunks) {
+					let hash = 0;
+					for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+						hash |= /** @type {number} */ (moduleBits.get(module));
+					}
+					chunkModulesHash.set(chunk, hash);
+				}
+
+				for (const chunkA of chunks) {
+					const chunkAHash =
+						/** @type {number} */
+						(chunkModulesHash.get(chunkA));
+					const chunkAModulesCount = chunkGraph.getNumberOfChunkModules(chunkA);
+					if (chunkAModulesCount === 0) continue;
+					/** @type {undefined | Module} */
+					let bestModule;
+					for (const module of chunkGraph.getChunkModulesIterable(chunkA)) {
+						if (
+							bestModule === undefined ||
+							chunkGraph.getNumberOfModuleChunks(bestModule) >
+								chunkGraph.getNumberOfModuleChunks(module)
+						) {
+							bestModule = module;
+						}
+					}
+					loopB: for (const chunkB of chunkGraph.getModuleChunksIterable(
+						/** @type {Module} */ (bestModule)
+					)) {
+						// as we iterate the same iterables twice
+						// skip if we find ourselves
+						if (chunkA === chunkB) continue;
+
+						const chunkBModulesCount =
+							chunkGraph.getNumberOfChunkModules(chunkB);
+
+						// 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 =
+							/** @type {number} */
+							(chunkModulesHash.get(chunkB));
+						if ((chunkBHash & chunkAHash) !== chunkAHash) continue;
+
+						// compare all modules
+						for (const m of chunkGraph.getChunkModulesIterable(chunkA)) {
+							if (!chunkGraph.isModuleInChunk(m, chunkB)) continue loopB;
+						}
+
+						/** @type {ChunkId[]} */
+						(chunkB.ids).push(/** @type {ChunkId} */ (chunkA.id));
+						// https://github.com/webpack/webpack/issues/18837
+						/** @type {ChunkId[]} */
+						(chunkB.ids).sort(compareIds);
+					}
+				}
+			});
+		});
+	}
+}
+
+module.exports = FlagIncludedChunksPlugin;

package/lib/optimize/InnerGraph.js

@@ -0,0 +1,368 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Sergey Melyukov @smelukov
+*/
+
+"use strict";
+
+const { UsageState } = require("../ExportsInfo");
+const JavascriptParser = require("../javascript/JavascriptParser");
+
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../Parser").ParserState} ParserState */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+/** @typedef {Set<string | TopLevelSymbol>} InnerGraphValueSet */
+/** @typedef {InnerGraphValueSet | true} InnerGraphValue */
+/** @typedef {TopLevelSymbol | null} InnerGraphKey */
+/** @typedef {Map<InnerGraphKey, InnerGraphValue | undefined>} InnerGraph */
+/** @typedef {(value: boolean | Set<string> | undefined) => void} UsageCallback */
+
+/**
+ * @typedef {object} StateObject
+ * @property {InnerGraph} innerGraph
+ * @property {TopLevelSymbol=} currentTopLevelSymbol
+ * @property {Map<TopLevelSymbol, Set<UsageCallback>>} usageCallbackMap
+ */
+
+/** @typedef {false | StateObject} State */
+
+class TopLevelSymbol {
+	/**
+	 * @param {string} name name of the variable
+	 */
+	constructor(name) {
+		/** @type {string} */
+		this.name = name;
+	}
+}
+
+module.exports.TopLevelSymbol = TopLevelSymbol;
+
+/** @type {WeakMap<ParserState, State>} */
+const parserStateMap = new WeakMap();
+const topLevelSymbolTag = Symbol("top level symbol");
+
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {State | undefined} state
+ */
+function getState(parserState) {
+	return parserStateMap.get(parserState);
+}
+
+/**
+ * @param {ParserState} state parser state
+ * @param {TopLevelSymbol | null} symbol the symbol, or null for all symbols
+ * @param {Usage} usage usage data
+ * @returns {void}
+ */
+module.exports.addUsage = (state, symbol, usage) => {
+	const innerGraphState = getState(state);
+
+	if (innerGraphState) {
+		const { innerGraph } = innerGraphState;
+		const info = innerGraph.get(symbol);
+		if (usage === true) {
+			innerGraph.set(symbol, true);
+		} else if (info === undefined) {
+			innerGraph.set(symbol, new Set([usage]));
+		} else if (info !== true) {
+			info.add(usage);
+		}
+	}
+};
+
+/** @typedef {string | TopLevelSymbol | true} Usage */
+
+/**
+ * @param {JavascriptParser} parser the parser
+ * @param {string} name name of variable
+ * @param {Usage} usage usage data
+ * @returns {void}
+ */
+module.exports.addVariableUsage = (parser, name, usage) => {
+	const symbol =
+		/** @type {TopLevelSymbol} */ (
+			parser.getTagData(name, topLevelSymbolTag)
+		) || module.exports.tagTopLevelSymbol(parser, name);
+	if (symbol) {
+		module.exports.addUsage(parser.state, symbol, 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()
+	});
+};
+
+/** @typedef {Set<string> | boolean} UsedByExports */
+
+/**
+ * @param {Dependency} dependency the dependency
+ * @param {UsedByExports | 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}
+ */
+module.exports.inferDependencyUsage = (state) => {
+	const innerGraphState = getState(state);
+
+	if (!innerGraphState) {
+		return;
+	}
+
+	const { innerGraph, usageCallbackMap } = innerGraphState;
+	/** @type {Map<InnerGraphKey, InnerGraphValueSet | undefined>} */
+	const processed = new Map();
+	// flatten graph to terminal nodes (string, undefined or true)
+	const nonTerminal = new Set(innerGraph.keys());
+	while (nonTerminal.size > 0) {
+		for (const key of nonTerminal) {
+			/** @type {InnerGraphValue} */
+			let newSet = new Set();
+			let isTerminal = true;
+			const value = innerGraph.get(key);
+			let alreadyProcessed = processed.get(key);
+			if (alreadyProcessed === undefined) {
+				/** @type {InnerGraphValueSet} */
+				alreadyProcessed = new Set();
+				processed.set(key, alreadyProcessed);
+			}
+			if (value !== true && value !== undefined) {
+				for (const item of value) {
+					alreadyProcessed.add(item);
+				}
+				for (const item of value) {
+					if (typeof item === "string") {
+						newSet.add(item);
+					} else {
+						const itemValue = innerGraph.get(item);
+						if (itemValue === true) {
+							newSet = true;
+							break;
+						}
+						if (itemValue !== undefined) {
+							for (const i of itemValue) {
+								if (i === key) continue;
+								if (alreadyProcessed.has(i)) continue;
+								newSet.add(i);
+								if (typeof i !== "string") {
+									isTerminal = false;
+								}
+							}
+						}
+					}
+				}
+				if (newSet === true) {
+					innerGraph.set(key, true);
+				} else if (newSet.size === 0) {
+					innerGraph.set(key, undefined);
+				} else {
+					innerGraph.set(key, newSet);
+				}
+			}
+			if (isTerminal) {
+				nonTerminal.delete(key);
+
+				// For the global key, merge with all other keys
+				if (key === null) {
+					const globalValue = innerGraph.get(null);
+					if (globalValue) {
+						for (const [key, value] of innerGraph) {
+							if (key !== null && value !== true) {
+								if (globalValue === true) {
+									innerGraph.set(key, true);
+								} else {
+									const newSet = new Set(value);
+									for (const item of globalValue) {
+										newSet.add(item);
+									}
+									innerGraph.set(key, newSet);
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	/** @type {Map<Dependency, true | Set<string>>} */
+	for (const [symbol, callbacks] of usageCallbackMap) {
+		const usage = /** @type {true | Set<string> | undefined} */ (
+			innerGraph.get(symbol)
+		);
+		for (const callback of callbacks) {
+			callback(usage === undefined ? false : usage);
+		}
+	}
+};
+
+/**
+ * @param {Dependency} dependency the dependency
+ * @param {UsedByExports | undefined} 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
+ */
+module.exports.onUsage = (state, onUsageCallback) => {
+	const innerGraphState = getState(state);
+
+	if (innerGraphState) {
+		const { usageCallbackMap, currentTopLevelSymbol } = innerGraphState;
+		if (currentTopLevelSymbol) {
+			let callbacks = usageCallbackMap.get(currentTopLevelSymbol);
+
+			if (callbacks === undefined) {
+				/** @type {Set<UsageCallback>} */
+				callbacks = new Set();
+				usageCallbackMap.set(currentTopLevelSymbol, callbacks);
+			}
+
+			callbacks.add(onUsageCallback);
+		} else {
+			onUsageCallback(true);
+		}
+	} else {
+		onUsageCallback(undefined);
+	}
+};
+
+/**
+ * @param {ParserState} state parser state
+ * @param {TopLevelSymbol | undefined} symbol the symbol
+ */
+module.exports.setTopLevelSymbol = (state, symbol) => {
+	const innerGraphState = getState(state);
+
+	if (innerGraphState) {
+		innerGraphState.currentTopLevelSymbol = symbol;
+	}
+};
+
+/**
+ * @param {JavascriptParser} parser parser
+ * @param {string} name name of variable
+ * @returns {TopLevelSymbol | undefined} symbol
+ */
+module.exports.tagTopLevelSymbol = (parser, name) => {
+	const innerGraphState = getState(parser.state);
+	if (!innerGraphState) return;
+
+	parser.defineVariable(name);
+
+	const existingTag = /** @type {TopLevelSymbol} */ (
+		parser.getTagData(name, topLevelSymbolTag)
+	);
+	if (existingTag) {
+		return existingTag;
+	}
+
+	const symbol = new TopLevelSymbol(name);
+	parser.tagVariable(
+		name,
+		topLevelSymbolTag,
+		symbol,
+		JavascriptParser.VariableInfoFlags.Normal
+	);
+	return symbol;
+};
+
+module.exports.topLevelSymbolTag = topLevelSymbolTag;