webpack 5.37.0 → 5.39.0

package/lib/optimize/RealContentHashPlugin.js

@@ -194,24 +194,22 @@ class RealContentHashPlugin {
 								cacheAnalyse.getLazyHashedEtag(source),
 								Array.from(hashes).join("|")
 							);
-							[
-								asset.referencedHashes,
-								asset.ownHashes
-							] = await cacheAnalyse.providePromise(name, etag, () => {
-								const referencedHashes = new Set();
-								let ownHashes = new Set();
-								const inContent = content.match(hashRegExp);
-								if (inContent) {
-									for (const hash of inContent) {
-										if (hashes.has(hash)) {
-											ownHashes.add(hash);
-											continue;
+							[asset.referencedHashes, asset.ownHashes] =
+								await cacheAnalyse.providePromise(name, etag, () => {
+									const referencedHashes = new Set();
+									let ownHashes = new Set();
+									const inContent = content.match(hashRegExp);
+									if (inContent) {
+										for (const hash of inContent) {
+											if (hashes.has(hash)) {
+												ownHashes.add(hash);
+												continue;
+											}
+											referencedHashes.add(hash);
 										}
-										referencedHashes.add(hash);
 									}
-								}
-								return [referencedHashes, ownHashes];
-							});
+									return [referencedHashes, ownHashes];
+								});
 						})
 					);
 					const getDependencies = hash => {

package/lib/optimize/SideEffectsFlagPlugin.js

@@ -86,11 +86,12 @@ class SideEffectsFlagPlugin {
 								if (module.factoryMeta === undefined) {
 									module.factoryMeta = {};
 								}
-								const hasSideEffects = SideEffectsFlagPlugin.moduleHasSideEffects(
-									resolveData.relativePath,
-									sideEffects,
-									cache
-								);
+								const hasSideEffects =
+									SideEffectsFlagPlugin.moduleHasSideEffects(
+										resolveData.relativePath,
+										sideEffects,
+										cache
+									);
 								module.factoryMeta.sideEffectFree = !hasSideEffects;
 							}
 						}

package/lib/optimize/SplitChunksPlugin.js

@@ -162,7 +162,10 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 
 const defaultGetName = /** @type {GetName} */ (() => {});
 
-const deterministicGroupingForModules = /** @type {function(DeterministicGroupingOptionsForModule): DeterministicGroupingGroupedItemsForModule[]} */ (deterministicGrouping);
+const deterministicGroupingForModules =
+	/** @type {function(DeterministicGroupingOptionsForModule): DeterministicGroupingGroupedItemsForModule[]} */ (
+		deterministicGrouping
+	);
 
 /** @type {WeakMap<Module, string>} */
 const getKeyCache = new WeakMap();
@@ -173,9 +176,11 @@ const getKeyCache = new WeakMap();
  * @returns {string} hashed filename
  */
 const hashFilename = (name, outputOptions) => {
-	const digest = /** @type {string} */ (createHash(outputOptions.hashFunction)
-		.update(name)
-		.digest(outputOptions.hashDigest));
+	const digest = /** @type {string} */ (
+		createHash(outputOptions.hashFunction)
+			.update(name)
+			.digest(outputOptions.hashDigest)
+	);
 	return digest.slice(0, 8);
 };
 
