ooxml-core 0.9.0 → 0.10.0

package/dist/pptx/index.mjs

@@ -3161,9 +3161,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
@@ -21427,12 +21427,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 {
@@ -21656,32 +21656,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 {
@@ -22617,17 +22617,17 @@ function unwrapXlsBytes(bytes) {
         }
         if (!canRebuild)
           return originalBytes;
-        const streams = /* @__PURE__ */ new Map();
+        const streams2 = /* @__PURE__ */ new Map();
         for (const entry of ole.entries) {
           if (entry.type !== ENTRY_TYPE_STREAM) {
             continue;
           }
           const data = entry.name.toLowerCase() === streamEntry.name.toLowerCase() ? editedWorkbookBytes : ole.getStream(entry.name);
           if (data) {
-            streams.set(entry.name, data);
+            streams2.set(entry.name, data);
           }
         }
-        return new Uint8Array(buildOle2(streams, rootClsid));
+        return new Uint8Array(buildOle2(streams2, rootClsid));
       }
     };
   } catch {
@@ -23339,17 +23339,17 @@ function unwrapDocBytes(bytes) {
       tableStreamName: fib.tableStreamName,
       tableBytes,
       rewrap: (editedWordDocBytes, editedTableBytes) => {
-        const streams = /* @__PURE__ */ new Map();
+        const streams2 = /* @__PURE__ */ new Map();
         for (const entry of ole.entries) {
           if (entry.type !== ENTRY_TYPE_STREAM) {
             continue;
           }
           const data = entry.name === "WordDocument" ? editedWordDocBytes : entry.name === fib.tableStreamName ? editedTableBytes : ole.getStream(entry.name);
           if (data) {
-            streams.set(entry.name, data);
+            streams2.set(entry.name, data);
           }
         }
-        return new Uint8Array(buildOle2(streams, rootClsid));
+        return new Uint8Array(buildOle2(streams2, rootClsid));
       }
     };
   } catch {
@@ -37121,16 +37121,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"() {
@@ -42070,9 +42070,9 @@ function findVarsContainer(node) {
       continue;
     }
     if (CONTAINER_LOCAL_NAMES.has(localNameOf4(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);
@@ -42129,8 +42129,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("@_") || localNameOf4(key2) !== name) {
       continue;
     }
@@ -42143,27 +42143,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;
   }
@@ -42204,7 +42204,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)) {
@@ -42213,7 +42213,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) {
@@ -42543,6 +42543,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`,
@@ -42582,8 +42583,406 @@ 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));
+}
+function findByLocalName(parent, localName29) {
+  if (!parent) {
+    return void 0;
+  }
+  if (parent[localName29] !== void 0 && typeof parent[localName29] === "object") {
+    return parent[localName29];
+  }
+  for (const key2 of Object.keys(parent)) {
+    const parts = key2.split(":");
+    if (parts[parts.length - 1] === localName29 && typeof parent[key2] === "object") {
+      return parent[key2];
+    }
+  }
+  return void 0;
+}
+function findScalarByLocalName(parent, localName29) {
+  if (!parent) {
+    return void 0;
+  }
+  if (parent[localName29] !== void 0) {
+    const v = parent[localName29];
+    if (typeof v === "string") {
+      return v;
+    }
+    if (typeof v === "number" || typeof v === "boolean") {
+      return String(v);
+    }
+    if (typeof v === "object" && v !== null && "#text" in v) {
+      return String(v["#text"]);
+    }
+  }
+  for (const key2 of Object.keys(parent)) {
+    const parts = key2.split(":");
+    if (parts[parts.length - 1] === localName29) {
+      const v = parent[key2];
+      if (typeof v === "string") {
+        return v;
+      }
+      if (typeof v === "number" || typeof v === "boolean") {
+        return String(v);
+      }
+      if (typeof v === "object" && v !== null && "#text" in v) {
+        return String(v["#text"]);
+      }
+    }
+  }
+  return void 0;
+}
+function findAllByLocalName(parent, localName29) {
+  if (!parent) {
+    return [];
+  }
+  for (const key2 of Object.keys(parent)) {
+    const parts = key2.split(":");
+    if (parts[parts.length - 1] === localName29) {
+      const v = parent[key2];
+      if (Array.isArray(v)) {
+        return v;
+      }
+      if (typeof v === "object" && v !== null) {
+        return [v];
+      }
+    }
+  }
+  return [];
+}
+function parseSignatureXml(signatureXml, signaturePath) {
+  const signature = findByLocalName(signatureXml, "Signature");
+  const signedInfo = findByLocalName(signature, "SignedInfo");
+  const sigMethodNode = findByLocalName(signedInfo, "SignatureMethod");
+  const signatureMethod = sigMethodNode?.["@_Algorithm"];
+  const signatureValue = findScalarByLocalName(signature, "SignatureValue")?.replace(/\s+/g, "");
+  const references = [];
+  const refNodes = findAllByLocalName(signedInfo, "Reference");
+  for (const ref of refNodes) {
+    const uri = String(ref["@_URI"] || "");
+    const dmNode = findByLocalName(ref, "DigestMethod");
+    const digestMethod2 = dmNode?.["@_Algorithm"];
+    const digestValue = findScalarByLocalName(ref, "DigestValue")?.replace(/\s+/g, "");
+    references.push({
+      uri,
+      ...digestMethod2 === void 0 ? {} : { digestMethod: digestMethod2 },
+      ...digestValue === void 0 ? {} : { digestValue }
+    });
+  }
+  const digestMethod = references[0]?.digestMethod;
+  const keyInfo = findByLocalName(signature, "KeyInfo");
+  const x509Data = findByLocalName(keyInfo, "X509Data");
+  let certificate;
+  if (x509Data) {
+    const certBase64 = findScalarByLocalName(x509Data, "X509Certificate")?.replace(/\s+/g, "");
+    if (certBase64) {
+      const issuerSerial = findByLocalName(x509Data, "X509IssuerSerial");
+      const issuer = findScalarByLocalName(issuerSerial, "X509IssuerName");
+      const serialNumber = findScalarByLocalName(issuerSerial, "X509SerialNumber");
+      const subject = findScalarByLocalName(x509Data, "X509SubjectName");
+      certificate = {
+        certificateBase64: certBase64,
+        ...issuer ? { issuer } : {},
+        ...subject ? { subject } : {},
+        ...serialNumber ? { serialNumber } : {}
+      };
+    }
+  }
+  let status = "unverified";
+  if (certificate?.validTo) {
+    const expiry = new Date(certificate.validTo);
+    if (expiry < /* @__PURE__ */ new Date()) {
+      status = "expired";
+    }
+  }
+  return {
+    signaturePath,
+    ...signatureMethod === void 0 ? {} : { signatureMethod },
+    ...digestMethod === void 0 ? {} : { digestMethod },
+    ...signatureValue === void 0 ? {} : { signatureValue },
+    ...certificate === void 0 ? {} : { certificate },
+    status,
+    references
+  };
+}
+async function verifySignatureDigests(signature, getPartContent) {
+  if (!signature.references.length) {
+    return "unverified";
+  }
+  if (typeof globalThis.crypto?.subtle === "undefined") {
+    return "unverified";
+  }
+  for (const ref of signature.references) {
+    if (!ref.digestValue || !ref.uri) {
+      continue;
+    }
+    const algo = ref.digestMethod?.toLowerCase() || "";
+    let hashAlgo;
+    if (algo.includes("sha256") || algo.includes("sha-256")) {
+      hashAlgo = "SHA-256";
+    } else if (algo.includes("sha512") || algo.includes("sha-512")) {
+      hashAlgo = "SHA-512";
+    } else if (algo.includes("sha1") || algo.includes("sha-1")) {
+      hashAlgo = "SHA-1";
+    } else {
+      continue;
+    }
+    const content = await getPartContent(ref.uri);
+    if (!content) {
+      continue;
+    }
+    try {
+      const digest2 = await crypto.subtle.digest(hashAlgo, content);
+      const digestBase64 = arrayBufferToBase64(digest2);
+      if (digestBase64 !== ref.digestValue) {
+        return "invalid";
+      }
+    } catch {
+      return "unverified";
+    }
+  }
+  return signature.certificate ? "valid" : "unknownCA";
+}
+function arrayBufferToBase64(buffer) {
+  const bytes = new Uint8Array(buffer);
+  let binary = "";
+  for (let i2 = 0; i2 < bytes.byteLength; i2++) {
+    binary += String.fromCharCode(bytes[i2]);
+  }
+  return btoa(binary);
+}
+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, DIGITAL_SIGNATURE_REL_TYPE, PPTX_VIEWER_MANIFEST_NS, XMLDSIG_NS, OPC_RELATIONSHIP_TRANSFORM, XML_TRANSFORM_ENVELOPED_SIGNATURE, SUPPORTED_XML_CANON_TRANSFORMS, ENTERPRISE_TRUST_ROOTS_FILE_ENV, ENTERPRISE_TRUST_ROOTS_PEM_ENV, ENTERPRISE_REQUIRE_REVOCATION_ENV, ENTERPRISE_FAIL_ON_REVOCATION_UNKNOWN_ENV, ENTERPRISE_REQUIRE_TIMESTAMP_ENV, DIGEST_ALGORITHM_TO_HASH, DIGEST_ALGORITHM_TO_WEB_CRYPTO;
+var init_constants3 = __esm({
+  "src/opc/signature/constants.ts"() {
+    DIGITAL_SIGNATURE_ORIGIN_REL_TYPE = "http://schemas.openxmlformats.org/package/2006/relationships/digital-signature/origin";
+    DIGITAL_SIGNATURE_REL_TYPE = "http://schemas.openxmlformats.org/package/2006/relationships/digital-signature/signature";
+    PPTX_VIEWER_MANIFEST_NS = "urn:pptx-viewer:ooxml-signature:v1";
+    XMLDSIG_NS = "http://www.w3.org/2000/09/xmldsig#";
+    OPC_RELATIONSHIP_TRANSFORM = "http://schemas.openxmlformats.org/package/2006/RelationshipTransform";
+    XML_TRANSFORM_ENVELOPED_SIGNATURE = "http://www.w3.org/2000/09/xmldsig#enveloped-signature";
+    SUPPORTED_XML_CANON_TRANSFORMS = /* @__PURE__ */ new Set([
+      "http://www.w3.org/TR/2001/REC-xml-c14n-20010315",
+      "http://www.w3.org/TR/2001/REC-xml-c14n-20010315#WithComments",
+      "http://www.w3.org/2001/10/xml-exc-c14n#",
+      "http://www.w3.org/2001/10/xml-exc-c14n#WithComments",
+      XML_TRANSFORM_ENVELOPED_SIGNATURE
+    ]);
+    ENTERPRISE_TRUST_ROOTS_FILE_ENV = "PPTX_VIEWER_TRUST_ROOTS_FILE";
+    ENTERPRISE_TRUST_ROOTS_PEM_ENV = "PPTX_VIEWER_TRUST_ROOTS_PEM";
+    ENTERPRISE_REQUIRE_REVOCATION_ENV = "PPTX_VIEWER_REQUIRE_REVOCATION_CHECK";
+    ENTERPRISE_FAIL_ON_REVOCATION_UNKNOWN_ENV = "PPTX_VIEWER_FAIL_ON_REVOCATION_UNKNOWN";
+    ENTERPRISE_REQUIRE_TIMESTAMP_ENV = "PPTX_VIEWER_REQUIRE_TIMESTAMP";
+    DIGEST_ALGORITHM_TO_HASH = {
+      "http://www.w3.org/2000/09/xmldsig#sha1": "sha1",
+      "http://www.w3.org/2001/04/xmlenc#sha256": "sha256",
+      "http://www.w3.org/2001/04/xmlenc#sha384": "sha384",
+      "http://www.w3.org/2001/04/xmlenc#sha512": "sha512"
+    };
+    DIGEST_ALGORITHM_TO_WEB_CRYPTO = {
+      "http://www.w3.org/2000/09/xmldsig#sha1": "SHA-1",
+      "http://www.w3.org/2001/04/xmlenc#sha256": "SHA-256",
+      "http://www.w3.org/2001/04/xmlenc#sha384": "SHA-384",
+      "http://www.w3.org/2001/04/xmlenc#sha512": "SHA-512"
+    };
+  }
+});
+
+// src/opc/signature/xml-utils.ts
+function escapeXmlAttr(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function escapeXmlText(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function isValidBase64(value) {
+  return typeof value === "string" && value.length > 0 && /^[A-Za-z0-9+/=\s]+$/.test(value);
+}
+function extractTagAttribute(xml, tagName, attributeName) {
+  const pattern = new RegExp(
+    `<${tagName}\\b[^>]*\\b${attributeName}="(?<attributeValue>[^"]+)"`,
+    "i"
+  );
+  const match = xml.match(pattern);
+  return match?.groups?.["attributeValue"]?.trim();
+}
+function extractFirstTagText(xml, localName29) {
+  const pattern = new RegExp(
+    `<([\\w.-]+:)?${localName29}\\b[^>]*>([\\s\\S]*?)<\\/([\\w.-]+:)?${localName29}>`,
+    "i"
+  );
+  const match = xml.match(pattern);
+  return match?.[2]?.replace(/\s+/g, "").trim() || void 0;
+}
+function extractAllTagText(xml, localName29) {
+  const result = [];
+  const regex = new RegExp(
+    `<([\\w.-]+:)?${localName29}\\b[^>]*>([\\s\\S]*?)<\\/([\\w.-]+:)?${localName29}>`,
+    "gi"
+  );
+  let match = regex.exec(xml);
+  while (match) {
+    const value = match[2]?.replace(/\s+/g, "").trim();
+    if (value) {
+      result.push(value);
+    }
+    match = regex.exec(xml);
+  }
+  return result;
+}
+var init_xml_utils2 = __esm({
+  "src/opc/signature/xml-utils.ts"() {
+  }
+});
+
+// src/opc/signature/reference-utils.ts
+function normalizePartPath(partPath) {
+  return partPath.replace(/\\/g, "/").replace(/^\/+/, "");
+}
+function resolveReferenceUriToPart(uri) {
+  const trimmed = uri.trim();
+  if (trimmed.length === 0 || trimmed.startsWith("#")) {
+    return void 0;
+  }
+  const decoded = decodeURIComponent(trimmed);
+  return normalizePartPath(decoded.startsWith("/") ? decoded.slice(1) : decoded);
+}
+var init_reference_utils = __esm({
+  "src/opc/signature/reference-utils.ts"() {
+  }
+});
+
+// src/opc/signature/digest.ts
+async function computeDigestBase64(content, digestAlgorithmUri) {
+  const webCryptoAlgo = DIGEST_ALGORITHM_TO_WEB_CRYPTO[digestAlgorithmUri];
+  if (!webCryptoAlgo) {
+    return void 0;
+  }
+  if (typeof globalThis.crypto?.subtle === "undefined") {
+    return void 0;
+  }
+  const buf = new ArrayBuffer(content.byteLength);
+  new Uint8Array(buf).set(content);
+  const digest2 = await globalThis.crypto.subtle.digest(webCryptoAlgo, buf);
+  return uint8ArrayToBase64(new Uint8Array(digest2));
+}
+function uint8ArrayToBase64(bytes) {
+  let binary = "";
+  for (let i2 = 0; i2 < bytes.byteLength; i2++) {
+    binary += String.fromCharCode(bytes[i2]);
+  }
+  return btoa(binary);
+}
+var init_digest = __esm({
+  "src/opc/signature/digest.ts"() {
+    init_constants3();
+  }
+});
+
+// src/opc/signature/inspection-status.ts
+function computeDetailStatus(detail, policy) {
+  const hasDigestMismatch = detail.referenceChecks.some(
+    (check) => check.digestStatus === "mismatch"
+  );
+  const hasMissingPart = detail.missingPartReferences.length > 0;
+  const hasVerifiedDigest = detail.referenceChecks.some(
+    (check) => check.digestStatus === "verified"
+  );
+  const revocationUnknown = detail.certificateRevocationStatus === "unknown" || detail.certificateRevocationStatus === "not-checked" || detail.certificateRevocationStatus === "error";
+  const timestampMissingOrUntrusted = detail.timestampAuthorityStatus === "not-present" || detail.timestampAuthorityStatus === "not-checked" || detail.timestampAuthorityStatus === "error" || detail.timestampAuthorityStatus === "untrusted";
+  if (detail.signatureValueStatus === "invalid") {
+    return "signature-invalid";
+  }
+  if (hasMissingPart) {
+    return "reference-missing";
+  }
+  if (hasDigestMismatch) {
+    return "digest-mismatch";
+  }
+  if (detail.certificateRevocationStatus === "revoked") {
+    return "certificate-revoked";
+  }
+  if (policy.requireRevocationCheck && (policy.failOnRevocationUnknown ? revocationUnknown : detail.certificateRevocationStatus !== "good")) {
+    return "certificate-untrusted";
+  }
+  if (detail.timestampAuthorityStatus === "invalid") {
+    return "timestamp-invalid";
+  }
+  if (policy.requireTimestamp && timestampMissingOrUntrusted) {
+    return "timestamp-untrusted";
+  }
+  if (detail.timestampAuthorityStatus === "untrusted") {
+    return "timestamp-untrusted";
+  }
+  if (detail.certificateTrustStatus === "untrusted" && detail.signatureValueStatus === "verified") {
+    return "certificate-untrusted";
+  }
+  if (hasVerifiedDigest && detail.signatureValueStatus === "verified") {
+    return "verified";
+  }
+  return "structural-only";
+}
+function computeVerificationStatus(details) {
+  const hasInvalidSignature = details.some((detail) => detail.status === "signature-invalid");
+  const hasMissing = details.some((detail) => detail.status === "reference-missing");
+  const hasMismatch = details.some((detail) => detail.status === "digest-mismatch");
+  const hasUntrusted = details.some((detail) => detail.status === "certificate-untrusted");
+  const hasRevoked = details.some((detail) => detail.status === "certificate-revoked");
+  const hasTimestampInvalid = details.some((detail) => detail.status === "timestamp-invalid");
+  const hasTimestampUntrusted = details.some((detail) => detail.status === "timestamp-untrusted");
+  const allVerified = details.every((detail) => detail.status === "verified");
+  return hasInvalidSignature ? "signature-invalid" : hasRevoked ? "certificate-revoked" : hasTimestampInvalid ? "timestamp-invalid" : hasTimestampUntrusted ? "timestamp-untrusted" : hasMissing ? "reference-missing" : hasMismatch ? "digest-mismatch" : allVerified ? "verified-trusted" : hasUntrusted ? "verified-untrusted" : "present-not-verified";
+}
+var init_inspection_status = __esm({
+  "src/opc/signature/inspection-status.ts"() {
+  }
+});
+
+// src/opc/signature/index.ts
+var init_signature = __esm({
+  "src/opc/signature/index.ts"() {
   }
 });
 
