webpack 5.85.1 → 5.87.0

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

@@ -21,6 +21,9 @@ Section -> NullsSection |
 					 I32NumbersSection |
 					 I8NumbersSection |
 					 ShortStringSection |
+					 BigIntSection |
+					 I32BigIntSection |
+					 I8BigIntSection
 					 StringSection |
 					 BufferSection |
 					 NopSection
@@ -39,6 +42,9 @@ ShortStringSection -> ShortStringSectionHeaderByte ascii-byte*
 StringSection -> StringSectionHeaderByte i32:length utf8-byte*
 BufferSection -> BufferSectionHeaderByte i32:length byte*
 NopSection --> NopSectionHeaderByte
+BigIntSection -> BigIntSectionHeaderByte i32:length ascii-byte*
+I32BigIntSection -> I32BigIntSectionHeaderByte i32
+I8BigIntSection -> I8BigIntSectionHeaderByte i8
 
 ShortStringSectionHeaderByte -> 0b1nnn_nnnn (n:length)
 
@@ -58,6 +64,9 @@ BooleansCountAndBitsByte ->
 StringSectionHeaderByte -> 0b0000_1110
 BufferSectionHeaderByte -> 0b0000_1111
 NopSectionHeaderByte -> 0b0000_1011
+BigIntSectionHeaderByte -> 0b0001_1010
+I32BigIntSectionHeaderByte -> 0b0001_1100
+I8BigIntSectionHeaderByte -> 0b0001_1011
 FalseHeaderByte -> 0b0000_1100
 TrueHeaderByte -> 0b0000_1101
 
@@ -78,6 +87,9 @@ const NULL_AND_I8_HEADER = 0x15;
 const NULL_AND_I32_HEADER = 0x16;
 const NULL_AND_TRUE_HEADER = 0x17;
 const NULL_AND_FALSE_HEADER = 0x18;
+const BIGINT_HEADER = 0x1a;
+const BIGINT_I8_HEADER = 0x1b;
+const BIGINT_I32_HEADER = 0x1c;
 const STRING_HEADER = 0x1e;
 const BUFFER_HEADER = 0x1f;
 const I8_HEADER = 0x60;
@@ -86,7 +98,7 @@ const F64_HEADER = 0x20;
 const SHORT_STRING_HEADER = 0x80;
 
 /** Uplift high-order bits */
-const NUMBERS_HEADER_MASK = 0xe0;
+const NUMBERS_HEADER_MASK = 0xe0; // 0b1010_0000
 const NUMBERS_COUNT_MASK = 0x1f; // 0b0001_1111
 const SHORT_STRING_LENGTH_MASK = 0x7f; // 0b0111_1111
 
@@ -113,6 +125,16 @@ const identifyNumber = n => {
 	return 2;
 };
 
