webpack 5.86.0 → 5.87.0

package/lib/runtime/PublicPathRuntimeModule.js

@@ -8,6 +8,7 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 
 /** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputOptions */
+/** @typedef {import("../Compilation")} Compilation */
 
 class PublicPathRuntimeModule extends RuntimeModule {
 	/**
@@ -22,7 +23,8 @@ class PublicPathRuntimeModule extends RuntimeModule {
 	 * @returns {string} runtime code
 	 */
 	generate() {
-		const { compilation, publicPath } = this;
+		const { publicPath } = this;
+		const compilation = /** @type {Compilation} */ (this.compilation);
 
 		return `${RuntimeGlobals.publicPath} = ${JSON.stringify(
 			compilation.getPath(publicPath || "", {

package/lib/runtime/RelativeUrlRuntimeModule.js

@@ -8,6 +8,8 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const HelperRuntimeModule = require("./HelperRuntimeModule");
 
+/** @typedef {import("../Compilation")} Compilation */
+
 class RelativeUrlRuntimeModule extends HelperRuntimeModule {
 	constructor() {
 		super("relative url");
@@ -17,7 +19,8 @@ class RelativeUrlRuntimeModule extends HelperRuntimeModule {
 	 * @returns {string} runtime code
 	 */
 	generate() {
-		const { runtimeTemplate } = this.compilation;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
 		return Template.asString([
 			`${RuntimeGlobals.relativeUrl} = function RelativeURL(url) {`,
 			Template.indent([

package/lib/runtime/RuntimeIdRuntimeModule.js

@@ -7,6 +7,9 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+
 class RuntimeIdRuntimeModule extends RuntimeModule {
 	constructor() {
 		super("runtimeId");
@@ -16,7 +19,8 @@ class RuntimeIdRuntimeModule extends RuntimeModule {
 	 * @returns {string} runtime code
 	 */
 	generate() {
-		const { chunkGraph, chunk } = this;
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
+		const chunk = /** @type {Chunk} */ (this.chunk);
 		const runtime = chunk.runtime;
 		if (typeof runtime !== "string")
 			throw new Error("RuntimeIdRuntimeModule must be in a single runtime");

package/lib/runtime/StartupChunkDependenciesRuntimeModule.js

@@ -9,6 +9,10 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Compilation")} Compilation */
+
 class StartupChunkDependenciesRuntimeModule extends RuntimeModule {
 	/**
 	 * @param {boolean} asyncChunkLoading use async chunk loading
@@ -22,13 +26,15 @@ class StartupChunkDependenciesRuntimeModule extends RuntimeModule {
 	 * @returns {string} runtime code
 	 */
 	generate() {
-		const { chunkGraph, chunk, compilation } = this;
-		const { runtimeTemplate } = compilation;
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
+		const chunk = /** @type {Chunk} */ (this.chunk);
 		const chunkIds = Array.from(
 			chunkGraph.getChunkEntryDependentChunksIterable(chunk)
 		).map(chunk => {
 			return chunk.id;
 		});
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
 		return Template.asString([
 			`var next = ${RuntimeGlobals.startup};`,
 			`${RuntimeGlobals.startup} = ${runtimeTemplate.basicFunction(

package/lib/runtime/StartupEntrypointRuntimeModule.js

@@ -7,6 +7,7 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 
+/** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../MainTemplate")} MainTemplate */
 
 class StartupEntrypointRuntimeModule extends RuntimeModule {
@@ -22,7 +23,7 @@ class StartupEntrypointRuntimeModule extends RuntimeModule {
 	 * @returns {string} runtime code
 	 */
 	generate() {
-		const { compilation } = this;
+		const compilation = /** @type {Compilation} */ (this.compilation);
 		const { runtimeTemplate } = compilation;
 		return `${
 			RuntimeGlobals.startupEntrypoint

package/lib/serialization/ObjectMiddleware.js

@@ -107,7 +107,7 @@ const ESCAPE_UNDEFINED = false;
 
 const CURRENT_VERSION = 2;
 
-/** @type {Map<Constructor, { request?: string, name?: string | number , serializer?: ObjectSerializer }>} */
+/** @type {Map<Constructor, { request?: string, name?: string | number | null, serializer?: ObjectSerializer }>} */
 const serializers = new Map();
 /** @type {Map<string | number, ObjectSerializer>} */
 const serializerInversed = new Map();
@@ -158,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>} */
@@ -191,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}
 	 */

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/ConsumeSharedRuntimeModule.js

@@ -17,10 +17,15 @@ 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;
@@ -30,11 +35,13 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
 	 * @returns {string} 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"
@@ -166,7 +175,7 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
 				]
 			)};`,
 			`var warn = ${
-				this.compilation.options.output.ignoreBrowserWarnings
+				compilation.outputOptions.ignoreBrowserWarnings
 					? runtimeTemplate.basicFunction("", "")
 					: runtimeTemplate.basicFunction("msg", [
 							'if (typeof console !== "undefined" && console.warn) console.warn(msg);'

package/lib/sharing/ProvideSharedDependency.js

@@ -12,6 +12,13 @@ const makeSerializable = require("../util/makeSerializable");
 /** @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;
@@ -46,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

@@ -174,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/ProvideSharedPlugin.js

@@ -42,27 +42,28 @@ class ProvideSharedPlugin {
 	constructor(options) {
 		validate(options);
 
-		/** @type {[string, ProvideOptions][]} */
-		this._provides = parseOptions(
-			options.provides,
-			item => {
-				if (Array.isArray(item))
-					throw new Error("Unexpected array of provides");
-				/** @type {ProvideOptions} */
-				const result = {
-					shareKey: item,
-					version: undefined,
-					shareScope: options.shareScope || "default",
-					eager: false
-				};
-				return result;
-			},
-			item => ({
-				shareKey: item.shareKey,
-				version: item.version,
-				shareScope: item.shareScope || options.shareScope || "default",
-				eager: !!item.eager
-			})
+		this._provides = /** @type {[string, ProvideOptions][]} */ (
+			parseOptions(
+				options.provides,
+				item => {
+					if (Array.isArray(item))
+						throw new Error("Unexpected array of provides");
+					/** @type {ProvideOptions} */
+					const result = {
+						shareKey: item,
+						version: undefined,
+						shareScope: options.shareScope || "default",
+						eager: false
+					};
+					return result;
+				},
+				item => ({
+					shareKey: item.shareKey,
+					version: item.version,
+					shareScope: item.shareScope || options.shareScope || "default",
+					eager: !!item.eager
+				})
+			)
 		);
 		this._provides.sort(([a], [b]) => {
 			if (a < b) return -1;

package/lib/sharing/ShareRuntimeModule.js

@@ -13,6 +13,10 @@ const {
 	compareStrings
 } = require("../util/comparators");
 
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Compilation")} Compilation */
+
 class ShareRuntimeModule extends RuntimeModule {
 	constructor() {
 		super("sharing");
@@ -22,15 +26,18 @@ class ShareRuntimeModule extends RuntimeModule {
 	 * @returns {string} runtime code
 	 */
 	generate() {
-		const { compilation, chunkGraph } = this;
+		const compilation = /** @type {Compilation} */ (this.compilation);
 		const {
 			runtimeTemplate,
 			codeGenerationResults,
-			outputOptions: { uniqueName }
+			outputOptions: { uniqueName, ignoreBrowserWarnings }
 		} = compilation;
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
 		/** @type {Map<string, Map<number, Set<string>>>} */
 		const initCodePerScope = new Map();
-		for (const chunk of this.chunk.getAllReferencedChunks()) {
+		for (const chunk of /** @type {Chunk} */ (
+			this.chunk
+		).getAllReferencedChunks()) {
 			const modules = chunkGraph.getOrderedChunkModulesIterableBySourceType(
 				chunk,
 				"share-init",
@@ -78,7 +85,7 @@ class ShareRuntimeModule extends RuntimeModule {
 					"// runs all init snippets from all modules reachable",
 					`var scope = ${RuntimeGlobals.shareScopeMap}[name];`,
 					`var warn = ${
-						this.compilation.options.output.ignoreBrowserWarnings
+						ignoreBrowserWarnings
 							? runtimeTemplate.basicFunction("", "")
 							: runtimeTemplate.basicFunction("msg", [
 									'if (typeof console !== "undefined" && console.warn) console.warn(msg);'

package/lib/sharing/resolveMatchedConfigs.js

@@ -66,7 +66,7 @@ exports.resolveMatchedConfigs = (compilation, configs) => {
 								);
 								return resolve();
 							}
-							resolved.set(result, config);
+							resolved.set(/** @type {string} */ (result), config);
 							resolve();
 						}
 					);

package/lib/sharing/utils.js

@@ -52,6 +52,11 @@ const DEF_GIT_PROTOCOL = "git+ssh://";
 
 // thanks to https://github.com/npm/hosted-git-info/blob/latest/git-host-info.js
 const extractCommithashByDomain = {
+	/**
+	 * @param {string} pathname pathname
+	 * @param {string} hash hash
+	 * @returns {string | undefined} hash
+	 */
 	"github.com": (pathname, hash) => {
 		let [, user, project, type, commithash] = pathname.split("/", 5);
 		if (type && type !== "tree") {
@@ -74,6 +79,11 @@ const extractCommithashByDomain = {
 
 		return commithash;
 	},
+	/**
+	 * @param {string} pathname pathname
+	 * @param {string} hash hash
+	 * @returns {string | undefined} hash
+	 */
 	"gitlab.com": (pathname, hash) => {
 		const path = pathname.slice(1);
 		if (path.includes("/-/") || path.includes("/archive.tar.gz")) {
@@ -81,7 +91,7 @@ const extractCommithashByDomain = {
 		}
 
 		const segments = path.split("/");
-		let project = segments.pop();
+		let project = /** @type {string} */ (segments.pop());
 		if (project.endsWith(".git")) {
 			project = project.slice(0, -4);
 		}
@@ -93,6 +103,11 @@ const extractCommithashByDomain = {
 
 		return hash;
 	},
+	/**
+	 * @param {string} pathname pathname
+	 * @param {string} hash hash
+	 * @returns {string | undefined} hash
+	 */
 	"bitbucket.org": (pathname, hash) => {
 		let [, user, project, aux] = pathname.split("/", 4);
 		if (["get"].includes(aux)) {
@@ -109,6 +124,11 @@ const extractCommithashByDomain = {
 
 		return hash;
 	},
+	/**
+	 * @param {string} pathname pathname
+	 * @param {string} hash hash
+	 * @returns {string | undefined} hash
+	 */
 	"gist.github.com": (pathname, hash) => {
 		let [, user, project, aux] = pathname.split("/", 4);
 		if (aux === "raw") {
@@ -121,7 +141,6 @@ const extractCommithashByDomain = {
 			}
 
 			project = user;
-			user = null;
 		}
 
 		if (project.endsWith(".git")) {
@@ -136,7 +155,7 @@ const extractCommithashByDomain = {
  * extract commit hash from parsed url
  *
  * @inner
- * @param {Object} urlParsed parsed url
+ * @param {URL} urlParsed parsed url
  * @returns {string} commithash
  */
 function getCommithash(urlParsed) {
@@ -148,8 +167,16 @@ function getCommithash(urlParsed) {
 		// eslint-disable-next-line no-empty
 	} catch (e) {}
 
-	if (extractCommithashByDomain[hostname]) {
-		return extractCommithashByDomain[hostname](pathname, hash) || "";
+	if (
+		extractCommithashByDomain[
+			/** @type {keyof extractCommithashByDomain} */ (hostname)
+		]
+	) {
+		return (
+			extractCommithashByDomain[
+				/** @type {keyof extractCommithashByDomain} */ (hostname)
+			](pathname, hash) || ""
+		);
 	}
 
 	return hash;

package/lib/util/AsyncQueue.js

@@ -70,7 +70,7 @@ class AsyncQueue {
 		this._entries = new Map();
 		/** @type {ArrayQueue<AsyncQueueEntry<T, K, R>>} */
 		this._queued = new ArrayQueue();
-		/** @type {AsyncQueue<any, any, any>[]} */
+		/** @type {AsyncQueue<any, any, any>[] | undefined} */
 		this._children = undefined;
 		this._activeTasks = 0;
 		this._willEnsureProcessing = false;
@@ -159,7 +159,9 @@ class AsyncQueue {
 	 */
 	invalidate(item) {
 		const key = this._getKey(item);
-		const entry = this._entries.get(key);
+		const entry =
+			/** @type {AsyncQueueEntry<T, K, R>} */
+			(this._entries.get(key));
 		this._entries.delete(key);
 		if (entry.state === QUEUED_STATE) {
 			this._queued.delete(entry);

package/lib/util/ParallelismFactorCalculator.js

@@ -7,12 +7,22 @@
 
 const binarySearchBounds = require("../util/binarySearchBounds");
 
+/** @typedef {function(number): void} Callback */
+
 class ParallelismFactorCalculator {
 	constructor() {
+		/** @type {number[]} */
 		this._rangePoints = [];
+		/** @type {Callback[]} */
 		this._rangeCallbacks = [];
 	}
 
+	/**
+	 * @param {number} start range start
+	 * @param {number} end range end
+	 * @param {Callback} callback callback
+	 * @returns {void}
+	 */
 	range(start, end, callback) {
 		if (start === end) return callback(1);
 		this._rangePoints.push(start);

package/lib/util/Semaphore.js

@@ -44,7 +44,7 @@ class Semaphore {
 		if (this.available > 0) {
 			if (this.waiters.length > 0) {
 				this.available--;
-				const callback = this.waiters.pop();
+				const callback = /** @type {(function(): void)} */ (this.waiters.pop());
 				callback();
 			}
 		}

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