On this page

These types are not exported by webpack, but they are available to TypeScript consumers.

Returns compiler or MultiCompiler.

Attributes
callback:
{CallbackWebpackFunction_2< Stats, void >}
Returns:<Compiler> | <null>

Returns the compiler object.

Attributes
Returns:<Compiler>

Returns the compiler object.

Attributes
callback:
{CallbackWebpackFunction_2< MultiStats, void >}

Returns the multi compiler object.

Attributes

Returns the multi compiler object.



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
relativePath:<string>
relative path
tsconfigPathsMap:<TsconfigPathsMap> | <null>
tsconfig paths map

Attributes
range:
{Tuple< number, number >}
value:<string>


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
the runtimes code should be generated for
all runtimes code should be generated for
runtimeTemplate:<RuntimeTemplate>
the runtime template
sourceTypes:
{ReadonlySet< string >} source types

Attributes

Attributes

Attributes
range:
{Tuple< number, number >}
value:<string>

  • 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.


Attributes
context:<string>
request:<string>

Attributes
safeTime:<number>
symlinks:
{Set< string >}
timestampHash:<string>

Attributes
context:<string>
contextDependencies:
{LazySet< string >}
fileDependencies:
{LazySet< string >}
missingDependencies:
{LazySet< string >}
request:<string>
resolveOptions:<ResolveOptions>

Attributes
safeTime:<number>
symlinks:
{Set< string >}
timestampHash:<string>

  • 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
loc:
{SourceLocation}
pattern:
{Set< DestructuringAssignmentProperty >}
range:
{Tuple< number, number >}
shorthand:<string> | <boolean>

Returns location of targetPath relative to rootPath.

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

Attributes
Returns:
{void}

The mappings from request to module info.


Attributes
value:<any>

  • [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).

  • [index: {string}] <any>
Attributes
asyncWebAssembly:<boolean>
Support WebAssembly as asynchronous EcmaScript Module.
backCompat:<boolean>
Enable backward-compat layer with deprecation warnings for many webpack 4 APIs.
Build http(s): urls using a lockfile and resource content cache.
cacheUnaffected:<boolean>
Enable additional in memory caching of modules that are unchanged and reference only unchanged modules.
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.
futureDefaults:<boolean>
Apply defaults of next major version.
Enable experimental HTML support. This flag does not by itself make  .html files usable directly as entry points without additional HTML handling.
Compile entrypoints and import()s only when they are accessed.
outputModule:<boolean>
Allow output javascript files as module source type.
sourceImport:<boolean>
Enable experimental tc39 proposal  https://github.com/tc39/proposal-source-phase-imports . This allows importing modules at source phase.
syncWebAssembly:<boolean>
Support WebAssembly as synchronous EcmaScript Module (outdated).
typescript:<boolean>
Enable typescript support.

