node__assert.d.ts

The `node:assert` module provides a set of assertion functions for verifying invariants.

node__async_hooks.d.ts

We strongly discourage the use of the `async_hooks` API. Other APIs that can cover most of its use cases include: * [`AsyncLocalStorage`](https://nodejs.org/docs/latest-v22.x/api/async_context.html#class-asynclocalstorage) tracks async context * [`process.getActiveResourcesInfo()`](https://nodejs.org/docs/latest-v22.x/api/process.html#processgetactiveresourcesinfo) tracks active resources The `node:async_hooks` module provides an API to track asynchronous resources. It can be accessed using: ```js import async_hooks from 'node:async_hooks'; ```

node__buffer.d.ts

`Buffer` objects are used to represent a fixed-length sequence of bytes. Many Node.js APIs support `Buffer`s. The `Buffer` class is a subclass of JavaScript's [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) class and extends it with methods that cover additional use cases. Node.js APIs accept plain [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) s wherever `Buffer`s are supported as well. While the `Buffer` class is available within the global scope, it is still recommended to explicitly reference it via an import or require statement. ```js import { Buffer } from 'node:buffer'; // Creates a zero-filled Buffer of length 10. const buf1 = Buffer.alloc(10); // Creates a Buffer of length 10, // filled with bytes which all have the value `1`. const buf2 = Buffer.alloc(10, 1); // Creates an uninitialized buffer of length 10. // This is faster than calling Buffer.alloc() but the returned // Buffer instance might contain old data that needs to be // overwritten using fill(), write(), or other functions that fill the Buffer's // contents. const buf3 = Buffer.allocUnsafe(10); // Creates a Buffer containing the bytes [1, 2, 3]. const buf4 = Buffer.from([1, 2, 3]); // Creates a Buffer containing the bytes [1, 1, 1, 1] – the entries // are all truncated using `(value & 255)` to fit into the range 0–255. const buf5 = Buffer.from([257, 257.5, -255, '1']); // Creates a Buffer containing the UTF-8-encoded bytes for the string 'tést': // [0x74, 0xc3, 0xa9, 0x73, 0x74] (in hexadecimal notation) // [116, 195, 169, 115, 116] (in decimal notation) const buf6 = Buffer.from('tést'); // Creates a Buffer containing the Latin-1 bytes [0x74, 0xe9, 0x73, 0x74]. const buf7 = Buffer.from('tést', 'latin1'); ```

node__child_process.d.ts

The `node:child_process` module provides the ability to spawn subprocesses in a manner that is similar, but not identical, to [`popen(3)`](http://man7.org/linux/man-pages/man3/popen.3.html). This capability is primarily provided by the spawn function: ```js import { spawn } from 'node:child_process'; const ls = spawn('ls', ['-lh', '/usr']); ls.stdout.on('data', (data) => { console.log(`stdout: ${data}`); }); ls.stderr.on('data', (data) => { console.error(`stderr: ${data}`); }); ls.on('close', (code) => { console.log(`child process exited with code ${code}`); }); ``` By default, pipes for `stdin`, `stdout`, and `stderr` are established between the parent Node.js process and the spawned subprocess. These pipes have limited (and platform-specific) capacity. If the subprocess writes to stdout in excess of that limit without the output being captured, the subprocess blocks waiting for the pipe buffer to accept more data. This is identical to the behavior of pipes in the shell. Use the `{ stdio: 'ignore' }` option if the output will not be consumed. The command lookup is performed using the `options.env.PATH` environment variable if `env` is in the `options` object. Otherwise, `process.env.PATH` is used. If `options.env` is set without `PATH`, lookup on Unix is performed on a default search path search of `/usr/bin:/bin` (see your operating system's manual for execvpe/execvp), on Windows the current processes environment variable `PATH` is used. On Windows, environment variables are case-insensitive. Node.js lexicographically sorts the `env` keys and uses the first one that case-insensitively matches. Only first (in lexicographic order) entry will be passed to the subprocess. This might lead to issues on Windows when passing objects to the `env` option that have multiple variants of the same key, such as `PATH` and `Path`. The spawn method spawns the child process asynchronously, without blocking the Node.js event loop. The spawnSync function provides equivalent functionality in a synchronous manner that blocks the event loop until the spawned process either exits or is terminated. For convenience, the `node:child_process` module provides a handful of synchronous and asynchronous alternatives to spawn and spawnSync. Each of these alternatives are implemented on top of spawn or spawnSync. * exec: spawns a shell and runs a command within that shell, passing the `stdout` and `stderr` to a callback function when complete. * execFile: similar to exec except that it spawns the command directly without first spawning a shell by default. * fork: spawns a new Node.js process and invokes a specified module with an IPC communication channel established that allows sending messages between parent and child. * execSync: a synchronous version of exec that will block the Node.js event loop. * execFileSync: a synchronous version of execFile that will block the Node.js event loop. For certain use cases, such as automating shell scripts, the `synchronous counterparts` may be more convenient. In many cases, however, the synchronous methods can have significant impact on performance due to stalling the event loop while spawned processes complete.

node__cluster.d.ts

> [!WARNING] Deno compatibility > All exports are non-functional stubs. Clusters of Node.js processes can be used to run multiple instances of Node.js that can distribute workloads among their application threads. When process isolation is not needed, use the [`worker_threads`](https://nodejs.org/docs/latest-v22.x/api/worker_threads.html) module instead, which allows running multiple application threads within a single Node.js instance. The cluster module allows easy creation of child processes that all share server ports. ```js import cluster from 'node:cluster'; import http from 'node:http'; import { availableParallelism } from 'node:os'; import process from 'node:process'; const numCPUs = availableParallelism(); if (cluster.isPrimary) { console.log(`Primary ${process.pid} is running`); // Fork workers. for (let i = 0; i < numCPUs; i++) { cluster.fork(); } cluster.on('exit', (worker, code, signal) => { console.log(`worker ${worker.process.pid} died`); }); } else { // Workers can share any TCP connection // In this case it is an HTTP server http.createServer((req, res) => { res.writeHead(200); res.end('hello world\n'); }).listen(8000); console.log(`Worker ${process.pid} started`); } ``` Running Node.js will now share port 8000 between the workers: ```console $ node server.js Primary 3596 is running Worker 4324 started Worker 4520 started Worker 6056 started Worker 5644 started ``` On Windows, it is not yet possible to set up a named pipe server in a worker.

node__console.d.ts

The `node:console` module provides a simple debugging console that is similar to the JavaScript console mechanism provided by web browsers. The module exports two specific components: * A `Console` class with methods such as `console.log()`, `console.error()`, and `console.warn()` that can be used to write to any Node.js stream. * A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstdout) and [`process.stderr`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module. _**Warning**_: The global console object's methods are neither consistently synchronous like the browser APIs they resemble, nor are they consistently asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v22.x/api/process.html#a-note-on-process-io) for more information. Example using the global `console`: ```js console.log('hello world'); // Prints: hello world, to stdout console.log('hello %s', 'world'); // Prints: hello world, to stdout console.error(new Error('Whoops, something bad happened')); // Prints error message and stack trace to stderr: // Error: Whoops, something bad happened // at [eval]:5:15 // at Script.runInThisContext (node:vm:132:18) // at Object.runInThisContext (node:vm:309:38) // at node:internal/process/execution:77:19 // at [eval]-wrapper:6:22 // at evalScript (node:internal/process/execution:76:60) // at node:internal/main/eval_string:23:3 const name = 'Will Robinson'; console.warn(`Danger ${name}! Danger!`); // Prints: Danger Will Robinson! Danger!, to stderr ``` Example using the `Console` class: ```js const out = getStreamSomehow(); const err = getStreamSomehow(); const myConsole = new console.Console(out, err); myConsole.log('hello world'); // Prints: hello world, to out myConsole.log('hello %s', 'world'); // Prints: hello world, to out myConsole.error(new Error('Whoops, something bad happened')); // Prints: [Error: Whoops, something bad happened], to err const name = 'Will Robinson'; myConsole.warn(`Danger ${name}! Danger!`); // Prints: Danger Will Robinson! Danger!, to err ```

node__constants.d.ts

node__crypto.d.ts

The `node:crypto` module provides cryptographic functionality that includes a set of wrappers for OpenSSL's hash, HMAC, cipher, decipher, sign, and verify functions. ```js const { createHmac } = await import('node:crypto'); const secret = 'abcdefg'; const hash = createHmac('sha256', secret) .update('I love cupcakes') .digest('hex'); console.log(hash); // Prints: // c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e ```

node__dgram.d.ts

The `node:dgram` module provides an implementation of UDP datagram sockets. ```js import dgram from 'node:dgram'; const server = dgram.createSocket('udp4'); server.on('error', (err) => { console.error(`server error:\n${err.stack}`); server.close(); }); server.on('message', (msg, rinfo) => { console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`); }); server.on('listening', () => { const address = server.address(); console.log(`server listening ${address.address}:${address.port}`); }); server.bind(41234); // Prints: server listening 0.0.0.0:41234 ```

