web-dc-api 0.0.58 → 0.0.60

package/dist/esm/node_modules/jscrypto/es6/RIPEMD160.js

@@ -0,0 +1,186 @@
+import { Hasher } from './lib/algorithm/Hasher.js';
+import { Word32Array } from './lib/Word32Array.js';
+
+/** @preserve
+(c) 2012 by Cédric Mesnil. All rights reserved.
+Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+ 
+- Redistributions of source code must retain the above copyright notice,
+  this list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+ 
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+// Constants table
+const _zl = new Word32Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8, 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12, 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2, 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13]);
+const _zr = new Word32Array([5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12, 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2, 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13, 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14, 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11]);
+const _sl = new Word32Array([11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8, 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12, 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5, 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12, 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6]);
+const _sr = new Word32Array([8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6, 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11, 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5, 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8, 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11]);
+const _hl = new Word32Array([0x00000000, 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xA953FD4E]);
+const _hr = new Word32Array([0x50A28BE6, 0x5C4DD124, 0x6D703EF3, 0x7A6D76E9, 0x00000000]);
+function f1(x, y, z) {
+  return x ^ y ^ z;
+}
+function f2(x, y, z) {
+  return x & y | ~x & z;
+}
+function f3(x, y, z) {
+  return (x | ~y) ^ z;
+}
+function f4(x, y, z) {
+  return x & z | y & ~z;
+}
+function f5(x, y, z) {
+  return x ^ (y | ~z);
+}
+function rotl(x, n) {
+  return x << n | x >>> 32 - n;
+}
+class RIPEMD160 extends Hasher {
+  constructor(props) {
+    super(props);
+    this._hash = new Word32Array([0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0]);
+    this._props = props;
+    if (props && typeof props.hash !== "undefined") {
+      this._hash = props.hash.clone();
+    }
+  }
+  _doReset() {
+    this._hash = new Word32Array([0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0]);
+  }
+  _doProcessBlock(words, offset) {
+    // Swap endian
+    for (let i = 0; i < 16; i++) {
+      // Shortcuts
+      const offsetI = offset + i;
+      const wordsOffsetI = words[offsetI];
+      // Swap
+      words[offsetI] = (wordsOffsetI << 8 | wordsOffsetI >>> 24) & 0x00ff00ff | (wordsOffsetI << 24 | wordsOffsetI >>> 8) & 0xff00ff00;
+    }
+    // Shortcut
+    const H = this._hash.words;
+    const hl = _hl.words;
+    const hr = _hr.words;
+    const zl = _zl.words;
+    const zr = _zr.words;
+    const sl = _sl.words;
+    const sr = _sr.words;
+    // Working variables
+    let al;
+    let bl;
+    let cl;
+    let dl;
+    let el;
+    let ar;
+    let br;
+    let cr;
+    let dr;
+    let er;
+    ar = al = H[0];
+    br = bl = H[1];
+    cr = cl = H[2];
+    dr = dl = H[3];
+    er = el = H[4];
+    // Computation
+    let t;
+    for (let i = 0; i < 80; i += 1) {
+      t = al + words[offset + zl[i]] | 0;
+      if (i < 16) {
+        t += f1(bl, cl, dl) + hl[0];
+      } else if (i < 32) {
+        t += f2(bl, cl, dl) + hl[1];
+      } else if (i < 48) {
+        t += f3(bl, cl, dl) + hl[2];
+      } else if (i < 64) {
+        t += f4(bl, cl, dl) + hl[3];
+      } else {
+        // if (i<80) {
+        t += f5(bl, cl, dl) + hl[4];
+      }
+      t = t | 0;
+      t = rotl(t, sl[i]);
+      t = t + el | 0;
+      al = el;
+      el = dl;
+      dl = rotl(cl, 10);
+      cl = bl;
+      bl = t;
+      t = ar + words[offset + zr[i]] | 0;
+      if (i < 16) {
+        t += f5(br, cr, dr) + hr[0];
+      } else if (i < 32) {
+        t += f4(br, cr, dr) + hr[1];
+      } else if (i < 48) {
+        t += f3(br, cr, dr) + hr[2];
+      } else if (i < 64) {
+        t += f2(br, cr, dr) + hr[3];
+      } else {
+        // if (i<80) {
+        t += f1(br, cr, dr) + hr[4];
+      }
+      t = t | 0;
+      t = rotl(t, sr[i]);
+      t = t + er | 0;
+      ar = er;
+      er = dr;
+      dr = rotl(cr, 10);
+      cr = br;
+      br = t;
+    }
+    // Intermediate hash value
+    t = H[1] + cl + dr | 0;
+    H[1] = H[2] + dl + er | 0;
+    H[2] = H[3] + el + ar | 0;
+    H[3] = H[4] + al + br | 0;
+    H[4] = H[0] + bl + cr | 0;
+    H[0] = t;
+  }
+  _doFinalize() {
+    // Shortcuts
+    const data = this._data;
+    const dataWords = data.words;
+    const nBitsTotal = this._nBytes * 8;
+    const nBitsLeft = data.nSigBytes * 8;
+    // Add padding
+    dataWords[nBitsLeft >>> 5] |= 0x80 << 24 - nBitsLeft % 32;
+    dataWords[(nBitsLeft + 64 >>> 9 << 4) + 14] = (nBitsTotal << 8 | nBitsTotal >>> 24) & 0x00ff00ff | (nBitsTotal << 24 | nBitsTotal >>> 8) & 0xff00ff00;
+    data.nSigBytes = (dataWords.length + 1) * 4;
+    // Hash final blocks
+    this._process();
+    // Shortcuts
+    const hash = this._hash;
+    const H = hash.words;
+    // Swap endian
+    for (let i = 0; i < 5; i++) {
+      // Shortcut
+      const Hi = H[i];
+      // Swap
+      H[i] = (Hi << 8 | Hi >>> 24) & 0x00ff00ff | (Hi << 24 | Hi >>> 8) & 0xff00ff00;
+    }
+    // Return final computed hash
+    return hash;
+  }
+  clone() {
+    const props = {
+      hash: this._hash,
+      blockSize: this._blockSize,
+      data: this._data,
+      nBytes: this._nBytes
+    };
+    return new RIPEMD160(props);
+  }
+  static hash(message, props) {
+    return new RIPEMD160(props).finalize(message);
+  }
+}
+
+export { RIPEMD160 };

package/dist/esm/node_modules/jscrypto/es6/Rabbit.js

@@ -0,0 +1,188 @@
+import { StreamCipher } from './lib/algorithm/cipher/StreamCipher.js';
+import { PasswordBasedCipher } from './lib/algorithm/cipher/PasswordBasedCipher.js';
+import { SerializableCipher } from './lib/algorithm/cipher/SerializableCipher.js';
+
+class Rabbit extends StreamCipher {
+  constructor(props) {
+    super(props);
+    this._blockSize = 128 / 32;
+    this.S = [];
+    this.C = [];
+    this.G = [];
+    this._X = [];
+    this._C = [];
+    this._b = 0;
+    this._props = props;
+    this._doReset();
+  }
+  _doReset() {
+    // Shortcuts
+    const K = this._key.words;
+    const iv = this._iv;
+    // Swap endian
+    for (let i = 0; i < 4; i++) {
+      K[i] = (K[i] << 8 | K[i] >>> 24) & 0x00ff00ff | (K[i] << 24 | K[i] >>> 8) & 0xff00ff00;
+    }
+    // Generate initial state values
+    const X = this._X = [K[0], K[3] << 16 | K[2] >>> 16, K[1], K[0] << 16 | K[3] >>> 16, K[2], K[1] << 16 | K[0] >>> 16, K[3], K[2] << 16 | K[1] >>> 16];
+    // Generate initial counter values
+    const C = this._C = [K[2] << 16 | K[2] >>> 16, K[0] & 0xffff0000 | K[1] & 0x0000ffff, K[3] << 16 | K[3] >>> 16, K[1] & 0xffff0000 | K[2] & 0x0000ffff, K[0] << 16 | K[0] >>> 16, K[2] & 0xffff0000 | K[3] & 0x0000ffff, K[1] << 16 | K[1] >>> 16, K[3] & 0xffff0000 | K[0] & 0x0000ffff];
+    // Carry bit
+    this._b = 0;
+    // Iterate the system four times
+    for (let i = 0; i < 4; i++) {
+      this.nextState();
+    }
+    // Modify the counters
+    for (let i = 0; i < 8; i++) {
+      C[i] ^= X[i + 4 & 7];
+    }
+    // IV setup
+    if (!iv) {
+      return;
+    }
+    // Shortcuts
+    const IV = iv.words;
+    const IV_0 = IV[0];
+    const IV_1 = IV[1];
+    // Generate four sub vectors
+    const i0 = (IV_0 << 8 | IV_0 >>> 24) & 0x00ff00ff | (IV_0 << 24 | IV_0 >>> 8) & 0xff00ff00;
+    const i2 = (IV_1 << 8 | IV_1 >>> 24) & 0x00ff00ff | (IV_1 << 24 | IV_1 >>> 8) & 0xff00ff00;
+    const i1 = i0 >>> 16 | i2 & 0xffff0000;
+    const i3 = i2 << 16 | i0 & 0x0000ffff;
+    // Modify counter values
+    C[0] ^= i0;
+    C[1] ^= i1;
+    C[2] ^= i2;
+    C[3] ^= i3;
+    C[4] ^= i0;
+    C[5] ^= i1;
+    C[6] ^= i2;
+    C[7] ^= i3;
+    // Iterate the system four times
+    for (let i = 0; i < 4; i++) {
+      this.nextState();
+    }
+  }
+  _doProcessBlock(words, offset) {
+    // Shortcut
+    const X = this._X;
+    // Iterate the system
+    this.nextState();
+    // Generate four key stream words
+    this.S[0] = X[0] ^ X[5] >>> 16 ^ X[3] << 16;
+    this.S[1] = X[2] ^ X[7] >>> 16 ^ X[5] << 16;
+    this.S[2] = X[4] ^ X[1] >>> 16 ^ X[7] << 16;
+    this.S[3] = X[6] ^ X[3] >>> 16 ^ X[1] << 16;
+    for (let i = 0; i < 4; i++) {
+      // Swap endian
+      this.S[i] = (this.S[i] << 8 | this.S[i] >>> 24) & 0x00ff00ff | (this.S[i] << 24 | this.S[i] >>> 8) & 0xff00ff00;
+      // Encrypt
+      words[offset + i] ^= this.S[i];
+    }
+  }
+  nextState() {
+    // Shortcuts
+    const X = this._X;
+    const C = this._C;
+    // Save old counter values
+    for (let i = 0; i < 8; i++) {
+      this.C[i] = C[i];
+    }
+    // Calculate new counter values
+    C[0] = C[0] + 0x4d34d34d + this._b | 0;
+    C[1] = C[1] + 0xd34d34d3 + (C[0] >>> 0 < this.C[0] >>> 0 ? 1 : 0) | 0;
+    C[2] = C[2] + 0x34d34d34 + (C[1] >>> 0 < this.C[1] >>> 0 ? 1 : 0) | 0;
+    C[3] = C[3] + 0x4d34d34d + (C[2] >>> 0 < this.C[2] >>> 0 ? 1 : 0) | 0;
+    C[4] = C[4] + 0xd34d34d3 + (C[3] >>> 0 < this.C[3] >>> 0 ? 1 : 0) | 0;
+    C[5] = C[5] + 0x34d34d34 + (C[4] >>> 0 < this.C[4] >>> 0 ? 1 : 0) | 0;
+    C[6] = C[6] + 0x4d34d34d + (C[5] >>> 0 < this.C[5] >>> 0 ? 1 : 0) | 0;
+    C[7] = C[7] + 0xd34d34d3 + (C[6] >>> 0 < this.C[6] >>> 0 ? 1 : 0) | 0;
+    this._b = C[7] >>> 0 < this.C[7] >>> 0 ? 1 : 0;
+    // Calculate the g-values
+    for (let i = 0; i < 8; i++) {
+      const gx = X[i] + C[i];
+      // Construct high and low argument for squaring
+      const ga = gx & 0xffff;
+      const gb = gx >>> 16;
+      // Calculate high and low result of squaring
+      const gh = ((ga * ga >>> 17) + ga * gb >>> 15) + gb * gb;
+      const gl = ((gx & 0xffff0000) * gx | 0) + ((gx & 0x0000ffff) * gx | 0);
+      // High XOR low
+      this.G[i] = gh ^ gl;
+    }
+    const G = this.G;
+    // Calculate new state values
+    X[0] = G[0] + (G[7] << 16 | G[7] >>> 16) + (G[6] << 16 | G[6] >>> 16) | 0;
+    X[1] = G[1] + (G[0] << 8 | G[0] >>> 24) + G[7] | 0;
+    X[2] = G[2] + (G[1] << 16 | G[1] >>> 16) + (G[0] << 16 | G[0] >>> 16) | 0;
+    X[3] = G[3] + (G[2] << 8 | G[2] >>> 24) + G[1] | 0;
+    X[4] = G[4] + (G[3] << 16 | G[3] >>> 16) + (G[2] << 16 | G[2] >>> 16) | 0;
+    X[5] = G[5] + (G[4] << 8 | G[4] >>> 24) + G[3] | 0;
+    X[6] = G[6] + (G[5] << 16 | G[5] >>> 16) + (G[4] << 16 | G[4] >>> 16) | 0;
+    X[7] = G[7] + (G[6] << 8 | G[6] >>> 24) + G[5] | 0;
+  }
+  /**
+   * Creates this cipher in encryption mode.
+   *
+   * @param {Word32Array} key The key.
+   * @param {Partial<CipherProps>?} props (Optional) The configuration options to use for this operation.
+   * @return {Cipher} A cipher instance.
+   * @example
+   *   var cipher = Rabbit.createEncryptor(keyWordArray);
+   */
+  static createEncryptor(key, props) {
+    props = typeof props === "undefined" ? {} : props;
+    return new Rabbit(Object.assign(Object.assign({}, props), {
+      key
+    }));
+  }
+  /**
+   * Creates this cipher in decryption mode.
+   *
+   * @param {Word32Array} key The key.
+   * @param {Partial<CipherProps>?} props (Optional) The configuration options to use for this operation.
+   * @return {Cipher} A cipher instance.
+   * @example
+   *   var cipher = Rabbit.createDecryptor(keyWordArray, { iv: ivWordArray });
+   */
+  static createDecryptor(key, props) {
+    props = typeof props === "undefined" ? {} : props;
+    return new Rabbit(Object.assign(Object.assign({}, props), {
+      key
+    }));
+  }
+  /**
+   * Encrypt a message with key
+   *
+   * @param {Word32Array|string} message
+   * @param {Word32Array|string} key
+   * @param {Partial<AESProps>?} props
+   * @example
+   *   var encryptedMessage = Rabbit.encrypt("test", "pass");
+   */
+  static encrypt(message, key, props) {
+    if (typeof key === "string") {
+      return PasswordBasedCipher.encrypt(Rabbit, message, key, props);
+    }
+    return SerializableCipher.encrypt(Rabbit, message, key, props);
+  }
+  /**
+   * Encrypt a encrypted message with key
+   *
+   * @param {CipherParams} cipherText
+   * @param {Word32Array|string} key
+   * @param {Partial<AESProps>?} props
+   * @example
+   *   var encryptedMessage = Rabbit.decrypt(cipherProps, "pass");
+   */
+  static decrypt(cipherText, key, props) {
+    if (typeof key === "string") {
+      return PasswordBasedCipher.decrypt(Rabbit, cipherText, key, props);
+    }
+    return SerializableCipher.decrypt(Rabbit, cipherText, key, props);
+  }
+}
+Rabbit.ivSize = 128 / 32;
+
+export { Rabbit };

