ooxml-core 1.0.0 → 1.1.0

package/dist/docx/load/index.mjs

@@ -54,8 +54,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");
     }
   }
@@ -97,8 +97,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);
     }
@@ -112,8 +112,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);
       }
@@ -127,8 +127,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) {
@@ -169,8 +169,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);
@@ -226,8 +226,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) {
@@ -292,10 +292,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;
 }
@@ -321,15 +321,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);
 }
@@ -448,6 +448,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,
@@ -527,40 +1367,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);
@@ -572,64 +1412,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,
@@ -828,35 +1668,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], el3 = 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], el3 = 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 | el3 << 18) ^ (eh >>> 18 | el3 << 14) ^ (el3 >>> 9 | eh << 23);
     const S1l = (el3 >>> 14 | eh << 18) ^ (el3 >>> 18 | eh << 14) ^ (eh >>> 9 | el3 << 23);
     const chh = eh & fh ^ ~eh & gh;
     const chl = el3 & fl ^ ~el3 & 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);
@@ -884,10 +1724,10 @@ function compress3(h, data, offset) {
     ah = t1h + t2h + Math.floor(nl / 4294967296) >>> 0;
     al = nl >>> 0;
   }
-  const add2 = (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 add2 = (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;
   };
   add2(0, ah, al);
   add2(2, bh, bl);
@@ -899,7 +1739,7 @@ function compress3(h, data, offset) {
   add2(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;
@@ -907,25 +1747,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
@@ -944,56 +2166,56 @@ 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);
 }
 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;
 }
 
@@ -1015,7 +2237,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),
@@ -1036,8 +2258,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;
     }
@@ -1078,8 +2300,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;
       }
@@ -1173,8 +2395,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;
     }
@@ -1183,9 +2405,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;
 }
@@ -1208,21 +2430,21 @@ function buildDirectoryTree(entryCount) {
   return { root: build(1, entryCount - 1, 0), links };
 }
 function writeFatChain(fat, chain2) {
-  for (let i = 0; i < chain2.sectors.length; i++) {
-    fat[chain2.sectors[i]] = i < chain2.sectors.length - 1 ? chain2.sectors[i + 1] : ENDOFCHAIN;
+  for (let i2 = 0; i2 < chain2.sectors.length; i2++) {
+    fat[chain2.sectors[i2]] = i2 < chain2.sectors.length - 1 ? chain2.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);
@@ -1248,11 +2470,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);
     }
   }
 }
@@ -1289,24 +2511,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);
@@ -1315,9 +2537,9 @@ function serializeDirectoryEntries(dirEntries, numDirSectors, sectorSize) {
   return dirData;
 }
 function writeStreamSectors(outBytes, streamData, chain2, sectorSize) {
-  for (let i = 0; i < chain2.sectors.length; i++) {
-    const sectorOffset = (chain2.sectors[i] + 1) * sectorSize;
-    const srcOffset = i * sectorSize;
+  for (let i2 = 0; i2 < chain2.sectors.length; i2++) {
+    const sectorOffset = (chain2.sectors[i2] + 1) * sectorSize;
+    const srcOffset = i2 * sectorSize;
     const srcEnd = Math.min(srcOffset + sectorSize, streamData.length);
     outBytes.set(streamData.subarray(srcOffset, srcEnd), sectorOffset);
   }
@@ -1328,15 +2550,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");
     }
   }
@@ -1354,7 +2576,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 });
@@ -1372,9 +2594,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;
@@ -1390,7 +2612,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++);
     }
   }
@@ -1449,11 +2671,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) {
@@ -1484,9 +2706,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);
@@ -1539,10 +2761,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;
@@ -1554,16 +2776,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);
@@ -1720,8 +2942,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);
   }
