webpack 5.57.1 → 5.59.0

package/lib/config/defaults.js

@@ -19,6 +19,7 @@ const {
 /** @typedef {import("../../declarations/WebpackOptions").EntryDescription} EntryDescription */
 /** @typedef {import("../../declarations/WebpackOptions").EntryNormalized} Entry */
 /** @typedef {import("../../declarations/WebpackOptions").Experiments} Experiments */
+/** @typedef {import("../../declarations/WebpackOptions").ExperimentsNormalized} ExperimentsNormalized */
 /** @typedef {import("../../declarations/WebpackOptions").ExternalsPresets} ExternalsPresets */
 /** @typedef {import("../../declarations/WebpackOptions").ExternalsType} ExternalsType */
 /** @typedef {import("../../declarations/WebpackOptions").InfrastructureLogging} InfrastructureLogging */
@@ -161,6 +162,8 @@ const applyWebpackOptionsDefaults = options => {
 
 	applyExperimentsDefaults(options.experiments, { production, development });
 
+	const futureDefaults = options.experiments.futureDefaults;
+
 	F(options, "cache", () =>
 		development ? { type: /** @type {"memory"} */ ("memory") } : false
 	);
@@ -172,7 +175,10 @@ const applyWebpackOptionsDefaults = options => {
 	});
 	const cache = !!options.cache;
 
-	applySnapshotDefaults(options.snapshot, { production });
+	applySnapshotDefaults(options.snapshot, {
+		production,
+		futureDefaults
+	});
 
 	applyModuleDefaults(options.module, {
 		cache,
@@ -192,7 +198,7 @@ const applyWebpackOptionsDefaults = options => {
 		development,
 		entry: options.entry,
 		module: options.module,
-		futureDefaults: options.experiments.futureDefaults
+		futureDefaults
 	});
 
 	applyExternalsPresetsDefaults(options.externalsPresets, {
@@ -252,7 +258,7 @@ const applyWebpackOptionsDefaults = options => {
 };
 
 /**
- * @param {Experiments} experiments options
+ * @param {ExperimentsNormalized} experiments options
  * @param {Object} options options
  * @param {boolean} options.production is production
  * @param {boolean} options.development is development mode
@@ -265,14 +271,14 @@ const applyExperimentsDefaults = (experiments, { production, development }) => {
 	D(experiments, "outputModule", false);
 	D(experiments, "asset", false);
 	D(experiments, "layers", false);
-	D(experiments, "lazyCompilation", false);
-	D(experiments, "buildHttp", false);
+	D(experiments, "lazyCompilation", undefined);
+	D(experiments, "buildHttp", undefined);
 	D(experiments, "futureDefaults", false);
 	D(experiments, "cacheUnaffected", experiments.futureDefaults);
 
 	if (typeof experiments.buildHttp === "object") {
 		D(experiments.buildHttp, "frozen", production);
-		D(experiments.buildHttp, "upgrade", development);
+		D(experiments.buildHttp, "upgrade", false);
 	}
 };
 
@@ -348,49 +354,65 @@ const applyCacheDefaults = (
  * @param {SnapshotOptions} snapshot options
  * @param {Object} options options
  * @param {boolean} options.production is production
+ * @param {boolean} options.futureDefaults is future defaults enabled
  * @returns {void}
  */
-const applySnapshotDefaults = (snapshot, { production }) => {
-	A(snapshot, "managedPaths", () => {
-		if (process.versions.pnp === "3") {
-			const match =
-				/^(.+?)[\\/]cache[\\/]watchpack-npm-[^\\/]+\.zip[\\/]node_modules[\\/]/.exec(
-					require.resolve("watchpack")
-				);
-			if (match) {
-				return [path.resolve(match[1], "unplugged")];
-			}
-		} else {
-			const match = /^(.+?[\\/]node_modules)[\\/]/.exec(
-				// eslint-disable-next-line node/no-extraneous-require
-				require.resolve("watchpack")
-			);
-			if (match) {
-				return [match[1]];
-			}
-		}
-		return [];
-	});
-	A(snapshot, "immutablePaths", () => {
-		if (process.versions.pnp === "1") {
-			const match =
-				/^(.+?[\\/]v4)[\\/]npm-watchpack-[^\\/]+-[\da-f]{40}[\\/]node_modules[\\/]/.exec(
+const applySnapshotDefaults = (snapshot, { production, futureDefaults }) => {
+	if (futureDefaults) {
+		F(snapshot, "managedPaths", () =>
+			process.versions.pnp === "3"
+				? [
+						/^(.+?(?:[\\/]\.yarn[\\/]unplugged[\\/][^\\/]+)?[\\/]node_modules[\\/])/
+				  ]
+				: [/^(.+?[\\/]node_modules[\\/])/]
+		);
+		F(snapshot, "immutablePaths", () =>
+			process.versions.pnp === "3"
+				? [/^(.+?[\\/]cache[\\/][^\\/]+\.zip[\\/]node_modules[\\/])/]
+				: []
+		);
+	} else {
+		A(snapshot, "managedPaths", () => {
+			if (process.versions.pnp === "3") {
+				const match =
+					/^(.+?)[\\/]cache[\\/]watchpack-npm-[^\\/]+\.zip[\\/]node_modules[\\/]/.exec(
+						require.resolve("watchpack")
+					);
+				if (match) {
+					return [path.resolve(match[1], "unplugged")];
+				}
+			} else {
+				const match = /^(.+?[\\/]node_modules)[\\/]/.exec(
+					// eslint-disable-next-line node/no-extraneous-require
 					require.resolve("watchpack")
 				);
-			if (match) {
-				return [match[1]];
+				if (match) {
+					return [match[1]];
+				}
 			}
-		} else if (process.versions.pnp === "3") {
-			const match =
-				/^(.+?)[\\/]watchpack-npm-[^\\/]+\.zip[\\/]node_modules[\\/]/.exec(
-					require.resolve("watchpack")
-				);
-			if (match) {
-				return [match[1]];
+			return [];
+		});
+		A(snapshot, "immutablePaths", () => {
+			if (process.versions.pnp === "1") {
+				const match =
+					/^(.+?[\\/]v4)[\\/]npm-watchpack-[^\\/]+-[\da-f]{40}[\\/]node_modules[\\/]/.exec(
+						require.resolve("watchpack")
+					);
+				if (match) {
+					return [match[1]];
+				}
+			} else if (process.versions.pnp === "3") {
+				const match =
+					/^(.+?)[\\/]watchpack-npm-[^\\/]+\.zip[\\/]node_modules[\\/]/.exec(
+						require.resolve("watchpack")
+					);
+				if (match) {
+					return [match[1]];
+				}
 			}
-		}
-		return [];
-	});
+			return [];
+		});
+	}
 	F(snapshot, "resolveBuildDependencies", () => ({
 		timestamp: true,
 		hash: true

package/lib/config/normalization.js

@@ -174,7 +174,12 @@ const getNormalizedWebpackOptions = config => {
 		experiments: nestedConfig(config.experiments, experiments => ({
 			...experiments,
 			buildHttp: optionalNestedConfig(experiments.buildHttp, options =>
-				options === true ? {} : options
+				Array.isArray(options) ? { allowedUris: options } : options
+			),
+			lazyCompilation: optionalNestedConfig(
+				experiments.lazyCompilation,
+				options =>
+					options === true ? {} : options === false ? undefined : options
 			)
 		})),
 		externals: config.externals,

package/lib/logging/Logger.js

@@ -155,6 +155,7 @@ class WebpackLogger {
 		if (this[TIMERS_AGGREGATES_SYMBOL] === undefined) return;
 		const time = this[TIMERS_AGGREGATES_SYMBOL].get(label);
 		if (time === undefined) return;
+		this[TIMERS_AGGREGATES_SYMBOL].delete(label);
 		this[LOG_SYMBOL](LogType.time, [label, ...time]);
 	}
 }

package/lib/node/NodeTargetPlugin.js

@@ -19,6 +19,7 @@ const builtins = [
 	"constants",
 	"crypto",
 	"dgram",
+	"diagnostics_channel",
 	"dns",
 	"dns/promises",
 	"domain",

package/lib/optimize/ConcatenatedModule.js

@@ -564,7 +564,7 @@ const getFinalName = (
 				? `(0,${reference})`
 				: asiSafe === false
 				? `;(0,${reference})`
-				: `Object(${reference})`;
+				: `/*#__PURE__*/Object(${reference})`;
 		}
 		return reference;
 	}

package/lib/optimize/EnsureChunkConditionsPlugin.js

@@ -30,6 +30,7 @@ class EnsureChunkConditionsPlugin {
 					/** @type {Set<ChunkGroup>} */
 					const chunkGroups = new Set();
 					for (const module of compilation.modules) {
+						if (!module.hasChunkCondition()) continue;
 						for (const chunk of chunkGraph.getModuleChunksIterable(module)) {
 							if (!module.chunkCondition(chunk, compilation)) {
 								sourceChunks.add(chunk);

package/lib/optimize/SplitChunksPlugin.js

@@ -59,6 +59,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {ChunkFilterFunction=} chunksFilter
  * @property {boolean=} enforce
  * @property {SplitChunksSizes} minSize
+ * @property {SplitChunksSizes} minSizeReduction
  * @property {SplitChunksSizes} minRemainingSize
  * @property {SplitChunksSizes} enforceSizeThreshold
  * @property {SplitChunksSizes} maxAsyncSize
@@ -80,6 +81,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {GetName=} getName
  * @property {ChunkFilterFunction=} chunksFilter
  * @property {SplitChunksSizes} minSize
+ * @property {SplitChunksSizes} minSizeReduction
  * @property {SplitChunksSizes} minRemainingSize
  * @property {SplitChunksSizes} enforceSizeThreshold
  * @property {SplitChunksSizes} maxAsyncSize
@@ -132,6 +134,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {ChunkFilterFunction} chunksFilter
  * @property {string[]} defaultSizeTypes
  * @property {SplitChunksSizes} minSize
+ * @property {SplitChunksSizes} minSizeReduction
  * @property {SplitChunksSizes} minRemainingSize
  * @property {SplitChunksSizes} enforceSizeThreshold
  * @property {SplitChunksSizes} maxInitialSize
@@ -336,6 +339,21 @@ const checkMinSize = (sizes, minSize) => {
 	return true;
 };
 
+/**
+ * @param {SplitChunksSizes} sizes the sizes
+ * @param {SplitChunksSizes} minSizeReduction the min sizes
+ * @param {number} chunkCount number of chunks
+ * @returns {boolean} true if there are sizes and all existing sizes are at least `minSizeReduction`
+ */
+const checkMinSizeReduction = (sizes, minSizeReduction, chunkCount) => {
+	for (const key of Object.keys(minSizeReduction)) {
+		const size = sizes[key];
+		if (size === undefined || size === 0) continue;
+		if (size * chunkCount < minSizeReduction[key]) return false;
+	}
+	return true;
+};
+
 /**
  * @param {SplitChunksSizes} sizes the sizes
  * @param {SplitChunksSizes} minSize the min sizes
@@ -548,6 +566,10 @@ const checkModuleLayer = (test, module) => {
  */
 const createCacheGroupSource = (options, key, defaultSizeTypes) => {
 	const minSize = normalizeSizes(options.minSize, defaultSizeTypes);
+	const minSizeReduction = normalizeSizes(
+		options.minSizeReduction,
+		defaultSizeTypes
+	);
 	const maxSize = normalizeSizes(options.maxSize, defaultSizeTypes);
 	return {
 		key,
@@ -556,6 +578,7 @@ const createCacheGroupSource = (options, key, defaultSizeTypes) => {
 		chunksFilter: normalizeChunksFilter(options.chunks),
 		enforce: options.enforce,
 		minSize,
+		minSizeReduction,
 		minRemainingSize: mergeSizes(
 			normalizeSizes(options.minRemainingSize, defaultSizeTypes),
 			minSize
@@ -594,6 +617,10 @@ module.exports = class SplitChunksPlugin {
 		];
 		const fallbackCacheGroup = options.fallbackCacheGroup || {};
 		const minSize = normalizeSizes(options.minSize, defaultSizeTypes);
+		const minSizeReduction = normalizeSizes(
+			options.minSizeReduction,
+			defaultSizeTypes
+		);
 		const maxSize = normalizeSizes(options.maxSize, defaultSizeTypes);
 
 		/** @type {SplitChunksOptions} */
@@ -601,6 +628,7 @@ module.exports = class SplitChunksPlugin {
 			chunksFilter: normalizeChunksFilter(options.chunks || "all"),
 			defaultSizeTypes,
 			minSize,
+			minSizeReduction,
 			minRemainingSize: mergeSizes(
 				normalizeSizes(options.minRemainingSize, defaultSizeTypes),
 				minSize
@@ -668,6 +696,10 @@ module.exports = class SplitChunksPlugin {
 			cacheGroupSource.minSize,
 			cacheGroupSource.enforce ? undefined : this.options.minSize
 		);
+		const minSizeReduction = mergeSizes(
+			cacheGroupSource.minSizeReduction,
+			cacheGroupSource.enforce ? undefined : this.options.minSizeReduction
+		);
 		const minRemainingSize = mergeSizes(
 			cacheGroupSource.minRemainingSize,
 			cacheGroupSource.enforce ? undefined : this.options.minRemainingSize
@@ -681,6 +713,7 @@ module.exports = class SplitChunksPlugin {
 			priority: cacheGroupSource.priority || 0,
 			chunksFilter: cacheGroupSource.chunksFilter || this.options.chunksFilter,
 			minSize,
+			minSizeReduction,
 			minRemainingSize,
 			enforceSizeThreshold,
 			maxAsyncSize: mergeSizes(
@@ -774,9 +807,13 @@ module.exports = class SplitChunksPlugin {
 					const chunkIndexMap = new Map();
 					const ZERO = BigInt("0");
 					const ONE = BigInt("1");
-					let index = ONE;
+					const START = ONE << BigInt("31");
+					let index = START;
 					for (const chunk of chunks) {
-						chunkIndexMap.set(chunk, index);
+						chunkIndexMap.set(
+							chunk,
+							index | BigInt((Math.random() * 0x7fffffff) | 0)
+						);
 						index = index << ONE;
 					}
 					/**
@@ -793,7 +830,8 @@ module.exports = class SplitChunksPlugin {
 						let key =
 							chunkIndexMap.get(first) | chunkIndexMap.get(result.value);
 						while (!(result = iterator.next()).done) {
-							key = key | chunkIndexMap.get(result.value);
+							const raw = chunkIndexMap.get(result.value);
+							key = key ^ raw;
 						}
 						return key;
 					};
@@ -1239,6 +1277,14 @@ module.exports = class SplitChunksPlugin {
 					for (const [key, info] of chunksInfoMap) {
 						if (removeMinSizeViolatingModules(info)) {
 							chunksInfoMap.delete(key);
+						} else if (
+							!checkMinSizeReduction(
+								info.sizes,
+								info.cacheGroup.minSizeReduction,
+								info.chunks.size
+							)
+						) {
+							chunksInfoMap.delete(key);
 						}
 					}
 
@@ -1526,7 +1572,14 @@ module.exports = class SplitChunksPlugin {
 										chunksInfoMap.delete(key);
 										continue;
 									}
-									if (removeMinSizeViolatingModules(info)) {
+									if (
+										removeMinSizeViolatingModules(info) ||
+										!checkMinSizeReduction(
+											info.sizes,
+											info.cacheGroup.minSizeReduction,
+											info.chunks.size
+										)
+									) {
 										chunksInfoMap.delete(key);
 										continue;
 									}

package/lib/schemes/FileUriPlugin.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const { URL, fileURLToPath } = require("url");
+const { NormalModule } = require("..");
 
 /** @typedef {import("../Compiler")} Compiler */
 
@@ -32,6 +33,14 @@ class FileUriPlugin {
 						resourceData.resource = path + query + fragment;
 						return true;
 					});
+				const hooks = NormalModule.getCompilationHooks(compilation);
+				hooks.readResource
+					.for(undefined)
+					.tapAsync("FileUriPlugin", (loaderContext, callback) => {
+						const { resourcePath } = loaderContext;
+						loaderContext.addDependency(resourcePath);
+						loaderContext.fs.readFile(resourcePath, callback);
+					});
 			}
 		);
 	}

package/lib/schemes/HttpUriPlugin.js

@@ -5,12 +5,13 @@
 
 "use strict";
 
-const { resolve, extname, dirname } = require("path");
+const { extname, basename } = require("path");
 const { URL } = require("url");
 const { createGunzip, createBrotliDecompress, createInflate } = require("zlib");
 const NormalModule = require("../NormalModule");
+const createSchemaValidation = require("../util/create-schema-validation");
 const createHash = require("../util/createHash");
-const { mkdirp } = require("../util/fs");
+const { mkdirp, dirname, join } = require("../util/fs");
 const memoize = require("../util/memoize");
 
 /** @typedef {import("../../declarations/plugins/schemes/HttpUriPlugin").HttpUriPluginOptions} HttpUriPluginOptions */
@@ -19,6 +20,18 @@ const memoize = require("../util/memoize");
 const getHttp = memoize(() => require("http"));
 const getHttps = memoize(() => require("https"));
 
+/** @type {(() => void)[] | undefined} */
+let inProgressWrite = undefined;
+
+const validate = createSchemaValidation(
+	require("../../schemas/plugins/schemes/HttpUriPlugin.check.js"),
+	() => require("../../schemas/plugins/schemes/HttpUriPlugin.json"),
+	{
+		name: "Http Uri Plugin",
+		baseDataPath: "options"
+	}
+);
+
 const toSafePath = str =>
 	str
 		.replace(/^[^a-zA-Z0-9]+|[^a-zA-Z0-9]+$/g, "")
@@ -104,7 +117,6 @@ class Lockfile {
 		this.version = 1;
 		/** @type {Map<string, LockfileEntry | "ignore" | "no-cache">} */
 		this.entries = new Map();
-		this.outdated = false;
 	}
 
 	static parse(content) {
@@ -251,25 +263,17 @@ const cachedWithKey = (fn, forceFn = fn) => {
 	return resultFn;
 };
 
-/**
- * @typedef {Object} HttpUriPluginAdvancedOptions
- * @property {string | typeof import("../util/Hash")=} hashFunction
- * @property {string=} hashDigest
- * @property {number=} hashDigestLength
- */
-
 class HttpUriPlugin {
 	/**
-	 * @param {HttpUriPluginOptions & HttpUriPluginAdvancedOptions} options options
+	 * @param {HttpUriPluginOptions} options options
 	 */
-	constructor(options = {}) {
+	constructor(options) {
+		validate(options);
 		this._lockfileLocation = options.lockfileLocation;
 		this._cacheLocation = options.cacheLocation;
 		this._upgrade = options.upgrade;
 		this._frozen = options.frozen;
-		this._hashFunction = options.hashFunction;
-		this._hashDigest = options.hashDigest;
-		this._hashDigestLength = options.hashDigestLength;
+		this._allowedUris = options.allowedUris;
 	}
 
 	/**
@@ -299,7 +303,8 @@ class HttpUriPlugin {
 				const logger = compilation.getLogger("webpack.HttpUriPlugin");
 				const lockfileLocation =
 					this._lockfileLocation ||
-					resolve(
+					join(
+						intermediateFs,
 						compiler.context,
 						compiler.name
 							? `${toSafePath(compiler.name)}.webpack.lock`
@@ -311,11 +316,10 @@ class HttpUriPlugin {
 						: lockfileLocation + ".data";
 				const upgrade = this._upgrade || false;
 				const frozen = this._frozen || false;
-				const hashFunction = this._hashFunction || "sha512";
-				const hashDigest =
-					this._hashDigest || compilation.outputOptions.hashDigest;
-				const hashDigestLength =
-					this._hashDigestLength || compilation.outputOptions.hashDigestLength;
+				const hashFunction = "sha512";
+				const hashDigest = "hex";
+				const hashDigestLength = 20;
+				const allowedUris = this._allowedUris;
 
 				let warnedAboutEol = false;
 
@@ -400,11 +404,13 @@ class HttpUriPlugin {
 					}
 				);
 
-				let outdatedLockfile = undefined;
+				/** @type {Map<string, LockfileEntry | "ignore" | "no-cache"> | undefined} */
+				let lockfileUpdates = undefined;
 				const storeLockEntry = (lockfile, url, entry) => {
 					const oldEntry = lockfile.entries.get(url);
+					if (lockfileUpdates === undefined) lockfileUpdates = new Map();
+					lockfileUpdates.set(url, entry);
 					lockfile.entries.set(url, entry);
-					outdatedLockfile = lockfile;
 					if (!oldEntry) {
 						logger.log(`${url} added to lockfile`);
 					} else if (typeof oldEntry === "string") {
@@ -440,8 +446,8 @@ class HttpUriPlugin {
 						if (!cacheLocation || !result.content)
 							return callback(null, result);
 						const key = getCacheKey(result.entry.resolved);
-						const filePath = resolve(cacheLocation, key);
-						mkdirp(intermediateFs, dirname(filePath), err => {
+						const filePath = join(intermediateFs, cacheLocation, key);
+						mkdirp(intermediateFs, dirname(intermediateFs, filePath), err => {
 							if (err) return callback(err);
 							intermediateFs.writeFile(filePath, result.content, err => {
 								if (err) return callback(err);
@@ -671,6 +677,19 @@ class HttpUriPlugin {
 						(url, callback) => fetchContentRaw(url, undefined, callback)
 					);
 
+					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;
+							}
+						}
+						return false;
+					};
+
 					const getInfo = cachedWithKey(
 						/**
 						 * @param {string} url the url
@@ -678,6 +697,15 @@ class HttpUriPlugin {
 						 * @returns {void}
 						 */
 						(url, callback) => {
+							if (!isAllowed(url)) {
+								return callback(
+									new Error(
+										`${url} doesn't match the allowedUris policy. These URIs are allowed:\n${allowedUris
+											.map(uri => ` - ${uri}`)
+											.join("\n")}`
+									)
+								);
+							}
 							getLockfile((err, lockfile) => {
 								if (err) return callback(err);
 								const entryOrString = lockfile.entries.get(url);
@@ -789,7 +817,7 @@ Remove this line from the lockfile to force upgrading.`
 									// When there is a lockfile cache
 									// we read the content from there
 									const key = getCacheKey(entry.resolved);
-									const filePath = resolve(cacheLocation, key);
+									const filePath = join(intermediateFs, cacheLocation, key);
 									fs.readFile(filePath, (err, result) => {
 										const content = /** @type {Buffer} */ (result);
 										if (err) {
@@ -934,6 +962,7 @@ Run build with un-frozen lockfile to automatically fix lockfile.`
 						.tapAsync("HttpUriPlugin", (resource, module, callback) => {
 							return getInfo(resource, (err, result) => {
 								if (err) return callback(err);
+								module.buildInfo.resourceIntegrity = result.entry.integrity;
 								callback(null, result.content);
 							});
 						});
@@ -963,12 +992,59 @@ Run build with un-frozen lockfile to automatically fix lockfile.`
 				compilation.hooks.finishModules.tapAsync(
 					"HttpUriPlugin",
 					(modules, callback) => {
-						if (!outdatedLockfile) return callback();
-						intermediateFs.writeFile(
-							lockfileLocation,
-							outdatedLockfile.toString(),
-							callback
+						if (!lockfileUpdates) return callback();
+						const ext = extname(lockfileLocation);
+						const tempFile = join(
+							intermediateFs,
+							dirname(intermediateFs, lockfileLocation),
+							`.${basename(lockfileLocation, ext)}.${
+								(Math.random() * 10000) | 0
+							}${ext}`
 						);
+
+						const writeDone = () => {
+							const nextOperation = inProgressWrite.shift();
+							if (nextOperation) {
+								nextOperation();
+							} else {
+								inProgressWrite = undefined;
+							}
+						};
+						const runWrite = () => {
+							intermediateFs.readFile(lockfileLocation, (err, buffer) => {
+								if (err && err.code !== "ENOENT") {
+									writeDone();
+									return callback(err);
+								}
+								const lockfile = buffer
+									? Lockfile.parse(buffer.toString("utf-8"))
+									: new Lockfile();
+								for (const [key, value] of lockfileUpdates) {
+									lockfile.entries.set(key, value);
+								}
+								intermediateFs.writeFile(tempFile, lockfile.toString(), err => {
+									if (err) {
+										writeDone();
+										return intermediateFs.unlink(tempFile, () => callback(err));
+									}
+									intermediateFs.rename(tempFile, lockfileLocation, err => {
+										if (err) {
+											writeDone();
+											return intermediateFs.unlink(tempFile, () =>
+												callback(err)
+											);
+										}
+										writeDone();
+										callback();
+									});
+								});
+							});
+						};
+						if (inProgressWrite) {
+							inProgressWrite.push(runWrite);
+						} else {
+							inProgressWrite = [];
+						}
 					}
 				);
 			}

package/lib/serialization/Serializer.js

@@ -16,9 +16,7 @@ class Serializer {
 		let current = obj;
 		for (const middleware of this.serializeMiddlewares) {
 			if (current && typeof current.then === "function") {
-				current = current.then(
-					data => data && middleware.serialize(data, context)
-				);
+				current = current.then(data => data && middleware.serialize(data, ctx));
 			} else if (current) {
 				try {
 					current = middleware.serialize(current, ctx);
@@ -36,7 +34,7 @@ class Serializer {
 		let current = value;
 		for (const middleware of this.deserializeMiddlewares) {
 			if (current && typeof current.then === "function") {
-				current = current.then(data => middleware.deserialize(data, context));
+				current = current.then(data => middleware.deserialize(data, ctx));
 			} else {
 				current = middleware.deserialize(current, ctx);
 			}

package/lib/util/fs.js

@@ -83,6 +83,8 @@ const path = require("path");
  * @returns {Watcher} a watcher
  */
 
+// TODO webpack 6 make optional methods required
+
 /**
  * @typedef {Object} OutputFileSystem
  * @property {function(string, Buffer|string, Callback): void} writeFile