webpack 5.85.1 → 5.86.0

package/lib/optimize/SplitChunksPlugin.js

@@ -41,7 +41,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 /**
  * @callback ChunkFilterFunction
  * @param {Chunk} chunk
- * @returns {boolean}
+ * @returns {boolean | undefined}
  */
 
 /**
@@ -69,7 +69,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {number=} maxInitialRequests
  * @property {(string | function(PathData, AssetInfo=): string)=} filename
  * @property {string=} idHint
- * @property {string} automaticNameDelimiter
+ * @property {string=} automaticNameDelimiter
  * @property {boolean=} reuseExistingChunk
  * @property {boolean=} usedExports
  */
@@ -254,12 +254,24 @@ const compareEntries = (a, b) => {
 	return compareModuleIterables(modulesA, modulesB);
 };
 
+/**
+ * @param {Chunk} chunk the chunk
+ * @returns {boolean} true, if the chunk is an entry chunk
+ */
 const INITIAL_CHUNK_FILTER = chunk => chunk.canBeInitial();
+/**
+ * @param {Chunk} chunk the chunk
+ * @returns {boolean} true, if the chunk is an async chunk
+ */
 const ASYNC_CHUNK_FILTER = chunk => !chunk.canBeInitial();
+/**
+ * @param {Chunk} chunk the chunk
+ * @returns {boolean} always true
+ */
 const ALL_CHUNK_FILTER = chunk => true;
 
 /**
- * @param {OptimizationSplitChunksSizes} value the sizes
+ * @param {OptimizationSplitChunksSizes | undefined} value the sizes
  * @param {string[]} defaultSizeTypes the default size types
  * @returns {SplitChunksSizes} normalized representation
  */
