webpack

webpack

Version 5.97.1
Published 2 months ago
5.21 MB
23 dependencies
MIT license

Install

npm i webpack

yarn add webpack

pnpm add webpack

Overview

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.

Index

Variables

variable CIRCULAR_CONNECTION

const CIRCULAR_CONNECTION: Symbol;

variable MEASURE_END_OPERATION

const MEASURE_END_OPERATION: Symbol;

variable MEASURE_START_OPERATION

const MEASURE_START_OPERATION: Symbol;

variable TOMBSTONE

const TOMBSTONE: Symbol;

variable topLevelSymbolTag

const topLevelSymbolTag: Symbol;

variable TRANSITIVE

const TRANSITIVE: Symbol;

variable TRANSITIVE_ONLY

const TRANSITIVE_ONLY: Symbol;

variable UNDEFINED_MARKER

const UNDEFINED_MARKER: Symbol;

variable UsageState

const UsageState: Readonly<{
    Unused: 0;
    OnlyPropertiesUsed: 1;
    NoInfo: 2;
    Unknown: 3;
    Used: 4;
}>;

variable version

const version: string;

variable webpack

const webpack: {
    (options: Configuration, callback?: CallbackWebpack<Stats>): Compiler;
    (
        options: ReadonlyArray<Configuration> & MultiCompilerOptions,
        callback?: CallbackWebpack<MultiStats>
    ): MultiCompiler;
};

Functions

function exports

exports: typeof exports;

function validate

validate: (arg0: Configuration | Configuration[]) => void;

function validateSchema

validateSchema: (
    schema: Parameters<typeof validateFunction>[0],
    options: Parameters<typeof validateFunction>[1],
    validationConfiguration?: ValidationErrorConfiguration
) => void;

Classes

class AsyncDependenciesBlock

class AsyncDependenciesBlock extends DependenciesBlock {}

constructor

constructor(
    groupOptions: RawChunkGroupOptions & { name?: null | string } & {
        entryOptions?: EntryOptions;
    },
    loc?: SyntheticDependencyLocation | RealDependencyLocation,
    request?: string
);

property chunkName

chunkName?: string;

property groupOptions

groupOptions: RawChunkGroupOptions & { name?: null | string } & {
    entryOptions?: EntryOptions;
};

property loc

loc?: SyntheticDependencyLocation | RealDependencyLocation;

property module

module: any;

property request

request?: string;

class AutomaticPrefetchPlugin

class AutomaticPrefetchPlugin {}

constructor

constructor();

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class BannerPlugin

class BannerPlugin {}

constructor

constructor(options: BannerPluginArgument);

banner: (data: { hash?: string; chunk: Chunk; filename: string }) => string;

property options

options: BannerPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class Cache

class Cache {}

constructor

constructor();

property hooks

hooks: {
    get: AsyncSeriesBailHook<
        [
            string,
            Etag,
            ((result: any, callback: (arg0?: Error) => void) => void)[]
        ],
        any
    >;
    store: AsyncParallelHook<[string, Etag, any]>;
    storeBuildDependencies: AsyncParallelHook<[Iterable<string>]>;
    beginIdle: SyncHook<[]>;
    endIdle: AsyncParallelHook<[]>;
    shutdown: AsyncParallelHook<[]>;
};

property STAGE_DEFAULT

static STAGE_DEFAULT: number;

property STAGE_DISK

static STAGE_DISK: number;

property STAGE_MEMORY

static STAGE_MEMORY: number;

property STAGE_NETWORK

static STAGE_NETWORK: number;

method beginIdle

beginIdle: () => void;

method endIdle

endIdle: (callback: CallbackCacheCache<void>) => void;

method get

get: <T>(
    identifier: string,
    etag: null | Etag,
    callback: CallbackCacheCache<T>
) => void;

method shutdown

shutdown: (callback: CallbackCacheCache<void>) => void;

method store

store: <T>(
    identifier: string,
    etag: null | Etag,
    data: T,
    callback: CallbackCacheCache<void>
) => void;

method storeBuildDependencies

storeBuildDependencies: (
    dependencies: Iterable<string>,
    callback: CallbackCacheCache<void>
) => void;

After this method has succeeded the cache can only be restored when build dependencies are

class Chunk

class Chunk {}

constructor

constructor(name?: string, backCompat?: boolean);

property auxiliaryFiles

auxiliaryFiles: Set<string>;

property chunkReason

chunkReason?: string;

property contentHash

contentHash: Record<string, string>;

property cssFilenameTemplate

cssFilenameTemplate?: string | ((arg0: PathData, arg1?: AssetInfo) => string);

property debugId

debugId: number;

property entryModule

readonly entryModule: Module;

property extraAsync

extraAsync: boolean;

property filenameTemplate

filenameTemplate?: string | ((arg0: PathData, arg1?: AssetInfo) => string);

property files

files: Set<string>;

property groupsIterable

readonly groupsIterable: SortableSet<ChunkGroup>;

property hash

hash?: string;

property id

id: string | number;

property idNameHints

idNameHints: SortableSet<string>;

property ids

ids: ChunkId[];

property modulesIterable

readonly modulesIterable: Iterable<Module>;

property name

name?: string;

property preventIntegration

preventIntegration: boolean;

property rendered

rendered: boolean;

property renderedHash

renderedHash?: string;

property runtime

runtime: RuntimeSpec;

method addGroup

addGroup: (chunkGroup: ChunkGroup) => void;

method addModule

addModule: (module: Module) => boolean;

method canBeInitial

canBeInitial: () => boolean;

method canBeIntegrated

canBeIntegrated: (otherChunk: Chunk) => boolean;

method compareTo

compareTo: (otherChunk: Chunk) => 0 | 1 | -1;

method containsModule

containsModule: (module: Module) => boolean;

method disconnectFromGroups

disconnectFromGroups: () => void;

method getAllAsyncChunks

getAllAsyncChunks: () => Set<Chunk>;

method getAllInitialChunks

getAllInitialChunks: () => Set<Chunk>;

method getAllReferencedAsyncEntrypoints

getAllReferencedAsyncEntrypoints: () => Set<Entrypoint>;

method getAllReferencedChunks

getAllReferencedChunks: () => Set<Chunk>;

method getChildIdsByOrders

getChildIdsByOrders: (
    chunkGraph: ChunkGraph,
    filterFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean
) => Record<string, (string | number)[]>;

method getChildIdsByOrdersMap

getChildIdsByOrdersMap: (
    chunkGraph: ChunkGraph,
    includeDirectChildren?: boolean,
    filterFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean
) => Record<string | number, Record<string, (string | number)[]>>;

method getChildrenOfTypeInOrder

getChildrenOfTypeInOrder: (
    chunkGraph: ChunkGraph,
    type: string
) => undefined | { onChunks: Chunk[]; chunks: Set<Chunk> }[];

method getChunkMaps

getChunkMaps: (realHash: boolean) => ChunkMaps;

method getChunkModuleMaps

getChunkModuleMaps: (filterFn: (m: Module) => boolean) => ChunkModuleMaps;

method getEntryOptions

getEntryOptions: () => undefined | EntryOptions;

method getModules

getModules: () => Module[];

method getNumberOfGroups

getNumberOfGroups: () => number;

method getNumberOfModules

getNumberOfModules: () => number;

method hasAsyncChunks

hasAsyncChunks: () => boolean;

method hasChildByOrder

hasChildByOrder: (
    chunkGraph: ChunkGraph,
    type: string,
    includeDirectChildren?: boolean,
    filterFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean
) => boolean;

method hasEntryModule

hasEntryModule: () => boolean;

method hasModuleInGraph

hasModuleInGraph: (
    filterFn: (m: Module) => boolean,
    filterChunkFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean
) => boolean;

method hasRuntime

hasRuntime: () => boolean;

method integrate

integrate: (otherChunk: Chunk) => boolean;

method integratedSize

integratedSize: (otherChunk: Chunk, options: ChunkSizeOptions) => number;

method isEmpty

isEmpty: () => boolean;

method isInGroup

isInGroup: (chunkGroup: ChunkGroup) => boolean;

method isOnlyInitial

isOnlyInitial: () => boolean;

method modulesSize

modulesSize: () => number;

method moveModule

moveModule: (module: Module, otherChunk: Chunk) => void;

method remove

remove: () => void;

method removeGroup

removeGroup: (chunkGroup: ChunkGroup) => void;

method removeModule

removeModule: (module: Module) => void;

method size

size: (options?: ChunkSizeOptions) => number;

method split

split: (newChunk: Chunk) => void;

method updateHash

updateHash: (hash: Hash, chunkGraph: ChunkGraph) => void;

class ChunkGraph

class ChunkGraph {}

constructor

constructor(moduleGraph: ModuleGraph, hashFunction?: string | typeof Hash);

property moduleGraph

moduleGraph: ModuleGraph;

method addChunkRuntimeRequirements

addChunkRuntimeRequirements: (chunk: Chunk, items: Set<string>) => void;

method addDependentHashModuleToChunk

addDependentHashModuleToChunk: (chunk: Chunk, module: RuntimeModule) => void;

method addFullHashModuleToChunk

addFullHashModuleToChunk: (chunk: Chunk, module: RuntimeModule) => void;

method addModuleRuntimeRequirements

addModuleRuntimeRequirements: (
    module: Module,
    runtime: RuntimeSpec,
    items: Set<string>,
    transferOwnership?: boolean
) => void;

method addTreeRuntimeRequirements

addTreeRuntimeRequirements: (chunk: Chunk, items: Iterable<string>) => void;

method attachDependentHashModules

attachDependentHashModules: (
    chunk: Chunk,
    modules: Iterable<RuntimeModule>
) => void;

method attachFullHashModules

attachFullHashModules: (chunk: Chunk, modules: Iterable<RuntimeModule>) => void;

method attachModules

attachModules: (chunk: Chunk, modules: Iterable<Module>) => void;

method attachRuntimeModules

attachRuntimeModules: (chunk: Chunk, modules: Iterable<RuntimeModule>) => void;

method canChunksBeIntegrated

canChunksBeIntegrated: (chunkA: Chunk, chunkB: Chunk) => boolean;

method clearChunkGraphForChunk

static clearChunkGraphForChunk: (chunk: Chunk) => void;

method clearChunkGraphForModule

static clearChunkGraphForModule: (module: Module) => void;

method compareChunks

compareChunks: (chunkA: Chunk, chunkB: Chunk) => 0 | 1 | -1;

method connectBlockAndChunkGroup

connectBlockAndChunkGroup: (
    depBlock: AsyncDependenciesBlock,
    chunkGroup: ChunkGroup
) => void;

method connectChunkAndEntryModule

connectChunkAndEntryModule: (
    chunk: Chunk,
    module: Module,
    entrypoint: Entrypoint
) => void;

method connectChunkAndModule

connectChunkAndModule: (chunk: Chunk, module: Module) => void;

method connectChunkAndRuntimeModule

connectChunkAndRuntimeModule: (chunk: Chunk, module: RuntimeModule) => void;

method disconnectChunk

disconnectChunk: (chunk: Chunk) => void;

method disconnectChunkAndEntryModule

disconnectChunkAndEntryModule: (chunk: Chunk, module: Module) => void;

method disconnectChunkAndModule

disconnectChunkAndModule: (chunk: Chunk, module: Module) => void;

method disconnectChunkAndRuntimeModule

disconnectChunkAndRuntimeModule: (chunk: Chunk, module: RuntimeModule) => void;

method disconnectChunkGroup

disconnectChunkGroup: (chunkGroup: ChunkGroup) => void;

method disconnectEntries

disconnectEntries: (chunk: Chunk) => void;

method disconnectEntryModule

disconnectEntryModule: (module: Module) => void;

method getBlockChunkGroup

getBlockChunkGroup: (depBlock: AsyncDependenciesBlock) => undefined | ChunkGroup;

method getChunkConditionMap

getChunkConditionMap: (
    chunk: Chunk,
    filterFn: (c: Chunk, chunkGraph: ChunkGraph) => boolean
) => Record<string | number, boolean>;

method getChunkDependentHashModulesIterable

getChunkDependentHashModulesIterable: (
    chunk: Chunk
) => undefined | Iterable<RuntimeModule>;

method getChunkEntryDependentChunksIterable

getChunkEntryDependentChunksIterable: (chunk: Chunk) => Iterable<Chunk>;

method getChunkEntryModulesIterable

getChunkEntryModulesIterable: (chunk: Chunk) => Iterable<Module>;

method getChunkEntryModulesWithChunkGroupIterable

getChunkEntryModulesWithChunkGroupIterable: (
    chunk: Chunk
) => Iterable<[Module, undefined | Entrypoint]>;

method getChunkFullHashModulesIterable

getChunkFullHashModulesIterable: (
    chunk: Chunk
) => undefined | Iterable<RuntimeModule>;

method getChunkFullHashModulesSet

getChunkFullHashModulesSet: (
    chunk: Chunk
) => undefined | ReadonlySet<RuntimeModule>;

method getChunkGraphForChunk

static getChunkGraphForChunk: (
    chunk: Chunk,
    deprecateMessage: string,
    deprecationCode: string
) => ChunkGraph;

method getChunkGraphForModule

static getChunkGraphForModule: (
    module: Module,
    deprecateMessage: string,
    deprecationCode: string
) => ChunkGraph;

method getChunkModuleIdMap

getChunkModuleIdMap: (
    chunk: Chunk,
    filterFn: (m: Module) => boolean,
    includeAllChunks?: boolean
) => Record<string | number, (string | number)[]>;

method getChunkModuleRenderedHashMap

getChunkModuleRenderedHashMap: (
    chunk: Chunk,
    filterFn: (m: Module) => boolean,
    hashLength?: number,
    includeAllChunks?: boolean
) => Record<string | number, Record<string | number, string>>;

method getChunkModules

getChunkModules: (chunk: Chunk) => Module[];

method getChunkModulesIterable

getChunkModulesIterable: (chunk: Chunk) => Iterable<Module>;

method getChunkModulesIterableBySourceType

getChunkModulesIterableBySourceType: (
    chunk: Chunk,
    sourceType: string
) => undefined | Iterable<Module>;

method getChunkModuleSourceTypes

getChunkModuleSourceTypes: (chunk: Chunk, module: Module) => ReadonlySet<string>;

method getChunkModulesSize

getChunkModulesSize: (chunk: Chunk) => number;

method getChunkModulesSizes

getChunkModulesSizes: (chunk: Chunk) => Record<string, number>;

method getChunkRootModules

getChunkRootModules: (chunk: Chunk) => Module[];

method getChunkRuntimeModulesInOrder

getChunkRuntimeModulesInOrder: (chunk: Chunk) => RuntimeModule[];

method getChunkRuntimeModulesIterable

getChunkRuntimeModulesIterable: (chunk: Chunk) => Iterable<RuntimeModule>;

method getChunkRuntimeRequirements

getChunkRuntimeRequirements: (chunk: Chunk) => ReadonlySet<string>;

method getChunkSize

getChunkSize: (chunk: Chunk, options?: ChunkSizeOptions) => number;

method getIntegratedChunksSize

getIntegratedChunksSize: (
    chunkA: Chunk,
    chunkB: Chunk,
    options?: ChunkSizeOptions
) => number;

method getModuleChunks

getModuleChunks: (module: Module) => Chunk[];

method getModuleChunksIterable

getModuleChunksIterable: (module: Module) => Iterable<Chunk>;

method getModuleGraphHash

getModuleGraphHash: (
    module: Module,
    runtime: RuntimeSpec,
    withConnections?: boolean
) => string;

method getModuleGraphHashBigInt

getModuleGraphHashBigInt: (
    module: Module,
    runtime: RuntimeSpec,
    withConnections?: boolean
) => bigint;

method getModuleHash

getModuleHash: (module: Module, runtime: RuntimeSpec) => string;

method getModuleId

getModuleId: (module: Module) => null | string | number;

method getModuleRuntimeRequirements

getModuleRuntimeRequirements: (
    module: Module,
    runtime: RuntimeSpec
) => ReadonlySet<string>;

method getModuleRuntimes

getModuleRuntimes: (module: Module) => RuntimeSpecSet;

method getModuleSourceTypes

getModuleSourceTypes: (module: Module) => ReadonlySet<string>;

method getNumberOfChunkFullHashModules

getNumberOfChunkFullHashModules: (chunk: Chunk) => number;

method getNumberOfChunkModules

getNumberOfChunkModules: (chunk: Chunk) => number;

method getNumberOfEntryModules

getNumberOfEntryModules: (chunk: Chunk) => number;

method getNumberOfModuleChunks

getNumberOfModuleChunks: (module: Module) => number;

method getNumberOfRuntimeModules

getNumberOfRuntimeModules: (chunk: Chunk) => number;

method getOrderedChunkModules

getOrderedChunkModules: (
    chunk: Chunk,
    comparator: (arg0: Module, arg1: Module) => 0 | 1 | -1
) => Module[];

method getOrderedChunkModulesIterable

getOrderedChunkModulesIterable: (
    chunk: Chunk,
    comparator: (arg0: Module, arg1: Module) => 0 | 1 | -1
) => Iterable<Module>;

method getOrderedChunkModulesIterableBySourceType

getOrderedChunkModulesIterableBySourceType: (
    chunk: Chunk,
    sourceType: string,
    comparator: (arg0: Module, arg1: Module) => 0 | 1 | -1
) => undefined | Iterable<Module>;

method getOrderedModuleChunksIterable

getOrderedModuleChunksIterable: (
    module: Module,
    sortFn: (arg0: Chunk, arg1: Chunk) => 0 | 1 | -1
) => Iterable<Chunk>;

method getRenderedModuleHash

getRenderedModuleHash: (module: Module, runtime: RuntimeSpec) => string;

method getRuntimeId

getRuntimeId: (runtime: string) => string | number;

method getTreeRuntimeRequirements

getTreeRuntimeRequirements: (chunk: Chunk) => ReadonlySet<string>;

method hasChunkEntryDependentChunks

hasChunkEntryDependentChunks: (chunk: Chunk) => boolean;

method hasModuleHashes

hasModuleHashes: (module: Module, runtime: RuntimeSpec) => boolean;

method hasModuleInGraph

hasModuleInGraph: (
    chunk: Chunk,
    filterFn: (m: Module) => boolean,
    filterChunkFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean
) => boolean;

method integrateChunks

integrateChunks: (chunkA: Chunk, chunkB: Chunk) => void;

method isEntryModule

isEntryModule: (module: Module) => boolean;

method isEntryModuleInChunk

isEntryModuleInChunk: (module: Module, chunk: Chunk) => boolean;

method isModuleInChunk

isModuleInChunk: (module: Module, chunk: Chunk) => boolean;

method isModuleInChunkGroup

isModuleInChunkGroup: (module: Module, chunkGroup: ChunkGroup) => boolean;

method replaceModule

replaceModule: (oldModule: Module, newModule: Module) => void;

method setChunkGraphForChunk

static setChunkGraphForChunk: (chunk: Chunk, chunkGraph: ChunkGraph) => void;

method setChunkGraphForModule

static setChunkGraphForModule: (module: Module, chunkGraph: ChunkGraph) => void;

method setChunkModuleSourceTypes

setChunkModuleSourceTypes: (
    chunk: Chunk,
    module: Module,
    sourceTypes: Set<string>
) => void;

method setModuleHashes

setModuleHashes: (
    module: Module,
    runtime: RuntimeSpec,
    hash: string,
    renderedHash: string
) => void;

method setModuleId

setModuleId: (module: Module, id: ModuleId) => void;

method setRuntimeId

setRuntimeId: (runtime: string, id: string | number) => void;

method upgradeDependentToFullHashModules

upgradeDependentToFullHashModules: (chunk: Chunk) => void;

class ChunkGroup

abstract class ChunkGroup {}

property asyncEntrypointsIterable

readonly asyncEntrypointsIterable: SortableSet<ChunkGroup>;

property blocksIterable

readonly blocksIterable: Iterable<AsyncDependenciesBlock>;

property childrenIterable

readonly childrenIterable: SortableSet<ChunkGroup>;

property chunks

chunks: Chunk[];

property debugId

readonly debugId: string;

get a uniqueId for ChunkGroup, made up of its member Chunk debugId's

property getModuleIndex

getModuleIndex: (module: Module) => undefined | number;

property getModuleIndex2

getModuleIndex2: (module: Module) => undefined | number;

property groupDebugId

groupDebugId: number;

property id

readonly id: string;

get a unique id for ChunkGroup, made up of its member Chunk id's

property index

index?: number;

property name

name?: string;

returns the name of current ChunkGroup sets a new name for current ChunkGroup

property options

options: ChunkGroupOptions;

property origins

origins: OriginRecord[];

property parentsIterable

readonly parentsIterable: SortableSet<ChunkGroup>;

method addAsyncEntrypoint

addAsyncEntrypoint: (entrypoint: Entrypoint) => boolean;

method addBlock

addBlock: (block: AsyncDependenciesBlock) => boolean;

method addChild

addChild: (group: ChunkGroup) => boolean;

method addOptions

addOptions: (options: ChunkGroupOptions) => void;

when a new chunk is added to a chunkGroup, addingOptions will occur.

method addOrigin

addOrigin: (
    module: null | Module,
    loc: DependencyLocation,
    request: string
) => void;

method addParent

addParent: (parentChunk: ChunkGroup) => boolean;

method checkConstraints

checkConstraints: () => void;

method compareTo

compareTo: (chunkGraph: ChunkGraph, otherGroup: ChunkGroup) => 0 | 1 | -1;

Sorting predicate which allows current ChunkGroup to be compared against another. Sorting values are based off of number of chunks in ChunkGroup.

method getBlocks

getBlocks: () => AsyncDependenciesBlock[];

method getChildren

getChildren: () => ChunkGroup[];

method getChildrenByOrders

getChildrenByOrders: (
    moduleGraph: ModuleGraph,
    chunkGraph: ChunkGraph
) => Record<string, ChunkGroup[]>;

method getFiles

getFiles: () => string[];

method getModulePostOrderIndex

getModulePostOrderIndex: (module: Module) => undefined | number;

Gets the bottom-up index of a module in this ChunkGroup

method getModulePreOrderIndex

getModulePreOrderIndex: (module: Module) => undefined | number;

Gets the top-down index of a module in this ChunkGroup

method getNumberOfBlocks

getNumberOfBlocks: () => number;

method getNumberOfChildren

getNumberOfChildren: () => number;

method getNumberOfParents

getNumberOfParents: () => number;

method getParents

getParents: () => ChunkGroup[];

method hasBlock

hasBlock: (block: AsyncDependenciesBlock) => boolean;

method hasParent

hasParent: (parent: ChunkGroup) => boolean;

method insertChunk

insertChunk: (chunk: Chunk, before: Chunk) => boolean;

inserts a chunk before another existing chunk in group

method isInitial

isInitial: () => boolean;

method pushChunk

pushChunk: (chunk: Chunk) => boolean;

add a chunk into ChunkGroup. Is pushed on or prepended

method remove

remove: () => void;

method removeChild

removeChild: (group: ChunkGroup) => boolean;

method removeChunk

removeChunk: (chunk: Chunk) => boolean;

method removeParent

removeParent: (chunkGroup: ChunkGroup) => boolean;

method replaceChunk

replaceChunk: (oldChunk: Chunk, newChunk: Chunk) => undefined | boolean;

method setModulePostOrderIndex

setModulePostOrderIndex: (module: Module, index: number) => void;

Sets the bottom-up index of a module in this ChunkGroup

method setModulePreOrderIndex

setModulePreOrderIndex: (module: Module, index: number) => void;

Sets the top-down index of a module in this ChunkGroup

method sortItems

sortItems: () => void;

method unshiftChunk

unshiftChunk: (chunk: Chunk) => boolean;

Performs an unshift of a specific chunk

class CleanPlugin

class CleanPlugin {}

constructor

constructor(options?: CleanOptions);

property options

options: {
    dry: boolean;
    keep?: string | RegExp | ((filename: string) => boolean);
};

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

method getCompilationHooks

static getCompilationHooks: (
    compilation: Compilation
) => CleanPluginCompilationHooks;

class Compilation

class Compilation {}

constructor

constructor(compiler: Compiler, params: CompilationParams);

Creates an instance of Compilation.

property additionalChunkAssets

additionalChunkAssets: string[];

property addModuleQueue

addModuleQueue: AsyncQueue<Module, string, Module>;

property assets

assets: CompilationAssets;

property assetsInfo

assetsInfo: Map<string, AssetInfo>;

property asyncEntrypoints

asyncEntrypoints: Entrypoint[];

property bail

bail: boolean;

property buildDependencies

buildDependencies: LazySet<string>;

property buildQueue

buildQueue: AsyncQueue<Module, Module, Module>;

property buildTimeExecutedModules

buildTimeExecutedModules: WeakSet<Module>;

property builtModules

builtModules: WeakSet<Module>;

property children

children: Compilation[];

property childrenCounters

childrenCounters: Record<string, number>;

property chunkGraph

chunkGraph: ChunkGraph;

property chunkGroups

chunkGroups: ChunkGroup[];

property chunks

chunks: Set<Chunk>;

property chunkTemplate

chunkTemplate: ChunkTemplate;

property codeGeneratedModules

codeGeneratedModules: WeakSet<Module>;

property codeGenerationResults

codeGenerationResults: CodeGenerationResults;

property comparedForEmitAssets

comparedForEmitAssets: Set<string>;

property compilationDependencies

compilationDependencies: { add: (item: string) => LazySet<string> };

property compiler

compiler: Compiler;

property compilerPath

compilerPath: string;

property contextDependencies

contextDependencies: LazySet<string>;

property creatingModuleDuringBuild

creatingModuleDuringBuild: WeakMap<Module, Set<Module>>;

Modules in value are building during the build of Module in key. Means value blocking key from finishing. Needed to detect build cycles.

property dependencyFactories

dependencyFactories: Map<DepConstructor, ModuleFactory>;

property dependencyTemplates

dependencyTemplates: DependencyTemplates;

property emittedAssets

emittedAssets: Set<string>;

property endTime

endTime?: number;

property entries

entries: Map<string, EntryData>;

property entrypoints

entrypoints: Map<string, Entrypoint>;

property errors

errors: WebpackError[];

property factorizeModule

