Node.js Documentation
Errors
Events
Guides
- "exports"
- "imports"
- "main"
- "name"
- "type"
- --input-type flag
- A note on process I/O
- ABORT_ERR
- AES keys
- ALPN and SNI
- ALPN negotiation
- API
- API for stream consumers
- API for stream implementers
- About this documentation
- Accessing core Node.js modules
- Accessing the main module
- Additional notes
- Additions to Error objects
- Addon examples
- Advanced serialization
- Advanced usage
- Algorithm matrix
- Algorithm parameters
- All together
- An example counting stream
- An example duplex stream
- An example writable stream
- Assets
- Assignment of the _ (underscore) variable
- Async Iteration
- Asynchronous context example
- Asynchronous hooks accepted by module.register()
- Asynchronous process creation
- Asynchronous thread-safe function calls
- Asynchronous version
- Asynchronous vs. synchronous
- Availability
- Avoiding duplicate warnings
- Awaiting multiple events emitted on process.nextTick()
- Background colors
- Basic Extension Errors
- Basic Node-API data types
- Blob objects and MessageChannel
- Breakpoints
- BroadcastChannel
- Brotli constants
- Buffer constants
- Buffer paths
- Buffer.from(), Buffer.alloc(), and Buffer.allocUnsafe()
- Buffering
- Buffers and TypedArrays
- Buffers and character encodings
- Buffers and iteration
- Build tools
- Build with a pre-installed ICU (system-icu)
- Building
- Building
- Built-in modules
- Built-in modules
- Built-in modules with mandatory node: prefix
- C++ addons
- C++ embedder API
- CCM mode
- CERT_CHAIN_TOO_LONG
- CERT_HAS_EXPIRED
- CERT_NOT_YET_VALID
- CERT_REJECTED
- CERT_REVOKED
- CERT_SIGNATURE_FAILURE
- CERT_UNTRUSTED
- CPU profiler
- CRL_HAS_EXPIRED
- CRL_NOT_YET_VALID
- CRL_SIGNATURE_FAILURE
- Caching
- Call results
- Callback API
- Callback API
- Callback API
- Callback example
- Callbacks
- Calling a thread-safe function
- Cancelling timers
- Capture rejections of promises
- Caveat in the asynchronous load hook
- Caveats
- Certificate object
- Chaining
- Choose one API style
- Class FormData
- Class Headers
- Cleanup on exit of the current Node.js environment
- Client-initiated renegotiation attack mitigation
- Client-side example
- Cloning an IntervalHistogram
- Collect trace events data by inspector
- Collecting HTTP/2 performance metrics
- Command reference
- Command-line API
- Commands and special keys
- Common Objects
- Common Objects
- Common system errors
- CommonJS Namespaces
- Communication with module customization hooks
- Community Conditions Definitions
- Comparison details
- Compatibility API
- Compatibility with older Node.js versions
- Compressing HTTP requests and responses
- Compressor options
- Conditional exports
- Configuration
- Conflict resolution constants
- Considerations when cloning objects with prototypes, classes, and accessors
- Considerations when transferring TypedArrays and Buffers
- Console
- Constants
- Constructing a URL from component parts and getting the constructed string
- Consuming readable streams with async iterators
- Context-aware addons
- Contributing
- Convenience methods
- Conventions of hooks
- Core API
- Corepack
- Coverage output
- Coverage reporters
- Creating readable streams with async generators
- Creation
- Crypto
- Crypto constants
- CryptoKey
- Custom asynchronous operations
- Custom evaluation functions
- Custom inspection functions on objects
- Custom promisified functions
- Custom reporters
- Customization Hooks
- Customizing ESM specifier resolution algorithm
- Customizing REPL output
- Customizing util.inspect colors
- Cycles
- DNS (dns) Details
- DNS promises API
- Dates
- Dates and Timers working together
- Debugger
- Deciding whether to keep the process running
- Decoding buffers in a writable stream
- Decompressor options
- Default Windows shell
- Default evaluation
- Deprecated APIs
- Deprecated APIs
- Deriving bits and keys
- Design and features
- Destruction
- Detecting internationalization support
- Determining if crypto support is unavailable
- Determining if crypto support is unavailable
- Determining if crypto support is unavailable
- Determining if crypto support is unavailable
- Determining module system
- Determining module system
- Diagnostic report
- Differences between ES modules and CommonJS
- Digest
- Disable all internationalization features (none)
- Domains and promises
- Dual CommonJS/ES module packages
- Duplex and transform streams
- ECDSA key pairs
- ECMAScript modules loader entry point caveat
- ERROR_IN_CERT_NOT_AFTER_FIELD
- ERROR_IN_CERT_NOT_BEFORE_FIELD
- ERROR_IN_CRL_LAST_UPDATE_FIELD
- ERROR_IN_CRL_NEXT_UPDATE_FIELD
- Ed25519/X25519 key pairs
- Embed a limited set of ICU data (small-icu)
- Embed the entire ICU (full-icu)
- Emitting custom warnings
- Enabling
- Enabling
- Enabling
- Encodings supported by default (with full ICU data)
- Encodings supported when ICU is disabled
- Encodings supported when Node.js is built with the small-icu option
- Encryption and decryption
- Enum types
- Environment life cycle APIs
- Environment variable options
- Environment variables
- Error codes
- Error codes for RST_STREAM and GOAWAY
- Error constants
- Error events
- Error handling
- Error handling
- Error handling
- Error propagation and interception
- Errors
- Errors while reading
- Errors while writing
- Event listener
- EventSource
- EventTarget and Event API
- EventTarget error handling
- Example ReadableStream
- Example embedding application
- Example: IPv4 outgoing multicast interface
- Example: IPv6 outgoing multicast interface
- Example: Read file stream line-by-Line
- Example: Running an HTTP server within a VM
- Example: Tiny CLI
- Example: sending a server object
- Example: sending a socket object
- Exceptions
- Exceptions vs. errors
- Execution control
- Exit codes
- Explicit binding
- Exporting and importing keys
- Exports sugar
- Extensions in subpaths
- Extraneous asynchronous activity
- FIPS mode
- FORCE_COLOR=[1, 2, 3]
- FS constants
- Factory of wrapped objects
- Fatal errors
- Features
- File System Permissions
- File URL paths
- File access constants
- File copy constants
- File descriptors
- File mode constants
- File modes
- File modules
- File open constants
- File paths
- File system flags
- File type constants
- Filename argument
- Filtering tests by name
- Finalization on the exit of the Node.js environment
- Flush operations
- Flushing
- Folders as modules
- For Zstd-based streams
- Foreground colors
- Formatting Errors
- Full TypeScript support
- Function arguments
- Function factory
- Functions
- Functions to convert from C types to Node-API
- Functions to convert from Node-API to C types
- Functions to create optimized property keys
- Functions to get global instances
- Garbage Collection (gc) Details
- Generating keys
- Generating single executable preparation blobs
- Global and local scope
- Global objects
- Global uncaught exceptions
- HMAC keys
- HOSTNAME_MISMATCH
- HPE_CHUNK_EXTENSIONS_OVERFLOW
- HPE_HEADER_OVERFLOW
- HPE_UNEXPECTED_CONTENT_LENGTH
- HTTP
- HTTP (http) Details
- HTTP/2 (http2) Details
- Handling events only once
- Headers object
- Heap profiler
- Hello world
- Hook callbacks
- Hook callbacks
- Hooks
- How it works
- Http2Session and sockets
- Http2Stream Lifecycle
- INVALID_CA
- INVALID_PURPOSE
- IPC support
- Identifying paths for IPC connections
- Implementation considerations
- Implementing a duplex stream
- Implementing a readable stream
- Implementing a transform stream
- Implementing a writable stream
- Implications of ABI stability
- Implicit binding
- Import attributes
- Import from HTTPS
- Import maps
- Importing types without type keyword
- In the injected main script
- Information
- Inodes
- Inspector only methods
- Integrating AsyncResource with EventEmitter
- Integration with DevTools
- Intentional limitations
- Interaction with workers
- Internationalization support
- Interoperability with CommonJS
- Introduction
- Introduction
- Introduction
- Invalid character handling in header names and values
- JSON modules
- JSON output
- JavaScript embedder API
- JavaScript expressions
- Launching worker threads from preload scripts
- Legacy API
- Legacy Node.js error codes
- Legacy assertion mode
- Legacy streams API (prior to Node.js 0.10)
- Legacy urlObject
- Limitations and Known Issues
- Linking to libraries included with Node.js
- List of deprecated APIs
- Loaders
- Loading addons using require()
- Loading from node_modules folders
- Loading from the global folders
- MODULE_NOT_FOUND
- Main entry point export
- Making handle lifespan shorter than that of the native method
- Mandatory file extensions
- Measuring how long it takes to load dependencies
- Measuring how long one HTTP round-trip takes
- Measuring how long the DNS takes when the request is successful
- Measuring how long the net.connect (only for TCP) takes when the connection is successful
- Measuring the duration of async operations
- Memory management
- Memory usage tuning
- Miscellaneous utilities
- Mocking
- Modifiers
- Modifying the default TLS cipher suite
- Module caching caveats
- Module compile cache
- Module registration
- Modules
- Modules loaders
- Modules: ECMAScript modules
- Modules: Packages
- Multiple reporters
- NET
- NODE_DEBUG=module[,…]
- NODE_DEBUG_NATIVE=module[,…]
- NODE_DISABLE_COLORS=1
- NODE_EXTRA_CA_CERTS=file
- NODE_ICU_DATA=file
- NODE_NO_WARNINGS=1
- NODE_OPTIONS=options...
- NODE_PATH=path[:…]
- NODE_PENDING_DEPRECATION=1
- NODE_PENDING_PIPE_INSTANCES=instances
- NODE_PRESERVE_SYMLINKS=1
- NODE_REDIRECT_WARNINGS=file
- NODE_REPL_EXTERNAL_MODULE=file
- NODE_REPL_HISTORY=file
- NODE_SKIP_PLATFORM_CHECK=value
- NODE_TEST_CONTEXT=value
- NODE_TLS_REJECT_UNAUTHORIZED=value
- NODE_V8_COVERAGE=dir
- NO_COLOR=<any>
- Name Related Errors
- Native abstractions for Node.js
- Navigator
- Nested conditions
- Net (net) Details
- No Addon Loading
- No NODE_PATH
- No __filename or __dirname
- No require, exports, or module.exports
- No require.cache
- No require.extensions
- No require.resolve
- Node-API
- Node-API
- Node-API callback types
- Node-API memory management types
- Node-API version matrix
- Node.js EventTarget vs. DOM EventTarget
- Node.js crypto constants
- Node.js error codes
- Node.js package.json field definitions
- Node.js streams interoperability
- Node.js warning names
- NodeEventTarget vs. EventEmitter
- Non-file forms of input
- Note about UDP datagram size
- Note on :authority and host
- Notes
- Notes
- Notes
- Notes
- OPENSSL_CONF=file
- OS constants
- OUT_OF_MEM
- Object creation functions
- Object factory
- Object lifetime management
- Object mode
- Object mode duplex streams
- Object wrap
- OpenSSL Error Codes
- OpenSSL engine constants
- OpenSSL errors
- OpenSSL options
- OpenSSL security level
- Options
- Options for building Node.js
- Ordering of callback and promise-based operations
- Organization of this document
- Other OpenSSL Errors
- Other OpenSSL constants
- Overview
- Overview
- Overview
- PATH_LENGTH_EXCEEDED
- POSIX error constants
- Package entry points
- Package manager tips
- Packages
- Passing arguments and this to listeners
- Passing wrapped objects around
- Paths aliases
- Per-drive working directories on Windows
- Percent-encoding in URLs
- Perfect forward secrecy
- Performance Considerations
- Permission Model constraints
- Permissions
- Persistent history
- Piping to writable streams from async iterators
- Platform support
- Platform-specific considerations
- Pledged Source Size
- Pre-shared keys
- Printing in AsyncHook callbacks
- Priority constants
- Process
- Process events
- Process-based permissions
- Program entry point
- Promise example
- Promise execution tracking
- Promise hooks
- Promises
- Promises API
- Providing ICU data at runtime
- Public API
- Push streams on the client
- RSA key pairs
- Readable streams
- Recoverable errors
- Reference counting of thread-safe functions
- References to values with a lifespan longer than that of the native method
- Report Version
- Request
- Resolution Algorithm Specification
- Resolution algorithm
- Resolution and loading algorithm
- Resolving user conditions
- Response
- Return values
- Reverse-i-search
- Revoking deprecations
- Running hooks
- Running tests from the command line
- Runtime API
- SELF_SIGNED_CERT_IN_CHAIN
- SQLite constants
- SSL_CERT_DIR=dir
- SSL_CERT_FILE=file
- Scheduling timers
- Script execution
- Security
- Self-referencing a package using its name
- Sensitive headers
- Serialization API
- Server-side example
- Session identifiers
- Session resumption
- Session tickets
- Setting security levels
- Setting up a per-instance state
- Setting up a per-process state
- Settings object
- Shell requirements
- Sign and verify
- Signal constants
- Simple asynchronous operations
- Simplified construction
- Single executable application creation process
- Single-executable application API
- Skipping tests
- Snapshot testing
- Source map v3 support
- Source maps
- Spawning .bat and .cmd files on Windows
- Special schemes
- Specifying alternative services
- Stability index
- Stability overview
- Starting multiple REPL instances against a single running instance
- Startup snapshot support
- Stat time values
- Stepping
- Streams Promises API
- Streams compatibility with async generators and async iterators
- Strict assertion mode
- String paths
- Structures
- Subpath exports
- Subpath imports
- Subpath patterns
- Subtests
- SubtleCrypto
- Support for weak or compromised algorithms
- Support of breakpoints
- Support of dynamic import() in compilation APIs
- Supported getaddrinfo flags
- Supporting the CONNECT method
- Synchronous API
- Synchronous blocking of stdio
- Synchronous example
- Synchronous process creation
- Synchronous version
- Synopsis
- System calls and man pages
- TLS/SSL concepts
- TODO tests
- TTY keybindings
- TZ
- Terminology
- Terminology
- Test reporters
- Test runner execution model
- The --zero-fill-buffers command-line option
- The Module object
- The Module object
- The Node.js REPL
- The WHATWG URL API
- The extended CONNECT protocol
- The module scope
- The module wrapper
- The node:trace_events module
- Threadpool usage
- Threadpool usage and performance considerations
- Three states
- Time Validity Errors
- Timeout interactions with asynchronous tasks and Promises
- Timerify (function) Details
- Timers
- Timers Promises API
- Top-level await
- Tracing object
- TracingChannel Channels
- Transferring with postMessage()
- Transpilation
- Troubleshooting: Context loss
- Trust or Chain Related Errors
- Two reading modes
- Type conversion between JavaScript and SQLite
- Type stripping
- Type stripping in dependencies
- TypeScript features
- Types of streams
- UDP
- UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY
- UNABLE_TO_DECRYPT_CERT_SIGNATURE
- UNABLE_TO_DECRYPT_CRL_SIGNATURE
- UNABLE_TO_GET_CRL
- UNABLE_TO_GET_ISSUER_CERT
- UNABLE_TO_GET_ISSUER_CERT_LOCALLY
- UNABLE_TO_VERIFY_LEAF_SIGNATURE
- URL strings and URL objects
- URLs
- UV_THREADPOOL_SIZE=size
- Uploading precompiled binaries
- Usage
- Usage
- Usage
- Usage and Policy Errors
- Usage and example
- Usage with async/await
- Use of the completer function
- Useful V8 options
- Using --tls-cipher-list
- Using AsyncResource for a Worker thread pool
- Using clear functions
- Using fs.writeFile() with file descriptors
- Using strings as inputs to cryptographic APIs
- Using the Node.js REPL with advanced line-editors
- Using the Permission Model with npx
- Using the hooks
- Utility Consumers
- V8
- V8 code cache support
- V8 inspector integration for Node.js
- Various
- Version 1
- Version 2
- Version 3
- Version 4
- Version 5
- Version history
- Version management
- WHATWG API
- WHATWG supported encodings
- Warning: Dont ignore errors!
- Warning: Using uncaughtException correctly
- Warning: binding inspector to a public IP:port combination is insecure
- Wasm modules
- Watchers
- WebSocket
- WebSocket
- What does it mean to "contextify" an object?
- What makes Buffer.allocUnsafe() and Buffer.allocUnsafeSlow() "unsafe"?
- When importModuleDynamically is a function
- When importModuleDynamically is vm.constants.USE_MAIN_CONTEXT_DEFAULT_LOADER
- When the importModuleDynamically option is not specified or undefined
- When to use queueMicrotask() vs. process.nextTick()
- Windows vs. POSIX
- Windows-specific error constants
- Worker Thread
- Worker support
- Working with JavaScript functions
- Working with JavaScript properties
- Working with JavaScript values
- Working with JavaScript values and abstract operations
- Working with Node.js timers modules
- Wrapping C++ objects
- Wrapping and unwrapping keys
- Writable streams
- X509 certificate error codes
- Zstd constants
- __dirname
- __dirname in the injected main script
- __filename
- __filename and module.filename in the injected main script
- assert
- await keyword
- crypto
- data: imports
- debuglog().enabled
- describe() and it() aliases
- dlopen constants
- dns.resolve(), dns.resolve*(), and dns.reverse()
- emitter[Symbol.for(nodejs.rejection)](err, eventName[, ...args])
- exports
- exports shortcut
- fetch
- file: URLs
- highWaterMark discrepancy after calling readable.setEncoding()
- import Specifiers
- import statements
- import() expressions
- libuv constants
- libuv event loop
- localStorage
- maxBuffer and Unicode
- mimeParams[@@iterator]()
- module
- navigator
- node-gyp
- node-pre-gyp
- node: imports
- node:buffer module APIs
- node:crypto module methods and properties
- node:dgram module functions
- node_api_create_buffer_from_arraybuffer
- node_api_create_external_string_latin1
- node_api_create_external_string_utf16
- node_api_create_property_key_latin1
- node_api_create_property_key_utf16
- node_api_create_property_key_utf8
- node_api_create_syntax_error
- node_api_get_module_file_name
- node_api_symbol_for
- node_api_throw_syntax_error
- only tests
- package.json and file extensions
- parseArgs tokens
- performance
- prebuild
- prebuildify
- require
- require(id) in the injected main script is not file based
- resource
- session.close().
- sessionStorage
- snapshot
- triggerAsyncId
- type
- zlib constants
Modules
Options
- -
- --
- --abort-on-uncaught-exception
- --allow-addons
- --allow-child-process
- --allow-fs-read
- --allow-fs-write
- --allow-wasi
- --allow-worker
- --build-snapshot
- --build-snapshot-config
- --completion-bash
- --cpu-prof
- --cpu-prof-dir
- --cpu-prof-interval
- --cpu-prof-name
- --diagnostic-dir=directory
- --disable-proto=mode
- --disable-sigusr1
- --disable-warning=code-or-type
- --disable-wasm-trap-handler
- --disallow-code-generation-from-strings
- --dns-result-order=order
- --enable-etw-stack-walking
- --enable-fips
- --enable-network-family-autoselection
- --enable-source-maps
- --entry-url
- --env-file-if-exists=config
- --env-file=config
- --experimental-addon-modules
- --experimental-async-context-frame
- --experimental-config-file=config
- --experimental-default-config-file
- --experimental-eventsource
- --experimental-import-meta-resolve
- --experimental-loader=module
- --experimental-network-inspection
- --experimental-print-required-tla
- --experimental-require-module
- --experimental-sea-config
- --experimental-shadow-realm
- --experimental-test-coverage
- --experimental-test-module-mocks
- --experimental-transform-types
- --experimental-vm-modules
- --experimental-wasi-unstable-preview1
- --experimental-wasm-modules
- --experimental-webstorage
- --expose-gc
- --force-context-aware
- --force-fips
- --force-node-api-uncaught-exceptions-policy
- --frozen-intrinsics
- --harmony-shadow-realm
- --heap-prof
- --heap-prof-dir
- --heap-prof-interval
- --heap-prof-name
- --heapsnapshot-near-heap-limit=max_count
- --heapsnapshot-signal=signal
- --icu-data-dir=file
- --import=module
- --input-type=type
- --insecure-http-parser
- --inspect-brk[=[host:]port]
- --inspect-port=[host:]port
- --inspect-publish-uid=stderr,http
- --inspect-wait[=[host:]port]
- --inspect[=[host:]port]
- --interpreted-frames-native-stack
- --jitless
- --localstorage-file=file
- --max-http-header-size=size
- --max-old-space-size=SIZE (in MiB)
- --max-semi-space-size=SIZE (in MiB)
- --napi-modules
- --network-family-autoselection-attempt-timeout
- --no-addons
- --no-deprecation
- --no-experimental-detect-module
- --no-experimental-global-navigator
- --no-experimental-repl-await
- --no-experimental-require-module
- --no-experimental-sqlite
- --no-experimental-strip-types
- --no-experimental-websocket
- --no-extra-info-on-fatal-exception
- --no-force-async-hooks-checks
- --no-global-search-paths
- --no-network-family-autoselection
- --no-warnings
- --node-memory-debug
- --openssl-config=file
- --openssl-legacy-provider
- --openssl-shared-config
- --pending-deprecation
- --perf-basic-prof
- --perf-basic-prof-only-functions
- --perf-prof
- --perf-prof-unwinding-info
- --permission
- --preserve-symlinks
- --preserve-symlinks-main
- --prof
- --prof-process
- --redirect-warnings=file
- --report-compact
- --report-dir=directory, report-directory=directory
- --report-exclude-env
- --report-exclude-network
- --report-filename=filename
- --report-on-fatalerror
- --report-on-signal
- --report-signal=signal
- --report-uncaught-exception
- --run
- --secure-heap-min=n
- --secure-heap=n
- --security-revert
- --snapshot-blob=path
- --stack-trace-limit=limit
- --test
- --test-concurrency
- --test-coverage-branches=threshold
- --test-coverage-exclude
- --test-coverage-functions=threshold
- --test-coverage-include
- --test-coverage-lines=threshold
- --test-force-exit
- --test-isolation=mode
- --test-name-pattern
- --test-only
- --test-reporter
- --test-reporter-destination
- --test-shard
- --test-skip-pattern
- --test-timeout
- --test-update-snapshots
- --throw-deprecation
- --title=title
- --tls-cipher-list=list
- --tls-keylog=file
- --tls-max-v1.2
- --tls-max-v1.3
- --tls-min-v1.0
- --tls-min-v1.1
- --tls-min-v1.2
- --tls-min-v1.3
- --trace-deprecation
- --trace-env
- --trace-env-js-stack
- --trace-env-native-stack
- --trace-event-categories
- --trace-event-file-pattern
- --trace-events-enabled
- --trace-exit
- --trace-require-module=mode
- --trace-sigint
- --trace-sync-io
- --trace-tls
- --trace-uncaught
- --trace-warnings
- --track-heap-objects
- --unhandled-rejections=mode
- --use-bundled-ca, --use-openssl-ca
- --use-largepages=mode
- --use-system-ca
- --v8-options
- --v8-pool-size=num
- --watch
- --watch-path
- --watch-preserve-output
- --zero-fill-buffers
- -C condition, --conditions=condition
- -c, --check
- -e, --eval "script"
- -h, --help
- -i, --interactive
- -p, --print "script"
- -r, --require module
- -v, --version
Variables
cls
clms
- AbortSignal.abort([reason])
- AbortSignal.any(signals)
- AbortSignal.timeout(delay)
- AsyncLocalStorage.bind(fn)
- AsyncLocalStorage.snapshot()
- AsyncResource.bind(fn[, type[, thisArg]])
- BlockList.isBlockList(value)
- Buffer.alloc(size[, fill[, encoding]])
- Buffer.allocUnsafe(size)
- Buffer.allocUnsafeSlow(size)
- Buffer.byteLength(string[, encoding])
- Buffer.compare(buf1, buf2)
- Buffer.concat(list[, totalLength])
- Buffer.copyBytesFrom(view[, offset[, length]])
- Buffer.from(array)
- Buffer.from(arrayBuffer[, byteOffset[, length]])
- Buffer.from(buffer)
- Buffer.from(object[, offsetOrEncoding[, length]])
- Buffer.from(string[, encoding])
- Buffer.isBuffer(obj)
- Buffer.isEncoding(encoding)
- Certificate.exportChallenge(spkac[, encoding])
- Certificate.exportPublicKey(spkac[, encoding])
- Certificate.verifySpkac(spkac[, encoding])
- ECDH.convertKey(key, curve[, inputEncoding[, outputEncoding[, format]]])
- Error.captureStackTrace(targetObject[, constructorOpt])
- KeyObject.from(key)
- ReadableStream.from(iterable)
- Resolver([options])
- SocketAddress.parse(input)
- URL.canParse(input[, base])
- URL.createObjectURL(blob)
- URL.parse(input[, base])
- URL.revokeObjectURL(id)
- abortController.abort([reason])
- abortSignal.throwIfAborted()
- after([fn][, options])
- after(asyncId)
- after(promise)
- afterEach([fn][, options])
- agent.createConnection(options[, callback])
- agent.destroy()
- agent.getName([options])
- agent.keepSocketAlive(socket)
- agent.reuseSocket(socket, request)
- assert(value[, message])
- assert.deepEqual(actual, expected[, message])
- assert.deepStrictEqual(actual, expected[, message])
- assert.doesNotMatch(string, regexp[, message])
- assert.doesNotReject(asyncFn[, error][, message])
- assert.doesNotThrow(fn[, error][, message])
- assert.equal(actual, expected[, message])
- assert.fail([message])
- assert.fail(actual, expected[, message[, operator[, stackStartFn]]])
- assert.ifError(value)
- assert.match(string, regexp[, message])
- assert.notDeepEqual(actual, expected[, message])
- assert.notDeepStrictEqual(actual, expected[, message])
- assert.notEqual(actual, expected[, message])
- assert.notStrictEqual(actual, expected[, message])
- assert.ok(value[, message])
- assert.partialDeepStrictEqual(actual, expected[, message])
- assert.register(name, fn)
- assert.rejects(asyncFn[, error][, message])
- assert.strictEqual(actual, expected[, message])
- assert.throws(fn[, error][, message])
- asyncEnd(event)
- asyncHook.disable()
- asyncHook.enable()
- asyncLocalStorage.disable()
- asyncLocalStorage.enterWith(store)
- asyncLocalStorage.exit(callback[, ...args])
- asyncLocalStorage.getStore()
- asyncLocalStorage.run(store, callback[, ...args])
- asyncResource.asyncId()
- asyncResource.bind(fn[, thisArg])
- asyncResource.emitDestroy()
- asyncResource.runInAsyncScope(fn[, thisArg, ...args])
- asyncResource.triggerAsyncId()
- asyncStart(event)
- async_hooks.createHook(callbacks)
- async_hooks.executionAsyncId()
- async_hooks.executionAsyncResource()
- async_hooks.triggerAsyncId()
- atob(data)
- before([fn][, options])
- before(asyncId)
- before(promise)
- beforeEach([fn][, options])
- blob.arrayBuffer()
- blob.bytes()
- blob.slice([start[, end[, type]]])
- blob.stream()
- blob.text()
- blockList.addAddress(address[, type])
- blockList.addRange(start, end[, type])
- blockList.addSubnet(net, prefix[, type])
- blockList.check(address[, type])
- broadcastChannel.close()
- broadcastChannel.postMessage(message)
- broadcastChannel.ref()
- broadcastChannel.unref()
- btoa(data)
- buf.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])
- buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]])
- buf.entries()
- buf.equals(otherBuffer)
- buf.fill(value[, offset[, end]][, encoding])
- buf.includes(value[, byteOffset][, encoding])
- buf.indexOf(value[, byteOffset][, encoding])
- buf.keys()
- buf.lastIndexOf(value[, byteOffset][, encoding])
- buf.readBigInt64BE([offset])
- buf.readBigInt64LE([offset])
- buf.readBigUInt64BE([offset])
- buf.readBigUInt64LE([offset])
- buf.readDoubleBE([offset])
- buf.readDoubleLE([offset])
- buf.readFloatBE([offset])
- buf.readFloatLE([offset])
- buf.readInt16BE([offset])
- buf.readInt16LE([offset])
- buf.readInt32BE([offset])
- buf.readInt32LE([offset])
- buf.readInt8([offset])
- buf.readIntBE(offset, byteLength)
- buf.readIntLE(offset, byteLength)
- buf.readUInt16BE([offset])
- buf.readUInt16LE([offset])
- buf.readUInt32BE([offset])
- buf.readUInt32LE([offset])
- buf.readUInt8([offset])
- buf.readUIntBE(offset, byteLength)
- buf.readUIntLE(offset, byteLength)
- buf.slice([start[, end]])
- buf.subarray([start[, end]])
- buf.swap16()
- buf.swap32()
- buf.swap64()
- buf.toJSON()
- buf.toString([encoding[, start[, end]]])
- buf.values()
- buf.write(string[, offset[, length]][, encoding])
- buf.writeBigInt64BE(value[, offset])
- buf.writeBigInt64LE(value[, offset])
- buf.writeBigUInt64BE(value[, offset])
- buf.writeBigUInt64LE(value[, offset])
- buf.writeDoubleBE(value[, offset])
- buf.writeDoubleLE(value[, offset])
- buf.writeFloatBE(value[, offset])
- buf.writeFloatLE(value[, offset])
- buf.writeInt16BE(value[, offset])
- buf.writeInt16LE(value[, offset])
- buf.writeInt32BE(value[, offset])
- buf.writeInt32LE(value[, offset])
- buf.writeInt8(value[, offset])
- buf.writeIntBE(value, offset, byteLength)
- buf.writeIntLE(value, offset, byteLength)
- buf.writeUInt16BE(value[, offset])
- buf.writeUInt16LE(value[, offset])
- buf.writeUInt32BE(value[, offset])
- buf.writeUInt32LE(value[, offset])
- buf.writeUInt8(value[, offset])
- buf.writeUIntBE(value, offset, byteLength)
- buf.writeUIntLE(value, offset, byteLength)
- buffer.atob(data)
- buffer.btoa(data)
- buffer.isAscii(input)
- buffer.isUtf8(input)
- buffer.resolveObjectURL(id)
- buffer.transcode(source, fromEnc, toEnc)
- certificate.exportChallenge(spkac[, encoding])
- certificate.exportPublicKey(spkac[, encoding])
- certificate.verifySpkac(spkac[, encoding])
- channel.bindStore(store[, transform])
- channel.publish(message)
- channel.runStores(context, fn[, thisArg[, ...args]])
- channel.subscribe(onMessage)
- channel.unbindStore(store)
- channel.unsubscribe(onMessage)
- child_process.exec(command[, options][, callback])
- child_process.execFile(file[, args][, options][, callback])
- child_process.execFileSync(file[, args][, options])
- child_process.execSync(command[, options])
- child_process.fork(modulePath[, args][, options])
- child_process.spawn(command[, args][, options])
- child_process.spawnSync(command[, args][, options])
- cipher.final([outputEncoding])
- cipher.getAuthTag()
- cipher.setAAD(buffer[, options])
- cipher.setAutoPadding([autoPadding])
- cipher.update(data[, inputEncoding][, outputEncoding])
- clearImmediate(immediate)
- clearImmediate(immediateObject)
- clearInterval(intervalObject)
- clearInterval(timeout)
- clearTimeout(timeout)
- clearTimeout(timeoutObject)
- clienthttp2session.request(headers[, options])
- cluster.disconnect([callback])
- cluster.fork([env])
- cluster.setupMaster([settings])
- cluster.setupPrimary([settings])
- console.assert(value[, ...message])
- console.clear()
- console.count([label])
- console.countReset([label])
- console.debug(data[, ...args])
- console.dir(obj[, options])
- console.dirxml(...data)
- console.error([data][, ...args])
- console.group([...label])
- console.groupCollapsed()
- console.groupEnd()
- console.info([data][, ...args])
- console.log([data][, ...args])
- console.profile([label])
- console.profileEnd([label])
- console.table(tabularData[, properties])
- console.time([label])
- console.timeEnd([label])
- console.timeLog([label][, ...data])
- console.timeStamp([label])
- console.trace([message][, ...args])
- console.warn([data][, ...args])
- context.after([fn][, options])
- context.afterEach([fn][, options])
- context.assert.fileSnapshot(value, path[, options])
- context.assert.snapshot(value[, options])
- context.before([fn][, options])
- context.beforeEach([fn][, options])
- context.diagnostic(message)
- context.plan(count[,options])
- context.runOnly(shouldRunOnlyTests)
- context.skip([message])
- context.test([name][, options][, fn])
- context.todo([message])
- context.waitFor(condition[, options])
- crypto.checkPrime(candidate[, options], callback)
- crypto.checkPrimeSync(candidate[, options])
- crypto.createCipheriv(algorithm, key, iv[, options])
- crypto.createDecipheriv(algorithm, key, iv[, options])
- crypto.createDiffieHellman(primeLength[, generator])
- crypto.createDiffieHellman(prime[, primeEncoding][, generator][, generatorEncoding])
- crypto.createDiffieHellmanGroup(name)
- crypto.createECDH(curveName)
- crypto.createHash(algorithm[, options])
- crypto.createHmac(algorithm, key[, options])
- crypto.createPrivateKey(key)
- crypto.createPublicKey(key)
- crypto.createSecretKey(key[, encoding])
- crypto.createSign(algorithm[, options])
- crypto.createVerify(algorithm[, options])
- crypto.diffieHellman(options[, callback])
- crypto.generateKey(type, options, callback)
- crypto.generateKeyPair(type, options, callback)
- crypto.generateKeyPairSync(type, options)
- crypto.generateKeySync(type, options)
- crypto.generatePrime(size[, options[, callback]])
- crypto.generatePrimeSync(size[, options])
- crypto.getCipherInfo(nameOrNid[, options])
- crypto.getCiphers()
- crypto.getCurves()
- crypto.getDiffieHellman(groupName)
- crypto.getFips()
- crypto.getHashes()
- crypto.getRandomValues(typedArray)
- crypto.getRandomValues(typedArray)
- crypto.hash(algorithm, data[, outputEncoding])
- crypto.hkdf(digest, ikm, salt, info, keylen, callback)
- crypto.hkdfSync(digest, ikm, salt, info, keylen)
- crypto.pbkdf2(password, salt, iterations, keylen, digest, callback)
- crypto.pbkdf2Sync(password, salt, iterations, keylen, digest)
- crypto.privateDecrypt(privateKey, buffer)
- crypto.privateEncrypt(privateKey, buffer)
- crypto.publicDecrypt(key, buffer)
- crypto.publicEncrypt(key, buffer)
- crypto.randomBytes(size[, callback])
- crypto.randomFill(buffer[, offset][, size], callback)
- crypto.randomFillSync(buffer[, offset][, size])
- crypto.randomInt([min, ]max[, callback])
- crypto.randomUUID()
- crypto.randomUUID([options])
- crypto.scrypt(password, salt, keylen[, options], callback)
- crypto.scryptSync(password, salt, keylen[, options])
- crypto.secureHeapUsed()
- crypto.setEngine(engine[, flags])
- crypto.setFips(bool)
- crypto.sign(algorithm, data, key[, callback])
- crypto.timingSafeEqual(a, b)
- crypto.verify(algorithm, data, key, signature[, callback])
- ctx.callCount()
- ctx.mockImplementation(implementation)
- ctx.mockImplementationOnce(implementation[, onCall])
- ctx.resetCalls()
- ctx.restore()
- database.applyChangeset(changeset[, options])
- database.close()
- database.createSession([options])
- database.enableLoadExtension(allow)
- database.exec(sql)
- database.function(name[, options], function)
- database.loadExtension(path)
- database.open()
- database.prepare(sql)
- database[Symbol.dispose]()
- decipher.final([outputEncoding])
- decipher.setAAD(buffer[, options])
- decipher.setAuthTag(buffer[, encoding])
- decipher.setAutoPadding([autoPadding])
- decipher.update(data[, inputEncoding][, outputEncoding])
- describe([name][, options][, fn])
- describe.only([name][, options][, fn])
- describe.skip([name][, options][, fn])
- describe.todo([name][, options][, fn])
- deserializer._readHostObject()
- deserializer.getWireFormatVersion()
- deserializer.readDouble()
- deserializer.readHeader()
- deserializer.readRawBytes(length)
- deserializer.readUint32()
- deserializer.readUint64()
- deserializer.readValue()
- deserializer.transferArrayBuffer(id, arrayBuffer)
- destroy(asyncId)
- dgram.createSocket(options[, callback])
- dgram.createSocket(type[, callback])
- diagnostics_channel.channel(name)
- diagnostics_channel.hasSubscribers(name)
- diagnostics_channel.subscribe(name, onMessage)
- diagnostics_channel.tracingChannel(nameOrChannels)
- diagnostics_channel.unsubscribe(name, onMessage)
- diffieHellman.computeSecret(otherPublicKey[, inputEncoding][, outputEncoding])
- diffieHellman.generateKeys([encoding])
- diffieHellman.getGenerator([encoding])
- diffieHellman.getPrime([encoding])
- diffieHellman.getPrivateKey([encoding])
- diffieHellman.getPublicKey([encoding])
- diffieHellman.setPrivateKey(privateKey[, encoding])
- diffieHellman.setPublicKey(publicKey[, encoding])
- dir.close()
- dir.close(callback)
- dir.closeSync()
- dir.read()
- dir.read(callback)
- dir.readSync()
- dir[Symbol.asyncIterator]()
- dirent.isBlockDevice()
- dirent.isCharacterDevice()
- dirent.isDirectory()
- dirent.isFIFO()
- dirent.isFile()
- dirent.isSocket()
- dirent.isSymbolicLink()
- dns.getDefaultResultOrder()
- dns.getServers()
- dns.lookup()
- dns.lookup(hostname[, options], callback)
- dns.lookupService(address, port, callback)
- dns.resolve(hostname[, rrtype], callback)
- dns.resolve4(hostname[, options], callback)
- dns.resolve6(hostname[, options], callback)
- dns.resolveAny(hostname, callback)
- dns.resolveCaa(hostname, callback)
- dns.resolveCname(hostname, callback)
- dns.resolveMx(hostname, callback)
- dns.resolveNaptr(hostname, callback)
- dns.resolveNs(hostname, callback)
- dns.resolvePtr(hostname, callback)
- dns.resolveSoa(hostname, callback)
- dns.resolveSrv(hostname, callback)
- dns.resolveTlsa(hostname, callback)
- dns.resolveTxt(hostname, callback)
- dns.reverse(ip, callback)
- dns.setDefaultResultOrder(order)
- dns.setServers(servers)
- dnsPromises.getDefaultResultOrder()
- dnsPromises.getServers()
- dnsPromises.lookup(hostname[, options])
- dnsPromises.lookupService(address, port)
- dnsPromises.resolve(hostname[, rrtype])
- dnsPromises.resolve4(hostname[, options])
- dnsPromises.resolve6(hostname[, options])
- dnsPromises.resolveAny(hostname)
- dnsPromises.resolveCaa(hostname)
- dnsPromises.resolveCname(hostname)
- dnsPromises.resolveMx(hostname)
- dnsPromises.resolveNaptr(hostname)
- dnsPromises.resolveNs(hostname)
- dnsPromises.resolvePtr(hostname)
- dnsPromises.resolveSoa(hostname)
- dnsPromises.resolveSrv(hostname)
- dnsPromises.resolveTlsa(hostname)
- dnsPromises.resolveTxt(hostname)
- dnsPromises.reverse(ip)
- dnsPromises.setDefaultResultOrder(order)
- dnsPromises.setServers(servers)
- domain.add(emitter)
- domain.bind(callback)
- domain.create()
- domain.enter()
- domain.exit()
- domain.intercept(callback)
- domain.remove(emitter)
- domain.run(fn[, ...args])
- ecdh.computeSecret(otherPublicKey[, inputEncoding][, outputEncoding])
- ecdh.generateKeys([encoding[, format]])
- ecdh.getPrivateKey([encoding])
- ecdh.getPublicKey([encoding][, format])
- ecdh.setPrivateKey(privateKey[, encoding])
- ecdh.setPublicKey(publicKey[, encoding])
- emitter.addListener(eventName, listener)
- emitter.emit(eventName[, ...args])
- emitter.eventNames()
- emitter.getMaxListeners()
- emitter.listenerCount(eventName[, listener])
- emitter.listeners(eventName)
- emitter.off(eventName, listener)
- emitter.on(eventName, listener)
- emitter.once(eventName, listener)
- emitter.prependListener(eventName, listener)
- emitter.prependOnceListener(eventName, listener)
- emitter.rawListeners(eventName)
- emitter.removeAllListeners([eventName])
- emitter.removeListener(eventName, listener)
- emitter.setMaxListeners(n)
- end(event)
- error(event)
- event.composedPath()
- event.initEvent(type[, bubbles[, cancelable]])
- event.preventDefault()
- event.stopImmediatePropagation()
- event.stopPropagation()
- eventTarget.addEventListener(type, listener[, options])
- eventTarget.dispatchEvent(event)
- eventTarget.removeEventListener(type, listener[, options])
- eventemitterasyncresource.emitDestroy()
- events.addAbortListener(signal, listener)
- events.getEventListeners(emitterOrTarget, eventName)
- events.getMaxListeners(emitterOrTarget)
- events.listenerCount(emitter, eventName)
- events.on(emitter, eventName[, options])
- events.once(emitter, name[, options])
- events.setMaxListeners(n[, ...eventTargets])
- filehandle.appendFile(data[, options])
- filehandle.chmod(mode)
- filehandle.chown(uid, gid)
- filehandle.close()
- filehandle.createReadStream([options])
- filehandle.createWriteStream([options])
- filehandle.datasync()
- filehandle.read([options])
- filehandle.read(buffer, offset, length, position)
- filehandle.read(buffer[, options])
- filehandle.readFile(options)
- filehandle.readLines([options])
- filehandle.readableWebStream()
- filehandle.readv(buffers[, position])
- filehandle.stat([options])
- filehandle.sync()
- filehandle.truncate(len)
- filehandle.utimes(atime, mtime)
- filehandle.write(buffer, offset[, length[, position]])
- filehandle.write(buffer[, options])
- filehandle.write(string[, position[, encoding]])
- filehandle.writeFile(data, options)
- filehandle.writev(buffers[, position])
- filehandle[Symbol.asyncDispose]()
- fs.access(path[, mode], callback)
- fs.accessSync(path[, mode])
- fs.appendFile(path, data[, options], callback)
- fs.appendFileSync(path, data[, options])
- fs.chmod(path, mode, callback)
- fs.chmodSync(path, mode)
- fs.chown(path, uid, gid, callback)
- fs.chownSync(path, uid, gid)
- fs.close(fd[, callback])
- fs.closeSync(fd)
- fs.copyFile(src, dest[, mode], callback)
- fs.copyFileSync(src, dest[, mode])
- fs.cp(src, dest[, options], callback)
- fs.cpSync(src, dest[, options])
- fs.createReadStream(path[, options])
- fs.createWriteStream(path[, options])
- fs.exists(path, callback)
- fs.existsSync(path)
- fs.fchmod(fd, mode, callback)
- fs.fchmodSync(fd, mode)
- fs.fchown(fd, uid, gid, callback)
- fs.fchownSync(fd, uid, gid)
- fs.fdatasync(fd, callback)
- fs.fdatasyncSync(fd)
- fs.fstat(fd[, options], callback)
- fs.fstatSync(fd[, options])
- fs.fsync(fd, callback)
- fs.fsyncSync(fd)
- fs.ftruncate(fd[, len], callback)
- fs.ftruncateSync(fd[, len])
- fs.futimes(fd, atime, mtime, callback)
- fs.futimesSync(fd, atime, mtime)
- fs.glob(pattern[, options], callback)
- fs.globSync(pattern[, options])
- fs.lchmod(path, mode, callback)
- fs.lchmodSync(path, mode)
- fs.lchown(path, uid, gid, callback)
- fs.lchownSync(path, uid, gid)
- fs.link(existingPath, newPath, callback)
- fs.linkSync(existingPath, newPath)
- fs.lstat(path[, options], callback)
- fs.lstatSync(path[, options])
- fs.lutimes(path, atime, mtime, callback)
- fs.lutimesSync(path, atime, mtime)
- fs.mkdir(path[, options], callback)
- fs.mkdirSync(path[, options])
- fs.mkdtemp(prefix[, options], callback)
- fs.mkdtempSync(prefix[, options])
- fs.open(path[, flags[, mode]], callback)
- fs.openAsBlob(path[, options])
- fs.openSync(path[, flags[, mode]])
- fs.opendir(path[, options], callback)
- fs.opendirSync(path[, options])
- fs.read(fd, buffer, offset, length, position, callback)
- fs.read(fd, buffer[, options], callback)
- fs.read(fd[, options], callback)
- fs.readFile(path[, options], callback)
- fs.readFileSync(path[, options])
- fs.readSync(fd, buffer, offset, length[, position])
- fs.readSync(fd, buffer[, options])
- fs.readdir(path[, options], callback)
- fs.readdirSync(path[, options])
- fs.readlink(path[, options], callback)
- fs.readlinkSync(path[, options])
- fs.readv(fd, buffers[, position], callback)
- fs.readvSync(fd, buffers[, position])
- fs.realpath(path[, options], callback)
- fs.realpath.native(path[, options], callback)
- fs.realpathSync(path[, options])
- fs.realpathSync.native(path[, options])
- fs.rename(oldPath, newPath, callback)
- fs.renameSync(oldPath, newPath)
- fs.rm(path[, options], callback)
- fs.rmSync(path[, options])
- fs.rmdir(path[, options], callback)
- fs.rmdirSync(path[, options])
- fs.stat(path[, options], callback)
- fs.statSync(path[, options])
- fs.statfs(path[, options], callback)
- fs.statfsSync(path[, options])
- fs.symlink(target, path[, type], callback)
- fs.symlinkSync(target, path[, type])
- fs.truncate(path[, len], callback)
- fs.truncateSync(path[, len])
- fs.unlink(path, callback)
- fs.unlinkSync(path)
- fs.unwatchFile(filename[, listener])
- fs.utimes(path, atime, mtime, callback)
- fs.utimesSync(path, atime, mtime)
- fs.watch(filename[, options][, listener])
- fs.watchFile(filename[, options], listener)
- fs.write(fd, buffer, offset[, length[, position]], callback)
- fs.write(fd, buffer[, options], callback)
- fs.write(fd, string[, position[, encoding]], callback)
- fs.writeFile(file, data[, options], callback)
- fs.writeFileSync(file, data[, options])
- fs.writeSync(fd, buffer, offset[, length[, position]])
- fs.writeSync(fd, buffer[, options])
- fs.writeSync(fd, string[, position[, encoding]])
- fs.writev(fd, buffers[, position], callback)
- fs.writevSync(fd, buffers[, position])
- fsPromises.access(path[, mode])
- fsPromises.appendFile(path, data[, options])
- fsPromises.chmod(path, mode)
- fsPromises.chown(path, uid, gid)
- fsPromises.copyFile(src, dest[, mode])
- fsPromises.cp(src, dest[, options])
- fsPromises.glob(pattern[, options])
- fsPromises.lchmod(path, mode)
- fsPromises.lchown(path, uid, gid)
- fsPromises.link(existingPath, newPath)
- fsPromises.lstat(path[, options])
- fsPromises.lutimes(path, atime, mtime)
- fsPromises.mkdir(path[, options])
- fsPromises.mkdtemp(prefix[, options])
- fsPromises.open(path, flags[, mode])
- fsPromises.opendir(path[, options])
- fsPromises.readFile(path[, options])
- fsPromises.readdir(path[, options])
- fsPromises.readlink(path[, options])
- fsPromises.realpath(path[, options])
- fsPromises.rename(oldPath, newPath)
- fsPromises.rm(path[, options])
- fsPromises.rmdir(path[, options])
- fsPromises.stat(path[, options])
- fsPromises.statfs(path[, options])
- fsPromises.symlink(target, path[, type])
- fsPromises.truncate(path[, len])
- fsPromises.unlink(path)
- fsPromises.utimes(path, atime, mtime)
- fsPromises.watch(filename[, options])
- fsPromises.writeFile(file, data[, options])
- hash.copy([options])
- hash.digest([encoding])
- hash.update(data[, inputEncoding])
- histogram.add(other)
- histogram.disable()
- histogram.enable()
- histogram.percentile(percentile)
- histogram.percentileBigInt(percentile)
- histogram.record(val)
- histogram.recordDelta()
- histogram.reset()
- hmac.digest([encoding])
- hmac.update(data[, inputEncoding])
- http.createServer([options][, requestListener])
- http.get(options[, callback])
- http.get(url[, options][, callback])
- http.request(options[, callback])
- http.request(url[, options][, callback])
- http.setMaxIdleHTTPParsers(max)
- http.validateHeaderName(name[, label])
- http.validateHeaderValue(name, value)
- http2.connect(authority[, options][, listener])
- http2.createSecureServer(options[, onRequestHandler])
- http2.createServer([options][, onRequestHandler])
- http2.getDefaultSettings()
- http2.getPackedSettings([settings])
- http2.getUnpackedSettings(buf)
- http2.performServerHandshake(socket[, options])
- http2session.close([callback])
- http2session.destroy([error][, code])
- http2session.goaway([code[, lastStreamID[, opaqueData]]])
- http2session.ping([payload, ]callback)
- http2session.ref()
- http2session.setLocalWindowSize(windowSize)
- http2session.setTimeout(msecs, callback)
- http2session.settings([settings][, callback])
- http2session.unref()
- http2stream.additionalHeaders(headers)
- http2stream.close(code[, callback])
- http2stream.priority(options)
- http2stream.pushStream(headers[, options], callback)
- http2stream.respond([headers[, options]])
- http2stream.respondWithFD(fd[, headers[, options]])
- http2stream.respondWithFile(path[, headers[, options]])
- http2stream.sendTrailers(headers)
- http2stream.setTimeout(msecs, callback)
- https.createServer([options][, requestListener])
- https.get(options[, callback])
- https.get(url[, options][, callback])
- https.request(options[, callback])
- https.request(url[, options][, callback])
- immediate.hasRef()
- immediate.ref()
- immediate.unref()
- immediate[Symbol.dispose]()
- import.meta.resolve(specifier)
- init(asyncId, type, triggerAsyncId, resource)
- init(promise, parent)
- initialize()
- inspector.Network.loadingFailed([params])
- inspector.Network.loadingFinished([params])
- inspector.Network.requestWillBeSent([params])
- inspector.Network.responseReceived([params])
- inspector.close()
- inspector.open([port[, host[, wait]]])
- inspector.url()
- inspector.waitForDebugger()
- it([name][, options][, fn])
- it.only([name][, options][, fn])
- it.skip([name][, options][, fn])
- it.todo([name][, options][, fn])
- keyObject.equals(otherKeyObject)
- keyObject.export([options])
- keyObject.toCryptoKey(algorithm, extractable, keyUsages)
- load(url, context, nextLoad)
- message.destroy([error])
- message.setTimeout(msecs[, callback])
- mime.toJSON()
- mime.toString()
- mimeParams.delete(name)
- mimeParams.entries()
- mimeParams.get(name)
- mimeParams.has(name)
- mimeParams.keys()
- mimeParams.set(name, value)
- mimeParams.values()
- mock.fn([original[, implementation]][, options])
- mock.getter(object, methodName[, implementation][, options])
- mock.method(object, methodName[, implementation][, options])
- mock.module(specifier[, options])
- mock.reset()
- mock.restoreAll()
- mock.setter(object, methodName[, implementation][, options])
- module.createRequire(filename)
- module.enableCompileCache([cacheDir])
- module.evaluate([options])
- module.findPackageJSON(specifier[, base])
- module.findSourceMap(path)
- module.flushCompileCache()
- module.getCompileCacheDir()
- module.getSourceMapsSupport()
- module.isBuiltin(moduleName)
- module.link(linker)
- module.register(specifier[, parentURL][, options])
- module.registerHooks(options)
- module.require(id)
- module.setSourceMapsSupport(enabled[, options])
- module.stripTypeScriptTypes(code[, options])
- module.syncBuiltinESMExports()
- napi_acquire_threadsafe_function
- napi_add_async_cleanup_hook
- napi_add_env_cleanup_hook
- napi_add_finalizer
- napi_adjust_external_memory
- napi_async_cleanup_hook
- napi_async_cleanup_hook_handle
- napi_async_complete_callback
- napi_async_destroy
- napi_async_execute_callback
- napi_async_init
- napi_call_function
- napi_call_threadsafe_function
- napi_callback
- napi_callback_info
- napi_cancel_async_work
- napi_check_object_type_tag
- napi_cleanup_hook
- napi_close_callback_scope
- napi_close_escapable_handle_scope
- napi_close_handle_scope
- napi_coerce_to_bool
- napi_coerce_to_number
- napi_coerce_to_object
- napi_coerce_to_string
- napi_create_array
- napi_create_array_with_length
- napi_create_arraybuffer
- napi_create_async_work
- napi_create_bigint_int64
- napi_create_bigint_uint64
- napi_create_bigint_words
- napi_create_buffer
- napi_create_buffer_copy
- napi_create_dataview
- napi_create_date
- napi_create_double
- napi_create_error
- napi_create_external
- napi_create_external_arraybuffer
- napi_create_external_buffer
- napi_create_function
- napi_create_int32
- napi_create_int64
- napi_create_object
- napi_create_promise
- napi_create_range_error
- napi_create_reference
- napi_create_string_latin1
- napi_create_string_utf16
- napi_create_string_utf8
- napi_create_symbol
- napi_create_threadsafe_function
- napi_create_type_error
- napi_create_typedarray
- napi_create_uint32
- napi_define_class
- napi_define_properties
- napi_delete_async_work
- napi_delete_element
- napi_delete_property
- napi_delete_reference
- napi_detach_arraybuffer
- napi_env
- napi_escapable_handle_scope
- napi_escape_handle
- napi_extended_error_info
- napi_fatal_error
- napi_fatal_exception
- napi_finalize
- napi_get_all_property_names
- napi_get_and_clear_last_exception
- napi_get_array_length
- napi_get_arraybuffer_info
- napi_get_boolean
- napi_get_buffer_info
- napi_get_cb_info
- napi_get_dataview_info
- napi_get_date_value
- napi_get_element
- napi_get_global
- napi_get_instance_data
- napi_get_last_error_info
- napi_get_named_property
- napi_get_new_target
- napi_get_node_version
- napi_get_null
- napi_get_property
- napi_get_property_names
- napi_get_prototype
- napi_get_reference_value
- napi_get_threadsafe_function_context
- napi_get_typedarray_info
- napi_get_undefined
- napi_get_uv_event_loop
- napi_get_value_bigint_int64
- napi_get_value_bigint_uint64
- napi_get_value_bigint_words
- napi_get_value_bool
- napi_get_value_double
- napi_get_value_external
- napi_get_value_int32
- napi_get_value_int64
- napi_get_value_string_latin1
- napi_get_value_string_utf16
- napi_get_value_string_utf8
- napi_get_value_uint32
- napi_get_version
- napi_handle_scope
- napi_has_element
- napi_has_named_property
- napi_has_own_property
- napi_has_property
- napi_instanceof
- napi_is_array
- napi_is_arraybuffer
- napi_is_buffer
- napi_is_dataview
- napi_is_date
- napi_is_detached_arraybuffer
- napi_is_error
- napi_is_exception_pending
- napi_is_promise
- napi_is_typedarray
- napi_key_collection_mode
- napi_key_conversion
- napi_key_filter
- napi_make_callback
- napi_new_instance
- napi_object_freeze
- napi_object_seal
- napi_open_callback_scope
- napi_open_escapable_handle_scope
- napi_open_handle_scope
- napi_property_attributes
- napi_property_descriptor
- napi_queue_async_work
- napi_ref
- napi_ref_threadsafe_function
- napi_reference_ref
- napi_reference_unref
- napi_reject_deferred
- napi_release_threadsafe_function
- napi_remove_async_cleanup_hook
- napi_remove_env_cleanup_hook
- napi_remove_wrap
- napi_resolve_deferred
- napi_run_script
- napi_set_element
- napi_set_instance_data
- napi_set_named_property
- napi_set_property
- napi_status
- napi_strict_equals
- napi_threadsafe_function
- napi_threadsafe_function_call_js
- napi_threadsafe_function_call_mode
- napi_threadsafe_function_release_mode
- napi_throw
- napi_throw_error
- napi_throw_range_error
- napi_throw_type_error
- napi_type_tag
- napi_type_tag_object
- napi_typedarray_type
- napi_typeof
- napi_unref_threadsafe_function
- napi_unwrap
- napi_value
- napi_valuetype
- napi_wrap
- net.connect()
- net.connect(options[, connectListener])
- net.connect(path[, connectListener])
- net.connect(port[, host][, connectListener])
- net.createConnection()
- net.createConnection(options[, connectListener])
- net.createConnection(path[, connectListener])
- net.createConnection(port[, host][, connectListener])
- net.createServer([options][, connectionListener])
- net.getDefaultAutoSelectFamily()
- net.getDefaultAutoSelectFamilyAttemptTimeout()
- net.isIP(input)
- net.isIPv4(input)
- net.isIPv6(input)
- net.setDefaultAutoSelectFamily(value)
- net.setDefaultAutoSelectFamilyAttemptTimeout(value)
- new Agent([options])
- new Agent([options])
- new AsyncLocalStorage()
- new AsyncResource(type[, options])
- new BroadcastChannel(name)
- new Buffer(array)
- new Buffer(arrayBuffer[, byteOffset[, length]])
- new Buffer(buffer)
- new Buffer(size)
- new Buffer(string[, encoding])
- new ByteLengthQueuingStrategy(init)
- new CompressionStream(format)
- new Console(options)
- new Console(stdout[, stderr][, ignoreErrors])
- new CountQueuingStrategy(init)
- new DatabaseSync(path[, options])
- new DecompressionStream(format)
- new Deserializer(buffer)
- new Error(message[, options])
- new MIMEParams()
- new MIMEType(input)
- new PerformanceObserver(callback)
- new ReadableStream([underlyingSource [, strategy]])
- new ReadableStreamBYOBReader(stream)
- new ReadableStreamDefaultReader(stream)
- new Serializer()
- new SlowBuffer(size)
- new SourceMap(payload[, { lineLengths }])
- new StringDecoder([encoding])
- new TextDecoder([encoding[, options]])
- new TextDecoderStream([encoding[, options]])
- new TextEncoderStream()
- new TransformStream([transformer[, writableStrategy[, readableStrategy]]])
- new URL(input[, base])
- new URLPattern()
- new URLPattern(obj[, baseURL][, options])
- new URLPattern(string[, baseURL][, options])
- new URLSearchParams()
- new URLSearchParams(iterable)
- new URLSearchParams(obj)
- new URLSearchParams(string)
- new WASI([options])
- new Worker(filename[, options])
- new WritableStream([underlyingSink[, strategy]])
- new WritableStreamDefaultWriter(stream)
- new X509Certificate(buffer)
- new assert.AssertionError(options)
- new assert.CallTracker()
- new buffer.Blob([sources[, options]])
- new buffer.File(sources, fileName[, options])
- new crypto.Certificate()
- new events.EventEmitterAsyncResource([options])
- new inspector.Session()
- new net.Server([options][, connectionListener])
- new net.Socket([options])
- new net.SocketAddress([options])
- new readlinePromises.Readline(stream[, options])
- new stream.Duplex(options)
- new stream.Readable([options])
- new stream.Transform([options])
- new stream.Writable([options])
- new tls.TLSSocket(socket[, options])
- new tty.ReadStream(fd[, options])
- new tty.WriteStream(fd)
- new v8.GCProfiler()
- new vm.Script(code[, options])
- new vm.SourceTextModule(code[, options])
- new vm.SyntheticModule(exportNames, evaluateCallback[, options])
- nodeEventTarget.addListener(type, listener)
- nodeEventTarget.emit(type, arg)
- nodeEventTarget.eventNames()
- nodeEventTarget.getMaxListeners()
- nodeEventTarget.listenerCount(type)
- nodeEventTarget.off(type, listener[, options])
- nodeEventTarget.on(type, listener)
- nodeEventTarget.once(type, listener)
- nodeEventTarget.removeAllListeners([type])
- nodeEventTarget.removeListener(type, listener[, options])
- nodeEventTarget.setMaxListeners(n)
- os.arch()
- os.availableParallelism()
- os.cpus()
- os.endianness()
- os.freemem()
- os.getPriority([pid])
- os.homedir()
- os.hostname()
- os.loadavg()
- os.machine()
- os.networkInterfaces()
- os.platform()
- os.release()
- os.setPriority([pid, ]priority)
- os.tmpdir()
- os.totalmem()
- os.type()
- os.uptime()
- os.userInfo([options])
- os.version()
- outgoingMessage.addTrailers(headers)
- outgoingMessage.appendHeader(name, value)
- outgoingMessage.cork()
- outgoingMessage.destroy([error])
- outgoingMessage.end(chunk[, encoding][, callback])
- outgoingMessage.flushHeaders()
- outgoingMessage.getHeader(name)
- outgoingMessage.getHeaderNames()
- outgoingMessage.getHeaders()
- outgoingMessage.hasHeader(name)
- outgoingMessage.pipe()
- outgoingMessage.removeHeader(name)
- outgoingMessage.setHeader(name, value)
- outgoingMessage.setHeaders(headers)
- outgoingMessage.setTimeout(msesc[, callback])
- outgoingMessage.uncork()
- outgoingMessage.write(chunk[, encoding][, callback])
- path.basename(path[, suffix])
- path.dirname(path)
- path.extname(path)
- path.format(pathObject)
- path.isAbsolute(path)
- path.join([...paths])
- path.matchesGlob(path, pattern)
- path.normalize(path)
- path.parse(path)
- path.relative(from, to)
- path.resolve([...paths])
- path.toNamespacedPath(path)
- perf_hooks.createHistogram([options])
- perf_hooks.monitorEventLoopDelay([options])
- performance.clearMarks([name])
- performance.clearMeasures([name])
- performance.clearResourceTimings([name])
- performance.eventLoopUtilization([utilization1[, utilization2]])
- performance.eventLoopUtilization([utilization1[, utilization2]])
- performance.getEntries()
- performance.getEntriesByName(name[, type])
- performance.getEntriesByType(type)
- performance.mark(name[, options])
- performance.markResourceTiming(timingInfo, requestedUrl, initiatorType, global, cacheMode, bodyInfo, responseStatus[, deliveryType])
- performance.measure(name[, startMarkOrOptions[, endMark]])
- performance.now()
- performance.setResourceTimingBufferSize(maxSize)
- performance.timerify(fn[, options])
- performance.toJSON()
- performanceObserver.disconnect()
- performanceObserver.observe(options)
- performanceObserver.takeRecords()
- performanceObserverEntryList.getEntries()
- performanceObserverEntryList.getEntriesByName(name[, type])
- performanceObserverEntryList.getEntriesByType(type)
- performanceResourceTiming.toJSON()
- permission.has(scope[, reference])
- port.close()
- port.hasRef()
- port.postMessage(value[, transferList])
- port.ref()
- port.start()
- port.unref()
- process.abort()
- process.availableMemory()
- process.channel.ref()
- process.channel.unref()
- process.chdir(directory)
- process.constrainedMemory()
- process.cpuUsage([previousValue])
- process.cwd()
- process.disconnect()
- process.dlopen(module, filename[, flags])
- process.emitWarning(warning[, options])
- process.emitWarning(warning[, type[, code]][, ctor])
- process.execve(file[, args[, env]])
- process.exit([code])
- process.finalization.register(ref, callback)
- process.finalization.registerBeforeExit(ref, callback)
- process.finalization.unregister(ref)
- process.getActiveResourcesInfo()
- process.getBuiltinModule(id)
- process.getegid()
- process.geteuid()
- process.getgid()
- process.getgroups()
- process.getuid()
- process.hasUncaughtExceptionCaptureCallback()
- process.hrtime([time])
- process.hrtime.bigint()
- process.initgroups(user, extraGroup)
- process.kill(pid[, signal])
- process.loadEnvFile(path)
- process.memoryUsage()
- process.memoryUsage.rss()
- process.nextTick(callback[, ...args])
- process.permission.has(scope[, reference])
- process.ref(maybeRefable)
- process.report.getReport([err])
- process.report.writeReport([filename][, err])
- process.resourceUsage()
- process.send(message[, sendHandle[, options]][, callback])
- process.setSourceMapsEnabled(val)
- process.setUncaughtExceptionCaptureCallback(fn)
- process.setegid(id)
- process.seteuid(id)
- process.setgid(id)
- process.setgroups(groups)
- process.setuid(id)
- process.threadCpuUsage([previousValue])
- process.umask()
- process.umask(mask)
- process.unref(maybeRefable)
- process.uptime()
- profiler.start()
- profiler.stop()
- promiseHooks.createHook(callbacks)
- promiseHooks.onAfter(after)
- promiseHooks.onBefore(before)
- promiseHooks.onInit(init)
- promiseHooks.onSettled(settled)
- promiseResolve(asyncId)
- punycode.decode(string)
- punycode.encode(string)
- punycode.toASCII(domain)
- punycode.toUnicode(domain)
- punycode.ucs2.decode(string)
- punycode.ucs2.encode(codePoints)
- querystring.decode()
- querystring.encode()
- querystring.escape(str)
- querystring.parse(str[, sep[, eq[, options]]])
- querystring.stringify(obj[, sep[, eq[, options]]])
- querystring.unescape(str)
- queueMicrotask(callback)
- readStream.setRawMode(mode)
- readable._construct(callback)
- readable._destroy(err, callback)
- readable._read(size)
- readable.compose(stream[, options])
- readable.destroy([error])
- readable.drop(limit[, options])
- readable.every(fn[, options])
- readable.filter(fn[, options])
- readable.find(fn[, options])
- readable.flatMap(fn[, options])
- readable.forEach(fn[, options])
- readable.isPaused()
- readable.iterator([options])
- readable.map(fn[, options])
- readable.pause()
- readable.pipe(destination[, options])
- readable.push()
- readable.push(chunk[, encoding])
- readable.read(0)
- readable.read([size])
- readable.reduce(fn[, initial[, options]])
- readable.resume()
- readable.setEncoding(encoding)
- readable.some(fn[, options])
- readable.take(limit[, options])
- readable.toArray([options])
- readable.unpipe([destination])
- readable.unshift(chunk[, encoding])
- readable.wrap(stream)
- readableByteStreamController.close()
- readableByteStreamController.enqueue(chunk)
- readableByteStreamController.error([error])
- readableStream.cancel([reason])
- readableStream.getReader([options])
- readableStream.pipeThrough(transform[, options])
- readableStream.pipeTo(destination[, options])
- readableStream.tee()
- readableStream.values([options])
- readableStreamBYOBReader.cancel([reason])
- readableStreamBYOBReader.read(view[, options])
- readableStreamBYOBReader.releaseLock()
- readableStreamBYOBRequest.respond(bytesWritten)
- readableStreamBYOBRequest.respondWithNewView(view)
- readableStreamDefaultController.close()
- readableStreamDefaultController.enqueue([chunk])
- readableStreamDefaultController.error([error])
- readableStreamDefaultReader.cancel([reason])
- readableStreamDefaultReader.read()
- readableStreamDefaultReader.releaseLock()
- readable[Symbol.asyncDispose]()
- readable[Symbol.asyncIterator]()
- readline.clearLine(stream, dir[, callback])
- readline.clearScreenDown(stream[, callback])
- readline.createInterface(options)
- readline.cursorTo(stream, x[, y][, callback])
- readline.emitKeypressEvents(stream[, interface])
- readline.moveCursor(stream, dx, dy[, callback])
- readlinePromises.createInterface(options)
- repl.start([options])
- replServer.clearBufferedCommand()
- replServer.defineCommand(keyword, cmd)
- replServer.displayPrompt([preserveCursor])
- replServer.setupHistory(historyPath, callback)
- request.abort()
- request.cork()
- request.destroy([error])
- request.destroy([error])
- request.end([data[, encoding]][, callback])
- request.flushHeaders()
- request.getHeader(name)
- request.getHeaderNames()
- request.getHeaders()
- request.getRawHeaderNames()
- request.hasHeader(name)
- request.removeHeader(name)
- request.setHeader(name, value)
- request.setNoDelay([noDelay])
- request.setSocketKeepAlive([enable][, initialDelay])
- request.setTimeout(msecs, callback)
- request.setTimeout(timeout[, callback])
- request.uncork()
- request.write(chunk[, encoding][, callback])
- require()
- require(id)
- require.resolve(request[, options])
- require.resolve.paths(request)
- resolve(specifier, context, nextResolve)
- resolver.cancel()
- resolver.setLocalAddress([ipv4][, ipv6])
- response.addTrailers(headers)
- response.addTrailers(headers)
- response.appendHeader(name, value)
- response.cork()
- response.createPushResponse(headers, callback)
- response.end([data[, encoding]][, callback])
- response.end([data[, encoding]][, callback])
- response.flushHeaders()
- response.getHeader(name)
- response.getHeader(name)
- response.getHeaderNames()
- response.getHeaderNames()
- response.getHeaders()
- response.getHeaders()
- response.hasHeader(name)
- response.hasHeader(name)
- response.removeHeader(name)
- response.removeHeader(name)
- response.setHeader(name, value)
- response.setHeader(name, value)
- response.setTimeout(msecs[, callback])
- response.setTimeout(msecs[, callback])
- response.uncork()
- response.write(chunk[, encoding][, callback])
- response.write(chunk[, encoding][, callback])
- response.writeContinue()
- response.writeContinue()
- response.writeEarlyHints(hints)
- response.writeEarlyHints(hints[, callback])
- response.writeHead(statusCode[, statusMessage][, headers])
- response.writeHead(statusCode[, statusMessage][, headers])
- response.writeProcessing()
- rl.clearLine(dir)
- rl.clearScreenDown()
- rl.close()
- rl.commit()
- rl.cursorTo(x[, y])
- rl.getCursorPos()
- rl.getPrompt()
- rl.moveCursor(dx, dy)
- rl.pause()
- rl.prompt([preserveCursor])
- rl.question(query[, options])
- rl.question(query[, options], callback)
- rl.resume()
- rl.rollback()
- rl.setPrompt(prompt)
- rl.write(data[, key])
- rl[Symbol.asyncIterator]()
- rl[Symbol.dispose]()
- run([options])
- script.createCachedData()
- script.runInContext(contextifiedObject[, options])
- script.runInNewContext([contextObject[, options]])
- script.runInThisContext([options])
- sea.getAsset(key[, encoding])
- sea.getAssetAsBlob(key[, options])
- sea.getRawAsset(key)
- sea.isSea()
- serializer._getDataCloneError(message)
- serializer._getSharedArrayBufferId(sharedArrayBuffer)
- serializer._setTreatArrayBufferViewsAsHostObjects(flag)
- serializer._writeHostObject(object)
- serializer.releaseBuffer()
- serializer.transferArrayBuffer(id, arrayBuffer)
- serializer.writeDouble(value)
- serializer.writeHeader()
- serializer.writeRawBytes(buffer)
- serializer.writeUint32(value)
- serializer.writeUint64(hi, lo)
- serializer.writeValue(value)
- server.addContext(hostname, context)
- server.address()
- server.address()
- server.close([callback])
- server.close([callback])
- server.close([callback])
- server.close([callback])
- server.close([callback])
- server.closeAllConnections()
- server.closeAllConnections()
- server.closeIdleConnections()
- server.closeIdleConnections()
- server.getConnections(callback)
- server.getTicketKeys()
- server.listen()
- server.listen()
- server.listen()
- server.listen()
- server.listen([port[, host[, backlog]]][, callback])
- server.listen(handle[, backlog][, callback])
- server.listen(options[, callback])
- server.listen(path[, backlog][, callback])
- server.ref()
- server.setSecureContext(options)
- server.setTicketKeys(keys)
- server.setTimeout([msecs][, callback])
- server.setTimeout([msecs][, callback])
- server.setTimeout([msecs][, callback])
- server.unref()
- server.updateSettings([settings])
- server[Symbol.asyncDispose]()
- server[Symbol.asyncDispose]()
- server[Symbol.asyncDispose]()
- server[Symbol.asyncDispose]()
- serverhttp2session.altsvc(alt, originOrStream)
- serverhttp2session.origin(...origins)
- session.changeset()
- session.connect()
- session.connectToMainThread()
- session.disconnect()
- session.patchset()
- session.post(method[, params])
- session.post(method[, params][, callback])
- setImmediate(callback[, ...args])
- setImmediate(callback[, ...args])
- setInterval(callback, delay[, ...args])
- setInterval(callback[, delay[, ...args]])
- setTimeout(callback, delay[, ...args])
- setTimeout(callback[, delay[, ...args]])
- settled(promise)
- sign.sign(privateKey[, outputEncoding])
- sign.update(data[, inputEncoding])
- snapshot.setDefaultSnapshotSerializers(serializers)
- snapshot.setResolveSnapshotPath(fn)
- socket.addMembership(multicastAddress[, multicastInterface])
- socket.addSourceSpecificMembership(sourceAddress, groupAddress[, multicastInterface])
- socket.address()
- socket.address()
- socket.bind([port][, address][, callback])
- socket.bind(options[, callback])
- socket.close([callback])
- socket.connect()
- socket.connect(options[, connectListener])
- socket.connect(path[, connectListener])
- socket.connect(port[, address][, callback])
- socket.connect(port[, host][, connectListener])
- socket.destroy([error])
- socket.destroySoon()
- socket.disconnect()
- socket.dropMembership(multicastAddress[, multicastInterface])
- socket.dropSourceSpecificMembership(sourceAddress, groupAddress[, multicastInterface])
- socket.end([data[, encoding]][, callback])
- socket.getRecvBufferSize()
- socket.getSendBufferSize()
- socket.getSendQueueCount()
- socket.getSendQueueSize()
- socket.pause()
- socket.ref()
- socket.ref()
- socket.remoteAddress()
- socket.resetAndDestroy()
- socket.resume()
- socket.send(msg[, offset, length][, port][, address][, callback])
- socket.setBroadcast(flag)
- socket.setEncoding([encoding])
- socket.setKeepAlive([enable][, initialDelay])
- socket.setMulticastInterface(multicastInterface)
- socket.setMulticastLoopback(flag)
- socket.setMulticastTTL(ttl)
- socket.setNoDelay([noDelay])
- socket.setRecvBufferSize(size)
- socket.setSendBufferSize(size)
- socket.setTTL(ttl)
- socket.setTimeout(timeout[, callback])
- socket.unref()
- socket.unref()
- socket.write(data[, encoding][, callback])
- socket[Symbol.asyncDispose]()
- sourceMap.findEntry(lineOffset, columnOffset)
- sourceMap.findOrigin(lineNumber, columnNumber)
- sourceTextModule.createCachedData()
- sqlite.backup(sourceDb, path[, options])
- start(event)
- statement.all([namedParameters][, ...anonymousParameters])
- statement.columns()
- statement.get([namedParameters][, ...anonymousParameters])
- statement.iterate([namedParameters][, ...anonymousParameters])
- statement.run([namedParameters][, ...anonymousParameters])
- statement.setAllowBareNamedParameters(enabled)
- statement.setAllowUnknownNamedParameters(enabled)
- statement.setReadBigInts(enabled)
- stats.isBlockDevice()
- stats.isCharacterDevice()
- stats.isDirectory()
- stats.isFIFO()
- stats.isFile()
- stats.isSocket()
- stats.isSymbolicLink()
- stream.Duplex.from(src)
- stream.Duplex.fromWeb(pair[, options])
- stream.Duplex.toWeb(streamDuplex)
- stream.Readable.from(iterable[, options])
- stream.Readable.fromWeb(readableStream[, options])
- stream.Readable.isDisturbed(stream)
- stream.Readable.toWeb(streamReadable[, options])
- stream.Writable.fromWeb(writableStream[, options])
- stream.Writable.toWeb(streamWritable)
- stream.addAbortSignal(signal, stream)
- stream.compose(...streams)
- stream.duplexPair([options])
- stream.finished(stream[, options])
- stream.finished(stream[, options], callback)
- stream.getDefaultHighWaterMark(objectMode)
- stream.isErrored(stream)
- stream.isReadable(stream)
- stream.pipeline(source[, ...transforms], destination, callback)
- stream.pipeline(source[, ...transforms], destination[, options])
- stream.pipeline(streams, callback)
- stream.pipeline(streams[, options])
- stream.setDefaultHighWaterMark(objectMode, value)
- streamConsumers.arrayBuffer(stream)
- streamConsumers.blob(stream)
- streamConsumers.buffer(stream)
- streamConsumers.json(stream)
- streamConsumers.text(stream)
- stringDecoder.end([buffer])
- stringDecoder.write(buffer)
- structuredClone(value[, options])
- subprocess.channel.ref()
- subprocess.channel.unref()
- subprocess.disconnect()
- subprocess.kill([signal])
- subprocess.ref()
- subprocess.send(message[, sendHandle[, options]][, callback])
- subprocess.unref()
- subprocess[Symbol.dispose]()
- subtle.decrypt(algorithm, key, data)
- subtle.deriveBits(algorithm, baseKey[, length])
- subtle.deriveKey(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages)
- subtle.digest(algorithm, data)
- subtle.encrypt(algorithm, key, data)
- subtle.exportKey(format, key)
- subtle.generateKey(algorithm, extractable, keyUsages)
- subtle.importKey(format, keyData, algorithm, extractable, keyUsages)
- subtle.sign(algorithm, key, data)
- subtle.unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgo, unwrappedKeyAlgo, extractable, keyUsages)
- subtle.verify(algorithm, key, signature, data)
- subtle.wrapKey(format, key, wrappingKey, wrapAlgo)
- suite([name][, options][, fn])
- suite.only([name][, options][, fn])
- suite.skip([name][, options][, fn])
- suite.todo([name][, options][, fn])
- syntheticModule.setExport(name, value)
- test([name][, options][, fn])
- test.only([name][, options][, fn])
- test.skip([name][, options][, fn])
- test.todo([name][, options][, fn])
- textDecoder.decode([input[, options]])
- textEncoder.encode([input])
- textEncoder.encodeInto(src, dest)
- timeout.close()
- timeout.hasRef()
- timeout.ref()
- timeout.refresh()
- timeout.unref()
- timeout[Symbol.dispose]()
- timeout[Symbol.toPrimitive]()
- timers.enable([enableOptions])
- timers.reset()
- timers.runAll()
- timers.setTime(milliseconds)
- timers.tick([milliseconds])
- timersPromises.scheduler.wait(delay[, options])
- timersPromises.scheduler.yield()
- timersPromises.setImmediate([value[, options]])
- timersPromises.setInterval([delay[, value[, options]]])
- timersPromises.setTimeout([delay[, value[, options]]])
- timers[Symbol.dispose]()
- tls.checkServerIdentity(hostname, cert)
- tls.connect(options[, callback])
- tls.connect(path[, options][, callback])
- tls.connect(port[, host][, options][, callback])
- tls.createSecureContext([options])
- tls.createSecurePair([context][, isServer][, requestCert][, rejectUnauthorized][, options])
- tls.createServer([options][, secureConnectionListener])
- tls.getCACertificates([type])
- tls.getCiphers()
- tlsSocket.address()
- tlsSocket.disableRenegotiation()
- tlsSocket.enableTrace()
- tlsSocket.exportKeyingMaterial(length, label[, context])
- tlsSocket.getCertificate()
- tlsSocket.getCipher()
- tlsSocket.getEphemeralKeyInfo()
- tlsSocket.getFinished()
- tlsSocket.getPeerCertificate([detailed])
- tlsSocket.getPeerFinished()
- tlsSocket.getPeerX509Certificate()
- tlsSocket.getProtocol()
- tlsSocket.getSession()
- tlsSocket.getSharedSigalgs()
- tlsSocket.getTLSTicket()
- tlsSocket.getX509Certificate()
- tlsSocket.isSessionReused()
- tlsSocket.renegotiate(options, callback)
- tlsSocket.setKeyCert(context)
- tlsSocket.setMaxSendFragment(size)
- trace_events.createTracing(options)
- trace_events.getEnabledCategories()
- tracing.disable()
- tracing.enable()
- tracingChannel.subscribe(subscribers)
- tracingChannel.traceCallback(fn[, position[, context[, thisArg[, ...args]]]])
- tracingChannel.tracePromise(fn[, context[, thisArg[, ...args]]])
- tracingChannel.traceSync(fn[, context[, thisArg[, ...args]]])
- tracingChannel.unsubscribe(subscribers)
- tracker.calls([fn][, exact])
- tracker.getCalls(fn)
- tracker.report()
- tracker.reset([fn])
- tracker.verify()
- transform._flush(callback)
- transform._transform(chunk, encoding, callback)
- transform.destroy([error])
- transformStreamDefaultController.enqueue([chunk])
- transformStreamDefaultController.error([reason])
- transformStreamDefaultController.terminate()
- tty.isatty(fd)
- url.domainToASCII(domain)
- url.domainToUnicode(domain)
- url.fileURLToPath(url[, options])
- url.format(URL[, options])
- url.format(urlObject)
- url.parse(urlString[, parseQueryString[, slashesDenoteHost]])
- url.pathToFileURL(path[, options])
- url.resolve(from, to)
- url.toJSON()
- url.toString()
- url.urlToHttpOptions(url)
- urlPattern.exec(input[, baseURL])
- urlPattern.test(input[, baseURL])
- urlSearchParams.append(name, value)
- urlSearchParams.delete(name[, value])
- urlSearchParams.entries()
- urlSearchParams.forEach(fn[, thisArg])
- urlSearchParams.get(name)
- urlSearchParams.getAll(name)
- urlSearchParams.has(name[, value])
- urlSearchParams.keys()
- urlSearchParams.set(name, value)
- urlSearchParams.sort()
- urlSearchParams.toString()
- urlSearchParams.values()
- urlSearchParams[Symbol.iterator]()
- util._extend(target, source)
- util.aborted(signal, resource)
- util.callbackify(original)
- util.debug(section)
- util.debuglog(section[, callback])
- util.deprecate(fn, msg[, code])
- util.diff(actual, expected)
- util.format(format[, ...args])
- util.formatWithOptions(inspectOptions, format[, ...args])
- util.getCallSites([frameCount][, options])
- util.getSystemErrorMap()
- util.getSystemErrorMessage(err)
- util.getSystemErrorName(err)
- util.inherits(constructor, superConstructor)
- util.inspect(object[, options])
- util.inspect(object[, showHidden[, depth[, colors]]])
- util.isArray(object)
- util.isDeepStrictEqual(val1, val2)
- util.parseArgs([config])
- util.parseEnv(content)
- util.promisify(original)
- util.stripVTControlCharacters(str)
- util.styleText(format, text[, options])
- util.toUSVString(string)
- util.transferableAbortController()
- util.transferableAbortSignal(signal)
- util.types.isAnyArrayBuffer(value)
- util.types.isArgumentsObject(value)
- util.types.isArrayBuffer(value)
- util.types.isArrayBufferView(value)
- util.types.isAsyncFunction(value)
- util.types.isBigInt64Array(value)
- util.types.isBigIntObject(value)
- util.types.isBigUint64Array(value)
- util.types.isBooleanObject(value)
- util.types.isBoxedPrimitive(value)
- util.types.isCryptoKey(value)
- util.types.isDataView(value)
- util.types.isDate(value)
- util.types.isExternal(value)
- util.types.isFloat32Array(value)
- util.types.isFloat64Array(value)
- util.types.isGeneratorFunction(value)
- util.types.isGeneratorObject(value)
- util.types.isInt16Array(value)
- util.types.isInt32Array(value)
- util.types.isInt8Array(value)
- util.types.isKeyObject(value)
- util.types.isMap(value)
- util.types.isMapIterator(value)
- util.types.isModuleNamespaceObject(value)
- util.types.isNativeError(value)
- util.types.isNumberObject(value)
- util.types.isPromise(value)
- util.types.isProxy(value)
- util.types.isRegExp(value)
- util.types.isSet(value)
- util.types.isSetIterator(value)
- util.types.isSharedArrayBuffer(value)
- util.types.isStringObject(value)
- util.types.isSymbolObject(value)
- util.types.isTypedArray(value)
- util.types.isUint16Array(value)
- util.types.isUint32Array(value)
- util.types.isUint8Array(value)
- util.types.isUint8ClampedArray(value)
- util.types.isWeakMap(value)
- util.types.isWeakSet(value)
- v8.cachedDataVersionTag()
- v8.deserialize(buffer)
- v8.getCppHeapStatistics([detailLevel])
- v8.getHeapCodeStatistics()
- v8.getHeapSnapshot([options])
- v8.getHeapSpaceStatistics()
- v8.getHeapStatistics()
- v8.isStringOneByteRepresentation(content)
- v8.queryObjects(ctor[, options])
- v8.serialize(value)
- v8.setFlagsFromString(flags)
- v8.setHeapSnapshotNearHeapLimit(limit)
- v8.startupSnapshot.addDeserializeCallback(callback[, data])
- v8.startupSnapshot.addSerializeCallback(callback[, data])
- v8.startupSnapshot.isBuildingSnapshot()
- v8.startupSnapshot.setDeserializeMainFunction(callback[, data])
- v8.stopCoverage()
- v8.takeCoverage()
- v8.writeHeapSnapshot([filename[,options]])
- verify.update(data[, inputEncoding])
- verify.verify(object, signature[, signatureEncoding])
- vm.compileFunction(code[, params[, options]])
- vm.createContext([contextObject[, options]])
- vm.isContext(object)
- vm.measureMemory([options])
- vm.runInContext(code, contextifiedObject[, options])
- vm.runInNewContext(code[, contextObject[, options]])
- vm.runInThisContext(code[, options])
- wasi.getImportObject()
- wasi.initialize(instance)
- wasi.start(instance)
- watcher.close()
- watcher.ref()
- watcher.unref()
- worker.disconnect()
- worker.getEnvironmentData(key)
- worker.getHeapSnapshot([options])
- worker.isConnected()
- worker.isDead()
- worker.isMarkedAsUntransferable(object)
- worker.kill([signal])
- worker.markAsUncloneable(object)
- worker.markAsUntransferable(object)
- worker.moveMessagePortToContext(port, contextifiedSandbox)
- worker.postMessage(value[, transferList])
- worker.postMessageToThread(threadId, value[, transferList][, timeout])
- worker.receiveMessageOnPort(port)
- worker.ref()
- worker.send(message[, sendHandle[, options]][, callback])
- worker.setEnvironmentData(key[, value])
- worker.terminate()
- worker.unref()
- writable._construct(callback)
- writable._destroy(err, callback)
- writable._final(callback)
- writable._write(chunk, encoding, callback)
- writable._writev(chunks, callback)
- writable.cork()
- writable.destroy([error])
- writable.end([chunk[, encoding]][, callback])
- writable.setDefaultEncoding(encoding)
- writable.uncork()
- writable.write(chunk[, encoding][, callback])
- writableStream.abort([reason])
- writableStream.close()
- writableStream.getWriter()
- writableStreamDefaultController.error([error])
- writableStreamDefaultWriter.abort([reason])
- writableStreamDefaultWriter.close()
- writableStreamDefaultWriter.releaseLock()
- writableStreamDefaultWriter.write([chunk])
- writable[Symbol.asyncDispose]()
- writeStream.clearLine(dir[, callback])
- writeStream.clearScreenDown([callback])
- writeStream.close([callback])
- writeStream.cursorTo(x[, y][, callback])
- writeStream.getColorDepth([env])
- writeStream.getWindowSize()
- writeStream.hasColors([count][, env])
- writeStream.moveCursor(dx, dy[, callback])
- x509.checkEmail(email[, options])
- x509.checkHost(name[, options])
- x509.checkIP(ip)
- x509.checkIssued(otherCert)
- x509.checkPrivateKey(privateKey)
- x509.toJSON()
- x509.toLegacyObject()
- x509.toString()
- x509.verify(publicKey)
- zlib.brotliCompress(buffer[, options], callback)
- zlib.brotliCompressSync(buffer[, options])
- zlib.brotliDecompress(buffer[, options], callback)
- zlib.brotliDecompressSync(buffer[, options])
- zlib.close([callback])
- zlib.crc32(data[, value])
- zlib.createBrotliCompress([options])
- zlib.createBrotliDecompress([options])
- zlib.createDeflate([options])
- zlib.createDeflateRaw([options])
- zlib.createGunzip([options])
- zlib.createGzip([options])
- zlib.createInflate([options])
- zlib.createInflateRaw([options])
- zlib.createUnzip([options])
- zlib.createZstdCompress([options])
- zlib.createZstdDecompress([options])
- zlib.deflate(buffer[, options], callback)
- zlib.deflateRaw(buffer[, options], callback)
- zlib.deflateRawSync(buffer[, options])
- zlib.deflateSync(buffer[, options])
- zlib.flush([kind, ]callback)
- zlib.gunzip(buffer[, options], callback)
- zlib.gunzipSync(buffer[, options])
- zlib.gzip(buffer[, options], callback)
- zlib.gzipSync(buffer[, options])
- zlib.inflate(buffer[, options], callback)
- zlib.inflateRaw(buffer[, options], callback)
- zlib.inflateRawSync(buffer[, options])
- zlib.inflateSync(buffer[, options])
- zlib.params(level, strategy, callback)
- zlib.reset()
- zlib.unzip(buffer[, options], callback)
- zlib.unzipSync(buffer[, options])
- zlib.zstdCompress(buffer[, options], callback)
- zlib.zstdCompressSync(buffer[, options])
- zlib.zstdDecompress(buffer[, options], callback)
- zlib.zstdDecompressSync(buffer[, options])
instps