Genese complexity report

<- util.d.ts
Methods : 96
Complexity index : 100.5
Cyclomatic complexity : 95
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 util.d.ts
format Complexity Index 2.7 Cyclomatic complexity 1
                            
                                
                
                function format(format: any, ...param: any[]): string; // ------- +2.7 Complexity index (+0.7 atomic, +2 recursivity)
            
                            
                        
formatWithOptions Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                function formatWithOptions(inspectOptions: InspectOptions, format: string, ...param: any[]): string; // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
log Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @deprecated since v0.11.3 - use a third party module instead. */
                function log(string: string): void; // ------------------------------------------------------------------------ +0.4 Complexity index (+0.4 atomic)
            
                            
                        
inspect Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                function inspect(object: any, showHidden?: boolean, depth?: number | null, color?: boolean): string; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
inspect Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                function inspect(object: any, options: InspectOptions): string; // -------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isArray Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /** @deprecated since v4.0.0 - use `Array.isArray()` instead. */
                function isArray(object: any): object is any[]; // ------------------------ +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isRegExp Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @deprecated since v4.0.0 - use `util.types.isRegExp()` instead. */
                function isRegExp(object: any): object is RegExp; // ---------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isDate Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @deprecated since v4.0.0 - use `util.types.isDate()` instead. */
                function isDate(object: any): object is Date; // ------------------------------ +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isError Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @deprecated since v4.0.0 - use `util.types.isNativeError()` instead. */
                function isError(object: any): object is Error; // ----------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
inherits Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                function inherits(constructor: any, superConstructor: any): void; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
debuglog Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                function debuglog(key: string): (msg: string, ...param: any[]) => void; // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
isBoolean Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @deprecated since v4.0.0 - use `typeof value === 'boolean'` instead. */
                function isBoolean(object: any): object is boolean; // ------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
isBuffer Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @deprecated since v4.0.0 - use `Buffer.isBuffer()` instead. */
                function isBuffer(object: any): object is Buffer; // ------------------------ +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isFunction Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** @deprecated since v4.0.0 - use `typeof value === 'function'` instead. */
                function isFunction(object: any): boolean; // ----------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
isNull Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @deprecated since v4.0.0 - use `value === null` instead. */
                function isNull(object: any): object is null; // ------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
isNullOrUndefined Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @deprecated since v4.0.0 - use `value === null || value === undefined` instead. */
                function isNullOrUndefined(object: any): object is null | undefined; // ------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isNumber Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @deprecated since v4.0.0 - use `typeof value === 'number'` instead. */
                function isNumber(object: any): object is number; // -------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
isObject Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** @deprecated since v4.0.0 - use `value !== null && typeof value === 'object'` instead. */
                function isObject(object: any): boolean; // ----------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
isPrimitive Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** @deprecated since v4.0.0 - use `(typeof value !== 'object' && typeof value !== 'function') || value === null` instead. */
                function isPrimitive(object: any): boolean; // ----------------------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
isString Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @deprecated since v4.0.0 - use `typeof value === 'string'` instead. */
                function isString(object: any): object is string; // -------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isSymbol Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @deprecated since v4.0.0 - use `typeof value === 'symbol'` instead. */
                function isSymbol(object: any): object is symbol; // -------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
isUndefined Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @deprecated since v4.0.0 - use `value === undefined` instead. */
                function isUndefined(object: any): object is undefined; // -------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
deprecate Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                function deprecate<T extends Function>(fn: T, message: string, code?: string): T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isDeepStrictEqual Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isDeepStrictEqual(val1: any, val2: any): boolean; // ------------------------------ +0.5 Complexity index (+0.5 atomic)
            
                            
                        
callbackify Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
            
                function callbackify(fn: () => Promise<void>): (callback: (err: NodeJS.ErrnoException) => void) => void; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
callbackify Complexity Index 1.3 Cyclomatic complexity 1
                            
                                
                
                function callbackify<TResult>(fn: () => Promise<TResult>): (callback: (err: NodeJS.ErrnoException, result: TResult) => void) => void; // ------- +1.3 Complexity index (+1.3 atomic)
            
                            
                        
callbackify Complexity Index 1.5 Cyclomatic complexity 1
                            
                                
                
                function callbackify<T1>(fn: (arg1: T1) => Promise<void>): (arg1: T1, callback: (err: NodeJS.ErrnoException) => void) => void; // -------------- +1.5 Complexity index (+1.5 atomic)
            
                            
                        
