@pezkuwi/util 14.0.1 → 14.0.4

package/src/u8a/toBn.ts

@@ -1,101 +0,0 @@
-// Copyright 2017-2025 @polkadot/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 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/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/toFloat.spec.ts

@@ -1,86 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/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 @polkadot/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 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/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(
-        new Uint8Array(Uint8Array.from([128, 0, 10, 11]), 64)
-      )
-    ).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)
-  );
-});

package/src/u8a/toHex.ts

@@ -1,68 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { HexString } from '../types.js';
-
-const U8 = new Array<string>(256);
-const U16 = new Array<string>(256 * 256);
-
-for (let n = 0; n < 256; n++) {
-  U8[n] = n.toString(16).padStart(2, '0');
-}
-
-for (let i = 0; i < 256; i++) {
-  const s = i << 8;
-
-  for (let j = 0; j < 256; j++) {
-    U16[s | j] = U8[i] + U8[j];
-  }
-}
-
-/** @internal */
-function hex (value: Uint8Array, result: HexString): HexString {
-  const mod = (value.length % 2) | 0;
-  const length = (value.length - mod) | 0;
-
-  for (let i = 0; i < length; i += 2) {
-    result += U16[(value[i] << 8) | value[i + 1]];
-  }
-
-  if (mod) {
-    result += U8[value[length] | 0];
-  }
-
-  return result;
-}
-
-/**
- * @name u8aToHex
- * @summary Creates a hex string from a Uint8Array object.
- * @description
- * `UInt8Array` input values return the actual hex string. `null` or `undefined` values returns an `0x` string.
- * @example
- * <BR>
- *
- * ```javascript
- * import { u8aToHex } from '@pezkuwi/util';
- *
- * u8aToHex(new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0xf])); // 0x68656c0f
- * ```
- */
-export function u8aToHex (value?: Uint8Array | null, bitLength = -1, isPrefixed = true): HexString {
-  // this is not 100% correct sinmce we support isPrefixed = false....
-  const empty = isPrefixed
-    ? '0x'
-    : '' as HexString;
-
-  if (!value?.length) {
-    return empty;
-  } else if (bitLength > 0) {
-    const length = Math.ceil(bitLength / 8);
-
-    if (value.length > length) {
-      return `${hex(value.subarray(0, length / 2), empty)}…${hex(value.subarray(value.length - length / 2), '' as HexString)}`;
-    }
-  }
-
-  return hex(value, empty);
-}

package/src/u8a/toHexBuffer.spec.ts

@@ -1,63 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { u8aToHex } from './toHexBuffer.js';
-
-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(
-        new Uint8Array(Uint8Array.from([128, 0, 10, 11]), 64)
-      )
-    ).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');
-  });
-});

package/src/u8a/toHexBuffer.ts

@@ -1,30 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { HexString } from '../types.js';
-
-/**
- * @name u8aToHex
- * @summary Creates a hex string from a Uint8Array object.
- * @description
- * `UInt8Array` input values return the actual hex string. `null` or `undefined` values returns an `0x` string.
- * @example
- * <BR>
- *
- * ```javascript
- * import { u8aToHex } from '@pezkuwi/util';
- *
- * u8aToHex(new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0xf])); // 0x68656c0f
- * ```
- */
-export function u8aToHex (value?: Uint8Array | null, bitLength = -1, isPrefixed = true): HexString {
-  const length = Math.ceil(bitLength / 8);
-
-  return `${isPrefixed ? '0x' : ''}${
-    !value?.length
-      ? ''
-      : (bitLength > 0 && value.length > length)
-        ? `${Buffer.from(value.subarray(0, length / 2)).toString('hex')}…${Buffer.from(value.subarray(value.length - length / 2)).toString('hex')}`
-        : Buffer.from(value).toString('hex')
-  }` as HexString;
-}

package/src/u8a/toNumber.spec.ts

