webpack 5.110.3 → 5.111.0

package/types.d.ts

@@ -4,7 +4,6 @@
  * Run `yarn fix:special` to update
  */
 
-import { Parser as ParserImport } from "acorn";
 import { Buffer } from "buffer";
 import {
 	ArrayExpression,
@@ -58,7 +57,7 @@ import {
 	ObjectExpression,
 	ObjectPattern,
 	PrivateIdentifier,
-	Program,
+	Program as ProgramImport,
 	Property,
 	PropertyDefinition,
 	RegExpLiteral,
@@ -67,7 +66,7 @@ import {
 	SequenceExpression,
 	SimpleCallExpression,
 	SimpleLiteral,
-	SourceLocation,
+	SourceLocation as SourceLocationImport,
 	SpreadElement,
 	StaticBlock,
 	Super,
@@ -330,6 +329,11 @@ declare interface AllCodeGenerationSchemas {
 	 */
 	chunkInitFragments: InitFragment<any>[];
 
+	/**
+	 * native external reexport source and attributes
+	 */
+	externalReexport: string;
+
 	/**
 	 * url for asset modules
 	 */
@@ -355,18 +359,6 @@ declare interface AllCodeGenerationSchemas {
 	 */
 	"share-init": [{ shareScope: string; initStage: number; init: string }];
 }
-declare interface AnalyzableChunkUrls {
-	/**
-	 * the urls that could be written, by chunk id
-	 */
-	urls: Map<ChunkId, string>;
-
-	/**
-	 * false when some chunk kept the runtime form, whose
-	 * ids the consumer then still resolves through the runtime name lookup
-	 */
-	complete: boolean;
-}
 type AnalyzableForm =
 	"import" | "url" | "url-runtime" | "url-inline" | "wasm" | "wasm-relative";
 type AnyLoaderContext = NormalModuleLoaderContext<any> &
@@ -586,6 +578,28 @@ declare abstract class AssetSourceGenerator extends Generator {
 	): null | Source;
 }
 declare abstract class AssetSourceParser extends ParserClass {}
+declare interface AssetSymlink {
+	/**
+	 * what the link points at, left as it is written
+	 */
+	target: string;
+
+	/**
+	 * whether it points at a directory, which is what Windows needs in order to create one
+	 */
+	isDirectory: boolean;
+}
+declare interface AssetTimestamps {
+	/**
+	 * last access time, in milliseconds
+	 */
+	atime: number;
+
+	/**
+	 * last modification time, in milliseconds
+	 */
+	mtime: number;
+}
 declare class AsyncDependenciesBlock extends DependenciesBlock {
 	constructor(
 		groupOptions: null | string | GroupOptionsAsyncDependenciesBlock,
@@ -880,7 +894,7 @@ declare interface BasenameCacheEntry {
  */
 declare abstract class BasicEvaluatedExpression {
 	expression?:
-		| Program
+		| ProgramImport
 		| ImportDeclaration
 		| ExportNamedDeclaration
 		| ExportAllDeclaration
@@ -1139,7 +1153,7 @@ declare abstract class BasicEvaluatedExpression {
 	 */
 	setExpression(
 		expression?:
-			| Program
+			| ProgramImport
 			| ImportDeclaration
 			| ExportNamedDeclaration
 			| ExportAllDeclaration
@@ -1229,6 +1243,17 @@ declare interface Bootstrap {
 	afterStartup: string[];
 	allowInlineStartup: boolean;
 }
+
+/**
+ * Which disjunction branch a named group sits in, so that the same name in two
+ * alternatives of one disjunction is allowed and a repeat in one is not.
+ */
+declare abstract class BranchID {
+	parent: null | BranchID;
+	base: BranchID;
+	separatedFrom(alt: BranchID): boolean;
+	sibling(): BranchID;
+}
 type BufferEncoding =
 	| "ascii"
 	| "utf8"
@@ -1283,8 +1308,82 @@ declare interface BufferedMap {
 	 */
 	file: string;
 }
+type BuildDependencyItem =
+	| string
+	| {
+			/**
+			 * Request to a dependency (resolved as directory relative to the context directory).
+			 */
+			dependency: string;
+			/**
+			 * When true, the dependency may be missing. Existence changes invalidate the cache.
+			 */
+			optional?: boolean;
+	  };
+declare interface BuildDiagnostics {
+	/**
+	 * what parser plugins reported as optimization bailouts, replayed into the module graph of every compilation that reuses the module
+	 */
+	optimizationBailouts?: string[];
+
+	/**
+	 * the statement whose side effect keeps the module in the bundle, as `type at location`
+	 */
+	sideEffectStatement?: string;
+
+	/**
+	 * how many `#__PURE__` annotations sit where the parser does not read them
+	 */
+	ineffectivePureAnnotations?: number;
+
+	/**
+	 * how many times the module reads `this` at its top level
+	 */
+	topLevelThis?: number;
+
+	/**
+	 * true when the module calls `eval` directly
+	 */
+	usesEval?: boolean;
+
+	/**
+	 * reasons why the module is not cacheable (e.g. paths of loaders that marked it)
+	 */
+	notCacheableReasons?: string[];
+}
 type BuildInfo = KnownBuildInfo & Record<string, any>;
 type BuildMeta = KnownBuildMeta & Record<string, any>;
+declare interface BuiltinEmbeddedRendererOptions {
+	/**
+	 * what the target can read (the CSS entries of `output.environment`), so a spelling it would not understand is never reached for; only read while printing, and an absent entry means the modern spelling is available
+	 */
+	environment?: CssEnvironment;
+
+	/**
+	 * rewrite a length into a shorter unit it is exactly equal in (`16px` -> `1pc`); off by default because it earns nothing once the asset is compressed, and only read while printing. A time is always rewritten
+	 */
+	convertLengthUnits?: boolean;
+
+	/**
+	 * shorten a custom property's value the way any other value is shortened (`--x:#ffffff` -> `#fff`); off by default because `getPropertyValue()` hands that text back, and only read while printing. What it may rewrite is what any other value's tokens may be, a color in a substitution's fallback included — that being the property's value rather than the function's own argument
+	 */
+	rewriteCustomProperties?: boolean;
+
+	/**
+	 * which of the meaning-preserving rewrites the minifying print makes; each is on unless it is `false`
+	 */
+	transforms?: CssTransformOptions;
+
+	/**
+	 * names a whole-project analysis found unused, which the print takes out: a bare name is a class, an id and an `@keyframes` name, and a `--`-prefixed one is a custom property. Only read while printing
+	 */
+	unusedSymbols?: string[];
+
+	/**
+	 * each pseudo-class to write as a class instead (`{ "focus-visible": "focus-visible" }`), so a script can apply it where the engine does not. Only read while printing
+	 */
+	pseudoClasses?: { [index: string]: string };
+}
 declare abstract class ByTypeGenerator extends Generator {
 	map: { [index: string]: undefined | Generator };
 	generateError?: (
@@ -1307,7 +1406,9 @@ declare class CacheClass {
 	hooks: {
 		get: AsyncSeriesBailHook<[string, null | Etag, GotHandler<any>[]], any>;
 		store: AsyncParallelHook<[string, null | Etag, any]>;
-		storeBuildDependencies: AsyncParallelHook<[Iterable<string>]>;
+		storeBuildDependencies: AsyncParallelHook<
+			[Iterable<string>, Iterable<string>]
+		>;
 		beginIdle: SyncHook<[]>;
 		endIdle: AsyncParallelHook<[]>;
 		shutdown: AsyncParallelHook<[]>;
@@ -1340,6 +1441,7 @@ declare class CacheClass {
 	 */
 	storeBuildDependencies(
 		dependencies: Iterable<string>,
+		optionalDependencies: Iterable<string>,
 		callback: CallbackCacheCache<void>
 	): void;
 
@@ -3003,6 +3105,7 @@ type CodeGenValue<K extends string> = K extends
 	| "topLevelDeclarations"
 	| "freeNames"
 	| "chunkInitFragments"
+	| "externalReexport"
 	| "url"
 	| "fullContentHash"
 	? AllCodeGenerationSchemas[K]
@@ -3234,7 +3337,7 @@ declare interface ColorsOptions {
 type CommentJavascriptParser = CommentImport & {
 	start: number;
 	end: number;
-	loc?: null | SourceLocation;
+	loc?: null | SourceLocationImport;
 };
 declare interface CommonJsImportSettings {
 	name?: string;
@@ -3540,6 +3643,7 @@ declare class Compilation {
 	contextDependencies: LazySet<string>;
 	missingDependencies: LazySet<string>;
 	buildDependencies: LazySet<string>;
+	optionalBuildDependencies: LazySet<string>;
 
 	/**
 	 * @deprecated
@@ -4353,7 +4457,7 @@ declare class Compiler {
 		check?: (value: T) => boolean
 	): void;
 }
-type ComponentValue = Token | FunctionNode | SimpleBlock;
+type ComponentValue = TokenSyntax | FunctionNode | SimpleBlock;
 declare class ConcatSource extends Source {
 	constructor(...args: ConcatSourceChild[]);
 	getChildren(): Source[];
@@ -4407,18 +4511,18 @@ declare interface ConcatenatedModuleInfo {
 	eager: boolean;
 	module: Module;
 	index: number;
-	ast?: Program;
+	ast?: ProgramImport;
 	internalSource?: Source;
 	source?: ReplaceSource;
 	chunkInitFragments?: InitFragment<ChunkRenderContextJavascriptModulesPlugin>[];
 	runtimeRequirements?: ReadonlySet<string>;
-	globalScope?: Scope;
+	globalScope?: ScopeScopeAnalyzer;
 
 	/**
 	 * the module's free references
 	 */
 	unresolvedReferences?: Reference[];
-	moduleScope?: Scope;
+	moduleScope?: ScopeScopeAnalyzer;
 	internalNames: Map<string, string>;
 	exportMap?: Map<string, string>;
 	rawExportMap?: Map<string, string>;
@@ -5301,6 +5405,167 @@ declare interface ContextTimestampAndHash {
 	symlinks?: Set<string>;
 }
 type ContextTypes = KnownContext & Record<any, any>;
+declare interface CopiedFileData {
+	/**
+	 * absolute path of the source file
+	 */
+	absoluteFilename: string;
+
+	/**
+	 * path of the source file, relative to the compiler context
+	 */
+	sourceFilename: string;
+
+	/**
+	 * path of the copied file, relative to `to`
+	 */
+	filename: string;
+}
+
+/**
+ * Options of the glob in 'from'.
+ */
+declare interface CopyGlobOptions {
+	/**
+	 * Whether the glob matches the case of a file name. Defaults to 'true'.
+	 */
+	caseSensitive?: boolean;
+
+	/**
+	 * How many directory levels below the base of the glob are read, where '1' reads only the base itself. Defaults to no limit.
+	 */
+	deep?: number;
+
+	/**
+	 * Whether the glob reaches a file or a directory whose name starts with a dot without naming it. Defaults to 'true'.
+	 */
+	dot?: boolean;
+
+	/**
+	 * Whether a symbolic link is resolved and copied as what it points at. Defaults to 'true'; 'false' copies the link itself, pointing where it already points.
+	 */
+	followSymlinks?: boolean;
+
+	/**
+	 * Globs of the files which are not copied, resolved like 'from'. A directory one of them matches is skipped whole.
+	 */
+	ignore?: string[];
+}
+
+/**
+ * A pattern of files which are copied to the output directory.
+ */
+declare interface CopyObjectPattern {
+	/**
+	 * Directory 'from' is resolved from and the copied paths are relative to. Defaults to the compiler context, and to what 'from' names when it is not a glob.
+	 */
+	context?: string;
+
+	/**
+	 * Filename template of a copied file inside 'to'. Defaults to '[path][base]', which keeps the name and the directory structure below 'from'.
+	 */
+	filename?: string | ((pathData: PathData, assetInfo?: AssetInfo) => string);
+
+	/**
+	 * Glob or path from where the files are copied.
+	 */
+	from: string | string[];
+
+	/**
+	 * Options of the glob in 'from'.
+	 */
+	globOptions?: CopyGlobOptions;
+
+	/**
+	 * Asset info of a copied file.
+	 */
+	info?: AssetInfo | ((file: CopiedFileData) => AssetInfo);
+
+	/**
+	 * Whether a copied file keeps the permissions of the file it was copied from. Defaults to 'false', which gives it the ones a new file gets. Has no effect on Windows.
+	 */
+	preservePermissions?: boolean;
+
+	/**
+	 * Whether a copied file keeps the access and modification times of the file it was copied from. Defaults to 'false', which stamps it with the time it was written.
+	 */
+	preserveTimestamps?: boolean;
+
+	/**
+	 * Directory the files are copied to, relative to 'output.path', which is where they land by default.
+	 */
+	to?: string | ((file: CopiedFileData) => string);
+
+	/**
+	 * Modifies the content of a copied file.
+	 */
+	transform?:
+		| {
+				/**
+				 * Whether the result of the transform is cached, and what it is cached under. Defaults to 'true'.
+				 */
+				cache?:
+					| boolean
+					| {
+							/**
+							 * Everything beside the content of the file the transform depends on, serialized into the cache key as JSON.
+							 */
+							keys?:
+								| CopyTransformCacheKeys
+								| ((
+										defaultKeys: CopyTransformCacheKeys,
+										absoluteFilename: string
+								  ) =>
+										CopyTransformCacheKeys | Promise<CopyTransformCacheKeys>);
+					  };
+				/**
+				 * Modifies the content of a copied file.
+				 */
+				transformer: (
+					content: Buffer,
+					absoluteFilename: string
+				) => string | Buffer | Promise<string | Buffer>;
+		  }
+		| ((
+				content: Buffer,
+				absoluteFilename: string
+		  ) => string | Buffer | Promise<string | Buffer>);
+}
+
+/**
+ * Patterns of files which are copied to the output directory, and the options of the copying itself.
+ */
+declare interface CopyOptions {
+	/**
+	 * Maximum number of files which are read at the same time. Defaults to '100'.
+	 */
+	concurrency?: number;
+
+	/**
+	 * Patterns of files which are copied to the output directory.
+	 */
+	patterns: CopyPattern[];
+
+	/**
+	 * Stage of 'processAssets' the files are copied at. Defaults to 'Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL', where a copied file is still minimized and compressed like every other asset; a later stage leaves it as it is on disk.
+	 */
+	stage?: number;
+}
+type CopyPattern = string | CopyObjectPattern;
+declare class CopyPlugin {
+	constructor(options: CopyOptions);
+	patterns: CopyPattern[];
+	concurrency: number;
+	stage: number;
+
+	/**
+	 * Apply the plugin
+	 */
+	apply(compiler: Compiler): void;
+}
+declare interface CopyTransformCacheKeys {
+	[index: string]: any;
+}
 type CreateData = NormalModuleCreateData & { settings: ModuleSettings };
 type CreateReadStreamFSImplementation = FSImplementation & {
 	read: (...args: any[]) => any;
@@ -5504,6 +5769,11 @@ declare class CssLoadingRuntimeModule extends RuntimeModule {
 		linkInsert: SyncWaterfallHook<[string, Chunk], string>;
 	};
 
+	/**
+	 * The answer a runtime module gives when it installs no chunk handler at all
+	 */
+	static NO_CHUNK_HANDLERS: [string, string][];
+
 	/**
 	 * Runtime modules without any dependencies to other runtime modules
 	 */
@@ -5943,6 +6213,11 @@ declare interface CssPrintOptions {
 	 */
 	convertLengthUnits?: boolean;
 
+	/**
+	 * give a rule the selectors of a later one printing the same block, past the rules between them; off by default, since it reorders the cascade and is sound only where nothing between declares what the block does
+	 */
+	mergeDistantRules?: boolean;
+
 	/**
 	 * shorten a custom property's value the way any other value is shortened (`--x:#ffffff` -> `#fff`); off by default because `getPropertyValue()` hands that text back, and only read while printing. What it may rewrite is what any other value's tokens may be, a color in a substitution's fallback included — that being the property's value rather than the function's own argument
 	 */
@@ -5957,6 +6232,16 @@ declare interface CssPrintOptions {
 	 * which of the meaning-preserving rewrites the minifying print makes; each is on unless it is `false`
 	 */
 	transforms?: CssTransformOptions;
+
+	/**
+	 * names a whole-project analysis found unused, which the print takes out: a bare name is a class, an id and an `@keyframes` name, and a `--`-prefixed one is a custom property. Only read while printing
+	 */
+	unusedSymbols?: string[];
+
+	/**
+	 * each pseudo-class to write as a class instead (`{ "focus-visible": "focus-visible" }`), so a script can apply it where the engine does not. Only read while printing
+	 */
+	pseudoClasses?: { [index: string]: string };
 }
 declare interface CssProcessOptions {
 	/**
@@ -6004,6 +6289,11 @@ declare interface CssProcessOptions {
 	 */
 	convertLengthUnits?: boolean;
 
+	/**
+	 * give a rule the selectors of a later one printing the same block, past the rules between them; off by default, since it reorders the cascade and is sound only where nothing between declares what the block does
+	 */
+	mergeDistantRules?: boolean;
+
 	/**
 	 * shorten a custom property's value the way any other value is shortened (`--x:#ffffff` -> `#fff`); off by default because `getPropertyValue()` hands that text back, and only read while printing. What it may rewrite is what any other value's tokens may be, a color in a substitution's fallback included — that being the property's value rather than the function's own argument
 	 */
@@ -6017,6 +6307,16 @@ declare interface CssProcessOptions {
 		info: { type: string; hostType: string }
 	) => undefined | string;
 
+	/**
+	 * each pseudo-class to write as a class instead (`{ "focus-visible": "focus-visible" }`), so a script can apply it where the engine does not. Only read while printing
+	 */
+	pseudoClasses?: { [index: string]: string };
+
+	/**
+	 * names a whole-project analysis found unused, which the print takes out: a bare name is a class, an id and an `@keyframes` name, and a `--`-prefixed one is a custom property. Only read while printing
+	 */
+	unusedSymbols?: string[];
+
 	/**
 	 * which of the meaning-preserving rewrites the minifying print makes; each is on unless it is `false`
 	 */
@@ -6028,11 +6328,36 @@ declare interface CssProcessOptions {
 	deferEmbeddedSource?: DeferredEmbeddedSource[];
 }
 declare interface CssTransformOptions {
+	/**
+	 * write a color the target cannot read as an extra declaration before it, in a spelling it does read
+	 */
+	colorFallbacks?: boolean;
+
+	/**
+	 * write a spelling the target cannot read as one it can — the same value, said another way
+	 */
+	lowerUnsupported?: boolean;
+
+	/**
+	 * write a name that matches ASCII case-insensitively — an at-rule, property, pseudo, function, unit or keyword — in lowercase
+	 */
+	foldCase?: boolean;
+
+	/**
+	 * write an escaped identifier the shortest way that names it, in a value or an id
+	 */
+	rewriteEscapes?: boolean;
+
 	/**
 	 * which comments survive: `"some"` (the default) the ones that carry something, `true` / `"all"` every one, `false` none, or the ones a pattern matches / a predicate accepts, over the comment's own text
 	 */
 	comments?: string | boolean | RegExp | ((comment: string) => boolean);
 
+	/**
+	 * write the query or selector list a `@custom-media` / `@custom-selector` names wherever one asks for it, and drop the rule that named it
+	 */
+	resolveCustomAtRules?: boolean;
+
 	/**
 	 * write a family of longhands as the one shorthand that sets them
 	 */
@@ -6058,6 +6383,11 @@ declare interface CssTransformOptions {
 	 */
 	removeDeadRules?: boolean;
 
+	/**
+	 * write a `:dir()` the target cannot read as the `[dir]` attribute selector, which reads the attribute rather than the directionality an element may inherit
+	 */
+	rewriteDirSelector?: boolean;
+
 	/**
 	 * write each color in the shortest spelling of the same value
 	 */
@@ -6205,8 +6535,8 @@ declare class DelegatedPlugin {
 	/**
 	 * Creates an instance of DelegatedPlugin.
 	 */
-	constructor(options: Options);
-	options: Options;
+	constructor(options: OptionsDelegatedModuleFactoryPlugin);
+	options: OptionsDelegatedModuleFactoryPlugin;
 
 	/**
 	 * Applies the plugin by registering its hooks on the compiler.
@@ -7018,6 +7348,34 @@ declare class DynamicEntryPlugin {
 	 */
 	apply(compiler: Compiler): void;
 }
+type EcmaVersion =
+	| 3
+	| 5
+	| 6
+	| 7
+	| 8
+	| 9
+	| 10
+	| 11
+	| 12
+	| 13
+	| 14
+	| 15
+	| 16
+	| 17
+	| 2015
+	| 2016
+	| 2017
+	| 2018
+	| 2019
+	| 2020
+	| 2021
+	| 2022
+	| 2023
+	| 2024
+	| 2025
+	| 2026
+	| "latest";
 type Effect = EffectUse | EffectBasic;
 declare interface EffectBasic {
 	type: string;
@@ -7665,6 +8023,12 @@ declare interface Environment {
 	 * The environment supports template literals.
 	 */
 	templateLiteral?: boolean;
+
+	/**
+	 * The environment supports top-level await ('await x' at the top level of a module).
+	 * @since 5.111.0
+	 */
+	topLevelAwait?: boolean;
 }
 declare class EnvironmentPlugin {
 	/**
@@ -7872,13 +8236,6 @@ declare interface Experiments {
 	 */
 	lazyCompilation?: boolean | LazyCompilationOptions;
 
-	/**
-	 * Allow output javascript files as module source type.
-	 * @since 5.0.0
-	 * @experimental
-	 */
-	outputModule?: boolean;
-
 	/**
 	 * Enable experimental tc39 proposal https://github.com/tc39/proposal-source-phase-imports. This allows importing modules at source phase.
 	 * @since 5.106.0
@@ -7968,13 +8325,6 @@ declare interface ExperimentsNormalized {
 	 */
 	lazyCompilation?: false | LazyCompilationOptions;
 
-	/**
-	 * Allow output javascript files as module source type.
-	 * @since 5.0.0
-	 * @experimental
-	 */
-	outputModule?: boolean;
-
 	/**
 	 * Enable experimental tc39 proposal https://github.com/tc39/proposal-source-phase-imports. This allows importing modules at source phase.
 	 * @since 5.106.0
@@ -8490,7 +8840,7 @@ declare interface ExposesConfig {
 declare interface ExposesObject {
 	[index: string]: string | ExposesConfig | string[];
 }
-type Expression =
+type ExpressionEstreeIndex =
 	| ImportExpressionImport
 	| UnaryExpression
 	| ArrayExpression
@@ -8526,6 +8876,38 @@ declare interface ExpressionExpressionInfo {
 	getMembersOptionals: () => boolean[];
 	getMemberRanges: () => [number, number][];
 }
+type ExpressionParser =
+	| (ImportExpressionImport & NodeLike)
+	| (UnaryExpression & NodeLike)
+	| (ArrayExpression & NodeLike)
+	| (ArrowFunctionExpression & NodeLike)
+	| (AssignmentExpression & NodeLike)
+	| (AwaitExpression & NodeLike)
+	| (BinaryExpression & NodeLike)
+	| (SimpleCallExpression & NodeLike)
+	| (NewExpression & NodeLike)
+	| (ChainExpression & NodeLike)
+	| (ClassExpression & NodeLike)
+	| (ConditionalExpression & NodeLike)
+	| (FunctionExpression & NodeLike)
+	| (Identifier & NodeLike)
+	| (SimpleLiteral & NodeLike)
+	| (RegExpLiteral & NodeLike)
+	| (BigIntLiteral & NodeLike)
+	| (LogicalExpression & NodeLike)
+	| (MemberExpression & NodeLike)
+	| (MetaProperty & NodeLike)
+	| (ObjectExpression & NodeLike)
+	| (SequenceExpression & NodeLike)
+	| (TaggedTemplateExpression & NodeLike)
+	| (TemplateLiteral & NodeLike)
+	| (ThisExpression & NodeLike)
+	| (UpdateExpression & NodeLike)
+	| (YieldExpression & NodeLike)
+	| (NodeLike & {
+			type: "ParenthesizedExpression";
+			expression: ExpressionParser;
+	  });
 declare interface ExtensionAliasOption {
 	alias: string | string[];
 	extension: string;
@@ -8700,6 +9082,12 @@ declare class ExternalModule extends Module {
 		normalModuleFactory: NormalModuleFactory
 	): void;
 	canBeWrappedInConcatenation(): boolean;
+
+	/**
+	 * The request this external resolves to for its own type, with the record form
+	 * narrowed to its entry. An array is a module specifier plus a property path.
+	 */
+	getResolvedRequest(): undefined | string | string[];
 	static getCompilationHooks: (compilation: Compilation) => {
 		/**
 		 * @since 5.106.0
@@ -8773,6 +9161,11 @@ declare interface ExternalModuleInfo {
 	 */
 	deferredNamespaceObjectName?: string;
 
+	/**
+	 * an import reads the spec namespace object the module hands out
+	 */
+	specNamespaceObjectUsed: boolean;
+
 	/**
 	 * "default-with-named" namespace
 	 */
@@ -9102,7 +9495,7 @@ declare interface FileCacheOptions {
 	/**
 	 * Dependencies the build depends on (in multiple categories, default categories: 'defaultWebpack').
 	 */
-	buildDependencies?: { [index: string]: string[] };
+	buildDependencies?: { [index: string]: BuildDependencyItem[] };
 
 	/**
 	 * Base directory for the cache (defaults to node_modules/.cache/webpack).
@@ -9333,6 +9726,7 @@ declare abstract class FileSystemInfo {
 	resolveBuildDependencies(
 		context: string,
 		deps: Iterable<string>,
+		optionalDeps: undefined | Iterable<string>,
 		callback: (
 			err?: null | Error,
 			resolveBuildDependenciesResult?: ResolveBuildDependenciesResult
@@ -9623,6 +10017,11 @@ declare class GetChunkFilenameRuntimeModule extends RuntimeModule {
 		| ((pathData: PathDataChunk, assetInfo?: AssetInfo) => string);
 	allChunks: boolean;
 
+	/**
+	 * The answer a runtime module gives when it installs no chunk handler at all
+	 */
+	static NO_CHUNK_HANDLERS: [string, string][];
+
 	/**
 	 * Runtime modules without any dependencies to other runtime modules
 	 */
@@ -10114,6 +10513,7 @@ declare interface HtmlEmittedContext {
 declare interface HtmlEntryInfo {
 	request: string;
 	entryName: string;
+	index: number;
 	type:
 		| "html"
 		| "script"
@@ -10225,7 +10625,7 @@ declare class HtmlModulesPlugin {
 	 */
 	static computeContentHash(
 		content: string | Buffer,
-		outputOptions: Output
+		outputOptions: OutputNormalizedWithDefaults
 	): string;
 
 	/**
@@ -10235,9 +10635,14 @@ declare class HtmlModulesPlugin {
 	 */
 	static getChunkFilenameTemplate(
 		chunk: Chunk,
-		outputOptions: Output
+		outputOptions: OutputNormalizedWithDefaults
 	): ChunkFilenameTemplate;
 
+	/**
+	 * Returns true, when the chunk has html.
+	 */
+	static chunkHasHtml(chunk: Chunk, chunkGraph: ChunkGraph): boolean;
+
 	/**
 	 * Per-compilation hooks for the experimental HTML support.
 	 */
@@ -10381,14 +10786,11 @@ declare interface HtmlParserOptions {
 	 */
 	urlHints?: UrlHintRule[];
 }
-type HtmlPrintOptions = Pick<
-	CssProcessOptions,
-	"environment" | "convertLengthUnits" | "rewriteCustomProperties"
-> & {
-	cssTransforms?: CssTransformOptions;
+declare interface HtmlPrintOptions {
 	transforms?: HtmlTransformOptions;
 	collapseWhitespace?: boolean | "all" | "conservative" | "smart";
 	mergeStyles?: boolean;
+	mergeScripts?: boolean;
 	removeEmptyAttributes?: boolean;
 	removeEmptyElements?: boolean;
 	removeRedundantAttributes?: boolean | "all" | "smart";
@@ -10401,7 +10803,7 @@ type HtmlPrintOptions = Pick<
 	) => undefined | string;
 	deferEmbeddedSource?: DeferredEmbeddedSource[];
 	deferSrcdoc?: boolean;
-};
+}
 declare interface HtmlProcessOptions {
 	/**
 	 * context element tag name for fragment parsing (see `parseHtml`); the HTML analog of the CSS parser's `as` parse-mode option
@@ -10418,26 +10820,6 @@ declare interface HtmlProcessOptions {
 	 */
 	minimize?: boolean;
 
-	/**
-	 * CSS's, not HTML's: handed to the CSS minifier that runs over an inline `<style>` and every `style=""`, so the inline copy of a declaration agrees with the `.css` asset
-	 */
-	environment?: CssEnvironment;
-
-	/**
-	 * CSS's too, handed over with `environment` (see `HtmlPrintOptions`)
-	 */
-	convertLengthUnits?: boolean;
-
-	/**
-	 * CSS's too, handed over with `environment` (see `HtmlPrintOptions`)
-	 */
-	rewriteCustomProperties?: boolean;
-
-	/**
-	 * CSS's per-transform switches too, handed over with `environment` (see `HtmlPrintOptions`)
-	 */
-	cssTransforms?: CssTransformOptions;
-
 	/**
 	 * which of the meaning-preserving rewrites the minifying print makes; each is on unless it is `false`
 	 */
@@ -10463,6 +10845,11 @@ declare interface HtmlProcessOptions {
 	 */
 	mergeStyles?: boolean;
 
+	/**
+	 * print a run of adjacent bare `<script>` elements whose bodies this print writes itself as one, which removes elements, hoists a later body's declarations into the ones before it, and lets a failing body end the whole run (default false)
+	 */
+	mergeScripts?: boolean;
+
 	/**
 	 * print an element's attributes commonest name first, ties by name, which nothing in HTML reads (default false)
 	 */
@@ -10489,12 +10876,12 @@ declare interface HtmlProcessOptions {
 	deferSrcdoc?: boolean;
 
 	/**
-	 * collects what `renderEmbeddedSource` would be offered instead of offering it, for a caller whose renderer is asynchronous: the print leaves a marker for each and `finish` puts the answers in their place, so one parse serves both. A `style=""` stays with the built-in CSS minifier, whose text this print reads back to decide how the attribute is written. Takes precedence over `renderEmbeddedSource`
+	 * collects what `renderEmbeddedSource` would be offered instead of offering it, for a caller whose renderer is asynchronous: the print leaves a marker for each and `finish` puts the answers in their place, so one parse serves both. Takes precedence over `renderEmbeddedSource`
 	 */
 	deferEmbeddedSource?: DeferredEmbeddedSource[];
 
 	/**
-	 * renders each nested body this document embeds — an inline `<style>`, every `style=""` (handed over as a whole stylesheet, SVG's and MathML's included), a `<script>` holding JSON or JavaScript, an `<svg>` subtree, and the document an `<iframe srcdoc>` holds (decoded, and written back escaped). Replaces the built-in CSS and JSON minifiers wherever it answers, and returning anything but text falls back to them; it is the only way inline JavaScript, SVG and a nested document are reached at all
+	 * renders each nested body this document embeds — an inline `<style>`, every `style=""` (as the block's contents it is, SVG's and MathML's included), a `<script>` holding JSON or JavaScript (with `as` naming which production of it the body is — `"module"` for a `<script type=module>`, `"script"` for a classic one), every event handler attribute, with `as: "event-handler"` saying it is a function body rather than a script — the production a `return` at its top level is in, which a renderer whose engine takes only whole scripts wraps before it reads — an `<svg>` subtree, and the document an `<iframe srcdoc>` holds (decoded, and written back escaped). The only way any of them is minified: webpack minifies nothing here itself, and `builtinEmbeddedRenderer` is its own CSS and JSON minifiers for a caller to pass; returning anything but text leaves a body as written
 	 */
 	renderEmbeddedSource?: (
 		source: string,
@@ -10749,25 +11136,15 @@ declare interface HtmlTransformHtmlContext {
 }
 declare interface HtmlTransformOptions {
 	/**
-	 * write a boolean attribute spelled with its own name (`disabled="disabled"`) as the bare name
+	 * write a boolean attribute as the bare name its presence already means; `true` only the spellings the spec canonicalizes, `"all"` any value
 	 */
-	collapseBooleanAttributes?: boolean;
+	collapseBooleanAttributes?: boolean | "all";
 
 	/**
 	 * which comments survive: `"some"` (the default) the ones that carry something, `true` / `"all"` every one, `false` none, or the ones a pattern matches / a predicate accepts, over the comment's own text. A comment a parser or a server reads is kept whatever this says
 	 */
 	comments?: string | boolean | RegExp | ((comment: string) => boolean);
 
-	/**
-	 * strip the whitespace between a JSON `<script>`'s tokens
-	 */
-	minifyJson?: boolean;
-
-	/**
-	 * run the CSS minifier over an inline `<style>` and every `style=""`
-	 */
-	minifyStyles?: boolean;
-
 	/**
 	 * drop or re-pick an attribute value's quotes
 	 */
@@ -10788,6 +11165,11 @@ declare interface HtmlTransformOptions {
 	 */
 	normalizeNumericAttributes?: boolean;
 
+	/**
+	 * drop the whitespace around a URL value (`href`, `src`, `action`, …), which resolving the URL skips over
+	 */
+	normalizeUrlAttributes?: boolean;
+
 	/**
 	 * leave out an optional tag other than the `<html>` / `<head>` / `<body>` shell, which is `removeImpliedTags`
 	 */
@@ -11434,13 +11816,19 @@ declare class InitFragment<GenerateContext> {
 declare abstract class InlinedUsedName {
 	value: InlinedValue;
 	suffix: string[];
-	render(comment: string): string;
+	render(comment?: string): string;
+
+	/**
+	 * Updates the hash with the data contributed by this instance.
+	 */
+	updateHash(hash: Hash): void;
 }
 declare abstract class InlinedValue {
 	kind: InlinedValueKind;
 	value?: null | string | number | boolean;
 	renderLiteral(): string;
 	render(comment: string): string;
+	equals(other: InlinedValue): boolean;
 	serialize(__0: ObjectSerializerContextObjectMiddlewareObject_3): void;
 	deserialize(__0: ObjectDeserializerContextObjectMiddlewareObject_2): void;
 }
@@ -12599,10 +12987,13 @@ declare class JavascriptParser extends ParserClass {
 		/**
 		 * @since 5.105.0
 		 */
-		collectGuards: SyncBailHook<[Expression], void | GuardCollection>;
+		collectGuards: SyncBailHook<
+			[ExpressionEstreeIndex],
+			void | GuardCollection
+		>;
 		classExtendsExpression: SyncBailHook<
 			[
-				Expression,
+				ExpressionEstreeIndex,
 				ClassExpression | ClassDeclaration | MaybeNamedClassDeclaration
 			],
 			boolean | void
@@ -12619,7 +13010,7 @@ declare class JavascriptParser extends ParserClass {
 		 */
 		classBodyValue: SyncBailHook<
 			[
-				Expression,
+				ExpressionEstreeIndex,
 				MethodDefinition | PropertyDefinition,
 				ClassExpression | ClassDeclaration | MaybeNamedClassDeclaration
 			],
@@ -12728,16 +13119,16 @@ declare class JavascriptParser extends ParserClass {
 		 * @since 5.101.3
 		 */
 		collectDestructuringAssignmentProperties: SyncBailHook<
-			[Expression],
+			[ExpressionEstreeIndex],
 			boolean | void
 		>;
-		canRename: HookMap<SyncBailHook<[Expression], boolean | void>>;
-		rename: HookMap<SyncBailHook<[Expression], boolean | void>>;
+		canRename: HookMap<SyncBailHook<[ExpressionEstreeIndex], boolean | void>>;
+		rename: HookMap<SyncBailHook<[ExpressionEstreeIndex], boolean | void>>;
 		assign: HookMap<SyncBailHook<[AssignmentExpression], boolean | void>>;
 		assignMemberChain: HookMap<
 			SyncBailHook<[AssignmentExpression, string[]], boolean | void>
 		>;
-		typeof: HookMap<SyncBailHook<[Expression], boolean | void>>;
+		typeof: HookMap<SyncBailHook<[ExpressionEstreeIndex], boolean | void>>;
 		importCall: SyncBailHook<
 			[
 				ImportExpressionJavascriptParser,
@@ -12788,7 +13179,13 @@ declare class JavascriptParser extends ParserClass {
 		>;
 		memberChainOfCallMemberChain: HookMap<
 			SyncBailHook<
-				[Expression, string[], CallExpression, string[], [number, number][]],
+				[
+					ExpressionEstreeIndex,
+					string[],
+					CallExpression,
+					string[],
+					[number, number][]
+				],
 				boolean | void
 			>
 		>;
@@ -12810,7 +13207,7 @@ declare class JavascriptParser extends ParserClass {
 		 * @since 5.71.0
 		 */
 		binaryExpression: SyncBailHook<[BinaryExpression], boolean | void>;
-		expression: HookMap<SyncBailHook<[Expression], boolean | void>>;
+		expression: HookMap<SyncBailHook<[ExpressionEstreeIndex], boolean | void>>;
 		expressionMemberChain: HookMap<
 			SyncBailHook<
 				[MemberExpression, string[], boolean[], [number, number][]],
@@ -12828,12 +13225,18 @@ declare class JavascriptParser extends ParserClass {
 			[LogicalExpression],
 			boolean | void
 		>;
-		program: SyncBailHook<[Program, CommentJavascriptParser[]], boolean | void>;
+		program: SyncBailHook<
+			[ProgramImport, CommentJavascriptParser[]],
+			boolean | void
+		>;
 		/**
 		 * @since 5.99.0
 		 */
 		terminate: SyncBailHook<[ReturnStatement | ThrowStatement], boolean | void>;
-		finish: SyncBailHook<[Program, CommentJavascriptParser[]], boolean | void>;
+		finish: SyncBailHook<
+			[ProgramImport, CommentJavascriptParser[]],
+			boolean | void
+		>;
 		/**
 		 * @since 5.99.9
 		 */
@@ -12911,7 +13314,7 @@ declare class JavascriptParser extends ParserClass {
 		| ForOfStatement
 		| ExportDefaultDeclaration;
 	destructuringAssignmentProperties?: WeakMap<
-		Expression,
+		ExpressionEstreeIndex,
 		Set<DestructuringAssignmentProperty>
 	>;
 	currentTagData?:
@@ -12927,7 +13330,7 @@ declare class JavascriptParser extends ParserClass {
 	 * Destructuring assignment properties for.
 	 */
 	destructuringAssignmentPropertiesFor(
-		node: Expression
+		node: ExpressionEstreeIndex
 	): undefined | Set<DestructuringAssignmentProperty>;
 
 	/**
@@ -13385,7 +13788,7 @@ declare class JavascriptParser extends ParserClass {
 	 */
 	enterDestructuringAssignment(
 		pattern: Pattern,
-		expression: Expression
+		expression: ExpressionEstreeIndex
 	):
 		| undefined
 		| ImportExpressionImport
@@ -14076,12 +14479,14 @@ declare class JavascriptParser extends ParserClass {
 	/**
 	 * Returns parsed string.
 	 */
-	parseString(expression: Expression): string;
+	parseString(expression: ExpressionEstreeIndex): string;
 
 	/**
 	 * Parses calculated string.
 	 */
-	parseCalculatedString(expression: Expression): CalculatedStringResult;
+	parseCalculatedString(
+		expression: ExpressionEstreeIndex
+	): CalculatedStringResult;
 
 	/**
 	 * Returns evaluation result.
@@ -14142,7 +14547,7 @@ declare class JavascriptParser extends ParserClass {
 		start?: number;
 		end?: number;
 		range?: [number, number];
-		loc?: null | SourceLocation;
+		loc?: null | SourceLocationImport;
 	}): DependencyLocation;
 
 	/**
@@ -14180,7 +14585,7 @@ declare class JavascriptParser extends ParserClass {
 	/**
 	 * Checks whether this javascript parser is statement level expression.
 	 */
-	isStatementLevelExpression(expr: Expression): boolean;
+	isStatementLevelExpression(expr: ExpressionEstreeIndex): boolean;
 
 	/**
 	 * Returns tag data.
@@ -14439,7 +14844,7 @@ declare class JavascriptParser extends ParserClass {
 	 * Gets name for expression.
 	 */
 	getNameForExpression(
-		expression: Expression
+		expression: ExpressionEstreeIndex
 	):
 		| undefined
 		| {
@@ -14452,7 +14857,7 @@ declare class JavascriptParser extends ParserClass {
 	 * Returns parser.
 	 */
 	static extend(
-		...plugins: ((BaseParser: typeof ParserImport) => typeof ParserImport)[]
+		...plugins: ((BaseParser: typeof ParserParser) => typeof ParserParser)[]
 	): typeof JavascriptParser;
 	static ALLOWED_MEMBER_TYPES_ALL: number;
 	static ALLOWED_MEMBER_TYPES_CALL_EXPRESSION: number;
@@ -14645,6 +15050,12 @@ declare interface JavascriptParserOptions {
 	 */
 	sourceImport?: boolean;
 
+	/**
+	 * Hand out a spec-compliant Module Namespace Exotic Object for 'import * as ns' and 'import()' of this module instead of the plain exports object. Requires 'Proxy' in the target environment, keeps every exported name, and costs runtime code, so enable it per module. Set it on the imported module, not on the importer.
+	 * @since 5.111.0
+	 */
+	specNamespaceObject?: boolean;
+
 	/**
 	 * Deprecated in favor of "exportsPresence". Emit errors instead of warnings when imported names don't exist in imported module.
 	 * @deprecated
@@ -14830,6 +15241,11 @@ declare class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 		compilation: Compilation
 	) => JsonpCompilationPluginHooks;
 
+	/**
+	 * The answer a runtime module gives when it installs no chunk handler at all
+	 */
+	static NO_CHUNK_HANDLERS: [string, string][];
+
 	/**
 	 * Runtime modules without any dependencies to other runtime modules
 	 */
@@ -14917,6 +15333,26 @@ declare interface KnownAssetInfo {
 	 */
 	sourceFilename?: string;
 
+	/**
+	 * true, when the asset was copied from a file by `output.copy`
+	 */
+	copied?: boolean;
+
+	/**
+	 * when set, the asset is emitted as a symbolic link rather than as its content
+	 */
+	symlink?: AssetSymlink;
+
+	/**
+	 * when set, the file the asset is written to is given these permissions
+	 */
+	mode?: number;
+
+	/**
+	 * when set, the file the asset is written to is stamped with these times
+	 */
+	timestamps?: AssetTimestamps;
+
 	/**
 	 * size in bytes, only set after asset has been emitted
 	 */
@@ -14955,14 +15391,20 @@ declare interface KnownAssetModuleBuildInfo {
 	filename?: string;
 	assetInfo?: AssetInfo;
 	fullContentHash?: string;
+
+	/**
+	 * 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
+	 */
+	assetResource?: string;
 }
 declare interface KnownBuildInfo {
-	cacheable?: boolean;
-
 	/**
-	 * reasons why the module is not cacheable (e.g. paths of loaders that marked it)
+	 * the module hands out a spec Module Namespace Exotic Object
 	 */
-	notCacheableReasons?: string[];
+	specNamespaceObject?: boolean;
+	cacheable?: boolean;
 	strict?: boolean;
 	moduleArgument?: string;
 	exportsArgument?: string;
@@ -14979,29 +15421,24 @@ declare interface KnownBuildInfo {
 	topLevelDeclarations?: Set<string>;
 
 	/**
-	 * true when the module is part of a circular dependency chain
+	 * true when the module is in a synchronous circular dependency chain
 	 */
 	isCircular?: boolean;
 
 	/**
-	 * true when the module calls `eval` directly
-	 */
-	usesEval?: boolean;
-
-	/**
-	 * how many `#__PURE__` annotations sit where the parser does not read them
+	 * CircularKind bit flags from CircularModulesPlugin; unset when the plugin did not run
 	 */
-	ineffectivePureAnnotations?: number;
+	circularKind?: number;
 
 	/**
-	 * how many times the module reads `this` at its top level
+	 * module uses top-level `for await…of` or `await using`, which can't be lowered to a generator
 	 */
-	topLevelThis?: number;
+	usesTopLevelAwaitForOf?: boolean;
 
 	/**
-	 * module uses top-level `for await…of` or `await using`, which can't be lowered to a generator
+	 * what the build recorded for stats and the performance hints to report
 	 */
-	usesTopLevelAwaitForOf?: boolean;
+	diagnostics?: BuildDiagnostics;
 }
 declare interface KnownBuildMeta {
 	exportsType?: "default" | "namespace" | "flagged" | "dynamic";
@@ -15118,6 +15555,11 @@ declare interface KnownJavascriptModuleBuildInfo {
 	 */
 	moduleConcatenationBailout?: string;
 
+	/**
+	 * what rules the module out as a concatenation root, while it may still be an inner module
+	 */
+	moduleConcatenationRootBailout?: string;
+
 	/**
 	 * using in APIPlugin
 	 */
@@ -15644,6 +16086,11 @@ declare interface LStatTypes {
 		) => void
 	): void;
 }
+declare interface LabelLike {
+	kind?: null | string;
+	name?: string;
+	statementStart?: number;
+}
 
 /**
  * Options for the default backend.
@@ -16015,6 +16462,11 @@ declare class LoadScriptRuntimeModule extends HelperRuntimeModule {
 		compilation: Compilation
 	) => LoadScriptCompilationHooks;
 
+	/**
+	 * The answer a runtime module gives when it installs no chunk handler at all
+	 */
+	static NO_CHUNK_HANDLERS: [string, string][];
+
 	/**
 	 * Runtime modules without any dependencies to other runtime modules
 	 */
@@ -16507,7 +16959,7 @@ declare abstract class MainTemplate {
 		options: PathData
 	) => InterpolatedPathAndAssetInfo;
 	get requireFn(): "__webpack_require__";
-	get outputOptions(): Output;
+	get outputOptions(): OutputNormalizedWithDefaults;
 }
 declare interface MakeCacheableResult<T> {
 	(value: string, cache?: object): T;
@@ -17211,6 +17663,11 @@ declare class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 		linkPrefetch: SyncWaterfallHook<[string, Chunk], string>;
 	};
 
+	/**
+	 * The answer a runtime module gives when it installs no chunk handler at all
+	 */
+	static NO_CHUNK_HANDLERS: [string, string][];
+
 	/**
 	 * Runtime modules without any dependencies to other runtime modules
 	 */
@@ -18014,7 +18471,7 @@ declare interface ModuleOptions {
 	defaultRules?: (undefined | null | false | "" | 0 | RuleSetRule | "...")[];
 
 	/**
-	 * Enable warnings for full dynamic dependencies.
+	 * Enable warnings for full dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.exprContextCritical'.
 	 * @deprecated
 	 */
 	exprContextCritical?: boolean;
@@ -18703,7 +19160,7 @@ declare interface NodeEnvironmentPluginOptions {
 	infrastructureLogging: InfrastructureLogging;
 }
 type NodeEstreeIndex =
-	| Program
+	| ProgramImport
 	| ImportDeclaration
 	| ExportNamedDeclaration
 	| ExportAllDeclaration
@@ -18777,6 +19234,14 @@ type NodeEstreeIndex =
 	| AssignmentPattern
 	| SwitchCase
 	| TemplateElement;
+declare interface NodeLike {
+	type: string;
+	start: number;
+	end: number;
+	loc?: any;
+	sourceFile?: string;
+	range?: [number, number];
+}
 
 /**
  * Options object for node compatibility features.
@@ -18963,9 +19428,11 @@ declare class NormalModule extends Module {
 		 */
 		beforeSnapshot: SyncHook<[NormalModule]>;
 		/**
+		 * Async since 5.111.0, so a tap can await work of its own — minifying an
+		 * asset, say, which before only a loader could do. `tap` keeps working.
 		 * @since 5.99.0
 		 */
-		processResult: SyncWaterfallHook<
+		processResult: AsyncSeriesWaterfallHook<
 			[
 				[
 					string | Buffer,
@@ -19774,7 +20241,7 @@ declare namespace ObjectDeserializerContextObjectMiddlewareObject_1 {
 }
 
 /**
- * Updates set size using the provided set.
+ * Updates map size using the provided map.
  */
 declare interface ObjectDeserializerContextObjectMiddlewareObject_2<
 	T extends ReadonlyArray<any> = ReadonlyArray<any>
@@ -19785,7 +20252,7 @@ declare interface ObjectDeserializerContextObjectMiddlewareObject_2<
 }
 
 /**
- * Updates set size using the provided set.
+ * Updates map size using the provided map.
  */
 declare interface ObjectDeserializerContextObjectMiddlewareObject_3 {
 	read: () => string;
@@ -19833,7 +20300,7 @@ declare interface ObjectEncodingOptionsTypes {
 }
 
 /**
- * Updates set size using the provided set.
+ * Updates map size using the provided map.
  */
 declare interface ObjectSerializer {
 	serialize: (
@@ -19846,7 +20313,7 @@ declare interface ObjectSerializer {
 }
 
 /**
- * Updates set size using the provided set.
+ * Updates map size using the provided map.
  */
 declare interface ObjectSerializerContextObjectMiddlewareObject_1 {
 	write: (
@@ -19878,7 +20345,7 @@ declare namespace ObjectSerializerContextObjectMiddlewareObject_2 {
 }
 
 /**
- * Updates set size using the provided set.
+ * Updates map size using the provided map.
  */
 declare interface ObjectSerializerContextObjectMiddlewareObject_3<
 	T extends ReadonlyArray<any> = ReadonlyArray<any>
@@ -19897,7 +20364,7 @@ declare interface ObjectSerializerContextObjectMiddlewareObject_3<
 }
 
 /**
- * Updates set size using the provided set.
+ * Updates map size using the provided map.
  */
 declare interface ObjectSerializerContextObjectMiddlewareObject_4 {
 	write: (
@@ -19916,7 +20383,7 @@ declare interface ObjectSerializerContextObjectMiddlewareObject_4 {
 }
 
 /**
- * Updates set size using the provided set.
+ * Updates map size using the provided map.
  */
 declare interface ObjectSerializerSnapshot {
 	length: number;
@@ -20143,6 +20610,12 @@ declare interface Optimization {
  * @since 5.110.0
  */
 declare interface OptimizationMinimizeCss {
+	/**
+	 * Write a color the `browserslist` target cannot read as an extra declaration before the one naming it, in a spelling it does read: `color: oklch(59.686% 0.15619 49.7694)` is written as `color: #c65d06` and then the `oklch()` itself, so an engine reading neither the Lab family nor `hwb()` is left with a color rather than with nothing. The fallback is that color clipped into the sRGB gamut and rounded, which the declaration standing after it corrects wherever it is read. Nothing is written where the author already set the property earlier in the same block, where the color holds a substitution or a relative reference this cannot fold, or where the fallback would still name a function the target cannot read. On by default, and only in effect for a `browserslist` target — any other target names no browsers to answer for.
+	 * @since 5.111.0
+	 */
+	colorFallbacks?: boolean;
+
 	/**
 	 * Which comments survive. `"some"`, the default, keeps a `/*!` banner and a comment annotated `@license` or `@preserve`; `true` (or `"all"`) keeps every comment and `false` keeps none; a string is read as a regular expression source, and it, a `RegExp` or a `(comment) => boolean` predicate is asked about each comment's own text and keeps the ones it accepts — standing in for the default rule rather than beside it, as terser's `format.comments` does, so a pattern that names nothing else drops the ones `"some"` would have kept. A `/*#` source-map pragma is a link rather than a comment, so `"some"` and `"all"` keep it; `false`, a pattern or a predicate decides it like any other. A predicate is handed to the minimizer's worker pool as source, so it must not close over anything.
 	 * @since 5.110.0
@@ -20155,6 +20628,24 @@ declare interface OptimizationMinimizeCss {
 	 */
 	convertLengthUnits?: boolean;
 
+	/**
+	 * Write a name that matches ASCII case-insensitively in lowercase: an at-rule name, a property name, a pseudo-class or pseudo-element name, a function name, a unit, and a keyword standing in a value whose grammar takes keywords alone. `@MEDIA`, `COLOR`, `:NTH-CHILD`, `URL(`, `1PX` and `currentColor` become `@media`, `color`, `:nth-child`, `url(`, `1px` and `currentcolor`. On by default, and exact: CSS matches every one of these ASCII case-insensitively, so the fold names the same thing. What it never touches is a name the author chose — a custom property, a custom ident such as an animation or grid-area name, an id, a class, a type selector, an attribute's value, or anything inside a substituted value. `@charset` is left as written, being read as bytes rather than matched, and `!important` is always written in lowercase because the printer writes the keyword rather than copying it.
+	 * @since 5.111.0
+	 */
+	foldCase?: boolean;
+
+	/**
+	 * Write a spelling the `browserslist` target cannot read as one it can — the same value said another way, rather than left for an engine that will drop it: a 4-/8-digit hex as `rgba()`, a double-position gradient stop as the two stops it names, `inset` / `overflow` / `place-*` as the longhands they set, `text-decoration` as its own longhands where a slot is newer than the shorthand, `system-ui` as the stack of platform font names it stands for, a `:lang()` or `:not()` holding a list as the `:is()` that means it, a media feature range as the `min-`/`max-` pair, and `light-dark()` as the custom-property pair a color scheme switches. On by default, and only in effect for a `browserslist` target — any other target names no browsers to answer for. Off leaves every such spelling as written, which is how a stylesheet one of these rewrites gets wrong is minified; it never makes the minifier write a spelling the target cannot read.
+	 * @since 5.111.0
+	 */
+	lowerUnsupported?: boolean;
+
+	/**
+	 * Give a rule the selectors of a later one printing the same block, past the rules standing between them. Off by default because it reorders the cascade, so it holds only where nothing between the two declares a property the shared block does. A block repeated at a distance already compresses on its own, so the join is taken only where the copy of the block it drops is worth more than twice the selector it writes instead. `mergeRules` is the safe half of this, joining only what nothing stands between.
+	 * @since 5.111.0
+	 */
+	mergeDistantRules?: boolean;
+
 	/**
 	 * Write a family of longhands as the one shorthand that sets them — four sides or corners, the two a pair shorthand sets, or the slots of an order-free one — even where unrelated declarations stand between them. On by default.
 	 * @since 5.110.0
@@ -20173,6 +20664,12 @@ declare interface OptimizationMinimizeCss {
 	 */
 	normalizeQuotes?: boolean;
 
+	/**
+	 * Each pseudo-class to write as an ordinary class instead, as `{ "focus-visible": "focus-visible" }` — so a script can apply the class where the engine reads no such pseudo. Only a plain pseudo-class is rewritten, wherever it stands in a selector: a pseudo-element (`::hover`) and a functional pseudo of the same name (`:hover(…)`) are not what a class stands in for, and a `:name` inside a quoted attribute value is nobody's pseudo. Nothing applies the class — that is the script's part.
+	 * @since 5.111.0
+	 */
+	pseudoClasses?: { [index: string]: string };
+
 	/**
 	 * Compute a call into the shorter call naming the same value: `calc()` and every math function over constants, a transform naming one axis or an identity, a gradient's default direction and its implied stops, an easing function that has a keyword, and a filter function given the amount an omitted argument already means. On by default.
 	 * @since 5.110.0
@@ -20180,17 +20677,35 @@ declare interface OptimizationMinimizeCss {
 	reduceFunctions?: boolean;
 
 	/**
-	 * Drop a rule or declaration nothing can read: a rule whose block ends up empty, a declaration an identical later one in the same block makes dead, and a rule an identical later sibling makes dead. On by default. Joining rules that are not dead is `mergeRules`.
+	 * Drop a rule or declaration nothing can read: a rule whose block ends up empty, a declaration a later one in the same block overrides, a rule an identical later sibling makes dead, and the `@charset` naming an encoding the output is not written in. On by default. Joining rules that are not dead is `mergeRules`.
 	 * @since 5.110.0
 	 */
 	removeDeadRules?: boolean;
 
+	/**
+	 * Resolve the `@custom-media` and `@custom-selector` at-rules: write the query or the selector list a name stands for wherever one asks for it, and drop the rule that named it. `@custom-media --wide (width>400px)` with `@media (--wide)` becomes `@media (width>400px)`, and `@custom-selector :--heading h1, h2` with `:--heading` becomes `:is(h1, h2)`. Off until asked for: `module.parser.css.customMedia` and `module.parser.css.customSelectors` already resolve both in every stylesheet webpack parses, so this is for a `.css` asset that reached the minimizer without being parsed — one emitted by `asset/resource` or copied in. Only a name stated before the rule asking for it is written out — the rules are read in the order they are written — and a rule naming one this has not come to is left as the author had it. A selector list is written as `:is(…)`, so a name is substituted only where the target reads `:is()`.
+	 * @since 5.111.0
+	 */
+	resolveCustomAtRules?: boolean;
+
 	/**
 	 * Shorten the values of custom properties (`--x: #ffffff` -> `#fff`, `--y: 0.5rem` -> `.5rem`), which are otherwise written back exactly as authored. Off by default: `getComputedStyle().getPropertyValue()` hands this text back, so a rewritten value is a different CSSOM — the one place a declaration's authored text survives. What it may rewrite is exactly what any other value's tokens may be, a color in a substitution's fallback included — that fallback being the property's value rather than the function's own argument.
 	 * @since 5.110.0
 	 */
 	rewriteCustomProperties?: boolean;
 
+	/**
+	 * Write a `:dir()` the `browserslist` target cannot read as the `[dir]` attribute selector it approximates: `a:dir(rtl)` becomes `a[dir=rtl]`. Off until asked for, because the two are not the same question — `:dir()` reads the directionality an element resolves to, which it may inherit from an ancestor, while `[dir=rtl]` reads the attribute on the element itself, so an element inside a `dir="rtl"` ancestor matches the first and not the second. Only in effect for a `browserslist` target that reads no `:dir()`; any other target names no browsers to answer for.
+	 * @since 5.111.0
+	 */
+	rewriteDirSelector?: boolean;
+
+	/**
+	 * Write an escaped identifier the shortest way that names the same thing, in a value or an id: `grid-area:\66oot` becomes `grid-area:foot` and `#\41 x` becomes `#Ax`. On by default, and exact: the escape and what replaces it are the same identifier. Off leaves every escape as the author wrote it, which is what a consumer comparing the text rather than reading the identifier needs.
+	 * @since 5.111.0
+	 */
+	rewriteEscapes?: boolean;
+
 	/**
 	 * Write each color in the shortest spelling of the same value: `#ffffff` -> `#fff`, `rgb(1 2 3)` -> `#010203`, a named color where the property takes no identifier of the author's own, and every polar and Lab function the target agrees with hex on. On by default.
 	 * @since 5.110.0
@@ -20198,7 +20713,7 @@ declare interface OptimizationMinimizeCss {
 	shortenColors?: boolean;
 
 	/**
-	 * Write a media feature in its range spelling where the target reads one (`(min-width:100px)` -> `(width>=100px)`), and collapse an `and` of two one-sided ranges into the interval it describes. On by default.
+	 * Shorten a rule's condition prelude: a media feature in its range spelling where the target reads one (`(min-width:100px)` -> `(width>=100px)`), an `and` of two one-sided ranges collapsed into the interval it describes, the `all` a query states before an `and` (which matches what the condition alone matches), and an operand a condition already states — in `@supports` and `@container` as well as `@media`. On by default.
 	 * @since 5.110.0
 	 */
 	shortenMediaQueries?: boolean;
@@ -20221,6 +20736,12 @@ declare interface OptimizationMinimizeCss {
 	 */
 	shortenValues?: boolean;
 
+	/**
+	 * Names a whole-project analysis found nothing uses, which the minimizer then takes out: a bare name is matched against every class and id a selector names and against every `@keyframes` name, and a `--`-prefixed one against every custom property a declaration sets. A selector list keeps the selectors that do not name one, and a rule left with none goes; a name inside a functional pseudo (`:not(.gone)`, `:is(.gone, .kept)`) is not one the rule needs, so it is left alone. Nothing is derived here — the list is the caller's, and a name on it that something does use takes working CSS out.
+	 * @since 5.111.0
+	 */
+	unusedSymbols?: string[];
+
 	/**
 	 * Maintain vendor prefixes for the `browserslist` target: add the `-webkit-` / `-moz-` / `-ms-` spelling of a property, at-rule or pseudo-selector that a selected browser still needs, and drop one none of them does. On by default, and only in effect for a `browserslist` target — any other target names no browsers to prefix for. A browserslist name no compat dataset covers (`op_mini`, `and_uc`, `and_qq`, `baidu`, `kaios`, `bb`) is skipped, and a selection of nothing but those prefixes for no one.
 	 * @since 5.110.0
@@ -20234,10 +20755,10 @@ declare interface OptimizationMinimizeCss {
  */
 declare interface OptimizationMinimizeHtml {
 	/**
-	 * Write a boolean attribute spelled with its own name (`disabled="disabled"`) as the bare name the spec canonicalizes it to. On by default.
+	 * Write a boolean attribute as the bare name its presence already means. The DOM reads `checked` from the attribute being there and never from its value, so `checked="checked"` and `checked=""` are the same element — but `getAttribute` hands back what was written. `true`, the default, rewrites only the spelling the spec itself canonicalizes, the attribute's own name; `"all"` rewrites any value, including the `checked="false"` that already means checked.
 	 * @since 5.110.0
 	 */
-	collapseBooleanAttributes?: boolean;
+	collapseBooleanAttributes?: boolean | "all";
 
 	/**
 	 * Collapse each run of whitespace in text to a single space. Left alone inside `pre`, `textarea` and `listing`, where whitespace renders verbatim. `true` (or `"conservative"`) never removes whitespace entirely — dropping it would join two inline elements that render apart. `"smart"` also drops the whitespace that sits against a block element's edge, where no line box reaches it. `"all"` drops the whitespace at every text node's edges, which does change how adjacent inline elements render.
@@ -20251,6 +20772,12 @@ declare interface OptimizationMinimizeHtml {
 	 */
 	comments?: string | boolean | RegExp | ((comment: string) => boolean);
 
+	/**
+	 * Print a run of adjacent `<script>` elements as one, joined by a newline and a `;`. Only bare ones fold — any attribute at all, a `src`, `type`, `nonce`, `async` or `id` among them, says the two are not interchangeable with one — and only where the print writes the bodies itself, so a `<script>` that `output.html.inline` fills in after the print is left alone. A body is left alone too wherever appending it would change what it means: one still inside a string, template or block comment would swallow the next, and a directive prologue, a hashbang or a leading `-->` mean what they do only at a start the appended body no longer has. Off by default: it removes elements, so `document.scripts`, a `script:nth-child()` selector and `querySelectorAll("script").length` all read a different document; a later body's `var` and `function` declarations become visible to the bodies before it; and a body that throws takes the rest of its run with it rather than only itself, while one that does not parse takes the whole run, its own code included.
+	 * @since 5.111.0
+	 */
+	mergeScripts?: boolean;
+
 	/**
 	 * Print a run of adjacent `<style>` elements as one sheet. Off by default: it removes elements, so `document.styleSheets`, a `style:nth-child()` selector and `querySelectorAll("style").length` all read a different document. A sheet the CSS minifier does not accept is never folded — appending to one that may be unterminated would make the next sheet part of its last rule — and neither is one led by `@import` / `@charset` / `@namespace`, which apply only at the top of a sheet.
 	 * @since 5.110.0
@@ -20263,24 +20790,6 @@ declare interface OptimizationMinimizeHtml {
 	 */
 	minifyConditionalComments?: boolean;
 
-	/**
-	 * Strip the whitespace between the tokens of a `<script>` whose type is a JSON MIME type. Every literal is copied byte for byte, so no number is rounded and no escape rewritten. On by default.
-	 * @since 5.110.0
-	 */
-	minifyJson?: boolean;
-
-	/**
-	 * Minify the document held in an `<iframe srcdoc>` attribute. Off by default: the body is a whole document of its own (its base URL is `about:srcdoc`), so minifying it is safe, but the attribute is readable from script and a consumer comparing `iframe.srcdoc` byte for byte would see it change.
-	 * @since 5.110.0
-	 */
-	minifySrcdoc?: boolean;
-
-	/**
-	 * Run the CSS minimizer over an inline `<style>` element and every `style=""` attribute, with the options `optimization.minimize.css` names. On by default.
-	 * @since 5.110.0
-	 */
-	minifyStyles?: boolean;
-
 	/**
 	 * Write an attribute value with whichever delimiters cost least — bare where the grammar allows it, else under the quote that needs fewer character references. On by default: the DOM reads the same value either way.
 	 * @since 5.110.0
@@ -20294,7 +20803,7 @@ declare interface OptimizationMinimizeHtml {
 	normalizeEnumeratedAttributes?: boolean;
 
 	/**
-	 * Normalize a list-shaped attribute value: a space-separated token list (`class`, `rel`, `part`, …), a comma-separated one (`accept`, `sizes`, …), a `srcset` and the viewport `<meta content>`. On by default. Reordering a token list is `sortTokenLists`, which is separate and off by default.
+	 * Normalize a list-shaped attribute value: a space-separated token list (`class`, `rel`, `part`, …), a comma-separated one (`accept`, `sizes`, …), a `srcset` and the viewport `<meta content>`. On by default. A list is read as the set the DOM reflects, so a repeat folds away, only where every token of it is a word: one holding a delimiter another language wrote a statement in is text, and keeps every token it names. Reordering a token list is `sortTokenLists`, which is separate and off by default.
 	 * @since 5.110.0
 	 */
 	normalizeListAttributes?: boolean;
@@ -20305,6 +20814,12 @@ declare interface OptimizationMinimizeHtml {
 	 */
 	normalizeNumericAttributes?: boolean;
 
+	/**
+	 * Drop the ASCII whitespace around a URL value (`href`, `src`, `action`, `poster`, …), which resolving the URL skips over, so the request goes to the same place either way. On by default: `getAttribute` hands back the attribute as written, so a script comparing those bytes is the one this is turned off for.
+	 * @since 5.111.0
+	 */
+	normalizeUrlAttributes?: boolean;
+
 	/**
 	 * Drop an attribute whose empty or all-whitespace value leaves it in the state its absence gives: the globals `class`, `id`, `style`, `dir`, `accesskey`, `itemprop`, `itemref`, `itemtype` and `part`, and every attribute reflecting a token list on the elements the spec defines it for — `rel` on `<a>`, `<area>`, `<form>` and `<link>`, `ping` on `<a>` and `<area>`, `headers` on `<td>` and `<th>`, `blocking` on `<link>`, `<script>` and `<style>`, `sizes` on `<link>`, `for` on `<output>` — where an empty list is no tokens. Anywhere else that spelling is an author attribute whose meaning is a script's, so `<x-foo rel="">` and `<label for="">` keep it. Off by default: an attribute selector matches on presence, so `[class]` stops matching. Never dropped: `title` and `lang`, whose empty value means what absence does not; `sandbox`, whose empty list is the most restrictive state an `<iframe>` has; and an event handler, whose empty body still compiles to a function where absence reads null.
 	 * @since 5.110.0
@@ -20342,7 +20857,7 @@ declare interface OptimizationMinimizeHtml {
 	sortAttributes?: boolean;
 
 	/**
-	 * Print every space-separated token list the DOM reads as a set — `class`, `rel`, `part`, `sandbox`, `blocking`, `itemprop` / `itemref` / `itemtype`, `<output for>` and `<link sizes>` — in token order. Nothing matching those reads order, so this only makes the same markup compress better across pages. Off by default: a script reading `className` or `rel` back sees the new order. The lists the DOM does not read as a set are left alone whatever this says — `ping` is the order its requests go out in and `accesskey` the order its keys are tried.
+	 * Print every space-separated token list the DOM reads as a set — `class`, `rel`, `part`, `sandbox`, `blocking`, `itemprop` / `itemref` / `itemtype`, `<output for>` and `<link sizes>` — in token order. Nothing matching those reads order, so this only makes the same markup compress better across pages. Off by default: a script reading `className` or `rel` back sees the new order. Asked for on its own: a list this reorders is rewritten whether or not `normalizeListAttributes` is on, since another order is another spelling. The lists the DOM does not read as a set are left alone whatever this says — `ping` is the order its requests go out in and `accesskey` the order its keys are tried.
 	 * @since 5.110.0
 	 */
 	sortTokenLists?: boolean;
@@ -20863,7 +21378,17 @@ declare interface OptimizationSplitChunksOptions {
 	 */
 	usedExports?: boolean;
 }
-declare interface Options {
+declare abstract class OptionsApply {
+	/**
+	 * Returns options object.
+	 */
+	process(
+		options: WebpackOptionsNormalizedWithDefaults,
+		compiler: Compiler,
+		interception?: WebpackOptionsInterception
+	): WebpackOptionsNormalizedWithDefaults;
+}
+declare interface OptionsDelegatedModuleFactoryPlugin {
 	/**
 	 * source
 	 */
@@ -20899,15 +21424,126 @@ declare interface Options {
 	 */
 	associatedObjectForCache?: object;
 }
-declare abstract class OptionsApply {
+declare interface OptionsParser {
 	/**
-	 * Returns options object.
+	 * which edition to parse
 	 */
-	process(
-		options: WebpackOptionsNormalizedWithDefaults,
-		compiler: Compiler,
-		interception?: WebpackOptionsInterception
-	): WebpackOptionsNormalizedWithDefaults;
+	ecmaVersion: EcmaVersion;
+
+	/**
+	 * the goal symbol
+	 */
+	sourceType?: "module" | "commonjs" | "script";
+
+	/**
+	 * whether the code is strict whatever it says
+	 */
+	strict?: boolean;
+
+	/**
+	 * called where a semicolon was inserted
+	 */
+	onInsertedSemicolon?: (
+		lastTokEnd: number,
+		lastTokEndLoc?: null | Position
+	) => void;
+
+	/**
+	 * called at a trailing comma
+	 */
+	onTrailingComma?: (
+		lastTokEnd: number,
+		lastTokEndLoc?: null | Position
+	) => void;
+
+	/**
+	 * whether reserved words may name things
+	 */
+	allowReserved?: boolean | "never";
+
+	/**
+	 * whether `return` may sit at the top level
+	 */
+	allowReturnOutsideFunction?: boolean;
+
+	/**
+	 * whether module syntax may sit anywhere
+	 */
+	allowImportExportEverywhere?: boolean;
+
+	/**
+	 * whether `await` may sit outside a function
+	 */
+	allowAwaitOutsideFunction?: boolean;
+
+	/**
+	 * whether `super` may sit outside a method
+	 */
+	allowSuperOutsideMethod?: boolean;
+
+	/**
+	 * whether a leading `#!` line is skipped
+	 */
+	allowHashBang?: boolean;
+
+	/**
+	 * whether private names must be declared
+	 */
+	checkPrivateFields?: boolean;
+
+	/**
+	 * whether nodes carry `loc`
+	 */
+	locations?: boolean;
+
+	/**
+	 * where the first offset falls
+	 */
+	startLocation?: { line: number; column: number };
+
+	/**
+	 * where tokens are reported
+	 */
+	onToken?: any[] | ((token?: any) => void);
+
+	/**
+	 * where comments are reported
+	 */
+	onComment?:
+		| any[]
+		| ((
+				isBlock: boolean,
+				text: string,
+				start: number,
+				end: number,
+				startLoc?: null | Position,
+				endLoc?: null | Position
+		  ) => void);
+
+	/**
+	 * whether nodes carry `range`
+	 */
+	ranges?: boolean;
+
+	/**
+	 * a program node to append to
+	 */
+	program?: NodeLike;
+
+	/**
+	 * the name errors and locations carry
+	 */
+	sourceFile?: string;
+
+	/**
+	 * the name every node carries
+	 */
+	directSourceFile?: string;
+
+	/**
+	 * whether parentheses become nodes
+	 */
+	preserveParens?: boolean;
 }
 declare interface OriginRecord {
 	module: null | Module;
@@ -21001,6 +21637,12 @@ declare interface Output {
 	 */
 	compareBeforeEmit?: boolean;
 
+	/**
+	 * Copy files and directories to the output directory.
+	 * @since 5.111.0
+	 */
+	copy?: string | CopyPattern[];
+
 	/**
 	 * This option enables cross-origin loading of chunks.
 	 */
@@ -21285,6 +21927,24 @@ declare interface OutputFileSystem {
 		pathLike: PathLikeFs,
 		callback: (err: null | NodeJS.ErrnoException) => void
 	) => void;
+	symlink?: (
+		target: PathLikeFs,
+		path: PathLikeFs,
+		type: undefined | null | "file" | "dir" | "junction",
+		callback: (err: null | NodeJS.ErrnoException) => void
+	) => void;
+	readlink?: ReadlinkFs;
+	chmod?: (
+		path: PathLikeFs,
+		mode: string | number,
+		callback: (err: null | NodeJS.ErrnoException) => void
+	) => void;
+	utimes?: (
+		path: PathLikeFs,
+		atime: string | number | Date,
+		mtime: string | number | Date,
+		callback: (err: null | NodeJS.ErrnoException) => void
+	) => void;
 	stat: StatFs;
 	lstat?: LStatFs;
 	readFile: ReadFileFs;
@@ -21526,6 +22186,11 @@ declare interface OutputNormalized {
 	 */
 	compareBeforeEmit?: boolean;
 
+	/**
+	 * Patterns of files which are copied to the output directory, and the options of the copying itself.
+	 */
+	copy?: CopyOptions;
+
 	/**
 	 * This option enables cross-origin loading of chunks.
 	 */
@@ -21823,7 +22488,7 @@ declare interface ParameterizedComparator<TArg extends object, T> {
 type ParseErrorSeverity = "error" | "warning";
 declare interface ParseOptionsJavascriptParser {
 	sourceType: "module" | "script";
-	ecmaVersion: ecmaVersion;
+	ecmaVersion: EcmaVersion;
 	locations?: boolean;
 	comments?: boolean;
 	ranges?: boolean;
@@ -21831,7 +22496,7 @@ declare interface ParseOptionsJavascriptParser {
 	allowReturnOutsideFunction?: boolean;
 
 	/**
-	 * internal: serve `range` lazily and skip acorn's location/range tracking
+	 * internal: serve `range` lazily and skip the parser's location/range tracking
 	 */
 	lazyNodes?: boolean;
 
@@ -21857,7 +22522,7 @@ declare interface ParseOptionsSyntax {
 	comment?: (input: string, start: number, end: number) => number;
 }
 declare interface ParseResult {
-	ast: Program;
+	ast: ProgramImport;
 	comments: CommentJavascriptParser[];
 }
 declare interface ParsedIdentifier {
@@ -21999,6 +22664,111 @@ declare interface ParserOptionsByModuleTypeKnown {
 declare interface ParserOptionsByModuleTypeUnknown {
 	[index: string]: { [index: string]: any };
 }
+
+/**
+ * The ECMAScript parser webpack owns, ported from acorn 8.18.0 so the bundler
+ * ships no parser dependency. `lib/javascript/syntax.js` subclasses it and
+ * overrides the hot paths.
+ * acorn source: https://github.com/acornjs/acorn/blob/8.18.0/acorn/src/state.js
+ */
+declare class ParserParser {
+	constructor(
+		options: undefined | null | Partial<OptionsParser>,
+		input: string,
+		startPos?: number
+	);
+	options: ResolvedOptionsParser;
+	sourceFile: null | string;
+	keywords: RegExp;
+	reservedWords: RegExp;
+	reservedWordsStrict: RegExp;
+	reservedWordsStrictBind: RegExp;
+	input: string;
+	containsEsc: boolean;
+	pos: number;
+	curLine: number;
+	lineStart: number;
+	type: TokenType;
+	value: any;
+	end: number;
+	start: number;
+	endLoc?: Position;
+	startLoc?: Position;
+	lastTokStartLoc?: null | Position;
+	lastTokEndLoc?: null | Position;
+	lastTokEnd: number;
+	lastTokStart: number;
+	context: TokContextLike[];
+	exprAllowed: boolean;
+	inModule: boolean;
+	strict: boolean;
+	potentialArrowAt: number;
+	potentialArrowInForAwait: boolean;
+	awaitIdentPos: number;
+	awaitPos: number;
+	yieldPos: number;
+	labels: LabelLike[];
+	undefinedExports: Record<string, NodeLike>;
+	scopeStack: ScopeParser[];
+	regexpState: null | RegExpValidationState;
+	privateNameStack: any[];
+	get inFunction(): boolean;
+	get inGenerator(): boolean;
+	get inAsync(): boolean;
+	get canAwait(): boolean;
+	get allowReturn(): boolean;
+	get allowSuper(): boolean;
+	get allowDirectSuper(): boolean;
+	get treatFunctionsAsVar(): number | boolean;
+	get allowNewDotTarget(): boolean;
+	get allowUsing(): boolean;
+	get inClassStaticBlock(): boolean;
+
+	/**
+	 * Whether a directive prologue starting at `start` opens with `"use strict"`.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.18.0/acorn/src/parseutil.js
+	 */
+	strictDirective(start: number): boolean;
+	unexpected(pos?: number): never;
+	parse(): any;
+
+	/**
+	 * Read a full expression, including the comma operator.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.18.0/acorn/src/expression.js
+	 */
+	parseExpression(
+		forInit?: string | boolean,
+		refDestructuringErrors?: any
+	): any;
+	getToken(): TokenParser;
+	initialContext(): TokContextLike[];
+	enterScope(flags: number): void;
+	treatFunctionsAsVarInScope(scope: { flags: number }): number | boolean;
+	currentScope(): ScopeParser;
+	currentVarScope(): ScopeParser;
+	currentThisScope(): ScopeParser;
+
+	/**
+	 * Report a parse error, naming where in the source it was found.
+	 * acorn source: https://github.com/acornjs/acorn/blob/8.18.0/acorn/src/location.js
+	 */
+	raise(pos: number, message: string): never;
+	raiseRecoverable(pos: number, message: string): never;
+	curPosition(): undefined | Position;
+	skipLineComment(startSkip: number): void;
+	[Symbol.iterator](): Iterator<TokenParser>;
+	static extend(...plugins: ((parser?: any) => any)[]): any;
+	static parse(input: string, options?: Partial<OptionsParser>): ProgramParser;
+	static parseExpressionAt(
+		input: string,
+		pos: number,
+		options?: Partial<OptionsParser>
+	): ExpressionParser;
+	static tokenizer(
+		input: string,
+		options?: Partial<OptionsParser>
+	): ParserParser;
+}
 type ParserState = ParserStateBase & Record<string, any>;
 declare interface ParserStateBase {
 	source: string | Buffer;
@@ -22104,6 +22874,12 @@ declare interface PerformanceOptions {
 	 */
 	all?: boolean;
 
+	/**
+	 * Report references in ESM output that keep webpack's runtime form, naming what stops each from being written as a literal 'import()' or 'new URL()' another bundler can follow (requires 'hints' to be enabled).
+	 * @since 5.111.0
+	 */
+	analyzableBailouts?: boolean;
+
 	/**
 	 * Filter function to select assets that are checked.
 	 */
@@ -22157,18 +22933,6 @@ declare interface PerformanceOptions {
 	 */
 	dynamicExports?: boolean;
 
-	/**
-	 * Report a production build whose 'devtool' writes the source map into the JavaScript, so everyone loading the page downloads it (requires 'hints' to be enabled).
-	 * @since 5.110.0
-	 */
-	embeddedSourceMaps?: boolean;
-
-	/**
-	 * Report modules shipped by more than one entrypoint, which every page that loads them downloads again (requires 'hints' to be enabled).
-	 * @since 5.110.0
-	 */
-	entrypointOverlap?: boolean;
-
 	/**
 	 * Report modules that call 'eval' directly, which stops minification, scope hoisting and tree shaking (requires 'hints' to be enabled).
 	 * @since 5.110.0
@@ -22250,6 +23014,12 @@ declare interface PerformanceOptions {
 	 */
 	scopeHoistingBailouts?: boolean;
 
+	/**
+	 * Report source maps that cost more than they give: a production 'devtool' that writes the map into the JavaScript, and modules a loader transformed without returning a map, which leaves positions pointing at the loader's output (requires 'hints' to be enabled).
+	 * @since 5.111.0
+	 */
+	sourceMaps?: boolean;
+
 	/**
 	 * Report splits 'optimization.splitChunks' refused because 'maxInitialRequests' or 'maxAsyncRequests' was already reached (requires 'hints' to be enabled).
 	 * @since 5.110.0
@@ -22275,34 +23045,22 @@ declare interface PerformanceOptions {
 	unsplitVendors?: boolean;
 
 	/**
-	 * Report 'resolve.alias' entries that no request matched.
-	 * @since 5.110.0
-	 */
-	unusedAliases?: boolean;
-
-	/**
-	 * Report keys defined by 'DefinePlugin' that no module ever referenced, which cost a parser hook per module and invalidate the build when their value changes.
-	 * @since 5.110.0
-	 */
-	unusedDefines?: boolean;
-
-	/**
-	 * Report requests listed in 'externals' that no module ever imported, which usually means the request is misspelled and the real one got bundled instead.
-	 * @since 5.110.0
+	 * Report asset files emitted for an import whose binding nothing reads, so the bytes ship for nothing (requires 'hints' to be enabled).
+	 * @since 5.111.0
 	 */
-	unusedExternals?: boolean;
+	unusedAssets?: boolean;
 
 	/**
-	 * Report modules bundled although nothing uses what they export, pulled in by a re-export (requires 'hints' to be enabled).
-	 * @since 5.110.0
+	 * Report configuration that no build used: 'resolve.alias' entries nothing matched, 'DefinePlugin' keys nothing referenced, 'externals' nothing imported, 'module.rules' that never matched, and Module Federation 'shared' keys or 'remotes' nothing imported.
+	 * @since 5.111.0
 	 */
-	unusedReexports?: boolean;
+	unusedConfig?: boolean;
 
 	/**
-	 * Report rules in 'module.rules' that never matched a module, which cost condition evaluation on every build. Note that plugins may add rules too, so a reported rule is not necessarily one you wrote.
-	 * @since 5.110.0
+	 * Report modules bundled although nothing uses what they export, naming the re-export or the side-effect statement that kept each one (requires 'hints' to be enabled).
+	 * @since 5.111.0
 	 */
-	unusedRules?: boolean;
+	unusedModules?: boolean;
 }
 declare interface PitchLoaderDefinitionFunction<
 	OptionsType = {},
@@ -22404,6 +23162,19 @@ declare interface PnpApi {
 		options: { considerBuiltins: boolean }
 	) => null | string;
 }
+
+/**
+ * A `{ line, column }` pair, as `options.locations` reports one.
+ */
+declare abstract class Position {
+	line: number;
+	column: number;
+	offset(n: number): Position;
+}
+declare interface PositionLike {
+	line: number;
+	column: number;
+}
 declare class PrefetchPlugin {
 	/**
 	 * Creates an instance of PrefetchPlugin.
@@ -22635,7 +23406,7 @@ declare class PrintContext<TPath, TNode, TPrintOptions = object> {
 	 * them ahead of the next top-level node as well.
 	 */
 	takeInserts(start: number, end: number): string;
-	sourceMap(options: SourceMapOptions): SourceMap;
+	sourceMap(options: SourceMapOptions, code?: string): SourceMap;
 
 	/**
 	 * Stand the text `resolve` gives back in place of every deferred write left
@@ -22727,6 +23498,7 @@ declare interface ProfilingPluginOptions {
 	 */
 	outputPath?: string;
 }
+type ProgramParser = ProgramImport & NodeLike;
 declare class ProgressPlugin {
 	/**
 	 * Creates an instance of ProgressPlugin.
@@ -23202,21 +23974,7 @@ declare interface ReadFileSync {
 	): string;
 	(
 		path: PathOrFileDescriptorFs,
-		options?:
-			| null
-			| "ascii"
-			| "utf8"
-			| "utf-8"
-			| "utf16le"
-			| "utf-16le"
-			| "ucs2"
-			| "ucs-2"
-			| "base64"
-			| "base64url"
-			| "latin1"
-			| "binary"
-			| "hex"
-			| (ObjectEncodingOptionsFs & { flag?: string })
+		options: ObjectEncodingOptionsFs & { flag?: string }
 	): string | Buffer;
 }
 declare interface ReadFileTypes {
@@ -23618,6 +24376,11 @@ declare interface RealContentHashPluginOptions {
 	 * the hash digest to use
 	 */
 	hashDigest: string;
+
+	/**
+	 * run only where analyzable output marked a name for repair
+	 */
+	onDemand?: boolean;
 }
 declare interface RealDependencyLocation {
 	start: SourcePosition;
@@ -23700,7 +24463,7 @@ declare interface RecursiveNonNullable<T> {}
  */
 declare abstract class Reference {
 	identifier: Identifier;
-	from: Scope;
+	from: ScopeScopeAnalyzer;
 	resolved?: Variable;
 }
 type ReferenceableItem = string | object;
@@ -23720,6 +24483,44 @@ declare interface ReferencedExport {
 	 */
 	canInline?: boolean;
 }
+
+/**
+ * The cursor a regexp literal is validated through.
+ */
+declare abstract class RegExpValidationState {
+	parser: ParserParser;
+	validFlags: string;
+	unicodeProperties: any;
+	source: string;
+	flags: string;
+	start: number;
+	switchU: boolean;
+	switchV: boolean;
+	switchN: boolean;
+	pos: number;
+	lastIntValue: number;
+	lastStringValue: string;
+	lastAssertionIsQuantifiable: boolean;
+	numCapturingParens: number;
+	maxBackReference: number;
+	groupNames: any;
+	backReferenceNames: string[];
+	branchID: null | BranchID;
+	reset(start: number, pattern: string, flags: string): void;
+	raise(message: string): void;
+
+	/**
+	 * The code point at an index, joining a surrogate pair where the `u` flag
+	 * asks for code points rather than units.
+	 */
+	at(i: number, forceU?: boolean): number;
+	nextIndex(i: number, forceU?: boolean): number;
+	current(forceU?: boolean): number;
+	lookahead(forceU?: boolean): number;
+	advance(forceU?: boolean): void;
+	eat(ch: number, forceU?: boolean): boolean;
+	eatChars(chs: number[], forceU?: boolean): boolean;
+}
 type Remotes = (string | RemotesObject)[] | RemotesObject;
 
 /**
@@ -24470,7 +25271,7 @@ declare interface ResolveOptionsResolverFactoryObject2 {
 	resolver?: Resolver;
 
 	/**
-	 * A list of directories to resolve modules from, can be absolute path, folder name, or a `file:` `URL` instance
+	 * A list of directories to resolve modules from, can be absolute path, folder name, or a `file:` URL
 	 */
 	modules?: string | URL_url | (string | URL_url)[];
 
@@ -24497,7 +25298,7 @@ declare interface ResolveOptionsResolverFactoryObject2 {
 	pnpApi?: null | PnpApi;
 
 	/**
-	 * A list of root paths, each an absolute path or a `file:` `URL` instance
+	 * A list of root paths, each an absolute path or a `file:` URL
 	 */
 	roots?: (string | URL_url)[];
 
@@ -24512,7 +25313,7 @@ declare interface ResolveOptionsResolverFactoryObject2 {
 	resolveToContext?: boolean;
 
 	/**
-	 * A list of resolve restrictions, each an absolute path, a `file:` `URL` instance, or a RegExp
+	 * A list of resolve restrictions, each an absolute path, a `file:` URL, or a RegExp
 	 */
 	restrictions?: (string | RegExp | URL_url)[];
 
@@ -24532,7 +25333,7 @@ declare interface ResolveOptionsResolverFactoryObject2 {
 	preferAbsolute?: boolean;
 
 	/**
-	 * TypeScript config file path (or `file:` `URL` instance) or config object with configFile and references
+	 * TypeScript config file path (or `file:` URL) or config object with configFile and references
 	 */
 	tsconfig?: string | boolean | URL_url | UserTsconfigOptions;
 }
@@ -24559,12 +25360,129 @@ declare interface ResolvedContextTimestampAndHash {
 	timestampHash?: string;
 	hash: string;
 }
-declare interface ResolvedOptions {
+declare interface ResolvedOptionsDefaults {
 	/**
 	 * - platform target properties
 	 */
 	platform: false | PlatformTargetProperties;
 }
+declare interface ResolvedOptionsParser {
+	/**
+	 * the edition, as the number the parser compares against
+	 */
+	ecmaVersion: number;
+
+	/**
+	 * the goal symbol
+	 */
+	sourceType: "module" | "commonjs" | "script";
+
+	/**
+	 * whether the code is strict whatever it says
+	 */
+	strict: boolean;
+
+	/**
+	 * called where a semicolon was inserted
+	 */
+	onInsertedSemicolon:
+		null | ((lastTokEnd: number, lastTokEndLoc?: null | Position) => void);
+
+	/**
+	 * called at a trailing comma
+	 */
+	onTrailingComma:
+		null | ((lastTokEnd: number, lastTokEndLoc?: null | Position) => void);
+
+	/**
+	 * whether reserved words may name things
+	 */
+	allowReserved: boolean | "never";
+
+	/**
+	 * whether `return` may sit at the top level
+	 */
+	allowReturnOutsideFunction: boolean;
+
+	/**
+	 * whether module syntax may sit anywhere
+	 */
+	allowImportExportEverywhere: boolean;
+
+	/**
+	 * whether `await` may sit outside a function
+	 */
+	allowAwaitOutsideFunction: boolean;
+
+	/**
+	 * whether `super` may sit outside a method
+	 */
+	allowSuperOutsideMethod: boolean;
+
+	/**
+	 * whether a leading `#!` line is skipped
+	 */
+	allowHashBang: boolean;
+
+	/**
+	 * whether private names must be declared
+	 */
+	checkPrivateFields: boolean;
+
+	/**
+	 * whether nodes carry `loc`
+	 */
+	locations: boolean;
+
+	/**
+	 * where the first offset falls
+	 */
+	startLocation: null | { line: number; column: number };
+
+	/**
+	 * where tokens are reported
+	 */
+	onToken: null | ((token?: any) => void);
+
+	/**
+	 * where comments are reported
+	 */
+	onComment:
+		| null
+		| ((
+				isBlock: boolean,
+				text: string,
+				start: number,
+				end: number,
+				startLoc?: null | Position,
+				endLoc?: null | Position
+		  ) => void);
+
+	/**
+	 * whether nodes carry `range`
+	 */
+	ranges: boolean;
+
+	/**
+	 * a program node to append to
+	 */
+	program: null | NodeLike;
+
+	/**
+	 * the name errors and locations carry
+	 */
+	sourceFile: null | string;
+
+	/**
+	 * the name every node carries
+	 */
+	directSourceFile: null | string;
+
+	/**
+	 * whether parentheses become nodes
+	 */
+	preserveParens: boolean;
+}
 declare abstract class Resolver {
 	fileSystem: FileSystem;
 	options: ResolveOptionsResolverFactoryObject1;
@@ -25339,6 +26257,12 @@ declare class RuntimeModule extends Module {
 	 */
 	attach(compilation: Compilation, chunk: Chunk, chunkGraph?: ChunkGraph): void;
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 */
+	getInstalledChunkHandlers(): null | [string, string][];
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 */
@@ -25356,6 +26280,11 @@ declare class RuntimeModule extends Module {
 	 */
 	shouldIsolate(): boolean;
 
+	/**
+	 * The answer a runtime module gives when it installs no chunk handler at all
+	 */
+	static NO_CHUNK_HANDLERS: [string, string][];
+
 	/**
 	 * Runtime modules without any dependencies to other runtime modules
 	 */
@@ -25506,6 +26435,7 @@ declare abstract class RuntimeTemplate {
 	supportsArrowFunction(): boolean;
 	supportsAsyncFunction(): boolean;
 	supportsGenerator(): boolean;
+	supportsTopLevelAwait(): boolean;
 	supportsOptionalChaining(): boolean;
 	supportsSpread(): boolean;
 	supportsObjectHasOwn(): boolean;
@@ -25519,6 +26449,19 @@ declare abstract class RuntimeTemplate {
 	supportsSourceImport(): boolean;
 	supportsModulePreload(): boolean;
 
+	/**
+	 * Whether the deferred fill rewrote a chunk whose hashed name would otherwise go
+	 * stale, which `RealContentHashPlugin` reads to run — and to repair `[chunkhash]`
+	 * names — where `optimization.realContentHash` did not ask for it.
+	 */
+	needsAnalyzableRepair(): boolean;
+
+	/**
+	 * The assets the deferred fill rewrote under a name that has to be repaired: an
+	 * on-demand repair renames only these and whatever names them.
+	 */
+	analyzableRepairedAssets(): ReadonlySet<string>;
+
 	/**
 	 * Whether a reference a foreign bundler can follow without running webpack's runtime
 	 * may be emitted — the one question every caller asks, in the form it is asking for:
@@ -25542,6 +26485,30 @@ declare abstract class RuntimeTemplate {
 		runtime?: RuntimeSpec
 	): boolean;
 
+	/**
+	 * Names the module whose code generation starts, so the reasons its references
+	 * record are handed back by `finishAnalyzableBailouts` and attributed to it.
+	 */
+	beginAnalyzableBailouts(module: Module): void;
+
+	/**
+	 * Ends the collection `beginAnalyzableBailouts` started, so the reasons can be
+	 * stored beside the result and reapplied when the cache restores it.
+	 */
+	finishAnalyzableBailouts(): undefined | string[];
+
+	/**
+	 * Reapplies the bailouts a cached code generation result was stored with, so a
+	 * restored module reports the same reasons a generated one does.
+	 */
+	restoreAnalyzableBailouts(module: Module, reasons: string[]): void;
+
+	/**
+	 * The reasons a module's references keep the runtime form, as recorded while its
+	 * code was generated.
+	 */
+	analyzableBailoutsOf(module: Module): string[];
+
 	/**
 	 * Builds the analyzable `new URL(specifier, import.meta.url)` expression the ESM
 	 * wasm/asset loader backends use to reference an emitted binary relative to the
@@ -26104,30 +27071,16 @@ declare abstract class RuntimeTemplate {
 		 */
 		runtimeRequirements: Set<string>;
 		/**
-		 * the module the `import()` is emitted into
+		 * the module the `import()` is emitted into, to report against
 		 */
 		originModule?: Module;
 	}): string;
 
-	/**
-	 * For ESM module output, load a single statically-named chunk through the
-	 * `analyzableChunkImport` helper — a literal `import("./chunk.js")` other bundlers
-	 * and webpack itself can follow, wrapped to keep `ensureChunk` timing and deduplication.
-	 * Returns `null` to fall back to the runtime `ensureChunk` form.
-	 */
-	analyzableChunkImport(
-		chunk: Chunk,
-		comment: string,
-		runtimeRequirements: Set<string>,
-		originModule: undefined | Module,
-		chunkGraph: ChunkGraph
-	): null | string;
-
 	/**
 	 * The `../` path from a chunk's own asset back to the output root. Hashes are
 	 * neutralized first: a runtime module is generated once to be hashed, before any
 	 * hash exists, so resolving one there throws — and `RuntimeModule.updateHash`
-	 * swallows that, pinning the module's hash to the message.
+	 * lets that throw fail the build rather than hashing it.
 	 */
 	chunkRootOutputDir(chunk: Chunk, enforceRelative: boolean): string;
 
@@ -26141,32 +27094,30 @@ declare abstract class RuntimeTemplate {
 		overridePublicPath: undefined | string,
 		chunk: Chunk,
 		module: Module,
-		chunkGraph: ChunkGraph,
-		runtimeRequirements: Set<string>
+		chunkGraph: ChunkGraph
 	): null | string;
 
 	/**
 	 * Static `new URL(<file>, import.meta.url)` for every stylesheet a runtime can load,
-	 * keyed by chunk id — one that cannot be named leaves the map incomplete, and its
-	 * id keeps the runtime `publicPath + getChunkCssFilename(id)` form. Both the runtime module reading them
+	 * keyed by chunk id, or `null` when they have to keep the runtime
+	 * `publicPath + getChunkCssFilename(id)` form. Both the runtime module reading them
 	 * and the plugin declaring what it needs ask this, so the two always agree. The
 	 * runtime hands an absolute url string to `link.href`, and so does this — the browser
 	 * resolves the element against the document, which is not where the chunk sits, and
-	 * the loader reads the url as text either way. Nothing is written out for a runtime
-	 * that also carries the hot handler; see below.
+	 * the loader reads the url as text either way.
 	 */
 	analyzableCssChunkUrls(
 		runtimeChunk: Chunk,
 		chunkGraph: ChunkGraph,
 		runtimeRequirements: ReadonlySet<string>,
 		consumingModule?: Module
-	): null | AnalyzableChunkUrls;
+	): null | Map<ChunkId, string>;
 
 	/**
 	 * Static `new URL(<file>, import.meta.url).href` for every javascript chunk a
 	 * runtime can hint at with `<link rel="prefetch"/"modulepreload">`, keyed by chunk
-	 * id — one that cannot be named leaves the map incomplete, and its id keeps the
-	 * runtime `publicPath + getChunkScriptFilename(id)` form. Both the runtime module reading
+	 * id, or `null` when they have to keep the runtime
+	 * `publicPath + getChunkScriptFilename(id)` form. Both the runtime module reading
 	 * them and the plugin declaring what it needs ask this, so the two always agree.
 	 */
 	analyzableChunkScriptUrls(
@@ -26174,7 +27125,37 @@ declare abstract class RuntimeTemplate {
 		chunkGraph: ChunkGraph,
 		runtimeRequirements: ReadonlySet<string>,
 		consumingModule?: Module
-	): null | AnalyzableChunkUrls;
+	): null | Map<ChunkId, string>;
+
+	/**
+	 * Records that this runtime reads its chunks some way other than a native
+	 * `import()`, so no literal can name what it loads. Recorded on the entries that
+	 * chose it, which is where the setting behind it lives.
+	 */
+	reportChunkImportBailout(chunk: Chunk, chunkGraph: ChunkGraph): void;
+
+	/**
+	 * Whether the loader still needs to build a url from a chunk id, which is the case
+	 * for a chunk it can be asked for that `analyzableChunkImports` leaves unnamed: one
+	 * carrying a runtime of its own, or one a second entrypoint has at startup.
+	 */
+	chunkImportsNeedRuntimeUrl(
+		runtimeChunk: Chunk,
+		chunkGraph: ChunkGraph
+	): boolean;
+
+	/**
+	 * A literal `import()` specifier for every javascript chunk a runtime loads on
+	 * demand, keyed by chunk id, or `null` when one of them cannot be named here. The
+	 * map is written into the runtime chunk rather than at each import site, so a
+	 * hashed chunk name reaches no module that imports it.
+	 */
+	analyzableChunkImports(
+		runtimeChunk: Chunk,
+		chunkGraph: ChunkGraph,
+		runtimeRequirements: ReadonlySet<string>,
+		consumingModule?: Module
+	): null | Map<ChunkId, string>;
 
 	/**
 	 * Static `new URL(<file>, import.meta.url)` for the binary emitted for an async wasm
@@ -26276,17 +27257,45 @@ declare interface RuntimeValueOptions {
 	version?: string | (() => string);
 }
 
+/**
+ * Helper function for joining two ranges into a single range. This is useful
+ * when working with AST nodes, as it allows you to combine the ranges of child nodes
+ * to create the range of the _parent node_.
+ */
+declare interface ScopeInfo {
+	definitions: StackedMap<string, VariableInfo | ScopeInfo>;
+	topLevelScope: boolean | "arrow";
+	inShorthand: string | boolean;
+	inTaggedTemplateTag: boolean;
+	inTry: boolean;
+	isStrict: boolean;
+	isAsmJs: boolean;
+	terminated?: 1 | 2;
+}
+
+/**
+ * One lexical scope, holding the names declared directly in it. Each set is
+ * built only once a name goes into it, which most scopes never do.
+ */
+declare abstract class ScopeParser {
+	flags: number;
+	var?: Set<string>;
+	lexical?: Set<string>;
+	functions?: Set<string>;
+	firstLexical?: string;
+}
+
 /**
  * A lexical scope. One shape for every kind, so the property loads in the
  * resolution loop stay monomorphic.
  */
-declare abstract class Scope {
+declare abstract class ScopeScopeAnalyzer {
 	type: ScopeType;
 	block: NodeEstreeIndex;
-	upper: null | Scope;
-	childScopes: Scope[];
+	upper: null | ScopeScopeAnalyzer;
+	childScopes: ScopeScopeAnalyzer[];
 	variables: Variable[];
-	variableScope: Scope;
+	variableScope: ScopeScopeAnalyzer;
 
 	/**
 	 * For a function scope with parameters, the offset where its body
@@ -26298,22 +27307,6 @@ declare abstract class Scope {
 	paramBoundary: number;
 	getBinding(name: string): undefined | Variable;
 }
-
-/**
- * Helper function for joining two ranges into a single range. This is useful
- * when working with AST nodes, as it allows you to combine the ranges of child nodes
- * to create the range of the _parent node_.
- */
-declare interface ScopeInfo {
-	definitions: StackedMap<string, VariableInfo | ScopeInfo>;
-	topLevelScope: boolean | "arrow";
-	inShorthand: string | boolean;
-	inTaggedTemplateTag: boolean;
-	inTry: boolean;
-	isStrict: boolean;
-	isAsmJs: boolean;
-	terminated?: 1 | 2;
-}
 type ScopeType =
 	| "function"
 	| "module"
@@ -26905,6 +27898,15 @@ declare interface SourceLike {
 	 */
 	clearCache?: (options?: ClearCacheOptions, visited?: WeakSet<Source>) => void;
 }
+
+/**
+ * The `loc` a node carries when `options.locations` is on.
+ */
+declare abstract class SourceLocationParser {
+	start?: null | PositionLike;
+	end?: null | PositionLike;
+	source: any;
+}
 declare interface SourceMap {
 	version: 3;
 	file: string;
@@ -27515,7 +28517,7 @@ declare abstract class StackedMap<K, V> {
 }
 
 /**
- * Updates set size using the provided set.
+ * Updates map size using the provided map.
  */
 declare interface StarListDeserializerContext {
 	read: () => HarmonyExportImportedSpecifierDependency[];
@@ -27524,7 +28526,7 @@ declare interface StarListDeserializerContext {
 }
 
 /**
- * Updates set size using the provided set.
+ * Updates map size using the provided map.
  */
 declare interface StarListSerializerContext {
 	write: (
@@ -28644,16 +29646,25 @@ declare interface TimestampAndHash {
 	timestamp?: number;
 	hash: string;
 }
-type Token = NodeSyntax & {
-	value: string;
-	unescaped: string;
-	numericValue: number;
-	typeFlag: "number" | "id" | "integer" | "unrestricted";
-	sign: "" | "+" | "-";
-	unit: string;
-	contentStart: number;
-	contentEnd: number;
-};
+declare interface TokContextLike {
+	token: string;
+	isExpr: boolean;
+	preserveSpace?: boolean;
+	override?: any;
+	generator?: boolean;
+}
+
+/**
+ * A token as `options.onToken` receives one.
+ */
+declare abstract class TokenParser {
+	type: any;
+	value: any;
+	start: any;
+	end: any;
+	loc?: SourceLocationParser;
+	range?: any[];
+}
 
 /**
  * Position-based view over the lexer — webpack's stand-in for the spec's
@@ -28716,6 +29727,12 @@ declare class TokenStream {
 	 */
 	advance(): void;
 
+	/**
+	 * Step over the whitespace the next token would be, without tokenizing it —
+	 * for the sites that discard whitespace tokens. No-op while a token is cached.
+	 */
+	skipWhitespace(): void;
+
 	/**
 	 * Mark (CSS Syntax §3 "mark") — push the current cursor position.
 	 */
@@ -28733,6 +29750,34 @@ declare class TokenStream {
 	 */
 	discardMark(): void;
 }
+type TokenSyntax = NodeSyntax & {
+	value: string;
+	unescaped: string;
+	numericValue: number;
+	typeFlag: "number" | "id" | "integer" | "unrestricted";
+	sign: "" | "+" | "-";
+	unit: string;
+	contentStart: number;
+	contentEnd: number;
+};
+
+/**
+ * A token's kind, carrying what the parser needs to know about it without
+ * re-inspecting the source: whether an expression may follow, its binary
+ * precedence, and how it updates the tokenizer's context.
+ */
+declare abstract class TokenType {
+	label: string;
+	keyword?: string;
+	beforeExpr: boolean;
+	startsExpr: boolean;
+	isLoop: boolean;
+	isAssign: boolean;
+	prefix: boolean;
+	postfix: boolean;
+	binop: null | number;
+	updateContext: null | ((prevType: TokenType) => void);
+}
 declare class TopLevelSymbol {
 	/**
 	 * Creates an instance of TopLevelSymbol.
@@ -28926,17 +29971,17 @@ declare interface UserAliasOptions {
 }
 declare interface UserTsconfigOptions {
 	/**
-	 * A path, or `file:` `URL` instance, pointing at the tsconfig file
+	 * A path, or `file:` URL, pointing at the tsconfig file
 	 */
 	configFile?: string | URL_url;
 
 	/**
-	 * References to other tsconfig files. 'auto' inherits from TypeScript config, or an array of relative/absolute paths or `file:` `URL` instances
+	 * References to other tsconfig files. 'auto' inherits from TypeScript config, or an array of relative/absolute paths or `file:` URLs
 	 */
 	references?: "auto" | (string | URL_url)[];
 
 	/**
-	 * Override baseUrl from tsconfig.json with a path or `file:` `URL` instance
+	 * Override baseUrl from tsconfig.json with a path or `file:` URL
 	 */
 	baseUrl?: string | URL_url;
 }
@@ -28953,7 +29998,7 @@ declare abstract class Variable {
 	name: string;
 	identifiers: Identifier[];
 	references: Reference[];
-	scope: Scope;
+	scope: ScopeScopeAnalyzer;
 }
 declare class VariableInfo {
 	/**
@@ -29981,34 +31026,6 @@ declare interface chunkModuleHashMap {
 	[index: number]: string;
 	[index: string]: string;
 }
-type ecmaVersion =
-	| 3
-	| 5
-	| 6
-	| 7
-	| 8
-	| 9
-	| 10
-	| 11
-	| 12
-	| 13
-	| 14
-	| 15
-	| 16
-	| 17
-	| 2015
-	| 2016
-	| 2017
-	| 2018
-	| 2019
-	| 2020
-	| 2021
-	| 2022
-	| 2023
-	| 2024
-	| 2025
-	| 2026
-	| "latest";
 declare function exports(
 	options: Configuration,
 	callback: CallbackWebpackFunction_2<Stats, void>
@@ -30134,7 +31151,6 @@ declare namespace exports {
 	export namespace RuntimeGlobals {
 		export let amdDefine: "__webpack_require__.amdD";
 		export let amdOptions: "__webpack_require__.amdO";
-		export let analyzableChunkImport: "__webpack_require__.ei";
 		export let asyncModule: "__webpack_require__.a";
 		export let asyncModuleDoneSymbol: "__webpack_require__.aD";
 		export let asyncModuleExportSymbol: "__webpack_require__.aE";
@@ -30177,7 +31193,10 @@ declare namespace exports {
 		export let harmonyModuleDecorator: "__webpack_require__.hmd";
 		export let hasCssModules: "has css modules";
 		export let hasFetchPriority: "has fetch priority";
+		export let hasChunkPriority: "has chunk priority";
 		export let hasOwnProperty: "__webpack_require__.o";
+		export let hasSealedDeferredNamespace: "has sealed deferred namespace";
+		export let hasSynthesizedDeferredNamespace: "has synthesized deferred namespace";
 		export let hmrDownloadManifest: "__webpack_require__.hmrM";
 		export let hmrDownloadUpdateHandlers: "__webpack_require__.hmrC";
 		export let hmrInvalidateModuleHandlers: "__webpack_require__.hmrI";
@@ -30213,6 +31232,7 @@ declare namespace exports {
 		export let scriptNonce: "__webpack_require__.nc";
 		export let setAnonymousDefaultName: "__webpack_require__.dn";
 		export let shareScopeMap: "__webpack_require__.S";
+		export let specNamespaceObject: "__webpack_require__.ns";
 		export let startup: "__webpack_require__.x";
 		export let startupAssetHints: "__webpack_require__.SAH";
 		export let startupEntrypoint: "__webpack_require__.X";
@@ -30244,7 +31264,7 @@ declare namespace exports {
 		export const applyWebpackOptionsDefaults: (
 			options: WebpackOptionsNormalized,
 			compilerIndex?: number
-		) => ResolvedOptions;
+		) => ResolvedOptionsDefaults;
 	}
 	export namespace dependencies {
 		export {
@@ -30468,6 +31488,38 @@ declare namespace exports {
 					errors?: (string | Error)[];
 				}[]
 			) => { warnings?: (string | Error)[]; errors?: (string | Error)[] };
+			export function cssMinify(
+				input: { [index: string]: string | Buffer },
+				sourceMap?: object,
+				minimizerOptions?: {
+					as?: "stylesheet" | "block-contents";
+					environment?: CssEnvironment;
+					convertLengthUnits?: boolean;
+					mergeDistantRules?: boolean;
+					rewriteCustomProperties?: boolean;
+					unusedSymbols?: string[];
+					pseudoClasses?: { [index: string]: string };
+					renderEmbeddedSource?: (
+						source: string,
+						info: { type: string; hostType: string }
+					) =>
+						| undefined
+						| string
+						| EmbeddedSourceResult
+						| Promise<undefined | string | EmbeddedSourceResult>;
+				} & CssTransformOptions
+			): Promise<{
+				code: string;
+				map?: SourceMap;
+				warnings?: (string | Error)[];
+				errors?: (string | Error)[];
+			}>;
+			export namespace cssMinify {
+				export let supportsWorkerThreads: () => boolean;
+				export let getTypes: () => string[];
+				export let getEmbeddedTypes: () => string[];
+				export let filter: (name: string) => boolean;
+			}
 			export let embeddedText: (
 				answer?: string | { code?: string }
 			) => undefined | string;
@@ -30492,7 +31544,7 @@ declare namespace exports {
 				input: string | TokenStream,
 				pos?: number,
 				options?: ParseOptionsSyntax
-			) => undefined | Token | FunctionNode | SimpleBlock;
+			) => undefined | TokenSyntax | FunctionNode | SimpleBlock;
 			export let parseADeclaration: (
 				input: string | TokenStream,
 				pos?: number,
@@ -30720,7 +31772,12 @@ declare namespace exports {
 				parentOf(n?: number): number;
 				children(n?: number): number[];
 			};
+			export let BLOCK_CONTENTS: "block-contents";
+			export let CLASSIC_SCRIPT: "script";
 			export let EMBEDDED_LANGUAGES: string[];
+			export let EVENT_HANDLER: "event-handler";
+			export let JSON_TYPE: "json";
+			export let MODULE_SCRIPT: "module";
 			export let NS_HTML: 0;
 			export let NS_MATHML: 1;
 			export let NS_SVG: 2;
@@ -30764,6 +31821,12 @@ declare namespace exports {
 					  }
 			) => string;
 			export let buildHeadTags: (opts: OutputHtmlOptions) => string;
+			export let builtinEmbeddedRenderer: (
+				options?: BuiltinEmbeddedRendererOptions
+			) => (
+				source: string,
+				info: { type: string; hostType: string; as?: string }
+			) => undefined | string;
 			export let collectEmbeddedDiagnostics: (
 				reported: {
 					warnings?: (string | Error)[];
@@ -30780,6 +31843,41 @@ declare namespace exports {
 				minimal?: boolean
 			) => string;
 			export let escapeText: (s: string) => string;
+			export function htmlMinify(
+				input: { [index: string]: string | Buffer },
+				sourceMap?: RawSourceMap,
+				minimizerOptions?: Omit<
+					HtmlPrintOptions,
+					"renderEmbeddedSource" | "deferEmbeddedSource"
+				> & {
+					environment?: CssEnvironment;
+					css?: {
+						convertLengthUnits?: boolean;
+						rewriteCustomProperties?: boolean;
+						unusedSymbols?: string[];
+						pseudoClasses?: { [index: string]: string };
+					};
+					minifyConditionalComments?: boolean;
+					renderEmbeddedSource?: (
+						source: string,
+						info: { type: string; hostType: string; as?: string }
+					) =>
+						| undefined
+						| string
+						| EmbeddedSourceResult
+						| Promise<undefined | string | EmbeddedSourceResult>;
+				}
+			): Promise<{
+				code: string;
+				warnings?: (string | Error)[];
+				errors?: (string | Error)[];
+			}>;
+			export namespace htmlMinify {
+				export let supportsWorkerThreads: () => boolean;
+				export let getTypes: () => string[];
+				export let getEmbeddedTypes: () => string[];
+				export let filter: (name: string) => boolean;
+			}
 			export let isAsciiWhitespace: (cc: number) => boolean;
 			export let metaTag: (name: string, content: string) => string;
 			export let parseCssUrls: (input: string) => [string, number, number][];
@@ -30936,6 +32034,7 @@ declare namespace exports {
 					HtmlPrintOptions
 				>
 			) => string;
+			export let stripJsonWhitespace: (json: string) => string;
 			export let tokenize: (
 				input: string,
 				pos?: number,
@@ -31260,6 +32359,7 @@ declare namespace exports {
 		ConcatenationScope,
 		ContextExclusionPlugin,
 		ContextReplacementPlugin,
+		CopyPlugin,
 		DefinePlugin,
 		Dependency,
 		DynamicEntryPlugin,