package/dist/esm/node_modules/jscrypto/es6/SHA1.js

@@ -0,0 +1,86 @@
+import { Hasher } from './lib/algorithm/Hasher.js';
+import { Word32Array } from './lib/Word32Array.js';
+
+// Reusable object
+const W = [];
+class SHA1 extends Hasher {
+  constructor(props) {
+    super(props);
+    this._hash = new Word32Array([0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0]);
+    this._props = props;
+    if (props && typeof props.hash !== "undefined") {
+      this._hash = props.hash.clone();
+    }
+  }
+  _doReset() {
+    this._hash = new Word32Array([0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0]);
+  }
+  _doProcessBlock(words, offset) {
+    const H = this._hash.words;
+    // Working variables
+    let a = H[0];
+    let b = H[1];
+    let c = H[2];
+    let d = H[3];
+    let e = H[4];
+    // Computation
+    for (let i = 0; i < 80; i++) {
+      if (i < 16) {
+        W[i] = words[offset + i] | 0;
+      } else {
+        const n = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];
+        W[i] = n << 1 | n >>> 31;
+      }
+      let t = (a << 5 | a >>> 27) + e + W[i];
+      if (i < 20) {
+        t += (b & c | ~b & d) + 0x5a827999;
+      } else if (i < 40) {
+        t += (b ^ c ^ d) + 0x6ed9eba1;
+      } else if (i < 60) {
+        t += (b & c | b & d | c & d) - 0x70e44324;
+      } else /* if (i < 80) */{
+          t += (b ^ c ^ d) - 0x359d3e2a;
+        }
+      e = d;
+      d = c;
+      c = b << 30 | b >>> 2;
+      b = a;
+      a = t;
+    }
+    // Intermediate hash value
+    H[0] = H[0] + a | 0;
+    H[1] = H[1] + b | 0;
+    H[2] = H[2] + c | 0;
+    H[3] = H[3] + d | 0;
+    H[4] = H[4] + e | 0;
+  }
+  _doFinalize() {
+    // Shortcuts
+    const dataWords = this._data.words;
+    const nBitsTotal = this._nBytes * 8;
+    const nBitsLeft = this._data.nSigBytes * 8;
+    // Add padding
+    dataWords[nBitsLeft >>> 5] |= 0x80 << 24 - nBitsLeft % 32;
+    dataWords[(nBitsLeft + 64 >>> 9 << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);
+    dataWords[(nBitsLeft + 64 >>> 9 << 4) + 15] = nBitsTotal;
+    this._data.nSigBytes = dataWords.length * 4;
+    // Hash final blocks
+    this._process();
+    // Return final computed hash
+    return this._hash;
+  }
+  clone() {
+    const props = {
+      hash: this._hash,
+      blockSize: this._blockSize,
+      data: this._data,
+      nBytes: this._nBytes
+    };
+    return new SHA1(props);
+  }
+  static hash(message, props) {
+    return new SHA1(props).finalize(message);
+  }
+}
+
+export { SHA1 };