callbackify Complexity Index 1.8 Cyclomatic complexity 1
                            
                                
                
                function callbackify<T1, TResult>(fn: (arg1: T1) => Promise<TResult>): (arg1: T1, callback: (err: NodeJS.ErrnoException, result: TResult) => void) => void; // ------- +1.8 Complexity index (+1.8 atomic)
            
                            
                        
callbackify Complexity Index 2 Cyclomatic complexity 1
                            
                                
                
                function callbackify<T1, T2>(fn: (arg1: T1, arg2: T2) => Promise<void>): (arg1: T1, arg2: T2, callback: (err: NodeJS.ErrnoException) => void) => void; // ------------ +2.0 Complexity index (+2.0 atomic)
            
                            
                        
callbackify Complexity Index 2.4 Cyclomatic complexity 1
                            
                                
                
                function callbackify<T1, T2, TResult>(fn: (arg1: T1, arg2: T2) => Promise<TResult>): (arg1: T1, arg2: T2, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void; // ------- +2.4 Complexity index (+2.4 atomic)
            
                            
                        
callbackify Complexity Index 2.5 Cyclomatic complexity 1
                            
                                
                
                function callbackify<T1, T2, T3>(fn: (arg1: T1, arg2: T2, arg3: T3) => Promise<void>): (arg1: T1, arg2: T2, arg3: T3, callback: (err: NodeJS.ErrnoException) => void) => void; // ------------------- +2.5 Complexity index (+2.5 atomic)
            
                            
                        
callbackify Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
                
                function callbackify<T1, T2, T3, TResult>( // ------------------------------------------------------------------------------------------------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
                    fn: (arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>): (arg1: T1, arg2: T2, arg3: T3, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void; // --------- +2.4 Complexity index (+2.4 atomic)
            
                            
                        
callbackify Complexity Index 3 Cyclomatic complexity 1
                            
                                
                    
                function callbackify<T1, T2, T3, T4>( // ---------------------------------------------------------------------------------------------------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
                    fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: NodeJS.ErrnoException) => void) => void; // -------------- +2.5 Complexity index (+2.5 atomic)
            
                            
                        
callbackify Complexity Index 3.4 Cyclomatic complexity 1
                            
                                
                    
                function callbackify<T1, T2, T3, T4, TResult>( // --------------------------------------------------------------------------------------------------------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
                    fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void; // ------- +2.8 Complexity index (+2.8 atomic)
            
                            
                        
callbackify Complexity Index 3.5 Cyclomatic complexity 1
                            
                                
                    
                function callbackify<T1, T2, T3, T4, T5>( // -------------------------------------------------------------------------------------------------------------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
                    fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: NodeJS.ErrnoException) => void) => void; // -------------- +2.9 Complexity index (+2.9 atomic)
            
                            
                        
callbackify Complexity Index 3.9 Cyclomatic complexity 1
                            
                                
                    
                function callbackify<T1, T2, T3, T4, T5, TResult>( // ---------------------------------------------------------------------------------------------------------------------------------------------- +0.7 Complexity index (+0.7 atomic)
                    fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>, // ----------------------------------------------------------------------------------------------------------------- +1.3 Complexity index (+1.3 atomic)
                ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void; // ---------------------------------------------------------- +1.9 Complexity index (+1.9 atomic)
            
                            
                        
callbackify Complexity Index 4 Cyclomatic complexity 1
                            
                                
                
                function callbackify<T1, T2, T3, T4, T5, T6>( // ------------------------------------------------------------------------------------------------ +0.7 Complexity index (+0.7 atomic)
                    fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<void>, // ------------------------------------------------------- +1.5 Complexity index (+1.5 atomic)
                ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, callback: (err: NodeJS.ErrnoException) => void) => void; // --------------------- +1.8 Complexity index (+1.8 atomic)
            
                            
                        
callbackify Complexity Index 4.4 Cyclomatic complexity 1
                            
                                
                
                function callbackify<T1, T2, T3, T4, T5, T6, TResult>( // ------------------------------------------------------------------------------------------------- +0.8 Complexity index (+0.8 atomic)
                    fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<TResult> // --------------------------------------------------------------- +1.5 Complexity index (+1.5 atomic)
                ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void; // ------- +2.1 Complexity index (+2.1 atomic)
            
                            
                        
promisify Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
            
                function promisify<TCustom extends Function>(fn: CustomPromisify<TCustom>): TCustom; // ------------------------------------ +0.7 Complexity index (+0.7 atomic)
            
                            
                        
promisify Complexity Index 1.2 Cyclomatic complexity 1
                            
                                
                
                function promisify<TResult>(fn: (callback: (err: any, result: TResult) => void) => void): () => Promise<TResult>; // ------- +1.2 Complexity index (+1.2 atomic)
            
                            
                        
promisify Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                function promisify(fn: (callback: (err?: any) => void) => void): () => Promise<void>; // ----------------------------------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
promisify Complexity Index 1.7 Cyclomatic complexity 1
                            
                                
                
                function promisify<T1, TResult>(fn: (arg1: T1, callback: (err: any, result: TResult) => void) => void): (arg1: T1) => Promise<TResult>; // ------- +1.7 Complexity index (+1.7 atomic)
            
                            
                        
promisify Complexity Index 1.4 Cyclomatic complexity 1
                            
                                
                
                function promisify<T1>(fn: (arg1: T1, callback: (err?: any) => void) => void): (arg1: T1) => Promise<void>; // ----------------------------------- +1.4 Complexity index (+1.4 atomic)
            
                            
                        
promisify Complexity Index 2.2 Cyclomatic complexity 1
                            
                                
                
                function promisify<T1, T2, TResult>(fn: (arg1: T1, arg2: T2, callback: (err: any, result: TResult) => void) => void): (arg1: T1, arg2: T2) => Promise<TResult>; // ------- +2.2 Complexity index (+2.2 atomic)
            
                            
                        
promisify Complexity Index 1.9 Cyclomatic complexity 1
                            
                                
                
                function promisify<T1, T2>(fn: (arg1: T1, arg2: T2, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2) => Promise<void>; // ----------------------------------- +1.9 Complexity index (+1.9 atomic)
            
                            
                        
promisify Complexity Index 2.7 Cyclomatic complexity 1
                            
                                
                
                function promisify<T1, T2, T3, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: TResult) => void) => void): // ------- +1.9 Complexity index (+1.9 atomic)
                    (arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>; // ----------------------------------------------------------------------------------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
promisify Complexity Index 2.4 Cyclomatic complexity 1
                            
                                
                    
                function promisify<T1, T2, T3>(fn: (arg1: T1, arg2: T2, arg3: T3, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2, arg3: T3) => Promise<void>; // ------- +2.4 Complexity index (+2.4 atomic)
            
                            
                        
promisify Complexity Index 3.2 Cyclomatic complexity 1
                            
                                
                
                function promisify<T1, T2, T3, T4, TResult>( // ---------------------------------------------------------------------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
                    fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: any, result: TResult) => void) => void, // ---------------------------------------------------------- +1.6 Complexity index (+1.6 atomic)
                ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>; // -------------------------------------------------------------------------------------------------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
promisify Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
                
                function promisify<T1, T2, T3, T4>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err?: any) => void) => void): // ------- +1.9 Complexity index (+1.9 atomic)
                    (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>; // ----------------------------------------------------------------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
promisify Complexity Index 3.7 Cyclomatic complexity 1
                            
                                
                    
                function promisify<T1, T2, T3, T4, T5, TResult>( // ------------------------------------------------------------------------- +0.7 Complexity index (+0.7 atomic)
                    fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: any, result: TResult) => void) => void, // ------- +1.8 Complexity index (+1.8 atomic)
                ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>; // ----------------------------------------------- +1.2 Complexity index (+1.2 atomic)
            
                            
                        