factorizeModule: {
    (
        options: FactorizeModuleOptions & { factoryResult?: false },
        callback: (err?: null | WebpackError, result?: null | Module) => void
    ): void;
    (
        options: FactorizeModuleOptions & { factoryResult: true },
        callback: (
            err?: null | WebpackError,
            result?: ModuleFactoryResult
        ) => void
    ): void;
};

property factorizeQueue

factorizeQueue: AsyncQueue<
    FactorizeModuleOptions,
    string,
    Module | ModuleFactoryResult
>;

property fileDependencies

fileDependencies: LazySet<string>;

property fileSystemInfo

fileSystemInfo: FileSystemInfo;

property fullHash

fullHash?: string;

property globalEntry

globalEntry: EntryData;

property hash

hash?: string;

property hooks

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<[]>;
    afterChunks: SyncHook<[Iterable<Chunk>]>;
    optimizeDependencies: SyncBailHook<[Iterable<Module>], boolean | void>;
    afterOptimizeDependencies: SyncHook<[Iterable<Module>]>;
    optimize: SyncHook<[]>;
    optimizeModules: SyncBailHook<[Iterable<Module>], boolean | void>;
    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<[], boolean | void>;
    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], void>
    >;
    additionalTreeRuntimeRequirements: SyncHook<
        [Chunk, Set<string>, RuntimeRequirementsContext]
    >;
    runtimeRequirementInTree: HookMap<
        SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext], void>
    >;
    runtimeModule: SyncHook<[RuntimeModule, Chunk]>;
    reviveModules: SyncHook<[Iterable<Module>, any]>;
    beforeModuleIds: SyncHook<[Iterable<Module>]>;
    moduleIds: SyncHook<[Iterable<Module>]>;
    optimizeModuleIds: SyncHook<[Iterable<Module>]>;
    afterOptimizeModuleIds: SyncHook<[Iterable<Module>]>;
    reviveChunks: SyncHook<[Iterable<Chunk>, any]>;
    beforeChunkIds: SyncHook<[Iterable<Chunk>]>;
    chunkIds: SyncHook<[Iterable<Chunk>]>;
    optimizeChunkIds: SyncHook<[Iterable<Chunk>]>;
    afterOptimizeChunkIds: SyncHook<[Iterable<Chunk>]>;
    recordModules: SyncHook<[Iterable<Module>, any]>;
    recordChunks: SyncHook<[Iterable<Chunk>, any]>;
    optimizeCodeGeneration: SyncHook<[Iterable<Module>]>;
    beforeModuleHash: SyncHook<[]>;
    afterModuleHash: SyncHook<[]>;
    beforeCodeGeneration: SyncHook<[]>;
    afterCodeGeneration: SyncHook<[]>;
    beforeRuntimeRequirements: SyncHook<[]>;
    afterRuntimeRequirements: SyncHook<[]>;
    beforeHash: SyncHook<[]>;
    contentHash: SyncHook<[Chunk]>;
    afterHash: SyncHook<[]>;
    recordHash: SyncHook<[any]>;
    record: SyncHook<[Compilation, any]>;
    beforeModuleAssets: SyncHook<[]>;
    shouldGenerateChunkAssets: SyncBailHook<[], boolean | void>;
    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<[], boolean | void>;
    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, AssetInfo]>;
    needAdditionalPass: SyncBailHook<[], boolean | void>;
    childCompiler: SyncHook<[Compiler, string, number]>;
    log: SyncBailHook<[string, LogEntry], boolean | void>;
    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]>;
    readonly normalModuleLoader: SyncHook<
        [LoaderContextNormalModule<any>, NormalModule]
    >;
}>;

property inputFileSystem

inputFileSystem: InputFileSystem;

property logger

logger: WebpackLogger;

property logging

logging: Map<string, LogEntry[]>;

property mainTemplate

mainTemplate: MainTemplate;

property missingDependencies

missingDependencies: LazySet<string>;

property moduleGraph

moduleGraph: ModuleGraph;

property moduleMemCaches

moduleMemCaches?: Map<Module, WeakTupleMap<any, any>>;

property moduleMemCaches2

moduleMemCaches2?: Map<Module, WeakTupleMap<any, any>>;

property modules

modules: Set<Module>;

property moduleTemplates

moduleTemplates: ModuleTemplates;

property name

name?: string;

property namedChunkGroups

namedChunkGroups: Map<string, ChunkGroup>;

property namedChunks

namedChunks: Map<string, Chunk>;

property needAdditionalPass

needAdditionalPass: boolean;

property options

options: WebpackOptionsNormalized;

property outputOptions

outputOptions: OutputNormalized;

property params

params: CompilationParams;

property PROCESS_ASSETS_STAGE_ADDITIONAL

static PROCESS_ASSETS_STAGE_ADDITIONAL: number;

Add additional assets to the compilation.

property PROCESS_ASSETS_STAGE_ADDITIONS

static PROCESS_ASSETS_STAGE_ADDITIONS: number;

Add additional sections to existing assets, like a banner or initialization code.

property PROCESS_ASSETS_STAGE_ANALYSE

static PROCESS_ASSETS_STAGE_ANALYSE: number;

Analyse existing assets.

property PROCESS_ASSETS_STAGE_DERIVED

static PROCESS_ASSETS_STAGE_DERIVED: number;

Derive new assets from existing assets. Existing assets should not be treated as complete.

property PROCESS_ASSETS_STAGE_DEV_TOOLING

static PROCESS_ASSETS_STAGE_DEV_TOOLING: number;

Add development tooling to assets, e. g. by extracting a SourceMap.

property PROCESS_ASSETS_STAGE_OPTIMIZE

static PROCESS_ASSETS_STAGE_OPTIMIZE: number;

Optimize existing assets in a general way.

property PROCESS_ASSETS_STAGE_OPTIMIZE_COMPATIBILITY

static PROCESS_ASSETS_STAGE_OPTIMIZE_COMPATIBILITY: number;

Optimize the compatibility of existing assets, e. g. add polyfills or vendor-prefixes.

property PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT

static PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT: number;

Optimize the count of existing assets, e. g. by merging them. Only assets of the same type should be merged. For assets of different types see PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE.

property PROCESS_ASSETS_STAGE_OPTIMIZE_HASH

static PROCESS_ASSETS_STAGE_OPTIMIZE_HASH: number;

Optimize the hashes of the assets, e. g. by generating real hashes of the asset content.

property PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE

static PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE: number;

Optimize the count of existing assets, e. g. by inlining assets of into other assets. Only assets of different types should be inlined. For assets of the same type see PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT.

property PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE

static PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE: number;

Optimize the size of existing assets, e. g. by minimizing or omitting whitespace.

property PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER

static PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER: number;

Optimize the transfer of existing assets, e. g. by preparing a compressed (gzip) file as separate asset.

property PROCESS_ASSETS_STAGE_PRE_PROCESS

static PROCESS_ASSETS_STAGE_PRE_PROCESS: number;

Basic preprocessing of assets.

property PROCESS_ASSETS_STAGE_REPORT

static PROCESS_ASSETS_STAGE_REPORT: number;

Creating assets for reporting purposes.

property PROCESS_ASSETS_STAGE_SUMMARIZE

static PROCESS_ASSETS_STAGE_SUMMARIZE: number;

Summarize the list of existing assets e. g. creating an assets manifest of Service Workers.

property processDependenciesQueue

processDependenciesQueue: AsyncQueue<Module, Module, Module>;

property profile

profile: boolean;

property rebuildQueue

rebuildQueue: AsyncQueue<Module, Module, Module>;

property records

records: any;

property requestShortener

requestShortener: RequestShortener;

property resolverFactory

resolverFactory: ResolverFactory;

property runtimeTemplate

runtimeTemplate: RuntimeTemplate;

property startTime

startTime?: number;

property usedChunkIds

usedChunkIds: Set<string | number>;

property usedModuleIds

usedModuleIds: Set<number>;

property valueCacheVersions

valueCacheVersions: Map<string, string | Set<string>>;

property warnings

warnings: WebpackError[];

method addAsyncEntrypoint

addAsyncEntrypoint: (
    options: EntryOptions,
    module: Module,
    loc: DependencyLocation,
    request: string
) => Entrypoint;

method addChunk

addChunk: (name?: string) => Chunk;

This method first looks to see if a name is provided for a new chunk, and first looks to see if any named chunks already exist and reuse that chunk instead.

method addChunkInGroup

addChunkInGroup: (
    groupOptions: string | ChunkGroupOptions,
    module?: Module,
    loc?: SyntheticDependencyLocation | RealDependencyLocation,
    request?: string
) => ChunkGroup;

If module is passed, loc and request must also be passed.

method addEntry

addEntry: (
    context: string,
    entry: Dependency,
    optionsOrName: string | EntryOptions,
    callback: (err?: null | WebpackError, result?: null | Module) => void
) => void;

method addInclude

addInclude: (
    context: string,
    dependency: Dependency,
    options: EntryOptions,
    callback: (err?: null | WebpackError, result?: null | Module) => void
) => void;

method addModule

addModule: (
    module: Module,
    callback: (err?: null | WebpackError, result?: null | Module) => void
) => void;

method addModuleChain

addModuleChain: (
    context: string,
    dependency: Dependency,
    callback: (err?: null | WebpackError, result?: null | Module) => void
) => void;

method addModuleTree

addModuleTree: (
    __0: {
        context: string;
        dependency: Dependency;
        contextInfo?: Partial<ModuleFactoryCreateDataContextInfo>;
    },
    callback: (err?: null | WebpackError, result?: null | Module) => void
) => void;

method addRuntimeModule

addRuntimeModule: (
    chunk: Chunk,
    module: RuntimeModule,
    chunkGraph?: ChunkGraph
) => void;

method assignDepth

assignDepth: (module: Module) => void;

method assignDepths

assignDepths: (modules: Set<Module>) => void;

method assignRuntimeIds

assignRuntimeIds: () => void;

method buildModule

buildModule: (
    module: Module,
    callback: (err?: null | WebpackError, result?: null | Module) => void
) => void;

Schedules a build of the module object

method checkConstraints

checkConstraints: () => void;

method clearAssets

clearAssets: () => void;

method codeGeneration

codeGeneration: (callback: (err?: null | WebpackError) => void) => void;

method createChildCompiler

createChildCompiler: (
    name: string,
    outputOptions?: Partial<OutputNormalized>,
    plugins?: (
        | ((this: Compiler, compiler: Compiler) => void)
        | WebpackPluginInstance
    )[]
) => Compiler;

This function allows you to run another instance of webpack inside of webpack however as a child with different settings and configurations (if desired) applied. It copies all hooks, plugins from parent (or top level compiler) and creates a child Compilation

method createChunkAssets

createChunkAssets: (callback: (err?: null | WebpackError) => void) => void;

method createHash

createHash: () => {
    module: Module;
    hash: string;
    runtime: RuntimeSpec;
    runtimes: RuntimeSpec[];
}[];

method createModuleAssets

createModuleAssets: () => void;

method createModuleHashes

createModuleHashes: () => void;

method createStatsFactory

createStatsFactory: (options: NormalizedStatsOptions) => StatsFactory;

method createStatsOptions

createStatsOptions: (
    optionsOrPreset?: string | boolean | StatsOptions,
    context?: CreateStatsOptionsContext
) => NormalizedStatsOptions;

method createStatsPrinter

createStatsPrinter: (options: NormalizedStatsOptions) => StatsPrinter;

method deleteAsset

deleteAsset: (file: string) => void;

method emitAsset

emitAsset: (file: string, source: Source, assetInfo?: AssetInfo) => void;

method executeModule

executeModule: (
    module: Module,
    options: ExecuteModuleOptions,
    callback: (err: null | WebpackError, result?: ExecuteModuleResult) => void
) => void;

method findModule

findModule: (identifier: string) => undefined | Module;

Attempts to search for a module by its identifier

method finish

finish: (callback: (err?: null | WebpackError) => void) => void;

method getAsset

getAsset: (name: string) => undefined | Readonly<Asset>;

method getAssetPath

getAssetPath: (filename: TemplatePath, data: PathData) => string;

method getAssetPathWithInfo

getAssetPathWithInfo: (
    filename: TemplatePath,
    data: PathData
) => InterpolatedPathAndAssetInfo;

method getAssets

getAssets: () => Readonly<Asset>[];

method getCache

getCache: (name: string) => CacheFacade;

method getDependencyReferencedExports

getDependencyReferencedExports: (
    dependency: Dependency,
    runtime: RuntimeSpec
) => (string[] | ReferencedExport)[];

method getErrors

getErrors: () => WebpackError[];

method getLogger

getLogger: (name: string | (() => string)) => WebpackLogger;

method getModule

getModule: (module: Module) => Module;

Fetches a module from a compilation by its identifier

method getPath

getPath: (filename: TemplatePath, data?: PathData) => string;

method getPathWithInfo

getPathWithInfo: (
    filename: TemplatePath,
    data?: PathData
) => InterpolatedPathAndAssetInfo;

method getRenderManifest

getRenderManifest: (options: RenderManifestOptions) => RenderManifestEntry[];

method getStats

getStats: () => Stats;

method getWarnings

getWarnings: () => WebpackError[];

method handleModuleCreation

handleModuleCreation: (
    __0: HandleModuleCreationOptions,
    callback: (err?: null | WebpackError, result?: null | Module) => void
) => void;

method patchChunksAfterReasonRemoval

patchChunksAfterReasonRemoval: (module: Module, chunk: Chunk) => void;

method processModuleDependencies

processModuleDependencies: (
    module: Module,
    callback: (err?: null | WebpackError, result?: null | Module) => void
) => void;

method processModuleDependenciesNonRecursive

processModuleDependenciesNonRecursive: (module: Module) => void;

method processRuntimeRequirements

processRuntimeRequirements: (__0?: {
    chunkGraph?: ChunkGraph;
    modules?: Iterable<Module>;
    chunks?: Iterable<Chunk>;
    codeGenerationResults?: CodeGenerationResults;
    chunkGraphEntries?: Iterable<Chunk>;
}) => void;

method rebuildModule

rebuildModule: (
    module: Module,
    callback: (err?: null | WebpackError, result?: null | Module) => void
) => void;

method removeChunkFromDependencies

removeChunkFromDependencies: (block: DependenciesBlock, chunk: Chunk) => void;

method removeReasonsOfDependencyBlock

removeReasonsOfDependencyBlock: (
    module: Module,
    block: DependenciesBlockLike
) => void;

method renameAsset

renameAsset: (file: string, newFile: string) => void;

method reportDependencyErrorsAndWarnings

reportDependencyErrorsAndWarnings: (
    module: Module,
    blocks: DependenciesBlock[]
) => boolean;

method seal

seal: (callback: (err?: null | WebpackError) => void) => void;

method sortItemsWithChunkIds

sortItemsWithChunkIds: () => void;

method summarizeDependencies

summarizeDependencies: () => void;

method unseal

unseal: () => void;

method updateAsset

updateAsset: (
    file: string,
    newSourceOrFunction: Source | ((arg0: Source) => Source),
    assetInfoUpdateOrFunction?: AssetInfo | ((arg0?: AssetInfo) => AssetInfo)
) => void;

class Compiler

class Compiler {}

constructor

constructor(context: string, options?: WebpackOptionsNormalized);

property cache

cache: Cache;

property compilerPath

compilerPath: string;

property context

context: string;

property contextTimestamps

contextTimestamps?: ReadonlyMap<string, FileSystemInfoEntry | 'ignore'>;

property fileTimestamps

fileTimestamps?: ReadonlyMap<string, FileSystemInfoEntry | 'ignore'>;

property fsStartTime

fsStartTime?: number;

property hooks

hooks: Readonly<{
    initialize: SyncHook<[]>;
    shouldEmit: SyncBailHook<[Compilation], boolean | void>;
    done: AsyncSeriesHook<[Stats]>;
    afterDone: SyncHook<[Stats]>;
    additionalPass: AsyncSeriesHook<[]>;
    beforeRun: AsyncSeriesHook<[Compiler]>;
    run: AsyncSeriesHook<[Compiler]>;
    emit: AsyncSeriesHook<[Compilation]>;
    assetEmitted: AsyncSeriesHook<[string, AssetEmittedInfo]>;
    afterEmit: AsyncSeriesHook<[Compilation]>;
    thisCompilation: SyncHook<[Compilation, CompilationParams]>;
    compilation: SyncHook<[Compilation, CompilationParams]>;
    normalModuleFactory: SyncHook<[NormalModuleFactory]>;
    contextModuleFactory: SyncHook<[ContextModuleFactory]>;
    beforeCompile: AsyncSeriesHook<[CompilationParams]>;
    compile: SyncHook<[CompilationParams]>;
    make: AsyncParallelHook<[Compilation]>;
    finishMake: AsyncParallelHook<[Compilation]>;
    afterCompile: AsyncSeriesHook<[Compilation]>;
    readRecords: AsyncSeriesHook<[]>;
    emitRecords: AsyncSeriesHook<[]>;
    watchRun: AsyncSeriesHook<[Compiler]>;
    failed: SyncHook<[Error]>;
    invalid: SyncHook<[string, number]>;
    watchClose: SyncHook<[]>;
    shutdown: AsyncSeriesHook<[]>;
    infrastructureLog: SyncBailHook<[string, string, any[]], true | void>;
    environment: SyncHook<[]>;
    afterEnvironment: SyncHook<[]>;
    afterPlugins: SyncHook<[Compiler]>;
    afterResolvers: SyncHook<[Compiler]>;
    entryOption: SyncBailHook<[string, EntryNormalized], boolean | void>;
}>;

property idle

idle: boolean;

property immutablePaths

immutablePaths: Set<string | RegExp>;

property infrastructureLogger

infrastructureLogger?: (arg0: string, arg1: LogTypeEnum, arg2?: any[]) => void;

property inputFileSystem

inputFileSystem: InputFileSystem;

property intermediateFileSystem

intermediateFileSystem: IntermediateFileSystem;

property managedPaths

managedPaths: Set<string | RegExp>;

property modifiedFiles

modifiedFiles?: ReadonlySet<string>;

property moduleMemCaches

moduleMemCaches?: Map<Module, ModuleMemCachesItem>;

property name

name?: string;

property options

options: WebpackOptionsNormalized;

property outputFileSystem

outputFileSystem: OutputFileSystem;

property outputPath

outputPath: string;

property parentCompilation

parentCompilation?: Compilation;

property platform

platform: Readonly<PlatformTargetProperties>;

property records

records: Record<string, any>;

property recordsInputPath

recordsInputPath: string;

property recordsOutputPath

recordsOutputPath: string;

property removedFiles

removedFiles?: ReadonlySet<string>;

property requestShortener

requestShortener: RequestShortener;

property resolverFactory

resolverFactory: ResolverFactory;

property root

root: Compiler;

property running

running: boolean;

property unmanagedPaths

unmanagedPaths: Set<string | RegExp>;

property watchFileSystem

watchFileSystem: WatchFileSystem;

property watching

watching?: Watching;

property watchMode

watchMode: boolean;

property webpack

webpack: typeof exports;

method close

close: (callback: RunCallback<void>) => void;

method compile

compile: (callback: RunCallback<Compilation>) => void;

method createChildCompiler

createChildCompiler: (
    compilation: Compilation,
    compilerName: string,
    compilerIndex: number,
    outputOptions?: Partial<OutputNormalized>,
    plugins?: WebpackPluginInstance[]
) => Compiler;

method createCompilation

createCompilation: (params: CompilationParams) => Compilation;

method createContextModuleFactory

createContextModuleFactory: () => ContextModuleFactory;

method createNormalModuleFactory

createNormalModuleFactory: () => NormalModuleFactory;

method emitAssets

emitAssets: (
    compilation: Compilation,
    callback: CallbackFunction_2<void>
) => void;

method emitRecords

emitRecords: (callback: CallbackFunction_2<void>) => void;

method getCache

getCache: (name: string) => CacheFacade;

method getInfrastructureLogger

getInfrastructureLogger: (name: string | (() => string)) => WebpackLogger;

method isChild

isChild: () => boolean;

method newCompilation

newCompilation: (params: CompilationParams) => Compilation;

method newCompilationParams

newCompilationParams: () => {
    normalModuleFactory: NormalModuleFactory;
    contextModuleFactory: ContextModuleFactory;
};

method purgeInputFileSystem

purgeInputFileSystem: () => void;

method readRecords

readRecords: (callback: CallbackFunction_2<void>) => void;

method run

run: (callback: RunCallback<Stats>) => void;

method runAsChild

runAsChild: (
    callback: (
        err: null | Error,
        entries?: Chunk[],
        compilation?: Compilation
    ) => any
) => void;

method watch

watch: (watchOptions: WatchOptions, handler: RunCallback<Stats>) => Watching;

class ConcatenationScope

class ConcatenationScope {}

constructor

constructor(
    modulesMap: ModuleInfo[] | Map<Module, ModuleInfo>,
    currentModule: ConcatenatedModuleInfo
);

property DEFAULT_EXPORT

static DEFAULT_EXPORT: string;

property NAMESPACE_OBJECT_EXPORT

static NAMESPACE_OBJECT_EXPORT: string;

method createModuleReference

createModuleReference: (
    module: Module,
    __1: Partial<ModuleReferenceOptions>
) => string;

method isModuleInScope

isModuleInScope: (module: Module) => boolean;

method isModuleReference

static isModuleReference: (name: string) => boolean;

method matchModuleReference

static matchModuleReference: (
    name: string
) => null | (ModuleReferenceOptions & { index: number });

method registerExport

registerExport: (exportName: string, symbol: string) => void;

method registerNamespaceExport

registerNamespaceExport: (symbol: string) => void;

method registerRawExport

registerRawExport: (exportName: string, expression: string) => void;

class ContextExclusionPlugin

class ContextExclusionPlugin {}

constructor

constructor(negativeMatcher: RegExp);

property negativeMatcher

negativeMatcher: RegExp;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class ContextReplacementPlugin

class ContextReplacementPlugin {}

constructor

constructor(
    resourceRegExp: RegExp,
    newContentResource?: any,
    newContentRecursive?: any,
    newContentRegExp?: RegExp
);

property newContentCallback

newContentCallback: any;

property newContentCreateContextMap

newContentCreateContextMap: any;

property newContentRecursive

newContentRecursive: any;

property newContentRegExp

newContentRegExp?: RegExp;

property newContentResource

newContentResource: any;

property resourceRegExp

resourceRegExp: RegExp;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class DefinePlugin

class DefinePlugin {}

constructor

constructor(definitions: Record<string, CodeValue>);

Create a new define plugin

property definitions

definitions: Record<string, CodeValue>;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

method runtimeValue

static runtimeValue: (
    fn: (arg0: {
        module: NormalModule;
        key: string;
        readonly version: ValueCacheVersion;
    }) => CodeValuePrimitive,
    options?: true | string[] | RuntimeValueOptions
) => RuntimeValue;

class DelegatedPlugin

class DelegatedPlugin {}

constructor

constructor(options: Options);

property options

options: Options;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class Dependency

class Dependency {}

constructor

constructor();

property category

readonly category: string;

property disconnect

readonly disconnect: any;

property EXPORTS_OBJECT_REFERENCED

static EXPORTS_OBJECT_REFERENCED: string[][];

property loc

loc: DependencyLocation;

property module

module: any;

property NO_EXPORTS_REFERENCED

static NO_EXPORTS_REFERENCED: string[][];

property optional

optional: boolean;

property TRANSITIVE

static TRANSITIVE: Symbol;

property type

readonly type: string;

property weak

weak: boolean;

method couldAffectReferencingModule

couldAffectReferencingModule: () => boolean | typeof TRANSITIVE;

method createIgnoredModule

createIgnoredModule: (context: string) => null | Module;

method deserialize

deserialize: (__0: ObjectDeserializerContext) => void;

method getCondition

getCondition: (
    moduleGraph: ModuleGraph
) =>
    | false
    | ((arg0: ModuleGraphConnection, arg1: RuntimeSpec) => ConnectionState);

method getContext

getContext: () => undefined | string;

method getErrors

getErrors: (moduleGraph: ModuleGraph) => undefined | null | WebpackError[];

Returns errors

method getExports

getExports: (moduleGraph: ModuleGraph) => undefined | ExportsSpec;

Returns the exported names

method getModuleEvaluationSideEffectsState

getModuleEvaluationSideEffectsState: (
    moduleGraph: ModuleGraph
) => ConnectionState;

method getNumberOfIdOccurrences

getNumberOfIdOccurrences: () => number;

implement this method to allow the occurrence order plugin to count correctly

method getReference

getReference: (moduleGraph: ModuleGraph) => never;

Returns the referenced module and export

method getReferencedExports

getReferencedExports: (
    moduleGraph: ModuleGraph,
    runtime: RuntimeSpec
) => (string[] | ReferencedExport)[];

Returns list of exports referenced by this dependency

method getResourceIdentifier

getResourceIdentifier: () => null | string;

method getWarnings

getWarnings: (moduleGraph: ModuleGraph) => undefined | null | WebpackError[];

Returns warnings

method serialize

serialize: (__0: ObjectSerializerContext) => void;

method setLoc

setLoc: (
    startLine: number,
    startColumn: number,
    endLine: number,
    endColumn: number
) => void;

method updateHash

updateHash: (hash: Hash, context: UpdateHashContextDependency) => void;

Update the hash

class DllPlugin

class DllPlugin {}

constructor

constructor(options: DllPluginOptions);

property options

options: {
    entryOnly: boolean;
    context?: string;
    format?: boolean;
    name?: string;
    path: string;
    type?: string;
};

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class DllReferencePlugin

class DllReferencePlugin {}

constructor

constructor(options: DllReferencePluginOptions);

property options

options: DllReferencePluginOptions;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class DynamicEntryPlugin

class DynamicEntryPlugin {}

constructor

constructor(context: string, entry: () => Promise<EntryStaticNormalized>);

property context

context: string;

property entry

entry: () => Promise<EntryStaticNormalized>;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class EntryOptionPlugin

class EntryOptionPlugin {}

constructor

constructor();

method apply

apply: (compiler: Compiler) => void;

method applyEntryOption

static applyEntryOption: (
    compiler: Compiler,
    context: string,
    entry: EntryNormalized
) => void;

method entryDescriptionToOptions

