@pezkuwi/util 14.0.5 → 14.0.6

package/build-deno/u8a/toBn.ts

@@ -0,0 +1,99 @@
+
+import type { ToBnOptions } from '../types.ts';
+
+import { BN } from '../bn/bn.ts';
+
+/**
+ * @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 'https://deno.land/x/pezkuwi/util/mod.ts';
+ *
+ * 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/build-deno/u8a/toBuffer.ts

@@ -0,0 +1,28 @@
+import { Buffer } from 'node:buffer';
+
+
+import type { BufferClass, BufferObject } from '../types.ts';
+
+import { xglobal } from 'https://deno.land/x/pezkuwi/x-global/mod.ts';
+
+import { hasBuffer } from '../has.ts';
+
+/**
+ * @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 'https://deno.land/x/pezkuwi/util/mod.ts';
+ *
+ * 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/build-deno/u8a/toFloat.ts

@@ -0,0 +1,24 @@
+
+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/build-deno/u8a/toHex.ts

@@ -0,0 +1,66 @@
+
+import type { HexString } from '../types.ts';
+
+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 'https://deno.land/x/pezkuwi/util/mod.ts';
+ *
+ * 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/build-deno/u8a/toHexBuffer.ts

@@ -0,0 +1,30 @@
+import { Buffer } from 'node:buffer';
+
+
+import type { HexString } from '../types.ts';
+
+/**
+ * @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 'https://deno.land/x/pezkuwi/util/mod.ts';
+ *
+ * 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/build-deno/u8a/toNumber.ts

@@ -0,0 +1,78 @@
+
+import type { ToBnOptions } from '../types.ts';
+
+/**
+ * @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/build-deno/u8a/toString.ts

@@ -0,0 +1,24 @@
+
+import { TextDecoder } from 'https://deno.land/x/pezkuwi/x-textdecoder/mod.ts';
+
+const decoder = new TextDecoder('utf-8');
+
+/**
+ * @name u8aToString
+ * @summary Creates a utf-8 string from a Uint8Array object.
+ * @description
+ * `UInt8Array` input values return the actual decoded utf-8 string. `null` or `undefined` values returns an empty string.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { u8aToString } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+ *
+ * u8aToString(new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0x6f])); // hello
+ * ```
+ */
+export function u8aToString (value?: Uint8Array | null): string {
+  return value
+    ? decoder.decode(value)
+    : '';
+}

package/build-deno/u8a/toU8a.ts

@@ -0,0 +1,46 @@
+import { Buffer } from 'node:buffer';
+
+
+import type { U8aLike } from '../types.ts';
+
+import { hexToU8a } from '../hex/toU8a.ts';
+import { isBuffer } from '../is/buffer.ts';
+import { isHex } from '../is/hex.ts';
+import { isU8a } from '../is/u8a.ts';
+import { stringToU8a } from '../string/toU8a.ts';
+
+/**
+ * @name u8aToU8a
+ * @summary Creates a Uint8Array value from a Uint8Array, Buffer, string or hex input.
+ * @description
+ * `null` or `undefined` inputs returns a `[]` result, Uint8Array values returns the value, hex strings returns a Uint8Array representation.
+ * If `strict` is true, `null` or `undefined` will throw an error instead of returning an empty array.
+ * Supports input types: Uint8Array, Buffer, hex string, string, or number array.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+ *
+ * u8aToU8a(new Uint8Array([0x12, 0x34]); // => Uint8Array([0x12, 0x34])
+ * u8aToU8a(0x1234); // => Uint8Array([0x12, 0x34])
+ * ```
+ */
+export function u8aToU8a (value?: U8aLike | null, strict = false): Uint8Array {
+  if (strict && (value === null || value === undefined)) {
+    throw new Error('u8aToU8a: Expected non-null, non-undefined value');
+  }
+
+  return isU8a(value)
+    // NOTE isBuffer needs to go here since it actually extends
+    // Uint8Array on Node.js environments, so all Buffer are Uint8Array,
+    // but Uint8Array is not Buffer
+    ? isBuffer(value)
+      ? new Uint8Array(value)
+      : value
+    : isHex(value)
+      ? hexToU8a(value)
+      : Array.isArray(value)
+        ? new Uint8Array(value)
+        : stringToU8a(value);
+}

package/build-deno/u8a/wrap.ts

