webpack

webpack

Version 5.109.2
Published 5 days ago
8.12 MB
20 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_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: _functionWebpack;

Functions

function defineConfig

defineConfig: <T extends DefineConfigInput>(config: T) => T;

function exports

exports: typeof exports;

function validate

validate: (configuration: Configuration | MultiConfiguration) => 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: string | GroupOptionsAsyncDependenciesBlock,
    loc?: SyntheticDependencyLocation | RealDependencyLocation,
    request?: string
);

property chunkName

chunkName?: string;

property circular

readonly circular: boolean;

property groupOptions

groupOptions: GroupOptionsAsyncDependenciesBlock;

property loc

loc?: SyntheticDependencyLocation | RealDependencyLocation;

property module

module: any;

property request

request?: string;

class AutomaticPrefetchPlugin

class AutomaticPrefetchPlugin {}

Records modules from one compilation and adds them back as prefetch dependencies in the next compilation.

constructor

constructor();

method apply

apply: (compiler: Compiler) => void;

Registers hooks that remember previously built normal modules and enqueue them as PrefetchDependency requests during the next make phase.

class BannerPlugin

class BannerPlugin {}

Prepends or appends banner text to emitted assets that match the configured file filters.

constructor

constructor(options: BannerPluginArgument);

Normalizes banner options and compiles the configured banner source into a function that can render per-asset banner text.

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

property options

options: BannerPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Validates the configured options and injects rendered banner comments into matching compilation assets at the configured process-assets stage.

class Cache

class CacheClass {}

Abstract cache interface backed by tapable hooks for reading, writing, idle transitions, and shutdown across webpack cache implementations.

constructor

constructor();

Initializes the cache lifecycle hooks implemented by cache backends.

property hooks

hooks: {
    get: AsyncSeriesBailHook<[string, Etag, GotHandler<any>[]], 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;

Signals that webpack is entering an idle phase and cache backends may flush or compact pending work.

method endIdle

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

Signals that webpack is leaving the idle phase and waits for cache backends to finish any asynchronous resume work.

method get

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

Retrieves a cached value and lets registered gotHandlers observe the result before the caller receives it.

method shutdown

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

Shuts down every registered cache backend and waits for cleanup to finish.

method store

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

Stores a cache entry for the identifier and etag through the registered cache backend hooks.

method storeBuildDependencies

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

Persists the set of build dependencies required to determine whether the cache can be restored in a future compilation.

class Chunk

class Chunk {}

A Chunk is a unit of encapsulation for Modules. Chunks are "rendered" into bundles that get emitted when the build completes.

constructor

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

Creates an instance of Chunk.

property auxiliaryFiles

auxiliaryFiles: Set<string>;

property chunkReason

chunkReason?: string;

property contentHash

contentHash: Record<string, string>;

property contentHashFull

contentHashFull: Record<string, string>;

property cssFilenameTemplate

cssFilenameTemplate?:
    | string
    | ((pathData: PathDataChunk, assetInfo?: AssetInfo) => string);

property debugId

debugId: number;

property entryModule

readonly entryModule: Module;

Returns entry module.
Deprecated

property extraAsync

extraAsync: boolean;

property filenameTemplate

filenameTemplate?:
    | string
    | ((pathData: PathDataChunk, assetInfo?: AssetInfo) => string);

property files

files: Set<string>;

property groupsIterable

readonly groupsIterable: SortableSet<ChunkGroup>;

Gets groups iterable.

property hash

hash?: string;

property id

id: string | number;

property idNameHints

idNameHints: SortableSet<string>;

property ids

ids: ChunkId[];

property modulesIterable

readonly modulesIterable: Iterable<Module>;

Deprecated

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;

Adds the provided chunk group to the chunk.

method addModule

addModule: (module: Module) => boolean;

Adds the provided module to the chunk.
Deprecated

method canBeInitial

canBeInitial: () => boolean;

Checks whether it can be initial.

method canBeIntegrated

canBeIntegrated: (otherChunk: Chunk) => boolean;

Checks whether this chunk can be integrated with another chunk.
Deprecated

method compareTo

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

Compares this chunk with another chunk.
Deprecated

method containsModule

containsModule: (module: Module) => boolean;

Checks whether this chunk contains the module.
Deprecated

method disconnectFromGroups

disconnectFromGroups: () => void;

Disconnects from groups.

method getAllAsyncChunks

getAllAsyncChunks: () => Set<Chunk>;

Gets all async chunks.

method getAllInitialChunks

getAllInitialChunks: () => Set<Chunk>;

Gets all initial chunks.

method getAllReferencedAsyncEntrypoints

getAllReferencedAsyncEntrypoints: () => Set<Entrypoint>;

Gets all referenced async entrypoints.

method getAllReferencedChunks

getAllReferencedChunks: () => Set<Chunk>;

Gets all referenced chunks.

method getChildIdsByOrders

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

Gets child ids by orders.

method getChildIdsByOrdersMap

getChildIdsByOrdersMap: (
    chunkGraph: ChunkGraph,
    includeDirectChildren?: boolean,
    filterFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean
) => ChunkChildIdsByOrdersMapByData;

Gets child ids by orders map.

method getChildrenOfTypeInOrder

getChildrenOfTypeInOrder: (
    chunkGraph: ChunkGraph,
    type: string
) => undefined | ChunkChildOfTypeInOrder[];

Gets children of type in order.

method getChunkMaps

getChunkMaps: (realHash: boolean) => ChunkMaps;

Returns the chunk map information.
Deprecated

method getChunkModuleMaps

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

Gets chunk module maps.
Deprecated

method getEntryOptions

getEntryOptions: () => undefined | EntryOptions;

Gets entry options.

method getModules

getModules: () => Module[];

Returns the modules for this chunk.
Deprecated

method getNumberOfGroups

getNumberOfGroups: () => number;

Gets number of groups.

method getNumberOfModules

getNumberOfModules: () => number;

Gets the number of modules in this chunk.
Deprecated

method hasAsyncChunks

hasAsyncChunks: () => boolean;

Checks whether this chunk has async chunks.

method hasChildByOrder

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

Checks whether this chunk contains the chunk graph.

method hasEntryModule

hasEntryModule: () => boolean;

Checks whether this chunk has an entry module.
Deprecated

method hasModuleInGraph

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

Checks whether this chunk contains a matching module in the graph.
Deprecated

method hasRuntime

hasRuntime: () => boolean;

Checks whether this chunk has runtime.

method integrate

integrate: (otherChunk: Chunk) => boolean;

Integrates another chunk into this chunk when possible.
Deprecated

method integratedSize

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

Returns the integrated size with another chunk.
Deprecated

method isEmpty

isEmpty: () => boolean;

Checks whether this chunk is empty.
Deprecated

method isInGroup

isInGroup: (chunkGroup: ChunkGroup) => boolean;

Checks whether this chunk is in group.

method isOnlyInitial

isOnlyInitial: () => boolean;

Checks whether this chunk is only initial.

method modulesSize

modulesSize: () => number;

Returns the total size of all modules in this chunk.
Deprecated

method moveModule

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

Moves a module from this chunk to another chunk.
Deprecated

method remove

remove: () => void;

Removes this chunk from the chunk graph and chunk groups.
Deprecated

method removeGroup

removeGroup: (chunkGroup: ChunkGroup) => void;

Removes the provided chunk group from the chunk.

method removeModule

removeModule: (module: Module) => void;

Removes the provided module from the chunk.
Deprecated

method size

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

Returns the estimated size for the requested source type.
Deprecated

method split

split: (newChunk: Chunk) => void;

Processes the provided new chunk.

method updateHash

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

Updates the hash with the data contributed by this instance.

class ChunkGraph

class ChunkGraph {}

constructor

constructor(moduleGraph: ModuleGraph, hashFunction?: HashFunction);

Creates an instance of ChunkGraph.

property moduleGraph

moduleGraph: ModuleGraph;

method addChunkRuntimeRequirements

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

Adds chunk runtime requirements.

method addDependentHashModuleToChunk

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

Adds dependent hash module to chunk.

method addFullHashModuleToChunk

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

Adds full hash module to chunk.

method addModuleRuntimeRequirements

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

Adds module runtime requirements.

method addTreeRuntimeRequirements

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

Adds tree runtime requirements.

method attachDependentHashModules

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

Attach dependent hash modules.

method attachFullHashModules

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

Attach full hash modules.

method attachModules

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

Processes the provided chunk.

method attachRuntimeModules

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

Attach runtime modules.

method canChunksBeIntegrated

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

Checks whether it can chunks be integrated.

method clearChunkGraphForChunk

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

Clear chunk graph for chunk.
Deprecated

method clearChunkGraphForModule

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

Clear chunk graph for module.
Deprecated

method compareChunks

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

Compares the provided values and returns their ordering.

method connectBlockAndChunkGroup

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

Connects block and chunk group.

method connectChunkAndEntryModule

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

Connects chunk and entry module.

method connectChunkAndModule

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

Connects chunk and module.

method connectChunkAndRuntimeModule

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

Connects chunk and runtime module.

method disconnectChunk

disconnectChunk: (chunk: Chunk) => void;

Processes the provided chunk.

method disconnectChunkAndEntryModule

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

Disconnects chunk and entry module.

method disconnectChunkAndModule

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

Disconnects chunk and module.

method disconnectChunkAndRuntimeModule

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

Disconnects chunk and runtime module.

method disconnectChunkGroup

disconnectChunkGroup: (chunkGroup: ChunkGroup) => void;

Disconnects chunk group.

method disconnectEntries

disconnectEntries: (chunk: Chunk) => void;

Disconnects entries.

method disconnectEntryModule

disconnectEntryModule: (module: Module) => void;

Disconnects entry module.

method getBlockChunkGroup

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

Gets block chunk group.

method getChunkConditionMap

getChunkConditionMap: (
    chunk: Chunk,
    filterFn: (c: Chunk, chunkGraph: ChunkGraph) => boolean
) => ChunkConditionMap;

Gets chunk condition map.

method getChunkDependentHashModulesIterable

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

Gets chunk dependent hash modules iterable.

method getChunkEntryDependentChunksIterable

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

Gets chunk entry dependent chunks iterable.

method getChunkEntryModulesIterable

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

Gets chunk entry modules iterable.

method getChunkEntryModulesWithChunkGroupIterable

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

Gets chunk entry modules with chunk group iterable.

method getChunkFullHashModulesIterable

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

Gets chunk full hash modules iterable.

method getChunkFullHashModulesSet

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

Gets chunk full hash modules set.

method getChunkGraphForChunk

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

Gets chunk graph for chunk.
Deprecated

method getChunkGraphForModule

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

Gets chunk graph for module.
Deprecated

method getChunkModuleIdMap

getChunkModuleIdMap: (
    chunk: Chunk,
    filterFn: (m: Module) => boolean,
    includeAllChunks?: boolean
) => ChunkModuleIdMapEs5Alias_2;

Gets chunk module id map.

method getChunkModuleRenderedHashMap

getChunkModuleRenderedHashMap: (
    chunk: Chunk,
    filterFn: (m: Module) => boolean,
    hashLength?: number,
    includeAllChunks?: boolean
) => ChunkModuleHashMap;

Gets chunk module rendered hash map.

method getChunkModules

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

Gets chunk modules.

method getChunkModulesIterable

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

Gets chunk modules iterable.

method getChunkModulesIterableBySourceType

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

Gets chunk modules iterable by source type.

method getChunkModuleSourceTypes

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

Gets chunk module source types.

method getChunkModulesSize

getChunkModulesSize: (chunk: Chunk) => number;

Gets chunk modules size.

method getChunkModulesSizes

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

Gets chunk modules sizes.

method getChunkRootModules

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

Gets chunk root modules.

method getChunkRuntimeModulesInOrder

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

Gets chunk runtime modules in order.

method getChunkRuntimeModulesIterable

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

Gets chunk runtime modules iterable.

method getChunkRuntimeRequirements

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

Gets chunk runtime requirements.

method getChunkSize

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

Returns total size of the chunk.

method getIntegratedChunksSize

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

Gets integrated chunks size.

method getModuleChunks

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

Gets module chunks.

method getModuleChunksIterable

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

Gets module chunks iterable.

method getModuleGraphHash

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

Gets module graph hash.

method getModuleGraphHashBigInt

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

Gets module graph hash big int.

method getModuleHash

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

Returns hash.

method getModuleId

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

Returns the id of the module.

method getModuleRuntimeRequirements

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

Gets module runtime requirements.

method getModuleRuntimes

getModuleRuntimes: (module: Module) => RuntimeSpecSet;

Gets module runtimes.

method getModuleSourceTypes

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

Gets module source types.

method getNumberOfChunkFullHashModules

getNumberOfChunkFullHashModules: (chunk: Chunk) => number;

Gets number of chunk full hash modules.

method getNumberOfChunkModules

getNumberOfChunkModules: (chunk: Chunk) => number;

Gets number of chunk modules.

method getNumberOfEntryModules

getNumberOfEntryModules: (chunk: Chunk) => number;

Gets number of entry modules.

method getNumberOfModuleChunks

getNumberOfModuleChunks: (module: Module) => number;

Gets number of module chunks.

method getNumberOfRuntimeModules

getNumberOfRuntimeModules: (chunk: Chunk) => number;

Gets number of runtime modules.

method getOrderedChunkModules

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

Gets ordered chunk modules.

method getOrderedChunkModulesIterable

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

Gets ordered chunk modules iterable.

method getOrderedChunkModulesIterableBySourceType

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

Gets ordered chunk modules iterable by source type.

method getOrderedModuleChunksIterable

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

Gets ordered module chunks iterable.

method getRenderedModuleHash

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

Gets rendered module hash.

method getRuntimeChunkDependentChunksIterable

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

Gets runtime chunk dependent chunks iterable.

method getRuntimeId

getRuntimeId: (runtime: string) => RuntimeId;

Returns the id of the runtime.

method getTreeRuntimeRequirements

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

Gets tree runtime requirements.

method hasChunkEntryDependentChunks

hasChunkEntryDependentChunks: (chunk: Chunk) => boolean;

Checks whether this chunk graph contains the chunk.

method hasModuleHashes

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

Checks whether this chunk graph contains the module.

method hasModuleInGraph

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

Checks whether this chunk graph contains the chunk.

method integrateChunks

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

Processes the provided chunk a.

method isEntryModule

isEntryModule: (module: Module) => boolean;

Checks whether this chunk graph is entry module.

method isEntryModuleInChunk

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

Checks whether this chunk graph is entry module in chunk.

method isModuleInChunk

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

Checks whether this chunk graph is module in chunk.

method isModuleInChunkGroup

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

Checks whether this chunk graph is module in chunk group.

method replaceModule

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

Processes the provided old module.

method setChunkGraphForChunk

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

Sets chunk graph for chunk.
Deprecated

method setChunkGraphForModule

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

Sets chunk graph for module.
Deprecated

method setChunkModuleSourceTypes

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

Sets chunk module source types.

method setModuleHashes

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

Sets module hashes.

method setModuleId

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

Updates module id using the provided module.

method setRuntimeId

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

Updates runtime id using the provided runtime.

method upgradeDependentToFullHashModules

upgradeDependentToFullHashModules: (chunk: Chunk) => void;

Upgrade dependent to full hash modules.

class ChunkGroup

abstract class ChunkGroup {}

Represents a connected group of chunks along with the parent/child relationships, async blocks, and traversal metadata webpack tracks for it.

property asyncEntrypointsIterable

readonly asyncEntrypointsIterable: SortableSet<ChunkGroup>;

property blocksIterable

readonly blocksIterable: Iterable<AsyncDependenciesBlock>;

Exposes the group's async dependency blocks as an iterable.

property childrenIterable

readonly childrenIterable: SortableSet<ChunkGroup>;

property chunks

chunks: Chunk[];

property debugId

readonly debugId: string;

Returns a debug-only identifier derived from the group's member chunk debug ids. This is primarily useful in diagnostics and assertions.

property getModuleIndex

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

property getModuleIndex2

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

property groupDebugId

groupDebugId: number;

property id

readonly id: string;

Returns an identifier derived from the ids of the chunks currently in the group.

property index

index?: number;

property name

name?: string;

Returns the configured name of the chunk group, if one was assigned. Updates the configured name of the chunk group.

property options

options: ChunkGroupOptions;

property origins

origins: OriginRecord[];

property parentsIterable

readonly parentsIterable: SortableSet<ChunkGroup>;

method addAsyncEntrypoint

addAsyncEntrypoint: (entrypoint: Entrypoint) => boolean;

Registers an async entrypoint that is rooted in this chunk group.

method addBlock

addBlock: (block: AsyncDependenciesBlock) => boolean;

Associates an async dependency block with this chunk group.

method addChild

addChild: (group: ChunkGroup) => boolean;

Adds a child chunk group to the current group.

method addOptions

addOptions: (options: ChunkGroupOptions) => void;

Merges additional options into the chunk group. Order-based options are combined by taking the higher priority, while unsupported conflicts surface as an explicit error.

method addOrigin

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

Records where this chunk group originated from in user code. The origin is used for diagnostics, ordering, and reporting.

method addParent

addParent: (parentChunk: ChunkGroup) => boolean;

Records a parent chunk group relationship.

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[];

Returns the async dependency blocks that create or reference this group.

method getChildOrderOptions

getChildOrderOptions: (
    childGroup: ChunkGroup,
    chunkGraph: ChunkGraph
) => Record<string, number>;

Aggregates per-block *Order options for the blocks that bridge this chunk group to the given child chunk group. *Order options are tied to the originating import() call and must not be sourced from the child's shared options, otherwise a webpackPrefetch/Preload directive from one parent would leak into other parents that share the child by name.

method getChildren

getChildren: () => ChunkGroup[];

Returns the child chunk groups reachable from this group.

method getChildrenByOrders

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

Groups child chunk groups by their *Order options and sorts each group by descending order and deterministic chunk-group comparison.

method getFiles

getFiles: () => string[];

Collects the emitted files produced by every chunk in the group.

method getModulePostOrderIndex

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

Returns the module's bottom-up traversal index within this group.

method getModulePreOrderIndex

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

Returns the module's top-down traversal index within this group.

method getNumberOfBlocks

getNumberOfBlocks: () => number;

method getNumberOfChildren

getNumberOfChildren: () => number;

method getNumberOfParents

getNumberOfParents: () => number;

method getParents

getParents: () => ChunkGroup[];

Returns the parent chunk groups that can lead to this group.

method hasBlock

hasBlock: (block: AsyncDependenciesBlock) => boolean;

Checks whether an async dependency block is associated with this group.

method hasParent

hasParent: (parent: ChunkGroup) => boolean;

Checks whether the provided group is registered as a parent.

method insertChunk

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

Inserts a chunk directly before another chunk that already belongs to the group, preserving the rest of the ordering.

method isInitial

isInitial: () => boolean;

Indicates whether this chunk group is loaded as part of the initial page load instead of being created lazily.

method pushChunk

pushChunk: (chunk: Chunk) => boolean;

Appends a chunk to the group when it is not already a member.

method remove

remove: () => void;

Disconnects this group from its parents, children, and chunks. Child groups are reconnected to this group's parents so the surrounding graph remains intact after removal.

method removeChild

removeChild: (group: ChunkGroup) => boolean;

Removes a child chunk group and clears the corresponding parent link on the removed child.

method removeChunk

removeChunk: (chunk: Chunk) => boolean;

Removes a chunk from this group.

method removeParent

removeParent: (chunkGroup: ChunkGroup) => boolean;

Removes a parent chunk group and clears the reverse child relationship.

method replaceChunk

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

Replaces one member chunk with another while preserving the group's ordering and avoiding duplicates.

method setModulePostOrderIndex

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

Stores the module's bottom-up traversal index within this group.

method setModulePreOrderIndex

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

Stores the module's top-down traversal index within this group.

method sortItems

sortItems: () => void;

method unshiftChunk

unshiftChunk: (chunk: Chunk) => boolean;

Moves a chunk to the front of the group or inserts it when it is not already present.

class CleanPlugin

class CleanPlugin {}

constructor

constructor(options?: CleanOptions);

property getCompilationHooks

static getCompilationHooks: (compilation: Compilation) => {
    keep: SyncBailHook<[string], boolean | void>;
};

property options

options: CleanOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class CodeGenerationResults

abstract class CodeGenerationResults {}

Stores code generation results keyed by module and runtime so later stages can retrieve emitted sources, metadata, and derived hashes.

property map

map: Map<Module, RuntimeSpecMap<CodeGenerationResult, CodeGenerationResult>>;

method add

add: (
    module: Module,
    runtime: RuntimeSpec,
    result: CodeGenerationResult
) => void;

Stores a code generation result for a module/runtime pair, creating the per-module runtime map when needed.

method get

get: (module: Module, runtime: RuntimeSpec) => CodeGenerationResult;

Returns the code generation result for a module/runtime pair, rejecting ambiguous lookups where no unique runtime-independent result exists.

method getData

getData: (module: Module, runtime: RuntimeSpec, key: string) => any;

Returns an arbitrary metadata entry recorded during code generation.

method getHash

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

Returns a stable hash for the generated sources and runtime requirements, computing and caching it on first access.

method getRuntimeRequirements

getRuntimeRequirements: (
    module: Module,
    runtime: RuntimeSpec
) => null | ReadonlySet<string>;

Returns the runtime requirements captured during code generation for the requested module/runtime pair.

method getSource

getSource: (module: Module, runtime: RuntimeSpec, sourceType: string) => Source;

Returns a generated source of the requested source type from a stored code generation result.

method has

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

Reports whether a module has a stored result for the requested runtime, or a single unambiguous result when no runtime is specified.

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> };

