Node.js

https://nodejs.org/docs/latest-v22.x/api/
Admin
Node.js is a JavaScript runtime built on Chrome's V8 JavaScript engine that enables developers to...
Tokens:3,028,268
Snippets:15,342
Trust Score:10
Update:17 hours ago
Show doc for...
Tokens:
Raw
### Output from starting the server

Source: https://nodejs.org/docs/latest-v22.x/api/async_hooks.html

Sample output from the async_hooks example when the server starts. It shows the sequence of init, before, after, and destroy events, and the execution context IDs.

```console
TCPSERVERWRAP(5): trigger: 1 execution: 1
TickObject(6): trigger: 5 execution: 1
before:  6
  Timeout(7): trigger: 6 execution: 6
after:   6
destroy: 6
before:  7
>>> 7
  TickObject(8): trigger: 7 execution: 7
after:   7
before:  8
after:   8
```

--------------------------------

### Start Node.js REPL and execute JavaScript

Source: https://nodejs.org/docs/latest-v22.x/api/repl.html

Shows how to start the Node.js REPL by running the `node` command without arguments. The example demonstrates defining an array, accessing it, and using `forEach` to print each element.

```console
$ node
> const a = [1, 2, 3];
undefined
> a
[ 1, 2, 3 ]
> a.forEach((v) => {
...   console.log(v);
...   });
1
2
3
```

--------------------------------

### Enabling promise execution tracking with createHook

Source: https://nodejs.org/docs/latest-v22.x/api/async_hooks.html

Installing async hooks via createHook enables promise execution tracking. The example shows that after enabling, the then() callback gets eid 7 and tid 6, with the first promise getting asyncId 6 and the second 7.

```javascript
import { createHook, executionAsyncId, triggerAsyncId } from 'node:async_hooks';
createHook({ init() {} }).enable(); // forces PromiseHooks to be enabled.
Promise.resolve(1729).then(() => {
  console.log(`eid ${executionAsyncId()} tid ${triggerAsyncId()}`);
});
// produces:
// eid 7 tid 6
```

```javascript
const { createHook, executionAsyncId, triggerAsyncId } = require('node:async_hooks');

createHook({ init() {} }).enable(); // forces PromiseHooks to be enabled.
Promise.resolve(1729).then(() => {
  console.log(`eid ${executionAsyncId()} tid ${triggerAsyncId()}`);
});
// produces:
// eid 7 tid 6
```

--------------------------------

### repl.start([options])

Source: https://nodejs.org/docs/latest-v22.x/api/repl.html

Creates and starts a repl.REPLServer instance. The options parameter can be a string specifying the input prompt, or an object with various configuration options.

```APIDOC
## repl.start([options])

### Description
Creates and starts a `repl.REPLServer` instance. If `options` is a string, it specifies the input prompt.

### Method
start

### Endpoint
repl.start([options])

### Parameters
#### Options
- **options** (Object | string) - Optional - Configuration options or a string prompt.
  - **prompt** (string) - Optional - The input prompt to display. Default: `'> '` (with a trailing space).
  - **input** (stream.Readable) - Optional - The `Readable` stream from which REPL input will be read. Default: `process.stdin`.
  - **output** (stream.Writable) - Optional - The `Writable` stream to which REPL output will be written. Default: `process.stdout`.
  - **terminal** (boolean) - Optional - If `true`, specifies that the `output` should be treated as a TTY terminal. Default: checking the value of the `isTTY` property on the `output` stream upon instantiation.
  - **eval** (Function) - Optional - The function to be used when evaluating each given line of input. Default: an async wrapper for the JavaScript `eval()` function. An `eval` function can error with `repl.Recoverable` to indicate the input was incomplete and prompt for additional lines.
  - **useColors** (boolean) - Optional - If `true`, specifies that the default `writer` function should include ANSI color styling to REPL output. If a custom `writer` function is provided then this has no effect. Default: checking color support on the `output` stream if the REPL instance's `terminal` value is `true`.
  - **useGlobal** (boolean) - Optional - If `true`, specifies that the default evaluation function will use the JavaScript `global` as the context as opposed to creating a new separate context for the REPL instance. The node CLI REPL sets this value to `true`. Default: `false`.
  - **ignoreUndefined** (boolean) - Optional - If `true`, specifies that the default writer will not output the return value of a command if it evaluates to `undefined`. Default: `false`.
  - **writer** (Function) - Optional - The function to invoke to format the output of each command before writing to `output`. Default: [`util.inspect()`](https://nodejs.org/docs/latest-v22.x/api/util.html#utilinspectobject-options).
  - **completer** (Function) - Optional - An optional function used for custom Tab auto completion. See [`readline.InterfaceCompleter`](https://nodejs.org/docs/latest-v22.x/api/readline.html#use-of-the-completer-function) for an example.
  - **replMode** (symbol) - Optional - A flag that specifies whether the default evaluator executes all JavaScript commands in strict mode or default (sloppy) mode. Acceptable values are:
    - `repl.REPL_MODE_SLOPPY` to evaluate expressions in sloppy mode.
    - `repl.REPL_MODE_STRICT` to evaluate expressions in strict mode. This is equivalent to prefacing every repl statement with `'use strict'`.
  - **breakEvalOnSigint** (boolean) - Optional - Stop evaluating the current piece of code when `SIGINT` is received, such as when Ctrl+C is pressed. This cannot be used together with a custom `eval` function. Default: `false`.
  - **preview** (boolean) - Optional - Defines if the repl prints autocomplete and output previews or not. Default: `true` with the default eval function and `false` in case a custom eval function is used. If `terminal` is falsy, then there are no previews and the value of `preview` has no effect.

### Returns
- **repl.REPLServer** - The created REPLServer instance.

### Request Example
```js
import repl from 'node:repl';