@@ -42595,6 +42994,8 @@ var init_opc = __esm({
     init_content_types();
     init_package();
     init_safe_href();
+    init_properties();
+    init_signature();
   }
 });
 
@@ -44286,25 +44687,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 };
-  }
-  const header = new Uint8Array(data, 0, 8);
-  if (OLE_MAGIC2.every((byte, i2) => header[i2] === byte)) {
-    return { format: "ole", encrypted: true };
+// src/crypto/detect.ts
+function toArrayBuffer(bytes) {
+  if (bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength) {
+    return bytes.buffer;
   }
-  if (header[0] === ZIP_MAGIC2[0] && header[1] === ZIP_MAGIC2[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_MAGIC2, 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_MAGIC2 = 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) {
@@ -44315,31 +44734,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();
   }
 });
 
@@ -44465,71 +44863,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(h2, view, offset) {
+  for (let i2 = 0; i2 < 16; i2++) W[i2] = view.getUint32(offset + i2 * 4);
+  for (let i2 = 16; i2 < 64; i2++) {
+    const a2 = W[i2 - 15];
+    const b2 = W[i2 - 2];
+    const s0 = rotr(a2, 7) ^ rotr(a2, 18) ^ a2 >>> 3;
+    const s1 = rotr(b2, 17) ^ rotr(b2, 19) ^ b2 >>> 10;
+    W[i2] = W[i2 - 16] + s0 + W[i2 - 7] + s1 >>> 0;
+  }
+  let a = h2[0], b = h2[1], c = h2[2], d = h2[3], e = h2[4], f6 = h2[5], g2 = h2[6], k = h2[7];
+  for (let i2 = 0; i2 < 64; i2++) {
+    const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+    const ch = e & f6 ^ ~e & g2;
+    const t1 = k + S1 + ch + K[i2] + W[i2] >>> 0;
+    const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+    const maj = a & b ^ a & c ^ b & c;
+    const t2 = S0 + maj >>> 0;
+    k = g2;
+    g2 = f6;
+    f6 = e;
+    e = d + t1 >>> 0;
+    d = c;
+    c = b;
+    b = a;
+    a = t1 + t2 >>> 0;
+  }
+  h2[0] = h2[0] + a >>> 0;
+  h2[1] = h2[1] + b >>> 0;
+  h2[2] = h2[2] + c >>> 0;
+  h2[3] = h2[3] + d >>> 0;
+  h2[4] = h2[4] + e >>> 0;
+  h2[5] = h2[5] + f6 >>> 0;
+  h2[6] = h2[6] + g2 >>> 0;
+  h2[7] = h2[7] + k >>> 0;
+}
+function pad64(data) {
+  const padded = new Uint8Array(Math.ceil((data.length + 9) / 64) * 64);
+  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(h2) {
+  const out = new Uint8Array(h2.length * 4);
+  const view = new DataView(out.buffer);
+  for (let i2 = 0; i2 < h2.length; i2++) view.setUint32(i2 * 4, h2[i2]);
+  return out;
+}
+function sha256(data) {
+  const h2 = new Uint32Array(IV);
+  const view = pad64(data);
+  for (let offset = 0; offset < view.byteLength; offset += 64) compress(h2, view, offset);
+  return wordsOut(h2);
+}
+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(h2, view, offset) {
+  for (let i2 = 0; i2 < 16; i2++) W2[i2] = view.getUint32(offset + i2 * 4);
+  for (let i2 = 16; i2 < 80; i2++) W2[i2] = rotl(W2[i2 - 3] ^ W2[i2 - 8] ^ W2[i2 - 14] ^ W2[i2 - 16], 1);
+  let a = h2[0], b = h2[1], c = h2[2], d = h2[3], e = h2[4];
+  for (let i2 = 0; i2 < 80; i2++) {
+    let f6;
+    let k;
+    if (i2 < 20) {
+      f6 = b & c | ~b & d;
+      k = 1518500249;
+    } else if (i2 < 40) {
+      f6 = b ^ c ^ d;
+      k = 1859775393;
+    } else if (i2 < 60) {
+      f6 = b & c | b & d | c & d;
+      k = 2400959708;
+    } else {
+      f6 = b ^ c ^ d;
+      k = 3395469782;
+    }
+    const t = rotl(a, 5) + f6 + e + k + W2[i2] >>> 0;
+    e = d;
+    d = c;
+    c = rotl(b, 30) >>> 0;
+    b = a;
+    a = t;
+  }
+  h2[0] = h2[0] + a >>> 0;
+  h2[1] = h2[1] + b >>> 0;
+  h2[2] = h2[2] + c >>> 0;
+  h2[3] = h2[3] + d >>> 0;
+  h2[4] = h2[4] + e >>> 0;
+}
+function sha1(data) {
+  const h2 = new Uint32Array([1732584193, 4023233417, 2562383102, 271733878, 3285377520]);
+  const view = pad64(data);
+  for (let offset = 0; offset < view.byteLength; offset += 64) compress2(h2, view, offset);
+  return wordsOut(h2);
+}
+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(h2, data, offset) {
+  for (let i2 = 0; i2 < 32; i2++) {
+    const o = offset + i2 * 4;
+    W3[i2] = (data[o] << 24 | data[o + 1] << 16 | data[o + 2] << 8 | data[o + 3]) >>> 0;
+  }
+  for (let i2 = 16; i2 < 80; i2++) {
+    const xh = W3[(i2 - 15) * 2];
+    const xl = W3[(i2 - 15) * 2 + 1];
+    const s0h = (xh >>> 1 | xl << 31) ^ (xh >>> 8 | xl << 24) ^ xh >>> 7;
+    const s0l = (xl >>> 1 | xh << 31) ^ (xl >>> 8 | xh << 24) ^ (xl >>> 7 | xh << 25);
+    const yh = W3[(i2 - 2) * 2];
+    const yl = W3[(i2 - 2) * 2 + 1];
+    const s1h = (yh >>> 19 | yl << 13) ^ (yl >>> 29 | yh << 3) ^ yh >>> 6;
+    const s1l = (yl >>> 19 | yh << 13) ^ (yh >>> 29 | yl << 3) ^ (yl >>> 6 | yh << 26);
+    let lo = (s0l >>> 0) + (s1l >>> 0) + W3[(i2 - 7) * 2 + 1] + W3[(i2 - 16) * 2 + 1];
+    const hi = s0h + s1h + W3[(i2 - 7) * 2] + W3[(i2 - 16) * 2] + Math.floor(lo / 4294967296);
+    lo >>>= 0;
+    W3[i2 * 2] = hi >>> 0;
+    W3[i2 * 2 + 1] = lo;
+  }
+  let ah = h2[0], al = h2[1], bh = h2[2], bl = h2[3], ch = h2[4], cl = h2[5], dh = h2[6], dl = h2[7];
+  let eh = h2[8], el = h2[9], fh = h2[10], fl = h2[11], gh = h2[12], gl = h2[13], hh = h2[14], hl = h2[15];
+  for (let i2 = 0; i2 < 80; i2++) {
+    const S1h = (eh >>> 14 | el << 18) ^ (eh >>> 18 | el << 14) ^ (el >>> 9 | eh << 23);
+    const S1l = (el >>> 14 | eh << 18) ^ (el >>> 18 | eh << 14) ^ (eh >>> 9 | el << 23);
+    const chh = eh & fh ^ ~eh & gh;
+    const chl = el & fl ^ ~el & gl;
+    let t1l = (hl >>> 0) + (S1l >>> 0) + (chl >>> 0) + K2[i2 * 2 + 1] + W3[i2 * 2 + 1];
+    const t1h = hh + S1h + chh + K2[i2 * 2] + W3[i2 * 2] + Math.floor(t1l / 4294967296);
+    t1l >>>= 0;
+    const S0h = (ah >>> 28 | al << 4) ^ (al >>> 2 | ah << 30) ^ (al >>> 7 | ah << 25);
+    const S0l = (al >>> 28 | ah << 4) ^ (ah >>> 2 | al << 30) ^ (ah >>> 7 | al << 25);
+    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 add7 = (i2, xh, xl) => {
+    const lo = (h2[i2 + 1] >>> 0) + (xl >>> 0);
+    h2[i2] = h2[i2] + xh + Math.floor(lo / 4294967296) >>> 0;
+    h2[i2 + 1] = lo >>> 0;
+  };
+  add7(0, ah, al);
+  add7(2, bh, bl);
+  add7(4, ch, cl);
+  add7(6, dh, dl);
+  add7(8, eh, el);
+  add7(10, fh, fl);
+  add7(12, gh, gl);
+  add7(14, hh, hl);
+}
+function digest64(data, iv, bytes) {
+  const h2 = 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(h2, padded, offset);
+  const out = new Uint8Array(bytes);
+  const outView = new DataView(out.buffer);
+  for (let i2 = 0; i2 < bytes / 4; i2++) outView.setUint32(i2 * 4, h2[i2]);
+  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_digest2 = __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 digest2 = digestFunction(hashAlgorithm);
+  if (digest2) {
+    let h3 = digest2(concatArrays(salt, passwordBytes));
+    const buffer = new Uint8Array(4 + h3.length);
+    const view = new DataView(buffer.buffer);
+    for (let i2 = 0; i2 < spinCount; i2++) {
+      view.setUint32(0, i2, true);
+      buffer.set(h3, 4);
+      h3 = digest2(buffer);
+    }
+    return h3;
+  }
   let h2 = await hash(hashAlgorithm, concatArrays(salt, passwordBytes));
   for (let i2 = 0; i2 < spinCount; i2++) {
     h2 = await hash(hashAlgorithm, concatArrays(uint32LE(i2), h2));
   }
-  h2 = await hash(hashAlgorithm, concatArrays(h2, blockKey));
-  const cbRequiredKeyLength = keyBits / 8;
-  const cbHash = hashSize;
-  const ipad = 54;
-  const opad = 92;
-  if (cbHash >= cbRequiredKeyLength) {
-    return h2.subarray(0, cbRequiredKeyLength);
-  }
-  const x1Input = new Uint8Array(64);
-  x1Input.fill(ipad);
-  for (let i2 = 0; i2 < h2.length && i2 < 64; i2++) {
-    x1Input[i2] = h2[i2] ^ ipad;
-  }
-  const x1 = await hash(hashAlgorithm, x1Input);
-  const x2Input = new Uint8Array(64);
-  x2Input.fill(opad);
-  for (let i2 = 0; i2 < h2.length && i2 < 64; i2++) {
-    x2Input[i2] = h2[i2] ^ 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 h2 = await hash("SHA-1", concatArrays(salt, passwordBytes));
-  for (let i2 = 0; i2 < 5e4; i2++) {
-    h2 = await hash("SHA-1", concatArrays(uint32LE(i2), h2));
-  }
   return h2;
 }
+async function extendKey(h2, hashAlgorithm, keyLength) {
+  const pad2 = async (value) => {
+    const input = new Uint8Array(64).fill(value);
+    for (let i2 = 0; i2 < h2.length && i2 < 64; i2++) input[i2] = h2[i2] ^ value;
+    return hash(hashAlgorithm, input);
+  };
+  const x3 = concatArrays(await pad2(54), await pad2(92));
+  return x3.subarray(0, keyLength);
+}
+function computeAgileKeyBase(password, salt, spinCount, hashAlgorithm) {
+  return spinPassword(password, salt, spinCount, hashAlgorithm);
+}
+async function deriveAgileKeyFromBase(base, hashAlgorithm, blockKey, keyBits, hashSize) {
+  const h2 = await hash(hashAlgorithm, concatArrays(base, blockKey));
+  const keyLength = keyBits / 8;
+  if (hashSize >= keyLength) return h2.subarray(0, keyLength);
+  return extendKey(h2, hashAlgorithm, keyLength);
+}
+function computeStandardKeyBase(password, salt) {
+  return spinPassword(password, salt, 5e4, "SHA-1");
+}
 async function deriveStandardKeyFromBase(base, keySize, blockNumber = 0) {
   const h2 = await hash("SHA-1", concatArrays(base, uint32LE(blockNumber)));
-  const cbRequiredKeyLength = keySize / 8;
-  if (h2.length >= cbRequiredKeyLength) {
-    return h2.subarray(0, cbRequiredKeyLength);
-  }
-  const x1Input = new Uint8Array(64);
-  x1Input.fill(54);
-  for (let i2 = 0; i2 < h2.length && i2 < 64; i2++) {
-    x1Input[i2] = h2[i2] ^ 54;
-  }
-  const x1 = await hash("SHA-1", x1Input);
-  const x2Input = new Uint8Array(64);
-  x2Input.fill(92);
-  for (let i2 = 0; i2 < h2.length && i2 < 64; i2++) {
-    x2Input[i2] = h2[i2] ^ 92;
-  }
-  const x2 = await hash("SHA-1", x2Input);
-  const x3 = concatArrays(x1, x2);
-  return x3.subarray(0, cbRequiredKeyLength);
+  return extendKey(h2, "SHA-1", keySize / 8);
 }
 async function deriveStandardKey(password, salt, keySize, _algIdHash, blockNumber = 0) {
   const base = await computeStandardKeyBase(password, salt);
@@ -44537,21 +45508,376 @@ async function deriveStandardKey(password, salt, keySize, _algIdHash, blockNumbe
 }
 async function generateIV(hashAlgorithm, salt, blockKey, blockSize) {
   const h2 = await hash(hashAlgorithm, concatArrays(salt, blockKey));
-  if (h2.length >= blockSize) {
-    return h2.subarray(0, blockSize);
-  }
-  const padded = new Uint8Array(blockSize);
-  padded.fill(54);
+  if (h2.length >= blockSize) return h2.subarray(0, blockSize);
+  const padded = new Uint8Array(blockSize).fill(54);
   padded.set(h2);
   return padded;
 }
+var BLOCK_KEYS, MAX_SPIN_COUNT;
+var init_key_derivation = __esm({
+  "src/crypto/key-derivation.ts"() {
+    init_ooxml_crypto_primitives();
+    init_digest2();
+    BLOCK_KEYS = {
+      verifierHashInput: new Uint8Array([254, 167, 210, 118, 59, 75, 158, 121]),
+      verifierHashValue: new Uint8Array([215, 170, 15, 109, 48, 97, 52, 78]),
+      encryptedKeyValue: new Uint8Array([20, 110, 11, 231, 171, 172, 208, 214]),
+      dataIntegrityHmacKey: new Uint8Array([95, 178, 173, 1, 12, 185, 225, 246]),
+      dataIntegrityHmacValue: new Uint8Array([160, 103, 127, 2, 178, 44, 132, 51])
+    };
+    MAX_SPIN_COUNT = 1e7;
+  }
+});
+
+// src/crypto/decrypt.ts
+async function verifyAgilePassword(info, password) {
+  const pke = info.passwordKeyEncryptor;
+  const base = await computeAgileKeyBase(password, pke.saltValue, pke.spinCount, pke.hashAlgorithm);
+  const blockKey = (block) => deriveAgileKeyFromBase(base, pke.hashAlgorithm, block, pke.keyBits, pke.hashSize);
+  const verifierHashInput = await aesCbcDecryptRaw(
+    await blockKey(BLOCK_KEYS.verifierHashInput),
+    pke.saltValue,
+    pke.encryptedVerifierHashInput
+  );
+  const verifierHashValue = await aesCbcDecryptRaw(
+    await blockKey(BLOCK_KEYS.verifierHashValue),
+    pke.saltValue,
+    pke.encryptedVerifierHashValue
+  );
+  const computedHash = await hash(pke.hashAlgorithm, verifierHashInput.subarray(0, pke.saltSize));
+  if (computedHash.length < pke.hashSize || verifierHashValue.length < pke.hashSize) return null;
+  let difference = 0;
+  for (let i2 = 0; i2 < pke.hashSize; i2++) difference |= verifierHashValue[i2] ^ computedHash[i2];
+  if (difference !== 0) return null;
+  const decryptedKey = await aesCbcDecryptRaw(
+    await blockKey(BLOCK_KEYS.encryptedKeyValue),
+    pke.saltValue,
+    pke.encryptedKeyValue
+  );
+  return decryptedKey.subarray(0, info.keyData.keyBits / 8);
+}
+async function verifyStandardPassword(info, password) {
+  const key2 = await deriveStandardKey(
+    password,
+    info.verifier.salt,
+    info.header.keySize,
+    info.header.algIdHash
+  );
+  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;
+  for (let i2 = 0; i2 < Math.min(hashSize, 20); i2++) {
+    if (computedHash[i2] !== decryptedHash[i2]) {
+      match = false;
+      break;
+    }
+  }
+  return match ? key2 : null;
+}
+async function verifyAgileDataIntegrity(info, key2, encryptedPackage) {
+  const keyData = info.keyData;
+  if (!info.dataIntegrity) {
+    return;
+  }
+  const hmacKeyIV = await generateIV(
+    keyData.hashAlgorithm,
+    keyData.saltValue,
+    BLOCK_KEYS.dataIntegrityHmacKey,
+    keyData.blockSize
+  );
+  const decryptedHmacKey = await aesCbcDecryptRaw(
+    key2,
+    hmacKeyIV,
+    info.dataIntegrity.encryptedHmacKey
+  );
+  const hmacKey = decryptedHmacKey.subarray(0, keyData.hashSize);
+  const hmacValueIV = await generateIV(
+    keyData.hashAlgorithm,
+    keyData.saltValue,
+    BLOCK_KEYS.dataIntegrityHmacValue,
+    keyData.blockSize
+  );
+  const decryptedHmacValue = await aesCbcDecryptRaw(
+    key2,
+    hmacValueIV,
+    info.dataIntegrity.encryptedHmacValue
+  );
+  const expectedHmac = decryptedHmacValue.subarray(0, keyData.hashSize);
+  const computedHmac = await hmac(keyData.hashAlgorithm, hmacKey, encryptedPackage);
+  let match = true;
+  if (computedHmac.length < keyData.hashSize) {
+    match = false;
+  } else {
+    for (let i2 = 0; i2 < keyData.hashSize; i2++) {
+      if (computedHmac[i2] !== expectedHmac[i2]) {
+        match = false;
+        break;
+      }
+    }
+  }
+  if (!match) {
+    throw new DataIntegrityError(
+      "Data integrity check failed. The encrypted file may be corrupted or tampered with."
+    );
+  }
+}
+async function decryptAgilePackage(encryptedPackage, key2, info) {
+  const keyData = info.keyData;
+  const sizeView = new DataView(encryptedPackage.buffer, encryptedPackage.byteOffset, 8);
+  const originalSize = sizeView.getUint32(0, true) + sizeView.getUint32(4, true) * 4294967296;
+  const encryptedData = encryptedPackage.subarray(8);
+  const segmentSize = 4096;
+  const result = new Uint8Array(originalSize);
+  let resultOffset = 0;
+  const numSegments = Math.ceil(encryptedData.length / segmentSize);
+  for (let segment = 0; segment < numSegments; segment++) {
+    const segmentStart = segment * segmentSize;
+    const segmentEnd = Math.min(segmentStart + segmentSize, encryptedData.length);
+    const segmentData = encryptedData.subarray(segmentStart, segmentEnd);
+    const blockKeyBytes = uint32LE(segment);
+    const segmentIV = await generateIV(
+      keyData.hashAlgorithm,
+      keyData.saltValue,
+      blockKeyBytes,
+      keyData.blockSize
+    );
+    const decrypted = await aesCbcDecryptRaw(key2, segmentIV, segmentData);
+    const bytesToCopy = Math.min(decrypted.length, originalSize - resultOffset);
+    result.set(decrypted.subarray(0, bytesToCopy), resultOffset);
+    resultOffset += bytesToCopy;
+  }
+  return result.buffer;
+}
+async function decryptStandardPackage(encryptedPackage, key2) {
+  const sizeView = new DataView(encryptedPackage.buffer, encryptedPackage.byteOffset, 8);
+  const originalSize = sizeView.getUint32(0, true);
+  const encryptedData = encryptedPackage.subarray(8);
+  const decrypted = await aesEcbDecrypt(key2, encryptedData);
+  return decrypted.slice(0, originalSize).buffer;
+}
+var init_decrypt = __esm({
+  "src/crypto/decrypt.ts"() {
+    init_ooxml_crypto_primitives();
+    init_aes_ecb();
+    init_errors();
+    init_key_derivation();
+  }
+});
+
+// src/crypto/encryption-info-write.ts
+function buildAgileEncryptionInfoXml(keyData, pke, dataIntegrity) {
+  const xmlNs = "http://schemas.microsoft.com/office/2006/encryption";
+  const pNs = "http://schemas.microsoft.com/office/2006/keyEncryptor/password";
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\r
+<encryption xmlns="${xmlNs}" xmlns:p="${pNs}"><keyData saltSize="${keyData.saltSize}" blockSize="${keyData.blockSize}" keyBits="${keyData.keyBits}" hashSize="${keyData.hashSize}" cipherAlgorithm="${keyData.cipherAlgorithm}" cipherChaining="${keyData.cipherChaining}" hashAlgorithm="${keyData.hashAlgorithm}" saltValue="${base64Encode(keyData.saltValue)}"/><dataIntegrity encryptedHmacKey="${base64Encode(dataIntegrity.encryptedHmacKey)}" encryptedHmacValue="${base64Encode(dataIntegrity.encryptedHmacValue)}"/><keyEncryptors><keyEncryptor uri="http://schemas.microsoft.com/office/2006/keyEncryptor/password"><p:encryptedKey spinCount="${pke.spinCount}" saltSize="${pke.saltSize}" blockSize="${pke.blockSize}" keyBits="${pke.keyBits}" hashSize="${pke.hashSize}" cipherAlgorithm="${pke.cipherAlgorithm}" cipherChaining="${pke.cipherChaining}" hashAlgorithm="${pke.hashAlgorithm}" saltValue="${base64Encode(pke.saltValue)}" encryptedVerifierHashInput="${base64Encode(pke.encryptedVerifierHashInput)}" encryptedVerifierHashValue="${base64Encode(pke.encryptedVerifierHashValue)}" encryptedKeyValue="${base64Encode(pke.encryptedKeyValue)}"/></keyEncryptor></keyEncryptors></encryption>`;
+}
+function buildEncryptionInfoStream(xmlString) {
+  const xmlBytes = new TextEncoder().encode(xmlString);
+  const result = new Uint8Array(8 + xmlBytes.length);
+  const view = new DataView(result.buffer);
+  view.setUint16(0, 4, true);
+  view.setUint16(2, 4, true);
+  view.setUint32(4, 64, true);
+  result.set(xmlBytes, 8);
+  return result;
+}
+function buildStandardEncryptionInfoStream(keyBits, salt, encryptedVerifier, encryptedVerifierHash) {
+  const algId = STANDARD_ALG_IDS[keyBits];
+  if (!algId) {
+    throw new Error(
+      `Unsupported standard encryption key size: ${keyBits} bits. Use 128, 192, or 256.`
+    );
+  }
+  const cspNameBytes = new Uint8Array((STANDARD_CSP_NAME.length + 1) * 2);
+  for (let i2 = 0; i2 < STANDARD_CSP_NAME.length; i2++) {
+    const code = STANDARD_CSP_NAME.charCodeAt(i2);
+    cspNameBytes[i2 * 2] = code & 255;
+    cspNameBytes[i2 * 2 + 1] = code >> 8 & 255;
+  }
+  const headerFixedSize = 32;
+  const headerSize = headerFixedSize + cspNameBytes.length;
+  const verifierSize = 4 + 16 + 16 + 4 + 32;
+  const totalSize = 12 + headerSize + verifierSize;
+  const data = new Uint8Array(totalSize);
+  const view = new DataView(data.buffer);
+  view.setUint16(0, 4, true);
+  view.setUint16(2, 2, true);
+  view.setUint32(4, STANDARD_FLAGS, true);
+  view.setUint32(8, headerSize, true);
+  const h2 = 12;
+  view.setUint32(h2, STANDARD_FLAGS, true);
+  view.setUint32(h2 + 4, 0, true);
+  view.setUint32(h2 + 8, algId, true);
+  view.setUint32(h2 + 12, STANDARD_ALG_ID_HASH_SHA1, true);
+  view.setUint32(h2 + 16, keyBits, true);
+  view.setUint32(h2 + 20, STANDARD_PROVIDER_TYPE_RSA_AES, true);
+  view.setUint32(h2 + 24, 0, true);
+  view.setUint32(h2 + 28, 0, true);
+  data.set(cspNameBytes, h2 + 32);
+  const v = 12 + headerSize;
+  view.setUint32(v, 16, true);
+  data.set(salt.subarray(0, 16), v + 4);
+  data.set(encryptedVerifier.subarray(0, 16), v + 20);
+  view.setUint32(v + 36, 20, true);
+  data.set(encryptedVerifierHash.subarray(0, 32), v + 40);
+  return data;
+}
+var STANDARD_ALG_IDS, STANDARD_ALG_ID_HASH_SHA1, STANDARD_PROVIDER_TYPE_RSA_AES, STANDARD_CSP_NAME, STANDARD_FLAGS;
+var init_encryption_info_write = __esm({
+  "src/crypto/encryption-info-write.ts"() {
+    init_ooxml_crypto_primitives();
+    STANDARD_ALG_IDS = {
+      128: 26126,
+      // CALG_AES_128
+      192: 26127,
+      // CALG_AES_192
+      256: 26128
+      // CALG_AES_256
+    };
+    STANDARD_ALG_ID_HASH_SHA1 = 32772;
+    STANDARD_PROVIDER_TYPE_RSA_AES = 24;
+    STANDARD_CSP_NAME = "Microsoft Enhanced RSA and AES Cryptographic Provider";
+    STANDARD_FLAGS = 36;
+  }
+});
+
+// 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);
+  }
+  return encrypted;
+}
+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 keyDataSalt = randomBytes(16);
+  const pkeSalt = randomBytes(16);
+  const documentKey = randomBytes(keyBits / 8);
+  const verifierHashInput = randomBytes(16);
+  const verifierHash = await hash(hashAlgorithm, verifierHashInput);
+  const base = await computeAgileKeyBase(password, pkeSalt, spinCount, hashAlgorithm);
+  const encryptUnder = async (block, data) => {
+    const key2 = await deriveAgileKeyFromBase(base, hashAlgorithm, block, keyBits, hashSize);
+    return aesCbcEncryptNoPad(key2, pkeSalt, padTo(data, blockSize));
+  };
+  const passwordKeyEncryptor = {
+    saltSize: 16,
+    blockSize,
+    keyBits,
+    hashSize,
+    cipherAlgorithm: "AES",
+    cipherChaining: "ChainingModeCBC",
+    hashAlgorithm,
+    saltValue: pkeSalt,
+    spinCount,
+    encryptedVerifierHashInput: await encryptUnder(BLOCK_KEYS.verifierHashInput, verifierHashInput),
+    encryptedVerifierHashValue: await encryptUnder(BLOCK_KEYS.verifierHashValue, verifierHash),
+    encryptedKeyValue: await encryptUnder(BLOCK_KEYS.encryptedKeyValue, documentKey)
+  };
+  const keyData = {
+    saltSize: 16,
+    blockSize,
+    keyBits,
+    hashSize,
+    cipherAlgorithm: "AES",
+    cipherChaining: "ChainingModeCBC",
+    hashAlgorithm,
+    saltValue: keyDataSalt
+  };
+  const info = {
+    keyData};
+  const encryptedPackage = await encryptAgilePackage(packageData, documentKey, info);
+  const hmacKey = randomBytes(hashSize);
+  const hmacValue = await hmac(hashAlgorithm, hmacKey, encryptedPackage);
+  const encryptIntegrity = async (block, data) => {
+    const iv = await generateIV(hashAlgorithm, keyDataSalt, block, blockSize);
+    return aesCbcEncryptNoPad(documentKey, iv, padTo(data, blockSize));
+  };
+  const dataIntegrity = {
+    encryptedHmacKey: await encryptIntegrity(BLOCK_KEYS.dataIntegrityHmacKey, hmacKey),
+    encryptedHmacValue: await encryptIntegrity(BLOCK_KEYS.dataIntegrityHmacValue, hmacValue)
+  };
+  const xml = buildAgileEncryptionInfoXml(keyData, passwordKeyEncryptor, dataIntegrity);
+  return container(buildEncryptionInfoStream(xml), encryptedPackage);
+}
+async function encryptStandard(packageData, password, options = {}) {
+  const keyBits = options.algorithm === "AES128" ? 128 : 256;
+  const salt = randomBytes(16);
+  const 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,
+    salt,
+    await aesEcbEncrypt(key2, verifier),
+    await aesEcbEncrypt(key2, 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 === 4 && versionMinor === 4) return parseAgileEncryptionInfo(data);
   if ((versionMajor === 2 || versionMajor === 3 || versionMajor === 4) && versionMinor === 2) {
     return parseStandardEncryptionInfo(data);
   }
@@ -44567,19 +45893,15 @@ function parseStandardEncryptionInfo(data) {
   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 i2 = cspOffset; i2 < cspEnd - 1; i2 += 2) {
+  for (let i2 = headerOffset + 32; i2 < cspEnd - 1; i2 += 2) {
     const ch = view.getUint16(i2, true);
-    if (ch === 0) {
-      break;
-    }
+    if (ch === 0) break;
     cspName += String.fromCharCode(ch);
   }
   const verifierOffset = 12 + headerSize;
@@ -44599,14 +45921,7 @@ function parseStandardEncryptionInfo(data) {
     isStandard: true,
     flags,
     headerSize,
-    header: {
-      flags: hFlags,
-      algId,
-      algIdHash,
-      keySize,
-      providerType,
-      cspName
-    },
+    header: { flags: hFlags, algId, algIdHash, keySize, providerType, cspName },
     verifier: {
       saltSize,
       salt: new Uint8Array(salt),
@@ -44616,615 +45931,157 @@ function parseStandardEncryptionInfo(data) {
     }
   };
 }
+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 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");
+  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: keyDataSaltSize,
-      blockSize: keyDataBlockSize,
-      keyBits: keyDataKeyBits,
-      hashSize: keyDataHashSize,
-      cipherAlgorithm: keyDataCipherAlgorithm,
-      cipherChaining: keyDataCipherChaining,
-      hashAlgorithm: keyDataHashAlgorithm,
-      saltValue: base64Decode(keyDataSaltValue)
+      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"))
     },
-    dataIntegrity: encryptedHmacKey ? {
-      encryptedHmacKey: base64Decode(encryptedHmacKey),
-      encryptedHmacValue: base64Decode(encryptedHmacValue)
-    } : void 0,
+    ...encryptedHmacKey ? {
+      dataIntegrity: {
+        encryptedHmacKey: base64Decode(encryptedHmacKey),
+        encryptedHmacValue: base64Decode(integrity("encryptedHmacValue"))
+      }
+    } : {},
     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();
-    BLOCK_KEYS = {
-      verifierHashInput: new Uint8Array([254, 167, 210, 118, 59, 75, 158, 121]),
-      verifierHashValue: new Uint8Array([215, 170, 15, 109, 48, 97, 52, 78]),
-      encryptedKeyValue: new Uint8Array([20, 110, 11, 231, 171, 172, 208, 214]),
-      dataIntegrityHmacKey: new Uint8Array([95, 178, 173, 1, 12, 185, 225, 246]),
-      dataIntegrityHmacValue: new Uint8Array([160, 103, 127, 2, 178, 44, 132, 51])
-    };
+      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"))
+    }
+  };
+}
+var RC4_ALG_ID;
+var init_encryption_info = __esm({
+  "src/crypto/encryption-info.ts"() {
+    init_ooxml_crypto_primitives();
     RC4_ALG_ID = 26625;
   }
 });
 
-// src/pptx/core/utils/ooxml-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 verifierHashInput = await aesCbcDecryptRaw(
-    verifierInputKey,
-    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,
-    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 i2 = 0; i2 < pke.hashSize; i2++) {
-    if (expectedHash[i2] !== actualHash[i2]) {
-      match = false;
-      break;
-    }
-  }
-  if (!match) {
-    return null;
+// 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."
+    );
   }
-  const encKeyKey = await deriveAgileKey(
-    password,
-    pke.saltValue,
-    pke.spinCount,
-    pke.hashAlgorithm,
-    BLOCK_KEYS.encryptedKeyValue,
-    pke.keyBits,
-    pke.hashSize
-  );
-  const decryptedKey = await aesCbcDecryptRaw(encKeyKey, pke.saltValue, pke.encryptedKeyValue);
-  return decryptedKey.subarray(0, info.keyData.keyBits / 8);
+  throw new Error("EncryptedPackage stream not found. The file may be corrupted.");
 }
-async function verifyStandardPassword(info, password) {
-  const key2 = await deriveStandardKey(
-    password,
-    info.verifier.salt,
-    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 computedHash = await hash("SHA-1", decryptedVerifier);
-  const hashSize = info.verifier.verifierHashSize;
-  let match = true;
-  for (let i2 = 0; i2 < Math.min(hashSize, 20); i2++) {
-    if (computedHash[i2] !== decryptedHash[i2]) {
-      match = false;
-      break;
-    }
+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));
   }
-  return match ? key2 : null;
+  const key2 = await verifyAgilePassword(info, password);
+  if (!key2) throw new IncorrectPasswordError();
+  await verifyAgileDataIntegrity(info, key2, data);
+  return new Uint8Array(await decryptAgilePackage(data, key2, info));
 }
-async function verifyAgileDataIntegrity(info, key2, encryptedPackage) {
-  const keyData = info.keyData;
-  if (!info.dataIntegrity) {
-    return;
-  }
-  const hmacKeyIV = await generateIV(
-    keyData.hashAlgorithm,
-    keyData.saltValue,
-    BLOCK_KEYS.dataIntegrityHmacKey,
-    keyData.blockSize
-  );
-  const decryptedHmacKey = await aesCbcDecryptRaw(
-    key2,
-    hmacKeyIV,
-    info.dataIntegrity.encryptedHmacKey
-  );
-  const hmacKey = decryptedHmacKey.subarray(0, keyData.hashSize);
-  const hmacValueIV = await generateIV(
-    keyData.hashAlgorithm,
-    keyData.saltValue,
-    BLOCK_KEYS.dataIntegrityHmacValue,
-    keyData.blockSize
-  );
-  const decryptedHmacValue = await aesCbcDecryptRaw(
-    key2,
-    hmacValueIV,
-    info.dataIntegrity.encryptedHmacValue
-  );
-  const expectedHmac = decryptedHmacValue.subarray(0, keyData.hashSize);
-  const computedHmac = await hmac(keyData.hashAlgorithm, hmacKey, encryptedPackage);
-  let match = true;
-  if (computedHmac.length < keyData.hashSize) {
-    match = false;
-  } else {
-    for (let i2 = 0; i2 < keyData.hashSize; i2++) {
-      if (computedHmac[i2] !== expectedHmac[i2]) {
-        match = false;
-        break;
-      }
-    }
-  }
-  if (!match) {
-    throw new DataIntegrityError(
-      "Data integrity check failed. The encrypted file may be corrupted or tampered with."
-    );
-  }
+function encryptOoxmlPackage(input, password, options = {}) {
+  const bytes = toBytes(input);
+  return options.encryptionScheme === "standard" ? encryptStandard(bytes, password, options) : encryptAgile(bytes, password, options);
 }
-async function decryptAgilePackage(encryptedPackage, key2, info) {
-  const keyData = info.keyData;
-  const sizeView = new DataView(encryptedPackage.buffer, encryptedPackage.byteOffset, 8);
-  const originalSize = sizeView.getUint32(0, true) + sizeView.getUint32(4, true) * 4294967296;
-  const encryptedData = encryptedPackage.subarray(8);
-  const segmentSize = 4096;
-  const result = new Uint8Array(originalSize);
-  let resultOffset = 0;
-  const numSegments = Math.ceil(encryptedData.length / segmentSize);
-  for (let segment = 0; segment < numSegments; segment++) {
-    const segmentStart = segment * segmentSize;
-    const segmentEnd = Math.min(segmentStart + segmentSize, encryptedData.length);
-    const segmentData = encryptedData.subarray(segmentStart, segmentEnd);
-    const blockKeyBytes = uint32LE(segment);
-    const segmentIV = await generateIV(
-      keyData.hashAlgorithm,
-      keyData.saltValue,
-      blockKeyBytes,
-      keyData.blockSize
-    );
-    const decrypted = await aesCbcDecryptRaw(key2, segmentIV, segmentData);
-    const bytesToCopy = Math.min(decrypted.length, originalSize - resultOffset);
-    result.set(decrypted.subarray(0, bytesToCopy), resultOffset);
-    resultOffset += bytesToCopy;
+async function verifyOoxmlPackagePassword(input, password) {
+  try {
+    const opened = openEncryptedPackage(input);
+    if (!opened) return false;
+    const info = parseEncryptionInfo(opened.encryptionInfo);
+    const key2 = isStandard(info) ? await verifyStandardPassword(info, password) : await verifyAgilePassword(info, password);
+    return key2 !== null;
+  } catch {
+    return false;
   }
-  return result.buffer;
 }
-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);
-  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 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-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;
-}
-function buildAgileEncryptionInfoXml(keyData, pke, dataIntegrity) {
-  const xmlNs = "http://schemas.microsoft.com/office/2006/encryption";
-  const pNs = "http://schemas.microsoft.com/office/2006/keyEncryptor/password";
-  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\r
-<encryption xmlns="${xmlNs}" xmlns:p="${pNs}"><keyData saltSize="${keyData.saltSize}" blockSize="${keyData.blockSize}" keyBits="${keyData.keyBits}" hashSize="${keyData.hashSize}" cipherAlgorithm="${keyData.cipherAlgorithm}" cipherChaining="${keyData.cipherChaining}" hashAlgorithm="${keyData.hashAlgorithm}" saltValue="${base64Encode(keyData.saltValue)}"/><dataIntegrity encryptedHmacKey="${base64Encode(dataIntegrity.encryptedHmacKey)}" encryptedHmacValue="${base64Encode(dataIntegrity.encryptedHmacValue)}"/><keyEncryptors><keyEncryptor uri="http://schemas.microsoft.com/office/2006/keyEncryptor/password"><p:encryptedKey spinCount="${pke.spinCount}" saltSize="${pke.saltSize}" blockSize="${pke.blockSize}" keyBits="${pke.keyBits}" hashSize="${pke.hashSize}" cipherAlgorithm="${pke.cipherAlgorithm}" cipherChaining="${pke.cipherChaining}" hashAlgorithm="${pke.hashAlgorithm}" saltValue="${base64Encode(pke.saltValue)}" encryptedVerifierHashInput="${base64Encode(pke.encryptedVerifierHashInput)}" encryptedVerifierHashValue="${base64Encode(pke.encryptedVerifierHashValue)}" encryptedKeyValue="${base64Encode(pke.encryptedKeyValue)}"/></keyEncryptor></keyEncryptors></encryption>`;
-}
-function buildEncryptionInfoStream(xmlString) {
-  const xmlBytes = new TextEncoder().encode(xmlString);
-  const result = new Uint8Array(8 + xmlBytes.length);
-  const view = new DataView(result.buffer);
-  view.setUint16(0, 4, true);
-  view.setUint16(2, 4, true);
-  view.setUint32(4, 64, true);
-  result.set(xmlBytes, 8);
-  return result;
-}
-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) {
-    throw new Error(
-      `Unsupported standard encryption key size: ${keyBits} bits. Use 128, 192, or 256.`
-    );
-  }
-  const cspNameBytes = new Uint8Array((STANDARD_CSP_NAME.length + 1) * 2);
-  for (let i2 = 0; i2 < STANDARD_CSP_NAME.length; i2++) {
-    const code = STANDARD_CSP_NAME.charCodeAt(i2);
-    cspNameBytes[i2 * 2] = code & 255;
-    cspNameBytes[i2 * 2 + 1] = code >> 8 & 255;
-  }
-  const headerFixedSize = 32;
-  const headerSize = headerFixedSize + cspNameBytes.length;
-  const verifierSize = 4 + 16 + 16 + 4 + 32;
-  const totalSize = 12 + headerSize + verifierSize;
-  const data = new Uint8Array(totalSize);
-  const view = new DataView(data.buffer);
-  view.setUint16(0, 4, true);
-  view.setUint16(2, 2, true);
-  view.setUint32(4, STANDARD_FLAGS, true);
-  view.setUint32(8, headerSize, true);
-  const h2 = 12;
-  view.setUint32(h2, STANDARD_FLAGS, true);
-  view.setUint32(h2 + 4, 0, true);
-  view.setUint32(h2 + 8, algId, true);
-  view.setUint32(h2 + 12, STANDARD_ALG_ID_HASH_SHA1, true);
-  view.setUint32(h2 + 16, keyBits, true);
-  view.setUint32(h2 + 20, STANDARD_PROVIDER_TYPE_RSA_AES, true);
-  view.setUint32(h2 + 24, 0, true);
-  view.setUint32(h2 + 28, 0, true);
-  data.set(cspNameBytes, h2 + 32);
-  const v = 12 + headerSize;
-  view.setUint32(v, 16, true);
-  data.set(salt.subarray(0, 16), v + 4);
-  data.set(encryptedVerifier.subarray(0, 16), v + 20);
-  view.setUint32(v + 36, 20, true);
-  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();
-    STANDARD_ALG_IDS = {
-      128: 26126,
-      // CALG_AES_128
-      192: 26127,
-      // CALG_AES_192
-      256: 26128
-      // CALG_AES_256
-    };
-    STANDARD_ALG_ID_HASH_SHA1 = 32772;
-    STANDARD_PROVIDER_TYPE_RSA_AES = 24;
-    STANDARD_CSP_NAME = "Microsoft Enhanced RSA and AES Cryptographic Provider";
-    STANDARD_FLAGS = 36;
+// 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) {
-  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."
-    );
-  }
-  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 (await decryptOoxmlPackage(encryptedBuffer, password)).buffer;
 }
 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);
