webpack 5.59.0 → 5.94.0

package/lib/schemes/HttpUriPlugin.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const EventEmitter = require("events");
 const { extname, basename } = require("path");
 const { URL } = require("url");
 const { createGunzip, createBrotliDecompress, createInflate } = require("zlib");
@@ -14,14 +15,73 @@ const createHash = require("../util/createHash");
 const { mkdirp, dirname, join } = require("../util/fs");
 const memoize = require("../util/memoize");
 
+/** @typedef {import("http").IncomingMessage} IncomingMessage */
+/** @typedef {import("http").RequestOptions} RequestOptions */
+/** @typedef {import("net").Socket} Socket */
+/** @typedef {import("stream").Readable} Readable */
 /** @typedef {import("../../declarations/plugins/schemes/HttpUriPlugin").HttpUriPluginOptions} HttpUriPluginOptions */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../FileSystemInfo").Snapshot} Snapshot */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../NormalModuleFactory").ResourceDataWithData} ResourceDataWithData */
+/** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
 
 const getHttp = memoize(() => require("http"));
 const getHttps = memoize(() => require("https"));
 
-/** @type {(() => void)[] | undefined} */
-let inProgressWrite = undefined;
+/**
+ * @param {typeof import("http") | typeof import("https")} request request
+ * @param {string | { toString: () => string } | undefined} proxy proxy
+ * @returns {function(URL, RequestOptions, function(IncomingMessage): void): EventEmitter} fn
+ */
+const proxyFetch = (request, proxy) => (url, options, callback) => {
+	const eventEmitter = new EventEmitter();
+
+	/**
+	 * @param {Socket=} socket socket
+	 * @returns {void}
+	 */
+	const doRequest = socket => {
+		request
+			.get(url, { ...options, ...(socket && { socket }) }, callback)
+			.on("error", eventEmitter.emit.bind(eventEmitter, "error"));
+	};
+
+	if (proxy) {
+		const { hostname: host, port } = new URL(proxy);
+
+		getHttp()
+			.request({
+				host, // IP address of proxy server
+				port, // port of proxy server
+				method: "CONNECT",
+				path: url.host
+			})
+			.on("connect", (res, socket) => {
+				if (res.statusCode === 200) {
+					// connected to proxy server
+					doRequest(socket);
+				}
+			})
+			.on("error", err => {
+				eventEmitter.emit(
+					"error",
+					new Error(
+						`Failed to connect to proxy server "${proxy}": ${err.message}`
+					)
+				);
+			})
+			.end();
+	} else {
+		doRequest();
+	}
+
+	return eventEmitter;
+};
+
+/** @typedef {() => void} InProgressWriteItem */
+/** @type {InProgressWriteItem[] | undefined} */
+let inProgressWrite;
 
 const validate = createSchemaValidation(
 	require("../../schemas/plugins/schemes/HttpUriPlugin.check.js"),
@@ -32,18 +92,31 @@ const validate = createSchemaValidation(
 	}
 );
 
+/**
+ * @param {string} str path
+ * @returns {string} safe path
+ */
 const toSafePath = str =>
 	str
 		.replace(/^[^a-zA-Z0-9]+|[^a-zA-Z0-9]+$/g, "")
 		.replace(/[^a-zA-Z0-9._-]+/g, "_");
 
+/**
+ * @param {Buffer} content content
+ * @returns {string} integrity
+ */
 const computeIntegrity = content => {
 	const hash = createHash("sha512");
 	hash.update(content);
-	const integrity = "sha512-" + hash.digest("base64");
+	const integrity = `sha512-${hash.digest("base64")}`;
 	return integrity;
 };
 
