webpack 5.83.1 → 5.85.0

package/lib/runtime/PublicPathRuntimeModule.js

@@ -7,7 +7,12 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 
+/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputOptions */
+
 class PublicPathRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {OutputOptions["publicPath"]} publicPath public path
+	 */
 	constructor(publicPath) {
 		super("publicPath", RuntimeModule.STAGE_BASIC);
 		this.publicPath = publicPath;

package/lib/runtime/StartupChunkDependenciesPlugin.js

@@ -8,9 +8,20 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const StartupChunkDependenciesRuntimeModule = require("./StartupChunkDependenciesRuntimeModule");
 const StartupEntrypointRuntimeModule = require("./StartupEntrypointRuntimeModule");
 
+/** @typedef {import("../../declarations/WebpackOptions").ChunkLoadingType} ChunkLoadingType */
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
+/**
+ * @typedef {Object} Options
+ * @property {ChunkLoadingType} chunkLoading
+ * @property {boolean=} asyncChunkLoading
+ */
+
 class StartupChunkDependenciesPlugin {
+	/**
+	 * @param {Options} options options
+	 */
 	constructor(options) {
 		this.chunkLoading = options.chunkLoading;
 		this.asyncChunkLoading =
@@ -29,6 +40,10 @@ class StartupChunkDependenciesPlugin {
 			"StartupChunkDependenciesPlugin",
 			compilation => {
 				const globalChunkLoading = compilation.outputOptions.chunkLoading;
+				/**
+				 * @param {Chunk} chunk chunk to check
+				 * @returns {boolean} true, when the plugin is enabled for the chunk
+				 */
 				const isEnabledForChunk = chunk => {
 					const options = chunk.getEntryOptions();
 					const chunkLoading =

package/lib/runtime/StartupChunkDependenciesRuntimeModule.js

@@ -10,6 +10,9 @@ const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
 class StartupChunkDependenciesRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {boolean} asyncChunkLoading use async chunk loading
+	 */
 	constructor(asyncChunkLoading) {
 		super("startup chunk dependencies", RuntimeModule.STAGE_TRIGGER);
 		this.asyncChunkLoading = asyncChunkLoading;
@@ -45,7 +48,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

@@ -10,6 +10,9 @@ const RuntimeModule = require("../RuntimeModule");
 /** @typedef {import("../MainTemplate")} MainTemplate */
 
 class StartupEntrypointRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {boolean} asyncChunkLoading use async chunk loading
+	 */
 	constructor(asyncChunkLoading) {
 		super("startup entrypoint");
 		this.asyncChunkLoading = asyncChunkLoading;
@@ -27,19 +30,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;
 	}

package/lib/sharing/ProvideSharedModuleFactory.js

@@ -15,7 +15,7 @@ const ProvideSharedModule = require("./ProvideSharedModule");
 class ProvideSharedModuleFactory extends ModuleFactory {
 	/**
 	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @param {function((Error | null)=, ModuleFactoryResult=): void} callback callback
 	 * @returns {void}
 	 */
 	create(data, callback) {

package/lib/sharing/ShareRuntimeModule.js

@@ -100,7 +100,7 @@ class ShareRuntimeModule extends RuntimeModule {
 						)};`,
 						"try {",
 						Template.indent([
-							"var module = __webpack_require__(id);",
+							`var module = ${RuntimeGlobals.require}(id);`,
 							"if(!module) return;",
 							`var initFn = ${runtimeTemplate.returningFunction(
 								`module && module.init && module.init(${RuntimeGlobals.shareScopeMap}[name], initScope)`,

package/lib/util/createHash.js

@@ -132,7 +132,7 @@ let BatchedHash = undefined;
 
 /**
  * Creates a hash by name or function
- * @param {string | typeof Hash} algorithm the algorithm name or a constructor creating a hash
+ * @param {string | typeof Hash | undefined} algorithm the algorithm name or a constructor creating a hash
  * @returns {Hash} the hash
  */
 module.exports = algorithm => {