@@ -1,47 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { TESTS } from '../bi/toU8a.spec.js';
-import { perf } from '../test/index.js';
-import { u8aToNumber } from './index.js';
-
-const TESTS_NUM = TESTS.filter(([,, numarr]) => numarr.length <= 6);
-
-describe('u8aToNumber', (): void => {
-  describe('empty creation', (): void => {
-    it('handles unsigned (le)', (): void => {
-      expect(
-        u8aToNumber(
-          new Uint8Array()
-        )
-      ).toBe(0);
-    });
-
-    it('handles signed (le)', (): void => {
-      expect(
-        u8aToNumber(
-          new Uint8Array(),
-          { isNegative: true }
-        )
-      ).toBe(0);
-    });
-  });
-
-  describe('conversion tests', (): void => {
-    TESTS_NUM.forEach(([isLe, isNegative, numarr, strval], i): void => {
-      it(`#${i}: creates ${strval} (bitLength=${numarr.length * 8}, isLe=${isLe}, isNegative=${isNegative})`, (): void => {
-        expect(
-          u8aToNumber(
-            new Uint8Array(numarr),
-            { isLe, isNegative }
-          ).toString()
-        ).toBe(strval);
-      });
-    });
-  });
-
-  perf('u8aToNumber (i32)', 750_000, [[new Uint8Array([0x9c, 0x9c, 0x9c, 0x9c])]], (v: Uint8Array) => u8aToNumber(v, { isNegative: true }));
-  perf('u8aToNumber (u32)', 750_000, [[new Uint8Array([0x68, 0x65, 0x6c, 0x6c])]], u8aToNumber);
-});

package/src/u8a/toNumber.ts

@@ -1,80 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { ToBnOptions } from '../types.js';
-
-/**
- * @name u8aToNumber
- * @summary Creates a number from a Uint8Array object.
- */
-export function u8aToNumber (value: Uint8Array, { isLe = true, isNegative = false }: ToBnOptions = {}): number {
-  // 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;
-
-  // When the value is a i{8, 16, 24, 32, 40, 40} values and the top-most bit
-  // indicates a signed value, we use a two's complement conversion. If one of these
-  // flags are not set, we just do a normal unsigned conversion (the same shortcut
-  // applies in both the u8aTo{BigInt, Bn} conversions as well)
-  if (isNegative && count && (value[count - 1] & 0x80)) {
-    switch (count) {
-      case 0:
-        return 0;
-
-      case 1:
-        return (((value[0] ^ 0x0000_00ff) * -1) - 1);
-
-      case 2:
-        return ((((value[0] + (value[1] << 8)) ^ 0x0000_ffff) * -1) - 1);
-
-      case 3:
-        return ((((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 ((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) * -1) - 1);
-
-      case 5:
-        return (((((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 (((((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:
-        throw new Error('Value more than 48-bits cannot be reliably converted');
-    }
-  }
-
-  switch (count) {
-    case 0:
-      return 0;
-
-    case 1:
-      return value[0];
-
-    case 2:
-      return value[0] + (value[1] << 8);
-
-    case 3:
-      return 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 value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00);
-
-    case 5:
-      return value[0] + (value[1] << 8) + (value[2] << 16) + ((value[3] + (value[4] << 8)) * 0x1_00_00_00);
-
-    case 6:
-      return value[0] + (value[1] << 8) + (value[2] << 16) + ((value[3] + (value[4] << 8) + (value[5] << 16)) * 0x1_00_00_00);
-
-    default:
-      throw new Error('Value more than 48-bits cannot be reliably converted');
-  }
-}

package/src/u8a/toString.spec.ts

@@ -1,36 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { u8aToString } from './index.js';
-
-describe('u8aToString', (): void => {
-  it('decodes to an empty string for undefined', (): void => {
-    expect(
-      u8aToString()
-    ).toEqual('');
-  });
-
-  it('decodes to an empty string for empty buffer', (): void => {
-    expect(
-      u8aToString(new Uint8Array())
-    ).toEqual('');
-  });
-
-  it('decodes the Uint8Array correctly (ru)', (): void => {
-    expect(
-      u8aToString(
-        new Uint8Array([208, 159, 209, 128, 208, 184, 208, 178, 208, 181, 209, 130, 44, 32, 208, 188, 208, 184, 209, 128, 33])
-      )
-    ).toEqual('Привет, мир!');
-  });
-
-  it('decodes the Uint8Array correctly (en)', (): void => {
-    expect(
-      u8aToString(
-        new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64])
-      )
-    ).toEqual('hello world');
-  });
-});