ooxml-core 1.0.0 → 1.1.0

package/dist/digest/index.cjs

@@ -23,10 +23,10 @@ var ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/
 var VALUES = new Map([...ALPHABET].map((char, index) => [char, index]));
 function encodeBase64(bytes) {
   let out = "";
-  for (let i = 0; i < bytes.length; i += 3) {
-    const a = bytes[i];
-    const b = bytes[i + 1];
-    const c = bytes[i + 2];
+  for (let i2 = 0; i2 < bytes.length; i2 += 3) {
+    const a = bytes[i2];
+    const b = bytes[i2 + 1];
+    const c = bytes[i2 + 2];
     const n = a << 16 | (b ?? 0) << 8 | (c ?? 0);
     out += ALPHABET[n >> 18] + ALPHABET[n >> 12 & 63];
     out += b === void 0 ? "=" : ALPHABET[n >> 6 & 63];
@@ -56,6 +56,846 @@ function decodeBase64(text) {
   return out;
 }
 
+// digest/md2.ts
+var S = [
+  41,
+  46,
+  67,
+  201,
+  162,
+  216,
+  124,
+  1,
+  61,
+  54,
+  84,
+  161,
+  236,
+  240,
+  6,
+  19,
+  98,
+  167,
+  5,
+  243,
+  192,
+  199,
+  115,
+  140,
+  152,
+  147,
+  43,
+  217,
+  188,
+  76,
+  130,
+  202,
+  30,
+  155,
+  87,
+  60,
+  253,
+  212,
+  224,
+  22,
+  103,
+  66,
+  111,
+  24,
+  138,
+  23,
+  229,
+  18,
+  190,
+  78,
+  196,
+  214,
+  218,
+  158,
+  222,
+  73,
+  160,
+  251,
+  245,
+  142,
+  187,
+  47,
+  238,
+  122,
+  169,
+  104,
+  121,
+  145,
+  21,
+  178,
+  7,
+  63,
+  148,
+  194,
+  16,
+  137,
+  11,
+  34,
+  95,
+  33,
+  128,
+  127,
+  93,
+  154,
+  90,
+  144,
+  50,
+  39,
+  53,
+  62,
+  204,
+  231,
+  191,
+  247,
+  151,
+  3,
+  255,
+  25,
+  48,
+  179,
+  72,
+  165,
+  181,
+  209,
+  215,
+  94,
+  146,
+  42,
+  172,
+  86,
+  170,
+  198,
+  79,
+  184,
+  56,
+  210,
+  150,
+  164,
+  125,
+  182,
+  118,
+  252,
+  107,
+  226,
+  156,
+  116,
+  4,
+  241,
+  69,
+  157,
+  112,
+  89,
+  100,
+  113,
+  135,
+  32,
+  134,
+  91,
+  207,
+  101,
+  230,
+  45,
+  168,
+  2,
+  27,
+  96,
+  37,
+  173,
+  174,
+  176,
+  185,
+  246,
+  28,
+  70,
+  97,
+  105,
+  52,
+  64,
+  126,
+  15,
+  85,
+  71,
+  163,
+  35,
+  221,
+  81,
+  175,
+  58,
+  195,
+  92,
+  249,
+  206,
+  186,
+  197,
+  234,
+  38,
+  44,
+  83,
+  13,
+  110,
+  133,
+  40,
+  132,
+  9,
+  211,
+  223,
+  205,
+  244,
+  65,
+  129,
+  77,
+  82,
+  106,
+  220,
+  55,
+  200,
+  108,
+  193,
+  171,
+  250,
+  36,
+  225,
+  123,
+  8,
+  12,
+  189,
+  177,
+  74,
+  120,
+  136,
+  149,
+  139,
+  227,
+  99,
+  232,
+  109,
+  233,
+  203,
+  213,
+  254,
+  59,
+  0,
+  29,
+  57,
+  242,
+  239,
+  183,
+  14,
+  102,
+  88,
+  208,
+  228,
+  166,
+  119,
+  114,
+  248,
+  235,
+  117,
+  75,
+  10,
+  49,
+  68,
+  80,
+  180,
+  143,
+  237,
+  31,
+  26,
+  219,
+  153,
+  141,
+  51,
+  159,
+  17,
+  131,
+  20
+];
+function transform(state, checksum, block) {
+  const x = new Uint8Array(48);
+  x.set(state, 0);
+  x.set(block, 16);
+  for (let k = 0; k < 16; k++) {
+    x[32 + k] = state[k] ^ block[k];
+  }
+  let t = 0;
+  for (let round2 = 0; round2 < 18; round2++) {
+    for (let k = 0; k < 48; k++) {
+      x[k] = x[k] ^ S[t];
+      t = x[k];
+    }
+    t = t + round2 & 255;
+  }
+  state.set(x.subarray(0, 16));
+  t = checksum[15];
+  for (let k = 0; k < 16; k++) {
+    checksum[k] = checksum[k] ^ S[block[k] ^ t];
+    t = checksum[k];
+  }
+}
+function md2(message) {
+  const padLength = 16 - message.length % 16;
+  const padded = new Uint8Array(message.length + padLength);
+  padded.set(message);
+  padded.fill(padLength, message.length);
+  const state = new Uint8Array(16);
+  const checksum = new Uint8Array(16);
+  for (let offset = 0; offset < padded.length; offset += 16) {
+    transform(state, checksum, padded.subarray(offset, offset + 16));
+  }
+  transform(state, checksum, checksum.slice());
+  return state;
+}
+
+// digest/bit-ops.ts
+function rotl32(x, n) {
+  return (x << n | x >>> 32 - n) >>> 0;
+}
+function add32(...values) {
+  let sum = 0;
+  for (const value of values) sum = sum + value >>> 0;
+  return sum;
+}
+function padMd4Style(message) {
+  const paddedLength = message.length + 9 + 63 & -64;
+  const padded = new Uint8Array(paddedLength);
+  padded.set(message);
+  padded[message.length] = 128;
+  new DataView(padded.buffer).setBigUint64(paddedLength - 8, BigInt(message.length) * 8n, true);
+  return padded;
+}
+function applyRotatingRound(r, ops, f6, x, feedback = false) {
+  let target = 0;
+  for (const [k, s, addConst] of ops) {
+    const i1 = target + 1 & 3;
+    const next = r[i1];
+    const rotated = rotl32(
+      add32(r[target], f6(next, r[target + 2 & 3], r[target + 3 & 3]), x[k], addConst),
+      s
+    );
+    r[target] = feedback ? add32(next, rotated) : rotated;
+    target = target + 3 & 3;
+  }
+}
+function mdStyleDigest(message, initialState, transform6) {
+  const padded = padMd4Style(message);
+  const view = new DataView(padded.buffer);
+  const state = [...initialState];
+  const words2 = new Array(16).fill(0);
+  for (let offset = 0; offset < padded.length; offset += 64) {
+    for (let i2 = 0; i2 < 16; i2++) words2[i2] = view.getUint32(offset + i2 * 4, true);
+    transform6(state, words2);
+  }
+  const out = new Uint8Array(state.length * 4);
+  const outView = new DataView(out.buffer);
+  for (let i2 = 0; i2 < state.length; i2++) outView.setUint32(i2 * 4, state[i2], true);
+  return out;
+}
+
+// digest/md4.ts
+var INITIAL_STATE = [1732584193, 4023233417, 2562383102, 271733878];
+var K2 = 1518500249;
+var K3 = 1859775393;
+var f1 = (x, y, z) => x & y | ~x & z;
+var f2 = (x, y, z) => x & y | x & z | y & z;
+var f3 = (x, y, z) => x ^ y ^ z;
+function round(order, shifts, k) {
+  return order.map((word, i2) => [word, shifts[i2 % 4], k]);
+}
+var SEQUENTIAL = Array.from({ length: 16 }, (_, i2) => i2);
+var COLUMNS = Array.from({ length: 16 }, (_, i2) => i2 % 4 * 4 + (i2 >> 2));
+var BIT_REVERSED = [0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15];
+var ROUND1 = round(SEQUENTIAL, [3, 7, 11, 19], 0);
+var ROUND2 = round(COLUMNS, [3, 5, 9, 13], K2);
+var ROUND3 = round(BIT_REVERSED, [3, 9, 11, 15], K3);
+function transform2(state, x) {
+  const r = [...state];
+  applyRotatingRound(r, ROUND1, f1, x);
+  applyRotatingRound(r, ROUND2, f2, x);
+  applyRotatingRound(r, ROUND3, f3, x);
+  for (let i2 = 0; i2 < 4; i2++) state[i2] = add32(state[i2], r[i2]);
+}
+function md4(message) {
+  return mdStyleDigest(message, INITIAL_STATE, transform2);
+}
+
+// digest/md5.ts
+var INITIAL_STATE2 = [1732584193, 4023233417, 2562383102, 271733878];
+function f(x, y, z) {
+  return x & y | ~x & z;
+}
+function g(x, y, z) {
+  return x & z | y & ~z;
+}
+function h(x, y, z) {
+  return x ^ y ^ z;
+}
+function i(x, y, z) {
+  return y ^ (x | ~z);
+}
+var T = Array.from(
+  { length: 64 },
+  (_, index) => Math.floor(Math.abs(Math.sin(index + 1)) * 2 ** 32)
+);
+var SHIFTS = [
+  [7, 12, 17, 22],
+  [5, 9, 14, 20],
+  [4, 11, 16, 23],
+  [6, 10, 15, 21]
+];
+var WORD_INDEX = [
+  (idx) => idx,
+  (idx) => (5 * idx + 1) % 16,
+  (idx) => (3 * idx + 5) % 16,
+  (idx) => 7 * idx % 16
+];
+var ROUND_FNS = [f, g, h, i];
+function buildOps(round2) {
+  const shifts = SHIFTS[round2];
+  const wordIndex = WORD_INDEX[round2];
+  return Array.from({ length: 16 }, (_, idx) => {
+    const opNumber = round2 * 16 + idx;
+    return [wordIndex(idx), shifts[idx % 4], T[opNumber]];
+  });
+}
+var ROUNDS = [0, 1, 2, 3].map(buildOps);
+function transform3(state, x) {
+  const r = [...state];
+  for (let round2 = 0; round2 < 4; round2++) {
+    applyRotatingRound(r, ROUNDS[round2], ROUND_FNS[round2], x, true);
+  }
+  for (let idx = 0; idx < 4; idx++) {
+    state[idx] = add32(state[idx], r[idx]);
+  }
+}
+function md5(message) {
+  return mdStyleDigest(message, INITIAL_STATE2, transform3);
+}
+
+// digest/ripemd-functions.ts
+function f12(x, y, z) {
+  return x ^ y ^ z;
+}
+function f22(x, y, z) {
+  return x & y | ~x & z;
+}
+function f32(x, y, z) {
+  return (x | ~y) ^ z;
+}
+function f4(x, y, z) {
+  return z & x | ~z & y;
+}
+function f5(x, y, z) {
+  return x ^ (y | ~z);
+}
+
+// digest/ripemd128.ts
+var INITIAL_STATE3 = [1732584193, 4023233417, 2562383102, 271733878];
+var LEFT_ROUNDS = [
+  [
+    [0, 11, 0],
+    [1, 14, 0],
+    [2, 15, 0],
+    [3, 12, 0],
+    [4, 5, 0],
+    [5, 8, 0],
+    [6, 7, 0],
+    [7, 9, 0],
+    [8, 11, 0],
+    [9, 13, 0],
+    [10, 14, 0],
+    [11, 15, 0],
+    [12, 6, 0],
+    [13, 7, 0],
+    [14, 9, 0],
+    [15, 8, 0]
+  ],
+  [
+    [7, 7, 1518500249],
+    [4, 6, 1518500249],
+    [13, 8, 1518500249],
+    [1, 13, 1518500249],
+    [10, 11, 1518500249],
+    [6, 9, 1518500249],
+    [15, 7, 1518500249],
+    [3, 15, 1518500249],
+    [12, 7, 1518500249],
+    [0, 12, 1518500249],
+    [9, 15, 1518500249],
+    [5, 9, 1518500249],
+    [2, 11, 1518500249],
+    [14, 7, 1518500249],
+    [11, 13, 1518500249],
+    [8, 12, 1518500249]
+  ],
+  [
+    [3, 11, 1859775393],
+    [10, 13, 1859775393],
+    [14, 6, 1859775393],
+    [4, 7, 1859775393],
+    [9, 14, 1859775393],
+    [15, 9, 1859775393],
+    [8, 13, 1859775393],
+    [1, 15, 1859775393],
+    [2, 14, 1859775393],
+    [7, 8, 1859775393],
+    [0, 13, 1859775393],
+    [6, 6, 1859775393],
+    [13, 5, 1859775393],
+    [11, 12, 1859775393],
+    [5, 7, 1859775393],
+    [12, 5, 1859775393]
+  ],
+  [
+    [1, 11, 2400959708],
+    [9, 12, 2400959708],
+    [11, 14, 2400959708],
+    [10, 15, 2400959708],
+    [0, 14, 2400959708],
+    [8, 15, 2400959708],
+    [12, 9, 2400959708],
+    [4, 8, 2400959708],
+    [13, 9, 2400959708],
+    [3, 14, 2400959708],
+    [7, 5, 2400959708],
+    [15, 6, 2400959708],
+    [14, 8, 2400959708],
+    [5, 6, 2400959708],
+    [6, 5, 2400959708],
+    [2, 12, 2400959708]
+  ]
+];
+var RIGHT_ROUNDS = [
+  [
+    [5, 8, 1352829926],
+    [14, 9, 1352829926],
+    [7, 9, 1352829926],
+    [0, 11, 1352829926],
+    [9, 13, 1352829926],
+    [2, 15, 1352829926],
+    [11, 15, 1352829926],
+    [4, 5, 1352829926],
+    [13, 7, 1352829926],
+    [6, 7, 1352829926],
+    [15, 8, 1352829926],
+    [8, 11, 1352829926],
+    [1, 14, 1352829926],
+    [10, 14, 1352829926],
+    [3, 12, 1352829926],
+    [12, 6, 1352829926]
+  ],
+  [
+    [6, 9, 1548603684],
+    [11, 13, 1548603684],
+    [3, 15, 1548603684],
+    [7, 7, 1548603684],
+    [0, 12, 1548603684],
+    [13, 8, 1548603684],
+    [5, 9, 1548603684],
+    [10, 11, 1548603684],
+    [14, 7, 1548603684],
+    [15, 7, 1548603684],
+    [8, 12, 1548603684],
+    [12, 7, 1548603684],
+    [4, 6, 1548603684],
+    [9, 15, 1548603684],
+    [1, 13, 1548603684],
+    [2, 11, 1548603684]
+  ],
+  [
+    [15, 9, 1836072691],
+    [5, 7, 1836072691],
+    [1, 15, 1836072691],
+    [3, 11, 1836072691],
+    [7, 8, 1836072691],
+    [14, 6, 1836072691],
+    [6, 6, 1836072691],
+    [9, 14, 1836072691],
+    [11, 12, 1836072691],
+    [8, 13, 1836072691],
+    [12, 5, 1836072691],
+    [2, 14, 1836072691],
+    [10, 13, 1836072691],
+    [0, 13, 1836072691],
+    [4, 7, 1836072691],
+    [13, 5, 1836072691]
+  ],
+  [
+    [8, 15, 0],
+    [6, 5, 0],
+    [4, 8, 0],
+    [1, 11, 0],
+    [3, 14, 0],
+    [11, 14, 0],
+    [15, 6, 0],
+    [0, 14, 0],
+    [5, 6, 0],
+    [12, 9, 0],
+    [2, 12, 0],
+    [13, 9, 0],
+    [9, 12, 0],
+    [7, 5, 0],
+    [10, 15, 0],
+    [14, 8, 0]
+  ]
+];
+var LEFT_FNS = [f12, f22, f32, f4];
+var RIGHT_FNS = [f4, f32, f22, f12];
+function transform4(state, x) {
+  const left = [...state];
+  const right = [...state];
+  for (let round2 = 0; round2 < 4; round2++) {
+    applyRotatingRound(left, LEFT_ROUNDS[round2], LEFT_FNS[round2], x);
+    applyRotatingRound(right, RIGHT_ROUNDS[round2], RIGHT_FNS[round2], x);
+  }
+  const orig = state;
+  const newState = [
+    add32(right[3], left[2], orig[1]),
+    add32(orig[2], left[3], right[0]),
+    add32(orig[3], left[0], right[1]),
+    add32(orig[0], left[1], right[2])
+  ];
+  for (let i2 = 0; i2 < 4; i2++) {
+    state[i2] = newState[i2];
+  }
+}
+function ripemd128(message) {
+  return mdStyleDigest(message, INITIAL_STATE3, transform4);
+}
+
+// digest/ripemd160.ts
+var INITIAL_STATE4 = [1732584193, 4023233417, 2562383102, 271733878, 3285377520];
+var LEFT_ROUNDS2 = [
+  [
+    [0, 11, 0],
+    [1, 14, 0],
+    [2, 15, 0],
+    [3, 12, 0],
+    [4, 5, 0],
+    [5, 8, 0],
+    [6, 7, 0],
+    [7, 9, 0],
+    [8, 11, 0],
+    [9, 13, 0],
+    [10, 14, 0],
+    [11, 15, 0],
+    [12, 6, 0],
+    [13, 7, 0],
+    [14, 9, 0],
+    [15, 8, 0]
+  ],
+  [
+    [7, 7, 1518500249],
+    [4, 6, 1518500249],
+    [13, 8, 1518500249],
+    [1, 13, 1518500249],
+    [10, 11, 1518500249],
+    [6, 9, 1518500249],
+    [15, 7, 1518500249],
+    [3, 15, 1518500249],
+    [12, 7, 1518500249],
+    [0, 12, 1518500249],
+    [9, 15, 1518500249],
+    [5, 9, 1518500249],
+    [2, 11, 1518500249],
+    [14, 7, 1518500249],
+    [11, 13, 1518500249],
+    [8, 12, 1518500249]
+  ],
+  [
+    [3, 11, 1859775393],
+    [10, 13, 1859775393],
+    [14, 6, 1859775393],
+    [4, 7, 1859775393],
+    [9, 14, 1859775393],
+    [15, 9, 1859775393],
+    [8, 13, 1859775393],
+    [1, 15, 1859775393],
+    [2, 14, 1859775393],
+    [7, 8, 1859775393],
+    [0, 13, 1859775393],
+    [6, 6, 1859775393],
+    [13, 5, 1859775393],
+    [11, 12, 1859775393],
+    [5, 7, 1859775393],
+    [12, 5, 1859775393]
+  ],
+  [
+    [1, 11, 2400959708],
+    [9, 12, 2400959708],
+    [11, 14, 2400959708],
+    [10, 15, 2400959708],
+    [0, 14, 2400959708],
+    [8, 15, 2400959708],
+    [12, 9, 2400959708],
+    [4, 8, 2400959708],
+    [13, 9, 2400959708],
+    [3, 14, 2400959708],
+    [7, 5, 2400959708],
+    [15, 6, 2400959708],
+    [14, 8, 2400959708],
+    [5, 6, 2400959708],
+    [6, 5, 2400959708],
+    [2, 12, 2400959708]
+  ],
+  [
+    [4, 9, 2840853838],
+    [0, 15, 2840853838],
+    [5, 5, 2840853838],
+    [9, 11, 2840853838],
+    [7, 6, 2840853838],
+    [12, 8, 2840853838],
+    [2, 13, 2840853838],
+    [10, 12, 2840853838],
+    [14, 5, 2840853838],
+    [1, 12, 2840853838],
+    [3, 13, 2840853838],
+    [8, 14, 2840853838],
+    [11, 11, 2840853838],
+    [6, 8, 2840853838],
+    [15, 5, 2840853838],
+    [13, 6, 2840853838]
+  ]
+];
+var RIGHT_ROUNDS2 = [
+  [
+    [5, 8, 1352829926],
+    [14, 9, 1352829926],
+    [7, 9, 1352829926],
+    [0, 11, 1352829926],
+    [9, 13, 1352829926],
+    [2, 15, 1352829926],
+    [11, 15, 1352829926],
+    [4, 5, 1352829926],
+    [13, 7, 1352829926],
+    [6, 7, 1352829926],
+    [15, 8, 1352829926],
+    [8, 11, 1352829926],
+    [1, 14, 1352829926],
+    [10, 14, 1352829926],
+    [3, 12, 1352829926],
+    [12, 6, 1352829926]
+  ],
+  [
+    [6, 9, 1548603684],
+    [11, 13, 1548603684],
+    [3, 15, 1548603684],
+    [7, 7, 1548603684],
+    [0, 12, 1548603684],
+    [13, 8, 1548603684],
+    [5, 9, 1548603684],
+    [10, 11, 1548603684],
+    [14, 7, 1548603684],
+    [15, 7, 1548603684],
+    [8, 12, 1548603684],
+    [12, 7, 1548603684],
+    [4, 6, 1548603684],
+    [9, 15, 1548603684],
+    [1, 13, 1548603684],
+    [2, 11, 1548603684]
+  ],
+  [
+    [15, 9, 1836072691],
+    [5, 7, 1836072691],
+    [1, 15, 1836072691],
+    [3, 11, 1836072691],
+    [7, 8, 1836072691],
+    [14, 6, 1836072691],
+    [6, 6, 1836072691],
+    [9, 14, 1836072691],
+    [11, 12, 1836072691],
+    [8, 13, 1836072691],
+    [12, 5, 1836072691],
+    [2, 14, 1836072691],
+    [10, 13, 1836072691],
+    [0, 13, 1836072691],
+    [4, 7, 1836072691],
+    [13, 5, 1836072691]
+  ],
+  [
+    [8, 15, 2053994217],
+    [6, 5, 2053994217],
+    [4, 8, 2053994217],
+    [1, 11, 2053994217],
+    [3, 14, 2053994217],
+    [11, 14, 2053994217],
+    [15, 6, 2053994217],
+    [0, 14, 2053994217],
+    [5, 6, 2053994217],
+    [12, 9, 2053994217],
+    [2, 12, 2053994217],
+    [13, 9, 2053994217],
+    [9, 12, 2053994217],
+    [7, 5, 2053994217],
+    [10, 15, 2053994217],
+    [14, 8, 2053994217]
+  ],
+  [
+    [12, 8, 0],
+    [15, 5, 0],
+    [10, 12, 0],
+    [4, 9, 0],
+    [1, 12, 0],
+    [5, 5, 0],
+    [8, 14, 0],
+    [7, 6, 0],
+    [6, 8, 0],
+    [2, 13, 0],
+    [13, 6, 0],
+    [14, 5, 0],
+    [0, 15, 0],
+    [3, 13, 0],
+    [9, 11, 0],
+    [11, 11, 0]
+  ]
+];
+var LEFT_FNS2 = [f12, f22, f32, f4, f5];
+var RIGHT_FNS2 = [f5, f4, f32, f22, f12];
+function applyLane(r, ops, f6, x, startTarget) {
+  let target = startTarget;
+  for (const [k, s, addConst] of ops) {
+    const i1 = (target + 1) % 5;
+    const i2 = (target + 2) % 5;
+    const i3 = (target + 3) % 5;
+    const i4 = (target + 4) % 5;
+    const sum = r[target] + f6(r[i1], r[i2], r[i3]) + x[k] + addConst >>> 0;
+    const newTarget = (sum << s | sum >>> 32 - s) + r[i4] >>> 0;
+    const c = r[i2];
+    r[i2] = (c << 10 | c >>> 22) >>> 0;
+    r[target] = newTarget;
+    target = (target + 4) % 5;
+  }
+  return target;
+}
+function transform5(state, x) {
+  const left = [...state];
+  const right = [...state];
+  let leftTarget = 0;
+  let rightTarget = 0;
+  for (let round2 = 0; round2 < 5; round2++) {
+    leftTarget = applyLane(left, LEFT_ROUNDS2[round2], LEFT_FNS2[round2], x, leftTarget);
+    rightTarget = applyLane(right, RIGHT_ROUNDS2[round2], RIGHT_FNS2[round2], x, rightTarget);
+  }
+  const orig = state;
+  const newState = [
+    add32(right[3], left[2], orig[1]),
+    add32(orig[2], left[3], right[4]),
+    add32(orig[3], left[4], right[0]),
+    add32(orig[4], left[0], right[1]),
+    add32(orig[0], left[1], right[2])
+  ];
+  for (let i2 = 0; i2 < 5; i2++) {
+    state[i2] = newState[i2];
+  }
+}
+function ripemd160(message) {
+  return mdStyleDigest(message, INITIAL_STATE4, transform5);
+}
+
 // digest/sha256.ts
 var K = new Uint32Array([
   1116352408,
@@ -135,40 +975,40 @@ var IV = [
 ];
 var W = new Uint32Array(64);
 var rotr = (x, n) => x >>> n | x << 32 - n;
-function compress(h, view, offset) {
-  for (let i = 0; i < 16; i++) W[i] = view.getUint32(offset + i * 4);
-  for (let i = 16; i < 64; i++) {
-    const a2 = W[i - 15];
-    const b2 = W[i - 2];
+function compress(h2, view, offset) {
+  for (let i2 = 0; i2 < 16; i2++) W[i2] = view.getUint32(offset + i2 * 4);
+  for (let i2 = 16; i2 < 64; i2++) {
+    const a2 = W[i2 - 15];
+    const b2 = W[i2 - 2];
     const s0 = rotr(a2, 7) ^ rotr(a2, 18) ^ a2 >>> 3;
     const s1 = rotr(b2, 17) ^ rotr(b2, 19) ^ b2 >>> 10;
-    W[i] = W[i - 16] + s0 + W[i - 7] + s1 >>> 0;
+    W[i2] = W[i2 - 16] + s0 + W[i2 - 7] + s1 >>> 0;
   }
-  let a = h[0], b = h[1], c = h[2], d = h[3], e = h[4], f = h[5], g = h[6], k = h[7];
-  for (let i = 0; i < 64; i++) {
+  let a = h2[0], b = h2[1], c = h2[2], d = h2[3], e = h2[4], f6 = h2[5], g2 = h2[6], k = h2[7];
+  for (let i2 = 0; i2 < 64; i2++) {
     const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
-    const ch = e & f ^ ~e & g;
-    const t1 = k + S1 + ch + K[i] + W[i] >>> 0;
+    const ch = e & f6 ^ ~e & g2;
+    const t1 = k + S1 + ch + K[i2] + W[i2] >>> 0;
     const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
     const maj = a & b ^ a & c ^ b & c;
     const t2 = S0 + maj >>> 0;
-    k = g;
-    g = f;
-    f = e;
+    k = g2;
+    g2 = f6;
+    f6 = e;
     e = d + t1 >>> 0;
     d = c;
     c = b;
     b = a;
     a = t1 + t2 >>> 0;
   }
-  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] + k >>> 0;
+  h2[0] = h2[0] + a >>> 0;
+  h2[1] = h2[1] + b >>> 0;
+  h2[2] = h2[2] + c >>> 0;
+  h2[3] = h2[3] + d >>> 0;
+  h2[4] = h2[4] + e >>> 0;
+  h2[5] = h2[5] + f6 >>> 0;
+  h2[6] = h2[6] + g2 >>> 0;
+  h2[7] = h2[7] + k >>> 0;
 }
 function pad64(data) {
   const padded = new Uint8Array(Math.ceil((data.length + 9) / 64) * 64);
@@ -180,64 +1020,64 @@ function pad64(data) {
   view.setUint32(padded.length - 4, bits >>> 0);
   return view;
 }
-function wordsOut(h) {
-  const out = new Uint8Array(h.length * 4);
+function wordsOut(h2) {
+  const out = new Uint8Array(h2.length * 4);
   const view = new DataView(out.buffer);
-  for (let i = 0; i < h.length; i++) view.setUint32(i * 4, h[i]);
+  for (let i2 = 0; i2 < h2.length; i2++) view.setUint32(i2 * 4, h2[i2]);
   return out;
 }
 function sha256(data) {
-  const h = new Uint32Array(IV);
+  const h2 = new Uint32Array(IV);
   const view = pad64(data);
-  for (let offset = 0; offset < view.byteLength; offset += 64) compress(h, view, offset);
-  return wordsOut(h);
+  for (let offset = 0; offset < view.byteLength; offset += 64) compress(h2, view, offset);
+  return wordsOut(h2);
 }
 
 // digest/sha1.ts
 var W2 = new Uint32Array(80);
 var rotl = (x, n) => x << n | x >>> 32 - n;
-function compress2(h, view, offset) {
-  for (let i = 0; i < 16; i++) W2[i] = view.getUint32(offset + i * 4);
-  for (let i = 16; i < 80; i++) W2[i] = rotl(W2[i - 3] ^ W2[i - 8] ^ W2[i - 14] ^ W2[i - 16], 1);
-  let a = h[0], b = h[1], c = h[2], d = h[3], e = h[4];
-  for (let i = 0; i < 80; i++) {
-    let f;
+function compress2(h2, view, offset) {
+  for (let i2 = 0; i2 < 16; i2++) W2[i2] = view.getUint32(offset + i2 * 4);
+  for (let i2 = 16; i2 < 80; i2++) W2[i2] = rotl(W2[i2 - 3] ^ W2[i2 - 8] ^ W2[i2 - 14] ^ W2[i2 - 16], 1);
+  let a = h2[0], b = h2[1], c = h2[2], d = h2[3], e = h2[4];
+  for (let i2 = 0; i2 < 80; i2++) {
+    let f6;
     let k;
-    if (i < 20) {
-      f = b & c | ~b & d;
+    if (i2 < 20) {
+      f6 = b & c | ~b & d;
       k = 1518500249;
-    } else if (i < 40) {
-      f = b ^ c ^ d;
+    } else if (i2 < 40) {
+      f6 = b ^ c ^ d;
       k = 1859775393;
-    } else if (i < 60) {
-      f = b & c | b & d | c & d;
+    } else if (i2 < 60) {
+      f6 = b & c | b & d | c & d;
       k = 2400959708;
     } else {
-      f = b ^ c ^ d;
+      f6 = b ^ c ^ d;
       k = 3395469782;
     }
-    const t = rotl(a, 5) + f + e + k + W2[i] >>> 0;
+    const t = rotl(a, 5) + f6 + e + k + W2[i2] >>> 0;
     e = d;
     d = c;
     c = rotl(b, 30) >>> 0;
     b = a;
     a = t;
   }
-  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;
+  h2[0] = h2[0] + a >>> 0;
+  h2[1] = h2[1] + b >>> 0;
+  h2[2] = h2[2] + c >>> 0;
+  h2[3] = h2[3] + d >>> 0;
+  h2[4] = h2[4] + e >>> 0;
 }
 function sha1(data) {
-  const h = new Uint32Array([1732584193, 4023233417, 2562383102, 271733878, 3285377520]);
+  const h2 = new Uint32Array([1732584193, 4023233417, 2562383102, 271733878, 3285377520]);
   const view = pad64(data);
-  for (let offset = 0; offset < view.byteLength; offset += 64) compress2(h, view, offset);
-  return wordsOut(h);
+  for (let offset = 0; offset < view.byteLength; offset += 64) compress2(h2, view, offset);
+  return wordsOut(h2);
 }
 
 // digest/sha512.ts
-var K2 = new Uint32Array([
+var K4 = new Uint32Array([
   1116352408,
   3609767458,
   1899447441,
@@ -436,35 +1276,35 @@ var IV_384 = [
   3204075428
 ];
 var W3 = new Uint32Array(160);
-function compress3(h, data, offset) {
-  for (let i = 0; i < 32; i++) {
-    const o = offset + i * 4;
-    W3[i] = (data[o] << 24 | data[o + 1] << 16 | data[o + 2] << 8 | data[o + 3]) >>> 0;
+function compress3(h2, data, offset) {
+  for (let i2 = 0; i2 < 32; i2++) {
+    const o = offset + i2 * 4;
+    W3[i2] = (data[o] << 24 | data[o + 1] << 16 | data[o + 2] << 8 | data[o + 3]) >>> 0;
   }
-  for (let i = 16; i < 80; i++) {
-    const xh = W3[(i - 15) * 2];
-    const xl = W3[(i - 15) * 2 + 1];
+  for (let i2 = 16; i2 < 80; i2++) {
+    const xh = W3[(i2 - 15) * 2];
+    const xl = W3[(i2 - 15) * 2 + 1];
     const s0h = (xh >>> 1 | xl << 31) ^ (xh >>> 8 | xl << 24) ^ xh >>> 7;
     const s0l = (xl >>> 1 | xh << 31) ^ (xl >>> 8 | xh << 24) ^ (xl >>> 7 | xh << 25);
-    const yh = W3[(i - 2) * 2];
-    const yl = W3[(i - 2) * 2 + 1];
+    const yh = W3[(i2 - 2) * 2];
+    const yl = W3[(i2 - 2) * 2 + 1];
     const s1h = (yh >>> 19 | yl << 13) ^ (yl >>> 29 | yh << 3) ^ yh >>> 6;
     const s1l = (yl >>> 19 | yh << 13) ^ (yh >>> 29 | yl << 3) ^ (yl >>> 6 | yh << 26);
-    let lo = (s0l >>> 0) + (s1l >>> 0) + W3[(i - 7) * 2 + 1] + W3[(i - 16) * 2 + 1];
-    const hi = s0h + s1h + W3[(i - 7) * 2] + W3[(i - 16) * 2] + Math.floor(lo / 4294967296);
+    let lo = (s0l >>> 0) + (s1l >>> 0) + W3[(i2 - 7) * 2 + 1] + W3[(i2 - 16) * 2 + 1];
+    const hi = s0h + s1h + W3[(i2 - 7) * 2] + W3[(i2 - 16) * 2] + Math.floor(lo / 4294967296);
     lo >>>= 0;
-    W3[i * 2] = hi >>> 0;
-    W3[i * 2 + 1] = lo;
+    W3[i2 * 2] = hi >>> 0;
+    W3[i2 * 2 + 1] = lo;
   }
-  let ah = h[0], al = h[1], bh = h[2], bl = h[3], ch = h[4], cl = h[5], dh = h[6], dl = h[7];
-  let eh = h[8], el = h[9], fh = h[10], fl = h[11], gh = h[12], gl = h[13], hh = h[14], hl = h[15];
-  for (let i = 0; i < 80; i++) {
+  let ah = h2[0], al = h2[1], bh = h2[2], bl = h2[3], ch = h2[4], cl = h2[5], dh = h2[6], dl = h2[7];
+  let eh = h2[8], el = h2[9], fh = h2[10], fl = h2[11], gh = h2[12], gl = h2[13], hh = h2[14], hl = h2[15];
+  for (let i2 = 0; i2 < 80; i2++) {
     const S1h = (eh >>> 14 | el << 18) ^ (eh >>> 18 | el << 14) ^ (el >>> 9 | eh << 23);
     const S1l = (el >>> 14 | eh << 18) ^ (el >>> 18 | eh << 14) ^ (eh >>> 9 | el << 23);
     const chh = eh & fh ^ ~eh & gh;
     const chl = el & fl ^ ~el & gl;
-    let t1l = (hl >>> 0) + (S1l >>> 0) + (chl >>> 0) + K2[i * 2 + 1] + W3[i * 2 + 1];
-    const t1h = hh + S1h + chh + K2[i * 2] + W3[i * 2] + Math.floor(t1l / 4294967296);
+    let t1l = (hl >>> 0) + (S1l >>> 0) + (chl >>> 0) + K4[i2 * 2 + 1] + W3[i2 * 2 + 1];
+    const t1h = hh + S1h + chh + K4[i2 * 2] + W3[i2 * 2] + Math.floor(t1l / 4294967296);
     t1l >>>= 0;
     const S0h = (ah >>> 28 | al << 4) ^ (al >>> 2 | ah << 30) ^ (al >>> 7 | ah << 25);
     const S0l = (al >>> 28 | ah << 4) ^ (ah >>> 2 | al << 30) ^ (ah >>> 7 | al << 25);
@@ -492,10 +1332,10 @@ function compress3(h, data, offset) {
     ah = t1h + t2h + Math.floor(nl / 4294967296) >>> 0;
     al = nl >>> 0;
   }
-  const add = (i, xh, xl) => {
-    const lo = (h[i + 1] >>> 0) + (xl >>> 0);
-    h[i] = h[i] + xh + Math.floor(lo / 4294967296) >>> 0;
-    h[i + 1] = lo >>> 0;
+  const add = (i2, xh, xl) => {
+    const lo = (h2[i2 + 1] >>> 0) + (xl >>> 0);
+    h2[i2] = h2[i2] + xh + Math.floor(lo / 4294967296) >>> 0;
+    h2[i2 + 1] = lo >>> 0;
   };
   add(0, ah, al);
   add(2, bh, bl);
@@ -507,7 +1347,7 @@ function compress3(h, data, offset) {
   add(14, hh, hl);
 }
 function digest64(data, iv, bytes) {
-  const h = new Uint32Array(iv);
+  const h2 = new Uint32Array(iv);
   const padded = new Uint8Array(Math.ceil((data.length + 17) / 128) * 128);
   padded.set(data);
   padded[data.length] = 128;
@@ -515,25 +1355,407 @@ function digest64(data, iv, bytes) {
   const view = new DataView(padded.buffer);
   view.setUint32(padded.length - 8, Math.floor(bits / 4294967296));
   view.setUint32(padded.length - 4, bits >>> 0);
-  for (let offset = 0; offset < padded.length; offset += 128) compress3(h, padded, offset);
+  for (let offset = 0; offset < padded.length; offset += 128) compress3(h2, padded, offset);
   const out = new Uint8Array(bytes);
   const outView = new DataView(out.buffer);
-  for (let i = 0; i < bytes / 4; i++) outView.setUint32(i * 4, h[i]);
+  for (let i2 = 0; i2 < bytes / 4; i2++) outView.setUint32(i2 * 4, h2[i2]);
   return out;
 }
 var sha512 = (data) => digest64(data, IV_512, 64);
 var sha384 = (data) => digest64(data, IV_384, 48);
 
+// digest/whirlpool-sbox.ts
+var TABLE0 = [
+  0x18186018c07830d8n,
+  0x23238c2305af4626n,
+  0xc6c63fc67ef991b8n,
+  0xe8e887e8136fcdfbn,
+  0x878726874ca113cbn,
+  0xb8b8dab8a9626d11n,
+  0x0101040108050209n,
+  0x4f4f214f426e9e0dn,
+  0x3636d836adee6c9bn,
+  0xa6a6a2a6590451ffn,
+  0xd2d26fd2debdb90cn,
+  0xf5f5f3f5fb06f70en,
+  0x7979f979ef80f296n,
+  0x6f6fa16f5fcede30n,
+  0x91917e91fcef3f6dn,
+  0x52525552aa07a4f8n,
+  0x60609d6027fdc047n,
+  0xbcbccabc89766535n,
+  0x9b9b569baccd2b37n,
+  0x8e8e028e048c018an,
+  0xa3a3b6a371155bd2n,
+  0x0c0c300c603c186cn,
+  0x7b7bf17bff8af684n,
+  0x3535d435b5e16a80n,
+  0x1d1d741de8693af5n,
+  0xe0e0a7e05347ddb3n,
+  0xd7d77bd7f6acb321n,
+  0xc2c22fc25eed999cn,
+  0x2e2eb82e6d965c43n,
+  0x4b4b314b627a9629n,
+  0xfefedffea321e15dn,
+  0x575741578216aed5n,
+  0x15155415a8412abdn,
+  0x7777c1779fb6eee8n,
+  0x3737dc37a5eb6e92n,
+  0xe5e5b3e57b56d79en,
+  0x9f9f469f8cd92313n,
+  0xf0f0e7f0d317fd23n,
+  0x4a4a354a6a7f9420n,
+  0xdada4fda9e95a944n,
+  0x58587d58fa25b0a2n,
+  0xc9c903c906ca8fcfn,
+  0x2929a429558d527cn,
+  0x0a0a280a5022145an,
+  0xb1b1feb1e14f7f50n,
+  0xa0a0baa0691a5dc9n,
+  0x6b6bb16b7fdad614n,
+  0x85852e855cab17d9n,
+  0xbdbdcebd8173673cn,
+  0x5d5d695dd234ba8fn,
+  0x1010401080502090n,
+  0xf4f4f7f4f303f507n,
+  0xcbcb0bcb16c08bddn,
+  0x3e3ef83eedc67cd3n,
+  0x0505140528110a2dn,
+  0x676781671fe6ce78n,
+  0xe4e4b7e47353d597n,
+  0x27279c2725bb4e02n,
+  0x4141194132588273n,
+  0x8b8b168b2c9d0ba7n,
+  0xa7a7a6a7510153f6n,
+  0x7d7de97dcf94fab2n,
+  0x95956e95dcfb3749n,
+  0xd8d847d88e9fad56n,
+  0xfbfbcbfb8b30eb70n,
+  0xeeee9fee2371c1cdn,
+  0x7c7ced7cc791f8bbn,
+  0x6666856617e3cc71n,
+  0xdddd53dda68ea77bn,
+  0x17175c17b84b2eafn,
+  0x4747014702468e45n,
+  0x9e9e429e84dc211an,
+  0xcaca0fca1ec589d4n,
+  0x2d2db42d75995a58n,
+  0xbfbfc6bf9179632en,
+  0x07071c07381b0e3fn,
+  0xadad8ead012347acn,
+  0x5a5a755aea2fb4b0n,
+  0x838336836cb51befn,
+  0x3333cc3385ff66b6n,
+  0x636391633ff2c65cn,
+  0x02020802100a0412n,
+  0xaaaa92aa39384993n,
+  0x7171d971afa8e2den,
+  0xc8c807c80ecf8dc6n,
+  0x19196419c87d32d1n,
+  0x494939497270923bn,
+  0xd9d943d9869aaf5fn,
+  0xf2f2eff2c31df931n,
+  0xe3e3abe34b48dba8n,
+  0x5b5b715be22ab6b9n,
+  0x88881a8834920dbcn,
+  0x9a9a529aa4c8293en,
+  0x262698262dbe4c0bn,
+  0x3232c8328dfa64bfn,
+  0xb0b0fab0e94a7d59n,
+  0xe9e983e91b6acff2n,
+  0x0f0f3c0f78331e77n,
+  0xd5d573d5e6a6b733n,
+  0x80803a8074ba1df4n,
+  0xbebec2be997c6127n,
+  0xcdcd13cd26de87ebn,
+  0x3434d034bde46889n,
+  0x48483d487a759032n,
+  0xffffdbffab24e354n,
+  0x7a7af57af78ff48dn,
+  0x90907a90f4ea3d64n,
+  0x5f5f615fc23ebe9dn,
+  0x202080201da0403dn,
+  0x6868bd6867d5d00fn,
+  0x1a1a681ad07234can,
+  0xaeae82ae192c41b7n,
+  0xb4b4eab4c95e757dn,
+  0x54544d549a19a8cen,
+  0x93937693ece53b7fn,
+  0x222288220daa442fn,
+  0x64648d6407e9c863n,
+  0xf1f1e3f1db12ff2an,
+  0x7373d173bfa2e6ccn,
+  0x12124812905a2482n,
+  0x40401d403a5d807an,
+  0x0808200840281048n,
+  0xc3c32bc356e89b95n,
+  0xecec97ec337bc5dfn,
+  0xdbdb4bdb9690ab4dn,
+  0xa1a1bea1611f5fc0n,
+  0x8d8d0e8d1c830791n,
+  0x3d3df43df5c97ac8n,
+  0x97976697ccf1335bn,
+  0x0000000000000000n,
+  0xcfcf1bcf36d483f9n,
+  0x2b2bac2b4587566en,
+  0x7676c57697b3ece1n,
+  0x8282328264b019e6n,
+  0xd6d67fd6fea9b128n,
+  0x1b1b6c1bd87736c3n,
+  0xb5b5eeb5c15b7774n,
+  0xafaf86af112943ben,
+  0x6a6ab56a77dfd41dn,
+  0x50505d50ba0da0ean,
+  0x45450945124c8a57n,
+  0xf3f3ebf3cb18fb38n,
+  0x3030c0309df060adn,
+  0xefef9bef2b74c3c4n,
+  0x3f3ffc3fe5c37edan,
+  0x55554955921caac7n,
+  0xa2a2b2a2791059dbn,
+  0xeaea8fea0365c9e9n,
+  0x656589650fecca6an,
+  0xbabad2bab9686903n,
+  0x2f2fbc2f65935e4an,
+  0xc0c027c04ee79d8en,
+  0xdede5fdebe81a160n,
+  0x1c1c701ce06c38fcn,
+  0xfdfdd3fdbb2ee746n,
+  0x4d4d294d52649a1fn,
+  0x92927292e4e03976n,
+  0x7575c9758fbceafan,
+  0x06061806301e0c36n,
+  0x8a8a128a249809aen,
+  0xb2b2f2b2f940794bn,
+  0xe6e6bfe66359d185n,
+  0x0e0e380e70361c7en,
+  0x1f1f7c1ff8633ee7n,
+  0x6262956237f7c455n,
+  0xd4d477d4eea3b53an,
+  0xa8a89aa829324d81n,
+  0x96966296c4f43152n,
+  0xf9f9c3f99b3aef62n,
+  0xc5c533c566f697a3n,
+  0x2525942535b14a10n,
+  0x59597959f220b2abn,
+  0x84842a8454ae15d0n,
+  0x7272d572b7a7e4c5n,
+  0x3939e439d5dd72ecn,
+  0x4c4c2d4c5a619816n,
+  0x5e5e655eca3bbc94n,
+  0x7878fd78e785f09fn,
+  0x3838e038ddd870e5n,
+  0x8c8c0a8c14860598n,
+  0xd1d163d1c6b2bf17n,
+  0xa5a5aea5410b57e4n,
+  0xe2e2afe2434dd9a1n,
+  0x616199612ff8c24en,
+  0xb3b3f6b3f1457b42n,
+  0x2121842115a54234n,
+  0x9c9c4a9c94d62508n,
+  0x1e1e781ef0663ceen,
+  0x4343114322528661n,
+  0xc7c73bc776fc93b1n,
+  0xfcfcd7fcb32be54fn,
+  0x0404100420140824n,
+  0x51515951b208a2e3n,
+  0x99995e99bcc72f25n,
+  0x6d6da96d4fc4da22n,
+  0x0d0d340d68391a65n,
+  0xfafacffa8335e979n,
+  0xdfdf5bdfb684a369n,
+  0x7e7ee57ed79bfca9n,
+  0x242490243db44819n,
+  0x3b3bec3bc5d776fen,
+  0xabab96ab313d4b9an,
+  0xcece1fce3ed181f0n,
+  0x1111441188552299n,
+  0x8f8f068f0c890383n,
+  0x4e4e254e4a6b9c04n,
+  0xb7b7e6b7d1517366n,
+  0xebeb8beb0b60cbe0n,
+  0x3c3cf03cfdcc78c1n,
+  0x81813e817cbf1ffdn,
+  0x94946a94d4fe3540n,
+  0xf7f7fbf7eb0cf31cn,
+  0xb9b9deb9a1676f18n,
+  0x13134c13985f268bn,
+  0x2c2cb02c7d9c5851n,
+  0xd3d36bd3d6b8bb05n,
+  0xe7e7bbe76b5cd38cn,
+  0x6e6ea56e57cbdc39n,
+  0xc4c437c46ef395aan,
+  0x03030c03180f061bn,
+  0x565645568a13acdcn,
+  0x44440d441a49885en,
+  0x7f7fe17fdf9efea0n,
+  0xa9a99ea921374f88n,
+  0x2a2aa82a4d825467n,
+  0xbbbbd6bbb16d6b0an,
+  0xc1c123c146e29f87n,
+  0x53535153a202a6f1n,
+  0xdcdc57dcae8ba572n,
+  0x0b0b2c0b58271653n,
+  0x9d9d4e9d9cd32701n,
+  0x6c6cad6c47c1d82bn,
+  0x3131c43195f562a4n,
+  0x7474cd7487b9e8f3n,
+  0xf6f6fff6e309f115n,
+  0x464605460a438c4cn,
+  0xacac8aac092645a5n,
+  0x89891e893c970fb5n,
+  0x14145014a04428b4n,
+  0xe1e1a3e15b42dfban,
+  0x16165816b04e2ca6n,
+  0x3a3ae83acdd274f7n,
+  0x6969b9696fd0d206n,
+  0x09092409482d1241n,
+  0x7070dd70a7ade0d7n,
+  0xb6b6e2b6d954716fn,
+  0xd0d067d0ceb7bd1en,
+  0xeded93ed3b7ec7d6n,
+  0xcccc17cc2edb85e2n,
+  0x424215422a578468n,
+  0x98985a98b4c22d2cn,
+  0xa4a4aaa4490e55edn,
+  0x2828a0285d885075n,
+  0x5c5c6d5cda31b886n,
+  0xf8f8c7f8933fed6bn,
+  0x8686228644a411c2n
+];
+
+// digest/whirlpool-table.ts
+var WORD_MASK = (1n << 64n) - 1n;
+var LOW_MASK = 0xffffffffn;
+function rotateBytesRight(value, bytes) {
+  const bits = BigInt(bytes) * 8n;
+  return (value >> bits | value << 64n - bits) & WORD_MASK;
+}
+var TABLES_HI = new Uint32Array(8 * 256);
+var TABLES_LO = new Uint32Array(8 * 256);
+for (let t = 0; t < 8; t++) {
+  for (let x = 0; x < 256; x++) {
+    const value = t === 0 ? TABLE0[x] : rotateBytesRight(TABLE0[x], t);
+    TABLES_HI[t * 256 + x] = Number(value >> 32n);
+    TABLES_LO[t * 256 + x] = Number(value & LOW_MASK);
+  }
+}
+var ROUND_CONSTANTS = [
+  0x1823c6e887b8014fn,
+  0x36a6d2f5796f9152n,
+  0x60bc9b8ea30c7b35n,
+  0x1de0d7c22e4bfe57n,
+  0x157737e59ff04adan,
+  0x58c9290ab1a06b85n,
+  0xbd5d10f4cb3e0567n,
+  0xe427418ba77d95d8n,
+  0xfbee7c66dd17479en,
+  0xca2dbf07ad5a8333n
+];
+var ROUND_CONSTANTS_HI = Uint32Array.from(ROUND_CONSTANTS, (c) => Number(c >> 32n));
+var ROUND_CONSTANTS_LO = Uint32Array.from(ROUND_CONSTANTS, (c) => Number(c & LOW_MASK));
+
+// digest/whirlpool.ts
+var TABLES_HI2 = TABLES_HI;
+var TABLES_LO2 = TABLES_LO;
+var ROUND_CONSTANTS_HI2 = ROUND_CONSTANTS_HI;
+var ROUND_CONSTANTS_LO2 = ROUND_CONSTANTS_LO;
+var BLOCK_BYTES = 64;
+var WORDS = 8;
+var ROUNDS2 = 10;
+var words = () => ({ hi: new Uint32Array(WORDS), lo: new Uint32Array(WORDS) });
+function op(src, column, out) {
+  const { hi: h2, lo: l } = src;
+  const b0 = h2[column] >>> 24;
+  const b1 = h2[column + 7 & 7] >>> 16 & 255;
+  const b2 = h2[column + 6 & 7] >>> 8 & 255;
+  const b3 = h2[column + 5 & 7] & 255;
+  const b4 = l[column + 4 & 7] >>> 24;
+  const b5 = l[column + 3 & 7] >>> 16 & 255;
+  const b6 = l[column + 2 & 7] >>> 8 & 255;
+  const b7 = l[column + 1 & 7] & 255;
+  out.hi[column] = TABLES_HI2[b0] ^ TABLES_HI2[256 + b1] ^ TABLES_HI2[512 + b2] ^ TABLES_HI2[768 + b3] ^ TABLES_HI2[1024 + b4] ^ TABLES_HI2[1280 + b5] ^ TABLES_HI2[1536 + b6] ^ TABLES_HI2[1792 + b7];
+  out.lo[column] = TABLES_LO2[b0] ^ TABLES_LO2[256 + b1] ^ TABLES_LO2[512 + b2] ^ TABLES_LO2[768 + b3] ^ TABLES_LO2[1024 + b4] ^ TABLES_LO2[1280 + b5] ^ TABLES_LO2[1536 + b6] ^ TABLES_LO2[1792 + b7];
+}
+var scratch = { key: words(), state: words(), initial: words(), nextKey: words(), next: words() };
+function processBlock(hash, block) {
+  const { key, state, initial, nextKey, next } = scratch;
+  for (let i2 = 0; i2 < WORDS; i2++) {
+    initial.hi[i2] = block.hi[i2] ^ hash.hi[i2];
+    initial.lo[i2] = block.lo[i2] ^ hash.lo[i2];
+  }
+  key.hi.set(hash.hi);
+  key.lo.set(hash.lo);
+  state.hi.set(initial.hi);
+  state.lo.set(initial.lo);
+  for (let round2 = 0; round2 < ROUNDS2; round2++) {
+    for (let j = 0; j < WORDS; j++) op(key, j, nextKey);
+    nextKey.hi[0] = nextKey.hi[0] ^ ROUND_CONSTANTS_HI2[round2];
+    nextKey.lo[0] = nextKey.lo[0] ^ ROUND_CONSTANTS_LO2[round2];
+    for (let j = 0; j < WORDS; j++) {
+      op(state, j, next);
+      next.hi[j] = next.hi[j] ^ nextKey.hi[j];
+      next.lo[j] = next.lo[j] ^ nextKey.lo[j];
+    }
+    key.hi.set(nextKey.hi);
+    key.lo.set(nextKey.lo);
+    state.hi.set(next.hi);
+    state.lo.set(next.lo);
+  }
+  for (let i2 = 0; i2 < WORDS; i2++) {
+    hash.hi[i2] = initial.hi[i2] ^ state.hi[i2];
+    hash.lo[i2] = initial.lo[i2] ^ state.lo[i2];
+  }
+}
+function pad(message) {
+  let total = message.length + 1;
+  while (total % BLOCK_BYTES !== 32) {
+    total++;
+  }
+  total += 32;
+  const padded = new Uint8Array(total);
+  padded.set(message);
+  padded[message.length] = 128;
+  new DataView(padded.buffer).setBigUint64(total - 8, BigInt(message.length) * 8n, false);
+  return padded;
+}
+function whirlpool(message) {
+  const padded = pad(message);
+  const view = new DataView(padded.buffer);
+  const hash = words();
+  const block = words();
+  for (let offset = 0; offset < padded.length; offset += BLOCK_BYTES) {
+    for (let i2 = 0; i2 < WORDS; i2++) {
+      block.hi[i2] = view.getUint32(offset + i2 * 8, false);
+      block.lo[i2] = view.getUint32(offset + i2 * 8 + 4, false);
+    }
+    processBlock(hash, block);
+  }
+  const out = new Uint8Array(BLOCK_BYTES);
+  const outView = new DataView(out.buffer);
+  for (let i2 = 0; i2 < WORDS; i2++) {
+    outView.setUint32(i2 * 8, hash.hi[i2], false);
+    outView.setUint32(i2 * 8 + 4, hash.lo[i2], false);
+  }
+  return out;
+}
+
 // digest/digest.ts
 var DIGESTS = {
   "SHA-1": sha1,
   "SHA-256": sha256,
   "SHA-384": sha384,
-  "SHA-512": sha512
+  "SHA-512": sha512,
+  MD2: md2,
+  MD4: md4,
+  MD5: md5,
+  "RIPEMD-128": ripemd128,
+  "RIPEMD-160": ripemd160,
+  WHIRLPOOL: whirlpool
 };
 function digestFunction(name) {
   const canonical = normalizeDigestAlgorithmName(name);
-  return canonical && canonical in DIGESTS ? DIGESTS[canonical] : void 0;
+  return canonical && DIGESTS[canonical];
 }
 function digestSync(name, data) {
   return digestFunction(name)?.(data);
@@ -542,20 +1764,20 @@ function digestSync(name, data) {
 // digest/password-hash.ts
 var MAX_SPIN_COUNT = 1e7;
 var validSpinCount = (spinCount) => spinCount === void 0 || Number.isInteger(spinCount) && spinCount >= 0 && spinCount <= MAX_SPIN_COUNT;
-function spin(password, salt, spinCount, digest) {
+function spinPasswordHash(password, salt, spinCount, digest) {
   const input = new Uint8Array(salt.length + password.length * 2);
   input.set(salt);
-  for (let i = 0; i < password.length; i++) {
-    const code = password.charCodeAt(i);
-    input[salt.length + i * 2] = code & 255;
-    input[salt.length + i * 2 + 1] = code >> 8;
+  for (let i2 = 0; i2 < password.length; i2++) {
+    const code = password.charCodeAt(i2);
+    input[salt.length + i2 * 2] = code & 255;
+    input[salt.length + i2 * 2 + 1] = code >> 8;
   }
   let value = digest(input);
   const buffer = new Uint8Array(value.length + 4);
   const view = new DataView(buffer.buffer);
-  for (let i = 0; i < spinCount; i++) {
+  for (let i2 = 0; i2 < spinCount; i2++) {
     buffer.set(value);
-    view.setUint32(value.length, i, true);
+    view.setUint32(value.length, i2, true);
     value = digest(buffer);
   }
   return value;
@@ -564,7 +1786,7 @@ function hashBytes(password, { algorithmName, saltValue, spinCount }) {
   const digest = digestFunction(algorithmName);
   const salt = decodeBase64(saltValue);
   if (!digest || !salt || !validSpinCount(spinCount)) return void 0;
-  return spin(password, salt, spinCount ?? 0, digest);
+  return spinPasswordHash(password, salt, spinCount ?? 0, digest);
 }
 function hashPassword(password, options) {
   const bytes = hashBytes(password, options);
@@ -576,7 +1798,7 @@ function verifyPasswordHash(password, hash) {
   const actual = expected && hashBytes(password, hash);
   if (!expected || !actual || actual.length !== expected.length) return false;
   let difference = 0;
-  for (let i = 0; i < actual.length; i++) difference |= actual[i] ^ expected[i];
+  for (let i2 = 0; i2 < actual.length; i2++) difference |= actual[i2] ^ expected[i2];
   return difference === 0;
 }
 
@@ -586,9 +1808,16 @@ exports.digestFunction = digestFunction;
 exports.digestSync = digestSync;
 exports.encodeBase64 = encodeBase64;
 exports.hashPassword = hashPassword;
+exports.md2 = md2;
+exports.md4 = md4;
+exports.md5 = md5;
 exports.normalizeDigestAlgorithmName = normalizeDigestAlgorithmName;
+exports.ripemd128 = ripemd128;
+exports.ripemd160 = ripemd160;
 exports.sha1 = sha1;
 exports.sha256 = sha256;
 exports.sha384 = sha384;
 exports.sha512 = sha512;
+exports.spinPasswordHash = spinPasswordHash;
 exports.verifyPasswordHash = verifyPasswordHash;
+exports.whirlpool = whirlpool;