webpack 5.85.1 → 5.87.0

package/lib/json/JsonParser.js

@@ -5,16 +5,20 @@
 
 "use strict";
 
-const parseJson = require("json-parse-even-better-errors");
 const Parser = require("../Parser");
 const JsonExportsDependency = require("../dependencies/JsonExportsDependency");
+const memoize = require("../util/memoize");
 const JsonData = require("./JsonData");
 
 /** @typedef {import("../../declarations/plugins/JsonModulesPluginParser").JsonModulesPluginParserOptions} JsonModulesPluginParserOptions */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
 /** @typedef {import("./JsonModulesPlugin").RawJsonData} RawJsonData */
 
+const getParseJson = memoize(() => require("json-parse-even-better-errors"));
+
 class JsonParser extends Parser {
 	/**
 	 * @param {JsonModulesPluginParserOptions} options parser options
@@ -36,17 +40,26 @@ class JsonParser extends Parser {
 
 		/** @type {NonNullable<JsonModulesPluginParserOptions["parse"]>} */
 		const parseFn =
-			typeof this.options.parse === "function" ? this.options.parse : parseJson;
-		/** @type {Buffer | RawJsonData} */
-		const data =
-			typeof source === "object"
-				? source
-				: parseFn(source[0] === "\ufeff" ? source.slice(1) : source);
-		const jsonData = new JsonData(data);
-		state.module.buildInfo.jsonData = jsonData;
-		state.module.buildInfo.strict = true;
-		state.module.buildMeta.exportsType = "default";
-		state.module.buildMeta.defaultObject =
+			typeof this.options.parse === "function"
+				? this.options.parse
+				: getParseJson();
+		/** @type {Buffer | RawJsonData | undefined} */
+		let data;
+		try {
+			data =
+				typeof source === "object"
+					? source
+					: parseFn(source[0] === "\ufeff" ? source.slice(1) : source);
+		} catch (e) {
+			throw new Error(`Cannot parse JSON: ${/** @type {Error} */ (e).message}`);
+		}
+		const jsonData = new JsonData(/** @type {Buffer | RawJsonData} */ (data));
+		const buildInfo = /** @type {BuildInfo} */ (state.module.buildInfo);
+		buildInfo.jsonData = jsonData;
+		buildInfo.strict = true;
+		const buildMeta = /** @type {BuildMeta} */ (state.module.buildMeta);
+		buildMeta.exportsType = "default";
+		buildMeta.defaultObject =
 			typeof data === "object" ? "redirect-warn" : false;
 		state.module.addDependency(new JsonExportsDependency(jsonData));
 		return state;

package/lib/node/ReadFileCompileAsyncWasmPlugin.js

@@ -40,6 +40,7 @@ class ReadFileCompileAsyncWasmPlugin {
 							: globalWasmLoading;
 					return wasmLoading === this._type;
 				};
+				const { importMetaName } = compilation.outputOptions;
 				/**
 				 * @type {(path: string) => string}
 				 */
@@ -48,7 +49,7 @@ class ReadFileCompileAsyncWasmPlugin {
 							Template.asString([
 								"Promise.all([import('fs'), import('url')]).then(([{ readFile }, { URL }]) => new Promise((resolve, reject) => {",
 								Template.indent([
-									`readFile(new URL(${path}, import.meta.url), (err, buffer) => {`,
+									`readFile(new URL(${path}, ${importMetaName}.url), (err, buffer) => {`,
 									Template.indent([
 										"if (err) return reject(err);",
 										"",

package/lib/optimize/AggressiveMergingPlugin.js

@@ -10,7 +10,15 @@ const { STAGE_ADVANCED } = require("../OptimizationStages");
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
+/**
+ * @typedef {Object} AggressiveMergingPluginOptions
+ * @property {number=} minSizeReduce minimal size reduction to trigger merging
+ */
+
 class AggressiveMergingPlugin {
+	/**
+	 * @param {AggressiveMergingPluginOptions=} [options] options object
+	 */
 	constructor(options) {
 		if (
 			(options !== undefined && typeof options !== "object") ||

package/lib/optimize/AggressiveSplittingPlugin.js

@@ -30,6 +30,12 @@ const validate = createSchemaValidation(
 	}
 );
 
+/**
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {Chunk} oldChunk the old chunk
+ * @param {Chunk} newChunk the new chunk
+ * @returns {(module: Module) => void} function to move module between chunks
+ */
 const moveModuleBetween = (chunkGraph, oldChunk, newChunk) => {
 	return module => {
 		chunkGraph.disconnectChunkAndModule(oldChunk, module);
@@ -92,6 +98,7 @@ class AggressiveSplittingPlugin {
 			compilation => {
 				let needAdditionalSeal = false;
 				let newSplits;
+				/** @type {Set<Chunk>} */
 				let fromAggressiveSplittingSet;
 				let chunkSplitDataMap;
 				compilation.hooks.optimize.tap("AggressiveSplittingPlugin", () => {
@@ -133,8 +140,8 @@ class AggressiveSplittingPlugin {
 							? recordedSplits.concat(newSplits)
 							: recordedSplits;
 
-						const minSize = this.options.minSize;
-						const maxSize = this.options.maxSize;
+						const minSize = /** @type {number} */ (this.options.minSize);
+						const maxSize = /** @type {number} */ (this.options.maxSize);
 
 						const applySplit = splitData => {
 							// Cannot split if id is already taken

package/lib/optimize/EnsureChunkConditionsPlugin.js

@@ -21,6 +21,9 @@ class EnsureChunkConditionsPlugin {
 		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

package/lib/optimize/FlagIncludedChunksPlugin.js

@@ -6,6 +6,7 @@
 "use strict";
 
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Chunk").ChunkId} ChunkId */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
 
@@ -61,13 +62,15 @@ class FlagIncludedChunksPlugin {
 					for (const chunk of chunks) {
 						let hash = 0;
 						for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
-							hash |= moduleBits.get(module);
+							hash |= /** @type {number} */ (moduleBits.get(module));
 						}
 						chunkModulesHash.set(chunk, hash);
 					}
 
 					for (const chunkA of chunks) {
-						const chunkAHash = chunkModulesHash.get(chunkA);
+						const chunkAHash =
+							/** @type {number} */
+							(chunkModulesHash.get(chunkA));
 						const chunkAModulesCount =
 							chunkGraph.getNumberOfChunkModules(chunkA);
 						if (chunkAModulesCount === 0) continue;
@@ -81,7 +84,7 @@ class FlagIncludedChunksPlugin {
 								bestModule = module;
 						}
 						loopB: for (const chunkB of chunkGraph.getModuleChunksIterable(
-							bestModule
+							/** @type {Module} */ (bestModule)
 						)) {
 							// as we iterate the same iterables twice
 							// skip if we find ourselves
@@ -100,14 +103,17 @@ class FlagIncludedChunksPlugin {
 							// is chunkA in chunkB?
 
 							// we do a cheap check for the hash value
-							const chunkBHash = chunkModulesHash.get(chunkB);
+							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;
 							}
-							chunkB.ids.push(chunkA.id);
+							/** @type {ChunkId[]} */
+							(chunkB.ids).push(/** @type {ChunkId} */ (chunkA.id));
 						}
 					}
 				}

package/lib/optimize/InnerGraph.js

@@ -16,7 +16,7 @@ const { UsageState } = require("../ExportsInfo");
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-/** @typedef {Map<TopLevelSymbol | null, Set<string | TopLevelSymbol> | true>} InnerGraph */
+/** @typedef {Map<TopLevelSymbol | null, Set<string | TopLevelSymbol> | true | undefined>} InnerGraph */
 /** @typedef {function(boolean | Set<string> | undefined): void} UsageCallback */
 
 /**
@@ -34,7 +34,7 @@ const topLevelSymbolTag = Symbol("top level symbol");
 
 /**
  * @param {ParserState} parserState parser state
- * @returns {State} state
+ * @returns {State | undefined} state
  */
 function getState(parserState) {
 	return parserStateMap.get(parserState);
@@ -235,7 +235,7 @@ exports.onUsage = (state, onUsageCallback) => {
 
 /**
  * @param {ParserState} state parser state
- * @param {TopLevelSymbol} symbol the symbol
+ * @param {TopLevelSymbol | undefined} symbol the symbol
  */
 exports.setTopLevelSymbol = (state, symbol) => {
 	const innerGraphState = getState(state);
@@ -260,7 +260,7 @@ exports.getTopLevelSymbol = state => {
 /**
  * @param {JavascriptParser} parser parser
  * @param {string} name name of variable
- * @returns {TopLevelSymbol} symbol
+ * @returns {TopLevelSymbol | undefined} symbol
  */
 exports.tagTopLevelSymbol = (parser, name) => {
 	const innerGraphState = getState(parser.state);

package/lib/optimize/LimitChunkCountPlugin.js

@@ -36,6 +36,12 @@ const validate = createSchemaValidation(
  * @property {number} bSize
  */
 
+/**
+ * @template K, V
+ * @param {Map<K, Set<V>>} map map
+ * @param {K} key key
+ * @param {V} value value
+ */
 const addToSetMap = (map, key, value) => {
 	const set = map.get(key);
 	if (set === undefined) {
@@ -68,7 +74,9 @@ class LimitChunkCountPlugin {
 				},
 				chunks => {
 					const chunkGraph = compilation.chunkGraph;
-					const maxChunks = options.maxChunks;
+					const maxChunks =
+						/** @type {LimitChunkCountPluginOptions} */
+						(options).maxChunks;
 					if (!maxChunks) return;
 					if (maxChunks < 1) return;
 					if (compilation.chunks.size <= maxChunks) return;
@@ -88,9 +96,17 @@ class LimitChunkCountPlugin {
 						c => c.sizeDiff,
 						(a, b) => b - a,
 						// Layer 2: ordered by smallest combined size
+						/**
+						 * @param {ChunkCombination} c combination
+						 * @returns {number} integrated size
+						 */
 						c => c.integratedSize,
 						(a, b) => a - b,
 						// Layer 3: ordered by position difference in orderedChunk (-> to be deterministic)
+						/**
+						 * @param {ChunkCombination} c combination
+						 * @returns {number} position difference
+						 */
 						c => c.bIdx - c.aIdx,
 						(a, b) => a - b,
 						// Layer 4: ordered by position in orderedChunk (-> to be deterministic)
@@ -193,14 +209,18 @@ class LimitChunkCountPlugin {
 							// Update all affected combinations
 							// delete all combination with the removed chunk
 							// we will use combinations with the kept chunk instead
-							for (const combination of combinationsByChunk.get(a)) {
+							for (const combination of /** @type {Set<ChunkCombination>} */ (
+								combinationsByChunk.get(a)
+							)) {
 								if (combination.deleted) continue;
 								combination.deleted = true;
 								combinations.delete(combination);
 							}
 
 							// Update combinations with the kept chunk with new sizes
-							for (const combination of combinationsByChunk.get(b)) {
+							for (const combination of /** @type {Set<ChunkCombination>} */ (
+								combinationsByChunk.get(b)
+							)) {
 								if (combination.deleted) continue;
 								if (combination.a === b) {
 									if (!chunkGraph.canChunksBeIntegrated(a, combination.b)) {
@@ -243,7 +263,12 @@ class LimitChunkCountPlugin {
 									finishUpdate();
 								}
 							}
-							combinationsByChunk.set(a, combinationsByChunk.get(b));
+							combinationsByChunk.set(
+								a,
+								/** @type {Set<ChunkCombination>} */ (
+									combinationsByChunk.get(b)
+								)
+							);
 							combinationsByChunk.delete(b);
 						}
 					}

package/lib/optimize/MangleExportsPlugin.js

@@ -39,7 +39,7 @@ const comparator = compareSelect(e => e.name, compareStringsNumeric);
 /**
  * @param {boolean} deterministic use deterministic names
  * @param {ExportsInfo} exportsInfo exports info
- * @param {boolean} isNamespace is namespace object
+ * @param {boolean | undefined} isNamespace is namespace object
  * @returns {void}
  */
 const mangleExportsInfo = (deterministic, exportsInfo, isNamespace) => {

package/lib/optimize/MinMaxSizeWarning.js

@@ -9,6 +9,11 @@ const SizeFormatHelpers = require("../SizeFormatHelpers");
 const WebpackError = require("../WebpackError");
 
 class MinMaxSizeWarning extends WebpackError {
+	/**
+	 * @param {string[] | undefined} keys keys
+	 * @param {number} minSize minimum size
+	 * @param {number} maxSize maximum size
+	 */
 	constructor(keys, minSize, maxSize) {
 		let keysMessage = "Fallback cache group";
 		if (keys) {

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -40,6 +40,10 @@ const ConcatenatedModule = require("./ConcatenatedModule");
  * @property {number} added
  */
 
+/**
+ * @param {string} msg message
+ * @returns {string} formatted message
+ */
 const formatBailoutReason = msg => {
 	return "ModuleConcatenation bailout: " + msg;
 };
@@ -64,8 +68,13 @@ class ModuleConcatenationPlugin {
 				);
 			}
 			const moduleGraph = compilation.moduleGraph;
+			/** @type {Map<Module, string | ((requestShortener: RequestShortener) => string)>} */
 			const bailoutReasonMap = new Map();
 
+			/**
+			 * @param {Module} module the module
+			 * @param {string | ((requestShortener: RequestShortener) => string)} reason the reason
+			 */
 			const setBailoutReason = (module, reason) => {
 				setInnerBailoutReason(module, reason);
 				moduleGraph
@@ -77,16 +86,30 @@ class ModuleConcatenationPlugin {
 					);
 			};
 
+			/**
+			 * @param {Module} module the module
+			 * @param {string | ((requestShortener: RequestShortener) => string)} reason the reason
+			 */
 			const setInnerBailoutReason = (module, reason) => {
 				bailoutReasonMap.set(module, reason);
 			};
 
+			/**
+			 * @param {Module} module the module
+			 * @param {RequestShortener} requestShortener the request shortener
+			 * @returns {string | ((requestShortener: RequestShortener) => string) | undefined} the reason
+			 */
 			const getInnerBailoutReason = (module, requestShortener) => {
 				const reason = bailoutReasonMap.get(module);
 				if (typeof reason === "function") return reason(requestShortener);
 				return reason;
 			};
 
+			/**
+			 * @param {Module} module the module
+			 * @param {Module | function(RequestShortener): string} problem the problem
+			 * @returns {(requestShortener: RequestShortener) => string} the reason
+			 */
 			const formatBailoutWarning = (module, problem) => requestShortener => {
 				if (typeof problem === "function") {
 					return formatBailoutReason(
@@ -460,7 +483,7 @@ class ModuleConcatenationPlugin {
 										c.module === rootModule ? c.originModule : c.module;
 									const innerConnection =
 										c.dependency instanceof HarmonyImportDependency &&
-										modules.has(otherModule);
+										modules.has(/** @type {Module} */ (otherModule));
 									return !innerConnection;
 								});
 								// add concatenated module to the compilation
@@ -533,7 +556,7 @@ class ModuleConcatenationPlugin {
 	 * @param {ChunkGraph} chunkGraph the chunk graph
 	 * @param {boolean} avoidMutateOnFailure avoid mutating the config when adding fails
 	 * @param {Statistics} statistics gathering metrics
-	 * @returns {Module | function(RequestShortener): string} the problematic module
+	 * @returns {null | Module | function(RequestShortener): string} the problematic module
 	 */
 	_tryToAdd(
 		compilation,
@@ -572,6 +595,10 @@ class ModuleConcatenationPlugin {
 			chunkGraph.getModuleChunksIterable(config.rootModule)
 		).filter(chunk => !chunkGraph.isModuleInChunk(module, chunk));
 		if (missingChunks.length > 0) {
+			/**
+			 * @param {RequestShortener} requestShortener request shortener
+			 * @returns {string} problem description
+			 */
 			const problem = requestShortener => {
 				const missingChunksList = Array.from(
 					new Set(missingChunks.map(chunk => chunk.name || "unnamed chunk(s)"))
@@ -609,6 +636,10 @@ class ModuleConcatenationPlugin {
 					return connection.isActive(runtime);
 				});
 			if (activeNonModulesConnections.length > 0) {
+				/**
+				 * @param {RequestShortener} requestShortener request shortener
+				 * @returns {string} problem description
+				 */
 				const problem = requestShortener => {
 					const importingExplanations = new Set(
 						activeNonModulesConnections.map(c => c.explanation).filter(Boolean)
@@ -666,6 +697,10 @@ class ModuleConcatenationPlugin {
 			return false;
 		});
 		if (otherChunkModules.length > 0) {
+			/**
+			 * @param {RequestShortener} requestShortener request shortener
+			 * @returns {string} problem description
+			 */
 			const problem = requestShortener => {
 				const names = otherChunkModules
 					.map(m => m.readableIdentifier(requestShortener))
@@ -693,6 +728,10 @@ class ModuleConcatenationPlugin {
 				nonHarmonyConnections.set(originModule, connections);
 		}
 		if (nonHarmonyConnections.size > 0) {
+			/**
+			 * @param {RequestShortener} requestShortener request shortener
+			 * @returns {string} problem description
+			 */
 			const problem = requestShortener => {
 				const names = Array.from(nonHarmonyConnections)
 					.map(([originModule, connections]) => {
@@ -753,6 +792,10 @@ class ModuleConcatenationPlugin {
 				}
 			}
 			if (otherRuntimeConnections.length > 0) {
+				/**
+				 * @param {RequestShortener} requestShortener request shortener
+				 * @returns {string} problem description
+				 */
 				const problem = requestShortener => {
 					return `Module ${module.readableIdentifier(
 						requestShortener
@@ -831,10 +874,17 @@ class ConcatConfiguration {
 		this.warnings = new Map();
 	}
 
+	/**
+	 * @param {Module} module the module
+	 */
 	add(module) {
 		this.modules.add(module);
 	}
 
+	/**
+	 * @param {Module} module the module
+	 * @returns {boolean} true, when the module is in the module set
+	 */
 	has(module) {
 		return this.modules.has(module);
 	}
@@ -843,10 +893,17 @@ class ConcatConfiguration {
 		return this.modules.size === 1;
 	}
 
+	/**
+	 * @param {Module} module the module
+	 * @param {Module | function(RequestShortener): string} problem the problem
+	 */
 	addWarning(module, problem) {
 		this.warnings.set(module, problem);
 	}
 
+	/**
+	 * @returns {Map<Module, Module | function(RequestShortener): string>} warnings
+	 */
 	getWarningsSorted() {
 		return new Map(
 			Array.from(this.warnings).sort((a, b) => {