ooxml-core 1.12.2 → 1.14.0

package/dist/chunk-M4XLF4R7.mjs

@@ -0,0 +1,387 @@
+import JSZip from 'jszip';
+
+// pptx/core/core/types.ts
+var DEFAULT_MAX_UNCOMPRESSED_BYTES = 500 * 1024 * 1024;
+var MAX_ZIP_ENTRY_COUNT = 65536;
+var ZipBombError = class extends Error {
+  code = "ZIP_BOMB";
+  uncompressedBytes;
+  limit;
+  entryCount;
+  constructor(message, details) {
+    super(message);
+    this.name = "ZipBombError";
+    this.uncompressedBytes = details.uncompressedBytes;
+    this.limit = details.limit;
+    this.entryCount = details.entryCount;
+  }
+};
+
+// opc/signature/constants.ts
+var DIGITAL_SIGNATURE_ORIGIN_REL_TYPE = "http://schemas.openxmlformats.org/package/2006/relationships/digital-signature/origin";
+var DIGITAL_SIGNATURE_REL_TYPE = "http://schemas.openxmlformats.org/package/2006/relationships/digital-signature/signature";
+var PPTX_VIEWER_MANIFEST_NS = "urn:pptx-viewer:ooxml-signature:v1";
+var XMLDSIG_NS = "http://www.w3.org/2000/09/xmldsig#";
+var OPC_RELATIONSHIP_TRANSFORM = "http://schemas.openxmlformats.org/package/2006/RelationshipTransform";
+var XML_TRANSFORM_ENVELOPED_SIGNATURE = "http://www.w3.org/2000/09/xmldsig#enveloped-signature";
+var 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
+]);
+var ENTERPRISE_TRUST_ROOTS_FILE_ENV = "PPTX_VIEWER_TRUST_ROOTS_FILE";
+var ENTERPRISE_TRUST_ROOTS_PEM_ENV = "PPTX_VIEWER_TRUST_ROOTS_PEM";
+var ENTERPRISE_REQUIRE_REVOCATION_ENV = "PPTX_VIEWER_REQUIRE_REVOCATION_CHECK";
+var ENTERPRISE_FAIL_ON_REVOCATION_UNKNOWN_ENV = "PPTX_VIEWER_FAIL_ON_REVOCATION_UNKNOWN";
+var ENTERPRISE_REQUIRE_TIMESTAMP_ENV = "PPTX_VIEWER_REQUIRE_TIMESTAMP";
+var 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"
+};
+var 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"
+};
+
+// 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();
+}
+var isNameChar = (c) => c !== void 0 && /[\w.-]/.test(c);
+var isWordChar = (c) => c !== void 0 && /\w/.test(c);
+function matchName(xml, lowerXml, from, lname) {
+  let pos = from;
+  if (!lowerXml.startsWith(lname, pos)) {
+    let end = pos;
+    while (isNameChar(xml[end])) end++;
+    if (end === pos || xml[end] !== ":") return -1;
+    pos = end + 1;
+    if (!lowerXml.startsWith(lname, pos)) return -1;
+  }
+  return pos + lname.length;
+}
+function findTagText(xml, lowerXml, lname, from) {
+  let lt = xml.indexOf("<", from);
+  while (lt !== -1) {
+    const afterName = matchName(xml, lowerXml, lt + 1, lname);
+    if (afterName !== -1 && !isWordChar(xml[afterName])) {
+      const gt = xml.indexOf(">", afterName);
+      if (gt === -1) return null;
+      let close = xml.indexOf("</", gt + 1);
+      while (close !== -1) {
+        const closeEnd = matchName(xml, lowerXml, close + 2, lname);
+        if (closeEnd !== -1 && xml[closeEnd] === ">") {
+          return { text: xml.slice(gt + 1, close), end: closeEnd + 1 };
+        }
+        close = xml.indexOf("</", close + 2);
+      }
+      return null;
+    }
+    lt = xml.indexOf("<", lt + 1);
+  }
+  return null;
+}
+function extractFirstTagText(xml, localName) {
+  const found = findTagText(xml, xml.toLowerCase(), localName.toLowerCase(), 0);
+  return found?.text.replace(/\s+/g, "").trim() || void 0;
+}
+function extractAllTagText(xml, localName) {
+  const result = [];
+  const lowerXml = xml.toLowerCase();
+  const lname = localName.toLowerCase();
+  let found = findTagText(xml, lowerXml, lname, 0);
+  while (found) {
+    const value = found.text.replace(/\s+/g, "").trim();
+    if (value) {
+      result.push(value);
+    }
+    found = findTagText(xml, lowerXml, lname, found.end);
+  }
+  return result;
+}
+
+// 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);
+}
+
+// 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 digest = await globalThis.crypto.subtle.digest(webCryptoAlgo, buf);
+  return uint8ArrayToBase64(new Uint8Array(digest));
+}
+function uint8ArrayToBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.byteLength; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+
+// 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 DEFAULT_ZIP_LIMITS = {
+  maxInputBytes: 100 * 1024 * 1024,
+  maxEntries: 1e4,
+  maxEntryBytes: 100 * 1024 * 1024,
+  maxTotalBytes: 100 * 1024 * 1024
+};
+var ZipLimitError = class extends Error {
+  code = "ZIP_BOMB";
+  limit;
+  constructor(message, details) {
+    super(message);
+    this.name = "ZipLimitError";
+    this.limit = details.limit;
+  }
+};
+var mib = (bytes) => Math.round(bytes / 1048576);
+function isSafePartName(name) {
+  if (name.includes("\0") || name.includes("\\")) return false;
+  if (/^[A-Za-z]:/u.test(name)) return false;
+  const body = name.startsWith("/") ? name.slice(1) : name;
+  if (body.startsWith("/")) return false;
+  return !body.split("/").some((segment) => segment === "..");
+}
+function declaredEntrySize(entry) {
+  const data = entry._data;
+  const size = Number(data?.uncompressedSize ?? 0);
+  return Number.isFinite(size) && size > 0 ? size : 0;
+}
+function resolveLimits(limits) {
+  const create = limits.createError;
+  return {
+    maxEntries: limits.maxEntries ?? DEFAULT_ZIP_LIMITS.maxEntries,
+    maxEntryBytes: limits.maxEntryBytes ?? DEFAULT_ZIP_LIMITS.maxEntryBytes,
+    maxTotalBytes: limits.maxTotalBytes ?? DEFAULT_ZIP_LIMITS.maxTotalBytes,
+    label: limits.label ?? "ZIP",
+    fail: (message, limit) => create ? create(message, { limit }) : new ZipLimitError(message, { limit })
+  };
+}
+function inflateEntryGuarded(entry, alreadyRead, limits) {
+  const r = resolveLimits(limits);
+  const declared = declaredEntrySize(entry);
+  return new Promise((resolvePromise, reject) => {
+    const chunks = [];
+    let size = 0;
+    let done = false;
+    const stream = entry.internalStream("uint8array");
+    const abort = (error) => {
+      if (done) return;
+      done = true;
+      stream.pause();
+      chunks.length = 0;
+      reject(error);
+    };
+    stream.on("data", (chunk) => {
+      if (done) return;
+      size += chunk.byteLength;
+      if (size > declared || size > r.maxEntryBytes)
+        return abort(
+          r.fail(`${r.label} part ${entry.name} inflates past its declared size`, r.maxEntryBytes)
+        );
+      if (alreadyRead + size > r.maxTotalBytes)
+        return abort(
+          r.fail(
+            `${r.label} package exceeds the ${mib(r.maxTotalBytes)} MiB uncompressed content limit`,
+            r.maxTotalBytes
+          )
+        );
+      chunks.push(chunk);
+    });
+    stream.on("error", (error) => abort(error));
+    stream.on("end", () => {
+      if (done) return;
+      done = true;
+      if (chunks.length === 1 && chunks[0]) return resolvePromise(chunks[0]);
+      const out = new Uint8Array(size);
+      let offset = 0;
+      for (const chunk of chunks) {
+        out.set(chunk, offset);
+        offset += chunk.byteLength;
+      }
+      resolvePromise(out);
+    });
+    stream.resume();
+  });
+}
+function toBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += 32768)
+    binary += String.fromCharCode(...bytes.subarray(i, i + 32768));
+  return btoa(binary);
+}
+function guardZip(zip, limits = {}) {
+  const r = resolveLimits(limits);
+  const entries = Object.values(zip.files);
+  if (entries.length > r.maxEntries)
+    throw r.fail(
+      `${r.label} package exceeds the ${r.maxEntries.toLocaleString("en-US")} part limit`,
+      r.maxEntries
+    );
+  let declared = 0;
+  for (const entry of entries) {
+    const original = entry.unsafeOriginalName;
+    if (!isSafePartName(entry.name) || original !== void 0 && !isSafePartName(original))
+      throw r.fail(`${r.label} package has an unsafe part name`, r.maxEntries);
+    if (entry.dir) continue;
+    const size = declaredEntrySize(entry);
+    if (size > r.maxEntryBytes)
+      throw r.fail(
+        `${r.label} part ${entry.name} exceeds the uncompressed part size limit`,
+        r.maxEntryBytes
+      );
+    declared += size;
+  }
+  if (declared > r.maxTotalBytes)
+    throw r.fail(
+      `${r.label} package exceeds the ${mib(r.maxTotalBytes)} MiB uncompressed content limit`,
+      r.maxTotalBytes
+    );
+  const produced = /* @__PURE__ */ new Map();
+  let total = 0;
+  for (const entry of entries) {
+    if (entry.dir) continue;
+    const inflateOriginal = entry.async.bind(entry);
+    entry.async = async (type, onUpdate) => {
+      const previous = produced.get(entry.name) ?? 0;
+      const bytes = await inflateEntryGuarded(entry, total - previous, limits);
+      if (bytes.byteLength > previous) {
+        total += bytes.byteLength - previous;
+        produced.set(entry.name, bytes.byteLength);
+      }
+      switch (type) {
+        case "uint8array":
+          return bytes;
+        case "string":
+        case "text":
+          return new TextDecoder("utf-8", { ignoreBOM: true }).decode(bytes);
+        case "arraybuffer":
+          return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+        case "base64":
+          return toBase64(bytes);
+        default:
+          return inflateOriginal(type, onUpdate);
+      }
+    };
+  }
+  return zip;
+}
+async function openZip(input, limits = {}) {
+  const r = resolveLimits(limits);
+  const maxInput = limits.maxInputBytes ?? DEFAULT_ZIP_LIMITS.maxInputBytes;
+  const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
+  if (bytes.byteLength > maxInput)
+    throw r.fail(
+      `${r.label} package exceeds the ${mib(maxInput)} MiB compressed input limit`,
+      maxInput
+    );
+  return guardZip(await JSZip.loadAsync(bytes), limits);
+}
+
+// pptx/core/utils/zip-open.ts
+var createError = (message, details) => new ZipBombError(message, details);
+function openPptxZip(bytes) {
+  return openZip(bytes, {
+    label: "PPTX",
+    maxInputBytes: DEFAULT_MAX_UNCOMPRESSED_BYTES,
+    maxEntries: MAX_ZIP_ENTRY_COUNT,
+    maxEntryBytes: DEFAULT_MAX_UNCOMPRESSED_BYTES,
+    maxTotalBytes: DEFAULT_MAX_UNCOMPRESSED_BYTES,
+    createError
+  });
+}
+function openNestedZip(bytes) {
+  return openZip(bytes, { label: "Embedded", createError });
+}
+
+export { DEFAULT_MAX_UNCOMPRESSED_BYTES, DIGEST_ALGORITHM_TO_HASH, DIGEST_ALGORITHM_TO_WEB_CRYPTO, DIGITAL_SIGNATURE_ORIGIN_REL_TYPE, DIGITAL_SIGNATURE_REL_TYPE, ENTERPRISE_FAIL_ON_REVOCATION_UNKNOWN_ENV, ENTERPRISE_REQUIRE_REVOCATION_ENV, ENTERPRISE_REQUIRE_TIMESTAMP_ENV, ENTERPRISE_TRUST_ROOTS_FILE_ENV, ENTERPRISE_TRUST_ROOTS_PEM_ENV, MAX_ZIP_ENTRY_COUNT, OPC_RELATIONSHIP_TRANSFORM, PPTX_VIEWER_MANIFEST_NS, SUPPORTED_XML_CANON_TRANSFORMS, XMLDSIG_NS, XML_TRANSFORM_ENVELOPED_SIGNATURE, ZipBombError, computeDetailStatus, computeDigestBase64, computeVerificationStatus, escapeXmlAttr, escapeXmlText, extractAllTagText, extractFirstTagText, extractTagAttribute, guardZip, isValidBase64, normalizePartPath, openNestedZip, openPptxZip, resolveReferenceUriToPart };