@open-file-viewer/core 0.1.5 → 0.1.6

package/dist/index.js

@@ -248,6 +248,9 @@ var extensionMimeMap = {
   skp: "application/vnd.sketchup.skp",
   sldprt: "application/sldworks",
   sldasm: "application/sldworks",
+  gds: "application/vnd.gds",
+  oas: "application/vnd.oasis.layout",
+  oasis: "application/vnd.oasis.layout",
   ttf: "font/ttf",
   otf: "font/otf",
   woff: "font/woff",
@@ -1752,6 +1755,7 @@ function imagePlugin() {
       let dragStartY = 0;
       let startOffsetX = 0;
       let startOffsetY = 0;
+      let activePointerId = null;
       const zoomLabel = document.createElement("span");
       zoomLabel.className = "ofv-image-zoom";
       const updateTransform = () => {
@@ -1799,29 +1803,61 @@ function imagePlugin() {
         if (event.button !== 0) {
           return;
         }
+        if (activePointerId !== null && activePointerId !== event.pointerId) {
+          finishDrag(activePointerId);
+        }
         dragging = true;
+        activePointerId = event.pointerId;
         dragStartX = event.clientX;
         dragStartY = event.clientY;
         startOffsetX = offsetX;
         startOffsetY = offsetY;
         stage.classList.add("is-dragging");
-        stage.setPointerCapture(event.pointerId);
+        try {
+          stage.setPointerCapture(event.pointerId);
+        } catch {
+        }
       };
       const onPointerMove = (event) => {
-        if (!dragging) {
+        if (!dragging || event.pointerId !== activePointerId) {
           return;
         }
         offsetX = startOffsetX + event.clientX - dragStartX;
         offsetY = startOffsetY + event.clientY - dragStartY;
         updateTransform();
       };
-      const onPointerUp = (event) => {
+      const finishDrag = (pointerId) => {
+        const captureId = pointerId ?? activePointerId;
         dragging = false;
+        activePointerId = null;
         stage.classList.remove("is-dragging");
-        if (stage.hasPointerCapture(event.pointerId)) {
-          stage.releasePointerCapture(event.pointerId);
+        if (captureId !== null && captureId !== void 0) {
+          try {
+            if (stage.hasPointerCapture(captureId)) {
+              stage.releasePointerCapture(captureId);
+            }
+          } catch {
+          }
         }
       };
+      const onPointerUp = (event) => {
+        if (event.pointerId === activePointerId) {
+          finishDrag(event.pointerId);
+        }
+      };
+      const onLostPointerCapture = (event) => {
+        if (event.pointerId === activePointerId) {
+          finishDrag(null);
+        }
+      };
+      const onPointerLeave = (event) => {
+        if (event.pointerId === activePointerId && event.buttons === 0) {
+          finishDrag(event.pointerId);
+        }
+      };
+      const onWindowBlur = () => {
+        finishDrag();
+      };
       const onWheel = (event) => {
         if (!event.ctrlKey && !event.metaKey) {
           return;
@@ -1833,8 +1869,11 @@ function imagePlugin() {
       stage.addEventListener("pointermove", onPointerMove);
       stage.addEventListener("pointerup", onPointerUp);
       stage.addEventListener("pointercancel", onPointerUp);
+      stage.addEventListener("lostpointercapture", onLostPointerCapture);
+      stage.addEventListener("pointerleave", onPointerLeave);
       stage.addEventListener("wheel", onWheel, { passive: false });
       image.addEventListener("error", showImageFallback);
+      window.addEventListener("blur", onWindowBlur);
       stage.append(image);
       wrapper.append(...showInlineControls ? [controls, stage, infoBar] : [stage, infoBar]);
       ctx.viewport.append(wrapper);
@@ -1881,8 +1920,12 @@ function imagePlugin() {
           stage.removeEventListener("pointermove", onPointerMove);
           stage.removeEventListener("pointerup", onPointerUp);
           stage.removeEventListener("pointercancel", onPointerUp);
+          stage.removeEventListener("lostpointercapture", onLostPointerCapture);
+          stage.removeEventListener("pointerleave", onPointerLeave);
           stage.removeEventListener("wheel", onWheel);
           image.removeEventListener("error", showImageFallback);
+          window.removeEventListener("blur", onWindowBlur);
+          finishDrag();
           wrapper.remove();
           if (convertedBlob) {
             URL.revokeObjectURL(url);
@@ -4031,6 +4074,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 [
@@ -4072,7 +4147,11 @@ function pdfPlugin(options = {}) {
       const doc = await documentTask.promise.catch((error) => {
         viewer.remove();
         ctx.viewport.classList.add("ofv-center");
-        const fallback = createPdfFallback(ctx.file.name, url, normalizePdfError(error));
+        const fallback = isEncryptedError(error) ? createEncryptedFallback(ctx.file, url, {
+          title: "PDF \u5DF2\u52A0\u5BC6\uFF0C\u65E0\u6CD5\u5728\u7EBF\u9884\u89C8",
+          message: "\u8BF7\u4E0B\u8F7D\u540E\u4F7F\u7528\u5BC6\u7801\u6253\u5F00\uFF0C\u6216\u4E0A\u4F20\u89E3\u5BC6\u540E\u7684 PDF \u6587\u4EF6\u3002",
+          action: "\u4E0B\u8F7D PDF"
+        }) : createPdfFallback(ctx.file.name, url, normalizePdfError(error));
         ctx.viewport.append(fallback);
         return void 0;
       });
@@ -4362,9 +4441,6 @@ function normalizePdfError(error) {
   const message = error instanceof Error ? error.message : String(error || "");
   const name = typeof error === "object" && error !== null && "name" in error ? String(error.name) : "";
   const lower = `${name} ${message}`.toLowerCase();
-  if (lower.includes("password")) {
-    return "\u8BE5 PDF \u53D7\u5BC6\u7801\u4FDD\u62A4\uFF0C\u5F53\u524D\u65E0\u6CD5\u5728\u6D4F\u89C8\u5668\u5185\u76F4\u63A5\u9884\u89C8\u3002";
-  }
   if (lower.includes("invalid") || lower.includes("missing") || lower.includes("corrupt")) {
     return "\u8BE5 PDF \u6587\u4EF6\u53EF\u80FD\u5DF2\u635F\u574F\u6216\u683C\u5F0F\u65E0\u6548\u3002";
   }
@@ -5394,6 +5470,10 @@ async function renderSheet(panel, arrayBuffer, extension) {
   }
 }
 function renderSheetFallback(panel, extension, detail) {
+  if (isEncryptedText(detail)) {
+    renderEncryptedOfficeByFileInfo(panel, `.${extension || "sheet"}`, "Office \u6587\u4EF6\u5DF2\u52A0\u5BC6\uFF0C\u65E0\u6CD5\u5728\u7EBF\u9884\u89C8");
+    return;
+  }
   const section = createSection("\u8868\u683C\u89E3\u6790\u5931\u8D25");
   const title = document.createElement("p");
   title.textContent = `.${extension || "sheet"} \u6587\u4EF6\u65E0\u6CD5\u89E3\u6790\u4E3A\u53EF\u9884\u89C8\u8868\u683C\u3002`;
@@ -5404,6 +5484,17 @@ function renderSheetFallback(panel, extension, detail) {
   section.append(title, meta, support);
   panel.append(section);
 }
+function renderEncryptedOfficeByFileInfo(panel, fileLabel, title) {
+  const section = createSection(title);
+  section.classList.add("ofv-encrypted");
+  const message = document.createElement("p");
+  message.textContent = `${fileLabel} \u53EF\u80FD\u5DF2\u52A0\u5BC6\u6216\u53D7\u4FDD\u62A4\u3002\u8BF7\u4E0B\u8F7D\u540E\u4F7F\u7528 Office/WPS \u8F93\u5165\u5BC6\u7801\u6253\u5F00\uFF0C\u6216\u4E0A\u4F20\u89E3\u5BC6\u540E\u7684\u6587\u4EF6\u3002`;
+  section.append(message);
+  panel.append(section);
+}
+function isEncryptedText(value) {
+  return /\b(password|encrypted|encrypt|protected|decrypt|permission|加密|密码|受保护)\b/i.test(value);
+}
 function renderFlatOds(panel, xml) {
   const sheets = parseFlatOds(xml);
   renderParsedSheets(panel, sheets, "FODS \u6587\u4EF6\u672A\u89E3\u6790\u5230\u8868\u683C\u3002");
@@ -6712,7 +6803,7 @@ function ofdPlugin() {
       try {
         zip = await JSZip4.loadAsync(await readArrayBuffer(ctx.file));
       } catch (error) {
-        panel.append(createOfdFallback(ctx.file.name, url, normalizeOfdError(error)));
+        panel.append(createOfdFailure(ctx.file, url, error));
         return {
           destroy() {
             panel.remove();
@@ -6729,7 +6820,7 @@ function ofdPlugin() {
           textFragments.push(...matches);
         }
       } catch (error) {
-        panel.append(createOfdFallback(ctx.file.name, url, normalizeOfdError(error)));
+        panel.append(createOfdFailure(ctx.file, url, error));
         return {
           destroy() {
             panel.remove();
@@ -7354,6 +7445,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";
@@ -7422,7 +7523,9 @@ function archivePlugin() {
       try {
         if (ext === "zip") {
           try {
-            const zip = await JSZip5.loadAsync(await readArrayBuffer(ctx.file));
+            const zip = await JSZip5.loadAsync(await readArrayBuffer(ctx.file), {
+              decodeFileName: decodeZipFileName
+            });
             archiveEntries = Object.values(zip.files).map((entry) => ({
               name: entry.name,
               unsafeName: entry.unsafeOriginalName,
@@ -7431,7 +7534,7 @@ function archivePlugin() {
               read: () => entry.async("arraybuffer")
             }));
           } catch (zipErr) {
-            if (zipErr.message && (zipErr.message.includes("encrypted") || zipErr.message.includes("password") || zipErr.message.includes("protected"))) {
+            if (isEncryptedError(zipErr)) {
               isEncrypted = true;
             } else {
               throw zipErr;
@@ -7464,17 +7567,11 @@ function archivePlugin() {
         parseError = `\u538B\u7F29\u5305\u89E3\u6790\u5931\u8D25\uFF1A${err.message || err}`;
       }
       if (isEncrypted) {
-        const fallback = document.createElement("div");
-        fallback.className = "ofv-fallback";
-        const title = document.createElement("strong");
-        title.textContent = "\u8BE5\u538B\u7F29\u5305\u5DF2\u88AB\u52A0\u5BC6\u4FDD\u62A4";
-        const meta = document.createElement("span");
-        meta.textContent = "\u4E3A\u4E86\u60A8\u7684\u6570\u636E\u5B89\u5168\uFF0C\u672C\u9884\u89C8\u5668\u4E0D\u652F\u6301\u76F4\u63A5\u5728\u7EBF\u89E3\u5BC6\u3002\u8BF7\u4E0B\u8F7D\u6587\u4EF6\u540E\u5728\u672C\u5730\u8F93\u5165\u5BC6\u7801\u89E3\u538B\u3002";
-        const download = document.createElement("a");
-        download.href = url;
-        download.download = ctx.file.name;
-        download.textContent = "\u4E0B\u8F7D\u6587\u4EF6";
-        fallback.append(title, meta, download);
+        const fallback = createEncryptedFallback(ctx.file, url, {
+          title: "\u538B\u7F29\u5305\u5DF2\u52A0\u5BC6\uFF0C\u65E0\u6CD5\u5728\u7EBF\u9884\u89C8",
+          message: "\u8BF7\u4E0B\u8F7D\u540E\u5728\u672C\u5730\u8F93\u5165\u5BC6\u7801\u89E3\u538B\uFF0C\u6216\u4E0A\u4F20\u89E3\u5BC6\u540E\u7684\u538B\u7F29\u5305\u3002",
+          action: "\u4E0B\u8F7D\u538B\u7F29\u5305"
+        });
         panel.append(fallback);
         ctx.viewport.classList.add("ofv-center");
         return {
@@ -7723,6 +7820,28 @@ async function findSubPreviewPlugin(plugins, file) {
   }
   return fallbackPlugin();
 }
+function decodeZipFileName(bytes) {
+  const data = Array.isArray(bytes) ? Uint8Array.from(bytes.map((value) => value.charCodeAt(0) & 255)) : bytes instanceof Uint8Array ? bytes : Uint8Array.from(bytes);
+  const utf8 = decodeZipNameWith(data, "utf-8", true);
+  if (utf8 && !looksMojibake(utf8)) {
+    return utf8;
+  }
+  const gb18030 = decodeZipNameWith(data, "gb18030", false) || decodeZipNameWith(data, "gbk", false);
+  if (gb18030 && !looksMojibake(gb18030)) {
+    return gb18030;
+  }
+  return utf8 || new TextDecoder("latin1").decode(data);
+}
+function decodeZipNameWith(bytes, encoding, fatal) {
+  try {
+    return new TextDecoder(encoding, { fatal }).decode(bytes);
+  } catch {
+    return void 0;
+  }
+}
+function looksMojibake(value) {
+  return /[\uFFFDÃÂÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞß]/.test(value);
+}
 function createInlineError(titleText, detailText) {
   const fallback = document.createElement("div");
   fallback.className = "ofv-fallback";
@@ -8144,13 +8263,14 @@ function emailPlugin() {
         } else {
           const PostalMime = (await import("postal-mime")).default;
           const parser = new PostalMime();
-          let rawText = await readTextFile(ctx.file);
+          let rawSource = await readArrayBuffer(ctx.file);
           if (ext === "mbox") {
+            let rawText = await readTextFile(ctx.file);
             const messages = splitMboxMessages(rawText);
             mboxSummary = messages.map(summarizeMboxMessage);
-            rawText = messages[0] || rawText;
+            rawSource = messages[0] || rawText;
           }
-          const parsed = await parser.parse(rawText);
+          const parsed = await parser.parse(rawSource);
           const from = parsed.from ? `${parsed.from.name || ""} <${parsed.from.address || ""}>`.trim() : "";
           const to = Array.isArray(parsed.to) ? parsed.to.map((t) => `${t.name || ""} <${t.address || ""}>`.trim()).join("; ") : "";
           const cc = Array.isArray(parsed.cc) ? parsed.cc.map((c) => `${c.name || ""} <${c.address || ""}>`.trim()).join("; ") : "";
@@ -8220,13 +8340,17 @@ function emailPlugin() {
           const sanitizedHtml = sanitizeEmailHtml(html);
           const iframe = document.createElement("iframe");
           iframe.className = "ofv-email-body-iframe";
-          iframe.setAttribute("sandbox", "allow-popups allow-popups-to-escape-sandbox");
+          iframe.setAttribute("sandbox", "allow-same-origin allow-popups allow-popups-to-escape-sandbox");
           iframe.style.cssText = "width: 100%; border: none; background: #fff; min-height: 200px;";
-          bodySection.append(iframe);
-          iframe.onload = () => {
+          let renderedHtmlBody = false;
+          const renderHtmlBody = () => {
+            if (renderedHtmlBody) {
+              return;
+            }
             try {
               const idoc = iframe.contentDocument || iframe.contentWindow?.document;
               if (idoc) {
+                renderedHtmlBody = true;
                 idoc.open();
                 idoc.write(`
                   <!doctype html>
@@ -8277,6 +8401,9 @@ function emailPlugin() {
               console.error("Failed to write html body to email iframe:", err);
             }
           };
+          iframe.addEventListener("load", renderHtmlBody, { once: true });
+          bodySection.append(iframe);
+          renderHtmlBody();
         } else {
           const pre = document.createElement("pre");
           pre.className = "ofv-text-block";
@@ -9798,6 +9925,7 @@ function decodeDrawioDiagram(value) {
 }
 
 // src/plugins/cad.ts
+import pako3 from "pako";
 var cadExtensions = /* @__PURE__ */ new Set([
   "dxf",
   "dwg",
@@ -9814,7 +9942,10 @@ var cadExtensions = /* @__PURE__ */ new Set([
   "3dm",
   "skp",
   "sldprt",
-  "sldasm"
+  "sldasm",
+  "gds",
+  "oas",
+  "oasis"
 ]);
 var cadMimeTypes = /* @__PURE__ */ new Set([
   "application/acad",
@@ -9831,7 +9962,11 @@ var cadMimeTypes = /* @__PURE__ */ new Set([
   "application/x-parasolid",
   "model/vnd.3dm",
   "application/vnd.sketchup.skp",
-  "application/sldworks"
+  "application/sldworks",
+  "application/vnd.gds",
+  "application/x-gdsii",
+  "application/vnd.oasis.layout",
+  "application/x-oasis-layout"
 ]);
 var cadMimeFormatMap = {
   "application/acad": "dwg",
@@ -9848,7 +9983,11 @@ var cadMimeFormatMap = {
   "application/x-parasolid": "x_t",
   "model/vnd.3dm": "3dm",
   "application/vnd.sketchup.skp": "skp",
-  "application/sldworks": "sldprt"
+  "application/sldworks": "sldprt",
+  "application/vnd.gds": "gds",
+  "application/x-gdsii": "gds",
+  "application/vnd.oasis.layout": "oas",
+  "application/x-oasis-layout": "oas"
 };
 function cadPlugin() {
   return {
@@ -9876,6 +10015,36 @@ function cadPlugin() {
         renderBinaryCad(panel, await readArrayBuffer(ctx.file), extension, ctx.file.name);
         return { destroy: () => panel.remove() };
       }
+      if (extension === "gds") {
+        const viewer2 = renderLayoutPreview(panel, parseGdsLayout(new Uint8Array(await readArrayBuffer(ctx.file)), ctx.file.name), ctx);
+        return {
+          canCommand(command) {
+            return viewer2.canCommand(command);
+          },
+          command(command) {
+            return viewer2.command(command);
+          },
+          destroy() {
+            viewer2.destroy();
+            panel.remove();
+          }
+        };
+      }
+      if (extension === "oas" || extension === "oasis") {
+        const viewer2 = renderLayoutPreview(panel, parseOasisLayout(new Uint8Array(await readArrayBuffer(ctx.file)), ctx.file.name), ctx);
+        return {
+          canCommand(command) {
+            return viewer2.canCommand(command);
+          },
+          command(command) {
+            return viewer2.command(command);
+          },
+          destroy() {
+            viewer2.destroy();
+            panel.remove();
+          }
+        };
+      }
       if (extension !== "dxf") {
         const section = createSection("CAD \u57FA\u7840\u9884\u89C8");
         section.append(`.${extension || "cad"} \u5DF2\u8BC6\u522B\u4E3A\u56FE\u7EB8/\u5DE5\u7A0B\u683C\u5F0F\uFF0C\u5F53\u524D\u524D\u7AEF\u63D2\u4EF6\u4F18\u5148\u6E32\u67D3 DXF\u3002\u8BE5\u683C\u5F0F\u5EFA\u8BAE\u63A5\u5165\u670D\u52A1\u7AEF\u8F6C\u6362\u6216 WASM \u4E13\u7528\u5F15\u64CE\u3002`);
@@ -9974,6 +10143,560 @@ function renderIfc(panel, text) {
   section.append(table);
   panel.append(section);
 }
+var layoutPalette = [
+  "#2563eb",
+  "#dc2626",
+  "#059669",
+  "#7c3aed",
+  "#d97706",
+  "#0891b2",
+  "#be123c",
+  "#4f46e5",
+  "#15803d",
+  "#a16207"
+];
+var gdsRecordNames = {
+  0: "HEADER",
+  1: "BGNLIB",
+  2: "LIBNAME",
+  3: "UNITS",
+  4: "ENDLIB",
+  5: "BGNSTR",
+  6: "STRNAME",
+  7: "ENDSTR",
+  8: "BOUNDARY",
+  9: "PATH",
+  10: "SREF",
+  11: "AREF",
+  12: "TEXT",
+  13: "LAYER",
+  14: "DATATYPE",
+  15: "WIDTH",
+  16: "XY",
+  17: "ENDEL",
+  18: "SNAME",
+  22: "TEXTTYPE",
+  25: "STRING",
+  45: "BOX"
+};
+var oasisRecordNames = {
+  0: "PAD",
+  1: "START",
+  2: "END",
+  3: "CELLNAME",
+  4: "CELLNAME-REF",
+  5: "TEXTSTRING",
+  6: "TEXTSTRING-REF",
+  7: "PROPNAME",
+  8: "PROPNAME-REF",
+  9: "PROPSTRING",
+  10: "PROPSTRING-REF",
+  11: "LAYERNAME",
+  12: "LAYERNAME-REF",
+  13: "CELL",
+  14: "XYABSOLUTE",
+  15: "XYRELATIVE",
+  16: "PLACEMENT",
+  17: "PLACEMENT",
+  18: "TEXT",
+  19: "RECTANGLE",
+  20: "POLYGON",
+  21: "PATH",
+  22: "TRAPEZOID",
+  23: "TRAPEZOID",
+  24: "TRAPEZOID",
+  25: "CTRAPEZOID",
+  26: "CIRCLE",
+  27: "PROPERTY",
+  28: "PROPERTY",
+  29: "XNAME",
+  30: "XNAME-REF",
+  31: "XELEMENT",
+  32: "XGEOMETRY",
+  33: "CBLOCK"
+};
+function renderLayoutPreview(panel, data, ctx) {
+  const section = createSection(`${data.format} \u7248\u56FE\u9884\u89C8`);
+  const summary = document.createElement("div");
+  summary.className = "ofv-cad-summary ofv-layout-summary";
+  appendMeta5(summary, "\u6587\u4EF6", data.fileName);
+  appendMeta5(summary, "\u683C\u5F0F", data.format);
+  if (data.libraryName) {
+    appendMeta5(summary, "\u5E93", data.libraryName);
+  }
+  if (data.version) {
+    appendMeta5(summary, "\u7248\u672C", data.version);
+  }
+  if (data.unit) {
+    appendMeta5(summary, "\u5355\u4F4D", data.unit);
+  }
+  appendMeta5(summary, "Cell", data.cells.length);
+  appendMeta5(summary, "\u51E0\u4F55", data.shapes.length);
+  appendMeta5(summary, "\u5F15\u7528", data.references.length);
+  appendMeta5(summary, "\u6587\u5B57", data.labels.length);
+  for (const [label, value] of data.metadata) {
+    appendMeta5(summary, label, value);
+  }
+  section.append(summary);
+  for (const noteText of [...data.notes, ...data.warnings]) {
+    const note = document.createElement("p");
+    note.className = data.warnings.includes(noteText) ? "ofv-layout-warning" : "ofv-layout-note";
+    note.textContent = noteText;
+    section.append(note);
+  }
+  const bounds = computeLayoutBounds(data.shapes, data.labels, data.references);
+  const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+  svg.setAttribute("class", "ofv-svg-stage ofv-layout-stage");
+  let currentViewBox = { x: bounds.minX, y: bounds.minY, width: bounds.width, height: bounds.height };
+  const initialViewBox = { ...currentViewBox };
+  const applyViewBox = () => {
+    svg.setAttribute("viewBox", `${currentViewBox.x} ${currentViewBox.y} ${currentViewBox.width} ${currentViewBox.height}`);
+  };
+  applyViewBox();
+  if (data.shapes.length === 0) {
+    const empty = document.createElementNS(svg.namespaceURI, "text");
+    empty.setAttribute("x", String(bounds.minX + bounds.width * 0.5));
+    empty.setAttribute("y", String(bounds.minY + bounds.height * 0.5));
+    empty.setAttribute("text-anchor", "middle");
+    empty.setAttribute("font-size", String(Math.max(bounds.width, bounds.height) / 34));
+    empty.setAttribute("fill", "currentColor");
+    empty.textContent = "\u5DF2\u8BC6\u522B\u7248\u56FE\u6587\u4EF6\uFF0C\u5F53\u524D\u6587\u4EF6\u672A\u89E3\u6790\u51FA\u53EF\u7ED8\u5236\u51E0\u4F55";
+    svg.append(empty);
+  }
+  const layerIndex = new Map([...data.layers.keys()].sort((a, b) => a.localeCompare(b)).map((layer, index) => [layer, index]));
+  for (const shape of data.shapes.slice(0, 6e3)) {
+    const color = layoutPalette[(layerIndex.get(shape.layer) || 0) % layoutPalette.length];
+    if (shape.kind === "path") {
+      const polyline = document.createElementNS(svg.namespaceURI, "polyline");
+      polyline.setAttribute("points", shape.points.map(([x, y]) => `${x},${-y}`).join(" "));
+      polyline.setAttribute("fill", "none");
+      polyline.setAttribute("stroke", color);
+      polyline.setAttribute("stroke-width", String(Math.max(bounds.stroke, Math.abs(shape.width || 0))));
+      polyline.setAttribute("stroke-linecap", "round");
+      polyline.setAttribute("stroke-linejoin", "round");
+      applyLayer(polyline, shape.layer);
+      svg.append(polyline);
+      continue;
+    }
+    const polygon = document.createElementNS(svg.namespaceURI, "polygon");
+    polygon.setAttribute("points", shape.points.map(([x, y]) => `${x},${-y}`).join(" "));
+    polygon.setAttribute("fill", color);
+    polygon.setAttribute("fill-opacity", "0.18");
+    polygon.setAttribute("stroke", color);
+    polygon.setAttribute("stroke-width", String(bounds.stroke));
+    polygon.setAttribute("vector-effect", "non-scaling-stroke");
+    applyLayer(polygon, shape.layer);
+    svg.append(polygon);
+  }
+  for (const label of data.labels.slice(0, 400)) {
+    const text = document.createElementNS(svg.namespaceURI, "text");
+    text.setAttribute("x", String(label.x));
+    text.setAttribute("y", String(-label.y));
+    text.setAttribute("font-size", String(Math.max(bounds.stroke * 12, Math.max(bounds.width, bounds.height) / 120)));
+    text.setAttribute("fill", "currentColor");
+    text.textContent = label.text;
+    applyLayer(text, label.layer);
+    svg.append(text);
+  }
+  const layers = [...data.layers.keys()].sort((a, b) => a.localeCompare(b));
+  if (layers.length > 0) {
+    section.append(createLayoutLayerControls(svg, layers, data.layers));
+  }
+  section.append(svg);
+  if (data.cells.length > 0) {
+    section.append(createLayoutCellList(data.cells, data.references));
+  }
+  panel.append(section);
+  const updateToolbarZoom = () => ctx.toolbar?.setZoom(initialViewBox.width / currentViewBox.width);
+  updateToolbarZoom();
+  return {
+    canCommand(command) {
+      return command === "zoom-in" || command === "zoom-out" || command === "zoom-reset";
+    },
+    command(command) {
+      if (command === "zoom-in" || command === "zoom-out") {
+        const factor = command === "zoom-in" ? 0.82 : 1.18;
+        const centerX = currentViewBox.x + currentViewBox.width / 2;
+        const centerY = currentViewBox.y + currentViewBox.height / 2;
+        currentViewBox.width *= factor;
+        currentViewBox.height *= factor;
+        currentViewBox.x = centerX - currentViewBox.width / 2;
+        currentViewBox.y = centerY - currentViewBox.height / 2;
+        applyViewBox();
+        updateToolbarZoom();
+        return true;
+      }
+      if (command === "zoom-reset") {
+        currentViewBox = { ...initialViewBox };
+        applyViewBox();
+        updateToolbarZoom();
+        return true;
+      }
+      return false;
+    },
+    destroy() {
+      ctx.toolbar?.setZoom(void 0);
+    }
+  };
+}
+function parseGdsLayout(bytes, fileName) {
+  const shapes = [];
+  const labels = [];
+  const references = [];
+  const cells = [];
+  const layers = /* @__PURE__ */ new Map();
+  const recordCounts = /* @__PURE__ */ new Map();
+  const warnings = [];
+  let libraryName = "";
+  let version = "";
+  let unit = "";
+  let offset = 0;
+  let current = {};
+  let currentKind = "";
+  while (offset + 4 <= bytes.length) {
+    const length = readUInt16(bytes, offset);
+    const recordType = bytes[offset + 2];
+    const data = bytes.slice(offset + 4, offset + length);
+    const name = gdsRecordNames[recordType] || `0x${recordType.toString(16).padStart(2, "0")}`;
+    recordCounts.set(name, (recordCounts.get(name) || 0) + 1);
+    if (length < 4 || offset + length > bytes.length) {
+      warnings.push(`GDS \u8BB0\u5F55\u5728 ${offset} \u5B57\u8282\u5904\u957F\u5EA6\u5F02\u5E38\uFF0C\u5DF2\u505C\u6B62\u89E3\u6790\u3002`);
+      break;
+    }
+    if (recordType === 0 && data.length >= 2) {
+      version = String(readUInt16(data, 0));
+    } else if (recordType === 2) {
+      libraryName = readGdsString(data);
+    } else if (recordType === 3 && data.length >= 16) {
+      unit = `${formatGdsReal(data, 0)} / ${formatGdsReal(data, 8)}`;
+    } else if (recordType === 6) {
+      cells.push(readGdsString(data));
+    } else if (recordType === 8 || recordType === 9 || recordType === 45) {
+      currentKind = recordType === 9 ? "path" : recordType === 45 ? "box" : "boundary";
+      current = { kind: currentKind, layer: "0", datatype: "0", points: [] };
+    } else if (recordType === 12) {
+      currentKind = "text";
+      current = { layer: "0", text: "", x: 0, y: 0 };
+    } else if (recordType === 10 || recordType === 11) {
+      currentKind = "reference";
+      current = { cell: "", x: 0, y: 0 };
+    } else if (recordType === 13 && data.length >= 2) {
+      current.layer = String(readInt16(data, 0));
+    } else if ((recordType === 14 || recordType === 22) && data.length >= 2) {
+      current.datatype = String(readInt16(data, 0));
+    } else if (recordType === 15 && data.length >= 4) {
+      current.width = Math.abs(readInt32(data, 0));
+    } else if (recordType === 16) {
+      const points = readGdsPoints(data);
+      if (currentKind === "text" && points[0]) {
+        current.x = points[0][0];
+        current.y = points[0][1];
+      } else if (currentKind === "reference" && points[0]) {
+        current.x = points[0][0];
+        current.y = points[0][1];
+      } else {
+        current.points = points;
+      }
+    } else if (recordType === 18) {
+      current.cell = readGdsString(data);
+    } else if (recordType === 25) {
+      current.text = readGdsString(data);
+    } else if (recordType === 17) {
+      if ((currentKind === "boundary" || currentKind === "path" || currentKind === "box") && current.points && current.points.length > 1) {
+        const shape = {
+          kind: current.kind || "boundary",
+          layer: String(current.layer || "0"),
+          datatype: current.datatype,
+          points: current.points,
+          width: current.width
+        };
+        shapes.push(shape);
+        layers.set(shape.layer, (layers.get(shape.layer) || 0) + 1);
+      } else if (currentKind === "text" && current.text) {
+        const label = {
+          layer: String(current.layer || "0"),
+          text: String(current.text),
+          x: Number(current.x || 0),
+          y: Number(current.y || 0)
+        };
+        labels.push(label);
+        layers.set(label.layer, (layers.get(label.layer) || 0) + 1);
+      } else if (currentKind === "reference" && current.cell) {
+        references.push({ cell: String(current.cell), x: Number(current.x || 0), y: Number(current.y || 0) });
+      }
+      current = {};
+      currentKind = "";
+    }
+    offset += length;
+  }
+  return {
+    format: "GDSII",
+    fileName,
+    libraryName,
+    version: version ? `Stream ${version}` : void 0,
+    unit,
+    cells,
+    shapes,
+    labels,
+    references,
+    layers,
+    metadata: [
+      ["\u5927\u5C0F", formatBytes3(bytes.byteLength)],
+      ["\u8BB0\u5F55", sumCounts(recordCounts)],
+      ["\u8BB0\u5F55\u7C7B\u578B", recordCounts.size]
+    ],
+    notes: [
+      `\u5DF2\u4ECE GDSII Stream \u4E2D\u89E3\u6790 ${shapes.length} \u4E2A\u51E0\u4F55\u3001${references.length} \u4E2A cell \u5F15\u7528\u548C ${labels.length} \u6BB5\u6587\u5B57\u3002`
+    ],
+    warnings
+  };
+}
+function parseOasisLayout(bytes, fileName) {
+  const chunks = extractOasisCblocks(bytes);
+  const expanded = chunks.flatMap((chunk) => [...chunk.bytes]);
+  const cellNames = uniqueHints([...extractAsciiRuns(bytes), ...chunks.flatMap((chunk) => extractAsciiRuns(chunk.bytes))]).filter((item) => /^[A-Za-z_][\w$.-]{1,80}$/.test(item)).filter((item) => !item.startsWith("S_"));
+  const propertyNames = uniqueHints(chunks.flatMap((chunk) => extractAsciiRuns(chunk.bytes)).filter((item) => item.startsWith("S_")));
+  const recordCounts = scanOasisRecordCounts(bytes);
+  const expandedCounts = scanOasisRecordCounts(new Uint8Array(expanded));
+  const layers = /* @__PURE__ */ new Map();
+  const shapes = [];
+  const labels = [];
+  const references = [];
+  for (const name of cellNames) {
+    references.push({ cell: name, x: 0, y: 0 });
+  }
+  const pseudo = createOasisStructureShapes(cellNames, chunks.length || recordCounts.size || 1);
+  for (const shape of pseudo) {
+    shapes.push(shape);
+    layers.set(shape.layer, (layers.get(shape.layer) || 0) + 1);
+  }
+  for (let index = 0; index < cellNames.length; index++) {
+    labels.push({ layer: "cell", text: cellNames[index], x: 12, y: -(18 + index * 18) });
+  }
+  if (cellNames.length > 0) {
+    layers.set("cell", (layers.get("cell") || 0) + cellNames.length);
+  }
+  const version = readOasisVersion(bytes);
+  const cblockText = chunks.length ? `${chunks.length} \u4E2A\uFF0C\u5C55\u5F00 ${formatBytes3(chunks.reduce((sum, chunk) => sum + chunk.bytes.byteLength, 0))}` : "\u672A\u53D1\u73B0";
+  const notes = [
+    "OASIS \u662F\u9AD8\u538B\u7F29\u82AF\u7247\u7248\u56FE\u683C\u5F0F\uFF0C\u5F53\u524D\u7248\u672C\u63D0\u4F9B\u6D4F\u89C8\u5668\u7AEF\u8BC6\u522B\u3001CBLOCK \u89E3\u538B\u3001cell/\u5C5E\u6027\u7ED3\u6784\u548C\u8F7B\u91CF\u7ED3\u6784\u793A\u610F\uFF1B\u5B8C\u6574\u51E0\u4F55\u9AD8\u4FDD\u771F\u6E32\u67D3\u5EFA\u8BAE\u540E\u7EED\u63A5\u5165\u4E13\u7528 OASIS \u89E3\u6790\u5668\u3002"
+  ];
+  if (propertyNames.length > 0) {
+    notes.push(`\u8BC6\u522B\u5230\u5C5E\u6027\uFF1A${propertyNames.slice(0, 5).join("\u3001")}`);
+  }
+  return {
+    format: "OASIS",
+    fileName,
+    version,
+    cells: cellNames,
+    shapes,
+    labels,
+    references: [],
+    layers,
+    metadata: [
+      ["\u5927\u5C0F", formatBytes3(bytes.byteLength)],
+      ["CBLOCK", cblockText],
+      ["\u8BB0\u5F55\u7C7B\u578B", recordCounts.size + expandedCounts.size],
+      ["\u53EF\u8BFB\u7247\u6BB5", cellNames.length + propertyNames.length]
+    ],
+    notes,
+    warnings: cellNames.length === 0 ? ["\u5F53\u524D OASIS \u6587\u4EF6\u672A\u63D0\u53D6\u5230 cell \u540D\u79F0\uFF0C\u53EF\u80FD\u4F7F\u7528\u4E86\u66F4\u590D\u6742\u7684\u7D22\u5F15\u6216\u52A0\u5BC6/\u538B\u7F29\u5E03\u5C40\u3002"] : []
+  };
+}
+function computeLayoutBounds(shapes, labels, references) {
+  const xs = [];
+  const ys = [];
+  for (const shape of shapes) {
+    for (const [x, y] of shape.points) {
+      xs.push(x);
+      ys.push(-y);
+    }
+  }
+  for (const label of labels) {
+    xs.push(label.x, label.x + label.text.length * 12);
+    ys.push(-label.y, -label.y - 16);
+  }
+  for (const reference of references) {
+    xs.push(reference.x);
+    ys.push(-reference.y);
+  }
+  const minX = Math.min(...xs, 0);
+  const maxX = Math.max(...xs, 100);
+  const minY = Math.min(...ys, 0);
+  const maxY = Math.max(...ys, 100);
+  const width = Math.max(1, maxX - minX);
+  const height = Math.max(1, maxY - minY);
+  const padding = Math.max(width, height) * 0.06;
+  return {
+    minX: minX - padding,
+    minY: minY - padding,
+    width: width + padding * 2,
+    height: height + padding * 2,
+    stroke: Math.max(width, height) / 900
+  };
+}
+function createLayoutLayerControls(svg, layers, counts) {
+  const controls = document.createElement("div");
+  controls.className = "ofv-cad-layers ofv-layout-layers";
+  const title = document.createElement("strong");
+  title.textContent = `\u56FE\u5C42 ${layers.length}`;
+  controls.append(title);
+  for (const layer of layers) {
+    const label = document.createElement("label");
+    const checkbox = document.createElement("input");
+    checkbox.type = "checkbox";
+    checkbox.checked = true;
+    checkbox.addEventListener("change", () => {
+      for (const element of svg.querySelectorAll(`[data-layer="${escapeCssAttribute(layer)}"]`)) {
+        element.style.display = checkbox.checked ? "" : "none";
+      }
+    });
+    const name = document.createElement("span");
+    name.textContent = `${layer} (${counts.get(layer) || 0})`;
+    label.append(checkbox, name);
+    controls.append(label);
+  }
+  return controls;
+}
+function createLayoutCellList(cells, references) {
+  const details = document.createElement("details");
+  details.className = "ofv-details ofv-layout-cells";
+  details.open = true;
+  const summary = document.createElement("summary");
+  summary.textContent = `Cell \u7ED3\u6784 ${cells.length}`;
+  const list = document.createElement("ul");
+  const refCounts = countBy(references.map((reference) => reference.cell));
+  for (const cell of cells.slice(0, 120)) {
+    const item = document.createElement("li");
+    const count = refCounts.get(cell) || 0;
+    item.textContent = count > 0 ? `${cell} \xB7 \u5F15\u7528 ${count}` : cell;
+    list.append(item);
+  }
+  details.append(summary, list);
+  return details;
+}
+function readUInt16(bytes, offset) {
+  return bytes[offset] << 8 | bytes[offset + 1];
+}
+function readInt16(bytes, offset) {
+  const value = readUInt16(bytes, offset);
+  return value & 32768 ? value - 65536 : value;
+}
+function readInt32(bytes, offset) {
+  const value = bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3];
+  return value | 0;
+}
+function readGdsString(bytes) {
+  return new TextDecoder("ascii").decode(bytes).replace(/\0+$/g, "").trim();
+}
+function readGdsPoints(bytes) {
+  const points = [];
+  for (let offset = 0; offset + 7 < bytes.length; offset += 8) {
+    points.push([readInt32(bytes, offset), readInt32(bytes, offset + 4)]);
+  }
+  return points;
+}
+function formatGdsReal(bytes, offset) {
+  const value = readGdsReal(bytes, offset);
+  if (!Number.isFinite(value) || value === 0) {
+    return "0";
+  }
+  if (Math.abs(value) < 1e-3 || Math.abs(value) >= 1e4) {
+    return value.toExponential(4);
+  }
+  return String(Number(value.toPrecision(6)));
+}
+function readGdsReal(bytes, offset) {
+  const first = bytes[offset];
+  if (!first) {
+    return 0;
+  }
+  const sign = first & 128 ? -1 : 1;
+  const exponent = (first & 127) - 64;
+  let mantissa = 0;
+  for (let index = 1; index < 8; index++) {
+    mantissa = mantissa * 256 + bytes[offset + index];
+  }
+  return sign * (mantissa / Math.pow(2, 56)) * Math.pow(16, exponent);
+}
+function sumCounts(counts) {
+  return [...counts.values()].reduce((sum, count) => sum + count, 0);
+}
+function extractOasisCblocks(bytes) {
+  const chunks = [];
+  const seen = /* @__PURE__ */ new Set();
+  const limit = Math.min(bytes.length, 25e4);
+  for (let offset = 0; offset < limit; offset++) {
+    try {
+      const inflated = pako3.inflateRaw(bytes.slice(offset));
+      if (inflated.byteLength < 4) {
+        continue;
+      }
+      const ascii = extractAsciiRuns(inflated);
+      const hasLayoutSignal = ascii.some((item) => item.startsWith("S_") || /TOP|CELL|DIE|SIZE/i.test(item));
+      const hasRecordSignal = inflated.some((byte) => byte >= 13 && byte <= 34);
+      if (!hasLayoutSignal && !hasRecordSignal) {
+        continue;
+      }
+      const signature = `${inflated.byteLength}:${Array.from(inflated.slice(0, 12)).join(",")}`;
+      if (seen.has(signature)) {
+        continue;
+      }
+      seen.add(signature);
+      chunks.push({ offset, bytes: inflated });
+      if (chunks.length >= 12) {
+        break;
+      }
+    } catch {
+    }
+  }
+  return chunks;
+}
+function scanOasisRecordCounts(bytes) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const byte of bytes.slice(0, Math.min(bytes.length, 12e3))) {
+    const name = oasisRecordNames[byte];
+    if (name) {
+      counts.set(name, (counts.get(name) || 0) + 1);
+    }
+  }
+  return counts;
+}
+function readOasisVersion(bytes) {
+  const magic = "%SEMI-OASIS\r\n";
+  const header = new TextDecoder("ascii").decode(bytes.slice(0, Math.min(bytes.length, 48)));
+  if (!header.startsWith(magic)) {
+    return void 0;
+  }
+  const start = magic.length;
+  if (bytes[start] !== 1) {
+    return "OASIS";
+  }
+  const length = bytes[start + 1];
+  const version = new TextDecoder("ascii").decode(bytes.slice(start + 2, start + 2 + length));
+  return version ? `OASIS ${version}` : "OASIS";
+}
+function createOasisStructureShapes(cellNames, fallbackCount) {
+  const rows = Math.max(1, cellNames.length || fallbackCount);
+  const shapes = [];
+  for (let index = 0; index < rows; index++) {
+    const top = -(index * 18);
+    const height = 12;
+    const width = 88 + Math.min((cellNames[index]?.length || 5) * 4, 90);
+    shapes.push({
+      kind: "box",
+      layer: "cell",
+      points: [
+        [0, top],
+        [width, top],
+        [width, top - height],
+        [0, top - height],
+        [0, top]
+      ]
+    });
+  }
+  return shapes;
+}
 function renderBinaryCad(panel, arrayBuffer, extension, fileName) {
   const bytes = new Uint8Array(arrayBuffer);
   const section = createSection(`${extension.toUpperCase()} \u6587\u4EF6\u9884\u89C8`);