YML formatting options

src/util.d.ts

@@ -105,7 +105,10 @@ declare module "util" {
     | "date"
     | "regexp"
     | "module";
-    export type CustomInspectFunction = (depth: number, options: InspectOptionsStylized) => any; // TODO: , inspect: inspect
+  export type CustomInspectFunction = (
+    depth: number,
+    options: InspectOptionsStylized,
+  ) => unknown; // TODO: , inspect: inspect
   export interface InspectOptionsStylized extends InspectOptions {
     stylize(text: string, styleType: Style): string;
   }
@@ -154,7 +157,10 @@ declare module "util" {
    * @since v0.5.3
    * @param format A `printf`-like format string.
    */
-    export function format(format?: any, ...param: any[]): string;
+  export function format(
+    format?: string,
+    ...param: (string | number | boolean)[]
+  ): string;
   /**
    * This function is identical to {@link format}, except in that it takes
    * an `inspectOptions` argument which specifies options that are passed along to {@link inspect}.
@@ -166,7 +172,11 @@ declare module "util" {
    * ```
    * @since v10.0.0
    */
-    export function formatWithOptions(inspectOptions: InspectOptions, format?: any, ...param: any[]): string;
+  export function formatWithOptions<T extends unknown[]>(
+    inspectOptions: InspectOptions,
+    format?: string,
+    ...param: T
+  ): string;
   /**
    * Returns the string name for a numeric error code that comes from a Node.js API.
    * The mapping between error codes and error names is platform-dependent.
@@ -261,7 +271,10 @@ declare module "util" {
    * @experimental
    * @param resource Any non-null entity, reference to which is held weakly.
    */
-    export function aborted(signal: AbortSignal, resource: any): Promise<void>;
+  export function aborted(
+    signal: AbortSignal,
+    resource: unknown,
+  ): Promise<void>;
   /**
    * 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
@@ -437,8 +450,13 @@ declare module "util" {
    * @param object Any JavaScript primitive or `Object`.
    * @return The representation of `object`.
    */
-    export function inspect(object: any, showHidden?: boolean, depth?: number | null, color?: boolean): string;
+  export function inspect(
-    export function inspect(object: any, options?: InspectOptions): string;
+    object: unknown,
+    showHidden?: boolean,
+    depth?: number | null,
+    color?: boolean,
+  ): string;
+  export function inspect(object: unknown, options?: InspectOptions): string;
   export namespace inspect {
     let colors: NodeJS.Dict<[number, number]>;
     let styles: {
@@ -595,7 +613,10 @@ declare module "util" {
    * @since v0.3.0
    * @legacy Use ES2015 class syntax and `extends` keyword instead.
    */
-    export function inherits(constructor: unknown, superConstructor: unknown): void;
+  export function inherits(
+    constructor: unknown,
+    superConstructor: unknown,
+  ): void;
   export type DebugLoggerFunction = (msg: string, ...param: unknown[]) => void;
   export interface DebugLogger extends DebugLoggerFunction {
     enabled: boolean;
@@ -657,7 +678,10 @@ declare module "util" {
    * @param callback A callback invoked the first time the logging function is called with a function argument that is a more optimized logging function.
    * @return The logging function
    */
-    export function debuglog(section: string, callback?: (fn: DebugLoggerFunction) => void): DebugLogger;
+  export function debuglog(
+    section: string,
+    callback?: (fn: DebugLoggerFunction) => void,
+  ): DebugLogger;
   export const debug: typeof debuglog;
   /**
    * Returns `true` if the given `object` is a `Boolean`. Otherwise, returns `false`.
@@ -747,7 +771,9 @@ declare module "util" {
    * @since v0.11.5
    * @deprecated Since v4.0.0 - Use `value === undefined || value === null` instead.
    */
-    export function isNullOrUndefined(object: unknown): object is null | undefined;
+  export function isNullOrUndefined(
+    object: unknown,
+  ): object is null | undefined;
   /**
    * Returns `true` if the given `object` is a `Number`. Otherwise, returns `false`.
    *
@@ -918,7 +944,11 @@ declare module "util" {
    * @param code A deprecation code. See the `list of deprecated APIs` for a list of codes.
    * @return The deprecated function wrapped to emit a warning.
    */
-    export function deprecate<T extends Function>(fn: T, msg: string, code?: string): T;
+  export function deprecate<T extends (...args: unknown[]) => unknown>(
+    fn: T,
+    msg: string,
+    code?: string,
+  ): T;
   /**
    * Returns `true` if there is deep strict equality between `val1` and `val2`.
    * Otherwise, returns `false`.
@@ -987,7 +1017,9 @@ declare module "util" {
    * @param fn An `async` function
    * @return a callback style function
    */
-    export function callbackify(fn: () => Promise<void>): (callback: (err: NodeJS.ErrnoException) => void) => void;
+  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;
@@ -996,22 +1028,49 @@ declare module "util" {
   ): (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;
+  ): (
+    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;
+  ): (
+    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;
+  ): (
+    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;
+  ): (
+    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>,
-    ): (arg1: T1, arg2: T2, arg3: T3, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void;
+  ): (
+    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>,
-    ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: NodeJS.ErrnoException) => void) => 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>,
   ): (
@@ -1023,7 +1082,14 @@ declare module "util" {
   ) => void;
   export function callbackify<T1, T2, T3, T4, T5>(
     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;
+  ): (
+    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>,
   ): (
@@ -1035,7 +1101,14 @@ declare module "util" {
     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>,
+    fn: (
+      arg1: T1,
+      arg2: T2,
+      arg3: T3,
+      arg4: T4,
+      arg5: T5,
+      arg6: T6,
+    ) => Promise<void>,
   ): (
     arg1: T1,
     arg2: T2,
@@ -1046,7 +1119,14 @@ declare module "util" {
     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>,
+    fn: (
+      arg1: T1,
+      arg2: T2,
+      arg3: T3,
+      arg4: T4,
+      arg5: T5,
+      arg6: T6,
+    ) => Promise<TResult>,
   ): (
     arg1: T1,
     arg2: T2,
@@ -1056,15 +1136,21 @@ declare module "util" {
     arg6: T6,
     callback: (err: NodeJS.ErrnoException | null, result: TResult) => void,
   ) => void;
-    export interface CustomPromisifyLegacy<TCustom extends Function> extends Function {
+  export interface CustomPromisifyLegacy<
+    TCustom extends (...args: unknown[]) => unknown,
+  > {
+    (...args: unknown[]): unknown;
     __promisify__: TCustom;
   }
-    export interface CustomPromisifySymbol<TCustom extends Function> extends Function {
+  export interface CustomPromisifySymbol<
+    TCustom extends (...args: unknown[]) => unknown,
+  > {
+    (...args: unknown[]): unknown;
     [promisify.custom]: TCustom;
   }
-    export type CustomPromisify<TCustom extends Function> =
+  export type CustomPromisify<TCustom extends (...args: unknown[]) => unknown> =
-        | CustomPromisifySymbol<TCustom>
+    CustomPromisifySymbol<TCustom> | CustomPromisifyLegacy<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
@@ -1134,40 +1220,88 @@ declare module "util" {
    * ```
    * @since v8.0.0
    */
-    export function promisify<TCustom extends Function>(fn: CustomPromisify<TCustom>): TCustom;
+  export function promisify<TCustom extends (...args: unknown[]) => unknown>(
+    fn: CustomPromisify<TCustom>,
+  ): TCustom;
   export function promisify<TResult>(
-        fn: (callback: (err: any, result: TResult) => void) => void,
+    fn: (callback: (err: unknown, result: TResult) => void) => void,
   ): () => Promise<TResult>;
-    export function promisify(fn: (callback: (err?: any) => void) => void): () => Promise<void>;
+  export function promisify(
+    fn: (callback: (err?: unknown) => void) => void,
+  ): () => Promise<void>;
   export function promisify<T1, TResult>(
-        fn: (arg1: T1, callback: (err: any, result: TResult) => void) => void,
+    fn: (arg1: T1, callback: (err: unknown, 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>(
+    fn: (arg1: T1, callback: (err?: unknown) => void) => void,
+  ): (arg1: T1) => Promise<void>;
   export function promisify<T1, T2, TResult>(
-        fn: (arg1: T1, arg2: T2, callback: (err: any, result: TResult) => void) => void,
+    fn: (
+      arg1: T1,
+      arg2: T2,
+      callback: (err: unknown, 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,
+    fn: (arg1: T1, arg2: T2, callback: (err?: unknown) => 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,
+    fn: (
+      arg1: T1,
+      arg2: T2,
+      arg3: T3,
+      callback: (err: unknown, 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,
+    fn: (
+      arg1: T1,
+      arg2: T2,
+      arg3: T3,
+      callback: (err?: unknown) => 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: unknown, 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,
+    fn: (
+      arg1: T1,
+      arg2: T2,
+      arg3: T3,
+      arg4: T4,
+      callback: (err?: unknown) => 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: unknown, 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?: unknown) => void,
+    ) => void,
   ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>;
-    export function promisify(fn: Function): Function;
+  export function promisify<T extends (...args: unknown[]) => void>(
+    fn: T,
+  ): (...funcArgs: Parameters<T>) => Promise<void>;
   export namespace promisify {
     /**
      * That can be used to declare custom promisified variants of functions.
@@ -1272,27 +1406,32 @@ 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`
      * https://nodejs.org/api/globals.html#textdecoder
      * @since v11.0.0
      */
-        var TextDecoder: typeof globalThis extends {
+    let TextDecoder: typeof globalThis extends {
-            onmessage: any;
+      onmessage: unknown;
       TextDecoder: infer TextDecoder;
-        } ? TextDecoder
+    }
+      ? TextDecoder
       : typeof _TextDecoder;
     /**
      * `TextEncoder` class is a global reference for `require('util').TextEncoder`
      * https://nodejs.org/api/globals.html#textencoder
      * @since v11.0.0
      */
-        var TextEncoder: typeof globalThis extends {
+    let TextEncoder: typeof globalThis extends {
-            onmessage: any;
+      onmessage: unknown;
       TextEncoder: infer TextEncoder;
-        } ? TextEncoder
+    }
+      ? TextEncoder
       : typeof _TextEncoder;
   }
 
@@ -1325,7 +1464,9 @@ declare module "util" {
    * @param config Used to provide arguments for parsing and to configure the parser. `config` supports the following properties:
    * @return The parsed command line arguments:
    */
-    export function parseArgs<T extends ParseArgsConfig>(config?: T): ParsedResults<T>;
+  export function parseArgs<T extends ParseArgsConfig>(
+    config?: T,
+  ): ParsedResults<T>;
   interface ParseArgsOptionConfig {
     /**
      * Type of argument.
@@ -1388,31 +1529,46 @@ 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
+  type IfDefaultsTrue<T, IfTrue, IfFalse> = T extends true
-        : T extends false ? IfFalse
+    ? 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
+  type IfDefaultsFalse<T, IfTrue, IfFalse> = T extends false
-        : T extends true ? IfTrue
+    ? IfFalse
+    : T extends true
+      ? IfTrue
       : IfFalse;
 
-    type ExtractOptionValue<T extends ParseArgsConfig, O extends ParseArgsOptionConfig> = IfDefaultsTrue<
+  type ExtractOptionValue<
+    T extends ParseArgsConfig,
+    O extends ParseArgsOptionConfig,
+  > = IfDefaultsTrue<
     T["strict"],
-        O["type"] extends "string" ? string : O["type"] extends "boolean" ? boolean : string | boolean,
+    O["type"] extends "string"
+      ? string
+      : O["type"] extends "boolean"
+        ? boolean
+        : string | boolean,
     string | boolean
   >;
 
-    type ParsedValues<T extends ParseArgsConfig> =
+  type ParsedValues<T extends ParseArgsConfig> = IfDefaultsTrue<
-        & IfDefaultsTrue<T["strict"], unknown, { [longOption: string]: undefined | string | boolean }>
+    T["strict"],
-        & (T["options"] extends ParseArgsOptionsConfig ? {
+    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]>
           >;
         }
-            : {});
+      : object);
 
   type ParsedPositionals<T extends ParseArgsConfig> = IfDefaultsTrue<
     T["strict"],
@@ -1423,7 +1579,8 @@ declare module "util" {
   type PreciseTokenForOptions<
     K extends string,
     O extends ParseArgsOptionConfig,
-    > = O["type"] extends "string" ? {
+  > = O["type"] extends "string"
+    ? {
         kind: "option";
         index: number;
         name: K;
@@ -1431,7 +1588,8 @@ declare module "util" {
         value: string;
         inlineValue: boolean;
       }
-        : O["type"] extends "boolean" ? {
+    : O["type"] extends "boolean"
+      ? {
           kind: "option";
           index: number;
           name: K;
@@ -1445,20 +1603,35 @@ declare module "util" {
     T extends ParseArgsConfig,
     K extends keyof T["options"] = keyof T["options"],
   > = K extends unknown
-        ? T["options"] extends ParseArgsOptionsConfig ? PreciseTokenForOptions<K & string, T["options"][K]>
+    ? 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>,
+    IfDefaultsFalse<
-        IfDefaultsTrue<T["allowPositionals"], { kind: "positional"; index: number; value: string }, never>
+      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<
@@ -1475,7 +1648,14 @@ 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;
@@ -1492,9 +1672,14 @@ declare module "util" {
 
   // 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 ? {
+  type ParsedResults<T extends ParseArgsConfig> = ParseArgsConfig extends T
+    ? {
         values: {
-                [longOption: string]: undefined | string | boolean | Array<string | boolean>;
+          [longOption: string]:
+            | undefined
+            | string
+            | boolean
+            | Array<string | boolean>;
         };
         positionals: string[];
         tokens?: Token[];
@@ -1754,7 +1939,7 @@ declare module "util/types" {
    * ```
    * @since v10.0.0
    */
-    function isBooleanObject(object: unknown): object is Boolean;
+  function isBooleanObject(object: unknown): object is boolean;
   /**
    * Returns `true` if the value is any boxed primitive object, e.g. created
    * by `new Boolean()`, `new String()` or `Object(Symbol())`.
@@ -1770,7 +1955,9 @@ declare module "util/types" {
    * ```
    * @since v10.11.0
    */
-    function isBoxedPrimitive(object: unknown): object is String | Number | BigInt | Boolean | Symbol;
+  function isBoxedPrimitive(
+    object: unknown,
+  ): object is string | number | bigint | boolean | symbol;
   /**
    * Returns `true` if the value is a built-in [`DataView`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView) instance.
    *
@@ -1923,8 +2110,11 @@ declare module "util/types" {
    * @since v10.0.0
    */
   function isMap<T>(
-        object: T | {},
+    object: T | object,
-    ): object is T extends ReadonlyMap<any, any> ? (unknown extends T ? never : ReadonlyMap<any, any>)
+  ): object is T extends ReadonlyMap<unknown, unknown>
+    ? unknown extends T
+      ? never
+      : ReadonlyMap<unknown, unknown>
     : 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.
@@ -1962,7 +2152,7 @@ declare module "util/types" {
    * Subclasses of the native error types are also native errors:
    *
    * ```js
-     * class MyError extends Error {}
+   * class MyError extends Error object
    * console.log(util.types.isNativeError(new MyError()));  // true
    * ```
    *
@@ -1971,7 +2161,7 @@ declare module "util/types" {
    *
    * ```js
    * const vm = require('node:vm');
-     * const context = vm.createContext({});
+   * const context = vm.createContext(object);
    * const myError = vm.runInContext('new Error()', context);
    * console.log(util.types.isNativeError(myError)); // true
    * console.log(myError instanceof Error); // false
@@ -1999,7 +2189,7 @@ declare module "util/types" {
    * ```
    * @since v10.0.0
    */
-    function isNumberObject(object: unknown): object is Number;
+  function isNumberObject(object: unknown): object is number;
   /**
    * Returns `true` if the value is a built-in [`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise).
    *
@@ -2040,8 +2230,12 @@ declare module "util/types" {
    * @since v10.0.0
    */
   function isSet<T>(
-        object: T | {},
+    object: T | object,
-    ): object is T extends ReadonlySet<any> ? (unknown extends T ? never : ReadonlySet<any>) : Set<unknown>;
+  ): object is T extends ReadonlySet<unknown>
+    ? unknown extends T
+      ? never
+      : ReadonlySet<unknown>
+    : 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.
    *
@@ -2077,7 +2271,7 @@ declare module "util/types" {
    * ```
    * @since v10.0.0
    */
-    function isStringObject(object: unknown): object is String;
+  function isStringObject(object: unknown): object is string;
   /**
    * Returns `true` if the value is a symbol object, created
    * by calling `Object()` on a `Symbol` primitive.
@@ -2089,7 +2283,7 @@ declare module "util/types" {
    * ```
    * @since v10.0.0
    */
-    function isSymbolObject(object: unknown): object is Symbol;
+  function isSymbolObject(object: unknown): object is symbol;
   /**
    * Returns `true` if the value is a built-in [`TypedArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray) instance.
    *