pptx-viewer-core 1.1.32 → 1.1.34

package/dist/index.js

@@ -1584,8 +1584,8 @@ var DEFAULT_COLORS = {
 };
 var DEFAULT_MAJOR_FONT = "Calibri Light";
 var DEFAULT_MINOR_FONT = "Calibri";
-function hexToRgb(hex7) {
-  return hex7.replace(/^#/, "").toUpperCase();
+function hexToRgb(hex8) {
+  return hex8.replace(/^#/, "").toUpperCase();
 }
 function isoNow() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d+Z$/, "Z");
@@ -4258,8 +4258,8 @@ var PptxColorTransformCodec = class {
   clampUnitInterval(value) {
     return Math.min(1, Math.max(0, value));
   }
-  hexToRgb(hex7) {
-    const normalized = hex7.replace("#", "");
+  hexToRgb(hex8) {
+    const normalized = hex8.replace("#", "");
     if (!/^[0-9a-fA-F]{6}$/.test(normalized)) {
       return void 0;
     }
@@ -5769,7 +5769,7 @@ var PptxColorStyleCodec = class {
       parseColor: (colorNode, placeholderColor) => this.parseColor(colorNode, placeholderColor),
       extractColorOpacity: (colorNode) => this.extractColorOpacity(colorNode),
       clampUnitInterval: (value) => this.clampUnitInterval(value),
-      hexToRgb: (hex7) => this.hexToRgb(hex7),
+      hexToRgb: (hex8) => this.hexToRgb(hex8),
       rgbToHex: (r, g, b) => this.rgbToHex(r, g, b)
     });
     this.shapeEffectXmlCodec = new PptxShapeEffectXmlCodec({
@@ -5792,8 +5792,8 @@ var PptxColorStyleCodec = class {
   clampUnitInterval(value) {
     return this.colorTransformCodec.clampUnitInterval(value);
   }
-  hexToRgb(hex7) {
-    return this.colorTransformCodec.hexToRgb(hex7);
+  hexToRgb(hex8) {
+    return this.colorTransformCodec.hexToRgb(hex8);
   }
   rgbToHex(r, g, b) {
     return this.colorTransformCodec.rgbToHex(r, g, b);
@@ -5964,9 +5964,9 @@ function normalizeHex(value) {
   if (raw.length === 0) {
     return "";
   }
-  const hex7 = raw.replace(/^#/, "");
-  if (/^[0-9a-fA-F]{6}$/.test(hex7)) {
-    return hex7.toUpperCase();
+  const hex8 = raw.replace(/^#/, "");
+  if (/^[0-9a-fA-F]{6}$/.test(hex8)) {
+    return hex8.toUpperCase();
   }
   return raw.toLowerCase();
 }
@@ -5976,8 +5976,8 @@ function colorsEqual(left, right) {
   }
   return normalizeHex(left) === normalizeHex(right);
 }
-function buildSrgbColorChoice(hex7, opacity) {
-  const normalized = String(hex7 || "").replace(/^#/, "");
+function buildSrgbColorChoice(hex8, opacity) {
+  const normalized = String(hex8 || "").replace(/^#/, "");
   const srgb = { "@_val": normalized };
   if (typeof opacity === "number" && Number.isFinite(opacity) && opacity >= 0 && opacity < 1) {
     const alphaPct = Math.round(Math.max(0, Math.min(1, opacity)) * 1e5);
@@ -6984,15 +6984,15 @@ var PptxMediaDataParser = class {
 
 // src/core/utils/ole-utils.ts
 var PROG_ID_MAP = [
-  { pattern: /^Excel\./i, type: "excel", extension: "xlsx" },
-  { pattern: /^Word\./i, type: "word", extension: "docx" },
-  { pattern: /^PowerPoint\./i, type: "excel", extension: "pptx" },
-  { pattern: /^Visio\./i, type: "visio", extension: "vsdx" },
-  { pattern: /^Equation\./i, type: "mathtype", extension: "wmf" },
-  { pattern: /^MathType/i, type: "mathtype", extension: "wmf" },
-  { pattern: /^AcroExch\./i, type: "pdf", extension: "pdf" },
-  { pattern: /^Acrobat\./i, type: "pdf", extension: "pdf" },
-  { pattern: /^Package$/i, type: "package", extension: "bin" }
+  { pattern: /^Excel\./iu, type: "excel", extension: "xlsx" },
+  { pattern: /^Word\./iu, type: "word", extension: "docx" },
+  { pattern: /^PowerPoint\./iu, type: "excel", extension: "pptx" },
+  { pattern: /^Visio\./iu, type: "visio", extension: "vsdx" },
+  { pattern: /^Equation\./iu, type: "mathtype", extension: "wmf" },
+  { pattern: /^MathType/iu, type: "mathtype", extension: "wmf" },
+  { pattern: /^AcroExch\./iu, type: "pdf", extension: "pdf" },
+  { pattern: /^Acrobat\./iu, type: "pdf", extension: "pdf" },
+  { pattern: /^Package$/iu, type: "package", extension: "bin" }
 ];
 var CLSID_MAP = /* @__PURE__ */ new Map([
   // Excel Workbook
@@ -7019,7 +7019,7 @@ function detectOleObjectType(progId, clsId) {
     }
   }
   if (clsId) {
-    const normalised = clsId.replace(/[{}]/g, "").toUpperCase().trim();
+    const normalised = clsId.replace(/[{}]/gu, "").toUpperCase().trim();
     const match = CLSID_MAP.get(normalised);
     if (match) {
       return { oleObjectType: match.type, oleFileExtension: match.extension };
@@ -7041,6 +7041,38 @@ function inferOleExtensionFromTarget(oleTarget) {
   }
   return void 0;
 }
+var OLE_EXTENSION_MIME_MAP = /* @__PURE__ */ new Map([
+  ["xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"],
+  ["xlsm", "application/vnd.ms-excel.sheet.macroEnabled.12"],
+  ["xls", "application/vnd.ms-excel"],
+  ["docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"],
+  ["docm", "application/vnd.ms-word.document.macroEnabled.12"],
+  ["doc", "application/msword"],
+  ["pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation"],
+  ["ppt", "application/vnd.ms-powerpoint"],
+  ["vsdx", "application/vnd.ms-visio.drawing"],
+  ["vsd", "application/vnd.visio"],
+  ["pdf", "application/pdf"],
+  ["rtf", "application/rtf"],
+  ["txt", "text/plain"],
+  ["csv", "text/csv"],
+  ["png", "image/png"],
+  ["jpg", "image/jpeg"],
+  ["jpeg", "image/jpeg"],
+  ["gif", "image/gif"],
+  ["wmf", "image/wmf"],
+  ["emf", "image/emf"],
+  ["zip", "application/zip"]
+]);
+function mimeTypeForOleFile(fileNameOrExtension) {
+  const fallback = "application/octet-stream";
+  if (!fileNameOrExtension) {
+    return fallback;
+  }
+  const lastDot = fileNameOrExtension.lastIndexOf(".");
+  const ext = (lastDot === -1 ? fileNameOrExtension : fileNameOrExtension.slice(lastDot + 1)).toLowerCase().trim();
+  return OLE_EXTENSION_MIME_MAP.get(ext) ?? fallback;
+}
 function getOleObjectTypeLabel(oleObjectType) {
   switch (oleObjectType) {
     case "excel":
@@ -8767,6 +8799,7 @@ var PptxSlideLoaderService = class {
       if (mediaTimingMap.size > 0) {
         await params.enrichMediaElementsWithTiming(slideElements, mediaTimingMap);
       }
+      await params.enrichOleElementsWithEmbeddedData(slideElements, path);
       const elements = [...layoutElements, ...slideElements];
       const backgroundColor = params.extractBackgroundColor(slideXmlObj) || await params.getLayoutBackgroundColor(path);
       const backgroundGradient = params.extractBackgroundGradient(slideXmlObj) || await params.getLayoutBackgroundGradient(path);
@@ -9489,9 +9522,9 @@ function decodeKeyframeValue(valNode) {
   if (strVal && strVal["@_val"] !== void 0) {
     return { value: String(strVal["@_val"]), valueType: "str" };
   }
-  const boolVal2 = valNode["p:boolVal"];
-  if (boolVal2 && boolVal2["@_val"] !== void 0) {
-    const raw = boolVal2["@_val"];
+  const boolVal3 = valNode["p:boolVal"];
+  if (boolVal3 && boolVal3["@_val"] !== void 0) {
+    const raw = boolVal3["@_val"];
     const value = raw === "1" || raw === "true";
     return { value, valueType: "bool" };
   }
@@ -12348,6 +12381,321 @@ function resolveLayoutDisplayName(input) {
   return fallbackFromPath(input.path);
 }
 
+// src/core/utils/ole2-parser-types.ts
+var OLE_MAGIC = new Uint8Array([208, 207, 17, 224, 161, 27, 26, 225]);
+var ENDOFCHAIN = 4294967294;
+var FREESECT = 4294967295;
+var FATSECT = 4294967293;
+var MAXREGSECT = 4294967290;
+var ENTRY_TYPE_EMPTY = 0;
+var ENTRY_TYPE_STREAM = 2;
+var ENTRY_TYPE_ROOT = 5;
+var DIR_ENTRY_SIZE = 128;
+var Ole2ParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "Ole2ParseError";
+  }
+};
+
+// src/core/utils/ole2-parser-read.ts
+function parseOle2(buffer) {
+  const data = new Uint8Array(buffer);
+  const view = new DataView(buffer);
+  for (let i = 0; i < OLE_MAGIC.length; i++) {
+    if (data[i] !== OLE_MAGIC[i]) {
+      throw new Ole2ParseError("Not a valid OLE2 compound file");
+    }
+  }
+  view.getUint16(24, true);
+  const majorVersion = view.getUint16(26, true);
+  const byteOrder = view.getUint16(28, true);
+  if (byteOrder !== 65534) {
+    throw new Ole2ParseError("Invalid byte order mark");
+  }
+  const sectorSizePower = view.getUint16(30, true);
+  const miniSectorSizePower = view.getUint16(32, true);
+  const sectorSize = 1 << sectorSizePower;
+  const miniSectorSize = 1 << miniSectorSizePower;
+  const totalFATSectors = view.getUint32(44, true);
+  const firstDirectorySector = view.getUint32(48, true);
+  const miniStreamCutoff = view.getUint32(56, true);
+  const firstMiniFATSector = view.getUint32(60, true);
+  const totalMiniFATSectors = view.getUint32(64, true);
+  const firstDIFATSector = view.getUint32(68, true);
+  const totalDIFATSectors = view.getUint32(72, true);
+  function sectorOffset(sector) {
+    return (sector + 1) * sectorSize;
+  }
+  function readSector(sector) {
+    const offset = sectorOffset(sector);
+    if (offset + sectorSize > data.length) {
+      throw new Ole2ParseError(
+        `Sector ${sector} at offset ${offset} exceeds file size ${data.length}`
+      );
+    }
+    return data.subarray(offset, offset + sectorSize);
+  }
+  const fatSectors = [];
+  for (let i = 0; i < 109 && fatSectors.length < totalFATSectors; i++) {
+    const sector = view.getUint32(76 + i * 4, true);
+    if (sector <= MAXREGSECT) {
+      fatSectors.push(sector);
+    }
+  }
+  let difatSector = firstDIFATSector;
+  for (let d = 0; d < totalDIFATSectors && difatSector <= MAXREGSECT; d++) {
+    const difatData = readSector(difatSector);
+    const difatView = new DataView(difatData.buffer, difatData.byteOffset, difatData.byteLength);
+    const entriesPerSector = (sectorSize - 4) / 4;
+    for (let i = 0; i < entriesPerSector && fatSectors.length < totalFATSectors; i++) {
+      const sector = difatView.getUint32(i * 4, true);
+      if (sector <= MAXREGSECT) {
+        fatSectors.push(sector);
+      }
+    }
+    difatSector = difatView.getUint32(sectorSize - 4, true);
+  }
+  const fatEntries = [];
+  for (const fatSector of fatSectors) {
+    const fatData = readSector(fatSector);
+    const fatView = new DataView(fatData.buffer, fatData.byteOffset, fatData.byteLength);
+    for (let i = 0; i < sectorSize / 4; i++) {
+      fatEntries.push(fatView.getUint32(i * 4, true));
+    }
+  }
+  function readSectorChain(startSector) {
+    const sectors = [];
+    let current = startSector;
+    const visited = /* @__PURE__ */ new Set();
+    while (current <= MAXREGSECT) {
+      if (visited.has(current)) {
+        throw new Ole2ParseError(`Circular reference in FAT chain at sector ${current}`);
+      }
+      visited.add(current);
+      sectors.push(readSector(current));
+      current = fatEntries[current] ?? ENDOFCHAIN;
+    }
+    const totalLength = sectors.length * sectorSize;
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const sector of sectors) {
+      result.set(sector, offset);
+      offset += sectorSize;
+    }
+    return result;
+  }
+  function readStream(startSector, size) {
+    const raw = readSectorChain(startSector);
+    return raw.subarray(0, Math.min(size, raw.length));
+  }
+  const miniFatEntries = [];
+  if (firstMiniFATSector <= MAXREGSECT && totalMiniFATSectors > 0) {
+    const miniFatRaw = readSectorChain(firstMiniFATSector);
+    const miniFatView = new DataView(
+      miniFatRaw.buffer,
+      miniFatRaw.byteOffset,
+      miniFatRaw.byteLength
+    );
+    for (let i = 0; i < miniFatRaw.length / 4; i++) {
+      miniFatEntries.push(miniFatView.getUint32(i * 4, true));
+    }
+  }
+  const dirRaw = readSectorChain(firstDirectorySector);
+  const numEntries = Math.floor(dirRaw.length / DIR_ENTRY_SIZE);
+  const entries = [];
+  for (let i = 0; i < numEntries; i++) {
+    const entryOffset = i * DIR_ENTRY_SIZE;
+    const entryView = new DataView(dirRaw.buffer, dirRaw.byteOffset + entryOffset, DIR_ENTRY_SIZE);
+    const nameLen = entryView.getUint16(64, true);
+    const objectType = entryView.getUint8(66);
+    if (objectType === ENTRY_TYPE_EMPTY) {
+      continue;
+    }
+    const nameBytes = Math.max(0, nameLen - 2);
+    let name = "";
+    for (let j = 0; j < nameBytes; j += 2) {
+      name += String.fromCharCode(entryView.getUint16(j, true));
+    }
+    const leftSiblingId = entryView.getUint32(68, true);
+    const rightSiblingId = entryView.getUint32(72, true);
+    const childId = entryView.getUint32(76, true);
+    const startSector = entryView.getUint32(116, true);
+    const sizeLow = entryView.getUint32(120, true);
+    let size = sizeLow;
+    if (majorVersion === 4) {
+      entryView.getUint32(124, true);
+      size = sizeLow;
+    }
+    entries.push({
+      name,
+      type: objectType,
+      startSector,
+      size,
+      childId: childId === 4294967295 ? -1 : childId,
+      leftSiblingId: leftSiblingId === 4294967295 ? -1 : leftSiblingId,
+      rightSiblingId: rightSiblingId === 4294967295 ? -1 : rightSiblingId
+    });
+  }
+  const rootEntry = entries.find((e) => e.type === ENTRY_TYPE_ROOT);
+  let miniStreamData;
+  if (rootEntry && rootEntry.startSector <= MAXREGSECT) {
+    miniStreamData = readSectorChain(rootEntry.startSector);
+  }
+  function readMiniStream(startSector, size) {
+    if (!miniStreamData) {
+      throw new Ole2ParseError("Mini stream container not found");
+    }
+    const sectors = [];
+    let current = startSector;
+    const visited = /* @__PURE__ */ new Set();
+    while (current <= MAXREGSECT) {
+      if (visited.has(current)) {
+        throw new Ole2ParseError(`Circular reference in mini FAT chain at sector ${current}`);
+      }
+      visited.add(current);
+      const offset2 = current * miniSectorSize;
+      sectors.push(miniStreamData.subarray(offset2, offset2 + miniSectorSize));
+      current = miniFatEntries[current] ?? ENDOFCHAIN;
+    }
+    const totalLength = sectors.length * miniSectorSize;
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const sector of sectors) {
+      result.set(sector, offset);
+      offset += miniSectorSize;
+    }
+    return result.subarray(0, Math.min(size, result.length));
+  }
+  function getStream(name) {
+    const entry = entries.find(
+      (e) => (e.type === ENTRY_TYPE_STREAM || e.type === ENTRY_TYPE_ROOT) && e.name === name
+    );
+    if (!entry) {
+      return void 0;
+    }
+    if (entry.size < miniStreamCutoff && entry.type !== ENTRY_TYPE_ROOT) {
+      return readMiniStream(entry.startSector, entry.size);
+    }
+    return readStream(entry.startSector, entry.size);
+  }
+  return { entries, getStream };
+}
+
+// src/core/utils/ole-embedded-extract.ts
+function oleBytesToDataUrl(bytes, mimeType) {
+  let binary = "";
+  const chunkSize = 32768;
+  for (let i = 0; i < bytes.length; i += chunkSize) {
+    const chunk = bytes.subarray(i, i + chunkSize);
+    binary += String.fromCharCode.apply(null, Array.from(chunk));
+  }
+  return `data:${mimeType};base64,${btoa(binary)}`;
+}
+var OLE10_NATIVE_STREAM_NAMES = [`${String.fromCharCode(1)}Ole10Native`, "Ole10Native"];
+var CONTENTS_STREAM = "CONTENTS";
+function isOle2CompoundFile(bytes) {
+  if (bytes.length < OLE_MAGIC.length) {
+    return false;
+  }
+  for (let i = 0; i < OLE_MAGIC.length; i++) {
+    if (bytes[i] !== OLE_MAGIC[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function baseNameFromPath(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) {
+    return void 0;
+  }
+  const lastSlash = Math.max(trimmed.lastIndexOf("\\"), trimmed.lastIndexOf("/"));
+  const base = lastSlash === -1 ? trimmed : trimmed.slice(lastSlash + 1);
+  return base.length > 0 ? base : void 0;
+}
+function readAsciiZ(bytes, offset) {
+  let end = offset;
+  while (end < bytes.length && bytes[end] !== 0) {
+    end++;
+  }
+  let value = "";
+  for (let i = offset; i < end; i++) {
+    value += String.fromCharCode(bytes[i]);
+  }
+  return { value, next: end < bytes.length ? end + 1 : end };
+}
+function decodeOle10Native(stream) {
+  if (stream.length < 6) {
+    return void 0;
+  }
+  const view = new DataView(stream.buffer, stream.byteOffset, stream.byteLength);
+  const declaredSize = view.getUint32(0, true);
+  const bodyEnd = Math.min(stream.length, 4 + declaredSize);
+  if (bodyEnd <= 4) {
+    return void 0;
+  }
+  let cursor = 6;
+  const label = readAsciiZ(stream, cursor);
+  cursor = label.next;
+  const sourcePath = readAsciiZ(stream, cursor);
+  cursor = sourcePath.next;
+  if (cursor + 8 > stream.length) {
+    return void 0;
+  }
+  cursor += 4;
+  const tempLen = view.getUint32(cursor, true);
+  cursor += 4;
+  if (tempLen > stream.length) {
+    return void 0;
+  }
+  cursor += tempLen;
+  if (cursor + 4 > stream.length) {
+    return void 0;
+  }
+  const nativeSize = view.getUint32(cursor, true);
+  cursor += 4;
+  const dataEnd = Math.min(stream.length, cursor + nativeSize);
+  if (dataEnd <= cursor) {
+    return void 0;
+  }
+  const data = stream.subarray(cursor, dataEnd);
+  const fileName = baseNameFromPath(sourcePath.value) ?? baseNameFromPath(label.value) ?? void 0;
+  return { fileName, data };
+}
+function unwrapOleEmbedding(bytes) {
+  if (bytes.length === 0) {
+    return { data: bytes };
+  }
+  if (!isOle2CompoundFile(bytes)) {
+    return { data: bytes };
+  }
+  try {
+    const buffer = bytes.buffer.slice(
+      bytes.byteOffset,
+      bytes.byteOffset + bytes.byteLength
+    );
+    const ole = parseOle2(buffer);
+    for (const name of OLE10_NATIVE_STREAM_NAMES) {
+      const ole10 = ole.getStream(name);
+      if (!ole10) {
+        continue;
+      }
+      const decoded = decodeOle10Native(ole10);
+      if (decoded && decoded.data.length > 0) {
+        return decoded;
+      }
+      return { data: ole10 };
+    }
+    const contents = ole.getStream(CONTENTS_STREAM);
+    if (contents && contents.length > 0) {
+      return { data: contents };
+    }
+  } catch {
+  }
+  return { data: bytes };
+}
+
 // src/core/utils/signature-constants.ts
 var DIGITAL_SIGNATURE_ORIGIN_REL_TYPE = "http://schemas.openxmlformats.org/package/2006/relationships/digital-signature/origin";
 var DIGITAL_SIGNATURE_REL_TYPE = "http://schemas.openxmlformats.org/package/2006/relationships/digital-signature/signature";
@@ -12737,13 +13085,13 @@ function generateFontGuid() {
       bytes[i] = Math.floor(Math.random() * 256);
     }
   }
-  const hex7 = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0").toUpperCase()).join("");
+  const hex8 = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0").toUpperCase()).join("");
   return [
-    hex7.substring(0, 8),
-    hex7.substring(8, 12),
-    hex7.substring(12, 16),
-    hex7.substring(16, 20),
-    hex7.substring(20, 32)
+    hex8.substring(0, 8),
+    hex8.substring(8, 12),
+    hex8.substring(12, 16),
+    hex8.substring(16, 20),
+    hex8.substring(20, 32)
   ].join("-");
 }
 function detectFontFormat(data) {
@@ -13064,7 +13412,8 @@ function parseSeriesDataPoints(seriesNode, xmlLookup, colorParser) {
   }).filter((dp) => dp !== void 0);
 }
 function parseSeriesDataLabels(seriesNode, xmlLookup) {
-  const dLblNodes = xmlLookup.getChildrenArrayByLocalName(seriesNode, "dLbl");
+  const dLblsNode = xmlLookup.getChildByLocalName(seriesNode, "dLbls");
+  const dLblNodes = dLblsNode ? xmlLookup.getChildrenArrayByLocalName(dLblsNode, "dLbl") : xmlLookup.getChildrenArrayByLocalName(seriesNode, "dLbl");
   if (dLblNodes.length === 0) {
     return [];
   }
@@ -13074,6 +13423,10 @@ function parseSeriesDataLabels(seriesNode, xmlLookup) {
     if (idx === void 0) {
       return void 0;
     }
+    const deleteNode = xmlLookup.getChildByLocalName(node, "delete");
+    if (deleteNode?.["@_val"] === "1" || deleteNode?.["@_val"] === "true") {
+      return { idx };
+    }
     const result = { idx };
     const boolFields = [
       ["showVal", "showVal"],
@@ -13421,6 +13774,29 @@ function collectAxisTextValues(node, results) {
   }
 }
 
+// src/core/utils/chart-container-type-map.ts
+var CONTAINER_LOCAL_NAME_TO_TYPE = {
+  barChart: "bar",
+  bar3DChart: "bar3D",
+  lineChart: "line",
+  line3DChart: "line3D",
+  pieChart: "pie",
+  pie3DChart: "pie3D",
+  ofPieChart: "ofPie",
+  doughnutChart: "doughnut",
+  areaChart: "area",
+  area3DChart: "area3D",
+  scatterChart: "scatter",
+  bubbleChart: "bubble",
+  radarChart: "radar",
+  stockChart: "stock",
+  surfaceChart: "surface",
+  surface3DChart: "surface"
+};
+function chartContainerLocalNameToType(localName) {
+  return CONTAINER_LOCAL_NAME_TO_TYPE[localName];
+}
+
 // src/core/utils/chart-cx-parser.ts
 function extractCxSeriesColor(ser, xmlLookup) {
   const spPr = xmlLookup.getChildByLocalName(ser, "spPr");
@@ -15176,10 +15552,10 @@ function applyBackgroundColorToCSld(cSld, backgroundColor) {
     delete cSld["p:bg"];
     return;
   }
-  const hex7 = backgroundColor.replace(/^#/, "").toUpperCase();
+  const hex8 = backgroundColor.replace(/^#/, "").toUpperCase();
   cSld["p:bg"] = {
     "p:bgPr": {
-      "a:solidFill": { "a:srgbClr": { "@_val": hex7 } },
+      "a:solidFill": { "a:srgbClr": { "@_val": hex8 } },
       "a:effectLst": {}
     }
   };
@@ -15802,8 +16178,8 @@ function accentColor(index, themeColorMap) {
   }
   return DEFAULT_ACCENT_COLORS[index % DEFAULT_ACCENT_COLORS.length];
 }
-function lighten(hex7, amount) {
-  const parsed = hex7.replace("#", "");
+function lighten(hex8, amount) {
+  const parsed = hex8.replace("#", "");
   const r = parseInt(parsed.substring(0, 2), 16);
   const g = parseInt(parsed.substring(2, 4), 16);
   const b = parseInt(parsed.substring(4, 6), 16);
@@ -18286,14 +18662,14 @@ function resolveLayoutCategory(layoutType) {
 }
 
 // src/core/utils/encryption-detection.ts
-var OLE_MAGIC = new Uint8Array([208, 207, 17, 224, 161, 27, 26, 225]);
+var OLE_MAGIC2 = new Uint8Array([208, 207, 17, 224, 161, 27, 26, 225]);
 var ZIP_MAGIC = new Uint8Array([80, 75]);
 function detectFileFormat(data) {
   if (data.byteLength < 8) {
     return { format: "unknown", encrypted: false };
   }
   const header = new Uint8Array(data, 0, 8);
-  if (OLE_MAGIC.every((byte, i) => header[i] === byte)) {
+  if (OLE_MAGIC2.every((byte, i) => header[i] === byte)) {
     return { format: "ole", encrypted: true };
   }
   if (header[0] === ZIP_MAGIC[0] && header[1] === ZIP_MAGIC[1]) {
@@ -18309,207 +18685,6 @@ var EncryptedFileError = class extends Error {
   }
 };
 
-// src/core/utils/ole2-parser-types.ts
-var OLE_MAGIC2 = new Uint8Array([208, 207, 17, 224, 161, 27, 26, 225]);
-var ENDOFCHAIN = 4294967294;
-var FREESECT = 4294967295;
-var FATSECT = 4294967293;
-var MAXREGSECT = 4294967290;
-var ENTRY_TYPE_EMPTY = 0;
-var ENTRY_TYPE_STREAM = 2;
-var ENTRY_TYPE_ROOT = 5;
-var DIR_ENTRY_SIZE = 128;
-var Ole2ParseError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "Ole2ParseError";
-  }
-};
-
-// src/core/utils/ole2-parser-read.ts
-function parseOle2(buffer) {
-  const data = new Uint8Array(buffer);
-  const view = new DataView(buffer);
-  for (let i = 0; i < OLE_MAGIC2.length; i++) {
-    if (data[i] !== OLE_MAGIC2[i]) {
-      throw new Ole2ParseError("Not a valid OLE2 compound file");
-    }
-  }
-  view.getUint16(24, true);
-  const majorVersion = view.getUint16(26, true);
-  const byteOrder = view.getUint16(28, true);
-  if (byteOrder !== 65534) {
-    throw new Ole2ParseError("Invalid byte order mark");
-  }
-  const sectorSizePower = view.getUint16(30, true);
-  const miniSectorSizePower = view.getUint16(32, true);
-  const sectorSize = 1 << sectorSizePower;
-  const miniSectorSize = 1 << miniSectorSizePower;
-  const totalFATSectors = view.getUint32(44, true);
-  const firstDirectorySector = view.getUint32(48, true);
-  const miniStreamCutoff = view.getUint32(56, true);
-  const firstMiniFATSector = view.getUint32(60, true);
-  const totalMiniFATSectors = view.getUint32(64, true);
-  const firstDIFATSector = view.getUint32(68, true);
-  const totalDIFATSectors = view.getUint32(72, true);
-  function sectorOffset(sector) {
-    return (sector + 1) * sectorSize;
-  }
-  function readSector(sector) {
-    const offset = sectorOffset(sector);
-    if (offset + sectorSize > data.length) {
-      throw new Ole2ParseError(
-        `Sector ${sector} at offset ${offset} exceeds file size ${data.length}`
-      );
-    }
-    return data.subarray(offset, offset + sectorSize);
-  }
-  const fatSectors = [];
-  for (let i = 0; i < 109 && fatSectors.length < totalFATSectors; i++) {
-    const sector = view.getUint32(76 + i * 4, true);
-    if (sector <= MAXREGSECT) {
-      fatSectors.push(sector);
-    }
-  }
-  let difatSector = firstDIFATSector;
-  for (let d = 0; d < totalDIFATSectors && difatSector <= MAXREGSECT; d++) {
-    const difatData = readSector(difatSector);
-    const difatView = new DataView(difatData.buffer, difatData.byteOffset, difatData.byteLength);
-    const entriesPerSector = (sectorSize - 4) / 4;
-    for (let i = 0; i < entriesPerSector && fatSectors.length < totalFATSectors; i++) {
-      const sector = difatView.getUint32(i * 4, true);
-      if (sector <= MAXREGSECT) {
-        fatSectors.push(sector);
-      }
-    }
-    difatSector = difatView.getUint32(sectorSize - 4, true);
-  }
-  const fatEntries = [];
-  for (const fatSector of fatSectors) {
-    const fatData = readSector(fatSector);
-    const fatView = new DataView(fatData.buffer, fatData.byteOffset, fatData.byteLength);
-    for (let i = 0; i < sectorSize / 4; i++) {
-      fatEntries.push(fatView.getUint32(i * 4, true));
-    }
-  }
-  function readSectorChain(startSector) {
-    const sectors = [];
-    let current = startSector;
-    const visited = /* @__PURE__ */ new Set();
-    while (current <= MAXREGSECT) {
-      if (visited.has(current)) {
-        throw new Ole2ParseError(`Circular reference in FAT chain at sector ${current}`);
-      }
-      visited.add(current);
-      sectors.push(readSector(current));
-      current = fatEntries[current] ?? ENDOFCHAIN;
-    }
-    const totalLength = sectors.length * sectorSize;
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const sector of sectors) {
-      result.set(sector, offset);
-      offset += sectorSize;
-    }
-    return result;
-  }
-  function readStream(startSector, size) {
-    const raw = readSectorChain(startSector);
-    return raw.subarray(0, Math.min(size, raw.length));
-  }
-  const miniFatEntries = [];
-  if (firstMiniFATSector <= MAXREGSECT && totalMiniFATSectors > 0) {
-    const miniFatRaw = readSectorChain(firstMiniFATSector);
-    const miniFatView = new DataView(
-      miniFatRaw.buffer,
-      miniFatRaw.byteOffset,
-      miniFatRaw.byteLength
-    );
-    for (let i = 0; i < miniFatRaw.length / 4; i++) {
-      miniFatEntries.push(miniFatView.getUint32(i * 4, true));
-    }
-  }
-  const dirRaw = readSectorChain(firstDirectorySector);
-  const numEntries = Math.floor(dirRaw.length / DIR_ENTRY_SIZE);
-  const entries = [];
-  for (let i = 0; i < numEntries; i++) {
-    const entryOffset = i * DIR_ENTRY_SIZE;
-    const entryView = new DataView(dirRaw.buffer, dirRaw.byteOffset + entryOffset, DIR_ENTRY_SIZE);
-    const nameLen = entryView.getUint16(64, true);
-    const objectType = entryView.getUint8(66);
-    if (objectType === ENTRY_TYPE_EMPTY) {
-      continue;
-    }
-    const nameBytes = Math.max(0, nameLen - 2);
-    let name = "";
-    for (let j = 0; j < nameBytes; j += 2) {
-      name += String.fromCharCode(entryView.getUint16(j, true));
-    }
-    const leftSiblingId = entryView.getUint32(68, true);
-    const rightSiblingId = entryView.getUint32(72, true);
-    const childId = entryView.getUint32(76, true);
-    const startSector = entryView.getUint32(116, true);
-    const sizeLow = entryView.getUint32(120, true);
-    let size = sizeLow;
-    if (majorVersion === 4) {
-      entryView.getUint32(124, true);
-      size = sizeLow;
-    }
-    entries.push({
-      name,
-      type: objectType,
-      startSector,
-      size,
-      childId: childId === 4294967295 ? -1 : childId,
-      leftSiblingId: leftSiblingId === 4294967295 ? -1 : leftSiblingId,
-      rightSiblingId: rightSiblingId === 4294967295 ? -1 : rightSiblingId
-    });
-  }
-  const rootEntry = entries.find((e) => e.type === ENTRY_TYPE_ROOT);
-  let miniStreamData;
-  if (rootEntry && rootEntry.startSector <= MAXREGSECT) {
-    miniStreamData = readSectorChain(rootEntry.startSector);
-  }
-  function readMiniStream(startSector, size) {
-    if (!miniStreamData) {
-      throw new Ole2ParseError("Mini stream container not found");
-    }
-    const sectors = [];
-    let current = startSector;
-    const visited = /* @__PURE__ */ new Set();
-    while (current <= MAXREGSECT) {
-      if (visited.has(current)) {
-        throw new Ole2ParseError(`Circular reference in mini FAT chain at sector ${current}`);
-      }
-      visited.add(current);
-      const offset2 = current * miniSectorSize;
-      sectors.push(miniStreamData.subarray(offset2, offset2 + miniSectorSize));
-      current = miniFatEntries[current] ?? ENDOFCHAIN;
-    }
-    const totalLength = sectors.length * miniSectorSize;
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const sector of sectors) {
-      result.set(sector, offset);
-      offset += miniSectorSize;
-    }
-    return result.subarray(0, Math.min(size, result.length));
-  }
-  function getStream(name) {
-    const entry = entries.find(
-      (e) => (e.type === ENTRY_TYPE_STREAM || e.type === ENTRY_TYPE_ROOT) && e.name === name
-    );
-    if (!entry) {
-      return void 0;
-    }
-    if (entry.size < miniStreamCutoff && entry.type !== ENTRY_TYPE_ROOT) {
-      return readMiniStream(entry.startSector, entry.size);
-    }
-    return readStream(entry.startSector, entry.size);
-  }
-  return { entries, getStream };
-}
-
 // src/core/utils/ole2-parser-write.ts
 function compareDirEntryNames(a, b) {
   if (a.length !== b.length) {
@@ -18556,7 +18731,7 @@ function writeInt32Sectors(outBytes, int32Data, firstSector, numSectors, sectorS
   }
 }
 function writeHeader(outView, outBytes, params) {
-  outBytes.set(OLE_MAGIC2, 0);
+  outBytes.set(OLE_MAGIC, 0);
   outView.setUint16(24, 62, true);
   outView.setUint16(26, 3, true);
   outView.setUint16(28, 65534, true);
@@ -21418,11 +21593,11 @@ async function repairPptx(buffer) {
 }
 
 // src/core/utils/theme-switching.ts
-function normalizeHex2(hex7) {
-  if (!hex7) {
+function normalizeHex2(hex8) {
+  if (!hex8) {
     return "";
   }
-  return hex7.replace(/^#/, "").toUpperCase().slice(0, 6);
+  return hex8.replace(/^#/, "").toUpperCase().slice(0, 6);
 }
 function buildColorRemapTable(oldColorMap, newColorMap) {
   const remap = /* @__PURE__ */ new Map();
@@ -21616,8 +21791,8 @@ function applyThemeToData(data, newColorScheme, newFontScheme, themeName) {
 }
 
 // src/core/utils/accessibility-checker.ts
-function parseHexColor(hex7) {
-  const cleaned = hex7.replace(/^#/, "");
+function parseHexColor(hex8) {
+  const cleaned = hex8.replace(/^#/, "");
   if (!/^[\da-fA-F]+$/.test(cleaned)) {
     return null;
   }
@@ -24917,6 +25092,37 @@ function ensureArray6(v) {
   }
   return Array.isArray(v) ? v : [v];
 }
+function consolidateComboContainersInXml(plotArea, getLocalName) {
+  const containerKeys = Object.keys(plotArea).filter((k) => getLocalName(k).endsWith("Chart"));
+  if (containerKeys.length === 0) {
+    return void 0;
+  }
+  const primaryKey = containerKeys[0];
+  if (containerKeys.length === 1) {
+    return primaryKey;
+  }
+  const primary = plotArea[primaryKey];
+  if (!primary) {
+    return primaryKey;
+  }
+  const serKey = findKey4(primary, "ser", getLocalName) ?? "c:ser";
+  const allSeries = [];
+  for (const key of containerKeys) {
+    const container = plotArea[key];
+    if (!container) {
+      continue;
+    }
+    const containerSerKey = findKey4(container, "ser", getLocalName);
+    if (containerSerKey) {
+      allSeries.push(...ensureArray6(container[containerSerKey]));
+    }
+    if (key !== primaryKey) {
+      delete plotArea[key];
+    }
+  }
+  primary[serKey] = allSeries.length === 1 ? allSeries[0] : allSeries;
+  return primaryKey;
+}
 function effectiveContainers(series, chartLevelType) {
   return series.map((s) => {
     const t = s.seriesChartType ?? chartLevelType;
@@ -25368,6 +25574,146 @@ function applySeriesMarkerToXml(seriesNode, marker, getLocalName) {
   insertOrdered2(seriesNode, "c:marker", built, getLocalName);
 }
 
+// src/core/utils/chart-series-datalabel-serializer.ts
+function findKey9(obj, local, getLocalName) {
+  return Object.keys(obj).find((k) => getLocalName(k) === local);
+}
+function boolVal2(on) {
+  return { "@_val": on ? "1" : "0" };
+}
+var AFTER_DLBLS = /* @__PURE__ */ new Set(["cat", "val", "xVal", "yVal", "bubbleSize", "smooth", "extLst"]);
+var DLBLS_GROUP_ORDER = [
+  "numFmt",
+  "spPr",
+  "txPr",
+  "dLblPos",
+  "showLegendKey",
+  "showVal",
+  "showCatName",
+  "showSerName",
+  "showPercent",
+  "showBubbleSize",
+  "separator",
+  "showLeaderLines",
+  "leaderLines"
+];
+function buildDLbl(existing, label, getLocalName) {
+  const node = {};
+  node["c:idx"] = { "@_val": String(label.idx) };
+  const hasShow = label.showVal !== void 0 || label.showCatName !== void 0 || label.showSerName !== void 0 || label.showPercent !== void 0 || label.showLegendKey !== void 0 || label.showBubbleSize !== void 0;
+  const hasContent = hasShow || label.position !== void 0 || label.text !== void 0;
+  if (!hasContent) {
+    node["c:delete"] = { "@_val": "1" };
+    return node;
+  }
+  if (existing) {
+    const layoutKey = findKey9(existing, "layout", getLocalName);
+    if (layoutKey) {
+      node[layoutKey] = existing[layoutKey];
+    }
+  }
+  if (label.text !== void 0) {
+    node["c:tx"] = {
+      "c:rich": {
+        "a:bodyPr": {},
+        "a:lstStyle": {},
+        "a:p": { "a:r": { "a:t": label.text } }
+      }
+    };
+  } else if (existing) {
+    const txKey = findKey9(existing, "tx", getLocalName);
+    if (txKey) {
+      node[txKey] = existing[txKey];
+    }
+  }
+  if (existing) {
+    for (const local of ["numFmt", "spPr", "txPr"]) {
+      const k = findKey9(existing, local, getLocalName);
+      if (k) {
+        node[k] = existing[k];
+      }
+    }
+  }
+  if (label.position !== void 0) {
+    node["c:dLblPos"] = { "@_val": label.position };
+  }
+  if (label.showLegendKey !== void 0) {
+    node["c:showLegendKey"] = boolVal2(label.showLegendKey);
+  }
+  if (label.showVal !== void 0) {
+    node["c:showVal"] = boolVal2(label.showVal);
+  }
+  if (label.showCatName !== void 0) {
+    node["c:showCatName"] = boolVal2(label.showCatName);
+  }
+  if (label.showSerName !== void 0) {
+    node["c:showSerName"] = boolVal2(label.showSerName);
+  }
+  if (label.showPercent !== void 0) {
+    node["c:showPercent"] = boolVal2(label.showPercent);
+  }
+  if (label.showBubbleSize !== void 0) {
+    node["c:showBubbleSize"] = boolVal2(label.showBubbleSize);
+  }
+  return node;
+}
+function applySeriesDataLabelsToXml(seriesNode, dataLabels, getLocalName) {
+  const dLblsKey = findKey9(seriesNode, "dLbls", getLocalName);
+  const labels = dataLabels ?? [];
+  const existingByIdx = /* @__PURE__ */ new Map();
+  let groupChildren = [];
+  if (dLblsKey) {
+    const dLbls = seriesNode[dLblsKey];
+    const dLblKey = findKey9(dLbls, "dLbl", getLocalName);
+    if (dLblKey) {
+      const nodes = Array.isArray(dLbls[dLblKey]) ? dLbls[dLblKey] : [dLbls[dLblKey]];
+      for (const node of nodes) {
+        const idxKey = findKey9(node, "idx", getLocalName);
+        const idxNode = idxKey ? node[idxKey] : void 0;
+        const idx = idxNode ? Number.parseInt(String(idxNode["@_val"]), 10) : NaN;
+        if (Number.isFinite(idx)) {
+          existingByIdx.set(idx, node);
+        }
+      }
+    }
+    groupChildren = Object.keys(dLbls).filter((k) => getLocalName(k) !== "dLbl").map((k) => [k, dLbls[k]]);
+  }
+  if (labels.length === 0 && groupChildren.length === 0) {
+    if (dLblsKey) {
+      delete seriesNode[dLblsKey];
+    }
+    return;
+  }
+  const built = [...labels].sort((a, b) => a.idx - b.idx).map((label) => buildDLbl(existingByIdx.get(label.idx), label, getLocalName));
+  const newDLbls = {};
+  if (built.length > 0) {
+    newDLbls["c:dLbl"] = built.length === 1 ? built[0] : built;
+  }
+  const ordered = [...groupChildren].sort((a, b) => {
+    const ai = DLBLS_GROUP_ORDER.indexOf(getLocalName(a[0]));
+    const bi = DLBLS_GROUP_ORDER.indexOf(getLocalName(b[0]));
+    return (ai === -1 ? DLBLS_GROUP_ORDER.length : ai) - (bi === -1 ? DLBLS_GROUP_ORDER.length : bi);
+  });
+  for (const [k, v] of ordered) {
+    newDLbls[k] = v;
+  }
+  if (dLblsKey) {
+    seriesNode[dLblsKey] = newDLbls;
+    return;
+  }
+  const keys = Object.keys(seriesNode);
+  const beforeIdx = keys.findIndex((k) => AFTER_DLBLS.has(getLocalName(k)));
+  const entries = keys.map((k) => [k, seriesNode[k]]);
+  const at = beforeIdx === -1 ? entries.length : beforeIdx;
+  entries.splice(at, 0, ["c:dLbls", newDLbls]);
+  for (const k of keys) {
+    delete seriesNode[k];
+  }
+  for (const [k, v] of entries) {
+    seriesNode[k] = v;
+  }
+}
+
 // src/core/utils/chart-trendline-serializer.ts
 var TYPE_TO_OOXML = {
   linear: "linear",
@@ -25377,7 +25723,7 @@ var TYPE_TO_OOXML = {
   power: "power",
   movingAvg: "movingAvg"
 };
-function findKey9(obj, local, getLocalName) {
+function findKey10(obj, local, getLocalName) {
   return Object.keys(obj).find((k) => getLocalName(k) === local);
 }
 function ensureArray9(v) {
@@ -25394,10 +25740,10 @@ function buildSpPr(existing, color, getLocalName) {
     return existing;
   }
   const spPr = existing ? { ...existing } : {};
-  const lnKey = findKey9(spPr, "ln", getLocalName) ?? "a:ln";
+  const lnKey = findKey10(spPr, "ln", getLocalName) ?? "a:ln";
   const existingLn = spPr[lnKey] ?? {};
-  const fillKey = findKey9(existingLn, "solidFill", getLocalName) ?? "a:solidFill";
-  const noFillKey = findKey9(existingLn, "noFill", getLocalName);
+  const fillKey = findKey10(existingLn, "solidFill", getLocalName) ?? "a:solidFill";
+  const noFillKey = findKey10(existingLn, "noFill", getLocalName);
   const ln = { ...existingLn };
   if (noFillKey) {
     delete ln[noFillKey];
@@ -25409,13 +25755,13 @@ function buildSpPr(existing, color, getLocalName) {
 function buildTrendline(existing, t, getLocalName) {
   const node = {};
   if (existing) {
-    const nameKey = findKey9(existing, "name", getLocalName);
+    const nameKey = findKey10(existing, "name", getLocalName);
     if (nameKey) {
       node["c:name"] = existing[nameKey];
     }
   }
   const spPr = buildSpPr(
-    existing ? existing[findKey9(existing, "spPr", getLocalName) ?? ""] : void 0,
+    existing ? existing[findKey10(existing, "spPr", getLocalName) ?? ""] : void 0,
     t.color,
     getLocalName
   );
@@ -25445,7 +25791,7 @@ function buildTrendline(existing, t, getLocalName) {
     node["c:dispEq"] = { "@_val": "1" };
   }
   if (existing) {
-    const lblKey = findKey9(existing, "trendlineLbl", getLocalName);
+    const lblKey = findKey10(existing, "trendlineLbl", getLocalName);
     if (lblKey) {
       node["c:trendlineLbl"] = existing[lblKey];
     }
@@ -25453,7 +25799,7 @@ function buildTrendline(existing, t, getLocalName) {
   return node;
 }
 function applySeriesTrendlinesToXml(seriesNode, trendlines, getLocalName) {
-  const existingKey = findKey9(seriesNode, "trendline", getLocalName);
+  const existingKey = findKey10(seriesNode, "trendline", getLocalName);
   const existingNodes = existingKey ? ensureArray9(seriesNode[existingKey]) : [];
   const built = trendlines.map((t, i) => buildTrendline(existingNodes[i], t, getLocalName));
   if (existingKey) {
@@ -28663,8 +29009,8 @@ function buildTextRunEffectListXml(style) {
   }
   return effectLst;
 }
-function buildShadowColorNode(hex7, opacity) {
-  const clr = hex7.replace("#", "");
+function buildShadowColorNode(hex8, opacity) {
+  const clr = hex8.replace("#", "");
   const alpha = typeof opacity === "number" ? Math.round(opacity * 1e5) : void 0;
   return {
     "@_val": clr,
@@ -31907,8 +32253,8 @@ function updateCellTextStyleInRawXml(element, rowIndex, colIndex, styleUpdates)
         }
       }
       if ("color" in styleUpdates && typeof styleUpdates.color === "string") {
-        const hex7 = styleUpdates.color.replace("#", "");
-        rPr["a:solidFill"] = { "a:srgbClr": { "@_val": hex7 } };
+        const hex8 = styleUpdates.color.replace("#", "");
+        rPr["a:solidFill"] = { "a:srgbClr": { "@_val": hex8 } };
       }
       if ("align" in styleUpdates) {
         const pPr = paragraph["a:pPr"] ?? {};
@@ -31948,8 +32294,8 @@ function updateCellTextStyleInRawXml(element, rowIndex, colIndex, styleUpdates)
         }
       }
       if ("color" in styleUpdates && typeof styleUpdates.color === "string") {
-        const hex7 = styleUpdates.color.replace("#", "");
-        endRPr["a:solidFill"] = { "a:srgbClr": { "@_val": hex7 } };
+        const hex8 = styleUpdates.color.replace("#", "");
+        endRPr["a:solidFill"] = { "a:srgbClr": { "@_val": hex8 } };
       }
     }
   }
@@ -32228,6 +32574,10 @@ var PptxHandlerRuntime23 = class _PptxHandlerRuntime extends PptxHandlerRuntime2
         if (!plotArea) {
           continue;
         }
+        consolidateComboContainersInXml(
+          plotArea,
+          (key) => this.compatibilityService.getXmlLocalName(key)
+        );
         let chartTypeKey = Object.keys(plotArea).find(
           (key) => this.compatibilityService.getXmlLocalName(key).endsWith("Chart")
         );
@@ -32290,19 +32640,19 @@ var PptxHandlerRuntime23 = class _PptxHandlerRuntime extends PptxHandlerRuntime2
             this.updateChartCacheValues(valNode, true, seriesData.values.map(String));
           }
           if (seriesData.color) {
-            const hex7 = seriesData.color.replace("#", "");
+            const hex8 = seriesData.color.replace("#", "");
             const spPr = this.xmlLookupService.getChildByLocalName(seriesNode, "spPr");
             if (spPr) {
               const solidFillKey = Object.keys(spPr).find(
                 (k) => this.compatibilityService.getXmlLocalName(k) === "solidFill"
               ) ?? "a:solidFill";
-              spPr[solidFillKey] = { "a:srgbClr": { "@_val": hex7 } };
+              spPr[solidFillKey] = { "a:srgbClr": { "@_val": hex8 } };
             } else {
               const spPrKey = Object.keys(seriesNode).find(
                 (k) => this.compatibilityService.getXmlLocalName(k) === "spPr"
               ) ?? "c:spPr";
               seriesNode[spPrKey] = {
-                "a:solidFill": { "a:srgbClr": { "@_val": hex7 } }
+                "a:solidFill": { "a:srgbClr": { "@_val": hex8 } }
               };
             }
           }
@@ -32334,6 +32684,13 @@ var PptxHandlerRuntime23 = class _PptxHandlerRuntime extends PptxHandlerRuntime2
               (key) => this.compatibilityService.getXmlLocalName(key)
             );
           }
+          if (seriesData.dataLabels !== void 0) {
+            applySeriesDataLabelsToXml(
+              seriesNode,
+              seriesData.dataLabels,
+              (key) => this.compatibilityService.getXmlLocalName(key)
+            );
+          }
         }
         if (chartData.series.length > seriesNodes.length) {
           const templateSeries = seriesNodes.length > 0 ? seriesNodes[seriesNodes.length - 1] : void 0;
@@ -32863,36 +33220,131 @@ var PptxHandlerRuntime23 = class _PptxHandlerRuntime extends PptxHandlerRuntime2
   }
 };
 
-// src/core/core/runtime/smartart-save-chrome.ts
+// src/core/core/runtime/smartart-colors-builder.ts
 function asObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function toArray(value) {
+  if (Array.isArray(value)) {
+    return value.filter((entry) => Boolean(asObject(entry)));
+  }
+  const obj = asObject(value);
+  return obj ? [obj] : [];
+}
+function findKey11(obj, name, getLocalName) {
+  return Object.keys(obj).find((k) => getLocalName(k) === name);
+}
+function hex7(value) {
+  return value.replace("#", "");
+}
+var COLOR_LOCAL_NAMES = /* @__PURE__ */ new Set([
+  "srgbClr",
+  "schemeClr",
+  "sysClr",
+  "prstClr",
+  "scrgbClr",
+  "hslClr"
+]);
+function applyColorToList(list, value, getLocalName) {
+  const colorKey = Object.keys(list).find((k) => COLOR_LOCAL_NAMES.has(getLocalName(k)));
+  const srgb = { "@_val": hex7(value) };
+  if (!colorKey) {
+    list["a:srgbClr"] = srgb;
+    return;
+  }
+  const existing = list[colorKey];
+  const rest = Array.isArray(existing) ? existing.slice(1).filter((entry) => Boolean(asObject(entry))) : [];
+  if (colorKey !== "a:srgbClr") {
+    delete list[colorKey];
+  }
+  list["a:srgbClr"] = rest.length > 0 ? [srgb, ...rest] : srgb;
+}
+function applySmartArtColorTransform(colorsDef, transform, getLocalName) {
+  if (!transform) {
+    return false;
+  }
+  let mutated = false;
+  if (transform.name && transform.name.length > 0) {
+    if (colorsDef["@_title"] !== transform.name) {
+      colorsDef["@_title"] = transform.name;
+      mutated = true;
+    }
+  }
+  const styleLblKey = findKey11(colorsDef, "styleLbl", getLocalName);
+  if (!styleLblKey) {
+    return mutated;
+  }
+  const labels = toArray(colorsDef[styleLblKey]);
+  if (labels.length === 0) {
+    return mutated;
+  }
+  let fillIndex = 0;
+  let lineIndex = 0;
+  for (const label of labels) {
+    const fillKey = findKey11(label, "fillClrLst", getLocalName);
+    if (fillKey) {
+      const value = transform.fillColors[fillIndex++];
+      const list = asObject(label[fillKey]);
+      if (list && value) {
+        applyColorToList(list, value, getLocalName);
+        mutated = true;
+      }
+    }
+    const lineKey = findKey11(label, "linClrLst", getLocalName);
+    if (lineKey) {
+      const value = transform.lineColors[lineIndex++];
+      const list = asObject(label[lineKey]);
+      if (list && value) {
+        applyColorToList(list, value, getLocalName);
+        mutated = true;
+      }
+    }
+  }
+  return mutated;
+}
+
+// src/core/core/runtime/smartart-quickstyle-builder.ts
+function applySmartArtQuickStyle(styleDef, quickStyle) {
+  if (!quickStyle || !quickStyle.name || quickStyle.name.length === 0) {
+    return false;
+  }
+  if (styleDef["@_title"] === quickStyle.name) {
+    return false;
+  }
+  styleDef["@_title"] = quickStyle.name;
+  return true;
+}
+
+// src/core/core/runtime/smartart-save-chrome.ts
+function asObject2(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 function applySmartArtChrome(dataModel, chrome, getLocalName) {
   if (!chrome || !chrome.backgroundColor && !chrome.outlineColor && (chrome.outlineWidth === null || chrome.outlineWidth === void 0)) {
     return;
   }
-  const findKey10 = (obj, name) => Object.keys(obj).find((k) => getLocalName(k) === name);
+  const findKey12 = (obj, name) => Object.keys(obj).find((k) => getLocalName(k) === name);
   if (chrome.backgroundColor) {
-    const hex7 = chrome.backgroundColor.replace("#", "");
-    const bgKey = findKey10(dataModel, "bg") ?? "dgm:bg";
-    const bg = asObject(dataModel[bgKey]);
-    const fillKey = findKey10(bg, "solidFill") ?? "a:solidFill";
-    bg[fillKey] = { "a:srgbClr": { "@_val": hex7 } };
+    const hex8 = chrome.backgroundColor.replace("#", "");
+    const bgKey = findKey12(dataModel, "bg") ?? "dgm:bg";
+    const bg = asObject2(dataModel[bgKey]);
+    const fillKey = findKey12(bg, "solidFill") ?? "a:solidFill";
+    bg[fillKey] = { "a:srgbClr": { "@_val": hex8 } };
     dataModel[bgKey] = bg;
   }
   const hasOutlineWidth = chrome.outlineWidth !== null && chrome.outlineWidth !== void 0;
   if (chrome.outlineColor || hasOutlineWidth) {
-    const wholeKey = findKey10(dataModel, "whole") ?? "dgm:whole";
-    const whole = asObject(dataModel[wholeKey]);
-    const lnKey = findKey10(whole, "ln") ?? "a:ln";
-    const ln = asObject(whole[lnKey]);
+    const wholeKey = findKey12(dataModel, "whole") ?? "dgm:whole";
+    const whole = asObject2(dataModel[wholeKey]);
+    const lnKey = findKey12(whole, "ln") ?? "a:ln";
+    const ln = asObject2(whole[lnKey]);
     if (hasOutlineWidth) {
       ln["@_w"] = String(Math.round(chrome.outlineWidth * 12700));
     }
     if (chrome.outlineColor) {
-      const hex7 = chrome.outlineColor.replace("#", "");
-      const fillKey = findKey10(ln, "solidFill") ?? "a:solidFill";
-      ln[fillKey] = { "a:srgbClr": { "@_val": hex7 } };
+      const hex8 = chrome.outlineColor.replace("#", "");
+      const fillKey = findKey12(ln, "solidFill") ?? "a:solidFill";
+      ln[fillKey] = { "a:srgbClr": { "@_val": hex8 } };
     }
     whole[lnKey] = ln;
     dataModel[wholeKey] = whole;
@@ -32927,10 +33379,56 @@ function buildPointText(text) {
     }
   };
 }
-function applyTextToExistingPoint(pt2, text) {
+function joinRunText(runs) {
+  return (runs ?? []).map((run) => run.text).join("");
+}
+function buildMultiRunParagraph(runs) {
+  const runObjects = runs.map((run) => {
+    const rObj = {};
+    rObj["a:rPr"] = run.rPr ?? { "@_lang": "en-US", "@_dirty": "0" };
+    rObj["a:t"] = run.text;
+    return rObj;
+  });
+  return { "a:r": runObjects.length === 1 ? runObjects[0] : runObjects };
+}
+function shouldRebuildFromRuns(node) {
+  const runs = node.runs;
+  if (!runs || runs.length === 0) {
+    return false;
+  }
+  const hasRichRun = runs.length > 1 || Boolean(runs[0]?.rPr);
+  if (!hasRichRun) {
+    return false;
+  }
+  return joinRunText(runs) === node.text;
+}
+function buildPointFromRuns(runs) {
+  return {
+    "a:bodyPr": {},
+    "a:lstStyle": {},
+    "a:p": buildMultiRunParagraph(runs)
+  };
+}
+function applyRunsToExistingBody(pt2, tKey, runs) {
+  const body = pt2[tKey];
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    pt2[tKey] = buildPointFromRuns(runs);
+    return;
+  }
+  const bodyObj = body;
+  const pKey = Object.keys(bodyObj).find((k) => stripPrefix(k) === "p");
+  bodyObj[pKey ?? "a:p"] = buildMultiRunParagraph(runs);
+}
+function applyTextToExistingPoint(pt2, node) {
+  const text = node.text;
+  const rebuildFromRuns = shouldRebuildFromRuns(node);
   const tKey = Object.keys(pt2).find((k) => stripPrefix(k) === "t");
   if (!tKey) {
-    pt2["dgm:t"] = buildPointText(text);
+    pt2["dgm:t"] = rebuildFromRuns ? buildPointFromRuns(node.runs) : buildPointText(text);
+    return;
+  }
+  if (rebuildFromRuns) {
+    applyRunsToExistingBody(pt2, tKey, node.runs);
     return;
   }
   const body = pt2[tKey];
@@ -32991,7 +33489,7 @@ function mergeSmartArtPointXml(existingPts, nodes) {
     if (!desired) {
       continue;
     }
-    applyTextToExistingPoint(pt2, desired.text);
+    applyTextToExistingPoint(pt2, desired);
     seenContentIds.add(modelId);
     merged.push(pt2);
   }
@@ -33004,7 +33502,7 @@ function mergeSmartArtPointXml(existingPts, nodes) {
     if (node.nodeType && !NON_CONTENT_POINT_TYPES.has(node.nodeType)) {
       ptNode["@_type"] = node.nodeType;
     }
-    ptNode["dgm:t"] = buildPointText(node.text);
+    ptNode["dgm:t"] = shouldRebuildFromRuns(node) ? buildPointFromRuns(node.runs) : buildPointText(node.text);
     merged.push(ptNode);
   }
   return merged;
@@ -33113,9 +33611,83 @@ var PptxHandlerRuntime24 = class _PptxHandlerRuntime extends PptxHandlerRuntime2
       } catch (e) {
         console.warn(`Failed to save SmartArt data at ${dataPartPath}:`, e);
       }
+      await this.regenerateSmartArtColorPart(slidePath, smartArtData);
+      await this.regenerateSmartArtQuickStylePart(slidePath, smartArtData);
     }
     this.pendingSmartArtUpdates = void 0;
   }
+  /**
+   * Merge the in-memory colour transform back into `ppt/diagrams/colors*.xml`.
+   *
+   * Resolves the part via the SmartArt `colorsRelId` relationship alongside
+   * the data part, merges surgically (preserving unknown content), and skips
+   * gracefully when the rel or part is absent. No-op when the in-memory data
+   * carries no colour transform.
+   */
+  async regenerateSmartArtColorPart(slidePath, smartArtData) {
+    const transform = smartArtData?.colorTransform;
+    if (!smartArtData?.colorsRelId || !transform) {
+      return;
+    }
+    await this.mergeSmartArtDiagramPart(
+      slidePath,
+      smartArtData.colorsRelId,
+      "colorsDef",
+      "colours",
+      (colorsDef) => applySmartArtColorTransform(
+        colorsDef,
+        transform,
+        (k) => this.compatibilityService.getXmlLocalName(k)
+      )
+    );
+  }
+  /**
+   * Merge the in-memory quick style back into `ppt/diagrams/quickStyles*.xml`.
+   *
+   * Resolves the part via the SmartArt `styleRelId` relationship, merges
+   * surgically, and skips gracefully when the rel or part is absent. No-op
+   * when the in-memory data carries no quick style.
+   */
+  async regenerateSmartArtQuickStylePart(slidePath, smartArtData) {
+    const quickStyle = smartArtData?.quickStyle;
+    if (!smartArtData?.styleRelId || !quickStyle) {
+      return;
+    }
+    await this.mergeSmartArtDiagramPart(
+      slidePath,
+      smartArtData.styleRelId,
+      "styleDef",
+      "quick style",
+      (styleDef) => applySmartArtQuickStyle(styleDef, quickStyle)
+    );
+  }
+  /**
+   * Read a SmartArt diagram part by slide relationship id, locate its root
+   * definition element by local name, apply a surgical merge callback, and
+   * write the part back only when the callback reports a change. Skips
+   * gracefully when the rel, part, or root element is absent.
+   */
+  async mergeSmartArtDiagramPart(slidePath, relId, defLocalName, label, merge) {
+    const relationships = this.slideRelsMap.get(slidePath);
+    const target = relationships?.get(relId);
+    if (!target) {
+      return;
+    }
+    const partPath = this.resolveImagePath(slidePath, target);
+    const existingXml = await this.zip.file(partPath)?.async("string");
+    if (!existingXml) {
+      return;
+    }
+    try {
+      const parsed = this.parser.parse(existingXml);
+      const def = this.xmlLookupService.getChildByLocalName(parsed, defLocalName);
+      if (def && merge(def)) {
+        this.zip.file(partPath, this.builder.build(parsed));
+      }
+    } catch (e) {
+      console.warn(`Failed to save SmartArt ${label} at ${partPath}:`, e);
+    }
+  }
   /**
    * Find the slide path for an element by scanning the slideMap.
    */
@@ -33147,10 +33719,10 @@ var PptxHandlerRuntime24 = class _PptxHandlerRuntime extends PptxHandlerRuntime2
       }
       const cSld = root["p:cSld"] || {};
       if (notesMaster.backgroundColor) {
-        const hex7 = notesMaster.backgroundColor.replace("#", "");
+        const hex8 = notesMaster.backgroundColor.replace("#", "");
         cSld["p:bg"] = {
           "p:bgPr": {
-            "a:solidFill": { "a:srgbClr": { "@_val": hex7 } },
+            "a:solidFill": { "a:srgbClr": { "@_val": hex8 } },
             "a:effectLst": {}
           }
         };
@@ -33183,10 +33755,10 @@ var PptxHandlerRuntime24 = class _PptxHandlerRuntime extends PptxHandlerRuntime2
       }
       const cSld = root["p:cSld"] || {};
       if (handoutMaster.backgroundColor) {
-        const hex7 = handoutMaster.backgroundColor.replace("#", "");
+        const hex8 = handoutMaster.backgroundColor.replace("#", "");
         cSld["p:bg"] = {
           "p:bgPr": {
-            "a:solidFill": { "a:srgbClr": { "@_val": hex7 } },
+            "a:solidFill": { "a:srgbClr": { "@_val": hex8 } },
             "a:effectLst": {}
           }
         };
@@ -35636,8 +36208,8 @@ var PptxHandlerRuntime34 = class extends PptxHandlerRuntime33 {
    */
   buildClrSchemeObject(schemeName, colorMap) {
     const slot = (key) => {
-      const hex7 = String(colorMap[key] || "").replace(/^#/, "");
-      const srgb = hex7.length === 6 ? hex7.toUpperCase() : "000000";
+      const hex8 = String(colorMap[key] || "").replace(/^#/, "");
+      const srgb = hex8.length === 6 ? hex8.toUpperCase() : "000000";
       return { "a:srgbClr": { "@_val": srgb } };
     };
     return {
@@ -42416,8 +42988,8 @@ var PptxHandlerRuntime66 = class extends PptxHandlerRuntime65 {
   /**
    * Build an OOXML colour node (`a:srgbClr`) from a hex string.
    */
-  buildSrgbClrNode(hex7) {
-    const clean = hex7.replace(/^#/, "").toUpperCase();
+  buildSrgbClrNode(hex8) {
+    const clean = hex8.replace(/^#/, "").toUpperCase();
     return { "a:srgbClr": { "@_val": clean } };
   }
   /**
@@ -42840,6 +43412,45 @@ var PptxHandlerRuntime68 = class extends PptxHandlerRuntime67 {
       }
     }
   }
+  /**
+   * Extract the per-run text + run-properties of a SmartArt content point's
+   * first paragraph (`dgm:t/a:p/a:r`).
+   *
+   * Each `a:r` yields one {@link PptxSmartArtTextRun} carrying its joined
+   * `a:t` text and a verbatim copy of its `a:rPr` properties (when present).
+   * Only the first paragraph is captured: SmartArt content points are
+   * single-paragraph in practice, and the round-trip save path rebuilds a
+   * single paragraph from these runs. Returns undefined when there is fewer
+   * than one run worth preserving (a single run is still returned so per-run
+   * formatting like a bold sole run survives).
+   */
+  extractSmartArtNodeRuns(point) {
+    const tBody = this.xmlLookupService.getChildByLocalName(point, "t");
+    if (!tBody) {
+      return void 0;
+    }
+    const paragraph = this.xmlLookupService.getChildrenArrayByLocalName(tBody, "p")[0];
+    if (!paragraph) {
+      return void 0;
+    }
+    const runNodes = this.xmlLookupService.getChildrenArrayByLocalName(paragraph, "r");
+    if (runNodes.length === 0) {
+      return void 0;
+    }
+    const runs = [];
+    for (const run of runNodes) {
+      const textValues = [];
+      this.collectLocalTextValues(run, "t", textValues);
+      const text = textValues.join("");
+      const rPrNode = this.xmlLookupService.getChildByLocalName(run, "rPr");
+      const entry = { text };
+      if (rPrNode) {
+        entry.rPr = JSON.parse(JSON.stringify(rPrNode));
+      }
+      runs.push(entry);
+    }
+    return runs.length > 0 ? runs : void 0;
+  }
   /**
    * Parse background and outline chrome from `dgm:bg` and `dgm:whole`.
    */
@@ -43143,11 +43754,13 @@ var PptxHandlerRuntime70 = class _PptxHandlerRuntime extends PptxHandlerRuntime6
       if (!resolvedText) {
         return null;
       }
+      const runs = this.extractSmartArtNodeRuns(point);
       return {
         id: pointId,
         text: resolvedText.trim(),
         parentId: parentByNodeId.get(pointId),
-        nodeType
+        nodeType,
+        runs
       };
     }).filter((entry) => Boolean(entry)).slice(0, MAX_SMARTART_NODES);
     if (nodes.length === 0) {
@@ -43865,11 +44478,11 @@ var PptxHandlerRuntime74 = class extends PptxHandlerRuntime73 {
       } else if (localName === "srgbClr") {
         const items = Array.isArray(value) ? value : [value];
         for (const item of items) {
-          const hex7 = String(
+          const hex8 = String(
             typeof item === "object" && item !== null ? item["@_val"] : item ?? ""
           ).trim();
-          if (hex7.length > 0) {
-            output.push(hex7.startsWith("#") ? hex7 : `#${hex7}`);
+          if (hex8.length > 0) {
+            output.push(hex8.startsWith("#") ? hex8 : `#${hex8}`);
           }
         }
       }
@@ -43937,9 +44550,10 @@ var PptxHandlerRuntime75 = class extends PptxHandlerRuntime74 {
       return void 0;
     }
     const chartType = this.detectChartType(plotArea);
-    const seriesContainerKey = Object.keys(plotArea).find(
+    const chartContainerKeys = Object.keys(plotArea).filter(
       (key) => this.compatibilityService.getXmlLocalName(key).endsWith("Chart")
     );
+    const seriesContainerKey = chartContainerKeys[0];
     if (!seriesContainerKey) {
       return this.parseCxChart(
         plotArea,
@@ -43951,19 +44565,14 @@ var PptxHandlerRuntime75 = class extends PptxHandlerRuntime74 {
       );
     }
     const seriesContainer = plotArea[seriesContainerKey];
-    const seriesList = this.xmlLookupService.getChildrenArrayByLocalName(seriesContainer, "ser");
-    if (seriesList.length === 0) {
+    const { categories, series } = this.parseAllChartContainers(
+      plotArea,
+      chartContainerKeys,
+      chartType
+    );
+    if (series.length === 0) {
       return void 0;
     }
-    const categoriesFromFirstSeries = this.extractChartPointValues(
-      this.xmlLookupService.getChildByLocalName(seriesList[0], "cat"),
-      false
-    );
-    const categories = categoriesFromFirstSeries.length ? categoriesFromFirstSeries : this.extractChartPointValues(
-      this.xmlLookupService.getChildByLocalName(seriesList[0], "xVal"),
-      false
-    );
-    const series = this.buildChartSeries(seriesList, categories);
     const titleNode = this.xmlLookupService.getChildByLocalName(chartRoot, "title");
     const titleTextValues = [];
     this.collectLocalTextValues(titleNode, "t", titleTextValues);
@@ -44062,6 +44671,49 @@ var PptxHandlerRuntime75 = class extends PptxHandlerRuntime74 {
       ...clrMapOvr ? { clrMapOvr } : {}
     };
   }
+  /**
+   * Parse every chart-type container in the plot area into a single flat
+   * series list plus a shared category list.
+   *
+   * For a single-type chart this parses the one container exactly as before.
+   * For a combo chart (multiple `c:*Chart` siblings) each container's series
+   * are parsed and tagged with the container's chart type via
+   * {@link PptxChartSeries.seriesChartType}, so the combo serializer can
+   * re-emit each series under the correct container on save. Series keep the
+   * document order of their containers.
+   *
+   * @param plotArea - The `c:plotArea` XML object.
+   * @param containerKeys - All chart-type container keys, in document order.
+   * @param chartLevelType - The detected chart-level type. When this is
+   *   `combo`, each series is tagged with its own container type; otherwise no
+   *   per-series type is set (the chart-level type applies to every series).
+   * @returns The merged categories and series.
+   */
+  parseAllChartContainers(plotArea, containerKeys, chartLevelType) {
+    const isCombo = chartLevelType === "combo";
+    let categories = [];
+    const series = [];
+    for (const containerKey of containerKeys) {
+      const container = plotArea[containerKey];
+      const seriesList = this.xmlLookupService.getChildrenArrayByLocalName(container, "ser");
+      if (seriesList.length === 0) {
+        continue;
+      }
+      if (categories.length === 0) {
+        const fromCat = this.extractChartPointValues(
+          this.xmlLookupService.getChildByLocalName(seriesList[0], "cat"),
+          false
+        );
+        categories = fromCat.length ? fromCat : this.extractChartPointValues(
+          this.xmlLookupService.getChildByLocalName(seriesList[0], "xVal"),
+          false
+        );
+      }
+      const containerType = isCombo ? chartContainerLocalNameToType(this.compatibilityService.getXmlLocalName(containerKey)) : void 0;
+      series.push(...this.buildChartSeries(seriesList, categories, containerType));
+    }
+    return { categories, series };
+  }
   /**
    * Build the series array from raw OOXML `c:ser` nodes.
    *
@@ -44071,9 +44723,11 @@ var PptxHandlerRuntime75 = class extends PptxHandlerRuntime74 {
    *
    * @param seriesList - Array of `c:ser` XML objects from the chart container.
    * @param categories - Pre-parsed category labels (used for fallback values).
+   * @param seriesChartType - When set (combo charts), tags every series in this
+   *   container with its source chart type for round-trip.
    * @returns The series array matching `PptxChartData["series"]`.
    */
-  buildChartSeries(seriesList, categories) {
+  buildChartSeries(seriesList, categories, seriesChartType) {
     return seriesList.map((seriesNode, seriesIndex) => {
       const seriesName = this.extractChartSeriesName(seriesNode);
       const values = this.extractChartPointValues(
@@ -44111,7 +44765,8 @@ var PptxHandlerRuntime75 = class extends PptxHandlerRuntime74 {
         ...dataPoints.length > 0 ? { dataPoints } : {},
         ...seriesMarker ? { marker: seriesMarker } : {},
         ...dataLabels.length > 0 ? { dataLabels } : {},
-        ...explosion !== void 0 ? { explosion } : {}
+        ...explosion !== void 0 ? { explosion } : {},
+        ...seriesChartType ? { seriesChartType } : {}
       };
     });
   }
@@ -44623,6 +45278,7 @@ var PptxHandlerRuntime77 = class extends PptxHandlerRuntime76 {
 };
 
 // src/core/core/runtime/PptxHandlerRuntimeLoadSession.ts
+var MAX_OLE_EMBEDDING_BYTES = 25 * 1024 * 1024;
 var PptxHandlerRuntime78 = class _PptxHandlerRuntime extends PptxHandlerRuntime77 {
   isZipContainer(data) {
     const bytes = new Uint8Array(data);
@@ -44842,6 +45498,59 @@ var PptxHandlerRuntime78 = class _PptxHandlerRuntime extends PptxHandlerRuntime7
       orderedSections
     };
   }
+  /**
+   * Recover and attach the real embedded binary for each OLE element on a
+   * slide so callers can download / open the inner file.
+   *
+   * For each embedded (non-linked) OLE object: resolve its relationship
+   * target to a zip path (same resolution as images), read the bytes, unwrap
+   * a generic "Package" wrapper (recovering the original file name) when
+   * present, derive a MIME type, and expose the payload as a data-URL on the
+   * element. Linked objects, missing targets, oversized payloads, and parse
+   * failures are skipped silently so existing behaviour is preserved.
+   */
+  async enrichOleElementsWithEmbeddedData(elements, slidePath, depth = 0) {
+    const MAX_OLE_DEPTH = 32;
+    if (depth > MAX_OLE_DEPTH) {
+      return;
+    }
+    for (const el of elements) {
+      if (el.type === "group" && el.children) {
+        await this.enrichOleElementsWithEmbeddedData(el.children, slidePath, depth + 1);
+        continue;
+      }
+      if (el.type !== "ole" || el.isLinked || !el.oleTarget) {
+        continue;
+      }
+      try {
+        const embeddingPath = this.resolveImagePath(slidePath, el.oleTarget);
+        if (!embeddingPath) {
+          continue;
+        }
+        const file = this.zip.file(embeddingPath);
+        if (!file) {
+          continue;
+        }
+        const buffer = await file.async("arraybuffer");
+        if (buffer.byteLength === 0 || buffer.byteLength > MAX_OLE_EMBEDDING_BYTES) {
+          continue;
+        }
+        const unwrapped = unwrapOleEmbedding(new Uint8Array(buffer));
+        if (unwrapped.data.length === 0) {
+          continue;
+        }
+        const fileName = unwrapped.fileName ?? el.fileName ?? (el.oleName && el.oleFileExtension ? `${el.oleName}.${el.oleFileExtension}` : void 0);
+        const mimeType = mimeTypeForOleFile(fileName ?? `x.${el.oleFileExtension ?? "bin"}`);
+        el.oleEmbeddedData = oleBytesToDataUrl(unwrapped.data, mimeType);
+        el.oleEmbeddedByteSize = unwrapped.data.length;
+        el.oleEmbeddedMimeType = mimeType;
+        if (fileName) {
+          el.oleEmbeddedFileName = fileName;
+        }
+      } catch {
+      }
+    }
+  }
   async loadSlidesForPresentation(sectionBySlideId) {
     if (!this.presentationData) {
       return [];
@@ -44869,6 +45578,7 @@ var PptxHandlerRuntime78 = class _PptxHandlerRuntime extends PptxHandlerRuntime7
       parseSlide: (slideXml2, slidePath) => this.parseSlide(slideXml2, slidePath),
       extractMediaTimingMap: (slideXml2, slidePath) => this.extractMediaTimingMap(slideXml2, slidePath),
       enrichMediaElementsWithTiming: (elements, timingMap) => this.enrichMediaElementsWithTiming(elements, timingMap),
+      enrichOleElementsWithEmbeddedData: (elements, slidePath) => this.enrichOleElementsWithEmbeddedData(elements, slidePath),
       extractBackgroundColor: (slideXml2) => this.extractBackgroundColor(slideXml2),
       getLayoutBackgroundColor: (slidePath) => this.getLayoutBackgroundColor(slidePath),
       extractBackgroundGradient: (slideXml2) => this.extractBackgroundGradient(slideXml2),
@@ -57098,6 +57808,51 @@ function setChartDataPointExplosion(element, seriesIndex, pointIndex, explosion)
   const dp = ensureDataPoint(series, pointIndex);
   dp.explosion = explosion;
 }
+function applyLabelEdit(label, edit) {
+  if (edit.showValue !== void 0) {
+    label.showVal = edit.showValue;
+  }
+  if (edit.showCategory !== void 0) {
+    label.showCatName = edit.showCategory;
+  }
+  if (edit.showSeriesName !== void 0) {
+    label.showSerName = edit.showSeriesName;
+  }
+  if (edit.showPercent !== void 0) {
+    label.showPercent = edit.showPercent;
+  }
+  if (edit.showLegendKey !== void 0) {
+    label.showLegendKey = edit.showLegendKey;
+  }
+  if (edit.position !== void 0) {
+    label.position = edit.position;
+  }
+  if (edit.text !== void 0) {
+    label.text = edit.text === "" ? void 0 : edit.text;
+  }
+}
+function setChartDataPointLabel(element, seriesIndex, pointIndex, edit) {
+  validateSeriesIndex(element, seriesIndex);
+  const series = element.chartData.series[seriesIndex];
+  if (edit === null) {
+    if (!series.dataLabels) {
+      return;
+    }
+    series.dataLabels = series.dataLabels.filter((l) => l.idx !== pointIndex);
+    if (series.dataLabels.length === 0) {
+      series.dataLabels = void 0;
+    }
+    return;
+  }
+  const labels = series.dataLabels ??= [];
+  let label = labels.find((l) => l.idx === pointIndex);
+  if (!label) {
+    label = { idx: pointIndex };
+    labels.push(label);
+    labels.sort((a, b) => a.idx - b.idx);
+  }
+  applyLabelEdit(label, edit);
+}
 function removeEmptyDataPoint(series, pointIndex) {
   if (!series.dataPoints) {
     return;
@@ -57147,8 +57902,8 @@ function generateLayoutXml(definition) {
   const phShapes = placeholders.map((ph, i) => placeholderSpXml(ph, i + 2)).join("\n");
   let bgXml = "";
   if (definition.backgroundColor) {
-    const hex7 = definition.backgroundColor.replace(/^#/, "").toUpperCase();
-    bgXml = `    <p:bg><p:bgPr><a:solidFill><a:srgbClr val="${hex7}"/></a:solidFill><a:effectLst/></p:bgPr></p:bg>
+    const hex8 = definition.backgroundColor.replace(/^#/, "").toUpperCase();
+    bgXml = `    <p:bg><p:bgPr><a:solidFill><a:srgbClr val="${hex8}"/></a:solidFill><a:effectLst/></p:bgPr></p:bg>
 `;
   }
   return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
@@ -57624,8 +58379,8 @@ var TextBuilder = class _TextBuilder {
    *
    * @param hex - Color as a hex string (e.g. "#FF0000").
    */
-  color(hex7) {
-    this._options.color = hex7;
+  color(hex8) {
+    this._options.color = hex8;
     return this;
   }
   /**
@@ -62401,8 +63156,8 @@ function stepTable10(t) {
   }
   return out.join(" ");
 }
-function parseHexRgb(hex7) {
-  const m = /^#?([0-9a-f]{6})/i.exec(hex7.trim());
+function parseHexRgb(hex8) {
+  const m = /^#?([0-9a-f]{6})/i.exec(hex8.trim());
   if (!m) {
     return { r: 0, g: 0, b: 0 };
   }
@@ -63154,6 +63909,7 @@ exports.createTemplateShapeRawXml = createTemplateShapeRawXml;
 exports.createTextElement = createTextElement;
 exports.createUniformTextSegments = createUniformTextSegments;
 exports.dataUrlToMediaBytes = dataUrlToMediaBytes;
+exports.decodeOle10Native = decodeOle10Native;
 exports.decomposeSmartArt = decomposeSmartArt;
 exports.decryptPptx = decryptPptx;
 exports.demoteSmartArtNode = demoteSmartArtNode;
@@ -63261,6 +64017,7 @@ exports.isEditableTextElement = isEditableTextElement;
 exports.isImageLikeElement = isImageLikeElement;
 exports.isInkElement = isInkElement;
 exports.isNamespaceSupported = isNamespaceSupported;
+exports.isOle2CompoundFile = isOle2CompoundFile;
 exports.isShapeElement = isShapeElement;
 exports.isStrictNamespaceUri = isStrictNamespaceUri;
 exports.isSummaryZoomSlide = isSummaryZoomSlide;
@@ -63279,6 +64036,7 @@ exports.mergePresentation = mergePresentation;
 exports.mergeShapes = mergeShapes;
 exports.mergeStyleParts = mergeStyleParts;
 exports.mergeThemeColorOverride = mergeThemeColorOverride;
+exports.mimeTypeForOleFile = mimeTypeForOleFile;
 exports.mm = mm;
 exports.moveSlidesToSection = moveSlidesToSection;
 exports.navigateCustomShow = navigateCustomShow;
@@ -63289,6 +64047,7 @@ exports.normalizePath = normalizePath;
 exports.normalizeStrictXml = normalizeStrictXml;
 exports.normalizeStrokeDashType = normalizeStrokeDashType;
 exports.obfuscateFont = obfuscateFont;
+exports.oleBytesToDataUrl = oleBytesToDataUrl;
 exports.ooxmlArcToSvg = ooxmlArcToSvg;
 exports.ooxmlToPresetName = ooxmlToPresetName;
 exports.parseActiveXControlsFromSlide = parseActiveXControlsFromSlide;
@@ -63378,6 +64137,7 @@ exports.setChartCategories = setChartCategories;
 exports.setChartDataLabels = setChartDataLabels;
 exports.setChartDataPointExplosion = setChartDataPointExplosion;
 exports.setChartDataPointFill = setChartDataPointFill;
+exports.setChartDataPointLabel = setChartDataPointLabel;
 exports.setChartGrouping = setChartGrouping;
 exports.setChartLegend = setChartLegend;
 exports.setChartSeriesChartType = setChartSeriesChartType;
@@ -63400,6 +64160,7 @@ exports.unionPolygons = unionPolygons;
 exports.unionShapes = unionShapes;
 exports.unionSvgPaths = unionSvgPaths;
 exports.unwrapAlternateContent = unwrapAlternateContent;
+exports.unwrapOleEmbedding = unwrapOleEmbedding;
 exports.updateCellTextInRawXml = updateCellTextInRawXml;
 exports.updateCellTextStyleInRawXml = updateCellTextStyleInRawXml;
 exports.updateChartDataPoint = updateChartDataPoint;