@@ -0,0 +1,62 @@
+
+
+import type { U8aLike } from '../types.ts';
+
+import { u8aConcatStrict } from './concat.ts';
+import { u8aEq } from './eq.ts';
+import { u8aToU8a } from './toU8a.ts';
+
+/** @internal */
+export const U8A_WRAP_ETHEREUM = /*#__PURE__*/ u8aToU8a('\x19Ethereum Signed Message:\n');
+
+/** @internal */
+export const U8A_WRAP_PREFIX = /*#__PURE__*/ u8aToU8a('<Bytes>');
+
+/** @internal */
+export const U8A_WRAP_POSTFIX = /*#__PURE__*/ u8aToU8a('</Bytes>');
+
+const WRAP_LEN = U8A_WRAP_PREFIX.length + U8A_WRAP_POSTFIX.length;
+
+/** @internal */
+export function u8aIsWrapped (u8a: Uint8Array, withEthereum: boolean): boolean {
+  return (
+    (
+      u8a.length >= WRAP_LEN &&
+      u8aEq(u8a.subarray(0, U8A_WRAP_PREFIX.length), U8A_WRAP_PREFIX) &&
+      u8aEq(u8a.slice(-U8A_WRAP_POSTFIX.length), U8A_WRAP_POSTFIX)
+    ) ||
+    (
+      withEthereum &&
+      u8a.length >= U8A_WRAP_ETHEREUM.length &&
+      u8aEq(u8a.subarray(0, U8A_WRAP_ETHEREUM.length), U8A_WRAP_ETHEREUM)
+    )
+  );
+}
+
+/**
+ * @name u8aUnwrapBytes
+ * @description Removes all <Bytes>...</Bytes> wrappers from the supplied value
+ */
+export function u8aUnwrapBytes (bytes: U8aLike): Uint8Array {
+  const u8a = u8aToU8a(bytes);
+
+  // we don't want to unwrap Ethereum-style wraps
+  return u8aIsWrapped(u8a, false)
+    ? u8a.subarray(U8A_WRAP_PREFIX.length, u8a.length - U8A_WRAP_POSTFIX.length)
+    : u8a;
+}
+
+/**
+ * @name u8aWrapBytes
+ * @description
+ * Adds a <Bytes>...</Bytes> wrapper to the supplied value, if
+ * - We don't already have a Bytes wrapper
+ * - The message is not an Ethereum-style message
+ */
+export function u8aWrapBytes (bytes: U8aLike): Uint8Array {
+  const u8a = u8aToU8a(bytes);
+
+  return u8aIsWrapped(u8a, true)
+    ? u8a
+    : u8aConcatStrict([U8A_WRAP_PREFIX, u8a, U8A_WRAP_POSTFIX]);
+}

package/build-tsc/array/chunk.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @name arrayChunk
+ * @summary Split T[] into T[][] based on the defind size
+ * @description
+ * Returns a set ao arrays based on the chunksize
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { arrayChunk } from '@pezkuwi/util';
+ *
+ * arrayChunk([1, 2, 3, 4, 5]); // [[1, 2], [3, 4], [5]]
+ * ```
+ */
+export declare function arrayChunk<T>(array: T[], chunkSize: number): T[][];

package/build-tsc/array/filter.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @name arrayFilter
+ * @summary Filters undefined and (optionally) null values from an array
+ * @description
+ * Returns a new array with all `undefined` values removed. Optionally, when `allowNulls = false`, it removes the `null` values as well
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { arrayFilter } from '@pezkuwi/util';
+ *
+ * arrayFilter([0, void 0, true, null, false, '']); // [0, true, null, false, '']
+ * arrayFilter([0, void 0, true, null, false, ''], false); // [0, true, false, '']
+ * ```
+ */
+export declare function arrayFilter<T = unknown>(array: readonly (T | null | undefined)[], allowNulls?: boolean): T[];

package/build-tsc/array/flatten.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @name arrayFlatten
+ * @summary Merge T[][] into T[]
+ * @description
+ * Returns a new array with all arrays merged into one
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { arrayFlatten } from '@pezkuwi/util';
+ *
+ * arrayFlatten([[1, 2], [3, 4], [5]]); // [1, 2, 3, 4, 5]
+ * ```
+ */
+export declare function arrayFlatten<T>(arrays: readonly T[][]): T[];

package/build-tsc/array/range.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @name arrayRange
+ * @summary Returns a range of numbers ith the size and the specified offset
+ * @description
+ * Returns a new array of numbers with the specific size. Optionally, when `startAt`, is provided, it generates the range to start at a specific value.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { arrayRange } from '@pezkuwi/util';
+ *
+ * arrayRange(5); // [0, 1, 2, 3, 4]
+ * arrayRange(3, 5); // [5, 6, 7]
+ * ```
+ */
+export declare function arrayRange(size: number, startAt?: number): number[];

package/build-tsc/assert.d.ts