Attributes
canMangle:<boolean>
can the export be renamed (defaults to true)
when reexported: from which export
nested exports
when reexported: from which module
hidden:<boolean>
export is not visible, because another export blends over it
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< string >} when exports = true, list of unaffected exports
exported names, true for unknown exports or null for no exports
when reexported: from which module
hideExports:
{Set< string >|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

Returns location of targetPath relative to rootPath.

Attributes
close:<object>

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
the runtime
runtimeRequirements:
{Set< string >} the requirements for runtime
runtimeTemplate:<RuntimeTemplate>
the runtime template
which kind of code should be generated

Attributes
digest:<object>
get hash digest
update:<object>
make hash update

  • 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
references:
{string[][]}

Attributes
atime:<Date>
atime
atimeMs:
{T} atime ms
birthtime:<Date>
birthtime
birthtimeMs:
{T} birthtime ms
blksize:
{T} blksize
blocks:
{T} blocks
ctime:<Date>
ctime
ctimeMs:
{T} ctime ms
dev:
{T} dev
gid:
{T} gid
ino:
{T} ino
isBlockDevice:<object>
is block device
isCharacterDevice:<object>
is character device
isDirectory:<object>
is directory
isFIFO:<object>
is FIFO
isFile:<object>
is file
isSocket:<object>
is socket
isSymbolicLink:<object>
is symbolic link
mode:
{T} mode
mtime:<Date>
mtime
mtimeMs:
{T} mtime ms
nlink:
{T} nlink
rdev:
{T} rdev
size:
{T} size
uid:
{T} uid

Attributes
atime:<Date>
atime
atimeMs:<number>
atime ms
birthtime:<Date>
birthtime
birthtimeMs:<number>
birthtime ms
blksize:<number>
blksize
blocks:<number>
blocks
ctime:<Date>
ctime
ctimeMs:<number>
ctime ms
dev
gid
ino
isBlockDevice:<object>
is block device
isCharacterDevice:<object>
is character device
isDirectory:<object>
is directory
isFIFO:<object>
is FIFO
isFile:<object>
is file
isSocket:<object>
is socket
isSymbolicLink:<object>
is symbolic link
mode
mtime:<Date>
mtime
mtimeMs:<number>
mtime ms
nlink:<number>
nlink
rdev
size
uid


  • {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>
charset:<string>
for css modules (charset at-rule)
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
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

  • harmonyNamedExports {Set< string >}
  • harmonyStarExports {HarmonyStarExportsList}
  • lastHarmonyImportOrder <number>
  • localModules <LocalModule[]>

Checks whether this object is sorted.


Attributes
cachedGetErrors:<object>
cachedGetWarnings:<object>
compilation:<Compilation>
compilationAuxiliaryFileToChunks:
{Map< string, Chunk[] >}
compilationFileToChunks:
{Map< string, Chunk[] >}
makePathsRelative:<object>
rootModules:
{Set< Module >}

Returns array of values.

Attributes

Attributes
green:<object>
magenta:<object>
yellow:<object>

Attributes
chunkGroupKind:<string>
compilation:<StatsCompilation>
moduleIssuer:<StatsModuleIssuer>
moduleReason:<StatsModuleReason>
moduleTraceDependency:<StatsModuleTraceDependency>
moduleTraceItem:<StatsModuleTraceItem>

  • path {PathLikeFs}
  • 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
The path absolute URL (this indicates that the path is absolute from the server's root directory) to file.
The source path relative to the context.

Attributes

  • file {PathLikeFs}
  • callback <object>
  • Returns: {void}

Attributes
compilation:<Compilation>
fileSystemInfo:
{FileSystemInfo}
valueCacheVersions:
{Map< string, ValueCacheVersion >}

  • [index: {string}] <any>

Attributes

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.
assetModuleFilename:
{string|TemplatePathFn< PathDataModule >} 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.
Add a comment in the UMD wrapper.
charset:<boolean>
Add charset attribute for script tag.
chunkFilename:
{string|TemplatePathFn< PathDataChunk >} 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 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|"use-credentials"|"anonymous"} This option enables cross-origin loading of chunks.
cssChunkFilename:
{string|TemplatePathFn< PathDataChunk >} 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.
cssFilename:
{string|TemplatePathFn< PathDataChunk >} 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.
devtoolFallbackModuleFilenameTemplate:<string> | <object>
Similar to  output.devtoolModuleFilenameTemplate , but used in the case of duplicate module identifiers.
devtoolModuleFilenameTemplate:<string> | <object>
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.
filename:
{string|TemplatePathFn< PathDataChunk >} 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>
Algorithm used for generation the hash (see node.js crypto package).
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.
htmlChunkFilename:
{string|TemplatePathFn< PathDataChunk >} Specifies the filename template of non-initial output html 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.
htmlFilename:
{string|TemplatePathFn< PathDataChunk >} Specifies the filename template of output html 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.
ignoreBrowserWarnings:<boolean>
Ignore warnings in the browser.
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).
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.
The output directory as  absolute path (required).
pathinfo:<boolean>
Include comments with information about the modules.
publicPath:
{string|TemplatePathFn< PathData >} 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
compilation:<Compilation>
source:
{string|Buffer< ArrayBufferLike >}

Returns check if version is greater or equal.

Attributes
browser:<boolean> | <null>
browser platform, running in a normal web browser
electron:<boolean> | <null>
electron platform, require of some electron built-in modules is available
node platform, require of node built-in modules is available
nwjs platform, require of legacy nw.gui is available
web platform, importing of http(s) and std: is available
webworker:<boolean> | <null>
(Web)Worker platform, running in a web/shared/service worker

Attributes
resolveToUnqualified:<object>
resolve to unqualified

Attributes
column:<number>

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
buffer:
{TBuffer}
offset:<number>
length:<number>
position:<number> | <bigint> | <null>
callback:<object>
Returns:
{void}
Attributes
options:
{ReadAsyncOptions< TBuffer >}
callback:<object>
Returns:
{void}
Attributes
callback:<object>
Returns:
{void}

  • path {PathLikeFs}
  • callback <object>
  • Returns: {void}

Attributes
Returns:
{void}
Attributes
options:<object>
callback:<object>
Returns:
{void}
Attributes
Returns:
{void}
Attributes
Returns:
{void}
Attributes
options:<object>
callback:<object>
Returns:
{void}
Attributes
options:<object>
callback:<object>
Returns:
{void}

Attributes
Returns:
{void}
Attributes
Returns:
{void}
Attributes
Returns:
{void}
Attributes
Returns:
{void}

  • path {PathLikeFs}
  • options {BufferEncodingOption}
  • callback <object>
  • Returns: {void}
  • path {PathLikeFs}
  • callback <object>
  • Returns: {void}

Attributes
options:
{EncodingOptionTypes}
callback:<object>
Returns:
{void}
Attributes
options:
{BufferEncodingOption}
callback:<object>
Returns:
{void}
Attributes
options:
{EncodingOptionTypes}
callback:<object>
Returns:
{void}
Attributes
Returns:
{void}

  • path {PathLikeFs}
  • options {BufferEncodingOption}
  • 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 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.


Attributes
chunk:<Chunk>
the chunk
chunkGraph:<ChunkGraph>
the chunk graph
codeGenerationResults:<CodeGenerationResults>
results of code generation
hash to be used for render call
moduleGraph:<ModuleGraph>
the module graph
runtimeTemplate:<RuntimeTemplate>
the runtime template


  • path {PathLikeFs}
  • callback <object>
  • Returns: {void}

Returns location of targetPath relative to rootPath.

Attributes
bigint:<boolean>

Attributes
Returns:
{void}
Attributes
Returns:
{void}
Attributes
options:<object>
callback:<object>
Returns:
{void}
Attributes
Returns:
{void}

Attributes
deferred:<boolean>
export:<string[]>
module:<Module>

Use a Trusted Types policy to create urls for chunks.

  • onPolicyCreationFailure {"continue"|"stop"} If the call to trustedTypes.createPolicy(...) fails -- e.g., due to the policy name missing from the CSP trusted-types list, or it being a duplicate name, etc. -- controls whether to continue with loading in the hope that require-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.

  • alias {CompiledAliasOption[]} tsconfig file data
  • modules <string[]> tsconfig file data

Attributes
allContexts:<object>
all contexts (main + refs) for quick lookup
contextList:<string[]>
precomputed  Object.keys(allContexts) — read-only; used on the _selectPathsDataForContext hot path
fileDependencies:
{Set< string >} file dependencies
main tsconfig paths data
mainContext:<string>
main tsconfig base URL (absolute path)
referenced tsconfig paths data mapped by baseUrl

Attributes

Attributes
defs:<any[]>
identifiers:
{Identifier[]}
references:
{Reference[]}
scope:
{Scope}

Returns location of targetPath relative to rootPath.

  • changes {Set< string >|null} get current aggregated changes that have not yet send to callback
  • contextTimeInfoEntries {Map< string, "ignore"|EntryTypesIndex|OnlySafeTimeEntry|ExistenceOnlyTimeEntryTypesIndex|null >} get info about directories
  • fileTimeInfoEntries {Map< string, "ignore"|EntryTypesIndex|OnlySafeTimeEntry|ExistenceOnlyTimeEntryTypesIndex|null >} get info about files
  • removals {Set< string >|null} get current aggregated removals that have not yet send to callback

Attributes

Attributes
data:
{string|ArrayBufferView< ArrayBufferLike >}
callback:<object>
Returns:
{void}
Attributes
data:
{string|ArrayBufferView< ArrayBufferLike >}
callback:<object>
Returns:
{void}

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:
{KnownBuildMeta|Record< string, any >}


Attributes
loc:
{SourceLocation}
start:<number>




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:
{"use"|"use-pre"|"use-post"}


Attributes
details:<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:
{T|FakeHookMarker}

Attributes
Attributes
entryOptions:<EntryOptions>
Attributes
circular:<boolean>


Type:
{IStatsBaseTypes< bigint >|object}
Attributes
atimeNs:<bigint>
birthtimeNs:<bigint>
ctimeNs:<bigint>
mtimeNs:<bigint>

  • phase {"defer"|"source"}

Type:
{0|1|2}

Type:
{ParserStateBase|Record< string, any >|KnownJavascriptParserState}

Type:
{KnownMeta|Record< symbol, string[] >|Record< string, any >}


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"|"number"|"boolean"}

Attributes
buildDependencies:<object>
immutablePaths:<string> | <RegExp[]>
managedPaths:<string> | <RegExp[]>
module:<object>
resolve:<object>
resolveBuildDependencies:<object>
unmanagedPaths:<string> | <RegExp[]>



Type:
{0|1|2|3|4}