@open-file-viewer/core 0.1.5 → 0.1.7

package/dist/index.cjs

@@ -301,6 +301,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",
@@ -321,7 +324,7 @@ var extensionMimeMap = {
 };
 async function normalizeFile(source, fileName, mimeType) {
   if (typeof source === "string") {
-    const name2 = fileName || source.split("?")[0]?.split("/").pop() || "remote-file";
+    const name2 = fileName || getFileNameFromUrl(source) || "remote-file";
     const extension2 = getExtension(name2);
     return {
       source,
@@ -366,6 +369,17 @@ async function normalizeFile(source, fileName, mimeType) {
     blob
   };
 }
+function getFileNameFromUrl(source) {
+  const rawName = source.split(/[?#]/, 1)[0]?.split("/").filter(Boolean).pop() || "";
+  if (!rawName) {
+    return "";
+  }
+  try {
+    return decodeURIComponent(rawName);
+  } catch {
+    return rawName;
+  }
+}
 function getExtension(name) {
   const clean = name.split("?")[0]?.split("#")[0] || "";
   const index = clean.lastIndexOf(".");
@@ -1805,6 +1819,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 = () => {
@@ -1852,29 +1867,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;
@@ -1886,8 +1933,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);
@@ -1934,8 +1984,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);
@@ -4084,6 +4138,38 @@ async function readText(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 [
@@ -4125,7 +4211,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;
       });
@@ -4415,9 +4505,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";
   }
@@ -5345,7 +5432,13 @@ async function renderSheet(panel, arrayBuffer, extension) {
   const xlsx = await import("xlsx");
   let workbook;
   try {
-    workbook = extension === "csv" || extension === "tsv" ? xlsx.read(decodeTextBuffer(arrayBuffer), { type: "string", FS: extension === "tsv" ? "	" : "," }) : xlsx.read(arrayBuffer, { type: "array" });
+    workbook = extension === "csv" || extension === "tsv" ? xlsx.read(decodeTextBuffer(arrayBuffer), {
+      type: "string",
+      FS: extension === "tsv" ? "	" : ",",
+      cellDates: true,
+      cellNF: true,
+      cellStyles: true
+    }) : xlsx.read(arrayBuffer, { type: "array", cellDates: true, cellNF: true, cellStyles: true });
   } catch (error) {
     if (isLegacyOfficeBinary(extension)) {
       renderLegacyOfficeBinary(panel, extension, arrayBuffer, `\u8868\u683C\u89E3\u6790\u5931\u8D25\uFF1A${normalizeOfficeError(error)}`);
@@ -5373,7 +5466,7 @@ async function renderSheet(panel, arrayBuffer, extension) {
     const heading = document.createElement("h3");
     heading.textContent = sheetName;
     const sheet = workbook.Sheets[sheetName];
-    const range = xlsx.utils.decode_range(sheet["!ref"] || "A1:A1");
+    const range = trimWorkbookSheetRange(sheet, xlsx.utils.decode_range(sheet["!ref"] || "A1:A1"), xlsx.utils.decode_cell);
     const rowCount = range.e.r - range.s.r + 1;
     const columnCount = range.e.c - range.s.c + 1;
     const formulaRows = collectFormulaRows(sheet, range, xlsx.utils.encode_cell);
@@ -5383,6 +5476,7 @@ async function renderSheet(panel, arrayBuffer, extension) {
     const tableWrapper = document.createElement("div");
     tableWrapper.className = "ofv-table-scroll";
     const viewport = createSheetViewport(rowCount, columnCount);
+    const columnSizing = { widths: /* @__PURE__ */ new Map() };
     const windowControls = createSheetWindowControls(viewport, () => renderTableWindow());
     const renderTableWindow = () => {
       tableWrapper.replaceChildren(
@@ -5392,7 +5486,9 @@ async function renderSheet(panel, arrayBuffer, extension) {
           sheetIndex,
           viewport,
           xlsx.utils.encode_cell,
-          xlsx.utils.format_cell
+          xlsx.utils.format_cell,
+          columnSizing,
+          renderTableWindow
         )
       );
       windowControls?.update();
@@ -5447,6 +5543,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`;
@@ -5457,6 +5557,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");
@@ -5487,9 +5598,10 @@ function renderParsedSheets(panel, sheets, emptyMessage) {
     const tableWrapper = document.createElement("div");
     tableWrapper.className = "ofv-table-scroll";
     const viewport = createSheetViewport(rowCount, columnCount);
+    const columnSizing = { widths: /* @__PURE__ */ new Map() };
     const windowControls = createSheetWindowControls(viewport, () => renderTableWindow());
     const renderTableWindow = () => {
-      tableWrapper.replaceChildren(createParsedSheetTable(sheet, sheetIndex, viewport));
+      tableWrapper.replaceChildren(createParsedSheetTable(sheet, sheetIndex, viewport, columnSizing, renderTableWindow));
       windowControls?.update();
     };
     content.append(heading, summary);
@@ -5716,6 +5828,45 @@ function chartText(element) {
 function chartStringValues(element) {
   return Array.from(element.querySelectorAll("*")).filter((item) => item.localName === "v" || item.localName === "t").map((item) => item.textContent?.trim() || "").filter(Boolean);
 }
+function trimWorkbookSheetRange(sheet, range, decodeCell) {
+  let minRow = Number.POSITIVE_INFINITY;
+  let minColumn = Number.POSITIVE_INFINITY;
+  let maxRow = Number.NEGATIVE_INFINITY;
+  let maxColumn = Number.NEGATIVE_INFINITY;
+  const include = (row, column) => {
+    minRow = Math.min(minRow, row);
+    minColumn = Math.min(minColumn, column);
+    maxRow = Math.max(maxRow, row);
+    maxColumn = Math.max(maxColumn, column);
+  };
+  for (const [address, cell] of Object.entries(sheet)) {
+    if (address.startsWith("!")) {
+      continue;
+    }
+    if (!cell || cell.v == null && !cell.f && !cell.w && !cell.h) {
+      continue;
+    }
+    const decoded = decodeCell(address);
+    include(decoded.r, decoded.c);
+  }
+  for (const merge of sheet["!merges"] || []) {
+    include(merge.s.r, merge.s.c);
+    include(merge.e.r, merge.e.c);
+  }
+  if (!Number.isFinite(minRow) || !Number.isFinite(minColumn) || !Number.isFinite(maxRow) || !Number.isFinite(maxColumn)) {
+    return range;
+  }
+  return {
+    s: {
+      r: Math.max(range.s.r, minRow),
+      c: Math.max(range.s.c, minColumn)
+    },
+    e: {
+      r: Math.min(range.e.r, maxRow),
+      c: Math.min(range.e.c, maxColumn)
+    }
+  };
+}
 function createSheetViewport(rowCount, columnCount) {
   return {
     rowStart: 0,
@@ -5778,42 +5929,245 @@ function createWindowButton(label, onClick) {
 function maxStart(total, size) {
   return Math.max(0, total - size);
 }
-function createWorkbookSheetTable(sheet, range, sheetIndex, viewport, encodeCell, formatCell) {
+function createWorkbookSheetTable(sheet, range, sheetIndex, viewport, encodeCell, formatCell, columnSizing, rerender) {
   const table = document.createElement("table");
   table.id = `ofv-sheet-${sheetIndex + 1}`;
+  table.className = "ofv-workbook-table";
   const rowEnd = Math.min(range.s.r + viewport.rowStart + SHEET_WINDOW_ROWS - 1, range.e.r);
   const columnEnd = Math.min(range.s.c + viewport.columnStart + SHEET_WINDOW_COLUMNS - 1, range.e.c);
-  for (let rowIndex = range.s.r + viewport.rowStart; rowIndex <= rowEnd; rowIndex += 1) {
+  const columnStart = range.s.c + viewport.columnStart;
+  const rowStart = range.s.r + viewport.rowStart;
+  const mergePlan = createSheetMergePlan(sheet["!merges"] || [], rowStart, rowEnd, columnStart, columnEnd);
+  const colGroup = document.createElement("colgroup");
+  let tableWidth = 0;
+  for (let columnIndex = columnStart; columnIndex <= columnEnd; columnIndex += 1) {
+    const col = document.createElement("col");
+    const width = columnSizing.widths.get(columnIndex) ?? getSheetColumnWidth(sheet["!cols"]?.[columnIndex]);
+    col.dataset.columnIndex = String(columnIndex);
+    col.style.width = `${width}px`;
+    tableWidth += width;
+    colGroup.append(col);
+  }
+  table.style.width = `${tableWidth}px`;
+  table.append(colGroup);
+  for (let rowIndex = rowStart; rowIndex <= rowEnd; rowIndex += 1) {
     const row = document.createElement("tr");
-    for (let columnIndex = range.s.c + viewport.columnStart; columnIndex <= columnEnd; columnIndex += 1) {
-      const cell = document.createElement(rowIndex === range.s.r ? "th" : "td");
+    const rowHeight = getSheetRowHeight(sheet["!rows"]?.[rowIndex]);
+    if (rowHeight) {
+      row.style.height = `${rowHeight}px`;
+    }
+    for (let columnIndex = columnStart; columnIndex <= columnEnd; columnIndex += 1) {
       const address = encodeCell({ r: rowIndex, c: columnIndex });
-      const sourceCell = sheet[address];
+      const coordinateKey = `${rowIndex}:${columnIndex}`;
+      if (mergePlan.covered.has(coordinateKey)) {
+        continue;
+      }
+      const merge = mergePlan.anchors.get(coordinateKey);
+      const sourceAddress = merge ? encodeCell({ r: merge.sourceRow, c: merge.sourceColumn }) : address;
+      const sourceCell = sheet[sourceAddress];
+      const cell = document.createElement(rowIndex === range.s.r ? "th" : "td");
       cell.dataset.cell = address;
+      if (sourceAddress !== address) {
+        cell.dataset.sourceCell = sourceAddress;
+      }
+      if (merge) {
+        cell.classList.add("ofv-cell-merged");
+        if (merge.rowspan > 1) {
+          cell.rowSpan = merge.rowspan;
+        }
+        if (merge.colspan > 1) {
+          cell.colSpan = merge.colspan;
+        }
+      }
       const text = sourceCell ? formatCell(sourceCell) : "";
       cell.textContent = text;
       if (text) {
         cell.title = text;
       }
+      applyWorkbookCellStyle(cell, sourceCell);
       if (sourceCell?.f) {
         cell.classList.add("ofv-cell-formula");
         cell.title = `=${sourceCell.f}`;
       }
+      if (text.includes("\n")) {
+        cell.classList.add("ofv-cell-multiline");
+      }
+      appendColumnResizeHandle(cell, columnIndex, columnSizing);
       row.append(cell);
     }
     table.append(row);
   }
   return table;
 }
-function createParsedSheetTable(sheet, sheetIndex, viewport) {
+function appendColumnResizeHandle(cell, columnIndex, columnSizing) {
+  const handle = document.createElement("span");
+  handle.className = "ofv-column-resize-handle";
+  handle.setAttribute("aria-hidden", "true");
+  handle.addEventListener("pointerdown", (event) => {
+    event.preventDefault();
+    event.stopPropagation();
+    const startX = event.clientX;
+    const startWidth = columnSizing.widths.get(columnIndex) ?? cell.getBoundingClientRect().width;
+    handle.setPointerCapture(event.pointerId);
+    const onMove = (moveEvent) => {
+      const nextWidth = Math.max(48, Math.min(720, Math.round(startWidth + moveEvent.clientX - startX)));
+      columnSizing.widths.set(columnIndex, nextWidth);
+      updateRenderedColumnWidth(cell, columnIndex, nextWidth);
+    };
+    const onEnd = () => {
+      handle.removeEventListener("pointermove", onMove);
+      handle.removeEventListener("pointerup", onEnd);
+      handle.removeEventListener("pointercancel", onEnd);
+    };
+    handle.addEventListener("pointermove", onMove);
+    handle.addEventListener("pointerup", onEnd);
+    handle.addEventListener("pointercancel", onEnd);
+  });
+  cell.append(handle);
+}
+function updateRenderedColumnWidth(cell, columnIndex, width) {
+  const table = cell.closest("table");
+  if (!table) {
+    return;
+  }
+  const column = Array.from(table.querySelectorAll("col")).find(
+    (col) => col.dataset.columnIndex === String(columnIndex)
+  );
+  if (column) {
+    column.style.width = `${width}px`;
+  }
+  const tableWidth = Array.from(table.querySelectorAll("col")).reduce((sum, col) => {
+    const parsed = Number.parseFloat(col.style.width);
+    return sum + (Number.isFinite(parsed) ? parsed : 0);
+  }, 0);
+  if (tableWidth > 0) {
+    table.style.width = `${Math.round(tableWidth)}px`;
+  }
+}
+function createSheetMergePlan(merges, rowStart, rowEnd, columnStart, columnEnd) {
+  const anchors = /* @__PURE__ */ new Map();
+  const covered = /* @__PURE__ */ new Set();
+  const encode = (row, column) => `${row}:${column}`;
+  for (const merge of merges) {
+    if (merge.e.r < rowStart || merge.s.r > rowEnd || merge.e.c < columnStart || merge.s.c > columnEnd) {
+      continue;
+    }
+    const visibleStartRow = Math.max(merge.s.r, rowStart);
+    const visibleEndRow = Math.min(merge.e.r, rowEnd);
+    const visibleStartColumn = Math.max(merge.s.c, columnStart);
+    const visibleEndColumn = Math.min(merge.e.c, columnEnd);
+    const anchor = encode(visibleStartRow, visibleStartColumn);
+    anchors.set(anchor, {
+      rowspan: visibleEndRow - visibleStartRow + 1,
+      colspan: visibleEndColumn - visibleStartColumn + 1,
+      sourceRow: merge.s.r,
+      sourceColumn: merge.s.c
+    });
+    for (let rowIndex = visibleStartRow; rowIndex <= visibleEndRow; rowIndex += 1) {
+      for (let columnIndex = visibleStartColumn; columnIndex <= visibleEndColumn; columnIndex += 1) {
+        const address = encode(rowIndex, columnIndex);
+        if (address !== anchor) {
+          covered.add(address);
+        }
+      }
+    }
+  }
+  return { anchors, covered };
+}
+function getSheetColumnWidth(column) {
+  if (column?.hidden) {
+    return 0;
+  }
+  const width = column?.wpx || (column?.wch ? column.wch * 7 + 5 : void 0) || (column?.width ? column.width * 7 : void 0) || 96;
+  return Math.max(28, Math.min(360, Math.round(width)));
+}
+function getSheetRowHeight(row) {
+  if (row?.hidden) {
+    return 0;
+  }
+  const height = row?.hpx || (row?.hpt ? row.hpt * 1.333 : void 0);
+  return height ? Math.max(18, Math.min(260, Math.round(height))) : void 0;
+}
+function applyWorkbookCellStyle(cell, sourceCell) {
+  const style = sourceCell?.s;
+  if (!style) {
+    return;
+  }
+  const fill = readWorkbookColor(style.fgColor || style.fill?.fgColor);
+  if (fill && style.patternType !== "none") {
+    cell.style.backgroundColor = fill;
+  }
+  const font = style.font;
+  if (font) {
+    if (font.bold) {
+      cell.style.fontWeight = "700";
+    }
+    if (font.italic) {
+      cell.style.fontStyle = "italic";
+    }
+    if (font.sz) {
+      cell.style.fontSize = `${Math.max(9, Math.min(24, Number(font.sz)))}pt`;
+    }
+    const fontColor = readWorkbookColor(font.color);
+    if (fontColor) {
+      cell.style.color = fontColor;
+    }
+  }
+  const alignment = style.alignment;
+  if (alignment) {
+    const horizontal = normalizeSheetHorizontalAlign(alignment.horizontal);
+    if (horizontal) {
+      cell.style.textAlign = horizontal;
+    }
+    const vertical = normalizeSheetVerticalAlign(alignment.vertical);
+    if (vertical) {
+      cell.style.verticalAlign = vertical;
+    }
+    if (alignment.wrapText) {
+      cell.classList.add("ofv-cell-multiline");
+    }
+  }
+}
+function readWorkbookColor(color) {
+  if (!color?.rgb) {
+    return void 0;
+  }
+  const rgb = color.rgb.length === 8 ? color.rgb.slice(2) : color.rgb;
+  return /^[\da-f]{6}$/i.test(rgb) ? `#${rgb}` : void 0;
+}
+function normalizeSheetHorizontalAlign(value) {
+  if (value === "center" || value === "right" || value === "left" || value === "justify") {
+    return value;
+  }
+  return void 0;
+}
+function normalizeSheetVerticalAlign(value) {
+  if (value === "top" || value === "middle" || value === "bottom") {
+    return value;
+  }
+  return void 0;
+}
+function createParsedSheetTable(sheet, sheetIndex, viewport, columnSizing, rerender) {
   const table = document.createElement("table");
   table.id = `ofv-sheet-${sheetIndex + 1}`;
   const formulaMap = new Map(sheet.formulas.map((item) => [item.address, item.formula]));
   const rowEnd = Math.min(viewport.rowStart + SHEET_WINDOW_ROWS, sheet.rows.length);
+  const columnEnd = Math.min(viewport.columnStart + SHEET_WINDOW_COLUMNS, viewport.columnCount);
+  const colGroup = document.createElement("colgroup");
+  let tableWidth = 0;
+  for (let columnIndex = viewport.columnStart; columnIndex < columnEnd; columnIndex += 1) {
+    const width = columnSizing.widths.get(columnIndex) ?? 112;
+    const col = document.createElement("col");
+    col.dataset.columnIndex = String(columnIndex);
+    col.style.width = `${width}px`;
+    tableWidth += width;
+    colGroup.append(col);
+  }
+  table.style.width = `${tableWidth}px`;
+  table.append(colGroup);
   for (let rowIndex = viewport.rowStart; rowIndex < rowEnd; rowIndex += 1) {
     const sourceRow = sheet.rows[rowIndex] || [];
     const row = document.createElement("tr");
-    const columnEnd = Math.min(viewport.columnStart + SHEET_WINDOW_COLUMNS, viewport.columnCount);
     for (let columnIndex = viewport.columnStart; columnIndex < columnEnd; columnIndex += 1) {
       const value = sourceRow[columnIndex] || "";
       const cell = document.createElement(rowIndex === 0 ? "th" : "td");
@@ -5828,6 +6182,10 @@ function createParsedSheetTable(sheet, sheetIndex, viewport) {
         cell.classList.add("ofv-cell-formula");
         cell.title = formula;
       }
+      if (value.includes("\n")) {
+        cell.classList.add("ofv-cell-multiline");
+      }
+      appendColumnResizeHandle(cell, columnIndex, columnSizing);
       row.append(cell);
     }
     table.append(row);
@@ -6765,7 +7123,7 @@ function ofdPlugin() {
       try {
         zip = await import_jszip4.default.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();
@@ -6782,7 +7140,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();
@@ -7407,6 +7765,16 @@ function finiteNumber2(value, 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";
@@ -7475,7 +7843,9 @@ function archivePlugin() {
       try {
         if (ext === "zip") {
           try {
-            const zip = await import_jszip5.default.loadAsync(await readArrayBuffer(ctx.file));
+            const zip = await import_jszip5.default.loadAsync(await readArrayBuffer(ctx.file), {
+              decodeFileName: decodeZipFileName
+            });
             archiveEntries = Object.values(zip.files).map((entry) => ({
               name: entry.name,
               unsafeName: entry.unsafeOriginalName,
@@ -7484,7 +7854,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;
@@ -7517,17 +7887,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 {
@@ -7776,6 +8140,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";
@@ -8197,13 +8583,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("; ") : "";
@@ -8273,13 +8660,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>
@@ -8330,6 +8721,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";
@@ -9851,112 +10245,726 @@ function decodeDrawioDiagram(value) {
 }
 
 // src/plugins/cad.ts
-var cadExtensions = /* @__PURE__ */ new Set([
-  "dxf",
-  "dwg",
-  "dwf",
-  "step",
-  "stp",
-  "iges",
-  "igs",
-  "ifc",
-  "sat",
-  "sab",
-  "x_t",
-  "x_b",
-  "3dm",
-  "skp",
-  "sldprt",
-  "sldasm"
-]);
-var cadMimeTypes = /* @__PURE__ */ new Set([
-  "application/acad",
-  "application/dxf",
-  "application/x-dxf",
-  "image/vnd.dxf",
-  "model/vnd.dwf",
-  "model/step",
-  "application/step",
-  "application/iges",
-  "application/x-step",
-  "application/sat",
-  "application/sab",
-  "application/x-parasolid",
-  "model/vnd.3dm",
-  "application/vnd.sketchup.skp",
-  "application/sldworks"
-]);
-var cadMimeFormatMap = {
-  "application/acad": "dwg",
-  "application/dxf": "dxf",
-  "application/x-dxf": "dxf",
-  "image/vnd.dxf": "dxf",
-  "model/vnd.dwf": "dwf",
-  "model/step": "step",
-  "application/step": "step",
-  "application/iges": "iges",
-  "application/x-step": "ifc",
-  "application/sat": "sat",
-  "application/sab": "sab",
-  "application/x-parasolid": "x_t",
-  "model/vnd.3dm": "3dm",
-  "application/vnd.sketchup.skp": "skp",
-  "application/sldworks": "sldprt"
-};
-function cadPlugin() {
-  return {
-    name: "cad",
-    match(file) {
-      return cadExtensions.has(file.extension) || cadMimeTypes.has(file.mimeType);
-    },
-    async render(ctx) {
-      const panel = createPanel("ofv-cad");
-      ctx.viewport.append(panel);
-      const extension = resolveFormat(ctx.file, cadMimeFormatMap);
-      if (extension === "step" || extension === "stp") {
-        renderStep(panel, await readTextFile(ctx.file), extension);
-        return { destroy: () => panel.remove() };
-      }
-      if (extension === "iges" || extension === "igs") {
-        renderIges(panel, await readTextFile(ctx.file), extension);
-        return { destroy: () => panel.remove() };
-      }
-      if (extension === "ifc") {
-        renderIfc(panel, await readTextFile(ctx.file));
-        return { destroy: () => panel.remove() };
-      }
-      if (extension === "dwg" || extension === "dwf") {
-        renderBinaryCad(panel, await readArrayBuffer(ctx.file), extension, ctx.file.name);
-        return { destroy: () => panel.remove() };
+var import_pako3 = __toESM(require("pako"), 1);
+
+// src/plugins/cad-dwg.ts
+var libreDwgPromise;
+var defaultLibreDwgWasmBaseUrl = "/vendor/libredwg-web";
+var minReadableDrawingHeight = 420;
+var svgNumberPattern = /-?\d*\.?\d+(?:e[-+]?\d+)?/gi;
+async function renderLibreDwgPreview(ctx, options = {}) {
+  if (ctx.extension !== "dwg" || options.enabled === false) {
+    return void 0;
+  }
+  const shell = document.createElement("div");
+  shell.className = "ofv-dwg-preview";
+  const status = document.createElement("div");
+  status.className = "ofv-dwg-preview-status";
+  status.textContent = "Loading DWG rendering engine...";
+  shell.append(status);
+  ctx.panel.append(shell);
+  try {
+    const { LibreDwg, Dwg_File_Type } = await loadLibreDwg();
+    const libredwg = await LibreDwg.create(options.wasmBaseUrl || defaultLibreDwgWasmBaseUrl);
+    const data = libredwg.dwg_read_data(ctx.arrayBuffer, Dwg_File_Type.DWG);
+    if (!data) {
+      throw new Error("DWG parser did not return drawing data.");
+    }
+    let svg = "";
+    let stats;
+    let thumbnailUrl;
+    try {
+      thumbnailUrl = createDwgThumbnailUrl(readDwgThumbnail(libredwg, data));
+      try {
+        const result = libredwg.convertEx(data);
+        const database = result.database;
+        stats = createDwgPreviewStats(database, result.stats.unknownEntityCount, Boolean(thumbnailUrl));
+        svg = libredwg.dwg_to_svg(database);
+      } catch (error) {
+        if (thumbnailUrl) {
+          const fallbackThumbnailUrl = thumbnailUrl;
+          status.replaceChildren(createDwgThumbnailFallbackStatus(ctx.fileName, error));
+          shell.append(createDwgThumbnailPreview(fallbackThumbnailUrl, ctx.fileName));
+          return {
+            destroy() {
+              URL.revokeObjectURL(fallbackThumbnailUrl);
+              shell.remove();
+            }
+          };
+        }
+        throw error;
       }
-      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`);
-        panel.append(section);
-        return { destroy: () => panel.remove() };
+    } finally {
+      libredwg.dwg_free(data);
+    }
+    if (!svg || !/<svg[\s>]/i.test(svg)) {
+      if (thumbnailUrl) {
+        const fallbackThumbnailUrl = thumbnailUrl;
+        status.replaceChildren(createDwgThumbnailFallbackStatus(ctx.fileName, "DWG parser finished but did not produce SVG output."));
+        shell.append(createDwgThumbnailPreview(fallbackThumbnailUrl, ctx.fileName));
+        return {
+          destroy() {
+            URL.revokeObjectURL(fallbackThumbnailUrl);
+            shell.remove();
+          }
+        };
       }
-      const dxf = await readTextFile(ctx.file);
-      const viewer = renderDxf(panel, dxf, ctx);
+      throw new Error("DWG parser finished but did not produce SVG output.");
+    }
+    const doc = new DOMParser().parseFromString(svg, "image/svg+xml");
+    const svgElement = doc.documentElement;
+    if (!(svgElement instanceof SVGElement) || svgElement.nodeName.toLowerCase() !== "svg" || svgElement.querySelector("parsererror")) {
+      throw new Error("DWG SVG output is invalid.");
+    }
+    svgElement.classList.add("ofv-dwg-preview-svg");
+    svgElement.setAttribute("role", "img");
+    svgElement.setAttribute("aria-label", ctx.fileName);
+    normalizeDwgSvg(svgElement);
+    const reliability = assessDwgSvgReliability(svgElement);
+    status.replaceChildren(createDwgStatusTitle(ctx.fileName, stats, reliability));
+    if (!reliability.isReliable && thumbnailUrl) {
+      shell.append(createDwgThumbnailPreview(thumbnailUrl, ctx.fileName));
       return {
-        canCommand(command) {
-          return viewer.canCommand(command);
-        },
-        command(command) {
-          return viewer.command(command);
-        },
         destroy() {
-          panel.remove();
+          URL.revokeObjectURL(thumbnailUrl);
+          shell.remove();
         }
       };
     }
-  };
-}
-function renderStep(panel, text, extension) {
-  const records = parseStepRecords(text);
-  const typeCounts = countBy(records.map((record) => record.type));
-  const section = createSection(`${extension.toUpperCase()} \u7ED3\u6784\u9884\u89C8`);
-  const note = document.createElement("p");
-  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 drawing = createDwgDrawingViewport(svgElement);
+    if (thumbnailUrl) {
+      shell.append(createDwgThumbnailPanel(thumbnailUrl));
+    }
+    shell.append(drawing.frame);
+    return {
+      resize() {
+        drawing.update();
+      },
+      canCommand(command) {
+        return command === "zoom-in" || command === "zoom-out" || command === "zoom-reset";
+      },
+      command(command) {
+        if (command === "zoom-in") {
+          drawing.setZoom(drawing.zoom * 1.18);
+          return true;
+        }
+        if (command === "zoom-out") {
+          drawing.setZoom(drawing.zoom / 1.18);
+          return true;
+        }
+        if (command === "zoom-reset") {
+          drawing.setZoom(1);
+          return true;
+        }
+        return false;
+      },
+      destroy() {
+        if (thumbnailUrl) {
+          URL.revokeObjectURL(thumbnailUrl);
+        }
+        shell.remove();
+      }
+    };
+  } catch (error) {
+    shell.remove();
+    console.warn("DWG LibreDWG preview failed, falling back to metadata preview:", error);
+    return void 0;
+  }
+}
+function loadLibreDwg() {
+  libreDwgPromise ||= import("@mlightcad/libredwg-web");
+  return libreDwgPromise;
+}
+function createDwgStatusTitle(fileName, stats, reliability) {
+  const wrapper = document.createElement("span");
+  const title = document.createElement("strong");
+  const note = document.createElement("small");
+  title.textContent = reliability.isReliable ? `\u5B9E\u9A8C\u6027 DWG \u6A21\u578B\u7A7A\u95F4\u9884\u89C8 \xB7 ${fileName}` : `DWG \u5185\u7F6E\u9884\u89C8\u56FE \xB7 ${fileName}`;
+  note.textContent = [
+    `${stats.entityCount.toLocaleString()} \u4E2A\u5B9E\u4F53`,
+    `${stats.visibleLayerCount}/${stats.layerCount} \u4E2A\u53EF\u89C1\u56FE\u5C42`,
+    `${stats.layoutCount} \u4E2A\u5E03\u5C40`,
+    stats.paperSpaceEntityCount ? `${stats.paperSpaceEntityCount.toLocaleString()} \u4E2A\u56FE\u7EB8\u7A7A\u95F4\u5B9E\u4F53` : "\u6A21\u578B\u7A7A\u95F4\u7EBF\u7A3F",
+    stats.unknownEntityCount ? `${stats.unknownEntityCount} \u4E2A\u672A\u77E5\u5B9E\u4F53` : "\u5B9E\u4F53\u89E3\u6790\u5B8C\u6574",
+    stats.hasThumbnail ? "\u5305\u542B\u5185\u7F6E\u7F29\u7565\u56FE" : "\u65E0\u5185\u7F6E\u7F29\u7565\u56FE"
+  ].join(" \xB7 ");
+  const warning = document.createElement("small");
+  warning.textContent = reliability.isReliable ? "\u5F53\u524D\u4E3A LibreDWG WASM \u7EBF\u7A3F\u9884\u89C8\uFF0C\u590D\u6742\u5E03\u5C40/\u6253\u5370\u7A7A\u95F4/\u5B57\u4F53/\u586B\u5145\u4E0E\u4E13\u4E1A CAD \u4ECD\u53EF\u80FD\u5B58\u5728\u5DEE\u5F02\u3002" : `LibreDWG \u7EBF\u7A3F\u68C0\u6D4B\u5230\u5F02\u5E38\u56FE\u5143\uFF0C\u5DF2\u4F18\u5148\u663E\u793A\u6587\u4EF6\u5185\u7F6E\u9884\u89C8\u56FE\u3002${reliability.reason ?? ""}`;
+  wrapper.append(title, note, warning);
+  return wrapper;
+}
+function createDwgThumbnailFallbackStatus(fileName, error) {
+  const wrapper = document.createElement("span");
+  const title = document.createElement("strong");
+  title.textContent = `DWG \u5185\u7F6E\u9884\u89C8\u56FE \xB7 ${fileName}`;
+  const note = document.createElement("small");
+  note.textContent = "LibreDWG \u5DF2\u8BFB\u53D6\u5230\u6587\u4EF6\u5185\u7F6E\u7F29\u7565\u56FE\uFF0C\u4F46\u7EBF\u7A3F\u9884\u89C8\u672A\u80FD\u751F\u6210\uFF0C\u5DF2\u81EA\u52A8\u5207\u6362\u4E3A\u7F29\u7565\u56FE\u515C\u5E95\u3002";
+  const detail = document.createElement("small");
+  detail.textContent = error instanceof Error ? error.message : String(error || "\u672A\u77E5\u89E3\u6790\u9519\u8BEF");
+  wrapper.append(title, note, detail);
+  return wrapper;
+}
+function createDwgPreviewStats(database, unknownEntityCount, hasThumbnail) {
+  const layers = database.tables.LAYER.entries;
+  return {
+    entityCount: database.entities.length,
+    layerCount: layers.length,
+    layoutCount: database.objects.LAYOUT.length,
+    unknownEntityCount,
+    visibleLayerCount: layers.filter((layer) => !layer.off && !layer.frozen).length,
+    paperSpaceEntityCount: database.entities.filter((entity) => entity.isInPaperSpace).length,
+    hasThumbnail
+  };
+}
+function readDwgThumbnail(libredwg, data) {
+  try {
+    const thumbnail = libredwg.dwg_bmp(data);
+    if (!thumbnail?.data?.length) {
+      return void 0;
+    }
+    return thumbnail;
+  } catch {
+    return void 0;
+  }
+}
+function createDwgThumbnailUrl(thumbnail) {
+  if (!thumbnail) {
+    return void 0;
+  }
+  if (thumbnail.type === 6) {
+    return URL.createObjectURL(new Blob([toArrayBuffer(thumbnail.data)], { type: "image/png" }));
+  }
+  if (thumbnail.type === 2) {
+    return URL.createObjectURL(new Blob([toArrayBuffer(createBmpFileBytes(thumbnail.data))], { type: "image/bmp" }));
+  }
+  return void 0;
+}
+function toArrayBuffer(bytes) {
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+function createBmpFileBytes(dibBytes) {
+  const view3 = new DataView(dibBytes.buffer, dibBytes.byteOffset, dibBytes.byteLength);
+  const headerSize = view3.getUint32(0, true);
+  const bitCount = view3.getUint16(14, true);
+  const paletteBytes = bitCount <= 8 ? 2 ** bitCount * 4 : 0;
+  const pixelOffset = 14 + headerSize + paletteBytes;
+  const bytes = new Uint8Array(14 + dibBytes.byteLength);
+  bytes[0] = 66;
+  bytes[1] = 77;
+  const fileView = new DataView(bytes.buffer);
+  fileView.setUint32(2, bytes.byteLength, true);
+  fileView.setUint32(10, pixelOffset, true);
+  bytes.set(dibBytes, 14);
+  return bytes;
+}
+function createDwgThumbnailPanel(thumbnailUrl) {
+  const panel = document.createElement("figure");
+  panel.className = "ofv-dwg-thumbnail";
+  const image = document.createElement("img");
+  image.src = thumbnailUrl;
+  image.alt = "DWG \u6587\u4EF6\u5185\u7F6E\u7F29\u7565\u56FE";
+  const caption = document.createElement("figcaption");
+  caption.textContent = "\u6587\u4EF6\u5185\u7F6E\u7F29\u7565\u56FE";
+  panel.append(image, caption);
+  return panel;
+}
+function createDwgThumbnailPreview(thumbnailUrl, fileName) {
+  const figure = document.createElement("figure");
+  figure.className = "ofv-dwg-thumbnail-preview";
+  const image = document.createElement("img");
+  image.src = thumbnailUrl;
+  image.alt = `${fileName} \u5185\u7F6E\u9884\u89C8\u56FE`;
+  const caption = document.createElement("figcaption");
+  caption.textContent = "DWG \u6587\u4EF6\u5185\u7F6E\u9884\u89C8\u56FE\u3002\u82E5\u9700\u8981\u63A5\u8FD1 CAD \u5E03\u5C40/\u6253\u5370\u7A7A\u95F4\u7684\u9AD8\u4FDD\u771F\u6548\u679C\uFF0C\u8BF7\u4F7F\u7528\u540C\u540D PNG\u3001SVG\u3001PDF \u5BFC\u51FA\u56FE\uFF0C\u6216\u901A\u8FC7 binaryRenderer \u63A5\u5165\u4E13\u4E1A CAD \u6E32\u67D3/\u8F6C\u6362\u670D\u52A1\u3002";
+  figure.append(image, caption);
+  return figure;
+}
+function normalizeDwgSvg(svgElement) {
+  svgElement.setAttribute("preserveAspectRatio", "xMidYMid meet");
+  removeInheritedDwgFills(svgElement);
+  focusDwgSvgOnMainDrawing(svgElement);
+  const style = document.createElementNS("http://www.w3.org/2000/svg", "style");
+  style.textContent = `
+    .ofv-dwg-preview-svg { background: #020617; }
+    .ofv-dwg-preview-svg g {
+      fill: none !important;
+    }
+    .ofv-dwg-preview-svg line,
+    .ofv-dwg-preview-svg path,
+    .ofv-dwg-preview-svg polyline,
+    .ofv-dwg-preview-svg polygon,
+    .ofv-dwg-preview-svg circle,
+    .ofv-dwg-preview-svg ellipse,
+    .ofv-dwg-preview-svg rect {
+      fill: none !important;
+      vector-effect: non-scaling-stroke;
+      stroke-width: 0.7px !important;
+      stroke-linecap: round;
+      stroke-linejoin: round;
+    }
+    .ofv-dwg-preview-svg [stroke="rgb(0,255,0)"] {
+      stroke: #34d399 !important;
+      stroke-opacity: 0.58 !important;
+    }
+    .ofv-dwg-preview-svg text {
+      vector-effect: non-scaling-stroke;
+      stroke-width: 0 !important;
+      fill: currentColor !important;
+    }
+  `;
+  svgElement.prepend(style);
+}
+function removeInheritedDwgFills(svgElement) {
+  const shapeSelector = "line,path,polyline,polygon,circle,ellipse,rect";
+  for (const group of svgElement.querySelectorAll("g[fill]")) {
+    group.setAttribute("fill", "none");
+  }
+  for (const styledElement of svgElement.querySelectorAll("[style]")) {
+    styledElement.style.fill = "none";
+  }
+  for (const shape of svgElement.querySelectorAll(shapeSelector)) {
+    shape.setAttribute("fill", "none");
+  }
+}
+function assessDwgSvgReliability(svgElement) {
+  const bounds = readSvgViewBox(svgElement);
+  if (!bounds) {
+    return { isReliable: true };
+  }
+  const largePathCount = countLargeSvgPaths(svgElement, bounds);
+  const totalPathCount = svgElement.querySelectorAll("path").length;
+  if (largePathCount >= 24 && totalPathCount > 0 && largePathCount / totalPathCount > 0.08) {
+    return {
+      isReliable: false,
+      reason: "\u8BE5\u6587\u4EF6\u5305\u542B\u5927\u91CF\u8D85\u51FA\u4E3B\u4F53\u89C6\u53E3\u7684\u5927\u8DEF\u5F84/\u5757\u53C2\u7167\uFF0C\u7EBF\u7A3F\u6A21\u5F0F\u4F1A\u660E\u663E\u504F\u79BB CAD \u5E03\u5C40\u3002"
+    };
+  }
+  return { isReliable: true };
+}
+function countLargeSvgPaths(svgElement, bounds) {
+  let count = 0;
+  const viewportArea = bounds.width * bounds.height;
+  if (!Number.isFinite(viewportArea) || viewportArea <= 0) {
+    return count;
+  }
+  for (const path of svgElement.querySelectorAll("path")) {
+    if (path.closest("defs")) {
+      continue;
+    }
+    const pathBounds = estimatePathBounds(path);
+    if (!pathBounds) {
+      continue;
+    }
+    const pathArea = pathBounds.width * pathBounds.height;
+    const crossesViewport = pathBounds.minX <= bounds.minX + bounds.width * 0.02 || pathBounds.minY <= bounds.minY + bounds.height * 0.02;
+    if (pathArea > viewportArea * 0.28 || crossesViewport && pathArea > viewportArea * 0.12) {
+      count += 1;
+    }
+  }
+  return count;
+}
+function estimatePathBounds(path) {
+  const numbers = readNumbers(path.getAttribute("d") ?? "");
+  if (numbers.length < 4) {
+    return void 0;
+  }
+  let minX = Number.POSITIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let maxX = Number.NEGATIVE_INFINITY;
+  let maxY = Number.NEGATIVE_INFINITY;
+  for (let index = 0; index + 1 < numbers.length; index += 2) {
+    const x = numbers[index];
+    const y = numbers[index + 1];
+    if (!Number.isFinite(x) || !Number.isFinite(y) || Math.abs(x) > 1e9 || Math.abs(y) > 1e9) {
+      continue;
+    }
+    minX = Math.min(minX, x);
+    minY = Math.min(minY, y);
+    maxX = Math.max(maxX, x);
+    maxY = Math.max(maxY, y);
+  }
+  if (!Number.isFinite(minX) || !Number.isFinite(minY) || !Number.isFinite(maxX) || !Number.isFinite(maxY)) {
+    return void 0;
+  }
+  return { minX, minY, width: maxX - minX, height: maxY - minY };
+}
+function focusDwgSvgOnMainDrawing(svgElement) {
+  const originalBounds = readSvgViewBox(svgElement);
+  const mainBounds = estimateMainDrawingBounds(svgElement);
+  if (!originalBounds || !mainBounds || !shouldUseMainDrawingBounds(originalBounds, mainBounds)) {
+    return;
+  }
+  const paddedBounds = padBounds(mainBounds, 0.05);
+  svgElement.dataset.originalViewBox = formatViewBox(originalBounds);
+  svgElement.dataset.focusViewBox = formatViewBox(paddedBounds);
+  svgElement.setAttribute("viewBox", formatViewBox(paddedBounds));
+}
+function shouldUseMainDrawingBounds(original, candidate) {
+  const originalAspectRatio = original.width / original.height;
+  const candidateAspectRatio = candidate.width / candidate.height;
+  const originalArea = original.width * original.height;
+  const candidateArea = candidate.width * candidate.height;
+  if (!Number.isFinite(originalArea) || !Number.isFinite(candidateArea) || candidateArea <= 0) {
+    return false;
+  }
+  return originalAspectRatio > 8 || originalAspectRatio < 0.125 || candidateArea / originalArea < 0.55 || Math.abs(Math.log(originalAspectRatio / candidateAspectRatio)) > Math.log(4);
+}
+function estimateMainDrawingBounds(svgElement) {
+  const points = [];
+  const addPoint = (x, y) => {
+    if (Number.isFinite(x) && Number.isFinite(y) && Math.abs(x) < 1e9 && Math.abs(y) < 1e9) {
+      points.push([x, y]);
+    }
+  };
+  for (const element of svgElement.querySelectorAll("line,path,polyline,polygon,circle,ellipse,rect,text,use")) {
+    if (element.closest("defs")) {
+      continue;
+    }
+    collectElementPoints(element, addPoint);
+  }
+  if (points.length < 16) {
+    return void 0;
+  }
+  const xs = points.map(([x]) => x).sort((a, b) => a - b);
+  const ys = points.map(([, y]) => y).sort((a, b) => a - b);
+  const minX = quantile(xs, 5e-3);
+  const maxX = quantile(xs, 0.995);
+  const minY = quantile(ys, 5e-3);
+  const maxY = quantile(ys, 0.995);
+  if (!Number.isFinite(minX) || !Number.isFinite(maxX) || !Number.isFinite(minY) || !Number.isFinite(maxY)) {
+    return void 0;
+  }
+  const width = maxX - minX;
+  const height = maxY - minY;
+  if (width <= 0 || height <= 0) {
+    return void 0;
+  }
+  return { minX, minY, width, height };
+}
+function collectElementPoints(element, addPoint) {
+  const tagName = element.tagName.toLowerCase();
+  if (tagName === "line") {
+    addPoint(readNumberAttribute(element, "x1"), readNumberAttribute(element, "y1"));
+    addPoint(readNumberAttribute(element, "x2"), readNumberAttribute(element, "y2"));
+  } else if (tagName === "circle") {
+    const cx = readNumberAttribute(element, "cx");
+    const cy = readNumberAttribute(element, "cy");
+    const r = readNumberAttribute(element, "r");
+    addPoint(cx - r, cy - r);
+    addPoint(cx + r, cy + r);
+  } else if (tagName === "ellipse") {
+    const cx = readNumberAttribute(element, "cx");
+    const cy = readNumberAttribute(element, "cy");
+    const rx = readNumberAttribute(element, "rx");
+    const ry = readNumberAttribute(element, "ry");
+    addPoint(cx - rx, cy - ry);
+    addPoint(cx + rx, cy + ry);
+  } else if (tagName === "rect") {
+    const x = readNumberAttribute(element, "x");
+    const y = readNumberAttribute(element, "y");
+    addPoint(x, y);
+    addPoint(x + readNumberAttribute(element, "width"), y + readNumberAttribute(element, "height"));
+  } else if (tagName === "text") {
+    addPoint(readNumberAttribute(element, "x"), readNumberAttribute(element, "y"));
+  } else if (tagName === "path") {
+    collectNumberPairs(element.getAttribute("d"), addPoint);
+  } else if (tagName === "polyline" || tagName === "polygon") {
+    collectNumberPairs(element.getAttribute("points"), addPoint);
+  }
+  collectTranslatePoints(element.getAttribute("transform"), addPoint);
+}
+function collectNumberPairs(value, addPoint) {
+  if (!value) {
+    return;
+  }
+  const numbers = readNumbers(value);
+  for (let index = 0; index + 1 < numbers.length; index += 2) {
+    addPoint(numbers[index], numbers[index + 1]);
+  }
+}
+function collectTranslatePoints(value, addPoint) {
+  if (!value) {
+    return;
+  }
+  const translatePattern = /translate\(\s*(-?\d*\.?\d+(?:e[-+]?\d+)?)(?:[\s,]+(-?\d*\.?\d+(?:e[-+]?\d+)?))?/gi;
+  for (const match of value.matchAll(translatePattern)) {
+    addPoint(Number(match[1]), Number(match[2] ?? 0));
+  }
+}
+function readNumbers(value) {
+  const matches = value.match(svgNumberPattern);
+  return matches ? matches.map((item) => Number(item)).filter(Number.isFinite) : [];
+}
+function readNumberAttribute(element, name) {
+  const value = Number(element.getAttribute(name) ?? 0);
+  return Number.isFinite(value) ? value : 0;
+}
+function quantile(values, ratio) {
+  const index = Math.max(0, Math.min(values.length - 1, Math.floor((values.length - 1) * ratio)));
+  return values[index];
+}
+function padBounds(bounds, ratio) {
+  const paddingX = bounds.width * ratio;
+  const paddingY = bounds.height * ratio;
+  return {
+    minX: bounds.minX - paddingX,
+    minY: bounds.minY - paddingY,
+    width: bounds.width + paddingX * 2,
+    height: bounds.height + paddingY * 2
+  };
+}
+function formatViewBox(bounds) {
+  return [bounds.minX, bounds.minY, bounds.width, bounds.height].map((value) => Number(value.toFixed(4))).join(" ");
+}
+function createDwgDrawingViewport(svgElement) {
+  const frame = document.createElement("div");
+  frame.className = "ofv-dwg-preview-frame";
+  const importedSvg = document.importNode(svgElement, true);
+  frame.append(importedSvg);
+  const aspectRatio = readSvgAspectRatio(svgElement);
+  let zoom = 1;
+  const update = () => {
+    const frameWidth = Math.max(frame.clientWidth, 1);
+    const readableWidth = aspectRatio ? minReadableDrawingHeight * aspectRatio : frameWidth;
+    const width = Math.max(frameWidth, readableWidth) * zoom;
+    importedSvg.style.width = `${Math.round(width)}px`;
+    importedSvg.style.minWidth = `${Math.round(width)}px`;
+  };
+  const setZoom = (nextZoom) => {
+    zoom = Math.min(Math.max(nextZoom, 0.2), 8);
+    update();
+  };
+  requestAnimationFrame(update);
+  return {
+    frame,
+    get zoom() {
+      return zoom;
+    },
+    setZoom,
+    update
+  };
+}
+function readSvgAspectRatio(svgElement) {
+  const viewBox = readSvgViewBox(svgElement);
+  return viewBox ? viewBox.width / viewBox.height : void 0;
+}
+function readSvgViewBox(svgElement) {
+  const viewBox = svgElement.getAttribute("viewBox");
+  if (!viewBox) {
+    return void 0;
+  }
+  const [minX, minY, width, height] = viewBox.trim().split(/[\s,]+/).map((value) => Number(value));
+  if (!Number.isFinite(minX) || !Number.isFinite(minY) || !Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+    return void 0;
+  }
+  return { minX, minY, width, height };
+}
+
+// src/plugins/cad.ts
+var cadExtensions = /* @__PURE__ */ new Set([
+  "dxf",
+  "dwg",
+  "dwf",
+  "step",
+  "stp",
+  "iges",
+  "igs",
+  "ifc",
+  "sat",
+  "sab",
+  "x_t",
+  "x_b",
+  "3dm",
+  "skp",
+  "sldprt",
+  "sldasm",
+  "gds",
+  "oas",
+  "oasis"
+]);
+var cadMimeTypes = /* @__PURE__ */ new Set([
+  "application/acad",
+  "application/dxf",
+  "application/x-dxf",
+  "image/vnd.dxf",
+  "model/vnd.dwf",
+  "model/step",
+  "application/step",
+  "application/iges",
+  "application/x-step",
+  "application/sat",
+  "application/sab",
+  "application/x-parasolid",
+  "model/vnd.3dm",
+  "application/vnd.sketchup.skp",
+  "application/sldworks",
+  "application/vnd.gds",
+  "application/x-gdsii",
+  "application/vnd.oasis.layout",
+  "application/x-oasis-layout"
+]);
+var cadMimeFormatMap = {
+  "application/acad": "dwg",
+  "application/dxf": "dxf",
+  "application/x-dxf": "dxf",
+  "image/vnd.dxf": "dxf",
+  "model/vnd.dwf": "dwf",
+  "model/step": "step",
+  "application/step": "step",
+  "application/iges": "iges",
+  "application/x-step": "ifc",
+  "application/sat": "sat",
+  "application/sab": "sab",
+  "application/x-parasolid": "x_t",
+  "model/vnd.3dm": "3dm",
+  "application/vnd.sketchup.skp": "skp",
+  "application/sldworks": "sldprt",
+  "application/vnd.gds": "gds",
+  "application/x-gdsii": "gds",
+  "application/vnd.oasis.layout": "oas",
+  "application/x-oasis-layout": "oas"
+};
+function cadPlugin(options = {}) {
+  return {
+    name: "cad",
+    match(file) {
+      return cadExtensions.has(file.extension) || cadMimeTypes.has(file.mimeType);
+    },
+    async render(ctx) {
+      const panel = createPanel("ofv-cad");
+      ctx.viewport.append(panel);
+      const extension = resolveFormat(ctx.file, cadMimeFormatMap);
+      if (extension === "step" || extension === "stp") {
+        renderStep(panel, await readTextFile(ctx.file), extension);
+        return { destroy: () => panel.remove() };
+      }
+      if (extension === "iges" || extension === "igs") {
+        renderIges(panel, await readTextFile(ctx.file), extension);
+        return { destroy: () => panel.remove() };
+      }
+      if (extension === "ifc") {
+        renderIfc(panel, await readTextFile(ctx.file));
+        return { destroy: () => panel.remove() };
+      }
+      if (extension === "dwg" || extension === "dwf") {
+        const arrayBuffer = await readArrayBuffer(ctx.file);
+        const bytes = new Uint8Array(arrayBuffer);
+        const enhancedInstance = await options.binaryRenderer?.({
+          panel,
+          fileName: ctx.file.name,
+          extension,
+          arrayBuffer,
+          bytes,
+          preview: ctx
+        });
+        if (enhancedInstance) {
+          return {
+            resize(size) {
+              enhancedInstance.resize?.(size);
+            },
+            canCommand(command) {
+              return enhancedInstance.canCommand?.(command) ?? false;
+            },
+            command(command) {
+              return enhancedInstance.command?.(command);
+            },
+            destroy() {
+              enhancedInstance.destroy();
+              panel.remove();
+            }
+          };
+        }
+        if (extension === "dwg" && options.libreDwg !== false) {
+          const libreDwgInstance = await renderLibreDwgPreview(
+            {
+              panel,
+              fileName: ctx.file.name,
+              extension,
+              arrayBuffer,
+              bytes,
+              preview: ctx
+            },
+            typeof options.libreDwg === "object" ? options.libreDwg : void 0
+          );
+          if (libreDwgInstance) {
+            return {
+              resize(size) {
+                libreDwgInstance.resize?.(size);
+              },
+              canCommand(command) {
+                return libreDwgInstance.canCommand?.(command) ?? false;
+              },
+              command(command) {
+                return libreDwgInstance.command?.(command);
+              },
+              destroy() {
+                libreDwgInstance.destroy();
+                panel.remove();
+              }
+            };
+          }
+        }
+        renderBinaryCad(panel, bytes, 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`);
+        panel.append(section);
+        return { destroy: () => panel.remove() };
+      }
+      const dxf = await readTextFile(ctx.file);
+      const viewer = renderDxf(panel, dxf, ctx);
+      return {
+        canCommand(command) {
+          return viewer.canCommand(command);
+        },
+        command(command) {
+          return viewer.command(command);
+        },
+        destroy() {
+          panel.remove();
+        }
+      };
+    }
+  };
+}
+function renderStep(panel, text, extension) {
+  const records = parseStepRecords(text);
+  const typeCounts = countBy(records.map((record) => record.type));
+  const section = createSection(`${extension.toUpperCase()} \u7ED3\u6784\u9884\u89C8`);
+  const note = document.createElement("p");
+  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);
@@ -10027,11 +11035,564 @@ function renderIfc(panel, text) {
   section.append(table);
   panel.append(section);
 }
-function renderBinaryCad(panel, arrayBuffer, extension, fileName) {
-  const bytes = new Uint8Array(arrayBuffer);
+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 = import_pako3.default.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, bytes, extension, fileName) {
   const section = createSection(`${extension.toUpperCase()} \u6587\u4EF6\u9884\u89C8`);
   const note = document.createElement("p");
-  note.textContent = extension === "dwg" ? "DWG \u662F AutoCAD \u4E13\u6709\u4E8C\u8FDB\u5236\u683C\u5F0F\uFF0C\u5F53\u524D\u524D\u7AEF\u63D2\u4EF6\u63D0\u4F9B\u6587\u4EF6\u8BC6\u522B\u3001\u7248\u672C\u63D0\u793A\u548C\u8F6C\u6362\u5EFA\u8BAE\uFF1B\u51E0\u4F55\u6E32\u67D3\u5EFA\u8BAE\u63A5\u5165 ODA/LibreDWG/\u670D\u52A1\u7AEF\u8F6C\u6362\u3002" : "DWF \u662F\u53D1\u5E03\u7528\u56FE\u7EB8\u683C\u5F0F\uFF0C\u5F53\u524D\u524D\u7AEF\u63D2\u4EF6\u63D0\u4F9B\u5BB9\u5668\u8BC6\u522B\u548C\u8F6C\u6362\u5EFA\u8BAE\uFF1B\u9AD8\u4FDD\u771F\u9875\u9762\u6E32\u67D3\u5EFA\u8BAE\u63A5\u5165\u4E13\u7528\u89E3\u6790\u5668\u6216\u670D\u52A1\u7AEF\u8F6C\u6362\u3002";
+  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);
@@ -10040,33 +11601,41 @@ function renderBinaryCad(panel, arrayBuffer, extension, fileName) {
   appendMeta5(meta, "\u7B7E\u540D", byteSignature2(bytes));
   appendMeta5(meta, "\u7248\u672C", detectCadVersion(bytes, extension));
   appendMeta5(meta, "\u5BB9\u5668", detectCadContainer(bytes));
-  const actions = document.createElement("ol");
+  const actions = document.createElement("div");
   actions.className = "ofv-cad-conversion";
+  const actionTitle = document.createElement("h4");
+  actionTitle.textContent = extension === "dwg" ? "\u63A8\u8350\u589E\u5F3A\u8DEF\u7EBF" : "\u63A8\u8350\u5904\u7406\u8DEF\u7EBF";
+  const actionList = document.createElement("ol");
   const suggestions = extension === "dwg" ? [
-    "\u670D\u52A1\u7AEF\u4F7F\u7528 ODA File Converter / Teigha \u5C06 DWG \u8F6C\u4E3A DXF\u3001SVG \u6216 PDF\u3002",
-    "\u6D4F\u89C8\u5668\u7AEF\u53EF\u540E\u7EED\u63A5\u5165 LibreDWG WASM\uFF0C\u4F46\u9700\u5904\u7406\u5B57\u4F53\u3001\u5757\u53C2\u7167\u3001\u5916\u90E8\u53C2\u7167\u548C\u8BB8\u53EF\u8BC1\u3002",
-    "\u82E5\u4E1A\u52A1\u53EA\u9700\u9884\u89C8\uFF0C\u5EFA\u8BAE\u8F6C\u6362\u4E3A PDF/SVG \u540E\u8D70\u73B0\u6709 PDF \u6216\u56FE\u50CF\u9884\u89C8\u94FE\u8DEF\u3002"
+    "\u4EA7\u54C1\u9ED8\u8BA4\u94FE\u8DEF\uFF1A\u670D\u52A1\u7AEF\u5C06 DWG \u8F6C\u4E3A PDF/SVG/DXF\uFF0C\u518D\u590D\u7528\u73B0\u6709 PDF\u3001\u56FE\u50CF\u6216 DXF \u9884\u89C8\u3002",
+    "\u7EAF\u524D\u7AEF\u589E\u5F3A\uFF1A\u901A\u8FC7 binaryRenderer \u63A5\u5165 mlightcad / LibreDWG WASM \u4E00\u7C7B\u5F15\u64CE\uFF0C\u6309\u9700\u52A0\u8F7D worker \u548C\u5B57\u4F53\u8D44\u6E90\u3002",
+    "\u5546\u7528\u9AD8\u4FDD\u771F\uFF1A\u63A5\u5165 ODA Drawings SDK / Web SDK\uFF0C\u9002\u5408\u590D\u6742\u56FE\u5C42\u3001\u5B57\u4F53\u3001\u5916\u90E8\u53C2\u7167\u548C\u5927\u56FE\u7EB8\u3002"
   ] : [
     "\u4F18\u5148\u5728\u670D\u52A1\u7AEF\u8F6C\u6362\u4E3A PDF/SVG\uFF0C\u4FDD\u7559\u56FE\u5C42\u3001\u9875\u9762\u548C\u6807\u6CE8\u4FE1\u606F\u3002",
-    "\u82E5 DWF \u4E3A\u538B\u7F29\u5BB9\u5668\uFF0C\u53EF\u540E\u7EED\u8BFB\u53D6 manifest/descriptor \u518D\u8FD8\u539F\u9875\u9762\u8D44\u6E90\u3002",
+    "\u82E5 DWF \u4E3A\u538B\u7F29\u5BB9\u5668\uFF0C\u53EF\u901A\u8FC7 binaryRenderer \u8BFB\u53D6 manifest/descriptor \u518D\u8FD8\u539F\u9875\u9762\u8D44\u6E90\u3002",
     "\u82E5\u4E1A\u52A1\u53EA\u9700\u4E0B\u8F7D/\u5F52\u6863\uFF0C\u4FDD\u7559\u5F53\u524D\u6587\u4EF6\u5143\u4FE1\u606F\u548C\u8F6C\u6362\u63D0\u793A\u5373\u53EF\u3002"
   ];
   for (const suggestion of suggestions) {
     const item = document.createElement("li");
     item.textContent = suggestion;
-    actions.append(item);
+    actionList.append(item);
   }
+  actions.append(actionTitle, actionList);
+  const raw = document.createElement("details");
+  raw.className = "ofv-details ofv-cad-raw-preview";
+  const rawSummary = document.createElement("summary");
+  rawSummary.textContent = "\u539F\u59CB\u5B57\u8282\u9884\u89C8";
   const preview = document.createElement("pre");
   preview.className = "ofv-text-block";
   preview.textContent = hexPreview(bytes);
-  section.append(note, meta, createBinaryCadProbe(bytes, extension), actions, preview);
+  raw.append(rawSummary, preview);
+  section.append(note, meta, actions, createBinaryCadProbe(bytes, extension), raw);
   panel.append(section);
 }
 function createBinaryCadProbe(bytes, extension) {
   const probe = probeBinaryCad(bytes);
   const details = document.createElement("details");
   details.className = "ofv-details ofv-cad-binary-probe";
-  details.open = true;
   const summary = document.createElement("summary");
   summary.textContent = "\u4E8C\u8FDB\u5236\u7ED3\u6784\u63A2\u6D4B";
   const meta = document.createElement("div");
@@ -11670,6 +13239,15 @@ function assetPlugin() {
       const isExternal = Boolean(ctx.file.url);
       const extension = resolveFormat(ctx.file, assetMimeFormatMap).toLowerCase();
       const bytes = new Uint8Array(await readArrayBuffer(ctx.file).catch(() => new ArrayBuffer(0)));
+      if (isPhotoshopAsset(extension)) {
+        panel.append(await createPhotoshopPreview(bytes));
+        return {
+          destroy() {
+            revokeObjectUrl(url, isExternal);
+            panel.remove();
+          }
+        };
+      }
       const section = createSection(assetTitle(extension));
       const summary = document.createElement("div");
       summary.className = "ofv-asset-summary";
@@ -11691,9 +13269,6 @@ function assetPlugin() {
       if (extension === "wasm") {
         section.append(createWasmPreview(bytes));
       }
-      if (extension === "psd" || extension === "psb") {
-        section.append(createPhotoshopPreview(bytes));
-      }
       if (extension === "sqlite" || extension === "sqlite3" || extension === "db") {
         section.append(createSqlitePreview(bytes));
       }
@@ -11746,7 +13321,7 @@ function assetGuidance(extension) {
     return "\u5B57\u4F53\u6587\u4EF6\u5DF2\u8BC6\u522B\uFF0C\u5F53\u524D\u4F1A\u4F7F\u7528 FontFace \u5C55\u793A\u5B57\u5F62\u6837\u5F20\uFF0C\u5E76\u89E3\u6790 sfnt/WOFF \u8868\u76EE\u5F55\u548C name \u5143\u4FE1\u606F\u3002";
   }
   if (extension === "psd" || extension === "psb") {
-    return "PSD/PSB \u5DF2\u8BC6\u522B\uFF0C\u5F53\u524D\u4F1A\u89E3\u6790\u57FA\u7840\u753B\u5E03\u3001\u901A\u9053\u3001\u4F4D\u6DF1\u548C\u989C\u8272\u6A21\u5F0F\uFF1B\u56FE\u5C42\u7F29\u7565\u56FE\u53EF\u540E\u7EED\u63A5\u5165 psd.js/WASM \u6216\u670D\u52A1\u7AEF\u8F6C\u6362\u3002";
+    return "PSD/PSB \u5DF2\u8BC6\u522B\uFF0C\u5F53\u524D\u4F1A\u4F18\u5148\u89E3\u6790 Photoshop \u5408\u6210\u56FE\u9884\u89C8\uFF0C\u5E76\u4FDD\u7559\u753B\u5E03\u3001\u901A\u9053\u3001\u4F4D\u6DF1\u548C\u989C\u8272\u6A21\u5F0F\u7B49\u7ED3\u6784\u4FE1\u606F\u3002";
   }
   if (["ai", "eps", "ps"].includes(extension)) {
     return "PostScript/Illustrator \u6587\u4EF6\u5DF2\u8BC6\u522B\uFF0C\u5F53\u524D\u4F1A\u89E3\u6790\u6587\u6863\u5934\u3001BoundingBox \u548C\u5E38\u89C1 DSC \u5143\u4FE1\u606F\uFF1B\u9AD8\u4FDD\u771F\u56FE\u5F62\u53EF\u540E\u7EED\u63A5\u5165 Ghostscript/Illustrator \u8F6C\u6362\u3002";
@@ -11768,6 +13343,9 @@ function assetGuidance(extension) {
 function isFontAsset(extension) {
   return ["ttf", "otf", "woff", "woff2", "eot"].includes(extension);
 }
+function isPhotoshopAsset(extension) {
+  return extension === "psd" || extension === "psb";
+}
 async function createFontPreview(extension, url, fileName, bytes) {
   const preview = document.createElement("div");
   preview.className = "ofv-font-preview";
@@ -12529,12 +14107,9 @@ function wasmExternalKind(kind) {
   };
   return names[kind] || `unknown ${kind}`;
 }
-function createPhotoshopPreview(bytes) {
+async function createPhotoshopPreview(bytes) {
   const preview = document.createElement("div");
   preview.className = "ofv-psd-preview";
-  const heading = document.createElement("strong");
-  heading.textContent = "Photoshop \u7ED3\u6784";
-  preview.append(heading);
   const header = parsePhotoshopHeader(bytes);
   if (!header.valid) {
     const error = document.createElement("p");
@@ -12543,16 +14118,66 @@ function createPhotoshopPreview(bytes) {
     preview.append(error);
     return preview;
   }
-  const summary = document.createElement("div");
-  summary.className = "ofv-psd-summary";
-  appendMeta(summary, "\u7248\u672C", header.version === 2 ? "PSB \u5927\u6587\u6863" : "PSD");
-  appendMeta(summary, "\u753B\u5E03", `${header.width} x ${header.height}px`);
-  appendMeta(summary, "\u901A\u9053", header.channels ?? "\u672A\u77E5");
-  appendMeta(summary, "\u4F4D\u6DF1", `${header.depth ?? "\u672A\u77E5"} bit`);
-  appendMeta(summary, "\u989C\u8272\u6A21\u5F0F", photoshopColorMode(header.colorMode ?? -1));
-  preview.append(summary);
+  preview.append(await createPhotoshopCompositePreview(bytes, header));
   return preview;
 }
+async function createPhotoshopCompositePreview(bytes, header) {
+  const wrapper = document.createElement("div");
+  wrapper.className = "ofv-psd-composite";
+  if (!canUseBrowserCanvas()) {
+    const status = document.createElement("p");
+    status.className = "ofv-psd-error";
+    status.textContent = "\u5F53\u524D\u73AF\u5883\u4E0D\u652F\u6301 Canvas\uFF0C\u65E0\u6CD5\u751F\u6210 PSD \u5408\u6210\u56FE\u9884\u89C8\u3002";
+    wrapper.append(status);
+    return wrapper;
+  }
+  try {
+    const { readPsd } = await import("ag-psd");
+    const psd = readPsd(toStandaloneArrayBuffer(bytes), {
+      skipLayerImageData: true,
+      skipThumbnail: true,
+      skipLinkedFilesData: true,
+      useImageData: true,
+      throwForMissingFeatures: false,
+      logMissingFeatures: false
+    });
+    const canvas = psd.canvas || createCanvasFromPsdImageData(psd);
+    if (!canvas) {
+      throw new Error("PSD \u6587\u4EF6\u6CA1\u6709\u53EF\u8BFB\u53D6\u7684\u5408\u6210\u56FE\u50CF\u6570\u636E\u3002\u8BF7\u5728 Photoshop \u4E2D\u5F00\u542F\u201C\u6700\u5927\u517C\u5BB9\u6027\u201D\u4FDD\u5B58\uFF0C\u6216\u63A5\u5165\u5916\u90E8\u8F6C\u6362\u670D\u52A1\u3002");
+    }
+    canvas.classList.add("ofv-psd-canvas");
+    canvas.setAttribute("role", "img");
+    canvas.setAttribute("aria-label", `Photoshop composite ${header.width} x ${header.height}`);
+    wrapper.append(canvas);
+  } catch (error) {
+    const status = document.createElement("p");
+    status.className = "ofv-psd-error";
+    status.textContent = `PSD \u5408\u6210\u56FE\u89E3\u6790\u5931\u8D25\uFF1A${error instanceof Error ? error.message : "\u5F53\u524D\u6587\u4EF6\u7279\u6027\u6682\u4E0D\u652F\u6301\u3002"}`;
+    wrapper.append(status);
+  }
+  return wrapper;
+}
+function canUseBrowserCanvas() {
+  return typeof document !== "undefined" && typeof HTMLCanvasElement !== "undefined";
+}
+function toStandaloneArrayBuffer(bytes) {
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+function createCanvasFromPsdImageData(psd) {
+  const imageData = psd.imageData;
+  if (!imageData || !imageData.width || !imageData.height || !(imageData.data instanceof Uint8ClampedArray)) {
+    return void 0;
+  }
+  const canvas = document.createElement("canvas");
+  canvas.width = imageData.width;
+  canvas.height = imageData.height;
+  const context = canvas.getContext("2d");
+  if (!context) {
+    return void 0;
+  }
+  context.putImageData(new ImageData(new Uint8ClampedArray(imageData.data), imageData.width, imageData.height), 0, 0);
+  return canvas;
+}
 function parsePhotoshopHeader(bytes) {
   if (bytes.length < 26) {
     return { valid: false, error: "\u6587\u4EF6\u592A\u77ED\uFF0C\u65E0\u6CD5\u8BFB\u53D6 PSD/PSB \u5934\u4FE1\u606F\u3002" };
@@ -12581,19 +14206,6 @@ function parsePhotoshopHeader(bytes) {
     colorMode: view3.getUint16(24, false)
   };
 }
-function photoshopColorMode(mode) {
-  const modes = {
-    0: "Bitmap",
-    1: "Grayscale",
-    2: "Indexed",
-    3: "RGB",
-    4: "CMYK",
-    7: "Multichannel",
-    8: "Duotone",
-    9: "Lab"
-  };
-  return modes[mode] ? `${modes[mode]} (${mode})` : `\u672A\u77E5 (${mode})`;
-}
 function createSqlitePreview(bytes) {
   const preview = document.createElement("div");
   preview.className = "ofv-sqlite-preview";