promisify Complexity Index 3.4 Cyclomatic complexity 1
                            
                                
                
                function promisify<T1, T2, T3, T4, T5>( // ------------------------------------------------------------------ +0.6 Complexity index (+0.6 atomic)
                    fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err?: any) => void) => void, // ------- +1.6 Complexity index (+1.6 atomic)
                ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>; // ---------------------------------- +1.2 Complexity index (+1.2 atomic)
            
                            
                        
promisify Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                function promisify(fn: Function): Function; // ----------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
isAnyArrayBuffer Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                    function isAnyArrayBuffer(object: any): boolean; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
isArgumentsObject Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                    
                    function isArgumentsObject(object: any): object is IArguments; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isArrayBuffer Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                    
                    function isArrayBuffer(object: any): object is ArrayBuffer; // ---------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isArrayBufferView Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                    
                    function isArrayBufferView(object: any): object is ArrayBufferView; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isAsyncFunction Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                    
                    function isAsyncFunction(object: any): boolean; // --------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
isBigInt64Array Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                    
                    function isBigInt64Array(value: any): value is BigInt64Array; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isBigUint64Array Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                    
                    function isBigUint64Array(value: any): value is BigUint64Array; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isBooleanObject Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                    
                    function isBooleanObject(object: any): object is Boolean; // ------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isBoxedPrimitive Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                    
                    function isBoxedPrimitive(object: any): object is (Number | Boolean | String | Symbol /* | Object(BigInt) | Object(Symbol) */); // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