+/**
+ * @param {bigint} n bigint
+ * @returns {0 | 1 | 2} type of bigint for serialization
+ */
+const identifyBigInt = n => {
+	if (n <= BigInt(127) && n >= BigInt(-128)) return 0;
+	if (n <= BigInt(2147483647) && n >= BigInt(-2147483648)) return 1;
+	return 2;
+};
+
 /**
  * @typedef {PrimitiveSerializableType[]} DeserializedType
  * @typedef {BufferSerializableType[]} SerializedType
@@ -331,6 +353,62 @@ class BinaryMiddleware extends SerializerMiddleware {
 					}
 					break;
 				}
+				case "bigint": {
+					const type = identifyBigInt(thing);
+					if (type === 0 && thing >= 0 && thing <= BigInt(10)) {
+						// shortcut for very small bigints
+						allocate(HEADER_SIZE + I8_SIZE);
+						writeU8(BIGINT_I8_HEADER);
+						writeU8(Number(thing));
+						break;
+					}
+
+					switch (type) {
+						case 0: {
+							let n = 1;
+							allocate(HEADER_SIZE + I8_SIZE * n);
+							writeU8(BIGINT_I8_HEADER | (n - 1));
+							while (n > 0) {
+								currentBuffer.writeInt8(
+									Number(/** @type {bigint} */ (data[i])),
+									currentPosition
+								);
+								currentPosition += I8_SIZE;
+								n--;
+								i++;
+							}
+							i--;
+							break;
+						}
+						case 1: {
+							let n = 1;
+							allocate(HEADER_SIZE + I32_SIZE * n);
+							writeU8(BIGINT_I32_HEADER | (n - 1));
+							while (n > 0) {
+								currentBuffer.writeInt32LE(
+									Number(/** @type {bigint} */ (data[i])),
+									currentPosition
+								);
+								currentPosition += I32_SIZE;
+								n--;
+								i++;
+							}
+							i--;
+							break;
+						}
+						default: {
+							const value = thing.toString();
+							const len = Buffer.byteLength(value);
+							allocate(len + HEADER_SIZE + I32_SIZE);
+							writeU8(BIGINT_HEADER);
+							writeU32(len);
+							currentBuffer.write(value, currentPosition);
+							currentPosition += len;
+							break;
+						}
+					}
+					break;
+				}
 				case "number": {
 					const type = identifyNumber(thing);
 					if (type === 0 && thing >= 0 && thing <= 10) {
@@ -847,6 +925,70 @@ class BinaryMiddleware extends SerializerMiddleware {
 							result.push(read(1).readInt8(0));
 						}
 					};
+				case BIGINT_I8_HEADER: {
+					const len = 1;
+					return () => {
+						const need = I8_SIZE * len;
+
+						if (isInCurrentBuffer(need)) {
+							for (let i = 0; i < len; i++) {
+								const value =
+									/** @type {Buffer} */
+									(currentBuffer).readInt8(currentPosition);
+								result.push(BigInt(value));
+								currentPosition += I8_SIZE;
+							}
+							checkOverflow();
+						} else {
+							const buf = read(need);
+							for (let i = 0; i < len; i++) {
+								const value = buf.readInt8(i * I8_SIZE);
+								result.push(BigInt(value));
+							}
+						}
+					};
+				}
+				case BIGINT_I32_HEADER: {
+					const len = 1;
+					return () => {
+						const need = I32_SIZE * len;
+						if (isInCurrentBuffer(need)) {
+							for (let i = 0; i < len; i++) {
+								const value = /** @type {Buffer} */ (currentBuffer).readInt32LE(
+									currentPosition
+								);
+								result.push(BigInt(value));
+								currentPosition += I32_SIZE;
+							}
+							checkOverflow();
+						} else {
+							const buf = read(need);
+							for (let i = 0; i < len; i++) {
+								const value = buf.readInt32LE(i * I32_SIZE);
+								result.push(BigInt(value));
+							}
+						}
+					};
+				}
+				case BIGINT_HEADER: {
+					return () => {
+						const len = readU32();
+						if (isInCurrentBuffer(len) && currentPosition + len < 0x7fffffff) {
+							const value = currentBuffer.toString(
+								undefined,
+								currentPosition,
+								currentPosition + len
+							);
+
+							result.push(BigInt(value));
+							currentPosition += len;
+							checkOverflow();
+						} else {
+							const value = read(len).toString();
+							result.push(BigInt(value));
+						}
+					};
+				}
 				default:
 					if (header <= 10) {
 						return () => result.push(header);

package/lib/serialization/ErrorObjectSerializer.js

@@ -21,6 +21,7 @@ class ErrorObjectSerializer {
 	serialize(obj, context) {
 		context.write(obj.message);
 		context.write(obj.stack);
+		context.write(/** @type {Error & { cause: "unknown" }} */ (obj).cause);
 	}
 	/**
 	 * @param {ObjectDeserializerContext} context context
@@ -31,6 +32,8 @@ class ErrorObjectSerializer {
 
 		err.message = context.read();
 		err.stack = context.read();
+		/** @type {Error & { cause: "unknown" }} */
+		(err).cause = context.read();
 
 		return err;
 	}

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}
 	 */
@@ -397,6 +400,9 @@ class ObjectMiddleware extends SerializerMiddleware {
 							", "
 						)} }`;
 					}
+					if (typeof item === "bigint") {
+						return `BigInt ${item}n`;
+					}
 					try {
 						return `${item}`;
 					} catch (e) {

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/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();
 			}
 		}