@types/node 16.9.3 → 16.10.0

node/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for Node.js (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
 
 ### Additional Details
- * Last updated: Sun, 19 Sep 2021 09:01:21 GMT
+ * Last updated: Sat, 25 Sep 2021 09:01:23 GMT
  * Dependencies: none
  * Global values: `AbortController`, `AbortSignal`, `__dirname`, `__filename`, `console`, `exports`, `gc`, `global`, `module`, `process`, `require`
 

node/assert.d.ts

@@ -1,7 +1,7 @@
 /**
  * The `assert` module provides a set of assertion functions for verifying
  * invariants.
- * @see [source](https://github.com/nodejs/node/blob/v16.7.0/lib/assert.js)
+ * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/assert.js)
  */
 declare module 'assert' {
     /**

node/async_hooks.d.ts

@@ -6,7 +6,7 @@
  * import async_hooks from 'async_hooks';
  * ```
  * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v16.7.0/lib/async_hooks.js)
+ * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/async_hooks.js)
  */
 declare module 'async_hooks' {
     /**

node/buffer.d.ts

@@ -4,7 +4,7 @@
  *
  * The `Buffer` class is a subclass of JavaScript's [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) class and
  * extends it with methods that cover additional use cases. Node.js APIs accept
- * plain [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array)s wherever `Buffer`s are supported as well.
+ * plain [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) s wherever `Buffer`s are supported as well.
  *
  * While the `Buffer` class is available within the global scope, it is still
  * recommended to explicitly reference it via an import or require statement.
@@ -41,7 +41,7 @@
  * // Creates a Buffer containing the Latin-1 bytes [0x74, 0xe9, 0x73, 0x74].
  * const buf7 = Buffer.from('tést', 'latin1');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v16.7.0/lib/buffer.js)
+ * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/buffer.js)
  */
 declare module 'buffer' {
     import { BinaryLike } from 'node:crypto';
@@ -137,7 +137,7 @@ declare module 'buffer' {
          */
         constructor(sources: Array<BinaryLike | Blob>, options?: BlobOptions);
         /**
-         * Returns a promise that fulfills with an [&lt;ArrayBuffer&gt;](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) containing a copy of
+         * Returns a promise that fulfills with an [ArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) containing a copy of
          * the `Blob` data.
          * @since v15.7.0
          */

node/child_process.d.ts

@@ -60,7 +60,7 @@
  * For certain use cases, such as automating shell scripts, the `synchronous counterparts` may be more convenient. In many cases, however,
  * the synchronous methods can have significant impact on performance due to
  * stalling the event loop while spawned processes complete.
- * @see [source](https://github.com/nodejs/node/blob/v16.7.0/lib/child_process.js)
+ * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/child_process.js)
  */
 declare module 'child_process' {
     import { ObjectEncodingOptions } from 'node:fs';
@@ -70,6 +70,14 @@ declare module 'child_process' {
     import { URL } from 'node:url';
     type Serializable = string | object | number | boolean | bigint;
     type SendHandle = net.Socket | net.Server;
+    /**
+     * Instances of the `ChildProcess` represent spawned child processes.
+     *
+     * Instances of `ChildProcess` are not intended to be created directly. Rather,
+     * use the {@link spawn}, {@link exec},{@link execFile}, or {@link fork} methods to create
+     * instances of `ChildProcess`.
+     * @since v2.2.0
+     */
     class ChildProcess extends EventEmitter {
         /**
          * A `Writable Stream` that represents the child process's `stdin`.
@@ -236,8 +244,8 @@ declare module 'child_process' {
         readonly spawnfile: string;
         /**
          * The `subprocess.kill()` method sends a signal to the child process. If no
-         * argument is given, the process will be sent the `'SIGTERM'` signal. See[`signal(7)`](http://man7.org/linux/man-pages/man7/signal.7.html) for a list of available signals. This function
-         * returns `true` if[`kill(2)`](http://man7.org/linux/man-pages/man2/kill.2.html) succeeds, and `false` otherwise.
+         * argument is given, the process will be sent the `'SIGTERM'` signal. See [`signal(7)`](http://man7.org/linux/man-pages/man7/signal.7.html) for a list of available signals. This function
+         * returns `true` if [`kill(2)`](http://man7.org/linux/man-pages/man2/kill.2.html) succeeds, and `false` otherwise.
          *
          * ```js
          * const { spawn } = require('child_process');
@@ -799,7 +807,7 @@ declare module 'child_process' {
     /**
      * Spawns a shell then executes the `command` within that shell, buffering any
      * generated output. The `command` string passed to the exec function is processed
-     * directly by the shell and special characters (vary based on[shell](https://en.wikipedia.org/wiki/List_of_command-line_interpreters))
+     * directly by the shell and special characters (vary based on [shell](https://en.wikipedia.org/wiki/List_of_command-line_interpreters))
      * need to be dealt with accordingly:
      *
      * ```js
@@ -1271,12 +1279,13 @@ declare module 'child_process' {
      * @param args List of string arguments.
      */
     function spawnSync(command: string): SpawnSyncReturns<Buffer>;
-    function spawnSync(command: string, options?: SpawnSyncOptionsWithStringEncoding): SpawnSyncReturns<string>;
-    function spawnSync(command: string, options?: SpawnSyncOptionsWithBufferEncoding): SpawnSyncReturns<Buffer>;
-    function spawnSync(command: string, options?: SpawnSyncOptions): SpawnSyncReturns<Buffer>;
-    function spawnSync(command: string, args?: ReadonlyArray<string>, options?: SpawnSyncOptionsWithStringEncoding): SpawnSyncReturns<string>;
-    function spawnSync(command: string, args?: ReadonlyArray<string>, options?: SpawnSyncOptionsWithBufferEncoding): SpawnSyncReturns<Buffer>;
-    function spawnSync(command: string, args?: ReadonlyArray<string>, options?: SpawnSyncOptions): SpawnSyncReturns<Buffer>;
+    function spawnSync(command: string, options: SpawnSyncOptionsWithStringEncoding): SpawnSyncReturns<string>;
+    function spawnSync(command: string, options: SpawnSyncOptionsWithBufferEncoding): SpawnSyncReturns<Buffer>;
+    function spawnSync(command: string, options?: SpawnSyncOptions): SpawnSyncReturns<string | Buffer>;
+    function spawnSync(command: string, args: ReadonlyArray<string>): SpawnSyncReturns<Buffer>;
+    function spawnSync(command: string, args: ReadonlyArray<string>, options: SpawnSyncOptionsWithStringEncoding): SpawnSyncReturns<string>;
+    function spawnSync(command: string, args: ReadonlyArray<string>, options: SpawnSyncOptionsWithBufferEncoding): SpawnSyncReturns<Buffer>;
+    function spawnSync(command: string, args?: ReadonlyArray<string>, options?: SpawnSyncOptions): SpawnSyncReturns<string | Buffer>;
     interface CommonExecOptions extends CommonOptions {
         input?: string | NodeJS.ArrayBufferView | undefined;
         stdio?: StdioOptions | undefined;
@@ -1310,9 +1319,9 @@ declare module 'child_process' {
      * @return The stdout from the command.
      */
     function execSync(command: string): Buffer;
-    function execSync(command: string, options?: ExecSyncOptionsWithStringEncoding): string;
-    function execSync(command: string, options?: ExecSyncOptionsWithBufferEncoding): Buffer;
-    function execSync(command: string, options?: ExecSyncOptions): Buffer;
+    function execSync(command: string, options: ExecSyncOptionsWithStringEncoding): string;
+    function execSync(command: string, options: ExecSyncOptionsWithBufferEncoding): Buffer;
+    function execSync(command: string, options?: ExecSyncOptions): string | Buffer;
     interface ExecFileSyncOptions extends CommonExecOptions {
         shell?: boolean | string | undefined;
     }
@@ -1320,7 +1329,7 @@ declare module 'child_process' {
         encoding: BufferEncoding;
     }
     interface ExecFileSyncOptionsWithBufferEncoding extends ExecFileSyncOptions {
-        encoding: BufferEncoding; // specify `null`.
+        encoding?: 'buffer' | null; // specify `null`.
     }
     /**
      * The `child_process.execFileSync()` method is generally identical to {@link execFile} with the exception that the method will not
@@ -1343,12 +1352,13 @@ declare module 'child_process' {
      * @return The stdout from the command.
      */
     function execFileSync(file: string): Buffer;
-    function execFileSync(file: string, options?: ExecFileSyncOptionsWithStringEncoding): string;
-    function execFileSync(file: string, options?: ExecFileSyncOptionsWithBufferEncoding): Buffer;
-    function execFileSync(file: string, options?: ExecFileSyncOptions): Buffer;
-    function execFileSync(file: string, args?: ReadonlyArray<string>, options?: ExecFileSyncOptionsWithStringEncoding): string;
-    function execFileSync(file: string, args?: ReadonlyArray<string>, options?: ExecFileSyncOptionsWithBufferEncoding): Buffer;
-    function execFileSync(file: string, args?: ReadonlyArray<string>, options?: ExecFileSyncOptions): Buffer;
+    function execFileSync(file: string, options: ExecFileSyncOptionsWithStringEncoding): string;
+    function execFileSync(file: string, options: ExecFileSyncOptionsWithBufferEncoding): Buffer;
+    function execFileSync(file: string, options?: ExecFileSyncOptions): string | Buffer;
+    function execFileSync(file: string, args: ReadonlyArray<string>): Buffer;
+    function execFileSync(file: string, args: ReadonlyArray<string>, options: ExecFileSyncOptionsWithStringEncoding): string;
+    function execFileSync(file: string, args: ReadonlyArray<string>, options: ExecFileSyncOptionsWithBufferEncoding): Buffer;
+    function execFileSync(file: string, args?: ReadonlyArray<string>, options?: ExecFileSyncOptions): string | Buffer;
 }
 declare module 'node:child_process' {
     export * from 'child_process';

node/cluster.d.ts

@@ -49,7 +49,7 @@
  * ```
  *
  * On Windows, it is not yet possible to set up a named pipe server in a worker.
- * @see [source](https://github.com/nodejs/node/blob/v16.7.0/lib/cluster.js)
+ * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/cluster.js)
  */
 declare module 'cluster' {
     import * as child from 'node:child_process';

node/console.d.ts

@@ -53,7 +53,7 @@
  * myConsole.warn(`Danger ${name}! Danger!`);
  * // Prints: Danger Will Robinson! Danger!, to err
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v16.7.0/lib/console.js)
+ * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/console.js)
  */
 declare module 'console' {
     import console = require('node:console');

node/crypto.d.ts

@@ -13,7 +13,7 @@
  * // Prints:
  * //   c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v16.7.0/lib/crypto.js)
+ * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/crypto.js)
  */
 declare module 'crypto' {
     import * as stream from 'node:stream';
@@ -548,6 +548,22 @@ declare module 'crypto' {
     class KeyObject {
         private constructor();
         /**
+         * Example: Converting a `CryptoKey` instance to a `KeyObject`:
+         *
+         * ```js
+         * const { webcrypto, KeyObject } = await import('crypto');
+         * const { subtle } = webcrypto;
+         *
+         * const key = await subtle.generateKey({
+         *   name: 'HMAC',
+         *   hash: 'SHA-256',
+         *   length: 256
+         * }, true, ['sign', 'verify']);
+         *
+         * const keyObject = KeyObject.from(key);
+         * console.log(keyObject.symmetricKeySize);
+         * // Prints: 32 (symmetric key size in bytes)
+         * ```
          * @since v15.0.0
          */
         static from(key: webcrypto.CryptoKey): KeyObject;
@@ -660,7 +676,7 @@ declare module 'crypto' {
      * non-cryptographically secure hash algorithm allow passwords to be tested very
      * rapidly.
      *
-     * In line with OpenSSL's recommendation to use a more modern algorithm instead of[`EVP_BytesToKey`](https://www.openssl.org/docs/man1.1.0/crypto/EVP_BytesToKey.html) it is recommended that
+     * In line with OpenSSL's recommendation to use a more modern algorithm instead of [`EVP_BytesToKey`](https://www.openssl.org/docs/man1.1.0/crypto/EVP_BytesToKey.html) it is recommended that
      * developers derive a key and IV on
      * their own using {@link scrypt} and to use {@link createCipheriv} to create the `Cipher` object. Users should not use ciphers with counter mode
      * (e.g. CTR, GCM, or CCM) in `crypto.createCipher()`. A warning is emitted when
@@ -688,7 +704,7 @@ declare module 'crypto' {
      * recent OpenSSL releases, `openssl list -cipher-algorithms`(`openssl list-cipher-algorithms` for older versions of OpenSSL) will
      * display the available cipher algorithms.
      *
-     * The `key` is the raw key used by the `algorithm` and `iv` is an[initialization vector](https://en.wikipedia.org/wiki/Initialization_vector). Both arguments must be `'utf8'` encoded
+     * The `key` is the raw key used by the `algorithm` and `iv` is an [initialization vector](https://en.wikipedia.org/wiki/Initialization_vector). Both arguments must be `'utf8'` encoded
      * strings,`Buffers`, `TypedArray`, or `DataView`s. The `key` may optionally be
      * a `KeyObject` of type `secret`. If the cipher does not need
      * an initialization vector, `iv` may be `null`.
@@ -905,7 +921,7 @@ declare module 'crypto' {
      * non-cryptographically secure hash algorithm allow passwords to be tested very
      * rapidly.
      *
-     * In line with OpenSSL's recommendation to use a more modern algorithm instead of[`EVP_BytesToKey`](https://www.openssl.org/docs/man1.1.0/crypto/EVP_BytesToKey.html) it is recommended that
+     * In line with OpenSSL's recommendation to use a more modern algorithm instead of [`EVP_BytesToKey`](https://www.openssl.org/docs/man1.1.0/crypto/EVP_BytesToKey.html) it is recommended that
      * developers derive a key and IV on
      * their own using {@link scrypt} and to use {@link createDecipheriv} to create the `Decipher` object.
      * @since v0.1.94
@@ -929,7 +945,7 @@ declare module 'crypto' {
      * recent OpenSSL releases, `openssl list -cipher-algorithms`(`openssl list-cipher-algorithms` for older versions of OpenSSL) will
      * display the available cipher algorithms.
      *
-     * The `key` is the raw key used by the `algorithm` and `iv` is an[initialization vector](https://en.wikipedia.org/wiki/Initialization_vector). Both arguments must be `'utf8'` encoded
+     * The `key` is the raw key used by the `algorithm` and `iv` is an [initialization vector](https://en.wikipedia.org/wiki/Initialization_vector). Both arguments must be `'utf8'` encoded
      * strings,`Buffers`, `TypedArray`, or `DataView`s. The `key` may optionally be
      * a `KeyObject` of type `secret`. If the cipher does not need
      * an initialization vector, `iv` may be `null`.
@@ -1151,6 +1167,26 @@ declare module 'crypto' {
         },
         callback: (err: Error | null, key: KeyObject) => void
     ): void;
+    /**
+     * Synchronously generates a new random secret key of the given `length`. The`type` will determine which validations will be performed on the `length`.
+     *
+     * ```js
+     * const {
+     *   generateKeySync
+     * } = await import('crypto');
+     *
+     * const key = generateKeySync('hmac', 64);
+     * console.log(key.export().toString('hex'));  // e89..........41e
+     * ```
+     * @since v15.0.0
+     * @param type The intended use of the generated secret key. Currently accepted values are `'hmac'` and `'aes'`.
+     */
+    function generateKeySync(
+        type: 'hmac' | 'aes',
+        options: {
+            length: number;
+        }
+    ): KeyObject;
     interface JsonWebKeyInput {
         key: JsonWebKey;
         format: 'jwk';
@@ -1524,7 +1560,7 @@ declare module 'crypto' {
     }
     /**
      * Creates a predefined `DiffieHellmanGroup` key exchange object. The
-     * supported groups are: `'modp1'`, `'modp2'`, `'modp5'` (defined in[RFC 2412](https://www.rfc-editor.org/rfc/rfc2412.txt), but see `Caveats`) and `'modp14'`, `'modp15'`,`'modp16'`, `'modp17'`,
+     * supported groups are: `'modp1'`, `'modp2'`, `'modp5'` (defined in [RFC 2412](https://www.rfc-editor.org/rfc/rfc2412.txt), but see `Caveats`) and `'modp14'`, `'modp15'`,`'modp16'`, `'modp17'`,
      * `'modp18'` (defined in [RFC 3526](https://www.rfc-editor.org/rfc/rfc3526.txt)). The
      * returned object mimics the interface of objects created by {@link createDiffieHellman}, but will not allow changing
      * the keys (with `diffieHellman.setPublicKey()`, for example). The
@@ -2209,7 +2245,7 @@ declare module 'crypto' {
      * This function is based on a constant-time algorithm.
      * Returns true if `a` is equal to `b`, without leaking timing information that
      * would allow an attacker to guess one of the values. This is suitable for
-     * comparing HMAC digests or secret values like authentication cookies or[capability urls](https://www.w3.org/TR/capability-urls/).
+     * comparing HMAC digests or secret values like authentication cookies or [capability urls](https://www.w3.org/TR/capability-urls/).
      *
      * `a` and `b` must both be `Buffer`s, `TypedArray`s, or `DataView`s, and they
      * must have the same byte length.
@@ -2243,7 +2279,7 @@ declare module 'crypto' {
     interface X448KeyPairKeyObjectOptions {}
     interface ECKeyPairKeyObjectOptions {
         /**
-         * Name of the curve to use.
+         * Name of the curve to use
          */
         namedCurve: string;
     }
@@ -2253,6 +2289,7 @@ declare module 'crypto' {
          */
         modulusLength: number;
         /**
+         * Public exponent
          * @default 0x10001
          */
         publicExponent?: number | undefined;
@@ -2263,9 +2300,22 @@ declare module 'crypto' {
          */
         modulusLength: number;
         /**
+         * Public exponent
          * @default 0x10001
          */
         publicExponent?: number | undefined;
+        /**
+         * Name of the message digest
+         */
+        hashAlgorithm?: string;
+        /**
+         * Name of the message digest used by MGF1
+         */
+        mgf1HashAlgorithm?: string;
+        /**
+         * Minimal salt length in bytes
+         */
+        saltLength?: string;
     }
     interface DSAKeyPairKeyObjectOptions {
         /**
@@ -2283,6 +2333,7 @@ declare module 'crypto' {
          */
         modulusLength: number;
         /**
+         * Public exponent
          * @default 0x10001
          */
         publicExponent?: number | undefined;
@@ -2300,9 +2351,22 @@ declare module 'crypto' {
          */
         modulusLength: number;
         /**
+         * Public exponent
          * @default 0x10001
          */
         publicExponent?: number | undefined;
+        /**
+         * Name of the message digest
+         */
+        hashAlgorithm?: string;
+        /**
+         * Name of the message digest used by MGF1
+         */
+        mgf1HashAlgorithm?: string;
+        /**
+         * Minimal salt length in bytes
+         */
+        saltLength?: string;
         publicKeyEncoding: {
             type: 'spki';
             format: PubF;
@@ -2382,8 +2446,8 @@ declare module 'crypto' {
         privateKey: T2;
     }
     /**
-     * Generates a new asymmetric key pair of the given `type`. RSA, DSA, EC, Ed25519,
-     * Ed448, X25519, X448, and DH are currently supported.
+     * Generates a new asymmetric key pair of the given `type`. RSA, RSA-PSS, DSA, EC,
+     * Ed25519, Ed448, X25519, X448, and DH are currently supported.
      *
      * If a `publicKeyEncoding` or `privateKeyEncoding` was specified, this function
      * behaves as if `keyObject.export()` had been called on its result. Otherwise,
@@ -2463,8 +2527,8 @@ declare module 'crypto' {
     function generateKeyPairSync(type: 'x448', options: X448KeyPairOptions<'der', 'der'>): KeyPairSyncResult<Buffer, Buffer>;
     function generateKeyPairSync(type: 'x448', options?: X448KeyPairKeyObjectOptions): KeyPairKeyObjectResult;
     /**
-     * Generates a new asymmetric key pair of the given `type`. RSA, DSA, EC, Ed25519,
-     * Ed448, X25519, X448, and DH are currently supported.
+     * Generates a new asymmetric key pair of the given `type`. RSA, RSA-PSS, DSA, EC,
+     * Ed25519, Ed448, X25519, X448, and DH are currently supported.
      *
      * If a `publicKeyEncoding` or `privateKeyEncoding` was specified, this function
      * behaves as if `keyObject.export()` had been called on its result. Otherwise,
@@ -2499,7 +2563,7 @@ declare module 'crypto' {
      * If this method is invoked as its `util.promisify()` ed version, it returns
      * a `Promise` for an `Object` with `publicKey` and `privateKey` properties.
      * @since v10.12.0
-     * @param type Must be `'rsa'`, `'dsa'`, `'ec'`, `'ed25519'`, `'ed448'`, `'x25519'`, `'x448'`, or `'dh'`.
+     * @param type Must be `'rsa'`, `'rsa-pss'`, `'dsa'`, `'ec'`, `'ed25519'`, `'ed448'`, `'x25519'`, `'x448'`, or `'dh'`.
      */
     function generateKeyPair(type: 'rsa', options: RSAKeyPairOptions<'pem', 'pem'>, callback: (err: Error | null, publicKey: string, privateKey: string) => void): void;
     function generateKeyPair(type: 'rsa', options: RSAKeyPairOptions<'pem', 'der'>, callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void): void;
@@ -2880,7 +2944,7 @@ declare module 'crypto' {
      *
      * The supplied `callback` function is called with two arguments: `err` and`derivedKey`. If an errors occurs while deriving the key, `err` will be set;
      * otherwise `err` will be `null`. The successfully generated `derivedKey` will
-     * be passed to the callback as an [&lt;ArrayBuffer&gt;](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer). An error will be thrown if any
+     * be passed to the callback as an [ArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer). An error will be thrown if any
      * of the input arguments specify invalid values or types.
      *
      * ```js
@@ -2907,7 +2971,7 @@ declare module 'crypto' {
      * Provides a synchronous HKDF key derivation function as defined in RFC 5869\. The
      * given `ikm`, `salt` and `info` are used with the `digest` to derive a key of`keylen` bytes.
      *
-     * The successfully generated `derivedKey` will be returned as an [&lt;ArrayBuffer&gt;](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer).
+     * The successfully generated `derivedKey` will be returned as an [ArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer).
      *
      * An error will be thrown if any of the input arguments specify invalid values or
      * types, or if the derived key cannot be generated.
@@ -3169,8 +3233,8 @@ declare module 'crypto' {
      * if given as an `ArrayBuffer`, `SharedArrayBuffer`, `TypedArray`, `Buffer`, or`DataView`.
      *
      * By default, the prime is encoded as a big-endian sequence of octets
-     * in an [&lt;ArrayBuffer&gt;](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer). If the `bigint` option is `true`, then a
-     * [&lt;bigint&gt;](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt)is provided.
+     * in an [ArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer). If the `bigint` option is `true`, then a
+     * [bigint](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt) is provided.
      * @since v15.8.0
      * @param size The size (in bits) of the prime to generate.
      */
@@ -3200,8 +3264,8 @@ declare module 'crypto' {
      * if given as an `ArrayBuffer`, `SharedArrayBuffer`, `TypedArray`, `Buffer`, or`DataView`.
      *
      * By default, the prime is encoded as a big-endian sequence of octets
-     * in an [&lt;ArrayBuffer&gt;](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer). If the `bigint` option is `true`, then a
-     * [&lt;bigint&gt;](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt)is provided.
+     * in an [ArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer). If the `bigint` option is `true`, then a
+     * [bigint](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt) is provided.
      * @since v15.8.0
      * @param size The size (in bits) of the prime to generate.
      */

node/dgram.d.ts

@@ -23,7 +23,7 @@
  * server.bind(41234);
  * // Prints: server listening 0.0.0.0:41234
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v16.7.0/lib/dgram.js)
+ * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/dgram.js)
  */
 declare module 'dgram' {
     import { AddressInfo } from 'node:net';
@@ -350,7 +350,7 @@ declare module 'dgram' {
          */
         setBroadcast(flag: boolean): void;
         /**
-         * _All references to scope in this section are referring to[IPv6 Zone Indices](https://en.wikipedia.org/wiki/IPv6_address#Scoped_literal_IPv6_addresses), which are defined by [RFC
+         * _All references to scope in this section are referring to [IPv6 Zone Indices](https://en.wikipedia.org/wiki/IPv6_address#Scoped_literal_IPv6_addresses), which are defined by [RFC
          * 4007](https://tools.ietf.org/html/rfc4007). In string form, an IP_
          * _with a scope index is written as `'IP%scope'` where scope is an interface name_
          * _or interface number._

node/diagnostics_channel.d.ts

@@ -20,7 +20,7 @@
  * should generally include the module name to avoid collisions with data from
  * other modules.
  * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v16.7.0/lib/diagnostics_channel.js)
+ * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/diagnostics_channel.js)
  */
 declare module 'diagnostics_channel' {
     /**

node/dns/promises.d.ts

@@ -323,7 +323,7 @@ declare module 'dns/promises' {
      * The `dnsPromises.setServers()` method must not be called while a DNS query is in
      * progress.
      *
-     * This method works much like[resolve.conf](https://man7.org/linux/man-pages/man5/resolv.conf.5.html).
+     * This method works much like [resolve.conf](https://man7.org/linux/man-pages/man5/resolv.conf.5.html).
      * That is, if attempting to resolve with the first server provided results in a`NOTFOUND` error, the `resolve()` method will _not_ attempt to resolve with
      * subsequent servers provided. Fallback DNS servers will only be used if the
      * earlier ones time out or result in some other error.

node/dns.d.ts

@@ -42,7 +42,7 @@
  * ```
  *
  * See the `Implementation considerations section` for more information.
- * @see [source](https://github.com/nodejs/node/blob/v16.7.0/lib/dns.js)
+ * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/dns.js)
  */
 declare module 'dns' {
     import * as dnsPromises from 'node:dns/promises';
@@ -502,7 +502,7 @@ declare module 'dns' {
      *
      * The {@link setServers} method affects only {@link resolve},`dns.resolve*()` and {@link reverse} (and specifically _not_ {@link lookup}).
      *
-     * This method works much like[resolve.conf](https://man7.org/linux/man-pages/man5/resolv.conf.5.html).
+     * This method works much like [resolve.conf](https://man7.org/linux/man-pages/man5/resolv.conf.5.html).
      * That is, if attempting to resolve with the first server provided results in a`NOTFOUND` error, the `resolve()` method will _not_ attempt to resolve with
      * subsequent servers provided. Fallback DNS servers will only be used if the
      * earlier ones time out or result in some other error.

node/domain.d.ts

@@ -11,7 +11,7 @@
  * will be notified, rather than losing the context of the error in the`process.on('uncaughtException')` handler, or causing the program to
  * exit immediately with an error code.
  * @deprecated Since v1.4.2 - Deprecated
- * @see [source](https://github.com/nodejs/node/blob/v16.7.0/lib/domain.js)
+ * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/domain.js)
  */
 declare module 'domain' {
     import EventEmitter = require('node:events');

node/events.d.ts

@@ -32,7 +32,7 @@
  * });
  * myEmitter.emit('event');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v16.7.0/lib/events.js)
+ * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/events.js)
  */
 declare module 'events' {
     interface EventEmitterOptions {
@@ -78,7 +78,7 @@ declare module 'events' {
          * The `Promise` will resolve with an array of all the arguments emitted to the
          * given event.
          *
-         * This method is intentionally generic and works with the web platform[EventTarget](https://dom.spec.whatwg.org/#interface-eventtarget) interface, which has no special`'error'` event
+         * This method is intentionally generic and works with the web platform [EventTarget](https://dom.spec.whatwg.org/#interface-eventtarget) interface, which has no special`'error'` event
          * semantics and does not listen to the `'error'` event.
          *
          * ```js