webpack 5.85.0 → 5.86.0

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.0",
+  "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",