@pezkuwi/util 14.0.22 → 14.0.23

package/build-deno/hex/addPrefix.ts

@@ -0,0 +1,24 @@
+
+import type { HexString } from '../types.ts';
+
+import { hexHasPrefix } from './hasPrefix.ts';
+
+/**
+ * @name hexAddPrefix
+ * @summary Adds the `0x` prefix to string values.
+ * @description
+ * Returns a `0x` prefixed string from the input value. If the input is already prefixed, it is returned unchanged.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { hexAddPrefix } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+ *
+ * console.log('With prefix', hexAddPrefix('0a0b12')); // => 0x0a0b12
+ * ```
+ */
+export function hexAddPrefix (value?: string | null): HexString {
+  return value && hexHasPrefix(value)
+    ? value
+    : `0x${value && value.length % 2 === 1 ? '0' : ''}${value || ''}`;
+}

package/build-deno/hex/fixLength.ts

@@ -0,0 +1,34 @@
+
+import type { HexString } from '../types.ts';
+
+import { hexAddPrefix } from './addPrefix.ts';
+import { hexStripPrefix } from './stripPrefix.ts';
+
+/**
+ * @name hexFixLength
+ * @summary Shifts a hex string to a specific bitLength
+ * @description
+ * Returns a `0x` prefixed string 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. Input values with less bits are returned as-is by default. When `withPadding` is set, shorter values are padded with `0`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { hexFixLength } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+ *
+ * console.log('fixed', hexFixLength('0x12', 16)); // => 0x12
+ * console.log('fixed', hexFixLength('0x12', 16, true)); // => 0x0012
+ * console.log('fixed', hexFixLength('0x0012', 8)); // => 0x12
+ * ```
+ */
+export function hexFixLength (value: string, bitLength = -1, withPadding = false): HexString {
+  const strLength = Math.ceil(bitLength / 4);
+  const hexLength = strLength + 2;
+
+  return hexAddPrefix(
+    (bitLength === -1 || value.length === hexLength || (!withPadding && value.length < hexLength))
+      ? hexStripPrefix(value)
+      : (value.length > hexLength)
+        ? hexStripPrefix(value).slice(-1 * strLength)
+        : `${'0'.repeat(strLength)}${hexStripPrefix(value)}`.slice(-1 * strLength)
+  );
+}

package/build-deno/hex/hasPrefix.ts

@@ -0,0 +1,22 @@
+
+import type { HexString } from '../types.ts';
+
+import { isHex } from '../is/hex.ts';
+
+/**
+ * @name hexHasPrefix
+ * @summary Tests for the existence of a `0x` prefix.
+ * @description
+ * Checks for a valid hex input value and if the start matched `0x`
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { hexHasPrefix } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+ *
+ * console.log('has prefix', hexHasPrefix('0x1234')); // => true
+ * ```
+ */
+export function hexHasPrefix (value?: string | null): value is HexString {
+  return !!value && isHex(value, -1);
+}

package/build-deno/hex/index.ts

@@ -0,0 +1,14 @@
+
+/**
+ * @summary Internal utilities to create and test for hex values
+ */
+
+export { hexAddPrefix } from './addPrefix.ts';
+export { hexFixLength } from './fixLength.ts';
+export { hexHasPrefix } from './hasPrefix.ts';
+export { hexStripPrefix } from './stripPrefix.ts';
+export { hexToBigInt } from './toBigInt.ts';
+export { hexToBn } from './toBn.ts';
+export { hexToNumber } from './toNumber.ts';
+export { hexToString } from './toString.ts';
+export { hexToU8a } from './toU8a.ts';

package/build-deno/hex/stripPrefix.ts

@@ -0,0 +1,28 @@
+
+import { REGEX_HEX_NOPREFIX, REGEX_HEX_PREFIXED } from '../is/hex.ts';
+
+/**
+ * @name hexStripPrefix
+ * @summary Strips any leading `0x` prefix.
+ * @description
+ * Tests for the existence of a `0x` prefix, and returns the value without the prefix. Un-prefixed values are returned as-is.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { hexStripPrefix } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+ *
+ * console.log('stripped', hexStripPrefix('0x1234')); // => 1234
+ * ```
+ */
+export function hexStripPrefix (value?: string | null): string {
+  if (!value || value === '0x') {
+    return '';
+  } else if (REGEX_HEX_PREFIXED.test(value)) {
+    return value.substring(2);
+  } else if (REGEX_HEX_NOPREFIX.test(value)) {
+    return value;
+  }
+
+  throw new Error(`Expected hex value to convert, found '${value}'`);
+}