@@ -0,0 +1,29 @@
+type MessageFn = () => string;
+/**
+ * @name assert
+ * @summary Checks for a valid test, if not Error is thrown.
+ * @description
+ * Checks that `test` is a truthy value. If value is falsy (`null`, `undefined`, `false`, ...), it throws an Error with the supplied `message`. When `test` passes, `true` is returned.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * const { assert } from '@pezkuwi/util';
+ *
+ * assert(true, 'True should be true'); // passes
+ * assert(false, 'False should not be true'); // Error thrown
+ * assert(false, () => 'message'); // Error with 'message'
+ * ```
+ */
+export declare function assert(condition: unknown, message: string | MessageFn): asserts condition;
+/**
+ * @name assertReturn
+ * @description Returns when the value is not undefined/null, otherwise throws assertion error
+ */
+export declare function assertReturn<T>(value: T | undefined | null, message: string | MessageFn): T;
+/**
+ * @name assertUnreachable
+ * @description An assertion helper that ensures all codepaths are followed
+ */
+export declare function assertUnreachable(x: never): never;
+export {};

package/build-tsc/bn/min.d.ts

@@ -0,0 +1,29 @@
+import type { BN } from './bn.js';
+/**
+ * @name bnMax
+ * @summary Finds and returns the highest value in an array of BNs.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import BN from 'bn.js';
+ * import { bnMax } from '@pezkuwi/util';
+ *
+ * bnMax([new BN(1), new BN(3), new BN(2)]).toString(); // => '3'
+ * ```
+ */
+export declare const bnMax: (...items: BN[]) => BN;
+/**
+ * @name bnMin
+ * @summary Finds and returns the smallest value in an array of BNs.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import BN from 'bn.js';
+ * import { bnMin } from '@pezkuwi/util';
+ *
+ * bnMin([new BN(1), new BN(3), new BN(2)]).toString(); // => '1'
+ * ```
+ */
+export declare const bnMin: (...items: BN[]) => BN;

package/build-tsc/bn/sqrt.d.ts

@@ -0,0 +1,16 @@
+import type { ToBn } from '../types.js';
+import { BN } from './bn.js';
+/**
+ * @name bnSqrt
+ * @summary Calculates the integer square root of a BN
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import BN from 'bn.js';
+ * import { bnSqrt } from '@pezkuwi/util';
+ *
+ * bnSqrt(new BN(16)).toString(); // => '4'
+ * ```
+ */
+export declare function bnSqrt<ExtToBn extends ToBn>(value: ExtToBn | BN | bigint | string | number | null): BN;

package/build-tsc/bn/toBn.d.ts

@@ -0,0 +1,19 @@
+import type { ToBigInt, ToBn } from '../types.js';
+import { BN } from './bn.js';
+/**
+ * @name bnToBn
+ * @summary Creates a BN value from a BN, bigint, string (base 10 or hex) or number input.
+ * @description
+ * `null` inputs returns a `0x0` result, BN values returns the value, numbers returns a BN representation.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import BN from 'bn.js';
+ * import { bnToBn } from '@pezkuwi/util';
+ *
+ * bnToBn(0x1234); // => BN(0x1234)
+ * bnToBn(new BN(0x1234)); // => BN(0x1234)
+ * ```
+ */
+export declare function bnToBn<ExtToBn extends ToBigInt | ToBn>(value?: ExtToBn | BN | bigint | string | number | null): BN;

package/build-tsc/bn/toHex.d.ts

@@ -0,0 +1,18 @@
+import type { HexString, NumberOptions, ToBn } from '../types.js';
+import type { BN } from './bn.js';
+/**
+ * @name bnToHex
+ * @summary Creates a hex value from a BN.js bignumber object.
+ * @description
+ * `null` inputs returns a `0x` result, BN values return the actual value as a `0x` prefixed hex value. Anything that is not a BN object throws an error. With `bitLength` set, it fixes the number to the specified length.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import BN from 'bn.js';
+ * import { bnToHex } from '@pezkuwi/util';
+ *
+ * bnToHex(new BN(0x123456)); // => '0x123456'
+ * ```
+ */
+export declare function bnToHex<ExtToBn extends ToBn>(value?: ExtToBn | BN | bigint | number | null, { bitLength, isLe, isNegative }?: NumberOptions): HexString;

package/build-tsc/bn/toU8a.d.ts

@@ -0,0 +1,17 @@
+import type { NumberOptions, ToBn } from '../types.js';
+import type { BN } from './bn.js';
+/**
+ * @name bnToU8a
+ * @summary Creates a Uint8Array object from a BN.
+ * @description
+ * `null`/`undefined`/`NaN` inputs returns an empty `Uint8Array` result. `BN` input values return the actual bytes value converted to a `Uint8Array`. Optionally convert using little-endian format if `isLE` is set.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { bnToU8a } from '@pezkuwi/util';
+ *
+ * bnToU8a(new BN(0x1234)); // => [0x12, 0x34]
+ * ```
+ */
+export declare function bnToU8a<ExtToBn extends ToBn>(value?: ExtToBn | BN | bigint | number | null, { bitLength, isLe, isNegative }?: NumberOptions): Uint8Array;