@types/node 16.4.14 → 16.7.0

node/buffer.d.ts

@@ -6,10 +6,12 @@
  * 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.
  *
- * The `Buffer` class is within the global scope, making it unlikely that one
- * would need to ever use `require('buffer').Buffer`.
+ * While the `Buffer` class is available within the global scope, it is still
+ * recommended to explicitly reference it via an import or require statement.
  *
  * ```js
+ * import { Buffer } from 'buffer';
+ *
  * // Creates a zero-filled Buffer of length 10.
  * const buf1 = Buffer.alloc(10);
  *
@@ -39,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.4.2/lib/buffer.js)
+ * @see [source](https://github.com/nodejs/node/blob/v16.7.0/lib/buffer.js)
  */
 declare module 'buffer' {
     import { BinaryLike } from 'node:crypto';
@@ -64,9 +66,9 @@ declare module 'buffer' {
      * sequence cannot be adequately represented in the target encoding. For instance:
      *
      * ```js
-     * const buffer = require('buffer');
+     * import { Buffer, transcode } from 'buffer';
      *
-     * const newBuf = buffer.transcode(Buffer.from('€'), 'utf8', 'ascii');
+     * const newBuf = transcode(Buffer.from('€'), 'utf8', 'ascii');
      * console.log(newBuf.toString('ascii'));
      * // Prints: '?'
      * ```
@@ -84,6 +86,14 @@ declare module 'buffer' {
         new (size: number): Buffer;
         prototype: Buffer;
     };
+    /**
+     * Resolves a `'blob:nodedata:...'` an associated `Blob` object registered using
+     * a prior call to `URL.createObjectURL()`.
+     * @since v16.7.0
+     * @experimental
+     * @param id A `'blob:nodedata:...` URL string returned by a prior call to `URL.createObjectURL()`.
+     */
+    export function resolveObjectURL(id: string): Blob | undefined;
     export { Buffer };
     /**
      * @experimental
@@ -142,11 +152,16 @@ declare module 'buffer' {
          */
         slice(start?: number, end?: number, type?: string): Blob;
         /**
-         * Returns a promise that resolves the contents of the `Blob` decoded as a UTF-8
-         * string.
+         * Returns a promise that fulfills with the contents of the `Blob` decoded as a
+         * UTF-8 string.
          * @since v15.7.0
          */
         text(): Promise<string>;
+        /**
+         * Returns a new `ReadableStream` that allows the content of the `Blob` to be read.
+         * @since v16.7.0
+         */
+        stream(): unknown; // pending web streams types
     }
     export import atob = globalThis.atob;
     export import btoa = globalThis.btoa;
