ooxml-core 1.0.0 → 1.1.0

package/dist/crypto/index.mjs

@@ -23,8 +23,8 @@ function parseOle2(buffer) {
   if (data.length < 512) {
     throw new Ole2ParseError("Truncated OLE2 compound file header");
   }
-  for (let i = 0; i < OLE_MAGIC.length; i++) {
-    if (data[i] !== OLE_MAGIC[i]) {
+  for (let i2 = 0; i2 < OLE_MAGIC.length; i2++) {
+    if (data[i2] !== OLE_MAGIC[i2]) {
       throw new Ole2ParseError("Not a valid OLE2 compound file");
     }
   }
@@ -66,8 +66,8 @@ function parseOle2(buffer) {
     return data.subarray(offset, offset + sectorSize);
   }
   const fatSectors = [];
-  for (let i = 0; i < 109 && fatSectors.length < totalFATSectors; i++) {
-    const sector = view.getUint32(76 + i * 4, true);
+  for (let i2 = 0; i2 < 109 && fatSectors.length < totalFATSectors; i2++) {
+    const sector = view.getUint32(76 + i2 * 4, true);
     if (sector <= MAXREGSECT) {
       fatSectors.push(sector);
     }
@@ -81,8 +81,8 @@ function parseOle2(buffer) {
     const difatData = readSector(difatSector);
     const difatView = new DataView(difatData.buffer, difatData.byteOffset, difatData.byteLength);
     const entriesPerSector = (sectorSize - 4) / 4;
-    for (let i = 0; i < entriesPerSector && fatSectors.length < totalFATSectors; i++) {
-      const sector = difatView.getUint32(i * 4, true);
+    for (let i2 = 0; i2 < entriesPerSector && fatSectors.length < totalFATSectors; i2++) {
+      const sector = difatView.getUint32(i2 * 4, true);
       if (sector <= MAXREGSECT) {
         fatSectors.push(sector);
       }
@@ -96,8 +96,8 @@ function parseOle2(buffer) {
   for (const fatSector of fatSectors) {
     const fatData = readSector(fatSector);
     const fatView = new DataView(fatData.buffer, fatData.byteOffset, fatData.byteLength);
-    for (let i = 0; i < sectorSize / 4 && fatEntries.length < sectorCount; i++) {
-      fatEntries.push(fatView.getUint32(i * 4, true));
+    for (let i2 = 0; i2 < sectorSize / 4 && fatEntries.length < sectorCount; i2++) {
+      fatEntries.push(fatView.getUint32(i2 * 4, true));
     }
   }
   function readSectorChain(startSector) {
@@ -138,8 +138,8 @@ function parseOle2(buffer) {
   const dirRaw = readSectorChain(firstDirectorySector);
   const numEntries = Math.floor(dirRaw.length / DIR_ENTRY_SIZE);
   const entries = [];
-  for (let i = 0; i < numEntries; i++) {
-    const entryOffset = i * DIR_ENTRY_SIZE;
+  for (let i2 = 0; i2 < numEntries; i2++) {
+    const entryOffset = i2 * DIR_ENTRY_SIZE;
     const entryView = new DataView(dirRaw.buffer, dirRaw.byteOffset + entryOffset, DIR_ENTRY_SIZE);
     const nameLen = entryView.getUint16(64, true);
     const objectType = entryView.getUint8(66);
@@ -195,8 +195,8 @@ function parseOle2(buffer) {
     }
     const miniFatView = new DataView(miniFatRaw.buffer, miniFatRaw.byteOffset, miniFatRaw.byteLength);
     const miniCapacity = Math.floor((miniStreamData?.length ?? 0) / miniSectorSize);
-    for (let i = 0; i < miniFatRaw.length / 4 && i < miniCapacity; i++) {
-      miniFatEntries.push(miniFatView.getUint32(i * 4, true));
+    for (let i2 = 0; i2 < miniFatRaw.length / 4 && i2 < miniCapacity; i2++) {
+      miniFatEntries.push(miniFatView.getUint32(i2 * 4, true));
     }
   }
   function readMiniStream(startSector, size) {
@@ -251,7 +251,7 @@ function randomBytes(length) {
   const cryptoObj = globalThis.crypto;
   if (cryptoObj?.getRandomValues) return cryptoObj.getRandomValues(new Uint8Array(length));
   const bytes = new Uint8Array(length);
-  for (let i = 0; i < length; i++) bytes[i] = Math.floor(Math.random() * 256);
+  for (let i2 = 0; i2 < length; i2++) bytes[i2] = Math.floor(Math.random() * 256);
   return bytes;
 }
 function randomHex(length) {
@@ -278,10 +278,10 @@ function getCrypto() {
 }
 function encodePasswordUtf16LE(password) {
   const buf = new Uint8Array(password.length * 2);
-  for (let i = 0; i < password.length; i++) {
-    const code = password.charCodeAt(i);
-    buf[i * 2] = code & 255;
-    buf[i * 2 + 1] = code >> 8 & 255;
+  for (let i2 = 0; i2 < password.length; i2++) {
+    const code = password.charCodeAt(i2);
+    buf[i2 * 2] = code & 255;
+    buf[i2 * 2 + 1] = code >> 8 & 255;
   }
   return buf;
 }
@@ -307,15 +307,15 @@ function uint32LE(value) {
 function base64Decode(str) {
   const binary = atob(str);
   const bytes = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++) {
-    bytes[i] = binary.charCodeAt(i);
+  for (let i2 = 0; i2 < binary.length; i2++) {
+    bytes[i2] = binary.charCodeAt(i2);
   }
   return bytes;
 }
 function base64Encode(bytes) {
   let binary = "";
-  for (let i = 0; i < bytes.length; i++) {
-    binary += String.fromCharCode(bytes[i]);
+  for (let i2 = 0; i2 < bytes.length; i2++) {
+    binary += String.fromCharCode(bytes[i2]);
   }
   return btoa(binary);
 }
@@ -462,6 +462,846 @@ function normalizeDigestAlgorithmName(name) {
   return Object.hasOwn(CANONICAL_BY_LOOKUP_KEY, key) ? CANONICAL_BY_LOOKUP_KEY[key] : void 0;
 }
 
+// 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,
@@ -541,40 +1381,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);
@@ -586,64 +1426,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,
@@ -842,35 +1682,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;
-  }
-  for (let i = 16; i < 80; i++) {
-    const xh = W3[(i - 15) * 2];
-    const xl = W3[(i - 15) * 2 + 1];
+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 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);
@@ -898,10 +1738,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);
@@ -913,7 +1753,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;
@@ -921,25 +1761,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(hash2, block) {
+  const { key, state, initial, nextKey, next } = scratch;
+  for (let i2 = 0; i2 < WORDS; i2++) {
+    initial.hi[i2] = block.hi[i2] ^ hash2.hi[i2];
+    initial.lo[i2] = block.lo[i2] ^ hash2.lo[i2];
+  }
+  key.hi.set(hash2.hi);
+  key.lo.set(hash2.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++) {
+    hash2.hi[i2] = initial.hi[i2] ^ state.hi[i2];
+    hash2.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 hash2 = 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(hash2, block);
+  }
+  const out = new Uint8Array(BLOCK_BYTES);
+  const outView = new DataView(out.buffer);
+  for (let i2 = 0; i2 < WORDS; i2++) {
+    outView.setUint32(i2 * 8, hash2.hi[i2], false);
+    outView.setUint32(i2 * 8 + 4, hash2.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];
 }
 
 // crypto/key-derivation.ts
@@ -958,39 +2180,39 @@ async function spinPassword(password, salt, spinCount, hashAlgorithm) {
   const passwordBytes = encodePasswordUtf16LE(password);
   const digest = digestFunction(hashAlgorithm);
   if (digest) {
-    let h2 = digest(concatArrays(salt, passwordBytes));
-    const buffer = new Uint8Array(4 + h2.length);
+    let h3 = digest(concatArrays(salt, passwordBytes));
+    const buffer = new Uint8Array(4 + h3.length);
     const view = new DataView(buffer.buffer);
-    for (let i = 0; i < spinCount; i++) {
-      view.setUint32(0, i, true);
-      buffer.set(h2, 4);
-      h2 = digest(buffer);
+    for (let i2 = 0; i2 < spinCount; i2++) {
+      view.setUint32(0, i2, true);
+      buffer.set(h3, 4);
+      h3 = digest(buffer);
     }
-    return h2;
+    return h3;
   }
-  let h = await hash(hashAlgorithm, concatArrays(salt, passwordBytes));
-  for (let i = 0; i < spinCount; i++) {
-    h = await hash(hashAlgorithm, concatArrays(uint32LE(i), h));
+  let h2 = await hash(hashAlgorithm, concatArrays(salt, passwordBytes));
+  for (let i2 = 0; i2 < spinCount; i2++) {
+    h2 = await hash(hashAlgorithm, concatArrays(uint32LE(i2), h2));
   }
-  return h;
+  return h2;
 }
-async function extendKey(h, hashAlgorithm, keyLength) {
-  const pad = async (value) => {
+async function extendKey(h2, hashAlgorithm, keyLength) {
+  const pad2 = async (value) => {
     const input = new Uint8Array(64).fill(value);
-    for (let i = 0; i < h.length && i < 64; i++) input[i] = h[i] ^ value;
+    for (let i2 = 0; i2 < h2.length && i2 < 64; i2++) input[i2] = h2[i2] ^ value;
     return hash(hashAlgorithm, input);
   };
-  const x3 = concatArrays(await pad(54), await pad(92));
+  const x3 = concatArrays(await pad2(54), await pad2(92));
   return x3.subarray(0, keyLength);
 }
 function computeAgileKeyBase(password, salt, spinCount, hashAlgorithm) {
   return spinPassword(password, salt, spinCount, hashAlgorithm);
 }
 async function deriveAgileKeyFromBase(base, hashAlgorithm, blockKey, keyBits, hashSize) {
-  const h = await hash(hashAlgorithm, concatArrays(base, blockKey));
+  const h2 = await hash(hashAlgorithm, concatArrays(base, blockKey));
   const keyLength = keyBits / 8;
-  if (hashSize >= keyLength) return h.subarray(0, keyLength);
-  return extendKey(h, hashAlgorithm, keyLength);
+  if (hashSize >= keyLength) return h2.subarray(0, keyLength);
+  return extendKey(h2, hashAlgorithm, keyLength);
 }
 async function deriveAgileKey(password, salt, spinCount, hashAlgorithm, blockKey, keyBits, hashSize) {
   const base = await computeAgileKeyBase(password, salt, spinCount, hashAlgorithm);
@@ -1000,18 +2222,18 @@ function computeStandardKeyBase(password, salt) {
   return spinPassword(password, salt, 5e4, "SHA-1");
 }
 async function deriveStandardKeyFromBase(base, keySize, blockNumber = 0) {
-  const h = await hash("SHA-1", concatArrays(base, uint32LE(blockNumber)));
-  return extendKey(h, "SHA-1", keySize / 8);
+  const h2 = await hash("SHA-1", concatArrays(base, uint32LE(blockNumber)));
+  return extendKey(h2, "SHA-1", keySize / 8);
 }
 async function deriveStandardKey(password, salt, keySize, _algIdHash, blockNumber = 0) {
   const base = await computeStandardKeyBase(password, salt);
   return deriveStandardKeyFromBase(base, keySize, blockNumber);
 }
 async function generateIV(hashAlgorithm, salt, blockKey, blockSize) {
-  const h = await hash(hashAlgorithm, concatArrays(salt, blockKey));
-  if (h.length >= blockSize) return h.subarray(0, blockSize);
+  const h2 = await hash(hashAlgorithm, concatArrays(salt, blockKey));
+  if (h2.length >= blockSize) return h2.subarray(0, blockSize);
   const padded = new Uint8Array(blockSize).fill(54);
-  padded.set(h);
+  padded.set(h2);
   return padded;
 }
 
@@ -1033,7 +2255,7 @@ async function verifyAgilePassword(info, password) {
   const computedHash = await hash(pke.hashAlgorithm, verifierHashInput.subarray(0, pke.saltSize));
   if (computedHash.length < pke.hashSize || verifierHashValue.length < pke.hashSize) return null;
   let difference = 0;
-  for (let i = 0; i < pke.hashSize; i++) difference |= verifierHashValue[i] ^ computedHash[i];
+  for (let i2 = 0; i2 < pke.hashSize; i2++) difference |= verifierHashValue[i2] ^ computedHash[i2];
   if (difference !== 0) return null;
   const decryptedKey = await aesCbcDecryptRaw(
     await blockKey(BLOCK_KEYS.encryptedKeyValue),
@@ -1054,8 +2276,8 @@ async function verifyStandardPassword(info, password) {
   const computedHash = await hash("SHA-1", decryptedVerifier);
   const hashSize = info.verifier.verifierHashSize;
   let match = true;
-  for (let i = 0; i < Math.min(hashSize, 20); i++) {
-    if (computedHash[i] !== decryptedHash[i]) {
+  for (let i2 = 0; i2 < Math.min(hashSize, 20); i2++) {
+    if (computedHash[i2] !== decryptedHash[i2]) {
       match = false;
       break;
     }
@@ -1096,8 +2318,8 @@ async function verifyAgileDataIntegrity(info, key, encryptedPackage) {
   if (computedHmac.length < keyData.hashSize) {
     match = false;
   } else {
-    for (let i = 0; i < keyData.hashSize; i++) {
-      if (computedHmac[i] !== expectedHmac[i]) {
+    for (let i2 = 0; i2 < keyData.hashSize; i2++) {
+      if (computedHmac[i2] !== expectedHmac[i2]) {
         match = false;
         break;
       }
@@ -1205,8 +2427,8 @@ function compareDirEntryNames(a, b) {
   if (a.length !== b.length) {
     return a.length - b.length;
   }
-  for (let i = 0; i < ua.length; i++) {
-    const diff = ua.charCodeAt(i) - ub.charCodeAt(i);
+  for (let i2 = 0; i2 < ua.length; i2++) {
+    const diff = ua.charCodeAt(i2) - ub.charCodeAt(i2);
     if (diff !== 0) {
       return diff;
     }
@@ -1215,9 +2437,9 @@ function compareDirEntryNames(a, b) {
 }
 function encodeName(name) {
   const bytes = new Uint8Array((name.length + 1) * 2);
-  for (let i = 0; i < name.length; i++) {
-    bytes[i * 2] = name.charCodeAt(i) & 255;
-    bytes[i * 2 + 1] = name.charCodeAt(i) >> 8 & 255;
+  for (let i2 = 0; i2 < name.length; i2++) {
+    bytes[i2 * 2] = name.charCodeAt(i2) & 255;
+    bytes[i2 * 2 + 1] = name.charCodeAt(i2) >> 8 & 255;
   }
   return bytes;
 }
@@ -1240,21 +2462,21 @@ function buildDirectoryTree(entryCount) {
   return { root: build(1, entryCount - 1, 0), links };
 }
 function writeFatChain(fat, chain) {
-  for (let i = 0; i < chain.sectors.length; i++) {
-    fat[chain.sectors[i]] = i < chain.sectors.length - 1 ? chain.sectors[i + 1] : ENDOFCHAIN;
+  for (let i2 = 0; i2 < chain.sectors.length; i2++) {
+    fat[chain.sectors[i2]] = i2 < chain.sectors.length - 1 ? chain.sectors[i2 + 1] : ENDOFCHAIN;
   }
 }
 function writeFatRun(fat, firstSector, count) {
-  for (let i = 0; i < count; i++) {
-    const sector = firstSector + i;
-    fat[sector] = i < count - 1 ? sector + 1 : ENDOFCHAIN;
+  for (let i2 = 0; i2 < count; i2++) {
+    const sector = firstSector + i2;
+    fat[sector] = i2 < count - 1 ? sector + 1 : ENDOFCHAIN;
   }
 }
 function writeInt32Sectors(outBytes, int32Data, firstSector, numSectors, sectorSize) {
   const entriesPerSector = sectorSize / 4;
-  for (let i = 0; i < numSectors; i++) {
-    const sectorOff = (firstSector + i + 1) * sectorSize;
-    const start = i * entriesPerSector;
+  for (let i2 = 0; i2 < numSectors; i2++) {
+    const sectorOff = (firstSector + i2 + 1) * sectorSize;
+    const start = i2 * entriesPerSector;
     const end = start + entriesPerSector;
     const chunk = int32Data.subarray(start, end);
     const chunkBytes = new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
@@ -1280,11 +2502,11 @@ function writeHeader(outView, outBytes, params) {
   const numDIFATSectors = params.numDIFATSectors ?? 0;
   outView.setUint32(68, numDIFATSectors > 0 ? params.firstDIFATSector ?? ENDOFCHAIN : ENDOFCHAIN, true);
   outView.setUint32(72, numDIFATSectors, true);
-  for (let i = 0; i < HEADER_DIFAT_ENTRIES; i++) {
-    if (i < params.numFATSectors) {
-      outView.setUint32(76 + i * 4, params.firstFATSector + i, true);
+  for (let i2 = 0; i2 < HEADER_DIFAT_ENTRIES; i2++) {
+    if (i2 < params.numFATSectors) {
+      outView.setUint32(76 + i2 * 4, params.firstFATSector + i2, true);
     } else {
-      outView.setUint32(76 + i * 4, FREESECT, true);
+      outView.setUint32(76 + i2 * 4, FREESECT, true);
     }
   }
 }
@@ -1321,24 +2543,24 @@ function serializeDirectoryEntries(dirEntries, numDirSectors, sectorSize) {
   const dirData = new Uint8Array(numDirSectors * sectorSize);
   const dirView = new DataView(dirData.buffer);
   const tree = buildDirectoryTree(dirEntries.length);
-  for (let i = 0; i < dirEntries.length; i++) {
-    const entry = dirEntries[i];
-    const entryOffset = i * DIR_ENTRY_SIZE;
+  for (let i2 = 0; i2 < dirEntries.length; i2++) {
+    const entry = dirEntries[i2];
+    const entryOffset = i2 * DIR_ENTRY_SIZE;
     const nameBytes = encodeName(entry.name);
     dirData.set(nameBytes.subarray(0, Math.min(nameBytes.length, 64)), entryOffset);
     dirView.setUint16(entryOffset + 64, Math.min((entry.name.length + 1) * 2, 64), true);
     dirData[entryOffset + 66] = entry.type;
-    dirData[entryOffset + 67] = i === 0 ? 1 : tree.links.get(i).color;
+    dirData[entryOffset + 67] = i2 === 0 ? 1 : tree.links.get(i2).color;
     if (entry.clsid) {
       dirData.set(entry.clsid.subarray(0, 16), entryOffset + 80);
     }
-    if (i === 0) {
+    if (i2 === 0) {
       dirView.setUint32(entryOffset + 68, 4294967295, true);
       dirView.setUint32(entryOffset + 72, 4294967295, true);
       dirView.setUint32(entryOffset + 76, tree.root, true);
     } else {
-      dirView.setUint32(entryOffset + 68, tree.links.get(i).left, true);
-      dirView.setUint32(entryOffset + 72, tree.links.get(i).right, true);
+      dirView.setUint32(entryOffset + 68, tree.links.get(i2).left, true);
+      dirView.setUint32(entryOffset + 72, tree.links.get(i2).right, true);
       dirView.setUint32(entryOffset + 76, 4294967295, true);
     }
     dirView.setUint32(entryOffset + 116, entry.startSector, true);
@@ -1347,9 +2569,9 @@ function serializeDirectoryEntries(dirEntries, numDirSectors, sectorSize) {
   return dirData;
 }
 function writeStreamSectors(outBytes, streamData, chain, sectorSize) {
-  for (let i = 0; i < chain.sectors.length; i++) {
-    const sectorOffset = (chain.sectors[i] + 1) * sectorSize;
-    const srcOffset = i * sectorSize;
+  for (let i2 = 0; i2 < chain.sectors.length; i2++) {
+    const sectorOffset = (chain.sectors[i2] + 1) * sectorSize;
+    const srcOffset = i2 * sectorSize;
     const srcEnd = Math.min(srcOffset + sectorSize, streamData.length);
     outBytes.set(streamData.subarray(srcOffset, srcEnd), sectorOffset);
   }
@@ -1360,15 +2582,15 @@ function buildOle2(streams2, rootClsid, miniStreamCutoff = 4096) {
   const sectorSize = 512;
   const miniSectorSize = 64;
   const names = [...streams2.keys()].sort(compareDirEntryNames);
-  for (let i = 0; i < names.length; i++) {
-    const name = names[i];
+  for (let i2 = 0; i2 < names.length; i2++) {
+    const name = names[i2];
     if (name.toUpperCase().length !== name.length) {
       throw new Error("CFB stream names with expanding uppercase mappings are unsupported");
     }
     if (!name.length || name.length > 31 || /[\x00\\/:!]/.test(name)) {
       throw new Error("CFB stream names must be 1-31 UTF-16 code units without NUL, \\, /, :, or !");
     }
-    if (i > 0 && compareDirEntryNames(names[i - 1], name) === 0) {
+    if (i2 > 0 && compareDirEntryNames(names[i2 - 1], name) === 0) {
       throw new Error("Duplicate CFB stream names");
     }
   }
@@ -1386,7 +2608,7 @@ function buildOle2(streams2, rootClsid, miniStreamCutoff = 4096) {
   for (const stream of regularStreams) {
     const numSectors = Math.ceil(stream.data.length / sectorSize);
     const sectors = [];
-    for (let i = 0; i < numSectors; i++) {
+    for (let i2 = 0; i2 < numSectors; i2++) {
       sectors.push(nextSector++);
     }
     fatChains.set(stream.name, { start: sectors[0] ?? ENDOFCHAIN, sectors });
@@ -1404,9 +2626,9 @@ function buildOle2(streams2, rootClsid, miniStreamCutoff = 4096) {
     for (const stream of miniStreams) {
       const numMiniSectors = Math.ceil(stream.data.length / miniSectorSize);
       const miniSectors = [];
-      for (let i = 0; i < numMiniSectors; i++) {
+      for (let i2 = 0; i2 < numMiniSectors; i2++) {
         miniSectors.push(nextMiniSector++);
-        const srcOffset = i * miniSectorSize;
+        const srcOffset = i2 * miniSectorSize;
         const srcEnd = Math.min(srcOffset + miniSectorSize, stream.data.length);
         miniStreamContainer.set(stream.data.subarray(srcOffset, srcEnd), miniOffset);
         miniOffset += miniSectorSize;
@@ -1422,7 +2644,7 @@ function buildOle2(streams2, rootClsid, miniStreamCutoff = 4096) {
   if (miniStreamContainer.length > 0) {
     const numSectors = Math.ceil(miniStreamContainer.length / sectorSize);
     rootStartSector = nextSector;
-    for (let i = 0; i < numSectors; i++) {
+    for (let i2 = 0; i2 < numSectors; i2++) {
       rootSectors.push(nextSector++);
     }
   }
@@ -1481,11 +2703,11 @@ function buildOle2(streams2, rootClsid, miniStreamCutoff = 4096) {
   if (numMiniFATSectors > 0) {
     writeFatRun(fat, firstMiniFATSector, numMiniFATSectors);
   }
-  for (let i = 0; i < numFATSectors; i++) {
-    fat[firstFATSector + i] = FATSECT;
+  for (let i2 = 0; i2 < numFATSectors; i2++) {
+    fat[firstFATSector + i2] = FATSECT;
   }
-  for (let i = 0; i < numDIFATSectors; i++) {
-    fat[firstDIFATSector + i] = DIFSECT;
+  for (let i2 = 0; i2 < numDIFATSectors; i2++) {
+    fat[firstDIFATSector + i2] = DIFSECT;
   }
   let miniFat;
   if (miniStreams.length > 0) {
@@ -1516,9 +2738,9 @@ function buildOle2(streams2, rootClsid, miniStreamCutoff = 4096) {
     writeStreamSectors(outBytes, miniStreamContainer, { start: rootSectors[0] ?? 0, sectors: rootSectors }, sectorSize);
   }
   const dirData = serializeDirectoryEntries(sortedDirEntries, numDirSectors, sectorSize);
-  for (let i = 0; i < numDirSectors; i++) {
-    const sectorOff = (firstDirSector + i + 1) * sectorSize;
-    outBytes.set(dirData.subarray(i * sectorSize, (i + 1) * sectorSize), sectorOff);
+  for (let i2 = 0; i2 < numDirSectors; i2++) {
+    const sectorOff = (firstDirSector + i2 + 1) * sectorSize;
+    outBytes.set(dirData.subarray(i2 * sectorSize, (i2 + 1) * sectorSize), sectorOff);
   }
   if (miniFat) {
     writeInt32Sectors(outBytes, miniFat, firstMiniFATSector, numMiniFATSectors, sectorSize);
@@ -1571,10 +2793,10 @@ function buildStandardEncryptionInfoStream(keyBits, salt, encryptedVerifier, enc
     );
   }
   const cspNameBytes = new Uint8Array((STANDARD_CSP_NAME.length + 1) * 2);
-  for (let i = 0; i < STANDARD_CSP_NAME.length; i++) {
-    const code = STANDARD_CSP_NAME.charCodeAt(i);
-    cspNameBytes[i * 2] = code & 255;
-    cspNameBytes[i * 2 + 1] = code >> 8 & 255;
+  for (let i2 = 0; i2 < STANDARD_CSP_NAME.length; i2++) {
+    const code = STANDARD_CSP_NAME.charCodeAt(i2);
+    cspNameBytes[i2 * 2] = code & 255;
+    cspNameBytes[i2 * 2 + 1] = code >> 8 & 255;
   }
   const headerFixedSize = 32;
   const headerSize = headerFixedSize + cspNameBytes.length;
@@ -1586,16 +2808,16 @@ function buildStandardEncryptionInfoStream(keyBits, salt, encryptedVerifier, enc
   view.setUint16(2, 2, true);
   view.setUint32(4, STANDARD_FLAGS, true);
   view.setUint32(8, headerSize, true);
-  const h = 12;
-  view.setUint32(h, STANDARD_FLAGS, true);
-  view.setUint32(h + 4, 0, true);
-  view.setUint32(h + 8, algId, true);
-  view.setUint32(h + 12, STANDARD_ALG_ID_HASH_SHA1, true);
-  view.setUint32(h + 16, keyBits, true);
-  view.setUint32(h + 20, STANDARD_PROVIDER_TYPE_RSA_AES, true);
-  view.setUint32(h + 24, 0, true);
-  view.setUint32(h + 28, 0, true);
-  data.set(cspNameBytes, h + 32);
+  const h2 = 12;
+  view.setUint32(h2, STANDARD_FLAGS, true);
+  view.setUint32(h2 + 4, 0, true);
+  view.setUint32(h2 + 8, algId, true);
+  view.setUint32(h2 + 12, STANDARD_ALG_ID_HASH_SHA1, true);
+  view.setUint32(h2 + 16, keyBits, true);
+  view.setUint32(h2 + 20, STANDARD_PROVIDER_TYPE_RSA_AES, true);
+  view.setUint32(h2 + 24, 0, true);
+  view.setUint32(h2 + 28, 0, true);
+  data.set(cspNameBytes, h2 + 32);
   const v = 12 + headerSize;
   view.setUint32(v, 16, true);
   data.set(salt.subarray(0, 16), v + 4);
@@ -1752,8 +2974,8 @@ function parseStandardEncryptionInfo(data) {
   const providerType = view.getUint32(headerOffset + 20, true);
   let cspName = "";
   const cspEnd = headerOffset + headerSize;
-  for (let i = headerOffset + 32; i < cspEnd - 1; i += 2) {
-    const ch = view.getUint16(i, true);
+  for (let i2 = headerOffset + 32; i2 < cspEnd - 1; i2 += 2) {
+    const ch = view.getUint16(i2, true);
     if (ch === 0) break;
     cspName += String.fromCharCode(ch);
   }