These types are not exported by webpack, but they are available to TypeScript consumers.
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
assetInfo:
<AssetInfo>an asset info for asset modules
chunkInitFragments:
{InitFragment< any >[]} 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< object >} share-init for modules federation
topLevelDeclarations:
{Set< string >} top level declarations for javascript modules
url:
<object>url for css and javascript modules
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:
<TsconfigPathsMap>
|
<null>tsconfig paths map
Attributes
call{CallExpression}calleeName<string>getCalleeMembers<object>getMemberRanges<object>getMembers<object>getMembersOptionals<object>name<string>rootInfo<string>type{"call"}
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>the dependency templates
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>the runtime template
sourceTypes:
{ReadonlySet< string >} source types
Attributes
Attributes
a{T}b{T}- Returns: {-1|0|1}
declaration{CompatibilitySettingsDeclaration}name<string>
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>
Attributes
Attributes
resolved:
<ResolvedContextFileSystemInfoEntry>safeTime:
<number>symlinks:
{Set< string >}
timestampHash:
<string>Attributes
hash:
<string>resolved:
<ResolvedContextTimestampAndHash>safeTime:
<number>symlinks:
{Set< string >}
timestampHash:
<string>Attributes
esModule:
<boolean>whether export __esModule
exports:
{Map< string, string >} the css exports
definitions{SyncWaterfallHook< Tuple< Record< string, CodeValue > >, Record< string, CodeValue > >}
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
Returns:
{void}
The mappings from request to module info.
[index: {string}]<object>
An object containing content, name and type.
Attributes
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).
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.
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).
Attributes
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:
<LazyCompilationOptions>Compile entrypoints and import()s only when they are accessed.
Attributes
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>mapping from dependencies to templates
getData:
<object>get access to the code generation data
moduleGraph:
<ModuleGraph>the module graph
runtime:
<RuntimeSpec>the runtime
runtimeRequirements:
{Set< string >} the requirements for runtime
runtimeTemplate:
<RuntimeTemplate>the runtime template
type:
<string>which kind of code should be generated
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 >}
Attributes
expression:
<ImportExpressionJavascriptParser>references:
{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>[index: {string}]<string>|<string[]>
- {Iterator< T, TReturn, TNext >}.
<Disposable>
- {SetIterator}
Returns:
{void}
Returns:
{IteratorObject< T, TReturn, TNext >}
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< string >} using in NormalModule
cacheable:
<boolean>contextDependencies:
{LazySet< string >} using in NormalModule
cssData:
<CssData>for css modules
dataUrl:
<boolean>for assets modules
exportsArgument:
<string>using in AMD
fileDependencies:
{LazySet< string >} 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} for json modules
missingDependencies:
{LazySet< string >} 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>
|
<null>using in ContextModule
strict:
<boolean>topLevelDeclarations:
{Set< string >} top level declaration names
valueDependencies:
{Map< string, ValueCacheVersion >} using in NormalModule
Attributes
environments:
<string[]>environments
harmonyNamedExports{Set< string >}harmonyStarExports{HarmonyStarExportsList}lastHarmonyImportOrder<number>localModules<LocalModule[]>
aggressiveSplits{SplitData[]}chunkHashes<ChunkHashes>chunkModuleHashes<ChunkModuleHashes>chunkModuleIds<ChunkModuleIds>chunkRuntime<ChunkRuntime>chunks<RecordsChunks>fullHashChunkModuleHashes<FullHashChunkModuleHashes>hash<string>hotIndex<number>modules<RecordsModules>
Attributes
cachedGetErrors:
<object>cachedGetWarnings:
<object>compilation:
<Compilation>compilationAuxiliaryFileToChunks:
{Map< string, Chunk[] >}
compilationFileToChunks:
{Map< string, Chunk[] >}
makePathsRelative:
<object>rootModules:
{Set< Module >}
runtime:
<RuntimeSpec>type:
<string>Attributes
args:
<any[]>children:
<StatsLoggingEntry[]>message:
<string>time:
<number>trace:
<string[]>type:
<string>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>path{PathLikeFs}callback<object>- Returns: {void}
path{PathLikeFs}options<StatOptions>|<object>|<undefined>callback<object>- Returns: {void}
path{PathLikeFs}options<StatOptions>|<object>callback<object>- Returns: {void}
path{PathLikeFs}options<StatOptions>|<undefined>callback<object>- Returns: {void}
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
Attributes
file{PathLikeFs}options<MakeDirectoryOptions>|<object>callback<object>- Returns: {void}
file{PathLikeFs}options<string>|<number>|<MakeDirectoryOptions>|<object>|<null>|<undefined>callback<object>- Returns: {void}
file{PathLikeFs}options<string>|<number>|<MakeDirectoryOptions>|<null>|<undefined>callback<object>- Returns: {void}
file{PathLikeFs}callback<object>- Returns: {void}
Attributes
compilation:
<Compilation>fileSystemInfo:
{FileSystemInfo}
valueCacheVersions:
{Map< string, ValueCacheVersion >}
[index: {string}]<any>
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:
<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 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>
|
<LibraryCustomUmdCommentObject>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>
|
<CleanOptions>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.
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[]>
|
<LibraryCustomUmdObject>
|
<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).
Attributes
electron platform, require of some electron built-in modules is available
Attributes
resolveToUnqualified:
<object>resolve to unqualified
Attributes
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.
Attributes
Returns:
{void}
Attributes
Returns:
{void}
Attributes
Returns:
{void}
path{PathLikeFs}options<object>|<null>|<undefined>callback<object>- Returns: {void}
path{PathLikeFs}options<ObjectEncodingOptions>|<object>|<null>|<undefined>callback<object>- Returns: {void}
path{PathLikeFs}callback<object>- Returns: {void}
path{PathLikeFs}options<ObjectEncodingOptions>|<object>callback<object>- Returns: {void}
path{PathLikeTypes}options<object>|<null>|<undefined>callback<object>- Returns: {void}
path{PathLikeTypes}options<ObjectEncodingOptions>|<object>|<null>|<undefined>callback<object>- Returns: {void}
path{PathLikeTypes}callback<object>- Returns: {void}
path{PathLikeTypes}options<ObjectEncodingOptions>|<object>callback<object>- Returns: {void}
Attributes
Returns:
{void}
Attributes
Returns:
{void}
Attributes
options:
<ObjectEncodingOptions>
|
<object>
|
<null>
|
<undefined>callback:
<object>Returns:
{void}
Attributes
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{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}
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}
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[]>|<RemotesConfig>
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>the runtime template
[index: {string}]<string>|<string[]>
path{PathLikeFs}callback<object>- Returns: {void}
path{PathLikeFs}options<StatOptions>|<object>|<undefined>callback<object>- Returns: {void}
path{PathLikeFs}options<StatOptions>|<object>callback<object>- Returns: {void}
path{PathLikeFs}options<StatOptions>|<undefined>callback<object>- Returns: {void}
path{PathLikeTypes}callback<object>- Returns: {void}
path{PathLikeTypes}options<StatOptions>|<object>|<undefined>callback<object>- Returns: {void}
path{PathLikeTypes}options<StatOptions>|<object>callback<object>- Returns: {void}
path{PathLikeTypes}options<StatOptions>|<undefined>callback<object>- Returns: {void}
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
alias:
<AliasOption[]>tsconfig file data
modules:
<string[]>tsconfig file data
Attributes
allContexts:
<object>all contexts (main + refs) for quick lookup
fileDependencies:
{Set< string >} file dependencies
main:
<TsconfigPathsData>main tsconfig paths data
mainContext:
<string>main tsconfig base URL (absolute path)
refs:
<object>referenced tsconfig paths data mapped by baseUrl
Attributes
Attributes
Attributes
Returns:
{void}
Attributes
Returns:
{void}
Type:
<ContextOptions>
|
<object>Attributes
resolveDependencies:
<object>resource:
<string>
|
<string[]>resourceFragment:
<string>resourceQuery:
<string>Type:
{"ascii"|"utf8"|"utf-8"|"utf16le"|"utf-16le"|"ucs2"|"ucs-2"|"base64"|"base64url"|"latin1"|"binary"|"hex"}
Type:
<object>Type:
{KnownBuildMeta|Record< string, any >}
Type:
<undefined>Type:
<object>Attributes
Type:
<boolean>Type:
<string>
|
<ConsumesObject[]>
|
<ConsumesObject>Type:
{FunctionDeclaration|VariableDeclaration|ClassDeclaration}
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:
<null>
|
<string>
|
<number>
|
<boolean>
|
<EnumValueObject>
|
<EnumValue[]>Attributes
details:
<string>Type:
<ExperimentsCommon>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:
{T|FakeHookMarker}
Type:
<RawChunkGroupOptions>
|
<object>
|
<object>
|
<object>Attributes
Attributes
entryOptions:
<EntryOptions>Attributes
circular:
<boolean>Type:
<object>phase{"defer"}
Type:
{0|1|2}
Type:
{ParserStateBase|Record< string, any >|KnownJavascriptParserState}
Type:
{KnownMeta|Record< symbol, string[] >|Record< string, any >}
Type:
<object>Type:
{ParserStateBase|Record< string, any >}
Type:
{Identifier|MemberExpression|ObjectPattern|ArrayPattern|RestElement|AssignmentPattern}
Type:
{"unknown-argument"|"unexpected-non-array-in-path"|"unexpected-non-object-in-path"|"multiple-values-unexpected"|"invalid-value"}
Type:
{object|RecursiveArrayOrRecord< T >[]|T}
Type:
<string>
|
<RemotesObject[]>
|
<RemotesObject>Type:
<string>Type:
{"string"|"number"|"boolean"}
Attributes
buildDependencies:
<object>immutablePaths:
<string>
|
<RegExp[]>managedPaths:
<string>
|
<RegExp[]>module:
<object>resolve:
<object>resolveBuildDependencies:
<object>unmanagedPaths:
<string>
|
<RegExp[]>Type:
<string>Type:
<undefined>
|
<string>Type:
{0|1|2|3|4}