@open-file-viewer/core 0.1.4 → 0.1.6

package/dist/index.js

@@ -248,6 +248,9 @@ var extensionMimeMap = {
   skp: "application/vnd.sketchup.skp",
   sldprt: "application/sldworks",
   sldasm: "application/sldworks",
+  gds: "application/vnd.gds",
+  oas: "application/vnd.oasis.layout",
+  oasis: "application/vnd.oasis.layout",
   ttf: "font/ttf",
   otf: "font/otf",
   woff: "font/woff",
@@ -1752,6 +1755,7 @@ function imagePlugin() {
       let dragStartY = 0;
       let startOffsetX = 0;
       let startOffsetY = 0;
+      let activePointerId = null;
       const zoomLabel = document.createElement("span");
       zoomLabel.className = "ofv-image-zoom";
       const updateTransform = () => {
@@ -1799,29 +1803,61 @@ function imagePlugin() {
         if (event.button !== 0) {
           return;
         }
+        if (activePointerId !== null && activePointerId !== event.pointerId) {
+          finishDrag(activePointerId);
+        }
         dragging = true;
+        activePointerId = event.pointerId;
         dragStartX = event.clientX;
         dragStartY = event.clientY;
         startOffsetX = offsetX;
         startOffsetY = offsetY;
         stage.classList.add("is-dragging");
-        stage.setPointerCapture(event.pointerId);
+        try {
+          stage.setPointerCapture(event.pointerId);
+        } catch {
+        }
       };
       const onPointerMove = (event) => {
-        if (!dragging) {
+        if (!dragging || event.pointerId !== activePointerId) {
           return;
         }
         offsetX = startOffsetX + event.clientX - dragStartX;
         offsetY = startOffsetY + event.clientY - dragStartY;
         updateTransform();
       };
-      const onPointerUp = (event) => {
+      const finishDrag = (pointerId) => {
+        const captureId = pointerId ?? activePointerId;
         dragging = false;
+        activePointerId = null;
         stage.classList.remove("is-dragging");
-        if (stage.hasPointerCapture(event.pointerId)) {
-          stage.releasePointerCapture(event.pointerId);
+        if (captureId !== null && captureId !== void 0) {
+          try {
+            if (stage.hasPointerCapture(captureId)) {
+              stage.releasePointerCapture(captureId);
+            }
+          } catch {
+          }
         }
       };
+      const onPointerUp = (event) => {
+        if (event.pointerId === activePointerId) {
+          finishDrag(event.pointerId);
+        }
+      };
+      const onLostPointerCapture = (event) => {
+        if (event.pointerId === activePointerId) {
+          finishDrag(null);
+        }
+      };
+      const onPointerLeave = (event) => {
+        if (event.pointerId === activePointerId && event.buttons === 0) {
+          finishDrag(event.pointerId);
+        }
+      };
+      const onWindowBlur = () => {
+        finishDrag();
+      };
       const onWheel = (event) => {
         if (!event.ctrlKey && !event.metaKey) {
           return;
@@ -1833,8 +1869,11 @@ function imagePlugin() {
       stage.addEventListener("pointermove", onPointerMove);
       stage.addEventListener("pointerup", onPointerUp);
       stage.addEventListener("pointercancel", onPointerUp);
+      stage.addEventListener("lostpointercapture", onLostPointerCapture);
+      stage.addEventListener("pointerleave", onPointerLeave);
       stage.addEventListener("wheel", onWheel, { passive: false });
       image.addEventListener("error", showImageFallback);
+      window.addEventListener("blur", onWindowBlur);
       stage.append(image);
       wrapper.append(...showInlineControls ? [controls, stage, infoBar] : [stage, infoBar]);
       ctx.viewport.append(wrapper);
@@ -1881,8 +1920,12 @@ function imagePlugin() {
           stage.removeEventListener("pointermove", onPointerMove);
           stage.removeEventListener("pointerup", onPointerUp);
           stage.removeEventListener("pointercancel", onPointerUp);
+          stage.removeEventListener("lostpointercapture", onLostPointerCapture);
+          stage.removeEventListener("pointerleave", onPointerLeave);
           stage.removeEventListener("wheel", onWheel);
           image.removeEventListener("error", showImageFallback);
+          window.removeEventListener("blur", onWindowBlur);
+          finishDrag();
           wrapper.remove();
           if (convertedBlob) {
             URL.revokeObjectURL(url);
@@ -3275,6 +3318,95 @@ function readAiffExtended(bytes, offset) {
   return mantissa * Math.pow(2, exponent - 16383 - 63);
 }
 
+// src/plugins/utils.ts
+async function readArrayBuffer(file) {
+  if (file.source instanceof ArrayBuffer) {
+    return file.source;
+  }
+  if (file.blob) {
+    return file.blob.arrayBuffer();
+  }
+  if (typeof file.source === "string") {
+    const response = await fetch(file.source);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch file: ${response.status}`);
+    }
+    return response.arrayBuffer();
+  }
+  throw new Error("Unsupported file source.");
+}
+async function readTextFile(file) {
+  const decode = (buffer) => decodeTextBuffer(buffer);
+  if (typeof file.source === "string") {
+    const response = await fetch(file.source);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch text file: ${response.status}`);
+    }
+    return decode(await response.arrayBuffer());
+  }
+  if (file.blob) {
+    return decode(await file.blob.arrayBuffer());
+  }
+  if (file.source instanceof ArrayBuffer) {
+    return decode(file.source);
+  }
+  return String(file.source);
+}
+function createPanel(className = "") {
+  const panel = document.createElement("div");
+  panel.className = `ofv-panel ${className}`.trim();
+  return panel;
+}
+function createSection(title) {
+  const section = document.createElement("section");
+  section.className = "ofv-section";
+  const heading = document.createElement("h3");
+  heading.textContent = title;
+  section.append(heading);
+  return section;
+}
+function appendMeta(parent, label, value) {
+  const row = document.createElement("div");
+  row.className = "ofv-meta-row";
+  const key = document.createElement("span");
+  key.textContent = label;
+  const content = document.createElement("strong");
+  content.textContent = String(value);
+  row.append(key, content);
+  parent.append(row);
+}
+function decodeTextBuffer(buffer) {
+  return decodeTextBytes(new Uint8Array(buffer));
+}
+function decodeTextBytes(bytes) {
+  if (bytes.length >= 3 && bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191) {
+    return new TextDecoder("utf-8").decode(bytes.subarray(3));
+  }
+  if (bytes.length >= 2) {
+    if (bytes[0] === 255 && bytes[1] === 254) {
+      return new TextDecoder("utf-16le").decode(bytes.subarray(2));
+    }
+    if (bytes[0] === 254 && bytes[1] === 255) {
+      return new TextDecoder("utf-16be").decode(bytes.subarray(2));
+    }
+  }
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    return decodeWithFallback(bytes, "gb18030") || decodeWithFallback(bytes, "gbk") || new TextDecoder("utf-8").decode(bytes);
+  }
+}
+function decodeWithFallback(bytes, encoding) {
+  try {
+    return new TextDecoder(encoding).decode(bytes);
+  } catch {
+    return void 0;
+  }
+}
+function resolveFormat(file, mimeMap) {
+  return file.extension || mimeMap[file.mimeType] || "";
+}
+
 // src/plugins/text.ts
 var langMap = {
   js: "javascript",
@@ -3931,17 +4063,49 @@ async function readText(source) {
     if (!response.ok) {
       throw new Error(`Failed to fetch text file: ${response.status}`);
     }
-    return response.text();
+    return decodeTextBuffer(await response.arrayBuffer());
   }
   if (source instanceof Blob) {
-    return source.text();
+    return decodeTextBuffer(await source.arrayBuffer());
   }
   if (source instanceof ArrayBuffer) {
-    return new TextDecoder().decode(source);
+    return decodeTextBuffer(source);
   }
   return String(source);
 }
 
+// src/plugins/encrypted.ts
+function createEncryptedFallback(file, url, copy = {}) {
+  const fallback = document.createElement("div");
+  fallback.className = "ofv-fallback ofv-encrypted";
+  const title = document.createElement("strong");
+  title.textContent = copy.title || "\u6587\u4EF6\u5DF2\u52A0\u5BC6\uFF0C\u65E0\u6CD5\u5728\u7EBF\u9884\u89C8";
+  const message = document.createElement("span");
+  message.textContent = copy.message || "\u8BF7\u4E0B\u8F7D\u540E\u5728\u672C\u5730\u8F93\u5165\u5BC6\u7801\u6253\u5F00\uFF0C\u6216\u4E0A\u4F20\u89E3\u5BC6\u540E\u7684\u6587\u4EF6\u3002";
+  const meta = document.createElement("dl");
+  meta.className = "ofv-fallback-meta ofv-encrypted-meta";
+  appendEncryptedMeta(meta, "\u6587\u4EF6", file.name || "\u672A\u547D\u540D\u6587\u4EF6");
+  appendEncryptedMeta(meta, "\u683C\u5F0F", file.extension ? `.${file.extension}` : file.mimeType || "\u672A\u77E5");
+  const download = document.createElement("a");
+  download.href = url;
+  download.download = file.name;
+  download.textContent = copy.action || "\u4E0B\u8F7D\u6587\u4EF6";
+  fallback.append(title, message, meta, download);
+  return fallback;
+}
+function isEncryptedError(error) {
+  const message = error instanceof Error ? error.message : String(error || "");
+  const name = typeof error === "object" && error !== null && "name" in error ? String(error.name) : "";
+  return /\b(password|encrypted|encrypt|protected|decrypt|permission|加密|密码|受保护)\b/i.test(`${name} ${message}`);
+}
+function appendEncryptedMeta(parent, label, value) {
+  const key = document.createElement("dt");
+  key.textContent = label;
+  const content = document.createElement("dd");
+  content.textContent = value;
+  parent.append(key, content);
+}
+
 // src/plugins/pdf.ts
 function multiplyMatrices(m1, m2) {
   return [
@@ -3983,7 +4147,11 @@ function pdfPlugin(options = {}) {
       const doc = await documentTask.promise.catch((error) => {
         viewer.remove();
         ctx.viewport.classList.add("ofv-center");
-        const fallback = createPdfFallback(ctx.file.name, url, normalizePdfError(error));
+        const fallback = isEncryptedError(error) ? createEncryptedFallback(ctx.file, url, {
+          title: "PDF \u5DF2\u52A0\u5BC6\uFF0C\u65E0\u6CD5\u5728\u7EBF\u9884\u89C8",
+          message: "\u8BF7\u4E0B\u8F7D\u540E\u4F7F\u7528\u5BC6\u7801\u6253\u5F00\uFF0C\u6216\u4E0A\u4F20\u89E3\u5BC6\u540E\u7684 PDF \u6587\u4EF6\u3002",
+          action: "\u4E0B\u8F7D PDF"
+        }) : createPdfFallback(ctx.file.name, url, normalizePdfError(error));
         ctx.viewport.append(fallback);
         return void 0;
       });
@@ -4273,9 +4441,6 @@ function normalizePdfError(error) {
   const message = error instanceof Error ? error.message : String(error || "");
   const name = typeof error === "object" && error !== null && "name" in error ? String(error.name) : "";
   const lower = `${name} ${message}`.toLowerCase();
-  if (lower.includes("password")) {
-    return "\u8BE5 PDF \u53D7\u5BC6\u7801\u4FDD\u62A4\uFF0C\u5F53\u524D\u65E0\u6CD5\u5728\u6D4F\u89C8\u5668\u5185\u76F4\u63A5\u9884\u89C8\u3002";
-  }
   if (lower.includes("invalid") || lower.includes("missing") || lower.includes("corrupt")) {
     return "\u8BE5 PDF \u6587\u4EF6\u53EF\u80FD\u5DF2\u635F\u574F\u6216\u683C\u5F0F\u65E0\u6548\u3002";
   }
@@ -4294,68 +4459,6 @@ function configurePdfWorker(pdf, workerSrc) {
 // src/plugins/epub.ts
 import JSZip from "jszip";
 import DOMPurify from "dompurify";
-
-// src/plugins/utils.ts
-async function readArrayBuffer(file) {
-  if (file.source instanceof ArrayBuffer) {
-    return file.source;
-  }
-  if (file.blob) {
-    return file.blob.arrayBuffer();
-  }
-  if (typeof file.source === "string") {
-    const response = await fetch(file.source);
-    if (!response.ok) {
-      throw new Error(`Failed to fetch file: ${response.status}`);
-    }
-    return response.arrayBuffer();
-  }
-  throw new Error("Unsupported file source.");
-}
-async function readTextFile(file) {
-  if (typeof file.source === "string") {
-    const response = await fetch(file.source);
-    if (!response.ok) {
-      throw new Error(`Failed to fetch text file: ${response.status}`);
-    }
-    return response.text();
-  }
-  if (file.blob) {
-    return file.blob.text();
-  }
-  if (file.source instanceof ArrayBuffer) {
-    return new TextDecoder().decode(file.source);
-  }
-  return String(file.source);
-}
-function createPanel(className = "") {
-  const panel = document.createElement("div");
-  panel.className = `ofv-panel ${className}`.trim();
-  return panel;
-}
-function createSection(title) {
-  const section = document.createElement("section");
-  section.className = "ofv-section";
-  const heading = document.createElement("h3");
-  heading.textContent = title;
-  section.append(heading);
-  return section;
-}
-function appendMeta(parent, label, value) {
-  const row = document.createElement("div");
-  row.className = "ofv-meta-row";
-  const key = document.createElement("span");
-  key.textContent = label;
-  const content = document.createElement("strong");
-  content.textContent = String(value);
-  row.append(key, content);
-  parent.append(row);
-}
-function resolveFormat(file, mimeMap) {
-  return file.extension || mimeMap[file.mimeType] || "";
-}
-
-// src/plugins/epub.ts
 var epubMimeTypes = /* @__PURE__ */ new Set(["application/epub+zip", "application/x-epub+zip"]);
 function epubPlugin() {
   return {
@@ -4975,8 +5078,15 @@ function officePlugin() {
       ctx.viewport.append(panel);
       const extension = resolveFormat(ctx.file, officeMimeFormatMap);
       const arrayBuffer = await readArrayBuffer(ctx.file);
+      const packageFormat = shouldSniffPackagedOffice(extension) ? await detectPackagedOfficeFormat(arrayBuffer) : void 0;
       let disposeDocxFit;
-      if (fileIsDocx(extension)) {
+      if (packageFormat === "docx" && !fileIsDocx(extension)) {
+        disposeDocxFit = await renderDocx(panel, arrayBuffer);
+      } 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);
       } else if (extension === "rtf") {
         renderPlainDocument(panel, "RTF \u6587\u6863", rtfToText(await readTextFromBuffer(arrayBuffer)));
@@ -5012,12 +5122,32 @@ function officePlugin() {
 function fileIsDocx(extension) {
   return extension === "docx" || extension === "docm" || extension === "dotx" || extension === "dotm";
 }
+function shouldSniffPackagedOffice(extension) {
+  return isLegacyOfficeBinary(extension) || packagedOfficeCandidates.has(extension) || extension === "";
+}
+async function detectPackagedOfficeFormat(arrayBuffer) {
+  try {
+    const zip = await JSZip3.loadAsync(arrayBuffer);
+    const entries = Object.values(zip.files).filter((entry) => !entry.dir);
+    const hasEntry = (path) => entries.some((entry) => entry.name.toLowerCase() === path.toLowerCase());
+    if (hasEntry("word/document.xml")) {
+      return "docx";
+    }
+    if (hasEntry("xl/workbook.xml")) {
+      return "xlsx";
+    }
+    if (hasEntry("ppt/presentation.xml")) {
+      return "pptx";
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
 async function renderDocx(panel, arrayBuffer) {
-  const section = createSection("Word \u6587\u6863");
   const content = document.createElement("div");
   content.className = "ofv-docx-document";
-  section.append(content);
-  panel.append(section);
+  panel.append(content);
   try {
     const docxPreview = await import("docx-preview");
     await docxPreview.renderAsync(arrayBuffer, content, content, {
@@ -5238,7 +5368,7 @@ async function renderSheet(panel, arrayBuffer, extension) {
   const xlsx = await import("xlsx");
   let workbook;
   try {
-    workbook = xlsx.read(arrayBuffer, { type: "array" });
+    workbook = extension === "csv" || extension === "tsv" ? xlsx.read(decodeTextBuffer(arrayBuffer), { type: "string", FS: extension === "tsv" ? "	" : "," }) : xlsx.read(arrayBuffer, { type: "array" });
   } catch (error) {
     if (isLegacyOfficeBinary(extension)) {
       renderLegacyOfficeBinary(panel, extension, arrayBuffer, `\u8868\u683C\u89E3\u6790\u5931\u8D25\uFF1A${normalizeOfficeError(error)}`);
@@ -5340,6 +5470,10 @@ async function renderSheet(panel, arrayBuffer, extension) {
   }
 }
 function renderSheetFallback(panel, extension, detail) {
+  if (isEncryptedText(detail)) {
+    renderEncryptedOfficeByFileInfo(panel, `.${extension || "sheet"}`, "Office \u6587\u4EF6\u5DF2\u52A0\u5BC6\uFF0C\u65E0\u6CD5\u5728\u7EBF\u9884\u89C8");
+    return;
+  }
   const section = createSection("\u8868\u683C\u89E3\u6790\u5931\u8D25");
   const title = document.createElement("p");
   title.textContent = `.${extension || "sheet"} \u6587\u4EF6\u65E0\u6CD5\u89E3\u6790\u4E3A\u53EF\u9884\u89C8\u8868\u683C\u3002`;
@@ -5350,6 +5484,17 @@ function renderSheetFallback(panel, extension, detail) {
   section.append(title, meta, support);
   panel.append(section);
 }
+function renderEncryptedOfficeByFileInfo(panel, fileLabel, title) {
+  const section = createSection(title);
+  section.classList.add("ofv-encrypted");
+  const message = document.createElement("p");
+  message.textContent = `${fileLabel} \u53EF\u80FD\u5DF2\u52A0\u5BC6\u6216\u53D7\u4FDD\u62A4\u3002\u8BF7\u4E0B\u8F7D\u540E\u4F7F\u7528 Office/WPS \u8F93\u5165\u5BC6\u7801\u6253\u5F00\uFF0C\u6216\u4E0A\u4F20\u89E3\u5BC6\u540E\u7684\u6587\u4EF6\u3002`;
+  section.append(message);
+  panel.append(section);
+}
+function isEncryptedText(value) {
+  return /\b(password|encrypted|encrypt|protected|decrypt|permission|加密|密码|受保护)\b/i.test(value);
+}
 function renderFlatOds(panel, xml) {
   const sheets = parseFlatOds(xml);
   renderParsedSheets(panel, sheets, "FODS \u6587\u4EF6\u672A\u89E3\u6790\u5230\u8868\u683C\u3002");
@@ -5871,10 +6016,30 @@ async function renderPptx(panel, arrayBuffer) {
   try {
     const { PptxViewer } = await import("@aiden0z/pptx-renderer");
     await PptxViewer.open(arrayBuffer, container);
+    normalizePptxLayout(container);
   } catch {
     container.textContent = "PPTX \u6E32\u67D3\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u6587\u4EF6\u662F\u5426\u635F\u574F\u3002";
   }
 }
+function normalizePptxLayout(container) {
+  const slideCanvases = findPptxSlideCanvases(container);
+  for (const slide of slideCanvases) {
+    slide.style.backgroundColor = "#FFFFFF";
+  }
+}
+function findPptxSlideCanvases(container) {
+  const slideWrappers = Array.from(container.querySelectorAll("div[data-slide-index]"));
+  const candidates = slideWrappers.flatMap(
+    (wrapper) => Array.from(wrapper.querySelectorAll("div")).filter(isPptxSlideCanvas)
+  );
+  if (candidates.length > 0) {
+    return Array.from(new Set(candidates));
+  }
+  return Array.from(container.querySelectorAll("div")).filter(isPptxSlideCanvas);
+}
+function isPptxSlideCanvas(element) {
+  return element.style.position === "relative" && parseCssPixelValue(element.style.width) > 0 && parseCssPixelValue(element.style.height) > 0;
+}
 async function renderOdp(panel, arrayBuffer) {
   const zip = await JSZip3.loadAsync(arrayBuffer);
   const content = zip.file("content.xml");
@@ -5902,34 +6067,28 @@ 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")) {
-    renderOfficePackageNotice(panel, extension, "\u68C0\u6D4B\u5230 OOXML Word \u5305\u7ED3\u6784\uFF0C\u5DF2\u6309 DOCX \u517C\u5BB9\u8DEF\u5F84\u9884\u89C8\u3002");
     await renderDocx(panel, arrayBuffer);
     return true;
   }
   if (hasEntry("xl/workbook.xml")) {
-    renderOfficePackageNotice(panel, extension, "\u68C0\u6D4B\u5230 OOXML Workbook \u5305\u7ED3\u6784\uFF0C\u5DF2\u6309 XLSX \u517C\u5BB9\u8DEF\u5F84\u9884\u89C8\u3002");
     await renderSheet(panel, arrayBuffer, extension);
     return true;
   }
   if (hasEntry("ppt/presentation.xml")) {
-    renderOfficePackageNotice(panel, extension, "\u68C0\u6D4B\u5230 OOXML Presentation \u5305\u7ED3\u6784\uFF0C\u5DF2\u6309 PPTX \u517C\u5BB9\u8DEF\u5F84\u9884\u89C8\u3002");
     await renderPptx(panel, arrayBuffer);
     return true;
   }
   if (contentXml) {
     const xml = await contentXml.async("text");
     if (/<office:spreadsheet\b|<table:table\b/i.test(xml)) {
-      renderOfficePackageNotice(panel, extension, "\u68C0\u6D4B\u5230 OpenDocument Spreadsheet \u5305\u7ED3\u6784\uFF0C\u5DF2\u6309 ODS \u517C\u5BB9\u8DEF\u5F84\u9884\u89C8\u3002");
       renderParsedSheets(panel, parseFlatOds(xml), `${extension.toUpperCase()} \u6587\u4EF6\u672A\u89E3\u6790\u5230\u8868\u683C\u3002`);
       return true;
     }
     if (/<office:presentation\b|<draw:page\b/i.test(xml)) {
-      renderOfficePackageNotice(panel, extension, "\u68C0\u6D4B\u5230 OpenDocument Presentation \u5305\u7ED3\u6784\uFF0C\u5DF2\u6309 ODP \u517C\u5BB9\u8DEF\u5F84\u9884\u89C8\u3002");
       renderOpenDocumentPresentation(panel, `${extension.toUpperCase()} \u6F14\u793A\u6587\u7A3F`, xml, await extractZipImages(zip, /^Pictures\//));
       return true;
     }
     if (/<office:text\b|<text:p\b/i.test(xml)) {
-      renderOfficePackageNotice(panel, extension, "\u68C0\u6D4B\u5230 OpenDocument Text \u5305\u7ED3\u6784\uFF0C\u5DF2\u6309 ODT \u517C\u5BB9\u8DEF\u5F84\u9884\u89C8\u3002");
       renderOpenDocumentXml(panel, `${extension.toUpperCase()} \u6587\u6863`, xml);
       return true;
     }
@@ -5955,14 +6114,6 @@ async function renderPackagedOfficePreview(panel, arrayBuffer, extension) {
   }
   return false;
 }
-function renderOfficePackageNotice(panel, extension, message) {
-  const section = createSection("\u517C\u5BB9\u5305\u8BC6\u522B");
-  const note = document.createElement("p");
-  note.className = "ofv-office-package-note";
-  note.textContent = `.${extension} ${message}`;
-  section.append(note);
-  panel.append(section);
-}
 function renderOfficePackageStructure(panel, extension, entries, message, metadata) {
   const section = createSection("Office \u5305\u7ED3\u6784\u9884\u89C8");
   const note = document.createElement("p");
@@ -6610,7 +6761,7 @@ function rtfToText(rtf) {
   return rtf.replace(/\\'[0-9a-fA-F]{2}/g, "").replace(/\\par[d]?/g, "\n").replace(/\\tab/g, "	").replace(/\\[a-zA-Z]+\d* ?/g, "").replace(/[{}]/g, "").replace(/\n{3,}/g, "\n\n").trim();
 }
 async function readTextFromBuffer(arrayBuffer) {
-  return new TextDecoder("utf-8", { fatal: false }).decode(arrayBuffer);
+  return decodeTextBuffer(arrayBuffer);
 }
 function mimeTypeFromPath(path) {
   const extension = path.split(".").pop()?.toLowerCase();
@@ -6652,7 +6803,7 @@ function ofdPlugin() {
       try {
         zip = await JSZip4.loadAsync(await readArrayBuffer(ctx.file));
       } catch (error) {
-        panel.append(createOfdFallback(ctx.file.name, url, normalizeOfdError(error)));
+        panel.append(createOfdFailure(ctx.file, url, error));
         return {
           destroy() {
             panel.remove();
@@ -6669,7 +6820,7 @@ function ofdPlugin() {
           textFragments.push(...matches);
         }
       } catch (error) {
-        panel.append(createOfdFallback(ctx.file.name, url, normalizeOfdError(error)));
+        panel.append(createOfdFailure(ctx.file, url, error));
         return {
           destroy() {
             panel.remove();
@@ -6677,36 +6828,72 @@ function ofdPlugin() {
           }
         };
       }
-      const images = await readOfdImages(entries);
-      const pages = await readOfdPages(entries, images);
-      const section = createSection("OFD \u57FA\u7840\u9884\u89C8");
-      const note = document.createElement("p");
-      note.textContent = pages.length > 0 ? "\u5F53\u524D\u7248\u672C\u63D0\u53D6 OFD \u9875\u9762\u6587\u672C\u3001\u8DEF\u5F84\u3001\u76F4\u7EBF\u548C\u56FE\u7247\u5BF9\u8C61\uFF0C\u5E76\u6309 Boundary \u5750\u6807\u751F\u6210\u8F7B\u91CF SVG \u7248\u5F0F\u9884\u89C8\u3002\u590D\u6742\u5B57\u4F53\u3001\u7B7E\u7AE0\u548C\u989C\u8272\u7A7A\u95F4\u53EF\u540E\u7EED\u63A5\u5165\u4E13\u7528 OFD \u6E32\u67D3\u5668\u3002" : "\u5F53\u524D\u7248\u672C\u63D0\u53D6 OFD \u5305\u5185 XML \u6587\u672C\u548C\u6587\u4EF6\u7ED3\u6784\u3002\u7248\u5F0F\u7EA7\u6E32\u67D3\u53EF\u5728\u540E\u7EED\u63A5\u5165\u4E13\u7528 OFD \u6E32\u67D3\u5668\u3002";
-      section.append(note);
-      section.append(createOfdSummary(entries, pages, images));
+      const context = await readOfdContext(entries);
+      const pages = await readOfdPages(entries, context);
+      let zoom = 1;
+      let rotation = 0;
+      const applyZoom = () => {
+        panel.style.setProperty("--ofv-ofd-zoom", formatOfdCssNumber(zoom));
+        ctx.toolbar?.setZoom(zoom);
+      };
+      const applyRotation = () => {
+        const normalizedRotation = (rotation % 360 + 360) % 360;
+        panel.style.setProperty("--ofv-ofd-rotation", `${normalizedRotation}deg`);
+        panel.classList.toggle("is-ofd-rotated-sideways", normalizedRotation === 90 || normalizedRotation === 270);
+      };
       if (pages.length > 0) {
         const pagesWrap = document.createElement("div");
         pagesWrap.className = "ofv-ofd-pages";
         for (const page of pages) {
           pagesWrap.append(renderOfdPage(page));
         }
-        section.append(pagesWrap);
-      }
-      const content = document.createElement("pre");
-      content.className = "ofv-text-block";
-      content.textContent = textFragments.slice(0, 300).join("\n") || "\u672A\u63D0\u53D6\u5230\u53EF\u8BFB\u6587\u672C\u3002";
-      section.append(content);
-      const list = createSection(`\u6587\u4EF6\u7ED3\u6784 ${entries.length}`);
-      const ul = document.createElement("ul");
-      for (const entry of entries.slice(0, 200)) {
-        const li = document.createElement("li");
-        li.textContent = entry.name;
-        ul.append(li);
-      }
-      list.append(ul);
-      panel.append(section, list);
+        panel.append(pagesWrap);
+        applyZoom();
+        applyRotation();
+      }
+      if (pages.length === 0) {
+        const content = document.createElement("pre");
+        content.className = "ofv-text-block";
+        content.textContent = textFragments.slice(0, 300).join("\n") || "\u672A\u63D0\u53D6\u5230\u53EF\u8BFB\u6587\u672C\u3002";
+        panel.append(content);
+      }
       return {
+        canCommand(command) {
+          return pages.length > 0 && (command === "zoom-in" || command === "zoom-out" || command === "zoom-reset" || command === "rotate-right" || command === "rotate-left");
+        },
+        command(command) {
+          if (pages.length === 0) {
+            return false;
+          }
+          if (command === "zoom-in") {
+            zoom = Math.min(4, zoom + 0.15);
+            applyZoom();
+            return true;
+          }
+          if (command === "zoom-out") {
+            zoom = Math.max(0.25, zoom - 0.15);
+            applyZoom();
+            return true;
+          }
+          if (command === "zoom-reset") {
+            zoom = 1;
+            applyZoom();
+            return true;
+          }
+          if (command === "rotate-right") {
+            rotation += 90;
+            applyRotation();
+            return true;
+          }
+          if (command === "rotate-left") {
+            rotation -= 90;
+            applyRotation();
+            return true;
+          }
+          return false;
+        },
         destroy() {
+          ctx.toolbar?.setZoom(void 0);
           panel.remove();
           revokeObjectUrl(url, isExternal);
         }
@@ -6714,76 +6901,71 @@ function ofdPlugin() {
     }
   };
 }
-function createOfdSummary(entries, pages, images) {
-  const summary = document.createElement("div");
-  summary.className = "ofv-ofd-summary";
-  const xmlEntries = entries.filter((entry) => entry.name.endsWith(".xml")).length;
-  const textCount = pages.reduce((count, page) => count + page.texts.length, 0);
-  const pathCount = pages.reduce((count, page) => count + page.paths.length, 0);
-  const lineCount = pages.reduce((count, page) => count + page.lines.length, 0);
-  const imageCount = pages.reduce((count, page) => count + page.images.length, 0);
-  const textLength = pages.reduce((count, page) => count + page.texts.reduce((inner, item) => inner + item.text.length, 0), 0);
-  appendOfdSummary(summary, "\u6587\u4EF6", String(entries.length));
-  appendOfdSummary(summary, "XML", String(xmlEntries));
-  appendOfdSummary(summary, "\u9875\u9762", String(pages.length));
-  appendOfdSummary(summary, "\u6587\u672C", String(textCount));
-  appendOfdSummary(summary, "\u8DEF\u5F84", String(pathCount));
-  appendOfdSummary(summary, "\u7EBF\u6761", String(lineCount));
-  appendOfdSummary(summary, "\u56FE\u7247\u5BF9\u8C61", String(imageCount));
-  appendOfdSummary(summary, "\u56FE\u7247\u8D44\u6E90", String(uniqueOfdImageResources(images)));
-  if (textLength > 0) {
-    appendOfdSummary(summary, "\u6587\u5B57\u957F\u5EA6", String(textLength));
-  }
-  const sizes = formatOfdPageSizes(pages);
-  if (sizes) {
-    appendOfdSummary(summary, "\u9875\u9762\u5C3A\u5BF8", sizes);
-  }
-  return summary;
-}
-function appendOfdSummary(parent, label, value) {
-  const item = document.createElement("span");
-  const key = document.createElement("span");
-  key.textContent = label;
-  const content = document.createElement("strong");
-  content.textContent = value;
-  item.append(key, content);
-  parent.append(item);
-}
-function uniqueOfdImageResources(images) {
-  return new Set(images.values()).size;
-}
-function formatOfdPageSizes(pages) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const page of pages) {
-    const key = `${Math.round(page.width)} x ${Math.round(page.height)}`;
-    counts.set(key, (counts.get(key) || 0) + 1);
-  }
-  return [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 4).map(([size, count]) => count > 1 ? `${size} (${count})` : size).join(", ");
-}
-async function readOfdPages(entries, images) {
+async function readOfdPages(entries, context) {
   const pages = [];
   const pageEntries = entries.filter((entry) => /(^|\/)Pages\/Page_[^/]+\/Content\.xml$/i.test(entry.name) || /(^|\/)Page_[^/]+\/Content\.xml$/i.test(entry.name)).slice(0, 80);
   for (const entry of pageEntries) {
     const xml = await entry.async("text");
-    const page = parseOfdPage(entry.name, xml, images);
+    const templates = await readPageTemplates(xml, context, entries);
+    const page = parseOfdPage(entry.name, xml, context.images, context.fonts, templates, context.pageSize);
     if (page.texts.length > 0 || page.paths.length > 0 || page.lines.length > 0 || page.images.length > 0) {
       pages.push(page);
     }
   }
   return pages;
 }
-function parseOfdPage(name, xml, images) {
+async function readPageTemplates(xml, context, entries) {
+  const doc = new DOMParser().parseFromString(xml, "application/xml");
+  if (doc.querySelector("parsererror")) {
+    return [];
+  }
+  const templateIds = Array.from(doc.getElementsByTagName("*")).filter((element) => element.localName === "Template").map((element) => getOfdAttribute(element, "TemplateID") || getOfdAttribute(element, "ID")).filter((id) => Boolean(id));
+  const templates = [];
+  for (const id of templateIds) {
+    const path = context.templates.get(id);
+    const entry = path ? findOfdEntry(entries, path) : void 0;
+    if (entry) {
+      templates.push(await entry.async("text"));
+    }
+  }
+  return templates;
+}
+function parseOfdPage(name, xml, images, fonts, templateXmls = [], defaultPageSize) {
   const doc = new DOMParser().parseFromString(xml, "application/xml");
   if (doc.querySelector("parsererror")) {
     return { name, width: 210, height: 297, texts: [], paths: [], lines: [], images: [] };
   }
-  const pageSize = parseOfdPageSize(doc);
-  const textObjects = Array.from(doc.getElementsByTagName("*")).filter((element) => element.localName === "TextObject");
-  const texts = textObjects.flatMap((element) => parseOfdTextObject(element));
-  const paths = Array.from(doc.getElementsByTagName("*")).filter((element) => element.localName === "PathObject").flatMap((element) => parseOfdPathObject(element));
+  const pageSize = parseOfdPageSize(doc, defaultPageSize);
+  const templatePages = templateXmls.map((templateXml) => {
+    const templateDoc = new DOMParser().parseFromString(templateXml, "application/xml");
+    return templateDoc.querySelector("parsererror") ? emptyOfdPageContent() : parseOfdPageContent(templateDoc, images, fonts);
+  });
+  const pageContent = parseOfdPageContent(doc, images, fonts);
+  const texts = [...templatePages.flatMap((page) => page.texts), ...pageContent.texts];
+  const paths = [...templatePages.flatMap((page) => page.paths), ...pageContent.paths];
+  const lines = [...templatePages.flatMap((page) => page.lines), ...pageContent.lines];
+  const imageObjects = [...templatePages.flatMap((page) => page.images), ...pageContent.images];
+  if (pageSize.explicit) {
+    return { name, width: pageSize.width, height: pageSize.height, texts, paths, lines, images: imageObjects };
+  }
+  const bounds = createOfdBounds(texts, paths, lines, imageObjects);
+  const width = Math.max(pageSize.width, ...bounds.map((item) => item.x + item.width + 12));
+  const height = Math.max(pageSize.height, ...bounds.map((item) => item.y + item.height + 12));
+  return { name, width, height, texts, paths, lines, images: imageObjects };
+}
+function parseOfdPageContent(doc, images, fonts) {
+  const textObjects = Array.from(doc.getElementsByTagName("*")).filter((element) => element.localName === "TextObject");
+  const texts = textObjects.flatMap((element) => parseOfdTextObject(element, fonts));
+  const paths = Array.from(doc.getElementsByTagName("*")).filter((element) => element.localName === "PathObject").flatMap((element) => parseOfdPathObject(element));
   const lines = Array.from(doc.getElementsByTagName("*")).filter((element) => element.localName === "LineObject").flatMap((element) => parseOfdLineObject(element));
   const imageObjects = Array.from(doc.getElementsByTagName("*")).filter((element) => element.localName === "ImageObject").flatMap((element) => parseOfdImageObject(element, images));
-  const bounds = [
+  return { texts, paths, lines, images: imageObjects };
+}
+function emptyOfdPageContent() {
+  return { texts: [], paths: [], lines: [], images: [] };
+}
+function createOfdBounds(texts, paths, lines, imageObjects) {
+  return [
     ...texts.map((item) => ({ x: item.x, y: item.y, width: item.width, height: item.height })),
     ...paths.map((item) => ({ x: item.x, y: item.y, width: item.width, height: item.height })),
     ...lines.map((item) => ({
@@ -6794,38 +6976,63 @@ function parseOfdPage(name, xml, images) {
     })),
     ...imageObjects.map((item) => ({ x: item.x, y: item.y, width: item.width, height: item.height }))
   ];
-  const width = Math.max(pageSize.width, ...bounds.map((item) => item.x + item.width + 12));
-  const height = Math.max(pageSize.height, ...bounds.map((item) => item.y + item.height + 12));
-  return { name, width, height, texts, paths, lines, images: imageObjects };
 }
-function parseOfdTextObject(element) {
+function parseOfdTextObject(element, fonts) {
   const boundary = parseBoundary(getOfdAttribute(element, "Boundary"));
   const size = finiteNumber2(getOfdAttribute(element, "Size"), Math.max(4, boundary.height || 5));
   const color = parseOfdColor(element, "#111827");
   const weight = finiteNumber2(getOfdAttribute(element, "Weight"), 400) >= 600 ? "700" : "400";
-  const letterSpacing = getOfdAttribute(element, "DeltaX") ? 0.5 : void 0;
+  const fontFamily = fontStackForOfdFont(fonts.get(getOfdAttribute(element, "Font") || ""));
+  const objectLetterSpacing = getOfdAttribute(element, "DeltaX") ? 0.5 : void 0;
   const textCodes = Array.from(element.getElementsByTagName("*")).filter((child) => child.localName === "TextCode");
   if (textCodes.length === 0) {
     return [];
   }
-  return textCodes.map((code) => {
+  return textCodes.flatMap((code) => {
     const x = boundary.x + finiteNumber2(getOfdAttribute(code, "X"), 0);
     const y = boundary.y + finiteNumber2(getOfdAttribute(code, "Y"), 0);
-    return {
-      text: code.textContent?.trim() || "",
-      x,
-      y,
-      width: boundary.width,
-      height: boundary.height,
-      size,
-      color,
-      weight,
-      letterSpacing
-    };
+    const text = code.textContent?.trim() || "";
+    const deltaX = parseOfdDeltaX(getOfdAttribute(code, "DeltaX"));
+    const align = deltaX ? "start" : inferOfdTextAlign(text, boundary);
+    const deltaY = getOfdAttribute(code, "DeltaY");
+    if (deltaY && text.length > 1) {
+      const step = parseOfdDeltaStep(deltaY, size);
+      return Array.from(text).map((char, index) => ({
+        text: char,
+        x,
+        y: y + index * step,
+        width: boundary.width,
+        height: boundary.height,
+        size,
+        color,
+        weight,
+        fontFamily,
+        letterSpacing: objectLetterSpacing,
+        vertical: true,
+        align
+      }));
+    }
+    return [
+      {
+        text,
+        x,
+        y,
+        width: boundary.width,
+        height: boundary.height,
+        size,
+        color,
+        weight,
+        fontFamily,
+        letterSpacing: deltaX ? void 0 : objectLetterSpacing,
+        deltaX,
+        align
+      }
+    ];
   }).filter((item) => item.text);
 }
 function parseOfdPathObject(element) {
   const boundary = parseBoundary(getOfdAttribute(element, "Boundary"));
+  const ctm = parseOfdCtm(getOfdAttribute(element, "CTM"));
   const commands = Array.from(element.getElementsByTagName("*")).filter(
     (child) => child.localName === "AbbreviatedData" || child.localName === "PathData"
   );
@@ -6840,9 +7047,10 @@ function parseOfdPathObject(element) {
       y: boundary.y,
       width: boundary.width,
       height: boundary.height,
-      stroke: parseOfdColor(element, "#334155", "StrokeColor"),
+      stroke: parseOfdColor(element, "#111827", "StrokeColor"),
       fill: parseOfdFill(element),
-      strokeWidth: finiteNumber2(getOfdAttribute(element, "LineWidth"), 1)
+      strokeWidth: finiteNumber2(getOfdAttribute(element, "LineWidth"), 1),
+      transform: createOfdPathTransform(boundary.x, boundary.y, ctm)
     }
   ];
 }
@@ -6859,7 +7067,7 @@ function parseOfdLineObject(element) {
       y1: boundary.y + start.y,
       x2: boundary.x + end.x,
       y2: boundary.y + end.y,
-      stroke: parseOfdColor(element, "#334155"),
+      stroke: parseOfdColor(element, "#111827"),
       strokeWidth: finiteNumber2(getOfdAttribute(element, "LineWidth"), 1)
     }
   ];
@@ -6881,6 +7089,8 @@ function parseOfdImageObject(element, images) {
 function renderOfdPage(page) {
   const figure = document.createElement("figure");
   figure.className = "ofv-ofd-page";
+  figure.style.setProperty("--ofv-ofd-page-width", `${formatOfdCssNumber(page.width)}mm`);
+  figure.style.setProperty("--ofv-ofd-page-height", `${formatOfdCssNumber(page.height)}mm`);
   const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
   svg.setAttribute("viewBox", `0 0 ${page.width} ${page.height}`);
   svg.setAttribute("role", "img");
@@ -6917,7 +7127,7 @@ function renderOfdPage(page) {
   for (const item of page.paths) {
     const path = document.createElementNS(svg.namespaceURI, "path");
     path.setAttribute("d", item.d);
-    path.setAttribute("transform", `translate(${item.x} ${item.y})`);
+    path.setAttribute("transform", item.transform);
     path.setAttribute("fill", item.fill);
     path.setAttribute("stroke", item.stroke);
     path.setAttribute("stroke-width", String(item.strokeWidth));
@@ -6936,22 +7146,63 @@ function renderOfdPage(page) {
   }
   for (const item of page.texts) {
     const text = document.createElementNS(svg.namespaceURI, "text");
-    text.setAttribute("x", String(item.x));
-    text.setAttribute("y", String(item.y + item.size));
+    text.setAttribute("x", String(item.align === "end" ? item.x + item.width : item.x));
+    text.setAttribute("y", String(item.y));
     text.setAttribute("font-size", String(item.size));
     text.setAttribute("fill", item.color);
     text.setAttribute("font-weight", item.weight);
+    text.setAttribute("font-family", item.fontFamily);
     if (item.letterSpacing !== void 0) {
       text.setAttribute("letter-spacing", String(item.letterSpacing));
     }
-    text.textContent = item.text;
+    if (item.deltaX && item.deltaX.length > 0 && item.align !== "end") {
+      const chars = Array.from(item.text);
+      let x = item.x;
+      for (let index = 0; index < chars.length; index += 1) {
+        const span = document.createElementNS(svg.namespaceURI, "tspan");
+        span.setAttribute("x", String(x));
+        span.setAttribute("y", String(item.y));
+        if (index < chars.length - 1) {
+          x += item.deltaX[Math.min(index, item.deltaX.length - 1)] || item.size;
+        }
+        span.textContent = chars[index];
+        text.append(span);
+      }
+    } else {
+      if (item.align === "end") {
+        text.setAttribute("text-anchor", "end");
+      }
+      text.textContent = item.text;
+    }
     svg.append(text);
   }
-  const caption = document.createElement("figcaption");
-  caption.textContent = `${page.name} \xB7 ${page.texts.length} text \xB7 ${page.paths.length} path \xB7 ${page.lines.length} line \xB7 ${page.images.length} image`;
-  figure.append(svg, caption);
+  figure.append(svg);
   return figure;
 }
+async function readOfdContext(entries) {
+  const images = await readOfdImages(entries);
+  const fonts = await readOfdFonts(entries);
+  const { templates, pageSize } = await readOfdDocumentInfo(entries);
+  return { images, templates, fonts, pageSize };
+}
+async function readOfdFonts(entries) {
+  const fonts = /* @__PURE__ */ new Map();
+  for (const entry of entries.filter((item) => /(?:^|\/)(?:DocumentRes|PublicRes)\.xml$/i.test(item.name))) {
+    const xml = await entry.async("text");
+    const doc = new DOMParser().parseFromString(xml, "application/xml");
+    if (doc.querySelector("parsererror")) {
+      continue;
+    }
+    for (const font of Array.from(doc.getElementsByTagName("*")).filter((element) => element.localName === "Font")) {
+      const id = getOfdAttribute(font, "ID");
+      const name = getOfdAttribute(font, "FontName") || getOfdAttribute(font, "FamilyName");
+      if (id && name) {
+        fonts.set(id, name.trim());
+      }
+    }
+  }
+  return fonts;
+}
 async function readOfdImages(entries) {
   const images = /* @__PURE__ */ new Map();
   for (const entry of entries.filter((item) => /\.(?:png|jpe?g|gif|bmp|webp)$/i.test(item.name)).slice(0, 80)) {
@@ -6966,17 +7217,69 @@ async function readOfdImages(entries) {
     images.set(entry.name, href);
     images.set(entry.name.split("/").pop() || entry.name, href);
   }
+  for (const entry of entries.filter((item) => /(?:^|\/)(?:DocumentRes|PublicRes)\.xml$/i.test(item.name))) {
+    const xml = await entry.async("text");
+    const doc = new DOMParser().parseFromString(xml, "application/xml");
+    if (doc.querySelector("parsererror")) {
+      continue;
+    }
+    const baseLoc = getOfdAttribute(doc.documentElement, "BaseLoc") || "";
+    const resourceDir = joinOfdPath(directoryName2(entry.name), baseLoc);
+    for (const media of Array.from(doc.getElementsByTagName("*")).filter((element) => element.localName === "MultiMedia")) {
+      const id = getOfdAttribute(media, "ID");
+      const mediaFile = findOfdChild(media, "MediaFile")?.textContent?.trim();
+      if (!id || !mediaFile) {
+        continue;
+      }
+      const imageEntry = findOfdEntry(entries, joinOfdPath(resourceDir, mediaFile)) || findOfdEntry(entries, mediaFile);
+      const href = imageEntry ? images.get(imageEntry.name) || images.get(imageEntry.name.split("/").pop() || imageEntry.name) : void 0;
+      if (href) {
+        images.set(id, href);
+      }
+    }
+  }
   return images;
 }
-function parseOfdPageSize(doc) {
+async function readOfdDocumentInfo(entries) {
+  const templates = /* @__PURE__ */ new Map();
+  let pageSize;
+  for (const entry of entries.filter((item) => /(?:^|\/)Document\.xml$/i.test(item.name))) {
+    const xml = await entry.async("text");
+    const doc = new DOMParser().parseFromString(xml, "application/xml");
+    if (doc.querySelector("parsererror")) {
+      continue;
+    }
+    const documentDir = directoryName2(entry.name);
+    const physicalBox = Array.from(doc.getElementsByTagName("*")).find((element) => element.localName === "PageArea")?.getElementsByTagName("*");
+    const pageAreaBox = physicalBox ? Array.from(physicalBox).find((element) => element.localName === "PhysicalBox") : void 0;
+    if (pageAreaBox?.textContent) {
+      const box = parseBoundary(pageAreaBox.textContent);
+      if (box.width > 0 && box.height > 0) {
+        pageSize = { width: box.width, height: box.height };
+      }
+    }
+    for (const template of Array.from(doc.getElementsByTagName("*")).filter((element) => element.localName === "TemplatePage")) {
+      const id = getOfdAttribute(template, "ID");
+      const baseLoc = getOfdAttribute(template, "BaseLoc");
+      if (id && baseLoc) {
+        templates.set(id, joinOfdPath(documentDir, baseLoc));
+      }
+    }
+  }
+  return { templates, pageSize };
+}
+function parseOfdPageSize(doc, defaultPageSize) {
+  if (defaultPageSize) {
+    return { ...defaultPageSize, explicit: true };
+  }
   const physicalBox = Array.from(doc.getElementsByTagName("*")).find((element) => element.localName === "PhysicalBox");
   if (physicalBox?.textContent) {
     const box = parseBoundary(physicalBox.textContent);
     if (box.width > 0 && box.height > 0) {
-      return { width: box.width, height: box.height };
+      return { width: box.width, height: box.height, explicit: true };
     }
   }
-  return { width: 210, height: 297 };
+  return { width: 210, height: 297, explicit: false };
 }
 function parseOfdColor(element, fallback, preferredLocalName = "FillColor") {
   const colorElement = findOfdChild(element, preferredLocalName) || findOfdChild(element, "StrokeColor") || findOfdChild(element, "FillColor");
@@ -7007,6 +7310,101 @@ function parsePoint(value, fallback) {
 function normalizeOfdPathData(value) {
   return value.replace(/\bM\s+/gi, "M ").replace(/\bL\s+/gi, "L ").replace(/\bC\s+/gi, "C ").replace(/\bQ\s+/gi, "Q ").replace(/\bA\s+/gi, "A ").replace(/\bB\s+/gi, "C ").replace(/\bZ\b/gi, "Z").replace(/\s+/g, " ").trim();
 }
+function parseOfdCtm(value) {
+  const parts = (value || "").trim().split(/\s+/).map((part) => Number(part));
+  if (parts.length !== 6 || parts.some((part) => !Number.isFinite(part))) {
+    return void 0;
+  }
+  return parts;
+}
+function createOfdPathTransform(x, y, ctm) {
+  if (!ctm) {
+    return `translate(${x} ${y})`;
+  }
+  const [a, b, c, d, e, f] = ctm;
+  return `translate(${x} ${y}) matrix(${a} ${b} ${c} ${d} ${e} ${f})`;
+}
+function parseOfdDeltaStep(value, fallback) {
+  const numbers = value.match(/-?\d+(?:\.\d+)?/g)?.map((part) => Number(part)).filter((part) => Number.isFinite(part)) || [];
+  return numbers.length > 0 ? numbers[numbers.length - 1] : fallback;
+}
+function parseOfdDeltaX(value) {
+  if (!value) {
+    return void 0;
+  }
+  const parts = value.match(/[a-z]+|-?\d+(?:\.\d+)?/gi) || [];
+  const deltas = [];
+  for (let index = 0; index < parts.length; index += 1) {
+    const token = parts[index];
+    if (/^g$/i.test(token)) {
+      const count = Number(parts[index + 1]);
+      const step = Number(parts[index + 2]);
+      if (Number.isFinite(count) && Number.isFinite(step)) {
+        deltas.push(...Array.from({ length: Math.max(0, Math.floor(count)) }, () => step));
+      }
+      index += 2;
+      continue;
+    }
+    const numeric = Number(token);
+    if (Number.isFinite(numeric)) {
+      deltas.push(numeric);
+    }
+  }
+  return deltas.length > 0 ? deltas : void 0;
+}
+function fontStackForOfdFont(fontName) {
+  const normalized = (fontName || "").trim().toLowerCase();
+  if (normalized.includes("courier")) {
+    return '"Courier New", Courier, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace';
+  }
+  if (normalized.includes("kaiti") || normalized.includes("kai") || normalized.includes("\u6977")) {
+    return '"STKaiti", "Kaiti SC", "KaiTi", "\u6977\u4F53", serif';
+  }
+  if (normalized.includes("simsun") || normalized.includes("simsong") || normalized.includes("song") || normalized.includes("\u5B8B")) {
+    return '"SimSong", "Songti SC", "STSong", SimSun, "\u5B8B\u4F53", serif';
+  }
+  if (normalized.includes("hei") || normalized.includes("\u9ED1")) {
+    return '"PingFang SC", "Microsoft YaHei", SimHei, sans-serif';
+  }
+  return '"SimSong", "Songti SC", "STSong", SimSun, "Noto Serif CJK SC", serif';
+}
+function inferOfdTextAlign(text, boundary) {
+  const normalized = text.trim();
+  if (!/^[¥￥]?\d+(?:\.\d+)?%?$/.test(normalized)) {
+    return "start";
+  }
+  if (boundary.x >= 75 || boundary.width <= 30) {
+    return "end";
+  }
+  return "start";
+}
+function findOfdEntry(entries, path) {
+  const normalized = normalizeOfdPath(path);
+  return entries.find((entry) => normalizeOfdPath(entry.name) === normalized || normalizeOfdPath(entry.name).endsWith(`/${normalized}`));
+}
+function joinOfdPath(...parts) {
+  const joined = parts.filter(Boolean).join("/");
+  const segments = [];
+  for (const segment of joined.split("/")) {
+    if (!segment || segment === ".") {
+      continue;
+    }
+    if (segment === "..") {
+      segments.pop();
+      continue;
+    }
+    segments.push(segment);
+  }
+  return segments.join("/");
+}
+function directoryName2(path) {
+  const normalized = normalizeOfdPath(path);
+  const index = normalized.lastIndexOf("/");
+  return index >= 0 ? normalized.slice(0, index) : "";
+}
+function normalizeOfdPath(path) {
+  return path.replace(/\\/g, "/").replace(/^\/+/, "").replace(/\/+/g, "/");
+}
 function mimeTypeFromPath2(path) {
   const extension = path.split(".").pop()?.toLowerCase();
   const map = {
@@ -7044,6 +7442,19 @@ function finiteNumber2(value, fallback) {
   const parsed = value === null ? Number.NaN : Number(value);
   return Number.isFinite(parsed) ? parsed : fallback;
 }
+function formatOfdCssNumber(value) {
+  return Number.isInteger(value) ? String(value) : value.toFixed(3).replace(/0+$/, "").replace(/\.$/, "");
+}
+function createOfdFailure(file, url, error) {
+  if (isEncryptedError(error)) {
+    return createEncryptedFallback(file, url, {
+      title: "OFD \u6587\u4EF6\u5DF2\u52A0\u5BC6\uFF0C\u65E0\u6CD5\u5728\u7EBF\u9884\u89C8",
+      message: "\u8BF7\u4E0B\u8F7D\u540E\u4F7F\u7528\u672C\u5730 OFD \u9605\u8BFB\u5668\u8F93\u5165\u5BC6\u7801\u6253\u5F00\uFF0C\u6216\u4E0A\u4F20\u89E3\u5BC6\u540E\u7684 OFD \u6587\u4EF6\u3002",
+      action: "\u4E0B\u8F7D OFD"
+    });
+  }
+  return createOfdFallback(file.name, url, normalizeOfdError(error));
+}
 function createOfdFallback(fileName, url, detail) {
   const fallback = document.createElement("div");
   fallback.className = "ofv-fallback";
@@ -7112,7 +7523,9 @@ function archivePlugin() {
       try {
         if (ext === "zip") {
           try {
-            const zip = await JSZip5.loadAsync(await readArrayBuffer(ctx.file));
+            const zip = await JSZip5.loadAsync(await readArrayBuffer(ctx.file), {
+              decodeFileName: decodeZipFileName
+            });
             archiveEntries = Object.values(zip.files).map((entry) => ({
               name: entry.name,
               unsafeName: entry.unsafeOriginalName,
@@ -7121,7 +7534,7 @@ function archivePlugin() {
               read: () => entry.async("arraybuffer")
             }));
           } catch (zipErr) {
-            if (zipErr.message && (zipErr.message.includes("encrypted") || zipErr.message.includes("password") || zipErr.message.includes("protected"))) {
+            if (isEncryptedError(zipErr)) {
               isEncrypted = true;
             } else {
               throw zipErr;
@@ -7154,17 +7567,11 @@ function archivePlugin() {
         parseError = `\u538B\u7F29\u5305\u89E3\u6790\u5931\u8D25\uFF1A${err.message || err}`;
       }
       if (isEncrypted) {
-        const fallback = document.createElement("div");
-        fallback.className = "ofv-fallback";
-        const title = document.createElement("strong");
-        title.textContent = "\u8BE5\u538B\u7F29\u5305\u5DF2\u88AB\u52A0\u5BC6\u4FDD\u62A4";
-        const meta = document.createElement("span");
-        meta.textContent = "\u4E3A\u4E86\u60A8\u7684\u6570\u636E\u5B89\u5168\uFF0C\u672C\u9884\u89C8\u5668\u4E0D\u652F\u6301\u76F4\u63A5\u5728\u7EBF\u89E3\u5BC6\u3002\u8BF7\u4E0B\u8F7D\u6587\u4EF6\u540E\u5728\u672C\u5730\u8F93\u5165\u5BC6\u7801\u89E3\u538B\u3002";
-        const download = document.createElement("a");
-        download.href = url;
-        download.download = ctx.file.name;
-        download.textContent = "\u4E0B\u8F7D\u6587\u4EF6";
-        fallback.append(title, meta, download);
+        const fallback = createEncryptedFallback(ctx.file, url, {
+          title: "\u538B\u7F29\u5305\u5DF2\u52A0\u5BC6\uFF0C\u65E0\u6CD5\u5728\u7EBF\u9884\u89C8",
+          message: "\u8BF7\u4E0B\u8F7D\u540E\u5728\u672C\u5730\u8F93\u5165\u5BC6\u7801\u89E3\u538B\uFF0C\u6216\u4E0A\u4F20\u89E3\u5BC6\u540E\u7684\u538B\u7F29\u5305\u3002",
+          action: "\u4E0B\u8F7D\u538B\u7F29\u5305"
+        });
         panel.append(fallback);
         ctx.viewport.classList.add("ofv-center");
         return {
@@ -7413,6 +7820,28 @@ async function findSubPreviewPlugin(plugins, file) {
   }
   return fallbackPlugin();
 }
+function decodeZipFileName(bytes) {
+  const data = Array.isArray(bytes) ? Uint8Array.from(bytes.map((value) => value.charCodeAt(0) & 255)) : bytes instanceof Uint8Array ? bytes : Uint8Array.from(bytes);
+  const utf8 = decodeZipNameWith(data, "utf-8", true);
+  if (utf8 && !looksMojibake(utf8)) {
+    return utf8;
+  }
+  const gb18030 = decodeZipNameWith(data, "gb18030", false) || decodeZipNameWith(data, "gbk", false);
+  if (gb18030 && !looksMojibake(gb18030)) {
+    return gb18030;
+  }
+  return utf8 || new TextDecoder("latin1").decode(data);
+}
+function decodeZipNameWith(bytes, encoding, fatal) {
+  try {
+    return new TextDecoder(encoding, { fatal }).decode(bytes);
+  } catch {
+    return void 0;
+  }
+}
+function looksMojibake(value) {
+  return /[\uFFFDÃÂÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞß]/.test(value);
+}
 function createInlineError(titleText, detailText) {
   const fallback = document.createElement("div");
   fallback.className = "ofv-fallback";
@@ -7834,13 +8263,14 @@ function emailPlugin() {
         } else {
           const PostalMime = (await import("postal-mime")).default;
           const parser = new PostalMime();
-          let rawText = await readTextFile(ctx.file);
+          let rawSource = await readArrayBuffer(ctx.file);
           if (ext === "mbox") {
+            let rawText = await readTextFile(ctx.file);
             const messages = splitMboxMessages(rawText);
             mboxSummary = messages.map(summarizeMboxMessage);
-            rawText = messages[0] || rawText;
+            rawSource = messages[0] || rawText;
           }
-          const parsed = await parser.parse(rawText);
+          const parsed = await parser.parse(rawSource);
           const from = parsed.from ? `${parsed.from.name || ""} <${parsed.from.address || ""}>`.trim() : "";
           const to = Array.isArray(parsed.to) ? parsed.to.map((t) => `${t.name || ""} <${t.address || ""}>`.trim()).join("; ") : "";
           const cc = Array.isArray(parsed.cc) ? parsed.cc.map((c) => `${c.name || ""} <${c.address || ""}>`.trim()).join("; ") : "";
@@ -7910,13 +8340,17 @@ function emailPlugin() {
           const sanitizedHtml = sanitizeEmailHtml(html);
           const iframe = document.createElement("iframe");
           iframe.className = "ofv-email-body-iframe";
-          iframe.setAttribute("sandbox", "allow-popups allow-popups-to-escape-sandbox");
+          iframe.setAttribute("sandbox", "allow-same-origin allow-popups allow-popups-to-escape-sandbox");
           iframe.style.cssText = "width: 100%; border: none; background: #fff; min-height: 200px;";
-          bodySection.append(iframe);
-          iframe.onload = () => {
+          let renderedHtmlBody = false;
+          const renderHtmlBody = () => {
+            if (renderedHtmlBody) {
+              return;
+            }
             try {
               const idoc = iframe.contentDocument || iframe.contentWindow?.document;
               if (idoc) {
+                renderedHtmlBody = true;
                 idoc.open();
                 idoc.write(`
                   <!doctype html>
@@ -7967,6 +8401,9 @@ function emailPlugin() {
               console.error("Failed to write html body to email iframe:", err);
             }
           };
+          iframe.addEventListener("load", renderHtmlBody, { once: true });
+          bodySection.append(iframe);
+          renderHtmlBody();
         } else {
           const pre = document.createElement("pre");
           pre.className = "ofv-text-block";
@@ -9488,6 +9925,7 @@ function decodeDrawioDiagram(value) {
 }
 
 // src/plugins/cad.ts
+import pako3 from "pako";
 var cadExtensions = /* @__PURE__ */ new Set([
   "dxf",
   "dwg",
@@ -9504,7 +9942,10 @@ var cadExtensions = /* @__PURE__ */ new Set([
   "3dm",
   "skp",
   "sldprt",
-  "sldasm"
+  "sldasm",
+  "gds",
+  "oas",
+  "oasis"
 ]);
 var cadMimeTypes = /* @__PURE__ */ new Set([
   "application/acad",
@@ -9521,7 +9962,11 @@ var cadMimeTypes = /* @__PURE__ */ new Set([
   "application/x-parasolid",
   "model/vnd.3dm",
   "application/vnd.sketchup.skp",
-  "application/sldworks"
+  "application/sldworks",
+  "application/vnd.gds",
+  "application/x-gdsii",
+  "application/vnd.oasis.layout",
+  "application/x-oasis-layout"
 ]);
 var cadMimeFormatMap = {
   "application/acad": "dwg",
@@ -9538,7 +9983,11 @@ var cadMimeFormatMap = {
   "application/x-parasolid": "x_t",
   "model/vnd.3dm": "3dm",
   "application/vnd.sketchup.skp": "skp",
-  "application/sldworks": "sldprt"
+  "application/sldworks": "sldprt",
+  "application/vnd.gds": "gds",
+  "application/x-gdsii": "gds",
+  "application/vnd.oasis.layout": "oas",
+  "application/x-oasis-layout": "oas"
 };
 function cadPlugin() {
   return {
@@ -9566,6 +10015,36 @@ function cadPlugin() {
         renderBinaryCad(panel, await readArrayBuffer(ctx.file), extension, ctx.file.name);
         return { destroy: () => panel.remove() };
       }
+      if (extension === "gds") {
+        const viewer2 = renderLayoutPreview(panel, parseGdsLayout(new Uint8Array(await readArrayBuffer(ctx.file)), ctx.file.name), ctx);
+        return {
+          canCommand(command) {
+            return viewer2.canCommand(command);
+          },
+          command(command) {
+            return viewer2.command(command);
+          },
+          destroy() {
+            viewer2.destroy();
+            panel.remove();
+          }
+        };
+      }
+      if (extension === "oas" || extension === "oasis") {
+        const viewer2 = renderLayoutPreview(panel, parseOasisLayout(new Uint8Array(await readArrayBuffer(ctx.file)), ctx.file.name), ctx);
+        return {
+          canCommand(command) {
+            return viewer2.canCommand(command);
+          },
+          command(command) {
+            return viewer2.command(command);
+          },
+          destroy() {
+            viewer2.destroy();
+            panel.remove();
+          }
+        };
+      }
       if (extension !== "dxf") {
         const section = createSection("CAD \u57FA\u7840\u9884\u89C8");
         section.append(`.${extension || "cad"} \u5DF2\u8BC6\u522B\u4E3A\u56FE\u7EB8/\u5DE5\u7A0B\u683C\u5F0F\uFF0C\u5F53\u524D\u524D\u7AEF\u63D2\u4EF6\u4F18\u5148\u6E32\u67D3 DXF\u3002\u8BE5\u683C\u5F0F\u5EFA\u8BAE\u63A5\u5165\u670D\u52A1\u7AEF\u8F6C\u6362\u6216 WASM \u4E13\u7528\u5F15\u64CE\u3002`);
@@ -9664,6 +10143,560 @@ function renderIfc(panel, text) {
   section.append(table);
   panel.append(section);
 }
+var layoutPalette = [
+  "#2563eb",
+  "#dc2626",
+  "#059669",
+  "#7c3aed",
+  "#d97706",
+  "#0891b2",
+  "#be123c",
+  "#4f46e5",
+  "#15803d",
+  "#a16207"
+];
+var gdsRecordNames = {
+  0: "HEADER",
+  1: "BGNLIB",
+  2: "LIBNAME",
+  3: "UNITS",
+  4: "ENDLIB",
+  5: "BGNSTR",
+  6: "STRNAME",
+  7: "ENDSTR",
+  8: "BOUNDARY",
+  9: "PATH",
+  10: "SREF",
+  11: "AREF",
+  12: "TEXT",
+  13: "LAYER",
+  14: "DATATYPE",
+  15: "WIDTH",
+  16: "XY",
+  17: "ENDEL",
+  18: "SNAME",
+  22: "TEXTTYPE",
+  25: "STRING",
+  45: "BOX"
+};
+var oasisRecordNames = {
+  0: "PAD",
+  1: "START",
+  2: "END",
+  3: "CELLNAME",
+  4: "CELLNAME-REF",
+  5: "TEXTSTRING",
+  6: "TEXTSTRING-REF",
+  7: "PROPNAME",
+  8: "PROPNAME-REF",
+  9: "PROPSTRING",
+  10: "PROPSTRING-REF",
+  11: "LAYERNAME",
+  12: "LAYERNAME-REF",
+  13: "CELL",
+  14: "XYABSOLUTE",
+  15: "XYRELATIVE",
+  16: "PLACEMENT",
+  17: "PLACEMENT",
+  18: "TEXT",
+  19: "RECTANGLE",
+  20: "POLYGON",
+  21: "PATH",
+  22: "TRAPEZOID",
+  23: "TRAPEZOID",
+  24: "TRAPEZOID",
+  25: "CTRAPEZOID",
+  26: "CIRCLE",
+  27: "PROPERTY",
+  28: "PROPERTY",
+  29: "XNAME",
+  30: "XNAME-REF",
+  31: "XELEMENT",
+  32: "XGEOMETRY",
+  33: "CBLOCK"
+};
+function renderLayoutPreview(panel, data, ctx) {
+  const section = createSection(`${data.format} \u7248\u56FE\u9884\u89C8`);
+  const summary = document.createElement("div");
+  summary.className = "ofv-cad-summary ofv-layout-summary";
+  appendMeta5(summary, "\u6587\u4EF6", data.fileName);
+  appendMeta5(summary, "\u683C\u5F0F", data.format);
+  if (data.libraryName) {
+    appendMeta5(summary, "\u5E93", data.libraryName);
+  }
+  if (data.version) {
+    appendMeta5(summary, "\u7248\u672C", data.version);
+  }
+  if (data.unit) {
+    appendMeta5(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);
+  for (const [label, value] of data.metadata) {
+    appendMeta5(summary, label, value);
+  }
+  section.append(summary);
+  for (const noteText of [...data.notes, ...data.warnings]) {
+    const note = document.createElement("p");
+    note.className = data.warnings.includes(noteText) ? "ofv-layout-warning" : "ofv-layout-note";
+    note.textContent = noteText;
+    section.append(note);
+  }
+  const bounds = computeLayoutBounds(data.shapes, data.labels, data.references);
+  const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+  svg.setAttribute("class", "ofv-svg-stage ofv-layout-stage");
+  let currentViewBox = { x: bounds.minX, y: bounds.minY, width: bounds.width, height: bounds.height };
+  const initialViewBox = { ...currentViewBox };
+  const applyViewBox = () => {
+    svg.setAttribute("viewBox", `${currentViewBox.x} ${currentViewBox.y} ${currentViewBox.width} ${currentViewBox.height}`);
+  };
+  applyViewBox();
+  if (data.shapes.length === 0) {
+    const empty = document.createElementNS(svg.namespaceURI, "text");
+    empty.setAttribute("x", String(bounds.minX + bounds.width * 0.5));
+    empty.setAttribute("y", String(bounds.minY + bounds.height * 0.5));
+    empty.setAttribute("text-anchor", "middle");
+    empty.setAttribute("font-size", String(Math.max(bounds.width, bounds.height) / 34));
+    empty.setAttribute("fill", "currentColor");
+    empty.textContent = "\u5DF2\u8BC6\u522B\u7248\u56FE\u6587\u4EF6\uFF0C\u5F53\u524D\u6587\u4EF6\u672A\u89E3\u6790\u51FA\u53EF\u7ED8\u5236\u51E0\u4F55";
+    svg.append(empty);
+  }
+  const layerIndex = new Map([...data.layers.keys()].sort((a, b) => a.localeCompare(b)).map((layer, index) => [layer, index]));
+  for (const shape of data.shapes.slice(0, 6e3)) {
+    const color = layoutPalette[(layerIndex.get(shape.layer) || 0) % layoutPalette.length];
+    if (shape.kind === "path") {
+      const polyline = document.createElementNS(svg.namespaceURI, "polyline");
+      polyline.setAttribute("points", shape.points.map(([x, y]) => `${x},${-y}`).join(" "));
+      polyline.setAttribute("fill", "none");
+      polyline.setAttribute("stroke", color);
+      polyline.setAttribute("stroke-width", String(Math.max(bounds.stroke, Math.abs(shape.width || 0))));
+      polyline.setAttribute("stroke-linecap", "round");
+      polyline.setAttribute("stroke-linejoin", "round");
+      applyLayer(polyline, shape.layer);
+      svg.append(polyline);
+      continue;
+    }
+    const polygon = document.createElementNS(svg.namespaceURI, "polygon");
+    polygon.setAttribute("points", shape.points.map(([x, y]) => `${x},${-y}`).join(" "));
+    polygon.setAttribute("fill", color);
+    polygon.setAttribute("fill-opacity", "0.18");
+    polygon.setAttribute("stroke", color);
+    polygon.setAttribute("stroke-width", String(bounds.stroke));
+    polygon.setAttribute("vector-effect", "non-scaling-stroke");
+    applyLayer(polygon, shape.layer);
+    svg.append(polygon);
+  }
+  for (const label of data.labels.slice(0, 400)) {
+    const text = document.createElementNS(svg.namespaceURI, "text");
+    text.setAttribute("x", String(label.x));
+    text.setAttribute("y", String(-label.y));
+    text.setAttribute("font-size", String(Math.max(bounds.stroke * 12, Math.max(bounds.width, bounds.height) / 120)));
+    text.setAttribute("fill", "currentColor");
+    text.textContent = label.text;
+    applyLayer(text, label.layer);
+    svg.append(text);
+  }
+  const layers = [...data.layers.keys()].sort((a, b) => a.localeCompare(b));
+  if (layers.length > 0) {
+    section.append(createLayoutLayerControls(svg, layers, data.layers));
+  }
+  section.append(svg);
+  if (data.cells.length > 0) {
+    section.append(createLayoutCellList(data.cells, data.references));
+  }
+  panel.append(section);
+  const updateToolbarZoom = () => ctx.toolbar?.setZoom(initialViewBox.width / currentViewBox.width);
+  updateToolbarZoom();
+  return {
+    canCommand(command) {
+      return command === "zoom-in" || command === "zoom-out" || command === "zoom-reset";
+    },
+    command(command) {
+      if (command === "zoom-in" || command === "zoom-out") {
+        const factor = command === "zoom-in" ? 0.82 : 1.18;
+        const centerX = currentViewBox.x + currentViewBox.width / 2;
+        const centerY = currentViewBox.y + currentViewBox.height / 2;
+        currentViewBox.width *= factor;
+        currentViewBox.height *= factor;
+        currentViewBox.x = centerX - currentViewBox.width / 2;
+        currentViewBox.y = centerY - currentViewBox.height / 2;
+        applyViewBox();
+        updateToolbarZoom();
+        return true;
+      }
+      if (command === "zoom-reset") {
+        currentViewBox = { ...initialViewBox };
+        applyViewBox();
+        updateToolbarZoom();
+        return true;
+      }
+      return false;
+    },
+    destroy() {
+      ctx.toolbar?.setZoom(void 0);
+    }
+  };
+}
+function parseGdsLayout(bytes, fileName) {
+  const shapes = [];
+  const labels = [];
+  const references = [];
+  const cells = [];
+  const layers = /* @__PURE__ */ new Map();
+  const recordCounts = /* @__PURE__ */ new Map();
+  const warnings = [];
+  let libraryName = "";
+  let version = "";
+  let unit = "";
+  let offset = 0;
+  let current = {};
+  let currentKind = "";
+  while (offset + 4 <= bytes.length) {
+    const length = readUInt16(bytes, offset);
+    const recordType = bytes[offset + 2];
+    const data = bytes.slice(offset + 4, offset + length);
+    const name = gdsRecordNames[recordType] || `0x${recordType.toString(16).padStart(2, "0")}`;
+    recordCounts.set(name, (recordCounts.get(name) || 0) + 1);
+    if (length < 4 || offset + length > bytes.length) {
+      warnings.push(`GDS \u8BB0\u5F55\u5728 ${offset} \u5B57\u8282\u5904\u957F\u5EA6\u5F02\u5E38\uFF0C\u5DF2\u505C\u6B62\u89E3\u6790\u3002`);
+      break;
+    }
+    if (recordType === 0 && data.length >= 2) {
+      version = String(readUInt16(data, 0));
+    } else if (recordType === 2) {
+      libraryName = readGdsString(data);
+    } else if (recordType === 3 && data.length >= 16) {
+      unit = `${formatGdsReal(data, 0)} / ${formatGdsReal(data, 8)}`;
+    } else if (recordType === 6) {
+      cells.push(readGdsString(data));
+    } else if (recordType === 8 || recordType === 9 || recordType === 45) {
+      currentKind = recordType === 9 ? "path" : recordType === 45 ? "box" : "boundary";
+      current = { kind: currentKind, layer: "0", datatype: "0", points: [] };
+    } else if (recordType === 12) {
+      currentKind = "text";
+      current = { layer: "0", text: "", x: 0, y: 0 };
+    } else if (recordType === 10 || recordType === 11) {
+      currentKind = "reference";
+      current = { cell: "", x: 0, y: 0 };
+    } else if (recordType === 13 && data.length >= 2) {
+      current.layer = String(readInt16(data, 0));
+    } else if ((recordType === 14 || recordType === 22) && data.length >= 2) {
+      current.datatype = String(readInt16(data, 0));
+    } else if (recordType === 15 && data.length >= 4) {
+      current.width = Math.abs(readInt32(data, 0));
+    } else if (recordType === 16) {
+      const points = readGdsPoints(data);
+      if (currentKind === "text" && points[0]) {
+        current.x = points[0][0];
+        current.y = points[0][1];
+      } else if (currentKind === "reference" && points[0]) {
+        current.x = points[0][0];
+        current.y = points[0][1];
+      } else {
+        current.points = points;
+      }
+    } else if (recordType === 18) {
+      current.cell = readGdsString(data);
+    } else if (recordType === 25) {
+      current.text = readGdsString(data);
+    } else if (recordType === 17) {
+      if ((currentKind === "boundary" || currentKind === "path" || currentKind === "box") && current.points && current.points.length > 1) {
+        const shape = {
+          kind: current.kind || "boundary",
+          layer: String(current.layer || "0"),
+          datatype: current.datatype,
+          points: current.points,
+          width: current.width
+        };
+        shapes.push(shape);
+        layers.set(shape.layer, (layers.get(shape.layer) || 0) + 1);
+      } else if (currentKind === "text" && current.text) {
+        const label = {
+          layer: String(current.layer || "0"),
+          text: String(current.text),
+          x: Number(current.x || 0),
+          y: Number(current.y || 0)
+        };
+        labels.push(label);
+        layers.set(label.layer, (layers.get(label.layer) || 0) + 1);
+      } else if (currentKind === "reference" && current.cell) {
+        references.push({ cell: String(current.cell), x: Number(current.x || 0), y: Number(current.y || 0) });
+      }
+      current = {};
+      currentKind = "";
+    }
+    offset += length;
+  }
+  return {
+    format: "GDSII",
+    fileName,
+    libraryName,
+    version: version ? `Stream ${version}` : void 0,
+    unit,
+    cells,
+    shapes,
+    labels,
+    references,
+    layers,
+    metadata: [
+      ["\u5927\u5C0F", formatBytes3(bytes.byteLength)],
+      ["\u8BB0\u5F55", sumCounts(recordCounts)],
+      ["\u8BB0\u5F55\u7C7B\u578B", recordCounts.size]
+    ],
+    notes: [
+      `\u5DF2\u4ECE GDSII Stream \u4E2D\u89E3\u6790 ${shapes.length} \u4E2A\u51E0\u4F55\u3001${references.length} \u4E2A cell \u5F15\u7528\u548C ${labels.length} \u6BB5\u6587\u5B57\u3002`
+    ],
+    warnings
+  };
+}
+function parseOasisLayout(bytes, fileName) {
+  const chunks = extractOasisCblocks(bytes);
+  const expanded = chunks.flatMap((chunk) => [...chunk.bytes]);
+  const cellNames = uniqueHints([...extractAsciiRuns(bytes), ...chunks.flatMap((chunk) => extractAsciiRuns(chunk.bytes))]).filter((item) => /^[A-Za-z_][\w$.-]{1,80}$/.test(item)).filter((item) => !item.startsWith("S_"));
+  const propertyNames = uniqueHints(chunks.flatMap((chunk) => extractAsciiRuns(chunk.bytes)).filter((item) => item.startsWith("S_")));
+  const recordCounts = scanOasisRecordCounts(bytes);
+  const expandedCounts = scanOasisRecordCounts(new Uint8Array(expanded));
+  const layers = /* @__PURE__ */ new Map();
+  const shapes = [];
+  const labels = [];
+  const references = [];
+  for (const name of cellNames) {
+    references.push({ cell: name, x: 0, y: 0 });
+  }
+  const pseudo = createOasisStructureShapes(cellNames, chunks.length || recordCounts.size || 1);
+  for (const shape of pseudo) {
+    shapes.push(shape);
+    layers.set(shape.layer, (layers.get(shape.layer) || 0) + 1);
+  }
+  for (let index = 0; index < cellNames.length; index++) {
+    labels.push({ layer: "cell", text: cellNames[index], x: 12, y: -(18 + index * 18) });
+  }
+  if (cellNames.length > 0) {
+    layers.set("cell", (layers.get("cell") || 0) + cellNames.length);
+  }
+  const version = readOasisVersion(bytes);
+  const cblockText = chunks.length ? `${chunks.length} \u4E2A\uFF0C\u5C55\u5F00 ${formatBytes3(chunks.reduce((sum, chunk) => sum + chunk.bytes.byteLength, 0))}` : "\u672A\u53D1\u73B0";
+  const notes = [
+    "OASIS \u662F\u9AD8\u538B\u7F29\u82AF\u7247\u7248\u56FE\u683C\u5F0F\uFF0C\u5F53\u524D\u7248\u672C\u63D0\u4F9B\u6D4F\u89C8\u5668\u7AEF\u8BC6\u522B\u3001CBLOCK \u89E3\u538B\u3001cell/\u5C5E\u6027\u7ED3\u6784\u548C\u8F7B\u91CF\u7ED3\u6784\u793A\u610F\uFF1B\u5B8C\u6574\u51E0\u4F55\u9AD8\u4FDD\u771F\u6E32\u67D3\u5EFA\u8BAE\u540E\u7EED\u63A5\u5165\u4E13\u7528 OASIS \u89E3\u6790\u5668\u3002"
+  ];
+  if (propertyNames.length > 0) {
+    notes.push(`\u8BC6\u522B\u5230\u5C5E\u6027\uFF1A${propertyNames.slice(0, 5).join("\u3001")}`);
+  }
+  return {
+    format: "OASIS",
+    fileName,
+    version,
+    cells: cellNames,
+    shapes,
+    labels,
+    references: [],
+    layers,
+    metadata: [
+      ["\u5927\u5C0F", formatBytes3(bytes.byteLength)],
+      ["CBLOCK", cblockText],
+      ["\u8BB0\u5F55\u7C7B\u578B", recordCounts.size + expandedCounts.size],
+      ["\u53EF\u8BFB\u7247\u6BB5", cellNames.length + propertyNames.length]
+    ],
+    notes,
+    warnings: cellNames.length === 0 ? ["\u5F53\u524D OASIS \u6587\u4EF6\u672A\u63D0\u53D6\u5230 cell \u540D\u79F0\uFF0C\u53EF\u80FD\u4F7F\u7528\u4E86\u66F4\u590D\u6742\u7684\u7D22\u5F15\u6216\u52A0\u5BC6/\u538B\u7F29\u5E03\u5C40\u3002"] : []
+  };
+}
+function computeLayoutBounds(shapes, labels, references) {
+  const xs = [];
+  const ys = [];
+  for (const shape of shapes) {
+    for (const [x, y] of shape.points) {
+      xs.push(x);
+      ys.push(-y);
+    }
+  }
+  for (const label of labels) {
+    xs.push(label.x, label.x + label.text.length * 12);
+    ys.push(-label.y, -label.y - 16);
+  }
+  for (const reference of references) {
+    xs.push(reference.x);
+    ys.push(-reference.y);
+  }
+  const minX = Math.min(...xs, 0);
+  const maxX = Math.max(...xs, 100);
+  const minY = Math.min(...ys, 0);
+  const maxY = Math.max(...ys, 100);
+  const width = Math.max(1, maxX - minX);
+  const height = Math.max(1, maxY - minY);
+  const padding = Math.max(width, height) * 0.06;
+  return {
+    minX: minX - padding,
+    minY: minY - padding,
+    width: width + padding * 2,
+    height: height + padding * 2,
+    stroke: Math.max(width, height) / 900
+  };
+}
+function createLayoutLayerControls(svg, layers, counts) {
+  const controls = document.createElement("div");
+  controls.className = "ofv-cad-layers ofv-layout-layers";
+  const title = document.createElement("strong");
+  title.textContent = `\u56FE\u5C42 ${layers.length}`;
+  controls.append(title);
+  for (const layer of layers) {
+    const label = document.createElement("label");
+    const checkbox = document.createElement("input");
+    checkbox.type = "checkbox";
+    checkbox.checked = true;
+    checkbox.addEventListener("change", () => {
+      for (const element of svg.querySelectorAll(`[data-layer="${escapeCssAttribute(layer)}"]`)) {
+        element.style.display = checkbox.checked ? "" : "none";
+      }
+    });
+    const name = document.createElement("span");
+    name.textContent = `${layer} (${counts.get(layer) || 0})`;
+    label.append(checkbox, name);
+    controls.append(label);
+  }
+  return controls;
+}
+function createLayoutCellList(cells, references) {
+  const details = document.createElement("details");
+  details.className = "ofv-details ofv-layout-cells";
+  details.open = true;
+  const summary = document.createElement("summary");
+  summary.textContent = `Cell \u7ED3\u6784 ${cells.length}`;
+  const list = document.createElement("ul");
+  const refCounts = countBy(references.map((reference) => reference.cell));
+  for (const cell of cells.slice(0, 120)) {
+    const item = document.createElement("li");
+    const count = refCounts.get(cell) || 0;
+    item.textContent = count > 0 ? `${cell} \xB7 \u5F15\u7528 ${count}` : cell;
+    list.append(item);
+  }
+  details.append(summary, list);
+  return details;
+}
+function readUInt16(bytes, offset) {
+  return bytes[offset] << 8 | bytes[offset + 1];
+}
+function readInt16(bytes, offset) {
+  const value = readUInt16(bytes, offset);
+  return value & 32768 ? value - 65536 : value;
+}
+function readInt32(bytes, offset) {
+  const value = bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3];
+  return value | 0;
+}
+function readGdsString(bytes) {
+  return new TextDecoder("ascii").decode(bytes).replace(/\0+$/g, "").trim();
+}
+function readGdsPoints(bytes) {
+  const points = [];
+  for (let offset = 0; offset + 7 < bytes.length; offset += 8) {
+    points.push([readInt32(bytes, offset), readInt32(bytes, offset + 4)]);
+  }
+  return points;
+}
+function formatGdsReal(bytes, offset) {
+  const value = readGdsReal(bytes, offset);
+  if (!Number.isFinite(value) || value === 0) {
+    return "0";
+  }
+  if (Math.abs(value) < 1e-3 || Math.abs(value) >= 1e4) {
+    return value.toExponential(4);
+  }
+  return String(Number(value.toPrecision(6)));
+}
+function readGdsReal(bytes, offset) {
+  const first = bytes[offset];
+  if (!first) {
+    return 0;
+  }
+  const sign = first & 128 ? -1 : 1;
+  const exponent = (first & 127) - 64;
+  let mantissa = 0;
+  for (let index = 1; index < 8; index++) {
+    mantissa = mantissa * 256 + bytes[offset + index];
+  }
+  return sign * (mantissa / Math.pow(2, 56)) * Math.pow(16, exponent);
+}
+function sumCounts(counts) {
+  return [...counts.values()].reduce((sum, count) => sum + count, 0);
+}
+function extractOasisCblocks(bytes) {
+  const chunks = [];
+  const seen = /* @__PURE__ */ new Set();
+  const limit = Math.min(bytes.length, 25e4);
+  for (let offset = 0; offset < limit; offset++) {
+    try {
+      const inflated = pako3.inflateRaw(bytes.slice(offset));
+      if (inflated.byteLength < 4) {
+        continue;
+      }
+      const ascii = extractAsciiRuns(inflated);
+      const hasLayoutSignal = ascii.some((item) => item.startsWith("S_") || /TOP|CELL|DIE|SIZE/i.test(item));
+      const hasRecordSignal = inflated.some((byte) => byte >= 13 && byte <= 34);
+      if (!hasLayoutSignal && !hasRecordSignal) {
+        continue;
+      }
+      const signature = `${inflated.byteLength}:${Array.from(inflated.slice(0, 12)).join(",")}`;
+      if (seen.has(signature)) {
+        continue;
+      }
+      seen.add(signature);
+      chunks.push({ offset, bytes: inflated });
+      if (chunks.length >= 12) {
+        break;
+      }
+    } catch {
+    }
+  }
+  return chunks;
+}
+function scanOasisRecordCounts(bytes) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const byte of bytes.slice(0, Math.min(bytes.length, 12e3))) {
+    const name = oasisRecordNames[byte];
+    if (name) {
+      counts.set(name, (counts.get(name) || 0) + 1);
+    }
+  }
+  return counts;
+}
+function readOasisVersion(bytes) {
+  const magic = "%SEMI-OASIS\r\n";
+  const header = new TextDecoder("ascii").decode(bytes.slice(0, Math.min(bytes.length, 48)));
+  if (!header.startsWith(magic)) {
+    return void 0;
+  }
+  const start = magic.length;
+  if (bytes[start] !== 1) {
+    return "OASIS";
+  }
+  const length = bytes[start + 1];
+  const version = new TextDecoder("ascii").decode(bytes.slice(start + 2, start + 2 + length));
+  return version ? `OASIS ${version}` : "OASIS";
+}
+function createOasisStructureShapes(cellNames, fallbackCount) {
+  const rows = Math.max(1, cellNames.length || fallbackCount);
+  const shapes = [];
+  for (let index = 0; index < rows; index++) {
+    const top = -(index * 18);
+    const height = 12;
+    const width = 88 + Math.min((cellNames[index]?.length || 5) * 4, 90);
+    shapes.push({
+      kind: "box",
+      layer: "cell",
+      points: [
+        [0, top],
+        [width, top],
+        [width, top - height],
+        [0, top - height],
+        [0, top]
+      ]
+    });
+  }
+  return shapes;
+}
 function renderBinaryCad(panel, arrayBuffer, extension, fileName) {
   const bytes = new Uint8Array(arrayBuffer);
   const section = createSection(`${extension.toUpperCase()} \u6587\u4EF6\u9884\u89C8`);