// a Unix style prompt
repl.start('$ ');
```

```js
const repl = require('node:repl');

// a Unix style prompt
repl.start('$ ');
```
```

--------------------------------

### Create REPLServer instances with repl.start and new

Source: https://nodejs.org/docs/latest-v22.x/api/repl.html

Shows two ways to create a REPLServer instance: using `repl.start()` and using the `new` keyword. Both use the `useColors` option.

```js
import repl from 'node:repl';

const options = { useColors: true };

const firstInstance = repl.start(options);
const secondInstance = new repl.REPLServer(options);
```

```js
const repl = require('node:repl');

const options = { useColors: true };

const firstInstance = repl.start(options);
const secondInstance = new repl.REPLServer(options);
```

--------------------------------

### eventLoopUtilization() example with CommonJS require

Source: https://nodejs.org/docs/latest-v22.x/api/perf_hooks.html

Shows how to use eventLoopUtilization() with CommonJS require. The example uses setImmediate to run after the event loop starts, then calls eventLoopUtilization() to get a baseline, blocks with spawnSync('sleep', ['5']), and logs the utilization. The utilization is 1 because spawnSync blocks the event loop.

```javascript
'use strict';
const { eventLoopUtilization } = require('node:perf_hooks').performance;
const { spawnSync } = require('node:child_process');

setImmediate(() => {
  const elu = eventLoopUtilization();
  spawnSync('sleep', ['5']);
  console.log(eventLoopUtilization(elu).utilization);
});
```

--------------------------------

### eventLoopUtilization() example with ESM imports

Source: https://nodejs.org/docs/latest-v22.x/api/perf_hooks.html

Shows how to use eventLoopUtilization() with ESM imports. The example uses setImmediate to run after the event loop starts, then calls eventLoopUtilization() to get a baseline, blocks with spawnSync('sleep', ['5']), and logs the utilization. The utilization is 1 because spawnSync blocks the event loop.

```javascript
import { eventLoopUtilization } from 'node:perf_hooks';
import { spawnSync } from 'node:child_process';

setImmediate(() => {
  const elu = eventLoopUtilization();
  spawnSync('sleep', ['5']);
  console.log(eventLoopUtilization(elu).utilization);
});
```

--------------------------------

### addon.cc - Initialize addon and export MyObject

Source: https://nodejs.org/docs/latest-v22.x/api/addons.html

Entry point for the addon. Includes node.h and myobject.h, initializes MyObject via MyObject::Init, and registers the module with NODE_MODULE.

```cpp
// addon.cc
#include <node.h>
#include "myobject.h"

namespace demo {

using v8::Local;
using v8::Object;

void InitAll(Local<Object> exports) {
  MyObject::Init(exports);
}

NODE_MODULE(NODE_GYP_MODULE_NAME, InitAll)

}  // namespace demo
```

--------------------------------

### Set up per-process state in main()

Source: https://nodejs.org/docs/latest-v22.x/api/embedding.html

Initializes Node.js per-process state: parses CLI options, creates a v8::Platform via MultiIsolatePlatform::Create(4), and initializes V8. Uses flags kNoInitializeV8 and kNoInitializeNodeV8Platform to defer V8 initialization. Prints parsing errors and returns early if needed. Must be followed by RunNodeInstance and cleanup calls.

