@yumiai/chat-widget 0.1.2 → 0.2.1

package/dist/gerber-simulation-entry-EBDX72XE.js

@@ -0,0 +1,1801 @@
+import {
+  GerberParser
+} from "./chunk-O3NXUM6C.js";
+import {
+  extractRar,
+  fetchFileById,
+  fetchFileByUrl,
+  parseUrlFileUrl,
+  parseUrlId,
+  require_lib
+} from "./chunk-7A4FY6FK.js";
+import {
+  __toESM
+} from "./chunk-7D4SUZUM.js";
+
+// src/components/jetPaveGerberViewer/src/viewer-src/simulation/js/main.js
+var import_jszip = __toESM(require_lib(), 1);
+var FINISH_COLORS = {
+  "ENIG": "#D4AF37",
+  // 沉金 - 金色
+  "HASL": "#C0C0C0",
+  // 喷锡 - 银色
+  "OSP": "#B87333",
+  // OSP - 铜色
+  "SILVER": "#E8E8E8",
+  // 镀银 - 亮银色
+  "ENEPIG": "#E6C87A"
+  // 化镍钯金 - 浅金色
+};
+var layers = {};
+var boardBounds = null;
+var refBounds = null;
+var currentView = "top";
+var zoomLevel = 1;
+var panOffset = { x: 0, y: 0 };
+var isDragging = false;
+var lastMousePos = { x: 0, y: 0 };
+var canvas;
+var ctx;
+var loadingOverlay;
+var loadingText;
+var statusLeft;
+var statusRight;
+var config = {
+  maskColor: "#1C590B",
+  silkColor: "#ffffff",
+  surfaceFinish: "ENIG",
+  showMask: true,
+  showSilk: true,
+  showDrill: true
+};
+var unitScale = 1;
+var DEBUG = true;
+var layerCache = {
+  top: null,
+  bottom: null,
+  dirty: true,
+  // 是否需要重新渲染
+  lastWidth: 0,
+  lastHeight: 0
+};
+var renderRAF = null;
+if (DEBUG) console.log("[simulation] main.js \u5DF2\u52A0\u8F7D");
+function initSimulation() {
+  if (DEBUG) console.log("[simulation] \u5F00\u59CB\u521D\u59CB\u5316");
+  initUI();
+  initEventListeners();
+  initUrlHandler();
+}
+if (document.readyState === "loading") {
+  document.addEventListener("DOMContentLoaded", initSimulation);
+} else {
+  initSimulation();
+}
+function initUI() {
+  canvas = document.getElementById("simulationCanvas");
+  ctx = canvas.getContext("2d");
+  loadingOverlay = document.getElementById("loadingOverlay");
+  loadingText = document.getElementById("loadingText");
+  statusLeft = document.getElementById("statusLeft");
+  statusRight = document.getElementById("statusRight");
+  render();
+}
+function initEventListeners() {
+  const fileInput = document.getElementById("fileInput");
+  fileInput.addEventListener("change", async (e) => {
+    const files = Array.from(e.target.files);
+    if (files.length > 0) {
+      await handleFiles(files);
+    }
+  });
+  document.getElementById("btnTopView").addEventListener("click", () => setView("top"));
+  document.getElementById("btnBottomView").addEventListener("click", () => setView("bottom"));
+  document.getElementById("maskColorSelect").addEventListener("change", (e) => {
+    config.maskColor = e.target.value;
+    document.getElementById("maskColorPreview").style.background = e.target.value;
+    invalidateCache();
+    render();
+  });
+  document.getElementById("silkColorSelect").addEventListener("change", (e) => {
+    config.silkColor = e.target.value;
+    document.getElementById("silkColorPreview").style.background = e.target.value;
+    invalidateCache();
+    render();
+  });
+  document.getElementById("finishSelect").addEventListener("change", (e) => {
+    config.surfaceFinish = e.target.value;
+    document.getElementById("finishColorPreview").style.background = FINISH_COLORS[e.target.value];
+    invalidateCache();
+    render();
+  });
+  document.getElementById("showMask").addEventListener("change", (e) => {
+    config.showMask = e.target.checked;
+    invalidateCache();
+    render();
+  });
+  document.getElementById("showSilk").addEventListener("change", (e) => {
+    config.showSilk = e.target.checked;
+    invalidateCache();
+    render();
+  });
+  document.getElementById("showDrill").addEventListener("change", (e) => {
+    config.showDrill = e.target.checked;
+    invalidateCache();
+    render();
+  });
+  document.getElementById("btnExport").addEventListener("click", exportImage);
+  document.getElementById("btnClear").addEventListener("click", clearAll);
+  const canvasContainer = document.getElementById("canvasContainer");
+  canvasContainer.addEventListener("wheel", (e) => {
+    e.preventDefault();
+    if (!boardBounds) return;
+    const delta = e.deltaY > 0 ? 0.9 : 1.1;
+    zoomLevel *= delta;
+    zoomLevel = Math.max(0.1, Math.min(10, zoomLevel));
+    render();
+  });
+  canvas.addEventListener("mousedown", (e) => {
+    if (e.button === 0) {
+      isDragging = true;
+      lastMousePos = { x: e.clientX, y: e.clientY };
+      canvas.style.cursor = "grabbing";
+    }
+  });
+  window.addEventListener("mousemove", (e) => {
+    if (isDragging) {
+      const dx = e.clientX - lastMousePos.x;
+      const dy = e.clientY - lastMousePos.y;
+      panOffset.x += dx;
+      panOffset.y += dy;
+      lastMousePos = { x: e.clientX, y: e.clientY };
+      render();
+    }
+  });
+  window.addEventListener("mouseup", () => {
+    if (isDragging) {
+      isDragging = false;
+      canvas.style.cursor = "grab";
+    }
+  });
+}
+function initUrlHandler() {
+  if (window.isRenderPage) {
+    if (DEBUG) console.log("[simulation] \u5728 render \u9875\u9762\u4E2D\u8FD0\u884C\uFF0C\u8DF3\u8FC7 URL \u5904\u7406");
+    return;
+  }
+  if (DEBUG) console.log("[simulation] initUrlHandler \u88AB\u8C03\u7528, URL:", window.location.href);
+  const id = parseUrlId();
+  const url = parseUrlFileUrl();
+  if (DEBUG) console.log("[simulation] \u89E3\u6790\u5230\u7684 ID:", id, "URL:", url);
+  if (id) {
+    if (DEBUG) console.log("[simulation] \u5F00\u59CB\u4ECE\u63A5\u53E3\u52A0\u8F7D\u6587\u4EF6, ID:", id);
+    loadFromId(id);
+    return;
+  }
+  if (url) {
+    if (DEBUG) console.log("[simulation] \u5F00\u59CB\u4ECE\u94FE\u63A5\u52A0\u8F7D\u6587\u4EF6:", url);
+    loadFromUrl(url);
+  }
+}
+async function handleFiles(files) {
+  console.log("[\u6027\u80FD] handleFiles \u5F00\u59CB");
+  const startTimeTotal = performance.now();
+  showLoading("\u6B63\u5728\u89E3\u6790\u6587\u4EF6...");
+  try {
+    console.log("[\u6027\u80FD] \u5F00\u59CB\u89E3\u538B\u6587\u4EF6...");
+    const startTimeExtract = performance.now();
+    let gerberFiles = [];
+    for (const file of files) {
+      const ext = file.name.split(".").pop().toLowerCase();
+      if (ext === "zip") {
+        console.log(`[\u6027\u80FD] \u89E3\u538B ZIP: ${file.name}`);
+        const startTimeZip = performance.now();
+        const extracted = await extractZip(file);
+        const endTimeZip = performance.now();
+        console.log(`[\u6027\u80FD] ZIP \u89E3\u538B\u5B8C\u6210\uFF0C\u8017\u65F6: ${(endTimeZip - startTimeZip).toFixed(2)}ms, \u6587\u4EF6\u6570: ${extracted.length}`);
+        gerberFiles.push(...extracted);
+      } else if (ext === "rar") {
+        console.log(`[\u6027\u80FD] \u89E3\u538B RAR: ${file.name}`);
+        const startTimeRar = performance.now();
+        try {
+          const extracted = await extractRar(file);
+          const endTimeRar = performance.now();
+          console.log(`[\u6027\u80FD] RAR \u89E3\u538B\u5B8C\u6210\uFF0C\u8017\u65F6: ${(endTimeRar - startTimeRar).toFixed(2)}ms, \u6587\u4EF6\u6570: ${extracted.length}`);
+          gerberFiles.push(...extracted);
+        } catch (rarError) {
+          if (rarError.isActualZip) {
+            const extracted = await extractZip(file);
+            const endTimeRar = performance.now();
+            console.log(`[\u6027\u80FD] RAR(\u5B9E\u4E3AZIP) \u89E3\u538B\u5B8C\u6210\uFF0C\u8017\u65F6: ${(endTimeRar - startTimeRar).toFixed(2)}ms, \u6587\u4EF6\u6570: ${extracted.length}`);
+            gerberFiles.push(...extracted);
+          } else {
+            throw rarError;
+          }
+        }
+      } else {
+        gerberFiles.push(file);
+      }
+    }
+    const endTimeExtract = performance.now();
+    console.log(`[\u6027\u80FD] \u6587\u4EF6\u89E3\u538B\u603B\u8017\u65F6: ${(endTimeExtract - startTimeExtract).toFixed(2)}ms, \u89E3\u538B\u540E\u6587\u4EF6\u6570: ${gerberFiles.length}`);
+    if (gerberFiles.length === 0) {
+      throw new Error("\u672A\u627E\u5230\u6709\u6548\u7684 Gerber \u6587\u4EF6");
+    }
+    console.log("[\u6027\u80FD] \u5F00\u59CB\u89E3\u6790 Gerber \u6587\u4EF6...");
+    const startTimeParse = performance.now();
+    await parseGerberFiles(gerberFiles);
+    const endTimeParse = performance.now();
+    console.log(`[\u6027\u80FD] Gerber \u6587\u4EF6\u89E3\u6790\u5B8C\u6210\uFF0C\u8017\u65F6: ${((endTimeParse - startTimeParse) / 1e3).toFixed(2)}\u79D2`);
+    console.log("[\u6027\u80FD] \u5F00\u59CB\u66F4\u65B0 UI \u548C\u6E32\u67D3...");
+    const startTimeRender = performance.now();
+    invalidateCache();
+    updateLayerList();
+    fitToView();
+    render();
+    const endTimeRender = performance.now();
+    console.log(`[\u6027\u80FD] UI \u66F4\u65B0\u548C\u6E32\u67D3\u5B8C\u6210\uFF0C\u8017\u65F6: ${(endTimeRender - startTimeRender).toFixed(2)}ms`);
+    const endTimeTotal = performance.now();
+    const totalTime = (endTimeTotal - startTimeTotal) / 1e3;
+    console.log(`[\u6027\u80FD] ========== handleFiles \u5B8C\u6210\uFF0C\u603B\u8017\u65F6: ${totalTime.toFixed(2)}\u79D2 ==========`);
+    console.log(`[\u6027\u80FD] \u8BE6\u7EC6\u8017\u65F6\uFF1A\u89E3\u538B=${((endTimeExtract - startTimeExtract) / 1e3).toFixed(2)}\u79D2, \u89E3\u6790=${((endTimeParse - startTimeParse) / 1e3).toFixed(2)}\u79D2, \u6E32\u67D3=${((endTimeRender - startTimeRender) / 1e3).toFixed(2)}\u79D2`);
+    hideLoading();
+    updateStatus(`\u5DF2\u52A0\u8F7D ${Object.keys(layers).length} \u4E2A\u56FE\u5C42`);
+  } catch (error) {
+    const endTimeTotal = performance.now();
+    const totalTime = (endTimeTotal - startTimeTotal) / 1e3;
+    console.error(`[\u9519\u8BEF] \u5904\u7406\u6587\u4EF6\u5931\u8D25 (\u8017\u65F6: ${totalTime.toFixed(2)}\u79D2):`, error);
+    hideLoading();
+    updateStatus("\u9519\u8BEF: " + error.message, true);
+  }
+}
+async function loadFromId(id) {
+  if (DEBUG) console.log("[simulation] loadFromId \u88AB\u8C03\u7528, ID:", id);
+  const startTimeTotal = performance.now();
+  showLoading("\u6B63\u5728\u4ECE\u670D\u52A1\u5668\u52A0\u8F7D...");
+  try {
+    if (DEBUG) console.log("[simulation] \u4F7F\u7528 fetchFileById \u83B7\u53D6\u6587\u4EF6...");
+    await fetchFileById(
+      id,
+      async (files) => {
+        if (DEBUG) console.log("[simulation] \u6536\u5230\u6587\u4EF6\uFF0C\u5F00\u59CB\u5904\u7406...");
+        await handleFiles(files);
+        const finalTime = performance.now();
+        const grandTotal = (finalTime - startTimeTotal) / 1e3;
+        console.log(`[\u6027\u80FD] ========== \u4ECE\u5F00\u59CB\u52A0\u8F7D\u5230\u5904\u7406\u5B8C\u6210\u603B\u8017\u65F6: ${grandTotal.toFixed(2)}\u79D2 ==========`);
+      },
+      (message, type) => {
+        console.log(`[simulation] \u72B6\u6001: ${message}`);
+      }
+    );
+  } catch (error) {
+    const endTime = performance.now();
+    const errorTime = (endTime - startTimeTotal) / 1e3;
+    console.error(`[simulation] \u83B7\u53D6\u6587\u4EF6\u5931\u8D25 (\u8017\u65F6: ${errorTime.toFixed(2)}\u79D2):`, error);
+    hideLoading();
+    updateStatus(`\u83B7\u53D6\u6587\u4EF6\u5931\u8D25: ${error.message}`, true);
+  }
+}
+async function loadFromUrl(url) {
+  if (DEBUG) console.log("[simulation] loadFromUrl \u88AB\u8C03\u7528, URL:", url);
+  const startTimeTotal = performance.now();
+  showLoading("\u6B63\u5728\u4ECE\u94FE\u63A5\u52A0\u8F7D...");
+  try {
+    if (DEBUG) console.log("[simulation] \u4F7F\u7528 fetchFileByUrl \u83B7\u53D6\u6587\u4EF6...");
+    await fetchFileByUrl(
+      url,
+      async (files) => {
+        if (DEBUG) console.log("[simulation] \u6536\u5230\u6587\u4EF6\uFF0C\u5F00\u59CB\u5904\u7406...");
+        await handleFiles(files);
+        const finalTime = performance.now();
+        const grandTotal = (finalTime - startTimeTotal) / 1e3;
+        console.log(`[\u6027\u80FD] ========== \u4ECE\u5F00\u59CB\u52A0\u8F7D\u5230\u5904\u7406\u5B8C\u6210\u603B\u8017\u65F6: ${grandTotal.toFixed(2)}\u79D2 ==========`);
+      },
+      (message, type) => {
+        console.log(`[simulation] \u72B6\u6001: ${message}`);
+      }
+    );
+  } catch (error) {
+    const endTime = performance.now();
+    const errorTime = (endTime - startTimeTotal) / 1e3;
+    console.error(`[simulation] \u83B7\u53D6\u6587\u4EF6\u5931\u8D25 (\u8017\u65F6: ${errorTime.toFixed(2)}\u79D2):`, error);
+    hideLoading();
+    updateStatus(`\u83B7\u53D6\u6587\u4EF6\u5931\u8D25: ${error.message}`, true);
+  }
+}
+async function extractZip(zipFile) {
+  const zip = await import_jszip.default.loadAsync(zipFile);
+  const files = [];
+  for (const filename in zip.files) {
+    if (zip.files[filename].dir) continue;
+    if (!isGerberFile(filename)) continue;
+    const content = await zip.files[filename].async("blob");
+    files.push(new File([content], filename));
+  }
+  return files;
+}
+function isGerberFile(fileName) {
+  const validExtensions = [
+    ".gtl",
+    ".gbl",
+    ".gts",
+    ".gbs",
+    ".gto",
+    ".gbo",
+    ".gtp",
+    ".gbp",
+    ".gm1",
+    ".drl",
+    ".gbr",
+    ".gko",
+    ".gdl",
+    ".gdd",
+    ".gm",
+    ".gd1",
+    ".gg1",
+    ".gpb",
+    ".gpt",
+    ".txt",
+    ".art",
+    ".d",
+    ".rou",
+    ".pho"
+  ];
+  const ext = "." + fileName.split(".").pop().toLowerCase();
+  return validExtensions.includes(ext) || /^\.g\d+$/i.test(ext) || /^\.gm\d+$/i.test(ext) || /^\.gp\d+$/i.test(ext);
+}
+async function parseGerberFiles(files) {
+  layers = {};
+  boardBounds = null;
+  refBounds = null;
+  const parseQueue = [];
+  for (const file of files) {
+    const layerType = getLayerType(file.name);
+    if (!layerType) continue;
+    const isDrill = layerType === "DRL" || layerType === "DRL2";
+    parseQueue.push({ file, layerType, isDrill });
+  }
+  parseQueue.sort((a, b) => a.isDrill === b.isDrill ? 0 : a.isDrill ? 1 : -1);
+  if (DEBUG) console.log("[\u4EFF\u771F\u56FE] \u6587\u4EF6\u89E3\u6790\u987A\u5E8F:", parseQueue.map((x) => x.file.name));
+  for (const { file, layerType } of parseQueue) {
+    try {
+      showLoading(`\u6B63\u5728\u89E3\u6790 ${file.name}...`);
+      const result = await GerberParser.parseFile(file, "#ffffff");
+      if (!result || !result.data) {
+        console.warn(`\u89E3\u6790 ${file.name} \u8FD4\u56DE\u7A7A\u6570\u636E`);
+        continue;
+      }
+      if ((layerType === "DRL" || layerType === "DRL2") && layers[layerType]) {
+        if (DEBUG) console.log(`[\u4EFF\u771F\u56FE] \u5408\u5E76\u94BB\u5B54\u5C42 ${layerType}: ${file.name}`);
+        const existing = layers[layerType];
+        if (result.data.vertices && existing.data.vertices) {
+          const newVertices = new Float32Array(existing.data.vertices.length + result.data.vertices.length);
+          newVertices.set(existing.data.vertices, 0);
+          newVertices.set(result.data.vertices, existing.data.vertices.length);
+          existing.data.vertices = newVertices;
+        }
+        if (result.data.lineStrips && existing.data.lineStrips) {
+          const vertexOffset = existing.data.vertices ? (existing.data.vertices.length - result.data.vertices.length) / 3 : 0;
+          const adjustedStrips = result.data.lineStrips.map((strip) => ({
+            start: strip.start + vertexOffset,
+            count: strip.count
+          }));
+          existing.data.lineStrips = [...existing.data.lineStrips, ...adjustedStrips];
+        }
+        if (result.bounds && existing.bounds) {
+          existing.bounds.minX = Math.min(existing.bounds.minX, result.bounds.minX);
+          existing.bounds.minY = Math.min(existing.bounds.minY, result.bounds.minY);
+          existing.bounds.maxX = Math.max(existing.bounds.maxX, result.bounds.maxX);
+          existing.bounds.maxY = Math.max(existing.bounds.maxY, result.bounds.maxY);
+        }
+        existing.name += `, ${file.name.split(/[/\\]/).pop()}`;
+      } else {
+        layers[layerType] = {
+          name: file.name,
+          type: layerType,
+          data: result.data,
+          bounds: result.bounds,
+          units: result.data.units || "mm"
+        };
+      }
+    } catch (error) {
+      console.warn(`\u89E3\u6790 ${file.name} \u5931\u8D25:`, error);
+    }
+  }
+  const refLayerTypes = ["GTL", "GBL", "GTS", "GBS", "GTO", "GBO"];
+  for (const type of refLayerTypes) {
+    const layer = layers[type];
+    if (!layer || !layer.bounds) continue;
+    const b = layer.bounds;
+    if (!refBounds) {
+      refBounds = { minX: b.minX, minY: b.minY, maxX: b.maxX, maxY: b.maxY };
+    } else {
+      refBounds.minX = Math.min(refBounds.minX, b.minX);
+      refBounds.minY = Math.min(refBounds.minY, b.minY);
+      refBounds.maxX = Math.max(refBounds.maxX, b.maxX);
+      refBounds.maxY = Math.max(refBounds.maxY, b.maxY);
+    }
+  }
+  for (const type of Object.keys(layers)) {
+    if (!/^SIG\d+$/i.test(type)) continue;
+    const layer = layers[type];
+    if (!layer || !layer.bounds) continue;
+    const b = layer.bounds;
+    if (!refBounds) {
+      refBounds = { minX: b.minX, minY: b.minY, maxX: b.maxX, maxY: b.maxY };
+    } else {
+      refBounds.minX = Math.min(refBounds.minX, b.minX);
+      refBounds.minY = Math.min(refBounds.minY, b.minY);
+      refBounds.maxX = Math.max(refBounds.maxX, b.maxX);
+      refBounds.maxY = Math.max(refBounds.maxY, b.maxY);
+    }
+  }
+  if (DEBUG) console.log(`[\u4EFF\u771F\u56FE] \u53C2\u8003\u8FB9\u754C\uFF08\u94DC\u5C42/\u963B\u710A\u5C42\uFF09:`, refBounds);
+  if (DEBUG) {
+    console.log(`[\u4EFF\u771F\u56FE] ===== \u5404\u56FE\u5C42\u4FE1\u606F =====`);
+    for (const [type, layer] of Object.entries(layers)) {
+      const b = layer.bounds;
+      const bStr = b ? `(${b.minX.toFixed(3)}, ${b.minY.toFixed(3)}) - (${b.maxX.toFixed(3)}, ${b.maxY.toFixed(3)})` : "null";
+      console.log(`[\u4EFF\u771F\u56FE] ${type}: units=${layer.units}, bounds=${bStr}`);
+    }
+    console.log(`[\u4EFF\u771F\u56FE] ===========================`);
+  }
+  if (refBounds) {
+    boardBounds = [refBounds.minX, refBounds.minY, refBounds.maxX, refBounds.maxY];
+  } else {
+    for (const [type, layer] of Object.entries(layers)) {
+      if (type === "GKO" || type === "DRL" || type === "DRL2") continue;
+      if (!layer.bounds) continue;
+      const b = layer.bounds;
+      if (!boardBounds) {
+        boardBounds = [b.minX, b.minY, b.maxX, b.maxY];
+      } else {
+        boardBounds[0] = Math.min(boardBounds[0], b.minX);
+        boardBounds[1] = Math.min(boardBounds[1], b.minY);
+        boardBounds[2] = Math.max(boardBounds[2], b.maxX);
+        boardBounds[3] = Math.max(boardBounds[3], b.maxY);
+      }
+    }
+  }
+  if (DEBUG) console.log(`[\u4EFF\u771F\u56FE] \u677F\u5B50\u8FB9\u754C:`, boardBounds);
+  if (DEBUG) console.log(`[\u4EFF\u771F\u56FE] \u5DF2\u52A0\u8F7D\u56FE\u5C42:`, Object.keys(layers));
+  checkAndFixDrillAlignment();
+}
+function checkAndFixDrillAlignment() {
+  if (!refBounds) {
+    if (DEBUG) console.log("[\u94BB\u5B54\u5BF9\u9F50] \u672A\u627E\u5230\u53C2\u8003\u8FB9\u754C\uFF0C\u8DF3\u8FC7\u5BF9\u9F50\u68C0\u67E5");
+    return;
+  }
+  const refLayerTypes = ["GTL", "GBL", "GTS", "GBS", "GTO", "GBO"];
+  let refLayerName = "REF";
+  for (const t of refLayerTypes) {
+    if (layers[t] && layers[t].bounds) {
+      refLayerName = t;
+      break;
+    }
+  }
+  if (refLayerName === "REF") {
+    const sigKeys = Object.keys(layers).filter((k) => /^SIG\d+$/i.test(k)).sort();
+    for (const t of sigKeys) {
+      if (layers[t] && layers[t].bounds) {
+        refLayerName = t;
+        break;
+      }
+    }
+  }
+  const computeOverflow = (b, ref) => {
+    const left = Math.max(0, ref.minX - b.minX);
+    const right = Math.max(0, b.maxX - ref.maxX);
+    const bottom = Math.max(0, ref.minY - b.minY);
+    const top = Math.max(0, b.maxY - ref.maxY);
+    const total = left + right + bottom + top;
+    return { left, right, bottom, top, total };
+  };
+  const translateBounds = (b, dx, dy) => ({
+    minX: b.minX + dx,
+    maxX: b.maxX + dx,
+    minY: b.minY + dy,
+    maxY: b.maxY + dy
+  });
+  const extractCircleCenters = (layerData, layerName = "") => {
+    if (!layerData || !layerData.vertices || !layerData.lineStrips) {
+      if (DEBUG) console.log(`[\u7279\u5F81\u63D0\u53D6] ${layerName}: \u6570\u636E\u65E0\u6548`);
+      return [];
+    }
+    const centers = [];
+    const vertices = layerData.vertices;
+    const lineStrips = layerData.lineStrips;
+    if (DEBUG) console.log(`[\u7279\u5F81\u63D0\u53D6] ${layerName}: \u5171\u6709 ${lineStrips.length} \u4E2A lineStrips`);
+    let skippedTooFew = 0;
+    let skippedAspect = 0;
+    let skippedTooSmall = 0;
+    for (const strip of lineStrips) {
+      if (strip.count < 6) {
+        skippedTooFew++;
+        continue;
+      }
+      let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+      for (let i = 0; i < strip.count; i++) {
+        const ptr = (strip.start + i) * 3;
+        const x = vertices[ptr];
+        const y = vertices[ptr + 1];
+        minX = Math.min(minX, x);
+        minY = Math.min(minY, y);
+        maxX = Math.max(maxX, x);
+        maxY = Math.max(maxY, y);
+      }
+      const w = maxX - minX;
+      const h = maxY - minY;
+      const aspectRatio = Math.max(w, h) / Math.max(1e-4, Math.min(w, h));
+      if (aspectRatio > 2) {
+        skippedAspect++;
+        continue;
+      }
+      if (w < 0.01 || h < 0.01) {
+        skippedTooSmall++;
+        continue;
+      }
+      const cx = (minX + maxX) / 2;
+      const cy = (minY + maxY) / 2;
+      const r = (w + h) / 4;
+      centers.push({ x: cx, y: cy, r });
+    }
+    if (DEBUG) {
+      console.log(`[\u7279\u5F81\u63D0\u53D6] ${layerName}: \u63D0\u53D6\u4E86 ${centers.length} \u4E2A\u5706\u5F62\u7279\u5F81\u70B9 (\u8DF3\u8FC7: \u70B9\u6570\u4E0D\u8DB3=${skippedTooFew}, \u5BBD\u9AD8\u6BD4\u5F02\u5E38=${skippedAspect}, \u5C3A\u5BF8\u592A\u5C0F=${skippedTooSmall})`);
+      if (centers.length > 0) {
+        const showCount = Math.min(5, centers.length);
+        console.log(`[\u7279\u5F81\u63D0\u53D6] ${layerName}: \u524D ${showCount} \u4E2A\u7279\u5F81\u70B9\u5750\u6807:`);
+        for (let i = 0; i < showCount; i++) {
+          console.log(`  ${i}: (${centers[i].x.toFixed(4)}, ${centers[i].y.toFixed(4)}), \u76F4\u5F84=${(centers[i].r * 2).toFixed(4)}`);
+        }
+      }
+    }
+    return centers;
+  };
+  const estimateOffsetByVoting = (drillCenters, refCenters, binSize = 0.5) => {
+    if (drillCenters.length < 2 || refCenters.length < 2) return null;
+    const coarseBinSize = Math.max(binSize, 0.02);
+    const votes = /* @__PURE__ */ new Map();
+    for (const drill of drillCenters) {
+      for (const ref of refCenters) {
+        const dx = ref.x - drill.x;
+        const dy = ref.y - drill.y;
+        const qx = Math.round(dx / coarseBinSize) * coarseBinSize;
+        const qy = Math.round(dy / coarseBinSize) * coarseBinSize;
+        const key = `${qx.toFixed(3)}_${qy.toFixed(3)}`;
+        if (!votes.has(key)) {
+          votes.set(key, { dx: qx, dy: qy, count: 0, pairs: [] });
+        }
+        const v = votes.get(key);
+        v.count++;
+        v.pairs.push({ drill, ref, dx, dy });
+      }
+    }
+    const allVotes = Array.from(votes.values()).sort((a, b) => b.count - a.count);
+    if (DEBUG && allVotes.length > 0) {
+      const topVotes = allVotes.slice(0, 5);
+      console.log(`[\u6295\u7968] \u7C97\u5339\u914D\u524D ${topVotes.length} \u4E2A\u5019\u9009\u504F\u79FB (binSize=${coarseBinSize}):`);
+      topVotes.forEach((v, i) => {
+        console.log(`  ${i + 1}. dx=${v.dx.toFixed(2)}, dy=${v.dy.toFixed(2)}, votes=${v.count}`);
+      });
+    }
+    if (allVotes.length === 0 || allVotes[0].count < 2) return null;
+    const bestCoarse = allVotes[0];
+    const tolerance = coarseBinSize * 1.5;
+    const sizeToleranceRatio = 3;
+    const allPairs = [];
+    for (let di = 0; di < drillCenters.length; di++) {
+      const drill = drillCenters[di];
+      for (let ri = 0; ri < refCenters.length; ri++) {
+        const ref = refCenters[ri];
+        const drillR = drill.r || 0;
+        const refR = ref.r || 0;
+        if (drillR > 0 && refR > 0) {
+          const sizeRatio = Math.max(drillR, refR) / Math.min(drillR, refR);
+          if (sizeRatio > sizeToleranceRatio) {
+            continue;
+          }
+        }
+        const shiftedDx = drill.x + bestCoarse.dx - ref.x;
+        const shiftedDy = drill.y + bestCoarse.dy - ref.y;
+        const dist = Math.sqrt(shiftedDx * shiftedDx + shiftedDy * shiftedDy);
+        if (dist < tolerance) {
+          allPairs.push({
+            drillIdx: di,
+            refIdx: ri,
+            drill,
+            ref,
+            dist,
+            dx: ref.x - drill.x,
+            dy: ref.y - drill.y
+          });
+        }
+      }
+    }
+    allPairs.sort((a, b) => a.dist - b.dist);
+    const usedDrill = /* @__PURE__ */ new Set();
+    const usedRef = /* @__PURE__ */ new Set();
+    const refinedPairs = [];
+    for (const pair of allPairs) {
+      if (usedDrill.has(pair.drillIdx) || usedRef.has(pair.refIdx)) continue;
+      refinedPairs.push(pair);
+      usedDrill.add(pair.drillIdx);
+      usedRef.add(pair.refIdx);
+    }
+    if (refinedPairs.length < 2) {
+      return {
+        dx: bestCoarse.dx,
+        dy: bestCoarse.dy,
+        votes: bestCoarse.count
+      };
+    }
+    const tolRefine = 0.012;
+    const matchedPairs = [];
+    const usedRefIndices = /* @__PURE__ */ new Set();
+    for (const drill of drillCenters) {
+      const transformedX = drill.x + bestCoarse.dx;
+      const transformedY = drill.y + bestCoarse.dy;
+      let minDistance = Infinity;
+      let nearestRef = null;
+      let nearestIdx = -1;
+      for (let i = 0; i < refCenters.length; i++) {
+        if (usedRefIndices.has(i)) continue;
+        const ref = refCenters[i];
+        const dist = Math.sqrt(Math.pow(transformedX - ref.x, 2) + Math.pow(transformedY - ref.y, 2));
+        if (dist < minDistance) {
+          minDistance = dist;
+          nearestRef = ref;
+          nearestIdx = i;
+        }
+      }
+      if (minDistance <= tolRefine && nearestIdx !== -1) {
+        usedRefIndices.add(nearestIdx);
+        matchedPairs.push({
+          drill,
+          ref: nearestRef,
+          dx: nearestRef.x - drill.x,
+          dy: nearestRef.y - drill.y,
+          error: minDistance
+        });
+      }
+    }
+    if (matchedPairs.length < 2) {
+      return {
+        dx: bestCoarse.dx,
+        dy: bestCoarse.dy,
+        votes: bestCoarse.count
+      };
+    }
+    let sumDx = 0, sumDy = 0;
+    for (const p of matchedPairs) {
+      sumDx += p.dx;
+      sumDy += p.dy;
+    }
+    const finalDx = sumDx / matchedPairs.length;
+    const finalDy = sumDy / matchedPairs.length;
+    if (DEBUG) {
+      console.log(`[\u6295\u7968] \u7CBE\u7EC6\u5316(2dPage\u65B9\u5F0F): \u7C97\u5339\u914D=(${bestCoarse.dx.toFixed(3)}, ${bestCoarse.dy.toFixed(3)}), \u5339\u914D\u5BF9=${matchedPairs.length}/${drillCenters.length}`);
+      const errors = matchedPairs.map((p) => p.error);
+      const avgError = errors.reduce((s, v) => s + v, 0) / errors.length;
+      const maxError = Math.max(...errors);
+      console.log(`[\u6295\u7968] \u5339\u914D\u8BEF\u5DEE: avg=${avgError.toFixed(4)}, max=${maxError.toFixed(4)}`);
+      console.log(`[\u6295\u7968] \u914D\u5BF9\u8BE6\u60C5:`);
+      for (let i = 0; i < Math.min(matchedPairs.length, 5); i++) {
+        const p = matchedPairs[i];
+        console.log(`  ${i}: \u94BB\u5B54(${p.drill.x.toFixed(3)}, ${p.drill.y.toFixed(3)}) -> \u710A\u76D8(${p.ref.x.toFixed(3)}, ${p.ref.y.toFixed(3)}), offset=(${p.dx.toFixed(3)}, ${p.dy.toFixed(3)}), err=${p.error.toFixed(4)}`);
+      }
+      console.log(`[\u6295\u7968] \u7CBE\u786E\u504F\u79FB(\u5E73\u5747\u503C): dx=${finalDx.toFixed(3)}, dy=${finalDy.toFixed(3)}`);
+    }
+    return {
+      dx: finalDx,
+      dy: finalDy,
+      votes: refinedPairs.length
+    };
+  };
+  const verifyOffset = (drillCenters, refCenters, dx, dy, tolerance = 0.5) => {
+    let matchCount = 0;
+    let totalError = 0;
+    for (const drill of drillCenters) {
+      const shiftedX = drill.x + dx;
+      const shiftedY = drill.y + dy;
+      let minDist = Infinity;
+      for (const ref of refCenters) {
+        const dist = Math.sqrt((shiftedX - ref.x) ** 2 + (shiftedY - ref.y) ** 2);
+        minDist = Math.min(minDist, dist);
+      }
+      if (minDist < tolerance) {
+        matchCount++;
+        totalError += minDist;
+      }
+    }
+    return {
+      matchCount,
+      matchRate: drillCenters.length > 0 ? matchCount / drillCenters.length : 0,
+      avgError: matchCount > 0 ? totalError / matchCount : Infinity
+    };
+  };
+  const drillLayerTypes = ["DRL", "DRL2"];
+  let needRecalcBounds = false;
+  for (const drlType of drillLayerTypes) {
+    const drillLayer = layers[drlType];
+    if (!drillLayer || !drillLayer.bounds) continue;
+    let drillBounds = drillLayer.bounds;
+    const refLayerBounds = refBounds;
+    const refWidth = refLayerBounds.maxX - refLayerBounds.minX;
+    const refHeight = refLayerBounds.maxY - refLayerBounds.minY;
+    let drillWidth = drillBounds.maxX - drillBounds.minX;
+    let drillHeight = drillBounds.maxY - drillBounds.minY;
+    const ratioX = drillWidth > 0 && refWidth > 0 ? drillWidth / refWidth : 1;
+    const ratioY = drillHeight > 0 && refHeight > 0 ? drillHeight / refHeight : 1;
+    if (DEBUG) {
+      console.log(`[\u94BB\u5B54\u5BF9\u9F50] ${drlType} \u8FB9\u754C: (${drillBounds.minX.toFixed(3)}, ${drillBounds.minY.toFixed(3)}) - (${drillBounds.maxX.toFixed(3)}, ${drillBounds.maxY.toFixed(3)})`);
+      console.log(`[\u94BB\u5B54\u5BF9\u9F50] ${drlType} \u5C3A\u5BF8: ${drillWidth.toFixed(3)} x ${drillHeight.toFixed(3)}`);
+      console.log(`[\u94BB\u5B54\u5BF9\u9F50] \u53C2\u8003\u8FB9\u754C(\u5408\u5E76${refLayerName}\u7B49): (${refLayerBounds.minX.toFixed(3)}, ${refLayerBounds.minY.toFixed(3)}) - (${refLayerBounds.maxX.toFixed(3)}, ${refLayerBounds.maxY.toFixed(3)})`);
+      console.log(`[\u94BB\u5B54\u5BF9\u9F50] \u53C2\u8003\u8FB9\u754C\u5C3A\u5BF8: ${refWidth.toFixed(3)} x ${refHeight.toFixed(3)}`);
+      console.log(`[\u94BB\u5B54\u5BF9\u9F50] ${drlType} \u6BD4\u4F8B: X=${ratioX.toFixed(2)}, Y=${ratioY.toFixed(2)}`);
+    }
+    const decidePow10Scale = (ratio) => {
+      if (!Number.isFinite(ratio) || ratio <= 0) return 1;
+      if (ratio > 2) {
+        const pow10 = Math.pow(10, Math.round(Math.log10(ratio)));
+        const cand = 1 / pow10;
+        const newRatio = ratio * cand;
+        if (cand !== 1 && newRatio >= 0.7 && newRatio <= 1.3) return cand;
+      } else if (ratio < 0.5) {
+        const inv = 1 / ratio;
+        const pow10 = Math.pow(10, Math.round(Math.log10(inv)));
+        const cand = pow10;
+        const newRatio = ratio * cand;
+        if (cand !== 1 && newRatio >= 0.7 && newRatio <= 1.3) return cand;
+      }
+      return 1;
+    };
+    const scaleX = decidePow10Scale(ratioX);
+    const scaleY = decidePow10Scale(ratioY);
+    const data = drillLayer.data;
+    if (!data || !data.vertices || !data.lineStrips) continue;
+    const vertices = data.vertices;
+    const lineStrips = data.lineStrips;
+    if (scaleX !== 1 || scaleY !== 1) {
+      console.warn(`[\u94BB\u5B54\u5BF9\u9F50] \u26A0\uFE0F ${drlType} \u9700\u8981\u7F29\u653E: scaleX=${scaleX}, scaleY=${scaleY}`);
+      for (const strip of lineStrips) {
+        if (strip.count < 3) continue;
+        let sumX = 0, sumY = 0;
+        for (let i = 0; i < strip.count; i++) {
+          const ptr = (strip.start + i) * 3;
+          sumX += vertices[ptr];
+          sumY += vertices[ptr + 1];
+        }
+        const cx = sumX / strip.count;
+        const cy = sumY / strip.count;
+        const newCx = cx * scaleX;
+        const newCy = cy * scaleY;
+        const dx = newCx - cx;
+        const dy = newCy - cy;
+        for (let i = 0; i < strip.count; i++) {
+          const ptr = (strip.start + i) * 3;
+          vertices[ptr] += dx;
+          vertices[ptr + 1] += dy;
+        }
+      }
+      drillBounds = {
+        minX: drillBounds.minX * scaleX,
+        maxX: drillBounds.maxX * scaleX,
+        minY: drillBounds.minY * scaleY,
+        maxY: drillBounds.maxY * scaleY
+      };
+      drillLayer.bounds = drillBounds;
+      drillWidth = drillBounds.maxX - drillBounds.minX;
+      drillHeight = drillBounds.maxY - drillBounds.minY;
+      if (DEBUG) console.log(`[\u94BB\u5B54\u5BF9\u9F50] \u2713 ${drlType} \u5DF2\u7F29\u653E\uFF0C\u65B0\u5C3A\u5BF8: ${drillWidth.toFixed(3)} x ${drillHeight.toFixed(3)}`);
+      needRecalcBounds = true;
+    }
+    const refLayerPriority = ["GTL", "GBL", "GTS", "GBS"];
+    let featureOffset = null;
+    const drillCenters = extractCircleCenters(drillLayer.data, drlType);
+    const isNonPlated = drlType === "DRL2" || drillLayer.name && /np|non-plated/i.test(drillLayer.name);
+    const skipFeatureAlignment = isNonPlated || drillCenters.length < 3;
+    if (skipFeatureAlignment) {
+      if (DEBUG) console.log(`[\u94BB\u5B54\u5BF9\u9F50] ${drlType}: \u8DF3\u8FC7\u7279\u5F81\u70B9\u5BF9\u9F50 (isNonPlated=${isNonPlated}, count=${drillCenters.length})`);
+    }
+    if (DEBUG) console.log(`[\u94BB\u5B54\u5BF9\u9F50] ===== \u5F00\u59CB\u7279\u5F81\u70B9\u5339\u914D =====`);
+    if (DEBUG) console.log(`[\u94BB\u5B54\u5BF9\u9F50] ${drlType} \u8FB9\u754C\u4E2D\u5FC3: (${((drillBounds.minX + drillBounds.maxX) / 2).toFixed(3)}, ${((drillBounds.minY + drillBounds.maxY) / 2).toFixed(3)})`);
+    if (skipFeatureAlignment) {
+      if (DEBUG) console.log(`[\u94BB\u5B54\u5BF9\u9F50] ===== \u8DF3\u8FC7\u7279\u5F81\u70B9\u5339\u914D (DRL2/NPTH \u6216 count < 3) =====`);
+    }
+    for (const refType of refLayerPriority) {
+      if (skipFeatureAlignment) break;
+      const refLayer = layers[refType];
+      if (!refLayer || !refLayer.data) {
+        if (DEBUG) console.log(`[\u94BB\u5B54\u5BF9\u9F50] ${refType}: \u56FE\u5C42\u4E0D\u5B58\u5728\u6216\u65E0\u6570\u636E`);
+        continue;
+      }
+      const refCenters = extractCircleCenters(refLayer.data, refType);
+      if (DEBUG) {
+        const refBds = refLayer.bounds;
+        if (refBds) {
+          console.log(`[\u94BB\u5B54\u5BF9\u9F50] ${refType} \u8FB9\u754C\u4E2D\u5FC3: (${((refBds.minX + refBds.maxX) / 2).toFixed(3)}, ${((refBds.minY + refBds.maxY) / 2).toFixed(3)})`);
+        }
+      }
+      if (drillCenters.length < 2 || refCenters.length < 2) {
+        if (DEBUG) console.log(`[\u94BB\u5B54\u5BF9\u9F50] ${refType}: \u7279\u5F81\u70B9\u4E0D\u8DB3 (drill=${drillCenters.length}, ref=${refCenters.length})`);
+        continue;
+      }
+      const offset = estimateOffsetByVoting(drillCenters, refCenters, 0.02);
+      if (!offset) {
+        if (DEBUG) console.log(`[\u94BB\u5B54\u5BF9\u9F50] ${refType}: \u6295\u7968\u672A\u5F97\u5230\u7ED3\u679C`);
+        continue;
+      }
+      const verification = verifyOffset(drillCenters, refCenters, offset.dx, offset.dy, 1);
+      if (DEBUG) console.log(`[\u94BB\u5B54\u5BF9\u9F50] ${refType} \u6295\u7968\u7ED3\u679C: dx=${offset.dx.toFixed(3)}, dy=${offset.dy.toFixed(3)}, votes=${offset.votes}, matchRate=${(verification.matchRate * 100).toFixed(1)}%`);
+      if (verification.matchRate > 0.3 && offset.votes >= 2) {
+        featureOffset = {
+          dx: offset.dx,
+          dy: offset.dy,
+          matchRate: verification.matchRate,
+          refType
+        };
+        if (DEBUG) console.log(`[\u94BB\u5B54\u5BF9\u9F50] \u2713 \u9009\u62E9 ${refType} \u4F5C\u4E3A\u53C2\u8003\u5C42\u8FDB\u884C\u7279\u5F81\u70B9\u5BF9\u9F50`);
+        break;
+      }
+    }
+    if (DEBUG) console.log(`[\u94BB\u5B54\u5BF9\u9F50] ===== \u7279\u5F81\u70B9\u5339\u914D\u7ED3\u675F =====`);
+    if (featureOffset && (Math.abs(featureOffset.dx) > 0.3 || Math.abs(featureOffset.dy) > 0.3)) {
+      console.warn(`[\u94BB\u5B54\u5BF9\u9F50] \u26A0\uFE0F ${drlType} \u5E94\u7528\u7279\u5F81\u70B9\u5BF9\u9F50(\u53C2\u8003${featureOffset.refType}): X=${featureOffset.dx.toFixed(3)}, Y=${featureOffset.dy.toFixed(3)} (\u5339\u914D\u7387=${(featureOffset.matchRate * 100).toFixed(1)}%)`);
+      for (let k = 0; k < vertices.length; k += 3) {
+        vertices[k] += featureOffset.dx;
+        vertices[k + 1] += featureOffset.dy;
+      }
+      drillLayer.bounds = translateBounds(drillBounds, featureOffset.dx, featureOffset.dy);
+      if (DEBUG) {
+        const newBounds = drillLayer.bounds;
+        console.log(`[\u94BB\u5B54\u5BF9\u9F50] \u2713 ${drlType} \u7279\u5F81\u70B9\u5BF9\u9F50\u540E\u8FB9\u754C: (${newBounds.minX.toFixed(3)}, ${newBounds.minY.toFixed(3)}) - (${newBounds.maxX.toFixed(3)}, ${newBounds.maxY.toFixed(3)})`);
+        if (lineStrips && lineStrips.length > 0) {
+          const firstStrip = lineStrips[0];
+          let sumX = 0, sumY = 0;
+          for (let i = 0; i < firstStrip.count; i++) {
+            const ptr = (firstStrip.start + i) * 3;
+            sumX += vertices[ptr];
+            sumY += vertices[ptr + 1];
+          }
+          const cx = sumX / firstStrip.count;
+          const cy = sumY / firstStrip.count;
+          console.log(`[\u94BB\u5B54\u5BF9\u9F50] \u9A8C\u8BC1: \u7B2C\u4E00\u4E2A\u94BB\u5B54\u4E2D\u5FC3\u4FEE\u6B63\u540E = (${cx.toFixed(3)}, ${cy.toFixed(3)})`);
+          const gtsLayer = layers.GTS;
+          if (gtsLayer && gtsLayer.data && gtsLayer.data.lineStrips && gtsLayer.data.lineStrips.length > 0) {
+            const gtsVerts = gtsLayer.data.vertices;
+            const gtsStrip = gtsLayer.data.lineStrips[0];
+            let gtsMinX = Infinity, gtsMinY = Infinity, gtsMaxX = -Infinity, gtsMaxY = -Infinity;
+            for (let i = 0; i < gtsStrip.count; i++) {
+              const ptr = (gtsStrip.start + i) * 3;
+              gtsMinX = Math.min(gtsMinX, gtsVerts[ptr]);
+              gtsMaxX = Math.max(gtsMaxX, gtsVerts[ptr]);
+              gtsMinY = Math.min(gtsMinY, gtsVerts[ptr + 1]);
+              gtsMaxY = Math.max(gtsMaxY, gtsVerts[ptr + 1]);
+            }
+            const gtsCx = (gtsMinX + gtsMaxX) / 2;
+            const gtsCy = (gtsMinY + gtsMaxY) / 2;
+            console.log(`[\u94BB\u5B54\u5BF9\u9F50] \u5BF9\u6BD4: GTS \u7B2C\u4E00\u4E2A\u5F62\u72B6\u4E2D\u5FC3 = (${gtsCx.toFixed(3)}, ${gtsCy.toFixed(3)})`);
+          }
+        }
+      }
+      needRecalcBounds = true;
+      continue;
+    }
+    const drillCenterX = (drillBounds.minX + drillBounds.maxX) / 2;
+    const drillCenterY = (drillBounds.minY + drillBounds.maxY) / 2;
+    const refCenterX = (refLayerBounds.minX + refLayerBounds.maxX) / 2;
+    const refCenterY = (refLayerBounds.minY + refLayerBounds.maxY) / 2;
+    const centerDistX = Math.abs(drillCenterX - refCenterX);
+    const centerDistY = Math.abs(drillCenterY - refCenterY);
+    const centerDist = Math.sqrt(centerDistX * centerDistX + centerDistY * centerDistY);
+    const sizeRatioX = drillWidth > 0 && refWidth > 0 ? Math.min(drillWidth / refWidth, refWidth / drillWidth) : 0;
+    const sizeRatioY = drillHeight > 0 && refHeight > 0 ? Math.min(drillHeight / refHeight, refHeight / drillHeight) : 0;
+    if (DEBUG) console.log(`[\u94BB\u5B54\u5BF9\u9F50] ${drlType} \u4E2D\u5FC3\u8DDD\u79BB: X=${centerDistX.toFixed(3)}, Y=${centerDistY.toFixed(3)}, total=${centerDist.toFixed(3)}`);
+    if (DEBUG) console.log(`[\u94BB\u5B54\u5BF9\u9F50] ${drlType} \u5C3A\u5BF8\u6BD4\u4F8B: X=${sizeRatioX.toFixed(3)}, Y=${sizeRatioY.toFixed(3)}`);
+    const overflowBefore = computeOverflow(drillBounds, refLayerBounds);
+    if (DEBUG) console.log(`[\u94BB\u5B54\u5BF9\u9F50] ${drlType} Overflow(before): left=${overflowBefore.left.toFixed(3)} right=${overflowBefore.right.toFixed(3)} bottom=${overflowBefore.bottom.toFixed(3)} top=${overflowBefore.top.toFixed(3)} total=${overflowBefore.total.toFixed(3)}`);
+    const applyThresholdMm = 0.5;
+    const centerThresholdMm = 2;
+    const isFullyContained = overflowBefore.total < 0.01;
+    if (isFullyContained) {
+      if (DEBUG) console.log(`[\u94BB\u5B54\u5BF9\u9F50] \u2713 ${drlType} \u5B8C\u5168\u5728\u53C2\u8003\u5C42\u8FB9\u754C\u5185\uFF0C\u65E0\u9700\u5BF9\u9F50`);
+      continue;
+    }
+    const needsAlignment = (centerDist > centerThresholdMm || overflowBefore.total > applyThresholdMm) && sizeRatioX > 0.5 && sizeRatioY > 0.5;
+    if (needsAlignment) {
+      const useCenterAlign = sizeRatioX > 0.85 && sizeRatioY > 0.85;
+      let finalDx = 0, finalDy = 0;
+      if (useCenterAlign) {
+        finalDx = refCenterX - drillCenterX;
+        finalDy = refCenterY - drillCenterY;
+        if (DEBUG) console.log(`[\u94BB\u5B54\u5BF9\u9F50] ${drlType} \u5C3A\u5BF8\u6BD4\u4F8B\u63A5\u8FD1(${sizeRatioX.toFixed(2)}, ${sizeRatioY.toFixed(2)})\uFF0C\u4F7F\u7528\u4E2D\u5FC3\u5BF9\u9F50`);
+      } else {
+        const candidatesX = [
+          0,
+          refLayerBounds.minX - drillBounds.minX,
+          // 左边对齐
+          refLayerBounds.maxX - drillBounds.maxX,
+          // 右边对齐
+          refCenterX - drillCenterX
+          // 中心对齐
+        ];
+        const candidatesY = [
+          0,
+          refLayerBounds.minY - drillBounds.minY,
+          // 底边对齐
+          refLayerBounds.maxY - drillBounds.maxY,
+          // 顶边对齐
+          refCenterY - drillCenterY
+          // 中心对齐
+        ];
+        let best = { dx: 0, dy: 0, error: Infinity, shift: Infinity };
+        for (const dx of candidatesX) {
+          for (const dy of candidatesY) {
+            const afterBounds = translateBounds(drillBounds, dx, dy);
+            const ov = computeOverflow(afterBounds, refLayerBounds);
+            const shift = Math.abs(dx) + Math.abs(dy);
+            if (ov.total < best.error - 1e-6 || Math.abs(ov.total - best.error) < 1e-6 && shift < best.shift) {
+              best = { dx, dy, error: ov.total, shift };
+            }
+          }
+        }
+        finalDx = best.dx;
+        finalDy = best.dy;
+        if (DEBUG) console.log(`[\u94BB\u5B54\u5BF9\u9F50] ${drlType} \u4F7F\u7528\u8FB9\u754C\u5BF9\u9F50\uFF0C\u5019\u9009\u504F\u79FB: X=${best.dx.toFixed(3)}, Y=${best.dy.toFixed(3)} (overflow after=${best.error.toFixed(3)})`);
+      }
+      if (Math.abs(finalDx) >= applyThresholdMm || Math.abs(finalDy) >= applyThresholdMm) {
+        console.warn(`[\u94BB\u5B54\u5BF9\u9F50] \u26A0\uFE0F ${drlType} \u5E94\u7528${useCenterAlign ? "\u4E2D\u5FC3" : "\u8FB9\u754C"}\u5BF9\u9F50: X=${finalDx.toFixed(3)}, Y=${finalDy.toFixed(3)}`);
+        for (let k = 0; k < vertices.length; k += 3) {
+          vertices[k] += finalDx;
+          vertices[k + 1] += finalDy;
+        }
+        drillLayer.bounds = translateBounds(drillBounds, finalDx, finalDy);
+        const overflowAfter = computeOverflow(drillLayer.bounds, refLayerBounds);
+        if (DEBUG) console.log(`[\u94BB\u5B54\u5BF9\u9F50] \u2713 ${drlType} Overflow(after): left=${overflowAfter.left.toFixed(3)} right=${overflowAfter.right.toFixed(3)} bottom=${overflowAfter.bottom.toFixed(3)} top=${overflowAfter.top.toFixed(3)} total=${overflowAfter.total.toFixed(3)}`);
+        needRecalcBounds = true;
+      } else {
+        if (DEBUG) console.log(`[\u94BB\u5B54\u5BF9\u9F50] ${drlType} \u504F\u79FB\u4E0D\u663E\u8457\uFF0C\u8DF3\u8FC7`);
+      }
+    } else {
+      if (DEBUG) console.log(`[\u94BB\u5B54\u5BF9\u9F50] \u2713 ${drlType} \u5DF2\u5BF9\u9F50\uFF08\u4E2D\u5FC3\u8DDD\u79BB < ${centerThresholdMm}mm\uFF0C\u8D8A\u754C < ${applyThresholdMm}mm\uFF09`);
+    }
+  }
+  if (needRecalcBounds) {
+    recalculateBoardBounds();
+  }
+}
+function recalculateBoardBounds() {
+  if (refBounds) {
+    boardBounds = [refBounds.minX, refBounds.minY, refBounds.maxX, refBounds.maxY];
+    if (DEBUG) console.log(`[\u4EFF\u771F\u56FE] \u91CD\u65B0\u8BA1\u7B97\u677F\u5B50\u8FB9\u754C\uFF08\u4F7F\u7528\u53C2\u8003\u8FB9\u754C\uFF09:`, boardBounds);
+    return;
+  }
+  boardBounds = null;
+  for (const [type, layer] of Object.entries(layers)) {
+    if (type === "DRL" || type === "DRL2" || type === "GKO") continue;
+    if (!layer.bounds) continue;
+    const b = layer.bounds;
+    if (!boardBounds) {
+      boardBounds = [b.minX, b.minY, b.maxX, b.maxY];
+    } else {
+      boardBounds[0] = Math.min(boardBounds[0], b.minX);
+      boardBounds[1] = Math.min(boardBounds[1], b.minY);
+      boardBounds[2] = Math.max(boardBounds[2], b.maxX);
+      boardBounds[3] = Math.max(boardBounds[3], b.maxY);
+    }
+  }
+  if (DEBUG) console.log(`[\u4EFF\u771F\u56FE] \u91CD\u65B0\u8BA1\u7B97\u677F\u5B50\u8FB9\u754C:`, boardBounds);
+}
+function getLayerType(fileName) {
+  const name = fileName.toLowerCase();
+  const ext = "." + name.split(".").pop();
+  if (ext === ".gtl") return "GTL";
+  if (ext === ".gbl") return "GBL";
+  if (ext === ".gts") return "GTS";
+  if (ext === ".gbs") return "GBS";
+  if (ext === ".gto") return "GTO";
+  if (ext === ".gbo") return "GBO";
+  if (ext === ".gtp") return "GTP";
+  if (ext === ".gbp") return "GBP";
+  if (ext === ".gko" || ext === ".gm1") return "GKO";
+  if (ext === ".drl" || ext === ".txt") {
+    const fileNameOnly = fileName.split(/[/\\]/).pop().toLowerCase();
+    const baseName = fileNameOnly.replace(/\.[^.]+$/, "");
+    if (baseName === "np" || baseName.startsWith("np-") || baseName.endsWith("-np")) {
+      return "DRL2";
+    }
+    return "DRL";
+  }
+  if (ext === ".bot") return "GBL";
+  if (ext === ".top") return "GTL";
+  if (ext === ".sob") return "GBS";
+  if (ext === ".sot") return "GTS";
+  if (ext === ".sst") return "GTO";
+  if (ext === ".ssb") return "GBO";
+  if (ext === ".smt") return "GTS";
+  if (ext === ".smb") return "GBS";
+  if (ext === ".pmt") return "GTP";
+  if (ext === ".pmb") return "GBP";
+  if (ext === ".ser") return "GTO";
+  if (ext === ".dri") return "DRL";
+  if (ext === ".d") return "DRL";
+  if (ext === ".art") {
+    const fileNameOnly = fileName.split(/[/\\]/).pop();
+    const dot = fileNameOnly.lastIndexOf(".");
+    const stemUpper = (dot > 0 ? fileNameOnly.substring(0, dot) : fileNameOnly).toUpperCase();
+    if (stemUpper === "SST") return "GTO";
+    if (stemUpper === "SMT") return "GTS";
+    if (stemUpper === "TOP") return "GTL";
+    if (stemUpper === "BOT") return "GBL";
+    if (stemUpper === "SMB") return "GBS";
+    if (stemUpper === "SSB") return "GBO";
+    if (stemUpper === "OUT") return "GKO";
+    const layMatch = stemUpper.match(/^LAY(\d+)$/);
+    if (layMatch) {
+      return null;
+    }
+    return null;
+  }
+  if (ext === ".pho") {
+    const fileNameOnly = fileName.split(/[/\\]/).pop();
+    const nameUpper = fileNameOnly.toUpperCase();
+    const isTopLayer = (numberStr) => {
+      if (!numberStr) return true;
+      const prefix3 = numberStr.substring(0, 3);
+      const num = parseInt(prefix3, 10);
+      return num <= 1;
+    };
+    if (nameUpper.startsWith("SST")) {
+      return "GTO";
+    }
+    if (nameUpper.startsWith("SSB")) {
+      return "GBO";
+    }
+    if (nameUpper.startsWith("SMD")) {
+      const numberMatch = nameUpper.match(/^SMD(\d+)/);
+      if (numberMatch) {
+        return isTopLayer(numberMatch[1]) ? "GTP" : "GBP";
+      }
+      return "GTP";
+    }
+    if (nameUpper.startsWith("SM")) {
+      const numberMatch = nameUpper.match(/^SM(\d+)/);
+      if (numberMatch) {
+        return isTopLayer(numberMatch[1]) ? "GTS" : "GBS";
+      }
+      return "GTS";
+    }
+    if (nameUpper.startsWith("ART")) {
+      const numberMatch = nameUpper.match(/^ART(\d+)/);
+      if (numberMatch) {
+        return isTopLayer(numberMatch[1]) ? "GTL" : "GBL";
+      }
+      return "GTL";
+    }
+    if (nameUpper.startsWith("DRL")) {
+      return "DRL";
+    }
+    if (nameUpper.startsWith("OUT")) {
+      return "GKO";
+    }
+    return null;
+  }
+  if (ext === ".gbr") {
+    const fileNameOnly = fileName.split(/[/\\]/).pop() || "";
+    const nu = fileNameOnly.toUpperCase();
+    if (/EDGE[._-]CUTS/i.test(nu)) return "GKO";
+    if (/F[._-]CU\b/i.test(nu)) return "GTL";
+    if (/B[._-]CU\b/i.test(nu)) return "GBL";
+    const inM = nu.match(/IN(\d+)[._-]CU/i);
+    if (inM) return "SIG" + (parseInt(inM[1], 10) + 1);
+  }
+  if (/^\.g\d+$/.test(ext)) {
+    const fileNameOnly = fileName.split(/[/\\]/).pop() || "";
+    const nu = fileNameOnly.toUpperCase();
+    const inM = nu.match(/IN(\d+)[._-]CU/i);
+    if (inM) return "SIG" + (parseInt(inM[1], 10) + 1);
+    const gd = ext.match(/^\.g(\d+)$/);
+    if (gd) return "SIG" + (parseInt(gd[1], 10) + 1);
+  }
+  if (/^\.gp\d+$/.test(ext)) {
+    const gpd = ext.match(/^\.gp(\d+)$/);
+    if (gpd) return "GP" + parseInt(gpd[1], 10);
+  }
+  if (name.includes("top") && name.includes("copper")) return "GTL";
+  if (name.includes("bottom") && name.includes("copper")) return "GBL";
+  if (name.includes("top") && name.includes("mask")) return "GTS";
+  if (name.includes("bottom") && name.includes("mask")) return "GBS";
+  if (name.includes("top") && name.includes("silk")) return "GTO";
+  if (name.includes("bottom") && name.includes("silk")) return "GBO";
+  if (name.includes("outline") || name.includes("profile")) return "GKO";
+  if (name.includes("drill")) return "DRL";
+  return null;
+}
+function render() {
+  if (renderRAF) {
+    cancelAnimationFrame(renderRAF);
+  }
+  renderRAF = requestAnimationFrame(doRender);
+}
+function invalidateCache() {
+  layerCache.dirty = true;
+  layerCache.top = null;
+  layerCache.bottom = null;
+}
+function doRender() {
+  renderRAF = null;
+  const container = document.getElementById("canvasContainer");
+  const containerWidth = container.clientWidth;
+  const containerHeight = container.clientHeight;
+  const pixelRatio = window.devicePixelRatio || 1;
+  canvas.width = containerWidth * pixelRatio;
+  canvas.height = containerHeight * pixelRatio;
+  canvas.style.width = `${containerWidth}px`;
+  canvas.style.height = `${containerHeight}px`;
+  ctx.fillStyle = "#1a1a1a";
+  ctx.fillRect(0, 0, canvas.width, canvas.height);
+  if (!boardBounds || Object.keys(layers).length === 0) return;
+  const boardWidth = boardBounds[2] - boardBounds[0];
+  const boardHeight = boardBounds[3] - boardBounds[1];
+  if (DEBUG) console.log(`[\u4EFF\u771F\u56FE] render: boardBounds = [${boardBounds.map((v) => v.toFixed(2)).join(", ")}], \u5C3A\u5BF8 = ${boardWidth.toFixed(2)} x ${boardHeight.toFixed(2)}`);
+  const firstLayer = Object.values(layers)[0];
+  unitScale = firstLayer && (firstLayer.units === "in" || firstLayer.units === "inch") ? 25.4 : 1;
+  const displayWidth = boardWidth * unitScale;
+  const displayHeight = boardHeight * unitScale;
+  const baseScale = Math.min(
+    containerWidth / displayWidth,
+    containerHeight / displayHeight
+  ) * 0.9;
+  const finalScale = baseScale * pixelRatio * unitScale * zoomLevel;
+  const useDirectRender = zoomLevel > 1.01;
+  if (useDirectRender) {
+    renderDirect(ctx, canvas.width, canvas.height, boardBounds, boardWidth, boardHeight, finalScale, baseScale, displayWidth, displayHeight, pixelRatio);
+  } else {
+    const needRebuildCache = layerCache.dirty || layerCache.lastWidth !== canvas.width || layerCache.lastHeight !== canvas.height;
+    if (needRebuildCache) {
+      const baseRenderScale = baseScale * pixelRatio * unitScale;
+      layerCache.top = createViewCache("top", canvas.width, canvas.height, boardBounds, boardWidth, boardHeight, baseRenderScale, baseScale, displayWidth, displayHeight, pixelRatio);
+      layerCache.bottom = createViewCache("bottom", canvas.width, canvas.height, boardBounds, boardWidth, boardHeight, baseRenderScale, baseScale, displayWidth, displayHeight, pixelRatio);
+      layerCache.dirty = false;
+      layerCache.lastWidth = canvas.width;
+      layerCache.lastHeight = canvas.height;
+    }
+    const cachedCanvas = currentView === "top" ? layerCache.top : layerCache.bottom;
+    if (cachedCanvas) {
+      const centerX = canvas.width / 2;
+      const centerY = canvas.height / 2;
+      ctx.save();
+      ctx.imageSmoothingEnabled = false;
+      ctx.translate(centerX, centerY);
+      ctx.scale(zoomLevel, zoomLevel);
+      ctx.translate(-centerX + panOffset.x * pixelRatio, -centerY + panOffset.y * pixelRatio);
+      ctx.drawImage(cachedCanvas, 0, 0);
+      ctx.restore();
+    }
+  }
+}
+function renderDirect(ctx2, width, height, boardBounds2, boardWidth, boardHeight, finalScale, baseScale, displayWidth, displayHeight, pixelRatio) {
+  const containerWidth = width / pixelRatio;
+  const containerHeight = height / pixelRatio;
+  const scaledWidth = displayWidth * baseScale * zoomLevel;
+  const scaledHeight = displayHeight * baseScale * zoomLevel;
+  const offsetX = (containerWidth - scaledWidth) / 2 * pixelRatio + panOffset.x * pixelRatio;
+  const offsetY = (containerHeight - scaledHeight) / 2 * pixelRatio + panOffset.y * pixelRatio;
+  ctx2.save();
+  ctx2.translate(offsetX, offsetY);
+  const isTop = currentView === "top";
+  if (isTop) {
+    ctx2.scale(finalScale, finalScale);
+    ctx2.translate(-boardBounds2[0], -boardBounds2[1]);
+  } else {
+    ctx2.translate(scaledWidth * pixelRatio, 0);
+    ctx2.scale(-finalScale, finalScale);
+    ctx2.translate(-boardBounds2[0], -boardBounds2[1]);
+  }
+  const copperLayer = isTop ? layers.GTL : layers.GBL;
+  const maskLayer = isTop ? layers.GTS : layers.GBS;
+  const silkLayer = isTop ? layers.GTO : layers.GBO;
+  const outlineLayer = layers.GKO;
+  const drillLayer = layers.DRL;
+  ctx2.fillStyle = "#226B0E";
+  ctx2.fillRect(boardBounds2[0], boardBounds2[1], boardWidth, boardHeight);
+  if (outlineLayer && outlineLayer.data) {
+    ctx2.fillStyle = "#2d5a28";
+    drawOutlineFillAllClosed(ctx2, outlineLayer.data);
+  } else {
+    ctx2.fillStyle = "#2d5a28";
+    ctx2.fillRect(boardBounds2[0], boardBounds2[1], boardWidth, boardHeight);
+  }
+  if (copperLayer && copperLayer.data) {
+    ctx2.fillStyle = "#40721E";
+    ctx2.strokeStyle = "#40721E";
+    ctx2.lineWidth = 0.08 / unitScale;
+    drawLayerData(ctx2, copperLayer.data, true);
+  }
+  if (config.showMask) {
+    ctx2.fillStyle = hexToRgba(config.maskColor, 0.65);
+    if (outlineLayer && outlineLayer.data) {
+      drawOutlineFillAllClosed(ctx2, outlineLayer.data);
+    } else {
+      ctx2.fillRect(boardBounds2[0], boardBounds2[1], boardWidth, boardHeight);
+    }
+  }
+  if (maskLayer && maskLayer.data) {
+    ctx2.fillStyle = FINISH_COLORS[config.surfaceFinish];
+    ctx2.strokeStyle = FINISH_COLORS[config.surfaceFinish];
+    drawLayerData(ctx2, maskLayer.data, false);
+  }
+  if (config.showSilk && silkLayer && silkLayer.data) {
+    ctx2.fillStyle = config.silkColor;
+    ctx2.strokeStyle = config.silkColor;
+    ctx2.lineWidth = 0.4 / unitScale;
+    drawLayerData(ctx2, silkLayer.data, false);
+  }
+  if (config.showDrill) {
+    ctx2.fillStyle = "#1a1a1a";
+    if (drillLayer && drillLayer.data) {
+      drawDrillHoles(ctx2, drillLayer.data);
+    }
+    const drillLayer2 = layers.DRL2;
+    if (drillLayer2 && drillLayer2.data) {
+      drawDrillHoles(ctx2, drillLayer2.data);
+    }
+  }
+  ctx2.restore();
+}
+function createViewCache(view, width, height, boardBounds2, boardWidth, boardHeight, baseRenderScale, baseScale, displayWidth, displayHeight, pixelRatio) {
+  const offscreen = document.createElement("canvas");
+  offscreen.width = width;
+  offscreen.height = height;
+  const offCtx = offscreen.getContext("2d");
+  offCtx.fillStyle = "#1a1a1a";
+  offCtx.fillRect(0, 0, width, height);
+  const containerWidth = width / pixelRatio;
+  const containerHeight = height / pixelRatio;
+  const scaledWidth = displayWidth * baseScale;
+  const scaledHeight = displayHeight * baseScale;
+  const offsetX = (containerWidth - scaledWidth) / 2 * pixelRatio;
+  const offsetY = (containerHeight - scaledHeight) / 2 * pixelRatio;
+  offCtx.save();
+  offCtx.translate(offsetX, offsetY);
+  const isTop = view === "top";
+  if (isTop) {
+    offCtx.scale(baseRenderScale, baseRenderScale);
+    offCtx.translate(-boardBounds2[0], -boardBounds2[1]);
+  } else {
+    offCtx.translate(scaledWidth * pixelRatio, 0);
+    offCtx.scale(-baseRenderScale, baseRenderScale);
+    offCtx.translate(-boardBounds2[0], -boardBounds2[1]);
+  }
+  const copperLayer = isTop ? layers.GTL : layers.GBL;
+  const maskLayer = isTop ? layers.GTS : layers.GBS;
+  const silkLayer = isTop ? layers.GTO : layers.GBO;
+  const outlineLayer = layers.GKO;
+  const drillLayer = layers.DRL;
+  offCtx.fillStyle = "#226B0E";
+  offCtx.fillRect(boardBounds2[0], boardBounds2[1], boardWidth, boardHeight);
+  if (outlineLayer && outlineLayer.data) {
+    offCtx.fillStyle = "#2d5a28";
+    drawOutlineFillAllClosed(offCtx, outlineLayer.data);
+  } else {
+    offCtx.fillStyle = "#2d5a28";
+    offCtx.fillRect(boardBounds2[0], boardBounds2[1], boardWidth, boardHeight);
+  }
+  if (copperLayer && copperLayer.data) {
+    offCtx.fillStyle = "#40721E";
+    offCtx.strokeStyle = "#40721E";
+    offCtx.lineWidth = 0.08 / unitScale;
+    drawLayerData(offCtx, copperLayer.data, true);
+  }
+  if (config.showMask) {
+    offCtx.fillStyle = hexToRgba(config.maskColor, 0.65);
+    if (outlineLayer && outlineLayer.data) {
+      drawOutlineFillAllClosed(offCtx, outlineLayer.data);
+    } else {
+      offCtx.fillRect(boardBounds2[0], boardBounds2[1], boardWidth, boardHeight);
+    }
+  }
+  if (maskLayer && maskLayer.data) {
+    if (DEBUG && view === "top" && maskLayer.data.lineStrips && maskLayer.data.lineStrips.length > 0) {
+      const gtsVerts = maskLayer.data.vertices;
+      const showCount = Math.min(3, maskLayer.data.lineStrips.length);
+      console.log(`[\u710A\u76D8\u6E32\u67D3] GTS \u524D ${showCount} \u4E2A\u5F62\u72B6\u5750\u6807:`);
+      for (let i = 0; i < showCount; i++) {
+        const strip = maskLayer.data.lineStrips[i];
+        let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+        for (let j = 0; j < strip.count; j++) {
+          const ptr = (strip.start + j) * 3;
+          minX = Math.min(minX, gtsVerts[ptr]);
+          maxX = Math.max(maxX, gtsVerts[ptr]);
+          minY = Math.min(minY, gtsVerts[ptr + 1]);
+          maxY = Math.max(maxY, gtsVerts[ptr + 1]);
+        }
+        const cx = (minX + maxX) / 2;
+        const cy = (minY + maxY) / 2;
+        console.log(`  GTS\u5F62\u72B6${i}: \u4E2D\u5FC3=(${cx.toFixed(4)}, ${cy.toFixed(4)}), \u5C3A\u5BF8=${(maxX - minX).toFixed(4)}x${(maxY - minY).toFixed(4)}`);
+      }
+    }
+    offCtx.fillStyle = FINISH_COLORS[config.surfaceFinish];
+    offCtx.strokeStyle = FINISH_COLORS[config.surfaceFinish];
+    drawLayerData(offCtx, maskLayer.data, false);
+  }
+  if (config.showSilk && silkLayer && silkLayer.data) {
+    offCtx.fillStyle = config.silkColor;
+    offCtx.strokeStyle = config.silkColor;
+    offCtx.lineWidth = 0.4 / unitScale;
+    drawLayerData(offCtx, silkLayer.data, false);
+  }
+  if (config.showDrill) {
+    offCtx.fillStyle = "#1a1a1a";
+    if (drillLayer && drillLayer.data) {
+      if (DEBUG) console.log(`[\u4EFF\u771F\u56FE] \u6E32\u67D3\u94BB\u5B54\u5C42 DRL (${view}):`, drillLayer.data.lineStrips?.length);
+      drawDrillHoles(offCtx, drillLayer.data);
+    }
+    const drillLayer2 = layers.DRL2;
+    if (drillLayer2 && drillLayer2.data) {
+      if (DEBUG) console.log(`[\u4EFF\u771F\u56FE] \u6E32\u67D3\u94BB\u5B54\u5C42 DRL2 (${view}):`, drillLayer2.data.lineStrips?.length);
+      drawDrillHoles(offCtx, drillLayer2.data);
+    }
+  }
+  offCtx.restore();
+  return offscreen;
+}
+function drawLayerData(ctx2, data, includeTraces = false) {
+  if (!data || !data.lineStrips || !data.vertices) return;
+  const vertices = data.vertices;
+  const lineStrips = data.lineStrips;
+  const shapes = [];
+  const traces = [];
+  for (const strip of lineStrips) {
+    if (strip.count < 2) continue;
+    let ptr = strip.start * 3;
+    const startX = vertices[ptr];
+    const startY = vertices[ptr + 1];
+    const lastPtr = (strip.start + strip.count - 1) * 3;
+    const lastX = vertices[lastPtr];
+    const lastY = vertices[lastPtr + 1];
+    const dist = Math.abs(startX - lastX) + Math.abs(startY - lastY);
+    const isClosed = dist < 2e-3;
+    if (isClosed) {
+      let area = 0;
+      let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+      for (let i = 0; i < strip.count; i++) {
+        const p1 = (strip.start + i) * 3;
+        const p2 = (strip.start + (i + 1) % strip.count) * 3;
+        const x1 = vertices[p1], y1 = vertices[p1 + 1];
+        const x2 = vertices[p2], y2 = vertices[p2 + 1];
+        area += x1 * y2 - x2 * y1;
+        if (x1 < minX) minX = x1;
+        if (y1 < minY) minY = y1;
+        if (x1 > maxX) maxX = x1;
+        if (y1 > maxY) maxY = y1;
+      }
+      area = Math.abs(area) / 2;
+      shapes.push({ strip, area, bbox: { minX, minY, maxX, maxY } });
+    } else {
+      traces.push(strip);
+    }
+  }
+  if (shapes.length > 1 && includeTraces) {
+    const totalArea = shapes.reduce((sum, s) => sum + s.area, 0);
+    const maxArea = Math.max(...shapes.map((s) => s.area));
+    const threshold = totalArea * 0.4;
+    const filteredShapes = shapes.filter((s) => !(s.area > threshold && s.area === maxArea));
+    shapes.length = 0;
+    shapes.push(...filteredShapes);
+  }
+  const SKIP_CONTAINMENT_THRESHOLD = 200;
+  const shapeParent = /* @__PURE__ */ new Map();
+  const shapeChildren = /* @__PURE__ */ new Map();
+  if (shapes.length <= SKIP_CONTAINMENT_THRESHOLD) {
+    for (let i = 0; i < shapes.length; i++) {
+      shapeChildren.set(i, []);
+    }
+    const sortedIndices = shapes.map((_, i) => i).sort((a, b) => shapes[b].area - shapes[a].area);
+    const MAX_PARENT_CANDIDATES = 50;
+    const parentCandidates = sortedIndices.slice(0, MAX_PARENT_CANDIDATES);
+    for (let i = 0; i < sortedIndices.length; i++) {
+      const childIdx = sortedIndices[i];
+      const child = shapes[childIdx];
+      let bestParent = -1;
+      let bestParentArea = Infinity;
+      for (const parentIdx of parentCandidates) {
+        if (parentIdx === childIdx) continue;
+        const parent = shapes[parentIdx];
+        if (parent.area <= child.area) continue;
+        const eps = 1e-3;
+        if (child.bbox.minX >= parent.bbox.minX - eps && child.bbox.maxX <= parent.bbox.maxX + eps && child.bbox.minY >= parent.bbox.minY - eps && child.bbox.maxY <= parent.bbox.maxY + eps) {
+          if (parent.area < bestParentArea) {
+            bestParentArea = parent.area;
+            bestParent = parentIdx;
+          }
+        }
+      }
+      if (bestParent >= 0) {
+        shapeParent.set(childIdx, bestParent);
+        shapeChildren.get(bestParent).push(childIdx);
+      }
+    }
+  } else {
+    for (let i = 0; i < shapes.length; i++) {
+      shapeChildren.set(i, []);
+    }
+  }
+  const topLevelShapes = [];
+  for (let i = 0; i < shapes.length; i++) {
+    if (!shapeParent.has(i)) {
+      topLevelShapes.push(i);
+    }
+  }
+  const rendered = /* @__PURE__ */ new Set();
+  for (const topIdx of topLevelShapes) {
+    if (rendered.has(topIdx)) continue;
+    const shape = shapes[topIdx];
+    const children = shapeChildren.get(topIdx) || [];
+    ctx2.beginPath();
+    let ptr = shape.strip.start * 3;
+    ctx2.moveTo(vertices[ptr], vertices[ptr + 1]);
+    for (let i = 1; i < shape.strip.count; i++) {
+      ptr = (shape.strip.start + i) * 3;
+      ctx2.lineTo(vertices[ptr], vertices[ptr + 1]);
+    }
+    ctx2.closePath();
+    for (const childIdx of children) {
+      const child = shapes[childIdx];
+      ptr = child.strip.start * 3;
+      ctx2.moveTo(vertices[ptr], vertices[ptr + 1]);
+      for (let i = 1; i < child.strip.count; i++) {
+        ptr = (child.strip.start + i) * 3;
+        ctx2.lineTo(vertices[ptr], vertices[ptr + 1]);
+      }
+      ctx2.closePath();
+      rendered.add(childIdx);
+      const grandChildren = shapeChildren.get(childIdx) || [];
+      for (const grandIdx of grandChildren) {
+        if (!rendered.has(grandIdx)) {
+          topLevelShapes.push(grandIdx);
+        }
+      }
+    }
+    ctx2.fill("evenodd");
+    rendered.add(topIdx);
+  }
+  if (includeTraces) {
+    for (const strip of traces) {
+      ctx2.beginPath();
+      let ptr = strip.start * 3;
+      ctx2.moveTo(vertices[ptr], vertices[ptr + 1]);
+      for (let i = 1; i < strip.count; i++) {
+        ptr = (strip.start + i) * 3;
+        ctx2.lineTo(vertices[ptr], vertices[ptr + 1]);
+      }
+      ctx2.stroke();
+    }
+  }
+}
+function drawOutlineFillAllClosed(ctx2, data) {
+  if (!data || !data.lineStrips || !data.vertices) return;
+  const vertices = data.vertices;
+  const lineStrips = data.lineStrips;
+  const closedPaths = [];
+  for (const strip of lineStrips) {
+    if (strip.count < 3) continue;
+    let ptr2 = strip.start * 3;
+    const startX = vertices[ptr2];
+    const startY = vertices[ptr2 + 1];
+    const lastPtr = (strip.start + strip.count - 1) * 3;
+    const lastX = vertices[lastPtr];
+    const lastY = vertices[lastPtr + 1];
+    const dist = Math.sqrt(Math.pow(startX - lastX, 2) + Math.pow(startY - lastY, 2));
+    if (dist < 1) {
+      let area = 0;
+      let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+      for (let i = 0; i < strip.count; i++) {
+        const p1 = (strip.start + i) * 3;
+        const p2 = (strip.start + (i + 1) % strip.count) * 3;
+        area += vertices[p1] * vertices[p2 + 1];
+        area -= vertices[p2] * vertices[p1 + 1];
+        const x = vertices[p1];
+        const y = vertices[p1 + 1];
+        if (x < minX) minX = x;
+        if (x > maxX) maxX = x;
+        if (y < minY) minY = y;
+        if (y > maxY) maxY = y;
+      }
+      area = Math.abs(area) / 2;
+      closedPaths.push({ strip, area, bbox: { minX, minY, maxX, maxY } });
+    }
+  }
+  const sortedByAreaForCheck = [...closedPaths].sort((a, b) => b.area - a.area);
+  const topPaths = sortedByAreaForCheck.slice(0, Math.min(10, sortedByAreaForCheck.length));
+  const strokeOutlineCount = topPaths.filter((path) => {
+    const w = path.bbox.maxX - path.bbox.minX;
+    const h = path.bbox.maxY - path.bbox.minY;
+    const aspectRatio = Math.max(w / h, h / w);
+    return aspectRatio > 50;
+  }).length;
+  const isStrokeOutlineMode = closedPaths.length > 0 && strokeOutlineCount >= topPaths.length * 0.8;
+  if (closedPaths.length === 0 || isStrokeOutlineMode) {
+    if (DEBUG) console.log(`[\u4EFF\u771F\u56FE] GKO\u5C42: \u68C0\u6D4B\u5230\u7EBF\u6761\u8F6E\u5ED3\u6A21\u5F0F\uFF0C\u4F7F\u7528\u53C2\u8003\u8FB9\u754C\u4F5C\u4E3A\u77E9\u5F62\u8F6E\u5ED3`);
+    if (refBounds) {
+      const refWidth = refBounds.maxX - refBounds.minX;
+      const refHeight = refBounds.maxY - refBounds.minY;
+      if (DEBUG) console.log(`[\u4EFF\u771F\u56FE] GKO\u5C42: \u77E9\u5F62\u8F6E\u5ED3 ${refWidth.toFixed(2)} x ${refHeight.toFixed(2)}`);
+      ctx2.beginPath();
+      ctx2.rect(refBounds.minX, refBounds.minY, refWidth, refHeight);
+      ctx2.fill();
+    }
+    return;
+  }
+  let minDimThreshold = 1e-3;
+  let minAreaThreshold = 1e-4;
+  if (refBounds) {
+    const refWidth = refBounds.maxX - refBounds.minX;
+    const refHeight = refBounds.maxY - refBounds.minY;
+    minDimThreshold = Math.min(refWidth, refHeight) * 5e-3;
+    minAreaThreshold = refWidth * refHeight * 1e-3;
+  }
+  const sortedByArea = [...closedPaths].sort((a, b) => b.area - a.area);
+  if (sortedByArea.length > 0) {
+    const top5 = sortedByArea.slice(0, 5);
+    if (DEBUG) console.log(`[\u4EFF\u771F\u56FE] GKO\u5C42: \u9762\u79EF\u6700\u5927\u7684 5 \u4E2A\u533A\u57DF:`);
+    top5.forEach((p, i) => {
+      const w = p.bbox.maxX - p.bbox.minX;
+      const h = p.bbox.maxY - p.bbox.minY;
+      const ar = Math.max(w / h, h / w);
+      if (DEBUG) console.log(`  ${i + 1}. \u9762\u79EF=${p.area.toFixed(4)}, \u5C3A\u5BF8=${w.toFixed(3)} x ${h.toFixed(3)}, \u5BBD\u9AD8\u6BD4=${ar.toFixed(1)}`);
+    });
+  }
+  const validShapePaths = closedPaths.filter((path) => {
+    const pathWidth = path.bbox.maxX - path.bbox.minX;
+    const pathHeight = path.bbox.maxY - path.bbox.minY;
+    const pathArea = path.area;
+    if (pathWidth < minDimThreshold || pathHeight < minDimThreshold) return false;
+    if (pathArea < minAreaThreshold) return false;
+    const aspectRatio = Math.max(pathWidth / pathHeight, pathHeight / pathWidth);
+    if (aspectRatio > 10) return false;
+    return true;
+  });
+  if (DEBUG) console.log(`[\u4EFF\u771F\u56FE] GKO\u5C42: \u5F62\u72B6\u8FC7\u6EE4\u540E ${closedPaths.length} \u2192 ${validShapePaths.length} \u4E2A\u6709\u6548\u533A\u57DF (\u9608\u503C: \u5C3A\u5BF8>${minDimThreshold.toFixed(4)}, \u9762\u79EF>${minAreaThreshold.toFixed(4)})`);
+  let candidatePaths = validShapePaths;
+  if (refBounds && validShapePaths.length > 0) {
+    const refWidth = refBounds.maxX - refBounds.minX;
+    const refHeight = refBounds.maxY - refBounds.minY;
+    const refArea = refWidth * refHeight;
+    const refCenterX = (refBounds.minX + refBounds.maxX) / 2;
+    const refCenterY = (refBounds.minY + refBounds.maxY) / 2;
+    if (DEBUG) console.log(`[\u4EFF\u771F\u56FE] GKO\u5C42: \u53C2\u8003\u8FB9\u754C = ${refWidth.toFixed(2)} x ${refHeight.toFixed(2)}, \u4E2D\u5FC3 = (${refCenterX.toFixed(2)}, ${refCenterY.toFixed(2)})`);
+    const containingPaths = validShapePaths.filter((path) => {
+      const bbox = path.bbox;
+      const margin = Math.max(refWidth, refHeight) * 0.1;
+      const containsRef = bbox.minX <= refBounds.minX + margin && bbox.maxX >= refBounds.maxX - margin && bbox.minY <= refBounds.minY + margin && bbox.maxY >= refBounds.maxY - margin;
+      return containsRef;
+    });
+    if (containingPaths.length > 0) {
+      if (DEBUG) console.log(`[\u4EFF\u771F\u56FE] GKO\u5C42: \u627E\u5230 ${containingPaths.length} \u4E2A\u5305\u542B\u53C2\u8003\u8FB9\u754C\u7684\u8F6E\u5ED3`);
+      candidatePaths = containingPaths;
+    } else {
+      const overlappingPaths = validShapePaths.filter((path) => {
+        const bbox = path.bbox;
+        const pathWidth = bbox.maxX - bbox.minX;
+        const pathHeight = bbox.maxY - bbox.minY;
+        const pathArea = pathWidth * pathHeight;
+        const hasOverlap = !(bbox.maxX < refBounds.minX || bbox.minX > refBounds.maxX || bbox.maxY < refBounds.minY || bbox.minY > refBounds.maxY);
+        const isReasonableSize = pathArea >= refArea * 0.3;
+        return hasOverlap && isReasonableSize;
+      });
+      if (overlappingPaths.length > 0) {
+        if (DEBUG) console.log(`[\u4EFF\u771F\u56FE] GKO\u5C42: \u627E\u5230 ${overlappingPaths.length} \u4E2A\u4E0E\u53C2\u8003\u8FB9\u754C\u91CD\u53E0\u7684\u8F6E\u5ED3`);
+        candidatePaths = overlappingPaths;
+      } else {
+        if (DEBUG) console.log(`[\u4EFF\u771F\u56FE] GKO\u5C42: \u8FC7\u6EE4\u540E\u65E0\u6709\u6548\u533A\u57DF\uFF0C\u4F7F\u7528\u6240\u6709 ${validShapePaths.length} \u4E2A\u6709\u6548\u5F62\u72B6\u533A\u57DF`);
+        candidatePaths = validShapePaths;
+      }
+    }
+  }
+  let mainOutline = null;
+  let useRefBoundsAsOutline = false;
+  if (candidatePaths.length > 1) {
+    candidatePaths.sort((a, b) => b.area - a.area);
+    mainOutline = candidatePaths[0];
+    const selectedWidth = mainOutline.bbox.maxX - mainOutline.bbox.minX;
+    const selectedHeight = mainOutline.bbox.maxY - mainOutline.bbox.minY;
+    if (DEBUG) console.log(`[\u4EFF\u771F\u56FE] GKO\u5C42\u9009\u62E9: \u4ECE ${candidatePaths.length} \u4E2A\u5019\u9009\u533A\u57DF\u4E2D\uFF0C\u9009\u62E9\u9762\u79EF\u6700\u5927\u7684 ${selectedWidth.toFixed(2)} x ${selectedHeight.toFixed(2)} \u7684\u533A\u57DF (\u9762\u79EF=${mainOutline.area.toFixed(4)})`);
+  } else if (candidatePaths.length === 1) {
+    mainOutline = candidatePaths[0];
+    const selectedWidth = mainOutline.bbox.maxX - mainOutline.bbox.minX;
+    const selectedHeight = mainOutline.bbox.maxY - mainOutline.bbox.minY;
+    if (DEBUG) console.log(`[\u4EFF\u771F\u56FE] GKO\u5C42\u9009\u62E9: \u53EA\u6709 1 \u4E2A\u5019\u9009\u533A\u57DF\uFF0C\u5C3A\u5BF8 = ${selectedWidth.toFixed(2)} x ${selectedHeight.toFixed(2)}`);
+  } else if (refBounds) {
+    const refWidth = refBounds.maxX - refBounds.minX;
+    const refHeight = refBounds.maxY - refBounds.minY;
+    if (DEBUG) console.log(`[\u4EFF\u771F\u56FE] GKO\u5C42\u9009\u62E9: \u65E0\u6709\u6548\u8F6E\u5ED3\uFF0C\u4F7F\u7528\u53C2\u8003\u8FB9\u754C\u4F5C\u4E3A\u77E9\u5F62\u8F6E\u5ED3 ${refWidth.toFixed(2)} x ${refHeight.toFixed(2)}`);
+    useRefBoundsAsOutline = true;
+    ctx2.beginPath();
+    ctx2.rect(refBounds.minX, refBounds.minY, refWidth, refHeight);
+    ctx2.fill();
+    return;
+  } else {
+    closedPaths.sort((a, b) => b.area - a.area);
+    mainOutline = closedPaths[0];
+    const selectedWidth = mainOutline.bbox.maxX - mainOutline.bbox.minX;
+    const selectedHeight = mainOutline.bbox.maxY - mainOutline.bbox.minY;
+    if (DEBUG) console.log(`[\u4EFF\u771F\u56FE] GKO\u5C42\u9009\u62E9: \u65E0\u5019\u9009\u533A\u57DF\uFF0C\u9009\u62E9\u9762\u79EF\u6700\u5927\u7684\u533A\u57DF ${selectedWidth.toFixed(2)} x ${selectedHeight.toFixed(2)}`);
+  }
+  const mainBbox = mainOutline.bbox;
+  const innerPaths = candidatePaths.filter((path) => {
+    if (path === mainOutline) return false;
+    const bbox = path.bbox;
+    const isInside = bbox.minX >= mainBbox.minX - 0.1 && bbox.maxX <= mainBbox.maxX + 0.1 && bbox.minY >= mainBbox.minY - 0.1 && bbox.maxY <= mainBbox.maxY + 0.1;
+    const pathWidth = bbox.maxX - bbox.minX;
+    const pathHeight = bbox.maxY - bbox.minY;
+    const mainWidth = mainBbox.maxX - mainBbox.minX;
+    const mainHeight = mainBbox.maxY - mainBbox.minY;
+    const minSize = Math.max(1, Math.min(mainWidth, mainHeight) * 5e-3);
+    const isReasonableSize = pathWidth > minSize && pathHeight > minSize;
+    return isInside && isReasonableSize;
+  });
+  if (DEBUG) console.log(`[\u4EFF\u771F\u56FE] GKO\u5C42\u5F02\u5F62: \u4E3B\u8F6E\u5ED3 + ${innerPaths.length} \u4E2A\u5185\u90E8\u5F00\u53E3/\u94E3\u69FD`);
+  ctx2.beginPath();
+  let ptr = mainOutline.strip.start * 3;
+  ctx2.moveTo(vertices[ptr], vertices[ptr + 1]);
+  for (let i = 1; i < mainOutline.strip.count; i++) {
+    ptr = (mainOutline.strip.start + i) * 3;
+    ctx2.lineTo(vertices[ptr], vertices[ptr + 1]);
+  }
+  ctx2.closePath();
+  for (const innerPath of innerPaths) {
+    ptr = innerPath.strip.start * 3;
+    ctx2.moveTo(vertices[ptr], vertices[ptr + 1]);
+    for (let i = 1; i < innerPath.strip.count; i++) {
+      ptr = (innerPath.strip.start + i) * 3;
+      ctx2.lineTo(vertices[ptr], vertices[ptr + 1]);
+    }
+    ctx2.closePath();
+  }
+  ctx2.fill("evenodd");
+}
+function drawDrillHoles(ctx2, data) {
+  if (!data) return;
+  const vertices = data.vertices;
+  const lineStrips = data.lineStrips;
+  if (!lineStrips || !vertices) {
+    if (DEBUG) console.log("[\u4EFF\u771F\u56FE] \u94BB\u5B54\u6570\u636E\u7F3A\u5931 lineStrips \u6216 vertices");
+    return;
+  }
+  const circles = [];
+  const slots = [];
+  let skippedCount = 0;
+  for (const strip of lineStrips) {
+    if (strip.count < 8) {
+      skippedCount++;
+      continue;
+    }
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (let i = 0; i < strip.count; i++) {
+      const ptr = (strip.start + i) * 3;
+      minX = Math.min(minX, vertices[ptr]);
+      minY = Math.min(minY, vertices[ptr + 1]);
+      maxX = Math.max(maxX, vertices[ptr]);
+      maxY = Math.max(maxY, vertices[ptr + 1]);
+    }
+    const bboxWidth = maxX - minX;
+    const bboxHeight = maxY - minY;
+    const aspectRatio = Math.max(bboxWidth, bboxHeight) / Math.max(1e-3, Math.min(bboxWidth, bboxHeight));
+    const cx = (minX + maxX) / 2;
+    const cy = (minY + maxY) / 2;
+    if (aspectRatio > 1.3) {
+      slots.push({ strip });
+    } else {
+      let sumR = 0;
+      for (let i = 0; i < strip.count; i++) {
+        const ptr = (strip.start + i) * 3;
+        const dx = vertices[ptr] - cx;
+        const dy = vertices[ptr + 1] - cy;
+        sumR += Math.sqrt(dx * dx + dy * dy);
+      }
+      const avgR = sumR / strip.count;
+      if (avgR > 1e-3) {
+        circles.push({ cx, cy, r: avgR });
+      } else {
+        skippedCount++;
+      }
+    }
+  }
+  if (circles.length > 0) {
+    ctx2.beginPath();
+    for (const c of circles) {
+      ctx2.moveTo(c.cx + c.r, c.cy);
+      ctx2.arc(c.cx, c.cy, c.r, 0, Math.PI * 2);
+    }
+    ctx2.fill();
+  }
+  if (slots.length > 0) {
+    ctx2.beginPath();
+    for (const s of slots) {
+      const strip = s.strip;
+      let ptr = strip.start * 3;
+      ctx2.moveTo(vertices[ptr], vertices[ptr + 1]);
+      for (let i = 1; i < strip.count; i++) {
+        ptr = (strip.start + i) * 3;
+        ctx2.lineTo(vertices[ptr], vertices[ptr + 1]);
+      }
+      ctx2.closePath();
+    }
+    ctx2.fill();
+  }
+  if (DEBUG) console.log(`[\u4EFF\u771F\u56FE] \u94BB\u5B54\u6E32\u67D3\u5B8C\u6210: \u7ED8\u5236 ${circles.length + slots.length} \u4E2A (\u5706\u5B54=${circles.length}, \u69FD\u5B54=${slots.length}), \u8DF3\u8FC7 ${skippedCount} \u4E2A`);
+}
+function hexToRgba(hex, alpha) {
+  const r = parseInt(hex.slice(1, 3), 16);
+  const g = parseInt(hex.slice(3, 5), 16);
+  const b = parseInt(hex.slice(5, 7), 16);
+  return `rgba(${r}, ${g}, ${b}, ${alpha})`;
+}
+function setView(view) {
+  currentView = view;
+  document.getElementById("btnTopView").classList.toggle("active", view === "top");
+  document.getElementById("btnBottomView").classList.toggle("active", view === "bottom");
+  panOffset = { x: 0, y: 0 };
+  render();
+}
+function fitToView() {
+  zoomLevel = 1;
+  panOffset = { x: 0, y: 0 };
+}
+function showLoading(text) {
+  loadingText.textContent = text;
+  loadingOverlay.classList.remove("hidden");
+}
+function hideLoading() {
+  loadingOverlay.classList.add("hidden");
+}
+function updateStatus(text, isError = false) {
+  if (statusLeft) {
+    statusLeft.textContent = text;
+  }
+  if (isError) {
+    console.error(`[simulation] \u9519\u8BEF: ${text}`);
+  } else if (text.includes("%")) {
+    console.log(`[simulation] \u72B6\u6001: ${text}`);
+  } else {
+    console.log(`[simulation] \u72B6\u6001: ${text}`);
+  }
+}
+function updateLayerList() {
+}
+function clearAll() {
+  layers = {};
+  boardBounds = null;
+  refBounds = null;
+  zoomLevel = 1;
+  panOffset = { x: 0, y: 0 };
+  invalidateCache();
+  render();
+  updateLayerList();
+  updateStatus("\u5C31\u7EEA");
+}
+function exportImage() {
+  if (!canvas || !boardBounds) {
+    alert("\u8BF7\u5148\u52A0\u8F7D Gerber \u6587\u4EF6");
+    return;
+  }
+  const link = document.createElement("a");
+  link.download = `pcb_simulation_${currentView}.png`;
+  link.href = canvas.toDataURL("image/png");
+  link.click();
+}
+window.simulationViewer = {
+  loadFromId,
+  loadFromUrl,
+  render,
+  setView,
+  config,
+  handleFiles,
+  // 导出文件处理函数，供 render 页面调用
+  initSimulation
+  // 导出初始化函数
+};
+window.simulationHandleFiles = handleFiles;
+//# sourceMappingURL=gerber-simulation-entry-EBDX72XE.js.map