circuit-to-svg 0.0.196 → 0.0.198

package/dist/index.js

@@ -1743,7 +1743,7 @@ function getSoftwareUsedString(circuitJson) {
 var package_default = {
   name: "circuit-to-svg",
   type: "module",
-  version: "0.0.195",
+  version: "0.0.197",
   description: "Convert Circuit JSON to SVG",
   main: "dist/index.js",
   files: [
@@ -1767,7 +1767,7 @@ var package_default = {
     "bun-match-svg": "^0.0.12",
     esbuild: "^0.20.2",
     "performance-now": "^2.1.0",
-    "circuit-json": "^0.0.260",
+    "circuit-json": "^0.0.261",
     react: "19.1.0",
     "react-cosmos": "7.0.0",
     "react-cosmos-plugin-vite": "7.0.0",
@@ -1783,6 +1783,7 @@ var package_default = {
   dependencies: {
     "@types/node": "^22.5.5",
     "bun-types": "^1.1.40",
+    "calculate-elbow": "0.0.12",
     svgson: "^5.3.1",
     "transformation-matrix": "^2.16.1"
   }
@@ -3070,6 +3071,1012 @@ function createSvgObjectFromAssemblyBoundary(transform, minX, minY, maxX, maxY)
   };
 }
 
+// lib/pinout/convert-circuit-json-to-pinout-svg.ts
+import { stringify as stringify3 } from "svgson";
+import { su as su6 } from "@tscircuit/circuit-json-util";
+import {
+  applyToPoint as applyToPoint34,
+  compose as compose7,
+  scale as scale4,
+  translate as translate7
+} from "transformation-matrix";
+
+// lib/pinout/svg-object-fns/create-svg-objects-from-pinout-board.ts
+import { applyToPoint as applyToPoint28 } from "transformation-matrix";
+import { su as su4 } from "@tscircuit/circuit-json-util";
+var BOARD_FILL_COLOR = "rgb(26, 115, 143)";
+var BOARD_STROKE_COLOR = "rgba(0,0,0,0.9)";
+function createSvgObjectsFromPinoutBoard(pcbBoard, ctx) {
+  const { transform, soup } = ctx;
+  const { width, height, center, outline } = pcbBoard;
+  let path;
+  if (outline && Array.isArray(outline) && outline.length >= 3) {
+    path = outline.map((point, index) => {
+      const [x, y] = applyToPoint28(transform, [point.x, point.y]);
+      return index === 0 ? `M ${x} ${y}` : `L ${x} ${y}`;
+    }).join(" ");
+  } else {
+    const halfWidth = width / 2;
+    const halfHeight = height / 2;
+    const topLeft = applyToPoint28(transform, [
+      center.x - halfWidth,
+      center.y - halfHeight
+    ]);
+    const topRight = applyToPoint28(transform, [
+      center.x + halfWidth,
+      center.y - halfHeight
+    ]);
+    const bottomRight = applyToPoint28(transform, [
+      center.x + halfWidth,
+      center.y + halfHeight
+    ]);
+    const bottomLeft = applyToPoint28(transform, [
+      center.x - halfWidth,
+      center.y + halfHeight
+    ]);
+    path = `M ${topLeft[0]} ${topLeft[1]} L ${topRight[0]} ${topRight[1]} L ${bottomRight[0]} ${bottomRight[1]} L ${bottomLeft[0]} ${bottomLeft[1]}`;
+  }
+  path += " Z";
+  const cutlery = su4(soup).pcb_cutout.list();
+  for (const cutout of cutlery) {
+    if (cutout.shape === "rect") {
+      const { x, y, width: width2, height: height2 } = cutout.center ? (() => {
+        const { x: x2, y: y2 } = cutout.center;
+        const { width: width3, height: height3 } = cutout;
+        return { x: x2, y: y2, width: width3, height: height3 };
+      })() : { x: 0, y: 0, width: 0, height: 0 };
+      const halfWidth = width2 / 2;
+      const halfHeight = height2 / 2;
+      const [tl, tr, br, bl] = [
+        applyToPoint28(transform, [x - halfWidth, y - halfHeight]),
+        applyToPoint28(transform, [x + halfWidth, y - halfHeight]),
+        applyToPoint28(transform, [x + halfWidth, y + halfHeight]),
+        applyToPoint28(transform, [x - halfWidth, y + halfHeight])
+      ];
+      path += ` M ${tl[0]} ${tl[1]} L ${tr[0]} ${tr[1]} L ${br[0]} ${br[1]} L ${bl[0]} ${bl[1]} Z`;
+    } else if (cutout.shape === "circle") {
+    }
+  }
+  return [
+    {
+      name: "path",
+      type: "element",
+      value: "",
+      children: [],
+      attributes: {
+        class: "pinout-board",
+        d: path,
+        fill: BOARD_FILL_COLOR,
+        stroke: BOARD_STROKE_COLOR,
+        "fill-rule": "evenodd",
+        "stroke-opacity": "0.8",
+        "stroke-width": (0.2 * Math.abs(transform.a)).toString()
+      }
+    }
+  ];
+}
+
+// lib/pinout/svg-object-fns/create-svg-objects-from-pinout-component.ts
+import { su as su5 } from "@tscircuit/circuit-json-util";
+import { applyToPoint as applyToPoint29 } from "transformation-matrix";
+var COMPONENT_FILL_COLOR = "rgba(120, 120, 120, 0.6)";
+var COMPONENT_LABEL_COLOR = "rgba(255, 255, 255, 0.9)";
+function createSvgObjectsFromPinoutComponent(elm, ctx) {
+  const { transform, soup } = ctx;
+  const { center, width, height, rotation = 0, source_component_id } = elm;
+  const sourceComponent = su5(soup).source_component.get(source_component_id);
+  if (!center || typeof width !== "number" || typeof height !== "number" || width === 0 || height === 0) {
+    return [];
+  }
+  const [x, y] = applyToPoint29(transform, [center.x, center.y]);
+  const scaledWidth = width * Math.abs(transform.a);
+  const scaledHeight = height * Math.abs(transform.d);
+  const transformStr = `translate(${x}, ${y}) rotate(${-rotation})`;
+  const children = [
+    {
+      name: "rect",
+      type: "element",
+      attributes: {
+        class: "pinout-component-box",
+        x: (-scaledWidth / 2).toString(),
+        y: (-scaledHeight / 2).toString(),
+        width: scaledWidth.toString(),
+        height: scaledHeight.toString(),
+        fill: COMPONENT_FILL_COLOR
+      },
+      value: "",
+      children: []
+    }
+  ];
+  if (sourceComponent?.name) {
+    const isTall = scaledHeight > scaledWidth * 1.5;
+    const labelFontSize = Math.min(scaledWidth, scaledHeight) * 0.4;
+    children.push({
+      name: "text",
+      type: "element",
+      attributes: {
+        x: "0",
+        y: "0",
+        fill: COMPONENT_LABEL_COLOR,
+        "font-size": `${labelFontSize}px`,
+        "font-family": "sans-serif",
+        "text-anchor": "middle",
+        "dominant-baseline": "middle",
+        transform: isTall ? "rotate(90)" : ""
+      },
+      children: [
+        {
+          type: "text",
+          value: sourceComponent.name,
+          name: "",
+          attributes: {},
+          children: []
+        }
+      ],
+      value: ""
+    });
+  }
+  return [
+    {
+      name: "g",
+      type: "element",
+      attributes: {
+        transform: transformStr
+      },
+      children,
+      value: ""
+    }
+  ];
+}
+
+// lib/pinout/svg-object-fns/create-svg-objects-from-pinout-hole.ts
+import { applyToPoint as applyToPoint30 } from "transformation-matrix";
+var HOLE_COLOR4 = "rgb(50, 50, 50)";
+function createSvgObjectsFromPinoutHole(hole, ctx) {
+  const { transform } = ctx;
+  const [x, y] = applyToPoint30(transform, [hole.x, hole.y]);
+  if (hole.hole_shape === "circle" || hole.hole_shape === "square") {
+    const scaledDiameter = hole.hole_diameter * Math.abs(transform.a);
+    const radius = scaledDiameter / 2;
+    if (hole.hole_shape === "circle") {
+      return [
+        {
+          name: "circle",
+          type: "element",
+          attributes: {
+            class: "pinout-hole",
+            cx: x.toString(),
+            cy: y.toString(),
+            r: radius.toString(),
+            fill: HOLE_COLOR4
+          },
+          children: [],
+          value: ""
+        }
+      ];
+    }
+    return [
+      {
+        name: "rect",
+        type: "element",
+        attributes: {
+          class: "pinout-hole",
+          x: (x - radius).toString(),
+          y: (y - radius).toString(),
+          width: scaledDiameter.toString(),
+          height: scaledDiameter.toString(),
+          fill: HOLE_COLOR4
+        },
+        children: [],
+        value: ""
+      }
+    ];
+  }
+  if (hole.hole_shape === "oval") {
+    const scaledWidth = hole.hole_width * Math.abs(transform.a);
+    const scaledHeight = hole.hole_height * Math.abs(transform.a);
+    const rx = scaledWidth / 2;
+    const ry = scaledHeight / 2;
+    return [
+      {
+        name: "ellipse",
+        type: "element",
+        attributes: {
+          class: "pinout-hole",
+          cx: x.toString(),
+          cy: y.toString(),
+          rx: rx.toString(),
+          ry: ry.toString(),
+          fill: HOLE_COLOR4
+        },
+        children: [],
+        value: ""
+      }
+    ];
+  }
+  return [];
+}
+
+// lib/pinout/svg-object-fns/create-svg-objects-from-pinout-plated-hole.ts
+import { applyToPoint as applyToPoint31 } from "transformation-matrix";
+var PAD_COLOR3 = "rgb(218, 165, 32)";
+var HOLE_COLOR5 = "rgb(40, 40, 40)";
+function createSvgObjectsFromPinoutPlatedHole(hole, ctx) {
+  const { transform } = ctx;
+  const [x, y] = applyToPoint31(transform, [hole.x, hole.y]);
+  if (hole.shape === "pill") {
+    const scaledOuterWidth = hole.outer_width * Math.abs(transform.a);
+    const scaledOuterHeight = hole.outer_height * Math.abs(transform.a);
+    const scaledHoleWidth = hole.hole_width * Math.abs(transform.a);
+    const scaledHoleHeight = hole.hole_height * Math.abs(transform.a);
+    const outerRadiusX = scaledOuterWidth / 2;
+    const straightLength = scaledOuterHeight - scaledOuterWidth;
+    const innerRadiusX = scaledHoleWidth / 2;
+    return [
+      {
+        name: "g",
+        type: "element",
+        children: [
+          // Outer pill shape
+          {
+            name: "path",
+            type: "element",
+            attributes: {
+              class: "pinout-hole-outer",
+              fill: PAD_COLOR3,
+              d: `M${x - outerRadiusX},${y - straightLength / 2} v${straightLength} a${outerRadiusX},${outerRadiusX} 0 0 0 ${scaledOuterWidth},0 v-${straightLength} a${outerRadiusX},${outerRadiusX} 0 0 0 -${scaledOuterWidth},0 z`
+            },
+            value: "",
+            children: []
+          },
+          // Inner pill shape
+          {
+            name: "path",
+            type: "element",
+            attributes: {
+              class: "pinout-hole-inner",
+              fill: HOLE_COLOR5,
+              d: `M${x - innerRadiusX},${y - (scaledHoleHeight - scaledHoleWidth) / 2} v${scaledHoleHeight - scaledHoleWidth} a${innerRadiusX},${innerRadiusX} 0 0 0 ${scaledHoleWidth},0 v-${scaledHoleHeight - scaledHoleWidth} a${innerRadiusX},${innerRadiusX} 0 0 0 -${scaledHoleWidth},0 z`
+            },
+            value: "",
+            children: []
+          }
+        ],
+        value: "",
+        attributes: {}
+      }
+    ];
+  }
+  if (hole.shape === "circle") {
+    const scaledOuterWidth = hole.outer_diameter * Math.abs(transform.a);
+    const scaledOuterHeight = hole.outer_diameter * Math.abs(transform.a);
+    const scaledHoleWidth = hole.hole_diameter * Math.abs(transform.a);
+    const scaledHoleHeight = hole.hole_diameter * Math.abs(transform.a);
+    const outerRadius = Math.min(scaledOuterWidth, scaledOuterHeight) / 2;
+    const innerRadius = Math.min(scaledHoleWidth, scaledHoleHeight) / 2;
+    return [
+      {
+        name: "g",
+        type: "element",
+        children: [
+          {
+            name: "circle",
+            type: "element",
+            attributes: {
+              class: "pinout-hole-outer",
+              fill: PAD_COLOR3,
+              cx: x.toString(),
+              cy: y.toString(),
+              r: outerRadius.toString()
+            },
+            value: "",
+            children: []
+          },
+          {
+            name: "circle",
+            type: "element",
+            attributes: {
+              class: "pinout-hole-inner",
+              fill: HOLE_COLOR5,
+              cx: x.toString(),
+              cy: y.toString(),
+              r: innerRadius.toString()
+            },
+            value: "",
+            children: []
+          }
+        ],
+        value: "",
+        attributes: {}
+      }
+    ];
+  }
+  if (hole.shape === "circular_hole_with_rect_pad") {
+    const scaledHoleDiameter = hole.hole_diameter * Math.abs(transform.a);
+    const scaledRectPadWidth = hole.rect_pad_width * Math.abs(transform.a);
+    const scaledRectPadHeight = hole.rect_pad_height * Math.abs(transform.a);
+    const holeRadius = scaledHoleDiameter / 2;
+    return [
+      {
+        name: "g",
+        type: "element",
+        children: [
+          // Rectangular pad (outer shape)
+          {
+            name: "rect",
+            type: "element",
+            attributes: {
+              class: "pinout-hole-outer-pad",
+              fill: PAD_COLOR3,
+              x: (x - scaledRectPadWidth / 2).toString(),
+              y: (y - scaledRectPadHeight / 2).toString(),
+              width: scaledRectPadWidth.toString(),
+              height: scaledRectPadHeight.toString()
+            },
+            value: "",
+            children: []
+          },
+          // Circular hole inside the rectangle
+          {
+            name: "circle",
+            type: "element",
+            attributes: {
+              class: "pinout-hole-inner",
+              fill: HOLE_COLOR5,
+              cx: x.toString(),
+              cy: y.toString(),
+              r: holeRadius.toString()
+            },
+            value: "",
+            children: []
+          }
+        ],
+        value: "",
+        attributes: {}
+      }
+    ];
+  }
+  if (hole.shape === "pill_hole_with_rect_pad") {
+    const scaledRectPadWidth = hole.rect_pad_width * Math.abs(transform.a);
+    const scaledRectPadHeight = hole.rect_pad_height * Math.abs(transform.a);
+    const scaledHoleHeight = hole.hole_height * Math.abs(transform.a);
+    const scaledHoleWidth = hole.hole_width * Math.abs(transform.a);
+    const holeRadius = Math.min(scaledHoleHeight, scaledHoleWidth) / 2;
+    return [
+      {
+        name: "g",
+        type: "element",
+        children: [
+          // Rectangular pad (outer shape)
+          {
+            name: "rect",
+            type: "element",
+            attributes: {
+              class: "pinout-hole-outer-pad",
+              fill: PAD_COLOR3,
+              x: (x - scaledRectPadWidth / 2).toString(),
+              y: (y - scaledRectPadHeight / 2).toString(),
+              width: scaledRectPadWidth.toString(),
+              height: scaledRectPadHeight.toString()
+            },
+            value: "",
+            children: []
+          },
+          // pill hole inside the rectangle
+          {
+            name: "rect",
+            type: "element",
+            attributes: {
+              class: "pinout-hole-inner",
+              fill: HOLE_COLOR5,
+              x: (x - scaledHoleWidth / 2).toString(),
+              y: (y - scaledHoleHeight / 2).toString(),
+              width: scaledHoleWidth.toString(),
+              height: scaledHoleHeight.toString(),
+              rx: holeRadius.toString(),
+              ry: holeRadius.toString()
+            },
+            value: "",
+            children: []
+          }
+        ],
+        value: "",
+        attributes: {}
+      }
+    ];
+  }
+  if (hole.shape === "rotated_pill_hole_with_rect_pad") {
+    const scaledRectPadWidth = hole.rect_pad_width * Math.abs(transform.a);
+    const scaledRectPadHeight = hole.rect_pad_height * Math.abs(transform.a);
+    const scaledHoleHeight = hole.hole_height * Math.abs(transform.a);
+    const scaledHoleWidth = hole.hole_width * Math.abs(transform.a);
+    const holeRadius = Math.min(scaledHoleHeight, scaledHoleWidth) / 2;
+    return [
+      {
+        name: "g",
+        type: "element",
+        children: [
+          {
+            name: "rect",
+            type: "element",
+            attributes: {
+              class: "pinout-hole-outer-pad",
+              fill: PAD_COLOR3,
+              x: (-scaledRectPadWidth / 2).toString(),
+              y: (-scaledRectPadHeight / 2).toString(),
+              width: scaledRectPadWidth.toString(),
+              height: scaledRectPadHeight.toString(),
+              transform: `translate(${x} ${y}) rotate(${-hole.rect_ccw_rotation})`
+            },
+            value: "",
+            children: []
+          },
+          {
+            name: "rect",
+            type: "element",
+            attributes: {
+              class: "pinout-hole-inner",
+              fill: HOLE_COLOR5,
+              x: (-scaledHoleWidth / 2).toString(),
+              y: (-scaledHoleHeight / 2).toString(),
+              width: scaledHoleWidth.toString(),
+              height: scaledHoleHeight.toString(),
+              rx: holeRadius.toString(),
+              ry: holeRadius.toString(),
+              transform: `translate(${x} ${y}) rotate(${-hole.hole_ccw_rotation})`
+            },
+            value: "",
+            children: []
+          }
+        ],
+        value: "",
+        attributes: {}
+      }
+    ];
+  }
+  return [];
+}
+
+// lib/pinout/svg-object-fns/create-svg-objects-from-pinout-smt-pad.ts
+import { applyToPoint as applyToPoint32 } from "transformation-matrix";
+var PAD_COLOR4 = "rgb(218, 165, 32)";
+function createSvgObjectsFromPinoutSmtPad(pad, ctx) {
+  const { transform } = ctx;
+  if (pad.shape === "rect" || pad.shape === "rotated_rect") {
+    const width = pad.width * Math.abs(transform.a);
+    const height = pad.height * Math.abs(transform.d);
+    const [x, y] = applyToPoint32(transform, [pad.x, pad.y]);
+    if (pad.shape === "rotated_rect" && pad.ccw_rotation) {
+      return [
+        {
+          name: "rect",
+          type: "element",
+          attributes: {
+            class: "pinout-pad",
+            fill: PAD_COLOR4,
+            x: (-width / 2).toString(),
+            y: (-height / 2).toString(),
+            width: width.toString(),
+            height: height.toString(),
+            transform: `translate(${x} ${y}) rotate(${-pad.ccw_rotation})`,
+            "data-layer": pad.layer
+          },
+          value: "",
+          children: []
+        }
+      ];
+    }
+    return [
+      {
+        name: "rect",
+        type: "element",
+        attributes: {
+          class: "pinout-pad",
+          fill: PAD_COLOR4,
+          x: (x - width / 2).toString(),
+          y: (y - height / 2).toString(),
+          width: width.toString(),
+          height: height.toString(),
+          "data-layer": pad.layer
+        },
+        value: "",
+        children: []
+      }
+    ];
+  }
+  if (pad.shape === "pill") {
+    const width = pad.width * Math.abs(transform.a);
+    const height = pad.height * Math.abs(transform.d);
+    const radius = pad.radius * Math.abs(transform.a);
+    const [x, y] = applyToPoint32(transform, [pad.x, pad.y]);
+    return [
+      {
+        name: "rect",
+        type: "element",
+        attributes: {
+          class: "pinout-pad",
+          fill: PAD_COLOR4,
+          x: (x - width / 2).toString(),
+          y: (y - height / 2).toString(),
+          width: width.toString(),
+          height: height.toString(),
+          rx: radius.toString(),
+          ry: radius.toString(),
+          "data-layer": pad.layer
+        },
+        value: "",
+        children: []
+      }
+    ];
+  }
+  if (pad.shape === "circle") {
+    const radius = pad.radius * Math.abs(transform.a);
+    const [x, y] = applyToPoint32(transform, [pad.x, pad.y]);
+    return [
+      {
+        name: "circle",
+        type: "element",
+        attributes: {
+          class: "pinout-pad",
+          fill: PAD_COLOR4,
+          cx: x.toString(),
+          cy: y.toString(),
+          r: radius.toString(),
+          "data-layer": pad.layer
+        },
+        value: "",
+        children: []
+      }
+    ];
+  }
+  if (pad.shape === "polygon") {
+    const points = (pad.points ?? []).map(
+      (point) => applyToPoint32(transform, [point.x, point.y])
+    );
+    return [
+      {
+        name: "polygon",
+        type: "element",
+        attributes: {
+          class: "pinout-pad",
+          fill: PAD_COLOR4,
+          points: points.map((p) => p.join(",")).join(" "),
+          "data-layer": pad.layer
+        },
+        value: "",
+        children: []
+      }
+    ];
+  }
+  return [];
+}
+
+// lib/pinout/svg-object-fns/create-svg-objects-from-pinout-port.ts
+import { applyToPoint as applyToPoint33 } from "transformation-matrix";
+import { calculateElbow } from "calculate-elbow";
+var LABEL_COLOR = "rgb(255, 255, 255)";
+var LABEL_BACKGROUND = "rgb(0, 0, 0)";
+var LINE_COLOR = "rgba(0, 0, 0, 0.6)";
+function createSvgObjectsFromPinoutPort(pcb_port, ctx) {
+  const label_info = ctx.label_positions.get(pcb_port.pcb_port_id);
+  if (!label_info) return [];
+  const { text: label, aliases, elbow_end, label_pos, edge } = label_info;
+  const [port_x, port_y] = applyToPoint33(ctx.transform, [pcb_port.x, pcb_port.y]);
+  const start_facing_direction = edge === "left" ? "x-" : edge === "right" ? "x+" : edge === "top" ? "y-" : "y+";
+  const end_facing_direction = edge === "left" ? "x+" : edge === "right" ? "x-" : edge === "top" ? "y+" : "y-";
+  const elbow_path = calculateElbow(
+    {
+      x: port_x,
+      y: port_y,
+      facingDirection: start_facing_direction
+    },
+    {
+      x: elbow_end.x,
+      y: elbow_end.y,
+      facingDirection: end_facing_direction
+    },
+    {}
+  );
+  const line_points = [...elbow_path, label_pos].map((p) => `${p.x},${p.y}`).join(" ");
+  const full_label = [label, ...aliases].join(" | ");
+  const fontSize = 11;
+  const textWidth = full_label.length * fontSize * 0.6;
+  const bgPadding = 5;
+  const rectHeight = fontSize + 2 * bgPadding;
+  const rectWidth = textWidth + 2 * bgPadding;
+  const text_y = label_pos.y;
+  let rectX;
+  let text_x;
+  if (edge === "left") {
+    rectX = label_pos.x - rectWidth;
+    text_x = label_pos.x - rectWidth / 2;
+  } else if (edge === "right") {
+    rectX = label_pos.x;
+    text_x = label_pos.x + rectWidth / 2;
+  } else {
+    rectX = label_pos.x - rectWidth / 2;
+    text_x = label_pos.x;
+  }
+  return [
+    {
+      name: "polyline",
+      type: "element",
+      attributes: {
+        points: line_points,
+        stroke: LINE_COLOR,
+        "stroke-width": "1.5",
+        fill: "none"
+      },
+      children: [],
+      value: ""
+    },
+    {
+      name: "rect",
+      type: "element",
+      attributes: {
+        x: rectX.toString(),
+        y: (text_y - rectHeight / 2).toString(),
+        width: rectWidth.toString(),
+        height: rectHeight.toString(),
+        fill: LABEL_BACKGROUND,
+        rx: "8",
+        // More rounded corners
+        ry: "8",
+        stroke: "none"
+      },
+      children: [],
+      value: ""
+    },
+    {
+      name: "text",
+      type: "element",
+      attributes: {
+        x: text_x.toString(),
+        y: text_y.toString(),
+        fill: LABEL_COLOR,
+        "font-size": `${fontSize}px`,
+        "font-family": "Arial, sans-serif",
+        "font-weight": "bold",
+        "text-anchor": "middle",
+        "dominant-baseline": "middle"
+      },
+      children: [
+        {
+          type: "text",
+          value: full_label,
+          name: "",
+          attributes: {},
+          children: []
+        }
+      ],
+      value: ""
+    }
+  ];
+}
+
+// lib/pinout/convert-circuit-json-to-pinout-svg.ts
+var OBJECT_ORDER3 = [
+  "pcb_board",
+  "pcb_smtpad",
+  "pcb_hole",
+  "pcb_plated_hole",
+  "pcb_component",
+  "pcb_port"
+];
+function getPortLabelInfo(port, soup) {
+  const source_port = su6(soup).source_port.get(port.source_port_id);
+  if (!source_port) return null;
+  const eligible_hints = source_port.port_hints?.filter(
+    (h) => !/^\d+$/.test(h) && !["left", "right", "top", "bottom"].includes(h)
+  ) ?? [];
+  let label = eligible_hints[0];
+  if (!label) label = source_port.name;
+  if (!label) return null;
+  const aliases = eligible_hints.filter((h) => h !== label);
+  return { text: label, aliases };
+}
+function getClosestEdge(port_pos_real, board_bounds) {
+  const dists = {
+    left: port_pos_real.x - board_bounds.minX,
+    right: board_bounds.maxX - port_pos_real.x,
+    top: board_bounds.maxY - port_pos_real.y,
+    bottom: port_pos_real.y - board_bounds.minY
+  };
+  let closest_edge = "left";
+  let min_dist = dists.left;
+  if (dists.right < min_dist) {
+    min_dist = dists.right;
+    closest_edge = "right";
+  }
+  if (dists.top < min_dist) {
+    min_dist = dists.top;
+    closest_edge = "top";
+  }
+  if (dists.bottom < min_dist) {
+    min_dist = dists.bottom;
+    closest_edge = "bottom";
+  }
+  return closest_edge;
+}
+function convertCircuitJsonToPinoutSvg(soup, options) {
+  let minX = Number.POSITIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let maxX = Number.NEGATIVE_INFINITY;
+  let maxY = Number.NEGATIVE_INFINITY;
+  for (const item of soup) {
+    if (item.type === "pcb_board") {
+      if ("outline" in item && item.outline && Array.isArray(item.outline) && item.outline.length > 0) {
+        for (const point of item.outline) {
+          minX = Math.min(minX, point.x);
+          minY = Math.min(minY, point.y);
+          maxX = Math.max(maxX, point.x);
+          maxY = Math.max(maxY, point.y);
+        }
+      } else {
+        const center = item.center;
+        const width = item.width || 0;
+        const height = item.height || 0;
+        minX = Math.min(minX, center.x - width / 2);
+        minY = Math.min(minY, center.y - height / 2);
+        maxX = Math.max(maxX, center.x + width / 2);
+        maxY = Math.max(maxY, center.y + height / 2);
+      }
+    }
+  }
+  const padding = 20;
+  const circuitWidth = maxX - minX + 2 * padding;
+  const circuitHeight = maxY - minY + 2 * padding;
+  const svgWidth = options?.width ?? 800;
+  const svgHeight = options?.height ?? 600;
+  const scaleX = svgWidth / circuitWidth;
+  const scaleY = svgHeight / circuitHeight;
+  const scaleFactor = Math.min(scaleX, scaleY);
+  const offsetX = (svgWidth - circuitWidth * scaleFactor) / 2;
+  const offsetY = (svgHeight - circuitHeight * scaleFactor) / 2;
+  const transform = compose7(
+    translate7(
+      offsetX - minX * scaleFactor + padding * scaleFactor,
+      svgHeight - offsetY + minY * scaleFactor - padding * scaleFactor
+    ),
+    scale4(scaleFactor, -scaleFactor)
+  );
+  const board_bounds = { minX, minY, maxX, maxY };
+  const pinout_ports = soup.filter(
+    (elm) => elm.type === "pcb_port" && elm.is_board_pinout
+  );
+  const ports_by_edge = {
+    left: [],
+    right: [],
+    top: [],
+    bottom: []
+  };
+  for (const port of pinout_ports) {
+    const edge = getClosestEdge({ x: port.x, y: port.y }, board_bounds);
+    ports_by_edge[edge].push(port);
+  }
+  const label_positions = /* @__PURE__ */ new Map();
+  const V_SPACING = 20;
+  const STAGGER_OFFSET_MIN = 20;
+  const STAGGER_OFFSET_PER_PIN = 2;
+  const STAGGER_OFFSET_STEP = 15;
+  const ALIGNED_OFFSET_MARGIN = 10;
+  const FONT_SIZE = 11;
+  const BG_PADDING = 5;
+  const LABEL_RECT_HEIGHT = FONT_SIZE + 2 * BG_PADDING;
+  const LABEL_MARGIN = 5;
+  const left_ports = ports_by_edge.left.map((port) => ({
+    port,
+    y: applyToPoint34(transform, [port.x, port.y])[1],
+    label_info: getPortLabelInfo(port, soup)
+  })).filter((p) => p.label_info).sort((a, b) => a.y - b.y);
+  if (left_ports.length > 0) {
+    const board_left_x = applyToPoint34(transform, [board_bounds.minX, 0])[0];
+    const num_labels = left_ports.length;
+    const middle_index = (num_labels - 1) / 2;
+    const stagger_offset_base = STAGGER_OFFSET_MIN + num_labels * STAGGER_OFFSET_PER_PIN;
+    const max_stagger_offset = stagger_offset_base + middle_index * STAGGER_OFFSET_STEP;
+    const aligned_label_offset = max_stagger_offset + ALIGNED_OFFSET_MARGIN;
+    const total_labels_height = num_labels * LABEL_RECT_HEIGHT + Math.max(0, num_labels - 1) * LABEL_MARGIN;
+    let current_y = (svgHeight - total_labels_height) / 2 + LABEL_RECT_HEIGHT / 2;
+    left_ports.forEach(({ port, label_info }, i) => {
+      const dist_from_middle = Math.abs(i - middle_index);
+      const stagger_rank = middle_index - dist_from_middle;
+      const stagger_offset = stagger_offset_base + stagger_rank * STAGGER_OFFSET_STEP;
+      const elbow_end = { x: board_left_x - stagger_offset, y: current_y };
+      const label_pos = { x: board_left_x - aligned_label_offset, y: current_y };
+      label_positions.set(port.pcb_port_id, {
+        text: label_info.text,
+        aliases: label_info.aliases,
+        elbow_end,
+        label_pos,
+        edge: "left"
+      });
+      current_y += LABEL_RECT_HEIGHT + LABEL_MARGIN;
+    });
+  }
+  const right_ports = ports_by_edge.right.map((port) => ({
+    port,
+    y: applyToPoint34(transform, [port.x, port.y])[1],
+    label_info: getPortLabelInfo(port, soup)
+  })).filter((p) => p.label_info).sort((a, b) => a.y - b.y);
+  if (right_ports.length > 0) {
+    const board_right_x = applyToPoint34(transform, [board_bounds.maxX, 0])[0];
+    const num_labels = right_ports.length;
+    const middle_index = (num_labels - 1) / 2;
+    const stagger_offset_base = STAGGER_OFFSET_MIN + num_labels * STAGGER_OFFSET_PER_PIN;
+    const max_stagger_offset = stagger_offset_base + middle_index * STAGGER_OFFSET_STEP;
+    const aligned_label_offset = max_stagger_offset + ALIGNED_OFFSET_MARGIN;
+    const total_labels_height = num_labels * LABEL_RECT_HEIGHT + Math.max(0, num_labels - 1) * LABEL_MARGIN;
+    let current_y = (svgHeight - total_labels_height) / 2 + LABEL_RECT_HEIGHT / 2;
+    right_ports.forEach(({ port, label_info }, i) => {
+      const dist_from_middle = Math.abs(i - middle_index);
+      const stagger_rank = middle_index - dist_from_middle;
+      const stagger_offset = stagger_offset_base + stagger_rank * STAGGER_OFFSET_STEP;
+      const elbow_end = { x: board_right_x + stagger_offset, y: current_y };
+      const label_pos = {
+        x: board_right_x + aligned_label_offset,
+        y: current_y
+      };
+      label_positions.set(port.pcb_port_id, {
+        text: label_info.text,
+        aliases: label_info.aliases,
+        elbow_end,
+        label_pos,
+        edge: "right"
+      });
+      current_y += LABEL_RECT_HEIGHT + LABEL_MARGIN;
+    });
+  }
+  const top_ports = ports_by_edge.top.map((port) => ({
+    port,
+    x: applyToPoint34(transform, [port.x, port.y])[0],
+    label_info: getPortLabelInfo(port, soup)
+  })).filter((p) => p.label_info).sort((a, b) => a.x - b.x);
+  if (top_ports.length > 0) {
+    const board_top_y = applyToPoint34(transform, [0, board_bounds.maxY])[1];
+    const labels_with_widths = top_ports.map((p) => {
+      const label = [p.label_info.text, ...p.label_info.aliases].join(" | ");
+      const textWidth = label.length * FONT_SIZE * 0.6;
+      const rectWidth = textWidth + 2 * BG_PADDING;
+      return { ...p, rectWidth };
+    });
+    const num_labels = labels_with_widths.length;
+    const middle_index = (num_labels - 1) / 2;
+    const stagger_offset_base = STAGGER_OFFSET_MIN + num_labels * STAGGER_OFFSET_PER_PIN;
+    const max_stagger_offset = stagger_offset_base + middle_index * STAGGER_OFFSET_STEP;
+    const aligned_label_offset = max_stagger_offset + ALIGNED_OFFSET_MARGIN;
+    const total_labels_width = labels_with_widths.reduce((sum, l) => sum + l.rectWidth, 0) + Math.max(0, num_labels - 1) * LABEL_MARGIN;
+    let current_x = (svgWidth - total_labels_width) / 2;
+    labels_with_widths.forEach(({ port, label_info, rectWidth }, i) => {
+      const dist_from_middle = Math.abs(i - middle_index);
+      const stagger_rank = middle_index - dist_from_middle;
+      const stagger_offset = stagger_offset_base + stagger_rank * STAGGER_OFFSET_STEP;
+      const label_center_x = current_x + rectWidth / 2;
+      const elbow_end = { x: label_center_x, y: board_top_y - stagger_offset };
+      const label_pos = {
+        x: label_center_x,
+        y: board_top_y - aligned_label_offset
+      };
+      label_positions.set(port.pcb_port_id, {
+        text: label_info.text,
+        aliases: label_info.aliases,
+        elbow_end,
+        label_pos,
+        edge: "top"
+      });
+      current_x += rectWidth + LABEL_MARGIN;
+    });
+  }
+  const bottom_ports = ports_by_edge.bottom.map((port) => ({
+    port,
+    x: applyToPoint34(transform, [port.x, port.y])[0],
+    label_info: getPortLabelInfo(port, soup)
+  })).filter((p) => p.label_info).sort((a, b) => a.x - b.x);
+  if (bottom_ports.length > 0) {
+    const board_bottom_y = applyToPoint34(transform, [0, board_bounds.minY])[1];
+    const labels_with_widths = bottom_ports.map((p) => {
+      const label = [p.label_info.text, ...p.label_info.aliases].join(" | ");
+      const textWidth = label.length * FONT_SIZE * 0.6;
+      const rectWidth = textWidth + 2 * BG_PADDING;
+      return { ...p, rectWidth };
+    });
+    const num_labels = labels_with_widths.length;
+    const middle_index = (num_labels - 1) / 2;
+    const stagger_offset_base = STAGGER_OFFSET_MIN + num_labels * STAGGER_OFFSET_PER_PIN;
+    const max_stagger_offset = stagger_offset_base + middle_index * STAGGER_OFFSET_STEP;
+    const aligned_label_offset = max_stagger_offset + ALIGNED_OFFSET_MARGIN;
+    const total_labels_width = labels_with_widths.reduce((sum, l) => sum + l.rectWidth, 0) + Math.max(0, num_labels - 1) * LABEL_MARGIN;
+    let current_x = (svgWidth - total_labels_width) / 2;
+    labels_with_widths.forEach(({ port, label_info, rectWidth }, i) => {
+      const dist_from_middle = Math.abs(i - middle_index);
+      const stagger_rank = middle_index - dist_from_middle;
+      const stagger_offset = stagger_offset_base + stagger_rank * STAGGER_OFFSET_STEP;
+      const label_center_x = current_x + rectWidth / 2;
+      const elbow_end = {
+        x: label_center_x,
+        y: board_bottom_y + stagger_offset
+      };
+      const label_pos = {
+        x: label_center_x,
+        y: board_bottom_y + aligned_label_offset
+      };
+      label_positions.set(port.pcb_port_id, {
+        text: label_info.text,
+        aliases: label_info.aliases,
+        elbow_end,
+        label_pos,
+        edge: "bottom"
+      });
+      current_x += rectWidth + LABEL_MARGIN;
+    });
+  }
+  const ctx = {
+    transform,
+    soup,
+    board_bounds,
+    label_positions
+  };
+  const svgObjects = soup.sort(
+    (a, b) => (OBJECT_ORDER3.indexOf(a.type) ?? 9999) - (OBJECT_ORDER3.indexOf(b.type) ?? 9999)
+  ).flatMap((item) => createSvgObjects3(item, ctx, soup));
+  const softwareUsedString = getSoftwareUsedString(soup);
+  const version = CIRCUIT_TO_SVG_VERSION;
+  const svgObject = {
+    name: "svg",
+    type: "element",
+    attributes: {
+      xmlns: "http://www.w3.org/2000/svg",
+      width: svgWidth.toString(),
+      height: svgHeight.toString(),
+      ...softwareUsedString && {
+        "data-software-used-string": softwareUsedString
+      },
+      ...options?.includeVersion && {
+        "data-circuit-to-svg-version": version
+      }
+    },
+    value: "",
+    children: [
+      {
+        name: "rect",
+        type: "element",
+        attributes: {
+          fill: "rgb(255, 255, 255)",
+          x: "0",
+          y: "0",
+          width: svgWidth.toString(),
+          height: svgHeight.toString()
+        },
+        value: "",
+        children: []
+      },
+      ...svgObjects
+    ].filter((child) => child !== null)
+  };
+  return stringify3(svgObject);
+}
+function createSvgObjects3(elm, ctx, soup) {
+  switch (elm.type) {
+    case "pcb_board":
+      return createSvgObjectsFromPinoutBoard(elm, ctx);
+    case "pcb_component":
+      return createSvgObjectsFromPinoutComponent(elm, ctx);
+    case "pcb_smtpad":
+      return createSvgObjectsFromPinoutSmtPad(elm, ctx);
+    case "pcb_hole":
+      return createSvgObjectsFromPinoutHole(elm, ctx);
+    case "pcb_plated_hole":
+      return createSvgObjectsFromPinoutPlatedHole(elm, ctx);
+    case "pcb_port":
+      if (elm.is_board_pinout) {
+        return createSvgObjectsFromPinoutPort(elm, ctx);
+      }
+      return [];
+    default:
+      return [];
+  }
+}
+
 // lib/utils/colors.ts
 var colorMap = {
   "3d_viewer": {
@@ -3310,21 +4317,21 @@ var colorMap = {
 };
 
 // lib/sch/convert-circuit-json-to-schematic-svg.ts
-import { stringify as stringify3 } from "svgson";
+import { stringify as stringify4 } from "svgson";
 import {
   fromTriangles,
   toSVG
 } from "transformation-matrix";
 
 // lib/sch/draw-schematic-grid.ts
-import { applyToPoint as applyToPoint28 } from "transformation-matrix";
+import { applyToPoint as applyToPoint35 } from "transformation-matrix";
 function drawSchematicGrid(params) {
   const { minX, minY, maxX, maxY } = params.bounds;
   const cellSize = params.cellSize ?? 1;
   const labelCells = params.labelCells ?? false;
   const gridLines = [];
   const transformPoint = (x, y) => {
-    const [transformedX, transformedY] = applyToPoint28(params.transform, [x, y]);
+    const [transformedX, transformedY] = applyToPoint35(params.transform, [x, y]);
     return { x: transformedX, y: transformedY };
   };
   for (let x = Math.floor(minX); x <= Math.ceil(maxX); x += cellSize) {
@@ -3405,15 +4412,15 @@ function drawSchematicGrid(params) {
 }
 
 // lib/sch/draw-schematic-labeled-points.ts
-import { applyToPoint as applyToPoint29 } from "transformation-matrix";
+import { applyToPoint as applyToPoint36 } from "transformation-matrix";
 function drawSchematicLabeledPoints(params) {
   const { points, transform } = params;
   const labeledPointsGroup = [];
   for (const point of points) {
-    const [x1, y1] = applyToPoint29(transform, [point.x - 0.1, point.y - 0.1]);
-    const [x2, y2] = applyToPoint29(transform, [point.x + 0.1, point.y + 0.1]);
-    const [x3, y3] = applyToPoint29(transform, [point.x - 0.1, point.y + 0.1]);
-    const [x4, y4] = applyToPoint29(transform, [point.x + 0.1, point.y - 0.1]);
+    const [x1, y1] = applyToPoint36(transform, [point.x - 0.1, point.y - 0.1]);
+    const [x2, y2] = applyToPoint36(transform, [point.x + 0.1, point.y + 0.1]);
+    const [x3, y3] = applyToPoint36(transform, [point.x - 0.1, point.y + 0.1]);
+    const [x4, y4] = applyToPoint36(transform, [point.x + 0.1, point.y - 0.1]);
     labeledPointsGroup.push({
       name: "path",
       type: "element",
@@ -3424,7 +4431,7 @@ function drawSchematicLabeledPoints(params) {
         "stroke-opacity": "0.7"
       }
     });
-    const [labelX, labelY] = applyToPoint29(transform, [
+    const [labelX, labelY] = applyToPoint36(transform, [
       point.x + 0.15,
       point.y - 0.15
     ]);
@@ -4514,12 +5521,12 @@ function getSchematicBoundsFromCircuitJson(soup, padding = 0.5) {
 }
 
 // lib/sch/svg-object-fns/create-svg-objects-from-sch-component-with-symbol.ts
-import { su as su4 } from "@tscircuit/circuit-json-util";
+import { su as su7 } from "@tscircuit/circuit-json-util";
 import { symbols } from "schematic-symbols";
 import "svgson";
 import {
-  applyToPoint as applyToPoint31,
-  compose as compose8
+  applyToPoint as applyToPoint38,
+  compose as compose9
 } from "transformation-matrix";
 
 // lib/utils/get-sch-stroke-size.ts
@@ -4589,26 +5596,26 @@ var matchSchPortsToSymbolPorts = ({
 };
 
 // lib/utils/point-pairs-to-matrix.ts
-import { compose as compose7, scale as scale4, translate as translate7 } from "transformation-matrix";
+import { compose as compose8, scale as scale5, translate as translate8 } from "transformation-matrix";
 function pointPairsToMatrix(a1, a2, b1, b2) {
   const tx = a2.x - a1.x;
   const ty = a2.y - a1.y;
   const originalDistance = Math.sqrt((b1.x - a1.x) ** 2 + (b1.y - a1.y) ** 2);
   const transformedDistance = Math.sqrt((b2.x - a2.x) ** 2 + (b2.y - a2.y) ** 2);
   const a = transformedDistance / originalDistance;
-  const translateMatrix = translate7(tx, ty);
-  const scaleMatrix = scale4(a, a);
-  return compose7(translateMatrix, scaleMatrix);
+  const translateMatrix = translate8(tx, ty);
+  const scaleMatrix = scale5(a, a);
+  return compose8(translateMatrix, scaleMatrix);
 }
 
 // lib/sch/svg-object-fns/create-svg-error-text.ts
-import { applyToPoint as applyToPoint30 } from "transformation-matrix";
+import { applyToPoint as applyToPoint37 } from "transformation-matrix";
 var createSvgSchErrorText = ({
   text,
   realCenter,
   realToScreenTransform
 }) => {
-  const screenCenter = applyToPoint30(realToScreenTransform, realCenter);
+  const screenCenter = applyToPoint37(realToScreenTransform, realCenter);
   return {
     type: "element",
     name: "text",
@@ -4675,10 +5682,10 @@ var createSvgObjectsFromSchematicComponentWithSymbol = ({
       })
     ];
   }
-  const schPorts = su4(circuitJson).schematic_port.list({
+  const schPorts = su7(circuitJson).schematic_port.list({
     schematic_component_id: schComponent.schematic_component_id
   });
-  const srcComponent = su4(circuitJson).source_component.get(
+  const srcComponent = su7(circuitJson).source_component.get(
     schComponent.source_component_id
   );
   const schPortsWithSymbolPorts = matchSchPortsToSymbolPorts({
@@ -4717,12 +5724,12 @@ var createSvgObjectsFromSchematicComponentWithSymbol = ({
     minY: Math.min(...paths.flatMap((p) => p.points.map((pt) => pt.y))),
     maxY: Math.max(...paths.flatMap((p) => p.points.map((pt) => pt.y)))
   };
-  const [screenMinX, screenMinY] = applyToPoint31(
-    compose8(realToScreenTransform, transformFromSymbolToReal),
+  const [screenMinX, screenMinY] = applyToPoint38(
+    compose9(realToScreenTransform, transformFromSymbolToReal),
     [bounds.minX, bounds.minY]
   );
-  const [screenMaxX, screenMaxY] = applyToPoint31(
-    compose8(realToScreenTransform, transformFromSymbolToReal),
+  const [screenMaxX, screenMaxY] = applyToPoint38(
+    compose9(realToScreenTransform, transformFromSymbolToReal),
     [bounds.maxX, bounds.maxY]
   );
   const rectHeight = Math.abs(screenMaxY - screenMinY);
@@ -4750,8 +5757,8 @@ var createSvgObjectsFromSchematicComponentWithSymbol = ({
       name: "path",
       attributes: {
         d: points.map((p, i) => {
-          const [x, y] = applyToPoint31(
-            compose8(realToScreenTransform, transformFromSymbolToReal),
+          const [x, y] = applyToPoint38(
+            compose9(realToScreenTransform, transformFromSymbolToReal),
             [p.x, p.y]
           );
           return `${i === 0 ? "M" : "L"} ${x} ${y}`;
@@ -4766,8 +5773,8 @@ var createSvgObjectsFromSchematicComponentWithSymbol = ({
     });
   }
   for (const text of texts) {
-    const screenTextPos = applyToPoint31(
-      compose8(realToScreenTransform, transformFromSymbolToReal),
+    const screenTextPos = applyToPoint38(
+      compose9(realToScreenTransform, transformFromSymbolToReal),
       text
     );
     let textValue = "";
@@ -4818,11 +5825,11 @@ var createSvgObjectsFromSchematicComponentWithSymbol = ({
     });
   }
   for (const box of boxes) {
-    const screenBoxPos = applyToPoint31(
-      compose8(realToScreenTransform, transformFromSymbolToReal),
+    const screenBoxPos = applyToPoint38(
+      compose9(realToScreenTransform, transformFromSymbolToReal),
       box
     );
-    const symbolToScreenScale = compose8(
+    const symbolToScreenScale = compose9(
       realToScreenTransform,
       transformFromSymbolToReal
     ).a;
@@ -4842,8 +5849,8 @@ var createSvgObjectsFromSchematicComponentWithSymbol = ({
   }
   for (const port of symbol.ports) {
     if (connectedSymbolPorts.has(port)) continue;
-    const screenPortPos = applyToPoint31(
-      compose8(realToScreenTransform, transformFromSymbolToReal),
+    const screenPortPos = applyToPoint38(
+      compose9(realToScreenTransform, transformFromSymbolToReal),
       port
     );
     svgObjects.push({
@@ -4862,8 +5869,8 @@ var createSvgObjectsFromSchematicComponentWithSymbol = ({
     });
   }
   for (const circle of circles) {
-    const screenCirclePos = applyToPoint31(
-      compose8(realToScreenTransform, transformFromSymbolToReal),
+    const screenCirclePos = applyToPoint38(
+      compose9(realToScreenTransform, transformFromSymbolToReal),
       circle
     );
     const screenRadius = Math.abs(circle.radius * realToScreenTransform.a);
@@ -4886,18 +5893,18 @@ var createSvgObjectsFromSchematicComponentWithSymbol = ({
 };
 
 // lib/sch/svg-object-fns/create-svg-objects-from-sch-component-with-box.ts
-import { su as su7 } from "@tscircuit/circuit-json-util";
+import { su as su10 } from "@tscircuit/circuit-json-util";
 import "schematic-symbols";
 import "svgson";
-import { applyToPoint as applyToPoint37 } from "transformation-matrix";
+import { applyToPoint as applyToPoint44 } from "transformation-matrix";
 
 // lib/sch/svg-object-fns/create-svg-objects-from-sch-port-on-box.ts
 import "transformation-matrix";
 import "@tscircuit/circuit-json-util";
 
 // lib/sch/svg-object-fns/create-svg-objects-for-sch-port-box-line.ts
-import { applyToPoint as applyToPoint32 } from "transformation-matrix";
-import { su as su5 } from "@tscircuit/circuit-json-util";
+import { applyToPoint as applyToPoint39 } from "transformation-matrix";
+import { su as su8 } from "@tscircuit/circuit-json-util";
 var PIN_CIRCLE_RADIUS_MM = 0.02;
 var createArrow = (tip, angle, size, color, strokeWidth) => {
   const arrowAngle = Math.PI / 6;
@@ -4929,7 +5936,7 @@ var createSvgObjectsForSchPortBoxLine = ({
   circuitJson
 }) => {
   const svgObjects = [];
-  const srcPort = su5(circuitJson).source_port.get(schPort.source_port_id);
+  const srcPort = su8(circuitJson).source_port.get(schPort.source_port_id);
   const realEdgePos = {
     x: schPort.center.x,
     y: schPort.center.y
@@ -4949,8 +5956,8 @@ var createSvgObjectsForSchPortBoxLine = ({
       realEdgePos.y += realPinLineLength;
       break;
   }
-  const screenSchPortPos = applyToPoint32(transform, schPort.center);
-  const screenRealEdgePos = applyToPoint32(transform, realEdgePos);
+  const screenSchPortPos = applyToPoint39(transform, schPort.center);
+  const screenRealEdgePos = applyToPoint39(transform, realEdgePos);
   const realLineEnd = { ...schPort.center };
   switch (schPort.side_of_component) {
     case "left":
@@ -4966,7 +5973,7 @@ var createSvgObjectsForSchPortBoxLine = ({
       realLineEnd.y += PIN_CIRCLE_RADIUS_MM;
       break;
   }
-  const screenLineEnd = applyToPoint32(transform, realLineEnd);
+  const screenLineEnd = applyToPoint39(transform, realLineEnd);
   svgObjects.push({
     name: "line",
     type: "element",
@@ -5088,7 +6095,7 @@ var createSvgObjectsForSchPortBoxLine = ({
 };
 
 // lib/sch/svg-object-fns/create-svg-objects-for-sch-port-pin-number-text.ts
-import { applyToPoint as applyToPoint33 } from "transformation-matrix";
+import { applyToPoint as applyToPoint40 } from "transformation-matrix";
 var createSvgObjectsForSchPortPinNumberText = (params) => {
   const svgObjects = [];
   const { schPort, schComponent, transform, circuitJson } = params;
@@ -5106,7 +6113,7 @@ var createSvgObjectsForSchPortPinNumberText = (params) => {
   } else {
     realPinNumberPos.y += 0.02;
   }
-  const screenPinNumberTextPos = applyToPoint33(transform, realPinNumberPos);
+  const screenPinNumberTextPos = applyToPoint40(transform, realPinNumberPos);
   svgObjects.push({
     name: "text",
     type: "element",
@@ -5136,7 +6143,7 @@ var createSvgObjectsForSchPortPinNumberText = (params) => {
 };
 
 // lib/sch/svg-object-fns/create-svg-objects-for-sch-port-pin-label.ts
-import { applyToPoint as applyToPoint34 } from "transformation-matrix";
+import { applyToPoint as applyToPoint41 } from "transformation-matrix";
 var LABEL_DIST_FROM_EDGE_MM = 0.1;
 var createSvgObjectsForSchPortPinLabel = (params) => {
   const svgObjects = [];
@@ -5150,7 +6157,7 @@ var createSvgObjectsForSchPortPinLabel = (params) => {
   const realPinEdgeDistance = schPort.distance_from_component_edge ?? 0.4;
   realPinNumberPos.x += vecToEdge.x * (realPinEdgeDistance + LABEL_DIST_FROM_EDGE_MM);
   realPinNumberPos.y += vecToEdge.y * (realPinEdgeDistance + LABEL_DIST_FROM_EDGE_MM);
-  const screenPinNumberTextPos = applyToPoint34(transform, realPinNumberPos);
+  const screenPinNumberTextPos = applyToPoint41(transform, realPinNumberPos);
   const label = schPort.display_pin_label ?? schComponent.port_labels?.[`${schPort.pin_number}`];
   if (!label) return [];
   const isNegated = label.startsWith("N_");
@@ -5198,13 +6205,13 @@ var createSvgObjectsFromSchPortOnBox = (params) => {
 };
 
 // lib/sch/svg-object-fns/create-svg-objects-for-sch-text.ts
-import { applyToPoint as applyToPoint36 } from "transformation-matrix";
+import { applyToPoint as applyToPoint43 } from "transformation-matrix";
 var createSvgSchText = ({
   elm,
   transform,
   colorMap: colorMap2
 }) => {
-  const center = applyToPoint36(transform, elm.position);
+  const center = applyToPoint43(transform, elm.position);
   const textAnchorMap = {
     center: "middle",
     center_right: "end",
@@ -5288,11 +6295,11 @@ var createSvgObjectsFromSchematicComponentWithBox = ({
   colorMap: colorMap2
 }) => {
   const svgObjects = [];
-  const componentScreenTopLeft = applyToPoint37(transform, {
+  const componentScreenTopLeft = applyToPoint44(transform, {
     x: schComponent.center.x - schComponent.size.width / 2,
     y: schComponent.center.y + schComponent.size.height / 2
   });
-  const componentScreenBottomRight = applyToPoint37(transform, {
+  const componentScreenBottomRight = applyToPoint44(transform, {
     x: schComponent.center.x + schComponent.size.width / 2,
     y: schComponent.center.y - schComponent.size.height / 2
   });
@@ -5328,7 +6335,7 @@ var createSvgObjectsFromSchematicComponentWithBox = ({
     },
     children: []
   });
-  const schTexts = su7(circuitJson).schematic_text.list();
+  const schTexts = su10(circuitJson).schematic_text.list();
   for (const schText of schTexts) {
     if (schText.schematic_component_id === schComponent.schematic_component_id) {
       svgObjects.push(
@@ -5340,7 +6347,7 @@ var createSvgObjectsFromSchematicComponentWithBox = ({
       );
     }
   }
-  const schematicPorts = su7(circuitJson).schematic_port.list({
+  const schematicPorts = su10(circuitJson).schematic_port.list({
     schematic_component_id: schComponent.schematic_component_id
   });
   for (const schPort of schematicPorts) {
@@ -5359,6 +6366,9 @@ var createSvgObjectsFromSchematicComponentWithBox = ({
 // lib/sch/svg-object-fns/create-svg-objects-from-sch-component.ts
 function createSvgObjectsFromSchematicComponent(params) {
   const { component } = params;
+  if (component.is_box_with_pins === false) {
+    return [];
+  }
   const innerElements = component.symbol_name ? createSvgObjectsFromSchematicComponentWithSymbol(params) : createSvgObjectsFromSchematicComponentWithBox(params);
   return [
     {
@@ -5375,13 +6385,13 @@ function createSvgObjectsFromSchematicComponent(params) {
 }
 
 // lib/sch/svg-object-fns/create-svg-objects-from-sch-voltage-probe.ts
-import { applyToPoint as applyToPoint38 } from "transformation-matrix";
+import { applyToPoint as applyToPoint45 } from "transformation-matrix";
 function createSvgObjectsFromSchVoltageProbe({
   probe,
   transform,
   colorMap: colorMap2
 }) {
-  const [screenX, screenY] = applyToPoint38(transform, [
+  const [screenX, screenY] = applyToPoint45(transform, [
     probe.position.x,
     probe.position.y
   ]);
@@ -5441,17 +6451,17 @@ function createSvgObjectsFromSchVoltageProbe({
 }
 
 // lib/sch/svg-object-fns/create-svg-objects-from-sch-debug-object.ts
-import { applyToPoint as applyToPoint39 } from "transformation-matrix";
+import { applyToPoint as applyToPoint46 } from "transformation-matrix";
 function createSvgObjectsFromSchDebugObject({
   debugObject,
   transform
 }) {
   if (debugObject.shape === "rect") {
-    let [screenLeft, screenTop] = applyToPoint39(transform, [
+    let [screenLeft, screenTop] = applyToPoint46(transform, [
       debugObject.center.x - debugObject.size.width / 2,
       debugObject.center.y - debugObject.size.height / 2
     ]);
-    let [screenRight, screenBottom] = applyToPoint39(transform, [
+    let [screenRight, screenBottom] = applyToPoint46(transform, [
       debugObject.center.x + debugObject.size.width / 2,
       debugObject.center.y + debugObject.size.height / 2
     ]);
@@ -5461,7 +6471,7 @@ function createSvgObjectsFromSchDebugObject({
     ];
     const width = Math.abs(screenRight - screenLeft);
     const height = Math.abs(screenBottom - screenTop);
-    const [screenCenterX, screenCenterY] = applyToPoint39(transform, [
+    const [screenCenterX, screenCenterY] = applyToPoint46(transform, [
       debugObject.center.x,
       debugObject.center.y
     ]);
@@ -5507,11 +6517,11 @@ function createSvgObjectsFromSchDebugObject({
     ];
   }
   if (debugObject.shape === "line") {
-    const [screenStartX, screenStartY] = applyToPoint39(transform, [
+    const [screenStartX, screenStartY] = applyToPoint46(transform, [
       debugObject.start.x,
       debugObject.start.y
     ]);
-    const [screenEndX, screenEndY] = applyToPoint39(transform, [
+    const [screenEndX, screenEndY] = applyToPoint46(transform, [
       debugObject.end.x,
       debugObject.end.y
     ]);
@@ -5561,7 +6571,7 @@ function createSvgObjectsFromSchDebugObject({
 }
 
 // lib/sch/svg-object-fns/create-svg-objects-from-sch-trace.ts
-import { applyToPoint as applyToPoint40 } from "transformation-matrix";
+import { applyToPoint as applyToPoint47 } from "transformation-matrix";
 function createSchematicTrace({
   trace,
   transform,
@@ -5575,11 +6585,11 @@ function createSchematicTrace({
   for (let edgeIndex = 0; edgeIndex < edges.length; edgeIndex++) {
     const edge = edges[edgeIndex];
     if (edge.is_crossing) continue;
-    const [screenFromX, screenFromY] = applyToPoint40(transform, [
+    const [screenFromX, screenFromY] = applyToPoint47(transform, [
       edge.from.x,
       edge.from.y
     ]);
-    const [screenToX, screenToY] = applyToPoint40(transform, [
+    const [screenToX, screenToY] = applyToPoint47(transform, [
       edge.to.x,
       edge.to.y
     ]);
@@ -5623,11 +6633,11 @@ function createSchematicTrace({
   }
   for (const edge of edges) {
     if (!edge.is_crossing) continue;
-    const [screenFromX, screenFromY] = applyToPoint40(transform, [
+    const [screenFromX, screenFromY] = applyToPoint47(transform, [
       edge.from.x,
       edge.from.y
     ]);
-    const [screenToX, screenToY] = applyToPoint40(transform, [
+    const [screenToX, screenToY] = applyToPoint47(transform, [
       edge.to.x,
       edge.to.y
     ]);
@@ -5671,7 +6681,7 @@ function createSchematicTrace({
   }
   if (trace.junctions) {
     for (const junction of trace.junctions) {
-      const [screenX, screenY] = applyToPoint40(transform, [
+      const [screenX, screenY] = applyToPoint47(transform, [
         junction.x,
         junction.y
       ]);
@@ -5726,20 +6736,20 @@ function createSchematicTrace({
 
 // lib/sch/svg-object-fns/create-svg-objects-for-sch-net-label.ts
 import {
-  applyToPoint as applyToPoint42,
-  compose as compose10,
+  applyToPoint as applyToPoint49,
+  compose as compose11,
   rotate as rotate6,
-  scale as scale6,
-  translate as translate10
+  scale as scale7,
+  translate as translate11
 } from "transformation-matrix";
 
 // lib/sch/svg-object-fns/create-svg-objects-for-sch-net-label-with-symbol.ts
 import {
-  applyToPoint as applyToPoint41,
-  compose as compose9,
+  applyToPoint as applyToPoint48,
+  compose as compose10,
   rotate as rotate5,
-  scale as scale5,
-  translate as translate9
+  scale as scale6,
+  translate as translate10
 } from "transformation-matrix";
 import { symbols as symbols3 } from "schematic-symbols";
 var createSvgObjectsForSchNetLabelWithSymbol = ({
@@ -5810,22 +6820,22 @@ var createSvgObjectsForSchNetLabelWithSymbol = ({
     x: symbolBounds.minX,
     y: (symbolBounds.minY + symbolBounds.maxY) / 2
   };
-  const rotatedSymbolEnd = applyToPoint41(rotationMatrix, symbolEndPoint);
-  const symbolToRealTransform = compose9(
-    translate9(
+  const rotatedSymbolEnd = applyToPoint48(rotationMatrix, symbolEndPoint);
+  const symbolToRealTransform = compose10(
+    translate10(
       realAnchorPosition.x - rotatedSymbolEnd.x,
       realAnchorPosition.y - rotatedSymbolEnd.y
     ),
     rotationMatrix,
-    scale5(1)
+    scale6(1)
     // Use full symbol size
   );
-  const [screenMinX, screenMinY] = applyToPoint41(
-    compose9(realToScreenTransform, symbolToRealTransform),
+  const [screenMinX, screenMinY] = applyToPoint48(
+    compose10(realToScreenTransform, symbolToRealTransform),
     [bounds.minX, bounds.minY]
   );
-  const [screenMaxX, screenMaxY] = applyToPoint41(
-    compose9(realToScreenTransform, symbolToRealTransform),
+  const [screenMaxX, screenMaxY] = applyToPoint48(
+    compose10(realToScreenTransform, symbolToRealTransform),
     [bounds.maxX, bounds.maxY]
   );
   const rectHeight = Math.abs(screenMaxY - screenMinY);
@@ -5848,8 +6858,8 @@ var createSvgObjectsForSchNetLabelWithSymbol = ({
   });
   for (const path of symbolPaths) {
     const symbolPath = path.points.map((p, i) => {
-      const [x, y] = applyToPoint41(
-        compose9(realToScreenTransform, symbolToRealTransform),
+      const [x, y] = applyToPoint48(
+        compose10(realToScreenTransform, symbolToRealTransform),
         [p.x, p.y]
       );
       return `${i === 0 ? "M" : "L"} ${x} ${y}`;
@@ -5869,8 +6879,8 @@ var createSvgObjectsForSchNetLabelWithSymbol = ({
     });
   }
   for (const text of symbolTexts) {
-    const screenTextPos = applyToPoint41(
-      compose9(realToScreenTransform, symbolToRealTransform),
+    const screenTextPos = applyToPoint48(
+      compose10(realToScreenTransform, symbolToRealTransform),
       text
     );
     let textValue = text.text;
@@ -5879,8 +6889,8 @@ var createSvgObjectsForSchNetLabelWithSymbol = ({
     } else if (textValue === "{VAL}") {
       textValue = "";
     }
-    const scale9 = Math.abs(realToScreenTransform.a);
-    const baseOffset = scale9 * 0.1;
+    const scale10 = Math.abs(realToScreenTransform.a);
+    const baseOffset = scale10 * 0.1;
     const offsetScreenPos = {
       x: screenTextPos.x,
       y: screenTextPos.y
@@ -5911,11 +6921,11 @@ var createSvgObjectsForSchNetLabelWithSymbol = ({
     });
   }
   for (const box of symbolBoxes) {
-    const screenBoxPos = applyToPoint41(
-      compose9(realToScreenTransform, symbolToRealTransform),
+    const screenBoxPos = applyToPoint48(
+      compose10(realToScreenTransform, symbolToRealTransform),
       box
     );
-    const symbolToScreenScale = compose9(
+    const symbolToScreenScale = compose10(
       realToScreenTransform,
       symbolToRealTransform
     ).a;
@@ -5934,11 +6944,11 @@ var createSvgObjectsForSchNetLabelWithSymbol = ({
     });
   }
   for (const circle of symbolCircles) {
-    const screenCirclePos = applyToPoint41(
-      compose9(realToScreenTransform, symbolToRealTransform),
+    const screenCirclePos = applyToPoint48(
+      compose10(realToScreenTransform, symbolToRealTransform),
       circle
     );
-    const symbolToScreenScale = compose9(
+    const symbolToScreenScale = compose10(
       realToScreenTransform,
       symbolToRealTransform
     ).a;
@@ -5979,14 +6989,14 @@ var createSvgObjectsForSchNetLabel = ({
   const fontSizePx = getSchScreenFontSize(realToScreenTransform, "net_label");
   const fontSizeMm = getSchMmFontSize("net_label");
   const textWidthFSR = estimateTextWidth(labelText || "");
-  const screenCenter = applyToPoint42(realToScreenTransform, schNetLabel.center);
+  const screenCenter = applyToPoint49(realToScreenTransform, schNetLabel.center);
   const realTextGrowthVec = getUnitVectorFromOutsideToEdge(
     schNetLabel.anchor_side
   );
   const screenTextGrowthVec = { ...realTextGrowthVec };
   screenTextGrowthVec.y *= -1;
   const fullWidthFsr = textWidthFSR + ARROW_POINT_WIDTH_FSR * 2 + END_PADDING_EXTRA_PER_CHARACTER_FSR * labelText.length + END_PADDING_FSR;
-  const screenAnchorPosition = schNetLabel.anchor_position ? applyToPoint42(realToScreenTransform, schNetLabel.anchor_position) : {
+  const screenAnchorPosition = schNetLabel.anchor_position ? applyToPoint49(realToScreenTransform, schNetLabel.anchor_position) : {
     x: screenCenter.x - screenTextGrowthVec.x * fullWidthFsr * fontSizePx / 2,
     y: screenCenter.y - screenTextGrowthVec.y * fullWidthFsr * fontSizePx / 2
   };
@@ -6027,11 +7037,11 @@ var createSvgObjectsForSchNetLabel = ({
       y: -0.6
     }
   ].map(
-    (fontRelativePoint) => applyToPoint42(
-      compose10(
+    (fontRelativePoint) => applyToPoint49(
+      compose11(
         realToScreenTransform,
-        translate10(realAnchorPosition.x, realAnchorPosition.y),
-        scale6(fontSizeMm),
+        translate11(realAnchorPosition.x, realAnchorPosition.y),
+        scale7(fontSizeMm),
         rotate6(pathRotation / 180 * Math.PI)
       ),
       fontRelativePoint
@@ -6104,17 +7114,17 @@ var createSvgObjectsForSchNetLabel = ({
 };
 
 // lib/sch/svg-object-fns/create-svg-objects-from-sch-box.ts
-import { applyToPoint as applyToPoint43 } from "transformation-matrix";
+import { applyToPoint as applyToPoint50 } from "transformation-matrix";
 var createSvgObjectsFromSchematicBox = ({
   schematicBox,
   transform,
   colorMap: colorMap2
 }) => {
-  const topLeft = applyToPoint43(transform, {
+  const topLeft = applyToPoint50(transform, {
     x: schematicBox.x,
     y: schematicBox.y
   });
-  const bottomRight = applyToPoint43(transform, {
+  const bottomRight = applyToPoint50(transform, {
     x: schematicBox.x + schematicBox.width,
     y: schematicBox.y + schematicBox.height
   });
@@ -6150,7 +7160,7 @@ var createSvgObjectsFromSchematicBox = ({
 };
 
 // lib/sch/svg-object-fns/create-svg-objects-from-sch-table.ts
-import { applyToPoint as applyToPoint44 } from "transformation-matrix";
+import { applyToPoint as applyToPoint51 } from "transformation-matrix";
 var createSvgObjectsFromSchematicTable = ({
   schematicTable,
   transform,
@@ -6183,11 +7193,11 @@ var createSvgObjectsFromSchematicTable = ({
   const svgObjects = [];
   const borderStrokeWidth = border_width * Math.abs(transform.a);
   const gridStrokeWidth = getSchStrokeSize(transform);
-  const [screenTopLeftX, screenTopLeftY] = applyToPoint44(transform, [
+  const [screenTopLeftX, screenTopLeftY] = applyToPoint51(transform, [
     topLeftX,
     topLeftY
   ]);
-  const [screenBottomRightX, screenBottomRightY] = applyToPoint44(transform, [
+  const [screenBottomRightX, screenBottomRightY] = applyToPoint51(transform, [
     topLeftX + totalWidth,
     topLeftY - totalHeight
   ]);
@@ -6219,8 +7229,8 @@ var createSvgObjectsFromSchematicTable = ({
         (cell) => cell.start_column_index <= i && cell.end_column_index > i && cell.start_row_index <= j && cell.end_row_index >= j
       );
       if (!isMerged) {
-        const start = applyToPoint44(transform, { x: currentX, y: segmentStartY });
-        const end = applyToPoint44(transform, { x: currentX, y: segmentEndY });
+        const start = applyToPoint51(transform, { x: currentX, y: segmentStartY });
+        const end = applyToPoint51(transform, { x: currentX, y: segmentEndY });
         svgObjects.push({
           name: "line",
           type: "element",
@@ -6249,11 +7259,11 @@ var createSvgObjectsFromSchematicTable = ({
         (cell) => cell.start_row_index <= i && cell.end_row_index > i && cell.start_column_index <= j && cell.end_column_index >= j
       );
       if (!isMerged) {
-        const start = applyToPoint44(transform, {
+        const start = applyToPoint51(transform, {
           x: segmentStartX,
           y: currentY
         });
-        const end = applyToPoint44(transform, { x: segmentEndX, y: currentY });
+        const end = applyToPoint51(transform, { x: segmentEndX, y: currentY });
         svgObjects.push({
           name: "line",
           type: "element",
@@ -6295,7 +7305,7 @@ var createSvgObjectsFromSchematicTable = ({
       } else if (vertical_align === "bottom") {
         realTextAnchorPos.y = cellTopLeftY - cellHeight + cell_padding;
       }
-      const screenTextAnchorPos = applyToPoint44(transform, realTextAnchorPos);
+      const screenTextAnchorPos = applyToPoint51(transform, realTextAnchorPos);
       const fontSize = getSchScreenFontSize(
         transform,
         "reference_designator",
@@ -6350,14 +7360,14 @@ var createSvgObjectsFromSchematicTable = ({
 };
 
 // lib/sch/svg-object-fns/create-svg-objects-for-sch-port-hover.ts
-import { su as su8 } from "@tscircuit/circuit-json-util";
-import { applyToPoint as applyToPoint45 } from "transformation-matrix";
+import { su as su11 } from "@tscircuit/circuit-json-util";
+import { applyToPoint as applyToPoint52 } from "transformation-matrix";
 var PIN_CIRCLE_RADIUS_MM2 = 0.02;
 var createSvgObjectsForSchPortHover = ({
   schPort,
   transform
 }) => {
-  const screenSchPortPos = applyToPoint45(transform, schPort.center);
+  const screenSchPortPos = applyToPoint52(transform, schPort.center);
   const pinRadiusPx = Math.abs(transform.a) * PIN_CIRCLE_RADIUS_MM2 * 2;
   return [
     {
@@ -6391,7 +7401,7 @@ var createSvgObjectsForSchComponentPortHovers = ({
   transform,
   circuitJson
 }) => {
-  const schematicPorts = su8(circuitJson).schematic_port.list({
+  const schematicPorts = su11(circuitJson).schematic_port.list({
     schematic_component_id: component.schematic_component_id
   });
   const svgs = [];
@@ -6402,14 +7412,14 @@ var createSvgObjectsForSchComponentPortHovers = ({
 };
 
 // lib/sch/svg-object-fns/create-svg-objects-from-sch-line.ts
-import { applyToPoint as applyToPoint46 } from "transformation-matrix";
+import { applyToPoint as applyToPoint53 } from "transformation-matrix";
 function createSvgObjectsFromSchematicLine({
   schLine,
   transform,
   colorMap: colorMap2
 }) {
-  const p1 = applyToPoint46(transform, { x: schLine.x1, y: schLine.y1 });
-  const p2 = applyToPoint46(transform, { x: schLine.x2, y: schLine.y2 });
+  const p1 = applyToPoint53(transform, { x: schLine.x1, y: schLine.y1 });
+  const p2 = applyToPoint53(transform, { x: schLine.x2, y: schLine.y2 });
   const strokeWidth = schLine.stroke_width ?? 0.02;
   const transformedStrokeWidth = Math.abs(transform.a) * strokeWidth;
   return [
@@ -6438,13 +7448,13 @@ function createSvgObjectsFromSchematicLine({
 }
 
 // lib/sch/svg-object-fns/create-svg-objects-from-sch-circle.ts
-import { applyToPoint as applyToPoint47 } from "transformation-matrix";
+import { applyToPoint as applyToPoint54 } from "transformation-matrix";
 function createSvgObjectsFromSchematicCircle({
   schCircle,
   transform,
   colorMap: colorMap2
 }) {
-  const center = applyToPoint47(transform, schCircle.center);
+  const center = applyToPoint54(transform, schCircle.center);
   const transformedRadius = Math.abs(transform.a) * schCircle.radius;
   const strokeWidth = schCircle.stroke_width ?? 0.02;
   const transformedStrokeWidth = Math.abs(transform.a) * strokeWidth;
@@ -6474,13 +7484,13 @@ function createSvgObjectsFromSchematicCircle({
 }
 
 // lib/sch/svg-object-fns/create-svg-objects-from-sch-rect.ts
-import { applyToPoint as applyToPoint48 } from "transformation-matrix";
+import { applyToPoint as applyToPoint55 } from "transformation-matrix";
 function createSvgObjectsFromSchematicRect({
   schRect,
   transform,
   colorMap: colorMap2
 }) {
-  const center = applyToPoint48(transform, schRect.center);
+  const center = applyToPoint55(transform, schRect.center);
   const transformedWidth = Math.abs(transform.a) * schRect.width;
   const transformedHeight = Math.abs(transform.d) * schRect.height;
   const strokeWidth = schRect.stroke_width ?? 0.02;
@@ -6516,13 +7526,13 @@ function createSvgObjectsFromSchematicRect({
 }
 
 // lib/sch/svg-object-fns/create-svg-objects-from-sch-arc.ts
-import { applyToPoint as applyToPoint49 } from "transformation-matrix";
+import { applyToPoint as applyToPoint56 } from "transformation-matrix";
 function createSvgObjectsFromSchematicArc({
   schArc,
   transform,
   colorMap: colorMap2
 }) {
-  const center = applyToPoint49(transform, schArc.center);
+  const center = applyToPoint56(transform, schArc.center);
   const transformedRadius = Math.abs(transform.a) * schArc.radius;
   const strokeWidth = schArc.stroke_width ?? 0.02;
   const transformedStrokeWidth = Math.abs(transform.a) * strokeWidth;
@@ -6862,25 +7872,25 @@ function convertCircuitJsonToSchematicSvg(circuitJson, options) {
     ],
     value: ""
   };
-  return stringify3(svgObject);
+  return stringify4(svgObject);
 }
 var circuitJsonToSchematicSvg = convertCircuitJsonToSchematicSvg;
 
 // lib/pcb/convert-circuit-json-to-solder-paste-mask.ts
-import { stringify as stringify4 } from "svgson";
+import { stringify as stringify5 } from "svgson";
 import {
-  applyToPoint as applyToPoint52,
-  compose as compose13,
-  scale as scale8,
-  translate as translate13
+  applyToPoint as applyToPoint59,
+  compose as compose14,
+  scale as scale9,
+  translate as translate14
 } from "transformation-matrix";
 
 // lib/pcb/svg-object-fns/convert-circuit-json-to-solder-paste-mask.ts
-import { applyToPoint as applyToPoint51 } from "transformation-matrix";
+import { applyToPoint as applyToPoint58 } from "transformation-matrix";
 function createSvgObjectsFromSolderPaste(solderPaste, ctx) {
   const { transform, layer: layerFilter } = ctx;
   if (layerFilter && solderPaste.layer !== layerFilter) return [];
-  const [x, y] = applyToPoint51(transform, [solderPaste.x, solderPaste.y]);
+  const [x, y] = applyToPoint58(transform, [solderPaste.x, solderPaste.y]);
   if (solderPaste.shape === "rect" || solderPaste.shape === "rotated_rect") {
     const width = solderPaste.width * Math.abs(transform.a);
     const height = solderPaste.height * Math.abs(transform.d);
@@ -6955,7 +7965,7 @@ function createSvgObjectsFromSolderPaste(solderPaste, ctx) {
 }
 
 // lib/pcb/convert-circuit-json-to-solder-paste-mask.ts
-var OBJECT_ORDER3 = [
+var OBJECT_ORDER4 = [
   "pcb_board",
   "pcb_solder_paste"
 ];
@@ -6988,12 +7998,12 @@ function convertCircuitJsonToSolderPasteMask(circuitJson, options) {
   const scaleFactor = Math.min(scaleX, scaleY);
   const offsetX = (svgWidth - circuitWidth * scaleFactor) / 2;
   const offsetY = (svgHeight - circuitHeight * scaleFactor) / 2;
-  const transform = compose13(
-    translate13(
+  const transform = compose14(
+    translate14(
       offsetX - minX * scaleFactor + padding * scaleFactor,
       svgHeight - offsetY + minY * scaleFactor - padding * scaleFactor
     ),
-    scale8(scaleFactor, -scaleFactor)
+    scale9(scaleFactor, -scaleFactor)
     // Flip in y-direction
   );
   const ctx = {
@@ -7002,8 +8012,8 @@ function convertCircuitJsonToSolderPasteMask(circuitJson, options) {
     colorMap: DEFAULT_PCB_COLOR_MAP
   };
   const svgObjects = filteredCircuitJson.sort(
-    (a, b) => (OBJECT_ORDER3.indexOf(b.type) ?? 9999) - (OBJECT_ORDER3.indexOf(a.type) ?? 9999)
-  ).flatMap((item) => createSvgObjects3({ elm: item, ctx }));
+    (a, b) => (OBJECT_ORDER4.indexOf(b.type) ?? 9999) - (OBJECT_ORDER4.indexOf(a.type) ?? 9999)
+  ).flatMap((item) => createSvgObjects4({ elm: item, ctx }));
   const softwareUsedString = getSoftwareUsedString(circuitJson);
   const version = CIRCUIT_TO_SVG_VERSION;
   const svgObject = {
@@ -7049,7 +8059,7 @@ function convertCircuitJsonToSolderPasteMask(circuitJson, options) {
     ].filter((child) => child !== null)
   };
   try {
-    return stringify4(svgObject);
+    return stringify5(svgObject);
   } catch (error) {
     console.error("Error stringifying SVG object:", error);
     throw error;
@@ -7071,7 +8081,7 @@ function convertCircuitJsonToSolderPasteMask(circuitJson, options) {
     }
   }
 }
-function createSvgObjects3({ elm, ctx }) {
+function createSvgObjects4({ elm, ctx }) {
   const { transform } = ctx;
   switch (elm.type) {
     case "pcb_board":
@@ -7083,8 +8093,8 @@ function createSvgObjects3({ elm, ctx }) {
   }
 }
 function createSvgObjectFromPcbBoundary2(transform, minX, minY, maxX, maxY) {
-  const [x1, y1] = applyToPoint52(transform, [minX, minY]);
-  const [x2, y2] = applyToPoint52(transform, [maxX, maxY]);
+  const [x1, y1] = applyToPoint59(transform, [minX, minY]);
+  const [x2, y2] = applyToPoint59(transform, [maxX, maxY]);
   const width = Math.abs(x2 - x1);
   const height = Math.abs(y2 - y1);
   const x = Math.min(x1, x2);
@@ -7112,6 +8122,7 @@ export {
   circuitJsonToSchematicSvg,
   convertCircuitJsonToAssemblySvg,
   convertCircuitJsonToPcbSvg,
+  convertCircuitJsonToPinoutSvg,
   convertCircuitJsonToSchematicSvg,
   convertCircuitJsonToSolderPasteMask,
   createSvgObjectsForSchComponentPortHovers,