webpack 5.110.3 → 5.111.0

package/lib/SourceMapDevToolPlugin.js

@@ -5,13 +5,13 @@
 
 "use strict";
 
-const asyncLib = require("neo-async");
 const { ConcatSource, RawSource } = require("webpack-sources");
 const Compilation = require("./Compilation");
 const ModuleFilenameHelpers = require("./ModuleFilenameHelpers");
 const ProgressPlugin = require("./ProgressPlugin");
 const SourceMapDevToolModuleOptionsPlugin = require("./SourceMapDevToolModuleOptionsPlugin");
 const { getPresentKinds } = require("./TemplatedPathPlugin");
+const asyncLib = require("./util/async");
 const createHash = require("./util/createHash");
 const { dirname, relative } = require("./util/fs");
 const generateDebugId = require("./util/generateDebugId");

package/lib/Watching.js

@@ -307,6 +307,7 @@ class Watching {
 				logger.time("storeBuildDependencies");
 				this.compiler.cache.storeBuildDependencies(
 					compilation.buildDependencies,
+					compilation.optionalBuildDependencies,
 					(err) => {
 						logger.timeEnd("storeBuildDependencies");
 						if (err) return handleError(err);
@@ -338,6 +339,8 @@ class Watching {
 			this.compiler.cache.storeBuildDependencies(
 				/** @type {Compilation} */
 				(compilation).buildDependencies,
+				/** @type {Compilation} */
+				(compilation).optionalBuildDependencies,
 				(err) => {
 					logger.timeEnd("storeBuildDependencies");
 					if (err) return handleError(err, cbs);
@@ -359,6 +362,11 @@ class Watching {
 					});
 					for (const cb of cbs) cb(null);
 					this.compiler.hooks.afterDone.call(/** @type {Stats} */ (stats));
+					// A watch run goes idle here rather than closing, so seal-only
+					// data would be held until the next build starts.
+					this.compiler._releaseUnusedCompilationData(
+						/** @type {Compilation} */ (compilation)
+					);
 				}
 			);
 		});
@@ -518,6 +526,7 @@ class Watching {
 				logger.time("storeBuildDependencies");
 				this.compiler.cache.storeBuildDependencies(
 					compilation.buildDependencies,
+					compilation.optionalBuildDependencies,
 					(err2) => {
 						logger.timeEnd("storeBuildDependencies");
 						shutdown(err || err2);

package/lib/WebpackOptionsApply.js

@@ -85,6 +85,7 @@ const { NODE_MODULES_REGEXP } = require("./util/identifier");
 /** @import { WebpackOptionsInterception } from "./config/normalization" */
 /** @import Compiler from "./Compiler" */
 /** @import { InputFileSystem, IntermediateFileSystem } from "./util/fs" */
+/** @import { ResolveOptionsWithDependencyType } from "./ResolverFactory" */
 
 const CLASS_NAME = "WebpackOptionsApply";
 
@@ -425,6 +426,12 @@ class WebpackOptionsApply extends OptionsApply {
 			).apply(compiler);
 		}
 
+		if (options.output.copy) {
+			const CopyPlugin = require("./CopyPlugin");
+
+			new CopyPlugin(options.output.copy).apply(compiler);
+		}
+
 		if (options.dotenv) {
 			const DotenvPlugin = require("./DotenvPlugin");
 
@@ -496,32 +503,6 @@ class WebpackOptionsApply extends OptionsApply {
 			sideEffectFree: options.experiments.futureDefaults
 		}).apply(compiler);
 
-		if (!options.experiments.outputModule) {
-			if (options.output.module) {
-				throw new Error(
-					"'output.module: true' is only allowed when 'experiments.outputModule' is enabled"
-				);
-			}
-			if (options.output.enabledLibraryTypes.includes("module")) {
-				throw new Error(
-					"library type \"module\" is only allowed when 'experiments.outputModule' is enabled"
-				);
-			}
-			if (options.output.enabledLibraryTypes.includes("modern-module")) {
-				throw new Error(
-					"library type \"modern-module\" is only allowed when 'experiments.outputModule' is enabled"
-				);
-			}
-			if (
-				options.externalsType === "module" ||
-				options.externalsType === "module-import"
-			) {
-				throw new Error(
-					"'externalsType: \"module\"' is only allowed when 'experiments.outputModule' is enabled"
-				);
-			}
-		}
-
 		if (options.output.module) {
 			// Analyzable output is ESM output, so this is every build that can reserve a name.
 			const RuntimeTemplate = require("./RuntimeTemplate");
@@ -738,8 +719,10 @@ class WebpackOptionsApply extends OptionsApply {
 			options.performance && options.performance.circularDependencies
 				? options.performance.hints
 				: false;
+		// ConstExportsPlugin Binding checks need CircularModulesPlugin when this is on.
+		const inlineExports = options.optimization.inlineExports;
 
-		if (options.mode === "production" || circularHints) {
+		if (options.mode === "production" || circularHints || inlineExports) {
 			const CircularModulesPlugin = require("./CircularModulesPlugin");
 
 			new CircularModulesPlugin({ hints: circularHints }).apply(compiler);
@@ -748,7 +731,7 @@ class WebpackOptionsApply extends OptionsApply {
 		const ConstExportsPlugin = require("./optimize/ConstExportsPlugin");
 
 		new ConstExportsPlugin({
-			inlineExports: options.optimization.inlineExports
+			inlineExports
 		}).apply(compiler);
 
 		if (options.optimization.mangleExports) {
@@ -778,7 +761,9 @@ class WebpackOptionsApply extends OptionsApply {
 
 			new NoEmitOnErrorsPlugin().apply(compiler);
 		}
-		if (options.optimization.realContentHash) {
+		// ESM output may bake a name into a chunk whose hashed name would then go stale;
+		// the repair runs for those alone where it was not asked for outright.
+		if (options.optimization.realContentHash || options.output.module) {
 			const RealContentHashPlugin = require("./optimize/RealContentHashPlugin");
 
 			new RealContentHashPlugin({
@@ -787,7 +772,8 @@ class WebpackOptionsApply extends OptionsApply {
 					(options.output.hashFunction),
 				hashDigest:
 					/** @type {NonNullable<WebpackOptions["output"]["hashDigest"]>} */
-					(options.output.hashDigest)
+					(options.output.hashDigest),
+				onDemand: !options.optimization.realContentHash
 			}).apply(compiler);
 		}
 		if (options.optimization.checkWasmTypes) {
@@ -906,7 +892,7 @@ class WebpackOptionsApply extends OptionsApply {
 					? publicPath
 					: "/";
 
-			// Marked internal: these keys are webpack's, so `performance.unusedDefines`
+			// Marked internal: these keys are webpack's, so `performance.unusedConfig`
 			// must not report them against the user.
 			DefinePlugin.markInternal(
 				new DefinePlugin({
@@ -966,18 +952,18 @@ class WebpackOptionsApply extends OptionsApply {
 				new RedundantDynamicImportsPlugin(options.performance).apply(compiler);
 			}
 
-			if (options.performance.entrypointOverlap) {
-				const EntrypointOverlapPlugin = require("./performance/EntrypointOverlapPlugin");
-
-				new EntrypointOverlapPlugin(options.performance).apply(compiler);
-			}
-
 			if (options.performance.largeModules) {
 				const LargeModulesPlugin = require("./performance/LargeModulesPlugin");
 
 				new LargeModulesPlugin(options.performance).apply(compiler);
 			}
 
+			if (options.performance.analyzableBailouts) {
+				const AnalyzableBailoutsPlugin = require("./performance/AnalyzableBailoutsPlugin");
+
+				new AnalyzableBailoutsPlugin(options.performance).apply(compiler);
+			}
+
 			if (options.performance.asyncChunkWaterfalls) {
 				const AsyncChunkWaterfallsPlugin = require("./performance/AsyncChunkWaterfallsPlugin");
 
@@ -1044,12 +1030,6 @@ class WebpackOptionsApply extends OptionsApply {
 				new DynamicExportsPlugin(options.performance).apply(compiler);
 			}
 
-			if (options.performance.embeddedSourceMaps) {
-				const EmbeddedSourceMapsPlugin = require("./performance/EmbeddedSourceMapsPlugin");
-
-				new EmbeddedSourceMapsPlugin(options.performance).apply(compiler);
-			}
-
 			if (options.performance.inlinedAssets) {
 				const InlinedAssetsPlugin = require("./performance/InlinedAssetsPlugin");
 
@@ -1068,42 +1048,56 @@ class WebpackOptionsApply extends OptionsApply {
 				new ScopeHoistingBailoutsPlugin(options.performance).apply(compiler);
 			}
 
-			if (options.performance.unusedReexports) {
-				const UnusedReexportsPlugin = require("./performance/UnusedReexportsPlugin");
+			// One switch for source maps: a devtool that ships the map to everyone,
+			// and a loader that loses it, are both about the map being worth its cost.
+			if (options.performance.sourceMaps) {
+				const EmbeddedSourceMapsPlugin = require("./performance/EmbeddedSourceMapsPlugin");
+				const MissingSourceMapsPlugin = require("./performance/MissingSourceMapsPlugin");
 
-				new UnusedReexportsPlugin(options.performance).apply(compiler);
+				new EmbeddedSourceMapsPlugin(options.performance).apply(compiler);
+				new MissingSourceMapsPlugin(options.performance).apply(compiler);
 			}
 
-			// Deliberately not gated on `hints`, like `unusedRules` below: a rule
-			// that only matches on one OS is a configuration mistake, not a size.
-			if (options.performance.osDependentRules) {
-				const OsDependentRuleWarningPlugin = require("./performance/OsDependentRuleWarningPlugin");
+			// One switch for configuration that did nothing: the four read different
+			// parts of the config, but the finding and the fix are the same.
+			if (options.performance.unusedConfig) {
+				const UnusedAliasesPlugin = require("./performance/UnusedAliasesPlugin");
+				const UnusedDefinesPlugin = require("./performance/UnusedDefinesPlugin");
+				const UnusedExternalsPlugin = require("./performance/UnusedExternalsPlugin");
+				const UnusedFederationPlugin = require("./performance/UnusedFederationPlugin");
+				// Reports even where size hints are off: a dead rule is a configuration
+				// mistake either way.
+				const UnusedRuleWarningPlugin = require("./performance/UnusedRuleWarningPlugin");
 
-				new OsDependentRuleWarningPlugin(options.performance).apply(compiler);
+				new UnusedAliasesPlugin(options.performance).apply(compiler);
+				new UnusedDefinesPlugin(options.performance).apply(compiler);
+				new UnusedExternalsPlugin(options.performance).apply(compiler);
+				new UnusedFederationPlugin(options.performance).apply(compiler);
+				new UnusedRuleWarningPlugin(options.performance).apply(compiler);
 			}
 
-			// Deliberately not gated on `hints`: an alias nothing matches is a
-			// configuration mistake, not a size.
-			if (options.performance.unusedAliases) {
-				const UnusedAliasesPlugin = require("./performance/UnusedAliasesPlugin");
+			// One switch for a module nothing uses: the two differ only in what kept
+			// it there, and each names the cause it knows about.
+			if (options.performance.unusedModules) {
+				const UnusedModulesPlugin = require("./performance/UnusedModulesPlugin");
+				const UnusedReexportsPlugin = require("./performance/UnusedReexportsPlugin");
 
-				new UnusedAliasesPlugin(options.performance).apply(compiler);
+				new UnusedModulesPlugin(options.performance).apply(compiler);
+				new UnusedReexportsPlugin(options.performance).apply(compiler);
 			}
 
-			// Deliberately not gated on `hints`: a key nothing reads is a
-			// configuration mistake, not a size.
-			if (options.performance.unusedDefines) {
-				const UnusedDefinesPlugin = require("./performance/UnusedDefinesPlugin");
+			// Deliberately not gated on `hints`, like `unusedConfig` above: a rule
+			// that only matches on one OS is a configuration mistake, not a size.
+			if (options.performance.osDependentRules) {
+				const OsDependentRuleWarningPlugin = require("./performance/OsDependentRuleWarningPlugin");
 
-				new UnusedDefinesPlugin(options.performance).apply(compiler);
+				new OsDependentRuleWarningPlugin(options.performance).apply(compiler);
 			}
 
-			// Deliberately not gated on `hints`: a misspelled external gets bundled
-			// instead, which no size limit would explain.
-			if (options.performance.unusedExternals) {
-				const UnusedExternalsPlugin = require("./performance/UnusedExternalsPlugin");
+			if (options.performance.unusedAssets) {
+				const UnusedAssetsPlugin = require("./performance/UnusedAssetsPlugin");
 
-				new UnusedExternalsPlugin(options.performance).apply(compiler);
+				new UnusedAssetsPlugin(options.performance).apply(compiler);
 			}
 
 			// Deliberately not gated on `hints`: asking for both directives on one
@@ -1113,14 +1107,6 @@ class WebpackOptionsApply extends OptionsApply {
 
 				new ConflictingResourceHintsPlugin(options.performance).apply(compiler);
 			}
-
-			// Deliberately not gated on `hints`: a dead rule is a configuration
-			// mistake worth reporting even where size hints are off.
-			if (options.performance.unusedRules) {
-				const UnusedRuleWarningPlugin = require("./performance/UnusedRuleWarningPlugin");
-
-				new UnusedRuleWarningPlugin(options.performance).apply(compiler);
-			}
 		}
 
 		new TemplatedPathPlugin().apply(compiler);
@@ -1258,34 +1244,41 @@ class WebpackOptionsApply extends OptionsApply {
 		if (!compiler.inputFileSystem) {
 			throw new Error("No input filesystem provided");
 		}
-		compiler.resolverFactory.hooks.resolveOptions
-			.for("normal")
-			.tap(CLASS_NAME, (resolveOptions) => {
-				resolveOptions = cleverMerge(options.resolve, resolveOptions);
+		/**
+		 * Supplies the compiler's input filesystem as the default for a resolver.
+		 * A filesystem set in the configuration is kept, so that `resolve.fileSystem`
+		 * reaches enhanced-resolve the way `resolve.resolver` already does.
+		 * @param {ResolveOptionsWithDependencyType} resolveOptions merged resolve options
+		 * @returns {ResolveOptionsWithDependencyType} the same options
+		 */
+		const withFileSystem = (resolveOptions) => {
+			if (!resolveOptions.fileSystem) {
 				resolveOptions.fileSystem =
 					/** @type {InputFileSystem} */
 					(compiler.inputFileSystem);
-				return resolveOptions;
-			});
+			}
+			return resolveOptions;
+		};
+
+		compiler.resolverFactory.hooks.resolveOptions
+			.for("normal")
+			.tap(CLASS_NAME, (resolveOptions) =>
+				withFileSystem(cleverMerge(options.resolve, resolveOptions))
+			);
 		compiler.resolverFactory.hooks.resolveOptions
 			.for("context")
 			.tap(CLASS_NAME, (resolveOptions) => {
-				resolveOptions = cleverMerge(options.resolve, resolveOptions);
-				resolveOptions.fileSystem =
-					/** @type {InputFileSystem} */
-					(compiler.inputFileSystem);
+				resolveOptions = withFileSystem(
+					cleverMerge(options.resolve, resolveOptions)
+				);
 				resolveOptions.resolveToContext = true;
 				return resolveOptions;
 			});
 		compiler.resolverFactory.hooks.resolveOptions
 			.for("loader")
-			.tap(CLASS_NAME, (resolveOptions) => {
-				resolveOptions = cleverMerge(options.resolveLoader, resolveOptions);
-				resolveOptions.fileSystem =
-					/** @type {InputFileSystem} */
-					(compiler.inputFileSystem);
-				return resolveOptions;
-			});
+			.tap(CLASS_NAME, (resolveOptions) =>
+				withFileSystem(cleverMerge(options.resolveLoader, resolveOptions))
+			);
 		compiler.hooks.afterResolvers.call(compiler);
 		return options;
 	}

package/lib/asset/AssetGenerator.js

@@ -28,7 +28,7 @@ const URLDependency = require("../dependencies/URLDependency");
 const { getScheme } = require("../util/URLAbsoluteSpecifier");
 const createHash = require("../util/createHash");
 const { languageOfMediaType } = require("../util/dataURL");
-const { makePathsRelative } = require("../util/identifier");
+const { makePathsRelative, parseResource } = require("../util/identifier");
 const memoize = require("../util/memoize");
 const nonNumericOnlyHash = require("../util/nonNumericOnlyHash");
 const {
@@ -55,7 +55,6 @@ const getMimeTypes = memoize(() => require("../util/mimeTypes"));
 /** @import { GenerateContext, UpdateHashContext } from "../Generator" */
 /**
  * @import Module, {
- * 	NameForCondition,
  * 	ConcatenationBailoutReasonContext,
  * 	SourceType,
  * 	SourceTypes
@@ -250,12 +249,27 @@ class AssetGenerator extends Generator {
 	static getSourceFileName(module, runtimeTemplate) {
 		return makePathsRelative(
 			runtimeTemplate.compilation.compiler.context,
-			/** @type {string} */
-			(module.getResource()),
+			AssetGenerator.getAssetResource(module),
 			runtimeTemplate.compilation.compiler.root
 		).replace(/^\.\//, "");
 	}
 
+	/**
+	 * The resource this asset is named after, which something that re-encoded it
+	 * may have changed. Its emitted name and inlined media type both read this.
+	 * @param {NormalModule} module module
+	 * @returns {string} the resource
+	 */
+	static getAssetResource(module) {
+		const buildInfo = /** @type {AssetModuleBuildInfo | undefined} */ (
+			module.buildInfo
+		);
+
+		return /** @type {string} */ (
+			(buildInfo && buildInfo.assetResource) || module.getResource()
+		);
+	}
+
 	/**
 	 * Gets the source file name as seen by a filename template. With
 	 * `experiments.futureDefaults` (webpack 6 default) `[path]` and `[file]` of a
@@ -504,11 +518,14 @@ class AssetGenerator extends Generator {
 			/** @type {AssetGeneratorDataUrlOptions} */
 			(this.dataUrlOptions).mimetype;
 		if (mimeType === undefined) {
-			const ext = path.extname(
-				/** @type {NameForCondition} */
-				(module.nameForCondition())
-			);
+			// The resource as it now is, minus the query and fragment a request
+			// carries into it.
+			const resource = AssetGenerator.getAssetResource(module);
+			const ext = path.extname(parseResource(resource).path);
+			// `resourceResolveData` describes what was read; once something
+			// re-encoded it, only the new extension says what the bytes are.
 			if (
+				resource === module.getResource() &&
 				module.resourceResolveData &&
 				module.resourceResolveData.mimetype !== undefined
 			) {

package/lib/asset/AssetModule.js

@@ -22,6 +22,9 @@ const makeSerializable = require("../util/makeSerializable");
  * @property {string=} filename
  * @property {AssetInfo=} assetInfo
  * @property {string=} fullContentHash
+ * @property {string=} assetResource the resource this asset is named after, when
+ * something re-encoded it. Unlike `matchResource` this is serialized, so a
+ * rename set while building survives the persistent cache
  */
 
 /** @typedef {NormalModuleBuildInfo & KnownAssetModuleBuildInfo} AssetModuleBuildInfo */

package/lib/asset/WebManifestParser.js

@@ -5,15 +5,15 @@
 
 "use strict";
 
-const { parse } = require("acorn");
 const Parser = require("../Parser");
 const HtmlSourceDependency = require("../dependencies/HtmlSourceDependency");
+const { parse } = require("../javascript/syntax");
 
 /** @import { Expression, ObjectExpression, Program, Property } from "estree" */
 /** @import { BuildInfo } from "../Module" */
 /** @import { ParserState, PreparsedAst } from "../Parser" */
 
-// acorn decorates every node with numeric source offsets (absent from the estree types).
+// the parser decorates every node with numeric source offsets (absent from the estree types).
 /** @typedef {{ start: number, end: number }} Positioned */
 
 // A URL carrying its own scheme (`https:`, `data:`, …) is external; it is only
@@ -70,9 +70,11 @@ class WebManifestParser extends Parser {
 		let ast;
 		try {
 			// Wrap in parens so the top-level object is an expression, not a block.
-			ast = /** @type {Program} */ (
-				/** @type {unknown} */ (parse(`(${source})`, { ecmaVersion: "latest" }))
-			);
+			ast = parse(`(${source})`, {
+				ecmaVersion: "latest",
+				sourceType: "script",
+				lazyNodes: true
+			});
 		} catch (_err) {
 			// Not valid JSON — leave the file untouched (still emitted as-is).
 			ast = undefined;

package/lib/cache/AddBuildDependenciesPlugin.js

@@ -9,14 +9,36 @@
 
 const PLUGIN_NAME = "AddBuildDependenciesPlugin";
 
+/**
+ * @typedef {object} NormalizedBuildDependencyItem
+ * @property {string} dependency request to resolve
+ * @property {boolean} optional when true the dependency may be missing
+ */
+
+/**
+ * @param {string | { dependency: string, optional?: boolean }} item build dependency
+ * @returns {NormalizedBuildDependencyItem} normalized build dependency
+ */
+const normalizeBuildDependencyItem = (item) => {
+	if (typeof item === "string") {
+		return { dependency: item, optional: false };
+	}
+	return {
+		dependency: item.dependency,
+		optional: Boolean(item.optional)
+	};
+};
+
 class AddBuildDependenciesPlugin {
 	/**
 	 * Creates an instance of AddBuildDependenciesPlugin.
-	 * @param {Iterable<string>} buildDependencies list of build dependencies
+	 * @param {Iterable<string | { dependency: string, optional?: boolean }>} buildDependencies list of build dependencies
 	 */
 	constructor(buildDependencies) {
-		/** @type {Set<string>} */
-		this.buildDependencies = new Set(buildDependencies);
+		/** @type {NormalizedBuildDependencyItem[]} */
+		this.buildDependencies = [...buildDependencies].map(
+			normalizeBuildDependencyItem
+		);
 	}
 
 	/**
@@ -26,7 +48,14 @@ class AddBuildDependenciesPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
-			compilation.buildDependencies.addAll(this.buildDependencies);
+			for (const { dependency, optional } of this.buildDependencies) {
+				compilation.buildDependencies.add(dependency);
+				if (optional) {
+					compilation.optionalBuildDependencies.add(dependency);
+					compilation.missingDependencies.add(dependency);
+					compilation.fileDependencies.add(dependency);
+				}
+			}
 		});
 	}
 }

package/lib/cache/IdleFileCachePlugin.js

@@ -98,10 +98,10 @@ class IdleFileCachePlugin {
 
 		compiler.cache.hooks.storeBuildDependencies.tap(
 			{ name: PLUGIN_NAME, stage: Cache.STAGE_DISK },
-			(dependencies) => {
+			(dependencies, optionalDependencies) => {
 				pendingIdleTasks.set(BUILD_DEPENDENCIES_KEY, () =>
 					Promise.resolve().then(() =>
-						strategy.storeBuildDependencies(dependencies)
+						strategy.storeBuildDependencies(dependencies, optionalDependencies)
 					)
 				);
 			}

package/lib/cache/PackFileCacheStrategy.js

@@ -1263,6 +1263,8 @@ class PackFileCacheStrategy {
 		this.buildDependencies = new Set();
 		/** @type {FileSystemDependencies} */
 		this.newBuildDependencies = new LazySet();
+		/** @type {FileSystemDependencies} */
+		this.newOptionalBuildDependencies = new LazySet();
 		/** @type {InstanceType<Snapshot> | undefined} */
 		this.resolveBuildDependenciesSnapshot = undefined;
 		/** @type {ResolveResults | undefined} */
@@ -1492,10 +1494,13 @@ class PackFileCacheStrategy {
 	/**
 	 * Stores build dependencies.
 	 * @param {FileSystemDependencies | Iterable<string>} dependencies dependencies to store
+	 * @param {FileSystemDependencies | Iterable<string>} optionalDependencies optional dependencies to store
+	 * @returns {void}
 	 */
-	storeBuildDependencies(dependencies) {
+	storeBuildDependencies(dependencies, optionalDependencies) {
 		if (this.readonly) return;
 		this.newBuildDependencies.addAll(dependencies);
+		this.newOptionalBuildDependencies.addAll(optionalDependencies);
 	}
 
 	afterAllStored() {
@@ -1512,9 +1517,14 @@ class PackFileCacheStrategy {
 				let promise;
 				/** @type {Set<string>} */
 				const newBuildDependencies = new Set();
+				/** @type {Set<string>} */
+				const optionalBuildDependencies = new Set();
 				for (const dep of this.newBuildDependencies) {
 					if (!this.buildDependencies.has(dep)) {
 						newBuildDependencies.add(dep);
+						if (this.newOptionalBuildDependencies.has(dep)) {
+							optionalBuildDependencies.add(dep);
+						}
 					}
 				}
 				if (newBuildDependencies.size > 0 || !this.buildSnapshot) {
@@ -1533,6 +1543,7 @@ class PackFileCacheStrategy {
 							this.fileSystemInfo.resolveBuildDependencies(
 								this.context,
 								newBuildDependencies,
+								optionalBuildDependencies,
 								(err, result) => {
 									this.logger.timeEnd("resolve build dependencies");
 									if (err) return reject(err);
@@ -1667,6 +1678,7 @@ class PackFileCacheStrategy {
 								this.buildDependencies.add(dep);
 							}
 							this.newBuildDependencies.clear();
+							this.newOptionalBuildDependencies.clear();
 							this.logger.timeEnd("store pack");
 							const stats = pack.getContentStats();
 							this.logger.log(
@@ -1887,6 +1899,7 @@ class PackFileCacheStrategy {
 		this.fileSystemInfo.clear();
 		this.buildDependencies.clear();
 		this.newBuildDependencies.clear();
+		this.newOptionalBuildDependencies.clear();
 		this.resolveBuildDependenciesSnapshot = undefined;
 		this.resolveResults = undefined;
 		this.buildSnapshot = undefined;

package/lib/config/browserslistTargetHandler.js

@@ -428,6 +428,25 @@ const resolve = (browsers) => {
 			// kaios: Not supported
 			node: [16, 9]
 		}),
+		topLevelAwait: rawChecker({
+			chrome: 89,
+			and_chr: 89,
+			edge: 89,
+			firefox: 89,
+			and_ff: 89,
+			// ie: Not supported,
+			opera: 75,
+			op_mob: 63,
+			safari: 15,
+			ios_saf: 15,
+			samsung: 15,
+			android: 89,
+			// and_qq: Not supported
+			// baidu: Not supported
+			// and_uc: Not supported
+			// kaios: Not supported
+			node: [14, 8]
+		}),
 		spread: rawChecker({
 			chrome: 60,
 			and_chr: 60,