@pezkuwi/util 14.0.13 → 14.0.14

package/src/u8a/toBigInt.spec.ts

@@ -1,106 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import { TESTS } from '../bi/toU8a.spec.js';
-import { perf } from '../test/index.js';
-import { u8aToBigInt } from './index.js';
-
-// test-cases are the same as in u8aToBn
-describe('u8aToBigInt', (): void => {
-  it('converts little-endian by default', (): void => {
-    expect(
-      u8aToBigInt(
-        new Uint8Array([0x12, 0x34])
-      ).toString(16)
-    ).toBe('3412');
-  });
-
-  describe('empty creation', (): void => {
-    it('handles unsigned (le)', (): void => {
-      expect(
-        u8aToBigInt(
-          new Uint8Array(),
-          { isLe: true }
-        ).toString(16)
-      ).toBe('0');
-    });
-
-    it('handles signed (le)', (): void => {
-      expect(
-        u8aToBigInt(
-          new Uint8Array(),
-          { isLe: true, isNegative: true }
-        ).toString(16)
-      ).toBe('0');
-    });
-
-    it('handles unsigned (be)', (): void => {
-      expect(
-        u8aToBigInt(
-          new Uint8Array(),
-          { isLe: false }
-        ).toString(16)
-      ).toBe('0');
-    });
-
-    it('handles signed (be)', (): void => {
-      expect(
-        u8aToBigInt(
-          new Uint8Array(),
-          { isLe: false, isNegative: true }
-        ).toString(16)
-      ).toBe('0');
-    });
-  });
-
-  it('handles overflows correctly (little-endian)', (): void => {
-    expect(
-      u8aToBigInt(
-        new Uint8Array([0, 1, 0, 0, 0, 0, 0, 0]),
-        { isLe: true }
-      )
-    ).toBe(256n);
-  });
-
-  describe('length tests', (): void => {
-    [true, false].forEach((isLe) => {
-      for (let i = 1; i < 32; i++) {
-        const tu8a = [0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78];
-        const tstr = tu8a.map((n) => n.toString(16));
-
-        it(`converts values with bitLength=${i * 8}, isLe=${isLe}`, (): void => {
-          expect(
-            u8aToBigInt(
-              new Uint8Array(tu8a.slice(0, i)),
-              { isLe }
-            ).toString(16)
-          ).toBe(
-            isLe
-              ? tstr.slice(0, i).reverse().join('')
-              : tstr.slice(0, i).join('')
-          );
-        });
-      }
-    });
-  });
-
-  describe('conversion tests', (): void => {
-    TESTS.forEach(([isLe, isNegative, numarr, strval], i): void => {
-      it(`#${i}: creates ${strval} (bitLength=${numarr.length * 8}, isLe=${isLe}, isNegative=${isNegative})`, (): void => {
-        expect(
-          u8aToBigInt(
-            new Uint8Array(numarr),
-            { isLe, isNegative }
-          ).toString()
-        ).toBe(strval);
-      });
-    });
-  });
-
-  perf('u8aToBigInt (i32)', 750_000, [[new Uint8Array([0x9c, 0x9c, 0x9c, 0x9c])]], (v: Uint8Array) => u8aToBigInt(v, { isNegative: true }));
-  perf('u8aToBigInt (u32)', 750_000, [[new Uint8Array([0x68, 0x65, 0x6c, 0x6c])]], u8aToBigInt);
-  perf('u8aToBigInt (u64)', 750_000, [[new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0x68, 0x65, 0x6c, 0x6c])]], u8aToBigInt);
-  perf('u8aToBigInt (u128)', 750_000, [[new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0x68, 0x65, 0x6c, 0x6c, 0x68, 0x65, 0x6c, 0x6c, 0x68, 0x65, 0x6c, 0x6c])]], u8aToBigInt);
-});

package/src/u8a/toBigInt.ts

