webpack 5.108.4 → 5.109.1

package/types.d.ts

@@ -851,31 +851,14 @@ declare interface BasenameCacheEntry {
 	 */
 	cache: Map<string, Map<undefined | string, undefined | string>>;
 }
+
+/**
+ * An instance is allocated for a large share of walked expressions, so the
+ * boolean facts live in one packed flags slot and the scalar/identifier
+ * fields in five slots shared by type, with accessors keeping every public
+ * field readable. This shrinks instances from 224 to 144 bytes on V8.
+ */
 declare abstract class BasicEvaluatedExpression {
-	type: number;
-	range?: [number, number];
-	falsy: boolean;
-	truthy: boolean;
-	nullish?: boolean;
-	sideEffects: boolean;
-	bool?: boolean;
-	number?: number;
-	bigint?: bigint;
-	regExp?: RegExp;
-	string?: string;
-	quasis?: BasicEvaluatedExpression[];
-	parts?: BasicEvaluatedExpression[];
-	array?: any[];
-	items?: BasicEvaluatedExpression[];
-	options?: BasicEvaluatedExpression[];
-	prefix?: null | BasicEvaluatedExpression;
-	postfix?: null | BasicEvaluatedExpression;
-	wrappedInnerExpressions?: BasicEvaluatedExpression[];
-	identifier?: string | VariableInfo;
-	rootInfo?: string | VariableInfo;
-	getMembers?: () => string[];
-	getMembersOptionals?: () => boolean[];
-	getMemberRanges?: () => [number, number][];
 	expression?:
 		| Program
 		| ImportDeclaration
@@ -951,6 +934,38 @@ declare abstract class BasicEvaluatedExpression {
 		| AssignmentPattern
 		| SwitchCase
 		| TemplateElement;
+	quasis?: BasicEvaluatedExpression[];
+	parts?: BasicEvaluatedExpression[];
+	items?: BasicEvaluatedExpression[];
+	options?: BasicEvaluatedExpression[];
+	prefix?: null | BasicEvaluatedExpression;
+	postfix?: null | BasicEvaluatedExpression;
+	wrappedInnerExpressions?: BasicEvaluatedExpression[];
+
+	/**
+	 * Served lazily from the attached expression when not set explicitly:
+	 * `evaluateExpression`'s plain results share the expression's range, and
+	 * most evaluations never read it, so the node's range array is only
+	 * materialized on demand.
+	 */
+	range?: [number, number];
+	type: number;
+	truthy: boolean;
+	falsy: boolean;
+	nullish?: boolean;
+	sideEffects: boolean;
+	bool?: boolean;
+	number?: number;
+	bigint?: bigint;
+	regExp?: RegExp;
+	string?: string;
+	templateStringKind?: "cooked" | "raw";
+	array?: any[];
+	identifier?: string | VariableInfo;
+	rootInfo?: string | VariableInfo;
+	getMembers?: () => string[];
+	getMembersOptionals?: () => boolean[];
+	getMemberRanges?: () => [number, number][];
 	isUnknown(): boolean;
 	isNull(): boolean;
 	isUndefined(): boolean;
@@ -1081,7 +1096,6 @@ declare abstract class BasicEvaluatedExpression {
 		parts: BasicEvaluatedExpression[],
 		kind: "cooked" | "raw"
 	): BasicEvaluatedExpression;
-	templateStringKind?: "cooked" | "raw";
 	setTruthy(): BasicEvaluatedExpression;
 	setFalsy(): BasicEvaluatedExpression;
 
@@ -1325,6 +1339,11 @@ declare class CacheClass {
 	static STAGE_NETWORK: number;
 }
 declare abstract class CacheFacade {
+	/**
+	 * Returns whether a cache backend is active.
+	 */
+	isEnabled(): boolean;
+
 	/**
 	 * Returns child cache.
 	 */
@@ -2787,6 +2806,16 @@ declare interface ChunkRenderContextJavascriptModulesPlugin {
 	 * rendering in strict context
 	 */
 	strictMode?: boolean;
+
+	/**
+	 * entry module inlined at the chunk top level instead of the registry
+	 */
+	inlinedEntryModule?: Module;
+
+	/**
+	 * rendered body of the inlined entry module
+	 */
+	inlinedEntrySource?: Source;
 }
 declare interface ChunkRuntime {
 	[index: number]: string;
@@ -3161,7 +3190,7 @@ declare interface ColorsOptions {
 type CommentJavascriptParser = CommentImport & {
 	start: number;
 	end: number;
-	loc: SourceLocation;
+	loc?: null | SourceLocation;
 };
 declare interface CommonJsImportSettings {
 	name?: string;
@@ -4320,6 +4349,16 @@ declare class ConcatSource extends Source {
 	): GeneratedSourceInfo;
 }
 type ConcatSourceChild = string | Source | SourceLike;
+
+/**
+ * Advanced options for module concatenation.
+ */
+declare interface ConcatenateModulesOptions {
+	/**
+	 * Also concatenate CommonJS modules with statically analyzable exports. Defaults to 'true'.
+	 */
+	commonjs?: boolean;
+}
 type ConcatenatedModuleBuildInfo = KnownBuildInfo &
 	Record<string, any> &
 	KnownConcatenatedModuleBuildInfo;
@@ -4327,6 +4366,11 @@ 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
+	 */
+	cjsWrapped?: boolean;
 	ast?: Program;
 	internalSource?: Source;
 	source?: ReplaceSource;
@@ -4398,6 +4442,11 @@ declare interface ConcatenationBailoutReasonContext {
 	 * the chunk graph
 	 */
 	chunkGraph: ChunkGraph;
+
+	/**
+	 * whether eligible CommonJS modules may be concatenated
+	 */
+	concatenateCommonJsModules?: boolean;
 }
 
 /**
@@ -4556,7 +4605,11 @@ declare interface Configuration {
 				data: ExternalItemFunctionData,
 				callback: (
 					err?: null | Error,
-					result?: string | boolean | string[] | { [index: string]: any }
+					result?:
+						| string
+						| boolean
+						| string[]
+						| (ExternalItemValueObjectKnown & ExternalItemValueObjectUnknown)
 				) => void
 		  ) => void)
 		| ((data: ExternalItemFunctionData) => Promise<ExternalItemValue>)
@@ -4589,6 +4642,7 @@ declare interface Configuration {
 		| "umd2"
 		| "jsonp"
 		| "system"
+		| "amd-async"
 		| "promise"
 		| "module-import"
 		| "script"
@@ -5070,6 +5124,31 @@ declare interface ContextOptions {
 	layer?: null | string;
 	attributes?: ImportAttributes;
 	phase?: 0 | 1 | 2;
+
+	/**
+	 * glob patterns for import.meta.glob
+	 */
+	patterns?: string[];
+
+	/**
+	 * importer context for import.meta.glob
+	 */
+	requestContext?: string;
+
+	/**
+	 * import selection for import.meta.glob
+	 */
+	importName?: string;
+
+	/**
+	 * exhaustive mode for import.meta.glob
+	 */
+	exhaustive?: boolean;
+
+	/**
+	 * case-sensitive matching for import.meta.glob
+	 */
+	caseSensitive?: boolean;
 }
 declare class ContextReplacementPlugin {
 	/**
@@ -5253,6 +5332,16 @@ declare interface CssAutoOrModuleParserOptions {
 	 */
 	customIdents?: boolean;
 
+	/**
+	 * Enable/disable resolution of `@custom-media` at-rules (file-local build-time substitution).
+	 */
+	customMedia?: boolean;
+
+	/**
+	 * Enable/disable resolution of `@custom-selector` at-rules (file-local build-time expansion to `:is(...)`).
+	 */
+	customSelectors?: boolean;
+
 	/**
 	 * Enable/disable renaming of dashed identifiers, e. g. custom properties.
 	 */
@@ -5263,6 +5352,11 @@ declare interface CssAutoOrModuleParserOptions {
 	 */
 	exportType?: "link" | "text" | "css-style-sheet" | "style";
 
+	/**
+	 * Auto-emit `<link rel="preload" as="font">` for the primary `src` URL of each `@font-face` reachable from an HTML entry's initial CSS. Only the first URL per `@font-face` is preloaded (preloading every format would double-download). Off by default; `parser.css.urlHints` rules and per-URL magic comments still override the seeded defaults. Set `output.crossOriginLoading` so the preload matches the font's CORS fetch.
+	 */
+	fontPreload?: boolean;
+
 	/**
 	 * Enable/disable renaming of `@function` names.
 	 */
@@ -5292,6 +5386,11 @@ declare interface CssAutoOrModuleParserOptions {
 	 * Enable/disable `url()`/`image-set()`/`src()`/`image()` functions handling.
 	 */
 	url?: boolean;
+
+	/**
+	 * URL-referenced-asset default hint rules for this parser (JavaScript `new URL(...)`, CSS `url(...)`, HTML `<img src>` / `<link href>` / `<script src>`).
+	 */
+	urlHints?: UrlHintRule[];
 }
 declare interface CssData {
 	/**
@@ -5497,6 +5596,16 @@ declare interface CssModuleParserOptions {
 	 */
 	customIdents?: boolean;
 
+	/**
+	 * Enable/disable resolution of `@custom-media` at-rules (file-local build-time substitution).
+	 */
+	customMedia?: boolean;
+
+	/**
+	 * Enable/disable resolution of `@custom-selector` at-rules (file-local build-time expansion to `:is(...)`).
+	 */
+	customSelectors?: boolean;
+
 	/**
 	 * Enable/disable renaming of dashed identifiers, e. g. custom properties.
 	 */
@@ -5507,6 +5616,11 @@ declare interface CssModuleParserOptions {
 	 */
 	exportType?: "link" | "text" | "css-style-sheet" | "style";
 
+	/**
+	 * Auto-emit `<link rel="preload" as="font">` for the primary `src` URL of each `@font-face` reachable from an HTML entry's initial CSS. Only the first URL per `@font-face` is preloaded (preloading every format would double-download). Off by default; `parser.css.urlHints` rules and per-URL magic comments still override the seeded defaults. Set `output.crossOriginLoading` so the preload matches the font's CORS fetch.
+	 */
+	fontPreload?: boolean;
+
 	/**
 	 * Enable/disable renaming of `@function` names.
 	 */
@@ -5531,6 +5645,11 @@ declare interface CssModuleParserOptions {
 	 * Enable/disable `url()`/`image-set()`/`src()`/`image()` functions handling.
 	 */
 	url?: boolean;
+
+	/**
+	 * URL-referenced-asset default hint rules for this parser (JavaScript `new URL(...)`, CSS `url(...)`, HTML `<img src>` / `<link href>` / `<script src>`).
+	 */
+	urlHints?: UrlHintRule[];
 }
 declare class CssModulesPlugin {
 	constructor();
@@ -5610,6 +5729,14 @@ declare abstract class CssParser extends ParserClass {
 		 * Enable/disable renaming of custom identifiers.
 		 */
 		customIdents: boolean;
+		/**
+		 * Enable/disable resolution of `@custom-media` at-rules (file-local build-time substitution).
+		 */
+		customMedia: boolean;
+		/**
+		 * Enable/disable resolution of `@custom-selector` at-rules (file-local build-time expansion to `:is(...)`).
+		 */
+		customSelectors: boolean;
 		/**
 		 * Enable/disable renaming of dashed identifiers, e. g. custom properties.
 		 */
@@ -5618,6 +5745,10 @@ declare abstract class CssParser extends ParserClass {
 		 * Configure how CSS content is exported as default.
 		 */
 		exportType?: "link" | "text" | "css-style-sheet" | "style";
+		/**
+		 * Auto-emit `<link rel="preload" as="font">` for the primary `src` URL of each `@font-face` reachable from an HTML entry's initial CSS. Only the first URL per `@font-face` is preloaded (preloading every format would double-download). Off by default; `parser.css.urlHints` rules and per-URL magic comments still override the seeded defaults. Set `output.crossOriginLoading` so the preload matches the font's CORS fetch.
+		 */
+		fontPreload?: boolean;
 		/**
 		 * Enable/disable renaming of `@function` names.
 		 */
@@ -5642,6 +5773,10 @@ declare abstract class CssParser extends ParserClass {
 		 * Enable/disable `url()`/`image-set()`/`src()`/`image()` functions handling.
 		 */
 		url: boolean;
+		/**
+		 * URL-referenced-asset default hint rules for this parser (JavaScript `new URL(...)`, CSS `url(...)`, HTML `<img src>` / `<link href>` / `<script src>`).
+		 */
+		urlHints?: UrlHintRule[];
 		/**
 		 * default mode
 		 */
@@ -5659,11 +5794,26 @@ declare interface CssParserOptions {
 	 */
 	as?: "stylesheet" | "block-contents";
 
+	/**
+	 * Enable/disable resolution of `@custom-media` at-rules (file-local build-time substitution).
+	 */
+	customMedia?: boolean;
+
+	/**
+	 * Enable/disable resolution of `@custom-selector` at-rules (file-local build-time expansion to `:is(...)`).
+	 */
+	customSelectors?: boolean;
+
 	/**
 	 * Configure how CSS content is exported as default.
 	 */
 	exportType?: "link" | "text" | "css-style-sheet" | "style";
 
+	/**
+	 * Auto-emit `<link rel="preload" as="font">` for the primary `src` URL of each `@font-face` reachable from an HTML entry's initial CSS. Only the first URL per `@font-face` is preloaded (preloading every format would double-download). Off by default; `parser.css.urlHints` rules and per-URL magic comments still override the seeded defaults. Set `output.crossOriginLoading` so the preload matches the font's CORS fetch.
+	 */
+	fontPreload?: boolean;
+
 	/**
 	 * Enable/disable `@import` at-rules handling.
 	 */
@@ -5678,8 +5828,33 @@ declare interface CssParserOptions {
 	 * Enable/disable `url()`/`image-set()`/`src()`/`image()` functions handling.
 	 */
 	url?: boolean;
+
+	/**
+	 * URL-referenced-asset default hint rules for this parser (JavaScript `new URL(...)`, CSS `url(...)`, HTML `<img src>` / `<link href>` / `<script src>`).
+	 */
+	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
@@ -5727,6 +5902,21 @@ declare class DefinePlugin {
 		options?: true | string[] | RuntimeValueOptions
 	): RuntimeValue;
 	static getCompilationHooks: (compilation: Compilation) => DefinePluginHooks;
+	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 DefinePluginHooks {
 	definitions: SyncWaterfallHook<
@@ -6108,7 +6298,6 @@ declare abstract class DependencyTemplates {
 declare interface DestructuringAssignmentProperty {
 	id: string;
 	range: [number, number];
-	loc: SourceLocation;
 	pattern?: Set<DestructuringAssignmentProperty>;
 	shorthand: string | boolean;
 }
@@ -6579,7 +6768,7 @@ declare class ElectronTargetPlugin {
 	 * Creates an instance of ElectronTargetPlugin.
 	 */
 	constructor(
-		context?: "main" | "preload" | "renderer",
+		context?: "preload" | "main" | "renderer",
 		type?:
 			| "import"
 			| "var"
@@ -6599,6 +6788,7 @@ declare class ElectronTargetPlugin {
 			| "umd2"
 			| "jsonp"
 			| "system"
+			| "amd-async"
 			| "promise"
 			| "module-import"
 			| "script"
@@ -6952,7 +7142,7 @@ declare interface EntryOptionPluginHooks {
 		undefined | string
 	>;
 }
-type EntryOptions = { name?: string } & Omit<
+type EntryOptions = { name?: string; worklet?: boolean } & Omit<
 	EntryDescriptionNormalized,
 	"import"
 >;
@@ -6978,11 +7168,6 @@ declare class EntryPlugin {
 		options: string | EntryOptions
 	): EntryDependency;
 }
-declare interface EntryScriptInfo {
-	request: string;
-	entryName: string;
-	type: "script" | "stylesheet" | "script-module" | "modulepreload";
-}
 type EntryStatic = string | EntryObject | string[];
 
 /**
@@ -7082,6 +7267,11 @@ declare interface Environment {
 	 */
 	forOf?: boolean;
 
+	/**
+	 * The environment supports generator functions and yield ('function* () { yield ... }').
+	 */
+	generator?: boolean;
+
 	/**
 	 * The environment supports 'globalThis'.
 	 */
@@ -7117,6 +7307,11 @@ declare interface Environment {
 	 */
 	module?: boolean;
 
+	/**
+	 * The environment supports `<link rel="modulepreload">` to preload EcmaScript modules.
+	 */
+	modulePreload?: boolean;
+
 	/**
 	 * The environment supports `process.getBuiltinModule()` to synchronously load Node.js core modules.
 	 */
@@ -7254,6 +7449,11 @@ declare interface ExecuteModuleOptions {
 declare interface ExecuteModuleResult {
 	exports: any;
 	cacheable: boolean;
+
+	/**
+	 * reasons why the executed modules are not cacheable
+	 */
+	notCacheableReasons: string[];
 	assets: Map<string, { source: Source; info?: AssetInfo }>;
 	fileDependencies: LazySet<string>;
 	contextDependencies: LazySet<string>;
@@ -7286,10 +7486,10 @@ declare interface Experiments {
 	[index: string]: any;
 
 	/**
-	 * Support WebAssembly as asynchronous EcmaScript Module.
+	 * Support WebAssembly as asynchronous EcmaScript Module. `"auto"` (the default) enables it unless a loader is registered for WebAssembly files.
 	 * @experimental
 	 */
-	asyncWebAssembly?: boolean;
+	asyncWebAssembly?: boolean | "auto";
 
 	/**
 	 * Enable backward-compat layer with deprecation warnings for many webpack 4 APIs.
@@ -7310,10 +7510,10 @@ declare interface Experiments {
 	cacheUnaffected?: boolean;
 
 	/**
-	 * Enable css support.
+	 * Enable css support. `"auto"` (the default) enables the built-in CSS support unless a loader is registered for CSS files.
 	 * @experimental
 	 */
-	css?: boolean;
+	css?: boolean | "auto";
 
 	/**
 	 * Enable experimental tc39 proposal https://github.com/tc39/proposal-defer-import-eval. This allows to defer execution of a module until it's first use.
@@ -7328,10 +7528,10 @@ declare interface Experiments {
 	futureDefaults?: boolean;
 
 	/**
-	 * Enable HTML entry support. Treats `.html` files as a first-class module type so they can be used directly as entry points.
+	 * Enable HTML entry support. Treats `.html` files as a first-class module type so they can be used directly as entry points. `"auto"` (the default) enables it unless a loader is registered for HTML files.
 	 * @experimental
 	 */
-	html?: boolean;
+	html?: boolean | "auto";
 
 	/**
 	 * Compile entrypoints and import()s only when they are accessed.
@@ -7358,10 +7558,10 @@ declare interface Experiments {
 	syncWebAssembly?: boolean;
 
 	/**
-	 * Enable typescript support.
+	 * Enable typescript support. `"auto"` (the default) enables the built-in TypeScript support when Node.js supports it (>= 22.6) and no loader is registered for TypeScript files.
 	 * @experimental
 	 */
-	typescript?: boolean;
+	typescript?: boolean | "auto";
 }
 
 /**
@@ -7369,10 +7569,10 @@ declare interface Experiments {
  */
 declare interface ExperimentsNormalized {
 	/**
-	 * Support WebAssembly as asynchronous EcmaScript Module.
+	 * Support WebAssembly as asynchronous EcmaScript Module. `"auto"` (the default) enables it unless a loader is registered for WebAssembly files.
 	 * @experimental
 	 */
-	asyncWebAssembly?: boolean;
+	asyncWebAssembly?: boolean | "auto";
 
 	/**
 	 * Enable backward-compat layer with deprecation warnings for many webpack 4 APIs.
@@ -7393,10 +7593,10 @@ declare interface ExperimentsNormalized {
 	cacheUnaffected?: boolean;
 
 	/**
-	 * Enable css support.
+	 * Enable css support. `"auto"` (the default) enables the built-in CSS support unless a loader is registered for CSS files.
 	 * @experimental
 	 */
-	css?: boolean;
+	css?: boolean | "auto";
 
 	/**
 	 * Enable experimental tc39 proposal https://github.com/tc39/proposal-defer-import-eval. This allows to defer execution of a module until it's first use.
@@ -7411,10 +7611,10 @@ declare interface ExperimentsNormalized {
 	futureDefaults?: boolean;
 
 	/**
-	 * Enable HTML entry support. Treats `.html` files as a first-class module type so they can be used directly as entry points.
+	 * Enable HTML entry support. Treats `.html` files as a first-class module type so they can be used directly as entry points. `"auto"` (the default) enables it unless a loader is registered for HTML files.
 	 * @experimental
 	 */
-	html?: boolean;
+	html?: boolean | "auto";
 
 	/**
 	 * Compile entrypoints and import()s only when they are accessed.
@@ -7441,10 +7641,10 @@ declare interface ExperimentsNormalized {
 	syncWebAssembly?: boolean;
 
 	/**
-	 * Enable typescript support.
+	 * Enable typescript support. `"auto"` (the default) enables the built-in TypeScript support when Node.js supports it (>= 22.6) and no loader is registered for TypeScript files.
 	 * @experimental
 	 */
-	typescript?: boolean;
+	typescript?: boolean | "auto";
 }
 declare abstract class ExportInfo {
 	name: string;
@@ -7984,7 +8184,11 @@ type ExternalItem =
 			data: ExternalItemFunctionData,
 			callback: (
 				err?: null | Error,
-				result?: string | boolean | string[] | { [index: string]: any }
+				result?:
+					| string
+					| boolean
+					| string[]
+					| (ExternalItemValueObjectKnown & ExternalItemValueObjectUnknown)
 			) => void
 	  ) => void)
 	| ((data: ExternalItemFunctionData) => Promise<ExternalItemValue>);
@@ -7993,7 +8197,11 @@ type ExternalItemFunction =
 			data: ExternalItemFunctionData,
 			callback: (
 				err?: null | Error,
-				result?: string | boolean | string[] | { [index: string]: any }
+				result?:
+					| string
+					| boolean
+					| string[]
+					| (ExternalItemValueObjectKnown & ExternalItemValueObjectUnknown)
 			) => void
 	  ) => void)
 	| ((data: ExternalItemFunctionData) => Promise<ExternalItemValue>);
@@ -8054,7 +8262,28 @@ declare interface ExternalItemObjectKnown {
 declare interface ExternalItemObjectUnknown {
 	[index: string]: ExternalItemValue;
 }
-type ExternalItemValue = string | boolean | string[] | { [index: string]: any };
+type ExternalItemValue =
+	| string
+	| boolean
+	| string[]
+	| (ExternalItemValueObjectKnown & ExternalItemValueObjectUnknown);
+
+/**
+ * The target of the external with a type, optionally with an 'interop' hint describing how its exports interoperate with ES module imports.
+ */
+declare interface ExternalItemValueObjectKnown {
+	/**
+	 * How an external's exports interoperate with ES module imports, independent of the importing module's strictness (similar to Rollup's `output.interop`). 'default': treat as CommonJS, the default import is the whole exports (Node.js semantics). 'esModule': treat as an ES module namespace, the default import is unboxed to `.default`.
+	 */
+	interop?: "default" | "esModule";
+}
+
+/**
+ * The target of the external with a type, optionally with an 'interop' hint describing how its exports interoperate with ES module imports.
+ */
+declare interface ExternalItemValueObjectUnknown {
+	[index: string]: string | string[];
+}
 declare class ExternalModule extends Module {
 	/**
 	 * Creates an instance of ExternalModule.
@@ -8064,13 +8293,15 @@ declare class ExternalModule extends Module {
 		type: ExternalsType,
 		userRequest: string,
 		dependencyMeta?:
-			ImportDependencyMeta | CssImportDependencyMeta | AssetDependencyMeta
+			ImportDependencyMeta | CssImportDependencyMeta | AssetDependencyMeta,
+		interop?: "default" | "esModule"
 	);
 	request: ExternalModuleRequest;
 	externalType: ExternalsType;
 	userRequest: string;
 	dependencyMeta?:
 		ImportDependencyMeta | CssImportDependencyMeta | AssetDependencyMeta;
+	interop?: "default" | "esModule";
 
 	/**
 	 * restore unsafe cache data
@@ -8186,7 +8417,11 @@ type Externals =
 			data: ExternalItemFunctionData,
 			callback: (
 				err?: null | Error,
-				result?: string | boolean | string[] | { [index: string]: any }
+				result?:
+					| string
+					| boolean
+					| string[]
+					| (ExternalItemValueObjectKnown & ExternalItemValueObjectUnknown)
 			) => void
 	  ) => void)
 	| ((data: ExternalItemFunctionData) => Promise<ExternalItemValue>)
@@ -8215,6 +8450,7 @@ declare class ExternalsPlugin {
 			| "umd2"
 			| "jsonp"
 			| "system"
+			| "amd-async"
 			| "promise"
 			| "module-import"
 			| "script"
@@ -8245,6 +8481,7 @@ declare class ExternalsPlugin {
 		| "umd2"
 		| "jsonp"
 		| "system"
+		| "amd-async"
 		| "promise"
 		| "module-import"
 		| "script"
@@ -8344,6 +8581,7 @@ type ExternalsType =
 	| "umd2"
 	| "jsonp"
 	| "system"
+	| "amd-async"
 	| "promise"
 	| "module-import"
 	| "script"
@@ -8459,7 +8697,7 @@ declare interface FileCacheOptions {
 	/**
 	 * Compression type used for the cache files.
 	 */
-	compression?: false | "gzip" | "brotli";
+	compression?: false | "gzip" | "brotli" | "zstd";
 
 	/**
 	 * Algorithm used for generation the hash (see node.js crypto package).
@@ -9380,6 +9618,77 @@ declare interface HotModuleReplacementPluginLoaderContext {
 declare class HotUpdateChunk extends Chunk {
 	constructor();
 }
+declare interface HtmlCompilationHooks {
+	/**
+	 * called with the list of extra tags to inject into each page (initially empty) plus the current HTML; push `HtmlTagDescriptor`s and return the list — webpack serializes and places them by `injectTo`. A structured alternative to the string-level `transformHtml` for adding tags; runs before CSP so injected inline tags are hashed
+	 */
+	injectTags: AsyncSeriesWaterfallHook<
+		[HtmlTagDescriptor[], HtmlInjectTagsContext],
+		HtmlTagDescriptor[]
+	>;
+
+	/**
+	 * called with the page's `<script>`/`<link>`/`<style>`/`<meta>` tags (webpack's own and any injected) as mutable descriptors; mutate `attrs` (add a `nonce`/`data-*`, switch `defer`↔`async`, …), set `remove: true`, or change `injectTo` to move a tag between `<head>` and `<body>`, and webpack rewrites the changed tags. Add new tags with `injectTags` instead
+	 */
+	transformTags: AsyncSeriesHook<[HtmlMutableTag[], HtmlTransformTagsContext]>;
+
+	/**
+	 * called with each emitted page's final HTML (all sentinels resolved) just before it is written; return the (possibly transformed) HTML — e.g. to minify, inject a CSP meta, or rewrite tags
+	 */
+	transformHtml: AsyncSeriesWaterfallHook<
+		[string, HtmlTransformHtmlContext],
+		string
+	>;
+
+	/**
+	 * called once each page's HTML asset has been finalized — a post-emit notification (nothing to return)
+	 */
+	htmlEmitted: AsyncSeriesHook<[HtmlEmittedContext]>;
+}
+declare interface HtmlEmittedContext {
+	outputName: string;
+}
+declare interface HtmlEntryInfo {
+	request: string;
+	entryName: string;
+	type:
+		| "html"
+		| "script"
+		| "stylesheet"
+		| "prefetch"
+		| "preload"
+		| "modulepreload"
+		| "script-module";
+	css?: boolean;
+}
+type HtmlFaviconIcon =
+	| string
+	| {
+			/**
+			 * Value for the `color` attribute (used by `rel="mask-icon"`).
+			 */
+			color?: string;
+			/**
+			 * Value for the `crossorigin` attribute.
+			 */
+			crossorigin?: "anonymous" | "use-credentials";
+			/**
+			 * Path to the icon file, emitted as a hashed asset.
+			 */
+			href: string;
+			/**
+			 * Value for the `media` attribute (e.g. `"(prefers-color-scheme: dark)"`).
+			 */
+			media?: string;
+			/**
+			 * Value for the `sizes` attribute (e.g. `"180x180"` or `"any"`).
+			 */
+			sizes?: string;
+			/**
+			 * Value for the `type` attribute; inferred from the file extension when omitted.
+			 */
+			type?: string;
+	  };
 declare abstract class HtmlGenerator extends Generator {
 	options: HtmlGeneratorOptions;
 
@@ -9430,14 +9739,75 @@ declare interface HtmlGeneratorOptions {
 	 */
 	extract?: boolean | "inline";
 }
+declare interface HtmlInjectTagsContext {
+	outputName: string;
+	html: string;
+}
 type HtmlModuleBuildInfo = KnownBuildInfo &
 	Record<string, any> &
 	KnownNormalModuleBuildInfo &
 	KnownHtmlModuleBuildInfo;
+declare class HtmlModulesPlugin {
+	constructor();
+
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 */
+	apply(compiler: Compiler): void;
+
+	/**
+	 * `output.hashFunction`/`hashSalt`/`hashDigest`/`hashDigestLength`
+	 * digest of `content`, with `nonNumericOnlyHash` applied — webpack's
+	 * standard `[contenthash]` recipe.
+	 */
+	static computeContentHash(
+		content: string | Buffer,
+		outputOptions: Output
+	): string;
+
+	/**
+	 * Filename template for an extracted HTML page: `output.htmlFilename` for
+	 * initial chunks, `output.htmlChunkFilename` otherwise — the HTML counterpart
+	 * of `CssModulesPlugin.getChunkFilenameTemplate`.
+	 */
+	static getChunkFilenameTemplate(
+		chunk: Chunk,
+		outputOptions: Output
+	): ChunkFilenameTemplate;
+
+	/**
+	 * Per-compilation hooks for the experimental HTML support.
+	 */
+	static getCompilationHooks: (
+		compilation: Compilation
+	) => HtmlCompilationHooks;
+}
+declare interface HtmlMutableTag {
+	/**
+	 * the (lowercased) tag name
+	 */
+	tag: string;
+
+	/**
+	 * mutable attributes; a string value renders `name="value"`, `true` a bare attribute, `false`/`undefined`/deleting the key drops it
+	 */
+	attrs: Record<string, undefined | string | boolean>;
+
+	/**
+	 * the tag's current region (`"head"`/`"body"`); set a different value to move it there (`*-prepend` to the region's start)
+	 */
+	injectTo?: "body" | "head" | "head-prepend" | "body-prepend";
+
+	/**
+	 * set true to delete the whole element
+	 */
+	remove?: boolean;
+}
 declare abstract class HtmlParser extends ParserClass {
 	magicCommentContext: ContextImport;
 	template?: (source: string, context: HtmlTemplateContext) => string;
-	sourcesByTag: Record<string, Record<string, SourceItem>>;
+	fragmentContext?: string;
+	sourcesByTag: SourceTable;
 
 	/**
 	 * Runs the `template` option over the source and returns the transformed
@@ -9453,6 +9823,11 @@ declare abstract class HtmlParser extends ParserClass {
  * Parser options for html modules.
  */
 declare interface HtmlParserOptions {
+	/**
+	 * Configure how the HTML source is parsed: `"document"` (the default) parses a full page; any other value is the tag name of the context element to parse the source as that element's inner HTML (a fragment) — e.g. `"template"` for a neutral fragment, or `"tbody"` so context-sensitive tags like a bare `<tr>`/`<td>` are kept instead of dropped.
+	 */
+	as?: string;
+
 	/**
 	 * Configure extraction of URL-like attribute values (e.g. `<img src>`, `<link href>`, `<script src>`) as webpack dependencies. `true` (default) uses the built-in source list; `false` disables extraction entirely so attributes are left untouched and `<script src>` / `<link rel="modulepreload">` / `<link rel="stylesheet">` no longer become compilation entries; an array lets you customize which `tag`/`attribute` pairs are treated as URLs and how they are bundled. Use the string `"..."` inside the array to inline the defaults. Inline `<script>` and `<style>` bodies are always processed. Use `webpackIgnore` comments or `IgnorePlugin` to skip individual URLs.
 	 */
@@ -9477,9 +9852,11 @@ declare interface HtmlParserOptions {
 						 */
 						tag?: string;
 						/**
-						 * How the attribute value should be parsed and bundled. `src` extracts a single URL as a plain asset; `srcset` parses a `srcset`-style list of candidate URLs as plain assets; `css-url` extracts `url(...)` references from a CSS value (like an SVG presentation attribute such as `fill`) as plain assets; `script` and `script-module` emit a classic / ES-module chunk entry like `<script src>` and `<script type="module" src>`; `stylesheet` emits a CSS chunk entry like `<link rel="stylesheet">`; `stylesheet-style` treats the attribute value as a full stylesheet (like a `<style>` body) and `stylesheet-style-attribute` as a CSS block's contents (a declaration list, like a `style` attribute) — both bundle it through the CSS pipeline and replace the attribute's content with the processed CSS at render time; `srcdoc` treats the attribute value as an entity-encoded HTML document (like `<iframe srcdoc>`), bundling it through the HTML pipeline and replacing the attribute's content with the processed HTML at render time.
+						 * How the attribute value should be parsed and bundled, or `false` to disable a built-in source for this `tag`/`attribute` (use together with `"..."` to drop a default, e.g. stop treating `<img src>` as a URL). `src` extracts a single URL as a plain asset; `srcset` parses a `srcset`-style list of candidate URLs as plain assets; `css-url` extracts `url(...)` references from a CSS value (like an SVG presentation attribute such as `fill`) as plain assets; `script` and `script-module` emit a classic / ES-module chunk entry like `<script src>` and `<script type="module" src>`; `stylesheet` emits a CSS chunk entry like `<link rel="stylesheet">`; `html` treats the URL as a link to another HTML file that is bundled as its own emitted page (its assets extracted) and rewrites the attribute to the page's output filename (like Parcel's `<a href="page.html">`); `stylesheet-style` treats the attribute value as a full stylesheet (like a `<style>` body) and `stylesheet-style-attribute` as a CSS block's contents (a declaration list, like a `style` attribute) — both bundle it through the CSS pipeline and replace the attribute's content with the processed CSS at render time; `srcdoc` treats the attribute value as an entity-encoded HTML document (like `<iframe srcdoc>`), bundling it through the HTML pipeline and replacing the attribute's content with the processed HTML at render time.
 						 */
 						type:
+							| false
+							| "html"
 							| "script"
 							| "css-url"
 							| "stylesheet"
@@ -9496,6 +9873,145 @@ declare interface HtmlParserOptions {
 	 * Transform the raw source before the html parser extracts dependencies. Receives the source string and a context (`{ module, resource }`) and must return the html string to parse. Useful for compiling a templating language (Handlebars, EJS, Eta, …) to html so that URLs the template emits are still picked up as webpack dependencies. Runs synchronously.
 	 */
 	template?: (source: string, context: HtmlTemplateContext) => string;
+
+	/**
+	 * URL-referenced-asset default hint rules for this parser (JavaScript `new URL(...)`, CSS `url(...)`, HTML `<img src>` / `<link href>` / `<script src>`).
+	 */
+	urlHints?: UrlHintRule[];
+}
+declare interface HtmlResourceHintHtmlEntryDependency {
+	/**
+	 * hint relationship
+	 */
+	rel: HtmlResourceHintRel;
+
+	/**
+	 * literal URL (external, `preconnect`, or an already-hashed asset)
+	 */
+	href?: string;
+
+	/**
+	 * chunk name to hint
+	 */
+	chunk?: string;
+
+	/**
+	 * entrypoint name to hint (expands to one hint per initial chunk)
+	 */
+	entry?: string;
+
+	/**
+	 * the `as` attribute; defaults to `script` for chunk/entry refs
+	 */
+	as?: string;
+
+	/**
+	 * the `type` attribute (MIME)
+	 */
+	type?: string;
+
+	/**
+	 * CORS mode (`true` → `anonymous`)
+	 */
+	crossorigin?: boolean | "anonymous" | "use-credentials";
+
+	/**
+	 * the `media` attribute
+	 */
+	media?: string;
+
+	/**
+	 * SRI for a chunk/entry ref; follows `output.html.integrity` by default, `false` opts out
+	 */
+	integrity?: boolean;
+
+	/**
+	 * the `fetchpriority` attribute (allowed on `preload`/`modulepreload`/`prefetch`)
+	 */
+	fetchPriority?: "auto" | "low" | "high";
+}
+type HtmlResourceHintRel =
+	"prefetch" | "preload" | "modulepreload" | "preconnect" | "dns-prefetch";
+
+/**
+ * A custom resource-hint `<link>` for `output.html.resourceHints`. Exactly one of `href` / `chunk` / `entry` names the target.
+ */
+declare interface HtmlResourceHintWebpackOptions {
+	/**
+	 * The `as` attribute (`script`, `style`, `font`, …); defaults to `script` for chunk/entry references.
+	 */
+	as?: string;
+
+	/**
+	 * Name of a chunk to hint; its emitted URL is resolved automatically.
+	 */
+	chunk?: string;
+
+	/**
+	 * The CORS mode; `true` maps to `anonymous`.
+	 */
+	crossorigin?: boolean | "anonymous" | "use-credentials";
+
+	/**
+	 * Name of an entrypoint to hint; expands to one hint per initial chunk.
+	 */
+	entry?: string;
+
+	/**
+	 * The `fetchpriority` attribute. Emitted on `preload` / `modulepreload` and on `prefetch` (the spec now permits it there).
+	 */
+	fetchPriority?: "auto" | "low" | "high";
+
+	/**
+	 * A literal URL used verbatim (external resource, `preconnect` origin, or an already-hashed asset).
+	 */
+	href?: string;
+
+	/**
+	 * Subresource Integrity for a chunk/entry reference. Follows `output.html.integrity` by default; set `false` to opt this hint out.
+	 */
+	integrity?: boolean;
+
+	/**
+	 * The `media` attribute.
+	 */
+	media?: string;
+
+	/**
+	 * The `rel` of the resource hint.
+	 */
+	rel: "prefetch" | "preload" | "modulepreload" | "preconnect" | "dns-prefetch";
+
+	/**
+	 * The `type` attribute (MIME type).
+	 */
+	type?: string;
+}
+declare interface HtmlTagDescriptor {
+	/**
+	 * tag name, e.g. `"script"` / `"link"` / `"meta"`
+	 */
+	tag: string;
+
+	/**
+	 * attributes; `true` renders a bare boolean attribute, `false`/`undefined` is omitted
+	 */
+	attrs?: Record<string, undefined | string | boolean>;
+
+	/**
+	 * inner content (ignored for void elements like `<link>`/`<meta>`)
+	 */
+	children?: string;
+
+	/**
+	 * placement; defaults to `"head"`
+	 */
+	injectTo?: "body" | "head" | "head-prepend" | "body-prepend";
+
+	/**
+	 * force a void element (no closing tag); inferred from the tag name when omitted
+	 */
+	voidTag?: boolean;
 }
 declare interface HtmlTemplateContext {
 	/**
@@ -9538,6 +10054,13 @@ declare interface HtmlTemplateContext {
 	 */
 	emitError: (error: string | Error) => void;
 }
+declare interface HtmlTransformHtmlContext {
+	outputName: string;
+}
+declare interface HtmlTransformTagsContext {
+	outputName: string;
+	html: string;
+}
 
 /**
  * Options for building http resources.
@@ -9960,6 +10483,65 @@ declare interface ImportDependencyMeta {
 type ImportExpressionJavascriptParser = ImportExpressionImport & {
 	phase?: "defer" | "source";
 };
+type ImportMetaParserOptions = ImportMetaParserOptionsKnown &
+	ImportMetaParserOptionsUnknown;
+
+/**
+ * Enable/disable evaluating import.meta fields. Omitted fields are enabled and unknown fields are preserved. Custom fields are allowed.
+ */
+declare interface ImportMetaParserOptionsKnown {
+	/**
+	 * Enable/disable evaluating import.meta.dirname.
+	 */
+	dirname?: boolean;
+
+	/**
+	 * Enable/disable evaluating import.meta.env.
+	 */
+	env?: boolean;
+
+	/**
+	 * Enable/disable evaluating import.meta.filename.
+	 */
+	filename?: boolean;
+
+	/**
+	 * Enable/disable evaluating import.meta.main.
+	 */
+	main?: boolean;
+
+	/**
+	 * Enable/disable evaluating import.meta.resolve.
+	 */
+	resolve?: boolean;
+
+	/**
+	 * Enable/disable evaluating import.meta.url.
+	 */
+	url?: boolean;
+
+	/**
+	 * Enable/disable evaluating import.meta.webpack.
+	 */
+	webpack?: boolean;
+
+	/**
+	 * Enable/disable evaluating import.meta.webpackContext.
+	 */
+	webpackContext?: boolean;
+
+	/**
+	 * Enable/disable evaluating import.meta.webpackHot.
+	 */
+	webpackHot?: boolean;
+}
+
+/**
+ * Enable/disable evaluating import.meta fields. Omitted fields are enabled and unknown fields are preserved. Custom fields are allowed.
+ */
+declare interface ImportMetaParserOptionsUnknown {
+	[index: string]: boolean;
+}
 declare interface ImportModuleOptions {
 	/**
 	 * the target layer
@@ -10019,6 +10601,11 @@ declare interface InfrastructureLogging {
 	 */
 	level?: "none" | "verbose" | "error" | "warn" | "info" | "log";
 
+	/**
+	 * Show build progress. `"auto"` shows it only for interactive terminals. This option is only used when no custom console is provided.
+	 */
+	progress?: boolean | "auto";
+
 	/**
 	 * Stream used for logging output. Defaults to process.stderr. This option is only used when no custom console is provided.
 	 */
@@ -10281,10 +10868,9 @@ declare abstract class JavascriptGenerator extends Generator {
 	 * Processes the provided module.
 	 */
 	sourceDependency(
-		module: Module,
 		dependency: Dependency,
-		initFragments: InitFragment<GenerateContext>[],
 		source: ReplaceSource,
+		templateContext: DependencyTemplateContext,
 		generateContext: GenerateContext
 	): void;
 
@@ -10294,7 +10880,7 @@ declare abstract class JavascriptGenerator extends Generator {
 	sourceBlock(
 		module: Module,
 		block: DependenciesBlock,
-		initFragments: InitFragment<GenerateContext>[],
+		templateContext: DependencyTemplateContext,
 		source: ReplaceSource,
 		generateContext: GenerateContext
 	): void;
@@ -10406,6 +10992,8 @@ declare class JavascriptParser extends ParserClass {
 		options?: {
 			parse?: (code: string, options: ParseOptions) => ParseResult;
 			typescript?: boolean;
+			importPhases?: boolean;
+			strictModeViolations?: false | "error" | "warn";
 		}
 	);
 	hooks: Readonly<{
@@ -10555,6 +11143,41 @@ declare class JavascriptParser extends ParserClass {
 			],
 			boolean | void
 		>;
+		preStatementByType: HookMap<
+			SyncBailHook<
+				[
+					| ImportDeclaration
+					| ExportNamedDeclaration
+					| ExportAllDeclaration
+					| FunctionDeclaration
+					| MaybeNamedFunctionDeclaration
+					| VariableDeclaration
+					| ClassDeclaration
+					| MaybeNamedClassDeclaration
+					| ExpressionStatement
+					| BlockStatement
+					| StaticBlock
+					| EmptyStatement
+					| DebuggerStatement
+					| WithStatement
+					| ReturnStatement
+					| LabeledStatement
+					| BreakStatement
+					| ContinueStatement
+					| IfStatement
+					| SwitchStatement
+					| ThrowStatement
+					| TryStatement
+					| WhileStatement
+					| DoWhileStatement
+					| ForStatement
+					| ForInStatement
+					| ForOfStatement
+					| ExportDefaultDeclaration
+				],
+				boolean | void
+			>
+		>;
 		blockPreStatement: SyncBailHook<
 			[
 				| ImportDeclaration
@@ -10588,6 +11211,41 @@ declare class JavascriptParser extends ParserClass {
 			],
 			boolean | void
 		>;
+		blockPreStatementByType: HookMap<
+			SyncBailHook<
+				[
+					| ImportDeclaration
+					| ExportNamedDeclaration
+					| ExportAllDeclaration
+					| FunctionDeclaration
+					| MaybeNamedFunctionDeclaration
+					| VariableDeclaration
+					| ClassDeclaration
+					| MaybeNamedClassDeclaration
+					| ExpressionStatement
+					| BlockStatement
+					| StaticBlock
+					| EmptyStatement
+					| DebuggerStatement
+					| WithStatement
+					| ReturnStatement
+					| LabeledStatement
+					| BreakStatement
+					| ContinueStatement
+					| IfStatement
+					| SwitchStatement
+					| ThrowStatement
+					| TryStatement
+					| WhileStatement
+					| DoWhileStatement
+					| ForStatement
+					| ForInStatement
+					| ForOfStatement
+					| ExportDefaultDeclaration
+				],
+				boolean | void
+			>
+		>;
 		statement: SyncBailHook<
 			[
 				| ImportDeclaration
@@ -10847,11 +11505,13 @@ declare class JavascriptParser extends ParserClass {
 	options: {
 		parse?: (code: string, options: ParseOptions) => ParseResult;
 		typescript?: boolean;
+		importPhases?: boolean;
+		strictModeViolations?: false | "error" | "warn";
 	};
 	scope: ScopeInfo;
 	state: JavascriptParserState;
 	comments?: CommentJavascriptParser[];
-	semicolons?: Set<number>;
+	semicolons?: Map<number, boolean>;
 	statementPath?: StatementPathItem[];
 	prevStatement?:
 		| ImportDeclaration
@@ -12130,6 +12790,20 @@ declare class JavascriptParser extends ParserClass {
 		commentsStartPos: number
 	): boolean;
 
+	/**
+	 * Returns the location of a node or comment, computed from its offsets so
+	 * ASTs from parsers without location support work too. Falls back to the
+	 * node's own `loc` only when no source text is available (preparsed ASTs).
+	 * Offsets can only be mapped while parsing — callbacks deferred past the
+	 * `parse()` call must take the location upfront.
+	 */
+	getLocation(node: {
+		start?: number;
+		end?: number;
+		range?: [number, number];
+		loc?: null | SourceLocation;
+	}): DependencyLocation;
+
 	/**
 	 * Returns comments in the range.
 	 */
@@ -12485,6 +13159,11 @@ declare interface JavascriptParserOptions {
 	 */
 	deferImport?: boolean;
 
+	/**
+	 * Auto-emit `<link rel="preload" as="style">` for the CSS of every dynamically imported (`import()`) chunk, so the stylesheet fetches in parallel with the chunk's JavaScript instead of after it parses. Unlike `dynamicImportPreload`, the JavaScript itself is not preloaded. `true` uses the default order; a number sets the preload order.
+	 */
+	dynamicImportCssPreload?: number | boolean;
+
 	/**
 	 * Specifies global fetchPriority for dynamic import.
 	 */
@@ -12551,12 +13230,13 @@ declare interface JavascriptParserOptions {
 	importExportsPresence?: false | "auto" | "error" | "warn";
 
 	/**
-	 * Enable/disable evaluating import.meta. Set to 'preserve-unknown' to preserve unknown properties for runtime evaluation.
+	 * Enable/disable evaluating import.meta. Set to 'preserve-unknown' or an object to preserve unknown properties for runtime evaluation.
 	 */
-	importMeta?: boolean | "preserve-unknown";
+	importMeta?: boolean | "preserve-unknown" | ImportMetaParserOptions;
 
 	/**
-	 * Enable/disable evaluating import.meta.webpackContext.
+	 * Deprecated in favor of "importMeta" object option with a "webpackContext" field. Enable/disable evaluating import.meta.webpackContext.
+	 * @deprecated
 	 */
 	importMetaContext?: boolean;
 
@@ -12616,6 +13296,11 @@ declare interface JavascriptParserOptions {
 	 */
 	strictExportPresence?: boolean;
 
+	/**
+	 * Specifies the behavior of constructs that break at runtime in strict mode (e.g. 'with', 'arguments.callee', assigning to read-only globals) when modules are emitted as ES module output.
+	 */
+	strictModeViolations?: false | "error" | "warn";
+
 	/**
 	 * Handle the this context correctly according to the spec for namespace objects.
 	 */
@@ -12657,11 +13342,21 @@ declare interface JavascriptParserOptions {
 	 */
 	url?: boolean | "relative";
 
+	/**
+	 * URL-referenced-asset default hint rules for this parser (JavaScript `new URL(...)`, CSS `url(...)`, HTML `<img src>` / `<link href>` / `<script src>`).
+	 */
+	urlHints?: UrlHintRule[];
+
 	/**
 	 * Disable or configure parsing of WebWorker syntax like new Worker() or navigator.serviceWorker.register().
 	 */
 	worker?: boolean | string[];
 
+	/**
+	 * Disable or configure parsing of Worklet syntax like context.audioWorklet.addModule() or CSS.paintWorklet.addModule().
+	 */
+	worklet?: boolean | string[];
+
 	/**
 	 * Enable warnings for partial dynamic dependencies.
 	 */
@@ -12906,6 +13601,11 @@ declare interface KnownAssetModuleBuildInfo {
 }
 declare interface KnownBuildInfo {
 	cacheable?: boolean;
+
+	/**
+	 * reasons why the module is not cacheable (e.g. paths of loaders that marked it)
+	 */
+	notCacheableReasons?: string[];
 	strict?: boolean;
 	moduleArgument?: string;
 	exportsArgument?: string;
@@ -12925,6 +13625,11 @@ declare interface KnownBuildInfo {
 	 * true when the module is part of a circular dependency chain
 	 */
 	isCircular?: boolean;
+
+	/**
+	 * module uses top-level `for await…of`, which can't be lowered to a generator
+	 */
+	usesTopLevelAwaitForOf?: boolean;
 }
 declare interface KnownBuildMeta {
 	exportsType?: "default" | "namespace" | "flagged" | "dynamic";
@@ -13023,7 +13728,7 @@ declare interface KnownHtmlModuleBuildInfo {
 	/**
 	 * entries collected from the document, grouped by kind
 	 */
-	htmlEntryScripts?: Record<string, EntryScriptInfo[]>;
+	htmlEntries?: Record<string, HtmlEntryInfo[]>;
 
 	/**
 	 * `../` per `<base href>` path segment, prepended to the auto-public-path undo path so a relative base doesn't misdirect bundled URLs
@@ -13323,6 +14028,7 @@ declare interface KnownStatsModule {
 	size?: number;
 	sizes?: Record<string, number>;
 	cacheable?: boolean;
+	notCacheableReasons?: string[];
 	built?: boolean;
 	codeGenerated?: boolean;
 	buildTimeExecuted?: boolean;
@@ -14533,10 +15239,6 @@ type Matcher =
 	| RegExp
 	| ((str: string) => boolean)
 	| (string | RegExp | ((str: string) => boolean))[];
-
-/**
- * Extract fragment index.
- */
 declare interface MaybeMergeableInitFragment<GenerateContext> {
 	key?: string;
 	stage: number;
@@ -14598,6 +15300,41 @@ declare interface MergeDuplicateChunksPluginOptions {
 	 */
 	stage?: number;
 }
+type MergedDefinitionNode =
+	| undefined
+	| null
+	| string
+	| number
+	| bigint
+	| boolean
+	| Function
+	| RegExp
+	| RuntimeValue
+	| {
+			[index: string]: RecursiveArrayOrRecord<
+				| undefined
+				| null
+				| string
+				| number
+				| bigint
+				| boolean
+				| Function
+				| RegExp
+				| RuntimeValue
+			>;
+	  }
+	| RecursiveArrayOrRecord<
+			| undefined
+			| null
+			| string
+			| number
+			| bigint
+			| boolean
+			| Function
+			| RegExp
+			| RuntimeValue
+	  >[]
+	| Map<string, MergedDefinitionNode>;
 type Meta = KnownMeta & Record<symbol, string[]> & Record<string, any>;
 declare class MinChunkSizePlugin {
 	/**
@@ -15310,6 +16047,7 @@ declare interface ModuleFederationPluginOptions {
 		| "umd2"
 		| "jsonp"
 		| "system"
+		| "amd-async"
 		| "promise"
 		| "module-import"
 		| "script"
@@ -16277,6 +17015,7 @@ declare class MultiCompiler {
 	compilers: Compiler[];
 	dependencies: WeakMap<Compiler, string[]>;
 	running: boolean;
+	watching?: MultiWatching;
 	get options(): WebpackOptionsNormalized[] & MultiCompilerOptions;
 	get outputPath(): string;
 
@@ -17756,9 +18495,9 @@ declare interface Optimization {
 		false | "natural" | "named" | "deterministic" | "size" | "total-size";
 
 	/**
-	 * Concatenate modules when possible to generate less modules, more efficient code and enable more optimizations by the minimizer.
+	 * Concatenate modules when possible to generate less modules, more efficient code and enable more optimizations by the minimizer. An options object implies 'true'.
 	 */
-	concatenateModules?: boolean;
+	concatenateModules?: boolean | ConcatenateModulesOptions;
 
 	/**
 	 * Emit assets even when errors occur. Critical errors are emitted into the generated code and will cause errors at runtime.
@@ -17906,9 +18645,9 @@ declare interface OptimizationNormalized {
 		false | "natural" | "named" | "deterministic" | "size" | "total-size";
 
 	/**
-	 * Concatenate modules when possible to generate less modules, more efficient code and enable more optimizations by the minimizer.
+	 * Concatenate modules when possible to generate less modules, more efficient code and enable more optimizations by the minimizer. An options object implies 'true'.
 	 */
-	concatenateModules?: boolean;
+	concatenateModules?: boolean | ConcatenateModulesOptions;
 
 	/**
 	 * Emit assets even when errors occur. Critical errors are emitted into the generated code and will cause errors at runtime.
@@ -18067,7 +18806,9 @@ type OptimizationNormalizedWithDefaults = OptimizationNormalized & {
 	mangleExports: NonNullable<undefined | boolean | "deterministic" | "size">;
 	innerGraph: NonNullable<undefined | boolean>;
 	inlineExports: NonNullable<undefined | boolean>;
-	concatenateModules: NonNullable<undefined | boolean>;
+	concatenateModules: NonNullable<
+		undefined | boolean | ConcatenateModulesOptions
+	>;
 	avoidEntryIife: NonNullable<undefined | boolean>;
 	emitOnErrors: NonNullable<undefined | boolean>;
 	checkWasmTypes: NonNullable<undefined | boolean>;
@@ -18667,6 +19408,26 @@ declare interface Output {
 	 */
 	publicPath?: string | TemplatePathFn<PathData>;
 
+	/**
+	 * Resource-hint (`<link rel="prefetch">` / `<link rel="preload">` / `<link rel="modulepreload">` / `<link rel="preconnect">`) emission for extracted HTML entries and URL-referenced assets. Accepts the initial-graph shorthand (boolean / `"prefetch"` / `"preload"` / `"none"` / `HtmlResourceHint[]` / function — equivalent to `{ initial: <value> }`) or the full object form `{ initial, urlHints, preconnect, modulePreloadPolyfill, manifest }`. `initial` defaults on for ESM output (`output.module`), where native `import()` would otherwise waterfall; classic output stays opt-in.
+	 */
+	resourceHints?:
+		| boolean
+		| "none"
+		| ResourceHintsOptions
+		| HtmlResourceHintWebpackOptions[]
+		| "prefetch"
+		| "preload"
+		| ((context: {
+				entryName: string;
+				entrypoint: Entrypoint;
+				hostType: "html" | "js";
+				compilation: Compilation;
+				defaultHints: (HtmlResourceHintHtmlEntryDependency & {
+					hostChunks: string[];
+				})[];
+		  }) => HtmlResourceHintHtmlEntryDependency[]);
+
 	/**
 	 * This option enables loading async chunks via a custom script type, such as script type="module".
 	 */
@@ -18718,6 +19479,11 @@ declare interface Output {
 	 */
 	wasmLoading?: string | false;
 
+	/**
+	 * Fall back to non-streaming WebAssembly instantiation when streaming compilation fails because the server does not serve `.wasm` files with the `application/wasm` MIME type.
+	 */
+	wasmStreamingFallback?: boolean;
+
 	/**
 	 * The filename of WebAssembly modules as relative path inside the 'output.path' directory.
 	 */
@@ -18788,10 +19554,155 @@ declare interface OutputFileSystem {
  * Options for the generated HTML files.
  */
 declare interface OutputHtmlOptions {
+	/**
+	 * Inject a `<base>` element into the page `<head>`. A string sets `href`; an object sets both `href` and optionally `target`. Skipped if the HTML already contains a `<base>` element.
+	 */
+	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;
+		  };
+
+	/**
+	 * Inject a `<meta http-equiv="Content-Security-Policy">` into every webpack-emitted HTML page. `false` (default) does nothing; `true` uses a strict baseline (`script-src 'self'`, `style-src 'self'`, `object-src 'none'`, `base-uri 'self'`) and appends a `sha256` hash of every inline `<script>`/`<style>` to `script-src`/`style-src`. An object customizes it. Skipped when the page already declares a CSP.
+	 */
+	csp?:
+		| boolean
+		| {
+				/**
+				 * Hash algorithm used for inline `<script>`/`<style>` sources.
+				 */
+				hashFunction?: "sha256" | "sha384" | "sha512";
+				/**
+				 * Placeholder nonce added to injected `<script>`/`<style>` tags and as a `'nonce-…'` source; rewrite it per request server-side.
+				 */
+				nonce?: string;
+				/**
+				 * CSP directives merged over the baseline. Each key is a directive (e.g. `"script-src"`); the value is a source string or list. Inline hashes and any `nonce` are still appended to `script-src`/`style-src`.
+				 */
+				policy?: { [index: string]: string | string[] };
+		  };
+
+	/**
+	 * Favicon(s) for webpack-generated HTML (authored pages are left untouched). `false` (default) injects nothing; `true` injects the webpack logo; a string is a path to an icon; an object maps each `<link rel>` to an icon — a path string, an object with the icon `href` plus extra link attributes (`sizes`, `media`, `color`, `type`, `crossorigin`), or an array of these for multiple icons under the same `rel` (e.g. several `sizes`, or light/dark `media` variants); a function receives the page name and returns one of these. Every icon is emitted as a hashed asset.
+	 */
+	favicon?:
+		| string
+		| boolean
+		| {
+				[index: string]:
+					| string
+					| {
+							/**
+							 * Value for the `color` attribute (used by `rel="mask-icon"`).
+							 */
+							color?: string;
+							/**
+							 * Value for the `crossorigin` attribute.
+							 */
+							crossorigin?: "anonymous" | "use-credentials";
+							/**
+							 * Path to the icon file, emitted as a hashed asset.
+							 */
+							href: string;
+							/**
+							 * Value for the `media` attribute (e.g. `"(prefers-color-scheme: dark)"`).
+							 */
+							media?: string;
+							/**
+							 * Value for the `sizes` attribute (e.g. `"180x180"` or `"any"`).
+							 */
+							sizes?: string;
+							/**
+							 * Value for the `type` attribute; inferred from the file extension when omitted.
+							 */
+							type?: string;
+					  }
+					| HtmlFaviconIcon[];
+		  }
+		| ((name: string) =>
+				| string
+				| boolean
+				| {
+						[index: string]:
+							| string
+							| {
+									/**
+									 * Value for the `color` attribute (used by `rel="mask-icon"`).
+									 */
+									color?: string;
+									/**
+									 * Value for the `crossorigin` attribute.
+									 */
+									crossorigin?: "anonymous" | "use-credentials";
+									/**
+									 * Path to the icon file, emitted as a hashed asset.
+									 */
+									href: string;
+									/**
+									 * Value for the `media` attribute (e.g. `"(prefers-color-scheme: dark)"`).
+									 */
+									media?: string;
+									/**
+									 * Value for the `sizes` attribute (e.g. `"180x180"` or `"any"`).
+									 */
+									sizes?: string;
+									/**
+									 * Value for the `type` attribute; inferred from the file extension when omitted.
+									 */
+									type?: string;
+							  }
+							| HtmlFaviconIcon[];
+				  });
+
+	/**
+	 * Where to place injected chunk `<script>`/`<link>` tags. `"body"` (default; `"head"` with `output.module`) keeps them next to the entry tag — end of `<body>` on generated pages; `"head"` moves them into `<head>`; `false` suppresses sibling-chunk injection (entry tags and resource hints remain).
+	 */
+	inject?: false | "body" | "head";
+
+	/**
+	 * Inline the content of matching chunks directly into the HTML instead of emitting a separate `<script>`/`<link>` tag. `true` inlines every chunk; `"script"` inlines only JavaScript, `"style"` only CSS; an array of `RegExp` patterns matches against the chunk name.
+	 */
+	inline?: boolean | "script" | "style" | RegExp[];
+
+	/**
+	 * Add Subresource Integrity (SRI) `integrity` attributes to injected `<script>`/`<link>` tags. `true` uses `['sha384']`; an array sets the hash algorithms; a function receives each referenced asset and returns the algorithms to use or `false` to skip it.
+	 */
+	integrity?:
+		| boolean
+		| string[]
+		| ((asset: { chunk: Chunk; filename: string }) => false | string[]);
+
+	/**
+	 * Web app manifest for webpack-generated HTML (authored pages are left untouched). `false` (default) injects nothing. A string is a path to an existing `.webmanifest` file to link. An object is the manifest contents — serialized, emitted as a hashed `.webmanifest` and linked with `<link rel="manifest">`; its `icons`/`screenshots` `src` paths resolve like any request and are emitted as hashed assets. A function receives the page name and returns one of these.
+	 */
+	manifest?:
+		| string
+		| false
+		| { [index: string]: any }
+		| ((name: string) => string | false | { [index: string]: any });
+
+	/**
+	 * Inject `<meta>` tags into the page `<head>`. Each key is the `name` attribute (or `"charset"` for a charset declaration); the value is the `content` string. Keys beginning with `og:` use the `property` attribute instead of `name`. A tag is skipped if the HTML already contains a meta with the same name.
+	 */
+	meta?: { [index: string]: string };
+
 	/**
 	 * How injected `<script>` tags load. `auto` (default) emits a module script for ES module output and `defer` otherwise; `defer` forces a deferred script; `blocking` emits a plain blocking script.
 	 */
 	scriptLoading?: "auto" | "defer" | "blocking";
+
+	/**
+	 * Sets the `<title>` of the generated HTML page. Skipped if the HTML already contains a `<title>` element.
+	 */
+	title?: string;
 }
 
 /**
@@ -19005,6 +19916,11 @@ declare interface OutputNormalized {
 	 */
 	publicPath?: string | TemplatePathFn<PathData>;
 
+	/**
+	 * Full resource-hint configuration.
+	 */
+	resourceHints?: ResourceHintsOptions;
+
 	/**
 	 * This option enables loading async chunks via a custom script type, such as script type="module".
 	 */
@@ -19051,6 +19967,11 @@ declare interface OutputNormalized {
 	 */
 	wasmLoading?: string | false;
 
+	/**
+	 * Fall back to non-streaming WebAssembly instantiation when streaming compilation fails because the server does not serve `.wasm` files with the `application/wasm` MIME type.
+	 */
+	wasmStreamingFallback?: boolean;
+
 	/**
 	 * The filename of WebAssembly modules as relative path inside the 'output.path' directory.
 	 */
@@ -19138,14 +20059,32 @@ declare interface ParseOptions {
 	locations?: boolean;
 	comments?: boolean;
 	ranges?: boolean;
-	semicolons?: boolean;
 	allowHashBang?: boolean;
 	allowReturnOutsideFunction?: boolean;
+
+	/**
+	 * internal: serve `range` lazily and skip acorn's location/range tracking
+	 */
+	lazyNodes?: boolean;
+
+	/**
+	 * internal: collect comments here without slicing their text eagerly
+	 */
+	lazyComments?: CommentJavascriptParser[];
+
+	/**
+	 * enable parsing of the import phase proposals (import defer / import source)
+	 */
+	importPhases?: boolean;
+
+	/**
+	 * internal: for `auto`, let the parser downgrade module->script in place instead of re-parsing
+	 */
+	moduleFallback?: boolean;
 }
 declare interface ParseResult {
 	ast: Program;
 	comments: CommentJavascriptParser[];
-	semicolons: Set<number>;
 }
 declare interface ParsedIdentifier {
 	/**
@@ -19627,6 +20566,7 @@ declare class ProgressPlugin {
 	percentBy: null | "entries" | "modules" | "dependencies";
 	progressBar:
 		| false
+		| "auto"
 		| Required<{
 				/**
 				 * Color used for the filled portion of the bar.
@@ -19636,7 +20576,13 @@ declare class ProgressPlugin {
 				 * Name shown before the progress bar.
 				 */
 				name?: string;
+				/**
+				 * Width of the progress bar in characters. Default: 25.
+				 */
+				width?: number;
 		  }>;
+	estimatedTime: boolean;
+	phaseTimings: boolean;
 
 	/**
 	 * Applies the plugin by registering its hooks on the compiler.
@@ -19653,18 +20599,7 @@ declare class ProgressPlugin {
 	static createDefaultHandler: (
 		profile: undefined | null | boolean,
 		logger: WebpackLogger,
-		progressBar?:
-			| false
-			| Required<{
-					/**
-					 * Color used for the filled portion of the bar.
-					 */
-					color?: string;
-					/**
-					 * Name shown before the progress bar.
-					 */
-					name?: string;
-			  }>
+		options?: DefaultHandlerOptions
 	) => (percentage: number, msg: string, ...args: string[]) => void;
 }
 type ProgressPluginArgument =
@@ -19695,6 +20630,11 @@ declare interface ProgressPluginOptions {
 	 */
 	entries?: boolean;
 
+	/**
+	 * Show estimated time remaining based on build progress. Default: false.
+	 */
+	estimatedTime?: boolean;
+
 	/**
 	 * Function that executes for every progress step.
 	 */
@@ -19715,16 +20655,22 @@ declare interface ProgressPluginOptions {
 	 */
 	percentBy?: null | "entries" | "modules" | "dependencies";
 
+	/**
+	 * Show a timing breakdown for each build phase when the build completes. Default: false.
+	 */
+	phaseTimings?: boolean;
+
 	/**
 	 * Collect profile data for progress steps. Default: false.
 	 */
 	profile?: null | boolean;
 
 	/**
-	 * Generate progress bar. Default: false.
+	 * Generate progress bar. `"auto"` enables it only for interactive terminals. Default: false.
 	 */
 	progressBar?:
 		| boolean
+		| "auto"
 		| {
 				/**
 				 * Color used for the filled portion of the bar.
@@ -19734,6 +20680,10 @@ declare interface ProgressPluginOptions {
 				 * Name shown before the progress bar.
 				 */
 				name?: string;
+				/**
+				 * Width of the progress bar in characters. Default: 25.
+				 */
+				width?: number;
 		  };
 }
 declare class ProvidePlugin {
@@ -19809,6 +20759,11 @@ type PureCondition =
 declare interface RawChunkGroupOptions {
 	preloadOrder?: number;
 	prefetchOrder?: number;
+
+	/**
+	 * preload only the chunk's CSS (`as="style"`), not its JS
+	 */
+	cssPreloadOrder?: number;
 	fetchPriority?: "auto" | "low" | "high";
 }
 type RawDevTool = string | false;
@@ -21667,6 +22622,50 @@ declare interface ResourceDataWithData {
 	context?: string;
 	data: ResourceSchemeData & Partial<ResolveRequest>;
 }
+
+/**
+ * Full resource-hint configuration.
+ */
+declare interface ResourceHintsOptions {
+	/**
+	 * 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).
+	 */
+	initial?:
+		| boolean
+		| "none"
+		| HtmlResourceHintWebpackOptions[]
+		| "prefetch"
+		| "preload"
+		| ((context: {
+				entryName: string;
+				entrypoint: Entrypoint;
+				hostType: "html" | "js";
+				compilation: Compilation;
+				defaultHints: (HtmlResourceHintHtmlEntryDependency & {
+					hostChunks: string[];
+				})[];
+		  }) => HtmlResourceHintHtmlEntryDependency[]);
+
+	/**
+	 * Emit a JSON manifest of the resolved resource hints for each entrypoint (the same descriptors as `stats.entrypoints[].resourceHints`) as an output asset at this path. Lets an SSR server inject the `<link>` tags itself without walking the chunk graph — webpack's analogue of Vite's `build.ssrManifest`. Empty when `initial` is `"none"`.
+	 */
+	manifest?: string;
+
+	/**
+	 * Inject a tiny inline `<script>` polyfill for `<link rel="modulepreload">` into extracted HTML pages. Defaults from the target's modulepreload support (`output.environment.modulePreload`) — `true` when the environment lacks native support, `false` when it has it. Set `false` to never inject (the `<link>` tags are still emitted but do nothing on browsers without support — useful under a strict CSP that forbids inline scripts).
+	 */
+	modulePreloadPolyfill?: boolean;
+
+	/**
+	 * Auto-emit `<link rel="preconnect">` for the origin of a cross-origin `output.publicPath` (the origin bundles and assets are served from) into extracted HTML entries and the resource-hint stats / manifest. Mirrors `output.crossOriginLoading`. No-op when `publicPath` is relative or `"auto"`.
+	 */
+	preconnect?: boolean;
+
+	/**
+	 * Project-wide URL-referenced-asset hint rules, applied as the base `urlHints` of every parser (JavaScript `new URL(...)`, CSS `url(...)`, HTML `<img src>` / `<link href>`). Parser-scoped `module.parser.<type>.urlHints` rules and per-URL magic comments still override these.
+	 */
+	urlHints?: UrlHintRule[];
+}
 declare interface ResourceSchemeData {
 	/**
 	 * mime type of the resource
@@ -22340,6 +23339,7 @@ declare abstract class RuntimeTemplate {
 	supportsLogicalAssignment(): boolean;
 	supportsArrowFunction(): boolean;
 	supportsAsyncFunction(): boolean;
+	supportsGenerator(): boolean;
 	supportsOptionalChaining(): boolean;
 	supportsSpread(): boolean;
 	supportsObjectHasOwn(): boolean;
@@ -22349,6 +23349,8 @@ declare abstract class RuntimeTemplate {
 	supportsBigIntLiteral(): boolean;
 	supportsDynamicImport(): boolean;
 	supportsEcmaScriptModuleSyntax(): boolean;
+	supportsModulePreload(): boolean;
+	supportsAnalyzableEsm(): boolean;
 	supportTemplateLiteral(): boolean;
 	supportNodePrefixForCoreModules(): boolean;
 
@@ -22692,6 +23694,10 @@ declare abstract class RuntimeTemplate {
 		 * if set, will be filled with runtime requirements
 		 */
 		runtimeRequirements: Set<string>;
+		/**
+		 * the module the `import()` is emitted into
+		 */
+		originModule?: Module;
 	}): string;
 
 	/**
@@ -22852,6 +23858,10 @@ declare abstract class RuntimeTemplate {
 		 * if set, will be filled with runtime requirements
 		 */
 		runtimeRequirements: Set<string>;
+		/**
+		 * the module the `import()` is emitted into
+		 */
+		originModule?: Module;
 	}): string;
 
 	/**
@@ -23491,6 +24501,9 @@ declare interface SourceAndMap {
 	 */
 	map: null | RawSourceMap;
 }
+declare interface SourceBucket {
+	[index: string]: undefined | SourceItem;
+}
 declare interface SourceItem {
 	type: SourceTypeOrResolver;
 	filter?: (attributes: Map<string, string>, value: string) => boolean;
@@ -23677,12 +24690,18 @@ declare interface SourcePosition {
 	line: number;
 	column?: number;
 }
+declare interface SourceTable {
+	[index: string]: SourceBucket;
+}
 type SourceType =
+	| "html"
 	| "script"
 	| "css-url"
 	| "stylesheet"
-	| "script-module"
+	| "prefetch"
+	| "preload"
 	| "modulepreload"
+	| "script-module"
 	| "src"
 	| "srcset"
 	| "stylesheet-style"
@@ -23690,11 +24709,14 @@ type SourceType =
 	| "srcdoc"
 	| "msapplication-task";
 type SourceTypeOrResolver =
+	| "html"
 	| "script"
 	| "css-url"
 	| "stylesheet"
-	| "script-module"
+	| "prefetch"
+	| "preload"
 	| "modulepreload"
+	| "script-module"
 	| "src"
 	| "srcset"
 	| "stylesheet-style"
@@ -23821,11 +24843,15 @@ declare abstract class StackEntry {
 
 /**
  * Layered map that supports child scopes while memoizing lookups from parent
- * scopes into the current layer.
+ * scopes. Layers form a linked parent chain, so `createChild` is O(1) instead
+ * of copying a layer array per scope. A layer's `Map` is only allocated on its
+ * first own write, and lookup results are memoized into the nearest
+ * `Map`-bearing layer of the walk — read-only layers (most block scopes) stay
+ * allocation-free and share their parent's memoized entries.
  */
 declare abstract class StackedMap<K, V> {
-	map: Map<K, InternalCell<V>>;
-	stack: Map<K, InternalCell<V>>[];
+	map?: Map<K, InternalCell<V>>;
+	parent?: StackedMap<K, V>;
 
 	/**
 	 * Stores a value in the current layer, preserving explicit `undefined`
@@ -23841,13 +24867,14 @@ declare abstract class StackedMap<K, V> {
 
 	/**
 	 * Checks whether a key exists in the current scope chain, caching any parent
-	 * lookup result in the current layer.
+	 * lookup result in the nearest `Map`-bearing layer.
 	 */
 	has(item: K): boolean;
 
 	/**
 	 * Returns the visible value for a key, caching parent hits and misses in the
-	 * current layer.
+	 * nearest `Map`-bearing layer so repeated lookups (from this layer or any
+	 * sibling below that layer) answer with a single probe.
 	 */
 	get(item: K): Cell<V>;
 
@@ -24361,6 +25388,11 @@ declare interface StatsOptions {
 	 */
 	chunkGroupMaxAssets?: number;
 
+	/**
+	 * Include the resolved `<link>` resource-hint descriptors for each entrypoint (`entrypoints[name].resourceHints`). Combines `output.resourceHints.chunks` (initial-graph modulepreload/preload/prefetch) with `output.resourceHints.assets` (URL-referenced fonts / images / …). Lets SSR frameworks inject the hints server-side without walking the chunk graph themselves; the analogue of Vite's `build.ssrManifest`.
+	 */
+	chunkGroupResourceHints?: boolean;
+
 	/**
 	 * Display all chunk groups with the corresponding bundles.
 	 */
@@ -25109,6 +26141,71 @@ declare interface UpdateHashContextGenerator {
 	runtime: RuntimeSpec;
 	runtimeTemplate?: RuntimeTemplate;
 }
+
+/**
+ * One default-hint rule for URL-referenced assets emitted by this parser (JS `new URL(...)`, CSS `url(...)`, HTML `<img src>` / `<link href>` / `<script src>`). `test` / `include` / `exclude` match against the asset's request; omit all three to apply to every asset. Matching rules set the same fields a `webpackPrefetch` / `webpackPreload` / `webpackAs` / `webpackType` / `webpackMedia` / `webpackFetchPriority` magic comment would; explicit magic comments on the same URL still win.
+ */
+declare interface UrlHintRule {
+	/**
+	 * Default `as` attribute (script / style / font / image / …).
+	 */
+	as?: string;
+
+	/**
+	 * A condition matcher.
+	 */
+	exclude?:
+		| string
+		| RegExp
+		| ((value: string) => boolean)
+		| RuleSetLogicalConditions
+		| RuleSetCondition[];
+
+	/**
+	 * Default fetchpriority for prefetch / preload links.
+	 */
+	fetchPriority?: false | "auto" | "low" | "high";
+
+	/**
+	 * A condition matcher.
+	 */
+	include?:
+		| string
+		| RegExp
+		| ((value: string) => boolean)
+		| RuleSetLogicalConditions
+		| RuleSetCondition[];
+
+	/**
+	 * Default `media` attribute (e.g. `"(min-width: 800px)"`).
+	 */
+	media?: string;
+
+	/**
+	 * When true, emit `<link rel="prefetch">` for matching assets without an explicit hint comment.
+	 */
+	prefetch?: boolean;
+
+	/**
+	 * When true, emit `<link rel="preload">` for matching assets without an explicit hint comment.
+	 */
+	preload?: boolean;
+
+	/**
+	 * A condition matcher.
+	 */
+	test?:
+		| string
+		| RegExp
+		| ((value: string) => boolean)
+		| RuleSetLogicalConditions
+		| RuleSetCondition[];
+
+	/**
+	 * Default `type` attribute (MIME).
+	 */
+	type?: string;
+}
 type Usage = string | true | TopLevelSymbol;
 type UsageStateType = 0 | 1 | 2 | 3 | 4;
 type UsedName = string | false | string[] | InlinedUsedName;
@@ -25852,6 +26949,7 @@ declare interface WebpackOptionsNormalized {
 		| "umd2"
 		| "jsonp"
 		| "system"
+		| "amd-async"
 		| "promise"
 		| "module-import"
 		| "script"
@@ -26025,6 +27123,7 @@ type WebpackOptionsNormalizedWithDefaults = WebpackOptionsNormalized & {
 		| "umd2"
 		| "jsonp"
 		| "system"
+		| "amd-async"
 		| "promise"
 		| "module-import"
 		| "script"
@@ -26290,12 +27389,15 @@ declare namespace exports {
 	export namespace RuntimeGlobals {
 		export let amdDefine: "__webpack_require__.amdD";
 		export let amdOptions: "__webpack_require__.amdO";
+		export let analyzableChunkImport: "__webpack_require__.ei";
 		export let asyncModule: "__webpack_require__.a";
 		export let asyncModuleDoneSymbol: "__webpack_require__.aD";
 		export let asyncModuleExportSymbol: "__webpack_require__.aE";
+		export let asyncModuleGenerator: "__webpack_require__.aG";
 		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 createFakeNamespaceObject: "__webpack_require__.t";
@@ -26323,6 +27425,7 @@ declare namespace exports {
 		export let getFullHash: "__webpack_require__.h";
 		export let getTrustedTypesPolicy: "__webpack_require__.tt";
 		export let getUpdateManifestFilename: "__webpack_require__.hmrF";
+		export let getWorkletBootstrap: "__webpack_require__.wb";
 		export let global: "__webpack_require__.g";
 		export let harmonyModuleDecorator: "__webpack_require__.hmd";
 		export let hasCssModules: "has css modules";
@@ -26348,8 +27451,10 @@ declare namespace exports {
 		export let moduleLoaded: "module.loaded";
 		export let nodeModuleDecorator: "__webpack_require__.nmd";
 		export let onChunksLoaded: "__webpack_require__.O";
+		export let prefetchAsset: "__webpack_require__.PA";
 		export let prefetchChunk: "__webpack_require__.E";
 		export let prefetchChunkHandlers: "__webpack_require__.F";
+		export let preloadAsset: "__webpack_require__.LA";
 		export let preloadChunk: "__webpack_require__.G";
 		export let preloadChunkHandlers: "__webpack_require__.H";
 		export let publicPath: "__webpack_require__.p";
@@ -26362,6 +27467,7 @@ declare namespace exports {
 		export let setAnonymousDefaultName: "__webpack_require__.dn";
 		export let shareScopeMap: "__webpack_require__.S";
 		export let startup: "__webpack_require__.x";
+		export let startupAssetHints: "__webpack_require__.SAH";
 		export let startupEntrypoint: "__webpack_require__.X";
 		export let startupNoDefault: "__webpack_require__.x (no default handler)";
 		export let startupOnlyAfter: "__webpack_require__.x (only after)";
@@ -26491,6 +27597,9 @@ declare namespace exports {
 	export namespace css {
 		export { CssModulesPlugin };
 	}
+	export namespace html {
+		export { HtmlModulesPlugin };
+	}
 	export namespace library {
 		export { AbstractLibraryPlugin, EnableLibraryPlugin };
 	}
@@ -26747,7 +27856,11 @@ declare namespace exports {
 		data: ExternalItemFunctionData,
 		callback: (
 			err?: null | Error,
-			result?: string | boolean | string[] | { [index: string]: any }
+			result?:
+				| string
+				| boolean
+				| string[]
+				| (ExternalItemValueObjectKnown & ExternalItemValueObjectUnknown)
 		) => void
 	) => void;
 	export type ExternalItemFunctionDataGetResolve = (