On this page

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>
  • {SchemaObject}
  • {AsyncSchema}
Attributes
$id:<string>
$schema:<string>
id:<string>
Attributes
signal:<AbortSignal>
  • {ListenOptions}
  • {ReadableOperatorOptions}
  • [<StreamOptions>](/Stream.html#interface-streamoptions)
  • [<FinishedOptions>](/Stream.html#interface-finishedoptions)
  • {PipelineOptions}
  • [<OnOptions>](/EventEmitter.html#interface-onoptions)
  • [<OnceOptions>](/EventEmitter.html#interface-onceoptions)
Attributes
signal:<AbortSignal>
Attributes
pluginName:<string>
name of the plugin
type:<string>
used library type
  • [index: {string}] <any>
Attributes
webpackAST:<object>
Attributes
address:<string>
family:<string>
port:<number>
Attributes
minSizeReduce:<number>
minimal size reduction to trigger merging
Attributes
chunkOverhead:<number>
Extra cost for each chunk (Default: 9.8kiB).
entryChunkMultiplicator:<number>
Extra cost multiplicator for entry chunks (Default: 10).
maxSize:<number>
Byte, max size of per file (Default: 50kiB).
minSize:<number>
Byte, split point. (Default: 30kiB).
  • {RsaHashedImportParams}
  • {EcKeyImportParams}
  • {HmacImportParams}
Attributes
name:<string>
  • [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 } share-init for modules federation
topLevelDeclarations:
{Set } top level declarations for javascript modules
url:<object>
url for css and javascript modules

Options for scope analysis.

Attributes
childVisitorKeys:<object> | <null>
Visitor key information for performance enhancement.
ecmaVersion:<number>
The ECMAScript version to use for evaluation (e.g.,  5 , 2015 , 2022 ).
fallback:<object>
Strategy to use when  childVisitorKeys is not specified.
ignoreEval:<boolean>
Whether to ignore  eval() calls, which normally create scopes.
impliedStrict:<boolean>
Whether to evaluate code in strict mode even outside modules or without  "use strict" .
jsx:<boolean>
Enables the tracking of JSX components as variable references.
nodejsScope:<boolean>
Whether to create a top-level function scope for CommonJS evaluation.
optimistic:<boolean>
Whether to enable optimistic scope analysis.
sourceType:
{"module"|"commonjs"|"script"} The type of JavaScript file to evaluate.
  • {Class}
Attributes
<Function>
Attributes
async:<boolean>
body:
{BlockStatement}
end:<number>
expression:<boolean>
generator:<boolean>
id:<null>
loc:<null>
params:
{Pattern[]}
range:
{Tuple<number, number>}
start:<number>
type:
{"FunctionDeclaration"}
Attributes
description:<string>
multiple:<boolean>
negatedDescription:<string>
path:<string>
type:
{"string"|"number"|"boolean"|"path"|"enum"|"RegExp"|"reset"}
values:
{EnumValue[]}
  • {BaseExpression}
Attributes
elements:<null[]>
leadingComments:<Comment[]>
loc:<null>
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:
{"ArrayExpression"}
Attributes
<Node>
Attributes
elements:<null[]>
end:<number>
loc:<null>
range:
{Tuple<number, number>}
start:<number>
type:
{"ArrayExpression"}
  • {IteratorObject<T, BuiltinIteratorReturn, unknown>}
Returns:
{void}
Returns:
{ArrayIterator }
Attributes
count:<number>
The number of values to drop.
Returns:
{IteratorObject<T, undefined, unknown>}

Creates an iterator whose values are the values from this iterator after skipping the provided count.

Attributes
predicate:<object>
A function that accepts up to two arguments. The every method calls the predicate function for each element in this iterator until the predicate returns false, or until the end of this iterator.
Returns:<boolean>

Determines whether all the members of this iterator satisfy the specified test.

Call Signature
Attributes
predicate:<object>
A function that accepts up to two arguments to be used to test values from the underlying iterator.
Returns:
{IteratorObject<S, undefined, unknown>}

Creates an iterator whose values are those from this iterator for which the provided predicate returns true.

Call Signature
Attributes
predicate:<object>
A function that accepts up to two arguments to be used to test values from the underlying iterator.
Returns:
{IteratorObject<T, undefined, unknown>}

Creates an iterator whose values are those from this iterator for which the provided predicate returns true.

Call Signature
Attributes
predicate:<object>
find calls predicate once for each element of this iterator, in order, until it finds one where predicate returns true. If such an element is found, find immediately returns that element value. Otherwise, find returns undefined.
Returns:<undefined>

Returns the value of the first element in this iterator where predicate is true, and undefined otherwise.

Call Signature
Attributes
predicate:<object>
Returns:<undefined>
Attributes
callback:<object>
A function that accepts up to two arguments to be used to transform values from the underlying iterator into new iterators or iterables to be flattened into the result.
Returns:
{IteratorObject<U, undefined, unknown>}

Creates an iterator whose values are the result of applying the callback to the values from this iterator and then flattening the resulting iterators or iterables.

Attributes
callbackfn:<object>
A function that accepts up to two arguments. forEach calls the callbackfn function one time for each element in the iterator.
Returns:
{void}

Performs the specified action for each element in the iterator.

Attributes
callbackfn:<object>
A function that accepts up to two arguments to be used to transform values from the underlying iterator.
Returns:
{IteratorObject<U, undefined, unknown>}

Creates an iterator whose values are the result of applying the callback to the values from this iterator.

  • __namedParameters {Tuple|Tuple}
  • Returns: {IteratorResult<T, undefined>}
Call Signature
Attributes
callbackfn:<object>
A function that accepts up to three arguments. The reduce method calls the callbackfn function one time for each element in the iterator.
Returns:
{T}

Calls the specified callback function for all the elements in this iterator. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

Call Signature
Attributes
callbackfn:<object>
initialValue:
{T}
Returns:
{T}
Call Signature
Attributes
callbackfn:<object>
A function that accepts up to three arguments. The reduce method calls the callbackfn function one time for each element in the iterator.
initialValue:
{U} If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of a value from the iterator.
Returns:
{U}

Calls the specified callback function for all the elements in this iterator. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

Attributes
value:<undefined>
Returns:
{IteratorResult<T, undefined>}
Attributes
predicate:<object>
A function that accepts up to two arguments. The some method calls the predicate function for each element in this iterator until the predicate returns a value true, or until the end of the iterator.
Returns:<boolean>

Determines whether the specified callback function returns true for any element of this iterator.

Attributes
limit:<number>
The maximum number of values to yield.
Returns:
{IteratorObject<T, undefined, unknown>}

Creates an iterator whose values are the values from this iterator, stopping once the provided limit is reached.

Attributes
e:<any>
Returns:
{IteratorResult<T, undefined>}
Returns:
{T[]}

Creates a new array from the values yielded by this iterator.

  • [n: {number}] {T}
Attributes
length:<number>
  • {BasePattern}
Attributes
elements:<null[]>
leadingComments:<Comment[]>
loc:<null>
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:
{"ArrayPattern"}
Attributes
<Node>
Attributes
elements:<null[]>
end:<number>
loc:<null>
range:
{Tuple<number, number>}
start:<number>
type:
{"ArrayPattern"}
  • {BaseExpression}.{BaseFunction}
Attributes
async:<boolean>
body:
{Expression|BlockStatement}
expression:<boolean>
generator:<boolean>
leadingComments:<Comment[]>
loc:<null>
params:
{Pattern[]}
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:
{"ArrowFunctionExpression"}
Attributes
<Function>
Attributes
async:<boolean>
body:
{Expression|BlockStatement}
end:<number>
expression:<boolean>
generator:<boolean>
id:<null>
loc:<null>
params:
{Pattern[]}
range:
{Tuple<number, number>}
start:<number>
type:
{"ArrowFunctionExpression"}
  • 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
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.
dataUrl:<object>
The options for data url generator.

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.
filename:<string> | <object>
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.
outputPath:<string> | <object>
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.
publicPath:<string> | <object>
The 'publicPath' specifies the public URL address of the output files when referenced in a browser.
  • {BaseExpression}
Attributes
leadingComments:<Comment[]>
left:
{Pattern}
loc:<null>
operator:
{AssignmentOperator}
range:
{Tuple<number, number>}
right:
{Expression}
trailingComments:<Comment[]>
type:
{"AssignmentExpression"}
Attributes
<Node>
Attributes
end:<number>
left:
{Pattern}
loc:<null>
operator:
{AssignmentOperator}
range:
{Tuple<number, number>}
right:
{Expression}
start:<number>
type:
{"AssignmentExpression"}
  • {BasePattern}
Attributes
leadingComments:<Comment[]>
left:
{Pattern}
loc:<null>
range:
{Tuple<number, number>}
right:
{Expression}
trailingComments:<Comment[]>
type:
{"AssignmentPattern"}
Attributes
<Node>
Attributes
end:<number>
left:
{Pattern}
loc:<null>
range:
{Tuple<number, number>}
right:
{Expression}
start:<number>
type:
{"AssignmentPattern"}
  • {Property}
Attributes
computed:<boolean>
key:
{Expression}
kind:
{"init"}
leadingComments:<Comment[]>
loc:<null>
method:<boolean>
range:
{Tuple<number, number>}
shorthand:<boolean>
trailingComments:<Comment[]>
type:
{"Property"}
value:
{Pattern}
Attributes
<Node>
Attributes
computed:<boolean>
end:<number>
key:
{Expression}
kind:
{"init"}
loc:<null>
method:
{false}
range:
{Tuple<number, number>}
shorthand:<boolean>
start:<number>
type:
{"Property"}
value:
{Pattern}
Attributes
divisorLength:<number>
Size of q in bits (DSA).
hashAlgorithm:<string>
Name of the message digest (RSA-PSS).
mgf1HashAlgorithm:<string>
Name of the message digest used by MGF1 (RSA-PSS).
modulusLength:<number>
Key size in bits (RSA, DSA).
namedCurve:<string>
Name of the curve (EC).
publicExponent:<bigint>
Public exponent (RSA).
saltLength:<number>
Minimal salt length in bytes (RSA-PSS).
Returns:
{AsyncIterator<T, TReturn, TNext>}

Describes a user-defined AsyncIterator that is also async iterable.

  • {AsyncIterator<T, TReturn, TNext>}
Returns:
{AsyncIterableIterator<T, TReturn, TNext>}
  • __namedParameters {Tuple|Tuple}
  • Returns: {Promise<IteratorResult<T, TReturn>>}
  • value {TReturn|PromiseLike}
  • Returns: {Promise<IteratorResult<T, TReturn>>}
Attributes
e:<any>
Returns:
{Promise<IteratorResult<T, TReturn>>}
  • {AsyncIterableIterator}
  • __namedParameters {Tuple|Tuple}
  • Returns: {Promise<IteratorResult<T, TReturn>>}
  • value {TReturn|PromiseLike}
  • Returns: {Promise<IteratorResult<T, TReturn>>}
Attributes
e:<any>
Returns:
{Promise<IteratorResult<T, TReturn>>}
  • [<EventEmitterAsyncResourceOptions>](/EventEmitter.html#interface-eventemitterasyncresourceoptions)
Attributes
requireManualDestroy:<boolean>
Disables automatic  emitDestroy when the object is garbage collected. This usually does not need to be set (even if emitDestroy is called manually), unless the resource's asyncId is retrieved and the sensitive API's emitDestroy is called with it.
triggerAsyncId:<number>
The ID of the execution context that created this async event.
  • {_SchemaObject}
Attributes
mangleImports:<boolean>
mangle imports
  • {BaseExpression}
  • argument {Expression}
  • leadingComments <Comment[]>
  • loc <null>
  • range {Tuple<number, number>}
  • trailingComments <Comment[]>
  • type {"AwaitExpression"}
Attributes
<Node>
  • argument {Expression}
  • end <number>
  • loc <null>
  • range {Tuple<number, number>}
  • start <number>
  • type {"AwaitExpression"}
Attributes
dispose:<object>
module:<object>
Attributes
banner:<string> | <object>
Specifies the banner.
entryOnly:<boolean>
If true, the banner will only be added to the entry chunks.
exclude:<string> | <RegExp> | <object>
Exclude all modules matching any of these conditions.
footer:<boolean>
If true, banner will be placed at the end of the output.
include:<string> | <RegExp> | <object>
Include all modules matching any of these conditions.
raw:<boolean>
If true, banner will not be wrapped in a comment.
stage:<number>
Specifies the stage when add a banner.
test:<string> | <RegExp> | <object>
Include all modules that pass test assertion.
  • {BaseExpression}
  • {SimpleCallExpression}
  • {NewExpression}
  • arguments {Expression|SpreadElement[]}
  • callee {Expression|Super}
  • leadingComments <Comment[]>
  • loc <null>
  • range {Tuple<number, number>}
  • trailingComments <Comment[]>
  • type <string>
  • {BaseNode}
  • {ClassExpression}
  • {MaybeNamedClassDeclaration}
  • {BaseStatement}
  • {MaybeNamedFunctionDeclaration}
  • {VariableDeclaration}
  • {MaybeNamedClassDeclaration}
Attributes
leadingComments:<Comment[]>
loc:<null>
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:<string>
  • {BaseNode}
  • {UnaryExpression}
  • {ImportExpression}
  • {ArrayExpression}
  • {ArrowFunctionExpression}
  • {AssignmentExpression}
  • {AwaitExpression}
  • {BinaryExpression}
  • {ChainExpression}
  • {ClassExpression}
  • {ConditionalExpression}
  • {FunctionExpression}
  • {Identifier}
  • {SimpleLiteral}
  • {RegExpLiteral}
  • {BigIntLiteral}
  • {LogicalExpression}
  • {MemberExpression}
  • {MetaProperty}
  • {ObjectExpression}
  • {SequenceExpression}
  • {TaggedTemplateExpression}
  • {TemplateLiteral}
  • {ThisExpression}
  • {UpdateExpression}
  • {YieldExpression}
  • {BaseCallExpression}
Attributes
leadingComments:<Comment[]>
loc:<null>
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:<string>
  • {BaseStatement}
  • {ForInStatement}
  • {ForOfStatement}
  • body {Statement}
  • leadingComments <Comment[]>
  • left {Pattern|VariableDeclaration}
  • loc <null>
  • range {Tuple<number, number>}
  • right {Expression}
  • trailingComments <Comment[]>
  • type <string>
  • {BaseNode}
  • {ArrowFunctionExpression}
  • {FunctionExpression}
  • {MaybeNamedFunctionDeclaration}
Attributes
async:<boolean>
body:
{Expression|BlockStatement}
generator:<boolean>
leadingComments:<Comment[]>
loc:<null>
params:
{Pattern[]}
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:<string>
  • {BaseNode}
  • {ImportDeclaration}
  • {ExportNamedDeclaration}
  • {ExportAllDeclaration}
  • {ExportDefaultDeclaration}
Attributes
leadingComments:<Comment[]>
loc:<null>
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:<string>
  • {BaseNode}
  • {ImportSpecifier}
  • {ImportDefaultSpecifier}
  • {ImportNamespaceSpecifier}
Attributes
leadingComments:<Comment[]>
loc:<null>
local:
{Identifier}
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:<string>
  • {BaseNodeWithoutComments}
  • {Identifier}
  • {SimpleLiteral}
  • {RegExpLiteral}
  • {BigIntLiteral}
  • {SpreadElement}
  • {PrivateIdentifier}
  • {Super}
  • {MethodDefinition}
  • {PropertyDefinition}
  • {VariableDeclarator}
  • {Program}
  • {SwitchCase}
  • {CatchClause}
  • {Property}
  • {Directive}
  • {BaseModuleDeclaration}
  • {ImportAttribute}
  • {BaseExpression}
  • {ClassBody}
  • {TemplateElement}
  • {BaseFunction}
  • {BaseClass}
  • {BasePattern}
  • {BaseStatement}
  • {JSXIdentifier}
  • {BaseModuleSpecifier}
Attributes
leadingComments:<Comment[]>
loc:<null>
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:<string>
Attributes
<Comment>
{BaseNode}
Attributes
loc:<null>
range:
{Tuple<number, number>}
type:<string>
  • {BaseNode}
  • {Identifier}
  • {MemberExpression}
  • {AssignmentPattern}
  • {ObjectPattern}
  • {ArrayPattern}
  • {RestElement}
Attributes
leadingComments:<Comment[]>
loc:<null>
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:<string>
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
  • {BaseNode}
  • {ExpressionStatement}
  • {BlockStatement}
  • {EmptyStatement}
  • {DebuggerStatement}
  • {WithStatement}
  • {ReturnStatement}
  • {LabeledStatement}
  • {BreakStatement}
  • {ContinueStatement}
  • {IfStatement}
  • {SwitchStatement}
  • {ThrowStatement}
  • {TryStatement}
  • {WhileStatement}
  • {DoWhileStatement}
  • {ForStatement}
  • {BaseDeclaration}
  • {BaseForXStatement}
Attributes
leadingComments:<Comment[]>
loc:<null>
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:<string>
  • {BaseNode}.{BaseExpression}
Attributes
bigint:<string>
leadingComments:<Comment[]>
loc:<null>
range:
{Tuple<number, number>}
raw:<string>
trailingComments:<Comment[]>
type:
{"Literal"}
value:<bigint> | <null>
  • {BaseExpression}
Attributes
leadingComments:<Comment[]>
left:
{Expression|PrivateIdentifier}
loc:<null>
operator:
{BinaryOperator}
range:
{Tuple<number, number>}
right:
{Expression}
trailingComments:<Comment[]>
type:
{"BinaryExpression"}
Attributes
<Node>
Attributes
end:<number>
left:
{Expression|PrivateIdentifier}
loc:<null>
operator:
{BinaryOperator}
range:
{Tuple<number, number>}
right:
{Expression}
start:<number>
type:
{"BinaryExpression"}
Attributes
size:<number>
type:<string>
Returns:
{Promise }
Returns:
{Promise }
Attributes
start:<number>
end:<number>
contentType:<string>
Returns:<Blob>
Returns:
{ReadableStream }
Returns:
{Promise }
  • endings {"native"|"transparent"}
  • type <string>
  • {BaseStatement}
Attributes
<Node>
  • body {Statement[]}
  • end <number>
  • loc <null>
  • range {Tuple<number, number>}
  • start <number>
  • type {"BlockStatement"}
Attributes
afterStartup:<string[]>
allowInlineStartup:<boolean>
beforeStartup:<string[]>
header:<string[]>
startup:<string[]>
  • {BaseStatement}
Attributes
label:<null>
leadingComments:<Comment[]>
loc:<null>
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:
{"BreakStatement"}
Attributes
<Node>
Attributes
end:<number>
label:<null>
loc:<null>
range:
{Tuple<number, number>}
start:<number>
type:
{"BreakStatement"}
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
bufferedMap:<null>
map:<null>
  • buffer {Buffer} buffer
  • hash {string|Buffer[]} hash
  • maps {Map<string, BufferEntry>} maps
  • size <number> size
  • source <boolean> source
Attributes
chunkGraph:<ChunkGraph>
moduleGraph:<ModuleGraph>
Attributes
automaticNameDelimiter:<string>
chunksFilter:<object>
enforce:<boolean>
enforceSizeThreshold:
{SplitChunksSizes}
filename:<string> | <object>
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>
Attributes
code:<boolean>
conditional:
{false|CalculatedStringResult[]}
range:
{Tuple<number, number>}
value:<string>
Attributes
err:<WebpackError> | <null>
result:<null>
Returns:
{void}
Attributes
err:<WebpackError> | <null>
result:
{T}
Returns:
{void}
Attributes
err:<Error> | <null>
result:<null>
Returns:
{void}
Attributes
err:<Error> | <null>
result:
{T}
Returns:
{void}
Attributes
err:<Error> | <null>
result:
{T}
Returns:
{void}
Attributes
err:<Error> | <null>
result:
{T}
Returns:
{R}
Attributes
<Node>
  • arguments {Expression|SpreadElement[]}
  • callee {Expression|Super}
  • end <number>
  • loc <null>
  • optional <boolean>
  • range {Tuple<number, number>}
  • start <number>
  • type {"CallExpression"}
Returns:<number> | <null>
Returns:<number> | <null>
Returns:<number> | <null>
Returns:<string> | <undefined>
Returns:<string> | <null>
Returns:<Function> | <undefined>
Returns:<string> | <null>
Returns:<number> | <null>
Returns:<string> | <null>
Returns:<number>
Returns:<number> | <null>
Returns:<string>
Returns:<string> | <null>
Returns:
{unknown}
Returns:<string> | <null>
Returns:<boolean>
Returns:<boolean>
Returns:<boolean>
Returns:<boolean>
Returns:<boolean>
Returns:<boolean>
  • {BaseNode}
Attributes
<Node>
  • {Dict<string|string[]>}
Attributes
C:<string> | <string[]>
Country code.
CN:<string> | <string[]>
Common name.
L:<string> | <string[]>
Locality.
O:<string> | <string[]>
Organization.
OU:<string> | <string[]>
Organizational unit.
ST:<string> | <string[]>
Street.
  • {BaseExpression}
  • expression {ChainElement}
  • leadingComments <Comment[]>
  • loc <null>
  • range {Tuple<number, number>}
  • trailingComments <Comment[]>
  • type {"ChainExpression"}
Attributes
<Node>
Attributes
end:<number>
expression:
{MemberExpression|CallExpression}
loc:<null>
range:
{Tuple<number, number>}
start:<number>
type:
{"ChainExpression"}
  • [index: {string}] {ChunkId[]}
  • [index: {string}] {ChunkChildIdsByOrdersMap}
Attributes
chunkGroup:<ChunkGroup>
name:<string>
Attributes
chunkGraph:<ChunkGraph>
the chunk graph
codeGenerationResults:<CodeGenerationResults>
results of code generation
moduleGraph:<ModuleGraph>
the module graph
runtimeTemplate:
[ <RuntimeTemplate> ]( /RuntimeTemplate.html) the runtime template
  • contentHash {Record<ChunkId, Record<string, string>>}
  • hash {Record<ChunkId, string>}
  • name {Record<ChunkId, string>}

  • [index: {number}] {IdToHashMap}

  • [index: {string}] {IdToHashMap}

  • [index: {number}] {ChunkId[]}

  • [index: {string}] {ChunkId[]}

  • [index: {number}] {ModuleId[]}

  • [index: {string}] {ModuleId[]}

Attributes
end:<number>
end id
name:<string>
the chunk name
order:
{"index"|"preOrderIndex"|"index2"|"postOrderIndex"} order
start:<number>
start id

  • [index: {number}] {ModuleId[]}

  • [index: {string}] {ModuleId[]}

  • hash {chunkModuleHashMap}
  • id {ChunkModuleIdMapEs5Alias_1}
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> ]( /RuntimeTemplate.html) the runtime template
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> ]( /DependencyTemplates.html) the dependency templates
moduleGraph:<ModuleGraph>
the module graph
runtimeTemplate:
[ <RuntimeTemplate> ]( /RuntimeTemplate.html) the runtime template
strictMode:<boolean>
rendering in strict context
Attributes
chunkOverhead:<number>
constant overhead for a chunk
entryChunkMultiplicator:<number>
multiplicator for initial chunks
Attributes
name:<string>
The cipher name.
standardName:<string>
IETF name for the cipher suite.
version:<string>
SSL/TLS protocol version.
Attributes
<Node>
  • {ClassExpression}
  • {ClassDeclaration}
  • {AnonymousClassDeclaration}
  • {BaseNode}
  • body {MethodDefinition|PropertyDefinition|StaticBlock[]}
  • leadingComments <Comment[]>
  • loc <null>
  • range {Tuple<number, number>}
  • trailingComments <Comment[]>
  • type {"ClassBody"}
Attributes
<Node>
  • body {MethodDefinition|PropertyDefinition|StaticBlock[]}
  • end <number>
  • loc <null>
  • range {Tuple<number, number>}
  • start <number>
  • type {"ClassBody"}
  • {MaybeNamedClassDeclaration}
  • body {ClassBody}
  • id {Identifier} It is null when a class declaration is a part of the export default class statement
  • leadingComments <Comment[]>
  • loc <null>
  • range {Tuple<number, number>}
  • superClass <null>
  • trailingComments <Comment[]>
  • type {"ClassDeclaration"}
  • {Class}
  • body {ClassBody}
  • end <number>
  • id {Identifier}
  • loc <null>
  • range {Tuple<number, number>}
  • start <number>
  • superClass <null>
  • type {"ClassDeclaration"}
  • {BaseClass}.{BaseExpression}
  • {Class}

Advanced options for cleaning assets.

Attributes
dry:<boolean>
Log the assets that should be removed instead of deleting them.
keep:<string> | <RegExp> | <object>
Keep these assets.
  • 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> ]( /DependencyTemplates.html) 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> ]( /RuntimeTemplate.html) the runtime template
sourceTypes:
{ReadonlySet } source types
Attributes
hash:<string>
module:<Module>
runtime:
{RuntimeSpec}
runtimes:
{RuntimeSpec[]}
  • data {CodeGenerationResultData} the resulting data for all source types
  • hash <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
delete:<object>
get:<object>
has:<object>
set:<object>
  • {BaseNodeWithoutComments}
Attributes
loc:<null>
range:
{Tuple<number, number>}
type:
{"Line"|"Block"}
value:<string>
Attributes
end:<number>
loc:
{SourceLocation}
range:
{Tuple<number, number>}
start:<number>
type:
{"Line"|"Block"}
value:<string>
Attributes
loc:<object>
range:
{Tuple<number, number>}
value:<string>
  • {TlsOptions}
  • {TLSSocketOptions}
  • ALPNProtocols {string[]|ArrayBufferView} An array of strings, or a single Buffer, TypedArray, or DataView containing the supported ALPN protocols. Buffers should have the format [len][name][len][name]... e.g. '\x08http/1.1\x08http/1.0', where the len byte is the length of the next protocol name. Passing an array is usually much simpler, e.g. ['http/1.1', 'http/1.0']. Protocols earlier in the list have higher preference than those later.
  • enableTrace <boolean> When enabled, TLS packet trace information is written to stderr. This can be used to debug TLS connection problems.
  • rejectUnauthorized <boolean> If true the server will reject any connection which is not authorized with the list of supplied CAs. This option only has an effect if requestCert is true.
  • requestCert <boolean> If true the server will request a certificate from clients that connect and attempt to verify that certificate. Defaults to false.
  • requestOCSP <boolean> If true, specifies that the OCSP status request extension will be added to the client hello and an 'OCSPResponse' event will be emitted on the socket before establishing a secure communication.
  • secureContext {SecureContext} An optional TLS context object from tls.createSecureContext()
  • SNICallback <object> SNICallback(servername, cb)  A function that will be called if the client supports SNI TLS extension. Two arguments will be passed when called: servername and cb. SNICallback should invoke cb(null, ctx), where ctx is a SecureContext instance. (tls.createSecureContext(...) can be used to get a proper SecureContext.) If SNICallback wasn't provided the default callback with high-level API will be used (see below).
Attributes
context:<string>
name:<string>
  • a {T}
  • b {T}
  • Returns: {-1|0|1}
  • declaration {CompatibilitySettingsDeclaration}
  • name <string>
  • loc {DependencyLocation}
  • range {Tuple<number, number>}
  • updated <boolean>
  • 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)
  • [n: {number}] {T}
Attributes
length:<number>
Attributes
separator:<string>
Returns:<string>
Attributes
start:<number>
end:<number>
Returns:
{T[]}
  • 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" namespace
  • interopNamespaceObject2Used <boolean> "default-only" namespace
  • interopNamespaceObjectName <string> "default-with-named" namespace
  • interopNamespaceObjectUsed <boolean> "default-with-named" namespace
  • module <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
  • {BaseExpression}
  • alternate {Expression}
  • consequent {Expression}
  • leadingComments <Comment[]>
  • loc <null>
  • range {Tuple<number, number>}
  • test {Expression}
  • trailingComments <Comment[]>
  • type {"ConditionalExpression"}
Attributes
<Node>
  • alternate {Expression}
  • consequent {Expression}
  • end <number>
  • loc <null>
  • range {Tuple<number, number>}
  • start <number>
  • test {Expression}
  • type {"ConditionalExpression"}
new Constructor(...params): any
Attributes
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.

  • 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 the output.path directory.
  • 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').
  • {Dict}
Attributes
context:<string>
request:<string>
  • resolved {ResolvedContextFileSystemInfoEntry}
  • safeTime <number>
  • symlinks {Set}
  • timestampHash <string>
Attributes
hash:<string>
resolved:<string>
symlinks:
{Set }
Attributes
resolveOptions:<ResolveOptions>
resource:<string> | <string[]>
resourceFragment:<string>
resourceQuery:<string>
Attributes
addon:<string>
attributes:
{Record<string, string>}
category:<string>
chunkName:<string> | <null>
exclude:<RegExp> | <null>
groupOptions:
{RawChunkGroupOptions}
include:<RegExp> | <null>
layer:<string> | <null>
mode:
{ContextMode}
namespaceObject:<boolean>
phase:
{0|2|1}
recursive:<boolean>
referencedExports:<null>
exports referenced from modules (won't be mangled)
regExp:<RegExp> | <null>
typePrefix:<string>
Attributes
context:<string>
contextDependencies:
{LazySet }
dependencies:
[ <ContextDependency[]> ]( /ContextDependency.html)
fileDependencies:
{LazySet }
missingDependencies:
{LazySet }
request:<string>
resolveOptions:<ResolveOptions>
Attributes
hash:<string>
resolved:
{ResolvedContextTimestampAndHash}
safeTime:<number>
symlinks:
{Set }
timestampHash:<string>
  • {BaseStatement}
Attributes
label:<null>
leadingComments:<Comment[]>
loc:<null>
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:
{"ContinueStatement"}
Attributes
<Node>
Attributes
end:<number>
label:<null>
loc:<null>
range:
{Tuple<number, number>}
start:<number>
type:
{"ContinueStatement"}
  • algorithm {KeyAlgorithm}
  • extractable <boolean>
  • type {KeyType}
  • usages {KeyUsage[]}
Attributes
esModule:<boolean>
whether export __esModule
exports:
{Map<string, string>} the css exports

Generator options for css modules.

Attributes
esModule:<boolean>
Configure the generated JS modules that use the ES modules syntax.
exportsOnly:<boolean>
Avoid generating and loading a stylesheet and only embed exports from css into output javascript files.
Attributes
layer:<string>
media:<string>
supports:<string>
  • 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> ]( /Hash.html) Algorithm used for generation the hash (see node.js crypto package).
localIdentHashSalt:<string>
Any string which is added to the hash to salt it.
localIdentName:<string> | <object>
Configure the generated local ident name.

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 @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.
  • {BaseStatement}
Attributes
leadingComments:<Comment[]>
loc:<null>
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:
{"DebuggerStatement"}
Attributes
<Node>
Attributes
end:<number>
loc:<null>
range:
{Tuple<number, number>}
start:<number>
type:
{"DebuggerStatement"}
  • definitions {SyncWaterfallHook<Tuple<Record<string, CodeValue>>, Record<string, CodeValue>>}
  • [index: {string}] {CodeValue}
Attributes
blocks:<AsyncDependenciesBlock[]>
dependencies:<Dependency[]>
new DependencyConstructor(...args): Dependency
Attributes
args:<any[]>
Returns:<Dependency>
Attributes
main:<number>
the main source order
sub:<number>
the sub source order
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> ]( /DependencyTemplates.html) the dependency templates
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> ]( /RuntimeTemplate.html) the runtime template

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
id:<string>
loc:
{SourceLocation}
pattern:
{Set }
range:
{Tuple<number, number>}
shorthand:<string> | <boolean>
  • {PeerCertificate}
Attributes
asn1Curve:<string>
The ASN.1 name of the OID of the elliptic curve. Well-known curves are identified by an OID. While it is unusual, it is possible that the curve is identified by its mathematical properties, in which case it will not have an OID.
bits:<number>
For RSA keys: The RSA bit size.

For EC keys: The key size in bits.

Attributes
ca:<boolean>
true if a Certificate Authority (CA), false otherwise.
exponent:<string>
The RSA exponent, as a string in hexadecimal number notation.
ext_key_usage:<string[]>
The extended key usage, a set of OIDs.
fingerprint:<string>
The SHA-1 digest of the DER encoded certificate. It is returned as a  : separated hexadecimal string.
fingerprint256:<string>
The SHA-256 digest of the DER encoded certificate. It is returned as a  : separated hexadecimal string.
fingerprint512:<string>
The SHA-512 digest of the DER encoded certificate. It is returned as a  : separated hexadecimal string.
infoAccess:
{Dict<string[]>} An array describing the AuthorityInfoAccess, used with OCSP.
issuer:
{Certificate} The certificate issuer, described in the same terms as the  subject .
issuerCertificate:
{DetailedPeerCertificate} The issuer certificate object. For self-signed certificates, this may be a circular reference.
modulus:<string>
The RSA modulus, as a hexadecimal string.
nistCurve:<string>
The NIST name for the elliptic curve, if it has one (not all well-known curves have been assigned names by NIST).
pubkey:
{NonSharedBuffer} The public key.
raw:
{NonSharedBuffer} The DER encoded X.509 certificate data.
serialNumber:<string>
The certificate serial number, as a hex string.
subject:
{Certificate} The certificate subject.
subjectaltname:<string>
A string containing concatenated names for the subject, an alternative to the  subject names.
valid_from:<string>
The date-time the certificate is valid from.
valid_to:<string>
The date-time the certificate is valid to.
Attributes
context:<string>
context for ids
maxLength:<number>
maximum length of ids
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
  • {Context}
  • {IncomingHttpHeaders}
  • {OutgoingHttpHeaders}
  • {Certificate}
  • {BaseNode}
Attributes
directive:<string>
expression:
{Literal}
leadingComments:<Comment[]>
loc:<null>
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:
{"ExpressionStatement"}
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}
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.

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'].
  • {BaseStatement}
  • body {Statement}
  • leadingComments <Comment[]>
  • loc <null>
  • range {Tuple<number, number>}
  • test {Expression}
  • trailingComments <Comment[]>
  • type {"DoWhileStatement"}
Attributes
<Node>
  • body {Statement}
  • end <number>
  • loc <null>
  • range {Tuple<number, number>}
  • start <number>
  • test {Expression}
  • type {"DoWhileStatement"}
Attributes
localAddress:<string>
localFamily:<string>
localPort:<number>
remoteAddress:<string>
remoteFamily:<string>
remotePort:<number>
  • {Algorithm}
Attributes
name:<string>
namedCurve:<string>
Attributes
type:<string>
value:<any>

No generator options are supported for this module type.

No parser options are supported for this module type.

  • {BaseStatement}