@@ -1,100 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { ToBnOptions } from '../types.js';
-
-import { BigInt } from '@pezkuwi/x-bigint';
-
-import { _1n } from '../bi/consts.js';
-
-const U8_MAX = BigInt(256);
-const U16_MAX = BigInt(256 * 256);
-const U64_MAX = BigInt('0x10000000000000000');
-
-/**
- * @name u8aToBigInt
- * @summary Creates a BigInt from a Uint8Array object.
- */
-export function u8aToBigInt (value: Uint8Array, { isLe = true, isNegative = false }: ToBnOptions = {}): bigint {
-  // slice + reverse is expensive, however SCALE is LE by default so this is the path
-  // we are most interested in (the BE is added for the sake of being comprehensive)
-  if (!isLe) {
-    value = value.slice().reverse();
-  }
-
-  const count = value.length;
-
-  if (isNegative && count && (value[count - 1] & 0x80)) {
-    switch (count) {
-      case 0:
-        return BigInt(0);
-
-      case 1:
-        return BigInt(((value[0] ^ 0x0000_00ff) * -1) - 1);
-
-      case 2:
-        return BigInt((((value[0] + (value[1] << 8)) ^ 0x0000_ffff) * -1) - 1);
-
-      case 4:
-        return BigInt((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) * -1) - 1);
-    }
-
-    const dvI = new DataView(value.buffer, value.byteOffset);
-
-    if (count === 8) {
-      return dvI.getBigInt64(0, true);
-    }
-
-    let result = BigInt(0);
-    const mod = count % 2;
-
-    for (let i = count - 2; i >= mod; i -= 2) {
-      result = (result * U16_MAX) + BigInt(dvI.getUint16(i, true) ^ 0xffff);
-    }
-
-    if (mod) {
-      result = (result * U8_MAX) + BigInt(value[0] ^ 0xff);
-    }
-
-    return (result * -_1n) - _1n;
-  }
-
-  switch (count) {
-    case 0:
-      return BigInt(0);
-
-    case 1:
-      return BigInt(value[0]);
-
-    case 2:
-      return BigInt(value[0] + (value[1] << 8));
-
-    case 4:
-      return BigInt(value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00));
-  }
-
-  const dvI = new DataView(value.buffer, value.byteOffset);
-
-  switch (count) {
-    case 8:
-      return dvI.getBigUint64(0, true);
-
-    case 16:
-      return (dvI.getBigUint64(8, true) * U64_MAX) + dvI.getBigUint64(0, true);
-
-    default: {
-      let result = BigInt(0);
-      const mod = count % 2;
-
-      for (let i = count - 2; i >= mod; i -= 2) {
-        result = (result * U16_MAX) + BigInt(dvI.getUint16(i, true));
-      }
-
-      if (mod) {
-        result = (result * U8_MAX) + BigInt(value[0]);
-      }
-
-      return result;
-    }
-  }
-}

package/src/u8a/toBn.spec.ts

@@ -1,106 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import { TESTS } from '../bi/toU8a.spec.js';
-import { perf } from '../test/index.js';
-import { u8aToBn } from './index.js';
-
-// test-cases are the same as in u8aToBigInt
-describe('u8aToBn', (): void => {
-  it('converts little-endian by default', (): void => {
-    expect(
-      u8aToBn(
-        new Uint8Array([0x12, 0x34])
-      ).toString(16)
-    ).toBe('3412');
-  });
-
-  describe('empty creation', (): void => {
-    it('handles unsigned (le)', (): void => {
-      expect(
-        u8aToBn(
-          new Uint8Array(),
-          { isLe: true }
-        ).toString(16)
-      ).toBe('0');
-    });
-
-    it('handles signed (le)', (): void => {
-      expect(
-        u8aToBn(
-          new Uint8Array(),
-          { isLe: true, isNegative: true }
-        ).toString(16)
-      ).toBe('0');
-    });
-
-    it('handles unsigned (be)', (): void => {
-      expect(
-        u8aToBn(
-          new Uint8Array(),
-          { isLe: false }
-        ).toString(16)
-      ).toBe('0');
-    });
-
-    it('handles signed (be)', (): void => {
-      expect(
-        u8aToBn(
-          new Uint8Array(),
-          { isLe: false, isNegative: true }
-        ).toString(16)
-      ).toBe('0');
-    });
-  });
-
-  it('handles overflows correctly (little-endian)', (): void => {
-    expect(
-      u8aToBn(
-        new Uint8Array([0, 1, 0, 0, 0, 0, 0, 0]),
-        { isLe: true }
-      ).toNumber()
-    ).toBe(256);
-  });
-
-  describe('length tests', (): void => {
-    [true, false].forEach((isLe) => {
-      for (let i = 1; i < 32; i++) {
-        const tu8a = [0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78];
-        const tstr = tu8a.map((n) => n.toString(16));
-
-        it(`converts values with bitLength=${i * 8}, isLe=${isLe}`, (): void => {
-          expect(
-            u8aToBn(
-              new Uint8Array(tu8a.slice(0, i)),
-              { isLe }
-            ).toString(16)
-          ).toBe(
-            isLe
-              ? tstr.slice(0, i).reverse().join('')
-              : tstr.slice(0, i).join('')
-          );
-        });
-      }
-    });
-  });
-
-  describe('conversion tests', (): void => {
-    TESTS.forEach(([isLe, isNegative, numarr, strval], i): void => {
-      it(`#${i}: creates ${strval} (bitLength=${numarr.length * 8}, isLe=${isLe}, isNegative=${isNegative})`, (): void => {
-        expect(
-          u8aToBn(
-            new Uint8Array(numarr),
-            { isLe, isNegative }
-          ).toString()
-        ).toBe(strval);
-      });
-    });
-  });
-
-  perf('u8aToBn (i32)', 750_000, [[new Uint8Array([0x9c, 0x9c, 0x9c, 0x9c])]], (v: Uint8Array) => u8aToBn(v, { isNegative: true }));
-  perf('u8aToBn (u32)', 750_000, [[new Uint8Array([0x68, 0x65, 0x6c, 0x6c])]], u8aToBn);
-  perf('u8aToBn (u64)', 750_000, [[new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0x68, 0x65, 0x6c, 0x6c])]], u8aToBn);
-  perf('u8aToBn (u128)', 750_000, [[new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0x68, 0x65, 0x6c, 0x6c, 0x68, 0x65, 0x6c, 0x6c, 0x68, 0x65, 0x6c, 0x6c])]], u8aToBn);
-});

