@open-file-viewer/core 0.1.15 → 0.1.17

package/dist/index.js

@@ -1877,12 +1877,12 @@ function imagePlugin() {
       let url = "";
       let convertedBlob = null;
       let isExternal = Boolean(ctx.file.url);
-      let canvasSource = null;
+      let tiffSource = null;
       if (isTiff) {
         ctx.setLoading(true);
         try {
           const bytes = await sourceBytesPromise;
-          canvasSource = await createTiffCanvas(bytes);
+          tiffSource = await createTiffPreview(bytes, ctx.file.name);
         } catch (err) {
           console.error("TIFF image conversion failed:", err);
           url = createObjectUrl(ctx.file);
@@ -1942,12 +1942,15 @@ function imagePlugin() {
       if (url) {
         image.src = url;
       }
-      const visual = canvasSource || image;
-      if (canvasSource) {
-        canvasSource.classList.add("ofv-media", "ofv-image-content", "ofv-tiff-canvas");
-        canvasSource.setAttribute("role", "img");
-        canvasSource.setAttribute("aria-label", ctx.file.name);
+      const visual = tiffSource || image;
+      if (tiffSource) {
+        tiffSource.classList.add("ofv-image-content");
+        if (tiffSource.classList.contains("ofv-tiff-pages")) {
+          stage.classList.add("ofv-image-stage-pages");
+        }
       }
+      const visualBox = document.createElement("div");
+      visualBox.className = "ofv-image-scrollbox";
       let scale = getInitialZoom(ctx);
       let rotation = 0;
       let offsetX = 0;
@@ -1961,7 +1964,23 @@ function imagePlugin() {
       let previewAvailable = true;
       const zoomLabel = document.createElement("span");
       zoomLabel.className = "ofv-image-zoom";
+      const updateScrollBox = () => {
+        if (visual.classList.contains("ofv-tiff-pages")) {
+          visualBox.style.removeProperty("width");
+          visualBox.style.removeProperty("height");
+          return;
+        }
+        const baseWidth = visual.offsetWidth || visual.getBoundingClientRect().width || visual.naturalWidth || 0;
+        const baseHeight = visual.offsetHeight || visual.getBoundingClientRect().height || visual.naturalHeight || 0;
+        if (baseWidth > 0) {
+          visualBox.style.width = `${Math.ceil(baseWidth * scale)}px`;
+        }
+        if (baseHeight > 0) {
+          visualBox.style.height = `${Math.ceil(baseHeight * scale)}px`;
+        }
+      };
       const updateTransform = () => {
+        updateScrollBox();
         visual.style.transform = `translate(${offsetX}px, ${offsetY}px) scale(${scale}) rotate(${rotation}deg)`;
         zoomLabel.textContent = `${Math.round(scale * 100)}%`;
         ctx.toolbar?.setZoom(previewAvailable ? scale : void 0);
@@ -2081,11 +2100,13 @@ function imagePlugin() {
       stage.addEventListener("lostpointercapture", onLostPointerCapture);
       stage.addEventListener("pointerleave", onPointerLeave);
       stage.addEventListener("wheel", onWheel, { passive: false });
-      if (!canvasSource) {
+      if (!tiffSource) {
         image.addEventListener("error", showImageFallback);
+        image.addEventListener("load", updateScrollBox);
       }
       window.addEventListener("blur", onWindowBlur);
-      stage.append(visual);
+      visualBox.append(visual);
+      stage.append(visualBox);
       wrapper.append(...showInlineControls ? [controls, stage, infoBar] : [stage, infoBar]);
       ctx.viewport.append(wrapper);
       updateTransform();
@@ -2123,7 +2144,12 @@ function imagePlugin() {
         },
         resize(size) {
           visual.style.maxWidth = `${size.width}px`;
-          visual.style.maxHeight = `${Math.max(0, size.height - controls.offsetHeight)}px`;
+          if (visual.classList.contains("ofv-tiff-pages")) {
+            visual.style.removeProperty("max-height");
+          } else {
+            visual.style.maxHeight = `${Math.max(0, size.height - controls.offsetHeight)}px`;
+          }
+          updateScrollBox();
         },
         destroy() {
           ctx.toolbar?.setZoom(void 0);
@@ -2138,6 +2164,7 @@ function imagePlugin() {
           stage.removeEventListener("pointerleave", onPointerLeave);
           stage.removeEventListener("wheel", onWheel);
           image.removeEventListener("error", showImageFallback);
+          image.removeEventListener("load", updateScrollBox);
           window.removeEventListener("blur", onWindowBlur);
           finishDrag();
           wrapper.remove();
@@ -2151,33 +2178,64 @@ function imagePlugin() {
     }
   };
 }
-async function createTiffCanvas(bytes) {
+async function createTiffPreview(bytes, fileName) {
   if (bytes.byteLength === 0) {
     throw new Error("\u65E0\u6CD5\u8BFB\u53D6 TIFF \u6587\u4EF6\u5185\u5BB9\u3002");
   }
   const UTIF = await import("utif");
   const buffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
   const ifds = UTIF.decode(buffer);
-  const ifd = ifds.find((item) => Number(item.width || 0) > 0 || Number(item.t256 || 0) > 0) || ifds[0];
-  if (!ifd) {
+  const imageIfds = ifds.filter((item) => hasTiffDimensions(item));
+  if (imageIfds.length === 0) {
     throw new Error("TIFF \u6587\u4EF6\u6CA1\u6709\u53EF\u89E3\u7801\u7684\u56FE\u50CF\u76EE\u5F55\u3002");
   }
+  const pages = imageIfds.map((ifd, index) => createTiffPage(UTIF, buffer, ifd, index, imageIfds.length, fileName));
+  if (pages.length === 1) {
+    return pages[0].canvas;
+  }
+  const container = document.createElement("div");
+  container.className = "ofv-tiff-pages";
+  container.setAttribute("role", "group");
+  container.setAttribute("aria-label", `${fileName}\uFF0C\u5171 ${pages.length} \u9875`);
+  for (const page of pages) {
+    const figure = document.createElement("figure");
+    figure.className = "ofv-tiff-page";
+    const caption = document.createElement("figcaption");
+    caption.textContent = `\u7B2C ${page.index + 1} / ${pages.length} \u9875 \xB7 ${page.width} x ${page.height}px`;
+    figure.append(page.canvas, caption);
+    container.append(figure);
+  }
+  return container;
+}
+function createTiffPage(UTIF, buffer, ifd, index, total, fileName) {
   UTIF.decodeImage(buffer, ifd);
   const rgba = UTIF.toRGBA8(ifd);
-  const width = Number(ifd.width || ifd.t256 || 0);
-  const height = Number(ifd.height || ifd.t257 || 0);
+  const { width, height } = getTiffDimensions(ifd);
   if (!width || !height || rgba.length < width * height * 4) {
     throw new Error("TIFF \u56FE\u50CF\u50CF\u7D20\u6570\u636E\u4E0D\u5B8C\u6574\u3002");
   }
   const canvas = document.createElement("canvas");
+  canvas.className = "ofv-tiff-canvas";
   canvas.width = width;
   canvas.height = height;
+  canvas.setAttribute("role", "img");
+  canvas.setAttribute("aria-label", total > 1 ? `${fileName} \u7B2C ${index + 1} \u9875` : fileName);
   const context = canvas.getContext("2d");
   if (!context) {
     throw new Error("\u5F53\u524D\u73AF\u5883\u4E0D\u652F\u6301 Canvas 2D\uFF0C\u65E0\u6CD5\u5C55\u793A TIFF\u3002");
   }
   context.putImageData(new ImageData(new Uint8ClampedArray(rgba), width, height), 0, 0);
-  return canvas;
+  return { canvas, width, height, index };
+}
+function hasTiffDimensions(ifd) {
+  const { width, height } = getTiffDimensions(ifd);
+  return width > 0 && height > 0;
+}
+function getTiffDimensions(ifd) {
+  return {
+    width: Number(ifd.width || ifd.t256 || 0),
+    height: Number(ifd.height || ifd.t257 || 0)
+  };
 }
 function createImageFallback(fileName, url) {
   const fallback = document.createElement("div");
@@ -2506,6 +2564,7 @@ function parseTiffInfo(bytes) {
     return { format: magic === 43 ? "BigTIFF" : "TIFF", note: "IFD \u504F\u79FB\u8D85\u51FA\u6587\u4EF6\u8303\u56F4" };
   }
   const count = magic === 43 ? readTiffUint64AsNumber(bytes, ifdOffset, littleEndian) : readTiffUint16(bytes, ifdOffset, littleEndian);
+  const imageCount = countTiffIfds(bytes, ifdOffset, magic === 43, littleEndian);
   const entrySize = magic === 43 ? 20 : 12;
   const entriesStart = ifdOffset + (magic === 43 ? 8 : 2);
   let width;
@@ -2532,9 +2591,26 @@ function parseTiffInfo(bytes) {
     height,
     bitDepth: bitDepth ? `${bitDepth} bit` : void 0,
     color: compression ? tiffCompressionName(compression) : void 0,
-    count: Number.isFinite(count) ? count : void 0
+    count: imageCount || void 0
   };
 }
+function countTiffIfds(bytes, firstOffset, bigTiff, littleEndian) {
+  const seen = /* @__PURE__ */ new Set();
+  let offset = firstOffset;
+  let count = 0;
+  while (Number.isFinite(offset) && offset > 0 && offset < bytes.length && !seen.has(offset) && count < 512) {
+    seen.add(offset);
+    const entryCount = bigTiff ? readTiffUint64AsNumber(bytes, offset, littleEndian) : readTiffUint16(bytes, offset, littleEndian);
+    const entrySize = bigTiff ? 20 : 12;
+    const nextOffsetPosition = offset + (bigTiff ? 8 : 2) + entryCount * entrySize;
+    if (!Number.isFinite(entryCount) || nextOffsetPosition + (bigTiff ? 8 : 4) > bytes.length) {
+      break;
+    }
+    count++;
+    offset = bigTiff ? readTiffUint64AsNumber(bytes, nextOffsetPosition, littleEndian) : readTiffUint32(bytes, nextOffsetPosition, littleEndian);
+  }
+  return count;
+}
 function readTiffInlineValue(bytes, offset, type, littleEndian) {
   if (offset + 4 > bytes.length) {
     return void 0;
@@ -3933,26 +4009,6 @@ var mimeLangMap = {
 };
 var MAX_HIGHLIGHT_CHARS = 18e4;
 var MAX_RENDER_CHARS = 6e5;
-function loadPrismCss(theme) {
-  const lightId = "ofv-prism-css-light";
-  const darkId = "ofv-prism-css-dark";
-  const activeId = theme === "dark" ? darkId : lightId;
-  const inactiveId = theme === "dark" ? lightId : darkId;
-  document.getElementById(inactiveId)?.remove();
-  if (document.getElementById(activeId)) {
-    return Promise.resolve();
-  }
-  const href = theme === "dark" ? "https://cdn.jsdelivr.net/npm/prismjs@1.29.0/themes/prism-tomorrow.min.css" : "https://cdn.jsdelivr.net/npm/prismjs@1.29.0/themes/prism.min.css";
-  return new Promise((resolve, reject) => {
-    const link = document.createElement("link");
-    link.id = activeId;
-    link.rel = "stylesheet";
-    link.href = href;
-    link.onload = () => resolve();
-    link.onerror = () => reject(new Error(`Failed to load Prism CSS: ${href}`));
-    document.head.appendChild(link);
-  });
-}
 function textPlugin() {
   return {
     name: "text",
@@ -3976,7 +4032,6 @@ function textPlugin() {
           }
         };
       }
-      const isDark = ctx.host.parentElement?.classList.contains("ofv-theme-dark") || document.body.classList.contains("ofv-theme-dark") || ctx.options.theme === "auto" && window.matchMedia?.("(prefers-color-scheme: dark)").matches || ctx.options.theme === "dark";
       if (isMarkdown) {
         const [markedModule, PrismModule2, DOMPurifyModule] = await Promise.all([
           import("marked"),
@@ -3997,7 +4052,6 @@ function textPlugin() {
         try {
           const codeBlocks = container.querySelectorAll("pre code");
           if (codeBlocks.length > 0) {
-            await loadPrismCss(isDark ? "dark" : "light");
             codeBlocks.forEach((block) => {
               const parent = block.parentElement;
               if (parent && !parent.className.includes("language-")) {
@@ -4121,9 +4175,6 @@ function textPlugin() {
           console.warn(`Prism failed to load language component for: ${lang}`, e);
         }
       }
-      await loadPrismCss(isDark ? "dark" : "light").catch((error) => {
-        console.warn("Prism CSS failed to load; rendering code without external theme:", error);
-      });
       const codeText = text.length > MAX_RENDER_CHARS ? text.slice(0, MAX_RENDER_CHARS) : text;
       const totalLines = countLines(text);
       const shownLines = countLines(codeText);
@@ -4651,10 +4702,11 @@ async function renderPdfDocumentPreview(options) {
       const baseViewport = page.getViewport({ scale: 1 });
       pagesMeta.push({
         width: baseViewport.width,
-        height: baseViewport.height
+        height: baseViewport.height,
+        rotation: getPdfPageRotation(page)
       });
     } catch {
-      pagesMeta.push({ width: 612, height: 792 });
+      pagesMeta.push({ width: 612, height: 792, rotation: 0 });
     }
   }
   const pageStates = [];
@@ -4689,7 +4741,7 @@ async function renderPdfDocumentPreview(options) {
       const page = await pdfDocument.getPage(pageIdx + 1);
       const meta = pagesMeta[pageIdx];
       const scale = options.fit === "actual" ? zoomFactor : Math.max(0.05, Math.min(5, getPdfAvailableWidth(size.width) / rotatedPdfWidth(meta, rotation) * zoomFactor));
-      const viewport = page.getViewport({ scale, rotation });
+      const viewport = page.getViewport({ scale, rotation: getPdfRenderRotation(meta, rotation) });
       const outputScale = getPdfOutputScale();
       const cssWidth = Math.floor(viewport.width);
       const cssHeight = Math.floor(viewport.height);
@@ -4728,6 +4780,8 @@ async function renderPdfDocumentPreview(options) {
         const span = document.createElement("span");
         span.textContent = str;
         span.style.fontSize = `${fontHeight}px`;
+        span.style.lineHeight = "1";
+        span.style.height = `${fontHeight}px`;
         span.style.fontFamily = item.fontName || "sans-serif";
         span.style.left = `${tx[4]}px`;
         span.style.top = `${tx[5] - fontHeight}px`;
@@ -4925,6 +4979,13 @@ function appendPdfSummary(parent, label, value) {
 function normalizePdfRotation(value) {
   return (value % 360 + 360) % 360;
 }
+function getPdfPageRotation(page) {
+  const rotation = Number(page.rotate);
+  return Number.isFinite(rotation) ? normalizePdfRotation(rotation) : 0;
+}
+function getPdfRenderRotation(meta, userRotation) {
+  return normalizePdfRotation((meta.rotation || 0) + userRotation);
+}
 function isPdfRotatedSideways(rotation) {
   const normalized = normalizePdfRotation(rotation);
   return normalized === 90 || normalized === 270;
@@ -5809,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"]);
@@ -5895,13 +7050,13 @@ function officePlugin(options = {}) {
       if (conversionContext && await shouldUseOfficeConversion(options, conversionContext)) {
         delegatedInstance = await renderConvertedOfficePreview(panel, ctx, options, conversionContext);
       } else if (packageFormat === "docx" && !fileIsDocx(extension)) {
-        disposeDocxFit = await renderDocx(panel, arrayBuffer);
+        disposeDocxFit = await renderDocx(panel, arrayBuffer, ctx.options.fit);
       } else if (packageFormat === "xlsx" && !sheetExtensions.has(extension)) {
         await renderSheet(panel, arrayBuffer, "xlsx");
       } else if (packageFormat === "pptx" && !["pptx", "pptm", "ppsx", "ppsm", "potx", "potm"].includes(extension)) {
         await renderPptx(panel, arrayBuffer);
       } else if (fileIsDocx(extension)) {
-        disposeDocxFit = await renderDocx(panel, arrayBuffer);
+        disposeDocxFit = await renderDocx(panel, arrayBuffer, ctx.options.fit);
       } else if (extension === "rtf") {
         renderPlainDocument(panel, "RTF \u6587\u6863", rtfToText(await readTextFromBuffer(arrayBuffer)));
       } else if (extension === "odt") {
@@ -5910,7 +7065,7 @@ function officePlugin(options = {}) {
         renderOpenDocumentXml(panel, "FODT \u6587\u6863", await readTextFromBuffer(arrayBuffer));
       } else if (extension === "fods") {
         renderFlatOds(panel, await readTextFromBuffer(arrayBuffer));
-      } else if (packagedOfficeCandidates.has(extension) && await renderPackagedOfficePreview(panel, arrayBuffer, extension)) {
+      } else if (packagedOfficeCandidates.has(extension) && await renderPackagedOfficePreview(panel, arrayBuffer, extension, ctx.options.fit)) {
       } else if (sheetExtensions.has(extension)) {
         await renderSheet(panel, arrayBuffer, extension);
       } else if (["pptx", "pptm", "ppsx", "ppsm", "potx", "potm"].includes(extension)) {
@@ -5919,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 {
@@ -6112,7 +7269,7 @@ async function detectPackagedOfficeFormat(arrayBuffer) {
   }
   return void 0;
 }
-async function renderDocx(panel, arrayBuffer) {
+async function renderDocx(panel, arrayBuffer, fit) {
   const content = document.createElement("div");
   content.className = "ofv-docx-document";
   const styleContainer = document.createElement("div");
@@ -6151,7 +7308,7 @@ async function renderDocx(panel, arrayBuffer) {
       return () => void 0;
     }
     panel.append(content);
-    disposeFit = fitDocxPages(content);
+    disposeFit = fitDocxPages(content, fit);
     return () => {
       disposeFit?.();
       styleContainer.remove();
@@ -6749,7 +7906,8 @@ function looksLikeDocxTextboxHeading(value) {
   return text.length > 0 && text.length <= 12 && !/[0-9@.:：]/.test(text);
 }
 async function normalizeDocxLayout(container, arrayBuffer) {
-  const hints = await readDocxLayoutHints(arrayBuffer);
+  const [hints, charts] = await Promise.all([readDocxLayoutHints(arrayBuffer), readDocxCharts(arrayBuffer)]);
+  repairDocxChartPlaceholders(container, charts);
   const pages = container.querySelectorAll("section.ofv-docx");
   for (const page of pages) {
     repairDocxShapeFills(page);
@@ -6764,6 +7922,75 @@ async function normalizeDocxLayout(container, arrayBuffer) {
     }
   }
 }
+async function readDocxCharts(arrayBuffer) {
+  try {
+    const zip = await JSZip3.loadAsync(arrayBuffer);
+    const documentXml = await zip.file("word/document.xml")?.async("text");
+    const documentDoc = documentXml ? parseOfficeXml(documentXml) : void 0;
+    if (!documentDoc) {
+      return [];
+    }
+    const relationships = await readOfficeRelationships(zip, "word/document.xml");
+    const chartDrawings = Array.from(documentDoc.getElementsByTagName("*")).filter((element) => element.localName === "inline" || element.localName === "anchor").map((element) => readDocxChartDrawing(element)).filter((item) => Boolean(item?.relationshipId));
+    const charts = [];
+    for (const [index, drawing] of chartDrawings.entries()) {
+      const chartRel = relationships.find((rel) => rel.id === drawing.relationshipId && /\/chart$/i.test(rel.type));
+      const chartPath = resolveOfficeRelationshipTarget("word/document.xml", chartRel?.target);
+      const chartXml = chartPath ? await zip.file(chartPath)?.async("text") : void 0;
+      const chart = chartXml ? parseChartXml(chartXml, chartPath?.split("/").pop() || `chart${index + 1}.xml`) : null;
+      if (chart) {
+        charts.push({ ...chart, widthPt: drawing.widthPt, heightPt: drawing.heightPt });
+      }
+    }
+    return charts;
+  } catch {
+    return [];
+  }
+}
+function readDocxChartDrawing(element) {
+  const chart = Array.from(element.getElementsByTagName("*")).find((child) => child.localName === "chart");
+  const relationshipId = chart ? getXmlAttribute3(chart, "id") : "";
+  if (!relationshipId) {
+    return void 0;
+  }
+  const extent = Array.from(element.children).find((child) => child.localName === "extent");
+  return {
+    relationshipId,
+    widthPt: emuToPt(Number(extent?.getAttribute("cx") || 0)),
+    heightPt: emuToPt(Number(extent?.getAttribute("cy") || 0))
+  };
+}
+function repairDocxChartPlaceholders(container, charts) {
+  if (charts.length === 0) {
+    return;
+  }
+  const placeholders = Array.from(container.querySelectorAll("section.ofv-docx div")).filter(isDocxChartPlaceholder);
+  if (placeholders.length !== charts.length) {
+    return;
+  }
+  placeholders.forEach((placeholder, index) => {
+    const chart = charts[index];
+    placeholder.classList.add("ofv-docx-chart-preview");
+    placeholder.dataset.ofvDocxChartPreview = "true";
+    if (chart.widthPt > 0) {
+      placeholder.style.width ||= `${formatCssNumber(chart.widthPt)}pt`;
+    }
+    if (chart.heightPt > 0) {
+      placeholder.style.height ||= `${formatCssNumber(chart.heightPt)}pt`;
+    }
+    placeholder.replaceChildren(renderChartSvg(chart));
+  });
+}
+function isDocxChartPlaceholder(element) {
+  if (element.dataset.ofvDocxChartPreview === "true" || element.children.length > 0 || normalizePreviewText(element.textContent || "")) {
+    return false;
+  }
+  const display = element.style.display;
+  const position = element.style.position;
+  const width = parseCssPixelValue(element.style.width);
+  const height = parseCssPixelValue(element.style.height);
+  return display === "inline-block" && position === "relative" && width >= 120 && height >= 80;
+}
 function repairDocxHeadingShapeAlignment(page) {
   for (const paragraph of page.querySelectorAll("p")) {
     const text = normalizePreviewText(paragraph.textContent || "");
@@ -6914,14 +8141,19 @@ function repairDocxShapeFills(page) {
   }
 }
 function repairDocxFloatingPictures(page, hints) {
-  const hint = hints.floatingPictures.find((item) => item.relativeFrom === "column" && item.wrap === "square");
-  if (!hint) {
+  const pageHints = hints.floatingPictures.filter((item) => item.relativeFrom === "column" && item.wrap === "square");
+  if (pageHints.length === 0) {
     return;
   }
-  const image = page.querySelector("img");
-  if (!image) {
+  const images = Array.from(page.querySelectorAll("img")).filter(
+    (image) => image.closest("[data-ofv-docx-float-repaired='true']") === null
+  );
+  if (images.length === 0 || images.length !== pageHints.length) {
     return;
   }
+  images.forEach((image, index) => repairDocxFloatingPicture(page, image, pageHints[index]));
+}
+function repairDocxFloatingPicture(page, image, hint) {
   const wrapper = image.parentElement;
   if (!wrapper || wrapper.dataset.ofvDocxFloatRepaired === "true") {
     return;
@@ -6967,7 +8199,7 @@ function parseCssLineHeight(value) {
   const parsed = Number.parseFloat(trimmed);
   return Number.isFinite(parsed) ? parsed : 0;
 }
-function fitDocxPages(container) {
+function fitDocxPages(container, fit) {
   const wrapper = container.querySelector(".ofv-docx-wrapper");
   if (!wrapper) {
     return () => void 0;
@@ -6980,6 +8212,7 @@ function fitDocxPages(container) {
       return;
     }
     const availableWidth = Math.max(1, container.clientWidth - 48);
+    const availableHeight = container.clientHeight > 0 ? Math.max(1, container.clientHeight - 48) : void 0;
     const pageWidth = Math.max(
       1,
       ...frames.map(({ page }) => {
@@ -6987,14 +8220,24 @@ function fitDocxPages(container) {
         return page.offsetWidth || rectWidth || parseCssPixelValue(page.style.width) || 794;
       })
     );
-    const scale = Math.min(1, Math.max(0.35, availableWidth / pageWidth));
+    const pageHeight = Math.max(
+      1,
+      ...frames.map(({ page }) => page.offsetHeight || page.getBoundingClientRect().height || parseCssPixelValue(page.style.height) || 1123)
+    );
+    const scale = getDocxFitScale(fit, availableWidth, availableHeight, pageWidth, pageHeight);
     const userZoom = parseCssPixelValue(panel?.style.getPropertyValue("--ofv-office-zoom") || "1") || 1;
     wrapper.style.setProperty("--ofv-docx-scale", formatCssNumber(scale));
     wrapper.style.setProperty("--ofv-docx-page-width", `${pageWidth}px`);
+    wrapper.style.width = `${Math.ceil(pageWidth * scale * userZoom + 48)}px`;
+    wrapper.style.maxWidth = "none";
+    wrapper.style.overflow = "visible";
     for (const { frame, page } of frames) {
-      const pageHeight = page.offsetHeight || page.getBoundingClientRect().height || parseCssPixelValue(page.style.height);
-      if (pageHeight > 0) {
-        frame.style.height = `${Math.ceil(pageHeight * scale * userZoom)}px`;
+      const framePageHeight = page.offsetHeight || page.getBoundingClientRect().height || parseCssPixelValue(page.style.height);
+      const framePageWidth = page.offsetWidth || page.getBoundingClientRect().width || parseCssPixelValue(page.style.width) || pageWidth;
+      frame.style.width = `${Math.ceil(framePageWidth * scale * userZoom)}px`;
+      frame.style.maxWidth = "none";
+      if (framePageHeight > 0) {
+        frame.style.height = `${Math.ceil(framePageHeight * scale * userZoom)}px`;
       }
     }
   };
@@ -7019,6 +8262,26 @@ function fitDocxPages(container) {
     observer.disconnect();
   };
 }
+function getDocxFitScale(fit, availableWidth, availableHeight, pageWidth, pageHeight) {
+  const widthScale = availableWidth / pageWidth;
+  const heightScale = availableHeight ? availableHeight / pageHeight : void 0;
+  if (fit === "actual") {
+    return 1;
+  }
+  if (fit === "height") {
+    return Math.max(0.1, heightScale ?? widthScale);
+  }
+  if (fit === "cover") {
+    return Math.max(0.1, Math.max(widthScale, heightScale ?? widthScale));
+  }
+  if (fit === "scale-down") {
+    return Math.min(1, Math.max(0.1, Math.min(widthScale, heightScale ?? widthScale)));
+  }
+  if (fit === "contain") {
+    return Math.max(0.1, Math.min(widthScale, heightScale ?? widthScale));
+  }
+  return Math.max(0.1, widthScale);
+}
 function ensureDocxPageFrames(wrapper) {
   const pages = Array.from(wrapper.querySelectorAll("section.ofv-docx"));
   return pages.map((page) => {
@@ -7550,9 +8813,9 @@ function parseChartXml(xml, fallbackName) {
     return null;
   }
   const type = detectChartType(doc);
-  const title = textFromFirst(doc, "title") || fallbackName.replace(/\.xml$/i, "");
+  const title = readChartTitle(doc, fallbackName);
   const seriesElements = Array.from(doc.getElementsByTagName("*")).filter((element) => element.localName === "ser");
-  const series = seriesElements.map((element, index) => parseChartSeries(element, index)).filter((item) => item.values.length > 0);
+  const series = seriesElements.map((element, index) => ({ ...parseChartSeries(element, index), color: readChartSeriesColor(element) })).filter((item) => item.values.length > 0);
   if (series.length === 0) {
     return null;
   }
@@ -7561,9 +8824,21 @@ function parseChartXml(xml, fallbackName) {
     type,
     title,
     categories: series.find((item) => item.categories.length > 0)?.categories || [],
-    series: series.map((item) => ({ name: item.name, values: item.values }))
+    series: series.map((item) => ({ name: item.name, values: item.values, color: item.color }))
   };
 }
+function readChartTitle(doc, fallbackName) {
+  const titleElement = Array.from(doc.getElementsByTagName("*")).find((element) => element.localName === "title");
+  if (!titleElement) {
+    return fallbackName.replace(/\.xml$/i, "");
+  }
+  const explicitTitle = chartText(titleElement);
+  if (explicitTitle) {
+    return explicitTitle;
+  }
+  const language = Array.from(doc.getElementsByTagName("*")).find((element) => element.localName === "lang")?.getAttribute("val") || "";
+  return /^zh\b/i.test(language) ? "\u56FE\u8868\u6807\u9898" : "Chart Title";
+}
 function detectChartType(doc) {
   const chartType = Array.from(doc.getElementsByTagName("*")).find(
     (element) => element.localName.endsWith("Chart") && element.localName !== "chart"
@@ -7580,6 +8855,31 @@ function parseChartSeries(element, index) {
     categories: stringsFromFirst(element, "cat")
   };
 }
+function readChartSeriesColor(element) {
+  const shape = Array.from(element?.children || []).find((child) => child.localName === "spPr");
+  const color = Array.from(shape?.getElementsByTagName("*") || []).find(
+    (child) => child.localName === "srgbClr" || child.localName === "schemeClr"
+  );
+  if (!color) {
+    return void 0;
+  }
+  if (color.localName === "srgbClr") {
+    const value = color.getAttribute("val") || "";
+    return /^[\da-f]{6}$/i.test(value) ? `#${value}` : void 0;
+  }
+  return chartSchemeColor(color.getAttribute("val") || "");
+}
+function chartSchemeColor(value) {
+  const colors = {
+    accent1: "#156082",
+    accent2: "#e97132",
+    accent3: "#196b24",
+    accent4: "#0f9ed5",
+    accent5: "#a02b93",
+    accent6: "#4ea72e"
+  };
+  return colors[value];
+}
 function renderChartPreviewSection(charts) {
   const section = createSection("\u8868\u683C\u56FE\u8868\u9884\u89C8");
   const grid = document.createElement("div");
@@ -7617,17 +8917,39 @@ function renderChartCard(chart) {
 }
 function renderChartSvg(chart) {
   const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
-  svg.setAttribute("viewBox", "0 0 640 260");
+  svg.setAttribute("viewBox", "0 0 640 380");
   svg.setAttribute("role", "img");
   svg.setAttribute("aria-label", chart.title);
   svg.classList.add("ofv-chart-svg");
   const allValues = chart.series.flatMap((item) => item.values).filter((value) => Number.isFinite(value));
   const max = Math.max(1, ...allValues);
   const min = Math.min(0, ...allValues);
+  const axisScale = createChartAxisScale(max, min);
+  const axisMax = axisScale.max;
+  const axisMin = axisScale.min;
   const span = max - min || 1;
-  const colors = ["#2563eb", "#059669", "#d97706", "#dc2626", "#7c3aed"];
-  const plot = { x: 48, y: 24, width: 552, height: 178 };
-  appendSvg(svg, "line", { x1: plot.x, y1: plot.y, x2: plot.x, y2: plot.y + plot.height, class: "ofv-chart-axis" });
+  const colors = ["#156082", "#e97132", "#196b24", "#0f9ed5", "#a02b93", "#4ea72e"];
+  const plot = { x: 74, y: 74, width: 526, height: 214 };
+  const categories = chart.categories.length > 0 ? chart.categories : chart.series[0]?.values.map((_, index) => String(index + 1)) || [];
+  const title = appendSvg(svg, "text", { x: 320, y: 34, class: "ofv-chart-title", "text-anchor": "middle" });
+  title.textContent = chart.title;
+  for (const value of axisScale.ticks) {
+    const y = plot.y + plot.height - (value - axisMin) / (axisMax - axisMin || 1) * plot.height;
+    appendSvg(svg, "line", {
+      x1: plot.x,
+      y1: Number(y.toFixed(1)),
+      x2: plot.x + plot.width,
+      y2: Number(y.toFixed(1)),
+      class: value === 0 ? "ofv-chart-axis" : "ofv-chart-gridline"
+    });
+    const label = appendSvg(svg, "text", {
+      x: plot.x - 12,
+      y: Number((y + 4).toFixed(1)),
+      class: "ofv-chart-label",
+      "text-anchor": "end"
+    });
+    label.textContent = formatChartTick(value);
+  }
   appendSvg(svg, "line", {
     x1: plot.x,
     y1: plot.y + plot.height,
@@ -7635,28 +8957,47 @@ function renderChartSvg(chart) {
     y2: plot.y + plot.height,
     class: "ofv-chart-axis"
   });
-  chart.series.forEach((series, seriesIndex) => {
-    const color = colors[seriesIndex % colors.length];
-    const step = series.values.length > 1 ? plot.width / (series.values.length - 1) : plot.width;
-    const points = series.values.map((value, index) => ({
-      x: plot.x + index * step,
-      y: plot.y + plot.height - (value - min) / span * plot.height
-    }));
-    if (chart.type.includes("bar") || chart.type.includes("col")) {
-      const barWidth = Math.max(4, Math.min(28, step * 0.6)) / Math.max(1, chart.series.length);
-      points.forEach((point, index) => {
-        const zeroY = plot.y + plot.height - (0 - min) / span * plot.height;
-        const x = point.x - barWidth * chart.series.length / 2 + seriesIndex * barWidth;
+  if (chart.type.includes("bar") || chart.type.includes("col")) {
+    const categoryCount = Math.max(1, categories.length, ...chart.series.map((series) => series.values.length));
+    const groupWidth = plot.width / categoryCount;
+    const clusterWidth = groupWidth * 0.58;
+    const barWidth = Math.max(5, Math.min(28, clusterWidth / Math.max(1, chart.series.length)));
+    const zeroY = plot.y + plot.height - (0 - axisMin) / (axisMax - axisMin || 1) * plot.height;
+    categories.slice(0, categoryCount).forEach((category, index) => {
+      const x = plot.x + groupWidth * (index + 0.5);
+      const label = appendSvg(svg, "text", {
+        x: Number(x.toFixed(1)),
+        y: plot.y + plot.height + 22,
+        class: "ofv-chart-label",
+        "text-anchor": "middle"
+      });
+      label.textContent = truncateChartLabel(category);
+    });
+    chart.series.forEach((series, seriesIndex) => {
+      const color = series.color || colors[seriesIndex % colors.length];
+      series.values.forEach((value, index) => {
+        const groupCenter = plot.x + groupWidth * (index + 0.5);
+        const x = groupCenter - barWidth * chart.series.length / 2 + seriesIndex * barWidth + barWidth * 0.12;
+        const y = plot.y + plot.height - (value - axisMin) / (axisMax - axisMin || 1) * plot.height;
         appendSvg(svg, "rect", {
-          x,
-          y: Math.min(point.y, zeroY),
-          width: barWidth,
-          height: Math.max(1, Math.abs(zeroY - point.y)),
+          x: Number(x.toFixed(1)),
+          y: Number(Math.min(y, zeroY).toFixed(1)),
+          width: Number((barWidth * 0.76).toFixed(1)),
+          height: Number(Math.max(1, Math.abs(zeroY - y)).toFixed(1)),
           fill: color,
           "data-index": index
         });
       });
-    } else {
+    });
+  } else {
+    chart.series.forEach((series, seriesIndex) => {
+      const color = series.color || colors[seriesIndex % colors.length];
+      const step = series.values.length > 1 ? plot.width / (series.values.length - 1) : plot.width;
+      const lineSpan = axisMax - axisMin || span;
+      const points = series.values.map((value, index) => ({
+        x: plot.x + index * step,
+        y: plot.y + plot.height - (value - axisMin) / lineSpan * plot.height
+      }));
       appendSvg(svg, "polyline", {
         points: points.map((point) => `${point.x.toFixed(1)},${point.y.toFixed(1)}`).join(" "),
         fill: "none",
@@ -7668,11 +9009,49 @@ function renderChartSvg(chart) {
       for (const point of points.slice(0, 80)) {
         appendSvg(svg, "circle", { cx: point.x, cy: point.y, r: 3, fill: color });
       }
-    }
-    appendLegend(svg, series.name, color, 52 + seriesIndex * 118, 236);
-  });
+    });
+  }
+  appendChartLegend(svg, chart, colors, 348);
   return svg;
 }
+function appendChartLegend(svg, chart, colors, y) {
+  const itemWidth = 86;
+  const startX = 320 - chart.series.length * itemWidth / 2;
+  chart.series.forEach((series, seriesIndex) => {
+    const color = series.color || colors[seriesIndex % colors.length];
+    appendLegend(svg, series.name, color, startX + seriesIndex * itemWidth, y);
+  });
+}
+function createChartAxisScale(max, min) {
+  const axisMin = Math.min(0, min);
+  const positiveMax = Math.max(1, max);
+  const step = niceChartStep((positiveMax - axisMin) / 5);
+  let axisMax = Math.ceil(positiveMax / step) * step;
+  if (axisMax <= positiveMax) {
+    axisMax += step;
+  }
+  const ticks = [];
+  for (let value = axisMin; value <= axisMax + step / 2; value += step) {
+    ticks.push(Number(value.toFixed(6)));
+  }
+  return { min: axisMin, max: axisMax, ticks };
+}
+function niceChartStep(rawStep) {
+  if (rawStep <= 0) {
+    return 1;
+  }
+  const magnitude = 10 ** Math.floor(Math.log10(rawStep));
+  const normalized = rawStep / magnitude;
+  const nice = normalized <= 1 ? 1 : normalized <= 2 ? 2 : normalized <= 5 ? 5 : 10;
+  return nice * magnitude;
+}
+function formatChartTick(value) {
+  const rounded = Math.abs(value) < 1 ? Number(value.toFixed(1)) : Number(value.toFixed(0));
+  return String(rounded);
+}
+function truncateChartLabel(value) {
+  return value.length > 10 ? `${value.slice(0, 10)}...` : value;
+}
 function appendLegend(svg, label, color, x, y) {
   appendSvg(svg, "rect", { x, y: y - 10, width: 12, height: 12, rx: 2, fill: color });
   const text = appendSvg(svg, "text", { x: x + 18, y, class: "ofv-chart-label" });
@@ -8406,7 +9785,7 @@ function renderOpenDocumentPresentationXml(panel, xml) {
   renderPresentationInsight(panel, inspectOpenDocumentPresentation("FODP \u6F14\u793A\u6587\u7A3F", xml, 0));
   renderOpenDocumentPresentation(panel, "FODP \u6F14\u793A\u6587\u7A3F", xml, []);
 }
-async function renderPackagedOfficePreview(panel, arrayBuffer, extension) {
+async function renderPackagedOfficePreview(panel, arrayBuffer, extension, fit) {
   let zip;
   try {
     zip = await JSZip3.loadAsync(arrayBuffer);
@@ -8417,7 +9796,7 @@ async function renderPackagedOfficePreview(panel, arrayBuffer, extension) {
   const hasEntry = (path) => entries.some((entry) => entry.name.toLowerCase() === path.toLowerCase());
   const contentXml = zip.file(/(^|\/)content\.xml$/i)[0];
   if (hasEntry("word/document.xml")) {
-    await renderDocx(panel, arrayBuffer);
+    await renderDocx(panel, arrayBuffer, fit);
     return true;
   }
   if (hasEntry("xl/workbook.xml")) {
@@ -8852,6 +10231,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();
@@ -13427,10 +14813,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;
@@ -13465,10 +14851,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;
@@ -13502,13 +14888,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) {
@@ -13533,10 +14919,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;
@@ -13573,10 +14959,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;
@@ -13684,23 +15070,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]) {
@@ -14306,12 +15692,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");
@@ -14351,12 +15737,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) {
@@ -14889,9 +16275,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");
@@ -15004,7 +16390,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");
@@ -17038,10 +18424,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);