@types/node 20.12.13 → 20.12.14

node/util.d.ts

@@ -6,7 +6,7 @@
  * ```js
  * const util = require('node:util');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.13.1/lib/util.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.12.2/lib/util.js)
  */
 declare module "util" {
     import * as types from "node:util/types";
@@ -1256,32 +1256,16 @@ declare module "util" {
      *
      * ```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
+     *   util.styleText('underline', util.styleText('italic', 'My italic underlined message')),
      * );
      * ```
      *
      * 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 format A text format 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;
+    export function styleText(format: ForegroundColors | BackgroundColors | Modifiers, text: string): string;
     /**
      * An implementation of the [WHATWG Encoding Standard](https://encoding.spec.whatwg.org/) `TextDecoder` API.
      *

node/v8.d.ts

@@ -4,7 +4,7 @@
  * ```js
  * const v8 = require('node:v8');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.13.1/lib/v8.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.12.2/lib/v8.js)
  */
 declare module "v8" {
     import { Readable } from "node:stream";
@@ -183,50 +183,6 @@ 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.

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.13.1/lib/vm.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.12.2/lib/vm.js)
  */
 declare module "vm" {
     import { ImportAttributes } from "node:module";
@@ -347,14 +347,11 @@ declare module "vm" {
         sourceMapURL?: string | undefined;
     }
     /**
-     * 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.
+     * 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.
      *
      * ```js
      * const vm = require('node:vm');

node/wasi.d.ts

@@ -67,7 +67,7 @@
  * wat2wasm demo.wat
  * ```
  * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v20.13.1/lib/wasi.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.12.2/lib/wasi.js)
  */
 declare module "wasi" {
     interface WASIOptions {

node/worker_threads.d.ts

@@ -49,7 +49,7 @@
  *
  * 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.
- * @see [source](https://github.com/nodejs/node/blob/v20.13.1/lib/worker_threads.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.12.2/lib/worker_threads.js)
  */
 declare module "worker_threads" {
     import { Blob } from "node:buffer";

node/zlib.d.ts

@@ -89,7 +89,7 @@
  *   });
  * ```
  * @since v0.5.8
- * @see [source](https://github.com/nodejs/node/blob/v20.13.1/lib/zlib.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.12.2/lib/zlib.js)
  */
 declare module "zlib" {
     import * as stream from "node:stream";