@@ -386,8 +398,8 @@ const totalSize = sizes => {
 };
 
 /**
- * @param {false|string|Function} name the chunk name
- * @returns {GetName} a function to get the name of the chunk
+ * @param {false|string|Function|undefined} name the chunk name
+ * @returns {GetName | undefined} a function to get the name of the chunk
  */
 const normalizeName = name => {
 	if (typeof name === "string") {
@@ -412,6 +424,11 @@ const normalizeChunksFilter = chunks => {
 	if (chunks === "all") {
 		return ALL_CHUNK_FILTER;
 	}
+	if (chunks instanceof RegExp) {
+		return chunk => {
+			return chunk.name ? chunks.test(chunk.name) : false;
+		};
+	}
 	if (typeof chunks === "function") {
 		return chunks;
 	}
@@ -839,6 +856,10 @@ module.exports = class SplitChunksPlugin {
 						}
 						return key;
 					};
+					/**
+					 * @param {bigint | Chunk} key key of the chunks
+					 * @returns {string} stringified key
+					 */
 					const keyToString = key => {
 						if (typeof key === "bigint") return key.toString(16);
 						return chunkIndexMap.get(key).toString(16);
@@ -910,6 +931,10 @@ module.exports = class SplitChunksPlugin {
 					// group these set of chunks by count
 					// to allow to check less sets via isSubset
 					// (only smaller sets can be subset)
+					/**
+					 * @param {IterableIterator<Set<Chunk>>} chunkSets set of sets of chunks
+					 * @returns {Map<number, Array<Set<Chunk>>>} map of sets of chunks by count
+					 */
 					const groupChunkSetsByCount = chunkSets => {
 						/** @type {Map<number, Array<Set<Chunk>>>} */
 						const chunkSetsByCount = new Map();
@@ -1019,8 +1044,9 @@ module.exports = class SplitChunksPlugin {
 							entry = new WeakMap();
 							selectedChunksCacheByChunksSet.set(chunks, entry);
 						}
-						/** @type {SelectedChunksResult} */
-						let entry2 = entry.get(chunkFilter);
+						let entry2 =
+							/** @type {SelectedChunksResult} */
+							(entry.get(chunkFilter));
 						if (entry2 === undefined) {
 							/** @type {Chunk[]} */
 							const selectedChunks = [];
@@ -1068,11 +1094,9 @@ module.exports = class SplitChunksPlugin {
 						// Break if minimum number of chunks is not reached
 						if (selectedChunks.length < cacheGroup.minChunks) return;
 						// Determine name for split chunk
-						const name = cacheGroup.getName(
-							module,
-							selectedChunks,
-							cacheGroup.key
-						);
+						const name =
+							/** @type {string} */
+							(cacheGroup.getName(module, selectedChunks, cacheGroup.key));
 						// Check if the name is ok
 						const existingChunk = compilation.namedChunks.get(name);
 						if (existingChunk) {
@@ -1139,7 +1163,7 @@ module.exports = class SplitChunksPlugin {
 								? ` name:${name}`
 								: ` chunks:${keyToString(selectedChunksKey)}`);
 						// Add module to maps
-						let info = chunksInfoMap.get(key);
+						let info = /** @type {ChunksInfoItem} */ (chunksInfoMap.get(key));
 						if (info === undefined) {
 							chunksInfoMap.set(
 								key,
@@ -1204,7 +1228,9 @@ module.exports = class SplitChunksPlugin {
 							getExportsChunkSetsInGraph();
 							/** @type {Set<Set<Chunk> | Chunk>} */
 							const set = new Set();
-							const groupedByUsedExports = groupedByExportsMap.get(module);
+							const groupedByUsedExports =
+								/** @type {Iterable<Chunk[]>} */
+								(groupedByExportsMap.get(module));
 							for (const chunks of groupedByUsedExports) {
 								const chunksKey = getKey(chunks);
 								for (const comb of getExportsCombinations(chunksKey))
@@ -1228,7 +1254,10 @@ module.exports = class SplitChunksPlugin {
 								if (count < cacheGroup.minChunks) continue;
 								// Select chunks by configuration
 								const { chunks: selectedChunks, key: selectedChunksKey } =
-									getSelectedChunks(chunkCombination, cacheGroup.chunksFilter);
+									getSelectedChunks(
+										chunkCombination,
+										/** @type {ChunkFilterFunction} */ (cacheGroup.chunksFilter)
+									);
 
 								addModuleToChunksInfoMap(
 									cacheGroup,
@@ -1320,12 +1349,13 @@ module.exports = class SplitChunksPlugin {
 							}
 						}
 
-						const item = bestEntry;
-						chunksInfoMap.delete(bestEntryKey);
+						const item = /** @type {ChunksInfoItem} */ (bestEntry);
+						chunksInfoMap.delete(/** @type {string} */ (bestEntryKey));
 
+						/** @type {Chunk["name"] | undefined} */
 						let chunkName = item.name;
 						// Variable for the new chunk (lazy created)
-						/** @type {Chunk} */
+						/** @type {Chunk | undefined} */
 						let newChunk;
 						// When no chunk name, check if we can reuse a chunk instead of creating a new one
 						let isExistingChunk = false;
@@ -1394,14 +1424,18 @@ module.exports = class SplitChunksPlugin {
 						) {
 							for (const chunk of usedChunks) {
 								// respect max requests
-								const maxRequests = chunk.isOnlyInitial()
-									? item.cacheGroup.maxInitialRequests
-									: chunk.canBeInitial()
-									? Math.min(
-											item.cacheGroup.maxInitialRequests,
-											item.cacheGroup.maxAsyncRequests
-									  )
-									: item.cacheGroup.maxAsyncRequests;
+								const maxRequests = /** @type {number} */ (
+									chunk.isOnlyInitial()
+										? item.cacheGroup.maxInitialRequests
+										: chunk.canBeInitial()
+										? Math.min(
+												/** @type {number} */
+												(item.cacheGroup.maxInitialRequests),
+												/** @type {number} */
+												(item.cacheGroup.maxAsyncRequests)
+										  )
+										: item.cacheGroup.maxAsyncRequests
+								);
 								if (
 									isFinite(maxRequests) &&
 									getRequests(chunk) >= maxRequests
@@ -1421,8 +1455,12 @@ module.exports = class SplitChunksPlugin {
 						// Were some (invalid) chunks removed from usedChunks?
 						// => readd all modules to the queue, as things could have been changed
 						if (usedChunks.size < item.chunks.size) {
-							if (isExistingChunk) usedChunks.add(newChunk);
-							if (usedChunks.size >= item.cacheGroup.minChunks) {
+							if (isExistingChunk)
+								usedChunks.add(/** @type {Chunk} */ (newChunk));
+							if (
+								/** @type {number} */ (usedChunks.size) >=
+								/** @type {number} */ (item.cacheGroup.minChunks)
+							) {
 								const chunksArr = Array.from(usedChunks);
 								for (const module of item.modules) {
 									addModuleToChunksInfoMap(
@@ -1466,7 +1504,7 @@ module.exports = class SplitChunksPlugin {
 								) {
 									// queue this item again to be processed again
 									// without violating modules
-									chunksInfoMap.set(bestEntryKey, item);
+									chunksInfoMap.set(/** @type {string} */ (bestEntryKey), item);
 								}
 								continue;
 							}
@@ -1696,7 +1734,9 @@ module.exports = class SplitChunksPlugin {
 									hashFilename(name, outputOptions);
 							}
 							if (i !== results.length - 1) {
-								const newPart = compilation.addChunk(name);
+								const newPart = compilation.addChunk(
+									/** @type {Chunk["name"]} */ (name)
+								);
 								chunk.split(newPart);
 								newPart.chunkReason = chunk.chunkReason;
 								// Add all modules to the new chunk
@@ -1711,7 +1751,7 @@ module.exports = class SplitChunksPlugin {
 								}
 							} else {
 								// change the chunk to be a part
-								chunk.name = name;
+								chunk.name = /** @type {Chunk["name"]} */ (name);
 							}
 						}
 					}

package/lib/serialization/BinaryMiddleware.js

@@ -21,6 +21,9 @@ Section -> NullsSection |
 					 I32NumbersSection |
 					 I8NumbersSection |
 					 ShortStringSection |
+					 BigIntSection |
+					 I32BigIntSection |
+					 I8BigIntSection
 					 StringSection |
 					 BufferSection |
 					 NopSection
@@ -39,6 +42,9 @@ ShortStringSection -> ShortStringSectionHeaderByte ascii-byte*
 StringSection -> StringSectionHeaderByte i32:length utf8-byte*
 BufferSection -> BufferSectionHeaderByte i32:length byte*
 NopSection --> NopSectionHeaderByte
+BigIntSection -> BigIntSectionHeaderByte i32:length ascii-byte*
+I32BigIntSection -> I32BigIntSectionHeaderByte i32
+I8BigIntSection -> I8BigIntSectionHeaderByte i8
 
 ShortStringSectionHeaderByte -> 0b1nnn_nnnn (n:length)
 
@@ -58,6 +64,9 @@ BooleansCountAndBitsByte ->
 StringSectionHeaderByte -> 0b0000_1110
 BufferSectionHeaderByte -> 0b0000_1111
 NopSectionHeaderByte -> 0b0000_1011
+BigIntSectionHeaderByte -> 0b0001_1010
+I32BigIntSectionHeaderByte -> 0b0001_1100
+I8BigIntSectionHeaderByte -> 0b0001_1011
 FalseHeaderByte -> 0b0000_1100
 TrueHeaderByte -> 0b0000_1101
 
@@ -78,6 +87,9 @@ const NULL_AND_I8_HEADER = 0x15;
 const NULL_AND_I32_HEADER = 0x16;
 const NULL_AND_TRUE_HEADER = 0x17;
 const NULL_AND_FALSE_HEADER = 0x18;
+const BIGINT_HEADER = 0x1a;
+const BIGINT_I8_HEADER = 0x1b;
+const BIGINT_I32_HEADER = 0x1c;
 const STRING_HEADER = 0x1e;
 const BUFFER_HEADER = 0x1f;
 const I8_HEADER = 0x60;
@@ -86,7 +98,7 @@ const F64_HEADER = 0x20;
 const SHORT_STRING_HEADER = 0x80;
 
 /** Uplift high-order bits */
-const NUMBERS_HEADER_MASK = 0xe0;
+const NUMBERS_HEADER_MASK = 0xe0; // 0b1010_0000
 const NUMBERS_COUNT_MASK = 0x1f; // 0b0001_1111
 const SHORT_STRING_LENGTH_MASK = 0x7f; // 0b0111_1111
 
@@ -113,6 +125,16 @@ const identifyNumber = n => {
 	return 2;
 };
 
+/**
+ * @param {bigint} n bigint
+ * @returns {0 | 1 | 2} type of bigint for serialization
+ */
+const identifyBigInt = n => {
+	if (n <= BigInt(127) && n >= BigInt(-128)) return 0;
+	if (n <= BigInt(2147483647) && n >= BigInt(-2147483648)) return 1;
+	return 2;
+};
+
 /**
  * @typedef {PrimitiveSerializableType[]} DeserializedType
  * @typedef {BufferSerializableType[]} SerializedType
@@ -331,6 +353,62 @@ class BinaryMiddleware extends SerializerMiddleware {
 					}
 					break;
 				}
+				case "bigint": {
+					const type = identifyBigInt(thing);
+					if (type === 0 && thing >= 0 && thing <= BigInt(10)) {
+						// shortcut for very small bigints
+						allocate(HEADER_SIZE + I8_SIZE);
+						writeU8(BIGINT_I8_HEADER);
+						writeU8(Number(thing));
+						break;
+					}
+
+					switch (type) {
+						case 0: {
+							let n = 1;
+							allocate(HEADER_SIZE + I8_SIZE * n);
+							writeU8(BIGINT_I8_HEADER | (n - 1));
+							while (n > 0) {
+								currentBuffer.writeInt8(
+									Number(/** @type {bigint} */ (data[i])),
+									currentPosition
+								);
+								currentPosition += I8_SIZE;
+								n--;
+								i++;
+							}
+							i--;
+							break;
+						}
+						case 1: {
+							let n = 1;
+							allocate(HEADER_SIZE + I32_SIZE * n);
+							writeU8(BIGINT_I32_HEADER | (n - 1));
+							while (n > 0) {
+								currentBuffer.writeInt32LE(
+									Number(/** @type {bigint} */ (data[i])),
+									currentPosition
+								);
+								currentPosition += I32_SIZE;
+								n--;
+								i++;
+							}
+							i--;
+							break;
+						}
+						default: {
+							const value = thing.toString();
+							const len = Buffer.byteLength(value);
+							allocate(len + HEADER_SIZE + I32_SIZE);
+							writeU8(BIGINT_HEADER);
+							writeU32(len);
+							currentBuffer.write(value, currentPosition);
+							currentPosition += len;
+							break;
+						}
+					}
+					break;
+				}
 				case "number": {
 					const type = identifyNumber(thing);
 					if (type === 0 && thing >= 0 && thing <= 10) {
@@ -847,6 +925,70 @@ class BinaryMiddleware extends SerializerMiddleware {
 							result.push(read(1).readInt8(0));
 						}
 					};
+				case BIGINT_I8_HEADER: {
+					const len = 1;
+					return () => {
+						const need = I8_SIZE * len;
+
+						if (isInCurrentBuffer(need)) {
+							for (let i = 0; i < len; i++) {
+								const value =
+									/** @type {Buffer} */
+									(currentBuffer).readInt8(currentPosition);
+								result.push(BigInt(value));
+								currentPosition += I8_SIZE;
+							}
+							checkOverflow();
+						} else {
+							const buf = read(need);
+							for (let i = 0; i < len; i++) {
+								const value = buf.readInt8(i * I8_SIZE);
+								result.push(BigInt(value));
+							}
+						}
+					};
+				}
+				case BIGINT_I32_HEADER: {
+					const len = 1;
+					return () => {
+						const need = I32_SIZE * len;
+						if (isInCurrentBuffer(need)) {
+							for (let i = 0; i < len; i++) {
+								const value = /** @type {Buffer} */ (currentBuffer).readInt32LE(
+									currentPosition
+								);
+								result.push(BigInt(value));
+								currentPosition += I32_SIZE;
+							}
+							checkOverflow();
+						} else {
+							const buf = read(need);
+							for (let i = 0; i < len; i++) {
+								const value = buf.readInt32LE(i * I32_SIZE);
+								result.push(BigInt(value));
+							}
+						}
+					};
+				}
+				case BIGINT_HEADER: {
+					return () => {
+						const len = readU32();
+						if (isInCurrentBuffer(len) && currentPosition + len < 0x7fffffff) {
+							const value = currentBuffer.toString(
+								undefined,
+								currentPosition,
+								currentPosition + len
+							);
+
+							result.push(BigInt(value));
+							currentPosition += len;
+							checkOverflow();
+						} else {
+							const value = read(len).toString();
+							result.push(BigInt(value));
+						}
+					};
+				}
 				default:
 					if (header <= 10) {
 						return () => result.push(header);

package/lib/serialization/ErrorObjectSerializer.js

@@ -21,6 +21,7 @@ class ErrorObjectSerializer {
 	serialize(obj, context) {
 		context.write(obj.message);
 		context.write(obj.stack);
+		context.write(/** @type {Error & { cause: "unknown" }} */ (obj).cause);
 	}
 	/**
 	 * @param {ObjectDeserializerContext} context context
@@ -31,6 +32,8 @@ class ErrorObjectSerializer {
 
 		err.message = context.read();
 		err.stack = context.read();
+		/** @type {Error & { cause: "unknown" }} */
+		(err).cause = context.read();
 
 		return err;
 	}

package/lib/serialization/ObjectMiddleware.js

@@ -397,6 +397,9 @@ class ObjectMiddleware extends SerializerMiddleware {
 							", "
 						)} }`;
 					}
+					if (typeof item === "bigint") {
+						return `BigInt ${item}n`;
+					}
 					try {
 						return `${item}`;
 					} catch (e) {

package/lib/serialization/types.js

@@ -6,7 +6,7 @@
 
 /** @typedef {undefined|null|number|string|boolean|Buffer|Object|(() => ComplexSerializableType[] | Promise<ComplexSerializableType[]>)} ComplexSerializableType */
 
-/** @typedef {undefined|null|number|string|boolean|Buffer|(() => PrimitiveSerializableType[] | Promise<PrimitiveSerializableType[]>)} PrimitiveSerializableType */
+/** @typedef {undefined|null|number|bigint|string|boolean|Buffer|(() => PrimitiveSerializableType[] | Promise<PrimitiveSerializableType[]>)} PrimitiveSerializableType */
 
 /** @typedef {Buffer|(() => BufferSerializableType[] | Promise<BufferSerializableType[]>)} BufferSerializableType */
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "5.85.1",
+  "version": "5.86.0",
   "author": "Tobias Koppers @sokra",
   "description": "Packs ECMAScript/CommonJs/AMD modules for the browser. Allows you to split your codebase into multiple bundles, which can be loaded on demand. Supports loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "license": "MIT",