static entryDescriptionToOptions: (
    compiler: Compiler,
    name: string,
    desc: EntryDescriptionNormalized
) => EntryOptions;

class EntryPlugin

class EntryPlugin {}

constructor

constructor(context: string, entry: string, options?: string | EntryOptions);

An entry plugin which will handle creation of the EntryDependency

property context

context: string;

property entry

entry: string;

property options

options: string | EntryOptions;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

method createDependency

static createDependency: (
    entry: string,
    options: string | EntryOptions
) => EntryDependency;

class EnvironmentPlugin

class EnvironmentPlugin {}

constructor

constructor(...keys: (string | string[] | Record<string, any>)[]);

property defaultValues

defaultValues: Record<string, any>;

property keys

keys: string[];

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class EvalDevToolModulePlugin

class EvalDevToolModulePlugin {}

constructor

constructor(options?: EvalDevToolModulePluginOptions);

property moduleFilenameTemplate

moduleFilenameTemplate: DevtoolModuleFilenameTemplate;

property namespace

namespace: string;

property sourceUrlComment

sourceUrlComment: string;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class EvalSourceMapDevToolPlugin

class EvalSourceMapDevToolPlugin {}

constructor

constructor(inputOptions: string | SourceMapDevToolPluginOptions);

property moduleFilenameTemplate

moduleFilenameTemplate: string | Function;

property namespace

namespace: string;

property options

options: SourceMapDevToolPluginOptions;

property sourceMapComment

sourceMapComment: string;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class ExternalModule

class ExternalModule extends Module {}

constructor

constructor(
    request: string | string[] | RequestRecord,
    type: string,
    userRequest: string,
    dependencyMeta?:
        | ImportDependencyMeta
        | CssImportDependencyMeta
        | AssetDependencyMeta
);

property dependencyMeta

dependencyMeta?:
    | ImportDependencyMeta
    | CssImportDependencyMeta
    | AssetDependencyMeta;

property externalType

externalType: string;

property request

request: string | string[] | Record<string, string | string[]>;

property userRequest

userRequest: string;

method restoreFromUnsafeCache

restoreFromUnsafeCache: (
    unsafeCacheData: object,
    normalModuleFactory: NormalModuleFactory
) => void;

restore unsafe cache data

class ExternalsPlugin

class ExternalsPlugin {}

constructor

constructor(type: string, externals: Externals);

property externals

externals: Externals;

property type

type?: string;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class Generator

class Generator {}

constructor

constructor();

method byType

static byType: (map: Record<string, Generator>) => ByTypeGenerator;

method generate

generate: (module: NormalModule, __1: GenerateContext) => null | Source;

method getConcatenationBailoutReason

getConcatenationBailoutReason: (
    module: NormalModule,
    context: ConcatenationBailoutReasonContext
) => undefined | string;

method getSize

getSize: (module: NormalModule, type?: string) => number;

method getTypes

getTypes: (module: NormalModule) => ReadonlySet<string>;

method updateHash

updateHash: (hash: Hash, __1: UpdateHashContextGenerator) => void;

class HotModuleReplacementPlugin

class HotModuleReplacementPlugin {}

constructor

constructor(options?: {});

property options

options: {};

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

method getParserHooks

static getParserHooks: (parser: JavascriptParser) => HMRJavascriptParserHooks;

class HotUpdateChunk

class HotUpdateChunk extends Chunk {}

constructor

constructor();

class IgnorePlugin

class IgnorePlugin {}

constructor

constructor(options: IgnorePluginOptions);

property options

options: IgnorePluginOptions;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

method checkIgnore

checkIgnore: (resolveData: ResolveData) => undefined | false;

Note that if "contextRegExp" is given, both the "resourceRegExp" and "contextRegExp" have to match.

class InitFragment

class InitFragment<GenerateContext> {}

constructor

constructor(
    content: string | Source,
    stage: number,
    position: number,
    key?: string,
    endContent?: string | Source
);

property content

content?: string | Source;

property endContent

endContent?: string | Source;

property key

key?: string;

property merge

merge: any;

property position

position: number;

property stage

stage: number;

property STAGE_ASYNC_BOUNDARY

static STAGE_ASYNC_BOUNDARY: number;

property STAGE_ASYNC_DEPENDENCIES

static STAGE_ASYNC_DEPENDENCIES: number;

property STAGE_ASYNC_HARMONY_IMPORTS

static STAGE_ASYNC_HARMONY_IMPORTS: number;

property STAGE_CONSTANTS

static STAGE_CONSTANTS: number;

property STAGE_HARMONY_EXPORTS

static STAGE_HARMONY_EXPORTS: number;

property STAGE_HARMONY_IMPORTS

static STAGE_HARMONY_IMPORTS: number;

property STAGE_PROVIDES

static STAGE_PROVIDES: number;

method addToSource

static addToSource: <Context, T>(
    source: Source,
    initFragments: InitFragment<T>[],
    context: Context
) => Source;

method deserialize

deserialize: (context: ObjectDeserializerContext) => void;

method getContent

getContent: (context: GenerateContext) => undefined | string | Source;

method getEndContent

getEndContent: (context: GenerateContext) => undefined | string | Source;

method serialize

serialize: (context: ObjectSerializerContext) => void;

class JavascriptModulesPlugin

class JavascriptModulesPlugin {}

constructor

constructor(options?: {});

property chunkHasJs

static chunkHasJs: (chunk: Chunk, chunkGraph: ChunkGraph) => boolean;

property options

options: {};

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

method getChunkFilenameTemplate

static getChunkFilenameTemplate: (
    chunk: Chunk,
    outputOptions: Output
) => TemplatePath;

method getCompilationHooks

static getCompilationHooks: (
    compilation: Compilation
) => CompilationHooksJavascriptModulesPlugin;

method getRenamedInlineModule

getRenamedInlineModule: (
    allModules: Module[],
    renderContext: MainRenderContext,
    inlinedModules: Set<Module>,
    chunkRenderContext: ChunkRenderContextJavascriptModulesPlugin,
    hooks: CompilationHooksJavascriptModulesPlugin,
    allStrict: undefined | boolean,
    hasChunkModules: boolean
) => false | Map<Module, Source>;

method renderBootstrap

renderBootstrap: (
    renderContext: RenderBootstrapContext,
    hooks: CompilationHooksJavascriptModulesPlugin
) => Bootstrap;

method renderChunk

renderChunk: (
    renderContext: RenderContextJavascriptModulesPlugin,
    hooks: CompilationHooksJavascriptModulesPlugin
) => Source;

method renderMain

renderMain: (
    renderContext: MainRenderContext,
    hooks: CompilationHooksJavascriptModulesPlugin,
    compilation: Compilation
) => Source;

method renderModule

renderModule: (
    module: Module,
    renderContext: ChunkRenderContextJavascriptModulesPlugin,
    hooks: CompilationHooksJavascriptModulesPlugin,
    factory: boolean
) => null | Source;

method renderRequire

renderRequire: (
    renderContext: RenderBootstrapContext,
    hooks: CompilationHooksJavascriptModulesPlugin
) => string;

method updateHashWithBootstrap

updateHashWithBootstrap: (
    hash: Hash,
    renderContext: RenderBootstrapContext,
    hooks: CompilationHooksJavascriptModulesPlugin
) => void;

class LibManifestPlugin

class LibManifestPlugin {}

constructor

constructor(options: LibManifestPluginOptions);

property options

options: LibManifestPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class LibraryTemplatePlugin

class LibraryTemplatePlugin {}

constructor

constructor(
    name: LibraryName,
    target: string,
    umdNamedDefine: boolean,
    auxiliaryComment: AuxiliaryComment,
    exportProperty: LibraryExport
);

property library

library: {
    type: string;
    name: LibraryName;
    umdNamedDefine: boolean;
    auxiliaryComment: AuxiliaryComment;
    export: LibraryExport;
};

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class LoaderOptionsPlugin

class LoaderOptionsPlugin {}

constructor

constructor(options?: LoaderOptionsPluginOptions & MatchObject);

property options

options: LoaderOptionsPluginOptions & MatchObject;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class LoaderTargetPlugin

class LoaderTargetPlugin {}

constructor

constructor(target: string);

property target

target: string;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class Module

class Module extends DependenciesBlock {}

constructor

constructor(type: string, context?: string, layer?: string);

property buildInfo

buildInfo?: BuildInfo;

property buildMeta

buildMeta?: BuildMeta;

property chunksIterable

readonly chunksIterable: Iterable<Chunk>;

property codeGenerationDependencies

codeGenerationDependencies?: Dependency[];

property context

context: string;

property debugId

debugId: number;

property depth

depth: number;

property errors

readonly errors: any;

property exportsArgument

readonly exportsArgument: string;

property factoryMeta

factoryMeta?: FactoryMeta;

property hasEqualsChunks

readonly hasEqualsChunks: any;

property hash

readonly hash: string;

property hot

hot: boolean;

property id

id: string | number;

property index

index: number;

property index2

index2: number;

property issuer

issuer?: Module;

property isUsed

readonly isUsed: any;

property layer

layer: string;

property moduleArgument

readonly moduleArgument: string;

property needId

needId: boolean;

property optimizationBailout

readonly optimizationBailout: (
    | string
    | ((requestShortener: RequestShortener) => string)
)[];

property optional

readonly optional: boolean;

property presentationalDependencies

presentationalDependencies?: Dependency[];

property profile

profile?: ModuleProfile;

property renderedHash

readonly renderedHash: string;

property resolveOptions

resolveOptions?: ResolveOptions;

property type

type: string;

property used

used: any;

property usedExports

readonly usedExports: boolean | SortableSet<string>;

property useSimpleSourceMap

useSimpleSourceMap: boolean;

property useSourceMap

useSourceMap: boolean;

property warnings

readonly warnings: any;

method addCacheDependencies

addCacheDependencies: (
    fileDependencies: LazySet<string>,
    contextDependencies: LazySet<string>,
    missingDependencies: LazySet<string>,
    buildDependencies: LazySet<string>
) => void;

method addChunk

addChunk: (chunk: Chunk) => boolean;

method addCodeGenerationDependency

addCodeGenerationDependency: (codeGenerationDependency: Dependency) => void;

method addError

addError: (error: WebpackError) => void;

method addPresentationalDependency

addPresentationalDependency: (presentationalDependency: Dependency) => void;

method addWarning

addWarning: (warning: WebpackError) => void;

method build

build: (
    options: WebpackOptionsNormalized,
    compilation: Compilation,
    resolver: ResolverWithOptions,
    fs: InputFileSystem,
    callback: (arg0?: WebpackError) => void
) => void;

method chunkCondition

chunkCondition: (chunk: Chunk, compilation: Compilation) => boolean;

method cleanupForCache

cleanupForCache: () => void;

Assuming this module is in the cache. Remove internal references to allow freeing some memory.

method clearWarningsAndErrors

clearWarningsAndErrors: () => void;

removes all warnings and errors

method codeGeneration

codeGeneration: (context: CodeGenerationContext) => CodeGenerationResult;

method getChunks

getChunks: () => Chunk[];

method getConcatenationBailoutReason

getConcatenationBailoutReason: (
    context: ConcatenationBailoutReasonContext
) => undefined | string;

method getErrors

getErrors: () => undefined | Iterable<WebpackError>;

method getExportsType

getExportsType: (
    moduleGraph: ModuleGraph,
    strict?: boolean
) => 'namespace' | 'default-only' | 'default-with-named' | 'dynamic';

method getNumberOfChunks

getNumberOfChunks: () => number;

method getNumberOfErrors

getNumberOfErrors: () => number;

method getNumberOfWarnings

getNumberOfWarnings: () => number;

method getSideEffectsConnectionState

getSideEffectsConnectionState: (moduleGraph: ModuleGraph) => ConnectionState;

method getSourceTypes

getSourceTypes: () => ReadonlySet<string>;

method getUnsafeCacheData

getUnsafeCacheData: () => UnsafeCacheData;

Module should be unsafe cached. Get data that's needed for that. This data will be passed to restoreFromUnsafeCache later.

method getWarnings

getWarnings: () => undefined | Iterable<WebpackError>;

method hasChunkCondition

hasChunkCondition: () => boolean;

method hasReasonForChunk

hasReasonForChunk: (
    chunk: Chunk,
    moduleGraph: ModuleGraph,
    chunkGraph: ChunkGraph
) => boolean;

method hasReasons

hasReasons: (moduleGraph: ModuleGraph, runtime: RuntimeSpec) => boolean;

method identifier

identifier: () => string;

method invalidateBuild

invalidateBuild: () => void;

method isAccessibleInChunk

isAccessibleInChunk: (
    chunkGraph: ChunkGraph,
    chunk: Chunk,
    ignoreChunk?: Chunk
) => boolean;

method isAccessibleInChunkGroup

isAccessibleInChunkGroup: (
    chunkGraph: ChunkGraph,
    chunkGroup: ChunkGroup,
    ignoreChunk?: Chunk
) => boolean;

method isEntryModule

isEntryModule: () => boolean;

method isInChunk

isInChunk: (chunk: Chunk) => boolean;

method isOptional

isOptional: (moduleGraph: ModuleGraph) => boolean;

method isProvided

isProvided: (exportName: string) => null | boolean;

method libIdent

libIdent: (options: LibIdentOptions) => null | string;

method nameForCondition

nameForCondition: () => null | string;

method needBuild

needBuild: (
    context: NeedBuildContext,
    callback: (arg0?: null | WebpackError, arg1?: boolean) => void
) => void;

method needRebuild

needRebuild: (
    fileTimestamps: Map<string, null | number>,
    contextTimestamps: Map<string, null | number>
) => boolean;

method originalSource

originalSource: () => null | Source;

method readableIdentifier

readableIdentifier: (requestShortener: RequestShortener) => string;

method removeChunk

removeChunk: (chunk: Chunk) => void;

method size

size: (type?: string) => number;

method source

source: (
    dependencyTemplates: DependencyTemplates,
    runtimeTemplate: RuntimeTemplate,
    type?: string
) => Source;

method updateCacheModule

updateCacheModule: (module: Module) => void;

Assuming this module is in the cache. Update the (cached) module with the fresh module from the factory. Usually updates internal references and properties.

class ModuleGraph

class ModuleGraph {}

constructor

constructor();

property ModuleGraphConnection

static ModuleGraphConnection: typeof ModuleGraphConnection;

method addExplanation

addExplanation: (dependency: Dependency, explanation: string) => void;

method addExtraReason

addExtraReason: (module: Module, explanation: string) => void;

method cached

cached: <T extends any[], V>(
    fn: (moduleGraph: ModuleGraph, ...args: T) => V,
    ...args: T
) => V;

method clearModuleGraphForModule

static clearModuleGraphForModule: (module: Module) => void;

method cloneModuleAttributes

cloneModuleAttributes: (sourceModule: Module, targetModule: Module) => void;

method copyOutgoingModuleConnections

copyOutgoingModuleConnections: (
    oldModule: Module,
    newModule: Module,
    filterConnection: (arg0: ModuleGraphConnection) => boolean
) => void;

method dependencyCacheProvide

dependencyCacheProvide: (dependency: Dependency, ...args: any[]) => any;

method freeze

freeze: (cacheStage?: string) => void;

method getConnection

getConnection: (dependency: Dependency) => undefined | ModuleGraphConnection;

method getDepth

getDepth: (module: Module) => null | number;

method getExportInfo

getExportInfo: (module: Module, exportName: string) => ExportInfo;

method getExportsInfo

getExportsInfo: (module: Module) => ExportsInfo;

method getIncomingConnections

getIncomingConnections: (module: Module) => Iterable<ModuleGraphConnection>;

method getIncomingConnectionsByOriginModule

getIncomingConnectionsByOriginModule: (
    module: Module
) => Map<undefined | null | Module, ReadonlyArray<ModuleGraphConnection>>;

method getIssuer

getIssuer: (module: Module) => undefined | null | Module;

method getMeta

getMeta: (thing?: any) => object;

method getMetaIfExisting

getMetaIfExisting: (thing?: any) => undefined | object;

method getModule

getModule: (dependency: Dependency) => null | Module;

method getModuleGraphForModule

static getModuleGraphForModule: (
    module: Module,
    deprecateMessage: string,
    deprecationCode: string
) => ModuleGraph;

method getOptimizationBailout

getOptimizationBailout: (
    module: Module
) => (string | ((requestShortener: RequestShortener) => string))[];

method getOrigin

getOrigin: (dependency: Dependency) => null | Module;

method getOutgoingConnections

getOutgoingConnections: (module: Module) => Iterable<ModuleGraphConnection>;

method getOutgoingConnectionsByModule

getOutgoingConnectionsByModule: (
    module: Module
) => undefined | Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;

method getParentBlock

getParentBlock: (dependency: Dependency) => undefined | DependenciesBlock;

method getParentBlockIndex

getParentBlockIndex: (dependency: Dependency) => number;

method getParentModule

getParentModule: (dependency: Dependency) => undefined | Module;

method getPostOrderIndex

getPostOrderIndex: (module: Module) => null | number;

method getPreOrderIndex

getPreOrderIndex: (module: Module) => null | number;

method getProfile

getProfile: (module: Module) => undefined | ModuleProfile;

method getProvidedExports

getProvidedExports: (module: Module) => null | true | string[];

method getReadOnlyExportInfo

getReadOnlyExportInfo: (module: Module, exportName: string) => ExportInfo;

method getResolvedModule

getResolvedModule: (dependency: Dependency) => null | Module;

method getResolvedOrigin

getResolvedOrigin: (dependency: Dependency) => null | Module;

method getUsedExports

getUsedExports: (
    module: Module,
    runtime: RuntimeSpec
) => null | boolean | SortableSet<string>;

method isAsync

isAsync: (module: Module) => boolean;

method isExportProvided

isExportProvided: (
    module: Module,
    exportName: string | string[]
) => null | boolean;

method moveModuleConnections

moveModuleConnections: (
    oldModule: Module,
    newModule: Module,
    filterConnection: (arg0: ModuleGraphConnection) => boolean
) => void;

method removeAllModuleAttributes

removeAllModuleAttributes: () => void;

method removeConnection

removeConnection: (dependency: Dependency) => void;

method removeModuleAttributes

removeModuleAttributes: (module: Module) => void;

method setAsync

setAsync: (module: Module) => void;

method setDepth

setDepth: (module: Module, depth: number) => void;

method setDepthIfLower

setDepthIfLower: (module: Module, depth: number) => boolean;

method setIssuer

setIssuer: (module: Module, issuer: null | Module) => void;

method setIssuerIfUnset

setIssuerIfUnset: (module: Module, issuer: null | Module) => void;

method setModuleGraphForModule

static setModuleGraphForModule: (
    module: Module,
    moduleGraph: ModuleGraph
) => void;

method setModuleMemCaches

setModuleMemCaches: (
    moduleMemCaches: Map<Module, WeakTupleMap<any, any>>
) => void;

method setParents

setParents: (
    dependency: Dependency,
    block: DependenciesBlock,
    module: Module,
    indexInBlock?: number
) => void;

method setPostOrderIndex

setPostOrderIndex: (module: Module, index: number) => void;

method setPostOrderIndexIfUnset

setPostOrderIndexIfUnset: (module: Module, index: number) => boolean;

method setPreOrderIndex

setPreOrderIndex: (module: Module, index: number) => void;

method setPreOrderIndexIfUnset

setPreOrderIndexIfUnset: (module: Module, index: number) => boolean;

method setProfile

setProfile: (module: Module, profile?: ModuleProfile) => void;

method setResolvedModule

setResolvedModule: (
    originModule: null | Module,
    dependency: Dependency,
    module: Module
) => void;

method unfreeze

unfreeze: () => void;

method updateModule

updateModule: (dependency: Dependency, module: Module) => void;

class ModuleGraphConnection

class ModuleGraphConnection {}

constructor

constructor(
    originModule: Module,
    dependency: Dependency,
    module: Module,
    explanation?: string,
    weak?: boolean,
    condition?:
        | false
        | ((arg0: ModuleGraphConnection, arg1: RuntimeSpec) => ConnectionState)
);

property active

active: void;

property addConnectionStates

static addConnectionStates: (
    a: ConnectionState,
    b: ConnectionState
) => ConnectionState;

property CIRCULAR_CONNECTION

static CIRCULAR_CONNECTION: Symbol;

property condition

condition?: (arg0: ModuleGraphConnection, arg1: RuntimeSpec) => ConnectionState;

property conditional

conditional: boolean;

property dependency

dependency: Dependency;

property explanation

readonly explanation: string;

property explanations

explanations?: Set<string>;

property module

module: Module;

property originModule

originModule: Module;

property resolvedModule

resolvedModule: Module;

property resolvedOriginModule

resolvedOriginModule: Module;

property TRANSITIVE_ONLY

static TRANSITIVE_ONLY: Symbol;

property weak

weak: boolean;

method addCondition

addCondition: (
    condition: (
        arg0: ModuleGraphConnection,
        arg1: RuntimeSpec
    ) => ConnectionState
) => void;

method addExplanation

addExplanation: (explanation: string) => void;

method clone

clone: () => ModuleGraphConnection;

method getActiveState

getActiveState: (runtime: RuntimeSpec) => ConnectionState;

method isActive

isActive: (runtime: RuntimeSpec) => boolean;

method isTargetActive

isTargetActive: (runtime: RuntimeSpec) => boolean;

method setActive

setActive: (value: boolean) => void;

class MultiCompiler

class MultiCompiler {}

constructor

constructor(
    compilers: Compiler[] | Record<string, Compiler>,
    options: MultiCompilerOptions
);

property compilers

compilers: Compiler[];

property dependencies

dependencies: WeakMap<Compiler, string[]>;

property hooks

hooks: Readonly<{
    done: SyncHook<[MultiStats]>;
    invalid: MultiHook<SyncHook<[string, number]>>;
    run: MultiHook<AsyncSeriesHook<[Compiler]>>;
    watchClose: SyncHook<[]>;
    watchRun: MultiHook<AsyncSeriesHook<[Compiler]>>;
    infrastructureLog: MultiHook<SyncBailHook<[string, string, any[]], true>>;
}>;

property inputFileSystem

inputFileSystem: InputFileSystem;

property intermediateFileSystem

intermediateFileSystem: IntermediateFileSystem;

property options

readonly options: WebpackOptionsNormalized[] & MultiCompilerOptions;

property outputFileSystem

outputFileSystem: OutputFileSystem;

property outputPath

readonly outputPath: string;

property running

running: boolean;

property watchFileSystem

watchFileSystem: WatchFileSystem;

method close

close: (callback: CallbackFunction_1<void>) => void;

method getInfrastructureLogger

getInfrastructureLogger: (name: string | (() => string)) => WebpackLogger;

method purgeInputFileSystem

purgeInputFileSystem: () => void;

method run

run: (callback: CallbackFunction_1<MultiStats>) => void;

method runWithDependencies

runWithDependencies: (
    compilers: Compiler[],
    fn: (compiler: Compiler, callback: CallbackFunction_1<MultiStats>) => any,
    callback: CallbackFunction_1<MultiStats>
) => void;

method setDependencies

setDependencies: (compiler: Compiler, dependencies: string[]) => void;

method validateDependencies

validateDependencies: (callback: CallbackFunction_1<MultiStats>) => boolean;

method watch

watch: (
    watchOptions: WatchOptions | WatchOptions[],
    handler: CallbackFunction_1<MultiStats>
) => MultiWatching;

class MultiStats

abstract class MultiStats {}

property hash

readonly hash: string;

property stats

stats: Stats[];

method hasErrors

hasErrors: () => boolean;

method hasWarnings

hasWarnings: () => boolean;

method toJson

toJson: (options?: string | boolean | StatsOptions) => StatsCompilation;

method toString

toString: (options?: string | boolean | StatsOptions) => string;

class NoEmitOnErrorsPlugin

class NoEmitOnErrorsPlugin {}

constructor

constructor();

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class NormalModule

class NormalModule extends Module {}

constructor

constructor(__0: NormalModuleCreateData);

property binary

binary: boolean;

property error

error: WebpackError;

property generator

generator?: Generator;

property generatorOptions

generatorOptions?: GeneratorOptions;

property loaders

loaders: LoaderItem[];

property matchResource

matchResource?: string;

property parser

parser?: Parser;

property parserOptions

parserOptions?: ParserOptions;

property rawRequest

rawRequest: string;

property request

request: string;

property resource

resource: string;

property resourceResolveData

resourceResolveData?: Record<string, any>;

property userRequest

userRequest: string;

method applyNoParseRule

applyNoParseRule: (rule: any, content: string) => boolean;

method createSource

createSource: (
    context: string,
    content: string | Buffer,
    sourceMap?: null | string | SourceMapSource,
    associatedObjectForCache?: object
) => Source;

method createSourceForAsset

createSourceForAsset: (
    context: string,
    name: string,
    content: string | Buffer,
    sourceMap?: string | SourceMap,
    associatedObjectForCache?: object
) => Source;

method deserialize

static deserialize: (context: ObjectDeserializerContext) => any;

method getCompilationHooks

static getCompilationHooks: (
    compilation: Compilation
) => NormalModuleCompilationHooks;

method getCurrentLoader

getCurrentLoader: (loaderContext?: any, index?: number) => null | LoaderItem;

method markModuleAsErrored

markModuleAsErrored: (error: WebpackError) => void;

method restoreFromUnsafeCache

restoreFromUnsafeCache: (
    unsafeCacheData: NormalModuleUnsafeCacheData,
    normalModuleFactory: NormalModuleFactory
) => void;

restore unsafe cache data

method shouldPreventParsing

shouldPreventParsing: (noParseRule: any, request: string) => boolean;

class NormalModuleReplacementPlugin

class NormalModuleReplacementPlugin {}

constructor

constructor(
    resourceRegExp: RegExp,
    newResource: string | ((arg0: ResolveData) => void)
);

Create an instance of the plugin

property newResource

newResource: string | ((arg0: ResolveData) => void);

property resourceRegExp

resourceRegExp: RegExp;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class Parser

class Parser {}

constructor

constructor();

method parse

parse: (
    source: string | Buffer | PreparsedAst,
    state: ParserState
) => ParserState;

class PlatformPlugin

class PlatformPlugin {}

constructor

constructor(platform: Partial<PlatformTargetProperties>);

property platform