```cpp
int main(int argc, char** argv) {
  argv = uv_setup_args(argc, argv);
  std::vector<std::string> args(argv, argv + argc);
  // Parse Node.js CLI options, and print any errors that have occurred while
  // trying to parse them.
  std::unique_ptr<node::InitializationResult> result =
      node::InitializeOncePerProcess(args, {
        node::ProcessInitializationFlags::kNoInitializeV8,
        node::ProcessInitializationFlags::kNoInitializeNodeV8Platform
      });

  for (const std::string& error : result->errors())
    fprintf(stderr, "%s: %s\n", args[0].c_str(), error.c_str());
  if (result->early_return() != 0) {
    return result->exit_code();
  }

  // Create a v8::Platform instance. `MultiIsolatePlatform::Create()` is a way
  // to create a v8::Platform instance that Node.js can use when creating
  // Worker threads. When no `MultiIsolatePlatform` instance is present,
  // Worker threads are disabled.
  std::unique_ptr<MultiIsolatePlatform> platform =
      MultiIsolatePlatform::Create(4);
  V8::InitializePlatform(platform.get());
  V8::Initialize();

  // See below for the contents of this function.
  int ret = RunNodeInstance(
      platform.get(), result->args(), result->exec_args());

  V8::Dispose();
  V8::DisposePlatform();

  node::TearDownOncePerProcess();
  return ret;
}
```

--------------------------------

### console.timeEnd example

Source: https://nodejs.org/docs/latest-v22.x/api/all.html

Stops a timer started with console.time and prints the elapsed time to stdout. The example shows the output format 'bunch-of-stuff: 225.438ms'.

```javascript
console.time('bunch-of-stuff');
// Do a bunch of stuff.
console.timeEnd('bunch-of-stuff');
// Prints: bunch-of-stuff: 225.438ms
```

--------------------------------

### repl.start([options])

Source: https://nodejs.org/docs/latest-v22.x/api/repl.html

Starts a Node.js REPL instance with the provided options. The options parameter is optional and can include settings like preview, terminal, useColors, breakEvalOnSigint, and replMode.

```APIDOC
## repl.start([options])

### Description
Starts a Node.js REPL instance with the provided options. The options parameter is optional and can include settings like preview, terminal, useColors, breakEvalOnSigint, and replMode.

### Method
start

### Endpoint
repl.start([options])

### Parameters
#### Options
- **preview** (boolean) - Optional - Enables preview mode.
- **terminal** (boolean) - Optional - Determines if the REPL is terminal-based.
- **useColors** (boolean) - Optional - Determines if colors are used, checks hasColors() if available.
- **breakEvalOnSigint** (boolean) - Optional - Breaks evaluation on SIGINT.
- **replMode** (string) - Optional - The REPL mode (REPL_MAGIC_MODE was removed in v10.0.0).

### History
- v13.4.0, v12.17.0: The `preview` option is now available.
- v12.0.0: The `terminal` option now follows the default description in all cases and `useColors` checks `hasColors()` if available.
- v10.0.0: The `REPL_MAGIC_MODE` `replMode` was removed.
- v6.3.0: The `breakEvalOnSigint` option is supported now.
- v5.8.0: The `options` parameter is optional now.
- v0.1.91: Added in: v0.1.91.
```

--------------------------------

### getSystemErrorMessage example

Source: https://nodejs.org/docs/latest-v22.x/api/util.html

Uses util.getSystemErrorMessage to get the string message for a numeric error code. The example shows 'No such file or directory' for a missing file.

```javascript
fs.access('file/that/does/not/exist', (err) => {
  const message = util.getSystemErrorMessage(err.errno);
  console.error(message);  // No such file or directory
});
```

--------------------------------

### getSystemErrorName example

Source: https://nodejs.org/docs/latest-v22.x/api/util.html

Uses util.getSystemErrorName to get the string name for a numeric error code from a Node.js API. In this example, accessing a non-existent file yields 'ENOENT'.

```javascript
fs.access('file/that/does/not/exist', (err) => {
  const name = util.getSystemErrorName(err.errno);
  console.error(name);  // ENOENT
});
```

--------------------------------

### Build addon with node-gyp

Source: https://nodejs.org/docs/latest-v22.x/api/addons.html

Command to configure and build the example addons using node-gyp after binding.gyp is ready.

```bash
node-gyp configure build copy
```

--------------------------------