Attributes
leadingComments:<Comment[]>
loc:<null>
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:
{"EmptyStatement"}
Attributes
<Node>
Attributes
end:<number>
loc:<null>
range:
{Tuple<number, number>}
start:<number>
type:
{"EmptyStatement"}
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.
filename:<string> | <object>
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.
layer:<string> | <null>
Specifies the layer in which modules of this entrypoint are placed.
library:<LibraryOptions>
Options for library.
publicPath:<string> | <object>
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.
filename:<string> | <object>
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.
layer:<string> | <null>
Specifies the layer in which modules of this entrypoint are placed.
library:<LibraryOptions>
Options for library.
publicPath:<string> | <object>
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
accuracy:<number>
safeTime:<number>
timestamp:<number>
  • [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
name:<string>
The name property is available only when type is 'ECDH'.
size:<number>
The size of parameter of an ephemeral key exchange.
type:<string>
The supported types are 'DH' and 'ECDH'.
Attributes
<Error>
  • data {unknown}
  • instancePath <string>
  • keyword {K}
  • message <string>
  • params {P}
  • parentSchema {AnySchemaObject}
  • propertyName <string>
  • schema {S}
  • schemaPath <string>
Attributes
toString:<object>
Attributes
moduleFilenameTemplate:<string> | <object>
module filename template
namespace:<string>
namespace
sourceUrlComment:<string>
source url comment
Attributes
<ReadableStream>
<WritableStream>
[ <EventEmitter> ]( /EventEmitter-1.html)
Attributes
error:<Error>
event:<string> | <symbol>
args:<any[]>
Returns:
{void}

The Symbol.for('nodejs.rejection') method is called in case a promise rejection happens when emitting an event and captureRejections is enabled on the emitter. It is possible to use events.captureRejectionSymbol in place of Symbol.for('nodejs.rejection').

import { EventEmitter, captureRejectionSymbol } from 'node:events';

class MyClass extends EventEmitter {
  constructor() {
    super({ captureRejections: true });
  }

  [captureRejectionSymbol](err, event, ...args) {
    console.log('rejection happened for', event, 'with', err, ...args);
    this.destroy(err);
  }

  destroy(err) {
    // Tear the resource down here.
  }
}
JavaScript
  • eventName {IfEventMap<T, unknown|unknown|E>}
  • listener {IfEventMap<T, object>}
  • Returns: <this>

Alias for emitter.on(eventName, listener).

  • eventName {IfEventMap<T, unknown|unknown|E>}
  • args {IfEventMap<T, T|EventEmitterEventMap|any[]>}
  • Returns: <boolean>

Synchronously calls each of the listeners registered for the event named eventName, in the order they were registered, passing the supplied arguments to each.

Returns true if the event had listeners, false otherwise.

import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();

// First listener
myEmitter.on('event', function firstListener() {
  console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
  console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
  const parameters = args.join(', ');
  console.log(`event with parameters ${parameters} in third listener`);
});

console.log(myEmitter.listeners('event'));

myEmitter.emit('event', 1, 2, 3, 4, 5);

// Prints:
// [
//   [Function: firstListener],
//   [Function: secondListener],
//   [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener
JavaScript
Returns:<string> | <symbol[]>

Returns an array listing the events for which the emitter has registered listeners.

import { EventEmitter } from 'node:events';

const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});

const sym = Symbol('symbol');
myEE.on(sym, () => {});

console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]
JavaScript
Returns:<number>

Returns the current max listener value for the EventEmitter which is either set by emitter.setMaxListeners(n) or defaults to events.defaultMaxListeners.

  • eventName {IfEventMap<T, unknown|unknown|E>} The name of the event being listened for
  • listener {IfEventMap<T, object, object>} The event handler function
  • Returns: <number>

Returns the number of listeners listening for the event named eventName. If listener is provided, it will return how many times the listener is found in the list of the listeners of the event.

  • eventName {IfEventMap<T, unknown|unknown|E>}
  • Returns: {IfEventMap<T, object, object>[]}

Returns a copy of the array of listeners for the event named eventName.

server.on('connection', (stream) => {
  console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]
JavaScript
  • eventName {IfEventMap<T, unknown|unknown|E>}
  • listener {IfEventMap<T, object>}
  • Returns: <this>

Alias for emitter.removeListener().

  • eventName {IfEventMap<T, unknown|unknown|E>} The name of the event.
  • listener {IfEventMap<T, object>} The callback function
  • Returns: <this>

Adds the listener function to the end of the listeners array for the event named eventName. No checks are made to see if the listener has already been added. Multiple calls passing the same combination of eventName and listener will result in the listener being added, and called, multiple times.

server.on('connection', (stream) => {
  console.log('someone connected!');
});
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

By default, event listeners are invoked in the order they are added. The emitter.prependListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
JavaScript
  • eventName {IfEventMap<T, unknown|unknown|E>} The name of the event.
  • listener {IfEventMap<T, object>} The callback function
  • Returns: <this>

Adds a one-time listener function for the event named eventName. The next time eventName is triggered, this listener is removed and then invoked.

server.once('connection', (stream) => {
  console.log('Ah, we have our first user!');
});
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

By default, event listeners are invoked in the order they are added. The emitter.prependOnceListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
JavaScript
  • eventName {IfEventMap<T, unknown|unknown|E>} The name of the event.
  • listener {IfEventMap<T, object>} The callback function
  • Returns: <this>

Adds the listener function to the beginning of the listeners array for the event named eventName. No checks are made to see if the listener has already been added. Multiple calls passing the same combination of eventName and listener will result in the listener being added, and called, multiple times.

server.prependListener('connection', (stream) => {
  console.log('someone connected!');
});
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

  • eventName {IfEventMap<T, unknown|unknown|E>} The name of the event.
  • listener {IfEventMap<T, object>} The callback function
  • Returns: <this>

Adds a one-time listener function for the event named eventName to the beginning of the listeners array. The next time eventName is triggered, this listener is removed, and then invoked.

server.prependOnceListener('connection', (stream) => {
  console.log('Ah, we have our first user!');
});
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

  • eventName {IfEventMap<T, unknown|unknown|E>}
  • Returns: {IfEventMap<T, object, object>[]}

Returns a copy of the array of listeners for the event named eventName, including any wrappers (such as those created by .once()).

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));

// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];

// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();

// Logs "log once" to the console and removes the listener
logFnWrapper();

emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');

// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');
JavaScript
  • eventName {IfEventMap<T, unknown|unknown|E, string|symbol>}
  • Returns: <this>

Removes all listeners, or those of the specified eventName.

It is bad practice to remove listeners added elsewhere in the code, particularly when the EventEmitter instance was created by some other component or module (e.g. sockets or file streams).

Returns a reference to the EventEmitter, so that calls can be chained.

  • eventName {IfEventMap<T, unknown|unknown|E>}
  • listener {IfEventMap<T, object>}
  • Returns: <this>

Removes the specified listener from the listener array for the event named eventName.

const callback = (stream) => {
  console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);
JavaScript

removeListener() will remove, at most, one instance of a listener from the listener array. If any single listener has been added multiple times to the listener array for the specified eventName, then removeListener() must be called multiple times to remove each instance.

Once an event is emitted, all listeners attached to it at the time of emitting are called in order. This implies that any removeListener() or removeAllListeners() calls after emitting and before the last listener finishes execution will not remove them from emit() in progress. Subsequent events behave as expected.

import { EventEmitter } from 'node:events';
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();

const callbackA = () => {
  console.log('A');
  myEmitter.removeListener('event', callbackB);
};

const callbackB = () => {
  console.log('B');
};

myEmitter.on('event', callbackA);

myEmitter.on('event', callbackB);

// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
//   A
//   B

// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
//   A
JavaScript

Because listeners are managed using an internal array, calling this will change the position indexes of any listener registered after the listener being removed. This will not impact the order in which listeners are called, but it means that any copies of the listener array as returned by the emitter.listeners() method will need to be recreated.

When a single function has been added as a handler multiple times for a single event (as in the example below), removeListener() will remove the most recently added instance. In the example the once('ping') listener is removed:

import { EventEmitter } from 'node:events';
const ee = new EventEmitter();

function pong() {
  console.log('pong');
}

ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);

ee.emit('ping');
ee.emit('ping');
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

Attributes
n:<number>
Returns:<this>

By default EventEmitters will print a warning if more than 10 listeners are added for a particular event. This is a useful default that helps finding memory leaks. The emitter.setMaxListeners() method allows the limit to be modified for this specific EventEmitter instance. The value can be set to Infinity (or 0) to indicate an unlimited number of listeners.

Returns a reference to the EventEmitter, so that calls can be chained.

  • newListener {Tuple<eventName, listener>}
  • removeListener {Tuple<eventName, listener>}
  • [<EventEmitterAsyncResourceOptions>](/EventEmitter.html#interface-eventemitterasyncresourceoptions)
Attributes
captureRejections:<boolean>
It enables  automatic capturing of promise rejection .
  • codeGenerationResult {CodeGenerationResult}
  • module <Module>
  • moduleObject {ExecuteModuleObject}
  • __webpack_require__ {WebpackRequire}
  • assets {Map<string, object>}
  • chunk <Chunk>
  • chunkGraph <ChunkGraph>
Attributes
error:<Error>
error
exports:<any>
exports
id:<string>
module id
loaded:<boolean>
is loaded
Attributes
entryOptions:<EntryOptions>
  • assets {Map<string, object>}
  • buildDependencies {LazySet}
  • cacheable <boolean>
  • contextDependencies {LazySet}
  • exports <any>
  • fileDependencies {LazySet}
  • missingDependencies {LazySet}
Attributes
id:<string>
module id
module:
{ExecuteModuleObject} module
require:
{WebpackRequire} require function

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.
  • {BaseModuleDeclaration}
  • attributes {ImportAttribute[]}
  • exported <null>
  • leadingComments <Comment[]>
  • loc <null>
  • range {Tuple<number, number>}
  • source {Literal}
  • trailingComments <Comment[]>
  • type {"ExportAllDeclaration"}
Attributes
<Node>
  • attributes {ImportAttribute[]}
  • end <number>
  • exported <null>
  • loc <null>
  • range {Tuple<number, number>}
  • source {Literal}
  • start <number>
  • type {"ExportAllDeclaration"}
  • {BaseModuleDeclaration}
  • declaration {MaybeNamedClassDeclaration|Expression|MaybeNamedFunctionDeclaration}
  • leadingComments <Comment[]>
  • loc <null>
  • range {Tuple<number, number>}
  • trailingComments <Comment[]>
  • type {"ExportDefaultDeclaration"}
Attributes
<Node>
  • declaration {Expression|FunctionDeclaration|ClassDeclaration|AnonymousFunctionDeclaration|AnonymousClassDeclaration}
  • end <number>
  • loc <null>
  • range {Tuple<number, number>}
  • start <number>
  • type {"ExportDefaultDeclaration"}
  • {BaseModuleDeclaration}
  • attributes {ImportAttribute[]}
  • declaration <null>
  • leadingComments <Comment[]>
  • loc <null>
  • range {Tuple<number, number>}
  • source <null>
  • specifiers {ExportSpecifier[]}
  • trailingComments <Comment[]>
  • type {"ExportNamedDeclaration"}
Attributes
<Node>
  • attributes {ImportAttribute[]}
  • declaration <null>
  • end <number>
  • loc <null>
  • range {Tuple<number, number>}
  • source <null>
  • specifiers {ExportSpecifier[]}
  • start <number>
  • type {"ExportNamedDeclaration"}
Attributes
canMangle:<boolean>
can the export be renamed (defaults to true)
export:<string[]> | <null>
when reexported: from which export
exports:<string>
nested exports
from:<ModuleGraphConnection>
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

Construct a type with the properties of T except for those in type K.

  • {Omit<BaseModuleSpecifier, "local">}
  • exported {Identifier|Literal}
  • leadingComments <Comment[]>
  • loc <null>
  • local {Identifier|Literal}
  • range {Tuple<number, number>}
  • trailingComments <Comment[]>
  • type {"ExportSpecifier"}
Attributes
<Node>
Attributes
end:<number>
exported:
{Identifier|Literal}
loc:<null>
local:
{Identifier|Literal}
range:
{Tuple<number, number>}
start:<number>
type:
{"ExportSpecifier"}
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
exports:<string> | <null>
exported names, true for unknown exports or null for no exports
from:<ModuleGraphConnection>
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.

Attributes
getMemberRanges:<object>
getMembers:<object>
getMembersOptionals:<object>
name:<string>
rootInfo:<string>
| [ <VariableInfo> ]( /VariableInfo.html)
type:
{"expression"}
  • ArrayExpression {ArrayExpression}
  • ArrowFunctionExpression {ArrowFunctionExpression}
  • AssignmentExpression {AssignmentExpression}
  • AwaitExpression {AwaitExpression}
  • BinaryExpression {BinaryExpression}
  • CallExpression {CallExpression}
  • ChainExpression {ChainExpression}
  • ClassExpression {ClassExpression}
  • ConditionalExpression {ConditionalExpression}
  • FunctionExpression {FunctionExpression}
  • Identifier {Identifier}
  • ImportExpression {ImportExpression}
  • Literal {Literal}
  • LogicalExpression {LogicalExpression}
  • MemberExpression {MemberExpression}
  • MetaProperty {MetaProperty}
  • NewExpression {NewExpression}
  • ObjectExpression {ObjectExpression}
  • SequenceExpression {SequenceExpression}
  • TaggedTemplateExpression {TaggedTemplateExpression}
  • TemplateLiteral {TemplateLiteral}
  • ThisExpression {ThisExpression}
  • UnaryExpression {UnaryExpression}
  • UpdateExpression {UpdateExpression}
  • YieldExpression {YieldExpression}
  • {BaseStatement}
  • expression {Expression}
  • leadingComments <Comment[]>
  • loc <null>
  • range {Tuple<number, number>}
  • trailingComments <Comment[]>
  • type {"ExpressionStatement"}
Attributes
<Node>
Attributes
directive:<string>
end:<number>
expression:
{Expression}
loc:<null>
range:
{Tuple<number, number>}
start:<number>
type:
{"ExpressionStatement"}
Attributes
alias:<string> | <string[]>
extension:<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> ]( /ModuleProfile.html)
dependencies:<Dependency[]>
factory:<ModuleFactory>
factoryResult:<boolean>
return full ModuleFactoryResult instead of only module
originModule:<Module> | <null>
Attributes
sideEffectFree:<boolean>
Attributes
automaticNameDelimiter:<string>
chunksFilter:<object>
maxAsyncSize:
{SplitChunksSizes}
maxInitialSize:
{SplitChunksSizes}
minSize:
{SplitChunksSizes}
Attributes
mangleImports:<boolean>
mangle imports
  • lstat {LStatTypes} lstat method
  • readdir {ReaddirTypes} readdir method
  • readFile {ReadFileTypes} read file method
  • readJson <object> read json method
  • readlink {ReadlinkTypes} read link method
  • realpath {RealPathTypes} realpath method
  • stat {StatTypes} stat method
Attributes
safeTime:<number>
timestamp:<number>

A typed array of 16-bit float values. The contents are initialized to 0. If the requested number of bytes could not be allocated an exception is raised.

  • [toStringTag] {"Float16Array"}
  • buffer {TArrayBuffer} The ArrayBuffer instance referenced by the array.
  • byteLength <number> The length in bytes of the array.
  • byteOffset <number> The offset in bytes of the array.
  • BYTES_PER_ELEMENT <number> The size in bytes of each element in the array.
  • length <number> The length of the array.
Returns:
{ArrayIterator }
Attributes
index:<number>
The zero-based index of the desired code unit. A negative index will count back from the last item.
Returns:<number> | <undefined>

Returns the item located at the specified index.

Attributes
target:<number>
If target is negative, it is treated as length+target where length is the length of the array.
start:<number>
If start is negative, it is treated as length+start. If end is negative, it is treated as length+end.
end:<number>
If not specified, length of the this object is used as its default value.
Returns:<this>

Returns the this object after copying a section of the array identified by start and end to the same array starting at position target

Returns:
{ArrayIterator<Tuple<number, number>>}

Returns an array of key, value pairs for every entry in the array

Attributes
predicate:<object>
A function that accepts up to three arguments. The every method calls the predicate function for each element in the array until the predicate returns a value which is coercible to the Boolean value false, or until the end of the array.
thisArg:<any>
An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.
Returns:<boolean>

Determines whether all the members of an array satisfy the specified test.

Attributes
value:<number>
value to fill array section with
start:<number>
index to start filling the array at. If start is negative, it is treated as length+start where length is the length of the array.
end:<number>
index to stop filling the array at. If end is negative, it is treated as length+end.
Returns:<this>

Changes all array elements from start to end index to a static value and returns the modified array

Attributes
predicate:<object>
A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array.
thisArg:<any>
An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.
Returns:
{Float16Array }

Returns the elements of an array that meet the condition specified in a callback function.

Attributes
predicate:<object>
find calls predicate once for each element of the array, in ascending order, until it finds one where predicate returns true. If such an element is found, find immediately returns that element value. Otherwise, find returns undefined.
thisArg:<any>
If provided, it will be used as the this value for each invocation of predicate. If it is not provided, undefined is used instead.
Returns:<number> | <undefined>

Returns the value of the first element in the array where predicate is true, and undefined otherwise.

Attributes
predicate:<object>
find calls predicate once for each element of the array, in ascending order, until it finds one where predicate returns true. If such an element is found, findIndex immediately returns that element index. Otherwise, findIndex returns -1.
thisArg:<any>
If provided, it will be used as the this value for each invocation of predicate. If it is not provided, undefined is used instead.
Returns:<number>

Returns the index of the first element in the array where predicate is true, and -1 otherwise.

Call Signature
Attributes
predicate:<object>
findLast calls predicate once for each element of the array, in descending order, until it finds one where predicate returns true. If such an element is found, findLast immediately returns that element value. Otherwise, findLast returns undefined.
thisArg:<any>
If provided, it will be used as the this value for each invocation of predicate. If it is not provided, undefined is used instead.
Returns:<undefined>

Returns the value of the last element in the array where predicate is true, and undefined otherwise.

Call Signature
Attributes
predicate:<object>
thisArg:<any>
Returns:<number> | <undefined>
Attributes
predicate:<object>
findLastIndex calls predicate once for each element of the array, in descending order, until it finds one where predicate returns true. If such an element is found, findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1.
thisArg:<any>
If provided, it will be used as the this value for each invocation of predicate. If it is not provided, undefined is used instead.
Returns:<number>

Returns the index of the last element in the array where predicate is true, and -1 otherwise.

Attributes
callbackfn:<object>
A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array.
thisArg:<any>
An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
Returns:
{void}

Performs the specified action for each element in an array.

Attributes
searchElement:<number>
The element to search for.
fromIndex:<number>
The position in this array at which to begin searching for searchElement.
Returns:<boolean>

Determines whether an array includes a certain element, returning true or false as appropriate.

Attributes
searchElement:<number>
The value to locate in the array.
fromIndex:<number>
The array index at which to begin the search. If fromIndex is omitted, the search starts at index 0.
Returns:<number>

Returns the index of the first occurrence of a value in an array.

Attributes
separator:<string>
A string used to separate one element of an array from the next in the resulting String. If omitted, the array elements are separated with a comma.
Returns:<string>

Adds all the elements of an array separated by the specified separator string.

Returns:
{ArrayIterator }

Returns an list of keys in the array

Attributes
searchElement:<number>
The value to locate in the array.
fromIndex:<number>
The array index at which to begin the search. If fromIndex is omitted, the search starts at index 0.
Returns:<number>

Returns the index of the last occurrence of a value in an array.

Attributes
callbackfn:<object>
A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.
thisArg:<any>
An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
Returns:
{Float16Array }

Calls a defined callback function on each element of an array, and returns an array that contains the results.

Call Signature
Attributes
callbackfn:<object>
A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
Returns:<number>

Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

Call Signature
Attributes
callbackfn:<object>
initialValue:<number>
Returns:<number>
Call Signature
Attributes
callbackfn:<object>
A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
initialValue:
{U} If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
Returns:
{U}

Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

Call Signature
Attributes
callbackfn:<object>
A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.
Returns:<number>

Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

Call Signature
Attributes
callbackfn:<object>
initialValue:<number>
Returns:<number>
Call Signature
Attributes
callbackfn:<object>
A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.
initialValue:
{U} If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
Returns:
{U}

Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

Returns:<this>

Reverses the elements in an Array.

  • array {ArrayLike} A typed or untyped array of values to set.
  • offset <number> The index in the current array at which the values are to be written.
  • Returns: {void}

Sets a value or an array of values.

Attributes
start:<number>
The beginning of the specified portion of the array.
end:<number>
The end of the specified portion of the array. This is exclusive of the element at the index 'end'.
Returns:
{Float16Array }

Returns a section of an array.

Attributes
predicate:<object>
A function that accepts up to three arguments. The some method calls the predicate function for each element in the array until the predicate returns a value which is coercible to the Boolean value true, or until the end of the array.
thisArg:<any>
An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.
Returns:<boolean>

Determines whether the specified callback function returns true for any element of an array.

Attributes
compareFn:<object>
Function used to determine the order of the elements. It is expected to return a negative value if first argument is less than second argument, zero if they're equal and a positive value otherwise. If omitted, the elements are sorted in ascending order.
[11,2,22,1].sort((a, b) => a - b)
Returns:<this>

Sorts an array.

Attributes
begin:<number>
The index of the beginning of the array.
end:<number>
The index of the end of the array.
Returns:
{Float16Array }

Gets a new Float16Array view of the ArrayBuffer store for this array, referencing the elements at begin, inclusive, up to end, exclusive.

Attributes
locales:<string> | <string[]>
options:
{NumberFormatOptions}
Returns:<string>

Converts a number to a string by using the current locale.

Returns:
{Float16Array }

Copies the array and returns the copy with the elements in reverse order.

Attributes
compareFn:<object>
Function used to determine the order of the elements. It is expected to return a negative value if the first argument is less than the second argument, zero if they're equal, and a positive value otherwise. If omitted, the elements are sorted in ascending order.
const myNums = Float16Array.from([11.25, 2, -22.5, 1]);
myNums.toSorted((a, b) => a - b) // Float16Array(4) [-22.5, 1, 2, 11.5]
TypeScript
Returns:
{Float16Array }

Copies and sorts the array.

Returns:<string>

Returns a string representation of an array.

Returns:<this>

Returns the primitive value of the specified object.

Returns:
{ArrayIterator }

Returns an list of values in the array

Attributes
index:<number>
The index of the value to overwrite. If the index is negative, then it replaces from the end of the array.
value:<number>
The value to insert into the copied array.
Returns:
{Float16Array } A copy of the original array with the inserted value.

Copies the array and inserts the given number at the provided index.

new Float16ArrayConstructor(length?): Float16Array<ArrayBuffer>
Attributes
length:<number>
Returns:
{Float16Array }
new Float16ArrayConstructor(array): void
  • array {ArrayLike|Iterable<number, any, any>}
  • Returns: {Float16Array}
new Float16ArrayConstructor(buffer, byteOffset?, length?): void
  • buffer {TArrayBuffer}
  • byteOffset <number>
  • length <number>
  • Returns: {Float16Array}
new Float16ArrayConstructor(buffer, byteOffset?, length?): Float16Array<ArrayBuffer>
Attributes
buffer:<ArrayBuffer>
byteOffset:<number>
length:<number>
Returns:
{Float16Array }
new Float16ArrayConstructor(array): void
  • array {ArrayBuffer|ArrayLike}
  • Returns: {Float16Array}
Attributes
BYTES_PER_ELEMENT:<number>
The size in bytes of each element in the array.
prototype:
{Float16Array }
Call Signature
  • arrayLike {ArrayLike} An array-like object to convert to an array.
  • Returns: {Float16Array}

Creates an array from an array-like or iterable object.

Call Signature
  • arrayLike {ArrayLike} An array-like object to convert to an array.
  • mapfn <object> A mapping function to call on every element of the array.
  • thisArg <any> Value of 'this' used to invoke the mapfn.
  • Returns: {Float16Array}

Creates an array from an array-like or iterable object.

Call Signature
  • elements {Iterable} An iterable object to convert to an array.
  • Returns: {Float16Array}

Creates an array from an array-like or iterable object.

Call Signature
  • elements {Iterable} An iterable object to convert to an array.
  • mapfn <object> A mapping function to call on every element of the array.
  • thisArg <any> Value of 'this' used to invoke the mapfn.
  • Returns: {Float16Array}

Creates an array from an array-like or iterable object.

Attributes
items:<number[]>
A set of elements to include in the new array object.
Returns:
{Float16Array }

Returns a new array from a set of elements.

  • {BaseForXStatement}
  • body {Statement}
  • leadingComments <Comment[]>
  • left {Pattern|VariableDeclaration}
  • loc <null>
  • range {Tuple<number, number>}
  • right {Expression}
  • trailingComments <Comment[]>
  • type {"ForInStatement"}
Attributes
<Node>
  • body {Statement}
  • end <number>
  • left {VariableDeclaration|Pattern}
  • loc <null>
  • range {Tuple<number, number>}
  • right {Expression}
  • start <number>
  • type {"ForInStatement"}
  • {BaseForXStatement}
Attributes
await:<boolean>
body:
{Statement}
leadingComments:<Comment[]>
left:
{Pattern|VariableDeclaration}
loc:<null>
range:
{Tuple<number, number>}
right:
{Expression}
trailingComments:<Comment[]>
type:
{"ForOfStatement"}
Attributes
<Node>
Attributes
await:<boolean>
body:
{Statement}
end:<number>
left:
{VariableDeclaration|Pattern}
loc:<null>
range:
{Tuple<number, number>}
right:
{Expression}
start:<number>
type:
{"ForOfStatement"}
  • {BaseStatement}
Attributes
<Node>
Attributes
close:<object>
open:<object>
Attributes
<Node>
  • {FunctionExpression}
  • {ArrowFunctionExpression}
  • {FunctionDeclaration}
  • {AnonymousFunctionDeclaration}
Attributes
async:<boolean>
body:
{Expression|BlockStatement}
end:<number>
expression:<boolean>
generator:<boolean>
id:<null>
loc:<null>
params:
{Pattern[]}
range:
{Tuple<number, number>}
start:<number>
type:<string>
  • {MaybeNamedFunctionDeclaration}
Attributes
async:<boolean>
body:
{BlockStatement}
generator:<boolean>
id:
{Identifier} It is null when a function declaration is a part of the  export default function statement
leadingComments:<Comment[]>
loc:<null>
params:
{Pattern[]}
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:
{"FunctionDeclaration"}
Attributes
<Function>
Attributes
async:<boolean>
body:
{BlockStatement}
end:<number>
expression:<boolean>
generator:<boolean>
id:
{Identifier}
loc:<null>
params:
{Pattern[]}
range:
{Tuple<number, number>}
start:<number>
type:
{"FunctionDeclaration"}
  • {BaseFunction}.{BaseExpression}
Attributes
async:<boolean>
body:
{BlockStatement}
generator:<boolean>
id:<null>
leadingComments:<Comment[]>
loc:<null>
params:
{Pattern[]}
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:
{"FunctionExpression"}
Attributes
<Function>
Attributes
async:<boolean>
body:
{BlockStatement}
end:<number>
expression:<boolean>
generator:<boolean>
id:<null>
loc:<null>
params:
{Pattern[]}
range:
{Tuple<number, number>}
start:<number>
type:
{"FunctionExpression"}
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> ]( /DependencyTemplates.html) 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 } the requirements for runtime
runtimeTemplate:
[ <RuntimeTemplate> ]( /RuntimeTemplate.html) the runtime template
type:<string>
which kind of code should be generated
Attributes
generatedColumn:<number>
generated column
generatedLine:<number>
generated line
source:<string>
source
  • [index: {string}] <any>

Specify options for each generator.

  • result {T}
  • callback <object>
  • Returns: {void}
Attributes
createGroup:<object>
getKeys:<object>
getOptions:<object>
Attributes
force:<boolean>
groupChildren:<boolean>
targetGroupCount:<number>
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>
originModule:<Module> | <null>
recursive:<boolean>
recurse into dependencies of the created module
  • 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> ]( /Hash.html) The hashing algorithm to use, defaults to 'md4'. All functions from Node.JS' crypto.createHash are supported.
Attributes
digest:<object>
get hash digest
update:<object>
make hash update
  • {Algorithm}
  • 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
call:<object>
done:<object>
error:<object>
loop:<object>
name:<string>
register:<object>
result:<object>
tap:<object>
Attributes
factory:<object>

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.
  • {BaseNode}.{BaseExpression}.{BasePattern}
Attributes
leadingComments:<Comment[]>
loc:<null>
name:<string>
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:
{"Identifier"}
Attributes
<Node>
Attributes
end:<number>
loc:<null>
name:<string>
range:
{Tuple<number, number>}
start:<number>
type:
{"Identifier"}
  • {BaseStatement}
Attributes
alternate:<null>
consequent:
{Statement}
leadingComments:<Comment[]>
loc:<null>
range:
{Tuple<number, number>}
test:
{Expression}
trailingComments:<Comment[]>
type:
{"IfStatement"}
Attributes
<Node>
Attributes
alternate:<null>
consequent:
{Statement}
end:<number>
loc:<null>
range:
{Tuple<number, number>}
start:<number>
test:
{Expression}
type:
{"IfStatement"}
  • {BaseNode}
  • key {Identifier|Literal}
  • leadingComments <Comment[]>
  • loc <null>
  • range {Tuple<number, number>}
  • trailingComments <Comment[]>
  • type {"ImportAttribute"}
  • value {Literal}
Attributes
<Node>
Attributes
end:<number>
key:
{Identifier|Literal}
loc:<null>
range:
{Tuple<number, number>}
start:<number>
type:
{"ImportAttribute"}
value:
{Literal}
  • {BaseModuleDeclaration}
  • attributes {ImportAttribute[]}
  • leadingComments <Comment[]>
  • loc <null>
  • range {Tuple<number, number>}
  • source {Literal}
  • specifiers {ImportSpecifier|ImportDefaultSpecifier|ImportNamespaceSpecifier[]}
  • trailingComments <Comment[]>
  • type {"ImportDeclaration"}
Attributes
<Node>
  • attributes {ImportAttribute[]}
  • end <number>
  • loc <null>
  • range {Tuple<number, number>}
  • source {Literal}
  • specifiers {ImportSpecifier|ImportDefaultSpecifier|ImportNamespaceSpecifier[]}
  • start <number>
  • type {"ImportDeclaration"}
  • {BaseModuleSpecifier}
Attributes
leadingComments:<Comment[]>
loc:<null>
local:
{Identifier}
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:
{"ImportDefaultSpecifier"}
Attributes
<Node>
Attributes
end:<number>
loc:<null>
local:
{Identifier}
range:
{Tuple<number, number>}
start:<number>
type:
{"ImportDefaultSpecifier"}
  • attributes {Record<string, string>}
  • externalType {"module"|"import"}
  • {BaseExpression}
Attributes
leadingComments:<Comment[]>
loc:<null>
options:<null>
range:
{Tuple<number, number>}
source:
{Expression}
trailingComments:<Comment[]>
type:
{"ImportExpression"}
Attributes
<Node>
Attributes
end:<number>
loc:<null>
options:<null>
range:
{Tuple<number, number>}
source:
{Expression}
start:<number>
type:
{"ImportExpression"}
Attributes
baseUri:<string>
target base uri
layer:<string>
the target layer
publicPath:<string>
the target public path
  • {BaseModuleSpecifier}
Attributes
leadingComments:<Comment[]>
loc:<null>
local:
{Identifier}
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:
{"ImportNamespaceSpecifier"}
Attributes
<Node>
Attributes
end:<number>
loc:<null>
local:
{Identifier}
range:
{Tuple<number, number>}
start:<number>
type:
{"ImportNamespaceSpecifier"}
  • expression {ImportExpressionJavascriptParser}
  • references {string[][]}
  • {BaseModuleSpecifier}
  • imported {Identifier|Literal}
  • leadingComments <Comment[]>
  • loc <null>
  • local {Identifier}
  • range {Tuple<number, number>}
  • trailingComments <Comment[]>
  • type {"ImportSpecifier"}
Attributes
<Node>
Attributes
end:<number>
imported:
{Identifier|Literal}
loc:<null>
local:
{Identifier}
range:
{Tuple<number, number>}
start:<number>
type:
{"ImportSpecifier"}
  • {Dict<string|string[]>}
Attributes
accept:<string>
accept-encoding:<string>
accept-language:<string>
accept-patch:<string>
accept-ranges:<string>
access-control-allow-credentials:<string>
access-control-allow-headers:<string>
access-control-allow-methods:<string>
access-control-allow-origin:<string>
access-control-expose-headers:<string>
access-control-max-age:<string>
access-control-request-headers:<string>
access-control-request-method:<string>
age:<string>
allow:<string>
alt-svc:<string>
authorization:<string>
cache-control:<string>
connection:<string>
content-disposition:<string>
content-encoding:<string>
content-language:<string>
content-length:<string>
content-location:<string>
content-range:<string>
content-type:<string>
cookie:<string>
date:<string>
etag:<string>
expect:<string>
expires:<string>
forwarded:<string>
from:<string>
host:<string>
if-match:<string>
if-modified-since:<string>
if-none-match:<string>
if-unmodified-since:<string>
last-modified:<string>
location:<string>
origin:<string>
pragma:<string>
proxy-authenticate:<string>
proxy-authorization:<string>
public-key-pins:<string>
range:<string>
referer:<string>
retry-after:<string>
sec-fetch-dest:<string>
sec-fetch-mode:<string>
sec-fetch-site:<string>
sec-fetch-user:<string>
sec-websocket-accept:<string>
sec-websocket-extensions:<string>
sec-websocket-key:<string>
sec-websocket-protocol:<string>
sec-websocket-version:<string>
set-cookie:<string[]>
strict-transport-security:<string>
tk:<string>
trailer:<string>
transfer-encoding:<string>
upgrade:<string>
user-agent:<string>
vary:<string>
via:<string>
warning:<string>
www-authenticate:<string>
  • [<ReadableEventMap>](/Stream.html#interface-readableeventmap)
  • aborted {Tuple}
  • close {Tuple}
  • data {Tuple}
  • end {Tuple}
  • error {Tuple}
  • pause {Tuple}
  • readable {Tuple}
  • resume {Tuple}

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.
debug:<string> | <boolean> | <RegExp> | <object>
Enable debug logging for specific loggers.
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
close:<object>
createWriteStream:<object>
mkdirSync:
{MkdirSync}
open:
{Open}
read:
{Read<ArrayBufferView >}
rename:<object>

Internal

This is the interface from which event-emitting Node.js APIs inherit in the types package. It is not intended for consumer use.

It provides event-mapped definitions similar to EventEmitter, except that its signatures are deliberately permissive: they provide type hinting, but not rigid type-checking, for compatibility reasons.

Classes that inherit directly from EventEmitter in JavaScript can inherit directly from this interface in the type definitions. Classes that are more than one inheritance level away from EventEmitter (eg. net.Socket > stream.Duplex > EventEmitter) must instead copy these method definitions into the derived class. Search "#region InternalEventEmitter" for examples.

  • [<EventEmitter>](/EventEmitter-1.html)
  • [<Server>](/Server.html)
Attributes
error:<Error>
event:<string> | <symbol>
args:<any[]>
Returns:
{void}

The Symbol.for('nodejs.rejection') method is called in case a promise rejection happens when emitting an event and captureRejections is enabled on the emitter. It is possible to use events.captureRejectionSymbol in place of Symbol.for('nodejs.rejection').

import { EventEmitter, captureRejectionSymbol } from 'node:events';

class MyClass extends EventEmitter {
  constructor() {
    super({ captureRejections: true });
  }

  [captureRejectionSymbol](err, event, ...args) {
    console.log('rejection happened for', event, 'with', err, ...args);
    this.destroy(err);
  }

  destroy(err) {
    // Tear the resource down here.
  }
}
JavaScript
Call Signature

Alias for emitter.on(eventName, listener).

Call Signature
Attributes
eventName:<string> | <symbol>
listener:<object>
Returns:<this>

Alias for emitter.on(eventName, listener).

Call Signature
  • eventName {E}
  • args {T}
  • Returns: <boolean>

Synchronously calls each of the listeners registered for the event named eventName, in the order they were registered, passing the supplied arguments to each.

Returns true if the event had listeners, false otherwise.

import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();

// First listener
myEmitter.on('event', function firstListener() {
  console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
  console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
  const parameters = args.join(', ');
  console.log(`event with parameters ${parameters} in third listener`);
});

console.log(myEmitter.listeners('event'));

myEmitter.emit('event', 1, 2, 3, 4, 5);

// Prints:
// [
//   [Function: firstListener],
//   [Function: secondListener],
//   [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener
JavaScript
Call Signature
Attributes
eventName:<string> | <symbol>
args:<any[]>
Returns:<boolean>

Synchronously calls each of the listeners registered for the event named eventName, in the order they were registered, passing the supplied arguments to each.

Returns true if the event had listeners, false otherwise.

import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();

// First listener
myEmitter.on('event', function firstListener() {
  console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
  console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
  const parameters = args.join(', ');
  console.log(`event with parameters ${parameters} in third listener`);
});

console.log(myEmitter.listeners('event'));

myEmitter.emit('event', 1, 2, 3, 4, 5);

// Prints:
// [
//   [Function: firstListener],
//   [Function: secondListener],
//   [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener
JavaScript
Returns:<string> | <symbol[]>

Returns an array listing the events for which the emitter has registered listeners.

import { EventEmitter } from 'node:events';

const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});

