@bsv/sdk 1.0.13 → 1.0.15

package/src/primitives/Hash.ts

@@ -49,7 +49,7 @@ abstract class BaseHash {
   padLength: number
   hmacStrength: number
 
-  constructor(
+  constructor (
     blockSize: number, outSize: number, hmacStrength: number, padLength: number
   ) {
     this.pending = null
@@ -64,15 +64,15 @@ abstract class BaseHash {
     this._delta32 = this.blockSize / 32
   }
 
-  _update(msg: number[], start: number): void {
+  _update (msg: number[], start: number): void {
     throw new Error('Not implemented')
   }
 
-  _digest(): number[] {
+  _digest (): number[] {
     throw new Error('Not implemented')
   }
 
-  _digestHex(): string {
+  _digestHex (): string {
     throw new Error('Not implemented')
   }
 
@@ -89,7 +89,7 @@ abstract class BaseHash {
    * @example
    * sha256.update('Hello World', 'utf8');
    */
-  update(msg: number[] | string, enc?: 'hex' | 'utf8'): this {
+  update (msg: number[] | string, enc?: 'hex' | 'utf8'): this {
     // Convert message to array, pad it, and join into 32bit blocks
     msg = toArray(msg, enc)
     if (this.pending == null) {
@@ -127,7 +127,7 @@ abstract class BaseHash {
    * @example
    * const hash = sha256.digest();
    */
-  digest(): number[] {
+  digest (): number[] {
     this.update(this._pad())
     assert(this.pending === null)
 
@@ -144,10 +144,10 @@ abstract class BaseHash {
    * @example
    * const hash = sha256.digestHex();
    */
-  digestHex(): string {
+  digestHex (): string {
     this.update(this._pad())
     assert(this.pending === null)
-    
+
     return this._digestHex()
   };
 
@@ -159,7 +159,7 @@ abstract class BaseHash {
    *
    * @returns Returns an array denoting the padding.
    */
-  private _pad(): number[] { //
+  private _pad (): number[] { //
     let len = this.pendingTotal
     const bytes = this._delta8
     const k = bytes - ((len + this.padLength) % bytes)
@@ -199,7 +199,7 @@ abstract class BaseHash {
   }
 }
 
-function isSurrogatePair(msg: string, i: number): boolean {
+function isSurrogatePair (msg: string, i: number): boolean {
   if ((msg.charCodeAt(i) & 0xFC00) !== 0xD800) {
     return false
   }
@@ -210,12 +210,12 @@ function isSurrogatePair(msg: string, i: number): boolean {
 }
 
 /**
- * 
- * @param msg 
+ *
+ * @param msg
  * @param enc Optional. Encoding to use if msg is string. Default is 'utf8'.
  * @returns array of byte values from msg. If msg is an array, a copy is returned.
  */
-export function toArray(msg: number[] | string, enc?: 'hex' | 'utf8'): number[] {
+export function toArray (msg: number[] | string, enc?: 'hex' | 'utf8'): number[] {
   if (Array.isArray(msg)) { return msg.slice() }
   if (!(msg as unknown as boolean)) { return [] }
   const res = []
@@ -261,7 +261,7 @@ export function toArray(msg: number[] | string, enc?: 'hex' | 'utf8'): number[]
   return res
 }
 
-function htonl(w: number): number {
+function htonl (w: number): number {
   const res = (w >>> 24) |
     ((w >>> 8) & 0xff00) |
     ((w << 8) & 0xff0000) |
@@ -269,7 +269,7 @@ function htonl(w: number): number {
   return res >>> 0
 }
 
-function toHex32(msg: number[], endian?: 'little' | 'big'): string {
+function toHex32 (msg: number[], endian?: 'little' | 'big'): string {
   let res = ''
   for (let i = 0; i < msg.length; i++) {
     let w = msg[i]
@@ -279,7 +279,7 @@ function toHex32(msg: number[], endian?: 'little' | 'big'): string {
   return res
 }
 
-function zero8(word: string): string {
+function zero8 (word: string): string {
   if (word.length === 7) {
     return '0' + word
   } else if (word.length === 6) {
@@ -299,7 +299,7 @@ function zero8(word: string): string {
   }
 }
 
-function join32(msg, start, end, endian): number[] {
+function join32 (msg, start, end, endian): number[] {
   const len = end - start
   assert(len % 4 === 0)
   const res = new Array(len / 4)
@@ -315,7 +315,7 @@ function join32(msg, start, end, endian): number[] {
   return res
 }
 
-function split32(msg: number[], endian: 'big' | 'little'): number[] {
+function split32 (msg: number[], endian: 'big' | 'little'): number[] {
   const res = new Array(msg.length * 4)
   for (let i = 0, k = 0; i < msg.length; i++, k += 4) {
     const m = msg[i]
@@ -334,63 +334,63 @@ function split32(msg: number[], endian: 'big' | 'little'): number[] {
   return res
 }
 
-function rotr32(w: number, b: number): number {
+function rotr32 (w: number, b: number): number {
   return (w >>> b) | (w << (32 - b))
 }
 
-function rotl32(w: number, b: number): number {
+function rotl32 (w: number, b: number): number {
   return (w << b) | (w >>> (32 - b))
 }
 
-function sum32(a: number, b: number): number {
+function sum32 (a: number, b: number): number {
   return (a + b) >>> 0
 }
 
-function SUM32_3(a: number, b: number, c: number): number {
+function SUM32_3 (a: number, b: number, c: number): number {
   return (a + b + c) >>> 0
 }
 
-function SUM32_4(a: number, b: number, c: number, d: number): number {
+function SUM32_4 (a: number, b: number, c: number, d: number): number {
   return (a + b + c + d) >>> 0
 }
 
-function SUM32_5(
+function SUM32_5 (
   a: number, b: number, c: number, d: number, e: number
 ): number {
   return (a + b + c + d + e) >>> 0
 }
 
-function FT_1(s, x, y, z): number {
+function FT_1 (s, x, y, z): number {
   if (s === 0) { return ch32(x, y, z) }
   if (s === 1 || s === 3) { return p32(x, y, z) }
   if (s === 2) { return maj32(x, y, z) }
 }
 
-function ch32(x, y, z): number {
+function ch32 (x, y, z): number {
   return (x & y) ^ ((~x) & z)
 }
 
-function maj32(x, y, z): number {
+function maj32 (x, y, z): number {
   return (x & y) ^ (x & z) ^ (y & z)
 }
 
-function p32(x, y, z): number {
+function p32 (x, y, z): number {
   return x ^ y ^ z
 }
 
-function S0_256(x): number {
+function S0_256 (x): number {
   return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22)
 }
 
-function S1_256(x): number {
+function S1_256 (x): number {
   return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25)
 }
 
-function G0_256(x): number {
+function G0_256 (x): number {
   return rotr32(x, 7) ^ rotr32(x, 18) ^ (x >>> 3)
 }
 
-function G1_256(x): number {
+function G1_256 (x): number {
   return rotr32(x, 17) ^ rotr32(x, 19) ^ (x >>> 10)
 }
 
@@ -426,97 +426,97 @@ const sh = [
   8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11
 ]
 
-function f(j, x, y, z): number {
+function f (j, x, y, z): number {
   if (j <= 15) { return x ^ y ^ z } else if (j <= 31) { return (x & y) | ((~x) & z) } else if (j <= 47) { return (x | (~y)) ^ z } else if (j <= 63) { return (x & z) | (y & (~z)) } else { return x ^ (y | (~z)) }
 }
 
-function K(j): number {
+function K (j): number {
   if (j <= 15) { return 0x00000000 } else if (j <= 31) { return 0x5a827999 } else if (j <= 47) { return 0x6ed9eba1 } else if (j <= 63) { return 0x8f1bbcdc } else { return 0xa953fd4e }
 }
 
-function Kh(j): number {
+function Kh (j): number {
   if (j <= 15) { return 0x50a28be6 } else if (j <= 31) { return 0x5c4dd124 } else if (j <= 47) { return 0x6d703ef3 } else if (j <= 63) { return 0x7a6d76e9 } else { return 0x00000000 }
 }
 
-function sum64(buf, pos, ah, al) {
-  const bh = buf[pos];
-  const bl = buf[pos + 1];
+function sum64 (buf, pos, ah, al) {
+  const bh = buf[pos]
+  const bl = buf[pos + 1]
 
-  const lo = (al + bl) >>> 0;
-  const hi = (lo < al ? 1 : 0) + ah + bh;
-  buf[pos] = hi >>> 0;
-  buf[pos + 1] = lo;
+  const lo = (al + bl) >>> 0
+  const hi = (lo < al ? 1 : 0) + ah + bh
+  buf[pos] = hi >>> 0
+  buf[pos + 1] = lo
 }
 
-function sum64_hi(ah, al, bh, bl) {
-  const lo = (al + bl) >>> 0;
-  const hi = (lo < al ? 1 : 0) + ah + bh;
-  return hi >>> 0;
+function sum64_hi (ah, al, bh, bl) {
+  const lo = (al + bl) >>> 0
+  const hi = (lo < al ? 1 : 0) + ah + bh
+  return hi >>> 0
 }
 
-function sum64_lo(ah, al, bh, bl) {
-  const lo = al + bl;
-  return lo >>> 0;
+function sum64_lo (ah, al, bh, bl) {
+  const lo = al + bl
+  return lo >>> 0
 }
 
-function sum64_4_hi(ah, al, bh, bl, ch, cl, dh, dl) {
-  let carry = 0;
-  let lo = al;
-  lo = (lo + bl) >>> 0;
-  carry += lo < al ? 1 : 0;
-  lo = (lo + cl) >>> 0;
-  carry += lo < cl ? 1 : 0;
-  lo = (lo + dl) >>> 0;
-  carry += lo < dl ? 1 : 0;
+function sum64_4_hi (ah, al, bh, bl, ch, cl, dh, dl) {
+  let carry = 0
+  let lo = al
+  lo = (lo + bl) >>> 0
+  carry += lo < al ? 1 : 0
+  lo = (lo + cl) >>> 0
+  carry += lo < cl ? 1 : 0
+  lo = (lo + dl) >>> 0
+  carry += lo < dl ? 1 : 0
 
-  const hi = ah + bh + ch + dh + carry;
-  return hi >>> 0;
+  const hi = ah + bh + ch + dh + carry
+  return hi >>> 0
 }
 
-function sum64_4_lo(ah, al, bh, bl, ch, cl, dh, dl) {
-  const lo = al + bl + cl + dl;
-  return lo >>> 0;
+function sum64_4_lo (ah, al, bh, bl, ch, cl, dh, dl) {
+  const lo = al + bl + cl + dl
+  return lo >>> 0
 }
 
-function sum64_5_hi(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
-  let carry = 0;
-  let lo = al;
-  lo = (lo + bl) >>> 0;
-  carry += lo < al ? 1 : 0;
-  lo = (lo + cl) >>> 0;
-  carry += lo < cl ? 1 : 0;
-  lo = (lo + dl) >>> 0;
-  carry += lo < dl ? 1 : 0;
-  lo = (lo + el) >>> 0;
-  carry += lo < el ? 1 : 0;
+function sum64_5_hi (ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
+  let carry = 0
+  let lo = al
+  lo = (lo + bl) >>> 0
+  carry += lo < al ? 1 : 0
+  lo = (lo + cl) >>> 0
+  carry += lo < cl ? 1 : 0
+  lo = (lo + dl) >>> 0
+  carry += lo < dl ? 1 : 0
+  lo = (lo + el) >>> 0
+  carry += lo < el ? 1 : 0
 
-  const hi = ah + bh + ch + dh + eh + carry;
-  return hi >>> 0;
+  const hi = ah + bh + ch + dh + eh + carry
+  return hi >>> 0
 }
 
-function sum64_5_lo(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
-  const lo = al + bl + cl + dl + el;
+function sum64_5_lo (ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
+  const lo = al + bl + cl + dl + el
 
-  return lo >>> 0;
+  return lo >>> 0
 }
 
-function rotr64_hi(ah, al, num) {
-  const r = (al << (32 - num)) | (ah >>> num);
-  return r >>> 0;
+function rotr64_hi (ah, al, num) {
+  const r = (al << (32 - num)) | (ah >>> num)
+  return r >>> 0
 }
 
-function rotr64_lo(ah, al, num) {
-  const r = (ah << (32 - num)) | (al >>> num);
-  return r >>> 0;
+function rotr64_lo (ah, al, num) {
+  const r = (ah << (32 - num)) | (al >>> num)
+  return r >>> 0
 }
 
-function shr64_hi(ah, al, num) {
-  return ah >>> num;
+function shr64_hi (ah, al, num) {
+  return ah >>> num
 }
 
-function shr64_lo(ah, al, num) {
-  const r = (ah << (32 - num)) | (al >>> num);
-  return r >>> 0;
+function shr64_lo (ah, al, num) {
+  const r = (ah << (32 - num)) | (al >>> num)
+  return r >>> 0
 }
 
 /**
@@ -539,7 +539,7 @@ function shr64_lo(ah, al, num) {
 export class RIPEMD160 extends BaseHash {
   h: number[]
 
-  constructor() {
+  constructor () {
     super(512, 160, 192, 64)
     this.endian = 'little'
 
@@ -547,7 +547,7 @@ export class RIPEMD160 extends BaseHash {
     this.endian = 'little'
   }
 
-  _update(msg: number[], start: number): void {
+  _update (msg: number[], start: number): void {
     let A = this.h[0]
     let B = this.h[1]
     let C = this.h[2]
@@ -589,12 +589,12 @@ export class RIPEMD160 extends BaseHash {
     this.h[0] = T
   }
 
-  _digest(): number[] {
-      return split32(this.h, 'little')
+  _digest (): number[] {
+    return split32(this.h, 'little')
   }
 
-  _digestHex(): string {
-      return toHex32(this.h, 'little')
+  _digestHex (): string {
+    return toHex32(this.h, 'little')
   }
 }
 
@@ -622,7 +622,7 @@ export class SHA256 extends BaseHash {
   W: number[]
   k: number[]
 
-  constructor() {
+  constructor () {
     super(512, 256, 192, 64)
     this.h = [
       0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
@@ -649,7 +649,7 @@ export class SHA256 extends BaseHash {
     this.W = new Array(64)
   }
 
-  _update(msg: number[], start?: number): void {
+  _update (msg: number[], start?: number): void {
     const W = this.W
 
     let i: number
@@ -693,11 +693,11 @@ export class SHA256 extends BaseHash {
     this.h[7] = sum32(this.h[7], h)
   };
 
-  _digest(): number[] {
+  _digest (): number[] {
     return split32(this.h, 'big')
   }
 
-  _digestHex(): string {
+  _digestHex (): string {
     return toHex32(this.h, 'big')
   }
 }
@@ -726,7 +726,7 @@ export class SHA1 extends BaseHash {
   W: number[]
   k: number[]
 
-  constructor() {
+  constructor () {
     super(512, 160, 80, 64)
     this.k = [
       0x5A827999, 0x6ED9EBA1,
@@ -738,7 +738,7 @@ export class SHA1 extends BaseHash {
     this.W = new Array(80)
   }
 
-  _update(msg: number[], start?: number): void {
+  _update (msg: number[], start?: number): void {
     const W = this.W
 
     let i: number
@@ -771,11 +771,11 @@ export class SHA1 extends BaseHash {
     this.h[4] = sum32(this.h[4], e)
   }
 
-  _digest(): number[] {
+  _digest (): number[] {
     return split32(this.h, 'big')
   }
 
-  _digestHex(): string {
+  _digestHex (): string {
     return toHex32(this.h, 'big')
   }
 }
@@ -804,7 +804,7 @@ export class SHA512 extends BaseHash {
   W: number[]
   k: number[]
 
-  constructor() {
+  constructor () {
     super(1024, 512, 192, 128)
     this.h = [
       0x6a09e667, 0xf3bcc908,
@@ -860,251 +860,237 @@ export class SHA512 extends BaseHash {
     this.W = new Array(160)
   }
 
-
-  _prepareBlock(msg, start) {
-    const W = this.W;
+  _prepareBlock (msg, start) {
+    const W = this.W
 
     // 32 x 32bit words
     let i
-    for (i = 0; i < 32; i++)
-      W[i] = msg[start + i];
+    for (i = 0; i < 32; i++) { W[i] = msg[start + i] }
     for (; i < W.length; i += 2) {
-      const c0_hi = g1_512_hi(W[i - 4], W[i - 3]);  // i - 2
-      const c0_lo = g1_512_lo(W[i - 4], W[i - 3]);
-      const c1_hi = W[i - 14];  // i - 7
-      const c1_lo = W[i - 13];
-      const c2_hi = g0_512_hi(W[i - 30], W[i - 29]);  // i - 15
-      const c2_lo = g0_512_lo(W[i - 30], W[i - 29]);
-      const c3_hi = W[i - 32];  // i - 16
-      const c3_lo = W[i - 31];
+      const c0_hi = g1_512_hi(W[i - 4], W[i - 3]) // i - 2
+      const c0_lo = g1_512_lo(W[i - 4], W[i - 3])
+      const c1_hi = W[i - 14] // i - 7
+      const c1_lo = W[i - 13]
+      const c2_hi = g0_512_hi(W[i - 30], W[i - 29]) // i - 15
+      const c2_lo = g0_512_lo(W[i - 30], W[i - 29])
+      const c3_hi = W[i - 32] // i - 16
+      const c3_lo = W[i - 31]
 
       W[i] = sum64_4_hi(
         c0_hi, c0_lo,
         c1_hi, c1_lo,
         c2_hi, c2_lo,
-        c3_hi, c3_lo);
+        c3_hi, c3_lo)
       W[i + 1] = sum64_4_lo(
         c0_hi, c0_lo,
         c1_hi, c1_lo,
         c2_hi, c2_lo,
-        c3_hi, c3_lo);
+        c3_hi, c3_lo)
     }
   }
 
-  _update(msg, start) {
-    this._prepareBlock(msg, start);
-
-    const W = this.W;
-
-    let ah = this.h[0];
-    let al = this.h[1];
-    let bh = this.h[2];
-    let bl = this.h[3];
-    let ch = this.h[4];
-    let cl = this.h[5];
-    let dh = this.h[6];
-    let dl = this.h[7];
-    let eh = this.h[8];
-    let el = this.h[9];
-    let fh = this.h[10];
-    let fl = this.h[11];
-    let gh = this.h[12];
-    let gl = this.h[13];
-    let hh = this.h[14];
-    let hl = this.h[15];
-
-    assert(this.k.length === W.length);
+  _update (msg, start) {
+    this._prepareBlock(msg, start)
+
+    const W = this.W
+
+    let ah = this.h[0]
+    let al = this.h[1]
+    let bh = this.h[2]
+    let bl = this.h[3]
+    let ch = this.h[4]
+    let cl = this.h[5]
+    let dh = this.h[6]
+    let dl = this.h[7]
+    let eh = this.h[8]
+    let el = this.h[9]
+    let fh = this.h[10]
+    let fl = this.h[11]
+    let gh = this.h[12]
+    let gl = this.h[13]
+    let hh = this.h[14]
+    let hl = this.h[15]
+
+    assert(this.k.length === W.length)
     for (let i = 0; i < W.length; i += 2) {
-      let c0_hi = hh;
-      let c0_lo = hl;
-      let c1_hi = s1_512_hi(eh, el);
-      let c1_lo = s1_512_lo(eh, el);
-      const c2_hi = ch64_hi(eh, el, fh, fl, gh, gl);
-      const c2_lo = ch64_lo(eh, el, fh, fl, gh, gl);
-      const c3_hi = this.k[i];
-      const c3_lo = this.k[i + 1];
-      const c4_hi = W[i];
-      const c4_lo = W[i + 1];
+      let c0_hi = hh
+      let c0_lo = hl
+      let c1_hi = s1_512_hi(eh, el)
+      let c1_lo = s1_512_lo(eh, el)
+      const c2_hi = ch64_hi(eh, el, fh, fl, gh, gl)
+      const c2_lo = ch64_lo(eh, el, fh, fl, gh, gl)
+      const c3_hi = this.k[i]
+      const c3_lo = this.k[i + 1]
+      const c4_hi = W[i]
+      const c4_lo = W[i + 1]
 
       const T1_hi = sum64_5_hi(
         c0_hi, c0_lo,
         c1_hi, c1_lo,
         c2_hi, c2_lo,
         c3_hi, c3_lo,
-        c4_hi, c4_lo);
+        c4_hi, c4_lo)
       const T1_lo = sum64_5_lo(
         c0_hi, c0_lo,
         c1_hi, c1_lo,
         c2_hi, c2_lo,
         c3_hi, c3_lo,
-        c4_hi, c4_lo);
+        c4_hi, c4_lo)
 
-      c0_hi = s0_512_hi(ah, al);
-      c0_lo = s0_512_lo(ah, al);
-      c1_hi = maj64_hi(ah, al, bh, bl, ch, cl);
-      c1_lo = maj64_lo(ah, al, bh, bl, ch, cl);
+      c0_hi = s0_512_hi(ah, al)
+      c0_lo = s0_512_lo(ah, al)
+      c1_hi = maj64_hi(ah, al, bh, bl, ch, cl)
+      c1_lo = maj64_lo(ah, al, bh, bl, ch, cl)
 
-      const T2_hi = sum64_hi(c0_hi, c0_lo, c1_hi, c1_lo);
-      const T2_lo = sum64_lo(c0_hi, c0_lo, c1_hi, c1_lo);
+      const T2_hi = sum64_hi(c0_hi, c0_lo, c1_hi, c1_lo)
+      const T2_lo = sum64_lo(c0_hi, c0_lo, c1_hi, c1_lo)
 
-      hh = gh;
-      hl = gl;
+      hh = gh
+      hl = gl
 
-      gh = fh;
-      gl = fl;
+      gh = fh
+      gl = fl
 
-      fh = eh;
-      fl = el;
+      fh = eh
+      fl = el
 
-      eh = sum64_hi(dh, dl, T1_hi, T1_lo);
-      el = sum64_lo(dl, dl, T1_hi, T1_lo);
+      eh = sum64_hi(dh, dl, T1_hi, T1_lo)
+      el = sum64_lo(dl, dl, T1_hi, T1_lo)
 
-      dh = ch;
-      dl = cl;
+      dh = ch
+      dl = cl
 
-      ch = bh;
-      cl = bl;
+      ch = bh
+      cl = bl
 
-      bh = ah;
-      bl = al;
+      bh = ah
+      bl = al
 
-      ah = sum64_hi(T1_hi, T1_lo, T2_hi, T2_lo);
-      al = sum64_lo(T1_hi, T1_lo, T2_hi, T2_lo);
+      ah = sum64_hi(T1_hi, T1_lo, T2_hi, T2_lo)
+      al = sum64_lo(T1_hi, T1_lo, T2_hi, T2_lo)
     }
 
-    sum64(this.h, 0, ah, al);
-    sum64(this.h, 2, bh, bl);
-    sum64(this.h, 4, ch, cl);
-    sum64(this.h, 6, dh, dl);
-    sum64(this.h, 8, eh, el);
-    sum64(this.h, 10, fh, fl);
-    sum64(this.h, 12, gh, gl);
-    sum64(this.h, 14, hh, hl);
+    sum64(this.h, 0, ah, al)
+    sum64(this.h, 2, bh, bl)
+    sum64(this.h, 4, ch, cl)
+    sum64(this.h, 6, dh, dl)
+    sum64(this.h, 8, eh, el)
+    sum64(this.h, 10, fh, fl)
+    sum64(this.h, 12, gh, gl)
+    sum64(this.h, 14, hh, hl)
   }
 
-  _digest() {
-    return split32(this.h, 'big');
+  _digest () {
+    return split32(this.h, 'big')
   }
 
-  _digestHex() {
-    return toHex32(this.h, 'big');
+  _digestHex () {
+    return toHex32(this.h, 'big')
   }
 }
 
-function ch64_hi(xh, xl, yh, yl, zh, zl) {
-  let r = (xh & yh) ^ ((~xh) & zh);
-  if (r < 0)
-    r += 0x100000000;
-  return r;
+function ch64_hi (xh, xl, yh, yl, zh, zl) {
+  let r = (xh & yh) ^ ((~xh) & zh)
+  if (r < 0) { r += 0x100000000 }
+  return r
 }
 
-function ch64_lo(xh, xl, yh, yl, zh, zl) {
-  let r = (xl & yl) ^ ((~xl) & zl);
-  if (r < 0)
-    r += 0x100000000;
-  return r;
+function ch64_lo (xh, xl, yh, yl, zh, zl) {
+  let r = (xl & yl) ^ ((~xl) & zl)
+  if (r < 0) { r += 0x100000000 }
+  return r
 }
 
-function maj64_hi(xh, xl, yh, yl, zh, zl) {
-  let r = (xh & yh) ^ (xh & zh) ^ (yh & zh);
-  if (r < 0)
-    r += 0x100000000;
-  return r;
+function maj64_hi (xh, xl, yh, yl, zh, zl) {
+  let r = (xh & yh) ^ (xh & zh) ^ (yh & zh)
+  if (r < 0) { r += 0x100000000 }
+  return r
 }
 
-function maj64_lo(xh, xl, yh, yl, zh, zl) {
-  let r = (xl & yl) ^ (xl & zl) ^ (yl & zl);
-  if (r < 0)
-    r += 0x100000000;
-  return r;
+function maj64_lo (xh, xl, yh, yl, zh, zl) {
+  let r = (xl & yl) ^ (xl & zl) ^ (yl & zl)
+  if (r < 0) { r += 0x100000000 }
+  return r
 }
 
-function s0_512_hi(xh, xl) {
-  const c0_hi = rotr64_hi(xh, xl, 28);
-  const c1_hi = rotr64_hi(xl, xh, 2);  // 34
-  const c2_hi = rotr64_hi(xl, xh, 7);  // 39
+function s0_512_hi (xh, xl) {
+  const c0_hi = rotr64_hi(xh, xl, 28)
+  const c1_hi = rotr64_hi(xl, xh, 2) // 34
+  const c2_hi = rotr64_hi(xl, xh, 7) // 39
 
-  let r = c0_hi ^ c1_hi ^ c2_hi;
-  if (r < 0)
-    r += 0x100000000;
-  return r;
+  let r = c0_hi ^ c1_hi ^ c2_hi
+  if (r < 0) { r += 0x100000000 }
+  return r
 }
 
-function s0_512_lo(xh, xl) {
-  const c0_lo = rotr64_lo(xh, xl, 28);
-  const c1_lo = rotr64_lo(xl, xh, 2);  // 34
-  const c2_lo = rotr64_lo(xl, xh, 7);  // 39
+function s0_512_lo (xh, xl) {
+  const c0_lo = rotr64_lo(xh, xl, 28)
+  const c1_lo = rotr64_lo(xl, xh, 2) // 34
+  const c2_lo = rotr64_lo(xl, xh, 7) // 39
 
-  let r = c0_lo ^ c1_lo ^ c2_lo;
-  if (r < 0)
-    r += 0x100000000;
-  return r;
+  let r = c0_lo ^ c1_lo ^ c2_lo
+  if (r < 0) { r += 0x100000000 }
+  return r
 }
 
-function s1_512_hi(xh, xl) {
-  const c0_hi = rotr64_hi(xh, xl, 14);
-  const c1_hi = rotr64_hi(xh, xl, 18);
-  const c2_hi = rotr64_hi(xl, xh, 9);  // 41
+function s1_512_hi (xh, xl) {
+  const c0_hi = rotr64_hi(xh, xl, 14)
+  const c1_hi = rotr64_hi(xh, xl, 18)
+  const c2_hi = rotr64_hi(xl, xh, 9) // 41
 
-  let r = c0_hi ^ c1_hi ^ c2_hi;
-  if (r < 0)
-    r += 0x100000000;
-  return r;
+  let r = c0_hi ^ c1_hi ^ c2_hi
+  if (r < 0) { r += 0x100000000 }
+  return r
 }
 
-function s1_512_lo(xh, xl) {
-  const c0_lo = rotr64_lo(xh, xl, 14);
-  const c1_lo = rotr64_lo(xh, xl, 18);
-  const c2_lo = rotr64_lo(xl, xh, 9);  // 41
+function s1_512_lo (xh, xl) {
+  const c0_lo = rotr64_lo(xh, xl, 14)
+  const c1_lo = rotr64_lo(xh, xl, 18)
+  const c2_lo = rotr64_lo(xl, xh, 9) // 41
 
-  let r = c0_lo ^ c1_lo ^ c2_lo;
-  if (r < 0)
-    r += 0x100000000;
-  return r;
+  let r = c0_lo ^ c1_lo ^ c2_lo
+  if (r < 0) { r += 0x100000000 }
+  return r
 }
 
-function g0_512_hi(xh, xl) {
-  const c0_hi = rotr64_hi(xh, xl, 1);
-  const c1_hi = rotr64_hi(xh, xl, 8);
-  const c2_hi = shr64_hi(xh, xl, 7);
+function g0_512_hi (xh, xl) {
+  const c0_hi = rotr64_hi(xh, xl, 1)
+  const c1_hi = rotr64_hi(xh, xl, 8)
+  const c2_hi = shr64_hi(xh, xl, 7)
 
-  let r = c0_hi ^ c1_hi ^ c2_hi;
-  if (r < 0)
-    r += 0x100000000;
-  return r;
+  let r = c0_hi ^ c1_hi ^ c2_hi
+  if (r < 0) { r += 0x100000000 }
+  return r
 }
 
-function g0_512_lo(xh, xl) {
-  const c0_lo = rotr64_lo(xh, xl, 1);
-  const c1_lo = rotr64_lo(xh, xl, 8);
-  const c2_lo = shr64_lo(xh, xl, 7);
+function g0_512_lo (xh, xl) {
+  const c0_lo = rotr64_lo(xh, xl, 1)
+  const c1_lo = rotr64_lo(xh, xl, 8)
+  const c2_lo = shr64_lo(xh, xl, 7)
 
-  let r = c0_lo ^ c1_lo ^ c2_lo;
-  if (r < 0)
-    r += 0x100000000;
-  return r;
+  let r = c0_lo ^ c1_lo ^ c2_lo
+  if (r < 0) { r += 0x100000000 }
+  return r
 }
 
-function g1_512_hi(xh, xl) {
-  const c0_hi = rotr64_hi(xh, xl, 19);
-  const c1_hi = rotr64_hi(xl, xh, 29);  // 61
-  const c2_hi = shr64_hi(xh, xl, 6);
+function g1_512_hi (xh, xl) {
+  const c0_hi = rotr64_hi(xh, xl, 19)
+  const c1_hi = rotr64_hi(xl, xh, 29) // 61
+  const c2_hi = shr64_hi(xh, xl, 6)
 
-  let r = c0_hi ^ c1_hi ^ c2_hi;
-  if (r < 0)
-    r += 0x100000000;
-  return r;
+  let r = c0_hi ^ c1_hi ^ c2_hi
+  if (r < 0) { r += 0x100000000 }
+  return r
 }
 
-function g1_512_lo(xh, xl) {
-  const c0_lo = rotr64_lo(xh, xl, 19);
-  const c1_lo = rotr64_lo(xl, xh, 29);  // 61
-  const c2_lo = shr64_lo(xh, xl, 6);
+function g1_512_lo (xh, xl) {
+  const c0_lo = rotr64_lo(xh, xl, 19)
+  const c1_lo = rotr64_lo(xl, xh, 29) // 61
+  const c2_lo = shr64_lo(xh, xl, 6)
 
-  let r = c0_lo ^ c1_lo ^ c2_lo;
-  if (r < 0)
-    r += 0x100000000;
-  return r;
+  let r = c0_lo ^ c1_lo ^ c2_lo
+  if (r < 0) { r += 0x100000000 }
+  return r
 }
 
 /**
@@ -1138,11 +1124,11 @@ export class SHA256HMAC {
    * @example
    * const myHMAC = new SHA256HMAC('deadbeef');
    */
-  constructor(key: number[] | string) {
+  constructor (key: number[] | string) {
     key = toArray(key, 'hex')
     // Shorten key, if needed
     if (key.length > this.blockSize) {
-      key = new SHA256().update(key).digest() as number[]
+      key = new SHA256().update(key).digest()
     }
     assert(key.length <= this.blockSize)
 
@@ -1169,7 +1155,7 @@ export class SHA256HMAC {
    * @example
    * myHMAC.update('deadbeef', 'hex');
    */
-  update(msg: number[] | string, enc?: 'hex'): SHA256HMAC {
+  update (msg: number[] | string, enc?: 'hex'): SHA256HMAC {
     this.inner.update(msg, enc)
     return this
   }
@@ -1183,7 +1169,7 @@ export class SHA256HMAC {
    * @example
    * let hashedMessage = myHMAC.digest();
    */
-  digest(): number[] {
+  digest (): number[] {
     this.outer.update(this.inner.digest())
     return this.outer.digest()
   }
@@ -1197,7 +1183,7 @@ export class SHA256HMAC {
    * @example
    * let hashedMessage = myHMAC.digestHex();
    */
-  digestHex(): string {
+  digestHex (): string {
     this.outer.update(this.inner.digest())
     return this.outer.digestHex()
   }
@@ -1234,11 +1220,11 @@ export class SHA512HMAC {
    * @example
    * const myHMAC = new SHA512HMAC('deadbeef');
    */
-  constructor(key: number[] | string) {
+  constructor (key: number[] | string) {
     key = toArray(key, 'hex')
     // Shorten key, if needed
     if (key.length > this.blockSize) {
-      key = new SHA512().update(key).digest() as number[]
+      key = new SHA512().update(key).digest()
     }
     assert(key.length <= this.blockSize)
 
@@ -1265,7 +1251,7 @@ export class SHA512HMAC {
    * @example
    * myHMAC.update('deadbeef', 'hex');
    */
-  update(msg: number[] | string, enc?: 'hex' | 'utf8'): SHA512HMAC {
+  update (msg: number[] | string, enc?: 'hex' | 'utf8'): SHA512HMAC {
     this.inner.update(msg, enc)
     return this
   }
@@ -1279,8 +1265,8 @@ export class SHA512HMAC {
    * @example
    * let hashedMessage = myHMAC.digest();
    */
-  digest(): number[] {
-    this.outer.update(this.inner.digest() as number[])
+  digest (): number[] {
+    this.outer.update(this.inner.digest())
     return this.outer.digest()
   }
 
@@ -1293,11 +1279,10 @@ export class SHA512HMAC {
    * @example
    * let hashedMessage = myHMAC.digestHex();
    */
-  digestHex(): string {
-    this.outer.update(this.inner.digest() as number[])
+  digestHex (): string {
+    this.outer.update(this.inner.digest())
     return this.outer.digestHex()
   }
-
 }
 
 /**
@@ -1438,7 +1423,7 @@ export const sha512hmac = (key: number[] | string, msg: number[] | string, enc?:
  *
  * @returns The computed key
  */
-export function pbkdf2(password: number[], salt: number[], iterations: number, keylen: number, digest = 'sha512'): number[] {
+export function pbkdf2 (password: number[], salt: number[], iterations: number, keylen: number, digest = 'sha512'): number[] {
   if (digest !== 'sha512') {
     throw new Error('Only sha512 is supported in this PBKDF2 implementation')
   }
@@ -1451,16 +1436,16 @@ export function pbkdf2(password: number[], salt: number[], iterations: number, k
   const l = Math.ceil(keylen / hLen)
 
   for (let i = 1; i <= l; i++) {
-    block1[salt.length] = (i >> 24) & 0xFF; // MSB
-    block1[salt.length + 1] = (i >> 16) & 0xFF;
-    block1[salt.length + 2] = (i >> 8) & 0xFF;
-    block1[salt.length + 3] = i & 0xFF; // LSB
+    block1[salt.length] = (i >> 24) & 0xFF // MSB
+    block1[salt.length + 1] = (i >> 16) & 0xFF
+    block1[salt.length + 2] = (i >> 8) & 0xFF
+    block1[salt.length + 3] = i & 0xFF // LSB
 
-    const T = sha512hmac(password, block1) as number[]
+    const T = sha512hmac(password, block1)
     let U = T
 
     for (let j = 1; j < iterations; j++) {
-      U = sha512hmac(password, U) as number[]
+      U = sha512hmac(password, U)
       for (let k = 0; k < hLen; k++) T[k] ^= U[k]
     }