Keyword index

One line: Every keyword, operator and API a page here is the home of, and that page; each page names its terms on its **Keywords:** line, and this index is generated from those lines by tools/check_pages.py --fix.

733 terms. Terms that start with punctuation (?., ??, #private) sort after the words.

Keyword or API	Where it is explained
AbortController	Cancellation
AbortError	Cancellation
AbortSignal	Cancellation
AbortSignal.any	Cancellation
AbortSignal.timeout	Cancellation
abstract	abstract and implements
Access-Control-Allow-Origin	fetch and CORS
addEventListener	DOM events
agent	One thread per agent
agent cluster	One thread per agent
AggregateError	all, allSettled, race and any
--allow-read	Deno and Bun
allowImportingTsExtensions	Module resolution
ambient declaration	Declaration files
any	any, unknown and never, any is contagious
apply	call, apply and bind
arguments	Parameters
Array	Arrays
array covariance	Array covariance
Array.from	Arrays
Array.fromAsync	Async iteration
Array.isArray	Arrays
Array.of	Arrays
Array.prototype.with	Mutating and copying methods
Array<T>	Arrays and tuples
ArrayBuffer	Typed arrays and ArrayBuffer
arrow function	Arrow functions
as	satisfies, as and annotations, Type assertions
as const	Primitive and literal types
as unknown as	Type assertions
ASI	Automatic semicolon insertion
asserts	Type predicates
async	async and await
async attribute	Loading scripts
async function	async and await
async function*	Async iteration
at	Arrays, String methods
Atomics	SharedArrayBuffer and Atomics
Atomics.add	SharedArrayBuffer and Atomics
Atomics.notify	SharedArrayBuffer and Atomics
Atomics.wait	SharedArrayBuffer and Atomics
automatic semicolon insertion	Automatic semicolon insertion
await	async and await
await using	using and Symbol.dispose
Awaited	Utility types
backtick	Template literals
BigInt	BigInt
BigInt.asIntN	BigInt
BigInt.asUintN	BigInt
bind	call, apply and bind
block scope	var, let and const
Boolean()	Converting on purpose
branded type	Branded types
break	Loops
Buffer	Buffer
Buffer.alloc	Buffer
Buffer.allocUnsafe	Buffer
Buffer.from	Buffer
Buffer.poolSize	Buffer
Bun	Deno and Bun
bundler	Module resolution, Bundlers and transpilers
call	call, apply and bind
cancelAnimationFrame	The rendering loop
Capitalize	Template literal types
case	if, switch and ? :
cause	Custom errors and cause
cents	Money
charCodeAt	Strings are UTF-16
--check	Running a file with Node
--checkers	TypeScript 7
child_process	Child processes
chrome://inspect	Debugging Node
circular import	Module cycles
.cjs	ES modules and CommonJS
class	Classes
ClassMethodDecoratorContext	Decorators
clearTimeout	Timers
closure	Closures
code point	Code points
code unit	Strings are UTF-16
codePointAt	Code points
CommonJS	ES modules and CommonJS
comparator	sort() compares strings
computed property name	Object literals
concatenation	The + operator
conditional type	Conditional types
configurable	Property descriptors
const	var, let and const, const is not frozen
const enum	Enums
const type parameter	const type parameters
contextual typing	Annotations and inference
continue	Loops
contravariance	Variance
control flow analysis	Narrowing
CORS	fetch and CORS
covariance	Variance
createReadStream	Streams
createRequire	require and ES modules
createServer	HTTP
crypto.getRandomValues	Random numbers
crypto.randomUUID	Random numbers
currency	Money
.d.ts	Declaration files
data types	Eight types
DataCloneError	postMessage
DataView	Typed arrays and ArrayBuffer
Date	Date months start at zero
Date.now	Measuring elapsed time
Date.parse	Parsing dates
debugger	Debugging Node
decimal	Money
declaration merging	Declaration merging
declare	Declaration files
declare global	Declaration merging
declare module	Declaration merging
decorators	Decorators
default parameters	Parameters
default type argument	Generic types
defer	Loading scripts
DefinitelyTyped	Types for packages
Deno	Deno and Bun
deref	WeakRef and FinalizationRegistry
description	Symbols
destructuring	Destructuring
destructuring assignment	Destructuring
difference	Grouping and set operations
--disallow-code-generation-from-strings	eval and new Function
discriminated union	Discriminated unions
DisposableStack	using and Symbol.dispose
distributive conditional type	Conditional types
do...while	Loops
document	The DOM
document.cookie	Storage
DOM	The DOM
DOMContentLoaded	Loading scripts
done	The iteration protocol
dotAll	Regex literals and flags
double	Every number is a double
drain	Streams
drop	Iterator helpers
duck typing	Structural typing
ECMA-262	ECMAScript versions
ECMAScript	The language and the host
emit	EventEmitter
empty item	Holes
enum	Enums
enumerable	Property descriptors
--env-file	process
eqeqeq	Lints around values and types
erasableSyntaxOnly	Erasable syntax
ERR_PACKAGE_PATH_NOT_EXPORTED	package.json
ERR_REQUIRE_ASYNC_MODULE	require and ES modules
ERR_REQUIRE_CYCLE_MODULE	Module cycles
ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX	Erasable syntax, Parameter properties
Error	throw and try...catch
error event	EventEmitter
error-first callback	Callbacks
Error.captureStackTrace	Stack traces
Error.isError	throw and try...catch
error.stack	Stack traces
Error.stackTraceLimit	Stack traces
ErrorOptions	Custom errors and cause
ES2015	ECMAScript versions
ES6	ECMAScript versions
esbuild	Bundlers and transpilers
ESLint	ESLint
eslint.config.js	ESLint
eval	eval and new Function
EvalError	Built-in error types
event delegation	DOM events
event loop	The event loop
event loop delay	Blocking the event loop
event.currentTarget	DOM events
event.target	DOM events
EventEmitter	EventEmitter
excess property check	Excess property checks
exec	match, matchAll and exec, Child processes
execFile	Child processes
exhaustiveness checking	Exhaustiveness checking
--experimental-transform-types	Erasable syntax
experimentalDecorators	Decorators
explicit type argument	When inference guesses wrong
export	import and export
export default	import and export
export type	Type-only imports
"exports"	package.json
--expose-gc	Measuring memory
extends	extends and super, Constraints
extends Error	Custom errors and cause
falsy	Truthy and falsy
fetch	HTTP
fileURLToPath	Paths and file URLs
filter	map, filter, reduce and friends
FinalizationRegistry	WeakRef and FinalizationRegistry
finally	finally
find	map, filter, reduce and friends
flags	Regex literals and flags
floating point	Every number is a double
fn.length	Functions are objects
fn.name	Functions are objects
for	Loops
for await...of	Async iteration
for...in	Own and inherited properties, for...in and for...of
for...of	for...in and for...of
forEach	map, filter, reduce and friends
formatToParts	Formatting dates
fs/promises	Files
function	Declarations, expressions and arrows
function expression	Declarations, expressions and arrows
function type	Function types
function*	Generators
garbage collection	Reachability
Generator	Generators
generic class	Generic types
generic constraint	Constraints
generic interface	Generic types
generics	Generic functions
get	Getters and setters
getDay	Date months start at zero
getMonth	Date months start at zero
getOwnPropertySymbols	Symbols
getTimezoneOffset	Time zones
global	The global object
globalThis	The global object
grapheme	Graphemes
--harmony	Which features your Node has
hasIndices	Regex literals and flags
hasOwnProperty	Own and inherited properties
heapUsed	Measuring memory
higher-order function	Higher-order functions
highWaterMark	Streams
hoisting	Hoisting and the temporal dead zone
hole	Holes
host environment	The language and the host
HttpOnly	Storage
IEEE 754	Every number is a double
if...else	if, switch and ? :
--ignoreConfig	tsc and tsconfig.json
IIFE	Closures in loops
immutable	Eight types
immutable binding	const is not frozen
implements	abstract and implements
implicit index signature	Recursive types
import	import and export
import * as	import and export
import type	Type-only imports
import()	Dynamic import() and top-level await
import.meta	import.meta
import.meta.dirname	Paths and file URLs
import.meta.main	import.meta
import.meta.resolve	import.meta
import.meta.url	import.meta
"imports"	package.json
in	Own and inherited properties
index signature	Object types
indexed access type	Indexed access types
IndexedDB	Storage
infer	Conditional types
Infinity	NaN, Infinity and -0
--input-type	Scripts and modules
--inspect	Debugging Node
--inspect-brk	Debugging Node
instanceof	instanceof
interface	Type aliases and interfaces
intersection	Grouping and set operations
intersection type	Union and intersection types
Intl.Collator	Comparing and sorting strings
Intl.DateTimeFormat	Formatting dates
Intl.NumberFormat	Rounding and formatting
Intl.Segmenter	Graphemes
Invalid Date	Parsing dates
is	Type predicates
IsLessThan	< and >
isMainThread	Worker threads
isNaN	NaN, Infinity and -0
isTTY	stdin, stdout and pipes
isWellFormed	Strings and bytes
iterable	The iteration protocol
Iterator	Iterator helpers
Iterator.from	Iterator helpers
JSON.parse	JSON, External data
JSON.stringify	JSON
key remapping	Mapped types
keyof	keyof and typeof in types
keyof typeof	keyof and typeof in types
label	Loops
language server	Editor setup
lastIndex	The g flag and lastIndex
length	Arrays, Strings are UTF-16
let	var, let and const
lexical scope	Closures
libuv	The event loop
literal type	Primitive and literal types
live binding	Live bindings
localeCompare	Comparing and sorting strings
localStorage	Storage
lone surrogate	Strings and bytes
long task	The rendering loop
Lowercase	Template literal types
LSP	Editor setup
map	map, filter, reduce and friends
Map	Map and Set
Map.groupBy	Grouping and set operations
mapped type	Mapped types
mark-and-sweep	Reachability
match	match, matchAll and exec
matchAll	match, matchAll and exec
Math.floor	Rounding and formatting
Math.random	Random numbers
Math.round	Rounding and formatting
Math.trunc	Rounding and formatting
--max-old-space-size	Measuring memory
Maximum call stack size exceeded	Recursion and the call stack
MaxListenersExceededWarning	Memory leaks
memory leak	Memory leaks
MessageChannel	postMessage
method bivariance	Array covariance
microtask	Microtasks and tasks
.mjs	ES modules and CommonJS
mock.timers	The built-in test runner
module augmentation	Declaration merging
module goal	Scripts and modules
module.exports	ES modules and CommonJS
moduleResolution	Module resolution
money	Money
monitorEventLoopDelay	Blocking the event loop
(?<name>…)	Named groups and replacements
NaN	NaN, Infinity and -0
narrowing	Narrowing
never	any, unknown and never, Exhaustiveness checking
new	new
new Boolean	Primitives and wrappers
new Function	eval and new Function
new Number	Primitives and wrappers
new String	Primitives and wrappers
new.target	new
next	The iteration protocol
NFC	Normalization
NFD	Normalization
NFKC	Normalization
NFKD	Normalization
no-await-in-loop	Sequential or parallel
no-compare-neg-zero	Lints around values and types
no-cond-assign	ESLint
no-constant-binary-expression	Lints around values and types
no-extend-native	Lints around values and types
no-floating-promises	ESLint
no-implicit-coercion	Lints around values and types
no-loss-of-precision	Lints around values and types
no-new-native-nonconstructor	Lints around values and types
no-new-wrappers	Lints around values and types
no-shadow-restricted-names	Lints around values and types
--no-strip-types	Running TypeScript
no-undef-init	Lints around values and types
node --test	The built-in test runner
node -e	Running a file with Node
node -p	Running a file with Node
node inspect	Debugging Node
node:assert	The built-in test runner
node:http	HTTP
node:test	The built-in test runner
node_modules/.bin	npm run and npx
nodenext	Module resolution
noEmit	Running TypeScript
noImplicitAny	strict
noImplicitOverride	readonly and override
NoInfer	When inference guesses wrong
nominal typing	Branded types
non-null assertion	strictNullChecks, Type assertions
normalize	Normalization
noUncheckedIndexedAccess	Index access
npm ci	npm
npm install	npm
npm run	npm run and npx
npm_lifecycle_event	npm run and npx
npx	npm run and npx
null	null and undefined
Number()	Converting on purpose
Number.EPSILON	Every number is a double
Number.isFinite	NaN, Infinity and -0
Number.isNaN	NaN, Infinity and -0
Number.isSafeInteger	Safe integers
Number.MAX_SAFE_INTEGER	Safe integers
Number.MIN_SAFE_INTEGER	Safe integers
object	object, Object and {}
Object	object, Object and {}
object identity	Values and references
object literal	Object literals
object reference	Values and references
Object.assign	Copying objects
Object.create	The prototype chain
Object.defineProperty	Property descriptors
Object.freeze	freeze, seal and preventExtensions
Object.getOwnPropertyDescriptor	Property descriptors
Object.getOwnPropertyNames	Property keys
Object.getPrototypeOf	The prototype chain
Object.groupBy	Grouping and set operations
Object.hasOwn	Own and inherited properties
Object.is	Object.is, NaN and -0
Object.isFrozen	freeze, seal and preventExtensions
Object.keys	Property keys
Object.preventExtensions	freeze, seal and preventExtensions
Object.seal	freeze, seal and preventExtensions
Object.setPrototypeOf	The prototype chain
objectWrap	Prettier
Omit	Utility types
once	EventEmitter
optional parameter	Function types
optional property	Object types
os.availableParallelism	One thread per agent
overload	Function types
override	readonly and override
package-lock.json	npm
package.json	npm
padStart	String methods
parameter property	Parameter properties
parentPort	Worker threads
parseFloat	Parsing numbers
parseInt	Parsing numbers
Partial	Utility types
pass by reference	Values and references
pass by sharing	Values and references
path.join	Paths and file URLs
path.resolve	Paths and file URLs
per-iteration binding	Closures in loops
performance.now	Measuring elapsed time
performance.timeOrigin	Measuring elapsed time
--permission	Deno and Bun
Pick	Utility types
polymorphic this	this in types
postMessage	postMessage
preflight	fetch and CORS
Prettier	Prettier
prettier-ignore	Prettier
.prettierrc	Prettier
primitive	Eight types
printWidth	Prettier
#private	Private fields
private	private versus #private
#private in obj	Private fields
process.argv	process
process.cwd	Paths and file URLs
process.env	process
process.exit	process
process.exitCode	process
process.features.typescript	Running TypeScript
process.hrtime.bigint	Measuring elapsed time
process.memoryUsage	Measuring memory
process.nextTick	Microtasks and tasks
process.stdin	stdin, stdout and pipes
process.stdout	stdin, stdout and pipes
process.version	Which features your Node has
process.versions	Which features your Node has
Promise	Promises
Promise.all	Sequential or parallel, all, allSettled, race and any
Promise.allSettled	all, allSettled, race and any
Promise.any	all, allSettled, race and any
Promise.race	all, allSettled, race and any
Promise.try	Promises
Promise.withResolvers	Promises
protected	private versus #private
Proxy	Proxy and Reflect
Proxy.revocable	Proxy and Reflect
public	private versus #private
queueMicrotask	Microtasks and tasks
radix	Parsing numbers
randomInt	Random numbers
RangeError	Built-in error types
reachability	Reachability
readFile	Files
readFileSync	Files
readline	stdin, stdout and pipes
readonly	Object types
-readonly	Mapped types
ReadonlyArray	Arrays and tuples
Record	Utility types
recursive type	Recursive types
reduce	map, filter, reduce and friends
ReferenceError	Built-in error types
Reflect	Proxy and Reflect
Reflect.ownKeys	Property keys
RegExp	Regex literals and flags
RegExp.escape	RegExp.escape
REPL	Running a file with Node
replace	Named groups and replacements
replaceAll	String methods
requestAnimationFrame	The rendering loop
require	require and ES modules
require(esm)	require and ES modules
Response.json	External data
response.ok	HTTP
rest parameters	Parameters
ReturnType	Utility types
reverse	Mutating and copying methods
rewriteRelativeImportExtensions	Module resolution
run-to-completion	Run to completion
runtime validation	Run-time validation
safe integer	Safe integers
same-origin policy	fetch and CORS
SameValue	Object.is, NaN and -0
SameValueZero	Object.is, NaN and -0
satisfies	satisfies, as and annotations
schema validation	Run-time validation
script goal	Scripts and modules
<script type="module">	Loading scripts
semver	npm
sessionStorage	Storage
set	Getters and setters
Set	Map and Set
setImmediate	Timers
setInterval	Timers
setMaxListeners	Memory leaks, EventEmitter
setMonth	Date months start at zero
setTimeout	Timers
SharedArrayBuffer	SharedArrayBuffer and Atomics
shorthand property	Object literals
--showConfig	tsc and tsconfig.json
--singleThreaded	TypeScript 7
slice	String methods
sloppy mode	Strict mode
some	map, filter, reduce and friends
sort	sort() compares strings
soundness	Array covariance
source map	Bundlers and transpilers
sparse array	Holes
spawn	Child processes
spawnSync	Child processes
splice	Mutating and copying methods
split	String methods
--stack-size	Recursion and the call stack
--stack-trace-limit	Stack traces
Stage 4	ECMAScript versions
static	Static members and static blocks
static type checking	What TypeScript adds
static {}	Static members and static blocks
sticky	Regex literals and flags
stopPropagation	DOM events
stream.pipeline	Streams
strict	strict
strict mode	Strict mode
strictBindCallApply	strict
strictBuiltinIteratorReturn	strict
strictFunctionTypes	Variance
strictNullChecks	strictNullChecks
strictPropertyInitialization	strict
String()	Converting on purpose
String.fromCharCode	Strings are UTF-16
String.fromCodePoint	Code points
String.raw	Tagged templates
stripTypeScriptTypes	Types are erased
structural typing	Structural typing
structuredClone	Copying objects
substring	String methods
super	extends and super
SuppressedError	using and Symbol.dispose
surrogate pair	Strings are UTF-16
switch	if, switch and ? :
Symbol	Symbols
Symbol.asyncIterator	Async iteration
Symbol.dispose	using and Symbol.dispose
Symbol.for	Symbols
Symbol.hasInstance	instanceof, Well-known symbols
Symbol.isConcatSpreadable	Well-known symbols
Symbol.iterator	The iteration protocol
Symbol.keyFor	Symbols
Symbol.toPrimitive	ToPrimitive
Symbol.toStringTag	Well-known symbols
symmetricDifference	Grouping and set operations
SyntaxError	Built-in error types
T[K]	Indexed access types
T[number]	Indexed access types
tagged template	Tagged templates
tagged union	Discriminated unions
tail call	Recursion and the call stack
take	Iterator helpers
TC39	ECMAScript versions
TDZ	Hoisting and the temporal dead zone
template literal	Template literals
template literal type	Template literal types
Temporal	Temporal
temporal dead zone	Hoisting and the temporal dead zone
Temporal.Instant	Temporal
Temporal.PlainDate	Temporal
Temporal.ZonedDateTime	Temporal
test	The g flag and lastIndex
TextDecoder	Strings and bytes
TextEncoder	Strings and bytes
then	Promises
thenable	Promises
this	this
this parameter	this in types
this type	this in types
throw	throw and try...catch
timers/promises	Timers
toArray	Iterator helpers
ToBoolean	Truthy and falsy
toFixed	Rounding and formatting
toISOString	Formatting dates
toJSON	JSON
toLocaleLowerCase	Case conversion
toLocaleString	Formatting dates
toLocaleUpperCase	Case conversion
toLowerCase	Case conversion
top-level await	Dynamic import() and top-level await
toPrecision	Rounding and formatting
ToPrimitive	ToPrimitive
toReversed	Mutating and copying methods
toSorted	Mutating and copying methods
toSpliced	Mutating and copying methods
toString	ToPrimitive
toUpperCase	Case conversion
toWellFormed	Strings and bytes
transfer list	postMessage
transpiler	Bundlers and transpilers
truthiness narrowing	Truthiness narrowing
truthy	Truthy and falsy
try...catch	throw and try...catch
tsc	tsc and tsconfig.json
tsc --lsp	Editor setup
tsconfig.json	tsc and tsconfig.json
tuple	Arrays and tuples
type alias	Type aliases and interfaces
type annotation	Annotations and inference
type argument inference	Generic functions
type assertion	Type assertions
type erasure	Types are erased
type error	What TypeScript adds
type guard	Narrowing
type inference	Annotations and inference
type parameter	Generic functions
type predicate	Type predicates
"type": "module"	package.json
TypedArray	Typed arrays and ArrayBuffer
TypeError	Built-in error types
typeof	typeof
typeRoots	Types for packages
@types	Types for packages
types	Types for packages
TypeScript 7	TypeScript 7
typescript-eslint	ESLint
typescript-go	TypeScript 7
TZ	Time zones
Uint8Array	Typed arrays and ArrayBuffer
Uint8ClampedArray	Typed arrays and ArrayBuffer
unary +	Converting on purpose
Uncapitalize	Template literal types
uncaughtException	Unhandled errors
undefined	null and undefined
--unhandled-rejections	Unhandled errors
unhandledRejection	Unhandled errors
unicodeSets	Unicode mode
union	Grouping and set operations
union type	Union and intersection types
unique symbol	Branded types
unknown	any, unknown and never
unref	Timers
Uppercase	Template literal types
URIError	Built-in error types
use strict	Strict mode
use-isnan	Lints around values and types
useUnknownInCatchVariables	strict
using	using and Symbol.dispose
UTF-16	Strings are UTF-16
util.callbackify	Callbacks
util.promisify	Callbacks
V8	Which features your Node has
--v8-options	Which features your Node has
v8.writeHeapSnapshot	Measuring memory
valid-typeof	Lints around values and types
valueOf	ToPrimitive
var	var, let and const
variance	Variance
verbatimModuleSyntax	Type-only imports
Vite	Bundlers and transpilers
void	null and undefined
VS Code	Editor setup
vtsls	Editor setup
weak type	Excess property checks
WeakMap	WeakMap and WeakSet
WeakRef	WeakRef and FinalizationRegistry
WeakSet	WeakMap and WeakSet
well-known symbols	Well-known symbols
while	Loops
widening	Primitive and literal types
window	The global object, The DOM
Worker	Worker threads
worker_threads	Worker threads
workerData	Worker threads
wrapper object	Primitives and wrappers
writable	Property descriptors
Writable	Streams
writeFile	Files
yield	Generators
yield*	Generators
Zed	Editor setup
? :	if, switch and ? :
!!	Truthy and falsy
!=	=== and ==
!==	=== and ==
$&	Named groups and replacements
$<name>	Named groups and replacements
${...}	Template literals
&	Bitwise operators
&&	Short-circuit evaluation
&&=	Short-circuit evaluation
+	The + operator
+=	The + operator
-?	Mapped types
-0	NaN, Infinity and -0
<	< and >
<<	Bitwise operators
<=	< and >
==	=== and ==
===	=== and ==
=>	Arrow functions
>	< and >
>=	< and >
>>>	Bitwise operators
?.	?. and ??
??	?. and ??, Short-circuit evaluation
??=	?. and ??, Short-circuit evaluation
\p{RGI_Emoji}	Unicode mode
\p{…}	Unicode mode
\u{...}	Code points
^	Bitwise operators
__proto__	Object literals, The prototype chain
|	Bitwise operators
||	Short-circuit evaluation
||=	Short-circuit evaluation
{}	object, Object and {}
~	Bitwise operators
(?<=…)	Lookbehind
(?<!…)	Lookbehind