@@ -210,12 +225,21 @@ declare module 'buffer' {
              */
             new (buffer: Buffer): Buffer;
             /**
-             * When passed a reference to the .buffer property of a TypedArray instance,
-             * the newly created Buffer will share the same allocated memory as the TypedArray.
-             * The optional {byteOffset} and {length} arguments specify a memory range
-             * within the {arrayBuffer} that will be shared by the Buffer.
+             * Allocates a new `Buffer` using an `array` of bytes in the range `0` – `255`.
+             * Array entries outside that range will be truncated to fit into it.
+             *
+             * ```js
+             * import { Buffer } from 'buffer';
+             *
+             * // Creates a new Buffer containing the UTF-8 bytes of the string 'buffer'.
+             * const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);
+             * ```
+             *
+             * A `TypeError` will be thrown if `array` is not an `Array` or another type
+             * appropriate for `Buffer.from()` variants.
              *
-             * @param arrayBuffer The .buffer property of any TypedArray or a new ArrayBuffer()
+             * `Buffer.from(array)` and `Buffer.from(string)` may also use the internal`Buffer` pool like `Buffer.allocUnsafe()` does.
+             * @since v5.10.0
              */
             from(arrayBuffer: WithImplicitCoercion<ArrayBuffer | SharedArrayBuffer>, byteOffset?: number, length?: number): Buffer;
             /**
@@ -243,67 +267,264 @@ declare module 'buffer' {
              */
             of(...items: number[]): Buffer;
             /**
-             * Returns true if {obj} is a Buffer
+             * Returns `true` if `obj` is a `Buffer`, `false` otherwise.
+             *
+             * ```js
+             * import { Buffer } from 'buffer';
              *
-             * @param obj object to test.
+             * Buffer.isBuffer(Buffer.alloc(10)); // true
+             * Buffer.isBuffer(Buffer.from('foo')); // true
+             * Buffer.isBuffer('a string'); // false
+             * Buffer.isBuffer([]); // false
+             * Buffer.isBuffer(new Uint8Array(1024)); // false
+             * ```
+             * @since v0.1.101
              */
             isBuffer(obj: any): obj is Buffer;
             /**
-             * Returns true if {encoding} is a valid encoding argument.
-             * Valid string encodings in Node 0.12: 'ascii'|'utf8'|'utf16le'|'ucs2'(alias of 'utf16le')|'base64'|'binary'(deprecated)|'hex'
+             * Returns `true` if `encoding` is the name of a supported character encoding,
+             * or `false` otherwise.
+             *
+             * ```js
+             * import { Buffer } from 'buffer';
+             *
+             * console.log(Buffer.isEncoding('utf8'));
+             * // Prints: true
+             *
+             * console.log(Buffer.isEncoding('hex'));
+             * // Prints: true
              *
-             * @param encoding string to test.
+             * console.log(Buffer.isEncoding('utf/8'));
+             * // Prints: false
+             *
+             * console.log(Buffer.isEncoding(''));
+             * // Prints: false
+             * ```
+             * @since v0.9.1
+             * @param encoding A character encoding name to check.
              */
             isEncoding(encoding: string): encoding is BufferEncoding;
             /**
-             * Gives the actual byte length of a string. encoding defaults to 'utf8'.
-             * This is not the same as String.prototype.length since that returns the number of characters in a string.
+             * Returns the byte length of a string when encoded using `encoding`.
+             * This is not the same as [`String.prototype.length`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length), which does not account
+             * for the encoding that is used to convert the string into bytes.
+             *
+             * For `'base64'`, `'base64url'`, and `'hex'`, this function assumes valid input.
+             * For strings that contain non-base64/hex-encoded data (e.g. whitespace), the
+             * return value might be greater than the length of a `Buffer` created from the
+             * string.
              *
-             * @param string string to test.
-             * @param encoding encoding used to evaluate (defaults to 'utf8')
+             * ```js
+             * import { Buffer } from 'buffer';
+             *
+             * const str = '\u00bd + \u00bc = \u00be';
+             *
+             * console.log(`${str}: ${str.length} characters, ` +
+             *             `${Buffer.byteLength(str, 'utf8')} bytes`);
+             * // Prints: ½ + ¼ = ¾: 9 characters, 12 bytes
+             * ```
+             *
+             * When `string` is a
+             * `Buffer`/[`DataView`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView)/[`TypedArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/-
+             * Reference/Global_Objects/TypedArray)/[`ArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer)/[`SharedArrayBuffer`](https://develop-
+             * er.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer), the byte length as reported by `.byteLength`is returned.
+             * @since v0.1.90
+             * @param string A value to calculate the length of.
+             * @param [encoding='utf8'] If `string` is a string, this is its encoding.
+             * @return The number of bytes contained within `string`.
              */
             byteLength(string: string | NodeJS.ArrayBufferView | ArrayBuffer | SharedArrayBuffer, encoding?: BufferEncoding): number;
             /**
-             * Returns a buffer which is the result of concatenating all the buffers in the list together.
+             * Returns a new `Buffer` which is the result of concatenating all the `Buffer`instances in the `list` together.
              *
-             * If the list has no items, or if the totalLength is 0, then it returns a zero-length buffer.
-             * If the list has exactly one item, then the first item of the list is returned.
-             * If the list has more than one item, then a new Buffer is created.
+             * If the list has no items, or if the `totalLength` is 0, then a new zero-length`Buffer` is returned.
+             *
+             * If `totalLength` is not provided, it is calculated from the `Buffer` instances
+             * in `list` by adding their lengths.
+             *
+             * If `totalLength` is provided, it is coerced to an unsigned integer. If the
+             * combined length of the `Buffer`s in `list` exceeds `totalLength`, the result is
+             * truncated to `totalLength`.
+             *
+             * ```js
+             * import { Buffer } from 'buffer';
+             *
+             * // Create a single `Buffer` from a list of three `Buffer` instances.
+             *
+             * const buf1 = Buffer.alloc(10);
+             * const buf2 = Buffer.alloc(14);
+             * const buf3 = Buffer.alloc(18);
+             * const totalLength = buf1.length + buf2.length + buf3.length;
+             *
+             * console.log(totalLength);
+             * // Prints: 42
+             *
+             * const bufA = Buffer.concat([buf1, buf2, buf3], totalLength);
+             *
+             * console.log(bufA);
+             * // Prints: <Buffer 00 00 00 00 ...>
+             * console.log(bufA.length);
+             * // Prints: 42
+             * ```
              *
-             * @param list An array of Buffer objects to concatenate
-             * @param totalLength Total length of the buffers when concatenated.
-             *   If totalLength is not provided, it is read from the buffers in the list. However, this adds an additional loop to the function, so it is faster to provide the length explicitly.
+             * `Buffer.concat()` may also use the internal `Buffer` pool like `Buffer.allocUnsafe()` does.
+             * @since v0.7.11
+             * @param list List of `Buffer` or {@link Uint8Array} instances to concatenate.
+             * @param totalLength Total length of the `Buffer` instances in `list` when concatenated.
              */
             concat(list: ReadonlyArray<Uint8Array>, totalLength?: number): Buffer;
             /**
-             * The same as buf1.compare(buf2).
+             * Compares `buf1` to `buf2`, typically for the purpose of sorting arrays of`Buffer` instances. This is equivalent to calling `buf1.compare(buf2)`.
+             *
+             * ```js
+             * import { Buffer } from 'buffer';
+             *
+             * const buf1 = Buffer.from('1234');
+             * const buf2 = Buffer.from('0123');
+             * const arr = [buf1, buf2];
+             *
+             * console.log(arr.sort(Buffer.compare));
+             * // Prints: [ <Buffer 30 31 32 33>, <Buffer 31 32 33 34> ]
+             * // (This result is equal to: [buf2, buf1].)
+             * ```
+             * @since v0.11.13
+             * @return Either `-1`, `0`, or `1`, depending on the result of the comparison. See `compare` for details.
              */
             compare(buf1: Uint8Array, buf2: Uint8Array): number;
             /**
-             * Allocates a new buffer of {size} octets.
+             * Allocates a new `Buffer` of `size` bytes. If `fill` is `undefined`, the`Buffer` will be zero-filled.
              *
-             * @param size count of octets to allocate.
-             * @param fill if specified, buffer will be initialized by calling buf.fill(fill).
-             *    If parameter is omitted, buffer will be filled with zeros.
-             * @param encoding encoding used for call to buf.fill while initalizing
+             * ```js
+             * import { Buffer } from 'buffer';
+             *
+             * const buf = Buffer.alloc(5);
+             *
+             * console.log(buf);
+             * // Prints: <Buffer 00 00 00 00 00>
+             * ```
+             *
+             * If `size` is larger than {@link constants.MAX_LENGTH} or smaller than 0, `ERR_INVALID_ARG_VALUE` is thrown.
+             *
+             * If `fill` is specified, the allocated `Buffer` will be initialized by calling `buf.fill(fill)`.
+             *
+             * ```js
+             * import { Buffer } from 'buffer';
+             *
+             * const buf = Buffer.alloc(5, 'a');
+             *
+             * console.log(buf);
+             * // Prints: <Buffer 61 61 61 61 61>
+             * ```
+             *
+             * If both `fill` and `encoding` are specified, the allocated `Buffer` will be
+             * initialized by calling `buf.fill(fill, encoding)`.
+             *
+             * ```js
+             * import { Buffer } from 'buffer';
+             *
+             * const buf = Buffer.alloc(11, 'aGVsbG8gd29ybGQ=', 'base64');
+             *
+             * console.log(buf);
+             * // Prints: <Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64>
+             * ```
+             *
+             * Calling `Buffer.alloc()` can be measurably slower than the alternative `Buffer.allocUnsafe()` but ensures that the newly created `Buffer` instance
+             * contents will never contain sensitive data from previous allocations, including
+             * data that might not have been allocated for `Buffer`s.
+             *
+             * A `TypeError` will be thrown if `size` is not a number.
+             * @since v5.10.0
+             * @param size The desired length of the new `Buffer`.
+             * @param [fill=0] A value to pre-fill the new `Buffer` with.
+             * @param [encoding='utf8'] If `fill` is a string, this is its encoding.
              */
             alloc(size: number, fill?: string | Buffer | number, encoding?: BufferEncoding): Buffer;
             /**
-             * Allocates a new buffer of {size} octets, leaving memory not initialized, so the contents
-             * of the newly created Buffer are unknown and may contain sensitive data.
+             * Allocates a new `Buffer` of `size` bytes. If `size` is larger than {@link constants.MAX_LENGTH} or smaller than 0, `ERR_INVALID_ARG_VALUE` is thrown.
+             *
+             * The underlying memory for `Buffer` instances created in this way is _not_
+             * _initialized_. The contents of the newly created `Buffer` are unknown and_may contain sensitive data_. Use `Buffer.alloc()` instead to initialize`Buffer` instances with zeroes.
+             *
+             * ```js
+             * import { Buffer } from 'buffer';
+             *
+             * const buf = Buffer.allocUnsafe(10);
+             *
+             * console.log(buf);
+             * // Prints (contents may vary): <Buffer a0 8b 28 3f 01 00 00 00 50 32>
+             *
+             * buf.fill(0);
+             *
+             * console.log(buf);
+             * // Prints: <Buffer 00 00 00 00 00 00 00 00 00 00>
+             * ```
+             *
+             * A `TypeError` will be thrown if `size` is not a number.
+             *
+             * The `Buffer` module pre-allocates an internal `Buffer` instance of
+             * size `Buffer.poolSize` that is used as a pool for the fast allocation of new`Buffer` instances created using `Buffer.allocUnsafe()`,`Buffer.from(array)`, `Buffer.concat()`, and the
+             * deprecated`new Buffer(size)` constructor only when `size` is less than or equal
+             * to `Buffer.poolSize >> 1` (floor of `Buffer.poolSize` divided by two).
              *
-             * @param size count of octets to allocate
+             * Use of this pre-allocated internal memory pool is a key difference between
+             * calling `Buffer.alloc(size, fill)` vs. `Buffer.allocUnsafe(size).fill(fill)`.
+             * Specifically, `Buffer.alloc(size, fill)` will _never_ use the internal `Buffer`pool, while `Buffer.allocUnsafe(size).fill(fill)`_will_ use the internal`Buffer` pool if `size` is less
+             * than or equal to half `Buffer.poolSize`. The
+             * difference is subtle but can be important when an application requires the
+             * additional performance that `Buffer.allocUnsafe()` provides.
+             * @since v5.10.0
+             * @param size The desired length of the new `Buffer`.
              */
             allocUnsafe(size: number): Buffer;
             /**
-             * Allocates a new non-pooled buffer of {size} octets, leaving memory not initialized, so the contents
-             * of the newly created Buffer are unknown and may contain sensitive data.
+             * Allocates a new `Buffer` of `size` bytes. If `size` is larger than {@link constants.MAX_LENGTH} or smaller than 0, `ERR_INVALID_ARG_VALUE` is thrown. A zero-length `Buffer` is created
+             * if `size` is 0.
+             *
+             * The underlying memory for `Buffer` instances created in this way is _not_
+             * _initialized_. The contents of the newly created `Buffer` are unknown and_may contain sensitive data_. Use `buf.fill(0)` to initialize
+             * such `Buffer` instances with zeroes.
+             *
+             * When using `Buffer.allocUnsafe()` to allocate new `Buffer` instances,
+             * allocations under 4 KB are sliced from a single pre-allocated `Buffer`. This
+             * allows applications to avoid the garbage collection overhead of creating many
+             * individually allocated `Buffer` instances. This approach improves both
+             * performance and memory usage by eliminating the need to track and clean up as
+             * many individual `ArrayBuffer` objects.
+             *
+             * However, in the case where a developer may need to retain a small chunk of
+             * memory from a pool for an indeterminate amount of time, it may be appropriate
+             * to create an un-pooled `Buffer` instance using `Buffer.allocUnsafeSlow()` and
+             * then copying out the relevant bits.
+             *
+             * ```js
+             * import { Buffer } from 'buffer';
+             *
+             * // Need to keep around a few small chunks of memory.
+             * const store = [];
+             *
+             * socket.on('readable', () => {
+             *   let data;
+             *   while (null !== (data = readable.read())) {
+             *     // Allocate for retained data.
+             *     const sb = Buffer.allocUnsafeSlow(10);
              *
-             * @param size count of octets to allocate
+             *     // Copy the data into the new allocation.
+             *     data.copy(sb, 0, 0, 10);
+             *
+             *     store.push(sb);
+             *   }
+             * });
+             * ```
+             *
+             * A `TypeError` will be thrown if `size` is not a number.
+             * @since v5.12.0
+             * @param size The desired length of the new `Buffer`.
              */
             allocUnsafeSlow(size: number): Buffer;
             /**
-             * This is the number of bytes used to determine the size of pre-allocated, internal Buffer instances used for pooling. This value may be modified.
+             * This is the size (in bytes) of pre-allocated internal `Buffer` instances used
+             * for pooling. This value may be modified.
+             * @since v0.11.3
              */
             poolSize: number;
         }
