webpack 5.99.6 → 5.99.8

package/types.d.ts

@@ -1,7 +1,7 @@
 /*
  * This file was automatically generated.
  * DO NOT MODIFY BY HAND.
- * Run `yarn special-lint-fix` to update
+ * Run `yarn fix:special` to update
  */
 
 import { Buffer } from "buffer";
@@ -88,14 +88,15 @@ import {
 	YieldExpression
 } from "estree";
 import { IncomingMessage, ServerOptions } from "http";
+import {
+	Session as SessionImportInspectorClass_1,
+	Session as SessionImportInspectorClass_2
+} from "inspector";
 import { JSONSchema4, JSONSchema6, JSONSchema7 } from "json-schema";
 import { ListenOptions, Server } from "net";
 import { validate as validateFunction } from "schema-utils";
 import { default as ValidationError } from "schema-utils/declarations/ValidationError";
-import {
-	Extend,
-	ValidationErrorConfiguration
-} from "schema-utils/declarations/validate";
+import { ValidationErrorConfiguration } from "schema-utils/declarations/validate";
 import {
 	AsArray,
 	AsyncParallelHook,
@@ -227,7 +228,6 @@ declare interface AggressiveSplittingPluginOptions {
 	 */
 	minSize?: number;
 }
-type Algorithm = string | typeof Hash;
 type Alias = string | false | string[];
 declare interface AliasOption {
 	alias: Alias;
@@ -1962,8 +1962,8 @@ declare class Compilation {
 		needAdditionalPass: SyncBailHook<[], boolean | void>;
 		childCompiler: SyncHook<[Compiler, string, number]>;
 		log: SyncBailHook<[string, LogEntry], boolean | void>;
-		processWarnings: SyncWaterfallHook<[WebpackError[]]>;
-		processErrors: SyncWaterfallHook<[WebpackError[]]>;
+		processWarnings: SyncWaterfallHook<[Error[]]>;
+		processErrors: SyncWaterfallHook<[Error[]]>;
 		statsPreset: HookMap<
 			SyncHook<[Partial<NormalizedStatsOptions>, CreateStatsOptionsContext]>
 		>;
@@ -2030,8 +2030,8 @@ declare class Compilation {
 	additionalChunkAssets: string[];
 	assets: CompilationAssets;
 	assetsInfo: Map<string, AssetInfo>;
-	errors: WebpackError[];
-	warnings: WebpackError[];
+	errors: Error[];
+	warnings: Error[];
 	children: Compilation[];
 	logging: Map<string, LogEntry[]>;
 	dependencyFactories: Map<DepConstructor, ModuleFactory>;
@@ -2230,8 +2230,8 @@ declare class Compilation {
 		filename: TemplatePath,
 		data: PathData
 	): InterpolatedPathAndAssetInfo;
-	getWarnings(): WebpackError[];
-	getErrors(): WebpackError[];
+	getWarnings(): Error[];
+	getErrors(): Error[];
 
 	/**
 	 * This function allows you to run another instance of webpack inside of webpack however as
@@ -2643,7 +2643,6 @@ declare interface Configuration {
 	externals?:
 		| string
 		| RegExp
-		| ExternalItem[]
 		| (ExternalItemObjectKnown & ExternalItemObjectUnknown)
 		| ((
 				data: ExternalItemFunctionData,
@@ -2652,7 +2651,8 @@ declare interface Configuration {
 					result?: string | boolean | string[] | { [index: string]: any }
 				) => void
 		  ) => void)
-		| ((data: ExternalItemFunctionData) => Promise<ExternalItemValue>);
+		| ((data: ExternalItemFunctionData) => Promise<ExternalItemValue>)
+		| ExternalItem[];
 
 	/**
 	 * Enable presets of externals for specific targets.
@@ -2705,7 +2705,7 @@ declare interface Configuration {
 				 */
 				module?: RegExp;
 		  }
-		| ((warning: WebpackError, compilation: Compilation) => boolean)
+		| ((warning: Error, compilation: Compilation) => boolean)
 	)[];
 
 	/**
@@ -3175,6 +3175,17 @@ declare interface CssAutoParserOptions {
 	 */
 	url?: boolean;
 }
+declare interface CssData {
+	/**
+	 * whether export __esModule
+	 */
+	esModule: boolean;
+
+	/**
+	 * the css exports
+	 */
+	exports: Map<string, string>;
+}
 
 /**
  * Generator options for css modules.
@@ -3914,7 +3925,18 @@ declare interface Effect {
 	value: any;
 }
 declare interface EffectData {
-	[index: string]: any;
+	resource?: string;
+	realResource?: string;
+	resourceQuery?: string;
+	resourceFragment?: string;
+	scheme?: string;
+	assertions?: ImportAttributes;
+	mimetype?: string;
+	dependency: string;
+	descriptionData: Record<string, any>;
+	compiler?: string;
+	issuer: string;
+	issuerLayer: string;
 }
 declare class ElectronTargetPlugin {
 	constructor(context?: "main" | "preload" | "renderer");
@@ -4802,6 +4824,15 @@ type ExternalItem =
 			) => void
 	  ) => void)
 	| ((data: ExternalItemFunctionData) => Promise<ExternalItemValue>);
+type ExternalItemFunction =
+	| ((
+			data: ExternalItemFunctionData,
+			callback: (
+				err?: null | Error,
+				result?: string | boolean | string[] | { [index: string]: any }
+			) => void
+	  ) => void)
+	| ((data: ExternalItemFunctionData) => Promise<ExternalItemValue>);
 
 /**
  * Data object passed as argument when a function is set for 'externals'.
@@ -4906,7 +4937,6 @@ declare interface ExternalModuleInfo {
 type Externals =
 	| string
 	| RegExp
-	| ExternalItem[]
 	| (ExternalItemObjectKnown & ExternalItemObjectUnknown)
 	| ((
 			data: ExternalItemFunctionData,
@@ -4915,7 +4945,8 @@ type Externals =
 				result?: string | boolean | string[] | { [index: string]: any }
 			) => void
 	  ) => void)
-	| ((data: ExternalItemFunctionData) => Promise<ExternalItemValue>);
+	| ((data: ExternalItemFunctionData) => Promise<ExternalItemValue>)
+	| ExternalItem[];
 declare class ExternalsPlugin {
 	constructor(type: undefined | string, externals: Externals);
 	type?: string;
@@ -5859,7 +5890,11 @@ declare interface InfrastructureLogging {
 	/**
 	 * Stream used for logging output. Defaults to process.stderr. This option is only used when no custom console is provided.
 	 */
-	stream?: NodeJS.WritableStream;
+	stream?: NodeJS.WritableStream & {
+		isTTY?: boolean;
+		columns?: number;
+		rows?: number;
+	};
 }
 declare class InitFragment<GenerateContext> {
 	constructor(
@@ -5918,6 +5953,9 @@ declare interface InputFileSystem {
 	relative?: (from: string, to: string) => string;
 	dirname?: (dirname: string) => string;
 }
+declare interface Inspector {
+	Session: typeof SessionImportInspectorClass_1;
+}
 type IntermediateFileSystem = InputFileSystem &
 	OutputFileSystem &
 	IntermediateFileSystemExtras;
@@ -7595,6 +7633,23 @@ type JsonObjectTypes = { [index: string]: JsonValueTypes } & {
 		| JsonObjectTypes
 		| JsonValueTypes[];
 };
+
+/**
+ * Parser options for JSON modules.
+ */
+declare interface JsonParserOptions {
+	/**
+	 * The depth of json dependency flagged as `exportInfo`.
+	 */
+	exportsDepth?: number;
+
+	/**
+	 * Function to parser content and return JSON.
+	 */
+	parse?: (
+		input: string
+	) => null | string | number | boolean | Buffer | JsonObjectFs | JsonValueFs[];
+}
 type JsonValueFs =
 	| null
 	| string
@@ -7714,19 +7769,97 @@ declare interface KnownAssetInfo {
 declare interface KnownBuildInfo {
 	cacheable?: boolean;
 	parsed?: boolean;
+	strict?: boolean;
+
+	/**
+	 * using in AMD
+	 */
 	moduleArgument?: string;
+
+	/**
+	 * using in AMD
+	 */
 	exportsArgument?: string;
-	strict?: boolean;
+
+	/**
+	 * using in CommonJs
+	 */
 	moduleConcatenationBailout?: string;
+
+	/**
+	 * using in APIPlugin
+	 */
+	needCreateRequire?: boolean;
+
+	/**
+	 * using in HttpUriPlugin
+	 */
+	resourceIntegrity?: string;
+
+	/**
+	 * using in NormalModule
+	 */
 	fileDependencies?: LazySet<string>;
+
+	/**
+	 * using in NormalModule
+	 */
 	contextDependencies?: LazySet<string>;
+
+	/**
+	 * using in NormalModule
+	 */
 	missingDependencies?: LazySet<string>;
+
+	/**
+	 * using in NormalModule
+	 */
 	buildDependencies?: LazySet<string>;
+
+	/**
+	 * using in NormalModule
+	 */
 	valueDependencies?: Map<string, string | Set<string>>;
-	hash?: any;
+
+	/**
+	 * using in NormalModule
+	 */
 	assets?: Record<string, Source>;
-	assetsInfo?: Map<string, undefined | AssetInfo>;
+
+	/**
+	 * using in NormalModule
+	 */
+	hash?: string;
+
+	/**
+	 * using in ContextModule
+	 */
 	snapshot?: null | Snapshot;
+
+	/**
+	 * for assets modules
+	 */
+	fullContentHash?: string;
+
+	/**
+	 * for assets modules
+	 */
+	filename?: string;
+
+	/**
+	 * for assets modules
+	 */
+	assetsInfo?: Map<string, undefined | AssetInfo>;
+
+	/**
+	 * for assets modules
+	 */
+	dataUrl?: boolean;
+
+	/**
+	 * for css modules
+	 */
+	cssData?: CssData;
 }
 declare interface KnownBuildMeta {
 	exportsType?: "namespace" | "dynamic" | "default" | "flagged";
@@ -7903,6 +8036,8 @@ declare interface KnownStatsError {
 	moduleTrace?: StatsModuleTraceItem[];
 	details?: string;
 	stack?: string;
+	cause?: KnownStatsError;
+	errors?: KnownStatsError[];
 	compilerPath?: string;
 }
 declare interface KnownStatsFactoryContext {
@@ -8571,7 +8706,7 @@ declare interface LoaderRunnerLoaderContext<OptionsType> {
 	async(): (
 		err?: null | Error,
 		content?: string | Buffer,
-		sourceMap?: string | SourceMap,
+		sourceMap?: null | string | SourceMap,
 		additionalData?: AdditionalData
 	) => void;
 
@@ -8585,7 +8720,7 @@ declare interface LoaderRunnerLoaderContext<OptionsType> {
 	callback: (
 		err?: null | Error,
 		content?: string | Buffer,
-		sourceMap?: string | SourceMap,
+		sourceMap?: null | string | SourceMap,
 		additionalData?: AdditionalData
 	) => void;
 
@@ -9493,7 +9628,11 @@ declare interface ModuleOptions {
 	/**
 	 * Don't parse files matching. It's matched against the full resolved request.
 	 */
-	noParse?: string | Function | RegExp | (string | Function | RegExp)[];
+	noParse?:
+		| string
+		| RegExp
+		| (string | RegExp | ((content: string) => boolean))[]
+		| ((content: string) => boolean);
 
 	/**
 	 * Specify options for each parser.
@@ -9538,7 +9677,7 @@ declare interface ModuleOptions {
 	/**
 	 * Cache the resolving of module requests.
 	 */
-	unsafeCache?: boolean | Function;
+	unsafeCache?: boolean | ((module: Module) => boolean);
 
 	/**
 	 * Enable warnings for partial dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.wrappedContextCritical'.
@@ -9573,7 +9712,11 @@ declare interface ModuleOptionsNormalized {
 	/**
 	 * Don't parse files matching. It's matched against the full resolved request.
 	 */
-	noParse?: string | Function | RegExp | (string | Function | RegExp)[];
+	noParse?:
+		| string
+		| RegExp
+		| (string | RegExp | ((content: string) => boolean))[]
+		| ((content: string) => boolean);
 
 	/**
 	 * Specify options for each parser.
@@ -9588,7 +9731,7 @@ declare interface ModuleOptionsNormalized {
 	/**
 	 * Cache the resolving of module requests.
 	 */
-	unsafeCache?: boolean | Function;
+	unsafeCache?: boolean | ((module: Module) => boolean);
 }
 declare interface ModulePathData {
 	id: string | number;
@@ -9885,6 +10028,11 @@ declare class NoEmitOnErrorsPlugin {
 	 */
 	apply(compiler: Compiler): void;
 }
+type NoParse =
+	| string
+	| RegExp
+	| (string | RegExp | ((content: string) => boolean))[]
+	| ((content: string) => boolean);
 type Node = false | NodeOptions;
 declare class NodeEnvironmentPlugin {
 	constructor(options: NodeEnvironmentPluginOptions);
@@ -9989,8 +10137,16 @@ declare class NormalModule extends Module {
 		associatedObjectForCache?: object
 	): Source;
 	markModuleAsErrored(error: WebpackError): void;
-	applyNoParseRule(rule: any, content: string): boolean;
-	shouldPreventParsing(noParseRule: any, request: string): boolean;
+	applyNoParseRule(rule: Exclude<NoParse, any[]>, content: string): boolean;
+	shouldPreventParsing(
+		noParseRule:
+			| undefined
+			| string
+			| RegExp
+			| (string | RegExp | ((content: string) => boolean))[]
+			| ((content: string) => boolean),
+		request: string
+	): boolean;
 	static getCompilationHooks(
 		compilation: Compilation
 	): NormalModuleCompilationHooks;
@@ -10515,7 +10671,154 @@ declare interface Optimization {
 				/**
 				 * The name or name factory for the runtime chunks.
 				 */
-				name?: string | Function;
+				name?: string | ((entrypoint: { name: string }) => string);
+		  };
+
+	/**
+	 * Skip over modules which contain no side effects when exports are not used (false: disabled, 'flag': only use manually placed side effects flag, true: also analyse source code for side effects).
+	 */
+	sideEffects?: boolean | "flag";
+
+	/**
+	 * Optimize duplication and caching by splitting chunks by shared modules and cache group.
+	 */
+	splitChunks?: false | OptimizationSplitChunksOptions;
+
+	/**
+	 * Figure out which exports are used by modules to mangle export names, omit unused exports and generate more efficient code (true: analyse used exports for each runtime, "global": analyse exports globally for all runtimes combined).
+	 */
+	usedExports?: boolean | "global";
+}
+
+/**
+ * Enables/Disables integrated optimizations.
+ */
+declare interface OptimizationNormalized {
+	/**
+	 * Avoid wrapping the entry module in an IIFE.
+	 */
+	avoidEntryIife?: boolean;
+
+	/**
+	 * Check for incompatible wasm types when importing/exporting from/to ESM.
+	 */
+	checkWasmTypes?: boolean;
+
+	/**
+	 * Define the algorithm to choose chunk ids (named: readable ids for better debugging, deterministic: numeric hash ids for better long term caching, size: numeric ids focused on minimal initial download size, total-size: numeric ids focused on minimal total download size, false: no algorithm used, as custom one can be provided via plugin).
+	 */
+	chunkIds?:
+		| 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.
+	 */
+	concatenateModules?: boolean;
+
+	/**
+	 * Emit assets even when errors occur. Critical errors are emitted into the generated code and will cause errors at runtime.
+	 */
+	emitOnErrors?: boolean;
+
+	/**
+	 * Also flag chunks as loaded which contain a subset of the modules.
+	 */
+	flagIncludedChunks?: boolean;
+
+	/**
+	 * Creates a module-internal dependency graph for top level symbols, exports and imports, to improve unused exports detection.
+	 */
+	innerGraph?: boolean;
+
+	/**
+	 * Rename exports when possible to generate shorter code (depends on optimization.usedExports and optimization.providedExports, true/"deterministic": generate short deterministic names optimized for caching, "size": generate the shortest possible names).
+	 */
+	mangleExports?: boolean | "deterministic" | "size";
+
+	/**
+	 * Reduce size of WASM by changing imports to shorter strings.
+	 */
+	mangleWasmImports?: boolean;
+
+	/**
+	 * Merge chunks which contain the same modules.
+	 */
+	mergeDuplicateChunks?: boolean;
+
+	/**
+	 * Enable minimizing the output. Uses optimization.minimizer.
+	 */
+	minimize?: boolean;
+
+	/**
+	 * Minimizer(s) to use for minimizing the output.
+	 */
+	minimizer?: (
+		| undefined
+		| null
+		| false
+		| ""
+		| 0
+		| ((this: Compiler, compiler: Compiler) => void)
+		| WebpackPluginInstance
+		| "..."
+	)[];
+
+	/**
+	 * Define the algorithm to choose module ids (natural: numeric ids in order of usage, named: readable ids for better debugging, hashed: (deprecated) short hashes as ids for better long term caching, deterministic: numeric hash ids for better long term caching, size: numeric ids focused on minimal initial download size, false: no algorithm used, as custom one can be provided via plugin).
+	 */
+	moduleIds?: false | "natural" | "named" | "deterministic" | "size" | "hashed";
+
+	/**
+	 * Avoid emitting assets when errors occur (deprecated: use 'emitOnErrors' instead).
+	 */
+	noEmitOnErrors?: boolean;
+
+	/**
+	 * Set process.env.NODE_ENV to a specific value.
+	 */
+	nodeEnv?: string | false;
+
+	/**
+	 * Generate records with relative paths to be able to move the context folder.
+	 */
+	portableRecords?: boolean;
+
+	/**
+	 * Figure out which exports are provided by modules to generate more efficient code.
+	 */
+	providedExports?: boolean;
+
+	/**
+	 * Use real [contenthash] based on final content of the assets.
+	 */
+	realContentHash?: boolean;
+
+	/**
+	 * Removes modules from chunks when these modules are already included in all parents.
+	 */
+	removeAvailableModules?: boolean;
+
+	/**
+	 * Remove chunks which are empty.
+	 */
+	removeEmptyChunks?: boolean;
+
+	/**
+	 * Create an additional chunk which contains only the webpack runtime and chunk hash maps.
+	 */
+	runtimeChunk?:
+		| false
+		| {
+				/**
+				 * The name factory for the runtime chunks.
+				 */
+				name?: (entrypoint: { name: string }) => string;
 		  };
 
 	/**
@@ -10671,8 +10974,13 @@ declare interface OptimizationSplitChunksOptions {
 		[index: string]:
 			| string
 			| false
-			| Function
 			| RegExp
+			| ((
+					module: Module
+			  ) =>
+					| void
+					| OptimizationSplitChunksCacheGroup
+					| OptimizationSplitChunksCacheGroup[])
 			| OptimizationSplitChunksCacheGroup;
 	};
 
@@ -11499,6 +11807,11 @@ declare interface ParserOptionsByModuleTypeKnown {
 	 * Parser options for javascript modules.
 	 */
 	"javascript/esm"?: JavascriptParserOptions;
+
+	/**
+	 * Parser options for JSON modules.
+	 */
+	json?: JsonParserOptions;
 }
 
 /**
@@ -11550,7 +11863,7 @@ declare interface PerformanceOptions {
 	/**
 	 * Filter function to select assets that are checked.
 	 */
-	assetFilter?: Function;
+	assetFilter?: (name: string, source: Source, assetInfo: AssetInfo) => boolean;
 
 	/**
 	 * Sets the format of the hints: warnings, errors or nothing at all.
@@ -11677,12 +11990,12 @@ declare interface ProcessAssetsAdditionalOptions {
 	additionalAssets?: any;
 }
 declare class Profiler {
-	constructor(inspector?: any);
-	session: any;
-	inspector: any;
+	constructor(inspector: Inspector);
+	session?: SessionImportInspectorClass_2;
+	inspector: Inspector;
 	hasSession(): boolean;
 	startProfiling(): Promise<void> | Promise<[any, any, any]>;
-	sendCommand(method: string, params?: Record<string, any>): Promise<any>;
+	sendCommand(method: string, params?: object): Promise<any>;
 	destroy(): Promise<void>;
 	stopProfiling(): Promise<{ profile: any }>;
 }
@@ -13259,12 +13572,19 @@ declare interface ResourceDataWithData {
 	data: Record<string, any>;
 }
 declare abstract class RestoreProvidedData {
-	exports: any[];
+	exports: RestoreProvidedDataExports[];
 	otherProvided?: null | boolean;
 	otherCanMangleProvide?: boolean;
 	otherTerminalBinding: boolean;
 	serialize(__0: ObjectSerializerContext): void;
 }
+declare interface RestoreProvidedDataExports {
+	name: string;
+	provided?: null | boolean;
+	canMangleProvide?: boolean;
+	terminalBinding: boolean;
+	exportsInfo?: RestoreProvidedData;
+}
 declare interface RmDirOptions {
 	maxRetries?: number;
 	recursive?: boolean;
@@ -13573,6 +13893,7 @@ declare interface RuleSetRule {
 				| string
 				| false
 				| 0
+				| RuleSetUseFunction
 				| {
 						/**
 						 * Unique loader options identifier.
@@ -13587,32 +13908,8 @@ declare interface RuleSetRule {
 						 */
 						options?: string | { [index: string]: any };
 				  }
-				| ((data: object) =>
-						| string
-						| {
-								/**
-								 * Unique loader options identifier.
-								 */
-								ident?: string;
-								/**
-								 * Loader name.
-								 */
-								loader?: string;
-								/**
-								 * Loader options.
-								 */
-								options?: string | { [index: string]: any };
-						  }
-						| __TypeWebpackOptions
-						| __Type_2[])
 		  )[]
-		| ((data: {
-				resource: string;
-				realResource: string;
-				resourceQuery: string;
-				issuer: string;
-				compiler: string;
-		  }) => __Type_2[])
+		| RuleSetUseFunction
 		| {
 				/**
 				 * Unique loader options identifier.
@@ -13626,8 +13923,7 @@ declare interface RuleSetRule {
 				 * Loader options.
 				 */
 				options?: string | { [index: string]: any };
-		  }
-		| __TypeWebpackOptions;
+		  };
 
 	/**
 	 * Match on import attributes of the dependency.
@@ -13642,6 +13938,7 @@ type RuleSetUse =
 			| string
 			| false
 			| 0
+			| RuleSetUseFunction
 			| {
 					/**
 					 * Unique loader options identifier.
@@ -13656,32 +13953,25 @@ type RuleSetUse =
 					 */
 					options?: string | { [index: string]: any };
 			  }
-			| ((data: object) =>
-					| string
-					| {
-							/**
-							 * Unique loader options identifier.
-							 */
-							ident?: string;
-							/**
-							 * Loader name.
-							 */
-							loader?: string;
-							/**
-							 * Loader options.
-							 */
-							options?: string | { [index: string]: any };
-					  }
-					| __TypeWebpackOptions
-					| __Type_2[])
 	  )[]
-	| ((data: {
-			resource: string;
-			realResource: string;
-			resourceQuery: string;
-			issuer: string;
-			compiler: string;
-	  }) => __Type_2[])
+	| RuleSetUseFunction
+	| {
+			/**
+			 * Unique loader options identifier.
+			 */
+			ident?: string;
+			/**
+			 * Loader name.
+			 */
+			loader?: string;
+			/**
+			 * Loader options.
+			 */
+			options?: string | { [index: string]: any };
+	  };
+type RuleSetUseFunction = (data: EffectData) =>
+	| string
+	| RuleSetUseFunction
 	| {
 			/**
 			 * Unique loader options identifier.
@@ -13696,9 +13986,31 @@ type RuleSetUse =
 			 */
 			options?: string | { [index: string]: any };
 	  }
-	| __TypeWebpackOptions;
+	| (
+			| undefined
+			| null
+			| string
+			| false
+			| 0
+			| RuleSetUseFunction
+			| {
+					/**
+					 * Unique loader options identifier.
+					 */
+					ident?: string;
+					/**
+					 * Loader name.
+					 */
+					loader?: string;
+					/**
+					 * Loader options.
+					 */
+					options?: string | { [index: string]: any };
+			  }
+	  )[];
 type RuleSetUseItem =
 	| string
+	| RuleSetUseFunction
 	| {
 			/**
 			 * Unique loader options identifier.
@@ -13712,18 +14024,18 @@ type RuleSetUseItem =
 			 * Loader options.
 			 */
 			options?: string | { [index: string]: any };
-	  }
-	| __TypeWebpackOptions;
+	  };
 declare interface RunCallback<T> {
 	(err: null | Error, result?: T): any;
 }
 declare class RuntimeChunkPlugin {
-	constructor(options: { name?: (entrypoint: { name: string }) => string });
-	options: {
-		name:
-			| ((entrypoint: { name: string }) => string)
-			| ((entrypoint: Entrypoint) => string);
-	};
+	constructor(options?: {
+		/**
+		 * The name factory for the runtime chunks.
+		 */
+		name?: (entrypoint: { name: string }) => string;
+	});
+	options: { name: (entrypoint: { name: string }) => string };
 
 	/**
 	 * Apply the plugin
@@ -15096,11 +15408,21 @@ declare interface StatsOptions {
 	 */
 	env?: boolean;
 
+	/**
+	 * Add cause to errors.
+	 */
+	errorCause?: boolean | "auto";
+
 	/**
 	 * Add details to errors (like resolving log).
 	 */
 	errorDetails?: boolean | "auto";
 
+	/**
+	 * Add nested errors to errors (like in AggregateError).
+	 */
+	errorErrors?: boolean | "auto";
+
 	/**
 	 * Add internal stack trace to errors.
 	 */
@@ -15778,7 +16100,7 @@ declare class WebpackError extends Error {
 	/**
 	 * Creates an instance of WebpackError.
 	 */
-	constructor(message?: string);
+	constructor(message?: string, options?: { cause?: unknown });
 	[index: number]: () => string;
 	details?: string;
 	module?: null | Module;
@@ -15788,22 +16110,59 @@ declare class WebpackError extends Error {
 	file?: string;
 	serialize(__0: ObjectSerializerContext): void;
 	deserialize(__0: ObjectDeserializerContext): void;
-
-	/**
-	 * Create .stack property on a target object
+	cause: any;
+
+	/**
+	 * Creates a `.stack` property on `targetObject`, which when accessed returns
+	 * a string representing the location in the code at which
+	 * `Error.captureStackTrace()` was called.
+	 * ```js
+	 * const myObject = {};
+	 * Error.captureStackTrace(myObject);
+	 * myObject.stack;  // Similar to `new Error().stack`
+	 * ```
+	 * The first line of the trace will be prefixed with
+	 * `${myObject.name}: ${myObject.message}`.
+	 * The optional `constructorOpt` argument accepts a function. If given, all frames
+	 * above `constructorOpt`, including `constructorOpt`, will be omitted from the
+	 * generated stack trace.
+	 * The `constructorOpt` argument is useful for hiding implementation
+	 * details of error generation from the user. For instance:
+	 * ```js
+	 * function a() {
+	 *   b();
+	 * }
+	 * function b() {
+	 *   c();
+	 * }
+	 * function c() {
+	 *   // Create an error without stack trace to avoid calculating the stack trace twice.
+	 *   const { stackTraceLimit } = Error;
+	 *   Error.stackTraceLimit = 0;
+	 *   const error = new Error();
+	 *   Error.stackTraceLimit = stackTraceLimit;
+	 *   // Capture the stack trace above function b
+	 *   Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
+	 *   throw error;
+	 * }
+	 * a();
+	 * ```
 	 */
 	static captureStackTrace(
 		targetObject: object,
 		constructorOpt?: Function
 	): void;
+	static prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
 
 	/**
-	 * Optional override for formatting stack traces
+	 * The `Error.stackTraceLimit` property specifies the number of stack frames
+	 * collected by a stack trace (whether generated by `new Error().stack` or
+	 * `Error.captureStackTrace(obj)`).
+	 * The default value is `10` but may be set to any valid JavaScript number. Changes
+	 * will affect any stack trace captured _after_ the value has been changed.
+	 * If set to a non-number value, or set to a negative number, stack traces will
+	 * not capture any frames.
 	 */
-	static prepareStackTrace?: (
-		err: Error,
-		stackTraces: NodeJS.CallSite[]
-	) => any;
 	static stackTraceLimit: number;
 }
 declare abstract class WebpackLogger {
@@ -15925,10 +16284,7 @@ declare interface WebpackOptionsNormalized {
 	/**
 	 * Ignore specific warnings.
 	 */
-	ignoreWarnings?: ((
-		warning: WebpackError,
-		compilation: Compilation
-	) => boolean)[];
+	ignoreWarnings?: ((warning: Error, compilation: Compilation) => boolean)[];
 
 	/**
 	 * Options for infrastructure level logging.
@@ -15963,7 +16319,7 @@ declare interface WebpackOptionsNormalized {
 	/**
 	 * Enables/Disables integrated optimizations.
 	 */
-	optimization: Optimization;
+	optimization: OptimizationNormalized;
 
 	/**
 	 * Normalized options affecting the output of the compilation. `output` options tell webpack how to write the compiled files to disk.
@@ -16154,62 +16510,6 @@ declare interface WriteStreamOptions {
 	signal?: null | AbortSignal;
 	fs?: null | CreateWriteStreamFSImplementation;
 }
-type __TypeWebpackOptions = (data: object) =>
-	| string
-	| {
-			/**
-			 * Unique loader options identifier.
-			 */
-			ident?: string;
-			/**
-			 * Loader name.
-			 */
-			loader?: string;
-			/**
-			 * Loader options.
-			 */
-			options?: string | { [index: string]: any };
-	  }
-	| __TypeWebpackOptions
-	| __Type_2[];
-type __Type_2 =
-	| undefined
-	| null
-	| string
-	| false
-	| 0
-	| {
-			/**
-			 * Unique loader options identifier.
-			 */
-			ident?: string;
-			/**
-			 * Loader name.
-			 */
-			loader?: string;
-			/**
-			 * Loader options.
-			 */
-			options?: string | { [index: string]: any };
-	  }
-	| ((data: object) =>
-			| string
-			| {
-					/**
-					 * Unique loader options identifier.
-					 */
-					ident?: string;
-					/**
-					 * Loader name.
-					 */
-					loader?: string;
-					/**
-					 * Loader options.
-					 */
-					options?: string | { [index: string]: any };
-			  }
-			| __TypeWebpackOptions
-			| __Type_2[]);
 declare function exports(
 	options: Configuration,
 	callback?: CallbackWebpack<Stats>
@@ -16238,42 +16538,39 @@ declare namespace exports {
 	export namespace cli {
 		export let getArguments: (
 			schema?:
-				| (JSONSchema4 &
-						Extend & {
-							absolutePath: boolean;
-							instanceof: string;
-							cli: {
-								helper?: boolean;
-								exclude?: boolean;
-								description?: string;
-								negatedDescription?: string;
-								resetDescription?: string;
-							};
-						})
-				| (JSONSchema6 &
-						Extend & {
-							absolutePath: boolean;
-							instanceof: string;
-							cli: {
-								helper?: boolean;
-								exclude?: boolean;
-								description?: string;
-								negatedDescription?: string;
-								resetDescription?: string;
-							};
-						})
-				| (JSONSchema7 &
-						Extend & {
-							absolutePath: boolean;
-							instanceof: string;
-							cli: {
-								helper?: boolean;
-								exclude?: boolean;
-								description?: string;
-								negatedDescription?: string;
-								resetDescription?: string;
-							};
-						})
+				| (JSONSchema4 & {
+						absolutePath: boolean;
+						instanceof: string;
+						cli: {
+							helper?: boolean;
+							exclude?: boolean;
+							description?: string;
+							negatedDescription?: string;
+							resetDescription?: string;
+						};
+				  })
+				| (JSONSchema6 & {
+						absolutePath: boolean;
+						instanceof: string;
+						cli: {
+							helper?: boolean;
+							exclude?: boolean;
+							description?: string;
+							negatedDescription?: string;
+							resetDescription?: string;
+						};
+				  })
+				| (JSONSchema7 & {
+						absolutePath: boolean;
+						instanceof: string;
+						cli: {
+							helper?: boolean;
+							exclude?: boolean;
+							description?: string;
+							negatedDescription?: string;
+							resetDescription?: string;
+						};
+				  })
 		) => Flags;
 		export let processArguments: (
 			args: Flags,
@@ -16306,7 +16603,10 @@ declare namespace exports {
 		export let REGEXP_NAMESPACE: RegExp;
 		export let createFilename: (
 			module: string | Module,
-			options: { namespace?: string; moduleFilenameTemplate?: any },
+			options: {
+				namespace?: string;
+				moduleFilenameTemplate?: string | ((context?: any) => string);
+			},
 			__2: {
 				requestShortener: RequestShortener;
 				chunkGraph: ChunkGraph;
@@ -16577,7 +16877,7 @@ declare namespace exports {
 		export { ProfilingPlugin };
 	}
 	export namespace util {
-		export const createHash: (algorithm: Algorithm) => Hash;
+		export const createHash: (algorithm: HashFunction) => Hash;
 		export namespace comparators {
 			export let compareChunksById: (a: Chunk, b: Chunk) => 0 | 1 | -1;
 			export let compareModulesByIdentifier: (
@@ -16744,6 +17044,81 @@ declare namespace exports {
 			export { SyncModuleIdsPlugin };
 		}
 	}
+	export type ExternalItemFunctionCallback = (
+		data: ExternalItemFunctionData,
+		callback: (
+			err?: null | Error,
+			result?: string | boolean | string[] | { [index: string]: any }
+		) => void
+	) => void;
+	export type ExternalItemFunctionDataGetResolve = (
+		options?: ResolveOptions
+	) =>
+		| ((
+				context: string,
+				request: string,
+				callback: (
+					err?: null | Error,
+					result?: string | false,
+					resolveRequest?: ResolveRequest
+				) => void
+		  ) => void)
+		| ((context: string, request: string) => Promise<string>);
+	export type ExternalItemFunctionDataGetResolveCallbackResult = (
+		context: string,
+		request: string,
+		callback: (
+			err?: null | Error,
+			result?: string | false,
+			resolveRequest?: ResolveRequest
+		) => void
+	) => void;
+	export type ExternalItemFunctionDataGetResolveResult = (
+		context: string,
+		request: string
+	) => Promise<string>;
+	export type ExternalItemFunctionPromise = (
+		data: ExternalItemFunctionData
+	) => Promise<ExternalItemValue>;
+	export type RuleSetUseFunction = (data: EffectData) =>
+		| string
+		| RuleSetUseFunction
+		| {
+				/**
+				 * Unique loader options identifier.
+				 */
+				ident?: string;
+				/**
+				 * Loader name.
+				 */
+				loader?: string;
+				/**
+				 * Loader options.
+				 */
+				options?: string | { [index: string]: any };
+		  }
+		| (
+				| undefined
+				| null
+				| string
+				| false
+				| 0
+				| RuleSetUseFunction
+				| {
+						/**
+						 * Unique loader options identifier.
+						 */
+						ident?: string;
+						/**
+						 * Loader name.
+						 */
+						loader?: string;
+						/**
+						 * Loader options.
+						 */
+						options?: string | { [index: string]: any };
+				  }
+		  )[];
 	export type WebpackPluginFunction = (
 		this: Compiler,
 		compiler: Compiler
@@ -16810,15 +17185,19 @@ declare namespace exports {
 		Entry,
 		EntryNormalized,
 		EntryObject,
+		ExternalItem,
+		ExternalItemFunction,
 		ExternalItemFunctionData,
 		ExternalItemObjectKnown,
 		ExternalItemObjectUnknown,
 		ExternalItemValue,
 		Externals,
 		FileCacheOptions,
+		GeneratorOptionsByModuleTypeKnown,
 		LibraryOptions,
 		MemoryCacheOptions,
 		ModuleOptions,
+		ParserOptionsByModuleTypeKnown,
 		ResolveOptions,
 		RuleSetCondition,
 		RuleSetConditionAbsolute,
@@ -16835,6 +17214,7 @@ declare namespace exports {
 		EntryOptions,
 		PathData,
 		AssetEmittedInfo,
+		Entrypoint,
 		MultiCompilerOptions,
 		MultiStats,
 		ResolveData,