@@ -939,10 +944,8 @@ module.exports = class SplitChunksPlugin {
 					const getCombinations = key => getCombinationsFactory()(key);
 
 					const getExportsCombinationsFactory = memoize(() => {
-						const {
-							chunkSetsInGraph,
-							singleChunkSets
-						} = getExportsChunkSetsInGraph();
+						const { chunkSetsInGraph, singleChunkSets } =
+							getExportsChunkSetsInGraph();
 						return createGetCombinations(
 							chunkSetsInGraph,
 							singleChunkSets,
@@ -1182,13 +1185,8 @@ module.exports = class SplitChunksPlugin {
 									chunkCombination instanceof Chunk ? 1 : chunkCombination.size;
 								if (count < cacheGroup.minChunks) continue;
 								// Select chunks by configuration
-								const {
-									chunks: selectedChunks,
-									key: selectedChunksKey
-								} = getSelectedChunks(
-									chunkCombination,
-									cacheGroup.chunksFilter
-								);
+								const { chunks: selectedChunks, key: selectedChunksKey } =
+									getSelectedChunks(chunkCombination, cacheGroup.chunksFilter);
 
 								addModuleToChunksInfoMap(
 									cacheGroup,

package/lib/performance/AssetsOverSizeLimitWarning.js

@@ -28,7 +28,5 @@ Assets: ${assetLists}`);
 
 		this.name = "AssetsOverSizeLimitWarning";
 		this.assets = assetsOverSizeLimit;
-
-		Error.captureStackTrace(this, this.constructor);
 	}
 };

package/lib/performance/EntrypointsOverSizeLimitWarning.js

@@ -31,7 +31,5 @@ Entrypoints:${entrypointList}\n`);
 
 		this.name = "EntrypointsOverSizeLimitWarning";
 		this.entrypoints = entrypoints;
-
-		Error.captureStackTrace(this, this.constructor);
 	}
 };

package/lib/performance/NoAsyncChunksWarning.js

@@ -16,7 +16,5 @@ module.exports = class NoAsyncChunksWarning extends WebpackError {
 		);
 
 		this.name = "NoAsyncChunksWarning";
-
-		Error.captureStackTrace(this, this.constructor);
 	}
 };

package/lib/runtime/EnsureChunkRuntimeModule.js

@@ -26,14 +26,15 @@ class EnsureChunkRuntimeModule extends RuntimeModule {
 				`${handlers} = {};`,
 				"// This file contains only the entry chunk.",
 				"// The chunk loading function for additional chunks",
-				`${
-					RuntimeGlobals.ensureChunk
-				} = ${runtimeTemplate.basicFunction("chunkId", [
-					`return Promise.all(Object.keys(${handlers}).reduce(${runtimeTemplate.basicFunction(
-						"promises, key",
-						[`${handlers}[key](chunkId, promises);`, "return promises;"]
-					)}, []));`
-				])};`
+				`${RuntimeGlobals.ensureChunk} = ${runtimeTemplate.basicFunction(
+					"chunkId",
+					[
+						`return Promise.all(Object.keys(${handlers}).reduce(${runtimeTemplate.basicFunction(
+							"promises, key",
+							[`${handlers}[key](chunkId, promises);`, "return promises;"]
+						)}, []));`
+					]
+				)};`
 			]);
 		} else {
 			// There ensureChunk is used somewhere in the tree, so we need an empty requireEnsure

package/lib/runtime/LoadScriptRuntimeModule.js

@@ -65,9 +65,8 @@ class LoadScriptRuntimeModule extends HelperRuntimeModule {
 		} = outputOptions;
 		const fn = RuntimeGlobals.loadScript;
 
-		const { createScript } = LoadScriptRuntimeModule.getCompilationHooks(
-			compilation
-		);
+		const { createScript } =
+			LoadScriptRuntimeModule.getCompilationHooks(compilation);
 
 		const code = Template.asString([
 			"script = document.createElement('script');",

package/lib/runtime/OnChunksLoadedRuntimeModule.js

@@ -21,49 +21,50 @@ class OnChunksLoadedRuntimeModule extends RuntimeModule {
 		const { runtimeTemplate } = compilation;
 		return Template.asString([
 			"var deferred = [];",
-			`${
-				RuntimeGlobals.onChunksLoaded
-			} = ${runtimeTemplate.basicFunction("result, chunkIds, fn, priority", [
-				"if(chunkIds) {",
-				Template.indent([
-					"priority = priority || 0;",
-					"for(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];",
-					"deferred[i] = [chunkIds, fn, priority];",
-					"return;"
-				]),
-				"}",
-				"var notFulfilled = Infinity;",
-				"for (var i = 0; i < deferred.length; i++) {",
-				Template.indent([
-					runtimeTemplate.destructureArray(
-						["chunkIds", "fn", "priority"],
-						"deferred[i]"
-					),
-					"var fulfilled = true;",
-					"for (var j = 0; j < chunkIds.length; j++) {",
+			`${RuntimeGlobals.onChunksLoaded} = ${runtimeTemplate.basicFunction(
+				"result, chunkIds, fn, priority",
+				[
+					"if(chunkIds) {",
 					Template.indent([
-						`if ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(${
-							RuntimeGlobals.onChunksLoaded
-						}).every(${runtimeTemplate.returningFunction(
-							`${RuntimeGlobals.onChunksLoaded}[key](chunkIds[j])`,
-							"key"
-						)})) {`,
-						Template.indent(["chunkIds.splice(j--, 1);"]),
-						"} else {",
+						"priority = priority || 0;",
+						"for(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];",
+						"deferred[i] = [chunkIds, fn, priority];",
+						"return;"
+					]),
+					"}",
+					"var notFulfilled = Infinity;",
+					"for (var i = 0; i < deferred.length; i++) {",
+					Template.indent([
+						runtimeTemplate.destructureArray(
+							["chunkIds", "fn", "priority"],
+							"deferred[i]"
+						),
+						"var fulfilled = true;",
+						"for (var j = 0; j < chunkIds.length; j++) {",
 						Template.indent([
-							"fulfilled = false;",
-							"if(priority < notFulfilled) notFulfilled = priority;"
+							`if ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(${
+								RuntimeGlobals.onChunksLoaded
+							}).every(${runtimeTemplate.returningFunction(
+								`${RuntimeGlobals.onChunksLoaded}[key](chunkIds[j])`,
+								"key"
+							)})) {`,
+							Template.indent(["chunkIds.splice(j--, 1);"]),
+							"} else {",
+							Template.indent([
+								"fulfilled = false;",
+								"if(priority < notFulfilled) notFulfilled = priority;"
+							]),
+							"}"
 						]),
+						"}",
+						"if(fulfilled) {",
+						Template.indent(["deferred.splice(i--, 1)", "result = fn();"]),
 						"}"
 					]),
 					"}",
-					"if(fulfilled) {",
-					Template.indent(["deferred.splice(i--, 1)", "result = fn();"]),
-					"}"
-				]),
-				"}",
-				"return result;"
-			])};`
+					"return result;"
+				]
+			)};`
 		]);
 	}
 }

