@pezkuwi/util 14.0.1 → 14.0.3

package/src/u8a/empty.spec.ts

@@ -1,46 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { perf } from '../test/index.js';
-import { u8aEmpty } from './index.js';
-
-describe('u8aEmpty', (): void => {
-  it('returns true on zero length', (): void => {
-    expect(
-      u8aEmpty(new Uint8Array())
-    ).toEqual(true);
-  });
-
-  it('returns true on all zero values', (): void => {
-    expect(
-      u8aEmpty(new Uint8Array([0, 0, 0, 0, 0, 0]))
-    ).toEqual(true);
-  });
-
-  it('returns false when value is found', (): void => {
-    expect(
-      u8aEmpty(new Uint8Array([0, 0, 0, 0, 0, 1]))
-    ).toEqual(false);
-  });
-
-  it('returns false when value is found (256)', (): void => {
-    const test = new Uint8Array(256);
-
-    expect(
-      u8aEmpty(test)
-    ).toEqual(true);
-
-    test[128] = 1;
-
-    expect(
-      u8aEmpty(test)
-    ).toEqual(false);
-  });
-
-  perf('u8aEmpty (32 cmp)', 1_000_000, [[new Uint8Array(32)]], u8aEmpty);
-  perf('u8aEmpty (64 cmp)', 500_000, [[new Uint8Array(64)]], u8aEmpty);
-  perf('u8aEmpty (128 cmp)', 250_000, [[new Uint8Array(128)]], u8aEmpty);
-  perf('u8aEmpty (256 cmp)', 125_000, [[new Uint8Array(256)]], u8aEmpty);
-});

package/src/u8a/empty.ts

@@ -1,22 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/**
- * @name u8aEmpty
- * @summary Tests for a `Uint8Array` for emptyness
- * @description
- * Checks to see if the input `Uint8Array` has zero length or contains all 0 values.
- */
-export function u8aEmpty (value: Uint8Array): boolean {
-  const len = value.length | 0;
-
-  // on smaller sizes, the byte-by-byte compare is faster than allocating
-  // another object for DataView (on very large arrays the DataView is faster)
-  for (let i = 0; i < len; i++) {
-    if (value[i] | 0) {
-      return false;
-    }
-  }
-
-  return true;
-}

package/src/u8a/eq.spec.ts

@@ -1,113 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { perf } from '../test/index.js';
-import { u8aEq } from './index.js';
-
-const ltest = new Uint8Array(32768);
-const stest = new Uint8Array(256);
-const ztest = new Uint8Array(64);
-
-for (let i = 0, count = ltest.length; i < count; i++) {
-  if (i < ztest.length) {
-    ztest[i] = i % 256;
-  }
-
-  if (i < stest.length) {
-    stest[i] = i % 256;
-  }
-
-  ltest[i] = i % 256;
-}
-
-describe('u8aEq', (): void => {
-  it('returns false when the lengths do not match', (): void => {
-    expect(
-      u8aEq(
-        new Uint8Array([1, 2, 3]),
-        new Uint8Array([1, 2])
-      )
-    ).toEqual(false);
-  });
-
-  it('returns false when the contents do not match', (): void => {
-    expect(
-      u8aEq(
-        new Uint8Array([1, 2, 3]),
-        new Uint8Array([1, 2, 4])
-      )
-    ).toEqual(false);
-  });
-
-  it('returns true when the contents do match', (): void => {
-    expect(
-      u8aEq(
-        new Uint8Array([1, 2, 3]),
-        new Uint8Array([1, 2, 3])
-      )
-    ).toEqual(true);
-  });
-
-  it('returns false when the contents do not match (with u32 start)', (): void => {
-    expect(
-      u8aEq(
-        new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3]),
-        new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 4])
-      )
-    ).toEqual(false);
-  });
-
-  it('returns true when the contents do match (with u32 start)', (): void => {
-    expect(
-      u8aEq(
-        new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3]),
-        new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3])
-      )
-    ).toEqual(true);
-  });
-
-  it('returns false when the contents do not match (u32 only)', (): void => {
-    expect(
-      u8aEq(
-        new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]),
-        new Uint8Array([1, 2, 3, 4, 5, 6, 7, 9])
-      )
-    ).toEqual(false);
-  });
-
-  it('returns true when the contents do match (u32 only)', (): void => {
-    expect(
-      u8aEq(
-        new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]),
-        new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8])
-      )
-    ).toEqual(true);
-  });
-
-  it('returns true with equalvalent hex & Uint8array', (): void => {
-    expect(
-      u8aEq(
-        '0x010203',
-        new Uint8Array([1, 2, 3])
-      )
-    ).toEqual(true);
-  });
-
-  it('works on aubarray values', (): void => {
-    const a = new Uint8Array(16);
-
-    for (let i = 0, count = a.length; i < count; i++) {
-      a[i] = i;
-    }
-
-    expect(
-      u8aEq(a.subarray(0, 5), a.subarray(0, 5))
-    ).toEqual(true);
-  });
-
-  perf('u8aEq (64 cmp)', 200_000, [[ztest, ztest]], u8aEq);
-  perf('u8aEq (256 cmp)', 200_000, [[stest, stest]], u8aEq);
-  perf('u8aEq (32k cmp)', 10_000, [[ltest, ltest]], u8aEq);
-});

