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

package/types.d.ts

@@ -88,7 +88,6 @@ import {
 	YieldExpression
 } from "estree";
 import {
-	IncomingMessage,
 	Server as ServerImportHttp,
 	ServerOptions as ServerOptionsImportHttp
 } from "http";
@@ -356,6 +355,8 @@ declare interface AllCodeGenerationSchemas {
 	 */
 	"share-init": [{ shareScope: string; initStage: number; init: string }];
 }
+type AnalyzableForm =
+	"import" | "url" | "url-runtime" | "url-inline" | "wasm" | "wasm-relative";
 type AnyLoaderContext = NormalModuleLoaderContext<any> &
 	LoaderRunnerLoaderContext<any> &
 	LoaderPluginLoaderContext &
@@ -445,7 +446,7 @@ declare abstract class AssetGenerator extends Generator {
 	/**
 	 * Generates data uri.
 	 */
-	generateDataUri(module: NormalModule): string;
+	generateDataUri(module: NormalModule, renderedSource?: Source): string;
 
 	/**
 	 * Generates fallback output for the provided error condition.
@@ -685,7 +686,16 @@ declare interface AsyncWebAssemblyModulesPluginOptions {
 	 */
 	mangleImports?: boolean;
 }
-declare abstract class AsyncWebAssemblyParser extends ParserClass {}
+type AtRule = NodeSyntax & {
+	name: string;
+	nameStart: number;
+	nameEnd: number;
+	prelude: ComponentValue[];
+	declarations: null | DeclarationSyntax[];
+	childRules: null | RuleSyntax[];
+	blockStart: number;
+	blockEnd: number;
+};
 
 /**
  * Records modules from one compilation and adds them back as prefetch
@@ -745,7 +755,7 @@ declare interface BannerPluginOptions {
 	/**
 	 * Exclude all modules matching any of these conditions.
 	 */
-	exclude?: string | RegExp | ((str: string) => boolean) | Rule[];
+	exclude?: string | RegExp | ((str: string) => boolean) | RuleAlias[];
 
 	/**
 	 * If true, banner will be placed at the end of the output.
@@ -755,7 +765,7 @@ declare interface BannerPluginOptions {
 	/**
 	 * Include all modules matching any of these conditions.
 	 */
-	include?: string | RegExp | ((str: string) => boolean) | Rule[];
+	include?: string | RegExp | ((str: string) => boolean) | RuleAlias[];
 
 	/**
 	 * If true, banner will not be wrapped in a comment.
@@ -770,7 +780,7 @@ declare interface BannerPluginOptions {
 	/**
 	 * Include all modules that pass test assertion.
 	 */
-	test?: string | RegExp | ((str: string) => boolean) | Rule[];
+	test?: string | RegExp | ((str: string) => boolean) | RuleAlias[];
 }
 declare interface BaseResolveRequest {
 	/**
@@ -1194,6 +1204,12 @@ declare abstract class BasicEvaluatedExpression {
 	): BasicEvaluatedExpression;
 }
 type BeforeContextResolveData = ContextResolveData & ContextOptions;
+declare interface BindCache<T> {
+	(cache: object): BindCacheResultFn<T>;
+}
+declare interface BindCacheResultFn<T> {
+	(value: string): T;
+}
 declare interface Bootstrap {
 	header: string[];
 	beforeStartup: string[];
@@ -1557,6 +1573,32 @@ declare interface CallbackWebpackFunction_2<T, R = void> {
 	 */
 	(err: null | Error, result?: T): R;
 }
+declare interface CappedSplit {
+	/**
+	 * the cache group whose split was refused
+	 */
+	cacheGroup: string;
+
+	/**
+	 * the chunk it would have been taken out of
+	 */
+	chunk: Chunk;
+
+	/**
+	 * the option that refused it
+	 */
+	limit: "maxAsyncRequests" | "maxInitialRequests";
+
+	/**
+	 * the value that option had
+	 */
+	maxRequests: number;
+
+	/**
+	 * how many modules the split would have moved
+	 */
+	modules: number;
+}
 type Cell<T> = undefined | T;
 
 /**
@@ -1853,6 +1895,7 @@ declare class ChunkGraph {
 	 */
 	constructor(moduleGraph: ModuleGraph, hashFunction?: HashFunction);
 	moduleGraph: ModuleGraph;
+	buildTimeExecution: boolean;
 
 	/**
 	 * Connects chunk and module.
@@ -3363,6 +3406,27 @@ declare class Compilation {
 			[RenderManifestEntry[], RenderManifestOptions],
 			RenderManifestEntry[]
 		>;
+		/**
+		 * Called with source written in one language that a module emits inside
+		 * another — CSS or HTML reaching the bundle as a JavaScript string
+		 * literal today — before it is embedded; return the (possibly
+		 * transformed) source, e.g. a minified one. `info.type` says which
+		 * language it is, so one tap serves every pair; no asset carries this
+		 * source, so an asset-level minimizer cannot reach it.
+		 * @since 5.110.0
+		 */
+		renderEmbeddedSource: AsyncSeriesWaterfallHook<
+			[Source, EmbeddedSourceInfo],
+			Source
+		>;
+		/**
+		 * Called while hashing a module that embeds such a source. Module hashes
+		 * are taken before code generation, so a `renderEmbeddedSource` tap must
+		 * write whatever it varies on into the hash, or the codegen cache
+		 * replays output from before its options changed.
+		 * @since 5.110.0
+		 */
+		embeddedSourceHash: SyncHook<[Module, Hash]>;
 		fullHash: SyncHook<[Hash]>;
 		chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
 		moduleAsset: SyncHook<[Module, string]>;
@@ -3446,6 +3510,7 @@ declare class Compilation {
 	assetsInfo: Map<string, AssetInfo>;
 	errors: Error[];
 	warnings: Error[];
+	hints: Error[];
 	children: Compilation[];
 	logging: Map<string, LogEntry[]>;
 	dependencyFactories: Map<DependencyConstructor, ModuleFactory>;
@@ -3680,6 +3745,20 @@ declare class Compilation {
 		chunkGraphEntries?: Iterable<Chunk>;
 	}): void;
 
+	/**
+	 * Queues a runtime module whose implementation is loaded on demand, for
+	 * `_attachPendingRuntimeModules` to await and build once the requirement pass
+	 * is over. `runtimeRequirementInTree` is a sync hook, so a tap cannot await
+	 * the load itself; anything the tap reads off the requirement set must be
+	 * captured before queueing, since `create` runs later.
+	 */
+	addLazyRuntimeModule(
+		chunk: Chunk,
+		load: () => Promise<any>,
+		create: (loaded?: any) => RuntimeModule,
+		chunkGraph?: ChunkGraph
+	): void;
+
 	/**
 	 * Adds runtime module.
 	 */
@@ -4033,6 +4112,15 @@ declare interface CompiledAliasOptions {
 	 */
 	useBuckets: boolean;
 }
