@opengeni/artifact-tool 0.2.2

package/dist/presentation-pptx.js

@@ -0,0 +1,2365 @@
+import {
+  presentationModelDigest,
+  sha256Hex
+} from "./chunk-5XIA6KHZ.js";
+import {
+  inflateBoundedZipEntry,
+  parseBoundedZip,
+  verifyBoundedZipEntry
+} from "./chunk-72SYDU4O.js";
+import {
+  PPTX_MEDIA_TYPE,
+  Presentation,
+  PresentationFidelityError,
+  PresentationFile,
+  PresentationSecurityError,
+  colorValue,
+  presentationLossState,
+  setPresentationLossState
+} from "./chunk-PI2AZVGK.js";
+import "./chunk-FGZM4FQ6.js";
+import {
+  FileBlob
+} from "./chunk-4BSENMAE.js";
+import "./chunk-Q2FFHEY7.js";
+import "./chunk-VUNV25KB.js";
+
+// src/presentation-pptx-xml.ts
+function parsePptxXmlPart(bytes, partName, budget) {
+  if (bytes.byteLength > budget.limits.xmlBytes) {
+    throw pptxXmlLimit("XML part exceeds its byte limit", partName);
+  }
+  budget.totalBytes += bytes.byteLength;
+  if (budget.totalBytes > budget.limits.totalXmlBytes) {
+    throw pptxXmlLimit("PPTX exceeds its total XML byte limit", partName);
+  }
+  let xml;
+  try {
+    if (bytes[0] === 255 && bytes[1] === 254) {
+      xml = new TextDecoder("utf-16le", { fatal: true }).decode(bytes);
+    } else if (bytes[0] === 254 && bytes[1] === 255) {
+      xml = new TextDecoder("utf-16be", { fatal: true }).decode(bytes);
+    } else {
+      xml = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    }
+  } catch {
+    throw pptxXmlSecurity("OOXML text is not valid UTF-8 or UTF-16", "unsafe-xml", partName);
+  }
+  if (/<!\s*(?:DOCTYPE|ENTITY)\b/i.test(xml)) {
+    throw pptxXmlSecurity("DOCTYPE and entity declarations are forbidden", "unsafe-xml", partName);
+  }
+  const parsed = parseXml(xml, partName, budget);
+  validateNamespaceBindings(parsed, partName, /* @__PURE__ */ new Map());
+  return parsed;
+}
+function parseXml(xml, partName, budget) {
+  const stack = [];
+  let root;
+  let cursor = 0;
+  let sawDeclaration = false;
+  const addNode = (node) => {
+    budget.totalNodes += 1;
+    if (budget.totalNodes > budget.limits.xmlNodes) {
+      throw pptxXmlLimit("PPTX exceeds its XML node limit", partName);
+    }
+    const parent = stack.at(-1);
+    if (parent) parent.children.push(node);
+    else if (node.type === "text" && isXmlWhitespace(node.value)) return;
+    else if (node.type === "element" && !root) root = node;
+    else
+      throw pptxXmlSecurity(
+        "XML has text outside its root or multiple roots",
+        "unsafe-xml",
+        partName
+      );
+  };
+  while (cursor < xml.length) {
+    const opening = xml.indexOf("<", cursor);
+    if (opening < 0) {
+      if (cursor < xml.length)
+        addNode({ type: "text", value: decodeEntities(xml.slice(cursor), partName) });
+      cursor = xml.length;
+      break;
+    }
+    if (opening > cursor) {
+      addNode({ type: "text", value: decodeEntities(xml.slice(cursor, opening), partName) });
+    }
+    if (xml.startsWith("<!--", opening)) {
+      const end2 = xml.indexOf("-->", opening + 4);
+      const body = end2 < 0 ? "" : xml.slice(opening + 4, end2);
+      if (end2 < 0 || body.includes("--") || body.endsWith("-")) {
+        throw pptxXmlSecurity("Malformed XML comment", "unsafe-xml", partName);
+      }
+      validateXmlCharacters(body, partName);
+      cursor = end2 + 3;
+      continue;
+    }
+    if (xml.startsWith("<?", opening)) {
+      const end2 = xml.indexOf("?>", opening + 2);
+      const instruction = end2 < 0 ? "" : xml.slice(opening + 2, end2);
+      const declaration = /^xml[\x20\t\r\n]+version=(?:"1\.[01]"|'1\.[01]')(?:[\x20\t\r\n]+encoding=(?:"[Uu][Tt][Ff]-(?:8|16)"|'[Uu][Tt][Ff]-(?:8|16)'))?(?:[\x20\t\r\n]+standalone=(?:"(?:yes|no)"|'(?:yes|no)'))?[\x20\t\r\n]*$/.test(
+        instruction
+      );
+      if (end2 < 0 || !declaration || opening !== 0 || root || stack.length > 0 || sawDeclaration) {
+        throw pptxXmlSecurity(
+          "XML processing instructions are unsupported",
+          "unsafe-xml",
+          partName
+        );
+      }
+      sawDeclaration = true;
+      cursor = end2 + 2;
+      continue;
+    }
+    if (xml.startsWith("<!", opening)) {
+      throw pptxXmlSecurity("XML declarations and CDATA are unsupported", "unsafe-xml", partName);
+    }
+    const end = findTagEnd(xml, opening + 1, partName);
+    const source = xml.slice(opening + 1, end);
+    if (source.startsWith("/")) {
+      const match = /^\/([^\x20\t\r\n]+)[\x20\t\r\n]*$/.exec(source);
+      const name = match?.[1];
+      if (!name || !XML_QNAME.test(name)) {
+        throw pptxXmlSecurity("Malformed XML closing tag", "unsafe-xml", partName);
+      }
+      const current = stack.pop();
+      if (!current || current.name !== name) {
+        throw pptxXmlSecurity("Mismatched XML closing tag", "unsafe-xml", partName);
+      }
+    } else {
+      if (isXmlSpace(source[0])) {
+        throw pptxXmlSecurity("XML start tag has leading whitespace", "unsafe-xml", partName);
+      }
+      const selfClosing = /\/[\x20\t\r\n]*$/.test(source);
+      const body = selfClosing ? source.replace(/\/[\x20\t\r\n]*$/, "") : source;
+      const element = parseStartTag(body, partName, budget.limits.xmlAttributesPerElement);
+      addNode(element);
+      if (!selfClosing) {
+        stack.push(element);
+        if (stack.length > budget.limits.xmlDepth) {
+          throw pptxXmlLimit("XML exceeds its depth limit", partName);
+        }
+      }
+    }
+    cursor = end + 1;
+  }
+  if (stack.length > 0 || !root) {
+    throw pptxXmlSecurity("XML is empty or ends with unclosed elements", "unsafe-xml", partName);
+  }
+  return root;
+}
+function findTagEnd(xml, start, partName) {
+  let quote;
+  for (let index = start; index < xml.length; index += 1) {
+    const character = xml[index];
+    if (quote) {
+      if (character === quote) quote = void 0;
+    } else if (character === '"' || character === "'") quote = character;
+    else if (character === ">") return index;
+  }
+  throw pptxXmlSecurity("Unterminated XML tag", "unsafe-xml", partName);
+}
+function parseStartTag(source, partName, maxAttributes) {
+  let cursor = 0;
+  const skipSpace = () => {
+    while (cursor < source.length && isXmlSpace(source[cursor])) cursor += 1;
+  };
+  const nameStart = cursor;
+  while (cursor < source.length && !isXmlSpace(source[cursor])) cursor += 1;
+  const name = source.slice(nameStart, cursor);
+  if (!XML_QNAME.test(name)) {
+    throw pptxXmlSecurity("Invalid XML element name", "unsafe-xml", partName);
+  }
+  const attributes = /* @__PURE__ */ new Map();
+  while (cursor < source.length) {
+    if (!isXmlSpace(source[cursor])) {
+      throw pptxXmlSecurity(
+        "XML attributes must be separated by whitespace",
+        "unsafe-xml",
+        partName
+      );
+    }
+    skipSpace();
+    if (cursor >= source.length) break;
+    const attributeStart = cursor;
+    while (cursor < source.length && !isXmlSpace(source[cursor]) && source[cursor] !== "=")
+      cursor += 1;
+    const attributeName = source.slice(attributeStart, cursor);
+    if (!XML_QNAME.test(attributeName)) {
+      throw pptxXmlSecurity("Invalid XML attribute name", "unsafe-xml", partName);
+    }
+    skipSpace();
+    if (source[cursor] !== "=") {
+      throw pptxXmlSecurity("XML attribute lacks a value", "unsafe-xml", partName);
+    }
+    cursor += 1;
+    skipSpace();
+    const quote = source[cursor];
+    if (quote !== '"' && quote !== "'") {
+      throw pptxXmlSecurity("XML attribute value must be quoted", "unsafe-xml", partName);
+    }
+    cursor += 1;
+    const valueStart = cursor;
+    const valueEnd = source.indexOf(quote, valueStart);
+    if (valueEnd < 0) {
+      throw pptxXmlSecurity("Unterminated XML attribute", "unsafe-xml", partName);
+    }
+    if (attributes.has(attributeName)) {
+      throw pptxXmlSecurity("Duplicate XML attribute", "unsafe-xml", partName);
+    }
+    if (attributes.size >= maxAttributes) {
+      throw pptxXmlLimit("XML element exceeds its attribute limit", partName);
+    }
+    const rawValue = source.slice(valueStart, valueEnd);
+    if (rawValue.includes("<")) {
+      throw pptxXmlSecurity(
+        "XML attribute contains an unescaped less-than sign",
+        "unsafe-xml",
+        partName
+      );
+    }
+    attributes.set(attributeName, decodeEntities(rawValue, partName));
+    cursor = valueEnd + 1;
+  }
+  return { type: "element", name, localName: xmlLocalName(name), attributes, children: [] };
+}
+function validateNamespaceBindings(element, partName, inherited) {
+  const bindings = new Map(inherited);
+  for (const [name, value] of element.attributes) {
+    if (name === "xmlns") bindings.set("", value);
+    else if (name.startsWith("xmlns:")) {
+      const declaredPrefix = name.slice(6);
+      const required = REQUIRED_NAMESPACE_URIS.get(declaredPrefix);
+      if (required && required !== value) {
+        throw pptxXmlSecurity(
+          "OOXML namespace prefix is rebound to an unexpected URI",
+          "unsafe-xml",
+          partName
+        );
+      }
+      bindings.set(declaredPrefix, value);
+    }
+  }
+  const prefix = xmlPrefix(element.name);
+  if (prefix && !bindings.has(prefix)) {
+    throw pptxXmlSecurity(
+      "XML element uses an undeclared namespace prefix",
+      "unsafe-xml",
+      partName
+    );
+  }
+  const namespaceUri = bindings.get(prefix ?? "");
+  if (namespaceUri === void 0) delete element.namespaceUri;
+  else element.namespaceUri = namespaceUri;
+  const attributeNamespaces = /* @__PURE__ */ new Map();
+  for (const name of element.attributes.keys()) {
+    if (name === "xmlns" || name.startsWith("xmlns:")) continue;
+    const attributePrefix = xmlPrefix(name);
+    if (attributePrefix && attributePrefix !== "xml" && !bindings.has(attributePrefix)) {
+      throw pptxXmlSecurity(
+        "XML attribute uses an undeclared namespace prefix",
+        "unsafe-xml",
+        partName
+      );
+    }
+    attributeNamespaces.set(
+      name,
+      attributePrefix === "xml" ? "http://www.w3.org/XML/1998/namespace" : attributePrefix ? bindings.get(attributePrefix) : void 0
+    );
+  }
+  element.attributeNamespaces = attributeNamespaces;
+  for (const child of pptxXmlChildren(element))
+    validateNamespaceBindings(child, partName, bindings);
+}
+function decodeEntities(value, partName) {
+  validateXmlCharacters(value, partName);
+  if (value.includes("]]>")) {
+    throw pptxXmlSecurity("XML contains malformed character data", "unsafe-xml", partName);
+  }
+  if (!value.includes("&")) return value;
+  const output = [];
+  let cursor = 0;
+  let ampersand = value.indexOf("&");
+  let references = 0;
+  while (ampersand >= 0) {
+    references += 1;
+    if (references > 65536) {
+      throw pptxXmlLimit("XML text exceeds its entity reference limit", partName);
+    }
+    output.push(value.slice(cursor, ampersand));
+    const semicolon = value.indexOf(";", ampersand + 1);
+    const nested = value.indexOf("&", ampersand + 1);
+    if (semicolon < 0 || nested >= 0 && nested < semicolon) {
+      throw pptxXmlSecurity(
+        "XML contains an unterminated entity reference",
+        "unsafe-xml",
+        partName
+      );
+    }
+    const entity = value.slice(ampersand + 1, semicolon);
+    if (entity.length === 0 || entity.length > 16) {
+      throw pptxXmlSecurity("XML contains a malformed entity reference", "unsafe-xml", partName);
+    }
+    output.push(decodeEntity(entity, partName));
+    cursor = semicolon + 1;
+    ampersand = value.indexOf("&", cursor);
+  }
+  output.push(value.slice(cursor));
+  return output.join("");
+}
+function decodeEntity(entity, partName) {
+  if (entity === "amp") return "&";
+  if (entity === "lt") return "<";
+  if (entity === "gt") return ">";
+  if (entity === "quot") return '"';
+  if (entity === "apos") return "'";
+  const decimal = /^#([0-9]+)$/.exec(entity);
+  const hexadecimal = /^#x([0-9a-f]+)$/i.exec(entity);
+  const codePoint = decimal ? Number(decimal[1]) : hexadecimal ? Number.parseInt(hexadecimal[1] ?? "", 16) : NaN;
+  if (!Number.isInteger(codePoint) || !isValidXmlCodePoint(codePoint)) {
+    throw pptxXmlSecurity(`Unsupported or invalid XML entity: &${entity};`, "unsafe-xml", partName);
+  }
+  return String.fromCodePoint(codePoint);
+}
+function validateXmlCharacters(value, partName) {
+  for (const character of value) {
+    if (!isValidXmlCodePoint(character.codePointAt(0) ?? 0)) {
+      throw pptxXmlSecurity("XML contains a forbidden character", "unsafe-xml", partName);
+    }
+  }
+}
+function isValidXmlCodePoint(codePoint) {
+  return codePoint === 9 || codePoint === 10 || codePoint === 13 || codePoint >= 32 && codePoint <= 55295 || codePoint >= 57344 && codePoint <= 65533 || codePoint >= 65536 && codePoint <= 1114111;
+}
+function pptxXmlChildren(element) {
+  return element?.children.filter((child) => child.type === "element") ?? [];
+}
+function pptxXmlChild(element, localName) {
+  return pptxXmlChildren(element).find((child) => child.localName === localName);
+}
+function pptxXmlDescendants(element, localName) {
+  const output = [];
+  const visit = (node) => {
+    for (const child of pptxXmlChildren(node)) {
+      if (child.localName === localName) output.push(child);
+      visit(child);
+    }
+  };
+  if (element) visit(element);
+  return output;
+}
+function pptxXmlAttribute(element, localName) {
+  if (!element) return void 0;
+  for (const [name, value] of element.attributes) {
+    if (xmlLocalName(name) === localName && name !== "xmlns" && !name.startsWith("xmlns:"))
+      return value;
+  }
+  return void 0;
+}
+function pptxXmlQualifiedAttribute(element, qualifiedName) {
+  return element?.attributes.get(qualifiedName);
+}
+function pptxXmlText(element) {
+  if (!element) return "";
+  let output = "";
+  const visit = (node) => {
+    if (node.type === "text") output += node.value;
+    else for (const child of node.children) visit(child);
+  };
+  visit(element);
+  return output;
+}
+function pptxXmlDirectText(element) {
+  return element?.children.filter((child) => child.type === "text").map((child) => child.value).join("") ?? "";
+}
+function pptxXmlSecurity(message, code, entryName) {
+  return new PresentationSecurityError(
+    entryName ? `${message}: ${entryName}` : message,
+    code,
+    entryName
+  );
+}
+function pptxXmlLimit(message, entryName) {
+  return pptxXmlSecurity(message, "limit-exceeded", entryName);
+}
+function xmlLocalName(value) {
+  return value.slice(value.indexOf(":") + 1);
+}
+function xmlPrefix(value) {
+  const index = value.indexOf(":");
+  return index < 0 ? void 0 : value.slice(0, index);
+}
+function isXmlSpace(value) {
+  return value === " " || value === "	" || value === "\r" || value === "\n";
+}
+function isXmlWhitespace(value) {
+  for (const character of value) if (!isXmlSpace(character)) return false;
+  return true;
+}
+var XML_QNAME = /^(?:[A-Za-z_][A-Za-z0-9_.-]*:)?[A-Za-z_][A-Za-z0-9_.-]*$/;
+var REQUIRED_NAMESPACE_URIS = /* @__PURE__ */ new Map([
+  ["a", "http://schemas.openxmlformats.org/drawingml/2006/main"],
+  ["c", "http://schemas.openxmlformats.org/drawingml/2006/chart"],
+  ["p", "http://schemas.openxmlformats.org/presentationml/2006/main"],
+  ["r", "http://schemas.openxmlformats.org/officeDocument/2006/relationships"]
+]);
+
+// src/presentation-pptx-import.ts
+var OFFICE_RELATIONSHIP_BASE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/";
+var PACKAGE_RELATIONSHIP_BASE = "http://schemas.openxmlformats.org/package/2006/relationships/";
+var PRESENTATION_MAIN_TYPE = "application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml";
+var PRESENTATION_NAMESPACE = "http://schemas.openxmlformats.org/presentationml/2006/main";
+var DRAWING_NAMESPACE = "http://schemas.openxmlformats.org/drawingml/2006/main";
+var CHART_NAMESPACE = "http://schemas.openxmlformats.org/drawingml/2006/chart";
+var CONTENT_TYPES_NAMESPACE = "http://schemas.openxmlformats.org/package/2006/content-types";
+var RELATIONSHIPS_NAMESPACE = "http://schemas.openxmlformats.org/package/2006/relationships";
+var TABLE_GRAPHIC_URI = "http://schemas.openxmlformats.org/drawingml/2006/table";
+var CHART_GRAPHIC_URI = "http://schemas.openxmlformats.org/drawingml/2006/chart";
+var EMU_PER_PIXEL = 9525;
+var DEFAULT_PPTX_IMPORT_LIMITS = Object.freeze({
+  compressedBytes: 128 * 1024 * 1024,
+  expandedBytes: 256 * 1024 * 1024,
+  entryBytes: 64 * 1024 * 1024,
+  entries: 3e4,
+  compressionRatio: 100,
+  totalXmlBytes: 32 * 1024 * 1024,
+  xmlBytes: 8 * 1024 * 1024,
+  xmlDepth: 192,
+  xmlNodes: 2e6,
+  xmlAttributesPerElement: 512,
+  relationshipsPerPart: 8192,
+  relationships: 5e4,
+  slides: 1e4,
+  elements: 1e6,
+  textCharacters: 16e6,
+  imageBytes: 128 * 1024 * 1024,
+  chartPoints: 5e6,
+  nestedPackageBytes: 32 * 1024 * 1024,
+  nestedExpandedBytes: 64 * 1024 * 1024,
+  nestedEntries: 2e4,
+  retainedBytes: 256 * 1024 * 1024
+});
+async function importPresentationPptx(input, options = {}) {
+  const limits = resolveLimits(options.limits);
+  const bytes = await toBytes(input);
+  if (bytes.byteLength === 0 || bytes.byteLength > limits.compressedBytes) {
+    throw pptxSecurity(
+      bytes.byteLength === 0 ? "PPTX input is empty" : "PPTX exceeds its compressed byte limit",
+      bytes.byteLength === 0 ? "invalid-package" : "limit-exceeded"
+    );
+  }
+  const directory = parseBoundedZip(
+    bytes,
+    {
+      entries: limits.entries,
+      compressedEntryBytes: limits.compressedBytes,
+      expandedEntryBytes: limits.entryBytes,
+      expandedBytes: limits.expandedBytes,
+      compressionRatio: limits.compressionRatio,
+      compressionRatioThreshold: 1048576
+    },
+    pptxZipFailure
+  );
+  const entries = new Map(directory.map((entry) => [entry.name, entry]));
+  const context = {
+    bytes,
+    limits,
+    entries,
+    xmlBudget: { limits, totalBytes: 0, totalNodes: 0 },
+    xmlCache: /* @__PURE__ */ new Map(),
+    bytesCache: /* @__PURE__ */ new Map(),
+    relationshipsCache: /* @__PURE__ */ new Map(),
+    issues: [],
+    unsupportedParts: /* @__PURE__ */ new Set(),
+    elements: 0,
+    textCharacters: 0,
+    imageBytes: 0,
+    chartPoints: 0,
+    relationships: 0,
+    nestedExpandedBytes: 0,
+    nestedEntries: 0,
+    retainedBytes: bytes.byteLength,
+    themeColors: DEFAULT_THEME_COLORS
+  };
+  await preflightPackage(context);
+  const rootRelationships = relationshipsFor(context, "");
+  const officeDocuments = rootRelationships.filter(
+    (relationship) => relationship.type === `${OFFICE_RELATIONSHIP_BASE}officeDocument`
+  );
+  if (officeDocuments.length !== 1 || officeDocuments[0]?.partName !== "ppt/presentation.xml") {
+    throw pptxSecurity(
+      "PPTX must contain exactly one canonical ppt/presentation.xml office document",
+      "invalid-package",
+      "_rels/.rels"
+    );
+  }
+  const presentationRoot = readXml(context, "ppt/presentation.xml");
+  requireRoot(presentationRoot, "presentation", PRESENTATION_NAMESPACE, "ppt/presentation.xml");
+  const presentationRelationships = relationshipsFor(context, "ppt/presentation.xml");
+  const presentationRelationshipById = byRelationshipId(presentationRelationships);
+  const slideSize = parseSlideSize(presentationRoot);
+  const themeRelationship = presentationRelationships.find(
+    (relationship) => relationship.type === `${OFFICE_RELATIONSHIP_BASE}theme`
+  );
+  if (themeRelationship) {
+    context.themeColors = parseThemeColors(
+      readXml(context, themeRelationship.partName),
+      themeRelationship.partName
+    );
+  }
+  const presentation = Presentation.create({ slideSize });
+  const masterByPart = /* @__PURE__ */ new Map();
+  const layoutByPart = /* @__PURE__ */ new Map();
+  importMastersAndLayouts(
+    context,
+    presentation,
+    presentationRoot,
+    presentationRelationshipById,
+    masterByPart,
+    layoutByPart
+  );
+  importSlides(context, presentation, presentationRoot, presentationRelationshipById, layoutByPart);
+  const deduplicatedIssues = deduplicateIssues(context.issues);
+  if (options.unsupportedContent === "error" && deduplicatedIssues.length > 0) {
+    throw new PresentationFidelityError(
+      "PPTX contains inert content that the editable presentation model cannot regenerate exactly",
+      deduplicatedIssues
+    );
+  }
+  const { presentationModelDigest: presentationModelDigest2, sha256Hex: sha256Hex2 } = await import("./presentation-pptx-state-digest-765CZZED.js");
+  setPresentationLossState(presentation, {
+    version: 1,
+    mediaType: PPTX_MEDIA_TYPE,
+    sourceBytes: bytes,
+    sourceDigest: await sha256Hex2(bytes),
+    unsupportedParts: [...context.unsupportedParts].sort(),
+    modelDigest: await presentationModelDigest2(presentation)
+  });
+  return presentation;
+}
+function resolveLimits(requested) {
+  const limits = { ...DEFAULT_PPTX_IMPORT_LIMITS, ...requested };
+  for (const [name, value] of Object.entries(limits)) {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+      throw pptxSecurity(`Invalid PPTX import limit: ${name}`, "limit-exceeded");
+    }
+    const maximum = DEFAULT_PPTX_IMPORT_LIMITS[name];
+    if (value > maximum) {
+      throw pptxSecurity(
+        `PPTX import limit ${name} may only tighten the production maximum`,
+        "limit-exceeded"
+      );
+    }
+  }
+  return limits;
+}
+async function toBytes(input) {
+  if (input instanceof Uint8Array) return input.slice();
+  if (input instanceof ArrayBuffer) return new Uint8Array(input.slice(0));
+  if (input instanceof Blob) return new Uint8Array(await input.arrayBuffer());
+  throw pptxSecurity("PPTX input must be a Blob, ArrayBuffer, or Uint8Array", "invalid-package");
+}
+async function preflightPackage(context) {
+  if (!context.entries.has("[Content_Types].xml") || !context.entries.has("_rels/.rels")) {
+    throw pptxSecurity("PPTX is missing required OPC package parts", "invalid-package");
+  }
+  for (const entry of context.entries.values()) rejectActiveEntry(entry.name, entry.directory);
+  for (const entry of context.entries.values()) {
+    if (entry.directory) continue;
+    if (isXmlPart(entry.name)) {
+      const xmlBytes = await inflateBoundedZipEntry(
+        context.bytes,
+        entry,
+        context.limits.entryBytes,
+        pptxZipFailure
+      );
+      reserveRetained(context, xmlBytes.byteLength * 3, entry.name);
+      context.bytesCache.set(entry.name, xmlBytes);
+      readXml(context, entry.name);
+    } else if (isRasterMediaPart(entry.name)) {
+      const imageBytes = await inflateBoundedZipEntry(
+        context.bytes,
+        entry,
+        context.limits.entryBytes,
+        pptxZipFailure
+      );
+      reserveRetained(context, imageBytes.byteLength, entry.name);
+      context.bytesCache.set(entry.name, imageBytes);
+    } else if (/^ppt\/embeddings\/.*\.xlsx$/i.test(entry.name)) {
+      const nestedBytes = await inflateBoundedZipEntry(
+        context.bytes,
+        entry,
+        context.limits.nestedPackageBytes,
+        pptxZipFailure
+      );
+      await preflightEmbeddedXlsx(context, entry, nestedBytes);
+    } else {
+      await verifyBoundedZipEntry(context.bytes, entry, context.limits.entryBytes, pptxZipFailure);
+    }
+  }
+  validateContentTypes(context);
+  for (const entry of context.entries.values()) {
+    if (!entry.name.endsWith(".rels")) continue;
+    relationshipsForPart(context, entry.name);
+  }
+  validateRelationshipTargets(context);
+  classifySourceOnlyParts(context);
+}
+function isXmlPart(name) {
+  return name === "[Content_Types].xml" || /(?:\.xml|\.rels)$/i.test(name);
+}
+function readXml(context, partName) {
+  const cached = context.xmlCache.get(partName);
+  if (cached) return cached;
+  const bytes = readPartBytes(context, partName);
+  const parsed = parsePptxXmlPart(bytes, partName, context.xmlBudget);
+  context.xmlCache.set(partName, parsed);
+  context.bytesCache.delete(partName);
+  return parsed;
+}
+function readPartBytes(context, partName) {
+  const cached = context.bytesCache.get(partName);
+  if (cached) return cached;
+  const entry = context.entries.get(partName);
+  if (!entry || entry.directory) {
+    throw pptxSecurity("Required PPTX part is missing", "invalid-package", partName);
+  }
+  throw pptxSecurity(
+    "PPTX part was not inflated during bounded preflight",
+    "invalid-package",
+    partName
+  );
+}
+function validateContentTypes(context) {
+  const root = readXml(context, "[Content_Types].xml");
+  requireRoot(root, "Types", CONTENT_TYPES_NAMESPACE, "[Content_Types].xml");
+  const defaults = /* @__PURE__ */ new Map();
+  const overrides = /* @__PURE__ */ new Map();
+  for (const child of pptxXmlChildren(root)) {
+    if (child.localName === "Default") {
+      const extension = requiredAttribute(child, "Extension", "[Content_Types].xml").toLowerCase();
+      const contentType = requiredAttribute(child, "ContentType", "[Content_Types].xml");
+      if (defaults.has(extension)) {
+        throw pptxSecurity(
+          "Duplicate OPC content-type extension",
+          "invalid-package",
+          "[Content_Types].xml"
+        );
+      }
+      defaults.set(extension, contentType);
+      if (!KNOWN_DEFAULT_CONTENT_TYPES.has(`${extension}\0${contentType}`)) {
+        markSourceOnly(context, ["[Content_Types].xml"]);
+      }
+    } else if (child.localName === "Override") {
+      const name = requiredAttribute(child, "PartName", "[Content_Types].xml");
+      if (!name.startsWith("/") || name.includes("\\") || name.includes("..")) {
+        throw pptxSecurity(
+          "Unsafe OPC content-type part name",
+          "invalid-package",
+          "[Content_Types].xml"
+        );
+      }
+      const normalized = name.slice(1);
+      const contentType = requiredAttribute(child, "ContentType", "[Content_Types].xml");
+      if (overrides.has(normalized.toLowerCase())) {
+        throw pptxSecurity("Duplicate OPC content-type override", "invalid-package", normalized);
+      }
+      overrides.set(normalized.toLowerCase(), contentType);
+      if (!isKnownPptxPart(normalized)) {
+        markSourceOnly(context, ["[Content_Types].xml", normalized]);
+      }
+    } else {
+      throw pptxSecurity(
+        "Unknown OPC content-type declaration",
+        "invalid-package",
+        "[Content_Types].xml"
+      );
+    }
+  }
+  const presentationType = overrides.get("ppt/presentation.xml");
+  if (presentationType !== PRESENTATION_MAIN_TYPE) {
+    throw pptxSecurity(
+      presentationType?.includes("macroEnabled") ? "Macro-enabled presentations are forbidden" : "ppt/presentation.xml has the wrong content type",
+      presentationType?.includes("macroEnabled") ? "active-content" : "invalid-package",
+      "[Content_Types].xml"
+    );
+  }
+  for (const entry of context.entries.values()) {
+    if (entry.directory || entry.name === "[Content_Types].xml") continue;
+    const extension = entry.name.includes(".") ? entry.name.slice(entry.name.lastIndexOf(".") + 1).toLowerCase() : "";
+    const contentType = overrides.get(entry.name.toLowerCase()) ?? defaults.get(extension);
+    if (!contentType) {
+      throw pptxSecurity("OPC package part lacks a content type", "invalid-package", entry.name);
+    }
+    if (isActiveContentType(contentType)) {
+      throw pptxSecurity("Active OPC content type is forbidden", "active-content", entry.name);
+    }
+  }
+}
+function relationshipsFor(context, sourcePart) {
+  return relationshipsForPart(context, relationshipPartName(sourcePart));
+}
+function relationshipsForPart(context, relationshipsPart) {
+  const cached = context.relationshipsCache.get(relationshipsPart);
+  if (cached) return cached;
+  if (!context.entries.has(relationshipsPart)) {
+    if (relationshipsPart === "_rels/.rels") {
+      throw pptxSecurity(
+        "OPC root relationships are missing",
+        "invalid-package",
+        relationshipsPart
+      );
+    }
+    context.relationshipsCache.set(relationshipsPart, []);
+    return [];
+  }
+  const root = readXml(context, relationshipsPart);
+  requireRoot(root, "Relationships", RELATIONSHIPS_NAMESPACE, relationshipsPart);
+  const sourcePart = relationshipSourcePart(relationshipsPart);
+  const relationships = [];
+  const ids = /* @__PURE__ */ new Set();
+  for (const child of pptxXmlChildren(root)) {
+    if (child.localName !== "Relationship" || pptxXmlChildren(child).length > 0) {
+      throw pptxSecurity("Invalid OPC relationship element", "invalid-package", relationshipsPart);
+    }
+    if (relationships.length >= context.limits.relationshipsPerPart) {
+      throw pptxSecurity(
+        "Relationship part exceeds its relationship limit",
+        "limit-exceeded",
+        relationshipsPart
+      );
+    }
+    const id = requiredAttribute(child, "Id", relationshipsPart);
+    const type = requiredAttribute(child, "Type", relationshipsPart);
+    const target = requiredAttribute(child, "Target", relationshipsPart);
+    if (id.length > 512 || type.length > 2048 || target.length > 4096 || ids.has(id)) {
+      throw pptxSecurity(
+        "Duplicate or oversized OPC relationship",
+        "invalid-package",
+        relationshipsPart
+      );
+    }
+    ids.add(id);
+    const targetMode = pptxXmlAttribute(child, "TargetMode") ?? "Internal";
+    if (targetMode !== "Internal") {
+      throw pptxSecurity(
+        "External OPC relationships are forbidden",
+        "external-relationship",
+        relationshipsPart
+      );
+    }
+    if (/^(?:https?|ftp|file|data|javascript):/i.test(target)) {
+      throw pptxSecurity(
+        "External OPC relationship target is forbidden",
+        "external-relationship",
+        relationshipsPart
+      );
+    }
+    const partName = resolvePartTarget(sourcePart, target, relationshipsPart);
+    const relationship = { id, type, target, sourcePart, partName };
+    validateRelationshipKind(context, relationship, relationshipsPart);
+    relationships.push(relationship);
+  }
+  context.relationships += relationships.length;
+  if (context.relationships > context.limits.relationships) {
+    throw pptxSecurity(
+      "PPTX exceeds its total relationship limit",
+      "limit-exceeded",
+      relationshipsPart
+    );
+  }
+  context.relationshipsCache.set(relationshipsPart, relationships);
+  return relationships;
+}
+function validateRelationshipKind(context, relationship, relationshipsPart) {
+  const suffix = relationship.type.slice(relationship.type.lastIndexOf("/") + 1);
+  const standardOfficeRelationship = relationship.type === `${OFFICE_RELATIONSHIP_BASE}${suffix}`;
+  const standardPackageRelationship = relationship.type === `${PACKAGE_RELATIONSHIP_BASE}${suffix}`;
+  if (!standardOfficeRelationship && !standardPackageRelationship && !ALLOWED_EXACT_RELATIONSHIPS.has(relationship.type)) {
+    throw pptxSecurity(
+      `Unsupported or non-standard presentation relationship type: ${relationship.type}`,
+      "invalid-package",
+      relationshipsPart
+    );
+  }
+  if (ACTIVE_RELATIONSHIP_SUFFIX.test(suffix)) {
+    throw pptxSecurity(
+      "Active or remote presentation relationship is forbidden",
+      "active-content",
+      relationshipsPart
+    );
+  }
+  if (!KNOWN_RELATIONSHIP_SUFFIXES.has(suffix)) {
+    markSourceOnly(context, [relationshipsPart, relationship.partName]);
+  }
+  if (suffix === "package") {
+    const safeChartWorkbook = /^ppt\/charts\/chart\d+\.xml$/i.test(relationship.sourcePart) && /^ppt\/embeddings\/[^/]+\.xlsx$/i.test(relationship.partName);
+    if (!safeChartWorkbook) {
+      throw pptxSecurity(
+        "Embedded packages are forbidden outside chart data workbooks",
+        "active-content",
+        relationshipsPart
+      );
+    }
+  }
+  if (suffix === "hyperlink") {
+    context.unsupportedParts.add(relationshipsPart);
+    context.issues.push(fidelityIssue("hyperlink", [relationshipsPart]));
+  }
+  if (SOURCE_ONLY_RELATIONSHIP_SUFFIXES.has(suffix)) {
+    context.unsupportedParts.add(relationshipsPart);
+    context.issues.push(fidelityIssue("theme", [relationshipsPart, relationship.partName]));
+  }
+}
+function classifySourceOnlyParts(context) {
+  for (const entry of context.entries.values()) {
+    if (!entry.directory && !isKnownPptxPart(entry.name)) {
+      markSourceOnly(context, [entry.name, "[Content_Types].xml"]);
+    }
+  }
+}
+function markSourceOnly(context, parts) {
+  for (const part of parts) context.unsupportedParts.add(part);
+  context.issues.push(fidelityIssue("source-only", parts));
+}
+function isKnownPptxPart(name) {
+  return KNOWN_PPTX_PART_PATTERNS.some((pattern) => pattern.test(name));
+}
+function isActiveContentType(contentType) {
+  return /(?:macroEnabled|vbaProject|activeX|oleObject|javascript|ecmascript|x-msdownload|executable|powershell|shellscript|text\/html)/i.test(
+    contentType
+  );
+}
+function validateRelationshipTargets(context) {
+  for (const relationships of context.relationshipsCache.values()) {
+    for (const relationship of relationships) {
+      const suffix = relationship.type.slice(relationship.type.lastIndexOf("/") + 1);
+      if (suffix === "hyperlink") continue;
+      if (!context.entries.has(relationship.partName)) {
+        throw pptxSecurity(
+          "OPC relationship targets a missing package part",
+          "invalid-package",
+          relationship.partName
+        );
+      }
+    }
+  }
+}
+async function preflightEmbeddedXlsx(context, entry, bytes) {
+  if (entry.expandedSize > context.limits.nestedPackageBytes) {
+    throw pptxSecurity(
+      "Embedded chart workbook exceeds its byte limit",
+      "limit-exceeded",
+      entry.name
+    );
+  }
+  const nested = parseBoundedZip(
+    bytes,
+    {
+      entries: Math.min(context.limits.entries, 1e4),
+      compressedEntryBytes: context.limits.nestedPackageBytes,
+      expandedEntryBytes: context.limits.nestedPackageBytes,
+      expandedBytes: context.limits.nestedPackageBytes,
+      compressionRatio: context.limits.compressionRatio,
+      compressionRatioThreshold: 1048576
+    },
+    pptxZipFailure
+  );
+  context.nestedEntries += nested.length;
+  context.nestedExpandedBytes += nested.reduce((sum, part) => sum + part.expandedSize, 0);
+  if (context.nestedEntries > context.limits.nestedEntries || context.nestedExpandedBytes > context.limits.nestedExpandedBytes) {
+    throw pptxSecurity(
+      "Embedded chart workbooks exceed the global nested archive budget",
+      "limit-exceeded",
+      entry.name
+    );
+  }
+  for (const nestedEntry of nested) {
+    rejectNestedWorkbookEntry(nestedEntry.name, entry.name);
+    if (nestedEntry.directory) continue;
+    if (isXmlPart(nestedEntry.name)) {
+      const xmlBytes = await inflateBoundedZipEntry(
+        bytes,
+        nestedEntry,
+        context.limits.nestedPackageBytes,
+        pptxZipFailure
+      );
+      const root = parsePptxXmlPart(
+        xmlBytes,
+        `${entry.name}!/${nestedEntry.name}`,
+        context.xmlBudget
+      );
+      if (nestedEntry.name.endsWith(".rels")) {
+        for (const relationship of pptxXmlChildren(root)) {
+          if (relationship.localName !== "Relationship") {
+            throw pptxSecurity(
+              "Embedded workbook relationship XML is invalid",
+              "invalid-package",
+              entry.name
+            );
+          }
+          const targetMode = pptxXmlAttribute(relationship, "TargetMode") ?? "Internal";
+          const target = requiredAttribute(
+            relationship,
+            "Target",
+            `${entry.name}!/${nestedEntry.name}`
+          );
+          if (targetMode !== "Internal" || /^(?:https?|ftp|file|data|javascript):/i.test(target) || target.includes("\\") || /%(?:2e|2f|5c)/i.test(target)) {
+            throw pptxSecurity(
+              "Embedded chart workbook contains an external relationship",
+              "external-relationship",
+              entry.name
+            );
+          }
+        }
+      }
+      if (pptxXmlDescendants(root, "f").length > 0) {
+        throw pptxSecurity(
+          "Formula-bearing embedded chart workbooks are not retained",
+          "active-content",
+          entry.name
+        );
+      }
+    } else {
+      await verifyBoundedZipEntry(
+        bytes,
+        nestedEntry,
+        context.limits.nestedPackageBytes,
+        pptxZipFailure
+      );
+    }
+  }
+}
+function rejectNestedWorkbookEntry(name, container) {
+  if (/(?:^|\/)(?:vbaProject|vbaData)\.bin$/i.test(name) || /(?:^|\/)(?:activeX|embeddings|externalLinks|connections|queryTables|webextensions)(?:\/|$)/i.test(
+    name
+  ) || /\.(?:exe|dll|com|msi|js|vbs|bat|cmd|ps1|sh|scr|jar)$/i.test(name)) {
+    throw pptxSecurity(
+      `Embedded chart workbook contains active content: ${name}`,
+      "active-content",
+      container
+    );
+  }
+}
+function rejectActiveEntry(name, directory = false) {
+  const safeChartWorkbook = /^ppt\/embeddings\/[^/]+\.xlsx$/i.test(name);
+  if (/(?:^|\/)(?:vbaProject|vbaData)\.bin$/i.test(name) || /(?:^|\/)(?:activeX|oleObject|externalLinks|connections|webextensions)(?:\/|$)/i.test(name) || /^ppt\/(?:audio|video)\//i.test(name) || /^ppt\/embeddings\//i.test(name) && !directory && !safeChartWorkbook || !directory && /\.(?:zip|docx|dotx|xlsx|xltx|pptx|ppsx)$/i.test(name) && !safeChartWorkbook || /\.(?:exe|dll|com|msi|js|vbs|vbe|bat|cmd|ps1|sh|scr|jar|ppam|pptm|svg|svgz|html?|mhtml)$/i.test(
+    name
+  )) {
+    throw pptxSecurity("Active presentation content is forbidden", "active-content", name);
+  }
+}
+function isRasterMediaPart(name) {
+  return /^ppt\/media\/[^/]+\.(?:png|jpe?g|gif|webp)$/i.test(name);
+}
+function reserveRetained(context, bytes, partName) {
+  context.retainedBytes += bytes;
+  if (context.retainedBytes > context.limits.retainedBytes) {
+    throw pptxSecurity("PPTX exceeds its retained-memory budget", "limit-exceeded", partName);
+  }
+}
+function importMastersAndLayouts(context, presentation, presentationRoot, presentationRelationships, masterByPart, layoutByPart) {
+  const masterIds = pptxXmlChildren(pptxXmlChild(presentationRoot, "sldMasterIdLst"));
+  for (const masterId of masterIds) {
+    const relationshipId = requiredRelationshipId(masterId, "ppt/presentation.xml");
+    const relationship = presentationRelationships.get(relationshipId);
+    if (!relationship || relationship.type !== `${OFFICE_RELATIONSHIP_BASE}slideMaster`) {
+      throw pptxSecurity(
+        "Slide master id references the wrong relationship",
+        "invalid-package",
+        "ppt/presentation.xml"
+      );
+    }
+    const masterRoot = readXml(context, relationship.partName);
+    requireRoot(masterRoot, "sldMaster", PRESENTATION_NAMESPACE, relationship.partName);
+    const common = requiredChild(masterRoot, "cSld", relationship.partName);
+    const masterRelationships = byRelationshipId(relationshipsFor(context, relationship.partName));
+    const elements = parseTemplateTree(
+      context,
+      requiredChild(common, "spTree", relationship.partName),
+      masterRelationships,
+      relationship.partName
+    );
+    const master = presentation.masters.add({
+      name: pptxXmlAttribute(common, "name") ?? `Master ${presentation.masters.items.length + 1}`,
+      background: parseBackground(context, common),
+      elements
+    });
+    masterByPart.set(relationship.partName, master);
+    for (const layoutId of pptxXmlChildren(pptxXmlChild(masterRoot, "sldLayoutIdLst"))) {
+      const layoutRelationshipId = requiredRelationshipId(layoutId, relationship.partName);
+      const layoutRelationship = masterRelationships.get(layoutRelationshipId);
+      if (!layoutRelationship || layoutRelationship.type !== `${OFFICE_RELATIONSHIP_BASE}slideLayout`) {
+        throw pptxSecurity(
+          "Slide layout id references the wrong relationship",
+          "invalid-package",
+          relationship.partName
+        );
+      }
+      if (layoutByPart.has(layoutRelationship.partName)) continue;
+      const layoutRoot = readXml(context, layoutRelationship.partName);
+      requireRoot(layoutRoot, "sldLayout", PRESENTATION_NAMESPACE, layoutRelationship.partName);
+      const layoutCommon = requiredChild(layoutRoot, "cSld", layoutRelationship.partName);
+      const layoutRelationships = byRelationshipId(
+        relationshipsFor(context, layoutRelationship.partName)
+      );
+      const parent = [...layoutRelationships.values()].find(
+        (candidate) => candidate.type === `${OFFICE_RELATIONSHIP_BASE}slideMaster`
+      );
+      if (!parent || parent.partName !== relationship.partName) {
+        throw pptxSecurity(
+          "Slide layout does not link back to its master",
+          "invalid-package",
+          layoutRelationship.partName
+        );
+      }
+      const layout = presentation.layouts.add({
+        name: pptxXmlAttribute(layoutCommon, "name") ?? `Layout ${presentation.layouts.items.length + 1}`,
+        masterId: master.id,
+        background: parseBackground(context, layoutCommon),
+        elements: parseTemplateTree(
+          context,
+          requiredChild(layoutCommon, "spTree", layoutRelationship.partName),
+          layoutRelationships,
+          layoutRelationship.partName
+        )
+      });
+      layoutByPart.set(layoutRelationship.partName, layout);
+    }
+  }
+}
+function importSlides(context, presentation, presentationRoot, presentationRelationships, layoutByPart) {
+  const slideIds = pptxXmlChildren(pptxXmlChild(presentationRoot, "sldIdLst"));
+  if (slideIds.length > context.limits.slides) {
+    throw pptxSecurity("PPTX exceeds its slide limit", "limit-exceeded", "ppt/presentation.xml");
+  }
+  const seenParts = /* @__PURE__ */ new Set();
+  for (const slideId of slideIds) {
+    const relationshipId = requiredRelationshipId(slideId, "ppt/presentation.xml");
+    const relationship = presentationRelationships.get(relationshipId);
+    if (!relationship || relationship.type !== `${OFFICE_RELATIONSHIP_BASE}slide` || seenParts.has(relationship.partName)) {
+      throw pptxSecurity(
+        "Slide id references an invalid or duplicate slide",
+        "invalid-package",
+        "ppt/presentation.xml"
+      );
+    }
+    seenParts.add(relationship.partName);
+    const root = readXml(context, relationship.partName);
+    requireRoot(root, "sld", PRESENTATION_NAMESPACE, relationship.partName);
+    const common = requiredChild(root, "cSld", relationship.partName);
+    const relationships = relationshipsFor(context, relationship.partName);
+    const relationshipById = byRelationshipId(relationships);
+    const slide = presentation.slides.add();
+    slide.title = pptxXmlAttribute(common, "name") ?? "";
+    slide.background.fill = parseBackground(context, common);
+    const layoutRelationship = relationships.find(
+      (candidate) => candidate.type === `${OFFICE_RELATIONSHIP_BASE}slideLayout`
+    );
+    if (!layoutRelationship) {
+      throw pptxSecurity(
+        "Slide lacks a slide-layout relationship",
+        "invalid-package",
+        relationship.partName
+      );
+    }
+    const layout = layoutByPart.get(layoutRelationship.partName);
+    if (!layout) {
+      throw pptxSecurity(
+        "Slide references an unknown slide layout",
+        "invalid-package",
+        relationship.partName
+      );
+    }
+    slide.setLayout(layout);
+    const parsed = parseSceneTree(
+      context,
+      requiredChild(common, "spTree", relationship.partName),
+      relationshipById,
+      relationship.partName
+    );
+    let derivedTitle;
+    for (const element of parsed) {
+      switch (element.kind) {
+        case "shape": {
+          const shape = slide.shapes.add(element.config);
+          if (!derivedTitle && (shape.placeholder?.type === "title" || shape.placeholder?.type === "ctrTitle") && shape.text.toString().length > 0)
+            derivedTitle = shape.text.toString();
+          break;
+        }
+        case "chart":
+          slide.charts.add(element.type, element.config ?? {});
+          break;
+        case "image":
+          slide.images.add(element.config);
+          break;
+        case "table":
+          slide.tables.add(element.config);
+          break;
+        case "group":
+          slide.groups.add(element.config);
+          break;
+      }
+    }
+    if (derivedTitle) slide.title = derivedTitle;
+    const notesRelationship = relationships.find(
+      (candidate) => candidate.type === `${OFFICE_RELATIONSHIP_BASE}notesSlide`
+    );
+    if (notesRelationship) slide.notes.set(parseNotes(context, notesRelationship.partName));
+    if (pptxXmlChild(root, "transition"))
+      addUnsupported(context, "transition", relationship.partName);
+    if (pptxXmlChild(root, "timing")) addUnsupported(context, "animation", relationship.partName);
+  }
+}
+function parseTemplateTree(context, tree, relationships, partName) {
+  const output = [];
+  for (const element of parseSceneTree(context, tree, relationships, partName)) {
+    if (element.kind === "group") {
+      addUnsupported(context, "group", partName);
+    } else output.push(element);
+  }
+  return output;
+}
+function parseSceneTree(context, tree, relationships, partName, transform = IDENTITY_TRANSFORM, depth = 0) {
+  if (depth > 32)
+    throw pptxSecurity("Presentation group nesting exceeds its limit", "limit-exceeded", partName);
+  const output = [];
+  for (const element of pptxXmlChildren(tree)) {
+    if (element.localName === "nvGrpSpPr" || element.localName === "grpSpPr") continue;
+    consumeElement(context, partName);
+    switch (element.localName) {
+      case "sp":
+      case "cxnSp":
+        if (element.localName === "cxnSp") {
+          addUnsupported(context, "connector", partName, "style-approximated");
+        }
+        output.push({ kind: "shape", config: parseShape(context, element, partName, transform) });
+        break;
+      case "pic":
+        {
+          const image = parseImage(context, element, relationships, partName, transform);
+          if (image) output.push({ kind: "image", config: image });
+        }
+        break;
+      case "graphicFrame": {
+        const graphicData = pptxXmlDescendants(element, "graphicData")[0];
+        const uri = pptxXmlAttribute(graphicData, "uri");
+        if (uri === TABLE_GRAPHIC_URI) {
+          output.push({ kind: "table", config: parseTable(context, element, partName, transform) });
+        } else if (uri === CHART_GRAPHIC_URI) {
+          const chartRef = pptxXmlDescendants(graphicData, "chart")[0];
+          const relationshipId = requiredRelationshipId(chartRef, partName);
+          const relationship = relationships.get(relationshipId);
+          if (!relationship || relationship.type !== `${OFFICE_RELATIONSHIP_BASE}chart`) {
+            throw pptxSecurity(
+              "Chart frame references the wrong relationship",
+              "invalid-package",
+              partName
+            );
+          }
+          const parsed = parseChart(context, relationship.partName);
+          if (parsed) {
+            const frameName = nonVisualName(element);
+            if (frameName) parsed.config.name = frameName;
+            parsed.config.position = parseFramePosition(element, partName, transform);
+            output.push({ kind: "chart", ...parsed });
+          }
+        } else {
+          addUnsupported(context, "smart-art", partName);
+        }
+        break;
+      }
+      case "grpSp": {
+        const group = parseGroup(context, element, relationships, partName, transform, depth + 1);
+        output.push({ kind: "group", config: group });
+        break;
+      }
+      case "contentPart":
+      case "alternateContent":
+      case "extLst":
+        addUnsupported(context, "custom-geometry", partName);
+        break;
+      default:
+        addUnsupported(context, "custom-geometry", partName);
+    }
+  }
+  return output;
+}
+function parseGroup(context, group, relationships, partName, parentTransform, depth) {
+  const properties = requiredChild(group, "grpSpPr", partName);
+  const xfrm = requiredChild(properties, "xfrm", partName);
+  const rawPosition = rawPositionFromXfrm(xfrm, partName);
+  const childOffsetElement = requiredChild(xfrm, "chOff", partName);
+  const childExtentElement = requiredChild(xfrm, "chExt", partName);
+  const childOffset = {
+    left: emuNumber(requiredAttribute(childOffsetElement, "x", partName), partName),
+    top: emuNumber(requiredAttribute(childOffsetElement, "y", partName), partName)
+  };
+  const childExtent = {
+    width: positiveEmu(requiredAttribute(childExtentElement, "cx", partName), partName),
+    height: positiveEmu(requiredAttribute(childExtentElement, "cy", partName), partName)
+  };
+  const position = applyTransform(rawPosition, parentTransform);
+  const name = nonVisualName(group) ?? `Group ${context.elements}`;
+  return {
+    name,
+    position,
+    childOffset,
+    childExtent,
+    rotation: rotationFromXfrm(xfrm, partName),
+    flipHorizontal: booleanAttribute(xfrm, "flipH"),
+    flipVertical: booleanAttribute(xfrm, "flipV"),
+    children: parseSceneTree(context, group, relationships, partName, IDENTITY_TRANSFORM, depth)
+  };
+}
+function parseShape(context, element, partName, transform) {
+  const properties = pptxXmlChild(element, "spPr");
+  const xfrm = pptxXmlChild(properties, "xfrm");
+  const position = xfrm ? applyTransform(rawPositionFromXfrm(xfrm, partName), transform) : applyTransform({ left: 0, top: 0, width: 1, height: 1 }, transform);
+  const preset = pptxXmlAttribute(pptxXmlChild(properties, "prstGeom"), "prst") ?? (element.localName === "cxnSp" ? "line" : "rect");
+  const geometry = mapGeometry(context, preset, partName);
+  const text = parseTextBody(context, pptxXmlChild(element, "txBody"), partName);
+  const placeholderElement = pptxXmlDescendants(
+    pptxXmlChild(element, element.localName === "cxnSp" ? "nvCxnSpPr" : "nvSpPr"),
+    "ph"
+  )[0];
+  const placeholderType = pptxXmlAttribute(placeholderElement, "type");
+  const placeholderIndex = optionalInteger(pptxXmlAttribute(placeholderElement, "idx"), partName);
+  return {
+    geometry,
+    name: nonVisualName(element) ?? `Shape ${context.elements}`,
+    position,
+    fill: parseFill(context, properties, "white") ?? "white",
+    line: parseLine(context, pptxXmlChild(properties, "ln"), partName),
+    text: text.value,
+    textStyle: text.style,
+    rotation: xfrm ? rotationFromXfrm(xfrm, partName) : 0,
+    ...placeholderType ? {
+      placeholder: {
+        type: placeholderType,
+        ...placeholderIndex === void 0 ? {} : { index: placeholderIndex }
+      }
+    } : {}
+  };
+}
+function parseImage(context, element, relationships, partName, transform) {
+  const blip = pptxXmlDescendants(element, "blip")[0];
+  const relationshipId = requiredRelationshipId(blip, partName, "embed");
+  const relationship = relationships.get(relationshipId);
+  if (!relationship || relationship.type !== `${OFFICE_RELATIONSHIP_BASE}image`) {
+    throw pptxSecurity("Picture references the wrong relationship", "invalid-package", partName);
+  }
+  if (!isRasterMediaPart(relationship.partName)) {
+    addUnsupported(context, "media", relationship.partName);
+    return void 0;
+  }
+  const bytes = readPartBytes(context, relationship.partName);
+  context.imageBytes += bytes.byteLength;
+  if (context.imageBytes > context.limits.imageBytes) {
+    throw pptxSecurity(
+      "PPTX exceeds its decoded image byte limit",
+      "limit-exceeded",
+      relationship.partName
+    );
+  }
+  const properties = requiredChild(element, "spPr", partName);
+  const xfrm = requiredChild(properties, "xfrm", partName);
+  const cropElement = pptxXmlDescendants(pptxXmlChild(element, "blipFill"), "srcRect")[0];
+  const crop = cropElement ? {
+    left: cropPercent(pptxXmlAttribute(cropElement, "l"), partName),
+    top: cropPercent(pptxXmlAttribute(cropElement, "t"), partName),
+    right: cropPercent(pptxXmlAttribute(cropElement, "r"), partName),
+    bottom: cropPercent(pptxXmlAttribute(cropElement, "b"), partName)
+  } : void 0;
+  const geometry = mapImageGeometry(
+    pptxXmlAttribute(pptxXmlChild(properties, "prstGeom"), "prst") ?? "rect"
+  );
+  const name = nonVisualName(element) ?? `Image ${context.elements}`;
+  const description = nonVisualDescription(element) ?? "";
+  const imageConfig = {
+    blob: bytes.slice(),
+    contentType: rasterContentType(relationship.partName),
+    name,
+    alt: description,
+    position: applyTransform(rawPositionFromXfrm(xfrm, partName), transform),
+    fit: crop ? "cover" : "contain",
+    geometry,
+    rotation: rotationFromXfrm(xfrm, partName),
+    flipHorizontal: booleanAttribute(xfrm, "flipH"),
+    flipVertical: booleanAttribute(xfrm, "flipV"),
+    lockAspectRatio: booleanAttribute(pptxXmlDescendants(element, "picLocks")[0], "noChangeAspect"),
+    ...crop ? { crop } : {}
+  };
+  return imageConfig;
+}
+function parseTable(context, frame, partName, transform) {
+  const table = pptxXmlDescendants(frame, "tbl")[0];
+  if (!table) throw pptxSecurity("Table frame lacks table data", "invalid-package", partName);
+  const grid = requiredChild(table, "tblGrid", partName);
+  const columnWidths = pptxXmlChildren(grid).map(
+    (column) => positiveEmu(requiredAttribute(column, "w", partName), partName)
+  );
+  if (columnWidths.length === 0) {
+    throw pptxSecurity("Presentation table has no columns", "invalid-package", partName);
+  }
+  const rowElements = pptxXmlChildren(table).filter((child) => child.localName === "tr");
+  const rows = [];
+  const rowHeights = [];
+  const occupied = Array.from(
+    { length: rowElements.length },
+    () => new Uint8Array(columnWidths.length)
+  );
+  for (const [rowIndex, rowElement] of rowElements.entries()) {
+    rowHeights.push(positiveEmu(requiredAttribute(rowElement, "h", partName), partName));
+    const row = Array.from(
+      { length: columnWidths.length },
+      () => null
+    );
+    let column = 0;
+    for (const cellElement of pptxXmlChildren(rowElement).filter(
+      (child) => child.localName === "tc"
+    )) {
+      if (column >= columnWidths.length) {
+        throw pptxSecurity("Presentation table row exceeds its grid", "invalid-package", partName);
+      }
+      const properties = pptxXmlChild(cellElement, "tcPr");
+      const horizontalMerge = booleanAttribute(cellElement, "hMerge") || booleanAttribute(properties, "hMerge");
+      const verticalMerge = booleanAttribute(cellElement, "vMerge") || booleanAttribute(properties, "vMerge");
+      if (horizontalMerge || verticalMerge) {
+        if (occupied[rowIndex][column] === 0) {
+          throw pptxSecurity(
+            "Presentation table merge continuation has no spanning anchor",
+            "invalid-package",
+            partName
+          );
+        }
+        column += 1;
+        continue;
+      }
+      if (occupied[rowIndex][column] !== 0) {
+        throw pptxSecurity("Presentation table spans overlap", "invalid-package", partName);
+      }
+      const colSpan = optionalPositiveInteger(
+        pptxXmlAttribute(cellElement, "gridSpan") ?? pptxXmlAttribute(properties, "gridSpan"),
+        partName
+      ) ?? 1;
+      const rowSpan = optionalPositiveInteger(
+        pptxXmlAttribute(cellElement, "rowSpan") ?? pptxXmlAttribute(properties, "rowSpan"),
+        partName
+      ) ?? 1;
+      if (column + colSpan > columnWidths.length || rowIndex + rowSpan > rowElements.length) {
+        throw pptxSecurity(
+          "Presentation table cell span exceeds its grid",
+          "invalid-package",
+          partName
+        );
+      }
+      const text = parseTextBody(context, pptxXmlChild(cellElement, "txBody"), partName);
+      row[column] = {
+        text: text.value,
+        textStyle: text.style,
+        fill: parseFill(context, properties, "white") ?? "white",
+        colSpan,
+        rowSpan
+      };
+      for (let occupiedRow = rowIndex; occupiedRow < rowIndex + rowSpan; occupiedRow += 1) {
+        for (let occupiedColumn = column; occupiedColumn < column + colSpan; occupiedColumn += 1) {
+          if (occupiedRow === rowIndex && occupiedColumn === column) continue;
+          if (occupied[occupiedRow][occupiedColumn] !== 0) {
+            throw pptxSecurity("Presentation table spans overlap", "invalid-package", partName);
+          }
+          occupied[occupiedRow][occupiedColumn] = 1;
+        }
+      }
+      column += 1;
+    }
+    if (column !== columnWidths.length) {
+      throw pptxSecurity(
+        "Presentation table row does not cover its grid",
+        "invalid-package",
+        partName
+      );
+    }
+    rows.push(row);
+  }
+  for (let row = 0; row < rows.length; row += 1) {
+    for (let column = 0; column < columnWidths.length; column += 1) {
+      if (rows[row][column] === null && occupied[row][column] === 0) {
+        throw pptxSecurity(
+          "Presentation table has an uncovered grid slot",
+          "invalid-package",
+          partName
+        );
+      }
+    }
+  }
+  if (pptxXmlChild(table, "tblPr")) {
+    const styleId = pptxXmlText(pptxXmlChild(pptxXmlChild(table, "tblPr"), "tableStyleId"));
+    if (styleId) addUnsupported(context, "table-style", partName);
+  }
+  return {
+    name: nonVisualName(frame) ?? `Table ${context.elements}`,
+    position: parseFramePosition(frame, partName, transform),
+    rows,
+    columnWidths,
+    rowHeights
+  };
+}
+function parseChart(context, partName) {
+  const root = readXml(context, partName);
+  requireRoot(root, "chartSpace", CHART_NAMESPACE, partName);
+  const chart = requiredChild(root, "chart", partName);
+  const plot = requiredChild(chart, "plotArea", partName);
+  const chartElement = pptxXmlChildren(plot).find(
+    (candidate) => CHART_ELEMENT_TYPES.has(candidate.localName)
+  );
+  if (!chartElement) {
+    addUnsupported(context, "unsupported-chart", partName);
+    return void 0;
+  }
+  const type = CHART_ELEMENT_TYPES.get(chartElement.localName);
+  if (chartElement.localName.includes("3D")) {
+    addUnsupported(context, "unsupported-chart", partName, "style-approximated");
+  }
+  const series = [];
+  for (const seriesElement of pptxXmlChildren(chartElement).filter(
+    (candidate) => candidate.localName === "ser"
+  )) {
+    const name = parseChartString(pptxXmlChild(seriesElement, "tx")) || `Series ${series.length + 1}`;
+    const categories2 = parseChartCategories(pptxXmlChild(seriesElement, "cat"));
+    const values = parseChartNumbers(
+      pptxXmlChild(seriesElement, type === "scatter" || type === "bubble" ? "yVal" : "val"),
+      context,
+      partName
+    );
+    const xValues = parseChartNumbers(pptxXmlChild(seriesElement, "xVal"), context, partName);
+    const bubbleSizes = parseChartNumbers(
+      pptxXmlChild(seriesElement, "bubbleSize"),
+      context,
+      partName
+    );
+    const fill = parseFill(context, pptxXmlChild(seriesElement, "spPr"), void 0);
+    series.push({
+      name,
+      categories: categories2,
+      values,
+      ...xValues.length > 0 ? { xValues } : {},
+      ...bubbleSizes.length > 0 ? { bubbleSizes } : {},
+      ...fill ? { fill } : {}
+    });
+  }
+  const categories = series.find((candidate) => (candidate.categories?.length ?? 0) > 0)?.categories ?? [];
+  const legend = pptxXmlChild(chart, "legend");
+  const labels = pptxXmlChild(chartElement, "dLbls");
+  const axes = pptxXmlChildren(plot).filter((candidate) => candidate.localName.endsWith("Ax"));
+  const categoryAxis = axes.find(
+    (axis) => axis.localName === "catAx" || axis.localName === "dateAx"
+  );
+  const valueAxis = axes.find((axis) => axis.localName === "valAx");
+  return {
+    type,
+    config: {
+      name: `Chart ${context.elements}`,
+      title: parseChartString(pptxXmlChild(chart, "title")),
+      categories,
+      series,
+      hasLegend: Boolean(legend) && !booleanAttribute(pptxXmlChild(legend, "delete"), "val"),
+      ...legend ? {
+        legend: {
+          position: chartLegendPosition(
+            pptxXmlAttribute(pptxXmlChild(legend, "legendPos"), "val")
+          )
+        }
+      } : {},
+      ...parseChartAxis(categoryAxis) ? { xAxis: parseChartAxis(categoryAxis) } : {},
+      ...parseChartAxis(valueAxis) ? { yAxis: parseChartAxis(valueAxis) } : {},
+      dataLabels: {
+        showValue: booleanAttribute(pptxXmlChild(labels, "showVal"), "val"),
+        showSeriesName: booleanAttribute(pptxXmlChild(labels, "showSerName"), "val"),
+        showCategoryName: booleanAttribute(pptxXmlChild(labels, "showCatName"), "val"),
+        showPercent: booleanAttribute(pptxXmlChild(labels, "showPercent"), "val")
+      }
+    }
+  };
+}
+function parseNotes(context, partName) {
+  const root = readXml(context, partName);
+  requireRoot(root, "notes", PRESENTATION_NAMESPACE, partName);
+  const common = requiredChild(root, "cSld", partName);
+  const tree = requiredChild(common, "spTree", partName);
+  const paragraphs = [];
+  for (const shape of pptxXmlChildren(tree).filter((child) => child.localName === "sp")) {
+    const placeholder = pptxXmlDescendants(shape, "ph")[0];
+    const type = pptxXmlAttribute(placeholder, "type");
+    if (type !== "body") continue;
+    const text = parseTextBody(context, pptxXmlChild(shape, "txBody"), partName).value;
+    if (text.length > 0) paragraphs.push(text);
+  }
+  return paragraphs.join("\n");
+}
+function parseTextBody(context, body, partName) {
+  if (!body) return { value: "", style: {} };
+  const paragraphs = [];
+  const styles = [];
+  let paragraphAlignment;
+  for (const paragraph of pptxXmlChildren(body).filter((child) => child.localName === "p")) {
+    const parts = [];
+    const paragraphProperties = pptxXmlChild(paragraph, "pPr");
+    const alignment = mapTextAlignment(pptxXmlAttribute(paragraphProperties, "algn"));
+    if (alignment && !paragraphAlignment) paragraphAlignment = alignment;
+    for (const child of pptxXmlChildren(paragraph)) {
+      if (child.localName === "r" || child.localName === "fld") {
+        const text = pptxXmlDirectText(pptxXmlChild(child, "t"));
+        consumeText(context, text.length, partName);
+        parts.push(text);
+        const properties = pptxXmlChild(child, "rPr");
+        if (properties) styles.push(parseTextStyle(context, properties, body));
+      } else if (child.localName === "br") parts.push("\n");
+    }
+    paragraphs.push(parts.join(""));
+  }
+  const value = paragraphs.join("\n");
+  const firstStyle = styles[0] ?? {};
+  if (styles.some((style) => JSON.stringify(style) !== JSON.stringify(firstStyle))) {
+    addUnsupported(context, "theme", partName, "style-approximated");
+  }
+  const verticalAlignment = mapVerticalAlignment(
+    pptxXmlAttribute(pptxXmlChild(body, "bodyPr"), "anchor")
+  );
+  return {
+    value,
+    style: {
+      ...firstStyle,
+      ...paragraphAlignment ? { alignment: paragraphAlignment } : {},
+      ...verticalAlignment ? { verticalAlignment } : {}
+    }
+  };
+}
+function parseTextStyle(context, properties, body) {
+  const size = optionalNumber(pptxXmlAttribute(properties, "sz"));
+  const font = pptxXmlAttribute(pptxXmlChild(properties, "latin"), "typeface");
+  const fill = parseFill(context, properties, void 0);
+  const underline = pptxXmlAttribute(properties, "u");
+  const verticalAlignment = mapVerticalAlignment(
+    pptxXmlAttribute(pptxXmlChild(body, "bodyPr"), "anchor")
+  );
+  return {
+    ...font && !font.startsWith("+") ? { fontFamily: font } : {},
+    ...size !== void 0 ? { fontSize: size / 75 } : {},
+    bold: booleanAttribute(properties, "b"),
+    italic: booleanAttribute(properties, "i"),
+    underline: underline !== void 0 && underline !== "none",
+    ...fill && fill !== "none" ? { color: typeof fill === "string" ? fill : fill.color } : {},
+    ...verticalAlignment ? { verticalAlignment } : {}
+  };
+}
+function parseBackground(context, common) {
+  const background = pptxXmlChild(common, "bg");
+  if (!background) return "white";
+  const properties = pptxXmlChild(background, "bgPr");
+  if (properties) return parseFill(context, properties, "white") ?? "white";
+  const reference = pptxXmlChild(background, "bgRef");
+  const scheme = pptxXmlAttribute(pptxXmlChild(reference, "schemeClr"), "val");
+  return scheme ? context.themeColors.get(scheme) ?? "white" : "white";
+}
+function parseFill(context, parent, fallback) {
+  if (!parent) return fallback;
+  if (pptxXmlChild(parent, "noFill")) return "none";
+  const solid = pptxXmlChild(parent, "solidFill");
+  if (!solid) return fallback;
+  const srgb = pptxXmlChild(solid, "srgbClr");
+  const scheme = pptxXmlChild(solid, "schemeClr");
+  const system = pptxXmlChild(solid, "sysClr");
+  const alpha = optionalNumber(
+    pptxXmlAttribute(pptxXmlChild(srgb ?? scheme ?? system, "alpha"), "val")
+  );
+  if (alpha === 0) return "none";
+  const srgbValue = pptxXmlAttribute(srgb, "val");
+  if (srgbValue && /^[0-9A-Fa-f]{6}$/.test(srgbValue)) return `#${srgbValue.toLowerCase()}`;
+  const schemeValue = pptxXmlAttribute(scheme, "val");
+  if (schemeValue) return context.themeColors.get(schemeValue) ?? fallback ?? "#000000";
+  const systemValue = pptxXmlAttribute(system, "lastClr");
+  if (systemValue && /^[0-9A-Fa-f]{6}$/.test(systemValue)) return `#${systemValue.toLowerCase()}`;
+  return fallback;
+}
+function parseLine(context, line, partName) {
+  if (!line) return { style: "none", fill: "none", width: 0 };
+  const width = optionalNumber(pptxXmlAttribute(line, "w"));
+  const dash = pptxXmlAttribute(pptxXmlChild(line, "prstDash"), "val");
+  const style = dash === "dot" || dash === "sysDot" ? "dot" : dash && dash !== "solid" ? "dash" : "solid";
+  if (dash && !["solid", "dot", "sysDot", "dash", "sysDash", "lgDash"].includes(dash)) {
+    addUnsupported(context, "theme", partName, "style-approximated");
+  }
+  const fill = parseFill(context, line, "#000000") ?? "#000000";
+  return fill === "none" ? { style: "none", fill: "none", width: 0 } : { style, fill, width: width === void 0 ? 1 : width / EMU_PER_PIXEL };
+}
+function parseFramePosition(frame, partName, transform) {
+  const xfrm = requiredChild(frame, "xfrm", partName);
+  return applyTransform(rawPositionFromXfrm(xfrm, partName), transform);
+}
+function rawPositionFromXfrm(xfrm, partName) {
+  const offset = requiredChild(xfrm, "off", partName);
+  const extent = requiredChild(xfrm, "ext", partName);
+  return {
+    left: emuNumber(requiredAttribute(offset, "x", partName), partName),
+    top: emuNumber(requiredAttribute(offset, "y", partName), partName),
+    width: positiveEmu(requiredAttribute(extent, "cx", partName), partName),
+    height: positiveEmu(requiredAttribute(extent, "cy", partName), partName)
+  };
+}
+function applyTransform(position, transform) {
+  return {
+    left: transform.offsetX + position.left * transform.scaleX,
+    top: transform.offsetY + position.top * transform.scaleY,
+    width: position.width * transform.scaleX,
+    height: position.height * transform.scaleY
+  };
+}
+function rotationFromXfrm(xfrm, partName) {
+  const raw = pptxXmlAttribute(xfrm, "rot");
+  if (raw === void 0) return 0;
+  const value = Number(raw);
+  if (!Number.isSafeInteger(value) || Math.abs(value) > 216e5) {
+    throw pptxSecurity("Shape rotation is invalid", "invalid-package", partName);
+  }
+  return value / 6e4;
+}
+function mapGeometry(context, preset, partName) {
+  const mapped = GEOMETRY_MAP.get(preset);
+  if (mapped) return mapped;
+  addUnsupported(context, "custom-geometry", partName);
+  return "rect";
+}
+function mapImageGeometry(value) {
+  return value === "ellipse" ? "ellipse" : value === "roundRect" ? "roundRect" : "rect";
+}
+function parseChartString(element) {
+  if (!element) return "";
+  const points = pptxXmlDescendants(element, "pt").map((point) => ({
+    index: optionalInteger(pptxXmlAttribute(point, "idx"), "chart") ?? 0,
+    value: pptxXmlText(pptxXmlChild(point, "v"))
+  })).sort((left, right) => left.index - right.index);
+  if (points.length > 0) return points.map((point) => point.value).join("");
+  return pptxXmlDescendants(element, "t").map(pptxXmlText).join("");
+}
+function parseChartCategories(element) {
+  if (!element) return [];
+  return pptxXmlDescendants(element, "pt").map((point) => ({
+    index: optionalInteger(pptxXmlAttribute(point, "idx"), "chart") ?? 0,
+    value: pptxXmlText(pptxXmlChild(point, "v"))
+  })).sort((left, right) => left.index - right.index).map((point) => point.value);
+}
+function parseChartNumbers(element, context, partName) {
+  if (!element) return [];
+  const points = pptxXmlDescendants(element, "pt").map((point) => {
+    const index = optionalInteger(pptxXmlAttribute(point, "idx"), partName) ?? 0;
+    const raw = pptxXmlText(pptxXmlChild(point, "v"));
+    const value = Number(raw);
+    if (!Number.isFinite(value)) {
+      throw pptxSecurity("Chart cache contains a non-finite number", "invalid-package", partName);
+    }
+    return { index, value };
+  }).sort((left, right) => left.index - right.index);
+  context.chartPoints += points.length;
+  if (context.chartPoints > context.limits.chartPoints) {
+    throw pptxSecurity("PPTX exceeds its chart point limit", "limit-exceeded", partName);
+  }
+  return points.map((point) => point.value);
+}
+function parseChartAxis(axis) {
+  if (!axis) return void 0;
+  const scaling = pptxXmlChild(axis, "scaling");
+  const minimum = optionalNumber(pptxXmlAttribute(pptxXmlChild(scaling, "min"), "val"));
+  const maximum = optionalNumber(pptxXmlAttribute(pptxXmlChild(scaling, "max"), "val"));
+  return {
+    visible: !booleanAttribute(pptxXmlChild(axis, "delete"), "val"),
+    title: parseChartString(pptxXmlChild(axis, "title")),
+    ...minimum === void 0 ? {} : { min: minimum },
+    ...maximum === void 0 ? {} : { max: maximum }
+  };
+}
+function chartLegendPosition(value) {
+  switch (value) {
+    case "l":
+      return "left";
+    case "t":
+      return "top";
+    case "tr":
+      return "topRight";
+    case "r":
+      return "right";
+    default:
+      return "bottom";
+  }
+}
+function parseThemeColors(root, partName) {
+  requireRoot(root, "theme", DRAWING_NAMESPACE, partName);
+  const colors = new Map(DEFAULT_THEME_COLORS);
+  const scheme = pptxXmlDescendants(root, "clrScheme")[0];
+  for (const entry of pptxXmlChildren(scheme)) {
+    const color = pptxXmlChildren(entry)[0];
+    const value = pptxXmlAttribute(color, color?.localName === "sysClr" ? "lastClr" : "val");
+    if (value && /^[0-9A-Fa-f]{6}$/.test(value))
+      colors.set(entry.localName, `#${value.toLowerCase()}`);
+  }
+  return colors;
+}
+function parseSlideSize(root) {
+  const size = requiredChild(root, "sldSz", "ppt/presentation.xml");
+  return {
+    width: positiveEmu(
+      requiredAttribute(size, "cx", "ppt/presentation.xml"),
+      "ppt/presentation.xml"
+    ),
+    height: positiveEmu(
+      requiredAttribute(size, "cy", "ppt/presentation.xml"),
+      "ppt/presentation.xml"
+    )
+  };
+}
+function mapTextAlignment(value) {
+  if (value === "ctr") return "center";
+  if (value === "r") return "right";
+  if (value === "just" || value === "justLow" || value === "dist") return "justify";
+  return value === "l" ? "left" : void 0;
+}
+function mapVerticalAlignment(value) {
+  if (value === "ctr") return "middle";
+  if (value === "b") return "bottom";
+  return value === "t" ? "top" : void 0;
+}
+function rasterContentType(partName) {
+  const extension = partName.slice(partName.lastIndexOf(".") + 1).toLowerCase();
+  if (extension === "png") return "image/png";
+  if (extension === "jpg" || extension === "jpeg") return "image/jpeg";
+  if (extension === "gif") return "image/gif";
+  return "image/webp";
+}
+function cropPercent(value, partName) {
+  if (value === void 0) return 0;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0 || parsed > 1e5) {
+    throw pptxSecurity("Picture crop percentage is invalid", "invalid-package", partName);
+  }
+  return parsed / 1e3;
+}
+function nonVisualName(element) {
+  return pptxXmlAttribute(pptxXmlDescendants(element, "cNvPr")[0], "name");
+}
+function nonVisualDescription(element) {
+  return pptxXmlAttribute(pptxXmlDescendants(element, "cNvPr")[0], "descr");
+}
+function requiredRelationshipId(element, partName, localName = "id") {
+  if (!element)
+    throw pptxSecurity("Relationship reference is missing", "invalid-package", partName);
+  const direct = pptxXmlQualifiedAttribute(element, `r:${localName}`);
+  if (direct) return direct;
+  const candidates = [...element.attributes].filter(
+    ([name]) => name.includes(":") && name.slice(name.indexOf(":") + 1) === localName && element.attributeNamespaces?.get(name) === OFFICE_RELATIONSHIP_BASE.slice(0, -1)
+  );
+  if (candidates.length !== 1 || !candidates[0]?.[1]) {
+    throw pptxSecurity(
+      "Relationship reference is missing or ambiguous",
+      "invalid-package",
+      partName
+    );
+  }
+  return candidates[0][1];
+}
+function requiredChild(parent, localName, partName) {
+  const candidates = pptxXmlChildren(parent).filter((child) => child.localName === localName);
+  if (candidates.length !== 1 || !candidates[0]) {
+    throw pptxSecurity(
+      `Required ${localName} element is missing or duplicated`,
+      "invalid-package",
+      partName
+    );
+  }
+  return candidates[0];
+}
+function requireRoot(element, localName, namespaceUri, partName) {
+  if (element.localName !== localName || element.namespaceUri !== namespaceUri) {
+    throw pptxSecurity(
+      `OOXML root must be ${localName} in ${namespaceUri}`,
+      "invalid-package",
+      partName
+    );
+  }
+}
+function requiredAttribute(element, localName, partName) {
+  const value = pptxXmlAttribute(element, localName);
+  if (value === void 0 || value.length === 0) {
+    throw pptxSecurity(`Required ${localName} attribute is missing`, "invalid-package", partName);
+  }
+  return value;
+}
+function byRelationshipId(relationships) {
+  return new Map(relationships.map((relationship) => [relationship.id, relationship]));
+}
+function relationshipPartName(sourcePart) {
+  if (sourcePart === "") return "_rels/.rels";
+  const slash = sourcePart.lastIndexOf("/");
+  const directory = slash < 0 ? "" : sourcePart.slice(0, slash + 1);
+  const file = slash < 0 ? sourcePart : sourcePart.slice(slash + 1);
+  return `${directory}_rels/${file}.rels`;
+}
+function relationshipSourcePart(relationshipPart) {
+  if (relationshipPart === "_rels/.rels") return "";
+  const match = /^(.*\/)?_rels\/([^/]+)\.rels$/.exec(relationshipPart);
+  if (!match) {
+    throw pptxSecurity("Invalid relationships part path", "invalid-package", relationshipPart);
+  }
+  return `${match[1] ?? ""}${match[2] ?? ""}`;
+}
+function resolvePartTarget(sourcePart, target, relationshipPart) {
+  if (/[\u0000-\u001f\u007f]/.test(target) || target.includes("\\") || target.startsWith("//") || /%(?:2e|2f|5c)/i.test(target)) {
+    throw pptxSecurity("Unsafe OPC relationship target", "invalid-package", relationshipPart);
+  }
+  const packageAbsolute = target.startsWith("/");
+  const relative = packageAbsolute ? target.slice(1) : target;
+  const base = !packageAbsolute && sourcePart.includes("/") ? sourcePart.slice(0, sourcePart.lastIndexOf("/") + 1) : "";
+  const combined = `${base}${relative}`;
+  if (combined.length === 0 || combined.length > 4096 || combined.includes("//")) {
+    throw pptxSecurity("Invalid OPC relationship target", "invalid-package", relationshipPart);
+  }
+  const output = [];
+  for (const segment of combined.split("/")) {
+    if (segment === "" || segment === ".") continue;
+    if (segment === "..") {
+      if (output.length === 0) {
+        throw pptxSecurity(
+          "OPC relationship escapes the package root",
+          "invalid-package",
+          relationshipPart
+        );
+      }
+      output.pop();
+    } else output.push(segment);
+    if (output.length > 256) {
+      throw pptxSecurity("OPC relationship path is too deep", "limit-exceeded", relationshipPart);
+    }
+  }
+  return output.join("/");
+}
+function emuNumber(value, partName) {
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || Math.abs(parsed) > 9525e6) {
+    throw pptxSecurity(
+      "Presentation geometry is outside supported bounds",
+      "invalid-package",
+      partName
+    );
+  }
+  return parsed / EMU_PER_PIXEL;
+}
+function positiveEmu(value, partName) {
+  const parsed = emuNumber(value, partName);
+  if (parsed <= 0) {
+    throw pptxSecurity("Presentation extent must be positive", "invalid-package", partName);
+  }
+  return parsed;
+}
+function optionalNumber(value) {
+  if (value === void 0) return void 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function optionalInteger(value, partName) {
+  if (value === void 0) return void 0;
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed < 0) {
+    throw pptxSecurity("OOXML integer is invalid", "invalid-package", partName);
+  }
+  return parsed;
+}
+function optionalPositiveInteger(value, partName) {
+  const parsed = optionalInteger(value, partName);
+  if (parsed === void 0) return void 0;
+  if (parsed <= 0 || parsed > 1024) {
+    throw pptxSecurity("OOXML span is outside supported bounds", "invalid-package", partName);
+  }
+  return parsed;
+}
+function booleanAttribute(element, name) {
+  const value = pptxXmlAttribute(element, name);
+  return value === "1" || value === "true" || value === "on";
+}
+function consumeElement(context, partName) {
+  context.elements += 1;
+  if (context.elements > context.limits.elements) {
+    throw pptxSecurity("PPTX exceeds its element limit", "limit-exceeded", partName);
+  }
+}
+function consumeText(context, characters, partName) {
+  context.textCharacters += characters;
+  if (context.textCharacters > context.limits.textCharacters) {
+    throw pptxSecurity("PPTX exceeds its text character limit", "limit-exceeded", partName);
+  }
+}
+function addUnsupported(context, feature, partName, code = "content-preserved-in-source") {
+  context.unsupportedParts.add(partName);
+  context.issues.push({
+    code,
+    severity: code === "content-will-be-discarded" ? "error" : "warning",
+    feature,
+    message: code === "style-approximated" ? `${feature} styling is represented by the closest editable model style` : `${feature} content is retained in the validated source package but is not editable`,
+    parts: [partName]
+  });
+}
+function fidelityIssue(feature, parts) {
+  return {
+    code: "content-preserved-in-source",
+    severity: "warning",
+    feature,
+    message: `${feature} content is retained in the validated source package but is not editable`,
+    parts
+  };
+}
+function deduplicateIssues(issues) {
+  const result = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    const key = `${issue.code}\0${issue.feature}\0${(issue.parts ?? []).join("\0")}`;
+    result.set(key, issue);
+  }
+  return [...result.values()];
+}
+function pptxSecurity(message, code, entryName) {
+  return new PresentationSecurityError(
+    entryName ? `${message}: ${entryName}` : message,
+    code,
+    entryName
+  );
+}
+function pptxZipFailure(kind, message, entryName) {
+  throw pptxSecurity(
+    message,
+    kind === "limit" ? "limit-exceeded" : kind === "encrypted" ? "encrypted-content" : "invalid-package",
+    entryName
+  );
+}
+var IDENTITY_TRANSFORM = { offsetX: 0, offsetY: 0, scaleX: 1, scaleY: 1 };
+var GEOMETRY_MAP = /* @__PURE__ */ new Map([
+  ["rect", "rect"],
+  ["roundRect", "roundRect"],
+  ["ellipse", "ellipse"],
+  ["triangle", "triangle"],
+  ["rtTriangle", "triangle"],
+  ["rightArrow", "rightArrow"],
+  ["line", "line"]
+]);
+var CHART_ELEMENT_TYPES = /* @__PURE__ */ new Map([
+  ["barChart", "bar"],
+  ["bar3DChart", "bar"],
+  ["lineChart", "line"],
+  ["line3DChart", "line"],
+  ["areaChart", "area"],
+  ["area3DChart", "area"],
+  ["pieChart", "pie"],
+  ["pie3DChart", "pie"],
+  ["doughnutChart", "doughnut"],
+  ["scatterChart", "scatter"],
+  ["bubbleChart", "bubble"],
+  ["radarChart", "radar"]
+]);
+var DEFAULT_THEME_COLORS = /* @__PURE__ */ new Map([
+  ["dk1", "#000000"],
+  ["lt1", "#ffffff"],
+  ["dk2", "#1f497d"],
+  ["lt2", "#eeeceed"],
+  ["accent1", "#4472c4"],
+  ["accent2", "#ed7d31"],
+  ["accent3", "#a5a5a5"],
+  ["accent4", "#ffc000"],
+  ["accent5", "#5b9bd5"],
+  ["accent6", "#70ad47"],
+  ["hlink", "#0563c1"],
+  ["folHlink", "#954f72"],
+  ["tx1", "#000000"],
+  ["bg1", "#ffffff"],
+  ["tx2", "#1f497d"],
+  ["bg2", "#eeeceed"]
+]);
+var KNOWN_RELATIONSHIP_SUFFIXES = /* @__PURE__ */ new Set([
+  "officeDocument",
+  "core-properties",
+  "extended-properties",
+  "custom-properties",
+  "slideMaster",
+  "slideLayout",
+  "slide",
+  "notesMaster",
+  "notesSlide",
+  "theme",
+  "presProps",
+  "viewProps",
+  "tableStyles",
+  "chart",
+  "image",
+  "package",
+  "hyperlink",
+  "handoutMaster",
+  "font",
+  "tags",
+  "customXml",
+  "comments",
+  "commentAuthors",
+  "diagramData",
+  "diagramLayout",
+  "diagramColors",
+  "diagramQuickStyle"
+]);
+var ACTIVE_RELATIONSHIP_SUFFIX = /^(?:vbaProject|activeX|oleObject|audio|video|media|externalLink|attachedTemplate|control|webVideo|linkedData|externalData)$/i;
+var SOURCE_ONLY_RELATIONSHIP_SUFFIXES = /* @__PURE__ */ new Set([
+  "handoutMaster",
+  "font",
+  "tags",
+  "customXml",
+  "comments",
+  "commentAuthors",
+  "diagramData",
+  "diagramLayout",
+  "diagramColors",
+  "diagramQuickStyle"
+]);
+var ALLOWED_EXACT_RELATIONSHIPS = /* @__PURE__ */ new Set([
+  "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties",
+  "http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties",
+  "http://schemas.openxmlformats.org/officeDocument/2006/relationships/custom-properties"
+]);
+var KNOWN_DEFAULT_CONTENT_TYPES = /* @__PURE__ */ new Set([
+  "rels\0application/vnd.openxmlformats-package.relationships+xml",
+  "xml\0application/xml",
+  "png\0image/png",
+  "jpg\0image/jpeg",
+  "jpeg\0image/jpeg",
+  "jpg\0image/jpg",
+  "gif\0image/gif",
+  "webp\0image/webp",
+  "svg\0image/svg+xml",
+  "m4v\0video/mp4",
+  "mp4\0video/mp4",
+  "vml\0application/vnd.openxmlformats-officedocument.vmlDrawing",
+  "xlsx\0application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+]);
+var KNOWN_PPTX_PART_PATTERNS = [
+  /^\[Content_Types\]\.xml$/,
+  /^_rels\/\.rels$/,
+  /^docProps\/(?:app|core|custom)\.xml$/,
+  /^ppt\/presentation\.xml$/,
+  /^ppt\/(?:presProps|viewProps|tableStyles)\.xml$/,
+  /^ppt\/(?:_rels\/presentation\.xml|slides\/_rels\/slide\d+\.xml|slideMasters\/_rels\/slideMaster\d+\.xml|slideLayouts\/_rels\/slideLayout\d+\.xml|notesSlides\/_rels\/notesSlide\d+\.xml|notesMasters\/_rels\/notesMaster\d+\.xml|charts\/_rels\/chart\d+\.xml)\.rels$/,
+  /^ppt\/(?:slides\/slide\d+|slideMasters\/slideMaster\d+|slideLayouts\/slideLayout\d+|notesSlides\/notesSlide\d+|notesMasters\/notesMaster\d+|charts\/chart\d+|theme\/theme\d+)\.xml$/,
+  /^ppt\/media\/[^/]+\.(?:png|jpe?g|gif|webp)$/i,
+  /^ppt\/embeddings\/[^/]+\.xlsx$/i
+];
+
+// src/presentation-pptx.ts
+var colorValue2 = colorValue;
+async function exportPresentationPptx(presentation, options = {}) {
+  const provenance = presentationLossState(presentation);
+  if (provenance) {
+    const [currentModelDigest, actualSourceDigest] = await Promise.all([
+      presentationModelDigest(presentation),
+      sha256Hex(provenance.sourceBytes)
+    ]);
+    const sourceBindingValid = provenance.version === 1 && provenance.mediaType === PPTX_MEDIA_TYPE && provenance.sourceDigest === actualSourceDigest;
+    if (sourceBindingValid && provenance.modelDigest === currentModelDigest) {
+      return FileBlob.fromBytes(provenance.sourceBytes, {
+        name: options.fileName ?? "presentation.pptx",
+        type: PPTX_MEDIA_TYPE
+      });
+    }
+    if (!sourceBindingValid && options.unsupportedContent !== "discard") {
+      throw new PresentationFidelityError(
+        "PPTX source-preservation envelope is invalid or no longer matches its source bytes",
+        [
+          {
+            code: "content-will-be-discarded",
+            severity: "error",
+            feature: "source-only",
+            message: "The retained source package failed its digest or version binding",
+            parts: [...provenance.unsupportedParts]
+          }
+        ]
+      );
+    }
+  }
+  const issues = PresentationFile.fidelityReport(presentation).map((issue) => ({
+    ...issue,
+    severity: "error",
+    code: "content-will-be-discarded"
+  }));
+  if (issues.length > 0 && options.unsupportedContent !== "discard") {
+    throw new PresentationFidelityError(
+      'PPTX export would discard source-only presentation content; use unsupportedContent: "discard" only when that loss is intended',
+      issues
+    );
+  }
+  const { default: PptxConstructor } = await import("pptxgenjs");
+  const pptx = new PptxConstructor();
+  pptx.defineLayout({
+    name: "OPENGENI_CUSTOM",
+    width: presentation.slideSize.width / 96,
+    height: presentation.slideSize.height / 96
+  });
+  pptx.layout = "OPENGENI_CUSTOM";
+  pptx.author = "OpenGeni";
+  for (const slide of presentation.slides.items) {
+    const target = pptx.addSlide();
+    target.background = { color: pptxColor(slide.background.fill) };
+    for (const element of slide.elements) {
+      if ("geometry" in element && "text" in element) exportShapeToPptx(target, element);
+      else if ("series" in element) exportChartToPptx(target, element);
+      else if ("sourceForPptx" in element) exportImageToPptx(target, element);
+      else if ("rows" in element) exportTableToPptx(target, element);
+      else if ("children" in element) exportGroupToPptx(target, element);
+    }
+    if (slide.notes.toString().length > 0) target.addNotes(slide.notes.toString());
+  }
+  const output = await pptx.write({ outputType: "arraybuffer" });
+  const bytes = output instanceof Uint8Array ? output : output instanceof ArrayBuffer ? new Uint8Array(output) : typeof output === "string" ? new TextEncoder().encode(output) : void 0;
+  if (!bytes) throw new Error("PPTX writer returned an unsupported output type");
+  const canonicalBytes = await canonicalizeGeneratedPptx(bytes);
+  return FileBlob.fromBytes(canonicalBytes, {
+    name: options.fileName ?? "presentation.pptx",
+    type: PPTX_MEDIA_TYPE
+  });
+}
+async function canonicalizeGeneratedPptx(bytes) {
+  const { default: JSZip } = await import("./lib-GQLPACFK.js");
+  const source = await JSZip.loadAsync(bytes);
+  const chartIds = Object.keys(source.files).map((name) => /^ppt\/charts\/chart(\d+)\.xml$/.exec(name)?.[1]).filter((value) => value !== void 0).map(Number).sort((left, right) => left - right);
+  const chartIdMap = new Map(chartIds.map((id, index) => [id, index + 1]));
+  const rename = (value) => value.replace(/chart(\d+)\.xml/g, (match, raw) => {
+    const replacement = chartIdMap.get(Number(raw));
+    return replacement === void 0 ? match : `chart${replacement}.xml`;
+  }).replace(/Microsoft_Excel_Worksheet(\d+)\.xlsx/g, (match, raw) => {
+    const replacement = chartIdMap.get(Number(raw));
+    return replacement === void 0 ? match : `Microsoft_Excel_Worksheet${replacement}.xlsx`;
+  });
+  return await canonicalizeGeneratedZip(source, rename, true);
+}
+async function canonicalizeGeneratedZip(source, rename, canonicalizeNestedWorkbooks) {
+  const { default: JSZip } = await import("./lib-GQLPACFK.js");
+  const output = new JSZip();
+  const entries = Object.values(source.files).filter((entry) => !entry.dir).sort((left, right) => rename(left.name).localeCompare(rename(right.name)));
+  for (const entry of entries) {
+    let data = await entry.async("uint8array");
+    if (canonicalizeNestedWorkbooks && /^ppt\/embeddings\/[^/]+\.xlsx$/i.test(entry.name)) {
+      data = await canonicalizeGeneratedZip(await JSZip.loadAsync(data), (value) => value, false);
+    } else if (/(?:\.xml|\.rels)$/i.test(entry.name) || entry.name === "[Content_Types].xml") {
+      const xml = new TextDecoder().decode(data);
+      data = new TextEncoder().encode(
+        rename(xml).replace(
+          /(<dcterms:(?:created|modified)\b[^>]*>)[^<]*(<\/dcterms:(?:created|modified)>)/g,
+          "$11980-01-01T00:00:00Z$2"
+        )
+      );
+    }
+    output.file(rename(entry.name), data, {
+      binary: true,
+      createFolders: false,
+      date: DETERMINISTIC_ZIP_DATE
+    });
+  }
+  return await output.generateAsync({
+    type: "uint8array",
+    compression: "DEFLATE",
+    compressionOptions: { level: 9 },
+    platform: "DOS"
+  });
+}
+var DETERMINISTIC_ZIP_DATE = /* @__PURE__ */ new Date("1980-01-01T00:00:00.000Z");
+function exportShapeToPptx(slide, shape, position = shape.position) {
+  const box = pptxPosition(position);
+  const fill = pptxFill(shape.fill);
+  const line = pptxLine(shape.line);
+  const text = shape.text.toString();
+  if (shape.geometry === "line" || text.length === 0) {
+    if (shape.geometry !== "textbox") {
+      slide.addShape(shape.geometry, {
+        ...box,
+        fill,
+        line,
+        rotate: shape.rotation,
+        objectName: shape.name
+      });
+    }
+  }
+  if (shape.geometry === "textbox" || text) {
+    const style = shape.text.style;
+    slide.addText(text, {
+      ...box,
+      margin: 0,
+      breakLine: false,
+      fontFace: style.fontFamily ?? "Aptos",
+      fontSize: (style.fontSize ?? 18) * 0.75,
+      bold: style.bold ?? false,
+      italic: style.italic ?? false,
+      underline: style.underline ? { style: "sng" } : void 0,
+      color: pptxColor(style.color ?? "slate-950"),
+      align: style.alignment ?? "left",
+      valign: style.verticalAlignment ?? "top",
+      shape: shape.geometry === "textbox" || shape.geometry === "line" ? void 0 : shape.geometry,
+      fill: shape.geometry === "line" ? { color: "FFFFFF", transparency: 100 } : fill,
+      line: shape.geometry === "line" ? { color: "FFFFFF", transparency: 100 } : line,
+      rotate: shape.rotation,
+      objectName: shape.name
+    });
+  }
+}
+function exportTableToPptx(slide, table, position = table.position) {
+  const rows = table.rows.map(
+    (row) => row.filter((cell) => cell !== null).map((cell) => ({
+      text: cell.text.toString(),
+      options: {
+        fill: pptxFill(cell.fill),
+        color: pptxColor(cell.text.style.color ?? table.textStyle.color ?? "slate-950"),
+        fontFace: cell.text.style.fontFamily ?? table.textStyle.fontFamily ?? "Aptos",
+        fontSize: (cell.text.style.fontSize ?? table.textStyle.fontSize ?? 16) * 0.75,
+        bold: cell.text.style.bold ?? table.textStyle.bold ?? false,
+        italic: cell.text.style.italic ?? table.textStyle.italic ?? false,
+        align: cell.text.style.alignment ?? table.textStyle.alignment ?? "left",
+        valign: cell.text.style.verticalAlignment ?? table.textStyle.verticalAlignment ?? "top",
+        rowspan: cell.rowSpan > 1 ? cell.rowSpan : void 0,
+        colspan: cell.colSpan > 1 ? cell.colSpan : void 0
+      }
+    }))
+  );
+  slide.addTable(rows, {
+    ...pptxPosition(position),
+    border: pptxTableBorder(table.line),
+    fill: pptxFill(table.fill),
+    margin: 2,
+    objectName: table.name,
+    ...table.columnWidths.length > 0 ? { colW: table.columnWidths.map((width) => width / 96) } : {},
+    ...table.rowHeights.length > 0 ? { rowH: table.rowHeights.map((height) => height / 96) } : {}
+  });
+}
+function exportGroupToPptx(slide, group, parentTransform = (position) => position) {
+  const transform = (position) => parentTransform(groupChildPosition(group, position));
+  for (const child of group.children) {
+    if ("geometry" in child && "text" in child)
+      exportShapeToPptx(slide, child, transform(child.position));
+    else if ("series" in child) exportChartToPptx(slide, child, transform(child.position));
+    else if ("sourceForPptx" in child) exportImageToPptx(slide, child, transform(child.position));
+    else if ("rows" in child) exportTableToPptx(slide, child, transform(child.position));
+    else if ("children" in child) exportGroupToPptx(slide, child, transform);
+  }
+}
+function exportChartToPptx(slide, chart, position = chart.position) {
+  const categories = chart.categories;
+  const data = chart.type === "scatter" || chart.type === "bubble" ? [
+    {
+      name: "X Values",
+      values: chart.series.items[0]?.xValues ?? []
+    },
+    ...chart.series.items.map((series) => ({
+      name: series.name,
+      values: series.values,
+      sizes: series.bubbleSizes.length > 0 ? series.bubbleSizes : void 0
+    }))
+  ] : chart.series.items.map((series) => ({
+    name: series.name,
+    labels: series.categories.length > 0 ? series.categories : categories,
+    values: series.values
+  }));
+  slide.addChart(chart.type, data, {
+    ...pptxPosition(position),
+    showTitle: chart.title.length > 0,
+    title: chart.title,
+    showLegend: chart.hasLegend,
+    legendPos: pptxLegendPosition(chart.legend?.position),
+    showValue: chart.dataLabels?.showValue ?? false,
+    showCategoryName: chart.dataLabels?.showCategoryName ?? false,
+    showPercent: chart.dataLabels?.showPercent ?? false,
+    showCatName: chart.dataLabels?.showCategoryName ?? false,
+    showSerName: chart.dataLabels?.showSeriesName ?? false,
+    catAxisHidden: chart.xAxis?.visible === false,
+    catAxisTitle: chart.xAxis?.title,
+    catAxisMinVal: chart.xAxis?.min,
+    catAxisMaxVal: chart.xAxis?.max,
+    valAxisHidden: chart.yAxis?.visible === false,
+    valAxisTitle: chart.yAxis?.title,
+    valAxisMinVal: chart.yAxis?.min,
+    valAxisMaxVal: chart.yAxis?.max
+  });
+}
+function exportImageToPptx(slide, image, position = image.position) {
+  slide.addImage({
+    ...image.sourceForPptx(),
+    ...pptxPosition(position),
+    altText: image.alt,
+    rotate: image.rotation,
+    flipH: image.flipHorizontal,
+    flipV: image.flipVertical,
+    rounding: image.geometry === "ellipse" || image.geometry === "roundRect",
+    objectName: image.name,
+    sizing: {
+      type: image.crop ? "crop" : image.fit,
+      w: position.width / 96,
+      h: position.height / 96
+    }
+  });
+}
+function groupChildPosition(group, position) {
+  const scaleX = group.position.width / group.childExtent.width;
+  const scaleY = group.position.height / group.childExtent.height;
+  return {
+    left: group.position.left + (position.left - group.childOffset.left) * scaleX,
+    top: group.position.top + (position.top - group.childOffset.top) * scaleY,
+    width: position.width * scaleX,
+    height: position.height * scaleY
+  };
+}
+function pptxLegendPosition(position) {
+  switch (position) {
+    case "left":
+      return "l";
+    case "top":
+      return "t";
+    case "topRight":
+      return "tr";
+    case "right":
+      return "r";
+    default:
+      return "b";
+  }
+}
+function pptxPosition(position) {
+  return {
+    x: position.left / 96,
+    y: position.top / 96,
+    w: position.width / 96,
+    h: position.height / 96
+  };
+}
+function pptxColor(fill) {
+  const color = colorValue2(fill);
+  return color === "none" ? "FFFFFF" : color.replace(/^#/, "").slice(0, 6).toUpperCase();
+}
+function pptxFill(fill) {
+  return colorValue2(fill) === "none" ? { color: "FFFFFF", transparency: 100 } : { color: pptxColor(fill), transparency: 0 };
+}
+function pptxLine(line) {
+  const none = line.style === "none" || colorValue2(line.fill ?? "none") === "none" || (line.width ?? 1) === 0;
+  return none ? { color: "FFFFFF", transparency: 100, width: 0 } : {
+    color: pptxColor(line.fill ?? "slate-900"),
+    width: (line.width ?? 1) * 0.75,
+    dashType: line.style
+  };
+}
+function pptxTableBorder(line) {
+  const shapeLine = pptxLine(line);
+  return {
+    color: shapeLine.color,
+    transparency: shapeLine.transparency,
+    pt: shapeLine.width,
+    type: shapeLine.dashType
+  };
+}
+export {
+  exportPresentationPptx,
+  importPresentationPptx
+};
+//# sourceMappingURL=presentation-pptx.js.map