webpack 5.94.0 → 5.96.0

package/lib/rules/RuleSetCompiler.js

@@ -10,7 +10,7 @@ const { SyncHook } = require("tapable");
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetRules} RuleSetRules */
 
-/** @typedef {function(string): boolean} RuleConditionFunction */
+/** @typedef {function(string | EffectData): boolean} RuleConditionFunction */
 
 /**
  * @typedef {object} RuleCondition
@@ -106,7 +106,7 @@ class RuleSetCompiler {
 						}
 					}
 					if (current !== undefined) {
-						if (!condition.fn(/** @type {string} */ (current))) return false;
+						if (!condition.fn(current)) return false;
 						continue;
 					}
 				} else if (p in data) {

package/lib/runtime/GetChunkFilenameRuntimeModule.js

@@ -20,7 +20,7 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 	 * @param {string} contentType the contentType to use the content hash for
 	 * @param {string} name kind of filename
 	 * @param {string} global function name to be assigned
-	 * @param {function(Chunk): TemplatePath} getFilenameForChunk functor to get the filename or function
+	 * @param {function(Chunk): TemplatePath | false} getFilenameForChunk functor to get the filename or function
 	 * @param {boolean} allChunks when false, only async chunks are included
 	 */
 	constructor(contentType, name, global, getFilenameForChunk, allChunks) {
@@ -244,7 +244,7 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 				hashWithLength: length =>
 					`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
 				chunk: {
-					id: `" + chunkId + "`,
+					id: '" + chunkId + "',
 					hash: mapExpr(c => /** @type {string} */ (c.renderedHash)),
 					hashWithLength: mapExprWithLength(
 						c => /** @type {string} */ (c.renderedHash)

package/lib/schemes/DataUriPlugin.js

@@ -11,7 +11,7 @@ const NormalModule = require("../NormalModule");
 
 // data URL scheme: "data:text/javascript;charset=utf-8;base64,some-string"
 // http://www.ietf.org/rfc/rfc2397.txt
-const URIRegEx = /^data:([^;,]+)?((?:;[^;,]+)*?)(?:;(base64))?,(.*)$/i;
+const URIRegEx = /^data:([^;,]+)?((?:;[^;,]+)*?)(?:;(base64)?)?,(.*)$/i;
 
 /**
  * @param {string} uri data URI

package/lib/serialization/BinaryMiddleware.js

@@ -135,6 +135,8 @@ const identifyBigInt = n => {
 	return 2;
 };
 
+/** @typedef {TODO} Context */
+
 /**
  * @typedef {PrimitiveSerializableType[]} DeserializedType
  * @typedef {BufferSerializableType[]} SerializedType
@@ -152,7 +154,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 
 	/**
 	 * @param {function(): Promise<any> | any} fn lazy function
-	 * @param {object} context serialize function
+	 * @param {TODO} context serialize function
 	 * @returns {function(): Promise<any> | any} new lazy
 	 */
 	_serializeLazy(fn, context) {
@@ -163,7 +165,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 
 	/**
 	 * @param {DeserializedType} data data
-	 * @param {object} context context object
+	 * @param {TODO} context context object
 	 * @param {{ leftOverBuffer: Buffer | null, allocationSize: number, increaseCounter: number }} allocationScope allocation scope
 	 * @returns {SerializedType} serialized data
 	 */
@@ -634,9 +636,9 @@ class BinaryMiddleware extends SerializerMiddleware {
 		// avoid leaking memory
 		currentBuffer = null;
 		leftOverBuffer = null;
-		allocationScope = undefined;
+		allocationScope = /** @type {EXPECTED_ANY} */ (undefined);
 		const _buffers = buffers;
-		buffers = undefined;
+		buffers = /** @type {EXPECTED_ANY} */ (undefined);
 		return _buffers;
 	}
 
@@ -666,19 +668,21 @@ class BinaryMiddleware extends SerializerMiddleware {
 
 	/**
 	 * @param {SerializedType} data data
-	 * @param {object} context context object
+	 * @param {TODO} context context object
 	 * @returns {DeserializedType} deserialized data
 	 */
 	_deserialize(data, context) {
 		let currentDataItem = 0;
+		/** @type {BufferSerializableType | null} */
 		let currentBuffer = data[0];
 		let currentIsBuffer = Buffer.isBuffer(currentBuffer);
 		let currentPosition = 0;
 
+		/** @type {(x: Buffer) => Buffer} */
 		const retainedBuffer = context.retainedBuffer || (x => x);
 
 		const checkOverflow = () => {
-			if (currentPosition >= currentBuffer.length) {
+			if (currentPosition >= /** @type {Buffer} */ (currentBuffer).length) {
 				currentPosition = 0;
 				currentDataItem++;
 				currentBuffer =
@@ -691,7 +695,8 @@ class BinaryMiddleware extends SerializerMiddleware {
 		 * @returns {boolean} true when in current buffer, otherwise false
 		 */
 		const isInCurrentBuffer = n =>
-			currentIsBuffer && n + currentPosition <= currentBuffer.length;
+			currentIsBuffer &&
+			n + currentPosition <= /** @type {Buffer} */ (currentBuffer).length;
 		const ensureBuffer = () => {
 			if (!currentIsBuffer) {
 				throw new Error(
@@ -708,12 +713,13 @@ class BinaryMiddleware extends SerializerMiddleware {
 		 */
 		const read = n => {
 			ensureBuffer();
-			const rem = currentBuffer.length - currentPosition;
+			const rem =
+				/** @type {Buffer} */ (currentBuffer).length - currentPosition;
 			if (rem < n) {
 				const buffers = [read(rem)];
 				n -= rem;
 				ensureBuffer();
-				while (currentBuffer.length < n) {
+				while (/** @type {Buffer} */ (currentBuffer).length < n) {
 					const b = /** @type {Buffer} */ (currentBuffer);
 					buffers.push(b);
 					n -= b.length;
@@ -739,7 +745,9 @@ class BinaryMiddleware extends SerializerMiddleware {
 		 */
 		const readUpTo = n => {
 			ensureBuffer();
-			const rem = currentBuffer.length - currentPosition;
+			const rem =
+				/** @type {Buffer} */
+				(currentBuffer).length - currentPosition;
 			if (rem < n) {
 				n = rem;
 			}
@@ -901,7 +909,8 @@ class BinaryMiddleware extends SerializerMiddleware {
 						const len = readU32();
 						if (isInCurrentBuffer(len) && currentPosition + len < 0x7fffffff) {
 							result.push(
-								currentBuffer.toString(
+								/** @type {Buffer} */
+								(currentBuffer).toString(
 									undefined,
 									currentPosition,
 									currentPosition + len
@@ -919,7 +928,8 @@ class BinaryMiddleware extends SerializerMiddleware {
 					return () => {
 						if (currentIsBuffer && currentPosition < 0x7ffffffe) {
 							result.push(
-								currentBuffer.toString(
+								/** @type {Buffer} */
+								(currentBuffer).toString(
 									"latin1",
 									currentPosition,
 									currentPosition + 1
@@ -992,11 +1002,13 @@ class BinaryMiddleware extends SerializerMiddleware {
 					return () => {
 						const len = readU32();
 						if (isInCurrentBuffer(len) && currentPosition + len < 0x7fffffff) {
-							const value = currentBuffer.toString(
-								undefined,
-								currentPosition,
-								currentPosition + len
-							);
+							const value =
+								/** @type {Buffer} */
+								(currentBuffer).toString(
+									undefined,
+									currentPosition,
+									currentPosition + len
+								);
 
 							result.push(BigInt(value));
 							currentPosition += len;
@@ -1018,7 +1030,8 @@ class BinaryMiddleware extends SerializerMiddleware {
 								currentPosition + len < 0x7fffffff
 							) {
 								result.push(
-									currentBuffer.toString(
+									/** @type {Buffer} */
+									(currentBuffer).toString(
 										"latin1",
 										currentPosition,
 										currentPosition + len
@@ -1118,7 +1131,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 		// avoid leaking memory in context
 		// eslint-disable-next-line prefer-const
 		let _result = result;
-		result = undefined;
+		result = /** @type {EXPECTED_ANY} */ (undefined);
 		return _result;
 	}
 }

package/lib/serialization/ObjectMiddleware.js

@@ -281,8 +281,8 @@ class ObjectMiddleware extends SerializerMiddleware {
 
 	/**
 	 * @param {string} request request
-	 * @param {TODO} name name
-	 * @returns {ObjectSerializer} serializer
+	 * @param {string} name name
+	 * @returns {ObjectSerializer | undefined} serializer
 	 */
 	static _getDeserializerForWithoutError(request, name) {
 		const key = `${request}/${name}`;
@@ -304,6 +304,10 @@ class ObjectMiddleware extends SerializerMiddleware {
 			referenceable.set(item, currentPos++);
 		};
 		let bufferDedupeMap = new Map();
+		/**
+		 * @param {Buffer} buf buffer
+		 * @returns {Buffer} deduped buffer
+		 */
 		const dedupeBuffer = buf => {
 			const len = buf.length;
 			const entry = bufferDedupeMap.get(len);
@@ -412,6 +416,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 				})
 				.join(" -> ");
 		};
+		/** @type {WeakSet<Error>} */
 		let hasDebugInfoAttached;
 		let ctx = {
 			write(value, key) {
@@ -421,9 +426,10 @@ class ObjectMiddleware extends SerializerMiddleware {
 					if (err !== NOT_SERIALIZABLE) {
 						if (hasDebugInfoAttached === undefined)
 							hasDebugInfoAttached = new WeakSet();
-						if (!hasDebugInfoAttached.has(err)) {
-							err.message += `\nwhile serializing ${stackToString(value)}`;
-							hasDebugInfoAttached.add(err);
+						if (!hasDebugInfoAttached.has(/** @type {Error} */ (err))) {
+							/** @type {Error} */
+							(err).message += `\nwhile serializing ${stackToString(value)}`;
+							hasDebugInfoAttached.add(/** @type {Error} */ (err));
 						}
 					}
 					throw err;
@@ -586,7 +592,8 @@ class ObjectMiddleware extends SerializerMiddleware {
 				bufferDedupeMap =
 				objectTypeLookup =
 				ctx =
-					undefined;
+					/** @type {EXPECTED_ANY} */
+					(undefined);
 		}
 	}
 
@@ -657,7 +664,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 									`at position ${currentDataPos - 1}`
 							);
 						}
-						const name = read();
+						const name = /** @type {string} */ (read());
 
 						serializer = ObjectMiddleware._getDeserializerForWithoutError(
 							request,
@@ -721,7 +728,8 @@ class ObjectMiddleware extends SerializerMiddleware {
 								: serializerEntry[1].name
 									? `${serializerEntry[1].request} ${serializerEntry[1].name}`
 									: serializerEntry[1].request;
-						err.message += `\n(during deserialization of ${name})`;
+						/** @type {Error} */
+						(err).message += `\n(during deserialization of ${name})`;
 						throw err;
 					}
 				}
@@ -755,7 +763,13 @@ class ObjectMiddleware extends SerializerMiddleware {
 			// This happens because the optimized code v8 generates
 			// is optimized for our "ctx.read" method so it will reference
 			// it from e. g. Dependency.prototype.deserialize -(IC)-> ctx.read
-			result = referenceable = data = objectTypeLookup = ctx = undefined;
+			result =
+				referenceable =
+				data =
+				objectTypeLookup =
+				ctx =
+					/** @type {EXPECTED_ANY} */
+					(undefined);
 		}
 	}
 }

package/lib/serialization/SerializerMiddleware.js

@@ -112,9 +112,10 @@ class SerializerMiddleware {
 	}
 
 	/**
+	 * @template T
 	 * @param {function(): Promise<any> | any} lazy lazy function
-	 * @param {function(any): Promise<any> | any} deserialize deserialize function
-	 * @returns {function(): Promise<any> | any} new lazy
+	 * @param {function(T): Promise<T> | T} deserialize deserialize function
+	 * @returns {function(): Promise<T> | T} new lazy
 	 */
 	static deserializeLazy(lazy, deserialize) {
 		const fn = memoize(() => {

package/lib/serialization/types.js

@@ -6,8 +6,8 @@
 
 /** @typedef {undefined | null | number | string | boolean | Buffer | object | (() => ComplexSerializableType[] | Promise<ComplexSerializableType[]>)} ComplexSerializableType */
 
-/** @typedef {undefined|null|number|bigint|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 */
+/** @typedef {Buffer | (() => BufferSerializableType[] | Promise<BufferSerializableType[]>)} BufferSerializableType */
 
 module.exports = {};

package/lib/sharing/ConsumeSharedModule.js

@@ -8,6 +8,7 @@
 const { RawSource } = require("webpack-sources");
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const Module = require("../Module");
+const { CONSUME_SHARED_TYPES } = require("../ModuleSourceTypesConstants");
 const {
 	WEBPACK_MODULE_TYPE_CONSUME_SHARED_MODULE
 } = require("../ModuleTypeConstants");
@@ -48,8 +49,6 @@ const ConsumeSharedFallbackDependency = require("./ConsumeSharedFallbackDependen
  * @property {boolean} eager include the fallback module in a sync way
  */
 
-const TYPES = new Set(["consume-shared"]);
-
 class ConsumeSharedModule extends Module {
 	/**
 	 * @param {string} context context
@@ -151,7 +150,7 @@ class ConsumeSharedModule extends Module {
 	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
-		return TYPES;
+		return CONSUME_SHARED_TYPES;
 	}
 
 	/**

package/lib/sharing/ConsumeSharedRuntimeModule.js

@@ -67,7 +67,9 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
 				);
 			}
 		};
-		for (const chunk of /** @type {Chunk} */ (this.chunk).getAllAsyncChunks()) {
+		for (const chunk of /** @type {Chunk} */ (
+			this.chunk
+		).getAllReferencedChunks()) {
 			const modules = chunkGraph.getChunkModulesIterableBySourceType(
 				chunk,
 				"consume-shared"

package/lib/sharing/ProvideSharedModule.js

@@ -7,6 +7,7 @@
 
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const Module = require("../Module");
+const { SHARED_INIT_TYPES } = require("../ModuleSourceTypesConstants");
 const { WEBPACK_MODULE_TYPE_PROVIDE } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const makeSerializable = require("../util/makeSerializable");
@@ -30,8 +31,6 @@ const ProvideForSharedDependency = require("./ProvideForSharedDependency");
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 
-const TYPES = new Set(["share-init"]);
-
 class ProvideSharedModule extends Module {
 	/**
 	 * @param {string} shareScope shared scope name
@@ -124,7 +123,7 @@ class ProvideSharedModule extends Module {
 	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
-		return TYPES;
+		return SHARED_INIT_TYPES;
 	}
 
 	/**

package/lib/stats/DefaultStatsFactoryPlugin.js

@@ -55,7 +55,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  */
 /** @typedef {import("./StatsFactory")} StatsFactory */
 /** @typedef {import("./StatsFactory").StatsFactoryContext} StatsFactoryContext */
-/** @typedef {Record<string, any> & KnownStatsCompilation} StatsCompilation */
+/** @typedef {Record<string, EXPECTED_ANY> & KnownStatsCompilation} StatsCompilation */
 /**
  * @typedef {object} KnownStatsCompilation
  * @property {any=} env
@@ -83,7 +83,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {Record<string, StatsLogging>=} logging
  */
 
-/** @typedef {Record<string, any> & KnownStatsLogging} StatsLogging */
+/** @typedef {Record<string, EXPECTED_ANY> & KnownStatsLogging} StatsLogging */
 /**
  * @typedef {object} KnownStatsLogging
  * @property {StatsLoggingEntry[]} entries
@@ -91,7 +91,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {boolean} debug
  */
 
-/** @typedef {Record<string, any> & KnownStatsLoggingEntry} StatsLoggingEntry */
+/** @typedef {Record<string, EXPECTED_ANY> & KnownStatsLoggingEntry} StatsLoggingEntry */
 /**
  * @typedef {object} KnownStatsLoggingEntry
  * @property {string} type
@@ -102,7 +102,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {number=} time
  */
 
-/** @typedef {Record<string, any> & KnownStatsAsset} StatsAsset */
+/** @typedef {Record<string, EXPECTED_ANY> & KnownStatsAsset} StatsAsset */
 /**
  * @typedef {object} KnownStatsAsset
  * @property {string} type
@@ -123,11 +123,11 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {boolean=} isOverSizeLimit
  */
 
-/** @typedef {Record<string, any> & KnownStatsChunkGroup} StatsChunkGroup */
+/** @typedef {Record<string, EXPECTED_ANY> & KnownStatsChunkGroup} StatsChunkGroup */
 /**
  * @typedef {object} KnownStatsChunkGroup
- * @property {string=} name
- * @property {(string|number)[]=} chunks
+ * @property {(string | null)=} name
+ * @property {(string | number)[]=} chunks
  * @property {({ name: string, size?: number })[]=} assets
  * @property {number=} filteredAssets
  * @property {number=} assetsSize
@@ -139,7 +139,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {boolean=} isOverSizeLimit
  */
 
-/** @typedef {Record<string, any> & KnownStatsModule} StatsModule */
+/** @typedef {Record<string, EXPECTED_ANY> & KnownStatsModule} StatsModule */
 /**
  * @typedef {object} KnownStatsModule
  * @property {string=} type
@@ -183,7 +183,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {ReturnType<Source["source"]>=} source
  */
 
-/** @typedef {Record<string, any> & KnownStatsProfile} StatsProfile */
+/** @typedef {Record<string, EXPECTED_ANY> & KnownStatsProfile} StatsProfile */
 /**
  * @typedef {object} KnownStatsProfile
  * @property {number} total
@@ -198,7 +198,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {number} dependencies
  */
 
-/** @typedef {Record<string, any> & KnownStatsModuleIssuer} StatsModuleIssuer */
+/** @typedef {Record<string, EXPECTED_ANY> & KnownStatsModuleIssuer} StatsModuleIssuer */
 /**
  * @typedef {object} KnownStatsModuleIssuer
  * @property {string} identifier
@@ -207,7 +207,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {StatsProfile} profile
  */
 
-/** @typedef {Record<string, any> & KnownStatsModuleReason} StatsModuleReason */
+/** @typedef {Record<string, EXPECTED_ANY> & KnownStatsModuleReason} StatsModuleReason */
 /**
  * @typedef {object} KnownStatsModuleReason
  * @property {string | null} moduleIdentifier
@@ -224,7 +224,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {(string | number | null)=} resolvedModuleId
  */
 
-/** @typedef {Record<string, any> & KnownStatsChunk} StatsChunk */
+/** @typedef {Record<string, EXPECTED_ANY> & KnownStatsChunk} StatsChunk */
 /**
  * @typedef {object} KnownStatsChunk
  * @property {boolean} rendered
@@ -250,7 +250,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {StatsChunkOrigin[]=} origins
  */
 
-/** @typedef {Record<string, any> & KnownStatsChunkOrigin} StatsChunkOrigin */
+/** @typedef {Record<string, EXPECTED_ANY> & KnownStatsChunkOrigin} StatsChunkOrigin */
 /**
  * @typedef {object} KnownStatsChunkOrigin
  * @property {string} module
@@ -261,7 +261,7 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {(string | number)=} moduleId
  */
 
-/** @typedef { Record<string, any> & KnownStatsModuleTraceItem} StatsModuleTraceItem */
+/** @typedef { Record<string, EXPECTED_ANY> & KnownStatsModuleTraceItem} StatsModuleTraceItem */
 /**
  * @typedef {object} KnownStatsModuleTraceItem
  * @property {string=} originIdentifier
@@ -273,13 +273,13 @@ const { makePathsRelative, parseResource } = require("../util/identifier");
  * @property {(string|number)=} moduleId
  */
 
-/** @typedef {Record<string, any> & KnownStatsModuleTraceDependency} StatsModuleTraceDependency */
+/** @typedef {Record<string, EXPECTED_ANY> & KnownStatsModuleTraceDependency} StatsModuleTraceDependency */
 /**
  * @typedef {object} KnownStatsModuleTraceDependency
  * @property {string=} loc
  */
 
-/** @typedef {Record<string, any> & KnownStatsError} StatsError */
+/** @typedef {Record<string, EXPECTED_ANY> & KnownStatsError} StatsError */
 /**
  * @typedef {object} KnownStatsError
  * @property {string} message
@@ -601,9 +601,10 @@ const SIMPLE_EXTRACTORS = {
 						}
 						let message;
 						if (entry.type === LogType.time) {
-							message = `${entry.args[0]}: ${
-								entry.args[1] * 1000 + entry.args[2] / 1000000
-							} ms`;
+							const [label, first, second] =
+								/** @type {[string, number, number]} */
+								(entry.args);
+							message = `${label}: ${first * 1000 + second / 1000000} ms`;
 						} else if (entry.args && entry.args.length > 0) {
 							message = util.format(entry.args[0], ...entry.args.slice(1));
 						}
@@ -2369,8 +2370,9 @@ const sortOrderRegular = field => {
 };
 
 /**
+ * @template T
  * @param {string} field field name
- * @returns {function(object, object): 0 | 1 | -1} comparators
+ * @returns {function(T, T): 0 | 1 | -1} comparators
  */
 const sortByField = field => {
 	if (!field) {

package/lib/stats/StatsFactory.js

@@ -41,17 +41,17 @@ const smartGrouping = require("../util/smartGrouping");
 
 /**
  * @typedef {object} StatsFactoryHooks
- * @property {HookMap<SyncBailHook<[ObjectForExtract, FactoryData, StatsFactoryContext], undefined>>} extract
- * @property {HookMap<SyncBailHook<[FactoryDataItem, StatsFactoryContext, number, number], boolean | undefined>>} filter
- * @property {HookMap<SyncBailHook<[Comparator[], StatsFactoryContext], undefined>>} sort
- * @property {HookMap<SyncBailHook<[FactoryDataItem, StatsFactoryContext, number, number], boolean | undefined>>} filterSorted
- * @property {HookMap<SyncBailHook<[GroupConfig[], StatsFactoryContext], undefined>>} groupResults
- * @property {HookMap<SyncBailHook<[Comparator[], StatsFactoryContext], undefined>>} sortResults
- * @property {HookMap<SyncBailHook<[FactoryDataItem, StatsFactoryContext, number, number], boolean | undefined>>} filterResults
- * @property {HookMap<SyncBailHook<[FactoryDataItem[], StatsFactoryContext], Result>>} merge
+ * @property {HookMap<SyncBailHook<[ObjectForExtract, FactoryData, StatsFactoryContext], void>>} extract
+ * @property {HookMap<SyncBailHook<[FactoryDataItem, StatsFactoryContext, number, number], boolean | void>>} filter
+ * @property {HookMap<SyncBailHook<[Comparator[], StatsFactoryContext], void>>} sort
+ * @property {HookMap<SyncBailHook<[FactoryDataItem, StatsFactoryContext, number, number], boolean | void>>} filterSorted
+ * @property {HookMap<SyncBailHook<[GroupConfig[], StatsFactoryContext], void>>} groupResults
+ * @property {HookMap<SyncBailHook<[Comparator[], StatsFactoryContext], void>>} sortResults
+ * @property {HookMap<SyncBailHook<[FactoryDataItem, StatsFactoryContext, number, number], boolean | void>>} filterResults
+ * @property {HookMap<SyncBailHook<[FactoryDataItem[], StatsFactoryContext], Result | void>>} merge
  * @property {HookMap<SyncBailHook<[Result, StatsFactoryContext], Result>>} result
- * @property {HookMap<SyncBailHook<[FactoryDataItem, StatsFactoryContext], string>>} getItemName
- * @property {HookMap<SyncBailHook<[FactoryDataItem, StatsFactoryContext], StatsFactory | undefined>>} getItemFactory
+ * @property {HookMap<SyncBailHook<[FactoryDataItem, StatsFactoryContext], string | void>>} getItemName
+ * @property {HookMap<SyncBailHook<[FactoryDataItem, StatsFactoryContext], StatsFactory | void>>} getItemFactory
  */
 
 /**
@@ -128,8 +128,8 @@ class StatsFactory {
 	 * @param {HM} hookMap hook map
 	 * @param {Caches<H>} cache cache
 	 * @param {string} type type
-	 * @param {function(H): R | undefined} fn fn
-	 * @returns {R | undefined} hook
+	 * @param {function(H): R | void} fn fn
+	 * @returns {R | void} hook
 	 * @private
 	 */
 	_forEachLevel(hookMap, cache, type, fn) {

package/lib/stats/StatsPrinter.js

@@ -67,16 +67,16 @@ const { HookMap, SyncWaterfallHook, SyncBailHook } = require("tapable");
  * @property {(message: string) => string=} formatError
  */
 
-/** @typedef {Record<string, any> & KnownStatsPrinterColorFn & KnownStatsPrinterFormaters & KnownStatsPrinterContext} StatsPrinterContext */
+/** @typedef {Record<string, EXPECTED_ANY> & KnownStatsPrinterColorFn & KnownStatsPrinterFormaters & KnownStatsPrinterContext} StatsPrinterContext */
 /** @typedef {any} PrintObject */
 
 /**
  * @typedef {object} StatsPrintHooks
  * @property {HookMap<SyncBailHook<[string[], StatsPrinterContext], void>>} sortElements
- * @property {HookMap<SyncBailHook<[PrintedElement[], StatsPrinterContext], string | undefined>>} printElements
- * @property {HookMap<SyncBailHook<[PrintObject[], StatsPrinterContext], true>>} sortItems
- * @property {HookMap<SyncBailHook<[PrintObject, StatsPrinterContext], string>>} getItemName
- * @property {HookMap<SyncBailHook<[string[], StatsPrinterContext], string | undefined>>} printItems
+ * @property {HookMap<SyncBailHook<[PrintedElement[], StatsPrinterContext], string | void>>} printElements
+ * @property {HookMap<SyncBailHook<[PrintObject[], StatsPrinterContext], boolean | void>>} sortItems
+ * @property {HookMap<SyncBailHook<[PrintObject, StatsPrinterContext], string | void>>} getItemName
+ * @property {HookMap<SyncBailHook<[string[], StatsPrinterContext], string | void>>} printItems
  * @property {HookMap<SyncBailHook<[PrintObject, StatsPrinterContext], string | void>>} print
  * @property {HookMap<SyncWaterfallHook<[string, StatsPrinterContext]>>} result
  */
@@ -147,8 +147,8 @@ class StatsPrinter {
 	 * @template {H extends import("tapable").Hook<any, infer R> ? R : never} R
 	 * @param {HM} hookMap hook map
 	 * @param {string} type type
-	 * @param {function(H): R | undefined} fn fn
-	 * @returns {R | undefined} hook
+	 * @param {function(H): R | void} fn fn
+	 * @returns {R | void} hook
 	 */
 	_forEachLevel(hookMap, type, fn) {
 		for (const hook of this._getAllLevelHooks(hookMap, type)) {

package/lib/util/AsyncQueue.js

@@ -68,12 +68,14 @@ class AsyncQueue {
 	 * @param {object} options options object
 	 * @param {string=} options.name name of the queue
 	 * @param {number=} options.parallelism how many items should be processed at once
+	 * @param {string=} options.context context of execution
 	 * @param {AsyncQueue<any, any, any>=} options.parent parent queue, which will have priority over this queue and with shared parallelism
 	 * @param {getKey<T, K>=} options.getKey extract key from item
 	 * @param {Processor<T, R>} options.processor async function to process items
 	 */
-	constructor({ name, parallelism, parent, processor, getKey }) {
+	constructor({ name, context, parallelism, parent, processor, getKey }) {
 		this._name = name;
+		this._context = context || "normal";
 		this._parallelism = parallelism || 1;
 		this._processor = processor;
 		this._getKey =
@@ -115,6 +117,20 @@ class AsyncQueue {
 		this._ensureProcessing = this._ensureProcessing.bind(this);
 	}
 
+	/**
+	 * @returns {string} context of execution
+	 */
+	getContext() {
+		return this._context;
+	}
+
+	/**
+	 * @param {string} value context of execution
+	 */
+	setContext(value) {
+		this._context = value;
+	}
+
 	/**
 	 * @param {T} item an item
 	 * @param {Callback<R>} callback callback function

package/lib/util/IterableHelpers.js

@@ -19,7 +19,7 @@ const last = set => {
 /**
  * @template T
  * @param {Iterable<T>} iterable iterable
- * @param {function(T): boolean} filter predicate
+ * @param {function(T): boolean | null | undefined} filter predicate
  * @returns {boolean} true, if some items match the filter predicate
  */
 const someInIterable = (iterable, filter) => {