platform: Partial<PlatformTargetProperties>;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class PrefetchPlugin

class PrefetchPlugin {}

constructor

constructor(context: string, request?: string);

property context

context: string;

property request

request: string;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class ProgressPlugin

class ProgressPlugin {}

constructor

constructor(options?: ProgressPluginArgument);

property createDefaultHandler

static createDefaultHandler: (
    profile: undefined | null | boolean,
    logger: WebpackLogger
) => (percentage: number, msg: string, ...args: string[]) => void;

property defaultOptions

static defaultOptions: {
    profile: boolean;
    modulesCount: number;
    dependenciesCount: number;
    modules: boolean;
    dependencies: boolean;
    activeModules: boolean;
    entries: boolean;
};

property dependenciesCount

dependenciesCount?: number;

property handler

handler?: (percentage: number, msg: string, ...args: string[]) => void;

property modulesCount

modulesCount?: number;

property percentBy

percentBy?: 'modules' | 'entries' | 'dependencies';

property profile

profile?: boolean;

property showActiveModules

showActiveModules?: boolean;

property showDependencies

showDependencies?: boolean;

property showEntries

showEntries?: boolean;

property showModules

showModules?: boolean;

method apply

apply: (compiler: Compiler | MultiCompiler) => void;

method getReporter

static getReporter: (
    compiler: Compiler
) => (p: number, ...args: string[]) => void;

class ProvidePlugin

class ProvidePlugin {}

constructor

constructor(definitions: Record<string, string | string[]>);

property definitions

definitions: Record<string, string | string[]>;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class Resolver

abstract class Resolver {}

property fileSystem

fileSystem: FileSystem;

property hooks

hooks: KnownHooks;

property options

options: ResolveOptionsResolverFactoryObject1;

method doResolve

doResolve: (
    hook: AsyncSeriesBailHook<[ResolveRequest, ResolveContext], ResolveRequest>,
    request: ResolveRequest,
    message: null | string,
    resolveContext: ResolveContext,
    callback: (err?: null | Error, result?: ResolveRequest) => void
) => void;

method ensureHook

ensureHook: (
    name:
        | string
        | AsyncSeriesBailHook<
              [ResolveRequest, ResolveContext],
              null | ResolveRequest
          >
) => AsyncSeriesBailHook<[ResolveRequest, ResolveContext], ResolveRequest>;

method getHook

getHook: (
    name:
        | string
        | AsyncSeriesBailHook<
              [ResolveRequest, ResolveContext],
              null | ResolveRequest
          >
) => AsyncSeriesBailHook<[ResolveRequest, ResolveContext], ResolveRequest>;

method isDirectory

isDirectory: (path: string) => boolean;

method isModule

isModule: (path: string) => boolean;

method isPrivate

isPrivate: (path: string) => boolean;

method join

join: (path: string, request: string) => string;

method normalize

normalize: (path: string) => string;

method parse

parse: (identifier: string) => ParsedIdentifier;

method resolve

resolve: (
    context: object,
    path: string,
    request: string,
    resolveContext: ResolveContext,
    callback: (
        err: null | ErrorWithDetail,
        res?: string | false,
        req?: ResolveRequest
    ) => void
) => void;

method resolveSync

resolveSync: (context: object, path: string, request: string) => string | false;

class RuntimeModule

class RuntimeModule extends Module {}

constructor

constructor(name: string, stage?: number);

property chunk

chunk?: Chunk;

property chunkGraph

chunkGraph?: ChunkGraph;

property compilation

compilation?: Compilation;

property dependentHash

dependentHash: boolean;

property fullHash

fullHash: boolean;

property name

name: string;

property stage

stage: number;

property STAGE_ATTACH

static STAGE_ATTACH: number;

Runtime modules which attach to handlers of other runtime modules

property STAGE_BASIC

static STAGE_BASIC: number;

Runtime modules with simple dependencies on other runtime modules

property STAGE_NORMAL

static STAGE_NORMAL: number;

Runtime modules without any dependencies to other runtime modules

property STAGE_TRIGGER

static STAGE_TRIGGER: number;

Runtime modules which trigger actions on bootstrap

method attach

attach: (
    compilation: Compilation,
    chunk: Chunk,
    chunkGraph?: ChunkGraph
) => void;

method generate

generate: () => null | string;

method getGeneratedCode

getGeneratedCode: () => null | string;

method shouldIsolate

shouldIsolate: () => boolean;

class SingleEntryPlugin

class EntryPlugin {}

constructor

constructor(context: string, entry: string, options?: string | EntryOptions);

An entry plugin which will handle creation of the EntryDependency

property context

context: string;

property entry

entry: string;

property options

options: string | EntryOptions;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

method createDependency

static createDependency: (
    entry: string,
    options: string | EntryOptions
) => EntryDependency;

class SourceMapDevToolPlugin

class SourceMapDevToolPlugin {}

constructor

constructor(options?: SourceMapDevToolPluginOptions);

property fallbackModuleFilenameTemplate

fallbackModuleFilenameTemplate: string | Function;

property moduleFilenameTemplate

moduleFilenameTemplate: string | Function;

property namespace

namespace: string;

property options

options: SourceMapDevToolPluginOptions;

property sourceMapFilename

sourceMapFilename: string | false;

property sourceMappingURLComment

sourceMappingURLComment:
    | string
    | false
    | ((arg0: PathData, arg1?: AssetInfo) => string);

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class Stats

class Stats {}

constructor

constructor(compilation: Compilation);

property compilation

compilation: Compilation;

property endTime

readonly endTime: number;

property hash

readonly hash: string;

property startTime

readonly startTime: number;

method hasErrors

hasErrors: () => boolean;

method hasWarnings

hasWarnings: () => boolean;

method toJson

toJson: (options?: string | boolean | StatsOptions) => StatsCompilation;

method toString

toString: (options?: string | boolean | StatsOptions) => string;

class Template

class Template {}

constructor

constructor();

property NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS

static NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS: number;

property NUMBER_OF_IDENTIFIER_START_CHARS

static NUMBER_OF_IDENTIFIER_START_CHARS: number;

method asString

static asString: (str: string | string[]) => string;

method getFunctionContent

static getFunctionContent: (fn: Function) => string;

method getModulesArrayBounds

static getModulesArrayBounds: (modules: WithId[]) => false | [number, number];

method indent

static indent: (s: string | string[]) => string;

method numberToIdentifier

static numberToIdentifier: (n: number) => string;

method numberToIdentifierContinuation

static numberToIdentifierContinuation: (n: number) => string;

method prefix

static prefix: (s: string | string[], prefix: string) => string;

method renderChunkModules

static renderChunkModules: (
    renderContext: ChunkRenderContextJavascriptModulesPlugin,
    modules: Module[],
    renderModule: (arg0: Module) => null | Source,
    prefix?: string
) => null | Source;

method renderChunkRuntimeModules

static renderChunkRuntimeModules: (
    runtimeModules: RuntimeModule[],
    renderContext: RenderContextJavascriptModulesPlugin
) => Source;

method renderRuntimeModules

static renderRuntimeModules: (
    runtimeModules: RuntimeModule[],
    renderContext: RenderContextJavascriptModulesPlugin & {
        codeGenerationResults?: CodeGenerationResults;
    }
) => Source;

method toComment

static toComment: (str: string) => string;

method toIdentifier

static toIdentifier: (str: string) => string;

method toNormalComment

static toNormalComment: (str: string) => string;

method toPath

static toPath: (str: string) => string;

class WatchIgnorePlugin

class WatchIgnorePlugin {}

constructor

constructor(options: WatchIgnorePluginOptions);

property paths

paths: (string | RegExp)[];

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class Watching

abstract class Watching {}

property blocked

blocked: boolean;

property callbacks

callbacks: CallbackFunction_1<void>[];

property closed

closed: boolean;

property compiler

compiler: Compiler;

property handler

handler: CallbackFunction_1<Stats>;

property invalid

invalid: boolean;

property lastWatcherStartTime

lastWatcherStartTime?: number;

property pausedWatcher

pausedWatcher?: Watcher;

property running

running: boolean;

property startTime

startTime: number;

property suspended

suspended: boolean;

property watcher

watcher?: Watcher;

property watchOptions

watchOptions: WatchOptions;

method close

close: (callback: CallbackFunction_1<void>) => void;

method invalidate

invalidate: (callback?: CallbackFunction_1<void>) => void;

method resume

resume: () => void;

method suspend

suspend: () => void;

method watch

watch: (
    files: Iterable<string>,
    dirs: Iterable<string>,
    missing: Iterable<string>
) => void;

class WebpackError

class WebpackError extends Error {}

constructor

constructor(message?: string);

Creates an instance of WebpackError.

property chunk

chunk?: Chunk;

property details

details?: string;

property file

file?: string;

property hideStack

hideStack?: boolean;

property loc

loc?: SyntheticDependencyLocation | RealDependencyLocation;

property module

module?: Module;

property prepareStackTrace

static prepareStackTrace?: (err: Error, stackTraces: NodeJS.CallSite[]) => any;

Optional override for formatting stack traces

property stackTraceLimit

static stackTraceLimit: number;

method captureStackTrace

static captureStackTrace: (
    targetObject: object,
    constructorOpt?: Function
) => void;

Create .stack property on a target object

method deserialize

deserialize: (__0: ObjectDeserializerContext) => void;

method serialize

serialize: (__0: ObjectSerializerContext) => void;

class WebpackOptionsApply

class WebpackOptionsApply extends OptionsApply {}

constructor

constructor();

class WebpackOptionsDefaulter

class WebpackOptionsDefaulter {}

constructor

constructor();

method process

process: (options: Configuration) => WebpackOptionsNormalized;

Interfaces

interface Argument

interface Argument {}

property configs

configs: ArgumentConfig[];

property description

description?: string;

property multiple

multiple: boolean;

property simpleType

simpleType: SimpleType;

interface Asset

interface Asset {}

property info

info: AssetInfo;

info about the asset

property name

name: string;

the filename of the asset

property source

source: Source;

source of the asset

interface AssetEmittedInfo

interface AssetEmittedInfo {}

property compilation

compilation: Compilation;

property content

content: Buffer;

property outputPath

outputPath: string;

property source

source: Source;

property targetPath

targetPath: string;

interface Configuration

interface Configuration {}

Options object as provided by the user.

property amd

amd?: false | { [index: string]: any };

Set the value of require.amd and define.amd. Or disable AMD support.

property bail

bail?: boolean;

Report the first error as a hard error instead of tolerating it.

property cache

cache?: boolean | FileCacheOptions | MemoryCacheOptions;

Cache generated modules and chunks to improve performance for multiple incremental builds.

property context

context?: string;

The base directory (absolute path!) for resolving the entry option. If output.pathinfo is set, the included pathinfo is shortened to this directory.

property dependencies

dependencies?: string[];

References to other configurations to depend on.

property devtool

devtool?: string | false;

A developer tool to enhance debugging (false | eval | [inline-|hidden-|eval-][nosources-][cheap-[module-]]source-map).

property entry

entry?:
    | string
    | (() => string | EntryObject | string[] | Promise<EntryStatic>)
    | EntryObject
    | string[];

The entry point(s) of the compilation.

property experiments

experiments?: Experiments;

Enables/Disables experiments (experimental features with relax SemVer compatibility).

property extends

extends?: string | string[];

Extend configuration from another configuration (only works when using webpack-cli).

property externals

externals?:
    | string
    | RegExp
    | ExternalItem[]
    | (ExternalItemObjectKnown & ExternalItemObjectUnknown)
    | ((
          data: ExternalItemFunctionData,
          callback: (
              err?: null | Error,
              result?: string | boolean | string[] | { [index: string]: any }
          ) => void
      ) => void)
    | ((data: ExternalItemFunctionData) => Promise<ExternalItemValue>);

Specify dependencies that shouldn't be resolved by webpack, but should become dependencies of the resulting bundle. The kind of the dependency depends on output.libraryTarget.

property externalsPresets

externalsPresets?: ExternalsPresets;

Enable presets of externals for specific targets.

property externalsType

externalsType?:
    | 'import'
    | 'var'
    | 'module'
    | 'assign'
    | 'this'
    | 'window'
    | 'self'
    | 'global'
    | 'commonjs'
    | 'commonjs2'
    | 'commonjs-module'
    | 'commonjs-static'
    | 'amd'
    | 'amd-require'
    | 'umd'
    | 'umd2'
    | 'jsonp'
    | 'system'
    | 'promise'
    | 'module-import'
    | 'script'
    | 'node-commonjs';

Specifies the default type of externals ('amd*', 'umd*', 'system' and 'jsonp' depend on output.libraryTarget set to the same value).

property ignoreWarnings

ignoreWarnings?: (
    | RegExp
    | {
          /**
           * A RegExp to select the origin file for the warning.
           */
          file?: RegExp;
          /**
           * A RegExp to select the warning message.
           */
          message?: RegExp;
          /**
           * A RegExp to select the origin module for the warning.
           */
          module?: RegExp;
      }
    | ((warning: WebpackError, compilation: Compilation) => boolean)
)[];

Ignore specific warnings.

property infrastructureLogging

infrastructureLogging?: InfrastructureLogging;

Options for infrastructure level logging.

property loader

loader?: Loader;

Custom values available in the loader context.

property mode

mode?: 'none' | 'development' | 'production';

Enable production optimizations or development hints.

property module

module?: ModuleOptions;

Options affecting the normal modules (NormalModuleFactory).

property name

name?: string;

Name of the configuration. Used when loading multiple configurations.

property node

node?: false | NodeOptions;

Include polyfills or mocks for various node stuff.

property optimization

optimization?: Optimization;

Enables/Disables integrated optimizations.

property output

output?: Output;

Options affecting the output of the compilation. output options tell webpack how to write the compiled files to disk.

property parallelism

parallelism?: number;

The number of parallel processed modules in the compilation.

property performance

performance?: false | PerformanceOptions;

Configuration for web performance recommendations.

property plugins

plugins?: (
    | undefined
    | null
    | false
    | ''
    | 0
    | ((this: Compiler, compiler: Compiler) => void)
    | WebpackPluginInstance
)[];

Add additional plugins to the compiler.

property profile

profile?: boolean;

Capture timing information for each module.

property recordsInputPath

recordsInputPath?: string | false;

Store compiler state to a json file.

property recordsOutputPath

recordsOutputPath?: string | false;

Load compiler state from a json file.

property recordsPath

recordsPath?: string | false;

Store/Load compiler state from/to a json file. This will result in persistent ids of modules and chunks. An absolute path is expected. recordsPath is used for recordsInputPath and recordsOutputPath if they left undefined.

property resolve

resolve?: ResolveOptions;

Options for the resolver.

property resolveLoader

resolveLoader?: ResolveOptions;

Options for the resolver when resolving loaders.

property snapshot

snapshot?: SnapshotOptionsWebpackOptions;

Options affecting how file system snapshots are created and validated.

property stats

stats?:
    | boolean
    | StatsOptions
    | 'none'
    | 'verbose'
    | 'summary'
    | 'errors-only'
    | 'errors-warnings'
    | 'minimal'
    | 'normal'
    | 'detailed';

Stats options object or preset name.

property target

target?: string | false | string[];

Environment to build for. An array of environments to build for all of them when possible.

property watch

watch?: boolean;

Enter watch mode, which rebuilds on file change.

property watchOptions

watchOptions?: WatchOptions;

Options for the watcher.

interface EntryObject

interface EntryObject {}

Multiple entry bundles are created. The key is the entry name. The value can be a string, an array or an entry description object.

index signature

[index: string]: string | string[] | EntryDescription;

interface ExternalItemFunctionData

interface ExternalItemFunctionData {}

Data object passed as argument when a function is set for 'externals'.

property context

context?: string;

The directory in which the request is placed.

property contextInfo

contextInfo?: ModuleFactoryCreateDataContextInfo;

Contextual information.

property dependencyType

dependencyType?: string;

The category of the referencing dependencies.

property getResolve

getResolve?: (
    options?: ResolveOptions
) =>
    | ((
          context: string,
          request: string,
          callback: (err?: Error, result?: string) => void
      ) => void)
    | ((context: string, request: string) => Promise<string>);

Get a resolve function with the current resolver options.

property request

request?: string;

The request as written by the user in the require/import expression/statement.

interface ExternalItemObjectKnown

interface ExternalItemObjectKnown {}

If an dependency matches exactly a property of the object, the property value is used as dependency.

property byLayer

byLayer?:
    | { [index: string]: ExternalItem }
    | ((layer: null | string) => ExternalItem);

Specify externals depending on the layer.

interface ExternalItemObjectUnknown

interface ExternalItemObjectUnknown {}

If an dependency matches exactly a property of the object, the property value is used as dependency.

index signature

[index: string]: ExternalItemValue;

interface FileCacheOptions

interface FileCacheOptions {}

Options object for persistent file-based caching.

property allowCollectingMemory

allowCollectingMemory?: boolean;

Allows to collect unused memory allocated during deserialization. This requires copying data into smaller buffers and has a performance cost.

property buildDependencies

buildDependencies?: { [index: string]: string[] };

Dependencies the build depends on (in multiple categories, default categories: 'defaultWebpack').

property cacheDirectory

cacheDirectory?: string;

Base directory for the cache (defaults to node_modules/.cache/webpack).

property cacheLocation

cacheLocation?: string;

Locations for the cache (defaults to cacheDirectory / name).

property compression

compression?: false | 'gzip' | 'brotli';

Compression type used for the cache files.

property hashAlgorithm

hashAlgorithm?: string;

Algorithm used for generation the hash (see node.js crypto package).

property idleTimeout

idleTimeout?: number;

Time in ms after which idle period the cache storing should happen.

property idleTimeoutAfterLargeChanges

idleTimeoutAfterLargeChanges?: number;

Time in ms after which idle period the cache storing should happen when larger changes has been detected (cumulative build time > 2 x avg cache store time).

property idleTimeoutForInitialStore

idleTimeoutForInitialStore?: number;

Time in ms after which idle period the initial cache storing should happen.

property immutablePaths

immutablePaths?: (string | RegExp)[];

List of paths that are managed by a package manager and contain a version or hash in its path so all files are immutable.

property managedPaths

managedPaths?: (string | RegExp)[];

List of paths that are managed by a package manager and can be trusted to not be modified otherwise.

property maxAge

maxAge?: number;

Time for which unused cache entries stay in the filesystem cache at minimum (in milliseconds).

property maxMemoryGenerations

maxMemoryGenerations?: number;

Number of generations unused cache entries stay in memory cache at minimum (0 = no memory cache used, 1 = may be removed after unused for a single compilation, ..., Infinity: kept forever). Cache entries will be deserialized from disk when removed from memory cache.

property memoryCacheUnaffected

memoryCacheUnaffected?: boolean;

Additionally cache computation of modules that are unchanged and reference only unchanged modules in memory.

property name

name?: string;

Name for the cache. Different names will lead to different coexisting caches.

property profile

profile?: boolean;

Track and log detailed timing information for individual cache items.

property readonly

readonly?: boolean;

Enable/disable readonly mode.

property store

store?: 'pack';

When to store data to the filesystem. (pack: Store data when compiler is idle in a single file).

property type

type: 'filesystem';

Filesystem caching.

property version

version?: string;

Version of the cache data. Different versions won't allow to reuse the cache and override existing content. Update the version when config changed in a way which doesn't allow to reuse cache. This will invalidate the cache.

interface InputFileSystem

interface InputFileSystem {}

property dirname

dirname?: (arg0: string) => string;

property join

join?: (arg0: string, arg1: string) => string;

property lstat

lstat?: LStatFs;

property lstatSync

lstatSync?: LStatSync;

property purge

purge?: (arg0?: string | string[] | Set<string>) => void;

property readdir

readdir: ReaddirFs;

property readdirSync

readdirSync?: ReaddirSync;

property readFile

readFile: ReadFileFs;

property readFileSync

readFileSync?: ReadFileSync;

property readJson

readJson?: (
    arg0: PathOrFileDescriptorFs,
    arg1: (
        arg0: null | Error | NodeJS.ErrnoException,
        arg1?: JsonObjectFs
    ) => void
) => void;

property readJsonSync

readJsonSync?: (arg0: PathOrFileDescriptorFs) => JsonObjectFs;

property readlink

readlink: ReadlinkFs;

property readlinkSync

readlinkSync?: ReadlinkSync;

property realpath

realpath?: RealPathFs;

property realpathSync

realpathSync?: RealPathSync;

property relative

relative?: (arg0: string, arg1: string) => string;

property stat

stat: StatFs;

property statSync

statSync?: StatSync;

interface LibraryOptions

interface LibraryOptions {}

Options for library.

property amdContainer

amdContainer?: string;

Add a container for define/require functions in the AMD module.

property auxiliaryComment

auxiliaryComment?: string | LibraryCustomUmdCommentObject;

Add a comment in the UMD wrapper.

property export

export?: string | string[];

Specify which export should be exposed as library.

property name

name?: string | string[] | LibraryCustomUmdObject;

The name of the library (some types allow unnamed libraries too).

property type

type: string;

Type of library (types included by default are 'var', 'module', 'assign', 'assign-properties', 'this', 'window', 'self', 'global', 'commonjs', 'commonjs2', 'commonjs-module', 'commonjs-static', 'amd', 'amd-require', 'umd', 'umd2', 'jsonp', 'system', but others might be added by plugins).

property umdNamedDefine

umdNamedDefine?: boolean;

If output.libraryTarget is set to umd and output.library is set, setting this to true will name the AMD module.

interface LoaderDefinitionFunction

interface LoaderDefinitionFunction<OptionsType = {}, ContextAdditions = {}> {}

call signature

(
    this: NormalModuleLoaderContext<OptionsType> &
        LoaderRunnerLoaderContext<OptionsType> &
        LoaderPluginLoaderContext &
        HotModuleReplacementPluginLoaderContext &
        ContextAdditions,
    content: string,
    sourceMap?: string | SourceMap,
    additionalData?: AdditionalData
): string | void | Buffer | Promise<string | Buffer>;

interface LoaderModule

interface LoaderModule<OptionsType = {}, ContextAdditions = {}> {}

property default

default?:
    | RawLoaderDefinitionFunction<OptionsType, ContextAdditions>
    | LoaderDefinitionFunction<OptionsType, ContextAdditions>;

property pitch

pitch?: PitchLoaderDefinitionFunction<OptionsType, ContextAdditions>;

property raw

raw?: false;

interface MemoryCacheOptions

interface MemoryCacheOptions {}

Options object for in-memory caching.

property cacheUnaffected

cacheUnaffected?: boolean;

Additionally cache computation of modules that are unchanged and reference only unchanged modules.

property maxGenerations

maxGenerations?: number;

Number of generations unused cache entries stay in memory cache at minimum (1 = may be removed after unused for a single compilation, ..., Infinity: kept forever).

property type

type: 'memory';

In memory caching.

interface ModuleOptions

interface ModuleOptions {}

Options affecting the normal modules (NormalModuleFactory).

property defaultRules

defaultRules?: (undefined | null | false | '' | 0 | RuleSetRule | '...')[];

An array of rules applied by default for modules.

property exprContextCritical

exprContextCritical?: boolean;

Enable warnings for full dynamic dependencies.

property exprContextRecursive

exprContextRecursive?: boolean;

Enable recursive directory lookup for full dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.exprContextRecursive'.

property exprContextRegExp

exprContextRegExp?: boolean | RegExp;

Sets the default regular expression for full dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.exprContextRegExp'.

property exprContextRequest

exprContextRequest?: string;

Set the default request for full dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.exprContextRequest'.

property generator

generator?: GeneratorOptionsByModuleType;

Specify options for each generator.

property noParse

noParse?: string | Function | RegExp | (string | Function | RegExp)[];

Don't parse files matching. It's matched against the full resolved request.

property parser

parser?: ParserOptionsByModuleType;

Specify options for each parser.

property rules

rules?: (undefined | null | false | '' | 0 | RuleSetRule | '...')[];

An array of rules applied for modules.

property strictExportPresence

strictExportPresence?: boolean;

Emit errors instead of warnings when imported names don't exist in imported module. Deprecated: This option has moved to 'module.parser.javascript.strictExportPresence'.

property strictThisContextOnImports

strictThisContextOnImports?: boolean;

Handle the this context correctly according to the spec for namespace objects. Deprecated: This option has moved to 'module.parser.javascript.strictThisContextOnImports'.

property unknownContextCritical

unknownContextCritical?: boolean;

Enable warnings when using the require function in a not statically analyse-able way. Deprecated: This option has moved to 'module.parser.javascript.unknownContextCritical'.

property unknownContextRecursive

unknownContextRecursive?: boolean;

Enable recursive directory lookup when using the require function in a not statically analyse-able way. Deprecated: This option has moved to 'module.parser.javascript.unknownContextRecursive'.

property unknownContextRegExp

unknownContextRegExp?: boolean | RegExp;

Sets the regular expression when using the require function in a not statically analyse-able way. Deprecated: This option has moved to 'module.parser.javascript.unknownContextRegExp'.

property unknownContextRequest

unknownContextRequest?: string;

Sets the request when using the require function in a not statically analyse-able way. Deprecated: This option has moved to 'module.parser.javascript.unknownContextRequest'.

property unsafeCache

unsafeCache?: boolean | Function;

Cache the resolving of module requests.

property wrappedContextCritical

wrappedContextCritical?: boolean;

Enable warnings for partial dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.wrappedContextCritical'.

property wrappedContextRecursive

wrappedContextRecursive?: boolean;

Enable recursive directory lookup for partial dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.wrappedContextRecursive'.

property wrappedContextRegExp

wrappedContextRegExp?: RegExp;

Set the inner regular expression for partial dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.wrappedContextRegExp'.

interface MultiCompilerOptions

interface MultiCompilerOptions {}

property parallelism

parallelism?: number;

how many Compilers are allows to run at the same time in parallel

interface OutputFileSystem

interface OutputFileSystem {}

property dirname

dirname?: (arg0: string) => string;

property join

join?: (arg0: string, arg1: string) => string;

property lstat

lstat?: LStatFs;

property mkdir

mkdir: Mkdir;

property readdir

readdir?: ReaddirFs;

property readFile

readFile: ReadFileFs;

property relative

relative?: (arg0: string, arg1: string) => string;

property rmdir

rmdir?: Rmdir;

