node-red-contrib-tak-registration 0.11.6 → 0.12.0

package/node_modules/@types/node/util.d.ts

@@ -6,7 +6,7 @@
  * ```js
  * const util = require('node:util');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/util.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.13.1/lib/util.js)
  */
 declare module "util" {
     import * as types from "node:util/types";
@@ -110,7 +110,7 @@ declare module "util" {
     }
     /**
      * The `util.format()` method returns a formatted string using the first argument
-     * as a `printf`\-like format string which can contain zero or more format
+     * as a `printf`-like format string which can contain zero or more format
      * specifiers. Each specifier is replaced with the converted value from the
      * corresponding argument. Supported specifiers are:
      *
@@ -121,7 +121,7 @@ declare module "util" {
      * // Returns: 'foo:%s'
      * ```
      *
-     * Values that are not part of the format string are formatted using`util.inspect()` if their type is not `string`.
+     * Values that are not part of the format string are formatted using `util.inspect()` if their type is not `string`.
      *
      * If there are more arguments passed to the `util.format()` method than the
      * number of specifiers, the extra arguments are concatenated to the returned
@@ -132,7 +132,7 @@ declare module "util" {
      * // Returns: 'foo:bar baz'
      * ```
      *
-     * If the first argument does not contain a valid format specifier, `util.format()`returns a string that is the concatenation of all arguments separated by spaces:
+     * If the first argument does not contain a valid format specifier, `util.format()` returns a string that is the concatenation of all arguments separated by spaces:
      *
      * ```js
      * util.format(1, 2, 3);
@@ -265,7 +265,7 @@ declare module "util" {
      * The `util.inspect()` method returns a string representation of `object` that is
      * intended for debugging. The output of `util.inspect` may change at any time
      * and should not be depended upon programmatically. Additional `options` may be
-     * passed that alter the result.`util.inspect()` will use the constructor's name and/or `@@toStringTag` to make
+     * passed that alter the result. `util.inspect()` will use the constructor's name and/or `@@toStringTag` to make
      * an identifiable tag for an inspected value.
      *
      * ```js
@@ -507,7 +507,7 @@ declare module "util" {
      */
     export function isDate(object: unknown): object is Date;
     /**
-     * Returns `true` if the given `object` is an `Error`. Otherwise, returns`false`.
+     * Returns `true` if the given `object` is an `Error`. Otherwise, returns `false`.
      *
      * ```js
      * const util = require('node:util');
@@ -521,7 +521,7 @@ declare module "util" {
      * ```
      *
      * This method relies on `Object.prototype.toString()` behavior. It is
-     * possible to obtain an incorrect result when the `object` argument manipulates`@@toStringTag`.
+     * possible to obtain an incorrect result when the `object` argument manipulates `@@toStringTag`.
      *
      * ```js
      * const util = require('node:util');
@@ -538,11 +538,11 @@ declare module "util" {
      */
     export function isError(object: unknown): object is Error;
     /**
-     * Usage of `util.inherits()` is discouraged. Please use the ES6 `class` and`extends` keywords to get language level inheritance support. Also note
+     * Usage of `util.inherits()` is discouraged. Please use the ES6 `class` and `extends` keywords to get language level inheritance support. Also note
      * that the two styles are [semantically incompatible](https://github.com/nodejs/node/issues/4179).
      *
      * Inherit the prototype methods from one [constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/constructor) into another. The
-     * prototype of `constructor` will be set to a new object created from`superConstructor`.
+     * prototype of `constructor` will be set to a new object created from `superConstructor`.
      *
      * This mainly adds some input validation on top of`Object.setPrototypeOf(constructor.prototype, superConstructor.prototype)`.
      * As an additional convenience, `superConstructor` will be accessible
@@ -693,7 +693,7 @@ declare module "util" {
      */
     export function isBuffer(object: unknown): object is Buffer;
     /**
-     * Returns `true` if the given `object` is a `Function`. Otherwise, returns`false`.
+     * Returns `true` if the given `object` is a `Function`. Otherwise, returns `false`.
      *
      * ```js
      * const util = require('node:util');
@@ -881,7 +881,7 @@ declare module "util" {
      * }, 'obsoleteFunction() is deprecated. Use newShinyFunction() instead.');
      * ```
      *
-     * When called, `util.deprecate()` will return a function that will emit a`DeprecationWarning` using the `'warning'` event. The warning will
+     * When called, `util.deprecate()` will return a function that will emit a `DeprecationWarning` using the `'warning'` event. The warning will
      * be emitted and printed to `stderr` the first time the returned function is
      * called. After the warning is emitted, the wrapped function is called without
      * emitting a warning.
@@ -907,10 +907,10 @@ declare module "util" {
      * stack trace are printed to `stderr` the first time the deprecated function is
      * called.
      *
-     * If the `--throw-deprecation` command-line flag is set, or the`process.throwDeprecation` property is set to `true`, then an exception will be
+     * If the `--throw-deprecation` command-line flag is set, or the `process.throwDeprecation` property is set to `true`, then an exception will be
      * thrown when the deprecated function is called.
      *
-     * The `--throw-deprecation` command-line flag and `process.throwDeprecation`property take precedence over `--trace-deprecation` and`process.traceDeprecation`.
+     * The `--throw-deprecation` command-line flag and `process.throwDeprecation` property take precedence over `--trace-deprecation` and `process.traceDeprecation`.
      * @since v0.8.0
      * @param fn The function that is being deprecated.
      * @param msg A warning message to display when the deprecated function is invoked.
@@ -941,7 +941,7 @@ declare module "util" {
      * Takes an `async` function (or a function that returns a `Promise`) and returns a
      * function following the error-first callback style, i.e. taking
      * an `(err, value) => ...` callback as the last argument. In the callback, the
-     * first argument will be the rejection reason (or `null` if the `Promise`resolved), and the second argument will be the resolved value.
+     * first argument will be the rejection reason (or `null` if the `Promise` resolved), and the second argument will be the resolved value.
      *
      * ```js
      * const util = require('node:util');
@@ -968,7 +968,7 @@ declare module "util" {
      *
      * Since `null` has a special meaning as the first argument to a callback, if a
      * wrapped function rejects a `Promise` with a falsy value as a reason, the value
-     * is wrapped in an `Error` with the original value stored in a field named`reason`.
+     * is wrapped in an `Error` with the original value stored in a field named `reason`.
      *
      * ```js
      * function fn() {
@@ -1097,10 +1097,10 @@ declare module "util" {
      * callStat();
      * ```
      *
-     * If there is an `original[util.promisify.custom]` property present, `promisify`will return its value, see `Custom promisified functions`.
+     * If there is an `original[util.promisify.custom]` property present, `promisify` will return its value, see `Custom promisified functions`.
      *
      * `promisify()` assumes that `original` is a function taking a callback as its
-     * final argument in all cases. If `original` is not a function, `promisify()`will throw an error. If `original` is a function but its last argument is not
+     * final argument in all cases. If `original` is not a function, `promisify()` will throw an error. If `original` is a function but its last argument is not
      * an error-first callback, it will still be passed an error-first
      * callback as its last argument.
      *
@@ -1173,6 +1173,115 @@ declare module "util" {
          */
         const custom: unique symbol;
     }
+    /**
+     * Stability: 1.1 - Active development
+     * Given an example `.env` file:
+     *
+     * ```js
+     * const { parseEnv } = require('node:util');
+     *
+     * parseEnv('HELLO=world\nHELLO=oh my\n');
+     * // Returns: { HELLO: 'oh my' }
+     * ```
+     * @param content The raw contents of a `.env` file.
+     * @since v20.12.0
+     */
+    export function parseEnv(content: string): object;
+    // https://nodejs.org/docs/latest/api/util.html#foreground-colors
+    type ForegroundColors =
+        | "black"
+        | "blackBright"
+        | "blue"
+        | "blueBright"
+        | "cyan"
+        | "cyanBright"
+        | "gray"
+        | "green"
+        | "greenBright"
+        | "grey"
+        | "magenta"
+        | "magentaBright"
+        | "red"
+        | "redBright"
+        | "white"
+        | "whiteBright"
+        | "yellow"
+        | "yellowBright";
+    // https://nodejs.org/docs/latest/api/util.html#background-colors
+    type BackgroundColors =
+        | "bgBlack"
+        | "bgBlackBright"
+        | "bgBlue"
+        | "bgBlueBright"
+        | "bgCyan"
+        | "bgCyanBright"
+        | "bgGray"
+        | "bgGreen"
+        | "bgGreenBright"
+        | "bgGrey"
+        | "bgMagenta"
+        | "bgMagentaBright"
+        | "bgRed"
+        | "bgRedBright"
+        | "bgWhite"
+        | "bgWhiteBright"
+        | "bgYellow"
+        | "bgYellowBright";
+    // https://nodejs.org/docs/latest/api/util.html#modifiers
+    type Modifiers =
+        | "blink"
+        | "bold"
+        | "dim"
+        | "doubleunderline"
+        | "framed"
+        | "hidden"
+        | "inverse"
+        | "italic"
+        | "overlined"
+        | "reset"
+        | "strikethrough"
+        | "underline";
+    /**
+     * Stability: 1.1 - Active development
+     *
+     * This function returns a formatted text considering the `format` passed.
+     *
+     * ```js
+     * const { styleText } = require('node:util');
+     * const errorMessage = styleText('red', 'Error! Error!');
+     * console.log(errorMessage);
+     * ```
+     *
+     * `util.inspect.colors` also provides text formats such as `italic`, and `underline` and you can combine both:
+     *
+     * ```js
+     * console.log(
+     *   util.styleText(['underline', 'italic'], 'My italic underlined message'),
+     * );
+     * ```
+     *
+     * When passing an array of formats, the order of the format applied is left to right so the following style
+     * might overwrite the previous one.
+     *
+     * ```js
+     * console.log(
+     *   util.styleText(['red', 'green'], 'text'), // green
+     * );
+     * ```
+     *
+     * The full list of formats can be found in [modifiers](https://nodejs.org/docs/latest-v20.x/api/util.html#modifiers).
+     * @param format A text format or an Array of text formats defined in `util.inspect.colors`.
+     * @param text The text to to be formatted.
+     * @since v20.12.0
+     */
+    export function styleText(
+        format:
+            | ForegroundColors
+            | BackgroundColors
+            | Modifiers
+            | Array<ForegroundColors | BackgroundColors | Modifiers>,
+        text: string,
+    ): string;
     /**
      * An implementation of the [WHATWG Encoding Standard](https://encoding.spec.whatwg.org/) `TextDecoder` API.
      *
@@ -1210,7 +1319,7 @@ declare module "util" {
          * incomplete byte sequences occurring at the end of the `input` are buffered
          * internally and emitted after the next call to `textDecoder.decode()`.
          *
-         * If `textDecoder.fatal` is `true`, decoding errors that occur will result in a`TypeError` being thrown.
+         * If `textDecoder.fatal` is `true`, decoding errors that occur will result in a `TypeError` being thrown.
          * @param input An `ArrayBuffer`, `DataView`, or `TypedArray` instance containing the encoded data.
          */
         decode(
@@ -1589,7 +1698,7 @@ declare module "util" {
         toString(): string;
     }
     /**
-     * The `MIMEParams` API provides read and write access to the parameters of a`MIMEType`.
+     * The `MIMEParams` API provides read and write access to the parameters of a `MIMEType`.
      * @since v19.1.0, v18.13.0
      */
     export class MIMEParams {
@@ -1630,7 +1739,7 @@ declare module "util" {
          */
         keys(): IterableIterator<string>;
         /**
-         * Sets the value in the `MIMEParams` object associated with `name` to`value`. If there are any pre-existing name-value pairs whose names are `name`,
+         * Sets the value in the `MIMEParams` object associated with `name` to `value`. If there are any pre-existing name-value pairs whose names are `name`,
          * set the first such pair's value to `value`.
          *
          * ```js
@@ -1965,8 +2074,8 @@ declare module "util/types" {
      * console.log(util.types.isNativeError(new MyError()));  // true
      * ```
      *
-     * A value being `instanceof` a native error class is not equivalent to `isNativeError()`returning `true` for that value. `isNativeError()` returns `true` for errors
-     * which come from a different [realm](https://tc39.es/ecma262/#realm) while `instanceof Error` returns `false`for these errors:
+     * A value being `instanceof` a native error class is not equivalent to `isNativeError()` returning `true` for that value. `isNativeError()` returns `true` for errors
+     * which come from a different [realm](https://tc39.es/ecma262/#realm) while `instanceof Error` returns `false` for these errors:
      *
      * ```js
      * const vm = require('node:vm');

package/node_modules/@types/node/v8.d.ts

@@ -4,7 +4,7 @@
  * ```js
  * const v8 = require('node:v8');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.11.0/lib/v8.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.13.1/lib/v8.js)
  */
 declare module "v8" {
     import { Readable } from "node:stream";
@@ -70,7 +70,7 @@ declare module "v8" {
     /**
      * Returns an object with the following properties:
      *
-     * `does_zap_garbage` is a 0/1 boolean, which signifies whether the`--zap_code_space` option is enabled or not. This makes V8 overwrite heap
+     * `does_zap_garbage` is a 0/1 boolean, which signifies whether the `--zap_code_space` option is enabled or not. This makes V8 overwrite heap
      * garbage with a bit pattern. The RSS footprint (resident set size) gets bigger
      * because it continuously touches all heap pages and that makes them less likely
      * to get swapped out by the operating system.
@@ -170,7 +170,7 @@ declare module "v8" {
      * after the VM has started may result in unpredictable behavior, including
      * crashes and data loss; or it may simply do nothing.
      *
-     * The V8 options available for a version of Node.js may be determined by running`node --v8-options`.
+     * The V8 options available for a version of Node.js may be determined by running `node --v8-options`.
      *
      * Usage:
      *
@@ -183,6 +183,50 @@ declare module "v8" {
      * @since v1.0.0
      */
     function setFlagsFromString(flags: string): void;
+    /**
+     * This is similar to the [`queryObjects()` console API](https://developer.chrome.com/docs/devtools/console/utilities#queryObjects-function)
+     * provided by the Chromium DevTools console. It can be used to search for objects that have the matching constructor on its prototype chain
+     * in the heap after a full garbage collection, which can be useful for memory leak regression tests. To avoid surprising results, users should
+     * avoid using this API on constructors whose implementation they don't control, or on constructors that can be invoked by other parties in the
+     * application.
+     *
+     * To avoid accidental leaks, this API does not return raw references to the objects found. By default, it returns the count of the objects
+     * found. If `options.format` is `'summary'`, it returns an array containing brief string representations for each object. The visibility provided
+     * in this API is similar to what the heap snapshot provides, while users can save the cost of serialization and parsing and directly filter the
+     * target objects during the search.
+     *
+     * Only objects created in the current execution context are included in the results.
+     *
+     * ```js
+     * import { queryObjects } from 'node:v8';
+     * class A { foo = 'bar'; }
+     * console.log(queryObjects(A)); // 0
+     * const a = new A();
+     * console.log(queryObjects(A)); // 1
+     * // [ "A { foo: 'bar' }" ]
+     * console.log(queryObjects(A, { format: 'summary' }));
+     *
+     * class B extends A { bar = 'qux'; }
+     * const b = new B();
+     * console.log(queryObjects(B)); // 1
+     * // [ "B { foo: 'bar', bar: 'qux' }" ]
+     * console.log(queryObjects(B, { format: 'summary' }));
+     *
+     * // Note that, when there are child classes inheriting from a constructor,
+     * // the constructor also shows up in the prototype chain of the child
+     * // classes's prototoype, so the child classes's prototoype would also be
+     * // included in the result.
+     * console.log(queryObjects(A));  // 3
+     * // [ "B { foo: 'bar', bar: 'qux' }", 'A {}', "A { foo: 'bar' }" ]
+     * console.log(queryObjects(A, { format: 'summary' }));
+     * ```
+     * @param ctor The constructor that can be used to search on the prototype chain in order to filter target objects in the heap.
+     * @since v20.13.0
+     * @experimental
+     */
+    function queryObjects(ctor: Function): number | string[];
+    function queryObjects(ctor: Function, options: { format: "count" }): number;
+    function queryObjects(ctor: Function, options: { format: "summary" }): string[];
     /**
      * Generates a snapshot of the current V8 heap and returns a Readable
      * Stream that may be used to read the JSON serialized representation.
@@ -356,7 +400,7 @@ declare module "v8" {
         transferArrayBuffer(id: number, arrayBuffer: ArrayBuffer): void;
         /**
          * Reads the underlying wire format version. Likely mostly to be useful to
-         * legacy code reading old wire format versions. May not be called before`.readHeader()`.
+         * legacy code reading old wire format versions. May not be called before `.readHeader()`.
          */
         getWireFormatVersion(): number;
         /**
@@ -365,7 +409,7 @@ declare module "v8" {
          */
         readUint32(): number;
         /**
-         * Read a raw 64-bit unsigned integer and return it as an array `[hi, lo]`with two 32-bit unsigned integer entries.
+         * Read a raw 64-bit unsigned integer and return it as an array `[hi, lo]` with two 32-bit unsigned integer entries.
          * For use inside of a custom `deserializer._readHostObject()`.
          */
         readUint64(): [number, number];
@@ -438,7 +482,7 @@ declare module "v8" {
          */
         start(): void;
         /**
-         * Stop collecting GC data and return an object.The content of object
+         * Stop collecting GC data and return an object. The content of object
          * is as follows.
          *
          * ```json

package/node_modules/@types/node/vm.d.ts

@@ -34,7 +34,7 @@
  *
  * console.log(x); // 1; y is not defined.
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/vm.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.13.1/lib/vm.js)
  */
 declare module "vm" {
     import { ImportAttributes } from "node:module";
@@ -42,12 +42,12 @@ declare module "vm" {
     interface BaseOptions {
         /**
          * Specifies the filename used in stack traces produced by this script.
-         * Default: `''`.
+         * @default ''
          */
         filename?: string | undefined;
         /**
          * Specifies the line number offset that is displayed in stack traces produced by this script.
-         * Default: `0`.
+         * @default 0
          */
         lineOffset?: number | undefined;
         /**
@@ -64,17 +64,19 @@ declare module "vm" {
         /** @deprecated in favor of `script.createCachedData()` */
         produceCachedData?: boolean | undefined;
         /**
-         * Called during evaluation of this module when `import()` is called.
-         * If this option is not specified, calls to `import()` will reject with `ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`.
+         * Used to specify how the modules should be loaded during the evaluation of this script when `import()` is called. This option is
+         * part of the experimental modules API. We do not recommend using it in a production environment. For detailed information, see
+         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v20.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
          */
         importModuleDynamically?:
             | ((specifier: string, script: Script, importAttributes: ImportAttributes) => Module)
+            | typeof constants.USE_MAIN_CONTEXT_DEFAULT_LOADER
             | undefined;
     }
     interface RunningScriptOptions extends BaseOptions {
         /**
          * When `true`, if an `Error` occurs while compiling the `code`, the line of code causing the error is attached to the stack trace.
-         * Default: `true`.
+         * @default true
          */
         displayErrors?: boolean | undefined;
         /**
@@ -86,7 +88,7 @@ declare module "vm" {
          * If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received.
          * Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that.
          * If execution is terminated, an `Error` will be thrown.
-         * Default: `false`.
+         * @default false
          */
         breakOnSigint?: boolean | undefined;
     }
@@ -122,7 +124,7 @@ declare module "vm" {
         cachedData?: Buffer | undefined;
         /**
          * Specifies whether to produce new cache data.
-         * Default: `false`,
+         * @default false
          */
         produceCachedData?: boolean | undefined;
         /**
@@ -193,7 +195,7 @@ declare module "vm" {
     class Script {
         constructor(code: string, options?: ScriptOptions | string);
         /**
-         * Runs the compiled code contained by the `vm.Script` object within the given`contextifiedObject` and returns the result. Running code does not have access
+         * Runs the compiled code contained by the `vm.Script` object within the given `contextifiedObject` and returns the result. Running code does not have access
          * to local scope.
          *
          * The following example compiles code that increments a global variable, sets
@@ -281,7 +283,7 @@ declare module "vm" {
          */
         runInThisContext(options?: RunningScriptOptions): any;
         /**
-         * Creates a code cache that can be used with the `Script` constructor's`cachedData` option. Returns a `Buffer`. This method may be called at any
+         * Creates a code cache that can be used with the `Script` constructor's `cachedData` option. Returns a `Buffer`. This method may be called at any
          * time and any number of times.
          *
          * The code cache of the `Script` doesn't contain any JavaScript observable
@@ -319,7 +321,7 @@ declare module "vm" {
         cachedDataProduced?: boolean | undefined;
         /**
          * When `cachedData` is supplied to create the `vm.Script`, this value will be set
-         * to either `true` or `false` depending on acceptance of the data by V8\.
+         * to either `true` or `false` depending on acceptance of the data by V8.
          * Otherwise the value is `undefined`.
          * @since v5.7.0
          */
@@ -345,11 +347,14 @@ declare module "vm" {
         sourceMapURL?: string | undefined;
     }
     /**
-     * If given a `contextObject`, the `vm.createContext()` method will `prepare
-     * that object` so that it can be used in calls to {@link runInContext} or `script.runInContext()`. Inside such scripts,
-     * the `contextObject` will be the global object, retaining all of its existing
-     * properties but also having the built-in objects and functions any standard [global object](https://es5.github.io/#x15.1) has. Outside of scripts run by the vm module, global variables
-     * will remain unchanged.
+     * If given a `contextObject`, the `vm.createContext()` method will
+     * [prepare that object](https://nodejs.org/docs/latest-v20.x/api/vm.html#what-does-it-mean-to-contextify-an-object)
+     * and return a reference to it so that it can be used in `{@link runInContext}` or
+     * [`script.runInContext()`](https://nodejs.org/docs/latest-v20.x/api/vm.html#scriptrunincontextcontextifiedobject-options). Inside such
+     * scripts, the `contextObject` will be the global object, retaining all of its
+     * existing properties but also having the built-in objects and functions any
+     * standard [global object](https://es5.github.io/#x15.1) has. Outside of scripts run by the vm module, global
+     * variables will remain unchanged.
      *
      * ```js
      * const vm = require('node:vm');
@@ -472,9 +477,9 @@ declare module "vm" {
      * // Prints: evalResult: 'eval', localVar: 'eval'
      * ```
      *
-     * Because `vm.runInThisContext()` does not have access to the local scope,`localVar` is unchanged. In contrast,
+     * Because `vm.runInThisContext()` does not have access to the local scope, `localVar` is unchanged. In contrast,
      * [`eval()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval) _does_ have access to the
-     * local scope, so the value `localVar` is changed. In this way`vm.runInThisContext()` is much like an [indirect `eval()` call](https://es5.github.io/#x10.4.2), e.g.`(0,eval)('code')`.
+     * local scope, so the value `localVar` is changed. In this way `vm.runInThisContext()` is much like an [indirect `eval()` call](https://es5.github.io/#x10.4.2), e.g.`(0,eval)('code')`.
      *
      * ## Example: Running an HTTP server within a VM
      *
@@ -536,7 +541,7 @@ declare module "vm" {
      * The format of the object that the returned Promise may resolve with is
      * specific to the V8 engine and may change from one version of V8 to the next.
      *
-     * The returned result is different from the statistics returned by`v8.getHeapSpaceStatistics()` in that `vm.measureMemory()` measure the
+     * The returned result is different from the statistics returned by `v8.getHeapSpaceStatistics()` in that `vm.measureMemory()` measure the
      * memory reachable by each V8 specific contexts in the current instance of
      * the V8 engine, while the result of `v8.getHeapSpaceStatistics()` measure
      * the memory occupied by each heap space in the current V8 instance.
@@ -604,7 +609,7 @@ declare module "vm" {
      * flag enabled.
      *
      * The `vm.Module` class provides a low-level interface for using
-     * ECMAScript modules in VM contexts. It is the counterpart of the `vm.Script`class that closely mirrors [Module Record](https://262.ecma-international.org/14.0/#sec-abstract-module-records) s as
+     * ECMAScript modules in VM contexts. It is the counterpart of the `vm.Script` class that closely mirrors [Module Record](https://262.ecma-international.org/14.0/#sec-abstract-module-records) s as
      * defined in the ECMAScript
      * specification.
      *
@@ -742,7 +747,7 @@ declare module "vm" {
          * * `'errored'`: The module has been evaluated, but an exception was thrown.
          *
          * Other than `'errored'`, this status string corresponds to the specification's [Cyclic Module Record](https://tc39.es/ecma262/#sec-cyclic-module-records)'s `[[Status]]` field. `'errored'`
-         * corresponds to`'evaluated'` in the specification, but with `[[EvaluationError]]` set to a
+         * corresponds to `'evaluated'` in the specification, but with `[[EvaluationError]]` set to a
          * value that is not `undefined`.
          */
         status: ModuleStatus;
@@ -775,7 +780,7 @@ declare module "vm" {
          * * Its `status` must not be `'errored'`.
          *
          * If the returned `Module`'s `status` is `'unlinked'`, this method will be
-         * recursively called on the returned `Module` with the same provided `linker`function.
+         * recursively called on the returned `Module` with the same provided `linker` function.
          *
          * `link()` returns a `Promise` that will either get resolved when all linking
          * instances resolve to a valid `Module`, or rejected if the linker function either
@@ -897,6 +902,22 @@ declare module "vm" {
          */
         setExport(name: string, value: any): void;
     }
+    /**
+     * Returns an object containing commonly used constants for VM operations.
+     * @since v20.12.0
+     */
+    namespace constants {
+        /**
+         * Stability: 1.1 - Active development
+         *
+         * A constant that can be used as the `importModuleDynamically` option to `vm.Script`
+         * and `vm.compileFunction()` so that Node.js uses the default ESM loader from the main
+         * context to load the requested module.
+         *
+         * For detailed information, see [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v20.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         */
+        const USE_MAIN_CONTEXT_DEFAULT_LOADER: number;
+    }
 }
 declare module "node:vm" {
     export * from "vm";

package/node_modules/@types/node/wasi.d.ts

@@ -29,7 +29,7 @@
  * wasi.start(instance);
  * ```
  *
- * To run the above example, create a new WebAssembly text format file named`demo.wat`:
+ * To run the above example, create a new WebAssembly text format file named `demo.wat`:
  *
  * ```text
  * (module
@@ -67,7 +67,7 @@
  * wat2wasm demo.wat
  * ```
  * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/wasi.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.13.1/lib/wasi.js)
  */
 declare module "wasi" {
     interface WASIOptions {
@@ -75,11 +75,13 @@ declare module "wasi" {
          * An array of strings that the WebAssembly application will
          * see as command line arguments. The first argument is the virtual path to the
          * WASI command itself.
+         * @default []
          */
         args?: string[] | undefined;
         /**
          * An object similar to `process.env` that the WebAssembly
          * application will see as its environment.
+         * @default {}
          */
         env?: object | undefined;
         /**
@@ -91,7 +93,7 @@ declare module "wasi" {
         preopens?: NodeJS.Dict<string> | undefined;
         /**
          * By default, when WASI applications call `__wasi_proc_exit()`
-         *  `wasi.start()` will return with the exit code specified rather than terminatng the process.
+         * `wasi.start()` will return with the exit code specified rather than terminatng the process.
          * Setting this option to `false` will cause the Node.js process to exit with
          * the specified exit code instead.
          * @default true
@@ -114,10 +116,10 @@ declare module "wasi" {
         stderr?: number | undefined;
         /**
          * The version of WASI requested.
-         * Currently the only supported versions are `'unstable'` and `'preview1'`.
-         * @since v20.0.0
+         * Currently the only supported versions are `'unstable'` and `'preview1'`. This option is mandatory.
+         * @since v19.8.0
          */
-        version: string;
+        version: "unstable" | "preview1";
     }
     /**
      * The `WASI` class provides the WASI system call API and additional convenience
@@ -145,10 +147,10 @@ declare module "wasi" {
          */
         getImportObject(): object;
         /**
-         * Attempt to begin execution of `instance` as a WASI command by invoking its`_start()` export. If `instance` does not contain a `_start()` export, or if`instance` contains an `_initialize()`
+         * Attempt to begin execution of `instance` as a WASI command by invoking its `_start()` export. If `instance` does not contain a `_start()` export, or if `instance` contains an `_initialize()`
          * export, then an exception is thrown.
          *
-         * `start()` requires that `instance` exports a [`WebAssembly.Memory`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory) named`memory`. If
+         * `start()` requires that `instance` exports a [`WebAssembly.Memory`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory) named `memory`. If
          * `instance` does not have a `memory` export an exception is thrown.
          *
          * If `start()` is called more than once, an exception is thrown.
@@ -156,9 +158,9 @@ declare module "wasi" {
          */
         start(instance: object): number; // TODO: avoid DOM dependency until WASM moved to own lib.
         /**
-         * Attempt to initialize `instance` as a WASI reactor by invoking its`_initialize()` export, if it is present. If `instance` contains a `_start()`export, then an exception is thrown.
+         * Attempt to initialize `instance` as a WASI reactor by invoking its `_initialize()` export, if it is present. If `instance` contains a `_start()` export, then an exception is thrown.
          *
-         * `initialize()` requires that `instance` exports a [`WebAssembly.Memory`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory) named`memory`.
+         * `initialize()` requires that `instance` exports a [`WebAssembly.Memory`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory) named `memory`.
          * If `instance` does not have a `memory` export an exception is thrown.
          *
          * If `initialize()` is called more than once, an exception is thrown.