package/build-deno/hex/toBigInt.ts

@@ -0,0 +1,17 @@
+
+import type { ToBnOptions } from '../types.ts';
+
+import { BigInt } from 'https://deno.land/x/pezkuwi/x-bigint/mod.ts';
+
+import { u8aToBigInt } from '../u8a/toBigInt.ts';
+import { hexToU8a } from './toU8a.ts';
+
+/**
+ * @name hexToBigInt
+ * @summary Creates a BigInt instance object from a hex string.
+ */
+export function hexToBigInt (value?: string | null, { isLe = false, isNegative = false }: ToBnOptions = {}): bigint {
+  return !value || value === '0x'
+    ? BigInt(0)
+    : u8aToBigInt(hexToU8a(value), { isLe, isNegative });
+}

package/build-deno/hex/toBn.ts

@@ -0,0 +1,38 @@
+
+import type { ToBnOptions } from '../types.ts';
+
+import { BN } from '../bn/bn.ts';
+import { hexStripPrefix } from './stripPrefix.ts';
+
+/**
+ * @name hexToBn
+ * @summary Creates a BN.js object from a hex string.
+ * @description
+ * `null` inputs returns a `BN(0)` result. Hex input values return the actual value converted to a BN. Anything that is not a hex string (including the `0x` prefix) throws an error.
+ * @param _value The value to convert
+ * @param _options Options to pass while converting
+ * @param _options.isLe Convert using Little Endian
+ * @param _options.isNegative Convert using two's complement
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { hexToBn } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+ *
+ * hexToBn('0x123480001f'); // => BN(0x123480001f)
+ * ```
+ */
+export function hexToBn (value?: string | null, { isLe = false, isNegative = false }: ToBnOptions = {}): BN {
+  if (!value || value === '0x') {
+    return new BN(0);
+  }
+
+  const stripped = hexStripPrefix(value);
+  const bn = new BN(stripped, 16, isLe ? 'le' : 'be');
+
+  // fromTwos takes as parameter the number of bits, which is the hex length
+  // multiplied by 4 (2 bytes being 8 bits)
+  return isNegative
+    ? bn.fromTwos(stripped.length * 4)
+    : bn;
+}

package/build-deno/hex/toNumber.ts

@@ -0,0 +1,24 @@
+import { Buffer } from 'node:buffer';
+
+
+import { hexToBn } from './toBn.ts';
+
+/**
+ * @name hexToNumber
+ * @summary Creates a Number value from a Buffer object.
+ * @description
+ * `null` inputs returns an NaN result, `hex` values return the actual value as a `Number`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { hexToNumber } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+ *
+ * hexToNumber('0x1234'); // => 0x1234
+ * ```
+ */
+export function hexToNumber (value?: string | null): number {
+  return value
+    ? hexToBn(value).toNumber()
+    : NaN;
+}

package/build-deno/hex/toString.ts

@@ -0,0 +1,23 @@
+
+import { u8aToString } from '../u8a/toString.ts';
+import { hexToU8a } from './toU8a.ts';
+
+/**
+ * @name hexToU8a
+ * @summary Creates a Uint8Array object from a hex string.
+ * @description
+ * Hex input values return the actual bytes value converted to a string. Anything that is not a hex string (including the `0x` prefix) throws an error.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { hexToString } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+ *
+ * hexToU8a('0x68656c6c6f'); // hello
+ * ```
+ */
+export function hexToString (_value?: string | null): string {
+  return u8aToString(
+    hexToU8a(_value)
+  );
+}

package/build-deno/hex/toU8a.ts

