web-dc-api 0.0.58 → 0.0.60

package/dist/cjs/node_modules/jscrypto/es6/SHA3.js

@@ -0,0 +1,236 @@
+'use strict';
+
+var Word64Array = require('./lib/Word64Array.js');
+var Hasher = require('./lib/algorithm/Hasher.js');
+var Word32Array = require('./lib/Word32Array.js');
+
+// Constants tables
+const RHO_OFFSETS = [];
+const PI_INDEXES = [];
+const ROUND_CONSTANTS = [];
+// Compute Constants
+(function computeConstants() {
+  // Compute rho offset constants
+  let x = 1;
+  let y = 0;
+  for (let t = 0; t < 24; t++) {
+    RHO_OFFSETS[x + 5 * y] = (t + 1) * (t + 2) / 2 % 64;
+    const newX = y % 5;
+    const newY = (2 * x + 3 * y) % 5;
+    x = newX;
+    y = newY;
+  }
+  // Compute pi index constants
+  for (let p = 0; p < 5; p++) {
+    for (let q = 0; q < 5; q++) {
+      PI_INDEXES[p + 5 * q] = q + (2 * p + 3 * q) % 5 * 5;
+    }
+  }
+  // Compute round constants
+  let LFSR = 0x01;
+  for (let i = 0; i < 24; i++) {
+    let roundConstantMsw = 0;
+    let roundConstantLsw = 0;
+    for (let j = 0; j < 7; j++) {
+      if (LFSR & 0x01) {
+        const bitPosition = (1 << j) - 1;
+        if (bitPosition < 32) {
+          roundConstantLsw ^= 1 << bitPosition;
+        } else /* if (bitPosition >= 32) */{
+            roundConstantMsw ^= 1 << bitPosition - 32;
+          }
+      }
+      // Compute next LFSR
+      if (LFSR & 0x80) {
+        // Primitive polynomial over GF(2): x^8 + x^6 + x^5 + x^4 + 1
+        LFSR = LFSR << 1 ^ 0x71;
+      } else {
+        LFSR <<= 1;
+      }
+    }
+    ROUND_CONSTANTS[i] = new Word64Array.Word64(roundConstantMsw, roundConstantLsw);
+  }
+})();
+// Reusable objects for temporary values
+const T = [];
+(function () {
+  for (let i = 0; i < 25; i++) {
+    T[i] = new Word64Array.Word64(0, 0);
+  }
+})();
+class SHA3 extends Hasher.Hasher {
+  constructor(props) {
+    super(props);
+    this._blockSize = 1024 / 32;
+    this._state = [];
+    this._outputLength = 512;
+    this._props = props;
+    if (props) {
+      if (typeof props.outputLength !== "undefined") {
+        if (![224, 256, 384, 512].includes(props.outputLength)) {
+          throw new Error("Unsupported output length.");
+        }
+        this._outputLength = props.outputLength;
+      }
+      if (typeof props.state !== "undefined") {
+        this._state = props.state.map(s => s.clone());
+      }
+    }
+    if (this._state.length === 0) {
+      for (let i = 0; i < 25; i++) {
+        this._state[i] = new Word64Array.Word64(0, 0);
+      }
+    }
+    this._blockSize = (1600 - 2 * this._outputLength) / 32;
+  }
+  _doReset() {
+    this._state = [];
+    for (let i = 0; i < 25; i++) {
+      this._state[i] = new Word64Array.Word64(0, 0);
+    }
+    this._blockSize = (1600 - 2 * this._outputLength) / 32;
+  }
+  _doProcessBlock(words, offset) {
+    // Shortcuts
+    const state = this._state;
+    const nBlockSizeLanes = this._blockSize / 2;
+    // Absorb
+    for (let i = 0; i < nBlockSizeLanes; i++) {
+      // Shortcuts
+      let W2i = words[offset + 2 * i];
+      let W2i1 = words[offset + 2 * i + 1];
+      // Swap endian
+      W2i = (W2i << 8 | W2i >>> 24) & 0x00ff00ff | (W2i << 24 | W2i >>> 8) & 0xff00ff00;
+      W2i1 = (W2i1 << 8 | W2i1 >>> 24) & 0x00ff00ff | (W2i1 << 24 | W2i1 >>> 8) & 0xff00ff00;
+      // Absorb message into state
+      state[i].high ^= W2i1;
+      state[i].low ^= W2i;
+    }
+    // Rounds
+    for (let round = 0; round < 24; round++) {
+      // Theta
+      for (let x = 0; x < 5; x++) {
+        // Mix column lanes
+        let tMsw = 0;
+        let tLsw = 0;
+        for (let y = 0; y < 5; y++) {
+          const l = state[x + 5 * y];
+          tMsw ^= l.high;
+          tLsw ^= l.low;
+        }
+        // Temporary values
+        const Tx = T[x];
+        Tx.high = tMsw;
+        Tx.low = tLsw;
+      }
+      for (let x = 0; x < 5; x++) {
+        // Shortcuts
+        const Tx4 = T[(x + 4) % 5];
+        const Tx1 = T[(x + 1) % 5];
+        const Tx1Msw = Tx1.high;
+        const Tx1Lsw = Tx1.low;
+        // Mix surrounding columns
+        const tMsw = Tx4.high ^ (Tx1Msw << 1 | Tx1Lsw >>> 31);
+        const tLsw = Tx4.low ^ (Tx1Lsw << 1 | Tx1Msw >>> 31);
+        for (let y = 0; y < 5; y++) {
+          const l = state[x + 5 * y];
+          l.high ^= tMsw;
+          l.low ^= tLsw;
+        }
+      }
+      // Rho Pi
+      for (let laneIndex = 1; laneIndex < 25; laneIndex++) {
+        let tMsw;
+        let tLsw;
+        // Shortcuts
+        const laneMsw = state[laneIndex].high;
+        const laneLsw = state[laneIndex].low;
+        const rhoOffset = RHO_OFFSETS[laneIndex];
+        // Rotate lanes
+        if (rhoOffset < 32) {
+          tMsw = laneMsw << rhoOffset | laneLsw >>> 32 - rhoOffset;
+          tLsw = laneLsw << rhoOffset | laneMsw >>> 32 - rhoOffset;
+        } else /* if (rhoOffset >= 32) */{
+            tMsw = laneLsw << rhoOffset - 32 | laneMsw >>> 64 - rhoOffset;
+            tLsw = laneMsw << rhoOffset - 32 | laneLsw >>> 64 - rhoOffset;
+          }
+        // Transpose lanes
+        const TPiLane = T[PI_INDEXES[laneIndex]];
+        TPiLane.high = tMsw;
+        TPiLane.low = tLsw;
+      }
+      // Rho pi at x = y = 0
+      const T0 = T[0];
+      const state0 = state[0];
+      T0.high = state0.high;
+      T0.low = state0.low;
+      // Chi
+      for (let x = 0; x < 5; x++) {
+        for (let y = 0; y < 5; y++) {
+          // Shortcuts
+          const laneIndex = x + 5 * y;
+          const l = state[laneIndex];
+          const TLane = T[laneIndex];
+          const Tx1Lane = T[(x + 1) % 5 + 5 * y];
+          const Tx2Lane = T[(x + 2) % 5 + 5 * y];
+          // Mix rows
+          l.high = TLane.high ^ ~Tx1Lane.high & Tx2Lane.high;
+          l.low = TLane.low ^ ~Tx1Lane.low & Tx2Lane.low;
+        }
+      }
+      // Iota
+      const lane = state[0];
+      const roundConstant = ROUND_CONSTANTS[round];
+      lane.high ^= roundConstant.high;
+      lane.low ^= roundConstant.low;
+    }
+  }
+  _doFinalize() {
+    // Shortcuts
+    const data = this._data;
+    const dataWords = data.words;
+    const nBitsLeft = data.nSigBytes * 8;
+    const blockSizeBits = this.blockSize * 32;
+    // Add padding
+    dataWords[nBitsLeft >>> 5] |= 0x1 << 24 - nBitsLeft % 32;
+    dataWords[(Math.ceil((nBitsLeft + 1) / blockSizeBits) * blockSizeBits >>> 5) - 1] |= 0x80;
+    data.nSigBytes = dataWords.length * 4;
+    // Hash final blocks
+    this._process();
+    // Shortcuts
+    const state = this._state;
+    const outputLengthBytes = this._outputLength / 8;
+    const outputLengthLanes = outputLengthBytes / 8;
+    // Squeeze
+    const hashWords = [];
+    for (let i = 0; i < outputLengthLanes; i++) {
+      // Shortcuts
+      const lane = state[i];
+      let laneMsw = lane.high;
+      let laneLsw = lane.low;
+      // Swap endian
+      laneMsw = (laneMsw << 8 | laneMsw >>> 24) & 0x00ff00ff | (laneMsw << 24 | laneMsw >>> 8) & 0xff00ff00;
+      laneLsw = (laneLsw << 8 | laneLsw >>> 24) & 0x00ff00ff | (laneLsw << 24 | laneLsw >>> 8) & 0xff00ff00;
+      // Squeeze state to retrieve hash
+      hashWords.push(laneLsw);
+      hashWords.push(laneMsw);
+    }
+    // Return final computed hash
+    return new Word32Array.Word32Array(hashWords, outputLengthBytes);
+  }
+  clone() {
+    const props = {
+      outputLength: this._outputLength,
+      state: this._state,
+      blockSize: this._blockSize,
+      data: this._data,
+      nBytes: this._nBytes
+    };
+    return new SHA3(props);
+  }
+  static hash(message, props) {
+    return new SHA3(props).finalize(message);
+  }
+}
+
+exports.SHA3 = SHA3;

