ooxml-core 0.9.0 → 0.10.0

package/dist/crypto/index.cjs

@@ -0,0 +1,1805 @@
+'use strict';
+
+// node_modules/.bun/@christophervr+ole2@0.4.0/node_modules/@christophervr/ole2/dist/ole2-parser-types.js
+var OLE_MAGIC = new Uint8Array([208, 207, 17, 224, 161, 177, 26, 225]);
+var ENDOFCHAIN = 4294967294;
+var FREESECT = 4294967295;
+var FATSECT = 4294967293;
+var DIFSECT = 4294967292;
+var MAXREGSECT = 4294967290;
+var ENTRY_TYPE_EMPTY = 0;
+var ENTRY_TYPE_STREAM = 2;
+var ENTRY_TYPE_ROOT = 5;
+var DIR_ENTRY_SIZE = 128;
+var Ole2ParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "Ole2ParseError";
+  }
+};
+
+// node_modules/.bun/@christophervr+ole2@0.4.0/node_modules/@christophervr/ole2/dist/ole2-parser-read.js
+function parseOle2(buffer) {
+  const data = new Uint8Array(buffer);
+  const view = new DataView(buffer);
+  for (let i = 0; i < OLE_MAGIC.length; i++) {
+    if (data[i] !== OLE_MAGIC[i]) {
+      throw new Ole2ParseError("Not a valid OLE2 compound file");
+    }
+  }
+  view.getUint16(24, true);
+  const majorVersion = view.getUint16(26, true);
+  const byteOrder = view.getUint16(28, true);
+  if (byteOrder !== 65534) {
+    throw new Ole2ParseError("Invalid byte order mark");
+  }
+  const sectorSizePower = view.getUint16(30, true);
+  const miniSectorSizePower = view.getUint16(32, true);
+  const sectorSize = 1 << sectorSizePower;
+  const miniSectorSize = 1 << miniSectorSizePower;
+  const totalFATSectors = view.getUint32(44, true);
+  const firstDirectorySector = view.getUint32(48, true);
+  const miniStreamCutoff = view.getUint32(56, true);
+  const firstMiniFATSector = view.getUint32(60, true);
+  const totalMiniFATSectors = view.getUint32(64, true);
+  const firstDIFATSector = view.getUint32(68, true);
+  const totalDIFATSectors = view.getUint32(72, true);
+  function sectorOffset(sector) {
+    return (sector + 1) * sectorSize;
+  }
+  function readSector(sector) {
+    const offset = sectorOffset(sector);
+    if (offset + sectorSize > data.length) {
+      throw new Ole2ParseError(`Sector ${sector} at offset ${offset} exceeds file size ${data.length}`);
+    }
+    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);
+    if (sector <= MAXREGSECT) {
+      fatSectors.push(sector);
+    }
+  }
+  let difatSector = firstDIFATSector;
+  for (let d = 0; d < totalDIFATSectors && difatSector <= MAXREGSECT; d++) {
+    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);
+      if (sector <= MAXREGSECT) {
+        fatSectors.push(sector);
+      }
+    }
+    difatSector = difatView.getUint32(sectorSize - 4, true);
+  }
+  const fatEntries = [];
+  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; i++) {
+      fatEntries.push(fatView.getUint32(i * 4, true));
+    }
+  }
+  function readSectorChain(startSector) {
+    const sectors = [];
+    let current = startSector;
+    const visited = /* @__PURE__ */ new Set();
+    while (current <= MAXREGSECT) {
+      if (visited.has(current)) {
+        throw new Ole2ParseError(`Circular reference in FAT chain at sector ${current}`);
+      }
+      visited.add(current);
+      sectors.push(readSector(current));
+      current = fatEntries[current] ?? ENDOFCHAIN;
+    }
+    const totalLength = sectors.length * sectorSize;
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const sector of sectors) {
+      result.set(sector, offset);
+      offset += sectorSize;
+    }
+    return result;
+  }
+  function readStream(startSector, size) {
+    const raw = readSectorChain(startSector);
+    return raw.subarray(0, Math.min(size, raw.length));
+  }
+  const miniFatEntries = [];
+  if (firstMiniFATSector <= MAXREGSECT && totalMiniFATSectors > 0) {
+    const miniFatRaw = readSectorChain(firstMiniFATSector);
+    const miniFatView = new DataView(miniFatRaw.buffer, miniFatRaw.byteOffset, miniFatRaw.byteLength);
+    for (let i = 0; i < miniFatRaw.length / 4; i++) {
+      miniFatEntries.push(miniFatView.getUint32(i * 4, true));
+    }
+  }
+  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;
+    const entryView = new DataView(dirRaw.buffer, dirRaw.byteOffset + entryOffset, DIR_ENTRY_SIZE);
+    const nameLen = entryView.getUint16(64, true);
+    const objectType = entryView.getUint8(66);
+    if (objectType === ENTRY_TYPE_EMPTY) {
+      continue;
+    }
+    const nameBytes = Math.max(0, nameLen - 2);
+    let name = "";
+    for (let j = 0; j < nameBytes; j += 2) {
+      name += String.fromCharCode(entryView.getUint16(j, true));
+    }
+    const leftSiblingId = entryView.getUint32(68, true);
+    const rightSiblingId = entryView.getUint32(72, true);
+    const childId = entryView.getUint32(76, true);
+    const clsid = new Uint8Array(entryView.buffer.slice(entryView.byteOffset + 80, entryView.byteOffset + 96));
+    const startSector = entryView.getUint32(116, true);
+    const sizeLow = entryView.getUint32(120, true);
+    let size = sizeLow;
+    if (majorVersion === 4) {
+      entryView.getUint32(124, true);
+      size = sizeLow;
+    }
+    entries.push({
+      name,
+      type: objectType,
+      startSector,
+      size,
+      childId: childId === 4294967295 ? -1 : childId,
+      leftSiblingId: leftSiblingId === 4294967295 ? -1 : leftSiblingId,
+      rightSiblingId: rightSiblingId === 4294967295 ? -1 : rightSiblingId,
+      clsid
+    });
+  }
+  const rootEntry = entries.find((e) => e.type === ENTRY_TYPE_ROOT);
+  let miniStreamData;
+  if (rootEntry && rootEntry.startSector <= MAXREGSECT) {
+    miniStreamData = readSectorChain(rootEntry.startSector);
+  }
+  function readMiniStream(startSector, size) {
+    if (!miniStreamData) {
+      throw new Ole2ParseError("Mini stream container not found");
+    }
+    const sectors = [];
+    let current = startSector;
+    const visited = /* @__PURE__ */ new Set();
+    while (current <= MAXREGSECT) {
+      if (visited.has(current)) {
+        throw new Ole2ParseError(`Circular reference in mini FAT chain at sector ${current}`);
+      }
+      visited.add(current);
+      const offset2 = current * miniSectorSize;
+      sectors.push(miniStreamData.subarray(offset2, offset2 + miniSectorSize));
+      current = miniFatEntries[current] ?? ENDOFCHAIN;
+    }
+    const totalLength = sectors.length * miniSectorSize;
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const sector of sectors) {
+      result.set(sector, offset);
+      offset += miniSectorSize;
+    }
+    return result.subarray(0, Math.min(size, result.length));
+  }
+  function getStream(name) {
+    const entry = entries.find((e) => (e.type === ENTRY_TYPE_STREAM || e.type === ENTRY_TYPE_ROOT) && e.name === name);
+    if (!entry) {
+      return void 0;
+    }
+    if (entry.size < miniStreamCutoff && entry.type !== ENTRY_TYPE_ROOT) {
+      return readMiniStream(entry.startSector, entry.size);
+    }
+    return readStream(entry.startSector, entry.size);
+  }
+  return { entries, getStream };
+}
+
+// node_modules/.bun/@christophervr+ole2@0.4.0/node_modules/@christophervr/ole2/dist/utils/ooxml-crypto-primitives.js
+function getSubtle() {
+  if (typeof globalThis.crypto !== "undefined" && globalThis.crypto.subtle) {
+    return globalThis.crypto.subtle;
+  }
+  throw new Error("Web Crypto API (crypto.subtle) is not available in this environment. Password-protected PPTX files require a runtime with Web Crypto support.");
+}
+function getCrypto() {
+  if (typeof globalThis.crypto !== "undefined") {
+    return globalThis.crypto;
+  }
+  throw new Error("crypto API is not available in this environment.");
+}
+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;
+  }
+  return buf;
+}
+function concatArrays(...arrays) {
+  let totalLength = 0;
+  for (const arr of arrays) {
+    totalLength += arr.length;
+  }
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
+function uint32LE(value) {
+  const buf = new Uint8Array(4);
+  const view = new DataView(buf.buffer);
+  view.setUint32(0, value, true);
+  return buf;
+}
+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);
+  }
+  return bytes;
+}
+function base64Encode(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function mapHashAlgorithm(algorithm) {
+  const upper = algorithm.toUpperCase().replace(/-/g, "");
+  switch (upper) {
+    case "SHA1":
+      return "SHA-1";
+    case "SHA256":
+      return "SHA-256";
+    case "SHA384":
+      return "SHA-384";
+    case "SHA512":
+      return "SHA-512";
+    default:
+      return algorithm;
+  }
+}
+async function hash(algorithm, data) {
+  const subtle = getSubtle();
+  const webCryptoAlg = mapHashAlgorithm(algorithm);
+  const result = await subtle.digest(webCryptoAlg, data);
+  return new Uint8Array(result);
+}
+async function aesCbcDecryptRaw(key, iv, data) {
+  const subtle = getSubtle();
+  const blockSize = 16;
+  if (data.length % blockSize !== 0) {
+    const padded = new Uint8Array(Math.ceil(data.length / blockSize) * blockSize);
+    padded.set(data);
+    data = padded;
+  }
+  if (data.length === 0) {
+    return new Uint8Array(0);
+  }
+  const cryptoKey = await subtle.importKey("raw", key, { name: "AES-CBC" }, false, ["encrypt", "decrypt"]);
+  const lastCiphertextBlock = data.subarray(data.length - blockSize);
+  const paddingPlaintext = new Uint8Array(blockSize);
+  paddingPlaintext.fill(blockSize);
+  const encryptedPadding = await subtle.encrypt({ name: "AES-CBC", iv: lastCiphertextBlock }, cryptoKey, paddingPlaintext);
+  const encPadBlock = new Uint8Array(encryptedPadding).subarray(0, blockSize);
+  const paddedData = new Uint8Array(data.length + blockSize);
+  paddedData.set(data);
+  paddedData.set(encPadBlock, data.length);
+  const result = await subtle.decrypt({ name: "AES-CBC", iv }, cryptoKey, paddedData);
+  return new Uint8Array(result).subarray(0, data.length);
+}
+async function aesCbcEncryptNoPad(key, iv, data) {
+  const blockSize = 16;
+  if (data.length % blockSize !== 0) {
+    throw new Error("Data must be block-aligned for no-padding encryption");
+  }
+  const subtle = getSubtle();
+  const cryptoKey = await subtle.importKey("raw", key, { name: "AES-CBC" }, false, ["encrypt"]);
+  const result = await subtle.encrypt({ name: "AES-CBC", iv }, cryptoKey, data);
+  return new Uint8Array(result).subarray(0, data.length);
+}
+async function hmac(algorithm, key, data) {
+  const subtle = getSubtle();
+  const webCryptoAlg = mapHashAlgorithm(algorithm);
+  const cryptoKey = await subtle.importKey("raw", key, { name: "HMAC", hash: webCryptoAlg }, false, ["sign"]);
+  const result = await subtle.sign("HMAC", cryptoKey, data);
+  return new Uint8Array(result);
+}
+
+// src/crypto/aes-ecb.ts
+var BLOCK = 16;
+var BATCH = 4096;
+async function aesEcbDecrypt(key, data) {
+  const plain = await aesCbcDecryptRaw(key, new Uint8Array(BLOCK), data);
+  for (let at = BLOCK; at < plain.length && at < data.length; at++) {
+    plain[at] = plain[at] ^ data[at - BLOCK];
+  }
+  return plain;
+}
+async function aesEcbEncrypt(key, data) {
+  const padded = new Uint8Array(Math.ceil(data.length / BLOCK) * BLOCK);
+  padded.set(data);
+  const subtle = getSubtle();
+  const cryptoKey = await subtle.importKey("raw", key, { name: "AES-CBC" }, false, [
+    "encrypt"
+  ]);
+  const iv = new Uint8Array(BLOCK);
+  const out = new Uint8Array(padded.length);
+  for (let start = 0; start < padded.length; start += BLOCK * BATCH) {
+    const end = Math.min(padded.length, start + BLOCK * BATCH);
+    const jobs = [];
+    for (let at = start; at < end; at += BLOCK) {
+      const block = padded.slice(at, at + BLOCK);
+      jobs.push(
+        subtle.encrypt({ name: "AES-CBC", iv }, cryptoKey, block).then((result) => {
+          out.set(new Uint8Array(result, 0, BLOCK), at);
+        })
+      );
+    }
+    await Promise.all(jobs);
+  }
+  return out;
+}
+
+// src/crypto/errors.ts
+var PasswordRequiredError = class extends Error {
+  code = "password-required";
+  constructor(message = "This file is password protected. Enter the password to open it.") {
+    super(message);
+    this.name = "PasswordRequiredError";
+  }
+};
+var IncorrectPasswordError = class extends Error {
+  code = "incorrect-password";
+  constructor(message = "The password is incorrect.") {
+    super(message);
+    this.name = "IncorrectPasswordError";
+  }
+};
+var DataIntegrityError = class extends Error {
+  code = "data-integrity";
+  constructor(message = "Data integrity check failed. The encrypted file may be corrupted or tampered with.") {
+    super(message);
+    this.name = "DataIntegrityError";
+  }
+};
+function isOoxmlCryptoError(error) {
+  if (!(error instanceof Error)) return false;
+  const code = error.code;
+  return code === "password-required" || code === "incorrect-password" || code === "data-integrity";
+}
+
+// src/digest/algorithm-names.ts
+var CANONICAL_BY_LOOKUP_KEY = {
+  SHA1: "SHA-1",
+  SHA256: "SHA-256",
+  SHA384: "SHA-384",
+  SHA512: "SHA-512",
+  MD2: "MD2",
+  MD4: "MD4",
+  MD5: "MD5",
+  RIPEMD128: "RIPEMD-128",
+  RIPEMD160: "RIPEMD-160",
+  WHIRLPOOL: "WHIRLPOOL"
+};
+function normalizeDigestAlgorithmName(name) {
+  const key = name.toUpperCase().replace(/[-_\s]/g, "");
+  return Object.hasOwn(CANONICAL_BY_LOOKUP_KEY, key) ? CANONICAL_BY_LOOKUP_KEY[key] : void 0;
+}
+
+// src/digest/sha256.ts
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var IV = [
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+];
+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];
+    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;
+  }
+  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++) {
+    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 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;
+    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;
+}
+function pad64(data) {
+  const padded = new Uint8Array(Math.ceil((data.length + 9) / 64) * 64);
+  padded.set(data);
+  padded[data.length] = 128;
+  const bits = data.length * 8;
+  const view = new DataView(padded.buffer);
+  view.setUint32(padded.length - 8, Math.floor(bits / 4294967296));
+  view.setUint32(padded.length - 4, bits >>> 0);
+  return view;
+}
+function wordsOut(h) {
+  const out = new Uint8Array(h.length * 4);
+  const view = new DataView(out.buffer);
+  for (let i = 0; i < h.length; i++) view.setUint32(i * 4, h[i]);
+  return out;
+}
+function sha256(data) {
+  const h = new Uint32Array(IV);
+  const view = pad64(data);
+  for (let offset = 0; offset < view.byteLength; offset += 64) compress(h, view, offset);
+  return wordsOut(h);
+}
+
+// src/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;
+    let k;
+    if (i < 20) {
+      f = b & c | ~b & d;
+      k = 1518500249;
+    } else if (i < 40) {
+      f = b ^ c ^ d;
+      k = 1859775393;
+    } else if (i < 60) {
+      f = b & c | b & d | c & d;
+      k = 2400959708;
+    } else {
+      f = b ^ c ^ d;
+      k = 3395469782;
+    }
+    const t = rotl(a, 5) + f + e + k + W2[i] >>> 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;
+}
+function sha1(data) {
+  const h = 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);
+}
+
+// src/digest/sha512.ts
+var K2 = new Uint32Array([
+  1116352408,
+  3609767458,
+  1899447441,
+  602891725,
+  3049323471,
+  3964484399,
+  3921009573,
+  2173295548,
+  961987163,
+  4081628472,
+  1508970993,
+  3053834265,
+  2453635748,
+  2937671579,
+  2870763221,
+  3664609560,
+  3624381080,
+  2734883394,
+  310598401,
+  1164996542,
+  607225278,
+  1323610764,
+  1426881987,
+  3590304994,
+  1925078388,
+  4068182383,
+  2162078206,
+  991336113,
+  2614888103,
+  633803317,
+  3248222580,
+  3479774868,
+  3835390401,
+  2666613458,
+  4022224774,
+  944711139,
+  264347078,
+  2341262773,
+  604807628,
+  2007800933,
+  770255983,
+  1495990901,
+  1249150122,
+  1856431235,
+  1555081692,
+  3175218132,
+  1996064986,
+  2198950837,
+  2554220882,
+  3999719339,
+  2821834349,
+  766784016,
+  2952996808,
+  2566594879,
+  3210313671,
+  3203337956,
+  3336571891,
+  1034457026,
+  3584528711,
+  2466948901,
+  113926993,
+  3758326383,
+  338241895,
+  168717936,
+  666307205,
+  1188179964,
+  773529912,
+  1546045734,
+  1294757372,
+  1522805485,
+  1396182291,
+  2643833823,
+  1695183700,
+  2343527390,
+  1986661051,
+  1014477480,
+  2177026350,
+  1206759142,
+  2456956037,
+  344077627,
+  2730485921,
+  1290863460,
+  2820302411,
+  3158454273,
+  3259730800,
+  3505952657,
+  3345764771,
+  106217008,
+  3516065817,
+  3606008344,
+  3600352804,
+  1432725776,
+  4094571909,
+  1467031594,
+  275423344,
+  851169720,
+  430227734,
+  3100823752,
+  506948616,
+  1363258195,
+  659060556,
+  3750685593,
+  883997877,
+  3785050280,
+  958139571,
+  3318307427,
+  1322822218,
+  3812723403,
+  1537002063,
+  2003034995,
+  1747873779,
+  3602036899,
+  1955562222,
+  1575990012,
+  2024104815,
+  1125592928,
+  2227730452,
+  2716904306,
+  2361852424,
+  442776044,
+  2428436474,
+  593698344,
+  2756734187,
+  3733110249,
+  3204031479,
+  2999351573,
+  3329325298,
+  3815920427,
+  3391569614,
+  3928383900,
+  3515267271,
+  566280711,
+  3940187606,
+  3454069534,
+  4118630271,
+  4000239992,
+  116418474,
+  1914138554,
+  174292421,
+  2731055270,
+  289380356,
+  3203993006,
+  460393269,
+  320620315,
+  685471733,
+  587496836,
+  852142971,
+  1086792851,
+  1017036298,
+  365543100,
+  1126000580,
+  2618297676,
+  1288033470,
+  3409855158,
+  1501505948,
+  4234509866,
+  1607167915,
+  987167468,
+  1816402316,
+  1246189591
+]);
+var IV_512 = [
+  1779033703,
+  4089235720,
+  3144134277,
+  2227873595,
+  1013904242,
+  4271175723,
+  2773480762,
+  1595750129,
+  1359893119,
+  2917565137,
+  2600822924,
+  725511199,
+  528734635,
+  4215389547,
+  1541459225,
+  327033209
+];
+var IV_384 = [
+  3418070365,
+  3238371032,
+  1654270250,
+  914150663,
+  2438529370,
+  812702999,
+  355462360,
+  4144912697,
+  1731405415,
+  4290775857,
+  2394180231,
+  1750603025,
+  3675008525,
+  1694076839,
+  1203062813,
+  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];
+    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 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);
+    lo >>>= 0;
+    W3[i * 2] = hi >>> 0;
+    W3[i * 2 + 1] = lo;
+  }
+  let ah = h[0], al = h[1], bh = h[2], bl = h[3], ch = h[4], cl = h[5], dh = h[6], dl = h[7];
+  let eh = h[8], el = h[9], fh = h[10], fl = h[11], gh = h[12], gl = h[13], hh = h[14], hl = h[15];
+  for (let i = 0; i < 80; i++) {
+    const S1h = (eh >>> 14 | el << 18) ^ (eh >>> 18 | el << 14) ^ (el >>> 9 | eh << 23);
+    const S1l = (el >>> 14 | eh << 18) ^ (el >>> 18 | eh << 14) ^ (eh >>> 9 | el << 23);
+    const chh = eh & fh ^ ~eh & gh;
+    const chl = el & fl ^ ~el & gl;
+    let t1l = (hl >>> 0) + (S1l >>> 0) + (chl >>> 0) + K2[i * 2 + 1] + W3[i * 2 + 1];
+    const t1h = hh + S1h + chh + K2[i * 2] + W3[i * 2] + Math.floor(t1l / 4294967296);
+    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);
+    const majh = ah & bh ^ ah & ch ^ bh & ch;
+    const majl = al & bl ^ al & cl ^ bl & cl;
+    let t2l = (S0l >>> 0) + (majl >>> 0);
+    const t2h = S0h + majh + Math.floor(t2l / 4294967296);
+    t2l >>>= 0;
+    hh = gh;
+    hl = gl;
+    gh = fh;
+    gl = fl;
+    fh = eh;
+    fl = el;
+    let nl = (dl >>> 0) + t1l;
+    eh = dh + t1h + Math.floor(nl / 4294967296) >>> 0;
+    el = nl >>> 0;
+    dh = ch;
+    dl = cl;
+    ch = bh;
+    cl = bl;
+    bh = ah;
+    bl = al;
+    nl = t1l + t2l;
+    ah = t1h + t2h + Math.floor(nl / 4294967296) >>> 0;
+    al = nl >>> 0;
+  }
+  const add = (i, xh, xl) => {
+    const lo = (h[i + 1] >>> 0) + (xl >>> 0);
+    h[i] = h[i] + xh + Math.floor(lo / 4294967296) >>> 0;
+    h[i + 1] = lo >>> 0;
+  };
+  add(0, ah, al);
+  add(2, bh, bl);
+  add(4, ch, cl);
+  add(6, dh, dl);
+  add(8, eh, el);
+  add(10, fh, fl);
+  add(12, gh, gl);
+  add(14, hh, hl);
+}
+function digest64(data, iv, bytes) {
+  const h = new Uint32Array(iv);
+  const padded = new Uint8Array(Math.ceil((data.length + 17) / 128) * 128);
+  padded.set(data);
+  padded[data.length] = 128;
+  const bits = data.length * 8;
+  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);
+  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]);
+  return out;
+}
+var sha512 = (data) => digest64(data, IV_512, 64);
+var sha384 = (data) => digest64(data, IV_384, 48);
+
+// src/digest/digest.ts
+var DIGESTS = {
+  "SHA-1": sha1,
+  "SHA-256": sha256,
+  "SHA-384": sha384,
+  "SHA-512": sha512
+};
+function digestFunction(name) {
+  const canonical = normalizeDigestAlgorithmName(name);
+  return canonical && canonical in DIGESTS ? DIGESTS[canonical] : void 0;
+}
+
+// src/crypto/key-derivation.ts
+var BLOCK_KEYS = {
+  verifierHashInput: new Uint8Array([254, 167, 210, 118, 59, 75, 158, 121]),
+  verifierHashValue: new Uint8Array([215, 170, 15, 109, 48, 97, 52, 78]),
+  encryptedKeyValue: new Uint8Array([20, 110, 11, 231, 171, 172, 208, 214]),
+  dataIntegrityHmacKey: new Uint8Array([95, 178, 173, 1, 12, 185, 225, 246]),
+  dataIntegrityHmacValue: new Uint8Array([160, 103, 127, 2, 178, 44, 132, 51])
+};
+var MAX_SPIN_COUNT = 1e7;
+async function spinPassword(password, salt, spinCount, hashAlgorithm) {
+  if (!Number.isInteger(spinCount) || spinCount < 0 || spinCount > MAX_SPIN_COUNT) {
+    throw new Error(`Unsupported encryption spin count: ${spinCount}.`);
+  }
+  const passwordBytes = encodePasswordUtf16LE(password);
+  const digest = digestFunction(hashAlgorithm);
+  if (digest) {
+    let h2 = digest(concatArrays(salt, passwordBytes));
+    const buffer = new Uint8Array(4 + h2.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);
+    }
+    return h2;
+  }
+  let h = await hash(hashAlgorithm, concatArrays(salt, passwordBytes));
+  for (let i = 0; i < spinCount; i++) {
+    h = await hash(hashAlgorithm, concatArrays(uint32LE(i), h));
+  }
+  return h;
+}
+async function extendKey(h, hashAlgorithm, keyLength) {
+  const pad = async (value) => {
+    const input = new Uint8Array(64).fill(value);
+    for (let i = 0; i < h.length && i < 64; i++) input[i] = h[i] ^ value;
+    return hash(hashAlgorithm, input);
+  };
+  const x3 = concatArrays(await pad(54), await pad(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 keyLength = keyBits / 8;
+  if (hashSize >= keyLength) return h.subarray(0, keyLength);
+  return extendKey(h, hashAlgorithm, keyLength);
+}
+async function deriveAgileKey(password, salt, spinCount, hashAlgorithm, blockKey, keyBits, hashSize) {
+  const base = await computeAgileKeyBase(password, salt, spinCount, hashAlgorithm);
+  return deriveAgileKeyFromBase(base, hashAlgorithm, blockKey, keyBits, hashSize);
+}
+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);
+}
+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 padded = new Uint8Array(blockSize).fill(54);
+  padded.set(h);
+  return padded;
+}
+
+// src/crypto/decrypt.ts
+async function verifyAgilePassword(info, password) {
+  const pke = info.passwordKeyEncryptor;
+  const base = await computeAgileKeyBase(password, pke.saltValue, pke.spinCount, pke.hashAlgorithm);
+  const blockKey = (block) => deriveAgileKeyFromBase(base, pke.hashAlgorithm, block, pke.keyBits, pke.hashSize);
+  const verifierHashInput = await aesCbcDecryptRaw(
+    await blockKey(BLOCK_KEYS.verifierHashInput),
+    pke.saltValue,
+    pke.encryptedVerifierHashInput
+  );
+  const verifierHashValue = await aesCbcDecryptRaw(
+    await blockKey(BLOCK_KEYS.verifierHashValue),
+    pke.saltValue,
+    pke.encryptedVerifierHashValue
+  );
+  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];
+  if (difference !== 0) return null;
+  const decryptedKey = await aesCbcDecryptRaw(
+    await blockKey(BLOCK_KEYS.encryptedKeyValue),
+    pke.saltValue,
+    pke.encryptedKeyValue
+  );
+  return decryptedKey.subarray(0, info.keyData.keyBits / 8);
+}
+async function verifyStandardPassword(info, password) {
+  const key = await deriveStandardKey(
+    password,
+    info.verifier.salt,
+    info.header.keySize,
+    info.header.algIdHash
+  );
+  const decryptedVerifier = await aesEcbDecrypt(key, info.verifier.encryptedVerifier);
+  const decryptedHash = await aesEcbDecrypt(key, info.verifier.encryptedVerifierHash);
+  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]) {
+      match = false;
+      break;
+    }
+  }
+  return match ? key : null;
+}
+async function verifyAgileDataIntegrity(info, key, encryptedPackage) {
+  const keyData = info.keyData;
+  if (!info.dataIntegrity) {
+    return;
+  }
+  const hmacKeyIV = await generateIV(
+    keyData.hashAlgorithm,
+    keyData.saltValue,
+    BLOCK_KEYS.dataIntegrityHmacKey,
+    keyData.blockSize
+  );
+  const decryptedHmacKey = await aesCbcDecryptRaw(
+    key,
+    hmacKeyIV,
+    info.dataIntegrity.encryptedHmacKey
+  );
+  const hmacKey = decryptedHmacKey.subarray(0, keyData.hashSize);
+  const hmacValueIV = await generateIV(
+    keyData.hashAlgorithm,
+    keyData.saltValue,
+    BLOCK_KEYS.dataIntegrityHmacValue,
+    keyData.blockSize
+  );
+  const decryptedHmacValue = await aesCbcDecryptRaw(
+    key,
+    hmacValueIV,
+    info.dataIntegrity.encryptedHmacValue
+  );
+  const expectedHmac = decryptedHmacValue.subarray(0, keyData.hashSize);
+  const computedHmac = await hmac(keyData.hashAlgorithm, hmacKey, encryptedPackage);
+  let match = true;
+  if (computedHmac.length < keyData.hashSize) {
+    match = false;
+  } else {
+    for (let i = 0; i < keyData.hashSize; i++) {
+      if (computedHmac[i] !== expectedHmac[i]) {
+        match = false;
+        break;
+      }
+    }
+  }
+  if (!match) {
+    throw new DataIntegrityError(
+      "Data integrity check failed. The encrypted file may be corrupted or tampered with."
+    );
+  }
+}
+async function decryptAgilePackage(encryptedPackage, key, info) {
+  const keyData = info.keyData;
+  const sizeView = new DataView(encryptedPackage.buffer, encryptedPackage.byteOffset, 8);
+  const originalSize = sizeView.getUint32(0, true) + sizeView.getUint32(4, true) * 4294967296;
+  const encryptedData = encryptedPackage.subarray(8);
+  const segmentSize = 4096;
+  const result = new Uint8Array(originalSize);
+  let resultOffset = 0;
+  const numSegments = Math.ceil(encryptedData.length / segmentSize);
+  for (let segment = 0; segment < numSegments; segment++) {
+    const segmentStart = segment * segmentSize;
+    const segmentEnd = Math.min(segmentStart + segmentSize, encryptedData.length);
+    const segmentData = encryptedData.subarray(segmentStart, segmentEnd);
+    const blockKeyBytes = uint32LE(segment);
+    const segmentIV = await generateIV(
+      keyData.hashAlgorithm,
+      keyData.saltValue,
+      blockKeyBytes,
+      keyData.blockSize
+    );
+    const decrypted = await aesCbcDecryptRaw(key, segmentIV, segmentData);
+    const bytesToCopy = Math.min(decrypted.length, originalSize - resultOffset);
+    result.set(decrypted.subarray(0, bytesToCopy), resultOffset);
+    resultOffset += bytesToCopy;
+  }
+  return result.buffer;
+}
+async function decryptStandardPackage(encryptedPackage, key) {
+  const sizeView = new DataView(encryptedPackage.buffer, encryptedPackage.byteOffset, 8);
+  const originalSize = sizeView.getUint32(0, true);
+  const encryptedData = encryptedPackage.subarray(8);
+  const decrypted = await aesEcbDecrypt(key, encryptedData);
+  return decrypted.slice(0, originalSize).buffer;
+}
+
+// src/crypto/detect.ts
+var OLE_MAGIC2 = [208, 207, 17, 224, 161, 177, 26, 225];
+var toBytes = (input) => input instanceof Uint8Array ? input : new Uint8Array(input);
+function toArrayBuffer(bytes) {
+  if (bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength) {
+    return bytes.buffer;
+  }
+  return bytes.slice().buffer;
+}
+function isCompoundFile(input) {
+  const bytes = toBytes(input);
+  return bytes.length >= 8 && OLE_MAGIC2.every((value, index) => bytes[index] === value);
+}
+function openEncryptedPackage(input) {
+  const bytes = toBytes(input);
+  if (!isCompoundFile(bytes)) return void 0;
+  try {
+    const file = parseOle2(toArrayBuffer(bytes));
+    if (!file.entries.some((entry) => entry.name === "EncryptedPackage")) return void 0;
+    const encryptionInfo = file.getStream("EncryptionInfo");
+    const encryptedPackage = encryptionInfo && file.getStream("EncryptedPackage");
+    return encryptionInfo && encryptedPackage ? { encryptionInfo, encryptedPackage } : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isEncryptedOoxmlPackage(input) {
+  const bytes = toBytes(input);
+  if (!isCompoundFile(bytes)) return false;
+  try {
+    const names = new Set(parseOle2(toArrayBuffer(bytes)).entries.map((entry) => entry.name));
+    return names.has("EncryptionInfo") && names.has("EncryptedPackage");
+  } catch {
+    return false;
+  }
+}
+function detectFileFormat(data) {
+  const bytes = toBytes(data);
+  if (bytes.length < 8) return { format: "unknown", encrypted: false };
+  if (isCompoundFile(bytes)) return { format: "ole", encrypted: true };
+  if (bytes[0] === 80 && bytes[1] === 75) return { format: "zip", encrypted: false };
+  return { format: "unknown", encrypted: false };
+}
+var EncryptedFileError = class extends Error {
+  isEncrypted = true;
+  constructor(message) {
+    super(message);
+    this.name = "EncryptedFileError";
+  }
+};
+
+// node_modules/.bun/@christophervr+ole2@0.4.0/node_modules/@christophervr/ole2/dist/ole2-parser-write-helpers.js
+function compareDirEntryNames(a, b) {
+  if (a.length !== b.length) {
+    return a.length - b.length;
+  }
+  const ua = a.toUpperCase();
+  const ub = b.toUpperCase();
+  for (let i = 0; i < ua.length; i++) {
+    const diff = ua.charCodeAt(i) - ub.charCodeAt(i);
+    if (diff !== 0) {
+      return diff;
+    }
+  }
+  return 0;
+}
+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;
+  }
+  return bytes;
+}
+function writeFatChain(fat, chain) {
+  for (let i = 0; i < chain.sectors.length; i++) {
+    fat[chain.sectors[i]] = i < chain.sectors.length - 1 ? chain.sectors[i + 1] : ENDOFCHAIN;
+  }
+}
+function writeFatRun(fat, firstSector, count) {
+  for (let i = 0; i < count; i++) {
+    const sector = firstSector + i;
+    fat[sector] = i < 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;
+    const end = start + entriesPerSector;
+    const chunk = int32Data.subarray(start, end);
+    const chunkBytes = new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+    outBytes.set(chunkBytes, sectorOff);
+  }
+}
+
+// node_modules/.bun/@christophervr+ole2@0.4.0/node_modules/@christophervr/ole2/dist/ole2-parser-write-serialize.js
+function writeHeader(outView, outBytes, params) {
+  outBytes.set(OLE_MAGIC, 0);
+  outView.setUint16(24, 62, true);
+  outView.setUint16(26, 3, true);
+  outView.setUint16(28, 65534, true);
+  outView.setUint16(30, 9, true);
+  outView.setUint16(32, 6, true);
+  outView.setUint32(40, 0, true);
+  outView.setUint32(44, params.numFATSectors, true);
+  outView.setUint32(48, params.firstDirSector, true);
+  outView.setUint32(52, 0, true);
+  outView.setUint32(56, params.miniStreamCutoff, true);
+  outView.setUint32(60, params.numMiniFATSectors > 0 ? params.firstMiniFATSector : ENDOFCHAIN, true);
+  outView.setUint32(64, params.numMiniFATSectors, true);
+  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);
+    } else {
+      outView.setUint32(76 + i * 4, FREESECT, true);
+    }
+  }
+}
+var HEADER_DIFAT_ENTRIES = 109;
+function difatSectorsFor(numFATSectors, sectorSize) {
+  const overflow = numFATSectors - HEADER_DIFAT_ENTRIES;
+  return overflow > 0 ? Math.ceil(overflow / (sectorSize / 4 - 1)) : 0;
+}
+function sizeFatSectors(dataSectors, sectorSize) {
+  const entriesPerFAT = sectorSize / 4;
+  let numFATSectors = 1;
+  while (true) {
+    const numDIFATSectors = difatSectorsFor(numFATSectors, sectorSize);
+    const needed = Math.ceil((dataSectors + numFATSectors + numDIFATSectors) / entriesPerFAT);
+    if (needed <= numFATSectors) {
+      return { numFATSectors, numDIFATSectors };
+    }
+    numFATSectors = needed;
+  }
+}
+function writeDifatSectors(outView, params) {
+  const perSector = params.sectorSize / 4 - 1;
+  for (let d = 0; d < params.numDIFATSectors; d++) {
+    const base = (params.firstDIFATSector + d + 1) * params.sectorSize;
+    for (let j = 0; j < perSector; j++) {
+      const fatIndex = HEADER_DIFAT_ENTRIES + d * perSector + j;
+      outView.setUint32(base + j * 4, fatIndex < params.numFATSectors ? params.firstFATSector + fatIndex : FREESECT, true);
+    }
+    const next = d < params.numDIFATSectors - 1 ? params.firstDIFATSector + d + 1 : ENDOFCHAIN;
+    outView.setUint32(base + perSector * 4, next, true);
+  }
+}
+function serializeDirectoryEntries(dirEntries, numDirSectors, sectorSize) {
+  const dirData = new Uint8Array(numDirSectors * sectorSize);
+  const dirView = new DataView(dirData.buffer);
+  for (let i = 0; i < dirEntries.length; i++) {
+    const entry = dirEntries[i];
+    const entryOffset = i * 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] = 1;
+    if (entry.clsid) {
+      dirData.set(entry.clsid.subarray(0, 16), entryOffset + 80);
+    }
+    if (i === 0) {
+      dirView.setUint32(entryOffset + 68, 4294967295, true);
+      dirView.setUint32(entryOffset + 72, 4294967295, true);
+      dirView.setUint32(entryOffset + 76, dirEntries.length > 1 ? 1 : 4294967295, true);
+    } else {
+      dirView.setUint32(entryOffset + 68, 4294967295, true);
+      dirView.setUint32(entryOffset + 72, i + 1 < dirEntries.length ? i + 1 : 4294967295, true);
+      dirView.setUint32(entryOffset + 76, 4294967295, true);
+    }
+    dirView.setUint32(entryOffset + 116, entry.startSector, true);
+    dirView.setUint32(entryOffset + 120, entry.size, true);
+  }
+  return dirData;
+}
+function writeStreamSectors(outBytes, streamData, chain, sectorSize) {
+  for (let i = 0; i < chain.sectors.length; i++) {
+    const sectorOffset = (chain.sectors[i] + 1) * sectorSize;
+    const srcOffset = i * sectorSize;
+    const srcEnd = Math.min(srcOffset + sectorSize, streamData.length);
+    outBytes.set(streamData.subarray(srcOffset, srcEnd), sectorOffset);
+  }
+}
+
+// node_modules/.bun/@christophervr+ole2@0.4.0/node_modules/@christophervr/ole2/dist/ole2-parser-write.js
+function buildOle2(streams2, rootClsid, miniStreamCutoff = 4096) {
+  const sectorSize = 512;
+  const miniSectorSize = 64;
+  const regularStreams = [];
+  const miniStreams = [];
+  for (const [name, data] of streams2) {
+    if (data.length < miniStreamCutoff) {
+      miniStreams.push({ name, data });
+    } else {
+      regularStreams.push({ name, data });
+    }
+  }
+  let nextSector = 0;
+  const fatChains = /* @__PURE__ */ new Map();
+  for (const stream of regularStreams) {
+    const numSectors = Math.ceil(stream.data.length / sectorSize);
+    const sectors = [];
+    for (let i = 0; i < numSectors; i++) {
+      sectors.push(nextSector++);
+    }
+    fatChains.set(stream.name, { start: sectors[0] ?? 0, sectors });
+  }
+  let miniStreamContainer = new Uint8Array(0);
+  const miniFatChains = /* @__PURE__ */ new Map();
+  let nextMiniSector = 0;
+  if (miniStreams.length > 0) {
+    let miniStreamSize = 0;
+    for (const s of miniStreams) {
+      miniStreamSize += Math.ceil(s.data.length / miniSectorSize) * miniSectorSize;
+    }
+    miniStreamContainer = new Uint8Array(miniStreamSize);
+    let miniOffset = 0;
+    for (const stream of miniStreams) {
+      const numMiniSectors = Math.ceil(stream.data.length / miniSectorSize);
+      const miniSectors = [];
+      for (let i = 0; i < numMiniSectors; i++) {
+        miniSectors.push(nextMiniSector++);
+        const srcOffset = i * miniSectorSize;
+        const srcEnd = Math.min(srcOffset + miniSectorSize, stream.data.length);
+        miniStreamContainer.set(stream.data.subarray(srcOffset, srcEnd), miniOffset);
+        miniOffset += miniSectorSize;
+      }
+      miniFatChains.set(stream.name, {
+        start: miniSectors[0] ?? 0,
+        sectors: miniSectors
+      });
+    }
+  }
+  let rootStartSector = -1;
+  const rootSectors = [];
+  if (miniStreamContainer.length > 0) {
+    const numSectors = Math.ceil(miniStreamContainer.length / sectorSize);
+    rootStartSector = nextSector;
+    for (let i = 0; i < numSectors; i++) {
+      rootSectors.push(nextSector++);
+    }
+  }
+  const dirEntries = [];
+  dirEntries.push({
+    name: "Root Entry",
+    type: ENTRY_TYPE_ROOT,
+    startSector: rootStartSector === -1 ? ENDOFCHAIN : rootStartSector,
+    size: miniStreamContainer.length,
+    clsid: rootClsid
+  });
+  for (const stream of regularStreams) {
+    const chain = fatChains.get(stream.name);
+    dirEntries.push({
+      name: stream.name,
+      type: ENTRY_TYPE_STREAM,
+      startSector: chain.start,
+      size: stream.data.length
+    });
+  }
+  for (const stream of miniStreams) {
+    const chain = miniFatChains.get(stream.name);
+    dirEntries.push({
+      name: stream.name,
+      type: ENTRY_TYPE_STREAM,
+      startSector: chain.start,
+      size: stream.data.length
+    });
+  }
+  const [rootEntry, ...streamEntries] = dirEntries;
+  streamEntries.sort((a, b) => compareDirEntryNames(a.name, b.name));
+  const sortedDirEntries = [rootEntry, ...streamEntries];
+  const numDirSectors = Math.ceil(dirEntries.length * DIR_ENTRY_SIZE / sectorSize);
+  const firstDirSector = nextSector;
+  nextSector += numDirSectors;
+  let firstMiniFATSector = ENDOFCHAIN;
+  let numMiniFATSectors = 0;
+  if (miniStreams.length > 0) {
+    numMiniFATSectors = Math.ceil(nextMiniSector * 4 / sectorSize);
+    firstMiniFATSector = nextSector;
+    nextSector += numMiniFATSectors;
+  }
+  const { numFATSectors, numDIFATSectors } = sizeFatSectors(nextSector, sectorSize);
+  const firstFATSector = nextSector;
+  nextSector += numFATSectors;
+  const firstDIFATSector = nextSector;
+  nextSector += numDIFATSectors;
+  const totalSectors = nextSector;
+  const fat = new Int32Array(numFATSectors * (sectorSize / 4));
+  fat.fill(-1);
+  for (const [, chain] of fatChains) {
+    writeFatChain(fat, chain);
+  }
+  writeFatChain(fat, { start: rootSectors[0] ?? 0, sectors: rootSectors });
+  writeFatRun(fat, firstDirSector, numDirSectors);
+  if (numMiniFATSectors > 0) {
+    writeFatRun(fat, firstMiniFATSector, numMiniFATSectors);
+  }
+  for (let i = 0; i < numFATSectors; i++) {
+    fat[firstFATSector + i] = FATSECT;
+  }
+  for (let i = 0; i < numDIFATSectors; i++) {
+    fat[firstDIFATSector + i] = DIFSECT;
+  }
+  let miniFat;
+  if (miniStreams.length > 0) {
+    miniFat = new Int32Array(numMiniFATSectors * (sectorSize / 4));
+    miniFat.fill(-1);
+    for (const [, chain] of miniFatChains) {
+      writeFatChain(miniFat, chain);
+    }
+  }
+  const fileSize = (totalSectors + 1) * sectorSize;
+  const output = new ArrayBuffer(fileSize);
+  const outView = new DataView(output);
+  const outBytes = new Uint8Array(output);
+  writeHeader(outView, outBytes, {
+    numFATSectors,
+    firstDirSector,
+    miniStreamCutoff,
+    firstMiniFATSector,
+    numMiniFATSectors,
+    firstFATSector,
+    firstDIFATSector,
+    numDIFATSectors
+  });
+  for (const stream of regularStreams) {
+    writeStreamSectors(outBytes, stream.data, fatChains.get(stream.name), sectorSize);
+  }
+  if (miniStreamContainer.length > 0) {
+    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);
+  }
+  if (miniFat) {
+    writeInt32Sectors(outBytes, miniFat, firstMiniFATSector, numMiniFATSectors, sectorSize);
+  }
+  writeInt32Sectors(outBytes, fat, firstFATSector, numFATSectors, sectorSize);
+  writeDifatSectors(outView, {
+    firstFATSector,
+    numFATSectors,
+    firstDIFATSector,
+    numDIFATSectors,
+    sectorSize
+  });
+  return output;
+}
+
+// src/crypto/encryption-info-write.ts
+function buildAgileEncryptionInfoXml(keyData, pke, dataIntegrity) {
+  const xmlNs = "http://schemas.microsoft.com/office/2006/encryption";
+  const pNs = "http://schemas.microsoft.com/office/2006/keyEncryptor/password";
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\r
+<encryption xmlns="${xmlNs}" xmlns:p="${pNs}"><keyData saltSize="${keyData.saltSize}" blockSize="${keyData.blockSize}" keyBits="${keyData.keyBits}" hashSize="${keyData.hashSize}" cipherAlgorithm="${keyData.cipherAlgorithm}" cipherChaining="${keyData.cipherChaining}" hashAlgorithm="${keyData.hashAlgorithm}" saltValue="${base64Encode(keyData.saltValue)}"/><dataIntegrity encryptedHmacKey="${base64Encode(dataIntegrity.encryptedHmacKey)}" encryptedHmacValue="${base64Encode(dataIntegrity.encryptedHmacValue)}"/><keyEncryptors><keyEncryptor uri="http://schemas.microsoft.com/office/2006/keyEncryptor/password"><p:encryptedKey spinCount="${pke.spinCount}" saltSize="${pke.saltSize}" blockSize="${pke.blockSize}" keyBits="${pke.keyBits}" hashSize="${pke.hashSize}" cipherAlgorithm="${pke.cipherAlgorithm}" cipherChaining="${pke.cipherChaining}" hashAlgorithm="${pke.hashAlgorithm}" saltValue="${base64Encode(pke.saltValue)}" encryptedVerifierHashInput="${base64Encode(pke.encryptedVerifierHashInput)}" encryptedVerifierHashValue="${base64Encode(pke.encryptedVerifierHashValue)}" encryptedKeyValue="${base64Encode(pke.encryptedKeyValue)}"/></keyEncryptor></keyEncryptors></encryption>`;
+}
+function buildEncryptionInfoStream(xmlString) {
+  const xmlBytes = new TextEncoder().encode(xmlString);
+  const result = new Uint8Array(8 + xmlBytes.length);
+  const view = new DataView(result.buffer);
+  view.setUint16(0, 4, true);
+  view.setUint16(2, 4, true);
+  view.setUint32(4, 64, true);
+  result.set(xmlBytes, 8);
+  return result;
+}
+var STANDARD_ALG_IDS = {
+  128: 26126,
+  // CALG_AES_128
+  192: 26127,
+  // CALG_AES_192
+  256: 26128
+  // CALG_AES_256
+};
+var STANDARD_ALG_ID_HASH_SHA1 = 32772;
+var STANDARD_PROVIDER_TYPE_RSA_AES = 24;
+var STANDARD_CSP_NAME = "Microsoft Enhanced RSA and AES Cryptographic Provider";
+var STANDARD_FLAGS = 36;
+function buildStandardEncryptionInfoStream(keyBits, salt, encryptedVerifier, encryptedVerifierHash) {
+  const algId = STANDARD_ALG_IDS[keyBits];
+  if (!algId) {
+    throw new Error(
+      `Unsupported standard encryption key size: ${keyBits} bits. Use 128, 192, or 256.`
+    );
+  }
+  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;
+  }
+  const headerFixedSize = 32;
+  const headerSize = headerFixedSize + cspNameBytes.length;
+  const verifierSize = 4 + 16 + 16 + 4 + 32;
+  const totalSize = 12 + headerSize + verifierSize;
+  const data = new Uint8Array(totalSize);
+  const view = new DataView(data.buffer);
+  view.setUint16(0, 4, true);
+  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 v = 12 + headerSize;
+  view.setUint32(v, 16, true);
+  data.set(salt.subarray(0, 16), v + 4);
+  data.set(encryptedVerifier.subarray(0, 16), v + 20);
+  view.setUint32(v + 36, 20, true);
+  data.set(encryptedVerifierHash.subarray(0, 32), v + 40);
+  return data;
+}
+
+// src/crypto/encrypt.ts
+var SEGMENT_SIZE = 4096;
+function container(encryptionInfo, encryptedPackage) {
+  const streams2 = /* @__PURE__ */ new Map();
+  streams2.set("EncryptionInfo", encryptionInfo);
+  streams2.set("EncryptedPackage", encryptedPackage);
+  return new Uint8Array(buildOle2(streams2));
+}
+function randomBytes(size) {
+  const bytes = new Uint8Array(size);
+  getCrypto().getRandomValues(bytes);
+  return bytes;
+}
+function padTo(data, blockSize) {
+  const padded = new Uint8Array(Math.ceil(data.length / blockSize) * blockSize);
+  padded.set(data);
+  return padded;
+}
+function withSizePrefix(size, body) {
+  const out = new Uint8Array(8 + body.length);
+  const view = new DataView(out.buffer, 0, 8);
+  view.setUint32(0, size % 4294967296, true);
+  view.setUint32(4, Math.floor(size / 4294967296), true);
+  out.set(body, 8);
+  return out;
+}
+async function encryptAgilePackage(packageData, key, info) {
+  const { hashAlgorithm, saltValue, blockSize } = info.keyData;
+  const padded = padTo(packageData, SEGMENT_SIZE);
+  const encrypted = withSizePrefix(packageData.length, padded);
+  for (let start = 0; start < padded.length; start += SEGMENT_SIZE) {
+    const iv = await generateIV(
+      hashAlgorithm,
+      saltValue,
+      uint32LE(start / SEGMENT_SIZE),
+      blockSize
+    );
+    const segment = padded.subarray(start, start + SEGMENT_SIZE);
+    encrypted.set(await aesCbcEncryptNoPad(key, iv, segment), 8 + start);
+  }
+  return encrypted;
+}
+async function encryptStandardPackage(packageData, key) {
+  const encryptedData = await aesEcbEncrypt(key, packageData);
+  return withSizePrefix(packageData.length, encryptedData);
+}
+async function encryptAgile(packageData, password, options = {}) {
+  const keyBits = options.algorithm === "AES128" ? 128 : 256;
+  const hashAlgorithm = "SHA-512";
+  const hashSize = 64;
+  const blockSize = 16;
+  const spinCount = options.spinCount ?? 1e5;
+  const keyDataSalt = randomBytes(16);
+  const pkeSalt = randomBytes(16);
+  const documentKey = randomBytes(keyBits / 8);
+  const verifierHashInput = randomBytes(16);
+  const verifierHash = await hash(hashAlgorithm, verifierHashInput);
+  const base = await computeAgileKeyBase(password, pkeSalt, spinCount, hashAlgorithm);
+  const encryptUnder = async (block, data) => {
+    const key = await deriveAgileKeyFromBase(base, hashAlgorithm, block, keyBits, hashSize);
+    return aesCbcEncryptNoPad(key, pkeSalt, padTo(data, blockSize));
+  };
+  const passwordKeyEncryptor = {
+    saltSize: 16,
+    blockSize,
+    keyBits,
+    hashSize,
+    cipherAlgorithm: "AES",
+    cipherChaining: "ChainingModeCBC",
+    hashAlgorithm,
+    saltValue: pkeSalt,
+    spinCount,
+    encryptedVerifierHashInput: await encryptUnder(BLOCK_KEYS.verifierHashInput, verifierHashInput),
+    encryptedVerifierHashValue: await encryptUnder(BLOCK_KEYS.verifierHashValue, verifierHash),
+    encryptedKeyValue: await encryptUnder(BLOCK_KEYS.encryptedKeyValue, documentKey)
+  };
+  const keyData = {
+    saltSize: 16,
+    blockSize,
+    keyBits,
+    hashSize,
+    cipherAlgorithm: "AES",
+    cipherChaining: "ChainingModeCBC",
+    hashAlgorithm,
+    saltValue: keyDataSalt
+  };
+  const info = {
+    keyData};
+  const encryptedPackage = await encryptAgilePackage(packageData, documentKey, info);
+  const hmacKey = randomBytes(hashSize);
+  const hmacValue = await hmac(hashAlgorithm, hmacKey, encryptedPackage);
+  const encryptIntegrity = async (block, data) => {
+    const iv = await generateIV(hashAlgorithm, keyDataSalt, block, blockSize);
+    return aesCbcEncryptNoPad(documentKey, iv, padTo(data, blockSize));
+  };
+  const dataIntegrity = {
+    encryptedHmacKey: await encryptIntegrity(BLOCK_KEYS.dataIntegrityHmacKey, hmacKey),
+    encryptedHmacValue: await encryptIntegrity(BLOCK_KEYS.dataIntegrityHmacValue, hmacValue)
+  };
+  const xml = buildAgileEncryptionInfoXml(keyData, passwordKeyEncryptor, dataIntegrity);
+  return container(buildEncryptionInfoStream(xml), encryptedPackage);
+}
+async function encryptStandard(packageData, password, options = {}) {
+  const keyBits = options.algorithm === "AES128" ? 128 : 256;
+  const salt = randomBytes(16);
+  const key = await deriveStandardKey(password, salt, keyBits);
+  const verifier = randomBytes(16);
+  const paddedVerifierHash = new Uint8Array(32);
+  paddedVerifierHash.set((await hash("SHA-1", verifier)).subarray(0, 20));
+  const encryptionInfo = buildStandardEncryptionInfoStream(
+    keyBits,
+    salt,
+    await aesEcbEncrypt(key, verifier),
+    await aesEcbEncrypt(key, paddedVerifierHash)
+  );
+  return container(encryptionInfo, await encryptStandardPackage(packageData, key));
+}
+
+// src/crypto/encryption-info.ts
+var RC4_ALG_ID = 26625;
+function parseEncryptionInfo(data) {
+  if (data.byteLength < 8) throw new Error("The EncryptionInfo stream is truncated.");
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const versionMajor = view.getUint16(0, true);
+  const versionMinor = view.getUint16(2, true);
+  if (versionMajor === 4 && versionMinor === 4) return parseAgileEncryptionInfo(data);
+  if ((versionMajor === 2 || versionMajor === 3 || versionMajor === 4) && versionMinor === 2) {
+    return parseStandardEncryptionInfo(data);
+  }
+  throw new Error(
+    `Unsupported encryption version: ${versionMajor}.${versionMinor}. Only Standard (2.2-4.2) and Agile (4.4) encryption are supported.`
+  );
+}
+function parseStandardEncryptionInfo(data) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const versionMajor = view.getUint16(0, true);
+  const versionMinor = view.getUint16(2, true);
+  const flags = view.getUint32(4, true);
+  const headerSize = view.getUint32(8, true);
+  const headerOffset = 12;
+  const hFlags = view.getUint32(headerOffset, true);
+  const algId = view.getUint32(headerOffset + 8, true);
+  const algIdHash = view.getUint32(headerOffset + 12, true);
+  const keySize = view.getUint32(headerOffset + 16, true);
+  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);
+    if (ch === 0) break;
+    cspName += String.fromCharCode(ch);
+  }
+  const verifierOffset = 12 + headerSize;
+  const saltSize = view.getUint32(verifierOffset, true);
+  const salt = new Uint8Array(data.buffer, data.byteOffset + verifierOffset + 4, 16);
+  const encryptedVerifier = new Uint8Array(data.buffer, data.byteOffset + verifierOffset + 20, 16);
+  const verifierHashSize = view.getUint32(verifierOffset + 36, true);
+  const encryptedVerifierHashLength = algId === RC4_ALG_ID ? verifierHashSize : Math.ceil(verifierHashSize / 16) * 16;
+  const encryptedVerifierHash = new Uint8Array(
+    data.buffer,
+    data.byteOffset + verifierOffset + 40,
+    encryptedVerifierHashLength
+  );
+  return {
+    version: { major: versionMajor, minor: versionMinor },
+    isAgile: false,
+    isStandard: true,
+    flags,
+    headerSize,
+    header: { flags: hFlags, algId, algIdHash, keySize, providerType, cspName },
+    verifier: {
+      saltSize,
+      salt: new Uint8Array(salt),
+      encryptedVerifier: new Uint8Array(encryptedVerifier),
+      verifierHashSize,
+      encryptedVerifierHash: new Uint8Array(encryptedVerifierHash)
+    }
+  };
+}
+function tagAttribute(xml, tag, attr) {
+  const tagMatch = xml.match(new RegExp(`<[^>]*${tag}[^>]*>`, "i"));
+  if (!tagMatch) return "";
+  const attrMatch = tagMatch[0].match(new RegExp(`\\b${attr}="([^"]*)"`, "i"));
+  return attrMatch?.[1] ?? "";
+}
+function parseAgileEncryptionInfo(data) {
+  const xml = new TextDecoder("utf-8").decode(data.subarray(8));
+  const keyData = (attr) => tagAttribute(xml, "keyData", attr);
+  const integrity = (attr) => tagAttribute(xml, "dataIntegrity", attr);
+  const pke = (attr) => tagAttribute(xml, "encryptedKey", attr);
+  const int = (value) => parseInt(value, 10);
+  const encryptedHmacKey = integrity("encryptedHmacKey");
+  return {
+    version: { major: 4, minor: 4 },
+    isAgile: true,
+    keyData: {
+      saltSize: int(keyData("saltSize")),
+      blockSize: int(keyData("blockSize")),
+      keyBits: int(keyData("keyBits")),
+      hashSize: int(keyData("hashSize")),
+      cipherAlgorithm: keyData("cipherAlgorithm"),
+      cipherChaining: keyData("cipherChaining"),
+      hashAlgorithm: keyData("hashAlgorithm"),
+      saltValue: base64Decode(keyData("saltValue"))
+    },
+    ...encryptedHmacKey ? {
+      dataIntegrity: {
+        encryptedHmacKey: base64Decode(encryptedHmacKey),
+        encryptedHmacValue: base64Decode(integrity("encryptedHmacValue"))
+      }
+    } : {},
+    passwordKeyEncryptor: {
+      saltSize: int(pke("saltSize")),
+      blockSize: int(pke("blockSize")),
+      keyBits: int(pke("keyBits")),
+      hashSize: int(pke("hashSize")),
+      cipherAlgorithm: pke("cipherAlgorithm"),
+      cipherChaining: pke("cipherChaining"),
+      hashAlgorithm: pke("hashAlgorithm"),
+      saltValue: base64Decode(pke("saltValue")),
+      spinCount: int(pke("spinCount")),
+      encryptedVerifierHashInput: base64Decode(pke("encryptedVerifierHashInput")),
+      encryptedVerifierHashValue: base64Decode(pke("encryptedVerifierHashValue")),
+      encryptedKeyValue: base64Decode(pke("encryptedKeyValue"))
+    }
+  };
+}
+
+// src/crypto/index.ts
+var isStandard = (info) => "isStandard" in info && info.isStandard;
+function streams(bytes) {
+  const opened = openEncryptedPackage(bytes);
+  if (opened) return { info: opened.encryptionInfo, data: opened.encryptedPackage };
+  const file = parseOle2(toArrayBuffer(bytes));
+  if (!file.getStream("EncryptionInfo")) {
+    throw new Error(
+      "EncryptionInfo stream not found. The file may not be an encrypted OOXML package."
+    );
+  }
+  throw new Error("EncryptedPackage stream not found. The file may be corrupted.");
+}
+async function decryptOoxmlPackage(input, password) {
+  const { info: infoStream, data } = streams(toBytes(input));
+  const info = parseEncryptionInfo(infoStream);
+  if (isStandard(info)) {
+    const key2 = await verifyStandardPassword(info, password);
+    if (!key2) throw new IncorrectPasswordError();
+    return new Uint8Array(await decryptStandardPackage(data, key2));
+  }
+  const key = await verifyAgilePassword(info, password);
+  if (!key) throw new IncorrectPasswordError();
+  await verifyAgileDataIntegrity(info, key, data);
+  return new Uint8Array(await decryptAgilePackage(data, key, info));
+}
+function encryptOoxmlPackage(input, password, options = {}) {
+  const bytes = toBytes(input);
+  return options.encryptionScheme === "standard" ? encryptStandard(bytes, password, options) : encryptAgile(bytes, password, options);
+}
+async function verifyOoxmlPackagePassword(input, password) {
+  try {
+    const opened = openEncryptedPackage(input);
+    if (!opened) return false;
+    const info = parseEncryptionInfo(opened.encryptionInfo);
+    const key = isStandard(info) ? await verifyStandardPassword(info, password) : await verifyAgilePassword(info, password);
+    return key !== null;
+  } catch {
+    return false;
+  }
+}
+
+exports.BLOCK_KEYS = BLOCK_KEYS;
+exports.DataIntegrityError = DataIntegrityError;
+exports.EncryptedFileError = EncryptedFileError;
+exports.IncorrectPasswordError = IncorrectPasswordError;
+exports.PasswordRequiredError = PasswordRequiredError;
+exports.RC4_ALG_ID = RC4_ALG_ID;
+exports.buildAgileEncryptionInfoXml = buildAgileEncryptionInfoXml;
+exports.buildEncryptionInfoStream = buildEncryptionInfoStream;
+exports.buildStandardEncryptionInfoStream = buildStandardEncryptionInfoStream;
+exports.computeStandardKeyBase = computeStandardKeyBase;
+exports.decryptAgilePackage = decryptAgilePackage;
+exports.decryptOoxmlPackage = decryptOoxmlPackage;
+exports.decryptStandardPackage = decryptStandardPackage;
+exports.deriveAgileKey = deriveAgileKey;
+exports.deriveStandardKey = deriveStandardKey;
+exports.deriveStandardKeyFromBase = deriveStandardKeyFromBase;
+exports.detectFileFormat = detectFileFormat;
+exports.encryptAgilePackage = encryptAgilePackage;
+exports.encryptOoxmlPackage = encryptOoxmlPackage;
+exports.encryptStandardPackage = encryptStandardPackage;
+exports.generateIV = generateIV;
+exports.isCompoundFile = isCompoundFile;
+exports.isEncryptedOoxmlPackage = isEncryptedOoxmlPackage;
+exports.isOoxmlCryptoError = isOoxmlCryptoError;
+exports.openEncryptedPackage = openEncryptedPackage;
+exports.parseEncryptionInfo = parseEncryptionInfo;
+exports.verifyAgileDataIntegrity = verifyAgileDataIntegrity;
+exports.verifyAgilePassword = verifyAgilePassword;
+exports.verifyOoxmlPackagePassword = verifyOoxmlPackagePassword;
+exports.verifyStandardPassword = verifyStandardPassword;