Genese complexity report

<- globals.d.ts
Methods : 96
Complexity index : 39.3
Cyclomatic complexity : 90
Cognitive complexity
100 % Correct 96/96
0 % Warning 0/96 (threshold : 10)
0 % Error 0/96 (threshold : 20)
Cyclomatic complexity
100 % Correct 96/96
0 % Warning 0/96 (threshold : 5)
0 % Error 0/96 (threshold : 10)
Methods of globals.d.ts
setTimeout Complexity Index 1.2 Cyclomatic complexity 1
                            
                                
            
            
            declare function setTimeout(callback: (...args: any[]) => void, ms: number, ...args: any[]): NodeJS.Timeout; // ------- +1.2 Complexity index (+1.2 atomic)
            
                            
                        
___promisify__ Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                function __promisify__(ms: number): Promise<void>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
___promisify__ Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                function __promisify__<T>(ms: number, value: T): Promise<T>; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
clearTimeout Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
            
            declare function clearTimeout(timeoutId: NodeJS.Timeout): void; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
setInterval Complexity Index 1.2 Cyclomatic complexity 1
                            
                                
            
            declare function setInterval(callback: (...args: any[]) => void, ms: number, ...args: any[]): NodeJS.Timeout; // ------- +1.2 Complexity index (+1.2 atomic)
            
                            
                        
clearInterval Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
            
            declare function clearInterval(intervalId: NodeJS.Timeout): void; // --------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
setImmediate Complexity Index 1.1 Cyclomatic complexity 1
                            
                                
            
            declare function setImmediate(callback: (...args: any[]) => void, ...args: any[]): NodeJS.Immediate; // ------- +1.1 Complexity index (+1.1 atomic)
            
                            
                        
___promisify__ Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                function __promisify__(): Promise<void>; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
___promisify__ Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                function __promisify__<T>(value: T): Promise<T>; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
clearImmediate Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
            
            declare function clearImmediate(immediateId: NodeJS.Immediate): void; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
queueMicrotask Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
            
            declare function queueMicrotask(callback: () => void): void; // ---------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
Complexity Index 0.4 Cyclomatic complexity 0
                            
                                
            
                /**
                 * Allocates a new buffer containing the given {str}.
                 *
                 * @param str String to store in buffer.
                 * @param encoding encoding to use, optional.  Default is 'utf8'
                 * @deprecated since v10.0.0 - Use `Buffer.from(string[, encoding])` instead.
                 */
                constructor(str: string, encoding?: BufferEncoding); // -------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
Complexity Index 0.1 Cyclomatic complexity 0
                            
                                
                
                /**
                 * Allocates a new buffer of {size} octets.
                 *
                 * @param size count of octets to allocate.
                 * @deprecated since v10.0.0 - Use `Buffer.alloc()` instead (also see `Buffer.allocUnsafe()`).
                 */
                constructor(size: number); // --------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
Complexity Index 0.2 Cyclomatic complexity 0
                            
                                
                
                /**
                 * Allocates a new buffer containing the given {array} of octets.
                 *
                 * @param array The octets to store.
                 * @deprecated since v10.0.0 - Use `Buffer.from(array)` instead.
                 */
                constructor(array: Uint8Array); // ----------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
Complexity Index 0.4 Cyclomatic complexity 0
                            
                                
                
                /**
                 * Produces a Buffer backed by the same allocated memory as
                 * the given {ArrayBuffer}/{SharedArrayBuffer}.
                 *
                 *
                 * @param arrayBuffer The ArrayBuffer with which to share memory.
                 * @deprecated since v10.0.0 - Use `Buffer.from(arrayBuffer[, byteOffset[, length]])` instead.
                 */
                constructor(arrayBuffer: ArrayBuffer | SharedArrayBuffer); // ------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
Complexity Index 0.3 Cyclomatic complexity 0
                            
                                
                
                /**
                 * Allocates a new buffer containing the given {array} of octets.
                 *
                 * @param array The octets to store.
                 * @deprecated since v10.0.0 - Use `Buffer.from(array)` instead.
                 */
                constructor(array: ReadonlyArray<any>); // --------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
Complexity Index 0.2 Cyclomatic complexity 0
                            
                                
                
                /**
                 * Copies the passed {buffer} data onto a new {Buffer} instance.
                 *
                 * @param buffer The buffer to copy.
                 * @deprecated since v10.0.0 - Use `Buffer.from(buffer)` instead.
                 */
                constructor(buffer: Buffer); // -------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
from Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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.
                 *
                 * @param arrayBuffer The .buffer property of any TypedArray or a new ArrayBuffer()
                 */
                static from(arrayBuffer: ArrayBuffer | SharedArrayBuffer, byteOffset?: number, length?: number): Buffer; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
from Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Creates a new Buffer using the passed {data}
                 * @param data data to create a new Buffer
                 */
                static from(data: ReadonlyArray<number>): Buffer; // -------------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
from Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                static from(data: Uint8Array): Buffer; // ------------------ +0.4 Complexity index (+0.4 atomic)
            
                            
                        
from Complexity Index 1.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Creates a new buffer containing the coerced value of an object
                 * A `TypeError` will be thrown if {obj} has not mentioned methods or is not of other type appropriate for `Buffer.from()` variants.
                 * @param obj An object supporting `Symbol.toPrimitive` or `valueOf()`.
                 */
                static from(obj: { valueOf(): string | object } | { [Symbol.toPrimitive](hint: 'string'): string }, byteOffset?: number, length?: number): Buffer; // ------- +1.4 Complexity index (+1.4 atomic)
            
                            
                        
from Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Creates a new Buffer containing the given JavaScript string {str}.
                 * If provided, the {encoding} parameter identifies the character encoding.
                 * If not provided, {encoding} defaults to 'utf8'.
                 */
                static from(str: string, encoding?: BufferEncoding): Buffer; // --------------------------------------------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
of Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Creates a new Buffer using the passed {data}
                 * @param values to create a new Buffer
                 */
                static of(...items: number[]): Buffer; // ----------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
isBuffer Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Returns true if {obj} is a Buffer
                 *
                 * @param obj object to test.
                 */
                static isBuffer(obj: any): obj is Buffer; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isEncoding Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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'
                 *
                 * @param encoding string to test.
                 */
                static isEncoding(encoding: string): encoding is BufferEncoding; // ---------------------------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