package/dist/cjs/node_modules/jscrypto/es6/SHA384.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var Word64Array = require('./lib/Word64Array.js');
+var SHA512 = require('./SHA512.js');
+
+class SHA384 extends SHA512.SHA512 {
+  constructor(props) {
+    super(props);
+    this._hash = new Word64Array.Word64Array([new Word64Array.Word64(0xcbbb9d5d, 0xc1059ed8), new Word64Array.Word64(0x629a292a, 0x367cd507), new Word64Array.Word64(0x9159015a, 0x3070dd17), new Word64Array.Word64(0x152fecd8, 0xf70e5939), new Word64Array.Word64(0x67332667, 0xffc00b31), new Word64Array.Word64(0x8eb44a87, 0x68581511), new Word64Array.Word64(0xdb0c2e0d, 0x64f98fa7), new Word64Array.Word64(0x47b5481d, 0xbefa4fa4)]);
+    this._props = props;
+    if (props && typeof props.hash !== "undefined") {
+      this._hash = props.hash.clone();
+    }
+  }
+  _doReset() {
+    this._hash = new Word64Array.Word64Array([new Word64Array.Word64(0xcbbb9d5d, 0xc1059ed8), new Word64Array.Word64(0x629a292a, 0x367cd507), new Word64Array.Word64(0x9159015a, 0x3070dd17), new Word64Array.Word64(0x152fecd8, 0xf70e5939), new Word64Array.Word64(0x67332667, 0xffc00b31), new Word64Array.Word64(0x8eb44a87, 0x68581511), new Word64Array.Word64(0xdb0c2e0d, 0x64f98fa7), new Word64Array.Word64(0x47b5481d, 0xbefa4fa4)]);
+  }
+  _doFinalize() {
+    const hash = super._doFinalize.call(this);
+    hash.nSigBytes -= 16;
+    return hash;
+  }
+  clone() {
+    const props = {
+      hash: this._hash,
+      blockSize: this._blockSize,
+      data: this._data,
+      nBytes: this._nBytes
+    };
+    return new SHA384(props);
+  }
+  static hash(message, props) {
+    return new SHA384(props).finalize(message);
+  }
+}
+
+exports.SHA384 = SHA384;

