@depup/webpack 5.109.2-depup.0 → 5.110.3-depup.0

package/lib/buildChunkGraph.js

@@ -6,22 +6,26 @@
 "use strict";
 
 const ModuleGraphConnection = require("./ModuleGraphConnection");
-const AsyncDependencyToInitialChunkError = require("./errors/AsyncDependencyToInitialChunkError");
+const memoize = require("./util/memoize");
+
 const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
 
-/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./ChunkGroup")} ChunkGroup */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Entrypoint")} Entrypoint */
-/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("./logging/Logger").Logger} Logger */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+const getAsyncDependencyToInitialChunkError = memoize(() =>
+	require("./errors/AsyncDependencyToInitialChunkError")
+);
+
+/** @import AsyncDependenciesBlock from "./AsyncDependenciesBlock" */
+/** @import Chunk from "./Chunk" */
+/** @import ChunkGroup from "./ChunkGroup" */
+/** @import Compilation from "./Compilation" */
+/** @import DependenciesBlock from "./DependenciesBlock" */
+/** @import { DependencyLocation } from "./Dependency" */
+/** @import Entrypoint, { EntryOptions } from "./Entrypoint" */
+/** @import Module from "./Module" */
+/** @import ModuleGraph from "./ModuleGraph" */
+/** @import { ConnectionState } from "./ModuleGraphConnection" */
+/** @import { Logger } from "./logging/Logger" */
+/** @import { RuntimeSpec } from "./util/runtime" */
 
 /**
  * Defines the queue item type used by this module.
@@ -723,7 +727,7 @@ const visitModules = (
 					c = cgi.chunkGroup;
 					if (c.isInitial()) {
 						compilation.errors.push(
-							new AsyncDependencyToInitialChunkError(
+							new (getAsyncDependencyToInitialChunkError())(
 								/** @type {string} */ (chunkName),
 								module,
 								/** @type {DependencyLocation} */ (b.loc)
@@ -845,26 +849,28 @@ const visitModules = (
 					chunkGroupInfo.skippedModuleConnections = skippedModuleConnections =
 						new Set();
 				}
