circuit-to-svg 0.0.305 → 0.0.307

package/dist/index.js

@@ -1,5 +1,5 @@
 // lib/pcb/convert-circuit-json-to-pcb-svg.ts
-import { distance as distance2 } from "circuit-json";
+import "circuit-json";
 import { stringify } from "svgson";
 import {
   applyToPoint as applyToPoint37,
@@ -3834,10 +3834,10 @@ function createSvgObjectsFromSmtPad(pad, ctx) {
       maskPoints = points.map(([px, py]) => {
         const dx = px - centroidX;
         const dy = py - centroidY;
-        const distance4 = Math.sqrt(dx * dx + dy * dy);
-        if (distance4 === 0) return [px, py];
-        const normalizedDx = dx / distance4;
-        const normalizedDy = dy / distance4;
+        const distance5 = Math.sqrt(dx * dx + dy * dy);
+        if (distance5 === 0) return [px, py];
+        const normalizedDx = dx / distance5;
+        const normalizedDy = dy / distance5;
         return [
           px + normalizedDx * soldermaskMargin,
           py + normalizedDy * soldermaskMargin
@@ -4043,11 +4043,11 @@ function createAnchorOffsetIndicators(params) {
 function getTrimmedConnectorLine(x1, y1, x2, y2) {
   const dx = x2 - x1;
   const dy = y2 - y1;
-  const distance4 = Math.hypot(dx, dy);
+  const distance5 = Math.hypot(dx, dy);
   const totalTrim = CONNECTOR_GROUP_GAP_PX + CONNECTOR_COMPONENT_GAP_PX;
-  if (!(distance4 > totalTrim)) return { x1, y1, x2, y2 };
-  const ux = dx / distance4;
-  const uy = dy / distance4;
+  if (!(distance5 > totalTrim)) return { x1, y1, x2, y2 };
+  const ux = dx / distance5;
+  const uy = dy / distance5;
   return {
     x1: x1 + ux * CONNECTOR_GROUP_GAP_PX,
     y1: y1 + uy * CONNECTOR_GROUP_GAP_PX,
@@ -5004,9 +5004,9 @@ var findNearestPointInNet = (sourcePoint, netId, connectivity, circuitJson) => {
     if (pos) {
       const dx = sourcePoint.x - pos.x;
       const dy = sourcePoint.y - pos.y;
-      const distance4 = Math.sqrt(dx * dx + dy * dy);
-      if (distance4 > 0 && distance4 < minDistance) {
-        minDistance = distance4;
+      const distance5 = Math.sqrt(dx * dx + dy * dy);
+      if (distance5 > 0 && distance5 < minDistance) {
+        minDistance = distance5;
         nearestPoint = pos;
       }
     }
@@ -5884,7 +5884,7 @@ function getSoftwareUsedString(circuitJson) {
 var package_default = {
   name: "circuit-to-svg",
   type: "module",
-  version: "0.0.304",
+  version: "0.0.306",
   description: "Convert Circuit JSON to SVG",
   main: "dist/index.js",
   files: [
@@ -6066,49 +6066,9 @@ function createErrorTextOverlay(circuitJson, dataType = "error_text_overlay") {
   return textBlock;
 }
 
-// lib/pcb/convert-circuit-json-to-pcb-svg.ts
-function convertCircuitJsonToPcbSvg(circuitJson, options) {
-  const drawPaddingOutsideBoard = options?.drawPaddingOutsideBoard ?? true;
-  const layer = options?.layer;
-  const colorOverrides = options?.colorOverrides;
-  const copperColors = {
-    ...DEFAULT_PCB_COLOR_MAP.copper
-  };
-  if (colorOverrides?.copper) {
-    for (const [layerName, color] of Object.entries(colorOverrides.copper)) {
-      if (color !== void 0) {
-        copperColors[layerName] = color;
-      }
-    }
-  }
-  const colorMap2 = {
-    copper: copperColors,
-    drill: colorOverrides?.drill ?? DEFAULT_PCB_COLOR_MAP.drill,
-    silkscreen: {
-      top: colorOverrides?.silkscreen?.top ?? DEFAULT_PCB_COLOR_MAP.silkscreen.top,
-      bottom: colorOverrides?.silkscreen?.bottom ?? DEFAULT_PCB_COLOR_MAP.silkscreen.bottom
-    },
-    boardOutline: colorOverrides?.boardOutline ?? DEFAULT_PCB_COLOR_MAP.boardOutline,
-    soldermask: {
-      top: colorOverrides?.soldermask?.top ?? DEFAULT_PCB_COLOR_MAP.soldermask.top,
-      bottom: colorOverrides?.soldermask?.bottom ?? DEFAULT_PCB_COLOR_MAP.soldermask.bottom
-    },
-    soldermaskOverCopper: {
-      top: colorOverrides?.soldermaskOverCopper?.top ?? DEFAULT_PCB_COLOR_MAP.soldermaskOverCopper.top,
-      bottom: colorOverrides?.soldermaskOverCopper?.bottom ?? DEFAULT_PCB_COLOR_MAP.soldermaskOverCopper.bottom
-    },
-    soldermaskWithCopperUnderneath: {
-      top: colorOverrides?.soldermaskWithCopperUnderneath?.top ?? DEFAULT_PCB_COLOR_MAP.soldermaskWithCopperUnderneath.top,
-      bottom: colorOverrides?.soldermaskWithCopperUnderneath?.bottom ?? DEFAULT_PCB_COLOR_MAP.soldermaskWithCopperUnderneath.bottom
-    },
-    substrate: colorOverrides?.substrate ?? DEFAULT_PCB_COLOR_MAP.substrate,
-    courtyard: colorOverrides?.courtyard ?? DEFAULT_PCB_COLOR_MAP.courtyard,
-    keepout: colorOverrides?.keepout ?? DEFAULT_PCB_COLOR_MAP.keepout,
-    debugComponent: {
-      fill: colorOverrides?.debugComponent?.fill ?? DEFAULT_PCB_COLOR_MAP.debugComponent.fill,
-      stroke: colorOverrides?.debugComponent?.stroke ?? DEFAULT_PCB_COLOR_MAP.debugComponent.stroke
-    }
-  };
+// lib/pcb/get-pcb-bounds-from-circuit-json.ts
+import { distance as distance2 } from "circuit-json";
+function getPcbBoundsFromCircuitJson(circuitJson) {
   let minX = Number.POSITIVE_INFINITY;
   let minY = Number.POSITIVE_INFINITY;
   let maxX = Number.NEGATIVE_INFINITY;
@@ -6128,53 +6088,167 @@ function convertCircuitJsonToPcbSvg(circuitJson, options) {
         continue;
       }
       const center = panel.center ?? { x: width / 2, y: height / 2 };
-      updateBounds(center, width, height);
+      updateBounds({ center, width, height });
     } else if (circuitJsonElm.type === "pcb_board") {
       if (circuitJsonElm.outline && Array.isArray(circuitJsonElm.outline) && circuitJsonElm.outline.length >= 3) {
         updateBoundsToIncludeOutline(circuitJsonElm.outline);
         updateBoardBoundsToIncludeOutline(circuitJsonElm.outline);
       } else if ("center" in circuitJsonElm && "width" in circuitJsonElm && "height" in circuitJsonElm) {
-        updateBounds(
-          circuitJsonElm.center,
-          circuitJsonElm.width,
-          circuitJsonElm.height
-        );
-        updateBoardBounds(
-          circuitJsonElm.center,
-          circuitJsonElm.width,
-          circuitJsonElm.height
-        );
+        updateBounds({
+          center: circuitJsonElm.center,
+          width: circuitJsonElm.width,
+          height: circuitJsonElm.height
+        });
+        updateBoardBounds({
+          center: circuitJsonElm.center,
+          width: circuitJsonElm.width,
+          height: circuitJsonElm.height
+        });
       }
     } else if (circuitJsonElm.type === "pcb_smtpad") {
       const pad = circuitJsonElm;
       if (pad.shape === "rect" || pad.shape === "rotated_rect" || pad.shape === "pill") {
-        updateBounds({ x: pad.x, y: pad.y }, pad.width, pad.height);
+        updateBounds({
+          center: { x: pad.x, y: pad.y },
+          width: pad.width,
+          height: pad.height
+        });
       } else if (pad.shape === "circle") {
         const radius = distance2.parse(pad.radius);
         if (radius !== void 0) {
-          updateBounds({ x: pad.x, y: pad.y }, radius * 2, radius * 2);
+          updateBounds({
+            center: { x: pad.x, y: pad.y },
+            width: radius * 2,
+            height: radius * 2
+          });
         }
       } else if (pad.shape === "polygon") {
         updateTraceBounds(pad.points);
       }
     } else if ("x" in circuitJsonElm && "y" in circuitJsonElm) {
-      updateBounds({ x: circuitJsonElm.x, y: circuitJsonElm.y }, 0, 0);
+      updateBounds({
+        center: { x: circuitJsonElm.x, y: circuitJsonElm.y },
+        width: 0,
+        height: 0
+      });
     } else if ("route" in circuitJsonElm) {
       updateTraceBounds(circuitJsonElm.route);
     } else if (circuitJsonElm.type === "pcb_note_rect" || circuitJsonElm.type === "pcb_fabrication_note_rect") {
-      updateBounds(
-        circuitJsonElm.center,
-        circuitJsonElm.width,
-        circuitJsonElm.height
-      );
+      updateBounds({
+        center: circuitJsonElm.center,
+        width: circuitJsonElm.width,
+        height: circuitJsonElm.height
+      });
+    } else if (circuitJsonElm.type === "pcb_note_dimension" || circuitJsonElm.type === "pcb_fabrication_note_dimension") {
+      const dimension = circuitJsonElm;
+      const {
+        from,
+        to,
+        text,
+        font_size = 1,
+        arrow_size,
+        offset_distance,
+        offset_direction
+      } = dimension;
+      if (!from || !to || !arrow_size) continue;
+      updateBounds({ center: from, width: 0, height: 0 });
+      updateBounds({ center: to, width: 0, height: 0 });
+      const normalize3 = (v) => {
+        const l = Math.hypot(v.x, v.y) || 1;
+        return { x: v.x / l, y: v.y / l };
+      };
+      const direction = normalize3({ x: to.x - from.x, y: to.y - from.y });
+      if (Number.isNaN(direction.x) || Number.isNaN(direction.y)) continue;
+      const perpendicular = { x: -direction.y, y: direction.x };
+      const hasOffsetDirection = offset_direction && typeof offset_direction.x === "number" && typeof offset_direction.y === "number";
+      const normalizedOffsetDirection = hasOffsetDirection ? normalize3(offset_direction) : { x: 0, y: 0 };
+      const offsetMagnitude = typeof offset_distance === "number" ? offset_distance : 0;
+      const offsetVector = {
+        x: normalizedOffsetDirection.x * offsetMagnitude,
+        y: normalizedOffsetDirection.y * offsetMagnitude
+      };
+      const fromOffset = {
+        x: from.x + offsetVector.x,
+        y: from.y + offsetVector.y
+      };
+      const toOffset = { x: to.x + offsetVector.x, y: to.y + offsetVector.y };
+      updateBounds({ center: fromOffset, width: 0, height: 0 });
+      updateBounds({ center: toOffset, width: 0, height: 0 });
+      const extensionDirection = hasOffsetDirection && (Math.abs(normalizedOffsetDirection.x) > Number.EPSILON || Math.abs(normalizedOffsetDirection.y) > Number.EPSILON) ? normalizedOffsetDirection : perpendicular;
+      const extensionLength = offsetMagnitude + arrow_size;
+      const fromExtEnd = {
+        x: from.x + extensionDirection.x * extensionLength,
+        y: from.y + extensionDirection.y * extensionLength
+      };
+      const toExtEnd = {
+        x: to.x + extensionDirection.x * extensionLength,
+        y: to.y + extensionDirection.y * extensionLength
+      };
+      updateBounds({ center: fromExtEnd, width: 0, height: 0 });
+      updateBounds({ center: toExtEnd, width: 0, height: 0 });
+      const arrowHalfWidth = arrow_size / 2;
+      const fromBase = {
+        x: fromOffset.x + direction.x * arrow_size,
+        y: fromOffset.y + direction.y * arrow_size
+      };
+      const toBase = {
+        x: toOffset.x - direction.x * arrow_size,
+        y: toOffset.y - direction.y * arrow_size
+      };
+      const fromArrowP2 = {
+        x: fromBase.x + perpendicular.x * arrowHalfWidth,
+        y: fromBase.y + perpendicular.y * arrowHalfWidth
+      };
+      const fromArrowP3 = {
+        x: fromBase.x - perpendicular.x * arrowHalfWidth,
+        y: fromBase.y - perpendicular.y * arrowHalfWidth
+      };
+      updateBounds({ center: fromArrowP2, width: 0, height: 0 });
+      updateBounds({ center: fromArrowP3, width: 0, height: 0 });
+      const toArrowP2 = {
+        x: toBase.x + perpendicular.x * arrowHalfWidth,
+        y: toBase.y + perpendicular.y * arrowHalfWidth
+      };
+      const toArrowP3 = {
+        x: toBase.x - perpendicular.x * arrowHalfWidth,
+        y: toBase.y - perpendicular.y * arrowHalfWidth
+      };
+      updateBounds({ center: toArrowP2, width: 0, height: 0 });
+      updateBounds({ center: toArrowP3, width: 0, height: 0 });
+      if (text) {
+        const midPoint = {
+          x: (from.x + to.x) / 2 + offsetVector.x,
+          y: (from.y + to.y) / 2 + offsetVector.y
+        };
+        const textOffset = arrow_size * 1.5;
+        const textPoint = {
+          x: midPoint.x + perpendicular.x * textOffset,
+          y: midPoint.y + perpendicular.y * textOffset
+        };
+        const textWidth = text.length * font_size * 0.6;
+        const textHeight = font_size;
+        updateBounds({
+          center: textPoint,
+          width: textWidth,
+          height: textHeight
+        });
+      }
     } else if (circuitJsonElm.type === "pcb_cutout") {
       const cutout = circuitJsonElm;
       if (cutout.shape === "rect") {
-        updateBounds(cutout.center, cutout.width, cutout.height);
+        updateBounds({
+          center: cutout.center,
+          width: cutout.width,
+          height: cutout.height
+        });
       } else if (cutout.shape === "circle") {
         const radius = distance2.parse(cutout.radius);
         if (radius !== void 0) {
-          updateBounds(cutout.center, radius * 2, radius * 2);
+          updateBounds({
+            center: cutout.center,
+            width: radius * 2,
+            height: radius * 2
+          });
         }
       } else if (cutout.shape === "polygon") {
         updateTraceBounds(cutout.points);
@@ -6187,34 +6261,262 @@ function convertCircuitJsonToPcbSvg(circuitJson, options) {
     } else if (circuitJsonElm.type === "pcb_keepout") {
       const keepout = circuitJsonElm;
       if (keepout.shape === "rect") {
-        updateBounds(keepout.center, keepout.width, keepout.height);
+        updateBounds({
+          center: keepout.center,
+          width: keepout.width,
+          height: keepout.height
+        });
       } else if (keepout.shape === "circle") {
         const radius = typeof keepout.radius === "number" ? keepout.radius : distance2.parse(keepout.radius) ?? 0;
         if (radius > 0) {
-          updateBounds(keepout.center, radius * 2, radius * 2);
+          updateBounds({
+            center: keepout.center,
+            width: radius * 2,
+            height: radius * 2
+          });
         }
       }
     } else if (circuitJsonElm.type === "pcb_silkscreen_text" || circuitJsonElm.type === "pcb_silkscreen_rect" || circuitJsonElm.type === "pcb_silkscreen_circle" || circuitJsonElm.type === "pcb_silkscreen_line" || circuitJsonElm.type === "pcb_silkscreen_oval") {
       updateSilkscreenBounds(circuitJsonElm);
     } else if (circuitJsonElm.type === "pcb_copper_text") {
-      updateBounds(circuitJsonElm.anchor_position, 0, 0);
+      updateBounds({
+        center: circuitJsonElm.anchor_position,
+        width: 0,
+        height: 0
+      });
     } else if (circuitJsonElm.type === "pcb_copper_pour") {
       if (circuitJsonElm.shape === "rect") {
-        updateBounds(
-          circuitJsonElm.center,
-          circuitJsonElm.width,
-          circuitJsonElm.height
-        );
+        updateBounds({
+          center: circuitJsonElm.center,
+          width: circuitJsonElm.width,
+          height: circuitJsonElm.height
+        });
       } else if (circuitJsonElm.shape === "polygon") {
         updateTraceBounds(circuitJsonElm.points);
       }
     }
   }
+  return {
+    minX,
+    minY,
+    maxX,
+    maxY,
+    boardMinX,
+    boardMinY,
+    boardMaxX,
+    boardMaxY,
+    hasBounds,
+    hasBoardBounds
+  };
+  function updateBounds({
+    center,
+    width,
+    height
+  }) {
+    if (!center) return;
+    const centerX = distance2.parse(center.x);
+    const centerY = distance2.parse(center.y);
+    if (centerX === void 0 || centerY === void 0) return;
+    const numericWidth = distance2.parse(width) ?? 0;
+    const numericHeight = distance2.parse(height) ?? 0;
+    const halfWidth = numericWidth / 2;
+    const halfHeight = numericHeight / 2;
+    minX = Math.min(minX, centerX - halfWidth);
+    minY = Math.min(minY, centerY - halfHeight);
+    maxX = Math.max(maxX, centerX + halfWidth);
+    maxY = Math.max(maxY, centerY + halfHeight);
+    hasBounds = true;
+  }
+  function updateBoardBounds({
+    center,
+    width,
+    height
+  }) {
+    if (!center) return;
+    const centerX = distance2.parse(center.x);
+    const centerY = distance2.parse(center.y);
+    if (centerX === void 0 || centerY === void 0) return;
+    const numericWidth = distance2.parse(width) ?? 0;
+    const numericHeight = distance2.parse(height) ?? 0;
+    const halfWidth = numericWidth / 2;
+    const halfHeight = numericHeight / 2;
+    boardMinX = Math.min(boardMinX, centerX - halfWidth);
+    boardMinY = Math.min(boardMinY, centerY - halfHeight);
+    boardMaxX = Math.max(boardMaxX, centerX + halfWidth);
+    boardMaxY = Math.max(boardMaxY, centerY + halfHeight);
+    hasBounds = true;
+    hasBoardBounds = true;
+  }
+  function updateBoundsToIncludeOutline(outline) {
+    let updated = false;
+    for (const point of outline) {
+      const x = distance2.parse(point.x);
+      const y = distance2.parse(point.y);
+      if (x === void 0 || y === void 0) continue;
+      minX = Math.min(minX, x);
+      minY = Math.min(minY, y);
+      maxX = Math.max(maxX, x);
+      maxY = Math.max(maxY, y);
+      updated = true;
+    }
+    if (updated) {
+      hasBounds = true;
+    }
+  }
+  function updateBoardBoundsToIncludeOutline(outline) {
+    let updated = false;
+    for (const point of outline) {
+      const x = distance2.parse(point.x);
+      const y = distance2.parse(point.y);
+      if (x === void 0 || y === void 0) continue;
+      boardMinX = Math.min(boardMinX, x);
+      boardMinY = Math.min(boardMinY, y);
+      boardMaxX = Math.max(boardMaxX, x);
+      boardMaxY = Math.max(boardMaxY, y);
+      updated = true;
+    }
+    if (updated) {
+      hasBounds = true;
+      hasBoardBounds = true;
+    }
+  }
+  function updateTraceBounds(route) {
+    let updated = false;
+    for (const point of route) {
+      const x = distance2.parse(point?.x);
+      const y = distance2.parse(point?.y);
+      if (x === void 0 || y === void 0) continue;
+      minX = Math.min(minX, x);
+      minY = Math.min(minY, y);
+      maxX = Math.max(maxX, x);
+      maxY = Math.max(maxY, y);
+      updated = true;
+    }
+    if (updated) {
+      hasBounds = true;
+    }
+  }
+  function updateSilkscreenBounds(item) {
+    if (item.type === "pcb_silkscreen_text") {
+      updateBounds({ center: item.anchor_position, width: 0, height: 0 });
+    } else if (item.type === "pcb_silkscreen_path") {
+      updateTraceBounds(item.route);
+    } else if (item.type === "pcb_silkscreen_rect") {
+      updateBounds({
+        center: item.center,
+        width: item.width,
+        height: item.height
+      });
+    } else if (item.type === "pcb_silkscreen_circle") {
+      const radius = distance2.parse(item.radius);
+      if (radius !== void 0) {
+        updateBounds({
+          center: item.center,
+          width: radius * 2,
+          height: radius * 2
+        });
+      }
+    } else if (item.type === "pcb_silkscreen_line") {
+      updateBounds({ center: { x: item.x1, y: item.y1 }, width: 0, height: 0 });
+      updateBounds({ center: { x: item.x2, y: item.y2 }, width: 0, height: 0 });
+    } else if (item.type === "pcb_silkscreen_oval") {
+      const radiusX = distance2.parse(item.radius_x);
+      const radiusY = distance2.parse(item.radius_y);
+      if (radiusX !== void 0 && radiusY !== void 0) {
+        updateBounds({
+          center: item.center,
+          width: radiusX * 2,
+          height: radiusY * 2
+        });
+      }
+    } else if (item.type === "pcb_cutout") {
+      const cutout = item;
+      if (cutout.shape === "rect") {
+        updateBounds({
+          center: cutout.center,
+          width: cutout.width,
+          height: cutout.height
+        });
+      } else if (cutout.shape === "circle") {
+        const radius = distance2.parse(cutout.radius);
+        if (radius !== void 0) {
+          updateBounds({
+            center: cutout.center,
+            width: radius * 2,
+            height: radius * 2
+          });
+        }
+      } else if (cutout.shape === "polygon") {
+        updateTraceBounds(cutout.points);
+      } else if (cutout.shape === "path") {
+        const cutoutPath = cutout;
+        if (cutoutPath.route && Array.isArray(cutoutPath.route)) {
+          updateTraceBounds(cutoutPath.route);
+        }
+      }
+    }
+  }
+}
+
+// lib/pcb/convert-circuit-json-to-pcb-svg.ts
+function convertCircuitJsonToPcbSvg(circuitJson, options) {
+  const drawPaddingOutsideBoard = options?.drawPaddingOutsideBoard ?? true;
+  const layer = options?.layer;
+  const colorOverrides = options?.colorOverrides;
+  const copperColors = {
+    ...DEFAULT_PCB_COLOR_MAP.copper
+  };
+  if (colorOverrides?.copper) {
+    for (const [layerName, color] of Object.entries(colorOverrides.copper)) {
+      if (color !== void 0) {
+        copperColors[layerName] = color;
+      }
+    }
+  }
+  const colorMap2 = {
+    copper: copperColors,
+    drill: colorOverrides?.drill ?? DEFAULT_PCB_COLOR_MAP.drill,
+    silkscreen: {
+      top: colorOverrides?.silkscreen?.top ?? DEFAULT_PCB_COLOR_MAP.silkscreen.top,
+      bottom: colorOverrides?.silkscreen?.bottom ?? DEFAULT_PCB_COLOR_MAP.silkscreen.bottom
+    },
+    boardOutline: colorOverrides?.boardOutline ?? DEFAULT_PCB_COLOR_MAP.boardOutline,
+    soldermask: {
+      top: colorOverrides?.soldermask?.top ?? DEFAULT_PCB_COLOR_MAP.soldermask.top,
+      bottom: colorOverrides?.soldermask?.bottom ?? DEFAULT_PCB_COLOR_MAP.soldermask.bottom
+    },
+    soldermaskOverCopper: {
+      top: colorOverrides?.soldermaskOverCopper?.top ?? DEFAULT_PCB_COLOR_MAP.soldermaskOverCopper.top,
+      bottom: colorOverrides?.soldermaskOverCopper?.bottom ?? DEFAULT_PCB_COLOR_MAP.soldermaskOverCopper.bottom
+    },
+    soldermaskWithCopperUnderneath: {
+      top: colorOverrides?.soldermaskWithCopperUnderneath?.top ?? DEFAULT_PCB_COLOR_MAP.soldermaskWithCopperUnderneath.top,
+      bottom: colorOverrides?.soldermaskWithCopperUnderneath?.bottom ?? DEFAULT_PCB_COLOR_MAP.soldermaskWithCopperUnderneath.bottom
+    },
+    substrate: colorOverrides?.substrate ?? DEFAULT_PCB_COLOR_MAP.substrate,
+    courtyard: colorOverrides?.courtyard ?? DEFAULT_PCB_COLOR_MAP.courtyard,
+    keepout: colorOverrides?.keepout ?? DEFAULT_PCB_COLOR_MAP.keepout,
+    debugComponent: {
+      fill: colorOverrides?.debugComponent?.fill ?? DEFAULT_PCB_COLOR_MAP.debugComponent.fill,
+      stroke: colorOverrides?.debugComponent?.stroke ?? DEFAULT_PCB_COLOR_MAP.debugComponent.stroke
+    }
+  };
+  const {
+    minX,
+    minY,
+    maxX,
+    maxY,
+    boardMinX,
+    boardMinY,
+    boardMaxX,
+    boardMaxY,
+    hasBoardBounds
+  } = getPcbBoundsFromCircuitJson(circuitJson);
   const padding = drawPaddingOutsideBoard ? 1 : 0;
-  const boundsMinX = drawPaddingOutsideBoard || !Number.isFinite(boardMinX) ? minX : boardMinX;
-  const boundsMinY = drawPaddingOutsideBoard || !Number.isFinite(boardMinY) ? minY : boardMinY;
-  const boundsMaxX = drawPaddingOutsideBoard || !Number.isFinite(boardMaxX) ? maxX : boardMaxX;
-  const boundsMaxY = drawPaddingOutsideBoard || !Number.isFinite(boardMaxY) ? maxY : boardMaxY;
+  const boundsMinX = drawPaddingOutsideBoard || !hasBoardBounds ? minX : boardMinX;
+  const boundsMinY = drawPaddingOutsideBoard || !hasBoardBounds ? minY : boardMinY;
+  const boundsMaxX = drawPaddingOutsideBoard || !hasBoardBounds ? maxX : boardMaxX;
+  const boundsMaxY = drawPaddingOutsideBoard || !hasBoardBounds ? maxY : boardMaxY;
   const circuitWidth = boundsMaxX - boundsMinX + 2 * padding;
   const circuitHeight = boundsMaxY - boundsMinY + 2 * padding;
   let svgWidth = options?.width ?? 800;
@@ -6363,126 +6665,6 @@ function convertCircuitJsonToPcbSvg(circuitJson, options) {
     console.error("Error stringifying SVG object:", error);
     throw error;
   }
-  function updateBounds(center, width, height) {
-    if (!center) return;
-    const centerX = distance2.parse(center.x);
-    const centerY = distance2.parse(center.y);
-    if (centerX === void 0 || centerY === void 0) return;
-    const numericWidth = distance2.parse(width) ?? 0;
-    const numericHeight = distance2.parse(height) ?? 0;
-    const halfWidth = numericWidth / 2;
-    const halfHeight = numericHeight / 2;
-    minX = Math.min(minX, centerX - halfWidth);
-    minY = Math.min(minY, centerY - halfHeight);
-    maxX = Math.max(maxX, centerX + halfWidth);
-    maxY = Math.max(maxY, centerY + halfHeight);
-    hasBounds = true;
-  }
-  function updateBoardBounds(center, width, height) {
-    if (!center) return;
-    const centerX = distance2.parse(center.x);
-    const centerY = distance2.parse(center.y);
-    if (centerX === void 0 || centerY === void 0) return;
-    const numericWidth = distance2.parse(width) ?? 0;
-    const numericHeight = distance2.parse(height) ?? 0;
-    const halfWidth = numericWidth / 2;
-    const halfHeight = numericHeight / 2;
-    boardMinX = Math.min(boardMinX, centerX - halfWidth);
-    boardMinY = Math.min(boardMinY, centerY - halfHeight);
-    boardMaxX = Math.max(boardMaxX, centerX + halfWidth);
-    boardMaxY = Math.max(boardMaxY, centerY + halfHeight);
-    hasBounds = true;
-    hasBoardBounds = true;
-  }
-  function updateBoundsToIncludeOutline(outline) {
-    let updated = false;
-    for (const point of outline) {
-      const x = distance2.parse(point.x);
-      const y = distance2.parse(point.y);
-      if (x === void 0 || y === void 0) continue;
-      minX = Math.min(minX, x);
-      minY = Math.min(minY, y);
-      maxX = Math.max(maxX, x);
-      maxY = Math.max(maxY, y);
-      updated = true;
-    }
-    if (updated) {
-      hasBounds = true;
-    }
-  }
-  function updateBoardBoundsToIncludeOutline(outline) {
-    let updated = false;
-    for (const point of outline) {
-      const x = distance2.parse(point.x);
-      const y = distance2.parse(point.y);
-      if (x === void 0 || y === void 0) continue;
-      boardMinX = Math.min(boardMinX, x);
-      boardMinY = Math.min(boardMinY, y);
-      boardMaxX = Math.max(boardMaxX, x);
-      boardMaxY = Math.max(boardMaxY, y);
-      updated = true;
-    }
-    if (updated) {
-      hasBounds = true;
-      hasBoardBounds = true;
-    }
-  }
-  function updateTraceBounds(route) {
-    let updated = false;
-    for (const point of route) {
-      const x = distance2.parse(point?.x);
-      const y = distance2.parse(point?.y);
-      if (x === void 0 || y === void 0) continue;
-      minX = Math.min(minX, x);
-      minY = Math.min(minY, y);
-      maxX = Math.max(maxX, x);
-      maxY = Math.max(maxY, y);
-      updated = true;
-    }
-    if (updated) {
-      hasBounds = true;
-    }
-  }
-  function updateSilkscreenBounds(item) {
-    if (item.type === "pcb_silkscreen_text") {
-      updateBounds(item.anchor_position, 0, 0);
-    } else if (item.type === "pcb_silkscreen_path") {
-      updateTraceBounds(item.route);
-    } else if (item.type === "pcb_silkscreen_rect") {
-      updateBounds(item.center, item.width, item.height);
-    } else if (item.type === "pcb_silkscreen_circle") {
-      const radius = distance2.parse(item.radius);
-      if (radius !== void 0) {
-        updateBounds(item.center, radius * 2, radius * 2);
-      }
-    } else if (item.type === "pcb_silkscreen_line") {
-      updateBounds({ x: item.x1, y: item.y1 }, 0, 0);
-      updateBounds({ x: item.x2, y: item.y2 }, 0, 0);
-    } else if (item.type === "pcb_silkscreen_oval") {
-      const radiusX = distance2.parse(item.radius_x);
-      const radiusY = distance2.parse(item.radius_y);
-      if (radiusX !== void 0 && radiusY !== void 0) {
-        updateBounds(item.center, radiusX * 2, radiusY * 2);
-      }
-    } else if (item.type === "pcb_cutout") {
-      const cutout = item;
-      if (cutout.shape === "rect") {
-        updateBounds(cutout.center, cutout.width, cutout.height);
-      } else if (cutout.shape === "circle") {
-        const radius = distance2.parse(cutout.radius);
-        if (radius !== void 0) {
-          updateBounds(cutout.center, radius * 2, radius * 2);
-        }
-      } else if (cutout.shape === "polygon") {
-        updateTraceBounds(cutout.points);
-      } else if (cutout.shape === "path") {
-        const cutoutPath = cutout;
-        if (cutoutPath.route && Array.isArray(cutoutPath.route)) {
-          updateTraceBounds(cutoutPath.route);
-        }
-      }
-    }
-  }
 }
 function createSvgObjects({
   elm,
@@ -13278,7 +13460,7 @@ function formatNumber2(value) {
 }
 
 // lib/pcb/convert-circuit-json-to-solder-paste-mask.ts
-import { distance as distance3 } from "circuit-json";
+import { distance as distance4 } from "circuit-json";
 import { stringify as stringify7 } from "svgson";
 import {
   applyToPoint as applyToPoint76,
@@ -13396,8 +13578,8 @@ function convertCircuitJsonToSolderPasteMask(circuitJson, options) {
       }
     } else if (item.type === "pcb_panel") {
       const panel = item;
-      const width = distance3.parse(panel.width);
-      const height = distance3.parse(panel.height);
+      const width = distance4.parse(panel.width);
+      const height = distance4.parse(panel.height);
       if (width !== void 0 && height !== void 0) {
         const center = panel.center ?? { x: width / 2, y: height / 2 };
         updateBounds(center, width, height);