property stat

stat: StatFs;

property unlink

unlink?: (
    arg0: PathLikeFs,
    arg1: (arg0: null | NodeJS.ErrnoException) => void
) => void;

property writeFile

writeFile: WriteFile;

interface PathData

interface PathData {}

property basename

basename?: string;

property chunk

chunk?: Chunk | ChunkPathData;

property chunkGraph

chunkGraph?: ChunkGraph;

property contentHash

contentHash?: string;

property contentHashType

contentHashType?: string;

property contentHashWithLength

contentHashWithLength?: (arg0: number) => string;

property filename

filename?: string;

property hash

hash?: string;

property hashWithLength

hashWithLength?: (arg0: number) => string;

property module

module?: Module | ModulePathData;

property noChunkHash

noChunkHash?: boolean;

property query

query?: string;

property runtime

runtime?: RuntimeSpec;

property url

url?: string;

interface PitchLoaderDefinitionFunction

interface PitchLoaderDefinitionFunction<OptionsType = {}, ContextAdditions = {}> {}

call signature

(
    this: NormalModuleLoaderContext<OptionsType> &
        LoaderRunnerLoaderContext<OptionsType> &
        LoaderPluginLoaderContext &
        HotModuleReplacementPluginLoaderContext &
        ContextAdditions,
    remainingRequest: string,
    previousRequest: string,
    data: object
): string | void | Buffer | Promise<string | Buffer>;

interface Problem

interface Problem {}

property argument

argument: string;

property expected

expected?: string;

property index

index?: number;

property path

path: string;

property type

type: ProblemType;

property value

value?: any;

interface RawLoaderDefinitionFunction

interface RawLoaderDefinitionFunction<OptionsType = {}, ContextAdditions = {}> {}

call signature

(
    this: NormalModuleLoaderContext<OptionsType> &
        LoaderRunnerLoaderContext<OptionsType> &
        LoaderPluginLoaderContext &
        HotModuleReplacementPluginLoaderContext &
        ContextAdditions,
    content: Buffer,
    sourceMap?: string | SourceMap,
    additionalData?: AdditionalData
): string | void | Buffer | Promise<string | Buffer>;

interface ResolveData

interface ResolveData {}

property assertions

assertions?: Record<string, any>;

property cacheable

cacheable: boolean;

allow to use the unsafe cache

property context

context: string;

property contextDependencies

contextDependencies: LazySet<string>;

property contextInfo

contextInfo: ModuleFactoryCreateDataContextInfo;

property createData

createData: Partial<NormalModuleCreateData & { settings: ModuleSettings }>;

property dependencies

dependencies: ModuleDependency[];

property dependencyType

dependencyType: string;

property fileDependencies

fileDependencies: LazySet<string>;

property ignoredModule

ignoredModule?: Module;

property missingDependencies

missingDependencies: LazySet<string>;

property request

request: string;

property resolveOptions

resolveOptions?: ResolveOptions;

interface ResolveOptions

interface ResolveOptions {}

Options object for resolving requests.

property alias

alias?:
    | {
          /**
           * New request.
           */
          alias: string | false | string[];
          /**
           * Request to be redirected.
           */
          name: string;
          /**
           * Redirect only exact matching request.
           */
          onlyModule?: boolean;
      }[]
    | { [index: string]: string | false | string[] };

Redirect module requests.

property aliasFields

aliasFields?: (string | string[])[];

Fields in the description file (usually package.json) which are used to redirect requests inside the module.

property byDependency

byDependency?: { [index: string]: ResolveOptions };

Extra resolve options per dependency category. Typical categories are "commonjs", "amd", "esm".

property cache

cache?: boolean;

Enable caching of successfully resolved requests (cache entries are revalidated).

property cachePredicate

cachePredicate?: (request: ResolveRequest) => boolean;

Predicate function to decide which requests should be cached.

property cacheWithContext

cacheWithContext?: boolean;

Include the context information in the cache identifier when caching.

property conditionNames

conditionNames?: string[];

Condition names for exports field entry point.

property descriptionFiles

descriptionFiles?: string[];

Filenames used to find a description file (like a package.json).

property enforceExtension

enforceExtension?: boolean;

Enforce the resolver to use one of the extensions from the extensions option (User must specify requests without extension).

property exportsFields

exportsFields?: string[];

Field names from the description file (usually package.json) which are used to provide entry points of a package.

property extensionAlias

extensionAlias?: { [index: string]: string | string[] };

An object which maps extension to extension aliases.

property extensions

extensions?: string[];

Extensions added to the request when trying to find the file.

property fallback

fallback?:
    | {
          /**
           * New request.
           */
          alias: string | false | string[];
          /**
           * Request to be redirected.
           */
          name: string;
          /**
           * Redirect only exact matching request.
           */
          onlyModule?: boolean;
      }[]
    | { [index: string]: string | false | string[] };

Redirect module requests when normal resolving fails.

property fileSystem

fileSystem?: InputFileSystem;

Filesystem for the resolver.

property fullySpecified

fullySpecified?: boolean;