byteLength Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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.
                 *
                 * @param string string to test.
                 * @param encoding encoding used to evaluate (defaults to 'utf8')
                 */
                static byteLength( // ------------------------------------------------------------------------------------------------ +0.1 Complexity index (+0.1 atomic)
                    string: string | NodeJS.ArrayBufferView | ArrayBuffer | SharedArrayBuffer, // ------------------------------------ +0.7 Complexity index (+0.7 atomic)
                    encoding?: BufferEncoding // ------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                ): number;
            
                            
                        
concat Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Returns a buffer which is the result of concatenating all the buffers 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.
                 *
                 * @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.
                 */
                static concat(list: ReadonlyArray<Uint8Array>, totalLength?: number): Buffer; // ---------------------------------------------------------------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
compare Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * The same as buf1.compare(buf2).
                 */
                static compare(buf1: Uint8Array, buf2: Uint8Array): number; // ------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
alloc Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Allocates a new buffer of {size} octets.
                 *
                 * @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
                 */
                static alloc(size: number, fill?: string | Buffer | number, encoding?: BufferEncoding): Buffer; // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
allocUnsafe Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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.
                 *
                 * @param size count of octets to allocate
                 */
                static allocUnsafe(size: number): Buffer; // ------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
allocUnsafeSlow Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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.
                 *
                 * @param size count of octets to allocate
                 */
                static allocUnsafeSlow(size: number): Buffer; // ---------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
write Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
            
                write(string: string, encoding?: BufferEncoding): number; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
write Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                write(string: string, offset: number, encoding?: BufferEncoding): number; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
write Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                write(string: string, offset: number, length: number, encoding?: BufferEncoding): number; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
toString Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                toString(encoding?: BufferEncoding, start?: number, end?: number): string; // ---------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
toJSON Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                toJSON(): { type: 'Buffer'; data: number[] }; // ------------------------------------ +0.5 Complexity index (+0.5 atomic)
            
                            
                        
equals Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                equals(otherBuffer: Uint8Array): boolean; // ----------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
compare Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                compare( // ---------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    otherBuffer: Uint8Array, // -------------------- +0.2 Complexity index (+0.2 atomic)
                    targetStart?: number, // ----------------------- +0.1 Complexity index (+0.1 atomic)
                    targetEnd?: number, // ------------------------- +0.1 Complexity index (+0.1 atomic)
                    sourceStart?: number, // ----------------------- +0.1 Complexity index (+0.1 atomic)
                    sourceEnd?: number // -------------------------- +0.1 Complexity index (+0.1 atomic)
                ): number;
            
                            
                        
copy Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                copy(targetBuffer: Uint8Array, targetStart?: number, sourceStart?: number, sourceEnd?: number): number; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
slice Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Returns a new `Buffer` that references **the same memory as the original**, but offset and cropped by the start and end indices.
                 *
                 * This method is incompatible with `Uint8Array#slice()`, which returns a copy of the original memory.
                 *
                 * @param begin Where the new `Buffer` will start. Default: `0`.
                 * @param end Where the new `Buffer` will end (not inclusive). Default: `buf.length`.
                 */
                slice(begin?: number, end?: number): Buffer; // ---------------------------------------------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
subarray Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Returns a new `Buffer` that references **the same memory as the original**, but offset and cropped by the start and end indices.
                 *
                 * This method is compatible with `Uint8Array#subarray()`.
                 *
                 * @param begin Where the new `Buffer` will start. Default: `0`.
                 * @param end Where the new `Buffer` will end (not inclusive). Default: `buf.length`.
                 */
                subarray(begin?: number, end?: number): Buffer; // ------------------------------------------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
writeBigInt64BE Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                writeBigInt64BE(value: bigint, offset?: number): number; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
writeBigInt64LE Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                writeBigInt64LE(value: bigint, offset?: number): number; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
writeBigUInt64BE Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                writeBigUInt64BE(value: bigint, offset?: number): number; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
writeBigUInt64LE Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                writeBigUInt64LE(value: bigint, offset?: number): number; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
writeUIntLE Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                writeUIntLE(value: number, offset: number, byteLength: number): number; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
writeUIntBE Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                writeUIntBE(value: number, offset: number, byteLength: number): number; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
writeIntLE Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                writeIntLE(value: number, offset: number, byteLength: number): number; // -------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
writeIntBE Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                writeIntBE(value: number, offset: number, byteLength: number): number; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
readBigUInt64BE Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                readBigUInt64BE(offset?: number): bigint; // ------------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
readBigUInt64LE Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                readBigUInt64LE(offset?: number): bigint; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
readBigInt64BE Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                readBigInt64BE(offset?: number): bigint; // -------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
readBigInt64LE Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                readBigInt64LE(offset?: number): bigint; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
readUIntLE Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                readUIntLE(offset: number, byteLength: number): number; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
readUIntBE Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                readUIntBE(offset: number, byteLength: number): number; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
readIntLE Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                readIntLE(offset: number, byteLength: number): number; // -------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
readIntBE Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                readIntBE(offset: number, byteLength: number): number; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
readUInt8 Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                readUInt8(offset?: number): number; // -------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
readUInt16LE Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                readUInt16LE(offset?: number): number; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
readUInt16BE Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                readUInt16BE(offset?: number): number; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
readUInt32LE Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                readUInt32LE(offset?: number): number; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
readUInt32BE Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                readUInt32BE(offset?: number): number; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
readInt8 Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                readInt8(offset?: number): number; // ----------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
readInt16LE Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                readInt16LE(offset?: number): number; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
readInt16BE Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                readInt16BE(offset?: number): number; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
readInt32LE Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                readInt32LE(offset?: number): number; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
readInt32BE Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                readInt32BE(offset?: number): number; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
readFloatLE Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                readFloatLE(offset?: number): number; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
readFloatBE Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                readFloatBE(offset?: number): number; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
readDoubleLE Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                readDoubleLE(offset?: number): number; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
readDoubleBE Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                readDoubleBE(offset?: number): number; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
reverse Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                reverse(): this; // ----------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
swap16 Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                swap16(): Buffer; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
swap32 Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                swap32(): Buffer; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
swap64 Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                swap64(): Buffer; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
writeUInt8 Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                writeUInt8(value: number, offset?: number): number; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
writeUInt16LE Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                writeUInt16LE(value: number, offset?: number): number; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
writeUInt16BE Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                writeUInt16BE(value: number, offset?: number): number; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
writeUInt32LE Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                writeUInt32LE(value: number, offset?: number): number; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
writeUInt32BE Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                writeUInt32BE(value: number, offset?: number): number; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
writeInt8 Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                writeInt8(value: number, offset?: number): number; // ----------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
writeInt16LE Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                writeInt16LE(value: number, offset?: number): number; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
writeInt16BE Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                writeInt16BE(value: number, offset?: number): number; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
writeInt32LE Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                writeInt32LE(value: number, offset?: number): number; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
writeInt32BE Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                writeInt32BE(value: number, offset?: number): number; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
writeFloatLE Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                writeFloatLE(value: number, offset?: number): number; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
writeFloatBE Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                writeFloatBE(value: number, offset?: number): number; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
writeDoubleLE Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                writeDoubleLE(value: number, offset?: number): number; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
writeDoubleBE Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                writeDoubleBE(value: number, offset?: number): number; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
fill Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
            
                fill(value: string | Uint8Array | number, offset?: number, end?: number, encoding?: BufferEncoding): this; // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
indexOf Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
            
                indexOf(value: string | number | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number; // ------------ +0.8 Complexity index (+0.8 atomic)
            
                            
                        
lastIndexOf Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                lastIndexOf(value: string | number | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
entries Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                entries(): IterableIterator<[number, number]>; // ------------------------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
includes Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                includes(value: string | number | Buffer, byteOffset?: number, encoding?: BufferEncoding): boolean; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
keys Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                keys(): IterableIterator<number>; // ------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
values Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                values(): IterableIterator<number>; // ------- +0.2 Complexity index (+0.2 atomic)