@@ -314,6 +535,8 @@ declare module 'buffer' {
              * written. However, partially encoded characters will not be written.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.alloc(256);
              *
              * const len = buf.write('\u00bd + \u00bc = \u00be', 0);
@@ -348,6 +571,8 @@ declare module 'buffer' {
              * as {@link constants.MAX_STRING_LENGTH}.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf1 = Buffer.allocUnsafe(26);
              *
              * for (let i = 0; i < 26; i++) {
@@ -383,6 +608,8 @@ declare module 'buffer' {
              * In particular, `Buffer.from(buf.toJSON())` works like `Buffer.from(buf)`.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5]);
              * const json = JSON.stringify(buf);
              *
@@ -408,6 +635,8 @@ declare module 'buffer' {
              * Returns `true` if both `buf` and `otherBuffer` have exactly the same bytes,`false` otherwise. Equivalent to `buf.compare(otherBuffer) === 0`.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf1 = Buffer.from('ABC');
              * const buf2 = Buffer.from('414243', 'hex');
              * const buf3 = Buffer.from('ABCD');
@@ -430,6 +659,8 @@ declare module 'buffer' {
              * * `-1` is returned if `target` should come _after_`buf` when sorted.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf1 = Buffer.from('ABC');
              * const buf2 = Buffer.from('BCD');
              * const buf3 = Buffer.from('ABCD');
@@ -452,6 +683,8 @@ declare module 'buffer' {
              * The optional `targetStart`, `targetEnd`, `sourceStart`, and `sourceEnd`arguments can be used to limit the comparison to specific ranges within `target`and `buf` respectively.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf1 = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8, 9]);
              * const buf2 = Buffer.from([5, 6, 7, 8, 9, 1, 2, 3, 4]);
              *
@@ -480,6 +713,8 @@ declare module 'buffer' {
              * different function arguments.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * // Create two `Buffer` instances.
              * const buf1 = Buffer.allocUnsafe(26);
              * const buf2 = Buffer.allocUnsafe(26).fill('!');
@@ -499,6 +734,8 @@ declare module 'buffer' {
              * ```
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * // Create a `Buffer` and copy data from one region to an overlapping region
              * // within the same `Buffer`.
              *
@@ -532,6 +769,8 @@ declare module 'buffer' {
              * which is a superclass of `Buffer`. To copy the slice, use`Uint8Array.prototype.slice()`.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.from('buffer');
              *
              * const copiedBuf = Uint8Array.prototype.slice.call(buf);
@@ -559,6 +798,8 @@ declare module 'buffer' {
              * Modifying the new `Buffer` slice will modify the memory in the original `Buffer`because the allocated memory of the two objects overlap.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * // Create a `Buffer` with the ASCII alphabet, take a slice, and modify one byte
              * // from the original `Buffer`.
              *
@@ -584,6 +825,8 @@ declare module 'buffer' {
              * end of `buf` rather than the beginning.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.from('buffer');
              *
              * console.log(buf.subarray(-6, -1).toString());
@@ -609,6 +852,8 @@ declare module 'buffer' {
              * `value` is interpreted and written as a two's complement signed integer.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.allocUnsafe(8);
              *
              * buf.writeBigInt64BE(0x0102030405060708n, 0);
@@ -628,6 +873,8 @@ declare module 'buffer' {
              * `value` is interpreted and written as a two's complement signed integer.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.allocUnsafe(8);
              *
              * buf.writeBigInt64LE(0x0102030405060708n, 0);
@@ -647,6 +894,8 @@ declare module 'buffer' {
              * This function is also available under the `writeBigUint64BE` alias.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.allocUnsafe(8);
              *
              * buf.writeBigUInt64BE(0xdecafafecacefaden, 0);
@@ -664,6 +913,8 @@ declare module 'buffer' {
              * Writes `value` to `buf` at the specified `offset` as little-endian
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.allocUnsafe(8);
              *
              * buf.writeBigUInt64LE(0xdecafafecacefaden, 0);
@@ -686,6 +937,8 @@ declare module 'buffer' {
              * This function is also available under the `writeUintLE` alias.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.allocUnsafe(6);
              *
              * buf.writeUIntLE(0x1234567890ab, 0, 6);
@@ -707,6 +960,8 @@ declare module 'buffer' {
              * This function is also available under the `writeUintBE` alias.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.allocUnsafe(6);
              *
              * buf.writeUIntBE(0x1234567890ab, 0, 6);
@@ -726,6 +981,8 @@ declare module 'buffer' {
              * when `value` is anything other than a signed integer.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.allocUnsafe(6);
              *
              * buf.writeIntLE(0x1234567890ab, 0, 6);
@@ -745,6 +1002,8 @@ declare module 'buffer' {
              * signed integer.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.allocUnsafe(6);
              *
              * buf.writeIntBE(0x1234567890ab, 0, 6);
@@ -765,6 +1024,8 @@ declare module 'buffer' {
              * This function is also available under the `readBigUint64BE` alias.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff]);
              *
              * console.log(buf.readBigUInt64BE(0));
@@ -780,6 +1041,8 @@ declare module 'buffer' {
              * This function is also available under the `readBigUint64LE` alias.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff]);
              *
              * console.log(buf.readBigUInt64LE(0));
@@ -814,6 +1077,8 @@ declare module 'buffer' {
              * This function is also available under the `readUintLE` alias.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]);
              *
              * console.log(buf.readUIntLE(0, 6).toString(16));
@@ -831,6 +1096,8 @@ declare module 'buffer' {
              * This function is also available under the `readUintBE` alias.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]);
              *
              * console.log(buf.readUIntBE(0, 6).toString(16));
@@ -848,6 +1115,8 @@ declare module 'buffer' {
              * supporting up to 48 bits of accuracy.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]);
              *
              * console.log(buf.readIntLE(0, 6).toString(16));
@@ -863,6 +1132,8 @@ declare module 'buffer' {
              * supporting up to 48 bits of accuracy.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]);
              *
              * console.log(buf.readIntBE(0, 6).toString(16));
@@ -883,6 +1154,8 @@ declare module 'buffer' {
              * This function is also available under the `readUint8` alias.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.from([1, -2]);
              *
              * console.log(buf.readUInt8(0));
@@ -902,6 +1175,8 @@ declare module 'buffer' {
              * This function is also available under the `readUint16LE` alias.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.from([0x12, 0x34, 0x56]);
              *
              * console.log(buf.readUInt16LE(0).toString(16));
@@ -921,6 +1196,8 @@ declare module 'buffer' {
              * This function is also available under the `readUint16BE` alias.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.from([0x12, 0x34, 0x56]);
              *
              * console.log(buf.readUInt16BE(0).toString(16));
@@ -938,6 +1215,8 @@ declare module 'buffer' {
              * This function is also available under the `readUint32LE` alias.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.from([0x12, 0x34, 0x56, 0x78]);
              *
              * console.log(buf.readUInt32LE(0).toString(16));
@@ -955,6 +1234,8 @@ declare module 'buffer' {
              * This function is also available under the `readUint32BE` alias.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.from([0x12, 0x34, 0x56, 0x78]);
              *
              * console.log(buf.readUInt32BE(0).toString(16));
@@ -970,6 +1251,8 @@ declare module 'buffer' {
              * Integers read from a `Buffer` are interpreted as two's complement signed values.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.from([-1, 5]);
              *
              * console.log(buf.readInt8(0));
@@ -989,6 +1272,8 @@ declare module 'buffer' {
              * Integers read from a `Buffer` are interpreted as two's complement signed values.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.from([0, 5]);
              *
              * console.log(buf.readInt16LE(0));
@@ -1006,6 +1291,8 @@ declare module 'buffer' {
              * Integers read from a `Buffer` are interpreted as two's complement signed values.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.from([0, 5]);
              *
              * console.log(buf.readInt16BE(0));
@@ -1021,6 +1308,8 @@ declare module 'buffer' {
              * Integers read from a `Buffer` are interpreted as two's complement signed values.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.from([0, 0, 0, 5]);
              *
              * console.log(buf.readInt32LE(0));
@@ -1038,6 +1327,8 @@ declare module 'buffer' {
              * Integers read from a `Buffer` are interpreted as two's complement signed values.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.from([0, 0, 0, 5]);
              *
              * console.log(buf.readInt32BE(0));
@@ -1051,6 +1342,8 @@ declare module 'buffer' {
              * Reads a 32-bit, little-endian float from `buf` at the specified `offset`.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.from([1, 2, 3, 4]);
              *
              * console.log(buf.readFloatLE(0));
@@ -1066,6 +1359,8 @@ declare module 'buffer' {
              * Reads a 32-bit, big-endian float from `buf` at the specified `offset`.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.from([1, 2, 3, 4]);
              *
              * console.log(buf.readFloatBE(0));
@@ -1079,6 +1374,8 @@ declare module 'buffer' {
              * Reads a 64-bit, little-endian double from `buf` at the specified `offset`.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
              *
              * console.log(buf.readDoubleLE(0));
@@ -1094,6 +1391,8 @@ declare module 'buffer' {
              * Reads a 64-bit, big-endian double from `buf` at the specified `offset`.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
              *
              * console.log(buf.readDoubleBE(0));
@@ -1109,6 +1408,8 @@ declare module 'buffer' {
              * byte order _in-place_. Throws `ERR_INVALID_BUFFER_SIZE` if `buf.length` is not a multiple of 2.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);
              *
              * console.log(buf1);
@@ -1129,6 +1430,8 @@ declare module 'buffer' {
              * between UTF-16 little-endian and UTF-16 big-endian:
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.from('This is little-endian UTF-16', 'utf16le');
              * buf.swap16(); // Convert to big-endian UTF-16 text.
              * ```
@@ -1141,6 +1444,8 @@ declare module 'buffer' {
              * byte order _in-place_. Throws `ERR_INVALID_BUFFER_SIZE` if `buf.length` is not a multiple of 4.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);
              *
              * console.log(buf1);
@@ -1165,6 +1470,8 @@ declare module 'buffer' {
              * Throws `ERR_INVALID_BUFFER_SIZE` if `buf.length` is not a multiple of 8.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);
              *
              * console.log(buf1);
@@ -1192,6 +1499,8 @@ declare module 'buffer' {
              * This function is also available under the `writeUint8` alias.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.allocUnsafe(4);
              *
              * buf.writeUInt8(0x3, 0);
@@ -1215,6 +1524,8 @@ declare module 'buffer' {
              * This function is also available under the `writeUint16LE` alias.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.allocUnsafe(4);
              *
              * buf.writeUInt16LE(0xdead, 0);
@@ -1236,6 +1547,8 @@ declare module 'buffer' {
              * This function is also available under the `writeUint16BE` alias.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.allocUnsafe(4);
              *
              * buf.writeUInt16BE(0xdead, 0);
@@ -1257,6 +1570,8 @@ declare module 'buffer' {
              * This function is also available under the `writeUint32LE` alias.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.allocUnsafe(4);
              *
              * buf.writeUInt32LE(0xfeedface, 0);
@@ -1277,6 +1592,8 @@ declare module 'buffer' {
              * This function is also available under the `writeUint32BE` alias.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.allocUnsafe(4);
              *
              * buf.writeUInt32BE(0xfeedface, 0);
@@ -1298,6 +1615,8 @@ declare module 'buffer' {
              * `value` is interpreted and written as a two's complement signed integer.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.allocUnsafe(2);
              *
              * buf.writeInt8(2, 0);
@@ -1319,6 +1638,8 @@ declare module 'buffer' {
              * The `value` is interpreted and written as a two's complement signed integer.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.allocUnsafe(2);
              *
              * buf.writeInt16LE(0x0304, 0);
@@ -1339,6 +1660,8 @@ declare module 'buffer' {
              * The `value` is interpreted and written as a two's complement signed integer.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.allocUnsafe(2);
              *
              * buf.writeInt16BE(0x0102, 0);
@@ -1359,6 +1682,8 @@ declare module 'buffer' {
              * The `value` is interpreted and written as a two's complement signed integer.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.allocUnsafe(4);
              *
              * buf.writeInt32LE(0x05060708, 0);
@@ -1379,6 +1704,8 @@ declare module 'buffer' {
              * The `value` is interpreted and written as a two's complement signed integer.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.allocUnsafe(4);
              *
              * buf.writeInt32BE(0x01020304, 0);
@@ -1397,6 +1724,8 @@ declare module 'buffer' {
              * undefined when `value` is anything other than a JavaScript number.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.allocUnsafe(4);
              *
              * buf.writeFloatLE(0xcafebabe, 0);
@@ -1415,6 +1744,8 @@ declare module 'buffer' {
              * undefined when `value` is anything other than a JavaScript number.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.allocUnsafe(4);
              *
              * buf.writeFloatBE(0xcafebabe, 0);
@@ -1433,6 +1764,8 @@ declare module 'buffer' {
              * other than a JavaScript number.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.allocUnsafe(8);
              *
              * buf.writeDoubleLE(123.456, 0);
@@ -1451,6 +1784,8 @@ declare module 'buffer' {
              * other than a JavaScript number.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.allocUnsafe(8);
              *
              * buf.writeDoubleBE(123.456, 0);
@@ -1469,6 +1804,8 @@ declare module 'buffer' {
              * the entire `buf` will be filled:
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * // Fill a `Buffer` with the ASCII character 'h'.
              *
              * const b = Buffer.allocUnsafe(50).fill('h');
@@ -1485,6 +1822,8 @@ declare module 'buffer' {
              * then only the bytes of that character that fit into `buf` are written:
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * // Fill a `Buffer` with character that takes up two bytes in UTF-8.
              *
              * console.log(Buffer.allocUnsafe(5).fill('\u0222'));
@@ -1495,6 +1834,8 @@ declare module 'buffer' {
              * fill data remains, an exception is thrown:
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.allocUnsafe(5);
              *
              * console.log(buf.fill('a'));
@@ -1522,6 +1863,8 @@ declare module 'buffer' {
              * value between `0` and `255`.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.from('this is a buffer');
              *
              * console.log(buf.indexOf('this'));
@@ -1553,6 +1896,8 @@ declare module 'buffer' {
              * behavior matches [`String.prototype.indexOf()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf).
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const b = Buffer.from('abcdef');
              *
              * // Passing a value that's a number, but not a valid byte.
@@ -1582,6 +1927,8 @@ declare module 'buffer' {
              * rather than the first occurrence.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.from('this buffer is a buffer');
              *
              * console.log(buf.lastIndexOf('this'));
@@ -1615,6 +1962,8 @@ declare module 'buffer' {
              * This behavior matches [`String.prototype.lastIndexOf()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf).
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const b = Buffer.from('abcdef');
              *
              * // Passing a value that's a number, but not a valid byte.
@@ -1646,6 +1995,8 @@ declare module 'buffer' {
              * of `buf`.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * // Log the entire contents of a `Buffer`.
              *
              * const buf = Buffer.from('buffer');
@@ -1668,6 +2019,8 @@ declare module 'buffer' {
              * Equivalent to `buf.indexOf() !== -1`.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.from('this is a buffer');
              *
              * console.log(buf.includes('this'));
@@ -1696,6 +2049,8 @@ declare module 'buffer' {
              * Creates and returns an [iterator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) of `buf` keys (indices).
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.from('buffer');
              *
              * for (const key of buf.keys()) {
@@ -1717,6 +2072,8 @@ declare module 'buffer' {
              * called automatically when a `Buffer` is used in a `for..of` statement.
              *
              * ```js
+             * import { Buffer } from 'buffer';
+             *
              * const buf = Buffer.from('buffer');
              *
              * for (const value of buf.values()) {