Treats the request specified by the user as fully specified, meaning no extensions are added and the mainFiles in directories are not resolved (This doesn't affect requests from mainFields, aliasFields or aliases).

property importsFields

importsFields?: string[];

Field names from the description file (usually package.json) which are used to provide internal request of a package (requests starting with # are considered as internal).

property mainFields

mainFields?: (string | string[])[];

Field names from the description file (package.json) which are used to find the default entry point.

property mainFiles

mainFiles?: string[];

Filenames used to find the default entry point if there is no description file or main field.

property modules

modules?: string[];

Folder names or directory paths where to find modules.

property plugins

plugins?: (
    | undefined
    | null
    | false
    | ''
    | 0
    | {
          [index: string]: any;
          /**
           * The run point of the plugin, required method.
           */
          apply: (arg0: Resolver) => void;
      }
    | ((this: Resolver, arg1: Resolver) => void)
    | '...'
)[];

Plugins for the resolver.

property preferAbsolute

preferAbsolute?: boolean;

Prefer to resolve server-relative URLs (starting with '/') as absolute paths before falling back to resolve in 'resolve.roots'.

property preferRelative

preferRelative?: boolean;

Prefer to resolve module requests as relative request and fallback to resolving as module.

property resolver

resolver?: Resolver;

Custom resolver.

property restrictions

restrictions?: (string | RegExp)[];

A list of resolve restrictions. Resolve results must fulfill all of these restrictions to resolve successfully. Other resolve paths are taken when restrictions are not met.

property roots

roots?: string[];

A list of directories in which requests that are server-relative URLs (starting with '/') are resolved.

property symlinks

symlinks?: boolean;

Enable resolving symlinks to the original location.

property unsafeCache

unsafeCache?: boolean | { [index: string]: any };

Enable caching of successfully resolved requests (cache entries are not revalidated).

property useSyncFileSystemCalls

useSyncFileSystemCalls?: boolean;

Use synchronous filesystem calls for the resolver.

interface RuleSetRule

interface RuleSetRule {}

A rule description with conditions and effects for modules.

property assert

assert?: { [index: string]: RuleSetConditionOrConditions };

Match on import assertions of the dependency.

property compiler

compiler?:
    | string
    | RegExp
    | ((value: string) => boolean)
    | RuleSetLogicalConditions
    | RuleSetCondition[];

Match the child compiler name.

property dependency

dependency?:
    | string
    | RegExp
    | ((value: string) => boolean)
    | RuleSetLogicalConditions
    | RuleSetCondition[];

Match dependency type.

property descriptionData

descriptionData?: { [index: string]: RuleSetConditionOrConditions };

Match values of properties in the description file (usually package.json).

property enforce

enforce?: 'pre' | 'post';

Enforce this rule as pre or post step.

property exclude

exclude?:
    | string
    | RegExp
    | ((value: string) => boolean)
    | RuleSetLogicalConditionsAbsolute
    | RuleSetConditionAbsolute[];

Shortcut for resource.exclude.

property generator

generator?: { [index: string]: any };

The options for the module generator.

property include

include?:
    | string
    | RegExp
    | ((value: string) => boolean)
    | RuleSetLogicalConditionsAbsolute
    | RuleSetConditionAbsolute[];

Shortcut for resource.include.

property issuer

issuer?:
    | string
    | RegExp
    | ((value: string) => boolean)
    | RuleSetLogicalConditionsAbsolute
    | RuleSetConditionAbsolute[];

Match the issuer of the module (The module pointing to this module).

property issuerLayer

issuerLayer?:
    | string
    | RegExp
    | ((value: string) => boolean)
    | RuleSetLogicalConditions
    | RuleSetCondition[];

Match layer of the issuer of this module (The module pointing to this module).

property layer

layer?: string;

Specifies the layer in which the module should be placed in.

property loader

loader?: string;

Shortcut for use.loader.

property mimetype

mimetype?:
    | string
    | RegExp
    | ((value: string) => boolean)
    | RuleSetLogicalConditions
    | RuleSetCondition[];

Match module mimetype when load from Data URI.

property oneOf

oneOf?: (undefined | null | false | '' | 0 | RuleSetRule)[];

Only execute the first matching rule in this array.

property options

options?: string | { [index: string]: any };

Shortcut for use.options.

property parser

parser?: { [index: string]: any };

Options for parsing.

property realResource

realResource?:
    | string
    | RegExp
    | ((value: string) => boolean)
    | RuleSetLogicalConditionsAbsolute
    | RuleSetConditionAbsolute[];

Match the real resource path of the module.

property resolve

resolve?: ResolveOptions;

Options for the resolver.

property resource

resource?:
    | string
    | RegExp
    | ((value: string) => boolean)
    | RuleSetLogicalConditionsAbsolute
    | RuleSetConditionAbsolute[];

Match the resource path of the module.

property resourceFragment

resourceFragment?:
    | string
    | RegExp
    | ((value: string) => boolean)
    | RuleSetLogicalConditions
    | RuleSetCondition[];

Match the resource fragment of the module.

property resourceQuery

resourceQuery?:
    | string
    | RegExp
    | ((value: string) => boolean)
    | RuleSetLogicalConditions
    | RuleSetCondition[];

Match the resource query of the module.

property rules

rules?: (undefined | null | false | '' | 0 | RuleSetRule)[];

Match and execute these rules when this rule is matched.

property scheme

scheme?:
    | string
    | RegExp
    | ((value: string) => boolean)
    | RuleSetLogicalConditions
    | RuleSetCondition[];

Match module scheme.

property sideEffects

sideEffects?: boolean;

Flags a module as with or without side effects.

property test

test?:
    | string
    | RegExp
    | ((value: string) => boolean)
    | RuleSetLogicalConditionsAbsolute
    | RuleSetConditionAbsolute[];

Shortcut for resource.test.

property type

type?: string;

Module type to use for the module.

property use

use?:
    | string
    | (
          | undefined
          | null
          | string
          | false
          | 0
          | {
                /**
                 * Unique loader options identifier.
                 */
                ident?: string;
                /**
                 * Loader name.
                 */
                loader?: string;
                /**
                 * Loader options.
                 */
                options?: string | { [index: string]: any };
            }
          | ((data: object) =>
                | string
                | {
                      /**
                       * Unique loader options identifier.
                       */
                      ident?: string;
                      /**
                       * Loader name.
                       */
                      loader?: string;
                      /**
                       * Loader options.
                       */
                      options?: string | { [index: string]: any };
                  }
                | __TypeWebpackOptions
                | __Type_2[])
      )[]
    | ((data: {
          resource: string;
          realResource: string;
          resourceQuery: string;
          issuer: string;
          compiler: string;
      }) => __Type_2[])
    | {
          /**
           * Unique loader options identifier.
           */
          ident?: string;
          /**
           * Loader name.
           */
          loader?: string;
          /**
           * Loader options.
           */
          options?: string | { [index: string]: any };
      }
    | __TypeWebpackOptions;

Modifiers applied to the module when rule is matched.

property with

with?: { [index: string]: RuleSetConditionOrConditions };

Match on import attributes of the dependency.

interface StatsOptions

interface StatsOptions {}

Stats options object.

property all

all?: boolean;

Fallback value for stats options when an option is not defined (has precedence over local webpack defaults).

property assets

assets?: boolean;

Add assets information.

property assetsSort

assetsSort?: string;

Sort the assets by that field.

property assetsSpace

assetsSpace?: number;

Space to display assets (groups will be collapsed to fit this space).

property builtAt

builtAt?: boolean;

Add built at time information.

property cached

cached?: boolean;

Add information about cached (not built) modules (deprecated: use 'cachedModules' instead).

property cachedAssets

cachedAssets?: boolean;

Show cached assets (setting this to false only shows emitted files).

property cachedModules

cachedModules?: boolean;

Add information about cached (not built) modules.

property children

children?: boolean;

Add children information.

property chunkGroupAuxiliary

chunkGroupAuxiliary?: boolean;

Display auxiliary assets in chunk groups.

property chunkGroupChildren

chunkGroupChildren?: boolean;

Display children of chunk groups.

property chunkGroupMaxAssets

chunkGroupMaxAssets?: number;

Limit of assets displayed in chunk groups.

property chunkGroups

chunkGroups?: boolean;

Display all chunk groups with the corresponding bundles.

property chunkModules

chunkModules?: boolean;

Add built modules information to chunk information.

property chunkModulesSpace

chunkModulesSpace?: number;

Space to display chunk modules (groups will be collapsed to fit this space, value is in number of modules/group).

property chunkOrigins

chunkOrigins?: boolean;

Add the origins of chunks and chunk merging info.

property chunkRelations

chunkRelations?: boolean;

Add information about parent, children and sibling chunks to chunk information.

property chunks

chunks?: boolean;

Add chunk information.

property chunksSort

chunksSort?: string;

Sort the chunks by that field.

property colors

colors?:
    | boolean
    | {
          /**
           * Custom color for bold text.
           */
          bold?: string;
          /**
           * Custom color for cyan text.
           */
          cyan?: string;
          /**
           * Custom color for green text.
           */
          green?: string;
          /**
           * Custom color for magenta text.
           */
          magenta?: string;
          /**
           * Custom color for red text.
           */
          red?: string;
          /**
           * Custom color for yellow text.
           */
          yellow?: string;
      };

Enables/Disables colorful output.

property context

context?: string;

Context directory for request shortening.

property dependentModules

dependentModules?: boolean;

Show chunk modules that are dependencies of other modules of the chunk.

property depth

depth?: boolean;

Add module depth in module graph.

property entrypoints

entrypoints?: boolean | 'auto';

Display the entry points with the corresponding bundles.

property env

env?: boolean;

Add --env information.

property errorDetails

errorDetails?: boolean | 'auto';

Add details to errors (like resolving log).

property errors

errors?: boolean;

Add errors.

property errorsCount

errorsCount?: boolean;

Add errors count.

property errorsSpace

errorsSpace?: number;

Space to display errors (value is in number of lines).

property errorStack

errorStack?: boolean;

Add internal stack trace to errors.

property exclude

exclude?:
    | string
    | boolean
    | RegExp
    | ModuleFilterItemTypes[]
    | ((
          name: string,
          module: StatsModule,
          type: 'module' | 'chunk' | 'root-of-chunk' | 'nested'
      ) => boolean);

Please use excludeModules instead.

property excludeAssets

excludeAssets?:
    | string
    | RegExp
    | AssetFilterItemTypes[]
    | ((name: string, asset: StatsAsset) => boolean);

Suppress assets that match the specified filters. Filters can be Strings, RegExps or Functions.

property excludeModules

excludeModules?:
    | string
    | boolean
    | RegExp
    | ModuleFilterItemTypes[]
    | ((
          name: string,
          module: StatsModule,
          type: 'module' | 'chunk' | 'root-of-chunk' | 'nested'
      ) => boolean);

Suppress modules that match the specified filters. Filters can be Strings, RegExps, Booleans or Functions.

property groupAssetsByChunk

groupAssetsByChunk?: boolean;

Group assets by how their are related to chunks.

property groupAssetsByEmitStatus

groupAssetsByEmitStatus?: boolean;

Group assets by their status (emitted, compared for emit or cached).

property groupAssetsByExtension

groupAssetsByExtension?: boolean;

Group assets by their extension.

property groupAssetsByInfo

groupAssetsByInfo?: boolean;

Group assets by their asset info (immutable, development, hotModuleReplacement, etc).

property groupAssetsByPath

groupAssetsByPath?: boolean;

Group assets by their path.

property groupModulesByAttributes

groupModulesByAttributes?: boolean;

Group modules by their attributes (errors, warnings, assets, optional, orphan, or dependent).

property groupModulesByCacheStatus

groupModulesByCacheStatus?: boolean;

Group modules by their status (cached or built and cacheable).

property groupModulesByExtension

groupModulesByExtension?: boolean;

Group modules by their extension.

property groupModulesByLayer

groupModulesByLayer?: boolean;

Group modules by their layer.

property groupModulesByPath

groupModulesByPath?: boolean;

Group modules by their path.

property groupModulesByType

groupModulesByType?: boolean;

Group modules by their type.

property groupReasonsByOrigin

groupReasonsByOrigin?: boolean;

Group reasons by their origin module.

property hash

hash?: boolean;

Add the hash of the compilation.

property ids

ids?: boolean;

Add ids.

property logging

logging?: boolean | 'none' | 'error' | 'warn' | 'info' | 'log' | 'verbose';

Add logging output.

property loggingDebug

loggingDebug?:
    | string
    | boolean
    | RegExp
    | FilterItemTypes[]
    | ((value: string) => boolean);

Include debug logging of specified loggers (i. e. for plugins or loaders). Filters can be Strings, RegExps or Functions.

property loggingTrace

loggingTrace?: boolean;

Add stack traces to logging output.

property moduleAssets

moduleAssets?: boolean;

Add information about assets inside modules.

property modules

modules?: boolean;

Add built modules information.

property modulesSort

modulesSort?: string;

Sort the modules by that field.

property modulesSpace

modulesSpace?: number;

Space to display modules (groups will be collapsed to fit this space, value is in number of modules/groups).

property moduleTrace

moduleTrace?: boolean;

Add dependencies and origin of warnings/errors.

property nestedModules

nestedModules?: boolean;

Add information about modules nested in other modules (like with module concatenation).

property nestedModulesSpace

nestedModulesSpace?: number;

Space to display modules nested within other modules (groups will be collapsed to fit this space, value is in number of modules/group).

property optimizationBailout

optimizationBailout?: boolean;

Show reasons why optimization bailed out for modules.

property orphanModules

orphanModules?: boolean;

Add information about orphan modules.

property outputPath

outputPath?: boolean;

Add output path information.

property performance

performance?: boolean;

Add performance hint flags.

property preset

preset?: string | boolean;

Preset for the default values.

property providedExports

providedExports?: boolean;

Show exports provided by modules.

property publicPath

publicPath?: boolean;

Add public path information.

property reasons

reasons?: boolean;

Add information about the reasons why modules are included.

property reasonsSpace

reasonsSpace?: number;

Space to display reasons (groups will be collapsed to fit this space).

property relatedAssets

relatedAssets?: boolean;

Add information about assets that are related to other assets (like SourceMaps for assets).

property runtime

runtime?: boolean;

Add information about runtime modules (deprecated: use 'runtimeModules' instead).

property runtimeModules

runtimeModules?: boolean;

Add information about runtime modules.

property source

source?: boolean;

Add the source code of modules.

property timings

timings?: boolean;

Add timing information.

property usedExports

usedExports?: boolean;

Show exports used by modules.

property version

version?: boolean;

Add webpack version information.

property warnings

warnings?: boolean;

Add warnings.

property warningsCount

warningsCount?: boolean;

Add warnings count.

property warningsFilter

warningsFilter?:
    | string
    | RegExp
    | WarningFilterItemTypes[]
    | ((warning: StatsError, value: string) => boolean);

Suppress listing warnings that match the specified filters (they will still be counted). Filters can be Strings, RegExps or Functions.

property warningsSpace

warningsSpace?: number;

Space to display warnings (value is in number of lines).

interface WebpackOptionsNormalized

interface WebpackOptionsNormalized {}

Normalized webpack options object.

property amd

amd?: false | { [index: string]: any };

Set the value of require.amd and define.amd. Or disable AMD support.

property bail

bail?: boolean;

Report the first error as a hard error instead of tolerating it.

property cache

cache: CacheOptionsNormalized;

Cache generated modules and chunks to improve performance for multiple incremental builds.

property context

context?: string;

The base directory (absolute path!) for resolving the entry option. If output.pathinfo is set, the included pathinfo is shortened to this directory.

property dependencies

dependencies?: string[];

References to other configurations to depend on.

property devServer

devServer?: false | { [index: string]: any };

Options for the webpack-dev-server.

property devtool

devtool?: string | false;

A developer tool to enhance debugging (false | eval | [inline-|hidden-|eval-][nosources-][cheap-[module-]]source-map).

property entry

entry: EntryNormalized;

The entry point(s) of the compilation.

property experiments

experiments: ExperimentsNormalized;

Enables/Disables experiments (experimental features with relax SemVer compatibility).

property externals

externals: Externals;

Specify dependencies that shouldn't be resolved by webpack, but should become dependencies of the resulting bundle. The kind of the dependency depends on output.libraryTarget.

property externalsPresets

externalsPresets: ExternalsPresets;

Enable presets of externals for specific targets.

property externalsType

externalsType?:
    | 'import'
    | 'var'
    | 'module'
    | 'assign'
    | 'this'
    | 'window'
    | 'self'
    | 'global'
    | 'commonjs'
    | 'commonjs2'
    | 'commonjs-module'
    | 'commonjs-static'
    | 'amd'
    | 'amd-require'
    | 'umd'
    | 'umd2'
    | 'jsonp'
    | 'system'
    | 'promise'
    | 'module-import'
    | 'script'
    | 'node-commonjs';

Specifies the default type of externals ('amd*', 'umd*', 'system' and 'jsonp' depend on output.libraryTarget set to the same value).

property ignoreWarnings

ignoreWarnings?: ((
    warning: WebpackError,
    compilation: Compilation
) => boolean)[];

Ignore specific warnings.

property infrastructureLogging

infrastructureLogging: InfrastructureLogging;

Options for infrastructure level logging.

property loader

loader?: Loader;

Custom values available in the loader context.

property mode

mode?: 'none' | 'development' | 'production';

Enable production optimizations or development hints.

property module

module: ModuleOptionsNormalized;

Options affecting the normal modules (NormalModuleFactory).

property name

name?: string;

Name of the configuration. Used when loading multiple configurations.

property node

node: Node;

Include polyfills or mocks for various node stuff.

property optimization

optimization: Optimization;

Enables/Disables integrated optimizations.

property output

output: OutputNormalized;

Normalized options affecting the output of the compilation. output options tell webpack how to write the compiled files to disk.

property parallelism

parallelism?: number;

The number of parallel processed modules in the compilation.

property performance

performance?: false | PerformanceOptions;

Configuration for web performance recommendations.

property plugins

plugins: (
    | undefined
    | null
    | false
    | ''
    | 0
    | ((this: Compiler, compiler: Compiler) => void)
    | WebpackPluginInstance
)[];

Add additional plugins to the compiler.

property profile

profile?: boolean;

Capture timing information for each module.

property recordsInputPath

recordsInputPath?: string | false;

Store compiler state to a json file.

property recordsOutputPath

recordsOutputPath?: string | false;

Load compiler state from a json file.

property resolve

resolve: ResolveOptions;

Options for the resolver.

property resolveLoader

resolveLoader: ResolveOptions;

Options for the resolver when resolving loaders.

property snapshot

snapshot: SnapshotOptionsWebpackOptions;

Options affecting how file system snapshots are created and validated.

property stats

stats: StatsValue;

Stats options object or preset name.

property target

target?: string | false | string[];

Environment to build for. An array of environments to build for all of them when possible.

property watch

watch?: boolean;

Enter watch mode, which rebuilds on file change.

property watchOptions

watchOptions: WatchOptions;

Options for the watcher.

interface WebpackPluginInstance

interface WebpackPluginInstance {}

Plugin instance.

property apply

apply: (compiler: Compiler) => void;

The run point of the plugin, required method.

index signature

[index: string]: any;

Type Aliases

type AssetInfo

type AssetInfo = KnownAssetInfo & Record<string, any>;

type Entry

type Entry =
    | string
    | (() => string | EntryObject | string[] | Promise<EntryStatic>)
    | EntryObject
    | string[];

type EntryNormalized

type EntryNormalized =
    | (() => Promise<EntryStaticNormalized>)
    | EntryStaticNormalized;

type EntryOptions

type EntryOptions = { name?: string } & Omit<EntryDescriptionNormalized, 'import'>;

type ExternalItemValue

type ExternalItemValue = string | boolean | string[] | { [index: string]: any };

type Externals

type Externals =
    | string
    | RegExp
    | ExternalItem[]
    | (ExternalItemObjectKnown & ExternalItemObjectUnknown)
    | ((
          data: ExternalItemFunctionData,
          callback: (
              err?: null | Error,
              result?: string | boolean | string[] | { [index: string]: any }
          ) => void
      ) => void)
    | ((data: ExternalItemFunctionData) => Promise<ExternalItemValue>);

type LoaderContext

type LoaderContextDeclarationsIndex<OptionsType> =
    NormalModuleLoaderContext<OptionsType> &
        LoaderRunnerLoaderContext<OptionsType> &
        LoaderPluginLoaderContext &
        HotModuleReplacementPluginLoaderContext;

type LoaderDefinition

type LoaderDefinition<
    OptionsType = {},
    ContextAdditions = {}
> = LoaderDefinitionFunction<OptionsType, ContextAdditions> & {
    raw?: false;
    pitch?: PitchLoaderDefinitionFunction<OptionsType, ContextAdditions>;
};

type ParserState

type ParserState = Record<string, any> & ParserStateBase;

type RawLoaderDefinition

type RawLoaderDefinition<
    OptionsType = {},
    ContextAdditions = {}
> = RawLoaderDefinitionFunction<OptionsType, ContextAdditions> & {
    raw: true;
    pitch?: PitchLoaderDefinitionFunction<OptionsType, ContextAdditions>;
};

type ResolvePluginInstance

type ResolvePluginInstance =
    | {
          [index: string]: any;
          /**
           * The run point of the plugin, required method.
           */
          apply: (arg0: Resolver) => void;
      }
    | ((this: Resolver, arg1: Resolver) => void);

type RuleSetCondition

type RuleSetCondition =
    | string
    | RegExp
    | ((value: string) => boolean)
    | RuleSetLogicalConditions
    | RuleSetCondition[];

type RuleSetConditionAbsolute

type RuleSetConditionAbsolute =
    | string
    | RegExp
    | ((value: string) => boolean)
    | RuleSetLogicalConditionsAbsolute
    | RuleSetConditionAbsolute[];

type RuleSetUse

type RuleSetUse =
    | string
    | (
          | undefined
          | null
          | string
          | false
          | 0
          | {
                /**
                 * Unique loader options identifier.
                 */
                ident?: string;
                /**
                 * Loader name.
                 */
                loader?: string;
                /**
                 * Loader options.
                 */
                options?: string | { [index: string]: any };
            }
          | ((data: object) =>
                | string
                | {
                      /**
                       * Unique loader options identifier.
                       */
                      ident?: string;
                      /**
                       * Loader name.
                       */
                      loader?: string;
                      /**
                       * Loader options.
                       */
                      options?: string | { [index: string]: any };
                  }
                | __TypeWebpackOptions
                | __Type_2[])
      )[]
    | ((data: {
          resource: string;
          realResource: string;
          resourceQuery: string;
          issuer: string;
          compiler: string;
      }) => __Type_2[])
    | {
          /**
           * Unique loader options identifier.
           */
          ident?: string;
          /**
           * Loader name.
           */
          loader?: string;
          /**
           * Loader options.
           */
          options?: string | { [index: string]: any };
      }
    | __TypeWebpackOptions;

type RuleSetUseItem

type RuleSetUseItem =
    | string
    | {
          /**
           * Unique loader options identifier.
           */
          ident?: string;
          /**
           * Loader name.
           */
          loader?: string;
          /**
           * Loader options.
           */
          options?: string | { [index: string]: any };
      }
    | __TypeWebpackOptions;

type StatsAsset

type StatsAsset = Record<string, any> & KnownStatsAsset;

type StatsChunk

type StatsChunk = Record<string, any> & KnownStatsChunk;

type StatsChunkGroup

type StatsChunkGroup = Record<string, any> & KnownStatsChunkGroup;

type StatsChunkOrigin

type StatsChunkOrigin = Record<string, any> & KnownStatsChunkOrigin;

type StatsCompilation

type StatsCompilation = Record<string, any> & KnownStatsCompilation;

type StatsError

type StatsError = Record<string, any> & KnownStatsError;

type StatsLogging

type StatsLogging = Record<string, any> & KnownStatsLogging;

type StatsLoggingEntry

type StatsLoggingEntry = Record<string, any> & KnownStatsLoggingEntry;

type StatsModule

type StatsModule = Record<string, any> & KnownStatsModule;

type StatsModuleIssuer

type StatsModuleIssuer = Record<string, any> & KnownStatsModuleIssuer;

type StatsModuleReason

type StatsModuleReason = Record<string, any> & KnownStatsModuleReason;

type StatsModuleTraceDependency

type StatsModuleTraceDependency = Record<string, any> &
    KnownStatsModuleTraceDependency;

type StatsModuleTraceItem

type StatsModuleTraceItem = Record<string, any> & KnownStatsModuleTraceItem;

type StatsProfile

type StatsProfile = Record<string, any> & KnownStatsProfile;

type WebpackPluginFunction

type WebpackPluginFunction = (this: Compiler, compiler: Compiler) => void;

Namespaces

namespace cache

namespace cache {}

class MemoryCachePlugin

class MemoryCachePlugin {}

constructor

constructor();

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

namespace cli

namespace cli {}

function getArguments

getArguments: (schema?: any) => Flags;

function processArguments

processArguments: (
    args: Flags,
    config: any,
    values: Record<string, Value[]>
) => null | Problem[];

namespace config

namespace config {}

function applyWebpackOptionsDefaults

applyWebpackOptionsDefaults: (
    options: WebpackOptionsNormalized,
    compilerIndex?: number
) => ResolvedOptions;

function getNormalizedWebpackOptions

getNormalizedWebpackOptions: (config: Configuration) => WebpackOptionsNormalized;

namespace container

namespace container {}

function scope

scope: <T>(
    scope: string,
    options: ContainerOptionsFormat<T>
) => Record<string, string | string[] | T>;

class ContainerPlugin

class ContainerPlugin {}

constructor

constructor(options: ContainerPluginOptions);

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class ContainerReferencePlugin

class ContainerReferencePlugin {}

constructor

constructor(options: ContainerReferencePluginOptions);

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class ModuleFederationPlugin

class ModuleFederationPlugin {}

constructor

constructor(options: ModuleFederationPluginOptions);

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

method getCompilationHooks

static getCompilationHooks: (
    compilation: Compilation
) => CompilationHooksModuleFederationPlugin;

Get the compilation hooks associated with this plugin.

namespace css

namespace css {}

class CssModulesPlugin

class CssModulesPlugin {}

constructor

constructor();

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

method chunkHasCss

static chunkHasCss: (chunk: Chunk, chunkGraph: ChunkGraph) => boolean;

method getChunkFilenameTemplate

static getChunkFilenameTemplate: (
    chunk: Chunk,
    outputOptions: OutputNormalized
) => TemplatePath;

method getCompilationHooks

static getCompilationHooks: (
    compilation: Compilation
) => CompilationHooksCssModulesPlugin;

method getModulesInOrder

getModulesInOrder: (
    chunk: Chunk,
    modules: Iterable<Module>,
    compilation: Compilation
) => Module[];

method getOrderedChunkCssModules

getOrderedChunkCssModules: (
    chunk: Chunk,
    chunkGraph: ChunkGraph,
    compilation: Compilation
) => Module[];

method renderChunk

renderChunk: (
    __0: RenderContextCssModulesPlugin,
    hooks: CompilationHooksCssModulesPlugin
) => Source;

method renderModule

renderModule: (
    module: CssModule,
    renderContext: ChunkRenderContextCssModulesPlugin,
    hooks: CompilationHooksCssModulesPlugin
) => Source;

namespace debug

namespace debug {}

class ProfilingPlugin

class ProfilingPlugin {}

constructor

constructor(options?: ProfilingPluginOptions);

property outputPath

outputPath: string;

property Profiler

static Profiler: typeof Profiler;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

namespace dependencies

namespace dependencies {}

class ConstDependency

class ConstDependency extends NullDependency {}

constructor

constructor(
    expression: string,
    range: number | [number, number],
    runtimeRequirements?: string[]
);

property EXPORTS_OBJECT_REFERENCED

static EXPORTS_OBJECT_REFERENCED: string[][];

property expression

expression: string;

property NO_EXPORTS_REFERENCED

static NO_EXPORTS_REFERENCED: string[][];

property range

range: number | [number, number];

property runtimeRequirements

runtimeRequirements: Set<string>;

property Template

static Template: typeof ConstDependencyTemplate;

property TRANSITIVE

static TRANSITIVE: Symbol;

class HarmonyImportDependency

class HarmonyImportDependency extends ModuleDependency {}

constructor

constructor(
    request: string,
    sourceOrder: number,
    attributes?: Record<string, string>
);

property ExportPresenceModes

static ExportPresenceModes: {
    NONE: 0;
    WARN: 1;
    AUTO: 2;
    ERROR: 3;
    fromUserOption(str: string | false): 0 | 1 | 2 | 3;
};

property EXPORTS_OBJECT_REFERENCED

static EXPORTS_OBJECT_REFERENCED: string[][];

property NO_EXPORTS_REFERENCED

static NO_EXPORTS_REFERENCED: string[][];

property sourceOrder

sourceOrder: number;

property Template

static Template: typeof HarmonyImportDependencyTemplate;

property TRANSITIVE

static TRANSITIVE: Symbol;

method getImportStatement

getImportStatement: (
    update: boolean,
    __1: DependencyTemplateContext
) => [string, string];

method getImportVar

getImportVar: (moduleGraph: ModuleGraph) => string;

method getLinkingErrors

getLinkingErrors: (
    moduleGraph: ModuleGraph,
    ids: string[],
    additionalMessage: string
) => undefined | WebpackError[];

class ModuleDependency

class ModuleDependency extends Dependency {}

constructor

constructor(request: string);

property assertions

assertions?: Record<string, string>;

property EXPORTS_OBJECT_REFERENCED

static EXPORTS_OBJECT_REFERENCED: string[][];

property NO_EXPORTS_REFERENCED

static NO_EXPORTS_REFERENCED: string[][];

property range

range: any;

property request

request: string;

property Template

static Template: typeof DependencyTemplate;

property TRANSITIVE

static TRANSITIVE: Symbol;

property userRequest

userRequest: string;

class NullDependency

class NullDependency extends Dependency {}

constructor

constructor();

property EXPORTS_OBJECT_REFERENCED

static EXPORTS_OBJECT_REFERENCED: string[][];

property NO_EXPORTS_REFERENCED

static NO_EXPORTS_REFERENCED: string[][];

property Template

static Template: typeof NullDependencyTemplate;

property TRANSITIVE

static TRANSITIVE: Symbol;

namespace electron

namespace electron {}

class ElectronTargetPlugin

class ElectronTargetPlugin {}

constructor

constructor(context?: 'main' | 'preload' | 'renderer');

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

namespace esm

namespace esm {}

class ModuleChunkLoadingRuntimeModule

class ModuleChunkLoadingRuntimeModule extends RuntimeModule {}

constructor

constructor(runtimeRequirements: ReadonlySet<string>);

property STAGE_ATTACH

static STAGE_ATTACH: number;

Runtime modules which attach to handlers of other runtime modules

property STAGE_BASIC

static STAGE_BASIC: number;

Runtime modules with simple dependencies on other runtime modules

property STAGE_NORMAL

static STAGE_NORMAL: number;

Runtime modules without any dependencies to other runtime modules

property STAGE_TRIGGER

static STAGE_TRIGGER: number;

Runtime modules which trigger actions on bootstrap

method getCompilationHooks

static getCompilationHooks: (
    compilation: Compilation
) => JsonpCompilationPluginHooks;

namespace experiments

namespace experiments {}

namespace experiments.ids

namespace experiments.ids {}

class SyncModuleIdsPlugin

class SyncModuleIdsPlugin {}

constructor

constructor(__0: {
    path: string;
    context?: string;
    test: (arg0: Module) => boolean;
    mode?: 'read' | 'create' | 'merge' | 'update';
});

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

namespace experiments.schemes

namespace experiments.schemes {}

class HttpUriPlugin

class HttpUriPlugin {}

constructor

constructor(options: HttpUriOptions);

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

namespace ids

namespace ids {}

class ChunkModuleIdRangePlugin

class ChunkModuleIdRangePlugin {}

constructor

constructor(options: ChunkModuleIdRangePluginOptions);

property options

options: ChunkModuleIdRangePluginOptions;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class DeterministicChunkIdsPlugin

class DeterministicChunkIdsPlugin {}

constructor

constructor(options?: DeterministicChunkIdsPluginOptions);

property options

options: DeterministicChunkIdsPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class DeterministicModuleIdsPlugin

class DeterministicModuleIdsPlugin {}

constructor

constructor(options?: DeterministicModuleIdsPluginOptions);

property options

options: DeterministicModuleIdsPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class HashedModuleIdsPlugin

class HashedModuleIdsPlugin {}

constructor

constructor(options?: HashedModuleIdsPluginOptions);

property options

options: HashedModuleIdsPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class NamedChunkIdsPlugin

class NamedChunkIdsPlugin {}

constructor

constructor(options?: NamedChunkIdsPluginOptions);

property context

context?: string;

property delimiter

delimiter: string;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class NamedModuleIdsPlugin

class NamedModuleIdsPlugin {}

constructor

constructor(options?: NamedModuleIdsPluginOptions);

property options

options: NamedModuleIdsPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class NaturalModuleIdsPlugin

class NaturalModuleIdsPlugin {}

constructor

constructor();

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class OccurrenceChunkIdsPlugin

class OccurrenceChunkIdsPlugin {}

constructor

constructor(options?: OccurrenceChunkIdsPluginOptions);

property options

options: OccurrenceChunkIdsPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class OccurrenceModuleIdsPlugin

class OccurrenceModuleIdsPlugin {}

constructor

constructor(options?: OccurrenceModuleIdsPluginOptions);

property options

options: OccurrenceModuleIdsPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

namespace javascript

namespace javascript {}

class EnableChunkLoadingPlugin

class EnableChunkLoadingPlugin {}

constructor

constructor(type: string);

property type

type: string;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

method checkEnabled

static checkEnabled: (compiler: Compiler, type: string) => void;

method setEnabled

static setEnabled: (compiler: Compiler, type: string) => void;

class JavascriptModulesPlugin

class JavascriptModulesPlugin {}

constructor

constructor(options?: {});

property chunkHasJs

static chunkHasJs: (chunk: Chunk, chunkGraph: ChunkGraph) => boolean;

property options

options: {};

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

method getChunkFilenameTemplate

static getChunkFilenameTemplate: (
    chunk: Chunk,
    outputOptions: Output
) => TemplatePath;

method getCompilationHooks

static getCompilationHooks: (
    compilation: Compilation
) => CompilationHooksJavascriptModulesPlugin;

method getRenamedInlineModule

getRenamedInlineModule: (
    allModules: Module[],
    renderContext: MainRenderContext,
    inlinedModules: Set<Module>,
    chunkRenderContext: ChunkRenderContextJavascriptModulesPlugin,
    hooks: CompilationHooksJavascriptModulesPlugin,
    allStrict: undefined | boolean,
    hasChunkModules: boolean
) => false | Map<Module, Source>;

method renderBootstrap

renderBootstrap: (
    renderContext: RenderBootstrapContext,
    hooks: CompilationHooksJavascriptModulesPlugin
) => Bootstrap;

method renderChunk

renderChunk: (
    renderContext: RenderContextJavascriptModulesPlugin,
    hooks: CompilationHooksJavascriptModulesPlugin
) => Source;

method renderMain

renderMain: (
    renderContext: MainRenderContext,
    hooks: CompilationHooksJavascriptModulesPlugin,
    compilation: Compilation
) => Source;

method renderModule

renderModule: (
    module: Module,
    renderContext: ChunkRenderContextJavascriptModulesPlugin,
    hooks: CompilationHooksJavascriptModulesPlugin,
    factory: boolean
) => null | Source;

method renderRequire

renderRequire: (
    renderContext: RenderBootstrapContext,
    hooks: CompilationHooksJavascriptModulesPlugin
) => string;

method updateHashWithBootstrap

updateHashWithBootstrap: (
    hash: Hash,
    renderContext: RenderBootstrapContext,
    hooks: CompilationHooksJavascriptModulesPlugin
) => void;

class JavascriptParser

class JavascriptParser extends Parser {}

constructor

constructor(sourceType?: 'module' | 'auto' | 'script');

property ALLOWED_MEMBER_TYPES_ALL

static ALLOWED_MEMBER_TYPES_ALL: number;

property ALLOWED_MEMBER_TYPES_CALL_EXPRESSION

static ALLOWED_MEMBER_TYPES_CALL_EXPRESSION: number;

property ALLOWED_MEMBER_TYPES_EXPRESSION

static ALLOWED_MEMBER_TYPES_EXPRESSION: number;

property comments

comments?: Comment[];

property currentTagData

currentTagData: any;

property destructuringAssignmentProperties

destructuringAssignmentProperties?: WeakMap<
    any,
    Set<DestructuringAssignmentProperty>
>;

property getImportAttributes

static getImportAttributes: (
    node:
        | ImportDeclarationJavascriptParser
        | ExportNamedDeclarationJavascriptParser
        | ExportAllDeclarationJavascriptParser
        | ImportExpressionJavascriptParser
) => undefined | ImportAttributes;

property hooks

hooks: Readonly<{
    evaluateTypeof: HookMap<
        SyncBailHook<[UnaryExpression], BasicEvaluatedExpression>
    >;
    evaluate: HookMap<SyncBailHook<[any], BasicEvaluatedExpression>>;
    evaluateIdentifier: HookMap<SyncBailHook<[any], BasicEvaluatedExpression>>;
    evaluateDefinedIdentifier: HookMap<
        SyncBailHook<[any], BasicEvaluatedExpression>
    >;
    evaluateNewExpression: HookMap<
        SyncBailHook<[NewExpression], BasicEvaluatedExpression>
    >;
    evaluateCallExpression: HookMap<
        SyncBailHook<[any], BasicEvaluatedExpression>
    >;
    evaluateCallExpressionMember: HookMap<
        SyncBailHook<[any, BasicEvaluatedExpression], BasicEvaluatedExpression>
    >;
    isPure: HookMap<SyncBailHook<[any, number], boolean | void>>;
    preStatement: SyncBailHook<[any], boolean | void>;
    blockPreStatement: SyncBailHook<[any], boolean | void>;
    statement: SyncBailHook<[any], boolean | void>;
    statementIf: SyncBailHook<[IfStatement], boolean | void>;
    classExtendsExpression: SyncBailHook<[any, any], boolean | void>;
    classBodyElement: SyncBailHook<[any, any], boolean | void>;
    classBodyValue: SyncBailHook<[any, any, any], boolean | void>;
    label: HookMap<SyncBailHook<[LabeledStatement], boolean | void>>;
    import: SyncBailHook<[any, any], boolean | void>;
    importSpecifier: SyncBailHook<[any, any, string, string], boolean | void>;
    export: SyncBailHook<[any], boolean | void>;
    exportImport: SyncBailHook<[any, any], boolean | void>;
    exportDeclaration: SyncBailHook<[any, any], boolean | void>;
    exportExpression: SyncBailHook<
        [ExportDefaultDeclaration, any],
        boolean | void
    >;
    exportSpecifier: SyncBailHook<[any, string, string, number], boolean | void>;
    exportImportSpecifier: SyncBailHook<
        [any, any, string, string, number],
        boolean | void
    >;
    preDeclarator: SyncBailHook<[VariableDeclarator, any], boolean | void>;
    declarator: SyncBailHook<[VariableDeclarator, any], boolean | void>;
    varDeclaration: HookMap<SyncBailHook<[any], boolean | void>>;
    varDeclarationLet: HookMap<SyncBailHook<[any], boolean | void>>;
    varDeclarationConst: HookMap<SyncBailHook<[any], boolean | void>>;
    varDeclarationVar: HookMap<SyncBailHook<[any], boolean | void>>;
    pattern: HookMap<SyncBailHook<[Identifier], boolean | void>>;
    canRename: HookMap<SyncBailHook<[any], boolean | void>>;
    rename: HookMap<SyncBailHook<[any], boolean | void>>;
    assign: HookMap<SyncBailHook<[AssignmentExpression], boolean | void>>;
    assignMemberChain: HookMap<
        SyncBailHook<[AssignmentExpression, string[]], boolean | void>
    >;
    typeof: HookMap<SyncBailHook<[any], boolean | void>>;
    importCall: SyncBailHook<[any], boolean | void>;
    topLevelAwait: SyncBailHook<[any], boolean | void>;
    call: HookMap<SyncBailHook<[any], boolean | void>>;
    callMemberChain: HookMap<
        SyncBailHook<
            [any, string[], boolean[], [number, number][]],
            boolean | void
        >
    >;
    memberChainOfCallMemberChain: HookMap<
        SyncBailHook<
            [any, string[], any, string[], [number, number][]],
            boolean | void
        >
    >;
    callMemberChainOfCallMemberChain: HookMap<
        SyncBailHook<
            [any, string[], any, string[], [number, number][]],
            boolean | void
        >
    >;
    optionalChaining: SyncBailHook<[ChainExpression], boolean | void>;
    new: HookMap<SyncBailHook<[NewExpression], boolean | void>>;
    binaryExpression: SyncBailHook<[BinaryExpression], boolean | void>;
    expression: HookMap<SyncBailHook<[any], boolean | void>>;
    expressionMemberChain: HookMap<
        SyncBailHook<
            [MemberExpression, string[], boolean[], [number, number][]],
            boolean | void
        >
    >;
    unhandledExpressionMemberChain: HookMap<
        SyncBailHook<[MemberExpression, string[]], boolean | void>
    >;
    expressionConditionalOperator: SyncBailHook<
        [ConditionalExpression],
        boolean | void
    >;
    expressionLogicalOperator: SyncBailHook<[LogicalExpression], boolean | void>;
    program: SyncBailHook<[Program, Comment[]], boolean | void>;
    finish: SyncBailHook<[Program, Comment[]], boolean | void>;
}>;

property magicCommentContext

magicCommentContext: Context;

property prevStatement

prevStatement?: any;

property scope

scope: ScopeInfo;

property semicolons

semicolons?: Set<number>;

property sourceType

sourceType: 'module' | 'auto' | 'script';

property state

state: ParserState;

property statementPath

statementPath?: any[];

property VariableInfo

static VariableInfo: typeof VariableInfo;

method blockPreWalkClassDeclaration

blockPreWalkClassDeclaration: (statement: ClassDeclaration) => void;

method blockPreWalkExportAllDeclaration

blockPreWalkExportAllDeclaration: (
    statement: ExportAllDeclarationJavascriptParser
) => void;

method blockPreWalkExportDefaultDeclaration

blockPreWalkExportDefaultDeclaration: (statement?: any) => void;

method blockPreWalkExportNamedDeclaration

blockPreWalkExportNamedDeclaration: (
    statement: ExportNamedDeclarationJavascriptParser
) => void;

method blockPreWalkExpressionStatement

blockPreWalkExpressionStatement: (statement: ExpressionStatement) => void;

method blockPreWalkImportDeclaration

blockPreWalkImportDeclaration: (
    statement: ImportDeclarationJavascriptParser
) => void;

method blockPreWalkStatement

blockPreWalkStatement: (
    statement:
        | ImportDeclarationJavascriptParser
        | ExportNamedDeclarationJavascriptParser
        | ExportAllDeclarationJavascriptParser
        | FunctionDeclaration
        | VariableDeclaration
        | ClassDeclaration
        | ExpressionStatement
        | BlockStatement
        | StaticBlock
        | EmptyStatement
        | DebuggerStatement
        | WithStatement
        | ReturnStatement
        | LabeledStatement
        | BreakStatement
        | ContinueStatement
        | IfStatement
        | SwitchStatement
        | ThrowStatement
        | TryStatement
        | WhileStatement
        | DoWhileStatement
        | ForStatement
        | ForInStatement
        | ForOfStatement
        | ExportDefaultDeclaration
) => void;

method blockPreWalkStatements

blockPreWalkStatements: (
    statements: (
        | ImportDeclarationJavascriptParser
        | ExportNamedDeclarationJavascriptParser
        | ExportAllDeclarationJavascriptParser
        | FunctionDeclaration
        | VariableDeclaration
        | ClassDeclaration
        | ExpressionStatement
        | BlockStatement
        | StaticBlock
        | EmptyStatement
        | DebuggerStatement
        | WithStatement
        | ReturnStatement
        | LabeledStatement
        | BreakStatement
        | ContinueStatement
        | IfStatement
        | SwitchStatement
        | ThrowStatement
        | TryStatement
        | WhileStatement
        | DoWhileStatement
        | ForStatement
        | ForInStatement
        | ForOfStatement
        | ExportDefaultDeclaration
    )[]
) => void;

Block pre walking iterates the scope for block variable declarations

method blockPreWalkVariableDeclaration

blockPreWalkVariableDeclaration: (statement: VariableDeclaration) => void;

method callHooksForExpression

callHooksForExpression: <T, R>(
    hookMap: HookMap<SyncBailHook<T, R>>,
    expr:
        | ImportExpressionImport
        | UnaryExpression
        | ArrayExpression
        | ArrowFunctionExpression
        | AssignmentExpression
        | AwaitExpression
        | BinaryExpression
        | SimpleCallExpression
        | NewExpression
        | ChainExpression
        | ClassExpression
        | ConditionalExpression
        | FunctionExpression
        | Identifier
        | SimpleLiteral
        | RegExpLiteral
        | BigIntLiteral
        | LogicalExpression
        | MemberExpression
        | MetaProperty
        | ObjectExpression
        | SequenceExpression
        | TaggedTemplateExpression
        | TemplateLiteral
        | ThisExpression
        | UpdateExpression
        | YieldExpression
        | Super,
    ...args: AsArray<T>
) => undefined | R;

method callHooksForExpressionWithFallback

callHooksForExpressionWithFallback: <T, R>(
    hookMap: HookMap<SyncBailHook<T, R>>,
    expr:
        | ImportExpressionImport
        | UnaryExpression
        | ArrayExpression
        | ArrowFunctionExpression
        | AssignmentExpression
        | AwaitExpression
        | BinaryExpression
        | SimpleCallExpression
        | NewExpression
        | ChainExpression
        | ClassExpression
        | ConditionalExpression
        | FunctionExpression
        | Identifier
        | SimpleLiteral
        | RegExpLiteral
        | BigIntLiteral
        | LogicalExpression
        | MemberExpression
        | MetaProperty
        | ObjectExpression
        | SequenceExpression
        | TaggedTemplateExpression
        | TemplateLiteral
        | ThisExpression
        | UpdateExpression
        | YieldExpression
        | Super,
    fallback: (
        arg0: string,
        arg1: string | VariableInfo | ScopeInfo,
        arg2: () => string[]
    ) => any,
    defined: (arg0: string) => any,
    ...args: AsArray<T>
) => undefined | R;

method callHooksForInfo

callHooksForInfo: <T, R>(
    hookMap: HookMap<SyncBailHook<T, R>>,
    info: ExportedVariableInfo,
    ...args: AsArray<T>
) => undefined | R;

method callHooksForInfoWithFallback

callHooksForInfoWithFallback: <T, R>(
    hookMap: HookMap<SyncBailHook<T, R>>,
    info: ExportedVariableInfo,
    fallback: (arg0: string) => any,
    defined: (arg0?: string) => any,
    ...args: AsArray<T>
) => undefined | R;

method callHooksForName

callHooksForName: <T, R>(
    hookMap: HookMap<SyncBailHook<T, R>>,
    name: string,
    ...args: AsArray<T>
) => undefined | R;

method callHooksForNameWithFallback

callHooksForNameWithFallback: <T, R>(
    hookMap: HookMap<SyncBailHook<T, R>>,
    name: string,
    fallback: (arg0: string) => any,
    defined: undefined | (() => any),
    ...args: AsArray<T>
) => undefined | R;

method defineVariable

defineVariable: (name: string) => void;

method destructuringAssignmentPropertiesFor

destructuringAssignmentPropertiesFor: (
    node: Expression
) => undefined | Set<DestructuringAssignmentProperty>;

method detectMode

detectMode: (
    statements: (
        | ImportDeclarationJavascriptParser
        | ExportNamedDeclarationJavascriptParser
        | ExportAllDeclarationJavascriptParser
        | FunctionDeclaration
        | VariableDeclaration
        | ClassDeclaration
        | ExpressionStatement
        | BlockStatement
        | StaticBlock
        | EmptyStatement
        | DebuggerStatement
        | WithStatement
        | ReturnStatement
        | LabeledStatement
        | BreakStatement
        | ContinueStatement
        | IfStatement
        | SwitchStatement
        | ThrowStatement
        | TryStatement
        | WhileStatement
        | DoWhileStatement
        | ForStatement
        | ForInStatement
        | ForOfStatement
        | ExportDefaultDeclaration
        | Directive
    )[]
) => void;

method enterArrayPattern

enterArrayPattern: (
    pattern: ArrayPattern,
    onIdent: (arg0: string, arg1: Identifier) => void
) => void;

method enterAssignmentPattern

enterAssignmentPattern: (
    pattern: AssignmentPattern,
    onIdent: (arg0: string, arg1: Identifier) => void
) => void;

method enterDeclaration

enterDeclaration: (
    declaration: Declaration,
    onIdent: (arg0: string, arg1: Identifier) => void
) => void;

method enterIdentifier

enterIdentifier: (
    pattern: Identifier,
    onIdent: (arg0: string, arg1: Identifier) => void
) => void;

method enterObjectPattern

enterObjectPattern: (
    pattern: ObjectPattern,
    onIdent: (arg0: string, arg1: Identifier) => void
) => void;

method enterPattern

enterPattern: (
    pattern:
        | Identifier
        | MemberExpression
        | ObjectPattern
        | ArrayPattern
        | RestElement
        | AssignmentPattern
        | Property,
    onIdent: (arg0: string, arg1: Identifier) => void
) => void;

method enterPatterns

enterPatterns: (
    patterns: (
        | string
        | Identifier
        | MemberExpression
        | ObjectPattern
        | ArrayPattern
        | RestElement
        | AssignmentPattern
        | Property
    )[],
    onIdent: (arg0: string) => void
) => void;

method enterRestElement

enterRestElement: (
    pattern: RestElement,
    onIdent: (arg0: string, arg1: Identifier) => void
) => void;

method evaluate

evaluate: (source: string) => BasicEvaluatedExpression;

method evaluatedVariable

evaluatedVariable: (tagInfo: TagInfo) => VariableInfo;

method evaluateExpression

evaluateExpression: (
    expression:
        | ImportExpressionImport
        | UnaryExpression
        | ArrayExpression
        | ArrowFunctionExpression
        | AssignmentExpression
        | AwaitExpression
        | BinaryExpression
        | SimpleCallExpression
        | NewExpression
        | ChainExpression
        | ClassExpression
        | ConditionalExpression
        | FunctionExpression
        | Identifier
        | SimpleLiteral
        | RegExpLiteral
        | BigIntLiteral
        | LogicalExpression
        | MemberExpression
        | MetaProperty
        | ObjectExpression
        | SequenceExpression
        | TaggedTemplateExpression
        | TemplateLiteral
        | ThisExpression
        | UpdateExpression
        | YieldExpression
        | SpreadElement
        | PrivateIdentifier
) => BasicEvaluatedExpression;

method extractMemberExpressionChain

extractMemberExpressionChain: (
    expression:
        | ImportExpressionImport
        | UnaryExpression
        | ArrayExpression
        | ArrowFunctionExpression
        | AssignmentExpression
        | AwaitExpression
        | BinaryExpression
        | SimpleCallExpression
        | NewExpression
        | ChainExpression
        | ClassExpression
        | ConditionalExpression
        | FunctionExpression
        | Identifier
        | SimpleLiteral
        | RegExpLiteral
        | BigIntLiteral
        | LogicalExpression
        | MemberExpression
        | MetaProperty
        | ObjectExpression
        | SequenceExpression
        | TaggedTemplateExpression
        | TemplateLiteral
        | ThisExpression
        | UpdateExpression
        | YieldExpression
        | Super
) => {
    members: string[];
    object:
        | ImportExpressionImport
        | UnaryExpression
        | ArrayExpression
        | ArrowFunctionExpression
        | AssignmentExpression
        | AwaitExpression
        | BinaryExpression
        | SimpleCallExpression
        | NewExpression
        | ChainExpression
        | ClassExpression
        | ConditionalExpression
        | FunctionExpression
        | Identifier
        | SimpleLiteral
        | RegExpLiteral
        | BigIntLiteral
        | LogicalExpression
        | MemberExpression
        | MetaProperty
        | ObjectExpression
        | SequenceExpression
        | TaggedTemplateExpression
        | TemplateLiteral
        | ThisExpression
        | UpdateExpression
        | YieldExpression
        | Super;
    membersOptionals: boolean[];
    memberRanges: [number, number][];
};

method getComments

getComments: (range: [number, number]) => Comment[];

method getFreeInfoFromVariable

getFreeInfoFromVariable: (
    varName: string
) => undefined | { name: string; info: string | VariableInfo };

method getMemberExpressionInfo

getMemberExpressionInfo: (
    expression:
        | ImportExpressionImport
        | UnaryExpression
        | ArrayExpression
        | ArrowFunctionExpression
        | AssignmentExpression
        | AwaitExpression
        | BinaryExpression
        | SimpleCallExpression
        | NewExpression
        | ChainExpression
        | ClassExpression
        | ConditionalExpression
        | FunctionExpression
        | Identifier
        | SimpleLiteral
        | RegExpLiteral
        | BigIntLiteral
        | LogicalExpression
        | MemberExpression
        | MetaProperty
        | ObjectExpression
        | SequenceExpression
        | TaggedTemplateExpression
        | TemplateLiteral
        | ThisExpression
        | UpdateExpression
        | YieldExpression
        | Super,
    allowedTypes: number
) => undefined | CallExpressionInfo | ExpressionExpressionInfo;

method getNameForExpression

getNameForExpression: (
    expression: MemberExpression
) =>
    | undefined
    | {
          name: string;
          rootInfo: ExportedVariableInfo;
          getMembers: () => string[];
      };

method getRenameIdentifier

getRenameIdentifier: (
    expr:
        | ImportExpressionImport
        | UnaryExpression
        | ArrayExpression
        | ArrowFunctionExpression
        | AssignmentExpression
        | AwaitExpression
        | BinaryExpression
        | SimpleCallExpression
        | NewExpression
        | ChainExpression
        | ClassExpression
        | ConditionalExpression
        | FunctionExpression
        | Identifier
        | SimpleLiteral
        | RegExpLiteral
        | BigIntLiteral
        | LogicalExpression
        | MemberExpression
        | MetaProperty
        | ObjectExpression
        | SequenceExpression
        | TaggedTemplateExpression
        | TemplateLiteral
        | ThisExpression
        | UpdateExpression
        | YieldExpression
        | SpreadElement
) => undefined | string | VariableInfoInterface;

method getTagData

getTagData: (name: string, tag: symbol) => any;

method getVariableInfo

getVariableInfo: (name: string) => ExportedVariableInfo;

method inBlockScope

inBlockScope: (fn: () => void) => void;

method inClassScope

inClassScope: (hasThis: boolean, params: Identifier[], fn: () => void) => void;

method inFunctionScope

inFunctionScope: (
    hasThis: boolean,
    params: (
        | string
        | Identifier
        | MemberExpression
        | ObjectPattern
        | ArrayPattern
        | RestElement
        | AssignmentPattern
    )[],
    fn: () => void
) => void;

method inScope

inScope: (params: any, fn: () => void) => void;

method isAsiPosition

isAsiPosition: (pos: number) => boolean;

method isPure

isPure: (
    expr:
        | undefined
        | null
        | ImportExpressionImport
        | UnaryExpression
        | ArrayExpression
        | ArrowFunctionExpression
        | AssignmentExpression
        | AwaitExpression
        | BinaryExpression
        | SimpleCallExpression
        | NewExpression
        | ChainExpression
        | ClassExpression
        | ConditionalExpression
        | FunctionExpression
        | Identifier
        | SimpleLiteral
        | RegExpLiteral
        | BigIntLiteral
        | LogicalExpression
        | MemberExpression
        | MetaProperty
        | ObjectExpression
        | SequenceExpression
        | TaggedTemplateExpression
        | TemplateLiteral
        | ThisExpression
        | UpdateExpression
        | YieldExpression
        | PrivateIdentifier
        | FunctionDeclaration
        | VariableDeclaration
        | ClassDeclaration,
    commentsStartPos: number
) => boolean;

method isStatementLevelExpression

isStatementLevelExpression: (expr: Expression) => boolean;

method isVariableDefined

isVariableDefined: (name: string) => boolean;

method parseCalculatedString

parseCalculatedString: (expression: Expression) => {
    range?: [number, number];
    value: string;
    code: boolean;
    conditional: any;
};

method parseCommentOptions

parseCommentOptions: (range: [number, number]) => {
    options: null | Record<string, any>;
    errors: null | (Error & { comment: Comment })[];
};

method parseString

parseString: (expression: Expression) => string;

method preWalkAssignmentExpression

preWalkAssignmentExpression: (expression: AssignmentExpression) => void;

method preWalkBlockStatement

preWalkBlockStatement: (statement: BlockStatement) => void;

method preWalkCatchClause

preWalkCatchClause: (catchClause: CatchClause) => void;

method preWalkDoWhileStatement

preWalkDoWhileStatement: (statement: DoWhileStatement) => void;

method preWalkForInStatement

preWalkForInStatement: (statement: ForInStatement) => void;

method preWalkForOfStatement

preWalkForOfStatement: (statement: ForOfStatement) => void;

method preWalkForStatement

preWalkForStatement: (statement: ForStatement) => void;

method preWalkFunctionDeclaration

preWalkFunctionDeclaration: (statement: FunctionDeclaration) => void;

method preWalkIfStatement

preWalkIfStatement: (statement: IfStatement) => void;

method preWalkLabeledStatement

preWalkLabeledStatement: (statement: LabeledStatement) => void;

method preWalkStatement

preWalkStatement: (
    statement:
        | ImportDeclarationJavascriptParser
        | ExportNamedDeclarationJavascriptParser
        | ExportAllDeclarationJavascriptParser
        | FunctionDeclaration
        | VariableDeclaration
        | ClassDeclaration
        | ExpressionStatement
        | BlockStatement
        | StaticBlock
        | EmptyStatement
        | DebuggerStatement
        | WithStatement
        | ReturnStatement
        | LabeledStatement
        | BreakStatement
        | ContinueStatement
        | IfStatement
        | SwitchStatement
        | ThrowStatement
        | TryStatement
        | WhileStatement
        | DoWhileStatement
        | ForStatement
        | ForInStatement
        | ForOfStatement
        | ExportDefaultDeclaration
) => void;

Walking iterates the statements and expressions and processes them

method preWalkStatements

preWalkStatements: (
    statements: (
        | ImportDeclarationJavascriptParser
        | ExportNamedDeclarationJavascriptParser
        | ExportAllDeclarationJavascriptParser
        | FunctionDeclaration
        | VariableDeclaration
        | ClassDeclaration
        | ExpressionStatement
        | BlockStatement
        | StaticBlock
        | EmptyStatement
        | DebuggerStatement
        | WithStatement
        | ReturnStatement
        | LabeledStatement
        | BreakStatement
        | ContinueStatement
        | IfStatement
        | SwitchStatement
        | ThrowStatement
        | TryStatement
        | WhileStatement
        | DoWhileStatement
        | ForStatement
        | ForInStatement
        | ForOfStatement
        | ExportDefaultDeclaration
    )[]
) => void;

Pre walking iterates the scope for variable declarations

method preWalkSwitchCases

preWalkSwitchCases: (switchCases: SwitchCase[]) => void;

method preWalkSwitchStatement

preWalkSwitchStatement: (statement: SwitchStatement) => void;

method preWalkTryStatement

preWalkTryStatement: (statement: TryStatement) => void;

method preWalkVariableDeclaration

preWalkVariableDeclaration: (statement: VariableDeclaration) => void;

method preWalkVariableDeclarator

preWalkVariableDeclarator: (declarator: VariableDeclarator) => void;

method preWalkWhileStatement

preWalkWhileStatement: (statement: WhileStatement) => void;

method preWalkWithStatement

preWalkWithStatement: (statement: WithStatement) => void;

method setAsiPosition

setAsiPosition: (pos: number) => void;

method setVariable

setVariable: (name: string, variableInfo: ExportedVariableInfo) => void;

method tagVariable

tagVariable: (name: string, tag: symbol, data?: any) => void;

method undefineVariable

undefineVariable: (name: string) => void;

method unsetAsiPosition

unsetAsiPosition: (pos: number) => void;

method walkArrayExpression

walkArrayExpression: (expression: ArrayExpression) => void;

method walkArrayPattern

walkArrayPattern: (pattern: ArrayPattern) => void;

method walkArrowFunctionExpression

walkArrowFunctionExpression: (expression: ArrowFunctionExpression) => void;

method walkAssignmentExpression

walkAssignmentExpression: (expression: AssignmentExpression) => void;

method walkAssignmentPattern

walkAssignmentPattern: (pattern: AssignmentPattern) => void;

method walkAwaitExpression

walkAwaitExpression: (expression: AwaitExpression) => void;

method walkBinaryExpression

walkBinaryExpression: (expression: BinaryExpression) => void;

method walkBlockStatement

walkBlockStatement: (statement: BlockStatement) => void;

method walkCallExpression

walkCallExpression: (expression: CallExpression) => void;

method walkCatchClause

walkCatchClause: (catchClause: CatchClause) => void;

method walkChainExpression

walkChainExpression: (expression: ChainExpression) => void;

method walkClass

walkClass: (classy: ClassExpression | ClassDeclaration) => void;

method walkClassDeclaration

walkClassDeclaration: (statement: ClassDeclaration) => void;

method walkClassExpression

walkClassExpression: (expression: ClassExpression) => void;

method walkConditionalExpression

walkConditionalExpression: (expression: ConditionalExpression) => void;

method walkDoWhileStatement

walkDoWhileStatement: (statement: DoWhileStatement) => void;

method walkExportDefaultDeclaration

walkExportDefaultDeclaration: (statement: ExportDefaultDeclaration) => void;

method walkExportNamedDeclaration

walkExportNamedDeclaration: (
    statement: ExportNamedDeclarationJavascriptParser
) => void;

method walkExpression

walkExpression: (expression?: any) => void;

method walkExpressions

walkExpressions: (
    expressions: (
        | null
        | ImportExpressionImport
        | UnaryExpression
        | ArrayExpression
        | ArrowFunctionExpression
        | AssignmentExpression
        | AwaitExpression
        | BinaryExpression
        | SimpleCallExpression
        | NewExpression
        | ChainExpression
        | ClassExpression
        | ConditionalExpression
        | FunctionExpression
        | Identifier
        | SimpleLiteral
        | RegExpLiteral
        | BigIntLiteral
        | LogicalExpression
        | MemberExpression
        | MetaProperty
        | ObjectExpression
        | SequenceExpression
        | TaggedTemplateExpression
        | TemplateLiteral
        | ThisExpression
        | UpdateExpression
        | YieldExpression
        | SpreadElement
    )[]
) => void;

method walkExpressionStatement

walkExpressionStatement: (statement: ExpressionStatement) => void;

method walkForInStatement

walkForInStatement: (statement: ForInStatement) => void;

method walkForOfStatement

walkForOfStatement: (statement: ForOfStatement) => void;

method walkForStatement

walkForStatement: (statement: ForStatement) => void;

method walkFunctionDeclaration

walkFunctionDeclaration: (statement: FunctionDeclaration) => void;

method walkFunctionExpression

walkFunctionExpression: (expression: FunctionExpression) => void;

method walkIdentifier

walkIdentifier: (expression: Identifier) => void;

method walkIfStatement

walkIfStatement: (statement: IfStatement) => void;

method walkImportExpression

walkImportExpression: (expression: ImportExpressionJavascriptParser) => void;

method walkLabeledStatement

walkLabeledStatement: (statement: LabeledStatement) => void;

method walkLeftRightExpression

walkLeftRightExpression: (
    expression: BinaryExpression | LogicalExpression
) => void;

method walkLogicalExpression

walkLogicalExpression: (expression: LogicalExpression) => void;

method walkMemberExpression

walkMemberExpression: (expression: MemberExpression) => void;

method walkMemberExpressionWithExpressionName

walkMemberExpressionWithExpressionName: (
    expression: any,
    name: string,
    rootInfo: string | VariableInfo,
    members: string[],
    onUnhandled?: any
) => void;

method walkMetaProperty

walkMetaProperty: (metaProperty: MetaProperty) => void;

method walkNestedStatement

walkNestedStatement: (statement: Statement) => void;

Walks a statements that is nested within a parent statement and can potentially be a non-block statement. This enforces the nested statement to never be in ASI position.

method walkNewExpression

walkNewExpression: (expression: NewExpression) => void;

method walkObjectExpression

walkObjectExpression: (expression: ObjectExpression) => void;

method walkObjectPattern

walkObjectPattern: (pattern: ObjectPattern) => void;

method walkPattern

walkPattern: (pattern: Pattern) => void;

method walkProperty

walkProperty: (prop: SpreadElement | Property) => void;

method walkRestElement

walkRestElement: (pattern: RestElement) => void;

method walkReturnStatement

walkReturnStatement: (statement: ReturnStatement) => void;

method walkSequenceExpression

walkSequenceExpression: (expression: SequenceExpression) => void;

method walkSpreadElement

walkSpreadElement: (expression: SpreadElement) => void;

method walkStatement

walkStatement: (
    statement:
        | ImportDeclarationJavascriptParser
        | ExportNamedDeclarationJavascriptParser
        | ExportAllDeclarationJavascriptParser
        | FunctionDeclaration
        | VariableDeclaration
        | ClassDeclaration
        | ExpressionStatement
        | BlockStatement
        | StaticBlock
        | EmptyStatement
        | DebuggerStatement
        | WithStatement
        | ReturnStatement
        | LabeledStatement
        | BreakStatement
        | ContinueStatement
        | IfStatement
        | SwitchStatement
        | ThrowStatement
        | TryStatement
        | WhileStatement
        | DoWhileStatement
        | ForStatement
        | ForInStatement
        | ForOfStatement
        | ExportDefaultDeclaration
) => void;

method walkStatements

walkStatements: (
    statements: (
        | ImportDeclarationJavascriptParser
        | ExportNamedDeclarationJavascriptParser
        | ExportAllDeclarationJavascriptParser
        | FunctionDeclaration
        | VariableDeclaration
        | ClassDeclaration
        | ExpressionStatement
        | BlockStatement
        | StaticBlock
        | EmptyStatement
        | DebuggerStatement
        | WithStatement
        | ReturnStatement
        | LabeledStatement
        | BreakStatement
        | ContinueStatement
        | IfStatement
        | SwitchStatement
        | ThrowStatement
        | TryStatement
        | WhileStatement
        | DoWhileStatement
        | ForStatement
        | ForInStatement
        | ForOfStatement
        | ExportDefaultDeclaration
    )[]
) => void;

Walking iterates the statements and expressions and processes them

method walkSwitchCases

walkSwitchCases: (switchCases: SwitchCase[]) => void;

method walkSwitchStatement

walkSwitchStatement: (statement: SwitchStatement) => void;

method walkTaggedTemplateExpression

walkTaggedTemplateExpression: (expression: TaggedTemplateExpression) => void;

method walkTemplateLiteral

walkTemplateLiteral: (expression: TemplateLiteral) => void;

method walkTerminatingStatement

walkTerminatingStatement: (statement: ReturnStatement | ThrowStatement) => void;

method walkThisExpression

walkThisExpression: (expression: ThisExpression) => void;

method walkThrowStatement

walkThrowStatement: (statement: ThrowStatement) => void;

method walkTryStatement

walkTryStatement: (statement: TryStatement) => void;

method walkUnaryExpression

walkUnaryExpression: (expression: UnaryExpression) => void;

method walkUpdateExpression

walkUpdateExpression: (expression: UpdateExpression) => void;

method walkVariableDeclaration

walkVariableDeclaration: (statement: VariableDeclaration) => void;

method walkWhileStatement

walkWhileStatement: (statement: WhileStatement) => void;

method walkWithStatement

walkWithStatement: (statement: WithStatement) => void;

method walkYieldExpression

walkYieldExpression: (expression: YieldExpression) => void;

namespace library

namespace library {}

class AbstractLibraryPlugin

class AbstractLibraryPlugin<T> {}

constructor

constructor(__0: { pluginName: string; type: string });

property COMMON_LIBRARY_NAME_MESSAGE

static COMMON_LIBRARY_NAME_MESSAGE: string;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

method chunkHash

chunkHash: (
    chunk: Chunk,
    hash: Hash,
    chunkHashContext: ChunkHashContext,
    libraryContext: LibraryContext<T>
) => void;

method embedInRuntimeBailout

embedInRuntimeBailout: (
    module: Module,
    renderContext: RenderContextJavascriptModulesPlugin,
    libraryContext: LibraryContext<T>
) => undefined | string;

method finishEntryModule

finishEntryModule: (
    module: Module,
    entryName: string,
    libraryContext: LibraryContext<T>
) => void;

method parseOptions

parseOptions: (library: LibraryOptions) => false | T;

method render

render: (
    source: Source,
    renderContext: RenderContextJavascriptModulesPlugin,
    libraryContext: LibraryContext<T>
) => Source;

method renderStartup

renderStartup: (
    source: Source,
    module: Module,
    renderContext: StartupRenderContext,
    libraryContext: LibraryContext<T>
) => Source;

method runtimeRequirements

runtimeRequirements: (
    chunk: Chunk,
    set: Set<string>,
    libraryContext: LibraryContext<T>
) => void;

method strictRuntimeBailout

strictRuntimeBailout: (
    renderContext: RenderContextJavascriptModulesPlugin,
    libraryContext: LibraryContext<T>
) => undefined | string;

class EnableLibraryPlugin

class EnableLibraryPlugin {}

constructor

constructor(type: string);

property type

type: string;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

method checkEnabled

static checkEnabled: (compiler: Compiler, type: string) => void;

method setEnabled

static setEnabled: (compiler: Compiler, type: string) => void;

namespace ModuleFilenameHelpers

namespace ModuleFilenameHelpers {}

variable ABSOLUTE_RESOURCE_PATH

let ABSOLUTE_RESOURCE_PATH: string;

variable ALL_LOADERS

let ALL_LOADERS: string;

variable ALL_LOADERS_RESOURCE

let ALL_LOADERS_RESOURCE: string;

variable HASH

let HASH: string;

variable ID

let ID: string;

variable LOADERS

let LOADERS: string;

variable LOADERS_RESOURCE

let LOADERS_RESOURCE: string;

variable NAMESPACE

let NAMESPACE: string;

variable QUERY

let QUERY: string;

variable REGEXP_ABSOLUTE_RESOURCE_PATH

let REGEXP_ABSOLUTE_RESOURCE_PATH: RegExp;

variable REGEXP_ALL_LOADERS

let REGEXP_ALL_LOADERS: RegExp;

variable REGEXP_ALL_LOADERS_RESOURCE

let REGEXP_ALL_LOADERS_RESOURCE: RegExp;

variable REGEXP_HASH

let REGEXP_HASH: RegExp;

variable REGEXP_ID

let REGEXP_ID: RegExp;

variable REGEXP_LOADERS

let REGEXP_LOADERS: RegExp;

variable REGEXP_LOADERS_RESOURCE

let REGEXP_LOADERS_RESOURCE: RegExp;

variable REGEXP_NAMESPACE

let REGEXP_NAMESPACE: RegExp;

variable REGEXP_QUERY

let REGEXP_QUERY: RegExp;

variable REGEXP_RESOURCE

let REGEXP_RESOURCE: RegExp;

variable REGEXP_RESOURCE_PATH

let REGEXP_RESOURCE_PATH: RegExp;

variable RESOURCE

let RESOURCE: string;

variable RESOURCE_PATH

let RESOURCE_PATH: string;

function createFilename

createFilename: (
    module: string | Module,
    options: any,
    __2: {
        requestShortener: RequestShortener;
        chunkGraph: ChunkGraph;
        hashFunction?: string | typeof Hash;
    }
) => string;

function matchObject

matchObject: (obj: MatchObject, str: string) => boolean;

function matchPart

matchPart: (str: string, test: Matcher) => boolean;

function replaceDuplicates

replaceDuplicates: <T>(
    array: T[],
    fn: (
        duplicateItem: T,
        duplicateItemIndex: number,
        numberOfTimesReplaced: number
    ) => T,
    comparator?: (firstElement: T, nextElement: T) => 0 | 1 | -1
) => T[];

namespace node

namespace node {}

class NodeEnvironmentPlugin

class NodeEnvironmentPlugin {}

constructor

constructor(options: { infrastructureLogging: InfrastructureLogging });

property options

options: { infrastructureLogging: InfrastructureLogging };

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class NodeSourcePlugin

class NodeSourcePlugin {}

constructor

constructor();

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class NodeTargetPlugin

class NodeTargetPlugin {}

constructor

constructor();

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class NodeTemplatePlugin

class NodeTemplatePlugin {}

constructor

constructor(options?: NodeTemplatePluginOptions);

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class ReadFileCompileAsyncWasmPlugin

class ReadFileCompileAsyncWasmPlugin {}

constructor

constructor(__0?: ReadFileCompileAsyncWasmPluginOptions);

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class ReadFileCompileWasmPlugin

class ReadFileCompileWasmPlugin {}

constructor

constructor(options?: ReadFileCompileWasmPluginOptions);

property options

options: ReadFileCompileWasmPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

namespace OptimizationStages

namespace OptimizationStages {}

variable STAGE_ADVANCED

let STAGE_ADVANCED: number;

variable STAGE_BASIC

let STAGE_BASIC: number;

variable STAGE_DEFAULT

let STAGE_DEFAULT: number;

namespace optimize

namespace optimize {}

class AggressiveMergingPlugin

class AggressiveMergingPlugin {}

constructor

constructor(options?: AggressiveMergingPluginOptions);

property options

options: AggressiveMergingPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class AggressiveSplittingPlugin

class AggressiveSplittingPlugin {}

constructor

constructor(options?: AggressiveSplittingPluginOptions);

property options

options: AggressiveSplittingPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

method wasChunkRecorded

static wasChunkRecorded: (chunk: Chunk) => boolean;

class LimitChunkCountPlugin

class LimitChunkCountPlugin {}

constructor

constructor(options?: LimitChunkCountPluginOptions);

property options

options: LimitChunkCountPluginOptions;

method apply

apply: (compiler: Compiler) => void;

class MergeDuplicateChunksPlugin

class MergeDuplicateChunksPlugin {}

constructor

constructor(options?: MergeDuplicateChunksPluginOptions);

property options

options: MergeDuplicateChunksPluginOptions;

method apply

apply: (compiler: Compiler) => void;

class MinChunkSizePlugin

class MinChunkSizePlugin {}

constructor

constructor(options: MinChunkSizePluginOptions);

property options

options: MinChunkSizePluginOptions;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class ModuleConcatenationPlugin

class ModuleConcatenationPlugin {}

constructor

constructor();

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class RealContentHashPlugin

class RealContentHashPlugin {}

constructor

constructor(__0: { hashFunction: string | typeof Hash; hashDigest: string });

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

method getCompilationHooks

static getCompilationHooks: (
    compilation: Compilation
) => CompilationHooksRealContentHashPlugin;

class RuntimeChunkPlugin

class RuntimeChunkPlugin {}

constructor

constructor(options: { name?: (entrypoint: { name: string }) => string });

property options

options: {
    name:
        | ((entrypoint: { name: string }) => string)
        | ((entrypoint: Entrypoint) => string);
};

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class SideEffectsFlagPlugin

class SideEffectsFlagPlugin {}

constructor

constructor(analyseSource?: boolean);

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

method moduleHasSideEffects

static moduleHasSideEffects: (
    moduleName: string,
    flagValue: undefined | string | boolean | string[],
    cache: Map<string, RegExp>
) => undefined | boolean;

class SplitChunksPlugin

class SplitChunksPlugin {}

constructor

constructor(options?: OptimizationSplitChunksOptions);

property options

options: SplitChunksOptions;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

namespace optimize.InnerGraph

namespace optimize.InnerGraph {}

variable topLevelSymbolTag

const topLevelSymbolTag: Symbol;

function addUsage

addUsage: (
    state: ParserState,
    symbol: TopLevelSymbol,
    usage: string | true | TopLevelSymbol
) => void;

function addVariableUsage

addVariableUsage: (
    parser: JavascriptParser,
    name: string,
    usage: string | true | TopLevelSymbol
) => void;

function bailout

bailout: (parserState: ParserState) => void;

function enable

enable: (parserState: ParserState) => void;

function getDependencyUsedByExportsCondition

getDependencyUsedByExportsCondition: (
    dependency: Dependency,
    usedByExports: undefined | boolean | Set<string>,
    moduleGraph: ModuleGraph
) => false | ((arg0: ModuleGraphConnection, arg1: RuntimeSpec) => ConnectionState);

function getTopLevelSymbol

getTopLevelSymbol: (state: ParserState) => void | TopLevelSymbol;

function inferDependencyUsage

inferDependencyUsage: (state: ParserState) => void;

function isDependencyUsedByExports

isDependencyUsedByExports: (
    dependency: Dependency,
    usedByExports: boolean | Set<string>,
    moduleGraph: ModuleGraph,
    runtime: RuntimeSpec
) => boolean;

function isEnabled

isEnabled: (parserState: ParserState) => boolean;

function onUsage

onUsage: (
    state: ParserState,
    onUsageCallback: (arg0?: boolean | Set<string>) => void
) => void;

function setTopLevelSymbol

setTopLevelSymbol: (state: ParserState, symbol?: TopLevelSymbol) => void;

function tagTopLevelSymbol

tagTopLevelSymbol: (parser: JavascriptParser, name: string) => TopLevelSymbol;

class TopLevelSymbol

class TopLevelSymbol {}

constructor

constructor(name: string);

property name

name: string;

namespace prefetch

namespace prefetch {}

class ChunkPrefetchPreloadPlugin

class ChunkPrefetchPreloadPlugin {}

constructor

constructor();

method apply

apply: (compiler: Compiler) => void;

namespace runtime

namespace runtime {}

class GetChunkFilenameRuntimeModule

class GetChunkFilenameRuntimeModule extends RuntimeModule {}

constructor

constructor(
    contentType: string,
    name: string,
    global: string,
    getFilenameForChunk: (
        arg0: Chunk
    ) => string | false | ((arg0: PathData, arg1?: AssetInfo) => string),
    allChunks: boolean
);

property allChunks

allChunks: boolean;

property contentType

contentType: string;

property getFilenameForChunk

getFilenameForChunk: (
    arg0: Chunk
) => string | false | ((arg0: PathData, arg1?: AssetInfo) => string);

property global

global: string;

property STAGE_ATTACH

static STAGE_ATTACH: number;

Runtime modules which attach to handlers of other runtime modules

property STAGE_BASIC

static STAGE_BASIC: number;

Runtime modules with simple dependencies on other runtime modules

property STAGE_NORMAL

static STAGE_NORMAL: number;

Runtime modules without any dependencies to other runtime modules

property STAGE_TRIGGER

static STAGE_TRIGGER: number;

Runtime modules which trigger actions on bootstrap

class LoadScriptRuntimeModule

class LoadScriptRuntimeModule extends HelperRuntimeModule {}

constructor

constructor(withCreateScriptUrl?: boolean, withFetchPriority?: boolean);

property STAGE_ATTACH

static STAGE_ATTACH: number;

Runtime modules which attach to handlers of other runtime modules

property STAGE_BASIC

static STAGE_BASIC: number;

Runtime modules with simple dependencies on other runtime modules

property STAGE_NORMAL

static STAGE_NORMAL: number;

Runtime modules without any dependencies to other runtime modules

property STAGE_TRIGGER

static STAGE_TRIGGER: number;

Runtime modules which trigger actions on bootstrap

method getCompilationHooks

static getCompilationHooks: (
    compilation: Compilation
) => LoadScriptCompilationHooks;

namespace RuntimeGlobals

namespace RuntimeGlobals {}

variable amdDefine

let amdDefine: string;

variable amdOptions

let amdOptions: string;

variable asyncModule

let asyncModule: string;

variable baseURI

let baseURI: string;

variable chunkCallback

let chunkCallback: string;

variable chunkName

let chunkName: string;

variable compatGetDefaultExport

let compatGetDefaultExport: string;

variable createFakeNamespaceObject

let createFakeNamespaceObject: string;

variable createScript

let createScript: string;

variable createScriptUrl

let createScriptUrl: string;

variable currentRemoteGetScope

let currentRemoteGetScope: string;

variable definePropertyGetters

let definePropertyGetters: string;

variable ensureChunk

let ensureChunk: string;

variable ensureChunkHandlers

let ensureChunkHandlers: string;

variable ensureChunkIncludeEntries

let ensureChunkIncludeEntries: string;

variable entryModuleId

let entryModuleId: string;

variable exports

let exports: string;

variable externalInstallChunk

let externalInstallChunk: string;

variable getChunkCssFilename

let getChunkCssFilename: string;

variable getChunkScriptFilename

let getChunkScriptFilename: string;

variable getChunkUpdateCssFilename

let getChunkUpdateCssFilename: string;

variable getChunkUpdateScriptFilename

let getChunkUpdateScriptFilename: string;

variable getFullHash

let getFullHash: string;

variable getTrustedTypesPolicy

let getTrustedTypesPolicy: string;

variable getUpdateManifestFilename

let getUpdateManifestFilename: string;

variable global

let global: string;

variable harmonyModuleDecorator

let harmonyModuleDecorator: string;

variable hasCssModules

let hasCssModules: string;

variable hasFetchPriority

let hasFetchPriority: string;

variable hasOwnProperty

let hasOwnProperty: string;

variable hmrDownloadManifest

let hmrDownloadManifest: string;

variable hmrDownloadUpdateHandlers

let hmrDownloadUpdateHandlers: string;

variable hmrInvalidateModuleHandlers

let hmrInvalidateModuleHandlers: string;

variable hmrModuleData

let hmrModuleData: string;

variable hmrRuntimeStatePrefix

let hmrRuntimeStatePrefix: string;

variable initializeSharing

let initializeSharing: string;

variable instantiateWasm

let instantiateWasm: string;

variable interceptModuleExecution

let interceptModuleExecution: string;

variable loadScript

let loadScript: string;

variable makeNamespaceObject

let makeNamespaceObject: string;

variable module

let module: string;

variable moduleCache

let moduleCache: string;

variable moduleFactories

let moduleFactories: string;

variable moduleFactoriesAddOnly

let moduleFactoriesAddOnly: string;

variable moduleId

let moduleId: string;

variable moduleLoaded

let moduleLoaded: string;

variable nodeModuleDecorator

let nodeModuleDecorator: string;

variable onChunksLoaded

let onChunksLoaded: string;

variable prefetchChunk

let prefetchChunk: string;

variable prefetchChunkHandlers

let prefetchChunkHandlers: string;

variable preloadChunk

let preloadChunk: string;

variable preloadChunkHandlers

let preloadChunkHandlers: string;

variable publicPath

let publicPath: string;

variable relativeUrl

let relativeUrl: string;

variable require

let require: string;

variable requireScope

let requireScope: string;

variable returnExportsFromRuntime

let returnExportsFromRuntime: string;

variable runtimeId

let runtimeId: string;

variable scriptNonce

let scriptNonce: string;

variable shareScopeMap

let shareScopeMap: string;

variable startup

let startup: string;

variable startupEntrypoint

let startupEntrypoint: string;

variable startupNoDefault

let startupNoDefault: string;

variable startupOnlyAfter

let startupOnlyAfter: string;

variable startupOnlyBefore

let startupOnlyBefore: string;

variable system

let system: string;

variable systemContext

let systemContext: string;

variable thisAsExports

let thisAsExports: string;

variable uncaughtErrorHandler

let uncaughtErrorHandler: string;

variable wasmInstances

let wasmInstances: string;

namespace sharing {}

scope: <T>(
    scope: string,
    options: ContainerOptionsFormat<T>
) => Record<string, string | string[] | T>;

class ConsumeSharedPlugin {}

constructor(options: ConsumeSharedPluginOptions);

apply: (compiler: Compiler) => void;

Apply the plugin

class ProvideSharedPlugin {}

constructor(options: ProvideSharedPluginOptions);

apply: (compiler: Compiler) => void;

Apply the plugin

class SharePlugin {}

constructor(options: SharePluginOptions);

apply: (compiler: Compiler) => void;

Apply the plugin

namespace sources

namespace sources {}

class CachedSource

class CachedSource extends Source {}

constructor

constructor(source: Source);

constructor

constructor(source: Source | (() => Source), cachedData?: any);

method getCachedData

getCachedData: () => any;

method original

original: () => Source;

method originalLazy

originalLazy: () => Source | (() => Source);

class CompatSource

class CompatSource extends Source {}

constructor

constructor(sourceLike: SourceLike);

method from

static from: (sourceLike: SourceLike) => Source;

class ConcatSource

class ConcatSource extends Source {}

constructor

constructor(...args: (string | Source)[]);

method add

add: (item: string | Source) => void;

method addAllSkipOptimizing

addAllSkipOptimizing: (items: Source[]) => void;

method getChildren

getChildren: () => Source[];

class OriginalSource

class OriginalSource extends Source {}

constructor

constructor(source: any, name: string);

method getName

getName: () => string;

class PrefixSource

class PrefixSource extends Source {}

constructor

constructor(prefix: string, source: string | Source);

method getPrefix

getPrefix: () => string;

method original

original: () => Source;

class RawSource

class RawSource extends Source {}

constructor

constructor(source: any, convertToString?: boolean);

method isBuffer

isBuffer: () => boolean;

class ReplaceSource

class ReplaceSource extends Source {}

constructor

constructor(source: Source, name?: string);

method getName

getName: () => string;

method getReplacements

getReplacements: () => {
    start: number;
    end: number;
    content: string;
    insertIndex: number;
    name: string;
}[];

method insert

insert: (pos: number, newValue: string, name?: string) => void;

method original

original: () => string;

method replace

replace: (start: number, end: number, newValue: string, name?: string) => void;

class SizeOnlySource

class SizeOnlySource extends Source {}

constructor

constructor(size: number);

class Source

class Source {}

constructor

constructor();

method buffer

buffer: () => Buffer;

method map

map: (options?: MapOptions) => null | RawSourceMap;

method size

size: () => number;

method source

source: () => string | Buffer;

method sourceAndMap

sourceAndMap: (options?: MapOptions) => { source: string | Buffer; map: Object };

method updateHash

updateHash: (hash: Hash) => void;

class SourceMapSource

class SourceMapSource extends Source {}

constructor

constructor(
    source: any,
    name: string,
    sourceMap: any,
    originalSource?: any,
    innerSourceMap?: any,
    removeOriginalSource?: boolean
);

method getArgsAsBuffers

getArgsAsBuffers: () => [
    Buffer,
    string,
    Buffer,
    undefined | Buffer,
    undefined | Buffer,
    boolean
];

namespace util

namespace util {}

function cleverMerge

cleverMerge: <T, O>(first?: T, second?: O) => T | O | (T & O);

function compileBooleanMatcher

compileBooleanMatcher: typeof compileBooleanMatcher;

function createHash

createHash: (algorithm: Algorithm) => Hash;

class LazySet

class LazySet<T> {}

constructor

constructor(iterable?: Iterable<T>);

property size

readonly size: number;

method [Symbol.iterator]

[Symbol.iterator]: () => IterableIterator<T>;

method add

add: (item: T) => LazySet<T>;

method addAll

addAll: (iterable: LazySet<T> | Iterable<T>) => LazySet<T>;

method clear

clear: () => void;

method delete

delete: (value: T) => boolean;

method deserialize

static deserialize: <T>(__0: ObjectDeserializerContext) => LazySet<T>;

method entries

entries: () => IterableIterator<[T, T]>;

method forEach

forEach: (
    callbackFn: (arg0: T, arg1: T, arg2: Set<T>) => void,
    thisArg?: any
) => void;

method has

has: (item: T) => boolean;

method keys

keys: () => IterableIterator<T>;

method serialize

serialize: (__0: ObjectSerializerContext) => void;

method values

values: () => IterableIterator<T>;

namespace util.comparators

namespace util.comparators {}

variable compareChunks

let compareChunks: ParameterizedComparator<ChunkGraph, Chunk>;

variable compareModulesById

let compareModulesById: ParameterizedComparator<ChunkGraph, Module>;

variable compareModulesByIdOrIdentifier

let compareModulesByIdOrIdentifier: ParameterizedComparator<ChunkGraph, Module>;

variable compareModulesByPostOrderIndexOrIdentifier

let compareModulesByPostOrderIndexOrIdentifier: ParameterizedComparator<
    ModuleGraph,
    Module
>;

variable compareModulesByPreOrderIndexOrIdentifier

let compareModulesByPreOrderIndexOrIdentifier: ParameterizedComparator<
    ModuleGraph,
    Module
>;

function compareChunkGroupsByIndex

compareChunkGroupsByIndex: (a: ChunkGroup, b: ChunkGroup) => 0 | 1 | -1;

function compareChunksById

compareChunksById: (a: Chunk, b: Chunk) => 0 | 1 | -1;

function compareChunksNatural

compareChunksNatural: (chunkGraph: ChunkGraph) => Comparator<Chunk>;

function compareIds

compareIds: (a: string | number, b: string | number) => 0 | 1 | -1;

function compareIterables

compareIterables: <T>(
    elementComparator: Comparator<T>
) => Comparator<Iterable<T>>;

function compareLocations

compareLocations: (a: DependencyLocation, b: DependencyLocation) => 0 | 1 | -1;

function compareModulesByIdentifier

compareModulesByIdentifier: (a: Module, b: Module) => 0 | 1 | -1;

function compareNumbers

compareNumbers: (a: number, b: number) => 0 | 1 | -1;

function compareSelect

compareSelect: <T, R>(
    getter: Selector<T, R>,
    comparator: Comparator<R>
) => Comparator<T>;

function compareStrings

compareStrings: (a: string, b: string) => 0 | 1 | -1;

function compareStringsNumeric

compareStringsNumeric: (a: string, b: string) => 0 | 1 | -1;

function concatComparators

concatComparators: <T>(
    c1: Comparator<T>,
    c2: Comparator<T>,
    ...cRest: Comparator<T>[]
) => Comparator<T>;

function keepOriginalOrder

keepOriginalOrder: <T>(iterable: Iterable<T>) => Comparator<T>;

namespace util.compileBooleanMatcher

namespace util.compileBooleanMatcher {}

function fromLists

fromLists: (
    positiveItems: string[],
    negativeItems: string[]
) => (arg0: string) => string;

function itemsToRegexp

itemsToRegexp: (itemsArr: string[]) => string;

namespace util.runtime

namespace util.runtime {}

function compareRuntime

compareRuntime: (a: RuntimeSpec, b: RuntimeSpec) => 0 | 1 | -1;

function filterRuntime

filterRuntime: (
    runtime: RuntimeSpec,
    filter: (arg0: RuntimeSpec) => boolean
) => undefined | string | boolean | SortableSet<string>;

function forEachRuntime

forEachRuntime: (
    runtime: RuntimeSpec,
    fn: (arg0?: string) => void,
    deterministicOrder?: boolean
) => void;

function getEntryRuntime

getEntryRuntime: (
    compilation: Compilation,
    name: string,
    options?: EntryOptions
) => RuntimeSpec;

function getRuntimeKey

getRuntimeKey: (runtime: RuntimeSpec) => string;

function intersectRuntime

intersectRuntime: (a: RuntimeSpec, b: RuntimeSpec) => RuntimeSpec;

function keyToRuntime

keyToRuntime: (key: string) => RuntimeSpec;

function mergeRuntime

mergeRuntime: (a: RuntimeSpec, b: RuntimeSpec) => RuntimeSpec;

function mergeRuntimeCondition

mergeRuntimeCondition: (
    a: RuntimeCondition,
    b: RuntimeCondition,
    runtime: RuntimeSpec
) => RuntimeCondition;

function mergeRuntimeConditionNonFalse

mergeRuntimeConditionNonFalse: (
    a: undefined | string | true | SortableSet<string>,
    b: undefined | string | true | SortableSet<string>,
    runtime: RuntimeSpec
) => undefined | string | true | SortableSet<string>;

function mergeRuntimeOwned

mergeRuntimeOwned: (a: RuntimeSpec, b: RuntimeSpec) => RuntimeSpec;

function runtimeConditionToString

runtimeConditionToString: (runtimeCondition: RuntimeCondition) => string;

function runtimeEqual

runtimeEqual: (a: RuntimeSpec, b: RuntimeSpec) => boolean;

function runtimeToString

runtimeToString: (runtime: RuntimeSpec) => string;

function subtractRuntime

subtractRuntime: (a: RuntimeSpec, b: RuntimeSpec) => RuntimeSpec;

function subtractRuntimeCondition

subtractRuntimeCondition: (
    a: RuntimeCondition,
    b: RuntimeCondition,
    runtime: RuntimeSpec
) => RuntimeCondition;

class RuntimeSpecMap

class RuntimeSpecMap<T> {}

constructor

constructor(clone?: RuntimeSpecMap<T>);

property size

readonly size: number;

method delete

delete: (runtime: RuntimeSpec) => void;

method get

get: (runtime: RuntimeSpec) => undefined | T;

method has

has: (runtime: RuntimeSpec) => boolean;

method keys

keys: () => RuntimeSpec[];

method provide

provide: (runtime: RuntimeSpec, computer: () => any) => any;

method set

set: (runtime: RuntimeSpec, value: T) => void;

method update

update: (runtime: RuntimeSpec, fn: (arg0?: T) => T) => void;

method values

values: () => IterableIterator<T>;

class RuntimeSpecSet

class RuntimeSpecSet {}

constructor

constructor(iterable?: Iterable<RuntimeSpec>);

property size

readonly size: number;

method [Symbol.iterator]

[Symbol.iterator]: () => IterableIterator<RuntimeSpec>;

method add

add: (runtime: RuntimeSpec) => void;

method has

has: (runtime: RuntimeSpec) => boolean;

namespace util.serialization

namespace util.serialization {}

variable buffersSerializer

const buffersSerializer: Serializer;

variable MEASURE_END_OPERATION

const MEASURE_END_OPERATION: Symbol;

variable MEASURE_START_OPERATION

const MEASURE_START_OPERATION: Symbol;

variable NOT_SERIALIZABLE

const NOT_SERIALIZABLE: {};

function createFileSerializer

createFileSerializer: (
    fs: IntermediateFileSystem,
    hashFunction: string | typeof Hash
) => Serializer;

function register

register: (
    Constructor: Constructor,
    request: string,
    name: null | string,
    serializer: ObjectSerializer
) => void;

function registerLoader

registerLoader: (regExp: RegExp, loader: (arg0: string) => boolean) => void;

function registerNotSerializable

registerNotSerializable: (Constructor: Constructor) => void;

namespace wasm

namespace wasm {}

class AsyncWebAssemblyModulesPlugin

class AsyncWebAssemblyModulesPlugin {}

constructor

constructor(options: AsyncWebAssemblyModulesPluginOptions);

property options

options: AsyncWebAssemblyModulesPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

method getCompilationHooks

static getCompilationHooks: (
    compilation: Compilation
) => CompilationHooksAsyncWebAssemblyModulesPlugin;

method renderModule

renderModule: (
    module: Module,
    renderContext: WebAssemblyRenderContext,
    hooks: CompilationHooksAsyncWebAssemblyModulesPlugin
) => Source;

class EnableWasmLoadingPlugin

class EnableWasmLoadingPlugin {}

constructor

constructor(type: string);

property type

type: string;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

method checkEnabled

static checkEnabled: (compiler: Compiler, type: string) => void;

method setEnabled

static setEnabled: (compiler: Compiler, type: string) => void;

namespace web

namespace web {}

class CssLoadingRuntimeModule

class CssLoadingRuntimeModule extends RuntimeModule {}

constructor

constructor(runtimeRequirements: ReadonlySet<string>);

property STAGE_ATTACH

static STAGE_ATTACH: number;

Runtime modules which attach to handlers of other runtime modules

property STAGE_BASIC

static STAGE_BASIC: number;

Runtime modules with simple dependencies on other runtime modules

property STAGE_NORMAL

static STAGE_NORMAL: number;

Runtime modules without any dependencies to other runtime modules

property STAGE_TRIGGER

static STAGE_TRIGGER: number;

Runtime modules which trigger actions on bootstrap

method getCompilationHooks

static getCompilationHooks: (
    compilation: Compilation
) => CssLoadingRuntimeModulePluginHooks;

class FetchCompileAsyncWasmPlugin

class FetchCompileAsyncWasmPlugin {}

constructor

constructor();

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class FetchCompileWasmPlugin

class FetchCompileWasmPlugin {}

constructor

constructor(options?: FetchCompileWasmPluginOptions);

property options

options: FetchCompileWasmPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

class JsonpChunkLoadingRuntimeModule

class JsonpChunkLoadingRuntimeModule extends RuntimeModule {}

constructor

constructor(runtimeRequirements: ReadonlySet<string>);

property STAGE_ATTACH

static STAGE_ATTACH: number;

Runtime modules which attach to handlers of other runtime modules

property STAGE_BASIC

static STAGE_BASIC: number;

Runtime modules with simple dependencies on other runtime modules

property STAGE_NORMAL

static STAGE_NORMAL: number;

Runtime modules without any dependencies to other runtime modules

property STAGE_TRIGGER

static STAGE_TRIGGER: number;

Runtime modules which trigger actions on bootstrap

method getCompilationHooks

static getCompilationHooks: (
    compilation: Compilation
) => JsonpCompilationPluginHooks;

class JsonpTemplatePlugin

class JsonpTemplatePlugin {}

constructor

constructor();

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

method getCompilationHooks

static getCompilationHooks: (
    compilation: Compilation
) => JsonpCompilationPluginHooks;

namespace webworker

namespace webworker {}

class WebWorkerTemplatePlugin

class WebWorkerTemplatePlugin {}

constructor

constructor();

method apply

apply: (compiler: Compiler) => void;

Apply the plugin

Package Files (1)

types.d.ts

Dev Dependencies (77)

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/webpack.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/webpack)

HTML

<a href="https://www.jsdocs.io/package/webpack"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 1 month ago.
Package analyzed in 22260 ms.
Missing or incorrect documentation? Open an issue for this package.

webpack

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Namespaces

Variables

variable CIRCULAR_CONNECTION

variable MEASURE_END_OPERATION

variable MEASURE_START_OPERATION

variable TOMBSTONE

variable topLevelSymbolTag

variable TRANSITIVE

variable TRANSITIVE_ONLY

variable UNDEFINED_MARKER

variable UsageState

variable version

variable webpack

Functions

function exports

function validate

function validateSchema

Classes

class AsyncDependenciesBlock

constructor

property chunkName

property groupOptions

property loc

property module

property request

class AutomaticPrefetchPlugin

constructor

method apply

class BannerPlugin

constructor

property banner

property options

method apply

class Cache

constructor

property hooks

property STAGE_DEFAULT

property STAGE_DISK

property STAGE_MEMORY

property STAGE_NETWORK

method beginIdle

method endIdle

method get

method shutdown

method store

method storeBuildDependencies

class Chunk

constructor

property auxiliaryFiles

property chunkReason

property contentHash

property cssFilenameTemplate

property debugId

property entryModule

property extraAsync

property filenameTemplate

property files

property groupsIterable

property hash

property id

property idNameHints

property ids

property modulesIterable

property name

property preventIntegration

property rendered

property renderedHash

property runtime

method addGroup

method addModule

method canBeInitial