package/src/u8a/toBn.ts

@@ -1,101 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { ToBnOptions } from '../types.js';
-
-import { BN } from '../bn/bn.js';
-
-/**
- * @name u8aToBn
- * @summary Creates a BN from a Uint8Array object.
- * @description
- * `UInt8Array` input values return the actual BN. `null` or `undefined` values returns an `0x0` value.
- * @param value The value to convert
- * @param options Options to pass while converting
- * @param options.isLe Convert using Little Endian (default)
- * @param options.isNegative Convert using two's complement
- * @example
- * <BR>
- *
- * ```javascript
- * import { u8aToBn } from '@pezkuwi/util';
- *
- * u8aToHex(new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0xf])); // 0x68656c0f
- * ```
- */
-export function u8aToBn (value: Uint8Array, { isLe = true, isNegative = false }: ToBnOptions = {}): BN {
-  // slice + reverse is expensive, however SCALE is LE by default so this is the path
-  // we are most interested in (the BE is added for the sake of being comprehensive)
-  if (!isLe) {
-    value = value.slice().reverse();
-  }
-
-  const count = value.length;
-
-  // shortcut for <= u48 values - in this case the manual conversion
-  // here seems to be more efficient than passing the full array
-  if (isNegative && count && (value[count - 1] & 0x80)) {
-    // Most common case i{8, 16, 32} default LE SCALE-encoded
-    // For <= 32, we also optimize the xor to a single op
-    switch (count) {
-      case 0:
-        return new BN(0);
-
-      case 1:
-        return new BN(((value[0] ^ 0x0000_00ff) * -1) - 1);
-
-      case 2:
-        return new BN((((value[0] + (value[1] << 8)) ^ 0x0000_ffff) * -1) - 1);
-
-      case 3:
-        return new BN((((value[0] + (value[1] << 8) + (value[2] << 16)) ^ 0x00ff_ffff) * -1) - 1);
-
-      case 4:
-        // for the 3rd byte, we don't << 24 - since JS converts all bitwise operators to
-        // 32-bit, in the case where the top-most bit is set this yields a negative value
-        return new BN((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) * -1) - 1);
-
-      case 5:
-        return new BN(((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) + ((value[4] ^ 0xff) * 0x1_00_00_00_00)) * -1) - 1);
-
-      case 6:
-        return new BN(((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) + (((value[4] + (value[5] << 8)) ^ 0x0000_ffff) * 0x1_00_00_00_00)) * -1) - 1);
-
-      default:
-        return new BN(value, 'le').fromTwos(count * 8);
-    }
-  }
-
-  // Most common case - u{8, 16, 32} default LE SCALE-encoded
-  //
-  // There are some slight benefits in unrolling this specific loop,
-  // however it comes with diminishing returns since here the actual
-  // `new BN` does seem to take up the bulk of the time
-  switch (count) {
-    case 0:
-      return new BN(0);
-
-    case 1:
-      return new BN(value[0]);
-
-    case 2:
-      return new BN(value[0] + (value[1] << 8));
-
-    case 3:
-      return new BN(value[0] + (value[1] << 8) + (value[2] << 16));
-
-    case 4:
-      // for the 3rd byte, we don't << 24 - since JS converts all bitwise operators to
-      // 32-bit, in the case where the top-most bit is set this yields a negative value
-      return new BN(value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00));
-
-    case 5:
-      return new BN(value[0] + (value[1] << 8) + (value[2] << 16) + ((value[3] + (value[4] << 8)) * 0x1_00_00_00));
-
-    case 6:
-      return new BN(value[0] + (value[1] << 8) + (value[2] << 16) + ((value[3] + (value[4] << 8) + (value[5] << 16)) * 0x1_00_00_00));
-
-    default:
-      return new BN(value, 'le');
-  }
-}