-				for (let i = skipConnectionBuffer.length - 1; i >= 0; i--) {
-					skippedModuleConnections.add(skipConnectionBuffer[i]);
+				// Drained by popping (still reverse order): `length = 0` would drop
+				// the buffer's backing store, so the next push reallocates one.
+				while (skipConnectionBuffer.length > 0) {
+					skippedModuleConnections.add(
+						/** @type {[Module, ModuleGraphConnection[]]} */
+						(skipConnectionBuffer.pop())
+					);
 				}
-				skipConnectionBuffer.length = 0;
 			}
 			if (skipBuffer.length > 0) {
 				let { skippedItems } = chunkGroupInfo;
 				if (skippedItems === undefined) {
 					chunkGroupInfo.skippedItems = skippedItems = new Set();
 				}
-				for (let i = skipBuffer.length - 1; i >= 0; i--) {
-					skippedItems.add(skipBuffer[i]);
+				while (skipBuffer.length > 0) {
+					skippedItems.add(/** @type {Module} */ (skipBuffer.pop()));
 				}
-				skipBuffer.length = 0;
 			}
 			if (queueBuffer.length > 0) {
-				for (let i = queueBuffer.length - 1; i >= 0; i--) {
-					queue.push(queueBuffer[i]);
+				while (queueBuffer.length > 0) {
+					queue.push(/** @type {QueueItem} */ (queueBuffer.pop()));
 				}
-				queueBuffer.length = 0;
 			}
 		}
 
@@ -1076,7 +1082,12 @@ const visitModules = (
 
 			statMergedAvailableModuleSets += availableModulesToBeMerged.length;
 
-			for (const availableModules of availableModulesToBeMerged) {
+			// Drained by popping: the fold is commutative, and `length = 0` would
+			// drop the backing store that the next enqueue then reallocates.
+			while (availableModulesToBeMerged.length > 0) {
+				const availableModules =
+					/** @type {bigint} */
+					(availableModulesToBeMerged.pop());
 				if (minAvailableModules === undefined) {
 					minAvailableModules = availableModules;
 				} else {
@@ -1085,8 +1096,6 @@ const visitModules = (
 			}
 
 			const changed = minAvailableModules !== cachedMinAvailableModules;
-
-			availableModulesToBeMerged.length = 0;
 			if (changed) {
 				info.minAvailableModules = minAvailableModules;
 				info.resultingAvailableModules = undefined;

package/lib/bun/BunTargetPlugin.js

@@ -8,7 +8,7 @@
 const ExternalsPlugin = require("../ExternalsPlugin");
 const { coreModules } = require("../node/nodeBuiltins");
 
-/** @typedef {import("../Compiler")} Compiler */
+/** @import Compiler from "../Compiler" */
 
 // Bun exposes the node.js core modules; externalize them with the `node:`
 // specifier (Bun resolves both forms) like the deno target.

package/lib/cache/AddBuildDependenciesPlugin.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-/** @typedef {import("../Compiler")} Compiler */
+/** @import Compiler from "../Compiler" */
 
 const PLUGIN_NAME = "AddBuildDependenciesPlugin";
 

package/lib/cache/AddManagedPathsPlugin.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-/** @typedef {import("../Compiler")} Compiler */
+/** @import Compiler from "../Compiler" */
 
 class AddManagedPathsPlugin {
 	/**

package/lib/cache/IdleFileCachePlugin.js

@@ -8,8 +8,8 @@
 const Cache = require("../Cache");
 const ProgressPlugin = require("../ProgressPlugin");
 
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("./PackFileCacheStrategy")} PackFileCacheStrategy */
+/** @import Compiler from "../Compiler" */
+/** @import PackFileCacheStrategy from "./PackFileCacheStrategy" */
 
 const BUILD_DEPENDENCIES_KEY = Symbol("build dependencies key");
 const PLUGIN_NAME = "IdleFileCachePlugin";

package/lib/cache/MemoryCachePlugin.js

@@ -7,9 +7,8 @@
 
 const Cache = require("../Cache");
 
-/** @typedef {import("../Cache").Data} Data */
-/** @typedef {import("../Cache").Etag} Etag */
-/** @typedef {import("../Compiler")} Compiler */
+/** @import { Data, Etag } from "../Cache" */
+/** @import Compiler from "../Compiler" */
 
 class MemoryCachePlugin {
 	/**
@@ -30,16 +29,25 @@ class MemoryCachePlugin {
 			{ name: "MemoryCachePlugin", stage: Cache.STAGE_MEMORY },
 			(identifier, etag, gotHandlers) => {
 				const cacheEntry = cache.get(identifier);
-				if (cacheEntry === null) {
-					return null;
-				} else if (cacheEntry !== undefined) {
-					return cacheEntry.etag === etag ? cacheEntry.data : null;
+				// A recorded miss: the whole chain was asked for this identifier already.
+				if (cacheEntry === null) return null;
+				// Etags are compared by identity — a lazy one is interned per source
+				// object, so equal content reached through a second object is a
+				// different etag. Hashing to tell those apart would cost every hit what
+				// laziness saves, so a mismatch falls through to the next stage instead:
+				// the file cache compares etags by value and can still answer. Returning
+				// `null` here would bail the hook and lose that (`Cache.get` maps it to
+				// `undefined` regardless, so it buys the caller nothing).
+				if (cacheEntry !== undefined && cacheEntry.etag === etag) {
+					return cacheEntry.data;
 				}
 				gotHandlers.push((result, callback) => {
-					if (result === undefined) {
-						cache.set(identifier, null);
-					} else {
+					if (result !== undefined) {
 						cache.set(identifier, { etag, data: result });
+					} else if (cacheEntry === undefined) {
+						// Record the miss only for an identifier nothing was known about:
+						// an entry reached with a different etag still answers its own.
+						cache.set(identifier, null);
 					}
 					return callback();
 				});

package/lib/cache/MemoryWithGcCachePlugin.js

@@ -7,9 +7,8 @@
 
 const Cache = require("../Cache");
 
-/** @typedef {import("../Cache").Data} Data */
-/** @typedef {import("../Cache").Etag} Etag */
-/** @typedef {import("../Compiler")} Compiler */
+/** @import { Data, Etag } from "../Cache" */
+/** @import Compiler from "../Compiler" */
 
 /**
  * Defines the memory with gc cache plugin options type used by this module.
@@ -104,29 +103,42 @@ class MemoryWithGcCachePlugin {
 			{ name: PLUGIN_NAME, stage: Cache.STAGE_MEMORY },
 			(identifier, etag, gotHandlers) => {
 				const cacheEntry = cache.get(identifier);
-				if (cacheEntry === null) {
-					return null;
-				} else if (cacheEntry !== undefined) {
-					return cacheEntry.etag === etag ? cacheEntry.data : null;
-				}
-				const oldCacheEntry = oldCache.get(identifier);
-				if (oldCacheEntry !== undefined) {
-					const cacheEntry = oldCacheEntry.entry;
-					if (cacheEntry === null) {
-						oldCache.delete(identifier);
-						cache.set(identifier, cacheEntry);
-						return null;
+				// A recorded miss: the whole chain was asked for this identifier already.
+				if (cacheEntry === null) return null;
+				// Etags are compared by identity — a lazy one is interned per source
+				// object, so equal content reached through a second object is a
+				// different etag. Hashing to tell those apart would cost every hit what
+				// laziness saves, so a mismatch falls through to the next stage instead:
+				// the file cache compares etags by value and can still answer. Returning
+				// `null` here would bail the hook and lose that (`Cache.get` maps it to
+				// `undefined` regardless, so it buys the caller nothing).
+				let known = cacheEntry !== undefined;
+				if (cacheEntry !== undefined) {
+					if (cacheEntry.etag === etag) return cacheEntry.data;
+				} else {
+					const oldCacheEntry = oldCache.get(identifier);
+					if (oldCacheEntry !== undefined) {
+						const entry = oldCacheEntry.entry;
+						if (entry === null) {
+							oldCache.delete(identifier);
+							cache.set(identifier, entry);
+							return null;
+						}
+						known = true;
+						if (entry.etag === etag) {
+							oldCache.delete(identifier);
+							cache.set(identifier, entry);
+							return entry.data;
+						}
 					}
-					if (cacheEntry.etag !== etag) return null;
-					oldCache.delete(identifier);
-					cache.set(identifier, cacheEntry);
-					return cacheEntry.data;
 				}
 				gotHandlers.push((result, callback) => {
-					if (result === undefined) {
-						cache.set(identifier, null);
-					} else {
+					if (result !== undefined) {
 						cache.set(identifier, { etag, data: result });
+					} else if (!known) {
+						// Record the miss only for an identifier nothing was known about:
+						// an entry reached with a different etag still answers its own.
+						cache.set(identifier, null);
 					}
 					return callback();
 				});

package/lib/cache/PackFileCacheStrategy.js

@@ -18,19 +18,26 @@ const {
 	createFileSerializer
 } = require("../util/serialization");
 
-/** @typedef {import("../../declarations/WebpackOptions").SnapshotOptions} SnapshotOptions */
-/** @typedef {import("../Compilation").FileSystemDependencies} FileSystemDependencies */
-/** @typedef {import("../Cache").Data} Data */
-/** @typedef {import("../Cache").Etag} Etag */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../FileSystemInfo").ResolveBuildDependenciesResult} ResolveBuildDependenciesResult */
-/** @typedef {import("../FileSystemInfo").ResolveResults} ResolveResults */
-/** @typedef {import("../FileSystemInfo").Snapshot} Snapshot */
-/** @typedef {import("../logging/Logger").Logger} Logger */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-/** @typedef {import("../util/Hash").HashFunction} HashFunction */
-/** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
+/** @import { SnapshotOptions } from "../../declarations/WebpackOptions" */
+/** @import { FileSystemDependencies } from "../Compilation" */
+/** @import { Data, Etag } from "../Cache" */
+/** @import Compiler from "../Compiler" */
+/**
+ * @import {
+ * 	ResolveBuildDependenciesResult,
+ * 	ResolveResults,
+ * 	Snapshot
+ * } from "../FileSystemInfo"
+ */
+/** @import { Logger } from "../logging/Logger" */
+/**
+ * @import {
+ * 	ObjectDeserializerContext,
+ * 	ObjectSerializerContext
+ * } from "../serialization/ObjectMiddleware"
+ */
+/** @import { HashFunction } from "../util/Hash" */
+/** @import { IntermediateFileSystem } from "../util/fs" */
 
 /** @typedef {Set<string>} Items */
 /** @typedef {Set<string>} BuildDependencies */
@@ -52,10 +59,10 @@ class PackContainer {
 	 * Creates an instance of PackContainer.
 	 * @param {Pack} data stored data
 	 * @param {string} version version identifier
-	 * @param {Snapshot} buildSnapshot snapshot of all build dependencies
+	 * @param {InstanceType<Snapshot>} buildSnapshot snapshot of all build dependencies
 	 * @param {BuildDependencies} buildDependencies list of all unresolved build dependencies captured
 	 * @param {ResolveResults} resolveResults result of the resolved build dependencies
-	 * @param {Snapshot} resolveBuildDependenciesSnapshot snapshot of the dependencies of the build dependencies resolving
+	 * @param {InstanceType<Snapshot>} resolveBuildDependenciesSnapshot snapshot of the dependencies of the build dependencies resolving
 	 */
 	constructor(
 		data,
@@ -69,13 +76,13 @@ class PackContainer {
 		this.data = data;
 		/** @type {string} */
 		this.version = version;
-		/** @type {Snapshot} */
+		/** @type {InstanceType<Snapshot>} */
 		this.buildSnapshot = buildSnapshot;
 		/** @type {BuildDependencies} */
 		this.buildDependencies = buildDependencies;
 		/** @type {ResolveResults} */
 		this.resolveResults = resolveResults;
-		/** @type {Snapshot} */
+		/** @type {InstanceType<Snapshot>} */
 		this.resolveBuildDependenciesSnapshot = resolveBuildDependenciesSnapshot;
 	}
 
@@ -1256,11 +1263,11 @@ class PackFileCacheStrategy {
 		this.buildDependencies = new Set();
 		/** @type {FileSystemDependencies} */
 		this.newBuildDependencies = new LazySet();
-		/** @type {Snapshot | undefined} */
+		/** @type {InstanceType<Snapshot> | undefined} */
 		this.resolveBuildDependenciesSnapshot = undefined;
 		/** @type {ResolveResults | undefined} */
 		this.resolveResults = undefined;
-		/** @type {Snapshot | undefined} */
+		/** @type {InstanceType<Snapshot> | undefined} */
 		this.buildSnapshot = undefined;
 		/** @type {Promise<Pack> | undefined} */
 		this.packPromise = this._openPack();
@@ -1285,13 +1292,13 @@ class PackFileCacheStrategy {
 	 */
 	_openPack() {
 		const { logger, profile, cacheLocation, version } = this;
-		/** @type {Snapshot} */
+		/** @type {InstanceType<Snapshot>} */
 		let buildSnapshot;
 		/** @type {BuildDependencies} */
 		let buildDependencies;
 		/** @type {BuildDependencies} */
 		let newBuildDependencies;
-		/** @type {Snapshot} */
+		/** @type {InstanceType<Snapshot>} */
 		let resolveBuildDependenciesSnapshot;
 		/** @type {ResolveResults | undefined} */
 		let resolveResults;
@@ -1633,12 +1640,12 @@ class PackFileCacheStrategy {
 					const content = new PackContainer(
 						pack,
 						this.version,
-						/** @type {Snapshot} */
+						/** @type {InstanceType<Snapshot>} */
 						(this.buildSnapshot),
 						updatedBuildDependencies,
 						/** @type {ResolveResults} */
 						(this.resolveResults),
-						/** @type {Snapshot} */
+						/** @type {InstanceType<Snapshot>} */
 						(this.resolveBuildDependenciesSnapshot)
 					);
 					const cleanup = this.fs.unlink !== undefined;

package/lib/cache/ResolverCachePlugin.js

@@ -8,18 +8,29 @@
 const LazySet = require("../util/LazySet");
 const makeSerializable = require("../util/makeSerializable");
 
-/** @typedef {import("enhanced-resolve").ResolveContext} ResolveContext */
-/** @typedef {import("enhanced-resolve").ResolveOptions} ResolveOptions */
-/** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */
-/** @typedef {import("enhanced-resolve").Resolver} Resolver */
-/** @typedef {import("../CacheFacade").ItemCacheFacade} ItemCacheFacade */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../FileSystemInfo")} FileSystemInfo */
-/** @typedef {import("../FileSystemInfo").Snapshot} Snapshot */
-/** @typedef {import("../FileSystemInfo").SnapshotOptions} SnapshotOptions */
-/** @typedef {import("../ResolverFactory").ResolveOptionsWithDependencyType} ResolveOptionsWithDependencyType */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/**
+ * @import {
+ * 	ResolveContext,
+ * 	ResolveOptions,
+ * 	ResolveRequest,
+ * 	Resolver
+ * } from "enhanced-resolve"
+ */
+/** @import { ItemCacheFacade } from "../CacheFacade" */
+/** @import Compiler from "../Compiler" */
+/**
+ * @import FileSystemInfo, {
+ * 	Snapshot,
+ * 	SnapshotOptions
+ * } from "../FileSystemInfo"
+ */
+/** @import { ResolveOptionsWithDependencyType } from "../ResolverFactory" */
+/**
+ * @import {
+ * 	ObjectDeserializerContext,
+ * 	ObjectSerializerContext
+ * } from "../serialization/ObjectMiddleware"
+ */
 
 /**
  * Defines the sync hook type used by this module.
@@ -33,12 +44,12 @@ class CacheEntry {
 	/**
 	 * Creates an instance of CacheEntry.
 	 * @param {ResolveRequest} result result
-	 * @param {Snapshot} snapshot snapshot
+	 * @param {InstanceType<Snapshot>} snapshot snapshot
 	 */
 	constructor(result, snapshot) {
 		/** @type {ResolveRequest} */
 		this.result = result;
-		/** @type {Snapshot} */
+		/** @type {InstanceType<Snapshot>} */
 		this.snapshot = snapshot;
 	}
 
@@ -112,7 +123,7 @@ class ResolverCachePlugin {
 	 */
 	apply(compiler) {
 		const cache = compiler.getCache(PLUGIN_NAME);
-		/** @type {FileSystemInfo} */
+		/** @type {FileSystemInfo | undefined} */
 		let fileSystemInfo;
 		/** @type {SnapshotOptions | undefined} */
 		let snapshotOptions;
@@ -120,6 +131,12 @@ class ResolverCachePlugin {
 		let cachedResolves = 0;
 		let cacheInvalidResolves = 0;
 		let concurrentResolves = 0;
+		// FileSystemInfo reaches the whole Compilation through its logger, so this
+		// compiler-lifetime closure would outlive what `Compiler.close()` releases.
+		compiler.hooks.shutdown.tap(PLUGIN_NAME, () => {
+			fileSystemInfo = undefined;
+			snapshotOptions = undefined;
+		});
 		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			snapshotOptions = compilation.options.snapshot.resolve;
 			fileSystemInfo = compilation.fileSystemInfo;
@@ -144,7 +161,7 @@ class ResolverCachePlugin {
 
 		/**
 		 * Processes the provided item cache.
-		 * @param {ItemCacheFacade} itemCache cache
+		 * @param {InstanceType<ItemCacheFacade>} itemCache cache
 		 * @param {Resolver} resolver the resolver
 		 * @param {ResolveContext} resolveContext context for resolving meta info
 		 * @param {ResolveRequest} request the request info object
@@ -209,7 +226,9 @@ class ResolverCachePlugin {
 					const fileDependencies = newResolveContext.fileDependencies;
 					const contextDependencies = newResolveContext.contextDependencies;
 					const missingDependencies = newResolveContext.missingDependencies;
-					fileSystemInfo.createSnapshot(
+					// Only reachable past the `!fileSystemInfo` guard on the resolve tap.
+					const fsInfo = /** @type {FileSystemInfo} */ (fileSystemInfo);
+					fsInfo.createSnapshot(
 						resolveTime,
 						/** @type {Dependencies} */
 						(fileDependencies),
@@ -395,7 +414,8 @@ class ResolverCachePlugin {
 
 								if (cacheEntry) {
 									const { snapshot, result } = cacheEntry;
-									fileSystemInfo.checkSnapshotValid(snapshot, (err, valid) => {
+									const fsInfo = /** @type {FileSystemInfo} */ (fileSystemInfo);
+									fsInfo.checkSnapshotValid(snapshot, (err, valid) => {
 										if (err || !valid) {
 											cacheInvalidResolves++;
 											return doRealResolve(

package/lib/cache/getLazyHashedEtag.js

@@ -8,9 +8,8 @@
 const { DEFAULTS } = require("../config/defaults");
 const createHash = require("../util/createHash");
 
-/** @typedef {import("../util/Hash")} Hash */
+/** @import Hash, { HashFunction } from "../util/Hash" */
 /** @typedef {typeof import("../util/Hash")} HashConstructor */
-/** @typedef {import("../util/Hash").HashFunction} HashFunction */
 
 /**
  * Represents the lazy hashed etag runtime component.

package/lib/cache/mergeEtags.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-/** @typedef {import("../Cache").Etag} Etag */
+/** @import { Etag } from "../Cache" */
 
 class MergedEtag {
 	/**

package/lib/cli.js

@@ -11,9 +11,7 @@ const webpackSchema =
 	/** @type {EXPECTED_ANY} */
 	(require("../schemas/WebpackOptions.json"));
 
-/** @typedef {import("json-schema").JSONSchema4} JSONSchema4 */
-/** @typedef {import("json-schema").JSONSchema6} JSONSchema6 */
-/** @typedef {import("json-schema").JSONSchema7} JSONSchema7 */
+/** @import { JSONSchema4, JSONSchema6, JSONSchema7 } from "json-schema" */
 /** @typedef {JSONSchema4 | JSONSchema6 | JSONSchema7} JSONSchema */
 /** @typedef {JSONSchema & { absolutePath: boolean, instanceof: string, cli: { helper?: boolean, exclude?: boolean, description?: string, negatedDescription?: string, resetDescription?: string } }} Schema */
 

package/lib/config/browserslistTargetHandler.js

@@ -8,13 +8,23 @@
 const path = require("path");
 const browserslist = require("browserslist");
 
-/** @typedef {import("./target").ApiTargetProperties} ApiTargetProperties */
-/** @typedef {import("./target").EcmaTargetProperties} EcmaTargetProperties */
-/** @typedef {import("./target").PlatformTargetProperties} PlatformTargetProperties */
+/**
+ * @import {
+ * 	ApiTargetProperties,
+ * 	EcmaTargetProperties,
+ * 	PlatformTargetProperties
+ * } from "./target"
+ */
 
 // [[C:]/path/to/config][:env]
 const inputRx = /^(?:((?:[A-Z]:)?[/\\].*?))?(?::(.+?))?$/i;
 
+// One resolution per `[input, context]` — several callers ask for the same
+// target, and each miss re-reads the config and re-runs the queries. The list is
+// handed out as it stands, so no caller may write to it.
+/** @type {Map<string, string[] | undefined> | null} */
+const cache = process.env.BROWSERSLIST_DISABLE_CACHE ? null : new Map();
+
 /**
  * Returns selected browsers.
  * @param {string | null | undefined} input input string
@@ -22,6 +32,25 @@ const inputRx = /^(?:((?:[A-Z]:)?[/\\].*?))?(?::(.+?))?$/i;
  * @returns {string[] | undefined} selected browsers
  */
 const load = (input, context) => {
+	if (cache === null) return loadBrowsers(input, context);
+	// A newline separates the two: an input carries a config path, an env or a
+	// query, and a directory carries none.
+	const key = `${input || ""}\n${context}`;
+	let browsers = cache.get(key);
+	if (browsers === undefined && !cache.has(key)) {
+		browsers = loadBrowsers(input, context);
+		cache.set(key, browsers);
+	}
+	return browsers;
+};
+
+/**
+ * Read the selection out of the browserslist config or query.
+ * @param {string | null | undefined} input input string
+ * @param {string} context the context directory
+ * @returns {string[] | undefined} selected browsers
+ */
+const loadBrowsers = (input, context) => {
 	// browserslist:path-to-config
 	// browserslist:path-to-config:env
 	if (input && path.isAbsolute(input)) {
@@ -69,8 +98,15 @@ const resolve = (browsers) => {
 	 * @param {Record<string, number | [number, number]>} versions first supported version
 	 * @returns {boolean} true if supports
 	 */
-	const rawChecker = (versions) =>
-		browsers.every((v) => {
+	const rawChecker = (versions) => checkAll(browsers, versions);
+	/**
+	 * Checks a subset of the list against a version number
+	 * @param {string[]} list the browsers to check
+	 * @param {Record<string, number | [number, number]>} versions first supported version
+	 * @returns {boolean} true if all support
+	 */
+	const checkAll = (list, versions) =>
+		list.every((v) => {
 			const [name, parsedVersion] = v.split(" ");
 			if (!name) return false;
 			const requiredVersion = versions[name];