webpack 5.5.1 → 5.9.0

package/types.d.ts

@@ -271,7 +271,7 @@ declare interface AssetInfo {
 }
 type AssetModuleFilename =
 	| string
-	| ((pathData: PathData, assetInfo: AssetInfo) => string);
+	| ((pathData: PathData, assetInfo?: AssetInfo) => string);
 declare abstract class AsyncDependenciesBlock extends DependenciesBlock {
 	groupOptions: {
 		preloadOrder?: number;
@@ -296,10 +296,10 @@ declare abstract class AsyncDependenciesBlock extends DependenciesBlock {
 declare abstract class AsyncQueue<T, K, R> {
 	hooks: {
 		beforeAdd: AsyncSeriesHook<[T]>;
-		added: SyncHook<[T], void>;
+		added: SyncHook<[T]>;
 		beforeStart: AsyncSeriesHook<[T]>;
-		started: SyncHook<[T], void>;
-		result: SyncHook<[T, Error, R], void>;
+		started: SyncHook<[T]>;
+		result: SyncHook<[T, Error, R]>;
 	};
 	add(item: T, callback: CallbackFunction<R>): void;
 	invalidate(item: T): void;
@@ -507,7 +507,7 @@ declare class Cache {
 		>;
 		store: AsyncParallelHook<[string, Etag, any]>;
 		storeBuildDependencies: AsyncParallelHook<[Iterable<string>]>;
-		beginIdle: SyncHook<[], void>;
+		beginIdle: SyncHook<[]>;
 		endIdle: AsyncParallelHook<[]>;
 		shutdown: AsyncParallelHook<[]>;
 	};
@@ -684,7 +684,7 @@ declare class Chunk {
 }
 type ChunkFilename =
 	| string
-	| ((pathData: PathData, assetInfo: AssetInfo) => string);
+	| ((pathData: PathData, assetInfo?: AssetInfo) => string);
 declare class ChunkGraph {
 	constructor(moduleGraph: ModuleGraph);
 	moduleGraph: ModuleGraph;
@@ -1096,11 +1096,11 @@ declare class Compilation {
 	 */
 	constructor(compiler: Compiler);
 	hooks: Readonly<{
-		buildModule: SyncHook<[Module], void>;
-		rebuildModule: SyncHook<[Module], void>;
-		failedModule: SyncHook<[Module, WebpackError], void>;
-		succeedModule: SyncHook<[Module], void>;
-		stillValidModule: SyncHook<[Module], void>;
+		buildModule: SyncHook<[Module]>;
+		rebuildModule: SyncHook<[Module]>;
+		failedModule: SyncHook<[Module, WebpackError]>;
+		succeedModule: SyncHook<[Module]>;
+		stillValidModule: SyncHook<[Module]>;
 		addEntry: SyncHook<
 			[
 				Dependency,
@@ -1113,8 +1113,7 @@ declare class Compilation {
 					| "runtime"
 					| "wasmLoading"
 				>
-			],
-			void
+			]
 		>;
 		failedEntry: SyncHook<
 			[
@@ -1129,8 +1128,7 @@ declare class Compilation {
 					| "wasmLoading"
 				>,
 				Error
-			],
-			void
+			]
 		>;
 		succeedEntry: SyncHook<
 			[
@@ -1145,8 +1143,7 @@ declare class Compilation {
 					| "wasmLoading"
 				>,
 				Module
-			],
-			void
+			]
 		>;
 		dependencyReferencedExports: SyncWaterfallHook<
 			[
@@ -1157,64 +1154,61 @@ declare class Compilation {
 		>;
 		finishModules: AsyncSeriesHook<[Iterable<Module>]>;
 		finishRebuildingModule: AsyncSeriesHook<[Module]>;
-		unseal: SyncHook<[], void>;
-		seal: SyncHook<[], void>;
-		beforeChunks: SyncHook<[], void>;
-		afterChunks: SyncHook<[Iterable<Chunk>], void>;
+		unseal: SyncHook<[]>;
+		seal: SyncHook<[]>;
+		beforeChunks: SyncHook<[]>;
+		afterChunks: SyncHook<[Iterable<Chunk>]>;
 		optimizeDependencies: SyncBailHook<[Iterable<Module>], any>;
-		afterOptimizeDependencies: SyncHook<[Iterable<Module>], void>;
-		optimize: SyncHook<[], void>;
+		afterOptimizeDependencies: SyncHook<[Iterable<Module>]>;
+		optimize: SyncHook<[]>;
 		optimizeModules: SyncBailHook<[Iterable<Module>], any>;
-		afterOptimizeModules: SyncHook<[Iterable<Module>], void>;
+		afterOptimizeModules: SyncHook<[Iterable<Module>]>;
 		optimizeChunks: SyncBailHook<[Iterable<Chunk>, ChunkGroup[]], any>;
-		afterOptimizeChunks: SyncHook<[Iterable<Chunk>, ChunkGroup[]], void>;
+		afterOptimizeChunks: SyncHook<[Iterable<Chunk>, ChunkGroup[]]>;
 		optimizeTree: AsyncSeriesHook<[Iterable<Chunk>, Iterable<Module>]>;
-		afterOptimizeTree: SyncHook<[Iterable<Chunk>, Iterable<Module>], void>;
+		afterOptimizeTree: SyncHook<[Iterable<Chunk>, Iterable<Module>]>;
 		optimizeChunkModules: AsyncSeriesBailHook<
 			[Iterable<Chunk>, Iterable<Module>],
 			any
 		>;
-		afterOptimizeChunkModules: SyncHook<
-			[Iterable<Chunk>, Iterable<Module>],
-			void
-		>;
+		afterOptimizeChunkModules: SyncHook<[Iterable<Chunk>, Iterable<Module>]>;
 		shouldRecord: SyncBailHook<[], boolean>;
-		additionalChunkRuntimeRequirements: SyncHook<[Chunk, Set<string>], void>;
+		additionalChunkRuntimeRequirements: SyncHook<[Chunk, Set<string>]>;
 		runtimeRequirementInChunk: HookMap<SyncBailHook<[Chunk, Set<string>], any>>;
-		additionalModuleRuntimeRequirements: SyncHook<[Module, Set<string>], void>;
+		additionalModuleRuntimeRequirements: SyncHook<[Module, Set<string>]>;
 		runtimeRequirementInModule: HookMap<
 			SyncBailHook<[Module, Set<string>], any>
 		>;
-		additionalTreeRuntimeRequirements: SyncHook<[Chunk, Set<string>], void>;
+		additionalTreeRuntimeRequirements: SyncHook<[Chunk, Set<string>]>;
 		runtimeRequirementInTree: HookMap<SyncBailHook<[Chunk, Set<string>], any>>;
-		runtimeModule: SyncHook<[RuntimeModule, Chunk], void>;
-		reviveModules: SyncHook<[Iterable<Module>, any], void>;
-		beforeModuleIds: SyncHook<[Iterable<Module>], void>;
-		moduleIds: SyncHook<[Iterable<Module>], void>;
-		optimizeModuleIds: SyncHook<[Iterable<Module>], void>;
-		afterOptimizeModuleIds: SyncHook<[Iterable<Module>], void>;
-		reviveChunks: SyncHook<[Iterable<Chunk>, any], void>;
-		beforeChunkIds: SyncHook<[Iterable<Chunk>], void>;
-		chunkIds: SyncHook<[Iterable<Chunk>], void>;
-		optimizeChunkIds: SyncHook<[Iterable<Chunk>], void>;
-		afterOptimizeChunkIds: SyncHook<[Iterable<Chunk>], void>;
-		recordModules: SyncHook<[Iterable<Module>, any], void>;
-		recordChunks: SyncHook<[Iterable<Chunk>, any], void>;
-		optimizeCodeGeneration: SyncHook<[Iterable<Module>], void>;
-		beforeModuleHash: SyncHook<[], void>;
-		afterModuleHash: SyncHook<[], void>;
-		beforeCodeGeneration: SyncHook<[], void>;
-		afterCodeGeneration: SyncHook<[], void>;
-		beforeRuntimeRequirements: SyncHook<[], void>;
-		afterRuntimeRequirements: SyncHook<[], void>;
-		beforeHash: SyncHook<[], void>;
-		contentHash: SyncHook<[Chunk], void>;
-		afterHash: SyncHook<[], void>;
-		recordHash: SyncHook<[any], void>;
-		record: SyncHook<[Compilation, any], void>;
-		beforeModuleAssets: SyncHook<[], void>;
+		runtimeModule: SyncHook<[RuntimeModule, Chunk]>;
+		reviveModules: SyncHook<[Iterable<Module>, any]>;
+		beforeModuleIds: SyncHook<[Iterable<Module>]>;
+		moduleIds: SyncHook<[Iterable<Module>]>;
+		optimizeModuleIds: SyncHook<[Iterable<Module>]>;
+		afterOptimizeModuleIds: SyncHook<[Iterable<Module>]>;
+		reviveChunks: SyncHook<[Iterable<Chunk>, any]>;
+		beforeChunkIds: SyncHook<[Iterable<Chunk>]>;
+		chunkIds: SyncHook<[Iterable<Chunk>]>;
+		optimizeChunkIds: SyncHook<[Iterable<Chunk>]>;
+		afterOptimizeChunkIds: SyncHook<[Iterable<Chunk>]>;
+		recordModules: SyncHook<[Iterable<Module>, any]>;
+		recordChunks: SyncHook<[Iterable<Chunk>, any]>;
+		optimizeCodeGeneration: SyncHook<[Iterable<Module>]>;
+		beforeModuleHash: SyncHook<[]>;
+		afterModuleHash: SyncHook<[]>;
+		beforeCodeGeneration: SyncHook<[]>;
+		afterCodeGeneration: SyncHook<[]>;
+		beforeRuntimeRequirements: SyncHook<[]>;
+		afterRuntimeRequirements: SyncHook<[]>;
+		beforeHash: SyncHook<[]>;
+		contentHash: SyncHook<[Chunk]>;
+		afterHash: SyncHook<[]>;
+		recordHash: SyncHook<[any]>;
+		record: SyncHook<[Compilation, any]>;
+		beforeModuleAssets: SyncHook<[]>;
 		shouldGenerateChunkAssets: SyncBailHook<[], boolean>;
-		beforeChunkAssets: SyncHook<[], void>;
+		beforeChunkAssets: SyncHook<[]>;
 		additionalChunkAssets: Pick<
 			AsyncSeriesHook<[Set<Chunk>]>,
 			"tap" | "tapAsync" | "tapPromise" | "name"
@@ -1235,10 +1229,17 @@ declare class Compilation {
 			"tap" | "tapAsync" | "tapPromise" | "name"
 		> &
 			FakeHookMarker;
-		optimizeAssets: AsyncSeriesHook<[Record<string, Source>]>;
-		afterOptimizeAssets: SyncHook<[Record<string, Source>], void>;
-		processAssets: AsyncSeriesHook<[Record<string, Source>]>;
-		afterProcessAssets: SyncHook<[Record<string, Source>], void>;
+		optimizeAssets: AsyncSeriesHook<
+			[Record<string, Source>],
+			{ additionalAssets?: true | Function }
+		>;
+		afterOptimizeAssets: SyncHook<[Record<string, Source>]>;
+		processAssets: AsyncSeriesHook<
+			[Record<string, Source>],
+			{ additionalAssets?: true | Function }
+		>;
+		afterProcessAssets: SyncHook<[Record<string, Source>]>;
+		processAdditionalAssets: AsyncSeriesHook<[Record<string, Source>]>;
 		needAdditionalSeal: SyncBailHook<[], boolean>;
 		afterSeal: AsyncSeriesHook<[]>;
 		renderManifest: SyncWaterfallHook<
@@ -1247,21 +1248,21 @@ declare class Compilation {
 				RenderManifestOptions
 			]
 		>;
-		fullHash: SyncHook<[Hash], void>;
-		chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext], void>;
-		moduleAsset: SyncHook<[Module, string], void>;
-		chunkAsset: SyncHook<[Chunk, string], void>;
+		fullHash: SyncHook<[Hash]>;
+		chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
+		moduleAsset: SyncHook<[Module, string]>;
+		chunkAsset: SyncHook<[Chunk, string]>;
 		assetPath: SyncWaterfallHook<[string, any, AssetInfo]>;
 		needAdditionalPass: SyncBailHook<[], boolean>;
-		childCompiler: SyncHook<[Compiler, string, number], void>;
+		childCompiler: SyncHook<[Compiler, string, number]>;
 		log: SyncBailHook<[string, LogEntry], true>;
 		processWarnings: SyncWaterfallHook<[WebpackError[]]>;
 		processErrors: SyncWaterfallHook<[WebpackError[]]>;
-		statsPreset: HookMap<SyncHook<[any, any], void>>;
-		statsNormalize: SyncHook<[any, any], void>;
-		statsFactory: SyncHook<[StatsFactory, any], void>;
-		statsPrinter: SyncHook<[StatsPrinter, any], void>;
-		readonly normalModuleLoader: SyncHook<[any, NormalModule], void>;
+		statsPreset: HookMap<SyncHook<[any, any]>>;
+		statsNormalize: SyncHook<[any, any]>;
+		statsFactory: SyncHook<[StatsFactory, any]>;
+		statsPrinter: SyncHook<[StatsPrinter, any]>;
+		readonly normalModuleLoader: SyncHook<[any, NormalModule]>;
 	}>;
 	name: string;
 	startTime: any;
@@ -1507,7 +1508,10 @@ declare class Compilation {
 	createChildCompiler(
 		name: string,
 		outputOptions: OutputNormalized,
-		plugins: Plugin[]
+		plugins: (
+			| ((this: Compiler, compiler: Compiler) => void)
+			| WebpackPluginInstance
+		)[]
 	): Compiler;
 	checkConstraints(): void;
 
@@ -1539,6 +1543,8 @@ declare class Compilation {
 
 	/**
 	 * Optimize the count of existing assets, e. g. by merging them.
+	 * Only assets of the same type should be merged.
+	 * For assets of different types see PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE.
 	 */
 	static PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT: number;
 
@@ -1553,16 +1559,22 @@ declare class Compilation {
 	static PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE: number;
 
 	/**
-	 * Summarize the list of existing assets.
-	 * When creating new assets from this they should be fully optimized.
-	 * e. g. creating an assets manifest of Service Workers.
+	 * Add development tooling to assets, e. g. by extracting a SourceMap.
 	 */
-	static PROCESS_ASSETS_STAGE_SUMMARIZE: number;
+	static PROCESS_ASSETS_STAGE_DEV_TOOLING: number;
 
 	/**
-	 * Add development tooling to assets, e. g. by extracting a SourceMap.
+	 * Optimize the count of existing assets, e. g. by inlining assets of into other assets.
+	 * Only assets of different types should be inlined.
+	 * For assets of the same type see PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT.
 	 */
-	static PROCESS_ASSETS_STAGE_DEV_TOOLING: number;
+	static PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE: number;
+
+	/**
+	 * Summarize the list of existing assets
+	 * e. g. creating an assets manifest of Service Workers.
+	 */
+	static PROCESS_ASSETS_STAGE_SUMMARIZE: number;
 
 	/**
 	 * Optimize the hashes of the assets, e. g. by generating real hashes of the asset content.
@@ -1597,9 +1609,12 @@ declare interface CompilationHooksJavascriptModulesPlugin {
 	renderMain: SyncWaterfallHook<[Source, RenderContextObject]>;
 	render: SyncWaterfallHook<[Source, RenderContextObject]>;
 	renderRequire: SyncWaterfallHook<[string, RenderBootstrapContext]>;
-	chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext], void>;
+	chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
 	useSourceMap: SyncBailHook<[Chunk, RenderContextObject], boolean>;
 }
+declare interface CompilationHooksRealContentHashPlugin {
+	updateHash: SyncBailHook<[Buffer[], string], string>;
+}
 declare interface CompilationParams {
 	normalModuleFactory: NormalModuleFactory;
 	contextModuleFactory: ContextModuleFactory;
@@ -1607,34 +1622,34 @@ declare interface CompilationParams {
 declare class Compiler {
 	constructor(context: string);
 	hooks: Readonly<{
-		initialize: SyncHook<[], void>;
+		initialize: SyncHook<[]>;
 		shouldEmit: SyncBailHook<[Compilation], boolean>;
 		done: AsyncSeriesHook<[Stats]>;
-		afterDone: SyncHook<[Stats], void>;
+		afterDone: SyncHook<[Stats]>;
 		additionalPass: AsyncSeriesHook<[]>;
 		beforeRun: AsyncSeriesHook<[Compiler]>;
 		run: AsyncSeriesHook<[Compiler]>;
 		emit: AsyncSeriesHook<[Compilation]>;
 		assetEmitted: AsyncSeriesHook<[string, AssetEmittedInfo]>;
 		afterEmit: AsyncSeriesHook<[Compilation]>;
-		thisCompilation: SyncHook<[Compilation, CompilationParams], void>;
-		compilation: SyncHook<[Compilation, CompilationParams], void>;
-		normalModuleFactory: SyncHook<[NormalModuleFactory], void>;
-		contextModuleFactory: SyncHook<[ContextModuleFactory], void>;
+		thisCompilation: SyncHook<[Compilation, CompilationParams]>;
+		compilation: SyncHook<[Compilation, CompilationParams]>;
+		normalModuleFactory: SyncHook<[NormalModuleFactory]>;
+		contextModuleFactory: SyncHook<[ContextModuleFactory]>;
 		beforeCompile: AsyncSeriesHook<[CompilationParams]>;
-		compile: SyncHook<[CompilationParams], void>;
+		compile: SyncHook<[CompilationParams]>;
 		make: AsyncParallelHook<[Compilation]>;
 		finishMake: AsyncParallelHook<[Compilation]>;
 		afterCompile: AsyncSeriesHook<[Compilation]>;
 		watchRun: AsyncSeriesHook<[Compiler]>;
-		failed: SyncHook<[Error], void>;
-		invalid: SyncHook<[string, number], void>;
-		watchClose: SyncHook<[], void>;
+		failed: SyncHook<[Error]>;
+		invalid: SyncHook<[string, number]>;
+		watchClose: SyncHook<[]>;
 		infrastructureLog: SyncBailHook<[string, string, any[]], true>;
-		environment: SyncHook<[], void>;
-		afterEnvironment: SyncHook<[], void>;
-		afterPlugins: SyncHook<[Compiler], void>;
-		afterResolvers: SyncHook<[Compiler], void>;
+		environment: SyncHook<[]>;
+		afterEnvironment: SyncHook<[]>;
+		afterPlugins: SyncHook<[Compiler]>;
+		afterResolvers: SyncHook<[Compiler]>;
 		entryOption: SyncBailHook<[string, EntryNormalized], boolean>;
 	}>;
 	webpack: typeof exports;
@@ -2194,8 +2209,20 @@ declare class DefinePlugin {
 	/**
 	 * Create a new define plugin
 	 */
-	constructor(definitions: Record<string, RecursiveArrayOrRecord>);
-	definitions: Record<string, RecursiveArrayOrRecord>;
+	constructor(
+		definitions: Record<
+			string,
+			RecursiveArrayOrRecord<
+				string | number | bigint | boolean | Function | RegExp | RuntimeValue
+			>
+		>
+	);
+	definitions: Record<
+		string,
+		RecursiveArrayOrRecord<
+			string | number | bigint | boolean | Function | RegExp | RuntimeValue
+		>
+	>;
 
 	/**
 	 * Apply the plugin
@@ -3213,7 +3240,7 @@ type ExternalItem =
 	| { [index: string]: string | boolean | string[] | { [index: string]: any } }
 	| ((
 			data: { context: string; request: string },
-			callback: (err: Error, result: string) => void
+			callback: (err?: Error, result?: string) => void
 	  ) => void);
 declare class ExternalModule extends Module {
 	constructor(request?: any, type?: any, userRequest?: any);
@@ -3237,7 +3264,7 @@ type Externals =
 	| { [index: string]: string | boolean | string[] | { [index: string]: any } }
 	| ((
 			data: { context: string; request: string },
-			callback: (err: Error, result: string) => void
+			callback: (err?: Error, result?: string) => void
 	  ) => void);
 declare class ExternalsPlugin {
 	constructor(type: string, externals: Externals);
@@ -3444,7 +3471,7 @@ declare interface FileSystem {
 	};
 }
 declare interface FileSystemCallback<T> {
-	(err: PossibleFileSystemError & Error, result: T): any;
+	(err?: PossibleFileSystemError & Error, result?: T): any;
 }
 declare interface FileSystemDirent {
 	name: string | Buffer;
@@ -3526,7 +3553,9 @@ declare interface FileSystemStats {
 	isDirectory: () => boolean;
 	isFile: () => boolean;
 }
-type Filename = string | ((pathData: PathData, assetInfo: AssetInfo) => string);
+type Filename =
+	| string
+	| ((pathData: PathData, assetInfo?: AssetInfo) => string);
 type FilterItemTypes = string | RegExp | ((value: string) => boolean);
 type FilterTypes =
 	| string
@@ -3659,7 +3688,7 @@ declare interface HashedModuleIdsPluginOptions {
 	/**
 	 * The encoding to use when generating the hash, defaults to 'base64'. All encodings from Node.JS' hash.digest are supported.
 	 */
-	hashDigest?: "hex" | "latin1" | "base64";
+	hashDigest?: "base64" | "latin1" | "hex";
 
 	/**
 	 * The prefix length of the hash digest to use, defaults to 4.
@@ -4162,6 +4191,13 @@ declare class JavascriptParser extends Parser {
 	preWalkStatement(statement?: any): void;
 	blockPreWalkStatement(statement?: any): void;
 	walkStatement(statement?: any): void;
+
+	/**
+	 * Walks a statements that is nested within a parent statement
+	 * and can potentially be a non-block statement.
+	 * This enforces the nested statement to never be in ASI position.
+	 */
+	walkNestedStatement(statement: Statement): void;
 	preWalkBlockStatement(statement?: any): void;
 	walkBlockStatement(statement?: any): void;
 	walkExpressionStatement(statement?: any): void;
@@ -5307,10 +5343,10 @@ declare abstract class ModuleTemplate {
 declare class MultiCompiler {
 	constructor(compilers: Compiler[] | Record<string, Compiler>);
 	hooks: Readonly<{
-		done: SyncHook<[MultiStats], void>;
-		invalid: MultiHook<SyncHook<[string, number], void>>;
+		done: SyncHook<[MultiStats]>;
+		invalid: MultiHook<SyncHook<[string, number]>>;
 		run: MultiHook<AsyncSeriesHook<[Compiler]>>;
-		watchClose: SyncHook<[], void>;
+		watchClose: SyncHook<[]>;
 		watchRun: MultiHook<AsyncSeriesHook<[Compiler]>>;
 		infrastructureLog: MultiHook<SyncBailHook<[string, string, any[]], true>>;
 	}>;
@@ -5619,8 +5655,8 @@ declare class NormalModule extends Module {
 	static deserialize(context?: any): NormalModule;
 }
 declare interface NormalModuleCompilationHooks {
-	loader: SyncHook<[any, NormalModule], void>;
-	beforeLoaders: SyncHook<[LoaderItem[], NormalModule, any], void>;
+	loader: SyncHook<[any, NormalModule]>;
+	beforeLoaders: SyncHook<[LoaderItem[], NormalModule, any]>;
 	readResourceForScheme: HookMap<
 		AsyncSeriesBailHook<[string, NormalModule], string | Buffer>
 	>;
@@ -5647,11 +5683,11 @@ declare abstract class NormalModuleFactory extends ModuleFactory {
 		beforeResolve: AsyncSeriesBailHook<[ResolveData], any>;
 		afterResolve: AsyncSeriesBailHook<[ResolveData], any>;
 		createModule: AsyncSeriesBailHook<[any, ResolveData], any>;
-		module: SyncWaterfallHook<[Module, any, ResolveData]>;
+		module: SyncWaterfallHook<[Module, any, ResolveData], any>;
 		createParser: HookMap<SyncBailHook<any, any>>;
-		parser: HookMap<SyncHook<any, void>>;
+		parser: HookMap<SyncHook<any>>;
 		createGenerator: HookMap<SyncBailHook<any, any>>;
-		generator: HookMap<SyncHook<any, void>>;
+		generator: HookMap<SyncHook<any>>;
 	}>;
 	resolverFactory: ResolverFactory;
 	ruleSet: RuleSet;
@@ -5907,7 +5943,7 @@ declare interface OptimizationSplitChunksCacheGroup {
 	/**
 	 * Sets the template for the filename for created chunks.
 	 */
-	filename?: string | ((pathData: PathData, assetInfo: AssetInfo) => string);
+	filename?: string | ((pathData: PathData, assetInfo?: AssetInfo) => string);
 
 	/**
 	 * Sets the hint for chunk id.
@@ -6050,7 +6086,7 @@ declare interface OptimizationSplitChunksOptions {
 	/**
 	 * Sets the template for the filename for created chunks.
 	 */
-	filename?: string | ((pathData: PathData, assetInfo: AssetInfo) => string);
+	filename?: string | ((pathData: PathData, assetInfo?: AssetInfo) => string);
 
 	/**
 	 * Prevents exposing path info when creating names for parts splitted by maxSize.
@@ -6648,9 +6684,6 @@ declare interface PerformanceOptions {
 	 */
 	maxEntrypointSize?: number;
 }
-declare interface Plugin {
-	apply: () => void;
-}
 declare interface PnpApiImpl {
 	resolveToUnqualified: (arg0: string, arg1: string, arg2?: any) => string;
 }
@@ -6855,13 +6888,13 @@ declare interface ProvidesObject {
 }
 type PublicPath =
 	| string
-	| ((pathData: PathData, assetInfo: AssetInfo) => string);
+	| ((pathData: PathData, assetInfo?: AssetInfo) => string);
 declare interface RawChunkGroupOptions {
 	preloadOrder?: number;
 	prefetchOrder?: number;
 }
 declare class RawSource extends Source {
-	constructor(source: string | Buffer, convertToString: boolean);
+	constructor(source: string | Buffer, convertToString?: boolean);
 	isBuffer(): boolean;
 }
 declare class ReadFileCompileWasmPlugin {
@@ -6873,21 +6906,26 @@ declare class ReadFileCompileWasmPlugin {
 	 */
 	apply(compiler: Compiler): void;
 }
+declare class RealContentHashPlugin {
+	constructor(__0: { hashFunction: any; hashDigest: any });
+
+	/**
+	 * Apply the plugin
+	 */
+	apply(compiler: Compiler): void;
+	static getCompilationHooks(
+		compilation: Compilation
+	): CompilationHooksRealContentHashPlugin;
+}
 declare interface RealDependencyLocation {
 	start: SourcePosition;
 	end?: SourcePosition;
 	index?: number;
 }
-type RecursiveArrayOrRecord =
-	| string
-	| number
-	| bigint
-	| boolean
-	| Function
-	| RegExp
-	| RuntimeValue
-	| { [index: string]: RecursiveArrayOrRecord }
-	| RecursiveArrayOrRecord[];
+type RecursiveArrayOrRecord<T> =
+	| { [index: string]: RecursiveArrayOrRecord<T> }
+	| RecursiveArrayOrRecord<T>[]
+	| T;
 declare interface ReferencedExport {
 	/**
 	 * name of the referenced export
@@ -7038,9 +7076,9 @@ declare interface RenderManifestOptions {
 	chunkGraph: ChunkGraph;
 }
 declare class ReplaceSource extends Source {
-	constructor(source: Source, name: string);
-	replace(start: number, end: number, newValue: string, name: string): void;
-	insert(pos: number, newValue: string, name: string): void;
+	constructor(source: Source, name?: string);
+	replace(start: number, end: number, newValue: string, name?: string): void;
+	insert(pos: number, newValue: string, name?: string): void;
 	getName(): string;
 	original(): string;
 	getReplacements(): {
@@ -7369,10 +7407,9 @@ declare abstract class Resolver {
 			[
 				AsyncSeriesBailHook<[ResolveRequest, ResolveContext], ResolveRequest>,
 				ResolveRequest
-			],
-			void
+			]
 		>;
-		noResolve: SyncHook<[ResolveRequest, Error], void>;
+		noResolve: SyncHook<[ResolveRequest, Error]>;
 		resolve: AsyncSeriesBailHook<
 			[ResolveRequest, ResolveContext],
 			ResolveRequest
@@ -7395,7 +7432,7 @@ declare abstract class Resolver {
 		path: string,
 		request: string,
 		resolveContext: ResolveContext,
-		callback: (arg0: Error, arg1: DevTool, arg2: ResolveRequest) => void
+		callback: (arg0: Error, arg1?: DevTool, arg2?: ResolveRequest) => void
 	): void;
 	doResolve(
 		hook?: any,
@@ -7644,8 +7681,7 @@ declare abstract class ResolverFactory {
 						dependencyType?: string;
 						resolveToContext?: boolean;
 					}
-				],
-				void
+				]
 			>
 		>;
 	}>;
@@ -8024,6 +8060,7 @@ declare abstract class RuntimeSpecMap<T> {
 }
 declare abstract class RuntimeSpecSet {
 	add(runtime?: any): void;
+	has(runtime?: any): boolean;
 	[Symbol.iterator](): IterableIterator<string | SortableSet<string>>;
 	readonly size: number;
 }
@@ -8292,14 +8329,6 @@ declare abstract class RuntimeTemplate {
 		 * true, if this is a weak dependency
 		 */
 		weak?: boolean;
-		/**
-		 * runtime for which this code will be generated
-		 */
-		runtime?: string | SortableSet<string>;
-		/**
-		 * only execute the statement in some runtimes
-		 */
-		runtimeCondition?: string | boolean | SortableSet<string>;
 		/**
 		 * if set, will be filled with runtime requirements
 		 */
@@ -8688,8 +8717,8 @@ declare abstract class SortableSet<T> extends Set<T> {
 declare class Source {
 	constructor();
 	size(): number;
-	map(options: MapOptions): Object;
-	sourceAndMap(options: MapOptions): { source: string | Buffer; map: Object };
+	map(options?: MapOptions): Object;
+	sourceAndMap(options?: MapOptions): { source: string | Buffer; map: Object };
 	updateHash(hash: Hash): void;
 	source(): string | Buffer;
 	buffer(): Buffer;
@@ -8792,8 +8821,8 @@ declare class SourceMapSource extends Source {
 		source: string | Buffer,
 		name: string,
 		sourceMap: string | Object | Buffer,
-		originalSource: string | Buffer,
-		innerSourceMap: string | Object | Buffer
+		originalSource?: string | Buffer,
+		innerSourceMap?: string | Object | Buffer
 	);
 	getArgsAsBuffers(): [Buffer, string, Buffer, Buffer, Buffer];
 }
@@ -10221,6 +10250,7 @@ declare namespace exports {
 			LimitChunkCountPlugin,
 			MinChunkSizePlugin,
 			ModuleConcatenationPlugin,
+			RealContentHashPlugin,
 			RuntimeChunkPlugin,
 			SideEffectsFlagPlugin,
 			SplitChunksPlugin