ppt2json 0.2.0 → 0.3.0

package/dist/index.mjs

@@ -1,10 +1,5 @@
 // index.ts
-import JSZip2 from "jszip";
-import {
-  ENABLE_DECK_JSON,
-  PPTX_JSON_PAYLOAD_PATH,
-  PPTX_JSON_PAYLOAD_VERSION
-} from "json2pptx";
+import { parseDocument } from "json2pptx-schema";
 
 // parser/parse.ts
 import JSZip from "jszip";
@@ -3129,176 +3124,8 @@ function shapeArc(cX, cY, rX, rY, stAng, endAng, isClose) {
 }
 function getCustomShapePath(custShapType, w, h) {
   const pathLstNode = getTextByPathList(custShapType, ["a:pathLst"]);
-  let pathNodes = getTextByPathList(pathLstNode, ["a:path"]);
-  if (Array.isArray(pathNodes)) pathNodes = pathNodes.shift();
-  const maxX = parseInt(pathNodes["attrs"]["w"]);
-  const maxY = parseInt(pathNodes["attrs"]["h"]);
-  const cX = maxX === 0 ? 0 : 1 / maxX * w;
-  const cY = maxY === 0 ? 0 : 1 / maxY * h;
-  let d = "";
-  let moveToNode = getTextByPathList(pathNodes, ["a:moveTo"]);
-  let lnToNodes = pathNodes["a:lnTo"];
-  let cubicBezToNodes = pathNodes["a:cubicBezTo"];
-  let quadBezToNodes = pathNodes["a:quadBezTo"];
-  const arcToNodes = pathNodes["a:arcTo"];
-  let closeNode = getTextByPathList(pathNodes, ["a:close"]);
-  if (!Array.isArray(moveToNode)) moveToNode = [moveToNode];
-  const multiSapeAry = [];
-  if (moveToNode.length > 0) {
-    Object.keys(moveToNode).forEach((key) => {
-      const moveToPtNode = moveToNode[key]["a:pt"];
-      if (moveToPtNode) {
-        Object.keys(moveToPtNode).forEach((key2) => {
-          const moveToNoPt = moveToPtNode[key2];
-          const spX = moveToNoPt["attrs"]?.["x"];
-          const spY = moveToNoPt["attrs"]?.["y"];
-          const order = moveToNoPt["attrs"]?.["order"];
-          multiSapeAry.push({
-            type: "movto",
-            x: spX,
-            y: spY,
-            order
-          });
-        });
-      }
-    });
-    if (lnToNodes) {
-      if (!Array.isArray(lnToNodes)) lnToNodes = [lnToNodes];
-      Object.keys(lnToNodes).forEach((key) => {
-        const lnToPtNode = lnToNodes[key]["a:pt"];
-        if (lnToPtNode) {
-          Object.keys(lnToPtNode).forEach((key2) => {
-            const lnToNoPt = lnToPtNode[key2];
-            const ptX = lnToNoPt["attrs"]?.["x"];
-            const ptY = lnToNoPt["attrs"]?.["y"];
-            const order = lnToNoPt["attrs"]?.["order"];
-            multiSapeAry.push({
-              type: "lnto",
-              x: ptX,
-              y: ptY,
-              order
-            });
-          });
-        }
-      });
-    }
-    if (cubicBezToNodes) {
-      const cubicBezToPtNodesAry = [];
-      if (!Array.isArray(cubicBezToNodes)) cubicBezToNodes = [cubicBezToNodes];
-      Object.keys(cubicBezToNodes).forEach((key) => {
-        cubicBezToPtNodesAry.push(cubicBezToNodes[key]["a:pt"]);
-      });
-      cubicBezToPtNodesAry.forEach((key) => {
-        const pts_ary = [];
-        key.forEach((pt) => {
-          const pt_obj = {
-            x: pt["attrs"]["x"],
-            y: pt["attrs"]["y"]
-          };
-          pts_ary.push(pt_obj);
-        });
-        const order = key[0]["attrs"]["order"];
-        multiSapeAry.push({
-          type: "cubicBezTo",
-          cubBzPt: pts_ary,
-          order
-        });
-      });
-    }
-    if (quadBezToNodes) {
-      const quadBezToPtNodesAry = [];
-      if (!Array.isArray(quadBezToNodes)) quadBezToNodes = [quadBezToNodes];
-      Object.keys(quadBezToNodes).forEach((key) => {
-        quadBezToPtNodesAry.push(quadBezToNodes[key]["a:pt"]);
-      });
-      quadBezToPtNodesAry.forEach((key) => {
-        const pts_ary = [];
-        key.forEach((pt) => {
-          const pt_obj = {
-            x: pt["attrs"]["x"],
-            y: pt["attrs"]["y"]
-          };
-          pts_ary.push(pt_obj);
-        });
-        const order = key[0]["attrs"]["order"];
-        multiSapeAry.push({
-          type: "quadBezTo",
-          quadBzPt: pts_ary,
-          order
-        });
-      });
-    }
-    if (arcToNodes) {
-      const arcToNodesAttrs = arcToNodes["attrs"];
-      const order = arcToNodesAttrs["order"];
-      const hR = arcToNodesAttrs["hR"];
-      const wR = arcToNodesAttrs["wR"];
-      const stAng = arcToNodesAttrs["stAng"];
-      const swAng = arcToNodesAttrs["swAng"];
-      let shftX = 0;
-      let shftY = 0;
-      const arcToPtNode = getTextByPathList(arcToNodes, ["a:pt", "attrs"]);
-      if (arcToPtNode) {
-        shftX = arcToPtNode["x"];
-        shftY = arcToPtNode["y"];
-      }
-      multiSapeAry.push({
-        type: "arcTo",
-        hR,
-        wR,
-        stAng,
-        swAng,
-        shftX,
-        shftY,
-        order
-      });
-    }
-    if (closeNode) {
-      if (!Array.isArray(closeNode)) closeNode = [closeNode];
-      Object.keys(closeNode).forEach(() => {
-        multiSapeAry.push({
-          type: "close",
-          order: Infinity
-        });
-      });
-    }
-    multiSapeAry.sort((a, b) => a.order - b.order);
-    let k = 0;
-    while (k < multiSapeAry.length) {
-      if (multiSapeAry[k].type === "movto") {
-        const spX = parseInt(multiSapeAry[k].x) * cX;
-        const spY = parseInt(multiSapeAry[k].y) * cY;
-        d += " M" + spX + "," + spY;
-      } else if (multiSapeAry[k].type === "lnto") {
-        const Lx = parseInt(multiSapeAry[k].x) * cX;
-        const Ly = parseInt(multiSapeAry[k].y) * cY;
-        d += " L" + Lx + "," + Ly;
-      } else if (multiSapeAry[k].type === "cubicBezTo") {
-        const Cx1 = parseInt(multiSapeAry[k].cubBzPt[0].x) * cX;
-        const Cy1 = parseInt(multiSapeAry[k].cubBzPt[0].y) * cY;
-        const Cx2 = parseInt(multiSapeAry[k].cubBzPt[1].x) * cX;
-        const Cy2 = parseInt(multiSapeAry[k].cubBzPt[1].y) * cY;
-        const Cx3 = parseInt(multiSapeAry[k].cubBzPt[2].x) * cX;
-        const Cy3 = parseInt(multiSapeAry[k].cubBzPt[2].y) * cY;
-        d += " C" + Cx1 + "," + Cy1 + " " + Cx2 + "," + Cy2 + " " + Cx3 + "," + Cy3;
-      } else if (multiSapeAry[k].type === "quadBezTo") {
-        const Qx1 = parseInt(multiSapeAry[k].quadBzPt[0].x) * cX;
-        const Qy1 = parseInt(multiSapeAry[k].quadBzPt[0].y) * cY;
-        const Qx2 = parseInt(multiSapeAry[k].quadBzPt[1].x) * cX;
-        const Qy2 = parseInt(multiSapeAry[k].quadBzPt[1].y) * cY;
-        d += " Q" + Qx1 + "," + Qy1 + " " + Qx2 + "," + Qy2;
-      } else if (multiSapeAry[k].type === "arcTo") {
-        const hR = parseInt(multiSapeAry[k].hR) * cX;
-        const wR = parseInt(multiSapeAry[k].wR) * cY;
-        const stAng = parseInt(multiSapeAry[k].stAng) / 6e4;
-        const swAng = parseInt(multiSapeAry[k].swAng) / 6e4;
-        const endAng = stAng + swAng;
-        d += shapeArc(wR, hR, wR, hR, stAng, endAng, false);
-      } else if (multiSapeAry[k].type === "close") d += "z";
-      k++;
-    }
-  }
-  return d;
+  const pathNodes = normalizeToArray(getTextByPathList(pathLstNode, ["a:path"]));
+  return pathNodes.map((pathNode) => buildCustomShapeSegment(pathNode, w, h)).filter(Boolean).join(" ");
 }
 function identifyShape(shapeData) {
   const pathLst = shapeData["a:pathLst"];
@@ -3313,16 +3140,16 @@ function identifyShape(shapeData) {
 }
 function extractPathCommands(path) {
   const commands = [];
-  if (path["a:moveTo"]) {
-    const moveTo = path["a:moveTo"];
-    const pt = moveTo["a:pt"];
+  const moveToList = normalizeToArray(path["a:moveTo"]);
+  moveToList.forEach((moveTo) => {
+    const pt = Array.isArray(moveTo?.["a:pt"]) ? moveTo["a:pt"][0] : moveTo?.["a:pt"];
     if (pt) {
       commands.push({
         type: "moveTo",
         points: [{ x: parseInt(pt.attrs?.x) || 0, y: parseInt(pt.attrs?.y) || 0 }]
       });
     }
-  }
+  });
   const lineToList = normalizeToArray(path["a:lnTo"]);
   lineToList.forEach((lnTo) => {
     const pt = lnTo["a:pt"];
@@ -3372,6 +3199,55 @@ function normalizeToArray(value) {
   if (!value) return [];
   return Array.isArray(value) ? value : [value];
 }
+function buildCustomShapeSegment(pathNode, w, h) {
+  if (!pathNode || typeof pathNode !== "object") return "";
+  const maxX = parseInt(pathNode.attrs?.w) || 0;
+  const maxY = parseInt(pathNode.attrs?.h) || 0;
+  const scaleX = maxX === 0 ? 0 : w / maxX;
+  const scaleY = maxY === 0 ? 0 : h / maxY;
+  const commands = extractPathCommands(pathNode);
+  if (!commands.length) return "";
+  return commands.map((command) => mapCommandToPath(command, scaleX, scaleY)).filter(Boolean).join(" ");
+}
+function mapCommandToPath(command, scaleX, scaleY) {
+  switch (command.type) {
+    case "moveTo": {
+      const point = command.points?.[0];
+      return `M${scaleValue(point?.x, scaleX)},${scaleValue(point?.y, scaleY)}`;
+    }
+    case "lineTo": {
+      const point = command.points?.[0];
+      return `L${scaleValue(point?.x, scaleX)},${scaleValue(point?.y, scaleY)}`;
+    }
+    case "cubicBezTo": {
+      if (!Array.isArray(command.points) || command.points.length < 3) return "";
+      const [p1, p2, p3] = command.points;
+      return `C${scaleValue(p1?.x, scaleX)},${scaleValue(p1?.y, scaleY)} ${scaleValue(p2?.x, scaleX)},${scaleValue(p2?.y, scaleY)} ${scaleValue(p3?.x, scaleX)},${scaleValue(p3?.y, scaleY)}`;
+    }
+    case "quadBezTo": {
+      if (!Array.isArray(command.points) || command.points.length < 2) return "";
+      const [p1, p2] = command.points;
+      return `Q${scaleValue(p1?.x, scaleX)},${scaleValue(p1?.y, scaleY)} ${scaleValue(p2?.x, scaleX)},${scaleValue(p2?.y, scaleY)}`;
+    }
+    case "arcTo": {
+      const startAngle = (parseInt(command.stAng) || 0) / 6e4;
+      const sweepAngle = (parseInt(command.swAng) || 0) / 6e4;
+      const endAngle = startAngle + sweepAngle;
+      const radiusX = scaleValue(command.wR, scaleX);
+      const radiusY = scaleValue(command.hR, scaleY);
+      return shapeArc(radiusX, radiusY, radiusX, radiusY, startAngle, endAngle, false).trim();
+    }
+    case "close":
+      return "z";
+    default:
+      return "";
+  }
+}
+function scaleValue(value, scale) {
+  const numeric = typeof value === "number" ? value : parseFloat(String(value ?? 0));
+  if (!Number.isFinite(numeric) || !Number.isFinite(scale)) return 0;
+  return numeric * scale;
+}
 function analyzePathCommands(commands, pathWidth, pathHeight) {
   const analysis = {
     lineCount: 0,
@@ -9310,6 +9186,7 @@ async function genDiagram(node, warpObj) {
 
 // utils.ts
 var PT_TO_PX = 96 / 72;
+var EXPORTED_OBJECT_NAME_RE = /^(shape-text|shape|text)-(\d+)-(.+)$/;
 function toPx(value) {
   if (value === void 0 || value === null) return void 0;
   return value * PT_TO_PX;
@@ -9327,18 +9204,80 @@ function mapFillColor(value) {
   if (!value) return void 0;
   return value.startsWith("#") ? value : `#${value}`;
 }
+function parseExportedObjectName(name) {
+  if (!name) return void 0;
+  const match = name.match(EXPORTED_OBJECT_NAME_RE);
+  if (!match) return void 0;
+  const slideIndex = Number.parseInt(match[2], 10);
+  if (!Number.isFinite(slideIndex)) return void 0;
+  return {
+    kind: match[1],
+    slideIndex,
+    refId: match[3]
+  };
+}
+function parseGradientPosition(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value > 100 ? value / 1e3 : value;
+  }
+  if (typeof value !== "string") return 0;
+  const numeric = Number.parseFloat(value);
+  if (!Number.isFinite(numeric)) return 0;
+  if (value.trim().endsWith("%")) return numeric;
+  return numeric > 100 ? numeric / 1e3 : numeric;
+}
+function mapGradient(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const colors = Array.isArray(value.colors) ? value.colors.filter((stop) => stop && typeof stop === "object").map((stop) => ({
+    pos: parseGradientPosition(stop.pos),
+    color: mapFillColor(stop.color) ?? "#FFFFFF"
+  })) : [];
+  return {
+    type: typeof value.type === "string" ? value.type === "line" ? "linear" : value.type : typeof value.path === "string" ? value.path === "line" ? "linear" : value.path : "linear",
+    rotate: typeof value.rotate === "number" ? value.rotate : typeof value.rot === "number" ? value.rot : 0,
+    colors
+  };
+}
 function mapFill(fill) {
-  if (!fill) return {};
-  if (typeof fill === "string") return { fill: mapFillColor(fill) ?? void 0 };
-  if (typeof fill === "object") {
-    if (fill.type === "color" && typeof fill.value === "string") {
-      return { fill: mapFillColor(fill.value) ?? void 0 };
-    }
-    if (fill.type === "image" && fill.value?.picBase64) {
-      return { fill: "", pattern: fill.value.picBase64 };
-    }
+  if (!fill) return void 0;
+  if (typeof fill === "string") {
+    const color = mapFillColor(fill);
+    return color ? { type: "solid", color } : void 0;
+  }
+  if (typeof fill !== "object") {
+    return void 0;
+  }
+  if (fill.type === "color" && typeof fill.value === "string") {
+    const color = mapFillColor(fill.value);
+    return color ? { type: "solid", color } : void 0;
+  }
+  if (fill.type === "solid" || fill.type === void 0 && typeof fill.color === "string") {
+    const color = mapFillColor(fill.color);
+    return color ? { type: "solid", color } : void 0;
   }
-  return {};
+  if (fill.type === "gradient") {
+    const gradient = mapGradient(fill.value ?? fill.gradient ?? fill);
+    return gradient ? { type: "gradient", gradient } : void 0;
+  }
+  if ((fill.type === "image" || fill.type === "pattern") && fill.value?.picBase64) {
+    return {
+      type: "image",
+      src: fill.value.picBase64,
+      ...typeof fill.value.opacity === "number" ? { opacity: fill.value.opacity } : {}
+    };
+  }
+  if (fill.type === "image" && typeof fill.src === "string") {
+    return {
+      type: "image",
+      src: fill.src,
+      ...typeof fill.opacity === "number" ? { opacity: fill.opacity } : {}
+    };
+  }
+  if (fill.gradient || fill.colors) {
+    const gradient = mapGradient(fill.gradient ?? fill);
+    return gradient ? { type: "gradient", gradient } : void 0;
+  }
+  return void 0;
 }
 function convertFontSizeToPx(content) {
   return content.replace(/font-size:\s*([0-9.]+)pt/gi, (_, size) => {
@@ -9463,14 +9402,16 @@ function mapKeypoints(pathFormula, raw) {
 // element-mapper.ts
 function mapElement(raw) {
   if (!raw || !raw.type) return null;
-  const base = mapBaseElement(raw);
-  if (raw.type === "text") {
+  const exportedMeta = parseExportedObjectName(raw.name);
+  const base = mapBaseElement(raw, exportedMeta);
+  if (raw.type === "text" || isExportedTextShape(raw, exportedMeta)) {
     const content = raw.content !== void 0 ? normalizeTextContent(raw.content) : raw.content;
     const fallbackLineHeight = hasMultiLineText(content) ? 1.5 : 1;
     const lineHeight = raw.lineHeight ?? fallbackLineHeight;
     const normalizedHeight = normalizeTextHeight(base.height, content, lineHeight);
     return {
       ...base,
+      type: "text",
       height: normalizedHeight,
       rotate: base.rotate ?? 0,
       flipH: void 0,
@@ -9482,7 +9423,7 @@ function mapElement(raw) {
       lineHeight,
       paragraphSpace: raw.paragraphSpace,
       vertical: raw.isVertical,
-      fill: mapFill(raw.fill).fill ?? ""
+      fill: mapFill(raw.fill)
     };
   }
   if (raw.type === "image") {
@@ -9507,10 +9448,11 @@ function mapElement(raw) {
     };
   }
   if (raw.type === "shape") {
-    const { fill, pattern } = mapFill(raw.fill);
+    const fill = mapFill(raw.fill) ?? { type: "solid", color: "rgba(255,255,255,0)" };
     const pathFormula = mapPathFormula(raw.shapType);
     const keypoints = pathFormula ? mapKeypoints(pathFormula, raw.keypoints) : void 0;
-    const hasText = raw.content !== void 0;
+    const normalizedShapeText = raw.content !== void 0 ? normalizeTextContent(raw.content) : void 0;
+    const hasText = hasRenderableText(normalizedShapeText);
     let path = raw.path;
     let viewBox = raw.viewBox ?? [raw.width ?? 0, raw.height ?? 0];
     let special = false;
@@ -9549,17 +9491,17 @@ function mapElement(raw) {
     }
     return {
       ...base,
+      type: "shape",
       rotate: base.rotate ?? 0,
       fixedRatio: false,
       path,
       viewBox,
       pathFormula: pathFormula ?? void 0,
       keypoints: keypoints ?? void 0,
-      pattern,
-      fill: fill ?? "",
+      fill,
       ...special ? { special: true } : {},
       text: hasText ? {
-        content: normalizeTextContent(raw.content),
+        content: normalizedShapeText,
         align: normalizeVAlign(raw.vAlign) ?? "middle",
         defaultColor: normalizeColor(raw.defaultColor) ?? normalizeColor(raw.color) ?? "#333",
         defaultFontName: raw.fontName ?? "",
@@ -9570,6 +9512,7 @@ function mapElement(raw) {
   if (raw.type === "line") {
     return {
       ...base,
+      type: "line",
       start: toPxPair(raw.start),
       end: toPxPair(raw.end),
       broken: toPxPair(raw.broken),
@@ -9606,9 +9549,6 @@ function normalizeElement(element) {
       points: ["", ""]
     };
   }
-  if (element.type === "shape" && element.fill) {
-    element.fill = mapFillColor(element.fill) ?? element.fill;
-  }
   if (element.type === "text" && element.content) {
     element.content = normalizeTextContent(element.content);
   }
@@ -9659,20 +9599,21 @@ function mapOutline(raw) {
     style: raw.borderType
   };
 }
-function mapBaseElement(raw) {
+function mapBaseElement(raw, exportedMeta) {
   const outline = mapOutline(raw);
   const shadow = mapShadow(raw.shadow);
-  const { fill } = mapFill(raw.fill);
+  const fill = mapFill(raw.fill);
+  const exportedId = exportedMeta?.kind === "shape-text" ? `${exportedMeta.refId}__text` : exportedMeta?.refId;
   return {
     type: raw.type,
-    id: raw.id,
+    id: exportedId ?? raw.id,
     groupId: raw.groupId,
     left: toPx(raw.left),
     top: toPx(raw.top),
     width: toPx(raw.width),
     height: toPx(raw.height),
     rotate: raw.rotate,
-    fill: fill ?? void 0,
+    fill,
     opacity: raw.opacity,
     outline: outline ?? void 0,
     shadow: shadow ?? void 0,
@@ -9680,6 +9621,15 @@ function mapBaseElement(raw) {
     flipV: raw.isFlipV
   };
 }
+function isExportedTextShape(raw, exportedMeta) {
+  if (raw?.type !== "shape" || !raw?.content) return false;
+  return exportedMeta?.kind === "text" || exportedMeta?.kind === "shape-text";
+}
+function hasRenderableText(content) {
+  if (!content) return false;
+  const plainText = content.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
+  return plainText.length > 0;
+}
 
 // slide-normalizer.ts
 var ID_ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_";
@@ -9694,7 +9644,8 @@ function normalizeSlide(slide, index) {
     const orderB = typeof b?.order === "number" ? b.order : 0;
     return orderA - orderB;
   });
-  const elements = flattenElements(orderedElements).map((element, elementIndex) => {
+  const restoredElements = restoreExportedRoundTripElements(orderedElements);
+  const elements = flattenElements(restoredElements).map((element, elementIndex) => {
     if (!element.id) {
       element.id = makeId(`slide-${index}-element-${elementIndex}-${element.type}`);
     }
@@ -9702,7 +9653,7 @@ function normalizeSlide(slide, index) {
   });
   return {
     id: slide?.id ?? slide?.slideId ?? makeId(`slide-${index}`),
-    background: backgroundFill.fill ? { type: "solid", color: backgroundFill.fill } : backgroundFill.pattern ? { type: "image", src: backgroundFill.pattern } : void 0,
+    background: backgroundFill,
     elements,
     remark: slide?.remark ?? ""
   };
@@ -9719,6 +9670,44 @@ function makeId(seed) {
   }
   return id;
 }
+function restoreExportedRoundTripElements(elements) {
+  const restored = elements.map((element) => {
+    if (element?.type === "group" && Array.isArray(element.elements)) {
+      return {
+        ...element,
+        elements: restoreExportedRoundTripElements(element.elements)
+      };
+    }
+    return element;
+  });
+  const shapesByRefId = /* @__PURE__ */ new Map();
+  for (const element of restored) {
+    const meta = parseExportedObjectName(element?.name);
+    if (meta?.kind === "shape") {
+      shapesByRefId.set(meta.refId, element);
+    }
+  }
+  return restored.filter((element) => {
+    const meta = parseExportedObjectName(element?.name);
+    if (meta?.kind !== "shape-text") {
+      return true;
+    }
+    const targetShape = shapesByRefId.get(meta.refId);
+    if (!targetShape || targetShape.type !== "shape") {
+      return true;
+    }
+    mergeShapeText(targetShape, element);
+    return false;
+  });
+}
+function mergeShapeText(targetShape, textShape) {
+  if (!targetShape.content && textShape?.content) {
+    targetShape.content = textShape.content;
+  }
+  if (textShape?.vAlign) {
+    targetShape.vAlign = textShape.vAlign;
+  }
+}
 function hashSeed(value) {
   let hash = 1779033703 ^ value.length;
   for (let index = 0; index < value.length; index += 1) {
@@ -9752,49 +9741,14 @@ var DEFAULT_THEME = {
 };
 async function parsePptxToJson(file) {
   const fileBuffer = await file.arrayBuffer();
-  const zip = await JSZip2.loadAsync(fileBuffer);
-  const embedded = ENABLE_DECK_JSON ? await resolveEmbeddedDeck(zip) : null;
-  if (embedded?.deck) {
-    return {
-      deck: embedded.deck,
-      warnings: embedded.warnings
-    };
-  }
   return {
     deck: await buildDeckFromPptx(fileBuffer),
-    warnings: embedded?.warnings ?? []
+    warnings: []
   };
 }
-async function resolveEmbeddedDeck(zip) {
-  const embeddedFile = zip.file(PPTX_JSON_PAYLOAD_PATH) ?? Object.values(zip.files).find(
-    (entry) => entry.name.endsWith(`/${PPTX_JSON_PAYLOAD_PATH}`)
-  ) ?? null;
-  if (!embeddedFile) {
-    return null;
-  }
-  const payloadText = await embeddedFile.async("string");
-  try {
-    const parsed = JSON.parse(payloadText);
-    if (isDeckEnvelope(parsed) && parsed.deck) {
-      return {
-        deck: parsed.deck,
-        warnings: parsed.version && parsed.version !== PPTX_JSON_PAYLOAD_VERSION ? [
-          `Embedded JSON payload version ${parsed.version} differs from ${PPTX_JSON_PAYLOAD_VERSION}.`
-        ] : []
-      };
-    }
-    return {
-      deck: parsed,
-      warnings: []
-    };
-  } catch {
-    return {
-      warnings: ["Embedded JSON payload could not be parsed. Falling back to PPTX parsing."]
-    };
-  }
-}
-function isDeckEnvelope(payload) {
-  return typeof payload === "object" && payload !== null && "deck" in payload;
+function normalizeDeck(value) {
+  const document = parseDocument(value);
+  return document;
 }
 async function buildDeckFromPptx(buffer) {
   const pptxJson = await parse2(buffer);
@@ -9804,7 +9758,7 @@ async function buildDeckFromPptx(buffer) {
   const slides = (Array.isArray(pptxJson.slides) ? pptxJson.slides : []).map(
     (slide, index) => normalizeSlide(slide, index)
   );
-  return {
+  return normalizeDeck({
     title: DEFAULT_DECK_TITLE,
     width,
     height,
@@ -9813,7 +9767,7 @@ async function buildDeckFromPptx(buffer) {
       themeColors
     },
     slides
-  };
+  });
 }
 function mapThemeColors(pptxJson) {
   if (!Array.isArray(pptxJson.themeColors)) {