### entry.js using v8.startupSnapshot hooks

Source: https://nodejs.org/docs/latest-v22.x/api/v8.html

Example script that uses v8.startupSnapshot to compress books during serialization and decompress during deserialization, then prints a book based on environment and arguments.

```js
'use strict';

const fs = require('node:fs');
const zlib = require('node:zlib');
const path = require('node:path');
const assert = require('node:assert');

const v8 = require('node:v8');

class BookShelf {
  storage = new Map();

  // Reading a series of files from directory and store them into storage.
  constructor(directory, books) {
    for (const book of books) {
      this.storage.set(book, fs.readFileSync(path.join(directory, book)));
    }
  }

  static compressAll(shelf) {
    for (const [ book, content ] of shelf.storage) {
      shelf.storage.set(book, zlib.gzipSync(content));
    }
  }

  static decompressAll(shelf) {
    for (const [ book, content ] of shelf.storage) {
      shelf.storage.set(book, zlib.gunzipSync(content));
    }
  }
}

// __dirname here is where the snapshot script is placed
// during snapshot building time.
const shelf = new BookShelf(__dirname, [
  'book1.en_US.txt',
  'book1.es_ES.txt',
  'book2.zh_CN.txt',
]);

assert(v8.startupSnapshot.isBuildingSnapshot());
// On snapshot serialization, compress the books to reduce size.
v8.startupSnapshot.addSerializeCallback(BookShelf.compressAll, shelf);
// On snapshot deserialization, decompress the books.
v8.startupSnapshot.addDeserializeCallback(BookShelf.decompressAll, shelf);
v8.startupSnapshot.setDeserializeMainFunction((shelf) => {
  // process.env and process.argv are refreshed during snapshot
  // deserialization.
  const lang = process.env.BOOK_LANG || 'en_US';
  const book = process.argv[1];
  const name = `${book}.${lang}.txt`;
  console.log(shelf.storage.get(name));
}, shelf); copy
```

--------------------------------

### Comments example

Source: https://nodejs.org/docs/latest-v22.x/api/environment_variables.html

Shows how hash-tags start comments, except when inside quotes.

```text
# This is a comment
MY_VAR = my variable # This is also a comment
MY_VAR_A = "# this is NOT a comment"
```

--------------------------------

### Start a REPL with a Unix-style prompt using node:repl

Source: https://nodejs.org/docs/latest-v22.x/api/all.html

Starts a REPL with a custom prompt. The example uses the ESM import syntax and the CommonJS require syntax. The prompt is set to '$ '.

```javascript
import repl from 'node:repl';

// a Unix style prompt
repl.start('$ ');
```

```javascript
const repl = require('node:repl');

// a Unix style prompt
repl.start('$ ');
```

--------------------------------

### Workaround: call socket.resume() to start data flow

Source: https://nodejs.org/docs/latest-v22.x/api/stream.html

This example fixes the broken case by calling socket.resume() to start the flow of data, discarding it. This allows the 'end' event to fire and the server to respond.

```javascript
// Workaround.
net.createServer((socket) => {
  socket.on('end', () => {
    socket.end('The message was received but was not processed.\n');
  });

  // Start the flow of data, discarding it.
  socket.resume();
}).listen(1337);
```

--------------------------------

### Command-line example for process.execArgv

Source: https://nodejs.org/docs/latest-v22.x/api/process.html

Shows a bash command that launches Node.js with specific options. The output demonstrates the resulting process.execArgv and process.argv arrays.

```bash
node --icu-data-dir=./foo --require ./bar.js script.js --version
```

```json
["--icu-data-dir=./foo", "--require", "./bar.js"]
```

```js
['/usr/local/bin/node', 'script.js', '--version']
```

--------------------------------

### server.listen(options[, callback])

Source: https://nodejs.org/docs/latest-v22.x/api/net.html

Starts a server listening for connections using the specified options. If port is specified, it behaves like server.listen(port, host, backlog, callback); if path is specified, it behaves like server.listen(path, backlog, callback). If neither is specified, an error is thrown.