package/lib/schemes/DataUriPlugin.js

@@ -6,10 +6,25 @@
 "use strict";
 
 const NormalModule = require("../NormalModule");
-const { getMimetype, decodeDataURI } = require("../util/DataURI");
 
 /** @typedef {import("../Compiler")} Compiler */
 
+// data URL scheme: "data:text/javascript;charset=utf-8;base64,some-string"
+// http://www.ietf.org/rfc/rfc2397.txt
+const URIRegEx = /^data:(?:[^;,]+)?(?:(?:;[^;,]+)*?)(;base64)?,(.*)$/i;
+const URIMetaRegEx = /^data:([^;,]+)?(?:(?:;[^;,]+)*?)(?:;(base64))?,/i;
+
+const decodeDataURI = uri => {
+	const match = URIRegEx.exec(uri);
+	if (!match) return null;
+
+	const isBase64 = match[1];
+	const body = match[2];
+	return isBase64
+		? Buffer.from(body, "base64")
+		: Buffer.from(decodeURIComponent(body), "ascii");
+};
+
 class DataUriPlugin {
 	/**
 	 * Apply the plugin
@@ -23,7 +38,11 @@ class DataUriPlugin {
 				normalModuleFactory.hooks.resolveForScheme
 					.for("data")
 					.tap("DataUriPlugin", resourceData => {
-						resourceData.data.mimetype = getMimetype(resourceData.resource);
+						const match = URIMetaRegEx.exec(resourceData.resource);
+						if (match) {
+							resourceData.data.mimetype = match[1] || "";
+							resourceData.data.encoding = match[2] || false;
+						}
 					});
 				NormalModule.getCompilationHooks(compilation)
 					.readResourceForScheme.for("data")

package/lib/serialization/BinaryMiddleware.js

@@ -100,6 +100,9 @@ const F64_SIZE = 8;
 const MEASURE_START_OPERATION = Symbol("MEASURE_START_OPERATION");
 const MEASURE_END_OPERATION = Symbol("MEASURE_END_OPERATION");
 
+/** @typedef {typeof MEASURE_START_OPERATION} MEASURE_START_OPERATION_TYPE */
+/** @typedef {typeof MEASURE_END_OPERATION} MEASURE_END_OPERATION_TYPE */
+
 const identifyNumber = n => {
 	if (n === (n | 0)) {
 		if (n <= 127 && n >= -128) return 0;
@@ -201,9 +204,8 @@ class BinaryMiddleware extends SerializerMiddleware {
 						if (!SerializerMiddleware.isLazy(thing))
 							throw new Error("Unexpected function " + thing);
 						/** @type {SerializedType | (() => SerializedType)} */
-						let serializedData = SerializerMiddleware.getLazySerializedValue(
-							thing
-						);
+						let serializedData =
+							SerializerMiddleware.getLazySerializedValue(thing);
 						if (serializedData === undefined) {
 							if (SerializerMiddleware.isLazy(thing, this)) {
 								const data = this._serialize(thing(), context);

package/lib/serialization/FileMiddleware.js

@@ -135,7 +135,9 @@ const serialize = async (middleware, data, name, writeFile) => {
 	const backgroundJobs = [];
 	const resolvedData = (
 		await Promise.all(
-			/** @type {Promise<Buffer[] | Buffer | SerializeResult>[]} */ (processedData)
+			/** @type {Promise<Buffer[] | Buffer | SerializeResult>[]} */ (
+				processedData
+			)
 		)
 	).map(item => {
 		if (Array.isArray(item) || Buffer.isBuffer(item)) return item;

package/lib/serialization/ObjectMiddleware.js

@@ -450,9 +450,8 @@ class ObjectMiddleware extends SerializerMiddleware {
 					);
 				}
 
-				const { request, name, serializer } = ObjectMiddleware.getSerializerFor(
-					item
-				);
+				const { request, name, serializer } =
+					ObjectMiddleware.getSerializerFor(item);
 				const key = `${request}/${name}`;
 				const lastIndex = objectTypeLookup.get(key);
 
@@ -500,9 +499,8 @@ class ObjectMiddleware extends SerializerMiddleware {
 				if (!SerializerMiddleware.isLazy(item))
 					throw new Error("Unexpected function " + item);
 				/** @type {SerializedType} */
-				const serializedData = SerializerMiddleware.getLazySerializedValue(
-					item
-				);
+				const serializedData =
+					SerializerMiddleware.getLazySerializedValue(item);
 				if (serializedData !== undefined) {
 					if (typeof serializedData === "function") {
 						result.push(serializedData);
@@ -539,7 +537,13 @@ class ObjectMiddleware extends SerializerMiddleware {
 			// This happens because the optimized code v8 generates
 			// is optimized for our "ctx.write" method so it will reference
 			// it from e. g. Dependency.prototype.serialize -(IC)-> ctx.write
-			data = result = referenceable = bufferDedupeMap = objectTypeLookup = ctx = undefined;
+			data =
+				result =
+				referenceable =
+				bufferDedupeMap =
+				objectTypeLookup =
+				ctx =
+					undefined;
 		}
 	}
 

package/lib/stats/DefaultStatsFactoryPlugin.js

@@ -10,7 +10,6 @@ const ModuleDependency = require("../dependencies/ModuleDependency");
 const formatLocation = require("../formatLocation");
 const { LogType } = require("../logging/Logger");
 const AggressiveSplittingPlugin = require("../optimize/AggressiveSplittingPlugin");
-const ConcatenatedModule = require("../optimize/ConcatenatedModule");
 const SizeLimitsPlugin = require("../performance/SizeLimitsPlugin");
 const { countIterable } = require("../util/IterableHelpers");
 const {
@@ -1078,9 +1077,8 @@ const SIMPLE_EXTRACTORS = {
 			const { compilation, type } = context;
 			const built = compilation.builtModules.has(module);
 			const codeGenerated = compilation.codeGeneratedModules.has(module);
-			const buildTimeExecuted = compilation.buildTimeExecutedModules.has(
-				module
-			);
+			const buildTimeExecuted =
+				compilation.buildTimeExecutedModules.has(module);
 			/** @type {{[x: string]: number}} */
 			const sizes = {};
 			for (const sourceType of module.getSourceTypes()) {
@@ -1228,11 +1226,13 @@ const SIMPLE_EXTRACTORS = {
 		},
 		nestedModules: (object, module, context, options, factory) => {
 			const { type } = context;
-			if (module instanceof ConcatenatedModule) {
-				const modules = module.modules;
+			const innerModules = /** @type {Module & { modules?: Module[] }} */ (
+				module
+			).modules;
+			if (Array.isArray(innerModules)) {
 				const groupedModules = factory.create(
 					`${type.slice(0, -8)}.modules`,
-					modules,
+					innerModules,
 					context
 				);
 				const limited = spaceLimited(

package/lib/stats/DefaultStatsPrinterPlugin.js

@@ -818,9 +818,8 @@ const SIMPLE_ITEMS_JOINER = {
 	"asset.chunkNames": itemsJoinCommaBracketsWithName("name"),
 	"asset.auxiliaryChunkNames": itemsJoinCommaBracketsWithName("auxiliary name"),
 	"asset.chunkIdHints": itemsJoinCommaBracketsWithName("id hint"),
-	"asset.auxiliaryChunkIdHints": itemsJoinCommaBracketsWithName(
-		"auxiliary id hint"
-	),
+	"asset.auxiliaryChunkIdHints":
+		itemsJoinCommaBracketsWithName("auxiliary id hint"),
 	"module.chunks": itemsJoinOneLine,
 	"module.issuerPath": items =>
 		items
@@ -912,11 +911,13 @@ const joinExplicitNewLine = (items, indenter) => {
 		.trim();
 };
 
-const joinError = error => (items, { red, yellow }) =>
-	`${error ? red("ERROR") : yellow("WARNING")} in ${joinExplicitNewLine(
-		items,
-		""
-	)}`;
+const joinError =
+	error =>
+	(items, { red, yellow }) =>
+		`${error ? red("ERROR") : yellow("WARNING")} in ${joinExplicitNewLine(
+			items,
+			""
+		)}`;
 
 /** @type {Record<string, (items: ({ element: string, content: string })[], context: StatsPrinterContext) => string>} */
 const SIMPLE_ELEMENT_JOINERS = {
@@ -1130,7 +1131,8 @@ const AVAILABLE_FORMATS = {
 				format: red
 			},
 			{
-				regExp: /\b(error|failed|unexpected|invalid|not found|not supported|not available|not possible|not implemented|doesn't support|conflict|conflicting|not existing|duplicate)\b/gi,
+				regExp:
+					/\b(error|failed|unexpected|invalid|not found|not supported|not available|not possible|not implemented|doesn't support|conflict|conflicting|not existing|duplicate)\b/gi,
 				format: red
 			}
 		];

package/lib/stats/StatsFactory.js

@@ -71,7 +71,8 @@ class StatsFactory {
 			getItemFactory: new HookMap(() => new SyncBailHook(["item", "context"]))
 		});
 		const hooks = this.hooks;
-		this._caches = /** @type {Record<keyof typeof hooks, Map<string, SyncBailHook<[any[], StatsFactoryContext]>[]>>} */ ({});
+		this._caches =
+			/** @type {Record<keyof typeof hooks, Map<string, SyncBailHook<[any[], StatsFactoryContext]>[]>>} */ ({});
 		for (const key of Object.keys(hooks)) {
 			this._caches[key] = new Map();
 		}

package/lib/stats/StatsPrinter.js

@@ -87,9 +87,9 @@ class StatsPrinter {
 	 * @returns {T[]} hooks
 	 */
 	_getAllLevelHooks(hookMap, type) {
-		let cache = /** @type {Map<string, T[]>} */ (this._levelHookCache.get(
-			hookMap
-		));
+		let cache = /** @type {Map<string, T[]>} */ (
+			this._levelHookCache.get(hookMap)
+		);
 		if (cache === undefined) {
 			cache = new Map();
 			this._levelHookCache.set(hookMap, cache);

package/lib/util/LazyBucketSortedSet.js

@@ -164,9 +164,9 @@ class LazyBucketSortedSet {
 				}
 			};
 		} else {
-			const oldEntry = /** @type {LazyBucketSortedSet<T, any>} */ (this._map.get(
-				key
-			));
+			const oldEntry = /** @type {LazyBucketSortedSet<T, any>} */ (
+				this._map.get(key)
+			);
 			const finishUpdate = oldEntry.startUpdate(item);
 			return remove => {
 				if (remove) {

package/lib/util/cleverMerge.js

@@ -539,7 +539,9 @@ const resolveByProperty = (obj, byProperty, ...values) => {
 	}
 	const { [byProperty]: _byValue, ..._remaining } = /** @type {object} */ (obj);
 	const remaining = /** @type {T} */ (_remaining);
-	const byValue = /** @type {Record<string, T> | function(...any[]): T} */ (_byValue);
+	const byValue = /** @type {Record<string, T> | function(...any[]): T} */ (
+		_byValue
+	);
 	if (typeof byValue === "object") {
 		const key = values[0];
 		if (key in byValue) {

package/lib/util/comparators.js

@@ -68,9 +68,8 @@ const compareModulesById = (chunkGraph, a, b) => {
 	return compareIds(chunkGraph.getModuleId(a), chunkGraph.getModuleId(b));
 };
 /** @type {ParameterizedComparator<ChunkGraph, Module>} */
-exports.compareModulesById = createCachedParameterizedComparator(
-	compareModulesById
-);
+exports.compareModulesById =
+	createCachedParameterizedComparator(compareModulesById);
 
 /**
  * @param {number} a number
@@ -138,9 +137,10 @@ const compareModulesByPostOrderIndexOrIdentifier = (moduleGraph, a, b) => {
 	return compareIds(a.identifier(), b.identifier());
 };
 /** @type {ParameterizedComparator<ModuleGraph, Module>} */
-exports.compareModulesByPostOrderIndexOrIdentifier = createCachedParameterizedComparator(
-	compareModulesByPostOrderIndexOrIdentifier
-);
+exports.compareModulesByPostOrderIndexOrIdentifier =
+	createCachedParameterizedComparator(
+		compareModulesByPostOrderIndexOrIdentifier
+	);
 
 /**
  * @param {ModuleGraph} moduleGraph the module graph
@@ -157,9 +157,10 @@ const compareModulesByPreOrderIndexOrIdentifier = (moduleGraph, a, b) => {
 	return compareIds(a.identifier(), b.identifier());
 };
 /** @type {ParameterizedComparator<ModuleGraph, Module>} */
-exports.compareModulesByPreOrderIndexOrIdentifier = createCachedParameterizedComparator(
-	compareModulesByPreOrderIndexOrIdentifier
-);
+exports.compareModulesByPreOrderIndexOrIdentifier =
+	createCachedParameterizedComparator(
+		compareModulesByPreOrderIndexOrIdentifier
+	);
 
 /**
  * @param {ChunkGraph} chunkGraph the chunk graph
@@ -284,10 +285,9 @@ const concatComparators = (c1, c2, ...cRest) => {
 		const [c3, ...cRest2] = cRest;
 		return concatComparators(c1, concatComparators(c2, c3, ...cRest2));
 	}
-	const cacheEntry = /** @type {Comparator<T>} */ (concatComparatorsCache.get(
-		c1,
-		c2
-	));
+	const cacheEntry = /** @type {Comparator<T>} */ (
+		concatComparatorsCache.get(c1, c2)
+	);
 	if (cacheEntry !== undefined) return cacheEntry;
 	/**
 	 * @param {T} a first value

package/lib/util/createHash.js

@@ -67,6 +67,7 @@ class BulkUpdateDecorator extends Hash {
 	 */
 	digest(encoding) {
 		let digestCache;
+		const buffer = this.buffer;
 		if (this.hash === undefined) {
 			// short data for hash, we can use caching
 			const cacheKey = `${this.hashKey}-${encoding}`;
@@ -74,18 +75,18 @@ class BulkUpdateDecorator extends Hash {
 			if (digestCache === undefined) {
 				digestCache = digestCaches[cacheKey] = new Map();
 			}
-			const cacheEntry = digestCache.get(this.buffer);
+			const cacheEntry = digestCache.get(buffer);
 			if (cacheEntry !== undefined) return cacheEntry;
 			this.hash = this.hashFactory();
 		}
-		if (this.buffer.length > 0) {
-			this.hash.update(this.buffer);
+		if (buffer.length > 0) {
+			this.hash.update(buffer);
 		}
 		const digestResult = this.hash.digest(encoding);
 		const result =
 			typeof digestResult === "string" ? digestResult : digestResult.toString();
 		if (digestCache !== undefined) {
-			digestCache.set(this.buffer, result);
+			digestCache.set(buffer, result);
 		}
 		return result;
 	}

package/lib/util/identifier.js

@@ -244,7 +244,8 @@ const _absolutify = (context, request) => {
 const absolutify = makeCacheable(_absolutify);
 exports.absolutify = absolutify;
 
-const PATH_QUERY_FRAGMENT_REGEXP = /^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
+const PATH_QUERY_FRAGMENT_REGEXP =
+	/^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
 
 /** @typedef {{ resource: string, path: string, query: string, fragment: string }} ParsedResource */