package/src/u8a/eq.ts

@@ -1,46 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { u8aToU8a } from './toU8a.js';
-
-/**
- * @name u8aEq
- * @summary Compares two Uint8Arrays for equality.
- * @description
- * For `UInt8Array` (or hex string) input values true if there is a match.
- * @example
- * <BR>
- *
- * ```javascript
- * import { u8aEq } from '@pezkuwi/util';
- *
- * u8aEq(new Uint8Array([0x68, 0x65]), new Uint8Array([0x68, 0x65])); // true
- * ```
- */
-export function u8aEq (a: string | Uint8Array, b: string | Uint8Array): boolean {
-  const u8aa = u8aToU8a(a);
-  const u8ab = u8aToU8a(b);
-
-  if (u8aa.length === u8ab.length) {
-    const dvA = new DataView(u8aa.buffer, u8aa.byteOffset);
-    const dvB = new DataView(u8ab.buffer, u8ab.byteOffset);
-    const mod = (u8aa.length % 4) | 0;
-    const length = (u8aa.length - mod) | 0;
-
-    for (let i = 0; i < length; i += 4) {
-      if (dvA.getUint32(i) !== dvB.getUint32(i)) {
-        return false;
-      }
-    }
-
-    for (let i = length, count = u8aa.length; i < count; i++) {
-      if (u8aa[i] !== u8ab[i]) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  return false;
-}

package/src/u8a/fixLength.spec.ts

@@ -1,34 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { u8aFixLength } from './index.js';
-
-describe('u8aFixLength', (): void => {
-  it('returns bitLength === -1 as-is', (): void => {
-    expect(
-      u8aFixLength(
-        new Uint8Array([0x12, 0x34, 0x56, 0x78])
-      )
-    ).toEqual(new Uint8Array([0x12, 0x34, 0x56, 0x78]));
-  });
-
-  it('does not change when bitlength === length', (): void => {
-    expect(
-      u8aFixLength(new Uint8Array([0x12, 0x34, 0x56, 0x78]), 32)
-    ).toEqual(new Uint8Array([0x12, 0x34, 0x56, 0x78]));
-  });
-
-  it('trims values when bitLength > length', (): void => {
-    expect(
-      u8aFixLength(new Uint8Array([0x12, 0x34, 0x56, 0x78]), 16)
-    ).toEqual(new Uint8Array([0x12, 0x34]));
-  });
-
-  it('adds zeros when bitLength < length (withPadded)', (): void => {
-    expect(
-      u8aFixLength(new Uint8Array([0x12, 0x34]), 32)
-    ).toEqual(new Uint8Array([0, 0, 0x12, 0x34]));
-  });
-});

package/src/u8a/fixLength.ts

@@ -1,34 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/**
- * @name u8aFixLength
- * @summary Shifts a Uint8Array to a specific bitLength
- * @description
- * Returns a uint8Array with the specified number of bits contained in the return value. (If bitLength is -1, length checking is not done). Values with more bits are trimmed to the specified length.
- * @example
- * <BR>
- *
- * ```javascript
- * import { u8aFixLength } from '@pezkuwi/util';
- *
- * u8aFixLength('0x12') // => 0x12
- * u8aFixLength('0x12', 16) // => 0x0012
- * u8aFixLength('0x1234', 8) // => 0x12
- * ```
- */
-export function u8aFixLength (value: Uint8Array, bitLength = -1, atStart = false): Uint8Array {
-  const byteLength = Math.ceil(bitLength / 8);
-
-  if (bitLength === -1 || value.length === byteLength) {
-    return value;
-  } else if (value.length > byteLength) {
-    return value.subarray(0, byteLength);
-  }
-
-  const result = new Uint8Array(byteLength);
-
-  result.set(value, atStart ? 0 : (byteLength - value.length));
-
-  return result;
-}

package/src/u8a/sorted.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 { u8aSorted } from './index.js';
-
-describe('u8aSorted', (): void => {
-  it('sorts a simple set of u8a', (): void => {
-    expect(
-      u8aSorted([new Uint8Array([1, 2, 3]), new Uint8Array([4, 5, 6]), new Uint8Array([2, 3, 4])])
-    ).toEqual([new Uint8Array([1, 2, 3]), new Uint8Array([2, 3, 4]), new Uint8Array([4, 5, 6])]);
-  });
-
-  it('sorts a simple set of u8a (not the same lengths)', (): void => {
-    expect(
-      u8aSorted([new Uint8Array([1, 2, 3, 4]), new Uint8Array([4, 5, 6]), new Uint8Array([1, 2, 3, 5])])
-    ).toEqual([new Uint8Array([1, 2, 3, 4]), new Uint8Array([1, 2, 3, 5]), new Uint8Array([4, 5, 6])]);
-  });
-});

package/src/u8a/toBigInt.spec.ts

@@ -1,106 +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 { 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 @polkadot/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 @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 { 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);
-});