package/dist/esm/node_modules/jscrypto/es6/SHA224.js

@@ -0,0 +1,35 @@
+import { Word32Array } from './lib/Word32Array.js';
+import { SHA256 } from './SHA256.js';
+
+class SHA224 extends SHA256 {
+  constructor(props) {
+    super(props);
+    this._hash = new Word32Array([0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4]);
+    this._props = props;
+    if (props && typeof props.hash !== "undefined") {
+      this._hash = props.hash.clone();
+    }
+  }
+  _doReset() {
+    this._hash = new Word32Array([0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4]);
+  }
+  _doFinalize() {
+    const hash = super._doFinalize.call(this);
+    hash.nSigBytes -= 4;
+    return hash;
+  }
+  clone() {
+    const props = {
+      hash: this._hash,
+      blockSize: this._blockSize,
+      data: this._data,
+      nBytes: this._nBytes
+    };
+    return new SHA224(props);
+  }
+  static hash(message, props) {
+    return new SHA224(props).finalize(message);
+  }
+}
+
+export { SHA224 };

package/dist/esm/node_modules/jscrypto/es6/SHA256.js

@@ -0,0 +1,121 @@
+import { Hasher } from './lib/algorithm/Hasher.js';
+import { Word32Array } from './lib/Word32Array.js';
+
+// Hash values
+const H = [];
+// Round constants
+const K = [];
+function isPrime(n) {
+  const sqrtN = Math.sqrt(n);
+  for (let factor = 2; factor <= sqrtN; factor++) {
+    if (!(n % factor)) {
+      return false;
+    }
+  }
+  return true;
+}
+function getFractionalBits(n) {
+  return (n - (n | 0)) * 0x100000000 | 0;
+}
+(function computeRoundConstants() {
+  let n = 2;
+  let nPrime = 0;
+  while (nPrime < 64) {
+    if (isPrime(n)) {
+      if (nPrime < 8) {
+        H[nPrime] = getFractionalBits(Math.pow(n, 1 / 2));
+      }
+      K[nPrime] = getFractionalBits(Math.pow(n, 1 / 3));
+      nPrime++;
+    }
+    n++;
+  }
+})();
+// Reusable object
+const W = [];
+class SHA256 extends Hasher {
+  constructor(props) {
+    super(props);
+    this._hash = new Word32Array(H.slice(0));
+    this._props = props;
+    if (props && typeof props.hash !== "undefined") {
+      this._hash = props.hash.clone();
+    }
+  }
+  _doReset() {
+    this._hash = new Word32Array(H.slice(0));
+  }
+  _doProcessBlock(words, offset) {
+    const _H = this._hash.words;
+    let a = _H[0];
+    let b = _H[1];
+    let c = _H[2];
+    let d = _H[3];
+    let e = _H[4];
+    let f = _H[5];
+    let g = _H[6];
+    let h = _H[7];
+    for (let i = 0; i < 64; i++) {
+      if (i < 16) {
+        W[i] = words[offset + i] | 0;
+      } else {
+        const gamma0x = W[i - 15];
+        const gamma0 = (gamma0x << 25 | gamma0x >>> 7) ^ (gamma0x << 14 | gamma0x >>> 18) ^ gamma0x >>> 3;
+        const gamma1x = W[i - 2];
+        const gamma1 = (gamma1x << 15 | gamma1x >>> 17) ^ (gamma1x << 13 | gamma1x >>> 19) ^ gamma1x >>> 10;
+        W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16];
+      }
+      const ch = e & f ^ ~e & g;
+      const maj = a & b ^ a & c ^ b & c;
+      const sigma0 = (a << 30 | a >>> 2) ^ (a << 19 | a >>> 13) ^ (a << 10 | a >>> 22);
+      const sigma1 = (e << 26 | e >>> 6) ^ (e << 21 | e >>> 11) ^ (e << 7 | e >>> 25);
+      const t1 = h + sigma1 + ch + K[i] + W[i];
+      const t2 = sigma0 + maj;
+      h = g;
+      g = f;
+      f = e;
+      e = d + t1 | 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 | 0;
+    }
+    // Intermediate hash value
+    _H[0] = _H[0] + a | 0;
+    _H[1] = _H[1] + b | 0;
+    _H[2] = _H[2] + c | 0;
+    _H[3] = _H[3] + d | 0;
+    _H[4] = _H[4] + e | 0;
+    _H[5] = _H[5] + f | 0;
+    _H[6] = _H[6] + g | 0;
+    _H[7] = _H[7] + h | 0;
+  }
+  _doFinalize() {
+    const words = this._data.words;
+    const nBitsTotal = this._nBytes * 8;
+    const nBitsLeft = this._data.nSigBytes * 8;
+    // Add padding
+    words[nBitsLeft >>> 5] |= 0x80 << 24 - nBitsLeft % 32;
+    words[(nBitsLeft + 64 >>> 9 << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);
+    words[(nBitsLeft + 64 >>> 9 << 4) + 15] = nBitsTotal;
+    this._data.nSigBytes = words.length * 4;
+    // Hash final blocks
+    this._process();
+    // Return final computed hash
+    return this._hash;
+  }
+  clone() {
+    const props = {
+      hash: this._hash,
+      blockSize: this._blockSize,
+      data: this._data,
+      nBytes: this._nBytes
+    };
+    return new SHA256(props);
+  }
+  static hash(message, props) {
+    return new SHA256(props).finalize(message);
+  }
+}
+
+export { SHA256 };