@types/node 20.6.3 → 20.6.4

node/util.d.ts

@@ -8,8 +8,8 @@
  * ```
  * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/util.js)
  */
-declare module 'util' {
-    import * as types from 'node:util/types';
+declare module "util" {
+    import * as types from "node:util/types";
     export interface InspectOptions {
         /**
          * If `true`, object's non-enumerable symbols and properties are included in the formatted result.
@@ -85,14 +85,25 @@ declare module 'util' {
          * the getter function.
          * @default false
          */
-        getters?: 'get' | 'set' | boolean | undefined;
+        getters?: "get" | "set" | boolean | undefined;
         /**
          * If set to `true`, an underscore is used to separate every three digits in all bigints and numbers.
          * @default false
          */
         numericSeparator?: boolean | undefined;
     }
-    export type Style = 'special' | 'number' | 'bigint' | 'boolean' | 'undefined' | 'null' | 'string' | 'symbol' | 'date' | 'regexp' | 'module';
+    export type Style =
+        | "special"
+        | "number"
+        | "bigint"
+        | "boolean"
+        | "undefined"
+        | "null"
+        | "string"
+        | "symbol"
+        | "date"
+        | "regexp"
+        | "module";
     export type CustomInspectFunction = (depth: number, options: InspectOptionsStylized) => any; // TODO: , inspect: inspect
     export interface InspectOptionsStylized extends InspectOptions {
         stylize(text: string, styleType: Style): string;
@@ -970,40 +981,83 @@ declare module 'util' {
      * @return a callback style function
      */
     export function callbackify(fn: () => Promise<void>): (callback: (err: NodeJS.ErrnoException) => void) => void;
-    export function callbackify<TResult>(fn: () => Promise<TResult>): (callback: (err: NodeJS.ErrnoException, result: TResult) => void) => void;
-    export function callbackify<T1>(fn: (arg1: T1) => Promise<void>): (arg1: T1, callback: (err: NodeJS.ErrnoException) => void) => void;
-    export function callbackify<T1, TResult>(fn: (arg1: T1) => Promise<TResult>): (arg1: T1, callback: (err: NodeJS.ErrnoException, result: TResult) => void) => void;
-    export function callbackify<T1, T2>(fn: (arg1: T1, arg2: T2) => Promise<void>): (arg1: T1, arg2: T2, callback: (err: NodeJS.ErrnoException) => void) => void;
-    export function callbackify<T1, T2, TResult>(fn: (arg1: T1, arg2: T2) => Promise<TResult>): (arg1: T1, arg2: T2, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void;
-    export function callbackify<T1, T2, T3>(fn: (arg1: T1, arg2: T2, arg3: T3) => Promise<void>): (arg1: T1, arg2: T2, arg3: T3, callback: (err: NodeJS.ErrnoException) => void) => void;
+    export function callbackify<TResult>(
+        fn: () => Promise<TResult>,
+    ): (callback: (err: NodeJS.ErrnoException, result: TResult) => void) => void;
+    export function callbackify<T1>(
+        fn: (arg1: T1) => Promise<void>,
+    ): (arg1: T1, callback: (err: NodeJS.ErrnoException) => void) => void;
+    export function callbackify<T1, TResult>(
+        fn: (arg1: T1) => Promise<TResult>,
+    ): (arg1: T1, callback: (err: NodeJS.ErrnoException, result: TResult) => void) => void;
+    export function callbackify<T1, T2>(
+        fn: (arg1: T1, arg2: T2) => Promise<void>,
+    ): (arg1: T1, arg2: T2, callback: (err: NodeJS.ErrnoException) => void) => void;
+    export function callbackify<T1, T2, TResult>(
+        fn: (arg1: T1, arg2: T2) => Promise<TResult>,
+    ): (arg1: T1, arg2: T2, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void;
+    export function callbackify<T1, T2, T3>(
+        fn: (arg1: T1, arg2: T2, arg3: T3) => Promise<void>,
+    ): (arg1: T1, arg2: T2, arg3: T3, callback: (err: NodeJS.ErrnoException) => void) => void;
     export function callbackify<T1, T2, T3, TResult>(
-        fn: (arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>
+        fn: (arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>,
     ): (arg1: T1, arg2: T2, arg3: T3, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void;
     export function callbackify<T1, T2, T3, T4>(
-        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>
+        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>,
     ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: NodeJS.ErrnoException) => void) => void;
     export function callbackify<T1, T2, T3, T4, TResult>(
-        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>
-    ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void;
+        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>,
+    ): (
+        arg1: T1,
+        arg2: T2,
+        arg3: T3,
+        arg4: T4,
+        callback: (err: NodeJS.ErrnoException | null, result: TResult) => void,
+    ) => void;
     export function callbackify<T1, T2, T3, T4, T5>(
-        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>
+        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>,
     ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: NodeJS.ErrnoException) => void) => void;
     export function callbackify<T1, T2, T3, T4, T5, TResult>(
-        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>
-    ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void;
+        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>,
+    ): (
+        arg1: T1,
+        arg2: T2,
+        arg3: T3,
+        arg4: T4,
+        arg5: T5,
+        callback: (err: NodeJS.ErrnoException | null, result: TResult) => void,
+    ) => void;
     export function callbackify<T1, T2, T3, T4, T5, T6>(
-        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<void>
-    ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, callback: (err: NodeJS.ErrnoException) => void) => void;
+        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<void>,
+    ): (
+        arg1: T1,
+        arg2: T2,
+        arg3: T3,
+        arg4: T4,
+        arg5: T5,
+        arg6: T6,
+        callback: (err: NodeJS.ErrnoException) => void,
+    ) => void;
     export function callbackify<T1, T2, T3, T4, T5, T6, TResult>(
-        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<TResult>
-    ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void;
+        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<TResult>,
+    ): (
+        arg1: T1,
+        arg2: T2,
+        arg3: T3,
+        arg4: T4,
+        arg5: T5,
+        arg6: T6,
+        callback: (err: NodeJS.ErrnoException | null, result: TResult) => void,
+    ) => void;
     export interface CustomPromisifyLegacy<TCustom extends Function> extends Function {
         __promisify__: TCustom;
     }
     export interface CustomPromisifySymbol<TCustom extends Function> extends Function {
         [promisify.custom]: TCustom;
     }
-    export type CustomPromisify<TCustom extends Function> = CustomPromisifySymbol<TCustom> | CustomPromisifyLegacy<TCustom>;
+    export type CustomPromisify<TCustom extends Function> =
+        | CustomPromisifySymbol<TCustom>
+        | CustomPromisifyLegacy<TCustom>;
     /**
      * Takes a function following the common error-first callback style, i.e. taking
      * an `(err, value) => ...` callback as the last argument, and returns a version
@@ -1072,23 +1126,37 @@ declare module 'util' {
      * @since v8.0.0
      */
     export function promisify<TCustom extends Function>(fn: CustomPromisify<TCustom>): TCustom;
-    export function promisify<TResult>(fn: (callback: (err: any, result: TResult) => void) => void): () => Promise<TResult>;
+    export function promisify<TResult>(
+        fn: (callback: (err: any, result: TResult) => void) => void,
+    ): () => Promise<TResult>;
     export function promisify(fn: (callback: (err?: any) => void) => void): () => Promise<void>;
-    export function promisify<T1, TResult>(fn: (arg1: T1, callback: (err: any, result: TResult) => void) => void): (arg1: T1) => Promise<TResult>;
+    export function promisify<T1, TResult>(
+        fn: (arg1: T1, callback: (err: any, result: TResult) => void) => void,
+    ): (arg1: T1) => Promise<TResult>;
     export function promisify<T1>(fn: (arg1: T1, callback: (err?: any) => void) => void): (arg1: T1) => Promise<void>;
-    export function promisify<T1, T2, TResult>(fn: (arg1: T1, arg2: T2, callback: (err: any, result: TResult) => void) => void): (arg1: T1, arg2: T2) => Promise<TResult>;
-    export function promisify<T1, T2>(fn: (arg1: T1, arg2: T2, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2) => Promise<void>;
-    export function promisify<T1, T2, T3, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: TResult) => void) => void): (arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>;
-    export function promisify<T1, T2, T3>(fn: (arg1: T1, arg2: T2, arg3: T3, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2, arg3: T3) => Promise<void>;
+    export function promisify<T1, T2, TResult>(
+        fn: (arg1: T1, arg2: T2, callback: (err: any, result: TResult) => void) => void,
+    ): (arg1: T1, arg2: T2) => Promise<TResult>;
+    export function promisify<T1, T2>(
+        fn: (arg1: T1, arg2: T2, callback: (err?: any) => void) => void,
+    ): (arg1: T1, arg2: T2) => Promise<void>;
+    export function promisify<T1, T2, T3, TResult>(
+        fn: (arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: TResult) => void) => void,
+    ): (arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>;
+    export function promisify<T1, T2, T3>(
+        fn: (arg1: T1, arg2: T2, arg3: T3, callback: (err?: any) => void) => void,
+    ): (arg1: T1, arg2: T2, arg3: T3) => Promise<void>;
     export function promisify<T1, T2, T3, T4, TResult>(
-        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: any, result: TResult) => void) => void
+        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: any, result: TResult) => void) => void,
     ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>;
-    export function promisify<T1, T2, T3, T4>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>;
+    export function promisify<T1, T2, T3, T4>(
+        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err?: any) => void) => void,
+    ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>;
     export function promisify<T1, T2, T3, T4, T5, TResult>(
-        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: any, result: TResult) => void) => void
+        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: any, result: TResult) => void) => void,
     ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>;
     export function promisify<T1, T2, T3, T4, T5>(
-        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err?: any) => void) => void
+        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err?: any) => void) => void,
     ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>;
     export function promisify(fn: Function): Function;
     export namespace promisify {
@@ -1127,7 +1195,7 @@ declare module 'util' {
             options?: {
                 fatal?: boolean | undefined;
                 ignoreBOM?: boolean | undefined;
-            }
+            },
         );
         /**
          * Decodes the `input` and returns a string. If `options.stream` is `true`, any
@@ -1141,7 +1209,7 @@ declare module 'util' {
             input?: NodeJS.ArrayBufferView | ArrayBuffer | null,
             options?: {
                 stream?: boolean | undefined;
-            }
+            },
         ): string;
     }
     export interface EncodeIntoResult {
@@ -1195,7 +1263,7 @@ declare module 'util' {
          */
         encodeInto(src: string, dest: Uint8Array): EncodeIntoResult;
     }
-    import { TextDecoder as _TextDecoder, TextEncoder as _TextEncoder } from 'util';
+    import { TextDecoder as _TextDecoder, TextEncoder as _TextEncoder } from "util";
     global {
         /**
          * `TextDecoder` class is a global reference for `require('util').TextDecoder`
@@ -1205,8 +1273,7 @@ declare module 'util' {
         var TextDecoder: typeof globalThis extends {
             onmessage: any;
             TextDecoder: infer TextDecoder;
-        }
-            ? TextDecoder
+        } ? TextDecoder
             : typeof _TextDecoder;
         /**
          * `TextEncoder` class is a global reference for `require('util').TextEncoder`
@@ -1216,8 +1283,7 @@ declare module 'util' {
         var TextEncoder: typeof globalThis extends {
             onmessage: any;
             TextEncoder: infer TextEncoder;
-        }
-            ? TextEncoder
+        } ? TextEncoder
             : typeof _TextEncoder;
     }
 
@@ -1255,7 +1321,7 @@ declare module 'util' {
         /**
          * Type of argument.
          */
-        type: 'string' | 'boolean';
+        type: "string" | "boolean";
         /**
          * Whether this option can be provided multiple times.
          * If `true`, all values will be collected in an array.
@@ -1313,89 +1379,81 @@ declare module 'util' {
     This is technically incorrect but is a much nicer UX for the common case.
     The IfDefaultsTrue version is for things which default to true; the IfDefaultsFalse version is for things which default to false.
     */
-    type IfDefaultsTrue<T, IfTrue, IfFalse> = T extends true
-        ? IfTrue
-        : T extends false
-        ? IfFalse
+    type IfDefaultsTrue<T, IfTrue, IfFalse> = T extends true ? IfTrue
+        : T extends false ? IfFalse
         : IfTrue;
 
     // we put the `extends false` condition first here because `undefined` compares like `any` when `strictNullChecks: false`
-    type IfDefaultsFalse<T, IfTrue, IfFalse> = T extends false
-        ? IfFalse
-        : T extends true
-        ? IfTrue
+    type IfDefaultsFalse<T, IfTrue, IfFalse> = T extends false ? IfFalse
+        : T extends true ? IfTrue
         : IfFalse;
 
     type ExtractOptionValue<T extends ParseArgsConfig, O extends ParseArgsOptionConfig> = IfDefaultsTrue<
-        T['strict'],
-        O['type'] extends 'string' ? string : O['type'] extends 'boolean' ? boolean : string | boolean,
+        T["strict"],
+        O["type"] extends "string" ? string : O["type"] extends "boolean" ? boolean : string | boolean,
         string | boolean
     >;
 
     type ParsedValues<T extends ParseArgsConfig> =
-        & IfDefaultsTrue<T['strict'], unknown, { [longOption: string]: undefined | string | boolean }>
-        & (T['options'] extends ParseArgsOptionsConfig
-            ? {
-                -readonly [LongOption in keyof T['options']]: IfDefaultsFalse<
-                    T['options'][LongOption]['multiple'],
-                    undefined | Array<ExtractOptionValue<T, T['options'][LongOption]>>,
-                    undefined | ExtractOptionValue<T, T['options'][LongOption]>
+        & IfDefaultsTrue<T["strict"], unknown, { [longOption: string]: undefined | string | boolean }>
+        & (T["options"] extends ParseArgsOptionsConfig ? {
+                -readonly [LongOption in keyof T["options"]]: IfDefaultsFalse<
+                    T["options"][LongOption]["multiple"],
+                    undefined | Array<ExtractOptionValue<T, T["options"][LongOption]>>,
+                    undefined | ExtractOptionValue<T, T["options"][LongOption]>
                 >;
             }
             : {});
 
     type ParsedPositionals<T extends ParseArgsConfig> = IfDefaultsTrue<
-        T['strict'],
-        IfDefaultsFalse<T['allowPositionals'], string[], []>,
-        IfDefaultsTrue<T['allowPositionals'], string[], []>
+        T["strict"],
+        IfDefaultsFalse<T["allowPositionals"], string[], []>,
+        IfDefaultsTrue<T["allowPositionals"], string[], []>
     >;
 
     type PreciseTokenForOptions<
         K extends string,
         O extends ParseArgsOptionConfig,
-    > = O['type'] extends 'string'
-        ? {
-              kind: 'option';
-              index: number;
-              name: K;
-              rawName: string;
-              value: string;
-              inlineValue: boolean;
-          }
-        : O['type'] extends 'boolean'
-        ? {
-              kind: 'option';
-              index: number;
-              name: K;
-              rawName: string;
-              value: undefined;
-              inlineValue: undefined;
-          }
+    > = O["type"] extends "string" ? {
+            kind: "option";
+            index: number;
+            name: K;
+            rawName: string;
+            value: string;
+            inlineValue: boolean;
+        }
+        : O["type"] extends "boolean" ? {
+                kind: "option";
+                index: number;
+                name: K;
+                rawName: string;
+                value: undefined;
+                inlineValue: undefined;
+            }
         : OptionToken & { name: K };
 
     type TokenForOptions<
         T extends ParseArgsConfig,
-        K extends keyof T['options'] = keyof T['options'],
+        K extends keyof T["options"] = keyof T["options"],
     > = K extends unknown
-        ? T['options'] extends ParseArgsOptionsConfig
-            ? PreciseTokenForOptions<K & string, T['options'][K]>
-            : OptionToken
+        ? T["options"] extends ParseArgsOptionsConfig ? PreciseTokenForOptions<K & string, T["options"][K]>
+        : OptionToken
         : never;
 
-    type ParsedOptionToken<T extends ParseArgsConfig> = IfDefaultsTrue<T['strict'], TokenForOptions<T>, OptionToken>;
+    type ParsedOptionToken<T extends ParseArgsConfig> = IfDefaultsTrue<T["strict"], TokenForOptions<T>, OptionToken>;
 
     type ParsedPositionalToken<T extends ParseArgsConfig> = IfDefaultsTrue<
-        T['strict'],
-        IfDefaultsFalse<T['allowPositionals'], { kind: 'positional'; index: number; value: string }, never>,
-        IfDefaultsTrue<T['allowPositionals'], { kind: 'positional'; index: number; value: string }, never>
+        T["strict"],
+        IfDefaultsFalse<T["allowPositionals"], { kind: "positional"; index: number; value: string }, never>,
+        IfDefaultsTrue<T["allowPositionals"], { kind: "positional"; index: number; value: string }, never>
     >;
 
     type ParsedTokens<T extends ParseArgsConfig> = Array<
-        ParsedOptionToken<T> | ParsedPositionalToken<T> | { kind: 'option-terminator'; index: number }
+        ParsedOptionToken<T> | ParsedPositionalToken<T> | { kind: "option-terminator"; index: number }
     >;
 
     type PreciseParsedResults<T extends ParseArgsConfig> = IfDefaultsFalse<
-        T['tokens'],
+        T["tokens"],
         {
             values: ParsedValues<T>;
             positionals: ParsedPositionals<T>;
@@ -1408,31 +1466,30 @@ declare module 'util' {
     >;
 
     type OptionToken =
-        | { kind: 'option'; index: number; name: string; rawName: string; value: string; inlineValue: boolean }
+        | { kind: "option"; index: number; name: string; rawName: string; value: string; inlineValue: boolean }
         | {
-              kind: 'option';
-              index: number;
-              name: string;
-              rawName: string;
-              value: undefined;
-              inlineValue: undefined;
-          };
+            kind: "option";
+            index: number;
+            name: string;
+            rawName: string;
+            value: undefined;
+            inlineValue: undefined;
+        };
 
     type Token =
         | OptionToken
-        | { kind: 'positional'; index: number; value: string }
-        | { kind: 'option-terminator'; index: number };
+        | { kind: "positional"; index: number; value: string }
+        | { kind: "option-terminator"; index: number };
 
     // If ParseArgsConfig extends T, then the user passed config constructed elsewhere.
     // So we can't rely on the `"not definitely present" implies "definitely not present"` assumption mentioned above.
-    type ParsedResults<T extends ParseArgsConfig> = ParseArgsConfig extends T
-        ? {
-              values: {
-                  [longOption: string]: undefined | string | boolean | Array<string | boolean>;
-              };
-              positionals: string[];
-              tokens?: Token[];
-          }
+    type ParsedResults<T extends ParseArgsConfig> = ParseArgsConfig extends T ? {
+            values: {
+                [longOption: string]: undefined | string | boolean | Array<string | boolean>;
+            };
+            positionals: string[];
+            tokens?: Token[];
+        }
         : PreciseParsedResults<T>;
 
     /**
@@ -1589,11 +1646,11 @@ declare module 'util' {
         [Symbol.iterator]: typeof MIMEParams.prototype.entries;
     }
 }
-declare module 'util/types' {
-    export * from 'util/types';
+declare module "util/types" {
+    export * from "util/types";
 }
-declare module 'util/types' {
-    import { KeyObject, webcrypto } from 'node:crypto';
+declare module "util/types" {
+    import { KeyObject, webcrypto } from "node:crypto";
     /**
      * Returns `true` if the value is a built-in [`ArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) or
      * [`SharedArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer) instance.
@@ -1859,7 +1916,10 @@ declare module 'util/types' {
      * ```
      * @since v10.0.0
      */
-    function isMap<T>(object: T | {}): object is T extends ReadonlyMap<any, any> ? (unknown extends T ? never : ReadonlyMap<any, any>) : Map<unknown, unknown>;
+    function isMap<T>(
+        object: T | {},
+    ): object is T extends ReadonlyMap<any, any> ? (unknown extends T ? never : ReadonlyMap<any, any>)
+        : Map<unknown, unknown>;
     /**
      * Returns `true` if the value is an iterator returned for a built-in [`Map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map) instance.
      *
@@ -1973,7 +2033,9 @@ declare module 'util/types' {
      * ```
      * @since v10.0.0
      */
-    function isSet<T>(object: T | {}): object is T extends ReadonlySet<any> ? (unknown extends T ? never : ReadonlySet<any>) : Set<unknown>;
+    function isSet<T>(
+        object: T | {},
+    ): object is T extends ReadonlySet<any> ? (unknown extends T ? never : ReadonlySet<any>) : Set<unknown>;
     /**
      * Returns `true` if the value is an iterator returned for a built-in [`Set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set) instance.
      *
@@ -2108,9 +2170,9 @@ declare module 'util/types' {
      */
     function isCryptoKey(object: unknown): object is webcrypto.CryptoKey;
 }
-declare module 'node:util' {
-    export * from 'util';
+declare module "node:util" {
+    export * from "util";
 }
-declare module 'node:util/types' {
-    export * from 'util/types';
+declare module "node:util/types" {
+    export * from "util/types";
 }

node/v8.d.ts

@@ -6,8 +6,8 @@
  * ```
  * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/v8.js)
  */
-declare module 'v8' {
-    import { Readable } from 'node:stream';
+declare module "v8" {
+    import { Readable } from "node:stream";
     interface HeapSpaceInfo {
         space_name: string;
         space_size: number;
@@ -630,6 +630,6 @@ declare module 'v8' {
      */
     const promiseHooks: PromiseHooks;
 }
-declare module 'node:v8' {
-    export * from 'v8';
+declare module "node:v8" {
+    export * from "v8";
 }