package/dist/cjs/node_modules/jscrypto/es6/SHA512.js

@@ -0,0 +1,198 @@
+'use strict';
+
+var Hasher = require('./lib/algorithm/Hasher.js');
+var Word64Array = require('./lib/Word64Array.js');
+
+const K = [new Word64Array.Word64(0x428a2f98, 0xd728ae22), new Word64Array.Word64(0x71374491, 0x23ef65cd), new Word64Array.Word64(0xb5c0fbcf, 0xec4d3b2f), new Word64Array.Word64(0xe9b5dba5, 0x8189dbbc), new Word64Array.Word64(0x3956c25b, 0xf348b538), new Word64Array.Word64(0x59f111f1, 0xb605d019), new Word64Array.Word64(0x923f82a4, 0xaf194f9b), new Word64Array.Word64(0xab1c5ed5, 0xda6d8118), new Word64Array.Word64(0xd807aa98, 0xa3030242), new Word64Array.Word64(0x12835b01, 0x45706fbe), new Word64Array.Word64(0x243185be, 0x4ee4b28c), new Word64Array.Word64(0x550c7dc3, 0xd5ffb4e2), new Word64Array.Word64(0x72be5d74, 0xf27b896f), new Word64Array.Word64(0x80deb1fe, 0x3b1696b1), new Word64Array.Word64(0x9bdc06a7, 0x25c71235), new Word64Array.Word64(0xc19bf174, 0xcf692694), new Word64Array.Word64(0xe49b69c1, 0x9ef14ad2), new Word64Array.Word64(0xefbe4786, 0x384f25e3), new Word64Array.Word64(0x0fc19dc6, 0x8b8cd5b5), new Word64Array.Word64(0x240ca1cc, 0x77ac9c65), new Word64Array.Word64(0x2de92c6f, 0x592b0275), new Word64Array.Word64(0x4a7484aa, 0x6ea6e483), new Word64Array.Word64(0x5cb0a9dc, 0xbd41fbd4), new Word64Array.Word64(0x76f988da, 0x831153b5), new Word64Array.Word64(0x983e5152, 0xee66dfab), new Word64Array.Word64(0xa831c66d, 0x2db43210), new Word64Array.Word64(0xb00327c8, 0x98fb213f), new Word64Array.Word64(0xbf597fc7, 0xbeef0ee4), new Word64Array.Word64(0xc6e00bf3, 0x3da88fc2), new Word64Array.Word64(0xd5a79147, 0x930aa725), new Word64Array.Word64(0x06ca6351, 0xe003826f), new Word64Array.Word64(0x14292967, 0x0a0e6e70), new Word64Array.Word64(0x27b70a85, 0x46d22ffc), new Word64Array.Word64(0x2e1b2138, 0x5c26c926), new Word64Array.Word64(0x4d2c6dfc, 0x5ac42aed), new Word64Array.Word64(0x53380d13, 0x9d95b3df), new Word64Array.Word64(0x650a7354, 0x8baf63de), new Word64Array.Word64(0x766a0abb, 0x3c77b2a8), new Word64Array.Word64(0x81c2c92e, 0x47edaee6), new Word64Array.Word64(0x92722c85, 0x1482353b), new Word64Array.Word64(0xa2bfe8a1, 0x4cf10364), new Word64Array.Word64(0xa81a664b, 0xbc423001), new Word64Array.Word64(0xc24b8b70, 0xd0f89791), new Word64Array.Word64(0xc76c51a3, 0x0654be30), new Word64Array.Word64(0xd192e819, 0xd6ef5218), new Word64Array.Word64(0xd6990624, 0x5565a910), new Word64Array.Word64(0xf40e3585, 0x5771202a), new Word64Array.Word64(0x106aa070, 0x32bbd1b8), new Word64Array.Word64(0x19a4c116, 0xb8d2d0c8), new Word64Array.Word64(0x1e376c08, 0x5141ab53), new Word64Array.Word64(0x2748774c, 0xdf8eeb99), new Word64Array.Word64(0x34b0bcb5, 0xe19b48a8), new Word64Array.Word64(0x391c0cb3, 0xc5c95a63), new Word64Array.Word64(0x4ed8aa4a, 0xe3418acb), new Word64Array.Word64(0x5b9cca4f, 0x7763e373), new Word64Array.Word64(0x682e6ff3, 0xd6b2b8a3), new Word64Array.Word64(0x748f82ee, 0x5defb2fc), new Word64Array.Word64(0x78a5636f, 0x43172f60), new Word64Array.Word64(0x84c87814, 0xa1f0ab72), new Word64Array.Word64(0x8cc70208, 0x1a6439ec), new Word64Array.Word64(0x90befffa, 0x23631e28), new Word64Array.Word64(0xa4506ceb, 0xde82bde9), new Word64Array.Word64(0xbef9a3f7, 0xb2c67915), new Word64Array.Word64(0xc67178f2, 0xe372532b), new Word64Array.Word64(0xca273ece, 0xea26619c), new Word64Array.Word64(0xd186b8c7, 0x21c0c207), new Word64Array.Word64(0xeada7dd6, 0xcde0eb1e), new Word64Array.Word64(0xf57d4f7f, 0xee6ed178), new Word64Array.Word64(0x06f067aa, 0x72176fba), new Word64Array.Word64(0x0a637dc5, 0xa2c898a6), new Word64Array.Word64(0x113f9804, 0xbef90dae), new Word64Array.Word64(0x1b710b35, 0x131c471b), new Word64Array.Word64(0x28db77f5, 0x23047d84), new Word64Array.Word64(0x32caab7b, 0x40c72493), new Word64Array.Word64(0x3c9ebe0a, 0x15c9bebc), new Word64Array.Word64(0x431d67c4, 0x9c100d4c), new Word64Array.Word64(0x4cc5d4be, 0xcb3e42b6), new Word64Array.Word64(0x597f299c, 0xfc657e2a), new Word64Array.Word64(0x5fcb6fab, 0x3ad6faec), new Word64Array.Word64(0x6c44198c, 0x4a475817)];
+const W = [];
+(function computeConstants() {
+  for (let i = 0; i < 80; i++) {
+    W[i] = new Word64Array.Word64(0, 0);
+  }
+})();
+class SHA512 extends Hasher.Hasher {
+  constructor(props) {
+    super(props);
+    this._blockSize = 1024 / 32;
+    this._hash = new Word64Array.Word64Array([new Word64Array.Word64(0x6a09e667, 0xf3bcc908), new Word64Array.Word64(0xbb67ae85, 0x84caa73b), new Word64Array.Word64(0x3c6ef372, 0xfe94f82b), new Word64Array.Word64(0xa54ff53a, 0x5f1d36f1), new Word64Array.Word64(0x510e527f, 0xade682d1), new Word64Array.Word64(0x9b05688c, 0x2b3e6c1f), new Word64Array.Word64(0x1f83d9ab, 0xfb41bd6b), new Word64Array.Word64(0x5be0cd19, 0x137e2179)]);
+    this._props = props;
+    if (props && typeof props.hash !== "undefined") {
+      this._hash = props.hash.clone();
+    }
+  }
+  _doReset() {
+    this._hash = new Word64Array.Word64Array([new Word64Array.Word64(0x6a09e667, 0xf3bcc908), new Word64Array.Word64(0xbb67ae85, 0x84caa73b), new Word64Array.Word64(0x3c6ef372, 0xfe94f82b), new Word64Array.Word64(0xa54ff53a, 0x5f1d36f1), new Word64Array.Word64(0x510e527f, 0xade682d1), new Word64Array.Word64(0x9b05688c, 0x2b3e6c1f), new Word64Array.Word64(0x1f83d9ab, 0xfb41bd6b), new Word64Array.Word64(0x5be0cd19, 0x137e2179)]);
+  }
+  _doProcessBlock(words, offset) {
+    // Shortcuts
+    const H = this._hash.words;
+    const H0 = H[0];
+    const H1 = H[1];
+    const H2 = H[2];
+    const H3 = H[3];
+    const H4 = H[4];
+    const H5 = H[5];
+    const H6 = H[6];
+    const H7 = H[7];
+    const H0h = H0.high;
+    let H0l = H0.low;
+    const H1h = H1.high;
+    let H1l = H1.low;
+    const H2h = H2.high;
+    let H2l = H2.low;
+    const H3h = H3.high;
+    let H3l = H3.low;
+    const H4h = H4.high;
+    let H4l = H4.low;
+    const H5h = H5.high;
+    let H5l = H5.low;
+    const H6h = H6.high;
+    let H6l = H6.low;
+    const H7h = H7.high;
+    let H7l = H7.low;
+    // Working variables
+    let ah = H0h;
+    let al = H0l;
+    let bh = H1h;
+    let bl = H1l;
+    let ch = H2h;
+    let cl = H2l;
+    let dh = H3h;
+    let dl = H3l;
+    let eh = H4h;
+    let el = H4l;
+    let fh = H5h;
+    let fl = H5l;
+    let gh = H6h;
+    let gl = H6l;
+    let hh = H7h;
+    let hl = H7l;
+    // Rounds
+    for (let i = 0; i < 80; i++) {
+      let Wil;
+      let Wih;
+      // Shortcut
+      const Wi = W[i];
+      // Extend message
+      if (i < 16) {
+        Wih = Wi.high = words[offset + i * 2] | 0;
+        Wil = Wi.low = words[offset + i * 2 + 1] | 0;
+      } else {
+        // Gamma0
+        const gamma0x = W[i - 15];
+        const gamma0xh = gamma0x.high;
+        const gamma0xl = gamma0x.low;
+        const gamma0h = (gamma0xh >>> 1 | gamma0xl << 31) ^ (gamma0xh >>> 8 | gamma0xl << 24) ^ gamma0xh >>> 7;
+        const gamma0l = (gamma0xl >>> 1 | gamma0xh << 31) ^ (gamma0xl >>> 8 | gamma0xh << 24) ^ (gamma0xl >>> 7 | gamma0xh << 25);
+        // Gamma1
+        const gamma1x = W[i - 2];
+        const gamma1xh = gamma1x.high;
+        const gamma1xl = gamma1x.low;
+        const gamma1h = (gamma1xh >>> 19 | gamma1xl << 13) ^ (gamma1xh << 3 | gamma1xl >>> 29) ^ gamma1xh >>> 6;
+        const gamma1l = (gamma1xl >>> 19 | gamma1xh << 13) ^ (gamma1xl << 3 | gamma1xh >>> 29) ^ (gamma1xl >>> 6 | gamma1xh << 26);
+        // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]
+        const Wi7 = W[i - 7];
+        const Wi7h = Wi7.high;
+        const Wi7l = Wi7.low;
+        const Wi16 = W[i - 16];
+        const Wi16h = Wi16.high;
+        const Wi16l = Wi16.low;
+        Wil = gamma0l + Wi7l;
+        Wih = gamma0h + Wi7h + (Wil >>> 0 < gamma0l >>> 0 ? 1 : 0);
+        Wil = Wil + gamma1l;
+        Wih = Wih + gamma1h + (Wil >>> 0 < gamma1l >>> 0 ? 1 : 0);
+        Wil = Wil + Wi16l;
+        Wih = Wih + Wi16h + (Wil >>> 0 < Wi16l >>> 0 ? 1 : 0);
+        Wi.high = Wih;
+        Wi.low = Wil;
+      }
+      const chh = eh & fh ^ ~eh & gh;
+      const chl = el & fl ^ ~el & gl;
+      const majh = ah & bh ^ ah & ch ^ bh & ch;
+      const majl = al & bl ^ al & cl ^ bl & cl;
+      const sigma0h = (ah >>> 28 | al << 4) ^ (ah << 30 | al >>> 2) ^ (ah << 25 | al >>> 7);
+      const sigma0l = (al >>> 28 | ah << 4) ^ (al << 30 | ah >>> 2) ^ (al << 25 | ah >>> 7);
+      const sigma1h = (eh >>> 14 | el << 18) ^ (eh >>> 18 | el << 14) ^ (eh << 23 | el >>> 9);
+      const sigma1l = (el >>> 14 | eh << 18) ^ (el >>> 18 | eh << 14) ^ (el << 23 | eh >>> 9);
+      // t1 = h + sigma1 + ch + K[i] + W[i]
+      const Ki = K[i];
+      const Kih = Ki.high;
+      const Kil = Ki.low;
+      let t1l = hl + sigma1l;
+      let t1h = hh + sigma1h + (t1l >>> 0 < hl >>> 0 ? 1 : 0);
+      t1l = t1l + chl;
+      t1h = t1h + chh + (t1l >>> 0 < chl >>> 0 ? 1 : 0);
+      t1l = t1l + Kil;
+      t1h = t1h + Kih + (t1l >>> 0 < Kil >>> 0 ? 1 : 0);
+      t1l = t1l + Wil;
+      t1h = t1h + Wih + (t1l >>> 0 < Wil >>> 0 ? 1 : 0);
+      // t2 = sigma0 + maj
+      const t2l = sigma0l + majl;
+      const t2h = sigma0h + majh + (t2l >>> 0 < sigma0l >>> 0 ? 1 : 0);
+      // Update working variables
+      hh = gh;
+      hl = gl;
+      gh = fh;
+      gl = fl;
+      fh = eh;
+      fl = el;
+      el = dl + t1l | 0;
+      eh = dh + t1h + (el >>> 0 < dl >>> 0 ? 1 : 0) | 0;
+      dh = ch;
+      dl = cl;
+      ch = bh;
+      cl = bl;
+      bh = ah;
+      bl = al;
+      al = t1l + t2l | 0;
+      ah = t1h + t2h + (al >>> 0 < t1l >>> 0 ? 1 : 0) | 0;
+    }
+    // Intermediate hash value
+    H0l = H0.low = H0l + al;
+    H0.high = H0h + ah + (H0l >>> 0 < al >>> 0 ? 1 : 0);
+    H1l = H1.low = H1l + bl;
+    H1.high = H1h + bh + (H1l >>> 0 < bl >>> 0 ? 1 : 0);
+    H2l = H2.low = H2l + cl;
+    H2.high = H2h + ch + (H2l >>> 0 < cl >>> 0 ? 1 : 0);
+    H3l = H3.low = H3l + dl;
+    H3.high = H3h + dh + (H3l >>> 0 < dl >>> 0 ? 1 : 0);
+    H4l = H4.low = H4l + el;
+    H4.high = H4h + eh + (H4l >>> 0 < el >>> 0 ? 1 : 0);
+    H5l = H5.low = H5l + fl;
+    H5.high = H5h + fh + (H5l >>> 0 < fl >>> 0 ? 1 : 0);
+    H6l = H6.low = H6l + gl;
+    H6.high = H6h + gh + (H6l >>> 0 < gl >>> 0 ? 1 : 0);
+    H7l = H7.low = H7l + hl;
+    H7.high = H7h + hh + (H7l >>> 0 < hl >>> 0 ? 1 : 0);
+  }
+  _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 + 128 >>> 10 << 5) + 30] = Math.floor(nBitsTotal / 0x100000000);
+    dataWords[(nBitsLeft + 128 >>> 10 << 5) + 31] = nBitsTotal;
+    data.nSigBytes = dataWords.length * 4;
+    // Hash final blocks
+    this._process();
+    // Convert hash to 32-bit word array before returning
+    return this._hash.to32();
+  }
+  clone() {
+    const props = {
+      hash: this._hash,
+      blockSize: this._blockSize,
+      data: this._data,
+      nBytes: this._nBytes
+    };
+    return new SHA512(props);
+  }
+  static hash(message, props) {
+    return new SHA512(props).finalize(message);
+  }
+}
+
+exports.SHA512 = SHA512;