package/src/u8a/toBuffer.spec.ts

@@ -1,20 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import { u8aToBuffer } from './index.js';
-
-describe('u8aToBuffer', (): void => {
-  it('returns [] when the buffer is null', (): void => {
-    expect(
-      u8aToBuffer(null)
-    ).toEqual(Buffer.from([]));
-  });
-
-  it('returns the Buffer value for the Uint8Array', (): void => {
-    expect(
-      u8aToBuffer(new Uint8Array([128, 0, 10]))
-    ).toEqual(Buffer.from([128, 0, 10]));
-  });
-});

package/src/u8a/toBuffer.ts

@@ -1,28 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { BufferClass, BufferObject } from '../types.js';
-
-import { xglobal } from '@pezkuwi/x-global';
-
-import { hasBuffer } from '../has.js';
-
-/**
- * @name u8aToBuffer
- * @summary Creates a Buffer object from a hex string.
- * @description
- * `null` inputs returns an empty `Buffer` result. `UInt8Array` input values return the actual bytes value converted to a `Buffer`. Anything that is not a `UInt8Array` throws an error.
- * @example
- * <BR>
- *
- * ```javascript
- * import { u8aToBuffer } from '@pezkuwi/util';
- *
- * console.log('Buffer', u8aToBuffer(new Uint8Array([1, 2, 3])));
- * ```
- */
-export function u8aToBuffer <T = BufferObject> (value?: Uint8Array | null): T {
-  return hasBuffer
-    ? (xglobal.Buffer as unknown as BufferClass).from(value || [])
-    : new Uint8Array(value || []) as T;
-}

package/src/u8a/toFloat.spec.ts

@@ -1,86 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import { hexToU8a } from '../hex/index.js';
-import { u8aToFloat } from './index.js';
-
-describe('u8aToFloat', (): void => {
-  it('throws on invalid bitLength', (): void => {
-    expect(
-      () => u8aToFloat(hexToU8a('0x00000000'), { bitLength: 48 as 32 })
-    ).toThrow();
-  });
-
-  it('throws on invalid input length', (): void => {
-    expect(
-      () => u8aToFloat(new Uint8Array())
-    ).toThrow();
-  });
-
-  describe('32-bit', (): void => {
-    it('correctly decodes +0.0', (): void => {
-      expect(
-        u8aToFloat(hexToU8a('0x00000000'))
-      ).toEqual(+0.0);
-    });
-
-    it('correctly decodes -0.0', (): void => {
-      expect(
-        u8aToFloat(hexToU8a('0x00000080'))
-      ).toEqual(-0.0);
-    });
-
-    it('correctly decodes -0.0 (BE)', (): void => {
-      expect(
-        u8aToFloat(hexToU8a('0x80000000'), { isLe: false })
-      ).toEqual(-0.0);
-    });
-
-    it('decoded NaN', (): void => {
-      expect(
-        u8aToFloat(hexToU8a('0x0000c07f'))
-      ).toEqual(Number.NaN);
-    });
-
-    // https://www.h-schmidt.net/FloatConverter/IEEE754.html
-    it('decodes a known number', (): void => {
-      expect(
-        u8aToFloat(hexToU8a('0x79e9f642')).toFixed(3)
-      ).toEqual('123.456');
-    });
-
-    it('decodes a known number (BE)', (): void => {
-      expect(
-        u8aToFloat(hexToU8a('0x42f6e979'), { isLe: false }).toFixed(3)
-      ).toEqual('123.456');
-    });
-  });
-
-  describe('64-bit', (): void => {
-    it('correctly decodes +0.0', (): void => {
-      expect(
-        u8aToFloat(hexToU8a('0x0000000000000000'), { bitLength: 64 })
-      ).toEqual(+0.0);
-    });
-
-    it('correctly decodes -0.0', (): void => {
-      expect(
-        u8aToFloat(hexToU8a('0x0000000000000080'), { bitLength: 64 })
-      ).toEqual(-0.0);
-    });
-
-    it('correctly decodes -0.0 (BE)', (): void => {
-      expect(
-        u8aToFloat(hexToU8a('0x8000000000000000'), { bitLength: 64, isLe: false })
-      ).toEqual(-0.0);
-    });
-
-    it('correctly decodes NaN', (): void => {
-      expect(
-        u8aToFloat(hexToU8a('0x000000000000f87f'), { bitLength: 64 })
-      ).toEqual(Number.NaN);
-    });
-  });
-});