const sym = Symbol('symbol');
myEE.on(sym, () => {});

console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]
JavaScript
Returns:<number>

Returns the current max listener value for the EventEmitter which is either set by emitter.setMaxListeners(n) or defaults to events.defaultMaxListeners.

Call Signature
  • eventName {E} The name of the event being listened for
  • listener <object> The event handler function
  • Returns: <number>

Returns the number of listeners listening for the event named eventName. If listener is provided, it will return how many times the listener is found in the list of the listeners of the event.

Call Signature
Attributes
eventName:<string> | <symbol>
The name of the event being listened for
listener:<object>
The event handler function
Returns:<number>

Returns the number of listeners listening for the event named eventName. If listener is provided, it will return how many times the listener is found in the list of the listeners of the event.

Call Signature

Returns a copy of the array of listeners for the event named eventName.

server.on('connection', (stream) => {
  console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]
JavaScript
Call Signature
Attributes
eventName:<string> | <symbol>
Returns:<object[]>

Returns a copy of the array of listeners for the event named eventName.

server.on('connection', (stream) => {
  console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]
JavaScript
Call Signature

Alias for emitter.removeListener().

Call Signature
Attributes
eventName:<string> | <symbol>
listener:<object>
Returns:<this>

Alias for emitter.removeListener().

Call Signature
  • eventName {E} The name of the event.
  • listener <object> The callback function
  • Returns: <this>

Adds the listener function to the end of the listeners array for the event named eventName. No checks are made to see if the listener has already been added. Multiple calls passing the same combination of eventName and listener will result in the listener being added, and called, multiple times.

server.on('connection', (stream) => {
  console.log('someone connected!');
});
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

By default, event listeners are invoked in the order they are added. The emitter.prependListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
JavaScript
Call Signature
Attributes
eventName:<string> | <symbol>
The name of the event.
listener:<object>
The callback function
Returns:<this>

Adds the listener function to the end of the listeners array for the event named eventName. No checks are made to see if the listener has already been added. Multiple calls passing the same combination of eventName and listener will result in the listener being added, and called, multiple times.

server.on('connection', (stream) => {
  console.log('someone connected!');
});
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

By default, event listeners are invoked in the order they are added. The emitter.prependListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
JavaScript
Call Signature
  • eventName {E} The name of the event.
  • listener <object> The callback function
  • Returns: <this>

Adds a one-time listener function for the event named eventName. The next time eventName is triggered, this listener is removed and then invoked.

server.once('connection', (stream) => {
  console.log('Ah, we have our first user!');
});
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

By default, event listeners are invoked in the order they are added. The emitter.prependOnceListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
JavaScript
Call Signature
Attributes
eventName:<string> | <symbol>
The name of the event.
listener:<object>
The callback function
Returns:<this>

Adds a one-time listener function for the event named eventName. The next time eventName is triggered, this listener is removed and then invoked.

server.once('connection', (stream) => {
  console.log('Ah, we have our first user!');
});
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

By default, event listeners are invoked in the order they are added. The emitter.prependOnceListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
JavaScript
Call Signature
  • eventName {E} The name of the event.
  • listener <object> The callback function
  • Returns: <this>

Adds the listener function to the beginning of the listeners array for the event named eventName. No checks are made to see if the listener has already been added. Multiple calls passing the same combination of eventName and listener will result in the listener being added, and called, multiple times.

server.prependListener('connection', (stream) => {
  console.log('someone connected!');
});
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

Call Signature
Attributes
eventName:<string> | <symbol>
The name of the event.
listener:<object>
The callback function
Returns:<this>

Adds the listener function to the beginning of the listeners array for the event named eventName. No checks are made to see if the listener has already been added. Multiple calls passing the same combination of eventName and listener will result in the listener being added, and called, multiple times.

server.prependListener('connection', (stream) => {
  console.log('someone connected!');
});
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

Call Signature
  • eventName {E} The name of the event.
  • listener <object> The callback function
  • Returns: <this>

Adds a one-time listener function for the event named eventName to the beginning of the listeners array. The next time eventName is triggered, this listener is removed, and then invoked.

server.prependOnceListener('connection', (stream) => {
  console.log('Ah, we have our first user!');
});
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

Call Signature
Attributes
eventName:<string> | <symbol>
The name of the event.
listener:<object>
The callback function
Returns:<this>

Adds a one-time listener function for the event named eventName to the beginning of the listeners array. The next time eventName is triggered, this listener is removed, and then invoked.

server.prependOnceListener('connection', (stream) => {
  console.log('Ah, we have our first user!');
});
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

Call Signature

Returns a copy of the array of listeners for the event named eventName, including any wrappers (such as those created by .once()).

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));

// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];

// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();

// Logs "log once" to the console and removes the listener
logFnWrapper();

emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');

// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');
JavaScript
Call Signature
Attributes
eventName:<string> | <symbol>
Returns:<object[]>

Returns a copy of the array of listeners for the event named eventName, including any wrappers (such as those created by .once()).

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));

// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];

// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();

// Logs "log once" to the console and removes the listener
logFnWrapper();

emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');

// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');
JavaScript
Call Signature
  • eventName {E}
  • Returns: <this>

Removes all listeners, or those of the specified eventName.

It is bad practice to remove listeners added elsewhere in the code, particularly when the EventEmitter instance was created by some other component or module (e.g. sockets or file streams).

Returns a reference to the EventEmitter, so that calls can be chained.

Call Signature
Attributes
eventName:<string> | <symbol>
Returns:<this>

Removes all listeners, or those of the specified eventName.

It is bad practice to remove listeners added elsewhere in the code, particularly when the EventEmitter instance was created by some other component or module (e.g. sockets or file streams).

Returns a reference to the EventEmitter, so that calls can be chained.

Call Signature

Removes the specified listener from the listener array for the event named eventName.

const callback = (stream) => {
  console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);
JavaScript

removeListener() will remove, at most, one instance of a listener from the listener array. If any single listener has been added multiple times to the listener array for the specified eventName, then removeListener() must be called multiple times to remove each instance.

Once an event is emitted, all listeners attached to it at the time of emitting are called in order. This implies that any removeListener() or removeAllListeners() calls after emitting and before the last listener finishes execution will not remove them from emit() in progress. Subsequent events behave as expected.

import { EventEmitter } from 'node:events';
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();

const callbackA = () => {
  console.log('A');
  myEmitter.removeListener('event', callbackB);
};

const callbackB = () => {
  console.log('B');
};

myEmitter.on('event', callbackA);

myEmitter.on('event', callbackB);

// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
//   A
//   B

// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
//   A
JavaScript

Because listeners are managed using an internal array, calling this will change the position indexes of any listener registered after the listener being removed. This will not impact the order in which listeners are called, but it means that any copies of the listener array as returned by the emitter.listeners() method will need to be recreated.

When a single function has been added as a handler multiple times for a single event (as in the example below), removeListener() will remove the most recently added instance. In the example the once('ping') listener is removed:

import { EventEmitter } from 'node:events';
const ee = new EventEmitter();

function pong() {
  console.log('pong');
}

ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);

ee.emit('ping');
ee.emit('ping');
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

Call Signature
Attributes
eventName:<string> | <symbol>
listener:<object>
Returns:<this>

Removes the specified listener from the listener array for the event named eventName.

const callback = (stream) => {
  console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);
JavaScript

removeListener() will remove, at most, one instance of a listener from the listener array. If any single listener has been added multiple times to the listener array for the specified eventName, then removeListener() must be called multiple times to remove each instance.

Once an event is emitted, all listeners attached to it at the time of emitting are called in order. This implies that any removeListener() or removeAllListeners() calls after emitting and before the last listener finishes execution will not remove them from emit() in progress. Subsequent events behave as expected.

import { EventEmitter } from 'node:events';
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();

const callbackA = () => {
  console.log('A');
  myEmitter.removeListener('event', callbackB);
};

const callbackB = () => {
  console.log('B');
};

myEmitter.on('event', callbackA);

myEmitter.on('event', callbackB);

// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
//   A
//   B

// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
//   A
JavaScript

Because listeners are managed using an internal array, calling this will change the position indexes of any listener registered after the listener being removed. This will not impact the order in which listeners are called, but it means that any copies of the listener array as returned by the emitter.listeners() method will need to be recreated.

When a single function has been added as a handler multiple times for a single event (as in the example below), removeListener() will remove the most recently added instance. In the example the once('ping') listener is removed:

import { EventEmitter } from 'node:events';
const ee = new EventEmitter();

function pong() {
  console.log('pong');
}

ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);

ee.emit('ping');
ee.emit('ping');
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

Attributes
n:<number>
Returns:<this>

By default EventEmitters will print a warning if more than 10 listeners are added for a particular event. This is a useful default that helps finding memory leaks. The emitter.setMaxListeners() method allows the limit to be modified for this specific EventEmitter instance. The value can be set to Infinity (or 0) to indicate an unlimited number of listeners.

Returns a reference to the EventEmitter, so that calls can be chained.

Attributes
info:<AssetInfo>
path:<string>
Attributes
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}
Returns:
{Iterator<T, TReturn, TNext>}

Describes a user-defined Iterator that is also iterable.

  • {Iterator<T, TReturn, TNext>}
Returns:
{IterableIterator<T, TReturn, TNext>}
  • __namedParameters {Tuple|Tuple}
  • Returns: {IteratorResult<T, TReturn>}
  • value {TReturn}
  • Returns: {IteratorResult<T, TReturn>}
Attributes
e:<any>
Returns:
{IteratorResult<T, TReturn>}
  • {Iterator<T, TReturn, TNext>}.{Disposable}
  • {SetIterator}
Returns:
{void}
Returns:
{IteratorObject<T, TReturn, TNext>}
  • __namedParameters {Tuple|Tuple}
  • Returns: {IteratorResult<T, TReturn>}
  • value {TReturn}
  • Returns: {IteratorResult<T, TReturn>}
Attributes
e:<any>
Returns:
{IteratorResult<T, TReturn>}
  • done {true}
  • value {TReturn}
  • done {false}
  • value {TYield}

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.
createRequire:<string> | <boolean>
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.
dynamicImportPrefetch:<number> | <boolean>
Specifies global prefetch for dynamic import.
dynamicImportPreload:<number> | <boolean>
Specifies global preload 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.
exprContextRegExp:<boolean> | <RegExp>
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.
unknownContextRegExp:<boolean> | <RegExp>
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
exportsDepth:<number>
The depth of json dependency flagged as  exportInfo .
namedExports:<boolean>
Allow named exports for json of object type
parse:<object>
Function that executes for a module source string and should return json-compatible data.

Parser options for JSON modules.

Attributes
exportsDepth:<number>
The depth of json dependency flagged as  exportInfo .
namedExports:<boolean>
Allow named exports for json of object type.
parse:<object>
Function to parser content and return JSON.
  • linkPrefetch {SyncWaterfallHook<Tuple<string, Chunk>, string>}
  • linkPreload {SyncWaterfallHook<Tuple<string, Chunk>, string>}

JSON Schema V4

Attributes
$ref:<string>
$schema:<string>
additionalItems:<boolean>
May only be defined when "items" is defined, and is a tuple of JSONSchemas.

This provides a definition for additional items in an array instance when tuple definitions of the items is provided. This can be false to indicate additional items in the array are not allowed, or it can be a schema that defines the schema of the additional items.

Attributes
additionalProperties:<boolean>
This attribute defines a schema for all properties that are not explicitly defined in an object type definition. If specified, the value MUST be a schema or a boolean. If false is provided, no additional properties are allowed beyond the properties defined in the schema. The default value is an empty schema which allows any value for additional properties.
allOf:
{JSONSchema4[]}
anyOf:
{JSONSchema4[]}
default:
{JSONSchema4Type}
definitions:<object>
dependencies:<object>
description:<string>
This attribute is a string that provides a full description of the of purpose the instance property.
enum:
{JSONSchema4Type[]} This provides an enumeration of all possible values that are valid for the instance property. This MUST be an array, and each item in the array represents a possible value for the instance value. If this attribute is defined, the instance value MUST be one of the values in the array in order for the schema to be valid.
exclusiveMaximum:<boolean>
exclusiveMinimum:<boolean>
extends:<string> | <string[]>
The value of this property MUST be another schema which will provide a base schema which the current schema will inherit from. The inheritance rules are such that any instance that is valid according to the current schema MUST be valid according to the referenced schema. This MAY also be an array, in which case, the instance MUST be valid for all the schemas in the array. A schema that extends another schema MAY define additional attributes, constrain existing attributes, or add other constraints.

Conceptually, the behavior of extends can be seen as validating an instance against all constraints in the extending schema as well as the extended schema(s).

Attributes
format:<string>
id:<string>
items:
{JSONSchema4|JSONSchema4[]} This attribute defines the allowed items in an instance array, and MUST be a schema or an array of schemas. The default value is an empty schema which allows any value for items in the instance array.

When this attribute value is a schema and the instance value is an array, then all the items in the array MUST be valid according to the schema.

When this attribute value is an array of schemas and the instance value is an array, each position in the instance array MUST conform to the schema in the corresponding position for this array. This called tuple typing. When tuple typing is used, additional items are allowed, disallowed, or constrained by the "additionalItems" (Section 5.6) attribute using the same rules as "additionalProperties" (Section 5.4) for objects.

Attributes
maximum:<number>
maxItems:<number>
maxLength:<number>
maxProperties:<number>
minimum:<number>
minItems:<number>
minLength:<number>
minProperties:<number>
multipleOf:<number>
not:
{JSONSchema4}
oneOf:
{JSONSchema4[]}
pattern:<string>
patternProperties:<object>
This attribute is an object that defines the schema for a set of property names of an object instance. The name of each property of this attribute's object is a regular expression pattern in the ECMA 262/Perl 5 format, while the value is a schema. If the pattern matches the name of a property on the instance object, the value of the instance's property MUST be valid against the pattern name's schema value.
properties:<object>
This attribute is an object with property definitions that define the valid values of instance object property values. When the instance value is an object, the property values of the instance object MUST conform to the property definitions in this object. In this object, each property definition's value MUST be a schema, and the property's name MUST be the name of the instance property that it defines. The instance property value MUST be valid according to the schema from the property definition. Properties are considered unordered, the order of the instance properties MAY be in any order.
required:<boolean> | <string[]>
This attribute indicates if the instance must have a value, and not be undefined. This is false by default, making the instance optional.
title:<string>
This attribute is a string that provides a short description of the instance property.
type:
{JSONSchema4TypeName|JSONSchema4TypeName[]} A single type, or a union of simple types
uniqueItems:<boolean>
  • {Array}
  • [n: {number}] {JSONSchema4Type}
  • [unscopables] <object> Is an object whose properties have the value 'true' when they will be absent when used in a 'with' statement.
  • length <number> Gets or sets the length of the array. This is a number one higher than the highest index in the array.
Returns:
{ArrayIterator }

Iterator

Attributes
index:<number>
The zero-based index of the desired code unit. A negative index will count back from the last item.
Returns:<undefined>

Returns the item located at the specified index.

Call Signature
  • items {ConcatArray[]} Additional arrays and/or items to add to the end of the array.
  • Returns: {JSONSchema4Type[]}

Combines two or more arrays. This method returns a new array without modifying any existing arrays.

Call Signature
  • items {JSONSchema4Type|ConcatArray[]} Additional arrays and/or items to add to the end of the array.
  • Returns: {JSONSchema4Type[]}

Combines two or more arrays. This method returns a new array without modifying any existing arrays.

Attributes
target:<number>
If target is negative, it is treated as length+target where length is the length of the array.
start:<number>
If start is negative, it is treated as length+start. If end is negative, it is treated as length+end.
end:<number>
If not specified, length of the this object is used as its default value.
Returns:<this>

Returns the this object after copying a section of the array identified by start and end to the same array starting at position target

Returns:
{ArrayIterator<Tuple<number, JSONSchema4Type>>}

Returns an iterable of key, value pairs for every entry in the array

Call Signature
Attributes
predicate:<object>
A function that accepts up to three arguments. The every method calls the predicate function for each element in the array until the predicate returns a value which is coercible to the Boolean value false, or until the end of the array.
thisArg:<any>
An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.
Returns:<this>

Determines whether all the members of an array satisfy the specified test.

Call Signature
Attributes
predicate:<object>
A function that accepts up to three arguments. The every method calls the predicate function for each element in the array until the predicate returns a value which is coercible to the Boolean value false, or until the end of the array.
thisArg:<any>
An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.
Returns:<boolean>

Determines whether all the members of an array satisfy the specified test.

  • value {JSONSchema4Type} value to fill array section with
  • start <number> index to start filling the array at. If start is negative, it is treated as length+start where length is the length of the array.
  • end <number> index to stop filling the array at. If end is negative, it is treated as length+end.
  • Returns: <this>

Changes all array elements from start to end index to a static value and returns the modified array

Call Signature
Attributes
predicate:<object>
A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array.
thisArg:<any>
An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.
Returns:
{S[]}

Returns the elements of an array that meet the condition specified in a callback function.

Call Signature
Attributes
predicate:<object>
A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array.
thisArg:<any>
An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.
Returns:
{JSONSchema4Type[]}

Returns the elements of an array that meet the condition specified in a callback function.

Call Signature
Attributes
predicate:<object>
find calls predicate once for each element of the array, in ascending order, until it finds one where predicate returns true. If such an element is found, find immediately returns that element value. Otherwise, find returns undefined.
thisArg:<any>
If provided, it will be used as the this value for each invocation of predicate. If it is not provided, undefined is used instead.
Returns:<undefined>

Returns the value of the first element in the array where predicate is true, and undefined otherwise.

Call Signature
Attributes
predicate:<object>
thisArg:<any>
Returns:<undefined>
Attributes
predicate:<object>
find calls predicate once for each element of the array, in ascending order, until it finds one where predicate returns true. If such an element is found, findIndex immediately returns that element index. Otherwise, findIndex returns -1.
thisArg:<any>
If provided, it will be used as the this value for each invocation of predicate. If it is not provided, undefined is used instead.
Returns:<number>

Returns the index of the first element in the array where predicate is true, and -1 otherwise.

Call Signature
Attributes
predicate:<object>
findLast calls predicate once for each element of the array, in descending order, until it finds one where predicate returns true. If such an element is found, findLast immediately returns that element value. Otherwise, findLast returns undefined.
thisArg:<any>
If provided, it will be used as the this value for each invocation of predicate. If it is not provided, undefined is used instead.
Returns:<undefined>

Returns the value of the last element in the array where predicate is true, and undefined otherwise.

Call Signature
Attributes
predicate:<object>
thisArg:<any>
Returns:<undefined>
Attributes
predicate:<object>
findLastIndex calls predicate once for each element of the array, in descending order, until it finds one where predicate returns true. If such an element is found, findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1.
thisArg:<any>
If provided, it will be used as the this value for each invocation of predicate. If it is not provided, undefined is used instead.
Returns:<number>

Returns the index of the last element in the array where predicate is true, and -1 otherwise.

  • this {A}
  • depth {D} The maximum recursion depth
  • Returns: {FlatArray<A, D>[]}

Returns a new array with all sub-array elements concatenated into it recursively up to the specified depth.

Attributes
callback:<object>
A function that accepts up to three arguments. The flatMap method calls the callback function one time for each element in the array.
thisArg:<This>
An object to which the this keyword can refer in the callback function. If thisArg is omitted, undefined is used as the this value.
Returns:
{U[]}

Calls a defined callback function on each element of an array. Then, flattens the result into a new array. This is identical to a map followed by flat with depth 1.

Attributes
callbackfn:<object>
A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array.
thisArg:<any>
An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
Returns:
{void}

Performs the specified action for each element in an array.

  • searchElement {JSONSchema4Type} The element to search for.
  • fromIndex <number> The position in this array at which to begin searching for searchElement.
  • Returns: <boolean>

Determines whether an array includes a certain element, returning true or false as appropriate.

  • searchElement {JSONSchema4Type} The value to locate in the array.
  • fromIndex <number> The array index at which to begin the search. If fromIndex is omitted, the search starts at index 0.
  • Returns: <number>

Returns the index of the first occurrence of a value in an array, or -1 if it is not present.

Attributes
separator:<string>
A string used to separate one element of the array from the next in the resulting string. If omitted, the array elements are separated with a comma.
Returns:<string>

Adds all the elements of an array into a string, separated by the specified separator string.

Returns:
{ArrayIterator }

Returns an iterable of keys in the array

  • searchElement {JSONSchema4Type} The value to locate in the array.
  • fromIndex <number> The array index at which to begin searching backward. If fromIndex is omitted, the search starts at the last index in the array.
  • Returns: <number>

Returns the index of the last occurrence of a specified value in an array, or -1 if it is not present.

Attributes
callbackfn:<object>
A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.
thisArg:<any>
An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
Returns:
{U[]}

Calls a defined callback function on each element of an array, and returns an array that contains the results.

Returns:<undefined>

Removes the last element from an array and returns it. If the array is empty, undefined is returned and the array is not modified.

  • items {JSONSchema4Type[]} New elements to add to the array.
  • Returns: <number>

Appends new elements to the end of an array, and returns the new length of the array.

Call Signature
Attributes
callbackfn:<object>
A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
Returns:
{JSONSchema4Type}

Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

Call Signature
Attributes
callbackfn:<object>
initialValue:
{JSONSchema4Type}
Returns:
{JSONSchema4Type}
Call Signature
Attributes
callbackfn:<object>
A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
initialValue:
{U} If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
Returns:
{U}

Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

Call Signature
Attributes
callbackfn:<object>
A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.
Returns:
{JSONSchema4Type}

Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

Call Signature
Attributes
callbackfn:<object>
initialValue:
{JSONSchema4Type}
Returns:
{JSONSchema4Type}
Call Signature
Attributes
callbackfn:<object>
A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.
initialValue:
{U} If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
Returns:
{U}

Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

Returns:
{JSONSchema4Type[]}

Reverses the elements in an array in place. This method mutates the array and returns a reference to the same array.

Returns:<undefined>

Removes the first element from an array and returns it. If the array is empty, undefined is returned and the array is not modified.

Attributes
start:<number>
The beginning index of the specified portion of the array. If start is undefined, then the slice begins at index 0.
end:<number>
The end index of the specified portion of the array. This is exclusive of the element at the index 'end'. If end is undefined, then the slice extends to the end of the array.
Returns:
{JSONSchema4Type[]}

Returns a copy of a section of an array. For both start and end, a negative index can be used to indicate an offset from the end of the array. For example, -2 refers to the second to last element of the array.

Attributes
predicate:<object>
A function that accepts up to three arguments. The some method calls the predicate function for each element in the array until the predicate returns a value which is coercible to the Boolean value true, or until the end of the array.
thisArg:<any>
An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.
Returns:<boolean>

Determines whether the specified callback function returns true for any element of an array.

Attributes
compareFn:<object>
Function used to determine the order of the elements. It is expected to return a negative value if the first argument is less than the second argument, zero if they're equal, and a positive value otherwise. If omitted, the elements are sorted in ascending, UTF-16 code unit order.
[11,2,22,1].sort((a, b) => a - b)
Returns:<this>

Sorts an array in place. This method mutates the array and returns a reference to the same array.

Call Signature
Attributes
start:<number>
The zero-based location in the array from which to start removing elements.
deleteCount:<number>
The number of elements to remove. Omitting this argument will remove all elements from the start paramater location to end of the array. If value of this argument is either a negative number, zero, undefined, or a type that cannot be converted to an integer, the function will evaluate the argument as zero and not remove any elements.
Returns:
{JSONSchema4Type[]} An array containing the elements that were deleted.

Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.

Call Signature
Attributes
start:<number>
The zero-based location in the array from which to start removing elements.
deleteCount:<number>
The number of elements to remove. If value of this argument is either a negative number, zero, undefined, or a type that cannot be converted to an integer, the function will evaluate the argument as zero and not remove any elements.
items:
{JSONSchema4Type[]} Elements to insert into the array in place of the deleted elements.
Returns:
{JSONSchema4Type[]} An array containing the elements that were deleted.

Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.

Call Signature
Returns:<string>

Returns a string representation of an array. The elements are converted to string using their toLocaleString methods.

Call Signature
Attributes
locales:<string> | <string[]>
options:
{NumberFormatOptions|DateTimeFormatOptions}
Returns:<string>
Returns:
{JSONSchema4Type[]}

Returns a copy of an array with its elements reversed.

Attributes
compareFn:<object>
Function used to determine the order of the elements. It is expected to return a negative value if the first argument is less than the second argument, zero if they're equal, and a positive value otherwise. If omitted, the elements are sorted in ascending, UTF-16 code unit order.
[11, 2, 22, 1].toSorted((a, b) => a - b) // [1, 2, 11, 22]
Returns:
{JSONSchema4Type[]}

Returns a copy of an array with its elements sorted.

Call Signature
Attributes
start:<number>
The zero-based location in the array from which to start removing elements.
deleteCount:<number>
The number of elements to remove.
items:
{JSONSchema4Type[]} Elements to insert into the copied array in place of the deleted elements.
Returns:
{JSONSchema4Type[]} The copied array.

Copies an array and removes elements and, if necessary, inserts new elements in their place. Returns the copied array.

Call Signature
Attributes
start:<number>
The zero-based location in the array from which to start removing elements.
deleteCount:<number>
The number of elements to remove.
Returns:
{JSONSchema4Type[]} A copy of the original array with the remaining elements.

Copies an array and removes elements while returning the remaining elements.

Returns:<string>

Returns a string representation of an array.

  • items {JSONSchema4Type[]} Elements to insert at the start of the array.
  • Returns: <number>

Inserts new elements at the start of an array, and returns the new length of the array.

Returns:
{ArrayIterator }

Returns an iterable of values in the array

Attributes
index:<number>
The index of the value to overwrite. If the index is negative, then it replaces from the end of the array.
value:
{JSONSchema4Type} The value to write into the copied array.
Returns:
{JSONSchema4Type[]} The copied array with the updated value.

Copies an array, then overwrites the value at the provided index with the given value. If the index is negative, then it replaces from the end of the array.

  • [key: {string}] {JSONSchema4Type}
Attributes
$id:<string>
$ref:<string>
$schema:<string>
additionalItems:
{JSONSchema6Definition} This keyword determines how child instances validate for arrays, and does not directly validate the immediate instance itself. If "items" is an array of schemas, validation succeeds if every instance element at a position greater than the size of "items" validates against "additionalItems". Otherwise, "additionalItems" MUST be ignored, as the "items" schema (possibly the default value of an empty schema) is applied to all elements. Omitting this keyword has the same behavior as an empty schema.
additionalProperties:
{JSONSchema6Definition} This attribute defines a schema for all properties that are not explicitly defined in an object type definition. If specified, the value MUST be a schema or a boolean. If false is provided, no additional properties are allowed beyond the properties defined in the schema. The default value is an empty schema which allows any value for additional properties.
allOf:
{JSONSchema6Definition[]}
anyOf:
{JSONSchema6Definition[]}
const:
{JSONSchema6Type} More readable form of a one-element "enum"
contains:
{JSONSchema6Definition} An array instance is valid against "contains" if at least one of its elements is valid against the given schema.
default:
{JSONSchema6Type} This keyword can be used to supply a default JSON value associated with a particular schema. It is RECOMMENDED that a default value be valid against the associated schema.
definitions:<object>
dependencies:<object>
This keyword specifies rules that are evaluated if the instance is an object and contains a certain property. Each property specifies a dependency. If the dependency value is an array, each element in the array must be unique. Omitting this keyword has the same behavior as an empty object.
description:<string>
This attribute is a string that provides a full description of the of purpose the instance property.
enum:
{JSONSchema6Type[]} This provides an enumeration of all possible values that are valid for the instance property. This MUST be an array, and each item in the array represents a possible value for the instance value. If this attribute is defined, the instance value MUST be one of the values in the array in order for the schema to be valid.
examples:
{JSONSchema6Type[]} Array of examples with no validation effect the value of "default" is usable as an example without repeating it under this keyword
exclusiveMaximum:<number>
Representing an exclusive upper limit for a numeric instance. This keyword validates only if the instance is strictly less than (not equal to) to "exclusiveMaximum".
exclusiveMinimum:<number>
Representing an exclusive lower limit for a numeric instance. This keyword validates only if the instance is strictly greater than (not equal to) to "exclusiveMinimum".
format:<string>
items:
{JSONSchema6Definition|JSONSchema6Definition[]} This keyword determines how child instances validate for arrays, and does not directly validate the immediate instance itself. Omitting this keyword has the same behavior as an empty schema.
maximum:<number>
Representing an inclusive upper limit for a numeric instance. This keyword validates only if the instance is less than or exactly equal to "maximum".
maxItems:<number>
Must be a non-negative integer. An array instance is valid against "maxItems" if its size is less than, or equal to, the value of this keyword.
maxLength:<number>
Must be a non-negative integer. A string instance is valid against this keyword if its length is less than, or equal to, the value of this keyword.
maxProperties:<number>
Must be a non-negative integer. An object instance is valid against "maxProperties" if its number of properties is less than, or equal to, the value of this keyword.
minimum:<number>
Representing an inclusive lower limit for a numeric instance. This keyword validates only if the instance is greater than or exactly equal to "minimum".
minItems:<number>
Must be a non-negative integer. An array instance is valid against "maxItems" if its size is greater than, or equal to, the value of this keyword. Omitting this keyword has the same behavior as a value of 0.
minLength:<number>
Must be a non-negative integer. A string instance is valid against this keyword if its length is greater than, or equal to, the value of this keyword. Omitting this keyword has the same behavior as a value of 0.
minProperties:<number>
Must be a non-negative integer. An object instance is valid against "maxProperties" if its number of properties is greater than, or equal to, the value of this keyword. Omitting this keyword has the same behavior as a value of 0.
multipleOf:<number>
Must be strictly greater than 0. A numeric instance is valid only if division by this keyword's value results in an integer.
not:
{JSONSchema6Definition}
oneOf:
{JSONSchema6Definition[]}
pattern:<string>
Should be a valid regular expression, according to the ECMA 262 regular expression dialect.
patternProperties:<object>
This attribute is an object that defines the schema for a set of property names of an object instance. The name of each property of this attribute's object is a regular expression pattern in the ECMA 262, while the value is a schema. If the pattern matches the name of a property on the instance object, the value of the instance's property MUST be valid against the pattern name's schema value. Omitting this keyword has the same behavior as an empty object.
properties:<object>
This keyword determines how child instances validate for objects, and does not directly validate the immediate instance itself. Validation succeeds if, for each name that appears in both the instance and as a name within this keyword's value, the child instance for that name successfully validates against the corresponding schema. Omitting this keyword has the same behavior as an empty object.
propertyNames:
{JSONSchema6Definition} Takes a schema which validates the names of all properties rather than their values. Note the property name that the schema is testing will always be a string. Omitting this keyword has the same behavior as an empty schema.
required:<string[]>
Elements of this array must be unique. An object instance is valid against this keyword if every item in the array is the name of a property in the instance. Omitting this keyword has the same behavior as an empty array.
title:<string>
This attribute is a string that provides a short description of the instance property.
type:
{JSONSchema6TypeName|JSONSchema6TypeName[]} A single type, or a union of simple types
uniqueItems:<boolean>
If this keyword has boolean value false, the instance validates successfully. If it has boolean value true, the instance validates successfully if all of its elements are unique. Omitting this keyword has the same behavior as a value of false.
  • {Array}
  • [n: {number}] {JSONSchema6Type}
  • [unscopables] <object> Is an object whose properties have the value 'true' when they will be absent when used in a 'with' statement.
  • length <number> Gets or sets the length of the array. This is a number one higher than the highest index in the array.
Returns:
{ArrayIterator }

Iterator

Attributes
index:<number>
The zero-based index of the desired code unit. A negative index will count back from the last item.
Returns:<undefined>

Returns the item located at the specified index.

Call Signature
  • items {ConcatArray[]} Additional arrays and/or items to add to the end of the array.
  • Returns: {JSONSchema6Type[]}

Combines two or more arrays. This method returns a new array without modifying any existing arrays.

Call Signature
  • items {JSONSchema6Type|ConcatArray[]} Additional arrays and/or items to add to the end of the array.
  • Returns: {JSONSchema6Type[]}

Combines two or more arrays. This method returns a new array without modifying any existing arrays.

Attributes
target:<number>
If target is negative, it is treated as length+target where length is the length of the array.
start:<number>
If start is negative, it is treated as length+start. If end is negative, it is treated as length+end.
end:<number>
If not specified, length of the this object is used as its default value.
Returns:<this>

Returns the this object after copying a section of the array identified by start and end to the same array starting at position target

Returns:
{ArrayIterator<Tuple<number, JSONSchema6Type>>}

Returns an iterable of key, value pairs for every entry in the array

Call Signature
Attributes
predicate:<object>
A function that accepts up to three arguments. The every method calls the predicate function for each element in the array until the predicate returns a value which is coercible to the Boolean value false, or until the end of the array.
thisArg:<any>
An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.
Returns:<this>

Determines whether all the members of an array satisfy the specified test.

Call Signature
Attributes
predicate:<object>
A function that accepts up to three arguments. The every method calls the predicate function for each element in the array until the predicate returns a value which is coercible to the Boolean value false, or until the end of the array.
thisArg:<any>
An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.
Returns:<boolean>

Determines whether all the members of an array satisfy the specified test.

  • value {JSONSchema6Type} value to fill array section with
  • start <number> index to start filling the array at. If start is negative, it is treated as length+start where length is the length of the array.
  • end <number> index to stop filling the array at. If end is negative, it is treated as length+end.
  • Returns: <this>

Changes all array elements from start to end index to a static value and returns the modified array

Call Signature
Attributes
predicate:<object>
A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array.
thisArg:<any>
An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.
Returns:
{S[]}

Returns the elements of an array that meet the condition specified in a callback function.

Call Signature
Attributes
predicate:<object>
A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array.
thisArg:<any>
An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.
Returns:
{JSONSchema6Type[]}

Returns the elements of an array that meet the condition specified in a callback function.

Call Signature
Attributes
predicate:<object>
find calls predicate once for each element of the array, in ascending order, until it finds one where predicate returns true. If such an element is found, find immediately returns that element value. Otherwise, find returns undefined.
thisArg:<any>
If provided, it will be used as the this value for each invocation of predicate. If it is not provided, undefined is used instead.
Returns:<undefined>

Returns the value of the first element in the array where predicate is true, and undefined otherwise.

Call Signature
Attributes
predicate:<object>
thisArg:<any>
Returns:<undefined>
Attributes
predicate:<object>
find calls predicate once for each element of the array, in ascending order, until it finds one where predicate returns true. If such an element is found, findIndex immediately returns that element index. Otherwise, findIndex returns -1.
thisArg:<any>
If provided, it will be used as the this value for each invocation of predicate. If it is not provided, undefined is used instead.
Returns:<number>

Returns the index of the first element in the array where predicate is true, and -1 otherwise.

Call Signature
Attributes
predicate:<object>
findLast calls predicate once for each element of the array, in descending order, until it finds one where predicate returns true. If such an element is found, findLast immediately returns that element value. Otherwise, findLast returns undefined.
thisArg:<any>
If provided, it will be used as the this value for each invocation of predicate. If it is not provided, undefined is used instead.
Returns:<undefined>

Returns the value of the last element in the array where predicate is true, and undefined otherwise.

Call Signature
Attributes
predicate:<object>
thisArg:<any>
Returns:<undefined>
Attributes
predicate:<object>
findLastIndex calls predicate once for each element of the array, in descending order, until it finds one where predicate returns true. If such an element is found, findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1.
thisArg:<any>
If provided, it will be used as the this value for each invocation of predicate. If it is not provided, undefined is used instead.
Returns:<number>