node__diagnostics_channel.d.ts

The `node:diagnostics_channel` module provides an API to create named channels to report arbitrary message data for diagnostics purposes. It can be accessed using: ```js import diagnostics_channel from 'node:diagnostics_channel'; ``` It is intended that a module writer wanting to report diagnostics messages will create one or many top-level channels to report messages through. Channels may also be acquired at runtime but it is not encouraged due to the additional overhead of doing so. Channels may be exported for convenience, but as long as the name is known it can be acquired anywhere. If you intend for your module to produce diagnostics data for others to consume it is recommended that you include documentation of what named channels are used along with the shape of the message data. Channel names should generally include the module name to avoid collisions with data from other modules.

node__dns--promises.d.ts

The `dns.promises` API provides an alternative set of asynchronous DNS methods that return `Promise` objects rather than using callbacks. The API is accessible via `import { promises as dnsPromises } from 'node:dns'` or `import dnsPromises from 'node:dns/promises'`.

node__dns.d.ts

The `node:dns` module enables name resolution. For example, use it to look up IP addresses of host names. Although named for the [Domain Name System (DNS)](https://en.wikipedia.org/wiki/Domain_Name_System), it does not always use the DNS protocol for lookups. lookup uses the operating system facilities to perform name resolution. It may not need to perform any network communication. To perform name resolution the way other applications on the same system do, use lookup. ```js import dns from 'node:dns'; dns.lookup('example.org', (err, address, family) => { console.log('address: %j family: IPv%s', address, family); }); // address: "93.184.216.34" family: IPv4 ``` All other functions in the `node:dns` module connect to an actual DNS server to perform name resolution. They will always use the network to perform DNS queries. These functions do not use the same set of configuration files used by lookup (e.g. `/etc/hosts`). Use these functions to always perform DNS queries, bypassing other name-resolution facilities. ```js import dns from 'node:dns'; dns.resolve4('archive.org', (err, addresses) => { if (err) throw err; console.log(`addresses: ${JSON.stringify(addresses)}`); addresses.forEach((a) => { dns.reverse(a, (err, hostnames) => { if (err) { throw err; } console.log(`reverse for ${a}: ${JSON.stringify(hostnames)}`); }); }); }); ``` See the [Implementation considerations section](https://nodejs.org/docs/latest-v22.x/api/dns.html#implementation-considerations) for more information.

node__domain.d.ts

> [!WARNING] Deno compatibility > All exports are non-functional stubs. > This is a deprecated Node module. > **This module is pending deprecation.** Once a replacement API has been finalized, this module will be fully deprecated. Most developers should **not** have cause to use this module. Users who absolutely must have the functionality that domains provide may rely on it for the time being but should expect to have to migrate to a different solution in the future. Domains provide a way to handle multiple different IO operations as a single group. If any of the event emitters or callbacks registered to a domain emit an `'error'` event, or throw an error, then the domain object will be notified, rather than losing the context of the error in the `process.on('uncaughtException')` handler, or causing the program to exit immediately with an error code.

node__events.d.ts

Much of the Node.js core API is built around an idiomatic asynchronous event-driven architecture in which certain kinds of objects (called "emitters") emit named events that cause `Function` objects ("listeners") to be called. For instance: a `net.Server` object emits an event each time a peer connects to it; a `fs.ReadStream` emits an event when the file is opened; a `stream` emits an event whenever data is available to be read. All objects that emit events are instances of the `EventEmitter` class. These objects expose an `eventEmitter.on()` function that allows one or more functions to be attached to named events emitted by the object. Typically, event names are camel-cased strings but any valid JavaScript property key can be used. When the `EventEmitter` object emits an event, all of the functions attached to that specific event are called _synchronously_. Any values returned by the called listeners are _ignored_ and discarded. The following example shows a simple `EventEmitter` instance with a single listener. The `eventEmitter.on()` method is used to register listeners, while the `eventEmitter.emit()` method is used to trigger the event. ```js import { EventEmitter } from 'node:events'; class MyEmitter extends EventEmitter {} const myEmitter = new MyEmitter(); myEmitter.on('event', () => { console.log('an event occurred!'); }); myEmitter.emit('event'); ```

node__fs--promises.d.ts

The `fs/promises` API provides asynchronous file system methods that return promises. The promise APIs use the underlying Node.js threadpool to perform file system operations off the event loop thread. These operations are not synchronized or threadsafe. Care must be taken when performing multiple concurrent modifications on the same file or data corruption may occur.

node__fs.d.ts

The `node:fs` module enables interacting with the file system in a way modeled on standard POSIX functions. To use the promise-based APIs: ```js import * as fs from 'node:fs/promises'; ``` To use the callback and sync APIs: ```js import * as fs from 'node:fs'; ``` All file system operations have synchronous, callback, and promise-based forms, and are accessible using both CommonJS syntax and ES6 Modules (ESM).

node__http.d.ts

To use the HTTP server and client one must import the `node:http` module. The HTTP interfaces in Node.js are designed to support many features of the protocol which have been traditionally difficult to use. In particular, large, possibly chunk-encoded, messages. The interface is careful to never buffer entire requests or responses, so the user is able to stream data. HTTP message headers are represented by an object like this: ```json { "content-length": "123", "content-type": "text/plain", "connection": "keep-alive", "host": "example.com", "accept": "*" } ``` Keys are lowercased. Values are not modified. In order to support the full spectrum of possible HTTP applications, the Node.js HTTP API is very low-level. It deals with stream handling and message parsing only. It parses a message into headers and body but it does not parse the actual headers or the body. See `message.headers` for details on how duplicate headers are handled. The raw headers as they were received are retained in the `rawHeaders` property, which is an array of `[key, value, key2, value2, ...]`. For example, the previous message header object might have a `rawHeaders` list like the following: ```js [ 'ConTent-Length', '123456', 'content-LENGTH', '123', 'content-type', 'text/plain', 'CONNECTION', 'keep-alive', 'Host', 'example.com', 'accepT', '*' ] ```

node__http2.d.ts

The `node:http2` module provides an implementation of the [HTTP/2](https://tools.ietf.org/html/rfc7540) protocol. It can be accessed using: ```js import http2 from 'node:http2'; ```

node__https.d.ts

HTTPS is the HTTP protocol over TLS/SSL. In Node.js this is implemented as a separate module.

node__inspector--promises.d.ts

The `node:inspector/promises` module provides an API for interacting with the V8 inspector.

node__inspector.d.ts

> [!WARNING] Deno compatibility > `console` is supported. Other APIs are non-functional stubs. The `node:inspector` module provides an API for interacting with the V8 inspector.

node__module.d.ts

node__net.d.ts

> Stability: 2 - Stable The `node:net` module provides an asynchronous network API for creating stream-based TCP or `IPC` servers (createServer) and clients (createConnection). It can be accessed using: ```js import net from 'node:net'; ```

node__os.d.ts

The `node:os` module provides operating system-related utility methods and properties. It can be accessed using: ```js import os from 'node:os'; ```

node__path.d.ts

The `node:path` module provides utilities for working with file and directory paths. It can be accessed using: ```js import path from 'node:path'; ```

node__perf_hooks.d.ts

This module provides an implementation of a subset of the W3C [Web Performance APIs](https://w3c.github.io/perf-timing-primer/) as well as additional APIs for Node.js-specific performance measurements. Node.js supports the following [Web Performance APIs](https://w3c.github.io/perf-timing-primer/): * [High Resolution Time](https://www.w3.org/TR/hr-time-2) * [Performance Timeline](https://w3c.github.io/performance-timeline/) * [User Timing](https://www.w3.org/TR/user-timing/) * [Resource Timing](https://www.w3.org/TR/resource-timing-2/) ```js import { PerformanceObserver, performance } from 'node:perf_hooks'; const obs = new PerformanceObserver((items) => { console.log(items.getEntries()[0].duration); performance.clearMarks(); }); obs.observe({ type: 'measure' }); performance.measure('Start to Now'); performance.mark('A'); doSomeLongRunningProcess(() => { performance.measure('A to Now', 'A'); performance.mark('B'); performance.measure('A to B', 'A', 'B'); }); ```

node__process.d.ts

node__punycode.d.ts

**The version of the punycode module bundled in Node.js is being deprecated. **In a future major version of Node.js this module will be removed. Users currently depending on the `punycode` module should switch to using the userland-provided [Punycode.js](https://github.com/bestiejs/punycode.js) module instead. For punycode-based URL encoding, see `url.domainToASCII` or, more generally, the `WHATWG URL API`. The `punycode` module is a bundled version of the [Punycode.js](https://github.com/bestiejs/punycode.js) module. It can be accessed using: ```js import punycode from 'node:punycode'; ``` [Punycode](https://tools.ietf.org/html/rfc3492) is a character encoding scheme defined by RFC 3492 that is primarily intended for use in Internationalized Domain Names. Because host names in URLs are limited to ASCII characters only, Domain Names that contain non-ASCII characters must be converted into ASCII using the Punycode scheme. For instance, the Japanese character that translates into the English word, `'example'` is `'例'`. The Internationalized Domain Name, `'例.com'` (equivalent to `'example.com'`) is represented by Punycode as the ASCII string `'xn--fsq.com'`. The `punycode` module provides a simple implementation of the Punycode standard. The `punycode` module is a third-party dependency used by Node.js and made available to developers as a convenience. Fixes or other modifications to the module must be directed to the [Punycode.js](https://github.com/bestiejs/punycode.js) project.

node__querystring.d.ts

The `node:querystring` module provides utilities for parsing and formatting URL query strings. It can be accessed using: ```js import querystring from 'node:querystring'; ``` `querystring` is more performant than `URLSearchParams` but is not a standardized API. Use `URLSearchParams` when performance is not critical or when compatibility with browser code is desirable.

node__readline--promises.d.ts

node__readline.d.ts

The `node:readline` module provides an interface for reading data from a [Readable](https://nodejs.org/docs/latest-v22.x/api/stream.html#readable-streams) stream (such as [`process.stdin`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstdin)) one line at a time. To use the promise-based APIs: ```js import * as readline from 'node:readline/promises'; ``` To use the callback and sync APIs: ```js import * as readline from 'node:readline'; ``` The following simple example illustrates the basic use of the `node:readline` module. ```js import * as readline from 'node:readline/promises'; import { stdin as input, stdout as output } from 'node:process'; const rl = readline.createInterface({ input, output }); const answer = await rl.question('What do you think of Node.js? '); console.log(`Thank you for your valuable feedback: ${answer}`); rl.close(); ``` Once this code is invoked, the Node.js application will not terminate until the `readline.Interface` is closed because the interface waits for data to be received on the `input` stream.

node__repl.d.ts

> [!WARNING] Deno compatibility > All symbols are not supported. The `node:repl` module provides a Read-Eval-Print-Loop (REPL) implementation that is available both as a standalone program or includible in other applications. It can be accessed using: ```js import repl from 'node:repl'; ```

node__sea.d.ts

> [!WARNING] Deno compatibility > All symbols are not supported. This feature allows the distribution of a Node.js application conveniently to a system that does not have Node.js installed. Node.js supports the creation of [single executable applications](https://github.com/nodejs/single-executable) by allowing the injection of a blob prepared by Node.js, which can contain a bundled script, into the `node` binary. During start up, the program checks if anything has been injected. If the blob is found, it executes the script in the blob. Otherwise Node.js operates as it normally does. The single executable application feature currently only supports running a single embedded script using the `CommonJS` module system. Users can create a single executable application from their bundled script with the `node` binary itself and any tool which can inject resources into the binary. Here are the steps for creating a single executable application using one such tool, [postject](https://github.com/nodejs/postject): 1. Create a JavaScript file: ```bash echo 'console.log(`Hello, ${process.argv[2]}!`);' > hello.js ``` 2. Create a configuration file building a blob that can be injected into the single executable application (see `Generating single executable preparation blobs` for details): ```bash echo '{ "main": "hello.js", "output": "sea-prep.blob" }' > sea-config.json ``` 3. Generate the blob to be injected: ```bash node --experimental-sea-config sea-config.json ``` 4. Create a copy of the `node` executable and name it according to your needs: * On systems other than Windows: ```bash cp $(command -v node) hello ``` * On Windows: ```text node -e "require('fs').copyFileSync(process.execPath, 'hello.exe')" ``` The `.exe` extension is necessary. 5. Remove the signature of the binary (macOS and Windows only): * On macOS: ```bash codesign --remove-signature hello ``` * On Windows (optional): [signtool](https://learn.microsoft.com/en-us/windows/win32/seccrypto/signtool) can be used from the installed [Windows SDK](https://developer.microsoft.com/en-us/windows/downloads/windows-sdk/). If this step is skipped, ignore any signature-related warning from postject. ```powershell signtool remove /s hello.exe ``` 6. Inject the blob into the copied binary by running `postject` with the following options: * `hello` / `hello.exe` \- The name of the copy of the `node` executable created in step 4. * `NODE_SEA_BLOB` \- The name of the resource / note / section in the binary where the contents of the blob will be stored. * `sea-prep.blob` \- The name of the blob created in step 1. * `--sentinel-fuse NODE_SEA_FUSE_fce680ab2cc467b6e072b8b5df1996b2` \- The [fuse](https://www.electronjs.org/docs/latest/tutorial/fuses) used by the Node.js project to detect if a file has been injected. * `--macho-segment-name NODE_SEA` (only needed on macOS) - The name of the segment in the binary where the contents of the blob will be stored. To summarize, here is the required command for each platform: * On Linux: ```bash npx postject hello NODE_SEA_BLOB sea-prep.blob \ --sentinel-fuse NODE_SEA_FUSE_fce680ab2cc467b6e072b8b5df1996b2 ``` * On Windows - PowerShell: ```powershell npx postject hello.exe NODE_SEA_BLOB sea-prep.blob ` --sentinel-fuse NODE_SEA_FUSE_fce680ab2cc467b6e072b8b5df1996b2 ``` * On Windows - Command Prompt: ```text npx postject hello.exe NODE_SEA_BLOB sea-prep.blob ^ --sentinel-fuse NODE_SEA_FUSE_fce680ab2cc467b6e072b8b5df1996b2 ``` * On macOS: ```bash npx postject hello NODE_SEA_BLOB sea-prep.blob \ --sentinel-fuse NODE_SEA_FUSE_fce680ab2cc467b6e072b8b5df1996b2 \ --macho-segment-name NODE_SEA ``` 7. Sign the binary (macOS and Windows only): * On macOS: ```bash codesign --sign - hello ``` * On Windows (optional): A certificate needs to be present for this to work. However, the unsigned binary would still be runnable. ```powershell signtool sign /fd SHA256 hello.exe ``` 8. Run the binary: * On systems other than Windows ```console $ ./hello world Hello, world! ``` * On Windows ```console $ .\hello.exe world Hello, world! ```

node__sqlite.d.ts

> [!WARNING] Deno compatibility > This module is not implemented. The `node:sqlite` module facilitates working with SQLite databases. To access it: ```js import sqlite from 'node:sqlite'; ``` This module is only available under the `node:` scheme. The following will not work: ```js import sqlite from 'node:sqlite'; ``` The following example shows the basic usage of the `node:sqlite` module to open an in-memory database, write data to the database, and then read the data back. ```js import { DatabaseSync } from 'node:sqlite'; const database = new DatabaseSync(':memory:'); // Execute SQL statements from strings. database.exec(` CREATE TABLE data( key INTEGER PRIMARY KEY, value TEXT ) STRICT `); // Create a prepared statement to insert data into the database. const insert = database.prepare('INSERT INTO data (key, value) VALUES (?, ?)'); // Execute the prepared statement with bound values. insert.run(1, 'hello'); insert.run(2, 'world'); // Create a prepared statement to read data from the database. const query = database.prepare('SELECT * FROM data ORDER BY key'); // Execute the prepared statement and log the result set. console.log(query.all()); // Prints: [ { key: 1, value: 'hello' }, { key: 2, value: 'world' } ] ```

node__stream--consumers.d.ts

node__stream--promises.d.ts

node__stream--web.d.ts

node__stream.d.ts

A stream is an abstract interface for working with streaming data in Node.js. The `node:stream` module provides an API for implementing the stream interface. There are many stream objects provided by Node.js. For instance, a [request to an HTTP server](https://nodejs.org/docs/latest-v22.x/api/http.html#class-httpincomingmessage) and [`process.stdout`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstdout) are both stream instances. Streams can be readable, writable, or both. All streams are instances of [`EventEmitter`](https://nodejs.org/docs/latest-v22.x/api/events.html#class-eventemitter). To access the `node:stream` module: ```js import stream from 'node:stream'; ``` The `node:stream` module is useful for creating new types of stream instances. It is usually not necessary to use the `node:stream` module to consume streams.

node__string_decoder.d.ts

The `node:string_decoder` module provides an API for decoding `Buffer` objects into strings in a manner that preserves encoded multi-byte UTF-8 and UTF-16 characters. It can be accessed using: ```js import { StringDecoder } from 'node:string_decoder'; ``` The following example shows the basic use of the `StringDecoder` class. ```js import { StringDecoder } from 'node:string_decoder'; const decoder = new StringDecoder('utf8'); const cent = Buffer.from([0xC2, 0xA2]); console.log(decoder.write(cent)); // Prints: ¢ const euro = Buffer.from([0xE2, 0x82, 0xAC]); console.log(decoder.write(euro)); // Prints: € ``` When a `Buffer` instance is written to the `StringDecoder` instance, an internal buffer is used to ensure that the decoded string does not contain any incomplete multibyte characters. These are held in the buffer until the next call to `stringDecoder.write()` or until `stringDecoder.end()` is called. In the following example, the three UTF-8 encoded bytes of the European Euro symbol (`€`) are written over three separate operations: ```js import { StringDecoder } from 'node:string_decoder'; const decoder = new StringDecoder('utf8'); decoder.write(Buffer.from([0xE2])); decoder.write(Buffer.from([0x82])); console.log(decoder.end(Buffer.from([0xAC]))); // Prints: € ```

node__test--reporters.d.ts

The `node:test/reporters` module exposes the builtin-reporters for `node:test`. To access it: ```js import test from 'node:test/reporters'; ``` This module is only available under the `node:` scheme. The following will not work: ```js import test from 'node:test/reporters'; ```

node__timers--promises.d.ts

The `timers/promises` API provides an alternative set of timer functions that return `Promise` objects. The API is accessible via `import timersPromises from 'node:timers/promises'`. ```js import { setTimeout, setImmediate, setInterval, } from 'node:timers/promises'; ```

node__timers.d.ts

The `timer` module exposes a global API for scheduling functions to be called at some future period of time. Because the timer functions are globals, there is no need to import `node:timers` to use the API. The timer functions within Node.js implement a similar API as the timers API provided by Web Browsers but use a different internal implementation that is built around the Node.js [Event Loop](https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#setimmediate-vs-settimeout).

node__tls.d.ts

The `node:tls` module provides an implementation of the Transport Layer Security (TLS) and Secure Socket Layer (SSL) protocols that is built on top of OpenSSL. The module can be accessed using: ```js import tls from 'node:tls'; ```

node__trace_events.d.ts

> [!WARNING] Deno compatibility > All exports are non-functional stubs. The `node:trace_events` module provides a mechanism to centralize tracing information generated by V8, Node.js core, and userspace code. Tracing can be enabled with the `--trace-event-categories` command-line flag or by using the `trace_events` module. The `--trace-event-categories` flag accepts a list of comma-separated category names. The available categories are: * `node`: An empty placeholder. * `node.async_hooks`: Enables capture of detailed [`async_hooks`](https://nodejs.org/docs/latest-v22.x/api/async_hooks.html) trace data. The [`async_hooks`](https://nodejs.org/docs/latest-v22.x/api/async_hooks.html) events have a unique `asyncId` and a special `triggerId` `triggerAsyncId` property. * `node.bootstrap`: Enables capture of Node.js bootstrap milestones. * `node.console`: Enables capture of `console.time()` and `console.count()` output. * `node.threadpoolwork.sync`: Enables capture of trace data for threadpool synchronous operations, such as `blob`, `zlib`, `crypto` and `node_api`. * `node.threadpoolwork.async`: Enables capture of trace data for threadpool asynchronous operations, such as `blob`, `zlib`, `crypto` and `node_api`. * `node.dns.native`: Enables capture of trace data for DNS queries. * `node.net.native`: Enables capture of trace data for network. * `node.environment`: Enables capture of Node.js Environment milestones. * `node.fs.sync`: Enables capture of trace data for file system sync methods. * `node.fs_dir.sync`: Enables capture of trace data for file system sync directory methods. * `node.fs.async`: Enables capture of trace data for file system async methods. * `node.fs_dir.async`: Enables capture of trace data for file system async directory methods. * `node.perf`: Enables capture of [Performance API](https://nodejs.org/docs/latest-v22.x/api/perf_hooks.html) measurements. * `node.perf.usertiming`: Enables capture of only Performance API User Timing measures and marks. * `node.perf.timerify`: Enables capture of only Performance API timerify measurements. * `node.promises.rejections`: Enables capture of trace data tracking the number of unhandled Promise rejections and handled-after-rejections. * `node.vm.script`: Enables capture of trace data for the `node:vm` module's `runInNewContext()`, `runInContext()`, and `runInThisContext()` methods. * `v8`: The [V8](https://nodejs.org/docs/latest-v22.x/api/v8.html) events are GC, compiling, and execution related. * `node.http`: Enables capture of trace data for http request / response. By default the `node`, `node.async_hooks`, and `v8` categories are enabled. ```bash node --trace-event-categories v8,node,node.async_hooks server.js ``` Prior versions of Node.js required the use of the `--trace-events-enabled` flag to enable trace events. This requirement has been removed. However, the `--trace-events-enabled` flag _may_ still be used and will enable the `node`, `node.async_hooks`, and `v8` trace event categories by default. ```bash node --trace-events-enabled node --trace-event-categories v8,node,node.async_hooks ``` Alternatively, trace events may be enabled using the `node:trace_events` module: ```js import trace_events from 'node:trace_events'; const tracing = trace_events.createTracing({ categories: ['node.perf'] }); tracing.enable(); // Enable trace event capture for the 'node.perf' category // do work tracing.disable(); // Disable trace event capture for the 'node.perf' category ``` Running Node.js with tracing enabled will produce log files that can be opened in the [`chrome://tracing`](https://www.chromium.org/developers/how-tos/trace-event-profiling-tool) tab of Chrome. The logging file is by default called `node_trace.${rotation}.log`, where `${rotation}` is an incrementing log-rotation id. The filepath pattern can be specified with `--trace-event-file-pattern` that accepts a template string that supports `${rotation}` and `${pid}`: ```bash node --trace-event-categories v8 --trace-event-file-pattern '${pid}-${rotation}.log' server.js ``` To guarantee that the log file is properly generated after signal events like `SIGINT`, `SIGTERM`, or `SIGBREAK`, make sure to have the appropriate handlers in your code, such as: ```js process.on('SIGINT', function onSigint() { console.info('Received SIGINT.'); process.exit(130); // Or applicable exit code depending on OS and signal }); ``` The tracing system uses the same time source as the one used by `process.hrtime()`. However the trace-event timestamps are expressed in microseconds, unlike `process.hrtime()` which returns nanoseconds. The features from this module are not available in [`Worker`](https://nodejs.org/docs/latest-v22.x/api/worker_threads.html#class-worker) threads.

node__tty.d.ts

The `node:tty` module provides the `tty.ReadStream` and `tty.WriteStream` classes. In most cases, it will not be necessary or possible to use this module directly. However, it can be accessed using: ```js import tty from 'node:tty'; ``` When Node.js detects that it is being run with a text terminal ("TTY") attached, `process.stdin` will, by default, be initialized as an instance of `tty.ReadStream` and both `process.stdout` and `process.stderr` will, by default, be instances of `tty.WriteStream`. The preferred method of determining whether Node.js is being run within a TTY context is to check that the value of the `process.stdout.isTTY` property is `true`: ```console $ node -p -e "Boolean(process.stdout.isTTY)" true $ node -p -e "Boolean(process.stdout.isTTY)" | cat false ``` In most cases, there should be little to no reason for an application to manually create instances of the `tty.ReadStream` and `tty.WriteStream` classes.

node__url.d.ts

The `node:url` module provides utilities for URL resolution and parsing. It can be accessed using: ```js import url from 'node:url'; ```

node__util--types.d.ts

node__util.d.ts

The `node:util` module supports the needs of Node.js internal APIs. Many of the utilities are useful for application and module developers as well. To access it: ```js import util from 'node:util'; ```

node__v8.d.ts

> [!WARNING] Deno compatibility > `cachedDataVersionTag` and `getHeapStatistics`, `serialize` and `deserialize` are supported. > `setFlagsFromStrings` is a noop. > Other APIs are not supported and will throw and error. > The `node:v8` module exposes APIs that are specific to the version of [V8](https://developers.google.com/v8/) built into the Node.js binary. It can be accessed using: ```js import v8 from 'node:v8'; ```

node__vm.d.ts

The `node:vm` module enables compiling and running code within V8 Virtual Machine contexts. **The `node:vm` module is not a security** **mechanism. Do not use it to run untrusted code.** JavaScript code can be compiled and run immediately or compiled, saved, and run later. A common use case is to run the code in a different V8 Context. This means invoked code has a different global object than the invoking code. One can provide the context by `contextifying` an object. The invoked code treats any property in the context like a global variable. Any changes to global variables caused by the invoked code are reflected in the context object. ```js import vm from 'node:vm'; const x = 1; const context = { x: 2 }; vm.createContext(context); // Contextify the object. const code = 'x += 40; var y = 17;'; // `x` and `y` are global variables in the context. // Initially, x has the value 2 because that is the value of context.x. vm.runInContext(code, context); console.log(context.x); // 42 console.log(context.y); // 17 console.log(x); // 1; y is not defined. ```

node__wasi.d.ts

> [!WARNING] Deno compatibility > All exports are non-functional stubs. **The `node:wasi` module does not currently provide the** **comprehensive file system security properties provided by some WASI runtimes.** **Full support for secure file system sandboxing may or may not be implemented in** **future. In the mean time, do not rely on it to run untrusted code.** The WASI API provides an implementation of the [WebAssembly System Interface](https://wasi.dev/) specification. WASI gives WebAssembly applications access to the underlying operating system via a collection of POSIX-like functions. ```js import { readFile } from 'node:fs/promises'; import { WASI } from 'node:wasi'; import { argv, env } from 'node:process'; const wasi = new WASI({ version: 'preview1', args: argv, env, preopens: { '/local': '/some/real/path/that/wasm/can/access', }, }); const wasm = await WebAssembly.compile( await readFile(new URL('./demo.wasm', import.meta.url)), ); const instance = await WebAssembly.instantiate(wasm, wasi.getImportObject()); wasi.start(instance); ``` To run the above example, create a new WebAssembly text format file named `demo.wat`: ```text (module ;; Import the required fd_write WASI function which will write the given io vectors to stdout ;; The function signature for fd_write is: ;; (File Descriptor, *iovs, iovs_len, nwritten) -> Returns number of bytes written (import "wasi_snapshot_preview1" "fd_write" (func $fd_write (param i32 i32 i32 i32) (result i32))) (memory 1) (export "memory" (memory 0)) ;; Write 'hello world\n' to memory at an offset of 8 bytes ;; Note the trailing newline which is required for the text to appear (data (i32.const 8) "hello world\n") (func $main (export "_start") ;; Creating a new io vector within linear memory (i32.store (i32.const 0) (i32.const 8)) ;; iov.iov_base - This is a pointer to the start of the 'hello world\n' string (i32.store (i32.const 4) (i32.const 12)) ;; iov.iov_len - The length of the 'hello world\n' string (call $fd_write (i32.const 1) ;; file_descriptor - 1 for stdout (i32.const 0) ;; *iovs - The pointer to the iov array, which is stored at memory location 0 (i32.const 1) ;; iovs_len - We're printing 1 string stored in an iov - so one. (i32.const 20) ;; nwritten - A place in memory to store the number of bytes written ) drop ;; Discard the number of bytes written from the top of the stack ) ) ``` Use [wabt](https://github.com/WebAssembly/wabt) to compile `.wat` to `.wasm` ```bash wat2wasm demo.wat ```

node__worker_threads.d.ts

The `node:worker_threads` module enables the use of threads that execute JavaScript in parallel. To access it: ```js import worker from 'node:worker_threads'; ``` Workers (threads) are useful for performing CPU-intensive JavaScript operations. They do not help much with I/O-intensive work. The Node.js built-in asynchronous I/O operations are more efficient than Workers can be. Unlike `child_process` or `cluster`, `worker_threads` can share memory. They do so by transferring `ArrayBuffer` instances or sharing `SharedArrayBuffer` instances. ```js import { Worker, isMainThread, parentPort, workerData, } from 'node:worker_threads'; import { parse } from 'some-js-parsing-library'; if (isMainThread) { module.exports = function parseJSAsync(script) { return new Promise((resolve, reject) => { const worker = new Worker(__filename, { workerData: script, }); worker.on('message', resolve); worker.on('error', reject); worker.on('exit', (code) => { if (code !== 0) reject(new Error(`Worker stopped with exit code ${code}`)); }); }); }; } else { const script = workerData; parentPort.postMessage(parse(script)); } ``` The above example spawns a Worker thread for each `parseJSAsync()` call. In practice, use a pool of Workers for these kinds of tasks. Otherwise, the overhead of creating Workers would likely exceed their benefit. When implementing a worker pool, use the `AsyncResource` API to inform diagnostic tools (e.g. to provide asynchronous stack traces) about the correlation between tasks and their outcomes. See `"Using AsyncResource for a Worker thread pool"` in the `async_hooks` documentation for an example implementation. Worker threads inherit non-process-specific options by default. Refer to `Worker constructor options` to know how to customize worker thread options, specifically `argv` and `execArgv` options.

node__zlib.d.ts

The `node:zlib` module provides compression functionality implemented using Gzip, Deflate/Inflate, and Brotli. To access it: ```js import zlib from 'node:zlib'; ``` Compression and decompression are built around the Node.js [Streams API](https://nodejs.org/docs/latest-v22.x/api/stream.html). Compressing or decompressing a stream (such as a file) can be accomplished by piping the source stream through a `zlib` `Transform` stream into a destination stream: ```js import { createGzip } from 'node:zlib'; import { pipeline } from 'node:stream'; import { createReadStream, createWriteStream, } from 'node:fs'; const gzip = createGzip(); const source = createReadStream('input.txt'); const destination = createWriteStream('input.txt.gz'); pipeline(source, gzip, destination, (err) => { if (err) { console.error('An error occurred:', err); process.exitCode = 1; } }); // Or, Promisified import { promisify } from 'node:util'; const pipe = promisify(pipeline); async function do_gzip(input, output) { const gzip = createGzip(); const source = createReadStream(input); const destination = createWriteStream(output); await pipe(source, gzip, destination); } do_gzip('input.txt', 'input.txt.gz') .catch((err) => { console.error('An error occurred:', err); process.exitCode = 1; }); ``` It is also possible to compress or decompress data in a single step: ```js import { deflate, unzip } from 'node:zlib'; const input = '.................................'; deflate(input, (err, buffer) => { if (err) { console.error('An error occurred:', err); process.exitCode = 1; } console.log(buffer.toString('base64')); }); const buffer = Buffer.from('eJzT0yMAAGTvBe8=', 'base64'); unzip(buffer, (err, buffer) => { if (err) { console.error('An error occurred:', err); process.exitCode = 1; } console.log(buffer.toString()); }); // Or, Promisified import { promisify } from 'node:util'; const do_unzip = promisify(unzip); do_unzip(buffer) .then((buf) => console.log(buf.toString())) .catch((err) => { console.error('An error occurred:', err); process.exitCode = 1; }); ```