-  const hashAlgorithm = "SHA-512";
-  const hashSize = 64;
-  const blockSize = 16;
-  const spinCount = options?.spinCount ?? 1e5;
-  const verifierHashInput = new Uint8Array(16);
-  crypto2.getRandomValues(verifierHashInput);
-  const verifierHash = await hash(hashAlgorithm, verifierHashInput);
-  const verifierInputKey = await deriveAgileKey(
-    password,
-    pkeSalt,
-    spinCount,
-    hashAlgorithm,
-    BLOCK_KEYS.verifierHashInput,
-    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,
-    spinCount,
-    hashAlgorithm,
-    BLOCK_KEYS.verifierHashValue,
-    keyBits,
-    hashSize
-  );
-  const paddedVerifierHash = new Uint8Array(Math.ceil(verifierHash.length / blockSize) * blockSize);
-  paddedVerifierHash.set(verifierHash);
-  const encryptedVerifierHashValue = await aesCbcEncryptNoPad(
-    verifierHashKey,
-    pkeSalt,
-    paddedVerifierHash
-  );
-  const encKeyKey = await deriveAgileKey(
-    password,
-    pkeSalt,
-    spinCount,
-    hashAlgorithm,
-    BLOCK_KEYS.encryptedKeyValue,
-    keyBits,
-    hashSize
-  );
-  const paddedDocumentKey = new Uint8Array(Math.ceil(documentKey.length / blockSize) * blockSize);
-  paddedDocumentKey.set(documentKey);
-  const encryptedKeyValue = await aesCbcEncryptNoPad(encKeyKey, pkeSalt, paddedDocumentKey);
-  const encInfo = {
-    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)
-    },
-    passwordKeyEncryptor: {
-      saltSize: 16,
-      blockSize,
-      keyBits,
-      hashSize,
-      cipherAlgorithm: "AES",
-      cipherChaining: "ChainingModeCBC",
-      hashAlgorithm,
-      saltValue: pkeSalt,
-      spinCount,
-      encryptedVerifierHashInput,
-      encryptedVerifierHashValue,
-      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);
+  return (await encryptOoxmlPackage(pptxBuffer, password, options)).buffer;
 }