```APIDOC
## server.listen(options[, callback])

### Description
Starts a server listening for connections using the specified options. If `port` is specified, it behaves the same as `server.listen([port[, host[, backlog]]][, callback])`. Otherwise, if `path` is specified, it behaves the same as `server.listen(path[, backlog][, callback])`. If none of them is specified, an error will be thrown.

### Method
listen

### Signature
`server.listen(options[, callback])`

### Parameters
#### Options Object
- **backlog** (number) - Optional - Common parameter of `server.listen()` functions.
- **exclusive** (boolean) - Optional - Default: `false`. If `false`, cluster workers will use the same underlying handle, allowing connection handling duties to be shared. If `true`, the handle is not shared, and attempted port sharing results in an error.
- **host** (string) - Optional - The host name or IP address to bind to.
- **ipv6Only** (boolean) - Optional - Default: `false`. For TCP servers, setting `ipv6Only` to `true` will disable dual-stack support, i.e., binding to host `::` won't make `0.0.0.0` be bound.
- **reusePort** (boolean) - Optional - Default: `false`. For TCP servers, setting `reusePort` to `true` allows multiple sockets on the same host to bind to the same port. Incoming connections are distributed by the operating system to listening sockets. Available only on some platforms (Linux 3.9+, DragonFlyBSD 3.6+, FreeBSD 12.0+, Solaris 11.4, AIX 7.2.5+). On unsupported platforms, this option raises an error.
- **path** (string) - Optional - Will be ignored if `port` is specified. See Identifying paths for IPC connections.
- **port** (number) - Optional - The port number to bind to.
- **readableAll** (boolean) - Optional - Default: `false`. For IPC servers makes the pipe readable for all users.
- **signal** (AbortSignal) - Optional - An AbortSignal that may be used to close a listening server.
- **writableAll** (boolean) - Optional - Default: `false`. For IPC servers makes the pipe writable for all users.

#### Callback
- **callback** (Function) - Optional - A callback function that is called when the server is listening.

### Returns
- **net.Server** - The server instance.

### Behavior Details
- If `exclusive` is `false` (default), cluster workers will use the same underlying handle, allowing connection handling duties to be shared. When `exclusive` is `true`, the handle is not shared, and attempted port sharing results in an error.
- When `exclusive` is `true` and the underlying handle is shared, it is possible that several workers query a handle with different backlogs. In this case, the first `backlog` passed to the master process will be used.
- Starting an IPC server as root may cause the server path to be inaccessible for unprivileged users. Using `readableAll` and `writableAll` will make the server accessible for all users.
- If the `signal` option is enabled, calling `.abort()` on the corresponding `AbortController` is similar to calling `.close()` on the server.

### Examples
#### Example 1: Listening on an exclusive port
```js
server.listen({
  host: 'localhost',
  port: 80,
  exclusive: true,
});
```

#### Example 2: Using AbortSignal to close the server
```js
const controller = new AbortController();
server.listen({
  host: 'localhost',
  port: 80,
  signal: controller.signal,
});
// Later, when you want to close the server.
controller.abort();
```

### History
| Version | Changes |
| --- | --- |
| v22.12.0 | The `reusePort` option is supported. |
| v15.6.0 | AbortSignal support was added. |
| v11.4.0 | The `ipv6Only` option is supported. |
| v0.11.14 | Added in: v0.11.14. |
```

--------------------------------

### streamConsumers.blob() example (ESM and CommonJS)

Source: https://nodejs.org/docs/latest-v22.x/api/webstreams.html

Consumes a ReadableStream and fulfills with a Blob containing the full contents. The example creates a Blob, gets its stream, and logs the size. Both ESM and CommonJS versions are shown.

```javascript
import { blob } from 'node:stream/consumers';

const dataBlob = new Blob(['hello world from consumers!']);

const readable = dataBlob.stream();
const data = await blob(readable);
console.log(`from readable: ${data.size}`);
// Prints: from readable: 27
```

```javascript
const { blob } = require('node:stream/consumers');

const dataBlob = new Blob(['hello world from consumers!']);

const readable = dataBlob.stream();
blob(readable).then((data) => {
  console.log(`from readable: ${data.size}`);
  // Prints: from readable: 27
});
```

--------------------------------

### Example: Adding a method 'hello'

Source: https://nodejs.org/docs/latest-v22.x/api/all.html

Example of an Init function that defines a method 'hello' on the exports object using napi_define_properties.

```APIDOC
## Example: Adding a method 'hello'

### Description
Shows how to define a method 'hello' on the exports object so it can be called as a method provided by the addon.

### Code
```c
napi_value Init(napi_env env, napi_value exports) {
  napi_status status;
  napi_property_descriptor desc = {
    "hello",
    NULL,
    Method,
    NULL,
    NULL,
    NULL,
    napi_writable | napi_enumerable | napi_configurable,
    NULL
  };
  status = napi_define_properties(env, exports, 1, &desc);
  if (status != napi_ok) return NULL;
  return exports;
}
```
```

