pptx-viewer-core 1.1.33 → 1.1.34

package/dist/index.js

@@ -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);
@@ -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";
@@ -18314,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]) {
@@ -18337,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) {
@@ -18584,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);
@@ -45131,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);
@@ -45350,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 [];
@@ -45377,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),
@@ -63707,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;
@@ -63814,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;
@@ -63832,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;
@@ -63842,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;
@@ -63954,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;