@pezkuwi/util 14.0.13 → 14.0.14

package/build-deno/hex/addPrefix.ts

@@ -1,24 +0,0 @@
-
-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

@@ -1,34 +0,0 @@
-
-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

@@ -1,22 +0,0 @@
-
-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

@@ -1,14 +0,0 @@
-
-/**
- * @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

@@ -1,28 +0,0 @@
-
-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

@@ -1,17 +0,0 @@
-
-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

@@ -1,38 +0,0 @@
-
-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

@@ -1,24 +0,0 @@
-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

@@ -1,23 +0,0 @@
-
-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

@@ -1,66 +0,0 @@
-
-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

@@ -1,52 +0,0 @@
-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

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

package/build-deno/is/array.ts

@@ -1,8 +0,0 @@
-
-/**
- * @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

@@ -1,50 +0,0 @@
-
-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

@@ -1,18 +0,0 @@
-
-/**
- * @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

@@ -1,21 +0,0 @@
-
-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

@@ -1,18 +0,0 @@
-
-/**
- * @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

@@ -1,28 +0,0 @@
-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

@@ -1,27 +0,0 @@
-
-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

@@ -1,10 +0,0 @@
-
-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

@@ -1,24 +0,0 @@
-
-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

@@ -1,17 +0,0 @@
-
-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

@@ -1,21 +0,0 @@
-
-/**
- * @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

@@ -1,20 +0,0 @@
-
-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

@@ -1,21 +0,0 @@
-
-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]));
-}