pptx-viewer-core 1.1.33 → 1.1.35

package/dist/index.js

@@ -6209,16 +6209,16 @@ var PptxShapeStyleExtractor = class {
   extractShapeStyle(spPr, styleNode) {
     const style = {};
     const shapeProps = spPr || {};
-    const solidFill = shapeProps["a:solidFill"];
+    const solidFill2 = shapeProps["a:solidFill"];
     const gradFill = shapeProps["a:gradFill"];
     const pattFill = shapeProps["a:pattFill"];
     const noFill = shapeProps["a:noFill"];
     const blipFill = shapeProps["a:blipFill"];
-    if (solidFill) {
+    if (solidFill2) {
       style.fillMode = "solid";
-      style.fillColor = this.context.parseColor(solidFill);
-      style.fillOpacity = this.context.extractColorOpacity(solidFill);
-      const solidFillColorXml = extractColorChoiceXml(solidFill);
+      style.fillColor = this.context.parseColor(solidFill2);
+      style.fillOpacity = this.context.extractColorOpacity(solidFill2);
+      const solidFillColorXml = extractColorChoiceXml(solidFill2);
       if (solidFillColorXml) {
         style.fillColorXml = solidFillColorXml;
       }
@@ -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);
@@ -8916,15 +8949,15 @@ var PptxSlideLoaderService = class {
 
 // src/core/services/PptxXmlLookupService.ts
 var PptxXmlLookupService = class {
-  getChildByLocalName(parent, localName) {
+  getChildByLocalName(parent, localName2) {
     if (!parent) {
       return void 0;
     }
-    const direct = parent[localName];
+    const direct = parent[localName2];
     if (direct && typeof direct === "object" && !Array.isArray(direct)) {
       return direct;
     }
-    const suffix = `:${localName}`;
+    const suffix = `:${localName2}`;
     const matchingKey = Object.keys(parent).find((key) => key.endsWith(suffix));
     if (!matchingKey) {
       return void 0;
@@ -8935,32 +8968,32 @@ var PptxXmlLookupService = class {
     }
     return value;
   }
-  getChildrenArrayByLocalName(parent, localName) {
+  getChildrenArrayByLocalName(parent, localName2) {
     if (!parent) {
       return [];
     }
-    const direct = parent[localName];
+    const direct = parent[localName2];
     if (direct !== void 0) {
       return this.toXmlArray(direct);
     }
-    const suffix = `:${localName}`;
+    const suffix = `:${localName2}`;
     const matchingKey = Object.keys(parent).find((key) => key.endsWith(suffix));
     if (!matchingKey) {
       return [];
     }
     return this.toXmlArray(parent[matchingKey]);
   }
-  getScalarChildByLocalName(parent, localName) {
+  getScalarChildByLocalName(parent, localName2) {
     if (!parent) {
       return void 0;
     }
-    const direct = parent[localName];
+    const direct = parent[localName2];
     if (typeof direct === "string" || typeof direct === "number") {
       return String(direct);
     }
-    const suffix = `:${localName}`;
+    const suffix = `:${localName2}`;
     for (const [key, value] of Object.entries(parent)) {
-      if (key !== localName && !key.endsWith(suffix)) {
+      if (key !== localName2 && !key.endsWith(suffix)) {
         continue;
       }
       if (typeof value === "string" || typeof value === "number") {
@@ -10405,11 +10438,11 @@ function parseP14FromExtLst(extLstNode, xmlLookupService, getXmlLocalName) {
       if (key.startsWith("@_")) {
         continue;
       }
-      const localName = getXmlLocalName(key);
-      if (!P14_TRANSITION_TYPES.has(localName)) {
+      const localName2 = getXmlLocalName(key);
+      if (!P14_TRANSITION_TYPES.has(localName2)) {
         continue;
       }
-      const type = localName;
+      const type = localName2;
       let direction;
       let orient;
       let pattern;
@@ -10459,8 +10492,8 @@ function buildP14ExtLst(transitionType, direction, orient, pattern, rawExtLst, x
         if (key.startsWith("@_")) {
           continue;
         }
-        const localName = getXmlLocalName(key);
-        if (P14_TRANSITION_TYPES.has(localName)) {
+        const localName2 = getXmlLocalName(key);
+        if (P14_TRANSITION_TYPES.has(localName2)) {
           return false;
         }
       }
@@ -10523,17 +10556,17 @@ var PptxSlideTransitionService = class {
       if (key.startsWith("@_")) {
         continue;
       }
-      const localName = this.getXmlLocalName(key);
-      if (localName === "sndAc") {
+      const localName2 = this.getXmlLocalName(key);
+      if (localName2 === "sndAc") {
         rawSoundAction = value;
         continue;
       }
-      if (localName === "extLst") {
+      if (localName2 === "extLst") {
         rawExtLst = value;
         continue;
       }
-      if (TRANSITION_TYPES.has(localName)) {
-        transitionType = localName;
+      if (TRANSITION_TYPES.has(localName2)) {
+        transitionType = localName2;
       }
       if (value && typeof value === "object" && !Array.isArray(value)) {
         const detail = value;
@@ -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";
@@ -12395,27 +12743,27 @@ function detectDigitalSignatures(zipEntryPaths) {
 function getSignaturePathsToStrip(zipEntryPaths) {
   return zipEntryPaths.filter((p) => p.startsWith(SIGNATURE_PREFIX));
 }
-function findByLocalName(parent, localName) {
+function findByLocalName(parent, localName2) {
   if (!parent) {
     return void 0;
   }
-  if (parent[localName] !== void 0 && typeof parent[localName] === "object") {
-    return parent[localName];
+  if (parent[localName2] !== void 0 && typeof parent[localName2] === "object") {
+    return parent[localName2];
   }
   for (const key of Object.keys(parent)) {
     const parts = key.split(":");
-    if (parts[parts.length - 1] === localName && typeof parent[key] === "object") {
+    if (parts[parts.length - 1] === localName2 && typeof parent[key] === "object") {
       return parent[key];
     }
   }
   return void 0;
 }
-function findScalarByLocalName(parent, localName) {
+function findScalarByLocalName(parent, localName2) {
   if (!parent) {
     return void 0;
   }
-  if (parent[localName] !== void 0) {
-    const v = parent[localName];
+  if (parent[localName2] !== void 0) {
+    const v = parent[localName2];
     if (typeof v === "string") {
       return v;
     }
@@ -12428,7 +12776,7 @@ function findScalarByLocalName(parent, localName) {
   }
   for (const key of Object.keys(parent)) {
     const parts = key.split(":");
-    if (parts[parts.length - 1] === localName) {
+    if (parts[parts.length - 1] === localName2) {
       const v = parent[key];
       if (typeof v === "string") {
         return v;
@@ -12443,13 +12791,13 @@ function findScalarByLocalName(parent, localName) {
   }
   return void 0;
 }
-function findAllByLocalName(parent, localName) {
+function findAllByLocalName(parent, localName2) {
   if (!parent) {
     return [];
   }
   for (const key of Object.keys(parent)) {
     const parts = key.split(":");
-    if (parts[parts.length - 1] === localName) {
+    if (parts[parts.length - 1] === localName2) {
       const v = parent[key];
       if (Array.isArray(v)) {
         return v;
@@ -12926,8 +13274,8 @@ function parseLineStyle(container, elementName, xmlLookup, colorParser) {
   if (spPr) {
     const lnNode = xmlLookup.getChildByLocalName(spPr, "ln");
     if (lnNode) {
-      const solidFill = xmlLookup.getChildByLocalName(lnNode, "solidFill");
-      const lineColor = colorParser.parseColor(solidFill);
+      const solidFill2 = xmlLookup.getChildByLocalName(lnNode, "solidFill");
+      const lineColor = colorParser.parseColor(solidFill2);
       if (lineColor) {
         result.color = lineColor;
       }
@@ -12969,8 +13317,8 @@ function parseShapeProps(spPrNode, xmlLookup, colorParser) {
   }
   const result = {};
   let hasProps = false;
-  const solidFill = xmlLookup.getChildByLocalName(spPrNode, "solidFill");
-  const fillColor = colorParser.parseColor(solidFill);
+  const solidFill2 = xmlLookup.getChildByLocalName(spPrNode, "solidFill");
+  const fillColor = colorParser.parseColor(solidFill2);
   if (fillColor) {
     result.fillColor = fillColor;
     hasProps = true;
@@ -13150,8 +13498,8 @@ var AXIS_TYPE_MAP = {
   dateAx: "dateAx",
   serAx: "serAx"
 };
-function upsertChartAxisChild(parent, localName, value, getLocalName) {
-  const existingKey = Object.keys(parent).find((k) => getLocalName(k) === localName);
+function upsertChartAxisChild(parent, localName2, value, getLocalName) {
+  const existingKey = Object.keys(parent).find((k) => getLocalName(k) === localName2);
   if (value === void 0) {
     if (existingKey) {
       delete parent[existingKey];
@@ -13161,18 +13509,18 @@ function upsertChartAxisChild(parent, localName, value, getLocalName) {
   if (existingKey) {
     parent[existingKey]["@_val"] = value;
   } else {
-    parent[`c:${localName}`] = { "@_val": value };
+    parent[`c:${localName2}`] = { "@_val": value };
   }
 }
 function parseChartAxes(plotArea, xmlLookup, colorParser, getLocalName) {
   const result = [];
   for (const key of Object.keys(plotArea)) {
-    const localName = getLocalName(key);
-    const axisType = AXIS_TYPE_MAP[localName];
+    const localName2 = getLocalName(key);
+    const axisType = AXIS_TYPE_MAP[localName2];
     if (!axisType) {
       continue;
     }
-    const axisNodes = xmlLookup.getChildrenArrayByLocalName(plotArea, localName);
+    const axisNodes = xmlLookup.getChildrenArrayByLocalName(plotArea, localName2);
     for (const axisNode of axisNodes) {
       const axis = parseSingleAxis(axisNode, axisType, xmlLookup, colorParser);
       if (axis) {
@@ -13369,8 +13717,8 @@ function parseTxPr(txPrNode, xmlLookup, colorParser, target) {
   if (latin?.["@_typeface"]) {
     target.fontFamily = String(latin["@_typeface"]);
   }
-  const solidFill = xmlLookup.getChildByLocalName(defRPr, "solidFill");
-  const fontColor = colorParser.parseColor(solidFill);
+  const solidFill2 = xmlLookup.getChildByLocalName(defRPr, "solidFill");
+  const fontColor = colorParser.parseColor(solidFill2);
   if (fontColor) {
     target.fontColor = fontColor;
   }
@@ -13445,8 +13793,8 @@ var CONTAINER_LOCAL_NAME_TO_TYPE = {
   surfaceChart: "surface",
   surface3DChart: "surface"
 };
-function chartContainerLocalNameToType(localName) {
-  return CONTAINER_LOCAL_NAME_TO_TYPE[localName];
+function chartContainerLocalNameToType(localName2) {
+  return CONTAINER_LOCAL_NAME_TO_TYPE[localName2];
 }
 
 // src/core/utils/chart-cx-parser.ts
@@ -13455,11 +13803,11 @@ function extractCxSeriesColor(ser, xmlLookup) {
   if (!spPr) {
     return void 0;
   }
-  const solidFill = xmlLookup.getChildByLocalName(spPr, "solidFill");
-  if (!solidFill) {
+  const solidFill2 = xmlLookup.getChildByLocalName(spPr, "solidFill");
+  if (!solidFill2) {
     return void 0;
   }
-  const srgb = xmlLookup.getChildByLocalName(solidFill, "srgbClr");
+  const srgb = xmlLookup.getChildByLocalName(solidFill2, "srgbClr");
   if (srgb) {
     const val = String(srgb["@_val"] || "").trim();
     if (val.length === 6) {
@@ -13667,18 +14015,18 @@ function parseWorksheetCells(xml) {
   }
   return cells;
 }
-function findByLocalName2(obj, localName) {
+function findByLocalName2(obj, localName2) {
   for (const key of Object.keys(obj)) {
     const parts = key.split(":");
     const local = parts[parts.length - 1];
-    if (local === localName) {
+    if (local === localName2) {
       return obj[key];
     }
   }
   return void 0;
 }
-function getChildArray(parent, localName) {
-  const child = findByLocalName2(parent, localName);
+function getChildArray(parent, localName2) {
+  const child = findByLocalName2(parent, localName2);
   if (!child) {
     return [];
   }
@@ -13690,8 +14038,8 @@ function getChildArray(parent, localName) {
   }
   return [];
 }
-function getTextValue(parent, localName) {
-  const child = findByLocalName2(parent, localName);
+function getTextValue(parent, localName2) {
+  const child = findByLocalName2(parent, localName2);
   if (child === void 0 || child === null) {
     return void 0;
   }
@@ -16157,8 +16505,8 @@ function createSimpleLookup() {
         return void 0;
       }
       for (const [key, value] of Object.entries(obj)) {
-        const localName = key.includes(":") ? key.split(":").pop() : key;
-        if (localName === name && value && typeof value === "object" && !Array.isArray(value)) {
+        const localName2 = key.includes(":") ? key.split(":").pop() : key;
+        if (localName2 === name && value && typeof value === "object" && !Array.isArray(value)) {
           return value;
         }
       }
@@ -16169,8 +16517,8 @@ function createSimpleLookup() {
         return [];
       }
       for (const [key, value] of Object.entries(obj)) {
-        const localName = key.includes(":") ? key.split(":").pop() : key;
-        if (localName === name) {
+        const localName2 = key.includes(":") ? key.split(":").pop() : key;
+        if (localName2 === name) {
           if (Array.isArray(value)) {
             return value.filter(
               (v) => v !== null && typeof v === "object"
@@ -17297,6 +17645,62 @@ function layoutRelationship(nodes, bounds, themeColorMap) {
   return elements;
 }
 
+// src/core/utils/smartart-node-style-apply.ts
+function styledContentNodes(nodes) {
+  return getContentNodes(nodes);
+}
+function applyNodeStylesToElements(elements, nodes) {
+  const contentNodes = styledContentNodes(nodes);
+  if (contentNodes.length === 0) {
+    return elements;
+  }
+  let shapeIndex = 0;
+  return elements.map((element) => {
+    if (element.type !== "shape") {
+      return element;
+    }
+    const node = contentNodes[shapeIndex++];
+    const style = node?.style;
+    if (!style || Object.keys(style).length === 0) {
+      return element;
+    }
+    const shapeStyle = { ...element.shapeStyle };
+    if (style.fillColor !== void 0) {
+      shapeStyle.fillColor = style.fillColor;
+      shapeStyle.fillMode = "solid";
+    }
+    if (style.lineColor !== void 0) {
+      shapeStyle.strokeColor = style.lineColor;
+    }
+    const baseTextStyle = element.textStyle ?? {};
+    const textStyle = { ...baseTextStyle };
+    if (style.fontColor !== void 0) {
+      textStyle.color = style.fontColor;
+    }
+    if (style.bold !== void 0) {
+      textStyle.bold = style.bold;
+    }
+    if (style.italic !== void 0) {
+      textStyle.italic = style.italic;
+    }
+    const segments = element.textSegments?.map((seg) => ({
+      ...seg,
+      style: {
+        ...seg.style,
+        ...style.fontColor !== void 0 ? { color: style.fontColor } : {},
+        ...style.bold !== void 0 ? { bold: style.bold } : {},
+        ...style.italic !== void 0 ? { italic: style.italic } : {}
+      }
+    }));
+    return {
+      ...element,
+      shapeStyle,
+      textStyle,
+      ...segments ? { textSegments: segments } : {}
+    };
+  });
+}
+
 // src/core/utils/smartart-decompose.ts
 function quickStyleStrokeScale(quickStyle) {
   if (!quickStyle?.effectIntensity) {
@@ -17393,9 +17797,13 @@ function decomposeSmartArt(smartArtData, containerBounds, themeColorMap, layoutD
   if (namedLayout) {
     const namedResult = dispatchNamedLayout(namedLayout, nodes, containerBounds, effectiveThemeMap);
     if (namedResult) {
-      return namedResult;
+      return applyNodeStylesToElements(namedResult, nodes);
     }
   }
+  const algorithmic = dispatchLayoutByType(layoutType, nodes, containerBounds, effectiveThemeMap);
+  return algorithmic ? applyNodeStylesToElements(algorithmic, nodes) : algorithmic;
+}
+function dispatchLayoutByType(layoutType, nodes, containerBounds, effectiveThemeMap) {
   switch (layoutType) {
     case "list":
       return layoutList(nodes, containerBounds, effectiveThemeMap);
@@ -17742,6 +18150,46 @@ function reorderSmartArtNodeToIndex(data, nodeId, newIndex) {
   };
 }
 
+// src/core/utils/smartart-editing-node-style.ts
+function mergeNodeStyle(current, patch) {
+  const merged = { ...current };
+  for (const key of Object.keys(patch)) {
+    const value = patch[key];
+    if (value === void 0) {
+      delete merged[key];
+    } else {
+      merged[key] = value;
+    }
+  }
+  return merged;
+}
+function setSmartArtNodeStyle(data, nodeId, style) {
+  let matched = false;
+  const nodes = data.nodes.map((node) => {
+    if (node.id !== nodeId) {
+      return node;
+    }
+    matched = true;
+    const nextStyle = mergeNodeStyle(node.style, style);
+    const hasStyle = Object.keys(nextStyle).length > 0;
+    const updated = { ...node };
+    if (hasStyle) {
+      updated.style = nextStyle;
+    } else {
+      delete updated.style;
+    }
+    return updated;
+  });
+  if (!matched) {
+    return data;
+  }
+  return {
+    ...data,
+    nodes,
+    drawingShapes: void 0
+  };
+}
+
 // src/core/utils/smartart-editing-reflow-layouts-geometric.ts
 function reflowCycle(nodes, bounds) {
   const size = Math.min(bounds.width, bounds.height);
@@ -18314,14 +18762,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]) {
@@ -18337,207 +18785,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) {
@@ -18584,7 +18831,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);
@@ -19755,18 +20002,18 @@ function extractTagAttribute(xml, tagName, attributeName) {
   const match = xml.match(pattern);
   return match?.groups?.["attributeValue"]?.trim();
 }
-function extractFirstTagText(xml, localName) {
+function extractFirstTagText(xml, localName2) {
   const pattern = new RegExp(
-    `<([\\w.-]+:)?${localName}\\b[^>]*>([\\s\\S]*?)<\\/([\\w.-]+:)?${localName}>`,
+    `<([\\w.-]+:)?${localName2}\\b[^>]*>([\\s\\S]*?)<\\/([\\w.-]+:)?${localName2}>`,
     "i"
   );
   const match = xml.match(pattern);
   return match?.[2]?.replace(/\s+/g, "").trim() || void 0;
 }
-function extractAllTagText(xml, localName) {
+function extractAllTagText(xml, localName2) {
   const result = [];
   const regex = new RegExp(
-    `<([\\w.-]+:)?${localName}\\b[^>]*>([\\s\\S]*?)<\\/([\\w.-]+:)?${localName}>`,
+    `<([\\w.-]+:)?${localName2}\\b[^>]*>([\\s\\S]*?)<\\/([\\w.-]+:)?${localName2}>`,
     "gi"
   );
   let match = regex.exec(xml);
@@ -26399,8 +26646,8 @@ var PptxHandlerRuntime2 = class extends PptxHandlerRuntime {
       return void 0;
     }
     const fillNode = tblBg["a:fill"];
-    const solidFill = fillNode?.["a:solidFill"] ?? tblBg["a:solidFill"];
-    const schemeClr = solidFill?.["a:schemeClr"];
+    const solidFill2 = fillNode?.["a:solidFill"] ?? tblBg["a:solidFill"];
+    const schemeClr = solidFill2?.["a:schemeClr"];
     const schemeColor = schemeClr ? String(schemeClr["@_val"] || "").trim() || void 0 : void 0;
     const fill = schemeColor ? { schemeColor } : void 0;
     const hasEffectLst = Boolean(tblBg["a:effectLst"]);
@@ -26428,11 +26675,11 @@ var PptxHandlerRuntime2 = class extends PptxHandlerRuntime {
     if (!fill) {
       return void 0;
     }
-    const solidFill = fill["a:solidFill"];
-    if (!solidFill) {
+    const solidFill2 = fill["a:solidFill"];
+    if (!solidFill2) {
       return void 0;
     }
-    const schemeClr = solidFill["a:schemeClr"];
+    const schemeClr = solidFill2["a:schemeClr"];
     if (!schemeClr) {
       return void 0;
     }
@@ -30711,10 +30958,10 @@ var PptxHandlerRuntime19 = class _PptxHandlerRuntime extends PptxHandlerRuntime1
     if (csTypeface) {
       style.complexScriptFont = csTypeface;
     }
-    const solidFill = xmlChild(runProperties, "a:solidFill");
-    if (solidFill) {
-      style.color = this.parseColor(solidFill);
-      const colorXml = extractColorChoiceXml(solidFill);
+    const solidFill2 = xmlChild(runProperties, "a:solidFill");
+    if (solidFill2) {
+      style.color = this.parseColor(solidFill2);
+      const colorXml = extractColorChoiceXml(solidFill2);
       if (colorXml) {
         style.colorXml = colorXml;
       }
@@ -31679,13 +31926,13 @@ function serializeTablePropertyFlags(tbl, tableData) {
   }
   tbl["a:tblPr"] = tblPr;
 }
-function replaceFirstTextValueInTree(node, localName, newValue, getXmlLocalName) {
+function replaceFirstTextValueInTree(node, localName2, newValue, getXmlLocalName) {
   if (node === null || node === void 0) {
     return false;
   }
   if (Array.isArray(node)) {
     for (const entry of node) {
-      if (replaceFirstTextValueInTree(entry, localName, newValue, getXmlLocalName)) {
+      if (replaceFirstTextValueInTree(entry, localName2, newValue, getXmlLocalName)) {
         return true;
       }
     }
@@ -31696,13 +31943,13 @@ function replaceFirstTextValueInTree(node, localName, newValue, getXmlLocalName)
   }
   const objectNode = node;
   for (const [key, value] of Object.entries(objectNode)) {
-    if (getXmlLocalName(key) === localName) {
+    if (getXmlLocalName(key) === localName2) {
       if (typeof value === "string" || typeof value === "number") {
         objectNode[key] = newValue;
         return true;
       }
     }
-    if (replaceFirstTextValueInTree(value, localName, newValue, getXmlLocalName)) {
+    if (replaceFirstTextValueInTree(value, localName2, newValue, getXmlLocalName)) {
       return true;
     }
   }
@@ -32790,10 +33037,10 @@ var PptxHandlerRuntime23 = class _PptxHandlerRuntime extends PptxHandlerRuntime2
    * Upsert a `c:<localName>` child with `@_val` on an axis or scaling node.
    * When `value` is undefined, removes any existing child of that local name.
    */
-  upsertChartAxisChild(parent, localName, value) {
+  upsertChartAxisChild(parent, localName2, value) {
     upsertChartAxisChild(
       parent,
-      localName,
+      localName2,
       value,
       (key) => this.compatibilityService.getXmlLocalName(key)
     );
@@ -32827,10 +33074,10 @@ var PptxHandlerRuntime23 = class _PptxHandlerRuntime extends PptxHandlerRuntime2
     cacheNode[ptKey] = buildChartPoints(values);
   }
   /** Replace the first text value found deep in the node tree. */
-  replaceFirstTextValue(node, localName, newValue) {
+  replaceFirstTextValue(node, localName2, newValue) {
     return replaceFirstTextValueInTree(
       node,
-      localName,
+      localName2,
       newValue,
       (key) => this.compatibilityService.getXmlLocalName(key)
     );
@@ -32842,10 +33089,10 @@ var PptxHandlerRuntime23 = class _PptxHandlerRuntime extends PptxHandlerRuntime2
    * Upsert a `c:<localName>` child carrying only an `@_val` attribute on
    * `parent`. When `value` is `undefined` the existing child is removed.
    */
-  upsertValChild(parent, localName, value) {
-    const existing = this.xmlLookupService.getChildByLocalName(parent, localName);
+  upsertValChild(parent, localName2, value) {
+    const existing = this.xmlLookupService.getChildByLocalName(parent, localName2);
     const existingKey = Object.keys(parent).find(
-      (k) => this.compatibilityService.getXmlLocalName(k) === localName
+      (k) => this.compatibilityService.getXmlLocalName(k) === localName2
     );
     if (value === void 0) {
       if (existingKey) {
@@ -32856,7 +33103,7 @@ var PptxHandlerRuntime23 = class _PptxHandlerRuntime extends PptxHandlerRuntime2
     if (existing && existingKey) {
       parent[existingKey] = { ...existing, "@_val": value };
     } else {
-      parent[`c:${localName}`] = { "@_val": value };
+      parent[`c:${localName2}`] = { "@_val": value };
     }
   }
   /**
@@ -33176,27 +33423,27 @@ function applySmartArtChrome(dataModel, chrome, getLocalName) {
   if (!chrome || !chrome.backgroundColor && !chrome.outlineColor && (chrome.outlineWidth === null || chrome.outlineWidth === void 0)) {
     return;
   }
-  const findKey12 = (obj, name) => Object.keys(obj).find((k) => getLocalName(k) === name);
+  const findKey13 = (obj, name) => Object.keys(obj).find((k) => getLocalName(k) === name);
   if (chrome.backgroundColor) {
     const hex8 = chrome.backgroundColor.replace("#", "");
-    const bgKey = findKey12(dataModel, "bg") ?? "dgm:bg";
+    const bgKey = findKey13(dataModel, "bg") ?? "dgm:bg";
     const bg = asObject2(dataModel[bgKey]);
-    const fillKey = findKey12(bg, "solidFill") ?? "a:solidFill";
+    const fillKey = findKey13(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 = findKey12(dataModel, "whole") ?? "dgm:whole";
+    const wholeKey = findKey13(dataModel, "whole") ?? "dgm:whole";
     const whole = asObject2(dataModel[wholeKey]);
-    const lnKey = findKey12(whole, "ln") ?? "a:ln";
+    const lnKey = findKey13(whole, "ln") ?? "a:ln";
     const ln = asObject2(whole[lnKey]);
     if (hasOutlineWidth) {
       ln["@_w"] = String(Math.round(chrome.outlineWidth * 12700));
     }
     if (chrome.outlineColor) {
       const hex8 = chrome.outlineColor.replace("#", "");
-      const fillKey = findKey12(ln, "solidFill") ?? "a:solidFill";
+      const fillKey = findKey13(ln, "solidFill") ?? "a:solidFill";
       ln[fillKey] = { "a:srgbClr": { "@_val": hex8 } };
     }
     whole[lnKey] = ln;
@@ -33204,6 +33451,102 @@ function applySmartArtChrome(dataModel, chrome, getLocalName) {
   }
 }
 
+// src/core/core/runtime/smartart-style-xml.ts
+function localName(key) {
+  const idx = key.indexOf(":");
+  return idx >= 0 ? key.slice(idx + 1) : key;
+}
+function findKey12(obj, local) {
+  return Object.keys(obj).find((k) => localName(k) === local);
+}
+function ensureChild(obj, local, prefixedFallback) {
+  const key = findKey12(obj, local) ?? prefixedFallback;
+  const existing = obj[key];
+  if (existing && typeof existing === "object" && !Array.isArray(existing)) {
+    return existing;
+  }
+  const created = {};
+  obj[key] = created;
+  return created;
+}
+function hexValue(color) {
+  return color.replace(/^#/u, "").toUpperCase();
+}
+function solidFill(color) {
+  return { "a:srgbClr": { "@_val": hexValue(color) } };
+}
+function setSolidFill(parent, color) {
+  const key = findKey12(parent, "solidFill") ?? "a:solidFill";
+  parent[key] = solidFill(color);
+}
+function applyShapeStyle(pt2, style) {
+  if (style.fillColor === void 0 && style.lineColor === void 0) {
+    return;
+  }
+  const spPr = ensureChild(pt2, "spPr", "dgm:spPr");
+  if (style.fillColor !== void 0) {
+    setSolidFill(spPr, style.fillColor);
+  }
+  if (style.lineColor !== void 0) {
+    const ln = ensureChild(spPr, "ln", "a:ln");
+    setSolidFill(ln, style.lineColor);
+  }
+}
+function ensureFirstRunRPr(pt2) {
+  const tKey = findKey12(pt2, "t");
+  if (!tKey) {
+    return void 0;
+  }
+  const body = pt2[tKey];
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    return void 0;
+  }
+  const pKey = findKey12(body, "p");
+  if (!pKey) {
+    return void 0;
+  }
+  const paragraph = body[pKey];
+  const firstP = Array.isArray(paragraph) ? paragraph[0] : paragraph;
+  if (!firstP || typeof firstP !== "object") {
+    return void 0;
+  }
+  const rKey = findKey12(firstP, "r");
+  if (!rKey) {
+    return void 0;
+  }
+  const run = firstP[rKey];
+  const firstR = Array.isArray(run) ? run[0] : run;
+  if (!firstR || typeof firstR !== "object") {
+    return void 0;
+  }
+  return ensureChild(firstR, "rPr", "a:rPr");
+}
+function applyRunStyle(pt2, style) {
+  if (style.bold === void 0 && style.italic === void 0 && style.fontColor === void 0) {
+    return;
+  }
+  const rPr = ensureFirstRunRPr(pt2);
+  if (!rPr) {
+    return;
+  }
+  if (style.bold !== void 0) {
+    rPr["@_b"] = style.bold ? "1" : "0";
+  }
+  if (style.italic !== void 0) {
+    rPr["@_i"] = style.italic ? "1" : "0";
+  }
+  if (style.fontColor !== void 0) {
+    setSolidFill(rPr, style.fontColor);
+  }
+}
+function applySmartArtNodeStyleToPoint(pt2, style) {
+  if (!style || Object.keys(style).length === 0) {
+    return;
+  }
+  applyShapeStyle(pt2, style);
+  applyRunStyle(pt2, style);
+}
+
 // src/core/core/runtime/smartart-xml-builders.ts
 var NON_CONTENT_POINT_TYPES = /* @__PURE__ */ new Set([
   "doc",
@@ -33343,6 +33686,7 @@ function mergeSmartArtPointXml(existingPts, nodes) {
       continue;
     }
     applyTextToExistingPoint(pt2, desired);
+    applySmartArtNodeStyleToPoint(pt2, desired.style);
     seenContentIds.add(modelId);
     merged.push(pt2);
   }
@@ -33356,6 +33700,7 @@ function mergeSmartArtPointXml(existingPts, nodes) {
       ptNode["@_type"] = node.nodeType;
     }
     ptNode["dgm:t"] = shouldRebuildFromRuns(node) ? buildPointFromRuns(node.runs) : buildPointText(node.text);
+    applySmartArtNodeStyleToPoint(ptNode, node.style);
     merged.push(ptNode);
   }
   return merged;
@@ -34329,8 +34674,8 @@ var PptxHandlerRuntime27 = class extends PptxHandlerRuntime26 {
     }
     const obj = node;
     for (const [key, value] of Object.entries(obj)) {
-      const localName = this.compatibilityService.getXmlLocalName(key);
-      if (localName === "extLst" && value && typeof value === "object") {
+      const localName2 = this.compatibilityService.getXmlLocalName(key);
+      if (localName2 === "extLst" && value && typeof value === "object") {
         const extLst = value;
         for (const extKey of Object.keys(extLst)) {
           const extLocalName = this.compatibilityService.getXmlLocalName(extKey);
@@ -36546,9 +36891,9 @@ function applyTableStyleEntryToNode(styleNode, entry) {
 }
 function applyFillToSection(styleNode, sectionKey, fill) {
   const section = ensureSection(styleNode, sectionKey);
-  const tcStyle = ensureChild(section, "a:tcStyle");
-  const fillNode = ensureChild(tcStyle, "a:fill");
-  const solidFill = ensureChild(fillNode, "a:solidFill");
+  const tcStyle = ensureChild2(section, "a:tcStyle");
+  const fillNode = ensureChild2(tcStyle, "a:fill");
+  const solidFill2 = ensureChild2(fillNode, "a:solidFill");
   const schemeClr = { "@_val": fill.schemeColor };
   if (fill.tint !== void 0) {
     schemeClr["a:tint"] = { "@_val": String(fill.tint) };
@@ -36556,14 +36901,14 @@ function applyFillToSection(styleNode, sectionKey, fill) {
   if (fill.shade !== void 0) {
     schemeClr["a:shade"] = { "@_val": String(fill.shade) };
   }
-  for (const key of Object.keys(solidFill)) {
-    delete solidFill[key];
+  for (const key of Object.keys(solidFill2)) {
+    delete solidFill2[key];
   }
-  solidFill["a:schemeClr"] = schemeClr;
+  solidFill2["a:schemeClr"] = schemeClr;
 }
 function applyTextToSection(styleNode, sectionKey, text) {
   const section = ensureSection(styleNode, sectionKey);
-  const tcTxStyle = ensureChild(section, "a:tcTxStyle");
+  const tcTxStyle = ensureChild2(section, "a:tcTxStyle");
   if (text.bold !== void 0) {
     if (text.bold) {
       tcTxStyle["@_b"] = "on";
@@ -36603,7 +36948,7 @@ function ensureSection(styleNode, sectionKey) {
   styleNode[sectionKey] = created;
   return created;
 }
-function ensureChild(parent, key) {
+function ensureChild2(parent, key) {
   const existing = parent[key];
   if (Array.isArray(existing) && existing.length > 0) {
     return existing[0];
@@ -40361,9 +40706,9 @@ var PptxHandlerRuntime56 = class extends PptxHandlerRuntime55 {
       }
       const bgPr = xmlChild(bg, "p:bgPr");
       if (bgPr) {
-        const solidFill = xmlChild(bgPr, "a:solidFill");
-        if (solidFill) {
-          return this.parseColor(solidFill);
+        const solidFill2 = xmlChild(bgPr, "a:solidFill");
+        if (solidFill2) {
+          return this.parseColor(solidFill2);
         }
         const pattFill = xmlChild(bgPr, "a:pattFill");
         if (pattFill) {
@@ -40406,9 +40751,9 @@ var PptxHandlerRuntime56 = class extends PptxHandlerRuntime55 {
     if (idx === 0) {
       return void 0;
     }
-    const solidFill = xmlChild(bgRef, "a:solidFill");
-    if (solidFill) {
-      return this.parseColor(solidFill);
+    const solidFill2 = xmlChild(bgRef, "a:solidFill");
+    if (solidFill2) {
+      return this.parseColor(solidFill2);
     }
     const overrideColor = this.parseColor(bgRef);
     if (this.themeFormatScheme) {
@@ -43227,7 +43572,7 @@ var PptxHandlerRuntime68 = class extends PptxHandlerRuntime67 {
       partPath
     };
   }
-  collectLocalTextValues(node, localName, output) {
+  collectLocalTextValues(node, localName2, output) {
     const MAX_NODES = 1e6;
     const stack = [node];
     let visited = 0;
@@ -43250,7 +43595,7 @@ var PptxHandlerRuntime68 = class extends PptxHandlerRuntime67 {
       }
       const objectNode = current;
       for (const [key, value] of Object.entries(objectNode)) {
-        if (this.compatibilityService.getXmlLocalName(key) === localName) {
+        if (this.compatibilityService.getXmlLocalName(key) === localName2) {
           if (typeof value === "string" || typeof value === "number") {
             const textValue = String(value).trim();
             if (textValue.length > 0) {
@@ -43304,6 +43649,71 @@ var PptxHandlerRuntime68 = class extends PptxHandlerRuntime67 {
     }
     return runs.length > 0 ? runs : void 0;
   }
+  /**
+   * Extract a content point's per-node visual override.
+   *
+   * Reads the point's presentation `spPr` solid fill and line colour, and the
+   * first run's `rPr` bold / italic / solid fill, into a
+   * {@link PptxSmartArtNodeStyle}. Every field is optional and only set when
+   * present, so an unstyled point yields `undefined` (never throws on missing
+   * structure). This lets the editing UI display the node's current colours.
+   */
+  extractSmartArtNodeStyle(point) {
+    const style = {};
+    const spPr = this.xmlLookupService.getChildByLocalName(point, "spPr");
+    if (spPr) {
+      const fill = this.parseColor(this.xmlLookupService.getChildByLocalName(spPr, "solidFill"));
+      if (fill) {
+        style.fillColor = fill;
+      }
+      const ln = this.xmlLookupService.getChildByLocalName(spPr, "ln");
+      if (ln) {
+        const lineColor = this.parseColor(
+          this.xmlLookupService.getChildByLocalName(ln, "solidFill")
+        );
+        if (lineColor) {
+          style.lineColor = lineColor;
+        }
+      }
+    }
+    const rPr = this.firstRunProperties(point);
+    if (rPr) {
+      if (this.xmlBoolean(rPr["@_b"])) {
+        style.bold = true;
+      }
+      if (this.xmlBoolean(rPr["@_i"])) {
+        style.italic = true;
+      }
+      const fontColor = this.parseColor(
+        this.xmlLookupService.getChildByLocalName(rPr, "solidFill")
+      );
+      if (fontColor) {
+        style.fontColor = fontColor;
+      }
+    }
+    return Object.keys(style).length > 0 ? style : void 0;
+  }
+  /** Read the first run's `rPr` of a content point's first paragraph. */
+  firstRunProperties(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 run = this.xmlLookupService.getChildrenArrayByLocalName(paragraph, "r")[0];
+    if (!run) {
+      return void 0;
+    }
+    return this.xmlLookupService.getChildByLocalName(run, "rPr");
+  }
+  /** Interpret an OOXML boolean attribute ("1"/"true"/"on" => true). */
+  xmlBoolean(value) {
+    const v = String(value ?? "").trim().toLowerCase();
+    return v === "1" || v === "true" || v === "on";
+  }
   /**
    * Parse background and outline chrome from `dgm:bg` and `dgm:whole`.
    */
@@ -43318,8 +43728,8 @@ var PptxHandlerRuntime68 = class extends PptxHandlerRuntime67 {
     }
     const chrome = {};
     if (bg) {
-      const solidFill = this.xmlLookupService.getChildByLocalName(bg, "solidFill");
-      const bgColor = this.parseColor(solidFill);
+      const solidFill2 = this.xmlLookupService.getChildByLocalName(bg, "solidFill");
+      const bgColor = this.parseColor(solidFill2);
       if (bgColor) {
         chrome.backgroundColor = bgColor;
       }
@@ -43327,8 +43737,8 @@ var PptxHandlerRuntime68 = class extends PptxHandlerRuntime67 {
     if (whole) {
       const lnNode = this.xmlLookupService.getChildByLocalName(whole, "ln");
       if (lnNode) {
-        const solidFill = this.xmlLookupService.getChildByLocalName(lnNode, "solidFill");
-        const outlineColor = this.parseColor(solidFill);
+        const solidFill2 = this.xmlLookupService.getChildByLocalName(lnNode, "solidFill");
+        const outlineColor = this.parseColor(solidFill2);
         if (outlineColor) {
           chrome.outlineColor = outlineColor;
         }
@@ -43503,8 +43913,8 @@ var PptxHandlerRuntime69 = class _PptxHandlerRuntime extends PptxHandlerRuntime6
     const skewY = xfrm?.["@_skewY"] ? parseInt(String(xfrm["@_skewY"]), 10) / 6e4 : void 0;
     const prstGeom = this.xmlLookupService.getChildByLocalName(spPr, "prstGeom");
     const shapeType = prstGeom ? String(prstGeom["@_prst"] || "rect") : "rect";
-    const solidFill = this.xmlLookupService.getChildByLocalName(spPr, "solidFill");
-    const fillColor = this.parseColor(solidFill);
+    const solidFill2 = this.xmlLookupService.getChildByLocalName(spPr, "solidFill");
+    const fillColor = this.parseColor(solidFill2);
     const lnNode = this.xmlLookupService.getChildByLocalName(spPr, "ln");
     const lnFill = lnNode ? this.xmlLookupService.getChildByLocalName(lnNode, "solidFill") : void 0;
     const strokeColor = this.parseColor(lnFill);
@@ -43608,12 +44018,14 @@ var PptxHandlerRuntime70 = class _PptxHandlerRuntime extends PptxHandlerRuntime6
         return null;
       }
       const runs = this.extractSmartArtNodeRuns(point);
+      const style = this.extractSmartArtNodeStyle(point);
       return {
         id: pointId,
         text: resolvedText.trim(),
         parentId: parentByNodeId.get(pointId),
         nodeType,
-        runs
+        runs,
+        style
       };
     }).filter((entry) => Boolean(entry)).slice(0, MAX_SMARTART_NODES);
     if (nodes.length === 0) {
@@ -43778,10 +44190,10 @@ var PptxHandlerRuntime71 = class extends PptxHandlerRuntime70 {
     };
     const matchedKeys = [];
     for (const key of Object.keys(plotArea)) {
-      const localName = this.compatibilityService.getXmlLocalName(key);
-      const mapped = chartElementMap[localName];
+      const localName2 = this.compatibilityService.getXmlLocalName(key);
+      const mapped = chartElementMap[localName2];
       if (mapped) {
-        matchedKeys.push(localName);
+        matchedKeys.push(localName2);
       }
     }
     if (matchedKeys.length >= 2) {
@@ -43791,8 +44203,8 @@ var PptxHandlerRuntime71 = class extends PptxHandlerRuntime70 {
       return chartElementMap[matchedKeys[0]];
     }
     for (const key of Object.keys(plotArea)) {
-      const localName = this.compatibilityService.getXmlLocalName(key);
-      if (localName === "plotAreaRegion" || localName === "plotSurface") {
+      const localName2 = this.compatibilityService.getXmlLocalName(key);
+      if (localName2 === "plotAreaRegion" || localName2 === "plotSurface") {
         const seriesArr = this.xmlLookupService.getChildrenArrayByLocalName(
           plotArea[key],
           "series"
@@ -44319,8 +44731,8 @@ var PptxHandlerRuntime74 = class extends PptxHandlerRuntime73 {
       if (key.startsWith("@_")) {
         continue;
       }
-      const localName = this.compatibilityService.getXmlLocalName(key);
-      if (localName === "schemeClr") {
+      const localName2 = this.compatibilityService.getXmlLocalName(key);
+      if (localName2 === "schemeClr") {
         const items = Array.isArray(value) ? value : [value];
         for (const item of items) {
           const resolved = this.resolveChartSchemeColor(item);
@@ -44328,7 +44740,7 @@ var PptxHandlerRuntime74 = class extends PptxHandlerRuntime73 {
             output.push(resolved);
           }
         }
-      } else if (localName === "srgbClr") {
+      } else if (localName2 === "srgbClr") {
         const items = Array.isArray(value) ? value : [value];
         for (const item of items) {
           const hex8 = String(
@@ -45131,6 +45543,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);
@@ -45350,6 +45763,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 [];
@@ -45377,6 +45843,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),
@@ -63707,6 +64174,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;
@@ -63814,6 +64282,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;
@@ -63832,6 +64301,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;
@@ -63842,6 +64312,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;
@@ -63941,6 +64412,7 @@ exports.setChartSeriesMarker = setChartSeriesMarker;
 exports.setChartSeriesTrendline = setChartSeriesTrendline;
 exports.setChartTitle = setChartTitle;
 exports.setChartType = setChartType;
+exports.setSmartArtNodeStyle = setSmartArtNodeStyle;
 exports.shouldRenderFallbackLabel = shouldRenderFallbackLabel;
 exports.shouldReturnToZoomSlide = shouldReturnToZoomSlide;
 exports.subtractPolygons = subtractPolygons;
@@ -63954,6 +64426,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;