Returns the index of the last element in the array where predicate is true, and -1 otherwise.

  • this {A}
  • depth {D} The maximum recursion depth
  • Returns: {FlatArray<A, D>[]}

Returns a new array with all sub-array elements concatenated into it recursively up to the specified depth.

Attributes
callback:<object>
A function that accepts up to three arguments. The flatMap method calls the callback function one time for each element in the array.
thisArg:<This>
An object to which the this keyword can refer in the callback function. If thisArg is omitted, undefined is used as the this value.
Returns:
{U[]}

Calls a defined callback function on each element of an array. Then, flattens the result into a new array. This is identical to a map followed by flat with depth 1.

Attributes
callbackfn:<object>
A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array.
thisArg:<any>
An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
Returns:
{void}

Performs the specified action for each element in an array.

  • searchElement {JSONSchema6Type} The element to search for.
  • fromIndex <number> The position in this array at which to begin searching for searchElement.
  • Returns: <boolean>

Determines whether an array includes a certain element, returning true or false as appropriate.

  • searchElement {JSONSchema6Type} The value to locate in the array.
  • fromIndex <number> The array index at which to begin the search. If fromIndex is omitted, the search starts at index 0.
  • Returns: <number>

Returns the index of the first occurrence of a value in an array, or -1 if it is not present.

Attributes
separator:<string>
A string used to separate one element of the array from the next in the resulting string. If omitted, the array elements are separated with a comma.
Returns:<string>

Adds all the elements of an array into a string, separated by the specified separator string.

Returns:
{ArrayIterator }

Returns an iterable of keys in the array

  • searchElement {JSONSchema6Type} The value to locate in the array.
  • fromIndex <number> The array index at which to begin searching backward. If fromIndex is omitted, the search starts at the last index in the array.
  • Returns: <number>

Returns the index of the last occurrence of a specified value in an array, or -1 if it is not present.

Attributes
callbackfn:<object>
A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.
thisArg:<any>
An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
Returns:
{U[]}

Calls a defined callback function on each element of an array, and returns an array that contains the results.

Returns:<undefined>

Removes the last element from an array and returns it. If the array is empty, undefined is returned and the array is not modified.

  • items {JSONSchema6Type[]} New elements to add to the array.
  • Returns: <number>

Appends new elements to the end of an array, and returns the new length of the array.

Call Signature
Attributes
callbackfn:<object>
A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
Returns:
{JSONSchema6Type}

Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

Call Signature
Attributes
callbackfn:<object>
initialValue:
{JSONSchema6Type}
Returns:
{JSONSchema6Type}
Call Signature
Attributes
callbackfn:<object>
A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
initialValue:
{U} If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
Returns:
{U}

Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

Call Signature
Attributes
callbackfn:<object>
A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.
Returns:
{JSONSchema6Type}

Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

Call Signature
Attributes
callbackfn:<object>
initialValue:
{JSONSchema6Type}
Returns:
{JSONSchema6Type}
Call Signature
Attributes
callbackfn:<object>
A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.
initialValue:
{U} If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
Returns:
{U}

Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

Returns:
{JSONSchema6Type[]}

Reverses the elements in an array in place. This method mutates the array and returns a reference to the same array.

Returns:<undefined>

Removes the first element from an array and returns it. If the array is empty, undefined is returned and the array is not modified.

Attributes
start:<number>
The beginning index of the specified portion of the array. If start is undefined, then the slice begins at index 0.
end:<number>
The end index of the specified portion of the array. This is exclusive of the element at the index 'end'. If end is undefined, then the slice extends to the end of the array.
Returns:
{JSONSchema6Type[]}

Returns a copy of a section of an array. For both start and end, a negative index can be used to indicate an offset from the end of the array. For example, -2 refers to the second to last element of the array.

Attributes
predicate:<object>
A function that accepts up to three arguments. The some method calls the predicate function for each element in the array until the predicate returns a value which is coercible to the Boolean value true, or until the end of the array.
thisArg:<any>
An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.
Returns:<boolean>

Determines whether the specified callback function returns true for any element of an array.

Attributes
compareFn:<object>
Function used to determine the order of the elements. It is expected to return a negative value if the first argument is less than the second argument, zero if they're equal, and a positive value otherwise. If omitted, the elements are sorted in ascending, UTF-16 code unit order.
[11,2,22,1].sort((a, b) => a - b)
Returns:<this>

Sorts an array in place. This method mutates the array and returns a reference to the same array.

Call Signature
Attributes
start:<number>
The zero-based location in the array from which to start removing elements.
deleteCount:<number>
The number of elements to remove. Omitting this argument will remove all elements from the start paramater location to end of the array. If value of this argument is either a negative number, zero, undefined, or a type that cannot be converted to an integer, the function will evaluate the argument as zero and not remove any elements.
Returns:
{JSONSchema6Type[]} An array containing the elements that were deleted.

Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.

Call Signature
Attributes
start:<number>
The zero-based location in the array from which to start removing elements.
deleteCount:<number>
The number of elements to remove. If value of this argument is either a negative number, zero, undefined, or a type that cannot be converted to an integer, the function will evaluate the argument as zero and not remove any elements.
items:
{JSONSchema6Type[]} Elements to insert into the array in place of the deleted elements.
Returns:
{JSONSchema6Type[]} An array containing the elements that were deleted.

Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.

Call Signature
Returns:<string>

Returns a string representation of an array. The elements are converted to string using their toLocaleString methods.

Call Signature
Attributes
locales:<string> | <string[]>
options:
{NumberFormatOptions|DateTimeFormatOptions}
Returns:<string>
Returns:
{JSONSchema6Type[]}

Returns a copy of an array with its elements reversed.

Attributes
compareFn:<object>
Function used to determine the order of the elements. It is expected to return a negative value if the first argument is less than the second argument, zero if they're equal, and a positive value otherwise. If omitted, the elements are sorted in ascending, UTF-16 code unit order.
[11, 2, 22, 1].toSorted((a, b) => a - b) // [1, 2, 11, 22]
Returns:
{JSONSchema6Type[]}

Returns a copy of an array with its elements sorted.

Call Signature
Attributes
start:<number>
The zero-based location in the array from which to start removing elements.
deleteCount:<number>
The number of elements to remove.
items:
{JSONSchema6Type[]} Elements to insert into the copied array in place of the deleted elements.
Returns:
{JSONSchema6Type[]} The copied array.

Copies an array and removes elements and, if necessary, inserts new elements in their place. Returns the copied array.

Call Signature
Attributes
start:<number>
The zero-based location in the array from which to start removing elements.
deleteCount:<number>
The number of elements to remove.
Returns:
{JSONSchema6Type[]} A copy of the original array with the remaining elements.

Copies an array and removes elements while returning the remaining elements.

Returns:<string>

Returns a string representation of an array.

  • items {JSONSchema6Type[]} Elements to insert at the start of the array.
  • Returns: <number>

Inserts new elements at the start of an array, and returns the new length of the array.

Returns:
{ArrayIterator }

Returns an iterable of values in the array

Attributes
index:<number>
The index of the value to overwrite. If the index is negative, then it replaces from the end of the array.
value:
{JSONSchema6Type} The value to write into the copied array.
Returns:
{JSONSchema6Type[]} The copied array with the updated value.

Copies an array, then overwrites the value at the provided index with the given value. If the index is negative, then it replaces from the end of the array.

  • [key: {string}] {JSONSchema6Type}
Attributes
$comment:<string>
$defs:<object>
$id:<string>
$ref:<string>
$schema:<string>
additionalItems:
{JSONSchema7Definition}
additionalProperties:
{JSONSchema7Definition}
allOf:
{JSONSchema7Definition[]}
anyOf:
{JSONSchema7Definition[]}
const:
{JSONSchema7Type}
contains:
{JSONSchema7Definition}
contentEncoding:<string>
contentMediaType:<string>
default:
{JSONSchema7Type}
definitions:<object>
dependencies:<object>
description:<string>
else:
{JSONSchema7Definition}
enum:
{JSONSchema7Type[]}
examples:
{JSONSchema7Type}
exclusiveMaximum:<number>
exclusiveMinimum:<number>
format:<string>
if:
{JSONSchema7Definition}
items:
{JSONSchema7Definition|JSONSchema7Definition[]}
maximum:<number>
maxItems:<number>
maxLength:<number>
maxProperties:<number>
minimum:<number>
minItems:<number>
minLength:<number>
minProperties:<number>
multipleOf:<number>
not:
{JSONSchema7Definition}
oneOf:
{JSONSchema7Definition[]}
pattern:<string>
patternProperties:<object>
properties:<object>
propertyNames:
{JSONSchema7Definition}
readOnly:<boolean>
required:<string[]>
then:
{JSONSchema7Definition}
title:<string>
type:
{JSONSchema7TypeName|JSONSchema7TypeName[]}
uniqueItems:<boolean>
writeOnly:<boolean>
  • {Array}
  • [n: {number}] {JSONSchema7Type}
  • [unscopables] <object> Is an object whose properties have the value 'true' when they will be absent when used in a 'with' statement.
  • length <number> Gets or sets the length of the array. This is a number one higher than the highest index in the array.
Returns:
{ArrayIterator }

Iterator

Attributes
index:<number>
The zero-based index of the desired code unit. A negative index will count back from the last item.
Returns:<undefined>

Returns the item located at the specified index.

Call Signature
  • items {ConcatArray[]} Additional arrays and/or items to add to the end of the array.
  • Returns: {JSONSchema7Type[]}

Combines two or more arrays. This method returns a new array without modifying any existing arrays.

Call Signature
  • items {JSONSchema7Type|ConcatArray[]} Additional arrays and/or items to add to the end of the array.
  • Returns: {JSONSchema7Type[]}

Combines two or more arrays. This method returns a new array without modifying any existing arrays.

Attributes
target:<number>
If target is negative, it is treated as length+target where length is the length of the array.
start:<number>
If start is negative, it is treated as length+start. If end is negative, it is treated as length+end.
end:<number>
If not specified, length of the this object is used as its default value.
Returns:<this>

Returns the this object after copying a section of the array identified by start and end to the same array starting at position target

Returns:
{ArrayIterator<Tuple<number, JSONSchema7Type>>}

Returns an iterable of key, value pairs for every entry in the array

Call Signature
Attributes
predicate:<object>
A function that accepts up to three arguments. The every method calls the predicate function for each element in the array until the predicate returns a value which is coercible to the Boolean value false, or until the end of the array.
thisArg:<any>
An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.
Returns:<this>

Determines whether all the members of an array satisfy the specified test.

Call Signature
Attributes
predicate:<object>
A function that accepts up to three arguments. The every method calls the predicate function for each element in the array until the predicate returns a value which is coercible to the Boolean value false, or until the end of the array.
thisArg:<any>
An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.
Returns:<boolean>

Determines whether all the members of an array satisfy the specified test.

  • value {JSONSchema7Type} value to fill array section with
  • start <number> index to start filling the array at. If start is negative, it is treated as length+start where length is the length of the array.
  • end <number> index to stop filling the array at. If end is negative, it is treated as length+end.
  • Returns: <this>

Changes all array elements from start to end index to a static value and returns the modified array

Call Signature
Attributes
predicate:<object>
A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array.
thisArg:<any>
An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.
Returns:
{S[]}

Returns the elements of an array that meet the condition specified in a callback function.

Call Signature
Attributes
predicate:<object>
A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array.
thisArg:<any>
An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.
Returns:
{JSONSchema7Type[]}

Returns the elements of an array that meet the condition specified in a callback function.

Call Signature
Attributes
predicate:<object>
find calls predicate once for each element of the array, in ascending order, until it finds one where predicate returns true. If such an element is found, find immediately returns that element value. Otherwise, find returns undefined.
thisArg:<any>
If provided, it will be used as the this value for each invocation of predicate. If it is not provided, undefined is used instead.
Returns:<undefined>

Returns the value of the first element in the array where predicate is true, and undefined otherwise.

Call Signature
Attributes
predicate:<object>
thisArg:<any>
Returns:<undefined>
Attributes
predicate:<object>
find calls predicate once for each element of the array, in ascending order, until it finds one where predicate returns true. If such an element is found, findIndex immediately returns that element index. Otherwise, findIndex returns -1.
thisArg:<any>
If provided, it will be used as the this value for each invocation of predicate. If it is not provided, undefined is used instead.
Returns:<number>

Returns the index of the first element in the array where predicate is true, and -1 otherwise.

Call Signature
Attributes
predicate:<object>
findLast calls predicate once for each element of the array, in descending order, until it finds one where predicate returns true. If such an element is found, findLast immediately returns that element value. Otherwise, findLast returns undefined.
thisArg:<any>
If provided, it will be used as the this value for each invocation of predicate. If it is not provided, undefined is used instead.
Returns:<undefined>

Returns the value of the last element in the array where predicate is true, and undefined otherwise.

Call Signature
Attributes
predicate:<object>
thisArg:<any>
Returns:<undefined>
Attributes
predicate:<object>
findLastIndex calls predicate once for each element of the array, in descending order, until it finds one where predicate returns true. If such an element is found, findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1.
thisArg:<any>
If provided, it will be used as the this value for each invocation of predicate. If it is not provided, undefined is used instead.
Returns:<number>

Returns the index of the last element in the array where predicate is true, and -1 otherwise.

  • this {A}
  • depth {D} The maximum recursion depth
  • Returns: {FlatArray<A, D>[]}

Returns a new array with all sub-array elements concatenated into it recursively up to the specified depth.

Attributes
callback:<object>
A function that accepts up to three arguments. The flatMap method calls the callback function one time for each element in the array.
thisArg:<This>
An object to which the this keyword can refer in the callback function. If thisArg is omitted, undefined is used as the this value.
Returns:
{U[]}

Calls a defined callback function on each element of an array. Then, flattens the result into a new array. This is identical to a map followed by flat with depth 1.

Attributes
callbackfn:<object>
A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array.
thisArg:<any>
An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
Returns:
{void}

Performs the specified action for each element in an array.

  • searchElement {JSONSchema7Type} The element to search for.
  • fromIndex <number> The position in this array at which to begin searching for searchElement.
  • Returns: <boolean>

Determines whether an array includes a certain element, returning true or false as appropriate.

  • searchElement {JSONSchema7Type} The value to locate in the array.
  • fromIndex <number> The array index at which to begin the search. If fromIndex is omitted, the search starts at index 0.
  • Returns: <number>

Returns the index of the first occurrence of a value in an array, or -1 if it is not present.

Attributes
separator:<string>
A string used to separate one element of the array from the next in the resulting string. If omitted, the array elements are separated with a comma.
Returns:<string>

Adds all the elements of an array into a string, separated by the specified separator string.

Returns:
{ArrayIterator }

Returns an iterable of keys in the array

  • searchElement {JSONSchema7Type} The value to locate in the array.
  • fromIndex <number> The array index at which to begin searching backward. If fromIndex is omitted, the search starts at the last index in the array.
  • Returns: <number>

Returns the index of the last occurrence of a specified value in an array, or -1 if it is not present.

Attributes
callbackfn:<object>
A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.
thisArg:<any>
An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
Returns:
{U[]}

Calls a defined callback function on each element of an array, and returns an array that contains the results.

Returns:<undefined>

Removes the last element from an array and returns it. If the array is empty, undefined is returned and the array is not modified.

  • items {JSONSchema7Type[]} New elements to add to the array.
  • Returns: <number>

Appends new elements to the end of an array, and returns the new length of the array.

Call Signature
Attributes
callbackfn:<object>
A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
Returns:
{JSONSchema7Type}

Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

Call Signature
Attributes
callbackfn:<object>
initialValue:
{JSONSchema7Type}
Returns:
{JSONSchema7Type}
Call Signature
Attributes
callbackfn:<object>
A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
initialValue:
{U} If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
Returns:
{U}

Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

Call Signature
Attributes
callbackfn:<object>
A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.
Returns:
{JSONSchema7Type}

Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

Call Signature
Attributes
callbackfn:<object>
initialValue:
{JSONSchema7Type}
Returns:
{JSONSchema7Type}
Call Signature
Attributes
callbackfn:<object>
A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.
initialValue:
{U} If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
Returns:
{U}

Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

Returns:
{JSONSchema7Type[]}

Reverses the elements in an array in place. This method mutates the array and returns a reference to the same array.

Returns:<undefined>

Removes the first element from an array and returns it. If the array is empty, undefined is returned and the array is not modified.

Attributes
start:<number>
The beginning index of the specified portion of the array. If start is undefined, then the slice begins at index 0.
end:<number>
The end index of the specified portion of the array. This is exclusive of the element at the index 'end'. If end is undefined, then the slice extends to the end of the array.
Returns:
{JSONSchema7Type[]}

Returns a copy of a section of an array. For both start and end, a negative index can be used to indicate an offset from the end of the array. For example, -2 refers to the second to last element of the array.

Attributes
predicate:<object>
A function that accepts up to three arguments. The some method calls the predicate function for each element in the array until the predicate returns a value which is coercible to the Boolean value true, or until the end of the array.
thisArg:<any>
An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.
Returns:<boolean>

Determines whether the specified callback function returns true for any element of an array.

Attributes
compareFn:<object>
Function used to determine the order of the elements. It is expected to return a negative value if the first argument is less than the second argument, zero if they're equal, and a positive value otherwise. If omitted, the elements are sorted in ascending, UTF-16 code unit order.
[11,2,22,1].sort((a, b) => a - b)
Returns:<this>

Sorts an array in place. This method mutates the array and returns a reference to the same array.

Call Signature
Attributes
start:<number>
The zero-based location in the array from which to start removing elements.
deleteCount:<number>
The number of elements to remove. Omitting this argument will remove all elements from the start paramater location to end of the array. If value of this argument is either a negative number, zero, undefined, or a type that cannot be converted to an integer, the function will evaluate the argument as zero and not remove any elements.
Returns:
{JSONSchema7Type[]} An array containing the elements that were deleted.

Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.

Call Signature
Attributes
start:<number>
The zero-based location in the array from which to start removing elements.
deleteCount:<number>
The number of elements to remove. If value of this argument is either a negative number, zero, undefined, or a type that cannot be converted to an integer, the function will evaluate the argument as zero and not remove any elements.
items:
{JSONSchema7Type[]} Elements to insert into the array in place of the deleted elements.
Returns:
{JSONSchema7Type[]} An array containing the elements that were deleted.

Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.

Call Signature
Returns:<string>

Returns a string representation of an array. The elements are converted to string using their toLocaleString methods.

Call Signature
Attributes
locales:<string> | <string[]>
options:
{NumberFormatOptions|DateTimeFormatOptions}
Returns:<string>
Returns:
{JSONSchema7Type[]}

Returns a copy of an array with its elements reversed.

Attributes
compareFn:<object>
Function used to determine the order of the elements. It is expected to return a negative value if the first argument is less than the second argument, zero if they're equal, and a positive value otherwise. If omitted, the elements are sorted in ascending, UTF-16 code unit order.
[11, 2, 22, 1].toSorted((a, b) => a - b) // [1, 2, 11, 22]
Returns:
{JSONSchema7Type[]}

Returns a copy of an array with its elements sorted.

Call Signature
Attributes
start:<number>
The zero-based location in the array from which to start removing elements.
deleteCount:<number>
The number of elements to remove.
items:
{JSONSchema7Type[]} Elements to insert into the copied array in place of the deleted elements.
Returns:
{JSONSchema7Type[]} The copied array.

Copies an array and removes elements and, if necessary, inserts new elements in their place. Returns the copied array.

Call Signature
Attributes
start:<number>
The zero-based location in the array from which to start removing elements.
deleteCount:<number>
The number of elements to remove.
Returns:
{JSONSchema7Type[]} A copy of the original array with the remaining elements.

Copies an array and removes elements while returning the remaining elements.

Returns:<string>

Returns a string representation of an array.

  • items {JSONSchema7Type[]} Elements to insert at the start of the array.
  • Returns: <number>

Inserts new elements at the start of an array, and returns the new length of the array.

Returns:
{ArrayIterator }

Returns an iterable of values in the array

Attributes
index:<number>
The index of the value to overwrite. If the index is negative, then it replaces from the end of the array.
value:
{JSONSchema7Type} The value to write into the copied array.
Returns:
{JSONSchema7Type[]} The copied array with the updated value.

Copies an array, then overwrites the value at the provided index with the given value. If the index is negative, then it replaces from the end of the array.

  • [key: {string}] {JSONSchema7Type}
Attributes
alg:<string>
crv:<string>
d:<string>
dp:<string>
dq:<string>
e:<string>
ext:<boolean>
k:<string>
key_ops:<string[]>
kty:<string>
n:<string>
oth:
{RsaOtherPrimesInfo[]}
p:<string>
q:<string>
qi:<string>
use:<string>
x:<string>
y:<string>
  • {BaseNode}
Attributes
leadingComments:<Comment[]>
loc:<null>
name:<string>
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:
{"JSXIdentifier"}
  • format {"jwk"}
Attributes
name:<string>
Attributes
passphrase:<string>
Optional passphrase.
pem:
{string|Buffer } Private keys in PEM format.
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> ]( /JsonData.html) for json modules
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> ]( /Snapshot.html) | <null> using in ContextModule
strict:<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 hook
  • resolve {AsyncSeriesBailHook<Tuple<ResolveRequest, ResolveContext>, ResolveRequest|null>} resolve hook
  • resolveStep {SyncHook<Tuple<AsyncSeriesBailHook<Tuple<ResolveRequest, ResolveContext>, ResolveRequest|null, UnsetAdditionalOptions>, ResolveRequest>>} resolve step hook
  • result {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> ]( /RequestShortener.html)
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>
id:<string> | <number>
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>
name:<string> | <null>
Attributes
loc:<string>
module:<string>
moduleId:<string> | <number>
moduleIdentifier:<string>
moduleName:<string>
request:<string>
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>
Attributes
cachedGetErrors:<object>
cachedGetWarnings:<object>
compilation:<Compilation>
compilationAuxiliaryFileToChunks:
{Map<string, Chunk[]>}
compilationFileToChunks:
{Map<string, Chunk[]>}
makePathsRelative:<object>
rootModules:
{Set }
runtime:
{RuntimeSpec}
type:<string>
Attributes
debug:<boolean>
entries:<StatsLoggingEntry[]>
filteredEntries:<number>
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>
depth:<number> | <null>
errors:<number>
failed:<boolean>
filteredModules:<number>
id:<string> | <number>
identifier:<string>
index:<number>
index2:<number>
issuer:<string> | <null>
issuerId:<string> | <number> | <null>
issuerName:<string> | <null>
issuerPath:<StatsModuleIssuer[]> | <null>
layer:<string> | <null>
modules:<StatsModule[]>
moduleType:<string>
name:<string>
nameForCondition:<string> | <null>
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
id:<string> | <number>
identifier:<string>
name:<string>
profile:<StatsProfile>
Attributes
active:<boolean>
explanation:<string> | <null>
loc:<string> | <null>
module:<string> | <null>
moduleId:<string> | <number> | <null>
moduleIdentifier:<string> | <null>
moduleName:<string> | <null>
resolvedModule:<string> | <null>
resolvedModuleId:<string> | <number> | <null>
resolvedModuleIdentifier:<string> | <null>
type:<string> | <null>
userRequest:<string> | <null>
Attributes
loc:<string>
Attributes
dependencies:<StatsModuleTraceDependency[]>
moduleId:<string> | <number>
moduleIdentifier:<string>
moduleName:<string>
originId:<string> | <number>
originIdentifier:<string>
originName:<string>
Attributes
bold:<object>
cyan:<object>
green:<object>
magenta:<object>
red:<object>
yellow:<object>
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
formatChunkId:<object>
formatDateTime:<object>
formatError:<object>
formatFilename:<object>
formatFlag:<object>
formatLayer:<object>
formatModuleId:<object>
formatSize:<object>
formatTime:<object>
Attributes
additionalIntegration:<number>
additionalResolving:<number>
building:<number>
dependencies:<number>
factory:<number>
integration:<number>
resolving:<number>
restoring:<number>
storing:<number>
total:<number>
  • factoryMeta {FactoryMeta} factory meta
  • generatorOptions {GeneratorOptions}
  • parserOptions {ParserOptions}
  • resolveOptions <ResolveOptions> resolve options
  • {BaseStatement}
  • body {Statement}
  • label {Identifier}
  • leadingComments <Comment[]>
  • loc <null>
  • range {Tuple<number, number>}
  • trailingComments <Comment[]>
  • type {"LabeledStatement"}
Attributes
<Node>
  • body {Statement}
  • end <number>
  • label {Identifier}
  • loc <null>
  • range {Tuple<number, number>}
  • start <number>
  • type {"LabeledStatement"}

Options for the default backend.

Attributes
client:<string>
A custom client.
listen:<number> | <object>
Specifies where to listen to from the server.
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
backend:<object> | <object>
Specifies the backend that should be used for handling client keep alive.
entries:<boolean>
Enable/disable lazy compilation for entries.
imports:<boolean>
Enable/disable lazy compilation for import() modules.
test:<string> | <RegExp> | <object>
Specify which entrypoints or import()ed modules should be lazily compiled. This is matched with the imported module and not the entrypoint name.
  • [index: {string}] <any>
Attributes
associatedObjectForCache:<object>
object for caching
context:<string>
absolute context path to which lib ident is relative to
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
chunkGraph:<ChunkGraph>
compilation:<Compilation>
options:
{T}

Set explicit comments for commonjs, commonjs2, amd, and root.

Attributes
amd:<string>
Set comment for  amd section in UMD.
commonjs:<string>
Set comment for  commonjs (exports) section in UMD.
commonjs2:<string>
Set comment for  commonjs2 (module.exports) section in UMD.
root:<string>
Set comment for  root (global variable) section in UMD.

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
chunkOverhead:<number>
Constant overhead for a chunk.
entryChunkMultiplicator:<number>
Multiplicator for initial chunks.
maxChunks:<number>
Limit the maximum number of chunks using a value greater than or equal to 1.
  • {Abortable}
Attributes
backlog:<number>
exclusive:<boolean>
host:<string>
ipv6Only:<boolean>
path:<string>
port:<number>
readableAll:<boolean>
reusePort:<boolean>
signal:<AbortSignal>
writableAll:<boolean>
Attributes
<Node>
Attributes
bigint:<string>
end:<number>
loc:<null>
range:
{Tuple<number, number>}
raw:<string>
regex:<object>
start:<number>
type:
{"Literal"}
value:<string> | <number> | <bigint> | <boolean> | <RegExp> | <null>

Custom values available in the loader context.

  • [index: {string}] <any>
Attributes
ident:<string> | <null>
loader:<string>
options:
{string|Record<string, any>|null}
type:<string> | <null>
  • [index: {string}] <any>
Attributes
debug:<boolean>
Whether loaders should be in debug mode or not. debug will be removed as of webpack 3.
minimize:<boolean>
Where loaders can be switched to minimize mode.
options:<object>
A configuration object that can be used to configure older loaders.

These properties are added by the LoaderPlugin

Call Signature
Attributes
request:<string>
options:<undefined>
callback:<object>
Returns:
{void}
Call Signature
Attributes
request:<string>
options:
{ImportModuleOptions}
Returns:
{Promise }
Attributes
request:<string>
callback:<object>
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"}
  • {BaseExpression}
Attributes
leadingComments:<Comment[]>
left:
{Expression}
loc:<null>
operator:
{LogicalOperator}
range:
{Tuple<number, number>}
right:
{Expression}
trailingComments:<Comment[]>
type:
{"LogicalExpression"}
Attributes
<Node>
Attributes
end:<number>
left:
{Expression}
loc:<null>
operator:
{LogicalOperator}
range:
{Tuple<number, number>}
right:
{Expression}
start:<number>
type:
{"LogicalExpression"}
Attributes
address:<string>
A string representation of an IPv4 or IPv6 address.
family:<number>
4 or 6 , denoting the family of address , or 0 if the address is not an IPv4 or IPv6 address. 0 is a likely indicator of a bug in the name resolution service used by the operating system.
Attributes
all:<boolean>
When  true , the callback returns all resolved addresses in an array. Otherwise, returns a single address.
family:<number>
The record family. Must be  4 , 6 , or 0 . For backward compatibility reasons, 'IPv4' and 'IPv6' are interpreted as 4 and 6 respectively. The value 0 indicates that either an IPv4 or IPv6 address is returned. If the value 0 is used with { all: true } (see below) , both IPv4 and IPv6 addresses are returned.
hints:<number>
One or more  supported getaddrinfo flags. Multiple flags may be passed by bitwise OR ing their values.
order:
{"ipv4first"|"ipv6first"|"verbatim"} When  verbatim , the resolved addresses are return unsorted. When ipv4first , the resolved addresses are sorted by placing IPv4 addresses before IPv6 addresses. When ipv6first , the resolved addresses are sorted by placing IPv6 addresses before IPv4 addresses. Default value is configurable using setDefaultResultOrder or --dns-result-order .
verbatim:<boolean>
When  true , the callback receives IPv4 and IPv6 addresses in the order the DNS resolver returned them. When false , IPv4 addresses are placed before IPv6 addresses. This option will be deprecated in favor of order . When both are specified, order has higher precedence. New code should only use order . Default value is configurable using setDefaultResultOrder
  • path {PathLikeFs}
  • callback <object>
  • Returns: {void}
  • path {PathLikeFs}
  • options <undefined>
  • Returns: {IStats}
  • 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}
Attributes
chunk:<Chunk>
the chunk
chunkGraph:<ChunkGraph>
the chunk graph
codeGenerationResults:<CodeGenerationResults>
results of code generation
dependencyTemplates:
[ <DependencyTemplates> ]( /DependencyTemplates.html) the dependency templates
hash:<string>
hash to be used for render call
moduleGraph:<ModuleGraph>
the module graph
runtimeTemplate:
[ <RuntimeTemplate> ]( /RuntimeTemplate.html) the runtime template
strictMode:<boolean>
rendering in strict context
Attributes
mode:<string> | <number>
recursive:<boolean>

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

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
columns:<boolean>
need columns?
module:<boolean>
is module
Attributes
exclude:<string> | <RegExp> | <object> | <string> | <RegExp> | <object[]>
include:<string> | <RegExp> | <object> | <string> | <RegExp> | <object[]>
test:<string> | <RegExp> | <object> | <string> | <RegExp> | <object[]>
Attributes
getContent:<object>
getEndContent:<object>
key:<string>
merge:<object>
mergeAll:<object>
position:<number>
stage:<number>
  • {BaseClass}.{BaseDeclaration}
  • {ClassDeclaration}
  • body {ClassBody}
  • id <null> It is null when a class declaration is a part of the export default class statement
  • leadingComments <Comment[]>
  • loc <null>
  • range {Tuple<number, number>}
  • superClass <null>
  • trailingComments <Comment[]>
  • type {"ClassDeclaration"}
  • {BaseFunction}.{BaseDeclaration}
  • {FunctionDeclaration}
Attributes
async:<boolean>
body:
{BlockStatement}
generator:<boolean>
id:<null>
It is null when a function declaration is a part of the  export default function statement
leadingComments:<Comment[]>
loc:<null>
params:
{Pattern[]}
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:
{"FunctionDeclaration"}
  • {BaseExpression}.{BasePattern}
Attributes
computed:<boolean>
leadingComments:<Comment[]>
loc:<null>
object:
{Expression|Super}
optional:<boolean>
property:
{Expression|PrivateIdentifier}
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:
{"MemberExpression"}
Attributes
<Node>
Attributes
computed:<boolean>
end:<number>
loc:<null>
object:
{Expression|Super}
optional:<boolean>
property:
{Expression|PrivateIdentifier}
range:
{Tuple<number, number>}
start:<number>
type:
{"MemberExpression"}
Attributes
stage:<number>
Specifies the stage for merging duplicate chunks.
  • {BaseExpression}
Attributes
leadingComments:<Comment[]>
loc:<null>
meta:
{Identifier}
property:
{Identifier}
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:
{"MetaProperty"}
Attributes
<Node>
Attributes
end:<number>
loc:<null>
meta:
{Identifier}
property:
{Identifier}
range:
{Tuple<number, number>}
start:<number>
type:
{"MetaProperty"}
  • {BaseNode}
Attributes
computed:<boolean>
key:
{Expression|PrivateIdentifier}
kind:
{"set"|"get"|"method"|"constructor"}
leadingComments:<Comment[]>
loc:<null>
range:
{Tuple<number, number>}
static:<boolean>
trailingComments:<Comment[]>
type:
{"MethodDefinition"}
value:
{FunctionExpression}
Attributes
<Node>
Attributes
computed:<boolean>
end:<number>
key:
{Expression|PrivateIdentifier}
kind:
{"set"|"get"|"method"|"constructor"}
loc:<null>
range:
{Tuple<number, number>}
start:<number>
static:<boolean>
type:
{"MethodDefinition"}
value:
{FunctionExpression}
Attributes
chunkOverhead:<number>
Constant overhead for a chunk.
entryChunkMultiplicator:<number>
Multiplicator for initial chunks.
minChunkSize:<number>
Minimum number of characters.
  • file {PathLikeFs}
  • callback <object>
  • Returns: {void}
  • inheritance {Tuple<CssLayer, Supports, Media>[]} - The inheritance chain
  • source <CachedSource> - The cached source
  • undoPath <string> - The undo path to the CSS file
Attributes
context:<string>
contextInfo:
{ModuleFactoryCreateDataContextInfo}
dependencies:<Dependency[]>
resolveOptions:<ResolveOptions>
Attributes
compiler:<string>
issuer:<string>
issuerLayer:
{IssuerLayer}
Attributes
cacheable:<boolean>
allow to use the unsafe cache
contextDependencies:
{Set }
fileDependencies:
{Set }
missingDependencies:
{Set }
module:<Module>
the created module or unset if no module was created
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.
noParse:<string> | <RegExp> | <object> | <string> | <RegExp> | <object[]>
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.
unsafeCache:<boolean> | <object>
Cache the resolving of module requests.
Attributes
hash:<string>
hashWithLength:<object>
id:<string> | <number>
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> ]( /DependencyTemplates.html) the dependency templates
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 false
moduleGraph:<ModuleGraph>
the module graph
renderInObject:<boolean>
render module in object container
runtimeTemplate:
[ <RuntimeTemplate> ]( /RuntimeTemplate.html) the runtime template
strictMode:<boolean>
rendering in strict context
Attributes
active:<boolean>
client:<string>
data:<string>
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
module:<Module>
origin:<Module>
Attributes
context:<string>
context
delimiter:<string>
delimiter
Attributes
context:<string>
context
Attributes
compilation:<Compilation>
fileSystemInfo:
[ <FileSystemInfo> ]( /FileSystemInfo.html)
valueCacheVersions:
{Map<string, ValueCacheVersion>}
  • {BaseCallExpression}
  • arguments {Expression|SpreadElement[]}
  • callee {Expression|Super}
  • leadingComments <Comment[]>
  • loc <null>
  • range {Tuple<number, number>}
  • trailingComments <Comment[]>
  • type {"NewExpression"}
