Node.js

https://nodejs.org/docs/latest-v24.x/api/
Admin
Node.js is an open-source, cross-platform JavaScript runtime environment that executes JavaScript...
Tokens:3,145,859
Snippets:18,408
Trust Score:10
Update:1 day ago
Show doc for...
Tokens:
Raw
### Run hello-world.js with node

Source: https://nodejs.org/docs/latest-v24.x/api/synopsis.html

Run from the terminal in the projects folder to start the example server.

```bash
node hello-world.js
```

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

### Running the cluster example

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

Command to run the cluster example and the resulting output showing the primary process and workers starting.

```console
$ node server.js
Primary 3596 is running
Worker 4324 started
Worker 4520 started
Worker 6056 started
Worker 5644 started
```

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

### Output from starting the server with async_hooks

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

Shows the console output produced by the async_hooks example when the server starts, including init, before, after, and destroy events with indentation.

```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 copy
```

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

### process.execPath example

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

Example value of process.execPath, which is the absolute pathname of the executable that started the Node.js process.

```json
"/usr/local/bin/node"
```

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

### repl.start([options])

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

Creates and starts a repl.REPLServer instance. The options parameter can be an object or a string. If a string is provided, it specifies the input prompt.

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

### Description

The `repl.start()` method creates and starts a [`repl.REPLServer`](https://nodejs.org/docs/latest-v24.x/api/repl.html#class-replserver) instance.

If `options` is a string, then it specifies the input prompt.

### Method

`repl.start([options])`

### Parameters

- **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. See the [custom evaluation functions](https://nodejs.org/docs/latest-v24.x/api/repl.html#custom-evaluation-functions) section for more details.
  - **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-v24.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-v24.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.

### 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 REPLServer() (ESM)

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

Shows two ways to create a REPLServer: using repl.start() and using the new keyword. Uses ES module import syntax.

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

const options = { useColors: true };

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

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

### Start Node.js REPL and execute JavaScript

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

Running `node` without arguments starts the REPL. The example shows defining an array, inspecting it, and iterating with forEach.

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

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

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

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

Use repl.start() or the new keyword with repl.REPLServer to create instances. Calling repl.REPLServer() without new throws a TypeError.

```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);
```

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

### Get and set url.username

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

Demonstrates getting the username portion of a URL and setting it to a new value. The example shows that setting username updates the URL's href.

```javascript
const myURL = new URL('https://abc:xyz@example.com');
console.log(myURL.username);
// Prints abc

myURL.username = '123';
console.log(myURL.href);
// Prints https://123:xyz@example.com/
```

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

### repl.start(options)

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

Creates and starts a REPLServer instance. The options object can include a writer function to customize output formatting.

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

### Description
Creates and starts a new REPLServer instance. The `options` parameter can be used to customize the REPL behavior, including output formatting via the `writer` option.

### Method
Function call

### Endpoint
`repl.start(options)`

### Parameters
- **options** (Object | string) - Configuration options for the REPL. See REPLServer constructor for details.

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

const r = repl.start({ prompt: '> ', eval: myEval, writer: myWriter });

function myEval(cmd, context, filename, callback) {
  callback(null, cmd);
}

function myWriter(output) {
  return output.toUpperCase();
}
```

### Response
Returns a REPLServer instance.

```

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

### Get and set url.search

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

Demonstrates getting the serialized query portion of a URL and setting it to a new value. The example shows that setting search updates the URL's href.

```javascript
const myURL = new URL('https://example.org/abc?123');
console.log(myURL.search);
// Prints ?123

myURL.search = 'abc=xyz';
console.log(myURL.href);
// Prints https://example.org/abc?abc=xyz
```

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

### Create REPLServer instances with repl.start() and new REPLServer() (CommonJS)

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

Shows two ways to create a REPLServer: using repl.start() and using the new keyword. Uses CommonJS require syntax.

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

const options = { useColors: true };

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

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

### Create, link, and evaluate a vm.Module with ES modules

Source: https://nodejs.org/docs/latest-v24.x/api/vm.html

This example illustrates the three steps for using vm.Module: creation/parsing, linking, and evaluation. It requires the --experimental-vm-modules flag and uses ES module syntax.

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

const contextifiedObject = vm.createContext({
  secret: 42,
  print: console.log,
});

// Step 1
//
// Create a Module by constructing a new `vm.SourceTextModule` object. This
// parses the provided source text, throwing a `SyntaxError` if anything goes
// wrong. By default, a Module is created in the top context. But here, we
// specify `contextifiedObject` as the context this Module belongs to.
//
// Here, we attempt to obtain the default export from the module "foo", and
// put it into local binding "secret".

const rootModule = new vm.SourceTextModule(`
  import s from 'foo';
  s;
  print(s);
`, { context: contextifiedObject });

// Step 2
//
// "Link" the imported dependencies of this Module to it.
//
// Obtain the requested dependencies of a SourceTextModule by
// `sourceTextModule.moduleRequests` and resolve them.
//
// Even top-level Modules without dependencies must be explicitly linked. The
// array passed to `sourceTextModule.linkRequests(modules)` can be
// empty, however.
//
// Note: This is a contrived example in that the resolveAndLinkDependencies
// creates a new "foo" module every time it is called. In a full-fledged
// module system, a cache would probably be used to avoid duplicated modules.

const moduleMap = new Map([
  ['root', rootModule],
]);

function resolveAndLinkDependencies(module) {
  const requestedModules = module.moduleRequests.map((request) => {
    // In a full-fledged module system, the resolveAndLinkDependencies would
    // resolve the module with the module cache key `[specifier, attributes]`.
    // In this example, we just use the specifier as the key.
    const specifier = request.specifier;

    let requestedModule = moduleMap.get(specifier);
    if (requestedModule === undefined) {
      requestedModule = new vm.SourceTextModule(`
        // The "secret" variable refers to the global variable we added to
        // "contextifiedObject" when creating the context.
        export default secret;
      `, { context: module.context });
      moduleMap.set(specifier, requestedModule);
      // Resolve the dependencies of the new module as well.
      resolveAndLinkDependencies(requestedModule);
    }

    return requestedModule;
  });

  module.linkRequests(requestedModules);
}

resolveAndLinkDependencies(rootModule);
rootModule.instantiate();

// Step 3
//
// Evaluate the Module. The evaluate() method returns a promise which will
// resolve after the module has finished evaluating.

// Prints 42.
await rootModule.evaluate();
```

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

### Get system error message using util.getSystemErrorMessage

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

Uses util.getSystemErrorMessage with err.errno to get the error message string. The example logs '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
}); copy
```

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

### Get system error name using util.getSystemErrorName

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

Calls util.getSystemErrorName with err.errno from a failed fs.access to get the error name string. The example logs 'ENOENT' for a missing file.

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

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

### repl.start([options])

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

Starts a REPL instance with the given options. The options parameter is optional.

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

### Description

Starts a REPL instance with the given options. The `options` parameter is optional.

### Method

`repl.start([options])`

### Parameters

- **options** (Object) - Optional. Configuration options for the REPL instance. (Specific options are not detailed in the provided source excerpt.)

### History

| Version | Changes |
| --- | --- |
| v24.1.0 | Added the possibility to add/edit/remove multilines while adding a multiline command. |
| v24.0.0 | The multi-line indicator is now "|" instead of "...". Added support for multi-line history. It is now possible to "fix" multi-line commands with syntax errors by visiting the history and editing the command. When visiting the multiline history from an old node version, the multiline structure is not preserved. |
| 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 |
```

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

### Run with configuration file

Source: https://nodejs.org/docs/latest-v24.x/api/permissions.html

Start Node.js with the permission model and load permissions from the default configuration file.

```console
$ node --permission --experimental-default-config-file app.js copy
```

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

### Get and set MIME subtype using mime.subtype

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

Use the `subtype` property to get or set the subtype portion of a MIME. The example logs the subtype before and after setting it, and shows the serialized MIME.

```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
```

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

### Complete vm.SourceTextModule lifecycle example

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

This example demonstrates the full lifecycle of a `vm.SourceTextModule`, including creation, linking dependencies, instantiation, and evaluation. It shows how to handle module requests, resolve dependencies, and execute the module to obtain its exports. The example uses a contextified object to provide global variables to the module.

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

const contextifiedObject = vm.createContext({
  secret: 42,
  print: console.log,
});

(async () => {
  // Step 1
  //
  // Create a Module by constructing a new `vm.SourceTextModule` object. This
  // parses the provided source text, throwing a `SyntaxError` if anything goes
  // wrong. By default, a Module is created in the top context. But here, we
  // specify `contextifiedObject` as the context this Module belongs to.
  //
  // Here, we attempt to obtain the default export from the module "foo", and
  // put it into local binding "secret".

  const rootModule = new vm.SourceTextModule(`
    import s from 'foo';
    s;
    print(s);
  `, { context: contextifiedObject });

  // Step 2
  //
  // "Link" the imported dependencies of this Module to it.
  //
  // Obtain the requested dependencies of a SourceTextModule by
  // `sourceTextModule.moduleRequests` and resolve them.
  //
  // Even top-level Modules without dependencies must be explicitly linked. The
  // array passed to `sourceTextModule.linkRequests(modules)` can be
  // empty, however.
  //
  // Note: This is a contrived example in that the resolveAndLinkDependencies
  // creates a new "foo" module every time it is called. In a full-fledged
  // module system, a cache would probably be used to avoid duplicated modules.

  const moduleMap = new Map([
    ['root', rootModule],
  ]);

  function resolveAndLinkDependencies(module) {
    const requestedModules = module.moduleRequests.map((request) => {
      // In a full-fledged module system, the resolveAndLinkDependencies would
      // resolve the module with the module cache key `[specifier, attributes]`.
      // In this example, we just use the specifier as the key.
      const specifier = request.specifier;

      let requestedModule = moduleMap.get(specifier);
      if (requestedModule === undefined) {
        requestedModule = new vm.SourceTextModule(`
          // The "secret" variable refers to the global variable we added to
          // "contextifiedObject" when creating the context.
          export default secret;
        `, { context: module.context });
        moduleMap.set(specifier, requestedModule);
        // Resolve the dependencies of the new module as well.
        resolveAndLinkDependencies(requestedModule);
      }

      return requestedModule;
    });

    module.linkRequests(requestedModules);
  }

  resolveAndLinkDependencies(rootModule);
  rootModule.instantiate();

  // Step 3
  //
  // Evaluate the Module. The evaluate() method returns a promise which will
  // resolve after the module has finished evaluating.

  // Prints 42.
  await rootModule.evaluate();
})();
```

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

### Generate certificate and key for the HTTP/2 server example

Source: https://nodejs.org/docs/latest-v24.x/api/http2.html

Run this openssl command to create localhost-privkey.pem and localhost-cert.pem required by the secure server example.

```bash
openssl req -x509 -newkey rsa:2048 -nodes -sha256 -subj '/CN=localhost' \
  -keyout localhost-privkey.pem -out localhost-cert.pem
```

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

### Get and set MIME type using mime.type

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

Use the `type` property to get or set the type portion of a MIME. The example logs the type before and after setting it, and shows the serialized MIME.

```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
```

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

### Run hello.mjs with --experimental-addon-modules

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

Execute the script with the --experimental-addon-modules flag to load the addon. The expected output is 'world'.

```console
$ node --experimental-addon-modules hello.mjs
world
```

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

### console.timeEnd example

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

Stops a timer that was previously started by calling console.time() and prints the result to stdout.

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

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

### Get system error map using util.getSystemErrorMap

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

Retrieves the Map of system error codes with util.getSystemErrorMap and looks up err.errno to get the error name. The example logs 'ENOENT' for a missing file.

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

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

### Build and run the hello addon

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

Commands to compile the addon with make and then load it via require to call the hello method, which outputs 'world'.

```console
$ make
$ node -p 'require("./hello.node").hello()'
world
```

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

### Example project structure for path matching

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

Example directory structure showing two files with the same basename in different directories.

```text
project/
  - src/utils.js
  - lib/utils.js copy
```

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

### Create and start a WASI instance using CommonJS

Source: https://nodejs.org/docs/latest-v24.x/api/wasi.html

CommonJS equivalent of the ES module example. Uses require and an async IIFE to compile and instantiate 'demo.wasm' from the current directory, then starts it with wasi.start(instance).

```javascript
const { readFile } = require('node:fs/promises');
const { WASI } = require('node:wasi');
const { argv, env } = require('node:process');
const { join } = require('node:path');

const wasi = new WASI({
  version: 'preview1',
  args: argv,
  env,
  preopens: {
    '/local': '/some/real/path/that/wasm/can/access',
  },
});

(async () => {
  const wasm = await WebAssembly.compile(
    await readFile(join(__dirname, 'demo.wasm')),
  );
  const instance = await WebAssembly.instantiate(wasm, wasi.getImportObject());

  wasi.start(instance);
})();
```

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

### Create, link, and evaluate a vm.Module with CommonJS

Source: https://nodejs.org/docs/latest-v24.x/api/vm.html

This example illustrates the three steps for using vm.Module: creation/parsing, linking, and evaluation. It requires the --experimental-vm-modules flag and uses CommonJS syntax.

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

const contextifiedObject = vm.createContext({
  secret: 42,
  print: console.log,
});
```

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

### buf.toString() example (CommonJS)

Source: https://nodejs.org/docs/latest-v24.x/api/buffer.html

Decodes a Buffer to a string using the specified encoding. The example shows decoding a buffer of ASCII letters and a buffer containing a non-ASCII character, with optional start and end offsets.

```javascript
const { Buffer } = require('node:buffer');

const buf1 = Buffer.allocUnsafe(26);

for (let i = 0; i < 26; i++) {
  // 97 is the decimal ASCII value for 'a'.
  buf1[i] = i + 97;
}

console.log(buf1.toString('utf8'));
// Prints: abcdefghijklmnopqrstuvwxyz
console.log(buf1.toString('utf8', 0, 5));
// Prints: abcde

const buf2 = Buffer.from('tést');

console.log(buf2.toString('hex'));
// Prints: 74c3a97374
console.log(buf2.toString('utf8', 0, 3));
// Prints: té
console.log(buf2.toString(undefined, 0, 3));
// Prints: té
```

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

### Create, Link, and Evaluate a vm.SourceTextModule

Source: https://nodejs.org/docs/latest-v24.x/api/vm.html

Shows how to create a SourceTextModule with a context, resolve and link its dependencies, and evaluate it. The example uses a contrived module map and prints 42.

```javascript
(async () => {
  // Step 1
  //
  // Create a Module by constructing a new `vm.SourceTextModule` object. This
  // parses the provided source text, throwing a `SyntaxError` if anything goes
  // wrong. By default, a Module is created in the top context. But here, we
  // specify `contextifiedObject` as the context this Module belongs to.
  //
  // Here, we attempt to obtain the default export from the module "foo", and
  // put it into local binding "secret".

  const rootModule = new vm.SourceTextModule(`
    import s from 'foo';
    s;
    print(s);
  `, { context: contextifiedObject });

  // Step 2
  //
  // "Link" the imported dependencies of this Module to it.
  //
  // Obtain the requested dependencies of a SourceTextModule by
  // `sourceTextModule.moduleRequests` and resolve them.
  //
  // Even top-level Modules without dependencies must be explicitly linked. The
  // array passed to `sourceTextModule.linkRequests(modules)` can be
  // empty, however.
  //
  // Note: This is a contrived example in that the resolveAndLinkDependencies
  // creates a new "foo" module every time it is called. In a full-fledged
  // module system, a cache would probably be used to avoid duplicated modules.

  const moduleMap = new Map([
    ['root', rootModule],
  ]);

  function resolveAndLinkDependencies(module) {
    const requestedModules = module.moduleRequests.map((request) => {
      // In a full-fledged module system, the resolveAndLinkDependencies would
      // resolve the module with the module cache key `[specifier, attributes]`.
      // In this example, we just use the specifier as the key.
      const specifier = request.specifier;

      let requestedModule = moduleMap.get(specifier);
      if (requestedModule === undefined) {
        requestedModule = new vm.SourceTextModule(`
          // The "secret" variable refers to the global variable we added to
          // "contextifiedObject" when creating the context.
          export default secret;
        `, { context: module.context });
        moduleMap.set(specifier, requestedModule);
        // Resolve the dependencies of the new module as well.
        resolveAndLinkDependencies(requestedModule);
      }

      return requestedModule;
    });

    module.linkRequests(requestedModules);
  }

  resolveAndLinkDependencies(rootModule);
  rootModule.instantiate();

  // Step 3
  //
  // Evaluate the Module. The evaluate() method returns a promise which will
  // resolve after the module has finished evaluating.

  // Prints 42.
  await rootModule.evaluate();
})();copy
```
Tokens:
Raw