@@ -0,0 +1,66 @@
+
+const CHR = '0123456789abcdef';
+const U8 = new Uint8Array(256);
+const U16 = new Uint8Array(256 * 256);
+
+for (let i = 0, count = CHR.length; i < count; i++) {
+  U8[CHR[i].charCodeAt(0) | 0] = i | 0;
+
+  if (i > 9) {
+    U8[CHR[i].toUpperCase().charCodeAt(0) | 0] = i | 0;
+  }
+}
+
+for (let i = 0; i < 256; i++) {
+  const s = i << 8;
+
+  for (let j = 0; j < 256; j++) {
+    U16[s | j] = (U8[i] << 4) | U8[j];
+  }
+}
+
+/**
+ * @name hexToU8a
+ * @summary Creates a Uint8Array object from a hex string.
+ * @description
+ * `null` inputs returns an empty `Uint8Array` result. Hex input values return the actual bytes value converted to a Uint8Array. Anything that is not a hex string (including the `0x` prefix) throws an error.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { hexToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+ *
+ * hexToU8a('0x80001f'); // Uint8Array([0x80, 0x00, 0x1f])
+ * hexToU8a('0x80001f', 32); // Uint8Array([0x00, 0x80, 0x00, 0x1f])
+ * ```
+ */
+export function hexToU8a (value?: string | null, bitLength = -1): Uint8Array {
+  if (!value) {
+    return new Uint8Array();
+  }
+
+  let s = value.startsWith('0x')
+    ? 2
+    : 0;
+
+  const decLength = Math.ceil((value.length - s) / 2);
+  const endLength = Math.ceil(
+    bitLength === -1
+      ? decLength
+      : bitLength / 8
+  );
+  const result = new Uint8Array(endLength);
+  const offset = endLength > decLength
+    ? endLength - decLength
+    : 0;
+
+  for (let i = offset; i < endLength; i++, s += 2) {
+    // The big factor here is actually the string lookups. If we do
+    // HEX_TO_U16[value.substring()] we get an 10x slowdown. In the
+    // same vein using charCodeAt (as opposed to value[s] or value.charAt(s)) is
+    // also the faster operation by at least 2x with the character map above
+    result[i] = U16[(value.charCodeAt(s) << 8) | value.charCodeAt(s + 1)];
+  }
+
+  return result;
+}

package/build-deno/hex/toU8aBuffer.ts

@@ -0,0 +1,52 @@
+import { Buffer } from 'node:buffer';
+
+
+/**
+ * @name hexToU8a
+ * @summary Creates a Uint8Array object from a hex string.
+ * @description
+ * `null` inputs returns an empty `Uint8Array` result. Hex input values return the actual bytes value converted to a Uint8Array. Anything that is not a hex string (including the `0x` prefix) throws an error.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { hexToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+ *
+ * hexToU8a('0x80001f'); // Uint8Array([0x80, 0x00, 0x1f])
+ * hexToU8a('0x80001f', 32); // Uint8Array([0x00, 0x80, 0x00, 0x1f])
+ * ```
+ */
+export function hexToU8a (_value?: string | null, bitLength = -1): Uint8Array {
+  if (!_value) {
+    return new Uint8Array();
+  }
+
+  const value = _value.startsWith('0x')
+    ? _value.substring(2)
+    : _value;
+  const buf = Buffer.from(value, 'hex');
+  const valLength = value.length / 2;
+  const resultLength = Math.ceil(
+    bitLength === -1
+      ? valLength
+      : bitLength / 8
+  );
+
+  if (resultLength === valLength) {
+    return Uint8Array.from(buf);
+  }
+
+  const offset = resultLength > valLength
+    ? resultLength - valLength
+    : 0;
+
+  if (offset) {
+    const u8a = new Uint8Array(resultLength);
+
+    u8a.set(buf, offset);
+
+    return u8a;
+  }
+
+  return Uint8Array.from(buf.subarray(0, resultLength));
+}

package/build-deno/index.ts

@@ -0,0 +1,4 @@
+
+import './packageDetect.ts';
+
+export * from './bundle.ts';

package/build-deno/is/array.ts

@@ -0,0 +1,8 @@
+
+/**
+ * @name isArray
+ * @summary Tests for a Array instance.
+ */
+export function isArray <T> (value?: unknown): value is T[] {
+  return Array.isArray(value);
+}