+/**
+ * @param {Buffer} content content
+ * @param {string} integrity integrity
+ * @returns {boolean} true, if integrity matches
+ */
 const verifyIntegrity = (content, integrity) => {
 	if (integrity === "ignore") return true;
 	return computeIntegrity(content) === integrity;
@@ -71,6 +144,11 @@ const parseKeyValuePairs = str => {
 	return result;
 };
 
+/**
+ * @param {string | undefined} cacheControl Cache-Control header
+ * @param {number} requestTime timestamp of request
+ * @returns {{storeCache: boolean, storeLock: boolean, validUntil: number}} Logic for storing in cache and lockfile cache
+ */
 const parseCacheControl = (cacheControl, requestTime) => {
 	// When false resource is not stored in cache
 	let storeCache = true;
@@ -81,8 +159,8 @@ const parseCacheControl = (cacheControl, requestTime) => {
 	if (cacheControl) {
 		const parsed = parseKeyValuePairs(cacheControl);
 		if (parsed["no-cache"]) storeCache = storeLock = false;
-		if (parsed["max-age"] && !isNaN(+parsed["max-age"])) {
-			validUntil = requestTime + +parsed["max-age"] * 1000;
+		if (parsed["max-age"] && !Number.isNaN(Number(parsed["max-age"]))) {
+			validUntil = requestTime + Number(parsed["max-age"]) * 1000;
 		}
 		if (parsed["must-revalidate"]) validUntil = 0;
 	}
@@ -94,23 +172,28 @@ const parseCacheControl = (cacheControl, requestTime) => {
 };
 
 /**
- * @typedef {Object} LockfileEntry
+ * @typedef {object} LockfileEntry
  * @property {string} resolved
  * @property {string} integrity
  * @property {string} contentType
  */
 
-const areLockfileEntriesEqual = (a, b) => {
-	return (
-		a.resolved === b.resolved &&
-		a.integrity === b.integrity &&
-		a.contentType === b.contentType
-	);
-};
+/**
+ * @param {LockfileEntry} a first lockfile entry
+ * @param {LockfileEntry} b second lockfile entry
+ * @returns {boolean} true when equal, otherwise false
+ */
+const areLockfileEntriesEqual = (a, b) =>
+	a.resolved === b.resolved &&
+	a.integrity === b.integrity &&
+	a.contentType === b.contentType;
 
-const entryToString = entry => {
-	return `resolved: ${entry.resolved}, integrity: ${entry.integrity}, contentType: ${entry.contentType}`;
-};
+/**
+ * @param {LockfileEntry} entry lockfile entry
+ * @returns {`resolved: ${string}, integrity: ${string}, contentType: ${*}`} stringified entry
+ */
+const entryToString = entry =>
+	`resolved: ${entry.resolved}, integrity: ${entry.integrity}, contentType: ${entry.contentType}`;
 
 class Lockfile {
 	constructor() {
@@ -119,6 +202,10 @@ class Lockfile {
 		this.entries = new Map();
 	}
 
+	/**
+	 * @param {string} content content of the lockfile
+	 * @returns {Lockfile} lockfile
+	 */
 	static parse(content) {
 		// TODO handle merge conflicts
 		const data = JSON.parse(content);
@@ -135,12 +222,15 @@ class Lockfile {
 					: {
 							resolved: key,
 							...entry
-					  }
+						}
 			);
 		}
 		return lockfile;
 	}
 
+	/**
+	 * @returns {string} stringified lockfile
+	 */
 	toString() {
 		let str = "{\n";
 		const entries = Array.from(this.entries).sort(([a], [b]) =>
@@ -165,17 +255,17 @@ class Lockfile {
 
 /**
  * @template R
- * @param {function(function(Error=, R=): void): void} fn function
- * @returns {function(function(Error=, R=): void): void} cached function
+ * @param {function(function(Error | null, R=): void): void} fn function
+ * @returns {function(function(Error | null, R=): void): void} cached function
  */
 const cachedWithoutKey = fn => {
 	let inFlight = false;
 	/** @type {Error | undefined} */
-	let cachedError = undefined;
+	let cachedError;
 	/** @type {R | undefined} */
-	let cachedResult = undefined;
-	/** @type {(function(Error=, R=): void)[] | undefined} */
-	let cachedCallbacks = undefined;
+	let cachedResult;
+	/** @type {(function(Error| null, R=): void)[] | undefined} */
+	let cachedCallbacks;
 	return callback => {
 		if (inFlight) {
 			if (cachedResult !== undefined) return callback(null, cachedResult);
@@ -199,14 +289,22 @@ const cachedWithoutKey = fn => {
 /**
  * @template T
  * @template R
- * @param {function(T, function(Error=, R=): void): void} fn function
- * @param {function(T, function(Error=, R=): void): void=} forceFn function for the second try
- * @returns {(function(T, function(Error=, R=): void): void) & { force: function(T, function(Error=, R=): void): void }} cached function
+ * @param {function(T, function(Error | null, R=): void): void} fn function
+ * @param {function(T, function(Error | null, R=): void): void=} forceFn function for the second try
+ * @returns {(function(T, function(Error | null, R=): void): void) & { force: function(T, function(Error | null, R=): void): void }} cached function
  */
 const cachedWithKey = (fn, forceFn = fn) => {
-	/** @typedef {{ result?: R, error?: Error, callbacks?: (function(Error=, R=): void)[], force?: true }} CacheEntry */
-	/** @type {Map<T, CacheEntry>} */
+	/**
+	 * @template R
+	 * @typedef {{ result?: R, error?: Error, callbacks?: (function(Error | null, R=): void)[], force?: true }} CacheEntry
+	 */
+	/** @type {Map<T, CacheEntry<R>>} */
 	const cache = new Map();
+	/**
+	 * @param {T} arg arg
+	 * @param {function(Error | null, R=): void} callback callback
+	 * @returns {void}
+	 */
 	const resultFn = (arg, callback) => {
 		const cacheEntry = cache.get(arg);
 		if (cacheEntry !== undefined) {
@@ -217,7 +315,7 @@ const cachedWithKey = (fn, forceFn = fn) => {
 			else cacheEntry.callbacks.push(callback);
 			return;
 		}
-		/** @type {CacheEntry} */
+		/** @type {CacheEntry<R>} */
 		const newCacheEntry = {
 			result: undefined,
 			error: undefined,
@@ -233,6 +331,11 @@ const cachedWithKey = (fn, forceFn = fn) => {
 			if (callbacks !== undefined) for (const cb of callbacks) cb(err, result);
 		});
 	};
+	/**
+	 * @param {T} arg arg
+	 * @param {function(Error | null, R=): void} callback callback
+	 * @returns {void}
+	 */
 	resultFn.force = (arg, callback) => {
 		const cacheEntry = cache.get(arg);
 		if (cacheEntry !== undefined && cacheEntry.force) {
@@ -243,7 +346,7 @@ const cachedWithKey = (fn, forceFn = fn) => {
 			else cacheEntry.callbacks.push(callback);
 			return;
 		}
-		/** @type {CacheEntry} */
+		/** @type {CacheEntry<R>} */
 		const newCacheEntry = {
 			result: undefined,
 			error: undefined,
@@ -263,6 +366,24 @@ const cachedWithKey = (fn, forceFn = fn) => {
 	return resultFn;
 };
 
+/**
+ * @typedef {object} LockfileCache
+ * @property {Lockfile} lockfile lockfile
+ * @property {Snapshot} snapshot snapshot
+ */
+
+/**
+ * @typedef {object} ResolveContentResult
+ * @property {LockfileEntry} entry lockfile entry
+ * @property {Buffer} content content
+ * @property {boolean} storeLock need store lockfile
+ */
+
+/** @typedef {{ storeCache: boolean, storeLock: boolean, validUntil: number, etag: string | undefined, fresh: boolean }} FetchResultMeta */
+/** @typedef {FetchResultMeta & { location: string }} RedirectFetchResult */
+/** @typedef {FetchResultMeta & { entry: LockfileEntry, content: Buffer }} ContentFetchResult */
+/** @typedef {RedirectFetchResult | ContentFetchResult} FetchResult */
+
 class HttpUriPlugin {
 	/**
 	 * @param {HttpUriPluginOptions} options options
@@ -274,6 +395,7 @@ class HttpUriPlugin {
 		this._upgrade = options.upgrade;
 		this._frozen = options.frozen;
 		this._allowedUris = options.allowedUris;
+		this._proxy = options.proxy;
 	}
 
 	/**
@@ -282,25 +404,30 @@ class HttpUriPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
+		const proxy =
+			this._proxy || process.env.http_proxy || process.env.HTTP_PROXY;
 		const schemes = [
 			{
 				scheme: "http",
-				fetch: (url, options, callback) => getHttp().get(url, options, callback)
+				fetch: proxyFetch(getHttp(), proxy)
 			},
 			{
 				scheme: "https",
-				fetch: (url, options, callback) =>
-					getHttps().get(url, options, callback)
+				fetch: proxyFetch(getHttps(), proxy)
 			}
 		];
+		/** @type {LockfileCache} */
 		let lockfileCache;
 		compiler.hooks.compilation.tap(
 			"HttpUriPlugin",
 			(compilation, { normalModuleFactory }) => {
-				const intermediateFs = compiler.intermediateFileSystem;
+				const intermediateFs =
+					/** @type {IntermediateFileSystem} */
+					(compiler.intermediateFileSystem);
 				const fs = compilation.inputFileSystem;
 				const cache = compilation.getCache("webpack.HttpUriPlugin");
 				const logger = compilation.getLogger("webpack.HttpUriPlugin");
+				/** @type {string} */
 				const lockfileLocation =
 					this._lockfileLocation ||
 					join(
@@ -310,10 +437,11 @@ class HttpUriPlugin {
 							? `${toSafePath(compiler.name)}.webpack.lock`
 							: "webpack.lock"
 					);
+				/** @type {string | false} */
 				const cacheLocation =
 					this._cacheLocation !== undefined
 						? this._cacheLocation
-						: lockfileLocation + ".data";
+						: `${lockfileLocation}.data`;
 				const upgrade = this._upgrade || false;
 				const frozen = this._frozen || false;
 				const hashFunction = "sha512";
@@ -323,6 +451,7 @@ class HttpUriPlugin {
 
 				let warnedAboutEol = false;
 
+				/** @type {Map<string, string>} */
 				const cacheKeyCache = new Map();
 				/**
 				 * @param {string} url the url
@@ -358,7 +487,7 @@ class HttpUriPlugin {
 
 				const getLockfile = cachedWithoutKey(
 					/**
-					 * @param {function(Error=, Lockfile=): void} callback callback
+					 * @param {function(Error | null, Lockfile=): void} callback callback
 					 * @returns {void}
 					 */
 					callback => {
@@ -375,14 +504,14 @@ class HttpUriPlugin {
 									[],
 									buffer ? [] : [lockfileLocation],
 									{ timestamp: true },
-									(err, snapshot) => {
+									(err, s) => {
 										if (err) return callback(err);
 										const lockfile = buffer
 											? Lockfile.parse(buffer.toString("utf-8"))
 											: new Lockfile();
 										lockfileCache = {
 											lockfile,
-											snapshot
+											snapshot: /** @type {Snapshot} */ (s)
 										};
 										callback(null, lockfile);
 									}
@@ -404,8 +533,16 @@ class HttpUriPlugin {
 					}
 				);
 
-				/** @type {Map<string, LockfileEntry | "ignore" | "no-cache"> | undefined} */
-				let lockfileUpdates = undefined;
+				/** @typedef {Map<string, LockfileEntry | "ignore" | "no-cache">} LockfileUpdates */
+
+				/** @type {LockfileUpdates | undefined} */
+				let lockfileUpdates;
+
+				/**
+				 * @param {Lockfile} lockfile lockfile instance
+				 * @param {string} url url to store
+				 * @param {LockfileEntry | "ignore" | "no-cache"} entry lockfile entry
+				 */
 				const storeLockEntry = (lockfile, url, entry) => {
 					const oldEntry = lockfile.entries.get(url);
 					if (lockfileUpdates === undefined) lockfileUpdates = new Map();
@@ -440,6 +577,13 @@ class HttpUriPlugin {
 					}
 				};
 
+				/**
+				 * @param {Lockfile} lockfile lockfile
+				 * @param {string} url url
+				 * @param {ResolveContentResult} result result
+				 * @param {function(Error | null, ResolveContentResult=): void} callback callback
+				 * @returns {void}
+				 */
 				const storeResult = (lockfile, url, result, callback) => {
 					if (result.storeLock) {
 						storeLockEntry(lockfile, url, result.entry);
@@ -462,12 +606,16 @@ class HttpUriPlugin {
 
 				for (const { scheme, fetch } of schemes) {
 					/**
-					 *
 					 * @param {string} url URL
-					 * @param {string} integrity integrity
-					 * @param {function(Error=, { entry: LockfileEntry, content: Buffer, storeLock: boolean }=): void} callback callback
+					 * @param {string | null} integrity integrity
+					 * @param {function(Error | null, ResolveContentResult=): void} callback callback
 					 */
 					const resolveContent = (url, integrity, callback) => {
+						/**
+						 * @param {Error | null} err error
+						 * @param {TODO} result result result
+						 * @returns {void}
+						 */
 						const handleResult = (err, result) => {
 							if (err) return callback(err);
 							if ("location" in result) {
@@ -476,41 +624,37 @@ class HttpUriPlugin {
 									integrity,
 									(err, innerResult) => {
 										if (err) return callback(err);
+										const { entry, content, storeLock } =
+											/** @type {ResolveContentResult} */ (innerResult);
 										callback(null, {
-											entry: innerResult.entry,
-											content: innerResult.content,
-											storeLock: innerResult.storeLock && result.storeLock
+											entry,
+											content,
+											storeLock: storeLock && result.storeLock
 										});
 									}
 								);
-							} else {
-								if (
-									!result.fresh &&
-									integrity &&
-									result.entry.integrity !== integrity &&
-									!verifyIntegrity(result.content, integrity)
-								) {
-									return fetchContent.force(url, handleResult);
-								}
-								return callback(null, {
-									entry: result.entry,
-									content: result.content,
-									storeLock: result.storeLock
-								});
 							}
+							if (
+								!result.fresh &&
+								integrity &&
+								result.entry.integrity !== integrity &&
+								!verifyIntegrity(result.content, integrity)
+							) {
+								return fetchContent.force(url, handleResult);
+							}
+							return callback(null, {
+								entry: result.entry,
+								content: result.content,
+								storeLock: result.storeLock
+							});
 						};
 						fetchContent(url, handleResult);
 					};
 
-					/** @typedef {{ storeCache: boolean, storeLock: boolean, validUntil: number, etag: string | undefined, fresh: boolean }} FetchResultMeta */
-					/** @typedef {FetchResultMeta & { location: string }} RedirectFetchResult */
-					/** @typedef {FetchResultMeta & { entry: LockfileEntry, content: Buffer }} ContentFetchResult */
-					/** @typedef {RedirectFetchResult | ContentFetchResult} FetchResult */
-
 					/**
 					 * @param {string} url URL
-					 * @param {FetchResult} cachedResult result from cache
-					 * @param {function(Error=, FetchResult=): void} callback callback
+					 * @param {FetchResult | RedirectFetchResult | undefined} cachedResult result from cache
+					 * @param {function(Error | null, FetchResult=): void} callback callback
 					 * @returns {void}
 					 */
 					const fetchContentRaw = (url, cachedResult, callback) => {
@@ -521,14 +665,14 @@ class HttpUriPlugin {
 								headers: {
 									"accept-encoding": "gzip, deflate, br",
 									"user-agent": "webpack",
-									"if-none-match": cachedResult
-										? cachedResult.etag || null
-										: null
+									"if-none-match": /** @type {TODO} */ (
+										cachedResult ? cachedResult.etag || null : null
+									)
 								}
 							},
 							res => {
-								const etag = res.headers["etag"];
-								const location = res.headers["location"];
+								const etag = res.headers.etag;
+								const location = res.headers.location;
 								const cacheControl = res.headers["cache-control"];
 								const { storeLock, storeCache, validUntil } = parseCacheControl(
 									cacheControl,
@@ -583,34 +727,54 @@ class HttpUriPlugin {
 									);
 								};
 								if (res.statusCode === 304) {
+									const result = /** @type {FetchResult} */ (cachedResult);
 									if (
-										cachedResult.validUntil < validUntil ||
-										cachedResult.storeLock !== storeLock ||
-										cachedResult.storeCache !== storeCache ||
-										cachedResult.etag !== etag
+										result.validUntil < validUntil ||
+										result.storeLock !== storeLock ||
+										result.storeCache !== storeCache ||
+										result.etag !== etag
 									) {
-										return finishWith(cachedResult);
-									} else {
-										logger.debug(`GET ${url} [${res.statusCode}] (unchanged)`);
-										return callback(null, {
-											...cachedResult,
-											fresh: true
-										});
+										return finishWith(result);
 									}
+									logger.debug(`GET ${url} [${res.statusCode}] (unchanged)`);
+									return callback(null, { ...result, fresh: true });
 								}
 								if (
 									location &&
+									res.statusCode &&
 									res.statusCode >= 301 &&
 									res.statusCode <= 308
 								) {
-									return finishWith({
+									const result = {
 										location: new URL(location, url).href
+									};
+									if (
+										!cachedResult ||
+										!("location" in cachedResult) ||
+										cachedResult.location !== result.location ||
+										cachedResult.validUntil < validUntil ||
+										cachedResult.storeLock !== storeLock ||
+										cachedResult.storeCache !== storeCache ||
+										cachedResult.etag !== etag
+									) {
+										return finishWith(result);
+									}
+									logger.debug(`GET ${url} [${res.statusCode}] (unchanged)`);
+									return callback(null, {
+										...result,
+										fresh: true,
+										storeLock,
+										storeCache,
+										validUntil,
+										etag
 									});
 								}
 								const contentType = res.headers["content-type"] || "";
+								/** @type {Buffer[]} */
 								const bufferArr = [];
 
 								const contentEncoding = res.headers["content-encoding"];
+								/** @type {Readable} */
 								let stream = res;
 								if (contentEncoding === "gzip") {
 									stream = stream.pipe(createGunzip());
@@ -662,9 +826,10 @@ class HttpUriPlugin {
 					const fetchContent = cachedWithKey(
 						/**
 						 * @param {string} url URL
-						 * @param {function(Error=, { validUntil: number, etag?: string, entry: LockfileEntry, content: Buffer, fresh: boolean } | { validUntil: number, etag?: string, location: string, fresh: boolean }=): void} callback callback
+						 * @param {function(Error | null, { validUntil: number, etag?: string, entry: LockfileEntry, content: Buffer, fresh: boolean } | { validUntil: number, etag?: string, location: string, fresh: boolean }=): void} callback callback
 						 * @returns {void}
-						 */ (url, callback) => {
+						 */
+						(url, callback) => {
 							cache.get(url, null, (err, cachedResult) => {
 								if (err) return callback(err);
 								if (cachedResult) {
@@ -677,25 +842,32 @@ class HttpUriPlugin {
 						(url, callback) => fetchContentRaw(url, undefined, callback)
 					);
 
+					/**
+					 * @param {string} uri uri
+					 * @returns {boolean} true when allowed, otherwise false
+					 */
 					const isAllowed = uri => {
 						for (const allowed of allowedUris) {
 							if (typeof allowed === "string") {
 								if (uri.startsWith(allowed)) return true;
 							} else if (typeof allowed === "function") {
 								if (allowed(uri)) return true;
-							} else {
-								if (allowed.test(uri)) return true;
+							} else if (allowed.test(uri)) {
+								return true;
 							}
 						}
 						return false;
 					};
 
+					/** @typedef {{ entry: LockfileEntry, content: Buffer }} Info */
+
 					const getInfo = cachedWithKey(
 						/**
 						 * @param {string} url the url
-						 * @param {function(Error=, { entry: LockfileEntry, content: Buffer }=): void} callback callback
+						 * @param {function(Error | null, Info=): void} callback callback
 						 * @returns {void}
 						 */
+						// eslint-disable-next-line no-loop-func
 						(url, callback) => {
 							if (!isAllowed(url)) {
 								return callback(
@@ -706,8 +878,9 @@ class HttpUriPlugin {
 									)
 								);
 							}
-							getLockfile((err, lockfile) => {
+							getLockfile((err, _lockfile) => {
 								if (err) return callback(err);
+								const lockfile = /** @type {Lockfile} */ (_lockfile);
 								const entryOrString = lockfile.entries.get(url);
 								if (!entryOrString) {
 									if (frozen) {
@@ -719,14 +892,24 @@ class HttpUriPlugin {
 									}
 									resolveContent(url, null, (err, result) => {
 										if (err) return callback(err);
-										storeResult(lockfile, url, result, callback);
+										storeResult(
+											/** @type {Lockfile} */
+											(lockfile),
+											url,
+											/** @type {ResolveContentResult} */
+											(result),
+											callback
+										);
 									});
 									return;
 								}
 								if (typeof entryOrString === "string") {
 									const entryTag = entryOrString;
-									resolveContent(url, null, (err, result) => {
+									resolveContent(url, null, (err, _result) => {
 										if (err) return callback(err);
+										const result =
+											/** @type {ResolveContentResult} */
+											(_result);
 										if (!result.storeLock || entryTag === "ignore")
 											return callback(null, result);
 										if (frozen) {
@@ -750,8 +933,11 @@ Remove this line from the lockfile to force upgrading.`
 									return;
 								}
 								let entry = entryOrString;
+								/**
+								 * @param {Buffer=} lockedContent locked content
+								 */
 								const doFetch = lockedContent => {
-									resolveContent(url, entry.integrity, (err, result) => {
+									resolveContent(url, entry.integrity, (err, _result) => {
 										if (err) {
 											if (lockedContent) {
 												logger.warn(
@@ -765,6 +951,9 @@ Remove this line from the lockfile to force upgrading.`
 											}
 											return callback(err);
 										}
+										const result =
+											/** @type {ResolveContentResult} */
+											(_result);
 										if (!result.storeLock) {
 											// When the lockfile entry should be no-cache
 											// we need to update the lockfile
@@ -819,12 +1008,16 @@ Remove this line from the lockfile to force upgrading.`
 									const key = getCacheKey(entry.resolved);
 									const filePath = join(intermediateFs, cacheLocation, key);
 									fs.readFile(filePath, (err, result) => {
-										const content = /** @type {Buffer} */ (result);
 										if (err) {
 											if (err.code === "ENOENT") return doFetch();
 											return callback(err);
 										}
-										const continueWithCachedContent = result => {
+										const content = /** @type {Buffer} */ (result);
+										/**
+										 * @param {Buffer | undefined} _result result
+										 * @returns {void}
+										 */
+										const continueWithCachedContent = _result => {
 											if (!upgrade) {
 												// When not in upgrade mode, we accept the result from the lockfile cache
 												return callback(null, { entry, content });
@@ -832,6 +1025,7 @@ Remove this line from the lockfile to force upgrading.`
 											return doFetch(content);
 										};
 										if (!verifyIntegrity(content, entry.integrity)) {
+											/** @type {Buffer | undefined} */
 											let contentWithChangedEol;
 											let isEolChanged = false;
 											try {
@@ -842,7 +1036,7 @@ Remove this line from the lockfile to force upgrading.`
 													contentWithChangedEol,
 													entry.integrity
 												);
-											} catch (e) {
+											} catch (_err) {
 												// ignore
 											}
 											if (isEolChanged) {
@@ -869,10 +1063,14 @@ This will avoid that the end of line sequence is changed by git on Windows.`;
 													);
 													intermediateFs.writeFile(
 														filePath,
-														contentWithChangedEol,
+														/** @type {Buffer} */
+														(contentWithChangedEol),
 														err => {
 															if (err) return callback(err);
-															continueWithCachedContent(contentWithChangedEol);
+															continueWithCachedContent(
+																/** @type {Buffer} */
+																(contentWithChangedEol)
+															);
 														}
 													);
 													return;
@@ -894,15 +1092,14 @@ Lockfile corrupted (${
 Run build with un-frozen lockfile to automatically fix lockfile.`
 													)
 												);
-											} else {
-												// "fix" the lockfile entry to the correct integrity
-												// the content has priority over the integrity value
-												entry = {
-													...entry,
-													integrity: computeIntegrity(content)
-												};
-												storeLockEntry(lockfile, url, entry);
 											}
+											// "fix" the lockfile entry to the correct integrity
+											// the content has priority over the integrity value
+											entry = {
+												...entry,
+												integrity: computeIntegrity(content)
+											};
+											storeLockEntry(lockfile, url, entry);
 										}
 										continueWithCachedContent(result);
 									});
@@ -913,9 +1110,15 @@ Run build with un-frozen lockfile to automatically fix lockfile.`
 						}
 					);
 
+					/**
+					 * @param {URL} url url
+					 * @param {ResourceDataWithData} resourceData resource data
+					 * @param {function(Error | null, true | void): void} callback callback
+					 */
 					const respondWithUrlModule = (url, resourceData, callback) => {
-						getInfo(url.href, (err, result) => {
+						getInfo(url.href, (err, _result) => {
 							if (err) return callback(err);
+							const result = /** @type {Info} */ (_result);
 							resourceData.resource = url.href;
 							resourceData.path = url.origin + url.pathname;
 							resourceData.query = url.search;
@@ -951,7 +1154,7 @@ Run build with un-frozen lockfile to automatically fix lockfile.`
 								return callback();
 							}
 							respondWithUrlModule(
-								new URL(resourceData.resource, data.context + "/"),
+								new URL(resourceData.resource, `${data.context}/`),
 								resourceData,
 								callback
 							);
@@ -959,13 +1162,15 @@ Run build with un-frozen lockfile to automatically fix lockfile.`
 					const hooks = NormalModule.getCompilationHooks(compilation);
 					hooks.readResourceForScheme
 						.for(scheme)
-						.tapAsync("HttpUriPlugin", (resource, module, callback) => {
-							return getInfo(resource, (err, result) => {
+						.tapAsync("HttpUriPlugin", (resource, module, callback) =>
+							getInfo(resource, (err, _result) => {
 								if (err) return callback(err);
-								module.buildInfo.resourceIntegrity = result.entry.integrity;
+								const result = /** @type {Info} */ (_result);
+								/** @type {BuildInfo} */
+								(module.buildInfo).resourceIntegrity = result.entry.integrity;
 								callback(null, result.content);
-							});
-						});
+							})
+						);
 					hooks.needBuild.tapAsync(
 						"HttpUriPlugin",
 						(module, context, callback) => {
@@ -973,11 +1178,13 @@ Run build with un-frozen lockfile to automatically fix lockfile.`
 								module.resource &&
 								module.resource.startsWith(`${scheme}://`)
 							) {
-								getInfo(module.resource, (err, result) => {
+								getInfo(module.resource, (err, _result) => {
 									if (err) return callback(err);
+									const result = /** @type {Info} */ (_result);
 									if (
 										result.entry.integrity !==
-										module.buildInfo.resourceIntegrity
+										/** @type {BuildInfo} */
+										(module.buildInfo).resourceIntegrity
 									) {
 										return callback(null, true);
 									}
@@ -1003,7 +1210,9 @@ Run build with un-frozen lockfile to automatically fix lockfile.`
 						);
 
 						const writeDone = () => {
-							const nextOperation = inProgressWrite.shift();
+							const nextOperation =
+								/** @type {InProgressWriteItem[]} */
+								(inProgressWrite).shift();
 							if (nextOperation) {
 								nextOperation();
 							} else {
@@ -1019,19 +1228,25 @@ Run build with un-frozen lockfile to automatically fix lockfile.`
 								const lockfile = buffer
 									? Lockfile.parse(buffer.toString("utf-8"))
 									: new Lockfile();
-								for (const [key, value] of lockfileUpdates) {
+								for (const [key, value] of /** @type {LockfileUpdates} */ (
+									lockfileUpdates
+								)) {
 									lockfile.entries.set(key, value);
 								}
 								intermediateFs.writeFile(tempFile, lockfile.toString(), err => {
 									if (err) {
 										writeDone();
-										return intermediateFs.unlink(tempFile, () => callback(err));
+										return (
+											/** @type {NonNullable<IntermediateFileSystem["unlink"]>} */
+											(intermediateFs.unlink)(tempFile, () => callback(err))
+										);
 									}
 									intermediateFs.rename(tempFile, lockfileLocation, err => {
 										if (err) {
 											writeDone();
-											return intermediateFs.unlink(tempFile, () =>
-												callback(err)
+											return (
+												/** @type {NonNullable<IntermediateFileSystem["unlink"]>} */
+												(intermediateFs.unlink)(tempFile, () => callback(err))
 											);
 										}
 										writeDone();
@@ -1044,6 +1259,7 @@ Run build with un-frozen lockfile to automatically fix lockfile.`
 							inProgressWrite.push(runWrite);
 						} else {
 							inProgressWrite = [];
+							runWrite();
 						}
 					}
 				);