webpack 5.83.1 → 5.84.0

package/lib/javascript/StartupHelpers.js

@@ -39,7 +39,7 @@ exports.generateEntryStartup = (
 	/** @type {string[]} */
 	const runtime = [
 		`var __webpack_exec__ = ${runtimeTemplate.returningFunction(
-			`__webpack_require__(${RuntimeGlobals.entryModuleId} = moduleId)`,
+			`${RuntimeGlobals.require}(${RuntimeGlobals.entryModuleId} = moduleId)`,
 			"moduleId"
 		)}`
 	];

package/lib/node/ReadFileChunkLoadingRuntimeModule.js

@@ -124,7 +124,7 @@ class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 							"}"
 						]),
 						"}",
-						`if(runtime) runtime(__webpack_require__);`,
+						`if(runtime) runtime(${RuntimeGlobals.require});`,
 						"for(var i = 0; i < chunkIds.length; i++) {",
 						Template.indent([
 							"if(installedChunks[chunkIds[i]]) {",
@@ -193,7 +193,7 @@ class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 			"",
 			withExternalInstallChunk
 				? Template.asString([
-						"module.exports = __webpack_require__;",
+						`module.exports = ${RuntimeGlobals.require};`,
 						`${RuntimeGlobals.externalInstallChunk} = installChunk;`
 				  ])
 				: "// no external install chunk",

package/lib/node/RequireChunkLoadingRuntimeModule.js

@@ -124,7 +124,7 @@ class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 							"}"
 						]),
 						"}",
-						`if(runtime) runtime(__webpack_require__);`,
+						`if(runtime) runtime(${RuntimeGlobals.require});`,
 						"for(var i = 0; i < chunkIds.length; i++)",
 						Template.indent("installedChunks[chunkIds[i]] = 1;"),
 						withOnChunkLoad ? `${RuntimeGlobals.onChunksLoaded}();` : ""
@@ -163,7 +163,7 @@ class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 			"",
 			withExternalInstallChunk
 				? Template.asString([
-						"module.exports = __webpack_require__;",
+						`module.exports = ${RuntimeGlobals.require};`,
 						`${RuntimeGlobals.externalInstallChunk} = installChunk;`
 				  ])
 				: "// no external install chunk",

package/lib/optimize/ConcatenatedModule.js

