webpack 5.76.1 → 5.88.2

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

@@ -46,11 +46,13 @@ Technically any value can be used.
 /**
  * @typedef {Object} ObjectSerializerContext
  * @property {function(any): void} write
+ * @property {function(any): void} setCircularReference
  */
 
 /**
  * @typedef {Object} ObjectDeserializerContext
  * @property {function(): any} read
+ * @property {function(any): void} setCircularReference
  */
 
 /**
@@ -59,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) {
@@ -68,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()) {
@@ -95,9 +107,12 @@ const ESCAPE_UNDEFINED = false;
 
 const CURRENT_VERSION = 2;
 
+/** @type {Map<Constructor, { request?: string, name?: string | number | null, 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 = {};
@@ -143,7 +158,10 @@ if (exports.constructor !== Object) {
 }
 
 for (const { request, name, serializer } of serializers.values()) {
-	serializerInversed.set(`${request}/${name}`, serializer);
+	serializerInversed.set(
+		`${request}/${name}`,
+		/** @type {ObjectSerializer} */ (serializer)
+	);
 }
 
 /** @type {Map<RegExp, (request: string) => boolean>} */
@@ -176,7 +194,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 	/**
 	 * @param {Constructor} Constructor the constructor
 	 * @param {string} request the request which will be required when deserializing
-	 * @param {string} name the name to make multiple serializer unique when sharing a request
+	 * @param {string | null} name the name to make multiple serializer unique when sharing a request
 	 * @param {ObjectSerializer} serializer the serializer
 	 * @returns {void}
 	 */
@@ -240,6 +258,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);
@@ -251,6 +274,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);
@@ -372,6 +400,9 @@ class ObjectMiddleware extends SerializerMiddleware {
 							", "
 						)} }`;
 					}
+					if (typeof item === "bigint") {
+						return `BigInt ${item}n`;
+					}
 					try {
 						return `${item}`;
 					} catch (e) {

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/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/lib/sharing/ConsumeSharedFallbackDependency.js

@@ -9,6 +9,9 @@ const ModuleDependency = require("../dependencies/ModuleDependency");
 const makeSerializable = require("../util/makeSerializable");
 
 class ConsumeSharedFallbackDependency extends ModuleDependency {
+	/**
+	 * @param {string} request the request
+	 */
 	constructor(request) {
 		super(request);
 	}

package/lib/sharing/ConsumeSharedModule.js

@@ -8,6 +8,9 @@
 const { RawSource } = require("webpack-sources");
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const Module = require("../Module");
+const {
+	WEBPACK_MODULE_TYPE_CONSUME_SHARED_MODULE
+} = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const makeSerializable = require("../util/makeSerializable");
 const { rangeToString, stringifyHoley } = require("../util/semver");
@@ -25,6 +28,8 @@ const ConsumeSharedFallbackDependency = require("./ConsumeSharedFallbackDependen
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("../util/semver").SemVerRange} SemVerRange */
@@ -50,7 +55,7 @@ class ConsumeSharedModule extends Module {
 	 * @param {ConsumeOptions} options consume options
 	 */
 	constructor(context, options) {
-		super("consume-shared-module", context);
+		super(WEBPACK_MODULE_TYPE_CONSUME_SHARED_MODULE, context);
 		this.options = options;
 	}
 
@@ -67,7 +72,7 @@ class ConsumeSharedModule extends Module {
 			singleton,
 			eager
 		} = this.options;
-		return `consume-shared-module|${shareScope}|${shareKey}|${
+		return `${WEBPACK_MODULE_TYPE_CONSUME_SHARED_MODULE}|${shareScope}|${shareKey}|${
 			requiredVersion && rangeToString(requiredVersion)
 		}|${strictVersion}|${importResolved}|${singleton}|${eager}`;
 	}
@@ -230,12 +235,18 @@ class ConsumeSharedModule extends Module {
 		};
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 		write(this.options);
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 		this.options = read();

package/lib/sharing/ConsumeSharedPlugin.js

@@ -224,6 +224,10 @@ class ConsumeSharedPlugin {
 										);
 										return resolve();
 									}
