ooxml-core 0.9.0 → 0.10.0

package/dist/opc/index.cjs

@@ -2,6 +2,12 @@
 
 var xmldom = require('@xmldom/xmldom');
 
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
 // src/opc/relationship-types.ts
 var BASE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
 var RELATIONSHIP_TYPES = {
@@ -33,6 +39,7 @@ var RELATIONSHIP_TYPES = {
   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`,
@@ -55,12 +62,69 @@ var RELATIONSHIP_TYPES = {
 
 // src/xml/namespaces.ts
 var NS = {
+  /** WordprocessingML main. */
+  w: "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
+  /** PresentationML main. */
+  p: "http://schemas.openxmlformats.org/presentationml/2006/main",
+  /** SpreadsheetML main. */
+  x: "http://schemas.openxmlformats.org/spreadsheetml/2006/main",
+  /** DrawingML main. */
+  a: "http://schemas.openxmlformats.org/drawingml/2006/main",
+  /** DrawingML chart. */
+  c: "http://schemas.openxmlformats.org/drawingml/2006/chart",
+  /** DrawingML diagram (SmartArt) main. */
+  dgm: "http://schemas.openxmlformats.org/drawingml/2006/diagram",
+  /** Office 2007+ diagram drawing (`dsp`). */
+  dsp: "http://schemas.microsoft.com/office/drawing/2008/diagram",
+  /** DrawingML Word drawing (`wp:inline`, `wp:anchor`). */
+  wp: "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing",
+  /** DrawingML picture. */
+  pic: "http://schemas.openxmlformats.org/drawingml/2006/picture",
+  /** Word 2010 shapes (`wps`). */
+  wps: "http://schemas.microsoft.com/office/word/2010/wordprocessingShape",
   /** Relationships (`r:id`, `r:embed`). */
   r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+  /** Markup compatibility (`mc:AlternateContent`). */
+  mc: "http://schemas.openxmlformats.org/markup-compatibility/2006",
   /** OPC relationships part. */
   rels: "http://schemas.openxmlformats.org/package/2006/relationships",
   /** OPC content types part. */
-  contentTypes: "http://schemas.openxmlformats.org/package/2006/content-types"};
+  contentTypes: "http://schemas.openxmlformats.org/package/2006/content-types",
+  /** Office Math. */
+  m: "http://schemas.openxmlformats.org/officeDocument/2006/math",
+  /** Core properties. */
+  cp: "http://schemas.openxmlformats.org/package/2006/metadata/core-properties",
+  /** Dublin Core elements. */
+  dc: "http://purl.org/dc/elements/1.1/",
+  /** Legacy VML. */
+  v: "urn:schemas-microsoft-com:vml",
+  /** Office VML extensions. */
+  o: "urn:schemas-microsoft-com:office:office",
+  /** Word VML extensions. */
+  w10: "urn:schemas-microsoft-com:office:word",
+  /** SpreadsheetML drawing (`xdr:wsDr`, cell anchors). */
+  xdr: "http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing",
+  /** SpreadsheetML 2009 extensions (`x14:conditionalFormatting`, `x14:dataBar`). */
+  x14: "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main",
+  /** SpreadsheetML 2009 attribute extensions (`x14ac:dyDescent`). */
+  x14ac: "http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac",
+  /** SpreadsheetML revision ids (`xr:uid`). */
+  xr: "http://schemas.microsoft.com/office/spreadsheetml/2014/revision",
+  /** Excel threaded comments and persons. */
+  tc: "http://schemas.microsoft.com/office/spreadsheetml/2018/threadedcomments",
+  /** Legacy VML Excel client data (`x:ClientData`). */
+  xv: "urn:schemas-microsoft-com:office:excel",
+  /** Extended (app) properties. */
+  extendedProperties: "http://schemas.openxmlformats.org/officeDocument/2006/extended-properties",
+  /** Dublin Core terms (`dcterms:created`). */
+  dcterms: "http://purl.org/dc/terms/",
+  /** Custom document properties (`docProps/custom.xml`). */
+  customProperties: "http://schemas.openxmlformats.org/officeDocument/2006/custom-properties",
+  /** Document property variant types (`vt:lpwstr`, `vt:vector`). */
+  vt: "http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes",
+  /** XML itself (`xml:space`). */
+  xml: "http://www.w3.org/XML/1998/namespace"
+};
 function parseXml(xml, options = {}) {
   const label = options.label ?? "OOXML";
   if (/<!DOCTYPE|<!ENTITY/i.test(xml))
@@ -82,8 +146,15 @@ function parseXml(xml, options = {}) {
     throw new Error(`Invalid ${label} XML: ${parseError || "missing root element"}`);
   return parsed;
 }
+var buildXml = (document) => new xmldom.XMLSerializer().serializeToString(document);
 var isElement = (node) => node.nodeType === 1;
 var elements = (parent) => Array.from(parent.childNodes).filter(isElement);
+function named(element, local, ns, lenient = true) {
+  if (!element || element.localName !== local) return false;
+  return element.namespaceURI === ns || lenient && !element.namespaceURI;
+}
+var children = (parent, local, ns, lenient = true) => elements(parent).filter((element) => named(element, local, ns, lenient));
+var first = (parent, local, ns, lenient = true) => parent ? children(parent, local, ns, lenient)[0] : void 0;
 function attr(element, local, ns, prefix) {
   return element?.getAttributeNS(ns, local) ?? element?.getAttribute(`${prefix}:${local}`) ?? void 0;
 }
@@ -227,8 +298,723 @@ function isSafeHyperlinkHref(href) {
   const scheme = /^([a-z][a-z0-9+.-]*:)/i.exec(href.trim())?.[1];
   return scheme !== void 0 && SAFE_SCHEMES.has(scheme.toLowerCase());
 }
+var OPEN_SCHEMES = /* @__PURE__ */ new Set(["http", "https", "mailto"]);
+var STORE_SCHEMES = /* @__PURE__ */ new Set([...OPEN_SCHEMES, "ftp", "file"]);
+var SCRIPT_SCHEMES = /* @__PURE__ */ new Set([
+  "javascript",
+  "vbscript",
+  "livescript",
+  "jscript",
+  "mocha",
+  "data",
+  "mhtml",
+  "ms-its",
+  "mk",
+  "x-javascript",
+  "blob"
+]);
+var IGNORABLE = new RegExp(
+  "[\\u0000-\\u0020\\u007f\\u00ad\\u200b-\\u200f\\u202a-\\u202e\\u2060-\\u2064\\ufeff]",
+  "gu"
+);
+var CONTROL = new RegExp("[\\u0000-\\u001f\\u007f]", "u");
+var SCHEME = /^([a-z][a-z0-9+.-]*):/;
+var STORE_ONLY = { store: true, open: false, reason: "not-openable" };
+var reject = (reason) => ({
+  store: false,
+  open: false,
+  reason
+});
+function hyperlinkPolicy(href) {
+  if (typeof href !== "string") return reject("empty");
+  const trimmed = href.trim();
+  const normalized = trimmed.replace(IGNORABLE, "").toLowerCase();
+  if (normalized.length === 0) return reject("empty");
+  const scheme = SCHEME.exec(normalized)?.[1];
+  if (scheme !== void 0 && SCRIPT_SCHEMES.has(scheme)) return reject("script-scheme");
+  if (scheme !== void 0 && !trimmed.toLowerCase().startsWith(`${scheme}:`))
+    return reject("obfuscated-scheme");
+  if (CONTROL.test(trimmed)) return reject("control-characters");
+  if (scheme === void 0 || scheme.length === 1) return STORE_ONLY;
+  if (OPEN_SCHEMES.has(scheme)) return { store: true, open: true };
+  if (STORE_SCHEMES.has(scheme)) return STORE_ONLY;
+  return reject("unsupported-scheme");
+}
+function isStorableHyperlinkHref(href) {
+  return hyperlinkPolicy(href).store;
+}
+function isOpenableHyperlinkHref(href) {
+  return hyperlinkPolicy(href).open;
+}
+
+// src/opc/properties/types.ts
+var CUSTOM_PROPERTIES_FMTID = "{D5CDD505-2E9C-101B-9397-08002B2CF9AE}";
+var PROPERTY_PART_NAMES = {
+  core: "docProps/core.xml",
+  app: "docProps/app.xml",
+  custom: "docProps/custom.xml"
+};
+var PROPERTY_CONTENT_TYPES = {
+  core: "application/vnd.openxmlformats-package.core-properties+xml",
+  app: "application/vnd.openxmlformats-officedocument.extended-properties+xml",
+  custom: "application/vnd.openxmlformats-officedocument.custom-properties+xml"
+};
+
+// src/opc/properties/core.ts
+var XSI = "http://www.w3.org/2001/XMLSchema-instance";
+var FIELDS = [
+  ["title", "dc", false],
+  ["subject", "dc", false],
+  ["creator", "dc", false],
+  ["keywords", "cp", false],
+  ["description", "dc", false],
+  ["lastModifiedBy", "cp", false],
+  ["created", "dcterms", true],
+  ["modified", "dcterms", true],
+  ["category", "cp", false],
+  ["contentStatus", "cp", false],
+  ["revision", "cp", false],
+  ["language", "dc", false],
+  ["identifier", "dc", false],
+  ["lastPrinted", "cp", false],
+  ["version", "cp", false]
+];
+var CORE_PROPERTY_FIELDS = FIELDS.map(([field]) => field);
+var EMPTY_CORE = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<cp:coreProperties xmlns:cp="${NS.cp}" xmlns:dc="${NS.dc}" xmlns:dcterms="${NS.dcterms}" xmlns:dcmitype="http://purl.org/dc/dcmitype/" xmlns:xsi="${XSI}"/>`;
+function parseCoreProperties(xml) {
+  const out = {};
+  if (!xml) return out;
+  const root = parseXml(xml, { label: "core properties" }).documentElement;
+  for (const [field, prefix] of FIELDS) {
+    const text = first(root, field, NS[prefix])?.textContent ?? "";
+    if (text !== "") out[field] = text;
+  }
+  return out;
+}
+function writeCoreProperties(props, sourceXml) {
+  const doc = parseXml(sourceXml ?? EMPTY_CORE, { label: "core properties" });
+  const root = doc.documentElement;
+  for (const [field, prefix, isDate] of FIELDS) {
+    const ns = NS[prefix];
+    const value = props[field];
+    let element = first(root, field, ns);
+    if (value === void 0 || value === "") {
+      if (element && (element.textContent ?? "") !== "") root.removeChild(element);
+      continue;
+    }
+    if (!element) {
+      element = doc.createElementNS(ns, `${prefix}:${field}`);
+      if (isDate) element.setAttributeNS(XSI, "xsi:type", "dcterms:W3CDTF");
+      root.appendChild(element);
+    }
+    if (element.textContent !== value) element.textContent = value;
+  }
+  const out = buildXml(doc);
+  return out.startsWith("<?xml") ? out : `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+${out}`;
+}
+
+// src/opc/properties/app.ts
+var FIELDS2 = [
+  ["template", "Template", "text"],
+  ["totalTime", "TotalTime", "int"],
+  ["application", "Application", "text"],
+  ["docSecurity", "DocSecurity", "int"],
+  ["scaleCrop", "ScaleCrop", "bool"],
+  ["headingPairs", "HeadingPairs", "pairs"],
+  ["titlesOfParts", "TitlesOfParts", "titles"],
+  ["manager", "Manager", "text"],
+  ["company", "Company", "text"],
+  ["linksUpToDate", "LinksUpToDate", "bool"],
+  ["sharedDoc", "SharedDoc", "bool"],
+  ["hyperlinkBase", "HyperlinkBase", "text"],
+  ["hyperlinksChanged", "HyperlinksChanged", "bool"],
+  ["appVersion", "AppVersion", "text"]
+];
+var EMPTY_APP = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Properties xmlns="${NS.extendedProperties}" xmlns:vt="${NS.vt}"/>`;
+function vectorItems(element) {
+  const vector = first(element, "vector", NS.vt);
+  return vector ? elements(vector) : [];
+}
+function readPairs(element) {
+  const variants = vectorItems(element).map((variant) => elements(variant)[0]);
+  const out = [];
+  for (let i = 0; i + 1 < variants.length; i += 2) {
+    const name = variants[i]?.textContent ?? "";
+    const count = Number.parseInt(variants[i + 1]?.textContent ?? "", 10);
+    out.push({ name, count: Number.isFinite(count) ? count : 0 });
+  }
+  return out;
+}
+function readField(element, kind) {
+  const text = element.textContent ?? "";
+  if (kind === "pairs") return readPairs(element);
+  if (kind === "titles") return vectorItems(element).map((item) => item.textContent ?? "");
+  if (kind === "bool") return text.trim() === "true" || text.trim() === "1";
+  if (kind === "int") {
+    const value = Number.parseInt(text, 10);
+    return Number.isFinite(value) ? value : void 0;
+  }
+  return text === "" ? void 0 : text;
+}
+function parseAppProperties(xml) {
+  const out = {};
+  if (!xml) return out;
+  const root = parseXml(xml, { label: "app properties" }).documentElement;
+  for (const [field, local, kind] of FIELDS2) {
+    const element = first(root, local, NS.extendedProperties);
+    if (!element) continue;
+    const value = readField(element, kind);
+    if (value !== void 0) out[field] = value;
+  }
+  return out;
+}
+var same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+function fill(doc, element, kind, value) {
+  while (element.firstChild) element.removeChild(element.firstChild);
+  const vt = (local, text) => {
+    const node = doc.createElementNS(NS.vt, `vt:${local}`);
+    if (text !== void 0) node.textContent = text;
+    return node;
+  };
+  if (kind === "pairs" || kind === "titles") {
+    const items = kind === "pairs" ? value.flatMap((pair) => [
+      vt("lpstr", pair.name),
+      vt("i4", String(Math.trunc(pair.count)))
+    ]) : value.map((title) => vt("lpstr", title));
+    const vector = vt("vector");
+    vector.setAttribute("size", String(items.length));
+    vector.setAttribute("baseType", kind === "pairs" ? "variant" : "lpstr");
+    for (const item of items) {
+      if (kind === "pairs") {
+        const variant = vt("variant");
+        variant.appendChild(item);
+        vector.appendChild(variant);
+      } else vector.appendChild(item);
+    }
+    element.appendChild(vector);
+    return;
+  }
+  element.textContent = kind === "bool" ? value ? "true" : "false" : String(value);
+}
+function writeAppProperties(props, sourceXml) {
+  const doc = parseXml(sourceXml ?? EMPTY_APP, { label: "app properties" });
+  const root = doc.documentElement;
+  const prior = parseAppProperties(sourceXml);
+  FIELDS2.forEach(([field, local, kind], index) => {
+    const value = props[field];
+    const existing = first(root, local, NS.extendedProperties);
+    if (value === void 0 || kind === "text" && value === "") {
+      if (existing && (existing.textContent ?? "") !== "") root.removeChild(existing);
+      return;
+    }
+    if (existing && same(prior[field], value)) return;
+    let element = existing;
+    if (!element) {
+      element = doc.createElementNS(NS.extendedProperties, local);
+      const next = FIELDS2.slice(index + 1).map(([, name]) => first(root, name, NS.extendedProperties)).find((node) => node !== void 0);
+      root.insertBefore(element, next ?? null);
+    }
+    fill(doc, element, kind, value);
+  });
+  const out = buildXml(doc);
+  return out.startsWith("<?xml") ? out : `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+${out}`;
+}
+
+// src/opc/properties/custom.ts
+var escape = (text, attribute = false) => {
+  const out = text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  return attribute ? out.replace(/"/g, "&quot;") : out;
+};
+var isVt = (element) => element.namespaceURI === NS.vt || element.prefix === "vt";
+function readValue(variant) {
+  const text = variant.textContent ?? "";
+  switch (isVt(variant) ? variant.localName : "") {
+    case "lpwstr":
+      return { name: "", type: "lpwstr", value: text };
+    case "i4":
+    case "int": {
+      const value = Number.parseInt(text, 10);
+      return Number.isFinite(value) ? { name: "", type: "i4", value } : void 0;
+    }
+    case "r8": {
+      const value = Number(text);
+      return text.trim() !== "" && Number.isFinite(value) ? { name: "", type: "r8", value } : void 0;
+    }
+    case "bool":
+      return { name: "", type: "bool", value: text.trim() === "true" || text.trim() === "1" };
+    case "filetime":
+      return { name: "", type: "filetime", value: text };
+    default:
+      return void 0;
+  }
+}
+function parseCustomProperties(xml) {
+  if (!xml) return [];
+  const root = parseXml(xml, { label: "custom properties" }).documentElement;
+  const out = [];
+  for (const property of children(root, "property", NS.customProperties)) {
+    const name = property.getAttribute("name") ?? "";
+    const variant = elements(property)[0];
+    if (!name || !variant) continue;
+    const value = readValue(variant) ?? {
+      name,
+      type: "raw",
+      xml: buildXml(variant)
+    };
+    const pid = Number.parseInt(property.getAttribute("pid") ?? "", 10);
+    const linkTarget = property.getAttribute("linkTarget");
+    out.push({
+      ...value,
+      name,
+      ...Number.isFinite(pid) ? { pid } : {},
+      ...linkTarget ? { linkTarget } : {}
+    });
+  }
+  return out;
+}
+function allocateCustomPropertyIds(properties) {
+  const used = /* @__PURE__ */ new Set();
+  const kept = properties.map((property) => {
+    const pid = property.pid;
+    if (pid === void 0 || !Number.isInteger(pid) || pid < 2 || used.has(pid)) return void 0;
+    used.add(pid);
+    return pid;
+  });
+  let next = Math.max(1, ...used) + 1;
+  return kept.map((pid) => pid ?? next++);
+}
+function variantXml(property) {
+  switch (property.type) {
+    case "raw":
+      return property.xml;
+    case "lpwstr":
+      return `<vt:lpwstr>${escape(property.value)}</vt:lpwstr>`;
+    case "i4":
+      return `<vt:i4>${Math.trunc(property.value)}</vt:i4>`;
+    case "r8":
+      return `<vt:r8>${String(property.value)}</vt:r8>`;
+    case "bool":
+      return `<vt:bool>${property.value ? "true" : "false"}</vt:bool>`;
+    case "filetime":
+      return `<vt:filetime>${escape(property.value)}</vt:filetime>`;
+  }
+}
+function writeCustomProperties(properties) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = properties.filter((property) => {
+    const key = property.name.toLowerCase();
+    if (!property.name || seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  if (!unique.length) return void 0;
+  const pids = allocateCustomPropertyIds(unique);
+  const body = unique.map((property, index) => {
+    const link = property.linkTarget ? ` linkTarget="${escape(property.linkTarget, true)}"` : "";
+    return `<property fmtid="${CUSTOM_PROPERTIES_FMTID}" pid="${pids[index] ?? index + 2}" name="${escape(property.name, true)}"${link}>${variantXml(property)}</property>`;
+  }).join("");
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Properties xmlns="${NS.customProperties}" xmlns:vt="${NS.vt}">${body}</Properties>`;
+}
+
+// src/opc/signature/index.ts
+var signature_exports = {};
+__export(signature_exports, {
+  DIGEST_ALGORITHM_TO_HASH: () => DIGEST_ALGORITHM_TO_HASH,
+  DIGEST_ALGORITHM_TO_WEB_CRYPTO: () => DIGEST_ALGORITHM_TO_WEB_CRYPTO,
+  DIGITAL_SIGNATURE_ORIGIN_REL_TYPE: () => DIGITAL_SIGNATURE_ORIGIN_REL_TYPE,
+  DIGITAL_SIGNATURE_REL_TYPE: () => DIGITAL_SIGNATURE_REL_TYPE,
+  ENTERPRISE_FAIL_ON_REVOCATION_UNKNOWN_ENV: () => ENTERPRISE_FAIL_ON_REVOCATION_UNKNOWN_ENV,
+  ENTERPRISE_REQUIRE_REVOCATION_ENV: () => ENTERPRISE_REQUIRE_REVOCATION_ENV,
+  ENTERPRISE_REQUIRE_TIMESTAMP_ENV: () => ENTERPRISE_REQUIRE_TIMESTAMP_ENV,
+  ENTERPRISE_TRUST_ROOTS_FILE_ENV: () => ENTERPRISE_TRUST_ROOTS_FILE_ENV,
+  ENTERPRISE_TRUST_ROOTS_PEM_ENV: () => ENTERPRISE_TRUST_ROOTS_PEM_ENV,
+  OPC_RELATIONSHIP_TRANSFORM: () => OPC_RELATIONSHIP_TRANSFORM,
+  PPTX_VIEWER_MANIFEST_NS: () => PPTX_VIEWER_MANIFEST_NS,
+  SIGNATURE_PART_PREFIX: () => SIGNATURE_PART_PREFIX,
+  SUPPORTED_XML_CANON_TRANSFORMS: () => SUPPORTED_XML_CANON_TRANSFORMS,
+  XMLDSIG_NS: () => XMLDSIG_NS,
+  XML_TRANSFORM_ENVELOPED_SIGNATURE: () => XML_TRANSFORM_ENVELOPED_SIGNATURE,
+  computeDetailStatus: () => computeDetailStatus,
+  computeDigestBase64: () => computeDigestBase64,
+  computeVerificationStatus: () => computeVerificationStatus,
+  detectDigitalSignatures: () => detectDigitalSignatures,
+  escapeXmlAttr: () => escapeXmlAttr,
+  escapeXmlText: () => escapeXmlText,
+  extractAllTagText: () => extractAllTagText,
+  extractFirstTagText: () => extractFirstTagText,
+  extractTagAttribute: () => extractTagAttribute,
+  getSignaturePathsToStrip: () => getSignaturePathsToStrip,
+  isSignaturePart: () => isSignaturePart,
+  isValidBase64: () => isValidBase64,
+  normalizePartPath: () => normalizePartPath,
+  parseSignatureXml: () => parseSignatureXml,
+  resolveReferenceUriToPart: () => resolveReferenceUriToPart,
+  verifySignatureDigests: () => verifySignatureDigests
+});
+
+// src/opc/signature/detection.ts
+var SIGNATURE_PART_PREFIX = "_xmlsignatures/";
+var SIGNATURE_PREFIX = SIGNATURE_PART_PREFIX;
+function isSignaturePart(path) {
+  return path.replace(/^\//, "").toLowerCase().startsWith(SIGNATURE_PART_PREFIX);
+}
+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, localName) {
+  if (!parent) {
+    return void 0;
+  }
+  if (parent[localName] !== void 0 && typeof parent[localName] === "object") {
+    return parent[localName];
+  }
+  for (const key of Object.keys(parent)) {
+    const parts = key.split(":");
+    if (parts[parts.length - 1] === localName && typeof parent[key] === "object") {
+      return parent[key];
+    }
+  }
+  return void 0;
+}
+function findScalarByLocalName(parent, localName) {
+  if (!parent) {
+    return void 0;
+  }
+  if (parent[localName] !== void 0) {
+    const v = parent[localName];
+    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 key of Object.keys(parent)) {
+    const parts = key.split(":");
+    if (parts[parts.length - 1] === localName) {
+      const v = parent[key];
+      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, localName) {
+  if (!parent) {
+    return [];
+  }
+  for (const key of Object.keys(parent)) {
+    const parts = key.split(":");
+    if (parts[parts.length - 1] === localName) {
+      const v = parent[key];
+      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 digest = await crypto.subtle.digest(hashAlgo, content);
+      const digestBase64 = arrayBufferToBase64(digest);
+      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 i = 0; i < bytes.byteLength; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+
+// src/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"
+};
+
+// 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, localName) {
+  const pattern = new RegExp(
+    `<([\\w.-]+:)?${localName}\\b[^>]*>([\\s\\S]*?)<\\/([\\w.-]+:)?${localName}>`,
+    "i"
+  );
+  const match = xml.match(pattern);
+  return match?.[2]?.replace(/\s+/g, "").trim() || void 0;
+}
+function extractAllTagText(xml, localName) {
+  const result = [];
+  const regex = new RegExp(
+    `<([\\w.-]+:)?${localName}\\b[^>]*>([\\s\\S]*?)<\\/([\\w.-]+:)?${localName}>`,
+    "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;
+}
+
+// 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);
+}
+
+// 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 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);
+}
+
+// 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";
+}
 
+exports.CORE_PROPERTY_FIELDS = CORE_PROPERTY_FIELDS;
+exports.CUSTOM_PROPERTIES_FMTID = CUSTOM_PROPERTIES_FMTID;
+exports.PROPERTY_CONTENT_TYPES = PROPERTY_CONTENT_TYPES;
+exports.PROPERTY_PART_NAMES = PROPERTY_PART_NAMES;
 exports.RELATIONSHIP_TYPES = RELATIONSHIP_TYPES;
+exports.allocateCustomPropertyIds = allocateCustomPropertyIds;
 exports.buildContentTypesXml = buildContentTypesXml;
 exports.buildRelationshipsXml = buildRelationshipsXml;
 exports.contentTypeForPart = contentTypeForPart;
@@ -237,9 +1023,19 @@ exports.ensureContentTypeOverride = ensureContentTypeOverride;
 exports.ensureRelationship = ensureRelationship;
 exports.findOfficeDocumentPart = findOfficeDocumentPart;
 exports.getRelationshipId = getRelationshipId;
+exports.hyperlinkPolicy = hyperlinkPolicy;
+exports.isOpenableHyperlinkHref = isOpenableHyperlinkHref;
 exports.isSafeHyperlinkHref = isSafeHyperlinkHref;
+exports.isStorableHyperlinkHref = isStorableHyperlinkHref;
 exports.nextRelationshipId = nextRelationshipId;
+exports.parseAppProperties = parseAppProperties;
 exports.parseContentTypes = parseContentTypes;
+exports.parseCoreProperties = parseCoreProperties;
+exports.parseCustomProperties = parseCustomProperties;
 exports.parseRelationships = parseRelationships;
 exports.relationshipsPartFor = relationshipsPartFor;
 exports.resolvePartPath = resolvePartPath;
+exports.signature = signature_exports;
+exports.writeAppProperties = writeAppProperties;
+exports.writeCoreProperties = writeCoreProperties;
+exports.writeCustomProperties = writeCustomProperties;