ooxml-core 0.9.0 → 0.11.0

package/dist/pptx/cli/index.cjs

@@ -14133,12 +14133,12 @@ var init_ole2_parser_write_serialize = __esm({
 });
 
 // node_modules/.bun/@christophervr+ole2@0.4.0/node_modules/@christophervr/ole2/dist/ole2-parser-write.js
-function buildOle2(streams, rootClsid, miniStreamCutoff = 4096) {
+function buildOle2(streams2, rootClsid, miniStreamCutoff = 4096) {
   const sectorSize = 512;
   const miniSectorSize = 64;
   const regularStreams = [];
   const miniStreams = [];
-  for (const [name, data] of streams) {
+  for (const [name, data] of streams2) {
     if (data.length < miniStreamCutoff) {
       miniStreams.push({ name, data });
     } else {
@@ -14362,32 +14362,32 @@ function replaceOleEmbedding(originalBytes, newPayloadBytes, options = {}) {
       const existing = ole.getStream(nativeStreamName);
       const decoded = decodeOle10Native(existing);
       const fileName = options.fileName ?? decoded?.fileName ?? "file.bin";
-      const streams = /* @__PURE__ */ new Map();
+      const streams2 = /* @__PURE__ */ new Map();
       for (const entry of ole.entries) {
         if (entry.name === "Root Entry" || entry.name === nativeStreamName) {
           continue;
         }
         const data = ole.getStream(entry.name);
         if (data) {
-          streams.set(entry.name, data);
+          streams2.set(entry.name, data);
         }
       }
-      streams.set(nativeStreamName, encodeOle10Native(fileName, newPayloadBytes));
-      return new Uint8Array(buildOle2(streams));
+      streams2.set(nativeStreamName, encodeOle10Native(fileName, newPayloadBytes));
+      return new Uint8Array(buildOle2(streams2));
     }
     if (ole.getStream(CONTENTS_STREAM2)) {
-      const streams = /* @__PURE__ */ new Map();
+      const streams2 = /* @__PURE__ */ new Map();
       for (const entry of ole.entries) {
         if (entry.name === "Root Entry" || entry.name === CONTENTS_STREAM2) {
           continue;
         }
         const data = ole.getStream(entry.name);
         if (data) {
-          streams.set(entry.name, data);
+          streams2.set(entry.name, data);
         }
       }
-      streams.set(CONTENTS_STREAM2, newPayloadBytes);
-      return new Uint8Array(buildOle2(streams));
+      streams2.set(CONTENTS_STREAM2, newPayloadBytes);
+      return new Uint8Array(buildOle2(streams2));
     }
     return newPayloadBytes;
   } catch {
@@ -27172,16 +27172,16 @@ var init_smartart_layout_interpreter_composite_slots = __esm({
 
 // src/pptx/core/utils/smartart-layout-interpreter-composite-iteration.ts
 function resolveIterationRect(dims, box, iteration, iterationCount) {
-  const container = resolveSlot(dims, box, 1, 1);
+  const container2 = resolveSlot(dims, box, 1, 1);
   if (iterationCount <= 1) {
-    return container;
+    return container2;
   }
-  if (container.width >= container.height) {
-    const width = container.width / iterationCount;
-    return { x: container.x + width * iteration, y: container.y, width, height: container.height };
+  if (container2.width >= container2.height) {
+    const width = container2.width / iterationCount;
+    return { x: container2.x + width * iteration, y: container2.y, width, height: container2.height };
   }
-  const height = container.height / iterationCount;
-  return { x: container.x, y: container.y + height * iteration, width: container.width, height };
+  const height = container2.height / iterationCount;
+  return { x: container2.x, y: container2.y + height * iteration, width: container2.width, height };
 }
 var init_smartart_layout_interpreter_composite_iteration = __esm({
   "src/pptx/core/utils/smartart-layout-interpreter-composite-iteration.ts"() {
@@ -32121,9 +32121,9 @@ function findVarsContainer(node) {
       continue;
     }
     if (CONTAINER_LOCAL_NAMES.has(localNameOf3(key2))) {
-      const container = Array.isArray(value) ? value[0] : value;
-      if (container && typeof container === "object") {
-        return container;
+      const container2 = Array.isArray(value) ? value[0] : value;
+      if (container2 && typeof container2 === "object") {
+        return container2;
       }
     }
     const nested = findVarsContainer(value);
@@ -32180,8 +32180,8 @@ function findNamedPresVars(node, presName) {
   }
   return void 0;
 }
-function varValue(container, name) {
-  for (const [key2, value] of Object.entries(container)) {
+function varValue(container2, name) {
+  for (const [key2, value] of Object.entries(container2)) {
     if (key2.startsWith("@_") || localNameOf3(key2) !== name) {
       continue;
     }
@@ -32194,27 +32194,27 @@ function varValue(container, name) {
   }
   return void 0;
 }
-function boolValue(container, name) {
-  const raw = varValue(container, name);
+function boolValue(container2, name) {
+  const raw = varValue(container2, name);
   if (raw === void 0) {
     return void 0;
   }
   const lower = raw.toLowerCase();
   return lower === "1" || lower === "true" || lower === "on";
 }
-function intValue(container, name) {
-  const raw = varValue(container, name);
+function intValue(container2, name) {
+  const raw = varValue(container2, name);
   if (raw === void 0) {
     return void 0;
   }
   const parsed = Number.parseInt(raw, 10);
   return Number.isFinite(parsed) ? parsed : void 0;
 }
-function parseSmartArtPresLayoutVars(container) {
-  if (!container) {
+function parseSmartArtPresLayoutVars(container2) {
+  if (!container2) {
     return void 0;
   }
-  const vars = findVarsContainer(container);
+  const vars = findVarsContainer(container2);
   if (!vars) {
     return void 0;
   }
@@ -32255,7 +32255,7 @@ function parseSmartArtPresLayoutVars(container) {
   if (resizeHandles !== void 0) {
     result.resizeHandles = resizeHandles;
   }
-  const hierRootVars = findNamedPresVars(container, "hierRoot1");
+  const hierRootVars = findNamedPresVars(container2, "hierRoot1");
   if (hierRootVars) {
     const rootHierBranch = varValue(hierRootVars, "hierBranch");
     if (rootHierBranch && HIER_BRANCHES.has(rootHierBranch)) {
@@ -32264,7 +32264,7 @@ function parseSmartArtPresLayoutVars(container) {
       result.hierarchyBranch = "init";
     }
   }
-  const rootTextVars = findNamedPresVars(container, "rootText1");
+  const rootTextVars = findNamedPresVars(container2, "rootText1");
   if (rootTextVars) {
     const rootChMax = intValue(rootTextVars, "chMax");
     if (rootChMax !== void 0) {
@@ -32550,6 +32550,7 @@ var init_relationship_types = __esm({
       diagramDrawing: "http://schemas.microsoft.com/office/2007/relationships/diagramDrawing",
       coreProperties: "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties",
       extendedProperties: `${BASE}/extended-properties`,
+      customProperties: `${BASE}/custom-properties`,
       customXml: `${BASE}/customXml`,
       worksheet: `${BASE}/worksheet`,
       chartsheet: `${BASE}/chartsheet`,
@@ -32589,8 +32590,60 @@ var init_package = __esm({
 });
 
 // src/opc/safe-href.ts
+var OPEN_SCHEMES;
 var init_safe_href = __esm({
   "src/opc/safe-href.ts"() {
+    OPEN_SCHEMES = /* @__PURE__ */ new Set(["http", "https", "mailto"]);
+    /* @__PURE__ */ new Set([...OPEN_SCHEMES, "ftp", "file"]);
+  }
+});
+
+// src/opc/properties/types.ts
+var init_types3 = __esm({
+  "src/opc/properties/types.ts"() {
+  }
+});
+
+// src/opc/properties/index.ts
+var init_properties = __esm({
+  "src/opc/properties/index.ts"() {
+    init_types3();
+  }
+});
+
+// src/opc/signature/detection.ts
+function detectDigitalSignatures(zipEntryPaths) {
+  const sigPaths = zipEntryPaths.filter(
+    (p) => p.startsWith(SIGNATURE_PREFIX) && p.endsWith(".xml")
+  );
+  return {
+    hasSignatures: sigPaths.length > 0,
+    signatureCount: sigPaths.length,
+    signaturePaths: sigPaths
+  };
+}
+function getSignaturePathsToStrip(zipEntryPaths) {
+  return zipEntryPaths.filter((p) => p.startsWith(SIGNATURE_PREFIX));
+}
+var SIGNATURE_PART_PREFIX, SIGNATURE_PREFIX;
+var init_detection = __esm({
+  "src/opc/signature/detection.ts"() {
+    SIGNATURE_PART_PREFIX = "_xmlsignatures/";
+    SIGNATURE_PREFIX = SIGNATURE_PART_PREFIX;
+  }
+});
+
+// src/opc/signature/constants.ts
+var DIGITAL_SIGNATURE_ORIGIN_REL_TYPE;
+var init_constants3 = __esm({
+  "src/opc/signature/constants.ts"() {
+    DIGITAL_SIGNATURE_ORIGIN_REL_TYPE = "http://schemas.openxmlformats.org/package/2006/relationships/digital-signature/origin";
+  }
+});
+
+// src/opc/signature/index.ts
+var init_signature = __esm({
+  "src/opc/signature/index.ts"() {
   }
 });
 
@@ -32602,6 +32655,8 @@ var init_opc = __esm({
     init_content_types();
     init_package();
     init_safe_href();
+    init_properties();
+    init_signature();
   }
 });
 
@@ -33234,25 +33289,43 @@ var init_theme_override_utils = __esm({
   }
 });
 
-// src/pptx/core/utils/encryption-detection.ts
-function detectFileFormat(data) {
-  if (data.byteLength < 8) {
-    return { format: "unknown", encrypted: false };
+// src/crypto/detect.ts
+function toArrayBuffer(bytes) {
+  if (bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength) {
+    return bytes.buffer;
   }
-  const header = new Uint8Array(data, 0, 8);
-  if (OLE_MAGIC2.every((byte, i) => header[i] === byte)) {
-    return { format: "ole", encrypted: true };
-  }
-  if (header[0] === ZIP_MAGIC[0] && header[1] === ZIP_MAGIC[1]) {
-    return { format: "zip", encrypted: false };
+  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 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 OLE_MAGIC2, ZIP_MAGIC, EncryptedFileError;
-var init_encryption_detection = __esm({
-  "src/pptx/core/utils/encryption-detection.ts"() {
-    OLE_MAGIC2 = new Uint8Array([208, 207, 17, 224, 161, 177, 26, 225]);
-    ZIP_MAGIC = new Uint8Array([80, 75]);
+var OLE_MAGIC2, toBytes, EncryptedFileError;
+var init_detect = __esm({
+  "src/crypto/detect.ts"() {
+    init_ole2_parser_read();
+    OLE_MAGIC2 = [208, 207, 17, 224, 161, 177, 26, 225];
+    toBytes = (input) => input instanceof Uint8Array ? input : new Uint8Array(input);
     EncryptedFileError = class extends Error {
       isEncrypted = true;
       constructor(message) {
@@ -33263,31 +33336,10 @@ var init_encryption_detection = __esm({
   }
 });
 
-// src/pptx/core/utils/ole2-parser.ts
-var init_ole2_parser = __esm({
-  "src/pptx/core/utils/ole2-parser.ts"() {
-    init_ole2_parser_types2();
-    init_ole2_parser_read2();
-    init_ole2_parser_write2();
-  }
-});
-
-// src/pptx/core/utils/ooxml-crypto-errors.ts
-var IncorrectPasswordError, DataIntegrityError;
-var init_ooxml_crypto_errors = __esm({
-  "src/pptx/core/utils/ooxml-crypto-errors.ts"() {
-    IncorrectPasswordError = class extends Error {
-      constructor(message = "The password is incorrect.") {
-        super(message);
-        this.name = "IncorrectPasswordError";
-      }
-    };
-    DataIntegrityError = class extends Error {
-      constructor(message = "Data integrity check failed. The encrypted file may be corrupted or tampered with.") {
-        super(message);
-        this.name = "DataIntegrityError";
-      }
-    };
+// src/pptx/core/utils/encryption-detection.ts
+var init_encryption_detection = __esm({
+  "src/pptx/core/utils/encryption-detection.ts"() {
+    init_detect();
   }
 });
 
@@ -33413,71 +33465,644 @@ var init_ooxml_crypto_primitives = __esm({
   }
 });
 
-// src/pptx/core/utils/ooxml-crypto-primitives.ts
-var init_ooxml_crypto_primitives2 = __esm({
-  "src/pptx/core/utils/ooxml-crypto-primitives.ts"() {
+// src/crypto/aes-ecb.ts
+async function aesEcbDecrypt(key2, data) {
+  const plain = await aesCbcDecryptRaw(key2, new Uint8Array(BLOCK), data);
+  for (let at2 = BLOCK; at2 < plain.length && at2 < data.length; at2++) {
+    plain[at2] = plain[at2] ^ data[at2 - BLOCK];
+  }
+  return plain;
+}
+async function aesEcbEncrypt(key2, data) {
+  const padded = new Uint8Array(Math.ceil(data.length / BLOCK) * BLOCK);
+  padded.set(data);
+  const subtle = getSubtle();
+  const cryptoKey = await subtle.importKey("raw", key2, { 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 at2 = start; at2 < end; at2 += BLOCK) {
+      const block = padded.slice(at2, at2 + BLOCK);
+      jobs.push(
+        subtle.encrypt({ name: "AES-CBC", iv }, cryptoKey, block).then((result) => {
+          out.set(new Uint8Array(result, 0, BLOCK), at2);
+        })
+      );
+    }
+    await Promise.all(jobs);
+  }
+  return out;
+}
+var BLOCK, BATCH;
+var init_aes_ecb = __esm({
+  "src/crypto/aes-ecb.ts"() {
     init_ooxml_crypto_primitives();
+    BLOCK = 16;
+    BATCH = 4096;
   }
 });
 
-// src/pptx/core/utils/ooxml-crypto-key-derivation.ts
-async function deriveAgileKey(password, salt, spinCount, hashAlgorithm, blockKey, keyBits, hashSize) {
+// src/crypto/errors.ts
+var IncorrectPasswordError, DataIntegrityError;
+var init_errors = __esm({
+  "src/crypto/errors.ts"() {
+    IncorrectPasswordError = class extends Error {
+      code = "incorrect-password";
+      constructor(message = "The password is incorrect.") {
+        super(message);
+        this.name = "IncorrectPasswordError";
+      }
+    };
+    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";
+      }
+    };
+  }
+});
+
+// src/digest/algorithm-names.ts
+function normalizeDigestAlgorithmName(name) {
+  const key2 = name.toUpperCase().replace(/[-_\s]/g, "");
+  return Object.hasOwn(CANONICAL_BY_LOOKUP_KEY, key2) ? CANONICAL_BY_LOOKUP_KEY[key2] : void 0;
+}
+var CANONICAL_BY_LOOKUP_KEY;
+var init_algorithm_names = __esm({
+  "src/digest/algorithm-names.ts"() {
+    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"
+    };
+  }
+});
+
+// src/digest/sha256.ts
+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);
+}
+var K, IV, W, rotr;
+var init_sha256 = __esm({
+  "src/digest/sha256.ts"() {
+    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
+    ]);
+    IV = [
+      1779033703,
+      3144134277,
+      1013904242,
+      2773480762,
+      1359893119,
+      2600822924,
+      528734635,
+      1541459225
+    ];
+    W = new Uint32Array(64);
+    rotr = (x, n) => x >>> n | x << 32 - n;
+  }
+});
+
+// src/digest/sha1.ts
+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);
+}
+var W2, rotl;
+var init_sha1 = __esm({
+  "src/digest/sha1.ts"() {
+    init_sha256();
+    W2 = new Uint32Array(80);
+    rotl = (x, n) => x << n | x >>> 32 - n;
+  }
+});
+
+// src/digest/sha512.ts
+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 K2, IV_512, IV_384, W3, sha512, sha384;
+var init_sha512 = __esm({
+  "src/digest/sha512.ts"() {
+    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
+    ]);
+    IV_512 = [
+      1779033703,
+      4089235720,
+      3144134277,
+      2227873595,
+      1013904242,
+      4271175723,
+      2773480762,
+      1595750129,
+      1359893119,
+      2917565137,
+      2600822924,
+      725511199,
+      528734635,
+      4215389547,
+      1541459225,
+      327033209
+    ];
+    IV_384 = [
+      3418070365,
+      3238371032,
+      1654270250,
+      914150663,
+      2438529370,
+      812702999,
+      355462360,
+      4144912697,
+      1731405415,
+      4290775857,
+      2394180231,
+      1750603025,
+      3675008525,
+      1694076839,
+      1203062813,
+      3204075428
+    ];
+    W3 = new Uint32Array(160);
+    sha512 = (data) => digest64(data, IV_512, 64);
+    sha384 = (data) => digest64(data, IV_384, 48);
+  }
+});
+
+// src/digest/digest.ts
+function digestFunction(name) {
+  const canonical = normalizeDigestAlgorithmName(name);
+  return canonical && canonical in DIGESTS ? DIGESTS[canonical] : void 0;
+}
+var DIGESTS;
+var init_digest = __esm({
+  "src/digest/digest.ts"() {
+    init_algorithm_names();
+    init_sha1();
+    init_sha256();
+    init_sha512();
+    DIGESTS = {
+      "SHA-1": sha1,
+      "SHA-256": sha256,
+      "SHA-384": sha384,
+      "SHA-512": sha512
+    };
+  }
+});
+
+// src/crypto/key-derivation.ts
+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));
   }
-  h = await hash(hashAlgorithm, concatArrays(h, blockKey));
-  const cbRequiredKeyLength = keyBits / 8;
-  const cbHash = hashSize;
-  const ipad = 54;
-  const opad = 92;
-  if (cbHash >= cbRequiredKeyLength) {
-    return h.subarray(0, cbRequiredKeyLength);
-  }
-  const x1Input = new Uint8Array(64);
-  x1Input.fill(ipad);
-  for (let i = 0; i < h.length && i < 64; i++) {
-    x1Input[i] = h[i] ^ ipad;
-  }
-  const x1 = await hash(hashAlgorithm, x1Input);
-  const x2Input = new Uint8Array(64);
-  x2Input.fill(opad);
-  for (let i = 0; i < h.length && i < 64; i++) {
-    x2Input[i] = h[i] ^ opad;
-  }
-  const x2 = await hash(hashAlgorithm, x2Input);
-  const x3 = concatArrays(x1, x2);
-  return x3.subarray(0, cbRequiredKeyLength);
-}
-async function computeStandardKeyBase(password, salt) {
-  const passwordBytes = encodePasswordUtf16LE(password);
-  let h = await hash("SHA-1", concatArrays(salt, passwordBytes));
-  for (let i = 0; i < 5e4; i++) {
-    h = await hash("SHA-1", 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);
+}
+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)));
-  const cbRequiredKeyLength = keySize / 8;
-  if (h.length >= cbRequiredKeyLength) {
-    return h.subarray(0, cbRequiredKeyLength);
-  }
-  const x1Input = new Uint8Array(64);
-  x1Input.fill(54);
-  for (let i = 0; i < h.length && i < 64; i++) {
-    x1Input[i] = h[i] ^ 54;
-  }
-  const x1 = await hash("SHA-1", x1Input);
-  const x2Input = new Uint8Array(64);
-  x2Input.fill(92);
-  for (let i = 0; i < h.length && i < 64; i++) {
-    x2Input[i] = h[i] ^ 92;
-  }
-  const x2 = await hash("SHA-1", x2Input);
-  const x3 = concatArrays(x1, x2);
-  return x3.subarray(0, cbRequiredKeyLength);
+  return extendKey(h, "SHA-1", keySize / 8);
 }
 async function deriveStandardKey(password, salt, keySize, _algIdHash, blockNumber = 0) {
   const base = await computeStandardKeyBase(password, salt);
@@ -33485,164 +34110,16 @@ async function deriveStandardKey(password, salt, keySize, _algIdHash, blockNumbe
 }
 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);
-  padded.fill(54);
+  if (h.length >= blockSize) return h.subarray(0, blockSize);
+  const padded = new Uint8Array(blockSize).fill(54);
   padded.set(h);
   return padded;
 }
-function parseEncryptionInfo(data) {
-  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);
-  view.getUint32(headerOffset + 4, 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 cspOffset = headerOffset + 32;
-  const cspEnd = headerOffset + headerSize;
-  for (let i = cspOffset; 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 parseAgileEncryptionInfo(data) {
-  const xmlBytes = data.subarray(8);
-  const xmlStr = new TextDecoder("utf-8").decode(xmlBytes);
-  const getAttr = (xml, tag, attr4) => {
-    const tagRegex = new RegExp(`<[^>]*${tag}[^>]*>`, "i");
-    const tagMatch = xml.match(tagRegex);
-    if (!tagMatch) {
-      return "";
-    }
-    const attrRegex = new RegExp(`${attr4}="([^"]*)"`, "i");
-    const attrMatch = tagMatch[0].match(attrRegex);
-    return attrMatch ? attrMatch[1] : "";
-  };
-  const keyDataSaltSize = parseInt(getAttr(xmlStr, "keyData", "saltSize"), 10);
-  const keyDataBlockSize = parseInt(getAttr(xmlStr, "keyData", "blockSize"), 10);
-  const keyDataKeyBits = parseInt(getAttr(xmlStr, "keyData", "keyBits"), 10);
-  const keyDataHashSize = parseInt(getAttr(xmlStr, "keyData", "hashSize"), 10);
-  const keyDataCipherAlgorithm = getAttr(xmlStr, "keyData", "cipherAlgorithm");
-  const keyDataCipherChaining = getAttr(xmlStr, "keyData", "cipherChaining");
-  const keyDataHashAlgorithm = getAttr(xmlStr, "keyData", "hashAlgorithm");
-  const keyDataSaltValue = getAttr(xmlStr, "keyData", "saltValue");
-  const encryptedHmacKey = getAttr(xmlStr, "dataIntegrity", "encryptedHmacKey");
-  const encryptedHmacValue = getAttr(xmlStr, "dataIntegrity", "encryptedHmacValue");
-  const encKeyTag = xmlStr.match(/<[^>]*encryptedKey[^>]*>/i);
-  const encKeyStr = encKeyTag ? encKeyTag[0] : "";
-  const getEncKeyAttr = (attr4) => {
-    const regex = new RegExp(`${attr4}="([^"]*)"`, "i");
-    const match = encKeyStr.match(regex);
-    return match ? match[1] : "";
-  };
-  const pkeSaltSize = parseInt(getEncKeyAttr("saltSize"), 10);
-  const pkeBlockSize = parseInt(getEncKeyAttr("blockSize"), 10);
-  const pkeKeyBits = parseInt(getEncKeyAttr("keyBits"), 10);
-  const pkeHashSize = parseInt(getEncKeyAttr("hashSize"), 10);
-  const pkeCipherAlgorithm = getEncKeyAttr("cipherAlgorithm");
-  const pkeCipherChaining = getEncKeyAttr("cipherChaining");
-  const pkeHashAlgorithm = getEncKeyAttr("hashAlgorithm");
-  const pkeSaltValue = getEncKeyAttr("saltValue");
-  const pkeSpinCount = parseInt(getEncKeyAttr("spinCount"), 10);
-  const pkeEncryptedVerifierHashInput = getEncKeyAttr("encryptedVerifierHashInput");
-  const pkeEncryptedVerifierHashValue = getEncKeyAttr("encryptedVerifierHashValue");
-  const pkeEncryptedKeyValue = getEncKeyAttr("encryptedKeyValue");
-  return {
-    version: { major: 4, minor: 4 },
-    isAgile: true,
-    keyData: {
-      saltSize: keyDataSaltSize,
-      blockSize: keyDataBlockSize,
-      keyBits: keyDataKeyBits,
-      hashSize: keyDataHashSize,
-      cipherAlgorithm: keyDataCipherAlgorithm,
-      cipherChaining: keyDataCipherChaining,
-      hashAlgorithm: keyDataHashAlgorithm,
-      saltValue: base64Decode(keyDataSaltValue)
-    },
-    dataIntegrity: encryptedHmacKey ? {
-      encryptedHmacKey: base64Decode(encryptedHmacKey),
-      encryptedHmacValue: base64Decode(encryptedHmacValue)
-    } : void 0,
-    passwordKeyEncryptor: {
-      saltSize: pkeSaltSize,
-      blockSize: pkeBlockSize,
-      keyBits: pkeKeyBits,
-      hashSize: pkeHashSize,
-      cipherAlgorithm: pkeCipherAlgorithm,
-      cipherChaining: pkeCipherChaining,
-      hashAlgorithm: pkeHashAlgorithm,
-      saltValue: base64Decode(pkeSaltValue),
-      spinCount: pkeSpinCount,
-      encryptedVerifierHashInput: base64Decode(pkeEncryptedVerifierHashInput),
-      encryptedVerifierHashValue: base64Decode(pkeEncryptedVerifierHashValue),
-      encryptedKeyValue: base64Decode(pkeEncryptedKeyValue)
-    }
-  };
-}
-var BLOCK_KEYS, RC4_ALG_ID;
-var init_ooxml_crypto_key_derivation = __esm({
-  "src/pptx/core/utils/ooxml-crypto-key-derivation.ts"() {
-    init_ooxml_crypto_primitives2();
+var BLOCK_KEYS, MAX_SPIN_COUNT;
+var init_key_derivation = __esm({
+  "src/crypto/key-derivation.ts"() {
+    init_ooxml_crypto_primitives();
+    init_digest();
     BLOCK_KEYS = {
       verifierHashInput: new Uint8Array([254, 167, 210, 118, 59, 75, 158, 121]),
       verifierHashValue: new Uint8Array([215, 170, 15, 109, 48, 97, 52, 78]),
@@ -33650,64 +34127,35 @@ var init_ooxml_crypto_key_derivation = __esm({
       dataIntegrityHmacKey: new Uint8Array([95, 178, 173, 1, 12, 185, 225, 246]),
       dataIntegrityHmacValue: new Uint8Array([160, 103, 127, 2, 178, 44, 132, 51])
     };
-    RC4_ALG_ID = 26625;
+    MAX_SPIN_COUNT = 1e7;
   }
 });
 
-// src/pptx/core/utils/ooxml-crypto-decrypt.ts
+// src/crypto/decrypt.ts
 async function verifyAgilePassword(info, password) {
   const pke = info.passwordKeyEncryptor;
-  const verifierInputKey = await deriveAgileKey(
-    password,
-    pke.saltValue,
-    pke.spinCount,
-    pke.hashAlgorithm,
-    BLOCK_KEYS.verifierHashInput,
-    pke.keyBits,
-    pke.hashSize
-  );
+  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(
-    verifierInputKey,
+    await blockKey(BLOCK_KEYS.verifierHashInput),
     pke.saltValue,
     pke.encryptedVerifierHashInput
   );
-  const verifierHashKey = await deriveAgileKey(
-    password,
-    pke.saltValue,
-    pke.spinCount,
-    pke.hashAlgorithm,
-    BLOCK_KEYS.verifierHashValue,
-    pke.keyBits,
-    pke.hashSize
-  );
   const verifierHashValue = await aesCbcDecryptRaw(
-    verifierHashKey,
+    await blockKey(BLOCK_KEYS.verifierHashValue),
     pke.saltValue,
     pke.encryptedVerifierHashValue
   );
   const computedHash = await hash(pke.hashAlgorithm, verifierHashInput.subarray(0, pke.saltSize));
-  const expectedHash = verifierHashValue.subarray(0, pke.hashSize);
-  const actualHash = computedHash.subarray(0, pke.hashSize);
-  let match = true;
-  for (let i = 0; i < pke.hashSize; i++) {
-    if (expectedHash[i] !== actualHash[i]) {
-      match = false;
-      break;
-    }
-  }
-  if (!match) {
-    return null;
-  }
-  const encKeyKey = await deriveAgileKey(
-    password,
+  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.spinCount,
-    pke.hashAlgorithm,
-    BLOCK_KEYS.encryptedKeyValue,
-    pke.keyBits,
-    pke.hashSize
+    pke.encryptedKeyValue
   );
-  const decryptedKey = await aesCbcDecryptRaw(encKeyKey, pke.saltValue, pke.encryptedKeyValue);
   return decryptedKey.subarray(0, info.keyData.keyBits / 8);
 }
 async function verifyStandardPassword(info, password) {
@@ -33717,9 +34165,8 @@ async function verifyStandardPassword(info, password) {
     info.header.keySize,
     info.header.algIdHash
   );
-  const iv = new Uint8Array(16);
-  const decryptedVerifier = await aesCbcDecryptRaw(key2, iv, info.verifier.encryptedVerifier);
-  const decryptedHash = await aesCbcDecryptRaw(key2, iv, info.verifier.encryptedVerifierHash);
+  const decryptedVerifier = await aesEcbDecrypt(key2, info.verifier.encryptedVerifier);
+  const decryptedHash = await aesEcbDecrypt(key2, info.verifier.encryptedVerifierHash);
   const computedHash = await hash("SHA-1", decryptedVerifier);
   const hashSize = info.verifier.verifierHashSize;
   let match = true;
@@ -33809,46 +34256,19 @@ async function decryptStandardPackage(encryptedPackage, key2) {
   const sizeView = new DataView(encryptedPackage.buffer, encryptedPackage.byteOffset, 8);
   const originalSize = sizeView.getUint32(0, true);
   const encryptedData = encryptedPackage.subarray(8);
-  const iv = new Uint8Array(16);
-  const decrypted = await aesCbcDecryptRaw(key2, iv, encryptedData);
+  const decrypted = await aesEcbDecrypt(key2, encryptedData);
   return decrypted.slice(0, originalSize).buffer;
 }
-var init_ooxml_crypto_decrypt = __esm({
-  "src/pptx/core/utils/ooxml-crypto-decrypt.ts"() {
-    init_ooxml_crypto_errors();
-    init_ooxml_crypto_key_derivation();
-    init_ooxml_crypto_primitives2();
+var init_decrypt = __esm({
+  "src/crypto/decrypt.ts"() {
+    init_ooxml_crypto_primitives();
+    init_aes_ecb();
+    init_errors();
+    init_key_derivation();
   }
 });
 
-// src/pptx/core/utils/ooxml-crypto-encrypt.ts
-async function encryptAgilePackage(packageData, key2, info) {
-  const keyData = info.keyData;
-  const segmentSize = 4096;
-  const paddedSize = Math.ceil(packageData.length / segmentSize) * segmentSize;
-  const paddedData = new Uint8Array(paddedSize);
-  paddedData.set(packageData);
-  const encrypted = new Uint8Array(8 + paddedSize);
-  const sizeView = new DataView(encrypted.buffer, 0, 8);
-  sizeView.setUint32(0, packageData.length, true);
-  sizeView.setUint32(4, 0, true);
-  const numSegments = Math.ceil(paddedSize / segmentSize);
-  for (let segment = 0; segment < numSegments; segment++) {
-    const segmentStart = segment * segmentSize;
-    const segmentEnd = segmentStart + segmentSize;
-    const segmentData = paddedData.subarray(segmentStart, segmentEnd);
-    const blockKeyBytes = uint32LE(segment);
-    const segmentIV = await generateIV(
-      keyData.hashAlgorithm,
-      keyData.saltValue,
-      blockKeyBytes,
-      keyData.blockSize
-    );
-    const encryptedSegment = await aesCbcEncryptNoPad(key2, segmentIV, segmentData);
-    encrypted.set(encryptedSegment, 8 + segmentStart);
-  }
-  return encrypted;
-}
+// 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";
@@ -33865,20 +34285,6 @@ function buildEncryptionInfoStream(xmlString) {
   result.set(xmlBytes, 8);
   return result;
 }
-async function encryptStandardPackage(packageData, key2) {
-  const blockSize = 16;
-  const paddedSize = Math.ceil(packageData.length / blockSize) * blockSize;
-  const paddedData = new Uint8Array(paddedSize);
-  paddedData.set(packageData);
-  const iv = new Uint8Array(blockSize);
-  const encryptedData = await aesCbcEncryptNoPad(key2, iv, paddedData);
-  const encrypted = new Uint8Array(8 + encryptedData.length);
-  const sizeView = new DataView(encrypted.buffer, 0, 8);
-  sizeView.setUint32(0, packageData.length, true);
-  sizeView.setUint32(4, 0, true);
-  encrypted.set(encryptedData, 8);
-  return encrypted;
-}
 function buildStandardEncryptionInfoStream(keyBits, salt, encryptedVerifier, encryptedVerifierHash) {
   const algId = STANDARD_ALG_IDS[keyBits];
   if (!algId) {
@@ -33920,40 +34326,10 @@ function buildStandardEncryptionInfoStream(keyBits, salt, encryptedVerifier, enc
   data.set(encryptedVerifierHash.subarray(0, 32), v + 40);
   return data;
 }
-async function encryptPptxStandard(pptxBuffer, password, options) {
-  const algorithm = options?.algorithm ?? "AES256";
-  const keyBits = algorithm === "AES128" ? 128 : 256;
-  const crypto2 = getCrypto();
-  const salt = new Uint8Array(16);
-  crypto2.getRandomValues(salt);
-  const key2 = await deriveStandardKey(password, salt, keyBits);
-  const verifier = new Uint8Array(16);
-  crypto2.getRandomValues(verifier);
-  const verifierHash = await hash("SHA-1", verifier);
-  const paddedVerifierHash = new Uint8Array(32);
-  paddedVerifierHash.set(verifierHash.subarray(0, 20));
-  const zeroIv = new Uint8Array(16);
-  const encryptedVerifier = await aesCbcEncryptNoPad(key2, zeroIv, verifier);
-  const encryptedVerifierHash = await aesCbcEncryptNoPad(key2, zeroIv, paddedVerifierHash);
-  const encryptionInfoBytes = buildStandardEncryptionInfoStream(
-    keyBits,
-    salt,
-    encryptedVerifier,
-    encryptedVerifierHash
-  );
-  const packageData = new Uint8Array(pptxBuffer);
-  const encryptedPackage = await encryptStandardPackage(packageData, key2);
-  const ole2Streams = /* @__PURE__ */ new Map();
-  ole2Streams.set("EncryptionInfo", encryptionInfoBytes);
-  ole2Streams.set("EncryptedPackage", encryptedPackage);
-  return buildOle2(ole2Streams);
-}
 var STANDARD_ALG_IDS, STANDARD_ALG_ID_HASH_SHA1, STANDARD_PROVIDER_TYPE_RSA_AES, STANDARD_CSP_NAME, STANDARD_FLAGS;
-var init_ooxml_crypto_encrypt = __esm({
-  "src/pptx/core/utils/ooxml-crypto-encrypt.ts"() {
-    init_ole2_parser();
-    init_ooxml_crypto_key_derivation();
-    init_ooxml_crypto_primitives2();
+var init_encryption_info_write = __esm({
+  "src/crypto/encryption-info-write.ts"() {
+    init_ooxml_crypto_primitives();
     STANDARD_ALG_IDS = {
       128: 26126,
       // CALG_AES_128
@@ -33969,178 +34345,317 @@ var init_ooxml_crypto_encrypt = __esm({
   }
 });
 
-// src/pptx/core/utils/ooxml-crypto.ts
-async function decryptPptx(encryptedBuffer, password) {
-  const ole2 = parseOle2(encryptedBuffer);
-  const encryptionInfoStream = ole2.getStream("EncryptionInfo");
-  if (!encryptionInfoStream) {
-    throw new Error(
-      "EncryptionInfo stream not found. The file may not be an encrypted OOXML package."
+// src/crypto/encrypt.ts
+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, key2, 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(key2, iv, segment), 8 + start);
   }
-  const encryptedPackage = ole2.getStream("EncryptedPackage");
-  if (!encryptedPackage) {
-    throw new Error("EncryptedPackage stream not found. The file may be corrupted.");
-  }
-  const info = parseEncryptionInfo(encryptionInfoStream);
-  if ("isStandard" in info && info.isStandard) {
-    const key3 = await verifyStandardPassword(info, password);
-    if (!key3) {
-      throw new IncorrectPasswordError();
-    }
-    return decryptStandardPackage(encryptedPackage, key3);
-  }
-  const agileInfo = info;
-  const key2 = await verifyAgilePassword(agileInfo, password);
-  if (!key2) {
-    throw new IncorrectPasswordError();
-  }
-  await verifyAgileDataIntegrity(agileInfo, key2, encryptedPackage);
-  return decryptAgilePackage(encryptedPackage, key2, agileInfo);
+  return encrypted;
 }
-async function encryptPptx(pptxBuffer, password, options) {
-  if (options?.encryptionScheme === "standard") {
-    return encryptPptxStandard(pptxBuffer, password, options);
-  }
-  const algorithm = options?.algorithm ?? "AES256";
-  const keyBits = algorithm === "AES128" ? 128 : 256;
-  const crypto2 = getCrypto();
-  const keyDataSalt = new Uint8Array(16);
-  crypto2.getRandomValues(keyDataSalt);
-  const pkeSalt = new Uint8Array(16);
-  crypto2.getRandomValues(pkeSalt);
-  const documentKey = new Uint8Array(keyBits / 8);
-  crypto2.getRandomValues(documentKey);
+async function encryptStandardPackage(packageData, key2) {
+  const encryptedData = await aesEcbEncrypt(key2, 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 verifierHashInput = new Uint8Array(16);
-  crypto2.getRandomValues(verifierHashInput);
+  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 verifierInputKey = await deriveAgileKey(
-    password,
-    pkeSalt,
-    spinCount,
-    hashAlgorithm,
-    BLOCK_KEYS.verifierHashInput,
+  const base = await computeAgileKeyBase(password, pkeSalt, spinCount, hashAlgorithm);
+  const encryptUnder = async (block, data) => {
+    const key2 = await deriveAgileKeyFromBase(base, hashAlgorithm, block, keyBits, hashSize);
+    return aesCbcEncryptNoPad(key2, pkeSalt, padTo(data, blockSize));
+  };
+  const passwordKeyEncryptor = {
+    saltSize: 16,
+    blockSize,
     keyBits,
-    hashSize
-  );
-  const paddedVerifierInput = new Uint8Array(
-    Math.ceil(verifierHashInput.length / blockSize) * blockSize
-  );
-  paddedVerifierInput.set(verifierHashInput);
-  const encryptedVerifierHashInput = await aesCbcEncryptNoPad(
-    verifierInputKey,
-    pkeSalt,
-    paddedVerifierInput
-  );
-  const verifierHashKey = await deriveAgileKey(
-    password,
-    pkeSalt,
+    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,
-    BLOCK_KEYS.verifierHashValue,
+    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 key2 = 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,
-    hashSize
+    salt,
+    await aesEcbEncrypt(key2, verifier),
+    await aesEcbEncrypt(key2, paddedVerifierHash)
   );
-  const paddedVerifierHash = new Uint8Array(Math.ceil(verifierHash.length / blockSize) * blockSize);
-  paddedVerifierHash.set(verifierHash);
-  const encryptedVerifierHashValue = await aesCbcEncryptNoPad(
-    verifierHashKey,
-    pkeSalt,
-    paddedVerifierHash
+  return container(encryptionInfo, await encryptStandardPackage(packageData, key2));
+}
+var SEGMENT_SIZE;
+var init_encrypt = __esm({
+  "src/crypto/encrypt.ts"() {
+    init_ole2_parser_write();
+    init_ooxml_crypto_primitives();
+    init_aes_ecb();
+    init_encryption_info_write();
+    init_key_derivation();
+    SEGMENT_SIZE = 4096;
+  }
+});
+
+// src/crypto/encryption-info.ts
+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.`
   );
-  const encKeyKey = await deriveAgileKey(
-    password,
-    pkeSalt,
-    spinCount,
-    hashAlgorithm,
-    BLOCK_KEYS.encryptedKeyValue,
-    keyBits,
-    hashSize
+}
+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
   );
-  const paddedDocumentKey = new Uint8Array(Math.ceil(documentKey.length / blockSize) * blockSize);
-  paddedDocumentKey.set(documentKey);
-  const encryptedKeyValue = await aesCbcEncryptNoPad(encKeyKey, pkeSalt, paddedDocumentKey);
-  const encInfo = {
+  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, attr4) {
+  const tagMatch = xml.match(new RegExp(`<[^>]*${tag}[^>]*>`, "i"));
+  if (!tagMatch) return "";
+  const attrMatch = tagMatch[0].match(new RegExp(`\\b${attr4}="([^"]*)"`, "i"));
+  return attrMatch?.[1] ?? "";
+}
+function parseAgileEncryptionInfo(data) {
+  const xml = new TextDecoder("utf-8").decode(data.subarray(8));
+  const keyData = (attr4) => tagAttribute(xml, "keyData", attr4);
+  const integrity = (attr4) => tagAttribute(xml, "dataIntegrity", attr4);
+  const pke = (attr4) => tagAttribute(xml, "encryptedKey", attr4);
+  const int = (value) => parseInt(value, 10);
+  const encryptedHmacKey = integrity("encryptedHmacKey");
+  return {
+    version: { major: 4, minor: 4 },
+    isAgile: true,
     keyData: {
-      saltSize: 16,
-      blockSize,
-      keyBits,
-      hashSize,
-      cipherAlgorithm: "AES",
-      cipherChaining: "ChainingModeCBC",
-      hashAlgorithm,
-      saltValue: keyDataSalt
-    },
-    dataIntegrity: {
-      encryptedHmacKey: new Uint8Array(0),
-      // Will be filled after encryption
-      encryptedHmacValue: new Uint8Array(0)
+      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: 16,
-      blockSize,
-      keyBits,
-      hashSize,
-      cipherAlgorithm: "AES",
-      cipherChaining: "ChainingModeCBC",
-      hashAlgorithm,
-      saltValue: pkeSalt,
-      spinCount,
-      encryptedVerifierHashInput,
-      encryptedVerifierHashValue,
-      encryptedKeyValue
+      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"))
     }
   };
-  const packageData = new Uint8Array(pptxBuffer);
-  const encryptedPackage = await encryptAgilePackage(packageData, documentKey, encInfo);
-  const hmacKeyRandom = new Uint8Array(hashSize);
-  crypto2.getRandomValues(hmacKeyRandom);
-  const hmacValue = await hmac(hashAlgorithm, hmacKeyRandom, encryptedPackage);
-  const hmacKeyIV = await generateIV(
-    hashAlgorithm,
-    keyDataSalt,
-    BLOCK_KEYS.dataIntegrityHmacKey,
-    blockSize
-  );
-  const paddedHmacKey = new Uint8Array(Math.ceil(hmacKeyRandom.length / blockSize) * blockSize);
-  paddedHmacKey.set(hmacKeyRandom);
-  const encryptedHmacKey = await aesCbcEncryptNoPad(documentKey, hmacKeyIV, paddedHmacKey);
-  const hmacValueIV = await generateIV(
-    hashAlgorithm,
-    keyDataSalt,
-    BLOCK_KEYS.dataIntegrityHmacValue,
-    blockSize
-  );
-  const paddedHmacValue = new Uint8Array(Math.ceil(hmacValue.length / blockSize) * blockSize);
-  paddedHmacValue.set(hmacValue);
-  const encryptedHmacValue = await aesCbcEncryptNoPad(documentKey, hmacValueIV, paddedHmacValue);
-  encInfo.dataIntegrity = {
-    encryptedHmacKey,
-    encryptedHmacValue
-  };
-  const xmlStr = buildAgileEncryptionInfoXml(
-    encInfo.keyData,
-    encInfo.passwordKeyEncryptor,
-    encInfo.dataIntegrity
-  );
-  const encryptionInfoBytes = buildEncryptionInfoStream(xmlStr);
-  const ole2Streams = /* @__PURE__ */ new Map();
-  ole2Streams.set("EncryptionInfo", encryptionInfoBytes);
-  ole2Streams.set("EncryptedPackage", encryptedPackage);
-  return buildOle2(ole2Streams);
+}
+var RC4_ALG_ID;
+var init_encryption_info = __esm({
+  "src/crypto/encryption-info.ts"() {
+    init_ooxml_crypto_primitives();
+    RC4_ALG_ID = 26625;
+  }
+});
+
+// src/crypto/index.ts
+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 key3 = await verifyStandardPassword(info, password);
+    if (!key3) throw new IncorrectPasswordError();
+    return new Uint8Array(await decryptStandardPackage(data, key3));
+  }
+  const key2 = await verifyAgilePassword(info, password);
+  if (!key2) throw new IncorrectPasswordError();
+  await verifyAgileDataIntegrity(info, key2, data);
+  return new Uint8Array(await decryptAgilePackage(data, key2, info));
+}
+function encryptOoxmlPackage(input, password, options = {}) {
+  const bytes = toBytes(input);
+  return options.encryptionScheme === "standard" ? encryptStandard(bytes, password, options) : encryptAgile(bytes, password, options);
+}
+var isStandard;
+var init_crypto = __esm({
+  "src/crypto/index.ts"() {
+    init_ole2_parser_read();
+    init_decrypt();
+    init_detect();
+    init_encrypt();
+    init_encryption_info();
+    init_errors();
+    isStandard = (info) => "isStandard" in info && info.isStandard;
+  }
+});
+
+// src/pptx/core/utils/ooxml-crypto-primitives.ts
+var init_ooxml_crypto_primitives2 = __esm({
+  "src/pptx/core/utils/ooxml-crypto-primitives.ts"() {
+    init_ooxml_crypto_primitives();
+  }
+});
+
+// src/pptx/core/utils/ooxml-crypto.ts
+async function decryptPptx(encryptedBuffer, password) {
+  return (await decryptOoxmlPackage(encryptedBuffer, password)).buffer;
+}
+async function encryptPptx(pptxBuffer, password, options) {
+  return (await encryptOoxmlPackage(pptxBuffer, password, options)).buffer;
 }
 var init_ooxml_crypto = __esm({
   "src/pptx/core/utils/ooxml-crypto.ts"() {
-    init_ole2_parser();
-    init_ooxml_crypto_decrypt();
-    init_ooxml_crypto_encrypt();
-    init_ooxml_crypto_errors();
-    init_ooxml_crypto_key_derivation();
-    init_ooxml_crypto_primitives2();
+    init_crypto();
+  }
+});
+
+// src/pptx/core/utils/ole2-parser.ts
+var init_ole2_parser = __esm({
+  "src/pptx/core/utils/ole2-parser.ts"() {
+    init_ole2_parser_types2();
+    init_ole2_parser_read2();
   }
 });
 
@@ -34219,12 +34734,12 @@ function transform(state, x) {
 function md4(message) {
   return mdStyleDigest(message, INITIAL_STATE, transform);
 }
-var INITIAL_STATE, K2, K3, ROUND1, ROUND2, ROUND3;
+var INITIAL_STATE, K22, K3, ROUND1, ROUND2, ROUND3;
 var init_md4 = __esm({
   "node_modules/.bun/@christophervr+ole2@0.4.0/node_modules/@christophervr/ole2/dist/utils/digests/md4.js"() {
     init_bit_ops();
     INITIAL_STATE = [1732584193, 4023233417, 2562383102, 271733878];
-    K2 = 1518500249;
+    K22 = 1518500249;
     K3 = 1859775393;
     ROUND1 = [
       [0, 3, 0],
@@ -34245,22 +34760,22 @@ var init_md4 = __esm({
       [15, 19, 0]
     ];
     ROUND2 = [
-      [0, 3, K2],
-      [4, 5, K2],
-      [8, 9, K2],
-      [12, 13, K2],
-      [1, 3, K2],
-      [5, 5, K2],
-      [9, 9, K2],
-      [13, 13, K2],
-      [2, 3, K2],
-      [6, 5, K2],
-      [10, 9, K2],
-      [14, 13, K2],
-      [3, 3, K2],
-      [7, 5, K2],
-      [11, 9, K2],
-      [15, 13, K2]
+      [0, 3, K22],
+      [4, 5, K22],
+      [8, 9, K22],
+      [12, 13, K22],
+      [1, 3, K22],
+      [5, 5, K22],
+      [9, 9, K22],
+      [13, 13, K22],
+      [2, 3, K22],
+      [6, 5, K22],
+      [10, 9, K22],
+      [14, 13, K22],
+      [3, 3, K22],
+      [7, 5, K22],
+      [11, 9, K22],
+      [15, 13, K22]
     ];
     ROUND3 = [
       [0, 3, K3],
@@ -34284,31 +34799,16 @@ var init_md4 = __esm({
 });
 
 // src/pptx/core/utils/signature-detection.ts
-function detectDigitalSignatures(zipEntryPaths) {
-  const sigPaths = zipEntryPaths.filter(
-    (p) => p.startsWith(SIGNATURE_PREFIX) && p.endsWith(".xml")
-  );
-  return {
-    hasSignatures: sigPaths.length > 0,
-    signatureCount: sigPaths.length,
-    signaturePaths: sigPaths
-  };
-}
-function getSignaturePathsToStrip(zipEntryPaths) {
-  return zipEntryPaths.filter((p) => p.startsWith(SIGNATURE_PREFIX));
-}
-var SIGNATURE_PREFIX;
 var init_signature_detection = __esm({
   "src/pptx/core/utils/signature-detection.ts"() {
-    SIGNATURE_PREFIX = "_xmlsignatures/";
+    init_detection();
   }
 });
 
 // src/pptx/core/utils/signature-constants.ts
-var DIGITAL_SIGNATURE_ORIGIN_REL_TYPE;
 var init_signature_constants = __esm({
   "src/pptx/core/utils/signature-constants.ts"() {
-    DIGITAL_SIGNATURE_ORIGIN_REL_TYPE = "http://schemas.openxmlformats.org/package/2006/relationships/digital-signature/origin";
+    init_constants3();
   }
 });
 
@@ -34698,11 +35198,11 @@ function parseSeriesErrBars(seriesNode, xmlLookup, extractPointValues, colorPars
     return result;
   }).filter((e) => e !== void 0);
 }
-function parseLineStyle(container, elementName, xmlLookup, colorParser) {
-  if (!container) {
+function parseLineStyle(container2, elementName, xmlLookup, colorParser) {
+  if (!container2) {
     return void 0;
   }
-  const lineNode = xmlLookup.getChildByLocalName(container, elementName);
+  const lineNode = xmlLookup.getChildByLocalName(container2, elementName);
   if (!lineNode) {
     return void 0;
   }
@@ -34767,9 +35267,9 @@ function chartColorChoiceValue(authored, color2, resolveColor2, opacity2) {
     opacity2
   );
 }
-function writeChartColorChoice(container, key2, color2, resolveColor2, opacity2) {
-  container[key2] = chartColorChoiceValue(
-    container[key2],
+function writeChartColorChoice(container2, key2, color2, resolveColor2, opacity2) {
+  container2[key2] = chartColorChoiceValue(
+    container2[key2],
     color2,
     resolveColor2,
     opacity2
@@ -35553,7 +36053,7 @@ function parseChartUniqueId(node, localName28) {
   const val = uniqueIdNode?.["@_val"];
   return typeof val === "string" && val.length > 0 ? val : void 0;
 }
-function randomBytes(length) {
+function randomBytes2(length) {
   const cryptoObj = typeof crypto === "undefined" ? void 0 : crypto;
   if (cryptoObj && typeof cryptoObj.getRandomValues === "function") {
     return cryptoObj.getRandomValues(new Uint8Array(length));
@@ -35565,7 +36065,7 @@ function randomBytes(length) {
   return bytes;
 }
 function randomHex(length) {
-  const bytes = randomBytes(Math.ceil(length / 2));
+  const bytes = randomBytes2(Math.ceil(length / 2));
   let out = "";
   for (const b of bytes) {
     out += b.toString(16).padStart(2, "0");
@@ -35574,7 +36074,7 @@ function randomHex(length) {
 }
 function generateChartUniqueId() {
   const cryptoObj = typeof crypto === "undefined" ? void 0 : crypto;
-  const variantNibble = (8 + randomBytes(1)[0] % 4).toString(16);
+  const variantNibble = (8 + randomBytes2(1)[0] % 4).toString(16);
   const uuid = cryptoObj && typeof cryptoObj.randomUUID === "function" ? cryptoObj.randomUUID() : `${randomHex(8)}-${randomHex(4)}-4${randomHex(3)}-${variantNibble}${randomHex(3)}-${randomHex(12)}`;
   return `{${uuid.toUpperCase()}}`;
 }
@@ -39643,10 +40143,10 @@ function parseVmlGroup(node, idPrefix, index) {
     return null;
   }
 }
-function parseVmlElements(container, idPrefix = "") {
+function parseVmlElements(container2, idPrefix = "") {
   const elements = [];
   for (const tag of VML_SHAPE_TAGS) {
-    const nodes = container[tag];
+    const nodes = container2[tag];
     if (!nodes) {
       continue;
     }
@@ -39746,8 +40246,8 @@ function diagnoseSelection(ac) {
   }
   return void 0;
 }
-function unwrapAlternateContent(container) {
-  const altContents = ensureArray3(container["mc:AlternateContent"]);
+function unwrapAlternateContent(container2) {
+  const altContents = ensureArray3(container2["mc:AlternateContent"]);
   if (altContents.length === 0) {
     return [];
   }
@@ -39767,7 +40267,7 @@ function unwrapAlternateContent(container) {
     for (const tag of SHAPE_TREE_ELEMENT_TAGS) {
       const children14 = ensureArray3(branch[tag]);
       if (children14.length > 0) {
-        container[tag] = [...ensureArray3(container[tag]), ...children14];
+        container2[tag] = [...ensureArray3(container2[tag]), ...children14];
         for (const child27 of children14) {
           block.childRefs.push({ tag, node: child27 });
         }
@@ -39777,11 +40277,11 @@ function unwrapAlternateContent(container) {
       blocks.push(block);
     }
   }
-  delete container["mc:AlternateContent"];
+  delete container2["mc:AlternateContent"];
   return blocks;
 }
-function reapplyAlternateContentToTree(container, blockByNode) {
-  let working = container;
+function reapplyAlternateContentToTree(container2, blockByNode) {
+  let working = container2;
   const groups = ensureArray3(working["p:grpSp"]);
   if (groups.length > 0) {
     let groupsChanged = false;
@@ -40642,16 +41142,16 @@ function applyActiveXControlsToSlide(slideXml3, controls) {
     return;
   }
   const nodes = controls.map(buildActiveXControlNode);
-  const container = cSld["p:controls"] ?? {};
+  const container2 = cSld["p:controls"] ?? {};
   const isNewContainer = cSld["p:controls"] === void 0;
-  container["p:control"] = nodes.length === 1 ? nodes[0] : nodes;
+  container2["p:control"] = nodes.length === 1 ? nodes[0] : nodes;
   if (isNewContainer && cSld["p:extLst"] !== void 0) {
     const extLst = cSld["p:extLst"];
     delete cSld["p:extLst"];
-    cSld["p:controls"] = container;
+    cSld["p:controls"] = container2;
     cSld["p:extLst"] = extLst;
   } else {
-    cSld["p:controls"] = container;
+    cSld["p:controls"] = container2;
   }
 }
 var init_activex_serializer = __esm({
@@ -42922,12 +43422,12 @@ var init_effect_dag_primitives = __esm({
 });
 
 // src/pptx/core/core/builders/effect-dag-serializer.ts
-function serializeEffectDagContainerNode(container) {
-  const xml = { "@_type": container.type };
-  if (container.name) {
-    xml["@_name"] = container.name;
+function serializeEffectDagContainerNode(container2) {
+  const xml = { "@_type": container2.type };
+  if (container2.name) {
+    xml["@_name"] = container2.name;
   }
-  for (const child27 of container.children) {
+  for (const child27 of container2.children) {
     appendChild2(xml, child27);
   }
   return xml;
@@ -42993,24 +43493,24 @@ function parseEffectDagContainer(node) {
   const type = VALID_CONTAINER_TYPES.has(typeAttr) ? typeAttr : "sib";
   const nameAttr = String(xml["@_name"] ?? "").trim();
   const children14 = parseChildren(xml);
-  const container = {
+  const container2 = {
     kind: "cont",
     type,
     children: children14
   };
   if (nameAttr) {
-    container.name = nameAttr;
+    container2.name = nameAttr;
   }
-  return container;
+  return container2;
 }
 function buildEffectDagTreeFromXml(effectDagXml) {
   return parseEffectDagContainer(effectDagXml);
 }
-function serializeEffectDagContainer(container) {
-  if (!container) {
+function serializeEffectDagContainer(container2) {
+  if (!container2) {
     return void 0;
   }
-  return serializeEffectDagContainerNode(container);
+  return serializeEffectDagContainerNode(container2);
 }
 function parseChildren(xml) {
   const children14 = [];
@@ -43076,7 +43576,7 @@ function parseBlend(value) {
   const modeAttr = String(xml["@_blend"] ?? "").trim().toLowerCase();
   const mode = VALID_BLEND_MODES.has(modeAttr) ? modeAttr : "over";
   const contNode = childByLocalName2(xml, "cont");
-  const container = parseEffectDagContainer(Array.isArray(contNode) ? contNode[0] : contNode) ?? {
+  const container2 = parseEffectDagContainer(Array.isArray(contNode) ? contNode[0] : contNode) ?? {
     kind: "cont",
     type: "sib",
     children: []
@@ -43084,7 +43584,7 @@ function parseBlend(value) {
   return {
     kind: "blend",
     mode,
-    container
+    container: container2
   };
 }
 function parseXfrm(value) {
@@ -44881,13 +45381,13 @@ function boolValue2(node) {
   const value = node["@_val"];
   return value !== "0" && value !== "false";
 }
-function parseBubbleChartOptions(container, localName28) {
-  if (!container) {
+function parseBubbleChartOptions(container2, localName28) {
+  if (!container2) {
     return void 0;
   }
   const node = (name) => {
-    const key2 = findKey11(container, name, localName28);
-    return key2 ? container[key2] : void 0;
+    const key2 = findKey11(container2, name, localName28);
+    return key2 ? container2[key2] : void 0;
   };
   const options = {};
   const bubble3D = boolValue2(node("bubble3D"));
@@ -44914,33 +45414,33 @@ function parseBubbleChartOptions(container, localName28) {
   }
   return Object.keys(options).length > 0 ? options : void 0;
 }
-function insertOrdered2(container, name, value, localName28) {
-  const existingKey = findKey11(container, name, localName28);
+function insertOrdered2(container2, name, value, localName28) {
+  const existingKey = findKey11(container2, name, localName28);
   if (existingKey) {
-    container[existingKey] = { ...container[existingKey], ...value };
+    container2[existingKey] = { ...container2[existingKey], ...value };
     return;
   }
-  const entries = Object.entries(container);
+  const entries = Object.entries(container2);
   const targetRank = ORDER2.indexOf(name);
   const index = entries.findIndex(([key2]) => {
     const rank = ORDER2.indexOf(localName28(key2));
     return rank >= 0 && rank > targetRank;
   });
   entries.splice(index < 0 ? entries.length : index, 0, [`c:${name}`, value]);
-  for (const key2 of Object.keys(container)) {
-    delete container[key2];
+  for (const key2 of Object.keys(container2)) {
+    delete container2[key2];
   }
   for (const [key2, child27] of entries) {
-    container[key2] = child27;
+    container2[key2] = child27;
   }
 }
-function applyBubbleChartOptions(container, options, localName28) {
+function applyBubbleChartOptions(container2, options, localName28) {
   if (options.bubble3D !== void 0) {
-    insertOrdered2(container, "bubble3D", { "@_val": options.bubble3D ? "1" : "0" }, localName28);
+    insertOrdered2(container2, "bubble3D", { "@_val": options.bubble3D ? "1" : "0" }, localName28);
   }
   if (options.bubbleScale !== void 0) {
     insertOrdered2(
-      container,
+      container2,
       "bubbleScale",
       {
         "@_val": chartPercentUnionValue(options.bubbleScale, {
@@ -44954,14 +45454,14 @@ function applyBubbleChartOptions(container, options, localName28) {
   }
   if (options.showNegativeBubbles !== void 0) {
     insertOrdered2(
-      container,
+      container2,
       "showNegBubbles",
       { "@_val": options.showNegativeBubbles ? "1" : "0" },
       localName28
     );
   }
   if (options.sizeRepresents !== void 0) {
-    insertOrdered2(container, "sizeRepresents", { "@_val": options.sizeRepresents }, localName28);
+    insertOrdered2(container2, "sizeRepresents", { "@_val": options.sizeRepresents }, localName28);
   }
 }
 var ORDER2;
@@ -45129,12 +45629,12 @@ var init_chart_up_down_bars = __esm({
 });
 
 // src/pptx/core/utils/drawing-media-reference.ts
-function parseDrawingMediaReference(container, externalRelIds) {
-  if (!container) {
+function parseDrawingMediaReference(container2, externalRelIds) {
+  if (!container2) {
     return void 0;
   }
   for (const kind of MEDIA_REFERENCE_NAMES) {
-    const node = child15(container, kind);
+    const node = child15(container2, kind);
     if (!node) {
       continue;
     }
@@ -45158,15 +45658,15 @@ function parseDrawingMediaReference(container, externalRelIds) {
   }
   return void 0;
 }
-function applyDrawingMediaReference(container, element, relationshipId2) {
+function applyDrawingMediaReference(container2, element, relationshipId2) {
   const kind = element.mediaReferenceKind;
   if (!kind) {
     return;
   }
-  const targetKey = Object.keys(container).find((key2) => localName13(key2) === kind);
-  for (const key2 of Object.keys(container)) {
+  const targetKey = Object.keys(container2).find((key2) => localName13(key2) === kind);
+  for (const key2 of Object.keys(container2)) {
     if (MEDIA_REFERENCE_NAMES.includes(localName13(key2))) {
-      delete container[key2];
+      delete container2[key2];
     }
   }
   const original = element.rawMediaReferenceXml ? { ...element.rawMediaReferenceXml } : {};
@@ -45183,7 +45683,7 @@ function applyDrawingMediaReference(container, element, relationshipId2) {
     if (extKey) {
       original[extKey] = extension;
     }
-    container[targetKey ?? "a:audioCd"] = original;
+    container2[targetKey ?? "a:audioCd"] = original;
     return;
   }
   if (kind === "wavAudioFile") {
@@ -45203,7 +45703,7 @@ function applyDrawingMediaReference(container, element, relationshipId2) {
       setAttribute4(original, "contentType", element.mediaReferenceContentType);
     }
   }
-  container[targetKey ?? `a:${kind}`] = original;
+  container2[targetKey ?? `a:${kind}`] = original;
 }
 function parseAudioCdPosition(value) {
   if (!value || typeof value !== "object") {
@@ -50132,10 +50632,10 @@ function applyPresentationDefaultTextStyle(presentation, levels) {
     PRESENTATION_BEFORE_DEFAULT_TEXT_STYLE
   );
 }
-function insertBeforeKeys(container, key2, value, before) {
+function insertBeforeKeys(container2, key2, value, before) {
   const rebuilt = {};
   let inserted = false;
-  for (const [childKey3, childValue] of Object.entries(container)) {
+  for (const [childKey3, childValue] of Object.entries(container2)) {
     if (childKey3 === key2) {
       continue;
     }
@@ -50148,10 +50648,10 @@ function insertBeforeKeys(container, key2, value, before) {
   if (!inserted) {
     rebuilt[key2] = value;
   }
-  for (const existingKey of Object.keys(container)) {
-    delete container[existingKey];
+  for (const existingKey of Object.keys(container2)) {
+    delete container2[existingKey];
   }
-  Object.assign(container, rebuilt);
+  Object.assign(container2, rebuilt);
 }
 var LEVEL_KEY_ORDER, SLDMASTER_BEFORE_TXSTYLES, TX_STYLES_CATEGORY_ORDER, PRESENTATION_BEFORE_DEFAULT_TEXT_STYLE;
 var init_master_text_style_writer = __esm({
@@ -56178,8 +56678,8 @@ function asNode(value) {
 }
 function parseShapeLocksFromNode(shape, spec) {
   const nv = asNode(shape?.[spec.nvKey]);
-  const container = asNode(nv?.[spec.cNvKey]);
-  return parseShapeLockNode(asNode(container?.[spec.lockTag]), spec);
+  const container2 = asNode(nv?.[spec.cNvKey]);
+  return parseShapeLockNode(asNode(container2?.[spec.lockTag]), spec);
 }
 function resolveLockContainerNode(shape, spec, create) {
   const nv = asNode(shape[spec.nvKey]);
@@ -59111,8 +59611,8 @@ function findCNvPr(shape) {
     return void 0;
   }
   for (const key2 of NV_CONTAINERS) {
-    const container = shape[key2];
-    const cNvPr = container?.["p:cNvPr"];
+    const container2 = shape[key2];
+    const cNvPr = container2?.["p:cNvPr"];
     if (cNvPr) {
       return cNvPr;
     }
@@ -59358,8 +59858,8 @@ async function loadLegacyVmlDrawings(zip, parser, slidePath, relsPath2) {
         continue;
       }
       const parsed = parser.parse(vmlXml);
-      const container = parsed["xml"] ?? parsed;
-      const shapes = parseVmlElements(container, `vml-${drawingIndex}-`);
+      const container2 = parsed["xml"] ?? parsed;
+      const shapes = parseVmlElements(container2, `vml-${drawingIndex}-`);
       results.push(...shapes);
       drawingIndex++;
     }
@@ -62570,12 +63070,12 @@ function collectInteractiveSequences(node, found) {
     );
   }
   containers.push(...ensureArray10(node["p:par"]), ...ensureArray10(node["p:seq"]));
-  for (const container of containers) {
-    if (isInteractiveSequence(container)) {
-      found.push(container);
+  for (const container2 of containers) {
+    if (isInteractiveSequence(container2)) {
+      found.push(container2);
       continue;
     }
-    collectInteractiveSequences(container, found);
+    collectInteractiveSequences(container2, found);
   }
 }
 function parseInteractiveSequences(rootPar, animations, walk3) {
@@ -62676,16 +63176,16 @@ function collectMediaNodes(node, animations) {
   const cTn = node["p:cTn"];
   const childTnList = cTn?.["p:childTnLst"];
   if (childTnList) {
-    for (const container of ["p:par", "p:seq", "p:excl"]) {
-      const children14 = ensureArray10(childTnList[container]);
+    for (const container2 of ["p:par", "p:seq", "p:excl"]) {
+      const children14 = ensureArray10(childTnList[container2]);
       for (const child27 of children14) {
         collectMediaNodes(child27, animations);
       }
     }
     collectMediaNodes(childTnList, animations);
   }
-  for (const container of ["p:par", "p:seq", "p:excl", "p:tnLst"]) {
-    const children14 = ensureArray10(node[container]);
+  for (const container2 of ["p:par", "p:seq", "p:excl", "p:tnLst"]) {
+    const children14 = ensureArray10(node[container2]);
     for (const child27 of children14) {
       collectMediaNodes(child27, animations);
     }
@@ -83696,7 +84196,7 @@ var init_layout_switch_placeholder_prompts = __esm({
 
 // src/pptx/core/core/types.ts
 var DEFAULT_MAX_UNCOMPRESSED_BYTES, MAX_ZIP_ENTRY_COUNT, ZipBombError;
-var init_types3 = __esm({
+var init_types4 = __esm({
   "src/pptx/core/core/types.ts"() {
     DEFAULT_MAX_UNCOMPRESSED_BYTES = 500 * 1024 * 1024;
     MAX_ZIP_ENTRY_COUNT = 65536;
@@ -84503,12 +85003,12 @@ function readCachedValues(refContainer, xmlLookup) {
   }
   return out;
 }
-function readRefOrLiteral(container, xmlLookup) {
-  const ref = xmlLookup.getChildByLocalName(container, "strRef") ?? xmlLookup.getChildByLocalName(container, "numRef");
+function readRefOrLiteral(container2, xmlLookup) {
+  const ref = xmlLookup.getChildByLocalName(container2, "strRef") ?? xmlLookup.getChildByLocalName(container2, "numRef");
   if (ref) {
     return readCachedValues(ref, xmlLookup);
   }
-  const literal2 = xmlLookup.getChildByLocalName(container, "strLit") ?? xmlLookup.getChildByLocalName(container, "numLit");
+  const literal2 = xmlLookup.getChildByLocalName(container2, "strLit") ?? xmlLookup.getChildByLocalName(container2, "numLit");
   return literal2 ? readCachedValues({ "c:strCache": literal2 }, xmlLookup) : [];
 }
 function parseOneFilteredSeries(node, xmlLookup) {
@@ -84543,15 +85043,15 @@ function parseOneFilteredSeries(node, xmlLookup) {
   }
   return result;
 }
-function findFilterExt(container, xmlLookup) {
-  const extLst = xmlLookup.getChildByLocalName(container, "extLst");
+function findFilterExt(container2, xmlLookup) {
+  const extLst = xmlLookup.getChildByLocalName(container2, "extLst");
   if (!extLst) {
     return void 0;
   }
   return xmlLookup.getChildrenArrayByLocalName(extLst, "ext").find((ext) => ext["@_uri"] === CHART_FILTERED_SERIES_EXT_URI);
 }
-function parseFilteredSeries(container, xmlLookup) {
-  const ext = findFilterExt(container, xmlLookup);
+function parseFilteredSeries(container2, xmlLookup) {
+  const ext = findFilterExt(container2, xmlLookup);
   if (!ext) {
     return void 0;
   }
@@ -84572,9 +85072,9 @@ function parseFilteredSeries(container, xmlLookup) {
   }
   return results.length > 0 ? results : void 0;
 }
-function collectFilteredSeriesIndices(container, xmlLookup) {
+function collectFilteredSeriesIndices(container2, xmlLookup) {
   const reserved = /* @__PURE__ */ new Set();
-  for (const filtered of parseFilteredSeries(container, xmlLookup) ?? []) {
+  for (const filtered of parseFilteredSeries(container2, xmlLookup) ?? []) {
     reserved.add(filtered.idx);
   }
   return reserved;
@@ -84619,8 +85119,8 @@ function readAxDataSource(cat, xmlLookup) {
   const ref = xmlLookup.getChildByLocalName(cat, "strRef") ?? xmlLookup.getChildByLocalName(cat, "numRef");
   return readCachedValues(ref, xmlLookup);
 }
-function parseFilteredTitles(container, xmlLookup) {
-  const ext = findFilterExt(container, xmlLookup);
+function parseFilteredTitles(container2, xmlLookup) {
+  const ext = findFilterExt(container2, xmlLookup);
   if (!ext) {
     return void 0;
   }
@@ -85535,8 +86035,8 @@ var init_chart_protection2 = __esm({
 });
 
 // src/pptx/core/utils/chart-series-axis.ts
-function resolveChartContainerValueAxisId(container, axes, xmlLookup) {
-  const referencedIds = xmlLookup.getChildrenArrayByLocalName(container, "axId").map((node) => Number.parseInt(String(node["@_val"]), 10)).filter(Number.isFinite);
+function resolveChartContainerValueAxisId(container2, axes, xmlLookup) {
+  const referencedIds = xmlLookup.getChildrenArrayByLocalName(container2, "axId").map((node) => Number.parseInt(String(node["@_val"]), 10)).filter(Number.isFinite);
   for (let index = referencedIds.length - 1; index >= 0; index--) {
     const id = referencedIds[index];
     if (axes.some((axis) => axis.axisType === "valAx" && axis.axisId === id)) {
@@ -91089,10 +91589,10 @@ function buildOle10Native(label, sourcePath, data) {
   return new ByteWriter().u32(body.length).bytes(body).toBytes();
 }
 function buildPackageStorage(label, sourcePath, data) {
-  const streams = /* @__PURE__ */ new Map();
-  streams.set("CompObj", hexToBytes(COMP_OBJ_HEX));
-  streams.set("Ole10Native", buildOle10Native(label, sourcePath, data));
-  return new Uint8Array(buildOle2(streams, PACKAGE_ROOT_CLSID));
+  const streams2 = /* @__PURE__ */ new Map();
+  streams2.set("CompObj", hexToBytes(COMP_OBJ_HEX));
+  streams2.set("Ole10Native", buildOle10Native(label, sourcePath, data));
+  return new Uint8Array(buildOle2(streams2, PACKAGE_ROOT_CLSID));
 }
 function buildExOleObjStg(storage) {
   return record(RT.ExternalOleObjectStg, storage, 0, false, 0);
@@ -91979,8 +92479,8 @@ function buildDrawing(canvasRect, shapes, backgroundRgb, fonts, drawingId, hyper
   const spgrData = new ByteWriter().bytes(buildCanvasPatriarch(allocator));
   const background = backgroundRgb ? buildBackgroundShape(backgroundRgb, allocator) : void 0;
   const prebuilt = prebuiltShapes?.(allocator) ?? [];
-  for (const container of prebuilt) {
-    spgrData.bytes(container);
+  for (const container2 of prebuilt) {
+    spgrData.bytes(container2);
   }
   for (const shape of shapes) {
     spgrData.bytes(buildAnyShapeContainer(shape, fonts, allocator, hyperlinks, oleEmbeds, mediaEmbeds));
@@ -92075,19 +92575,19 @@ function* iterateRecords(view, start, end) {
     offset = rec.dataOffset + rec.recLen;
   }
 }
-function* iterateChildren(view, container) {
-  yield* iterateRecords(view, container.dataOffset, container.dataOffset + container.recLen);
+function* iterateChildren(view, container2) {
+  yield* iterateRecords(view, container2.dataOffset, container2.dataOffset + container2.recLen);
 }
-function findChild4(view, container, recType, recInstance) {
-  for (const child27 of iterateChildren(view, container)) {
+function findChild4(view, container2, recType, recInstance) {
+  for (const child27 of iterateChildren(view, container2)) {
     if (child27.recType === recType && (recInstance === void 0 || child27.recInstance === recInstance)) {
       return child27;
     }
   }
   return void 0;
 }
-function findDescendant(view, container, recType, recInstance) {
-  for (const child27 of iterateChildren(view, container)) {
+function findDescendant(view, container2, recType, recInstance) {
+  for (const child27 of iterateChildren(view, container2)) {
     if (child27.recType === recType && (recInstance === void 0)) {
       return child27;
     }
@@ -92138,8 +92638,8 @@ function parseColorSchemeAtom(view, rec) {
   }
   return colors;
 }
-function findSchemeColors(view, container) {
-  for (const child27 of iterateChildren(view, container)) {
+function findSchemeColors(view, container2) {
+  for (const child27 of iterateChildren(view, container2)) {
     if (child27.recType === RT.ColorSchemeAtom && child27.recInstance === 1) {
       return parseColorSchemeAtom(view, child27);
     }
@@ -92803,13 +93303,13 @@ async function buildPptFile(deck, options = {}) {
   const encrypted = Boolean(options.password);
   const finished = encrypted ? await finishEncrypted(layout, lastSlideId, options.password) : await finishUnencrypted(layout, lastSlideId);
   const currentUser = buildCurrentUserStream(finished.offsetToCurrentEdit, encrypted);
-  const streams = /* @__PURE__ */ new Map();
-  streams.set("Current User", currentUser);
-  streams.set("PowerPoint Document", finished.documentBytes);
+  const streams2 = /* @__PURE__ */ new Map();
+  streams2.set("Current User", currentUser);
+  streams2.set("PowerPoint Document", finished.documentBytes);
   if (finished.picturesBytes && finished.picturesBytes.length > 0) {
-    streams.set("Pictures", finished.picturesBytes);
+    streams2.set("Pictures", finished.picturesBytes);
   }
-  return new Uint8Array(buildOle2(streams, PPT_STORAGE_CLSID, 0));
+  return new Uint8Array(buildOle2(streams2, PPT_STORAGE_CLSID, 0));
 }
 var init_write_ppt = __esm({
   "node_modules/.bun/@christophervr+ole2@0.4.0/node_modules/@christophervr/ole2/dist/ppt/writer/write-ppt.js"() {
@@ -93708,20 +94208,20 @@ function buildRestoredRegionXml(region) {
 }
 function applyCommonSlideContainer(root, name, props) {
   const key2 = findViewKey(root, name) ?? `p:${name}`;
-  const container = { ...root[key2] ?? {} };
-  const commonKey = findViewKey(container, "cSldViewPr") ?? "p:cSldViewPr";
-  container[commonKey] = buildCommonSlideView(props, viewChild(container, "cSldViewPr"));
-  root[key2] = container;
+  const container2 = { ...root[key2] ?? {} };
+  const commonKey = findViewKey(container2, "cSldViewPr") ?? "p:cSldViewPr";
+  container2[commonKey] = buildCommonSlideView(props, viewChild(container2, "cSldViewPr"));
+  root[key2] = container2;
 }
 function applyCommonViewContainer(root, name, props) {
   const key2 = findViewKey(root, name) ?? `p:${name}`;
-  const container = { ...root[key2] ?? {} };
-  const commonKey = findViewKey(container, "cViewPr") ?? "p:cViewPr";
+  const container2 = { ...root[key2] ?? {} };
+  const commonKey = findViewKey(container2, "cViewPr") ?? "p:cViewPr";
   const wrapper = buildCommonSlideView(props, {
-    "p:cViewPr": viewChild(container, "cViewPr") ?? {}
+    "p:cViewPr": viewChild(container2, "cViewPr") ?? {}
   });
-  container[commonKey] = viewChild(wrapper, "cViewPr");
-  root[key2] = container;
+  container2[commonKey] = viewChild(wrapper, "cViewPr");
+  root[key2] = container2;
 }
 var init_pptx_view_props_helpers = __esm({
   "src/pptx/core/core/runtime/pptx-view-props-helpers.ts"() {
@@ -94044,22 +94544,22 @@ function ordered3(existing, modeled, getLocalName2) {
   });
   return Object.fromEntries(entries);
 }
-function insertAfterLastSeries(container, dLbls, getLocalName2) {
-  const keys = Object.keys(container);
+function insertAfterLastSeries(container2, dLbls, getLocalName2) {
+  const keys = Object.keys(container2);
   let lastSer = -1;
   keys.forEach((k, i) => {
     if (getLocalName2(k) === "ser") {
       lastSer = i;
     }
   });
-  const entries = keys.map((k) => [k, container[k]]);
+  const entries = keys.map((k) => [k, container2[k]]);
   const at2 = lastSer === -1 ? entries.length : lastSer + 1;
   entries.splice(at2, 0, ["c:dLbls", dLbls]);
   for (const k of keys) {
-    delete container[k];
+    delete container2[k];
   }
   for (const [k, v] of entries) {
-    container[k] = v;
+    container2[k] = v;
   }
 }
 function buildDLbls(existing, opts, getLocalName2) {
@@ -94096,25 +94596,25 @@ function applyChartDataLabelsToXml(plotArea, style, getLocalName2) {
   }
   const chartTypeKeys = Object.keys(plotArea).filter((k) => getLocalName2(k).endsWith("Chart"));
   for (const ctKey of chartTypeKeys) {
-    const container = plotArea[ctKey];
-    if (!container || typeof container !== "object") {
+    const container2 = plotArea[ctKey];
+    if (!container2 || typeof container2 !== "object") {
       continue;
     }
-    const existingKey = findKey16(container, "dLbls", getLocalName2);
+    const existingKey = findKey16(container2, "dLbls", getLocalName2);
     if (style.hasDataLabels === false) {
-      const existing2 = existingKey ? container[existingKey] : void 0;
+      const existing2 = existingKey ? container2[existingKey] : void 0;
       const off = ordered3(existing2, { "c:delete": { "@_val": "1" } }, getLocalName2);
       if (existingKey) {
-        container[existingKey] = off;
+        container2[existingKey] = off;
       } else {
-        insertAfterLastSeries(container, off, getLocalName2);
+        insertAfterLastSeries(container2, off, getLocalName2);
       }
       continue;
     }
     const opts = style.dataLabels ?? {};
     const anyFlag = opts.showValue || opts.showCategory || opts.showSeriesName || opts.showPercent || opts.showLegendKey || opts.showBubbleSize;
     const effective = anyFlag ? opts : { ...opts, showValue: true };
-    const existing = existingKey ? container[existingKey] : void 0;
+    const existing = existingKey ? container2[existingKey] : void 0;
     const built = buildDLbls(existing, effective, getLocalName2);
     applyDataLabelsRangeToDLbls(
       built,
@@ -94123,9 +94623,9 @@ function applyChartDataLabelsToXml(plotArea, style, getLocalName2) {
       getLocalName2
     );
     if (existingKey) {
-      container[existingKey] = built;
+      container2[existingKey] = built;
     } else {
-      insertAfterLastSeries(container, built, getLocalName2);
+      insertAfterLastSeries(container2, built, getLocalName2);
     }
   }
 }
@@ -95120,54 +95620,54 @@ function axisFormatting(chartData, type, id, index = 0) {
   return chartData.axes?.find((axis) => axis.axisId === id) ?? chartData.axes?.filter((axis) => axis.axisType === type)[index];
 }
 function buildChartTypeContainer(chartData, family) {
-  const container = {};
+  const container2 = {};
   if (family === "bar") {
-    container["c:barDir"] = { "@_val": chartData.barDirection === "bar" ? "bar" : "col" };
-    container["c:grouping"] = {
+    container2["c:barDir"] = { "@_val": chartData.barDirection === "bar" ? "bar" : "col" };
+    container2["c:grouping"] = {
       "@_val": chartData.groupingStandard && (chartData.grouping ?? "clustered") === "clustered" ? "standard" : chartData.grouping ?? "clustered"
     };
-    container["c:varyColors"] = { "@_val": "0" };
+    container2["c:varyColors"] = { "@_val": "0" };
   } else if (family === "line" || family === "area") {
-    container["c:grouping"] = { "@_val": chartData.grouping ?? "standard" };
-    container["c:varyColors"] = { "@_val": "0" };
+    container2["c:grouping"] = { "@_val": chartData.grouping ?? "standard" };
+    container2["c:varyColors"] = { "@_val": "0" };
   } else if (family === "radar") {
-    container["c:radarStyle"] = { "@_val": chartData.radarStyle ?? "marker" };
-    container["c:varyColors"] = { "@_val": "0" };
+    container2["c:radarStyle"] = { "@_val": chartData.radarStyle ?? "marker" };
+    container2["c:varyColors"] = { "@_val": "0" };
   } else if (family === "scatter") {
-    container["c:scatterStyle"] = { "@_val": "lineMarker" };
-    container["c:varyColors"] = { "@_val": "0" };
+    container2["c:scatterStyle"] = { "@_val": "lineMarker" };
+    container2["c:varyColors"] = { "@_val": "0" };
   } else if (family === "ofPie") {
-    container["c:ofPieType"] = { "@_val": "pie" };
-    container["c:varyColors"] = { "@_val": "1" };
+    container2["c:ofPieType"] = { "@_val": "pie" };
+    container2["c:varyColors"] = { "@_val": "1" };
   } else if (family === "stock") ; else if (family === "surface") {
-    container["c:wireframe"] = { "@_val": chartData.wireframe === false ? "0" : "1" };
+    container2["c:wireframe"] = { "@_val": chartData.wireframe === false ? "0" : "1" };
   } else {
-    container["c:varyColors"] = { "@_val": family === "bubble" ? "0" : "1" };
+    container2["c:varyColors"] = { "@_val": family === "bubble" ? "0" : "1" };
   }
-  container["c:ser"] = chartData.series.map(
+  container2["c:ser"] = chartData.series.map(
     (s, i) => buildSeries(family, s, i, chartData.categories, chartData.dateCategories)
   );
   if (family === "bubble" && chartData.bubbleOptions) {
-    applyBubbleChartOptions(container, chartData.bubbleOptions, (key2) => key2.replace(/^.*:/u, ""));
+    applyBubbleChartOptions(container2, chartData.bubbleOptions, (key2) => key2.replace(/^.*:/u, ""));
   }
   if (family === "line" && chartData.upDownBars !== void 0) {
-    applyChartUpDownBars(container, chartData.upDownBars, (key2) => key2.replace(/^.*:/u, ""));
+    applyChartUpDownBars(container2, chartData.upDownBars, (key2) => key2.replace(/^.*:/u, ""));
   }
   if (family === "bar" || family === "ofPie") {
-    container["c:gapWidth"] = { "@_val": "150" };
+    container2["c:gapWidth"] = { "@_val": "150" };
   }
   if (family === "bar" && chartData.chartType === "bar3D" && chartData.barShape) {
-    container["c:shape"] = { "@_val": chartData.barShape };
+    container2["c:shape"] = { "@_val": chartData.barShape };
   }
   if (family === "stock") {
-    container["c:hiLowLines"] = {};
+    container2["c:hiLowLines"] = {};
   }
   if (family === "bar" || family === "line" || family === "area" || family === "radar" || family === "scatter" || family === "bubble" || family === "stock" || family === "surface") {
-    container["c:axId"] = [{ "@_val": String(CAT_AX_ID) }, { "@_val": String(VAL_AX_ID) }];
+    container2["c:axId"] = [{ "@_val": String(CAT_AX_ID) }, { "@_val": String(VAL_AX_ID) }];
   } else if (family === "doughnut") {
-    container["c:holeSize"] = { "@_val": "50" };
+    container2["c:holeSize"] = { "@_val": "50" };
   }
-  return container;
+  return container2;
 }
 function buildPlotArea(chartData, tag, family) {
   const plotArea = { "c:layout": {} };
@@ -95521,8 +96021,8 @@ async function writeCustomerDataScopes(zip, scopes, codec) {
       continue;
     }
     const sourceData = codec.parse(sourceXml);
-    const container = getContainer(sourceData, scope.location);
-    if (!container) {
+    const container2 = getContainer(sourceData, scope.location);
+    if (!container2) {
       continue;
     }
     const relsPath2 = relsForSourcePart(scope.sourcePartPath);
@@ -95557,9 +96057,9 @@ async function writeCustomerDataScopes(zip, scopes, codec) {
       authoredEntries.push(rawEntry);
       contentTypes2.set(path2, entry.contentType);
     }
-    const existingList = container["p:custDataLst"] ?? {};
+    const existingList = container2["p:custDataLst"] ?? {};
     existingList["p:custData"] = authoredEntries;
-    placeCustomerDataList(container, existingList, scope.location);
+    placeCustomerDataList(container2, existingList, scope.location);
     relsRoot["Relationship"] = relationships2;
     zip.file(relsPath2, codec.build(relsData));
     zip.file(scope.sourcePartPath, codec.build(sourceData));
@@ -95609,11 +96109,11 @@ function upsertRelationship(relationships2, entry, target) {
 function isCustomXmlRelationship(value) {
   return String(value ?? "").endsWith("/relationships/customXml");
 }
-function placeCustomerDataList(container, list2, location) {
+function placeCustomerDataList(container2, list2, location) {
   const insertBefore3 = location === "presentation" ? /* @__PURE__ */ new Set(["p:kinsoku", "p:defaultTextStyle", "p:modifyVerifier", "p:extLst"]) : /* @__PURE__ */ new Set(["p:controls", "p:extLst"]);
   const rebuilt = {};
   let inserted = false;
-  for (const [key2, value] of Object.entries(container)) {
+  for (const [key2, value] of Object.entries(container2)) {
     if (key2 === "p:custDataLst") {
       continue;
     }
@@ -95626,10 +96126,10 @@ function placeCustomerDataList(container, list2, location) {
   if (!inserted) {
     rebuilt["p:custDataLst"] = list2;
   }
-  for (const key2 of Object.keys(container)) {
-    delete container[key2];
+  for (const key2 of Object.keys(container2)) {
+    delete container2[key2];
   }
-  Object.assign(container, rebuilt);
+  Object.assign(container2, rebuilt);
 }
 async function upsertContentTypes(zip, codec, contentTypes2) {
   const xml = await zip.file("[Content_Types].xml")?.async("string");
@@ -95705,10 +96205,10 @@ function resolveTagsContainer(data) {
   }
   return void 0;
 }
-function placeAtKey(container, key2, value, insertBefore3) {
+function placeAtKey(container2, key2, value, insertBefore3) {
   const rebuilt = {};
   let inserted = false;
-  for (const [childKey3, childValue] of Object.entries(container)) {
+  for (const [childKey3, childValue] of Object.entries(container2)) {
     if (childKey3 === key2) {
       continue;
     }
@@ -95721,10 +96221,10 @@ function placeAtKey(container, key2, value, insertBefore3) {
   if (!inserted) {
     rebuilt[key2] = value;
   }
-  for (const existingKey of Object.keys(container)) {
-    delete container[existingKey];
+  for (const existingKey of Object.keys(container2)) {
+    delete container2[existingKey];
   }
-  Object.assign(container, rebuilt);
+  Object.assign(container2, rebuilt);
 }
 async function upsertTagsOwningElement(zip, codec, sourcePartPath, relationshipId2) {
   const xml = await zip.file(sourcePartPath)?.async("string");
@@ -95736,10 +96236,10 @@ async function upsertTagsOwningElement(zip, codec, sourcePartPath, relationshipI
   if (!resolved) {
     return;
   }
-  const { container, insertBefore: insertBefore3 } = resolved;
-  const list2 = { ...container["p:custDataLst"] ?? {} };
+  const { container: container2, insertBefore: insertBefore3 } = resolved;
+  const list2 = { ...container2["p:custDataLst"] ?? {} };
   list2["p:tags"] = { "@_r:id": relationshipId2 };
-  placeAtKey(container, "p:custDataLst", list2, insertBefore3);
+  placeAtKey(container2, "p:custDataLst", list2, insertBefore3);
   zip.file(sourcePartPath, codec.build(data));
 }
 async function removeTagsOwningElement(zip, codec, sourcePartPath) {
@@ -96256,21 +96756,21 @@ function normalizeGroupingNode(containerLocal, node) {
     node["@_val"] = normalizeChartGroupingValue(containerLocal, value);
   }
 }
-function normalizeChartContainerChildren(container, containerLocal, getLocalName2) {
+function normalizeChartContainerChildren(container2, containerLocal, getLocalName2) {
   if (!isKnownChartContainer(containerLocal)) {
     return;
   }
-  for (const key2 of Object.keys(container)) {
+  for (const key2 of Object.keys(container2)) {
     if (key2.startsWith("@_") || key2 === "#text") {
       continue;
     }
     const local = getLocalName2(key2);
     if (!chartContainerAllows(containerLocal, local)) {
-      delete container[key2];
+      delete container2[key2];
       continue;
     }
     if (local === "grouping") {
-      const node = container[key2];
+      const node = container2[key2];
       if (node && typeof node === "object" && !Array.isArray(node)) {
         normalizeGroupingNode(containerLocal, node);
       }
@@ -96278,18 +96778,18 @@ function normalizeChartContainerChildren(container, containerLocal, getLocalName
   }
   const required = REQUIRED_LEADING_CHILD[containerLocal];
   if (required) {
-    const present = Object.keys(container).some((k) => getLocalName2(k) === required.local);
+    const present = Object.keys(container2).some((k) => getLocalName2(k) === required.local);
     if (!present) {
-      container[`c:${required.local}`] = { "@_val": required.val };
+      container2[`c:${required.local}`] = { "@_val": required.val };
     }
   }
 }
-function orderChartContainerChildren(container, containerLocal, getLocalName2) {
+function orderChartContainerChildren(container2, containerLocal, getLocalName2) {
   const order = CHART_CONTAINER_CHILD_ORDER[containerLocal];
   if (!order) {
     return;
   }
-  const keys = Object.keys(container).filter((k) => !k.startsWith("@_") && k !== "#text");
+  const keys = Object.keys(container2).filter((k) => !k.startsWith("@_") && k !== "#text");
   if (keys.some((k) => !order.includes(getLocalName2(k)))) {
     return;
   }
@@ -96299,12 +96799,12 @@ function orderChartContainerChildren(container, containerLocal, getLocalName2) {
   if (sorted.every((k, i) => k === keys[i])) {
     return;
   }
-  const saved = sorted.map((k) => [k, container[k]]);
+  const saved = sorted.map((k) => [k, container2[k]]);
   for (const k of keys) {
-    delete container[k];
+    delete container2[k];
   }
   for (const [k, v] of saved) {
-    container[k] = v;
+    container2[k] = v;
   }
 }
 function renameXmlKeyInPlace(obj, oldKey, newKey) {
@@ -96325,12 +96825,12 @@ function referencedAxisIds(plotArea, getLocalName2) {
     if (!getLocalName2(key2).endsWith("Chart")) {
       continue;
     }
-    for (const container of toArray2(plotArea[key2])) {
-      for (const childKey3 of Object.keys(container)) {
+    for (const container2 of toArray2(plotArea[key2])) {
+      for (const childKey3 of Object.keys(container2)) {
         if (getLocalName2(childKey3) !== "axId") {
           continue;
         }
-        for (const axId of toArray2(container[childKey3])) {
+        for (const axId of toArray2(container2[childKey3])) {
           const val = axId["@_val"];
           if (val !== void 0) {
             ids.add(String(val));
@@ -96381,8 +96881,8 @@ var init_chart_container_schema = __esm({
 function findKey22(obj, local, getLocalName2) {
   return Object.keys(obj).find((k) => getLocalName2(k) === local);
 }
-function nonSeriesEntries(container, getLocalName2) {
-  return Object.keys(container).filter((k) => getLocalName2(k) !== "ser").map((k) => [k, container[k]]);
+function nonSeriesEntries(container2, getLocalName2) {
+  return Object.keys(container2).filter((k) => getLocalName2(k) !== "ser").map((k) => [k, container2[k]]);
 }
 function ensureArray17(v) {
   if (v === void 0) {
@@ -96398,9 +96898,9 @@ function consolidateComboContainersInXml(plotArea, getLocalName2) {
   const primaryKey = containerKeys[0];
   const containerChildren = /* @__PURE__ */ new Map();
   for (const key2 of containerKeys) {
-    const container = plotArea[key2];
-    if (container) {
-      containerChildren.set(getLocalName2(key2), nonSeriesEntries(container, getLocalName2));
+    const container2 = plotArea[key2];
+    if (container2) {
+      containerChildren.set(getLocalName2(key2), nonSeriesEntries(container2, getLocalName2));
     }
   }
   if (containerKeys.length === 1) {
@@ -96413,13 +96913,13 @@ function consolidateComboContainersInXml(plotArea, getLocalName2) {
   const serKey = findKey22(primary, "ser", getLocalName2) ?? "c:ser";
   const allSeries = [];
   for (const key2 of containerKeys) {
-    const container = plotArea[key2];
-    if (!container) {
+    const container2 = plotArea[key2];
+    if (!container2) {
       continue;
     }
-    const containerSerKey = findKey22(container, "ser", getLocalName2);
+    const containerSerKey = findKey22(container2, "ser", getLocalName2);
     if (containerSerKey) {
-      allSeries.push(...ensureArray17(container[containerSerKey]));
+      allSeries.push(...ensureArray17(container2[containerSerKey]));
     }
     if (key2 !== primaryKey) {
       delete plotArea[key2];
@@ -96466,21 +96966,21 @@ function applyComboSeriesTypesToXml(plotArea, originalKey, series, chartLevelTyp
   const at2 = keys.indexOf(originalKey);
   const newEntries = [];
   for (const local of groupOrder) {
-    const container = {};
+    const container2 = {};
     for (const [k, v] of originalChildren?.get(local) ?? fallbackEntries) {
-      container[k] = JSON.parse(JSON.stringify(v));
+      container2[k] = JSON.parse(JSON.stringify(v));
     }
     const grouped = groups.get(local);
-    container[serKey] = grouped.length === 1 ? grouped[0] : grouped;
+    container2[serKey] = grouped.length === 1 ? grouped[0] : grouped;
     applyGroupAxisReferences(
-      container,
+      container2,
       series.filter((_item, index) => resolved[index] === local),
       axes,
       getLocalName2
     );
-    normalizeChartContainerChildren(container, local, getLocalName2);
-    orderChartContainerChildren(container, local, getLocalName2);
-    newEntries.push([`c:${local}`, container]);
+    normalizeChartContainerChildren(container2, local, getLocalName2);
+    orderChartContainerChildren(container2, local, getLocalName2);
+    newEntries.push([`c:${local}`, container2]);
   }
   entries.splice(at2, 1, ...newEntries);
   for (const k of keys) {
@@ -96491,7 +96991,7 @@ function applyComboSeriesTypesToXml(plotArea, originalKey, series, chartLevelTyp
   }
   return true;
 }
-function applyGroupAxisReferences(container, series, axes, getLocalName2) {
+function applyGroupAxisReferences(container2, series, axes, getLocalName2) {
   const axisIds = new Set(series.map((item) => item.axisId).filter((id) => id !== void 0));
   if (axisIds.size !== 1) {
     return;
@@ -96502,8 +97002,8 @@ function applyGroupAxisReferences(container, series, axes, getLocalName2) {
   if (valueAxisId === void 0 || categoryAxisId === void 0) {
     return;
   }
-  const key2 = findKey22(container, "axId", getLocalName2) ?? "c:axId";
-  container[key2] = [{ "@_val": String(categoryAxisId) }, { "@_val": String(valueAxisId) }];
+  const key2 = findKey22(container2, "axId", getLocalName2) ?? "c:axId";
+  container2[key2] = [{ "@_val": String(categoryAxisId) }, { "@_val": String(valueAxisId) }];
 }
 var init_chart_combo_serializer = __esm({
   "src/pptx/core/utils/chart-combo-serializer.ts"() {
@@ -96556,8 +97056,8 @@ function buildFilteredSerNode(entry, categories) {
   }
   return node;
 }
-function filteredSeriesUnchanged(container, filteredSeries, xmlLookup) {
-  const existing = parseFilteredSeries(container, xmlLookup);
+function filteredSeriesUnchanged(container2, filteredSeries, xmlLookup) {
+  const existing = parseFilteredSeries(container2, xmlLookup);
   if (!filteredSeries || filteredSeries.length === 0) {
     return !existing || existing.length === 0;
   }
@@ -96569,9 +97069,9 @@ function filteredSeriesUnchanged(container, filteredSeries, xmlLookup) {
     return entry.idx === other.idx && entry.order === other.order && entry.name === other.name && entry.uniqueId === other.uniqueId && JSON.stringify(entry.values ?? null) === JSON.stringify(other.values ?? null) && JSON.stringify(entry.categories ?? null) === JSON.stringify(other.categories ?? null);
   });
 }
-function applyFilteredSeriesToXml(container, filteredSeries, categories, containerLocalName, getLocalName2) {
-  const extLstKey = findKey23(container, "extLst", getLocalName2) ?? "c:extLst";
-  const extLst = { ...container[extLstKey] ?? {} };
+function applyFilteredSeriesToXml(container2, filteredSeries, categories, containerLocalName, getLocalName2) {
+  const extLstKey = findKey23(container2, "extLst", getLocalName2) ?? "c:extLst";
+  const extLst = { ...container2[extLstKey] ?? {} };
   const extKey = findKey23(extLst, "ext", getLocalName2);
   const exts = extKey ? Array.isArray(extLst[extKey]) ? [...extLst[extKey]] : [extLst[extKey]] : [];
   const otherExts = exts.filter((ext) => ext["@_uri"] !== CHART_FILTERED_SERIES_EXT_URI);
@@ -96596,11 +97096,11 @@ function applyFilteredSeriesToXml(container, filteredSeries, categories, contain
   );
   const newExts = ownExtHasContent ? [...otherExts, ownExt] : otherExts;
   if (newExts.length === 0) {
-    delete container[extLstKey];
+    delete container2[extLstKey];
     return;
   }
   extLst[extKey ?? "c:ext"] = newExts.length === 1 ? newExts[0] : newExts;
-  container[extLstKey] = extLst;
+  container2[extLstKey] = extLst;
 }
 var init_chart_filtered_series_writer = __esm({
   "src/pptx/core/utils/chart-filtered-series-writer.ts"() {
@@ -97402,11 +97902,11 @@ var init_chart_title_style_serializer = __esm({
     };
   }
 });
-function collectChartWorkbookWrite(xmlLookupService, container, isNumeric, values) {
-  if (!container) {
+function collectChartWorkbookWrite(xmlLookupService, container2, isNumeric, values) {
+  if (!container2) {
     return void 0;
   }
-  const refNode = xmlLookupService.getChildByLocalName(container, isNumeric ? "numRef" : "strRef");
+  const refNode = xmlLookupService.getChildByLocalName(container2, isNumeric ? "numRef" : "strRef");
   const formula = refNode ? xmlLookupService.getScalarChildByLocalName(refNode, "f") : void 0;
   return formula ? { formula, isNumeric, values } : void 0;
 }
@@ -98169,12 +98669,12 @@ function applyPicAltText(node, altText) {
 }
 function applyChildXfrmToRawNode(node, off, ext) {
   const spPrKey = findChildKey2(node, "spPr");
-  const container = spPrKey ? node[spPrKey] ?? node : node;
-  const xfrmKey = findChildKey2(container, "xfrm");
+  const container2 = spPrKey ? node[spPrKey] ?? node : node;
+  const xfrmKey = findChildKey2(container2, "xfrm");
   if (!xfrmKey) {
     return;
   }
-  const xfrm = container[xfrmKey];
+  const xfrm = container2[xfrmKey];
   const offKey = findChildKey2(xfrm, "off") ?? "a:off";
   const extKey = findChildKey2(xfrm, "ext") ?? "a:ext";
   xfrm[offKey] = { "@_x": String(Math.round(off.x)), "@_y": String(Math.round(off.y)) };
@@ -98182,13 +98682,13 @@ function applyChildXfrmToRawNode(node, off, ext) {
 }
 function applyRotationFlipToRawNode(node, rotation, flipH, flipV) {
   const spPrKey = findChildKey2(node, "spPr");
-  const container = spPrKey ? node[spPrKey] ?? node : node;
-  const xfrmKey = findChildKey2(container, "xfrm");
+  const container2 = spPrKey ? node[spPrKey] ?? node : node;
+  const xfrmKey = findChildKey2(container2, "xfrm");
   const hasAny = Boolean(rotation) || Boolean(flipH) || Boolean(flipV);
   if (!xfrmKey && !hasAny) {
     return;
   }
-  const xfrm = xfrmKey ? container[xfrmKey] : {};
+  const xfrm = xfrmKey ? container2[xfrmKey] : {};
   if (rotation) {
     xfrm["@_rot"] = String(Math.round(rotation * 6e4));
   } else {
@@ -98204,9 +98704,9 @@ function applyRotationFlipToRawNode(node, rotation, flipH, flipV) {
   } else {
     delete xfrm["@_flipV"];
   }
-  container[xfrmKey ?? "a:xfrm"] = xfrm;
+  container2[xfrmKey ?? "a:xfrm"] = xfrm;
   if (spPrKey) {
-    node[spPrKey] = container;
+    node[spPrKey] = container2;
   }
 }
 var init_chart_user_shapes_raw_patch = __esm({
@@ -98556,8 +99056,8 @@ var init_placeholder_remap = __esm({
 
 // src/pptx/core/utils/placeholder-xml.ts
 function findNonVisualProps(rawXml) {
-  for (const container of ["p:nvSpPr", "p:nvPicPr", "p:nvGraphicFramePr"]) {
-    const parent = rawXml[container];
+  for (const container2 of ["p:nvSpPr", "p:nvPicPr", "p:nvGraphicFramePr"]) {
+    const parent = rawXml[container2];
     const nvPr = parent?.["p:nvPr"];
     if (nvPr) {
       return nvPr;
@@ -101448,9 +101948,9 @@ var init_PptxHandlerRuntimeElementActions = __esm({
           }
           return;
         }
-        const container = existing ?? resolveLockContainerNode(shape, spec, true);
-        if (container) {
-          container[spec.lockTag] = next;
+        const container2 = existing ?? resolveLockContainerNode(shape, spec, true);
+        if (container2) {
+          container2[spec.lockTag] = next;
         }
       }
     };
@@ -101957,8 +102457,8 @@ var init_PptxHandlerRuntimeMediaTimingParsing = __esm({
         if (cTn) {
           const childTnLst = cTn["p:childTnLst"];
           if (childTnLst) {
-            for (const container of ["p:par", "p:seq", "p:excl"]) {
-              const children14 = this.ensureArray(childTnLst[container]);
+            for (const container2 of ["p:par", "p:seq", "p:excl"]) {
+              const children14 = this.ensureArray(childTnLst[container2]);
               for (const child27 of children14) {
                 this.walkMediaTimingTree(child27, result, slidePath);
               }
@@ -101966,8 +102466,8 @@ var init_PptxHandlerRuntimeMediaTimingParsing = __esm({
             this.walkMediaTimingTree(childTnLst, result, slidePath);
           }
         }
-        for (const container of ["p:par", "p:seq", "p:excl", "p:tnLst"]) {
-          const children14 = this.ensureArray(node[container]);
+        for (const container2 of ["p:par", "p:seq", "p:excl", "p:tnLst"]) {
+          const children14 = this.ensureArray(node[container2]);
           for (const child27 of children14) {
             this.walkMediaTimingTree(child27, result, slidePath);
           }
@@ -103132,8 +103632,8 @@ var init_PptxHandlerRuntimePresentationProps = __esm({
        * `<a:noFill/>` parses to the empty STRING, so presence - not truthiness -
        * has to decide.
        */
-      parseChartContainerFill(container) {
-        const shapeProperties = this.xmlLookupService.getChildByLocalName(container, "spPr");
+      parseChartContainerFill(container2) {
+        const shapeProperties = this.xmlLookupService.getChildByLocalName(container2, "spPr");
         if (!shapeProperties) {
           return void 0;
         }
@@ -109057,10 +109557,10 @@ var init_PptxHandlerRuntimeSaveDataSerialization = __esm({
               if (!local.endsWith("Chart")) {
                 continue;
               }
-              const container = plotArea[key2];
-              if (container) {
+              const container2 = plotArea[key2];
+              if (container2) {
                 orderChartContainerChildren(
-                  container,
+                  container2,
                   local,
                   (k) => this.compatibilityService.getXmlLocalName(k)
                 );
@@ -109139,8 +109639,8 @@ var init_PptxHandlerRuntimeSaveDataSerialization = __esm({
        * when the container has no formula reference (e.g. a brand-new series
        * built without one), so it is always safe to call.
        */
-      pushChartWorkbookWrite(workbookWrites, container, isNumeric, values) {
-        const write = collectChartWorkbookWrite(this.xmlLookupService, container, isNumeric, values);
+      pushChartWorkbookWrite(workbookWrites, container2, isNumeric, values) {
+        const write = collectChartWorkbookWrite(this.xmlLookupService, container2, isNumeric, values);
         if (write) {
           workbookWrites.push(write);
         }
@@ -109149,17 +109649,17 @@ var init_PptxHandlerRuntimeSaveDataSerialization = __esm({
        * Update the cached point values in a chart reference node
        * (numRef/strRef or numLit/strLit).
        */
-      updateChartCacheValues(container, isNumeric, values) {
+      updateChartCacheValues(container2, isNumeric, values) {
         const refName = isNumeric ? "numRef" : "strRef";
         const litName = isNumeric ? "numLit" : "strLit";
         const cacheName = isNumeric ? "numCache" : "strCache";
-        const refNode = this.xmlLookupService.getChildByLocalName(container, refName) || this.xmlLookupService.getChildByLocalName(container, litName);
+        const refNode = this.xmlLookupService.getChildByLocalName(container2, refName) || this.xmlLookupService.getChildByLocalName(container2, litName);
         if (!refNode) {
-          const literalKey = Object.keys(container).find(
+          const literalKey = Object.keys(container2).find(
             (key2) => this.compatibilityService.getXmlLocalName(key2) === "v"
           );
           if (literalKey && values.length === 1) {
-            container[literalKey] = values[0];
+            container2[literalKey] = values[0];
           }
           return;
         }
@@ -116411,9 +116911,9 @@ function rememberTemplateSpTreePositions(runtime, partPath, spTree, positionOf)
   }
   byPart.set(partPath, positions);
 }
-function withReplacedChild(container, tag, indexInType, replacement) {
-  const existing = container[tag];
-  const next = { ...container };
+function withReplacedChild(container2, tag, indexInType, replacement) {
+  const existing = container2[tag];
+  const next = { ...container2 };
   if (Array.isArray(existing)) {
     const siblings = [...existing];
     siblings[indexInType] = replacement;
@@ -116423,8 +116923,8 @@ function withReplacedChild(container, tag, indexInType, replacement) {
   }
   return next;
 }
-function orderContainer(container, plan, getLocalName2) {
-  let working = container;
+function orderContainer(container2, plan, getLocalName2) {
+  let working = container2;
   for (const entry of plan) {
     if (entry.children.length === 0) {
       continue;
@@ -120640,8 +121140,8 @@ function asRuns(value) {
 function withSplit(authored, inherited) {
   return { ...inherited, ...authored, authoredRunStyle: authored, inheritedRunStyle: inherited };
 }
-function readRuns(container, extract) {
-  const runs = asRuns(container?.["a:r"]);
+function readRuns(container2, extract) {
+  const runs = asRuns(container2?.["a:r"]);
   const text2 = runs.map((run) => run["a:t"] !== void 0 ? xmlText(run["a:t"]) ?? "" : "").join("");
   const first = runs[0];
   return {
@@ -122138,8 +122638,8 @@ var init_PptxHandlerRuntimeSpTreeParsing = __esm({
        * so the save layer can re-emit the original `<mc:Choice>` /
        * `<mc:Fallback>` shape on dirty save (CC-4).
        */
-      unwrapAlternateContent(container) {
-        const blocks = unwrapAlternateContent(container);
+      unwrapAlternateContent(container2) {
+        const blocks = unwrapAlternateContent(container2);
         for (const block of blocks) {
           for (const ref of block.childRefs) {
             this.alternateContentBlockByRawXml.set(ref.node, block);
@@ -127224,17 +127724,17 @@ var init_PptxHandlerRuntimeSmartArtParsing = __esm({
 // src/pptx/core/core/runtime/smartart-drawing-blip.ts
 function collectDrawingShapeNodes(root, getChildren) {
   const out = [];
-  const walk3 = (container) => {
-    if (!container) {
+  const walk3 = (container2) => {
+    if (!container2) {
       return;
     }
-    for (const sp of getChildren(container, "sp")) {
+    for (const sp of getChildren(container2, "sp")) {
       out.push({ node: sp, isPic: false });
     }
-    for (const pic of getChildren(container, "pic")) {
+    for (const pic of getChildren(container2, "pic")) {
       out.push({ node: pic, isPic: true });
     }
-    for (const grp of getChildren(container, "grpSp")) {
+    for (const grp of getChildren(container2, "grpSp")) {
       walk3(grp);
     }
   };
@@ -128743,13 +129243,13 @@ var init_PptxHandlerRuntimeChartParsing = __esm({
         let filteredSeriesTitle;
         let filteredCategoryTitle;
         for (const containerKey of containerKeys) {
-          const container = plotArea[containerKey];
-          const seriesList = this.xmlLookupService.getChildrenArrayByLocalName(container, "ser");
-          const containerFilteredSeries = parseFilteredSeries(container, this.xmlLookupService);
+          const container2 = plotArea[containerKey];
+          const seriesList = this.xmlLookupService.getChildrenArrayByLocalName(container2, "ser");
+          const containerFilteredSeries = parseFilteredSeries(container2, this.xmlLookupService);
           if (containerFilteredSeries) {
             filteredSeries = [...filteredSeries ?? [], ...containerFilteredSeries];
           }
-          const containerFilteredTitles = parseFilteredTitles(container, this.xmlLookupService);
+          const containerFilteredTitles = parseFilteredTitles(container2, this.xmlLookupService);
           if (containerFilteredTitles?.seriesTitle && filteredSeriesTitle === void 0) {
             filteredSeriesTitle = containerFilteredTitles.seriesTitle;
           }
@@ -128776,7 +129276,7 @@ var init_PptxHandlerRuntimeChartParsing = __esm({
             this.compatibilityService.getXmlLocalName(containerKey)
           );
           const containerType = isCombo ? resolvedContainerType : void 0;
-          const axisId = resolveChartContainerValueAxisId(container, axes ?? [], this.xmlLookupService);
+          const axisId = resolveChartContainerValueAxisId(container2, axes ?? [], this.xmlLookupService);
           series.push(
             ...this.buildChartSeries(
               seriesList,
@@ -128814,8 +129314,8 @@ var init_PptxHandlerRuntimeChartParsing = __esm({
        * Read a numeric `@val` from a named child of a chart-type container.
        * Returns `undefined` when the child or its `@val` is absent/non-finite.
        */
-      parseChartNumberVal(container, localName28) {
-        const node = this.xmlLookupService.getChildByLocalName(container, localName28);
+      parseChartNumberVal(container2, localName28) {
+        const node = this.xmlLookupService.getChildByLocalName(container2, localName28);
         const raw = node?.["@_val"];
         if (raw === void 0 || raw === null || raw === "") {
           return void 0;
@@ -128828,8 +129328,8 @@ var init_PptxHandlerRuntimeChartParsing = __esm({
        * A present element with no `@val` follows the OOXML `CT_Boolean` default
        * of `true`; `undefined` when the child is absent.
        */
-      parseChartBoolVal(container, localName28) {
-        const node = this.xmlLookupService.getChildByLocalName(container, localName28);
+      parseChartBoolVal(container2, localName28) {
+        const node = this.xmlLookupService.getChildByLocalName(container2, localName28);
         if (!node) {
           return void 0;
         }
@@ -129499,7 +129999,7 @@ var init_PptxHandlerRuntimeLoadSession = __esm({
     init_ole_embedded_extract();
     init_ole_utils();
     init_signature_detection();
-    init_types3();
+    init_types4();
     init_authored_slide_background();
     init_bullet_picture_image_enrichment();
     init_PptxHandlerRuntimeEmbeddedFonts();
@@ -131011,14 +131511,14 @@ var init_text_atoms = __esm({
 function readCString(view, rec) {
   return decodeTextChars(view, rec.dataOffset, rec.recLen);
 }
-function parseExHyperlinkContainer(view, container) {
-  const atom2 = findChild4(view, container, RT.ExternalHyperlinkAtom);
+function parseExHyperlinkContainer(view, container2) {
+  const atom2 = findChild4(view, container2, RT.ExternalHyperlinkAtom);
   if (!atom2 || atom2.recLen < 4) {
     return void 0;
   }
   const id = view.getUint32(atom2.dataOffset, true);
   const strings2 = {};
-  for (const child27 of iterateChildren(view, container)) {
+  for (const child27 of iterateChildren(view, container2)) {
     if (child27.recType !== RT.CString) {
       continue;
     }
@@ -131278,14 +131778,14 @@ var init_persist_directory2 = __esm({
 function readCString2(view, rec) {
   return decodeTextChars(view, rec.dataOffset, rec.recLen);
 }
-function parseOleEmbedContainer(view, container) {
-  const atom2 = findChild4(view, container, RT.ExternalOleObjectAtom);
+function parseOleEmbedContainer(view, container2) {
+  const atom2 = findChild4(view, container2, RT.ExternalOleObjectAtom);
   if (!atom2 || atom2.recLen < 24) {
     return void 0;
   }
   const exObjId = view.getUint32(atom2.dataOffset + 8, true);
   const persistIdRef = view.getUint32(atom2.dataOffset + 16, true);
-  const progIdRec = findChild4(view, container, RT.CString, 2);
+  const progIdRec = findChild4(view, container2, RT.CString, 2);
   const progId = progIdRec ? readCString2(view, progIdRec) : void 0;
   return { exObjId, ref: { persistIdRef, progId } };
 }
@@ -131947,7 +132447,7 @@ function arrowType(value) {
   return ARROW_MAP[value] ?? "triangle";
 }
 var OPT2, DASH_MAP, ARROW_MAP;
-var init_properties = __esm({
+var init_properties2 = __esm({
   "src/pptx/core/ppt/escher/properties.ts"() {
     OPT2 = {
       rotation: 4,
@@ -132106,14 +132606,14 @@ var init_shape_props = __esm({
     init_color_scheme2();
     init_record_types2();
     init_geometry_map();
-    init_properties();
+    init_properties2();
     GRADIENT_FILL_TYPES = /* @__PURE__ */ new Set([4, 5, 6, 7, 8]);
   }
 });
 
 // src/pptx/core/ppt/escher/sp-container.ts
-function parseShape2(ctx, container) {
-  const fsp = findChild4(ctx.view, container, OA.FSP);
+function parseShape2(ctx, container2) {
+  const fsp = findChild4(ctx.view, container2, OA.FSP);
   if (!fsp || fsp.recLen < 8) {
     return void 0;
   }
@@ -132122,10 +132622,10 @@ function parseShape2(ctx, container) {
   if (flags & FSP_FLAG_DELETED) {
     return void 0;
   }
-  const optRec = findChild4(ctx.view, container, OA.FOPT);
+  const optRec = findChild4(ctx.view, container2, OA.FOPT);
   const props = optRec ? parseProperties(ctx.view, ctx.data, optRec) : { values: /* @__PURE__ */ new Map(), complex: /* @__PURE__ */ new Map() };
-  const anchorRec = findChild4(ctx.view, container, OA.ClientAnchor);
-  const childAnchorRec = findChild4(ctx.view, container, OA.ChildAnchor);
+  const anchorRec = findChild4(ctx.view, container2, OA.ClientAnchor);
+  const childAnchorRec = findChild4(ctx.view, container2, OA.ChildAnchor);
   const anchor = anchorRec ? readClientAnchor(ctx.view, anchorRec) : childAnchorRec ? readChildAnchor(ctx.view, childAnchorRec) : void 0;
   const namePayload = props.complex.get(OPT2.wzName);
   const name = namePayload ? decodeComplexString(namePayload) : void 0;
@@ -132133,7 +132633,7 @@ function parseShape2(ctx, container) {
   const rotationDeg = rotationRaw !== void 0 ? rotationToDegrees(rotationRaw) : void 0;
   const flipH = (flags & FSP_FLAG_FLIPH2) !== 0 ? true : void 0;
   const flipV = (flags & FSP_FLAG_FLIPV2) !== 0 ? true : void 0;
-  const clientData = findChild4(ctx.view, container, OA.ClientData);
+  const clientData = findChild4(ctx.view, container2, OA.ClientData);
   const actionClick = clientData ? resolveShapeInteractiveInfo(ctx.view, clientData, ctx.hyperlinkStrings) : void 0;
   const pib = props.values.get(OPT2.pib);
   if (pib !== void 0 && pib > 0) {
@@ -132187,7 +132687,7 @@ function parseShape2(ctx, container) {
       shape.placeholderType = placeholderType;
     }
   }
-  const clientTextbox2 = findChild4(ctx.view, container, OA.ClientTextbox);
+  const clientTextbox2 = findChild4(ctx.view, container2, OA.ClientTextbox);
   if (clientTextbox2) {
     const text2 = extractText(ctx, clientTextbox2);
     if (text2 && text2.paragraphs.some((p) => p.runs.length > 0)) {
@@ -132199,11 +132699,11 @@ function parseShape2(ctx, container) {
   }
   return shape;
 }
-function parseGroup(ctx, container) {
+function parseGroup(ctx, container2) {
   const children14 = [];
   let groupShape;
   let first = true;
-  for (const child27 of iterateChildren(ctx.view, container)) {
+  for (const child27 of iterateChildren(ctx.view, container2)) {
     if (child27.recType === OA.SpContainer && first) {
       groupShape = child27;
       first = false;
@@ -132273,8 +132773,8 @@ function parseDrawing(ctx, dgContainer) {
   }
   return result;
 }
-function extractBackground(ctx, container) {
-  const fsp = findChild4(ctx.view, container, OA.FSP);
+function extractBackground(ctx, container2) {
+  const fsp = findChild4(ctx.view, container2, OA.FSP);
   if (!fsp || fsp.recLen < 8) {
     return void 0;
   }
@@ -132282,7 +132782,7 @@ function extractBackground(ctx, container) {
   if ((flags & FSP_FLAG_BACKGROUND2) === 0 || (flags & FSP_FLAG_GROUP2) !== 0) {
     return void 0;
   }
-  const optRec = findChild4(ctx.view, container, OA.FOPT);
+  const optRec = findChild4(ctx.view, container2, OA.FOPT);
   if (!optRec) {
     return ctx.scheme[0];
   }
@@ -132299,7 +132799,7 @@ var init_sp_container = __esm({
     init_record_types2();
     init_client_data_extract();
     init_geometry_map();
-    init_properties();
+    init_properties2();
     init_shape_props();
     FSP_FLAG_GROUP2 = 1;
     FSP_FLAG_DELETED = 8;
@@ -132310,22 +132810,22 @@ var init_sp_container = __esm({
 });
 
 // src/pptx/core/ppt/slide-parser.ts
-function parseSlideContainer(inputs, container) {
+function parseSlideContainer(inputs, container2) {
   const { view, data, fonts } = inputs;
   let followMasterBackground = true;
   let followMasterScheme = true;
   let followMasterObjects = true;
-  const slideAtom = findChild4(view, container, RT.SlideAtom);
+  const slideAtom = findChild4(view, container2, RT.SlideAtom);
   if (slideAtom && slideAtom.recLen >= 24) {
     const flags = view.getUint16(slideAtom.dataOffset + 20, true);
     followMasterObjects = (flags & SLIDE_FLAG_MASTER_OBJECTS2) !== 0;
     followMasterScheme = (flags & SLIDE_FLAG_MASTER_SCHEME2) !== 0;
     followMasterBackground = (flags & SLIDE_FLAG_MASTER_BACKGROUND2) !== 0;
   }
-  const ownScheme = findSchemeColors(view, container);
+  const ownScheme = findSchemeColors(view, container2);
   const scheme = followMasterScheme ? inputs.masterScheme : ownScheme ?? inputs.masterScheme;
   const slide = { followMasterBackground, followMasterObjects, shapes: [] };
-  const drawing = findChild4(view, container, RT.Drawing);
+  const drawing = findChild4(view, container2, RT.Drawing);
   if (drawing) {
     const dgContainer = findDescendant(view, drawing, OA.DgContainer);
     if (dgContainer) {
@@ -132348,12 +132848,12 @@ function parseSlideContainer(inputs, container) {
   }
   return slide;
 }
-function parseMasterContainer(view, data, fonts, fallbackScheme, container, hyperlinkStrings, oleExObjIds) {
-  const scheme = findSchemeColors(view, container);
+function parseMasterContainer(view, data, fonts, fallbackScheme, container2, hyperlinkStrings, oleExObjIds) {
+  const scheme = findSchemeColors(view, container2);
   const active = scheme ?? fallbackScheme;
   let backgroundRgb;
   let shapes = [];
-  const drawing = findChild4(view, container, RT.Drawing);
+  const drawing = findChild4(view, container2, RT.Drawing);
   if (drawing) {
     const dgContainer = findDescendant(view, drawing, OA.DgContainer);
     if (dgContainer) {
@@ -132373,7 +132873,7 @@ function parseMasterContainer(view, data, fonts, fallbackScheme, container, hype
       );
     }
   }
-  return { scheme, backgroundRgb, shapes, container };
+  return { scheme, backgroundRgb, shapes, container: container2 };
 }
 var SLIDE_FLAG_MASTER_OBJECTS2, SLIDE_FLAG_MASTER_SCHEME2, SLIDE_FLAG_MASTER_BACKGROUND2;
 var init_slide_parser = __esm({
@@ -132524,11 +133024,11 @@ function findBStore(view, docContainer) {
   }
   return findDescendant(view, drawingGroup, OA.BStoreContainer);
 }
-async function parseDeck(streams) {
-  const data = streams.powerPointDocument;
+async function parseDeck(streams2) {
+  const data = streams2.powerPointDocument;
   const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
-  const { currentEdit, directory } = buildPersistDirectory(view, streams.offsetToCurrentEdit);
-  if (currentEdit.encryptSessionPersistIdRef !== void 0 && currentEdit.encryptSessionPersistIdRef !== 0 && !streams.decrypted) {
+  const { currentEdit, directory } = buildPersistDirectory(view, streams2.offsetToCurrentEdit);
+  if (currentEdit.encryptSessionPersistIdRef !== void 0 && currentEdit.encryptSessionPersistIdRef !== 0 && !streams2.decrypted) {
     throw new EncryptedPptError();
   }
   const docOffset = directory.get(currentEdit.docPersistIdRef);
@@ -132615,7 +133115,7 @@ async function parseDeck(streams) {
   }
   const bstoreRec = findBStore(view, docContainer);
   const pictures = await parsePictures(
-    streams.pictures,
+    streams2.pictures,
     bstoreRec ? { view, rec: bstoreRec } : void 0
   );
   const usedExObjIds = /* @__PURE__ */ new Set();
@@ -132664,6 +133164,20 @@ var init_document_parser = __esm({
   }
 });
 
+// src/pptx/core/utils/ooxml-crypto-errors.ts
+var init_ooxml_crypto_errors = __esm({
+  "src/pptx/core/utils/ooxml-crypto-errors.ts"() {
+    init_errors();
+  }
+});
+
+// src/pptx/core/utils/ooxml-crypto-key-derivation.ts
+var init_ooxml_crypto_key_derivation = __esm({
+  "src/pptx/core/utils/ooxml-crypto-key-derivation.ts"() {
+    init_encryption_info();
+  }
+});
+
 // src/pptx/core/ppt/rc4-cryptoapi-key.ts
 var init_rc4_cryptoapi_key2 = __esm({
   "src/pptx/core/ppt/rc4-cryptoapi-key.ts"() {
@@ -136411,12 +136925,12 @@ var SlideProcessor = class {
     if (positionedCells.length === 0) {
       return [];
     }
-    const container = [
+    const container2 = [
       `<div style="position:relative;width:${displayW}px;height:${displayH}px;border:1px solid #e5e7eb;overflow:hidden;margin:0.5em 0">`,
       ...positionedCells,
       "</div>"
     ].join("\n");
-    return [container];
+    return [container2];
   }
   /** Sorts elements into natural reading order (top-to-bottom, left-to-right). */
   sortElementsByReadingOrder(elements) {