-async function verifyPassword(encryptedBuffer, password) {
-  try {
-    const ole2 = parseOle2(encryptedBuffer);
-    const encryptionInfoStream = ole2.getStream("EncryptionInfo");
-    if (!encryptionInfoStream) {
-      return false;
-    }
-    const info = parseEncryptionInfo(encryptionInfoStream);
-    if ("isStandard" in info && info.isStandard) {
-      const key3 = await verifyStandardPassword(info, password);
-      return key3 !== null;
-    }
-    const agileInfo = info;
-    const key2 = await verifyAgilePassword(agileInfo, password);
-    return key2 !== null;
-  } catch {
-    return false;
-  }
+function verifyPassword(encryptedBuffer, password) {
+  return verifyOoxmlPackagePassword(encryptedBuffer, password);
 }
 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_ooxml_crypto_errors();
+    init_crypto();
+    init_errors();
+  }
+});
+
+// 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/digests/algorithm-names.ts
-function normalizeDigestAlgorithmName(name) {
+function normalizeDigestAlgorithmName2(name) {
   const key2 = name.toUpperCase().replace(/[-_\s]/g, "");
-  return CANONICAL_BY_LOOKUP_KEY[key2];
+  return CANONICAL_BY_LOOKUP_KEY2[key2];
 }
-var CANONICAL_BY_LOOKUP_KEY, WEB_CRYPTO_ALGORITHMS;
-var init_algorithm_names = __esm({
+var CANONICAL_BY_LOOKUP_KEY2, WEB_CRYPTO_ALGORITHMS;
+var init_algorithm_names2 = __esm({
   "src/pptx/core/utils/digests/algorithm-names.ts"() {
-    CANONICAL_BY_LOOKUP_KEY = {
+    CANONICAL_BY_LOOKUP_KEY2 = {
       SHA1: "SHA-1",
       SHA256: "SHA-256",
       SHA384: "SHA-384",
@@ -45631,12 +46488,12 @@ function transform2(state, x) {
 function md4(message) {
   return mdStyleDigest(message, INITIAL_STATE, transform2);
 }
-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],
@@ -45657,22 +46514,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],
@@ -46592,9 +47449,9 @@ async function digest(algorithm, data) {
   throw new Error(`Unsupported digest algorithm: ${algorithm}`);
 }
 var PURE_DIGESTS;
-var init_digest = __esm({
+var init_digest3 = __esm({
   "src/pptx/core/utils/digests/digest.ts"() {
-    init_algorithm_names();
+    init_algorithm_names2();
     init_md2();
     init_md42();
     init_md5();
@@ -46615,8 +47472,8 @@ var init_digest = __esm({
 // src/pptx/core/utils/digests/index.ts
 var init_digests = __esm({
   "src/pptx/core/utils/digests/index.ts"() {
-    init_algorithm_names();
-    init_digest();
+    init_algorithm_names2();
+    init_digest3();
   }
 });
 
@@ -46711,10 +47568,10 @@ var init_modify_verifier_codec = __esm({
 // src/pptx/core/utils/modify-verifier.ts
 function resolveModifyVerifierAlgorithmName(verifier) {
   if (verifier.algorithmName) {
-    return normalizeDigestAlgorithmName(verifier.algorithmName);
+    return normalizeDigestAlgorithmName2(verifier.algorithmName);
   }
   if (verifier.algIdExt) {
-    return normalizeDigestAlgorithmName(verifier.algIdExt);
+    return normalizeDigestAlgorithmName2(verifier.algIdExt);
   }
   if (verifier.cryptAlgorithmSid !== void 0) {
     return CRYPT_ALGORITHM_SID_NAMES[verifier.cryptAlgorithmSid];
@@ -46734,7 +47591,7 @@ async function verifyModifyPassword(verifier, password) {
 }
 async function createModifyVerifier(password, options) {
   const requestedAlgorithm = options?.algorithmName ?? "SHA-512";
-  const algorithm = normalizeDigestAlgorithmName(requestedAlgorithm);
+  const algorithm = normalizeDigestAlgorithmName2(requestedAlgorithm);
   if (!algorithm) {
     throw new Error(`Unsupported modify-verifier hash algorithm: ${requestedAlgorithm}`);
   }
@@ -46752,7 +47609,7 @@ async function createModifyVerifier(password, options) {
 }
 async function createSaltlessModifyVerifierForTesting(password, options) {
   const requestedAlgorithm = options?.algorithmName ?? "SHA-512";
-  const algorithm = normalizeDigestAlgorithmName(requestedAlgorithm);
+  const algorithm = normalizeDigestAlgorithmName2(requestedAlgorithm);
   if (!algorithm) {
     throw new Error(`Unsupported modify-verifier hash algorithm: ${requestedAlgorithm}`);
   }
@@ -46784,373 +47641,44 @@ var init_modify_verifier = __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));
-}
-function findByLocalName(parent, localName29) {
-  if (!parent) {
-    return void 0;
-  }
-  if (parent[localName29] !== void 0 && typeof parent[localName29] === "object") {
-    return parent[localName29];
-  }
-  for (const key2 of Object.keys(parent)) {
-    const parts = key2.split(":");
-    if (parts[parts.length - 1] === localName29 && typeof parent[key2] === "object") {
-      return parent[key2];
-    }
-  }
-  return void 0;
-}
-function findScalarByLocalName(parent, localName29) {
-  if (!parent) {
-    return void 0;
-  }
-  if (parent[localName29] !== void 0) {
-    const v = parent[localName29];
-    if (typeof v === "string") {
-      return v;
-    }
-    if (typeof v === "number" || typeof v === "boolean") {
-      return String(v);
-    }
-    if (typeof v === "object" && v !== null && "#text" in v) {
-      return String(v["#text"]);
-    }
-  }
-  for (const key2 of Object.keys(parent)) {
-    const parts = key2.split(":");
-    if (parts[parts.length - 1] === localName29) {
-      const v = parent[key2];
-      if (typeof v === "string") {
-        return v;
-      }
-      if (typeof v === "number" || typeof v === "boolean") {
-        return String(v);
-      }
-      if (typeof v === "object" && v !== null && "#text" in v) {
-        return String(v["#text"]);
-      }
-    }
-  }
-  return void 0;
-}
-function findAllByLocalName(parent, localName29) {
-  if (!parent) {
-    return [];
-  }
-  for (const key2 of Object.keys(parent)) {
-    const parts = key2.split(":");
-    if (parts[parts.length - 1] === localName29) {
-      const v = parent[key2];
-      if (Array.isArray(v)) {
-        return v;
-      }
-      if (typeof v === "object" && v !== null) {
-        return [v];
-      }
-    }
-  }
-  return [];
-}
-function parseSignatureXml(signatureXml, signaturePath) {
-  const signature = findByLocalName(signatureXml, "Signature");
-  const signedInfo = findByLocalName(signature, "SignedInfo");
-  const sigMethodNode = findByLocalName(signedInfo, "SignatureMethod");
-  const signatureMethod = sigMethodNode?.["@_Algorithm"];
-  const signatureValue = findScalarByLocalName(signature, "SignatureValue")?.replace(/\s+/g, "");
-  const references = [];
-  const refNodes = findAllByLocalName(signedInfo, "Reference");
-  for (const ref of refNodes) {
-    const uri = String(ref["@_URI"] || "");
-    const dmNode = findByLocalName(ref, "DigestMethod");
-    const digestMethod2 = dmNode?.["@_Algorithm"];
-    const digestValue = findScalarByLocalName(ref, "DigestValue")?.replace(/\s+/g, "");
-    references.push({ uri, digestMethod: digestMethod2, digestValue });
-  }
-  const digestMethod = references[0]?.digestMethod;
-  const keyInfo = findByLocalName(signature, "KeyInfo");
-  const x509Data = findByLocalName(keyInfo, "X509Data");
-  let certificate;
-  if (x509Data) {
-    const certBase64 = findScalarByLocalName(x509Data, "X509Certificate")?.replace(/\s+/g, "");
-    if (certBase64) {
-      const issuerSerial = findByLocalName(x509Data, "X509IssuerSerial");
-      const issuer = findScalarByLocalName(issuerSerial, "X509IssuerName");
-      const serialNumber = findScalarByLocalName(issuerSerial, "X509SerialNumber");
-      const subject = findScalarByLocalName(x509Data, "X509SubjectName");
-      certificate = {
-        certificateBase64: certBase64,
-        ...issuer ? { issuer } : {},
-        ...subject ? { subject } : {},
-        ...serialNumber ? { serialNumber } : {}
-      };
-    }
-  }
-  let status = "unverified";
-  if (certificate?.validTo) {
-    const expiry = new Date(certificate.validTo);
-    if (expiry < /* @__PURE__ */ new Date()) {
-      status = "expired";
-    }
-  }
-  return {
-    signaturePath,
-    signatureMethod,
-    digestMethod,
-    signatureValue,
-    certificate,
-    status,
-    references
-  };
-}
-async function verifySignatureDigests(signature, getPartContent) {
-  if (!signature.references.length) {
-    return "unverified";
-  }
-  if (typeof globalThis.crypto?.subtle === "undefined") {
-    return "unverified";
-  }
-  for (const ref of signature.references) {
-    if (!ref.digestValue || !ref.uri) {
-      continue;
-    }
-    const algo = ref.digestMethod?.toLowerCase() || "";
-    let hashAlgo;
-    if (algo.includes("sha256") || algo.includes("sha-256")) {
-      hashAlgo = "SHA-256";
-    } else if (algo.includes("sha512") || algo.includes("sha-512")) {
-      hashAlgo = "SHA-512";
-    } else if (algo.includes("sha1") || algo.includes("sha-1")) {
-      hashAlgo = "SHA-1";
-    } else {
-      continue;
-    }
-    const content = await getPartContent(ref.uri);
-    if (!content) {
-      continue;
-    }
-    try {
-      const digest2 = await crypto.subtle.digest(hashAlgo, content);
-      const digestBase64 = arrayBufferToBase64(digest2);
-      if (digestBase64 !== ref.digestValue) {
-        return "invalid";
-      }
-    } catch {
-      return "unverified";
-    }
-  }
-  return signature.certificate ? "valid" : "unknownCA";
-}
-function arrayBufferToBase64(buffer) {
-  const bytes = new Uint8Array(buffer);
-  let binary = "";
-  for (let i2 = 0; i2 < bytes.byteLength; i2++) {
-    binary += String.fromCharCode(bytes[i2]);
-  }
-  return btoa(binary);
-}
-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, DIGITAL_SIGNATURE_REL_TYPE, PPTX_VIEWER_MANIFEST_NS, XMLDSIG_NS, OPC_RELATIONSHIP_TRANSFORM, XML_TRANSFORM_ENVELOPED_SIGNATURE, SUPPORTED_XML_CANON_TRANSFORMS, ENTERPRISE_TRUST_ROOTS_FILE_ENV, ENTERPRISE_TRUST_ROOTS_PEM_ENV, ENTERPRISE_REQUIRE_REVOCATION_ENV, ENTERPRISE_FAIL_ON_REVOCATION_UNKNOWN_ENV, ENTERPRISE_REQUIRE_TIMESTAMP_ENV, DIGEST_ALGORITHM_TO_HASH, DIGEST_ALGORITHM_TO_WEB_CRYPTO;
 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";
-    DIGITAL_SIGNATURE_REL_TYPE = "http://schemas.openxmlformats.org/package/2006/relationships/digital-signature/signature";
-    PPTX_VIEWER_MANIFEST_NS = "urn:pptx-viewer:ooxml-signature:v1";
-    XMLDSIG_NS = "http://www.w3.org/2000/09/xmldsig#";
-    OPC_RELATIONSHIP_TRANSFORM = "http://schemas.openxmlformats.org/package/2006/RelationshipTransform";
-    XML_TRANSFORM_ENVELOPED_SIGNATURE = "http://www.w3.org/2000/09/xmldsig#enveloped-signature";
-    SUPPORTED_XML_CANON_TRANSFORMS = /* @__PURE__ */ new Set([
-      "http://www.w3.org/TR/2001/REC-xml-c14n-20010315",
-      "http://www.w3.org/TR/2001/REC-xml-c14n-20010315#WithComments",
-      "http://www.w3.org/2001/10/xml-exc-c14n#",
-      "http://www.w3.org/2001/10/xml-exc-c14n#WithComments",
-      XML_TRANSFORM_ENVELOPED_SIGNATURE
-    ]);
-    ENTERPRISE_TRUST_ROOTS_FILE_ENV = "PPTX_VIEWER_TRUST_ROOTS_FILE";
-    ENTERPRISE_TRUST_ROOTS_PEM_ENV = "PPTX_VIEWER_TRUST_ROOTS_PEM";
-    ENTERPRISE_REQUIRE_REVOCATION_ENV = "PPTX_VIEWER_REQUIRE_REVOCATION_CHECK";
-    ENTERPRISE_FAIL_ON_REVOCATION_UNKNOWN_ENV = "PPTX_VIEWER_FAIL_ON_REVOCATION_UNKNOWN";
-    ENTERPRISE_REQUIRE_TIMESTAMP_ENV = "PPTX_VIEWER_REQUIRE_TIMESTAMP";
-    DIGEST_ALGORITHM_TO_HASH = {
-      "http://www.w3.org/2000/09/xmldsig#sha1": "sha1",
-      "http://www.w3.org/2001/04/xmlenc#sha256": "sha256",
-      "http://www.w3.org/2001/04/xmlenc#sha384": "sha384",
-      "http://www.w3.org/2001/04/xmlenc#sha512": "sha512"
-    };
-    DIGEST_ALGORITHM_TO_WEB_CRYPTO = {
-      "http://www.w3.org/2000/09/xmldsig#sha1": "SHA-1",
-      "http://www.w3.org/2001/04/xmlenc#sha256": "SHA-256",
-      "http://www.w3.org/2001/04/xmlenc#sha384": "SHA-384",
-      "http://www.w3.org/2001/04/xmlenc#sha512": "SHA-512"
-    };
+    init_constants3();
   }
 });
 
 // src/pptx/core/utils/signature-xml-utils.ts
-function escapeXmlAttr(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
-}
-function escapeXmlText(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function isValidBase64(value) {
-  return typeof value === "string" && value.length > 0 && /^[A-Za-z0-9+/=\s]+$/.test(value);
-}
-function extractTagAttribute(xml, tagName, attributeName) {
-  const pattern = new RegExp(
-    `<${tagName}\\b[^>]*\\b${attributeName}="(?<attributeValue>[^"]+)"`,
-    "i"
-  );
-  const match = xml.match(pattern);
-  return match?.groups?.["attributeValue"]?.trim();
-}
-function extractFirstTagText(xml, localName29) {
-  const pattern = new RegExp(
-    `<([\\w.-]+:)?${localName29}\\b[^>]*>([\\s\\S]*?)<\\/([\\w.-]+:)?${localName29}>`,
-    "i"
-  );
-  const match = xml.match(pattern);
-  return match?.[2]?.replace(/\s+/g, "").trim() || void 0;
-}
-function extractAllTagText(xml, localName29) {
-  const result = [];
-  const regex = new RegExp(
-    `<([\\w.-]+:)?${localName29}\\b[^>]*>([\\s\\S]*?)<\\/([\\w.-]+:)?${localName29}>`,
-    "gi"
-  );
-  let match = regex.exec(xml);
-  while (match) {
-    const value = match[2]?.replace(/\s+/g, "").trim();
-    if (value) {
-      result.push(value);
-    }
-    match = regex.exec(xml);
-  }
-  return result;
-}
 var init_signature_xml_utils = __esm({
   "src/pptx/core/utils/signature-xml-utils.ts"() {
+    init_xml_utils2();
   }
 });
 
 // src/pptx/core/utils/signature-reference-utils.ts
-function normalizePartPath(partPath) {
-  return partPath.replace(/\\/g, "/").replace(/^\/+/, "");
-}
-function resolveReferenceUriToPart(uri) {
-  const trimmed = uri.trim();
-  if (trimmed.length === 0 || trimmed.startsWith("#")) {
-    return void 0;
-  }
-  const decoded = decodeURIComponent(trimmed);
-  return normalizePartPath(decoded.startsWith("/") ? decoded.slice(1) : decoded);
-}
 var init_signature_reference_utils = __esm({
   "src/pptx/core/utils/signature-reference-utils.ts"() {
+    init_reference_utils();
   }
 });
 
 // src/pptx/core/utils/signature-digest.ts
-async function computeDigestBase64(content, digestAlgorithmUri) {
-  const webCryptoAlgo = DIGEST_ALGORITHM_TO_WEB_CRYPTO[digestAlgorithmUri];
-  if (!webCryptoAlgo) {
-    return void 0;
-  }
-  if (typeof globalThis.crypto?.subtle === "undefined") {
-    return void 0;
-  }
-  const buf = new ArrayBuffer(content.byteLength);
-  new Uint8Array(buf).set(content);
-  const digest2 = await globalThis.crypto.subtle.digest(webCryptoAlgo, buf);
-  return uint8ArrayToBase64(new Uint8Array(digest2));
-}
-function uint8ArrayToBase64(bytes) {
-  let binary = "";
-  for (let i2 = 0; i2 < bytes.byteLength; i2++) {
-    binary += String.fromCharCode(bytes[i2]);
-  }
-  return btoa(binary);
-}
 var init_signature_digest = __esm({
   "src/pptx/core/utils/signature-digest.ts"() {
-    init_signature_constants();
+    init_digest();
   }
 });
 
 // src/pptx/core/utils/signature-inspection-status.ts
-function computeDetailStatus(detail, policy) {
-  const hasDigestMismatch = detail.referenceChecks.some(
-    (check) => check.digestStatus === "mismatch"
-  );
-  const hasMissingPart = detail.missingPartReferences.length > 0;
-  const hasVerifiedDigest = detail.referenceChecks.some(
-    (check) => check.digestStatus === "verified"
-  );
-  const revocationUnknown = detail.certificateRevocationStatus === "unknown" || detail.certificateRevocationStatus === "not-checked" || detail.certificateRevocationStatus === "error";
-  const timestampMissingOrUntrusted = detail.timestampAuthorityStatus === "not-present" || detail.timestampAuthorityStatus === "not-checked" || detail.timestampAuthorityStatus === "error" || detail.timestampAuthorityStatus === "untrusted";
-  if (detail.signatureValueStatus === "invalid") {
-    return "signature-invalid";
-  }
-  if (hasMissingPart) {
-    return "reference-missing";
-  }
-  if (hasDigestMismatch) {
-    return "digest-mismatch";
-  }
-  if (detail.certificateRevocationStatus === "revoked") {
-    return "certificate-revoked";
-  }
-  if (policy.requireRevocationCheck && (policy.failOnRevocationUnknown ? revocationUnknown : detail.certificateRevocationStatus !== "good")) {
-    return "certificate-untrusted";
-  }
-  if (detail.timestampAuthorityStatus === "invalid") {
-    return "timestamp-invalid";
-  }
-  if (policy.requireTimestamp && timestampMissingOrUntrusted) {
-    return "timestamp-untrusted";
-  }
-  if (detail.timestampAuthorityStatus === "untrusted") {
-    return "timestamp-untrusted";
-  }
-  if (detail.certificateTrustStatus === "untrusted" && detail.signatureValueStatus === "verified") {
-    return "certificate-untrusted";
-  }
-  if (hasVerifiedDigest && detail.signatureValueStatus === "verified") {
-    return "verified";
-  }
-  return "structural-only";
-}
-function computeVerificationStatus(details) {
-  const hasInvalidSignature = details.some((detail) => detail.status === "signature-invalid");
-  const hasMissing = details.some((detail) => detail.status === "reference-missing");
-  const hasMismatch = details.some((detail) => detail.status === "digest-mismatch");
-  const hasUntrusted = details.some((detail) => detail.status === "certificate-untrusted");
-  const hasRevoked = details.some((detail) => detail.status === "certificate-revoked");
-  const hasTimestampInvalid = details.some((detail) => detail.status === "timestamp-invalid");
-  const hasTimestampUntrusted = details.some((detail) => detail.status === "timestamp-untrusted");
-  const allVerified = details.every((detail) => detail.status === "verified");
-  return hasInvalidSignature ? "signature-invalid" : hasRevoked ? "certificate-revoked" : hasTimestampInvalid ? "timestamp-invalid" : hasTimestampUntrusted ? "timestamp-untrusted" : hasMissing ? "reference-missing" : hasMismatch ? "digest-mismatch" : allVerified ? "verified-trusted" : hasUntrusted ? "verified-untrusted" : "present-not-verified";
-}
 var init_signature_inspection_status = __esm({
   "src/pptx/core/utils/signature-inspection-status.ts"() {
+    init_inspection_status();
   }
 });
 
@@ -47509,11 +48037,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;
   }
@@ -48136,7 +48664,7 @@ function parseChartUniqueId(node, localName29) {
   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));
@@ -48148,7 +48676,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");
@@ -48157,7 +48685,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()}}`;
 }
@@ -52596,10 +53124,10 @@ function parseVmlGroup(node, idPrefix, index) {
     return null;
   }
 }
-function parseVmlElements(container, idPrefix = "") {
+function parseVmlElements(container2, idPrefix = "") {
   const elements2 = [];
   for (const tag of VML_SHAPE_TAGS) {
-    const nodes = container[tag];
+    const nodes = container2[tag];
     if (!nodes) {
       continue;
     }
@@ -52699,8 +53227,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 [];
   }
@@ -52720,7 +53248,7 @@ function unwrapAlternateContent(container) {
     for (const tag of SHAPE_TREE_ELEMENT_TAGS) {
       const children15 = ensureArray3(branch[tag]);
       if (children15.length > 0) {
-        container[tag] = [...ensureArray3(container[tag]), ...children15];
+        container2[tag] = [...ensureArray3(container2[tag]), ...children15];
         for (const child27 of children15) {
           block.childRefs.push({ tag, node: child27 });
         }
@@ -52730,11 +53258,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;
@@ -53629,16 +54157,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({
@@ -60156,12 +60684,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;
@@ -60227,24 +60755,24 @@ function parseEffectDagContainer(node) {
   const type = VALID_CONTAINER_TYPES.has(typeAttr) ? typeAttr : "sib";
   const nameAttr = String(xml["@_name"] ?? "").trim();
   const children15 = parseChildren(xml);
-  const container = {
+  const container2 = {
     kind: "cont",
     type,
     children: children15
   };
   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 children15 = [];
@@ -60310,7 +60838,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: []
@@ -60318,7 +60846,7 @@ function parseBlend(value) {
   return {
     kind: "blend",
     mode,
-    container
+    container: container2
   };
 }
 function parseXfrm(value) {
@@ -62115,13 +62643,13 @@ function boolValue2(node) {
   const value = node["@_val"];
   return value !== "0" && value !== "false";
 }
-function parseBubbleChartOptions(container, localName29) {
-  if (!container) {
+function parseBubbleChartOptions(container2, localName29) {
+  if (!container2) {
     return void 0;
   }
   const node = (name) => {
-    const key2 = findKey11(container, name, localName29);
-    return key2 ? container[key2] : void 0;
+    const key2 = findKey11(container2, name, localName29);
+    return key2 ? container2[key2] : void 0;
   };
   const options = {};
   const bubble3D = boolValue2(node("bubble3D"));
@@ -62148,33 +62676,33 @@ function parseBubbleChartOptions(container, localName29) {
   }
   return Object.keys(options).length > 0 ? options : void 0;
 }
-function insertOrdered2(container, name, value, localName29) {
-  const existingKey = findKey11(container, name, localName29);
+function insertOrdered2(container2, name, value, localName29) {
+  const existingKey = findKey11(container2, name, localName29);
   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(localName29(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, localName29) {
+function applyBubbleChartOptions(container2, options, localName29) {
   if (options.bubble3D !== void 0) {
-    insertOrdered2(container, "bubble3D", { "@_val": options.bubble3D ? "1" : "0" }, localName29);
+    insertOrdered2(container2, "bubble3D", { "@_val": options.bubble3D ? "1" : "0" }, localName29);
   }
   if (options.bubbleScale !== void 0) {
     insertOrdered2(
-      container,
+      container2,
       "bubbleScale",
       {
         "@_val": chartPercentUnionValue(options.bubbleScale, {
@@ -62188,14 +62716,14 @@ function applyBubbleChartOptions(container, options, localName29) {
   }
   if (options.showNegativeBubbles !== void 0) {
     insertOrdered2(
-      container,
+      container2,
       "showNegBubbles",
       { "@_val": options.showNegativeBubbles ? "1" : "0" },
       localName29
     );
   }
   if (options.sizeRepresents !== void 0) {
-    insertOrdered2(container, "sizeRepresents", { "@_val": options.sizeRepresents }, localName29);
+    insertOrdered2(container2, "sizeRepresents", { "@_val": options.sizeRepresents }, localName29);
   }
 }
 var ORDER2;
@@ -62561,12 +63089,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;
     }
@@ -62590,15 +63118,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) => localName14(key2) === kind);
-  for (const key2 of Object.keys(container)) {
+  const targetKey = Object.keys(container2).find((key2) => localName14(key2) === kind);
+  for (const key2 of Object.keys(container2)) {
     if (MEDIA_REFERENCE_NAMES.includes(localName14(key2))) {
-      delete container[key2];
+      delete container2[key2];
     }
   }
   const original = element.rawMediaReferenceXml ? { ...element.rawMediaReferenceXml } : {};
@@ -62615,7 +63143,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") {
@@ -62635,7 +63163,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") {
@@ -67905,10 +68433,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;
     }
@@ -67921,10 +68449,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({
@@ -73951,8 +74479,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]);
@@ -76888,8 +77416,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;
     }
@@ -77135,8 +77663,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++;
     }
@@ -80494,12 +81022,12 @@ function collectInteractiveSequences(node, found) {
     );
   }
   containers.push(...ensureArray11(node["p:par"]), ...ensureArray11(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) {
@@ -80600,16 +81128,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 children15 = ensureArray11(childTnList[container]);
+    for (const container2 of ["p:par", "p:seq", "p:excl"]) {
+      const children15 = ensureArray11(childTnList[container2]);
       for (const child27 of children15) {
         collectMediaNodes(child27, animations);
       }
     }
     collectMediaNodes(childTnList, animations);
   }
-  for (const container of ["p:par", "p:seq", "p:excl", "p:tnLst"]) {
-    const children15 = ensureArray11(node[container]);
+  for (const container2 of ["p:par", "p:seq", "p:excl", "p:tnLst"]) {
+    const children15 = ensureArray11(node[container2]);
     for (const child27 of children15) {
       collectMediaNodes(child27, animations);
     }
@@ -101737,7 +102265,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;
@@ -102544,12 +103072,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) {
@@ -102584,15 +103112,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;
   }
@@ -102613,9 +103141,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;
@@ -102660,8 +103188,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;
   }
@@ -103576,8 +104104,8 @@ var init_chart_protection2 = __esm({
 });
 
 // src/pptx/core/utils/chart-series-axis.ts
-function resolveChartContainerValueAxisId(container, axes, xmlLookup) {
-  const referencedIds2 = xmlLookup.getChildrenArrayByLocalName(container, "axId").map((node) => Number.parseInt(String(node["@_val"]), 10)).filter(Number.isFinite);
+function resolveChartContainerValueAxisId(container2, axes, xmlLookup) {
+  const referencedIds2 = xmlLookup.getChildrenArrayByLocalName(container2, "axId").map((node) => Number.parseInt(String(node["@_val"]), 10)).filter(Number.isFinite);
   for (let index = referencedIds2.length - 1; index >= 0; index--) {
     const id = referencedIds2[index];
     if (axes.some((axis) => axis.axisType === "valAx" && axis.axisId === id)) {
@@ -109130,10 +109658,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);
@@ -110020,8 +110548,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));
@@ -110116,19 +110644,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;
     }
@@ -110179,8 +110707,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);
     }
@@ -110844,13 +111372,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"() {
@@ -111749,20 +112277,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"() {
@@ -112085,22 +112613,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, i2) => {
     if (getLocalName2(k) === "ser") {
       lastSer = i2;
     }
   });
-  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) {
@@ -112137,25 +112665,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,
@@ -112164,9 +112692,9 @@ function applyChartDataLabelsToXml(plotArea, style, getLocalName2) {
       getLocalName2
     );
     if (existingKey) {
-      container[existingKey] = built;
+      container2[existingKey] = built;
     } else {
-      insertAfterLastSeries(container, built, getLocalName2);
+      insertAfterLastSeries(container2, built, getLocalName2);
     }
   }
 }
@@ -113161,54 +113689,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, i2) => buildSeries(family, s, i2, 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": {} };
@@ -113562,8 +114090,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);
@@ -113598,9 +114126,9 @@ async function writeCustomerDataScopes(zip, scopes, codec) {
       authoredEntries.push(rawEntry);
       contentTypes2.set(path, 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));
@@ -113650,11 +114178,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;
     }
@@ -113667,10 +114195,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");
@@ -113746,10 +114274,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;
     }
@@ -113762,10 +114290,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");
@@ -113777,10 +114305,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) {
@@ -114297,21 +114825,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);
       }
@@ -114319,18 +114847,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;
   }
@@ -114340,12 +114868,12 @@ function orderChartContainerChildren(container, containerLocal, getLocalName2) {
   if (sorted.every((k, i2) => k === keys[i2])) {
     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) {
@@ -114366,12 +114894,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));
@@ -114422,8 +114950,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 ensureArray18(v) {
   if (v === void 0) {
@@ -114439,9 +114967,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) {
@@ -114454,13 +114982,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(...ensureArray18(container[containerSerKey]));
+      allSeries.push(...ensureArray18(container2[containerSerKey]));
     }
     if (key2 !== primaryKey) {
       delete plotArea[key2];
@@ -114507,21 +115035,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) {
@@ -114532,7 +115060,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;
@@ -114543,8 +115071,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"() {
@@ -114597,8 +115125,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;
   }
@@ -114610,9 +115138,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);
@@ -114637,11 +115165,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"() {
@@ -115443,11 +115971,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;
 }
@@ -116210,12 +116738,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)) };
@@ -116223,13 +116751,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 {
@@ -116245,9 +116773,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({
@@ -116597,8 +117125,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;
@@ -120425,9 +120953,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;
         }
       }
     };
@@ -120934,8 +121462,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 children15 = this.ensureArray(childTnLst[container]);
+            for (const container2 of ["p:par", "p:seq", "p:excl"]) {
+              const children15 = this.ensureArray(childTnLst[container2]);
               for (const child27 of children15) {
                 this.walkMediaTimingTree(child27, result, slidePath);
               }
@@ -120943,8 +121471,8 @@ var init_PptxHandlerRuntimeMediaTimingParsing = __esm({
             this.walkMediaTimingTree(childTnLst, result, slidePath);
           }
         }
-        for (const container of ["p:par", "p:seq", "p:excl", "p:tnLst"]) {
-          const children15 = this.ensureArray(node[container]);
+        for (const container2 of ["p:par", "p:seq", "p:excl", "p:tnLst"]) {
+          const children15 = this.ensureArray(node[container2]);
           for (const child27 of children15) {
             this.walkMediaTimingTree(child27, result, slidePath);
           }
@@ -122109,8 +122637,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;
         }
@@ -128547,10 +129075,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)
                 );
@@ -128629,8 +129157,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);
         }
@@ -128639,17 +129167,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;
         }
@@ -135901,9 +136429,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;
@@ -135913,8 +136441,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;
@@ -140130,8 +140658,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 {
@@ -141628,8 +142156,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);
@@ -146714,17 +147242,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);
     }
   };
@@ -148233,13 +148761,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;
           }
@@ -148266,7 +148794,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,
@@ -148304,8 +148832,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, localName29) {
-        const node = this.xmlLookupService.getChildByLocalName(container, localName29);
+      parseChartNumberVal(container2, localName29) {
+        const node = this.xmlLookupService.getChildByLocalName(container2, localName29);
         const raw = node?.["@_val"];
         if (raw === void 0 || raw === null || raw === "") {
           return void 0;
@@ -148318,8 +148846,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, localName29) {
-        const node = this.xmlLookupService.getChildByLocalName(container, localName29);
+      parseChartBoolVal(container2, localName29) {
+        const node = this.xmlLookupService.getChildByLocalName(container2, localName29);
         if (!node) {
           return void 0;
         }
@@ -148989,7 +149517,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();
@@ -150160,7 +150688,7 @@ var init_core = __esm({
     init_PptxHandlerRuntime();
     init_builders();
     init_factories();
-    init_types3();
+    init_types4();
     init_table_structural_ops();
     init_table_style_defaults();
     init_auto_number_sequence();
@@ -150568,14 +151096,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;
     }
@@ -150835,14 +151363,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 } };
 }
@@ -151504,7 +152032,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,
@@ -151663,14 +152191,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;
   }
@@ -151679,10 +152207,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;
@@ -151690,7 +152218,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) {
@@ -151744,7 +152272,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)) {
@@ -151756,11 +152284,11 @@ function parseShape2(ctx, container) {
   }
   return shape;
 }
-function parseGroup(ctx, container) {
+function parseGroup(ctx, container2) {
   const children15 = [];
   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;
@@ -151830,8 +152358,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;
   }
@@ -151839,7 +152367,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];
   }
@@ -151856,7 +152384,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;
@@ -151867,22 +152395,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) {
@@ -151905,12 +152433,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) {
@@ -151930,7 +152458,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({
@@ -152081,11 +152609,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);
@@ -152172,7 +152700,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();
@@ -152221,6 +152749,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"() {
@@ -156409,9 +156951,9 @@ var MASTER_XMLNS = 'xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/ma
 var FALLBACK_CLR_MAP = '<p:clrMap bg1="lt1" tx1="dk1" bg2="lt2" tx2="dk2" accent1="accent1" accent2="accent2" accent3="accent3" accent4="accent4" accent5="accent5" accent6="accent6" hlink="hlink" folHlink="folHlink"/>';
 var FALLBACK_TX_STYLES = '<p:txStyles><p:titleStyle><a:lvl1pPr algn="l"><a:defRPr sz="4400" kern="1200"><a:solidFill><a:schemeClr val="tx1"/></a:solidFill><a:latin typeface="+mj-lt"/></a:defRPr></a:lvl1pPr></p:titleStyle><p:bodyStyle><a:lvl1pPr algn="l"><a:defRPr sz="3200" kern="1200"><a:solidFill><a:schemeClr val="tx1"/></a:solidFill><a:latin typeface="+mn-lt"/></a:defRPr></a:lvl1pPr></p:bodyStyle><p:otherStyle><a:defPPr><a:defRPr lang="en-US"/></a:defPPr></p:otherStyle></p:txStyles>';
 function extractTag(xml, tag) {
-  const container = xml.match(new RegExp(`<${tag}(?:\\s[^>]*)?>[^]*?</${tag}>`));
-  if (container) {
-    return container[0];
+  const container2 = xml.match(new RegExp(`<${tag}(?:\\s[^>]*)?>[^]*?</${tag}>`));
+  if (container2) {
+    return container2[0];
   }
   const selfClosed = xml.match(new RegExp(`<${tag}(?:\\s[^>]*)?/>`));
   return selfClosed ? selfClosed[0] : "";
@@ -170494,12 +171036,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(elements2) {