isDataView Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                    
                    function isDataView(object: any): object is DataView; // --------------------------------------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isDate Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                    
                    function isDate(object: any): object is Date; // --------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isExternal Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                    
                    function isExternal(object: any): boolean; // ---------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
isFloat32Array Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                    
                    function isFloat32Array(object: any): object is Float32Array; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isFloat64Array Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                    
                    function isFloat64Array(object: any): object is Float64Array; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isGeneratorFunction Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                    
                    function isGeneratorFunction(object: any): boolean; // ----------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
isGeneratorObject Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                    
                    function isGeneratorObject(object: any): boolean; // --------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
isInt8Array Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                    
                    function isInt8Array(object: any): object is Int8Array; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isInt16Array Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                    
                    function isInt16Array(object: any): object is Int16Array; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isInt32Array Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                    
                    function isInt32Array(object: any): object is Int32Array; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isMap Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                    
                    function isMap(object: any): boolean; // --------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
isMapIterator Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                    
                    function isMapIterator(object: any): boolean; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
isModuleNamespaceObject Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                    
                    function isModuleNamespaceObject(value: any): boolean; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
isNativeError Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                    
                    function isNativeError(object: any): object is Error; // -------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isNumberObject Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                    
                    function isNumberObject(object: any): object is Number; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isPromise Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                    
                    function isPromise(object: any): boolean; // --------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
isProxy Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                    
                    function isProxy(object: any): boolean; // --------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
isRegExp Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                    
                    function isRegExp(object: any): object is RegExp; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isSet Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                    
                    function isSet(object: any): boolean; // ------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
isSetIterator Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                    
                    function isSetIterator(object: any): boolean; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
isSharedArrayBuffer Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                    
                    function isSharedArrayBuffer(object: any): boolean; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
isStringObject Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                    
                    function isStringObject(object: any): boolean; // ------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
isSymbolObject Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                    
                    function isSymbolObject(object: any): boolean; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
isTypedArray Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                    
                    function isTypedArray(object: any): object is NodeJS.TypedArray; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isUint8Array Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                    
                    function isUint8Array(object: any): object is Uint8Array; // -------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isUint8ClampedArray Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                    
                    function isUint8ClampedArray(object: any): object is Uint8ClampedArray; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isUint16Array Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                    
                    function isUint16Array(object: any): object is Uint16Array; // ------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isUint32Array Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                    
                    function isUint32Array(object: any): object is Uint32Array; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isWeakMap Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                    
                    function isWeakMap(object: any): boolean; // ------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
isWeakSet Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                    
                    function isWeakSet(object: any): boolean; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
isWebAssemblyCompiledModule Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                    
                    function isWebAssemblyCompiledModule(object: any): boolean; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
Complexity Index 0.5 Cyclomatic complexity 0
                            
                                
                    
                    constructor(
                      encoding?: string, // --------------------------------------- +0.2 Complexity index (+0.2 atomic)
                      options?: { fatal?: boolean; ignoreBOM?: boolean } // ------- +0.3 Complexity index (+0.3 atomic)
                    );
            
                            
                        
decode Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                    
                    decode( // ------------------------------------------------------ +0.1 Complexity index (+0.1 atomic)
                      input?: NodeJS.ArrayBufferView | ArrayBuffer | null, // ------- +0.5 Complexity index (+0.5 atomic)
                      options?: { stream?: boolean } // ----------------------------- +0.2 Complexity index (+0.2 atomic)
                    ): string; // --------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
encode Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                    
                    encode(input?: string): Uint8Array; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
encodeInto Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                    
                    encodeInto(input: string, output: Uint8Array): EncodeIntoResult; // ------- +0.6 Complexity index (+0.6 atomic)