+declare interface CompiledRule {
+	path: string;
+	raw: RuleSetRule;
+	used: boolean;
+	conditions: RuleCondition[];
+	effects: (EffectUse | EffectBasic | ((effectData: EffectData) => Effect[]))[];
+	rules?: CompiledRule[];
+	oneOf?: CompiledRule[];
+}
 declare class Compiler {
 	/**
 	 * Creates an instance of Compiler.
@@ -4253,6 +4341,7 @@ declare class Compiler {
 		check?: (value: T) => boolean
 	): void;
 }
+type ComponentValue = Token | FunctionNode | SimpleBlock;
 declare class ConcatSource extends Source {
 	constructor(...args: ConcatSourceChild[]);
 	getChildren(): Source[];
@@ -4294,24 +4383,39 @@ type ConcatenatedModuleBuildInfo = KnownBuildInfo &
 	KnownConcatenatedModuleBuildInfo;
 declare interface ConcatenatedModuleInfo {
 	type: "concatenated";
-	module: Module;
-	index: number;
 
 	/**
-	 * a "weird" CommonJS module executed via the CJS wrapper runtime helper with real module/exports objects
+	 * the body renders inside the lazy CJS wrapper with real module/exports instead of being scope-hoisted into the shared scope
+	 */
+	wrapped: boolean;
+
+	/**
+	 * a wrapped body reached by an eager import edge, so its accessor is called at its own slot in evaluation order
 	 */
-	cjsWrapped?: boolean;
+	eager: boolean;
+	module: Module;
+	index: number;
 	ast?: Program;
 	internalSource?: Source;
 	source?: ReplaceSource;
 	chunkInitFragments?: InitFragment<ChunkRenderContextJavascriptModulesPlugin>[];
 	runtimeRequirements?: ReadonlySet<string>;
 	globalScope?: Scope;
+
+	/**
+	 * the module's free references
+	 */
+	unresolvedReferences?: Reference[];
 	moduleScope?: Scope;
 	internalNames: Map<string, string>;
 	exportMap?: Map<string, string>;
 	rawExportMap?: Map<string, string>;
 	namespaceExportSymbol?: string;
+
+	/**
+	 * name of the lazy wrapper accessor function (calling it evaluates the module and returns its exports)
+	 */
+	namespaceFnName?: string;
 	namespaceObjectName?: string;
 
 	/**
@@ -4400,6 +4504,36 @@ declare class ConcatenationScope {
 	 */
 	isModuleInScope(module: Module): boolean;
 
+	/**
+	 * Whether an in-scope module's body renders inside the lazy wrapper.
+	 */
+	isModuleWrapped(module: Module): boolean;
+
+	/**
+	 * Marks a wrapped module as eagerly imported, so its accessor is called at its
+	 * own slot in evaluation order instead of from inside the importing body.
+	 */
+	registerEagerModule(module: Module): void;
+
+	/**
+	 * Whether the current module runs inside the lazy wrapper. Exports then live
+	 * on a real exports object, not hoisted bindings, so templates emit runtime
+	 * code.
+	 */
+	isWrapped(): boolean;
+
+	/**
+	 * Records a `require(...)` call that was replaced as a whole by a
+	 * concatenation reference, so nothing else rewrites a range inside it.
+	 */
+	registerReplacedRequire(range: [number, number]): void;
+
+	/**
+	 * Checks whether an offset sits inside an already-replaced `require(...)` call.
+	 * Containment, not exact match: `new require(...)` is replaced from `new`.
+	 */
+	isInsideReplacedRequire(start: number): boolean;
+
 	/**
 	 * Records the symbol that should be used when the current module exports a
 	 * named binding.
@@ -4443,6 +4577,11 @@ declare class ConcatenationScope {
 	 */
 	static isModuleReference(name: string): boolean;
 
+	/**
+	 * Finds all encoded module references in a generated source.
+	 */
+	static findModuleReferences(source: Source): ModuleReferenceMatch[];
+
 	/**
 	 * Parses an encoded module reference back into its module index and
 	 * reference flags.
@@ -4539,7 +4678,8 @@ declare interface Configuration {
 						| string
 						| boolean
 						| string[]
-						| (ExternalItemValueObjectKnown & ExternalItemValueObjectUnknown)
+						| ExternalItemValueObject
+						| ExternalItemValueWithOptions
 				) => void
 		  ) => void)
 		| ((data: ExternalItemFunctionData) => Promise<ExternalItemValue>)
@@ -4775,7 +4915,10 @@ declare class ConstDependency extends NullDependency {
 	/**
 	 * Returns true if the dependency can be concatenated (scope hoisting).
 	 */
-	static canConcatenate(dependency: Dependency): boolean;
+	static canConcatenate(
+		dependency: Dependency,
+		concatenateCommonJsModules: boolean
+	): boolean;
 	static TRANSITIVE: symbol;
 	static LAZY_UNTIL_LOCAL: "local";
 	static LAZY_UNTIL_ID: "id";
@@ -4959,6 +5102,12 @@ type ContextDependencyOptions = ContextOptions & { request: string };
 declare abstract class ContextElementDependency extends ModuleDependency {
 	referencedExports?: null | string[][];
 	attributes?: ImportAttributes;
+
+	/**
+	 * The request as the user wrote it, e.g. `#configs/file.mjs` where `request`
+	 * is the `./file.mjs` relative to the resolved `#configs` directory.
+	 */
+	get originalRequest(): string;
 }
 declare class ContextExclusionPlugin {
 	/**
@@ -5029,6 +5178,10 @@ declare abstract class ContextModuleFactory extends ModuleFactory {
 }
 type ContextModuleOptions = ContextOptions & ContextModuleOptionsExtras;
 declare interface ContextModuleOptionsExtras {
+	/**
+	 * the request of the context as written by the user, before it was resolved
+	 */
+	request?: string;
 	resource: string | false | string[];
 	resourceQuery?: string;
 	resourceFragment?: string;
@@ -5140,89 +5293,7 @@ declare interface ContextTimestampAndHash {
 	symlinks?: Set<string>;
 }
 type ContextTypes = KnownContext & Record<any, any>;
-
-declare interface CreateData {
-	/**
-	 * an optional layer in which the module is
-	 */
-	layer?: string;
-
-	/**
-	 * module type. When deserializing, this is set to an empty string "".
-	 */
-	type: string;
-
-	/**
-	 * request string
-	 */
-	request: string;
-
-	/**
-	 * request intended by user (without loaders from config)
-	 */
-	userRequest: string;
-
-	/**
-	 * request without resolving
-	 */
-	rawRequest: string;
-
-	/**
-	 * list of loaders
-	 */
-	loaders: LoaderItem[];
-
-	/**
-	 * path + query of the real resource
-	 */
-	resource: string;
-
-	/**
-	 * resource resolve data
-	 */
-	resourceResolveData?: ResourceSchemeData & Partial<ResolveRequest>;
-
-	/**
-	 * context directory for resolving
-	 */
-	context: string;
-
-	/**
-	 * path + query of the matched resource (virtual)
-	 */
-	matchResource?: string;
-
-	/**
-	 * the parser used
-	 */
-	parser: ParserClass;
-
-	/**
-	 * the options of the parser used
-	 */
-	parserOptions?: ParserOptions;
-
-	/**
-	 * the generator used
-	 */
-	generator: Generator;
-
-	/**
-	 * the options of the generator used
-	 */
-	generatorOptions?: GeneratorOptions;
-
-	/**
-	 * options used for resolving requests from this module
-	 */
-	resolveOptions?: ResolveOptions;
-
-	/**
-	 * enable/disable extracting source map
-	 */
-	extractSourceMap: boolean;
-	settings: ModuleSettings;
-}
+type CreateData = NormalModuleCreateData & { settings: ModuleSettings };
 type CreateReadStreamFSImplementation = FSImplementation & {
 	read: (...args: any[]) => any;
 };
@@ -5338,6 +5409,17 @@ declare interface CssData {
 	 */
 	exportLocs?: Map<string, { line: number; column: number }>;
 }
+declare interface CssEnvironment {
+	/**
+	 * the browserslist selection (`["chrome 100", "safari 15"]`), so vendor prefixes and every spelling a target has to be able to read are decided for exactly these browsers; absent leaves prefixes untouched and assumes every ability
+	 */
+	browsers?: string[];
+
+	/**
+	 * whether prefixes are written at all; false leaves them alone while the selection still decides which spellings a target reads
+	 */
+	vendorPrefixes?: boolean;
+}
 declare abstract class CssGenerator extends Generator {
 	options: CssModuleGeneratorOptions;
 
@@ -5834,117 +5916,298 @@ declare interface CssParserOptions {
 	 */
 	urlHints?: UrlHintRule[];
 }
-type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
-declare interface DefaultHandlerOptions {
-	progressBar?:
-		| false
-		| Required<{
-				/**
-				 * Color used for the filled portion of the bar.
-				 */
-				color?: string;
-				/**
-				 * Name shown before the progress bar.
-				 */
-				name?: string;
-				/**
-				 * Width of the progress bar in characters. Default: 25.
-				 */
-				width?: number;
-		  }>;
-	estimatedTime?: boolean;
-	phaseTimings?: boolean;
-}
-type DefineConfigInput =
-	| Configuration
-	| MultiConfiguration
-	| ((
-			env: Record<string, any>,
-			argv: Record<string, any>
-	  ) => MaybePromise<Configuration | MultiConfiguration>)
-	| ((
-			env: Record<string, any>,
-			argv: Record<string, any>
-	  ) => MaybePromise<Configuration | MultiConfiguration>)[]
-	| Promise<
-			| Configuration
-			| MultiConfiguration
-			| ((
-					env: Record<string, any>,
-					argv: Record<string, any>
-			  ) => MaybePromise<Configuration | MultiConfiguration>)
-			| ((
-					env: Record<string, any>,
-					argv: Record<string, any>
-			  ) => MaybePromise<Configuration | MultiConfiguration>)[]
-	  >;
-declare class DefinePlugin {
+declare interface CssPrintOptions {
 	/**
-	 * Create a new define plugin
+	 * 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
 	 */
-	constructor(definitions: Definitions);
-	definitions: Definitions;
+	environment?: CssEnvironment;
 
 	/**
-	 * Applies the plugin by registering its hooks on the compiler.
+	 * renders source this stylesheet embeds: the payload of a `url()` `data:` URL whose media type names a language webpack knows (SVG, CSS, HTML, JSON, JavaScript). Absent, a data URL is emitted exactly as written
 	 */
-	apply(compiler: Compiler): void;
+	renderEmbeddedSource?: (
+		source: string,
+		info: { type: string; hostType: string }
+	) => undefined | string;
 
 	/**
-	 * Returns runtime value.
+	 * 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
 	 */
-	static runtimeValue(
-		fn: (value: {
-			module: NormalModule;
-			key: string;
-			readonly version: ValueCacheVersion;
-		}) => CodeValuePrimitive,
-		options?: true | string[] | RuntimeValueOptions
-	): RuntimeValue;
-	static getCompilationHooks: (compilation: Compilation) => {
-		/**
-		 * @since 5.104.0
-		 */
-		definitions: SyncWaterfallHook<
-			[Record<string, CodeValue>],
-			Record<string, CodeValue>
-		>;
-	};
-	static VALUE_DEP_MAIN: "webpack/DefinePlugin_hash";
-	static VALUE_DEP_PREFIX: "webpack/DefinePlugin ";
-	static getMergedDefinitionNode: (
-		compilation: Compilation,
-		key: string
-	) => MergedDefinitionNode;
-	static getRuntimeRequirements: (code: string) => undefined | string[];
-	static stringifyMergedDefinition: (
-		compilation: Compilation,
-		parser: JavascriptParser,
-		node: MergedDefinitionNode,
-		key: string,
-		objKeys?: null | Set<string>
-	) => string;
-	static toPropertyKey: (key: string) => string;
-}
-declare interface Definitions {
-	[index: string]: CodeValue;
-}
-declare class DelegatedPlugin {
+	convertLengthUnits?: boolean;
+
 	/**
-	 * Creates an instance of DelegatedPlugin.
+	 * 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
 	 */
-	constructor(options: Options);
-	options: Options;
+	rewriteCustomProperties?: boolean;
 
 	/**
-	 * Applies the plugin by registering its hooks on the compiler.
+	 * 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`
 	 */
-	apply(compiler: Compiler): void;
-}
+	deferEmbeddedSource?: DeferredEmbeddedSource[];
 
-/**
- * DependenciesBlock is the base class for all Module classes in webpack. It describes a
- * "block" of dependencies which are pointers to other DependenciesBlock instances. For example
+	/**
+	 * which of the meaning-preserving rewrites the minifying print makes; each is on unless it is `false`
+	 */
+	transforms?: CssTransformOptions;
+}
+declare interface CssProcessOptions {
+	/**
+	 * shared loc converter (default a fresh one over the input)
+	 */
+	locConverter?: LocConverter;
+
+	/**
+	 * walk into block bodies' nested rules (default true)
+	 */
+	recurseBlocks?: boolean;
+
+	/**
+	 * which top-level production to consume the source as (see `TOP_LEVEL_CONSUMERS`): `"stylesheet"` (default) or `"block-contents"` (a block's contents, e.g. an HTML `style` attribute)
+	 */
+	as?: "stylesheet" | "block-contents";
+
+	/**
+	 * what the grammar may leave un-materialized to go faster — safe only for parts nothing reads in the active parse; default skip nothing. Ignored while printing (`minimize`), which needs every node
+	 */
+	skip?: SkipOptions;
+
+	/**
+	 * print the safely-minified serialization (collapsed whitespace, dropped redundant separators, the `printer`'s value transforms) as `process` walks and return `{ code, map }` (default false = walk only, return `undefined`)
+	 */
+	minimize?: boolean;
+
+	/**
+	 * name of the input in the emitted source map (`sources[0]` / `file`); only read while printing
+	 */
+	source?: string;
+
+	/**
+	 * the input's contents for the map's `sourcesContent`; only read while printing
+	 */
+	content?: string;
+
+	/**
+	 * 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;
+
+	/**
+	 * renders source this stylesheet embeds: the payload of a `url()` `data:` URL whose media type names a language webpack knows (SVG, CSS, HTML, JSON, JavaScript). Absent, a data URL is emitted exactly as written
+	 */
+	renderEmbeddedSource?: (
+		source: string,
+		info: { type: string; hostType: string }
+	) => undefined | string;
+
+	/**
+	 * which of the meaning-preserving rewrites the minifying print makes; each is on unless it is `false`
+	 */
+	transforms?: CssTransformOptions;
+
+	/**
+	 * 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[];
+}
+declare interface CssTransformOptions {
+	/**
+	 * 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 a family of longhands as the one shorthand that sets them
+	 */
+	mergeLonghands?: boolean;
+
+	/**
+	 * join rules that print the same block, at-rules that share a prelude, and a named `@layer` block a later sibling opens again
+	 */
+	mergeRules?: boolean;
+
+	/**
+	 * normalize a string's, `url()`'s, font family's and attribute value's quoting
+	 */
+	normalizeQuotes?: boolean;
+
+	/**
+	 * compute a call into the shorter call naming the same value (`calc()` and the math functions, transforms, gradients, easing functions, filters)
+	 */
+	reduceFunctions?: boolean;
+
+	/**
+	 * drop a rule or declaration nothing can read: an empty rule, and one an identical later one supersedes
+	 */
+	removeDeadRules?: boolean;
+
+	/**
+	 * write each color in the shortest spelling of the same value
+	 */
+	shortenColors?: boolean;
+
+	/**
+	 * write a media feature in its range spelling and collapse an `and` of two into the interval
+	 */
+	shortenMediaQueries?: boolean;
+
+	/**
+	 * write each number in its shortest equal spelling
+	 */
+	shortenNumbers?: boolean;
+
+	/**
+	 * rewrite a selector into a shorter equal one
+	 */
+	shortenSelectors?: boolean;
+
+	/**
+	 * write a value the shortest way its property's own grammar allows
+	 */
+	shortenValues?: boolean;
+}
+type DeclarationEstreeIndex =
+	FunctionDeclaration | VariableDeclaration | ClassDeclaration;
+type DeclarationSyntax = NodeSyntax & {
+	name: string;
+	nameStart: number;
+	nameEnd: number;
+	value: ComponentValue[];
+	important: boolean;
+};
+declare interface DecodedEntitiesWithMap {
+	text: string;
+	map?: number[];
+}
+declare interface DefaultHandlerOptions {
+	progressBar?:
+		| false
+		| Required<{
+				/**
+				 * Color used for the filled portion of the bar.
+				 */
+				color?: string;
+				/**
+				 * Name shown before the progress bar.
+				 */
+				name?: string;
+				/**
+				 * Width of the progress bar in characters. Default: 25.
+				 */
+				width?: number;
+		  }>;
+	estimatedTime?: boolean;
+	phaseTimings?: boolean;
+}
+
+declare interface DeferredEmbeddedSource {
+	source: string;
+	build: (answer?: string) => string;
+	type: string;
+	hostType: string;
+	as?: string;
+}
+type DefineConfigInput =
+	| Configuration
+	| MultiConfiguration
+	| ((
+			env: Record<string, any>,
+			argv: Record<string, any>
+	  ) => MaybePromise<Configuration | MultiConfiguration>)
+	| ((
+			env: Record<string, any>,
+			argv: Record<string, any>
+	  ) => MaybePromise<Configuration | MultiConfiguration>)[]
+	| Promise<
+			| Configuration
+			| MultiConfiguration
+			| ((
+					env: Record<string, any>,
+					argv: Record<string, any>
+			  ) => MaybePromise<Configuration | MultiConfiguration>)
+			| ((
+					env: Record<string, any>,
+					argv: Record<string, any>
+			  ) => MaybePromise<Configuration | MultiConfiguration>)[]
+	  >;
+declare class DefinePlugin {
+	/**
+	 * Create a new define plugin
+	 */
+	constructor(definitions: Definitions);
+	definitions: Definitions;
+
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 */
+	apply(compiler: Compiler): void;
+
+	/**
+	 * Returns runtime value.
+	 */
+	static runtimeValue(
+		fn: (value: {
+			module: NormalModule;
+			key: string;
+			readonly version: ValueCacheVersion;
+		}) => CodeValuePrimitive,
+		options?: true | string[] | RuntimeValueOptions
+	): RuntimeValue;
+	static getCompilationHooks: (compilation: Compilation) => {
+		/**
+		 * @since 5.104.0
+		 */
+		definitions: SyncWaterfallHook<
+			[Record<string, CodeValue>],
+			Record<string, CodeValue>
+		>;
+	};
+	static VALUE_DEP_MAIN: string;
+	static VALUE_DEP_PREFIX: string;
+	static getDeclaredKeys: (compilation: Compilation) => undefined | Set<string>;
+	static getMergedDefinitionNode: (
+		compilation: Compilation,
+		key: string
+	) => MergedDefinitionNode;
+	static getRuntimeRequirements: (code: string) => undefined | string[];
+	static markInternal: (plugin: DefinePlugin) => DefinePlugin;
+	static stringifyMergedDefinition: (
+		compilation: Compilation,
+		parser: JavascriptParser,
+		node: MergedDefinitionNode,
+		key: string,
+		objKeys?: null | Set<string>
+	) => string;
+	static toPropertyKey: (key: string) => string;
+}
+declare interface Definitions {
+	[index: string]: CodeValue;
+}
+declare class DelegatedPlugin {
+	/**
+	 * Creates an instance of DelegatedPlugin.
+	 */
+	constructor(options: Options);
+	options: Options;
+
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 */
+	apply(compiler: Compiler): void;
+}
+
+/**
+ * DependenciesBlock is the base class for all Module classes in webpack. It describes a
+ * "block" of dependencies which are pointers to other DependenciesBlock instances. For example
  * when a Module has a CommonJs require statement, the DependencyBlock for the CommonJs module
  * would be added as a dependency to the Module. DependenciesBlock is inherited by two types of classes:
  * Module subclasses and AsyncDependenciesBlock subclasses. The only difference between the two is that
@@ -5985,12 +6248,12 @@ declare abstract class DependenciesBlock {
 	/**
 	 * Serializes this instance into the provided serializer context.
 	 */
-	serialize(__0: ObjectSerializerContextObjectMiddlewareObject_5): void;
+	serialize(__0: ObjectSerializerContextObjectMiddlewareObject_3): void;
 
 	/**
 	 * Restores this instance from the provided deserializer context.
 	 */
-	deserialize(__0: ObjectDeserializerContextObjectMiddlewareObject_4): void;
+	deserialize(__0: ObjectDeserializerContextObjectMiddlewareObject_2): void;
 }
 declare interface DependenciesBlockLike {
 	dependencies: Dependency[];
@@ -6010,6 +6273,13 @@ declare class Dependency {
 	 */
 	get category(): string;
 
+	/**
+	 * Returns the source type this dependency reads from the module it references:
+	 * `javascript` for anything going through the module wrapper, `asset-url` for a
+	 * bare url embedded into non-javascript output (css, html, a manifest).
+	 */
+	get referencedSourceType(): string;
+
 	/**
 	 * Returns location.
 	 */
@@ -6140,17 +6410,17 @@ declare class Dependency {
 	/**
 	 * Returns true if this dependency can be concatenated
 	 */
-	canConcatenate(): boolean;
+	canConcatenate(concatenateCommonJsModules: boolean): boolean;
 
 	/**
 	 * Serializes this instance into the provided serializer context.
 	 */
-	serialize(__0: ObjectSerializerContextObjectMiddlewareObject_5): void;
+	serialize(__0: ObjectSerializerContextObjectMiddlewareObject_3): void;
 
 	/**
 	 * Restores this instance from the provided deserializer context.
 	 */
-	deserialize(__0: ObjectDeserializerContextObjectMiddlewareObject_4): void;
+	deserialize(__0: ObjectDeserializerContextObjectMiddlewareObject_2): void;
 	module: any;
 	get disconnect(): any;
 
@@ -6176,7 +6446,10 @@ declare class Dependency {
 	/**
 	 * Returns true if the dependency can be concatenated (scope hoisting).
 	 */
-	static canConcatenate(dependency: Dependency): boolean;
+	static canConcatenate(
+		dependency: Dependency,
+		concatenateCommonJsModules: boolean
+	): boolean;
 	static TRANSITIVE: symbol;
 	static LAZY_UNTIL_LOCAL: "local";
 	static LAZY_UNTIL_ID: "id";
@@ -6751,6 +7024,7 @@ declare interface EffectData {
 	mimetype?: string;
 	dependency: string;
 	descriptionData?: JsonObjectTypes;
+	descriptionRelativePath?: string;
 	compiler?: string;
 	issuer: string;
 	issuerLayer: string;
@@ -6766,9 +7040,6 @@ declare interface EffectUse {
 }
 type EffectUseType = "use" | "use-pre" | "use-post";
 declare class ElectronTargetPlugin {
-	/**
-	 * Creates an instance of ElectronTargetPlugin.
-	 */
 	constructor(
 		context?: "preload" | "main" | "renderer",
 		type?:
@@ -6807,6 +7078,32 @@ declare class ElectronTargetPlugin {
 	 */
 	apply(compiler: Compiler): void;
 }
+declare interface EmbeddedSourceInfo {
+	/**
+	 * the embedded source's type, e.g. `"css"` / `"html"`
+	 */
+	type: string;
+
+	/**
+	 * the type of the source it is embedded in, e.g. `"javascript"`
+	 */
+	hostType: string;
+
+	/**
+	 * the module being generated
+	 */
+	module: Module;
+
+	/**
+	 * which of that language's productions this is, where more than one can be embedded — a `style=""` holds `"block-contents"`, an inline `<style>` a whole `"stylesheet"`. Absent where the language has only one
+	 */
+	as?: string;
+}
+declare interface EmbeddedSourceResult {
+	code?: string;
+	warnings?: (string | Error)[];
+	errors?: (string | Error)[];
+}
 
 /**
  * No generator options are supported for this module type.
@@ -6984,9 +7281,9 @@ declare interface EntryDescription {
 	filename?: string | TemplatePathFn<PathDataChunk>;
 
 	/**
-	 * Generate an HTML file for this entrypoint with its JS and CSS output chunks injected. Overrides `output.html` for this entry.
+	 * Generate an HTML file for this entrypoint with its JS and CSS output chunks injected. An object overrides `output.html` option by option for this entry; `inline` is resolved once per generated page and can only be set on `output.html`.
 	 */
-	html?: boolean;
+	html?: boolean | OutputHtmlOptions;
 
 	/**
 	 * Module(s) that are loaded upon startup.
@@ -7054,9 +7351,9 @@ declare interface EntryDescriptionNormalized {
 	filename?: string | TemplatePathFn<PathDataChunk>;
 
 	/**
-	 * Generate an HTML file for this entrypoint with its JS and CSS output chunks injected. Overrides `output.html` for this entry.
+	 * Generate an HTML file for this entrypoint with its JS and CSS output chunks injected. An object overrides `output.html` option by option for this entry; `inline` is resolved once per generated page and can only be set on `output.html`.
 	 */
-	html?: boolean;
+	html?: boolean | OutputHtmlOptions;
 
 	/**
 	 * Module(s) that are loaded upon startup. The last one is exported.
@@ -7244,6 +7541,13 @@ declare interface Environment {
 	 */
 	const?: boolean;
 
+	/**
+	 * The environment supports deferred module evaluation ('import defer * as ns from "..."', 'import.defer("...")').
+	 * @since 5.110.0
+	 * @experimental
+	 */
+	deferImport?: boolean;
+
 	/**
 	 * The environment supports destructuring ('{ a, b } = obj').
 	 */
@@ -7331,6 +7635,13 @@ declare interface Environment {
 	 */
 	optionalChaining?: boolean;
 
+	/**
+	 * The environment supports source phase imports ('import source m from "..."', 'import.source("...")').
+	 * @since 5.110.0
+	 * @experimental
+	 */
+	sourceImport?: boolean;
+
 	/**
 	 * The environment supports spread and rest in array/object literals and calls ('{ ...obj }', 'fn(...args)').
 	 */
@@ -7978,7 +8289,7 @@ declare abstract class ExportsInfo {
 	/**
 	 * Gets read only export info.
 	 */
-	getReadOnlyExportInfo(name: string): ExportInfo;
+	getReadOnlyExportInfo(name: string): any;
 
 	/**
 	 * Gets read only export info recursive.
@@ -8218,7 +8529,8 @@ type ExternalItem =
 					| string
 					| boolean
 					| string[]
-					| (ExternalItemValueObjectKnown & ExternalItemValueObjectUnknown)
+					| ExternalItemValueObject
+					| ExternalItemValueWithOptions
 			) => void
 	  ) => void)
 	| ((data: ExternalItemFunctionData) => Promise<ExternalItemValue>);
@@ -8231,7 +8543,8 @@ type ExternalItemFunction =
 					| string
 					| boolean
 					| string[]
-					| (ExternalItemValueObjectKnown & ExternalItemValueObjectUnknown)
+					| ExternalItemValueObject
+					| ExternalItemValueWithOptions
 			) => void
 	  ) => void)
 	| ((data: ExternalItemFunctionData) => Promise<ExternalItemValue>);
@@ -8272,6 +8585,11 @@ declare interface ExternalItemFunctionData {
 	 * the request as written by the user in the require/import expression/statement
 	 */
 	request: string;
+
+	/**
+	 * same as `request`, except for an element of a context module (a request containing an expression), where it is the request as written by the user instead of the one relative to the resolved context directory
+	 */
+	originalRequest: string;
 }
 
 /**
@@ -8296,7 +8614,10 @@ type ExternalItemValue =
 	| string
 	| boolean
 	| string[]
-	| (ExternalItemValueObjectKnown & ExternalItemValueObjectUnknown);
+	| ExternalItemValueObject
+	| ExternalItemValueWithOptions;
+type ExternalItemValueObject = ExternalItemValueObjectKnown &
+	ExternalItemValueObjectUnknown;
 
 /**
  * The target of the external with a type, optionally with an 'interop' hint describing how its exports interoperate with ES module imports.
@@ -8315,6 +8636,25 @@ declare interface ExternalItemValueObjectKnown {
 declare interface ExternalItemValueObjectUnknown {
 	[index: string]: string | string[];
 }
+type ExternalItemValueTarget =
+	string | boolean | string[] | ExternalItemValueObject;
+
+/**
+ * The target of the external together with options describing how webpack should treat it.
+ * @since 5.110.0
+ */
+declare interface ExternalItemValueWithOptions {
+	/**
+	 * The target of the external.
+	 */
+	external: ExternalItemValueTarget;
+
+	/**
+	 * Whether importing the external has side effects (like the `sideEffects` flag in a package.json). `false` allows webpack to drop the external when none of its exports are used. Defaults to `true`, as webpack can't analyze an external.
+	 * @since 5.110.0
+	 */
+	sideEffects?: boolean;
+}
 declare class ExternalModule extends Module {
 	/**
 	 * Creates an instance of ExternalModule.
@@ -8325,7 +8665,8 @@ declare class ExternalModule extends Module {
 		userRequest: string,
 		dependencyMeta?:
 			ImportDependencyMeta | CssImportDependencyMeta | AssetDependencyMeta,
-		interop?: "default" | "esModule"
+		interop?: "default" | "esModule",
+		sideEffects?: boolean
 	);
 	request: ExternalModuleRequest;
 	externalType: ExternalsType;
@@ -8333,6 +8674,7 @@ declare class ExternalModule extends Module {
 	dependencyMeta?:
 		ImportDependencyMeta | CssImportDependencyMeta | AssetDependencyMeta;
 	interop?: "default" | "esModule";
+	sideEffects?: boolean;
 
 	/**
 	 * restore unsafe cache data
@@ -8341,6 +8683,7 @@ declare class ExternalModule extends Module {
 		unsafeCacheData: UnsafeCacheData,
 		normalModuleFactory: NormalModuleFactory
 	): void;
+	canBeWrappedInConcatenation(): boolean;
 	static getCompilationHooks: (compilation: Compilation) => {
 		/**
 		 * @since 5.106.0
@@ -8364,6 +8707,16 @@ type ExternalModuleBuildInfo = KnownBuildInfo &
 	KnownExternalModuleBuildInfo;
 declare interface ExternalModuleInfo {
 	type: "external";
+
+	/**
+	 * the module's `require()` call is deferred behind an accessor instead of running at its own slot; unlike a wrapped concatenated member there is no body and no CJS wrapper, so any external may be wrapped
+	 */
+	wrapped: boolean;
+
+	/**
+	 * a wrapped module reached by an eager import edge, so its accessor is called at its own slot in evaluation order
+	 */
+	eager: boolean;
 	module: Module;
 	runtimeCondition?: string | boolean | SortableSet<string>;
 	nonDeferAccess: boolean;
@@ -8374,6 +8727,11 @@ declare interface ExternalModuleInfo {
 	 */
 	name?: string;
 
+	/**
+	 * lazy module accessor
+	 */
+	namespaceFnName?: string;
+
 	/**
 	 * decoupled namespace object that keeps original export names when the exports are mangled
 	 */
@@ -8454,7 +8812,8 @@ type Externals =
 					| string
 					| boolean
 					| string[]
-					| (ExternalItemValueObjectKnown & ExternalItemValueObjectUnknown)
+					| ExternalItemValueObject
+					| ExternalItemValueWithOptions
 			) => void
 	  ) => void)
 	| ((data: ExternalItemFunctionData) => Promise<ExternalItemValue>)
@@ -8572,9 +8931,21 @@ declare interface ExternalsPresets {
 	node?: boolean;
 
 	/**
-	 * Treat NW.js legacy nw.gui module as external and load it via require() when used.
+	 * Treat installed packages (requests resolving into a 'node_modules' directory) as external and load them via require()/import at runtime instead of bundling them (useful for server-side rendering builds).
 	 */
-	nwjs?: boolean;
+	nodeModules?:
+		| boolean
+		| {
+				/**
+				 * Keep these requests bundled instead of externalizing them.
+				 */
+				allowlist?: (string | RegExp | ((request: string) => boolean))[];
+		  };
+
+	/**
+	 * Treat NW.js legacy nw.gui module as external and load it via require() when used.
+	 */
+	nwjs?: boolean;
 
 	/**
 	 * Treat references to 'http(s)://...' and 'std:...' as external and load them via import when used (Note that this changes execution order as externals are executed before any other code in the chunk).
@@ -9000,6 +9371,12 @@ declare interface Flags {
 declare interface FullHashChunkModuleHashes {
 	[index: string]: string;
 }
+type FunctionNode = NodeSyntax & {
+	name: string;
+	nameStart: number;
+	nameEnd: number;
+	value: ComponentValue[];
+};
 declare interface GenerateContext {
 	/**
 	 * mapping from dependencies to templates
@@ -9105,6 +9482,14 @@ declare class Generator {
 	static byType(map: {
 		[index: string]: undefined | Generator;
 	}): ByTypeGenerator;
+
+	/**
+	 * Returns the statement a module that failed to build throws when executed.
+	 */
+	static throwBuildErrorCode(
+		error: Error,
+		parseErrorConstructor?: string
+	): string;
 }
 declare interface GeneratorOptions {
 	[index: string]: any;
@@ -9486,7 +9871,10 @@ declare class HarmonyImportDependency extends ModuleDependency {
 	/**
 	 * Returns true if the dependency can be concatenated (scope hoisting).
 	 */
-	static canConcatenate(dependency: Dependency): boolean;
+	static canConcatenate(
+		dependency: Dependency,
+		concatenateCommonJsModules: boolean
+	): boolean;
 	static TRANSITIVE: symbol;
 	static LAZY_UNTIL_LOCAL: "local";
 	static LAZY_UNTIL_ID: "id";
@@ -9619,7 +10007,7 @@ type Head<T extends ReadonlyArray<any>> = T extends readonly [infer H, ...any[]]
 	? H
 	: T extends readonly []
 		? any
-		: T extends (infer E)[]
+		: T extends readonly (infer E)[]
 			? E
 			: never;
 
@@ -9651,6 +10039,46 @@ declare interface HotModuleReplacementPluginLoaderContext {
 declare class HotUpdateChunk extends Chunk {
 	constructor();
 }
+declare interface HtmlAstSkip {
+	/**
+	 * drop every `Text` node. Raw-text element bodies (`<script>`/`<style>`/…) aren't emitted either — their content span is recorded as the element's `contentEnd` (see `RAW_TEXT_ELEMENTS`) so a consumer can read `[tagEnd, contentEnd]` by offset. For consumers that read text by offset (e.g. `HtmlParser`), never the html5lib serializer.
+	 */
+	text?: boolean;
+
+	/**
+	 * drop comment nodes entirely. Not for consumers that read comments (e.g. webpack magic comments).
+	 */
+	comments?: boolean;
+
+	/**
+	 * drop the doctype node; quirks-mode detection is unaffected.
+	 */
+	doctype?: boolean;
+}
+declare interface HtmlAttribute {
+	/**
+	 * lowercased (and, in foreign content, adjusted) attribute name
+	 */
+	name: string;
+	value: string;
+
+	/**
+	 * name used by the html5lib tree serializer (foreign-namespaced)
+	 */
+	serializedName?: string;
+
+	/**
+	 * source offset, or -1 on adoption-agency clones
+	 */
+	nameStart: number;
+	nameEnd: number;
+
+	/**
+	 * source offset, or -1 when valueless / on clones
+	 */
+	valueStart: number;
+	valueEnd: number;
+}
 declare interface HtmlEmittedContext {
 	outputName: string;
 }
@@ -9836,6 +10264,17 @@ declare interface HtmlMutableTag {
 	 */
 	remove?: boolean;
 }
+declare interface HtmlParseOptions {
+	/**
+	 * context element name for fragment parsing (e.g. `td`, `svg path`); omit for a full document
+	 */
+	fragmentContext?: string;
+
+	/**
+	 * node kinds to omit from the AST (see `HtmlAstSkip`); omit to build the full tree
+	 */
+	skip?: HtmlAstSkip;
+}
 declare abstract class HtmlParser extends ParserClass {
 	magicCommentContext: ContextImport;
 	template?: (source: string, context: HtmlTemplateContext) => string;
@@ -9913,6 +10352,126 @@ declare interface HtmlParserOptions {
 	 */
 	urlHints?: UrlHintRule[];
 }
+type HtmlPrintOptions = Pick<
+	CssProcessOptions,
+	"environment" | "convertLengthUnits" | "rewriteCustomProperties"
+> & {
+	cssTransforms?: CssTransformOptions;
+	transforms?: HtmlTransformOptions;
+	collapseWhitespace?: boolean | "all" | "conservative" | "smart";
+	mergeStyles?: boolean;
+	removeEmptyAttributes?: boolean;
+	removeEmptyElements?: boolean;
+	removeRedundantAttributes?: boolean | "all" | "smart";
+	sortAttributes?: boolean;
+	sortTokenLists?: boolean;
+	removeImpliedTags?: boolean | "all" | "smart";
+	renderEmbeddedSource?: (
+		source: string,
+		info: { type: string; hostType: string; as?: string }
+	) => 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
+	 */
+	fragmentContext?: string;
+
+	/**
+	 * node kinds to omit from the AST for speed/memory (see `HtmlAstSkip`)
+	 */
+	skip?: HtmlAstSkip;
+
+	/**
+	 * print the safely-minified serialization (nodes rebuilt from source, inert comments dropped, opening-tag whitespace collapsed) as `process` walks, and return it (default false = walk only, return `""`)
+	 */
+	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`
+	 */
+	transforms?: HtmlTransformOptions;
+
+	/**
+	 * collapse each run of whitespace in text to a single space, except where an ancestor renders it verbatim; `"smart"` also drops what sits against a block edge and `"all"` drops every edge (default false)
+	 */
+	collapseWhitespace?: boolean | "all" | "conservative" | "smart";
+
+	/**
+	 * drop an attribute whose empty value leaves it in the state its absence gives (default false)
+	 */
+	removeEmptyAttributes?: boolean;
+
+	/**
+	 * drop an element with no children and no attributes, unless its bare form is meaningful (default false)
+	 */
+	removeEmptyElements?: boolean;
+
+	/**
+	 * print a run of adjacent `<style>` elements as one sheet, which removes elements (default false)
+	 */
+	mergeStyles?: boolean;
+
+	/**
+	 * print an element's attributes commonest name first, ties by name, which nothing in HTML reads (default false)
+	 */
+	sortAttributes?: boolean;
+
+	/**
+	 * print every token list the DOM reads as a set (`class`, `rel`, `part`, …) in token order (default false)
+	 */
+	sortTokenLists?: boolean;
+
+	/**
+	 * drop an attribute whose value is the element's own default; `true` is `"smart"`, and `"all"` also drops the spec defaults a selector can match (default false)
+	 */
+	removeRedundantAttributes?: boolean | "all" | "smart";
+
+	/**
+	 * how much of the `<html>` / `<head>` / `<body>` shell §13.1.2.4 lets the parser imply may be left out: `"smart"` leaves out only the `<html>` start tag, `true` (or `"all"`) all six, `false` none (default `"smart"`)
+	 */
+	removeImpliedTags?: boolean | "all" | "smart";
+
+	/**
+	 * whether an `<iframe srcdoc>` is among what `deferEmbeddedSource` collects (default true); false for a caller that minifies them itself, which keeps the attribute on the normal path and its shorter delimiter
+	 */
+	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`
+	 */
+	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
+	 */
+	renderEmbeddedSource?: (
+		source: string,
+		info: { type: string; hostType: string; as?: string }
+	) => undefined | string;
+}
 declare interface HtmlResourceHintHtmlEntryDependency {
 	/**
 	 * hint relationship
@@ -10089,9 +10648,122 @@ declare interface HtmlTemplateContext {
 	 */
 	emitError: (error: string | Error) => void;
 }
+declare interface HtmlTokenCallbacks {
+	openTag?: (
+		input: string,
+		start: number,
+		end: number,
+		nameStart: number,
+		nameEnd: number,
+		selfClosing: boolean
+	) => number;
+	closeTag?: (
+		input: string,
+		start: number,
+		end: number,
+		nameStart: number,
+		nameEnd: number
+	) => number;
+	text?: (input: string, start: number, end: number) => number;
+	attribute?: (
+		input: string,
+		nameStart: number,
+		nameEnd: number,
+		valueStart: number,
+		valueEnd: number,
+		quoteType: number
+	) => number;
+	comment?: (
+		input: string,
+		start: number,
+		end: number,
+		dataStart: number,
+		dataEnd: number
+	) => number;
+	doctype?: (
+		input: string,
+		start: number,
+		end: number,
+		nameStart: number,
+		nameEnd: number,
+		publicStart: number,
+		publicEnd: number,
+		systemStart: number,
+		systemEnd: number,
+		forceQuirks: boolean
+	) => number;
+	parseError?: (
+		input: string,
+		code: string,
+		start: number,
+		end: number,
+		severity: ParseErrorSeverity
+	) => void;
+
+	/**
+	 * returns true when the adjusted current node is in a foreign (SVG/MathML) namespace, which is where a `<![CDATA[` opens a CDATA section
+	 */
+	isForeign?: () => boolean;
+
+	/**
+	 * returns true when the tree builder will not run the algorithm that switches the tokenizer for this start tag, so it stays in the data state
+	 */
+	vetoesContentMode?: (name: string) => boolean;
+
+	/**
+	 * context element tag name for fragment parsing; seeds the initial content mode
+	 */
+	fragmentContext?: string;
+}
 declare interface HtmlTransformHtmlContext {
 	outputName: string;
 }
+declare interface HtmlTransformOptions {
+	/**
+	 * write a boolean attribute spelled with its own name (`disabled="disabled"`) as the bare name
+	 */
+	collapseBooleanAttributes?: 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. 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
+	 */
+	normalizeAttributeQuotes?: boolean;
+
+	/**
+	 * fold an enumerated value to the keyword it names
+	 */
+	normalizeEnumeratedAttributes?: boolean;
+
+	/**
+	 * normalize a space-, comma- or descriptor-separated list value (`class`, `rel`, `srcset`, `sizes`, the viewport `content`)
+	 */
+	normalizeListAttributes?: boolean;
+
+	/**
+	 * write an integer attribute the one way its rules read it
+	 */
+	normalizeNumericAttributes?: boolean;
+
+	/**
+	 * leave out an optional tag other than the `<html>` / `<head>` / `<body>` shell, which is `removeImpliedTags`
+	 */
+	removeOptionalTags?: boolean;
+}
 declare interface HtmlTransformTagsContext {
 	outputName: string;
 	html: string;
@@ -10707,12 +11379,12 @@ declare class InitFragment<GenerateContext> {
 	/**
 	 * Serializes this instance into the provided serializer context.
 	 */
-	serialize(context: ObjectSerializerContextObjectMiddlewareObject_5): void;
+	serialize(context: ObjectSerializerContextObjectMiddlewareObject_3): void;
 
 	/**
 	 * Restores this instance from the provided deserializer context.
 	 */
-	deserialize(context: ObjectDeserializerContextObjectMiddlewareObject_4): void;
+	deserialize(context: ObjectDeserializerContextObjectMiddlewareObject_2): void;
 
 	/**
 	 * Adds the provided source to the init fragment.
@@ -10740,8 +11412,8 @@ declare abstract class InlinedValue {
 	value?: null | string | number | boolean;
 	renderLiteral(): string;
 	render(comment: string): string;
-	serialize(__0: ObjectSerializerContextObjectMiddlewareObject_5): void;
-	deserialize(__0: ObjectDeserializerContextObjectMiddlewareObject_4): void;
+	serialize(__0: ObjectSerializerContextObjectMiddlewareObject_3): void;
+	deserialize(__0: ObjectDeserializerContextObjectMiddlewareObject_2): void;
 }
 type InlinedValueKind = "string" | "number" | "boolean" | "undefined" | "null";
 declare interface InnerGraphUtils {
@@ -11014,6 +11686,15 @@ declare class JavascriptModulesPlugin {
 				[Module, Partial<RenderBootstrapContext>],
 				string | void
 			>;
+			/**
+			 * Offers a module's rendered export-definition call to a consumer that can place
+			 * it better — a library whose entry exports the same bindings natively takes it
+			 * over and emits it only where the module is wrapped. Return true to take it.
+			 */
+			onDemandExportsGeneration: SyncBailHook<
+				[Module, RuntimeSpec, string, boolean],
+				boolean | void
+			>;
 			/**
 			 * @since 5.22.0
 			 */
@@ -11094,6 +11775,15 @@ declare class JavascriptModulesPlugin {
 				[Module, Partial<RenderBootstrapContext>],
 				string | void
 			>;
+			/**
+			 * Offers a module's rendered export-definition call to a consumer that can place
+			 * it better — a library whose entry exports the same bindings natively takes it
+			 * over and emits it only where the module is wrapped. Return true to take it.
+			 */
+			onDemandExportsGeneration: SyncBailHook<
+				[Module, RuntimeSpec, string, boolean],
+				boolean | void
+			>;
 			/**
 			 * @since 5.22.0
 			 */
@@ -11174,6 +11864,15 @@ declare class JavascriptModulesPlugin {
 				[Module, Partial<RenderBootstrapContext>],
 				string | void
 			>;
+			/**
+			 * Offers a module's rendered export-definition call to a consumer that can place
+			 * it better — a library whose entry exports the same bindings natively takes it
+			 * over and emits it only where the module is wrapped. Return true to take it.
+			 */
+			onDemandExportsGeneration: SyncBailHook<
+				[Module, RuntimeSpec, string, boolean],
+				boolean | void
+			>;
 			/**
 			 * @since 5.22.0
 			 */
@@ -11256,6 +11955,15 @@ declare class JavascriptModulesPlugin {
 				[Module, Partial<RenderBootstrapContext>],
 				string | void
 			>;
+			/**
+			 * Offers a module's rendered export-definition call to a consumer that can place
+			 * it better — a library whose entry exports the same bindings natively takes it
+			 * over and emits it only where the module is wrapped. Return true to take it.
+			 */
+			onDemandExportsGeneration: SyncBailHook<
+				[Module, RuntimeSpec, string, boolean],
+				boolean | void
+			>;
 			/**
 			 * @since 5.22.0
 			 */
@@ -11336,6 +12044,15 @@ declare class JavascriptModulesPlugin {
 				[Module, Partial<RenderBootstrapContext>],
 				string | void
 			>;
+			/**
+			 * Offers a module's rendered export-definition call to a consumer that can place
+			 * it better — a library whose entry exports the same bindings natively takes it
+			 * over and emits it only where the module is wrapped. Return true to take it.
+			 */
+			onDemandExportsGeneration: SyncBailHook<
+				[Module, RuntimeSpec, string, boolean],
+				boolean | void
+			>;
 			/**
 			 * @since 5.22.0
 			 */
@@ -11416,6 +12133,15 @@ declare class JavascriptModulesPlugin {
 				[Module, Partial<RenderBootstrapContext>],
 				string | void
 			>;
+			/**
+			 * Offers a module's rendered export-definition call to a consumer that can place
+			 * it better — a library whose entry exports the same bindings natively takes it
+			 * over and emits it only where the module is wrapped. Return true to take it.
+			 */
+			onDemandExportsGeneration: SyncBailHook<
+				[Module, RuntimeSpec, string, boolean],
+				boolean | void
+			>;
 			/**
 			 * @since 5.22.0
 			 */
@@ -11495,6 +12221,15 @@ declare class JavascriptModulesPlugin {
 			[Module, Partial<RenderBootstrapContext>],
 			string | void
 		>;
+		/**
+		 * Offers a module's rendered export-definition call to a consumer that can place
+		 * it better — a library whose entry exports the same bindings natively takes it
+		 * over and emits it only where the module is wrapped. Return true to take it.
+		 */
+		onDemandExportsGeneration: SyncBailHook<
+			[Module, RuntimeSpec, string, boolean],
+			boolean | void
+		>;
 		/**
 		 * @since 5.22.0
 		 */
@@ -11527,7 +12262,10 @@ declare class JavascriptParser extends ParserClass {
 	constructor(
 		sourceType?: "module" | "auto" | "script",
 		options?: {
-			parse?: (code: string, options: ParseOptions) => ParseResult;
+			parse?: (
+				code: string,
+				options: ParseOptionsJavascriptParser
+			) => ParseResult;
 			typescript?: boolean;
 			importPhases?: boolean;
 			strictModeViolations?: false | "error" | "warn";
@@ -11879,7 +12617,7 @@ declare class JavascriptParser extends ParserClass {
 					| ExportAllDeclaration
 					| ExportDefaultDeclaration
 				),
-				Declaration
+				DeclarationEstreeIndex
 			],
 			boolean | void
 		>;
@@ -12007,6 +12745,7 @@ declare class JavascriptParser extends ParserClass {
 				| ThisExpression
 				| UpdateExpression
 				| YieldExpression
+				| VariableDeclaration
 				| ForOfStatement
 			],
 			boolean | void
@@ -12073,7 +12812,10 @@ declare class JavascriptParser extends ParserClass {
 	}>;
 	sourceType: "module" | "auto" | "script";
 	options: {
-		parse?: (code: string, options: ParseOptions) => ParseResult;
+		parse?: (
+			code: string,
+			options: ParseOptionsJavascriptParser
+		) => ParseResult;
 		typescript?: boolean;
 		importPhases?: boolean;
 		strictModeViolations?: false | "error" | "warn";
@@ -12654,7 +13396,7 @@ declare class JavascriptParser extends ParserClass {
 	 * Processes the provided declaration.
 	 */
 	enterDeclaration(
-		declaration: Declaration,
+		declaration: DeclarationEstreeIndex,
 		onIdent: (ident: string, identifier: Identifier) => void
 	): void;
 
@@ -13379,6 +14121,18 @@ declare class JavascriptParser extends ParserClass {
 	 */
 	getComments(range: [number, number]): CommentJavascriptParser[];
 
+	/**
+	 * Reports whether `identifier` may occur as a word in the source text of
+	 * `range`. A conservative pre-filter for expensive AST scans: `false` means
+	 * it certainly does not occur, while a match inside a comment or a string
+	 * yields `true`. Also `true` when no source text is available (preparsed
+	 * AST), so callers must stay correct without the filter.
+	 */
+	sourceMayContainIdentifier(
+		range: [number, number],
+		identifier: string
+	): boolean;
+
 	/**
 	 * Checks whether this javascript parser is asi position.
 	 */
@@ -13671,9 +14425,9 @@ declare class JavascriptParser extends ParserClass {
 	static extend(
 		...plugins: ((BaseParser: typeof ParserImport) => typeof ParserImport)[]
 	): typeof JavascriptParser;
-	static ALLOWED_MEMBER_TYPES_ALL: 3;
-	static ALLOWED_MEMBER_TYPES_CALL_EXPRESSION: 1;
-	static ALLOWED_MEMBER_TYPES_EXPRESSION: 2;
+	static ALLOWED_MEMBER_TYPES_ALL: number;
+	static ALLOWED_MEMBER_TYPES_CALL_EXPRESSION: number;
+	static ALLOWED_MEMBER_TYPES_EXPRESSION: number;
 	static VariableInfo: typeof VariableInfo;
 	static VariableInfoFlags: Readonly<{
 		Evaluated: 0;
@@ -13825,7 +14579,7 @@ declare interface JavascriptParserOptions {
 	/**
 	 * Function to parser source code.
 	 */
-	parse?: (code: string, options: ParseOptions) => ParseResult;
+	parse?: (code: string, options: ParseOptionsJavascriptParser) => ParseResult;
 
 	/**
 	 * Mark the listed top-level function names for pure-function-based tree shaking.
@@ -14201,7 +14955,22 @@ declare interface KnownBuildInfo {
 	isCircular?: boolean;
 
 	/**
-	 * module uses top-level `for await…of`, which can't be lowered to a generator
+	 * true when the module calls `eval` directly
+	 */
+	usesEval?: boolean;
+
+	/**
+	 * 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;
+
+	/**
+	 * module uses top-level `for await…of` or `await using`, which can't be lowered to a generator
 	 */
 	usesTopLevelAwaitForOf?: boolean;
 }
@@ -14220,6 +14989,11 @@ declare interface KnownBuildMeta {
 	 * using in ModuleLibraryPlugin
 	 */
 	exportsSourceByRuntime?: Map<string, string>;
+
+	/**
+	 * export definitions `ModuleLibraryPlugin` took over, re-emitted only where the module is wrapped
+	 */
+	exportsBindingSourceByRuntime?: Map<string, string>;
 }
 declare interface KnownConcatenatedModuleBuildInfo {
 	fileDependencies?: LazySet<string>;
@@ -14320,6 +15094,11 @@ declare interface KnownJavascriptModuleBuildInfo {
 	 */
 	needCreateRequire?: boolean;
 
+	/**
+	 * module reassigns `__webpack_public_path__` at runtime, using in APIPlugin
+	 */
+	usingPublicPathOverride?: boolean;
+
 	/**
 	 * names of locally declared functions known to be free of side effects
 	 */
@@ -14329,6 +15108,11 @@ declare interface KnownJavascriptModuleBuildInfo {
 	 * whether this module was parsed with `optimization.inlineExports` enabled (gates inlining of its exports)
 	 */
 	inlineExports?: boolean;
+
+	/**
+	 * module scope holds a `using`/`await using` declaration, so its resources must be disposed when the module finished evaluating
+	 */
+	usesTopLevelUsingDeclaration?: boolean;
 }
 declare interface KnownJavascriptModuleBuildMeta {
 	strictHarmonyModule?: boolean;
@@ -14525,6 +15309,8 @@ declare interface KnownStatsCompilation {
 	errorsCount?: number;
 	warnings?: StatsError[];
 	warningsCount?: number;
+	hints?: StatsError[];
+	hintsCount?: number;
 	children?: StatsCompilation[];
 	logging?: Record<string, StatsLogging>;
 	filteredWarningDetailsCount?: number;
@@ -14854,8 +15640,8 @@ declare interface LazyCompilationDefaultBackendOptions {
 	 * Specifies how to create the server handling the EventSource requests.
 	 */
 	server?:
-		| ServerOptionsImportHttps<typeof IncomingMessage>
-		| ServerOptionsImportHttp<typeof IncomingMessage>
+		| ServerOptionsImportHttps
+		| ServerOptionsImportHttp
 		| (() => ServerLazyCompilationBackend);
 }
 
@@ -14978,7 +15764,7 @@ declare class LazySet<T> {
 	 * serialization stream.
 	 */
 	serialize(
-		__0: ObjectSerializerContextObjectMiddlewareObject_4<(number | T)[]>
+		__0: ObjectSerializerContextObjectMiddlewareObject_3<(number | T)[]>
 	): void;
 
 	/**
@@ -14990,7 +15776,7 @@ declare class LazySet<T> {
 	 * Restores a `LazySet` from serialized item data.
 	 */
 	static deserialize<T>(
-		__0: ObjectDeserializerContextObjectMiddlewareObject_3<(number | T)[]>
+		__0: ObjectDeserializerContextObjectMiddlewareObject_2<(number | T)[]>
 	): LazySet<T>;
 }
 declare interface LibIdentOptions {
@@ -15129,6 +15915,11 @@ declare interface LibraryOptions {
 	 */
 	type: string;
 
+	/**
+	 * Add a branch to the UMD wrapper for an AMD-style loader exposing `define` on a container object, given as a dot-separated path, after the `define.amd` branch.
+	 */
+	umdAmdContainer?: string;
+
 	/**
 	 * If `output.libraryTarget` is set to umd and `output.library` is set, setting this to true will name the AMD module.
 	 */
@@ -15487,6 +16278,16 @@ declare class LoaderTargetPlugin {
 	 */
 	apply(compiler: Compiler): void;
 }
+declare abstract class LocConverter {
+	line: number;
+	column: number;
+	pos: number;
+
+	/**
+	 * Returns location converter.
+	 */
+	get(pos: number): LocConverter;
+}
 declare abstract class LocalModule {
 	name: string;
 	idx: number;
@@ -15501,12 +16302,12 @@ declare abstract class LocalModule {
 	/**
 	 * Serializes this instance into the provided serializer context.
 	 */
-	serialize(context: ObjectSerializerContextObjectMiddlewareObject_2): void;
+	serialize(context: ObjectSerializerContextObjectMiddlewareObject_1): void;
 
 	/**
 	 * Restores this instance from the provided deserializer context.
 	 */
-	deserialize(context: ObjectDeserializerContextObjectMiddlewareObject_1): void;
+	deserialize(context: ObjectDeserializerContextObjectMiddlewareObject_3): void;
 }
 declare interface LogEntry {
 	type:
@@ -15679,6 +16480,9 @@ declare abstract class MainTemplate {
 	get requireFn(): "__webpack_require__";
 	get outputOptions(): Output;
 }
+declare interface MakeCacheableResult<T> {
+	(value: string, cache?: object): T;
+}
 declare interface MakeDirectoryOptions {
 	recursive?: boolean;
 	mode?: string | number;
@@ -16411,6 +17215,8 @@ declare class ModuleConcatenationPlugin {
 	 * Applies the plugin by registering its hooks on the compiler.
 	 */
 	apply(compiler: Compiler): void;
+	static BAILOUT_PREFIX: string;
+	static REJECTED_PREFIX: string;
 }
 declare class ModuleDependency extends Dependency {
 	/**
@@ -16446,7 +17252,10 @@ declare class ModuleDependency extends Dependency {
 	/**
 	 * Returns true if the dependency can be concatenated (scope hoisting).
 	 */
-	static canConcatenate(dependency: Dependency): boolean;
+	static canConcatenate(
+		dependency: Dependency,
+		concatenateCommonJsModules: boolean
+	): boolean;
 	static TRANSITIVE: symbol;
 	static LAZY_UNTIL_LOCAL: "local";
 	static LAZY_UNTIL_ID: "id";
@@ -17372,6 +18181,11 @@ declare abstract class ModuleProfile {
 	 */
 	mergeInto(realProfile: ModuleProfile): void;
 }
+declare interface ModuleReferenceMatch {
+	start: number;
+	end: number;
+	name: string;
+}
 declare interface ModuleReferenceOptions {
 	/**
 	 * the properties or exports selected from the referenced module
@@ -17398,6 +18212,11 @@ declare interface ModuleReferenceOptions {
 	 */
 	mangleableNamespace: boolean;
 
+	/**
+	 * true, when the reference resolves to the module's own exports value with plain property access, skipping ESM interop (how `require()` and a wrapped module's side-effect init see it)
+	 */
+	moduleExportsAccess: boolean;
+
 	/**
 	 * if the position is ASI safe or unknown
 	 */
@@ -17577,10 +18396,11 @@ declare class MultiCompiler {
 		options: MultiCompilerOptions
 	);
 	hooks: Readonly<{
-		done: SyncHook<[MultiStats]>;
+		done: SyncHook<[MultiStats, Compiler[]]>;
 		invalid: MultiHook<SyncHook<[null | string, number]>>;
 		run: MultiHook<AsyncSeriesHook<[Compiler]>>;
 		watchClose: SyncHook<[]>;
+		shutdown: MultiHook<AsyncSeriesHook<[]>>;
 		watchRun: MultiHook<AsyncSeriesHook<[Compiler]>>;
 		infrastructureLog: MultiHook<
 			SyncBailHook<[string, string, undefined | any[]], true | void>
@@ -17733,6 +18553,42 @@ declare abstract class MultiWatching {
 	 */
 	close(callback: (err: null | Error, result?: void) => void): void;
 }
+declare interface MutableToken {
+	/**
+	 * one of the `TT_*` constants
+	 */
+	type: number;
+
+	/**
+	 * byte offset of the token's first code point
+	 */
+	start: number;
+
+	/**
+	 * byte offset just past the token's last code point
+	 */
+	end: number;
+
+	/**
+	 * hash tokens: starts an ident sequence
+	 */
+	isId: boolean;
+
+	/**
+	 * url tokens: first content code point
+	 */
+	contentStart: number;
+
+	/**
+	 * url tokens: just past the last content code point
+	 */
+	contentEnd: number;
+
+	/**
+	 * dimension tokens: first unit-ident code point
+	 */
+	unitStart: number;
+}
 declare class NamedChunkIdsPlugin {
 	/**
 	 * Creates an instance of NamedChunkIdsPlugin.
@@ -17911,6 +18767,9 @@ declare interface NodeOptions {
 	 */
 	global?: boolean | "warn";
 }
+declare interface NodePrinter<TPath, TNode, TPrintOptions = object> {
+	(path: TPath, writer: PrintContext<TPath, TNode, TPrintOptions>): string;
+}
 declare class NodeSourcePlugin {
 	constructor();
 
@@ -17919,20 +18778,59 @@ declare class NodeSourcePlugin {
 	 */
 	apply(compiler: Compiler): void;
 }
-declare class NodeTargetPlugin {
+declare interface NodeSyntax {
 	/**
-	 * Creates an instance of NodeTargetPlugin.
+	 * node-type discriminator
 	 */
-	constructor(type?: ExternalsType);
-	type: ExternalsType;
+	type: number;
 
 	/**
-	 * Applies the plugin by registering its hooks on the compiler.
+	 * byte offset of the node's first code point
 	 */
-	apply(compiler: Compiler): void;
-	static builtins: (string | RegExp)[];
-}
-declare class NodeTemplatePlugin {
+	start: number;
+
+	/**
+	 * byte offset just past the node's last code point
+	 */
+	end: number;
+
+	/**
+	 * the `[start, end)` byte range
+	 */
+	range: [number, number];
+
+	/**
+	 * source location (1-based line, 0-based column)
+	 */
+	loc: {
+		start: { line: number; column: number };
+		end: { line: number; column: number };
+	};
+
+	/**
+	 * source slice for this node
+	 */
+	toString: () => string;
+
+	/**
+	 * name with CSS escapes resolved (name-bearing nodes only)
+	 */
+	unescapedName: string;
+}
+declare class NodeTargetPlugin {
+	/**
+	 * Creates an instance of NodeTargetPlugin.
+	 */
+	constructor(type?: ExternalsType);
+	type: ExternalsType;
+
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 */
+	apply(compiler: Compiler): void;
+	static builtins: (string | RegExp)[];
+}
+declare class NodeTemplatePlugin {
 	/**
 	 * Creates an instance of NodeTemplatePlugin.
 	 */
@@ -17952,7 +18850,7 @@ declare interface NodeTemplatePluginOptions {
 type NodeWebpackOptions = false | NodeOptions;
 type NonNullable<T> = T & {};
 declare class NormalModule extends Module {
-	constructor(__0: NormalModuleCreateDataNormalModuleObject_1<string>);
+	constructor(__0: NormalModuleCreateData<string>);
 	request: string;
 	userRequest: string;
 	rawRequest: string;
@@ -18058,7 +18956,7 @@ declare class NormalModule extends Module {
 		needBuild: AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>;
 	};
 	static deserialize(
-		context: ObjectDeserializerContextObjectMiddlewareObject_4
+		context: ObjectDeserializerContextObjectMiddlewareObject_2
 	): NormalModule;
 
 	/**
@@ -18070,9 +18968,7 @@ declare class NormalModule extends Module {
 type NormalModuleBuildInfo = KnownBuildInfo &
 	Record<string, any> &
 	KnownNormalModuleBuildInfo;
-declare interface NormalModuleCreateDataNormalModuleObject_1<
-	T extends string = string
-> {
+declare interface NormalModuleCreateData<T extends string = string> {
 	/**
 	 * an optional layer in which the module is
 	 */
@@ -18135,8 +19031,8 @@ declare interface NormalModuleCreateDataNormalModuleObject_1<
 		Record<"asset/resource", AssetParser> &
 		Record<"asset/source", AssetSourceParser> &
 		Record<"asset/bytes", AssetBytesParser> &
-		Record<"webassembly/async", AsyncWebAssemblyParser> &
-		Record<"webassembly/sync", WebAssemblyParser> &
+		Record<"webassembly/async", WebAssemblyParserAsyncWebAssemblyParser> &
+		Record<"webassembly/sync", WebAssemblyParserClass> &
 		Record<"css", CssParser> &
 		Record<"css/auto", CssParser> &
 		Record<"css/module", CssParser> &
@@ -18234,6 +19130,10 @@ declare abstract class NormalModuleFactory extends ModuleFactory {
 		afterResolve: AsyncSeriesBailHook<[ResolveData], false | void>;
 		createModule: AsyncSeriesBailHook<[CreateData, ResolveData], void | Module>;
 		module: SyncWaterfallHook<[Module, CreateData, ResolveData], Module>;
+		/**
+		 * @since 5.110.0
+		 */
+		prepareModuleType: HookMap<AsyncSeriesHook<[]>>;
 		createParser: TypedHookMap<
 			Record<
 				"javascript/auto",
@@ -18267,11 +19167,14 @@ declare abstract class NormalModuleFactory extends ModuleFactory {
 				> &
 				Record<
 					"webassembly/async",
-					SyncBailHook<[EmptyParserOptions], AsyncWebAssemblyParser>
+					SyncBailHook<
+						[EmptyParserOptions],
+						WebAssemblyParserAsyncWebAssemblyParser
+					>
 				> &
 				Record<
 					"webassembly/sync",
-					SyncBailHook<[EmptyParserOptions], WebAssemblyParser>
+					SyncBailHook<[EmptyParserOptions], WebAssemblyParserClass>
 				> &
 				Record<"css", SyncBailHook<[CssParserOptions], CssParser>> &
 				Record<"css/auto", SyncBailHook<[CssModuleParserOptions], CssParser>> &
@@ -18319,11 +19222,14 @@ declare abstract class NormalModuleFactory extends ModuleFactory {
 				> &
 				Record<
 					"webassembly/async",
-					SyncBailHook<[AsyncWebAssemblyParser, EmptyParserOptions], void>
+					SyncBailHook<
+						[WebAssemblyParserAsyncWebAssemblyParser, EmptyParserOptions],
+						void
+					>
 				> &
 				Record<
 					"webassembly/sync",
-					SyncBailHook<[WebAssemblyParser, EmptyParserOptions], void>
+					SyncBailHook<[WebAssemblyParserClass, EmptyParserOptions], void>
 				> &
 				Record<"css", SyncBailHook<[CssParser, CssParserOptions], void>> &
 				Record<
@@ -18518,8 +19424,8 @@ declare abstract class NormalModuleFactory extends ModuleFactory {
 		Record<"asset/resource", AssetParser> &
 		Record<"asset/source", AssetSourceParser> &
 		Record<"asset/bytes", AssetBytesParser> &
-		Record<"webassembly/async", AsyncWebAssemblyParser> &
-		Record<"webassembly/sync", WebAssemblyParser> &
+		Record<"webassembly/async", WebAssemblyParserAsyncWebAssemblyParser> &
+		Record<"webassembly/sync", WebAssemblyParserClass> &
 		Record<"css", CssParser> &
 		Record<"css/auto", CssParser> &
 		Record<"css/module", CssParser> &
@@ -18542,8 +19448,8 @@ declare abstract class NormalModuleFactory extends ModuleFactory {
 		Record<"asset/resource", AssetParser> &
 		Record<"asset/source", AssetSourceParser> &
 		Record<"asset/bytes", AssetBytesParser> &
-		Record<"webassembly/async", AsyncWebAssemblyParser> &
-		Record<"webassembly/sync", WebAssemblyParser> &
+		Record<"webassembly/async", WebAssemblyParserAsyncWebAssemblyParser> &
+		Record<"webassembly/sync", WebAssemblyParserClass> &
 		Record<"css", CssParser> &
 		Record<"css/auto", CssParser> &
 		Record<"css/module", CssParser> &
@@ -18813,7 +19719,10 @@ declare class NullDependency extends Dependency {
 	/**
 	 * Returns true if the dependency can be concatenated (scope hoisting).
 	 */
-	static canConcatenate(dependency: Dependency): boolean;
+	static canConcatenate(
+		dependency: Dependency,
+		concatenateCommonJsModules: boolean
+	): boolean;
 	static TRANSITIVE: symbol;
 	static LAZY_UNTIL_LOCAL: "local";
 	static LAZY_UNTIL_ID: "id";
@@ -18826,18 +19735,9 @@ declare class NullDependencyTemplate extends DependencyTemplate {
 declare interface ObjectConfiguration {
 	[index: string]: any;
 }
-
-/**
- * Updates set size using the provided set.
- */
-declare interface ObjectDeserializerContextObjectMiddlewareObject_1 {
-	read: () => string;
-	rest: ObjectDeserializerContextObjectMiddlewareObject_3<[number, boolean]>;
-	setCircularReference: (value: ReferenceableItem) => void;
-}
-declare namespace ObjectDeserializerContextObjectMiddlewareObject_2 {
+declare namespace ObjectDeserializerContextObjectMiddlewareObject_1 {
 	export let read: () => any;
-	export let rest: ObjectDeserializerContextObjectMiddlewareObject_3<
+	export let rest: ObjectDeserializerContextObjectMiddlewareObject_2<
 		ReadonlyArray<any>
 	>;
 	export let setCircularReference: (value: ReferenceableItem) => void;
@@ -18846,20 +19746,20 @@ declare namespace ObjectDeserializerContextObjectMiddlewareObject_2 {
 /**
  * Updates set size using the provided set.
  */
-declare interface ObjectDeserializerContextObjectMiddlewareObject_3<
+declare interface ObjectDeserializerContextObjectMiddlewareObject_2<
 	T extends ReadonlyArray<any> = ReadonlyArray<any>
 > {
 	read: () => Head<T>;
-	rest: ObjectDeserializerContextObjectMiddlewareObject_3<Tail<T>>;
+	rest: ObjectDeserializerContextObjectMiddlewareObject_2<Tail<T>>;
 	setCircularReference: (value: ReferenceableItem) => void;
 }
 
 /**
  * Updates set size using the provided set.
  */
-declare interface ObjectDeserializerContextObjectMiddlewareObject_4 {
-	read: () => any;
-	rest: ObjectDeserializerContextObjectMiddlewareObject_3<ReadonlyArray<any>>;
+declare interface ObjectDeserializerContextObjectMiddlewareObject_3 {
+	read: () => string;
+	rest: ObjectDeserializerContextObjectMiddlewareObject_2<[number, boolean]>;
 	setCircularReference: (value: ReferenceableItem) => void;
 }
 
@@ -18908,10 +19808,10 @@ declare interface ObjectEncodingOptionsTypes {
 declare interface ObjectSerializer {
 	serialize: (
 		value: any,
-		context: ObjectSerializerContextObjectMiddlewareObject_4<any>
+		context: ObjectSerializerContextObjectMiddlewareObject_3<any>
 	) => void;
 	deserialize: (
-		context: ObjectDeserializerContextObjectMiddlewareObject_3<any>
+		context: ObjectDeserializerContextObjectMiddlewareObject_2<any>
 	) => any;
 }
 
@@ -18919,28 +19819,9 @@ declare interface ObjectSerializer {
  * Updates set size using the provided set.
  */
 declare interface ObjectSerializerContextObjectMiddlewareObject_1 {
-	write: (
-		value: RestoreProvidedDataExports[]
-	) => ObjectSerializerContextObjectMiddlewareObject_4<
-		[undefined | null | boolean, undefined | boolean, boolean]
-	>;
-	setCircularReference: (value: ReferenceableItem) => void;
-	snapshot: () => ObjectSerializerSnapshot;
-	rollback: (snapshot: ObjectSerializerSnapshot) => void;
-	writeLazy?: (item?: any) => void;
-	writeSeparate?: (
-		item: any,
-		obj?: LazyOptions
-	) => LazyFunction<any, any, any, LazyOptions>;
-}
-
-/**
- * Updates set size using the provided set.
- */
-declare interface ObjectSerializerContextObjectMiddlewareObject_2 {
 	write: (
 		value: string
-	) => ObjectSerializerContextObjectMiddlewareObject_4<[number, boolean]>;
+	) => ObjectSerializerContextObjectMiddlewareObject_3<[number, boolean]>;
 	setCircularReference: (value: ReferenceableItem) => void;
 	snapshot: () => ObjectSerializerSnapshot;
 	rollback: (snapshot: ObjectSerializerSnapshot) => void;
@@ -18950,10 +19831,10 @@ declare interface ObjectSerializerContextObjectMiddlewareObject_2 {
 		obj?: LazyOptions
 	) => LazyFunction<any, any, any, LazyOptions>;
 }
-declare namespace ObjectSerializerContextObjectMiddlewareObject_3 {
+declare namespace ObjectSerializerContextObjectMiddlewareObject_2 {
 	export let write: (
 		value?: any
-	) => ObjectSerializerContextObjectMiddlewareObject_4<ReadonlyArray<any>>;
+	) => ObjectSerializerContextObjectMiddlewareObject_3<ReadonlyArray<any>>;
 	export let setCircularReference: (value: ReferenceableItem) => void;
 	export let snapshot: () => ObjectSerializerSnapshot;
 	export let rollback: (snapshot: ObjectSerializerSnapshot) => void;
@@ -18969,12 +19850,12 @@ declare namespace ObjectSerializerContextObjectMiddlewareObject_3 {
 /**
  * Updates set size using the provided set.
  */
-declare interface ObjectSerializerContextObjectMiddlewareObject_4<
+declare interface ObjectSerializerContextObjectMiddlewareObject_3<
 	T extends ReadonlyArray<any> = ReadonlyArray<any>
 > {
 	write: (
 		value: Head<T>
-	) => ObjectSerializerContextObjectMiddlewareObject_4<Tail<T>>;
+	) => ObjectSerializerContextObjectMiddlewareObject_3<Tail<T>>;
 	setCircularReference: (value: ReferenceableItem) => void;
 	snapshot: () => ObjectSerializerSnapshot;
 	rollback: (snapshot: ObjectSerializerSnapshot) => void;
@@ -18988,10 +19869,12 @@ declare interface ObjectSerializerContextObjectMiddlewareObject_4<
 /**
  * Updates set size using the provided set.
  */
-declare interface ObjectSerializerContextObjectMiddlewareObject_5 {
+declare interface ObjectSerializerContextObjectMiddlewareObject_4 {
 	write: (
-		value?: any
-	) => ObjectSerializerContextObjectMiddlewareObject_4<ReadonlyArray<any>>;
+		value: RestoreProvidedDataExports[]
+	) => ObjectSerializerContextObjectMiddlewareObject_3<
+		[undefined | null | boolean, undefined | boolean, boolean]
+	>;
 	setCircularReference: (value: ReferenceableItem) => void;
 	snapshot: () => ObjectSerializerSnapshot;
 	rollback: (snapshot: ObjectSerializerSnapshot) => void;
@@ -19131,9 +20014,9 @@ declare interface Optimization {
 	mergeDuplicateChunks?: boolean;
 
 	/**
-	 * Enable minimizing the output. Uses optimization.minimizer.
+	 * Enable minimizing the output. Uses optimization.minimizer. An object enables it and configures the built-in minimizer per asset type.
 	 */
-	minimize?: boolean;
+	minimize?: boolean | OptimizationMinimizeOptions;
 
 	/**
 	 * Minimizer(s) to use for minimizing the output.
@@ -19220,6 +20103,245 @@ declare interface Optimization {
 	usedExports?: boolean | "global";
 }
 
+/**
+ * What the CSS minimizer does. Applies wherever it runs: on `.css` assets and on the inline `<style>` / `style=""` the HTML minimizer hands it. Every transform that keeps the stylesheet's meaning is on by default and may be turned off on its own, so a document a rewrite breaks can be minimized without it while the rest still applies; the two that change what the CSSOM hands back (`convertLengthUnits`, `rewriteCustomProperties`) are off until asked for.
+ * @since 5.110.0
+ */
+declare interface OptimizationMinimizeCss {
+	/**
+	 * 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
+	 */
+	comments?: string | boolean | RegExp | ((comment: string) => boolean);
+
+	/**
+	 * Rewrite a length into a shorter unit it is exactly equal in (`16px` -> `1pc`). Off by default: the authored unit is lost, and once the asset is compressed the rewrite rarely earns anything.
+	 * @since 5.110.0
+	 */
+	convertLengthUnits?: 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
+	 */
+	mergeLonghands?: boolean;
+
+	/**
+	 * Join rules nothing stands between: adjacent rules that print the same block become one selector list, at-rules that share a prelude become one rule, and a named `@layer` block a later sibling opens again is folded into the first. On by default.
+	 * @since 5.110.0
+	 */
+	mergeRules?: boolean;
+
+	/**
+	 * Normalize quoting: a string takes whichever quote needs fewer escapes, a `url()` and an attribute selector's value drop theirs where the content is still one token, and a font family whose name is a run of identifiers is written unquoted. On by default.
+	 * @since 5.110.0
+	 */
+	normalizeQuotes?: boolean;
+
+	/**
+	 * 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
+	 */
+	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`.
+	 * @since 5.110.0
+	 */
+	removeDeadRules?: 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 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
+	 */
+	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.
+	 * @since 5.110.0
+	 */
+	shortenMediaQueries?: boolean;
+
+	/**
+	 * Write each number in its shortest equal spelling — dropping a leading zero, a trailing fraction and a `+`, rounding to the six significant digits a stylesheet can observe, dropping the unit a zero does not need, and writing an alpha and a ratio the one way its grammar spells them. On by default.
+	 * @since 5.110.0
+	 */
+	shortenNumbers?: boolean;
+
+	/**
+	 * Rewrite a selector into an equal one: a selector list deduplicated and ordered, a CSS2 pseudo-element's second colon dropped, the universal a compound already implies dropped, an `An+B` written the shortest way its microsyntax allows, and a `from` / `100%` keyframe selector written as the shorter of the pair. On by default.
+	 * @since 5.110.0
+	 */
+	shortenSelectors?: boolean;
+
+	/**
+	 * Write a value the shortest way its property's own grammar allows: a `{1,4}` box or corner notation collapsed, a slot holding its own initial dropped, and `flex` / `font-weight` / `display` / `transition` / `<position>` / `<repeat-style>` written the short way. On by default. Merging separate longhand declarations is `mergeLonghands`.
+	 * @since 5.110.0
+	 */
+	shortenValues?: boolean;
+
+	/**
+	 * 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
+	 */
+	vendorPrefixes?: boolean;
+}
+
+/**
+ * What the HTML minimizer does. Every transform that keeps the document's DOM is on by default and may be turned off on its own, so a page a rewrite breaks can be minimized without it while the rest still applies; the ones that change what a script or a selector reads back are off until asked for.
+ * @since 5.110.0
+ */
+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.
+	 * @since 5.110.0
+	 */
+	collapseBooleanAttributes?: boolean;
+
+	/**
+	 * 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.
+	 * @since 5.110.0
+	 */
+	collapseWhitespace?: boolean | "all" | "conservative" | "smart";
+
+	/**
+	 * Which comments survive. `"some"`, the default, keeps nothing: every comment an HTML parser reads is inert; `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 downlevel conditional comment, a server-side include and a `<?…?>` template directive are code rather than comments and stay whatever this says. A predicate is handed to the minimizer's worker pool as source, so it must not close over anything.
+	 * @since 5.110.0
+	 */
+	comments?: string | boolean | RegExp | ((comment: string) => 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
+	 */
+	mergeStyles?: boolean;
+
+	/**
+	 * Minify the markup inside a downlevel-hidden conditional comment (`<!--[if IE]> … <![endif]-->`). Off by default: the body is minified on its own, so a context-sensitive decision inside it — which end tags are optional, where a table cell may sit — is taken as though it started a document rather than where the comment sits. Only browsers older than IE10 read these at all.
+	 * @since 5.110.0
+	 */
+	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
+	 */
+	normalizeAttributeQuotes?: boolean;
+
+	/**
+	 * Fold an enumerated attribute's value to the keyword it names (`type="TEXT"` -> `type=text`), which the DOM matches ASCII case-insensitively. A value the spec does not enumerate is left as written. On by default.
+	 * @since 5.110.0
+	 */
+	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.
+	 * @since 5.110.0
+	 */
+	normalizeListAttributes?: boolean;
+
+	/**
+	 * Write an integer attribute (`tabindex`, `colspan`, `width`, …) the one way its own rules read it — leading whitespace, a `+` and leading zeros all go. On by default.
+	 * @since 5.110.0
+	 */
+	normalizeNumericAttributes?: 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
+	 */
+	removeEmptyAttributes?: boolean;
+
+	/**
+	 * Drop an element that has no children and no attributes. Kept anyway when its bare form is still doing a job (`canvas`, `slot`, `template`, `textarea`, `progress`, `meter`, `output`, `dialog`, and the table structure), when it is a void element, or when it is foreign content. Off by default: CSS can give an empty element a size or a `::before`, and the minifier cannot see the stylesheet. Emptiness is read off the output rather than the source, so a run of nested empties goes together and an element left empty only by a dropped comment or by whitespace `collapseWhitespace` deletes goes with them.
+	 * @since 5.110.0
+	 */
+	removeEmptyElements?: boolean;
+
+	/**
+	 * How much of the `<html>` / `<head>` / `<body>` shell §13.1.2.4 lets the parser imply may be left out. Every other optional tag goes unconditionally — nothing can observe that — but these six are what a consumer reading the page with a regexp rather than a parser looks for. `"smart"`, the default, leaves out the one such a reader never matches: the `<html>` start tag, which is omittable only when it carries no attribute at all, so the `<html lang=en>` anyone greps for keeps its tag anyway. `</html>` stays with it, since a truncation check reads a page as complete by finding one. `true` (or `"all"`) leaves out all six, which is where a crawler matching on `<body>` stops finding one; `false` leaves out none. A tag also stays wherever the spec keeps it: an attribute to carry, a comment minifying does not drop, whitespace opening the element, or a `meta` / `noscript` / `link` / `script` / `style` / `template` element opening the body.
+	 * @since 5.110.0
+	 */
+	removeImpliedTags?: boolean | "all" | "smart";
+
+	/**
+	 * Leave out a tag §13.1.2.4 lets the parser imply, other than the `<html>` / `<head>` / `<body>` shell, which `removeImpliedTags` decides on its own. On by default: nothing can observe the difference, the tree parses the same either way. A tag still stays wherever the spec keeps it — a comment or whitespace behind it, or a following element the insertion mode does not close it through.
+	 * @since 5.110.0
+	 */
+	removeOptionalTags?: boolean;
+
+	/**
+	 * Drop an attribute whose value is the one the element already defaults to. Off by default: an attribute a page no longer carries is one `getAttribute` and every attribute selector read differently, whichever tier dropped it. `true` (or `"smart"`) drops only markers on elements that render nothing — `<script type=text/javascript>`, `<script language=javascript>`, `<script charset=utf-8>`, `<style type=text/css>`, `<link type=text/css>`, `<link media=all>` — so no rule that styles the page stops applying, which is what `@swc/html` does by default. `"all"` also drops spec defaults such as `<input type=text>` and `<form method=get>`, which reaches further still: an attribute selector matches the content attribute, not the reflected default, so `input[type=text]` stops matching.
+	 * @since 5.110.0
+	 */
+	removeRedundantAttributes?: boolean | "all" | "smart";
+
+	/**
+	 * Print an element's attributes in a fixed order: the document's commonest attribute names first, ties by name. Nothing in HTML reads attribute order, so this only makes the same markup compress better across pages — the run of attributes two elements share becomes the same run of bytes. Off by default: a script reading `element.attributes` back, or a snapshot of the emitted HTML, sees the new order.
+	 * @since 5.110.0
+	 */
+	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.
+	 * @since 5.110.0
+	 */
+	sortTokenLists?: boolean;
+}
+
+/**
+ * Options handed as-is to the JavaScript minimizer (terser-compatible). Defaults to `{ compress: { passes: 2 } }`.
+ * @since 5.110.0
+ */
+declare interface OptimizationMinimizeJavascript {
+	[index: string]: any;
+}
+
+/**
+ * Enable minimizing the output, configured per asset type. An absent type is minimized with the defaults; `false` disables minimizing it.
+ * @since 5.110.0
+ */
+declare interface OptimizationMinimizeOptions {
+	/**
+	 * Minimize CSS assets: `false` disables it, an object configures what the built-in minimizer may do beyond the transforms that always apply.
+	 */
+	css?: false | OptimizationMinimizeCss;
+
+	/**
+	 * Minimize HTML assets: `false` disables it, an object configures what the built-in minimizer may do beyond the transforms that always apply.
+	 */
+	html?: false | OptimizationMinimizeHtml;
+
+	/**
+	 * Minimize JavaScript assets: `false` disables it, an object is handed as-is to the JavaScript minimizer.
+	 */
+	javascript?: false | OptimizationMinimizeJavascript;
+}
+
 /**
  * Enables/Disables integrated optimizations.
  */
@@ -19281,9 +20403,9 @@ declare interface OptimizationNormalized {
 	mergeDuplicateChunks?: boolean;
 
 	/**
-	 * Enable minimizing the output. Uses optimization.minimizer.
+	 * Enable minimizing the output. Uses optimization.minimizer. An object configures the built-in minimizer per asset type.
 	 */
-	minimize?: boolean;
+	minimize?: false | OptimizationMinimizeOptions;
 
 	/**
 	 * Minimizer(s) to use for minimizing the output.
@@ -19411,7 +20533,7 @@ type OptimizationNormalizedWithDefaults = OptimizationNormalized & {
 	mangleWasmImports: NonNullable<undefined | boolean>;
 	portableRecords: NonNullable<undefined | boolean>;
 	realContentHash: NonNullable<undefined | boolean>;
-	minimize: NonNullable<undefined | boolean>;
+	minimize: NonNullable<undefined | false | OptimizationMinimizeOptions>;
 	minimizer: (
 		| ((this: Compiler, compiler: Compiler) => void)
 		| WebpackPluginInstance
@@ -20656,7 +21778,8 @@ type OutputNormalizedWithDefaults = OutputNormalized & {
 declare interface ParameterizedComparator<TArg extends object, T> {
 	(tArg: TArg): Comparator<T>;
 }
-declare interface ParseOptions {
+type ParseErrorSeverity = "error" | "warning";
+declare interface ParseOptionsJavascriptParser {
 	sourceType: "module" | "script";
 	ecmaVersion: ecmaVersion;
 	locations?: boolean;
@@ -20685,6 +21808,12 @@ declare interface ParseOptions {
 	 */
 	moduleFallback?: boolean;
 }
+declare interface ParseOptionsSyntax {
+	/**
+	 * optional comment-token callback; the public `parse*` entry points use it to build the `TokenStream` so the outer parser's comment tracker still sees magic comments inside the consumed range
+	 */
+	comment?: (input: string, start: number, end: number) => number;
+}
 declare interface ParseResult {
 	ast: Program;
 	comments: CommentJavascriptParser[];
@@ -20927,15 +22056,111 @@ type Pattern =
  * Configuration object for web performance recommendations.
  */
 declare interface PerformanceOptions {
+	/**
+	 * Fallback value for the performance checks that are not set individually (has precedence over local webpack defaults). Does not apply to 'hints', 'maxAssetSize' or 'maxEntrypointSize'.
+	 * @since 5.110.0
+	 */
+	all?: boolean;
+
 	/**
 	 * Filter function to select assets that are checked.
 	 */
 	assetFilter?: (name: string, source: Source, assetInfo: AssetInfo) => boolean;
 
 	/**
-	 * Sets the format of the hints: warnings, errors or nothing at all.
+	 * Report chains of 'import()' calls where each chunk can only be requested once the one before it has arrived, so the levels cost round trips in series (requires 'hints' to be enabled).
+	 * @since 5.110.0
+	 */
+	asyncChunkWaterfalls?: boolean;
+
+	/**
+	 * Report 'require.context' calls with no filter, which bundle every file under a directory (requires 'hints' to be enabled).
+	 * @since 5.110.0
+	 */
+	broadContexts?: boolean;
+
+	/**
+	 * Report how much of the module graph the cache reused, and the modules that can never be reused (requires 'hints' to be enabled).
+	 * @since 5.110.0
+	 */
+	cacheEffectiveness?: boolean;
+
+	/**
+	 * Report groups of modules that import each other synchronously (requires 'hints' to be enabled).
+	 * @since 5.110.0
 	 */
-	hints?: false | "error" | "warning";
+	circularDependencies?: boolean;
+
+	/**
+	 * Report chunks asked for as both prefetch and preload from the same place, where the two directives contradict each other.
+	 * @since 5.110.0
+	 */
+	conflictingResourceHints?: boolean;
+
+	/**
+	 * Report modules emitted into more than one chunk, and the bytes the extra copies cost (requires 'hints' to be enabled).
+	 * @since 5.110.0
+	 */
+	duplicateModules?: boolean;
+
+	/**
+	 * Report packages which are included more than once, in different versions or as multiple copies of the same version (requires 'hints' to be enabled).
+	 * @since 5.110.0
+	 */
+	duplicatePackages?: boolean;
+
+	/**
+	 * Report modules whose exports cannot be read statically, which stops anything importing them from being tree-shaken (requires 'hints' to be enabled).
+	 * @since 5.110.0
+	 */
+	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
+	 */
+	evalUsage?: boolean;
+
+	/**
+	 * Sets the format of the hints: warnings, errors, stats-only or nothing at all.
+	 */
+	hints?: false | "error" | "stats" | "warning";
+
+	/**
+	 * Report the loaders, plugins and hooks that hold the main thread, timing each one's own code rather than what it waited for (requires 'hints' to be enabled).
+	 * @since 5.110.0
+	 */
+	hotspots?: boolean;
+
+	/**
+	 * Report assets inlined as data urls that are large enough for the base64 cost and the lost caching to outweigh the request they save (requires 'hints' to be enabled).
+	 * @since 5.110.0
+	 */
+	inlinedAssets?: boolean;
+
+	/**
+	 * Report a single module that makes up most of the chunk it is in (requires 'hints' to be enabled).
+	 * @since 5.110.0
+	 */
+	largeModules?: boolean;
+
+	/**
+	 * Report polyfill packages that emulate language features the target already supports natively (requires 'hints' to be enabled).
+	 * @since 5.110.0
+	 */
+	legacyJavascript?: boolean;
 
 	/**
 	 * File size limit (in bytes) when exceeded, that webpack will provide performance hints.
@@ -20946,6 +22171,96 @@ declare interface PerformanceOptions {
 	 * Total size of an entry point (in bytes).
 	 */
 	maxEntrypointSize?: number;
+
+	/**
+	 * Report packages that keep unused code in the bundle because their package.json does not declare 'sideEffects' (requires 'hints' to be enabled).
+	 * @since 5.110.0
+	 */
+	missingSideEffects?: boolean;
+
+	/**
+	 * Report an entry that exports a default beside named exports for a CommonJS library, where a consumer receives the namespace object (requires 'hints' to be enabled).
+	 * @since 5.110.0
+	 */
+	mixedExports?: boolean;
+
+	/**
+	 * Report conditions in 'module.rules' that hardcode a path separator, so they only match on one operating system.
+	 * @since 5.110.0
+	 */
+	osDependentRules?: boolean;
+
+	/**
+	 * Report '/*#__PURE__* /' annotations that sit somewhere the parser does not read them (requires 'hints' to be enabled).
+	 * @since 5.110.0
+	 */
+	pureAnnotations?: boolean;
+
+	/**
+	 * Report 'import()' calls whose module is already loaded where the call runs, so they defer nothing (requires 'hints' to be enabled).
+	 * @since 5.110.0
+	 */
+	redundantDynamicImports?: boolean;
+
+	/**
+	 * Report modules that could not be merged into their importer's scope, and why (requires 'hints' to be enabled).
+	 * @since 5.110.0
+	 */
+	scopeHoistingBailouts?: boolean;
+
+	/**
+	 * Report splits 'optimization.splitChunks' refused because 'maxInitialRequests' or 'maxAsyncRequests' was already reached (requires 'hints' to be enabled).
+	 * @since 5.110.0
+	 */
+	splitChunksCapped?: boolean;
+
+	/**
+	 * Report chunks loaded on demand that carry less than 'optimization.splitChunks.minSize' (requires 'hints' to be enabled).
+	 * @since 5.110.0
+	 */
+	tinyChunks?: boolean;
+
+	/**
+	 * Report modules that read 'this' at the top level of an ES module, where it is 'undefined' rather than the module object or the global one (requires 'hints' to be enabled).
+	 * @since 5.110.0
+	 */
+	topLevelThis?: boolean;
+
+	/**
+	 * Report initial chunks that mix 'node_modules' code with application code, so every application change re-downloads the dependencies too (requires 'hints' to be enabled).
+	 * @since 5.110.0
+	 */
+	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
+	 */
+	unusedExternals?: 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
+	 */
+	unusedReexports?: 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
+	 */
+	unusedRules?: boolean;
 }
 declare interface PitchLoaderDefinitionFunction<
 	OptionsType = {},
@@ -21086,6 +22401,224 @@ declare class PrefixSource extends Source {
 declare interface PreparsedAst {
 	[index: string]: any;
 }
+
+/**
+ * The per-node output store handed to a language node printer as its `writer`. It
+ * carries the print `options` (today just `mode`) and one map: a finished node ->
+ * its printed text. A printer *returns* its text (`printNode` stores it) and reads
+ * a child's with `get`, so a parent composes its own text from its children's —
+ * the map is what makes that composition (and the CSS value transforms built on
+ * it) possible. `take` flushes a finished top-level node into the output and drops
+ * the map, so a streaming grammar never holds more than one top-level subtree.
+ */
+declare class PrintContext<TPath, TNode, TPrintOptions = object> {
+	constructor(
+		options: PrintOptions & TPrintOptions,
+		printer: NodePrinter<TPath, TNode, TPrintOptions>
+	);
+	options: PrintOptions & TPrintOptions;
+	mapWanted: boolean;
+
+	/**
+	 * Hold `text` back as the opener of a node being printed in pieces. Nothing
+	 * reaches the output until {@link flushPending}, so {@link dropPending} can
+	 * still take it back if the node turns out to be empty.
+	 */
+	pushPending(text: string): number;
+
+	/**
+	 * Rewrite a held-back opener — an opener whose text depends on what turns out
+	 * to follow it can only be settled once something does.
+	 */
+	setPending(depth: number, text: string): void;
+
+	/**
+	 * Emit every held-back opener, outermost first — something inside the
+	 * innermost one has content, so all of them do.
+	 */
+	flushPending(): void;
+
+	/**
+	 * Anchor the outermost held-back opener, applied when it is flushed. Openers
+	 * are flushed together, so only the outermost carries one.
+	 */
+	anchorPending(srcOffset?: number, srcLine?: number, srcCol?: number): void;
+	isPending(depth: number): boolean;
+
+	/**
+	 * Drop the innermost held-back opener — its node printed to nothing.
+	 */
+	dropPending(): void;
+
+	/**
+	 * Close off what has been emitted so far and return the index the next piece
+	 * will take. Cutting is the point: a caller bounding a later edit by this
+	 * (see {@link dropTrailing}) must not be able to reach output from before it,
+	 * which a mark taken while the tail was still open would sit in the middle of.
+	 */
+	markCut(): number;
+
+	/**
+	 * Append a piece of a node that is being printed in pieces. Nothing takes it
+	 * back, so it only extends the output.
+	 */
+	emitStreamed(text: string): void;
+
+	/**
+	 * Forget every node's printed text. A node printed in pieces does this once
+	 * each child is emitted, so the store never holds more than one of them —
+	 * which is also what keeps a recycled node id from reading as an earlier
+	 * node's text.
+	 */
+	dropStore(): void;
+
+	/**
+	 * Drop trailing `charCode`s from the end of the output at or after `from` —
+	 * the separator the piece before a terminator no longer needs. Walks back over
+	 * pieces emptied by {@link retract}, so it sees what the output reads as.
+	 */
+	dropTrailing(from: number, charCode: number): void;
+
+	/**
+	 * Run the node printer for `node` and store what it returns (the grammar calls
+	 * this once the node's visitors and children are done). `path` is on `node`.
+	 */
+	printNode(node: TNode, path: TPath): void;
+
+	/**
+	 * Print one node and hand its text straight back — for a node inside one being
+	 * printed in pieces, whose text is emitted as it is printed, so the store
+	 * would only ever be written and read once.
+	 */
+	printPiece(path: TPath): string;
+	get(node: TNode): string;
+
+	/**
+	 * Append `text` as a piece of its own, so {@link retract} can still take it
+	 * back once a later sibling turns out to override it. Cuts the accumulating
+	 * tail off in front of it, so it is for the text that may actually be taken
+	 * back and not for output at large.
+	 */
+	emitRetractable(text: string): number;
+
+	/**
+	 * Take back an already-emitted piece — the printer has since found that a
+	 * later one overrides it. Pieces after it keep their place. A piece emitted by
+	 * {@link takeRetractable} takes the mapping anchored to it back as well; any
+	 * other anchor into the piece would be left pointing at what follows it, so
+	 * this must not be used on one (see {@link take}).
+	 */
+	retract(index: number): void;
+
+	/**
+	 * Fold `text` into an already-emitted piece, in front of the character it ends
+	 * with — a later sibling whose body belongs inside that piece, as a repeated
+	 * named `@layer` block's does. Mappings are piece-relative and this only grows
+	 * the piece past everything already anchored in it, so they keep their
+	 * positions; the folded text carries none of its own.
+	 */
+	foldIntoRetractable(index: number, text: string): void;
+
+	/**
+	 * Write an already-emitted piece again, shorter — a rule inside it a later
+	 * copy makes dead. Mappings anchored in the piece keep the offsets they were
+	 * given, so one inside what was cut names what now follows it.
+	 */
+	rewriteRetractable(index: number, text: string): void;
+
+	/**
+	 * {@link take} for a top-level node a later sibling may still make dead — the
+	 * unprefixed twin of a vendor-prefixed rule, which can stand anywhere after
+	 * it. The node is emitted as a piece of its own, with its mapping recorded
+	 * against that piece, so {@link retract} takes both back.
+	 */
+	takeRetractable(
+		node: TNode,
+		srcOffset?: number,
+		srcLine?: number,
+		srcCol?: number,
+		text?: string
+	): number;
+
+	/**
+	 * Emit one finished top-level node: first any kept comments that precede it,
+	 * then a source mapping anchoring its output start to `[srcLine, srcCol]`, then
+	 * its text — and drop the per-node store so the next top-level node starts
+	 * clean. `srcOffset` / `srcLine` / `srcCol` are the node's source position; a
+	 * grammar that doesn't map positions (e.g. HTML) omits them (no comments, no
+	 * mapping — the map ends up empty).
+	 */
+	take(
+		node?: TNode,
+		srcOffset?: number,
+		srcLine?: number,
+		srcCol?: number,
+		text?: string
+	): void;
+
+	/**
+	 * Tie whatever is emitted next to a source position: flush the kept comments
+	 * that precede it, then record the mapping. Split out of {@link take} for a
+	 * node printed in pieces, whose first piece is emitted well after the printer
+	 * for it began.
+	 */
+	anchor(srcOffset?: number, srcLine?: number, srcCol?: number): void;
+
+	/**
+	 * Whether a kept literal is queued to land before `pos`. A printer folding two
+	 * top-level nodes together asks first: the literal belongs between them, so
+	 * the fold would move it past what it was written above.
+	 */
+	hasInsertBefore(pos: number): boolean;
+
+	/**
+	 * Emit the kept literals landing before `pos`. A printer holding a node back
+	 * calls this at hold time, so what was written above it is still emitted
+	 * above it — and {@link hasInsertBefore} then answers about the gap to the
+	 * next node rather than the whole span since the last node taken.
+	 */
+	flushInsertsBefore(pos: number): void;
+
+	/**
+	 * Queue a literal to carry through to the output at source offset `pos` — a
+	 * comment the printer chose to keep (e.g. a `/*!` license banner). Calls
+	 * arrive in source order; each lands just before the first top-level node
+	 * starting after `pos` (or at the end, via {@link result}).
+	 */
+	insert(pos: number, text: string): void;
+
+	/**
+	 * Take the queued inserts sitting in `[start, end)` — a printer that writes
+	 * that source range out itself places them, so the writer must not flush
+	 * them ahead of the next top-level node as well.
+	 */
+	takeInserts(start: number, end: number): string;
+	sourceMap(options: SourceMapOptions): SourceMap;
+
+	/**
+	 * Stand the text `resolve` gives back in place of every deferred write left
+	 * in the output, and move the mappings that follow one in the same piece by
+	 * what its text changed in length. Runs before {@link result} and
+	 * {@link sourceMap}, so both read the substituted output rather than
+	 * correcting for it.
+	 * The marker is `NUL id NUL`. A NUL mostly cannot reach printed output on its
+	 * own account — both preprocessors turn one into U+FFFD — but an RCDATA
+	 * element and an attribute value keep the one they were written with, so a
+	 * pair of them is read as a write only where what stands between spells an id
+	 * this answers for. Anything else is the source's own text and is left alone.
+	 */
+	substitute(resolve: (id: number) => undefined | string, infix: string): void;
+
+	/**
+	 * Throw away everything printed and stand `text` in its place. For the one
+	 * caller that can only tell its output is wrong once it has all of it.
+	 */
+	replaceAll(text: string): void;
+	result(): string;
+}
+declare interface PrintOptions {
+	mode: "minify" | "beautify";
+}
 declare interface PrintedElement {
 	element: string;
 	content?: string;
@@ -21359,6 +22892,13 @@ declare interface ProvidesObject {
 }
 type PureCondition =
 	boolean | ((compilation: Compilation, module: Module) => boolean);
+type QualifiedRule = NodeSyntax & {
+	prelude: ComponentValue[];
+	declarations: null | DeclarationSyntax[];
+	childRules: null | RuleSyntax[];
+	blockStart: number;
+	blockEnd: number;
+};
 declare interface RawChunkGroupOptions {
 	preloadOrder?: number;
 	prefetchOrder?: number;
@@ -21945,10 +23485,7 @@ declare interface ReaddirTypes {
 			withFileTypes: true;
 			recursive?: boolean;
 		},
-		callback: (
-			err: null | NodeJS.ErrnoException,
-			files?: DirentTypes<string>[]
-		) => void
+		callback: (err: null | NodeJS.ErrnoException, files?: DirentTypes[]) => void
 	): void;
 	(
 		path: PathLikeTypes,
@@ -22115,92 +23652,14 @@ type RecursiveArrayOrRecord<T> =
 	| RecursiveArrayOrRecord<T>[]
 	| T;
 declare interface RecursiveNonNullable<T> {}
-declare interface Reference {
+
+/**
+ * One identifier occurrence that refers to a binding.
+ */
+declare abstract class Reference {
 	identifier: Identifier;
 	from: Scope;
-	resolved: null | Variable;
-	writeExpr:
-		| null
-		| Program
-		| ImportDeclaration
-		| ExportNamedDeclaration
-		| ExportAllDeclaration
-		| ImportExpressionImport
-		| UnaryExpression
-		| ArrayExpression
-		| ArrowFunctionExpression
-		| AssignmentExpression
-		| AwaitExpression
-		| BinaryExpression
-		| SimpleCallExpression
-		| NewExpression
-		| ChainExpression
-		| ClassExpression
-		| ConditionalExpression
-		| FunctionExpression
-		| Identifier
-		| SimpleLiteral
-		| RegExpLiteral
-		| BigIntLiteral
-		| LogicalExpression
-		| MemberExpression
-		| MetaProperty
-		| ObjectExpression
-		| SequenceExpression
-		| TaggedTemplateExpression
-		| TemplateLiteral
-		| ThisExpression
-		| UpdateExpression
-		| YieldExpression
-		| SpreadElement
-		| PrivateIdentifier
-		| Super
-		| FunctionDeclaration
-		| VariableDeclaration
-		| ClassDeclaration
-		| ExpressionStatement
-		| BlockStatement
-		| StaticBlock
-		| EmptyStatement
-		| DebuggerStatement
-		| WithStatement
-		| ReturnStatement
-		| LabeledStatement
-		| BreakStatement
-		| ContinueStatement
-		| IfStatement
-		| SwitchStatement
-		| ThrowStatement
-		| TryStatement
-		| WhileStatement
-		| DoWhileStatement
-		| ForStatement
-		| ForInStatement
-		| ForOfStatement
-		| ExportDefaultDeclaration
-		| MethodDefinition
-		| PropertyDefinition
-		| VariableDeclarator
-		| AssignmentProperty
-		| Property
-		| CatchClause
-		| ClassBody
-		| ImportSpecifier
-		| ImportDefaultSpecifier
-		| ImportNamespaceSpecifier
-		| ExportSpecifier
-		| ObjectPattern
-		| ArrayPattern
-		| RestElement
-		| AssignmentPattern
-		| SwitchCase
-		| TemplateElement;
-	init: boolean;
-	isWrite: () => boolean;
-	isRead: () => boolean;
-	isWriteOnly: () => boolean;
-	isReadOnly: () => boolean;
-	isReadWrite: () => boolean;
+	resolved?: Variable;
 }
 type ReferenceableItem = string | object;
 declare interface ReferencedExport {
@@ -23220,6 +24679,11 @@ declare interface ResourceDataWithData {
  * @since 5.109.0
  */
 declare interface ResourceHintsOptions {
+	/**
+	 * Skip the runtime-injected `<link rel="prefetch">` for a chunk that is already preloaded or prefetched in the document (avoids a duplicate request in some browsers such as Chrome).
+	 */
+	dedupe?: boolean;
+
 	/**
 	 * Initial dependency-graph chunk hints. `true` auto-emits `<link rel="modulepreload">` (ESM output) or `<link rel="preload" as="script">` (classic) for each of the entry's initial dependency chunks; `"prefetch"` uses `<link rel="prefetch">`; `"preload"` is an alias of `true`; `false` disables chunk hints (URL-asset hints from magic comments / `urlHints` still fire); `"none"` is a hard off switch (no `<link>` anywhere, empty stats / manifest); an array of `HtmlResourceHint` descriptors replaces the auto set; a function receives the auto `defaultHints` plus context (`entryName`, `entrypoint`, `hostType: "html" | "js"`, `compilation`) and returns the final list (replaces the removed `resolveDependencies` hook).
 	 * @since 5.109.0
@@ -23290,7 +24754,7 @@ declare abstract class RestoreProvidedData {
 	/**
 	 * Serializes this instance into the provided serializer context.
 	 */
-	serialize(context: ObjectSerializerContextObjectMiddlewareObject_1): void;
+	serialize(context: ObjectSerializerContextObjectMiddlewareObject_4): void;
 }
 declare interface RestoreProvidedDataExports {
 	name: string;
@@ -23301,7 +24765,28 @@ declare interface RestoreProvidedDataExports {
 	pureProvide?: boolean;
 	exportsInfo?: RestoreProvidedData;
 }
-type Rule = string | RegExp | ((str: string) => boolean);
+type RuleAlias = string | RegExp | ((str: string) => boolean);
+declare interface RuleCondition {
+	property: string | string[];
+	matchWhenEmpty: boolean;
+	fn: (
+		value: EffectData[
+			| "compiler"
+			| "dependency"
+			| "resource"
+			| "scheme"
+			| "realResource"
+			| "resourceQuery"
+			| "resourceFragment"
+			| "attributes"
+			| "mimetype"
+			| "descriptionData"
+			| "descriptionRelativePath"
+			| "issuer"
+			| "issuerLayer"
+			| "phase"]
+	) => boolean;
+}
 declare interface RuleSet {
 	/**
 	 * map of references in the rule set (may grow over time)
@@ -23312,6 +24797,11 @@ declare interface RuleSet {
 	 * execute the rule set
 	 */
 	exec: (effectData: EffectData) => Effect[];
+
+	/**
+	 * the rules that never matched, outermost first
+	 */
+	unusedRules: () => CompiledRule[];
 }
 type RuleSetCondition =
 	| string
@@ -23334,7 +24824,7 @@ type RuleSetConditionOrConditions =
 type RuleSetLoaderOptions = string | { [index: string]: any };
 
 /**
- * Logic operators used in a condition matcher.
+ * Logic operators and glob patterns used in a condition matcher.
  */
 declare interface RuleSetLogicalConditions {
 	/**
@@ -23342,6 +24832,12 @@ declare interface RuleSetLogicalConditions {
 	 */
 	and?: RuleSetCondition[];
 
+	/**
+	 * Match glob patterns against the value, `!` in front of a pattern excludes it. Path separators are normalized to `/` on every OS, and a relative pattern matches at any depth.
+	 * @since 5.110.0
+	 */
+	glob?: string | string[];
+
 	/**
 	 * Logical NOT.
 	 */
@@ -23359,7 +24855,7 @@ declare interface RuleSetLogicalConditions {
 }
 
 /**
- * Logic operators used in a condition matcher.
+ * Logic operators and glob patterns used in a condition matcher.
  */
 declare interface RuleSetLogicalConditionsAbsolute {
 	/**
@@ -23367,6 +24863,12 @@ declare interface RuleSetLogicalConditionsAbsolute {
 	 */
 	and?: RuleSetConditionAbsolute[];
 
+	/**
+	 * Match glob patterns against the value, `!` in front of a pattern excludes it. Path separators are normalized to `/` on every OS, and a relative pattern matches at any depth.
+	 * @since 5.110.0
+	 */
+	glob?: string | string[];
+
 	/**
 	 * Logical NOT.
 	 */
@@ -23417,6 +24919,17 @@ declare interface RuleSetRule {
 	 */
 	descriptionData?: { [index: string]: RuleSetConditionOrConditions };
 
+	/**
+	 * Match the path of the module relative to the directory of the description file (usually package.json), i.e. './lib/button.js'. Always uses forward slashes.
+	 * @since 5.110.0
+	 */
+	descriptionRelativePath?:
+		| string
+		| RegExp
+		| ((value: string) => boolean)
+		| RuleSetLogicalConditions
+		| RuleSetCondition[];
+
 	/**
 	 * Enforce this rule as pre or post step.
 	 */
@@ -23442,6 +24955,12 @@ declare interface RuleSetRule {
 	 */
 	generator?: { [index: string]: any };
 
+	/**
+	 * Match the module resource against glob patterns, `!` in front of a pattern excludes it. Combines with `test`, `include` and `exclude`.
+	 * @since 5.110.0
+	 */
+	glob?: string | string[];
+
 	/**
 	 * Shortcut for resource.include.
 	 */
@@ -23740,6 +25259,7 @@ type RuleSetUseItem =
 			 */
 			options?: string | { [index: string]: any };
 	  };
+type RuleSyntax = AtRule | QualifiedRule;
 declare class RuntimeChunkPlugin {
 	/**
 	 * Creates an instance of RuntimeChunkPlugin.
@@ -23789,6 +25309,8 @@ declare class RuntimeModule extends Module {
 
 	/**
 	 * Returns true, if the runtime module should get it's own scope.
+	 * When false, `generate()` must emit complete statements ending with `;`
+	 * so a following runtime IIFE is not parsed as a call (ASI).
 	 */
 	shouldIsolate(): boolean;
 
@@ -23906,6 +25428,12 @@ declare abstract class RuntimeTemplate {
 	globalObject: string;
 	contentHashReplacement: string;
 	isIIFE(): boolean;
+
+	/**
+	 * Whether the global object expression reads the `this` binding, which only
+	 * refers to the global object outside of strict mode.
+	 */
+	globalObjectUsesThis(): boolean;
 	isModule(): boolean;
 	isNeutralPlatform(): boolean;
 
@@ -23923,8 +25451,10 @@ declare abstract class RuntimeTemplate {
 
 	/**
 	 * Expression for the global registry that collects CSS server-side when there
-	 * is no DOM (SSR). An SSR host reads it from `globalThis`; it is keyed by the
-	 * style/chunk identifier and namespaced by `output.uniqueName`.
+	 * is no DOM (SSR). Read it with `__webpack_css_server_styles__`; it is keyed
+	 * by the style/chunk identifier and namespaced by `output.uniqueName`.
+	 * Targets without `globalThis` go through the `__webpack_require__.g`
+	 * polyfill, so consumers must also require `RuntimeGlobals.global`.
 	 */
 	cssServerStyleRegistry(): string;
 	supportsConst(): boolean;
@@ -23943,8 +25473,81 @@ declare abstract class RuntimeTemplate {
 	supportsBigIntLiteral(): boolean;
 	supportsDynamicImport(): boolean;
 	supportsEcmaScriptModuleSyntax(): boolean;
+	supportsDeferImport(): boolean;
+	supportsSourceImport(): boolean;
 	supportsModulePreload(): boolean;
-	supportsAnalyzableEsm(): boolean;
+
+	/**
+	 * 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:
+	 * - `"import"` — a literal `import("./chunk.js")` in place of `ensureChunk(id)`
+	 * - `"url"` — a literal `new URL(<file>, import.meta.url)`
+	 * - `"url-runtime"` — the same, written into a runtime module rather than a module
+	 * - `"url-inline"` — whether such a reference names the file at the call site
+	 * - `"wasm"` — the same, fully baked for a wasm binary the runtime would name
+	 * - `"wasm-relative"` — a wasm path built at runtime under an `import.meta.url` base
+	 * `"url-inline"` differs from `"url"` only in taking the `.p + <file>` fallback as
+	 * an answer too — both name the file where it is used rather than through the
+	 * asset's javascript wrapper, which is what decides whether that wrapper is emitted.
+	 * A name code generation cannot settle may still be baked, through a stand-in the
+	 * deferred pass fills in. Not covered here, because only the reference can tell: a
+	 * chunk with no id, and one this compilation emits no javascript for.
+	 */
+	supportsAnalyzable(
+		form: AnalyzableForm,
+		chunkGraph?: ChunkGraph,
+		module?: Module,
+		runtime?: RuntimeSpec
+	): boolean;
+
+	/**
+	 * 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
+	 * current module (via `output.importMetaName`) instead of the runtime public-path
+	 * global — the form other bundlers and webpack itself can statically follow.
+	 */
+	importMetaUrl(specifier: string): string;
+
+	/**
+	 * Whether a baked asset url resolves against the entry `baseUri` at all. A public
+	 * path that reaches the same place from any base never reads `.b` — and `auto`
+	 * resolves to an absolute url too — while output with no baked form has nothing to
+	 * resolve. Where this is false, what `baseUri` is set to cannot reach the generated
+	 * code, so it must not reach the module hash either: `URLDependency.updateHash`
+	 * asks this before contributing one.
+	 */
+	analyzableUrlReadsBaseUri(): boolean;
+
+	/**
+	 * Static literal specifier (already quoted) for the `new URL(<here>, import.meta.url)`
+	 * an asset reference bakes to, or `null` to keep the runtime form. Unlike a wasm
+	 * binary, the runtime resolves an asset url against `__webpack_require__.b` — the
+	 * output root, or an entry `baseUri` where one is set — so that base is settled here
+	 * before the rest of the name is.
+	 */
+	getAnalyzableAssetUrl(
+		module: Module,
+		chunkGraph: ChunkGraph,
+		filename: string,
+		runtime: RuntimeSpec
+	): null | string;
+
+	/**
+	 * The `baseUri` the entries this code runs under agree on, which replaces the output
+	 * root an asset url resolves against. Asked per runtime, because that is what the
+	 * module is generated for: two entries with different bases each get their own
+	 * source. `undefined` when none of them sets one, `null` when they disagree — an
+	 * entry that omits it disagrees with one that sets it.
+	 */
+	entryBaseUri(runtime: RuntimeSpec): undefined | null | string;
+
+	/**
+	 * `output.publicPath` as the constant it will be, for code that would otherwise read
+	 * `__webpack_require__.p` for a value that never changes. `undefined` when only the
+	 * hash could say, or when a runtime reassigns `__webpack_public_path__` — then the
+	 * global is the only thing that knows.
+	 */
+	constantPublicPath(): undefined | string;
 	supportTemplateLiteral(): boolean;
 	supportNodePrefixForCoreModules(): boolean;
 
@@ -24000,6 +25603,12 @@ declare abstract class RuntimeTemplate {
 	 */
 	getBuiltinModule(request: string, access?: string): string;
 
+	/**
+	 * Renders a `then` callback calling `fn` with `args`. An arrow keeps the `this`
+	 * a method call gives; the bound form is shorter without arrows.
+	 */
+	deferredCall(fn: string, args: string): string;
+
 	/**
 	 * Renders an object-literal method, using method shorthand when supported
 	 * and falling back to a `prop: function/arrow` property otherwise.
@@ -24458,6 +26067,70 @@ declare abstract class RuntimeTemplate {
 		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.
+	 */
+	chunkRootOutputDir(chunk: Chunk, enforceRelative: boolean): string;
+
+	/**
+	 * Static `new URL(<file>, import.meta.url)` for every stylesheet a runtime can load,
+	 * keyed by chunk id, or `null` when any of them has 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.
+	 */
+	analyzableCssChunkUrls(
+		runtimeChunk: Chunk,
+		chunkGraph: ChunkGraph,
+		runtimeRequirements: ReadonlySet<string>,
+		consumingModule?: Module
+	): 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, or `null` when any of them has 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(
+		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
+	 * module. Only called when `supportsAnalyzable("wasm")` holds.
+	 */
+	getAnalyzableWasmUrl(
+		module: Module,
+		chunkGraph: ChunkGraph,
+		runtime: RuntimeSpec,
+		runtimeRequirements: Set<string>
+	): string;
+
 	/**
 	 * Async module factory.
 	 */
@@ -24478,6 +26151,10 @@ declare abstract class RuntimeTemplate {
 		 * request string used originally
 		 */
 		request?: string;
+		/**
+		 * the module the factory is emitted into
+		 */
+		originModule?: Module;
 	}): string;
 
 	/**
@@ -24542,32 +26219,28 @@ declare interface RuntimeValueOptions {
 	buildDependencies?: string[];
 	version?: string | (() => string);
 }
-declare interface Scope {
-	type:
-		| "function"
-		| "module"
-		| "global"
-		| "block"
-		| "catch"
-		| "class"
-		| "class-field-initializer"
-		| "class-static-block"
-		| "for"
-		| "function-expression-name"
-		| "switch"
-		| "with"
-		| "TDZ";
-	isStrict: boolean;
+
+/**
+ * A lexical scope. One shape for every kind, so the property loads in the
+ * resolution loop stay monomorphic.
+ */
+declare abstract class Scope {
+	type: ScopeType;
+	block: NodeEstreeIndex;
 	upper: null | Scope;
 	childScopes: Scope[];
-	variableScope: Scope;
-	block: NodeEstreeIndex;
 	variables: Variable[];
-	set: Map<string, Variable>;
-	references: Reference[];
-	through: Reference[];
-	functionExpressionScope: boolean;
-	implicit?: { variables: Variable[]; set: Map<string, Variable> };
+	variableScope: Scope;
+
+	/**
+	 * For a function scope with parameters, the offset where its body
+	 * starts; `-1` for every other scope. Separates the two regions that
+	 * share this scope, so a reference in the parameter list can be kept
+	 * from resolving to a binding declared in the body — see
+	 * `isHiddenBodyBinding`.
+	 */
+	paramBoundary: number;
+	getBinding(name: string): undefined | Variable;
 }
 
 /**
@@ -24585,6 +26258,19 @@ declare interface ScopeInfo {
 	isAsmJs: boolean;
 	terminated?: 1 | 2;
 }
+type ScopeType =
+	| "function"
+	| "module"
+	| "global"
+	| "function-expression-name"
+	| "block"
+	| "switch"
+	| "catch"
+	| "with"
+	| "for"
+	| "class"
+	| "class-field-initializer"
+	| "class-static-block";
 declare interface Selector<A, B> {
 	(input: A): undefined | null | B;
 }
@@ -24638,9 +26324,7 @@ declare abstract class SerializerMiddleware<
 		context: Context
 	): DeserializedType | Promise<DeserializedType>;
 }
-type ServerLazyCompilationBackend =
-	| ServerImportHttp<typeof IncomingMessage>
-	| ServerImportHttps<typeof IncomingMessage>;
+type ServerLazyCompilationBackend = ServerImportHttp | ServerImportHttps;
 declare interface SetIterator<T> extends IteratorObject<T, undefined> {
 	[Symbol.iterator](): SetIterator<T>;
 	[Symbol.dispose](): void;
@@ -24750,10 +26434,31 @@ declare class SideEffectsFlagPlugin {
 	): undefined | boolean;
 }
 type SideEffectsFlagValue = undefined | string | boolean | string[];
+type SimpleBlock = NodeSyntax & {
+	token: SimpleBlockToken;
+	value: ComponentValue[];
+};
+type SimpleBlockToken = "[" | "(" | "{";
 type SimpleType = "string" | "number" | "boolean";
 declare class SizeOnlySource extends Source {
 	constructor(size: number);
 }
+declare interface SkipOptions {
+	/**
+	 * component-value node types to drop from declaration value / function-arg lists (indexed by `NodeType`, 1 = skip; build with `buildSkipSet`)
+	 */
+	types?: Uint8Array;
+
+	/**
+	 * drop qualified-rule (selector) preludes — the rule and its block are still produced (default false)
+	 */
+	selectorPrelude?: boolean;
+
+	/**
+	 * drop at-rule preludes — the at-rule and its block are still produced (default false)
+	 */
+	atRulePrelude?: boolean;
+}
 declare abstract class Snapshot {
 	startTime?: number;
 	fileTimestamps?: Map<string, null | FileSystemInfoEntry>;
@@ -24864,12 +26569,12 @@ declare abstract class Snapshot {
 	/**
 	 * Serializes this instance into the provided serializer context.
 	 */
-	serialize(__0: ObjectSerializerContextObjectMiddlewareObject_5): void;
+	serialize(__0: ObjectSerializerContextObjectMiddlewareObject_3): void;
 
 	/**
 	 * Restores this instance from the provided deserializer context.
 	 */
-	deserialize(__0: ObjectDeserializerContextObjectMiddlewareObject_4): void;
+	deserialize(__0: ObjectDeserializerContextObjectMiddlewareObject_2): void;
 
 	/**
 	 * Gets file iterable.
@@ -25144,6 +26849,14 @@ declare interface SourceLike {
 	 */
 	clearCache?: (options?: ClearCacheOptions, visited?: WeakSet<Source>) => void;
 }
+declare interface SourceMap {
+	version: 3;
+	file: string;
+	sources: string[];
+	sourcesContent?: string[];
+	names: string[];
+	mappings: string;
+}
 declare class SourceMapDevToolPlugin {
 	/**
 	 * Creates an instance of SourceMapDevToolPlugin.
@@ -25180,7 +26893,7 @@ declare interface SourceMapDevToolPluginOptions {
 	/**
 	 * Exclude modules that match the given value from source map generation.
 	 */
-	exclude?: string | RegExp | ((str: string) => boolean) | Rule[];
+	exclude?: string | RegExp | ((str: string) => boolean) | RuleAlias[];
 
 	/**
 	 * Generator string or function to create identifiers of modules for the 'sources' array in the SourceMap used only if 'moduleFilenameTemplate' would result in a conflict.
@@ -25201,12 +26914,12 @@ declare interface SourceMapDevToolPluginOptions {
 	/**
 	 * Decide whether to ignore source files that match the specified value in the SourceMap.
 	 */
-	ignoreList?: string | RegExp | ((str: string) => boolean) | Rule[];
+	ignoreList?: string | RegExp | ((str: string) => boolean) | RuleAlias[];
 
 	/**
 	 * Include source maps for module paths that match the given value.
 	 */
-	include?: string | RegExp | ((str: string) => boolean) | Rule[];
+	include?: string | RegExp | ((str: string) => boolean) | RuleAlias[];
 
 	/**
 	 * Indicates whether SourceMaps from loaders should be used (defaults to true).
@@ -25242,7 +26955,11 @@ declare interface SourceMapDevToolPluginOptions {
 	/**
 	 * Include source maps for modules based on their extension (defaults to .js and .css).
 	 */
-	test?: string | RegExp | ((str: string) => boolean) | Rule[];
+	test?: string | RegExp | ((str: string) => boolean) | RuleAlias[];
+}
+declare interface SourceMapOptions {
+	source: string;
+	content?: string;
 }
 declare class SourceMapSource extends Source {
 	constructor(
@@ -25284,6 +27001,232 @@ declare interface SourcePosition {
 	line: number;
 	column?: number;
 }
+
+/**
+ * Visitor coordinator: owns the visitor registry and drives a language
+ * `grammar` over the source. Language-agnostic — each syntax (CSS, HTML, …)
+ * binds its own grammar, node-type enum and (optionally) node printer.
+ * Babel-style usage:
+ * ```
+ * processor.use({ [NodeType.X]: (path) => {}, [NodeType.Y]: { enter, exit } });
+ * processor.process(source);
+ * ```
+ */
+declare abstract class SourceProcessorClass<
+	TPath,
+	TNode,
+	TProcessOptions = object,
+	TPrintOptions = object
+> {
+	/**
+	 * Register a Babel-style visitor map; calls accumulate per node type.
+	 * A bucket is a function (= `{ enter }`) or `{ enter?, exit? }`.
+	 */
+	use(
+		map: VisitorMap<TPath>
+	): SourceProcessorClass<TPath, TNode, TProcessOptions, TPrintOptions>;
+
+	/**
+	 * Parse `input` once and fire the visitors in source order. Asking for output
+	 * — `mode`, the one thing that names it — makes the same walk print, given a
+	 * printer supplied at construction: a
+	 * {@link PrintContext} is created, each node's printer fires into it as the node
+	 * finishes, and the result is returned as `{ code, map }`: the serialized output
+	 * and, for a caller that named its input with `source` / `content`, the
+	 * input->output source map — `map` is `undefined` without one. Asking for
+	 * none of it only walks and returns `undefined`. A single parse — printing
+	 * never re-parses; all configuration is per-call.
+	 */
+	process(
+		input: string,
+		options: TProcessOptions & { mode: "minify" | "beautify" } & {
+			source: string;
+			content?: string;
+		}
+	): { code: string; map: SourceMap };
+	process(
+		input: string,
+		options: TProcessOptions & { mode: "minify" | "beautify" }
+	): { code: string; map: undefined };
+	process(input: string, options?: TProcessOptions): undefined;
+
+	/**
+	 * {@link process}, for a caller whose renderer answers asynchronously. Code
+	 * generation is synchronous — a printer returns its node's text, it cannot
+	 * await one — so the walk leaves a marker where each answer goes, they are
+	 * asked for together, and {@link PrintContext.substitute} stands each in its
+	 * place before the output and its map are built. One parse either way, and
+	 * the async boundary stays at the top rather than on every node.
+	 * This is the shape `process` itself takes once it is async: how the answers
+	 * are waited for is this method's business, so nothing above it changes.
+	 */
+	processAsync(
+		input: string,
+		options: Omit<TProcessOptions, "renderEmbeddedSource"> & {
+			mode: "minify" | "beautify";
+		} & {
+			source?: string;
+			content?: string;
+			renderEmbeddedSource?: (
+				source: string,
+				hole?: any
+			) => undefined | string | Promise<undefined | string>;
+		}
+	): Promise<{ code: string; map?: SourceMap }>;
+}
+
+/**
+ * The generic visitor coordinator (`util/SourceProcessor`) bound to the HTML
+ * `grammar`. Babel-style usage:
+ * ```
+ * new SourceProcessor().use({ [NodeType.Element]: (path) => {}, [NodeType.Comment]: { enter, exit } }).process(source, { skip });
+ * ```
+ * @experimental exposed as `webpack.html.syntax.SourceProcessor`; unstable API
+ */
+declare class SourceProcessorSyntaxClass_1 extends SourceProcessorClass<
+	{
+		get node(): number;
+		get parent(): null | number;
+		/**
+		 * Stop the walk descending into the current node (enter only).
+		 */
+		skipChildren(): void;
+		type(n?: number): number;
+		start(n?: number): number;
+		end(n?: number): number;
+		/**
+		 * Raw source slice `[start, end)` — valid only during the walk (the printer's
+		 * window), before `parseHtml` releases `_htmlSource`.
+		 */
+		source(n?: number): string;
+		sourceSpanAt(from: number, to: number): string;
+		tagName(n?: number): string;
+		namespace(n?: number): number;
+		selfClosing(n?: number): boolean;
+		attributes(n?: number): HtmlAttribute[];
+		attributeCount(n?: number): number;
+		/**
+		 * The i-th attribute of an element, as an id for the `attribute*` reads.
+		 */
+		attributeAt(i: number, n?: number): number;
+		/**
+		 * Linear lookup by (lowercased) name.
+		 */
+		findAttribute(name: string, n?: number): number;
+		attributeName(a: number): string;
+		attributeValue(a: number): string;
+		attributeNameStart(a: number): number;
+		attributeNameEnd(a: number): number;
+		attributeValueStart(a: number): number;
+		attributeValueEnd(a: number): number;
+		tagEnd(n?: number): number;
+		nameEnd(n?: number): number;
+		/**
+		 * Whether the source wrote this element's end tag rather than the parser
+		 * popping it for an implied close. Read back off the range instead of marked
+		 * during the parse: an element's end spans the token that closed it, so its
+		 * own end tag is the last thing in it — and only the few elements around a
+		 * region printed from source ever ask.
+		 */
+		sourceClosed(n?: number): boolean;
+		openTag(n?: number): string;
+		/**
+		 * An element's end tag, generated as `</name>` from the opening tag's own name
+		 * (exact source casing, correct for foreign camelCase elements). Generated, not
+		 * sliced: element `end` offsets don't span the end tag, and an omitted optional
+		 * end tag (`<li>`, `<p>`, …) still serializes to the same DOM. `""` when the
+		 * parser inserted the element, as {@link openTag } does — it has no name in the
+		 * source to echo, and slicing one would spell `</>`.
+		 */
+		closeTag(n?: number): string;
+		contentEnd(n?: number): number;
+		templateContent(n?: number): number;
+		data(n?: number): string;
+		piTarget(n?: number): string;
+		doctypeName(n?: number): string;
+		doctypePublicId(_n?: number): null | string;
+		doctypeSystemId(_n?: number): null | string;
+		firstChild(n?: number): number;
+		nextSibling(n?: number): number;
+		parentOf(n?: number): number;
+		children(n?: number): number[];
+	},
+	number,
+	HtmlProcessOptions
+> {
+	constructor();
+	static PrintContext: typeof PrintContext;
+	static deferredWrite: (id: number) => string;
+}
+
+/**
+ * The generic visitor coordinator (`util/SourceProcessor`) bound to the CSS
+ * `grammar`. All configuration is per `process` call. `process(src, { minimize:
+ * true })` returns `{ code, map }` — the safely-minified serialization (built by
+ * the same walk that fires visitors) and its source map; without `minimize` it
+ * just walks and returns `undefined`. Babel-style usage:
+ * ```
+ * new SourceProcessor().use({ [NodeType.AtRule]: (path) => {} }).process(source, { skip });
+ * ```
+ * @experimental exposed as `webpack.css.syntax.SourceProcessor`; unstable API
+ */
+declare class SourceProcessorSyntaxClass_2 extends SourceProcessorClass<
+	{
+		get node(): NodeSyntax;
+		get parent(): null | NodeSyntax;
+		get index(): number;
+		/**
+		 * Stop the walk descending into the current node (enter only).
+		 */
+		skipChildren(): void;
+		inValue(): boolean;
+		type(n?: NodeSyntax): number;
+		start(n?: NodeSyntax): number;
+		end(n?: NodeSyntax): number;
+		range(n?: NodeSyntax): [number, number];
+		loc(n?: NodeSyntax): {
+			start: { line: number; column: number };
+			end: { line: number; column: number };
+		};
+		source(n?: NodeSyntax): string;
+		value(n?: NodeSyntax): string;
+		unescaped(n?: NodeSyntax): string;
+		typeFlag(n?: NodeSyntax): string;
+		contentStart(n?: NodeSyntax): number;
+		contentEnd(n?: NodeSyntax): number;
+		name(n?: NodeSyntax): string;
+		nameStart(n?: NodeSyntax): number;
+		nameEnd(n?: NodeSyntax): number;
+		unescapedName(n?: NodeSyntax): string;
+		children(n?: NodeSyntax): ComponentValue[];
+		prelude(n?: NodeSyntax): ComponentValue[];
+		childCount(n?: NodeSyntax): number;
+		childAt(n: NodeSyntax, i: number): ComponentValue;
+		/**
+		 * A block big enough to stream hands its children to the visitors as each one
+		 * finishes rather than collecting them, so both lists read as an empty block
+		 * on it — `null`, which means no block at all, is still only for the `@…;`
+		 * forms. Read a block's children from the walk, not from here.
+		 */
+		declarations(n?: NodeSyntax): null | DeclarationSyntax[];
+		/**
+		 * Reads as an empty block on a streamed rule; see {@link declarations }.
+		 */
+		childRules(n?: NodeSyntax): null | RuleSyntax[];
+		blockStart(n?: NodeSyntax): number;
+		blockEnd(n?: NodeSyntax): number;
+		important(n?: NodeSyntax): boolean;
+		blockToken(n?: NodeSyntax): SimpleBlockToken;
+		setEnd(n: NodeSyntax, v: number): void;
+		setBlockEnd(n: NodeSyntax, v: number): void;
+	},
+	NodeSyntax,
+	CssProcessOptions
+> {
+	constructor();
+	static PrintContext: typeof PrintContext;
+	static deferredWrite: (id: number) => string;
+}
 declare interface SourceTable {
 	[index: string]: SourceBucket;
 }
@@ -25354,6 +27297,9 @@ declare class SplitChunksPlugin {
 	 * Applies the plugin by registering its hooks on the compiler.
 	 */
 	apply(compiler: Compiler): void;
+	static getCappedSplits: (
+		compilation: Compilation
+	) => undefined | CappedSplit[];
 }
 declare interface SplitChunksSizes {
 	[index: string]: number;
@@ -25509,7 +27455,7 @@ declare abstract class StackedMap<K, V> {
  */
 declare interface StarListDeserializerContext {
 	read: () => HarmonyExportImportedSpecifierDependency[];
-	rest: ObjectDeserializerContextObjectMiddlewareObject_3<[]>;
+	rest: ObjectDeserializerContextObjectMiddlewareObject_2<[]>;
 	setCircularReference: (value: ReferenceableItem) => void;
 }
 
@@ -25519,7 +27465,7 @@ declare interface StarListDeserializerContext {
 declare interface StarListSerializerContext {
 	write: (
 		value: HarmonyExportImportedSpecifierDependency[]
-	) => ObjectSerializerContextObjectMiddlewareObject_4<[]>;
+	) => ObjectSerializerContextObjectMiddlewareObject_3<[]>;
 	setCircularReference: (value: ReferenceableItem) => void;
 	snapshot: () => ObjectSerializerSnapshot;
 	rollback: (snapshot: ObjectSerializerSnapshot) => void;
@@ -26210,6 +28156,18 @@ declare interface StatsOptions {
 	 */
 	hash?: boolean;
 
+	/**
+	 * Add performance hints reported with 'performance.hints: "stats"'.
+	 * @since 5.110.0
+	 */
+	hints?: boolean;
+
+	/**
+	 * Add the number of performance hints.
+	 * @since 5.110.0
+	 */
+	hintsCount?: boolean;
+
 	/**
 	 * Add ids.
 	 */
@@ -26457,6 +28415,7 @@ declare interface StreamOptions {
 declare interface Stringable {
 	toString: () => string;
 }
+type Stylesheet = NodeSyntax & { rules: RuleSyntax[] };
 type Supports = undefined | string;
 declare class SyncModuleIdsPlugin {
 	/**
@@ -26621,6 +28580,95 @@ 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;
+};
+
+/**
+ * Position-based view over the lexer — webpack's stand-in for the spec's
+ * "normalize into a token stream" (CSS Syntax §9). It unifies the lexer and the
+ * stream in one class: the `readToken` primitive lexes one token (the CSS
+ * tokenizer), and the spec token-stream operations `next` / `consume` /
+ * `discard` / `mark` / `restoreMark` / `discardMark` drive it from a byte
+ * cursor. `parse*` entry points wrap a source string in one of these and every
+ * `consume*` algorithm reads tokens from it.
+ * No token buffer is kept: the cursor is a byte offset and the only state is
+ * the next token (lazily tokenized once and cached until consumed). The
+ * declaration-vs-qualified-rule backtracking in `consumeABlocksContents`
+ * rewinds by `mark`ing / `restoreMark`ing that byte offset, which simply
+ * re-tokenizes the rewound span — comment tokens are filtered here and fire
+ * `onComment` once each, tracked by a monotonic high-water mark so a
+ * re-tokenized span never re-fires them.
+ * `SourceProcessor` is handed this class (not an instance) and threads it to
+ * the grammar, so a different language can drive the same visitor machinery by
+ * swapping the tokenizer — the per-token `readToken` primitive — for its own.
+ */
+declare class TokenStream {
+	constructor(
+		input: string,
+		pos?: number,
+		locConverter?: LocConverter,
+		onComment?: (input: string, start: number, end: number) => number
+	);
+	input: string;
+	locConverter: LocConverter;
+
+	/**
+	 * The next token (CSS Syntax §3 "next token") — the upcoming token without
+	 * consuming it; the `<eof-token>` once the source is exhausted. This is the
+	 * token the consume algorithms dispatch on (the spec's "process"). Tokenized
+	 * from `_pos` on first use and cached until consumed; comment tokens are
+	 * skipped here, firing `onComment` once each.
+	 */
+	next(): MutableToken;
+
+	/**
+	 * Consume a token (CSS Syntax §3 "consume a token") — return the next token
+	 * and advance the cursor past it. The returned token is valid until the next
+	 * `next` re-tokenizes (the reused instance is not cleared by advancing).
+	 */
+	consume(): MutableToken;
+
+	/**
+	 * Discard a token (CSS Syntax §3 "discard a token") — advance the cursor past
+	 * the next token without returning it.
+	 */
+	discard(): void;
+
+	/**
+	 * Advance past the already-peeked next token, skipping the redundant `next()`
+	 * re-check `consume` / `discard` pay. Precondition: the caller has just called
+	 * `next()` (so `_tok` is the cached next token and `_hasNext` is true) and that
+	 * token is not the `<eof-token>` — the hot "peek, decide, advance" sites where
+	 * both always hold. Callers that can't guarantee a non-EOF cached token use
+	 * `consume` / `discard` instead.
+	 */
+	advance(): void;
+
+	/**
+	 * Mark (CSS Syntax §3 "mark") — push the current cursor position.
+	 */
+	mark(): void;
+
+	/**
+	 * Restore a mark (CSS Syntax §3 "restore a mark") — pop the last mark and
+	 * rewind the cursor to it. The rewound span is re-tokenized on the next read;
+	 * already-fired comments are not re-fired (`_commentHigh`).
+	 */
+	restoreMark(): void;
+
+	/**
+	 * Discard a mark (CSS Syntax §3 "discard a mark") — pop without rewinding.
+	 */
+	discardMark(): void;
+}
 declare class TopLevelSymbol {
 	/**
 	 * Creates an instance of TopLevelSymbol.
@@ -26829,12 +28877,15 @@ type ValueCacheVersion = string | Set<string>;
 declare interface Values {
 	[index: string]: Value[];
 }
-declare interface Variable {
+
+/**
+ * A binding: one name declared in one scope.
+ */
+declare abstract class Variable {
 	name: string;
-	scope: Scope;
 	identifiers: Identifier[];
 	references: Reference[];
-	defs: any[];
+	scope: Scope;
 }
 declare class VariableInfo {
 	/**
@@ -26947,6 +28998,14 @@ declare class VirtualUrlPlugin {
 	getCacheVersion(version: string | true | (() => string)): undefined | string;
 	static DEFAULT_SCHEME: string;
 }
+type VisitorBucket<TPath> =
+	VisitorFn<TPath> | { enter?: VisitorFn<TPath>; exit?: VisitorFn<TPath> };
+declare interface VisitorFn<TPath> {
+	(path: TPath): void;
+}
+declare interface VisitorMap<TPath> {
+	[index: number]: VisitorBucket<TPath>;
+}
 type WarningFilterItemTypes =
 	string | RegExp | ((warning: StatsError, warningString: string) => boolean);
 
@@ -27211,7 +29270,8 @@ declare abstract class WeakTupleMap<K extends any[], V> {
 	 */
 	clear(): void;
 }
-declare abstract class WebAssemblyParser extends ParserClass {}
+declare abstract class WebAssemblyParserAsyncWebAssemblyParser extends ParserClass {}
+declare abstract class WebAssemblyParserClass extends ParserClass {}
 declare interface WebAssemblyRenderContext {
 	/**
 	 * the chunk
@@ -27267,12 +29327,12 @@ declare class WebpackError extends Error {
 	/**
 	 * Serializes this instance into the provided serializer context.
 	 */
-	serialize(__0: ObjectSerializerContextObjectMiddlewareObject_5): void;
+	serialize(__0: ObjectSerializerContextObjectMiddlewareObject_3): void;
 
 	/**
 	 * Restores this instance from the provided deserializer context.
 	 */
-	deserialize(__0: ObjectDeserializerContextObjectMiddlewareObject_4): void;
+	deserialize(__0: ObjectDeserializerContextObjectMiddlewareObject_2): void;
 
 	/**
 	 * Creates a `.stack` property on `targetObject`, which when accessed returns
@@ -27744,6 +29804,7 @@ declare interface WebpackRequire {
 	(id: string): any;
 	i?: ((options: ExecuteOptions) => void)[];
 	c?: Record<string, ExecuteModuleObject>;
+	p?: string;
 }
 declare interface WithId {
 	id: string | number;
@@ -27792,6 +29853,31 @@ type WriteStreamOptions = StreamOptions & {
 	fs?: null | CreateWriteStreamFSImplementation;
 	flush?: boolean;
 };
+declare interface _functionSyntax {
+	/**
+	 * Decode HTML character references in a string. Handles all numeric
+	 * references (with WHATWG remap of 0x00, surrogates, out-of-range, and the
+	 * C1 Windows-1252 table) and the full WHATWG named character references
+	 * table. Unknown or malformed references are left as literal text.
+	 * When `isAttribute` is `true`, applies the WHATWG
+	 * "consumed-as-part-of-an-attribute" rule: a named reference without a
+	 * trailing `;` whose next character is `=` or ASCII alphanumeric is left
+	 * undecoded, so e.g. `&amp=foo` stays literal in an attribute value but
+	 * decodes to `&=foo` in text.
+	 * With `withMap` the result also carries a boundary map from the decoded
+	 * string back to raw offsets, so spans computed on the decoded text (e.g.
+	 * srcset candidate URLs) can be translated to source ranges. `map[i]` is the
+	 * raw offset of decoded boundary `i` (`0..text.length`); boundaries inside a
+	 * reference's decoded text map to the reference start. `map` is `undefined`
+	 * when nothing was decoded (then `text === str`).
+	 */
+	(str: string, isAttribute?: boolean): string;
+	(
+		str: string,
+		isAttribute: undefined | boolean,
+		withMap: true
+	): DecodedEntitiesWithMap;
+}
 
 /**
  * Returns compiler or MultiCompiler.
@@ -27923,6 +30009,8 @@ declare namespace exports {
 		) => null | Problem[];
 	}
 	export namespace ModuleFilenameHelpers {
+		export let DEFAULT_MODULE_FILENAME_TEMPLATE: string;
+		export let DEFAULT_FALLBACK_MODULE_FILENAME_TEMPLATE: string;
 		export let ALL_LOADERS_RESOURCE: string;
 		export let REGEXP_ALL_LOADERS_RESOURCE: RegExp;
 		export let LOADERS_RESOURCE: string;
@@ -27986,9 +30074,10 @@ declare namespace exports {
 		export let baseURI: "__webpack_require__.b";
 		export let chunkCallback: "webpackChunk";
 		export let chunkName: "__webpack_require__.cn";
-		export let commonJsWrap: "__webpack_require__.cjs";
 		export let compatGetDefaultExport: "__webpack_require__.n";
 		export let compileWasm: "__webpack_require__.vs";
+		export let concatenationWrap: "__webpack_require__.cw";
+		export let constructRequire: "__webpack_require__.cr";
 		export let createFakeNamespaceObject: "__webpack_require__.t";
 		export let createScript: "__webpack_require__.ts";
 		export let createScriptUrl: "__webpack_require__.tu";
@@ -27997,11 +30086,11 @@ declare namespace exports {
 		export let deferredModuleAsyncTransitiveDependencies: "__webpack_require__.zT";
 		export let deferredModuleAsyncTransitiveDependenciesSymbol: "__webpack_require__.zS";
 		export let definePropertyGetters: "__webpack_require__.d";
+		export let definePropertyGettersFromArray: "__webpack_require__.d (array)";
 		export let ensureChunk: "__webpack_require__.e";
 		export let ensureChunkHandlers: "__webpack_require__.f";
 		export let ensureChunkIncludeEntries: "__webpack_require__.f (include entries)";
 		export let entryModuleId: "__webpack_require__.s";
-		export let esmId: "__webpack_esm_id__";
 		export let esmIds: "__webpack_esm_ids__";
 		export let esmModules: "__webpack_esm_modules__";
 		export let esmRuntime: "__webpack_esm_runtime__";
@@ -28011,6 +30100,7 @@ declare namespace exports {
 		export let getChunkScriptFilename: "__webpack_require__.u";
 		export let getChunkUpdateCssFilename: "__webpack_require__.hk";
 		export let getChunkUpdateScriptFilename: "__webpack_require__.hu";
+		export let getCssServerStyles: "__webpack_require__.cs";
 		export let getFullHash: "__webpack_require__.h";
 		export let getTrustedTypesPolicy: "__webpack_require__.tt";
 		export let getUpdateManifestFilename: "__webpack_require__.hmrF";
@@ -28184,9 +30274,607 @@ declare namespace exports {
 		export { AsyncWebAssemblyModulesPlugin, EnableWasmLoadingPlugin };
 	}
 	export namespace css {
+		export namespace syntax {
+			export let A: {
+				get node(): NodeSyntax;
+				get parent(): null | NodeSyntax;
+				get index(): number;
+				/**
+				 * Stop the walk descending into the current node (enter only).
+				 */
+				skipChildren(): void;
+				inValue(): boolean;
+				type(n?: NodeSyntax): number;
+				start(n?: NodeSyntax): number;
+				end(n?: NodeSyntax): number;
+				range(n?: NodeSyntax): [number, number];
+				loc(n?: NodeSyntax): {
+					start: { line: number; column: number };
+					end: { line: number; column: number };
+				};
+				source(n?: NodeSyntax): string;
+				value(n?: NodeSyntax): string;
+				unescaped(n?: NodeSyntax): string;
+				typeFlag(n?: NodeSyntax): string;
+				contentStart(n?: NodeSyntax): number;
+				contentEnd(n?: NodeSyntax): number;
+				name(n?: NodeSyntax): string;
+				nameStart(n?: NodeSyntax): number;
+				nameEnd(n?: NodeSyntax): number;
+				unescapedName(n?: NodeSyntax): string;
+				children(n?: NodeSyntax): ComponentValue[];
+				prelude(n?: NodeSyntax): ComponentValue[];
+				childCount(n?: NodeSyntax): number;
+				childAt(n: NodeSyntax, i: number): ComponentValue;
+				/**
+				 * A block big enough to stream hands its children to the visitors as each one
+				 * finishes rather than collecting them, so both lists read as an empty block
+				 * on it — `null`, which means no block at all, is still only for the `@…;`
+				 * forms. Read a block's children from the walk, not from here.
+				 */
+				declarations(n?: NodeSyntax): null | DeclarationSyntax[];
+				/**
+				 * Reads as an empty block on a streamed rule; see {@link declarations }.
+				 */
+				childRules(n?: NodeSyntax): null | RuleSyntax[];
+				blockStart(n?: NodeSyntax): number;
+				blockEnd(n?: NodeSyntax): number;
+				important(n?: NodeSyntax): boolean;
+				blockToken(n?: NodeSyntax): SimpleBlockToken;
+				setEnd(n: NodeSyntax, v: number): void;
+				setBlockEnd(n: NodeSyntax, v: number): void;
+			};
+			export let EMBEDDED_LANGUAGES: string[];
+			export namespace NodeType {
+				export let Ident: number;
+				export let Function: number;
+				export let AtKeyword: number;
+				export let Hash: number;
+				export let String: number;
+				export let BadString: number;
+				export let Url: number;
+				export let BadUrl: number;
+				export let Delim: number;
+				export let Number: number;
+				export let Percentage: number;
+				export let Dimension: number;
+				export let Whitespace: number;
+				export let Colon: number;
+				export let Semicolon: number;
+				export let Comma: number;
+				export let RightParenthesis: number;
+				export let RightSquareBracket: number;
+				export let RightCurlyBracket: number;
+				export let CDO: number;
+				export let CDC: number;
+				export let SimpleBlock: number;
+				export let Declaration: number;
+				export let AtRule: number;
+				export let QualifiedRule: number;
+				export let Stylesheet: number;
+				export let Comment: number;
+				export let Raw: number;
+			}
+			export let TT_AT_KEYWORD: 16;
+			export let TT_BAD_STRING_TOKEN: 4;
+			export let TT_BAD_URL_TOKEN: 19;
+			export let TT_CDC: 25;
+			export let TT_CDO: 24;
+			export let TT_COLON: 14;
+			export let TT_COMMA: 13;
+			export let TT_COMMENT: 1;
+			export let TT_DELIM: 6;
+			export let TT_DIMENSION: 23;
+			export let TT_EOF: 26;
+			export let TT_FUNCTION: 17;
+			export let TT_HASH: 5;
+			export let TT_IDENTIFIER: 20;
+			export let TT_LEFT_CURLY_BRACKET: 9;
+			export let TT_LEFT_PARENTHESIS: 7;
+			export let TT_LEFT_SQUARE_BRACKET: 8;
+			export let TT_NUMBER: 21;
+			export let TT_PERCENTAGE: 22;
+			export let TT_RIGHT_CURLY_BRACKET: 12;
+			export let TT_RIGHT_PARENTHESIS: 10;
+			export let TT_RIGHT_SQUARE_BRACKET: 11;
+			export let TT_SEMICOLON: 15;
+			export let TT_STRING: 3;
+			export let TT_URL: 18;
+			export let TT_WHITESPACE: 2;
+			export let askEmbeddedRenderer: (
+				render: (
+					source: string,
+					info: { type: string; hostType: string; as?: string }
+				) =>
+					| undefined
+					| string
+					| EmbeddedSourceResult
+					| Promise<undefined | string | EmbeddedSourceResult>,
+				hole: { source: string; type: string; hostType: string; as?: string },
+				reported: EmbeddedSourceResult[]
+			) => Promise<undefined | string | EmbeddedSourceResult>;
+			export let buildSkipSet: (nodeTypes: number[]) => Uint8Array;
+			export let collectEmbeddedDiagnostics: (
+				reported: {
+					warnings?: (string | Error)[];
+					errors?: (string | Error)[];
+				}[]
+			) => { warnings?: (string | Error)[]; errors?: (string | Error)[] };
+			export let embeddedText: (
+				answer?: string | { code?: string }
+			) => undefined | string;
+			export let equalsLowerCase: (s: string, lit: string) => boolean;
+			export let escapeIdentifier: MakeCacheableResult<string> & {
+				bindCache: BindCache<string>;
+			};
+			export let isDashedIdentifier: (identifier: string) => boolean;
+			export let isWhitespace: (cc: number) => boolean;
+			export let normalizeUrl: (str: string, isString: boolean) => string;
+			export let parseABlocksContents: (
+				input: string | TokenStream,
+				pos?: number,
+				options?: ParseOptionsSyntax
+			) => { decls: DeclarationSyntax[]; rules: RuleSyntax[] };
+			export let parseACommaSeparatedListOfComponentValues: (
+				input: string | TokenStream,
+				pos?: number,
+				options?: ParseOptionsSyntax
+			) => ComponentValue[][];
+			export let parseAComponentValue: (
+				input: string | TokenStream,
+				pos?: number,
+				options?: ParseOptionsSyntax
+			) => undefined | Token | FunctionNode | SimpleBlock;
+			export let parseADeclaration: (
+				input: string | TokenStream,
+				pos?: number,
+				options?: ParseOptionsSyntax
+			) => undefined | DeclarationSyntax;
+			export let parseAListOfComponentValues: (
+				input: string | TokenStream,
+				pos?: number,
+				options?: ParseOptionsSyntax
+			) => ComponentValue[];
+			export let parseARule: (
+				input: string | TokenStream,
+				pos?: number,
+				options?: ParseOptionsSyntax
+			) => undefined | AtRule | QualifiedRule;
+			export let parseAStylesheet: (
+				input: string | TokenStream,
+				pos?: number,
+				options?: ParseOptionsSyntax
+			) => Stylesheet;
+			export let parseAStylesheetsContents: (
+				input: string | TokenStream,
+				pos?: number,
+				options?: ParseOptionsSyntax
+			) => RuleSyntax[];
+			export let pickTransforms: (
+				options: object
+			) => undefined | CssTransformOptions;
+			export let printer: (
+				path: {
+					get node(): NodeSyntax;
+					get parent(): null | NodeSyntax;
+					get index(): number;
+					/**
+					 * Stop the walk descending into the current node (enter only).
+					 */
+					skipChildren(): void;
+					inValue(): boolean;
+					type(n?: NodeSyntax): number;
+					start(n?: NodeSyntax): number;
+					end(n?: NodeSyntax): number;
+					range(n?: NodeSyntax): [number, number];
+					loc(n?: NodeSyntax): {
+						start: { line: number; column: number };
+						end: { line: number; column: number };
+					};
+					source(n?: NodeSyntax): string;
+					value(n?: NodeSyntax): string;
+					unescaped(n?: NodeSyntax): string;
+					typeFlag(n?: NodeSyntax): string;
+					contentStart(n?: NodeSyntax): number;
+					contentEnd(n?: NodeSyntax): number;
+					name(n?: NodeSyntax): string;
+					nameStart(n?: NodeSyntax): number;
+					nameEnd(n?: NodeSyntax): number;
+					unescapedName(n?: NodeSyntax): string;
+					children(n?: NodeSyntax): ComponentValue[];
+					prelude(n?: NodeSyntax): ComponentValue[];
+					childCount(n?: NodeSyntax): number;
+					childAt(n: NodeSyntax, i: number): ComponentValue;
+					/**
+					 * A block big enough to stream hands its children to the visitors as each one
+					 * finishes rather than collecting them, so both lists read as an empty block
+					 * on it — `null`, which means no block at all, is still only for the `@…;`
+					 * forms. Read a block's children from the walk, not from here.
+					 */
+					declarations(n?: NodeSyntax): null | DeclarationSyntax[];
+					/**
+					 * Reads as an empty block on a streamed rule; see {@link declarations }.
+					 */
+					childRules(n?: NodeSyntax): null | RuleSyntax[];
+					blockStart(n?: NodeSyntax): number;
+					blockEnd(n?: NodeSyntax): number;
+					important(n?: NodeSyntax): boolean;
+					blockToken(n?: NodeSyntax): SimpleBlockToken;
+					setEnd(n: NodeSyntax, v: number): void;
+					setBlockEnd(n: NodeSyntax, v: number): void;
+				},
+				writer: PrintContext<
+					{
+						get node(): NodeSyntax;
+						get parent(): null | NodeSyntax;
+						get index(): number;
+						/**
+						 * Stop the walk descending into the current node (enter only).
+						 */
+						skipChildren(): void;
+						inValue(): boolean;
+						type(n?: NodeSyntax): number;
+						start(n?: NodeSyntax): number;
+						end(n?: NodeSyntax): number;
+						range(n?: NodeSyntax): [number, number];
+						loc(n?: NodeSyntax): {
+							start: { line: number; column: number };
+							end: { line: number; column: number };
+						};
+						source(n?: NodeSyntax): string;
+						value(n?: NodeSyntax): string;
+						unescaped(n?: NodeSyntax): string;
+						typeFlag(n?: NodeSyntax): string;
+						contentStart(n?: NodeSyntax): number;
+						contentEnd(n?: NodeSyntax): number;
+						name(n?: NodeSyntax): string;
+						nameStart(n?: NodeSyntax): number;
+						nameEnd(n?: NodeSyntax): number;
+						unescapedName(n?: NodeSyntax): string;
+						children(n?: NodeSyntax): ComponentValue[];
+						prelude(n?: NodeSyntax): ComponentValue[];
+						childCount(n?: NodeSyntax): number;
+						childAt(n: NodeSyntax, i: number): ComponentValue;
+						/**
+						 * A block big enough to stream hands its children to the visitors as each one
+						 * finishes rather than collecting them, so both lists read as an empty block
+						 * on it — `null`, which means no block at all, is still only for the `@…;`
+						 * forms. Read a block's children from the walk, not from here.
+						 */
+						declarations(n?: NodeSyntax): null | DeclarationSyntax[];
+						/**
+						 * Reads as an empty block on a streamed rule; see {@link declarations }.
+						 */
+						childRules(n?: NodeSyntax): null | RuleSyntax[];
+						blockStart(n?: NodeSyntax): number;
+						blockEnd(n?: NodeSyntax): number;
+						important(n?: NodeSyntax): boolean;
+						blockToken(n?: NodeSyntax): SimpleBlockToken;
+						setEnd(n: NodeSyntax, v: number): void;
+						setBlockEnd(n: NodeSyntax, v: number): void;
+					},
+					NodeSyntax,
+					CssPrintOptions
+				>
+			) => string;
+			export let rangeEquals: (
+				input: string,
+				start: number,
+				end: number,
+				lit: string
+			) => boolean;
+			export let rangeEqualsLowerCase: (
+				input: string,
+				start: number,
+				end: number,
+				lit: string
+			) => boolean;
+			export let readToken: (
+				input: string,
+				pos: number,
+				out: MutableToken
+			) => undefined | MutableToken;
+			export let skipEscape: (input: string, pos: number) => number;
+			export let toLowerCaseIfNeeded: (s: string) => string;
+			export let unescapeIdentifier: MakeCacheableResult<string> & {
+				bindCache: BindCache<string>;
+			};
+			export { SourceProcessorSyntaxClass_2 as SourceProcessor, TokenStream };
+		}
 		export { CssModulesPlugin };
 	}
 	export namespace html {
+		export namespace syntax {
+			export let A: {
+				get node(): number;
+				get parent(): null | number;
+				/**
+				 * Stop the walk descending into the current node (enter only).
+				 */
+				skipChildren(): void;
+				type(n?: number): number;
+				start(n?: number): number;
+				end(n?: number): number;
+				/**
+				 * Raw source slice `[start, end)` — valid only during the walk (the printer's
+				 * window), before `parseHtml` releases `_htmlSource`.
+				 */
+				source(n?: number): string;
+				sourceSpanAt(from: number, to: number): string;
+				tagName(n?: number): string;
+				namespace(n?: number): number;
+				selfClosing(n?: number): boolean;
+				attributes(n?: number): HtmlAttribute[];
+				attributeCount(n?: number): number;
+				/**
+				 * The i-th attribute of an element, as an id for the `attribute*` reads.
+				 */
+				attributeAt(i: number, n?: number): number;
+				/**
+				 * Linear lookup by (lowercased) name.
+				 */
+				findAttribute(name: string, n?: number): number;
+				attributeName(a: number): string;
+				attributeValue(a: number): string;
+				attributeNameStart(a: number): number;
+				attributeNameEnd(a: number): number;
+				attributeValueStart(a: number): number;
+				attributeValueEnd(a: number): number;
+				tagEnd(n?: number): number;
+				nameEnd(n?: number): number;
+				/**
+				 * Whether the source wrote this element's end tag rather than the parser
+				 * popping it for an implied close. Read back off the range instead of marked
+				 * during the parse: an element's end spans the token that closed it, so its
+				 * own end tag is the last thing in it — and only the few elements around a
+				 * region printed from source ever ask.
+				 */
+				sourceClosed(n?: number): boolean;
+				openTag(n?: number): string;
+				/**
+				 * An element's end tag, generated as `</name>` from the opening tag's own name
+				 * (exact source casing, correct for foreign camelCase elements). Generated, not
+				 * sliced: element `end` offsets don't span the end tag, and an omitted optional
+				 * end tag (`<li>`, `<p>`, …) still serializes to the same DOM. `""` when the
+				 * parser inserted the element, as {@link openTag } does — it has no name in the
+				 * source to echo, and slicing one would spell `</>`.
+				 */
+				closeTag(n?: number): string;
+				contentEnd(n?: number): number;
+				templateContent(n?: number): number;
+				data(n?: number): string;
+				piTarget(n?: number): string;
+				doctypeName(n?: number): string;
+				doctypePublicId(_n?: number): null | string;
+				doctypeSystemId(_n?: number): null | string;
+				firstChild(n?: number): number;
+				nextSibling(n?: number): number;
+				parentOf(n?: number): number;
+				children(n?: number): number[];
+			};
+			export let EMBEDDED_LANGUAGES: string[];
+			export let NS_HTML: 0;
+			export let NS_MATHML: 1;
+			export let NS_SVG: 2;
+			export namespace NodeType {
+				export let Document: 1;
+				export let DocumentFragment: 2;
+				export let Element: 3;
+				export let Text: 4;
+				export let Comment: 5;
+				export let Doctype: 6;
+				export let ProcessingInstruction: 7;
+			}
+			export let QUOTE_DOUBLE: 1;
+			export let QUOTE_NONE: 0;
+			export let QUOTE_SINGLE: 2;
+			export let SVG_TAG_ADJUST: Record<string, string>;
+			export let askEmbeddedRenderer: (
+				render: (
+					source: string,
+					info: { type: string; hostType: string; as?: string }
+				) =>
+					| undefined
+					| string
+					| EmbeddedSourceResult
+					| Promise<undefined | string | EmbeddedSourceResult>,
+				hole: { source: string; type: string; hostType: string; as?: string },
+				reported: EmbeddedSourceResult[]
+			) => Promise<undefined | string | EmbeddedSourceResult>;
+			export let baseTag: (
+				base:
+					| string
+					| {
+							/**
+							 * Value for the `href` attribute of the `<base>` element.
+							 */
+							href: string;
+							/**
+							 * Value for the `target` attribute of the `<base>` element (e.g. `"_blank"`).
+							 */
+							target?: string;
+					  }
+			) => string;
+			export let buildHeadTags: (opts: OutputHtmlOptions) => string;
+			export let collectEmbeddedDiagnostics: (
+				reported: {
+					warnings?: (string | Error)[];
+					errors?: (string | Error)[];
+				}[]
+			) => { warnings?: (string | Error)[]; errors?: (string | Error)[] };
+			export let decodeEntities: _functionSyntax;
+			export let embeddedText: (
+				answer?: string | { code?: string }
+			) => undefined | string;
+			export let escapeAttribute: (
+				s: string,
+				delimiter?: number,
+				minimal?: boolean
+			) => string;
+			export let escapeText: (s: string) => string;
+			export let isAsciiWhitespace: (cc: number) => boolean;
+			export let metaTag: (name: string, content: string) => string;
+			export let parseCssUrls: (input: string) => [string, number, number][];
+			export let parseHtml: (
+				input: string,
+				pos?: number,
+				options?: HtmlParseOptions
+			) => number;
+			export let parseMsapplicationTask: (
+				input: string
+			) => [string, number, number][];
+			export let parseSrc: (input: string) => [string, number, number][];
+			export let parseSrcset: (input: string) => [string, number, number][];
+			export let pickTransforms: (
+				options: object
+			) => undefined | HtmlTransformOptions;
+			export let printer: (
+				path: {
+					get node(): number;
+					get parent(): null | number;
+					/**
+					 * Stop the walk descending into the current node (enter only).
+					 */
+					skipChildren(): void;
+					type(n?: number): number;
+					start(n?: number): number;
+					end(n?: number): number;
+					/**
+					 * Raw source slice `[start, end)` — valid only during the walk (the printer's
+					 * window), before `parseHtml` releases `_htmlSource`.
+					 */
+					source(n?: number): string;
+					sourceSpanAt(from: number, to: number): string;
+					tagName(n?: number): string;
+					namespace(n?: number): number;
+					selfClosing(n?: number): boolean;
+					attributes(n?: number): HtmlAttribute[];
+					attributeCount(n?: number): number;
+					/**
+					 * The i-th attribute of an element, as an id for the `attribute*` reads.
+					 */
+					attributeAt(i: number, n?: number): number;
+					/**
+					 * Linear lookup by (lowercased) name.
+					 */
+					findAttribute(name: string, n?: number): number;
+					attributeName(a: number): string;
+					attributeValue(a: number): string;
+					attributeNameStart(a: number): number;
+					attributeNameEnd(a: number): number;
+					attributeValueStart(a: number): number;
+					attributeValueEnd(a: number): number;
+					tagEnd(n?: number): number;
+					nameEnd(n?: number): number;
+					/**
+					 * Whether the source wrote this element's end tag rather than the parser
+					 * popping it for an implied close. Read back off the range instead of marked
+					 * during the parse: an element's end spans the token that closed it, so its
+					 * own end tag is the last thing in it — and only the few elements around a
+					 * region printed from source ever ask.
+					 */
+					sourceClosed(n?: number): boolean;
+					openTag(n?: number): string;
+					/**
+					 * An element's end tag, generated as `</name>` from the opening tag's own name
+					 * (exact source casing, correct for foreign camelCase elements). Generated, not
+					 * sliced: element `end` offsets don't span the end tag, and an omitted optional
+					 * end tag (`<li>`, `<p>`, …) still serializes to the same DOM. `""` when the
+					 * parser inserted the element, as {@link openTag } does — it has no name in the
+					 * source to echo, and slicing one would spell `</>`.
+					 */
+					closeTag(n?: number): string;
+					contentEnd(n?: number): number;
+					templateContent(n?: number): number;
+					data(n?: number): string;
+					piTarget(n?: number): string;
+					doctypeName(n?: number): string;
+					doctypePublicId(_n?: number): null | string;
+					doctypeSystemId(_n?: number): null | string;
+					firstChild(n?: number): number;
+					nextSibling(n?: number): number;
+					parentOf(n?: number): number;
+					children(n?: number): number[];
+				},
+				writer: PrintContext<
+					{
+						get node(): number;
+						get parent(): null | number;
+						/**
+						 * Stop the walk descending into the current node (enter only).
+						 */
+						skipChildren(): void;
+						type(n?: number): number;
+						start(n?: number): number;
+						end(n?: number): number;
+						/**
+						 * Raw source slice `[start, end)` — valid only during the walk (the printer's
+						 * window), before `parseHtml` releases `_htmlSource`.
+						 */
+						source(n?: number): string;
+						sourceSpanAt(from: number, to: number): string;
+						tagName(n?: number): string;
+						namespace(n?: number): number;
+						selfClosing(n?: number): boolean;
+						attributes(n?: number): HtmlAttribute[];
+						attributeCount(n?: number): number;
+						/**
+						 * The i-th attribute of an element, as an id for the `attribute*` reads.
+						 */
+						attributeAt(i: number, n?: number): number;
+						/**
+						 * Linear lookup by (lowercased) name.
+						 */
+						findAttribute(name: string, n?: number): number;
+						attributeName(a: number): string;
+						attributeValue(a: number): string;
+						attributeNameStart(a: number): number;
+						attributeNameEnd(a: number): number;
+						attributeValueStart(a: number): number;
+						attributeValueEnd(a: number): number;
+						tagEnd(n?: number): number;
+						nameEnd(n?: number): number;
+						/**
+						 * Whether the source wrote this element's end tag rather than the parser
+						 * popping it for an implied close. Read back off the range instead of marked
+						 * during the parse: an element's end spans the token that closed it, so its
+						 * own end tag is the last thing in it — and only the few elements around a
+						 * region printed from source ever ask.
+						 */
+						sourceClosed(n?: number): boolean;
+						openTag(n?: number): string;
+						/**
+						 * An element's end tag, generated as `</name>` from the opening tag's own name
+						 * (exact source casing, correct for foreign camelCase elements). Generated, not
+						 * sliced: element `end` offsets don't span the end tag, and an omitted optional
+						 * end tag (`<li>`, `<p>`, …) still serializes to the same DOM. `""` when the
+						 * parser inserted the element, as {@link openTag } does — it has no name in the
+						 * source to echo, and slicing one would spell `</>`.
+						 */
+						closeTag(n?: number): string;
+						contentEnd(n?: number): number;
+						templateContent(n?: number): number;
+						data(n?: number): string;
+						piTarget(n?: number): string;
+						doctypeName(n?: number): string;
+						doctypePublicId(_n?: number): null | string;
+						doctypeSystemId(_n?: number): null | string;
+						firstChild(n?: number): number;
+						nextSibling(n?: number): number;
+						parentOf(n?: number): number;
+						children(n?: number): number[];
+					},
+					number,
+					HtmlPrintOptions
+				>
+			) => string;
+			export let tokenize: (
+				input: string,
+				pos?: number,
+				callbacks?: HtmlTokenCallbacks
+			) => number;
+			export { SourceProcessorSyntaxClass_1 as SourceProcessor };
+		}
 		export { HtmlModulesPlugin };
 	}
 	export namespace library {
@@ -28233,6 +30921,7 @@ declare namespace exports {
 			export let compareChunksNatural: (
 				chunkGraph: ChunkGraph
 			) => Comparator<Chunk>;
+			export let compareErrors: Comparator<Error>;
 			export let compareIds: (
 				a: string | number,
 				b: string | number
@@ -28449,7 +31138,8 @@ declare namespace exports {
 				| string
 				| boolean
 				| string[]
-				| (ExternalItemValueObjectKnown & ExternalItemValueObjectUnknown)
+				| ExternalItemValueObject
+				| ExternalItemValueWithOptions
 		) => void
 	) => void;
 	export type ExternalItemFunctionDataGetResolve = (
@@ -28486,9 +31176,9 @@ declare namespace exports {
 		argv: Record<string, any>
 	) => MaybePromise<Configuration | MultiConfiguration>;
 	export type ObjectSerializerContext =
-		typeof ObjectSerializerContextObjectMiddlewareObject_3;
+		typeof ObjectSerializerContextObjectMiddlewareObject_2;
 	export type ObjectDeserializerContext =
-		typeof ObjectDeserializerContextObjectMiddlewareObject_2;
+		typeof ObjectDeserializerContextObjectMiddlewareObject_1;
 	export {
 		AutomaticPrefetchPlugin,
 		AsyncDependenciesBlock,