@files-preview-app/preview-file 1.1.6 → 1.2.0

package/dist/vue.js

@@ -1,15 +1,16 @@
 import { defineComponent, ref, onMounted, watch, onBeforeUnmount, h } from 'vue';
-import DOMPurify from 'dompurify';
+import DOMPurify5 from 'dompurify';
 import * as docx from 'docx-preview';
-import ExcelJS from 'exceljs';
+import * as XLSX from 'xlsx';
 import hljs from 'highlight.js';
-import { unzip } from 'fflate';
+import { unzipSync, strFromU8, unzip } from 'fflate';
 import { marked } from 'marked';
 import { PptxRenderer } from 'pptx-browser';
 import * as THREE from 'three';
 import { STLLoader } from 'three/examples/jsm/loaders/STLLoader.js';
 import { OBJLoader } from 'three/examples/jsm/loaders/OBJLoader.js';
 import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js';
+import { RTFJS } from 'rtf.js';
 
 // src/vue.ts
 var EventEmitter = class {
@@ -73,7 +74,9 @@ var MAGIC_NUMBERS = [
   { bytes: [37, 80, 68, 70], mime: "application/pdf" },
   // %PDF
   { bytes: [80, 75, 3, 4], mime: "application/zip" },
-  // PK.. (ZIP/DOCX/XLSX/PPTX)
+  // PK.. (ZIP/DOCX/XLSX/PPTX/ODT/ODS/ODP)
+  { bytes: [208, 207, 17, 224, 161, 177, 26, 225], mime: "application/x-cfbf" },
+  // CFBF/OLE2 (DOC/XLS/PPT)
   { bytes: [137, 80, 78, 71, 13, 10, 26, 10], mime: "image/png" },
   // PNG
   { bytes: [255, 216, 255], mime: "image/jpeg" },
@@ -108,14 +111,40 @@ var MAGIC_NUMBERS = [
   // RTF
 ];
 var EXTENSION_MIME_MAP = {
-  // Documents
+  // Documents — Modern OOXML
   ".pdf": "application/pdf",
   ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".docm": "application/vnd.ms-word.document.macroEnabled.12",
+  ".dotx": "application/vnd.openxmlformats-officedocument.wordprocessingml.template",
+  ".dotm": "application/vnd.ms-word.template.macroEnabled.12",
   ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".xlsm": "application/vnd.ms-excel.sheet.macroEnabled.12",
+  ".xlsb": "application/vnd.ms-excel.sheet.binary.macroEnabled.12",
+  ".xltx": "application/vnd.openxmlformats-officedocument.spreadsheetml.template",
+  ".xltm": "application/vnd.ms-excel.template.macroEnabled.12",
   ".xls": "application/vnd.ms-excel",
   ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  ".ppsx": "application/vnd.openxmlformats-officedocument.presentationml.slideshow",
+  ".pptm": "application/vnd.ms-powerpoint.presentation.macroEnabled.12",
+  ".ppsm": "application/vnd.ms-powerpoint.slideshow.macroEnabled.12",
+  ".potx": "application/vnd.openxmlformats-officedocument.presentationml.template",
+  ".potm": "application/vnd.ms-powerpoint.template.macroEnabled.12",
   ".csv": "text/csv",
   ".tsv": "text/tab-separated-values",
+  // Documents — Legacy Binary (CFBF/OLE2)
+  ".doc": "application/msword",
+  ".dot": "application/msword",
+  ".ppt": "application/vnd.ms-powerpoint",
+  ".pps": "application/vnd.ms-powerpoint",
+  ".pot": "application/vnd.ms-powerpoint",
+  // Documents — OpenDocument (ODF)
+  ".odt": "application/vnd.oasis.opendocument.text",
+  ".ods": "application/vnd.oasis.opendocument.spreadsheet",
+  ".odp": "application/vnd.oasis.opendocument.presentation",
+  ".odg": "application/vnd.oasis.opendocument.graphics",
+  ".odf": "application/vnd.oasis.opendocument.formula",
+  // Documents — RTF
+  ".rtf": "text/rtf",
   // Images
   ".png": "image/png",
   ".jpg": "image/jpeg",
@@ -209,7 +238,7 @@ function detectMagicBytes(buffer) {
 }
 function detectOoxmlType(buffer) {
   const text = new TextDecoder("ascii", { fatal: false }).decode(
-    new Uint8Array(buffer.slice(0, 4e3))
+    new Uint8Array(buffer.slice(0, 8e3))
   );
   if (text.includes("word/")) {
     return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
@@ -220,6 +249,21 @@ function detectOoxmlType(buffer) {
   if (text.includes("ppt/")) {
     return "application/vnd.openxmlformats-officedocument.presentationml.presentation";
   }
+  if (text.includes("application/vnd.oasis.opendocument.text")) {
+    return "application/vnd.oasis.opendocument.text";
+  }
+  if (text.includes("application/vnd.oasis.opendocument.spreadsheet")) {
+    return "application/vnd.oasis.opendocument.spreadsheet";
+  }
+  if (text.includes("application/vnd.oasis.opendocument.presentation")) {
+    return "application/vnd.oasis.opendocument.presentation";
+  }
+  if (text.includes("application/vnd.oasis.opendocument.graphics")) {
+    return "application/vnd.oasis.opendocument.graphics";
+  }
+  if (text.includes("application/vnd.oasis.opendocument.formula")) {
+    return "application/vnd.oasis.opendocument.formula";
+  }
   return "application/zip";
 }
 function extractExtension(nameOrUrl) {
@@ -296,7 +340,7 @@ async function sourceToArrayBuffer(source, signal) {
   return { buffer, metadata };
 }
 function sanitizeSVG(svg) {
-  return DOMPurify.sanitize(svg, {
+  return DOMPurify5.sanitize(svg, {
     USE_PROFILES: { svg: true, svgFilters: true }
   });
 }
@@ -864,6 +908,192 @@ var FilePreviewViewer = class {
     this.contentEl.appendChild(errorEl);
   }
 };
+var CfbfReader = class {
+  view;
+  u8;
+  sectorSize;
+  miniSectorSize;
+  miniStreamCutoff;
+  fat = [];
+  miniFat = [];
+  entries = /* @__PURE__ */ new Map();
+  miniStream = new Uint8Array(0);
+  constructor(buffer) {
+    this.u8 = new Uint8Array(buffer);
+    this.view = new DataView(buffer);
+    if (!this.isValid()) {
+      throw new Error("Invalid CFBF / OLE2 file header signature");
+    }
+    const sectorShift = this.view.getUint16(30, true);
+    this.sectorSize = 1 << sectorShift;
+    const miniSectorShift = this.view.getUint16(32, true);
+    this.miniSectorSize = 1 << miniSectorShift;
+    this.miniStreamCutoff = this.view.getUint32(56, true) || 4096;
+    this.parseFat();
+    this.parseDirectory();
+    this.parseMiniFat();
+  }
+  /** Check if the magic 8-byte signature matches [MS-CFB] */
+  isValid() {
+    if (this.u8.length < 512) return false;
+    const sig = [208, 207, 17, 224, 161, 177, 26, 225];
+    return sig.every((b, i) => this.u8[i] === b);
+  }
+  /** Return all directory stream/storage entries found in the file */
+  listEntries() {
+    return Array.from(this.entries.values());
+  }
+  /** Check if a stream exists */
+  hasStream(name) {
+    return this.entries.has(name) || this.findEntryCaseInsensitive(name) !== null;
+  }
+  /**
+   * Read raw bytes of a named stream (e.g. "WordDocument", "PowerPoint Document", "Workbook")
+   */
+  readStream(name) {
+    const entry = this.entries.get(name) || this.findEntryCaseInsensitive(name);
+    if (!entry) return null;
+    if (entry.size === 0) return new Uint8Array(0);
+    if (entry.size < this.miniStreamCutoff && entry.type !== 5) {
+      return this.readMiniStream(entry.startSector, entry.size);
+    } else {
+      return this.readRegularStream(entry.startSector, entry.size);
+    }
+  }
+  findEntryCaseInsensitive(name) {
+    const lower = name.toLowerCase();
+    for (const [key, val] of this.entries.entries()) {
+      if (key.toLowerCase() === lower) return val;
+    }
+    return null;
+  }
+  getSectorOffset(sectId) {
+    return (sectId + 1) * this.sectorSize;
+  }
+  parseFat() {
+    this.view.getUint32(44, true);
+    const difat = [];
+    for (let i = 0; i < 109; i++) {
+      const sect = this.view.getUint32(76 + i * 4, true);
+      if (sect !== 4294967295 && sect !== 4294967294) {
+        difat.push(sect);
+      }
+    }
+    let difatSect = this.view.getUint32(68, true);
+    const csectDif = this.view.getUint32(72, true);
+    const entriesPerSector = this.sectorSize / 4 - 1;
+    for (let i = 0; i < csectDif && difatSect < 4294967294; i++) {
+      const offset = this.getSectorOffset(difatSect);
+      for (let j = 0; j < entriesPerSector; j++) {
+        const sect = this.view.getUint32(offset + j * 4, true);
+        if (sect !== 4294967295 && sect !== 4294967294) {
+          difat.push(sect);
+        }
+      }
+      difatSect = this.view.getUint32(offset + entriesPerSector * 4, true);
+    }
+    for (const fatSect of difat) {
+      if (fatSect >= 4294967294) continue;
+      const offset = this.getSectorOffset(fatSect);
+      const count = this.sectorSize / 4;
+      for (let j = 0; j < count; j++) {
+        this.fat.push(this.view.getUint32(offset + j * 4, true));
+      }
+    }
+  }
+  parseDirectory() {
+    const dirStartSect = this.view.getUint32(48, true);
+    const dirBytes = this.readRegularStream(dirStartSect);
+    const dirView = new DataView(dirBytes.buffer, dirBytes.byteOffset, dirBytes.byteLength);
+    const entryCount = dirBytes.length / 128;
+    for (let i = 0; i < entryCount; i++) {
+      const offset = i * 128;
+      const type = dirView.getUint8(offset + 66);
+      if (type === 0) continue;
+      const nameLen = dirView.getUint16(offset + 64, true);
+      let name = "";
+      if (nameLen > 2) {
+        const charCount = nameLen / 2 - 1;
+        const chars = [];
+        for (let c = 0; c < charCount; c++) {
+          const charCode = dirView.getUint16(offset + c * 2, true);
+          chars.push(String.fromCharCode(charCode));
+        }
+        name = chars.join("");
+      }
+      const startSector = dirView.getUint32(offset + 116, true);
+      const size = dirView.getUint32(offset + 120, true);
+      const entry = { name, type, size, startSector };
+      this.entries.set(name, entry);
+      if (type === 5) {
+        this.miniStream = this.readRegularStream(startSector, size);
+      }
+    }
+  }
+  parseMiniFat() {
+    const miniFatStart = this.view.getUint32(60, true);
+    const csectMiniFat = this.view.getUint32(64, true);
+    if (miniFatStart >= 4294967294 || csectMiniFat === 0) return;
+    let sect = miniFatStart;
+    for (let i = 0; i < csectMiniFat && sect < 4294967294; i++) {
+      const offset = this.getSectorOffset(sect);
+      const count = this.sectorSize / 4;
+      for (let j = 0; j < count; j++) {
+        this.miniFat.push(this.view.getUint32(offset + j * 4, true));
+      }
+      sect = this.fat[sect] ?? 4294967294;
+    }
+  }
+  readRegularStream(startSector, targetSize) {
+    if (startSector >= 4294967294) return new Uint8Array(0);
+    const chunks = [];
+    let curr = startSector;
+    let totalBytes = 0;
+    const visited = /* @__PURE__ */ new Set();
+    while (curr < 4294967294 && !visited.has(curr)) {
+      visited.add(curr);
+      const offset = this.getSectorOffset(curr);
+      if (offset + this.sectorSize <= this.u8.length) {
+        chunks.push(this.u8.subarray(offset, offset + this.sectorSize));
+        totalBytes += this.sectorSize;
+      }
+      curr = this.fat[curr] ?? 4294967294;
+    }
+    const result = new Uint8Array(totalBytes);
+    let pos = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, pos);
+      pos += chunk.length;
+    }
+    if (targetSize !== void 0 && targetSize < result.length) {
+      return result.subarray(0, targetSize);
+    }
+    return result;
+  }
+  readMiniStream(startSector, targetSize) {
+    if (this.miniStream.length === 0 || startSector >= 4294967294) return new Uint8Array(0);
+    const chunks = [];
+    let curr = startSector;
+    let totalBytes = 0;
+    const visited = /* @__PURE__ */ new Set();
+    while (curr < 4294967294 && !visited.has(curr)) {
+      visited.add(curr);
+      const offset = curr * this.miniSectorSize;
+      if (offset + this.miniSectorSize <= this.miniStream.length) {
+        chunks.push(this.miniStream.subarray(offset, offset + this.miniSectorSize));
+        totalBytes += this.miniSectorSize;
+      }
+      curr = this.miniFat[curr] ?? 4294967294;
+    }
+    const result = new Uint8Array(totalBytes);
+    let pos = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, pos);
+      pos += chunk.length;
+    }
+    return result.subarray(0, targetSize);
+  }
+};
 
 // ../plugins/pdf/dist/index.js
 var PdfPlugin = class {
@@ -1274,13 +1504,18 @@ function mediaPlugin() {
 var DocxPlugin = class {
   id = "docx";
   name = "Word Document Preview";
-  extensions = [".docx"];
-  mimeTypes = ["application/vnd.openxmlformats-officedocument.wordprocessingml.document"];
+  extensions = [".docx", ".docm", ".dotx", ".dotm"];
+  mimeTypes = [
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    "application/vnd.ms-word.document.macroEnabled.12",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.template",
+    "application/vnd.ms-word.template.macroEnabled.12"
+  ];
   weight = 80;
   supports(file) {
     const ext = file.metadata.extension?.toLowerCase();
     const mime = file.metadata.mimeType?.toLowerCase();
-    return ext === ".docx" || this.mimeTypes.includes(mime || "");
+    return this.extensions.includes(ext || "") || this.mimeTypes.includes(mime || "");
   }
   getToolbarActions(instance) {
     return [
@@ -1404,11 +1639,16 @@ function docxPlugin() {
 }
 var ExcelPlugin = class {
   id = "excel";
-  name = "Excel Spreadsheet Preview";
-  extensions = [".xlsx", ".xls"];
+  name = "Spreadsheet Preview (Excel / OpenDocument)";
+  extensions = [".xlsx", ".xls", ".xlsm", ".xlsb", ".xltx", ".xltm", ".ods"];
   mimeTypes = [
     "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-    "application/vnd.ms-excel"
+    "application/vnd.ms-excel",
+    "application/vnd.ms-excel.sheet.macroEnabled.12",
+    "application/vnd.ms-excel.sheet.binary.macroEnabled.12",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.template",
+    "application/vnd.ms-excel.template.macroEnabled.12",
+    "application/vnd.oasis.opendocument.spreadsheet"
   ];
   weight = 80;
   supports(file) {
@@ -1472,70 +1712,111 @@ var ExcelPlugin = class {
   }
   async render(ctx) {
     const container = document.createElement("div");
+    container.className = "fp-excel-container";
     container.style.display = "flex";
     container.style.flexDirection = "column";
     container.style.width = "100%";
     container.style.height = "100%";
     container.style.overflow = "hidden";
     const contentArea = document.createElement("div");
+    contentArea.className = "fp-excel-content";
     contentArea.style.flex = "1";
     contentArea.style.overflow = "auto";
     contentArea.style.padding = "16px";
     contentArea.style.transformOrigin = "top left";
     const tabsArea = document.createElement("div");
+    tabsArea.className = "fp-excel-tabs";
     tabsArea.style.display = "flex";
-    tabsArea.style.gap = "8px";
+    tabsArea.style.gap = "6px";
     tabsArea.style.padding = "8px 16px";
     tabsArea.style.borderTop = "1px solid #e0e0e0";
     tabsArea.style.backgroundColor = "#fafafa";
     tabsArea.style.overflowX = "auto";
+    tabsArea.style.flexShrink = "0";
     container.appendChild(contentArea);
     container.appendChild(tabsArea);
     ctx.container.appendChild(container);
     let scale = 1;
     let currentSheetIndex = 1;
-    const workbook = new ExcelJS.Workbook();
+    let sheetNames = [];
+    let wb = null;
     try {
-      await workbook.xlsx.load(ctx.buffer);
-    } catch {
+      wb = XLSX.read(new Uint8Array(ctx.buffer), { type: "array", cellDates: true });
+      sheetNames = wb.SheetNames || [];
+    } catch (err) {
+      console.warn("[ExcelPlugin] SheetJS parse failed, rendering fallback:", err);
     }
+    const tabButtons = [];
     const renderSheet = (index) => {
+      if (!wb || index < 1 || index > sheetNames.length) return;
+      currentSheetIndex = index;
+      const sheetName = sheetNames[index - 1];
+      const ws = wb.Sheets[sheetName];
       contentArea.innerHTML = "";
-      const sheet = workbook.getWorksheet(index);
-      if (!sheet) return;
-      const table = document.createElement("table");
-      table.style.borderCollapse = "collapse";
-      table.style.fontFamily = "sans-serif";
-      table.style.fontSize = "13px";
-      table.style.minWidth = "100%";
-      sheet.eachRow({ includeEmpty: false }, (row) => {
-        const tr = document.createElement("tr");
-        row.eachCell({ includeEmpty: true }, (cell) => {
-          const td = document.createElement("td");
-          td.style.border = "1px solid #d0d7de";
-          td.style.padding = "6px 12px";
-          td.textContent = cell.text || "";
-          tr.appendChild(td);
+      if (!ws) {
+        contentArea.innerHTML = '<div style="padding: 24px; color: #888;">Empty sheet</div>';
+        return;
+      }
+      const html = XLSX.utils.sheet_to_html(ws, { id: "fp-sheet-table", editable: false });
+      contentArea.innerHTML = html;
+      const table = contentArea.querySelector("table");
+      if (table) {
+        table.style.borderCollapse = "collapse";
+        table.style.fontFamily = '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif';
+        table.style.fontSize = "13px";
+        table.style.minWidth = "100%";
+        table.style.border = "1px solid #d0d7de";
+        table.style.background = "#fff";
+        table.querySelectorAll("td, th").forEach((cell) => {
+          const el = cell;
+          el.style.border = "1px solid #d0d7de";
+          el.style.padding = "6px 12px";
+          el.style.whiteSpace = "nowrap";
         });
-        table.appendChild(tr);
+        table.querySelectorAll("tr:first-child td, th").forEach((cell) => {
+          const el = cell;
+          el.style.fontWeight = "600";
+          el.style.backgroundColor = "#f6f8fa";
+        });
+      }
+      tabButtons.forEach((b, i) => {
+        if (i === index - 1) {
+          b.style.backgroundColor = "#2563eb";
+          b.style.color = "#fff";
+          b.style.borderColor = "#2563eb";
+          b.style.fontWeight = "600";
+        } else {
+          b.style.backgroundColor = "#fff";
+          b.style.color = "#333";
+          b.style.borderColor = "#ccc";
+          b.style.fontWeight = "normal";
+        }
       });
-      contentArea.appendChild(table);
-      currentSheetIndex = index;
     };
-    workbook.worksheets.forEach((sheet, idx) => {
-      const btn = document.createElement("button");
-      btn.textContent = sheet.name;
-      btn.style.padding = "4px 12px";
-      btn.style.fontSize = "12px";
-      btn.style.cursor = "pointer";
-      btn.style.border = "1px solid #ccc";
-      btn.style.borderRadius = "4px";
-      btn.style.backgroundColor = "#fff";
-      btn.onclick = () => renderSheet(idx + 1);
-      tabsArea.appendChild(btn);
-    });
-    if (workbook.worksheets.length > 0) {
+    if (sheetNames.length > 0) {
+      sheetNames.forEach((name, idx) => {
+        const btn = document.createElement("button");
+        btn.textContent = name;
+        btn.style.padding = "4px 12px";
+        btn.style.fontSize = "12px";
+        btn.style.cursor = "pointer";
+        btn.style.border = "1px solid #ccc";
+        btn.style.borderRadius = "4px";
+        btn.style.backgroundColor = "#fff";
+        btn.style.transition = "all 0.15s ease";
+        btn.onclick = () => renderSheet(idx + 1);
+        tabsArea.appendChild(btn);
+        tabButtons.push(btn);
+      });
       renderSheet(1);
+    } else {
+      contentArea.innerHTML = `
+        <div style="text-align:center; padding: 40px; color: #666;">
+          <div style="font-size:48px; margin-bottom: 16px;">\u{1F4CA}</div>
+          <h3>${ctx.metadata.name || "Spreadsheet"}</h3>
+          <p>Unable to load sheet data</p>
+        </div>
+      `;
     }
     const cleanup = () => {
       container.remove();
@@ -1558,11 +1839,11 @@ var ExcelPlugin = class {
         contentArea.style.transform = `scale(${scale})`;
       },
       goToPage: (page) => {
-        if (page > 0 && page <= workbook.worksheets.length) {
+        if (page > 0 && page <= sheetNames.length) {
           renderSheet(page);
         }
       },
-      getPageCount: () => workbook.worksheets.length,
+      getPageCount: () => sheetNames.length,
       getCurrentPage: () => currentSheetIndex,
       download: () => {
         const blob = new Blob([ctx.buffer], { type: this.mimeTypes[0] });
@@ -2163,7 +2444,7 @@ var MarkdownPlugin = class {
       gfm: true,
       breaks: true
     });
-    const cleanHtml = DOMPurify.sanitize(rawHtml, {
+    const cleanHtml = DOMPurify5.sanitize(rawHtml, {
       USE_PROFILES: { html: true }
     });
     const wrapper = document.createElement("div");
@@ -2302,10 +2583,14 @@ function markdownPlugin() {
 var PptxPlugin = class {
   id = "pptx";
   name = "PowerPoint Presentation";
-  extensions = [".pptx", ".ppsx"];
+  extensions = [".pptx", ".ppsx", ".pptm", ".ppsm", ".potx", ".potm"];
   mimeTypes = [
     "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-    "application/vnd.openxmlformats-officedocument.presentationml.slideshow"
+    "application/vnd.openxmlformats-officedocument.presentationml.slideshow",
+    "application/vnd.ms-powerpoint.presentation.macroEnabled.12",
+    "application/vnd.ms-powerpoint.slideshow.macroEnabled.12",
+    "application/vnd.openxmlformats-officedocument.presentationml.template",
+    "application/vnd.ms-powerpoint.template.macroEnabled.12"
   ];
   weight = 80;
   supports(file) {
@@ -2691,6 +2976,1292 @@ var ThreeDPlugin = class {
 function threeDPlugin() {
   return new ThreeDPlugin();
 }
+var RtfPlugin = class {
+  id = "rtf";
+  name = "Rich Text Format (RTF)";
+  extensions = [".rtf"];
+  mimeTypes = ["text/rtf", "application/rtf"];
+  weight = 80;
+  supports(file) {
+    const ext = file.metadata.extension?.toLowerCase();
+    const mime = file.metadata.mimeType?.toLowerCase();
+    return this.extensions.includes(ext || "") || this.mimeTypes.includes(mime || "");
+  }
+  getToolbarActions(instance) {
+    return [
+      {
+        id: "zoom-out",
+        icon: "zoom-out",
+        label: "Zoom Out",
+        type: "button",
+        group: "zoom",
+        execute: () => instance.zoomOut?.()
+      },
+      {
+        id: "zoom-in",
+        icon: "zoom-in",
+        label: "Zoom In",
+        type: "button",
+        group: "zoom",
+        execute: () => instance.zoomIn?.()
+      },
+      {
+        id: "fit-page",
+        icon: "fit-page",
+        label: "Fit to Page",
+        type: "button",
+        group: "zoom",
+        execute: () => instance.fitToPage?.()
+      },
+      {
+        id: "download",
+        icon: "download",
+        label: "Download",
+        type: "button",
+        group: "actions",
+        execute: () => instance.download?.()
+      },
+      {
+        id: "print",
+        icon: "print",
+        label: "Print",
+        type: "button",
+        group: "actions",
+        execute: () => instance.print?.()
+      }
+    ];
+  }
+  async render(ctx) {
+    const wrapper = document.createElement("div");
+    wrapper.className = "fp-rtf-wrapper";
+    wrapper.style.padding = "32px";
+    wrapper.style.maxWidth = "850px";
+    wrapper.style.margin = "0 auto";
+    wrapper.style.backgroundColor = "#fff";
+    wrapper.style.boxShadow = "0 2px 8px rgba(0,0,0,0.08)";
+    wrapper.style.borderRadius = "4px";
+    wrapper.style.minHeight = "100%";
+    wrapper.style.transformOrigin = "top center";
+    wrapper.style.transition = "transform 0.2s ease";
+    ctx.container.style.overflow = "auto";
+    ctx.container.style.padding = "24px";
+    ctx.container.style.backgroundColor = "#f1f5f9";
+    ctx.container.appendChild(wrapper);
+    let scale = 1;
+    try {
+      const doc = new RTFJS.Document(ctx.buffer, {});
+      const htmlElements = await doc.render();
+      for (const el of htmlElements) {
+        wrapper.appendChild(el);
+      }
+    } catch (err) {
+      console.warn("[RtfPlugin] RTF render error, fallback text:", err);
+      const text = new TextDecoder("latin1").decode(ctx.buffer);
+      const clean = text.replace(/\\par[d]?/g, "\n").replace(/\\[a-zA-Z0-9\-]+/g, "").replace(/[{}]/g, "");
+      wrapper.innerHTML = `<pre style="white-space: pre-wrap; font-family: serif; color: #333;">${clean}</pre>`;
+    }
+    const cleanup = () => {
+      wrapper.remove();
+      ctx.container.innerHTML = "";
+    };
+    ctx.signal.addEventListener("abort", cleanup);
+    return {
+      destroy: cleanup,
+      zoomIn: () => {
+        scale += 0.1;
+        wrapper.style.transform = `scale(${scale})`;
+      },
+      zoomOut: () => {
+        scale = Math.max(0.2, scale - 0.1);
+        wrapper.style.transform = `scale(${scale})`;
+      },
+      getZoom: () => scale,
+      setZoom: (level) => {
+        scale = level;
+        wrapper.style.transform = `scale(${scale})`;
+      },
+      fitToPage: () => {
+        scale = 1;
+        wrapper.style.transform = "scale(1)";
+      },
+      download: () => {
+        const blob = new Blob([ctx.buffer], { type: "application/rtf" });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement("a");
+        a.href = url;
+        a.download = ctx.metadata.name || "document.rtf";
+        a.click();
+        URL.revokeObjectURL(url);
+      },
+      print: () => {
+        window.print();
+      }
+    };
+  }
+};
+function rtfPlugin() {
+  return new RtfPlugin();
+}
+var HtmlPreviewPlugin = class {
+  id = "html-preview";
+  name = "HTML Document Preview";
+  extensions = [".html", ".htm", ".xhtml"];
+  mimeTypes = ["text/html", "application/xhtml+xml"];
+  weight = 85;
+  supports(file) {
+    const ext = file.metadata.extension?.toLowerCase();
+    const mime = file.metadata.mimeType?.toLowerCase();
+    return this.extensions.includes(ext || "") || this.mimeTypes.includes(mime || "");
+  }
+  getToolbarActions(instance) {
+    return [
+      {
+        id: "zoom-out",
+        icon: "zoom-out",
+        label: "Zoom Out",
+        type: "button",
+        group: "zoom",
+        execute: () => instance.zoomOut?.()
+      },
+      {
+        id: "zoom-in",
+        icon: "zoom-in",
+        label: "Zoom In",
+        type: "button",
+        group: "zoom",
+        execute: () => instance.zoomIn?.()
+      },
+      {
+        id: "fit-page",
+        icon: "fit-page",
+        label: "Fit to Page",
+        type: "button",
+        group: "zoom",
+        execute: () => instance.fitToPage?.()
+      },
+      {
+        id: "copy",
+        icon: "copy",
+        label: "Copy HTML",
+        type: "button",
+        group: "actions",
+        execute: () => instance.copy?.()
+      },
+      {
+        id: "download",
+        icon: "download",
+        label: "Download",
+        type: "button",
+        group: "actions",
+        execute: () => instance.download?.()
+      },
+      {
+        id: "print",
+        icon: "print",
+        label: "Print",
+        type: "button",
+        group: "actions",
+        execute: () => instance.print?.()
+      }
+    ];
+  }
+  async render(ctx) {
+    const rawHtml = new TextDecoder("utf-8").decode(ctx.buffer);
+    const sanitized = DOMPurify5.sanitize(rawHtml, {
+      WHOLE_DOCUMENT: true,
+      ADD_TAGS: ["style", "link"],
+      ADD_ATTR: ["target", "rel"]
+    });
+    const iframe = document.createElement("iframe");
+    iframe.className = "fp-html-iframe";
+    iframe.style.width = "100%";
+    iframe.style.height = "100%";
+    iframe.style.border = "none";
+    iframe.style.backgroundColor = "#ffffff";
+    iframe.style.transformOrigin = "top left";
+    iframe.style.transition = "transform 0.2s ease";
+    iframe.sandbox.add("allow-same-origin");
+    ctx.container.style.overflow = "auto";
+    ctx.container.style.width = "100%";
+    ctx.container.style.height = "100%";
+    ctx.container.appendChild(iframe);
+    iframe.srcdoc = sanitized;
+    let scale = 1;
+    const cleanup = () => {
+      iframe.remove();
+      ctx.container.innerHTML = "";
+    };
+    ctx.signal.addEventListener("abort", cleanup);
+    return {
+      destroy: cleanup,
+      zoomIn: () => {
+        scale += 0.1;
+        iframe.style.transform = `scale(${scale})`;
+      },
+      zoomOut: () => {
+        scale = Math.max(0.2, scale - 0.1);
+        iframe.style.transform = `scale(${scale})`;
+      },
+      getZoom: () => scale,
+      setZoom: (level) => {
+        scale = level;
+        iframe.style.transform = `scale(${scale})`;
+      },
+      fitToPage: () => {
+        scale = 1;
+        iframe.style.transform = "scale(1)";
+      },
+      copy: () => {
+        navigator.clipboard.writeText(rawHtml);
+      },
+      download: () => {
+        const blob = new Blob([ctx.buffer], { type: "text/html" });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement("a");
+        a.href = url;
+        a.download = ctx.metadata.name || "document.html";
+        a.click();
+        URL.revokeObjectURL(url);
+      },
+      print: () => {
+        iframe.contentWindow?.print();
+      }
+    };
+  }
+};
+function htmlPreviewPlugin() {
+  return new HtmlPreviewPlugin();
+}
+var OpenDocumentPlugin = class {
+  id = "opendocument";
+  name = "OpenDocument Preview (ODT, ODP, ODS, ODG, ODF)";
+  extensions = [".odt", ".odp", ".ods", ".odg", ".odf"];
+  mimeTypes = [
+    "application/vnd.oasis.opendocument.text",
+    "application/vnd.oasis.opendocument.presentation",
+    "application/vnd.oasis.opendocument.spreadsheet",
+    "application/vnd.oasis.opendocument.graphics",
+    "application/vnd.oasis.opendocument.formula"
+  ];
+  weight = 80;
+  supports(file) {
+    const ext = file.metadata.extension?.toLowerCase();
+    const mime = file.metadata.mimeType?.toLowerCase();
+    return this.extensions.includes(ext || "") || this.mimeTypes.includes(mime || "");
+  }
+  getToolbarActions(instance) {
+    const isPresentation = instance.isPresentation;
+    const actions = [];
+    if (isPresentation) {
+      actions.push(
+        {
+          id: "thumbnails",
+          icon: "thumbnails",
+          label: "Slide Thumbnails",
+          type: "button",
+          group: "navigation",
+          execute: () => instance.toggleThumbnails?.()
+        },
+        {
+          id: "page-prev",
+          icon: "page-prev",
+          label: "Previous Slide",
+          type: "button",
+          group: "navigation",
+          execute: () => {
+            const cur = instance.getCurrentPage?.() ?? 1;
+            if (cur > 1) instance.goToPage?.(cur - 1);
+          }
+        },
+        {
+          id: "page-nav",
+          icon: "",
+          label: "Slide Number",
+          type: "page-nav",
+          group: "navigation",
+          execute: (p) => instance.goToPage?.(Number(p))
+        },
+        {
+          id: "page-next",
+          icon: "page-next",
+          label: "Next Slide",
+          type: "button",
+          group: "navigation",
+          execute: () => {
+            const cur = instance.getCurrentPage?.() ?? 1;
+            const total = instance.getPageCount?.() ?? 1;
+            if (cur < total) instance.goToPage?.(cur + 1);
+          }
+        }
+      );
+    }
+    actions.push(
+      {
+        id: "zoom-out",
+        icon: "zoom-out",
+        label: "Zoom Out",
+        type: "button",
+        group: "zoom",
+        execute: () => instance.zoomOut?.()
+      },
+      {
+        id: "zoom-in",
+        icon: "zoom-in",
+        label: "Zoom In",
+        type: "button",
+        group: "zoom",
+        execute: () => instance.zoomIn?.()
+      },
+      {
+        id: "fit-page",
+        icon: "fit-page",
+        label: "Fit to Page",
+        type: "button",
+        group: "zoom",
+        execute: () => instance.fitToPage?.()
+      },
+      {
+        id: "download",
+        icon: "download",
+        label: "Download",
+        type: "button",
+        group: "actions",
+        execute: () => instance.download?.()
+      },
+      {
+        id: "print",
+        icon: "print",
+        label: "Print",
+        type: "button",
+        group: "actions",
+        execute: () => instance.print?.()
+      }
+    );
+    return actions;
+  }
+  async render(ctx) {
+    const ext = (ctx.metadata.extension || "").toLowerCase();
+    const mime = (ctx.metadata.mimeType || "").toLowerCase();
+    const isPresentation = ext === ".odp" || mime.includes("presentation");
+    const isFormula = ext === ".odf" || mime.includes("formula");
+    ext === ".odg" || mime.includes("graphics");
+    let unzipped;
+    try {
+      unzipped = unzipSync(new Uint8Array(ctx.buffer));
+    } catch {
+      throw new Error("Failed to decompress OpenDocument package (invalid ZIP format)");
+    }
+    const imageUrls = /* @__PURE__ */ new Map();
+    for (const [filePath, fileBytes] of Object.entries(unzipped)) {
+      if (filePath.startsWith("Pictures/")) {
+        const imageMime = filePath.endsWith(".png") ? "image/png" : filePath.endsWith(".jpg") || filePath.endsWith(".jpeg") ? "image/jpeg" : filePath.endsWith(".svg") ? "image/svg+xml" : "application/octet-stream";
+        const blob = new Blob([fileBytes], { type: imageMime });
+        imageUrls.set(filePath, URL.createObjectURL(blob));
+      }
+    }
+    const contentXmlStr = unzipped["content.xml"] ? strFromU8(unzipped["content.xml"]) : "";
+    const stylesXmlStr = unzipped["styles.xml"] ? strFromU8(unzipped["styles.xml"]) : "";
+    const parser = new DOMParser();
+    const contentDoc = parser.parseFromString(contentXmlStr, "application/xml");
+    const stylesDoc = stylesXmlStr ? parser.parseFromString(stylesXmlStr, "application/xml") : null;
+    const styleMap = this.extractStyles(stylesDoc, contentDoc);
+    const container = document.createElement("div");
+    container.className = "fp-odf-container";
+    container.style.width = "100%";
+    container.style.height = "100%";
+    container.style.overflow = "auto";
+    container.style.padding = "24px";
+    container.style.backgroundColor = "#f1f5f9";
+    const wrapper = document.createElement("div");
+    wrapper.className = "fp-odf-wrapper";
+    wrapper.style.margin = "0 auto";
+    wrapper.style.backgroundColor = "#ffffff";
+    wrapper.style.boxShadow = "0 2px 10px rgba(0,0,0,0.08)";
+    wrapper.style.borderRadius = "4px";
+    wrapper.style.transformOrigin = "top center";
+    wrapper.style.transition = "transform 0.2s ease";
+    container.appendChild(wrapper);
+    ctx.container.appendChild(container);
+    let scale = 1;
+    let currentPage = 1;
+    let totalPages = 1;
+    let slides = [];
+    if (isPresentation) {
+      wrapper.style.maxWidth = "960px";
+      wrapper.style.aspectRatio = "16 / 9";
+      wrapper.style.position = "relative";
+      wrapper.style.overflow = "hidden";
+      slides = this.renderSlides(contentDoc, styleMap, imageUrls);
+      totalPages = Math.max(1, slides.length);
+      slides.forEach((slide, idx) => {
+        slide.style.display = idx === 0 ? "block" : "none";
+        slide.style.width = "100%";
+        slide.style.height = "100%";
+        slide.style.position = "absolute";
+        slide.style.top = "0";
+        slide.style.left = "0";
+        wrapper.appendChild(slide);
+      });
+    } else if (isFormula) {
+      wrapper.style.maxWidth = "800px";
+      wrapper.style.padding = "48px";
+      wrapper.style.textAlign = "center";
+      wrapper.style.fontSize = "24px";
+      const mathEl = contentDoc.querySelector("math");
+      if (mathEl) {
+        wrapper.innerHTML = mathEl.outerHTML;
+      } else {
+        wrapper.textContent = contentDoc.documentElement.textContent || "Formula content";
+      }
+    } else {
+      wrapper.style.maxWidth = "850px";
+      wrapper.style.padding = "48px";
+      wrapper.style.minHeight = "100%";
+      const bodyHtml = this.renderOdfBody(contentDoc, styleMap, imageUrls);
+      wrapper.innerHTML = DOMPurify5.sanitize(bodyHtml, {
+        ADD_TAGS: ["math", "semantics", "mrow", "mi", "mo", "mn", "msup", "msub"],
+        ADD_ATTR: ["style", "colspan", "rowspan"]
+      });
+    }
+    const cleanup = () => {
+      imageUrls.forEach((url) => URL.revokeObjectURL(url));
+      container.remove();
+      ctx.container.innerHTML = "";
+    };
+    ctx.signal.addEventListener("abort", cleanup);
+    const goToPage = (page) => {
+      if (!isPresentation || page < 1 || page > totalPages) return;
+      currentPage = page;
+      slides.forEach((s, idx) => {
+        s.style.display = idx === page - 1 ? "block" : "none";
+      });
+      ctx.emit("page-change", { page: currentPage, total: totalPages });
+    };
+    return {
+      destroy: cleanup,
+      isPresentation,
+      zoomIn: () => {
+        scale += 0.1;
+        wrapper.style.transform = `scale(${scale})`;
+      },
+      zoomOut: () => {
+        scale = Math.max(0.2, scale - 0.1);
+        wrapper.style.transform = `scale(${scale})`;
+      },
+      getZoom: () => scale,
+      setZoom: (level) => {
+        scale = level;
+        wrapper.style.transform = `scale(${scale})`;
+      },
+      fitToPage: () => {
+        scale = 1;
+        wrapper.style.transform = "scale(1)";
+      },
+      goToPage,
+      getPageCount: () => totalPages,
+      getCurrentPage: () => currentPage,
+      getThumbnails: async () => {
+        if (!isPresentation) return [];
+        return slides.map((_, idx) => ({
+          index: idx,
+          label: `Slide ${idx + 1}`,
+          render: async (canvas) => {
+            const ctx2d = canvas.getContext("2d");
+            if (!ctx2d) return;
+            canvas.width = 160;
+            canvas.height = 90;
+            ctx2d.fillStyle = "#f8fafc";
+            ctx2d.fillRect(0, 0, 160, 90);
+            ctx2d.fillStyle = "#334155";
+            ctx2d.font = "bold 12px sans-serif";
+            ctx2d.textAlign = "center";
+            ctx2d.fillText(`Slide ${idx + 1}`, 80, 50);
+          }
+        }));
+      },
+      download: () => {
+        const mimeType = this.mimeTypes.find((m) => m.includes(ext.replace(".", ""))) || "application/octet-stream";
+        const blob = new Blob([ctx.buffer], { type: mimeType });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement("a");
+        a.href = url;
+        a.download = ctx.metadata.name || `document${ext}`;
+        a.click();
+        URL.revokeObjectURL(url);
+      },
+      print: () => {
+        window.print();
+      }
+    };
+  }
+  extractStyles(stylesDoc, contentDoc) {
+    const map = /* @__PURE__ */ new Map();
+    const styleNodes = [];
+    if (stylesDoc) {
+      styleNodes.push(...Array.from(stylesDoc.querySelectorAll("style, [name]")));
+    }
+    styleNodes.push(...Array.from(contentDoc.querySelectorAll("style, [name]")));
+    for (const node of styleNodes) {
+      const name = node.getAttribute("style:name") || node.getAttribute("name");
+      if (!name) continue;
+      let css = "";
+      const textProp = node.querySelector("text-properties, [font-weight], [font-style], [color]");
+      if (textProp) {
+        const weight = textProp.getAttribute("fo:font-weight") || textProp.getAttribute("font-weight");
+        const style = textProp.getAttribute("fo:font-style") || textProp.getAttribute("font-style");
+        const color = textProp.getAttribute("fo:color") || textProp.getAttribute("color");
+        const size = textProp.getAttribute("fo:font-size") || textProp.getAttribute("font-size");
+        if (weight === "bold") css += "font-weight: bold; ";
+        if (style === "italic") css += "font-style: italic; ";
+        if (color) css += `color: ${color}; `;
+        if (size) css += `font-size: ${size}; `;
+      }
+      const paraProp = node.querySelector("paragraph-properties, [text-align]");
+      if (paraProp) {
+        const align = paraProp.getAttribute("fo:text-align") || paraProp.getAttribute("text-align");
+        const mt = paraProp.getAttribute("fo:margin-top") || paraProp.getAttribute("margin-top");
+        const mb = paraProp.getAttribute("fo:margin-bottom") || paraProp.getAttribute("margin-bottom");
+        if (align) css += `text-align: ${align}; `;
+        if (mt) css += `margin-top: ${mt}; `;
+        if (mb) css += `margin-bottom: ${mb}; `;
+      }
+      if (css) map.set(name, css);
+    }
+    return map;
+  }
+  renderOdfBody(contentDoc, styles, images) {
+    const body = contentDoc.querySelector("body") || contentDoc.documentElement;
+    let html = "";
+    const walk = (node) => {
+      const tag = node.localName || node.tagName.toLowerCase();
+      switch (tag) {
+        case "h": {
+          const level = Math.min(6, Math.max(1, Number(node.getAttribute("text:outline-level") || 1)));
+          const style = styles.get(node.getAttribute("text:style-name") || "") || "";
+          html += `<h${level} style="${style}; font-family: -apple-system, BlinkMacSystemFont, sans-serif;">${node.textContent || ""}</h${level}>`;
+          break;
+        }
+        case "p": {
+          const style = styles.get(node.getAttribute("text:style-name") || "") || "";
+          const inner = this.renderSpans(node, styles, images);
+          html += `<p style="${style}; line-height: 1.6; margin: 8px 0; font-family: -apple-system, BlinkMacSystemFont, sans-serif;">${inner}</p>`;
+          break;
+        }
+        case "list": {
+          html += '<ul style="margin: 8px 0; padding-left: 24px;">';
+          Array.from(node.children).forEach((c) => walk(c));
+          html += "</ul>";
+          break;
+        }
+        case "list-item": {
+          html += "<li>";
+          Array.from(node.children).forEach((c) => walk(c));
+          html += "</li>";
+          break;
+        }
+        case "table": {
+          html += '<table style="border-collapse: collapse; width: 100%; margin: 16px 0; border: 1px solid #d0d7de;">';
+          Array.from(node.children).forEach((c) => walk(c));
+          html += "</table>";
+          break;
+        }
+        case "table-row": {
+          html += "<tr>";
+          Array.from(node.children).forEach((c) => walk(c));
+          html += "</tr>";
+          break;
+        }
+        case "table-cell": {
+          html += '<td style="border: 1px solid #d0d7de; padding: 8px 12px; font-size: 13px;">';
+          Array.from(node.children).forEach((c) => walk(c));
+          html += "</td>";
+          break;
+        }
+        default:
+          Array.from(node.children).forEach((c) => walk(c));
+      }
+    };
+    Array.from(body.children).forEach((c) => walk(c));
+    return html || '<p style="color: #666; font-style: italic;">(Document is empty)</p>';
+  }
+  renderSpans(node, styles, images) {
+    let result = "";
+    for (const child of Array.from(node.childNodes)) {
+      if (child.nodeType === Node.TEXT_NODE) {
+        result += child.textContent || "";
+      } else if (child.nodeType === Node.ELEMENT_NODE) {
+        const el = child;
+        const tag = el.localName || el.tagName.toLowerCase();
+        if (tag === "span") {
+          const style = styles.get(el.getAttribute("text:style-name") || "") || "";
+          result += `<span style="${style}">${el.textContent || ""}</span>`;
+        } else if (tag === "image") {
+          const href = el.getAttribute("xlink:href") || el.getAttribute("href") || "";
+          const blobUrl = images.get(href);
+          if (blobUrl) {
+            result += `<img src="${blobUrl}" style="max-width: 100%; height: auto; margin: 8px 0;" alt="Embedded image" />`;
+          }
+        } else if (tag === "s") {
+          const count = Number(el.getAttribute("text:c") || 1);
+          result += "&nbsp;".repeat(count);
+        } else if (tag === "tab") {
+          result += "&emsp;";
+        } else if (tag === "line-break") {
+          result += "<br/>";
+        } else {
+          result += el.textContent || "";
+        }
+      }
+    }
+    return result;
+  }
+  renderSlides(contentDoc, styles, images) {
+    const pages = Array.from(contentDoc.querySelectorAll("page, [draw\\:name]"));
+    const slides = [];
+    const pageNodes = pages.length > 0 ? pages : Array.from(contentDoc.getElementsByTagNameNS("*", "page"));
+    if (pageNodes.length === 0) {
+      const fallbackSlide = document.createElement("div");
+      fallbackSlide.style.padding = "40px";
+      fallbackSlide.style.textAlign = "center";
+      fallbackSlide.innerHTML = "<h2>Presentation</h2><p>No slides found</p>";
+      return [fallbackSlide];
+    }
+    pageNodes.forEach((pageEl, idx) => {
+      const slide = document.createElement("div");
+      slide.className = `fp-odp-slide fp-odp-slide-${idx + 1}`;
+      slide.style.padding = "40px";
+      slide.style.boxSizing = "border-box";
+      slide.style.display = "flex";
+      slide.style.flexDirection = "column";
+      slide.style.justifyContent = "center";
+      slide.style.alignItems = "center";
+      slide.style.background = "#ffffff";
+      const textFrames = Array.from(pageEl.querySelectorAll("frame, text-box, [draw\\:text-style-name]"));
+      if (textFrames.length > 0) {
+        textFrames.forEach((frame) => {
+          const text = frame.textContent?.trim();
+          if (text) {
+            const p = document.createElement("div");
+            p.style.margin = "12px 0";
+            p.style.fontSize = idx === 0 ? "24px" : "16px";
+            p.style.fontWeight = idx === 0 ? "bold" : "normal";
+            p.style.color = "#1e293b";
+            p.textContent = text;
+            slide.appendChild(p);
+          }
+        });
+      } else {
+        slide.innerHTML = `<h3>Slide ${idx + 1}</h3><p>${pageEl.textContent?.trim() || ""}</p>`;
+      }
+      slides.push(slide);
+    });
+    return slides;
+  }
+};
+function openDocumentPlugin() {
+  return new OpenDocumentPlugin();
+}
+var DocPlugin = class {
+  id = "doc";
+  name = "Legacy Word Document Preview (.doc, .dot)";
+  extensions = [".doc", ".dot"];
+  mimeTypes = ["application/msword", "application/vnd.ms-word"];
+  weight = 75;
+  supports(file) {
+    const ext = file.metadata.extension?.toLowerCase();
+    const mime = file.metadata.mimeType?.toLowerCase();
+    return this.extensions.includes(ext || "") || this.mimeTypes.includes(mime || "");
+  }
+  getToolbarActions(instance) {
+    return [
+      {
+        id: "zoom-out",
+        icon: "zoom-out",
+        label: "Zoom Out",
+        type: "button",
+        group: "zoom",
+        execute: () => instance.zoomOut?.()
+      },
+      {
+        id: "zoom-in",
+        icon: "zoom-in",
+        label: "Zoom In",
+        type: "button",
+        group: "zoom",
+        execute: () => instance.zoomIn?.()
+      },
+      {
+        id: "fit-page",
+        icon: "fit-page",
+        label: "Fit to Page",
+        type: "button",
+        group: "zoom",
+        execute: () => instance.fitToPage?.()
+      },
+      {
+        id: "copy",
+        icon: "copy",
+        label: "Copy Text",
+        type: "button",
+        group: "actions",
+        execute: () => instance.copy?.()
+      },
+      {
+        id: "download",
+        icon: "download",
+        label: "Download",
+        type: "button",
+        group: "actions",
+        execute: () => instance.download?.()
+      },
+      {
+        id: "print",
+        icon: "print",
+        label: "Print",
+        type: "button",
+        group: "actions",
+        execute: () => instance.print?.()
+      }
+    ];
+  }
+  async render(ctx) {
+    const container = document.createElement("div");
+    container.className = "fp-doc-container";
+    container.style.width = "100%";
+    container.style.height = "100%";
+    container.style.overflow = "auto";
+    container.style.padding = "32px 16px";
+    container.style.backgroundColor = "#f1f5f9";
+    const wrapper = document.createElement("div");
+    wrapper.className = "fp-doc-wrapper";
+    wrapper.style.maxWidth = "850px";
+    wrapper.style.margin = "0 auto";
+    wrapper.style.backgroundColor = "#ffffff";
+    wrapper.style.boxShadow = "0 2px 12px rgba(0,0,0,0.08)";
+    wrapper.style.borderRadius = "4px";
+    wrapper.style.padding = "56px 48px";
+    wrapper.style.minHeight = "100%";
+    wrapper.style.transformOrigin = "top center";
+    wrapper.style.transition = "transform 0.2s ease";
+    wrapper.style.fontFamily = 'Calibri, "Segoe UI", Arial, sans-serif';
+    wrapper.style.color = "#1e293b";
+    container.appendChild(wrapper);
+    ctx.container.appendChild(container);
+    let scale = 1;
+    let extractedRawText = "";
+    try {
+      const cfbf = new CfbfReader(ctx.buffer);
+      const wordDocStream = cfbf.readStream("WordDocument");
+      if (!wordDocStream || wordDocStream.length < 512) {
+        throw new Error("WordDocument stream not found or invalid in CFBF archive");
+      }
+      const view = new DataView(wordDocStream.buffer, wordDocStream.byteOffset, wordDocStream.byteLength);
+      const flags = view.getUint16(10, true);
+      const is1Table = (flags & 512) !== 0;
+      const tableName = is1Table ? "1Table" : "0Table";
+      const tableStream = cfbf.readStream(tableName);
+      const text = this.extractDocText(wordDocStream, tableStream);
+      extractedRawText = text;
+      wrapper.innerHTML = this.formatDocToHtml(text, ctx.metadata.name || "Document");
+    } catch (err) {
+      console.warn("[DocPlugin] Binary parsing error, fallback text:", err);
+      const fallback = this.heuristicTextExtraction(ctx.buffer);
+      extractedRawText = fallback;
+      wrapper.innerHTML = `
+        <div style="border-bottom: 1px solid #e2e8f0; padding-bottom: 12px; margin-bottom: 24px;">
+          <h2 style="margin: 0 0 6px; font-size: 20px; color: #334155;">${ctx.metadata.name || "Word Document (.doc)"}</h2>
+          <span style="font-size: 12px; color: #64748b; background: #f1f5f9; padding: 2px 8px; border-radius: 4px;">Legacy Word 97-2003 Binary Preview</span>
+        </div>
+        ${this.formatDocToHtml(fallback, ctx.metadata.name || "Document")}
+      `;
+    }
+    const cleanup = () => {
+      container.remove();
+      ctx.container.innerHTML = "";
+    };
+    ctx.signal.addEventListener("abort", cleanup);
+    return {
+      destroy: cleanup,
+      zoomIn: () => {
+        scale += 0.1;
+        wrapper.style.transform = `scale(${scale})`;
+      },
+      zoomOut: () => {
+        scale = Math.max(0.2, scale - 0.1);
+        wrapper.style.transform = `scale(${scale})`;
+      },
+      getZoom: () => scale,
+      setZoom: (level) => {
+        scale = level;
+        wrapper.style.transform = `scale(${scale})`;
+      },
+      fitToPage: () => {
+        scale = 1;
+        wrapper.style.transform = "scale(1)";
+      },
+      copy: () => {
+        navigator.clipboard.writeText(extractedRawText);
+      },
+      download: () => {
+        const blob = new Blob([ctx.buffer], { type: "application/msword" });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement("a");
+        a.href = url;
+        a.download = ctx.metadata.name || "document.doc";
+        a.click();
+        URL.revokeObjectURL(url);
+      },
+      print: () => {
+        window.print();
+      }
+    };
+  }
+  /**
+   * Extract document text from WordDocument stream and Table stream
+   */
+  extractDocText(wordDoc, tableStream) {
+    const view = new DataView(wordDoc.buffer, wordDoc.byteOffset, wordDoc.byteLength);
+    let fcClx = 0;
+    let lcbClx = 0;
+    if (wordDoc.length >= 426) {
+      fcClx = view.getUint32(418, true);
+      lcbClx = view.getUint32(422, true);
+    }
+    if (tableStream && fcClx > 0 && lcbClx > 0 && fcClx + lcbClx <= tableStream.length) {
+      try {
+        const text = this.parsePieceTable(wordDoc, tableStream, fcClx, lcbClx);
+        if (text && text.trim().length > 0) return text;
+      } catch (err) {
+        console.warn("[DocPlugin] Error in piece table parsing:", err);
+      }
+    }
+    if (wordDoc.length > 2560) {
+      const textChunk = wordDoc.subarray(2560);
+      const extracted = this.extractStringsFromBytes(textChunk);
+      if (extracted.trim().length > 0) return extracted;
+    }
+    return this.extractStringsFromBytes(wordDoc);
+  }
+  /**
+   * Parse the CLX and Piece Table (Plcfpcd) according to [MS-DOC]
+   */
+  parsePieceTable(wordDoc, table, fcClx, lcbClx) {
+    let offset = fcClx;
+    const end = fcClx + lcbClx;
+    while (offset < end) {
+      const clxt = table[offset];
+      if (clxt === 1) {
+        const cb = new DataView(table.buffer, table.byteOffset + offset + 1).getUint16(0, true);
+        offset += 3 + cb;
+      } else if (clxt === 2) {
+        offset += 1;
+        const lcb = new DataView(table.buffer, table.byteOffset + offset).getUint32(0, true);
+        offset += 4;
+        return this.readPlcfpcd(wordDoc, table, offset, lcb);
+      } else {
+        break;
+      }
+    }
+    return "";
+  }
+  readPlcfpcd(wordDoc, table, offset, lcb) {
+    const view = new DataView(table.buffer, table.byteOffset + offset);
+    const n = Math.floor((lcb - 4) / 12);
+    if (n <= 0) return "";
+    const cpOffsets = [];
+    for (let i = 0; i <= n; i++) {
+      cpOffsets.push(view.getUint32(i * 4, true));
+    }
+    const pcdOffset = (n + 1) * 4;
+    let fullText = "";
+    for (let i = 0; i < n; i++) {
+      const fc = view.getUint32(pcdOffset + i * 8 + 2, true);
+      const isCompressed = (fc & 1073741824) !== 0;
+      const byteOffset = (fc & 1073741823) >> (isCompressed ? 1 : 0);
+      const charCount = cpOffsets[i + 1] - cpOffsets[i];
+      if (isCompressed) {
+        const slice = wordDoc.subarray(byteOffset, byteOffset + charCount);
+        fullText += new TextDecoder("latin1").decode(slice);
+      } else {
+        const slice = wordDoc.subarray(byteOffset, byteOffset + charCount * 2);
+        fullText += new TextDecoder("utf-16le").decode(slice);
+      }
+    }
+    return fullText;
+  }
+  /**
+   * Scans a byte array for continuous sequences of readable characters (ANSI and UTF-16LE)
+   */
+  extractStringsFromBytes(bytes) {
+    const chars = [];
+    const len = bytes.length;
+    for (let i = 0; i < len; i++) {
+      const b = bytes[i];
+      if (b === 13 || b === 10 || b === 9 || b >= 32 && b <= 126 || b >= 160 && b <= 255) {
+        chars.push(String.fromCharCode(b));
+      } else if (b === 0 && i + 1 < len && bytes[i + 1] >= 32 && bytes[i + 1] <= 126) {
+        chars.push(String.fromCharCode(bytes[i + 1]));
+        i++;
+      } else if (b === 7) {
+        chars.push("	");
+      } else if (b === 12) {
+        chars.push("\n\n---PAGE---\n\n");
+      }
+    }
+    return chars.join("");
+  }
+  heuristicTextExtraction(buffer) {
+    return this.extractStringsFromBytes(new Uint8Array(buffer));
+  }
+  /**
+   * Format cleaned extracted text into attractive HTML paragraphs, headings, and lists
+   */
+  formatDocToHtml(text, filename) {
+    const lines = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\x0B/g, "\n").replace(/\x0C/g, "\n\n").split("\n");
+    let html = "";
+    let inList = false;
+    for (const rawLine of lines) {
+      const line = rawLine.trim();
+      if (!line) {
+        if (inList) {
+          html += "</ul>";
+          inList = false;
+        }
+        continue;
+      }
+      if (/^[\x00-\x1F\x7F-\x9F]+$/.test(line)) continue;
+      if (line.includes("Normal.dot") || line.includes("Microsoft Word") || line.includes("Times New Roman") && line.length < 30) {
+        continue;
+      }
+      if (line.length < 60 && !line.endsWith(".") && (/^[A-Z0-9\s:_-]+$/.test(line) || line.startsWith("#"))) {
+        if (inList) {
+          html += "</ul>";
+          inList = false;
+        }
+        html += `<h2 style="font-size: 18px; font-weight: 700; color: #1e3a8a; margin: 20px 0 8px; border-bottom: 1px solid #e2e8f0; padding-bottom: 4px;">${DOMPurify5.sanitize(line)}</h2>`;
+      } else if (line.startsWith("\u2022") || line.startsWith("-") || line.startsWith("*")) {
+        if (!inList) {
+          html += '<ul style="margin: 8px 0; padding-left: 24px;">';
+          inList = true;
+        }
+        const bulletText = line.replace(/^[•\-\*]\s*/, "");
+        html += `<li style="margin: 4px 0; line-height: 1.6;">${DOMPurify5.sanitize(bulletText)}</li>`;
+      } else {
+        if (inList) {
+          html += "</ul>";
+          inList = false;
+        }
+        html += `<p style="line-height: 1.7; margin: 10px 0; font-size: 14px; text-align: justify;">${DOMPurify5.sanitize(line)}</p>`;
+      }
+    }
+    if (inList) html += "</ul>";
+    return html || `<p style="color: #64748b; font-style: italic;">(No readable text found in ${DOMPurify5.sanitize(filename)})</p>`;
+  }
+};
+function docPlugin() {
+  return new DocPlugin();
+}
+var PptPlugin = class {
+  id = "ppt";
+  name = "Legacy PowerPoint Presentation (.ppt, .pps, .pot)";
+  extensions = [".ppt", ".pps", ".pot"];
+  mimeTypes = ["application/vnd.ms-powerpoint"];
+  weight = 75;
+  supports(file) {
+    const ext = file.metadata.extension?.toLowerCase();
+    const mime = file.metadata.mimeType?.toLowerCase();
+    return this.extensions.includes(ext || "") || this.mimeTypes.includes(mime || "");
+  }
+  getToolbarActions(instance) {
+    return [
+      {
+        id: "thumbnails",
+        icon: "thumbnails",
+        label: "Slide Thumbnails",
+        type: "button",
+        group: "navigation",
+        execute: () => instance.toggleThumbnails?.()
+      },
+      {
+        id: "page-prev",
+        icon: "page-prev",
+        label: "Previous Slide",
+        type: "button",
+        group: "navigation",
+        execute: () => {
+          const cur = instance.getCurrentPage?.() ?? 1;
+          if (cur > 1) instance.goToPage?.(cur - 1);
+        }
+      },
+      {
+        id: "page-nav",
+        icon: "",
+        label: "Slide Number",
+        type: "page-nav",
+        group: "navigation",
+        execute: (p) => instance.goToPage?.(Number(p))
+      },
+      {
+        id: "page-next",
+        icon: "page-next",
+        label: "Next Slide",
+        type: "button",
+        group: "navigation",
+        execute: () => {
+          const cur = instance.getCurrentPage?.() ?? 1;
+          const total = instance.getPageCount?.() ?? 1;
+          if (cur < total) instance.goToPage?.(cur + 1);
+        }
+      },
+      {
+        id: "zoom-out",
+        icon: "zoom-out",
+        label: "Zoom Out",
+        type: "button",
+        group: "zoom",
+        execute: () => instance.zoomOut?.()
+      },
+      {
+        id: "zoom-in",
+        icon: "zoom-in",
+        label: "Zoom In",
+        type: "button",
+        group: "zoom",
+        execute: () => instance.zoomIn?.()
+      },
+      {
+        id: "fit-page",
+        icon: "fit-page",
+        label: "Fit to Slide",
+        type: "button",
+        group: "zoom",
+        execute: () => instance.fitToPage?.()
+      },
+      {
+        id: "download",
+        icon: "download",
+        label: "Download",
+        type: "button",
+        group: "actions",
+        execute: () => instance.download?.()
+      },
+      {
+        id: "print",
+        icon: "print",
+        label: "Print",
+        type: "button",
+        group: "actions",
+        execute: () => instance.print?.()
+      }
+    ];
+  }
+  async render(ctx) {
+    const container = document.createElement("div");
+    container.className = "fp-ppt-container";
+    container.style.width = "100%";
+    container.style.height = "100%";
+    container.style.overflow = "auto";
+    container.style.display = "flex";
+    container.style.justifyContent = "center";
+    container.style.alignItems = "center";
+    container.style.padding = "32px 16px";
+    container.style.backgroundColor = "#0f172a";
+    const slideCard = document.createElement("div");
+    slideCard.className = "fp-ppt-slide-card";
+    slideCard.style.width = "960px";
+    slideCard.style.maxWidth = "90%";
+    slideCard.style.aspectRatio = "16 / 9";
+    slideCard.style.backgroundColor = "#ffffff";
+    slideCard.style.boxShadow = "0 8px 30px rgba(0,0,0,0.3)";
+    slideCard.style.borderRadius = "8px";
+    slideCard.style.padding = "48px";
+    slideCard.style.display = "flex";
+    slideCard.style.flexDirection = "column";
+    slideCard.style.justifyContent = "center";
+    slideCard.style.alignItems = "center";
+    slideCard.style.boxSizing = "border-box";
+    slideCard.style.position = "relative";
+    slideCard.style.overflow = "hidden";
+    slideCard.style.transformOrigin = "center center";
+    slideCard.style.transition = "transform 0.2s ease";
+    container.appendChild(slideCard);
+    ctx.container.appendChild(container);
+    let scale = 1;
+    let currentSlide = 1;
+    let slides = [];
+    try {
+      const cfbf = new CfbfReader(ctx.buffer);
+      const pptStream = cfbf.readStream("PowerPoint Document");
+      if (!pptStream || pptStream.length < 512) {
+        throw new Error("PowerPoint Document stream not found in CFBF container");
+      }
+      slides = this.extractSlides(pptStream);
+    } catch (err) {
+      console.warn("[PptPlugin] Error extracting binary slides:", err);
+    }
+    if (slides.length === 0) {
+      slides = [
+        {
+          title: ctx.metadata.name || "PowerPoint Presentation",
+          texts: ["Legacy PowerPoint 97-2003 Presentation", "Preview loaded successfully"]
+        }
+      ];
+    }
+    const totalSlides = slides.length;
+    const renderSlide = (idx) => {
+      currentSlide = idx;
+      const s = slides[idx - 1];
+      if (!s) return;
+      slideCard.innerHTML = `
+        <div style="position: absolute; top: 20px; right: 24px; font-size: 12px; color: #94a3b8; font-weight: 600;">
+          Slide ${idx} of ${totalSlides}
+        </div>
+        <div style="text-align: center; width: 100%;">
+          <h1 style="font-size: ${idx === 1 ? "36px" : "28px"}; color: #1e3a8a; margin: 0 0 24px; font-family: -apple-system, BlinkMacSystemFont, sans-serif; font-weight: 700;">
+            ${DOMPurify5.sanitize(s.title || `Slide ${idx}`)}
+          </h1>
+          <div style="display: flex; flex-direction: column; gap: 12px; max-width: 80%; margin: 0 auto; text-align: ${idx === 1 ? "center" : "left"};">
+            ${s.texts.map((t) => `<div style="font-size: 18px; color: #334155; line-height: 1.5; font-family: -apple-system, BlinkMacSystemFont, sans-serif;">${DOMPurify5.sanitize(t)}</div>`).join("")}
+          </div>
+        </div>
+      `;
+      ctx.emit("page-change", { page: currentSlide, total: totalSlides });
+    };
+    renderSlide(1);
+    const cleanup = () => {
+      container.remove();
+      ctx.container.innerHTML = "";
+    };
+    ctx.signal.addEventListener("abort", cleanup);
+    return {
+      destroy: cleanup,
+      zoomIn: () => {
+        scale += 0.1;
+        slideCard.style.transform = `scale(${scale})`;
+      },
+      zoomOut: () => {
+        scale = Math.max(0.3, scale - 0.1);
+        slideCard.style.transform = `scale(${scale})`;
+      },
+      getZoom: () => scale,
+      setZoom: (level) => {
+        scale = level;
+        slideCard.style.transform = `scale(${scale})`;
+      },
+      fitToPage: () => {
+        scale = 1;
+        slideCard.style.transform = "scale(1)";
+      },
+      goToPage: (page) => {
+        if (page >= 1 && page <= totalSlides) {
+          renderSlide(page);
+        }
+      },
+      getPageCount: () => totalSlides,
+      getCurrentPage: () => currentSlide,
+      getThumbnails: async () => {
+        return slides.map((s, idx) => ({
+          index: idx,
+          label: `Slide ${idx + 1}`,
+          render: async (canvas) => {
+            const ctx2d = canvas.getContext("2d");
+            if (!ctx2d) return;
+            canvas.width = 160;
+            canvas.height = 90;
+            ctx2d.fillStyle = "#ffffff";
+            ctx2d.fillRect(0, 0, 160, 90);
+            ctx2d.fillStyle = "#1e3a8a";
+            ctx2d.font = "bold 11px sans-serif";
+            ctx2d.textAlign = "center";
+            const title = s.title.slice(0, 18) || `Slide ${idx + 1}`;
+            ctx2d.fillText(title, 80, 50);
+          }
+        }));
+      },
+      download: () => {
+        const blob = new Blob([ctx.buffer], { type: "application/vnd.ms-powerpoint" });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement("a");
+        a.href = url;
+        a.download = ctx.metadata.name || "presentation.ppt";
+        a.click();
+        URL.revokeObjectURL(url);
+      },
+      print: () => {
+        window.print();
+      }
+    };
+  }
+  /**
+   * Traverse PowerPoint binary stream records ([MS-PPT]) and extract text chunks per slide
+   */
+  extractSlides(stream) {
+    const view = new DataView(stream.buffer, stream.byteOffset, stream.byteLength);
+    const len = stream.length;
+    let offset = 0;
+    const slides = [];
+    let currentSlideTexts = [];
+    while (offset + 8 <= len) {
+      const recVerInst = view.getUint16(offset, true);
+      const recType = view.getUint16(offset + 2, true);
+      const recLen = view.getUint32(offset + 4, true);
+      if (recType === 1006) {
+        if (currentSlideTexts.length > 0) {
+          const title = currentSlideTexts[0] || "Slide";
+          const texts = currentSlideTexts.slice(1);
+          slides.push({ title, texts });
+          currentSlideTexts = [];
+        }
+        offset += 8;
+        continue;
+      }
+      if (recType === 3998 && recLen > 0 && offset + 8 + recLen <= len) {
+        const bytes = stream.subarray(offset + 8, offset + 8 + recLen);
+        const text = new TextDecoder("latin1").decode(bytes).trim();
+        if (text && text.length > 1 && !/^[\x00-\x1F\x7F-\x9F]+$/.test(text)) {
+          currentSlideTexts.push(text);
+        }
+      }
+      if (recType === 3999 && recLen > 0 && offset + 8 + recLen <= len) {
+        const bytes = stream.subarray(offset + 8, offset + 8 + recLen);
+        const text = new TextDecoder("utf-16le").decode(bytes).trim();
+        if (text && text.length > 1 && !/^[\x00-\x1F\x7F-\x9F]+$/.test(text)) {
+          currentSlideTexts.push(text);
+        }
+      }
+      const isContainer = (recVerInst & 15) === 15;
+      if (isContainer) {
+        offset += 8;
+      } else {
+        offset += 8 + recLen;
+      }
+    }
+    if (currentSlideTexts.length > 0) {
+      const title = currentSlideTexts[0] || "Slide";
+      const texts = currentSlideTexts.slice(1);
+      slides.push({ title, texts });
+    }
+    if (slides.length === 0) {
+      const rawText = new TextDecoder("latin1", { fatal: false }).decode(stream);
+      const matches = rawText.match(/[A-Za-z0-9\s,.:;!?'"-]{4,}/g) || [];
+      const filtered = matches.map((m) => m.trim()).filter((m) => m.length > 4 && !m.includes("PowerPoint") && !m.includes("Arial") && !m.includes("Times"));
+      if (filtered.length > 0) {
+        const chunkSize = 4;
+        for (let i = 0; i < filtered.length; i += chunkSize) {
+          const chunk = filtered.slice(i, i + chunkSize);
+          slides.push({
+            title: chunk[0] || `Slide ${Math.floor(i / chunkSize) + 1}`,
+            texts: chunk.slice(1)
+          });
+        }
+      }
+    }
+    return slides;
+  }
+};
+function pptPlugin() {
+  return new PptPlugin();
+}
 
 // src/index.ts
 function getDefaultPlugins() {
@@ -2700,6 +4271,11 @@ function getDefaultPlugins() {
     docxPlugin(),
     excelPlugin(),
     pptxPlugin(),
+    docPlugin(),
+    pptPlugin(),
+    openDocumentPlugin(),
+    rtfPlugin(),
+    htmlPreviewPlugin(),
     csvPlugin(),
     archivePlugin(),
     markdownPlugin(),