webpack 5.41.0 → 5.43.0

package/lib/serialization/BinaryMiddleware.js

@@ -165,12 +165,23 @@ class BinaryMiddleware extends SerializerMiddleware {
 		};
 		const flush = () => {
 			if (currentBuffer !== null) {
-				buffers.push(currentBuffer.slice(0, currentPosition));
+				buffers.push(
+					Buffer.from(
+						currentBuffer.buffer,
+						currentBuffer.byteOffset,
+						currentPosition
+					)
+				);
 				if (
 					!leftOverBuffer ||
 					leftOverBuffer.length < currentBuffer.length - currentPosition
-				)
-					leftOverBuffer = currentBuffer.slice(currentPosition);
+				) {
+					leftOverBuffer = Buffer.from(
+						currentBuffer.buffer,
+						currentBuffer.byteOffset + currentPosition,
+						currentBuffer.byteLength - currentPosition
+					);
+				}
 				currentBuffer = null;
 				buffersTotalLength += currentPosition;
 				currentPosition = 0;
@@ -537,12 +548,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 		const isInCurrentBuffer = n => {
 			return currentIsBuffer && n + currentPosition <= currentBuffer.length;
 		};
-		/**
-		 * Reads n bytes
-		 * @param {number} n amount of bytes to read
-		 * @returns {Buffer} buffer with bytes
-		 */
-		const read = n => {
+		const ensureBuffer = () => {
 			if (!currentIsBuffer) {
 				throw new Error(
 					currentBuffer === null
@@ -550,14 +556,34 @@ class BinaryMiddleware extends SerializerMiddleware {
 						: "Unexpected lazy element in stream"
 				);
 			}
+		};
+		/**
+		 * Reads n bytes
+		 * @param {number} n amount of bytes to read
+		 * @returns {Buffer} buffer with bytes
+		 */
+		const read = n => {
+			ensureBuffer();
 			const rem = currentBuffer.length - currentPosition;
 			if (rem < n) {
-				return Buffer.concat([read(rem), read(n - rem)]);
+				const buffers = [read(rem)];
+				n -= rem;
+				ensureBuffer();
+				while (currentBuffer.length < n) {
+					const b = /** @type {Buffer} */ (currentBuffer);
+					buffers.push(b);
+					n -= b.length;
+					currentDataItem++;
+					currentBuffer =
+						currentDataItem < data.length ? data[currentDataItem] : null;
+					currentIsBuffer = Buffer.isBuffer(currentBuffer);
+					ensureBuffer();
+				}
+				buffers.push(read(n));
+				return Buffer.concat(buffers);
 			}
-			const res = /** @type {Buffer} */ (currentBuffer).slice(
-				currentPosition,
-				currentPosition + n
-			);
+			const b = /** @type {Buffer} */ (currentBuffer);
+			const res = Buffer.from(b.buffer, b.byteOffset + currentPosition, n);
 			currentPosition += n;
 			checkOverflow();
 			return res;
@@ -568,33 +594,19 @@ class BinaryMiddleware extends SerializerMiddleware {
 		 * @returns {Buffer} buffer with bytes
 		 */
 		const readUpTo = n => {
-			if (!currentIsBuffer) {
-				throw new Error(
-					currentBuffer === null
-						? "Unexpected end of stream"
-						: "Unexpected lazy element in stream"
-				);
-			}
+			ensureBuffer();
 			const rem = currentBuffer.length - currentPosition;
 			if (rem < n) {
 				n = rem;
 			}
-			const res = /** @type {Buffer} */ (currentBuffer).slice(
-				currentPosition,
-				currentPosition + n
-			);
+			const b = /** @type {Buffer} */ (currentBuffer);
+			const res = Buffer.from(b.buffer, b.byteOffset + currentPosition, n);
 			currentPosition += n;
 			checkOverflow();
 			return res;
 		};
 		const readU8 = () => {
-			if (!currentIsBuffer) {
-				throw new Error(
-					currentBuffer === null
-						? "Unexpected end of stream"
-						: "Unexpected lazy element in stream"
-				);
-			}
+			ensureBuffer();
 			/**
 			 * There is no need to check remaining buffer size here
 			 * since {@link checkOverflow} guarantees at least one byte remaining
@@ -735,7 +747,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 				case STRING_HEADER:
 					return () => {
 						const len = readU32();
-						if (isInCurrentBuffer(len)) {
+						if (isInCurrentBuffer(len) && currentPosition + len < 0x7fffffff) {
 							result.push(
 								currentBuffer.toString(
 									undefined,
@@ -753,7 +765,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 					return () => result.push("");
 				case SHORT_STRING_HEADER | 1:
 					return () => {
-						if (currentIsBuffer) {
+						if (currentIsBuffer && currentPosition < 0x7ffffffe) {
 							result.push(
 								currentBuffer.toString(
 									"latin1",
@@ -785,7 +797,10 @@ class BinaryMiddleware extends SerializerMiddleware {
 					} else if ((header & SHORT_STRING_HEADER) === SHORT_STRING_HEADER) {
 						const len = header & SHORT_STRING_LENGTH_MASK;
 						return () => {
-							if (isInCurrentBuffer(len)) {
+							if (
+								isInCurrentBuffer(len) &&
+								currentPosition + len < 0x7fffffff
+							) {
 								result.push(
 									currentBuffer.toString(
 										"latin1",

package/lib/serialization/FileMiddleware.js

@@ -5,6 +5,14 @@
 "use strict";
 
 const { constants } = require("buffer");
+const { pipeline } = require("stream");
+const {
+	createBrotliCompress,
+	createBrotliDecompress,
+	createGzip,
+	createGunzip,
+	constants: zConstants
+} = require("zlib");
 const createHash = require("../util/createHash");
 const { dirname, join, mkdirp } = require("../util/fs");
 const memoize = require("../util/memoize");
@@ -37,6 +45,9 @@ const hashForName = buffers => {
 	return /** @type {string} */ (hash.digest("hex"));
 };
 
+const COMPRESSION_CHUNK_SIZE = 100 * 1024 * 1024;
+const DECOMPRESSION_CHUNK_SIZE = 100 * 1024 * 1024;
+
 const writeUInt64LE = Buffer.prototype.writeBigUInt64LE
 	? (buf, value, offset) => {
 			buf.writeBigUInt64LE(BigInt(value), offset);
@@ -69,7 +80,7 @@ const readUInt64LE = Buffer.prototype.readBigUInt64LE
  * @param {FileMiddleware} middleware this
  * @param {BufferSerializableType[] | Promise<BufferSerializableType[]>} data data to be serialized
  * @param {string | boolean} name file base name
- * @param {function(string | false, Buffer[]): Promise} writeFile writes a file
+ * @param {function(string | false, Buffer[]): Promise<void>} writeFile writes a file
  * @returns {Promise<SerializeResult>} resulting file pointer and promise
  */
 const serialize = async (middleware, data, name, writeFile) => {
@@ -280,8 +291,16 @@ const deserialize = async (middleware, name, readFile) => {
 	}
 	const sectionCount = readUInt32LE();
 	const lengths = [];
+	let lastLengthPositive = false;
 	for (let i = 0; i < sectionCount; i++) {
-		lengths.push(readInt32LE());
+		const value = readInt32LE();
+		const valuePositive = value >= 0;
+		if (lastLengthPositive && valuePositive) {
+			lengths[lengths.length - 1] += value;
+		} else {
+			lengths.push(value);
+			lastLengthPositive = valuePositive;
+		}
 	}
 	const result = [];
 	for (let length of lengths) {
@@ -307,13 +326,24 @@ const deserialize = async (middleware, name, readFile) => {
 			} else if (contentPosition !== 0) {
 				if (length <= contentItemLength - contentPosition) {
 					result.push(
-						contentItem.slice(contentPosition, contentPosition + length)
+						Buffer.from(
+							contentItem.buffer,
+							contentItem.byteOffset + contentPosition,
+							length
+						)
 					);
 					contentPosition += length;
 					length = 0;
 				} else {
-					result.push(contentItem.slice(contentPosition));
-					length -= contentItemLength - contentPosition;
+					const l = contentItemLength - contentPosition;
+					result.push(
+						Buffer.from(
+							contentItem.buffer,
+							contentItem.byteOffset + contentPosition,
+							l
+						)
+					);
+					length -= l;
 					contentPosition = contentItemLength;
 				}
 			} else {
@@ -322,7 +352,9 @@ const deserialize = async (middleware, name, readFile) => {
 					length -= contentItemLength;
 					contentPosition = contentItemLength;
 				} else {
-					result.push(contentItem.slice(0, length));
+					result.push(
+						Buffer.from(contentItem.buffer, contentItem.byteOffset, length)
+					);
 					contentPosition += length;
 					length = 0;
 				}
@@ -334,7 +366,9 @@ const deserialize = async (middleware, name, readFile) => {
 					length -= contentItemLength;
 					contentPosition = contentItemLength;
 				} else {
-					result.push(contentItem.slice(0, length));
+					result.push(
+						Buffer.from(contentItem.buffer, contentItem.byteOffset, length)
+					);
 					contentPosition += length;
 					length = 0;
 				}
@@ -376,11 +410,37 @@ class FileMiddleware extends SerializerMiddleware {
 						? join(this.fs, filename, `../${name}${extension}`)
 						: filename;
 					await new Promise((resolve, reject) => {
-						const stream = this.fs.createWriteStream(file + "_");
+						let stream = this.fs.createWriteStream(file + "_");
+						let compression;
+						if (file.endsWith(".gz")) {
+							compression = createGzip({
+								chunkSize: COMPRESSION_CHUNK_SIZE,
+								level: zConstants.Z_BEST_SPEED
+							});
+						} else if (file.endsWith(".br")) {
+							compression = createBrotliCompress({
+								chunkSize: COMPRESSION_CHUNK_SIZE,
+								params: {
+									[zConstants.BROTLI_PARAM_MODE]: zConstants.BROTLI_MODE_TEXT,
+									[zConstants.BROTLI_PARAM_QUALITY]: 2,
+									[zConstants.BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING]: true,
+									[zConstants.BROTLI_PARAM_SIZE_HINT]: content.reduce(
+										(size, b) => size + b.length,
+										0
+									)
+								}
+							});
+						}
+						if (compression) {
+							pipeline(compression, stream, reject);
+							stream = compression;
+							stream.on("finish", () => resolve());
+						} else {
+							stream.on("error", err => reject(err));
+							stream.on("finish", () => resolve());
+						}
 						for (const b of content) stream.write(b);
 						stream.end();
-						stream.on("error", err => reject(err));
-						stream.on("finish", () => resolve());
 					});
 					if (name) allWrittenFiles.add(file);
 				};
@@ -447,6 +507,34 @@ class FileMiddleware extends SerializerMiddleware {
 					let currentBuffer;
 					let currentBufferUsed;
 					const buf = [];
+					let decompression;
+					if (file.endsWith(".gz")) {
+						decompression = createGunzip({
+							chunkSize: DECOMPRESSION_CHUNK_SIZE
+						});
+					} else if (file.endsWith(".br")) {
+						decompression = createBrotliDecompress({
+							chunkSize: DECOMPRESSION_CHUNK_SIZE
+						});
+					}
+					if (decompression) {
+						let newResolve, newReject;
+						resolve(
+							Promise.all([
+								new Promise((rs, rj) => {
+									newResolve = rs;
+									newReject = rj;
+								}),
+								new Promise((resolve, reject) => {
+									decompression.on("data", chunk => buf.push(chunk));
+									decompression.on("end", () => resolve());
+									decompression.on("error", err => reject(err));
+								})
+							]).then(() => buf)
+						);
+						resolve = newResolve;
+						reject = newReject;
+					}
 					this.fs.open(file, "r", (err, fd) => {
 						if (err) {
 							reject(err);
@@ -455,13 +543,18 @@ class FileMiddleware extends SerializerMiddleware {
 						const read = () => {
 							if (currentBuffer === undefined) {
 								currentBuffer = Buffer.allocUnsafeSlow(
-									Math.min(constants.MAX_LENGTH, remaining)
+									Math.min(
+										constants.MAX_LENGTH,
+										remaining,
+										decompression ? DECOMPRESSION_CHUNK_SIZE : Infinity
+									)
 								);
 								currentBufferUsed = 0;
 							}
 							let readBuffer = currentBuffer;
 							let readOffset = currentBufferUsed;
 							let readLength = currentBuffer.length - currentBufferUsed;
+							// values passed to fs.read must be valid int32 values
 							if (readOffset > 0x7fffffff) {
 								readBuffer = currentBuffer.slice(readOffset);
 								readOffset = 0;
@@ -485,9 +578,16 @@ class FileMiddleware extends SerializerMiddleware {
 									currentBufferUsed += bytesRead;
 									remaining -= bytesRead;
 									if (currentBufferUsed === currentBuffer.length) {
-										buf.push(currentBuffer);
+										if (decompression) {
+											decompression.write(currentBuffer);
+										} else {
+											buf.push(currentBuffer);
+										}
 										currentBuffer = undefined;
 										if (remaining === 0) {
+											if (decompression) {
+												decompression.end();
+											}
 											this.fs.close(fd, err => {
 												if (err) {
 													reject(err);

package/lib/util/internalSerializables.js

@@ -156,6 +156,7 @@ module.exports = {
 		require("../dependencies/WebpackIsIncludedDependency"),
 	"dependencies/WorkerDependency": () =>
 		require("../dependencies/WorkerDependency"),
+	"json/JsonData": () => require("../json/JsonData"),
 	"optimize/ConcatenatedModule": () =>
 		require("../optimize/ConcatenatedModule"),
 	DelegatedModule: () => require("../DelegatedModule"),

package/lib/util/makeSerializable.js

@@ -9,7 +9,6 @@ const { register } = require("./serialization");
 class ClassSerializer {
 	constructor(Constructor) {
 		this.Constructor = Constructor;
-		this.hash = null;
 	}
 
 	serialize(obj, context) {

package/package.json

@@ -1,20 +1,20 @@
 {
   "name": "webpack",
-  "version": "5.41.0",
+  "version": "5.43.0",
   "author": "Tobias Koppers @sokra",
   "description": "Packs CommonJs/AMD modules for the browser. Allows to split your codebase into multiple bundles, which can be loaded on demand. Support loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "license": "MIT",
   "dependencies": {
     "@types/eslint-scope": "^3.7.0",
-    "@types/estree": "^0.0.48",
-    "@webassemblyjs/ast": "1.11.0",
-    "@webassemblyjs/wasm-edit": "1.11.0",
-    "@webassemblyjs/wasm-parser": "1.11.0",
-    "acorn": "^8.2.1",
+    "@types/estree": "^0.0.49",
+    "@webassemblyjs/ast": "1.11.1",
+    "@webassemblyjs/wasm-edit": "1.11.1",
+    "@webassemblyjs/wasm-parser": "1.11.1",
+    "acorn": "^8.4.1",
     "browserslist": "^4.14.5",
     "chrome-trace-event": "^1.0.2",
     "enhanced-resolve": "^5.8.0",
-    "es-module-lexer": "^0.6.0",
+    "es-module-lexer": "^0.7.1",
     "eslint-scope": "5.1.1",
     "events": "^3.2.0",
     "glob-to-regexp": "^0.4.1",