package/dist/cjs/node_modules/jscrypto/es6/index.js

@@ -0,0 +1,118 @@
+'use strict';
+
+require('./lib/random.js');
+var Word32Array = require('./lib/Word32Array.js');
+var Word64Array = require('./lib/Word64Array.js');
+require('./lib/browser.js');
+var Base64 = require('./lib/encoder/Base64.js');
+var Utf8 = require('./lib/encoder/Utf8.js');
+var Latin1 = require('./lib/encoder/Latin1.js');
+var Hex = require('./lib/encoder/Hex.js');
+var Utf16 = require('./lib/encoder/Utf16.js');
+var OpenSSLKDF = require('./lib/algorithm/cipher/kdf/OpenSSLKDF.js');
+var PBKDF2 = require('./lib/algorithm/cipher/kdf/module/PBKDF2.js');
+var EvpKDF = require('./lib/algorithm/cipher/kdf/module/EvpKDF.js');
+var SerializableCipher = require('./lib/algorithm/cipher/SerializableCipher.js');
+var PasswordBasedCipher = require('./lib/algorithm/cipher/PasswordBasedCipher.js');
+var CipherParams = require('./lib/algorithm/cipher/CipherParams.js');
+var Hmac = require('./Hmac.js');
+var HmacMD5 = require('./HmacMD5.js');
+var HmacSHA1 = require('./HmacSHA1.js');
+var HmacSHA224 = require('./HmacSHA224.js');
+var HmacSHA256 = require('./HmacSHA256.js');
+var HmacSHA384 = require('./HmacSHA384.js');
+var HmacSHA512 = require('./HmacSHA512.js');
+var GMAC = require('./GMAC.js');
+var CBCMAC = require('./CBCMAC.js');
+var MD5 = require('./MD5.js');
+var SHA1 = require('./SHA1.js');
+var SHA224 = require('./SHA224.js');
+var SHA256 = require('./SHA256.js');
+var SHA384 = require('./SHA384.js');
+var SHA512 = require('./SHA512.js');
+var SHA3 = require('./SHA3.js');
+var AES = require('./AES.js');
+var DES = require('./DES.js');
+var DES3 = require('./DES3.js');
+var RIPEMD160 = require('./RIPEMD160.js');
+var Rabbit = require('./Rabbit.js');
+var RC4 = require('./RC4.js');
+var RC4Drop = require('./RC4Drop.js');
+var CBC = require('./lib/algorithm/cipher/mode/CBC.js');
+var CFB = require('./lib/algorithm/cipher/mode/CFB.js');
+var CTR = require('./lib/algorithm/cipher/mode/CTR.js');
+var ECB = require('./lib/algorithm/cipher/mode/ECB.js');
+var OFB = require('./lib/algorithm/cipher/mode/OFB.js');
+var GCM = require('./lib/algorithm/cipher/mode/GCM.js');
+var CCM = require('./lib/algorithm/cipher/mode/CCM.js');
+var AnsiX923 = require('./lib/algorithm/cipher/pad/AnsiX923.js');
+var ISO10126 = require('./lib/algorithm/cipher/pad/ISO10126.js');
+var ISO97971 = require('./lib/algorithm/cipher/pad/ISO97971.js');
+var Pkcs7 = require('./lib/algorithm/cipher/pad/Pkcs7.js');
+var NoPadding = require('./lib/algorithm/cipher/pad/NoPadding.js');
+var Zero = require('./lib/algorithm/cipher/pad/Zero.js');
+var OpenSSLFormatter = require('./lib/algorithm/cipher/formatter/OpenSSLFormatter.js');
+
+const mode = {
+  CBC: CBC.CBC,
+  CFB: CFB.CFB,
+  CTR: CTR.CTR,
+  ECB: ECB.ECB,
+  OFB: OFB.OFB,
+  GCM: GCM.GCM,
+  CCM: CCM.CCM
+};
+const pad = {
+  AnsiX923: AnsiX923.AnsiX923,
+  ISO10126: ISO10126.ISO10126,
+  ISO97971: ISO97971.ISO97971,
+  Pkcs7: Pkcs7.Pkcs7,
+  NoPadding: NoPadding.NoPadding,
+  Zero: Zero.Zero
+};
+const formatter = {
+  OpenSSLFormatter: OpenSSLFormatter.OpenSSLFormatter
+};
+
+exports.Word32Array = Word32Array.Word32Array;
+exports.Word64 = Word64Array.Word64;
+exports.Word64Array = Word64Array.Word64Array;
+exports.Base64 = Base64.Base64;
+exports.Utf8 = Utf8.Utf8;
+exports.Latin1 = Latin1.Latin1;
+exports.Hex = Hex.Hex;
+exports.Utf16 = Utf16.Utf16;
+exports.Utf16BE = Utf16.Utf16BE;
+exports.Utf16LE = Utf16.Utf16LE;
+exports.OpenSSLKDF = OpenSSLKDF.OpenSSLKDF;
+exports.PBKDF2 = PBKDF2.PBKDF2;
+exports.EvpKDF = EvpKDF.EvpKDF;
+exports.SerializableCipher = SerializableCipher.SerializableCipher;
+exports.PasswordBasedCipher = PasswordBasedCipher.PasswordBasedCipher;
+exports.CipherParams = CipherParams.CipherParams;
+exports.Hmac = Hmac.Hmac;
+exports.HmacMD5 = HmacMD5.HmacMD5;
+exports.HmacSHA1 = HmacSHA1.HmacSHA1;
+exports.HmacSHA224 = HmacSHA224.HmacSHA224;
+exports.HmacSHA256 = HmacSHA256.HmacSHA256;
+exports.HmacSHA384 = HmacSHA384.HmacSHA384;
+exports.HmacSHA512 = HmacSHA512.HmacSHA512;
+exports.GMAC = GMAC.GMAC;
+exports.CBCMAC = CBCMAC.CBCMAC;
+exports.MD5 = MD5.MD5;
+exports.SHA1 = SHA1.SHA1;
+exports.SHA224 = SHA224.SHA224;
+exports.SHA256 = SHA256.SHA256;
+exports.SHA384 = SHA384.SHA384;
+exports.SHA512 = SHA512.SHA512;
+exports.SHA3 = SHA3.SHA3;
+exports.AES = AES.AES;
+exports.DES = DES.DES;
+exports.DES3 = DES3.DES3;
+exports.RIPEMD160 = RIPEMD160.RIPEMD160;
+exports.Rabbit = Rabbit.Rabbit;
+exports.RC4 = RC4.RC4;
+exports.RC4Drop = RC4Drop.RC4Drop;
+exports.formatter = formatter;
+exports.mode = mode;
+exports.pad = pad;