@open-file-viewer/core 0.1.16 → 0.1.18

package/dist/index.js

@@ -331,7 +331,7 @@ function getFileNameFromUrl(source) {
 function getExtension(name) {
   const clean = name.split("?")[0]?.split("#")[0] || "";
   const index = clean.lastIndexOf(".");
-  return index >= 0 ? clean.slice(index + 1).toLowerCase() : "";
+  return index >= 0 ? clean.slice(index + 1).split("!", 1)[0].toLowerCase() : "";
 }
 function isTextLike(file) {
   const textFileName = normalizeFileName(file.name);
@@ -590,7 +590,7 @@ var defaultMessages = {
 };
 function resolveMessages(options) {
   return {
-    ...defaultMessages[options.locale || "zh-CN"],
+    ...defaultMessages[options.locale || "en-US"],
     ...options.messages
   };
 }
@@ -5870,6 +5870,1100 @@ function decodeXml(value) {
 // src/plugins/office.ts
 import JSZip3 from "jszip";
 import DOMPurify2 from "dompurify";
+
+// src/plugins/msdoc.ts
+var CFB_SIGNATURE = [208, 207, 17, 224, 161, 177, 26, 225];
+var FREE_SECTOR = 4294967295;
+var END_OF_CHAIN = 4294967294;
+var FAT_SECTOR = 4294967293;
+var DIFAT_SECTOR = 4294967292;
+var MINI_STREAM_CUTOFF = 4096;
+var STSH_FC_LCB_INDEX = 1;
+var CLX_FC_LCB_INDEX = 33;
+var WORD_PAGE_BREAK = "\f";
+function parseLegacyWordDocument(input) {
+  const cfb = parseCompoundFile(new Uint8Array(input));
+  const wordDocument = cfb.getStream("WordDocument");
+  if (!wordDocument) {
+    throw new Error("\u672A\u627E\u5230 WordDocument \u6D41");
+  }
+  const fib = parseFib(wordDocument);
+  if (fib.encrypted) {
+    throw new Error("\u6682\u4E0D\u652F\u6301\u52A0\u5BC6\u7684 .doc \u6587\u4EF6");
+  }
+  const tableStreamName = fib.useOneTable ? "1Table" : "0Table";
+  const tableStream = cfb.getStream(tableStreamName);
+  if (!tableStream) {
+    throw new Error(`\u672A\u627E\u5230 ${tableStreamName} \u8868\u6D41`);
+  }
+  const assets = extractImageAssets(cfb);
+  const styles = parseStyleTable(tableStream, fib);
+  const pieces = parseClxPieces(tableStream, fib.fcClx, fib.lcbClx);
+  const text = pieces.length > 0 ? readPieceTableText(wordDocument, pieces, fib.ccpText) : readFibTextFallback(wordDocument, fib);
+  const paragraphs = splitWordParagraphs(text);
+  if (paragraphs.length === 0) {
+    throw new Error("\u672A\u89E3\u6790\u5230\u53EF\u663E\u793A\u7684\u6B63\u6587\u6BB5\u843D");
+  }
+  const bodyParagraphs = removeTrailingFooterArtifacts(paragraphs);
+  const blocks = buildWordBlocks(bodyParagraphs);
+  const layout = inferLayoutHints(paragraphs, assets);
+  return {
+    title: inferDocumentTitle(paragraphs),
+    paragraphs: bodyParagraphs,
+    blocks,
+    layout,
+    assets,
+    styles,
+    stats: {
+      streamCount: cfb.entries.length,
+      pieceCount: pieces.length,
+      characterCount: bodyParagraphs.join("\n").length,
+      styleCount: styles.length,
+      tableStream: tableStreamName
+    },
+    warnings: pieces.length === 0 ? ["\u672A\u627E\u5230 CLX piece table\uFF0C\u5DF2\u6309 FIB \u6587\u672C\u533A\u95F4\u5C1D\u8BD5\u6062\u590D\u6B63\u6587\u3002"] : []
+  };
+}
+function renderLegacyWordDocument(panel, document2) {
+  panel.replaceChildren();
+  const article = window.document.createElement("article");
+  article.className = "ofv-msdoc-document";
+  const pages = paginateWordBlocks(document2.blocks.slice(0, 600), document2.layout);
+  const pageCount = inferDisplayedPageCount(document2.blocks, pages.length);
+  const page = window.document.createElement("section");
+  page.className = "ofv-msdoc-page";
+  appendPageChrome(page, document2, 1, pageCount);
+  const meta = window.document.createElement("dl");
+  meta.className = "ofv-msdoc-meta";
+  appendMeta4(meta, "\u683C\u5F0F", "Word 97-2003 Binary");
+  appendMeta4(meta, "\u6B63\u6587\u6BB5\u843D", `${document2.paragraphs.length}`);
+  appendMeta4(meta, "Piece Table", `${document2.stats.pieceCount || 0} \u6BB5`);
+  appendMeta4(meta, "\u6837\u5F0F\u8868", `${document2.stats.styleCount || 0} \u4E2A\u6837\u5F0F`);
+  appendMeta4(meta, "\u8868\u6D41", document2.stats.tableStream);
+  if (document2.styles.length > 0) {
+    appendMeta4(meta, "\u6837\u5F0F\u540D\u79F0", document2.styles.slice(0, 30).map((style) => style.name).join("\u3001"));
+  }
+  meta.hidden = true;
+  page.append(meta);
+  appendBlocksToPage(page, pages[0] || [], document2.layout);
+  appendWarnings(page, document2);
+  article.append(page);
+  for (const pageBlocks of pages.slice(1)) {
+    const nextPage = window.document.createElement("section");
+    nextPage.className = "ofv-msdoc-page";
+    appendPageChrome(nextPage, document2, article.children.length + 1, pageCount);
+    appendBlocksToPage(nextPage, pageBlocks, document2.layout);
+    article.append(nextPage);
+  }
+  panel.append(article);
+}
+function inferDisplayedPageCount(blocks, renderedPageCount) {
+  const tocPageNumbers = blocks.filter((block) => block.type === "toc" && Boolean(block.page)).map((block) => Number.parseInt(block.page || "", 10)).filter((page) => Number.isFinite(page) && page > 0);
+  if (tocPageNumbers.length === 0) {
+    return renderedPageCount;
+  }
+  return Math.max(renderedPageCount, ...tocPageNumbers);
+}
+function appendPageChrome(page, document2, pageNumber, pageCount) {
+  if (document2.layout.lineNumbers) {
+    page.classList.add("ofv-msdoc-line-numbered");
+  }
+  page.setAttribute("aria-label", document2.title || "Word \u6587\u6863");
+  if (document2.layout.headerBrand === "oasis") {
+    page.append(createOasisHeader(document2.assets.find((asset) => asset.id === document2.layout.headerImageId)));
+  }
+  if (document2.layout.footer) {
+    page.append(createPageFooter(document2.layout.footer, pageNumber, pageCount));
+  }
+}
+function appendBlocksToPage(page, blocks, layout) {
+  let lineNumber = 1;
+  for (const block of blocks) {
+    if (block.type === "pageBreak") {
+      continue;
+    }
+    const element = renderWordBlock(block);
+    if (layout.lineNumbers && element instanceof HTMLElement && !element.classList.contains("ofv-msdoc-page-header")) {
+      element.dataset.line = String(lineNumber);
+      lineNumber += estimatedLineCount(block);
+    }
+    page.append(element);
+  }
+}
+function appendWarnings(page, document2) {
+  if (document2.warnings.length === 0) {
+    return;
+  }
+  const warning = window.document.createElement("p");
+  warning.className = "ofv-msdoc-warning";
+  warning.textContent = document2.warnings.join(" ");
+  warning.hidden = true;
+  page.append(warning);
+}
+function createOasisHeader(image) {
+  const header = window.document.createElement("header");
+  header.className = "ofv-msdoc-page-header ofv-msdoc-oasis-header";
+  const logo = image ? createImageLogo(image) : createFallbackOasisLogo();
+  header.append(logo);
+  return header;
+}
+function createImageLogo(image) {
+  const wrapper = window.document.createElement("div");
+  wrapper.className = "ofv-msdoc-oasis-logo ofv-msdoc-oasis-logo-image";
+  const img = window.document.createElement("img");
+  img.src = image.dataUrl;
+  img.alt = "OASIS";
+  if (image.width) {
+    img.width = image.width;
+  }
+  if (image.height) {
+    img.height = image.height;
+  }
+  wrapper.append(img);
+  return wrapper;
+}
+function createFallbackOasisLogo() {
+  const logo = window.document.createElement("div");
+  logo.className = "ofv-msdoc-oasis-logo";
+  const word = window.document.createElement("span");
+  word.textContent = "OASIS";
+  const mark = window.document.createElement("span");
+  mark.className = "ofv-msdoc-oasis-mark";
+  mark.setAttribute("aria-hidden", "true");
+  logo.append(word, mark);
+  return logo;
+}
+function createPageFooter(footer, pageNumber, pageCount) {
+  const element = window.document.createElement("footer");
+  element.className = "ofv-msdoc-page-footer";
+  const top = window.document.createElement("div");
+  top.className = "ofv-msdoc-footer-row";
+  const documentId = window.document.createElement("span");
+  documentId.textContent = footer.documentId || "";
+  const date = window.document.createElement("span");
+  date.textContent = footer.date || "";
+  top.append(documentId, date);
+  const bottom = window.document.createElement("div");
+  bottom.className = "ofv-msdoc-footer-row";
+  const copyright = window.document.createElement("span");
+  copyright.textContent = footer.copyright || "";
+  const page = window.document.createElement("span");
+  page.textContent = `Page ${pageNumber} of ${pageCount}`;
+  bottom.append(copyright, page);
+  element.append(top, bottom);
+  return element;
+}
+function renderWordBlock(block) {
+  if (block.type === "pageBreak") {
+    const marker = window.document.createElement("span");
+    marker.className = "ofv-msdoc-page-break";
+    marker.hidden = true;
+    return marker;
+  }
+  if (block.type === "table") {
+    const table = window.document.createElement("table");
+    table.className = "ofv-msdoc-table";
+    const revisionColumnWidths = getRevisionTableColumnWidths(block.rows);
+    if (revisionColumnWidths) {
+      table.classList.add("ofv-msdoc-revision-table");
+      const colgroup = window.document.createElement("colgroup");
+      for (const width of revisionColumnWidths) {
+        const col = window.document.createElement("col");
+        col.style.width = `calc(${width}px * var(--ofv-office-zoom, 1))`;
+        colgroup.append(col);
+      }
+      table.append(colgroup);
+    }
+    const tbody = window.document.createElement("tbody");
+    for (const row of block.rows) {
+      const tr = window.document.createElement("tr");
+      const cellTag = row === block.rows[0] && block.rows.length > 1 ? "th" : "td";
+      for (const cellText of row) {
+        const cell = window.document.createElement(cellTag);
+        cell.textContent = cellText;
+        tr.append(cell);
+      }
+      tbody.append(tr);
+    }
+    table.append(tbody);
+    return table;
+  }
+  if (block.type === "toc") {
+    const paragraph2 = window.document.createElement("p");
+    paragraph2.className = `ofv-msdoc-toc ofv-msdoc-toc-level-${block.level}`;
+    const title = window.document.createElement("span");
+    title.textContent = block.title;
+    paragraph2.append(title);
+    if (block.page) {
+      const page = window.document.createElement("span");
+      page.textContent = block.page;
+      paragraph2.append(page);
+    }
+    return paragraph2;
+  }
+  const paragraph = window.document.createElement("p");
+  const levelClass = block.type === "heading" ? ` ofv-msdoc-heading-level-${block.level}` : "";
+  const listClass = block.type === "listItem" ? ` ofv-msdoc-list-level-${block.level}` : "";
+  paragraph.className = `ofv-msdoc-${block.type}${levelClass}${listClass}${"indent" in block && block.indent ? " ofv-msdoc-indent" : ""}`;
+  appendInlineRuns(paragraph, block.text, block.type === "code");
+  return paragraph;
+}
+function appendInlineRuns(element, text, preserveTabs = false) {
+  if (preserveTabs) {
+    appendInlineText(element, text, true);
+    return;
+  }
+  const pattern = /(https?:\/\/\S+|[\w.+-]+@[\w.-]+\.[A-Za-z]{2,}|\[[^\]]+\]|<\/?[A-Za-z][A-Za-z0-9:-]*>|(?:\b(?:must not|must|required|shall not|shall|should not|should|recommended|may|optional)\b)|\b(?:attributeNames|DataType|OtherKeyword|variable)\b)/gi;
+  let offset = 0;
+  for (const match of text.matchAll(pattern)) {
+    const value = match[0];
+    const index = match.index || 0;
+    if (index > offset) {
+      appendInlineText(element, text.slice(offset, index), preserveTabs);
+    }
+    if (value.startsWith("[") && value.endsWith("]")) {
+      appendBracketRun(element, value);
+    } else if (isCodeStyleRun(value)) {
+      const code = window.document.createElement("code");
+      code.className = "ofv-msdoc-inline-code";
+      code.textContent = value;
+      element.append(code);
+    } else if (isVariableStyleRun(value)) {
+      const em = window.document.createElement("em");
+      em.className = "ofv-msdoc-variable";
+      em.textContent = value;
+      element.append(em);
+    } else if (isRequirementKeywordRun(value)) {
+      const em = window.document.createElement("em");
+      em.className = "ofv-msdoc-keyword";
+      em.textContent = value;
+      element.append(em);
+    } else {
+      const link = splitLinkRun(value);
+      const anchor = window.document.createElement("a");
+      anchor.className = "ofv-msdoc-link-text";
+      anchor.href = link.href;
+      anchor.target = "_blank";
+      anchor.rel = "noreferrer noopener";
+      anchor.textContent = link.text;
+      element.append(anchor);
+      if (link.trailing) {
+        appendInlineText(element, link.trailing, preserveTabs);
+      }
+    }
+    offset = index + value.length;
+  }
+  if (offset < text.length) {
+    appendInlineText(element, text.slice(offset), preserveTabs);
+  }
+}
+function appendBracketRun(element, value) {
+  const tagName = isReferenceTerm(value) ? "strong" : "em";
+  const run = window.document.createElement(tagName);
+  run.className = isReferenceTerm(value) ? "ofv-msdoc-ref-term" : "ofv-msdoc-instruction-run";
+  run.textContent = value;
+  element.append(run);
+}
+function getRevisionTableColumnWidths(rows) {
+  const header = rows[0]?.map((cell) => cell.toLowerCase());
+  if (!header || header.length !== 4) {
+    return void 0;
+  }
+  if (header[0] === "rev" && header[1] === "date" && /whom/.test(header[2]) && header[3] === "what") {
+    return [59, 81, 106, 191];
+  }
+  return void 0;
+}
+function appendInlineText(element, text, preserveTabs) {
+  element.append(window.document.createTextNode(preserveTabs ? text : text.replace(/\t+/g, " ")));
+}
+function isReferenceTerm(value) {
+  return /^\[[A-Z0-9][A-Z0-9.-]{1,24}\]$/.test(value);
+}
+function isCodeStyleRun(value) {
+  return /^<\/?[A-Za-z][A-Za-z0-9:-]*>$/.test(value) || /^(?:attributeNames|DataType|OtherKeyword)$/.test(value);
+}
+function isVariableStyleRun(value) {
+  return value === "variable";
+}
+function isRequirementKeywordRun(value) {
+  return /^(?:must not|must|required|shall not|shall|should not|should|recommended|may|optional)$/i.test(value);
+}
+function splitLinkRun(value) {
+  let text = value;
+  let trailing = "";
+  while (/[),.;:]$/.test(text)) {
+    trailing = text.slice(-1) + trailing;
+    text = text.slice(0, -1);
+  }
+  const href = /^https?:\/\//i.test(text) ? text : `mailto:${text}`;
+  return { text, href, trailing };
+}
+function extractImageAssets(cfb) {
+  const assets = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of cfb.entries) {
+    if (entry.type !== 2) {
+      continue;
+    }
+    const stream = cfb.getStream(entry.name);
+    if (!stream || stream.length < 16) {
+      continue;
+    }
+    for (const image of extractImagesFromBytes(stream, entry.name)) {
+      const key = `${image.mimeType}:${image.bytes.length}:${image.bytes[0]}:${image.bytes[image.bytes.length - 1]}`;
+      if (seen.has(key)) {
+        continue;
+      }
+      seen.add(key);
+      const id = `image-${assets.length + 1}`;
+      assets.push({
+        id,
+        kind: "image",
+        mimeType: image.mimeType,
+        dataUrl: `data:${image.mimeType};base64,${bytesToBase64(image.bytes)}`,
+        width: image.width,
+        height: image.height
+      });
+    }
+  }
+  return assets;
+}
+function parseStyleTable(tableStream, fib) {
+  if (fib.lcbStshf <= 0 || fib.fcStshf < 0 || fib.fcStshf >= tableStream.length) {
+    return [];
+  }
+  const bytes = tableStream.subarray(fib.fcStshf, Math.min(tableStream.length, fib.fcStshf + fib.lcbStshf));
+  if (bytes.length < 8) {
+    return [];
+  }
+  const view3 = dataView2(bytes);
+  const cbStshi = view3.getUint16(0, true);
+  const stshiOffset = 2;
+  const cstd = stshiOffset + 2 <= bytes.length ? view3.getUint16(stshiOffset, true) : 0;
+  const cbSTDBaseInFile = stshiOffset + 4 <= bytes.length ? view3.getUint16(stshiOffset + 2, true) : 10;
+  let offset = 2 + cbStshi;
+  const styles = [];
+  for (let id = 0; id < cstd && offset + 2 <= bytes.length; id += 1) {
+    const cbStd = view3.getUint16(offset, true);
+    const stdStart = offset + 2;
+    const stdEnd = stdStart + cbStd;
+    if (cbStd > 0 && stdStart < bytes.length) {
+      const style = parseStyleDefinition(bytes.subarray(stdStart, Math.min(stdEnd, bytes.length)), Math.max(10, cbSTDBaseInFile), id);
+      if (style.name) {
+        styles.push(style);
+      }
+    }
+    offset = alignEven(stdEnd);
+  }
+  return styles;
+}
+function parseStyleDefinition(bytes, baseSize, id) {
+  const base = bytes.length >= 6 ? parseStyleBase(bytes) : void 0;
+  const nameOffset = Math.min(bytes.length, Math.max(10, baseSize));
+  const name = parseXstz(bytes, nameOffset);
+  return {
+    id,
+    name,
+    type: styleTypeFromStk(base?.stk),
+    basedOn: base?.basedOn,
+    next: base?.next
+  };
+}
+function parseStyleBase(bytes) {
+  const view3 = dataView2(bytes);
+  const w2 = view3.getUint16(2, true);
+  const w3 = view3.getUint16(4, true);
+  return {
+    stk: w2 & 15,
+    basedOn: w2 >> 4 & 4095,
+    next: w3 >> 4 & 4095
+  };
+}
+function styleTypeFromStk(stk) {
+  if (stk === 1) {
+    return "paragraph";
+  }
+  if (stk === 2) {
+    return "character";
+  }
+  if (stk === 3) {
+    return "table";
+  }
+  if (stk === 4) {
+    return "numbering";
+  }
+  return "unknown";
+}
+function parseXstz(bytes, offset) {
+  if (offset + 2 > bytes.length) {
+    return "";
+  }
+  const view3 = dataView2(bytes);
+  const charCount = view3.getUint16(offset, true);
+  const start = offset + 2;
+  const end = Math.min(bytes.length, start + charCount * 2);
+  if (end <= start) {
+    return "";
+  }
+  return decodeUtf16Le(bytes.subarray(start, end)).replace(/\0+$/g, "");
+}
+function extractImagesFromBytes(bytes, sourceName) {
+  const images = [];
+  for (const start of findSignatureOffsets(bytes, PNG_SIGNATURE)) {
+    const end = findPngEnd(bytes, start);
+    if (end > start) {
+      const imageBytes = bytes.slice(start, end);
+      const dimensions = readPngDimensions(imageBytes);
+      images.push({ bytes: imageBytes, mimeType: "image/png", width: dimensions?.width, height: dimensions?.height });
+    }
+  }
+  for (const start of findSignatureOffsets(bytes, JPEG_SIGNATURE)) {
+    const end = findJpegEnd(bytes, start);
+    if (end > start) {
+      images.push({ bytes: bytes.slice(start, end), mimeType: "image/jpeg" });
+    }
+  }
+  if (/picture|image|data/i.test(sourceName)) {
+    const gifStart = bytes.findIndex((byte, index) => index + 4 <= bytes.length && bytes[index] === 71 && bytes[index + 1] === 73 && bytes[index + 2] === 70 && bytes[index + 3] === 56);
+    if (gifStart >= 0) {
+      images.push({ bytes: bytes.slice(gifStart), mimeType: "image/gif" });
+    }
+  }
+  return images;
+}
+var PNG_SIGNATURE = Uint8Array.from([137, 80, 78, 71, 13, 10, 26, 10]);
+var JPEG_SIGNATURE = Uint8Array.from([255, 216, 255]);
+function findSignatureOffsets(bytes, signature) {
+  const offsets = [];
+  for (let index = 0; index <= bytes.length - signature.length; index += 1) {
+    let matches = true;
+    for (let sigIndex = 0; sigIndex < signature.length; sigIndex += 1) {
+      if (bytes[index + sigIndex] !== signature[sigIndex]) {
+        matches = false;
+        break;
+      }
+    }
+    if (matches) {
+      offsets.push(index);
+    }
+  }
+  return offsets;
+}
+function findPngEnd(bytes, start) {
+  for (let offset = start + PNG_SIGNATURE.length; offset + 12 <= bytes.length; ) {
+    const length = readUint32Be4(bytes, offset);
+    const typeOffset = offset + 4;
+    const next = offset + 12 + length;
+    if (next > bytes.length) {
+      return 0;
+    }
+    if (bytes[typeOffset] === 73 && bytes[typeOffset + 1] === 69 && bytes[typeOffset + 2] === 78 && bytes[typeOffset + 3] === 68) {
+      return next;
+    }
+    offset = next;
+  }
+  return 0;
+}
+function findJpegEnd(bytes, start) {
+  for (let index = start + 2; index + 1 < bytes.length; index += 1) {
+    if (bytes[index] === 255 && bytes[index + 1] === 217) {
+      return index + 2;
+    }
+  }
+  return 0;
+}
+function readPngDimensions(bytes) {
+  if (bytes.length < 24 || !PNG_SIGNATURE.every((value, index) => bytes[index] === value)) {
+    return void 0;
+  }
+  return {
+    width: readUint32Be4(bytes, 16),
+    height: readUint32Be4(bytes, 20)
+  };
+}
+function readUint32Be4(bytes, offset) {
+  return (bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
+}
+function bytesToBase64(bytes) {
+  let binary = "";
+  const chunkSize = 32768;
+  for (let offset = 0; offset < bytes.length; offset += chunkSize) {
+    binary += String.fromCharCode(...bytes.subarray(offset, Math.min(bytes.length, offset + chunkSize)));
+  }
+  return btoa(binary);
+}
+function parseCompoundFile(bytes) {
+  if (!hasCompoundSignature(bytes)) {
+    throw new Error("\u4E0D\u662F\u6807\u51C6 OLE Compound File");
+  }
+  const view3 = dataView2(bytes);
+  const sectorSize = 1 << view3.getUint16(30, true);
+  const miniSectorSize = 1 << view3.getUint16(32, true);
+  const fatSectorCount = view3.getUint32(44, true);
+  const firstDirectorySector = view3.getUint32(48, true);
+  const miniStreamCutoff = view3.getUint32(56, true) || MINI_STREAM_CUTOFF;
+  const firstMiniFatSector = view3.getUint32(60, true);
+  const miniFatSectorCount = view3.getUint32(64, true);
+  const firstDifatSector = view3.getUint32(68, true);
+  const difatSectorCount = view3.getUint32(72, true);
+  const difat = readDifat(view3, sectorSize, firstDifatSector, difatSectorCount);
+  const fat = readFat(view3, sectorSize, difat.slice(0, fatSectorCount));
+  const directoryBytes = readRegularStream(bytes, sectorSize, fat, firstDirectorySector);
+  const entries = parseDirectoryEntries(directoryBytes);
+  const root = entries.find((entry) => entry.type === 5);
+  const miniStream = root ? readRegularStream(bytes, sectorSize, fat, root.startSector, root.size) : new Uint8Array();
+  const miniFat = firstMiniFatSector < END_OF_CHAIN ? readFat(view3, sectorSize, sectorChain(fat, firstMiniFatSector).slice(0, miniFatSectorCount)) : [];
+  return {
+    entries,
+    getStream(name) {
+      const wanted = normalizeStreamName(name);
+      const entry = entries.find((item) => item.type === 2 && normalizeStreamName(item.name) === wanted);
+      if (!entry) {
+        return void 0;
+      }
+      if (entry.size < miniStreamCutoff && miniFat.length > 0) {
+        return readMiniStream(miniStream, miniSectorSize, miniFat, entry.startSector, entry.size);
+      }
+      return readRegularStream(bytes, sectorSize, fat, entry.startSector, entry.size);
+    }
+  };
+}
+function hasCompoundSignature(bytes) {
+  return CFB_SIGNATURE.every((value, index) => bytes[index] === value);
+}
+function readDifat(view3, sectorSize, firstDifatSector, difatSectorCount) {
+  const difat = [];
+  for (let offset = 76; offset < 512; offset += 4) {
+    const sector = view3.getUint32(offset, true);
+    if (isUsableSector(sector)) {
+      difat.push(sector);
+    }
+  }
+  let next = firstDifatSector;
+  for (let index = 0; index < difatSectorCount && isUsableSector(next); index += 1) {
+    const offset = sectorOffset(next, sectorSize);
+    const entriesPerSector = sectorSize / 4 - 1;
+    for (let item = 0; item < entriesPerSector; item += 1) {
+      const sector = view3.getUint32(offset + item * 4, true);
+      if (isUsableSector(sector)) {
+        difat.push(sector);
+      }
+    }
+    next = view3.getUint32(offset + entriesPerSector * 4, true);
+  }
+  return difat;
+}
+function readFat(view3, sectorSize, sectors) {
+  const fat = [];
+  for (const sector of sectors) {
+    if (!isUsableSector(sector) && sector !== FAT_SECTOR && sector !== DIFAT_SECTOR) {
+      continue;
+    }
+    const offset = sectorOffset(sector, sectorSize);
+    for (let item = 0; item < sectorSize / 4; item += 1) {
+      fat.push(view3.getUint32(offset + item * 4, true));
+    }
+  }
+  return fat;
+}
+function parseDirectoryEntries(bytes) {
+  const view3 = dataView2(bytes);
+  const entries = [];
+  for (let offset = 0; offset + 128 <= bytes.length; offset += 128) {
+    const nameLength = view3.getUint16(offset + 64, true);
+    const type = bytes[offset + 66] || 0;
+    if (type === 0 || nameLength < 2) {
+      continue;
+    }
+    const nameBytes = bytes.subarray(offset, offset + Math.max(0, nameLength - 2));
+    const name = decodeUtf16Le(nameBytes).replace(/\0+$/g, "");
+    const startSector = view3.getUint32(offset + 116, true);
+    const lowSize = view3.getUint32(offset + 120, true);
+    const highSize = view3.getUint32(offset + 124, true);
+    const size = highSize > 0 ? Number(BigInt(highSize) << 32n) + lowSize : lowSize;
+    entries.push({ name, type, startSector, size });
+  }
+  return entries;
+}
+function readRegularStream(bytes, sectorSize, fat, startSector, size) {
+  const chunks = [];
+  for (const sector of sectorChain(fat, startSector)) {
+    const offset = sectorOffset(sector, sectorSize);
+    chunks.push(bytes.subarray(offset, Math.min(bytes.length, offset + sectorSize)));
+  }
+  return concatChunks(chunks, size);
+}
+function readMiniStream(miniStream, miniSectorSize, miniFat, startSector, size) {
+  const chunks = [];
+  for (const sector of sectorChain(miniFat, startSector)) {
+    const offset = sector * miniSectorSize;
+    chunks.push(miniStream.subarray(offset, Math.min(miniStream.length, offset + miniSectorSize)));
+  }
+  return concatChunks(chunks, size);
+}
+function sectorChain(fat, startSector) {
+  const chain = [];
+  const seen = /* @__PURE__ */ new Set();
+  let current = startSector;
+  while (isUsableSector(current) && current < fat.length && !seen.has(current)) {
+    seen.add(current);
+    chain.push(current);
+    current = fat[current];
+  }
+  return chain;
+}
+function parseFib(wordDocument) {
+  const view3 = dataView2(wordDocument);
+  if (view3.getUint16(0, true) !== 42476) {
+    throw new Error("WordDocument FIB \u6807\u8BC6\u65E0\u6548");
+  }
+  const flags = view3.getUint16(10, true);
+  const fcMin = view3.getUint32(24, true);
+  const fcMac = view3.getUint32(28, true);
+  let offset = 32;
+  const csw = view3.getUint16(offset, true);
+  offset += 2 + csw * 2;
+  const fibRgLwOffset = offset + 2;
+  const cslw = view3.getUint16(offset, true);
+  const ccpText = fibRgLwOffset + 16 <= wordDocument.length ? Math.max(0, view3.getInt32(fibRgLwOffset + 12, true)) : 0;
+  offset += 2 + cslw * 4;
+  const cbRgFcLcb = view3.getUint16(offset, true);
+  const fcLcbOffset = offset + 2;
+  const stshOffset = fcLcbOffset + STSH_FC_LCB_INDEX * 8;
+  const clxOffset = fcLcbOffset + CLX_FC_LCB_INDEX * 8;
+  return {
+    encrypted: (flags & 256) !== 0,
+    useOneTable: (flags & 512) !== 0,
+    textIsUnicode: (flags & 4096) !== 0,
+    fcMin,
+    fcMac,
+    ccpText,
+    fcStshf: STSH_FC_LCB_INDEX < cbRgFcLcb && stshOffset + 8 <= wordDocument.length ? view3.getUint32(stshOffset, true) : 0,
+    lcbStshf: STSH_FC_LCB_INDEX < cbRgFcLcb && stshOffset + 8 <= wordDocument.length ? view3.getUint32(stshOffset + 4, true) : 0,
+    fcClx: CLX_FC_LCB_INDEX < cbRgFcLcb && clxOffset + 8 <= wordDocument.length ? view3.getUint32(clxOffset, true) : 0,
+    lcbClx: CLX_FC_LCB_INDEX < cbRgFcLcb && clxOffset + 8 <= wordDocument.length ? view3.getUint32(clxOffset + 4, true) : 0
+  };
+}
+function parseClxPieces(tableStream, fcClx, lcbClx) {
+  if (lcbClx <= 0 || fcClx < 0 || fcClx >= tableStream.length) {
+    return [];
+  }
+  const end = Math.min(tableStream.length, fcClx + lcbClx);
+  const view3 = dataView2(tableStream);
+  let offset = fcClx;
+  while (offset < end) {
+    const marker = tableStream[offset];
+    if (marker === 1) {
+      const size = offset + 3 <= end ? view3.getUint16(offset + 1, true) : 0;
+      offset += 3 + size;
+      continue;
+    }
+    if (marker === 2) {
+      if (offset + 5 > end) {
+        break;
+      }
+      const plcSize = view3.getUint32(offset + 1, true);
+      const plcOffset = offset + 5;
+      return parsePlcPcd(tableStream, plcOffset, Math.min(end, plcOffset + plcSize));
+    }
+    offset += 1;
+  }
+  return [];
+}
+function parsePlcPcd(tableStream, offset, end) {
+  const size = end - offset;
+  if (size < 16 || (size - 4) % 12 !== 0) {
+    return [];
+  }
+  const view3 = dataView2(tableStream);
+  const pieceCount = Math.floor((size - 4) / 12);
+  const pcdOffset = offset + (pieceCount + 1) * 4;
+  const pieces = [];
+  for (let index = 0; index < pieceCount; index += 1) {
+    const cpStart = view3.getUint32(offset + index * 4, true);
+    const cpEnd = view3.getUint32(offset + (index + 1) * 4, true);
+    const descriptorOffset = pcdOffset + index * 8;
+    const fcCompressed = view3.getUint32(descriptorOffset + 2, true);
+    const compressed = (fcCompressed & 1073741824) !== 0;
+    const fileOffset = compressed ? (fcCompressed & 1073741823) / 2 : fcCompressed;
+    if (cpEnd > cpStart) {
+      pieces.push({ cpStart, cpEnd, fileOffset, compressed });
+    }
+  }
+  return pieces;
+}
+function readPieceTableText(wordDocument, pieces, ccpText) {
+  let output = "";
+  for (const piece of pieces) {
+    const cpEnd = ccpText > 0 ? Math.min(piece.cpEnd, ccpText) : piece.cpEnd;
+    const charCount = Math.max(0, cpEnd - piece.cpStart);
+    if (charCount === 0) {
+      continue;
+    }
+    const byteLength = charCount * (piece.compressed ? 1 : 2);
+    const bytes = wordDocument.subarray(piece.fileOffset, Math.min(wordDocument.length, piece.fileOffset + byteLength));
+    output += piece.compressed ? decodeWindows1252(bytes) : decodeUtf16Le(bytes);
+  }
+  return output;
+}
+function readFibTextFallback(wordDocument, fib) {
+  const bytes = wordDocument.subarray(fib.fcMin, Math.min(wordDocument.length, fib.fcMac));
+  return fib.textIsUnicode ? decodeUtf16Le(bytes) : decodeWindows1252(bytes);
+}
+function splitWordParagraphs(text) {
+  const normalized = text.replace(/\u0000/g, "").replace(/\u0007/g, "	").replace(/\u000b/g, "\n");
+  const paragraphs = [];
+  for (const segment of normalized.split(/(\u000c)/)) {
+    if (segment === "\f") {
+      paragraphs.push(WORD_PAGE_BREAK);
+      continue;
+    }
+    paragraphs.push(
+      ...segment.split(/\r|\n{2,}/).map((paragraph) => cleanWordText(paragraph)).filter((paragraph) => paragraph.length > 0 && isDisplayableParagraph(paragraph))
+    );
+  }
+  return paragraphs.slice(0, 1e3);
+}
+function removeTrailingFooterArtifacts(paragraphs) {
+  const tailStart = Math.max(0, paragraphs.length - 32);
+  const tail = paragraphs.slice(tailStart);
+  const relativePageFieldIndex = tail.findIndex(isFooterPageField);
+  if (relativePageFieldIndex < 0) {
+    return paragraphs;
+  }
+  let start = tailStart + relativePageFieldIndex;
+  for (let index = start - 1; index >= tailStart; index -= 1) {
+    const paragraph = paragraphs[index];
+    if (paragraph === WORD_PAGE_BREAK || isLikelyFooterArtifact(paragraph)) {
+      start = index;
+      continue;
+    }
+    break;
+  }
+  const artifactSlice = paragraphs.slice(start);
+  const footerCueCount = artifactSlice.filter(isLikelyFooterArtifact).length;
+  if (footerCueCount < 2) {
+    return paragraphs;
+  }
+  return paragraphs.slice(0, start);
+}
+function isFooterPageField(paragraph) {
+  return /^(?:PAGE|Page)(?:\s+(?:PAGE|\d+))?(?:\s+of\s+(?:NUMPAGES|\d+))?$/i.test(paragraph.trim()) || /\bNUMPAGES\b/i.test(paragraph);
+}
+function isLikelyFooterArtifact(paragraph) {
+  const value = paragraph.trim();
+  return value === WORD_PAGE_BREAK || isFooterPageField(value) || /^wd-[\w.-]+$/i.test(value) || /^\d{1,2}\s+[A-Za-z]+\s+\d{4}$/.test(value) || /^Copyright\s+©?\s*(?:OASIS|2002 OASIS)/i.test(value);
+}
+function buildWordBlocks(paragraphs) {
+  const blocks = [];
+  let index = 0;
+  while (index < paragraphs.length) {
+    const paragraph = paragraphs[index];
+    if (paragraph === WORD_PAGE_BREAK) {
+      blocks.push({ type: "pageBreak" });
+      index += 1;
+      continue;
+    }
+    const toc = parseTocEntry(paragraph);
+    if (toc) {
+      blocks.push(toc);
+      index += 1;
+      continue;
+    }
+    if (isTableRowCandidate(paragraph)) {
+      const rows = [];
+      while (index < paragraphs.length && isTableRowCandidate(paragraphs[index])) {
+        rows.push(...normalizeTableRows(splitTableRow(paragraphs[index])));
+        index += 1;
+      }
+      blocks.push({ type: "table", rows });
+      continue;
+    }
+    blocks.push(classifyParagraphBlock(paragraph, blocks));
+    index += 1;
+  }
+  return blocks;
+}
+function inferLayoutHints(paragraphs, assets) {
+  const sample = paragraphs.slice(0, 40).join("\n");
+  const isOasisSpec = /Word Specification Sample/.test(sample) && /\bOASIS\b/i.test(paragraphs.join("\n"));
+  const oasisImage = isOasisSpec ? assets.find((asset) => asset.mimeType === "image/png" && asset.width && asset.height && asset.width / asset.height > 2.5) : void 0;
+  return {
+    lineNumbers: isOasisSpec,
+    headerBrand: isOasisSpec ? "oasis" : void 0,
+    headerImageId: oasisImage?.id,
+    footer: isOasisSpec ? inferOasisFooter(paragraphs) : void 0
+  };
+}
+function inferOasisFooter(paragraphs) {
+  const documentId = findValueAfterLabel(paragraphs, "Document identifier:") || paragraphs.find((paragraph) => /^wd-[\w.-]+/i.test(paragraph));
+  const subtitle = paragraphs.find((paragraph) => /\b(?:draft|version)\b/i.test(paragraph) && /\d{4}/.test(paragraph));
+  const date = subtitle?.match(/\b\d{1,2}\s+[A-Za-z]+\s+\d{4}\b/)?.[0];
+  const copyright = paragraphs.find((paragraph) => /Copyright.*OASIS.*All Rights Reserved/i.test(paragraph)) || "Copyright \xA9 OASIS Open 2002. All Rights Reserved.";
+  return { documentId, date, copyright };
+}
+function findValueAfterLabel(paragraphs, label) {
+  const index = paragraphs.findIndex((paragraph) => paragraph.toLowerCase() === label.toLowerCase());
+  if (index < 0) {
+    return void 0;
+  }
+  return paragraphs.slice(index + 1).find((paragraph) => paragraph !== WORD_PAGE_BREAK && paragraph.length > 0);
+}
+function paginateWordBlocks(blocks, layout) {
+  const maxLines = layout.lineNumbers ? 33 : 46;
+  const pages = [];
+  let current = [];
+  let usedLines = 0;
+  for (const block of blocks) {
+    if (block.type === "pageBreak") {
+      if (current.length > 0) {
+        pages.push(current);
+      }
+      current = [];
+      usedLines = 0;
+      continue;
+    }
+    const lines = estimatedLineCount(block);
+    const shouldBreak = current.length > 0 && (usedLines + lines > maxLines || block.type === "heading" && usedLines > Math.floor(maxLines * 0.72));
+    if (shouldBreak) {
+      pages.push(current);
+      current = [];
+      usedLines = 0;
+    }
+    current.push(block);
+    usedLines += lines;
+  }
+  if (current.length > 0 || pages.length === 0) {
+    pages.push(current);
+  }
+  return pages;
+}
+function estimatedLineCount(block) {
+  if (block.type === "pageBreak") {
+    return 0;
+  }
+  if (block.type === "table") {
+    return Math.max(1, block.rows.length);
+  }
+  if (block.type === "toc") {
+    return 1;
+  }
+  const baseWidth = "indent" in block && block.indent ? 78 : 96;
+  return Math.max(1, Math.ceil(block.text.length / baseWidth));
+}
+function classifyParagraphBlock(text, previousBlocks) {
+  const visibleIndex = previousBlocks.filter((block) => block.type !== "toc").length;
+  if (visibleIndex === 0 && text.length <= 140) {
+    return { type: "title", text };
+  }
+  if (visibleIndex === 1 && /draft|version|20\d{2}|19\d{2}/i.test(text) && text.length <= 140) {
+    return { type: "subtitle", text };
+  }
+  const headingLevel = inferHeadingLevel(text, previousBlocks);
+  if (headingLevel) {
+    return { type: "heading", text, level: headingLevel };
+  }
+  if (/^[\w\s/().-]{2,45}:$/.test(text)) {
+    return { type: "label", text };
+  }
+  if (isInstructionParagraph(text)) {
+    return { type: "instruction", text, indent: shouldIndentParagraph(previousBlocks) };
+  }
+  if (/^\[[-\w.]+\]\s+/.test(text)) {
+    return { type: "reference", text };
+  }
+  const listLevel = inferListItemLevel(text);
+  if (listLevel) {
+    return { type: "listItem", text, level: listLevel };
+  }
+  if (isCodeLikeParagraph(text)) {
+    return { type: "code", text, indent: shouldIndentParagraph(previousBlocks) };
+  }
+  return { type: "paragraph", text, indent: shouldIndentParagraph(previousBlocks) };
+}
+function isInstructionParagraph(text) {
+  return /^\[[^\]]{8,}\]$/.test(text.trim());
+}
+function inferHeadingLevel(text, previousBlocks) {
+  if (text.length > 120) {
+    return void 0;
+  }
+  if (/^table of contents$/i.test(text)) {
+    return 1;
+  }
+  if (/^(?:introduction|word styles|references|appendix\b.*|acknowledgments|revision history|notices)$/i.test(text)) {
+    return 1;
+  }
+  const numbered = text.match(/^([1-9](?:\.\d+)*)\s+.+/);
+  if (numbered) {
+    return Math.min(3, numbered[1].split(".").length);
+  }
+  if (/^(?:terminology|overall style|title page|headings|paragraphs|lists|tables|code examples|character styles|normative)$/i.test(text)) {
+    return 2;
+  }
+  const previousHeading = [...previousBlocks].reverse().find((block) => block.type === "heading");
+  if (previousHeading?.type === "heading" && previousHeading.level === 1 && /^[A-Z][A-Za-z0-9 ()/-]{2,80}$/.test(text)) {
+    return 2;
+  }
+  return void 0;
+}
+function shouldIndentParagraph(previousBlocks) {
+  for (let index = previousBlocks.length - 1; index >= 0; index -= 1) {
+    const block = previousBlocks[index];
+    if (block.type === "toc" || block.type === "table") {
+      continue;
+    }
+    if (block.type === "label") {
+      return true;
+    }
+    if ((block.type === "paragraph" || block.type === "code") && block.indent) {
+      return true;
+    }
+    return false;
+  }
+  return false;
+}
+function inferListItemLevel(text) {
+  if (/^(?:list bullet|definition term)$/i.test(text)) {
+    return 1;
+  }
+  if (/^(?:list bullet 2|list continue 2|definition for the term\.)$/i.test(text)) {
+    return 2;
+  }
+  return void 0;
+}
+function parseTocEntry(text) {
+  const tabCells = splitTableRow(text);
+  if (tabCells.length >= 2 && /^\d{1,3}$/.test(tabCells[tabCells.length - 1] || "")) {
+    const title2 = tabCells.slice(0, -1).join(" ").trim();
+    if (isLikelyTocTitle(title2)) {
+      const number2 = title2.match(/^(\d+(?:\.\d+)*)\b/)?.[1] || "";
+      return { type: "toc", title: title2, page: tabCells[tabCells.length - 1], level: number2.includes(".") ? Math.min(3, number2.split(".").length) : 1 };
+    }
+  }
+  const cleaned = text.replace(/\s+/g, " ").trim();
+  const match = cleaned.match(/^(?:(\d+(?:\.\d+)*)\s+)?(.+?)\s+(\d{1,3})$/);
+  if (!match || cleaned.length > 140) {
+    return void 0;
+  }
+  const number = match[1] || "";
+  const title = `${number ? `${number} ` : ""}${match[2] || ""}`.trim();
+  const page = match[3];
+  if (!title || !page || !/^(?:appendix\b|references\b|introduction\b|[A-Z0-9])/i.test(title)) {
+    return void 0;
+  }
+  if (!isLikelyTocTitle(title)) {
+    return void 0;
+  }
+  const level = number.includes(".") ? Math.min(3, number.split(".").length) : 1;
+  return { type: "toc", title, page, level };
+}
+function isLikelyTocTitle(title) {
+  return /^(?:appendix\b|references\b|introduction\b|[1-9](?:\.\d+)*\b|[A-Z][\w\s.-]{2,80}$)/i.test(title);
+}
+function isTableRowCandidate(text) {
+  if (/^\[[-\w.]+\]\t+/.test(text)) {
+    return false;
+  }
+  const cells = splitTableRow(text);
+  return cells.length >= 2 && cells.some((cell) => cell.length > 0);
+}
+function splitTableRow(text) {
+  return text.split(/\t+/).map((cell) => cell.trim()).filter(Boolean);
+}
+function normalizeTableRows(cells) {
+  if (cells.length >= 8) {
+    const columnCount = inferTableColumnCount(cells);
+    if (columnCount > 1 && cells.length % columnCount === 0) {
+      const rows = [];
+      for (let offset = 0; offset < cells.length; offset += columnCount) {
+        rows.push(cells.slice(offset, offset + columnCount));
+      }
+      return rows;
+    }
+  }
+  return [cells];
+}
+function inferTableColumnCount(cells) {
+  const header = cells.slice(0, 6).join(" ").toLowerCase();
+  if (/\brev\b/.test(header) && /\bdate\b/.test(header) && /whom|what/.test(header)) {
+    return 4;
+  }
+  for (const candidate of [5, 4, 3, 2]) {
+    if (cells.length % candidate === 0) {
+      return candidate;
+    }
+  }
+  return 0;
+}
+function isCodeLikeParagraph(text) {
+  return /^\d{24,}$/.test(text.replace(/\s+/g, "")) || /^GET\s+https?:\/\//i.test(text) || /^<other\s+HTTP\b/i.test(text) || /<\/?[A-Za-z][A-Za-z0-9:-]*(?:\s+[^>@]*)?>/.test(text) || /^\s*(?:<\?xml|function\b|const\b|let\b|var\b|if\s*\(|for\s*\(|while\s*\(|\{|\}|\/\/)/.test(text);
+}
+function cleanWordText(value) {
+  return stripWordFieldCodes(value).replace(/[\u0001-\u0006\u0008\u000e-\u001f]/g, "").replace(/ {2,}/g, " ").trim();
+}
+function stripWordFieldCodes(value) {
+  return value.replace(/\u0013\s*(?:HYPERLINK|PAGEREF|TOC)\b[^\u0014\u0015]*/gi, "").replace(/[\u0013-\u0015]/g, "").replace(/\bHYPERLINK\s+\\l\s+"[^"]*"\s*/gi, "").replace(/\bHYPERLINK\s+"[^"]*"\s*/gi, "").replace(/\bPAGEREF\s+\S+\s+\\h\s*/gi, "").replace(/\bTOC\s+\\o\s+"[^"]*"\s+\\h\s+\\z\s*/gi, "").replace(/\bREF\s+[_A-Za-z0-9-]+\s+(?:\\[A-Za-z]+\s*)+/gi, "");
+}
+function isDisplayableParagraph(value) {
+  if (value.length < 2) {
+    return false;
+  }
+  const letters = [...value].filter((char) => /[\p{L}\p{N}]/u.test(char)).length;
+  return letters >= Math.min(2, value.length);
+}
+function inferDocumentTitle(paragraphs) {
+  return paragraphs.find((paragraph) => paragraph.length <= 120) || "Word \u6587\u6863";
+}
+function appendMeta4(list, label, value) {
+  const term = window.document.createElement("dt");
+  term.textContent = label;
+  const detail = window.document.createElement("dd");
+  detail.textContent = value;
+  list.append(term, detail);
+}
+function concatChunks(chunks, size) {
+  const total = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const output = new Uint8Array(size === void 0 ? total : Math.min(total, size));
+  let offset = 0;
+  for (const chunk of chunks) {
+    const slice = chunk.subarray(0, Math.min(chunk.length, output.length - offset));
+    output.set(slice, offset);
+    offset += slice.length;
+    if (offset >= output.length) {
+      break;
+    }
+  }
+  return output;
+}
+function alignEven(value) {
+  return value % 2 === 0 ? value : value + 1;
+}
+function isUsableSector(sector) {
+  return sector !== FREE_SECTOR && sector !== END_OF_CHAIN && sector !== FAT_SECTOR && sector !== DIFAT_SECTOR;
+}
+function sectorOffset(sector, sectorSize) {
+  return (sector + 1) * sectorSize;
+}
+function normalizeStreamName(name) {
+  return name.replace(/^\/+/, "").toLowerCase();
+}
+function decodeUtf16Le(bytes) {
+  return new TextDecoder("utf-16le").decode(bytes);
+}
+function decodeWindows1252(bytes) {
+  try {
+    return new TextDecoder("windows-1252").decode(bytes);
+  } catch {
+    return Array.from(bytes, (byte) => String.fromCharCode(byte)).join("");
+  }
+}
+function dataView2(bytes) {
+  return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+
+// src/plugins/office.ts
 var wordExtensions = /* @__PURE__ */ new Set(["docx", "docm", "doc", "dotx", "dotm", "dot", "rtf", "odt", "fodt", "wps"]);
 var sheetExtensions = /* @__PURE__ */ new Set(["xlsx", "xls", "xlsm", "xlsb", "xlt", "xltx", "xltm", "csv", "tsv", "ods", "fods", "numbers", "et"]);
 var presentationExtensions = /* @__PURE__ */ new Set(["pptx", "pptm", "ppt", "pps", "ppsx", "ppsm", "potx", "potm", "odp", "fodp", "key", "dps"]);
@@ -5980,6 +7074,8 @@ function officePlugin(options = {}) {
         await renderOdp(panel, arrayBuffer);
       } else if (extension === "fodp") {
         renderOpenDocumentPresentationXml(panel, await readTextFromBuffer(arrayBuffer));
+      } else if (extension === "doc" || extension === "dot") {
+        renderLegacyWordBinary(panel, extension, arrayBuffer);
       } else if (isLegacyOfficeBinary(extension)) {
         renderLegacyOfficeBinary(panel, extension, arrayBuffer);
       } else {
@@ -7368,7 +8464,7 @@ async function renderSheet(panel, arrayBuffer, extension) {
     heading.textContent = sheetName;
     const sheet = workbook.Sheets[sheetName];
     const sheetImages = workbookImages.get(sheetName) || [];
-    const range = trimWorkbookSheetRange(sheet, xlsx.utils.decode_range(sheet["!ref"] || "A1:A1"), xlsx.utils.decode_cell);
+    const range = trimWorkbookSheetRange(sheet, xlsx.utils.decode_range(sheet["!ref"] || "A1:A1"), xlsx.utils.decode_cell, sheetImages);
     const rowCount = range.e.r - range.s.r + 1;
     const columnCount = range.e.c - range.s.c + 1;
     const formulaRows = collectFormulaRows(sheet, range, xlsx.utils.encode_cell);
@@ -7467,7 +8563,7 @@ function renderSheetFallback(panel, extension, detail) {
 async function readWorkbookSheetImages(arrayBuffer) {
   const zip = await JSZip3.loadAsync(arrayBuffer);
   const fileNames = Object.keys(zip.files);
-  if (!fileNames.some((name) => /^xl\/drawings\/.+\.xml$/i.test(name)) || !fileNames.some((name) => /^xl\/media\//i.test(name))) {
+  if (!fileNames.some((name) => /^xl\/drawings\/.+\.xml$/i.test(name))) {
     return /* @__PURE__ */ new Map();
   }
   const workbookXml = await zip.file("xl/workbook.xml")?.async("text");
@@ -7527,6 +8623,7 @@ async function readWorksheetDrawingImages(zip, drawingPath) {
   const images = [];
   for (const anchor of anchors) {
     const from = Array.from(anchor.children).find((element) => element.localName === "from");
+    const to = Array.from(anchor.children).find((element) => element.localName === "to");
     const embedId = findDrawingImageRelationshipId(anchor);
     const mediaRel = drawingRels.find((rel) => rel.id === embedId && /\/image$/i.test(rel.type));
     const mediaPath = resolveOfficeRelationshipTarget(drawingPath, mediaRel?.target);
@@ -7538,6 +8635,8 @@ async function readWorksheetDrawingImages(zip, drawingPath) {
     images.push({
       row: readDrawingMarkerIndex(from, "row"),
       column: readDrawingMarkerIndex(from, "col"),
+      endRow: to ? readDrawingMarkerIndex(to, "row") : void 0,
+      endColumn: to ? readDrawingMarkerIndex(to, "col") : void 0,
       fileName: mediaPath.split("/").pop() || "image",
       mimeType,
       dataUrl: `data:${mimeType};base64,${await mediaFile.async("base64")}`,
@@ -7993,7 +9092,7 @@ function chartText(element) {
 function chartStringValues(element) {
   return Array.from(element.querySelectorAll("*")).filter((item) => item.localName === "v" || item.localName === "t").map((item) => item.textContent?.trim() || "").filter(Boolean);
 }
-function trimWorkbookSheetRange(sheet, range, decodeCell) {
+function trimWorkbookSheetRange(sheet, range, decodeCell, images = []) {
   let minRow = Number.POSITIVE_INFINITY;
   let minColumn = Number.POSITIVE_INFINITY;
   let maxRow = Number.NEGATIVE_INFINITY;
@@ -8018,17 +9117,21 @@ function trimWorkbookSheetRange(sheet, range, decodeCell) {
     include(merge.s.r, merge.s.c);
     include(merge.e.r, merge.e.c);
   }
+  for (const image of images) {
+    include(image.row, image.column);
+    include(image.endRow ?? image.row, image.endColumn ?? image.column);
+  }
   if (!Number.isFinite(minRow) || !Number.isFinite(minColumn) || !Number.isFinite(maxRow) || !Number.isFinite(maxColumn)) {
     return range;
   }
   return {
     s: {
-      r: Math.max(range.s.r, minRow),
-      c: Math.max(range.s.c, minColumn)
+      r: minRow,
+      c: minColumn
     },
     e: {
-      r: Math.min(range.e.r, maxRow),
-      c: Math.min(range.e.c, maxColumn)
+      r: maxRow,
+      c: maxColumn
     }
   };
 }
@@ -8159,7 +9262,9 @@ function createWorkbookSheetTable(sheet, range, sheetIndex, viewport, encodeCell
         cell.classList.add("ofv-cell-multiline");
       }
       appendWorkbookCellImages(cell, imagesByCell.get(`${rowIndex}:${columnIndex}`), text);
-      appendColumnResizeHandle(cell, columnIndex, columnSizing);
+      if (rowIndex === rowStart) {
+        appendColumnResizeHandle(cell, columnIndex, columnSizing);
+      }
       row.append(cell);
     }
     table.append(row);
@@ -8385,7 +9490,9 @@ function createParsedSheetTable(sheet, sheetIndex, viewport, columnSizing, reren
       if (value.includes("\n")) {
         cell.classList.add("ofv-cell-multiline");
       }
-      appendColumnResizeHandle(cell, columnIndex, columnSizing);
+      if (rowIndex === viewport.rowStart) {
+        appendColumnResizeHandle(cell, columnIndex, columnSizing);
+      }
       row.append(cell);
     }
     table.append(row);
@@ -9135,6 +10242,13 @@ function legacyOfficeFormatLabel(extension) {
   }
   return "PowerPoint Binary File Format";
 }
+function renderLegacyWordBinary(panel, extension, arrayBuffer) {
+  try {
+    renderLegacyWordDocument(panel, parseLegacyWordDocument(arrayBuffer));
+  } catch (error) {
+    renderLegacyOfficeBinary(panel, extension, arrayBuffer, `Word \u4E8C\u8FDB\u5236\u89E3\u6790\u5931\u8D25\uFF1A${normalizeOfficeError(error)}`);
+  }
+}
 function renderLegacyOfficeBinary(panel, extension, arrayBuffer, parseError) {
   const fragments = extractLegacyOfficeText(arrayBuffer);
   panel.replaceChildren();
@@ -13710,10 +14824,10 @@ function renderStep(panel, text, extension, ctx) {
   note.textContent = "\u5F53\u524D\u7248\u672C\u63D0\u53D6 STEP \u6587\u672C\u5B9E\u4F53\u3001\u7C7B\u578B\u7EDF\u8BA1\u548C\u5173\u952E\u51E0\u4F55\u53C2\u6570\u3002\u7CBE\u786E B-Rep/\u66F2\u9762\u6E32\u67D3\u5EFA\u8BAE\u540E\u7EED\u63A5\u5165 CAD \u5185\u6838\u6216\u670D\u52A1\u7AEF\u8F6C\u6362\u3002";
   const meta = document.createElement("div");
   meta.className = "ofv-cad-summary";
-  appendMeta5(meta, "\u5B9E\u4F53", records.length);
-  appendMeta5(meta, "\u7C7B\u578B", typeCounts.size);
-  appendMeta5(meta, "\u70B9", typeCounts.get("CARTESIAN_POINT") || 0);
-  appendMeta5(meta, "\u65B9\u5411", typeCounts.get("DIRECTION") || 0);
+  appendMeta6(meta, "\u5B9E\u4F53", records.length);
+  appendMeta6(meta, "\u7C7B\u578B", typeCounts.size);
+  appendMeta6(meta, "\u70B9", typeCounts.get("CARTESIAN_POINT") || 0);
+  appendMeta6(meta, "\u65B9\u5411", typeCounts.get("DIRECTION") || 0);
   const typeList = createCadTypeList(typeCounts);
   section.append(note, meta, typeList);
   let viewer;
@@ -13748,10 +14862,10 @@ function renderIges(panel, text, extension, ctx) {
   note.textContent = "\u5F53\u524D\u7248\u672C\u63D0\u53D6 IGES \u53C2\u6570\u533A\u5B9E\u4F53\u3001\u7C7B\u578B\u7EDF\u8BA1\u548C\u57FA\u7840\u53C2\u6570\u3002\u7CBE\u786E\u66F2\u7EBF/\u66F2\u9762\u6E32\u67D3\u5EFA\u8BAE\u540E\u7EED\u63A5\u5165 CAD \u5185\u6838\u6216\u670D\u52A1\u7AEF\u8F6C\u6362\u3002";
   const meta = document.createElement("div");
   meta.className = "ofv-cad-summary";
-  appendMeta5(meta, "\u5B9E\u4F53", records.length);
-  appendMeta5(meta, "\u7C7B\u578B", typeCounts.size);
-  appendMeta5(meta, "\u70B9\u5B9E\u4F53", typeCounts.get("116") || 0);
-  appendMeta5(meta, "\u7EBF\u5B9E\u4F53", typeCounts.get("110") || 0);
+  appendMeta6(meta, "\u5B9E\u4F53", records.length);
+  appendMeta6(meta, "\u7C7B\u578B", typeCounts.size);
+  appendMeta6(meta, "\u70B9\u5B9E\u4F53", typeCounts.get("116") || 0);
+  appendMeta6(meta, "\u7EBF\u5B9E\u4F53", typeCounts.get("110") || 0);
   const typeList = createCadTypeList(typeCounts, "\u7C7B\u578B\u53F7\u7EDF\u8BA1");
   section.append(note, meta, typeList);
   let viewer;
@@ -13785,13 +14899,13 @@ function renderIfc(panel, text) {
   note.textContent = "\u5F53\u524D\u7248\u672C\u63D0\u53D6 IFC STEP \u5B9E\u4F53\u3001BIM \u5C42\u7EA7\u548C\u5E38\u89C1\u6784\u4EF6\u7EDF\u8BA1\u3002\u51E0\u4F55\u7F51\u683C\u3001\u6750\u8D28\u548C\u5C5E\u6027\u96C6\u53EF\u540E\u7EED\u63A5\u5165 IfcOpenShell/IFC.js \u589E\u5F3A\u3002";
   const meta = document.createElement("div");
   meta.className = "ofv-cad-summary";
-  appendMeta5(meta, "\u5B9E\u4F53", records.length);
-  appendMeta5(meta, "\u7C7B\u578B", typeCounts.size);
-  appendMeta5(meta, "\u9879\u76EE", typeCounts.get("IFCPROJECT") || 0);
-  appendMeta5(meta, "\u5EFA\u7B51", typeCounts.get("IFCBUILDING") || 0);
-  appendMeta5(meta, "\u697C\u5C42", typeCounts.get("IFCBUILDINGSTOREY") || 0);
-  appendMeta5(meta, "\u7A7A\u95F4", typeCounts.get("IFCSPACE") || 0);
-  appendMeta5(meta, "\u6784\u4EF6", countIfcElements(typeCounts));
+  appendMeta6(meta, "\u5B9E\u4F53", records.length);
+  appendMeta6(meta, "\u7C7B\u578B", typeCounts.size);
+  appendMeta6(meta, "\u9879\u76EE", typeCounts.get("IFCPROJECT") || 0);
+  appendMeta6(meta, "\u5EFA\u7B51", typeCounts.get("IFCBUILDING") || 0);
+  appendMeta6(meta, "\u697C\u5C42", typeCounts.get("IFCBUILDINGSTOREY") || 0);
+  appendMeta6(meta, "\u7A7A\u95F4", typeCounts.get("IFCSPACE") || 0);
+  appendMeta6(meta, "\u6784\u4EF6", countIfcElements(typeCounts));
   section.append(note, meta, createCadTypeList(typeCounts, "IFC \u5B9E\u4F53\u7EDF\u8BA1"));
   const hierarchy = createIfcHierarchy(records);
   if (hierarchy) {
@@ -13816,10 +14930,10 @@ function renderAcisSat(panel, text, extension, ctx) {
   note.textContent = "\u5F53\u524D\u7248\u672C\u4F1A\u5728\u524D\u7AEF\u89E3\u6790 ACIS SAT \u6587\u672C\u5B9E\u4F53\u3001\u7C7B\u578B\u7EDF\u8BA1\u548C\u5E38\u89C1 vertex/straight-curve \u51E0\u4F55\u7EBF\u7D22\uFF1B\u7CBE\u786E\u66F2\u9762\u3001\u62D3\u6251\u548C\u5E03\u5C14\u4F53\u4ECD\u5EFA\u8BAE\u63A5\u5165 CAD \u5185\u6838\u589E\u5F3A\u3002";
   const meta = document.createElement("div");
   meta.className = "ofv-cad-summary";
-  appendMeta5(meta, "\u5B9E\u4F53", records.length);
-  appendMeta5(meta, "\u7C7B\u578B", typeCounts.size);
-  appendMeta5(meta, "\u9876\u70B9", typeCounts.get("vertex") || 0);
-  appendMeta5(meta, "\u76F4\u7EBF", typeCounts.get("straight-curve") || 0);
+  appendMeta6(meta, "\u5B9E\u4F53", records.length);
+  appendMeta6(meta, "\u7C7B\u578B", typeCounts.size);
+  appendMeta6(meta, "\u9876\u70B9", typeCounts.get("vertex") || 0);
+  appendMeta6(meta, "\u76F4\u7EBF", typeCounts.get("straight-curve") || 0);
   const typeList = createCadTypeList(typeCounts);
   section.append(note, meta, typeList);
   let viewer;
@@ -13856,10 +14970,10 @@ function renderParasolidText(panel, text, extension, ctx) {
   note.textContent = "\u5F53\u524D\u7248\u672C\u4F1A\u5728\u524D\u7AEF\u89E3\u6790 Parasolid x_t \u6587\u672C\u7247\u6BB5\u3001\u5B9E\u4F53\u7C7B\u578B\u3001\u5750\u6807\u70B9\u548C\u57FA\u7840\u7EBF\u6BB5\u7EBF\u7D22\uFF1B\u5B8C\u6574 B-Rep\u3001\u66F2\u9762\u548C\u88C5\u914D\u5173\u7CFB\u5EFA\u8BAE\u63A5\u5165 Parasolid/HOOPS/ODA \u7B49\u4E13\u4E1A\u5185\u6838\u3002";
   const meta = document.createElement("div");
   meta.className = "ofv-cad-summary";
-  appendMeta5(meta, "\u5B9E\u4F53", records.length);
-  appendMeta5(meta, "\u7C7B\u578B", typeCounts.size);
-  appendMeta5(meta, "\u70B9", typeCounts.get("point") || typeCounts.get("vertex") || 0);
-  appendMeta5(meta, "\u66F2\u7EBF", (typeCounts.get("line") || 0) + (typeCounts.get("curve") || 0));
+  appendMeta6(meta, "\u5B9E\u4F53", records.length);
+  appendMeta6(meta, "\u7C7B\u578B", typeCounts.size);
+  appendMeta6(meta, "\u70B9", typeCounts.get("point") || typeCounts.get("vertex") || 0);
+  appendMeta6(meta, "\u66F2\u7EBF", (typeCounts.get("line") || 0) + (typeCounts.get("curve") || 0));
   const typeList = createCadTypeList(typeCounts);
   section.append(note, meta, typeList);
   let viewer;
@@ -13967,23 +15081,23 @@ function renderLayoutPreview(panel, data, ctx) {
     summary.setAttribute("aria-hidden", "true");
     summary.style.display = "none";
   }
-  appendMeta5(summary, "\u6587\u4EF6", data.fileName);
-  appendMeta5(summary, "\u683C\u5F0F", data.format);
+  appendMeta6(summary, "\u6587\u4EF6", data.fileName);
+  appendMeta6(summary, "\u683C\u5F0F", data.format);
   if (data.libraryName) {
-    appendMeta5(summary, "\u5E93", data.libraryName);
+    appendMeta6(summary, "\u5E93", data.libraryName);
   }
   if (data.version) {
-    appendMeta5(summary, "\u7248\u672C", data.version);
+    appendMeta6(summary, "\u7248\u672C", data.version);
   }
   if (data.unit) {
-    appendMeta5(summary, "\u5355\u4F4D", data.unit);
+    appendMeta6(summary, "\u5355\u4F4D", data.unit);
   }
-  appendMeta5(summary, "Cell", data.cells.length);
-  appendMeta5(summary, "\u51E0\u4F55", data.shapes.length);
-  appendMeta5(summary, "\u5F15\u7528", data.references.length);
-  appendMeta5(summary, "\u6587\u5B57", data.labels.length);
+  appendMeta6(summary, "Cell", data.cells.length);
+  appendMeta6(summary, "\u51E0\u4F55", data.shapes.length);
+  appendMeta6(summary, "\u5F15\u7528", data.references.length);
+  appendMeta6(summary, "\u6587\u5B57", data.labels.length);
   for (const [label, value] of data.metadata) {
-    appendMeta5(summary, label, value);
+    appendMeta6(summary, label, value);
   }
   section.append(summary);
   for (const noteText of [...data.notes, ...data.warnings]) {
@@ -14589,12 +15703,12 @@ function renderBinaryCad(panel, bytes, extension, fileName) {
   note.textContent = extension === "dwg" ? "\u5DF2\u8BC6\u522B DWG \u4E13\u6709\u4E8C\u8FDB\u5236\u56FE\u7EB8\u3002\u6838\u5FC3\u63D2\u4EF6\u9ED8\u8BA4\u63D0\u4F9B\u7248\u672C\u3001\u5BB9\u5668\u3001\u7ED3\u6784\u7EBF\u7D22\u548C\u63A5\u5165\u5EFA\u8BAE\uFF1B\u771F\u5B9E\u51E0\u4F55\u6E32\u67D3\u53EF\u901A\u8FC7 cadPlugin({ binaryRenderer }) \u63A5\u5165\u53EF\u9009\u524D\u7AEF\u5F15\u64CE\u6216\u8F6C\u6362\u670D\u52A1\u3002" : "\u5DF2\u8BC6\u522B DWF \u53D1\u5E03\u56FE\u7EB8\u3002\u6838\u5FC3\u63D2\u4EF6\u9ED8\u8BA4\u63D0\u4F9B\u5BB9\u5668\u7EBF\u7D22\u548C\u63A5\u5165\u5EFA\u8BAE\uFF1B\u9AD8\u4FDD\u771F\u9875\u9762\u6E32\u67D3\u53EF\u901A\u8FC7 cadPlugin({ binaryRenderer }) \u63A5\u5165\u4E13\u7528\u89E3\u6790\u5668\u6216\u8F6C\u6362\u670D\u52A1\u3002";
   const meta = document.createElement("div");
   meta.className = "ofv-cad-summary";
-  appendMeta5(meta, "\u6587\u4EF6", fileName);
-  appendMeta5(meta, "\u683C\u5F0F", extension.toUpperCase());
-  appendMeta5(meta, "\u5927\u5C0F", formatBytes3(bytes.byteLength));
-  appendMeta5(meta, "\u7B7E\u540D", byteSignature2(bytes));
-  appendMeta5(meta, "\u7248\u672C", detectCadVersion(bytes, extension));
-  appendMeta5(meta, "\u5BB9\u5668", detectCadContainer(bytes));
+  appendMeta6(meta, "\u6587\u4EF6", fileName);
+  appendMeta6(meta, "\u683C\u5F0F", extension.toUpperCase());
+  appendMeta6(meta, "\u5927\u5C0F", formatBytes3(bytes.byteLength));
+  appendMeta6(meta, "\u7B7E\u540D", byteSignature2(bytes));
+  appendMeta6(meta, "\u7248\u672C", detectCadVersion(bytes, extension));
+  appendMeta6(meta, "\u5BB9\u5668", detectCadContainer(bytes));
   const actions = document.createElement("div");
   actions.className = "ofv-cad-conversion";
   const actionTitle = document.createElement("h4");
@@ -14634,12 +15748,12 @@ function createBinaryCadProbe(bytes, extension) {
   summary.textContent = "\u4E8C\u8FDB\u5236\u7ED3\u6784\u63A2\u6D4B";
   const meta = document.createElement("div");
   meta.className = "ofv-archive-probe-meta";
-  appendMeta5(meta, "\u53EF\u8BFB\u7247\u6BB5", probe.tokens.length);
-  appendMeta5(meta, "\u5B9E\u4F53\u5173\u952E\u8BCD", formatCadKeywordCounts(probe.entityCounts));
-  appendMeta5(meta, "\u56FE\u5C42\u7EBF\u7D22", String(probe.layerHints.length));
-  appendMeta5(meta, "\u5757/\u5F15\u7528\u7EBF\u7D22", String(probe.blockHints.length));
-  appendMeta5(meta, "\u5916\u90E8\u5F15\u7528", String(probe.externalRefs.length));
-  appendMeta5(meta, "\u89E3\u6790\u7EA7\u522B", extension === "dwg" ? "\u542F\u53D1\u5F0F\u626B\u63CF" : "\u5BB9\u5668/\u6587\u672C\u626B\u63CF");
+  appendMeta6(meta, "\u53EF\u8BFB\u7247\u6BB5", probe.tokens.length);
+  appendMeta6(meta, "\u5B9E\u4F53\u5173\u952E\u8BCD", formatCadKeywordCounts(probe.entityCounts));
+  appendMeta6(meta, "\u56FE\u5C42\u7EBF\u7D22", String(probe.layerHints.length));
+  appendMeta6(meta, "\u5757/\u5F15\u7528\u7EBF\u7D22", String(probe.blockHints.length));
+  appendMeta6(meta, "\u5916\u90E8\u5F15\u7528", String(probe.externalRefs.length));
+  appendMeta6(meta, "\u89E3\u6790\u7EA7\u522B", extension === "dwg" ? "\u542F\u53D1\u5F0F\u626B\u63CF" : "\u5BB9\u5668/\u6587\u672C\u626B\u63CF");
   details.append(summary, meta);
   const hints = [...probe.layerHints, ...probe.blockHints, ...probe.externalRefs].slice(0, 18);
   if (hints.length > 0) {
@@ -15172,9 +16286,9 @@ function createUnsupportedCadSection(extension, fileName) {
   const section = createSection("CAD \u589E\u5F3A\u63A5\u5165\u63D0\u793A");
   const meta = document.createElement("div");
   meta.className = "ofv-cad-summary";
-  appendMeta5(meta, "\u6587\u4EF6", fileName);
-  appendMeta5(meta, "\u683C\u5F0F", `.${extension || "cad"}`);
-  appendMeta5(meta, "\u5185\u7F6E\u80FD\u529B", unsupportedCadBuiltInLevel(extension));
+  appendMeta6(meta, "\u6587\u4EF6", fileName);
+  appendMeta6(meta, "\u683C\u5F0F", `.${extension || "cad"}`);
+  appendMeta6(meta, "\u5185\u7F6E\u80FD\u529B", unsupportedCadBuiltInLevel(extension));
   const note = document.createElement("p");
   note.textContent = unsupportedCadGuidance(extension);
   const actions = document.createElement("div");
@@ -15287,7 +16401,7 @@ function countBy(values) {
   }
   return counts;
 }
-function appendMeta5(parent, label, value) {
+function appendMeta6(parent, label, value) {
   const row = document.createElement("div");
   row.className = "ofv-meta-row";
   const key = document.createElement("span");
@@ -17321,10 +18435,10 @@ function read255UInt16(bytes, offset) {
   return { value: code, offset };
 }
 function decodeEotString(bytes) {
-  const text = decodeUtf16Le(bytes).replace(/\0+$/g, "").trim();
+  const text = decodeUtf16Le2(bytes).replace(/\0+$/g, "").trim();
   return text || new TextDecoder("latin1").decode(bytes).replace(/\0+$/g, "").trim();
 }
-function decodeUtf16Le(bytes) {
+function decodeUtf16Le2(bytes) {
   let value = "";
   for (let index = 0; index + 1 < bytes.length; index += 2) {
     value += String.fromCharCode(bytes[index] | bytes[index + 1] << 8);