package/build-deno/is/ascii.ts

@@ -0,0 +1,50 @@
+
+import type { AnyString, U8aLike } from '../types.ts';
+
+import { u8aToU8a } from '../u8a/toU8a.ts';
+import { isHex } from './hex.ts';
+import { isString } from './string.ts';
+
+/** @internal */
+function isAsciiStr (str: AnyString): boolean {
+  for (let i = 0, count = str.length; i < count; i++) {
+    const b = str.charCodeAt(i);
+
+    // check is inlined here, it is faster than making a call
+    if (b < 32 || b > 126) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/** @internal */
+function isAsciiBytes (u8a: Uint8Array | number[]): boolean {
+  for (let i = 0, count = u8a.length; i < count; i++) {
+    const b = u8a[i] | 0;
+
+    // check is inlined here, it is faster than making a call
+    if (b < 32 || b > 126) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * @name isAscii
+ * @summary Tests if the input is printable ASCII
+ * @description
+ * Checks to see if the input string or Uint8Array is printable ASCII, 32-127 + formatters
+ */
+export function isAscii (value?: U8aLike | null): boolean {
+  return isString(value)
+    ? isHex(value)
+      ? isAsciiBytes(u8aToU8a(value))
+      : isAsciiStr(value)
+    : value
+      ? isAsciiBytes(value)
+      : false;
+}

package/build-deno/is/bigInt.ts

@@ -0,0 +1,18 @@
+
+/**
+ * @name isBigInt
+ * @summary Tests for a `BigInt` object instance.
+ * @description
+ * Checks to see if the input object is an instance of `BigInt`
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { isBigInt } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+ *
+ * console.log('isBigInt', isBigInt(123_456n)); // => true
+ * ```
+ */
+export function isBigInt (value: unknown): value is bigint {
+  return typeof value === 'bigint';
+}

package/build-deno/is/bn.ts

@@ -0,0 +1,21 @@
+
+import { BN } from '../bn/bn.ts';
+
+/**
+ * @name isBn
+ * @summary Tests for a `BN` object instance.
+ * @description
+ * Checks to see if the input object is an instance of `BN` (bn.js).
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import BN from 'https://esm.sh/bn.js@5.2.1';
+ * import { isBn } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+ *
+ * console.log('isBn', isBn(new BN(1))); // => true
+ * ```
+ */
+export function isBn (value: unknown): value is BN {
+  return BN.isBN(value);
+}

package/build-deno/is/boolean.ts

@@ -0,0 +1,18 @@
+
+/**
+ * @name isBoolean
+ * @summary Tests for a boolean value.
+ * @description
+ * Checks to see if the input value is a JavaScript boolean.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { isBoolean } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+ *
+ * isBoolean(false); // => true
+ * ```
+ */
+export function isBoolean (value: unknown): value is boolean {
+  return typeof value === 'boolean';
+}

package/build-deno/is/buffer.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';
+import { isFunction } from './function.ts';
+
+/**
+ * @name isBuffer
+ * @summary Tests for a `Buffer` object instance.
+ * @description
+ * Checks to see if the input object is an instance of `Buffer`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { isBuffer } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+ *
+ * console.log('isBuffer', isBuffer(Buffer.from([]))); // => true
+ * ```
+ */
+export function isBuffer <T = BufferObject> (value: unknown): value is T {
+  // we do check a function first, since it is slightly faster than isBuffer itself
+  return hasBuffer && !!value && isFunction((value as unknown as BufferObject).readDoubleLE) && (xglobal.Buffer as unknown as BufferClass).isBuffer(value);
+}

package/build-deno/is/childClass.ts

@@ -0,0 +1,27 @@
+
+import type { Class } from '../types.ts';
+
+import { isClass } from './class.ts';
+
+/**
+ * @name isChildClass
+ * @summary Tests if the child extends the parent Class
+ * @description
+ * Checks to see if the child Class extends the parent Class
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { isChildClass } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+ *
+ * console.log('isChildClass', isChildClass(BN, BN); // => true
+ * console.log('isChildClass', isChildClass(BN, Uint8Array); // => false
+ * ```
+ */
+export function isChildClass <P extends Class> (Parent: P, Child?: unknown): Child is P {
+  // https://stackoverflow.com/questions/30993434/check-if-a-constructor-inherits-another-in-es6/30993664
+  return isClass(Child) && isClass(Parent)
+    // eslint-disable-next-line no-prototype-builtins
+    ? Parent === Child || Parent.isPrototypeOf(Child)
+    : false;
+}

package/build-deno/is/class.ts

@@ -0,0 +1,10 @@
+
+import type { Class } from '../types.ts';
+
+import { isOnFunction } from './helpers.ts';
+
+/**
+ * @name isClass
+ * Tests if the supplied argument is a Class
+ */
+export const isClass: <T extends Class> (value?: unknown) => value is T = /*#__PURE__*/ isOnFunction('isPrototypeOf', 'hasOwnProperty');

package/build-deno/is/codec.ts

@@ -0,0 +1,24 @@
+
+import type { HexString } from '../types.ts';
+
+import { isOnObject } from './helpers.ts';
+
+interface Registry {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  get: (...params: never[]) => any;
+}
+
+interface Codec {
+  readonly registry: Registry;
+
+  toHex (...params: never[]): HexString;
+  toHuman (...params: never[]): unknown;
+  toU8a: (...params: never[]) => Uint8Array;
+}
+
+const checkCodec = /*#__PURE__*/ isOnObject<Codec>('toHex', 'toHuman', 'toU8a');
+const checkRegistry = /*#__PURE__*/ isOnObject<Registry>('get');
+
+export function isCodec <T extends Codec = Codec> (value?: unknown): value is T {
+  return checkCodec(value) && checkRegistry(value.registry);
+}

package/build-deno/is/compact.ts

@@ -0,0 +1,17 @@
+
+import type { BN } from '../bn/bn.ts';
+
+import { isOnObject } from './helpers.ts';
+
+interface Compact<T> {
+  toBigInt (): bigint;
+  toBn (): BN;
+  toNumber (): number;
+  unwrap (): T;
+}
+
+/**
+ * @name isCompact
+ * @summary Tests for SCALE-Compact-like object instance.
+ */
+export const isCompact: <T> (value?: unknown) => value is Compact<T> = /*#__PURE__*/ isOnObject('toBigInt', 'toBn', 'toNumber', 'unwrap');

package/build-deno/is/error.ts

@@ -0,0 +1,21 @@
+
+/**
+ * @name isError
+ * @summary Tests for a `Error` object instance.
+ * @description
+ * Checks to see if the input object is an instance of `Error`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { isError } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+ *
+ * console.log('isError', isError(new Error('message'))); // => true
+ * ```
+ */
+export function isError (value: unknown): value is Error {
+  return (
+    ((value && (value as Error).constructor) === Error) ||
+    value instanceof Error
+  );
+}

package/build-deno/is/function.ts

@@ -0,0 +1,20 @@
+
+type FnType = Function;
+
+/**
+ * @name isFunction
+ * @summary Tests for a `function`.
+ * @description
+ * Checks to see if the input value is a JavaScript function.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { isFunction } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+ *
+ * isFunction(() => false); // => true
+ * ```
+ */
+export function isFunction (value: unknown): value is FnType {
+  return typeof value === 'function';
+}

package/build-deno/is/helpers.ts

@@ -0,0 +1,21 @@
+
+import { isFunction } from './function.ts';
+import { isObject } from './object.ts';
+
+export function isOn <T> (...fns: (keyof T)[]): (value?: unknown) => value is T {
+  return (value?: unknown): value is T =>
+    (isObject(value) || isFunction(value)) &&
+    fns.every((f) => isFunction((value as T)[f]));
+}
+
+export function isOnFunction <T> (...fns: (keyof T)[]): (value?: unknown) => value is T {
+  return (value?: unknown): value is T =>
+    isFunction(value) &&
+    fns.every((f) => isFunction((value as T)[f]));
+}
+
+export function isOnObject <T> (...fns: (keyof T)[]): (value?: unknown) => value is T {
+  return (value?: unknown): value is T =>
+    isObject(value) &&
+    fns.every((f) => isFunction((value as T)[f]));
+}