--------------------------------

### Get and set mime.subtype

Source: https://nodejs.org/docs/latest-v22.x/api/util.html

Demonstrates getting and setting the subtype portion of a MIME. The example creates a MIMEType for 'text/ecmascript', prints the subtype, changes it to 'javascript', and prints the updated subtype and full MIME string.

```javascript
import { MIMEType } from 'node:util';

const myMIME = new MIMEType('text/ecmascript');
console.log(myMIME.subtype);
// Prints: ecmascript
myMIME.subtype = 'javascript';
console.log(myMIME.subtype);
// Prints: javascript
console.log(String(myMIME));
// Prints: text/javascript
```

```javascript
const { MIMEType } = require('node:util');

const myMIME = new MIMEType('text/ecmascript');
console.log(myMIME.subtype);
// Prints: ecmascript
myMIME.subtype = 'javascript';
console.log(myMIME.subtype);
// Prints: javascript
console.log(String(myMIME));
// Prints: text/javascript
```

--------------------------------

### CoffeeScript example files (main.coffee and scream.coffee)

Source: https://nodejs.org/docs/latest-v22.x/api/all.html

Example CoffeeScript files used to demonstrate the load hooks. main.coffee imports scream.coffee and prints a message, while scream.coffee exports a function that uppercases a string.

```coffeescript
# main.coffee
import { scream } from './scream.coffee'
console.log scream 'hello, world'

import { version } from 'node:process'
console.log "Brought to you by Node.js version #{version}"
```

```coffeescript
# scream.coffee
export scream = (str) -> str.toUpperCase()
```

--------------------------------

### Event: 'setup'

Source: https://nodejs.org/docs/latest-v22.x/api/cluster.html

Emitted every time cluster.setupPrimary() is called. The handler receives the settings object.

```APIDOC
## Event: 'setup'

### Description
Emitted every time cluster.setupPrimary() is called. The handler receives the settings object.

### Event
`'setup'`

### Parameters
- `settings` (Object) - The cluster.settings object at the time setupPrimary() was called.

### Notes
The settings object is advisory only; use cluster.settings for accuracy.
```

--------------------------------

### Get and set mime.type

Source: https://nodejs.org/docs/latest-v22.x/api/util.html

Demonstrates getting and setting the type portion of a MIME. The example creates a MIMEType for 'text/javascript', prints the type, changes it to 'application', and prints the updated type and full MIME string.

```javascript
import { MIMEType } from 'node:util';

const myMIME = new MIMEType('text/javascript');
console.log(myMIME.type);
// Prints: text
myMIME.type = 'application';
console.log(myMIME.type);
// Prints: application
console.log(String(myMIME));
// Prints: application/javascript
```

```javascript
const { MIMEType } = require('node:util');

const myMIME = new MIMEType('text/javascript');
console.log(myMIME.type);
// Prints: text
myMIME.type = 'application';
console.log(myMIME.type);
// Prints: application
console.log(String(myMIME));
// Prints: application/javascript
```

--------------------------------

### process.memoryUsage.rss() example (ESM and CommonJS)

Source: https://nodejs.org/docs/latest-v22.x/api/all.html

Shows how to use process.memoryUsage.rss() to get the Resident Set Size in bytes. The example is provided in both ESM (import) and CommonJS (require) syntax. The output is a sample integer value.

```javascript
import { memoryUsage } from 'node:process';

console.log(memoryUsage.rss());
// 35655680
```

```javascript
const { memoryUsage } = require('node:process');

console.log(memoryUsage.rss());
// 35655680
```

--------------------------------

### replServer.setupHistory(historyPath, callback)

Source: https://nodejs.org/docs/latest-v22.x/api/repl.html

Initializes a history log file for the REPL instance. This is useful when creating a REPL programmatically, as a history file is not initialized by default in that case.

```APIDOC
## replServer.setupHistory(historyPath, callback)

### Description
Initializes a history log file for the REPL instance. This is useful when creating a REPL programmatically, as a history file is not initialized by default in that case.

### Method
N/A (JavaScript method)

### Endpoint
N/A

### Parameters
- **historyPath** (string) - Required - The path to the history file.
- **callback** (Function) - Required - Called when history writes are ready or upon error. The callback receives:
  - **err** (Error) - The error object, if any.
  - **repl** (repl.REPLServer) - The REPL server instance.

### Request Example
No request example provided.

### Response
No return value documented.

### Response Example
No response example provided.
```
Tokens:
Raw