webpack
Version:
Packs ECMAScript/CommonJs/AMD modules for the browser. Allows you to split your codebase into multiple bundles, which can be loaded on demand. Supports loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.
1,867 lines (1,771 loc) • 394 kB
TypeScript
/*
* This file was automatically generated.
* DO NOT MODIFY BY HAND.
* Run `yarn special-lint-fix` to update
*/
import { Buffer } from "buffer";
import {
ArrayExpression,
ArrayPattern,
ArrowFunctionExpression,
AssignmentExpression,
AssignmentPattern,
AssignmentProperty,
AwaitExpression,
BigIntLiteral,
BinaryExpression,
BlockStatement,
BreakStatement,
CatchClause,
ChainExpression,
ClassBody,
ClassDeclaration,
ClassExpression,
Comment,
ConditionalExpression,
ContinueStatement,
DebuggerStatement,
Directive,
DoWhileStatement,
EmptyStatement,
ExportAllDeclaration,
ExportDefaultDeclaration,
ExportNamedDeclaration,
ExportSpecifier,
ExpressionStatement,
ForInStatement,
ForOfStatement,
ForStatement,
FunctionDeclaration,
FunctionExpression,
Identifier,
IfStatement,
ImportDeclaration,
ImportDefaultSpecifier,
ImportExpression,
ImportNamespaceSpecifier,
ImportSpecifier,
LabeledStatement,
LogicalExpression,
MemberExpression,
MetaProperty,
MethodDefinition,
NewExpression,
ObjectExpression,
ObjectPattern,
PrivateIdentifier,
Program,
Property,
PropertyDefinition,
RegExpLiteral,
RestElement,
ReturnStatement,
SequenceExpression,
SimpleCallExpression,
SimpleLiteral,
SpreadElement,
StaticBlock,
Super,
SwitchCase,
SwitchStatement,
TaggedTemplateExpression,
TemplateElement,
TemplateLiteral,
ThisExpression,
ThrowStatement,
TryStatement,
UnaryExpression,
UpdateExpression,
VariableDeclaration,
VariableDeclarator,
WhileStatement,
WithStatement,
YieldExpression
} from "estree";
import {
IncomingMessage,
ServerOptions as ServerOptionsImport,
ServerResponse
} from "http";
import { ListenOptions, Server } from "net";
import { validate as validateFunction } from "schema-utils";
import { default as ValidationError } from "schema-utils/declarations/ValidationError";
import { ValidationErrorConfiguration } from "schema-utils/declarations/validate";
import {
AsArray,
AsyncParallelHook,
AsyncSeriesBailHook,
AsyncSeriesHook,
AsyncSeriesWaterfallHook,
HookMap,
MultiHook,
SyncBailHook,
SyncHook,
SyncWaterfallHook
} from "tapable";
import { SecureContextOptions, TlsOptions } from "tls";
import { URL } from "url";
import { Context } from "vm";
declare interface Abortable {
/**
* When provided the corresponding `AbortController` can be used to cancel an asynchronous action.
*/
signal?: AbortSignal;
}
declare class AbstractLibraryPlugin<T> {
constructor(__0: {
/**
* name of the plugin
*/
pluginName: string;
/**
* used library type
*/
type: string;
});
/**
* Apply the plugin
*/
apply(compiler: Compiler): void;
parseOptions(library: LibraryOptions): false | T;
finishEntryModule(
module: Module,
entryName: string,
libraryContext: LibraryContext<T>
): void;
embedInRuntimeBailout(
module: Module,
renderContext: RenderContext,
libraryContext: LibraryContext<T>
): undefined | string;
strictRuntimeBailout(
renderContext: RenderContext,
libraryContext: LibraryContext<T>
): undefined | string;
runtimeRequirements(
chunk: Chunk,
set: Set<string>,
libraryContext: LibraryContext<T>
): void;
render(
source: Source,
renderContext: RenderContext,
libraryContext: LibraryContext<T>
): Source;
renderStartup(
source: Source,
module: Module,
renderContext: StartupRenderContext,
libraryContext: LibraryContext<T>
): Source;
chunkHash(
chunk: Chunk,
hash: Hash,
chunkHashContext: ChunkHashContext,
libraryContext: LibraryContext<T>
): void;
static COMMON_LIBRARY_NAME_MESSAGE: string;
}
declare interface AdditionalData {
[index: string]: any;
webpackAST: object;
}
declare class AggressiveMergingPlugin {
constructor(options?: AggressiveMergingPluginOptions);
options: AggressiveMergingPluginOptions;
/**
* Apply the plugin
*/
apply(compiler: Compiler): void;
}
declare interface AggressiveMergingPluginOptions {
/**
* minimal size reduction to trigger merging
*/
minSizeReduce?: number;
}
declare class AggressiveSplittingPlugin {
constructor(options?: AggressiveSplittingPluginOptions);
options: AggressiveSplittingPluginOptions;
/**
* Apply the plugin
*/
apply(compiler: Compiler): void;
static wasChunkRecorded(chunk: Chunk): boolean;
}
declare interface AggressiveSplittingPluginOptions {
/**
* Extra cost for each chunk (Default: 9.8kiB).
*/
chunkOverhead?: number;
/**
* Extra cost multiplicator for entry chunks (Default: 10).
*/
entryChunkMultiplicator?: number;
/**
* Byte, max size of per file (Default: 50kiB).
*/
maxSize?: number;
/**
* Byte, split point. (Default: 30kiB).
*/
minSize?: number;
}
type Alias = string | false | string[];
declare interface AliasOption {
alias: Alias;
name: string;
onlyModule?: boolean;
}
type AliasOptionNewRequest = string | false | string[];
declare interface AliasOptions {
[index: string]: AliasOptionNewRequest;
}
declare interface Argument {
description: string;
simpleType: "string" | "number" | "boolean";
multiple: boolean;
configs: ArgumentConfig[];
}
declare interface ArgumentConfig {
description: string;
negatedDescription?: string;
path: string;
multiple: boolean;
type: "string" | "number" | "boolean" | "path" | "enum" | "RegExp" | "reset";
values?: any[];
}
type ArrayBufferView =
| Uint8Array
| Uint8ClampedArray
| Uint16Array
| Uint32Array
| Int8Array
| Int16Array
| Int32Array
| BigUint64Array
| BigInt64Array
| Float32Array
| Float64Array
| DataView;
declare interface Asset {
/**
* the filename of the asset
*/
name: string;
/**
* source of the asset
*/
source: Source;
/**
* info about the asset
*/
info: AssetInfo;
}
declare interface AssetEmittedInfo {
content: Buffer;
source: Source;
compilation: Compilation;
outputPath: string;
targetPath: string;
}
type AssetFilterItemTypes =
| string
| RegExp
| ((name: string, asset: StatsAsset) => boolean);
/**
* Options object for data url generation.
*/
declare interface AssetGeneratorDataUrlOptions {
/**
* Asset encoding (defaults to base64).
*/
encoding?: false | "base64";
/**
* Asset mimetype (getting from file extension by default).
*/
mimetype?: string;
}
type AssetGeneratorOptions = AssetInlineGeneratorOptions &
AssetResourceGeneratorOptions;
type AssetInfo = KnownAssetInfo & Record<string, any>;
/**
* Generator options for asset/inline modules.
*/
declare interface AssetInlineGeneratorOptions {
/**
* Whether or not this asset module should be considered binary. This can be set to 'false' to treat this asset module as text.
*/
binary?: boolean;
/**
* The options for data url generator.
*/
dataUrl?:
| AssetGeneratorDataUrlOptions
| ((
source: string | Buffer,
context: { filename: string; module: Module }
) => string);
}
/**
* Options object for DataUrl condition.
*/
declare interface AssetParserDataUrlOptions {
/**
* Maximum size of asset that should be inline as modules. Default: 8kb.
*/
maxSize?: number;
}
/**
* Parser options for asset modules.
*/
declare interface AssetParserOptions {
/**
* The condition for inlining the asset as DataUrl.
*/
dataUrlCondition?:
| AssetParserDataUrlOptions
| ((
source: string | Buffer,
context: { filename: string; module: Module }
) => boolean);
}
/**
* Generator options for asset/resource modules.
*/
declare interface AssetResourceGeneratorOptions {
/**
* Whether or not this asset module should be considered binary. This can be set to 'false' to treat this asset module as text.
*/
binary?: boolean;
/**
* Emit an output asset from this asset module. This can be set to 'false' to omit emitting e. g. for SSR.
*/
emit?: boolean;
/**
* Specifies the filename template of output files on disk. You must **not** specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
*/
filename?: string | ((pathData: PathData, assetInfo?: AssetInfo) => string);
/**
* Emit the asset in the specified folder relative to 'output.path'. This should only be needed when custom 'publicPath' is specified to match the folder structure there.
*/
outputPath?: string | ((pathData: PathData, assetInfo?: AssetInfo) => string);
/**
* The 'publicPath' specifies the public URL address of the output files when referenced in a browser.
*/
publicPath?: string | ((pathData: PathData, assetInfo?: AssetInfo) => string);
}
declare class AsyncDependenciesBlock extends DependenciesBlock {
constructor(
groupOptions:
| null
| (RawChunkGroupOptions & { name?: string } & {
entryOptions?: EntryOptions;
}),
loc?: null | SyntheticDependencyLocation | RealDependencyLocation,
request?: null | string
);
groupOptions: RawChunkGroupOptions & { name?: string } & {
entryOptions?: EntryOptions;
};
loc?: null | SyntheticDependencyLocation | RealDependencyLocation;
request?: null | string;
chunkName?: string;
module: any;
}
declare abstract class AsyncQueue<T, K, R> {
hooks: {
beforeAdd: AsyncSeriesHook<[T]>;
added: SyncHook<[T]>;
beforeStart: AsyncSeriesHook<[T]>;
started: SyncHook<[T]>;
result: SyncHook<[T, Error, R]>;
};
add(item: T, callback: CallbackAsyncQueue<R>): void;
invalidate(item: T): void;
/**
* Waits for an already started item
*/
waitFor(item: T, callback: CallbackAsyncQueue<R>): void;
stop(): void;
increaseParallelism(): void;
decreaseParallelism(): void;
isProcessing(item: T): boolean;
isQueued(item: T): boolean;
isDone(item: T): boolean;
clear(): void;
}
declare class AsyncWebAssemblyModulesPlugin {
constructor(options: AsyncWebAssemblyModulesPluginOptions);
options: AsyncWebAssemblyModulesPluginOptions;
/**
* Apply the plugin
*/
apply(compiler: Compiler): void;
renderModule(
module: Module,
renderContext: WebAssemblyRenderContext,
hooks: CompilationHooksAsyncWebAssemblyModulesPlugin
): Source;
static getCompilationHooks(
compilation: Compilation
): CompilationHooksAsyncWebAssemblyModulesPlugin;
}
declare interface AsyncWebAssemblyModulesPluginOptions {
/**
* mangle imports
*/
mangleImports?: boolean;
}
declare class AutomaticPrefetchPlugin {
constructor();
/**
* Apply the plugin
*/
apply(compiler: Compiler): void;
}
type AuxiliaryComment = string | LibraryCustomUmdCommentObject;
declare interface BackendApi {
dispose: (arg0?: Error) => void;
module: (arg0: Module) => { client: string; data: string; active: boolean };
}
declare class BannerPlugin {
constructor(options: BannerPluginArgument);
options: BannerPluginOptions;
banner: (data: { hash?: string; chunk: Chunk; filename: string }) => string;
/**
* Apply the plugin
*/
apply(compiler: Compiler): void;
}
type BannerPluginArgument =
| string
| BannerPluginOptions
| ((data: { hash?: string; chunk: Chunk; filename: string }) => string);
declare interface BannerPluginOptions {
/**
* Specifies the banner.
*/
banner:
| string
| ((data: { hash?: string; chunk: Chunk; filename: string }) => string);
/**
* If true, the banner will only be added to the entry chunks.
*/
entryOnly?: boolean;
/**
* Exclude all modules matching any of these conditions.
*/
exclude?: string | RegExp | Rule[];
/**
* If true, banner will be placed at the end of the output.
*/
footer?: boolean;
/**
* Include all modules matching any of these conditions.
*/
include?: string | RegExp | Rule[];
/**
* If true, banner will not be wrapped in a comment.
*/
raw?: boolean;
/**
* Specifies the banner.
*/
stage?: number;
/**
* Include all modules that pass test assertion.
*/
test?: string | RegExp | Rule[];
}
declare interface BaseResolveRequest {
path: string | false;
context?: object;
descriptionFilePath?: string;
descriptionFileRoot?: string;
descriptionFileData?: JsonObjectTypes;
relativePath?: string;
ignoreSymlinks?: boolean;
fullySpecified?: boolean;
__innerRequest?: string;
__innerRequest_request?: string;
__innerRequest_relativePath?: string;
}
declare abstract class BasicEvaluatedExpression {
type: number;
range?: [number, number];
falsy: boolean;
truthy: boolean;
nullish?: boolean;
sideEffects: boolean;
bool?: boolean;
number?: number;
bigint?: bigint;
regExp?: RegExp;
string?: string;
quasis?: BasicEvaluatedExpression[];
parts?: BasicEvaluatedExpression[];
array?: any[];
items?: BasicEvaluatedExpression[];
options?: BasicEvaluatedExpression[];
prefix?: null | BasicEvaluatedExpression;
postfix?: null | BasicEvaluatedExpression;
wrappedInnerExpressions?: BasicEvaluatedExpression[];
identifier?: string | VariableInfoInterface;
rootInfo?: string | VariableInfoInterface;
getMembers?: () => string[];
getMembersOptionals?: () => boolean[];
getMemberRanges?: () => [number, number][];
expression?:
| UnaryExpression
| ArrayExpression
| ArrowFunctionExpression
| AssignmentExpression
| AwaitExpression
| BinaryExpression
| SimpleCallExpression
| NewExpression
| ChainExpression
| ClassExpression
| ConditionalExpression
| FunctionExpression
| Identifier
| ImportExpression
| SimpleLiteral
| RegExpLiteral
| BigIntLiteral
| LogicalExpression
| MemberExpression
| MetaProperty
| ObjectExpression
| SequenceExpression
| TaggedTemplateExpression
| TemplateLiteral
| ThisExpression
| UpdateExpression
| YieldExpression
| FunctionDeclaration
| VariableDeclaration
| ClassDeclaration
| PrivateIdentifier
| ExpressionStatement
| BlockStatement
| StaticBlock
| EmptyStatement
| DebuggerStatement
| WithStatement
| ReturnStatement
| LabeledStatement
| BreakStatement
| ContinueStatement
| IfStatement
| SwitchStatement
| ThrowStatement
| TryStatement
| WhileStatement
| DoWhileStatement
| ForStatement
| ForInStatement
| ForOfStatement
| ImportDeclaration
| ExportNamedDeclaration
| ExportDefaultDeclaration
| ExportAllDeclaration
| MethodDefinition
| PropertyDefinition
| VariableDeclarator
| Program
| SwitchCase
| CatchClause
| ObjectPattern
| ArrayPattern
| RestElement
| AssignmentPattern
| SpreadElement
| Property
| AssignmentProperty
| ClassBody
| ImportSpecifier
| ImportDefaultSpecifier
| ImportNamespaceSpecifier
| ExportSpecifier
| Super
| TemplateElement;
isUnknown(): boolean;
isNull(): boolean;
isUndefined(): boolean;
isString(): boolean;
isNumber(): boolean;
isBigInt(): boolean;
isBoolean(): boolean;
isRegExp(): boolean;
isConditional(): boolean;
isArray(): boolean;
isConstArray(): boolean;
isIdentifier(): boolean;
isWrapped(): boolean;
isTemplateString(): boolean;
/**
* Is expression a primitive or an object type value?
*/
isPrimitiveType(): undefined | boolean;
/**
* Is expression a runtime or compile-time value?
*/
isCompileTimeValue(): boolean;
/**
* Gets the compile-time value of the expression
*/
asCompileTimeValue(): any;
isTruthy(): boolean;
isFalsy(): boolean;
isNullish(): undefined | boolean;
/**
* Can this expression have side effects?
*/
couldHaveSideEffects(): boolean;
/**
* Creates a boolean representation of this evaluated expression.
*/
asBool(): undefined | boolean;
/**
* Creates a nullish coalescing representation of this evaluated expression.
*/
asNullish(): undefined | boolean;
/**
* Creates a string representation of this evaluated expression.
*/
asString(): undefined | string;
setString(string: string): BasicEvaluatedExpression;
setUndefined(): BasicEvaluatedExpression;
setNull(): BasicEvaluatedExpression;
/**
* Set's the value of this expression to a number
*/
setNumber(number: number): BasicEvaluatedExpression;
/**
* Set's the value of this expression to a BigInt
*/
setBigInt(bigint: bigint): BasicEvaluatedExpression;
/**
* Set's the value of this expression to a boolean
*/
setBoolean(bool: boolean): BasicEvaluatedExpression;
/**
* Set's the value of this expression to a regular expression
*/
setRegExp(regExp: RegExp): BasicEvaluatedExpression;
/**
* Set's the value of this expression to a particular identifier and its members.
*/
setIdentifier(
identifier: string | VariableInfoInterface,
rootInfo: string | VariableInfoInterface,
getMembers: () => string[],
getMembersOptionals?: () => boolean[],
getMemberRanges?: () => [number, number][]
): BasicEvaluatedExpression;
/**
* Wraps an array of expressions with a prefix and postfix expression.
*/
setWrapped(
prefix?: null | BasicEvaluatedExpression,
postfix?: null | BasicEvaluatedExpression,
innerExpressions?: BasicEvaluatedExpression[]
): BasicEvaluatedExpression;
/**
* Stores the options of a conditional expression.
*/
setOptions(options: BasicEvaluatedExpression[]): BasicEvaluatedExpression;
/**
* Adds options to a conditional expression.
*/
addOptions(options: BasicEvaluatedExpression[]): BasicEvaluatedExpression;
/**
* Set's the value of this expression to an array of expressions.
*/
setItems(items: BasicEvaluatedExpression[]): BasicEvaluatedExpression;
/**
* Set's the value of this expression to an array of strings.
*/
setArray(array: string[]): BasicEvaluatedExpression;
/**
* Set's the value of this expression to a processed/unprocessed template string. Used
* for evaluating TemplateLiteral expressions in the JavaScript Parser.
*/
setTemplateString(
quasis: BasicEvaluatedExpression[],
parts: BasicEvaluatedExpression[],
kind: "raw" | "cooked"
): BasicEvaluatedExpression;
templateStringKind?: "raw" | "cooked";
setTruthy(): BasicEvaluatedExpression;
setFalsy(): BasicEvaluatedExpression;
/**
* Set's the value of the expression to nullish.
*/
setNullish(value: boolean): BasicEvaluatedExpression;
/**
* Set's the range for the expression.
*/
setRange(range: [number, number]): BasicEvaluatedExpression;
/**
* Set whether or not the expression has side effects.
*/
setSideEffects(sideEffects?: boolean): BasicEvaluatedExpression;
/**
* Set the expression node for the expression.
*/
setExpression(
expression?:
| UnaryExpression
| ArrayExpression
| ArrowFunctionExpression
| AssignmentExpression
| AwaitExpression
| BinaryExpression
| SimpleCallExpression
| NewExpression
| ChainExpression
| ClassExpression
| ConditionalExpression
| FunctionExpression
| Identifier
| ImportExpression
| SimpleLiteral
| RegExpLiteral
| BigIntLiteral
| LogicalExpression
| MemberExpression
| MetaProperty
| ObjectExpression
| SequenceExpression
| TaggedTemplateExpression
| TemplateLiteral
| ThisExpression
| UpdateExpression
| YieldExpression
| FunctionDeclaration
| VariableDeclaration
| ClassDeclaration
| PrivateIdentifier
| ExpressionStatement
| BlockStatement
| StaticBlock
| EmptyStatement
| DebuggerStatement
| WithStatement
| ReturnStatement
| LabeledStatement
| BreakStatement
| ContinueStatement
| IfStatement
| SwitchStatement
| ThrowStatement
| TryStatement
| WhileStatement
| DoWhileStatement
| ForStatement
| ForInStatement
| ForOfStatement
| ImportDeclaration
| ExportNamedDeclaration
| ExportDefaultDeclaration
| ExportAllDeclaration
| MethodDefinition
| PropertyDefinition
| VariableDeclarator
| Program
| SwitchCase
| CatchClause
| ObjectPattern
| ArrayPattern
| RestElement
| AssignmentPattern
| SpreadElement
| Property
| AssignmentProperty
| ClassBody
| ImportSpecifier
| ImportDefaultSpecifier
| ImportNamespaceSpecifier
| ExportSpecifier
| Super
| TemplateElement
): BasicEvaluatedExpression;
}
type BufferEncoding =
| "ascii"
| "utf8"
| "utf-8"
| "utf16le"
| "utf-16le"
| "ucs2"
| "ucs-2"
| "latin1"
| "binary"
| "base64"
| "base64url"
| "hex";
type BufferEncodingOption = "buffer" | { encoding: "buffer" };
type BuildInfo = KnownBuildInfo & Record<string, any>;
type BuildMeta = KnownBuildMeta & Record<string, any>;
declare abstract class ByTypeGenerator extends Generator {
map: Record<string, Generator>;
}
declare const CIRCULAR_CONNECTION: unique symbol;
declare class Cache {
constructor();
hooks: {
get: AsyncSeriesBailHook<
[
string,
null | Etag,
((result: any, callback: (arg0?: Error) => void) => void)[]
],
any
>;
store: AsyncParallelHook<[string, null | Etag, any]>;
storeBuildDependencies: AsyncParallelHook<[Iterable<string>]>;
beginIdle: SyncHook<[]>;
endIdle: AsyncParallelHook<[]>;
shutdown: AsyncParallelHook<[]>;
};
get<T>(
identifier: string,
etag: null | Etag,
callback: CallbackCacheCache<T>
): void;
store<T>(
identifier: string,
etag: null | Etag,
data: T,
callback: CallbackCacheCache<void>
): void;
/**
* After this method has succeeded the cache can only be restored when build dependencies are
*/
storeBuildDependencies(
dependencies: Iterable<string>,
callback: CallbackCacheCache<void>
): void;
beginIdle(): void;
endIdle(callback: CallbackCacheCache<void>): void;
shutdown(callback: CallbackCacheCache<void>): void;
static STAGE_MEMORY: number;
static STAGE_DEFAULT: number;
static STAGE_DISK: number;
static STAGE_NETWORK: number;
}
declare abstract class CacheFacade {
getChildCache(name: string): CacheFacade;
getItemCache(identifier: string, etag: null | Etag): ItemCacheFacade;
getLazyHashedEtag(obj: HashableObject): Etag;
mergeEtags(a: Etag, b: Etag): Etag;
get<T>(
identifier: string,
etag: null | Etag,
callback: CallbackCacheCacheFacade<T>
): void;
getPromise<T>(identifier: string, etag: null | Etag): Promise<T>;
store<T>(
identifier: string,
etag: null | Etag,
data: T,
callback: CallbackCacheCacheFacade<void>
): void;
storePromise<T>(
identifier: string,
etag: null | Etag,
data: T
): Promise<void>;
provide<T>(
identifier: string,
etag: null | Etag,
computer: (arg0: CallbackNormalErrorCache<T>) => void,
callback: CallbackNormalErrorCache<T>
): void;
providePromise<T>(
identifier: string,
etag: null | Etag,
computer: () => T | Promise<T>
): Promise<T>;
}
declare interface CacheGroupSource {
key?: string;
priority?: number;
getName?: (
module?: Module,
chunks?: Chunk[],
key?: string
) => undefined | string;
chunksFilter?: (chunk: Chunk) => undefined | boolean;
enforce?: boolean;
minSize: SplitChunksSizes;
minSizeReduction: SplitChunksSizes;
minRemainingSize: SplitChunksSizes;
enforceSizeThreshold: SplitChunksSizes;
maxAsyncSize: SplitChunksSizes;
maxInitialSize: SplitChunksSizes;
minChunks?: number;
maxAsyncRequests?: number;
maxInitialRequests?: number;
filename?: string | ((arg0: PathData, arg1?: AssetInfo) => string);
idHint?: string;
automaticNameDelimiter?: string;
reuseExistingChunk?: boolean;
usedExports?: boolean;
}
declare interface CacheGroupsContext {
moduleGraph: ModuleGraph;
chunkGraph: ChunkGraph;
}
type CacheOptionsNormalized = false | FileCacheOptions | MemoryCacheOptions;
declare class CachedSource extends Source {
constructor(source: Source);
constructor(source: Source | (() => Source), cachedData?: any);
original(): Source;
originalLazy(): Source | (() => Source);
getCachedData(): any;
}
type CallExpression = SimpleCallExpression | NewExpression;
declare interface CallExpressionInfo {
type: "call";
call: CallExpression;
calleeName: string;
rootInfo: string | VariableInfo;
getCalleeMembers: () => string[];
name: string;
getMembers: () => string[];
getMembersOptionals: () => boolean[];
getMemberRanges: () => [number, number][];
}
declare interface CallbackAsyncQueue<T> {
(err?: null | WebpackError, result?: T): any;
}
declare interface CallbackCacheCache<T> {
(err: null | WebpackError, result?: T): void;
}
declare interface CallbackCacheCacheFacade<T> {
(err?: null | Error, result?: null | T): void;
}
declare interface CallbackFunction_1<T> {
(err: null | Error, result?: T): any;
}
declare interface CallbackFunction_2<T> {
(err?: null | Error, result?: T): any;
}
declare interface CallbackNormalErrorCache<T> {
(err?: null | Error, result?: T): void;
}
declare interface CallbackNormalModuleFactory<T> {
(err?: null | Error, stats?: T): void;
}
declare interface CallbackWebpack<T> {
(err: null | Error, stats?: T): void;
}
type Cell<T> = undefined | T;
declare class Chunk {
constructor(name?: string, backCompat?: boolean);
id: null | string | number;
ids: null | ChunkId[];
debugId: number;
name?: string;
idNameHints: SortableSet<string>;
preventIntegration: boolean;
filenameTemplate?: string | ((arg0: PathData, arg1?: AssetInfo) => string);
cssFilenameTemplate?: string | ((arg0: PathData, arg1?: AssetInfo) => string);
runtime: RuntimeSpec;
files: Set<string>;
auxiliaryFiles: Set<string>;
rendered: boolean;
hash?: string;
contentHash: Record<string, string>;
renderedHash?: string;
chunkReason?: string;
extraAsync: boolean;
get entryModule(): Module;
hasEntryModule(): boolean;
addModule(module: Module): boolean;
removeModule(module: Module): void;
getNumberOfModules(): number;
get modulesIterable(): Iterable<Module>;
compareTo(otherChunk: Chunk): 0 | 1 | -1;
containsModule(module: Module): boolean;
getModules(): Module[];
remove(): void;
moveModule(module: Module, otherChunk: Chunk): void;
integrate(otherChunk: Chunk): boolean;
canBeIntegrated(otherChunk: Chunk): boolean;
isEmpty(): boolean;
modulesSize(): number;
size(options?: ChunkSizeOptions): number;
integratedSize(otherChunk: Chunk, options: ChunkSizeOptions): number;
getChunkModuleMaps(filterFn: (m: Module) => boolean): ChunkModuleMaps;
hasModuleInGraph(
filterFn: (m: Module) => boolean,
filterChunkFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean
): boolean;
getChunkMaps(realHash: boolean): ChunkMaps;
hasRuntime(): boolean;
canBeInitial(): boolean;
isOnlyInitial(): boolean;
getEntryOptions(): undefined | EntryOptions;
addGroup(chunkGroup: ChunkGroup): void;
removeGroup(chunkGroup: ChunkGroup): void;
isInGroup(chunkGroup: ChunkGroup): boolean;
getNumberOfGroups(): number;
get groupsIterable(): SortableSet<ChunkGroup>;
disconnectFromGroups(): void;
split(newChunk: Chunk): void;
updateHash(hash: Hash, chunkGraph: ChunkGraph): void;
getAllAsyncChunks(): Set<Chunk>;
getAllInitialChunks(): Set<Chunk>;
getAllReferencedChunks(): Set<Chunk>;
getAllReferencedAsyncEntrypoints(): Set<Entrypoint>;
hasAsyncChunks(): boolean;
getChildIdsByOrders(
chunkGraph: ChunkGraph,
filterFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean
): Record<string, (string | number)[]>;
getChildrenOfTypeInOrder(
chunkGraph: ChunkGraph,
type: string
): undefined | { onChunks: Chunk[]; chunks: Set<Chunk> }[];
getChildIdsByOrdersMap(
chunkGraph: ChunkGraph,
includeDirectChildren?: boolean,
filterFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean
): Record<string | number, Record<string, (string | number)[]>>;
}
declare class ChunkGraph {
constructor(moduleGraph: ModuleGraph, hashFunction?: string | typeof Hash);
moduleGraph: ModuleGraph;
connectChunkAndModule(chunk: Chunk, module: Module): void;
disconnectChunkAndModule(chunk: Chunk, module: Module): void;
disconnectChunk(chunk: Chunk): void;
attachModules(chunk: Chunk, modules: Iterable<Module>): void;
attachRuntimeModules(chunk: Chunk, modules: Iterable<RuntimeModule>): void;
attachFullHashModules(chunk: Chunk, modules: Iterable<RuntimeModule>): void;
attachDependentHashModules(
chunk: Chunk,
modules: Iterable<RuntimeModule>
): void;
replaceModule(oldModule: Module, newModule: Module): void;
isModuleInChunk(module: Module, chunk: Chunk): boolean;
isModuleInChunkGroup(module: Module, chunkGroup: ChunkGroup): boolean;
isEntryModule(module: Module): boolean;
getModuleChunksIterable(module: Module): Iterable<Chunk>;
getOrderedModuleChunksIterable(
module: Module,
sortFn: (arg0: Chunk, arg1: Chunk) => 0 | 1 | -1
): Iterable<Chunk>;
getModuleChunks(module: Module): Chunk[];
getNumberOfModuleChunks(module: Module): number;
getModuleRuntimes(module: Module): RuntimeSpecSet;
getNumberOfChunkModules(chunk: Chunk): number;
getNumberOfChunkFullHashModules(chunk: Chunk): number;
getChunkModulesIterable(chunk: Chunk): Iterable<Module>;
getChunkModulesIterableBySourceType(
chunk: Chunk,
sourceType: string
): undefined | Iterable<Module>;
setChunkModuleSourceTypes(
chunk: Chunk,
module: Module,
sourceTypes: Set<string>
): void;
getChunkModuleSourceTypes(chunk: Chunk, module: Module): Set<string>;
getModuleSourceTypes(module: Module): Set<string>;
getOrderedChunkModulesIterable(
chunk: Chunk,
comparator: (arg0: Module, arg1: Module) => 0 | 1 | -1
): Iterable<Module>;
getOrderedChunkModulesIterableBySourceType(
chunk: Chunk,
sourceType: string,
comparator: (arg0: Module, arg1: Module) => 0 | 1 | -1
): undefined | Iterable<Module>;
getChunkModules(chunk: Chunk): Module[];
getOrderedChunkModules(
chunk: Chunk,
comparator: (arg0: Module, arg1: Module) => 0 | 1 | -1
): Module[];
getChunkModuleIdMap(
chunk: Chunk,
filterFn: (m: Module) => boolean,
includeAllChunks?: boolean
): Record<string | number, (string | number)[]>;
getChunkModuleRenderedHashMap(
chunk: Chunk,
filterFn: (m: Module) => boolean,
hashLength?: number,
includeAllChunks?: boolean
): Record<string | number, Record<string | number, string>>;
getChunkConditionMap(
chunk: Chunk,
filterFn: (c: Chunk, chunkGraph: ChunkGraph) => boolean
): Record<string | number, boolean>;
hasModuleInGraph(
chunk: Chunk,
filterFn: (m: Module) => boolean,
filterChunkFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean
): boolean;
compareChunks(chunkA: Chunk, chunkB: Chunk): 0 | 1 | -1;
getChunkModulesSize(chunk: Chunk): number;
getChunkModulesSizes(chunk: Chunk): Record<string, number>;
getChunkRootModules(chunk: Chunk): Module[];
getChunkSize(chunk: Chunk, options?: ChunkSizeOptions): number;
getIntegratedChunksSize(
chunkA: Chunk,
chunkB: Chunk,
options?: ChunkSizeOptions
): number;
canChunksBeIntegrated(chunkA: Chunk, chunkB: Chunk): boolean;
integrateChunks(chunkA: Chunk, chunkB: Chunk): void;
upgradeDependentToFullHashModules(chunk: Chunk): void;
isEntryModuleInChunk(module: Module, chunk: Chunk): boolean;
connectChunkAndEntryModule(
chunk: Chunk,
module: Module,
entrypoint?: Entrypoint
): void;
connectChunkAndRuntimeModule(chunk: Chunk, module: RuntimeModule): void;
addFullHashModuleToChunk(chunk: Chunk, module: RuntimeModule): void;
addDependentHashModuleToChunk(chunk: Chunk, module: RuntimeModule): void;
disconnectChunkAndEntryModule(chunk: Chunk, module: Module): void;
disconnectChunkAndRuntimeModule(chunk: Chunk, module: RuntimeModule): void;
disconnectEntryModule(module: Module): void;
disconnectEntries(chunk: Chunk): void;
getNumberOfEntryModules(chunk: Chunk): number;
getNumberOfRuntimeModules(chunk: Chunk): number;
getChunkEntryModulesIterable(chunk: Chunk): Iterable<Module>;
getChunkEntryDependentChunksIterable(chunk: Chunk): Iterable<Chunk>;
hasChunkEntryDependentChunks(chunk: Chunk): boolean;
getChunkRuntimeModulesIterable(chunk: Chunk): Iterable<RuntimeModule>;
getChunkRuntimeModulesInOrder(chunk: Chunk): RuntimeModule[];
getChunkFullHashModulesIterable(
chunk: Chunk
): undefined | Iterable<RuntimeModule>;
getChunkFullHashModulesSet(
chunk: Chunk
): undefined | ReadonlySet<RuntimeModule>;
getChunkDependentHashModulesIterable(
chunk: Chunk
): undefined | Iterable<RuntimeModule>;
getChunkEntryModulesWithChunkGroupIterable(
chunk: Chunk
): Iterable<[Module, undefined | Entrypoint]>;
getBlockChunkGroup(depBlock: AsyncDependenciesBlock): undefined | ChunkGroup;
connectBlockAndChunkGroup(
depBlock: AsyncDependenciesBlock,
chunkGroup: ChunkGroup
): void;
disconnectChunkGroup(chunkGroup: ChunkGroup): void;
getModuleId(module: Module): ModuleId;
setModuleId(module: Module, id: ModuleId): void;
getRuntimeId(runtime: string): string | number;
setRuntimeId(runtime: string, id: string | number): void;
hasModuleHashes(module: Module, runtime: RuntimeSpec): boolean;
getModuleHash(module: Module, runtime: RuntimeSpec): string;
getRenderedModuleHash(module: Module, runtime: RuntimeSpec): string;
setModuleHashes(
module: Module,
runtime: RuntimeSpec,
hash: string,
renderedHash: string
): void;
addModuleRuntimeRequirements(
module: Module,
runtime: RuntimeSpec,
items: Set<string>,
transferOwnership?: boolean
): void;
addChunkRuntimeRequirements(chunk: Chunk, items: Set<string>): void;
addTreeRuntimeRequirements(chunk: Chunk, items: Iterable<string>): void;
getModuleRuntimeRequirements(
module: Module,
runtime: RuntimeSpec
): ReadonlySet<string>;
getChunkRuntimeRequirements(chunk: Chunk): ReadonlySet<string>;
getModuleGraphHash(
module: Module,
runtime: RuntimeSpec,
withConnections?: boolean
): string;
getModuleGraphHashBigInt(
module: Module,
runtime: RuntimeSpec,
withConnections?: boolean
): bigint;
getTreeRuntimeRequirements(chunk: Chunk): ReadonlySet<string>;
static getChunkGraphForModule(
module: Module,
deprecateMessage: string,
deprecationCode: string
): ChunkGraph;
static setChunkGraphForModule(module: Module, chunkGraph: ChunkGraph): void;
static clearChunkGraphForModule(module: Module): void;
static getChunkGraphForChunk(
chunk: Chunk,
deprecateMessage: string,
deprecationCode: string
): ChunkGraph;
static setChunkGraphForChunk(chunk: Chunk, chunkGraph: ChunkGraph): void;
static clearChunkGraphForChunk(chunk: Chunk): void;
}
declare abstract class ChunkGroup {
groupDebugId: number;
options: ChunkGroupOptions;
chunks: Chunk[];
origins: OriginRecord[];
index?: number;
/**
* when a new chunk is added to a chunkGroup, addingOptions will occur.
*/
addOptions(options: ChunkGroupOptions): void;
/**
* returns the name of current ChunkGroup
* sets a new name for current ChunkGroup
*/
name?: string;
/**
* get a uniqueId for ChunkGroup, made up of its member Chunk debugId's
*/
get debugId(): string;
/**
* get a unique id for ChunkGroup, made up of its member Chunk id's
*/
get id(): string;
/**
* Performs an unshift of a specific chunk
*/
unshiftChunk(chunk: Chunk): boolean;
/**
* inserts a chunk before another existing chunk in group
*/
insertChunk(chunk: Chunk, before: Chunk): boolean;
/**
* add a chunk into ChunkGroup. Is pushed on or prepended
*/
pushChunk(chunk: Chunk): boolean;
replaceChunk(oldChunk: Chunk, newChunk: Chunk): undefined | boolean;
removeChunk(chunk: Chunk): boolean;
isInitial(): boolean;
addChild(group: ChunkGroup): boolean;
getChildren(): ChunkGroup[];
getNumberOfChildren(): number;
get childrenIterable(): SortableSet<ChunkGroup>;
removeChild(group: ChunkGroup): boolean;
addParent(parentChunk: ChunkGroup): boolean;
getParents(): ChunkGroup[];
getNumberOfParents(): number;
hasParent(parent: ChunkGroup): boolean;
get parentsIterable(): SortableSet<ChunkGroup>;
removeParent(chunkGroup: ChunkGroup): boolean;
addAsyncEntrypoint(entrypoint: Entrypoint): boolean;
get asyncEntrypointsIterable(): SortableSet<ChunkGroup>;
getBlocks(): AsyncDependenciesBlock[];
getNumberOfBlocks(): number;
hasBlock(block: AsyncDependenciesBlock): boolean;
get blocksIterable(): Iterable<AsyncDependenciesBlock>;
addBlock(block: AsyncDependenciesBlock): boolean;
addOrigin(module: Module, loc: DependencyLocation, request: string): void;
getFiles(): string[];
remove(): void;
sortItems(): void;
/**
* Sorting predicate which allows current ChunkGroup to be compared against another.
* Sorting values are based off of number of chunks in ChunkGroup.
*/
compareTo(chunkGraph: ChunkGraph, otherGroup: ChunkGroup): 0 | 1 | -1;
getChildrenByOrders(
moduleGraph: ModuleGraph,
chunkGraph: ChunkGraph
): Record<string, ChunkGroup[]>;
/**
* Sets the top-down index of a module in this ChunkGroup
*/
setModulePreOrderIndex(module: Module, index: number): void;
/**
* Gets the top-down index of a module in this ChunkGroup
*/
getModulePreOrderIndex(module: Module): undefined | number;
/**
* Sets the bottom-up index of a module in this ChunkGroup
*/
setModulePostOrderIndex(module: Module, index: number): void;
/**
* Gets the bottom-up index of a module in this ChunkGroup
*/
getModulePostOrderIndex(module: Module): undefined | number;
checkConstraints(): void;
getModuleIndex: (module: Module) => undefined | number;
getModuleIndex2: (module: Module) => undefined | number;
}
type ChunkGroupOptions = RawChunkGroupOptions & { name?: string };
declare interface ChunkHashContext {
/**
* results of code generation
*/
codeGenerationResults: CodeGenerationResults;
/**
* the runtime template
*/
runtimeTemplate: RuntimeTemplate;
/**
* the module graph
*/
moduleGraph: ModuleGraph;
/**
* the chunk graph
*/
chunkGraph: ChunkGraph;
}
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 class ChunkModuleIdRangePlugin {
constructor(options: ChunkModuleIdRangePluginOptions);
options: ChunkModuleIdRangePluginOptions;
/**
* Apply the plugin
*/
apply(compiler: Compiler): void;
}
declare interface ChunkModuleIdRangePluginOptions {
/**
* the chunk name
*/
name: string;
/**
* order
*/
order?: "index" | "index2" | "preOrderIndex" | "postOrderIndex";
/**
* start id
*/
start?: number;
/**
* end id
*/
end?: number;
}
declare interface ChunkModuleMaps {
id: Record<string | number, (string | number)[]>;
hash: Record<string | number, string>;
}
declare interface ChunkPathData {
id: string | number;
name?: string;
hash: string;
hashWithLength?: (arg0: number) => string;
contentHash?: Record<string, string>;
contentHashWithLength?: Record<string, (length: number) => string>;
}
declare class ChunkPrefetchPreloadPlugin {
constructor();
apply(compiler: Compiler): void;
}
declare interface ChunkRenderContext {
/**
* the chunk
*/
chunk: Chunk;
/**
* the dependency templates
*/
dependencyTemplates: DependencyTemplates;
/**
* the runtime template
*/
runtimeTemplate: RuntimeTemplate;
/**
* the module graph
*/
moduleGraph: ModuleGraph;
/**
* the chunk graph
*/
chunkGraph: ChunkGraph;
/**
* results of code generation
*/
codeGenerationResults: CodeGenerationResults;
/**
* init fragments for the chunk
*/
chunkInitFragments: InitFragment<ChunkRenderContext>[];
/**
* rendering in strict context
*/
strictMode: boolean;
}
declare interface ChunkSizeOptions {
/**
* constant overhead for a chunk
*/
chunkOverhead?: number;
/**
* multiplicator for initial chunks
*/
entryChunkMultiplicator?: number;
}
declare abstract class ChunkTemplate {
hooks: Readonly<{
renderManifest: { tap: (options?: any, fn?: any) => void };
modules: { tap: (options?: any, fn?: any) => void };
render: { tap: (options?: any, fn?: any) => void };
renderWithEntry: { tap: (options?: any, fn?: any) => void };
hash: { tap: (options?: any, fn?: any) => void };
hashForChunk: { tap: (options?: any, fn?: any) => void };
}>;
get outputOptions(): Output;
}
/**
* Advanced options for cleaning assets.
*/
declare interface CleanOptions {
/**
* Log the assets that should be removed instead of deleting them.
*/
dry?: boolean;
/**
* Keep these assets.
*/
keep?: string | RegExp | ((filename: string) => boolean);
}
declare class CleanPlugin {
constructor(options?: CleanOptions);
options: {
/**
* Log the assets that should be removed instead of deleting them.
*/
dry: boolean;
/**
* Keep these assets.
*/
keep?: string | RegExp | ((filename: string) => boolean);
};
/**
* Apply the plugin
*/
apply(compiler: Compiler): void;
static getCompilationHooks(
compilation: Compilation
): CleanPluginCompilationHooks;
}
declare interface CleanPluginCompilationHooks {
/**
* when returning true the file/directory will be kept during cleaning, returning false will clean it and ignore the following plugins and config
*/
keep: SyncBailHook<[string], boolean>;
}
declare interface CodeGenerationContext {
/**
* the dependency templates
*/
dependencyTemplates: DependencyTemplates;
/**
* the runtime template
*/
runtimeTemplate: RuntimeTemplate;
/**
* the module graph
*/
moduleGraph: ModuleGraph;
/**
* the chunk graph
*/
chunkGraph: ChunkGraph;
/**
* the runtimes code should be generated for
*/
runtime: RuntimeSpec;
/**
* when in concatenated module, information about other concatenated modules
*/
concatenationScope?: ConcatenationScope;
/**
* code generation results of other modules (need to have a codeGenerationDependency to use that)
*/
codeGenerationResults?: CodeGenerationResults;
/**
* the compilation
*/
compilation?: Compilation;
/**
* source types
*/
sourceTypes?: ReadonlySet<string>;
}
declare interface CodeGenerationResult {
/**
* the resulting sources for all source types
*/
sources: Map<string, Source>;
/**
* the resulting data for all source types
*/
data?: Map<string, any>;
/**
* the runtime requirements
*/
runtimeRequirements: ReadonlySet<string>;
/**
* a hash of the code generation result (will be automatically calculated from sources and runtimeRequirements if not provided)
*/
hash?: string;
}
declare abstract class CodeGenerationResults {
map: Map<Module, RuntimeSpecMap<CodeGenerationResult>>;
get(module: Module, runtime: RuntimeSpec): CodeGenerationResult;
has(module: Module, runtime: RuntimeSpec): boolean;
getSource(module: Module, runtime: RuntimeSpec, sourceType: string): Source;
getRuntimeRequirements(
module: Module,
runtime: RuntimeSpec
): ReadonlySet<string>;
getData(module: Module, runtime: RuntimeSpec, key: string): any;
getHash(module: Module, runtime: RuntimeSpec): any;
add(module: Module, runtime: RuntimeSpec, result: CodeGenerationResult): void;
}
type CodeValue =
| undefined
| null
| string
| number
| bigint
| boolean
| Function
| RegExp
| RuntimeValue
| {
[index: string]: RecursiveArrayOrRecord<
| undefined
| null
| string
| number
| bigint
| boolean
| Function
| RegExp
| RuntimeValue
>;
}
| RecursiveArrayOrRecord<
| undefined
| null
| string
| number
| bigint
| boolean
| Function
| RegExp
| RuntimeValue
>[];
type CodeValuePrimitive =
| undefined
| null
| string
| number
| bigint
| boolean
| Function
| RegExp;
declare interface Comparator<T> {
(arg0: T, arg1: T): 0 | 1 | -1;
}
declare class CompatSource extends Source {
constructor(sourceLike: SourceLike);
static from(sourceLike: SourceLike): Source;
}
declare class Compilation {
/**
* Creates an instance of Compilation.
*/
constructor(compiler: Compiler, params: CompilationParams);
hooks: Readonly<{
buildModule: SyncHook<[Module]>;
rebuildModule: SyncHook<[Module]>;
failedModule: SyncHook<[Module, WebpackError]>;
succeedModule: SyncHook<[Module]>;
stillValidModule: SyncHook<[Module]>;
addEntry: SyncHook<[Dependency, EntryOptions]>;
failedEntry: SyncHook<[Dependency, EntryOptions, Error]>;
succeedEntry: SyncHook<[Dependency, EntryOptions, Module]>;
dependencyReferencedExports: SyncWaterfallHook<
[(string[] | ReferencedExport)[], Dependency, RuntimeSpec]
>;
executeModule: SyncHook<[ExecuteModuleArgument, ExecuteModuleContext]>;
prepareModuleExecution: AsyncParallelHook<
[ExecuteModuleArgument, ExecuteModuleContext]
>;
finishModules: AsyncSeriesHook<[Iterable<Module>]>;
finishRebuildingModule: AsyncSeriesHook<[Module]>;
unseal: SyncHook<[]>;
seal: SyncHook<[]>;
beforeChunks: SyncHook<[]>;
/**
* The `afterChunks` hook is called directly after the chunks and module graph have
* been created and before the chunks and modules have been optimized. This hook is useful to
* inspect, analyze, and/or modify the chunk graph.
*/
afterChunks: SyncHook<[Iterable<Chunk>]>;
optimizeDependencies: SyncBailHook<[Iterable<Module>], any>;
afterOptimizeDependencies: SyncHook<[Iterable<Module>]>;
optimize: SyncHook<[]>;
optimizeModules: SyncBailHook<[Iterable<Module>], any>;
afterOptimizeModules: SyncHook<[Iterable<Module>]>;
optimizeChunks: SyncBailHook<
[Iterable<Chunk>, ChunkGroup[]],
boolean | void
>;
afterOptimizeChunks: SyncHook<[Iterable<Chunk>, ChunkGroup[]]>;
optimizeTree: AsyncSeriesHook<[Iterable<Chunk>, Iterable<Module>]>;
afterOptimizeTree: SyncHook<[Iterable<Chunk>, Iterable<Module>]>;
optimizeChunkModules: AsyncSeriesBailHook<
[Iterable<Chunk>, Iterable<Module>],
void
>;
afterOptimizeChunkModules: SyncHook<[Iterable<Chunk>, Iterable<Module>]>;
shouldRecord: SyncBailHook<[], undefined | boolean>;
additionalChunkRuntimeRequirements: SyncHook<
[Chunk, Set<string>, RuntimeRequirementsContext]
>;
runtimeRequirementInChunk: HookMap<
SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext], void>
>;
additionalModuleRuntimeRequirements: SyncHook<
[Module, Set<string>, RuntimeRequirementsContext]
>;
runtimeRequirementInModule: HookMap<
SyncBailHook<[Module, Set<string>, RuntimeRequirementsContext], any>
>;
additionalTreeRuntimeRequirements: SyncHook<
[Chunk, Set<string>, RuntimeRequirementsContext]
>;
runtimeRequirementInTree: HookMap<
SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext], any>
>;
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<[]>;
additionalChunkAssets: FakeHook<
Pick<
AsyncSeriesHook<[Set<Chunk>]>,
"name" | "tap" | "tapAsync" | "tapPromise"
>
>;
additionalAssets: FakeHook<
Pick<AsyncSeriesHook<[]>, "name" | "tap" | "tapAsync" | "tapPromise">
>;
optimizeChunkAssets: FakeHook<
Pick<
AsyncSeriesHook<[Set<Chunk>]>,
"name" | "tap" | "tapAsync" | "tapPromise"
>
>;
afterOptimizeChunkAssets: FakeHook<
Pick<
AsyncSeriesHook<[Set<Chunk>]>,
"name" | "tap" | "tapAsync" | "tapPromise"
>
>;
optimizeAssets: AsyncSeriesHook<
[CompilationAssets],
ProcessAssetsAdditionalOptions
>;
afterOptimizeAssets: SyncHook<[CompilationAssets]>;
processAssets: AsyncSeriesHook<
[CompilationAssets],
ProcessAssetsAdditionalOptions
>;
afterProcessAssets: SyncHook<[CompilationAssets]>;
processAdditionalAssets: AsyncSeriesHook<[CompilationAssets]>;
needAdditionalSeal: SyncBailHook<[], undefined | boolean>;
afterSeal: AsyncSeriesHook<[]>;
renderManifest: SyncWaterfallHook<
[RenderManifestEntry[], RenderManifestOptions]
>;
fullHash: SyncHook<[Hash]>;
chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
moduleAsset: SyncHook<[Module, string]>;
chunkAsset: SyncHook<[Chunk, string]>;
assetPath: SyncWaterfallHook<[string, object, undefined | AssetInfo]>;
needAdditionalPass: SyncBailHook<[], boolean>;
childCompiler: SyncHook<[Compiler, string, number]>;
log: SyncBailHook<[string, LogEntry], true>;
processWarnings: SyncWaterfallHook<[WebpackError[]]>;
processErrors: SyncWaterfallHook<[WebpackError[]]>;
statsPreset: HookMap<
SyncHook<[Partial<NormalizedStatsOptions>, CreateStatsOptionsContext]>
>;
statsNormalize: SyncHook<
[Partial<NormalizedStatsOptions>, CreateStatsOptionsContext]
>;
statsFactory: SyncHook<[StatsFactory, NormalizedStatsOptions]>;
statsPrinter: SyncHook<[StatsPrinter, NormalizedStatsOptions]>;
get normalModuleLoader(): SyncHook<[object, NormalModule]>;
}>;
name?: string;
startTime?: number;
endTime?: number;
compiler: Compiler;
resolverFactory: ResolverFactory;
inputFileSystem: InputFileSystem;
fileSystemInfo: FileSystemInfo;
valueCacheVersions: Map<string, string | Set<string>>;
requestShortener: RequestShortener;
compilerPath: string;
logger: WebpackLogger;
options: WebpackOptionsNormalized;
outputOptions: OutputNormalized;
bail: boolean;
profile: boolean;
params: CompilationParams;
mainTemplate: MainTemplate;
chunkTemplate: ChunkTemplate;
runtimeTemplate: RuntimeTemplate;
moduleTemplates: ModuleTemplates;
moduleMemCaches?: Map<Module, WeakTupleMap<any, any>>;
moduleMemCaches2?: Map<Module, WeakTupleMap<any, any>>;
moduleGraph: ModuleGraph;
chunkGraph: ChunkGraph;
codeGenerationResults: CodeGenerationResults;
processDependenciesQueue: AsyncQueue<Module, Module, Module>;
addModuleQueue: AsyncQueue<Module, string, Module>;
factorizeQueue: AsyncQueue<
FactorizeModuleOptions,
string,
Module | ModuleFactoryResult
>;
buildQueue: AsyncQueue<Module, Mod