@tonysamperi/krypto 1.0.0

package/dist/esm/algo/index.js

@@ -0,0 +1,7 @@
+export * from "./aes.class.js";
+export * from "./des.class.js";
+export * from "./md5.class.js";
+export * from "./triple-des.class.js";
+export * from "./sha1.class.js";
+export * from "./sha256.class.js";
+export * from "./sha512.class.js";

package/dist/esm/algo/md5.class.d.ts

@@ -0,0 +1,13 @@
+import { Hasher } from "../lib/hasher.class.js";
+import { WordArray } from "../lib/word-array.class.js";
+export declare class MD5 extends Hasher {
+    get hash(): WordArray;
+    protected _hash: WordArray;
+    static FF(a: number, b: number, c: number, d: number, x: number, s: number, t: number): number;
+    static GG(a: number, b: number, c: number, d: number, x: number, s: number, t: number): number;
+    static HH(a: number, b: number, c: number, d: number, x: number, s: number, t: number): number;
+    static II(a: number, b: number, c: number, d: number, x: number, s: number, t: number): number;
+    reset(): void;
+    protected _doFinalize(): WordArray;
+    protected _doProcessBlock(m: number[], offset: number): void;
+}

package/dist/esm/algo/md5.class.js

@@ -0,0 +1,137 @@
+import { Hasher } from "../lib/hasher.class.js";
+import { WordArray } from "../lib/word-array.class.js";
+const T = [];
+for (let i = 0; i < 64; i++) {
+  T[i] = Math.abs(Math.sin(i + 1)) * 4294967296 | 0;
+}
+class MD5 extends Hasher {
+  get hash() {
+    return this._hash;
+  }
+  static FF(a, b, c, d, x, s, t) {
+    const n = a + (b & c | ~b & d) + x + t;
+    return (n << s | n >>> 32 - s) + b;
+  }
+  static GG(a, b, c, d, x, s, t) {
+    const n = a + (b & d | c & ~d) + x + t;
+    return (n << s | n >>> 32 - s) + b;
+  }
+  static HH(a, b, c, d, x, s, t) {
+    const n = a + (b ^ c ^ d) + x + t;
+    return (n << s | n >>> 32 - s) + b;
+  }
+  static II(a, b, c, d, x, s, t) {
+    const n = a + (c ^ (b | ~d)) + x + t;
+    return (n << s | n >>> 32 - s) + b;
+  }
+  reset() {
+    super.reset();
+    this._hash = new WordArray([
+      1732584193,
+      4023233417,
+      2562383102,
+      271733878
+    ]);
+  }
+  _doFinalize() {
+    const nBitsTotal = this._nDataBytes * 8;
+    const nBitsLeft = this._data.sigBytes * 8;
+    this._data.words[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;
+    const nBitsTotalH = Math.floor(nBitsTotal / 4294967296);
+    const nBitsTotalL = nBitsTotal;
+    this._data.words[(nBitsLeft + 64 >>> 9 << 4) + 15] = (nBitsTotalH << 8 | nBitsTotalH >>> 24) & 16711935 | (nBitsTotalH << 24 | nBitsTotalH >>> 8) & 4278255360;
+    this._data.words[(nBitsLeft + 64 >>> 9 << 4) + 14] = (nBitsTotalL << 8 | nBitsTotalL >>> 24) & 16711935 | (nBitsTotalL << 24 | nBitsTotalL >>> 8) & 4278255360;
+    this._data.sigBytes = (this._data.words.length + 1) * 4;
+    this._process();
+    for (let i = 0; i < 4; i++) {
+      this._hash.words[i] = (this._hash.words[i] << 8 | this._hash.words[i] >>> 24) & 16711935 | (this._hash.words[i] << 24 | this._hash.words[i] >>> 8) & 4278255360;
+    }
+    return this._hash;
+  }
+  _doProcessBlock(m, offset) {
+    for (let i = 0; i < 16; i++) {
+      const offsetI = offset + i;
+      const mOffsetI = m[offsetI];
+      m[offsetI] = (mOffsetI << 8 | mOffsetI >>> 24) & 16711935 | (mOffsetI << 24 | mOffsetI >>> 8) & 4278255360;
+    }
+    const mOffsets = Array.from({ length: 16 });
+    for (let i = 0; i < 16; i++) {
+      mOffsets[i] = m[offset + i];
+    }
+    let a = this._hash.words[0];
+    let b = this._hash.words[1];
+    let c = this._hash.words[2];
+    let d = this._hash.words[3];
+    a = MD5.FF(a, b, c, d, mOffsets[0], 7, T[0]);
+    d = MD5.FF(d, a, b, c, mOffsets[1], 12, T[1]);
+    c = MD5.FF(c, d, a, b, mOffsets[2], 17, T[2]);
+    b = MD5.FF(b, c, d, a, mOffsets[3], 22, T[3]);
+    a = MD5.FF(a, b, c, d, mOffsets[4], 7, T[4]);
+    d = MD5.FF(d, a, b, c, mOffsets[5], 12, T[5]);
+    c = MD5.FF(c, d, a, b, mOffsets[6], 17, T[6]);
+    b = MD5.FF(b, c, d, a, mOffsets[7], 22, T[7]);
+    a = MD5.FF(a, b, c, d, mOffsets[8], 7, T[8]);
+    d = MD5.FF(d, a, b, c, mOffsets[9], 12, T[9]);
+    c = MD5.FF(c, d, a, b, mOffsets[10], 17, T[10]);
+    b = MD5.FF(b, c, d, a, mOffsets[11], 22, T[11]);
+    a = MD5.FF(a, b, c, d, mOffsets[12], 7, T[12]);
+    d = MD5.FF(d, a, b, c, mOffsets[13], 12, T[13]);
+    c = MD5.FF(c, d, a, b, mOffsets[14], 17, T[14]);
+    b = MD5.FF(b, c, d, a, mOffsets[15], 22, T[15]);
+    a = MD5.GG(a, b, c, d, mOffsets[1], 5, T[16]);
+    d = MD5.GG(d, a, b, c, mOffsets[6], 9, T[17]);
+    c = MD5.GG(c, d, a, b, mOffsets[11], 14, T[18]);
+    b = MD5.GG(b, c, d, a, mOffsets[0], 20, T[19]);
+    a = MD5.GG(a, b, c, d, mOffsets[5], 5, T[20]);
+    d = MD5.GG(d, a, b, c, mOffsets[10], 9, T[21]);
+    c = MD5.GG(c, d, a, b, mOffsets[15], 14, T[22]);
+    b = MD5.GG(b, c, d, a, mOffsets[4], 20, T[23]);
+    a = MD5.GG(a, b, c, d, mOffsets[9], 5, T[24]);
+    d = MD5.GG(d, a, b, c, mOffsets[14], 9, T[25]);
+    c = MD5.GG(c, d, a, b, mOffsets[3], 14, T[26]);
+    b = MD5.GG(b, c, d, a, mOffsets[8], 20, T[27]);
+    a = MD5.GG(a, b, c, d, mOffsets[13], 5, T[28]);
+    d = MD5.GG(d, a, b, c, mOffsets[2], 9, T[29]);
+    c = MD5.GG(c, d, a, b, mOffsets[7], 14, T[30]);
+    b = MD5.GG(b, c, d, a, mOffsets[12], 20, T[31]);
+    a = MD5.HH(a, b, c, d, mOffsets[5], 4, T[32]);
+    d = MD5.HH(d, a, b, c, mOffsets[8], 11, T[33]);
+    c = MD5.HH(c, d, a, b, mOffsets[11], 16, T[34]);
+    b = MD5.HH(b, c, d, a, mOffsets[14], 23, T[35]);
+    a = MD5.HH(a, b, c, d, mOffsets[1], 4, T[36]);
+    d = MD5.HH(d, a, b, c, mOffsets[4], 11, T[37]);
+    c = MD5.HH(c, d, a, b, mOffsets[7], 16, T[38]);
+    b = MD5.HH(b, c, d, a, mOffsets[10], 23, T[39]);
+    a = MD5.HH(a, b, c, d, mOffsets[13], 4, T[40]);
+    d = MD5.HH(d, a, b, c, mOffsets[0], 11, T[41]);
+    c = MD5.HH(c, d, a, b, mOffsets[3], 16, T[42]);
+    b = MD5.HH(b, c, d, a, mOffsets[6], 23, T[43]);
+    a = MD5.HH(a, b, c, d, mOffsets[9], 4, T[44]);
+    d = MD5.HH(d, a, b, c, mOffsets[12], 11, T[45]);
+    c = MD5.HH(c, d, a, b, mOffsets[15], 16, T[46]);
+    b = MD5.HH(b, c, d, a, mOffsets[2], 23, T[47]);
+    a = MD5.II(a, b, c, d, mOffsets[0], 6, T[48]);
+    d = MD5.II(d, a, b, c, mOffsets[7], 10, T[49]);
+    c = MD5.II(c, d, a, b, mOffsets[14], 15, T[50]);
+    b = MD5.II(b, c, d, a, mOffsets[5], 21, T[51]);
+    a = MD5.II(a, b, c, d, mOffsets[12], 6, T[52]);
+    d = MD5.II(d, a, b, c, mOffsets[3], 10, T[53]);
+    c = MD5.II(c, d, a, b, mOffsets[10], 15, T[54]);
+    b = MD5.II(b, c, d, a, mOffsets[1], 21, T[55]);
+    a = MD5.II(a, b, c, d, mOffsets[8], 6, T[56]);
+    d = MD5.II(d, a, b, c, mOffsets[15], 10, T[57]);
+    c = MD5.II(c, d, a, b, mOffsets[6], 15, T[58]);
+    b = MD5.II(b, c, d, a, mOffsets[13], 21, T[59]);
+    a = MD5.II(a, b, c, d, mOffsets[4], 6, T[60]);
+    d = MD5.II(d, a, b, c, mOffsets[11], 10, T[61]);
+    c = MD5.II(c, d, a, b, mOffsets[2], 15, T[62]);
+    b = MD5.II(b, c, d, a, mOffsets[9], 21, T[63]);
+    this._hash.words[0] = this._hash.words[0] + a | 0;
+    this._hash.words[1] = this._hash.words[1] + b | 0;
+    this._hash.words[2] = this._hash.words[2] + c | 0;
+    this._hash.words[3] = this._hash.words[3] + d | 0;
+  }
+}
+export {
+  MD5
+};

package/dist/esm/algo/sha1.class.d.ts

@@ -0,0 +1,9 @@
+import { Hasher } from "../lib/hasher.class.js";
+import { WordArray } from "../lib/word-array.class.js";
+export declare class SHA1 extends Hasher {
+    get hash(): WordArray;
+    protected _hash: WordArray;
+    reset(): void;
+    protected _doFinalize(): WordArray;
+    protected _doProcessBlock(m: number[], offset: number): void;
+}

package/dist/esm/algo/sha1.class.js

@@ -0,0 +1,66 @@
+import { Hasher } from "../lib/hasher.class.js";
+import { WordArray } from "../lib/word-array.class.js";
+const H = [1732584193, 4023233417, 2562383102, 271733878, 3285377520];
+const W = new Array(80);
+class SHA1 extends Hasher {
+  get hash() {
+    return this._hash;
+  }
+  reset() {
+    super.reset();
+    this._hash = new WordArray(H.slice(0));
+  }
+  _doFinalize() {
+    const nBitsTotal = this._nDataBytes * 8;
+    const nBitsLeft = this._data.sigBytes * 8;
+    this._data.words[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;
+    this._data.words[(nBitsLeft + 64 >>> 9 << 4) + 14] = Math.floor(nBitsTotal / 4294967296);
+    this._data.words[(nBitsLeft + 64 >>> 9 << 4) + 15] = nBitsTotal;
+    this._data.sigBytes = this._data.words.length * 4;
+    this._process();
+    return this._hash;
+  }
+  _doProcessBlock(m, offset) {
+    let a = this._hash.words[0];
+    let b = this._hash.words[1];
+    let c = this._hash.words[2];
+    let d = this._hash.words[3];
+    let e = this._hash.words[4];
+    for (let i = 0; i < 80; i++) {
+      if (i < 16) {
+        W[i] = m[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 f, k;
+      if (i < 20) {
+        f = b & c | ~b & d;
+        k = 1518500249;
+      } else if (i < 40) {
+        f = b ^ c ^ d;
+        k = 1859775393;
+      } else if (i < 60) {
+        f = b & c | b & d | c & d;
+        k = 2400959708;
+      } else {
+        f = b ^ c ^ d;
+        k = 3395469782;
+      }
+      const temp = (a << 5 | a >>> 27) + f + e + k + W[i];
+      e = d;
+      d = c;
+      c = b << 30 | b >>> 2;
+      b = a;
+      a = temp | 0;
+    }
+    this._hash.words[0] = this._hash.words[0] + a | 0;
+    this._hash.words[1] = this._hash.words[1] + b | 0;
+    this._hash.words[2] = this._hash.words[2] + c | 0;
+    this._hash.words[3] = this._hash.words[3] + d | 0;
+    this._hash.words[4] = this._hash.words[4] + e | 0;
+  }
+}
+export {
+  SHA1
+};

package/dist/esm/algo/sha256.class.d.ts

@@ -0,0 +1,9 @@
+import { Hasher } from "../lib/hasher.class.js";
+import { WordArray } from "../lib/word-array.class.js";
+export declare class SHA256 extends Hasher {
+    private _hash;
+    constructor();
+    reset(): void;
+    protected _doFinalize(): WordArray;
+    protected _doProcessBlock(m: number[], offset: number): void;
+}

package/dist/esm/algo/sha256.class.js

@@ -0,0 +1,96 @@
+import { Hasher } from "../lib/hasher.class.js";
+import { WordArray } from "../lib/word-array.class.js";
+const H = [];
+const K = [];
+(function() {
+  function isPrime(n2) {
+    const sqrtN = Math.sqrt(n2);
+    for (let factor = 2; factor <= sqrtN; factor++) {
+      if (!(n2 % factor)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  function getFractionalBits(n2) {
+    return (n2 - (n2 | 0)) * 4294967296 | 0;
+  }
+  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++;
+  }
+})();
+const W = [];
+class SHA256 extends Hasher {
+  constructor() {
+    super();
+  }
+  reset() {
+    super.reset();
+    this._hash = new WordArray(H.slice(0));
+  }
+  _doFinalize() {
+    const nBitsTotal = this._nDataBytes * 8;
+    const nBitsLeft = this._data.sigBytes * 8;
+    this._data.words[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;
+    this._data.words[(nBitsLeft + 64 >>> 9 << 4) + 14] = Math.floor(nBitsTotal / 4294967296);
+    this._data.words[(nBitsLeft + 64 >>> 9 << 4) + 15] = nBitsTotal;
+    this._data.sigBytes = this._data.words.length * 4;
+    this._process();
+    return this._hash;
+  }
+  _doProcessBlock(m, offset) {
+    let a = this._hash.words[0];
+    let b = this._hash.words[1];
+    let c = this._hash.words[2];
+    let d = this._hash.words[3];
+    let e = this._hash.words[4];
+    let f = this._hash.words[5];
+    let g = this._hash.words[6];
+    let h = this._hash.words[7];
+    for (let i = 0; i < 64; i++) {
+      if (i < 16) {
+        W[i] = m[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;
+    }
+    this._hash.words[0] = this._hash.words[0] + a | 0;
+    this._hash.words[1] = this._hash.words[1] + b | 0;
+    this._hash.words[2] = this._hash.words[2] + c | 0;
+    this._hash.words[3] = this._hash.words[3] + d | 0;
+    this._hash.words[4] = this._hash.words[4] + e | 0;
+    this._hash.words[5] = this._hash.words[5] + f | 0;
+    this._hash.words[6] = this._hash.words[6] + g | 0;
+    this._hash.words[7] = this._hash.words[7] + h | 0;
+  }
+}
+export {
+  SHA256
+};

package/dist/esm/algo/sha512.class.d.ts

@@ -0,0 +1,9 @@
+import { Hasher } from "../lib/hasher.class.js";
+import { WordArray } from "../lib/word-array.class.js";
+export declare class SHA512 extends Hasher {
+    private _hash;
+    constructor();
+    reset(): void;
+    protected _doFinalize(): WordArray;
+    protected _doProcessBlock(m: number[], offset: number): void;
+}

package/dist/esm/algo/sha512.class.js

@@ -0,0 +1,221 @@
+import { Hasher } from "../lib/hasher.class.js";
+import { X64Word } from "../lib/x64-word.class.js";
+import { X64WordArray } from "../lib/x64-word-array.class.js";
+const K = [
+  new X64Word(1116352408, 3609767458),
+  new X64Word(1899447441, 602891725),
+  new X64Word(3049323471, 3964484399),
+  new X64Word(3921009573, 2173295548),
+  new X64Word(961987163, 4081628472),
+  new X64Word(1508970993, 3053834265),
+  new X64Word(2453635748, 2937671579),
+  new X64Word(2870763221, 3664609560),
+  new X64Word(3624381080, 2734883394),
+  new X64Word(310598401, 1164996542),
+  new X64Word(607225278, 1323610764),
+  new X64Word(1426881987, 3590304994),
+  new X64Word(1925078388, 4068182383),
+  new X64Word(2162078206, 991336113),
+  new X64Word(2614888103, 633803317),
+  new X64Word(3248222580, 3479774868),
+  new X64Word(3835390401, 2666613458),
+  new X64Word(4022224774, 944711139),
+  new X64Word(264347078, 2341262773),
+  new X64Word(604807628, 2007800933),
+  new X64Word(770255983, 1495990901),
+  new X64Word(1249150122, 1856431235),
+  new X64Word(1555081692, 3175218132),
+  new X64Word(1996064986, 2198950837),
+  new X64Word(2554220882, 3999719339),
+  new X64Word(2821834349, 766784016),
+  new X64Word(2952996808, 2566594879),
+  new X64Word(3210313671, 3203337956),
+  new X64Word(3336571891, 1034457026),
+  new X64Word(3584528711, 2466948901),
+  new X64Word(113926993, 3758326383),
+  new X64Word(338241895, 168717936),
+  new X64Word(666307205, 1188179964),
+  new X64Word(773529912, 1546045734),
+  new X64Word(1294757372, 1522805485),
+  new X64Word(1396182291, 2643833823),
+  new X64Word(1695183700, 2343527390),
+  new X64Word(1986661051, 1014477480),
+  new X64Word(2177026350, 1206759142),
+  new X64Word(2456956037, 344077627),
+  new X64Word(2730485921, 1290863460),
+  new X64Word(2820302411, 3158454273),
+  new X64Word(3259730800, 3505952657),
+  new X64Word(3345764771, 106217008),
+  new X64Word(3516065817, 3606008344),
+  new X64Word(3600352804, 1432725776),
+  new X64Word(4094571909, 1467031594),
+  new X64Word(275423344, 851169720),
+  new X64Word(430227734, 3100823752),
+  new X64Word(506948616, 1363258195),
+  new X64Word(659060556, 3750685593),
+  new X64Word(883997877, 3785050280),
+  new X64Word(958139571, 3318307427),
+  new X64Word(1322822218, 3812723403),
+  new X64Word(1537002063, 2003034995),
+  new X64Word(1747873779, 3602036899),
+  new X64Word(1955562222, 1575990012),
+  new X64Word(2024104815, 1125592928),
+  new X64Word(2227730452, 2716904306),
+  new X64Word(2361852424, 442776044),
+  new X64Word(2428436474, 593698344),
+  new X64Word(2756734187, 3733110249),
+  new X64Word(3204031479, 2999351573),
+  new X64Word(3329325298, 3815920427),
+  new X64Word(3391569614, 3928383900),
+  new X64Word(3515267271, 566280711),
+  new X64Word(3940187606, 3454069534),
+  new X64Word(4118630271, 4000239992),
+  new X64Word(116418474, 1914138554),
+  new X64Word(174292421, 2731055270),
+  new X64Word(289380356, 3203993006),
+  new X64Word(460393269, 320620315),
+  new X64Word(685471733, 587496836),
+  new X64Word(852142971, 1086792851),
+  new X64Word(1017036298, 365543100),
+  new X64Word(1126000580, 2618297676),
+  new X64Word(1288033470, 3409855158),
+  new X64Word(1501505948, 4234509866),
+  new X64Word(1607167915, 987167468),
+  new X64Word(1816402316, 1246189591)
+];
+const W = [];
+(function() {
+  for (let i = 0; i < 80; i++) {
+    W[i] = new X64Word(void 0, void 0);
+  }
+})();
+class SHA512 extends Hasher {
+  constructor() {
+    super({
+      blockSize: 1024 / 32
+    });
+  }
+  reset() {
+    super.reset();
+    this._hash = new X64WordArray([
+      new X64Word(1779033703, 4089235720),
+      new X64Word(3144134277, 2227873595),
+      new X64Word(1013904242, 4271175723),
+      new X64Word(2773480762, 1595750129),
+      new X64Word(1359893119, 2917565137),
+      new X64Word(2600822924, 725511199),
+      new X64Word(528734635, 4215389547),
+      new X64Word(1541459225, 327033209)
+    ]);
+  }
+  _doFinalize() {
+    const data = this._data;
+    const dataWords = data.words;
+    const nBitsTotal = this._nDataBytes * 8;
+    const nBitsLeft = data.sigBytes * 8;
+    dataWords[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;
+    dataWords[(nBitsLeft + 128 >>> 10 << 5) + 30] = Math.floor(nBitsTotal / 4294967296);
+    dataWords[(nBitsLeft + 128 >>> 10 << 5) + 31] = nBitsTotal;
+    data.sigBytes = dataWords.length * 4;
+    this._process();
+    return this._hash.toX32();
+  }
+  _doProcessBlock(m, offset) {
+    let ah = this._hash.words[0].high;
+    let al = this._hash.words[0].low;
+    let bh = this._hash.words[1].high;
+    let bl = this._hash.words[1].low;
+    let ch = this._hash.words[2].high;
+    let cl = this._hash.words[2].low;
+    let dh = this._hash.words[3].high;
+    let dl = this._hash.words[3].low;
+    let eh = this._hash.words[4].high;
+    let el = this._hash.words[4].low;
+    let fh = this._hash.words[5].high;
+    let fl = this._hash.words[5].low;
+    let gh = this._hash.words[6].high;
+    let gl = this._hash.words[6].low;
+    let hh = this._hash.words[7].high;
+    let hl = this._hash.words[7].low;
+    for (let i = 0; i < 80; i++) {
+      let currentLow;
+      let currentHi;
+      if (i < 16) {
+        currentHi = W[i].high = m[offset + i * 2] | 0;
+        currentLow = W[i].low = m[offset + i * 2 + 1] | 0;
+      } else {
+        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);
+        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);
+        currentLow = gamma0l + W[i - 7].low;
+        currentHi = gamma0h + W[i - 7].high + (currentLow >>> 0 < gamma0l >>> 0 ? 1 : 0);
+        currentLow = currentLow + gamma1l;
+        currentHi = currentHi + gamma1h + (currentLow >>> 0 < gamma1l >>> 0 ? 1 : 0);
+        currentLow = currentLow + W[i - 16].low;
+        currentHi = currentHi + W[i - 16].high + (currentLow >>> 0 < W[i - 16].low >>> 0 ? 1 : 0);
+        W[i].high = currentHi;
+        W[i].low = currentLow;
+      }
+      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);
+      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 + K[i].low;
+      t1h = t1h + K[i].high + (t1l >>> 0 < K[i].low >>> 0 ? 1 : 0);
+      t1l = t1l + currentLow;
+      t1h = t1h + currentHi + (t1l >>> 0 < currentLow >>> 0 ? 1 : 0);
+      const t2l = sigma0l + majl;
+      const t2h = sigma0h + majh + (t2l >>> 0 < sigma0l >>> 0 ? 1 : 0);
+      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;
+    }
+    this._hash.words[0].low = this._hash.words[0].low = this._hash.words[0].low + al;
+    this._hash.words[0].high = this._hash.words[0].high + ah + (this._hash.words[0].low >>> 0 < al >>> 0 ? 1 : 0);
+    this._hash.words[1].low = this._hash.words[1].low = this._hash.words[1].low + bl;
+    this._hash.words[1].high = this._hash.words[1].high + bh + (this._hash.words[1].low >>> 0 < bl >>> 0 ? 1 : 0);
+    this._hash.words[2].low = this._hash.words[2].low = this._hash.words[2].low + cl;
+    this._hash.words[2].high = this._hash.words[2].high + ch + (this._hash.words[2].low >>> 0 < cl >>> 0 ? 1 : 0);
+    this._hash.words[3].low = this._hash.words[3].low = this._hash.words[3].low + dl;
+    this._hash.words[3].high = this._hash.words[3].high + dh + (this._hash.words[3].low >>> 0 < dl >>> 0 ? 1 : 0);
+    this._hash.words[4].low = this._hash.words[4].low = this._hash.words[4].low + el;
+    this._hash.words[4].high = this._hash.words[4].high + eh + (this._hash.words[4].low >>> 0 < el >>> 0 ? 1 : 0);
+    this._hash.words[5].low = this._hash.words[5].low = this._hash.words[5].low + fl;
+    this._hash.words[5].high = this._hash.words[5].high + fh + (this._hash.words[5].low >>> 0 < fl >>> 0 ? 1 : 0);
+    this._hash.words[6].low = this._hash.words[6].low = this._hash.words[6].low + gl;
+    this._hash.words[6].high = this._hash.words[6].high + gh + (this._hash.words[6].low >>> 0 < gl >>> 0 ? 1 : 0);
+    this._hash.words[7].low = this._hash.words[7].low = this._hash.words[7].low + hl;
+    this._hash.words[7].high = this._hash.words[7].high + hh + (this._hash.words[7].low >>> 0 < hl >>> 0 ? 1 : 0);
+  }
+}
+export {
+  SHA512
+};

package/dist/esm/algo/triple-des.class.d.ts

@@ -0,0 +1,16 @@
+import { BlockCipher } from "../lib/block-cipher.class.js";
+import { WordArray } from "../lib/word-array.class.js";
+import { BufferedBlockAlgorithmConfig } from "../lib/buffered-block-algorithm-config.interface.js";
+import { DES } from "./des.class.js";
+export declare class TripleDES extends BlockCipher {
+    static blockSize: number;
+    static ivSize: number;
+    static keySize: number;
+    protected _des1: DES;
+    protected _des2: DES;
+    protected _des3: DES;
+    constructor(xformMode: number, key: WordArray, cfg?: BufferedBlockAlgorithmConfig);
+    decryptBlock(m: number[], offset: number): void;
+    encryptBlock(m: number[], offset: number): void;
+    reset(): void;
+}

package/dist/esm/algo/triple-des.class.js

@@ -0,0 +1,37 @@
+import { BlockCipher } from "../lib/block-cipher.class.js";
+import { WordArray } from "../lib/word-array.class.js";
+import { DES } from "./des.class.js";
+class TripleDES extends BlockCipher {
+  constructor(xformMode, key, cfg) {
+    super(xformMode, key, cfg);
+    this.reset();
+  }
+  decryptBlock(m, offset) {
+    this._des3.decryptBlock(m, offset);
+    this._des2.encryptBlock(m, offset);
+    this._des1.decryptBlock(m, offset);
+  }
+  encryptBlock(m, offset) {
+    this._des1.encryptBlock(m, offset);
+    this._des2.decryptBlock(m, offset);
+    this._des3.encryptBlock(m, offset);
+  }
+  reset() {
+    super.reset();
+    if (this._key.words.length !== 2 && this._key.words.length !== 4 && this._key.words.length < 6) {
+      throw new Error("Invalid key length - 3DES requires the key length to be 64, 128, 192 or >192.");
+    }
+    const key1 = this._key.words.slice(0, 2);
+    const key2 = this._key.words.length < 4 ? this._key.words.slice(0, 2) : this._key.words.slice(2, 4);
+    const key3 = this._key.words.length < 6 ? this._key.words.slice(0, 2) : this._key.words.slice(4, 6);
+    this._des1 = DES.createEncryptor(new WordArray(key1));
+    this._des2 = DES.createEncryptor(new WordArray(key2));
+    this._des3 = DES.createEncryptor(new WordArray(key3));
+  }
+}
+TripleDES.blockSize = 192 / 32;
+TripleDES.ivSize = 64 / 32;
+TripleDES.keySize = 64 / 32;
+export {
+  TripleDES
+};

package/dist/esm/enc/base64.class.d.ts

@@ -0,0 +1,31 @@
+import { WordArray } from "../lib/word-array.class.js";
+import { AbstractEncoder } from "./encoder.model.js";
+export declare class Base64 implements AbstractEncoder {
+    protected static _map: string;
+    protected static _reverseMap: number[] | undefined;
+    /**
+     * Converts a Base64 string to a word array.
+     *
+     * @param base64Str The Base64 string.
+     *
+     * @return The word array.
+     *
+     * @example
+     *
+     *     let wordArray = Base64.parse(base64String);
+     */
+    static parse(base64Str: string): WordArray;
+    static parseLoop(base64Str: string, base64StrLength: number, reverseMap: number[]): WordArray;
+    /**
+     * Converts a word array to a Base64 string.
+     *
+     * @param wordArray The word array.
+     *
+     * @return The Base64 string.
+     *
+     * @example
+     *
+     *     let base64String = Base64.stringify(wordArray);
+     */
+    static stringify(wordArray: WordArray): string;
+}