webpack 5.85.0 → 5.88.1

package/lib/util/createHash.js

@@ -11,11 +11,14 @@ const BULK_SIZE = 2000;
 
 // We are using an object instead of a Map as this will stay static during the runtime
 // so access to it can be optimized by v8
+/** @type {Object<string, Map<string, string>>} */
 const digestCaches = {};
 
+/** @typedef {function(): Hash} HashFactory */
+
 class BulkUpdateDecorator extends Hash {
 	/**
-	 * @param {Hash | function(): Hash} hashOrFactory function to create a hash
+	 * @param {Hash | HashFactory} hashOrFactory function to create a hash
 	 * @param {string=} hashKey key for caching
 	 */
 	constructor(hashOrFactory, hashKey) {
@@ -43,7 +46,8 @@ class BulkUpdateDecorator extends Hash {
 			typeof data !== "string" ||
 			data.length > BULK_SIZE
 		) {
-			if (this.hash === undefined) this.hash = this.hashFactory();
+			if (this.hash === undefined)
+				this.hash = /** @type {HashFactory} */ (this.hashFactory)();
 			if (this.buffer.length > 0) {
 				this.hash.update(this.buffer);
 				this.buffer = "";
@@ -52,7 +56,8 @@ class BulkUpdateDecorator extends Hash {
 		} else {
 			this.buffer += data;
 			if (this.buffer.length > BULK_SIZE) {
-				if (this.hash === undefined) this.hash = this.hashFactory();
+				if (this.hash === undefined)
+					this.hash = /** @type {HashFactory} */ (this.hashFactory)();
 				this.hash.update(this.buffer);
 				this.buffer = "";
 			}
@@ -77,7 +82,7 @@ class BulkUpdateDecorator extends Hash {
 			}
 			const cacheEntry = digestCache.get(buffer);
 			if (cacheEntry !== undefined) return cacheEntry;
-			this.hash = this.hashFactory();
+			this.hash = /** @type {HashFactory} */ (this.hashFactory)();
 		}
 		if (buffer.length > 0) {
 			this.hash.update(buffer);
@@ -111,7 +116,9 @@ class DebugHash extends Hash {
 		if (data.startsWith(prefix)) {
 			data = Buffer.from(data.slice(prefix.length), "hex").toString();
 		}
-		this.string += `[${data}](${new Error().stack.split("\n", 3)[2]})\n`;
+		this.string += `[${data}](${
+			/** @type {string} */ (new Error().stack).split("\n", 3)[2]
+		})\n`;
 		return this;
 	}
 
@@ -125,9 +132,13 @@ class DebugHash extends Hash {
 	}
 }
 
+/** @type {typeof import("crypto") | undefined} */
 let crypto = undefined;
+/** @type {typeof import("./hash/xxhash64") | undefined} */
 let createXXHash64 = undefined;
+/** @type {typeof import("./hash/md4") | undefined} */
 let createMd4 = undefined;
+/** @type {typeof import("./hash/BatchedHash") | undefined} */
 let BatchedHash = undefined;
 
 /**
@@ -150,7 +161,9 @@ module.exports = algorithm => {
 					BatchedHash = require("./hash/BatchedHash");
 				}
 			}
-			return new BatchedHash(createXXHash64());
+			return new /** @type {typeof import("./hash/BatchedHash")} */ (
+				BatchedHash
+			)(createXXHash64());
 		case "md4":
 			if (createMd4 === undefined) {
 				createMd4 = require("./hash/md4");
@@ -158,14 +171,22 @@ module.exports = algorithm => {
 					BatchedHash = require("./hash/BatchedHash");
 				}
 			}
-			return new BatchedHash(createMd4());
+			return new /** @type {typeof import("./hash/BatchedHash")} */ (
+				BatchedHash
+			)(createMd4());
 		case "native-md4":
 			if (crypto === undefined) crypto = require("crypto");
-			return new BulkUpdateDecorator(() => crypto.createHash("md4"), "md4");
+			return new BulkUpdateDecorator(
+				() => /** @type {typeof import("crypto")} */ (crypto).createHash("md4"),
+				"md4"
+			);
 		default:
 			if (crypto === undefined) crypto = require("crypto");
 			return new BulkUpdateDecorator(
-				() => crypto.createHash(algorithm),
+				() =>
+					/** @type {typeof import("crypto")} */ (crypto).createHash(
+						/** @type {string} */ (algorithm)
+					),
 				algorithm
 			);
 	}

package/lib/util/deprecation.js

@@ -78,7 +78,7 @@ exports.arrayToSetDeprecation = (set, name) => {
 		);
 		/**
 		 * @deprecated
-		 * @this {Set}
+		 * @this {Set<any>}
 		 * @returns {number} count
 		 */
 		set[method] = function () {
@@ -101,7 +101,7 @@ exports.arrayToSetDeprecation = (set, name) => {
 	);
 	/**
 	 * @deprecated
-	 * @this {Set}
+	 * @this {Set<any>}
 	 * @returns {number} count
 	 */
 	set.push = function () {
@@ -119,9 +119,13 @@ exports.arrayToSetDeprecation = (set, name) => {
 			);
 		};
 	}
+	/**
+	 * @param {number} index index
+	 * @returns {any} value
+	 */
 	const createIndexGetter = index => {
 		/**
-		 * @this {Set} a Set
+		 * @this {Set<any>} a Set
 		 * @returns {any} the value at this location
 		 */
 		const fn = function () {
@@ -134,6 +138,9 @@ exports.arrayToSetDeprecation = (set, name) => {
 		};
 		return fn;
 	};
+	/**
+	 * @param {number} index index
+	 */
 	const defineIndexGetter = index => {
 		Object.defineProperty(set, index, {
 			get: createIndexGetter(index),

package/lib/util/deterministicGrouping.js

@@ -94,7 +94,8 @@ const subtractSizeFrom = (total, size) => {
 };
 
 /**
- * @param {Iterable<Node>} nodes some nodes
+ * @template T
+ * @param {Iterable<Node<T>>} nodes some nodes
  * @returns {Record<string, number>} total size
  */
 const sumSize = nodes => {
@@ -105,6 +106,11 @@ const sumSize = nodes => {
 	return sum;
 };
 
+/**
+ * @param {Record<string, number>} size size
+ * @param {Record<string, number>} maxSize minimum size
+ * @returns {boolean} true, when size is too big
+ */
 const isTooBig = (size, maxSize) => {
 	for (const key of Object.keys(size)) {
 		const s = size[key];
@@ -117,6 +123,11 @@ const isTooBig = (size, maxSize) => {
 	return false;
 };
 
+/**
+ * @param {Record<string, number>} size size
+ * @param {Record<string, number>} minSize minimum size
+ * @returns {boolean} true, when size is too small
+ */
 const isTooSmall = (size, minSize) => {
 	for (const key of Object.keys(size)) {
 		const s = size[key];
@@ -129,6 +140,11 @@ const isTooSmall = (size, minSize) => {
 	return false;
 };
 
+/**
+ * @param {Record<string, number>} size size
+ * @param {Record<string, number>} minSize minimum size
+ * @returns {Set<string>} set of types that are too small
+ */
 const getTooSmallTypes = (size, minSize) => {
 	const types = new Set();
 	for (const key of Object.keys(size)) {
@@ -142,6 +158,12 @@ const getTooSmallTypes = (size, minSize) => {
 	return types;
 };
 
+/**
+ * @template T
+ * @param {TODO} size size
+ * @param {Set<string>} types types
+ * @returns {number} number of matching size types
+ */
 const getNumberOfMatchingSizeTypes = (size, types) => {
 	let i = 0;
 	for (const key of Object.keys(size)) {
@@ -150,6 +172,11 @@ const getNumberOfMatchingSizeTypes = (size, types) => {
 	return i;
 };
 
+/**
+ * @param {Record<string, number>} size size
+ * @param {Set<string>} types types
+ * @returns {number} selective size sum
+ */
 const selectiveSizeSum = (size, types) => {
 	let sum = 0;
 	for (const key of Object.keys(size)) {
@@ -180,20 +207,20 @@ class Node {
 class Group {
 	/**
 	 * @param {Node<T>[]} nodes nodes
-	 * @param {number[]} similarities similarities between the nodes (length = nodes.length - 1)
+	 * @param {number[] | null} similarities similarities between the nodes (length = nodes.length - 1)
 	 * @param {Record<string, number>=} size size of the group
 	 */
 	constructor(nodes, similarities, size) {
 		this.nodes = nodes;
 		this.similarities = similarities;
 		this.size = size || sumSize(nodes);
-		/** @type {string} */
+		/** @type {string | undefined} */
 		this.key = undefined;
 	}
 
 	/**
-	 * @param {function(Node): boolean} filter filter function
-	 * @returns {Node[]} removed nodes
+	 * @param {function(Node<T>): boolean} filter filter function
+	 * @returns {Node<T>[] | undefined} removed nodes
 	 */
 	popNodes(filter) {
 		const newNodes = [];
@@ -208,7 +235,7 @@ class Group {
 				if (newNodes.length > 0) {
 					newSimilarities.push(
 						lastNode === this.nodes[i - 1]
-							? this.similarities[i - 1]
+							? /** @type {number[]} */ (this.similarities)[i - 1]
 							: similarity(lastNode.key, node.key)
 					);
 				}
@@ -225,7 +252,8 @@ class Group {
 }
 
 /**
- * @param {Iterable<Node>} nodes nodes
+ * @template T
+ * @param {Iterable<Node<T>>} nodes nodes
  * @returns {number[]} similarities
  */
 const getSimilarities = nodes => {
@@ -297,6 +325,11 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 	if (initialNodes.length > 0) {
 		const initialGroup = new Group(initialNodes, getSimilarities(initialNodes));
 
+		/**
+		 * @param {Group<T>} group group
+		 * @param {Record<string, number>} consideredSize size of the group to consider
+		 * @returns {boolean} true, if the group was modified
+		 */
 		const removeProblematicNodes = (group, consideredSize = group.size) => {
 			const problemTypes = getTooSmallTypes(consideredSize, minSize);
 			if (problemTypes.size > 0) {
@@ -347,7 +380,7 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 			const queue = [initialGroup];
 
 			while (queue.length) {
-				const group = queue.pop();
+				const group = /** @type {Group<T>} */ (queue.pop());
 				// only groups bigger than maxSize need to be splitted
 				if (!isTooBig(group.size, maxSize)) {
 					result.push(group);
@@ -428,7 +461,9 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 					// rightSize ^^^^^^^^^^^^^^^
 
 					while (pos <= right + 1) {
-						const similarity = group.similarities[pos - 1];
+						const similarity = /** @type {number[]} */ (group.similarities)[
+							pos - 1
+						];
 						if (
 							similarity < bestSimilarity &&
 							!isTooSmall(leftSize, minSize) &&
@@ -458,7 +493,9 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 				/** @type {number[]} */
 				const rightSimilarities = [];
 				for (let i = right + 2; i < group.nodes.length; i++) {
-					rightSimilarities.push(group.similarities[i - 1]);
+					rightSimilarities.push(
+						/** @type {number[]} */ (group.similarities)[i - 1]
+					);
 					rightNodes.push(group.nodes[i]);
 				}
 				queue.push(new Group(rightNodes, rightSimilarities));
@@ -467,7 +504,9 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 				/** @type {number[]} */
 				const leftSimilarities = [];
 				for (let i = 1; i < left; i++) {
-					leftSimilarities.push(group.similarities[i - 1]);
+					leftSimilarities.push(
+						/** @type {number[]} */ (group.similarities)[i - 1]
+					);
 					leftNodes.push(group.nodes[i]);
 				}
 				queue.push(new Group(leftNodes, leftSimilarities));

package/lib/util/findGraphRoots.js

@@ -109,7 +109,9 @@ module.exports = (items, getDependencies) => {
 				// Are there still edges unprocessed in the current node?
 				if (topOfStack.openEdges.length > 0) {
 					// Process one dependency
-					const dependency = topOfStack.openEdges.pop();
+					const dependency =
+						/** @type {Node<T>} */
+						(topOfStack.openEdges.pop());
 					switch (dependency.marker) {
 						case NO_MARKER:
 							// dependency has not be visited yet
@@ -169,7 +171,7 @@ module.exports = (items, getDependencies) => {
 							// so it's not really a root cycle
 							// remove the cycle from the root cycles
 							// and convert it to a normal node
-							rootCycles.delete(dependency.cycle);
+							rootCycles.delete(/** @type {Cycle<T>} */ (dependency.cycle));
 							dependency.marker = DONE_MARKER;
 							break;
 						// DONE_MARKER: nothing to do, don't recurse into dependencies

package/lib/util/memoize.js

@@ -13,18 +13,18 @@
  */
 const memoize = fn => {
 	let cache = false;
-	/** @type {T} */
+	/** @type {T | undefined} */
 	let result = undefined;
 	return () => {
 		if (cache) {
-			return result;
+			return /** @type {T} */ (result);
 		} else {
 			result = fn();
 			cache = true;
 			// Allow to clean up memory for fn
 			// and all dependent resources
 			fn = undefined;
-			return result;
+			return /** @type {T} */ (result);
 		}
 	};
 };

package/lib/util/processAsyncTree.js

@@ -21,6 +21,9 @@ const processAsyncTree = (items, concurrency, processor, callback) => {
 	let finished = false;
 	let processScheduled = true;
 
+	/**
+	 * @param {T} item item
+	 */
 	const push = item => {
 		queue.push(item);
 		if (!processScheduled && processing < concurrency) {
@@ -29,6 +32,9 @@ const processAsyncTree = (items, concurrency, processor, callback) => {
 		}
 	};
 
+	/**
+	 * @param {E | null | undefined} err error
+	 */
 	const processorCallback = err => {
 		processing--;
 		if (err && !finished) {
@@ -46,7 +52,7 @@ const processAsyncTree = (items, concurrency, processor, callback) => {
 		if (finished) return;
 		while (processing < concurrency && queue.length > 0) {
 			processing++;
-			const item = queue.pop();
+			const item = /** @type {T} */ (queue.pop());
 			processor(item, push, processorCallback);
 		}
 		processScheduled = false;

package/lib/util/registerExternalSerializer.js

@@ -26,7 +26,7 @@ const {
 /** @typedef {import("./serialization").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("./serialization").ObjectSerializerContext} ObjectSerializerContext */
 
-/** @typedef {ObjectSerializerContext & { writeLazy?: (any) => void }} WebpackObjectSerializerContext */
+/** @typedef {ObjectSerializerContext & { writeLazy?: (value: any) => void }} WebpackObjectSerializerContext */
 
 const CURRENT_MODULE = "webpack/lib/util/registerExternalSerializer";
 

package/lib/util/runtime.js

@@ -53,7 +53,7 @@ exports.getEntryRuntime = (compilation, name, options) => {
 
 /**
  * @param {RuntimeSpec} runtime runtime
- * @param {function(string): void} fn functor
+ * @param {function(string | undefined): void} fn functor
  * @param {boolean} deterministicOrder enforce a deterministic order
  * @returns {void}
  */
@@ -70,6 +70,11 @@ exports.forEachRuntime = (runtime, fn, deterministicOrder = false) => {
 	}
 };
 
+/**
+ * @template T
+ * @param {SortableSet<T>} set set
+ * @returns {string} runtime key
+ */
 const getRuntimesKey = set => {
 	set.sort();
 	return Array.from(set).join("\n");
@@ -98,6 +103,11 @@ const keyToRuntime = key => {
 };
 exports.keyToRuntime = keyToRuntime;
 
+/**
+ * @template T
+ * @param {SortableSet<T>} set set
+ * @returns {string} runtime string
+ */
 const getRuntimesString = set => {
 	set.sort();
 	return Array.from(set).join("+");
@@ -415,6 +425,11 @@ exports.filterRuntime = (runtime, filter) => {
 	return result;
 };
 
+/**
+ * @template T
+ * @typedef {Map<string, T>} RuntimeSpecMapInnerMap
+ * */
+
 /**
  * @template T
  */
@@ -426,15 +441,15 @@ class RuntimeSpecMap {
 		this._mode = clone ? clone._mode : 0; // 0 = empty, 1 = single entry, 2 = map
 		/** @type {RuntimeSpec} */
 		this._singleRuntime = clone ? clone._singleRuntime : undefined;
-		/** @type {T} */
+		/** @type {T | undefined} */
 		this._singleValue = clone ? clone._singleValue : undefined;
-		/** @type {Map<string, T> | undefined} */
+		/** @type {RuntimeSpecMapInnerMap<T> | undefined} */
 		this._map = clone && clone._map ? new Map(clone._map) : undefined;
 	}
 
 	/**
 	 * @param {RuntimeSpec} runtime the runtimes
-	 * @returns {T} value
+	 * @returns {T | undefined} value
 	 */
 	get(runtime) {
 		switch (this._mode) {
@@ -445,7 +460,9 @@ class RuntimeSpecMap {
 					? this._singleValue
 					: undefined;
 			default:
-				return this._map.get(getRuntimeKey(runtime));
+				return /** @type {RuntimeSpecMapInnerMap<T>} */ (this._map).get(
+					getRuntimeKey(runtime)
+				);
 		}
 	}
 
@@ -460,10 +477,16 @@ class RuntimeSpecMap {
 			case 1:
 				return runtimeEqual(this._singleRuntime, runtime);
 			default:
-				return this._map.has(getRuntimeKey(runtime));
+				return /** @type {RuntimeSpecMapInnerMap<T>} */ (this._map).has(
+					getRuntimeKey(runtime)
+				);
 		}
 	}
 
+	/**
+	 * @param {RuntimeSpec} runtime the runtimes
+	 * @param {T} value the value
+	 */
 	set(runtime, value) {
 		switch (this._mode) {
 			case 0:
@@ -478,15 +501,24 @@ class RuntimeSpecMap {
 				}
 				this._mode = 2;
 				this._map = new Map();
-				this._map.set(getRuntimeKey(this._singleRuntime), this._singleValue);
+				this._map.set(
+					getRuntimeKey(this._singleRuntime),
+					/** @type {T} */ (this._singleValue)
+				);
 				this._singleRuntime = undefined;
 				this._singleValue = undefined;
 			/* falls through */
 			default:
-				this._map.set(getRuntimeKey(runtime), value);
+				/** @type {RuntimeSpecMapInnerMap<T>} */
+				(this._map).set(getRuntimeKey(runtime), value);
 		}
 	}
 
+	/**
+	 * @param {RuntimeSpec} runtime the runtimes
+	 * @param {() => TODO} computer function to compute the value
+	 * @returns {TODO} true, when the runtime was deleted
+	 */
 	provide(runtime, computer) {
 		switch (this._mode) {
 			case 0:
@@ -495,11 +527,14 @@ class RuntimeSpecMap {
 				return (this._singleValue = computer());
 			case 1: {
 				if (runtimeEqual(this._singleRuntime, runtime)) {
-					return this._singleValue;
+					return /** @type {T} */ (this._singleValue);
 				}
 				this._mode = 2;
 				this._map = new Map();
-				this._map.set(getRuntimeKey(this._singleRuntime), this._singleValue);
+				this._map.set(
+					getRuntimeKey(this._singleRuntime),
+					/** @type {T} */ (this._singleValue)
+				);
 				this._singleRuntime = undefined;
 				this._singleValue = undefined;
 				const newValue = computer();
@@ -508,15 +543,19 @@ class RuntimeSpecMap {
 			}
 			default: {
 				const key = getRuntimeKey(runtime);
-				const value = this._map.get(key);
+				const value = /** @type {Map<string, T>} */ (this._map).get(key);
 				if (value !== undefined) return value;
 				const newValue = computer();
-				this._map.set(key, newValue);
+				/** @type {Map<string, T>} */
+				(this._map).set(key, newValue);
 				return newValue;
 			}
 		}
 	}
 
+	/**
+	 * @param {RuntimeSpec} runtime the runtimes
+	 */
 	delete(runtime) {
 		switch (this._mode) {
 			case 0:
@@ -529,10 +568,15 @@ class RuntimeSpecMap {
 				}
 				return;
 			default:
-				this._map.delete(getRuntimeKey(runtime));
+				/** @type {RuntimeSpecMapInnerMap<T>} */
+				(this._map).delete(getRuntimeKey(runtime));
 		}
 	}
 
+	/**
+	 * @param {RuntimeSpec} runtime the runtimes
+	 * @param {function(T | undefined): T} fn function to update the value
+	 */
 	update(runtime, fn) {
 		switch (this._mode) {
 			case 0:
@@ -546,7 +590,10 @@ class RuntimeSpecMap {
 				if (newValue !== undefined) {
 					this._mode = 2;
 					this._map = new Map();
-					this._map.set(getRuntimeKey(this._singleRuntime), this._singleValue);
+					this._map.set(
+						getRuntimeKey(this._singleRuntime),
+						/** @type {T} */ (this._singleValue)
+					);
 					this._singleRuntime = undefined;
 					this._singleValue = undefined;
 					this._map.set(getRuntimeKey(runtime), newValue);
@@ -555,9 +602,11 @@ class RuntimeSpecMap {
 			}
 			default: {
 				const key = getRuntimeKey(runtime);
-				const oldValue = this._map.get(key);
+				const oldValue = /** @type {Map<string, T>} */ (this._map).get(key);
 				const newValue = fn(oldValue);
-				if (newValue !== oldValue) this._map.set(key, newValue);
+				if (newValue !== oldValue)
+					/** @type {RuntimeSpecMapInnerMap<T>} */
+					(this._map).set(key, newValue);
 			}
 		}
 	}
@@ -569,7 +618,11 @@ class RuntimeSpecMap {
 			case 1:
 				return [this._singleRuntime];
 			default:
-				return Array.from(this._map.keys(), keyToRuntime);
+				return Array.from(
+					/** @type {RuntimeSpecMapInnerMap<T>} */
+					(this._map).keys(),
+					keyToRuntime
+				);
 		}
 	}
 
@@ -578,21 +631,24 @@ class RuntimeSpecMap {
 			case 0:
 				return [][Symbol.iterator]();
 			case 1:
-				return [this._singleValue][Symbol.iterator]();
+				return [/** @type {T} */ (this._singleValue)][Symbol.iterator]();
 			default:
-				return this._map.values();
+				return /** @type {Map<string, T>} */ (this._map).values();
 		}
 	}
 
 	get size() {
-		if (this._mode <= 1) return this._mode;
-		return this._map.size;
+		if (/** @type {number} */ (this._mode) <= 1) return this._mode;
+		return /** @type {Map<string, T>} */ (this._map).size;
 	}
 }
 
 exports.RuntimeSpecMap = RuntimeSpecMap;
 
 class RuntimeSpecSet {
+	/**
+	 * @param {Iterable<RuntimeSpec>=} iterable iterable
+	 */
 	constructor(iterable) {
 		/** @type {Map<string, RuntimeSpec>} */
 		this._map = new Map();
@@ -603,10 +659,17 @@ class RuntimeSpecSet {
 		}
 	}
 
+	/**
+	 * @param {RuntimeSpec} runtime runtime
+	 */
 	add(runtime) {
 		this._map.set(getRuntimeKey(runtime), runtime);
 	}
 
+	/**
+	 * @param {RuntimeSpec} runtime runtime
+	 * @returns {boolean} true, when the runtime exists
+	 */
 	has(runtime) {
 		return this._map.has(getRuntimeKey(runtime));
 	}

package/lib/util/semver.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {(string|number|undefined|[])[]} SemVerRange */
 
 /**

package/lib/util/smartGrouping.js

@@ -110,7 +110,7 @@ const smartGrouping = (items, groupConfigs) => {
 		/** @type {(T | R)[]} */
 		const results = [];
 		for (;;) {
-			/** @type {Group<T, R>} */
+			/** @type {Group<T, R> | undefined} */
 			let bestGroup = undefined;
 			let bestGroupSize = -1;
 			let bestGroupItems = undefined;

package/lib/validateSchema.js

@@ -119,7 +119,9 @@ const validateSchema = (schema, options, validationConfiguration) => {
 						)
 					) {
 						return `${formattedError}\nDid you mean ${
-							DID_YOU_MEAN[params.additionalProperty]
+							DID_YOU_MEAN[
+								/** @type {keyof DID_YOU_MEAN} */ (params.additionalProperty)
+							]
 						}?`;
 					}
 
@@ -129,7 +131,9 @@ const validateSchema = (schema, options, validationConfiguration) => {
 							params.additionalProperty
 						)
 					) {
-						return `${formattedError}\n${REMOVED[params.additionalProperty]}?`;
+						return `${formattedError}\n${
+							REMOVED[/** @type {keyof REMOVED} */ (params.additionalProperty)]
+						}?`;
 					}
 
 					if (!error.dataPath) {