@@ -2202,7 +3424,7 @@ function setAttribute(element, local, value) {
 }
 function paraIdFor(id, index) {
   let hash2 = index + 1 >>> 0;
-  for (let i = 0; i < id.length; i++) hash2 = Math.imul(hash2, 31) + id.charCodeAt(i) >>> 0;
+  for (let i2 = 0; i2 < id.length; i2++) hash2 = Math.imul(hash2, 31) + id.charCodeAt(i2) >>> 0;
   return hash2.toString(16).padStart(8, "0").toUpperCase();
 }
 function buildCommentsDocument(comments) {
@@ -2393,6 +3615,27 @@ function expectDefined(value, context) {
   return value;
 }
 
+// color/color-primitives.ts
+function toHex(value) {
+  return Math.min(255, Math.max(0, Math.round(value))).toString(16).padStart(2, "0").toUpperCase();
+}
+
+// drawingml/theme-model.ts
+var THEME_COLOR_SLOTS = [
+  "dk1",
+  "lt1",
+  "dk2",
+  "lt2",
+  "accent1",
+  "accent2",
+  "accent3",
+  "accent4",
+  "accent5",
+  "accent6",
+  "hlink",
+  "folHlink"
+];
+
 // docx/generated/wml-simple-types.ts
 var ST_HighlightColor = ["black", "blue", "cyan", "green", "magenta", "red", "yellow", "white", "darkBlue", "darkCyan", "darkGreen", "darkMagenta", "darkRed", "darkYellow", "darkGray", "lightGray", "none"];
 function isStHighlightColor(value) {
@@ -2479,9 +3722,6 @@ function isStRelFromV(value) {
 function isThemeColorToken(value) {
   return isStThemeColor(value);
 }
-function toHex(value) {
-  return Math.min(255, Math.max(0, Math.round(value))).toString(16).padStart(2, "0").toUpperCase();
-}
 function fractionToThemeByte(fraction) {
   return toHex(Math.round(Math.min(1, Math.max(0, fraction)) * 255));
 }
@@ -4548,9 +5788,9 @@ function buildWatermarkRun(doc, spec, uniqueId) {
   type.setAttribute("path", "m@7,l@8,m@5,21600l@6,21600e");
   const formulas = v("formulas");
   for (const eqn of FORMULAS) {
-    const f = v("f");
-    f.setAttribute("eqn", eqn);
-    formulas.appendChild(f);
+    const f6 = v("f");
+    f6.setAttribute("eqn", eqn);
+    formulas.appendChild(f6);
   }
   const path = v("path");
   path.setAttribute("textpathok", "t");
@@ -4895,7 +6135,7 @@ var DIAGRAM_RELATIONSHIP_TYPES = {
   drawing: RELATIONSHIP_TYPES.diagramDrawing
 };
 
-// diagram/dom.ts
+// drawingml/dom.ts
 function attributeReader(element) {
   return (name) => {
     if (!element) return void 0;
@@ -5051,7 +6291,7 @@ function parseDiagramDataModel(source, part) {
   };
 }
 
-// diagram/drawing-color.ts
+// drawingml/drawing-color.ts
 var COLOR_ELEMENTS = {
   srgbClr: "srgb",
   schemeClr: "scheme",
@@ -5190,7 +6430,7 @@ function parseDiagramLayoutSummary(source) {
   };
 }
 
-// diagram/drawing-fill.ts
+// drawingml/drawing-fill.ts
 var FILL_ELEMENTS = /* @__PURE__ */ new Set([
   "noFill",
   "solidFill",
@@ -5282,7 +6522,7 @@ function parseDrawingLine(ln) {
   return line;
 }
 
-// diagram/drawing-text.ts
+// drawingml/drawing-text.ts
 function parseSpacing(parent) {
   for (const [name, unit, divisor] of [
     ["spcPts", "points", 100],
@@ -5361,7 +6601,7 @@ function parseDrawingTextBody(body) {
   return result;
 }
 
-// diagram/drawing-geometry.ts
+// drawingml/drawing-geometry.ts
 var int = (element, name) => Number.parseInt(element?.getAttribute(name) ?? "", 10);
 function parseFrame(container2) {
   const off = first(container2, "off", NS.a);
@@ -5506,12 +6746,12 @@ function groupTransform(group, parent) {
 }
 function parseShape(sp, index, group, issues) {
   const spPr = first(sp, "spPr", NS.dsp);
-  const transform = parseTransform(first(spPr, "xfrm", NS.a));
-  if (!transform) return void 0;
+  const transform6 = parseTransform(first(spPr, "xfrm", NS.a));
+  if (!transform6) return void 0;
   const modelId = stringAttribute(sp, "modelId") ?? stringAttribute(first(first(sp, "nvSpPr", NS.dsp), "cNvPr", NS.dsp), "id") ?? `dsp-${index}`;
   const { geometry, adjustments, paths, issue } = parseDrawingGeometry(spPr);
   if (issue) issues.push({ code: issue, message: `Shape ${modelId}: ${issue}.` });
-  const frame = applyGroup(transform.frame, group);
+  const frame = applyGroup(transform6.frame, group);
   if ((frame.width <= 0 || frame.height <= 0) && geometry !== "line") return void 0;
   const shape = {
     modelId,
@@ -5519,9 +6759,9 @@ function parseShape(sp, index, group, issues) {
     geometry,
     has3d: Boolean(first(spPr, "scene3d", NS.a) || first(spPr, "sp3d", NS.a))
   };
-  if (transform.rotation !== void 0) shape.rotation = transform.rotation;
-  if (transform.flipHorizontal) shape.flipHorizontal = true;
-  if (transform.flipVertical) shape.flipVertical = true;
+  if (transform6.rotation !== void 0) shape.rotation = transform6.rotation;
+  if (transform6.flipHorizontal) shape.flipHorizontal = true;
+  if (transform6.flipVertical) shape.flipVertical = true;
   if (adjustments) shape.adjustments = adjustments;
   if (paths) shape.paths = paths;
   const fill = parseDrawingFill(spPr);
@@ -6163,6 +7403,23 @@ function parseRunPropertiesSnapshot(xml) {
   return parsePropertiesSnapshot(xml, "rPr");
 }
 
+// docx/field-flags.ts
+function parseFieldFlags(element) {
+  const locked = onOffAttribute(element, "fldLock");
+  const dirty = onOffAttribute(element, "dirty");
+  if (locked === void 0 && dirty === void 0) return void 0;
+  return { ...locked !== void 0 && { locked }, ...dirty !== void 0 && { dirty } };
+}
+function writeFieldFlags(element, flags) {
+  for (const [name, value] of [
+    ["fldLock", flags?.locked],
+    ["dirty", flags?.dirty]
+  ]) {
+    if (value === void 0) element.removeAttributeNS(WORD_NS, name);
+    else element.setAttributeNS(WORD_NS, `w:${name}`, value ? "true" : "false");
+  }
+}
+
 // docx/write-run.ts
 function setAttribute6(element, local, value) {
   element.setAttributeNS(WORD_NS, `w:${local}`, value);
@@ -6348,6 +7605,7 @@ function createRun(doc, run, base, old, allocator) {
   if (run.fieldChar) {
     const marker = makeW(doc, "fldChar");
     setAttribute6(marker, "fldCharType", run.fieldChar);
+    writeFieldFlags(marker, run.fieldFlags);
     node.appendChild(marker);
     return node;
   }
@@ -6428,6 +7686,11 @@ function takeSimpleFieldCommentEdges(doc, runs, start, end, opens, closes) {
     after: take(closes, end - 1).reverse().flatMap((edge) => rangeEndNodes(doc, edge))
   };
 }
+
+// docx/field-lock.ts
+function sameFieldFlags(a, b) {
+  return a?.locked === b?.locked && a?.dirty === b?.dirty;
+}
 var MATH_NAMESPACES = /* @__PURE__ */ new Set([
   "http://schemas.openxmlformats.org/officeDocument/2006/math",
   "http://purl.oclc.org/ooxml/officeDocument/math"
@@ -6752,6 +8015,7 @@ function buildInlineContent(doc, runs, base, slots, allocator, ranges) {
       container2 = makeW(doc, "fldSimple");
       setW6(container2, "instr", ` ${group.instr} `);
     }
+    if (group.kind === "simpleField") writeFieldFlags(container2, runAt(start).fieldFlags);
     const edges = group.kind === "simpleField" ? takeSimpleFieldCommentEdges(doc, runs, start, index, opens, closes) : { before: [], after: [] };
     for (let item = start; item < index; item++)
       for (const node of nodesFor(item)) container2.appendChild(node);
@@ -6762,13 +8026,18 @@ function buildInlineContent(doc, runs, base, slots, allocator, ranges) {
 function containerGroup(run) {
   if (run.link) return { kind: "link", link: run.link };
   if (run.field?.simple)
-    return { kind: "simpleField", instr: run.field.instr, instanceId: run.fieldInstanceId };
+    return {
+      kind: "simpleField",
+      instr: run.field.instr,
+      instanceId: run.fieldInstanceId,
+      fieldFlags: run.fieldFlags
+    };
   return void 0;
 }
 function sameGroup(a, b) {
   if (!a || !b) return a === b;
   if (a.kind === "link" && b.kind === "link") return sameLink(a.link, b.link);
-  return a.kind === "simpleField" && b.kind === "simpleField" && a.instr === b.instr && a.instanceId === b.instanceId;
+  return a.kind === "simpleField" && b.kind === "simpleField" && a.instr === b.instr && a.instanceId === b.instanceId && sameFieldFlags(a.fieldFlags, b.fieldFlags);
 }
 
 // docx/paragraph-styles.ts
@@ -7200,8 +8469,8 @@ function replaceSlots(doc, parent, oldNodes, nextNodes, insertionAnchor = null)
     return marker;
   });
   const shared = Math.min(placeholders.length, nextNodes.length);
-  for (const [i, marker] of placeholders.slice(0, shared).entries()) {
-    const next = nextNodes[i];
+  for (const [i2, marker] of placeholders.slice(0, shared).entries()) {
+    const next = nextNodes[i2];
     if (next) parent.replaceChild(next, marker);
   }
   for (const marker of placeholders.slice(shared)) parent.removeChild(marker);
@@ -7809,6 +9078,217 @@ async function registerNumberingPart(zip) {
   zip.file(relsPath, buildXml(relsDoc));
 }
 
+// docx/numbering-parse.ts
+var integer2 = (value, fallback) => parseInteger(value) ?? fallback;
+var flag = (element) => onOffElement(element) === true;
+function byName(root, local) {
+  return Array.from(root.getElementsByTagName("*")).filter(
+    (node) => node.nodeType === 1 && named2(node, local)
+  );
+}
+function parseMarkerFormat(rPr) {
+  if (!rPr) return void 0;
+  const format = {};
+  const family = getW(first2(rPr, "rFonts"), "ascii");
+  if (family) format.fontFamily = family;
+  const size = parseInteger(getW(first2(rPr, "sz"), "val"));
+  if (size !== void 0 && size > 0) format.fontSizeHalfPoints = size;
+  if (onOffElement(first2(rPr, "b")) === true) format.bold = true;
+  if (onOffElement(first2(rPr, "i")) === true) format.italic = true;
+  const color = getW(first2(rPr, "color"), "val");
+  if (color && /^[0-9a-f]{6}$/i.test(color)) format.color = `#${color.toLowerCase()}`;
+  return Object.keys(format).length ? format : void 0;
+}
+function parseNumberingLevel(lvl) {
+  const level = integer2(getW(lvl, "ilvl"), 0);
+  const start = integer2(getW(first2(lvl, "start"), "val"), 1);
+  const numFmt = enumValue(isStNumberFormat, getW(first2(lvl, "numFmt"), "val"), "w:numFmt") ?? "decimal";
+  const lvlText = getW(first2(lvl, "lvlText"), "val") ?? "";
+  const jc = getW(first2(lvl, "lvlJc"), "val");
+  const ind = first2(first2(lvl, "pPr"), "ind");
+  const suffRaw = getW(first2(lvl, "suff"), "val");
+  const result = { level, start, numFmt, lvlText };
+  if (!first2(lvl, "start")) result.startWasOmitted = true;
+  const paragraphStyleId = getW(first2(lvl, "pStyle"), "val");
+  if (paragraphStyleId) result.paragraphStyleId = paragraphStyleId;
+  if (jc === "left" || jc === "center" || jc === "right") result.lvlJc = jc;
+  const left = getW(ind, "left") ?? getW(ind, "start");
+  if (left !== void 0) result.indentLeftTwips = parseSignedTwips(left) ?? signedTwips(0);
+  const hanging = getW(ind, "hanging");
+  if (hanging !== void 0) result.hangingTwips = parseTwips(hanging) ?? twips(0);
+  const firstLine = getW(ind, "firstLine");
+  if (firstLine !== void 0) result.firstLineTwips = parseTwips(firstLine) ?? twips(0);
+  const tabs = first2(first2(lvl, "pPr"), "tabs");
+  const tab = tabs ? children2(tabs, "tab").find((stop) => getW(stop, "val") !== "clear") : void 0;
+  const tabPos = tab ? parseTwips(getW(tab, "pos")) : void 0;
+  if (tabPos !== void 0) result.tabStopTwips = tabPos;
+  if (flag(first2(lvl, "isLgl"))) result.isLgl = true;
+  const restart = getW(first2(lvl, "lvlRestart"), "val");
+  if (restart !== void 0) result.lvlRestart = integer2(restart, 0);
+  const marker = parseMarkerFormat(first2(lvl, "rPr"));
+  if (marker) result.markerFormat = marker;
+  result.suffix = suffRaw === "space" ? "space" : suffRaw === "nothing" ? "none" : "tab";
+  return result;
+}
+function parseAbstractNum(element) {
+  const id = getW(element, "abstractNumId");
+  if (!id) return void 0;
+  const levels = {};
+  for (const lvl of children2(element, "lvl")) {
+    const parsed = parseNumberingLevel(lvl);
+    levels[parsed.level] = parsed;
+  }
+  return { id, levels };
+}
+function parseNum(element) {
+  const id = getW(element, "numId");
+  if (!id) return void 0;
+  const abstractNumId = getW(first2(element, "abstractNumId"), "val") ?? "";
+  const levelOverrides = {};
+  for (const override of children2(element, "lvlOverride")) {
+    const level = integer2(getW(override, "ilvl"), 0);
+    const entry = {};
+    const startOverride = getW(first2(override, "startOverride"), "val");
+    if (startOverride !== void 0) entry.startOverride = integer2(startOverride, 1);
+    const lvl = first2(override, "lvl");
+    if (lvl) entry.lvl = parseNumberingLevel(lvl);
+    if (Object.keys(entry).length) levelOverrides[level] = entry;
+  }
+  return {
+    id,
+    abstractNumId,
+    ...Object.keys(levelOverrides).length ? { levelOverrides } : {}
+  };
+}
+function parseNumberingCatalog(xml) {
+  const document = parseXml2(xml);
+  const root = document.documentElement;
+  const abstractNums = {};
+  const warnings = [];
+  for (const element of byName(root, "abstractNum")) {
+    const parsed = parseAbstractNum(element);
+    if (!parsed) continue;
+    abstractNums[parsed.id] = parsed;
+    const link = getW(first2(element, "numStyleLink"), "val");
+    if (link)
+      warnings.push(
+        `Numbering definition abstractNum ${parsed.id} links to style "${link}"; style-linked numbering levels are not resolved.`
+      );
+    if (byName(element, "lvlPicBulletId").length)
+      warnings.push(
+        `Numbering definition abstractNum ${parsed.id} uses a picture bullet; picture bullets are not rendered.`
+      );
+  }
+  const nums = {};
+  for (const element of byName(root, "num")) {
+    const parsed = parseNum(element);
+    if (parsed) nums[parsed.id] = parsed;
+  }
+  return { abstractNums, nums, warnings: [...new Set(warnings)] };
+}
+function resolveNumberingLevel(catalog, numId, level) {
+  const num = catalog.nums[numId];
+  if (!num) return void 0;
+  const override = num.levelOverrides?.[level];
+  const sourceAbstract = catalog.abstractNums[num.abstractNumId]?.levels[level];
+  const abstract = sourceAbstract?.startWasOmitted && sourceAbstract.start === 1 ? { ...sourceAbstract, start: 0 } : sourceAbstract;
+  let base = override?.lvl ?? abstract;
+  if (!base) return void 0;
+  if (override?.lvl) {
+    const { lvlRestart: _ignored, ...properties } = base;
+    base = {
+      ...properties,
+      ...abstract?.lvlRestart !== void 0 ? { lvlRestart: abstract.lvlRestart } : {}
+    };
+  }
+  let start = override?.startOverride ?? base.start;
+  if (override?.lvl) {
+    if (abstract?.lvlRestart === 0 && override.startOverride === void 0) start = abstract.start;
+    else if (!override.lvl.startWasOmitted || override.lvl.start !== 1) start = override.lvl.start;
+    else start = override.startOverride ?? 0;
+  }
+  return start !== base.start ? { ...base, start } : base;
+}
+
+// docx/numbering-start-edit.ts
+function assertListStartValue(level, start) {
+  if (!Number.isInteger(level) || level < 0 || level > 8)
+    throw new Error("List level must be an integer from 0 through 8.");
+  if (!Number.isInteger(start) || start < 0 || start > 2147483647)
+    throw new Error("List start must be an integer from 0 through 2147483647.");
+}
+
+// docx/numbering-start-patch.ts
+function withoutStarts(num) {
+  const { levelOverrides, ...properties } = num;
+  const kept = {};
+  for (const [level, override] of Object.entries(levelOverrides ?? {})) {
+    const { startOverride: _start, ...rest } = override;
+    if (Object.keys(rest).length) kept[level] = rest;
+  }
+  return { ...properties, ...Object.keys(kept).length ? { levelOverrides: kept } : {} };
+}
+function numberingStartChanges(prior, next) {
+  const changes = [];
+  for (const [id, previous] of Object.entries(prior?.nums ?? {})) {
+    const current = next.nums[id];
+    if (!current || JSON.stringify(withoutStarts(current)) !== JSON.stringify(withoutStarts(previous)))
+      throw new Error(
+        `Cannot edit numbering definition num "${id}" except its supported start overrides.`
+      );
+    for (const key of /* @__PURE__ */ new Set([
+      ...Object.keys(previous.levelOverrides ?? {}),
+      ...Object.keys(current.levelOverrides ?? {})
+    ])) {
+      const level = Number(key);
+      const old = previous.levelOverrides?.[level];
+      const value = current.levelOverrides?.[level];
+      if (old?.startOverride === value?.startOverride) continue;
+      if (value?.startOverride === void 0)
+        throw new Error("Removing a list start override is unsupported.");
+      assertListStartValue(level, value.startOverride);
+      if (String(level) !== key || !prior || !resolveNumberingLevel(prior, id, level))
+        throw new Error("List instance or level does not exist.");
+      if (old?.lvl || value.lvl)
+        throw new Error("Changing starts with a full level override is unsupported.");
+      changes.push({ numId: id, level, start: value.startOverride });
+    }
+  }
+  return changes;
+}
+function patchNumberingStarts(doc, changes) {
+  const sameNumber = (source, expected) => source !== void 0 && /^[+-]?\d+$/.test(source) && Number(source) === Number(expected);
+  const prepared = changes.map((change) => {
+    const nums = children2(doc.documentElement, "num").filter(
+      (num2) => sameNumber(getW(num2, "numId"), change.numId)
+    );
+    if (nums.length !== 1 || getW(nums[0], "numId") !== change.numId)
+      throw new Error("Cannot patch an ambiguous or missing source list instance.");
+    const num = nums[0];
+    const overrides = children2(num, "lvlOverride").filter(
+      (node) => sameNumber(getW(node, "ilvl"), String(change.level))
+    );
+    if (overrides.length > 1) throw new Error("Cannot patch duplicate source level overrides.");
+    const override = overrides[0];
+    if (override && getW(override, "ilvl") !== String(change.level))
+      throw new Error("Cannot patch a noncanonical source level override.");
+    if (override && (children2(override, "lvl").length || children2(override, "startOverride").length > 1))
+      throw new Error("Cannot patch a full or ambiguous source level override.");
+    return { change, num, override };
+  });
+  for (const { change, num, override: existing } of prepared) {
+    const override = existing ?? makeW(doc, "lvlOverride");
+    if (!existing) {
+      override.setAttributeNS(WORD_NS, "w:ilvl", String(change.level));
+      const after = children2(num, "lvlOverride").at(-1) ?? children2(num, "abstractNumId")[0];
+      num.insertBefore(override, after?.nextSibling ?? null);
+    }
+    const start = children2(override, "startOverride")[0] ?? makeW(doc, "startOverride");
+    start.setAttributeNS(WORD_NS, "w:val", String(change.start));
+    if (!start.parentNode) override.insertBefore(start, override.firstChild);
+  }
+}
+
 // docx/numbering-package.ts
 function setAttribute8(element, local, value) {
   element.setAttributeNS(WORD_NS, `w:${local}`, value);
@@ -7913,17 +9393,14 @@ async function applyNumberingCatalog(zip, model, binding) {
       throw new Error(
         `Cannot edit numbering definition abstractNum "${id}"; the original numbering.xml is preserved unchanged.`
       );
-  for (const id of Object.keys(prior?.nums ?? {}))
-    if (JSON.stringify(next.nums[id]) !== JSON.stringify(prior?.nums[id]))
-      throw new Error(
-        `Cannot edit numbering definition num "${id}"; the original numbering.xml is preserved unchanged.`
-      );
+  const startChanges = numberingStartChanges(prior, next);
   const newAbstractIds = Object.keys(next.abstractNums).filter((id) => !prior?.abstractNums[id]);
   const newNumIds = Object.keys(next.nums).filter((id) => !prior?.nums[id]);
-  if (!newAbstractIds.length && !newNumIds.length) return;
+  if (!newAbstractIds.length && !newNumIds.length && !startChanges.length) return;
   const existingFile = zip.file("word/numbering.xml");
   const doc = existingFile ? parseXml2(await existingFile.async("string")) : parseXml2(`<w:numbering xmlns:w="${WORD_NS}"/>`);
   const root = doc.documentElement;
+  patchNumberingStarts(doc, startChanges);
   const cleanup = children2(root, "numIdMacAtCleanup")[0] ?? null;
   const firstNum = children2(root, "num")[0] ?? cleanup;
   for (const id of newAbstractIds) {
@@ -8936,23 +10413,31 @@ function createFieldTracker() {
   const stack = [];
   return (element, run) => {
     let resultInstr;
+    let resultLocked;
     for (const child3 of Array.from(element.childNodes)) {
       if (!isElement(child3)) continue;
       if (named2(child3, "fldChar")) {
         const type = getW(child3, "fldCharType");
-        if (type === "begin") stack.push({ instr: "", inResult: false });
-        else if (type === "separate") {
+        if (type === "begin") {
+          const locked = parseFieldFlags(child3)?.locked;
+          stack.push({ instr: "", inResult: false, ...locked !== void 0 && { locked } });
+        } else if (type === "separate") {
           const top = stack.at(-1);
           if (top) top.inResult = true;
         } else if (type === "end") stack.pop();
       } else {
         const top = stack.at(-1);
         if (named2(child3, "instrText") && top && !top.inResult) top.instr += textContent(child3);
-        else if ((named2(child3, "t") || named2(child3, "delText")) && top?.inResult)
+        else if ((named2(child3, "t") || named2(child3, "delText")) && top?.inResult) {
           resultInstr = top.instr.trim();
+          resultLocked = top.locked;
+        }
       }
     }
-    if (resultInstr) run.field = { instr: resultInstr };
+    if (resultInstr) {
+      run.field = { instr: resultInstr };
+      if (resultLocked !== void 0) run.fieldFlags = { locked: resultLocked };
+    }
     return run;
   };
 }
@@ -8963,7 +10448,11 @@ function storyFieldResults(container2) {
     if (named2(element, "fldSimple") || named2(element, "txbxContent")) return;
     if (named2(element, "r")) {
       const run = trackField(element, { text: "" });
-      if (run.field) metadata.set(element, run.field);
+      if (run.field)
+        metadata.set(element, {
+          field: run.field,
+          ...run.fieldFlags && { fieldFlags: run.fieldFlags }
+        });
       return;
     }
     for (const child3 of Array.from(element.childNodes)) if (isElement(child3)) visit(child3);
@@ -9055,7 +10544,11 @@ function parseRun2(node, revision) {
   if (breakKind) run.break = breakKind;
   if (noteReference) run.noteReference = noteReference;
   if (noteMark) run.noteMark = noteMark;
-  if (fieldChar) run.fieldChar = fieldChar;
+  if (fieldChar) {
+    run.fieldChar = fieldChar;
+    const flags = parseFieldFlags(only);
+    if (flags) run.fieldFlags = flags;
+  }
   if (fieldCode !== void 0) run.fieldCode = fieldCode;
   const runRevision = revision ?? runFormatRevision(props);
   if (runRevision) run.revision = runRevision;
@@ -9074,8 +10567,11 @@ function parseParagraph2(node, id, fields) {
     (element, revision) => {
       const run = parseRun2(element, revision);
       if (!fields) return trackField(element, run);
-      const field = fields.get(element);
-      if (field) run.field = { ...field };
+      const metadata = fields.get(element);
+      if (metadata) {
+        run.field = { ...metadata.field };
+        if (metadata.fieldFlags) run.fieldFlags = { ...metadata.fieldFlags };
+      }
       return run;
     },
     (item) => {
@@ -9097,20 +10593,23 @@ function parseParagraph2(node, id, fields) {
       );
       if (link) return results.map((run) => ({ ...run, link }));
       const field = { instr: instr.trim(), simple: true };
+      const flags = parseFieldFlags(item);
+      const fieldState = flags ? { fieldFlags: flags } : {};
       const fieldInstanceId = `${id}:simple-field-${simpleFieldIndex++}`;
-      if (!results.length) return [{ text: fieldPlaceholderText(instr), field, fieldInstanceId }];
+      if (!results.length)
+        return [{ text: fieldPlaceholderText(instr), field, fieldInstanceId, ...fieldState }];
       if (results.every(
         (run) => !run.text && !run.equation && !run.image && !run.break && !run.noteReference && !run.noteMark && !run.fieldChar && run.fieldCode === void 0
       )) {
         return [
-          { text: "", fieldChar: "begin" },
+          { text: "", fieldChar: "begin", ...fieldState },
           { text: "", fieldCode: instr },
           { text: "", fieldChar: "separate" },
           ...results,
           { text: "", fieldChar: "end" }
         ];
       }
-      return results.map((run) => ({ ...run, field, fieldInstanceId }));
+      return results.map((run) => ({ ...run, field, fieldInstanceId, ...fieldState }));
     },
     (hyperlink) => {
       if (!activeContext) return void 0;
@@ -9412,115 +10911,6 @@ async function parseDocumentParts(zip, body, blocks, drawings) {
   };
 }
 
-// docx/numbering-parse.ts
-var integer2 = (value, fallback) => parseInteger(value) ?? fallback;
-var flag = (element) => onOffElement(element) === true;
-function byName(root, local) {
-  return Array.from(root.getElementsByTagName("*")).filter(
-    (node) => node.nodeType === 1 && named2(node, local)
-  );
-}
-function parseMarkerFormat(rPr) {
-  if (!rPr) return void 0;
-  const format = {};
-  const family = getW(first2(rPr, "rFonts"), "ascii");
-  if (family) format.fontFamily = family;
-  const size = parseInteger(getW(first2(rPr, "sz"), "val"));
-  if (size !== void 0 && size > 0) format.fontSizeHalfPoints = size;
-  if (onOffElement(first2(rPr, "b")) === true) format.bold = true;
-  if (onOffElement(first2(rPr, "i")) === true) format.italic = true;
-  const color = getW(first2(rPr, "color"), "val");
-  if (color && /^[0-9a-f]{6}$/i.test(color)) format.color = `#${color.toLowerCase()}`;
-  return Object.keys(format).length ? format : void 0;
-}
-function parseNumberingLevel(lvl) {
-  const level = integer2(getW(lvl, "ilvl"), 0);
-  const start = integer2(getW(first2(lvl, "start"), "val"), 1);
-  const numFmt = enumValue(isStNumberFormat, getW(first2(lvl, "numFmt"), "val"), "w:numFmt") ?? "decimal";
-  const lvlText = getW(first2(lvl, "lvlText"), "val") ?? "";
-  const jc = getW(first2(lvl, "lvlJc"), "val");
-  const ind = first2(first2(lvl, "pPr"), "ind");
-  const suffRaw = getW(first2(lvl, "suff"), "val");
-  const result = { level, start, numFmt, lvlText };
-  if (!first2(lvl, "start")) result.startWasOmitted = true;
-  const paragraphStyleId = getW(first2(lvl, "pStyle"), "val");
-  if (paragraphStyleId) result.paragraphStyleId = paragraphStyleId;
-  if (jc === "left" || jc === "center" || jc === "right") result.lvlJc = jc;
-  const left = getW(ind, "left") ?? getW(ind, "start");
-  if (left !== void 0) result.indentLeftTwips = parseSignedTwips(left) ?? signedTwips(0);
-  const hanging = getW(ind, "hanging");
-  if (hanging !== void 0) result.hangingTwips = parseTwips(hanging) ?? twips(0);
-  const firstLine = getW(ind, "firstLine");
-  if (firstLine !== void 0) result.firstLineTwips = parseTwips(firstLine) ?? twips(0);
-  const tabs = first2(first2(lvl, "pPr"), "tabs");
-  const tab = tabs ? children2(tabs, "tab").find((stop) => getW(stop, "val") !== "clear") : void 0;
-  const tabPos = tab ? parseTwips(getW(tab, "pos")) : void 0;
-  if (tabPos !== void 0) result.tabStopTwips = tabPos;
-  if (flag(first2(lvl, "isLgl"))) result.isLgl = true;
-  const restart = getW(first2(lvl, "lvlRestart"), "val");
-  if (restart !== void 0) result.lvlRestart = integer2(restart, 0);
-  const marker = parseMarkerFormat(first2(lvl, "rPr"));
-  if (marker) result.markerFormat = marker;
-  result.suffix = suffRaw === "space" ? "space" : suffRaw === "nothing" ? "none" : "tab";
-  return result;
-}
-function parseAbstractNum(element) {
-  const id = getW(element, "abstractNumId");
-  if (!id) return void 0;
-  const levels = {};
-  for (const lvl of children2(element, "lvl")) {
-    const parsed = parseNumberingLevel(lvl);
-    levels[parsed.level] = parsed;
-  }
-  return { id, levels };
-}
-function parseNum(element) {
-  const id = getW(element, "numId");
-  if (!id) return void 0;
-  const abstractNumId = getW(first2(element, "abstractNumId"), "val") ?? "";
-  const levelOverrides = {};
-  for (const override of children2(element, "lvlOverride")) {
-    const level = integer2(getW(override, "ilvl"), 0);
-    const entry = {};
-    const startOverride = getW(first2(override, "startOverride"), "val");
-    if (startOverride !== void 0) entry.startOverride = integer2(startOverride, 1);
-    const lvl = first2(override, "lvl");
-    if (lvl) entry.lvl = parseNumberingLevel(lvl);
-    if (Object.keys(entry).length) levelOverrides[level] = entry;
-  }
-  return {
-    id,
-    abstractNumId,
-    ...Object.keys(levelOverrides).length ? { levelOverrides } : {}
-  };
-}
-function parseNumberingCatalog(xml) {
-  const document = parseXml2(xml);
-  const root = document.documentElement;
-  const abstractNums = {};
-  const warnings = [];
-  for (const element of byName(root, "abstractNum")) {
-    const parsed = parseAbstractNum(element);
-    if (!parsed) continue;
-    abstractNums[parsed.id] = parsed;
-    const link = getW(first2(element, "numStyleLink"), "val");
-    if (link)
-      warnings.push(
-        `Numbering definition abstractNum ${parsed.id} links to style "${link}"; style-linked numbering levels are not resolved.`
-      );
-    if (byName(element, "lvlPicBulletId").length)
-      warnings.push(
-        `Numbering definition abstractNum ${parsed.id} uses a picture bullet; picture bullets are not rendered.`
-      );
-  }
-  const nums = {};
-  for (const element of byName(root, "num")) {
-    const parsed = parseNum(element);
-    if (parsed) nums[parsed.id] = parsed;
-  }
-  return { abstractNums, nums, warnings: [...new Set(warnings)] };
-}
-
 // docx/comments.ts
 var W14_NS2 = "http://schemas.microsoft.com/office/word/2010/wordml";
 var W15_NS2 = "http://schemas.microsoft.com/office/word/2012/wordml";
@@ -9564,62 +10954,88 @@ function parseComments(commentsXml, extendedXml) {
   return comments;
 }
 
-// docx/theme.ts
-var DRAWING_NS = "http://schemas.openxmlformats.org/drawingml/2006/main";
-var SCHEME_ORDER = [
-  "dk1",
-  "lt1",
-  "dk2",
-  "lt2",
-  "accent1",
-  "accent2",
-  "accent3",
-  "accent4",
-  "accent5",
-  "accent6",
-  "hlink",
-  "folHlink"
-];
-function drawingChild(parent, local) {
-  if (!parent) return void 0;
-  for (const node of Array.from(parent.childNodes)) {
-    const element = node;
-    if (element.nodeType === 1 && element.localName === local && element.namespaceURI === DRAWING_NS)
-      return element;
+// drawingml/theme.ts
+new Set(THEME_COLOR_SLOTS);
+function nonEmpty(value) {
+  return value ? value : void 0;
+}
+function parseThemeColorScheme(scheme) {
+  const result = { colors: {} };
+  if (!scheme) return result;
+  const name = nonEmpty(scheme.getAttribute("name"));
+  if (name) result.name = name;
+  for (const slot2 of THEME_COLOR_SLOTS) {
+    const color = parseDrawingColorIn(first(scheme, slot2, NS.a));
+    if (color) result.colors[slot2] = color;
   }
-  return void 0;
+  return result;
 }
-function colorOf2(slot2) {
-  const srgb = drawingChild(slot2, "srgbClr");
-  if (srgb) return srgb.getAttribute("val")?.toUpperCase() || void 0;
-  const sys = drawingChild(slot2, "sysClr");
-  if (sys) return sys.getAttribute("lastClr")?.toUpperCase() || void 0;
-  return void 0;
+function parseFontCollection(collection) {
+  const result = { scripts: {} };
+  if (!collection) return result;
+  const typeface = (local) => nonEmpty(first(collection, local, NS.a)?.getAttribute("typeface"));
+  const latin = typeface("latin");
+  const eastAsia = typeface("ea");
+  const complexScript = typeface("cs");
+  if (latin) result.latin = latin;
+  if (eastAsia) result.eastAsia = eastAsia;
+  if (complexScript) result.complexScript = complexScript;
+  for (const font of elements(collection)) {
+    if (font.localName !== "font") continue;
+    const script = nonEmpty(font.getAttribute("script"));
+    const face = nonEmpty(font.getAttribute("typeface"));
+    if (script && face && !Object.hasOwn(result.scripts, script)) result.scripts[script] = face;
+  }
+  return result;
 }
-function fontSetOf(element) {
-  if (!element) return {};
-  const latin = drawingChild(element, "latin")?.getAttribute("typeface") || void 0;
-  const ea = drawingChild(element, "ea")?.getAttribute("typeface") || void 0;
-  const cs = drawingChild(element, "cs")?.getAttribute("typeface") || void 0;
+function parseThemeFontScheme(scheme) {
+  const result = {
+    major: parseFontCollection(first(scheme, "majorFont", NS.a)),
+    minor: parseFontCollection(first(scheme, "minorFont", NS.a))
+  };
+  const name = nonEmpty(scheme?.getAttribute("name"));
+  if (name) result.name = name;
+  return result;
+}
+function rootOf2(source) {
+  return "documentElement" in source ? source.documentElement : source;
+}
+function parseTheme(source) {
+  const root = rootOf2(source);
+  const holder = first(root, "themeElements", NS.a) ?? root;
+  const theme = {
+    colorScheme: parseThemeColorScheme(first(holder, "clrScheme", NS.a)),
+    fontScheme: parseThemeFontScheme(first(holder, "fontScheme", NS.a))
+  };
+  const name = nonEmpty(root.getAttribute("name"));
+  if (name) theme.name = name;
+  return theme;
+}
+
+// drawingml/theme-color.ts
+function themeSlotHex(color) {
+  if (!color) return void 0;
+  const value = color.kind === "srgb" ? color.value : color.kind === "system" ? color.fallback : void 0;
+  return value ? value.toUpperCase() : void 0;
+}
+
+// docx/theme.ts
+function fontSetOf(collection) {
+  const { latin, eastAsia, complexScript } = collection;
   return {
     ...latin ? { latin } : {},
-    ...ea ? { eastAsia: ea } : {},
-    ...cs ? { complexScript: cs } : {}
+    ...eastAsia ? { eastAsia } : {},
+    ...complexScript ? { complexScript } : {}
   };
 }
-function parseTheme(xml) {
-  const document = parseXml2(xml);
-  const root = document.documentElement;
-  const clrScheme = Array.from(root.getElementsByTagNameNS(DRAWING_NS, "clrScheme"))[0];
+function parseTheme2(xml) {
+  const theme = parseTheme(parseXml2(xml));
   const colors = {};
-  for (const slotName of SCHEME_ORDER) {
-    const slot2 = drawingChild(clrScheme, slotName);
-    const value = colorOf2(slot2);
-    if (value) colors[slotName] = value;
-  }
-  const fontScheme = Array.from(root.getElementsByTagNameNS(DRAWING_NS, "fontScheme"))[0];
-  const major = drawingChild(fontScheme, "majorFont");
-  const minor = drawingChild(fontScheme, "minorFont");
+  for (const slot2 of THEME_COLOR_SLOTS) {
+    const value = themeSlotHex(theme.colorScheme.colors[slot2]);
+    if (value) colors[slot2] = value;
+  }
+  const { major, minor } = theme.fontScheme;
   return { colors, colorMapping: {}, fonts: { major: fontSetOf(major), minor: fontSetOf(minor) } };
 }
 var MAPPING_KEYS = ["bg1", "tx1", "bg2", "tx2"];
@@ -9844,7 +11260,7 @@ async function readPackage(input) {
   const themeFile = zip.file("word/theme/theme1.xml");
   const settingsFile = zip.file("word/settings.xml");
   if (themeFile) {
-    model.theme = parseTheme(await themeFile.async("string"));
+    model.theme = parseTheme2(await themeFile.async("string"));
     if (settingsFile) {
       const settingsXml = await settingsFile.async("string");
       model.theme.colorMapping = withParseWarnings(
@@ -10019,7 +11435,7 @@ function readDocFib(wordDoc) {
   if (expectedCounts.get(nFib) !== fibRgFcLcbCount || cswNew !== 0 && cswNew !== (nFib === 274 ? 5 : 2))
     throw new Error("Word FIB version and array counts disagree");
   const ccpText = view.getInt32(fibRgLw97Offset + 12, true);
-  const otherStories = [4, 5, 7, 8, 9, 10].map((i) => view.getInt32(fibRgLw97Offset + i * 4, true));
+  const otherStories = [4, 5, 7, 8, 9, 10].map((i2) => view.getInt32(fibRgLw97Offset + i2 * 4, true));
   if (ccpText < 0 || otherStories.some((cp) => cp < 0))
     throw new Error("Negative Word story length");
   function fcLcbPair(index) {
@@ -10133,14 +11549,14 @@ function processCompoundFileStream(input, path, replacement) {
     };
     const fatCount = read32(44), difatCount = read32(72), difatStart = read32(68);
     const fatIds = [];
-    for (let i = 0; i < 109 && fatIds.length < fatCount; i++) {
-      const id = read32(76 + 4 * i);
+    for (let i2 = 0; i2 < 109 && fatIds.length < fatCount; i2++) {
+      const id = read32(76 + 4 * i2);
       if (id <= MAX)
         fatIds.push(id);
     }
     let difat = difatStart;
     const difatIds = /* @__PURE__ */ new Set();
-    for (let i = 0; i < difatCount; i++) {
+    for (let i2 = 0; i2 < difatCount; i2++) {
       if (difatIds.has(difat) || difat > MAX)
         return reject();
       difatIds.add(difat);
@@ -10163,7 +11579,7 @@ function processCompoundFileStream(input, path, replacement) {
     const exactChain = (table, start, bytes, unit) => chain(table, start, Math.ceil(bytes / unit));
     const dirStart = read32(48), dirSectors = chainToEnd(fat, dirStart, sectorCount);
     const dirBytes = new Uint8Array(dirSectors.length * sectorSize);
-    dirSectors.forEach((id, i) => dirBytes.set(sector(id), i * sectorSize));
+    dirSectors.forEach((id, i2) => dirBytes.set(sector(id), i2 * sectorSize));
     const dvDir = new DataView(dirBytes.buffer);
     const entries = [];
     for (let p = 0, id = 0; p + SIZE <= dirBytes.length; p += SIZE, id++) {
@@ -10174,8 +11590,8 @@ function processCompoundFileStream(input, path, replacement) {
       if (nameLength < 2 || nameLength > 64 || nameLength % 2)
         return reject();
       let name = "";
-      for (let i = 0; i < nameLength - 2; i += 2)
-        name += String.fromCharCode(dvDir.getUint16(p + i, true));
+      for (let i2 = 0; i2 < nameLength - 2; i2 += 2)
+        name += String.fromCharCode(dvDir.getUint16(p + i2, true));
       const sizeLow = dvDir.getUint32(p + 120, true), sizeHigh = dvDir.getUint32(p + 124, true);
       if (sizeHigh !== 0)
         return reject();
@@ -10290,19 +11706,19 @@ function processCompoundFileStream(input, path, replacement) {
       if (target.size >= miniCutoff) {
         const ids2 = exactChain(fat, target.start, target.size, sectorSize);
         const result2 = new Uint8Array(ids2.length * sectorSize);
-        ids2.forEach((id, i) => result2.set(sector(id), i * sectorSize));
+        ids2.forEach((id, i2) => result2.set(sector(id), i2 * sectorSize));
         return result2.slice(0, target.size);
       }
       const ids = exactChain(miniFat, target.start, target.size, miniSize);
       const rootSectors = exactChain(fat, rootMini.start, rootMini.size, sectorSize);
       const result = new Uint8Array(ids.length * miniSize);
-      ids.forEach((id, i) => {
+      ids.forEach((id, i2) => {
         const start = id * miniSize;
         if (start + miniSize > rootMini.size)
           throw new Error("Mini stream out of bounds");
         const rootSector = rootSectors[Math.floor(start / sectorSize)];
         const source = sector(rootSector).subarray(start % sectorSize, start % sectorSize + miniSize);
-        result.set(source, i * miniSize);
+        result.set(source, i2 * miniSize);
       });
       return result.slice(0, target.size);
     }
@@ -10312,8 +11728,8 @@ function processCompoundFileStream(input, path, replacement) {
     if (target.size >= miniCutoff) {
       const sectors = exactChain(fat, target.start, target.size, sectorSize);
       sectors.forEach((id) => sector(id));
-      for (let i = 0; i < sectors.length; i++)
-        output.set(replacement.subarray(i * sectorSize, Math.min((i + 1) * sectorSize, replacement.length)), offset(sectors[i]));
+      for (let i2 = 0; i2 < sectors.length; i2++)
+        output.set(replacement.subarray(i2 * sectorSize, Math.min((i2 + 1) * sectorSize, replacement.length)), offset(sectors[i2]));
     } else {
       if (!miniFat.length)
         return reject();
@@ -10322,9 +11738,9 @@ function processCompoundFileStream(input, path, replacement) {
       const rootSectors = exactChain(fat, rootMini2.start, rootMini2.size, sectorSize);
       rootSectors.forEach((id) => sector(id));
       const rootData = new Uint8Array(rootMini2.size);
-      rootSectors.forEach((id, i) => rootData.set(sector(id).subarray(0, Math.min(sectorSize, rootData.length - i * sectorSize)), i * sectorSize));
-      for (let i = 0; i < replacement.length; i++) {
-        const miniOffset = miniSectors[Math.floor(i / miniSize)] * miniSize + i % miniSize;
+      rootSectors.forEach((id, i2) => rootData.set(sector(id).subarray(0, Math.min(sectorSize, rootData.length - i2 * sectorSize)), i2 * sectorSize));
+      for (let i2 = 0; i2 < replacement.length; i2++) {
+        const miniOffset = miniSectors[Math.floor(i2 / miniSize)] * miniSize + i2 % miniSize;
         if (miniOffset >= rootData.length)
           return reject();
         const rootSectorIndex = Math.floor(miniOffset / sectorSize);
@@ -10332,7 +11748,7 @@ function processCompoundFileStream(input, path, replacement) {
         if (rootSector === void 0)
           return reject();
         const physical = offset(rootSector) + miniOffset % sectorSize;
-        output[physical] = replacement[i];
+        output[physical] = replacement[i2];
       }
     }
     return output;
@@ -10462,11 +11878,11 @@ function resizeCompoundFileStreamV4(input, path, replacement) {
     const sectorCount = input.length / SECTOR3 - 1, fatCount = read(44);
     if (sectorCount > fatCount * FAT_ENTRIES2)
       return fail("unsafe-edit");
-    const fatIds = Array.from({ length: fatCount }, (_, i) => read(76 + 4 * i));
+    const fatIds = Array.from({ length: fatCount }, (_, i2) => read(76 + 4 * i2));
     const fat = [];
     for (const id of fatIds) {
-      for (let i = 0; i < FAT_ENTRIES2 && fat.length < sectorCount; i++)
-        fat.push(read((id + 1) * SECTOR3 + i * 4));
+      for (let i2 = 0; i2 < FAT_ENTRIES2 && fat.length < sectorCount; i2++)
+        fat.push(read((id + 1) * SECTOR3 + i2 * 4));
     }
     if (fatIds.some((id) => fat[id] !== FAT))
       return fail("unsafe-edit");
@@ -10483,8 +11899,8 @@ function resizeCompoundFileStreamV4(input, path, replacement) {
         if (![1, 2, 5].includes(type) || nameLength < 2 || nameLength > 64 || nameLength % 2 || view.getUint16(offset + nameLength - 2, true))
           return fail("unsafe-edit");
         let name2 = "";
-        for (let i = 0; i < nameLength - 2; i += 2)
-          name2 += String.fromCharCode(view.getUint16(offset + i, true));
+        for (let i2 = 0; i2 < nameLength - 2; i2 += 2)
+          name2 += String.fromCharCode(view.getUint16(offset + i2, true));
         if (read(offset + 124) !== 0)
           return fail("unsafe-edit");
         const id = block * DIRECTORY_ENTRIES + entry;
@@ -10513,18 +11929,18 @@ function resizeCompoundFileStreamV4(input, path, replacement) {
     output.set(input);
     output.set(replacement, (sectorCount + 1) * SECTOR3);
     const outView = new DataView(output.buffer);
-    for (let i = fatCount; i < newFatCount; i++) {
-      const id = sectorCount + payloadSectors + i - fatCount;
+    for (let i2 = fatCount; i2 < newFatCount; i2++) {
+      const id = sectorCount + payloadSectors + i2 - fatCount;
       fatIds.push(id);
       output.fill(255, (id + 1) * SECTOR3, (id + 2) * SECTOR3);
-      outView.setUint32(76 + i * 4, id, true);
+      outView.setUint32(76 + i2 * 4, id, true);
     }
     outView.setUint32(44, newFatCount, true);
     const writeFat = (id, value) => outView.setUint32((fatIds[Math.floor(id / FAT_ENTRIES2)] + 1) * SECTOR3 + id % FAT_ENTRIES2 * 4, value, true);
     for (const id of oldChain)
       writeFat(id, FREE);
-    for (let i = 0; i < payloadSectors; i++)
-      writeFat(sectorCount + i, i + 1 === payloadSectors ? END2 : sectorCount + i + 1);
+    for (let i2 = 0; i2 < payloadSectors; i2++)
+      writeFat(sectorCount + i2, i2 + 1 === payloadSectors ? END2 : sectorCount + i2 + 1);
     for (const id of fatIds)
       writeFat(id, FAT);
     outView.setUint32(target.offset + 116, payloadSectors ? sectorCount : END2, true);
@@ -10550,11 +11966,11 @@ function appendCompoundAllocations(input, existingFatIds, payloads, sectorSize =
   const bytes = new Uint8Array((totalSectors + 1) * sectorSize);
   bytes.set(input);
   const view = new DataView(bytes.buffer), fatIds = [...existingFatIds];
-  for (let i = existingFatIds.length; i < fatCount; i++) {
-    const id = sectorCount + payloadSectors + i - existingFatIds.length;
+  for (let i2 = existingFatIds.length; i2 < fatCount; i2++) {
+    const id = sectorCount + payloadSectors + i2 - existingFatIds.length;
     fatIds.push(id);
     bytes.fill(255, (id + 1) * sectorSize, (id + 2) * sectorSize);
-    view.setUint32(76 + i * 4, id, true);
+    view.setUint32(76 + i2 * 4, id, true);
   }
   view.setUint32(44, fatCount, true);
   const writeFat = (id, value) => view.setUint32((fatIds[Math.floor(id / entriesPerFat)] + 1) * sectorSize + id % entriesPerFat * 4, value, true);
@@ -10562,8 +11978,8 @@ function appendCompoundAllocations(input, existingFatIds, payloads, sectorSize =
   let next = sectorCount;
   for (let payload = 0; payload < payloads.length; payload++) {
     bytes.set(payloads[payload], (next + 1) * sectorSize);
-    const chain2 = Array.from({ length: counts[payload] }, (_, i) => next + i);
-    chain2.forEach((id, i) => writeFat(id, chain2[i + 1] ?? 4294967294));
+    const chain2 = Array.from({ length: counts[payload] }, (_, i2) => next + i2);
+    chain2.forEach((id, i2) => writeFat(id, chain2[i2 + 1] ?? 4294967294));
     chains.push(chain2);
     next += counts[payload];
   }
@@ -10628,18 +12044,18 @@ function resizeMiniCompoundStream(input, fat, fatIds, root, target, replacement,
   const firstMini = Math.ceil(root.size / MINI), count = Math.ceil(replacement.length / MINI);
   const newRootSize = count ? (firstMini + count) * MINI : root.size;
   const newRoot = new Uint8Array(newRootSize);
-  rootSectors.forEach((id, i) => newRoot.set(input.subarray((id + 1) * SECTOR, (id + 1) * SECTOR + Math.min(SECTOR, root.size - i * SECTOR)), i * SECTOR));
+  rootSectors.forEach((id, i2) => newRoot.set(input.subarray((id + 1) * SECTOR, (id + 1) * SECTOR + Math.min(SECTOR, root.size - i2 * SECTOR)), i2 * SECTOR));
   if (count)
     newRoot.set(replacement, firstMini * MINI);
   const newMiniFatCount = Math.max(miniFatCount, Math.ceil((firstMini + count) / 128));
   const newMiniFat = new Uint8Array(newMiniFatCount * SECTOR).fill(255);
-  miniFatSectors.forEach((id, i) => newMiniFat.set(input.subarray((id + 1) * SECTOR, (id + 2) * SECTOR), i * SECTOR));
+  miniFatSectors.forEach((id, i2) => newMiniFat.set(input.subarray((id + 1) * SECTOR, (id + 2) * SECTOR), i2 * SECTOR));
   const miniView = new DataView(newMiniFat.buffer);
   if (wasMini)
     for (const id of oldChain)
       miniView.setUint32(id * 4, FREE2, true);
-  for (let i = 0; i < count; i++)
-    miniView.setUint32((firstMini + i) * 4, i + 1 === count ? END3 : firstMini + i + 1, true);
+  for (let i2 = 0; i2 < count; i2++)
+    miniView.setUint32((firstMini + i2) * 4, i2 + 1 === count ? END3 : firstMini + i2 + 1, true);
   const output = appendCompoundAllocations(input, fatIds, [newRoot, newMiniFat]);
   if (!output)
     return void 0;
@@ -10767,11 +12183,11 @@ function resizeCompoundFileStream(input, path, replacement) {
     const sectorCount = input.length / SECTOR2 - 1, fatCount = read(44);
     if (sectorCount > fatCount * FAT_ENTRIES)
       return fail("unsafe-edit");
-    const fatIds = Array.from({ length: fatCount }, (_, i) => read(76 + 4 * i));
+    const fatIds = Array.from({ length: fatCount }, (_, i2) => read(76 + 4 * i2));
     const fat = [];
     for (const id of fatIds) {
-      for (let i = 0; i < FAT_ENTRIES && fat.length < sectorCount; i++)
-        fat.push(read((id + 1) * SECTOR2 + i * 4));
+      for (let i2 = 0; i2 < FAT_ENTRIES && fat.length < sectorCount; i2++)
+        fat.push(read((id + 1) * SECTOR2 + i2 * 4));
     }
     if (fatIds.some((id) => fat[id] !== FAT2))
       return fail("unsafe-edit");
@@ -10785,8 +12201,8 @@ function resizeCompoundFileStream(input, path, replacement) {
         if (![1, 2, 5].includes(type) || nameLength < 2 || nameLength > 64 || nameLength % 2 || view.getUint16(offset + nameLength - 2, true))
           return fail("unsafe-edit");
         let name2 = "";
-        for (let i = 0; i < nameLength - 2; i += 2)
-          name2 += String.fromCharCode(view.getUint16(offset + i, true));
+        for (let i2 = 0; i2 < nameLength - 2; i2 += 2)
+          name2 += String.fromCharCode(view.getUint16(offset + i2, true));
         const id = block * 4 + entry;
         slots.set(id, { id, name: name2, type, left: read(offset + 68), right: read(offset + 72), child: read(offset + 76), start: read(offset + 116), size: read(offset + 120), offset });
       }
@@ -10853,7 +12269,7 @@ function unwrapDocBytes(bytes) {
           const patchedWord = replaceCompoundFileStream(bytes, ["WordDocument"], editedWordDocBytes);
           if (patchedWord === bytes)
             throw new DocCfbRewriteError("Cannot safely patch WordDocument");
-          if (editedTableBytes.every((value, i) => value === tableBytes[i]))
+          if (editedTableBytes.every((value, i2) => value === tableBytes[i2]))
             return patchedWord;
           const patchedTable = replaceCompoundFileStream(patchedWord, [fib.tableStreamName], editedTableBytes);
           if (patchedTable === patchedWord)
@@ -10882,15 +12298,15 @@ function parseBteTable(tableStream, at) {
     throw new Error("Invalid BTE table bounds");
   const n = (at.lcb - 4) / 8;
   const fcs = [];
-  for (let i = 0; i <= n; i++) {
-    const fc = view.getInt32(at.fc + i * 4, true);
-    if (fc < 0 || i > 0 && fc <= fcs[i - 1])
+  for (let i2 = 0; i2 <= n; i2++) {
+    const fc = view.getInt32(at.fc + i2 * 4, true);
+    if (fc < 0 || i2 > 0 && fc <= fcs[i2 - 1])
       throw new Error("Invalid BTE FC boundaries");
     fcs.push(fc);
   }
   const pns = [];
-  for (let i = 0; i < n; i++) {
-    pns.push(view.getUint32(at.fc + (n + 1) * 4 + i * 4, true));
+  for (let i2 = 0; i2 < n; i2++) {
+    pns.push(view.getUint32(at.fc + (n + 1) * 4 + i2 * 4, true));
   }
   return { fcs, pns };
 }
@@ -10898,11 +12314,11 @@ function buildBteTableBytes(table) {
   const n = table.pns.length;
   const bytes = new Uint8Array((n + 1) * 4 + n * 4);
   const view = new DataView(bytes.buffer);
-  for (let i = 0; i <= n; i++) {
-    view.setInt32(i * 4, table.fcs[i], true);
+  for (let i2 = 0; i2 <= n; i2++) {
+    view.setInt32(i2 * 4, table.fcs[i2], true);
   }
-  for (let i = 0; i < n; i++) {
-    view.setUint32((n + 1) * 4 + i * 4, table.pns[i], true);
+  for (let i2 = 0; i2 < n; i2++) {
+    view.setUint32((n + 1) * 4 + i2 * 4, table.pns[i2], true);
   }
   return bytes;
 }
@@ -10940,11 +12356,11 @@ function extractPapxBlob(wordDoc, papxBte, fc) {
     throw new Error("Invalid PAPX run count");
   const pageView = new DataView(page.buffer, page.byteOffset, page.byteLength);
   const rgbxOffset = (crun + 1) * 4;
-  for (let i = 0; i < crun; i++) {
-    const runFcStart = pageView.getInt32(i * 4, true);
-    const runFcEnd = pageView.getInt32((i + 1) * 4, true);
+  for (let i2 = 0; i2 < crun; i2++) {
+    const runFcStart = pageView.getInt32(i2 * 4, true);
+    const runFcEnd = pageView.getInt32((i2 + 1) * 4, true);
     if (fc >= runFcStart && fc < runFcEnd) {
-      const bOffsetWord = page[rgbxOffset + i * 13];
+      const bOffsetWord = page[rgbxOffset + i2 * 13];
       if (bOffsetWord === 0)
         return new Uint8Array();
       const blobOffset = bOffsetWord * 2;
@@ -10967,11 +12383,11 @@ function extractChpxBlob(wordDoc, chpxBte, fc) {
     throw new Error("Invalid CHPX run count");
   const pageView = new DataView(page.buffer, page.byteOffset, page.byteLength);
   const rgbOffset = (crun + 1) * 4;
-  for (let i = 0; i < crun; i++) {
-    const runFcStart = pageView.getInt32(i * 4, true);
-    const runFcEnd = pageView.getInt32((i + 1) * 4, true);
+  for (let i2 = 0; i2 < crun; i2++) {
+    const runFcStart = pageView.getInt32(i2 * 4, true);
+    const runFcEnd = pageView.getInt32((i2 + 1) * 4, true);
     if (fc >= runFcStart && fc < runFcEnd) {
-      const bOffsetWord = page[rgbOffset + i];
+      const bOffsetWord = page[rgbOffset + i2];
       if (bOffsetWord === 0) {
         return new Uint8Array(0);
       }
@@ -11050,7 +12466,7 @@ var CP1252_HIGH_BLOCK = [
   382,
   376
 ];
-var CP1252_HIGH_BLOCK_REVERSE = new Map(CP1252_HIGH_BLOCK.map((codePoint, i) => [codePoint, 128 + i]));
+var CP1252_HIGH_BLOCK_REVERSE = new Map(CP1252_HIGH_BLOCK.map((codePoint, i2) => [codePoint, 128 + i2]));
 function decodeCp1252Byte(byte) {
   if (byte >= 128 && byte <= 159) {
     return CP1252_HIGH_BLOCK[byte - 128];
@@ -11135,16 +12551,16 @@ function parseDocClx(tableStream, clx, maxPieces) {
 function parsePlcPcd(view, plcStart, lcb) {
   const n = Math.floor((lcb - 4) / (4 + 8));
   const cps = [];
-  for (let i = 0; i <= n; i++) {
-    const cp = view.getInt32(plcStart + i * 4, true);
-    if (i === 0 && cp !== 0 || i > 0 && cp <= cps[i - 1])
+  for (let i2 = 0; i2 <= n; i2++) {
+    const cp = view.getInt32(plcStart + i2 * 4, true);
+    if (i2 === 0 && cp !== 0 || i2 > 0 && cp <= cps[i2 - 1])
       throw new Error("Piece CPs must start at zero and increase");
     cps.push(cp);
   }
   const pcdStart = plcStart + (n + 1) * 4;
   const pieces = [];
-  for (let i = 0; i < n; i++) {
-    const pOff = pcdStart + i * 8;
+  for (let i2 = 0; i2 < n; i2++) {
+    const pOff = pcdStart + i2 * 8;
     const flagsWord = view.getUint16(pOff, true);
     const fcRaw = view.getUint32(pOff + 2, true);
     if ((fcRaw & 2147483648) !== 0)
@@ -11153,8 +12569,8 @@ function parsePlcPcd(view, plcStart, lcb) {
     const compressed = (fcRaw >>> 30 & 1) === 1;
     const fcField = fcRaw & 1073741823;
     pieces.push({
-      cpStart: cps[i],
-      cpEnd: cps[i + 1],
+      cpStart: cps[i2],
+      cpEnd: cps[i2 + 1],
       fc: compressed ? fcField >>> 1 : fcField,
       compressed,
       flagsWord,
@@ -11173,8 +12589,8 @@ function decodePieceText(wordDoc, piece) {
   }
   const view = new DataView(wordDoc.buffer, wordDoc.byteOffset, wordDoc.byteLength);
   let out = "";
-  for (let i = 0; i < charLen; i++) {
-    out += String.fromCharCode(view.getUint16(piece.fc + i * 2, true));
+  for (let i2 = 0; i2 < charLen; i2++) {
+    out += String.fromCharCode(view.getUint16(piece.fc + i2 * 2, true));
   }
   return out;
 }
@@ -11199,8 +12615,8 @@ function encodePieceText(text) {
   }
   const bytes = new Uint8Array(text.length * 2);
   const view = new DataView(bytes.buffer);
-  for (let i = 0; i < text.length; i++) {
-    view.setUint16(i * 2, text.charCodeAt(i), true);
+  for (let i2 = 0; i2 < text.length; i2++) {
+    view.setUint16(i2 * 2, text.charCodeAt(i2), true);
   }
   return { bytes, compressed: false };
 }
@@ -11347,9 +12763,9 @@ function shiftDocMainFieldCps(table, at, body, editStart, editEnd, delta, maxFie
   const view = new DataView(source.buffer, source.byteOffset, source.byteLength);
   const markers = [];
   let previous = -1;
-  for (let i = 0; i < n; i++) {
-    const cp = view.getInt32(i * 4, true);
-    const ch = source[(n + 1) * 4 + i * 2] & 31;
+  for (let i2 = 0; i2 < n; i2++) {
+    const cp = view.getInt32(i2 * 4, true);
+    const ch = source[(n + 1) * 4 + i2 * 2] & 31;
     if (cp <= previous || cp >= body.length || ![19, 20, 21].includes(ch) || body.charCodeAt(cp) !== ch)
       throw new Error("Invalid main-story field marker");
     markers.push({ cp, ch });
@@ -11362,12 +12778,12 @@ function shiftDocMainFieldCps(table, at, body, editStart, editEnd, delta, maxFie
   const result = source.slice();
   const out = new DataView(result.buffer);
   let shiftedLast = -1;
-  for (let i = 0; i < n; i++) {
-    const cp = markers[i].cp;
+  for (let i2 = 0; i2 < n; i2++) {
+    const cp = markers[i2].cp;
     const shifted = cp >= editEnd ? cp + delta : cp;
     if (shifted < 0 || shifted >= body.length + delta || shifted <= shiftedLast)
       throw new Error("Field position shifts outside the main story");
-    out.setInt32(i * 4, shifted, true);
+    out.setInt32(i2 * 4, shifted, true);
     shiftedLast = shifted;
   }
   let shiftedSentinel = sentinel >= editEnd ? sentinel + delta : sentinel;
@@ -11426,9 +12842,9 @@ function pieceAndFcAtCp(pieces, cp) {
 }
 function paragraphBoundaries(bodyText) {
   const boundaries = [];
-  for (let i = 0; i < bodyText.length; i++) {
-    if (bodyText[i] === "\r") {
-      boundaries.push(i + 1);
+  for (let i2 = 0; i2 < bodyText.length; i2++) {
+    if (bodyText[i2] === "\r") {
+      boundaries.push(i2 + 1);
     }
   }
   if (boundaries[boundaries.length - 1] !== bodyText.length && bodyText.length > 0) {
@@ -11439,8 +12855,8 @@ function paragraphBoundaries(bodyText) {
 function encodePieceTextUtf16(text) {
   const bytes = new Uint8Array(text.length * 2);
   const view = new DataView(bytes.buffer);
-  for (let i = 0; i < text.length; i++)
-    view.setUint16(i * 2, text.charCodeAt(i), true);
+  for (let i2 = 0; i2 < text.length; i2++)
+    view.setUint16(i2 * 2, text.charCodeAt(i2), true);
   return bytes;
 }
 function readOleDocParagraphs(docBytes, limits) {
@@ -11479,8 +12895,8 @@ function shiftSectionTableCps(tableBytes, sed, editEndCp, delta) {
   if (sed.lcb < 4 || (sed.lcb - 4) % 16 !== 0 || sed.fc > tableBytes.length - sed.lcb)
     throw new Error("Invalid section table");
   const n = (sed.lcb - 4) / 16;
-  for (let i = 0; i <= n; i++) {
-    const off = sed.fc + i * 4;
+  for (let i2 = 0; i2 <= n; i2++) {
+    const off = sed.fc + i2 * 4;
     const cp = view.getInt32(off, true);
     if (cp >= editEndCp) {
       view.setInt32(off, cp + delta, true);
@@ -11754,13 +13170,13 @@ async function loadLegacyDoc(input) {
           "Adding or removing paragraphs in legacy .doc files is unsupported."
         );
       let output = original;
-      for (let i = 0; i < updated.length; i++) {
-        if (updated[i] === paragraphs[i]) continue;
-        if (/[\r\n]/u.test(updated[i]))
+      for (let i2 = 0; i2 < updated.length; i2++) {
+        if (updated[i2] === paragraphs[i2]) continue;
+        if (/[\r\n]/u.test(updated[i2]))
           throw new LegacyDocError(
             "Adding line breaks in legacy .doc paragraph text is unsupported."
           );
-        const result = writeOleDocParagraphEdit(output, i, updated[i]);
+        const result = writeOleDocParagraphEdit(output, i2, updated[i2]);
         if (result === output)
           throw new LegacyDocError(
             "This .doc uses structures that prevent safe paragraph text editing."