Attributes
<Node>
  • arguments {Expression|SpreadElement[]}
  • callee {Expression}
  • end <number>
  • loc <null>
  • range {Tuple<number, number>}
  • start <number>
  • type {"NewExpression"}
  • {Program}
  • {Identifier}
  • {Literal}
  • {ThisExpression}
  • {ArrayExpression}
  • {ObjectExpression}
  • {UnaryExpression}
  • {UpdateExpression}
  • {BinaryExpression}
  • {AssignmentExpression}
  • {LogicalExpression}
  • {MemberExpression}
  • {ConditionalExpression}
  • {CallExpression}
  • {NewExpression}
  • {SequenceExpression}
  • {YieldExpression}
  • {TemplateLiteral}
  • {TaggedTemplateExpression}
  • {MetaProperty}
  • {AwaitExpression}
  • {ChainExpression}
  • {ImportExpression}
  • {ParenthesizedExpression}
  • {ExpressionStatement}
  • {BlockStatement}
  • {EmptyStatement}
  • {DebuggerStatement}
  • {WithStatement}
  • {ReturnStatement}
  • {LabeledStatement}
  • {BreakStatement}
  • {ContinueStatement}
  • {IfStatement}
  • {SwitchStatement}
  • {ThrowStatement}
  • {TryStatement}
  • {WhileStatement}
  • {DoWhileStatement}
  • {ForStatement}
  • {ForInStatement}
  • {ForOfStatement}
  • {ImportDeclaration}
  • {ExportNamedDeclaration}
  • {ExportDefaultDeclaration}
  • {ExportAllDeclaration}
  • {SpreadElement}
  • {Property}
  • <Function>
  • {PrivateIdentifier}
  • {Super}
  • {TemplateElement}
  • {Class}
  • {ClassBody}
  • {SwitchCase}
  • {CatchClause}
  • {VariableDeclaration}
  • {ImportSpecifier}
  • {ImportDefaultSpecifier}
  • {ImportNamespaceSpecifier}
  • {ImportAttribute}
  • {ExportSpecifier}
  • {ObjectPattern}
  • {ArrayPattern}
  • {RestElement}
  • {AssignmentPattern}
  • {MethodDefinition}
  • {PropertyDefinition}
  • {StaticBlock}
  • {VariableDeclarator}
  • {AssignmentProperty}
Attributes
end:<number>
loc:<null>
range:
{Tuple<number, number>}
start:<number>
type:<string>
  • infrastructureLogging {InfrastructureLogging} infrastructure logging options
  • AssignmentProperty {AssignmentProperty}
  • CatchClause {CatchClause}
  • Class {Class}
  • ClassBody {ClassBody}
  • Expression {Expression}
  • Function <Function>
  • Identifier {Identifier}
  • Literal {Literal}
  • MethodDefinition {MethodDefinition}
  • ModuleDeclaration {ModuleDeclaration}
  • ModuleSpecifier {ModuleSpecifier}
  • Pattern {Pattern}
  • PrivateIdentifier {PrivateIdentifier}
  • Program {Program}
  • Property {Property}
  • PropertyDefinition {PropertyDefinition}
  • SpreadElement {SpreadElement}
  • Statement {Statement}
  • Super {Super}
  • SwitchCase {SwitchCase}
  • TemplateElement {TemplateElement}
  • VariableDeclarator {VariableDeclarator}

Options object for node compatibility features.

Attributes
__dirname:<boolean>
Include a polyfill for the '__dirname' variable.
__filename:<boolean>
Include a polyfill for the '__filename' variable.
global:<boolean>
Include a polyfill for the 'global' variable.
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>
fs:<InputFileSystem>
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
name:<string>
content:
{string|Buffer }
sourceMap:<string>
assetInfo:<AssetInfo>
Returns:
{void}
Attributes
warning:<Error>
Returns:
{void}
Attributes
name:<string>
Returns:
[ <WebpackLogger> ]( /WebpackLogger.html)
Call Signature
Returns:
{OptionsType}
Call Signature
  • schema {Schema}
  • Returns: {OptionsType}
  • options {ResolveOptionsWithDependencyType}
  • Returns: <object>
Attributes
context:<string>
request:<string>
callback:<object>
Returns:
{void}
  • [index: {string}] <any>
Attributes
encoding:<null>
  • {BaseExpression}
Attributes
leadingComments:<Comment[]>
loc:<null>
properties:
{Property|SpreadElement[]}
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:
{"ObjectExpression"}
Attributes
<Node>
Attributes
end:<number>
loc:<null>
properties:
{SpreadElement|Property[]}
range:
{Tuple<number, number>}
start:<number>
type:
{"ObjectExpression"}
  • {BasePattern}
Attributes
leadingComments:<Comment[]>
loc:<null>
properties:
{AssignmentProperty|RestElement[]}
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:
{"ObjectPattern"}
Attributes
<Node>
Attributes
end:<number>
loc:<null>
properties:
{RestElement|AssignmentProperty[]}
range:
{Tuple<number, number>}
start:<number>
type:
{"ObjectPattern"}
Attributes
deserialize:<object>
serialize:<object>
Attributes
currentPos:<number>
currentPosTypeLookup:<number>
cycleStackSize:<number>
length:<number>
objectTypeLookupSize:<number>
referenceableSize:<number>
Attributes
prioritiseInitial:<boolean>
Prioritise initial size over total size.
Attributes
prioritiseInitial:<boolean>
Prioritise initial size over total size.
Attributes
safeTime:<number>
  • buffer {Uint8Array|object}
Attributes
bytesWritten:<number>
buffer:<Uint8Array>
Returns:<boolean>

This function is called for every chunk of incoming data. Two arguments are passed to it: the number of bytes written to buffer and a reference to buffer. Return false from this function to implicitly pause() the socket.

  • 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.
runtimeChunk:<boolean> | <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).

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.
chunks:<RegExp> | <object>
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.
enforceSizeThreshold:<number> | <object>
Size threshold at which splitting is enforced and other restrictions (minRemainingSize, maxAsyncRequests, maxInitialRequests) are ignored.
filename:<string> | <object>
Sets the template for the filename for created chunks.
idHint:<string>
Sets the hint for chunk id.
layer:<string> | <RegExp> | <object>
Assign modules to a cache group by module layer.
maxAsyncRequests:<number>
Maximum number of requests which are accepted for on-demand loading.
maxAsyncSize:<number> | <object>
Maximal size hint for the on-demand chunks.
maxInitialRequests:<number>
Maximum number of initial chunks which are accepted for an entry point.
maxInitialSize:<number> | <object>
Maximal size hint for the initial chunks.
maxSize:<number> | <object>
Maximal size hint for the created chunks.
minChunks:<number>
Minimum number of times a module has to be duplicated until it's considered for splitting.
minRemainingSize:<number> | <object>
Minimal size for the chunks the stay after moving the modules to a new chunk.
minSize:<number> | <object>
Minimal size for the created chunk.
minSizeReduction:<number> | <object>
Minimum size reduction due to the created chunk.
name:<string> | <object>
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.
test:<string> | <RegExp> | <object>
Assign modules to a cache group by module name.
type:<string> | <RegExp> | <object>
Assign modules to a cache group by module type.
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').
chunks:<RegExp> | <object>
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.
enforceSizeThreshold:<number> | <object>
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.
filename:<string> | <object>
Sets the template for the filename for created chunks.
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.
maxAsyncSize:<number> | <object>
Maximal size hint for the on-demand chunks.
maxInitialRequests:<number>
Maximum number of initial chunks which are accepted for an entry point.
maxInitialSize:<number> | <object>
Maximal size hint for the initial chunks.
maxSize:<number> | <object>
Maximal size hint for the created chunks.
minChunks:<number>
Minimum number of times a module has to be duplicated until it's considered for splitting.
minRemainingSize:<number> | <object>
Minimal size for the chunks the stay after moving the modules to a new chunk.
minSize:<number> | <object>
Minimal size for the created chunks.
minSizeReduction:<number> | <object>
Minimum size reduction due to the created chunk.
name:<string> | <object>
Give chunks created a name (chunks with equal name are merged).
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
Attributes
allowAwaitOutsideFunction:<boolean>
By default,  await identifiers are allowed to appear at the top-level scope only if ecmaVersion >= 2022. When enabled, await identifiers are allowed to appear at the top-level scope, but they are still not allowed in non-async functions.
allowHashBang:<boolean>
When enabled, hashbang directive in the beginning of file is allowed and treated as a line comment. Enabled by default when  ecmaVersion >= 2023.
allowImportExportEverywhere:<boolean>
When enabled, import/export statements are not constrained to appearing at the top of the program, and an import.meta expression in a script isn't considered an error.
allowReserved:<boolean>
By default, reserved words are only enforced if ecmaVersion >= 5. Set  allowReserved to a boolean value to explicitly turn this on an off. When this option has the value "never", reserved words and keywords can also not be used as property names.
allowReturnOutsideFunction:<boolean>
When enabled, a return at the top level is not considered an error.
allowSuperOutsideMethod:<boolean>
When enabled, super identifiers are not constrained to appearing in methods and do not raise an error when they appear elsewhere.
checkPrivateFields:<boolean>
By default, the parser will verify that private properties are only used in places where they are valid and have been declared. Set this to false to turn such checks off.
directSourceFile:<string>
This value, if given, is stored in every node, whether  locations is on or off.
ecmaVersion:
{ecmaVersion}  ecmaVersion indicates the ECMAScript version to parse. Can be a number, either in year ( 2022 ) or plain version number ( 6 ) form, or "latest" (the latest the library supports). This influences support for strict mode, the set of reserved words, and support for new syntax features.
locations:<boolean>
When  locations is on, loc properties holding objects with start and end properties as Position objects will be attached to the nodes.
onComment:<object> | <Comment[]>
This takes a export function or an array.

When a export function is passed, Acorn will call that export function with (block, text, start, end) parameters whenever a comment is skipped. block is a boolean indicating whether this is a block (/* */) comment, text is the content of the comment, and start and end are character offsets that denote the start and end of the comment. When the locations option is on, two more parameters are passed, the full locations of Position export type of the start and end of the comments.

When a array is passed, each found comment of Comment export type is pushed to the array.

Note that you are not allowed to call the parser from the callback—that will corrupt its internal state.

Attributes
onInsertedSemicolon:<object>
a callback that will be called when a semicolon is automatically inserted.
onToken:<object>
| [ <Token[]> ]( /Token.html) a callback that will cause Acorn to call that export function with object in the same format as tokens returned from  tokenizer().getToken() . Note that you are not allowed to call the parser from the callback—that will corrupt its internal state.
onTrailingComma:<object>
similar to  onInsertedSemicolon , but for trailing commas
preserveParens:<boolean>
When enabled, parenthesized expressions are represented by (non-standard) ParenthesizedExpression nodes
program:<Node>
It is possible to parse multiple files into a single AST by passing the tree produced by parsing the first file as  program option in subsequent parses. This will add the toplevel forms of the parsed file to the Program (top) node of an existing parse tree.
ranges:<boolean>
Nodes have their start and end characters offsets recorded in  start and end properties (directly on the node, rather than the loc object, which holds line/column data. To also add a [semi-standardized][range] range property holding a [start, end] array with the same numbers, set the ranges option to true .
sourceFile:<string>
When  locations is on, you can pass this to record the source file in every node's loc object.
sourceType:
{"module"|"commonjs"|"script"}  sourceType indicates the mode the code should be parsed in. Can be either "script" , "module" or "commonjs" . This influences global strict mode and parsing of import and export declarations.
  • {Dict}
Attributes
accept:<string> | <string[]>
accept-charset:<string> | <string[]>
accept-encoding:<string> | <string[]>
accept-language:<string> | <string[]>
accept-ranges:<string>
access-control-allow-credentials:<string>
access-control-allow-headers:<string>
access-control-allow-methods:<string>
access-control-allow-origin:<string>
access-control-expose-headers:<string>
access-control-max-age:<string>
access-control-request-headers:<string>
access-control-request-method:<string>
age:<string>
allow:<string>
authorization:<string>
cache-control:<string>
cdn-cache-control:<string>
connection:<string> | <string[]>
content-disposition:<string>
content-encoding:<string>
content-language:<string>
content-length:<string> | <number>
content-location:<string>
content-range:<string>
content-security-policy:<string>
content-security-policy-report-only:<string>
content-type:<string>
cookie:<string> | <string[]>
date:<string>
dav:<string> | <string[]>
dnt:<string>
etag:<string>
expect:<string>
expires:<string>
forwarded:<string>
from:<string>
host:<string>
if-match:<string>
if-modified-since:<string>
if-none-match:<string>
if-range:<string>
if-unmodified-since:<string>
last-modified:<string>
link:<string> | <string[]>
location:<string>
max-forwards:<string>
origin:<string>
pragma:<string> | <string[]>
proxy-authenticate:<string> | <string[]>
proxy-authorization:<string>
public-key-pins:<string>
public-key-pins-report-only:<string>
range:<string>
referer:<string>
referrer-policy:<string>
refresh:<string>
retry-after:<string>
sec-websocket-accept:<string>
sec-websocket-extensions:<string> | <string[]>
sec-websocket-key:<string>
sec-websocket-protocol:<string> | <string[]>
sec-websocket-version:<string>
server:<string>
set-cookie:<string> | <string[]>
strict-transport-security:<string>
te:<string>
trailer:<string>
transfer-encoding:<string>
upgrade:<string>
upgrade-insecure-requests:<string>
user-agent:<string>
vary:<string>
via:<string> | <string[]>
warning:<string>
www-authenticate:<string> | <string[]>
x-content-type-options:<string>
x-dns-prefetch-control:<string>
x-frame-options:<string>
x-xss-protection:<string>
  • [<WritableEventMap>](/Stream.html#interface-writableeventmap)
  • close {Tuple}
  • drain {Tuple}
  • error {Tuple}
  • finish {Tuple}
  • pipe {Tuple}
  • prefinish {Tuple}
  • unpipe {Tuple}

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> | <object>
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.
chunkFilename:<string> | <object>
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.
cssChunkFilename:<string> | <object>
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> | <object>
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> | <object>
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> ]( /Hash.html) 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.
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.
publicPath:<string> | <object>
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
assetModuleFilename:<string> | <object>
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.
chunkFilename:<string> | <object>
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.
cssChunkFilename:<string> | <object>
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> | <object>
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> | <object>
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> ]( /Hash.html) 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.
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.
publicPath:<string> | <object>
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
<Node>
Attributes
end:<number>
expression:
{Expression}
loc:<null>
range:
{Tuple<number, number>}
start:<number>
type:
{"ParenthesizedExpression"}
Attributes
directory:<boolean>
is directory
file:<boolean>
is file
fragment:<string>
fragment
internal:<boolean>
is internal
module:<boolean>
is module
query:<string>
query
request:<string>
request
Attributes
allowHashBang:<boolean>
allowReturnOutsideFunction:<boolean>
comments:<boolean>
ecmaVersion:
{ecmaVersion}
locations:<boolean>
ranges:<boolean>
semicolons:<boolean>
sourceType:
{"module"|"script"}
  • ast {Program}
  • comments {CommentJavascriptParser[]}
  • semicolons {Set}
  • [index: {string}] <any>

Specify options for each parser.

Attributes
compilation:<Compilation>
current:<NormalModule>
module:<NormalModule>
options:
{WebpackOptionsNormalizedWithDefaults}
source:
{string|Buffer }
  • {DetailedPeerCertificate}
Attributes
asn1Curve:<string>
The ASN.1 name of the OID of the elliptic curve. Well-known curves are identified by an OID. While it is unusual, it is possible that the curve is identified by its mathematical properties, in which case it will not have an OID.
bits:<number>
For RSA keys: The RSA bit size.

For EC keys: The key size in bits.

Attributes
ca:<boolean>
true if a Certificate Authority (CA), false otherwise.
exponent:<string>
The RSA exponent, as a string in hexadecimal number notation.
ext_key_usage:<string[]>
The extended key usage, a set of OIDs.
fingerprint:<string>
The SHA-1 digest of the DER encoded certificate. It is returned as a  : separated hexadecimal string.
fingerprint256:<string>
The SHA-256 digest of the DER encoded certificate. It is returned as a  : separated hexadecimal string.
fingerprint512:<string>
The SHA-512 digest of the DER encoded certificate. It is returned as a  : separated hexadecimal string.
infoAccess:
{Dict<string[]>} An array describing the AuthorityInfoAccess, used with OCSP.
issuer:
{Certificate} The certificate issuer, described in the same terms as the  subject .
modulus:<string>
The RSA modulus, as a hexadecimal string.
nistCurve:<string>
The NIST name for the elliptic curve, if it has one (not all well-known curves have been assigned names by NIST).
pubkey:
{NonSharedBuffer} The public key.
raw:
{NonSharedBuffer} The DER encoded X.509 certificate data.
serialNumber:<string>
The certificate serial number, as a hex string.
subject:
{Certificate} The certificate subject.
subjectaltname:<string>
A string containing concatenated names for the subject, an alternative to the  subject names.
valid_from:<string>
The date-time the certificate is valid from.
valid_to:<string>
The date-time the certificate is valid to.

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
end:<boolean>
End the writer when the reader ends.
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:<boolean> | <null>
node platform, require of node built-in modules is available
nwjs:<boolean> | <null>
nwjs platform, require of legacy nw.gui is available
web:<boolean> | <null>
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>
0-based
line:<number>
1-based
Attributes
column:<number>
>= 0
line:<number>
>= 1
Attributes
column:<number>
line:<number>
  • [index: {string}] <any>
Attributes
content:<string>
element:<string>
  • {BaseNode}
Attributes
leadingComments:<Comment[]>
loc:<null>
name:<string>
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:
{"PrivateIdentifier"}
Attributes
<Node>
Attributes
end:<number>
loc:<null>
name:<string>
range:
{Tuple<number, number>}
start:<number>
type:
{"PrivateIdentifier"}
Attributes
cipher:<string>
format:
{"pem"|"der"}
passphrase:
{string|Buffer }
type:
{T}
Attributes
additionalAssets:<boolean> | <object>
Attributes
outputPath:<string>
Path to the output file e.g.  path.resolve(__dirname, 'profiling/events.json') . Defaults to events.json .
  • {BaseNode}
  • body {ModuleDeclaration|Statement|Directive[]}
  • comments <Comment[]>
  • leadingComments <Comment[]>
  • loc <null>
  • range {Tuple<number, number>}
  • sourceType {"module"|"script"}
  • trailingComments <Comment[]>
  • type {"Program"}
Attributes
<Node>
  • body {Statement|ModuleDeclaration[]}
  • end <number>
  • loc <null>
  • range {Tuple<number, number>}
  • sourceType {"module"|"script"}
  • start <number>
  • type {"Program"}

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.
profile:<boolean> | <null>
Collect profile data for progress steps. Default: false.
Attributes
onfulfilled:<object> | <null>
The callback to execute when the Promise is resolved.
onrejected:<object> | <null>
The callback to execute when the Promise is rejected.
Returns:
{PromiseLike<TResult1|TResult2>} A Promise for the completion of which ever callback is executed.

Attaches callbacks for the resolution and/or rejection of the Promise.

  • {BaseNode}
  • {AssignmentProperty}
Attributes
computed:<boolean>
key:
{Expression}
kind:
{"init"|"set"|"get"}
leadingComments:<Comment[]>
loc:<null>
method:<boolean>
range:
{Tuple<number, number>}
shorthand:<boolean>
trailingComments:<Comment[]>
type:
{"Property"}
value:
{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|ObjectPattern|ArrayPattern|RestElement|AssignmentPattern}
Attributes
<Node>
Attributes
computed:<boolean>
end:<number>
key:
{Expression}
kind:
{"init"|"set"|"get"}
loc:<null>
method:<boolean>
range:
{Tuple<number, number>}
shorthand:<boolean>
start:<number>
type:
{"Property"}
value:
{Expression}
  • {BaseNode}
Attributes
computed:<boolean>
key:
{Expression|PrivateIdentifier}
leadingComments:<Comment[]>
loc:<null>
range:
{Tuple<number, number>}
static:<boolean>
trailingComments:<Comment[]>
type:
{"PropertyDefinition"}
value:<null>
Attributes
<Node>
Attributes
computed:<boolean>
end:<number>
key:
{Expression|PrivateIdentifier}
loc:<null>
range:
{Tuple<number, number>}
start:<number>
static:<boolean>
type:
{"PropertyDefinition"}
value:<null>

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.

  • format {"pem"|"der"}
  • type {T}
  • buf {string|Buffer} PFX or PKCS12 encoded private key and certificate chain.
  • passphrase <string> Optional passphrase.
Attributes
highWaterMark:<number>
size:
{QueuingStrategySize }
  • fetchPriority {"auto"|"low"|"high"}
  • prefetchOrder <number>
  • preloadOrder <number>
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
fd:<number>
buffer:
{TBuffer}
offset:<number>
length:<number>
position:<number> | <bigint> | <null>
callback:<object>
Returns:
{void}
Attributes
fd:<number>
options:
{ReadAsyncOptions }
callback:<object>
Returns:
{void}
Attributes
fd:<number>
callback:<object>
Returns:
{void}
Attributes
byobRequest:<ReadableStreamBYOBRequest> | <null>
desiredSize:<number> | <null>
Returns:
{void}
  • chunk {NonSharedArrayBufferView}
  • Returns: {void}
Attributes
e:<any>
Returns:
{void}
Attributes
destroyOnReturn:<boolean>
When set to  false , calling return on the async iterator, or exiting a for await...of iteration using a break , return , or throw will not destroy the stream.
  • {Abortable}
  • [<ArrayOptions>](/Stream.html#interface-arrayoptions)
Attributes
concurrency:<number>
The maximum concurrent invocations of  fn to call on the stream at once.
highWaterMark:<number>
How many items to buffer while waiting for user consumption of the output.
signal:<AbortSignal>
  • {StreamOptions}
  • [<DuplexOptions>](/Stream.html#interface-duplexoptions)
Attributes
autoDestroy:<boolean>
construct:<object>
destroy:<object>
emitClose:<boolean>
encoding:
{BufferEncoding}
highWaterMark:<number>
objectMode:<boolean>
read:<object>
signal:<AbortSignal>
  • [<EventEmitter>](/EventEmitter-1.html)
  • {ReadWriteStream}
Attributes
readable:<boolean>
Returns:
{AsyncIterableIterator<string|Buffer >}
Attributes
error:<Error>
event:<string> | <symbol>
args:<any[]>
Returns:
{void}

The Symbol.for('nodejs.rejection') method is called in case a promise rejection happens when emitting an event and captureRejections is enabled on the emitter. It is possible to use events.captureRejectionSymbol in place of Symbol.for('nodejs.rejection').

import { EventEmitter, captureRejectionSymbol } from 'node:events';

class MyClass extends EventEmitter {
  constructor() {
    super({ captureRejections: true });
  }

  [captureRejectionSymbol](err, event, ...args) {
    console.log('rejection happened for', event, 'with', err, ...args);
    this.destroy(err);
  }

  destroy(err) {
    // Tear the resource down here.
  }
}
JavaScript
Attributes
eventName:<string> | <symbol>
listener:<object>
Returns:<this>

Alias for emitter.on(eventName, listener).

Attributes
eventName:<string> | <symbol>
args:<any[]>
Returns:<boolean>

Synchronously calls each of the listeners registered for the event named eventName, in the order they were registered, passing the supplied arguments to each.

Returns true if the event had listeners, false otherwise.

import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();

// First listener
myEmitter.on('event', function firstListener() {
  console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
  console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
  const parameters = args.join(', ');
  console.log(`event with parameters ${parameters} in third listener`);
});

console.log(myEmitter.listeners('event'));

myEmitter.emit('event', 1, 2, 3, 4, 5);

// Prints:
// [
//   [Function: firstListener],
//   [Function: secondListener],
//   [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener
JavaScript
Returns:<string> | <symbol[]>

Returns an array listing the events for which the emitter has registered listeners.

import { EventEmitter } from 'node:events';

const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});

const sym = Symbol('symbol');
myEE.on(sym, () => {});

console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]
JavaScript
Returns:<number>

Returns the current max listener value for the EventEmitter which is either set by emitter.setMaxListeners(n) or defaults to events.defaultMaxListeners.

Returns:<boolean>
Attributes
eventName:<string> | <symbol>
The name of the event being listened for
listener:<object>
The event handler function
Returns:<number>

Returns the number of listeners listening for the event named eventName. If listener is provided, it will return how many times the listener is found in the list of the listeners of the event.

Attributes
eventName:<string> | <symbol>
Returns:<object[]>

Returns a copy of the array of listeners for the event named eventName.

server.on('connection', (stream) => {
  console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]
JavaScript
Attributes
eventName:<string> | <symbol>
listener:<object>
Returns:<this>

Alias for emitter.removeListener().

Attributes
eventName:<string> | <symbol>
The name of the event.
listener:<object>
The callback function
Returns:<this>

Adds the listener function to the end of the listeners array for the event named eventName. No checks are made to see if the listener has already been added. Multiple calls passing the same combination of eventName and listener will result in the listener being added, and called, multiple times.

server.on('connection', (stream) => {
  console.log('someone connected!');
});
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

By default, event listeners are invoked in the order they are added. The emitter.prependListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
JavaScript
Attributes
eventName:<string> | <symbol>
The name of the event.
listener:<object>
The callback function
Returns:<this>

Adds a one-time listener function for the event named eventName. The next time eventName is triggered, this listener is removed and then invoked.

server.once('connection', (stream) => {
  console.log('Ah, we have our first user!');
});
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

By default, event listeners are invoked in the order they are added. The emitter.prependOnceListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
JavaScript
Returns:<this>
  • destination {T}
  • options <object>
  • Returns: {T}
Attributes
eventName:<string> | <symbol>
The name of the event.
listener:<object>
The callback function
Returns:<this>

Adds the listener function to the beginning of the listeners array for the event named eventName. No checks are made to see if the listener has already been added. Multiple calls passing the same combination of eventName and listener will result in the listener being added, and called, multiple times.

server.prependListener('connection', (stream) => {
  console.log('someone connected!');
});
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

Attributes
eventName:<string> | <symbol>
The name of the event.
listener:<object>
The callback function
Returns:<this>

Adds a one-time listener function for the event named eventName to the beginning of the listeners array. The next time eventName is triggered, this listener is removed, and then invoked.

server.prependOnceListener('connection', (stream) => {
  console.log('Ah, we have our first user!');
});
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

Attributes
eventName:<string> | <symbol>
Returns:<object[]>

Returns a copy of the array of listeners for the event named eventName, including any wrappers (such as those created by .once()).

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));

// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];

// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();

// Logs "log once" to the console and removes the listener
logFnWrapper();

emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');

// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');
JavaScript
Attributes
size:<number>
Returns:
{string|Buffer }
Attributes
eventName:<string> | <symbol>
Returns:<this>

Removes all listeners, or those of the specified eventName.

It is bad practice to remove listeners added elsewhere in the code, particularly when the EventEmitter instance was created by some other component or module (e.g. sockets or file streams).

Returns a reference to the EventEmitter, so that calls can be chained.

Attributes
eventName:<string> | <symbol>
listener:<object>
Returns:<this>

Removes the specified listener from the listener array for the event named eventName.

const callback = (stream) => {
  console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);
JavaScript

removeListener() will remove, at most, one instance of a listener from the listener array. If any single listener has been added multiple times to the listener array for the specified eventName, then removeListener() must be called multiple times to remove each instance.

Once an event is emitted, all listeners attached to it at the time of emitting are called in order. This implies that any removeListener() or removeAllListeners() calls after emitting and before the last listener finishes execution will not remove them from emit() in progress. Subsequent events behave as expected.

import { EventEmitter } from 'node:events';
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();

const callbackA = () => {
  console.log('A');
  myEmitter.removeListener('event', callbackB);
};

const callbackB = () => {
  console.log('B');
};

myEmitter.on('event', callbackA);

myEmitter.on('event', callbackB);

// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
//   A
//   B

// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
//   A
JavaScript

Because listeners are managed using an internal array, calling this will change the position indexes of any listener registered after the listener being removed. This will not impact the order in which listeners are called, but it means that any copies of the listener array as returned by the emitter.listeners() method will need to be recreated.

When a single function has been added as a handler multiple times for a single event (as in the example below), removeListener() will remove the most recently added instance. In the example the once('ping') listener is removed:

import { EventEmitter } from 'node:events';
const ee = new EventEmitter();

function pong() {
  console.log('pong');
}

ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);

ee.emit('ping');
ee.emit('ping');
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

Returns:<this>
  • encoding {BufferEncoding}
  • Returns: <this>
Attributes
n:<number>
Returns:<this>

By default EventEmitters will print a warning if more than 10 listeners are added for a particular event. This is a useful default that helps finding memory leaks. The emitter.setMaxListeners() method allows the limit to be modified for this specific EventEmitter instance. The value can be set to Infinity (or 0) to indicate an unlimited number of listeners.

Returns a reference to the EventEmitter, so that calls can be chained.

Attributes
destination:<WritableStream>
Returns:<this>
  • chunk {string|Uint8Array}
  • encoding {BufferEncoding}
  • Returns: {void}
Attributes
oldStream:<ReadableStream>
Returns:<this>
Attributes
locked:<boolean>
  • options {ReadableStreamIteratorOptions}
  • Returns: {ReadableStreamAsyncIterator}
Attributes
reason:<any>
Returns:
{Promise }
Call Signature
Attributes
options:<object>
Returns:<ReadableStreamBYOBReader>
Call Signature
Returns:
{ReadableStreamDefaultReader }
Call Signature
  • options {ReadableStreamGetReaderOptions}
  • Returns: {ReadableStreamReader}
  • transform {ReadableWritablePair<T, R>}
  • options {StreamPipeOptions}
  • Returns: {ReadableStream}
  • destination {WritableStream}
  • options {StreamPipeOptions}
  • Returns: {Promise}
Returns:
{Tuple<ReadableStream , ReadableStream >}
  • options {ReadableStreamIteratorOptions}
  • Returns: {ReadableStreamAsyncIterator}
  • {AsyncIterator[<<T, NodeJS.BuiltinIteratorReturn, unknown>>](<T, NodeJS.html#class-t-nodejsbuiltiniteratorreturn-unknown)}
Returns:
{PromiseLike }
Returns:
{ReadableStreamAsyncIterator }
  • __namedParameters {Tuple|Tuple}
  • Returns: {Promise<IteratorResult<T, undefined>>}
  • value {PromiseLike}
  • Returns: {Promise<IteratorResult<T, undefined>>}
Attributes
e:<any>
Returns:
{Promise<IteratorResult<T, undefined>>}
  • {ReadableStreamGenericReader}
  • closed {Promise}
Attributes
reason:<any>
Returns:
{Promise }
  • view {T}
  • options {ReadableStreamBYOBReaderReadOptions}
  • Returns: {Promise<ReadableStreamReadResult>}
Returns:
{void}
Attributes
min:<number>
Attributes
view:<null>
Attributes
bytesWritten:<number>
Returns:
{void}
  • view {NonSharedArrayBufferView}
  • Returns: {void}
Attributes
desiredSize:<number> | <null>
Returns:
{void}
  • chunk {R}
  • Returns: {void}
Attributes
e:<any>
Returns:
{void}
  • {ReadableStreamGenericReader}
  • closed {Promise}
Attributes
reason:<any>
Returns:
{Promise }
Returns:
{Promise<ReadableStreamReadResult >}
Returns:
{void}
Attributes
<ReadableStreamBYOBReader>
<ReadableStreamDefaultReader>
  • closed {Promise}
Attributes
reason:<any>
Returns:
{Promise }
  • mode {"byob"}
Attributes
preventCancel:<boolean>
  • done {false}
  • value {T}
  • strategy {QueuingStrategy}
  • type {"bytes"}
  • readable {ReadableStream}
  • writable {WritableStream}
  • path {PathLikeFs}
  • callback <object>
  • Returns: {void}
  • path {PathLikeFs}
  • options <object>
  • Returns: {Buffer[]}
  • path {PathLikeFs}
  • options <object> | <null>
  • Returns: {string[]|Buffer[]}
  • path {PathLikeFs}
  • options <object>
  • Returns: {Dirent[]}
  • path {PathLikeFs}
  • options <object>
  • Returns: {Dirent<Buffer>[]}
  • path {PathLikeTypes}
  • callback <object>
  • Returns: {void}
Attributes
import:<boolean>
use import?
Attributes
import:<boolean>
use import?
mangleImports:<boolean>
mangle imports
  • path {PathOrFileDescriptorFs}
  • options <object>
  • callback <object>
  • Returns: {void}
  • path {PathOrFileDescriptorFs}
  • callback <object>
  • Returns: {void}
  • path {PathOrFileDescriptorFs}
  • options <object> | <null>
  • Returns: {Buffer}
  • path {PathOrFileDescriptorFs}
  • options <object> | <null>
  • Returns: {string|Buffer}
  • path {PathOrFileDescriptorTypes}
  • options <object>
  • 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
size:<number>
  • value {T}
  • Returns: <boolean> a boolean indicating whether an element with the specified value exists in the set-like or not.
Returns:
{Iterator }

Despite its name, returns an iterator of the values in the set-like.

Attributes
<ReadableStream>
. <WritableStream>
Attributes
readable:<boolean>
writable:<boolean>
Returns:
{AsyncIterableIterator<string|Buffer >}
Attributes
error:<Error>
event:<string> | <symbol>
args:<any[]>
Returns:
{void}

The Symbol.for('nodejs.rejection') method is called in case a promise rejection happens when emitting an event and captureRejections is enabled on the emitter. It is possible to use events.captureRejectionSymbol in place of Symbol.for('nodejs.rejection').

import { EventEmitter, captureRejectionSymbol } from 'node:events';

class MyClass extends EventEmitter {
  constructor() {
    super({ captureRejections: true });
  }

  [captureRejectionSymbol](err, event, ...args) {
    console.log('rejection happened for', event, 'with', err, ...args);
    this.destroy(err);
  }

  destroy(err) {
    // Tear the resource down here.
  }
}
JavaScript
Attributes
eventName:<string> | <symbol>
listener:<object>
Returns:<this>

Alias for emitter.on(eventName, listener).

Attributes
eventName:<string> | <symbol>
args:<any[]>
Returns:<boolean>

Synchronously calls each of the listeners registered for the event named eventName, in the order they were registered, passing the supplied arguments to each.

Returns true if the event had listeners, false otherwise.

import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();

// First listener
myEmitter.on('event', function firstListener() {
  console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
  console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
  const parameters = args.join(', ');
  console.log(`event with parameters ${parameters} in third listener`);
});

console.log(myEmitter.listeners('event'));

myEmitter.emit('event', 1, 2, 3, 4, 5);

// Prints:
// [
//   [Function: firstListener],
//   [Function: secondListener],
//   [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener
JavaScript
Call Signature
Attributes
cb:<object>
Returns:<this>
Call Signature
Call Signature
Attributes
str:<string>
encoding:
{BufferEncoding}
cb:<object>
Returns:<this>
Returns:<string> | <symbol[]>

Returns an array listing the events for which the emitter has registered listeners.

import { EventEmitter } from 'node:events';

const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});

const sym = Symbol('symbol');
myEE.on(sym, () => {});

console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]
JavaScript
Returns:<number>

Returns the current max listener value for the EventEmitter which is either set by emitter.setMaxListeners(n) or defaults to events.defaultMaxListeners.

Returns:<boolean>
Attributes
eventName:<string> | <symbol>
The name of the event being listened for
listener:<object>
The event handler function
Returns:<number>

Returns the number of listeners listening for the event named eventName. If listener is provided, it will return how many times the listener is found in the list of the listeners of the event.

Attributes
eventName:<string> | <symbol>
Returns:<object[]>

Returns a copy of the array of listeners for the event named eventName.

server.on('connection', (stream) => {
  console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]
JavaScript
Attributes
eventName:<string> | <symbol>
listener:<object>
Returns:<this>

Alias for emitter.removeListener().

Attributes
eventName:<string> | <symbol>
The name of the event.
listener:<object>
The callback function
Returns:<this>

Adds the listener function to the end of the listeners array for the event named eventName. No checks are made to see if the listener has already been added. Multiple calls passing the same combination of eventName and listener will result in the listener being added, and called, multiple times.

server.on('connection', (stream) => {
  console.log('someone connected!');
});
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

By default, event listeners are invoked in the order they are added. The emitter.prependListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
JavaScript
Attributes
eventName:<string> | <symbol>
The name of the event.
listener:<object>
The callback function
Returns:<this>

Adds a one-time listener function for the event named eventName. The next time eventName is triggered, this listener is removed and then invoked.

server.once('connection', (stream) => {
  console.log('Ah, we have our first user!');
});
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

By default, event listeners are invoked in the order they are added. The emitter.prependOnceListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
JavaScript
Returns:<this>
  • destination {T}
  • options <object>
  • Returns: {T}
Attributes
eventName:<string> | <symbol>
The name of the event.
listener:<object>
The callback function
Returns:<this>

Adds the listener function to the beginning of the listeners array for the event named eventName. No checks are made to see if the listener has already been added. Multiple calls passing the same combination of eventName and listener will result in the listener being added, and called, multiple times.

server.prependListener('connection', (stream) => {
  console.log('someone connected!');
});
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

Attributes
eventName:<string> | <symbol>
The name of the event.
listener:<object>
The callback function
Returns:<this>

Adds a one-time listener function for the event named eventName to the beginning of the listeners array. The next time eventName is triggered, this listener is removed, and then invoked.

server.prependOnceListener('connection', (stream) => {
  console.log('Ah, we have our first user!');
});
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

Attributes
eventName:<string> | <symbol>
Returns:<object[]>

Returns a copy of the array of listeners for the event named eventName, including any wrappers (such as those created by .once()).

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));

// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];

// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();

// Logs "log once" to the console and removes the listener
logFnWrapper();

emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');

// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');
JavaScript
Attributes
size:<number>
Returns:
{string|Buffer }
Attributes
eventName:<string> | <symbol>
Returns:<this>

Removes all listeners, or those of the specified eventName.

It is bad practice to remove listeners added elsewhere in the code, particularly when the EventEmitter instance was created by some other component or module (e.g. sockets or file streams).

Returns a reference to the EventEmitter, so that calls can be chained.

Attributes
eventName:<string> | <symbol>
listener:<object>
Returns:<this>

Removes the specified listener from the listener array for the event named eventName.

const callback = (stream) => {
  console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);
JavaScript

removeListener() will remove, at most, one instance of a listener from the listener array. If any single listener has been added multiple times to the listener array for the specified eventName, then removeListener() must be called multiple times to remove each instance.

Once an event is emitted, all listeners attached to it at the time of emitting are called in order. This implies that any removeListener() or removeAllListeners() calls after emitting and before the last listener finishes execution will not remove them from emit() in progress. Subsequent events behave as expected.

import { EventEmitter } from 'node:events';
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();

const callbackA = () => {
  console.log('A');
  myEmitter.removeListener('event', callbackB);
};

const callbackB = () => {
  console.log('B');
};

myEmitter.on('event', callbackA);

myEmitter.on('event', callbackB);

// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
//   A
//   B

// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
//   A
JavaScript

Because listeners are managed using an internal array, calling this will change the position indexes of any listener registered after the listener being removed. This will not impact the order in which listeners are called, but it means that any copies of the listener array as returned by the emitter.listeners() method will need to be recreated.

When a single function has been added as a handler multiple times for a single event (as in the example below), removeListener() will remove the most recently added instance. In the example the once('ping') listener is removed:

import { EventEmitter } from 'node:events';
const ee = new EventEmitter();

function pong() {
  console.log('pong');
}

ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);

ee.emit('ping');
ee.emit('ping');
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

Returns:<this>
  • encoding {BufferEncoding}
  • Returns: <this>
Attributes
n:<number>
Returns:<this>

By default EventEmitters will print a warning if more than 10 listeners are added for a particular event. This is a useful default that helps finding memory leaks. The emitter.setMaxListeners() method allows the limit to be modified for this specific EventEmitter instance. The value can be set to Infinity (or 0) to indicate an unlimited number of listeners.

Returns a reference to the EventEmitter, so that calls can be chained.

Attributes
destination:<WritableStream>
Returns:<this>
  • chunk {string|Uint8Array}
  • encoding {BufferEncoding}
  • Returns: {void}
Attributes
oldStream:<ReadableStream>
Returns:<this>
Call Signature
Call Signature
Attributes
str:<string>
encoding:
{BufferEncoding}
cb:<object>
Returns:<boolean>
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
  • {BaseNode}.{BaseExpression}