package/src/u8a/toFloat.ts

@@ -1,26 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-interface Options {
-  bitLength?: 32 | 64;
-  isLe?: boolean;
-}
-
-/**
- * @name u8aToFloat
- * @description Converts a Uint8Array value into the float (either 32 or 64-bit)
- * representation.
- */
-export function u8aToFloat (value: Uint8Array, { bitLength = 32, isLe = true }: Options = {}): number {
-  if (bitLength !== 32 && bitLength !== 64) {
-    throw new Error('Invalid bitLength provided, expected 32 or 64');
-  } else if (value.length < (bitLength / 8)) {
-    throw new Error(`Invalid input buffer provided, expected at least ${bitLength / 8} bytes, found ${value.length}`);
-  }
-
-  const dv = new DataView(value.buffer, value.byteOffset);
-
-  return bitLength === 32
-    ? dv.getFloat32(0, isLe)
-    : dv.getFloat64(0, isLe);
-}

package/src/u8a/toHex.spec.ts

@@ -1,94 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import { perfCmp } from '../test/index.js';
-import { u8aToHex } from './index.js';
-import { u8aToHex as u8aToHexBuffer } from './toHexBuffer.js';
-
-const ptest32k = new Uint8Array(32768);
-const ptest256 = new Uint8Array(256);
-
-for (let i = 0, count = ptest32k.length; i < count; i++) {
-  if (i < ptest256.length) {
-    ptest256[1] = i % 256;
-  }
-
-  ptest32k[i] = i % 256;
-}
-
-describe('u8aToHex', (): void => {
-  it('returns empty as 0x', (): void => {
-    expect(
-      u8aToHex()
-    ).toEqual('0x');
-  });
-
-  it('returns empty as "" (unprefixed)', (): void => {
-    expect(
-      u8aToHex(null, -1, false)
-    ).toEqual('');
-  });
-
-  it('returns the hex value for the array', (): void => {
-    expect(
-      u8aToHex(
-        new Uint8Array([128, 0, 10])
-      )
-    ).toEqual('0x80000a');
-  });
-
-  it('returns the hex value for the array (unprefixed)', (): void => {
-    expect(
-      u8aToHex(
-        new Uint8Array([128, 0, 10]),
-        -1,
-        false
-      )
-    ).toEqual('80000a');
-  });
-
-  it('handles starting zeros correctly', (): void => {
-    expect(
-      u8aToHex(
-        new Uint8Array([0, 1, 0, 0, 0, 0, 0, 0])
-      )
-    ).toEqual('0x0001000000000000');
-  });
-
-  it('returns the hex value where allowed < max', (): void => {
-    expect(
-      u8aToHex(
-        Uint8Array.from([128, 0, 10, 11])
-      )
-    ).toEqual('0x80000a0b');
-  });
-
-  it('returns the trimmed hex value where allowed >= max', (): void => {
-    expect(
-      u8aToHex(
-        new Uint8Array([128, 0, 10, 11, 12, 13]),
-        32
-      )
-    ).toEqual('0x8000…0c0d');
-  });
-
-  it('converts known bytes to their correct values', (): void => {
-    expect(
-      // hello world
-      u8aToHex(new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64]))
-    ).toEqual('0x68656c6c6f20776f726c64');
-  });
-
-  perfCmp('u8aToHex (32k)', ['u8aToHexBuffer', 'u8aToHex'], 1000, [[ptest32k]], (s: Uint8Array, isSecond) =>
-    isSecond
-      ? u8aToHex(s)
-      : u8aToHexBuffer(s)
-  );
-  perfCmp('u8aToHex (128)', ['u8aToHexBuffer', 'u8aToHex'], 200_000, [[ptest256]], (s: Uint8Array, isSecond) =>
-    isSecond
-      ? u8aToHex(s)
-      : u8aToHexBuffer(s)
-  );
-});