- AppendOnlyStackedSet
- AssetBytesGenerator
- AssetBytesParser
- AssetGenerator
- AssetParser
- AssetSourceGenerator
- AssetSourceParser
- AsyncQueue
- AsyncWebAssemblyParser
- BasicEvaluatedExpression
- ByTypeGenerator
- CacheFacade
- ChunkTemplate
- ConstDependencyTemplate
- ContextDependency
- ContextElementDependency
- ContextModuleFactory
- CssGenerator
- CssModule
- CssParser
- DependenciesBlock
- DependencyTemplate
- DependencyTemplates
- EntryDependency
- ExportInfo
- ExportMode
- ExportsInfo
- FileSystemInfo
- HarmonyExportImportedSpecifierDependency
- HarmonyImportDependencyTemplate
- HarmonyStarExportsList
- Hash
- HelperRuntimeModule
- ItemCacheFacade
- JavascriptGenerator
- JsonData
- JsonGenerator
- JsonParser
- LocalModule
- MainTemplate
- ModuleExternalInitFragment
- ModuleProfile
- ModuleTemplate
- MultiWatching
- NormalModuleFactory
- NormalReexportItem
- NullDependencyTemplate
- OptionsApply
- Profiler
- Replacement
- RequestShortener
- ResolverFactory
- RestoreProvidedData
- RuntimeTemplate
- RuntimeValue
- Serializer
- SerializerMiddleware
- Snapshot
- SortableSet
- StackedMap
- StatsFactory
- StatsPrinter
- VariableInfo
- WeakTupleMap
- WebAssemblyParser
- WebpackLogger
Attributes
options:
<Configuration>callback:
{CallbackWebpackFunction_2<Stats, void>}
Returns:
<Compiler>
|
<null>Attributes
options:
<Configuration>Returns:
<Compiler>Attributes
options:
<MultiConfiguration>callback:
{CallbackWebpackFunction_2<MultiStats, void>}
Returns:
<MultiCompiler>
|
<null>Attributes
options:
<MultiConfiguration>Returns:
<MultiCompiler>Attributes
signal:
<AbortSignal>Attributes
[index: {string}]<any>
Attributes
webpackAST:
<object>Attributes
minSizeReduce:
<number>minimal size reduction to trigger merging
Attributes
[index: {string}]{AliasOptionNewRequest}
Attributes
assetInfo:
<AssetInfo>an asset info for asset modules
chunkInitFragments:
{InitFragment
[]} chunk init fragments for javascript modules
filename:
<string>a filename for asset modules
fullContentHash:
<string>a full content hash for asset modules
share-init:
{Tuple
topLevelDeclarations:
{Set
} top level declarations for javascript modules
url:
<object>url for css and javascript modules
Attributes
sourceType{"css-url"}
Options object for data url generation.
encoding{false|"base64"} Asset encoding (defaults to base64).mimetype<string>Asset mimetype (getting from file extension by default).
Generator options for asset/inline modules.
Attributes
Options object for DataUrl condition.
Attributes
maxSize:
<number>Maximum size of asset that should be inline as modules. Default: 8kb.
Parser options for asset modules.
Attributes
dataUrlCondition:
<object>The condition for inlining the asset as DataUrl.
Generator options for asset/resource modules.
Attributes
binary:
<boolean>Whether or not this asset module should be considered binary. This can be set to 'false' to treat this asset module as text.
emit:
<boolean>Emit an output asset from this asset module. This can be set to 'false' to omit emitting e. g. for SSR.
Specifies the filename template of output files on disk. You must
not
specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
Emit the asset in the specified folder relative to 'output.path'. This should only be needed when custom 'publicPath' is specified to match the folder structure there.
Attributes
mangleImports:
<boolean>mangle imports
Attributes
Attributes
Attributes
__innerRequest:
<string>inner request for internal usage
__innerRequest_relativePath:
<string>inner relative path for internal usage
__innerRequest_request:
<string>inner request for internal usage
context:
{ContextTypes} content
descriptionFileData:
{JsonObjectTypes} description file data
descriptionFilePath:
<string>description file path
descriptionFileRoot:
<string>description file root
fullySpecified:
<boolean>true when full specified, otherwise false
ignoreSymlinks:
<boolean>true when need to ignore symlinks, otherwise false
path:
<string>path
relativePath:
<string>relative path
tsconfigPathsMap:
<null>tsconfig paths map
Attributes
afterStartup:
<string[]>allowInlineStartup:
<boolean>beforeStartup:
<string[]>header:
<string[]>startup:
<string[]>Attributes
file:
<string>file
mappings:
{Buffer
} mappings
names:
<string[]>name
sourceRoot:
<string>source root
sources:
<string[]>sources
sourcesContent:
{""|Buffer
[]} sources content
version:
<number>version
Attributes
buffer{Buffer} bufferhash{string|Buffer[]} hash maps{Map<string, BufferEntry>} mapssize<number>sizesource<boolean>source
Attributes
chunkGraph:
<ChunkGraph>moduleGraph:
<ModuleGraph>Attributes
automaticNameDelimiter:
<string>chunksFilter:
<object>enforce:
<boolean>enforceSizeThreshold:
{SplitChunksSizes}
getName:
<object>idHint:
<string>key:
<string>maxAsyncRequests:
<number>maxAsyncSize:
{SplitChunksSizes}
maxInitialRequests:
<number>maxInitialSize:
{SplitChunksSizes}
minChunks:
<number>minRemainingSize:
{SplitChunksSizes}
minSize:
{SplitChunksSizes}
minSizeReduction:
{SplitChunksSizes}
priority:
<number>reuseExistingChunk:
<boolean>usedExports:
<boolean>[index: {string}]<undefined>
Attributes
Attributes
err:
<WebpackError>
|
<null>result:
<null>Returns:
{void}
Attributes
err:
<WebpackError>
|
<null>result:
{T}
Returns:
{void}
Attributes
Returns:
{void}
Attributes
Returns:
{void}
Attributes
Returns:
{void}
Attributes
Returns:
{R}
call{CallExpression}calleeName<string>getCalleeMembers<object>getMemberRanges<object>getMembers<object>getMembersOptionals<object>name<string>rootInfo<string>| [<VariableInfo>](/VariableInfo.html) type{"call"}
[index: {string}]{ChunkId[]}
[index: {string}]{ChunkChildIdsByOrdersMap}
chunks{Set} onChunks<Chunk[]>
Attributes
chunkGroup:
<ChunkGroup>name:
<string>Attributes
chunkGraph:
<ChunkGraph>the chunk graph
codeGenerationResults:
<CodeGenerationResults>results of code generation
moduleGraph:
<ModuleGraph>the module graph
runtimeTemplate:
[
/RuntimeTemplate.html) the runtime template
<RuntimeTemplate>
](
contentHash{Record<ChunkId, Record<string, string>>}hash{Record<ChunkId, string>}name{Record<ChunkId, string>}
[index: {string}]<string>
-
[index: {number}]{IdToHashMap} -
[index: {string}]{IdToHashMap}
-
[index: {number}]{ChunkId[]} -
[index: {string}]{ChunkId[]}
-
[index: {number}]{ModuleId[]} -
[index: {string}]{ModuleId[]}
Attributes
-
[index: {number}]{ModuleId[]} -
[index: {string}]{ModuleId[]}
hash{chunkModuleHashMap}id{ChunkModuleIdMapEs5Alias_1}
contentHash{Record<string, string>}contentHashWithLength{Record<string, object>}hash<string>hashWithLength<object>id<string>|<number>name<string>
Attributes
chunk:
<Chunk>the chunk
chunkGraph:
<ChunkGraph>the chunk graph
codeGenerationResults:
<CodeGenerationResults>results of code generation
moduleFactoryCache:
{WeakMap<Source, ModuleFactoryCacheEntry>} moduleFactoryCache
moduleSourceContent:
<Source>content
runtimeTemplate:
[
/RuntimeTemplate.html) the runtime template
<RuntimeTemplate>
](
undoPath:
<string>undo path to css file
Attributes
chunk:
<Chunk>the chunk
chunkGraph:
<ChunkGraph>the chunk graph
chunkInitFragments:
{InitFragment
[]} init fragments for the chunk
codeGenerationResults:
<CodeGenerationResults>results of code generation
dependencyTemplates:
[
/DependencyTemplates.html) the dependency templates
<DependencyTemplates>
](
moduleGraph:
<ModuleGraph>the module graph
runtimeTemplate:
[
/RuntimeTemplate.html) the runtime template
<RuntimeTemplate>
](
strictMode:
<boolean>rendering in strict context
Attributes
Advanced options for cleaning assets.
Attributes
keep{SyncBailHook<Tuple, boolean|void>} when returning true the file/directory will be kept during cleaning, returning false will clean it and ignore the following plugins and config
Attributes
chunkGraph:
<ChunkGraph>the chunk graph
codeGenerationResults:
<CodeGenerationResults>code generation results of other modules (need to have a codeGenerationDependency to use that)
compilation:
<Compilation>the compilation
concatenationScope:
<ConcatenationScope>when in concatenated module, information about other concatenated modules
dependencyTemplates:
[
/DependencyTemplates.html) the dependency templates
<DependencyTemplates>
](
moduleGraph:
<ModuleGraph>the module graph
runtime:
{RuntimeSpec} the runtimes code should be generated for
runtimes:
{RuntimeSpec[]} all runtimes code should be generated for
runtimeTemplate:
[
/RuntimeTemplate.html) the runtime template
<RuntimeTemplate>
](
sourceTypes:
{ReadonlySet
} source types
Attributes
data{CodeGenerationResultData} the resulting data for all source typeshash<string>a hash of the code generation result (will be automatically calculated from sources and runtimeRequirements if not provided)runtimeRequirements{ReadonlySet|null} the runtime requirements sources{Map<string, Source>} the resulting sources for all source types
Attributes
Attributes
Attributes
a{T}b{T}- Returns: {-1|0|1}
declaration{CompatibilitySettingsDeclaration}name<string>
loc{DependencyLocation}range{Tuple<number, number>}updated<boolean>
[index: {string}]<Source>
renderModuleContent{SyncWaterfallHook<Tuple<Source, Module, WebAssemblyRenderContext>, Source>}
chunkHash{SyncHook<Tuple<Chunk, Hash, ChunkHashContext>>}renderModulePackage{SyncWaterfallHook<Tuple<Source, Module, ChunkRenderContextCssModulesPlugin>, Source>}
chunkHash{SyncHook<Tuple<Chunk, Hash, ChunkHashContext>>}embedInRuntimeBailout{SyncBailHook<Tuple<Module, RenderContextJavascriptModulesPlugin>, string|void>}inlineInRuntimeBailout{SyncBailHook<Tuple<Module, Partial>, string|void>} render{SyncWaterfallHook<Tuple<Source, RenderContextJavascriptModulesPlugin>, Source>}renderChunk{SyncWaterfallHook<Tuple<Source, RenderContextJavascriptModulesPlugin>, Source>}renderContent{SyncWaterfallHook<Tuple<Source, RenderContextJavascriptModulesPlugin>, Source>}renderMain{SyncWaterfallHook<Tuple<Source, RenderContextJavascriptModulesPlugin>, Source>}renderModuleContainer{SyncWaterfallHook<Tuple<Source, Module, ModuleRenderContext>, Source>}renderModuleContent{SyncWaterfallHook<Tuple<Source, Module, ModuleRenderContext>, Source>}renderModulePackage{SyncWaterfallHook<Tuple<Source, Module, ModuleRenderContext>, Source>}renderRequire{SyncWaterfallHook<Tuple<string, RenderBootstrapContext>, string>}renderStartup{SyncWaterfallHook<Tuple<Source, Module, StartupRenderContext>, Source>}strictRuntimeBailout{SyncBailHook<Tuple, string|void>} useSourceMap{SyncBailHook<Tuple<Chunk, RenderContextJavascriptModulesPlugin>, boolean|void>}
addContainerEntryDependency{SyncHook} addFederationRuntimeDependency{SyncHook}
updateHash{SyncBailHook<Tuple<Buffer[], string>, string|void>}
contextModuleFactory[<ContextModuleFactory>](/ContextModuleFactory.html) normalModuleFactory[<NormalModuleFactory>](/NormalModuleFactory.html)
ast{Program}chunkInitFragments{InitFragment[]} concatenationScope<ConcatenationScope>exportMap{Map<string, string>}globalScope{Scope<Variable, Reference>} index<number>internalNames{Map<string, string>}internalSource<Source>interopDefaultAccessName<string>runtime namespace object that detects "__esModule"interopDefaultAccessUsed<boolean>runtime namespace object that detects "__esModule"interopNamespaceObject2Name<string>"default-only" namespaceinteropNamespaceObject2Used<boolean>"default-only" namespaceinteropNamespaceObjectName<string>"default-with-named" namespaceinteropNamespaceObjectUsed<boolean>"default-with-named" namespacemodule<Module>moduleScope{Scope<Variable, Reference>} namespaceExportSymbol<string>namespaceObjectName<string>rawExportMap{Map<string, string>}runtimeRequirements{ReadonlySet} source<ReplaceSource>type{"concatenated"}
Attributes
chunkGraph:
<ChunkGraph>the chunk graph
moduleGraph:
<ModuleGraph>the module graph
new Constructor(...params): anyAttributes
params:
<any[]>Returns:
<any>Advanced configuration for modules that should be consumed from share scope.
Attributes
eager:
<boolean>Include the fallback module directly instead behind an async request. This allows to use fallback module in initial load too. All possible shared modules need to be eager too.
import:
<string>Fallback module if no shared module is found in share scope. Defaults to the property name.
packageName:
<string>Package name to determine required version from description file. This is only needed when package name can't be automatically determined from request.
requiredVersion:
<string>Version requirement from module in share scope.
shareKey:
<string>Module is looked up under this key from the share scope.
shareScope:
<string>Share scope name.
singleton:
<boolean>Allow only a single version of the shared module in share scope (disabled by default).
strictVersion:
<boolean>Do not accept shared module if version is not valid (defaults to yes, if local fallback module is available and shared module is not a singleton, otherwise no, has no effect if there is no required version specified).
Options for consuming shared modules.
consumes{Consumes} Modules that should be consumed from share scope. When provided, property names are used to match requested modules in this compilation.shareScope<string>Share scope name used for all consumed modules (defaults to 'default').
Modules that should be consumed from share scope. Property names are used to match requested modules in this compilation. Relative requests are resolved, module requests are matched unresolved, absolute paths will match resolved requests. A trailing slash will match all requests with this prefix. In this case shareKey must also have a trailing slash.
[index: {string}]<string>
exposes{Exposes} Modules that should be exposed by this container. When provided, property name is used as public name, otherwise public name is automatically inferred from request.filename<string>The filename for this container relative path inside theoutput.pathdirectory.library<LibraryOptions>Options for library.name<string>The name for this container.runtime<string>The name of the runtime chunk. If set a runtime chunk with this name is created or an existing entrypoint is used as runtime.shareScope<string>The name of the share scope which is shared with the host (defaults to 'default').
remotes{Remotes} Container locations and request scopes from which modules should be resolved and loaded at runtime. When provided, property name is used as request scope, otherwise request scope is automatically inferred from container location.remoteType{ExternalsType} The external type of the remote containers.shareScope<string>The name of the share scope shared with all remotes (defaults to 'default').
Attributes
resolved{ResolvedContextFileSystemInfoEntry}safeTime<number>symlinks{Set} timestampHash<string>
Attributes
Attributes
resolveOptions:
<ResolveOptions>resource:
<string>
|
<string[]>resourceFragment:
<string>resourceQuery:
<string>Attributes
Attributes
context:
<string>contextDependencies:
{LazySet
}
dependencies:
[
/ContextDependency.html)
<ContextDependency[]>
](
fileDependencies:
{LazySet
}
missingDependencies:
{LazySet
}
request:
<string>resolveOptions:
<ResolveOptions>Attributes
Attributes
esModule:
<boolean>whether export __esModule
exports:
{Map<string, string>} the css exports
Generator options for css modules.
Attributes
Attributes
createStylesheet{SyncWaterfallHook<Tuple<string, Chunk>, string>}linkPrefetch{SyncWaterfallHook<Tuple<string, Chunk>, string>}linkPreload{SyncWaterfallHook<Tuple<string, Chunk>, string>}
Generator options for css/module modules.
Attributes
esModule:
<boolean>Configure the generated JS modules that use the ES modules syntax.
exportsConvention:
<object>Specifies the convention of exported names.
exportsOnly:
<boolean>Avoid generating and loading a stylesheet and only embed exports from css into output javascript files.
exportType:
{"link"|"text"|"css-style-sheet"|"style"} Configure how CSS content is exported as default.
localIdentHashDigest:
<string>Digest types used for the hash.
localIdentHashDigestLength:
<number>Number of chars which are used for the hash.
localIdentHashFunction:
<string>| [
/Hash.html) Algorithm used for generation the hash (see node.js crypto package).
<Hash>
](
localIdentHashSalt:
<string>Any string which is added to the hash to salt it.
Parser options for css/module modules.
Attributes
animation:
<boolean>Enable/disable renaming of
@keyframes
.container:
<boolean>Enable/disable renaming of
@container
names.customIdents:
<boolean>Enable/disable renaming of custom identifiers.
dashedIdents:
<boolean>Enable/disable renaming of dashed identifiers, e. g. custom properties.
exportType:
{"link"|"text"|"css-style-sheet"|"style"} Configure how CSS content is exported as default.
function:
<boolean>Enable/disable renaming of
@function
names.grid:
<boolean>Enable/disable renaming of grid identifiers.
import:
<boolean>Enable/disable
@import
at-rules handling.namedExports:
<boolean>Use ES modules named export for css exports.
url:
<boolean>Enable/disable
url()
/
image-set()
/
src()
/
image()
functions handling.Parser options for css modules.
exportType{"link"|"text"|"css-style-sheet"|"style"} Configure how CSS content is exported as default.import<boolean>Enable/disable@importat-rules handling.namedExports<boolean>Use ES modules named export for css exports.url<boolean>Enable/disableurl()/image-set()/src()/image()functions handling.
definitions{SyncWaterfallHook<Tuple<Record<string, CodeValue>>, Record<string, CodeValue>>}
[index: {string}]{CodeValue}
Attributes
blocks:
<AsyncDependenciesBlock[]>dependencies:
<Dependency[]>new DependencyConstructor(...args): DependencyAttributes
args:
<any[]>Returns:
<Dependency>Attributes
Attributes
chunkGraph:
<ChunkGraph>the chunk graph
chunkInitFragments:
{InitFragment
[]} chunkInitFragments
codeGenerationResults:
<CodeGenerationResults>the code generation results
concatenationScope:
<ConcatenationScope>when in a concatenated module, information about other concatenated modules
dependencyTemplates:
[
/DependencyTemplates.html) the dependency templates
<DependencyTemplates>
](
initFragments:
{InitFragment
[]} mutable array of init fragments for the current module
module:
<Module>current module
moduleGraph:
<ModuleGraph>the module graph
runtime:
{RuntimeSpec} current runtimes, for which code is generated
runtimeRequirements:
{Set
} the requirements for runtime
runtimeTemplate:
[
/RuntimeTemplate.html) the runtime template
<RuntimeTemplate>
](
Helper function for joining two ranges into a single range. This is useful when working with AST nodes, as it allows you to combine the ranges of child nodes to create the range of the parent node.
Attributes
Attributes
Attributes
context:
<string>context relative to which module identifiers are computed
failOnConflict:
<boolean>throw an error when id conflicts occur (instead of rehashing)
fixedLength:
<boolean>do not increase the maxLength to find an optimal id space size
maxLength:
<number>maximum id length in digits (used as starting point)
salt:
<number>hash salt for ids
test:
<object>selector function for modules
Attributes
isBlockDevice:
<object>true when is block device, otherwise false
isCharacterDevice:
<object>true when is character device, otherwise false
isDirectory:
<object>true when is directory, otherwise false
isFIFO:
<object>true when is FIFO, otherwise false
isFile:
<object>true when is file, otherwise false
isSocket:
<object>true when is socket, otherwise false
isSymbolicLink:
<object>true when is symbolic link, otherwise false
name:
{T} name
parentPath:
<string>path
path:
<string>path
- {IteratorObject}
Returns:
{void}
Attributes
context:
<string>Context of requests in the manifest file (defaults to the webpack context).
entryOnly:
<boolean>If true, only entry points will be exposed (default: true).
format:
<boolean>If true, manifest json file (output) will be formatted.
name:
<string>Name of the exposed dll function (external name, use value of 'output.library').
path:
<string>Absolute path to the manifest json file (output).
type:
<string>Type of the dll bundle (external type, use value of 'output.libraryTarget').
The mappings from request to module info.
[index: {string}]<object>
An object containing content, name and type.
content{DllReferencePluginOptionsContent} The mappings from request to module info.name<string>The name where the dll is exposed (external name).type{"global"|"commonjs"|"jsonp"|"this"|"var"|"assign"|"window"|"commonjs2"|"commonjs-module"|"amd"|"amd-require"|"umd"|"umd2"|"system"} The type how the dll is exposed (external type).
Options for Dotenv plugin.
Attributes
dir:
<string>The directory from which .env files are loaded. Can be an absolute path, false will disable the .env file loading.
prefix:
<string>
|
<string[]>Only expose environment variables that start with these prefixes. Defaults to 'WEBPACK_'.
template:
<string[]>Template patterns for .env file names. Use [mode] as placeholder for the webpack mode. Defaults to ['.env', '.env.local', '.env.[mode]', '.env.[mode].local'].
Attributes
attributes{Record<string, string>}compiler<string>dependency<string>descriptionData{JsonObjectTypes}issuer<string>issuerLayer<string>mimetype<string>realResource<string>resource<string>resourceFragment<string>resourceQuery<string>scheme<string>
type{EffectUseType}value<object>
No generator options are supported for this module type.
No parser options are supported for this module type.
Attributes
additionalApply:
<object>function that runs when applying the current plugin.
Attributes
dependencies:
<Dependency[]>dependencies of the entrypoint that should be evaluated at startup
includeDependencies:
<Dependency[]>dependencies of the entrypoint that should be included but not evaluated
options:
<EntryOptions>options of the entrypoint
An object with entry point description.
Attributes
asyncChunks:
<boolean>Enable/disable creating async chunks that are loaded on demand.
baseUri:
<string>Base uri for this entry.
chunkLoading:
<string>The method of loading chunks (methods included by default are 'jsonp' (web), 'import' (ESM), 'importScripts' (WebWorker), 'require' (sync node.js), 'async-node' (async node.js), but others might be added by plugins).
dependOn:
<string>
|
<string[]>The entrypoints that the current entrypoint depend on. They must be loaded when this entrypoint is loaded.
Specifies the filename of the output file on disk. You must
not
specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
import:
{EntryItem} Module(s) that are loaded upon startup.
library:
<LibraryOptions>Options for library.
The 'publicPath' specifies the public URL address of the output files when referenced in a browser.
runtime:
<string>The name of the runtime chunk. If set a runtime chunk with this name is created or an existing entrypoint is used as runtime.
wasmLoading:
<string>The method of loading WebAssembly Modules (methods included by default are 'fetch' (web/WebWorker), 'async-node' (node.js), but others might be added by plugins).
An object with entry point description.
Attributes
asyncChunks:
<boolean>Enable/disable creating async chunks that are loaded on demand.
baseUri:
<string>Base uri for this entry.
chunkLoading:
<string>The method of loading chunks (methods included by default are 'jsonp' (web), 'import' (ESM), 'importScripts' (WebWorker), 'require' (sync node.js), 'async-node' (async node.js), but others might be added by plugins).
dependOn:
<string[]>The entrypoints that the current entrypoint depend on. They must be loaded when this entrypoint is loaded.
Specifies the filename of output files on disk. You must
not
specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
import:
<string[]>Module(s) that are loaded upon startup. The last one is exported.
library:
<LibraryOptions>Options for library.
The 'publicPath' specifies the public URL address of the output files when referenced in a browser.
runtime:
<string>The name of the runtime chunk. If set a runtime chunk with this name is created or an existing entrypoint is used as runtime.
wasmLoading:
<string>The method of loading WebAssembly Modules (methods included by default are 'fetch' (web/WebWorker), 'async-node' (node.js), but others might be added by plugins).
Multiple entry bundles are created. The key is the entry name. The value is an entry description object.
[index: {string}]{EntryDescriptionNormalized}
Attributes
[index: {string}]{EnumValue}
The abilities of the environment where the webpack generated code should run.
Attributes
arrowFunction:
<boolean>The environment supports arrow functions ('() => { ... }').
asyncFunction:
<boolean>The environment supports async function and await ('async function () { await ... }').
bigIntLiteral:
<boolean>The environment supports BigInt as literal (123n).
const:
<boolean>The environment supports const and let for variable declarations.
destructuring:
<boolean>The environment supports destructuring ('{ a, b } = obj').
document:
<boolean>The environment supports 'document'.
dynamicImport:
<boolean>The environment supports an async import() function to import EcmaScript modules.
dynamicImportInWorker:
<boolean>The environment supports an async import() is available when creating a worker.
forOf:
<boolean>The environment supports 'for of' iteration ('for (const x of array) { ... }').
globalThis:
<boolean>The environment supports 'globalThis'.
importMetaDirnameAndFilename:
<boolean>The environment supports
import.meta.dirname
and
import.meta.filename
.methodShorthand:
<boolean>The environment supports object method shorthand ('{ module() {} }').
module:
<boolean>The environment supports EcmaScript Module syntax to import EcmaScript modules (import ... from '...').
nodePrefixForCoreModules:
<boolean>The environment supports
node:
prefix for Node.js core modules.optionalChaining:
<boolean>The environment supports optional chaining ('obj?.a' or 'obj?.()').
templateLiteral:
<boolean>The environment supports template literals.
Attributes
toString:
<object>Attributes
codeGenerationResult{CodeGenerationResult}module<Module>moduleObject{ExecuteModuleObject}
__webpack_require__{WebpackRequire}assets{Map<string, object>}chunk<Chunk>chunkGraph<ChunkGraph>
Attributes
Attributes
entryOptions:
<EntryOptions>assets{Map<string, object>}buildDependencies{LazySet} cacheable<boolean>contextDependencies{LazySet} exports<any>fileDependencies{LazySet} missingDependencies{LazySet}
Attributes
Enables/Disables experiments (experimental features with relax SemVer compatibility).
Attributes
asyncWebAssembly:
<boolean>Support WebAssembly as asynchronous EcmaScript Module.
backCompat:
<boolean>Enable backward-compat layer with deprecation warnings for many webpack 4 APIs.
cacheUnaffected:
<boolean>Enable additional in memory caching of modules that are unchanged and reference only unchanged modules.
futureDefaults:
<boolean>Apply defaults of next major version.
outputModule:
<boolean>Allow output javascript files as module source type.
syncWebAssembly:
<boolean>Support WebAssembly as synchronous EcmaScript Module (outdated).
Enables/Disables experiments (experimental features with relax SemVer compatibility).
[index: {string}]<any>
Attributes
buildHttp:
<string>
|
<RegExp>
|
<object[]>Build http(s): urls using a lockfile and resource content cache.
css:
<boolean>Enable css support.
deferImport:
<boolean>Enable experimental tc39 proposal
https://github.com/tc39/proposal-defer-import-eval
. This allows to defer execution of a module until it's first use.
lazyCompilation:
<boolean>Compile entrypoints and import()s only when they are accessed.
Enables/Disables experiments (experimental features with relax SemVer compatibility).
buildHttp{HttpUriOptions} Build http(s): urls using a lockfile and resource content cache.css<boolean>Enable css support.deferImport<boolean>Enable experimental tc39 proposal https://github.com/tc39/proposal-defer-import-eval. This allows to defer execution of a module until it's first use.lazyCompilation{false|LazyCompilationOptions} Compile entrypoints and import()s only when they are accessed.
Attributes
canMangle:
<boolean>can the export be renamed (defaults to true)
export:
<string[]>
|
<null>when reexported: from which export
exports:
<string>nested exports
when reexported: from which module
hidden:
<boolean>export is not visible, because another export blends over it
name:
<string>the name of the export
priority:
<number>when reexported: with which priority
terminalBinding:
<boolean>is the export a terminal binding that should be checked for export star conflicts
Attributes
canMangle:
<boolean>can the export be renamed (defaults to true)
dependencies:
<Module[]>module on which the result depends on
excludeExports:
{Set
} when exports = true, list of unaffected exports
when reexported: from which module
hideExports:
{Set
|null} list of maybe prior exposed, but now hidden exports
priority:
<number>when reexported: with which priority
terminalBinding:
<boolean>are the exports terminal bindings that should be checked for export star conflicts
Advanced configuration for modules that should be exposed by this container.
Attributes
import:
<string>
|
<string[]>Request to a module that should be exposed by this container.
name:
<string>Custom chunk name for the exposed module.
Modules that should be exposed by this container. Property names are used as public paths.
[index: {string}]<string>|<string[]>
Attributes
Attributes
alias:
<string>
|
<string[]>extension:
<string>[index: {string}]<string>|<string[]>
chunkCondition{SyncBailHook<Tuple<Chunk, Compilation>, boolean>}
Attributes
deferred:
<boolean>the module is deferred at least once
deferredName:
<string>deferred module.exports / harmony namespace object
deferredNamespaceObjectName:
<string>deferred namespace object that being used in a not-analyzable way so it must be materialized
deferredNamespaceObjectUsed:
<boolean>deferred namespace object that being used in a not-analyzable way so it must be materialized
index:
<number>interopDefaultAccessName:
<string>runtime namespace object that detects "__esModule"
interopDefaultAccessUsed:
<boolean>runtime namespace object that detects "__esModule"
interopNamespaceObject2Name:
<string>"default-only" namespace
interopNamespaceObject2Used:
<boolean>"default-only" namespace
interopNamespaceObjectName:
<string>"default-with-named" namespace
interopNamespaceObjectUsed:
<boolean>"default-with-named" namespace
module:
<Module>name:
<string>module.exports / harmony namespace object
nonDeferAccess:
<boolean>runtimeCondition:
{string|boolean|SortableSet
}
type:
{"external"}
Enable presets of externals for specific targets.
Attributes
electron:
<boolean>Treat common electron built-in modules in main and preload context like 'electron', 'ipc' or 'shell' as external and load them via require() when used.
electronMain:
<boolean>Treat electron built-in modules in the main context like 'app', 'ipc-main' or 'shell' as external and load them via require() when used.
electronPreload:
<boolean>Treat electron built-in modules in the preload context like 'web-frame', 'ipc-renderer' or 'shell' as external and load them via require() when used.
electronRenderer:
<boolean>Treat electron built-in modules in the renderer context like 'web-frame', 'ipc-renderer' or 'shell' as external and load them via require() when used.
node:
<boolean>Treat node.js built-in modules like fs, path or vm as external and load them via require() when used.
nwjs:
<boolean>Treat NW.js legacy nw.gui module as external and load it via require() when used.
web:
<boolean>Treat references to 'http(s)://...' and 'std:...' as external and load them via import when used (Note that this changes execution order as externals are executed before any other code in the chunk).
webAsync:
<boolean>Treat references to 'http(s)://...' and 'std:...' as external and load them via async import() when used (Note that this external type is an async module, which has various effects on the execution).
Attributes
context:
<string>contextInfo:
{Partial
}
currentProfile:
[
/ModuleProfile.html)
<ModuleProfile>
](
dependencies:
<Dependency[]>factory:
<ModuleFactory>factoryResult:
<boolean>return full ModuleFactoryResult instead of only module
Attributes
sideEffectFree:
<boolean>Attributes
Attributes
mangleImports:
<boolean>mangle imports
lstat{LStatTypes} lstat methodreaddir{ReaddirTypes} readdir methodreadFile{ReadFileTypes} read file methodreadJson<object>read json methodreadlink{ReadlinkTypes} read link methodrealpath{RealPathTypes} realpath methodstat{StatTypes} stat method
Attributes
[index: {string}]<Argument>
Attributes
[index: {string}]<string>
Attributes
chunkGraph:
<ChunkGraph>the chunk graph
codeGenerationResults:
<CodeGenerationResults>code generation results of other modules (need to have a codeGenerationDependency to use that)
concatenationScope:
<ConcatenationScope>when in concatenated module, information about other concatenated modules
dependencyTemplates:
[
/DependencyTemplates.html) mapping from dependencies to templates
<DependencyTemplates>
](
getData:
<object>get access to the code generation data
moduleGraph:
<ModuleGraph>the module graph
runtime:
{RuntimeSpec} the runtime
runtimeRequirements:
{Set
} the requirements for runtime
runtimeTemplate:
[
/RuntimeTemplate.html) the runtime template
<RuntimeTemplate>
](
type:
<string>which kind of code should be generated
Attributes
[index: {string}]<any>
Specify options for each generator.
[index: {string}]<object>
result{T}callback<object>- Returns: {void}
Attributes
Attributes
Attributes
checkCycle:
<boolean>check the cycle dependencies of the created module
connectOrigin:
<boolean>connect the resolved module with the origin module
context:
<string>contextInfo:
{Partial
}
dependencies:
<Dependency[]>factory:
<ModuleFactory>recursive:
<boolean>recurse into dependencies of the created module
attributes{Record<string, string>}await<boolean>ids<string[]>name<string>phase{ImportPhaseType}source<string>sourceOrder<number>
guards{AppendOnlyStackedSet}
Attributes
updateHash:
<object>Attributes
context:
<string>The context directory for creating names.
hashDigest:
{"ascii"|"utf8"|"utf-8"|"utf16le"|"utf-16le"|"ucs2"|"ucs-2"|"base64"|"base64url"|"latin1"|"binary"|"hex"} The encoding to use when generating the hash, defaults to 'base64'. All encodings from Node.JS' hash.digest are supported.
hashDigestLength:
<number>The prefix length of the hash digest to use, defaults to 4.
hashFunction:
<string>| [
/Hash.html) The hashing algorithm to use, defaults to 'md4'. All functions from Node.JS' crypto.createHash are supported.
<Hash>
](
Attributes
hotAcceptCallback{SyncBailHook<Tuple<ClassExpression|Identifier|SimpleLiteral|RegExpLiteral|BigIntLiteral|ArrayExpression|ArrowFunctionExpression|AssignmentExpression|AwaitExpression|BinaryExpression|SimpleCallExpression|NewExpression|ChainExpression|ConditionalExpression|FunctionExpression|ImportExpression|LogicalExpression|MemberExpression|MetaProperty|ObjectExpression|SequenceExpression|TaggedTemplateExpression|TemplateLiteral|ThisExpression|UnaryExpression|UpdateExpression|YieldExpression|SpreadElement, string[]>, void>}hotAcceptWithoutCallback{SyncBailHook<Tuple<CallExpression, string[]>, void>}
These properties are added by the HotModuleReplacementPlugin
Attributes
hot:
<boolean>Options for building http resources.
Attributes
allowedUris:
<string>
|
<RegExp>
|
<object[]>List of allowed URIs (resp. the beginning of them).
cacheLocation:
<string>Location where resource content is stored for lockfile entries. It's also possible to disable storing by passing false.
frozen:
<boolean>When set, anything that would lead to a modification of the lockfile or any resource content, will result in an error.
lockfileLocation:
<string>Location of the lockfile.
proxy:
<string>Proxy configuration, which can be used to specify a proxy server to use for HTTP requests.
upgrade:
<boolean>When set, resources of existing lockfile entries will be fetched and entries will be upgraded when resource content has changed.
attributes{Record<string, string>}externalType{"module"|"import"}
Attributes
expression{ImportExpressionJavascriptParser}references{string[][]}
Options for infrastructure level logging.
Attributes
appendOnly:
<boolean>Only appends lines to the output. Avoids updating existing output e. g. for status messages. This option is only used when no custom console is provided.
colors:
<boolean>Enables/Disables colorful output. This option is only used when no custom console is provided.
console:
<Console>Custom console used for logging.
level:
{"error"|"warn"|"info"|"log"|"verbose"|"none"} Log level.
stream:
<WritableStream>
|
<object>Stream used for logging output. Defaults to process.stderr. This option is only used when no custom console is provided.
Session{Session}
Attributes
Attributes
info:
<AssetInfo>path:
<string>Attributes
atime:
<Date>atimeMs:
<number>birthtime:
<Date>birthtimeMs:
<number>blksize:
<number>blocks:
<number>ctime:
<Date>ctimeMs:
<number>dev:
<number>gid:
<number>ino:
<number>isBlockDevice:
<object>isCharacterDevice:
<object>isDirectory:
<object>isFIFO:
<object>isFile:
<object>isSocket:
<object>isSymbolicLink:
<object>mode:
<number>mtime:
<Date>mtimeMs:
<number>nlink:
<number>rdev:
<number>size:
<number>uid:
<number>Attributes
atime:
<Date>atimeMs:
{T}
birthtime:
<Date>birthtimeMs:
{T}
blksize:
{T}
blocks:
{T}
ctime:
<Date>ctimeMs:
{T}
dev:
{T}
gid:
{T}
ino:
{T}
isBlockDevice:
<object>isCharacterDevice:
<object>isDirectory:
<object>isFIFO:
<object>isFile:
<object>isSocket:
<object>isSymbolicLink:
<object>mode:
{T}
mtime:
<Date>mtimeMs:
{T}
nlink:
{T}
rdev:
{T}
size:
{T}
uid:
{T}
[index: {string}]<string>|<string[]>
- {Iterator<T, TReturn, TNext>}.{Disposable}
- {SetIterator}
Returns:
{void}
Returns:
{IteratorObject<T, TReturn, TNext>}
Parser options for javascript modules.
Attributes
amd:
<object>Set the value of
require.amd
and
define.amd
. Or disable AMD support.browserify:
<boolean>Enable/disable special handling for browserify bundles.
commonjs:
<boolean>Enable/disable parsing of CommonJs syntax.
commonjsMagicComments:
<boolean>Enable/disable parsing of magic comments in CommonJs syntax.
Enable/disable parsing "import { createRequire } from "module"" and evaluating createRequire().
deferImport:
<boolean>Enable experimental tc39 proposal
https://github.com/tc39/proposal-defer-import-eval
. This allows to defer execution of a module until it's first use.
dynamicImportFetchPriority:
{false|"auto"|"low"|"high"} Specifies global fetchPriority for dynamic import.
dynamicImportMode:
{"weak"|"eager"|"lazy"|"lazy-once"} Specifies global mode for dynamic import.
dynamicUrl:
<boolean>Enable/disable parsing of dynamic URL.
exportsPresence:
{false|"error"|"warn"|"auto"} Specifies the behavior of invalid export names in "import ... from ..." and "export ... from ...".
exprContextCritical:
<boolean>Enable warnings for full dynamic dependencies.
exprContextRecursive:
<boolean>Enable recursive directory lookup for full dynamic dependencies.
Sets the default regular expression for full dynamic dependencies.
exprContextRequest:
<string>Set the default request for full dynamic dependencies.
harmony:
<boolean>Enable/disable parsing of EcmaScript Modules syntax.
import:
<boolean>Enable/disable parsing of import() syntax.
importExportsPresence:
{false|"error"|"warn"|"auto"} Specifies the behavior of invalid export names in "import ... from ...".
importMeta:
<boolean>Enable/disable evaluating import.meta. Set to 'preserve-unknown' to preserve unknown properties for runtime evaluation.
importMetaContext:
<boolean>Enable/disable evaluating import.meta.webpackContext.
node:
{false|NodeOptions} Include polyfills or mocks for various node stuff.
overrideStrict:
{"strict"|"non-strict"} Override the module to strict or non-strict. This may affect the behavior of the module (some behaviors differ between strict and non-strict), so please configure this option carefully.
parse:
<object>Function to parser source code.
reexportExportsPresence:
{false|"error"|"warn"|"auto"} Specifies the behavior of invalid export names in "export ... from ...". This might be useful to disable during the migration from "export ... from ..." to "export type ... from ..." when reexporting types in TypeScript.
requireContext:
<boolean>Enable/disable parsing of require.context syntax.
requireEnsure:
<boolean>Enable/disable parsing of require.ensure syntax.
requireInclude:
<boolean>Enable/disable parsing of require.include syntax.
requireJs:
<boolean>Enable/disable parsing of require.js special syntax like require.config, requirejs.config, require.version and requirejs.onError.
strictExportPresence:
<boolean>Deprecated in favor of "exportsPresence". Emit errors instead of warnings when imported names don't exist in imported module.
strictThisContextOnImports:
<boolean>Handle the this context correctly according to the spec for namespace objects.
system:
<boolean>Enable/disable parsing of System.js special syntax like System.import, System.get, System.set and System.register.
unknownContextCritical:
<boolean>Enable warnings when using the require function in a not statically analyse-able way.
unknownContextRecursive:
<boolean>Enable recursive directory lookup when using the require function in a not statically analyse-able way.
Sets the regular expression when using the require function in a not statically analyse-able way.
unknownContextRequest:
<string>Sets the request when using the require function in a not statically analyse-able way.
url:
<boolean>Enable/disable parsing of new URL() syntax.
worker:
<boolean>
|
<string[]>Disable or configure parsing of WebWorker syntax like new Worker() or navigator.serviceWorker.register().
wrappedContextCritical:
<boolean>Enable warnings for partial dynamic dependencies.
wrappedContextRecursive:
<boolean>Enable recursive directory lookup for partial dynamic dependencies.
wrappedContextRegExp:
<RegExp>Set the inner regular expression for partial dynamic dependencies.
Generator options for json modules.
Attributes
JSONParse:
<boolean>Use
JSON.parse
when the JSON string is longer than 20 characters.Attributes
[index: {string}]<string>|<number>|<boolean>|<null>|<undefined>
[index: {string}]<string>|<number>|<boolean>|<null>|<undefined>
Parser options for JSON modules.
Attributes
linkPrefetch{SyncWaterfallHook<Tuple<string, Chunk>, string>}linkPreload{SyncWaterfallHook<Tuple<string, Chunk>, string>}
Attributes
chunkhash:
<string>
|
<string[]>the value(s) of the chunk hash used for this asset
contenthash:
<string>
|
<string[]>the value(s) of the content hash used for this asset
development:
<boolean>true, when asset is only used for development and doesn't count towards user-facing assets
fullhash:
<string>
|
<string[]>the value(s) of the full hash used for this asset
hotModuleReplacement:
<boolean>true, when asset ships data for updating an existing application (HMR)
immutable:
<boolean>true, if the asset can be long term cached forever (contains a hash)
javascriptModule:
<boolean>true, when asset is javascript and an ESM
manifest:
<boolean>true, when file is a manifest
minimized:
<boolean>whether the asset is minimized
modulehash:
<string>
|
<string[]>the value(s) of the module hash used for this asset
related:
{Record<string, string|string[]|null>} object of pointers to other assets, keyed by type of relation (only points from parent to child)
size:
<number>size in bytes, only set after asset has been emitted
sourceFilename:
<string>when asset was created from a source file (potentially transformed), the original filename relative to compilation context
Attributes
active:
<boolean>for lazy compilation modules
assetInfo:
<AssetInfo>for assets modules
assets:
{Record<string, Source>} using in NormalModule
assetsInfo:
{Map<string, AssetInfo|undefined>} using in NormalModule
buildDependencies:
{LazySet
} using in NormalModule
cacheable:
<boolean>contextDependencies:
{LazySet
} using in NormalModule
cssData:
{CssData} for css modules
dataUrl:
<boolean>for assets modules
exportsArgument:
<string>using in AMD
fileDependencies:
{LazySet
} using in NormalModule
filename:
<string>for assets modules
fullContentHash:
<string>for assets modules
hash:
<string>using in NormalModule
javascriptModule:
<boolean>for external modules
jsonData:
[
/JsonData.html) for json modules
<JsonData>
](
missingDependencies:
{LazySet
} using in NormalModule
moduleArgument:
<string>using in AMD
moduleConcatenationBailout:
<string>using in CommonJs
needCreateRequire:
<boolean>using in APIPlugin
parsed:
<boolean>resourceIntegrity:
<string>using in HttpUriPlugin
snapshot:
[
/Snapshot.html) |
<Snapshot>
](
<null>
using in ContextModulestrict:
<boolean>topLevelDeclarations:
{Set
} top level declaration names
valueDependencies:
{Map<string, ValueCacheVersion>} using in NormalModule
Attributes
async:
<boolean>defaultObject:
{false|"redirect"|"redirect-warn"}
exportsFinalNameByRuntime:
{Map<string, Record<string, string>>}
exportsSourceByRuntime:
{Map<string, string>}
exportsType:
{"default"|"dynamic"|"namespace"|"flagged"}
isCSSModule:
<boolean>jsIncompatibleExports:
{Record<string, string>}
sideEffectFree:
<boolean>strictHarmonyModule:
<boolean>treatAsCommonJs:
<boolean>Attributes
environments:
<string[]>environments
Attributes
forToString:
<boolean>noResolve{SyncHook<Tuple<ResolveRequest, Error>>} no resolve hookresolve{AsyncSeriesBailHook<Tuple<ResolveRequest, ResolveContext>, ResolveRequest|null>} resolve hookresolveStep{SyncHook<Tuple<AsyncSeriesBailHook<Tuple<ResolveRequest, ResolveContext>, ResolveRequest|null, UnsetAdditionalOptions>, ResolveRequest>>} resolve step hookresult{AsyncSeriesHook<Tuple<ResolveRequest, ResolveContext>>} result hook
harmonyNamedExports{Set} harmonyStarExports[<HarmonyStarExportsList>](/HarmonyStarExportsList.html) lastHarmonyImportOrder<number>localModules[<LocalModule[]>](/LocalModule.html)
deferredImportVarMap{Map<Module, string>}importVarMap{Map<Module, string>}
Attributes
assetsSort:
<string>assetsSpace:
<number>cachedAssets:
<boolean>cachedModules:
<boolean>chunkGroupAuxiliary:
<boolean>chunkGroupChildren:
<boolean>chunkGroupMaxAssets:
<number>chunkGroups:
<boolean>chunkModulesSort:
<string>chunkModulesSpace:
<number>chunksSort:
<string>context:
<string>dependentModules:
<boolean>entrypoints:
<boolean>excludeAssets:
<object[]>excludeModules:
<object[]>groupAssetsByEmitStatus:
<boolean>groupAssetsByExtension:
<boolean>groupAssetsByPath:
<boolean>groupModulesByAttributes:
<boolean>groupModulesByCacheStatus:
<boolean>groupModulesByExtension:
<boolean>groupModulesByLayer:
<boolean>groupModulesByPath:
<boolean>groupModulesByType:
<boolean>ids:
<boolean>logging:
{false|"error"|"warn"|"info"|"log"|"verbose"|"none"}
loggingDebug:
<object[]>loggingTrace:
<boolean>modulesSort:
<string>modulesSpace:
<number>nestedModulesSort:
<string>nestedModulesSpace:
<number>orphanModules:
<boolean>requestShortener:
[
/RequestShortener.html)
<RequestShortener>
](
runtimeModules:
<boolean>warningsFilter:
<object[]>aggressiveSplits{SplitData[]}chunkHashes{ChunkHashes}chunkModuleHashes{ChunkModuleHashes}chunkModuleIds{ChunkModuleIds}chunkRuntime{ChunkRuntime}chunks{RecordsChunks}fullHashChunkModuleHashes{FullHashChunkModuleHashes}hash<string>hotIndex<number>modules{RecordsModules}
Attributes
auxiliaryChunkIdHints:
<string[]>auxiliaryChunkNames:
{ChunkName[]}
auxiliaryChunks:
{ChunkId[]}
cached:
<boolean>chunkIdHints:
<string[]>chunkNames:
{ChunkName[]}
chunks:
{ChunkId[]}
comparedForEmit:
<boolean>emitted:
<boolean>filteredRelated:
<number>info:
<AssetInfo>isOverSizeLimit:
<boolean>name:
<string>related:
<StatsAsset[]>size:
<number>type:
<string>Attributes
auxiliaryFiles:
<string[]>children:
{ChunkId[]}
childrenByOrder:
{Record<string, ChunkId[]>}
entry:
<boolean>files:
<string[]>filteredModules:
<number>hash:
<string>idHints:
<string[]>initial:
<boolean>modules:
<StatsModule[]>names:
<string[]>origins:
<StatsChunkOrigin[]>parents:
{ChunkId[]}
reason:
<string>recorded:
<boolean>rendered:
<boolean>runtime:
<string[]>siblings:
{ChunkId[]}
size:
<number>sizes:
{Record<string, number>}
Attributes
assets:
<object[]>assetsSize:
<number>auxiliaryAssets:
<object[]>auxiliaryAssetsSize:
<number>childAssets:
{Record<string, string[]>}
children:
{Record<string, StatsChunkGroup[]>}
chunks:
{ChunkId[]}
filteredAssets:
<number>filteredAuxiliaryAssets:
<number>isOverSizeLimit:
<boolean>Attributes
Attributes
assets:
<StatsAsset[]>assetsByChunkName:
{Record<string, string[]>}
builtAt:
<number>children:
<StatsCompilation[]>chunks:
<StatsChunk[]>entrypoints:
{Record<string, StatsChunkGroup>}
env:
<any>errors:
<StatsError[]>errorsCount:
<number>filteredAssets:
<number>filteredErrorDetailsCount:
<number>filteredModules:
<number>filteredWarningDetailsCount:
<number>hash:
<string>logging:
{Record<string, StatsLogging>}
modules:
<StatsModule[]>name:
<string>namedChunkGroups:
{Record<string, StatsChunkGroup>}
needAdditionalPass:
<boolean>outputPath:
<string>publicPath:
<string>time:
<number>version:
<string>warnings:
<StatsError[]>warningsCount:
<number>cause{KnownStatsError}chunkEntry<boolean>chunkId<string>|<number>chunkInitial<boolean>chunkName<string>compilerPath<string>details<string>errors{KnownStatsError[]}file<string>loc<string>message<string>moduleId<string>|<number>moduleIdentifier<string>moduleName<string>moduleTrace<StatsModuleTraceItem[]>stack<string>
Attributes
cachedGetErrors:
<object>cachedGetWarnings:
<object>compilation:
<Compilation>compilationAuxiliaryFileToChunks:
{Map<string, Chunk[]>}
compilationFileToChunks:
{Map<string, Chunk[]>}
makePathsRelative:
<object>rootModules:
{Set
}
runtime:
{RuntimeSpec}
type:
<string>Attributes
Attributes
args:
<any[]>children:
<StatsLoggingEntry[]>message:
<string>time:
<number>trace:
<string[]>type:
<string>Attributes
assets:
<string[]>buildTimeExecuted:
<boolean>built:
<boolean>cacheable:
<boolean>cached:
<boolean>chunks:
{ChunkId[]}
codeGenerated:
<boolean>dependent:
<boolean>errors:
<number>failed:
<boolean>filteredModules:
<number>identifier:
<string>index:
<number>index2:
<number>issuerPath:
<StatsModuleIssuer[]>
|
<null>modules:
<StatsModule[]>moduleType:
<string>name:
<string>optimizationBailout:
<string[]>optional:
<boolean>orphan:
<boolean>postOrderIndex:
<number>preOrderIndex:
<number>profile:
<StatsProfile>providedExports:
<string[]>
|
<null>reasons:
<StatsModuleReason[]>size:
<number>sizes:
{Record<string, number>}
source:
{string|Buffer
}
type:
<string>usedExports:
<boolean>
|
<string[]>
|
<null>warnings:
<number>Attributes
Attributes
active:
<boolean>Attributes
loc:
<string>Attributes
Attributes
Attributes
asset:
<StatsAsset>chunk:
<StatsChunk>chunkGroup:
<StatsChunkGroup>chunkGroupKind:
<string>compilation:
<StatsCompilation>error:
<StatsError>logging:
<StatsLogging>module:
<StatsModule>moduleIssuer:
<StatsModuleIssuer>moduleReason:
<StatsModuleReason>moduleTraceDependency:
<StatsModuleTraceDependency>moduleTraceItem:
<StatsModuleTraceItem>profile:
<StatsProfile>type:
<string>Attributes
Attributes
factoryMeta{FactoryMeta} factory metageneratorOptions{GeneratorOptions}parserOptions{ParserOptions}resolveOptions<ResolveOptions>resolve options
Options for the default backend.
Attributes
client:
<string>A custom client.
protocol:
{"http"|"https"} Specifies the protocol the client should use to connect to the server.
server:
{ServerOptions<IncomingMessage, ServerResponse>|ServerOptions<IncomingMessage, ServerResponse>|object} Specifies how to create the server handling the EventSource requests.
Options for compiling entrypoints and import()s only when they are accessed.
Attributes
[index: {string}]<any>
Attributes
Attributes
context:
<string>Context of requests in the manifest file (defaults to the webpack context).
entryOnly:
<boolean>If true, only entry points will be exposed (default: true).
format:
<boolean>If true, manifest json file (output) will be formatted.
name:
<string>Name of the exposed dll function (external name, use value of 'output.library').
path:
<string>Absolute path to the manifest json file (output).
type:
<string>Type of the dll bundle (external type, use value of 'output.libraryTarget').
Attributes
Set explicit comments for commonjs, commonjs2, amd, and root.
Attributes
Description object for all UMD variants of the library name.
Attributes
amd:
<string>Name of the exposed AMD library in the UMD.
commonjs:
<string>Name of the exposed commonjs export in the UMD.
root:
<string>
|
<string[]>Name of the property exposed globally by a UMD library.
Attributes
Custom values available in the loader context.
[index: {string}]<any>
Attributes
[index: {string}]<any>
Attributes
These properties are added by the LoaderPlugin
Call Signature
Attributes
Returns:
{void}
Call Signature
Attributes
request:
<string>options:
{ImportModuleOptions}
Returns:
{Promise
}
Attributes
Returns:
{void}
Resolves the given request to a module, applies all configured loaders and calls back with the generated source, the sourceMap and the module instance (usually an instance of NormalModule). Use this function if you need to know the source code of another module to generate the result.
The properties are added by https://github.com/webpack/loader-runner
Attributes
callback:
<object>context:
<string>The directory of the module. Can be used as context for resolving other stuff.
eg '/workspaces/ts-loader/examples/vanilla/src'
currentRequest:
<string>data:
<any>environment:
{Environment} Tell what kind of ES-features may be used in the generated runtime-code.
Example: { arrowFunction: true }
loaderIndex:
<number>The index in the loaders array of the current loader.
In the example: in loader1: 0, in loader2: 1
loaders:
<object[]>An array of all the loaders. It is writeable in the pitch phase.
loaders = [{request: string, path: string, query: string, module: function}]
In the example:
[
{ request: "/abc/loader1.js?xyz",
path: "/abc/loader1.js",
query: "?xyz",
module: [Function]
},
{ request: "/abc/node_modules/loader2/index.js",
path: "/abc/node_modules/loader2/index.js",
query: "",
module: [Function]
}
]
previousRequest:
<string>query:
<string>remainingRequest:
<string>request:
<string>resource:
<string>The resource inclusive query and fragment.
Example: "/abc/resource.js?query#frag"
resourceFragment:
<string>The resource fragment.
Example: "#frag"
resourcePath:
<string>The resource path.
In the example: "/abc/resource.js"
resourceQuery:
<string>The resource query string.
Example: "?query"
target:
<string>Target of compilation.
Example: "web"
Attributes
context:
<string>Returns:
{void}
Add a directory as dependency of the loader result.
Attributes
file:
<string>Returns:
{void}
Adds a file as dependency of the loader result in order to make them watchable. For example, html-loader uses this technique as it finds src and src-set attributes. Then, it sets the url's for those attributes as dependencies of the html file that is parsed.
Attributes
context:
<string>Returns:
{void}
Returns:
<object>Make this loader async.
Attributes
flag:
<boolean>Returns:
{void}
Make this loader result cacheable. By default it's cacheable. A cacheable loader must have a deterministic result, when inputs and dependencies haven't changed. This means the loader shouldn't have other dependencies than specified with this.addDependency. Most loaders are deterministic and cacheable.
Returns:
{void}
Remove all dependencies of the loader result. Even initial dependencies and these of other loaders.
Attributes
file:
<string>Returns:
{void}
alias of addDependency Adds a file as dependency of the loader result in order to make them watchable. For example, html-loader uses this technique as it finds src and src-set attributes. Then, it sets the url's for those attributes as dependencies of the html file that is parsed.
Returns:
<string[]>Returns:
<string[]>Returns:
<string[]>createScript{SyncWaterfallHook<Tuple<string, Chunk>, string>}
Attributes
args:
<any[]>time:
<number>trace:
<string[]>type:
{"debug"|"error"|"warn"|"info"|"log"|"trace"|"group"|"groupCollapsed"|"groupEnd"|"profile"|"profileEnd"|"time"|"clear"|"status"}
path{PathLikeFs}callback<object>- Returns: {void}
path{PathLikeFs}options<object>|<undefined>callback<object>- Returns: {void}
path{PathLikeFs}options<undefined>callback<object>- Returns: {void}
path{PathLikeFs}options<undefined>- Returns: {IStats}
path{PathLikeFs}options<object>- Returns:
<undefined>
path{PathLikeFs}options<object>- Returns:
<undefined>
path{PathLikeFs}options<object>- Returns: {IStats}
path{PathLikeFs}options<object>- Returns: {IBigIntStats}
path{PathLikeFs}options<object>- Returns: {IStats|IBigIntStats}
path{PathLikeFs}options{StatSyncOptions}- Returns:
<undefined>
path{PathLikeTypes}callback<object>- Returns: {void}
path{PathLikeTypes}options<object>|<undefined>callback<object>- Returns: {void}
path{PathLikeTypes}options<undefined>callback<object>- Returns: {void}
Attributes
chunk:
<Chunk>the chunk
chunkGraph:
<ChunkGraph>the chunk graph
codeGenerationResults:
<CodeGenerationResults>results of code generation
dependencyTemplates:
[
/DependencyTemplates.html) the dependency templates
<DependencyTemplates>
](
hash:
<string>hash to be used for render call
moduleGraph:
<ModuleGraph>the module graph
runtimeTemplate:
[
/RuntimeTemplate.html) the runtime template
<RuntimeTemplate>
](
strictMode:
<boolean>rendering in strict context
Attributes
Describes a manifest entrypoint.
Attributes
imports:
<string[]>Contains the names of entrypoints.
parents:
<string[]>Contains the names of parent entrypoints.
Describes a manifest asset that links the emitted path to the producing asset.
Attributes
The manifest object.
[index: {string}]<any>
assets{Record<string, ManifestItem>} Contains the names of assets.entrypoints{Record<string, ManifestEntrypoint>} Contains the names of entrypoints.
Attributes
entrypoints:
<boolean>Enables/disables generation of the entrypoints manifest section.
filename:
<string>Specifies the filename of the output file on disk. By default the plugin will emit
manifest.json
inside the 'output.path' directory.filter:
<object>Allows filtering the files which make up the manifest.
generate:
<object>A function that receives the manifest object, modifies it, and returns the modified manifest.
prefix:
<string>Specifies a path prefix for all keys in the manifest.
serialize:
<object>A function that receives the manifest object and returns the manifest string.
Attributes
Attributes
Attributes
Attributes
stage:
<number>Specifies the stage for merging duplicate chunks.
Attributes
file{PathLikeFs}options<string>|<number>|<object>|<null>|<undefined>callback<object>- Returns: {void}
file{PathLikeFs}options<string>|<number>|<null>|<undefined>callback<object>- Returns: {void}
file{PathLikeFs}callback<object>- Returns: {void}
path{PathLikeFs}options<object>- Returns:
<string>|<undefined>
path{PathLikeFs}options<string>|<number>|<null>- Returns:
<string>|<undefined>
inheritance{Tuple<CssLayer, Supports, Media>[]} - The inheritance chainsource<CachedSource>- The cached sourceundoPath<string>- The undo path to the CSS file
Attributes
context:
<string>contextInfo:
{ModuleFactoryCreateDataContextInfo}
dependencies:
<Dependency[]>resolveOptions:
<ResolveOptions>Attributes
Attributes
Attributes
exposes:
<string>Modules that should be exposed by this container. When provided, property name is used as public name, otherwise public name is automatically inferred from request.
filename:
<string>The filename of the container as relative path inside the
output.path
directory.library:
<LibraryOptions>Options for library.
name:
<string>The name of the container.
remotes:
<string>Container locations and request scopes from which modules should be resolved and loaded at runtime. When provided, property name is used as request scope, otherwise request scope is automatically inferred from container location.
remoteType:
{"asset"|"module"|"css-import"|"css-url"|"global"|"import"|"commonjs"|"jsonp"|"promise"|"this"|"var"|"assign"|"window"|"self"|"commonjs2"|"commonjs-module"|"commonjs-static"|"amd"|"amd-require"|"umd"|"umd2"|"system"|"module-import"|"script"|"node-commonjs"} The external type of the remote containers.
runtime:
<string>The name of the runtime chunk. If set a runtime chunk with this name is created or an existing entrypoint is used as runtime.
shared:
<string>Modules that should be shared in the share scope. When provided, property names are used to match requested modules in this compilation.
shareScope:
<string>Share scope name used for all shared modules (defaults to 'default').
Attributes
absoluteResourcePath:
<string>the absolute resource path of the module request
allLoaders:
<string>the all loaders of the module request
hash:
<string>the hash of the module identifier
identifier:
<string>the identifier of the module
loaders:
<string>the loaders of the module request
moduleId:
<string>the module id of the module
namespace:
<string>the module namespace
query:
<string>the query of the module identifier
resource:
<string>the resource of the module request
resourcePath:
<string>the resource path of the module request
shortIdentifier:
<string>the shortened identifier of the module
buildInfo{BuildInfo}memCache{WeakTupleMap<any[], any>}references{WeakMap<Dependency, Module>}
Options affecting the normal modules (NormalModuleFactory).
Attributes
defaultRules:
<"...">
|
<RuleSetRule>
|
<null>
|
<undefined[]>An array of rules applied by default for modules.
generator:
{GeneratorOptionsByModuleType} Specify options for each generator.
Don't parse files matching. It's matched against the full resolved request.
parser:
{ParserOptionsByModuleType} Specify options for each parser.
rules:
<"...">
|
<RuleSetRule>
|
<null>
|
<undefined[]>An array of rules applied for modules.
Attributes
Attributes
asiSafe:
<boolean>if the position is ASI safe or unknown
call:
<boolean>true, when this referenced export is called
deferredImport:
<boolean>true, when this referenced export is deferred
directImport:
<boolean>true, when this referenced export is directly imported (not via property access)
ids:
<string[]>the properties/exports of the module
Attributes
chunk:
<Chunk>the chunk
chunkGraph:
<ChunkGraph>the chunk graph
chunkInitFragments:
{InitFragment
[]} init fragments for the chunk
codeGenerationResults:
<CodeGenerationResults>results of code generation
dependencyTemplates:
[
/DependencyTemplates.html) the dependency templates
<DependencyTemplates>
](
factory:
<boolean>true: renders as factory method, false: pure module content
inlinedInIIFE:
<boolean>the inlined entry module is wrapped in an IIFE, existing only when
factory
is set to falsemoduleGraph:
<ModuleGraph>the module graph
renderInObject:
<boolean>render module in object container
runtimeTemplate:
[
/RuntimeTemplate.html) the runtime template
<RuntimeTemplate>
](
strictMode:
<boolean>rendering in strict context
Attributes
Attributes
extractSourceMap:
<boolean>Enable/Disable extracting source map.
generator:
<object>The options for the module generator.
layer:
<string>Specifies the layer in which the module should be placed in.
parser:
<object>Options for parsing.
resolve:
<ResolveOptions>Options for the resolver.
sideEffects:
<boolean>Flags a module as with or without side effects.
type:
<string>Module type to use for the module.
javascript[<ModuleTemplate>](/ModuleTemplate.html)
Attributes
Attributes
Attributes
context:
<string>context
Attributes
compilation:
<Compilation>fileSystemInfo:
[
/FileSystemInfo.html)
<FileSystemInfo>
](
valueCacheVersions:
{Map<string, ValueCacheVersion>}
[index: {string}]<string>
infrastructureLogging{InfrastructureLogging} infrastructure logging options
Options object for node compatibility features.
Attributes
Attributes
asyncChunkLoading:
<boolean>enable async chunk loading
[index: {string}]{VirtualModule}
beforeLoaders{SyncHook<Tuple<LoaderItem[], NormalModule, AnyLoaderContext>>}beforeParse{SyncHook<Tuple>} beforeSnapshot{SyncHook<Tuple>} loader{SyncHook<Tuple<AnyLoaderContext, NormalModule>>}needBuild{AsyncSeriesBailHook<Tuple<NormalModule, NeedBuildContext>, boolean>}processResult{SyncWaterfallHook<Tuple<Tuple<string|Buffer, string|RawSourceMap|undefined, PreparsedAst|undefined>, NormalModule>, Tuple<string|Buffer , string|RawSourceMap|undefined, PreparsedAst|undefined>>} readResource{HookMap<AsyncSeriesBailHook<Tuple, string|Buffer |null, UnsetAdditionalOptions>>} readResourceForScheme{HookMap<FakeHook<AsyncSeriesBailHook<Tuple<string, NormalModule>, string|Buffer|null, UnsetAdditionalOptions>>>}
Attributes
context:
<string>context directory for resolving
extractSourceMap:
<boolean>enable/disable extracting source map
generator:
<Generator>the generator used
generatorOptions:
{GeneratorOptions} the options of the generator used
layer:
<string>an optional layer in which the module is
loaders:
{LoaderItem[]} list of loaders
matchResource:
<string>path + query of the matched resource (virtual)
parser:
{ParserClass} the parser used
parserOptions:
{ParserOptions} the options of the parser used
rawRequest:
<string>request without resolving
request:
<string>request string
resolveOptions:
<ResolveOptions>options used for resolving requests from this module
resource:
<string>path + query of the real resource
resourceResolveData:
{ResourceSchemeData|Partial
} resource resolve data
type:
<string>module type. When deserializing, this is set to an empty string "".
userRequest:
<string>request intended by user (without loaders from config)
These properties are added by the NormalModule
Attributes
_compilation:
<Compilation>_compiler:
<Compiler>_module:
<NormalModule>hashDigest:
<string>hashDigestLength:
<number>hashFunction:
{HashFunction}
hashSalt:
<string>mode:
{"development"|"none"|"production"}
rootContext:
<string>sourceMap:
<boolean>utils:
<object>version:
<number>webpack:
<boolean>Attributes
dep:
<string>Returns:
{void}
Attributes
error:
<Error>Returns:
{void}
Attributes
Returns:
{void}
Attributes
warning:
<Error>Returns:
{void}
Attributes
name:
<string>Returns:
[
/WebpackLogger.html)
<WebpackLogger>
](
Call Signature
Returns:
{OptionsType}
Call Signature
schema{Schema}- Returns: {OptionsType}
options{ResolveOptionsWithDependencyType}- Returns:
<object>
Attributes
Returns:
{void}
[index: {string}]<any>
Attributes
encoding:
<null>Attributes
Attributes
Attributes
prioritiseInitial:
<boolean>Prioritise initial size over total size.
Attributes
prioritiseInitial:
<boolean>Prioritise initial size over total size.
Attributes
safeTime:
<number>file{PathLikeFs}flags<string>|<number>|<undefined>mode<string>|<number>|<null>|<undefined>callback<object>- Returns: {void}
file{PathLikeFs}flags<string>|<number>|<undefined>callback<object>- Returns: {void}
file{PathLikeFs}callback<object>- Returns: {void}
Enables/Disables integrated optimizations.
Attributes
avoidEntryIife:
<boolean>Avoid wrapping the entry module in an IIFE.
checkWasmTypes:
<boolean>Check for incompatible wasm types when importing/exporting from/to ESM.
chunkIds:
{false|"size"|"natural"|"named"|"deterministic"|"total-size"} Define the algorithm to choose chunk ids (named: readable ids for better debugging, deterministic: numeric hash ids for better long term caching, size: numeric ids focused on minimal initial download size, total-size: numeric ids focused on minimal total download size, false: no algorithm used, as custom one can be provided via plugin).
concatenateModules:
<boolean>Concatenate modules when possible to generate less modules, more efficient code and enable more optimizations by the minimizer.
emitOnErrors:
<boolean>Emit assets even when errors occur. Critical errors are emitted into the generated code and will cause errors at runtime.
flagIncludedChunks:
<boolean>Also flag chunks as loaded which contain a subset of the modules.
innerGraph:
<boolean>Creates a module-internal dependency graph for top level symbols, exports and imports, to improve unused exports detection.
mangleExports:
<boolean>Rename exports when possible to generate shorter code (depends on optimization.usedExports and optimization.providedExports, true/"deterministic": generate short deterministic names optimized for caching, "size": generate the shortest possible names).
mangleWasmImports:
<boolean>Reduce size of WASM by changing imports to shorter strings.
mergeDuplicateChunks:
<boolean>Merge chunks which contain the same modules.
minimize:
<boolean>Enable minimizing the output. Uses optimization.minimizer.
minimizer:
<"...">
|
<WebpackPluginInstance>
|
<object>
|
<null>
|
<undefined[]>Minimizer(s) to use for minimizing the output.
moduleIds:
{false|"size"|"natural"|"named"|"deterministic"|"hashed"} Define the algorithm to choose module ids (natural: numeric ids in order of usage, named: readable ids for better debugging, hashed: (deprecated) short hashes as ids for better long term caching, deterministic: numeric hash ids for better long term caching, size: numeric ids focused on minimal initial download size, false: no algorithm used, as custom one can be provided via plugin).
nodeEnv:
<string>Set process.env.NODE_ENV to a specific value.
noEmitOnErrors:
<boolean>Avoid emitting assets when errors occur (deprecated: use 'emitOnErrors' instead).
portableRecords:
<boolean>Generate records with relative paths to be able to move the context folder.
providedExports:
<boolean>Figure out which exports are provided by modules to generate more efficient code.
realContentHash:
<boolean>Use real [contenthash] based on final content of the assets.
removeAvailableModules:
<boolean>Removes modules from chunks when these modules are already included in all parents.
removeEmptyChunks:
<boolean>Remove chunks which are empty.
Create an additional chunk which contains only the webpack runtime and chunk hash maps.
sideEffects:
<boolean>Skip over modules which contain no side effects when exports are not used (false: disabled, 'flag': only use manually placed side effects flag, true: also analyse source code for side effects).
splitChunks:
{false|OptimizationSplitChunksOptions} Optimize duplication and caching by splitting chunks by shared modules and cache group.
usedExports:
<boolean>Figure out which exports are used by modules to mangle export names, omit unused exports and generate more efficient code (true: analyse used exports for each runtime, "global": analyse exports globally for all runtimes combined).
Enables/Disables integrated optimizations.
Attributes
avoidEntryIife:
<boolean>Avoid wrapping the entry module in an IIFE.
checkWasmTypes:
<boolean>Check for incompatible wasm types when importing/exporting from/to ESM.
chunkIds:
{false|"size"|"natural"|"named"|"deterministic"|"total-size"} Define the algorithm to choose chunk ids (named: readable ids for better debugging, deterministic: numeric hash ids for better long term caching, size: numeric ids focused on minimal initial download size, total-size: numeric ids focused on minimal total download size, false: no algorithm used, as custom one can be provided via plugin).
concatenateModules:
<boolean>Concatenate modules when possible to generate less modules, more efficient code and enable more optimizations by the minimizer.
emitOnErrors:
<boolean>Emit assets even when errors occur. Critical errors are emitted into the generated code and will cause errors at runtime.
flagIncludedChunks:
<boolean>Also flag chunks as loaded which contain a subset of the modules.
innerGraph:
<boolean>Creates a module-internal dependency graph for top level symbols, exports and imports, to improve unused exports detection.
mangleExports:
<boolean>Rename exports when possible to generate shorter code (depends on optimization.usedExports and optimization.providedExports, true/"deterministic": generate short deterministic names optimized for caching, "size": generate the shortest possible names).
mangleWasmImports:
<boolean>Reduce size of WASM by changing imports to shorter strings.
mergeDuplicateChunks:
<boolean>Merge chunks which contain the same modules.
minimize:
<boolean>Enable minimizing the output. Uses optimization.minimizer.
minimizer:
<"...">
|
<WebpackPluginInstance>
|
<object[]>Minimizer(s) to use for minimizing the output.
moduleIds:
{false|"size"|"natural"|"named"|"deterministic"|"hashed"} Define the algorithm to choose module ids (natural: numeric ids in order of usage, named: readable ids for better debugging, hashed: (deprecated) short hashes as ids for better long term caching, deterministic: numeric hash ids for better long term caching, size: numeric ids focused on minimal initial download size, false: no algorithm used, as custom one can be provided via plugin).
nodeEnv:
<string>Set process.env.NODE_ENV to a specific value.
noEmitOnErrors:
<boolean>Avoid emitting assets when errors occur (deprecated: use 'emitOnErrors' instead).
portableRecords:
<boolean>Generate records with relative paths to be able to move the context folder.
providedExports:
<boolean>Figure out which exports are provided by modules to generate more efficient code.
realContentHash:
<boolean>Use real [contenthash] based on final content of the assets.
removeAvailableModules:
<boolean>Removes modules from chunks when these modules are already included in all parents.
removeEmptyChunks:
<boolean>Remove chunks which are empty.
runtimeChunk:
<object>Create an additional chunk which contains only the webpack runtime and chunk hash maps.
sideEffects:
<boolean>Skip over modules which contain no side effects when exports are not used (false: disabled, 'flag': only use manually placed side effects flag, true: also analyse source code for side effects).
splitChunks:
{false|OptimizationSplitChunksOptions} Optimize duplication and caching by splitting chunks by shared modules and cache group.
usedExports:
<boolean>Figure out which exports are used by modules to mangle export names, omit unused exports and generate more efficient code (true: analyse used exports for each runtime, "global": analyse exports globally for all runtimes combined).
Options object for describing behavior of a cache group selecting modules that should be cached together.
Attributes
automaticNameDelimiter:
<string>Sets the name delimiter for created chunks.
Select chunks for determining cache group content (defaults to "initial", "initial" and "all" requires adding these chunks to the HTML).
enforce:
<boolean>Ignore minimum size, minimum chunks and maximum requests and always create chunks for this cache group.
Size threshold at which splitting is enforced and other restrictions (minRemainingSize, maxAsyncRequests, maxInitialRequests) are ignored.
idHint:
<string>Sets the hint for chunk id.
maxAsyncRequests:
<number>Maximum number of requests which are accepted for on-demand loading.
maxInitialRequests:
<number>Maximum number of initial chunks which are accepted for an entry point.
minChunks:
<number>Minimum number of times a module has to be duplicated until it's considered for splitting.
Minimal size for the chunks the stay after moving the modules to a new chunk.
Give chunks for this cache group a name (chunks with equal name are merged).
priority:
<number>Priority of this cache group.
reuseExistingChunk:
<boolean>Try to reuse existing chunk (with name) when it has matching modules.
usedExports:
<boolean>Compare used exports when checking common modules. Modules will only be put in the same chunk when exports are equal.
Options object for splitting chunks into smaller chunks.
Attributes
automaticNameDelimiter:
<string>Sets the name delimiter for created chunks.
cacheGroups:
<object>Assign modules to a cache group (modules from different cache groups are tried to keep in separate chunks, default categories: 'default', 'defaultVendors').
Select chunks for determining shared modules (defaults to "async", "initial" and "all" requires adding these chunks to the HTML).
defaultSizeTypes:
<string[]>Sets the size types which are used when a number is used for sizes.
Size threshold at which splitting is enforced and other restrictions (minRemainingSize, maxAsyncRequests, maxInitialRequests) are ignored.
fallbackCacheGroup:
<object>Options for modules not selected by any other cache group.
hidePathInfo:
<boolean>Prevents exposing path info when creating names for parts splitted by maxSize.
maxAsyncRequests:
<number>Maximum number of requests which are accepted for on-demand loading.
maxInitialRequests:
<number>Maximum number of initial chunks which are accepted for an entry point.
minChunks:
<number>Minimum number of times a module has to be duplicated until it's considered for splitting.
Minimal size for the chunks the stay after moving the modules to a new chunk.
usedExports:
<boolean>Compare used exports when checking common modules. Modules will only be put in the same chunk when exports are equal.
Attributes
associatedObjectForCache:
<object>object for caching
content:
{DllReferencePluginOptionsContent} content
context:
<string>absolute context path to which lib ident is relative to
extensions:
<string[]>extensions
scope:
<string>scope
source:
<string>source
type:
{"object"|"require"} type
Options affecting the output of the compilation. output options tell webpack how to write the compiled files to disk.
Attributes
amdContainer:
<string>Add a container for define/require functions in the AMD module.
The filename of asset modules as relative path inside the 'output.path' directory.
asyncChunks:
<boolean>Enable/disable creating async chunks that are loaded on demand.
auxiliaryComment:
<string>Add a comment in the UMD wrapper.
charset:
<boolean>Add charset attribute for script tag.
Specifies the filename template of output files of non-initial chunks on disk. You must
not
specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
chunkFormat:
<string>The format of chunks (formats included by default are 'array-push' (web/WebWorker), 'commonjs' (node.js), 'module' (ESM), but others might be added by plugins).
chunkLoading:
<string>The method of loading chunks (methods included by default are 'jsonp' (web), 'import' (ESM), 'importScripts' (WebWorker), 'require' (sync node.js), 'async-node' (async node.js), but others might be added by plugins).
chunkLoadingGlobal:
<string>The global variable used by webpack for loading of chunks.
chunkLoadTimeout:
<number>Number of milliseconds before chunk request expires.
clean:
<boolean>Clean the output directory before emit.
compareBeforeEmit:
<boolean>Check if to be emitted file already exists and have the same content before writing to output filesystem.
crossOriginLoading:
{false|"anonymous"|"use-credentials"} This option enables cross-origin loading of chunks.
Specifies the filename template of non-initial output css files on disk. You must
not
specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
Specifies the filename template of output css files on disk. You must
not
specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
Similar to
output.devtoolModuleFilenameTemplate
, but used in the case of duplicate module identifiers.Filename template string of function for the sources array in a generated SourceMap.
devtoolNamespace:
<string>Module namespace to use when interpolating filename template string for the sources array in a generated SourceMap. Defaults to
output.library
if not set. It's useful for avoiding runtime collisions in sourcemaps from multiple webpack projects built as libraries.enabledChunkLoadingTypes:
<string[]>List of chunk loading types enabled for use by entry points.
enabledLibraryTypes:
<string[]>List of library types enabled for use by entry points.
enabledWasmLoadingTypes:
<string[]>List of wasm loading types enabled for use by entry points.
environment:
{Environment} The abilities of the environment where the webpack generated code should run.
Specifies the filename of output files on disk. You must
not
specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
globalObject:
<string>An expression which is used to address the global object/scope in runtime code.
hashDigest:
<string>Digest types used for the hash.
hashDigestLength:
<number>Number of chars which are used for the hash.
hashFunction:
<string>| [
/Hash.html) Algorithm used for generation the hash (see node.js crypto package).
<Hash>
](
hashSalt:
<string>Any string which is added to the hash to salt it.
hotUpdateChunkFilename:
<string>The filename of the Hot Update Chunks. They are inside the output.path directory.
hotUpdateGlobal:
<string>The global variable used by webpack for loading of hot update chunks.
hotUpdateMainFilename:
<string>The filename of the Hot Update Main File. It is inside the 'output.path' directory.
ignoreBrowserWarnings:
<boolean>Ignore warnings in the browser.
iife:
<boolean>Wrap javascript code into IIFE's to avoid leaking into global scope.
importFunctionName:
<string>The name of the native import() function (can be exchanged for a polyfill).
importMetaName:
<string>The name of the native import.meta object (can be exchanged for a polyfill).
library:
<string>
|
<string[]>
|
<LibraryOptions>Make the output files a library, exporting the exports of the entry point.
libraryExport:
<string>
|
<string[]>Specify which export should be exposed as library.
libraryTarget:
<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).
module:
<boolean>Output javascript files as module source type.
path:
<string>The output directory as
absolute path
(required).
pathinfo:
<boolean>Include comments with information about the modules.
The 'publicPath' specifies the public URL address of the output files when referenced in a browser.
scriptType:
{false|"module"|"text/javascript"} This option enables loading async chunks via a custom script type, such as script type="module".
sourceMapFilename:
<string>The filename of the SourceMaps for the JavaScript files. They are inside the 'output.path' directory.
sourcePrefix:
<string>Prefixes every line of the source in the bundle with this string.
strictModuleErrorHandling:
<boolean>Handles error in module loading correctly at a performance cost. This will handle module error compatible with the EcmaScript Modules spec.
strictModuleExceptionHandling:
<boolean>Handles exceptions in module loading correctly at a performance cost (Deprecated). This will handle module error compatible with the Node.js CommonJS way.
trustedTypes:
<string>
|
<TrustedTypes>Use a Trusted Types policy to create urls for chunks. 'output.uniqueName' is used a default policy name. Passing a string sets a custom policy name.
umdNamedDefine:
<boolean>If
output.libraryTarget
is set to umd and
output.library
is set, setting this to true will name the AMD module.uniqueName:
<string>A unique name of the webpack build to avoid multiple webpack runtimes to conflict when using globals.
wasmLoading:
<string>The method of loading WebAssembly Modules (methods included by default are 'fetch' (web/WebWorker), 'async-node' (node.js), but others might be added by plugins).
webassemblyModuleFilename:
<string>The filename of WebAssembly modules as relative path inside the 'output.path' directory.
workerChunkLoading:
<string>The method of loading chunks (methods included by default are 'jsonp' (web), 'import' (ESM), 'importScripts' (WebWorker), 'require' (sync node.js), 'async-node' (async node.js), but others might be added by plugins).
workerPublicPath:
<string>Worker public path. Much like the public path, this sets the location where the worker script file is intended to be found. If not set, webpack will use the publicPath. Don't set this option unless your worker scripts are located at a different path from your other script files.
workerWasmLoading:
<string>The method of loading WebAssembly Modules (methods included by default are 'fetch' (web/WebWorker), 'async-node' (node.js), but others might be added by plugins).
Normalized options affecting the output of the compilation. output options tell webpack how to write the compiled files to disk.
Attributes
The filename of asset modules as relative path inside the 'output.path' directory.
asyncChunks:
<boolean>Enable/disable creating async chunks that are loaded on demand.
charset:
<boolean>Add charset attribute for script tag.
Specifies the filename template of output files of non-initial chunks on disk. You must
not
specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
chunkFormat:
<string>The format of chunks (formats included by default are 'array-push' (web/WebWorker), 'commonjs' (node.js), 'module' (ESM), but others might be added by plugins).
chunkLoading:
<string>The method of loading chunks (methods included by default are 'jsonp' (web), 'import' (ESM), 'importScripts' (WebWorker), 'require' (sync node.js), 'async-node' (async node.js), but others might be added by plugins).
chunkLoadingGlobal:
<string>The global variable used by webpack for loading of chunks.
chunkLoadTimeout:
<number>Number of milliseconds before chunk request expires.
clean:
<boolean>Clean the output directory before emit.
compareBeforeEmit:
<boolean>Check if to be emitted file already exists and have the same content before writing to output filesystem.
crossOriginLoading:
{false|"anonymous"|"use-credentials"} This option enables cross-origin loading of chunks.
Specifies the filename template of non-initial output css files on disk. You must
not
specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
Specifies the filename template of output css files on disk. You must
not
specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
Similar to
output.devtoolModuleFilenameTemplate
, but used in the case of duplicate module identifiers.Filename template string of function for the sources array in a generated SourceMap.
devtoolNamespace:
<string>Module namespace to use when interpolating filename template string for the sources array in a generated SourceMap. Defaults to
output.library
if not set. It's useful for avoiding runtime collisions in sourcemaps from multiple webpack projects built as libraries.enabledChunkLoadingTypes:
<string[]>List of chunk loading types enabled for use by entry points.
enabledLibraryTypes:
<string[]>List of library types enabled for use by entry points.
enabledWasmLoadingTypes:
<string[]>List of wasm loading types enabled for use by entry points.
environment:
{Environment} The abilities of the environment where the webpack generated code should run.
Specifies the filename of output files on disk. You must
not
specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
globalObject:
<string>An expression which is used to address the global object/scope in runtime code.
hashDigest:
<string>Digest types used for the hash.
hashDigestLength:
<number>Number of chars which are used for the hash.
hashFunction:
<string>| [
/Hash.html) Algorithm used for generation the hash (see node.js crypto package).
<Hash>
](
hashSalt:
<string>Any string which is added to the hash to salt it.
hotUpdateChunkFilename:
<string>The filename of the Hot Update Chunks. They are inside the output.path directory.
hotUpdateGlobal:
<string>The global variable used by webpack for loading of hot update chunks.
hotUpdateMainFilename:
<string>The filename of the Hot Update Main File. It is inside the 'output.path' directory.
ignoreBrowserWarnings:
<boolean>Ignore warnings in the browser.
iife:
<boolean>Wrap javascript code into IIFE's to avoid leaking into global scope.
importFunctionName:
<string>The name of the native import() function (can be exchanged for a polyfill).
importMetaName:
<string>The name of the native import.meta object (can be exchanged for a polyfill).
library:
<LibraryOptions>Options for library.
module:
<boolean>Output javascript files as module source type.
path:
<string>The output directory as
absolute path
(required).
pathinfo:
<boolean>Include comments with information about the modules.
The 'publicPath' specifies the public URL address of the output files when referenced in a browser.
scriptType:
{false|"module"|"text/javascript"} This option enables loading async chunks via a custom script type, such as script type="module".
sourceMapFilename:
<string>The filename of the SourceMaps for the JavaScript files. They are inside the 'output.path' directory.
sourcePrefix:
<string>Prefixes every line of the source in the bundle with this string.
strictModuleErrorHandling:
<boolean>Handles error in module loading correctly at a performance cost. This will handle module error compatible with the EcmaScript Modules spec.
strictModuleExceptionHandling:
<boolean>Handles exceptions in module loading correctly at a performance cost (Deprecated). This will handle module error compatible with the Node.js CommonJS way.
trustedTypes:
<TrustedTypes>Use a Trusted Types policy to create urls for chunks.
uniqueName:
<string>A unique name of the webpack build to avoid multiple webpack runtimes to conflict when using globals.
wasmLoading:
<string>The method of loading WebAssembly Modules (methods included by default are 'fetch' (web/WebWorker), 'async-node' (node.js), but others might be added by plugins).
webassemblyModuleFilename:
<string>The filename of WebAssembly modules as relative path inside the 'output.path' directory.
workerChunkLoading:
<string>The method of loading chunks (methods included by default are 'jsonp' (web), 'import' (ESM), 'importScripts' (WebWorker), 'require' (sync node.js), 'async-node' (async node.js), but others might be added by plugins).
workerPublicPath:
<string>Worker public path. Much like the public path, this sets the location where the worker script file is intended to be found. If not set, webpack will use the publicPath. Don't set this option unless your worker scripts are located at a different path from your other script files.
workerWasmLoading:
<string>The method of loading WebAssembly Modules (methods included by default are 'fetch' (web/WebWorker), 'async-node' (node.js), but others might be added by plugins).
tArg{TArg}- Returns: {Comparator
}
Attributes
Attributes
ast{Program}comments{CommentJavascriptParser[]}semicolons{Set}
[index: {string}]<any>
Specify options for each parser.
[index: {string}]<object>
Attributes
compilation:
<Compilation>current:
<NormalModule>module:
<NormalModule>options:
{WebpackOptionsNormalizedWithDefaults}
source:
{string|Buffer
}
Configuration object for web performance recommendations.
Attributes
assetFilter:
<object>Filter function to select assets that are checked.
hints:
{false|"error"|"warning"} Sets the format of the hints: warnings, errors or nothing at all.
maxAssetSize:
<number>File size limit (in bytes) when exceeded, that webpack will provide performance hints.
maxEntrypointSize:
<number>Total size of an entry point (in bytes).
Attributes
electron platform, require of some electron built-in modules is available
Attributes
resolveToUnqualified:
<object>resolve to unqualified
Attributes
[index: {string}]<any>
Attributes
Attributes
Attributes
outputPath:
<string>Path to the output file e.g.
path.resolve(__dirname, 'profiling/events.json')
. Defaults to
events.json
.Options object for the ProgressPlugin.
Attributes
activeModules:
<boolean>Show active modules count and one active module in progress message.
dependencies:
<boolean>Show dependencies count in progress message.
dependenciesCount:
<number>Minimum dependencies count to start with. For better progress calculation. Default: 10000.
entries:
<boolean>Show entries count in progress message.
handler:
<object>Function that executes for every progress step.
modules:
<boolean>Show modules count in progress message.
modulesCount:
<number>Minimum modules count to start with. For better progress calculation. Default: 5000.
percentBy:
<null>Collect percent algorithm. By default it calculates by a median from modules, entries and dependencies percent.
Advanced configuration for modules that should be provided as shared modules to the share scope.
Attributes
eager:
<boolean>Include the provided module directly instead behind an async request. This allows to use this shared module in initial load too. All possible shared modules need to be eager too.
shareKey:
<string>Key in the share scope under which the shared modules should be stored.
shareScope:
<string>Share scope name.
version:
<string>Version of the provided module. Will replace lower matching versions, but not higher.
provides{Provides} Modules that should be provided as shared modules to the share scope. When provided, property name is used to match modules, otherwise this is automatically inferred from share key.shareScope<string>Share scope name used for all provided modules (defaults to 'default').
Modules that should be provided as shared modules to the share scope. Property names are used as share keys.
[index: {string}]<string>
Attributes
debugId:
<string>debug id
file:
<string>file
ignoreList:
<number[]>ignore list
mappings:
<string>mappings
names:
<string[]>names
sourceRoot:
<string>source root
sources:
<string[]>sources
sourcesContent:
<string[]>sources content
version:
<number>version
Attributes
Returns:
{void}
Attributes
Returns:
{void}
Attributes
Returns:
{void}
path{PathLikeFs}options<object>|<null>|<undefined>callback<object>- Returns: {void}
path{PathLikeFs}options<object>|<null>|<undefined>callback<object>- Returns: {void}
path{PathLikeFs}callback<object>- Returns: {void}
path{PathLikeFs}options<object>|<null>- Returns:
<string[]>
path{PathLikeFs}options<object>- Returns: {Buffer
[]}
path{PathLikeFs}options<object>- Returns: {Dirent
[]}
path{PathLikeFs}options<object>- Returns: {Dirent<Buffer
>[]}
path{PathLikeTypes}options<object>|<null>|<undefined>callback<object>- Returns: {void}
path{PathLikeTypes}options<object>|<null>|<undefined>callback<object>- Returns: {void}
path{PathLikeTypes}callback<object>- Returns: {void}
Attributes
import:
<boolean>use import?
Attributes
path{PathOrFileDescriptorFs}options<object>|<null>|<undefined>callback<object>- Returns: {void}
path{PathOrFileDescriptorFs}options<object>|<null>|<undefined>callback<object>- Returns: {void}
path{PathOrFileDescriptorFs}callback<object>- Returns: {void}
path{PathOrFileDescriptorTypes}options<object>|<null>|<undefined>callback<object>- Returns: {void}
path{PathOrFileDescriptorTypes}options<object>|<null>|<undefined>callback<object>- Returns: {void}
path{PathOrFileDescriptorTypes}callback<object>- Returns: {void}
path{PathLikeFs}options{EncodingOption}callback<object>- Returns: {void}
path{PathLikeFs}options{BufferEncodingOption}callback<object>- Returns: {void}
path{PathLikeFs}options{EncodingOption}callback<object>- Returns: {void}
path{PathLikeFs}callback<object>- Returns: {void}
path{PathLikeFs}options{EncodingOption}- Returns:
<string>
path{PathLikeFs}options{BufferEncodingOption}- Returns: {Buffer}
path{PathLikeFs}options{EncodingOption}- Returns: {string|Buffer
}
path{PathLikeTypes}options{EncodingOption}callback<object>- Returns: {void}
path{PathLikeTypes}options{BufferEncodingOption}callback<object>- Returns: {void}
path{PathLikeTypes}options{EncodingOption}callback<object>- Returns: {void}
path{PathLikeTypes}callback<object>- Returns: {void}
Attributes
hashDigest:
<string>the hash digest to use
hashFunction:
{HashFunction} the hash function to use
end{SourcePosition}index<number>start{SourcePosition}
path{PathLikeFs}options{EncodingOption}callback<object>- Returns: {void}
path{PathLikeFs}options{BufferEncodingOption}callback<object>- Returns: {void}
path{PathLikeFs}options{EncodingOption}callback<object>- Returns: {void}
path{PathLikeFs}callback<object>- Returns: {void}
path{PathLikeFs}options{EncodingOption}- Returns:
<string>
path{PathLikeFs}options{BufferEncodingOption}- Returns: {Buffer}
path{PathLikeFs}options{EncodingOption}- Returns: {string|Buffer
}
path{PathLikeTypes}options{EncodingOption}callback<object>- Returns: {void}
path{PathLikeTypes}options{BufferEncodingOption}callback<object>- Returns: {void}
path{PathLikeTypes}options{EncodingOption}callback<object>- Returns: {void}
path{PathLikeTypes}callback<object>- Returns: {void}
byName{Record<string, number>}bySource{Record<string, number>}usedIds<number[]>
byIdentifier{Record<string, number>}usedIds<number[]>
Attributes
canMangle:
<boolean>when false, referenced export can not be mangled, defaults to true
name:
<string[]>name of the referenced export
Advanced configuration for container locations from which modules should be resolved and loaded at runtime.
Attributes
external:
<string>
|
<string[]>Container locations from which modules should be resolved and loaded at runtime.
shareScope:
<string>The name of the share scope shared with this remote.
Container locations from which modules should be resolved and loaded at runtime. Property names are used as request scopes.
[index: {string}]<string>|<string[]>
Attributes
chunk:
<Chunk>the chunk
chunkGraph:
<ChunkGraph>the chunk graph
codeGenerationResults:
<CodeGenerationResults>results of code generation
hash:
<string>hash to be used for render call
moduleGraph:
<ModuleGraph>the module graph
runtimeTemplate:
[
/RuntimeTemplate.html) the runtime template
<RuntimeTemplate>
](
Attributes
chunk:
<Chunk>the chunk
chunkGraph:
<ChunkGraph>the chunk graph
codeGenerationResults:
<CodeGenerationResults>results of code generation
modules:
[
/CssModule.html) modules
<CssModule[]>
](
runtimeTemplate:
[
/RuntimeTemplate.html) the runtime template
<RuntimeTemplate>
](
undoPath:
<string>undo path to css file
uniqueName:
<string>the unique name
Attributes
chunk:
<Chunk>the chunk
chunkGraph:
<ChunkGraph>the chunk graph
codeGenerationResults:
<CodeGenerationResults>results of code generation
dependencyTemplates:
[
/DependencyTemplates.html) the dependency templates
<DependencyTemplates>
](
moduleGraph:
<ModuleGraph>the module graph
runtimeTemplate:
[
/RuntimeTemplate.html) the runtime template
<RuntimeTemplate>
](
strictMode:
<boolean>rendering in strict context
Attributes
Attributes
auxiliary:
<boolean>filenameTemplate:
<TemplatePath>hash:
<string>identifier:
<string>info:
<AssetInfo>pathOptions:
<PathData>render:
<object>[index: {string}]<string>|<string[]>
directories{Set} list of directories files{Set} list of files missing{Set} list of missing entries resolveDependencies{ResolveDependencies} dependencies of the resolvingresolveResults{Map<string, string|false|undefined>} stored resolve results
contextDependencies{WriteOnlySet} directories that was found on file system fileDependencies{WriteOnlySet} files that was found on file system log<object>log functionmissingDependencies{WriteOnlySet} dependencies that was not found on file system stack{Set} set of hooks' calls. For instance, resolve → parsedResolve → describedResolve,yield<object>yield result, if provided plugins can return several results
Attributes
Attributes
directories{Set} list of directories files{Set} list of files missing{Set} list of missing entries
platform{false|PlatformTargetProperties} - platform target properties
alias{AliasOption[]} aliasaliasFields{Set<string|string[]>} alias fieldscachePredicate<object>cache predicatecacheWithContext<boolean>cache with contextconditionNames{Set} A list of exports field condition names. descriptionFiles<string[]>description filesenforceExtension<boolean>enforce extensionexportsFields{Set<string|string[]>} exports fieldsextensionAlias{ExtensionAliasOption[]} extension aliasextensions{Set} extensions fallback{AliasOption[]} fallbackfileSystem<FileSystem>fileSystemfullySpecified<boolean>fully specifiedimportsFields{Set<string|string[]>} imports fieldsmainFields<object[]>main fieldsmainFiles{Set} main files modules<string>modulesplugins<Plugin[]>pluginspnpApi<null>pnp APIpreferAbsolute<boolean>prefer absolutepreferRelative<boolean>prefer relativeresolver<Resolver>resolverresolveToContext<boolean>resolve to contextrestrictions{Set<string|RegExp>} restrictionsroots{Set} roots symlinks<boolean>symlinkstsconfig<string>|<boolean>tsconfig file path or config objectunsafeCache{false|CacheTypes} unsafe cache
alias{AliasOption[]|AliasOptions} A list of module alias configurations or an object which maps key to valuealiasFields<string>A list of alias fields in description filescachePredicate<object>A function which decides whether a request should be cached or not. An object is passed with at leastpathandrequestproperties.cacheWithContext<boolean>Whether or not the unsafeCache should include request context as part of the cache key.conditionNames<string[]>A list of exports field condition names.descriptionFiles<string[]>A list of description files to read fromenforceExtension<boolean>Enforce that a extension from extensions must be usedexportsFields<string>A list of exports fields in description filesextensionAlias{ExtensionAliasOptions} An object which maps extension to extension aliasesextensions<string[]>A list of extensions which should be tried for filesfallback{AliasOption[]|AliasOptions} A list of module alias configurations or an object which maps key to value, applied only after modules optionfileSystem<FileSystem>The file system which should be usedfullySpecified<boolean>The request is already fully specified and no extensions or directories are resolved for itimportsFields<string>A list of imports fields in description filesmainFields<string>|<string[]>|<object[]>A list of main fields in description filesmainFiles<string[]>A list of main files in directoriesmodules<string>|<string[]>A list of directories to resolve modules from, can be absolute path or folder nameplugins<Plugin[]>A list of additional resolve plugins which should be appliedpnpApi<null>A PnP API that should be used - null is "never", undefined is "auto"preferAbsolute<boolean>Prefer to resolve server-relative urls as absolute paths before falling back to resolve in rootspreferRelative<boolean>Prefer to resolve module requests as relative requests before falling back to modulesresolver<Resolver>A prepared Resolver to which the plugins are attachedresolveToContext<boolean>Resolve to a context instead of a filerestrictions<string>|<RegExp[]>A list of resolve restrictionsroots<string[]>A list of root pathssymlinks<boolean>Resolve symlinks to their symlinked locationtsconfig<string>|<boolean>TypeScript config file path or config object with configFile and referencesunsafeCache<boolean>Use this cache object to unsafely cache the successful requestsuseSyncFileSystemCalls<boolean>Use only the sync constraints of the file system calls
direct{WeakMap<ResolveOptionsWithDependencyType, ResolverWithOptions>}stringified{Map<string, ResolverWithOptions>}
Attributes
Attributes
Attributes
Attributes
exec:
<object>execute the rule set
references:
{Map<string, RuleSetLoaderOptions>} map of references in the rule set (may grow over time)
Logic operators used in a condition matcher.
Attributes
Logic operators used in a condition matcher.
Attributes
Logical AND.
not:
<string>
|
<RegExp>
|
<RuleSetConditionAbsolute[]>
|
<object>Logical NOT.
Logical OR.
Attributes
chunkGraph:
<ChunkGraph>the chunk graph
codeGenerationResults:
<CodeGenerationResults>the code generation results
Attributes
buildDependencies:
<string[]>contextDependencies:
<string[]>fileDependencies:
<string[]>missingDependencies:
<string[]>Helper function for joining two ranges into a single range. This is useful when working with AST nodes, as it allows you to combine the ranges of child nodes to create the range of the parent node.
definitions{StackedMap<string, VariableInfo|ScopeInfo>}inShorthand<string>|<boolean>inTaggedTemplateTag<boolean>inTry<boolean>isAsmJs<boolean>isStrict<boolean>terminated{2|1}topLevelScope<boolean>
input{A}- Returns:
<null>|<undefined>
- {IteratorObject<T, undefined>}
Returns:
{void}
Returns:
{SetIterator
}
Advanced configuration for modules that should be shared in the share scope.
Attributes
eager:
<boolean>Include the provided and fallback module directly instead behind an async request. This allows to use this shared module in initial load too. All possible shared modules need to be eager too.
import:
<string>Provided module that should be provided to share scope. Also acts as fallback module if no shared module is found in share scope or version isn't valid. Defaults to the property name.
packageName:
<string>Package name to determine required version from description file. This is only needed when package name can't be automatically determined from request.
requiredVersion:
<string>Version requirement from module in share scope.
shareKey:
<string>Module is looked up under this key from the share scope.
shareScope:
<string>Share scope name.
singleton:
<boolean>Allow only a single version of the shared module in share scope (disabled by default).
strictVersion:
<boolean>Do not accept shared module if version is not valid (defaults to yes, if local fallback module is available and shared module is not a singleton, otherwise no, has no effect if there is no required version specified).
version:
<string>Version of the provided module. Will replace lower matching versions, but not higher.
Modules that should be shared in the share scope. Property names are used to match requested modules in this compilation. Relative requests are resolved, module requests are matched unresolved, absolute paths will match resolved requests. A trailing slash will match all requests with this prefix. In this case shareKey must also have a trailing slash.
[index: {string}]<string>
Options for shared modules.
shared{Shared} Modules that should be shared in the share scope. When provided, property names are used to match requested modules in this compilation.shareScope<string>Share scope name used for all shared modules (defaults to 'default').
Attributes
Options affecting how file system snapshots are created and validated.
Attributes
buildDependencies:
<object>Options for snapshotting build dependencies to determine if the whole cache need to be invalidated.
contextModule:
<object>Options for snapshotting the context module to determine if it needs to be built again.
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.
managedPaths:
<string>
|
<RegExp[]>List of paths that are managed by a package manager and can be trusted to not be modified otherwise.
module:
<object>Options for snapshotting dependencies of modules to determine if they need to be built again.
resolve:
<object>Options for snapshotting dependencies of request resolving to determine if requests need to be re-resolved.
resolveBuildDependencies:
<object>Options for snapshotting the resolving of build dependencies to determine if the build dependencies need to be re-resolved.
unmanagedPaths:
<string>
|
<RegExp[]>List of paths that are not managed by a package manager and the contents are subject to change.
a{T}b{T}- Returns:
<number>
Attributes
map:
<null>map
source:
{SourceValue} source
Attributes
Attributes
Appends the given value to the original asset. Usually the #sourceMappingURL comment. [url] is replaced with a URL to the source map file. false disables the appending.
columns:
<boolean>Indicates whether column mappings should be used (defaults to true).
debugIds:
<boolean>Emit debug IDs into source and SourceMap.
Exclude modules that match the given value from source map generation.
Generator string or function to create identifiers of modules for the 'sources' array in the SourceMap used only if 'moduleFilenameTemplate' would result in a conflict.
fileContext:
<string>Path prefix to which the [file] placeholder is relative to.
Defines the output filename of the SourceMap (will be inlined if no value is provided).
Decide whether to ignore source files that match the specified value in the SourceMap.
Include source maps for module paths that match the given value.
module:
<boolean>Indicates whether SourceMaps from loaders should be used (defaults to true).
Generator string or function to create identifiers of modules for the 'sources' array in the SourceMap.
namespace:
<string>Namespace prefix to allow multiple webpack roots in the devtools.
noSources:
<boolean>Omit the 'sourceContents' array from the SourceMap.
publicPath:
<string>Provide a custom public path for the SourceMapping comment.
sourceRoot:
<string>Provide a custom value for the 'sourceRoot' property in the SourceMap.
Attributes
Attributes
automaticNameDelimiter:
<string>chunksFilter:
<object>defaultSizeTypes:
<string[]>enforceSizeThreshold:
{SplitChunksSizes}
fallbackCacheGroup:
{FallbackCacheGroup}
getCacheGroups:
<object>getName:
<object>hidePathInfo:
<boolean>maxAsyncRequests:
<number>maxAsyncSize:
{SplitChunksSizes}
maxInitialRequests:
<number>maxInitialSize:
{SplitChunksSizes}
minChunks:
<number>minRemainingSize:
{SplitChunksSizes}
minSize:
{SplitChunksSizes}
minSizeReduction:
{SplitChunksSizes}
usedExports:
<boolean>[index: {string}]<number>
Attributes
Attributes
chunk:
<Chunk>the chunk
chunkGraph:
<ChunkGraph>the chunk graph
codeGenerationResults:
<CodeGenerationResults>results of code generation
dependencyTemplates:
[
/DependencyTemplates.html) the dependency templates
<DependencyTemplates>
](
inlined:
<boolean>inlined
inlinedInIIFE:
<boolean>the inlined entry module is wrapped in an IIFE
moduleGraph:
<ModuleGraph>the module graph
needExportsDeclaration:
<boolean>whether the top-level exports declaration needs to be generated
runtimeTemplate:
[
/RuntimeTemplate.html) the runtime template
<RuntimeTemplate>
](
strictMode:
<boolean>rendering in strict context
path{PathLikeFs}callback<object>- Returns: {void}
path{PathLikeFs}options<object>|<undefined>callback<object>- Returns: {void}
path{PathLikeFs}options<undefined>callback<object>- Returns: {void}
Attributes
bigint:
<boolean>extract{HookMap<SyncBailHook<Tuple<any, any, StatsFactoryContext>, void, UnsetAdditionalOptions>>}filter{HookMap<SyncBailHook<Tuple<any, StatsFactoryContext, number, number>, boolean|void, UnsetAdditionalOptions>>}filterResults{HookMap<SyncBailHook<Tuple<any, StatsFactoryContext, number, number>, boolean|void, UnsetAdditionalOptions>>}filterSorted{HookMap<SyncBailHook<Tuple<any, StatsFactoryContext, number, number>, boolean|void, UnsetAdditionalOptions>>}getItemFactory{HookMap<SyncBailHook<Tuple<any, StatsFactoryContext>, void|StatsFactory, UnsetAdditionalOptions>>}getItemName{HookMap<SyncBailHook<Tuple<any, StatsFactoryContext>, string|void, UnsetAdditionalOptions>>}groupResults{HookMap<SyncBailHook<Tuple<GroupConfig<any, any>[], StatsFactoryContext>, void, UnsetAdditionalOptions>>}merge{HookMap<SyncBailHook<Tuple<any[], StatsFactoryContext>, any, UnsetAdditionalOptions>>}result{HookMap<SyncBailHook<Tuple<any, StatsFactoryContext>, any, UnsetAdditionalOptions>>}sort{HookMap<SyncBailHook<Tuple<object[], StatsFactoryContext>, void, UnsetAdditionalOptions>>}sortResults{HookMap<SyncBailHook<Tuple<object[], StatsFactoryContext>, void, UnsetAdditionalOptions>>}
getItemName{HookMap<SyncBailHook<Tuple<any, StatsPrinterContext>, string|void, UnsetAdditionalOptions>>}print{HookMap<SyncBailHook<Tuple<any, StatsPrinterContext>, string|void|undefined, UnsetAdditionalOptions>>}printElements{HookMap<SyncBailHook<Tuple<PrintedElement[], StatsPrinterContext>, string|void|undefined, UnsetAdditionalOptions>>}printItems{HookMap<SyncBailHook<Tuple<string[], StatsPrinterContext>, string|undefined, UnsetAdditionalOptions>>}result{HookMap<SyncWaterfallHook<Tuple<string, StatsPrinterContext>, string, UnsetAdditionalOptions>>}sortElements{HookMap<SyncBailHook<Tuple<string[], StatsPrinterContext>, void, UnsetAdditionalOptions>>}sortItems{HookMap<SyncBailHook<Tuple<any[], StatsPrinterContext>, boolean|void, UnsetAdditionalOptions>>}
path{PathLikeFs}options<undefined>- Returns: {IStats}
path{PathLikeFs}options<object>- Returns:
<undefined>
path{PathLikeFs}options<object>- Returns:
<undefined>
path{PathLikeFs}options<object>- Returns: {IStats}
path{PathLikeFs}options<object>- Returns: {IBigIntStats}
path{PathLikeFs}options<object>- Returns: {IStats|IBigIntStats}
path{PathLikeFs}options{StatSyncOptions}- Returns:
<undefined>
Attributes
path{PathLikeTypes}callback<object>- Returns: {void}
path{PathLikeTypes}options<object>|<undefined>callback<object>- Returns: {void}
path{PathLikeTypes}options<undefined>callback<object>- Returns: {void}
Attributes
Attributes
Attributes
toString:
<object>Attributes
Attributes
data{Record<string, any>|TopLevelSymbol|HarmonySettings|ImportSettings|CommonJsImportSettings|CompatibilitySettings|HarmonySpecifierGuards}next{TagInfo}tag<symbol>
Attributes
Attributes
Attributes
Use a Trusted Types policy to create urls for chunks.
onPolicyCreationFailure{"continue"|"stop"} If the call totrustedTypes.createPolicy(...)fails -- e.g., due to the policy name missing from the CSPtrusted-typeslist, or it being a duplicate name, etc. -- controls whether to continue with loading in the hope thatrequire-trusted-types-for 'script'isn't enforced yet, versus fail immediately. Default behavior is 'stop'.policyName<string>The name of the Trusted Types policy created by webpack to serve bundle chunks.
Attributes
baseUrl:
<string>Override baseUrl from tsconfig.json. If provided, this value will be used instead of the baseUrl in the tsconfig file
configFile:
<string>A relative path to the tsconfig file based on cwd, or an absolute path of tsconfig file
references:
<string[]>References to other tsconfig files. 'auto' inherits from TypeScript config, or an array of relative/absolute paths
alias{AliasOption[]} tsconfig file datamodules<string[]>tsconfig file data
Attributes
Attributes
chunkGraph:
<ChunkGraph>runtime:
{RuntimeSpec}
runtimeTemplate:
[
/RuntimeTemplate.html)
<RuntimeTemplate>
](
Attributes
chunkGraph:
<ChunkGraph>module:
<NormalModule>the module
runtime:
{RuntimeSpec}
runtimeTemplate:
[
/RuntimeTemplate.html)
<RuntimeTemplate>
](
Attributes
[index: {string}]{Value[]}
A virtual module definition.
Attributes
[index: {string}]{VirtualModuleContent}
Options for building virtual resources.
Attributes
Attributes
close:
<object>closes the watcher and all underlying file watchers
getAggregatedChanges:
<object>get current aggregated changes that have not yet send to callback
getAggregatedRemovals:
<object>get current aggregated removals that have not yet send to callback
getContextTimeInfoEntries:
<object>get info about directories
getFileTimeInfoEntries:
<object>get info about files
getInfo:
<object>get info about timestamps and changes
pause:
<object>closes the watcher, but keeps underlying file watchers alive until the next watch call
changes{Set|null} get current aggregated changes that have not yet send to callback contextTimeInfoEntries{Map<string, "ignore"|EntryTypesIndex|OnlySafeTimeEntry|ExistenceOnlyTimeEntryTypesIndex|null>} get info about directoriesfileTimeInfoEntries{Map<string, "ignore"|EntryTypesIndex|OnlySafeTimeEntry|ExistenceOnlyTimeEntryTypesIndex|null>} get info about filesremovals{Set|null} get current aggregated removals that have not yet send to callback
Attributes
watch:
<object>Attributes
paths:
<string>
|
<RegExp[]>A list of RegExps or absolute paths to directories or files that should be ignored.
Options for the watcher.
Attributes
aggregateTimeout:
<number>Delay the rebuilt after the first change. Value is a time in ms.
followSymlinks:
<boolean>Resolve symlinks and watch symlink and real file. This is usually not needed as webpack already resolves symlinks ('resolve.symlinks').
ignored:
<string>
|
<RegExp>
|
<string[]>Ignore some files from watching (glob pattern or regexp).
stdin:
<boolean>Stop watching when stdin stream has ended.
Attributes
chunk:
<Chunk>the chunk
chunkGraph:
<ChunkGraph>the chunk graph
codeGenerationResults:
<CodeGenerationResults>results of code generation
dependencyTemplates:
[
/DependencyTemplates.html) the dependency templates
<DependencyTemplates>
](
moduleGraph:
<ModuleGraph>the module graph
runtimeTemplate:
[
/RuntimeTemplate.html) the runtime template
<RuntimeTemplate>
](
Attributes
devtool:
<string>
|
<object[]>Attributes
id:
<string>Returns:
<any>c{Record<string, ExecuteModuleObject>}i<object[]>
Attributes
Attributes
withOptions:
<object>create a resolver with additional/different options
file{PathOrFileDescriptorFs}data{string|ArrayBufferView} options{WriteFileOptions}callback<object>- Returns: {void}
file{PathOrFileDescriptorFs}data{string|ArrayBufferView} callback<object>- Returns: {void}
Attributes
add:
<object>Type:
<object>Attributes
resolveDependencies:
<object>resource:
<string>
|
<string[]>resourceFragment:
<string>resourceQuery:
<string>Type:
<string>
|
<string[]>Type:
<string>
|
<string[]>Type:
{NormalModuleLoaderContext
|LoaderRunnerLoaderContext
|LoaderPluginLoaderContext|HotModuleReplacementPluginLoaderContext}
Type:
{AssetInlineGeneratorOptions|AssetResourceGeneratorOptions}
Type:
<string>Type:
{ContextResolveData|ContextOptions}
Type:
{"ascii"|"utf8"|"utf-8"|"utf16le"|"utf-16le"|"ucs2"|"ucs-2"|"base64"|"base64url"|"latin1"|"binary"|"hex"}
Type:
<object>Type:
{KnownBuildInfo|Record<string, any>}
Type:
{KnownBuildMeta|Record<string, any>}
Type:
{SimpleCallExpression|NewExpression}
Type:
<undefined>Type:
<object>Attributes
Type:
{Omit<Map<string, any>, "get"|"set"|"has"|"delete">|CodeGenMapOverloads}
Type:
<any>Type:
{undefined|null|string|number|bigint|boolean|Function|RegExp|RuntimeValue|object|RecursiveArrayOrRecord<undefined|null|string|number|bigint|boolean|Function|RegExp|RuntimeValue>[]}
Type:
<undefined>
|
<null>
|
<string>
|
<number>
|
<bigint>
|
<boolean>
|
<Function>
|
<RegExp>Type:
<object>Attributes
Type:
<boolean>Type:
<string>Type:
{Item
|string|Item
[]}
Type:
<object>Attributes
request:
<string>Type:
{"weak"|"eager"|"lazy"|"lazy-once"|"sync"|"async-weak"}
Type:
{ContextOptions|ContextModuleOptionsExtras}
Type:
{KnownContext|Record<any, any>}
Type:
{Record<string, StatsChunkGroup>|StatsObject<V, F>[]|StatsObject<T, F>}
Type:
<object>Attributes
read:
<object>Type:
{KnownCreateStatsOptionsContext|Record<string, any>}
Type:
<object>Attributes
Type:
<undefined>
|
<string>Type:
{FunctionDeclaration|VariableDeclaration|ClassDeclaration}
Type:
{SyntheticDependencyLocation|RealDependencyLocation}
Attributes
context:
<string>Context of requests in the manifest (or content property) as absolute path.
extensions:
<string[]>Extensions used to resolve modules in the dll bundle (only used when using 'scope').
manifest:
<string>An object containing content and name or a string to the absolute path of the JSON manifest to be loaded upon compilation.
name:
<string>The name where the dll is exposed (external name, defaults to manifest.name).
scope:
<string>Prefix which is used for accessing the content of the dll.
sourceType:
{"var"|"assign"|"this"|"window"|"global"|"commonjs"|"commonjs2"|"commonjs-module"|"amd"|"amd-require"|"umd"|"umd2"|"jsonp"|"system"} How the dll is exposed (libraryTarget, defaults to manifest.type).
type:
{"object"|"require"} The way how the export of the dll bundle is used.
content{DllReferencePluginOptionsContent} The mappings from request to module info.context<string>Context of requests in the manifest (or content property) as absolute path.extensions<string[]>Extensions used to resolve modules in the dll bundle (only used when using 'scope').name<string>The name where the dll is exposed (external name).scope<string>Prefix which is used for accessing the content of the dll.sourceType{"var"|"assign"|"this"|"window"|"global"|"commonjs"|"commonjs2"|"commonjs-module"|"amd"|"amd-require"|"umd"|"umd2"|"jsonp"|"system"} How the dll is exposed (libraryTarget).type{"object"|"require"} The way how the export of the dll bundle is used.
Type:
{3|5|6|7|8|9|10|11|12|13|14|15|16|17|2015|2016|2017|2018|2019|2020|2021|2022|2023|2024|2025|2026|"latest"}
Type:
{EffectUse|EffectBasic}
Type:
{"use"|"use-pre"|"use-post"}
Type:
<undefined>
|
<null>Type:
<string>
|
<string[]>Type:
<string>
|
<EntryObject>
|
<string[]>Attributes
details:
<string>Type:
{"module"|"chunk"|"root-of-chunk"|"nested"}
Type:
{ExperimentsCommon|ExperimentsExtra}
Type:
{ExperimentsCommon|ExperimentsNormalizedExtra}
Type:
<string>| [
/VariableInfo.html)
<VariableInfo>
](
Type:
{"unused"|"missing"|"empty-star"|"reexport-dynamic-default"|"reexport-named-default"|"reexport-namespace-object"|"reexport-fake-namespace-object"|"reexport-undefined"|"normal-reexport"|"dynamic-reexport"}
Type:
{0|1|2|3}
Type:
{"namespace"|"default-only"|"default-with-named"|"dynamic"}
Type:
<string>Type:
{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}
Type:
<string>
|
<string[]>Type:
<object>electron{NonNullable<undefined|boolean>}electronMain{NonNullable<undefined|boolean>}electronPreload{NonNullable<undefined|boolean>}electronRenderer{NonNullable<undefined|boolean>}node{NonNullable<undefined|boolean>}nwjs{NonNullable<undefined|boolean>}web{NonNullable<undefined|boolean>}
Type:
{"import"|"var"|"module"|"assign"|"this"|"window"|"self"|"global"|"commonjs"|"commonjs2"|"commonjs-module"|"commonjs-static"|"amd"|"amd-require"|"umd"|"umd2"|"jsonp"|"system"|"promise"|"module-import"|"script"|"node-commonjs"|"asset"|"css-import"|"css-url"}
Type:
{T|FakeHookMarker}
Attributes
Attributes
entryOptions:
<EntryOptions>Attributes
circular:
<boolean>Type:
<string>| [
/Hash.html)
<Hash>
](
Type:
{IStatsBase
|object}
Attributes
Attributes
Attributes
checkResource:
<object>A filter function for resource and context.
Type:
{true|Tuple<string, string>[]}
Type:
<object>phase{"defer"}
Type:
{0|1|2}
Type:
<undefined>
|
<null>
|
<string>Type:
<object>appendOnly{NonNullable<undefined|boolean>}colors{NonNullable<undefined|boolean>}debug{NonNullable<undefined|string|boolean|RegExp|FilterItemTypes[]|object>}level{NonNullable<undefined|"none"|"verbose"|"error"|"warn"|"info"|"log">}stream<NodeJS.WritableStream>|<object>
Type:
{T|TOMBSTONE|UNDEFINED_MARKER}
Type:
<undefined>
|
<null>
|
<Module>Type:
{ParserStateBase|Record<string, any>|KnownJavascriptParserState}
Type:
{object|Partial
Type:
<string>
|
<string[]>Type:
<string>
|
<string[]>Type:
{"error"|"warn"|"info"|"log"|"debug"|"clear"|"profile"|"trace"|"group"|"groupCollapsed"|"groupEnd"|"profileEnd"|"time"|"status"}
Type:
<undefined>
|
<string>Type:
{KnownMeta|Record<symbol, string[]>|Record<string, any>}
Type:
{ConcatenatedModuleInfo|ExternalModuleInfo}
Type:
{false|NodeOptions}
Type:
<object>Type:
{KnownNormalizedStatsOptions|Omit<StatsOptions, "context"|"chunkGroups"|"requestShortener"|"chunksSort"|"modulesSort"|"chunkModulesSort"|"nestedModulesSort"|"assetsSort"|"ids"|"cachedAssets"|"groupAssetsByEmitStatus"|"groupAssetsByPath"|"groupAssetsByExtension"|"assetsSpace"|"excludeAssets"|"excludeModules"|"warningsFilter"|"cachedModules"|"orphanModules"|"dependentModules"|"runtimeModules"|"groupModulesByCacheStatus"|"groupModulesByLayer"|"groupModulesByAttributes"|"groupModulesByPath"|"groupModulesByExtension"|"groupModulesByType"|"entrypoints"|"chunkGroupAuxiliary"|"chunkGroupChildren"|"chunkGroupMaxAssets"|"modulesSpace"|"chunkModulesSpace"|"nestedModulesSpace"|"logging"|"loggingDebug"|"loggingTrace"|"_env">|Record<string, any>}
Type:
<object>avoidEntryIife{NonNullable<undefined|boolean>}checkWasmTypes{NonNullable<undefined|boolean>}chunkIds{NonNullable<undefined|false|"natural"|"named"|"deterministic"|"size"|"total-size">}concatenateModules{NonNullable<undefined|boolean>}emitOnErrors{NonNullable<undefined|boolean>}flagIncludedChunks{NonNullable<undefined|boolean>}innerGraph{NonNullable<undefined|boolean>}mangleExports{NonNullable<undefined|boolean|"deterministic"|"size">}mangleWasmImports{NonNullable<undefined|boolean>}mergeDuplicateChunks{NonNullable<undefined|boolean>}minimize{NonNullable<undefined|boolean>}minimizer<object>|<WebpackPluginInstance>|<"..."[]>moduleIds{NonNullable<undefined|false|"natural"|"named"|"deterministic"|"size"|"hashed">}nodeEnv{NonNullable<undefined|string|false>}portableRecords{NonNullable<undefined|boolean>}providedExports{NonNullable<undefined|boolean>}realContentHash{NonNullable<undefined|boolean>}removeAvailableModules{NonNullable<undefined|boolean>}removeEmptyChunks{NonNullable<undefined|boolean>}runtimeChunk{NonNullable<undefined|false|object>}sideEffects{NonNullable<undefined|boolean|"flag">}splitChunks{NonNullable<undefined|false|OptimizationSplitChunksOptions>}usedExports{NonNullable<undefined|boolean|"global">}
Type:
<object>assetModuleFilename{NonNullable<undefined|string|object>}asyncChunks{NonNullable<undefined|boolean>}charset{NonNullable<undefined|boolean>}chunkFilename{NonNullable<undefined|string|object>}chunkFormat{NonNullable<undefined|string|false>}chunkLoading{NonNullable<undefined|string|false>}chunkLoadingGlobal<string>chunkLoadTimeout<number>compareBeforeEmit{NonNullable<undefined|boolean>}crossOriginLoading{NonNullable<undefined|false|"anonymous"|"use-credentials">}cssChunkFilename{NonNullable<undefined|string|object>}cssFilename{NonNullable<undefined|string|object>}devtoolNamespace<string>environment{RecursiveNonNullable} filename{NonNullable<undefined|string|object>}globalObject<string>hashDigest<string>hashDigestLength<number>hashFunction{NonNullable<undefined|string|Hash>}hotUpdateChunkFilename<string>hotUpdateGlobal<string>hotUpdateMainFilename<string>iife{NonNullable<undefined|boolean>}importFunctionName<string>importMetaName<string>module{NonNullable<undefined|boolean>}path<string>pathinfo{NonNullable<undefined|boolean|"verbose">}publicPath{NonNullable<undefined|string|object>}scriptType{NonNullable<undefined|false|"module"|"text/javascript">}sourceMapFilename<string>strictModuleErrorHandling{NonNullable<undefined|boolean>}strictModuleExceptionHandling{NonNullable<undefined|boolean>}uniqueName<string>wasmLoading{NonNullable<undefined|string|false>}webassemblyModuleFilename<string>workerChunkLoading{NonNullable<undefined|string|false>}workerPublicPath<string>workerWasmLoading{NonNullable<undefined|string|false>}
Type:
<string>Type:
{Identifier|MemberExpression|ObjectPattern|ArrayPattern|RestElement|AssignmentPattern}
Type:
<undefined>
|
<null>
|
<object>
|
<object>Type:
{"unknown-argument"|"unexpected-non-array-in-path"|"unexpected-non-object-in-path"|"multiple-values-unexpected"|"invalid-value"}
Type:
<object>Type:
<string>Type:
<string>Type:
<object>Attributes
Type:
{KnownRecords|Record<string, KnownRecords[]>|Record<string, any>}
Type:
{object|RecursiveArrayOrRecord
[]|T}
Type:
<string>Type:
<ResolveOptions>
|
<object>Attributes
Type:
{BaseResolveRequest|Partial
}
Type:
<Resolver>Type:
<string>
|
<RegExp>
|
<object>
|
<RuleSetCondition[]>data{EffectData}- Returns:
<string>|<RuleSetUseFunction>|<object>|<undefined>|<null>|<string>|<RuleSetUseFunction>|<object[]>
Type:
{undefined|string|boolean|SortableSet
}
Type:
{undefined|string|SortableSet
}
Type:
{ServerImportHttp
|ServerImportHttps
}
Type:
<string>Type:
<undefined>
|
<string>
|
<boolean>
|
<string[]>Type:
{"string"|"number"|"boolean"}
Type:
<object>Attributes
buildDependencies:
<object>immutablePaths:
<string>
|
<RegExp[]>managedPaths:
<string>
|
<RegExp[]>module:
<object>resolve:
<object>resolveBuildDependencies:
<object>unmanagedPaths:
<string>
|
<RegExp[]>Type:
<string>Type:
{FunctionDeclaration|VariableDeclaration|ClassDeclaration|ExpressionStatement|BlockStatement|StaticBlock|EmptyStatement|DebuggerStatement|WithStatement|ReturnStatement|LabeledStatement|BreakStatement|ContinueStatement|IfStatement|SwitchStatement|ThrowStatement|TryStatement|WhileStatement|DoWhileStatement|ForStatement|ForInStatement|ForOfStatement}
Type:
{ImportDeclaration|ExportNamedDeclaration|ExportAllDeclaration|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|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}
Type:
{KnownStatsFactoryContext|Record<string, any>}
Type:
{KnownStatsPrinterColorFunctions|KnownStatsPrinterFormatters|KnownStatsPrinterContext|Record<string, any>}
Type:
<boolean>
|
<StatsOptions>Type:
<undefined>
|
<string>Type:
{KnownUnsafeCacheData|Record<string, any>}
Type:
<string>
|
<TopLevelSymbol>Type:
{0|1|2|3|4}
Type:
<string>
|
<string[]>Type:
{string|Set
}
Type:
{0|1|2|4}
Attributes
context:
<string>infrastructureLogging{InfrastructureLoggingNormalizedWithDefaults}
target{NonNullable<undefined|string|false|string[]>}
output{OutputNormalizedWithDefaults}
optimization{OptimizationNormalizedWithDefaults}
devtool{NonNullable<undefined|string|false|object[]>}
stats{NonNullable}
node{NonNullable}
profile{NonNullable<undefined|boolean>}
Attributes
parallelism:
<number>snapshot{SnapshotNormalizedWithDefaults}
externalsPresets{ExternalsPresetsNormalizedWithDefaults}
externalsType{NonNullable<undefined|"import"|"var"|"module"|"assign"|"this"|"window"|"self"|"global"|"commonjs"|"commonjs2"|"commonjs-module"|"commonjs-static"|"amd"|"amd-require"|"umd"|"umd2"|"jsonp"|"system"|"promise"|"module-import"|"script"|"node-commonjs"|"asset"|"css-import"|"css-url">}
watch{NonNullable<undefined|boolean>}
performance{NonNullable<undefined|false|PerformanceOptions>}
recordsInputPath{NonNullable<undefined|string|false>}
recordsOutputPath{NonNullable<undefined|string|false>}
dotenv{NonNullable<undefined|boolean|DotenvPluginOptions>}
Type:
<object>Attributes
Stability: 0Deprecated
Type:
<string>
|
<object[]>Type:
{boolean|SortableSet
|null}
Type:
<symbol>Type:
<symbol>Type:
<symbol>Type:
<symbol>- cache
- cli
- config
- container
- css
- debug
- dependencies
- electron
- esm
- experiments
- ids
- javascript
- library
- ModuleFilenameHelpers
- node
- OptimizationStages
- optimize
- prefetch
- runtime
- RuntimeGlobals
- sharing
- sources
- util
- wasm
- web
- webworker
- AsyncDependenciesBlock
- AutomaticPrefetchPlugin
- BannerPlugin
- Cache
- Chunk
- ChunkGraph
- ChunkGroup
- CleanPlugin
- CodeGenerationResults
- Compilation
- Compiler
- ConcatenationScope
- ContextExclusionPlugin
- ContextReplacementPlugin
- DefinePlugin
- DelegatedPlugin
- Dependency
- DllPlugin
- DllReferencePlugin
- DotenvPlugin
- DynamicEntryPlugin
- EntryOptionPlugin
- EntryPlugin
- Entrypoint
- EnvironmentPlugin
- EvalDevToolModulePlugin
- EvalSourceMapDevToolPlugin
- ExternalModule
- ExternalsPlugin
- Generator
- HotModuleReplacementPlugin
- HotUpdateChunk
- IgnorePlugin
- InitFragment
- JavascriptModulesPlugin
- LibManifestPlugin
- LibraryTemplatePlugin
- LoaderOptionsPlugin
- LoaderTargetPlugin
- ManifestPlugin
- Module
- ModuleFactory
- ModuleGraph
- ModuleGraphConnection
- MultiCompiler
- MultiStats
- NoEmitOnErrorsPlugin
- NormalModule
- NormalModuleReplacementPlugin
- Parser
- PlatformPlugin
- PrefetchPlugin
- ProgressPlugin
- ProvidePlugin
- Resolver
- RuntimeModule
- SourceMapDevToolPlugin
- Stats
- Template
- WatchIgnorePlugin
- Watching
- WebpackError
- WebpackOptionsApply
- WebpackOptionsDefaulter
Type:
{Readonly
webpack.validate(configuration): voidAttributes
configuration:
<Configuration>
|
<MultiConfiguration>Returns:
{void}
webpack.validateSchema(schema, options, validationConfiguration?): voidschema{Parameters} options{Parameters} validationConfiguration{ValidationErrorConfiguration}- Returns: {void}
Type:
<string>Type:
{_functionWebpack}
webpack(options, callback): voidAttributes
options:
<Configuration>options
callback:
{CallbackWebpackFunction_2<Stats, void>} callback
Returns:
<Compiler>
|
<null>Compiler or MultiCompiler
Attributes
options:
<Configuration>options
Returns:
<Compiler>Compiler or MultiCompiler
Attributes
options:
<MultiConfiguration>options
callback:
{CallbackWebpackFunction_2<MultiStats, void>} callback
Returns:
<MultiCompiler>
|
<null>Compiler or MultiCompiler
Attributes
options:
<MultiConfiguration>options
Returns:
<MultiCompiler>Compiler or MultiCompiler