+									if (data.name === packageName) {
+										// Package self-referencing
+										return resolve();
+									}
 									const requiredVersion = getRequiredVersionFromDescriptionFile(
 										data,
 										packageName

package/lib/sharing/ConsumeSharedRuntimeModule.js

@@ -17,24 +17,31 @@ const {
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("./ConsumeSharedModule")} ConsumeSharedModule */
 
 class ConsumeSharedRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {ReadonlySet<string>} runtimeRequirements runtime requirements
+	 */
 	constructor(runtimeRequirements) {
 		super("consumes", RuntimeModule.STAGE_ATTACH);
 		this._runtimeRequirements = runtimeRequirements;
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { compilation, chunkGraph } = this;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
 		const { runtimeTemplate, codeGenerationResults } = compilation;
 		const chunkToModuleMapping = {};
 		/** @type {Map<string | number, Source>} */
 		const moduleIdToSourceMapping = new Map();
+		/** @type {(string | number)[]} */
 		const initialConsumes = [];
 		/**
 		 *
@@ -57,7 +64,7 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
 				);
 			}
 		};
-		for (const chunk of this.chunk.getAllAsyncChunks()) {
+		for (const chunk of /** @type {Chunk} */ (this.chunk).getAllAsyncChunks()) {
 			const modules = chunkGraph.getChunkModulesIterableBySourceType(
 				chunk,
 				"consume-shared"
@@ -65,7 +72,9 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
 			if (!modules) continue;
 			addModules(modules, chunk, (chunkToModuleMapping[chunk.id] = []));
 		}
-		for (const chunk of this.chunk.getAllInitialChunks()) {
+		for (const chunk of /** @type {Chunk} */ (
+			this.chunk
+		).getAllInitialChunks()) {
 			const modules = chunkGraph.getChunkModulesIterableBySourceType(
 				chunk,
 				"consume-shared"
@@ -119,8 +128,7 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
 				"scope, scopeName, key, requiredVersion",
 				[
 					"var version = findSingletonVersionKey(scope, key);",
-					"if (!satisfy(requiredVersion, version)) " +
-						'typeof console !== "undefined" && console.warn && console.warn(getInvalidSingletonVersionMessage(scope, key, version, requiredVersion));',
+					"if (!satisfy(requiredVersion, version)) warn(getInvalidSingletonVersionMessage(scope, key, version, requiredVersion));",
 					"return get(scope[key][version]);"
 				]
 			)};`,
@@ -166,10 +174,17 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
 					"throw new Error(getInvalidVersionMessage(scope, scopeName, key, requiredVersion));"
 				]
 			)};`,
+			`var warn = ${
+				compilation.outputOptions.ignoreBrowserWarnings
+					? runtimeTemplate.basicFunction("", "")
+					: runtimeTemplate.basicFunction("msg", [
+							'if (typeof console !== "undefined" && console.warn) console.warn(msg);'
+					  ])
+			};`,
 			`var warnInvalidVersion = ${runtimeTemplate.basicFunction(
 				"scope, scopeName, key, requiredVersion",
 				[
-					'typeof console !== "undefined" && console.warn && console.warn(getInvalidVersionMessage(scope, scopeName, key, requiredVersion));'
+					"warn(getInvalidVersionMessage(scope, scopeName, key, requiredVersion));"
 				]
 			)};`,
 			`var get = ${runtimeTemplate.basicFunction("entry", [

package/lib/sharing/ProvideSharedDependency.js

@@ -8,7 +8,17 @@
 const Dependency = require("../Dependency");
 const makeSerializable = require("../util/makeSerializable");
 
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
 class ProvideSharedDependency extends Dependency {
+	/**
+	 * @param {string} shareScope share scope
+	 * @param {string} name module name
+	 * @param {string | false} version version
+	 * @param {string} request request
+	 * @param {boolean} eager true, if this is an eager dependency
+	 */
 	constructor(shareScope, name, version, request, eager) {
 		super();
 		this.shareScope = shareScope;
@@ -31,6 +41,9 @@ class ProvideSharedDependency extends Dependency {
 		} @ ${this.version}${this.eager ? " (eager)" : ""}`;
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		context.write(this.shareScope);
 		context.write(this.name);
@@ -40,6 +53,10 @@ class ProvideSharedDependency extends Dependency {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {ProvideSharedDependency} deserialize fallback dependency
+	 */
 	static deserialize(context) {
 		const { read } = context;
 		const obj = new ProvideSharedDependency(

package/lib/sharing/ProvideSharedModule.js

@@ -7,6 +7,7 @@
 
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const Module = require("../Module");
+const { WEBPACK_MODULE_TYPE_PROVIDE } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const makeSerializable = require("../util/makeSerializable");
 const ProvideForSharedDependency = require("./ProvideForSharedDependency");
@@ -23,6 +24,8 @@ const ProvideForSharedDependency = require("./ProvideForSharedDependency");
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 
@@ -37,7 +40,7 @@ class ProvideSharedModule extends Module {
 	 * @param {boolean} eager include the module in sync way
 	 */
 	constructor(shareScope, name, version, request, eager) {
-		super("provide-module");
+		super(WEBPACK_MODULE_TYPE_PROVIDE);
 		this._shareScope = shareScope;
 		this._name = name;
 		this._version = version;
@@ -158,6 +161,9 @@ class ProvideSharedModule extends Module {
 		return { sources, data, runtimeRequirements };
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 		write(this._shareScope);
@@ -168,6 +174,10 @@ class ProvideSharedModule extends Module {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {ProvideSharedModule} deserialize fallback dependency
+	 */
 	static deserialize(context) {
 		const { read } = context;
 		const obj = new ProvideSharedModule(read(), read(), read(), read(), read());

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) {