Attributes
leadingComments:<Comment[]>
loc:<null>
range:
{Tuple<number, number>}
raw:<string>
regex:<object>
trailingComments:<Comment[]>
type:
{"Literal"}
value:<RegExp> | <null>

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:<string>
hash to be used for render call
moduleGraph:<ModuleGraph>
the module graph
runtimeTemplate:
[ <RuntimeTemplate> ]( /RuntimeTemplate.html) the runtime template
Attributes
chunk:<Chunk>
the chunk
chunkGraph:<ChunkGraph>
the chunk graph
codeGenerationResults:<CodeGenerationResults>
results of code generation
modules:
[ <CssModule[]> ]( /CssModule.html) modules
runtimeTemplate:
[ <RuntimeTemplate> ]( /RuntimeTemplate.html) the runtime template
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> ]( /DependencyTemplates.html) the dependency templates
moduleGraph:<ModuleGraph>
the module graph
runtimeTemplate:
[ <RuntimeTemplate> ]( /RuntimeTemplate.html) the runtime template
strictMode:<boolean>
rendering in strict context
Attributes
auxiliary:<boolean>
filename:<string>
hash:<string>
identifier:<string>
info:<AssetInfo>
render:<object>
Attributes
auxiliary:<boolean>
filenameTemplate:<TemplatePath>
hash:<string>
identifier:<string>
info:<AssetInfo>
pathOptions:<PathData>
render:<object>
  • directories {Set} list of directories
  • files {Set} list of files
  • missing {Set} list of missing entries
  • resolveDependencies {ResolveDependencies} dependencies of the resolving
  • resolveResults {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 function
  • missingDependencies {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
safeTime:<number>
timestampHash:<string>
Attributes
hash:<string>
safeTime:<number>
timestampHash:<string>
  • directories {Set} list of directories
  • files {Set} list of files
  • missing {Set} list of missing entries
  • platform {false|PlatformTargetProperties} - platform target properties
  • alias {AliasOption[]} alias
  • aliasFields {Set<string|string[]>} alias fields
  • cachePredicate <object> cache predicate
  • cacheWithContext <boolean> cache with context
  • conditionNames {Set} A list of exports field condition names.
  • descriptionFiles <string[]> description files
  • enforceExtension <boolean> enforce extension
  • exportsFields {Set<string|string[]>} exports fields
  • extensionAlias {ExtensionAliasOption[]} extension alias
  • extensions {Set} extensions
  • fallback {AliasOption[]} fallback
  • fileSystem <FileSystem> fileSystem
  • fullySpecified <boolean> fully specified
  • importsFields {Set<string|string[]>} imports fields
  • mainFields <object[]> main fields
  • mainFiles {Set} main files
  • modules <string> modules
  • plugins <Plugin[]> plugins
  • pnpApi <null> pnp API
  • preferAbsolute <boolean> prefer absolute
  • preferRelative <boolean> prefer relative
  • resolver <Resolver> resolver
  • resolveToContext <boolean> resolve to context
  • restrictions {Set<string|RegExp>} restrictions
  • roots {Set} roots
  • symlinks <boolean> symlinks
  • tsconfig <string> | <boolean> tsconfig file path or config object
  • unsafeCache {false|CacheTypes} unsafe cache
  • alias {AliasOption[]|AliasOptions} A list of module alias configurations or an object which maps key to value
  • aliasFields <string> A list of alias fields in description files
  • cachePredicate <object> A function which decides whether a request should be cached or not. An object is passed with at least path and request properties.
  • 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 from
  • enforceExtension <boolean> Enforce that a extension from extensions must be used
  • exportsFields <string> A list of exports fields in description files
  • extensionAlias {ExtensionAliasOptions} An object which maps extension to extension aliases
  • extensions <string[]> A list of extensions which should be tried for files
  • fallback {AliasOption[]|AliasOptions} A list of module alias configurations or an object which maps key to value, applied only after modules option
  • fileSystem <FileSystem> The file system which should be used
  • fullySpecified <boolean> The request is already fully specified and no extensions or directories are resolved for it
  • importsFields <string> A list of imports fields in description files
  • mainFields <string> | <string[]> | <object[]> A list of main fields in description files
  • mainFiles <string[]> A list of main files in directories
  • modules <string> | <string[]> A list of directories to resolve modules from, can be absolute path or folder name
  • plugins <Plugin[]> A list of additional resolve plugins which should be applied
  • pnpApi <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 roots
  • preferRelative <boolean> Prefer to resolve module requests as relative requests before falling back to modules
  • resolver <Resolver> A prepared Resolver to which the plugins are attached
  • resolveToContext <boolean> Resolve to a context instead of a file
  • restrictions <string> | <RegExp[]> A list of resolve restrictions
  • roots <string[]> A list of root paths
  • symlinks <boolean> Resolve symlinks to their symlinked location
  • tsconfig <string> | <boolean> TypeScript config file path or config object with configFile and references
  • unsafeCache <boolean> Use this cache object to unsafely cache the successful requests
  • useSyncFileSystemCalls <boolean> Use only the sync constraints of the file system calls
  • direct {WeakMap<ResolveOptionsWithDependencyType, ResolverWithOptions>}
  • stringified {Map<string, ResolverWithOptions>}
Attributes
context:<string>
data:
{ResourceSchemeData|Partial }
fragment:<string>
path:<string>
query:<string>
resource:<string>
Attributes
encodedContent:<string>
encoded content of the resource
encoding:
{false|"base64"} encoding of the resource
mimetype:<string>
mime type of the resource
parameters:<string>
additional parameters for the resource
  • {BasePattern}
  • argument {Pattern}
  • leadingComments <Comment[]>
  • loc <null>
  • range {Tuple<number, number>}
  • trailingComments <Comment[]>
  • type {"RestElement"}
Attributes
<Node>
  • argument {Pattern}
  • end <number>
  • loc <null>
  • range {Tuple<number, number>}
  • start <number>
  • type {"RestElement"}
Attributes
canMangleProvide:<boolean>
exportsInfo:
[ <RestoreProvidedData> ]( /RestoreProvidedData.html)
name:<string>
provided:<boolean> | <null>
terminalBinding:<boolean>
  • {BaseStatement}
Attributes
argument:<null>
leadingComments:<Comment[]>
loc:<null>
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:
{"ReturnStatement"}
Attributes
<Node>
Attributes
argument:<null>
end:<number>
loc:<null>
range:
{Tuple<number, number>}
start:<number>
type:
{"ReturnStatement"}
  • {Algorithm}
  • hash {AlgorithmIdentifier}
  • name <string>
Attributes
d:<string>
r:<string>
t:<string>
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
and:<RuleSetCondition[]>
Logical AND.
not:<string> | <RegExp> | <RuleSetCondition[]> | <object>
Logical NOT.
or:<RuleSetCondition[]>
Logical OR.

Logic operators used in a condition matcher.

Attributes
and:<RuleSetConditionAbsolute[]>
Logical AND.
not:<string> | <RegExp> | <RuleSetConditionAbsolute[]> | <object>
Logical NOT.
or:<RuleSetConditionAbsolute[]>
Logical OR.
Attributes
chunkGraph:<ChunkGraph>
the chunk graph
codeGenerationResults:<CodeGenerationResults>
the code generation results
Attributes
buildDependencies:<string[]>
contextDependencies:<string[]>
fileDependencies:<string[]>
missingDependencies:<string[]>
version:<string> | <object>
  • {_SchemaObject}

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
context:<any>
  • {TlsOptions}
  • {TLSSocketOptions}
Attributes
allowPartialTrustChain:<boolean>
Treat intermediate (non-self-signed) certificates in the trust CA certificate list as trusted.
ALPNCallback:<object>
If set, this will be called when a client opens a connection using the ALPN extension. One argument will be passed to the callback: an object containing  servername and protocols fields, respectively containing the server name from the SNI extension (if any) and an array of ALPN protocol name strings. The callback must return either one of the strings listed in protocols , which will be returned to the client as the selected ALPN protocol, or undefined , to reject the connection with a fatal alert. If a string is returned that does not match one of the client's ALPN protocols, an error will be thrown. This option cannot be used with the ALPNProtocols option, and setting both options will throw an error.
ca:
{string|Buffer |string|Buffer []} Optionally override the trusted CA certificates. Default is to trust the well-known CAs curated by Mozilla. Mozilla's CAs are completely replaced when CAs are explicitly specified using this option.
cert:
{string|Buffer |string|Buffer []} Cert chains in PEM format. One cert chain should be provided per private key. Each cert chain should consist of the PEM formatted certificate for a provided private key, followed by the PEM formatted intermediate certificates (if any), in order, and not including the root CA (the root CA must be pre-known to the peer, see ca). When providing multiple cert chains, they do not have to be in the same order as their private keys in key. If the intermediate certificates are not provided, the peer will not be able to validate the certificate, and the handshake will fail.
ciphers:<string>
Cipher suite specification, replacing the default. For more information, see modifying the default cipher suite. Permitted ciphers can be obtained via tls.getCiphers(). Cipher names must be uppercased in order for OpenSSL to accept them.
clientCertEngine:<string>
Name of an OpenSSL engine which can provide the client certificate.
crl:
{string|Buffer |string|Buffer []} PEM formatted CRLs (Certificate Revocation Lists).
dhparam:
{string|Buffer } 'auto' or custom Diffie-Hellman parameters, required for non-ECDHE perfect forward secrecy. If omitted or invalid, the parameters are silently discarded and DHE ciphers will not be available. ECDHE-based perfect forward secrecy will still be available.
ecdhCurve:<string>
A string describing a named curve or a colon separated list of curve NIDs or names, for example P-521:P-384:P-256, to use for ECDH key agreement. Set to auto to select the curve automatically. Use crypto.getCurves() to obtain a list of available curve names. On recent releases, openssl ecparam -list_curves will also display the name and description of each available elliptic curve. Default: tls.DEFAULT_ECDH_CURVE.
honorCipherOrder:<boolean>
Attempt to use the server's cipher suite preferences instead of the client's. When true, causes SSL_OP_CIPHER_SERVER_PREFERENCE to be set in secureOptions
key:
{string|Buffer |string|Buffer |KeyObject[]} Private keys in PEM format. PEM allows the option of private keys being encrypted. Encrypted keys will be decrypted with options.passphrase. Multiple keys using different algorithms can be provided either as an array of unencrypted key strings or buffers, or an array of objects in the form {pem: <string|buffer>[, passphrase:  ]}. The object form can only occur in an array. object.passphrase is optional. Encrypted keys will be decrypted with object.passphrase if provided, or options.passphrase if it is not.
maxVersion?:
{SecureVersion} Optionally set the maximum TLS version to allow. One of  'TLSv1.3' , 'TLSv1.2' , 'TLSv1.1' , or 'TLSv1' . Cannot be specified along with the secureProtocol option, use one or the other. Default: 'TLSv1.3' , unless changed using CLI options. Using --tls-max-v1.2 sets the default to 'TLSv1.2' . Using --tls-max-v1.3 sets the default to 'TLSv1.3' . If multiple of the options are provided, the highest maximum is used.
minVersion?:
{SecureVersion} Optionally set the minimum TLS version to allow. One of  'TLSv1.3' , 'TLSv1.2' , 'TLSv1.1' , or 'TLSv1' . Cannot be specified along with the secureProtocol option, use one or the other. It is not recommended to use less than TLSv1.2, but it may be required for interoperability. Default: 'TLSv1.2' , unless changed using CLI options. Using --tls-v1.0 sets the default to 'TLSv1' . Using --tls-v1.1 sets the default to 'TLSv1.1' . Using --tls-min-v1.3 sets the default to 'TLSv1.3'. If multiple of the options are provided, the lowest minimum is used.
passphrase:<string>
Shared passphrase used for a single private key and/or a PFX.
pfx:
{string|Buffer |string|Buffer |PxfObject[]} PFX or PKCS12 encoded private key and certificate chain. pfx is an alternative to providing key and cert individually. PFX is usually encrypted, if it is, passphrase will be used to decrypt it. Multiple PFX can be provided either as an array of unencrypted PFX buffers, or an array of objects in the form {buf: <string|buffer>[, passphrase:  ]}. The object form can only occur in an array. object.passphrase is optional. Encrypted PFX will be decrypted with object.passphrase if provided, or options.passphrase if it is not.
privateKeyEngine:<string>
Name of an OpenSSL engine to get private key from. Should be used together with privateKeyIdentifier.
privateKeyIdentifier:<string>
Identifier of a private key managed by an OpenSSL engine. Should be used together with privateKeyEngine. Should not be set together with key, because both options define a private key in different ways.
secureOptions:<number>
Optionally affect the OpenSSL protocol behavior, which is not usually necessary. This should be used carefully if at all! Value is a numeric bitmask of the SSL_OP_* options from OpenSSL Options
secureProtocol:<string>
Legacy mechanism to select the TLS protocol version to use, it does not support independent control of the minimum and maximum version, and does not support limiting the protocol to TLSv1.3. Use minVersion and maxVersion instead. The possible values are listed as SSL_METHODS, use the function names as strings. For example, use 'TLSv1_1_method' to force TLS version 1.1, or 'TLS_method' to allow any TLS protocol version up to TLSv1.3. It is not recommended to use TLS versions less than 1.2, but it may be required for interoperability. Default: none, see minVersion.
sessionIdContext:<string>
Opaque identifier used by servers to ensure session state is not shared between applications. Unused by clients.
sessionTimeout:<number>
The number of seconds after which a TLS session created by the server will no longer be resumable. See Session Resumption for more information. Default: 300.
sigalgs:<string>
Colon-separated list of supported signature algorithms. The list can contain digest algorithms (SHA256, MD5 etc.), public key algorithms (RSA-PSS, ECDSA etc.), combination of both (e.g 'RSA+SHA384') or TLS v1.3 scheme names (e.g. rsa_pss_pss_sha512).
ticketKeys:
{Buffer } 48-bytes of cryptographically strong pseudo-random data. See Session Resumption for more information.
  • {BaseExpression}
  • expressions {Expression[]}
  • leadingComments <Comment[]>
  • loc <null>
  • range {Tuple<number, number>}
  • trailingComments <Comment[]>
  • type {"SequenceExpression"}
Attributes
<Node>
Attributes
end:<number>
expressions:
{Expression[]}
loc:<null>
range:
{Tuple<number, number>}
start:<number>
type:
{"SequenceExpression"}
  • {ServerEventMap}
  • {ServerEventMap}
  • checkContinue {Tuple<request, response>}
  • checkExpectation {Tuple<request, response>}
  • clientError {Tuple<exception, socket>}
  • close {Tuple}
  • connect {Tuple<request, socket, head>}
  • connection {Tuple}
  • drop {Tuple}
  • dropRequest {Tuple<request, socket>}
  • error {Tuple}
  • listening {Tuple}
  • request {Tuple<request, response>}
  • upgrade {Tuple<req, socket, head>}
  • {ServerEventMap<Request, Response>}.{ServerEventMap}
  • checkContinue {Tuple<request, response>}
  • checkExpectation {Tuple<request, response>}
  • clientError {Tuple<exception, socket>}
  • close {Tuple}
  • connect {Tuple<request, socket, head>}
  • connection {Tuple}
  • drop {Tuple}
  • dropRequest {Tuple<request, socket>}
  • error {Tuple}
  • keylog {Tuple<line, tlsSocket>}
  • listening {Tuple}
  • newSession {Tuple<sessionId, sessionData, callback>}
  • OCSPRequest {Tuple<certificate, issuer, callback>}
  • request {Tuple<request, response>}
  • resumeSession {Tuple<sessionId, callback>}
  • secureConnection {Tuple}
  • tlsClientError {Tuple<exception, tlsSocket>}
  • upgrade {Tuple<req, socket, head>}
  • {ServerEventMap}
  • {ServerEventMap}
  • close {Tuple}
  • connection {Tuple}
  • drop {Tuple}
  • error {Tuple}
  • listening {Tuple}
  • {ServerEventMap}
  • {ServerEventMap}
  • close {Tuple}
  • connection {Tuple}
  • drop {Tuple}
  • error {Tuple}
  • keylog {Tuple<line, tlsSocket>}
  • listening {Tuple}
  • newSession {Tuple<sessionId, sessionData, callback>}
  • OCSPRequest {Tuple<certificate, issuer, callback>}
  • resumeSession {Tuple<sessionId, callback>}
  • secureConnection {Tuple}
  • tlsClientError {Tuple<exception, tlsSocket>}
  • {ServerOptions}
Attributes
connectionsCheckingInterval:<number>
Sets the interval value in milliseconds to check for request and headers timeout in incomplete requests.
headersTimeout:<number>
Sets the timeout value in milliseconds for receiving the complete HTTP headers from the client. See  Server.headersTimeout for more information.
highWaterMark:<number>
Optionally overrides all  socket s' readableHighWaterMark and writableHighWaterMark . This affects highWaterMark property of both IncomingMessage and ServerResponse . Default:
IncomingMessage:<Request>
Specifies the  IncomingMessage class to be used. Useful for extending the original IncomingMessage .
insecureHTTPParser:<boolean>
Use an insecure HTTP parser that accepts invalid HTTP headers when  true . Using the insecure parser should be avoided. See --insecure-http-parser for more information.
joinDuplicateHeaders:<boolean>
It joins the field line values of multiple headers in a request with  , instead of discarding the duplicates.
keepAlive:<boolean>
If set to  true , it enables keep-alive functionality on the socket immediately after a new incoming connection is received, similarly on what is done in socket.setKeepAlive([enable][, initialDelay]) .
keepAliveInitialDelay:<number>
If set to a positive number, it sets the initial delay before the first keepalive probe is sent on an idle socket.
keepAliveTimeout:<number>
The number of milliseconds of inactivity a server needs to wait for additional incoming data, after it has finished writing the last response, before a socket will be destroyed.
keepAliveTimeoutBuffer:<number>
An additional buffer time added to the  server.keepAliveTimeout to extend the internal socket timeout.
maxHeaderSize:<number>
Optionally overrides the value of  --max-http-header-size for requests received by this server, i.e. the maximum length of request headers in bytes.
noDelay:<boolean>
If set to  true , it disables the use of Nagle's algorithm immediately after a new incoming connection is received.
optimizeEmptyRequests:<boolean>
If set to  true , requests without Content-Length or Transfer-Encoding headers (indicating no body) will be initialized with an already-ended body stream, so they will never emit any stream events (like 'data' or 'end' ). You can use req.readableEnded to detect this case.
rejectNonStandardBodyWrites:<boolean>
If set to  true , an error is thrown when writing to an HTTP response which does not have a body.
requestTimeout:<number>
Sets the timeout value in milliseconds for receiving the entire request from the client.
requireHostHeader:<boolean>
If set to  true , it forces the server to respond with a 400 (Bad Request) status code to any HTTP/1.1 request message that lacks a Host header (as mandated by the specification).
ServerResponse:<Response>
Specifies the  ServerResponse class to be used. Useful for extending the original ServerResponse .
shouldUpgradeCallback:<object>
A callback which receives an incoming request and returns a boolean, to control which upgrade attempts should be accepted. Accepted upgrades will fire an  'upgrade' event (or their sockets will be destroyed, if no listener is registered) while rejected upgrades will fire a 'request' event like any non-upgrade request.
uniqueHeaders:<string>
A list of response headers that should be sent only once. If the header's value is an array, the items will be joined using  ; .
  • {ServerOptions<Request, Response>}.{TlsOptions}
Attributes
allowHalfOpen:<boolean>
Indicates whether half-opened TCP connections are allowed.
allowPartialTrustChain:<boolean>
Treat intermediate (non-self-signed) certificates in the trust CA certificate list as trusted.
ALPNCallback:<object>
If set, this will be called when a client opens a connection using the ALPN extension. One argument will be passed to the callback: an object containing  servername and protocols fields, respectively containing the server name from the SNI extension (if any) and an array of ALPN protocol name strings. The callback must return either one of the strings listed in protocols , which will be returned to the client as the selected ALPN protocol, or undefined , to reject the connection with a fatal alert. If a string is returned that does not match one of the client's ALPN protocols, an error will be thrown. This option cannot be used with the ALPNProtocols option, and setting both options will throw an error.
ALPNProtocols:
{string[]|ArrayBufferView } An array of strings, or a single Buffer , TypedArray , or DataView containing the supported ALPN protocols. Buffers should have the format [len][name][len][name]... e.g. '\x08http/1.1\x08http/1.0' , where the len byte is the length of the next protocol name. Passing an array is usually much simpler, e.g. ['http/1.1', 'http/1.0'] . Protocols earlier in the list have higher preference than those later.
blockList:
[ <BlockList> ]( /BlockList.html)  blockList can be used for disabling inbound access to specific IP addresses, IP ranges, or IP subnets. This does not work if the server is behind a reverse proxy, NAT, etc. because the address checked against the block list is the address of the proxy, or the one specified by the NAT.
ca:
{string|Buffer |string|Buffer []} Optionally override the trusted CA certificates. Default is to trust the well-known CAs curated by Mozilla. Mozilla's CAs are completely replaced when CAs are explicitly specified using this option.
cert:
{string|Buffer |string|Buffer []} Cert chains in PEM format. One cert chain should be provided per private key. Each cert chain should consist of the PEM formatted certificate for a provided private key, followed by the PEM formatted intermediate certificates (if any), in order, and not including the root CA (the root CA must be pre-known to the peer, see ca). When providing multiple cert chains, they do not have to be in the same order as their private keys in key. If the intermediate certificates are not provided, the peer will not be able to validate the certificate, and the handshake will fail.
ciphers:<string>
Cipher suite specification, replacing the default. For more information, see modifying the default cipher suite. Permitted ciphers can be obtained via tls.getCiphers(). Cipher names must be uppercased in order for OpenSSL to accept them.
clientCertEngine:<string>
Name of an OpenSSL engine which can provide the client certificate.
connectionsCheckingInterval:<number>
Sets the interval value in milliseconds to check for request and headers timeout in incomplete requests.
crl:
{string|Buffer |string|Buffer []} PEM formatted CRLs (Certificate Revocation Lists).
dhparam:
{string|Buffer } 'auto' or custom Diffie-Hellman parameters, required for non-ECDHE perfect forward secrecy. If omitted or invalid, the parameters are silently discarded and DHE ciphers will not be available. ECDHE-based perfect forward secrecy will still be available.
ecdhCurve:<string>
A string describing a named curve or a colon separated list of curve NIDs or names, for example P-521:P-384:P-256, to use for ECDH key agreement. Set to auto to select the curve automatically. Use crypto.getCurves() to obtain a list of available curve names. On recent releases, openssl ecparam -list_curves will also display the name and description of each available elliptic curve. Default: tls.DEFAULT_ECDH_CURVE.
enableTrace:<boolean>
When enabled, TLS packet trace information is written to  stderr . This can be used to debug TLS connection problems.
handshakeTimeout:<number>
Abort the connection if the SSL/TLS handshake does not finish in the specified number of milliseconds. A 'tlsClientError' is emitted on the tls.Server object whenever a handshake times out. Default: 120000 (120 seconds).
headersTimeout:<number>
Sets the timeout value in milliseconds for receiving the complete HTTP headers from the client. See  Server.headersTimeout for more information.
highWaterMark:<number>
Optionally overrides all  socket s' readableHighWaterMark and writableHighWaterMark . This affects highWaterMark property of both IncomingMessage and ServerResponse . Default:
honorCipherOrder:<boolean>
Attempt to use the server's cipher suite preferences instead of the client's. When true, causes SSL_OP_CIPHER_SERVER_PREFERENCE to be set in secureOptions
IncomingMessage:<Request>
Specifies the  IncomingMessage class to be used. Useful for extending the original IncomingMessage .
insecureHTTPParser:<boolean>
Use an insecure HTTP parser that accepts invalid HTTP headers when  true . Using the insecure parser should be avoided. See --insecure-http-parser for more information.
joinDuplicateHeaders:<boolean>
It joins the field line values of multiple headers in a request with  , instead of discarding the duplicates.
keepAlive:<boolean>
If set to  true , it enables keep-alive functionality on the socket immediately after a new incoming connection is received, similarly on what is done in socket.setKeepAlive([enable][, initialDelay]) .
keepAliveInitialDelay:<number>
If set to a positive number, it sets the initial delay before the first keepalive probe is sent on an idle socket.
keepAliveTimeout:<number>
The number of milliseconds of inactivity a server needs to wait for additional incoming data, after it has finished writing the last response, before a socket will be destroyed.
keepAliveTimeoutBuffer:<number>
An additional buffer time added to the  server.keepAliveTimeout to extend the internal socket timeout.
key:
{string|Buffer |string|Buffer |KeyObject[]} Private keys in PEM format. PEM allows the option of private keys being encrypted. Encrypted keys will be decrypted with options.passphrase. Multiple keys using different algorithms can be provided either as an array of unencrypted key strings or buffers, or an array of objects in the form {pem: <string|buffer>[, passphrase:  ]}. The object form can only occur in an array. object.passphrase is optional. Encrypted keys will be decrypted with object.passphrase if provided, or options.passphrase if it is not.
maxHeaderSize:<number>
Optionally overrides the value of  --max-http-header-size for requests received by this server, i.e. the maximum length of request headers in bytes.
maxVersion?:
{SecureVersion} Optionally set the maximum TLS version to allow. One of  'TLSv1.3' , 'TLSv1.2' , 'TLSv1.1' , or 'TLSv1' . Cannot be specified along with the secureProtocol option, use one or the other. Default: 'TLSv1.3' , unless changed using CLI options. Using --tls-max-v1.2 sets the default to 'TLSv1.2' . Using --tls-max-v1.3 sets the default to 'TLSv1.3' . If multiple of the options are provided, the highest maximum is used.
minVersion?:
{SecureVersion} Optionally set the minimum TLS version to allow. One of  'TLSv1.3' , 'TLSv1.2' , 'TLSv1.1' , or 'TLSv1' . Cannot be specified along with the secureProtocol option, use one or the other. It is not recommended to use less than TLSv1.2, but it may be required for interoperability. Default: 'TLSv1.2' , unless changed using CLI options. Using --tls-v1.0 sets the default to 'TLSv1' . Using --tls-v1.1 sets the default to 'TLSv1.1' . Using --tls-min-v1.3 sets the default to 'TLSv1.3'. If multiple of the options are provided, the lowest minimum is used.
noDelay:<boolean>
If set to  true , it disables the use of Nagle's algorithm immediately after a new incoming connection is received.
optimizeEmptyRequests:<boolean>
If set to  true , requests without Content-Length or Transfer-Encoding headers (indicating no body) will be initialized with an already-ended body stream, so they will never emit any stream events (like 'data' or 'end' ). You can use req.readableEnded to detect this case.
passphrase:<string>
Shared passphrase used for a single private key and/or a PFX.
pauseOnConnect:<boolean>
Indicates whether the socket should be paused on incoming connections.
pfx:
{string|Buffer |string|Buffer |PxfObject[]} PFX or PKCS12 encoded private key and certificate chain. pfx is an alternative to providing key and cert individually. PFX is usually encrypted, if it is, passphrase will be used to decrypt it. Multiple PFX can be provided either as an array of unencrypted PFX buffers, or an array of objects in the form {buf: <string|buffer>[, passphrase:  ]}. The object form can only occur in an array. object.passphrase is optional. Encrypted PFX will be decrypted with object.passphrase if provided, or options.passphrase if it is not.
privateKeyEngine:<string>
Name of an OpenSSL engine to get private key from. Should be used together with privateKeyIdentifier.
privateKeyIdentifier:<string>
Identifier of a private key managed by an OpenSSL engine. Should be used together with privateKeyEngine. Should not be set together with key, because both options define a private key in different ways.
pskCallback:<object>
pskIdentityHint:<string>
hint to send to a client to help with selecting the identity during TLS-PSK negotiation. Will be ignored in TLS 1.3. Upon failing to set pskIdentityHint  tlsClientError will be emitted with ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED code.
rejectNonStandardBodyWrites:<boolean>
If set to  true , an error is thrown when writing to an HTTP response which does not have a body.
rejectUnauthorized:<boolean>
If true the server will reject any connection which is not authorized with the list of supplied CAs. This option only has an effect if requestCert is true.
requestCert:<boolean>
If true the server will request a certificate from clients that connect and attempt to verify that certificate. Defaults to false.
requestOCSP:<boolean>
If true, specifies that the OCSP status request extension will be added to the client hello and an 'OCSPResponse' event will be emitted on the socket before establishing a secure communication.
requestTimeout:<number>
Sets the timeout value in milliseconds for receiving the entire request from the client.
requireHostHeader:<boolean>
If set to  true , it forces the server to respond with a 400 (Bad Request) status code to any HTTP/1.1 request message that lacks a Host header (as mandated by the specification).
secureContext:
{SecureContext} An optional TLS context object from tls.createSecureContext()
secureOptions:<number>
Optionally affect the OpenSSL protocol behavior, which is not usually necessary. This should be used carefully if at all! Value is a numeric bitmask of the SSL_OP_* options from OpenSSL Options
secureProtocol:<string>
Legacy mechanism to select the TLS protocol version to use, it does not support independent control of the minimum and maximum version, and does not support limiting the protocol to TLSv1.3. Use minVersion and maxVersion instead. The possible values are listed as SSL_METHODS, use the function names as strings. For example, use 'TLSv1_1_method' to force TLS version 1.1, or 'TLS_method' to allow any TLS protocol version up to TLSv1.3. It is not recommended to use TLS versions less than 1.2, but it may be required for interoperability. Default: none, see minVersion.
ServerResponse:<Response>
Specifies the  ServerResponse class to be used. Useful for extending the original ServerResponse .
sessionIdContext:<string>
Opaque identifier used by servers to ensure session state is not shared between applications. Unused by clients.
sessionTimeout:<number>
The number of seconds after which a TLS session created by the server will no longer be resumable. See Session Resumption for more information. Default: 300.
shouldUpgradeCallback:<object>
A callback which receives an incoming request and returns a boolean, to control which upgrade attempts should be accepted. Accepted upgrades will fire an  'upgrade' event (or their sockets will be destroyed, if no listener is registered) while rejected upgrades will fire a 'request' event like any non-upgrade request.
sigalgs:<string>
Colon-separated list of supported signature algorithms. The list can contain digest algorithms (SHA256, MD5 etc.), public key algorithms (RSA-PSS, ECDSA etc.), combination of both (e.g 'RSA+SHA384') or TLS v1.3 scheme names (e.g. rsa_pss_pss_sha512).
SNICallback:<object>
SNICallback(servername, cb)  A function that will be called if the client supports SNI TLS extension. Two arguments will be passed when called: servername and cb. SNICallback should invoke cb(null, ctx), where ctx is a SecureContext instance. (tls.createSecureContext(...) can be used to get a proper SecureContext.) If SNICallback wasn't provided the default callback with high-level API will be used (see below).
ticketKeys:
{Buffer } 48-bytes of cryptographically strong pseudo-random data.
uniqueHeaders:<string>
A list of response headers that should be sent only once. If the header's value is an array, the items will be joined using  ; .
  • {TlsOptions}
Attributes
allowHalfOpen:<boolean>
Indicates whether half-opened TCP connections are allowed.
blockList:
[ <BlockList> ]( /BlockList.html)  blockList can be used for disabling inbound access to specific IP addresses, IP ranges, or IP subnets. This does not work if the server is behind a reverse proxy, NAT, etc. because the address checked against the block list is the address of the proxy, or the one specified by the NAT.
highWaterMark:<number>
Optionally overrides all  net.Socket s' readableHighWaterMark and writableHighWaterMark .
keepAlive:<boolean>
If set to  true , it enables keep-alive functionality on the socket immediately after a new incoming connection is received, similarly on what is done in socket.setKeepAlive([enable][, initialDelay]) .
keepAliveInitialDelay:<number>
If set to a positive number, it sets the initial delay before the first keepalive probe is sent on an idle socket.
noDelay:<boolean>
If set to  true , it disables the use of Nagle's algorithm immediately after a new incoming connection is received.
pauseOnConnect:<boolean>
Indicates whether the socket should be paused on incoming connections.
  • {IteratorObject<T, undefined>}
Returns:
{void}
Returns:
{SetIterator }
  • __namedParameters {Tuple|Tuple}
  • Returns: {IteratorResult<T, undefined>}
Attributes
value:<undefined>
Returns:
{IteratorResult<T, undefined>}
Attributes
e:<any>
Returns:
{IteratorResult<T, undefined>}
  • {IteratorObject<T, BuiltinIteratorReturn, unknown>}
Returns:
{void}
Returns:
{SetIterator }
Attributes
count:<number>
The number of values to drop.
Returns:
{IteratorObject<T, undefined, unknown>}

Creates an iterator whose values are the values from this iterator after skipping the provided count.

Attributes
predicate:<object>
A function that accepts up to two arguments. The every method calls the predicate function for each element in this iterator until the predicate returns false, or until the end of this iterator.
Returns:<boolean>

Determines whether all the members of this iterator satisfy the specified test.

Call Signature
Attributes
predicate:<object>
A function that accepts up to two arguments to be used to test values from the underlying iterator.
Returns:
{IteratorObject<S, undefined, unknown>}

Creates an iterator whose values are those from this iterator for which the provided predicate returns true.

Call Signature
Attributes
predicate:<object>
A function that accepts up to two arguments to be used to test values from the underlying iterator.
Returns:
{IteratorObject<T, undefined, unknown>}

Creates an iterator whose values are those from this iterator for which the provided predicate returns true.

Call Signature
Attributes
predicate:<object>
find calls predicate once for each element of this iterator, in order, until it finds one where predicate returns true. If such an element is found, find immediately returns that element value. Otherwise, find returns undefined.
Returns:<undefined>

Returns the value of the first element in this iterator where predicate is true, and undefined otherwise.

Call Signature
Attributes
predicate:<object>
Returns:<undefined>
Attributes
callback:<object>
A function that accepts up to two arguments to be used to transform values from the underlying iterator into new iterators or iterables to be flattened into the result.
Returns:
{IteratorObject<U, undefined, unknown>}

Creates an iterator whose values are the result of applying the callback to the values from this iterator and then flattening the resulting iterators or iterables.

Attributes
callbackfn:<object>
A function that accepts up to two arguments. forEach calls the callbackfn function one time for each element in the iterator.
Returns:
{void}

Performs the specified action for each element in the iterator.

Attributes
callbackfn:<object>
A function that accepts up to two arguments to be used to transform values from the underlying iterator.
Returns:
{IteratorObject<U, undefined, unknown>}

Creates an iterator whose values are the result of applying the callback to the values from this iterator.

  • __namedParameters {Tuple|Tuple}
  • Returns: {IteratorResult<T, undefined>}
Call Signature
Attributes
callbackfn:<object>
A function that accepts up to three arguments. The reduce method calls the callbackfn function one time for each element in the iterator.
Returns:
{T}

Calls the specified callback function for all the elements in this iterator. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

Call Signature
Attributes
callbackfn:<object>
initialValue:
{T}
Returns:
{T}
Call Signature
Attributes
callbackfn:<object>
A function that accepts up to three arguments. The reduce method calls the callbackfn function one time for each element in the iterator.
initialValue:
{U} If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of a value from the iterator.
Returns:
{U}

Calls the specified callback function for all the elements in this iterator. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

Attributes
value:<undefined>
Returns:
{IteratorResult<T, undefined>}
Attributes
predicate:<object>
A function that accepts up to two arguments. The some method calls the predicate function for each element in this iterator until the predicate returns a value true, or until the end of the iterator.
Returns:<boolean>

Determines whether the specified callback function returns true for any element of this iterator.

Attributes
limit:<number>
The maximum number of values to yield.
Returns:
{IteratorObject<T, undefined, unknown>}

Creates an iterator whose values are the values from this iterator, stopping once the provided limit is reached.

Attributes
e:<any>
Returns:
{IteratorResult<T, undefined>}
Returns:
{T[]}

Creates a new array from the values yielded by this iterator.

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.

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').
  • {BaseCallExpression}
  • arguments {Expression|SpreadElement[]}
  • callee {Expression|Super}
  • leadingComments <Comment[]>
  • loc <null>
  • optional <boolean>
  • range {Tuple<number, number>}
  • trailingComments <Comment[]>
  • type {"CallExpression"}
  • {BaseNode}.{BaseExpression}
Attributes
leadingComments:<Comment[]>
loc:<null>
range:
{Tuple<number, number>}
raw:<string>
trailingComments:<Comment[]>
type:
{"Literal"}
value:<string> | <number> | <boolean> | <null>
Attributes
hash:<boolean>
should use hash to snapshot
timestamp:<boolean>
should use timestamp to snapshot

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.
Attributes
address:<string>
The network address as either an IPv4 or IPv6 string.
family:
{IPVersion}
flowlabel:<number>
An IPv6 flow-label used only if  family is 'ipv6' .
port:<number>
An IP port.
Attributes
allowHalfOpen:<boolean>
blockList:
[ <BlockList> ]( /BlockList.html)
fd:<number>
keepAlive:<boolean>
keepAliveInitialDelay:<number>
noDelay:<boolean>
onread:
{OnReadOpts}
readable:<boolean>
signal:<AbortSignal>
typeOfService:<number>
writable:<boolean>

Construct a type with the properties of T except for those in type K.

  • {Omit[<<stream.DuplexEventMap, "close">>](<stream.html#class-streamduplexeventmap-close)}
  • {TLSSocketEventMap}
  • close {Tuple}
  • connect {Tuple}
  • connectionAttempt {Tuple<ip, port, family>}
  • connectionAttemptFailed {Tuple<ip, port, family, error>}
  • connectionAttemptTimeout {Tuple<ip, port, family>}
  • data {Tuple}
  • drain {Tuple}
  • end {Tuple}
  • error {Tuple}
  • finish {Tuple}
  • lookup {Tuple<err, address, family, host>}
  • pause {Tuple}
  • pipe {Tuple}
  • readable {Tuple}
  • ready {Tuple}
  • resume {Tuple}
  • timeout {Tuple}
  • unpipe {Tuple}
Attributes
map:<null>
map
source:
{SourceValue} source
Attributes
buffer:<object>
buffer
map:<object>
map
size:<object>
size
source:<object>
source
sourceAndMap:<object>
source and map
updateHash:<object>
hash updater
Attributes
append:<string> | <object> | <null>
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:<string> | <RegExp> | <object>
Exclude modules that match the given value from source map generation.
fallbackModuleFilenameTemplate:<string> | <object>
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.
filename:<string> | <null>
Defines the output filename of the SourceMap (will be inlined if no value is provided).
ignoreList:<string> | <RegExp> | <object>
Decide whether to ignore source files that match the specified value in the SourceMap.
include:<string> | <RegExp> | <object>
Include source maps for module paths that match the given value.
module:<boolean>
Indicates whether SourceMaps from loaders should be used (defaults to true).
moduleFilenameTemplate:<string> | <object>
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.
test:<string> | <RegExp> | <object>
Include source maps for modules based on their extension (defaults to .js and .css).
Attributes
column:<number>
line:<number>
Attributes
automaticNameDelimiter:<string>
chunksFilter:<object>
defaultSizeTypes:<string[]>
enforceSizeThreshold:
{SplitChunksSizes}
fallbackCacheGroup:
{FallbackCacheGroup}
filename:<string> | <object>
getCacheGroups:<object>
getName:<object>
hidePathInfo:<boolean>
maxAsyncRequests:<number>
maxAsyncSize:
{SplitChunksSizes}
maxInitialRequests:<number>
maxInitialSize:
{SplitChunksSizes}
minChunks:<number>
minRemainingSize:
{SplitChunksSizes}
minSize:
{SplitChunksSizes}
minSizeReduction:
{SplitChunksSizes}
usedExports:<boolean>
Attributes
hash:<string>
id:<string> | <number>
modules:<string[]>
size:<number>
  • {BaseNode}
  • argument {Expression}
  • leadingComments <Comment[]>
  • loc <null>
  • range {Tuple<number, number>}
  • trailingComments <Comment[]>
  • type {"SpreadElement"}
Attributes
<Node>
  • argument {Expression}
  • end <number>
  • loc <null>
  • range {Tuple<number, number>}
  • start <number>
  • type {"SpreadElement"}
Attributes
chunk:<Chunk>
the chunk
chunkGraph:<ChunkGraph>
the chunk graph
codeGenerationResults:<CodeGenerationResults>
results of code generation
dependencyTemplates:
[ <DependencyTemplates> ]( /DependencyTemplates.html) the dependency templates
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> ]( /RuntimeTemplate.html) the runtime template
strictMode:<boolean>
rendering in strict context
  • path {PathLikeFs}
  • callback <object>
  • Returns: {void}

Construct a type with the properties of T except for those in type K.

  • {Omit<BlockStatement, "type">}
Attributes
<Node>
  • body {Statement[]}
  • end <number>
  • loc <null>
  • range {Tuple<number, number>}
  • start <number>
  • type {"StaticBlock"}
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: {IStats}
  • path {PathLikeFs}
  • options <object>
  • Returns: {IBigIntStats}
  • path {PathLikeFs}
  • options <object>
  • Returns: {IStats|IBigIntStats}
  • path {PathLikeFs}
  • options {StatSyncOptions}
  • Returns: <undefined>
Attributes
bigint:<boolean>
throwIfNoEntry:<boolean>
  • path {PathLikeTypes}
  • callback <object>
  • Returns: {void}
Attributes
columns:<boolean>
finalSource:<boolean>
source:<boolean>
Attributes
autoClose:<boolean>
emitClose:<boolean>
encoding:
{"ascii"|"utf8"|"utf-8"|"utf16le"|"utf-16le"|"ucs2"|"ucs-2"|"base64"|"base64url"|"latin1"|"binary"|"hex"}
fd:<any>
flags:<string>
mode:<number>
signal:<AbortSignal> | <null>
start:<number>
Attributes
preventAbort:<boolean>
preventCancel:<boolean>
preventClose:<boolean>
signal:<AbortSignal>
Attributes
toString:<object>
  • {BaseNode}
Attributes
leadingComments:<Comment[]>
loc:<null>
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:
{"Super"}
Attributes
<Node>
Attributes
end:<number>
loc:<null>
range:
{Tuple<number, number>}
start:<number>
type:
{"Super"}
  • {BaseNode}
Attributes
<Node>
  • {BaseStatement}
  • cases {SwitchCase[]}
  • discriminant {Expression}
  • leadingComments <Comment[]>
  • loc <null>
  • range {Tuple<number, number>}
  • trailingComments <Comment[]>
  • type {"SwitchStatement"}
Attributes
<Node>
  • cases {SwitchCase[]}
  • discriminant {Expression}
  • end <number>
  • loc <null>
  • range {Tuple<number, number>}
  • start <number>
  • type {"SwitchStatement"}
  • format {"buffer"}
Attributes
context:<string>
context for module names
mode:
{"update"|"read"|"create"|"merge"} operation mode (defaults to merge)
path:<string>
path to file
test:<object>
selector for modules
Attributes
index:<number>
name:<string>
  • {BaseExpression}
Attributes
leadingComments:<Comment[]>
loc:<null>
quasi:
{TemplateLiteral}
range:
{Tuple<number, number>}
tag:
{Expression}
trailingComments:<Comment[]>
type:
{"TaggedTemplateExpression"}
Attributes
<Node>
Attributes
end:<number>
loc:<null>
quasi:
{TemplateLiteral}
range:
{Tuple<number, number>}
start:<number>
tag:
{Expression}
type:
{"TaggedTemplateExpression"}
  • data {Record<string, any>|TopLevelSymbol|HarmonySettings|ImportSettings|CommonJsImportSettings|CompatibilitySettings|HarmonySpecifierGuards}
  • next {TagInfo}
  • tag <symbol>
Attributes
connection:<ModuleGraphConnection>
export:<string[]>
module:<Module>
Attributes
deferred:<boolean>
export:<string[]>
module:<Module>
Attributes
autoSelectFamily:<boolean>
autoSelectFamilyAttemptTimeout:<number>
family:<number>
hints:<number>
host:<string>
localAddress:<string>
localPort:<number>
lookup:
{LookupFunction}
port:<number>
  • {BaseNode}
Attributes
leadingComments:<Comment[]>
loc:<null>
range:
{Tuple<number, number>}
tail:<boolean>
trailingComments:<Comment[]>
type:
{"TemplateElement"}
value:<object>
Attributes
<Node>
Attributes
end:<number>
loc:<null>
range:
{Tuple<number, number>}
start:<number>
tail:<boolean>
type:
{"TemplateElement"}
value:<object>
  • {BaseExpression}
  • expressions {Expression[]}
  • leadingComments <Comment[]>
  • loc <null>
  • quasis {TemplateElement[]}
  • range {Tuple<number, number>}
  • trailingComments <Comment[]>
  • type {"TemplateLiteral"}
Attributes
<Node>
Attributes
end:<number>
expressions:
{Expression[]}
loc:<null>
quasis:
{TemplateElement[]}
range:
{Tuple<number, number>}
start:<number>
type:
{"TemplateLiteral"}
  • {BaseExpression}
Attributes
leadingComments:<Comment[]>
loc:<null>
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:
{"ThisExpression"}
Attributes
<Node>
Attributes
end:<number>
loc:<null>
range:
{Tuple<number, number>}
start:<number>
type:
{"ThisExpression"}
  • {BaseStatement}
  • argument {Expression}
  • leadingComments <Comment[]>
  • loc <null>
  • range {Tuple<number, number>}
  • trailingComments <Comment[]>
  • type {"ThrowStatement"}
Attributes
<Node>
  • argument {Expression}
  • end <number>
  • loc <null>
  • range {Tuple<number, number>}
  • start <number>
  • type {"ThrowStatement"}
Attributes
hash:<string>
safeTime:<number>
timestamp:<number>
  • {SecureContextOptions}.{CommonConnectionOptions}.{ServerOpts}
  • {ServerOptions}
Attributes
allowHalfOpen:<boolean>
Indicates whether half-opened TCP connections are allowed.
allowPartialTrustChain:<boolean>
Treat intermediate (non-self-signed) certificates in the trust CA certificate list as trusted.
ALPNCallback:<object>
If set, this will be called when a client opens a connection using the ALPN extension. One argument will be passed to the callback: an object containing  servername and protocols fields, respectively containing the server name from the SNI extension (if any) and an array of ALPN protocol name strings. The callback must return either one of the strings listed in protocols , which will be returned to the client as the selected ALPN protocol, or undefined , to reject the connection with a fatal alert. If a string is returned that does not match one of the client's ALPN protocols, an error will be thrown. This option cannot be used with the ALPNProtocols option, and setting both options will throw an error.
ALPNProtocols:
{string[]|ArrayBufferView } An array of strings, or a single Buffer , TypedArray , or DataView containing the supported ALPN protocols. Buffers should have the format [len][name][len][name]... e.g. '\x08http/1.1\x08http/1.0' , where the len byte is the length of the next protocol name. Passing an array is usually much simpler, e.g. ['http/1.1', 'http/1.0'] . Protocols earlier in the list have higher preference than those later.
blockList:
[ <BlockList> ]( /BlockList.html)  blockList can be used for disabling inbound access to specific IP addresses, IP ranges, or IP subnets. This does not work if the server is behind a reverse proxy, NAT, etc. because the address checked against the block list is the address of the proxy, or the one specified by the NAT.
ca:
{string|Buffer |string|Buffer []} Optionally override the trusted CA certificates. Default is to trust the well-known CAs curated by Mozilla. Mozilla's CAs are completely replaced when CAs are explicitly specified using this option.
cert:
{string|Buffer |string|Buffer []} Cert chains in PEM format. One cert chain should be provided per private key. Each cert chain should consist of the PEM formatted certificate for a provided private key, followed by the PEM formatted intermediate certificates (if any), in order, and not including the root CA (the root CA must be pre-known to the peer, see ca). When providing multiple cert chains, they do not have to be in the same order as their private keys in key. If the intermediate certificates are not provided, the peer will not be able to validate the certificate, and the handshake will fail.
ciphers:<string>
Cipher suite specification, replacing the default. For more information, see modifying the default cipher suite. Permitted ciphers can be obtained via tls.getCiphers(). Cipher names must be uppercased in order for OpenSSL to accept them.
clientCertEngine:<string>
Name of an OpenSSL engine which can provide the client certificate.
crl:
{string|Buffer |string|Buffer []} PEM formatted CRLs (Certificate Revocation Lists).
dhparam:
{string|Buffer } 'auto' or custom Diffie-Hellman parameters, required for non-ECDHE perfect forward secrecy. If omitted or invalid, the parameters are silently discarded and DHE ciphers will not be available. ECDHE-based perfect forward secrecy will still be available.
ecdhCurve:<string>
A string describing a named curve or a colon separated list of curve NIDs or names, for example P-521:P-384:P-256, to use for ECDH key agreement. Set to auto to select the curve automatically. Use crypto.getCurves() to obtain a list of available curve names. On recent releases, openssl ecparam -list_curves will also display the name and description of each available elliptic curve. Default: tls.DEFAULT_ECDH_CURVE.
enableTrace:<boolean>
When enabled, TLS packet trace information is written to  stderr . This can be used to debug TLS connection problems.
handshakeTimeout:<number>
Abort the connection if the SSL/TLS handshake does not finish in the specified number of milliseconds. A 'tlsClientError' is emitted on the tls.Server object whenever a handshake times out. Default: 120000 (120 seconds).
highWaterMark:<number>
Optionally overrides all  net.Socket s' readableHighWaterMark and writableHighWaterMark .
honorCipherOrder:<boolean>
Attempt to use the server's cipher suite preferences instead of the client's. When true, causes SSL_OP_CIPHER_SERVER_PREFERENCE to be set in secureOptions
keepAlive:<boolean>
If set to  true , it enables keep-alive functionality on the socket immediately after a new incoming connection is received, similarly on what is done in socket.setKeepAlive([enable][, initialDelay]) .
keepAliveInitialDelay:<number>
If set to a positive number, it sets the initial delay before the first keepalive probe is sent on an idle socket.
key:
{string|Buffer |string|Buffer |KeyObject[]} Private keys in PEM format. PEM allows the option of private keys being encrypted. Encrypted keys will be decrypted with options.passphrase. Multiple keys using different algorithms can be provided either as an array of unencrypted key strings or buffers, or an array of objects in the form {pem: <string|buffer>[, passphrase:  ]}. The object form can only occur in an array. object.passphrase is optional. Encrypted keys will be decrypted with object.passphrase if provided, or options.passphrase if it is not.
maxVersion?:
{SecureVersion} Optionally set the maximum TLS version to allow. One of  'TLSv1.3' , 'TLSv1.2' , 'TLSv1.1' , or 'TLSv1' . Cannot be specified along with the secureProtocol option, use one or the other. Default: 'TLSv1.3' , unless changed using CLI options. Using --tls-max-v1.2 sets the default to 'TLSv1.2' . Using --tls-max-v1.3 sets the default to 'TLSv1.3' . If multiple of the options are provided, the highest maximum is used.
minVersion?:
{SecureVersion} Optionally set the minimum TLS version to allow. One of  'TLSv1.3' , 'TLSv1.2' , 'TLSv1.1' , or 'TLSv1' . Cannot be specified along with the secureProtocol option, use one or the other. It is not recommended to use less than TLSv1.2, but it may be required for interoperability. Default: 'TLSv1.2' , unless changed using CLI options. Using --tls-v1.0 sets the default to 'TLSv1' . Using --tls-v1.1 sets the default to 'TLSv1.1' . Using --tls-min-v1.3 sets the default to 'TLSv1.3'. If multiple of the options are provided, the lowest minimum is used.
noDelay:<boolean>
If set to  true , it disables the use of Nagle's algorithm immediately after a new incoming connection is received.
passphrase:<string>
Shared passphrase used for a single private key and/or a PFX.
pauseOnConnect:<boolean>
Indicates whether the socket should be paused on incoming connections.
pfx:
{string|Buffer |string|Buffer |PxfObject[]} PFX or PKCS12 encoded private key and certificate chain. pfx is an alternative to providing key and cert individually. PFX is usually encrypted, if it is, passphrase will be used to decrypt it. Multiple PFX can be provided either as an array of unencrypted PFX buffers, or an array of objects in the form {buf: <string|buffer>[, passphrase:  ]}. The object form can only occur in an array. object.passphrase is optional. Encrypted PFX will be decrypted with object.passphrase if provided, or options.passphrase if it is not.
privateKeyEngine:<string>
Name of an OpenSSL engine to get private key from. Should be used together with privateKeyIdentifier.
privateKeyIdentifier:<string>
Identifier of a private key managed by an OpenSSL engine. Should be used together with privateKeyEngine. Should not be set together with key, because both options define a private key in different ways.
pskCallback:<object>
pskIdentityHint:<string>
hint to send to a client to help with selecting the identity during TLS-PSK negotiation. Will be ignored in TLS 1.3. Upon failing to set pskIdentityHint  tlsClientError will be emitted with ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED code.
rejectUnauthorized:<boolean>
If true the server will reject any connection which is not authorized with the list of supplied CAs. This option only has an effect if requestCert is true.
requestCert:<boolean>
If true the server will request a certificate from clients that connect and attempt to verify that certificate. Defaults to false.
requestOCSP:<boolean>
If true, specifies that the OCSP status request extension will be added to the client hello and an 'OCSPResponse' event will be emitted on the socket before establishing a secure communication.
secureContext:
{SecureContext} An optional TLS context object from tls.createSecureContext()
secureOptions:<number>
Optionally affect the OpenSSL protocol behavior, which is not usually necessary. This should be used carefully if at all! Value is a numeric bitmask of the SSL_OP_* options from OpenSSL Options
secureProtocol:<string>
Legacy mechanism to select the TLS protocol version to use, it does not support independent control of the minimum and maximum version, and does not support limiting the protocol to TLSv1.3. Use minVersion and maxVersion instead. The possible values are listed as SSL_METHODS, use the function names as strings. For example, use 'TLSv1_1_method' to force TLS version 1.1, or 'TLS_method' to allow any TLS protocol version up to TLSv1.3. It is not recommended to use TLS versions less than 1.2, but it may be required for interoperability. Default: none, see minVersion.
sessionIdContext:<string>
Opaque identifier used by servers to ensure session state is not shared between applications. Unused by clients.
sessionTimeout:<number>
The number of seconds after which a TLS session created by the server will no longer be resumable. See Session Resumption for more information. Default: 300.
sigalgs:<string>
Colon-separated list of supported signature algorithms. The list can contain digest algorithms (SHA256, MD5 etc.), public key algorithms (RSA-PSS, ECDSA etc.), combination of both (e.g 'RSA+SHA384') or TLS v1.3 scheme names (e.g. rsa_pss_pss_sha512).
SNICallback:<object>
SNICallback(servername, cb)  A function that will be called if the client supports SNI TLS extension. Two arguments will be passed when called: servername and cb. SNICallback should invoke cb(null, ctx), where ctx is a SecureContext instance. (tls.createSecureContext(...) can be used to get a proper SecureContext.) If SNICallback wasn't provided the default callback with high-level API will be used (see below).
ticketKeys:
{Buffer } 48-bytes of cryptographically strong pseudo-random data.

Construct a type with the properties of T except for those in type K.

  • {SocketEventMap}
  • close {Tuple}
  • connect {Tuple}
  • connectionAttempt {Tuple<ip, port, family>}
  • connectionAttemptFailed {Tuple<ip, port, family, error>}
  • connectionAttemptTimeout {Tuple<ip, port, family>}
  • data {Tuple}
  • drain {Tuple}
  • end {Tuple}
  • error {Tuple}
  • finish {Tuple}
  • keylog {Tuple}
  • lookup {Tuple<err, address, family, host>}
  • OCSPResponse {Tuple}
  • pause {Tuple}
  • pipe {Tuple}
  • readable {Tuple}
  • ready {Tuple}
  • resume {Tuple}
  • secure {Tuple}
  • secureConnect {Tuple}
  • session {Tuple}
  • timeout {Tuple}
  • unpipe {Tuple}
  • {SecureContextOptions}.{CommonConnectionOptions}
Attributes
allowPartialTrustChain:<boolean>
Treat intermediate (non-self-signed) certificates in the trust CA certificate list as trusted.
ALPNCallback:<object>
If set, this will be called when a client opens a connection using the ALPN extension. One argument will be passed to the callback: an object containing  servername and protocols fields, respectively containing the server name from the SNI extension (if any) and an array of ALPN protocol name strings. The callback must return either one of the strings listed in protocols , which will be returned to the client as the selected ALPN protocol, or undefined , to reject the connection with a fatal alert. If a string is returned that does not match one of the client's ALPN protocols, an error will be thrown. This option cannot be used with the ALPNProtocols option, and setting both options will throw an error.
ALPNProtocols:
{string[]|ArrayBufferView } An array of strings, or a single Buffer , TypedArray , or DataView containing the supported ALPN protocols. Buffers should have the format [len][name][len][name]... e.g. '\x08http/1.1\x08http/1.0' , where the len byte is the length of the next protocol name. Passing an array is usually much simpler, e.g. ['http/1.1', 'http/1.0'] . Protocols earlier in the list have higher preference than those later.
ca:
{string|Buffer |string|Buffer []} Optionally override the trusted CA certificates. Default is to trust the well-known CAs curated by Mozilla. Mozilla's CAs are completely replaced when CAs are explicitly specified using this option.
cert:
{string|Buffer |string|Buffer []} Cert chains in PEM format. One cert chain should be provided per private key. Each cert chain should consist of the PEM formatted certificate for a provided private key, followed by the PEM formatted intermediate certificates (if any), in order, and not including the root CA (the root CA must be pre-known to the peer, see ca). When providing multiple cert chains, they do not have to be in the same order as their private keys in key. If the intermediate certificates are not provided, the peer will not be able to validate the certificate, and the handshake will fail.
ciphers:<string>
Cipher suite specification, replacing the default. For more information, see modifying the default cipher suite. Permitted ciphers can be obtained via tls.getCiphers(). Cipher names must be uppercased in order for OpenSSL to accept them.
clientCertEngine:<string>
Name of an OpenSSL engine which can provide the client certificate.
crl:
{string|Buffer |string|Buffer []} PEM formatted CRLs (Certificate Revocation Lists).
dhparam:
{string|Buffer } 'auto' or custom Diffie-Hellman parameters, required for non-ECDHE perfect forward secrecy. If omitted or invalid, the parameters are silently discarded and DHE ciphers will not be available. ECDHE-based perfect forward secrecy will still be available.
ecdhCurve:<string>
A string describing a named curve or a colon separated list of curve NIDs or names, for example P-521:P-384:P-256, to use for ECDH key agreement. Set to auto to select the curve automatically. Use crypto.getCurves() to obtain a list of available curve names. On recent releases, openssl ecparam -list_curves will also display the name and description of each available elliptic curve. Default: tls.DEFAULT_ECDH_CURVE.
enableTrace:<boolean>
When enabled, TLS packet trace information is written to  stderr . This can be used to debug TLS connection problems.
honorCipherOrder:<boolean>
Attempt to use the server's cipher suite preferences instead of the client's. When true, causes SSL_OP_CIPHER_SERVER_PREFERENCE to be set in secureOptions
isServer:<boolean>
If true the TLS socket will be instantiated in server-mode. Defaults to false.
key:
{string|Buffer |string|Buffer |KeyObject[]} Private keys in PEM format. PEM allows the option of private keys being encrypted. Encrypted keys will be decrypted with options.passphrase. Multiple keys using different algorithms can be provided either as an array of unencrypted key strings or buffers, or an array of objects in the form {pem: <string|buffer>[, passphrase:  ]}. The object form can only occur in an array. object.passphrase is optional. Encrypted keys will be decrypted with object.passphrase if provided, or options.passphrase if it is not.
maxVersion?:
{SecureVersion} Optionally set the maximum TLS version to allow. One of  'TLSv1.3' , 'TLSv1.2' , 'TLSv1.1' , or 'TLSv1' . Cannot be specified along with the secureProtocol option, use one or the other. Default: 'TLSv1.3' , unless changed using CLI options. Using --tls-max-v1.2 sets the default to 'TLSv1.2' . Using --tls-max-v1.3 sets the default to 'TLSv1.3' . If multiple of the options are provided, the highest maximum is used.
minVersion?:
{SecureVersion} Optionally set the minimum TLS version to allow. One of  'TLSv1.3' , 'TLSv1.2' , 'TLSv1.1' , or 'TLSv1' . Cannot be specified along with the secureProtocol option, use one or the other. It is not recommended to use less than TLSv1.2, but it may be required for interoperability. Default: 'TLSv1.2' , unless changed using CLI options. Using --tls-v1.0 sets the default to 'TLSv1' . Using --tls-v1.1 sets the default to 'TLSv1.1' . Using --tls-min-v1.3 sets the default to 'TLSv1.3'. If multiple of the options are provided, the lowest minimum is used.
passphrase:<string>
Shared passphrase used for a single private key and/or a PFX.
pfx:
{string|Buffer |string|Buffer |PxfObject[]} PFX or PKCS12 encoded private key and certificate chain. pfx is an alternative to providing key and cert individually. PFX is usually encrypted, if it is, passphrase will be used to decrypt it. Multiple PFX can be provided either as an array of unencrypted PFX buffers, or an array of objects in the form {buf: <string|buffer>[, passphrase:  ]}. The object form can only occur in an array. object.passphrase is optional. Encrypted PFX will be decrypted with object.passphrase if provided, or options.passphrase if it is not.
privateKeyEngine:<string>
Name of an OpenSSL engine to get private key from. Should be used together with privateKeyIdentifier.
privateKeyIdentifier:<string>
Identifier of a private key managed by an OpenSSL engine. Should be used together with privateKeyEngine. Should not be set together with key, because both options define a private key in different ways.
rejectUnauthorized:<boolean>
If true the server will reject any connection which is not authorized with the list of supplied CAs. This option only has an effect if requestCert is true.
requestCert:<boolean>
If true the server will request a certificate from clients that connect and attempt to verify that certificate. Defaults to false.
requestOCSP:<boolean>
If true, specifies that the OCSP status request extension will be added to the client hello and an 'OCSPResponse' event will be emitted on the socket before establishing a secure communication.
secureContext:
{SecureContext} An optional TLS context object from tls.createSecureContext()
secureOptions:<number>
Optionally affect the OpenSSL protocol behavior, which is not usually necessary. This should be used carefully if at all! Value is a numeric bitmask of the SSL_OP_* options from OpenSSL Options
secureProtocol:<string>
Legacy mechanism to select the TLS protocol version to use, it does not support independent control of the minimum and maximum version, and does not support limiting the protocol to TLSv1.3. Use minVersion and maxVersion instead. The possible values are listed as SSL_METHODS, use the function names as strings. For example, use 'TLSv1_1_method' to force TLS version 1.1, or 'TLS_method' to allow any TLS protocol version up to TLSv1.3. It is not recommended to use TLS versions less than 1.2, but it may be required for interoperability. Default: none, see minVersion.
server:
[ <Server> ]( /Server.html) An optional net.Server instance.
session:
{Buffer } An optional Buffer instance containing a TLS session.
sessionIdContext:<string>
Opaque identifier used by servers to ensure session state is not shared between applications. Unused by clients.
sessionTimeout:<number>
The number of seconds after which a TLS session created by the server will no longer be resumable. See Session Resumption for more information. Default: 300.
sigalgs:<string>
Colon-separated list of supported signature algorithms. The list can contain digest algorithms (SHA256, MD5 etc.), public key algorithms (RSA-PSS, ECDSA etc.), combination of both (e.g 'RSA+SHA384') or TLS v1.3 scheme names (e.g. rsa_pss_pss_sha512).
SNICallback:<object>
SNICallback(servername, cb)  A function that will be called if the client supports SNI TLS extension. Two arguments will be passed when called: servername and cb. SNICallback should invoke cb(null, ctx), where ctx is a SecureContext instance. (tls.createSecureContext(...) can be used to get a proper SecureContext.) If SNICallback wasn't provided the default callback with high-level API will be used (see below).
ticketKeys:
{Buffer } 48-bytes of cryptographically strong pseudo-random data. See Session Resumption for more information.
  • cancel {TransformerCancelCallback}
  • flush {TransformerFlushCallback}
  • readableType <undefined>
  • start {TransformerStartCallback}
  • transform {TransformerTransformCallback<I, O>}
  • writableType <undefined>
Attributes
reason:<any>
Returns:
{void|PromiseLike }
  • controller {TransformStreamDefaultController}
  • Returns: {void|PromiseLike}
  • controller {TransformStreamDefaultController}
  • Returns: <any>
  • chunk {I}
  • controller {TransformStreamDefaultController}
  • Returns: {void|PromiseLike}
  • readable {ReadableStream}
  • writable {WritableStream}
Attributes
desiredSize:<number> | <null>
  • chunk {O}
  • Returns: {void}
Attributes
reason:<any>
Returns:
{void}
Returns:
{void}

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.
  • {BaseStatement}
Attributes
<Node>
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 data
  • modules <string[]> tsconfig file data
Attributes
allContexts:<object>
all contexts (main + refs) for quick lookup
fileDependencies:
{Set } 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
  • {BaseExpression}
  • argument {Expression}
  • leadingComments <Comment[]>
  • loc <null>
  • operator {UnaryOperator}
  • prefix {true}
  • range {Tuple<number, number>}
  • trailingComments <Comment[]>
  • type {"UnaryExpression"}
Attributes
<Node>
  • argument {Expression}
  • end <number>
  • loc <null>
  • operator {UnaryOperator}
  • prefix <boolean>
  • range {Tuple<number, number>}
  • start <number>
  • type {"UnaryExpression"}
Attributes
autoAllocateChunkSize:<number>
cancel:
{UnderlyingSourceCancelCallback}
pull:<object>
start:<object>
type:
{"bytes"}
  • abort {UnderlyingSinkAbortCallback}
  • close {UnderlyingSinkCloseCallback}
  • start {UnderlyingSinkStartCallback}
  • type <undefined>
  • write {UnderlyingSinkWriteCallback}
Attributes
reason:<any>
Returns:
{void|PromiseLike }
Returns:
{void|PromiseLike }
Attributes
controller:<WritableStreamDefaultController>
Returns:<any>
Attributes
autoAllocateChunkSize:<number>
cancel:
{UnderlyingSourceCancelCallback}
pull:
{UnderlyingSourcePullCallback }
start:
{UnderlyingSourceStartCallback }
type:
{"bytes"}
Attributes
reason:<any>
Returns:
{void|PromiseLike }
  • controller {ReadableStreamController}
  • Returns: {void|PromiseLike}
  • controller {ReadableStreamController}
  • Returns: <any>
  • {BaseExpression}
  • argument {Expression}
  • leadingComments <Comment[]>
  • loc <null>
  • operator {UpdateOperator}
  • prefix <boolean>
  • range {Tuple<number, number>}
  • trailingComments <Comment[]>
  • type {"UpdateExpression"}
Attributes
<Node>
  • argument {Expression}
  • end <number>
  • loc <null>
  • operator {UpdateOperator}
  • prefix <boolean>
  • range {Tuple<number, number>}
  • start <number>
  • type {"UpdateExpression"}
Attributes
chunkGraph:<ChunkGraph>
runtime:
{RuntimeSpec}
runtimeTemplate:
[ <RuntimeTemplate> ]( /RuntimeTemplate.html)
Attributes
chunkGraph:<ChunkGraph>
module:<NormalModule>
the module
runtime:
{RuntimeSpec}
runtimeTemplate:
[ <RuntimeTemplate> ]( /RuntimeTemplate.html)
  • {URL_url}
Attributes
hash:<string>
host:<string>
hostname:<string>
href:<string>
origin:<string>
password:<string>
pathname:<string>
port:<string>
protocol:<string>
search:<string>
searchParams:<URLSearchParams>
username:<string>
Returns:<string>
Attributes
<URL>
Attributes
hash:<string>
host:<string>
hostname:<string>
href:<string>
origin:<string>
password:<string>
pathname:<string>
port:<string>
protocol:<string>
search:<string>
searchParams:<URLSearchParams>
username:<string>
Returns:<string>
Attributes
size:<number>
Returns:
{URLSearchParamsIterator<Tuple<string, string>>}
Attributes
name:<string>
value:<string>
Returns:
{void}
Attributes
name:<string>
value:<string>
Returns:
{void}
Returns:
{URLSearchParamsIterator<Tuple<string, string>>}
Attributes
callbackfn:<object>
thisArg:<any>
Returns:
{void}
Attributes
name:<string>
Returns:<string> | <null>
Attributes
name:<string>
Returns:<string[]>
Attributes
name:<string>
value:<string>
Returns:<boolean>
Returns:
{URLSearchParamsIterator }
Attributes
name:<string>
value:<string>
Returns:
{void}
Returns:
{void}
Returns:
{URLSearchParamsIterator }
  • {Iterator[<<T, NodeJS.BuiltinIteratorReturn, unknown>>](<T, NodeJS.html#class-t-nodejsbuiltiniteratorreturn-unknown)}
Returns:
{void}
Returns:
{URLSearchParamsIterator }
Attributes
count:<number>
The number of values to drop.
Returns:
{IteratorObject<T, undefined, unknown>}

Creates an iterator whose values are the values from this iterator after skipping the provided count.

Attributes
predicate:<object>
A function that accepts up to two arguments. The every method calls the predicate function for each element in this iterator until the predicate returns false, or until the end of this iterator.
Returns:<boolean>

Determines whether all the members of this iterator satisfy the specified test.

Call Signature
Attributes
predicate:<object>
A function that accepts up to two arguments to be used to test values from the underlying iterator.
Returns:
{IteratorObject<S, undefined, unknown>}

Creates an iterator whose values are those from this iterator for which the provided predicate returns true.

Call Signature
Attributes
predicate:<object>
A function that accepts up to two arguments to be used to test values from the underlying iterator.
Returns:
{IteratorObject<T, undefined, unknown>}

Creates an iterator whose values are those from this iterator for which the provided predicate returns true.

Call Signature
Attributes
predicate:<object>
find calls predicate once for each element of this iterator, in order, until it finds one where predicate returns true. If such an element is found, find immediately returns that element value. Otherwise, find returns undefined.
Returns:<undefined>

Returns the value of the first element in this iterator where predicate is true, and undefined otherwise.

Call Signature
Attributes
predicate:<object>
Returns:<undefined>
Attributes
callback:<object>
A function that accepts up to two arguments to be used to transform values from the underlying iterator into new iterators or iterables to be flattened into the result.
Returns:
{IteratorObject<U, undefined, unknown>}

Creates an iterator whose values are the result of applying the callback to the values from this iterator and then flattening the resulting iterators or iterables.

Attributes
callbackfn:<object>
A function that accepts up to two arguments. forEach calls the callbackfn function one time for each element in the iterator.
Returns:
{void}

Performs the specified action for each element in the iterator.

Attributes
callbackfn:<object>
A function that accepts up to two arguments to be used to transform values from the underlying iterator.
Returns:
{IteratorObject<U, undefined, unknown>}

Creates an iterator whose values are the result of applying the callback to the values from this iterator.

  • __namedParameters {Tuple|Tuple}
  • Returns: {IteratorResult<T, undefined>}
Call Signature
Attributes
callbackfn:<object>
A function that accepts up to three arguments. The reduce method calls the callbackfn function one time for each element in the iterator.
Returns:
{T}

Calls the specified callback function for all the elements in this iterator. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

Call Signature
Attributes
callbackfn:<object>
initialValue:
{T}
Returns:
{T}
Call Signature
Attributes
callbackfn:<object>
A function that accepts up to three arguments. The reduce method calls the callbackfn function one time for each element in the iterator.
initialValue:
{U} If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of a value from the iterator.
Returns:
{U}

Calls the specified callback function for all the elements in this iterator. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

Attributes
value:<undefined>
Returns:
{IteratorResult<T, undefined>}
Attributes
predicate:<object>
A function that accepts up to two arguments. The some method calls the predicate function for each element in this iterator until the predicate returns a value true, or until the end of the iterator.
Returns:<boolean>

Determines whether the specified callback function returns true for any element of this iterator.

Attributes
limit:<number>
The maximum number of values to yield.
Returns:
{IteratorObject<T, undefined, unknown>}

Creates an iterator whose values are the values from this iterator, stopping once the provided limit is reached.

Attributes
e:<any>
Returns:
{IteratorResult<T, undefined>}
Returns:
{T[]}

Creates a new array from the values yielded by this iterator.

  • [index: {string}] {Value[]}
  • {BaseDeclaration}
  • declarations {VariableDeclarator[]}
  • kind {"const"|"var"|"let"|"using"|"await using"}
  • leadingComments <Comment[]>
  • loc <null>
  • range {Tuple<number, number>}
  • trailingComments <Comment[]>
  • type {"VariableDeclaration"}
Attributes
<Node>
  • declarations {VariableDeclarator[]}
  • end <number>
  • kind {"const"|"var"|"let"|"using"|"await using"}
  • loc <null>
  • range {Tuple<number, number>}
  • start <number>
  • type {"VariableDeclaration"}
  • {BaseNode}
Attributes
<Node>
Attributes
end:<number>
id:
{Pattern}
init:<null>
loc:<null>
range:
{Tuple<number, number>}
start:<number>
type:
{"VariableDeclarator"}

A virtual module definition.

Attributes
context:<string>
The context for the virtual module. A string path. Defaults to 'auto', which will try to resolve the context from the module id.
source:<object>
The source function that provides the virtual content.
type:<string>
The module type.
version:<string> | <object>
Optional version function or value for cache invalidation.
  • [index: {string}] {VirtualModuleContent}

Options for building virtual resources.

Attributes
context:<string>
The default context for virtual modules. A string path. Defaults to 'auto', which will try to resolve the context from the module id.
modules:<object>
The virtual modules configuration.
scheme:<string>
The URL scheme to use for virtual resources.
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 directories
  • fileTimeInfoEntries {Map<string, "ignore"|EntryTypesIndex|OnlySafeTimeEntry|ExistenceOnlyTimeEntryTypesIndex|null>} get info about files
  • removals {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).
poll:<number> | <boolean>
Enable polling mode for watching.
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> ]( /DependencyTemplates.html) the dependency templates
moduleGraph:<ModuleGraph>
the module graph
runtimeTemplate:
[ <RuntimeTemplate> ]( /RuntimeTemplate.html) the runtime template
Attributes
devtool:<string> | <object[]>
Attributes
id:<string>
Returns:<any>
  • c {Record<string, ExecuteModuleObject>}
  • i <object[]>
  • {BaseStatement}
  • body {Statement}
  • leadingComments <Comment[]>
  • loc <null>
  • range {Tuple<number, number>}
  • test {Expression}
  • trailingComments <Comment[]>
  • type {"WhileStatement"}
Attributes
<Node>
  • body {Statement}
  • end <number>
  • loc <null>
  • range {Tuple<number, number>}
  • start <number>
  • test {Expression}
  • type {"WhileStatement"}
Attributes
id:<string> | <number>
Attributes
withOptions:<object>
create a resolver with additional/different options
  • {BaseStatement}
  • body {Statement}
  • leadingComments <Comment[]>
  • loc <null>
  • object {Expression}
  • range {Tuple<number, number>}
  • trailingComments <Comment[]>
  • type {"WithStatement"}
Attributes
<Node>
  • body {Statement}
  • end <number>
  • loc <null>
  • object {Expression}
  • range {Tuple<number, number>}
  • start <number>
  • type {"WithStatement"}
  • {StreamOptions}
  • [<DuplexOptions>](/Stream.html#interface-duplexoptions)
Attributes
autoDestroy:<boolean>
construct:<object>
decodeStrings:<boolean>
defaultEncoding:
{BufferEncoding}
destroy:<object>
emitClose:<boolean>
final:<object>
highWaterMark:<number>
objectMode:<boolean>
signal:<AbortSignal>
write:<object>
writev:<object>
  • [<EventEmitter>](/EventEmitter-1.html)
  • {ReadWriteStream}
Attributes
writable:<boolean>
Attributes
error:<Error>
event:<string> | <symbol>
args:<any[]>
Returns:
{void}

The Symbol.for('nodejs.rejection') method is called in case a promise rejection happens when emitting an event and captureRejections is enabled on the emitter. It is possible to use events.captureRejectionSymbol in place of Symbol.for('nodejs.rejection').

import { EventEmitter, captureRejectionSymbol } from 'node:events';

class MyClass extends EventEmitter {
  constructor() {
    super({ captureRejections: true });
  }

  [captureRejectionSymbol](err, event, ...args) {
    console.log('rejection happened for', event, 'with', err, ...args);
    this.destroy(err);
  }

  destroy(err) {
    // Tear the resource down here.
  }
}
JavaScript
Attributes
eventName:<string> | <symbol>
listener:<object>
Returns:<this>

Alias for emitter.on(eventName, listener).

Attributes
eventName:<string> | <symbol>
args:<any[]>
Returns:<boolean>

Synchronously calls each of the listeners registered for the event named eventName, in the order they were registered, passing the supplied arguments to each.

Returns true if the event had listeners, false otherwise.

import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();

// First listener
myEmitter.on('event', function firstListener() {
  console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
  console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
  const parameters = args.join(', ');
  console.log(`event with parameters ${parameters} in third listener`);
});

console.log(myEmitter.listeners('event'));

myEmitter.emit('event', 1, 2, 3, 4, 5);

// Prints:
// [
//   [Function: firstListener],
//   [Function: secondListener],
//   [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener
JavaScript
Call Signature
Attributes
cb:<object>
Returns:<this>
Call Signature
Call Signature
Attributes
str:<string>
encoding:
{BufferEncoding}
cb:<object>
Returns:<this>
Returns:<string> | <symbol[]>

Returns an array listing the events for which the emitter has registered listeners.

import { EventEmitter } from 'node:events';

const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});

const sym = Symbol('symbol');
myEE.on(sym, () => {});

console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]
JavaScript
Returns:<number>

Returns the current max listener value for the EventEmitter which is either set by emitter.setMaxListeners(n) or defaults to events.defaultMaxListeners.

Attributes
eventName:<string> | <symbol>
The name of the event being listened for
listener:<object>
The event handler function
Returns:<number>

Returns the number of listeners listening for the event named eventName. If listener is provided, it will return how many times the listener is found in the list of the listeners of the event.

Attributes
eventName:<string> | <symbol>
Returns:<object[]>

Returns a copy of the array of listeners for the event named eventName.

server.on('connection', (stream) => {
  console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]
JavaScript
Attributes
eventName:<string> | <symbol>
listener:<object>
Returns:<this>

Alias for emitter.removeListener().

Attributes
eventName:<string> | <symbol>
The name of the event.
listener:<object>
The callback function
Returns:<this>

Adds the listener function to the end of the listeners array for the event named eventName. No checks are made to see if the listener has already been added. Multiple calls passing the same combination of eventName and listener will result in the listener being added, and called, multiple times.

server.on('connection', (stream) => {
  console.log('someone connected!');
});
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

By default, event listeners are invoked in the order they are added. The emitter.prependListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
JavaScript
Attributes
eventName:<string> | <symbol>
The name of the event.
listener:<object>
The callback function
Returns:<this>

Adds a one-time listener function for the event named eventName. The next time eventName is triggered, this listener is removed and then invoked.

server.once('connection', (stream) => {
  console.log('Ah, we have our first user!');
});
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

By default, event listeners are invoked in the order they are added. The emitter.prependOnceListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
JavaScript
Attributes
eventName:<string> | <symbol>
The name of the event.
listener:<object>
The callback function
Returns:<this>

Adds the listener function to the beginning of the listeners array for the event named eventName. No checks are made to see if the listener has already been added. Multiple calls passing the same combination of eventName and listener will result in the listener being added, and called, multiple times.

server.prependListener('connection', (stream) => {
  console.log('someone connected!');
});
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

Attributes
eventName:<string> | <symbol>
The name of the event.
listener:<object>
The callback function
Returns:<this>

Adds a one-time listener function for the event named eventName to the beginning of the listeners array. The next time eventName is triggered, this listener is removed, and then invoked.

server.prependOnceListener('connection', (stream) => {
  console.log('Ah, we have our first user!');
});
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

Attributes
eventName:<string> | <symbol>
Returns:<object[]>

Returns a copy of the array of listeners for the event named eventName, including any wrappers (such as those created by .once()).

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));

// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];

// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();

// Logs "log once" to the console and removes the listener
logFnWrapper();

emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');

// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');
JavaScript
Attributes
eventName:<string> | <symbol>
Returns:<this>

Removes all listeners, or those of the specified eventName.

It is bad practice to remove listeners added elsewhere in the code, particularly when the EventEmitter instance was created by some other component or module (e.g. sockets or file streams).

Returns a reference to the EventEmitter, so that calls can be chained.

Attributes
eventName:<string> | <symbol>
listener:<object>
Returns:<this>

Removes the specified listener from the listener array for the event named eventName.

const callback = (stream) => {
  console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);
JavaScript

removeListener() will remove, at most, one instance of a listener from the listener array. If any single listener has been added multiple times to the listener array for the specified eventName, then removeListener() must be called multiple times to remove each instance.

Once an event is emitted, all listeners attached to it at the time of emitting are called in order. This implies that any removeListener() or removeAllListeners() calls after emitting and before the last listener finishes execution will not remove them from emit() in progress. Subsequent events behave as expected.

import { EventEmitter } from 'node:events';
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();

const callbackA = () => {
  console.log('A');
  myEmitter.removeListener('event', callbackB);
};

const callbackB = () => {
  console.log('B');
};

myEmitter.on('event', callbackA);

myEmitter.on('event', callbackB);

// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
//   A
//   B

// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
//   A
JavaScript

Because listeners are managed using an internal array, calling this will change the position indexes of any listener registered after the listener being removed. This will not impact the order in which listeners are called, but it means that any copies of the listener array as returned by the emitter.listeners() method will need to be recreated.

When a single function has been added as a handler multiple times for a single event (as in the example below), removeListener() will remove the most recently added instance. In the example the once('ping') listener is removed:

import { EventEmitter } from 'node:events';
const ee = new EventEmitter();

function pong() {
  console.log('pong');
}

ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);

