@jetv/chat-widget 0.2.1

package/dist/chunk-O3NXUM6C.js

@@ -0,0 +1,1871 @@
+// src/components/jetPaveGerberViewer/src/viewer-src/3dPage/js/gerber-parser.js
+import { parse, plot, renderSVG } from "web-gerber";
+var DEBUG_MODE = true;
+var debugLog = DEBUG_MODE ? console.log.bind(console) : () => {
+};
+var GerberParser = class _GerberParser {
+  // 存储从Gerber文件中提取的格式信息，供钻孔文件使用
+  static gerberFormatInfo = null;
+  /**
+   * 读取文件为文本
+   */
+  static async readFileAsText(file) {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = (event) => resolve(event.target.result);
+      reader.onerror = (error) => reject(new Error("\u8BFB\u53D6\u6587\u4EF6\u5931\u8D25: " + error.message));
+      reader.readAsText(file);
+    });
+  }
+  /**
+   * 解析 Gerber 文件
+   * @param {File} file - Gerber 文件
+   * @param {string} color - 图层颜色
+   * @returns {Promise<{data: Object, bounds: Object}>} - 解析后的数据
+   */
+  /**
+   * 检查文件扩展名是否是 TX/TX+数字 格式（如 .txt, .tx1, .tx2 等）
+   */
+  static isTxFileExtension(extension) {
+    return extension === ".txt" || /^\.tx\d+$/i.test(extension);
+  }
+  static async parseFile(file, color) {
+    _GerberParser._debugPathCount = 0;
+    const fileNameOnly = file.name.split(/[/\\]/).pop();
+    const fileNameUpper = fileNameOnly.toUpperCase();
+    const lastDotIndex = fileNameOnly.lastIndexOf(".");
+    let fileExtension = "";
+    if (lastDotIndex > 0 && lastDotIndex < fileNameOnly.length - 1) {
+      fileExtension = "." + fileNameOnly.substring(lastDotIndex + 1).toLowerCase();
+    } else {
+      if (/.*_INT\d+$/i.test(fileNameUpper)) {
+        fileExtension = "";
+      } else {
+        fileExtension = "." + fileNameOnly.toLowerCase();
+      }
+    }
+    let gerberStr;
+    let isDrillFile = fileExtension === ".drl" || fileExtension === ".d";
+    let detectedFormat = null;
+    const isTxFile = this.isTxFileExtension(fileExtension);
+    const isTxtDrillFile = fileExtension === ".txt";
+    if (fileExtension === ".drl" || fileExtension === ".d" || isTxFile || isTxtDrillFile) {
+      try {
+        gerberStr = await this.readFileAsText(file);
+        if (isTxFile || fileExtension === ".d" || isTxtDrillFile) {
+          const trimmedContent = gerberStr.trim();
+          const headerLines = trimmedContent.split(/\r?\n/).slice(0, 20).map((line) => line.trim()).filter(Boolean);
+          const hasM48InHeader = headerLines.some((line) => /^M48$/i.test(line));
+          const hasM71M72InHeader = headerLines.some((line) => /^M7[12]$/i.test(line));
+          const hasToolDefInHeader = headerLines.some((line) => /^T\d+/i.test(line));
+          const isExcellonFile = hasM48InHeader || hasM71M72InHeader && hasToolDefInHeader;
+          if (isTxFile && isExcellonFile || fileExtension === ".d" || fileExtension === ".drl" || isTxtDrillFile && isExcellonFile) {
+            if (isTxFile || isTxtDrillFile) {
+              const fileTypeName = fileExtension.toUpperCase();
+              console.log(`[\u94BB\u5B54\u8BC6\u522B] ${file.name} \u662F Excellon \u94BB\u5B54\u6587\u4EF6 (M48=${hasM48InHeader}, M71/M72=${hasM71M72InHeader})`);
+            } else if (fileExtension === ".drl") {
+              debugLog(`\u68C0\u6D4B\u5230 .drl \u6587\u4EF6 ${file.name} \u662F\u94BB\u5B54\u6587\u4EF6`);
+            } else {
+              debugLog(`\u68C0\u6D4B\u5230 .d \u6587\u4EF6 ${file.name} \u662F\u94BB\u5B54\u6587\u4EF6`);
+            }
+            isDrillFile = true;
+            const lines = gerberStr.split("\n").map((line) => line.trim());
+            let hasFileFormat = false;
+            for (const line of lines) {
+              const formatMatch = line.match(/FILE_FORMAT[=:](\d+)[:.](\d+)/i);
+              if (formatMatch) {
+                hasFileFormat = true;
+                detectedFormat = detectedFormat || {};
+                const integerPlaces = parseInt(formatMatch[1]);
+                const decimalPlaces = parseInt(formatMatch[2]);
+                const totalPlaces = integerPlaces + decimalPlaces;
+                detectedFormat.places = [integerPlaces, decimalPlaces];
+                detectedFormat.integerPlaces = integerPlaces;
+                detectedFormat.decimalPlaces = decimalPlaces;
+                detectedFormat.totalPlaces = totalPlaces;
+                debugLog(`\u68C0\u6D4B\u5230\u5750\u6807\u683C\u5F0F: ${integerPlaces}:${decimalPlaces} (${integerPlaces}\u4F4D\u6574\u6570, ${decimalPlaces}\u4F4D\u5C0F\u6570, \u603B\u5171${totalPlaces}\u4F4D)`);
+                if (line.includes("INCH")) {
+                  detectedFormat.unit = "inch";
+                  debugLog("\u68C0\u6D4B\u5230\u5355\u4F4D: INCH");
+                } else if (line.includes("METRIC")) {
+                  detectedFormat.unit = "metric";
+                  debugLog("\u68C0\u6D4B\u5230\u5355\u4F4D: METRIC");
+                }
+                if (line.includes(",TZ") || line.includes("TZ,")) {
+                  detectedFormat.zero = "T";
+                  debugLog("\u68C0\u6D4B\u5230\u96F6\u683C\u5F0F: TZ (Trailing Zeros)");
+                } else if (line.includes(",LZ") || line.includes("LZ,")) {
+                  detectedFormat.zero = "L";
+                  debugLog("\u68C0\u6D4B\u5230\u96F6\u683C\u5F0F: LZ (Leading Zeros)");
+                }
+              }
+            }
+            if (!hasFileFormat) {
+              let hasFmat2 = false;
+              let hasInchTz = false;
+              let hasMetricLz = false;
+              for (const line of lines) {
+                if (line.match(/FMAT\s*,?\s*2/i)) {
+                  hasFmat2 = true;
+                }
+                if (line.match(/INCH\s*,\s*TZ/i) || line.match(/TZ\s*,\s*INCH/i)) {
+                  hasInchTz = true;
+                }
+                if (line.match(/METRIC\s*,\s*LZ/i) || line.match(/LZ\s*,\s*METRIC/i)) {
+                  hasMetricLz = true;
+                }
+                if (line.match(/^INCH/i) || line.includes("INCH,") || line.includes(",INCH")) {
+                  detectedFormat = detectedFormat || {};
+                  detectedFormat.unit = "inch";
+                }
+                if (line.match(/^METRIC/i) || line.includes("METRIC,") || line.includes(",METRIC")) {
+                  detectedFormat = detectedFormat || {};
+                  detectedFormat.unit = "metric";
+                }
+                if (line.match(/^M72$/i)) {
+                  detectedFormat = detectedFormat || {};
+                  detectedFormat.unit = "inch";
+                }
+                if (line.match(/^M71$/i)) {
+                  detectedFormat = detectedFormat || {};
+                  detectedFormat.unit = "metric";
+                }
+                if (line.includes(",TZ") || line.includes("TZ,") || line.match(/^TZ$/i)) {
+                  detectedFormat = detectedFormat || {};
+                  detectedFormat.zero = "T";
+                }
+                if (line.includes(",LZ") || line.includes("LZ,") || line.match(/^LZ$/i)) {
+                  detectedFormat = detectedFormat || {};
+                  detectedFormat.zero = "L";
+                }
+              }
+              if (_GerberParser.gerberFormatInfo && _GerberParser.gerberFormatInfo.places) {
+                detectedFormat = detectedFormat || {};
+                detectedFormat.places = _GerberParser.gerberFormatInfo.places;
+                detectedFormat.integerPlaces = _GerberParser.gerberFormatInfo.integerPlaces;
+                detectedFormat.decimalPlaces = _GerberParser.gerberFormatInfo.decimalPlaces;
+                detectedFormat.totalPlaces = _GerberParser.gerberFormatInfo.totalPlaces;
+                detectedFormat.unit = detectedFormat.unit || _GerberParser.gerberFormatInfo.unit || "inch";
+                detectedFormat.zero = detectedFormat.zero || _GerberParser.gerberFormatInfo.zero || "L";
+                console.log(`[\u683C\u5F0F\u7EE7\u627F] ${file.name}: \u7EE7\u627F Gerber \u683C\u5F0F ${detectedFormat.integerPlaces}:${detectedFormat.decimalPlaces}, \u5355\u4F4D=${detectedFormat.unit}, \u96F6\u683C\u5F0F=${detectedFormat.zero === "L" ? "LZ" : "TZ"}`);
+              } else if (hasFmat2 || hasInchTz) {
+                detectedFormat = detectedFormat || {};
+                detectedFormat.places = [2, 4];
+                detectedFormat.integerPlaces = 2;
+                detectedFormat.decimalPlaces = 4;
+                detectedFormat.totalPlaces = 6;
+                detectedFormat.unit = detectedFormat.unit || "inch";
+                detectedFormat.zero = detectedFormat.zero || (hasInchTz ? "T" : "L");
+                console.log(`[\u683C\u5F0F\u63A8\u65AD] ${file.name}: FMAT,2/INCH \u683C\u5F0F 2:4, \u5355\u4F4D=${detectedFormat.unit}, \u96F6\u683C\u5F0F=${detectedFormat.zero === "L" ? "LZ" : "TZ"}`);
+              } else if (hasMetricLz) {
+                detectedFormat = detectedFormat || {};
+                detectedFormat.places = [3, 3];
+                detectedFormat.integerPlaces = 3;
+                detectedFormat.decimalPlaces = 3;
+                detectedFormat.totalPlaces = 6;
+                detectedFormat.unit = "metric";
+                detectedFormat.zero = "L";
+                debugLog(`[FMAT\u683C\u5F0F] \u68C0\u6D4B\u5230 METRIC,LZ\uFF0C\u4F7F\u7528\u9ED8\u8BA4 3:3 \u683C\u5F0F (6\u4F4D)`);
+              } else if (_GerberParser.gerberFormatInfo) {
+                detectedFormat = detectedFormat || {};
+                detectedFormat.places = _GerberParser.gerberFormatInfo.places;
+                detectedFormat.integerPlaces = _GerberParser.gerberFormatInfo.integerPlaces;
+                detectedFormat.decimalPlaces = _GerberParser.gerberFormatInfo.decimalPlaces;
+                detectedFormat.totalPlaces = _GerberParser.gerberFormatInfo.totalPlaces;
+                detectedFormat.zero = detectedFormat.zero || _GerberParser.gerberFormatInfo.zero || "L";
+                detectedFormat.unit = detectedFormat.unit || _GerberParser.gerberFormatInfo.unit || "inch";
+                console.log(`[\u683C\u5F0F\u7EE7\u627F] ${file.name}: \u65E0FILE_FORMAT\uFF0C\u7EE7\u627F Gerber \u683C\u5F0F ${detectedFormat.integerPlaces}:${detectedFormat.decimalPlaces}, \u5355\u4F4D=${detectedFormat.unit}, \u96F6\u683C\u5F0F=${detectedFormat.zero === "L" ? "LZ" : "TZ"}`);
+              } else {
+                console.warn(`[\u683C\u5F0F\u8B66\u544A] ${file.name}: \u6CA1\u6709FILE_FORMAT\uFF0C\u4E14\u6CA1\u6709\u53EF\u7528\u7684Gerber\u683C\u5F0F\u4FE1\u606F`);
+              }
+            }
+          }
+        }
+        const printableChars = gerberStr.split("").filter((char) => {
+          const code = char.charCodeAt(0);
+          return code >= 32 && code <= 126 || code === 10 || code === 13 || code === 9;
+        }).length;
+        const printableRatio = printableChars / gerberStr.length;
+        if (printableRatio < 0.5) {
+          const arrayBuffer = await file.arrayBuffer();
+          try {
+            const decoder = new TextDecoder("utf-8", { fatal: false, ignoreBOM: true });
+            gerberStr = decoder.decode(arrayBuffer);
+          } catch (e) {
+            const decoder = new TextDecoder("latin1", { fatal: false });
+            gerberStr = decoder.decode(arrayBuffer);
+          }
+        }
+      } catch (e) {
+        gerberStr = await this.readFileAsText(file);
+      }
+    } else {
+      gerberStr = await this.readFileAsText(file);
+    }
+    if (!gerberStr || gerberStr.trim().length === 0) {
+      throw new Error(`\u6587\u4EF6 ${file.name} \u5185\u5BB9\u4E3A\u7A7A`);
+    }
+    if (!isDrillFile) {
+      const fslaMatch = gerberStr.match(/%FSLAX(\d+)(\d+)Y(\d+)(\d+)\*%/i);
+      if (fslaMatch) {
+        const xIntegerPlaces = parseInt(fslaMatch[1]);
+        const xDecimalPlaces = parseInt(fslaMatch[2]);
+        const yIntegerPlaces = parseInt(fslaMatch[3]);
+        const yDecimalPlaces = parseInt(fslaMatch[4]);
+        const formatInfo = {
+          integerPlaces: xIntegerPlaces,
+          decimalPlaces: xDecimalPlaces,
+          totalPlaces: xIntegerPlaces + xDecimalPlaces,
+          places: [xIntegerPlaces, xDecimalPlaces],
+          unit: gerberStr.includes("%MOIN*%") ? "inch" : "metric",
+          zero: gerberStr.includes("%FSLAX") ? "L" : "T"
+          // FSLA表示前导零省略（LZ），FSLT表示尾部零省略（TZ）
+        };
+        _GerberParser.gerberFormatInfo = formatInfo;
+        _GerberParser.currentFileFormatInfo = formatInfo;
+        debugLog(`[\u683C\u5F0F\u63D0\u53D6] \u4ECEGerber\u6587\u4EF6 ${file.name} \u63D0\u53D6\u683C\u5F0F\u4FE1\u606F: ${xIntegerPlaces}\u4F4D\u6574\u6570, ${xDecimalPlaces}\u4F4D\u5C0F\u6570`);
+      }
+    }
+    const originalGerberStr = gerberStr;
+    let hasPadded = false;
+    let paddedGerberStr = null;
+    if (isDrillFile && detectedFormat && detectedFormat.totalPlaces && detectedFormat.zero === "L") {
+      const totalPlaces = detectedFormat.totalPlaces;
+      debugLog(`[DRL\u8C03\u8BD5] \u68C0\u6D4B\u5230LZ\u683C\u5F0F\uFF0CFILE_FORMAT=${detectedFormat.integerPlaces}:${detectedFormat.decimalPlaces}`);
+      debugLog(`[DRL\u8C03\u8BD5] \u68C0\u6D4B\u5230\u7684\u683C\u5F0F:`, {
+        integerPlaces: detectedFormat.integerPlaces,
+        decimalPlaces: detectedFormat.decimalPlaces,
+        totalPlaces: detectedFormat.totalPlaces,
+        zero: detectedFormat.zero,
+        unit: detectedFormat.unit
+      });
+      const coordMatchesBefore = gerberStr.match(/([XY])(\d+)/g) || [];
+      debugLog(`[DRL\u8C03\u8BD5] \u5904\u7406\u524D\u627E\u5230 ${coordMatchesBefore.length} \u4E2A\u5750\u6807\u503C`);
+      if (coordMatchesBefore.length > 0 && coordMatchesBefore.length <= 10) {
+        debugLog(`[DRL\u8C03\u8BD5] \u524D\u51E0\u4E2A\u5750\u6807\u503C:`, coordMatchesBefore.slice(0, 5));
+      }
+      let replaceCount = 0;
+      paddedGerberStr = gerberStr.replace(/([XY])(\d+)/g, (match, coord, num) => {
+        if (num.length < totalPlaces) {
+          const paddedNum = num.padStart(totalPlaces, "0");
+          if (replaceCount < 5) {
+            debugLog(`[DRL\u8C03\u8BD5] \u5750\u6807\u503C ${coord}${num} -> ${coord}${paddedNum} (\u524D\u88650\u5230${totalPlaces}\u4F4D)`);
+          }
+          replaceCount++;
+          return `${coord}${paddedNum}`;
+        }
+        return match;
+      });
+      debugLog(`[DRL\u8C03\u8BD5] \u5750\u6807\u503C\u9884\u5904\u7406\u5B8C\u6210\uFF0C\u5171\u5904\u7406 ${replaceCount} \u4E2A\u5750\u6807\u503C`);
+      if (replaceCount > 0) {
+        hasPadded = true;
+        const coordMatchesAfter = paddedGerberStr.match(/([XY])(\d+)/g) || [];
+        debugLog(`[DRL\u8C03\u8BD5] \u88650\u540E\u627E\u5230 ${coordMatchesAfter.length} \u4E2A\u5750\u6807\u503C`);
+        if (coordMatchesAfter.length > 0 && coordMatchesAfter.length <= 10) {
+          debugLog(`[DRL\u8C03\u8BD5] \u524D\u51E0\u4E2A\u88650\u540E\u7684\u5750\u6807\u503C:`, coordMatchesAfter.slice(0, 5));
+        }
+      }
+    } else if (isDrillFile && detectedFormat) {
+      debugLog(`[DRL\u8C03\u8BD5] \u68C0\u6D4B\u5230\u7684\u683C\u5F0F\u4FE1\u606F:`, {
+        integerPlaces: detectedFormat.integerPlaces,
+        decimalPlaces: detectedFormat.decimalPlaces,
+        totalPlaces: detectedFormat.totalPlaces,
+        zero: detectedFormat.zero,
+        unit: detectedFormat.unit
+      });
+      if (detectedFormat.zero !== "L") {
+        debugLog(`[DRL\u8C03\u8BD5] \u975E LZ \u683C\u5F0F\uFF0C\u4E0D\u8FDB\u884C\u5750\u6807\u9884\u5904\u7406`);
+      }
+    }
+    let parseResult;
+    let lastError = null;
+    if (isDrillFile) {
+      const fileTypeLabel = isTxFile ? `${fileExtension.toUpperCase()} (Excellon)` : "DRL";
+      debugLog(`\u5C1D\u8BD5\u89E3\u6790 ${fileTypeLabel} \u6587\u4EF6 ${file.name}...`);
+      debugLog(`\u6587\u4EF6\u5185\u5BB9\u9884\u89C8\uFF08\u524D200\u5B57\u7B26\uFF09:`, gerberStr.substring(0, 200));
+      if (detectedFormat && detectedFormat.integerPlaces && detectedFormat.decimalPlaces) {
+        const coordMatches = gerberStr.match(/[XY](-?\d+)/g);
+        if (coordMatches) {
+          let maxDigits = 0;
+          for (const coord of coordMatches) {
+            const digits = coord.substring(1).replace(/-/g, "").length;
+            maxDigits = Math.max(maxDigits, digits);
+          }
+          const definedDigits = detectedFormat.integerPlaces + detectedFormat.decimalPlaces;
+          debugLog(`[DRL\u683C\u5F0F\u68C0\u6D4B] ${file.name} \u5B9A\u4E49\u683C\u5F0F: [${detectedFormat.integerPlaces}, ${detectedFormat.decimalPlaces}] (${definedDigits}\u4F4D)`);
+          debugLog(`[DRL\u683C\u5F0F\u68C0\u6D4B] ${file.name} \u5B9E\u9645\u6700\u957F\u5750\u6807: ${maxDigits}\u4F4D`);
+          if (maxDigits > definedDigits) {
+            const extraDigits = maxDigits - definedDigits;
+            detectedFormat.integerPlaces += extraDigits;
+            detectedFormat.totalPlaces = detectedFormat.integerPlaces + detectedFormat.decimalPlaces;
+            detectedFormat.places = [detectedFormat.integerPlaces, detectedFormat.decimalPlaces];
+            debugLog(`[DRL\u683C\u5F0F\u4FEE\u6B63] \u2713 \u52A8\u6001\u8C03\u6574\u683C\u5F0F\u4E3A: [${detectedFormat.integerPlaces}, ${detectedFormat.decimalPlaces}] (${maxDigits}\u4F4D)`);
+            const oldFormatPattern = /FILE_FORMAT[=:]\d+[:.]\d+/i;
+            const newFormatStr = `FILE_FORMAT=${detectedFormat.integerPlaces}:${detectedFormat.decimalPlaces}`;
+            if (oldFormatPattern.test(gerberStr)) {
+              gerberStr = gerberStr.replace(oldFormatPattern, newFormatStr);
+              debugLog(`[DRL\u683C\u5F0F\u4FEE\u6B63] \u2713 \u5DF2\u4FEE\u6539\u6587\u4EF6\u683C\u5F0F\u5B9A\u4E49 \u2192 ${newFormatStr}`);
+              if (paddedGerberStr) {
+                paddedGerberStr = paddedGerberStr.replace(oldFormatPattern, newFormatStr);
+              }
+            }
+          }
+        }
+      }
+      if (isTxFile && detectedFormat && detectedFormat.places) {
+        const parseAttempts = [];
+        parseAttempts.push({
+          gerberStr: originalGerberStr,
+          // 使用原始内容
+          format: {
+            places: detectedFormat.places,
+            zero: detectedFormat.zero || "T"
+            // 使用原始检测到的格式（LZ）
+          },
+          description: "\u4E0D\u88650\uFF0C\u76F4\u63A5\u4F7F\u7528LZ\u683C\u5F0F"
+        });
+        if (hasPadded && paddedGerberStr) {
+          parseAttempts.push({
+            gerberStr: paddedGerberStr,
+            // 使用补0后的内容
+            format: {
+              places: detectedFormat.places,
+              zero: "T"
+              // 补0后使用TZ格式
+            },
+            description: "\u88650\u540E\u4F7F\u7528TZ\u683C\u5F0F"
+          });
+        }
+        if (hasPadded && paddedGerberStr) {
+          parseAttempts.push({
+            gerberStr: paddedGerberStr,
+            // 使用补0后的内容
+            format: {
+              places: detectedFormat.places
+              // 不指定zero参数
+            },
+            description: "\u88650\u540E\u4E0D\u6307\u5B9Azero\u53C2\u6570"
+          });
+        }
+        parseAttempts.push({
+          gerberStr: originalGerberStr,
+          // 使用原始内容
+          format: {
+            places: detectedFormat.places
+            // 不指定zero参数
+          },
+          description: "\u4E0D\u88650\uFF0C\u4E0D\u6307\u5B9Azero\u53C2\u6570"
+        });
+        for (const attempt of parseAttempts) {
+          try {
+            const formatOptions = {
+              type: "drill",
+              format: attempt.format
+            };
+            debugLog(`[DRL\u8C03\u8BD5] \u5C1D\u8BD5\u89E3\u6790\u65B9\u5F0F: ${attempt.description}`, formatOptions.format);
+            parseResult = parse(attempt.gerberStr, formatOptions);
+            debugLog(`[DRL\u8C03\u8BD5] ${fileTypeLabel} \u6587\u4EF6\u4F7F\u7528 ${attempt.description} \u89E3\u6790\u6210\u529F`);
+            debugLog(`[DRL\u8C03\u8BD5] parseResult \u7C7B\u578B:`, parseResult?.type);
+            debugLog(`[DRL\u8C03\u8BD5] parseResult \u5DE5\u5177\u6570\u91CF:`, parseResult?.tools ? Object.keys(parseResult.tools).length : 0);
+            if (parseResult?.tools && Object.keys(parseResult.tools).length > 0) {
+              let totalHoles = 0;
+              for (const tool of Object.values(parseResult.tools)) {
+                if (tool.holes) {
+                  totalHoles += tool.holes.length;
+                }
+              }
+              debugLog(`[DRL\u8C03\u8BD5] \u89E3\u6790\u51FA\u7684\u5B54\u603B\u6570: ${totalHoles}`);
+            }
+            break;
+          } catch (e0) {
+            lastError = e0;
+            debugLog(`[DRL\u8C03\u8BD5] ${fileTypeLabel} \u6587\u4EF6\u4F7F\u7528 ${attempt.description} \u89E3\u6790\u5931\u8D25: ${e0.message}`);
+          }
+        }
+      }
+      if (!parseResult) {
+        try {
+          parseResult = parse(gerberStr);
+          debugLog(`[DRL\u8C03\u8BD5] ${fileTypeLabel} \u6587\u4EF6\u76F4\u63A5\u89E3\u6790\u6210\u529F`);
+          debugLog(`[DRL\u8C03\u8BD5] parseResult \u7C7B\u578B:`, parseResult?.type);
+          debugLog(`[DRL\u8C03\u8BD5] parseResult \u5DE5\u5177\u6570\u91CF:`, parseResult?.tools ? Object.keys(parseResult.tools).length : 0);
+        } catch (e1) {
+          lastError = e1;
+          debugLog(`[DRL\u8C03\u8BD5] ${fileTypeLabel} \u6587\u4EF6\u76F4\u63A5\u89E3\u6790\u5931\u8D25: ${e1.message}`);
+          try {
+            parseResult = parse(gerberStr, { type: "drill" });
+            debugLog(`${fileTypeLabel} \u6587\u4EF6\u4F7F\u7528 drill \u7C7B\u578B\u89E3\u6790\u6210\u529F`);
+          } catch (e2) {
+            lastError = e2;
+            debugLog(`${fileTypeLabel} \u6587\u4EF6\u4F7F\u7528 drill \u7C7B\u578B\u89E3\u6790\u5931\u8D25: ${e2.message}`);
+            try {
+              parseResult = parse(gerberStr, {
+                type: "drill",
+                format: {
+                  places: [4, 5],
+                  // 常见的小数位数
+                  zero: "L"
+                  // Leading zeros
+                }
+              });
+              debugLog(`${fileTypeLabel} \u6587\u4EF6\u4F7F\u7528\u683C\u5F0F\u53C2\u6570\u89E3\u6790\u6210\u529F`);
+            } catch (e2_5) {
+              lastError = e2_5;
+              debugLog(`${fileTypeLabel} \u6587\u4EF6\u4F7F\u7528\u683C\u5F0F\u53C2\u6570\u89E3\u6790\u5931\u8D25: ${e2_5.message}`);
+              if (isTxFile && detectedFormat) {
+                const formatAttempts = [];
+                if (detectedFormat.places) {
+                  formatAttempts.push({
+                    places: detectedFormat.places,
+                    zero: detectedFormat.zero || "T",
+                    description: `[\u6574\u6570\u4F4D\u6570${detectedFormat.integerPlaces}, \u5C0F\u6570\u4F4D\u6570${detectedFormat.decimalPlaces}]`
+                  });
+                  debugLog(`[DRL\u8C03\u8BD5] \u5C06\u5C1D\u8BD5\u4F7F\u7528\u683C\u5F0F: places=[${detectedFormat.places[0]}, ${detectedFormat.places[1]}], zero=${detectedFormat.zero || "T"}`);
+                }
+                if (formatAttempts.length === 0) {
+                  formatAttempts.push({
+                    places: [4, 5],
+                    zero: detectedFormat.zero || "T",
+                    description: "\u9ED8\u8BA4\u683C\u5F0F[4, 5]"
+                  });
+                  debugLog(`[DRL\u8C03\u8BD5] \u672A\u68C0\u6D4B\u5230\u683C\u5F0F\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u683C\u5F0F`);
+                }
+                let parsed = false;
+                for (const formatOption of formatAttempts) {
+                  try {
+                    const formatOptions = {
+                      type: "drill",
+                      format: {
+                        places: formatOption.places,
+                        zero: formatOption.zero
+                      }
+                    };
+                    parseResult = parse(gerberStr, formatOptions);
+                    debugLog(`${fileTypeLabel} \u6587\u4EF6\u4F7F\u7528\u683C\u5F0F ${formatOption.description} \u89E3\u6790\u6210\u529F:`, formatOptions.format);
+                    parsed = true;
+                    break;
+                  } catch (e) {
+                    lastError = e;
+                    debugLog(`${fileTypeLabel} \u6587\u4EF6\u4F7F\u7528\u683C\u5F0F ${formatOption.description} \u89E3\u6790\u5931\u8D25: ${e.message}`);
+                  }
+                }
+                if (!parsed) {
+                  try {
+                    parseResult = parse(gerberStr, {
+                      type: "drill",
+                      format: {
+                        places: [4, 5],
+                        zero: "T"
+                        // Trailing zeros
+                      }
+                    });
+                    debugLog(`${fileTypeLabel} \u6587\u4EF6\u4F7F\u7528\u9ED8\u8BA4 TZ \u683C\u5F0F\u89E3\u6790\u6210\u529F`);
+                    parsed = true;
+                  } catch (e2_6_default) {
+                    lastError = e2_6_default;
+                    debugLog(`${fileTypeLabel} \u6587\u4EF6\u4F7F\u7528\u9ED8\u8BA4 TZ \u683C\u5F0F\u89E3\u6790\u5931\u8D25: ${e2_6_default.message}`);
+                  }
+                }
+                if (!parsed) {
+                  try {
+                    const cleanedStr = gerberStr.split("").filter((char) => {
+                      const code = char.charCodeAt(0);
+                      return code >= 32 && code <= 126 || code === 10 || code === 13 || code === 9;
+                    }).join("");
+                    if (cleanedStr.length > 0) {
+                      parseResult = parse(cleanedStr, { type: "drill" });
+                      debugLog(`${fileTypeLabel} \u6587\u4EF6\u6E05\u7406\u540E\u89E3\u6790\u6210\u529F`);
+                    } else {
+                      throw new Error("\u6E05\u7406\u540E\u6587\u4EF6\u5185\u5BB9\u4E3A\u7A7A");
+                    }
+                  } catch (e3) {
+                    lastError = e3;
+                    debugLog(`${fileTypeLabel} \u6587\u4EF6\u6E05\u7406\u540E\u89E3\u6790\u5931\u8D25: ${e3.message}`);
+                    try {
+                      const aggressiveCleaned = gerberStr.split("").map((char) => {
+                        const code = char.charCodeAt(0);
+                        if (code >= 32 && code <= 126 || code === 10 || code === 13 || code === 9) {
+                          return char;
+                        }
+                        return " ";
+                      }).join("").replace(/\s+/g, " ").trim();
+                      if (aggressiveCleaned.length > 10) {
+                        parseResult = parse(aggressiveCleaned, { type: "drill" });
+                        debugLog(`${fileTypeLabel} \u6587\u4EF6\u6FC0\u8FDB\u6E05\u7406\u540E\u89E3\u6790\u6210\u529F`);
+                      } else {
+                        throw new Error("\u6FC0\u8FDB\u6E05\u7406\u540E\u5185\u5BB9\u4E0D\u8DB3");
+                      }
+                    } catch (e4) {
+                      lastError = e4;
+                      debugLog(`${fileTypeLabel} \u6587\u4EF6\u6FC0\u8FDB\u6E05\u7406\u540E\u89E3\u6790\u5931\u8D25: ${e4.message}`);
+                      const possibleTypes = ["outline", "top", "bottom", "unknown"];
+                      let parsed2 = false;
+                      for (const type of possibleTypes) {
+                        try {
+                          parseResult = parse(gerberStr, { type });
+                          debugLog(`${fileTypeLabel} \u6587\u4EF6\u4F7F\u7528 ${type} \u7C7B\u578B\u89E3\u6790\u6210\u529F`);
+                          parsed2 = true;
+                          break;
+                        } catch (e) {
+                          lastError = e;
+                        }
+                      }
+                      if (!parsed2) {
+                        console.warn(`${fileTypeLabel} \u6587\u4EF6 ${file.name} \u65E0\u6CD5\u88AB web-gerber \u89E3\u6790`);
+                        throw new Error(`\u65E0\u6CD5\u89E3\u6790 ${fileTypeLabel} \u6587\u4EF6 ${file.name}\u3002\u6587\u4EF6\u53EF\u80FD\u662F\u4E8C\u8FDB\u5236\u683C\u5F0F\uFF08Excellon\uFF09\uFF0Cweb-gerber \u4EC5\u652F\u6301\u6587\u672C\u683C\u5F0F\u7684 Gerber \u6587\u4EF6\u3002\u5DF2\u5C1D\u8BD5\u591A\u79CD\u65B9\u5F0F\uFF0C\u6700\u540E\u9519\u8BEF: ${lastError?.message || "\u672A\u77E5\u9519\u8BEF"}`);
+                      }
+                    }
+                  }
+                }
+              } else {
+                try {
+                  const cleanedStr = gerberStr.split("").filter((char) => {
+                    const code = char.charCodeAt(0);
+                    return code >= 32 && code <= 126 || code === 10 || code === 13 || code === 9;
+                  }).join("");
+                  if (cleanedStr.length > 0) {
+                    parseResult = parse(cleanedStr);
+                    debugLog(`${fileTypeLabel} \u6587\u4EF6\u6E05\u7406\u540E\u89E3\u6790\u6210\u529F`);
+                  } else {
+                    throw new Error("\u6E05\u7406\u540E\u6587\u4EF6\u5185\u5BB9\u4E3A\u7A7A");
+                  }
+                } catch (e3) {
+                  lastError = e3;
+                  debugLog(`${fileTypeLabel} \u6587\u4EF6\u6E05\u7406\u540E\u89E3\u6790\u5931\u8D25: ${e3.message}`);
+                  try {
+                    const aggressiveCleaned = gerberStr.split("").map((char) => {
+                      const code = char.charCodeAt(0);
+                      if (code >= 32 && code <= 126 || code === 10 || code === 13 || code === 9) {
+                        return char;
+                      }
+                      return " ";
+                    }).join("").replace(/\s+/g, " ").trim();
+                    if (aggressiveCleaned.length > 10) {
+                      parseResult = parse(aggressiveCleaned);
+                      debugLog(`${fileTypeLabel} \u6587\u4EF6\u6FC0\u8FDB\u6E05\u7406\u540E\u89E3\u6790\u6210\u529F`);
+                    } else {
+                      throw new Error("\u6FC0\u8FDB\u6E05\u7406\u540E\u5185\u5BB9\u4E0D\u8DB3");
+                    }
+                  } catch (e4) {
+                    lastError = e4;
+                    debugLog(`${fileTypeLabel} \u6587\u4EF6\u6FC0\u8FDB\u6E05\u7406\u540E\u89E3\u6790\u5931\u8D25: ${e4.message}`);
+                    const possibleTypes = ["outline", "top", "bottom", "unknown"];
+                    let parsed = false;
+                    for (const type of possibleTypes) {
+                      try {
+                        parseResult = parse(gerberStr, { type });
+                        debugLog(`${fileTypeLabel} \u6587\u4EF6\u4F7F\u7528 ${type} \u7C7B\u578B\u89E3\u6790\u6210\u529F`);
+                        parsed = true;
+                        break;
+                      } catch (e) {
+                        lastError = e;
+                      }
+                    }
+                    if (!parsed) {
+                      console.warn(`${fileTypeLabel} \u6587\u4EF6 ${file.name} \u65E0\u6CD5\u88AB web-gerber \u89E3\u6790\uFF0C\u53EF\u80FD\u662F\u4E8C\u8FDB\u5236\u683C\u5F0F`);
+                      throw new Error(`\u65E0\u6CD5\u89E3\u6790 ${fileTypeLabel} \u6587\u4EF6 ${file.name}\u3002\u6587\u4EF6\u53EF\u80FD\u662F\u4E8C\u8FDB\u5236\u683C\u5F0F\uFF08Excellon\uFF09\uFF0Cweb-gerber \u4EC5\u652F\u6301\u6587\u672C\u683C\u5F0F\u7684 Gerber \u6587\u4EF6\u3002\u5DF2\u5C1D\u8BD5\u591A\u79CD\u65B9\u5F0F\uFF0C\u6700\u540E\u9519\u8BEF: ${lastError?.message || "\u672A\u77E5\u9519\u8BEF"}`);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    } else {
+      try {
+        debugLog(`[\u89E3\u6790\u8C03\u8BD5] \u6587\u4EF6 ${file.name}, currentFileFormatInfo\u5B58\u5728: ${!!_GerberParser.currentFileFormatInfo}`);
+        if (_GerberParser.currentFileFormatInfo) {
+          let integerPlaces = _GerberParser.currentFileFormatInfo.integerPlaces;
+          let decimalPlaces = _GerberParser.currentFileFormatInfo.decimalPlaces;
+          const coordMatches = gerberStr.match(/[XY](-?\d+)/g);
+          if (coordMatches) {
+            let maxDigits = 0;
+            for (const coord of coordMatches) {
+              const digits = coord.substring(1).replace(/-/g, "").length;
+              maxDigits = Math.max(maxDigits, digits);
+            }
+            const definedDigits = integerPlaces + decimalPlaces;
+            debugLog(`[\u683C\u5F0F\u68C0\u6D4B] ${file.name} \u5B9A\u4E49\u683C\u5F0F: [${integerPlaces}, ${decimalPlaces}] (${definedDigits}\u4F4D)`);
+            debugLog(`[\u683C\u5F0F\u68C0\u6D4B] ${file.name} \u5B9E\u9645\u6700\u957F\u5750\u6807: ${maxDigits}\u4F4D`);
+            if (maxDigits > definedDigits) {
+              const extraDigits = maxDigits - definedDigits;
+              integerPlaces += extraDigits;
+              debugLog(`[\u683C\u5F0F\u4FEE\u6B63] \u2713 \u52A8\u6001\u8C03\u6574\u683C\u5F0F\u4E3A: [${integerPlaces}, ${decimalPlaces}] (${maxDigits}\u4F4D)`);
+              debugLog(`[\u683C\u5F0F\u4FEE\u6B63] \u8FD9\u68378\u4F4D\u5750\u6807 X10405403 \u4F1A\u88AB\u89E3\u6790\u4E3A ${(10405403 / Math.pow(10, decimalPlaces)).toFixed(decimalPlaces)}"`);
+              const oldFormat = `%FSLAX${_GerberParser.currentFileFormatInfo.integerPlaces}${decimalPlaces}Y${_GerberParser.currentFileFormatInfo.integerPlaces}${decimalPlaces}*%`;
+              const newFormat = `%FSLAX${integerPlaces}${decimalPlaces}Y${integerPlaces}${decimalPlaces}*%`;
+              if (gerberStr.includes(oldFormat)) {
+                gerberStr = gerberStr.replace(oldFormat, newFormat);
+                debugLog(`[\u683C\u5F0F\u4FEE\u6B63] \u2713 \u5DF2\u4FEE\u6539\u6587\u4EF6\u683C\u5F0F\u5B9A\u4E49: ${oldFormat} \u2192 ${newFormat}`);
+              } else {
+                debugLog(`[\u683C\u5F0F\u4FEE\u6B63] \u26A0\uFE0F \u672A\u627E\u5230\u683C\u5F0F\u5B9A\u4E49\u5B57\u7B26\u4E32\uFF0C\u5C1D\u8BD5\u901A\u7528\u66FF\u6362`);
+                gerberStr = gerberStr.replace(/%FSLAX\d+\d+Y\d+\d+\*%/i, newFormat);
+              }
+            }
+          }
+          const formatOptions = {
+            format: {
+              places: [integerPlaces, decimalPlaces],
+              zero: _GerberParser.currentFileFormatInfo.zero
+            }
+          };
+          debugLog(`[Gerber\u89E3\u6790] ${file.name} \u6700\u7EC8\u4F7F\u7528\u683C\u5F0F: places=[${integerPlaces}, ${decimalPlaces}], zero=${_GerberParser.currentFileFormatInfo.zero}`);
+          parseResult = parse(gerberStr, formatOptions);
+        } else {
+          parseResult = parse(gerberStr);
+        }
+      } catch (parseError) {
+        const fileTypeMap = {
+          ".gtl": "top",
+          ".gbl": "bottom",
+          ".gts": "topsolder",
+          ".gbs": "bottomsolder",
+          ".gto": "topsilkscreen",
+          ".gbo": "bottomsilkscreen",
+          ".gtp": "toppaste",
+          ".gbp": "bottompaste",
+          ".gm1": "outline",
+          ".gko": "outline",
+          ".gdl": "outline",
+          ".gdd": "outline",
+          ".gm": "outline",
+          ".gd1": "outline",
+          ".gg1": "outline",
+          ".gpb": "bottompaste",
+          ".gpt": "toppaste"
+        };
+        let fileType = fileTypeMap[fileExtension];
+        if (!fileType && /^\.gm\d+$/i.test(fileExtension)) {
+          fileType = "outline";
+        }
+        if (!fileType && /^\.int\d+$/i.test(fileExtension)) {
+          fileType = "top";
+        }
+        if (!fileType && fileExtension === "" && /.*_INT\d+$/i.test(fileNameUpper)) {
+          fileType = "top";
+        }
+        fileType = fileType || "unknown";
+        try {
+          parseResult = parse(gerberStr, { type: fileType });
+        } catch (typeError) {
+          if (fileType === "unknown" || /^\.int\d+$/i.test(fileExtension) || fileExtension === "" && /.*_INT\d+$/i.test(fileNameUpper)) {
+            try {
+              parseResult = parse(gerberStr);
+            } catch (finalError) {
+              throw new Error(`\u65E0\u6CD5\u89E3\u6790\u6587\u4EF6 ${file.name}\u3002\u9519\u8BEF: ${parseError.message || typeError.message || finalError.message}`);
+            }
+          } else {
+            throw new Error(`\u65E0\u6CD5\u89E3\u6790\u6587\u4EF6 ${file.name}\u3002\u9519\u8BEF: ${parseError.message || typeError.message}`);
+          }
+        }
+      }
+    }
+    const plotResult = plot(parseResult);
+    debugLog(`[DRL\u8C03\u8BD5] \u6587\u4EF6 ${file.name} \u89E3\u6790\u6210\u529F\uFF0CplotResult:`, plotResult);
+    if (!isDrillFile && plotResult.tools && Object.keys(plotResult.tools).length > 0 && file.name.toUpperCase().includes("GTL")) {
+      debugLog(`[\u5149\u5708\u8C03\u8BD5] \u6587\u4EF6 ${file.name} \u5305\u542B ${Object.keys(plotResult.tools).length} \u4E2A\u5DE5\u5177\u5B9A\u4E49:`);
+      const toolEntries = Object.entries(plotResult.tools).slice(0, 5);
+      toolEntries.forEach(([id, tool]) => {
+        debugLog(`  \u5DE5\u5177 ${id}:`, JSON.stringify(tool, null, 2));
+      });
+      if (plotResult.children && plotResult.children.length > 0) {
+        const typeCount = {};
+        const polarityCount = { dark: 0, clear: 0 };
+        plotResult.children.forEach((child) => {
+          typeCount[child.type] = (typeCount[child.type] || 0) + 1;
+          if (child.polarity) {
+            polarityCount[child.polarity] = (polarityCount[child.polarity] || 0) + 1;
+          }
+        });
+        debugLog(`[Children\u7EDF\u8BA1] GTL\u6587\u4EF6 ${plotResult.children.length} \u4E2A children:`);
+        debugLog(`  \u7C7B\u578B\u7EDF\u8BA1:`, typeCount);
+        debugLog(`  \u6781\u6027\u7EDF\u8BA1:`, polarityCount);
+        const types = Object.keys(typeCount);
+        types.forEach((type) => {
+          const example = plotResult.children.find((c) => c.type === type);
+          if (example) {
+            debugLog(`  ${type} \u793A\u4F8B:`, JSON.stringify({
+              type: example.type,
+              tool: example.tool,
+              dcode: example.dcode,
+              polarity: example.polarity,
+              segmentsCount: example.segments?.length,
+              keys: Object.keys(example)
+            }, null, 2));
+          }
+        });
+      }
+    }
+    if (isDrillFile && plotResult) {
+      debugLog(`[DRL\u8C03\u8BD5] plotResult \u8BE6\u7EC6\u4FE1\u606F:`);
+      debugLog(`  - type: ${plotResult.type}`);
+      debugLog(`  - units: ${plotResult.units}`);
+      debugLog(`  - size:`, plotResult.size);
+      debugLog(`  - tools:`, plotResult.tools ? Object.keys(plotResult.tools).length + " \u4E2A\u5DE5\u5177" : "\u65E0");
+      if (plotResult.tools) {
+        const toolKeys = Object.keys(plotResult.tools).slice(0, 5);
+        toolKeys.forEach((key) => {
+          debugLog(`    - T${key}: \u76F4\u5F84 ${plotResult.tools[key]?.diameter || "\u672A\u77E5"}`);
+        });
+      }
+      debugLog(`  - children\u6570\u91CF: ${plotResult.children?.length || 0}`);
+    }
+    const svgTree = renderSVG(plotResult);
+    debugLog(`[DRL\u8C03\u8BD5] \u6587\u4EF6 ${file.name} SVG\u6811\u751F\u6210\u6210\u529F\uFF0Cchildren\u6570\u91CF:`, svgTree?.children?.length || 0);
+    if (isDrillFile && svgTree?.children) {
+      let circleCount = 0;
+      const countCircles = (element) => {
+        if (!element) return;
+        if (element.tagName?.toLowerCase() === "circle") {
+          circleCount++;
+        }
+        if (element.children) {
+          element.children.forEach((child) => countCircles(child));
+        }
+      };
+      svgTree.children.forEach((child) => countCircles(child));
+      debugLog(`[DRL\u8C03\u8BD5] SVG\u6811\u4E2D\u5706\u5F62\u5143\u7D20\uFF08\u5B54\uFF09\u6570\u91CF: ${circleCount}`);
+      if (circleCount > 0) {
+        const circles = [];
+        const extractCircles = (element) => {
+          if (!element) return;
+          if (element.tagName?.toLowerCase() === "circle") {
+            const cx = parseFloat(element.properties?.cx || element.attributes?.cx || 0);
+            const cy = parseFloat(element.properties?.cy || element.attributes?.cy || 0);
+            const r = parseFloat(element.properties?.r || element.attributes?.r || 0);
+            circles.push({ cx, cy, r });
+          }
+          if (element.children) {
+            element.children.forEach((child) => extractCircles(child));
+          }
+        };
+        svgTree.children.forEach((child) => extractCircles(child));
+        debugLog(`[DRL\u8C03\u8BD5] \u524D5\u4E2A\u5B54\u7684\u5750\u6807:`);
+        circles.slice(0, 5).forEach((circle, idx) => {
+          debugLog(`  ${idx + 1}. \u4E2D\u5FC3: (${circle.cx.toFixed(6)}, ${circle.cy.toFixed(6)}), \u534A\u5F84: ${circle.r.toFixed(6)}`);
+        });
+        if (detectedFormat && detectedFormat.totalPlaces && circles.length > 0) {
+          try {
+            const xyMatch = gerberStr.match(/X(-?\d+)\s*Y(-?\d+)/i);
+            console.log(`[\u94BB\u5B54\u5750\u6807\u68C0\u67E5] ${file.name}: \u9996\u4E2AXY=${xyMatch ? xyMatch[0] : "\u672A\u627E\u5230"}, circles[0]=(${circles[0]?.cx?.toFixed(4)}, ${circles[0]?.cy?.toFixed(4)})`);
+            if (xyMatch && circles[0]) {
+              const actX = circles[0].cx;
+              const actY = circles[0].cy;
+              const parseFixedCoord = (rawDigits, fmt, zeroMode) => {
+                if (!fmt || rawDigits == null) return null;
+                const s = String(rawDigits).trim();
+                const sign = s.startsWith("-") ? -1 : 1;
+                let digits = s.replace(/[^0-9]/g, "");
+                if (!digits) return null;
+                const need = fmt.totalPlaces;
+                if (need && digits.length < need) {
+                  if ((zeroMode || "").toUpperCase() === "L" || zeroMode === "LZ") {
+                    digits = digits.padStart(need, "0");
+                  } else {
+                    digits = digits.padEnd(need, "0");
+                  }
+                }
+                const denom = Math.pow(10, fmt.decimalPlaces || 0);
+                const n = parseInt(digits, 10);
+                if (!Number.isFinite(n) || denom === 0) return null;
+                return sign * (n / denom);
+              };
+              const plotUnits = plotResult && plotResult.units === "in" ? "in" : "mm";
+              const srcUnits = detectedFormat.unit === "inch" ? "in" : detectedFormat.unit === "metric" ? "mm" : plotUnits;
+              const evalZeroMode = (zeroMode) => {
+                let expX = parseFixedCoord(xyMatch[1], detectedFormat, zeroMode);
+                let expY = parseFixedCoord(xyMatch[2], detectedFormat, zeroMode);
+                if (expX != null && expY != null) {
+                  if (srcUnits === "in" && plotUnits === "mm") {
+                    expX *= 25.4;
+                    expY *= 25.4;
+                  }
+                  if (srcUnits === "mm" && plotUnits === "in") {
+                    expX /= 25.4;
+                    expY /= 25.4;
+                  }
+                }
+                const ratios = [];
+                if (Number.isFinite(expX) && Math.abs(actX) > 1e-4) ratios.push(Math.abs(expX) / Math.abs(actX));
+                if (Number.isFinite(expY) && Math.abs(actY) > 1e-4) ratios.push(Math.abs(expY) / Math.abs(actY));
+                if (ratios.length === 0) return null;
+                const avg = ratios.reduce((s, v) => s + v, 0) / ratios.length;
+                const max = Math.max(...ratios);
+                const min = Math.min(...ratios);
+                const spread = avg !== 0 ? Math.abs(max - min) / Math.abs(avg) : 999;
+                return { zeroMode, expX, expY, avg, spread };
+              };
+              const primaryZero = detectedFormat.zero === "T" ? "TZ" : "LZ";
+              const altZero = primaryZero === "TZ" ? "LZ" : "TZ";
+              const primary = evalZeroMode(primaryZero);
+              const alt = evalZeroMode(altZero);
+              console.log(`[\u94BB\u5B54\u5750\u6807\u68C0\u67E5] ${file.name}: \u683C\u5F0F=${detectedFormat.integerPlaces}:${detectedFormat.decimalPlaces}, \u5B9E\u9645=(${actX.toFixed(4)}, ${actY.toFixed(4)}), plotUnits=${plotUnits}, srcUnits=${srcUnits}`);
+              if (primary) console.log(`[\u94BB\u5B54\u5750\u6807\u68C0\u67E5] ${file.name}: ${primaryZero}\u6A21\u5F0F \u671F\u671B=(${primary.expX?.toFixed(4)}, ${primary.expY?.toFixed(4)}), ratio=${primary.avg?.toFixed(4)}, spread=${primary.spread?.toFixed(4)}`);
+              if (alt) console.log(`[\u94BB\u5B54\u5750\u6807\u68C0\u67E5] ${file.name}: ${altZero}\u6A21\u5F0F \u671F\u671B=(${alt.expX?.toFixed(4)}, ${alt.expY?.toFixed(4)}), ratio=${alt.avg?.toFixed(4)}, spread=${alt.spread?.toFixed(4)}`);
+              const near1 = (r) => r && Number.isFinite(r.avg) && r.spread < 0.05 && Math.abs(r.avg - 1) <= 0.05;
+              if (!near1(primary) && !near1(alt)) {
+                const chosen = primary && alt ? primary.spread <= alt.spread ? primary : alt : primary || alt;
+                if (chosen && Number.isFinite(chosen.avg) && chosen.spread < 0.05 && Math.abs(chosen.avg - 1) > 0.05) {
+                  const absAvg = Math.abs(chosen.avg);
+                  const pow10 = Math.pow(10, Math.round(Math.log10(absAvg)));
+                  const snapped = Math.abs(absAvg - pow10) / pow10 < 0.15 ? pow10 : absAvg;
+                  if (snapped >= 0.01 && snapped <= 1e4 && Math.abs(snapped - 1) > 0.05) {
+                    console.warn(`[\u94BB\u5B54\u5750\u6807\u4FEE\u6B63] ${file.name}: \u68C0\u6D4B\u5230 ${snapped.toFixed(2)}x \u7F29\u653E\u504F\u5DEE\uFF0C\u4FEE\u6B63\u5706\u5FC3\u5750\u6807 (plotUnits=${plotUnits}, srcUnits=${srcUnits}, zero=${chosen.zeroMode})`);
+                    const applyFix = (node) => {
+                      if (!node) return;
+                      const tag = node.tagName?.toLowerCase();
+                      if (tag === "circle" || tag === "ellipse") {
+                        const p = node.properties || (node.properties = {});
+                        const cx = parseFloat(p.cx ?? node.attributes?.cx ?? 0);
+                        const cy = parseFloat(p.cy ?? node.attributes?.cy ?? 0);
+                        if (Number.isFinite(cx)) p.cx = String(cx * snapped);
+                        if (Number.isFinite(cy)) p.cy = String(cy * snapped);
+                      }
+                      if (node.children) node.children.forEach(applyFix);
+                    };
+                    svgTree.children.forEach((child) => applyFix(child));
+                  }
+                }
+              } else if (near1(alt) && !near1(primary)) {
+                console.warn(`[\u94BB\u5B54\u5750\u6807\u68C0\u67E5] ${file.name}: \u96F6\u6291\u5236\u58F0\u660E\u4E3A ${primaryZero}\uFF0C\u4F46\u5750\u6807\u66F4\u7B26\u5408 ${altZero}\uFF08\u65E0\u9700\u4FEE\u6B63\uFF09`);
+              } else if (near1(primary)) {
+                console.log(`[\u94BB\u5B54\u5750\u6807\u68C0\u67E5] ${file.name}: \u2713 ${primaryZero}\u6A21\u5F0F\u5339\u914D\u826F\u597D (ratio\u22481)\uFF0C\u65E0\u9700\u4FEE\u6B63`);
+              } else {
+                console.log(`[\u94BB\u5B54\u5750\u6807\u68C0\u67E5] ${file.name}: \u672A\u89E6\u53D1\u4FEE\u6B63 (near1(primary)=${near1(primary)}, near1(alt)=${near1(alt)})`);
+              }
+            }
+          } catch (e) {
+            console.warn(`[\u94BB\u5B54\u5750\u6807\u4FEE\u6B63] ${file.name}: posScaleFix \u8BA1\u7B97\u5931\u8D25:`, e?.message || e);
+          }
+        } else {
+          console.log(`[\u94BB\u5B54\u5750\u6807\u68C0\u67E5] ${file.name}: \u8DF3\u8FC7\u68C0\u67E5 (detectedFormat=${!!detectedFormat}, totalPlaces=${detectedFormat?.totalPlaces}, circles=${circles.length})`);
+        }
+        if (detectedFormat && detectedFormat.totalPlaces && detectedFormat.zero === "L") {
+          debugLog(`[DRL\u8C03\u8BD5] \u5F00\u59CB\u9A8C\u8BC1\u5750\u6807\u89E3\u6790...`);
+          const originalContent = await this.readFileAsText(file);
+          const originalCoords = originalContent.match(/([XY])(\d+)/g) || [];
+          if (originalCoords.length > 0) {
+            debugLog(`[DRL\u8C03\u8BD5] \u4ECE\u539F\u59CB\u6587\u4EF6\u4E2D\u63D0\u53D6\u7684\u524D5\u4E2A\u5750\u6807\u503C:`);
+            const sampleCoords = originalCoords.slice(0, 10);
+            for (let i = 0; i < Math.min(5, Math.floor(sampleCoords.length / 2)); i++) {
+              const xCoord = sampleCoords[i * 2];
+              const yCoord = sampleCoords[i * 2 + 1];
+              if (xCoord && yCoord) {
+                const xMatch = xCoord.match(/X(\d+)/);
+                const yMatch = yCoord.match(/Y(\d+)/);
+                if (xMatch && yMatch) {
+                  const xRaw = xMatch[1];
+                  const yRaw = yMatch[1];
+                  const xPadded = xRaw.padStart(detectedFormat.totalPlaces, "0");
+                  const yPadded = yRaw.padStart(detectedFormat.totalPlaces, "0");
+                  const xInteger = parseInt(xPadded.substring(0, detectedFormat.integerPlaces));
+                  const xDecimal = parseInt(xPadded.substring(detectedFormat.integerPlaces)) / Math.pow(10, detectedFormat.decimalPlaces);
+                  const xExpected = xInteger + xDecimal;
+                  const yInteger = parseInt(yPadded.substring(0, detectedFormat.integerPlaces));
+                  const yDecimal = parseInt(yPadded.substring(detectedFormat.integerPlaces)) / Math.pow(10, detectedFormat.decimalPlaces);
+                  const yExpected = yInteger + yDecimal;
+                  const parsedCircle = circles[i];
+                  debugLog(`  ${i + 1}. \u539F\u59CB: ${xCoord}${yCoord}`);
+                  debugLog(`      \u88650\u540E: X${xPadded}Y${yPadded}`);
+                  debugLog(`      \u5E94\u8BE5\u89E3\u6790\u4E3A: (${xExpected.toFixed(6)}, ${yExpected.toFixed(6)})`);
+                  if (parsedCircle) {
+                    debugLog(`      \u5B9E\u9645\u89E3\u6790\u4E3A: (${parsedCircle.cx.toFixed(6)}, ${parsedCircle.cy.toFixed(6)})`);
+                    const xDiff = Math.abs(parsedCircle.cx - xExpected);
+                    const yDiff = Math.abs(parsedCircle.cy - yExpected);
+                    if (xDiff > 1e-3 || yDiff > 1e-3) {
+                      debugLog(`      \u26A0\uFE0F  \u5750\u6807\u4E0D\u5339\u914D\uFF01X\u5DEE\u5F02: ${(xDiff * 25.4).toFixed(3)} mm, Y\u5DEE\u5F02: ${(yDiff * 25.4).toFixed(3)} mm`);
+                    } else {
+                      debugLog(`      \u2713 \u5750\u6807\u5339\u914D`);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    let bounds = null;
+    if (parseResult && typeof parseResult === "object") {
+      if (parseResult.bounds) {
+        bounds = parseResult.bounds;
+      } else if (parseResult.format && parseResult.format.bounds) {
+        bounds = parseResult.format.bounds;
+      } else if (parseResult.minX !== void 0 && parseResult.minY !== void 0) {
+        bounds = {
+          minX: parseResult.minX,
+          minY: parseResult.minY,
+          maxX: parseResult.maxX,
+          maxY: parseResult.maxY
+        };
+      }
+    }
+    if (plotResult && typeof plotResult === "object") {
+      if (plotResult.bounds) {
+        bounds = plotResult.bounds;
+      } else if (plotResult.minX !== void 0 && plotResult.minY !== void 0) {
+        bounds = {
+          minX: plotResult.minX,
+          minY: plotResult.minY,
+          maxX: plotResult.maxX,
+          maxY: plotResult.maxY
+        };
+      }
+    }
+    const webglData = this.svgTreeToWebGL(svgTree, color, bounds, plotResult);
+    if (!bounds && webglData.bounds) {
+      bounds = webglData.bounds;
+    }
+    return {
+      data: webglData,
+      bounds: bounds || { minX: 0, minY: 0, maxX: 100, maxY: 100 },
+      isDrillFile,
+      // 标记是否是钻孔文件，供main.js使用
+      units: plotResult ? plotResult.units : "mm",
+      plotResult
+      // 🎯 保留原始 plotResult，包含 polarity 信息
+    };
+  }
+  /**
+   * 将 SVG 树转换为 WebGL 数据
+   * @param {Object} svgTree - SVG 树（hast 格式）
+   * @param {string} color - 颜色
+   * @param {Object} bounds - 坐标范围（可选）
+   * @returns {Object} - WebGL 数据
+   */
+  static svgTreeToWebGL(svgTree, color, bounds = null) {
+    const vertices = [];
+    const colors = [];
+    const indices = [];
+    const lineStrips = [];
+    let calculatedBounds = { minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity };
+    const rgb = this.hexToRgb(color);
+    function addVertex(x, y) {
+      vertices.push(x, y, 0);
+      colors.push(rgb.r, rgb.g, rgb.b);
+      calculatedBounds.minX = Math.min(calculatedBounds.minX, x);
+      calculatedBounds.minY = Math.min(calculatedBounds.minY, y);
+      calculatedBounds.maxX = Math.max(calculatedBounds.maxX, x);
+      calculatedBounds.maxY = Math.max(calculatedBounds.maxY, y);
+    }
+    const getVertexOffset = () => vertices.length / 3;
+    const getPaintInfo = (element) => {
+      const fillRaw = element?.properties?.fill ?? element?.attributes?.fill ?? element?.properties?.style?.fill ?? element?.attributes?.style?.fill;
+      const strokeRaw = element?.properties?.stroke ?? element?.attributes?.stroke ?? element?.properties?.style?.stroke ?? element?.attributes?.style?.stroke;
+      const fill = (fillRaw == null ? "" : String(fillRaw)).trim().toLowerCase();
+      const stroke = (strokeRaw == null ? "" : String(strokeRaw)).trim().toLowerCase();
+      const hasFill = fill === "" ? true : fill !== "none";
+      const hasStroke = stroke !== "" && stroke !== "none";
+      const kind = hasFill ? "fill" : hasStroke ? "stroke" : "unknown";
+      return { kind, hasFill, hasStroke };
+    };
+    const processElement = (element) => {
+      if (!element || !element.tagName) return;
+      const tagName = element.tagName.toLowerCase();
+      const paint = getPaintInfo(element);
+      switch (tagName) {
+        case "path":
+          _GerberParser.processPath(element, addVertex, lineStrips, getVertexOffset, paint);
+          break;
+        case "circle":
+          _GerberParser.processCircle(element, addVertex, lineStrips, getVertexOffset, paint);
+          break;
+        case "ellipse":
+          _GerberParser.processEllipse(element, addVertex, lineStrips, getVertexOffset, paint);
+          break;
+        case "rect":
+          _GerberParser.processRect(element, addVertex, lineStrips, getVertexOffset, paint);
+          break;
+        case "line":
+          _GerberParser.processLine(element, addVertex, indices, getVertexOffset);
+          break;
+        case "polyline":
+          _GerberParser.processPolyline(element, addVertex, lineStrips, getVertexOffset, paint);
+          break;
+        case "polygon":
+          _GerberParser.processPolygon(element, addVertex, lineStrips, getVertexOffset, paint);
+          break;
+        case "g":
+          if (element.children) {
+            element.children.forEach((child) => processElement(child));
+          }
+          break;
+      }
+    };
+    if (svgTree.children) {
+      debugLog(`\u5904\u7406 ${svgTree.children.length} \u4E2A\u5B50\u5143\u7D20`);
+      svgTree.children.forEach((child) => processElement(child));
+    } else {
+      console.warn(`SVG\u6811\u6CA1\u6709\u5B50\u5143\u7D20\uFF0C\u53EF\u80FD\u6587\u4EF6\u53EA\u5305\u542B\u5B9A\u4E49\uFF08\u5982%ADD\uFF09\u800C\u6CA1\u6709\u7ED8\u56FE\u547D\u4EE4`);
+    }
+    if (calculatedBounds.minX === Infinity && bounds) {
+      calculatedBounds = bounds;
+    }
+    const vertexCount = vertices.length / 3;
+    debugLog(`WebGL\u8F6C\u6362\u5B8C\u6210: ${vertexCount} \u4E2A\u9876\u70B9, ${lineStrips.length} \u6761\u7EBF, ${indices.length} \u4E2A\u7D22\u5F15`);
+    return {
+      vertices: new Float32Array(vertices),
+      colors: new Float32Array(colors),
+      indices: new Uint16Array(indices),
+      lineStrips,
+      vertexCount,
+      bounds: calculatedBounds
+    };
+  }
+  /**
+   * 处理 path 元素
+   * 支持 stroke-width 属性，将开放路径扩展为有宽度的闭合多边形
+   */
+  static processPath(element, addVertex, lineStrips, getVertexOffset, paint = null) {
+    const d = element.properties?.d || element.attributes?.d || "";
+    if (!d) return;
+    const points = this.parsePathData(d);
+    if (points.length < 2) {
+      return;
+    }
+    let strokeWidth = parseFloat(
+      element.properties?.["stroke-width"] || element.attributes?.["stroke-width"] || element.properties?.strokeWidth || element.attributes?.strokeWidth || 0
+    );
+    if (strokeWidth === 0) {
+      const style = element.properties?.style || element.attributes?.style || "";
+      if (typeof style === "string") {
+        const match = style.match(/stroke-width\s*:\s*([0-9.]+)/i);
+        if (match) {
+          strokeWidth = parseFloat(match[1]);
+        }
+      } else if (typeof style === "object") {
+        strokeWidth = parseFloat(style["stroke-width"] || style.strokeWidth || 0);
+      }
+    }
+    if (!_GerberParser._debugPathCount) {
+      _GerberParser._debugPathCount = 0;
+    }
+    if (_GerberParser._debugPathCount < 3) {
+      _GerberParser._debugPathCount++;
+      debugLog(`[\u8C03\u8BD5] Path \u5143\u7D20 #${_GerberParser._debugPathCount}:`, {
+        properties: element.properties,
+        attributes: element.attributes,
+        strokeWidth,
+        pointsCount: points.length,
+        isClosed: Math.sqrt(Math.pow(points[0].x - points[points.length - 1].x, 2) + Math.pow(points[0].y - points[points.length - 1].y, 2)) < 1e-3
+      });
+    }
+    const first = points[0];
+    const last = points[points.length - 1];
+    const closeDist = Math.sqrt(Math.pow(first.x - last.x, 2) + Math.pow(first.y - last.y, 2));
+    const isClosed = closeDist < 1e-3;
+    if (strokeWidth > 0 && !isClosed) {
+      const expandedPoints = this.expandPathToPolygon(points, strokeWidth);
+      if (expandedPoints.length >= 3) {
+        const stripStart2 = getVertexOffset();
+        expandedPoints.forEach((point) => {
+          addVertex(point.x, point.y);
+        });
+        addVertex(expandedPoints[0].x, expandedPoints[0].y);
+        lineStrips.push({
+          start: stripStart2,
+          count: expandedPoints.length + 1,
+          kind: "fill"
+        });
+        return;
+      }
+    }
+    const stripStart = getVertexOffset();
+    points.forEach((point) => {
+      addVertex(point.x, point.y);
+    });
+    lineStrips.push({
+      start: stripStart,
+      count: points.length,
+      kind: paint?.kind || "unknown"
+    });
+  }
+  /**
+   * 将开放路径扩展为有宽度的闭合多边形
+   * @param {Array} points - 路径点数组 [{x, y}, ...]
+   * @param {number} strokeWidth - 线宽
+   * @returns {Array} - 扩展后的多边形点数组
+   */
+  static expandPathToPolygon(points, strokeWidth) {
+    if (points.length < 2) return [];
+    const halfWidth = strokeWidth / 2;
+    const leftSide = [];
+    const rightSide = [];
+    for (let i = 0; i < points.length; i++) {
+      const curr = points[i];
+      const prev = points[i - 1];
+      const next = points[i + 1];
+      let dx, dy, len, perpX, perpY;
+      if (i === 0) {
+        dx = next.x - curr.x;
+        dy = next.y - curr.y;
+        len = Math.sqrt(dx * dx + dy * dy);
+        if (len < 1e-9) {
+          perpX = 0;
+          perpY = halfWidth;
+        } else {
+          perpX = -dy / len * halfWidth;
+          perpY = dx / len * halfWidth;
+        }
+      } else if (i === points.length - 1) {
+        dx = curr.x - prev.x;
+        dy = curr.y - prev.y;
+        len = Math.sqrt(dx * dx + dy * dy);
+        if (len < 1e-9) {
+          perpX = 0;
+          perpY = halfWidth;
+        } else {
+          perpX = -dy / len * halfWidth;
+          perpY = dx / len * halfWidth;
+        }
+      } else {
+        const dx1 = curr.x - prev.x;
+        const dy1 = curr.y - prev.y;
+        const len1 = Math.sqrt(dx1 * dx1 + dy1 * dy1);
+        const dx2 = next.x - curr.x;
+        const dy2 = next.y - curr.y;
+        const len2 = Math.sqrt(dx2 * dx2 + dy2 * dy2);
+        if (len1 < 1e-9 && len2 < 1e-9) {
+          perpX = 0;
+          perpY = halfWidth;
+        } else if (len1 < 1e-9) {
+          perpX = -dy2 / len2 * halfWidth;
+          perpY = dx2 / len2 * halfWidth;
+        } else if (len2 < 1e-9) {
+          perpX = -dy1 / len1 * halfWidth;
+          perpY = dx1 / len1 * halfWidth;
+        } else {
+          const perpX1 = -dy1 / len1;
+          const perpY1 = dx1 / len1;
+          const perpX2 = -dy2 / len2;
+          const perpY2 = dx2 / len2;
+          let avgPerpX = (perpX1 + perpX2) / 2;
+          let avgPerpY = (perpY1 + perpY2) / 2;
+          const avgLen = Math.sqrt(avgPerpX * avgPerpX + avgPerpY * avgPerpY);
+          if (avgLen < 1e-9) {
+            perpX = perpX1 * halfWidth;
+            perpY = perpY1 * halfWidth;
+          } else {
+            const dot = perpX1 * perpX2 + perpY1 * perpY2;
+            const miterLen = halfWidth / Math.max(0.5, Math.sqrt((1 + dot) / 2));
+            perpX = avgPerpX / avgLen * miterLen;
+            perpY = avgPerpY / avgLen * miterLen;
+          }
+        }
+      }
+      leftSide.push({
+        x: curr.x + perpX,
+        y: curr.y + perpY
+      });
+      rightSide.push({
+        x: curr.x - perpX,
+        y: curr.y - perpY
+      });
+    }
+    const polygon = [...leftSide, ...rightSide.reverse()];
+    return polygon;
+  }
+  /**
+   * 处理 circle 元素
+   */
+  static processCircle(element, addVertex, lineStrips, getVertexOffset, paint = null) {
+    const cx = parseFloat(element.properties?.cx || element.attributes?.cx || 0);
+    const cy = parseFloat(element.properties?.cy || element.attributes?.cy || 0);
+    const r = parseFloat(element.properties?.r || element.attributes?.r || 0);
+    if (r <= 0) return;
+    const segments = Math.max(32, Math.ceil(r * 0.5));
+    const points = [];
+    for (let i = 0; i <= segments; i++) {
+      const angle = i / segments * Math.PI * 2;
+      points.push({
+        x: cx + Math.cos(angle) * r,
+        y: cy + Math.sin(angle) * r
+      });
+    }
+    const stripStart = getVertexOffset();
+    points.forEach((point) => {
+      addVertex(point.x, point.y);
+    });
+    lineStrips.push({
+      start: stripStart,
+      count: points.length,
+      kind: paint?.kind || "unknown"
+    });
+  }
+  /**
+   * 处理 ellipse 元素
+   */
+  static processEllipse(element, addVertex, lineStrips, getVertexOffset, paint = null) {
+    const cx = parseFloat(element.properties?.cx || element.attributes?.cx || 0);
+    const cy = parseFloat(element.properties?.cy || element.attributes?.cy || 0);
+    const rx = parseFloat(element.properties?.rx || element.attributes?.rx || 0);
+    const ry = parseFloat(element.properties?.ry || element.attributes?.ry || 0);
+    if (rx <= 0 || ry <= 0) return;
+    const segments = Math.max(32, Math.ceil(Math.max(rx, ry) * 0.5));
+    const points = [];
+    for (let i = 0; i <= segments; i++) {
+      const angle = i / segments * Math.PI * 2;
+      points.push({
+        x: cx + Math.cos(angle) * rx,
+        y: cy + Math.sin(angle) * ry
+      });
+    }
+    const stripStart = getVertexOffset();
+    points.forEach((point) => {
+      addVertex(point.x, point.y);
+    });
+    lineStrips.push({
+      start: stripStart,
+      count: points.length,
+      kind: paint?.kind || "unknown"
+    });
+  }
+  /**
+   * 处理 rect 元素（支持圆角矩形）
+   */
+  static processRect(element, addVertex, lineStrips, getVertexOffset, paint = null) {
+    const x = parseFloat(element.properties?.x || element.attributes?.x || 0);
+    const y = parseFloat(element.properties?.y || element.attributes?.y || 0);
+    const width = parseFloat(element.properties?.width || element.attributes?.width || 0);
+    const height = parseFloat(element.properties?.height || element.attributes?.height || 0);
+    const rx = parseFloat(element.properties?.rx || element.attributes?.rx || 0);
+    const ry = parseFloat(element.properties?.ry || element.attributes?.ry || rx || 0);
+    if (width <= 0 || height <= 0) return;
+    const stripStart = getVertexOffset();
+    if (rx > 0 && ry > 0) {
+      const maxRx = Math.min(rx, width / 2);
+      const maxRy = Math.min(ry, height / 2);
+      addVertex(x + maxRx, y);
+      const topRightArc = this.approximateArc(
+        x + width - maxRx,
+        y,
+        maxRx,
+        maxRy,
+        0,
+        0,
+        1,
+        x + width,
+        y + maxRy
+      );
+      for (let i = 1; i < topRightArc.length; i++) {
+        addVertex(topRightArc[i].x, topRightArc[i].y);
+      }
+      const bottomRightArc = this.approximateArc(
+        x + width,
+        y + height - maxRy,
+        maxRx,
+        maxRy,
+        0,
+        0,
+        1,
+        x + width - maxRx,
+        y + height
+      );
+      for (let i = 1; i < bottomRightArc.length; i++) {
+        addVertex(bottomRightArc[i].x, bottomRightArc[i].y);
+      }
+      const bottomLeftArc = this.approximateArc(
+        x + maxRx,
+        y + height,
+        maxRx,
+        maxRy,
+        0,
+        0,
+        1,
+        x,
+        y + height - maxRy
+      );
+      for (let i = 1; i < bottomLeftArc.length; i++) {
+        addVertex(bottomLeftArc[i].x, bottomLeftArc[i].y);
+      }
+      const topLeftArc = this.approximateArc(
+        x,
+        y + maxRy,
+        maxRx,
+        maxRy,
+        0,
+        0,
+        1,
+        x + maxRx,
+        y
+      );
+      for (let i = 1; i < topLeftArc.length; i++) {
+        addVertex(topLeftArc[i].x, topLeftArc[i].y);
+      }
+    } else {
+      addVertex(x, y);
+      addVertex(x + width, y);
+      addVertex(x + width, y + height);
+      addVertex(x, y + height);
+      addVertex(x, y);
+    }
+    lineStrips.push({
+      start: stripStart,
+      count: getVertexOffset() - stripStart,
+      kind: paint?.kind || "unknown"
+    });
+  }
+  /**
+   * 处理 line 元素
+   */
+  static processLine(element, addVertex, indices, getVertexOffset) {
+    const x1 = parseFloat(element.properties?.x1 || element.attributes?.x1 || 0);
+    const y1 = parseFloat(element.properties?.y1 || element.attributes?.y1 || 0);
+    const x2 = parseFloat(element.properties?.x2 || element.attributes?.x2 || 0);
+    const y2 = parseFloat(element.properties?.y2 || element.attributes?.y2 || 0);
+    const v0 = getVertexOffset();
+    addVertex(x1, y1);
+    const v1 = getVertexOffset();
+    addVertex(x2, y2);
+    indices.push(v0, v1);
+  }
+  /**
+   * 处理 polyline 元素
+   */
+  static processPolyline(element, addVertex, lineStrips, getVertexOffset, paint = null) {
+    const points = element.properties?.points || element.attributes?.points || "";
+    if (!points) return;
+    const coords = this.parsePoints(points);
+    if (coords.length < 2) return;
+    const stripStart = getVertexOffset();
+    coords.forEach((coord) => {
+      addVertex(coord.x, coord.y);
+    });
+    lineStrips.push({
+      start: stripStart,
+      count: coords.length,
+      kind: paint?.kind || "unknown"
+    });
+  }
+  /**
+   * 处理 polygon 元素
+   */
+  static processPolygon(element, addVertex, lineStrips, getVertexOffset, paint = null) {
+    const points = element.properties?.points || element.attributes?.points || "";
+    if (!points) return;
+    const coords = this.parsePoints(points);
+    if (coords.length < 2) return;
+    const stripStart = getVertexOffset();
+    coords.forEach((coord) => {
+      addVertex(coord.x, coord.y);
+    });
+    addVertex(coords[0].x, coords[0].y);
+    lineStrips.push({
+      start: stripStart,
+      count: coords.length + 1,
+      kind: paint?.kind || "unknown"
+    });
+  }
+  /**
+   * 解析 SVG path 数据
+   * 支持 M, L, H, V, Z, A 命令（绝对和相对坐标）
+   * A 命令用于绘制圆弧（圆角矩形等）
+   */
+  static parsePathData(d) {
+    if (!d || typeof d !== "string") return [];
+    const points = [];
+    let currentX = 0;
+    let currentY = 0;
+    let startX = 0;
+    let startY = 0;
+    const tokens = d.match(/[MLHVZACQSTmlhvzacqst]|-?[\d.]+(?:[eE][+-]?\d+)?/g);
+    if (!tokens || tokens.length === 0) return [];
+    let i = 0;
+    while (i < tokens.length) {
+      const token = tokens[i];
+      const upperToken = token.toUpperCase();
+      const isRelative = token === token.toLowerCase();
+      if (upperToken === "M") {
+        if (i + 2 < tokens.length) {
+          const x = parseFloat(tokens[i + 1]);
+          const y = parseFloat(tokens[i + 2]);
+          if (!isNaN(x) && !isNaN(y)) {
+            if (isRelative) {
+              currentX += x;
+              currentY += y;
+            } else {
+              currentX = x;
+              currentY = y;
+            }
+            startX = currentX;
+            startY = currentY;
+            points.push({ x: currentX, y: currentY });
+            i += 3;
+            while (i + 1 < tokens.length && !/^[MLHVZACQSTmlhvzacqst]$/.test(tokens[i])) {
+              const nextX = parseFloat(tokens[i]);
+              const nextY = parseFloat(tokens[i + 1]);
+              if (!isNaN(nextX) && !isNaN(nextY)) {
+                if (isRelative) {
+                  currentX += nextX;
+                  currentY += nextY;
+                } else {
+                  currentX = nextX;
+                  currentY = nextY;
+                }
+                points.push({ x: currentX, y: currentY });
+                i += 2;
+              } else {
+                break;
+              }
+            }
+          } else {
+            i++;
+          }
+        } else {
+          i++;
+        }
+      } else if (upperToken === "L") {
+        if (i + 2 < tokens.length) {
+          const x = parseFloat(tokens[i + 1]);
+          const y = parseFloat(tokens[i + 2]);
+          if (!isNaN(x) && !isNaN(y)) {
+            if (isRelative) {
+              currentX += x;
+              currentY += y;
+            } else {
+              currentX = x;
+              currentY = y;
+            }
+            points.push({ x: currentX, y: currentY });
+            i += 3;
+            while (i + 1 < tokens.length && !/^[MLHVZACQSTmlhvzacqst]$/.test(tokens[i])) {
+              const nextX = parseFloat(tokens[i]);
+              const nextY = parseFloat(tokens[i + 1]);
+              if (!isNaN(nextX) && !isNaN(nextY)) {
+                if (isRelative) {
+                  currentX += nextX;
+                  currentY += nextY;
+                } else {
+                  currentX = nextX;
+                  currentY = nextY;
+                }
+                points.push({ x: currentX, y: currentY });
+                i += 2;
+              } else {
+                break;
+              }
+            }
+          } else {
+            i++;
+          }
+        } else {
+          i++;
+        }
+      } else if (upperToken === "A") {
+        if (i + 7 < tokens.length) {
+          const rx = parseFloat(tokens[i + 1]);
+          const ry = parseFloat(tokens[i + 2]);
+          const xAxisRotation = parseFloat(tokens[i + 3]);
+          const largeArcFlag = parseFloat(tokens[i + 4]);
+          const sweepFlag = parseFloat(tokens[i + 5]);
+          const x = parseFloat(tokens[i + 6]);
+          const y = parseFloat(tokens[i + 7]);
+          if (!isNaN(rx) && !isNaN(ry) && !isNaN(x) && !isNaN(y)) {
+            const endX = isRelative ? currentX + x : x;
+            const endY = isRelative ? currentY + y : y;
+            const arcPoints = this.approximateArc(
+              currentX,
+              currentY,
+              rx,
+              ry,
+              xAxisRotation,
+              largeArcFlag,
+              sweepFlag,
+              endX,
+              endY
+            );
+            for (let j = 1; j < arcPoints.length; j++) {
+              points.push(arcPoints[j]);
+            }
+            currentX = endX;
+            currentY = endY;
+            i += 8;
+            while (i + 6 < tokens.length && !/^[MLHVZACQSTmlhvzacqst]$/.test(tokens[i])) {
+              const nextRx = parseFloat(tokens[i]);
+              const nextRy = parseFloat(tokens[i + 1]);
+              const nextXAxisRotation = parseFloat(tokens[i + 2]);
+              const nextLargeArcFlag = parseFloat(tokens[i + 3]);
+              const nextSweepFlag = parseFloat(tokens[i + 4]);
+              const nextX = parseFloat(tokens[i + 5]);
+              const nextY = parseFloat(tokens[i + 6]);
+              if (!isNaN(nextRx) && !isNaN(nextRy) && !isNaN(nextX) && !isNaN(nextY)) {
+                const nextEndX = isRelative ? currentX + nextX : nextX;
+                const nextEndY = isRelative ? currentY + nextY : nextY;
+                const nextArcPoints = this.approximateArc(
+                  currentX,
+                  currentY,
+                  nextRx,
+                  nextRy,
+                  nextXAxisRotation,
+                  nextLargeArcFlag,
+                  nextSweepFlag,
+                  nextEndX,
+                  nextEndY
+                );
+                for (let j = 1; j < nextArcPoints.length; j++) {
+                  points.push(nextArcPoints[j]);
+                }
+                currentX = nextEndX;
+                currentY = nextEndY;
+                i += 7;
+              } else {
+                break;
+              }
+            }
+          } else {
+            i++;
+          }
+        } else {
+          i++;
+        }
+      } else if (upperToken === "H") {
+        if (i + 1 < tokens.length) {
+          const x = parseFloat(tokens[i + 1]);
+          if (!isNaN(x)) {
+            if (isRelative) {
+              currentX += x;
+            } else {
+              currentX = x;
+            }
+            points.push({ x: currentX, y: currentY });
+            i += 2;
+          } else {
+            i++;
+          }
+        } else {
+          i++;
+        }
+      } else if (upperToken === "V") {
+        if (i + 1 < tokens.length) {
+          const y = parseFloat(tokens[i + 1]);
+          if (!isNaN(y)) {
+            if (isRelative) {
+              currentY += y;
+            } else {
+              currentY = y;
+            }
+            points.push({ x: currentX, y: currentY });
+            i += 2;
+          } else {
+            i++;
+          }
+        } else {
+          i++;
+        }
+      } else if (upperToken === "Z") {
+        if (points.length > 0 && (currentX !== startX || currentY !== startY)) {
+          points.push({ x: startX, y: startY });
+        }
+        currentX = startX;
+        currentY = startY;
+        i++;
+      } else if (upperToken === "C" || upperToken === "S" || upperToken === "Q" || upperToken === "T") {
+        i++;
+        const paramCount = upperToken === "C" ? 6 : upperToken === "S" ? 4 : upperToken === "Q" ? 4 : 2;
+        let skipped = 0;
+        while (i < tokens.length && skipped < paramCount) {
+          const num = parseFloat(tokens[i]);
+          if (!isNaN(num)) {
+            skipped++;
+            if (skipped === paramCount - 1) {
+              const endY = isRelative ? currentY + num : num;
+              currentY = endY;
+            } else if (skipped === paramCount - 2) {
+              const endX = isRelative ? currentX + num : num;
+              currentX = endX;
+            }
+          }
+          i++;
+        }
+        if (skipped === paramCount) {
+          points.push({ x: currentX, y: currentY });
+        }
+      } else {
+        console.warn(`\u8DEF\u5F84\u89E3\u6790\uFF1A\u9047\u5230\u672A\u77E5\u547D\u4EE4\u6216\u683C\u5F0F\u9519\u8BEF: ${token}\uFF0C\u4F4D\u7F6E: ${i}`);
+        i++;
+      }
+    }
+    return points;
+  }
+  /**
+   * 近似圆弧为线段
+   * @param {number} x1 - 起始点 X
+   * @param {number} y1 - 起始点 Y
+   * @param {number} rx - X 轴半径
+   * @param {number} ry - Y 轴半径
+   * @param {number} xAxisRotation - X 轴旋转角度（度）
+   * @param {number} largeArcFlag - 大弧标志（0 或 1）
+   * @param {number} sweepFlag - 扫描标志（0 或 1）
+   * @param {number} x2 - 终点 X
+   * @param {number} y2 - 终点 Y
+   * @returns {Array} - 近似点数组
+   */
+  static approximateArc(x1, y1, rx, ry, xAxisRotation, largeArcFlag, sweepFlag, x2, y2) {
+    const points = [];
+    if (rx < 1e-3 || ry < 1e-3) {
+      points.push({ x: x1, y: y1 });
+      points.push({ x: x2, y: y2 });
+      return points;
+    }
+    const dx = (x1 - x2) / 2;
+    const dy = (y1 - y2) / 2;
+    const cosPhi = Math.cos(xAxisRotation * Math.PI / 180);
+    const sinPhi = Math.sin(xAxisRotation * Math.PI / 180);
+    const x1p = cosPhi * dx + sinPhi * dy;
+    const y1p = -sinPhi * dx + cosPhi * dy;
+    const lambda = x1p * x1p / (rx * rx) + y1p * y1p / (ry * ry);
+    if (lambda > 1) {
+      rx *= Math.sqrt(lambda);
+      ry *= Math.sqrt(lambda);
+    }
+    const sign = largeArcFlag === sweepFlag ? -1 : 1;
+    const num = Math.max(0, (rx * rx * ry * ry - rx * rx * y1p * y1p - ry * ry * x1p * x1p) / (rx * rx * y1p * y1p + ry * ry * x1p * x1p));
+    const co = sign * Math.sqrt(num);
+    const cxp = co * rx * y1p / ry;
+    const cyp = -(co * ry * x1p) / rx;
+    const cx = cosPhi * cxp - sinPhi * cyp + (x1 + x2) / 2;
+    const cy = sinPhi * cxp + cosPhi * cyp + (y1 + y2) / 2;
+    const ux = (x1p - cxp) / rx;
+    const uy = (y1p - cyp) / ry;
+    const vx = (-x1p - cxp) / rx;
+    const vy = (-y1p - cyp) / ry;
+    let startAngle = Math.atan2(uy, ux);
+    let sweepAngle = Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy);
+    if (sweepFlag === 0 && sweepAngle > 0) {
+      sweepAngle -= 2 * Math.PI;
+    } else if (sweepFlag === 1 && sweepAngle < 0) {
+      sweepAngle += 2 * Math.PI;
+    }
+    const isFullCircle = Math.abs(Math.abs(sweepAngle) - 2 * Math.PI) < 1e-3;
+    const minSegments = 64;
+    const segments = Math.max(minSegments, Math.ceil(Math.abs(sweepAngle) * Math.max(rx, ry) / 2));
+    points.push({ x: x1, y: y1 });
+    for (let i = 1; i <= segments; i++) {
+      const angle = startAngle + sweepAngle * i / segments;
+      const px = cx + rx * Math.cos(angle) * cosPhi - ry * Math.sin(angle) * sinPhi;
+      const py = cy + rx * Math.cos(angle) * sinPhi + ry * Math.sin(angle) * cosPhi;
+      points.push({ x: px, y: py });
+    }
+    return points;
+  }
+  /**
+   * 解析 points 属性（polyline/polygon）
+   */
+  static parsePoints(pointsStr) {
+    if (!pointsStr || typeof pointsStr !== "string") return [];
+    const coords = [];
+    const numbers = pointsStr.match(/-?[\d.]+(?:[eE][+-]?\d+)?/g);
+    if (!numbers || numbers.length < 2) return [];
+    for (let i = 0; i < numbers.length - 1; i += 2) {
+      const x = parseFloat(numbers[i]);
+      const y = parseFloat(numbers[i + 1]);
+      if (!isNaN(x) && !isNaN(y)) {
+        coords.push({ x, y });
+      }
+    }
+    return coords;
+  }
+  /**
+   * 将十六进制颜色转换为 RGB
+   */
+  static hexToRgb(hex) {
+    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    return result ? {
+      r: parseInt(result[1], 16) / 255,
+      g: parseInt(result[2], 16) / 255,
+      b: parseInt(result[3], 16) / 255
+    } : { r: 1, g: 0, b: 0 };
+  }
+  /**
+   * 从 SVG 树中提取钻孔坐标（圆形元素的中心点）
+   * 用于 DRL 文件
+   * @param {Object} svgTree - SVG 树
+   * @returns {Array<{x: number, y: number, r: number}>} - 钻孔坐标数组
+   */
+  static extractHoles(svgTree) {
+    const holes = [];
+    if (!svgTree || !svgTree.children) return holes;
+    const extractFromElement = (element) => {
+      if (!element || !element.tagName) return;
+      const tagName = element.tagName.toLowerCase();
+      if (tagName === "circle") {
+        const cx = parseFloat(element.properties?.cx || element.attributes?.cx || 0);
+        const cy = parseFloat(element.properties?.cy || element.attributes?.cy || 0);
+        const r = parseFloat(element.properties?.r || element.attributes?.r || 0);
+        if (r > 0 && !isNaN(cx) && !isNaN(cy)) {
+          holes.push({ x: cx, y: cy, r });
+        }
+      } else if (tagName === "g") {
+        if (element.children) {
+          element.children.forEach((child) => extractFromElement(child));
+        }
+      }
+    };
+    svgTree.children.forEach((child) => extractFromElement(child));
+    return holes;
+  }
+  /**
+   * 从 SVG 树中提取特征点（圆形、矩形等元素的中心点）
+   * 用于 Gerber 文件，提取焊盘、过孔等特征点
+   * @param {Object} svgTree - SVG 树
+   * @returns {Array<{x: number, y: number, r?: number, type: string}>} - 特征点坐标数组
+   */
+  static extractFeaturePoints(svgTree) {
+    const points = [];
+    if (!svgTree || !svgTree.children) return points;
+    const extractFromElement = (element) => {
+      if (!element || !element.tagName) return;
+      const tagName = element.tagName.toLowerCase();
+      if (tagName === "circle") {
+        const cx = parseFloat(element.properties?.cx || element.attributes?.cx || 0);
+        const cy = parseFloat(element.properties?.cy || element.attributes?.cy || 0);
+        const r = parseFloat(element.properties?.r || element.attributes?.r || 0);
+        if (r > 0 && !isNaN(cx) && !isNaN(cy)) {
+          points.push({ x: cx, y: cy, r, type: "circle" });
+        }
+      } else if (tagName === "rect") {
+        const x = parseFloat(element.properties?.x || element.attributes?.x || 0);
+        const y = parseFloat(element.properties?.y || element.attributes?.y || 0);
+        const width = parseFloat(element.properties?.width || element.attributes?.width || 0);
+        const height = parseFloat(element.properties?.height || element.attributes?.height || 0);
+        if (width > 0 && height > 0 && !isNaN(x) && !isNaN(y)) {
+          const cx = x + width / 2;
+          const cy = y + height / 2;
+          const r = Math.sqrt(width * width + height * height) / 2;
+          points.push({ x: cx, y: cy, r, type: "rect", width, height });
+        }
+      } else if (tagName === "ellipse") {
+        const cx = parseFloat(element.properties?.cx || element.attributes?.cx || 0);
+        const cy = parseFloat(element.properties?.cy || element.attributes?.cy || 0);
+        const rx = parseFloat(element.properties?.rx || element.attributes?.rx || 0);
+        const ry = parseFloat(element.properties?.ry || element.attributes?.ry || 0);
+        if (rx > 0 && ry > 0 && !isNaN(cx) && !isNaN(cy)) {
+          const isCircle = Math.abs(rx - ry) < 1e-4;
+          const r = isCircle ? rx : Math.max(rx, ry);
+          points.push({
+            x: cx,
+            y: cy,
+            r,
+            type: isCircle ? "circle" : "ellipse",
+            rx,
+            ry
+          });
+        }
+      } else if (tagName === "polygon") {
+        const pointsStr = element.properties?.points || element.attributes?.points || "";
+        if (pointsStr) {
+          const polygonPoints = this.parsePoints(pointsStr);
+          if (polygonPoints.length >= 3) {
+            let sumX = 0;
+            let sumY = 0;
+            let minX = Infinity;
+            let minY = Infinity;
+            let maxX = -Infinity;
+            let maxY = -Infinity;
+            for (const point of polygonPoints) {
+              sumX += point.x;
+              sumY += point.y;
+              minX = Math.min(minX, point.x);
+              minY = Math.min(minY, point.y);
+              maxX = Math.max(maxX, point.x);
+              maxY = Math.max(maxY, point.y);
+            }
+            const cx = sumX / polygonPoints.length;
+            const cy = sumY / polygonPoints.length;
+            const r = Math.sqrt(
+              Math.pow(maxX - minX, 2) + Math.pow(maxY - minY, 2)
+            ) / 2;
+            if (r > 1e-3) {
+              points.push({ x: cx, y: cy, r, type: "polygon", pointCount: polygonPoints.length });
+            }
+          }
+        }
+      } else if (tagName === "polyline") {
+        const pointsStr = element.properties?.points || element.attributes?.points || "";
+        if (pointsStr) {
+          const polylinePoints = this.parsePoints(pointsStr);
+          if (polylinePoints.length >= 2) {
+            let sumX = 0;
+            let sumY = 0;
+            let minX = Infinity;
+            let minY = Infinity;
+            let maxX = -Infinity;
+            let maxY = -Infinity;
+            for (const point of polylinePoints) {
+              sumX += point.x;
+              sumY += point.y;
+              minX = Math.min(minX, point.x);
+              minY = Math.min(minY, point.y);
+              maxX = Math.max(maxX, point.x);
+              maxY = Math.max(maxY, point.y);
+            }
+            const cx = sumX / polylinePoints.length;
+            const cy = sumY / polylinePoints.length;
+            const r = Math.sqrt(
+              Math.pow(maxX - minX, 2) + Math.pow(maxY - minY, 2)
+            ) / 2;
+            if (r > 1e-3) {
+              points.push({ x: cx, y: cy, r, type: "polyline", pointCount: polylinePoints.length });
+            }
+          }
+        }
+      } else if (tagName === "path") {
+        const d = element.properties?.d || element.attributes?.d || "";
+        if (d) {
+          const pathPoints = this.parsePathData(d);
+          if (pathPoints.length >= 2) {
+            let sumX = 0;
+            let sumY = 0;
+            for (const point of pathPoints) {
+              sumX += point.x;
+              sumY += point.y;
+            }
+            const centerX = sumX / pathPoints.length;
+            const centerY = sumY / pathPoints.length;
+            const distances = pathPoints.map(
+              (p) => Math.sqrt(Math.pow(p.x - centerX, 2) + Math.pow(p.y - centerY, 2))
+            );
+            const avgDistance = distances.reduce((a, b) => a + b, 0) / distances.length;
+            const variance = distances.reduce((sum, d2) => sum + Math.pow(d2 - avgDistance, 2), 0) / distances.length;
+            const stdDev = Math.sqrt(variance);
+            const isClosed = pathPoints.length > 2 && Math.sqrt(
+              Math.pow(pathPoints[0].x - pathPoints[pathPoints.length - 1].x, 2) + Math.pow(pathPoints[0].y - pathPoints[pathPoints.length - 1].y, 2)
+            ) < 1e-3;
+            const isCircle = isClosed && avgDistance > 1e-3 && stdDev / avgDistance < 0.05;
+            if (isCircle) {
+              points.push({
+                x: centerX,
+                y: centerY,
+                r: avgDistance,
+                type: "circle",
+                source: "path"
+              });
+            } else {
+              const start = pathPoints[0];
+              const end = pathPoints[pathPoints.length - 1];
+              const pathLength = Math.sqrt(
+                Math.pow(end.x - start.x, 2) + Math.pow(end.y - start.y, 2)
+              );
+              if (pathLength > 1e-3) {
+                points.push({ x: start.x, y: start.y, r: pathLength / 2, type: "path-start" });
+                points.push({ x: end.x, y: end.y, r: pathLength / 2, type: "path-end" });
+              }
+            }
+          }
+        }
+      } else if (tagName === "g") {
+        if (element.children) {
+          element.children.forEach((child) => extractFromElement(child));
+        }
+      }
+    };
+    svgTree.children.forEach((child) => extractFromElement(child));
+    return points;
+  }
+};
+
+export {
+  GerberParser
+};
+//# sourceMappingURL=chunk-O3NXUM6C.js.map