@open-file-viewer/core 0.1.6 → 0.1.7

package/dist/index.cjs

@@ -324,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,
@@ -369,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(".");
@@ -5421,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)}`);
@@ -5449,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);
@@ -5459,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(
@@ -5468,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();
@@ -5578,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);
@@ -5807,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,
@@ -5869,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");
@@ -5919,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);
@@ -9979,6 +10246,521 @@ function decodeDrawioDiagram(value) {
 
 // src/plugins/cad.ts
 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;
+      }
+    } 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();
+          }
+        };
+      }
+      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 {
+        destroy() {
+          URL.revokeObjectURL(thumbnailUrl);
+          shell.remove();
+        }
+      };
+    }
+    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",
@@ -10042,7 +10824,7 @@ var cadMimeFormatMap = {
   "application/vnd.oasis.layout": "oas",
   "application/x-oasis-layout": "oas"
 };
-function cadPlugin() {
+function cadPlugin(options = {}) {
   return {
     name: "cad",
     match(file) {
@@ -10065,7 +10847,64 @@ function cadPlugin() {
         return { destroy: () => panel.remove() };
       }
       if (extension === "dwg" || extension === "dwf") {
-        renderBinaryCad(panel, await readArrayBuffer(ctx.file), extension, ctx.file.name);
+        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") {
@@ -10750,11 +11589,10 @@ function createOasisStructureShapes(cellNames, fallbackCount) {
   }
   return shapes;
 }
-function renderBinaryCad(panel, arrayBuffer, extension, fileName) {
-  const bytes = new Uint8Array(arrayBuffer);
+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);
@@ -10763,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");
@@ -12393,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";
@@ -12414,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));
       }
@@ -12469,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";
@@ -12491,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";
@@ -13252,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");
@@ -13266,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" };
@@ -13304,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";