Deprecated

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<DependencyConstructor, 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: Error[];

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],
        (string[] | ReferencedExport)[]
    >;
    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>, Records]>;
    beforeModuleIds: SyncHook<[Iterable<Module>]>;
    moduleIds: SyncHook<[Iterable<Module>]>;
    optimizeModuleIds: SyncHook<[Iterable<Module>]>;
    afterOptimizeModuleIds: SyncHook<[Iterable<Module>]>;
    reviveChunks: SyncHook<[Iterable<Chunk>, Records]>;
    beforeChunkIds: SyncHook<[Iterable<Chunk>]>;
    chunkIds: SyncHook<[Iterable<Chunk>]>;
    optimizeChunkIds: SyncHook<[Iterable<Chunk>]>;
    afterOptimizeChunkIds: SyncHook<[Iterable<Chunk>]>;
    recordModules: SyncHook<[Iterable<Module>, Records]>;
    recordChunks: SyncHook<[Iterable<Chunk>, Records]>;
    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<[Records]>;
    record: SyncHook<[Compilation, Records]>;
    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],
        RenderManifestEntry[]
    >;
    fullHash: SyncHook<[Hash]>;
    chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
    moduleAsset: SyncHook<[Module, string]>;
    chunkAsset: SyncHook<[Chunk, string]>;
    assetPath: SyncWaterfallHook<[string, PathData, AssetInfo], string>;
    needAdditionalPass: SyncBailHook<[], boolean | void>;
    childCompiler: SyncHook<[Compiler, string, number]>;
    log: SyncBailHook<[string, LogEntry], boolean | void>;
    processWarnings: SyncWaterfallHook<[Error[]], Error[]>;
    processErrors: SyncWaterfallHook<[Error[]], Error[]>;
    statsPreset: HookMap<
        SyncHook<[Partial<NormalizedStatsOptions>, CreateStatsOptionsContext]>
    >;
    statsNormalize: SyncHook<
        [Partial<NormalizedStatsOptions>, CreateStatsOptionsContext]
    >;
    statsFactory: SyncHook<[StatsFactory, NormalizedStatsOptions]>;
    statsPrinter: SyncHook<[StatsPrinter, NormalizedStatsOptions]>;
    readonly normalModuleLoader: SyncHook<[AnyLoaderContext, 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: WebpackOptionsNormalizedWithDefaults;

property outputOptions

outputOptions: OutputNormalizedWithDefaults;

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: Records;

property requestShortener

requestShortener: RequestShortener;

property resolverFactory

resolverFactory: ResolverFactory;

property runtimeTemplate

runtimeTemplate: RuntimeTemplate;

property startTime

startTime?: number;

property usedChunkIds

usedChunkIds: Set<number>;

property usedModuleIds

usedModuleIds: Set<number>;

property valueCacheVersions

valueCacheVersions: Map<string, ValueCacheVersion>;

property warnings

warnings: Error[];

method addAsyncEntrypoint

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

Adds the provided async entrypoint to this chunk group.

method addChunk

addChunk: (name?: null | 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;

Adds the provided string to the compilation.

method addInclude

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

Adds the provided string to the compilation.

method addModule

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

Adds the provided module to the compilation.

method addModuleChain

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

Adds the provided string to the compilation.

method addModuleTree

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

Adds the provided object to the compilation.

method addRuntimeModule

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

Adds runtime module.

method assignDepth

assignDepth: (module: Module) => void;

Processes the provided module.
Deprecated

method assignDepths

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

Assigns depth values to the provided modules.

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;

Generates code and runtime requirements for this module.

method createChildCompiler

createChildCompiler: (
    name: string,
    outputOptions?: Partial<OutputNormalized>,
    plugins?: (
        | false
        | ''
        | 0
        | ((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;

Creates a chunk assets.

method createHash

createHash: () => CodeGenerationJob[];

method createModuleAssets

createModuleAssets: () => void;

method createModuleHashes

createModuleHashes: () => void;

method createStatsFactory

createStatsFactory: (options: NormalizedStatsOptions) => StatsFactory;

Creates a stats factory.

method createStatsOptions

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

Creates a stats options.

method createStatsPrinter

createStatsPrinter: (options: NormalizedStatsOptions) => StatsPrinter;

Creates a stats printer.

method deleteAsset

deleteAsset: (file: string) => void;

Processes the provided file.

method emitAsset

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

Processes the provided file.

method executeModule

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

Processes the provided module.

method factorizeModule

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

Processes the provided module callback.
Processes the provided module factory result callback.

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;

Processes the provided callback.

method getAsset

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

Returns the asset or undefined when not found.

method getAssetPath

getAssetPath: <T extends PathData = PathData>(
    filename: string | TemplatePathFn<T>,
    data: T
) => string;

Returns interpolated path.

method getAssetPathWithInfo

getAssetPathWithInfo: <T extends PathData = PathData>(
    filename: string | TemplatePathFn<T>,
    data: T
) => InterpolatedPathAndAssetInfo;

Gets asset path with info.

method getAssets

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

method getCache

getCache: (name: string) => CacheFacade;

Returns the cache facade instance.

method getDependencyReferencedExports

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

Gets dependency referenced exports.

method getErrors

getErrors: () => Error[];

method getLogger

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

Returns a logger with that name.

method getModule

getModule: (module: Module) => Module;

Fetches a module from a compilation by its identifier

method getPath

getPath: <T extends PathData = PathData>(
    filename: string | TemplatePathFn<T>,
    data?: T
) => string;

Returns interpolated path.

method getPathWithInfo

getPathWithInfo: <T extends PathData = PathData>(
    filename: string | TemplatePathFn<T>,
    data?: T
) => InterpolatedPathAndAssetInfo;

Gets path with info.

method getRenderManifest

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

Gets render manifest.

method getStats

getStats: () => Stats;

method getWarnings

getWarnings: () => Error[];

method handleModuleCreation

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

Handle module creation.

method patchChunksAfterReasonRemoval

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

Patch chunks after reason removal.

method processModuleDependencies

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

Process module dependencies.

method processModuleDependenciesNonRecursive

processModuleDependenciesNonRecursive: (module: Module) => void;

Process module dependencies non recursive.

method processRuntimeRequirements

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

Process runtime requirements.

method rebuildModule

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

Processes the provided module.

method removeChunkFromDependencies

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

Removes chunk from dependencies.

method removeReasonsOfDependencyBlock

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

Removes reasons of dependency block.

method renameAsset

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

Processes the provided file.

method reportDependencyErrorsAndWarnings

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

Report dependency errors and warnings.

method seal

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

Processes the provided callback.

method sortItemsWithChunkIds

sortItemsWithChunkIds: () => void;

method summarizeDependencies

summarizeDependencies: () => void;

method unseal

unseal: () => void;

method updateAsset

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

Updates asset using the provided file.

class Compiler

class Compiler {}

constructor

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

Creates an instance of Compiler.

property cache

cache: CacheClass;

property compilerPath

compilerPath: string;

property context

context: string;

property contextTimestamps

contextTimestamps?: Map<
    string,
    | 'ignore'
    | EntryTypesIndex
    | OnlySafeTimeEntry
    | ExistenceOnlyTimeEntryTypesIndex
>;

property fileTimestamps

fileTimestamps?: Map<
    string,
    | 'ignore'
    | EntryTypesIndex
    | OnlySafeTimeEntry
    | ExistenceOnlyTimeEntryTypesIndex
>;

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>;
    validate: SyncHook<[]>;
    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?: (value: string, type: LogTypeEnum, args?: 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: Records;

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: (err: null | Error, result?: void) => void) => void;

Processes the provided error callback.

method compile

compile: (callback: CallbackWebpackFunction_2<Compilation, void>) => void;

Processes the provided compilation.

method createChildCompiler

createChildCompiler: (
    compilation: Compilation,
    compilerName: string,
    compilerIndex: number,
    outputOptions?: Partial<OutputNormalized>,
    plugins?: (
        | false
        | ''
        | 0
        | WebpackPluginInstance
        | ((this: Compiler, compiler: Compiler) => void)
    )[]
) => Compiler;

Creates a child compiler.

method createCompilation

createCompilation: (params: CompilationParams) => Compilation;

Creates a compilation.

method createContextModuleFactory

createContextModuleFactory: () => ContextModuleFactory;

method createNormalModuleFactory

createNormalModuleFactory: () => NormalModuleFactory;

method emitAssets

emitAssets: (
    compilation: Compilation,
    callback: (err: null | Error, result?: void) => void
) => void;

Processes the provided compilation.

method emitRecords

emitRecords: (callback: (err: null | Error, result?: void) => void) => void;

Processes the provided error callback.

method getCache

getCache: (name: string) => CacheFacade;

Returns the cache facade instance.

method getInfrastructureLogger

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

Gets infrastructure logger.

method isChild

isChild: () => boolean;

method newCompilation

newCompilation: (params: CompilationParams) => Compilation;

Returns the created compilation.

method newCompilationParams

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

method purgeInputFileSystem

purgeInputFileSystem: () => void;

method readRecords

readRecords: (callback: (err: null | Error, result?: void) => void) => void;

Processes the provided error callback.

method run

run: (callback: CallbackWebpackFunction_2<Stats, void>) => void;

Processes the provided stat.

method runAsChild

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

Processes the provided run as child callback.

method validate

validate: <T extends unknown = object>(
    schema:
        | (JSONSchema4 & ExtendedSchema)
        | (JSONSchema6 & ExtendedSchema)
        | (JSONSchema7 & ExtendedSchema)
        | (() => Parameters<typeof validateFunction>[0]),
    value: T,
    options?: ValidationErrorConfiguration,
    check?: (value: T) => boolean
) => void;

Schema validation function with optional pre-compiled check

method watch

watch: (
    watchOptions: WatchOptions,
    handler: CallbackWebpackFunction_2<Stats, void>
) => undefined | Watching;

Returns a compiler watcher.

class ConcatenationScope

class ConcatenationScope {}

Tracks the symbols and cross-module references needed while rendering a concatenated module.

constructor

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

Creates the mutable scope object used while rendering a concatenated module and its cross-module references.

property DEFAULT_EXPORT

static DEFAULT_EXPORT: string;

property NAMESPACE_OBJECT_EXPORT

static NAMESPACE_OBJECT_EXPORT: string;

property usedNames

usedNames: Set<string>;

method createModuleReference

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

Encodes a reference to another concatenated module as a placeholder identifier that can be parsed later during code generation.

method getRawExport

getRawExport: (exportName: string) => undefined | string;

Returns the raw expression registered for an export, if one exists.

method isModuleInScope

isModuleInScope: (module: Module) => boolean;

Checks whether a module participates in the current concatenation scope.

method isModuleReference

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

Checks whether an identifier is one of webpack's encoded concatenation module references.

method matchModuleReference

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

Parses an encoded module reference back into its module index and reference flags.

method registerExport

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

Records the symbol that should be used when the current module exports a named binding.

method registerNamespaceExport

registerNamespaceExport: (symbol: string) => void;

Records the symbol that should be used for the synthetic namespace export.

method registerRawExport

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

Records a raw expression that can be used to reference an export without going through the normal symbol map.

method setRawExportMap

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

Replaces the raw expression for an export only when that export already has an entry in the raw export map.

class ContextExclusionPlugin

class ContextExclusionPlugin {}

constructor

constructor(negativeMatcher: RegExp);

Creates an instance of ContextExclusionPlugin.

property negativeMatcher

negativeMatcher: RegExp;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class ContextReplacementPlugin

class ContextReplacementPlugin {}

constructor

constructor(
    resourceRegExp: RegExp,
    newContentResource?:
        | string
        | boolean
        | RegExp
        | ((
              context: BeforeContextResolveData | AfterContextResolveData
          ) => void),
    newContentRecursive?: boolean | RegExp | NewContentCreateContextMap,
    newContentRegExp?: RegExp
);

Creates an instance of ContextReplacementPlugin.

property newContentCallback

newContentCallback?: (
    context: BeforeContextResolveData | AfterContextResolveData
) => void;

property newContentCreateContextMap

newContentCreateContextMap?: (
    fs: InputFileSystem,
    callback: (
        err: null | Error,
        newContentRecursive: NewContentCreateContextMap
    ) => void
) => void;

Stores new content create context map.

property newContentRecursive

newContentRecursive?: boolean;

property newContentRegExp

newContentRegExp?: RegExp;

property newContentResource

newContentResource?: string;

property resourceRegExp

resourceRegExp: RegExp;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class DefinePlugin

class DefinePlugin {}

constructor

constructor(definitions: Definitions);

Create a new define plugin

property definitions

definitions: Definitions;

property getCompilationHooks

static getCompilationHooks: (compilation: Compilation) => {
    definitions: SyncWaterfallHook<
        [Record<string, CodeValue>],
        Record<string, CodeValue>
    >;
};

property getMergedDefinitionNode

static getMergedDefinitionNode: (
    compilation: Compilation,
    key: string
) => MergedDefinitionNode;

property getRuntimeRequirements

static getRuntimeRequirements: (code: string) => undefined | string[];

property stringifyMergedDefinition

static stringifyMergedDefinition: (
    compilation: Compilation,
    parser: JavascriptParser,
    node: MergedDefinitionNode,
    key: string,
    objKeys?: null | Set<string>
) => string;

property toPropertyKey

static toPropertyKey: (key: string) => string;

property VALUE_DEP_MAIN

static VALUE_DEP_MAIN: string;

property VALUE_DEP_PREFIX

static VALUE_DEP_PREFIX: string;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

method runtimeValue

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

Returns runtime value.

class DelegatedPlugin

class DelegatedPlugin {}

constructor

constructor(options: Options);

Creates an instance of DelegatedPlugin.

property options

options: Options;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class Dependency

class Dependency {}

constructor

constructor();

property category

readonly category: string;

Returns a dependency category, typical categories are "commonjs", "amd", "esm".

property disconnect

readonly disconnect: any;

property EXPORTS_OBJECT_REFERENCED

static EXPORTS_OBJECT_REFERENCED: string[][];

property EXPORTS_OBJECT_REFERENCED_MANGLEABLE

static EXPORTS_OBJECT_REFERENCED_MANGLEABLE: string[][];

property LAZY_UNTIL_FALLBACK

static LAZY_UNTIL_FALLBACK: string;

property LAZY_UNTIL_ID

static LAZY_UNTIL_ID: string;

property LAZY_UNTIL_LOCAL

static LAZY_UNTIL_LOCAL: string;

property LAZY_UNTIL_REQUEST

static LAZY_UNTIL_REQUEST: string;

property loc

loc: DependencyLocation;

Returns location.

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;

Returns a display name for the type of dependency.

method canConcatenate

static canConcatenate: (dependency: Dependency) => boolean;

Returns true if this dependency can be concatenated
Returns true if the dependency can be concatenated (scope hoisting).

method compareLocations

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

Compares two dependencies by source location for sorting a module's dependencies, without materializing the loc objects (get loc caches its result, so comparing through it would retain a location object on every sorted dependency). These dependencies always carry a real source position, so only start (line, column) and the within-statement index are compared; a dependency without an index sorts after one that has an index at the same position.

method couldAffectReferencingModule

couldAffectReferencingModule: () => boolean | symbol;

Could affect referencing module.

method createIgnoredModule

createIgnoredModule: (context: string) => Module;

Creates an ignored module.

method deserialize

deserialize: (__0: ObjectDeserializerContextObjectMiddlewareObject_4) => void;

Restores this instance from the provided deserializer context.

method getCondition

getCondition: (
    moduleGraph: ModuleGraph
) =>
    | false
    | ((
          moduleGraphConnection: ModuleGraphConnection,
          runtime: RuntimeSpec
      ) => ConnectionState);

Returns function to determine if the connection is active.

method getContext

getContext: () => undefined | string;

Returns a request context.

method getErrors

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

Returns errors.

method getExports

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

Returns the exported names

method getForwardId

getForwardId: () => null | string | true;

Returns the export name this dependency requests from its target module (lazy barrel optimization).

method getLazyName

getLazyName: () => null | string;

Returns the export name for a LAZY_UNTIL_LOCAL/LAZY_UNTIL_ID classification (lazy barrel optimization).

method getLazyUntil

getLazyUntil: () => null | 'local' | 'id' | '*' | '@';

Returns how this dependency may be deferred when its parent module is side-effect-free (lazy barrel optimization).

method getModuleEvaluationSideEffectsState

getModuleEvaluationSideEffectsState: (
    moduleGraph: ModuleGraph
) => ConnectionState;

Gets module evaluation side effects state.

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
Deprecated

method getReferencedExports

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

Returns list of exports referenced by this dependency

method getResourceIdentifier

getResourceIdentifier: () => null | string;

Returns an identifier to merge equal requests.

method getWarnings

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

Returns warnings.

method isLazy

isLazy: () => boolean;

Whether the lazy barrel currently defers creating this dependency's target module (lazy barrel optimization).

method isLowPriorityDependency

static isLowPriorityDependency: (dependency: Dependency) => boolean;

Returns true if the dependency is a low priority dependency.

method serialize

serialize: (__0: ObjectSerializerContextObjectMiddlewareObject_5) => void;

Serializes this instance into the provided serializer context.

method setLazy

setLazy: (value: boolean) => void;

Sets whether the lazy barrel defers creating this dependency's target module (lazy barrel optimization).

method setLoc

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

Updates loc using the provided start line.

method setLocWithIndex

setLocWithIndex: (loc: DependencyLocation, index: number) => void;

Updates loc from a source location plus an explicit index, without materializing the loc object (keeps get loc lazy). Replaces the dep.loc = Object.create(loc); dep.loc.index = i pattern, which both allocated a copy and stored the index outside the serialized fields.

method updateHash

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

Updates the hash with the data contributed by this instance.

class DllPlugin

class DllPlugin {}

constructor

constructor(options: DllPluginOptions);

Creates an instance of DllPlugin.

property options

options: DllPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class DllReferencePlugin

class DllReferencePlugin {}

constructor

constructor(options: DllReferencePluginOptions);

Creates an instance of DllReferencePlugin.

property options

options: DllReferencePluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class DotenvPlugin

class DotenvPlugin {}

constructor

constructor(options?: DotenvPluginOptions);

Creates an instance of DotenvPlugin.

property options

options: DotenvPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class DynamicEntryPlugin

class DynamicEntryPlugin {}

constructor

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

Creates an instance of DynamicEntryPlugin.

property context

context: string;

property entry

entry: () => Promise<EntryStaticNormalized>;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class EntryOptionPlugin

class EntryOptionPlugin {}

constructor

constructor();

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

method applyEntryOption

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

Apply entry option.

method entryDescriptionToOptions

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

Entry description to options.

method getHooks

static getHooks: (compiler: Compiler) => EntryOptionPluginHooks;

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;

Applies the plugin by registering its hooks on the compiler.

method createDependency

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

Creates a dependency.

class Entrypoint

abstract class Entrypoint extends ChunkGroup {}

Entrypoint serves as an encapsulation primitive for chunks that are a part of a single ChunkGroup. They represent all bundles that need to be loaded for a single instance of a page. Multi-page application architectures will typically yield multiple Entrypoint objects inside of the compilation, whereas a Single Page App may only contain one with many lazy-loaded chunks.

method addDependOn

addDependOn: (entrypoint: Entrypoint) => void;

method dependOn

dependOn: (entrypoint: Entrypoint) => boolean;

method getEntrypointChunk

getEntrypointChunk: () => Chunk;

Returns the chunk which contains the entrypoint modules (or at least the execution of them)

method getRuntimeChunk

getRuntimeChunk: () => null | Chunk;

Fetches the chunk reference containing the webpack bootstrap code

method setEntrypointChunk

setEntrypointChunk: (chunk: Chunk) => void;

Sets the chunk with the entrypoint modules for an entrypoint.

method setRuntimeChunk

setRuntimeChunk: (chunk: Chunk) => void;

Sets the runtimeChunk for an entrypoint.

class EnvironmentPlugin

class EnvironmentPlugin {}

constructor

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

Creates an instance of EnvironmentPlugin.

property defaultValues

defaultValues: Record<string, any>;

property keys

keys: string[];

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class EvalDevToolModulePlugin

class EvalDevToolModulePlugin {}

constructor

constructor(options?: EvalDevToolModulePluginOptions);

Creates an instance of EvalDevToolModulePlugin.

property moduleFilenameTemplate

moduleFilenameTemplate: DevtoolModuleFilenameTemplate;

property namespace

namespace: string;

property sourceUrlComment

sourceUrlComment: string;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class EvalSourceMapDevToolPlugin

class EvalSourceMapDevToolPlugin {}

constructor

constructor(inputOptions?: string | SourceMapDevToolPluginOptions);

Creates an instance of EvalSourceMapDevToolPlugin.

property moduleFilenameTemplate

moduleFilenameTemplate: DevtoolModuleFilenameTemplate;

property namespace

namespace: string;

property options

options: SourceMapDevToolPluginOptions;

property sourceMapComment

sourceMapComment: string;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class ExternalModule

class ExternalModule extends Module {}

constructor

constructor(
    request: ExternalModuleRequest,
    type: ExternalsType,
    userRequest: string,
    dependencyMeta?:
        | ImportDependencyMeta
        | CssImportDependencyMeta
        | AssetDependencyMeta,
    interop?: 'default' | 'esModule'
);

Creates an instance of ExternalModule.

property dependencyMeta

dependencyMeta?:
    | ImportDependencyMeta
    | CssImportDependencyMeta
    | AssetDependencyMeta;

property externalType

externalType: ExternalsType;

property getCompilationHooks

static getCompilationHooks: (compilation: Compilation) => {
    chunkCondition: SyncBailHook<[Chunk, Compilation], boolean>;
};

property getExternalModuleNodeCommonjsInitFragment

static getExternalModuleNodeCommonjsInitFragment: (
    runtimeTemplate: RuntimeTemplate,
    universal?: boolean
) => InitFragment<ChunkRenderContextJavascriptModulesPlugin>;

property interop

interop?: 'default' | 'esModule';

property ModuleExternalInitFragment

static ModuleExternalInitFragment: typeof ModuleExternalInitFragment;

property request

request: ExternalModuleRequest;

property userRequest

userRequest: string;

method getSourceBasicTypes

static getSourceBasicTypes: (module: Module) => ReadonlySet<string>;

Gets source basic types.
Deprecated
In webpack 6, call getSourceBasicTypes() directly on the module instance instead of using this static method.

method restoreFromUnsafeCache

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

restore unsafe cache data

class ExternalsPlugin

class ExternalsPlugin {}

constructor

constructor(
    type:
        | 'module'
        | 'script'
        | 'import'
        | 'assign'
        | 'var'
        | 'this'
        | 'window'
        | 'self'
        | 'global'
        | 'commonjs'
        | 'commonjs2'
        | 'commonjs-module'
        | 'commonjs-static'
        | 'amd'
        | 'amd-require'
        | 'umd'
        | 'umd2'
        | 'jsonp'
        | 'system'
        | 'amd-async'
        | 'promise'
        | 'module-import'
        | 'node-commonjs'
        | 'asset'
        | 'asset-url'
        | 'css-import'
        | 'css-url'
        | ((dependency: Dependency) => ExternalsType),
    externals: Externals
);

Creates an instance of ExternalsPlugin.

property externals

externals: Externals;

property type

type:
    | 'module'
    | 'script'
    | 'import'
    | 'assign'
    | 'var'
    | 'this'
    | 'window'
    | 'self'
    | 'global'
    | 'commonjs'
    | 'commonjs2'
    | 'commonjs-module'
    | 'commonjs-static'
    | 'amd'
    | 'amd-require'
    | 'umd'
    | 'umd2'
    | 'jsonp'
    | 'system'
    | 'amd-async'
    | 'promise'
    | 'module-import'
    | 'node-commonjs'
    | 'asset'
    | 'asset-url'
    | 'css-import'
    | 'css-url'
    | ((dependency: Dependency) => ExternalsType);

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class Generator

class Generator {}

constructor

constructor();

method byType

static byType: (map: { [index: string]: Generator }) => ByTypeGenerator;

Returns generator by type.

method generate

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

Generates generated code for this runtime module.

method getConcatenationBailoutReason

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

Returns the reason this module cannot be concatenated, when one exists.

method getSize

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

Returns the estimated size for the requested source type.

method getTypes

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

Returns the source types available for this module.

method getTypesDependOnIncomingConnections

getTypesDependOnIncomingConnections: () => boolean;

method updateHash

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

Updates the hash with the data contributed by this instance.

class HotModuleReplacementPlugin

class HotModuleReplacementPlugin {}

constructor

constructor();

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

method getParserHooks

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

Returns the attached hooks.

class HotUpdateChunk

class HotUpdateChunk extends Chunk {}

constructor

constructor();

class IgnorePlugin

class IgnorePlugin {}

constructor

constructor(options: IgnorePluginOptions);

Creates an instance of IgnorePlugin.

property options

options: IgnorePluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

method checkIgnore

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

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

class InitFragment

class InitFragment<GenerateContext> {}

Represents InitFragment.

constructor

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

Creates an instance of InitFragment.

property content

content?: string | Source;

property endContent

endContent?: string | Source;

property key

key?: string;

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>(
    source: Source,
    initFragments: MaybeMergeableInitFragment<Context>[],
    context: Context
) => Source;

Adds the provided source to the init fragment.

method deserialize

deserialize: (
    context: ObjectDeserializerContextObjectMiddlewareObject_4
) => void;

Restores this instance from the provided deserializer context.

method getContent

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

Returns the source code that will be included as initialization code.

method getEndContent

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

Returns the source code that will be included at the end of the module.

method serialize

serialize: (context: ObjectSerializerContextObjectMiddlewareObject_5) => void;

Serializes this instance into the provided serializer context.

class JavascriptModulesPlugin

class JavascriptModulesPlugin {}

constructor

constructor(options?: {});

property chunkHasJs

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

property getCompilationHooks

static getCompilationHooks: (compilation: Compilation) => {
    renderModuleContent: SyncWaterfallHook<
        [Source, Module, ModuleRenderContext],
        Source
    >;
    renderModuleContainer: SyncWaterfallHook<
        [Source, Module, ModuleRenderContext],
        Source
    >;
    renderModulePackage: SyncWaterfallHook<
        [Source, Module, ModuleRenderContext],
        Source
    >;
    render: SyncWaterfallHook<
        [Source, RenderContextJavascriptModulesPlugin],
        Source
    >;
    renderContent: SyncWaterfallHook<
        [Source, RenderContextJavascriptModulesPlugin],
        Source
    >;
    renderStartup: SyncWaterfallHook<
        [Source, Module, StartupRenderContext],
        Source
    >;
    renderChunk: SyncWaterfallHook<
        [Source, RenderContextJavascriptModulesPlugin],
        Source
    >;
    renderMain: SyncWaterfallHook<
        [Source, RenderContextJavascriptModulesPlugin],
        Source
    >;
    renderRequire: SyncWaterfallHook<[string, RenderBootstrapContext], string>;
    inlineInRuntimeBailout: SyncBailHook<
        [Module, Partial<RenderBootstrapContext>],
        string | void
    >;
    embedInRuntimeBailout: SyncBailHook<
        [Module, RenderContextJavascriptModulesPlugin],
        string | void
    >;
    strictRuntimeBailout: SyncBailHook<
        [RenderContextJavascriptModulesPlugin],
        string | void
    >;
    chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
    useSourceMap: SyncBailHook<
        [Chunk, RenderContextJavascriptModulesPlugin],
        boolean | void
    >;
};

property options

options: {};

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

method getChunkFilenameTemplate

static getChunkFilenameTemplate: (
    chunk: Chunk,
    outputOptions: OutputNormalizedWithDefaults
) => ChunkFilenameTemplate;

Gets chunk filename template.

method renderBootstrap

renderBootstrap: (
    renderContext: RenderBootstrapContext,
    hooks: {
        renderModuleContent: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        renderModuleContainer: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        renderModulePackage: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        render: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderContent: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderStartup: SyncWaterfallHook<
            [Source, Module, StartupRenderContext],
            Source
        >;
        renderChunk: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderMain: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderRequire: SyncWaterfallHook<
            [string, RenderBootstrapContext],
            string
        >;
        inlineInRuntimeBailout: SyncBailHook<
            [Module, Partial<RenderBootstrapContext>],
            string | void
        >;
        embedInRuntimeBailout: SyncBailHook<
            [Module, RenderContextJavascriptModulesPlugin],
            string | void
        >;
        strictRuntimeBailout: SyncBailHook<
            [RenderContextJavascriptModulesPlugin],
            string | void
        >;
        chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
        useSourceMap: SyncBailHook<
            [Chunk, RenderContextJavascriptModulesPlugin],
            boolean | void
        >;
    }
) => Bootstrap;

Renders the generated source of the bootstrap code.

method renderChunk

renderChunk: (
    renderContext: RenderContextJavascriptModulesPlugin,
    hooks: {
        renderModuleContent: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        renderModuleContainer: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        renderModulePackage: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        render: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderContent: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderStartup: SyncWaterfallHook<
            [Source, Module, StartupRenderContext],
            Source
        >;
        renderChunk: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderMain: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderRequire: SyncWaterfallHook<
            [string, RenderBootstrapContext],
            string
        >;
        inlineInRuntimeBailout: SyncBailHook<
            [Module, Partial<RenderBootstrapContext>],
            string | void
        >;
        embedInRuntimeBailout: SyncBailHook<
            [Module, RenderContextJavascriptModulesPlugin],
            string | void
        >;
        strictRuntimeBailout: SyncBailHook<
            [RenderContextJavascriptModulesPlugin],
            string | void
        >;
        chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
        useSourceMap: SyncBailHook<
            [Chunk, RenderContextJavascriptModulesPlugin],
            boolean | void
        >;
    }
) => Source;

Renders the rendered source.

method renderMain

renderMain: (
    renderContext: MainRenderContext,
    hooks: {
        renderModuleContent: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        renderModuleContainer: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        renderModulePackage: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        render: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderContent: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderStartup: SyncWaterfallHook<
            [Source, Module, StartupRenderContext],
            Source
        >;
        renderChunk: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderMain: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderRequire: SyncWaterfallHook<
            [string, RenderBootstrapContext],
            string
        >;
        inlineInRuntimeBailout: SyncBailHook<
            [Module, Partial<RenderBootstrapContext>],
            string | void
        >;
        embedInRuntimeBailout: SyncBailHook<
            [Module, RenderContextJavascriptModulesPlugin],
            string | void
        >;
        strictRuntimeBailout: SyncBailHook<
            [RenderContextJavascriptModulesPlugin],
            string | void
        >;
        chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
        useSourceMap: SyncBailHook<
            [Chunk, RenderContextJavascriptModulesPlugin],
            boolean | void
        >;
    },
    compilation: Compilation
) => Source;

Renders the newly generated source from rendering.

method renderModule

renderModule: (
    module: Module,
    renderContext: ModuleRenderContext,
    hooks: {
        renderModuleContent: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        renderModuleContainer: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        renderModulePackage: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        render: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderContent: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderStartup: SyncWaterfallHook<
            [Source, Module, StartupRenderContext],
            Source
        >;
        renderChunk: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderMain: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderRequire: SyncWaterfallHook<
            [string, RenderBootstrapContext],
            string
        >;
        inlineInRuntimeBailout: SyncBailHook<
            [Module, Partial<RenderBootstrapContext>],
            string | void
        >;
        embedInRuntimeBailout: SyncBailHook<
            [Module, RenderContextJavascriptModulesPlugin],
            string | void
        >;
        strictRuntimeBailout: SyncBailHook<
            [RenderContextJavascriptModulesPlugin],
            string | void
        >;
        chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
        useSourceMap: SyncBailHook<
            [Chunk, RenderContextJavascriptModulesPlugin],
            boolean | void
        >;
    }
) => null | Source;

Renders the newly generated source from rendering.

method renderRequire

renderRequire: (
    renderContext: RenderBootstrapContext,
    hooks: {
        renderModuleContent: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        renderModuleContainer: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        renderModulePackage: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        render: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderContent: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderStartup: SyncWaterfallHook<
            [Source, Module, StartupRenderContext],
            Source
        >;
        renderChunk: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderMain: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderRequire: SyncWaterfallHook<
            [string, RenderBootstrapContext],
            string
        >;
        inlineInRuntimeBailout: SyncBailHook<
            [Module, Partial<RenderBootstrapContext>],
            string | void
        >;
        embedInRuntimeBailout: SyncBailHook<
            [Module, RenderContextJavascriptModulesPlugin],
            string | void
        >;
        strictRuntimeBailout: SyncBailHook<
            [RenderContextJavascriptModulesPlugin],
            string | void
        >;
        chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
        useSourceMap: SyncBailHook<
            [Chunk, RenderContextJavascriptModulesPlugin],
            boolean | void
        >;
    }
) => string;

Renders the generated source of the require function.

method updateHashWithBootstrap

updateHashWithBootstrap: (
    hash: Hash,
    renderContext: RenderBootstrapContext,
    hooks: {
        renderModuleContent: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        renderModuleContainer: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        renderModulePackage: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        render: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderContent: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderStartup: SyncWaterfallHook<
            [Source, Module, StartupRenderContext],
            Source
        >;
        renderChunk: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderMain: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderRequire: SyncWaterfallHook<
            [string, RenderBootstrapContext],
            string
        >;
        inlineInRuntimeBailout: SyncBailHook<
            [Module, Partial<RenderBootstrapContext>],
            string | void
        >;
        embedInRuntimeBailout: SyncBailHook<
            [Module, RenderContextJavascriptModulesPlugin],
            string | void
        >;
        strictRuntimeBailout: SyncBailHook<
            [RenderContextJavascriptModulesPlugin],
            string | void
        >;
        chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
        useSourceMap: SyncBailHook<
            [Chunk, RenderContextJavascriptModulesPlugin],
            boolean | void
        >;
    }
) => void;

Updates hash with bootstrap.

class LibManifestPlugin

class LibManifestPlugin {}

constructor

constructor(options: LibManifestPluginOptions);

Creates an instance of LibManifestPlugin.

property options

options: LibManifestPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class LibraryTemplatePlugin

class LibraryTemplatePlugin {}

constructor

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

Creates an instance of LibraryTemplatePlugin.

property library

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

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class LoaderOptionsPlugin

class LoaderOptionsPlugin {}

constructor

constructor(options?: LoaderOptionsPluginOptions & MatchObject);

Creates an instance of LoaderOptionsPlugin.

property options

options: LoaderOptionsPluginOptions & MatchObject;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class LoaderTargetPlugin

class LoaderTargetPlugin {}

constructor

constructor(target: string);

Creates an instance of LoaderTargetPlugin.

property target

target: string;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class ManifestPlugin

class ManifestPlugin {}

constructor

constructor(options?: ManifestPluginOptions);

Creates an instance of ManifestPlugin.

property options

options: ManifestPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class Module

class Module extends DependenciesBlock {}

constructor

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

Creates an instance of Module.

property buildInfo

buildInfo?: BuildInfo;

property buildMeta

buildMeta?: BuildMeta;

property chunksIterable

readonly chunksIterable: Iterable<Chunk>;

Deprecated

property codeGenerationDependencies

codeGenerationDependencies?: Dependency[];

property context

context: string;

property debugId

debugId: number;

property depth

depth: number;

Returns the depth. Updates the depth using the provided value.
Deprecated

property errors

readonly errors: any;

property exportsArgument

readonly exportsArgument: string;

Gets exports argument.

property factoryMeta

factoryMeta?: FactoryMeta;

property hasEqualsChunks

readonly hasEqualsChunks: any;

property hash

readonly hash: string;

Returns the hash of the module.
Deprecated

property id

id: string | number;

Returns the module id assigned by the chunk graph. Updates the module id using the provided value.
Deprecated

property index

index: number;

Returns the pre-order index. Updates the pre-order index using the provided value.
Deprecated

property index2

index2: number;

Returns the post-order index. Updates the post-order index using the provided value.
Deprecated

property issuer

issuer?: Module;

Returns the issuer. Updates the issuer using the provided value.
Deprecated

property isUsed

readonly isUsed: any;

property layer

layer: string;

property moduleArgument

readonly moduleArgument: string;

Gets module argument.

property needId

needId: boolean;

property optimizationBailout

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

Gets optimization bailout.
Deprecated

property optional

readonly optional: boolean;

Deprecated

property presentationalDependencies

presentationalDependencies?: Dependency[];

property profile

profile?: ModuleProfile;

Deprecated

property renderedHash

readonly renderedHash: string;

Returns the rendered hash of the module.
Deprecated

property resolveOptions

resolveOptions?: ResolveOptions;

property type

type: string;

property used

used: any;

property usedExports

readonly usedExports: boolean | SortableSet<string>;

Deprecated

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;

Adds the provided file dependencies to the module.

method addChunk

addChunk: (chunk: Chunk) => boolean;

Adds the provided chunk to the module.
Deprecated

method addCodeGenerationDependency

addCodeGenerationDependency: (codeGenerationDependency: Dependency) => void;

Adds code generation dependency.

method addError

addError: (error: Error) => void;

Adds the provided error to the module.

method addPresentationalDependency

addPresentationalDependency: (presentationalDependency: Dependency) => void;

Adds presentational dependency.

method addWarning

addWarning: (warning: Error) => void;

Adds the provided warning to the module.

method build

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

Builds the module using the provided compilation context.

method chunkCondition

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

Returns true if the module can be placed in the chunk.

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;

Generates code and runtime requirements for this module.

method getChunks

getChunks: () => Chunk[];

Deprecated

method getConcatenationBailoutReason

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

Returns the reason this module cannot be concatenated, when one exists.

method getErrors

getErrors: () => undefined | Error[];

Returns list of errors if any.

method getExportsType

getExportsType: (moduleGraph: ModuleGraph, strict?: boolean) => ExportsType;

Returns export type.

method getNumberOfChunks

getNumberOfChunks: () => number;

Deprecated

method getNumberOfErrors

getNumberOfErrors: () => number;

Gets number of errors.

method getNumberOfWarnings

getNumberOfWarnings: () => number;

Gets number of warnings.

method getReferencedSourceTypes

getReferencedSourceTypes: () => undefined | ReadonlySet<string>;

Freshly recomputed source types when they depend on incoming connections, for chunk-graph cache invalidation; undefined otherwise. #20800

method getSideEffectsConnectionState

getSideEffectsConnectionState: (moduleGraph: ModuleGraph) => ConnectionState;

Gets side effects connection state.

method getSourceBasicTypes

static getSourceBasicTypes: (module: Module) => ReadonlySet<string>;

Basic source types are high-level categories like javascript, css, webassembly, etc. We only have built-in knowledge about the javascript basic type here; other basic types may be added or changed over time by generators and do not need to be handled or detected here. Some modules, e.g. RemoteModule, may return non-basic source types like "remote" and "share-init" from getSourceTypes(), but their generated output is still JavaScript, i.e. their basic type is JS.
Gets source basic types.
Deprecated
In webpack 6, call getSourceBasicTypes() directly on the module instance instead of using this static method.

method getSourceTypes

getSourceTypes: () => ReadonlySet<string>;

Returns the source types this module can generate.

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 | Error[];

Returns list of warnings if any.

method hasChunkCondition

hasChunkCondition: () => boolean;

method hasReasonForChunk

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

Checks whether this module contains the chunk.

method hasReasons

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

Checks whether this module contains the module graph.

method identifier

identifier: () => string;

Returns the unique identifier used to reference this module.

method invalidateBuild

invalidateBuild: () => void;

Invalidates the cached state associated with this value.

method isAccessibleInChunk

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

Checks whether this module is accessible in chunk.

method isAccessibleInChunkGroup

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

Checks whether this module is accessible in chunk group.

method isEntryModule

isEntryModule: () => boolean;

Deprecated

method isInChunk

isInChunk: (chunk: Chunk) => boolean;

Checks whether this module is in the provided chunk.
Deprecated

method isOptional

isOptional: (moduleGraph: ModuleGraph) => boolean;

Checks whether this module is optional.

method isProvided

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

Checks whether this module provides the specified export.
Deprecated

method libIdent

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

Gets the library identifier.

method nameForCondition

nameForCondition: () => null | string;

Returns the path used when matching this module against rule conditions.

method needBuild

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

Checks whether the module needs to be rebuilt for the current build state.

method needRebuild

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

Checks whether it needs rebuild.
Deprecated
Use needBuild instead

method originalSource

originalSource: () => null | Source;

Gets the original source.

method readableIdentifier

readableIdentifier: (requestShortener: RequestShortener) => string;

Returns a human-readable identifier for this module.

method removeChunk

removeChunk: (chunk: Chunk) => void;

Removes the provided chunk from the module.
Deprecated

method size

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

Returns the estimated size for the requested source type.

method source

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

Returns generated source.
Deprecated
Use codeGeneration() instead

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 ModuleFactory

class ModuleFactory {}

constructor

constructor();

method create

create: (
    data: ModuleFactoryCreateData,
    callback: (err?: null | Error, result?: ModuleFactoryResult) => void
) => void;

Processes the provided data.

class ModuleGraph

class ModuleGraph {}

constructor

constructor();

property ModuleGraphConnection

static ModuleGraphConnection: typeof ModuleGraphConnection;

method addExplanation

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

Adds the provided dependency to the module graph.

method addExtraReason

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

Adds the provided module to the module graph.

method cached

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

Returns computed value or cached.

method clearModuleGraphForModule

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

Clear module graph for module.
Deprecated

method cloneModuleAttributes

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

Clones module attributes.

method copyOutgoingModuleConnections

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

Copies outgoing module connections.

method dependencyCacheProvide

dependencyCacheProvide: <D extends Dependency, ARGS extends any[], R>(
    dependency: D,
    args_0: ARGS,
    ...args_1: ((moduleGraph: ModuleGraph, dependency: D, ...args: ARGS) => R)[]
) => R;

Dependency cache provide.

method finishUpdateParent

finishUpdateParent: () => void;

Finish update parent.

method freeze

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

Processes the provided cache stage.

method getConnection

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

Returns the connection.

method getDepth

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

Returns the depth of the module.

method getExportInfo

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

Returns info about the export.

method getExportsInfo

getExportsInfo: (module: Module) => ExportsInfo;

Returns info about the exports.

method getIncomingConnections

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

Gets incoming connections.

method getIncomingConnectionsByOriginModule

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

Gets incoming connections by origin module.

method getIssuer

getIssuer: (module: Module) => Issuer;

Returns the issuer module.

method getMeta

getMeta: (thing: object) => Meta;

Returns metadata.

method getMetaIfExisting

getMetaIfExisting: (thing: object) => undefined | Meta;

Gets meta if existing.

method getModule

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

Returns the referenced module.

method getModuleGraphForModule

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

Gets module graph for module.
Deprecated

method getOptimizationBailout

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

Gets optimization bailout.

method getOrigin

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

Returns the referencing module.

method getOutgoingConnections

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

Gets outgoing connections.

method getOutgoingConnectionsByModule

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

Gets outgoing connections by module.

method getParentBlock

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

Returns parent block.

method getParentBlockIndex

getParentBlockIndex: (dependency: Dependency) => number;

Gets parent block index.

method getParentModule

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

Gets parent module.

method getPostOrderIndex

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

Gets post order index.

method getPreOrderIndex

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

Gets pre order index.

method getProfile

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

Returns the module profile.

method getProvidedExports

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

Gets provided exports.

method getReadOnlyExportInfo

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

Gets read only export info.

method getResolvedModule

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

Gets resolved module.

method getResolvedOrigin

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

Gets resolved origin.

method getUsedExports

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

Returns the used exports.

method isAsync

isAsync: (module: Module) => boolean;

Checks whether this module graph is async.

method isDeferred

isDeferred: (module: Module) => boolean;

Checks whether this module graph is deferred.

method isExportProvided

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

Checks whether this module graph is export provided.

method moveModuleConnections

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

Move module connections.

method removeAllModuleAttributes

removeAllModuleAttributes: () => void;

Removes all module attributes.

method removeConnection

removeConnection: (dependency: Dependency) => void;

Removes connection.

method removeModuleAttributes

removeModuleAttributes: (module: Module) => void;

Removes module attributes.

method setAsync

setAsync: (module: Module) => void;

Updates async using the provided module.

method setDepth

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

Updates depth using the provided module.

method setDepthIfLower

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

Sets depth if lower.

method setIssuer

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

Updates issuer using the provided module.

method setIssuerIfUnset

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

Sets issuer if unset.

method setModuleGraphForModule

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

Sets module graph for module.
Deprecated

method setModuleMemCaches

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

Sets module mem caches.

method setParentDependenciesBlockIndex

setParentDependenciesBlockIndex: (dependency: Dependency, index: number) => void;

Sets parent dependencies block index.

method setParents

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

Updates parents using the provided dependency.

method setPostOrderIndex

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

Sets post order index.

method setPostOrderIndexIfUnset

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

Sets post order index if unset.

method setPreOrderIndex

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

Sets pre order index.

method setPreOrderIndexIfUnset

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

Sets pre order index if unset.

method setProfile

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

Updates profile using the provided module.

method setResolvedModule

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

Sets resolved module.

method unfreeze

unfreeze: () => void;

method updateModule

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

Updates module using the provided dependency.

method updateParent

updateParent: (
    dependency: Dependency,
    connection?: ModuleGraphConnection,
    parentModule?: Module
) => void;

Updates parent using the provided dependency.

class ModuleGraphConnection

class ModuleGraphConnection {}

constructor

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

Creates an instance of ModuleGraphConnection.

property addConnectionStates

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

property CIRCULAR_CONNECTION

static CIRCULAR_CONNECTION: Symbol;

property condition

condition?:
    | false
    | ((
          moduleGraphConnection: ModuleGraphConnection,
          runtime: 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: (
        moduleGraphConnection: ModuleGraphConnection,
        runtime: RuntimeSpec
    ) => ConnectionState
) => void;

Adds the provided condition to the module graph connection.

method addExplanation

addExplanation: (explanation: string) => void;

Adds the provided explanation to the module graph connection.

method clone

clone: () => ModuleGraphConnection;

method getActiveState

getActiveState: (runtime: RuntimeSpec) => ConnectionState;

Returns true: fully active, false: inactive, TRANSITIVE: direct module inactive, but transitive connection maybe active.

method isActive

isActive: (runtime: RuntimeSpec) => boolean;

Checks whether this module graph connection is active.

method isTargetActive

isTargetActive: (runtime: RuntimeSpec) => boolean;

Checks whether this module graph connection is target active.

method setActive

setActive: (value: boolean) => void;

Updates active using the provided value.

class MultiCompiler

class MultiCompiler {}

constructor

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

Creates an instance of MultiCompiler.

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 | void>
    >;
}>;

property inputFileSystem

inputFileSystem: InputFileSystem;

Sets input file system.

property intermediateFileSystem

intermediateFileSystem: IntermediateFileSystem;

Sets intermediate file system.

property options

readonly options: WebpackOptionsNormalized[] & MultiCompilerOptions;

property outputFileSystem

outputFileSystem: OutputFileSystem;

Sets output file system.

property outputPath

readonly outputPath: string;

property running

running: boolean;

property watchFileSystem

watchFileSystem: WatchFileSystem;

Sets watch file system.

property watching

watching?: MultiWatching;

method close

close: (callback: (err: null | Error, result?: void) => void) => void;

Processes the provided error callback.

method getInfrastructureLogger

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

Gets infrastructure logger.

method purgeInputFileSystem

purgeInputFileSystem: () => void;

method run

run: (callback: CallbackWebpackFunction_2<MultiStats, void>) => void;

Processes the provided multi stat.

method runWithDependencies

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

Run with dependencies.
Deprecated
This method should have been private

method setDependencies

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

Updates dependencies using the provided compiler.

method validateDependencies

validateDependencies: (
    callback: CallbackWebpackFunction_2<MultiStats, void>
) => boolean;

Validate dependencies.

method watch

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

Returns a compiler watcher.

class MultiStats

abstract class MultiStats {}

property hash

readonly hash: string;

property stats

stats: Stats[];

method hasErrors

hasErrors: () => boolean;

Checks whether this multi stats has errors.

method hasWarnings

hasWarnings: () => boolean;

Checks whether this multi stats has warnings.

method toJson

toJson: (
    options?:
        | boolean
        | StatsOptions
        | 'none'
        | 'summary'
        | 'errors-only'
        | 'errors-warnings'
        | 'minimal'
        | 'normal'
        | 'detailed'
        | 'verbose'
) => StatsCompilation;

Returns json output.

method toString

toString: (
    options?:
        | boolean
        | StatsOptions
        | 'none'
        | 'summary'
        | 'errors-only'
        | 'errors-warnings'
        | 'minimal'
        | 'normal'
        | 'detailed'
        | 'verbose'
) => string;

Returns a string representation.

class NoEmitOnErrorsPlugin

class NoEmitOnErrorsPlugin {}

constructor

constructor();

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class NormalModule

class NormalModule extends Module {}

constructor

constructor(__0: NormalModuleCreateDataNormalModuleObject_1<string>);

property binary

binary: boolean;

property error

error: Error;

property extractSourceMap

extractSourceMap: boolean;

property generator

generator?: Generator;

property generatorOptions

generatorOptions?: GeneratorOptions;

property hot

hot: boolean;

property loaders

loaders: LoaderItem[];

property matchResource

matchResource?: string;

property parser

parser?: ParserClass;

property parserOptions

parserOptions?: ParserOptions;

property rawRequest

rawRequest: string;

property request

request: string;

property resource

resource: string;

property resourceResolveData

resourceResolveData?: ResourceSchemeData & Partial<ResolveRequest>;

property userRequest

userRequest: string;

method applyNoParseRule

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

method createSource

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

method createSourceForAsset

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

method deserialize

static deserialize: (
    context: ObjectDeserializerContextObjectMiddlewareObject_4
) => NormalModule;

method getCompilationHooks

static getCompilationHooks: (compilation: Compilation) => {
    readResourceForScheme: HookMap<
        FakeHook<
            AsyncSeriesBailHook<[string, NormalModule], null | string | Buffer>
        >
    >;
    readResource: HookMap<
        AsyncSeriesBailHook<[AnyLoaderContext], null | string | Buffer>
    >;
    loader: SyncHook<[AnyLoaderContext, NormalModule]>;
    beforeLoaders: SyncHook<[LoaderItem[], NormalModule, AnyLoaderContext]>;
    beforeParse: SyncHook<[NormalModule]>;
    beforeSnapshot: SyncHook<[NormalModule]>;
    processResult: SyncWaterfallHook<
        [
            [
                string | Buffer,
                undefined | string | RawSourceMap,
                undefined | PreparsedAst
            ],
            NormalModule
        ],
        [
            string | Buffer,
            undefined | string | RawSourceMap,
            undefined | PreparsedAst
        ]
    >;
    needBuild: AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>;
};

method getCurrentLoader

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

method getResource

getResource: () => null | string;

method getSourceBasicTypes

static getSourceBasicTypes: (module: Module) => ReadonlySet<string>;

Gets source basic types.
Deprecated
In webpack 6, call getSourceBasicTypes() directly on the module instance instead of using this static method.

method markModuleAsErrored

markModuleAsErrored: (error: Error) => void;

method restoreFromUnsafeCache

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

restore unsafe cache data

method shouldPreventParsing

shouldPreventParsing: (
    noParseRule:
        | string
        | RegExp
        | ((content: string) => boolean)
        | (string | RegExp | ((content: string) => boolean))[],
    request: string
) => boolean;

class NormalModuleReplacementPlugin

class NormalModuleReplacementPlugin {}

constructor

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

Create an instance of the plugin

property newResource

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

property resourceRegExp

resourceRegExp: RegExp;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class Parser

class ParserClass {}

constructor

constructor();

method parse

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

Parses the provided source and updates the parser state.

class PlatformPlugin

class PlatformPlugin {}

Should be used only for "target === false" or when you want to overwrite platform target properties

constructor

constructor(platform: Partial<PlatformTargetProperties>);

Creates an instance of PlatformPlugin.

property platform

platform: Partial<PlatformTargetProperties>;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class PrefetchPlugin

class PrefetchPlugin {}

constructor

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

Creates an instance of PrefetchPlugin.

property context

context: string;

property request

request: string;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class ProgressPlugin

class ProgressPlugin {}

constructor

constructor(options?: ProgressPluginArgument);

Creates an instance of ProgressPlugin.

property createDefaultHandler

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

property defaultOptions

static defaultOptions: Required<Omit<ProgressPluginOptions, 'handler'>>;

property dependenciesCount

dependenciesCount: number;

property estimatedTime

estimatedTime: boolean;

property handler

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

property modulesCount

modulesCount: number;

property options

options: ProgressPluginOptions;

property percentBy

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

property phaseTimings

phaseTimings: boolean;

property profile

profile: boolean;

property progressBar

progressBar:
    | false
    | 'auto'
    | Required<{ color?: string; name?: string; width?: number }>;

property showActiveModules

showActiveModules: boolean;

property showDependencies

showDependencies: boolean;

property showEntries

showEntries: boolean;

property showModules

showModules: boolean;

method apply

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

Applies the plugin by registering its hooks on the compiler.

method getReporter

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

Returns a progress reporter, if any.

class ProvidePlugin

class ProvidePlugin {}

constructor

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

Creates an instance of ProvidePlugin.

property definitions

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

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class Resolver

abstract class Resolver {}

property fileSystem

fileSystem: FileSystem;

property hooks

hooks: KnownHooks;

property options

options: ResolveOptionsResolverFactoryObject1;

property pathCache

pathCache: PathCacheFunctions;

method basename

basename: (path: string, suffix?: string) => string;

method dirname

dirname: (path: string) => string;

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: {
    (
        parent: string | URL_url,
        specifier: string | URL_url,
        callback: (
            err: null | ErrorWithDetail,
            res?: string | false,
            req?: ResolveRequest
        ) => void
    ): void;
    (
        parent: string | URL_url,
        specifier: string | URL_url,
        resolveContext: ResolveContext,
        callback: (
            err: ErrorWithDetail,
            res?: string | false,
            req?: ResolveRequest
        ) => void
    ): void;
    (
        context: ContextTypes,
        parent: string | URL_url,
        specifier: string | URL_url,
        callback: (
            err: ErrorWithDetail,
            res?: string | false,
            req?: ResolveRequest
        ) => void
    ): void;
    (
        context: ContextTypes,
        parent: string | URL_url,
        specifier: string | URL_url,
        resolveContext: ResolveContext,
        callback: (
            err: ErrorWithDetail,
            res?: string | false,
            req?: ResolveRequest
        ) => void
    ): void;
};

method resolvePromise

resolvePromise: {
    (
        parent: string | URL_url,
        specifier: string | URL_url,
        resolveContext?: ResolveContext
    ): Promise<string | false>;
    (
        context: ContextTypes,
        parent: string | URL_url,
        specifier: string | URL_url,
        resolveContext?: ResolveContext
    ): Promise<string | false>;
};

method resolveSync

resolveSync: {
    (
        parent: string | URL_url,
        specifier: string | URL_url,
        resolveContext?: ResolveContext
    ): string | false;
    (
        context: ContextTypes,
        parent: string | URL_url,
        specifier: string | URL_url,
        resolveContext?: ResolveContext
    ): string | false;
};

class RuntimeModule

class RuntimeModule extends Module {}

constructor

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

Creates an instance of RuntimeModule.

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;

Processes the provided compilation.

method generate

generate: () => null | string;

Generates runtime code for this runtime module.

method getGeneratedCode

getGeneratedCode: () => null | string;

Gets generated code.

method getSourceBasicTypes

static getSourceBasicTypes: (module: Module) => ReadonlySet<string>;

Gets source basic types.
Deprecated
In webpack 6, call getSourceBasicTypes() directly on the module instance instead of using this static method.

method shouldIsolate

shouldIsolate: () => boolean;

Returns true, if the runtime module should get it's own scope.

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;

Applies the plugin by registering its hooks on the compiler.

method createDependency

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

Creates a dependency.

class SourceMapDevToolPlugin

class SourceMapDevToolPlugin {}

constructor

constructor(options?: SourceMapDevToolPluginOptions);

Creates an instance of SourceMapDevToolPlugin.

property fallbackModuleFilenameTemplate

fallbackModuleFilenameTemplate: DevtoolFallbackModuleFilenameTemplate;

property moduleFilenameTemplate

moduleFilenameTemplate: DevtoolModuleFilenameTemplate;

property namespace

namespace: string;

property options

options: SourceMapDevToolPluginOptions;

property sourceMapFilename

sourceMapFilename?: string | false;

property sourceMappingURLComment

sourceMappingURLComment: string | false | TemplatePathFn<PathData>;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class Stats

class Stats {}

constructor

constructor(compilation: Compilation);

Creates an instance of Stats.

property compilation

compilation: Compilation;

property endTime

readonly endTime: number;

property hash

readonly hash: string;

property startTime

readonly startTime: number;

method hasErrors

hasErrors: () => boolean;

Checks whether this stats has errors.

method hasWarnings

hasWarnings: () => boolean;

Checks whether this stats has warnings.

method toJson

toJson: (
    options?:
        | boolean
        | StatsOptions
        | 'none'
        | 'summary'
        | 'errors-only'
        | 'errors-warnings'
        | 'minimal'
        | 'normal'
        | 'detailed'
        | 'verbose'
) => StatsCompilation;

Returns json output.

method toString

toString: (
    options?:
        | boolean
        | StatsOptions
        | 'none'
        | 'summary'
        | 'errors-only'
        | 'errors-warnings'
        | 'minimal'
        | 'normal'
        | 'detailed'
        | 'verbose'
) => string;

Returns a string representation.

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;

Returns a single string from array.

method getFunctionContent

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

Gets function content.

method getModulesArrayBounds

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

Gets modules array bounds.

method indent

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

Returns converted identity.

method numberToIdentifier

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

Number to identifier.

method numberToIdentifierContinuation

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

Number to identifier continuation.

method prefix

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

Returns new prefix string.

method renderChunkModules

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

Renders chunk modules.

method renderChunkRuntimeModules

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

Renders chunk runtime modules.

method renderRuntimeModules

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

Renders runtime modules.

method toComment

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

Returns a commented version of string.

method toIdentifier

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

Returns created identifier.

method toNormalComment

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

Returns a commented version of string.

method toPath

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

Returns normalized bundle-safe path.

class WatchIgnorePlugin

class WatchIgnorePlugin {}

constructor

constructor(options: WatchIgnorePluginOptions);

Creates an instance of WatchIgnorePlugin.

property options

options: WatchIgnorePluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class Watching

abstract class Watching {}

property blocked

blocked: boolean;

property callbacks

callbacks: ((err: null | Error, result?: void) => void)[];

property closed

closed: boolean;

property compiler

compiler: Compiler;

property handler

handler: CallbackWebpackFunction_2<Stats, void>;

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: (err: null | Error, result?: void) => void) => void;

Processes the provided error callback.

method invalidate

invalidate: (callback?: (err: null | Error, result?: void) => void) => void;

Processes the provided error callback.

method resume

resume: () => void;

method suspend

suspend: () => void;

method watch

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

Processes the provided file.

class WebpackError

class WebpackError extends Error {}

constructor

constructor(message?: string, options?: { cause?: unknown });

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 stackTraceLimit

static stackTraceLimit: number;

The Error.stackTraceLimit property specifies the number of stack frames collected by a stack trace (whether generated by new Error().stack or Error.captureStackTrace(obj)). The default value is 10 but may be set to any valid JavaScript number. Changes will affect any stack trace captured _after_ the value has been changed. If set to a non-number value, or set to a negative number, stack traces will not capture any frames.

method captureStackTrace

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

Creates a .stack property on targetObject, which when accessed returns a string representing the location in the code at which Error.captureStackTrace() was called.

const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack;  // Similar to `new Error().stack`

The first line of the trace will be prefixed with ${myObject.name}: ${myObject.message}. The optional constructorOpt argument accepts a function. If given, all frames above constructorOpt, including constructorOpt, will be omitted from the generated stack trace. The constructorOpt argument is useful for hiding implementation details of error generation from the user. For instance:

function a() {
  b();
}
function b() {
  c();
}
function c() {
  // Create an error without stack trace to avoid calculating the stack trace twice.
  const { stackTraceLimit } = Error;
  Error.stackTraceLimit = 0;
  const error = new Error();
  Error.stackTraceLimit = stackTraceLimit;
  // Capture the stack trace above function b
  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
  throw error;
}
a();

method deserialize

deserialize: (__0: ObjectDeserializerContextObjectMiddlewareObject_4) => void;

Restores this instance from the provided deserializer context.

method prepareStackTrace

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

method serialize

serialize: (__0: ObjectSerializerContextObjectMiddlewareObject_5) => void;

Serializes this instance into the provided serializer context.

class WebpackOptionsApply

class WebpackOptionsApply extends OptionsApply {}

constructor

constructor();

class WebpackOptionsDefaulter

class WebpackOptionsDefaulter {}

constructor

constructor();

method process

process: (options: Configuration) => WebpackOptionsNormalized;

Returns normalized webpack options.

Interfaces

interface Argument

interface Argument {}

Returns object of arguments.

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 {}

Checks whether this object is sorted.

property compilation

compilation: Compilation;

property content

content: Buffer;

property outputPath

outputPath: string;

property source

source: Source;

property targetPath

targetPath: string;

interface Colors

interface Colors {}

property bgBlack

bgBlack: (value?: any) => string;

property bgBlackBright

bgBlackBright: (value?: any) => string;

property bgBlue

bgBlue: (value?: any) => string;

property bgBlueBright

bgBlueBright: (value?: any) => string;

property bgCyan

bgCyan: (value?: any) => string;

property bgCyanBright

bgCyanBright: (value?: any) => string;

property bgGreen

bgGreen: (value?: any) => string;

property bgGreenBright

bgGreenBright: (value?: any) => string;

property bgMagenta

bgMagenta: (value?: any) => string;

property bgMagentaBright

bgMagentaBright: (value?: any) => string;

property bgRed

bgRed: (value?: any) => string;

property bgRedBright

bgRedBright: (value?: any) => string;

property bgWhite

bgWhite: (value?: any) => string;

property bgWhiteBright

bgWhiteBright: (value?: any) => string;

property bgYellow

bgYellow: (value?: any) => string;

property bgYellowBright

bgYellowBright: (value?: any) => string;

property black

black: (value?: any) => string;

property blackBright

blackBright: (value?: any) => string;

property blue

blue: (value?: any) => string;

property blueBright

blueBright: (value?: any) => string;

property bold

bold: (value?: any) => string;

property cyan

cyan: (value?: any) => string;

property cyanBright

cyanBright: (value?: any) => string;

property dim

dim: (value?: any) => string;

property gray

gray: (value?: any) => string;

property green

green: (value?: any) => string;

property greenBright

greenBright: (value?: any) => string;

property hidden

hidden: (value?: any) => string;

property inverse

inverse: (value?: any) => string;

property italic

italic: (value?: any) => string;

property magenta

magenta: (value?: any) => string;

property magentaBright

magentaBright: (value?: any) => string;

property red

red: (value?: any) => string;

property redBright

redBright: (value?: any) => string;

property reset

reset: (value?: any) => string;

property strikethrough

strikethrough: (value?: any) => string;

property underline

underline: (value?: any) => string;

property white

white: (value?: any) => string;

property whiteBright

whiteBright: (value?: any) => string;

property yellow

yellow: (value?: any) => string;

property yellowBright

yellowBright: (value?: any) => string;

interface ColorsOptions

interface ColorsOptions {}

Creates a colors from the provided colors option.

property useColor

useColor?: boolean;

force use colors

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
    | {
          /**
           * Which asset type should receive this devtool value.
           */
          type: 'css' | 'all' | 'javascript';
          /**
           * A developer tool to enhance debugging (false | eval | [inline-|hidden-|eval-][nosources-][cheap-[module-]]source-map).
           */
          use: RawDevTool;
      }[];

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

property dotenv

dotenv?: boolean | DotenvPluginOptions;

Enable and configure the Dotenv plugin to load environment variables from .env files.

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
    | (ExternalItemObjectKnown & ExternalItemObjectUnknown)
    | ((
          data: ExternalItemFunctionData,
          callback: (
              err?: null | Error,
              result?:
                  | string
                  | boolean
                  | string[]
                  | (ExternalItemValueObjectKnown &
                        ExternalItemValueObjectUnknown)
          ) => void
      ) => void)
    | ((data: ExternalItemFunctionData) => Promise<ExternalItemValue>)
    | ExternalItem[];

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'
    | 'amd-async'
    | 'promise'
    | 'module-import'
    | 'script'
    | 'node-commonjs'
    | 'asset'
    | 'asset-url'
    | 'css-import'
    | 'css-url';

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: Error, 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'
    | 'summary'
    | 'errors-only'
    | 'errors-warnings'
    | 'minimal'
    | 'normal'
    | 'detailed'
    | 'verbose';

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 validate

validate?: boolean;

Enable validation of webpack configuration. Defaults to true in development mode. In production mode, defaults to true unless futureDefaults is enabled, then defaults to false.

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 {}

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 dependency

property getResolve

getResolve: (
    options?: ResolveOptions
) =>
    | ((
          context: string,
          request: string,
          callback: (
              err?: null | Error,
              result?: string | false,
              resolveRequest?: ResolveRequest
          ) => 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' | 'zstd';

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 GeneratorOptionsByModuleTypeKnown

interface GeneratorOptionsByModuleTypeKnown {}

Specify options for each generator.

property "asset/bytes"

'asset/bytes'?: EmptyGeneratorOptions;

No generator options are supported for this module type.

property "asset/inline"

'asset/inline'?: AssetInlineGeneratorOptions;

Generator options for asset/inline modules.

property "asset/resource"

'asset/resource'?: AssetResourceGeneratorOptions;

Generator options for asset/resource modules.

property "asset/source"

'asset/source'?: EmptyGeneratorOptions;

No generator options are supported for this module type.

property "css/auto"

'css/auto'?: CssModuleGeneratorOptions;

Generator options for css/module modules.

property "css/global"

'css/global'?: CssModuleGeneratorOptions;

Generator options for css/module modules.

property "css/module"

'css/module'?: CssModuleGeneratorOptions;

Generator options for css/module modules.

property "javascript/auto"

'javascript/auto'?: EmptyGeneratorOptions;

No generator options are supported for this module type.

property "javascript/dynamic"

'javascript/dynamic'?: EmptyGeneratorOptions;

No generator options are supported for this module type.

property "javascript/esm"

'javascript/esm'?: EmptyGeneratorOptions;

No generator options are supported for this module type.

property asset

asset?: AssetGeneratorOptions;

Generator options for asset modules.

property css

css?: CssGeneratorOptions;

Generator options for css modules.

property html

html?: HtmlGeneratorOptions;

Generator options for html modules.

property javascript

javascript?: EmptyGeneratorOptions;

No generator options are supported for this module type.

property json

json?: JsonGeneratorOptions;

Generator options for json modules.

interface InputFileSystem

interface InputFileSystem {}

Returns location of targetPath relative to rootPath.

property dirname

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

property join

join?: (path1: string, path2: string) => string;

property lstat

lstat?: LStatFs;

property lstatSync

lstatSync?: LStatSync;

property purge

purge?: (
    value?: string | string[] | Set<string>,
    options?: { exact?: boolean }
) => void;

property readdir

readdir: ReaddirFs;

property readdirSync

readdirSync?: ReaddirSync;

property readFile

readFile: ReadFileFs;

property readFileSync

readFileSync?: ReadFileSync;

property readJson

readJson?: (
    pathOrFileDescriptor: PathOrFileDescriptorFs,
    callback: (
        err: null | Error | NodeJS.ErrnoException,
        result?: JsonObjectFs
    ) => void
) => void;

property readJsonSync

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

property readlink

readlink: ReadlinkFs;

property readlinkSync

readlinkSync?: ReadlinkSync;

property realpath

realpath?: RealPathFs;

property realpathSync

realpathSync?: RealPathSync;

property relative

relative?: (from: string, to: 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 | RawSourceMap,
    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.
Deprecated

property exprContextRecursive

exprContextRecursive?: boolean;

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

property exprContextRegExp

exprContextRegExp?: boolean | RegExp;

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

property exprContextRequest

exprContextRequest?: string;

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

property generator

generator?: GeneratorOptionsByModuleType;

Specify options for each generator.

property noParse

noParse?:
    | string
    | RegExp
    | ((content: string) => boolean)
    | (string | RegExp | ((content: string) => boolean))[];

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'.
Deprecated

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'.
Deprecated

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'.
Deprecated

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'.
Deprecated

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'.
Deprecated

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'.
Deprecated

property unsafeCache

unsafeCache?: boolean | ((module: Module) => boolean);

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'.
Deprecated

property wrappedContextRecursive

wrappedContextRecursive?: boolean;

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

property wrappedContextRegExp

wrappedContextRegExp?: RegExp;

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

interface MultiCompilerOptions

interface MultiCompilerOptions {}

property parallelism

parallelism?: number;

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

interface MultiStatsOptions

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 | false;

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).
Deprecated

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
    | StatsOptions
    | 'none'
    | 'summary'
    | 'errors-only'
    | 'errors-warnings'
    | 'minimal'
    | 'normal'
    | 'detailed'
    | 'verbose'
    | StatsValue[];

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 chunkGroupResourceHints

chunkGroupResourceHints?: boolean;

Include the resolved <link> resource-hint descriptors for each entrypoint (entrypoints[name].resourceHints). Combines output.resourceHints.chunks (initial-graph modulepreload/preload/prefetch) with output.resourceHints.assets (URL-referenced fonts / images / …). Lets SSR frameworks inject the hints server-side without walking the chunk graph themselves; the analogue of Vite's build.ssrManifest. 5.109.0

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 | false;

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 errorCause

errorCause?: boolean | 'auto';

Add cause to errors.

property errorDetails

errorDetails?: boolean | 'auto';

Add details to errors (like resolving log).

property errorErrors

errorErrors?: boolean | 'auto';

Add nested errors to errors (like in AggregateError).

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' | 'verbose' | 'error' | 'warn' | 'info' | 'log';

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 | false;

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).
Deprecated

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, warningString: 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 OutputFileSystem

interface OutputFileSystem {}

Returns location of targetPath relative to rootPath.

property createReadStream

createReadStream?: (
    path: PathLikeFs,
    options?:
        | 'ascii'
        | 'utf8'
        | 'utf-8'
        | 'utf16le'
        | 'utf-16le'
        | 'ucs2'
        | 'ucs-2'
        | 'base64'
        | 'base64url'
        | 'latin1'
        | 'binary'
        | 'hex'
        | ReadStreamOptions
) => NodeJS.ReadableStream;

property dirname

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

property join

join?: (path1: string, path2: string) => string;

property lstat

lstat?: LStatFs;

property mkdir

mkdir: Mkdir;

property readdir

readdir?: ReaddirFs;

property readFile

readFile: ReadFileFs;

property relative

relative?: (from: string, to: string) => string;

property rmdir

rmdir?: (
    file: PathLikeFs,
    callback: (err: null | NodeJS.ErrnoException) => void
) => void;

property stat

stat: StatFs;

property unlink

unlink?: (
    pathLike: PathLikeFs,
    callback: (err: null | NodeJS.ErrnoException) => void
) => void;

property writeFile

writeFile: WriteFile;

interface ParserOptionsByModuleTypeKnown

interface ParserOptionsByModuleTypeKnown {}

Specify options for each parser.

property "asset/bytes"

'asset/bytes'?: EmptyParserOptions;

No parser options are supported for this module type.

property "asset/inline"

'asset/inline'?: EmptyParserOptions;

No parser options are supported for this module type.

property "asset/resource"

'asset/resource'?: EmptyParserOptions;

No parser options are supported for this module type.

property "asset/source"

'asset/source'?: EmptyParserOptions;

No parser options are supported for this module type.

property "css/auto"

'css/auto'?: CssAutoOrModuleParserOptions;

Parser options for css/auto and css/module modules.

property "css/global"

'css/global'?: CssModuleParserOptions;

Parser options for css/global modules.

property "css/module"

'css/module'?: CssAutoOrModuleParserOptions;

Parser options for css/auto and css/module modules.

property "javascript/auto"

'javascript/auto'?: JavascriptParserOptions;

Parser options for javascript modules.

property "javascript/dynamic"

'javascript/dynamic'?: JavascriptParserOptions;

Parser options for javascript modules.

property "javascript/esm"

'javascript/esm'?: JavascriptParserOptions;

Parser options for javascript modules.

property asset

asset?: AssetParserOptions;

Parser options for asset modules.

property css

css?: CssParserOptions;

Parser options for css modules.

property html

html?: HtmlParserOptions;

Parser options for html modules.

property javascript

javascript?: JavascriptParserOptions;

Parser options for javascript modules.

property json

json?: JsonParserOptions;

Parser options for JSON modules.

interface PathData

interface PathData {}

property basename

basename?: string;

property chunk

chunk?: Chunk | ChunkPathData;

property chunkGraph

chunkGraph?: ChunkGraph;

property contentHash

contentHash?: string;

property contentHashFull

contentHashFull?: string;

untruncated module/asset content hash, for re-encoding [contenthash:<digest>] from full entropy

property contentHashType

contentHashType?: string;

property contentHashWithLength

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

property filename

filename?: string;

property fullHash

fullHash?: string;

untruncated compilation hash, for re-encoding [fullhash:<digest>]

property fullHashDigest

fullHashDigest?: string;

digest fullHash is encoded in (defaults to hashDigest)

property hash

hash?: string;

property hashAsFullHash

hashAsFullHash?: boolean;

treat [hash] as [fullhash] rather than the module hash (CSS local idents)

property hashDigest

hashDigest?: string;

digest the stored hashes are encoded in (for [hash:<digest>])

property hashWithDigest

hashWithDigest?: (digest: string, length?: number) => string;

builds [fullhash:<digest>]/[hash:<digest>] in the runtime chunk-filename context, where it throws because a runtime getFullHash() expression cannot be re-encoded

property hashWithLength

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

property local

local?: string;

property module

module?: Module | ModulePathData;

property noChunkHash

noChunkHash?: boolean;

property prepareId

prepareId?: (id: string | number) => string | number;

property query

query?: string;

property realContentHash

realContentHash?: boolean;

whether optimization.realContentHash recomputes content hashes (records an inline [contenthash:<digest>] so it re-encodes in that digest)

property runtime

runtime?: RuntimeSpec;

property uniqueName

uniqueName?: string;

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 {}

Returns object of arguments.

property argument

argument: string;

property expected

expected?: string;

property index

index?: number;

property path

path: string;

property type

type: ProblemType;

property value

value?: string | number | boolean | RegExp;

interface RawLoaderDefinitionFunction

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

call signature

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

interface RenderManifestOptions

interface RenderManifestOptions {}

property chunk

chunk: Chunk;

the chunk used to render

property chunkGraph

chunkGraph: ChunkGraph;

property codeGenerationResults

codeGenerationResults: CodeGenerationResults;

property dependencyTemplates

dependencyTemplates: DependencyTemplates;

property fullHash

fullHash: string;

property hash

hash: string;

property moduleGraph

moduleGraph: ModuleGraph;

property moduleTemplates

moduleTemplates: { javascript: ModuleTemplate };

property outputOptions

outputOptions: OutputNormalizedWithDefaults;

property runtimeTemplate

runtimeTemplate: RuntimeTemplate;

interface ResolveData

interface ResolveData {}

property attributes

attributes?: ImportAttributes;

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<CreateData>;

property dependencies

dependencies: ModuleDependency[];

property dependencyType

dependencyType: string;

property fileDependencies

fileDependencies: LazySet<string>;

property ignoredModule

ignoredModule?: Module;

property missingDependencies

missingDependencies: LazySet<string>;

property phase

phase?: 'defer' | 'source' | 'evaluation';

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 tsconfig

tsconfig?:
    | string
    | boolean
    | {
          /**
           * A path to the tsconfig file.
           */
          configFile?: string;
          /**
           * References to other tsconfig files. 'auto' inherits from TypeScript config, or an array of relative/absolute paths.
           */
          references?: string;
      };

TypeScript config for paths mapping. Can be false (disabled), true (use default tsconfig.json), a string path to tsconfig.json, or an object with configFile and references options.

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 extractSourceMap

extractSourceMap?: boolean;

Enable/Disable extracting source map.

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 phase

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

Match the import phase of the dependency.

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
          | RuleSetUseFunction
          | {
                /**
                 * Unique loader options identifier.
                 */
                ident?: string;
                /**
                 * Loader name.
                 */
                loader?: string;
                /**
                 * Loader options.
                 */
                options?: string | { [index: string]: any };
            }
      )[]
    | RuleSetUseFunction
    | {
          /**
           * Unique loader options identifier.
           */
          ident?: string;
          /**
           * Loader name.
           */
          loader?: string;
          /**
           * Loader options.
           */
          options?: string | { [index: string]: any };
      };

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 | false;

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).
Deprecated

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
    | StatsOptions
    | 'none'
    | 'summary'
    | 'errors-only'
    | 'errors-warnings'
    | 'minimal'
    | 'normal'
    | 'detailed'
    | 'verbose'
    | StatsValue[];

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 chunkGroupResourceHints

chunkGroupResourceHints?: boolean;

Include the resolved <link> resource-hint descriptors for each entrypoint (entrypoints[name].resourceHints). Combines output.resourceHints.chunks (initial-graph modulepreload/preload/prefetch) with output.resourceHints.assets (URL-referenced fonts / images / …). Lets SSR frameworks inject the hints server-side without walking the chunk graph themselves; the analogue of Vite's build.ssrManifest. 5.109.0

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 | false;

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 errorCause

errorCause?: boolean | 'auto';

Add cause to errors.

property errorDetails

errorDetails?: boolean | 'auto';

Add details to errors (like resolving log).

property errorErrors

errorErrors?: boolean | 'auto';

Add nested errors to errors (like in AggregateError).

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' | 'verbose' | 'error' | 'warn' | 'info' | 'log';

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 | false;

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).
Deprecated

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, warningString: 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
    | {
          /**
           * Which asset type should receive this devtool value.
           */
          type: 'css' | 'all' | 'javascript';
          /**
           * A developer tool to enhance debugging (false | eval | [inline-|hidden-|eval-][nosources-][cheap-[module-]]source-map).
           */
          use: RawDevTool;
      }[];

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

property dotenv

dotenv?: boolean | DotenvPluginOptions;

Enable and configure the Dotenv plugin to load environment variables from .env files.

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'
    | 'amd-async'
    | 'promise'
    | 'module-import'
    | 'script'
    | 'node-commonjs'
    | 'asset'
    | 'asset-url'
    | 'css-import'
    | 'css-url';

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

property ignoreWarnings

ignoreWarnings?: ((warning: Error, 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: NodeWebpackOptions;

Include polyfills or mocks for various node stuff.

property optimization

optimization: OptimizationNormalized;

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: (
    | ((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 validate

validate?: boolean;

Enable validation of webpack configuration. Defaults to true in development mode. In production mode, defaults to true unless futureDefaults is enabled, then defaults to false.

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 AssetModuleBuildInfo

type AssetModuleBuildInfo = KnownBuildInfo &
    Record<string, any> &
    KnownNormalModuleBuildInfo &
    KnownAssetModuleBuildInfo;

type BuildInfo

type BuildInfo = KnownBuildInfo & Record<string, any>;

type BuildMeta

type BuildMeta = KnownBuildMeta & Record<string, any>;

type ConcatenatedModuleBuildInfo

type ConcatenatedModuleBuildInfo = KnownBuildInfo &
    Record<string, any> &
    KnownConcatenatedModuleBuildInfo;

type ConfigurationFactory

type ConfigurationFactory = (
    env: Record<string, any>,
    argv: Record<string, any>
) => MaybePromise<Configuration | MultiConfiguration>;

type ContextModuleBuildInfo

type ContextModuleBuildInfo = KnownBuildInfo &
    Record<string, any> &
    KnownContextModuleBuildInfo;

type CssModuleBuildInfo

type CssModuleBuildInfo = KnownBuildInfo &
    Record<string, any> &
    KnownNormalModuleBuildInfo &
    KnownCssModuleBuildInfo;

type CssModuleBuildMeta

type CssModuleBuildMeta = KnownBuildMeta &
    Record<string, any> &
    KnownCssModuleBuildMeta;

type DefineConfigInput

type DefineConfigInput =
    | Configuration
    | MultiConfiguration
    | ((
          env: Record<string, any>,
          argv: Record<string, any>
      ) => MaybePromise<Configuration | MultiConfiguration>)
    | ((
          env: Record<string, any>,
          argv: Record<string, any>
      ) => MaybePromise<Configuration | MultiConfiguration>)[]
    | Promise<
          | Configuration
          | MultiConfiguration
          | ((
                env: Record<string, any>,
                argv: Record<string, any>
            ) => MaybePromise<Configuration | MultiConfiguration>)
          | ((
                env: Record<string, any>,
                argv: Record<string, any>
            ) => MaybePromise<Configuration | MultiConfiguration>)[]
      >;

type Entry

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

type EntryNormalized

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

type EntryOptions

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

type ExternalItem

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

type ExternalItemFunction

type ExternalItemFunction =
    | ((
          data: ExternalItemFunctionData,
          callback: (
              err?: null | Error,
              result?:
                  | string
                  | boolean
                  | string[]
                  | (ExternalItemValueObjectKnown & ExternalItemValueObjectUnknown)
          ) => void
      ) => void)
    | ((data: ExternalItemFunctionData) => Promise<ExternalItemValue>);

type ExternalItemFunctionCallback

type ExternalItemFunctionCallback = (
    data: ExternalItemFunctionData,
    callback: (
        err?: null | Error,
        result?:
            | string
            | boolean
            | string[]
            | (ExternalItemValueObjectKnown & ExternalItemValueObjectUnknown)
    ) => void
) => void;

type ExternalItemFunctionDataGetResolve

type ExternalItemFunctionDataGetResolve = (
    options?: ResolveOptions
) =>
    | ((
          context: string,
          request: string,
          callback: (
              err?: null | Error,
              result?: string | false,
              resolveRequest?: ResolveRequest
          ) => void
      ) => void)
    | ((context: string, request: string) => Promise<string>);

type ExternalItemFunctionDataGetResolveCallbackResult

type ExternalItemFunctionDataGetResolveCallbackResult = (
    context: string,
    request: string,
    callback: (
        err?: null | Error,
        result?: string | false,
        resolveRequest?: ResolveRequest
    ) => void
) => void;

type ExternalItemFunctionDataGetResolveResult

type ExternalItemFunctionDataGetResolveResult = (
    context: string,
    request: string
) => Promise<string>;

type ExternalItemFunctionPromise

type ExternalItemFunctionPromise = (
    data: ExternalItemFunctionData
) => Promise<ExternalItemValue>;

type ExternalItemValue

type ExternalItemValue =
    | string
    | boolean
    | string[]
    | (ExternalItemValueObjectKnown & ExternalItemValueObjectUnknown);

type ExternalModuleBuildInfo

type ExternalModuleBuildInfo = KnownBuildInfo &
    Record<string, any> &
    KnownExternalModuleBuildInfo;

type Externals

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

type HtmlModuleBuildInfo

type HtmlModuleBuildInfo = KnownBuildInfo &
    Record<string, any> &
    KnownNormalModuleBuildInfo &
    KnownHtmlModuleBuildInfo;

type JavascriptModuleBuildInfo

type JavascriptModuleBuildInfo = KnownBuildInfo &
    Record<string, any> &
    KnownNormalModuleBuildInfo &
    KnownJavascriptModuleBuildInfo;

type JavascriptModuleBuildMeta

type JavascriptModuleBuildMeta = KnownBuildMeta &
    Record<string, any> &
    KnownJavascriptModuleBuildMeta;

type JsonModuleBuildInfo

type JsonModuleBuildInfo = KnownBuildInfo &
    Record<string, any> &
    KnownNormalModuleBuildInfo &
    KnownJsonModuleBuildInfo;

type LoaderContext

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

type LoaderDefinition

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

type MultiConfiguration

type MultiConfiguration = ReadonlyArray<Configuration> & MultiCompilerOptions;

type NormalModuleBuildInfo

type NormalModuleBuildInfo = KnownBuildInfo &
    Record<string, any> &
    KnownNormalModuleBuildInfo;

type ObjectDeserializerContext

type ObjectDeserializerContext =
    typeof ObjectDeserializerContextObjectMiddlewareObject_2;

type ObjectSerializerContext

type ObjectSerializerContext =
    typeof ObjectSerializerContextObjectMiddlewareObject_3;

type ParserState

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

type PathDataChunk

type PathDataChunk = PathData & { chunk: Chunk | ChunkPathData };

type PathDataModule

type PathDataModule = PathData & {
    module: Module | ModulePathData;
    chunkGraph: ChunkGraph;
};

type RawLoaderDefinition

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

type RenderManifestEntry

type RenderManifestEntry = RenderManifestEntryTemplated | RenderManifestEntryStatic;

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
          | RuleSetUseFunction
          | {
                /**
                 * Unique loader options identifier.
                 */
                ident?: string;
                /**
                 * Loader name.
                 */
                loader?: string;
                /**
                 * Loader options.
                 */
                options?: string | { [index: string]: any };
            }
      )[]
    | RuleSetUseFunction
    | {
          /**
           * Unique loader options identifier.
           */
          ident?: string;
          /**
           * Loader name.
           */
          loader?: string;
          /**
           * Loader options.
           */
          options?: string | { [index: string]: any };
      };

type RuleSetUseFunction

type RuleSetUseFunction = (data: EffectData) =>
    | string
    | RuleSetUseFunction
    | {
          /**
           * Unique loader options identifier.
           */
          ident?: string;
          /**
           * Loader name.
           */
          loader?: string;
          /**
           * Loader options.
           */
          options?: string | { [index: string]: any };
      }
    | (
          | undefined
          | null
          | string
          | false
          | 0
          | RuleSetUseFunction
          | {
                /**
                 * Unique loader options identifier.
                 */
                ident?: string;
                /**
                 * Loader name.
                 */
                loader?: string;
                /**
                 * Loader options.
                 */
                options?: string | { [index: string]: any };
            }
      )[];

type RuleSetUseItem

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

type StatsAsset

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

type StatsChunk

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

type StatsChunkGroup

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

type StatsChunkOrigin

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

type StatsCompilation

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

type StatsError

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

type StatsLogging

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

type StatsLoggingEntry

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

type StatsModule

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

type StatsModuleIssuer

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

type StatsModuleReason

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

type StatsModuleTraceDependency

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

type StatsModuleTraceItem

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

type StatsProfile

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

type SyncWasmModuleBuildMeta

type SyncWasmModuleBuildMeta = KnownBuildMeta &
    Record<string, any> &
    KnownSyncWasmModuleBuildMeta;

type TemplatePath

type TemplatePath = string | TemplatePathFn<PathData>;

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;

Applies the plugin by registering its hooks on the compiler.

namespace cli

namespace cli {}

function createColors

createColors: (__0?: ColorsOptions) => Colors;

function getArguments

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

function isColorSupported

isColorSupported: () => boolean;

function processArguments

processArguments: (
    args: Flags,
    config: ObjectConfiguration,
    values: Values
) => 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);

Creates an instance of ContainerPlugin.

property options

options: ContainerPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class ContainerReferencePlugin

class ContainerReferencePlugin {}

constructor

constructor(options: ContainerReferencePluginOptions);

Creates an instance of ContainerReferencePlugin.

property options

options: ContainerReferencePluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class ModuleFederationPlugin

class ModuleFederationPlugin {}

constructor

constructor(options: ModuleFederationPluginOptions);

Creates an instance of ModuleFederationPlugin.

property getCompilationHooks

static getCompilationHooks: (compilation: Compilation) => {
    addContainerEntryDependency: SyncHook<Dependency>;
    addFederationRuntimeDependency: SyncHook<Dependency>;
};

property options

options: ModuleFederationPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

namespace css

namespace css {}

class CssModulesPlugin

class CssModulesPlugin {}

constructor

constructor();

property getCompilationHooks

static getCompilationHooks: (compilation: Compilation) => {
    renderModulePackage: SyncWaterfallHook<
        [Source, Module, ChunkRenderContextCssModulesPlugin],
        Source
    >;
    chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
    orderModules: SyncBailHook<
        [Chunk, Module[], Compilation],
        undefined | void | Module[]
    >;
};

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

method chunkHasCss

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

Returns true, when the chunk has css.

method getChunkFilenameTemplate

static getChunkFilenameTemplate: (
    chunk: Chunk,
    outputOptions: OutputNormalizedWithDefaults
) => ChunkFilenameTemplate;

Gets chunk filename template.

method getModulesInOrder

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

Gets modules in order.

method getOrderedChunkCssModules

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

Gets ordered chunk css modules.

method renderChunk

renderChunk: (
    __0: RenderContextCssModulesPlugin,
    hooks: {
        renderModulePackage: SyncWaterfallHook<
            [Source, Module, ChunkRenderContextCssModulesPlugin],
            Source
        >;
        chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
        orderModules: SyncBailHook<
            [Chunk, Module[], Compilation],
            undefined | void | Module[]
        >;
    }
) => Source;

Renders generated source.

method renderModule

static renderModule: (
    module: CssModule,
    renderContext: ChunkRenderContextCssModulesPlugin,
    hooks: {
        renderModulePackage: SyncWaterfallHook<
            [Source, Module, ChunkRenderContextCssModulesPlugin],
            Source
        >;
        chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
        orderModules: SyncBailHook<
            [Chunk, Module[], Compilation],
            undefined | void | Module[]
        >;
    }
) => null | Source;

Renders css module source.

namespace debug

namespace debug {}

class ProfilingPlugin

class ProfilingPlugin {}

constructor

constructor(options?: ProfilingPluginOptions);

Creates an instance of ProfilingPlugin.

property options

options: ProfilingPluginOptions;

property Profiler

static Profiler: typeof Profiler;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

namespace dependencies

namespace dependencies {}

class ConstDependency

class ConstDependency extends NullDependency {}

constructor

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

Creates an instance of ConstDependency.

property EXPORTS_OBJECT_REFERENCED

static EXPORTS_OBJECT_REFERENCED: string[][];

property EXPORTS_OBJECT_REFERENCED_MANGLEABLE

static EXPORTS_OBJECT_REFERENCED_MANGLEABLE: string[][];

property expression

expression: string;

property LAZY_UNTIL_FALLBACK

static LAZY_UNTIL_FALLBACK: string;

property LAZY_UNTIL_ID

static LAZY_UNTIL_ID: string;

property LAZY_UNTIL_LOCAL

static LAZY_UNTIL_LOCAL: string;

property LAZY_UNTIL_REQUEST

static LAZY_UNTIL_REQUEST: 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;

method canConcatenate

static canConcatenate: (dependency: Dependency) => boolean;

Returns true if the dependency can be concatenated (scope hoisting).

method compareLocations

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

Compares two dependencies by source location for sorting a module's dependencies, without materializing the loc objects (get loc caches its result, so comparing through it would retain a location object on every sorted dependency). These dependencies always carry a real source position, so only start (line, column) and the within-statement index are compared; a dependency without an index sorts after one that has an index at the same position.

method isLowPriorityDependency

static isLowPriorityDependency: (dependency: Dependency) => boolean;

Returns true if the dependency is a low priority dependency.

class HarmonyImportDependency

class HarmonyImportDependency extends ModuleDependency {}

constructor

constructor(
    request: string,
    sourceOrder: number,
    phase?: 0 | 1 | 2,
    attributes?: Record<string, string>
);

Creates an instance of HarmonyImportDependency.

property attributes

attributes?: Record<string, string>;

property ExportPresenceModes

static ExportPresenceModes: {
    NONE: ExportPresenceMode;
    WARN: ExportPresenceMode;
    AUTO: ExportPresenceMode;
    ERROR: ExportPresenceMode;
    fromUserOption(str: string | false): ExportPresenceMode;
    resolveFromOptions(
        specificValue: undefined | string | false,
        options: JavascriptParserOptions
    ): ExportPresenceMode;
};

property EXPORTS_OBJECT_REFERENCED

static EXPORTS_OBJECT_REFERENCED: string[][];

property EXPORTS_OBJECT_REFERENCED_MANGLEABLE

static EXPORTS_OBJECT_REFERENCED_MANGLEABLE: string[][];

property getNonOptionalPart

static getNonOptionalPart: (
    members: string[],
    membersOptionals: boolean[]
) => string[];

property LAZY_UNTIL_FALLBACK

static LAZY_UNTIL_FALLBACK: string;

property LAZY_UNTIL_ID

static LAZY_UNTIL_ID: string;

property LAZY_UNTIL_LOCAL

static LAZY_UNTIL_LOCAL: string;

property LAZY_UNTIL_REQUEST

static LAZY_UNTIL_REQUEST: string;

property NO_EXPORTS_REFERENCED

static NO_EXPORTS_REFERENCED: string[][];

property phase

phase: ImportPhaseType;

property Template

static Template: typeof HarmonyImportDependencyTemplate;

property TRANSITIVE

static TRANSITIVE: Symbol;

method canConcatenate

static canConcatenate: (dependency: Dependency) => boolean;

Returns true if the dependency can be concatenated (scope hoisting).

method compareLocations

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

Compares two dependencies by source location for sorting a module's dependencies, without materializing the loc objects (get loc caches its result, so comparing through it would retain a location object on every sorted dependency). These dependencies always carry a real source position, so only start (line, column) and the within-statement index are compared; a dependency without an index sorts after one that has an index at the same position.

method getImportStatement

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

Gets import statement.

method getImportVar

getImportVar: (moduleGraph: ModuleGraph) => string;

Returns name of the variable for the import.

method getLinkingErrors

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

Gets linking errors.

method getModuleExports

getModuleExports: (__0: DependencyTemplateContext) => string;

Gets module exports.

method isLowPriorityDependency

static isLowPriorityDependency: (dependency: Dependency) => boolean;

Returns true if the dependency is a low priority dependency.

class ModuleDependency

class ModuleDependency extends Dependency {}

constructor

constructor(request: string, sourceOrder?: number);

Creates an instance of ModuleDependency.

property EXPORTS_OBJECT_REFERENCED

static EXPORTS_OBJECT_REFERENCED: string[][];

property EXPORTS_OBJECT_REFERENCED_MANGLEABLE

static EXPORTS_OBJECT_REFERENCED_MANGLEABLE: string[][];

property LAZY_UNTIL_FALLBACK

static LAZY_UNTIL_FALLBACK: string;

property LAZY_UNTIL_ID

static LAZY_UNTIL_ID: string;

property LAZY_UNTIL_LOCAL

static LAZY_UNTIL_LOCAL: string;

property LAZY_UNTIL_REQUEST

static LAZY_UNTIL_REQUEST: string;

property NO_EXPORTS_REFERENCED

static NO_EXPORTS_REFERENCED: string[][];

property range

range?: [number, number];

property request

request: string;

property sourceOrder

sourceOrder?: number;

property Template

static Template: typeof DependencyTemplate;

property TRANSITIVE

static TRANSITIVE: Symbol;

property userRequest

userRequest: string;

property weak

weak: boolean;

method canConcatenate

static canConcatenate: (dependency: Dependency) => boolean;

Returns true if the dependency can be concatenated (scope hoisting).

method compareLocations

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

Compares two dependencies by source location for sorting a module's dependencies, without materializing the loc objects (get loc caches its result, so comparing through it would retain a location object on every sorted dependency). These dependencies always carry a real source position, so only start (line, column) and the within-statement index are compared; a dependency without an index sorts after one that has an index at the same position.

method isLowPriorityDependency

static isLowPriorityDependency: (dependency: Dependency) => boolean;

Returns true if the dependency is a low priority dependency.

class NullDependency

class NullDependency extends Dependency {}

constructor

constructor();

property EXPORTS_OBJECT_REFERENCED

static EXPORTS_OBJECT_REFERENCED: string[][];

property EXPORTS_OBJECT_REFERENCED_MANGLEABLE

static EXPORTS_OBJECT_REFERENCED_MANGLEABLE: string[][];

property LAZY_UNTIL_FALLBACK

static LAZY_UNTIL_FALLBACK: string;

property LAZY_UNTIL_ID

static LAZY_UNTIL_ID: string;

property LAZY_UNTIL_LOCAL

static LAZY_UNTIL_LOCAL: string;

property LAZY_UNTIL_REQUEST

static LAZY_UNTIL_REQUEST: string;

property NO_EXPORTS_REFERENCED

static NO_EXPORTS_REFERENCED: string[][];

property Template

static Template: typeof NullDependencyTemplate;

property TRANSITIVE

static TRANSITIVE: Symbol;

method canConcatenate

static canConcatenate: (dependency: Dependency) => boolean;

Returns true if the dependency can be concatenated (scope hoisting).

method compareLocations

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

Compares two dependencies by source location for sorting a module's dependencies, without materializing the loc objects (get loc caches its result, so comparing through it would retain a location object on every sorted dependency). These dependencies always carry a real source position, so only start (line, column) and the within-statement index are compared; a dependency without an index sorts after one that has an index at the same position.

method isLowPriorityDependency

static isLowPriorityDependency: (dependency: Dependency) => boolean;

Returns true if the dependency is a low priority dependency.

namespace dll

namespace dll {}

class DelegatedPlugin

class DelegatedPlugin {}

constructor

constructor(options: Options);

Creates an instance of DelegatedPlugin.

property options

options: Options;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class DllPlugin

class DllPlugin {}

constructor

constructor(options: DllPluginOptions);

Creates an instance of DllPlugin.

property options

options: DllPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class DllReferencePlugin

class DllReferencePlugin {}

constructor

constructor(options: DllReferencePluginOptions);

Creates an instance of DllReferencePlugin.

property options

options: DllReferencePluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class LibManifestPlugin

class LibManifestPlugin {}

constructor

constructor(options: LibManifestPluginOptions);

Creates an instance of LibManifestPlugin.

property options

options: LibManifestPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

namespace electron

namespace electron {}

class ElectronTargetPlugin

class ElectronTargetPlugin {}

constructor

constructor(
    context?: 'preload' | 'main' | 'renderer',
    type?:
        | 'module'
        | 'script'
        | 'import'
        | 'assign'
        | 'var'
        | 'this'
        | 'window'
        | 'self'
        | 'global'
        | 'commonjs'
        | 'commonjs2'
        | 'commonjs-module'
        | 'commonjs-static'
        | 'amd'
        | 'amd-require'
        | 'umd'
        | 'umd2'
        | 'jsonp'
        | 'system'
        | 'amd-async'
        | 'promise'
        | 'module-import'
        | 'node-commonjs'
        | 'asset'
        | 'asset-url'
        | 'css-import'
        | 'css-url'
);

Creates an instance of ElectronTargetPlugin.

property type

type: ExternalsType;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

namespace esm

namespace esm {}

class ModuleChunkLoadingRuntimeModule

class ModuleChunkLoadingRuntimeModule extends RuntimeModule {}

constructor

constructor(runtimeRequirements: ReadonlySet<string>);

Creates an instance of ModuleChunkLoadingRuntimeModule.

property getCompilationHooks

static getCompilationHooks: (compilation: Compilation) => {
    linkPreload: SyncWaterfallHook<[string, Chunk], string>;
    linkPrefetch: SyncWaterfallHook<[string, Chunk], 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 getSourceBasicTypes

static getSourceBasicTypes: (module: Module) => ReadonlySet<string>;

Gets source basic types.
Deprecated
In webpack 6, call getSourceBasicTypes() directly on the module instance instead of using this static method.

namespace experiments

namespace experiments {}

namespace experiments.ids

namespace experiments.ids {}

class SyncModuleIdsPlugin

class SyncModuleIdsPlugin {}

constructor

constructor(options: SyncModuleIdsPluginOptions);

Creates an instance of SyncModuleIdsPlugin.

property options

options: SyncModuleIdsPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

namespace experiments.schemes

namespace experiments.schemes {}

class HttpUriPlugin

class HttpUriPlugin {}

constructor

constructor(options: HttpUriOptions);

Creates an instance of HttpUriPlugin.

property options

options: HttpUriOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class VirtualUrlPlugin

class VirtualUrlPlugin {}

constructor

constructor(
    modules: VirtualModules,
    schemeOrOptions?: string | Omit<VirtualUrlOptions, 'modules'>
);

Creates an instance of VirtualUrlPlugin.

property context

context?: string;

property DEFAULT_SCHEME

static DEFAULT_SCHEME: string;

property modules

modules: NormalizedModules;

property options

options: VirtualUrlOptions;

property scheme

scheme: string;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

method findVirtualModuleConfigById

findVirtualModuleConfigById: (id: string) => VirtualModule;

Finds virtual module config by id.

method getCacheVersion

getCacheVersion: (version: string | true | (() => string)) => undefined | string;

Get the cache version for a given version value

namespace html

namespace html {}

class HtmlModulesPlugin

class HtmlModulesPlugin {}

constructor

constructor();

property getCompilationHooks

static getCompilationHooks: (compilation: Compilation) => {
    injectTags: AsyncSeriesWaterfallHook<
        [HtmlTagDescriptor[], HtmlInjectTagsContext],
        HtmlTagDescriptor[]
    >;
    transformTags: AsyncSeriesHook<[HtmlMutableTag[], HtmlTransformTagsContext]>;
    transformHtml: AsyncSeriesWaterfallHook<
        [string, HtmlTransformHtmlContext],
        string
    >;
    htmlEmitted: AsyncSeriesHook<[HtmlEmittedContext]>;
};

Per-compilation hooks for the experimental HTML support.

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

method computeContentHash

static computeContentHash: (
    content: string | Buffer,
    outputOptions: Output
) => string;

output.hashFunction/hashSalt/hashDigest/hashDigestLength digest of content, with nonNumericOnlyHash applied — webpack's standard [contenthash] recipe.

method getChunkFilenameTemplate

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

Filename template for an extracted HTML page: output.htmlFilename for initial chunks, output.htmlChunkFilename otherwise — the HTML counterpart of CssModulesPlugin.getChunkFilenameTemplate.

namespace ids

namespace ids {}

class ChunkModuleIdRangePlugin

class ChunkModuleIdRangePlugin {}

constructor

constructor(options: ChunkModuleIdRangePluginOptions);

Creates an instance of ChunkModuleIdRangePlugin.

property options

options: ChunkModuleIdRangePluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class DeterministicChunkIdsPlugin

class DeterministicChunkIdsPlugin {}

constructor

constructor(options?: DeterministicChunkIdsPluginOptions);

Creates an instance of DeterministicChunkIdsPlugin.

property options

options: DeterministicChunkIdsPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class DeterministicModuleIdsPlugin

class DeterministicModuleIdsPlugin {}

constructor

constructor(options?: DeterministicModuleIdsPluginOptions);

Creates an instance of DeterministicModuleIdsPlugin.

property options

options: DeterministicModuleIdsPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class HashedModuleIdsPlugin

class HashedModuleIdsPlugin {}

constructor

constructor(options?: HashedModuleIdsPluginOptions);

Creates an instance of HashedModuleIdsPlugin.

property options

options: HashedModuleIdsPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class NamedChunkIdsPlugin

class NamedChunkIdsPlugin {}

constructor

constructor(options?: NamedChunkIdsPluginOptions);

Creates an instance of NamedChunkIdsPlugin.

property options

options: NamedChunkIdsPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class NamedModuleIdsPlugin

class NamedModuleIdsPlugin {}

constructor

constructor(options?: NamedModuleIdsPluginOptions);

Creates an instance of NamedModuleIdsPlugin.

property options

options: NamedModuleIdsPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class NaturalModuleIdsPlugin

class NaturalModuleIdsPlugin {}

constructor

constructor();

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class OccurrenceChunkIdsPlugin

class OccurrenceChunkIdsPlugin {}

constructor

constructor(options?: OccurrenceChunkIdsPluginOptions);

Creates an instance of OccurrenceChunkIdsPlugin.

property options

options: OccurrenceChunkIdsPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class OccurrenceModuleIdsPlugin

class OccurrenceModuleIdsPlugin {}

constructor

constructor(options?: OccurrenceModuleIdsPluginOptions);

Creates an instance of OccurrenceModuleIdsPlugin.

property options

options: OccurrenceModuleIdsPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

namespace javascript

namespace javascript {}

class EnableChunkLoadingPlugin

class EnableChunkLoadingPlugin {}

constructor

constructor(type: string);

Creates an instance of EnableChunkLoadingPlugin.

property type

type: string;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

method checkEnabled

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

Checks enabled.

method setEnabled

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

Updates enabled using the provided compiler.

class JavascriptModulesPlugin

class JavascriptModulesPlugin {}

constructor

constructor(options?: {});

property chunkHasJs

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

property getCompilationHooks

static getCompilationHooks: (compilation: Compilation) => {
    renderModuleContent: SyncWaterfallHook<
        [Source, Module, ModuleRenderContext],
        Source
    >;
    renderModuleContainer: SyncWaterfallHook<
        [Source, Module, ModuleRenderContext],
        Source
    >;
    renderModulePackage: SyncWaterfallHook<
        [Source, Module, ModuleRenderContext],
        Source
    >;
    render: SyncWaterfallHook<
        [Source, RenderContextJavascriptModulesPlugin],
        Source
    >;
    renderContent: SyncWaterfallHook<
        [Source, RenderContextJavascriptModulesPlugin],
        Source
    >;
    renderStartup: SyncWaterfallHook<
        [Source, Module, StartupRenderContext],
        Source
    >;
    renderChunk: SyncWaterfallHook<
        [Source, RenderContextJavascriptModulesPlugin],
        Source
    >;
    renderMain: SyncWaterfallHook<
        [Source, RenderContextJavascriptModulesPlugin],
        Source
    >;
    renderRequire: SyncWaterfallHook<[string, RenderBootstrapContext], string>;
    inlineInRuntimeBailout: SyncBailHook<
        [Module, Partial<RenderBootstrapContext>],
        string | void
    >;
    embedInRuntimeBailout: SyncBailHook<
        [Module, RenderContextJavascriptModulesPlugin],
        string | void
    >;
    strictRuntimeBailout: SyncBailHook<
        [RenderContextJavascriptModulesPlugin],
        string | void
    >;
    chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
    useSourceMap: SyncBailHook<
        [Chunk, RenderContextJavascriptModulesPlugin],
        boolean | void
    >;
};

property options

options: {};

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

method getChunkFilenameTemplate

static getChunkFilenameTemplate: (
    chunk: Chunk,
    outputOptions: OutputNormalizedWithDefaults
) => ChunkFilenameTemplate;

Gets chunk filename template.

method renderBootstrap

renderBootstrap: (
    renderContext: RenderBootstrapContext,
    hooks: {
        renderModuleContent: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        renderModuleContainer: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        renderModulePackage: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        render: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderContent: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderStartup: SyncWaterfallHook<
            [Source, Module, StartupRenderContext],
            Source
        >;
        renderChunk: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderMain: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderRequire: SyncWaterfallHook<
            [string, RenderBootstrapContext],
            string
        >;
        inlineInRuntimeBailout: SyncBailHook<
            [Module, Partial<RenderBootstrapContext>],
            string | void
        >;
        embedInRuntimeBailout: SyncBailHook<
            [Module, RenderContextJavascriptModulesPlugin],
            string | void
        >;
        strictRuntimeBailout: SyncBailHook<
            [RenderContextJavascriptModulesPlugin],
            string | void
        >;
        chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
        useSourceMap: SyncBailHook<
            [Chunk, RenderContextJavascriptModulesPlugin],
            boolean | void
        >;
    }
) => Bootstrap;

Renders the generated source of the bootstrap code.

method renderChunk

renderChunk: (
    renderContext: RenderContextJavascriptModulesPlugin,
    hooks: {
        renderModuleContent: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        renderModuleContainer: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        renderModulePackage: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        render: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderContent: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderStartup: SyncWaterfallHook<
            [Source, Module, StartupRenderContext],
            Source
        >;
        renderChunk: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderMain: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderRequire: SyncWaterfallHook<
            [string, RenderBootstrapContext],
            string
        >;
        inlineInRuntimeBailout: SyncBailHook<
            [Module, Partial<RenderBootstrapContext>],
            string | void
        >;
        embedInRuntimeBailout: SyncBailHook<
            [Module, RenderContextJavascriptModulesPlugin],
            string | void
        >;
        strictRuntimeBailout: SyncBailHook<
            [RenderContextJavascriptModulesPlugin],
            string | void
        >;
        chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
        useSourceMap: SyncBailHook<
            [Chunk, RenderContextJavascriptModulesPlugin],
            boolean | void
        >;
    }
) => Source;

Renders the rendered source.

method renderMain

renderMain: (
    renderContext: MainRenderContext,
    hooks: {
        renderModuleContent: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        renderModuleContainer: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        renderModulePackage: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        render: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderContent: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderStartup: SyncWaterfallHook<
            [Source, Module, StartupRenderContext],
            Source
        >;
        renderChunk: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderMain: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderRequire: SyncWaterfallHook<
            [string, RenderBootstrapContext],
            string
        >;
        inlineInRuntimeBailout: SyncBailHook<
            [Module, Partial<RenderBootstrapContext>],
            string | void
        >;
        embedInRuntimeBailout: SyncBailHook<
            [Module, RenderContextJavascriptModulesPlugin],
            string | void
        >;
        strictRuntimeBailout: SyncBailHook<
            [RenderContextJavascriptModulesPlugin],
            string | void
        >;
        chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
        useSourceMap: SyncBailHook<
            [Chunk, RenderContextJavascriptModulesPlugin],
            boolean | void
        >;
    },
    compilation: Compilation
) => Source;

Renders the newly generated source from rendering.

method renderModule

renderModule: (
    module: Module,
    renderContext: ModuleRenderContext,
    hooks: {
        renderModuleContent: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        renderModuleContainer: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        renderModulePackage: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        render: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderContent: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderStartup: SyncWaterfallHook<
            [Source, Module, StartupRenderContext],
            Source
        >;
        renderChunk: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderMain: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderRequire: SyncWaterfallHook<
            [string, RenderBootstrapContext],
            string
        >;
        inlineInRuntimeBailout: SyncBailHook<
            [Module, Partial<RenderBootstrapContext>],
            string | void
        >;
        embedInRuntimeBailout: SyncBailHook<
            [Module, RenderContextJavascriptModulesPlugin],
            string | void
        >;
        strictRuntimeBailout: SyncBailHook<
            [RenderContextJavascriptModulesPlugin],
            string | void
        >;
        chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
        useSourceMap: SyncBailHook<
            [Chunk, RenderContextJavascriptModulesPlugin],
            boolean | void
        >;
    }
) => null | Source;

Renders the newly generated source from rendering.

method renderRequire

renderRequire: (
    renderContext: RenderBootstrapContext,
    hooks: {
        renderModuleContent: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        renderModuleContainer: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        renderModulePackage: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        render: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderContent: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderStartup: SyncWaterfallHook<
            [Source, Module, StartupRenderContext],
            Source
        >;
        renderChunk: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderMain: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderRequire: SyncWaterfallHook<
            [string, RenderBootstrapContext],
            string
        >;
        inlineInRuntimeBailout: SyncBailHook<
            [Module, Partial<RenderBootstrapContext>],
            string | void
        >;
        embedInRuntimeBailout: SyncBailHook<
            [Module, RenderContextJavascriptModulesPlugin],
            string | void
        >;
        strictRuntimeBailout: SyncBailHook<
            [RenderContextJavascriptModulesPlugin],
            string | void
        >;
        chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
        useSourceMap: SyncBailHook<
            [Chunk, RenderContextJavascriptModulesPlugin],
            boolean | void
        >;
    }
) => string;

Renders the generated source of the require function.

method updateHashWithBootstrap

updateHashWithBootstrap: (
    hash: Hash,
    renderContext: RenderBootstrapContext,
    hooks: {
        renderModuleContent: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        renderModuleContainer: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        renderModulePackage: SyncWaterfallHook<
            [Source, Module, ModuleRenderContext],
            Source
        >;
        render: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderContent: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderStartup: SyncWaterfallHook<
            [Source, Module, StartupRenderContext],
            Source
        >;
        renderChunk: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderMain: SyncWaterfallHook<
            [Source, RenderContextJavascriptModulesPlugin],
            Source
        >;
        renderRequire: SyncWaterfallHook<
            [string, RenderBootstrapContext],
            string
        >;
        inlineInRuntimeBailout: SyncBailHook<
            [Module, Partial<RenderBootstrapContext>],
            string | void
        >;
        embedInRuntimeBailout: SyncBailHook<
            [Module, RenderContextJavascriptModulesPlugin],
            string | void
        >;
        strictRuntimeBailout: SyncBailHook<
            [RenderContextJavascriptModulesPlugin],
            string | void
        >;
        chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
        useSourceMap: SyncBailHook<
            [Chunk, RenderContextJavascriptModulesPlugin],
            boolean | void
        >;
    }
) => void;

Updates hash with bootstrap.

class JavascriptParser

class JavascriptParser extends ParserClass {}

constructor

constructor(
    sourceType?: 'module' | 'auto' | 'script',
    options?: {
        parse?: (code: string, options: ParseOptions) => ParseResult;
        typescript?: boolean;
        importPhases?: boolean;
        strictModeViolations?: false | 'error' | 'warn';
    }
);

Creates an instance of JavascriptParser.

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?: any[];

property currentTagData

currentTagData?:
    | Record<string, any>
    | TopLevelSymbol
    | HarmonySettings
    | ImportSettings
    | CommonJsImportSettings
    | CompatibilitySettings;

property destructuringAssignmentProperties

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

property getImportAttributes

static getImportAttributes: (
    node:
        | ImportDeclaration
        | ExportNamedDeclaration
        | ExportAllDeclaration
        | 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>;
    preStatementByType: HookMap<SyncBailHook<[any], boolean | void>>;
    blockPreStatement: SyncBailHook<[any], boolean | void>;
    blockPreStatementByType: HookMap<SyncBailHook<[any], boolean | void>>;
    statement: SyncBailHook<[any], boolean | void>;
    statementIf: SyncBailHook<[IfStatement], boolean | void>;
    collectGuards: SyncBailHook<[any], void | GuardCollection>;
    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<[ImportDeclaration, any], boolean | void>;
    importSpecifier: SyncBailHook<
        [ImportDeclaration, 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, VariableDeclaration],
        boolean | void
    >;
    declarator: SyncBailHook<[VariableDeclarator, any], boolean | void>;
    varDeclaration: HookMap<SyncBailHook<[Identifier], boolean | void>>;
    varDeclarationLet: HookMap<SyncBailHook<[Identifier], boolean | void>>;
    varDeclarationConst: HookMap<SyncBailHook<[Identifier], boolean | void>>;
    varDeclarationUsing: HookMap<SyncBailHook<[Identifier], boolean | void>>;
    varDeclarationVar: HookMap<SyncBailHook<[Identifier], boolean | void>>;
    pattern: HookMap<SyncBailHook<[Identifier], boolean | void>>;
    collectDestructuringAssignmentProperties: SyncBailHook<
        [any],
        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, 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, any[]], boolean | void>;
    terminate: SyncBailHook<[any], boolean | void>;
    finish: SyncBailHook<[Program, any[]], boolean | void>;
    unusedStatement: SyncBailHook<[any], boolean | void>;
}>;

property magicCommentContext

magicCommentContext: ContextImport;

property options

options: {
    parse?: (code: string, options: ParseOptions) => ParseResult;
    typescript?: boolean;
    importPhases?: boolean;
    strictModeViolations?: false | 'error' | 'warn';
};

property prevStatement

prevStatement?: any;

property scope

scope: ScopeInfo;

property semicolons

semicolons?: Map<number, boolean>;

property sourceType

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

property state

state: JavascriptParserState;

property statementPath

statementPath?: any[];

property VariableInfo

static VariableInfo: typeof VariableInfo;

property VariableInfoFlags

static VariableInfoFlags: Readonly<{
    Evaluated: 0;
    Free: 1;
    Normal: 2;
    Tagged: 4;
}>;

method blockPreWalkClassDeclaration

blockPreWalkClassDeclaration: (
    statement: ClassDeclaration | MaybeNamedClassDeclaration
) => void;

Block pre walk class declaration.

method blockPreWalkExportDefaultDeclaration

blockPreWalkExportDefaultDeclaration: (
    statement: ExportDefaultDeclaration
) => void;

Block pre walk export default declaration.

method blockPreWalkExportNamedDeclaration

blockPreWalkExportNamedDeclaration: (statement: ExportNamedDeclaration) => void;

Block pre walk export named declaration.

method blockPreWalkExpressionStatement

blockPreWalkExpressionStatement: (statement: ExpressionStatement) => void;

Block pre walk expression statement.

method blockPreWalkStatement

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

Block pre walk statement.

method blockPreWalkStatements

blockPreWalkStatements: (
    statements: (
        | ImportDeclaration
        | ExportNamedDeclaration
        | ExportAllDeclaration
        | 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;

Block pre walk variable declaration.

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;

Call hooks for expression.

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: (
        name: string,
        rootInfo: string | VariableInfo | ScopeInfo,
        getMembers: () => string[]
    ) => R,
    defined: (result?: string) => undefined | R,
    ...args: AsArray<T>
) => undefined | R;

Call hooks for expression with fallback.

method callHooksForInfo

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

Call hooks for info.

method callHooksForInfoWithFallback

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

Call hooks for info with fallback.

method callHooksForName

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

Call hooks for name.

method callHooksForNameWithFallback

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

Call hooks for name with fallback.

method defineVariable

defineVariable: (name: string) => void;

Processes the provided name.

method destructuringAssignmentPropertiesFor

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

Destructuring assignment properties for.

method detectMode

detectMode: (
    statements: (
        | ImportDeclaration
        | ExportNamedDeclaration
        | ExportAllDeclaration
        | 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;

Processes the provided statement.

method enterArrayPattern

enterArrayPattern: (
    pattern: ArrayPattern,
    onIdent: (ident: string, identifier: Identifier) => void
) => void;

Enter array pattern.

method enterAssignmentPattern

enterAssignmentPattern: (
    pattern: AssignmentPattern,
    onIdent: (ident: string, identifier: Identifier) => void
) => void;

Enter assignment pattern.

method enterDeclaration

enterDeclaration: (
    declaration: Declaration,
    onIdent: (ident: string, identifier: Identifier) => void
) => void;

Processes the provided declaration.

method enterDestructuringAssignment

enterDestructuringAssignment: (
    pattern: Pattern,
    expression: Expression
) =>
    | undefined
    | 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;

Enter destructuring assignment.

method enterIdentifier

enterIdentifier: (
    pattern: Identifier,
    onIdent: (ident: string, identifier: Identifier) => void
) => void;

Processes the provided pattern.

method enterObjectPattern

enterObjectPattern: (
    pattern: ObjectPattern,
    onIdent: (ident: string, identifier: Identifier) => void
) => void;

Enter object pattern.

method enterPattern

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

Processes the provided pattern.

method enterPatterns

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

Processes the provided pattern.

method enterRestElement

enterRestElement: (
    pattern: RestElement,
    onIdent: (ident: string, identifier: Identifier) => void
) => void;

Enter rest element.

method evaluate

evaluate: (source: string) => BasicEvaluatedExpression;

Returns evaluation result.

method evaluatedVariable

evaluatedVariable: (tagInfo: TagInfo) => VariableInfo;

Evaluated variable.

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
        | Super
) => BasicEvaluatedExpression;

Evaluate expression.

method extend

static extend: (
    ...plugins: ((BaseParser: any) => any)[]
) => typeof JavascriptParser;

Returns parser.

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][];
};

Extract member expression chain.

method getComments

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

Returns comments in the range.

method getFreeInfoFromVariable

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

Gets free info from variable.

method getLocation

getLocation: (node: {
    start?: number;
    end?: number;
    range?: [number, number];
    loc?: null | SourceLocation;
}) => DependencyLocation;

Returns the location of a node or comment, computed from its offsets so ASTs from parsers without location support work too. Falls back to the node's own loc only when no source text is available (preparsed ASTs). Offsets can only be mapped while parsing — callbacks deferred past the parse() call must take the location upfront.

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;

Gets member expression info.

method getMemberExpressionRoot

getMemberExpressionRoot: (
    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
) =>
    | 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;

Finds the root object of a member expression chain without allocating the member arrays. The traversal/break logic must stay in sync with extractMemberExpressionChain; it lets getMemberExpressionInfo reject unrecognized roots (~77% of calls) before paying for the arrays.

method getNameForExpression

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

Gets name for expression.

method getNameInfoFromVariable

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

Gets name info from variable.

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 | VariableInfo;

Gets rename identifier.

method getTagData

getTagData: (
    name: string,
    tag: symbol
) =>
    | undefined
    | Record<string, any>
    | TopLevelSymbol
    | HarmonySettings
    | ImportSettings
    | CommonJsImportSettings
    | CompatibilitySettings;

Returns tag data.

method getVariableInfo

getVariableInfo: (name: string) => ExportedVariableInfo;

Gets variable info.

method inBlockScope

inBlockScope: (fn: () => void, inExecutedPath?: boolean) => void;

Processes the provided fn.

method inClassScope

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

Processes the provided has thi.

method inFunctionScope

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

Processes the provided has thi.

method inScope

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

Processes the provided param.
Deprecated

method isAsiPosition

isAsiPosition: (pos: number) => boolean;

Checks whether this javascript parser is asi position.

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
        | MaybeNamedFunctionDeclaration
        | VariableDeclaration
        | ClassDeclaration
        | MaybeNamedClassDeclaration,
    commentsStartPos: number
) => boolean;

Checks whether this javascript parser is pure.

method isStatementLevelExpression

isStatementLevelExpression: (expr: Expression) => boolean;

Checks whether this javascript parser is statement level expression.

method isVariableDefined

isVariableDefined: (name: string) => boolean;

Checks whether this javascript parser is variable defined.

method modulePreWalkExportAllDeclaration

modulePreWalkExportAllDeclaration: (statement: ExportAllDeclaration) => void;

Module pre walk export all declaration.

method modulePreWalkExportNamedDeclaration

modulePreWalkExportNamedDeclaration: (statement: ExportNamedDeclaration) => void;

Module pre walk export named declaration.

method modulePreWalkImportDeclaration

modulePreWalkImportDeclaration: (statement: ImportDeclaration) => void;

Module pre walk import declaration.

method modulePreWalkStatements

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

Module pre walking iterates the scope for import entries

method parseCalculatedString

parseCalculatedString: (expression: Expression) => CalculatedStringResult;

Parses calculated string.

method parseCommentOptions

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

Parses comment options.

method parseString

parseString: (expression: Expression) => string;

Returns parsed string.

method preWalkAssignmentExpression

preWalkAssignmentExpression: (expression: AssignmentExpression) => void;

Pre walk assignment expression.

method preWalkBlockStatement

preWalkBlockStatement: (statement: BlockStatement) => void;

Pre walk block statement.

method preWalkCatchClause

preWalkCatchClause: (catchClause: CatchClause) => void;

Pre walk catch clause.

method preWalkDoWhileStatement

preWalkDoWhileStatement: (statement: DoWhileStatement) => void;

Pre walk do while statement.

method preWalkForInStatement

preWalkForInStatement: (statement: ForInStatement) => void;

Pre walk for in statement.

method preWalkForOfStatement

preWalkForOfStatement: (statement: ForOfStatement) => void;

Pre walk for of statement.

method preWalkForStatement

preWalkForStatement: (statement: ForStatement) => void;

Pre walk for statement.

method preWalkFunctionDeclaration

preWalkFunctionDeclaration: (
    statement: FunctionDeclaration | MaybeNamedFunctionDeclaration
) => void;

Pre walk function declaration.

method preWalkIfStatement

preWalkIfStatement: (statement: IfStatement) => void;

Pre walk if statement.

method preWalkLabeledStatement

preWalkLabeledStatement: (statement: LabeledStatement) => void;

Pre walk labeled statement.

method preWalkStatement

preWalkStatement: (
    statement:
        | ImportDeclaration
        | ExportNamedDeclaration
        | ExportAllDeclaration
        | FunctionDeclaration
        | MaybeNamedFunctionDeclaration
        | VariableDeclaration
        | ClassDeclaration
        | MaybeNamedClassDeclaration
        | 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: (
        | ImportDeclaration
        | ExportNamedDeclaration
        | ExportAllDeclaration
        | 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;

Pre walk switch cases.

method preWalkSwitchStatement

preWalkSwitchStatement: (statement: SwitchStatement) => void;

Pre walk switch statement.

method preWalkTryStatement

preWalkTryStatement: (statement: TryStatement) => void;

Pre walk try statement.

method preWalkVariableDeclaration

preWalkVariableDeclaration: (statement: VariableDeclaration) => void;

Pre walk variable declaration.

method preWalkVariableDeclarator

preWalkVariableDeclarator: (declarator: VariableDeclarator) => void;

Pre walk variable declarator.

method preWalkWhileStatement

preWalkWhileStatement: (statement: WhileStatement) => void;

Pre walk while statement.

method preWalkWithStatement

preWalkWithStatement: (statement: WithStatement) => void;

Pre walk with statement.

method setAsiPosition

setAsiPosition: (pos: number) => void;

Updates asi position using the provided po.

method setVariable

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

Updates variable using the provided name.

method tagVariable

tagVariable: (
    name: string,
    tag: symbol,
    data?:
        | Record<string, any>
        | TopLevelSymbol
        | HarmonySettings
        | ImportSettings
        | CommonJsImportSettings
        | CompatibilitySettings,
    flags?: 0 | 1 | 2 | 4
) => void;

Processes the provided name.

method undefineVariable

undefineVariable: (name: string) => void;

Processes the provided name.

method unsetAsiPosition

unsetAsiPosition: (pos: number) => void;

Unset asi position.

method walkArrayExpression

walkArrayExpression: (expression: ArrayExpression) => void;

Walk array expression.

method walkArrayPattern

walkArrayPattern: (pattern: ArrayPattern) => void;

Walk array pattern.

method walkArrowFunctionExpression

walkArrowFunctionExpression: (expression: ArrowFunctionExpression) => void;

Walk arrow function expression.

method walkAssignmentExpression

walkAssignmentExpression: (expression: AssignmentExpression) => void;

Walk assignment expression.

method walkAssignmentPattern

walkAssignmentPattern: (pattern: AssignmentPattern) => void;

Walk assignment pattern.

method walkAwaitExpression

walkAwaitExpression: (expression: AwaitExpression) => void;

Walk await expression.

method walkBinaryExpression

walkBinaryExpression: (expression: BinaryExpression) => void;

Walk binary expression.

method walkBlockStatement

walkBlockStatement: (statement: BlockStatement | StaticBlock) => void;

Walk block statement.

method walkCallExpression

walkCallExpression: (expression: CallExpression) => void;

Walk call expression.

method walkCatchClause

walkCatchClause: (catchClause: CatchClause) => void;

Processes the provided catch clause.

method walkChainExpression

walkChainExpression: (expression: ChainExpression) => void;

Walk chain expression.

method walkClass

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

Processes the provided classy.

method walkClassDeclaration

walkClassDeclaration: (
    statement: ClassDeclaration | MaybeNamedClassDeclaration
) => void;

Walk class declaration.

method walkClassExpression

walkClassExpression: (expression: ClassExpression) => void;

Walk class expression.

method walkConditionalExpression

walkConditionalExpression: (expression: ConditionalExpression) => void;

Walk conditional expression.

method walkDoWhileStatement

walkDoWhileStatement: (statement: DoWhileStatement) => void;

Walk do while statement.

method walkExportDefaultDeclaration

walkExportDefaultDeclaration: (statement: ExportDefaultDeclaration) => void;

Walk export default declaration.

method walkExportNamedDeclaration

walkExportNamedDeclaration: (statement: ExportNamedDeclaration) => void;

Walk export named declaration.

method walkExpression

walkExpression: (
    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
        | Super
) => void;

Processes the provided expression.

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;

Processes the provided expression.

method walkExpressionStatement

walkExpressionStatement: (statement: ExpressionStatement) => void;

Walk expression statement.

method walkForInStatement

walkForInStatement: (statement: ForInStatement) => void;

Walk for in statement.

method walkForOfStatement

walkForOfStatement: (statement: ForOfStatement) => void;

Walk for of statement.

method walkForStatement

walkForStatement: (statement: ForStatement) => void;

Walk for statement.

method walkFunctionDeclaration

walkFunctionDeclaration: (
    statement: FunctionDeclaration | MaybeNamedFunctionDeclaration
) => void;

Walk function declaration.

method walkFunctionExpression

walkFunctionExpression: (expression: FunctionExpression) => void;

Walk function expression.

method walkGuardedBranch

walkGuardedBranch: (frame: undefined | null | object, walk: () => void) => void;

Walks a conditional branch with its guard frame (if any) pushed onto the parser-state guard stack for the duration of the branch body.

method walkIdentifier

walkIdentifier: (expression: Identifier) => void;

Processes the provided expression.

method walkIfStatement

walkIfStatement: (statement: IfStatement) => void;

Processes the provided statement.

method walkImportExpression

walkImportExpression: (expression: ImportExpressionJavascriptParser) => void;

Walk import expression.

method walkLabeledStatement

walkLabeledStatement: (statement: LabeledStatement) => void;

Walk labeled statement.

method walkLeftRightExpression

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

Walk left right expression.

method walkLogicalExpression

walkLogicalExpression: (expression: LogicalExpression) => void;

Walk logical expression.

method walkMemberExpression

walkMemberExpression: (expression: MemberExpression) => void;

Walk member expression.

method walkMemberExpressionWithExpressionName

walkMemberExpressionWithExpressionName: <R>(
    expression: MemberExpression,
    name: string,
    rootInfo: string | VariableInfo,
    members: string[],
    onUnhandled: () => undefined | R
) => void;

Walk member expression with expression name.

method walkMetaProperty

walkMetaProperty: (metaProperty: MetaProperty) => void;

Walk meta property.

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;

Walk new expression.

method walkObjectExpression

walkObjectExpression: (expression: ObjectExpression) => void;

Walk object expression.

method walkObjectPattern

walkObjectPattern: (pattern: ObjectPattern) => void;

Walk object pattern.

method walkPattern

walkPattern: (pattern: Pattern) => void;

Processes the provided pattern.

method walkProperty

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

Processes the provided prop.

method walkRestElement

walkRestElement: (pattern: RestElement) => void;

Processes the provided pattern.

method walkReturnStatement

walkReturnStatement: (statement: ReturnStatement) => void;

Walk return statement.

method walkSequenceExpression

walkSequenceExpression: (expression: SequenceExpression) => void;

Walk sequence expression.

method walkSpreadElement

walkSpreadElement: (expression: SpreadElement) => void;

Walk spread element.

method walkStatement

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

Processes the provided statement.

method walkStatements

walkStatements: (
    statements: (
        | ImportDeclaration
        | ExportNamedDeclaration
        | ExportAllDeclaration
        | 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;

Processes the provided switch case.

method walkSwitchStatement

walkSwitchStatement: (statement: SwitchStatement) => void;

Walk switch statement.

method walkTaggedTemplateExpression

walkTaggedTemplateExpression: (expression: TaggedTemplateExpression) => void;

Walk tagged template expression.

method walkTemplateLiteral

walkTemplateLiteral: (expression: TemplateLiteral) => void;

Walk template literal.

method walkTerminatingStatement

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

Walk terminating statement.

method walkThisExpression

walkThisExpression: (expression: ThisExpression) => void;

Walk this expression.

method walkThrowStatement

walkThrowStatement: (statement: ThrowStatement) => void;

Walk throw statement.

method walkTryStatement

walkTryStatement: (statement: TryStatement) => void;

Walk try statement.

method walkUnaryExpression

walkUnaryExpression: (expression: UnaryExpression) => void;

Walk unary expression.

method walkUpdateExpression

walkUpdateExpression: (expression: UpdateExpression) => void;

Walk update expression.

method walkVariableDeclaration

walkVariableDeclaration: (statement: VariableDeclaration) => void;

Walk variable declaration.

method walkWhileStatement

walkWhileStatement: (statement: WhileStatement) => void;

Walk while statement.

method walkWithStatement

walkWithStatement: (statement: WithStatement) => void;

Walk with statement.

method walkYieldExpression

walkYieldExpression: (expression: YieldExpression) => void;

Walk yield expression.

namespace library

namespace library {}

class AbstractLibraryPlugin

class AbstractLibraryPlugin<T> {}

Represents AbstractLibraryPlugin.

constructor

constructor(__0: AbstractLibraryPluginOptions);

Creates an instance of AbstractLibraryPlugin.

property COMMON_LIBRARY_NAME_MESSAGE

static COMMON_LIBRARY_NAME_MESSAGE: string;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

method chunkHash

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

Processes the provided chunk.

method embedInRuntimeBailout

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

Embed in runtime bailout.

method finishEntryModule

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

Finish entry module.

method parseOptions

parseOptions: (library: LibraryOptions) => T;

Returns preprocess as needed by overriding.

method render

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

Returns source with library export.

method renderModuleContent

renderModuleContent: (
    source: Source,
    module: Module,
    renderContext: ModuleRenderContext,
    libraryContext: Omit<LibraryContext<T>, 'options'>
) => Source;

Renders module content.

method renderStartup

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

Renders source with library export.

method runtimeRequirements

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

Processes the provided chunk.

method strictRuntimeBailout

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

Strict runtime bailout.

class EnableLibraryPlugin

class EnableLibraryPlugin {}

constructor

constructor(type: string, options?: EnableLibraryPluginOptions);

Creates an instance of EnableLibraryPlugin.

property options

options: EnableLibraryPluginOptions;

property type

type: string;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

method checkEnabled

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

Checks enabled.

method setEnabled

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

Updates enabled using the provided compiler.

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: {
        namespace?: string;
        moduleFilenameTemplate?:
            | string
            | ((context: ModuleFilenameTemplateContext) => string);
    },
    __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: NodeEnvironmentPluginOptions);

Creates an instance of NodeEnvironmentPlugin.

property options

options: NodeEnvironmentPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class NodeSourcePlugin

class NodeSourcePlugin {}

constructor

constructor();

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class NodeTargetPlugin

class NodeTargetPlugin {}

constructor

constructor(type?: ExternalsType);

Creates an instance of NodeTargetPlugin.

property builtins

static builtins: (string | RegExp)[];

property type

type: ExternalsType;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class NodeTemplatePlugin

class NodeTemplatePlugin {}

constructor

constructor(options?: NodeTemplatePluginOptions);

Creates an instance of NodeTemplatePlugin.

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class ReadFileCompileAsyncWasmPlugin

class ReadFileCompileAsyncWasmPlugin {}

constructor

constructor(__0?: ReadFileCompileAsyncWasmPluginOptions);

Creates an instance of ReadFileCompileAsyncWasmPlugin.

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class ReadFileCompileWasmPlugin

class ReadFileCompileWasmPlugin {}

constructor

constructor(options?: ReadFileCompileWasmPluginOptions);

Creates an instance of ReadFileCompileWasmPlugin.

property options

options: ReadFileCompileWasmPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

namespace ObjectDeserializerContextObjectMiddlewareObject_2

namespace ObjectDeserializerContextObjectMiddlewareObject_2 {}

variable rest

let rest: ObjectDeserializerContextObjectMiddlewareObject_3<readonly any[]>;

function read

read: () => any;

function setCircularReference

setCircularReference: (value: ReferenceableItem) => void;

namespace ObjectSerializerContextObjectMiddlewareObject_3

namespace ObjectSerializerContextObjectMiddlewareObject_3 {}

variable writeLazy

let writeLazy: (item?: any) => void;

variable writeSeparate

let writeSeparate: (
    item: any,
    obj?: LazyOptions
) => LazyFunction<any, any, any, LazyOptions>;

function rollback

rollback: (snapshot: ObjectSerializerSnapshot) => void;

function setCircularReference

setCircularReference: (value: ReferenceableItem) => void;

function snapshot

snapshot: () => ObjectSerializerSnapshot;

function write

write: (
    value?: any
) => ObjectSerializerContextObjectMiddlewareObject_4<ReadonlyArray<any>>;

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);

Creates an instance of AggressiveMergingPlugin.

property options

options: AggressiveMergingPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class AggressiveSplittingPlugin

class AggressiveSplittingPlugin {}

constructor

constructor(options?: AggressiveSplittingPluginOptions);

Creates an instance of AggressiveSplittingPlugin.

property options

options: AggressiveSplittingPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

method wasChunkRecorded

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

Was chunk recorded.

class LimitChunkCountPlugin

class LimitChunkCountPlugin {}

constructor

constructor(options?: LimitChunkCountPluginOptions);

Creates an instance of LimitChunkCountPlugin.

property options

options: LimitChunkCountPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class MergeDuplicateChunksPlugin

class MergeDuplicateChunksPlugin {}

constructor

constructor(options?: MergeDuplicateChunksPluginOptions);

Creates an instance of MergeDuplicateChunksPlugin.

property options

options: MergeDuplicateChunksPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class MinChunkSizePlugin

class MinChunkSizePlugin {}

constructor

constructor(options: MinChunkSizePluginOptions);

Creates an instance of MinChunkSizePlugin.

property options

options: MinChunkSizePluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class ModuleConcatenationPlugin

class ModuleConcatenationPlugin {}

constructor

constructor();

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class RealContentHashPlugin

class RealContentHashPlugin {}

constructor

constructor(__0: RealContentHashPluginOptions);

Creates an instance of RealContentHashPlugin.

property getCompilationHooks

static getCompilationHooks: (compilation: Compilation) => {
    updateHash: SyncBailHook<[Buffer[], string], string | void>;
};

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class RuntimeChunkPlugin

class RuntimeChunkPlugin {}

constructor

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

Creates an instance of RuntimeChunkPlugin.

property options

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

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class SideEffectsFlagPlugin

class SideEffectsFlagPlugin {}

constructor

constructor(analyseSource?: boolean);

Creates an instance of SideEffectsFlagPlugin.

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

method moduleHasSideEffects

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

Module has side effects.

class SplitChunksPlugin

class SplitChunksPlugin {}

constructor

constructor(options?: OptimizationSplitChunksOptions);

Creates an instance of SplitChunksPlugin.

property options

options: SplitChunksOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

namespace optimize.InnerGraph

namespace optimize.InnerGraph {}

variable topLevelSymbolTag

const topLevelSymbolTag: Symbol;

function getDependencyUsedByExportsCondition

getDependencyUsedByExportsCondition: (
    dependency: Dependency,
    moduleGraph: ModuleGraph
) =>
    | false
    | ((
          moduleGraphConnection: ModuleGraphConnection,
          runtime: RuntimeSpec
      ) => ConnectionState);

function getInnerGraphUtils

getInnerGraphUtils: (compilation: Compilation) => InnerGraphUtils;

class TopLevelSymbol

class TopLevelSymbol {}

constructor

constructor(
    name: string,
    pure?: boolean | ((compilation: Compilation, module: Module) => boolean)
);

Creates an instance of TopLevelSymbol.

property conditional

conditional: boolean;

property name

name: string;

property pureFn

pureFn?: (compilation: Compilation, module: Module) => boolean;

method isPure

isPure: (compilation: Compilation, module: Module) => boolean;

method setPure

setPure: (pure: PureCondition) => void;

Sets the pure condition

namespace prefetch

namespace prefetch {}

class ChunkPrefetchPreloadPlugin

class ChunkPrefetchPreloadPlugin {}

Adds runtime support for chunk prefetch and preload relationships discovered in the chunk graph.

constructor

constructor();

method apply

apply: (compiler: Compiler) => void;

Registers compilation hooks that emit the runtime modules responsible for scheduling chunk prefetch and preload requests.

namespace runtime

namespace runtime {}

class GetChunkFilenameRuntimeModule

class GetChunkFilenameRuntimeModule extends RuntimeModule {}

constructor

constructor(
    contentType: string,
    name: string,
    global: string,
    getFilenameForChunk: (
        chunk: Chunk
    ) =>
        | string
        | false
        | ((pathData: PathDataChunk, assetInfo?: AssetInfo) => string),
    allChunks: boolean,
    usesFullHashDigest?: boolean
);

property allChunks

allChunks: boolean;

property contentType

contentType: string;

property getFilenameForChunk

getFilenameForChunk: (
    chunk: Chunk
) =>
    | string
    | false
    | ((pathData: PathDataChunk, assetInfo?: 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

method getSourceBasicTypes

static getSourceBasicTypes: (module: Module) => ReadonlySet<string>;

Gets source basic types.
Deprecated
In webpack 6, call getSourceBasicTypes() directly on the module instance instead of using this static method.

class LoadScriptRuntimeModule

class LoadScriptRuntimeModule extends HelperRuntimeModule {}

constructor

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

property getCompilationHooks

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

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 getSourceBasicTypes

static getSourceBasicTypes: (module: Module) => ReadonlySet<string>;

Gets source basic types.
Deprecated
In webpack 6, call getSourceBasicTypes() directly on the module instance instead of using this static method.

namespace RuntimeGlobals

namespace RuntimeGlobals {}

variable amdDefine

let amdDefine: string;

variable amdOptions

let amdOptions: string;

variable analyzableChunkImport

let analyzableChunkImport: string;

variable asyncModule

let asyncModule: string;

variable asyncModuleDoneSymbol

let asyncModuleDoneSymbol: string;

variable asyncModuleExportSymbol

let asyncModuleExportSymbol: string;

variable asyncModuleGenerator

let asyncModuleGenerator: string;

variable baseURI

let baseURI: string;

variable chunkCallback

let chunkCallback: string;

variable chunkName

let chunkName: string;

variable commonJsWrap

let commonJsWrap: string;

variable compatGetDefaultExport

let compatGetDefaultExport: string;

variable compileWasm

let compileWasm: string;

variable createFakeNamespaceObject

let createFakeNamespaceObject: string;

variable createScript

let createScript: string;

variable createScriptUrl

let createScriptUrl: string;

variable cssInjectStyle

let cssInjectStyle: string;

variable currentRemoteGetScope

let currentRemoteGetScope: string;

variable deferredModuleAsyncTransitiveDependencies

let deferredModuleAsyncTransitiveDependencies: string;

variable deferredModuleAsyncTransitiveDependenciesSymbol

let deferredModuleAsyncTransitiveDependenciesSymbol: 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 esmId

let esmId: string;

variable esmIds

let esmIds: string;

variable esmModules

let esmModules: string;

variable esmRuntime

let esmRuntime: 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 getWorkletBootstrap

let getWorkletBootstrap: 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 makeDeferredNamespaceObject

let makeDeferredNamespaceObject: string;

variable makeNamespaceObject

let makeNamespaceObject: string;

variable makeOptimizedDeferredNamespaceObject

let makeOptimizedDeferredNamespaceObject: 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 prefetchAsset

let prefetchAsset: string;

variable prefetchChunk

let prefetchChunk: string;

variable prefetchChunkHandlers

let prefetchChunkHandlers: string;

variable preloadAsset

let preloadAsset: 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 setAnonymousDefaultName

let setAnonymousDefaultName: string;

variable shareScopeMap

let shareScopeMap: string;

variable startup

let startup: string;

variable startupAssetHints

let startupAssetHints: 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 toBinary

let toBinary: string;

variable uncaughtErrorHandler

let uncaughtErrorHandler: string;

variable wasmInstances

let wasmInstances: string;

variable worker

let worker: string;

namespace sharing {}

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

class ConsumeSharedPlugin {}

constructor(options: ConsumeSharedPluginOptions);

Creates an instance of ConsumeSharedPlugin.

options: ConsumeSharedPluginOptions;

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class ProvideSharedPlugin {}

constructor(options: ProvideSharedPluginOptions);

Creates an instance of ProvideSharedPlugin.

options: ProvideSharedPluginOptions;

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

class SharePlugin {}

constructor(options: SharePluginOptions);

Creates an instance of SharePlugin.

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

namespace sources

namespace sources {}

class CachedSource

class CachedSource extends Source {}

constructor

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

method getCachedData

getCachedData: () => CachedData;

method original

original: () => Source;

method originalLazy

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

method streamChunks

streamChunks: (
    options: StreamChunksOptions,
    onChunk: (
        chunk: undefined | string,
        generatedLine: number,
        generatedColumn: number,
        sourceIndex: number,
        originalLine: number,
        originalColumn: number,
        nameIndex: number
    ) => void,
    onSource: (
        sourceIndex: number,
        source: null | string,
        sourceContent?: string
    ) => void,
    onName: (nameIndex: number, name: string) => void
) => GeneratedSourceInfo;

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: ConcatSourceChild[]);

method add

add: (item: ConcatSourceChild) => void;

method addAllSkipOptimizing

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

method getChildren

getChildren: () => Source[];

method streamChunks

streamChunks: (
    options: StreamChunksOptions,
    onChunk: (
        chunk: undefined | string,
        generatedLine: number,
        generatedColumn: number,
        sourceIndex: number,
        originalLine: number,
        originalColumn: number,
        nameIndex: number
    ) => void,
    onSource: (
        sourceIndex: number,
        source: null | string,
        sourceContent?: string
    ) => void,
    onName: (nameIndex: number, name: string) => void
) => GeneratedSourceInfo;

class OriginalSource

class OriginalSource extends Source {}

constructor

constructor(value: any, name: string);

method getName

getName: () => string;

method streamChunks

streamChunks: (
    options: StreamChunksOptions,
    onChunk: (
        chunk: undefined | string,
        generatedLine: number,
        generatedColumn: number,
        sourceIndex: number,
        originalLine: number,
        originalColumn: number,
        nameIndex: number
    ) => void,
    onSource: (
        sourceIndex: number,
        source: null | string,
        sourceContent?: string
    ) => void,
    _onName: (nameIndex: number, name: string) => void
) => GeneratedSourceInfo;

class PrefixSource

class PrefixSource extends Source {}

constructor

constructor(prefix: string, source: any);

method getPrefix

getPrefix: () => string;

method original

original: () => Source;

method streamChunks

streamChunks: (
    options: StreamChunksOptions,
    onChunk: (
        chunk: undefined | string,
        generatedLine: number,
        generatedColumn: number,
        sourceIndex: number,
        originalLine: number,
        originalColumn: number,
        nameIndex: number
    ) => void,
    onSource: (
        sourceIndex: number,
        source: null | string,
        sourceContent?: string
    ) => void,
    onName: (nameIndex: number, name: string) => void
) => GeneratedSourceInfo;

class RawSource

class RawSource extends Source {}

constructor

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

method isBuffer

isBuffer: () => boolean;

method streamChunks

streamChunks: (
    options: StreamChunksOptions,
    onChunk: (
        chunk: undefined | string,
        generatedLine: number,
        generatedColumn: number,
        sourceIndex: number,
        originalLine: number,
        originalColumn: number,
        nameIndex: number
    ) => void,
    onSource: (
        sourceIndex: number,
        source: null | string,
        sourceContent?: string
    ) => void,
    onName: (nameIndex: number, name: string) => void
) => GeneratedSourceInfo;

class ReplaceSource

class ReplaceSource extends Source {}

constructor

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

property Replacement

static Replacement: typeof Replacement;

method getName

getName: () => undefined | string;

method getReplacements

getReplacements: () => Replacement[];

method insert

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

method original

original: () => Source;

method replace

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

method streamChunks

streamChunks: (
    options: StreamChunksOptions,
    onChunk: (
        chunk: undefined | string,
        generatedLine: number,
        generatedColumn: number,
        sourceIndex: number,
        originalLine: number,
        originalColumn: number,
        nameIndex: number
    ) => void,
    onSource: (
        sourceIndex: number,
        source: null | string,
        sourceContent?: string
    ) => void,
    onName: (nameIndex: number, name: string) => void
) => GeneratedSourceInfo;

class SizeOnlySource

class SizeOnlySource extends Source {}

constructor

constructor(size: number);

class Source

class Source {}

constructor

constructor();

method buffer

buffer: () => Buffer;

method buffers

buffers: () => Buffer[];

method clearCache

clearCache: (options?: ClearCacheOptions, visited?: WeakSet<Source>) => void;

Release cached data held by this source. clearCache is a memory hint: it never affects correctness or output, only how expensive the next read is. Subclasses override; the base is a no-op so every Source supports the call. Composite sources always recurse into wrapped sources. When the same child is reachable via several parents (e.g. modules shared across webpack chunks), pass a shared visited WeakSet so each subtree is walked at most once. Not safe to call concurrently with source/map/sourceAndMap/ streamChunks/updateHash on the same instance.

method map

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

method size

size: () => number;

method source

source: () => SourceValue;

method sourceAndMap

sourceAndMap: (options?: MapOptions) => SourceAndMap;

method updateHash

updateHash: (hash: HashLike) => void;

class SourceMapSource

class SourceMapSource extends Source {}

constructor

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

method getArgsAsBuffers

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

method streamChunks

streamChunks: (
    options: StreamChunksOptions,
    onChunk: (
        chunk: undefined | string,
        generatedLine: number,
        generatedColumn: number,
        sourceIndex: number,
        originalLine: number,
        originalColumn: number,
        nameIndex: number
    ) => void,
    onSource: (
        sourceIndex: number,
        source: null | string,
        sourceContent?: string
    ) => void,
    onName: (nameIndex: number, name: string) => void
) => GeneratedSourceInfo;

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: HashFunction) => Hash;

class LazySet

class LazySet<T> {}

Like Set but with an addAll method to eventually add items from another iterable. Access methods make sure that all delayed operations are executed. Iteration methods deopts to normal Set performance until clear is called again (because of the chance of modifications during iteration).

constructor

constructor(iterable?: Iterable<T>);

Seeds the set with an optional iterable while preparing internal queues for deferred merges.

property size

readonly size: number;

Returns the number of items after applying any deferred merges.

method [Symbol.iterator]

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

Returns the default iterator over values after forcing pending merges.

method add

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

Adds a single item immediately to the concrete backing set.

method addAll

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

Queues another iterable or lazy set for later merging so large bulk adds can stay cheap until the set is read.

method clear

clear: () => void;

Removes all items and clears every deferred merge queue.

method delete

delete: (value: T) => boolean;

Deletes an item after first materializing any deferred additions that may contain it.

method deserialize

static deserialize: <T>(
    __0: ObjectDeserializerContextObjectMiddlewareObject_3<(number | T)[]>
) => LazySet<T>;

Restores a LazySet from serialized item data.

method entries

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

Returns the set's entry iterator and permanently switches future operations to eager merge mode to preserve iterator correctness.

method forEach

forEach: <K>(
    callbackFn: (value: T, value2: T, set: Set<T>) => void,
    thisArg: K
) => void;

Iterates over every item after forcing pending merges and switching to eager mode for correctness during iteration.

method has

has: (item: T) => boolean;

Checks whether an item is present after applying any deferred merges.

method keys

keys: () => SetIterator<T>;

Returns the key iterator, eagerly materializing pending merges first.

method serialize

serialize: (
    __0: ObjectSerializerContextObjectMiddlewareObject_4<(number | T)[]>
) => void;

Serializes the fully materialized set contents into webpack's object serialization stream.

method values

values: () => SetIterator<T>;

Returns the value iterator, eagerly materializing pending merges first.

namespace util.comparators

namespace util.comparators {}

variable compareChunks

let compareChunks: ParameterizedComparator<ChunkGraph, Chunk>;

variable compareModulesByFullName

let compareModulesByFullName: ParameterizedComparator<Compiler, Module>;

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>;

function sortWithSourceOrder

sortWithSourceOrder: (
    dependencies: Dependency[],
    dependencySourceOrderMap: WeakMap<Dependency, DependencySourceOrder>,
    onDependencyReSort?: (dep: Dependency, index: number) => void
) => void;

namespace util.compileBooleanMatcher

namespace util.compileBooleanMatcher {}

function fromLists

fromLists: (
    positiveItems: string[],
    negativeItems: string[]
) => (value: 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: (runtime?: RuntimeSpec) => boolean
) => undefined | string | boolean | SortableSet<string>;

function forEachRuntime

forEachRuntime: (
    runtime: RuntimeSpec,
    fn: (runtime?: 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, R = T> {}

Represents RuntimeSpecMap.

constructor

constructor(clone?: RuntimeSpecMap<T, R>);

Creates an instance of RuntimeSpecMap.

property size

readonly size: number;

method delete

delete: (runtime: RuntimeSpec) => void;

Processes the provided runtime.

method get

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

Returns value.

method has

has: (runtime: RuntimeSpec) => boolean;

Returns true, when the runtime is stored.

method keys

keys: () => RuntimeSpec[];

method provide

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

Returns the new value.

method set

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

Updates default using the provided runtime.

method update

update: (runtime: RuntimeSpec, fn: (value?: R) => R) => void;

Processes the provided runtime.

method values

values: () => IterableIterator<R>;

Returns values.

class RuntimeSpecSet

class RuntimeSpecSet {}

constructor

constructor(iterable?: Iterable<RuntimeSpec>);

Creates an instance of RuntimeSpecSet.

property size

readonly size: number;

method [Symbol.iterator]

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

Returns iterable iterator.

method add

add: (runtime: RuntimeSpec) => void;

Processes the provided runtime.

method has

has: (runtime: RuntimeSpec) => boolean;

Returns true, when the runtime exists.

namespace util.serialization

namespace util.serialization {}

variable buffersSerializer

const buffersSerializer: Serializer<any, any, any>;

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: <D, S, C>(
    fs: IntermediateFileSystem,
    hashFunction: HashFunction
) => Serializer<D, S, C>;

function register

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

function registerLoader

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

function registerNotSerializable

registerNotSerializable: (Constructor: Constructor) => void;

namespace wasm

namespace wasm {}

class AsyncWebAssemblyModulesPlugin

class AsyncWebAssemblyModulesPlugin {}

constructor

constructor(options: AsyncWebAssemblyModulesPluginOptions);

Creates an instance of AsyncWebAssemblyModulesPlugin.

property getCompilationHooks

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

property options

options: AsyncWebAssemblyModulesPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

method renderModule

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

Renders the newly generated source from rendering.

class EnableWasmLoadingPlugin

class EnableWasmLoadingPlugin {}

Validates and enables named wasm loading backends by applying the plugin implementations that provide their runtime support.

constructor

constructor(type: string);

Stores the wasm loading backend name that should be enabled for the compiler.

property type

type: string;

method apply

apply: (compiler: Compiler) => void;

Enables the requested wasm loading backend once and applies the environment-specific plugins that provide its parser, generator, and runtime support.

method checkEnabled

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

Verifies that a wasm loading type has been enabled before code generation attempts to use it.

method setEnabled

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

Marks a custom or built-in wasm loading type as enabled for the compiler without applying additional built-in behavior.

namespace web

namespace web {}

class CssLoadingRuntimeModule

class CssLoadingRuntimeModule extends RuntimeModule {}

constructor

constructor(runtimeRequirements: ReadonlySet<string>);

property getCompilationHooks

static getCompilationHooks: (compilation: Compilation) => {
    createStylesheet: SyncWaterfallHook<[string, Chunk], string>;
    linkPreload: SyncWaterfallHook<[string, Chunk], string>;
    linkPrefetch: SyncWaterfallHook<[string, Chunk], string>;
    linkInsert: SyncWaterfallHook<[string, Chunk], 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 getSourceBasicTypes

static getSourceBasicTypes: (module: Module) => ReadonlySet<string>;

Gets source basic types.
Deprecated
In webpack 6, call getSourceBasicTypes() directly on the module instance instead of using this static method.

class FetchCompileAsyncWasmPlugin

class FetchCompileAsyncWasmPlugin {}

Enables asynchronous WebAssembly loading through fetch for environments that can instantiate fetched binaries at runtime.

constructor

constructor();

method apply

apply: (compiler: Compiler) => void;

Registers compilation hooks that attach the async fetch-based wasm runtime to chunks containing async WebAssembly modules.

class FetchCompileWasmPlugin

class FetchCompileWasmPlugin {}

Enables synchronous WebAssembly chunk loading that fetches .wasm files and compiles them in browser-like environments.

constructor

constructor(options?: FetchCompileWasmPluginOptions);

Stores options that affect generated synchronous WebAssembly runtime code.

property options

options: FetchCompileWasmPluginOptions;

method apply

apply: (compiler: Compiler) => void;

Registers compilation hooks that attach the fetch-based synchronous wasm runtime module to chunks containing sync WebAssembly modules.

class JsonpChunkLoadingRuntimeModule

class JsonpChunkLoadingRuntimeModule extends RuntimeModule {}

constructor

constructor(runtimeRequirements: ReadonlySet<string>);

property getCompilationHooks

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

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 getSourceBasicTypes

static getSourceBasicTypes: (module: Module) => ReadonlySet<string>;

Gets source basic types.
Deprecated
In webpack 6, call getSourceBasicTypes() directly on the module instance instead of using this static method.

class JsonpTemplatePlugin

class JsonpTemplatePlugin {}

constructor

constructor();

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

method getCompilationHooks

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

Returns hooks.
Deprecated
use JsonpChunkLoadingRuntimeModule.getCompilationHooks instead

namespace webworker

namespace webworker {}

class WebWorkerTemplatePlugin

class WebWorkerTemplatePlugin {}

constructor

constructor();

method apply

apply: (compiler: Compiler) => void;

Applies the plugin by registering its hooks on the compiler.

Package Files (1)

types.d.ts

Dev Dependencies (92)

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 2 seconds ago.
Package analyzed in 23949 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_ONLY

variable UNDEFINED_MARKER

variable UsageState

variable version

variable webpack

Functions

function defineConfig

function exports

function validate

function validateSchema

Classes

class AsyncDependenciesBlock

constructor

property chunkName

property circular

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 contentHashFull

property cssFilenameTemplate

property debugId

property entryModule

Deprecated

property extraAsync

property filenameTemplate

property files

property groupsIterable

property hash

property id

property idNameHints

property ids

property modulesIterable

Deprecated

property name

property preventIntegration

property rendered

property renderedHash