ee.emit('ping');
ee.emit('ping');
JavaScript

Returns a reference to the EventEmitter, so that calls can be chained.

Attributes
n:<number>
Returns:<this>

By default EventEmitters will print a warning if more than 10 listeners are added for a particular event. This is a useful default that helps finding memory leaks. The emitter.setMaxListeners() method allows the limit to be modified for this specific EventEmitter instance. The value can be set to Infinity (or 0) to indicate an unlimited number of listeners.

Returns a reference to the EventEmitter, so that calls can be chained.

Call Signature
Call Signature
Attributes
str:<string>
encoding:
{BufferEncoding}
cb:<object>
Returns:<boolean>
Attributes
locked:<boolean>
Attributes
reason:<any>
Returns:
{Promise }
Returns:
{Promise }
Returns:
{WritableStreamDefaultWriter }
Attributes
signal:<AbortSignal>
Attributes
e:<any>
Returns:
{void}
Attributes
reason:<any>
Returns:
{Promise }
Returns:
{Promise }
Returns:
{void}
  • chunk {W}
  • Returns: {Promise}
  • file {PathOrFileDescriptorFs}
  • data {string|ArrayBufferView}
  • options {WriteFileOptions}
  • callback <object>
  • Returns: {void}
  • file {PathOrFileDescriptorFs}
  • data {string|ArrayBufferView}
  • callback <object>
  • Returns: {void}
Attributes
add:<object>
Attributes
multiLabelWildcards:<boolean>
partialWildcards:<boolean>
singleLabelSubdomains:<boolean>
subject:
{"default"|"never"|"always"}
wildcards:<boolean>
  • {BaseExpression}
Attributes
argument:<null>
delegate:<boolean>
leadingComments:<Comment[]>
loc:<null>
range:
{Tuple<number, number>}
trailingComments:<Comment[]>
type:
{"YieldExpression"}
Attributes
<Node>
Attributes
argument:<null>
delegate:<boolean>
end:<number>
loc:<null>
range:
{Tuple<number, number>}
start:<number>
type:
{"YieldExpression"}
Type:<object>
Attributes
resolveDependencies:<object>
resource:<string> | <string[]>
resourceFragment:<string>
resourceQuery:<string>
Type:<string>
Type:<string> | <string[]>
Type:<string> | <string[]>
Type:
{Hook<any, any>}
Type:
{NormalModuleLoaderContext |LoaderRunnerLoaderContext |LoaderPluginLoaderContext|HotModuleReplacementPluginLoaderContext}
Type:
{SchemaObject|AsyncSchema}
Type:<object>
Type:
{ArrayBufferTypes}
Type:
{TypedArray |DataView }
Type:
{T|Tuple }
Type:<string> | <RegExp> | <object>
Type:
{AssetInlineGeneratorOptions|AssetResourceGeneratorOptions}
Type:
{"="|"+="|"-="|"*="|"/="|"%="|"**="|"<<="|">>="|">>>="|"|="|"^="|"&="|"||="|"&&="|"??="}
Type:
{"="|"+="|"-="|"*="|"/="|"%="|"<<="|">>="|">>>="|"|="|"^="|"&="|"**="|"||="|"&&="|"??="}
Type:
{"dh"|"dsa"|"ec"|"ed25519"|"ed448"|MLDSAKeyType|MLKEMKeyType|"rsa-pss"|"rsa"|SLHDSAKeyType|"x25519"|"x448"}
Type:<string>
Type:<string> | <object>
Type:
{ContextResolveData|ContextOptions}
Type:<string> | <NodeJS.ArrayBufferView>
Type:
{"=="|"!="|"==="|"!=="|"<"|"<="|">"|">="|"<<"|">>"|">>>"|"+"|"-"|"*"|"/"|"%"|"**"|"|"|"^"|"&"|"in"|"instanceof"}
Type:
{"=="|"!="|"==="|"!=="|"<"|"<="|">"|">="|"<<"|">>"|">>>"|"+"|"-"|"*"|"/"|"%"|"|"|"^"|"&"|"in"|"instanceof"|"**"}
Type:<NodeJS.BufferSource> | <Blob> | <string>
Type:
{"ascii"|"utf8"|"utf-8"|"utf16le"|"utf-16le"|"ucs2"|"ucs-2"|"base64"|"base64url"|"latin1"|"binary"|"hex"}
Type:
{"ascii"|"utf8"|"utf-8"|"utf16le"|"utf-16le"|"ucs2"|"ucs-2"|"base64"|"base64url"|"latin1"|"binary"|"hex"}
Type:<object>
Type:<ArrayBuffer>

The BufferSource type from the Web IDL specification.

Type:
{KnownBuildInfo|Record<string, any>}
Type:
{KnownBuildMeta|Record<string, any>}
Type:
{intrinsic}

Defines the TReturn type used for built-in iterators produced by Array, Map, Set, and others. This is undefined when strictBuiltInIteratorReturn is true; otherwise, this is any.

Type:<any>
Type:<FileCacheOptions> | <MemoryCacheOptions>
Attributes
error:<null>
result:
{T}
Returns:
{void}
Type:
{SimpleCallExpression|NewExpression}
Type:
{SimpleCallExpression|NewExpression}
Type:<undefined>
Type:
{SimpleCallExpression|MemberExpression}
Type:<object>
Attributes
name:<null> | <string>
Type:<string> | <number>
Type:<null> | <string>
Type:
{ClassDeclaration|ClassExpression}
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
end:<number>
loc:
{SourceLocation}
start:<number>
Type:<string> | <Source>
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
close:<object>
write:<object>
Type:<undefined> | <string>
Type:
{FunctionDeclaration|VariableDeclaration|ClassDeclaration}
Type:
{FunctionDeclaration|VariableDeclaration|ClassDeclaration}
Type:
{FunctionDeclaration|VariableDeclaration|ClassDeclaration}
Type:<object> | <object> | <object> | <object> | <object> | <object> | <object> | <object>

Represents a variable definition.

Attributes
index:<number> | <null>
The index of the definition in a pattern, if applicable.
kind:<string> | <null>
The kind of variable (e.g., 'var', 'let', 'const'), if applicable.
name:<ESTree.Identifier>
The identifier node of the definition.
Type:
{SyntheticDependencyLocation|RealDependencyLocation}
Type:<string> | <object>
Type:<string> | <object>
Type:<object> | <object>

<object>

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.

<object>

  • 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:
{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[]>
Type:<null> | <string> | <number> | <boolean>
Type:
{ErrorObject}
Type:<Error> | <object>
Attributes
details:<string>
Type:
{EventListener|EventListenerObject}
Type:
{Record<T, any[]>}
Type:
{never|T}

Exclude from T those types that are assignable to U

Type:
{"module"|"chunk"|"root-of-chunk"|"nested"}
Type:
{ExperimentsCommon|ExperimentsExtra}
Type:
{ExperimentsCommon|ExperimentsNormalizedExtra}
Type:<string>
| [ <VariableInfo> ]( /VariableInfo.html)
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:
{Identifier|Literal|ThisExpression|ArrayExpression|ObjectExpression|FunctionExpression|UnaryExpression|UpdateExpression|BinaryExpression|AssignmentExpression|LogicalExpression|MemberExpression|ConditionalExpression|CallExpression|NewExpression|SequenceExpression|ArrowFunctionExpression|YieldExpression|TemplateLiteral|TaggedTemplateExpression|ClassExpression|MetaProperty|AwaitExpression|ChainExpression|ImportExpression|ParenthesizedExpression}
Type:
{ExpressionMap}
Type:
unknown
Attributes
formatExclusiveMaximum:<string> | <boolean>
format exclusive maximum
formatExclusiveMinimum:<string> | <boolean>
format exclusive minimum
formatMaximum:<string> | <number>
format maximum
formatMinimum:<string> | <number>
format minimum
link:<string>
link
undefinedAsNull:<boolean>
undefined will be resolved as null
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}
Type:<string> | <RegExp> | <object>
Type:
{void[]|ReadonlyArray |object}
Type:<object>
Type:<object>
Attributes
fn:<Function>
type:
{"sync"|"async"|"promise"}
Type:
{FunctionDeclaration|FunctionExpression|ArrowFunctionExpression}
Type:<GeneratorOptionsByModuleTypeKnown>
Type:<object> | <object> | <object>
Attributes
name:<null> | <string>
Attributes
entryOptions:<EntryOptions>
Attributes
circular:<boolean>
Type:<string>
| [ <Hash> ]( /Hash.html)
  • key {K}
  • Returns: {H}
Type:
{IStatsBase |object}
Attributes
atimeNs:<bigint>
birthtimeNs:<bigint>
ctimeNs:<bigint>
mtimeNs:<bigint>
Type:
{False|True}
Type:<object>
Type:<object> | <object>

<object>

Attributes
contextRegExp:<RegExp>
A RegExp to test the context (directory) against.
resourceRegExp:<RegExp>
A RegExp to test the request against.

<object>

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>
Attributes
error:<null>
result:
{T}
Returns:
{void}
Type:<any>

Obtain the return type of a constructor function type

Type:<InputFileSystem> | <OutputFileSystem>
Type:
{T|TOMBSTONE|UNDEFINED_MARKER}
Type:
{"ipv4"|"ipv6"}
Type:<undefined> | <null> | <Module>
Type:<null> | <string>
Type:
{IteratorYieldResult |IteratorReturnResult }
Type:
{ParserStateBase|Record<string, any>|KnownJavascriptParserState}
Type:
{JSONSchema4}
Type:<string> | <number> | <boolean> | <null>
Type:
{"string"|"number"|"integer"|"boolean"|"object"|"array"|"null"|"any"}
Type:
{JSONSchema6}
Type:<boolean>

JSON Schema V6

Type:<string> | <number> | <boolean> | <null>
Type:
{"string"|"number"|"integer"|"boolean"|"object"|"array"|"null"|"any"}
Type:
{JSONSchema7}
Type:<boolean>

JSON Schema v7

Type:<string> | <number> | <boolean> | <null>

Primitive type

Type:
{"string"|"number"|"integer"|"boolean"|"object"|"array"|"null"}

Primitive type

Type:<null> | <string> | <number> | <boolean>
Type:<null> | <string> | <number> | <boolean>
Type:
{SymmetricKeyExportOptions|PublicKeyExportOptions|PrivateKeyExportOptions|JwkKeyExportOptions}
Type:<object>
Type:
{"pem"|"der"|"jwk"}
Type:
{"secret"|"public"|"private"}
Type:
{"private"|"public"|"secret"}
Type:
{"decapsulateBits"|"decapsulateKey"|"decrypt"|"deriveBits"|"deriveKey"|"encapsulateBits"|"encapsulateKey"|"encrypt"|"sign"|"unwrapKey"|"verify"|"wrapKey"}
Type:
{object|Partial }
Type:<string> | <string[]>
Type:<string> | <string[]>
Type:
{SimpleLiteral|RegExpLiteral|BigIntLiteral}
Type:
{"||"|"&&"|"??"}
Type:
{"||"|"&&"|"??"}
Type:
{"error"|"warn"|"info"|"log"|"debug"|"clear"|"profile"|"trace"|"group"|"groupCollapsed"|"groupEnd"|"profileEnd"|"time"|"status"}
Attributes
hostname:<string>
options:<dns.LookupOptions>
callback:<object>
Returns:
{void}
Type:<string> | <RegExp> | <object> | <string> | <RegExp> | <object[]>
Type:
{T|never}
Type:<undefined> | <string>
Type:
{KnownMeta|Record<symbol, string[]>|Record<string, any>}
Type:
{unknown}
Type:
{unknown}
Type:
{ImportDeclaration|ExportNamedDeclaration|ExportDefaultDeclaration|ExportAllDeclaration}
Type:
{ImportDeclaration|ExportNamedDeclaration|ExportDefaultDeclaration|ExportAllDeclaration}
Type:<string> | <RegExp> | <object>
Type:<string> | <number>
Type:
{ConcatenatedModuleInfo|ExternalModuleInfo}
Type:
{ImportSpecifier|ImportDefaultSpecifier|ImportNamespaceSpecifier|ExportSpecifier}
Type:
{false|NodeOptions}
Type:
{NodeMap}
Type:<object>
Stability: 0Deprecated: This is intended for internal use, and will be removed once @types/node no longer supports TypeScript versions earlier than 5.7.
Type:
{ArrayBufferView }
Stability: 0Deprecated: This is intended for internal use, and will be removed once @types/node no longer supports TypeScript versions earlier than 5.7.
Type:
{Buffer }
Stability: 0Deprecated: This is intended for internal use, and will be removed once @types/node no longer supports TypeScript versions earlier than 5.7.
Type:
{Uint8Array }
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:
{Pick<T, Exclude<T, K>>}

Construct a type with the properties of T except for those in type K.

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:<number> | <string> | <string[]>
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:
{P|never}

Obtain the parameters of a function type in a tuple

Type:<ParserOptionsByModuleTypeKnown>
Type:
{unknown}

Make all properties in T optional

Type:<string> | <URL>
Type:<string>
Type:<string> | <number> | <URL>
Type:<string> | <number>
Type:
{Identifier|MemberExpression|ObjectPattern|ArrayPattern|RestElement|AssignmentPattern}
Type:
{Identifier|ObjectPattern|ArrayPattern|RestElement|AssignmentPattern|MemberExpression}
Type:
{Identifier|MemberExpression|ObjectPattern|ArrayPattern|RestElement|AssignmentPattern}
Type:
{unknown}

From T, pick a set of properties whose keys are in the union K

Type:<undefined> | <null> | <object> | <object>
Attributes
formattedError:<string>
error:
{SchemaUtilErrorObject}
Returns:<string>
Type:
{"pkcs1"|"pkcs8"|"sec1"}
Type:
{"unknown-argument"|"unexpected-non-array-in-path"|"unexpected-non-object-in-path"|"multiple-values-unexpected"|"invalid-value"}
Type:<object>
Type:<string>
Type:
{"pkcs1"|"spki"}
Type:<string>
Type:
{ReadableStreamDefaultController |ReadableByteStreamController}
Type:
{ReadableStreamDefaultReader |ReadableStreamBYOBReader}
Type:
{ReadableStreamReadValueResult |ReadableStreamReadDoneResult }
Type:
{unknown}

Make all properties in T readonly

Type:
[ <StreamOptions> ]( /Stream.html#interface-streamoptions) | <object>
Attributes
end:<number>
fs:<null>
Type:
{unknown}

Construct a type with a set of properties K of type T

Type:
{KnownRecords|Record<string, KnownRecords[]>|Record<string, any>}
Type:
{object|RecursiveArrayOrRecord []|T}
Type:<string> | <object>
Type:<string>
  • request {InstanceType}
  • response {InstanceType|object}
  • Returns: {void}
Type:
{unknown}

Make all properties in T required

Type:<ResolveOptions> | <object>
Attributes
dependencyType:<string>
resolveToContext:<boolean>
Type:
{BaseResolveRequest|Partial }
Type:<Resolver>
Type:<any>

Obtain the return type of a function type

Type:<string> | <RegExp> | <object>
Type:<string> | <RegExp> | <object> | <RuleSetCondition[]>
Type:<string> | <object>
Type:
{undefined|string|boolean|SortableSet }
Type:<string> | <number>
Type:
{undefined|string|SortableSet }
Type:
{JSONSchema4|JSONSchema6|JSONSchema7|ExtendedSchema}
Type:<object>
  • children {ErrorObject[]}
Type:<"TLSv1.3"> | <"TLSv1.2"> | <"TLSv1.1">
Type:
{ServerImportHttp |ServerImportHttps }
Type:<string>
Type:<undefined> | <string> | <boolean> | <string[]>
Type:
{"string"|"number"|"boolean"}
Type:
{unknown}
Type:<object>
Attributes
buildDependencies:<object>
immutablePaths:<string> | <RegExp[]>
managedPaths:<string> | <RegExp[]>
module:<object>
resolve:<object>
resolveBuildDependencies:<object>
unmanagedPaths:<string> | <RegExp[]>
Type:
{TcpSocketConnectOpts|IpcSocketConnectOpts}
Type:
{"opening"|"open"|"readOnly"|"writeOnly"|"closed"}
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:
{ExpressionStatement|BlockStatement|StaticBlock|EmptyStatement|DebuggerStatement|WithStatement|ReturnStatement|LabeledStatement|BreakStatement|ContinueStatement|IfStatement|SwitchStatement|ThrowStatement|TryStatement|WhileStatement|DoWhileStatement|ForStatement|ForInStatement|ForOfStatement|Declaration}
Type:
{ExpressionStatement|BlockStatement|EmptyStatement|DebuggerStatement|WithStatement|ReturnStatement|LabeledStatement|BreakStatement|ContinueStatement|IfStatement|SwitchStatement|ThrowStatement|TryStatement|WhileStatement|DoWhileStatement|ForStatement|ForInStatement|ForOfStatement|Declaration}
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:<StatsCompilation> | <StatsChunkGroup> | <StatsChunk> | <StatsChunkOrigin> | <StatsModule> | <StatsModuleReason> | <StatsAsset> | <StatsModuleTraceItem> | <StatsModuleTraceDependency> | <StatsError>
Type:
{KnownStatsPrinterColorFunctions|KnownStatsPrinterFormatters|KnownStatsPrinterContext|Record<string, any>}
Type:<boolean> | <StatsOptions>
Type:<undefined> | <string>
Type:<object>
Attributes
name:<string>
Type:
unknown
Attributes
before:<string>
stage:<number>
Type:
{Uint8Array |Uint8ClampedArray |Uint16Array |Uint32Array |Int8Array |Int16Array |Int32Array |BigUint64Array |BigInt64Array |Float16Array |Float32Array |Float64Array }
Type:
{"-"|"+"|"!"|"~"|"typeof"|"void"|"delete"}
Type:
{"-"|"+"|"!"|"~"|"typeof"|"void"|"delete"}
Type:
{KnownUnsafeCacheData|Record<string, any>}
Type:
{"++"|"--"}
Type:
{"++"|"--"}
Type:<string> | <TopLevelSymbol>
Type:
{0|1|2|3|4}
Type:<string> | <string[]>
Type:
{ValidationErrorConfiguration}
Type:
unknown
Attributes
baseDataPath:<string>
base data path
name:<string>
name
postFormatter:
{PostFormatter} post formatter
Type:<string> | <number> | <boolean> | <RegExp>
Type:
{string|Set }
Type:
{0|1|2|4}
Type:<string> | <object>
Type:<string> | <RegExp> | <object>
Type:<WebpackOptionsNormalized> | <object> | <object> | <object> | <object> | <object> | <object> | <object> | <object> | <object> | <object> | <object> | <object> | <object> | <object> | <object> | <object> | <object> | <object>
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:<null> | <object>
Type:
[ <StreamOptions> ]( /Stream.html#interface-streamoptions) | <object>
Attributes
flush:<boolean>
fs:<null>
Stability: 0Deprecated
Type:<string> | <object[]>
Type:
{boolean|SortableSet |null}
  • blobParts {BlobPart[]}
  • options {BlobPropertyBag}
  • Returns: <Blob>
Type:<symbol>
  • type {"CatchClause"|"Parameter"|"FunctionName"|"ClassName"|"Variable"|"ImportBinding"|"ImplicitGlobalVariable"} The type of definition (e.g., 'Variable', 'Parameter').
  • name {Identifier} The identifier node of the definition.
  • node {CatchClause|ClassDeclaration|ClassExpression|ArrowFunctionExpression|AssignmentExpression|FunctionExpression|FunctionDeclaration|ImportSpecifier|ImportDefaultSpecifier|ImportNamespaceSpecifier|ForInStatement|ForOfStatement|VariableDeclarator} The AST node where the definition occurs.
  • parent <null> The parent node, if applicable.
  • index <number> | <null> The index of the definition in a pattern, if applicable.
  • kind <string> | <null> The kind of variable (e.g., 'var', 'let', 'const'), if applicable.
  • Returns: {Definition}

Creates a new Definition instance.

Type:
{Float16ArrayConstructor}
Returns:<ReadableByteStreamController>

  • underlyingSource {UnderlyingByteSource}

  • strategy <object>

  • Returns: {ReadableStream}

  • underlyingSource {UnderlyingDefaultSource}

  • strategy {QueuingStrategy}

  • Returns: {ReadableStream}

  • underlyingSource {UnderlyingSource}

  • strategy {QueuingStrategy}

  • Returns: {ReadableStream}

Returns:<ReadableStreamBYOBRequest>
Returns:<ReadableStreamDefaultController>
  • stream {ReadableStream}
  • Returns: {ReadableStreamDefaultReader}
Type:<symbol>
  • transformer {Transformer<I, O>}
  • writableStrategy {QueuingStrategy}
  • readableStrategy {QueuingStrategy}
  • Returns: {TransformStream<I, O>}
Returns:<TransformStreamDefaultController>
Type:<symbol>
Type:<symbol>
Attributes
url:<string> | <URL>
base:<string> | <URL>
Returns:<URL>
  • init {string|Record<string, string>|string[][]|URLSearchParams}
  • Returns: <URLSearchParams>
  • underlyingSink {UnderlyingSink}
  • strategy {QueuingStrategy}
  • Returns: {WritableStream}
Returns:<WritableStreamDefaultController>
  • stream {WritableStream}
  • Returns: {WritableStreamDefaultWriter}
  • schema {Schema} schema
  • options <object> | <object[]> options
  • configuration {ValidationErrorConfiguration} configuration
  • Returns: {void}
Type:
{Readonly }
webpack.validate(configuration): void
Attributes
configuration:<Configuration> | <MultiConfiguration>
Returns:
{void}
webpack.validateSchema(schema, options, validationConfiguration?): void
  • schema {Parameters}
  • options {Parameters}
  • validationConfiguration {ValidationErrorConfiguration}
  • Returns: {void}
Type:<string>
Type:
{_functionWebpack}
webpack(options, callback): void
Attributes
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