webpack 5.99.9 → 5.100.0

package/types.d.ts

@@ -263,6 +263,7 @@ type ArrayBufferView<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike> =
 	| Int32Array
 	| BigUint64Array
 	| BigInt64Array
+	| Float16Array
 	| Float32Array
 	| Float64Array
 	| DataView;
@@ -529,16 +530,59 @@ declare interface BannerPluginOptions {
 	test?: string | RegExp | Rule[];
 }
 declare interface BaseResolveRequest {
+	/**
+	 * path
+	 */
 	path: string | false;
+
+	/**
+	 * content
+	 */
 	context?: object;
+
+	/**
+	 * description file path
+	 */
 	descriptionFilePath?: string;
+
+	/**
+	 * description file root
+	 */
 	descriptionFileRoot?: string;
+
+	/**
+	 * description file data
+	 */
 	descriptionFileData?: JsonObjectTypes;
+
+	/**
+	 * relative path
+	 */
 	relativePath?: string;
+
+	/**
+	 * true when need to ignore symlinks, otherwise false
+	 */
 	ignoreSymlinks?: boolean;
+
+	/**
+	 * true when full specified, otherwise false
+	 */
 	fullySpecified?: boolean;
+
+	/**
+	 * inner request for internal usage
+	 */
 	__innerRequest?: string;
+
+	/**
+	 * inner request for internal usage
+	 */
 	__innerRequest_request?: string;
+
+	/**
+	 * inner relative path for internal usage
+	 */
 	__innerRequest_relativePath?: string;
 }
 declare abstract class BasicEvaluatedExpression {
@@ -895,6 +939,46 @@ type BufferEncoding =
 	| "binary"
 	| "hex";
 type BufferEncodingOption = "buffer" | { encoding: "buffer" };
+declare interface BufferEntry {
+	map?: null | RawSourceMap;
+	bufferedMap?: null | BufferedMap;
+}
+declare interface BufferedMap {
+	/**
+	 * version
+	 */
+	version: number;
+
+	/**
+	 * sources
+	 */
+	sources: string[];
+
+	/**
+	 * name
+	 */
+	names: string[];
+
+	/**
+	 * source root
+	 */
+	sourceRoot?: string;
+
+	/**
+	 * sources content
+	 */
+	sourcesContent?: ("" | Buffer)[];
+
+	/**
+	 * mappings
+	 */
+	mappings?: Buffer;
+
+	/**
+	 * file
+	 */
+	file: string;
+}
 type BuildInfo = KnownBuildInfo & Record<string, any>;
 type BuildMeta = KnownBuildMeta & Record<string, any>;
 declare abstract class ByTypeGenerator extends Generator {
@@ -906,7 +990,7 @@ declare abstract class ByTypeGenerator extends Generator {
 	) => null | Source;
 }
 declare const CIRCULAR_CONNECTION: unique symbol;
-declare class Cache {
+declare class CacheClass {
 	constructor();
 	hooks: {
 		get: AsyncSeriesBailHook<
@@ -1014,12 +1098,64 @@ declare interface CacheGroupsContext {
 	chunkGraph: ChunkGraph;
 }
 type CacheOptionsNormalized = false | FileCacheOptions | MemoryCacheOptions;
+declare interface CacheTypes {
+	[index: string]: undefined | ResolveRequest | ResolveRequest[];
+}
+declare interface CachedData {
+	/**
+	 * source
+	 */
+	source?: boolean;
+
+	/**
+	 * buffer
+	 */
+	buffer: Buffer;
+
+	/**
+	 * size
+	 */
+	size?: number;
+
+	/**
+	 * maps
+	 */
+	maps: Map<string, BufferEntry>;
+
+	/**
+	 * hash
+	 */
+	hash?: (string | Buffer)[];
+}
 declare class CachedSource extends Source {
-	constructor(source: Source);
-	constructor(source: Source | (() => Source), cachedData?: any);
-	original(): Source;
+	constructor(source: Source | (() => Source), cachedData?: CachedData);
+	getCachedData(): CachedData;
 	originalLazy(): Source | (() => Source);
-	getCachedData(): any;
+	original(): Source;
+	streamChunks(
+		options: StreamChunksOptions,
+		onChunk: (
+			chunk: undefined | string,
+			generatedLine: number,
+			generatedColumn: number,
+			sourceIndex: number,
+			originalLine: number,
+			originalColumn: number,
+			nameIndex: number
+		) => void,
+		onSource: (
+			sourceIndex: number,
+			source: null | string,
+			sourceContent?: string
+		) => void,
+		onName: (nameIndex: number, name: string) => void
+	): GeneratedSourceInfo;
+}
+declare interface CalculatedStringResult {
+	range?: [number, number];
+	value: string;
+	code: boolean;
+	conditional: false | CalculatedStringResult[];
 }
 type CallExpression = SimpleCallExpression | NewExpression;
 declare interface CallExpressionInfo {
@@ -1444,12 +1580,19 @@ declare interface ChunkHashContext {
 	 */
 	chunkGraph: ChunkGraph;
 }
+declare interface ChunkHashes {
+	[index: number]: string;
+	[index: string]: string;
+}
 type ChunkId = string | number;
 declare interface ChunkMaps {
 	hash: Record<string | number, string>;
 	contentHash: Record<string | number, Record<string, string>>;
 	name: Record<string | number, string>;
 }
+declare interface ChunkModuleHashes {
+	[index: string]: string;
+}
 declare class ChunkModuleIdRangePlugin {
 	constructor(options: ChunkModuleIdRangePluginOptions);
 	options: ChunkModuleIdRangePluginOptions;
@@ -1480,6 +1623,10 @@ declare interface ChunkModuleIdRangePluginOptions {
 	 */
 	end?: number;
 }
+declare interface ChunkModuleIds {
+	[index: number]: ModuleId[];
+	[index: string]: ModuleId[];
+}
 declare interface ChunkModuleMaps {
 	id: Record<string | number, (string | number)[]>;
 	hash: Record<string | number, string>;
@@ -1564,6 +1711,10 @@ declare interface ChunkRenderContextJavascriptModulesPlugin {
 	 */
 	strictMode?: boolean;
 }
+declare interface ChunkRuntime {
+	[index: number]: string;
+	[index: string]: string;
+}
 declare interface ChunkSizeOptions {
 	/**
 	 * constant overhead for a chunk
@@ -1973,7 +2124,7 @@ declare class Compilation {
 		statsFactory: SyncHook<[StatsFactory, NormalizedStatsOptions]>;
 		statsPrinter: SyncHook<[StatsPrinter, NormalizedStatsOptions]>;
 		get normalModuleLoader(): SyncHook<
-			[LoaderContextNormalModule<any>, NormalModule]
+			[LoaderContextObject<any>, NormalModule]
 		>;
 	}>;
 	name?: string;
@@ -2461,7 +2612,7 @@ declare class Compiler {
 	watchFileSystem: null | WatchFileSystem;
 	recordsInputPath: null | string;
 	recordsOutputPath: null | string;
-	records: Record<string, any>;
+	records: Records;
 	managedPaths: Set<string | RegExp>;
 	unmanagedPaths: Set<string | RegExp>;
 	immutablePaths: Set<string | RegExp>;
@@ -2480,7 +2631,7 @@ declare class Compiler {
 	options: WebpackOptionsNormalized;
 	context: string;
 	requestShortener: RequestShortener;
-	cache: Cache;
+	cache: CacheClass;
 	moduleMemCaches?: Map<Module, ModuleMemCachesItem>;
 	compilerPath: string;
 	running: boolean;
@@ -2524,11 +2675,30 @@ declare class Compiler {
 	close(callback: RunCallback<void>): void;
 }
 declare class ConcatSource extends Source {
-	constructor(...args: (string | Source)[]);
+	constructor(...args: ConcatSourceChild[]);
 	getChildren(): Source[];
-	add(item: string | Source): void;
-	addAllSkipOptimizing(items: Source[]): void;
+	add(item: ConcatSourceChild): void;
+	addAllSkipOptimizing(items: ConcatSourceChild[]): void;
+	streamChunks(
+		options: StreamChunksOptions,
+		onChunk: (
+			chunk: undefined | string,
+			generatedLine: number,
+			generatedColumn: number,
+			sourceIndex: number,
+			originalLine: number,
+			originalColumn: number,
+			nameIndex: number
+		) => void,
+		onSource: (
+			sourceIndex: number,
+			source: null | string,
+			sourceContent?: string
+		) => void,
+		onName: (nameIndex: number, name: string) => void
+	): GeneratedSourceInfo;
 }
+type ConcatSourceChild = string | Source | SourceLike;
 declare interface ConcatenatedModuleInfo {
 	type: "concatenated";
 	module: Module;
@@ -2545,11 +2715,35 @@ declare interface ConcatenatedModuleInfo {
 	rawExportMap?: Map<string, string>;
 	namespaceExportSymbol?: string;
 	namespaceObjectName?: string;
+
+	/**
+	 * "default-with-named" namespace
+	 */
 	interopNamespaceObjectUsed: boolean;
+
+	/**
+	 * "default-with-named" namespace
+	 */
 	interopNamespaceObjectName?: string;
+
+	/**
+	 * "default-only" namespace
+	 */
 	interopNamespaceObject2Used: boolean;
+
+	/**
+	 * "default-only" namespace
+	 */
 	interopNamespaceObject2Name?: string;
+
+	/**
+	 * runtime namespace object that detects "__esModule"
+	 */
 	interopDefaultAccessUsed: boolean;
+
+	/**
+	 * runtime namespace object that detects "__esModule"
+	 */
 	interopDefaultAccessName?: string;
 }
 declare interface ConcatenationBailoutReasonContext {
@@ -2838,8 +3032,8 @@ declare interface Configuration {
 }
 type ConnectionState =
 	| boolean
-	| typeof TRANSITIVE_ONLY
-	| typeof CIRCULAR_CONNECTION;
+	| typeof CIRCULAR_CONNECTION
+	| typeof TRANSITIVE_ONLY;
 declare class ConstDependency extends NullDependency {
 	constructor(
 		expression: string,
@@ -3293,7 +3487,7 @@ declare abstract class CssModule extends NormalModule {
 	cssLayer: CssLayer;
 	supports: Supports;
 	media: Media;
-	inheritance: [CssLayer, Supports, Media][];
+	inheritance?: [CssLayer, Supports, Media][];
 }
 
 /**
@@ -3463,7 +3657,8 @@ declare interface DependenciesBlockLike {
 declare class Dependency {
 	constructor();
 	weak: boolean;
-	optional: boolean;
+	defer?: boolean;
+	optional?: boolean;
 	get type(): string;
 	get category(): string;
 	loc: DependencyLocation;
@@ -3685,16 +3880,59 @@ declare interface DeterministicModuleIdsPluginOptions {
 	failOnConflict?: boolean;
 }
 type DevtoolModuleFilenameTemplate = string | ((context?: any) => string);
-declare interface Dirent {
+declare interface Dirent<T extends string | Buffer = string> {
+	/**
+	 * true when is file, otherwise false
+	 */
 	isFile: () => boolean;
+
+	/**
+	 * true when is directory, otherwise false
+	 */
 	isDirectory: () => boolean;
+
+	/**
+	 * true when is block device, otherwise false
+	 */
 	isBlockDevice: () => boolean;
+
+	/**
+	 * true when is character device, otherwise false
+	 */
 	isCharacterDevice: () => boolean;
+
+	/**
+	 * true when is symbolic link, otherwise false
+	 */
 	isSymbolicLink: () => boolean;
+
+	/**
+	 * true when is FIFO, otherwise false
+	 */
 	isFIFO: () => boolean;
+
+	/**
+	 * true when is socket, otherwise false
+	 */
 	isSocket: () => boolean;
-	name: string;
-	path: string;
+
+	/**
+	 * name
+	 */
+	name: T;
+
+	/**
+	 * path
+	 */
+	parentPath: string;
+
+	/**
+	 * path
+	 */
+	path?: string;
+}
+declare interface Disposable {
+	[Symbol.dispose](): void;
 }
 declare class DllPlugin {
 	constructor(options: DllPluginOptions);
@@ -4492,6 +4730,11 @@ declare interface ExperimentsExtra {
 	 */
 	css?: boolean;
 
+	/**
+	 * 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.
+	 */
+	deferImport?: boolean;
+
 	/**
 	 * Compile entrypoints and import()s only when they are accessed.
 	 */
@@ -4513,6 +4756,11 @@ declare interface ExperimentsNormalizedExtra {
 	 */
 	css?: boolean;
 
+	/**
+	 * 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.
+	 */
+	deferImport?: boolean;
+
 	/**
 	 * Compile entrypoints and import()s only when they are accessed.
 	 */
@@ -4746,6 +4994,11 @@ declare interface ExportsSpec {
 	 */
 	dependencies?: Module[];
 }
+type ExportsType =
+	| "namespace"
+	| "default-only"
+	| "default-with-named"
+	| "dynamic";
 type Exposes = (string | ExposesObject)[] | ExposesObject;
 
 /**
@@ -4926,12 +5179,60 @@ declare interface ExternalModuleInfo {
 	module: Module;
 	runtimeCondition?: string | boolean | SortableSet<string>;
 	index: number;
+
+	/**
+	 * module.exports / harmony namespace object
+	 */
 	name?: string;
+
+	/**
+	 * deferred module.exports / harmony namespace object
+	 */
+	deferredName?: string;
+
+	/**
+	 * the module is deferred at least once
+	 */
+	deferred: boolean;
+
+	/**
+	 * deferred namespace object that being used in a not-analyzable way so it must be materialized
+	 */
+	deferredNamespaceObjectUsed: boolean;
+
+	/**
+	 * deferred namespace object that being used in a not-analyzable way so it must be materialized
+	 */
+	deferredNamespaceObjectName?: string;
+
+	/**
+	 * "default-with-named" namespace
+	 */
 	interopNamespaceObjectUsed: boolean;
+
+	/**
+	 * "default-with-named" namespace
+	 */
 	interopNamespaceObjectName?: string;
+
+	/**
+	 * "default-only" namespace
+	 */
 	interopNamespaceObject2Used: boolean;
+
+	/**
+	 * "default-only" namespace
+	 */
 	interopNamespaceObject2Name?: string;
+
+	/**
+	 * runtime namespace object that detects "__esModule"
+	 */
 	interopDefaultAccessUsed: boolean;
+
+	/**
+	 * runtime namespace object that detects "__esModule"
+	 */
 	interopDefaultAccessName?: string;
 }
 type Externals =
@@ -5183,18 +5484,45 @@ declare interface FileCacheOptions {
 	version?: string;
 }
 declare interface FileSystem {
+	/**
+	 * read file method
+	 */
 	readFile: ReadFileTypes;
+
+	/**
+	 * readdir method
+	 */
 	readdir: ReaddirTypes;
+
+	/**
+	 * read json method
+	 */
 	readJson?: (
-		arg0: PathOrFileDescriptorTypes,
-		arg1: (
-			arg0: null | Error | NodeJS.ErrnoException,
-			arg1?: JsonObjectTypes
+		pathOrFileDescription: PathOrFileDescriptorTypes,
+		callback: (
+			err: null | Error | NodeJS.ErrnoException,
+			result?: JsonObjectTypes
 		) => void
 	) => void;
+
+	/**
+	 * read link method
+	 */
 	readlink: ReadlinkTypes;
+
+	/**
+	 * lstat method
+	 */
 	lstat?: LStatTypes;
+
+	/**
+	 * stat method
+	 */
 	stat: StatTypes;
+
+	/**
+	 * realpath method
+	 */
 	realpath?: RealPathTypes;
 }
 declare abstract class FileSystemInfo {
@@ -5294,6 +5622,9 @@ type FilterItemTypes = string | RegExp | ((value: string) => boolean);
 declare interface Flags {
 	[index: string]: Argument;
 }
+declare interface FullHashChunkModuleHashes {
+	[index: string]: string;
+}
 declare interface GenerateContext {
 	/**
 	 * mapping from dependencies to templates
@@ -5343,7 +5674,30 @@ declare interface GenerateContext {
 	/**
 	 * get access to the code generation data
 	 */
-	getData?: () => Map<string, any>;
+	getData?: () => GenerateContextData;
+}
+type GenerateContextData = Map<"url", { [index: string]: string }> &
+	Map<"fullContentHash", string> &
+	Map<"contentHash", string> &
+	Map<"filename", string> &
+	Map<"assetInfo", AssetInfo> &
+	Map<"chunkInitFragments", InitFragment<GenerateContext>[]> &
+	Record<string, any>;
+declare interface GeneratedSourceInfo {
+	/**
+	 * generated line
+	 */
+	generatedLine?: number;
+
+	/**
+	 * generated column
+	 */
+	generatedColumn?: number;
+
+	/**
+	 * source
+	 */
+	source?: string;
 }
 declare class Generator {
 	constructor();
@@ -5595,6 +5949,17 @@ declare class Hash {
 	digest(encoding?: string): string | Buffer;
 }
 type HashFunction = string | typeof Hash;
+declare interface HashLike {
+	/**
+	 * make hash update
+	 */
+	update: (data: string | Buffer, inputEncoding?: string) => HashLike;
+
+	/**
+	 * get hash digest
+	 */
+	digest: (encoding?: string) => string | Buffer;
+}
 declare interface HashableObject {
 	updateHash: (hash: Hash) => void;
 }
@@ -5793,6 +6158,7 @@ type ImportAttribute = BaseNode & {
 type ImportAttributes = Record<string, string> & {};
 type ImportDeclarationJavascriptParser = ImportDeclarationImport & {
 	attributes?: ImportAttribute[];
+	phase?: "defer";
 };
 declare interface ImportDependencyMeta {
 	attributes?: ImportAttributes;
@@ -5828,6 +6194,7 @@ type ImportExpressionJavascriptParser = ImportExpressionImport & {
 		| ThisExpression
 		| UpdateExpression
 		| YieldExpression;
+	phase?: "defer";
 };
 declare interface ImportModuleOptions {
 	/**
@@ -6009,6 +6376,12 @@ declare abstract class ItemCacheFacade {
 	): void;
 	providePromise<T>(computer: () => T | Promise<T>): Promise<T>;
 }
+declare interface IteratorObject<T, TReturn = unknown, TNext = unknown>
+	extends Iterator<T, TReturn, TNext>,
+		Disposable {
+	[Symbol.iterator](): IteratorObject<T, TReturn, TNext>;
+	[Symbol.dispose](): void;
+}
 declare class JavascriptModulesPlugin {
 	constructor(options?: object);
 	options: object;
@@ -6403,10 +6776,11 @@ declare class JavascriptParser extends Parser {
 			boolean | void
 		>;
 		declarator: SyncBailHook<[VariableDeclarator, Statement], boolean | void>;
-		varDeclaration: HookMap<SyncBailHook<[Declaration], boolean | void>>;
-		varDeclarationLet: HookMap<SyncBailHook<[Declaration], boolean | void>>;
-		varDeclarationConst: HookMap<SyncBailHook<[Declaration], boolean | void>>;
-		varDeclarationVar: HookMap<SyncBailHook<[Declaration], boolean | void>>;
+		varDeclaration: HookMap<SyncBailHook<[Identifier], boolean | void>>;
+		varDeclarationLet: HookMap<SyncBailHook<[Identifier], boolean | void>>;
+		varDeclarationConst: HookMap<SyncBailHook<[Identifier], boolean | void>>;
+		varDeclarationUsing: HookMap<SyncBailHook<[Identifier], boolean | void>>;
+		varDeclarationVar: HookMap<SyncBailHook<[Identifier], boolean | void>>;
 		pattern: HookMap<SyncBailHook<[Identifier], boolean | void>>;
 		canRename: HookMap<SyncBailHook<[Expression], boolean | void>>;
 		rename: HookMap<SyncBailHook<[Expression], boolean | void>>;
@@ -6815,7 +7189,7 @@ declare class JavascriptParser extends Parser {
 	 */
 	walkNestedStatement(statement: Statement): void;
 	preWalkBlockStatement(statement: BlockStatement): void;
-	walkBlockStatement(statement: BlockStatement): void;
+	walkBlockStatement(statement: BlockStatement | StaticBlock): void;
 	walkExpressionStatement(statement: ExpressionStatement): void;
 	preWalkIfStatement(statement: IfStatement): void;
 	walkIfStatement(statement: IfStatement): void;
@@ -7059,7 +7433,7 @@ declare class JavascriptParser extends Parser {
 					name: string,
 					rootInfo: string | VariableInfo | ScopeInfo,
 					getMembers: () => string[]
-			  ) => any),
+			  ) => R),
 		defined: undefined | ((result?: string) => undefined | R),
 		...args: AsArray<T>
 	): undefined | R;
@@ -7076,7 +7450,7 @@ declare class JavascriptParser extends Parser {
 	callHooksForInfoWithFallback<T, R>(
 		hookMap: HookMap<SyncBailHook<T, R>>,
 		info: ExportedVariableInfo,
-		fallback: undefined | ((name: string) => any),
+		fallback: undefined | ((name: string) => undefined | R),
 		defined: undefined | ((result?: string) => any),
 		...args: AsArray<T>
 	): undefined | R;
@@ -7224,12 +7598,7 @@ declare class JavascriptParser extends Parser {
 			| Super
 	): BasicEvaluatedExpression;
 	parseString(expression: Expression): string;
-	parseCalculatedString(expression: Expression): {
-		range?: [number, number];
-		value: string;
-		code: boolean;
-		conditional: any;
-	};
+	parseCalculatedString(expression: Expression): CalculatedStringResult;
 	evaluate(source: string): BasicEvaluatedExpression;
 	isPure(
 		expr:
@@ -7396,8 +7765,9 @@ declare class JavascriptParser extends Parser {
 				getMembers: () => string[];
 		  };
 	static ALLOWED_MEMBER_TYPES_ALL: 3;
-	static ALLOWED_MEMBER_TYPES_EXPRESSION: 2;
 	static ALLOWED_MEMBER_TYPES_CALL_EXPRESSION: 1;
+	static ALLOWED_MEMBER_TYPES_EXPRESSION: 2;
+	static VariableInfo: typeof VariableInfo;
 	static getImportAttributes: (
 		node:
 			| ImportDeclarationJavascriptParser
@@ -7405,7 +7775,6 @@ declare class JavascriptParser extends Parser {
 			| ExportAllDeclarationJavascriptParser
 			| ImportExpressionJavascriptParser
 	) => undefined | ImportAttributes;
-	static VariableInfo: typeof VariableInfo;
 }
 
 /**
@@ -7459,6 +7828,11 @@ declare interface JavascriptParserOptions {
 	 */
 	dynamicImportPreload?: number | boolean;
 
+	/**
+	 * Enable/disable parsing of dynamic URL.
+	 */
+	dynamicUrl?: boolean;
+
 	/**
 	 * Specifies the behavior of invalid export names in "import ... from ..." and "export ... from ...".
 	 */
@@ -7604,6 +7978,17 @@ declare interface JavascriptParserOptions {
 	 */
 	wrappedContextRegExp?: RegExp;
 }
+declare abstract class JsonData {
+	get():
+		| undefined
+		| null
+		| string
+		| number
+		| boolean
+		| JsonObjectFs
+		| JsonValueFs[];
+	updateHash(hash: Hash): void;
+}
 
 /**
  * Generator options for json modules.
@@ -7827,6 +8212,11 @@ declare interface KnownBuildInfo {
 	 */
 	assets?: Record<string, Source>;
 
+	/**
+	 * using in NormalModule
+	 */
+	assetsInfo?: Map<string, undefined | AssetInfo>;
+
 	/**
 	 * using in NormalModule
 	 */
@@ -7850,19 +8240,39 @@ declare interface KnownBuildInfo {
 	/**
 	 * for assets modules
 	 */
-	assetsInfo?: Map<string, undefined | AssetInfo>;
+	dataUrl?: boolean;
 
 	/**
 	 * for assets modules
 	 */
-	dataUrl?: boolean;
+	assetInfo?: AssetInfo;
 
 	/**
-	 * for css modules
+	 * for external modules
 	 */
-	cssData?: CssData;
-}
-declare interface KnownBuildMeta {
+	javascriptModule?: boolean;
+
+	/**
+	 * for lazy compilation modules
+	 */
+	active?: boolean;
+
+	/**
+	 * for css modules
+	 */
+	cssData?: CssData;
+
+	/**
+	 * for json modules
+	 */
+	jsonData?: JsonData;
+
+	/**
+	 * top level declaration names
+	 */
+	topLevelDeclarations?: Set<string>;
+}
+declare interface KnownBuildMeta {
 	exportsType?: "namespace" | "dynamic" | "default" | "flagged";
 	defaultObject?: false | "redirect" | "redirect-warn";
 	strictHarmonyModule?: boolean;
@@ -7870,11 +8280,15 @@ declare interface KnownBuildMeta {
 	sideEffectFree?: boolean;
 	exportsFinalName?: Record<string, string>;
 	isCSSModule?: boolean;
+	jsIncompatibleExports?: Record<string, string>;
 }
 declare interface KnownCreateStatsOptionsContext {
 	forToString?: boolean;
 }
 declare interface KnownHooks {
+	/**
+	 * resolve step hook
+	 */
 	resolveStep: SyncHook<
 		[
 			AsyncSeriesBailHook<
@@ -7884,11 +8298,23 @@ declare interface KnownHooks {
 			ResolveRequest
 		]
 	>;
+
+	/**
+	 * no resolve hook
+	 */
 	noResolve: SyncHook<[ResolveRequest, Error]>;
+
+	/**
+	 * resolve hook
+	 */
 	resolve: AsyncSeriesBailHook<
 		[ResolveRequest, ResolveContext],
 		null | ResolveRequest
 	>;
+
+	/**
+	 * result hook
+	 */
 	result: AsyncSeriesHook<[ResolveRequest, ResolveContext]>;
 }
 declare interface KnownNormalizedStatsOptions {
@@ -7934,6 +8360,18 @@ declare interface KnownNormalizedStatsOptions {
 	loggingDebug: ((value: string) => boolean)[];
 	loggingTrace: boolean;
 }
+declare interface KnownRecords {
+	aggressiveSplits?: SplitData[];
+	chunks?: RecordsChunks;
+	modules?: RecordsModules;
+	hash?: string;
+	hotIndex?: number;
+	fullHashChunkModuleHashes?: FullHashChunkModuleHashes;
+	chunkModuleHashes?: ChunkModuleHashes;
+	chunkHashes?: ChunkHashes;
+	chunkRuntime?: ChunkRuntime;
+	chunkModuleIds?: ChunkModuleIds;
+}
 declare interface KnownStatsAsset {
 	type: string;
 	name: string;
@@ -8249,24 +8687,24 @@ declare interface LStatSync {
 declare interface LStatTypes {
 	(
 		path: PathLikeTypes,
-		callback: (arg0: null | NodeJS.ErrnoException, arg1?: IStats) => void
+		callback: (err: null | NodeJS.ErrnoException, result?: IStats) => void
 	): void;
 	(
 		path: PathLikeTypes,
 		options: undefined | (StatOptions & { bigint?: false }),
-		callback: (arg0: null | NodeJS.ErrnoException, arg1?: IStats) => void
+		callback: (err: null | NodeJS.ErrnoException, result?: IStats) => void
 	): void;
 	(
 		path: PathLikeTypes,
 		options: StatOptions & { bigint: true },
-		callback: (arg0: null | NodeJS.ErrnoException, arg1?: IBigIntStats) => void
+		callback: (err: null | NodeJS.ErrnoException, result?: IBigIntStats) => void
 	): void;
 	(
 		path: PathLikeTypes,
 		options: undefined | StatOptions,
 		callback: (
-			arg0: null | NodeJS.ErrnoException,
-			arg1?: IStats | IBigIntStats
+			err: null | NodeJS.ErrnoException,
+			result?: IStats | IBigIntStats
 		) => void
 	): void;
 }
@@ -8350,16 +8788,16 @@ declare class LazySet<T> {
 	addAll(iterable: LazySet<T> | Iterable<T>): LazySet<T>;
 	clear(): void;
 	delete(value: T): boolean;
-	entries(): IterableIterator<[T, T]>;
+	entries(): SetIterator<[T, T]>;
 	forEach<K>(
 		callbackFn: (value: T, value2: T, set: Set<T>) => void,
 		thisArg: K
 	): void;
 	has(item: T): boolean;
-	keys(): IterableIterator<T>;
-	values(): IterableIterator<T>;
+	keys(): SetIterator<T>;
+	values(): SetIterator<T>;
 	serialize(__0: ObjectSerializerContext): void;
-	[Symbol.iterator](): IterableIterator<T>;
+	[Symbol.iterator](): SetIterator<T>;
 	static deserialize<T>(__0: ObjectDeserializerContext): LazySet<T>;
 }
 declare interface LibIdentOptions {
@@ -8584,7 +9022,7 @@ type LoaderContextDeclarationsIndex<OptionsType> =
 		LoaderRunnerLoaderContext<OptionsType> &
 		LoaderPluginLoaderContext &
 		HotModuleReplacementPluginLoaderContext;
-type LoaderContextNormalModule<T> = NormalModuleLoaderContext<T> &
+type LoaderContextObject<T> = NormalModuleLoaderContext<T> &
 	LoaderRunnerLoaderContext<T> &
 	LoaderPluginLoaderContext &
 	HotModuleReplacementPluginLoaderContext;
@@ -8606,7 +9044,7 @@ declare interface LoaderDefinitionFunction<
 			HotModuleReplacementPluginLoaderContext &
 			ContextAdditions,
 		content: string,
-		sourceMap?: string | SourceMap,
+		sourceMap?: string | RawSourceMap,
 		additionalData?: AdditionalData
 	): string | void | Buffer | Promise<string | Buffer>;
 }
@@ -8707,7 +9145,7 @@ declare interface LoaderRunnerLoaderContext<OptionsType> {
 	async(): (
 		err?: null | Error,
 		content?: string | Buffer,
-		sourceMap?: null | string | SourceMap,
+		sourceMap?: null | string | RawSourceMap,
 		additionalData?: AdditionalData
 	) => void;
 
@@ -8721,7 +9159,7 @@ declare interface LoaderRunnerLoaderContext<OptionsType> {
 	callback: (
 		err?: null | Error,
 		content?: string | Buffer,
-		sourceMap?: null | string | SourceMap,
+		sourceMap?: null | string | RawSourceMap,
 		additionalData?: AdditionalData
 	) => void;
 
@@ -9005,7 +9443,14 @@ declare interface MakeDirectoryOptions {
 	mode?: string | number;
 }
 declare interface MapOptions {
+	/**
+	 * need columns?
+	 */
 	columns?: boolean;
+
+	/**
+	 * is module
+	 */
 	module?: boolean;
 }
 declare interface MatchObject {
@@ -9163,10 +9608,7 @@ declare class Module extends DependenciesBlock {
 	isProvided(exportName: string): null | boolean;
 	get exportsArgument(): string;
 	get moduleArgument(): string;
-	getExportsType(
-		moduleGraph: ModuleGraph,
-		strict?: boolean
-	): "namespace" | "default-only" | "default-with-named" | "dynamic";
+	getExportsType(moduleGraph: ModuleGraph, strict?: boolean): ExportsType;
 	addPresentationalDependency(presentationalDependency: Dependency): void;
 	addCodeGenerationDependency(codeGenerationDependency: Dependency): void;
 	addWarning(warning: WebpackError): void;
@@ -9505,6 +9947,7 @@ declare class ModuleGraph {
 	setDepth(module: Module, depth: number): void;
 	setDepthIfLower(module: Module, depth: number): boolean;
 	isAsync(module: Module): boolean;
+	isDeferred(module: Module): boolean;
 	setAsync(module: Module): void;
 	getMeta(thing: object): any;
 	getMetaIfExisting(thing: object): any;
@@ -9577,12 +10020,12 @@ declare class ModuleGraphConnection {
 	getActiveState(runtime: RuntimeSpec): ConnectionState;
 	setActive(value: boolean): void;
 	active: void;
+	static CIRCULAR_CONNECTION: typeof CIRCULAR_CONNECTION;
+	static TRANSITIVE_ONLY: typeof TRANSITIVE_ONLY;
 	static addConnectionStates: (
 		a: ConnectionState,
 		b: ConnectionState
 	) => ConnectionState;
-	static TRANSITIVE_ONLY: typeof TRANSITIVE_ONLY;
-	static CIRCULAR_CONNECTION: typeof CIRCULAR_CONNECTION;
 }
 type ModuleId = string | number;
 type ModuleInfo = ConcatenatedModuleInfo | ExternalModuleInfo;
@@ -9797,6 +10240,11 @@ declare interface ModuleReferenceOptions {
 	 */
 	directImport: boolean;
 
+	/**
+	 * true, when this referenced export is deferred
+	 */
+	deferredImport: boolean;
+
 	/**
 	 * if the position is ASI safe or unknown
 	 */
@@ -9937,7 +10385,7 @@ declare class MultiCompiler {
 	runWithDependencies(
 		compilers: Compiler[],
 		fn: (compiler: Compiler, callback: CallbackFunction_1<MultiStats>) => any,
-		callback: CallbackFunction_1<MultiStats>
+		callback: CallbackFunction_1<Stats[]>
 	): void;
 	watch(
 		watchOptions: WatchOptions | WatchOptions[],
@@ -10127,17 +10575,17 @@ declare class NormalModule extends Module {
 		context: string,
 		name: string,
 		content: string | Buffer,
-		sourceMap?: string | SourceMap,
+		sourceMap?: string | RawSourceMap,
 		associatedObjectForCache?: object
 	): Source;
 	getCurrentLoader(
-		loaderContext: LoaderContextNormalModule<any>,
+		loaderContext: LoaderContextObject<any>,
 		index?: number
 	): null | LoaderItem;
 	createSource(
 		context: string,
 		content: string | Buffer,
-		sourceMap?: null | string | SourceMapSource,
+		sourceMap?: null | string | RawSourceMap,
 		associatedObjectForCache?: object
 	): Source;
 	markModuleAsErrored(error: WebpackError): void;
@@ -10157,9 +10605,9 @@ declare class NormalModule extends Module {
 	static deserialize(context: ObjectDeserializerContext): NormalModule;
 }
 declare interface NormalModuleCompilationHooks {
-	loader: SyncHook<[LoaderContextNormalModule<any>, NormalModule]>;
+	loader: SyncHook<[LoaderContextObject<any>, NormalModule]>;
 	beforeLoaders: SyncHook<
-		[LoaderItem[], NormalModule, LoaderContextNormalModule<any>]
+		[LoaderItem[], NormalModule, LoaderContextObject<any>]
 	>;
 	beforeParse: SyncHook<[NormalModule]>;
 	beforeSnapshot: SyncHook<[NormalModule]>;
@@ -10169,13 +10617,17 @@ declare interface NormalModuleCompilationHooks {
 		>
 	>;
 	readResource: HookMap<
-		AsyncSeriesBailHook<
-			[LoaderContextNormalModule<any>],
-			null | string | Buffer
-		>
+		AsyncSeriesBailHook<[LoaderContextObject<any>], null | string | Buffer>
 	>;
 	processResult: SyncWaterfallHook<
-		[[string | Buffer, string | SourceMapSource, PreparsedAst], NormalModule]
+		[
+			[
+				string | Buffer,
+				undefined | string | RawSourceMap,
+				undefined | PreparsedAst
+			],
+			NormalModule
+		]
 	>;
 	needBuild: AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>;
 }
@@ -10188,7 +10640,7 @@ declare interface NormalModuleCreateData {
 	/**
 	 * module type. When deserializing, this is set to an empty string "".
 	 */
-	type: "" | "javascript/auto" | "javascript/dynamic" | "javascript/esm";
+	type: string;
 
 	/**
 	 * request string
@@ -10287,7 +10739,15 @@ declare abstract class NormalModuleFactory extends ModuleFactory {
 			SyncBailHook<[GeneratorOptions], void | Generator>
 		>;
 		generator: HookMap<SyncBailHook<[any, GeneratorOptions], void>>;
-		createModuleClass: HookMap<SyncBailHook<[any, ResolveData], void | Module>>;
+		createModuleClass: HookMap<
+			SyncBailHook<
+				[
+					Partial<NormalModuleCreateData & { settings: ModuleSettings }>,
+					ResolveData
+				],
+				void | Module
+			>
+		>;
 	}>;
 	resolverFactory: ResolverFactory;
 	ruleSet: RuleSet;
@@ -10451,6 +10911,9 @@ declare class NullDependency extends Dependency {
 declare class NullDependencyTemplate extends DependencyTemplate {
 	constructor();
 }
+declare interface ObjectConfiguration {
+	[index: string]: any;
+}
 declare interface ObjectDeserializerContext {
 	read: () => any;
 	setCircularReference: (value: ReferenceableItem) => void;
@@ -11153,8 +11616,26 @@ declare interface OriginRecord {
 	request: string;
 }
 declare class OriginalSource extends Source {
-	constructor(source: string | Buffer, name: string);
+	constructor(value: string | Buffer, name: string);
 	getName(): string;
+	streamChunks(
+		options: StreamChunksOptions,
+		onChunk: (
+			chunk: undefined | string,
+			generatedLine: number,
+			generatedColumn: number,
+			sourceIndex: number,
+			originalLine: number,
+			originalColumn: number,
+			nameIndex: number
+		) => void,
+		onSource: (
+			sourceIndex: number,
+			source: null | string,
+			sourceContent?: string
+		) => void,
+		_onName: (nameIndex: number, name: string) => void
+	): GeneratedSourceInfo;
 }
 
 /**
@@ -11727,12 +12208,39 @@ declare interface ParameterizedComparator<TArg extends object, T> {
 	(tArg: TArg): Comparator<T>;
 }
 declare interface ParsedIdentifier {
+	/**
+	 * request
+	 */
 	request: string;
+
+	/**
+	 * query
+	 */
 	query: string;
+
+	/**
+	 * fragment
+	 */
 	fragment: string;
+
+	/**
+	 * is directory
+	 */
 	directory: boolean;
+
+	/**
+	 * is module
+	 */
 	module: boolean;
+
+	/**
+	 * is file
+	 */
 	file: boolean;
+
+	/**
+	 * is internal
+	 */
 	internal: boolean;
 }
 declare class Parser {
@@ -11945,13 +12453,16 @@ type Plugin =
 	| false
 	| ""
 	| 0
-	| { apply: (arg0: Resolver) => void }
-	| ((this: Resolver, arg1: Resolver) => void);
+	| { apply: (this: Resolver, resolver: Resolver) => void }
+	| ((this: Resolver, resolver: Resolver) => void);
 declare interface PnpApi {
+	/**
+	 * resolve to unqualified
+	 */
 	resolveToUnqualified: (
-		arg0: string,
-		arg1: string,
-		arg2: object
+		packageName: string,
+		issuer: string,
+		options: { considerBuiltins: boolean }
 	) => null | string;
 }
 declare class PrefetchPlugin {
@@ -11965,9 +12476,27 @@ declare class PrefetchPlugin {
 	apply(compiler: Compiler): void;
 }
 declare class PrefixSource extends Source {
-	constructor(prefix: string, source: string | Source);
-	original(): Source;
+	constructor(prefix: string, source: string | Source | Buffer);
 	getPrefix(): string;
+	original(): Source;
+	streamChunks(
+		options: StreamChunksOptions,
+		onChunk: (
+			chunk: undefined | string,
+			generatedLine: number,
+			generatedColumn: number,
+			sourceIndex: number,
+			originalLine: number,
+			originalColumn: number,
+			nameIndex: number
+		) => void,
+		onSource: (
+			sourceIndex: number,
+			source: null | string,
+			sourceContent?: string
+		) => void,
+		onName: (nameIndex: number, name: string) => void
+	): GeneratedSourceInfo;
 }
 declare interface PreparsedAst {
 	[index: string]: any;
@@ -12185,22 +12714,77 @@ declare interface RawLoaderDefinitionFunction<
 			HotModuleReplacementPluginLoaderContext &
 			ContextAdditions,
 		content: Buffer,
-		sourceMap?: string | SourceMap,
+		sourceMap?: string | RawSourceMap,
 		additionalData?: AdditionalData
 	): string | void | Buffer | Promise<string | Buffer>;
 }
 declare class RawSource extends Source {
-	constructor(source: string | Buffer, convertToString?: boolean);
+	constructor(value: string | Buffer, convertToString?: boolean);
 	isBuffer(): boolean;
+	streamChunks(
+		options: StreamChunksOptions,
+		onChunk: (
+			chunk: undefined | string,
+			generatedLine: number,
+			generatedColumn: number,
+			sourceIndex: number,
+			originalLine: number,
+			originalColumn: number,
+			nameIndex: number
+		) => void,
+		onSource: (
+			sourceIndex: number,
+			source: null | string,
+			sourceContent?: string
+		) => void,
+		onName: (nameIndex: number, name: string) => void
+	): GeneratedSourceInfo;
 }
 declare interface RawSourceMap {
+	/**
+	 * version
+	 */
 	version: number;
+
+	/**
+	 * sources
+	 */
 	sources: string[];
+
+	/**
+	 * names
+	 */
 	names: string[];
+
+	/**
+	 * source root
+	 */
 	sourceRoot?: string;
+
+	/**
+	 * sources content
+	 */
 	sourcesContent?: string[];
+
+	/**
+	 * mappings
+	 */
 	mappings: string;
+
+	/**
+	 * file
+	 */
 	file: string;
+
+	/**
+	 * debug id
+	 */
+	debugId?: string;
+
+	/**
+	 * ignore list
+	 */
+	ignoreList?: number[];
 }
 declare interface Read<
 	TBuffer extends
@@ -12381,7 +12965,7 @@ declare interface ReadFileTypes {
 			| undefined
 			| null
 			| ({ encoding?: null; flag?: string } & Abortable),
-		callback: (arg0: null | NodeJS.ErrnoException, arg1?: Buffer) => void
+		callback: (err: null | NodeJS.ErrnoException, result?: Buffer) => void
 	): void;
 	(
 		path: PathOrFileDescriptorTypes,
@@ -12399,7 +12983,7 @@ declare interface ReadFileTypes {
 			| "binary"
 			| "hex"
 			| ({ encoding: BufferEncoding; flag?: string } & Abortable),
-		callback: (arg0: null | NodeJS.ErrnoException, arg1?: string) => void
+		callback: (err: null | NodeJS.ErrnoException, result?: string) => void
 	): void;
 	(
 		path: PathOrFileDescriptorTypes,
@@ -12420,13 +13004,13 @@ declare interface ReadFileTypes {
 			| "hex"
 			| (ObjectEncodingOptions & { flag?: string } & Abortable),
 		callback: (
-			arg0: null | NodeJS.ErrnoException,
-			arg1?: string | Buffer
+			err: null | NodeJS.ErrnoException,
+			result?: string | Buffer
 		) => void
 	): void;
 	(
 		path: PathOrFileDescriptorTypes,
-		callback: (arg0: null | NodeJS.ErrnoException, arg1?: Buffer) => void
+		callback: (err: null | NodeJS.ErrnoException, result?: Buffer) => void
 	): void;
 }
 declare interface ReaddirFs {
@@ -12465,18 +13049,14 @@ declare interface ReaddirFs {
 					withFileTypes?: false;
 					recursive?: boolean;
 			  },
-		callback: (err: null | NodeJS.ErrnoException, result?: string[]) => void
+		callback: (err: null | NodeJS.ErrnoException, files?: string[]) => void
 	): void;
 	(
 		path: PathLikeFs,
 		options:
 			| "buffer"
 			| { encoding: "buffer"; withFileTypes?: false; recursive?: boolean },
-		callback: (err: null | NodeJS.ErrnoException, result?: Buffer[]) => void
-	): void;
-	(
-		path: PathLikeFs,
-		callback: (err: null | NodeJS.ErrnoException, result?: string[]) => void
+		callback: (err: null | NodeJS.ErrnoException, files?: Buffer[]) => void
 	): void;
 	(
 		path: PathLikeFs,
@@ -12501,16 +13081,31 @@ declare interface ReaddirFs {
 			  }),
 		callback: (
 			err: null | NodeJS.ErrnoException,
-			result?: string[] | Buffer[]
+			files?: string[] | Buffer[]
 		) => void
 	): void;
+	(
+		path: PathLikeFs,
+		callback: (err: null | NodeJS.ErrnoException, files?: string[]) => void
+	): void;
 	(
 		path: PathLikeFs,
 		options: ObjectEncodingOptions & {
 			withFileTypes: true;
 			recursive?: boolean;
 		},
-		callback: (err: null | NodeJS.ErrnoException, result?: Dirent[]) => void
+		callback: (
+			err: null | NodeJS.ErrnoException,
+			files?: Dirent<string>[]
+		) => void
+	): void;
+	(
+		path: PathLikeFs,
+		options: { encoding: "buffer"; withFileTypes: true; recursive?: boolean },
+		callback: (
+			err: null | NodeJS.ErrnoException,
+			files: Dirent<Buffer>[]
+		) => void
 	): void;
 }
 declare interface ReaddirSync {
@@ -12579,7 +13174,11 @@ declare interface ReaddirSync {
 			withFileTypes: true;
 			recursive?: boolean;
 		}
-	): Dirent[];
+	): Dirent<string>[];
+	(
+		path: PathLikeFs,
+		options: { encoding: "buffer"; withFileTypes: true; recursive?: boolean }
+	): Dirent<Buffer>[];
 }
 declare interface ReaddirTypes {
 	(
@@ -12617,18 +13216,14 @@ declare interface ReaddirTypes {
 					withFileTypes?: false;
 					recursive?: boolean;
 			  },
-		callback: (arg0: null | NodeJS.ErrnoException, arg1?: string[]) => void
+		callback: (err: null | NodeJS.ErrnoException, files?: string[]) => void
 	): void;
 	(
 		path: PathLikeTypes,
 		options:
 			| "buffer"
 			| { encoding: "buffer"; withFileTypes?: false; recursive?: boolean },
-		callback: (arg0: null | NodeJS.ErrnoException, arg1?: Buffer[]) => void
-	): void;
-	(
-		path: PathLikeTypes,
-		callback: (arg0: null | NodeJS.ErrnoException, arg1?: string[]) => void
+		callback: (err: null | NodeJS.ErrnoException, files?: Buffer[]) => void
 	): void;
 	(
 		path: PathLikeTypes,
@@ -12652,17 +13247,32 @@ declare interface ReaddirTypes {
 					recursive?: boolean;
 			  }),
 		callback: (
-			arg0: null | NodeJS.ErrnoException,
-			arg1?: string[] | Buffer[]
+			err: null | NodeJS.ErrnoException,
+			files?: string[] | Buffer[]
 		) => void
 	): void;
+	(
+		path: PathLikeTypes,
+		callback: (err: null | NodeJS.ErrnoException, files?: string[]) => void
+	): void;
 	(
 		path: PathLikeTypes,
 		options: ObjectEncodingOptions & {
 			withFileTypes: true;
 			recursive?: boolean;
 		},
-		callback: (arg0: null | NodeJS.ErrnoException, arg1?: Dirent[]) => void
+		callback: (
+			err: null | NodeJS.ErrnoException,
+			files?: Dirent<string>[]
+		) => void
+	): void;
+	(
+		path: PathLikeTypes,
+		options: { encoding: "buffer"; withFileTypes: true; recursive?: boolean },
+		callback: (
+			err: null | NodeJS.ErrnoException,
+			files: Dirent<Buffer>[]
+		) => void
 	): void;
 }
 declare interface ReadlinkFs {
@@ -12698,24 +13308,24 @@ declare interface ReadlinkTypes {
 	(
 		path: PathLikeTypes,
 		options: EncodingOption,
-		callback: (arg0: null | NodeJS.ErrnoException, arg1?: string) => void
+		callback: (err: null | NodeJS.ErrnoException, result?: string) => void
 	): void;
 	(
 		path: PathLikeTypes,
 		options: BufferEncodingOption,
-		callback: (arg0: null | NodeJS.ErrnoException, arg1?: Buffer) => void
+		callback: (err: null | NodeJS.ErrnoException, result?: Buffer) => void
 	): void;
 	(
 		path: PathLikeTypes,
 		options: EncodingOption,
 		callback: (
-			arg0: null | NodeJS.ErrnoException,
-			arg1?: string | Buffer
+			err: null | NodeJS.ErrnoException,
+			result?: string | Buffer
 		) => void
 	): void;
 	(
 		path: PathLikeTypes,
-		callback: (arg0: null | NodeJS.ErrnoException, arg1?: string) => void
+		callback: (err: null | NodeJS.ErrnoException, result?: string) => void
 	): void;
 }
 declare class RealContentHashPlugin {
@@ -12778,28 +13388,37 @@ declare interface RealPathTypes {
 	(
 		path: PathLikeTypes,
 		options: EncodingOption,
-		callback: (arg0: null | NodeJS.ErrnoException, arg1?: string) => void
+		callback: (err: null | NodeJS.ErrnoException, result?: string) => void
 	): void;
 	(
 		path: PathLikeTypes,
 		options: BufferEncodingOption,
-		callback: (arg0: null | NodeJS.ErrnoException, arg1?: Buffer) => void
+		callback: (err: null | NodeJS.ErrnoException, result?: Buffer) => void
 	): void;
 	(
 		path: PathLikeTypes,
 		options: EncodingOption,
 		callback: (
-			arg0: null | NodeJS.ErrnoException,
-			arg1?: string | Buffer
+			err: null | NodeJS.ErrnoException,
+			result?: string | Buffer
 		) => void
 	): void;
 	(
 		path: PathLikeTypes,
-		callback: (arg0: null | NodeJS.ErrnoException, arg1?: string) => void
+		callback: (err: null | NodeJS.ErrnoException, result?: string) => void
 	): void;
 }
-declare interface Records {
-	[index: string]: any;
+type Records = KnownRecords &
+	Record<string, KnownRecords[]> &
+	Record<string, any>;
+declare interface RecordsChunks {
+	byName?: Record<string, number>;
+	bySource?: Record<string, number>;
+	usedIds?: number[];
+}
+declare interface RecordsModules {
+	byIdentifier?: Record<string, number>;
+	usedIds?: number[];
 }
 type RecursiveArrayOrRecord<T> =
 	| { [index: string]: RecursiveArrayOrRecord<T> }
@@ -12980,17 +13599,38 @@ declare interface RenderManifestOptions {
 }
 declare class ReplaceSource extends Source {
 	constructor(source: Source, name?: string);
+	getName(): undefined | string;
+	getReplacements(): Replacement[];
 	replace(start: number, end: number, newValue: string, name?: string): void;
 	insert(pos: number, newValue: string, name?: string): void;
-	getName(): string;
-	original(): string;
-	getReplacements(): {
-		start: number;
-		end: number;
-		content: string;
-		insertIndex: number;
-		name: string;
-	}[];
+	original(): Source;
+	streamChunks(
+		options: StreamChunksOptions,
+		onChunk: (
+			chunk: undefined | string,
+			generatedLine: number,
+			generatedColumn: number,
+			sourceIndex: number,
+			originalLine: number,
+			originalColumn: number,
+			nameIndex: number
+		) => void,
+		onSource: (
+			sourceIndex: number,
+			source: null | string,
+			sourceContent?: string
+		) => void,
+		onName: (nameIndex: number, name: string) => void
+	): GeneratedSourceInfo;
+	static Replacement: typeof Replacement;
+}
+declare class Replacement {
+	constructor(start: number, end: number, content: string, name?: string);
+	start: number;
+	end: number;
+	content: string;
+	name?: string;
+	index?: number;
 }
 declare interface RequestRecord {
 	[index: string]: string | string[];
@@ -13026,6 +13666,9 @@ declare interface ResolveBuildDependenciesResult {
 	resolveDependencies: ResolveDependencies;
 }
 declare interface ResolveContext {
+	/**
+	 * directories that was found on file system
+	 */
 	contextDependencies?: WriteOnlySet<string>;
 
 	/**
@@ -13046,12 +13689,12 @@ declare interface ResolveContext {
 	/**
 	 * log function
 	 */
-	log?: (arg0: string) => void;
+	log?: (str: string) => void;
 
 	/**
 	 * yield result, if provided plugins can return several results
 	 */
-	yield?: (arg0: ResolveRequest) => void;
+	yield?: (request: ResolveRequest) => void;
 }
 declare interface ResolveData {
 	contextInfo: ModuleFactoryCreateDataContextInfo;
@@ -13279,123 +13922,226 @@ declare interface ResolveOptions {
 	useSyncFileSystemCalls?: boolean;
 }
 declare interface ResolveOptionsResolverFactoryObject1 {
-	alias: AliasOption[];
-	fallback: AliasOption[];
-	aliasFields: Set<string | string[]>;
-	extensionAlias: ExtensionAliasOption[];
-	cachePredicate: (arg0: ResolveRequest) => boolean;
-	cacheWithContext: boolean;
-
-	/**
-	 * A list of exports field condition names.
-	 */
-	conditionNames: Set<string>;
-	descriptionFiles: string[];
-	enforceExtension: boolean;
-	exportsFields: Set<string | string[]>;
-	importsFields: Set<string | string[]>;
-	extensions: Set<string>;
-	fileSystem: FileSystem;
-	unsafeCache: false | object;
-	symlinks: boolean;
-	resolver?: Resolver;
-	modules: (string | string[])[];
-	mainFields: { name: string[]; forceRelative: boolean }[];
-	mainFiles: Set<string>;
-	plugins: Plugin[];
-	pnpApi: null | PnpApi;
-	roots: Set<string>;
-	fullySpecified: boolean;
-	resolveToContext: boolean;
-	restrictions: Set<string | RegExp>;
-	preferRelative: boolean;
-	preferAbsolute: boolean;
-}
-declare interface ResolveOptionsResolverFactoryObject2 {
 	/**
-	 * A list of module alias configurations or an object which maps key to value
+	 * alias
 	 */
-	alias?: AliasOption[] | AliasOptions;
+	alias: AliasOption[];
 
 	/**
-	 * A list of module alias configurations or an object which maps key to value, applied only after modules option
+	 * fallback
 	 */
-	fallback?: AliasOption[] | AliasOptions;
+	fallback: AliasOption[];
 
 	/**
-	 * An object which maps extension to extension aliases
+	 * alias fields
 	 */
-	extensionAlias?: ExtensionAliasOptions;
+	aliasFields: Set<string | string[]>;
 
 	/**
-	 * A list of alias fields in description files
+	 * extension alias
 	 */
-	aliasFields?: (string | string[])[];
+	extensionAlias: ExtensionAliasOption[];
 
 	/**
-	 * A function which decides whether a request should be cached or not. An object is passed with at least `path` and `request` properties.
+	 * cache predicate
 	 */
-	cachePredicate?: (arg0: ResolveRequest) => boolean;
+	cachePredicate: (predicate: ResolveRequest) => boolean;
 
 	/**
-	 * Whether or not the unsafeCache should include request context as part of the cache key.
+	 * cache with context
 	 */
-	cacheWithContext?: boolean;
+	cacheWithContext: boolean;
 
 	/**
-	 * A list of description files to read from
+	 * A list of exports field condition names.
 	 */
-	descriptionFiles?: string[];
+	conditionNames: Set<string>;
 
 	/**
-	 * A list of exports field condition names.
+	 * description files
 	 */
-	conditionNames?: string[];
+	descriptionFiles: string[];
 
 	/**
-	 * Enforce that a extension from extensions must be used
+	 * enforce extension
 	 */
-	enforceExtension?: boolean;
+	enforceExtension: boolean;
 
 	/**
-	 * A list of exports fields in description files
+	 * exports fields
 	 */
-	exportsFields?: (string | string[])[];
+	exportsFields: Set<string | string[]>;
 
 	/**
-	 * A list of imports fields in description files
+	 * imports fields
 	 */
-	importsFields?: (string | string[])[];
+	importsFields: Set<string | string[]>;
 
 	/**
-	 * A list of extensions which should be tried for files
+	 * extensions
 	 */
-	extensions?: string[];
+	extensions: Set<string>;
 
 	/**
-	 * The file system which should be used
+	 * fileSystem
 	 */
 	fileSystem: FileSystem;
 
 	/**
-	 * Use this cache object to unsafely cache the successful requests
+	 * unsafe cache
 	 */
-	unsafeCache?: boolean | object;
+	unsafeCache: false | CacheTypes;
 
 	/**
-	 * Resolve symlinks to their symlinked location
+	 * symlinks
 	 */
-	symlinks?: boolean;
+	symlinks: boolean;
 
 	/**
-	 * A prepared Resolver to which the plugins are attached
+	 * resolver
 	 */
 	resolver?: Resolver;
 
 	/**
-	 * A list of directories to resolve modules from, can be absolute path or folder name
+	 * modules
 	 */
-	modules?: string | string[];
+	modules: (string | string[])[];
+
+	/**
+	 * main fields
+	 */
+	mainFields: { name: string[]; forceRelative: boolean }[];
+
+	/**
+	 * main files
+	 */
+	mainFiles: Set<string>;
+
+	/**
+	 * plugins
+	 */
+	plugins: Plugin[];
+
+	/**
+	 * pnp API
+	 */
+	pnpApi: null | PnpApi;
+
+	/**
+	 * roots
+	 */
+	roots: Set<string>;
+
+	/**
+	 * fully specified
+	 */
+	fullySpecified: boolean;
+
+	/**
+	 * resolve to context
+	 */
+	resolveToContext: boolean;
+
+	/**
+	 * restrictions
+	 */
+	restrictions: Set<string | RegExp>;
+
+	/**
+	 * prefer relative
+	 */
+	preferRelative: boolean;
+
+	/**
+	 * prefer absolute
+	 */
+	preferAbsolute: boolean;
+}
+declare interface ResolveOptionsResolverFactoryObject2 {
+	/**
+	 * A list of module alias configurations or an object which maps key to value
+	 */
+	alias?: AliasOption[] | AliasOptions;
+
+	/**
+	 * A list of module alias configurations or an object which maps key to value, applied only after modules option
+	 */
+	fallback?: AliasOption[] | AliasOptions;
+
+	/**
+	 * An object which maps extension to extension aliases
+	 */
+	extensionAlias?: ExtensionAliasOptions;
+
+	/**
+	 * A list of alias fields in description files
+	 */
+	aliasFields?: (string | string[])[];
+
+	/**
+	 * A function which decides whether a request should be cached or not. An object is passed with at least `path` and `request` properties.
+	 */
+	cachePredicate?: (predicate: ResolveRequest) => boolean;
+
+	/**
+	 * Whether or not the unsafeCache should include request context as part of the cache key.
+	 */
+	cacheWithContext?: boolean;
+
+	/**
+	 * A list of description files to read from
+	 */
+	descriptionFiles?: string[];
+
+	/**
+	 * A list of exports field condition names.
+	 */
+	conditionNames?: string[];
+
+	/**
+	 * Enforce that a extension from extensions must be used
+	 */
+	enforceExtension?: boolean;
+
+	/**
+	 * A list of exports fields in description files
+	 */
+	exportsFields?: (string | string[])[];
+
+	/**
+	 * A list of imports fields in description files
+	 */
+	importsFields?: (string | string[])[];
+
+	/**
+	 * A list of extensions which should be tried for files
+	 */
+	extensions?: string[];
+
+	/**
+	 * The file system which should be used
+	 */
+	fileSystem: FileSystem;
+
+	/**
+	 * Use this cache object to unsafely cache the successful requests
+	 */
+	unsafeCache?: boolean | CacheTypes;
+
+	/**
+	 * Resolve symlinks to their symlinked location
+	 */
+	symlinks?: boolean;
+
+	/**
+	 * A prepared Resolver to which the plugins are attached
+	 */
+	resolver?: Resolver;
+
+	/**
+	 * A list of directories to resolve modules from, can be absolute path or folder name
+	 */
+	modules?: string | string[];
 
 	/**
 	 * A list of main fields in description files
@@ -14389,6 +15135,10 @@ declare abstract class RuntimeTemplate {
 		 * the module
 		 */
 		module: Module;
+		/**
+		 * the module graph
+		 */
+		moduleGraph: ModuleGraph;
 		/**
 		 * the chunk graph
 		 */
@@ -14413,12 +15163,20 @@ declare abstract class RuntimeTemplate {
 		 * if set, will be filled with runtime requirements
 		 */
 		runtimeRequirements: Set<string>;
+		/**
+		 * if set, the module will be deferred
+		 */
+		defer?: boolean;
 	}): [string, string];
 	exportFromImport<GenerateContext>(__0: {
 		/**
 		 * the module graph
 		 */
 		moduleGraph: ModuleGraph;
+		/**
+		 * the chunk graph
+		 */
+		chunkGraph: ChunkGraph;
 		/**
 		 * the module
 		 */
@@ -14467,6 +15225,10 @@ declare abstract class RuntimeTemplate {
 		 * if set, will be filled with runtime requirements
 		 */
 		runtimeRequirements: Set<string>;
+		/**
+		 * if true, the module will be deferred.
+		 */
+		defer?: boolean;
 	}): string;
 	blockPromise(__0: {
 		/**
@@ -14601,6 +15363,10 @@ declare abstract class SerializerMiddleware<
 		context: Context
 	): DeserializedType | Promise<DeserializedType>;
 }
+declare interface SetIterator<T> extends IteratorObject<T, undefined> {
+	[Symbol.iterator](): SetIterator<T>;
+	[Symbol.dispose](): void;
+}
 declare class SharePlugin {
 	constructor(options: SharePluginOptions);
 
@@ -14861,25 +15627,54 @@ declare abstract class SortableSet<T> extends Set<T> {
 }
 declare class Source {
 	constructor();
+	source(): SourceValue;
+	buffer(): Buffer;
 	size(): number;
 	map(options?: MapOptions): null | RawSourceMap;
-	sourceAndMap(options?: MapOptions): { source: string | Buffer; map: Object };
-	updateHash(hash: Hash): void;
-	source(): string | Buffer;
-	buffer(): Buffer;
+	sourceAndMap(options?: MapOptions): SourceAndMap;
+	updateHash(hash: HashLike): void;
 }
-declare interface SourceLike {
-	source(): string | Buffer;
+declare interface SourceAndMap {
+	/**
+	 * source
+	 */
+	source: SourceValue;
+
+	/**
+	 * map
+	 */
+	map: null | RawSourceMap;
 }
-declare interface SourceMap {
-	version: number;
-	sources: string[];
-	mappings: string;
-	file?: string;
-	sourceRoot?: string;
-	sourcesContent?: string[];
-	names?: string[];
-	debugId?: string;
+declare interface SourceLike {
+	/**
+	 * source
+	 */
+	source: () => SourceValue;
+
+	/**
+	 * buffer
+	 */
+	buffer?: () => Buffer;
+
+	/**
+	 * size
+	 */
+	size?: () => number;
+
+	/**
+	 * map
+	 */
+	map?: (options?: MapOptions) => null | RawSourceMap;
+
+	/**
+	 * source and map
+	 */
+	sourceAndMap?: (options?: MapOptions) => SourceAndMap;
+
+	/**
+	 * hash updater
+	 */
+	updateHash?: (hash: HashLike) => void;
 }
 declare class SourceMapDevToolPlugin {
 	constructor(options?: SourceMapDevToolPluginOptions);
@@ -14980,11 +15775,11 @@ declare interface SourceMapDevToolPluginOptions {
 }
 declare class SourceMapSource extends Source {
 	constructor(
-		source: string | Buffer,
+		value: string | Buffer,
 		name: string,
-		sourceMap: string | Object | Buffer,
+		sourceMap?: string | Buffer | RawSourceMap,
 		originalSource?: string | Buffer,
-		innerSourceMap?: string | Object | Buffer,
+		innerSourceMap?: string | Buffer | RawSourceMap,
 		removeOriginalSource?: boolean
 	);
 	getArgsAsBuffers(): [
@@ -14993,13 +15788,32 @@ declare class SourceMapSource extends Source {
 		Buffer,
 		undefined | Buffer,
 		undefined | Buffer,
-		boolean
+		undefined | boolean
 	];
+	streamChunks(
+		options: StreamChunksOptions,
+		onChunk: (
+			chunk: undefined | string,
+			generatedLine: number,
+			generatedColumn: number,
+			sourceIndex: number,
+			originalLine: number,
+			originalColumn: number,
+			nameIndex: number
+		) => void,
+		onSource: (
+			sourceIndex: number,
+			source: null | string,
+			sourceContent?: string
+		) => void,
+		onName: (nameIndex: number, name: string) => void
+	): GeneratedSourceInfo;
 }
 declare interface SourcePosition {
 	line: number;
 	column?: number;
 }
+type SourceValue = string | Buffer;
 declare interface SplitChunksOptions {
 	chunksFilter: (chunk: Chunk) => undefined | boolean;
 	defaultSizeTypes: string[];
@@ -15035,6 +15849,12 @@ declare class SplitChunksPlugin {
 declare interface SplitChunksSizes {
 	[index: string]: number;
 }
+declare interface SplitData {
+	id?: string | number;
+	hash?: string;
+	modules: Module[];
+	size: number;
+}
 declare abstract class StackedMap<K, V> {
 	map: Map<K, InternalCell<V>>;
 	stack: Map<K, InternalCell<V>>[];
@@ -15107,24 +15927,24 @@ declare interface StatSyncOptions {
 declare interface StatTypes {
 	(
 		path: PathLikeTypes,
-		callback: (arg0: null | NodeJS.ErrnoException, arg1?: IStats) => void
+		callback: (err: null | NodeJS.ErrnoException, result?: IStats) => void
 	): void;
 	(
 		path: PathLikeTypes,
 		options: undefined | (StatOptions & { bigint?: false }),
-		callback: (arg0: null | NodeJS.ErrnoException, arg1?: IStats) => void
+		callback: (err: null | NodeJS.ErrnoException, result?: IStats) => void
 	): void;
 	(
 		path: PathLikeTypes,
 		options: StatOptions & { bigint: true },
-		callback: (arg0: null | NodeJS.ErrnoException, arg1?: IBigIntStats) => void
+		callback: (err: null | NodeJS.ErrnoException, result?: IBigIntStats) => void
 	): void;
 	(
 		path: PathLikeTypes,
 		options: undefined | StatOptions,
 		callback: (
-			arg0: null | NodeJS.ErrnoException,
-			arg1?: IStats | IBigIntStats
+			err: null | NodeJS.ErrnoException,
+			result?: IStats | IBigIntStats
 		) => void
 	): void;
 }
@@ -15778,6 +16598,11 @@ type StatsValue =
 	| "minimal"
 	| "normal"
 	| "detailed";
+declare interface StreamChunksOptions {
+	source?: boolean;
+	finalSource?: boolean;
+	columns?: boolean;
+}
 type Supports = undefined | string;
 declare class SyncModuleIdsPlugin {
 	constructor(__0: SyncModuleIdsPluginOptions);
@@ -15831,6 +16656,7 @@ declare interface TargetItemWithConnection {
 declare interface TargetItemWithoutConnection {
 	module: Module;
 	export: string[];
+	deferred: boolean;
 }
 declare class Template {
 	constructor();
@@ -15861,8 +16687,8 @@ declare class Template {
 		runtimeModules: RuntimeModule[],
 		renderContext: RenderContextJavascriptModulesPlugin
 	): Source;
-	static NUMBER_OF_IDENTIFIER_START_CHARS: number;
 	static NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS: number;
+	static NUMBER_OF_IDENTIFIER_START_CHARS: number;
 }
 type TemplatePath =
 	| string
@@ -15892,11 +16718,6 @@ declare interface TrustedTypes {
 	policyName?: string;
 }
 declare const UNDEFINED_MARKER: unique symbol;
-
-/**
- * `URL` class is a global reference for `require('url').URL`
- * https://nodejs.org/api/url.html#the-whatwg-url-api
- */
 declare interface URL_url extends URL {}
 type UnsafeCacheData = KnownUnsafeCacheData & Record<string, any>;
 declare interface UpdateHashContextDependency {
@@ -15917,6 +16738,9 @@ type UsageStateType = 0 | 1 | 2 | 3 | 4;
 type UsedName = string | false | string[];
 type Value = string | number | boolean | RegExp;
 type ValueCacheVersion = string | Set<string>;
+declare interface Values {
+	[index: string]: Value[];
+}
 declare class VariableInfo {
 	constructor(
 		declaredScope: ScopeInfo,
@@ -15927,6 +16751,46 @@ declare class VariableInfo {
 	freeName?: string | true;
 	tagInfo?: TagInfo;
 }
+declare interface VirtualModuleConfig {
+	/**
+	 * - The module type
+	 */
+	type?: string;
+
+	/**
+	 * - The source function
+	 */
+	source: (loaderContext: LoaderContextObject<any>) => string | Promise<string>;
+
+	/**
+	 * - Optional version function or value
+	 */
+	version?: string | true | (() => string);
+}
+type VirtualModuleInput =
+	| string
+	| ((loaderContext: LoaderContextObject<any>) => string | Promise<string>)
+	| VirtualModuleConfig;
+declare interface VirtualModules {
+	[index: string]: VirtualModuleInput;
+}
+declare class VirtualUrlPlugin {
+	constructor(modules: VirtualModules, scheme?: string);
+	scheme: string;
+	modules: { [index: string]: VirtualModuleConfig };
+
+	/**
+	 * Apply the plugin
+	 */
+	apply(compiler: Compiler): void;
+	findVirtualModuleConfigById(id: string): VirtualModuleConfig;
+
+	/**
+	 * Get the cache version for a given version value
+	 */
+	getCacheVersion(version: string | true | (() => string)): undefined | string;
+	static DEFAULT_SCHEME: string;
+}
 type WarningFilterItemTypes =
 	| string
 	| RegExp
@@ -16467,6 +17331,7 @@ declare interface WriteFile {
 			| Int32Array
 			| BigUint64Array
 			| BigInt64Array
+			| Float16Array
 			| Float32Array
 			| Float64Array
 			| DataView,
@@ -16486,6 +17351,7 @@ declare interface WriteFile {
 			| Int32Array
 			| BigUint64Array
 			| BigInt64Array
+			| Float16Array
 			| Float32Array
 			| Float64Array
 			| DataView,
@@ -16599,8 +17465,8 @@ declare namespace exports {
 		) => Flags;
 		export let processArguments: (
 			args: Flags,
-			config: any,
-			values: Record<string, Value[]>
+			config: ObjectConfiguration,
+			values: Values
 		) => null | Problem[];
 	}
 	export namespace ModuleFilenameHelpers {
@@ -16651,81 +17517,85 @@ declare namespace exports {
 		export let matchObject: (obj: MatchObject, str: string) => boolean;
 	}
 	export namespace OptimizationStages {
+		export let STAGE_ADVANCED: 10;
 		export let STAGE_BASIC: -10;
 		export let STAGE_DEFAULT: 0;
-		export let STAGE_ADVANCED: 10;
 	}
 	export namespace RuntimeGlobals {
-		export let require: "__webpack_require__";
-		export let requireScope: "__webpack_require__.*";
+		export let amdDefine: "__webpack_require__.amdD";
+		export let amdOptions: "__webpack_require__.amdO";
+		export let asyncModule: "__webpack_require__.a";
+		export let asyncModuleDoneSymbol: "__webpack_require__.aD";
+		export let asyncModuleExportSymbol: "__webpack_require__.aE";
+		export let baseURI: "__webpack_require__.b";
+		export let chunkCallback: "webpackChunk";
+		export let chunkName: "__webpack_require__.cn";
+		export let compatGetDefaultExport: "__webpack_require__.n";
+		export let createFakeNamespaceObject: "__webpack_require__.t";
+		export let createScript: "__webpack_require__.ts";
+		export let createScriptUrl: "__webpack_require__.tu";
+		export let currentRemoteGetScope: "__webpack_require__.R";
+		export let definePropertyGetters: "__webpack_require__.d";
+		export let ensureChunk: "__webpack_require__.e";
+		export let ensureChunkHandlers: "__webpack_require__.f";
+		export let ensureChunkIncludeEntries: "__webpack_require__.f (include entries)";
+		export let entryModuleId: "__webpack_require__.s";
 		export let exports: "__webpack_exports__";
-		export let thisAsExports: "top-level-this-exports";
-		export let returnExportsFromRuntime: "return-exports-from-runtime";
+		export let externalInstallChunk: "__webpack_require__.C";
+		export let getChunkCssFilename: "__webpack_require__.k";
+		export let getChunkScriptFilename: "__webpack_require__.u";
+		export let getChunkUpdateCssFilename: "__webpack_require__.hk";
+		export let getChunkUpdateScriptFilename: "__webpack_require__.hu";
+		export let getFullHash: "__webpack_require__.h";
+		export let getTrustedTypesPolicy: "__webpack_require__.tt";
+		export let getUpdateManifestFilename: "__webpack_require__.hmrF";
+		export let global: "__webpack_require__.g";
+		export let harmonyModuleDecorator: "__webpack_require__.hmd";
+		export let hasCssModules: "has css modules";
+		export let hasFetchPriority: "has fetch priority";
+		export let hasOwnProperty: "__webpack_require__.o";
+		export let hmrDownloadManifest: "__webpack_require__.hmrM";
+		export let hmrDownloadUpdateHandlers: "__webpack_require__.hmrC";
+		export let hmrInvalidateModuleHandlers: "__webpack_require__.hmrI";
+		export let hmrModuleData: "__webpack_require__.hmrD";
+		export let hmrRuntimeStatePrefix: "__webpack_require__.hmrS";
+		export let initializeSharing: "__webpack_require__.I";
+		export let instantiateWasm: "__webpack_require__.v";
+		export let interceptModuleExecution: "__webpack_require__.i";
+		export let loadScript: "__webpack_require__.l";
+		export let makeDeferredNamespaceObject: "__webpack_require__.z";
+		export let makeDeferredNamespaceObjectSymbol: "__webpack_require__.zS";
+		export let makeNamespaceObject: "__webpack_require__.r";
 		export let module: "module";
-		export let moduleId: "module.id";
-		export let moduleLoaded: "module.loaded";
-		export let publicPath: "__webpack_require__.p";
-		export let entryModuleId: "__webpack_require__.s";
 		export let moduleCache: "__webpack_require__.c";
 		export let moduleFactories: "__webpack_require__.m";
 		export let moduleFactoriesAddOnly: "__webpack_require__.m (add only)";
-		export let ensureChunk: "__webpack_require__.e";
-		export let ensureChunkHandlers: "__webpack_require__.f";
-		export let ensureChunkIncludeEntries: "__webpack_require__.f (include entries)";
+		export let moduleId: "module.id";
+		export let moduleLoaded: "module.loaded";
+		export let nodeModuleDecorator: "__webpack_require__.nmd";
+		export let onChunksLoaded: "__webpack_require__.O";
 		export let prefetchChunk: "__webpack_require__.E";
 		export let prefetchChunkHandlers: "__webpack_require__.F";
 		export let preloadChunk: "__webpack_require__.G";
 		export let preloadChunkHandlers: "__webpack_require__.H";
-		export let definePropertyGetters: "__webpack_require__.d";
-		export let makeNamespaceObject: "__webpack_require__.r";
-		export let createFakeNamespaceObject: "__webpack_require__.t";
-		export let compatGetDefaultExport: "__webpack_require__.n";
-		export let harmonyModuleDecorator: "__webpack_require__.hmd";
-		export let nodeModuleDecorator: "__webpack_require__.nmd";
-		export let getFullHash: "__webpack_require__.h";
-		export let wasmInstances: "__webpack_require__.w";
-		export let instantiateWasm: "__webpack_require__.v";
-		export let uncaughtErrorHandler: "__webpack_require__.oe";
-		export let scriptNonce: "__webpack_require__.nc";
-		export let loadScript: "__webpack_require__.l";
-		export let createScript: "__webpack_require__.ts";
-		export let createScriptUrl: "__webpack_require__.tu";
-		export let getTrustedTypesPolicy: "__webpack_require__.tt";
-		export let hasFetchPriority: "has fetch priority";
-		export let chunkName: "__webpack_require__.cn";
+		export let publicPath: "__webpack_require__.p";
+		export let relativeUrl: "__webpack_require__.U";
+		export let require: "__webpack_require__";
+		export let requireScope: "__webpack_require__.*";
+		export let returnExportsFromRuntime: "return-exports-from-runtime";
 		export let runtimeId: "__webpack_require__.j";
-		export let getChunkScriptFilename: "__webpack_require__.u";
-		export let getChunkCssFilename: "__webpack_require__.k";
-		export let hasCssModules: "has css modules";
-		export let getChunkUpdateScriptFilename: "__webpack_require__.hu";
-		export let getChunkUpdateCssFilename: "__webpack_require__.hk";
+		export let scriptNonce: "__webpack_require__.nc";
+		export let shareScopeMap: "__webpack_require__.S";
 		export let startup: "__webpack_require__.x";
+		export let startupEntrypoint: "__webpack_require__.X";
 		export let startupNoDefault: "__webpack_require__.x (no default handler)";
 		export let startupOnlyAfter: "__webpack_require__.x (only after)";
 		export let startupOnlyBefore: "__webpack_require__.x (only before)";
-		export let chunkCallback: "webpackChunk";
-		export let startupEntrypoint: "__webpack_require__.X";
-		export let onChunksLoaded: "__webpack_require__.O";
-		export let externalInstallChunk: "__webpack_require__.C";
-		export let interceptModuleExecution: "__webpack_require__.i";
-		export let global: "__webpack_require__.g";
-		export let shareScopeMap: "__webpack_require__.S";
-		export let initializeSharing: "__webpack_require__.I";
-		export let currentRemoteGetScope: "__webpack_require__.R";
-		export let getUpdateManifestFilename: "__webpack_require__.hmrF";
-		export let hmrDownloadManifest: "__webpack_require__.hmrM";
-		export let hmrDownloadUpdateHandlers: "__webpack_require__.hmrC";
-		export let hmrModuleData: "__webpack_require__.hmrD";
-		export let hmrInvalidateModuleHandlers: "__webpack_require__.hmrI";
-		export let hmrRuntimeStatePrefix: "__webpack_require__.hmrS";
-		export let amdDefine: "__webpack_require__.amdD";
-		export let amdOptions: "__webpack_require__.amdO";
 		export let system: "__webpack_require__.System";
-		export let hasOwnProperty: "__webpack_require__.o";
 		export let systemContext: "__webpack_require__.y";
-		export let baseURI: "__webpack_require__.b";
-		export let relativeUrl: "__webpack_require__.U";
-		export let asyncModule: "__webpack_require__.a";
+		export let thisAsExports: "top-level-this-exports";
+		export let uncaughtErrorHandler: "__webpack_require__.oe";
+		export let wasmInstances: "__webpack_require__.w";
 	}
 	export const UsageState: Readonly<{
 		Unused: 0;
@@ -16776,9 +17646,6 @@ declare namespace exports {
 	}
 	export namespace optimize {
 		export namespace InnerGraph {
-			export let bailout: (parserState: ParserState) => void;
-			export let enable: (parserState: ParserState) => void;
-			export let isEnabled: (parserState: ParserState) => boolean;
 			export let addUsage: (
 				state: ParserState,
 				symbol: null | TopLevelSymbol,
@@ -16789,7 +17656,30 @@ declare namespace exports {
 				name: string,
 				usage: string | true | TopLevelSymbol
 			) => void;
+			export let bailout: (parserState: ParserState) => void;
+			export let enable: (parserState: ParserState) => void;
+			export let getDependencyUsedByExportsCondition: (
+				dependency: Dependency,
+				usedByExports: undefined | boolean | Set<string>,
+				moduleGraph: ModuleGraph
+			) =>
+				| null
+				| false
+				| ((
+						moduleGraphConnection: ModuleGraphConnection,
+						runtime: RuntimeSpec
+				  ) => ConnectionState);
+			export let getTopLevelSymbol: (
+				state: ParserState
+			) => void | TopLevelSymbol;
 			export let inferDependencyUsage: (state: ParserState) => void;
+			export let isDependencyUsedByExports: (
+				dependency: Dependency,
+				usedByExports: boolean | Set<string>,
+				moduleGraph: ModuleGraph,
+				runtime: RuntimeSpec
+			) => boolean;
+			export let isEnabled: (parserState: ParserState) => boolean;
 			export let onUsage: (
 				state: ParserState,
 				onUsageCallback: (value?: boolean | Set<string>) => void
@@ -16798,30 +17688,10 @@ declare namespace exports {
 				state: ParserState,
 				symbol?: TopLevelSymbol
 			) => void;
-			export let getTopLevelSymbol: (
-				state: ParserState
-			) => void | TopLevelSymbol;
 			export let tagTopLevelSymbol: (
 				parser: JavascriptParser,
 				name: string
 			) => undefined | TopLevelSymbol;
-			export let isDependencyUsedByExports: (
-				dependency: Dependency,
-				usedByExports: boolean | Set<string>,
-				moduleGraph: ModuleGraph,
-				runtime: RuntimeSpec
-			) => boolean;
-			export let getDependencyUsedByExportsCondition: (
-				dependency: Dependency,
-				usedByExports: undefined | boolean | Set<string>,
-				moduleGraph: ModuleGraph
-			) =>
-				| null
-				| false
-				| ((
-						moduleGraphConnection: ModuleGraphConnection,
-						runtime: RuntimeSpec
-				  ) => ConnectionState);
 			export { TopLevelSymbol, topLevelSymbolTag };
 		}
 		export {
@@ -16904,17 +17774,38 @@ declare namespace exports {
 	export namespace util {
 		export const createHash: (algorithm: HashFunction) => Hash;
 		export namespace comparators {
+			export let compareChunkGroupsByIndex: (
+				a: ChunkGroup,
+				b: ChunkGroup
+			) => 0 | 1 | -1;
+			export let compareChunks: ParameterizedComparator<ChunkGraph, Chunk>;
 			export let compareChunksById: (a: Chunk, b: Chunk) => 0 | 1 | -1;
-			export let compareModulesByIdentifier: (
-				a: Module,
-				b: Module
+			export let compareChunksNatural: (
+				chunkGraph: ChunkGraph
+			) => Comparator<Chunk>;
+			export let compareIds: (
+				a: string | number,
+				b: string | number
+			) => 0 | 1 | -1;
+			export let compareIterables: <T>(
+				elementComparator: Comparator<T>
+			) => Comparator<Iterable<T>>;
+			export let compareLocations: (
+				a: DependencyLocation,
+				b: DependencyLocation
 			) => 0 | 1 | -1;
 			export let compareModulesById: ParameterizedComparator<
 				ChunkGraph,
 				Module
 			>;
-			export let compareNumbers: (a: number, b: number) => 0 | 1 | -1;
-			export let compareStringsNumeric: (a: string, b: string) => 0 | 1 | -1;
+			export let compareModulesByIdOrIdentifier: ParameterizedComparator<
+				ChunkGraph,
+				Module
+			>;
+			export let compareModulesByIdentifier: (
+				a: Module,
+				b: Module
+			) => 0 | 1 | -1;
 			export let compareModulesByPostOrderIndexOrIdentifier: ParameterizedComparator<
 				ModuleGraph,
 				Module
@@ -16923,60 +17814,42 @@ declare namespace exports {
 				ModuleGraph,
 				Module
 			>;
-			export let compareModulesByIdOrIdentifier: ParameterizedComparator<
-				ChunkGraph,
-				Module
-			>;
-			export let compareChunks: ParameterizedComparator<ChunkGraph, Chunk>;
-			export let compareIds: (
-				a: string | number,
-				b: string | number
-			) => 0 | 1 | -1;
+			export let compareNumbers: (a: number, b: number) => 0 | 1 | -1;
+			export let compareSelect: <T, R>(
+				getter: Selector<T, R>,
+				comparator: Comparator<R>
+			) => Comparator<T>;
 			export let compareStrings: (a: string, b: string) => 0 | 1 | -1;
-			export let compareChunkGroupsByIndex: (
-				a: ChunkGroup,
-				b: ChunkGroup
-			) => 0 | 1 | -1;
+			export let compareStringsNumeric: (a: string, b: string) => 0 | 1 | -1;
 			export let concatComparators: <T>(
 				c1: Comparator<T>,
 				c2: Comparator<T>,
 				...cRest: Comparator<T>[]
 			) => Comparator<T>;
-			export let compareSelect: <T, R>(
-				getter: Selector<T, R>,
-				comparator: Comparator<R>
-			) => Comparator<T>;
-			export let compareIterables: <T>(
-				elementComparator: Comparator<T>
-			) => Comparator<Iterable<T>>;
 			export let keepOriginalOrder: <T>(iterable: Iterable<T>) => Comparator<T>;
-			export let compareChunksNatural: (
-				chunkGraph: ChunkGraph
-			) => Comparator<Chunk>;
-			export let compareLocations: (
-				a: DependencyLocation,
-				b: DependencyLocation
-			) => 0 | 1 | -1;
 		}
 		export namespace runtime {
-			export let getEntryRuntime: (
-				compilation: Compilation,
-				name: string,
-				options?: EntryOptions
-			) => RuntimeSpec;
+			export let compareRuntime: (a: RuntimeSpec, b: RuntimeSpec) => 0 | 1 | -1;
+			export let filterRuntime: (
+				runtime: RuntimeSpec,
+				filter: (runtime?: RuntimeSpec) => boolean
+			) => undefined | string | boolean | SortableSet<string>;
 			export let forEachRuntime: (
 				runtime: RuntimeSpec,
 				fn: (runtime?: string) => void,
 				deterministicOrder?: boolean
 			) => void;
+			export let getEntryRuntime: (
+				compilation: Compilation,
+				name: string,
+				options?: EntryOptions
+			) => RuntimeSpec;
 			export let getRuntimeKey: (runtime: RuntimeSpec) => string;
+			export let intersectRuntime: (
+				a: RuntimeSpec,
+				b: RuntimeSpec
+			) => RuntimeSpec;
 			export let keyToRuntime: (key: string) => RuntimeSpec;
-			export let runtimeToString: (runtime: RuntimeSpec) => string;
-			export let runtimeConditionToString: (
-				runtimeCondition: RuntimeCondition
-			) => string;
-			export let runtimeEqual: (a: RuntimeSpec, b: RuntimeSpec) => boolean;
-			export let compareRuntime: (a: RuntimeSpec, b: RuntimeSpec) => 0 | 1 | -1;
 			export let mergeRuntime: (a: RuntimeSpec, b: RuntimeSpec) => RuntimeSpec;
 			export let mergeRuntimeCondition: (
 				a: RuntimeCondition,
@@ -16992,10 +17865,11 @@ declare namespace exports {
 				a: RuntimeSpec,
 				b: RuntimeSpec
 			) => RuntimeSpec;
-			export let intersectRuntime: (
-				a: RuntimeSpec,
-				b: RuntimeSpec
-			) => RuntimeSpec;
+			export let runtimeConditionToString: (
+				runtimeCondition: RuntimeCondition
+			) => string;
+			export let runtimeEqual: (a: RuntimeSpec, b: RuntimeSpec) => boolean;
+			export let runtimeToString: (runtime: RuntimeSpec) => string;
 			export let subtractRuntime: (
 				a: RuntimeSpec,
 				b: RuntimeSpec
@@ -17005,10 +17879,6 @@ declare namespace exports {
 				b: RuntimeCondition,
 				runtime: RuntimeSpec
 			) => RuntimeCondition;
-			export let filterRuntime: (
-				runtime: RuntimeSpec,
-				filter: (runtime?: RuntimeSpec) => boolean
-			) => undefined | string | boolean | SortableSet<string>;
 			export { RuntimeSpecMap, RuntimeSpecSet };
 		}
 		export namespace serialization {
@@ -17063,7 +17933,7 @@ declare namespace exports {
 	}
 	export namespace experiments {
 		export namespace schemes {
-			export { HttpUriPlugin };
+			export { HttpUriPlugin, VirtualUrlPlugin };
 		}
 		export namespace ids {
 			export { SyncModuleIdsPlugin };
@@ -17152,7 +18022,7 @@ declare namespace exports {
 		AutomaticPrefetchPlugin,
 		AsyncDependenciesBlock,
 		BannerPlugin,
-		Cache,
+		CacheClass as Cache,
 		Chunk,
 		ChunkGraph,
 		CleanPlugin,