@@ -1611,7 +1611,7 @@ ${defineGetters}`
 						result.add(`if (${condition}) {\n`);
 					}
 					result.add(
-						`var ${info.name} = __webpack_require__(${JSON.stringify(
+						`var ${info.name} = ${RuntimeGlobals.require}(${JSON.stringify(
 							chunkGraph.getModuleId(info.module)
 						)});`
 					);

package/lib/optimize/InnerGraphPlugin.js

@@ -120,7 +120,10 @@ class InnerGraphPlugin {
 						if (!InnerGraph.isEnabled(parser.state)) return;
 
 						if (parser.scope.topLevelScope === true) {
-							if (statement.type === "ClassDeclaration") {
+							if (
+								statement.type === "ClassDeclaration" &&
+								parser.isPure(statement, statement.range[0])
+							) {
 								const name = statement.id ? statement.id.name : "*default*";
 								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
 								classWithTopLevelSymbol.set(statement, fn);
@@ -131,8 +134,9 @@ class InnerGraphPlugin {
 								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
 								const decl = statement.declaration;
 								if (
-									decl.type === "ClassExpression" ||
-									decl.type === "ClassDeclaration"
+									(decl.type === "ClassExpression" ||
+										decl.type === "ClassDeclaration") &&
+									parser.isPure(decl, decl.range[0])
 								) {
 									classWithTopLevelSymbol.set(decl, fn);
 								} else if (parser.isPure(decl, statement.range[0])) {
@@ -157,7 +161,10 @@ class InnerGraphPlugin {
 							decl.id.type === "Identifier"
 						) {
 							const name = decl.id.name;
-							if (decl.init.type === "ClassExpression") {
+							if (
+								decl.init.type === "ClassExpression" &&
+								parser.isPure(decl.init, decl.id.range[1])
+							) {
 								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
 								classWithTopLevelSymbol.set(decl.init, fn);
 							} else if (parser.isPure(decl.init, decl.id.range[1])) {

package/lib/runtime/StartupChunkDependenciesRuntimeModule.js

@@ -45,7 +45,7 @@ class StartupChunkDependenciesRuntimeModule extends RuntimeModule {
 							// using map is shorter for 3 or more chunks
 							`return Promise.all(${JSON.stringify(chunkIds)}.map(${
 								RuntimeGlobals.ensureChunk
-							}, __webpack_require__)).then(next);`
+							}, ${RuntimeGlobals.require})).then(next);`
 					  ]
 					: [
 							// calling ensureChunk directly is shorter for 0 - 2 chunks

package/lib/runtime/StartupEntrypointRuntimeModule.js

@@ -27,19 +27,19 @@ class StartupEntrypointRuntimeModule extends RuntimeModule {
 			"// arguments: chunkIds, moduleId are deprecated",
 			"var moduleId = chunkIds;",
 			`if(!fn) chunkIds = result, fn = ${runtimeTemplate.returningFunction(
-				`__webpack_require__(${RuntimeGlobals.entryModuleId} = moduleId)`
+				`${RuntimeGlobals.require}(${RuntimeGlobals.entryModuleId} = moduleId)`
 			)};`,
 			...(this.asyncChunkLoading
 				? [
-						`return Promise.all(chunkIds.map(${
-							RuntimeGlobals.ensureChunk
-						}, __webpack_require__)).then(${runtimeTemplate.basicFunction("", [
+						`return Promise.all(chunkIds.map(${RuntimeGlobals.ensureChunk}, ${
+							RuntimeGlobals.require
+						})).then(${runtimeTemplate.basicFunction("", [
 							"var r = fn();",
 							"return r === undefined ? result : r;"
 						])})`
 				  ]
 				: [
-						`chunkIds.map(${RuntimeGlobals.ensureChunk}, __webpack_require__)`,
+						`chunkIds.map(${RuntimeGlobals.ensureChunk}, ${RuntimeGlobals.require})`,
 						"var r = fn();",
 						"return r === undefined ? result : r;"
 				  ])

package/lib/serialization/ArraySerializer.js

@@ -4,16 +4,32 @@
 
 "use strict";
 
+/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
 class ArraySerializer {
-	serialize(array, { write }) {
-		write(array.length);
-		for (const item of array) write(item);
+	/**
+	 * @template T
+	 * @param {T[]} array array
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(array, context) {
+		context.write(array.length);
+		for (const item of array) context.write(item);
 	}
-	deserialize({ read }) {
-		const length = read();
+
+	/**
+	 * @template T
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {T[]} array
+	 */
+	deserialize(context) {
+		/** @type {number} */
+		const length = context.read();
+		/** @type {T[]} */
 		const array = [];
 		for (let i = 0; i < length; i++) {
-			array.push(read());
+			array.push(context.read());
 		}
 		return array;
 	}

package/lib/serialization/BinaryMiddleware.js

@@ -101,6 +101,10 @@ const MEASURE_END_OPERATION = Symbol("MEASURE_END_OPERATION");
 /** @typedef {typeof MEASURE_START_OPERATION} MEASURE_START_OPERATION_TYPE */
 /** @typedef {typeof MEASURE_END_OPERATION} MEASURE_END_OPERATION_TYPE */
 
+/**
+ * @param {number} n number
+ * @returns {0 | 1 | 2} type of number for serialization
+ */
 const identifyNumber = n => {
 	if (n === (n | 0)) {
 		if (n <= 127 && n >= -128) return 0;
@@ -203,17 +207,27 @@ class BinaryMiddleware extends SerializerMiddleware {
 				currentPosition = 0;
 			}
 		};
+		/**
+		 * @param {number} byte byte
+		 */
 		const writeU8 = byte => {
 			currentBuffer.writeUInt8(byte, currentPosition++);
 		};
+		/**
+		 * @param {number} ui32 ui32
+		 */
 		const writeU32 = ui32 => {
 			currentBuffer.writeUInt32LE(ui32, currentPosition);
 			currentPosition += 4;
 		};
+		/** @type {number[]} */
 		const measureStack = [];
 		const measureStart = () => {
 			measureStack.push(buffers.length, currentPosition);
 		};
+		/**
+		 * @returns {number} size
+		 */
 		const measureEnd = () => {
 			const oldPos = measureStack.pop();
 			const buffersIndex = measureStack.pop();
@@ -258,6 +272,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 							break;
 						}
 					}
+					/** @type {number[]} */
 					const lengths = [];
 					for (const item of serializedData) {
 						let last;
@@ -640,6 +655,9 @@ class BinaryMiddleware extends SerializerMiddleware {
 			checkOverflow();
 			return res;
 		};
+		/**
+		 * @returns {number} U8
+		 */
 		const readU8 = () => {
 			ensureBuffer();
 			/**
@@ -653,6 +671,9 @@ class BinaryMiddleware extends SerializerMiddleware {
 			checkOverflow();
 			return byte;
 		};
+		/**
+		 * @returns {number} U32
+		 */
 		const readU32 = () => {
 			return read(I32_SIZE).readUInt32LE(0);
 		};

package/lib/serialization/DateObjectSerializer.js

@@ -4,12 +4,23 @@
 
 "use strict";
 
+/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
 class DateObjectSerializer {
-	serialize(obj, { write }) {
-		write(obj.getTime());
+	/**
+	 * @param {Date} obj date
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(obj, context) {
+		context.write(obj.getTime());
 	}
-	deserialize({ read }) {
-		return new Date(read());
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {Date} date
+	 */
+	deserialize(context) {
+		return new Date(context.read());
 	}
 }
 

package/lib/serialization/ErrorObjectSerializer.js

@@ -4,21 +4,33 @@
 
 "use strict";
 
+/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
 class ErrorObjectSerializer {
+	/**
+	 * @param {ErrorConstructor | EvalErrorConstructor | RangeErrorConstructor | ReferenceErrorConstructor | SyntaxErrorConstructor | TypeErrorConstructor} Type error type
+	 */
 	constructor(Type) {
 		this.Type = Type;
 	}
-
-	serialize(obj, { write }) {
-		write(obj.message);
-		write(obj.stack);
+	/**
+	 * @param {Error | EvalError | RangeError | ReferenceError | SyntaxError | TypeError} obj error
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(obj, context) {
+		context.write(obj.message);
+		context.write(obj.stack);
 	}
-
-	deserialize({ read }) {
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {Error | EvalError | RangeError | ReferenceError | SyntaxError | TypeError} error
+	 */
+	deserialize(context) {
 		const err = new this.Type();
 
-		err.message = read();
-		err.stack = read();
+		err.message = context.read();
+		err.stack = context.read();
 
 		return err;
 	}

package/lib/serialization/FileMiddleware.js

@@ -181,6 +181,7 @@ const serialize = async (
 		SerializerMiddleware.setLazySerializedValue(lazy, buf);
 		return buf;
 	});
+	/** @type {number[]} */
 	const lengths = [];
 	for (const item of resolvedData) {
 		if (Array.isArray(item)) {
@@ -203,6 +204,7 @@ const serialize = async (
 	for (let i = 0; i < lengths.length; i++) {
 		header.writeInt32LE(lengths[i], 8 + i * 4);
 	}
+	/** @type {Buffer[]} */
 	const buf = [header];
 	for (const item of resolvedData) {
 		if (Array.isArray(item)) {
@@ -247,6 +249,9 @@ const deserialize = async (middleware, name, readFile) => {
 		contentItemLength = contentItem.length;
 		contentPosition = 0;
 	};
+	/**
+	 * @param {number} n number of bytes to ensure
+	 */
 	const ensureData = n => {
 		if (contentPosition === contentItemLength) {
 			nextContent();
@@ -274,18 +279,28 @@ const deserialize = async (middleware, name, readFile) => {
 			contentPosition = 0;
 		}
 	};
+	/**
+	 * @returns {number} value value
+	 */
 	const readUInt32LE = () => {
 		ensureData(4);
 		const value = contentItem.readUInt32LE(contentPosition);
 		contentPosition += 4;
 		return value;
 	};
+	/**
+	 * @returns {number} value value
+	 */
 	const readInt32LE = () => {
 		ensureData(4);
 		const value = contentItem.readInt32LE(contentPosition);
 		contentPosition += 4;
 		return value;
 	};
+	/**
+	 * @param {number} l length
+	 * @returns {Buffer} buffer
+	 */
 	const readSlice = l => {
 		ensureData(l);
 		if (contentPosition === 0 && contentItemLength === l) {
@@ -556,7 +571,9 @@ class FileMiddleware extends SerializerMiddleware {
 						return;
 					}
 					let remaining = /** @type {number} */ (stats.size);
+					/** @type {Buffer | undefined} */
 					let currentBuffer;
+					/** @type {number | undefined} */
 					let currentBufferUsed;
 					const buf = [];
 					let decompression;

package/lib/serialization/MapObjectSerializer.js

@@ -4,25 +4,41 @@
 
 "use strict";
 
+/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
 class MapObjectSerializer {
-	serialize(obj, { write }) {
-		write(obj.size);
+	/**
+	 * @template K, V
+	 * @param {Map<K, V>} obj map
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(obj, context) {
+		context.write(obj.size);
 		for (const key of obj.keys()) {
-			write(key);
+			context.write(key);
 		}
 		for (const value of obj.values()) {
-			write(value);
+			context.write(value);
 		}
 	}
-	deserialize({ read }) {
-		let size = read();
+	/**
+	 * @template K, V
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {Map<K, V>} map
+	 */
+	deserialize(context) {
+		/** @type {number} */
+		let size = context.read();
+		/** @type {Map<K, V>} */
 		const map = new Map();
+		/** @type {K[]} */
 		const keys = [];
 		for (let i = 0; i < size; i++) {
-			keys.push(read());
+			keys.push(context.read());
 		}
 		for (let i = 0; i < size; i++) {
-			map.set(keys[i], read());
+			map.set(keys[i], context.read());
 		}
 		return map;
 	}

package/lib/serialization/NullPrototypeObjectSerializer.js

@@ -4,27 +4,44 @@
 
 "use strict";
 
+/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
 class NullPrototypeObjectSerializer {
-	serialize(obj, { write }) {
+	/**
+	 * @template {Object} T
+	 * @param {T} obj null object
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(obj, context) {
+		/** @type {string[]} */
 		const keys = Object.keys(obj);
 		for (const key of keys) {
-			write(key);
+			context.write(key);
 		}
-		write(null);
+		context.write(null);
 		for (const key of keys) {
-			write(obj[key]);
+			context.write(obj[key]);
 		}
 	}
-	deserialize({ read }) {
+	/**
+	 * @template {Object} T
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {T} null object
+	 */
+	deserialize(context) {
+		/** @type {T} */
 		const obj = Object.create(null);
+		/** @type {string[]} */
 		const keys = [];
-		let key = read();
+		/** @type {string | null} */
+		let key = context.read();
 		while (key !== null) {
 			keys.push(key);
-			key = read();
+			key = context.read();
 		}
 		for (const key of keys) {
-			obj[key] = read();
+			obj[key] = context.read();
 		}
 		return obj;
 	}

package/lib/serialization/ObjectMiddleware.js

@@ -61,6 +61,11 @@ Technically any value can be used.
  * @property {function(ObjectDeserializerContext): any} deserialize
  */
 
+/**
+ * @template T
+ * @param {Set<T>} set set
+ * @param {number} size count of items to keep
+ */
 const setSetSize = (set, size) => {
 	let i = 0;
 	for (const item of set) {
@@ -70,6 +75,11 @@ const setSetSize = (set, size) => {
 	}
 };
 
+/**
+ * @template K, X
+ * @param {Map<K, X>} map map
+ * @param {number} size count of items to keep
+ */
 const setMapSize = (map, size) => {
 	let i = 0;
 	for (const item of map.keys()) {
@@ -97,9 +107,12 @@ const ESCAPE_UNDEFINED = false;
 
 const CURRENT_VERSION = 2;
 
+/** @type {Map<Constructor, { request?: string, name?: string | number , serializer?: ObjectSerializer }>} */
 const serializers = new Map();
+/** @type {Map<string | number, ObjectSerializer>} */
 const serializerInversed = new Map();
 
+/** @type {Set<string>} */
 const loadedRequests = new Set();
 
 const NOT_SERIALIZABLE = {};
@@ -242,6 +255,11 @@ class ObjectMiddleware extends SerializerMiddleware {
 		return config;
 	}
 
+	/**
+	 * @param {string} request request
+	 * @param {TODO} name name
+	 * @returns {ObjectSerializer} serializer
+	 */
 	static getDeserializerFor(request, name) {
 		const key = request + "/" + name;
 		const serializer = serializerInversed.get(key);
@@ -253,6 +271,11 @@ class ObjectMiddleware extends SerializerMiddleware {
 		return serializer;
 	}
 
+	/**
+	 * @param {string} request request
+	 * @param {TODO} name name
+	 * @returns {ObjectSerializer} serializer
+	 */
 	static _getDeserializerForWithoutError(request, name) {
 		const key = request + "/" + name;
 		const serializer = serializerInversed.get(key);

package/lib/serialization/PlainObjectSerializer.js

@@ -4,6 +4,9 @@
 
 "use strict";
 
+/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
 const cache = new WeakMap();
 
 class ObjectStructure {
@@ -41,37 +44,45 @@ const getCachedKeys = (keys, cacheAssoc) => {
 };
 
 class PlainObjectSerializer {
-	serialize(obj, { write }) {
+	/**
+	 * @param {Object} obj plain object
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(obj, context) {
 		const keys = Object.keys(obj);
 		if (keys.length > 128) {
 			// Objects with so many keys are unlikely to share structure
 			// with other objects
-			write(keys);
+			context.write(keys);
 			for (const key of keys) {
-				write(obj[key]);
+				context.write(obj[key]);
 			}
 		} else if (keys.length > 1) {
-			write(getCachedKeys(keys, write));
+			context.write(getCachedKeys(keys, context.write));
 			for (const key of keys) {
-				write(obj[key]);
+				context.write(obj[key]);
 			}
 		} else if (keys.length === 1) {
 			const key = keys[0];
-			write(key);
-			write(obj[key]);
+			context.write(key);
+			context.write(obj[key]);
 		} else {
-			write(null);
+			context.write(null);
 		}
 	}
-	deserialize({ read }) {
-		const keys = read();
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {Object} plain object
+	 */
+	deserialize(context) {
+		const keys = context.read();
 		const obj = {};
 		if (Array.isArray(keys)) {
 			for (const key of keys) {
-				obj[key] = read();
+				obj[key] = context.read();
 			}
 		} else if (keys !== null) {
-			obj[keys] = read();
+			obj[keys] = context.read();
 		}
 		return obj;
 	}

package/lib/serialization/RegExpObjectSerializer.js

@@ -4,13 +4,24 @@
 
 "use strict";
 
+/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
 class RegExpObjectSerializer {
-	serialize(obj, { write }) {
-		write(obj.source);
-		write(obj.flags);
+	/**
+	 * @param {RegExp} obj regexp
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(obj, context) {
+		context.write(obj.source);
+		context.write(obj.flags);
 	}
-	deserialize({ read }) {
-		return new RegExp(read(), read());
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {RegExp} regexp
+	 */
+	deserialize(context) {
+		return new RegExp(context.read(), context.read());
 	}
 }
 

package/lib/serialization/SetObjectSerializer.js

@@ -4,18 +4,33 @@
 
 "use strict";
 
+/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
 class SetObjectSerializer {
-	serialize(obj, { write }) {
-		write(obj.size);
+	/**
+	 * @template T
+	 * @param {Set<T>} obj set
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(obj, context) {
+		context.write(obj.size);
 		for (const value of obj) {
-			write(value);
+			context.write(value);
 		}
 	}
-	deserialize({ read }) {
-		let size = read();
+	/**
+	 * @template T
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {Set<T>} date
+	 */
+	deserialize(context) {
+		/** @type {number} */
+		let size = context.read();
+		/** @type {Set<T>} */
 		const set = new Set();
 		for (let i = 0; i < size; i++) {
-			set.add(read());
+			set.add(context.read());
 		}
 		return set;
 	}