circuit-to-svg 0.0.283 → 0.0.285

package/dist/index.js

@@ -1,11 +1,11 @@
 // lib/pcb/convert-circuit-json-to-pcb-svg.ts
-import { distance } from "circuit-json";
+import { distance as distance2 } from "circuit-json";
 import { stringify } from "svgson";
 import {
-  applyToPoint as applyToPoint32,
-  compose as compose5,
-  scale as scale2,
-  translate as translate5
+  applyToPoint as applyToPoint33,
+  compose as compose6,
+  scale as scale3,
+  translate as translate6
 } from "transformation-matrix";
 
 // lib/pcb/svg-object-fns/create-svg-objects-from-pcb-trace-error.ts
@@ -2677,8 +2677,326 @@ function createSvgObjectsFromPcbSilkscreenRect(pcbSilkscreenRect, ctx) {
   return [svgObject];
 }
 
+// lib/pcb/svg-object-fns/create-svg-objects-from-pcb-copper-text.ts
+import {
+  applyToPoint as applyToPoint16,
+  compose as compose3,
+  rotate as rotate3,
+  translate as translate3,
+  scale as scale2,
+  toString as matrixToString4
+} from "transformation-matrix";
+
+// lib/pcb/colors.ts
+var DEFAULT_PCB_COLOR_MAP = {
+  copper: {
+    top: "rgb(200, 52, 52)",
+    inner1: "rgb(255, 140, 0)",
+    inner2: "rgb(255, 215, 0)",
+    inner3: "rgb(50, 205, 50)",
+    inner4: "rgb(64, 224, 208)",
+    inner5: "rgb(138, 43, 226)",
+    inner6: "rgb(255, 105, 180)",
+    bottom: "rgb(77, 127, 196)"
+  },
+  soldermaskWithCopperUnderneath: {
+    top: "rgb(18, 82, 50)",
+    bottom: "rgb(77, 127, 196)"
+  },
+  soldermask: {
+    top: "rgb(12, 55, 33)",
+    bottom: "rgb(12, 55, 33)"
+  },
+  soldermaskOverCopper: {
+    top: "rgb(52, 135, 73)",
+    bottom: "rgb(52, 135, 73)"
+  },
+  substrate: "rgb(201, 162, 110)",
+  // FR4 substrate color (tan/beige)
+  drill: "#FF26E2",
+  silkscreen: {
+    top: "#f2eda1",
+    bottom: "#5da9e9"
+  },
+  boardOutline: "rgba(255, 255, 255, 0.5)",
+  courtyard: "#FF00FF",
+  debugComponent: {
+    fill: null,
+    stroke: null
+  }
+};
+var HOLE_COLOR = DEFAULT_PCB_COLOR_MAP.drill;
+var SILKSCREEN_TOP_COLOR = DEFAULT_PCB_COLOR_MAP.silkscreen.top;
+var SILKSCREEN_BOTTOM_COLOR = DEFAULT_PCB_COLOR_MAP.silkscreen.bottom;
+
+// lib/pcb/layer-name-to-color.ts
+var LAYER_NAME_TO_COLOR = {
+  ...DEFAULT_PCB_COLOR_MAP.copper
+};
+function layerNameToColor(layerName, colorMap2 = DEFAULT_PCB_COLOR_MAP) {
+  return colorMap2.copper[layerName] ?? "white";
+}
+var SOLDER_PASTE_LAYER_NAME_TO_COLOR = {
+  bottom: "rgb(105, 105, 105)",
+  top: "rgb(105, 105, 105)"
+};
+function solderPasteLayerNameToColor(layerName) {
+  return SOLDER_PASTE_LAYER_NAME_TO_COLOR[layerName] ?? "rgb(105, 105, 105)";
+}
+
+// lib/pcb/svg-object-fns/create-svg-objects-from-pcb-copper-text.ts
+import { distance } from "circuit-json";
+import { lineAlphabet } from "@tscircuit/alphabet";
+var CHAR_WIDTH = 1;
+var CHAR_SPACING = 0.2;
+var LINE_HEIGHT = 1.4;
+function linesToPathData(lines, offsetX, offsetY, charScale) {
+  return lines.map((line) => {
+    const x1 = offsetX + line.x1 * charScale;
+    const y1 = offsetY + (1 - line.y1) * charScale;
+    const x2 = offsetX + line.x2 * charScale;
+    const y2 = offsetY + (1 - line.y2) * charScale;
+    return `M${x1} ${y1}L${x2} ${y2}`;
+  }).join(" ");
+}
+function textToAlphabetPath(text, fontSize) {
+  const paths = [];
+  const charAdvance = (CHAR_WIDTH + CHAR_SPACING) * fontSize;
+  let x = 0;
+  for (const char of text) {
+    if (char === " ") {
+      x += charAdvance * 0.6;
+      continue;
+    }
+    const lines = lineAlphabet[char];
+    if (lines) {
+      paths.push(linesToPathData(lines, x, 0, fontSize));
+    }
+    x += charAdvance;
+  }
+  const width = x > 0 ? x - CHAR_SPACING * fontSize : 0;
+  return { pathData: paths.join(" "), width };
+}
+var maskIdCounter = 0;
+function textToCenteredAlphabetPaths(text, fontSize) {
+  const textLines = text.split("\n");
+  const lineHeight = fontSize * LINE_HEIGHT;
+  const totalHeight = textLines.length * lineHeight;
+  const lineWidths = [];
+  let maxWidth = 0;
+  for (const line of textLines) {
+    const { width } = textToAlphabetPath(line, fontSize);
+    lineWidths.push(width);
+    if (width > maxWidth) maxWidth = width;
+  }
+  const paths = [];
+  let y = -totalHeight / 2;
+  for (let i = 0; i < textLines.length; i++) {
+    const line = textLines[i];
+    const lineWidth = lineWidths[i];
+    const charAdvance = (CHAR_WIDTH + CHAR_SPACING) * fontSize;
+    let x = -lineWidth / 2;
+    for (const char of line) {
+      if (char === " ") {
+        x += charAdvance * 0.6;
+        continue;
+      }
+      const charLines = lineAlphabet[char];
+      if (charLines) {
+        paths.push(linesToPathData(charLines, x, y, fontSize));
+      }
+      x += charAdvance;
+    }
+    y += lineHeight;
+  }
+  return {
+    pathData: paths.join(" "),
+    width: maxWidth,
+    height: totalHeight
+  };
+}
+function createSvgObjectsFromPcbCopperText(pcbCopperText, ctx) {
+  const { transform, layer: filterLayer, colorMap: colorMap2 } = ctx;
+  const {
+    anchor_position,
+    text,
+    font_size = "0.2mm",
+    layer,
+    ccw_rotation = 0,
+    anchor_alignment = "center",
+    is_knockout = false,
+    knockout_padding,
+    is_mirrored = false
+  } = pcbCopperText;
+  const layerName = layer ?? "top";
+  if (filterLayer && filterLayer !== layerName) return [];
+  if (!anchor_position) return [];
+  const [ax, ay] = applyToPoint16(transform, [
+    anchor_position.x,
+    anchor_position.y
+  ]);
+  const fontSizeNum = distance.parse(font_size) ?? 0.2;
+  const scaleFactor = Math.abs(transform.a);
+  const copperColor = layerNameToColor(layerName, colorMap2);
+  const isBottom = layerName === "bottom";
+  const applyMirror = isBottom ? true : is_mirrored === true;
+  if (is_knockout) {
+    const { pathData: pathData2, width: width2, height: height2 } = textToCenteredAlphabetPaths(
+      text,
+      fontSizeNum
+    );
+    const padX = knockout_padding?.left ?? fontSizeNum * 0.5;
+    const padY = knockout_padding?.top ?? fontSizeNum * 0.3;
+    const rectW = width2 + padX * 2;
+    const rectH = height2 + padY * 2;
+    const strokeWidth2 = fontSizeNum * 0.15;
+    const knockoutTransform = matrixToString4(
+      compose3(
+        translate3(ax, ay),
+        rotate3(-ccw_rotation * Math.PI / 180),
+        ...applyMirror ? [scale2(-1, 1)] : [],
+        scale2(scaleFactor, scaleFactor)
+      )
+    );
+    const maskId = `knockout-mask-${pcbCopperText.pcb_copper_text_id}-${maskIdCounter++}`;
+    return [
+      {
+        name: "defs",
+        type: "element",
+        value: "",
+        children: [
+          {
+            name: "mask",
+            type: "element",
+            value: "",
+            attributes: {
+              id: maskId
+            },
+            children: [
+              // White background - area that will show copper
+              {
+                name: "rect",
+                type: "element",
+                value: "",
+                attributes: {
+                  x: (-rectW / 2).toString(),
+                  y: (-rectH / 2).toString(),
+                  width: rectW.toString(),
+                  height: rectH.toString(),
+                  fill: "white"
+                },
+                children: []
+              },
+              // Black text strokes - area that will be cut out
+              {
+                name: "path",
+                type: "element",
+                value: "",
+                attributes: {
+                  d: pathData2,
+                  fill: "none",
+                  stroke: "black",
+                  "stroke-width": strokeWidth2.toString(),
+                  "stroke-linecap": "round",
+                  "stroke-linejoin": "round"
+                },
+                children: []
+              }
+            ]
+          }
+        ],
+        attributes: {}
+      },
+      {
+        name: "rect",
+        type: "element",
+        value: "",
+        children: [],
+        attributes: {
+          x: (-rectW / 2).toString(),
+          y: (-rectH / 2).toString(),
+          width: rectW.toString(),
+          height: rectH.toString(),
+          fill: copperColor,
+          mask: `url(#${maskId})`,
+          transform: knockoutTransform,
+          class: `pcb-copper-text-knockout pcb-copper-${layerName}`,
+          "data-type": "pcb_copper_text",
+          "data-pcb-copper-text-id": pcbCopperText.pcb_copper_text_id
+        }
+      }
+    ];
+  }
+  const { pathData, width, height } = textToCenteredAlphabetPaths(
+    text,
+    fontSizeNum
+  );
+  let offsetX = 0;
+  let offsetY = 0;
+  switch (anchor_alignment) {
+    case "top_left":
+      offsetX = width / 2;
+      offsetY = height / 2;
+      break;
+    case "top_center":
+      offsetY = height / 2;
+      break;
+    case "top_right":
+      offsetX = -width / 2;
+      offsetY = height / 2;
+      break;
+    case "center_left":
+      offsetX = width / 2;
+      break;
+    case "center_right":
+      offsetX = -width / 2;
+      break;
+    case "bottom_left":
+      offsetX = width / 2;
+      offsetY = -height / 2;
+      break;
+    case "bottom_center":
+      offsetY = -height / 2;
+      break;
+    case "bottom_right":
+      offsetX = -width / 2;
+      offsetY = -height / 2;
+      break;
+  }
+  const textTransform = matrixToString4(
+    compose3(
+      translate3(ax, ay),
+      rotate3(-ccw_rotation * Math.PI / 180),
+      ...applyMirror ? [scale2(-1, 1)] : [],
+      translate3(offsetX, offsetY),
+      scale2(scaleFactor, scaleFactor)
+    )
+  );
+  const strokeWidth = fontSizeNum * 0.15;
+  return [
+    {
+      name: "path",
+      type: "element",
+      attributes: {
+        d: pathData,
+        fill: "none",
+        stroke: copperColor,
+        "stroke-width": strokeWidth.toString(),
+        "stroke-linecap": "round",
+        "stroke-linejoin": "round",
+        transform: textTransform,
+        class: `pcb-copper-text pcb-copper-${layerName}`,
+        "data-type": "pcb_copper_text",
+        "data-pcb-copper-text-id": pcbCopperText.pcb_copper_text_id
+      },
+      children: [],
+      value: ""
+    }
+  ];
+}
+
 // lib/pcb/svg-object-fns/create-svg-objects-from-pcb-silkscreen-circle.ts
-import { applyToPoint as applyToPoint16 } from "transformation-matrix";
+import { applyToPoint as applyToPoint17 } from "transformation-matrix";
 function createSvgObjectsFromPcbSilkscreenCircle(pcbSilkscreenCircle, ctx) {
   const { transform, layer: layerFilter, colorMap: colorMap2 } = ctx;
   const {
@@ -2693,7 +3011,7 @@ function createSvgObjectsFromPcbSilkscreenCircle(pcbSilkscreenCircle, ctx) {
     console.error("Invalid PCB Silkscreen Circle data:", { center, radius });
     return [];
   }
-  const [transformedX, transformedY] = applyToPoint16(transform, [
+  const [transformedX, transformedY] = applyToPoint17(transform, [
     center.x,
     center.y
   ]);
@@ -2721,7 +3039,7 @@ function createSvgObjectsFromPcbSilkscreenCircle(pcbSilkscreenCircle, ctx) {
 }
 
 // lib/pcb/svg-object-fns/create-svg-objects-from-pcb-silkscreen-line.ts
-import { applyToPoint as applyToPoint17 } from "transformation-matrix";
+import { applyToPoint as applyToPoint18 } from "transformation-matrix";
 function createSvgObjectsFromPcbSilkscreenLine(pcbSilkscreenLine, ctx) {
   const { transform, layer: layerFilter, colorMap: colorMap2 } = ctx;
   const {
@@ -2738,8 +3056,8 @@ function createSvgObjectsFromPcbSilkscreenLine(pcbSilkscreenLine, ctx) {
     console.error("Invalid coordinates:", { x1, y1, x2, y2 });
     return [];
   }
-  const [transformedX1, transformedY1] = applyToPoint17(transform, [x1, y1]);
-  const [transformedX2, transformedY2] = applyToPoint17(transform, [x2, y2]);
+  const [transformedX1, transformedY1] = applyToPoint18(transform, [x1, y1]);
+  const [transformedX2, transformedY2] = applyToPoint18(transform, [x2, y2]);
   const transformedStrokeWidth = stroke_width * Math.abs(transform.a);
   const color = layer === "bottom" ? colorMap2.silkscreen.bottom : colorMap2.silkscreen.top;
   return [
@@ -2765,7 +3083,7 @@ function createSvgObjectsFromPcbSilkscreenLine(pcbSilkscreenLine, ctx) {
 }
 
 // lib/pcb/svg-object-fns/create-svg-objects-from-pcb-courtyard-rect.ts
-import { applyToPoint as applyToPoint18 } from "transformation-matrix";
+import { applyToPoint as applyToPoint19 } from "transformation-matrix";
 function createSvgObjectsFromPcbCourtyardRect(pcbCourtyardRect, ctx) {
   const { transform, layer: layerFilter, colorMap: colorMap2 } = ctx;
   const {
@@ -2784,7 +3102,7 @@ function createSvgObjectsFromPcbCourtyardRect(pcbCourtyardRect, ctx) {
     });
     return [];
   }
-  const [transformedX, transformedY] = applyToPoint18(transform, [
+  const [transformedX, transformedY] = applyToPoint19(transform, [
     center.x,
     center.y
   ]);
@@ -2825,66 +3143,7 @@ function pairs(arr) {
 }
 
 // lib/pcb/svg-object-fns/create-svg-objects-from-pcb-trace.ts
-import { applyToPoint as applyToPoint19 } from "transformation-matrix";
-
-// lib/pcb/colors.ts
-var DEFAULT_PCB_COLOR_MAP = {
-  copper: {
-    top: "rgb(200, 52, 52)",
-    inner1: "rgb(255, 140, 0)",
-    inner2: "rgb(255, 215, 0)",
-    inner3: "rgb(50, 205, 50)",
-    inner4: "rgb(64, 224, 208)",
-    inner5: "rgb(138, 43, 226)",
-    inner6: "rgb(255, 105, 180)",
-    bottom: "rgb(77, 127, 196)"
-  },
-  soldermaskWithCopperUnderneath: {
-    top: "rgb(18, 82, 50)",
-    bottom: "rgb(77, 127, 196)"
-  },
-  soldermask: {
-    top: "rgb(12, 55, 33)",
-    bottom: "rgb(12, 55, 33)"
-  },
-  soldermaskOverCopper: {
-    top: "rgb(52, 135, 73)",
-    bottom: "rgb(52, 135, 73)"
-  },
-  substrate: "rgb(201, 162, 110)",
-  // FR4 substrate color (tan/beige)
-  drill: "#FF26E2",
-  silkscreen: {
-    top: "#f2eda1",
-    bottom: "#5da9e9"
-  },
-  boardOutline: "rgba(255, 255, 255, 0.5)",
-  courtyard: "#FF00FF",
-  debugComponent: {
-    fill: null,
-    stroke: null
-  }
-};
-var HOLE_COLOR = DEFAULT_PCB_COLOR_MAP.drill;
-var SILKSCREEN_TOP_COLOR = DEFAULT_PCB_COLOR_MAP.silkscreen.top;
-var SILKSCREEN_BOTTOM_COLOR = DEFAULT_PCB_COLOR_MAP.silkscreen.bottom;
-
-// lib/pcb/layer-name-to-color.ts
-var LAYER_NAME_TO_COLOR = {
-  ...DEFAULT_PCB_COLOR_MAP.copper
-};
-function layerNameToColor(layerName, colorMap2 = DEFAULT_PCB_COLOR_MAP) {
-  return colorMap2.copper[layerName] ?? "white";
-}
-var SOLDER_PASTE_LAYER_NAME_TO_COLOR = {
-  bottom: "rgb(105, 105, 105)",
-  top: "rgb(105, 105, 105)"
-};
-function solderPasteLayerNameToColor(layerName) {
-  return SOLDER_PASTE_LAYER_NAME_TO_COLOR[layerName] ?? "rgb(105, 105, 105)";
-}
-
-// lib/pcb/svg-object-fns/create-svg-objects-from-pcb-trace.ts
+import { applyToPoint as applyToPoint20 } from "transformation-matrix";
 function createSvgObjectsFromPcbTrace(trace, ctx) {
   const { transform, layer: layerFilter, colorMap: colorMap2, showSolderMask } = ctx;
   if (!trace.route || !Array.isArray(trace.route) || trace.route.length < 2)
@@ -2892,8 +3151,8 @@ function createSvgObjectsFromPcbTrace(trace, ctx) {
   const segments = pairs(trace.route);
   const svgObjects = [];
   for (const [start, end] of segments) {
-    const startPoint = applyToPoint19(transform, [start.x, start.y]);
-    const endPoint = applyToPoint19(transform, [end.x, end.y]);
+    const startPoint = applyToPoint20(transform, [start.x, start.y]);
+    const endPoint = applyToPoint20(transform, [end.x, end.y]);
     const layer = "layer" in start ? start.layer : "layer" in end ? end.layer : null;
     if (!layer) continue;
     if (layerFilter && layer !== layerFilter) continue;
@@ -2948,7 +3207,7 @@ function createSvgObjectsFromPcbTrace(trace, ctx) {
 }
 
 // lib/pcb/svg-object-fns/create-svg-objects-from-smt-pads.ts
-import { applyToPoint as applyToPoint20 } from "transformation-matrix";
+import { applyToPoint as applyToPoint21 } from "transformation-matrix";
 function createSvgObjectsFromSmtPad(pad, ctx) {
   const { transform, layer: layerFilter, colorMap: colorMap2, showSolderMask } = ctx;
   if (layerFilter && pad.layer !== layerFilter) return [];
@@ -2959,7 +3218,7 @@ function createSvgObjectsFromSmtPad(pad, 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] = applyToPoint20(transform, [pad.x, pad.y]);
+    const [x, y] = applyToPoint21(transform, [pad.x, pad.y]);
     const cornerRadiusValue = pad.corner_radius ?? pad.rect_border_radius ?? 0;
     const scaledBorderRadius = cornerRadiusValue * Math.abs(transform.a);
     if (pad.shape === "rotated_rect" && pad.ccw_rotation) {
@@ -3201,7 +3460,7 @@ function createSvgObjectsFromSmtPad(pad, ctx) {
     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] = applyToPoint20(transform, [pad.x, pad.y]);
+    const [x, y] = applyToPoint21(transform, [pad.x, pad.y]);
     const rotationTransformAttributes = isRotated ? {
       transform: `translate(${x} ${y}) rotate(${-(pad.ccw_rotation ?? 0)})`
     } : void 0;
@@ -3319,7 +3578,7 @@ function createSvgObjectsFromSmtPad(pad, ctx) {
   }
   if (pad.shape === "circle") {
     const radius = pad.radius * Math.abs(transform.a);
-    const [x, y] = applyToPoint20(transform, [pad.x, pad.y]);
+    const [x, y] = applyToPoint21(transform, [pad.x, pad.y]);
     const padElement = {
       name: "circle",
       type: "element",
@@ -3409,7 +3668,7 @@ function createSvgObjectsFromSmtPad(pad, ctx) {
   }
   if (pad.shape === "polygon") {
     const points = (pad.points ?? []).map(
-      (point) => applyToPoint20(transform, [point.x, point.y])
+      (point) => applyToPoint21(transform, [point.x, point.y])
     );
     const padElement = {
       name: "polygon",
@@ -3434,10 +3693,10 @@ function createSvgObjectsFromSmtPad(pad, ctx) {
       maskPoints = points.map(([px, py]) => {
         const dx = px - centroidX;
         const dy = py - centroidY;
-        const distance3 = Math.sqrt(dx * dx + dy * dy);
-        if (distance3 === 0) return [px, py];
-        const normalizedDx = dx / distance3;
-        const normalizedDy = dy / distance3;
+        const distance4 = Math.sqrt(dx * dx + dy * dy);
+        if (distance4 === 0) return [px, py];
+        const normalizedDx = dx / distance4;
+        const normalizedDy = dy / distance4;
         return [
           px + normalizedDx * soldermaskMargin,
           py + normalizedDy * soldermaskMargin
@@ -3508,190 +3767,513 @@ function createSvgObjectsFromSmtPad(pad, ctx) {
 }
 
 // lib/pcb/svg-object-fns/create-svg-objects-from-pcb-board.ts
-import { applyToPoint as applyToPoint21 } from "transformation-matrix";
-function createSvgObjectsFromPcbBoard(pcbBoard, ctx) {
-  const { transform, colorMap: colorMap2, showSolderMask } = 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] = applyToPoint21(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 = applyToPoint21(transform, [
-      center.x - halfWidth,
-      center.y - halfHeight
-    ]);
-    const topRight = applyToPoint21(transform, [
-      center.x + halfWidth,
-      center.y - halfHeight
-    ]);
-    const bottomRight = applyToPoint21(transform, [
-      center.x + halfWidth,
-      center.y + halfHeight
-    ]);
-    const bottomLeft = applyToPoint21(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 svgObjects = [];
-  if (showSolderMask) {
-    const layer = ctx.layer ?? "top";
-    const maskLayer = layer === "bottom" ? "soldermask-bottom" : "soldermask-top";
-    svgObjects.push({
-      name: "path",
-      type: "element",
-      value: "",
-      children: [],
-      attributes: {
-        class: "pcb-board-soldermask",
-        d: path,
-        fill: colorMap2.soldermask.top,
-        "fill-opacity": "0.8",
-        stroke: "none",
-        "data-type": "pcb_soldermask",
-        "data-pcb-layer": maskLayer
-      }
-    });
-  }
-  svgObjects.push({
-    name: "path",
-    type: "element",
-    value: "",
-    children: [],
-    attributes: {
-      class: "pcb-board",
-      d: path,
-      fill: "none",
-      stroke: colorMap2.boardOutline,
-      "stroke-width": (0.1 * Math.abs(transform.a)).toString(),
-      "data-type": "pcb_board",
-      "data-pcb-layer": "board"
-    }
-  });
-  return svgObjects;
-}
+import { applyToPoint as applyToPoint23 } from "transformation-matrix";
 
-// lib/pcb/svg-object-fns/create-svg-objects-from-pcb-panel.ts
+// lib/utils/create-pcb-component-anchor-offset-indicators.ts
 import { applyToPoint as applyToPoint22 } from "transformation-matrix";
-function createSvgObjectsFromPcbPanel(pcbPanel, ctx) {
-  const { transform, colorMap: colorMap2, showSolderMask } = ctx;
-  const width = Number(pcbPanel.width);
-  const height = Number(pcbPanel.height);
-  const center = pcbPanel.center ?? { x: width / 2, y: height / 2 };
-  const halfWidth = width / 2;
-  const halfHeight = height / 2;
-  const topLeft = applyToPoint22(transform, [
-    center.x - halfWidth,
-    center.y - halfHeight
-  ]);
-  const topRight = applyToPoint22(transform, [
-    center.x + halfWidth,
-    center.y - halfHeight
-  ]);
-  const bottomRight = applyToPoint22(transform, [
-    center.x + halfWidth,
-    center.y + halfHeight
+var OFFSET_THRESHOLD_MM = 0.01;
+var TICK_SIZE_PX = 4;
+var LABEL_GAP_PX = 8;
+var LABEL_FONT_SIZE_PX = 11;
+var STROKE_WIDTH_PX = 1;
+var ANCHOR_MARKER_SIZE_PX = 5;
+var ANCHOR_MARKER_STROKE_WIDTH_PX = 1.5;
+var COMPONENT_GAP_PX = 15;
+var COMPONENT_SIDE_GAP_PX = 10;
+var DISTANCE_MULTIPLIER = 0.2;
+var MAX_OFFSET_PX = 50;
+function createAnchorOffsetIndicators(params) {
+  const {
+    groupAnchorPosition,
+    componentPosition,
+    transform,
+    componentWidth = 0,
+    componentHeight = 0
+  } = params;
+  const objects = [];
+  const [screenGroupAnchorX, screenGroupAnchorY] = applyToPoint22(transform, [
+    groupAnchorPosition.x,
+    groupAnchorPosition.y
   ]);
-  const bottomLeft = applyToPoint22(transform, [
-    center.x - halfWidth,
-    center.y + halfHeight
+  const [screenComponentX, screenComponentY] = applyToPoint22(transform, [
+    componentPosition.x,
+    componentPosition.y
   ]);
-  const path = `M ${topLeft[0]} ${topLeft[1]} L ${topRight[0]} ${topRight[1]} L ${bottomRight[0]} ${bottomRight[1]} L ${bottomLeft[0]} ${bottomLeft[1]} Z`;
-  const isCoveredWithSolderMask = pcbPanel.covered_with_solder_mask !== false;
-  const shouldShowSolderMask = Boolean(
-    showSolderMask && isCoveredWithSolderMask
+  const offsetX = componentPosition.x - groupAnchorPosition.x;
+  const offsetY = componentPosition.y - groupAnchorPosition.y;
+  const scale10 = Math.abs(transform.a);
+  const screenComponentWidth = componentWidth * scale10;
+  const screenComponentHeight = componentHeight * scale10;
+  objects.push(createAnchorMarker(screenGroupAnchorX, screenGroupAnchorY));
+  objects.push({
+    name: "line",
+    type: "element",
+    attributes: {
+      x1: screenGroupAnchorX.toString(),
+      y1: screenGroupAnchorY.toString(),
+      x2: screenComponentX.toString(),
+      y2: screenComponentY.toString(),
+      stroke: "#ffffff",
+      "stroke-width": "0.5",
+      "stroke-dasharray": "3,3",
+      opacity: "0.5",
+      class: "anchor-offset-connector"
+    },
+    children: [],
+    value: ""
+  });
+  objects.push({
+    name: "circle",
+    type: "element",
+    attributes: {
+      cx: screenComponentX.toString(),
+      cy: screenComponentY.toString(),
+      r: "2",
+      fill: "#ffffff",
+      opacity: "0.7",
+      class: "anchor-offset-component-marker"
+    },
+    children: [],
+    value: ""
+  });
+  const yDistance = Math.abs(screenComponentY - screenGroupAnchorY);
+  const xDistance = Math.abs(screenComponentX - screenGroupAnchorX);
+  const totalDistance = Math.sqrt(xDistance * xDistance + yDistance * yDistance);
+  const componentHeightOffset = screenComponentHeight / 2 + COMPONENT_GAP_PX;
+  const dynamicOffset = Math.max(
+    componentHeightOffset,
+    Math.min(MAX_OFFSET_PX, totalDistance * DISTANCE_MULTIPLIER)
   );
-  return [
-    {
-      name: "path",
-      type: "element",
-      value: "",
-      children: [],
-      attributes: {
-        class: "pcb-panel",
-        d: path,
-        fill: "none",
-        stroke: colorMap2.boardOutline,
-        "stroke-width": (0.1 * Math.abs(transform.a)).toString(),
-        "data-type": "pcb_panel",
-        "data-pcb-layer": "board"
-      }
-    }
-  ];
+  const horizontalLineY = offsetY > 0 ? screenComponentY - dynamicOffset : screenComponentY + dynamicOffset;
+  const componentWidthOffset = screenComponentWidth / 2 + COMPONENT_SIDE_GAP_PX;
+  const verticalLineX = offsetX > 0 ? screenComponentX + componentWidthOffset : screenComponentX - componentWidthOffset;
+  if (Math.abs(offsetX) > OFFSET_THRESHOLD_MM) {
+    objects.push(
+      ...createHorizontalDimension({
+        startX: screenGroupAnchorX,
+        endX: screenComponentX,
+        y: horizontalLineY,
+        offsetMm: offsetX,
+        offsetY
+      })
+    );
+  }
+  if (Math.abs(offsetY) > OFFSET_THRESHOLD_MM) {
+    objects.push(
+      ...createVerticalDimension({
+        x: verticalLineX,
+        startY: screenGroupAnchorY,
+        endY: screenComponentY,
+        offsetMm: offsetY,
+        offsetX
+      })
+    );
+  }
+  return objects;
 }
-
-// lib/pcb/svg-object-fns/create-svg-objects-from-pcb-via.ts
-import { applyToPoint as applyToPoint23 } from "transformation-matrix";
-function createSvgObjectsFromPcbVia(hole, ctx) {
-  const { transform, colorMap: colorMap2 } = ctx;
-  const [x, y] = applyToPoint23(transform, [hole.x, hole.y]);
-  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;
+function createAnchorMarker(x, y) {
   return {
     name: "g",
     type: "element",
     attributes: {
-      "data-type": "pcb_via",
-      "data-pcb-layer": "through"
+      class: "anchor-offset-marker",
+      "data-type": "anchor_offset_marker"
     },
     children: [
       {
-        name: "circle",
+        name: "line",
         type: "element",
         attributes: {
-          class: "pcb-hole-outer",
-          fill: colorMap2.copper.top,
-          cx: x.toString(),
-          cy: y.toString(),
-          r: outerRadius.toString(),
-          "data-type": "pcb_via",
-          "data-pcb-layer": "top"
-        }
+          x1: x.toString(),
+          y1: (y - ANCHOR_MARKER_SIZE_PX).toString(),
+          x2: x.toString(),
+          y2: (y + ANCHOR_MARKER_SIZE_PX).toString(),
+          stroke: "#ffffff",
+          "stroke-width": ANCHOR_MARKER_STROKE_WIDTH_PX.toString(),
+          "stroke-linecap": "round"
+        },
+        children: [],
+        value: ""
       },
       {
-        name: "circle",
+        name: "line",
         type: "element",
         attributes: {
-          class: "pcb-hole-inner",
-          fill: colorMap2.drill,
-          cx: x.toString(),
-          cy: y.toString(),
-          r: innerRadius.toString(),
-          "data-type": "pcb_via",
-          "data-pcb-layer": "drill"
-        }
+          x1: (x - ANCHOR_MARKER_SIZE_PX).toString(),
+          y1: y.toString(),
+          x2: (x + ANCHOR_MARKER_SIZE_PX).toString(),
+          y2: y.toString(),
+          stroke: "#ffffff",
+          "stroke-width": ANCHOR_MARKER_STROKE_WIDTH_PX.toString(),
+          "stroke-linecap": "round"
+        },
+        children: [],
+        value: ""
       }
-    ]
+    ],
+    value: ""
   };
 }
-
-// lib/pcb/svg-object-fns/create-svg-objects-from-pcb-hole.ts
-import { applyToPoint as applyToPoint24 } from "transformation-matrix";
-function createSvgObjectsFromPcbHole(hole, ctx) {
-  const { transform, colorMap: colorMap2, showSolderMask } = ctx;
-  const layer = ctx.layer ?? "top";
-  const [x, y] = applyToPoint24(transform, [hole.x, hole.y]);
-  const isCoveredWithSolderMask = Boolean(hole.is_covered_with_solder_mask);
-  const soldermaskMargin = (hole.soldermask_margin ?? 0) * Math.abs(transform.a);
-  const shouldShowSolderMask = showSolderMask && isCoveredWithSolderMask && soldermaskMargin !== 0;
-  const solderMaskColor = colorMap2.soldermask.top;
-  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") {
-      const holeElement2 = {
-        name: "circle",
+function createHorizontalDimension({
+  startX,
+  endX,
+  y,
+  offsetMm,
+  offsetY
+}) {
+  const objects = [];
+  objects.push({
+    name: "line",
+    type: "element",
+    attributes: {
+      x1: startX.toString(),
+      y1: y.toString(),
+      x2: endX.toString(),
+      y2: y.toString(),
+      stroke: "#ffffff",
+      "stroke-width": STROKE_WIDTH_PX.toString(),
+      class: "anchor-offset-dimension-x"
+    },
+    children: [],
+    value: ""
+  });
+  objects.push({
+    name: "line",
+    type: "element",
+    attributes: {
+      x1: startX.toString(),
+      y1: (y - TICK_SIZE_PX).toString(),
+      x2: startX.toString(),
+      y2: (y + TICK_SIZE_PX).toString(),
+      stroke: "#ffffff",
+      "stroke-width": STROKE_WIDTH_PX.toString()
+    },
+    children: [],
+    value: ""
+  });
+  objects.push({
+    name: "line",
+    type: "element",
+    attributes: {
+      x1: endX.toString(),
+      y1: (y - TICK_SIZE_PX).toString(),
+      x2: endX.toString(),
+      y2: (y + TICK_SIZE_PX).toString(),
+      stroke: "#ffffff",
+      "stroke-width": STROKE_WIDTH_PX.toString()
+    },
+    children: [],
+    value: ""
+  });
+  const midX = (startX + endX) / 2;
+  const labelY = offsetY > 0 ? y - TICK_SIZE_PX - LABEL_GAP_PX : y + TICK_SIZE_PX + LABEL_GAP_PX;
+  objects.push({
+    name: "text",
+    type: "element",
+    attributes: {
+      x: midX.toString(),
+      y: labelY.toString(),
+      fill: "#ffffff",
+      "font-size": LABEL_FONT_SIZE_PX.toString(),
+      "font-family": "Arial, sans-serif",
+      "text-anchor": "middle",
+      "dominant-baseline": offsetY > 0 ? "baseline" : "hanging",
+      class: "anchor-offset-label"
+    },
+    children: [
+      {
+        type: "text",
+        value: `X: ${offsetMm.toFixed(2)}mm`,
+        name: "",
+        attributes: {},
+        children: []
+      }
+    ],
+    value: ""
+  });
+  return objects;
+}
+function createVerticalDimension({
+  x,
+  startY,
+  endY,
+  offsetMm,
+  offsetX
+}) {
+  const objects = [];
+  objects.push({
+    name: "line",
+    type: "element",
+    attributes: {
+      x1: x.toString(),
+      y1: startY.toString(),
+      x2: x.toString(),
+      y2: endY.toString(),
+      stroke: "#ffffff",
+      "stroke-width": STROKE_WIDTH_PX.toString(),
+      class: "anchor-offset-dimension-y"
+    },
+    children: [],
+    value: ""
+  });
+  objects.push({
+    name: "line",
+    type: "element",
+    attributes: {
+      x1: (x - TICK_SIZE_PX).toString(),
+      y1: startY.toString(),
+      x2: (x + TICK_SIZE_PX).toString(),
+      y2: startY.toString(),
+      stroke: "#ffffff",
+      "stroke-width": STROKE_WIDTH_PX.toString()
+    },
+    children: [],
+    value: ""
+  });
+  objects.push({
+    name: "line",
+    type: "element",
+    attributes: {
+      x1: (x - TICK_SIZE_PX).toString(),
+      y1: endY.toString(),
+      x2: (x + TICK_SIZE_PX).toString(),
+      y2: endY.toString(),
+      stroke: "#ffffff",
+      "stroke-width": STROKE_WIDTH_PX.toString()
+    },
+    children: [],
+    value: ""
+  });
+  const midY = (startY + endY) / 2;
+  const labelX = offsetX < 0 ? x - TICK_SIZE_PX - 4 : x + TICK_SIZE_PX + 4;
+  objects.push({
+    name: "text",
+    type: "element",
+    attributes: {
+      x: labelX.toString(),
+      y: midY.toString(),
+      fill: "#ffffff",
+      "font-size": LABEL_FONT_SIZE_PX.toString(),
+      "font-family": "Arial, sans-serif",
+      "text-anchor": offsetX < 0 ? "end" : "start",
+      "dominant-baseline": "middle",
+      class: "anchor-offset-label"
+    },
+    children: [
+      {
+        type: "text",
+        value: `Y: ${offsetMm.toFixed(2)}mm`,
+        name: "",
+        attributes: {},
+        children: []
+      }
+    ],
+    value: ""
+  });
+  return objects;
+}
+
+// lib/pcb/svg-object-fns/create-svg-objects-from-pcb-board.ts
+function createSvgObjectsFromPcbBoard(pcbBoard, ctx) {
+  const { transform, colorMap: colorMap2, showSolderMask, circuitJson } = 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] = applyToPoint23(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 = applyToPoint23(transform, [
+      center.x - halfWidth,
+      center.y - halfHeight
+    ]);
+    const topRight = applyToPoint23(transform, [
+      center.x + halfWidth,
+      center.y - halfHeight
+    ]);
+    const bottomRight = applyToPoint23(transform, [
+      center.x + halfWidth,
+      center.y + halfHeight
+    ]);
+    const bottomLeft = applyToPoint23(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 svgObjects = [];
+  if (showSolderMask) {
+    const layer = ctx.layer ?? "top";
+    const maskLayer = layer === "bottom" ? "soldermask-bottom" : "soldermask-top";
+    svgObjects.push({
+      name: "path",
+      type: "element",
+      value: "",
+      children: [],
+      attributes: {
+        class: "pcb-board-soldermask",
+        d: path,
+        fill: colorMap2.soldermask.top,
+        "fill-opacity": "0.8",
+        stroke: "none",
+        "data-type": "pcb_soldermask",
+        "data-pcb-layer": maskLayer
+      }
+    });
+  }
+  svgObjects.push({
+    name: "path",
+    type: "element",
+    value: "",
+    children: [],
+    attributes: {
+      class: "pcb-board",
+      d: path,
+      fill: "none",
+      stroke: colorMap2.boardOutline,
+      "stroke-width": (0.1 * Math.abs(transform.a)).toString(),
+      "data-type": "pcb_board",
+      "data-pcb-layer": "board"
+    }
+  });
+  if (ctx.showAnchorOffsets && circuitJson) {
+    const panel = circuitJson.find(
+      (elm) => elm.type === "pcb_panel"
+    );
+    if (panel) {
+      const panelCenter = panel.center ?? { x: 0, y: 0 };
+      svgObjects.push(
+        ...createAnchorOffsetIndicators({
+          groupAnchorPosition: panelCenter,
+          componentPosition: center,
+          transform,
+          componentWidth: width,
+          componentHeight: height
+        })
+      );
+    }
+  }
+  return svgObjects;
+}
+
+// lib/pcb/svg-object-fns/create-svg-objects-from-pcb-panel.ts
+import { applyToPoint as applyToPoint24 } from "transformation-matrix";
+function createSvgObjectsFromPcbPanel(pcbPanel, ctx) {
+  const { transform, colorMap: colorMap2, showSolderMask } = ctx;
+  const width = Number(pcbPanel.width);
+  const height = Number(pcbPanel.height);
+  const center = pcbPanel.center ?? { x: width / 2, y: height / 2 };
+  const halfWidth = width / 2;
+  const halfHeight = height / 2;
+  const topLeft = applyToPoint24(transform, [
+    center.x - halfWidth,
+    center.y - halfHeight
+  ]);
+  const topRight = applyToPoint24(transform, [
+    center.x + halfWidth,
+    center.y - halfHeight
+  ]);
+  const bottomRight = applyToPoint24(transform, [
+    center.x + halfWidth,
+    center.y + halfHeight
+  ]);
+  const bottomLeft = applyToPoint24(transform, [
+    center.x - halfWidth,
+    center.y + halfHeight
+  ]);
+  const path = `M ${topLeft[0]} ${topLeft[1]} L ${topRight[0]} ${topRight[1]} L ${bottomRight[0]} ${bottomRight[1]} L ${bottomLeft[0]} ${bottomLeft[1]} Z`;
+  const isCoveredWithSolderMask = pcbPanel.covered_with_solder_mask !== false;
+  const shouldShowSolderMask = Boolean(
+    showSolderMask && isCoveredWithSolderMask
+  );
+  return [
+    {
+      name: "path",
+      type: "element",
+      value: "",
+      children: [],
+      attributes: {
+        class: "pcb-panel",
+        d: path,
+        fill: "none",
+        stroke: colorMap2.boardOutline,
+        "stroke-width": (0.1 * Math.abs(transform.a)).toString(),
+        "data-type": "pcb_panel",
+        "data-pcb-layer": "board"
+      }
+    }
+  ];
+}
+
+// lib/pcb/svg-object-fns/create-svg-objects-from-pcb-via.ts
+import { applyToPoint as applyToPoint25 } from "transformation-matrix";
+function createSvgObjectsFromPcbVia(hole, ctx) {
+  const { transform, colorMap: colorMap2 } = ctx;
+  const [x, y] = applyToPoint25(transform, [hole.x, hole.y]);
+  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",
+    attributes: {
+      "data-type": "pcb_via",
+      "data-pcb-layer": "through"
+    },
+    children: [
+      {
+        name: "circle",
+        type: "element",
+        attributes: {
+          class: "pcb-hole-outer",
+          fill: colorMap2.copper.top,
+          cx: x.toString(),
+          cy: y.toString(),
+          r: outerRadius.toString(),
+          "data-type": "pcb_via",
+          "data-pcb-layer": "top"
+        }
+      },
+      {
+        name: "circle",
+        type: "element",
+        attributes: {
+          class: "pcb-hole-inner",
+          fill: colorMap2.drill,
+          cx: x.toString(),
+          cy: y.toString(),
+          r: innerRadius.toString(),
+          "data-type": "pcb_via",
+          "data-pcb-layer": "drill"
+        }
+      }
+    ]
+  };
+}
+
+// lib/pcb/svg-object-fns/create-svg-objects-from-pcb-hole.ts
+import { applyToPoint as applyToPoint26 } from "transformation-matrix";
+function createSvgObjectsFromPcbHole(hole, ctx) {
+  const { transform, colorMap: colorMap2, showSolderMask } = ctx;
+  const layer = ctx.layer ?? "top";
+  const [x, y] = applyToPoint26(transform, [hole.x, hole.y]);
+  const isCoveredWithSolderMask = Boolean(hole.is_covered_with_solder_mask);
+  const soldermaskMargin = (hole.soldermask_margin ?? 0) * Math.abs(transform.a);
+  const shouldShowSolderMask = showSolderMask && isCoveredWithSolderMask && soldermaskMargin !== 0;
+  const solderMaskColor = colorMap2.soldermask.top;
+  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") {
+      const holeElement2 = {
+        name: "circle",
         type: "element",
         attributes: {
           class: "pcb-hole",
@@ -4178,7 +4760,7 @@ import {
   getFullConnectivityMapFromCircuitJson
 } from "circuit-json-to-connectivity-map";
 import "svgson";
-import { applyToPoint as applyToPoint25 } from "transformation-matrix";
+import { applyToPoint as applyToPoint27 } from "transformation-matrix";
 
 // lib/pcb/create-svg-objects-from-pcb-rats-nest/get-element-position.ts
 import { su } from "@tscircuit/circuit-json-util";
@@ -4205,9 +4787,9 @@ var findNearestPointInNet = (sourcePoint, netId, connectivity, circuitJson) => {
     if (pos) {
       const dx = sourcePoint.x - pos.x;
       const dy = sourcePoint.y - pos.y;
-      const distance3 = Math.sqrt(dx * dx + dy * dy);
-      if (distance3 > 0 && distance3 < minDistance) {
-        minDistance = distance3;
+      const distance4 = Math.sqrt(dx * dx + dy * dy);
+      if (distance4 > 0 && distance4 < minDistance) {
+        minDistance = distance4;
         nearestPoint = pos;
       }
     }
@@ -4258,11 +4840,11 @@ function createSvgObjectsForRatsNest(circuitJson, ctx) {
   });
   const svgObjects = [];
   for (const line of ratsNestLines) {
-    const transformedStart = applyToPoint25(transform, [
+    const transformedStart = applyToPoint27(transform, [
       line.startPoint.x,
       line.startPoint.y
     ]);
-    const transformedEnd = applyToPoint25(transform, [
+    const transformedEnd = applyToPoint27(transform, [
       line.endPoint.x,
       line.endPoint.y
     ]);
@@ -4290,17 +4872,17 @@ function createSvgObjectsForRatsNest(circuitJson, ctx) {
 
 // lib/pcb/svg-object-fns/create-svg-objects-from-pcb-cutout.ts
 import {
-  applyToPoint as applyToPoint26,
-  compose as compose3,
-  rotate as rotate3,
-  translate as translate3,
-  toString as matrixToString6
+  applyToPoint as applyToPoint28,
+  compose as compose4,
+  rotate as rotate4,
+  translate as translate4,
+  toString as matrixToString7
 } from "transformation-matrix";
 function createSvgObjectsFromPcbCutout(cutout, ctx) {
   const { transform, colorMap: colorMap2 } = ctx;
   if (cutout.shape === "rect") {
     const rectCutout = cutout;
-    const [cx, cy] = applyToPoint26(transform, [
+    const [cx, cy] = applyToPoint28(transform, [
       rectCutout.center.x,
       rectCutout.center.y
     ]);
@@ -4318,8 +4900,8 @@ function createSvgObjectsFromPcbCutout(cutout, ctx) {
       width: scaledWidth.toString(),
       height: scaledHeight.toString(),
       fill: colorMap2.drill,
-      transform: matrixToString6(
-        compose3(translate3(cx, cy), rotate3(svgRotation * Math.PI / 180))
+      transform: matrixToString7(
+        compose4(translate4(cx, cy), rotate4(svgRotation * Math.PI / 180))
       ),
       "data-type": "pcb_cutout",
       "data-pcb-layer": "drill"
@@ -4342,7 +4924,7 @@ function createSvgObjectsFromPcbCutout(cutout, ctx) {
   }
   if (cutout.shape === "circle") {
     const circleCutout = cutout;
-    const [cx, cy] = applyToPoint26(transform, [
+    const [cx, cy] = applyToPoint28(transform, [
       circleCutout.center.x,
       circleCutout.center.y
     ]);
@@ -4369,7 +4951,7 @@ function createSvgObjectsFromPcbCutout(cutout, ctx) {
     const polygonCutout = cutout;
     if (!polygonCutout.points || polygonCutout.points.length === 0) return [];
     const transformedPoints = polygonCutout.points.map(
-      (p) => applyToPoint26(transform, [p.x, p.y])
+      (p) => applyToPoint28(transform, [p.x, p.y])
     );
     const pointsString = transformedPoints.map((p) => `${p[0]},${p[1]}`).join(" ");
     return [
@@ -4393,19 +4975,19 @@ function createSvgObjectsFromPcbCutout(cutout, ctx) {
 
 // lib/pcb/svg-object-fns/create-svg-objects-from-pcb-copper-pour.ts
 import {
-  applyToPoint as applyToPoint28,
-  compose as compose4,
-  rotate as rotate4,
-  toString as matrixToString7,
-  translate as translate4
+  applyToPoint as applyToPoint30,
+  compose as compose5,
+  rotate as rotate5,
+  toString as matrixToString8,
+  translate as translate5
 } from "transformation-matrix";
 
 // lib/utils/ring-to-path-d.ts
-import { applyToPoint as applyToPoint27 } from "transformation-matrix";
+import { applyToPoint as applyToPoint29 } from "transformation-matrix";
 function ringToPathD(vertices, transform) {
   if (vertices.length === 0) return "";
   const transformedVertices = vertices.map((v) => {
-    const [x, y] = applyToPoint27(transform, [v.x, v.y]);
+    const [x, y] = applyToPoint29(transform, [v.x, v.y]);
     return { ...v, x, y };
   });
   let d = `M ${transformedVertices[0].x} ${transformedVertices[0].y}`;
@@ -4494,7 +5076,7 @@ function createSvgObjectsFromPcbCopperPour(pour, ctx) {
   const maskOverlayColor = layer === "bottom" ? colorMap2.soldermaskOverCopper.bottom : colorMap2.soldermaskOverCopper.top;
   const maskOverlayOpacity = "0.9";
   if (pour.shape === "rect") {
-    const [cx, cy] = applyToPoint28(transform, [pour.center.x, pour.center.y]);
+    const [cx, cy] = applyToPoint30(transform, [pour.center.x, pour.center.y]);
     const scaledWidth = pour.width * Math.abs(transform.a);
     const scaledHeight = pour.height * Math.abs(transform.d);
     const svgRotation = -(pour.rotation ?? 0);
@@ -4503,8 +5085,8 @@ function createSvgObjectsFromPcbCopperPour(pour, ctx) {
       y: (-scaledHeight / 2).toString(),
       width: scaledWidth.toString(),
       height: scaledHeight.toString(),
-      transform: matrixToString7(
-        compose4(translate4(cx, cy), rotate4(svgRotation * Math.PI / 180))
+      transform: matrixToString8(
+        compose5(translate5(cx, cy), rotate5(svgRotation * Math.PI / 180))
       )
     };
     const copperRect = {
@@ -4546,7 +5128,7 @@ function createSvgObjectsFromPcbCopperPour(pour, ctx) {
   if (pour.shape === "polygon") {
     if (!pour.points || pour.points.length === 0) return [];
     const transformedPoints = pour.points.map(
-      (p) => applyToPoint28(transform, [p.x, p.y])
+      (p) => applyToPoint30(transform, [p.x, p.y])
     );
     const pointsString = transformedPoints.map((p) => `${p[0]},${p[1]}`).join(" ");
     const copperPolygon = {
@@ -4632,454 +5214,148 @@ function createSvgObjectsFromPcbCopperPour(pour, ctx) {
 }
 
 // lib/pcb/svg-object-fns/create-svg-objects-for-pcb-grid.ts
-import "svgson";
-var DEFAULT_GRID_LINE_COLOR = "rgba(255, 255, 255, 0.5)";
-var GRID_PATTERN_ID = "pcb-grid-pattern";
-function createSvgObjectsForPcbGrid({
-  grid,
-  svgWidth,
-  svgHeight
-}) {
-  if (!grid) {
-    return {};
-  }
-  const gridLineColor = grid.lineColor ?? DEFAULT_GRID_LINE_COLOR;
-  const gridCellSize = grid.cellSize;
-  const majorCellSize = grid.majorCellSize;
-  const majorLineColor = grid.majorLineColor ?? gridLineColor;
-  if (majorCellSize !== void 0) {
-    if (!gridCellSize || gridCellSize <= 0) {
-      throw new Error("grid.majorCellSize requires a positive grid.cellSize");
-    }
-    if (majorCellSize <= 0) {
-      throw new Error(
-        "grid.majorCellSize must be a positive multiple of grid.cellSize"
-      );
-    }
-    const ratio = majorCellSize / gridCellSize;
-    const nearestInteger = Math.round(ratio);
-    if (!Number.isFinite(ratio) || Math.abs(ratio - nearestInteger) > 1e-6) {
-      throw new Error(
-        "grid.majorCellSize must be a positive multiple of grid.cellSize"
-      );
-    }
-  }
-  if (!gridCellSize || gridCellSize <= 0) {
-    return {};
-  }
-  const hasMajorGrid = majorCellSize !== void 0;
-  const patternChildren = hasMajorGrid ? createMajorGridPatternChildren(
-    gridCellSize,
-    majorCellSize,
-    gridLineColor,
-    majorLineColor
-  ) : [
-    {
-      name: "path",
-      type: "element",
-      value: "",
-      attributes: {
-        d: `M ${gridCellSize} 0 L 0 0 0 ${gridCellSize}`,
-        fill: "none",
-        stroke: gridLineColor,
-        "stroke-width": "1",
-        "shape-rendering": "crispEdges"
-      },
-      children: []
-    }
-  ];
-  const defs = {
-    name: "defs",
-    type: "element",
-    value: "",
-    attributes: {},
-    children: [
-      {
-        name: "pattern",
-        type: "element",
-        value: "",
-        attributes: {
-          id: GRID_PATTERN_ID,
-          width: hasMajorGrid ? majorCellSize.toString() : gridCellSize.toString(),
-          height: hasMajorGrid ? majorCellSize.toString() : gridCellSize.toString(),
-          patternUnits: "userSpaceOnUse"
-        },
-        children: patternChildren
-      }
-    ]
-  };
-  const rect = {
-    name: "rect",
-    type: "element",
-    value: "",
-    attributes: {
-      x: "0",
-      y: "0",
-      width: svgWidth.toString(),
-      height: svgHeight.toString(),
-      fill: `url(#${GRID_PATTERN_ID})`,
-      "pointer-events": "none",
-      "data-type": "pcb_grid",
-      "data-pcb-layer": "global"
-    },
-    children: []
-  };
-  return { defs, rect };
-}
-function createMajorGridPatternChildren(cellSize, majorCellSize, lineColor, majorLineColor) {
-  const children = [];
-  const steps = Math.round(majorCellSize / cellSize);
-  for (let step = 0; step < steps; step += 1) {
-    const offset = Number((step * cellSize).toFixed(6));
-    const offsetString = offset.toString();
-    const color = step === 0 ? majorLineColor : lineColor;
-    const majorSizeString = majorCellSize.toString();
-    children.push({
-      name: "line",
-      type: "element",
-      value: "",
-      attributes: {
-        x1: offsetString,
-        y1: "0",
-        x2: offsetString,
-        y2: majorSizeString,
-        stroke: color,
-        "stroke-width": "1",
-        "shape-rendering": "crispEdges"
-      },
-      children: []
-    });
-    children.push({
-      name: "line",
+import "svgson";
+var DEFAULT_GRID_LINE_COLOR = "rgba(255, 255, 255, 0.5)";
+var GRID_PATTERN_ID = "pcb-grid-pattern";
+function createSvgObjectsForPcbGrid({
+  grid,
+  svgWidth,
+  svgHeight
+}) {
+  if (!grid) {
+    return {};
+  }
+  const gridLineColor = grid.lineColor ?? DEFAULT_GRID_LINE_COLOR;
+  const gridCellSize = grid.cellSize;
+  const majorCellSize = grid.majorCellSize;
+  const majorLineColor = grid.majorLineColor ?? gridLineColor;
+  if (majorCellSize !== void 0) {
+    if (!gridCellSize || gridCellSize <= 0) {
+      throw new Error("grid.majorCellSize requires a positive grid.cellSize");
+    }
+    if (majorCellSize <= 0) {
+      throw new Error(
+        "grid.majorCellSize must be a positive multiple of grid.cellSize"
+      );
+    }
+    const ratio = majorCellSize / gridCellSize;
+    const nearestInteger = Math.round(ratio);
+    if (!Number.isFinite(ratio) || Math.abs(ratio - nearestInteger) > 1e-6) {
+      throw new Error(
+        "grid.majorCellSize must be a positive multiple of grid.cellSize"
+      );
+    }
+  }
+  if (!gridCellSize || gridCellSize <= 0) {
+    return {};
+  }
+  const hasMajorGrid = majorCellSize !== void 0;
+  const patternChildren = hasMajorGrid ? createMajorGridPatternChildren(
+    gridCellSize,
+    majorCellSize,
+    gridLineColor,
+    majorLineColor
+  ) : [
+    {
+      name: "path",
       type: "element",
       value: "",
       attributes: {
-        x1: "0",
-        y1: offsetString,
-        x2: majorSizeString,
-        y2: offsetString,
-        stroke: color,
+        d: `M ${gridCellSize} 0 L 0 0 0 ${gridCellSize}`,
+        fill: "none",
+        stroke: gridLineColor,
         "stroke-width": "1",
         "shape-rendering": "crispEdges"
       },
       children: []
-    });
-  }
-  return children;
-}
-
-// lib/pcb/svg-object-fns/create-svg-objects-from-pcb-component.ts
-import { applyToPoint as applyToPoint30 } from "transformation-matrix";
-
-// lib/utils/create-pcb-component-anchor-offset-indicators.ts
-import { applyToPoint as applyToPoint29 } from "transformation-matrix";
-var OFFSET_THRESHOLD_MM = 0.01;
-var TICK_SIZE_PX = 4;
-var LABEL_GAP_PX = 8;
-var LABEL_FONT_SIZE_PX = 11;
-var STROKE_WIDTH_PX = 1;
-var ANCHOR_MARKER_SIZE_PX = 5;
-var ANCHOR_MARKER_STROKE_WIDTH_PX = 1.5;
-var COMPONENT_GAP_PX = 15;
-var COMPONENT_SIDE_GAP_PX = 10;
-var DISTANCE_MULTIPLIER = 0.2;
-var MAX_OFFSET_PX = 50;
-function createAnchorOffsetIndicators(params) {
-  const {
-    groupAnchorPosition,
-    componentPosition,
-    transform,
-    componentWidth = 0,
-    componentHeight = 0
-  } = params;
-  const objects = [];
-  const [screenGroupAnchorX, screenGroupAnchorY] = applyToPoint29(transform, [
-    groupAnchorPosition.x,
-    groupAnchorPosition.y
-  ]);
-  const [screenComponentX, screenComponentY] = applyToPoint29(transform, [
-    componentPosition.x,
-    componentPosition.y
-  ]);
-  const offsetX = componentPosition.x - groupAnchorPosition.x;
-  const offsetY = componentPosition.y - groupAnchorPosition.y;
-  const scale9 = Math.abs(transform.a);
-  const screenComponentWidth = componentWidth * scale9;
-  const screenComponentHeight = componentHeight * scale9;
-  objects.push(createAnchorMarker(screenGroupAnchorX, screenGroupAnchorY));
-  objects.push({
-    name: "line",
-    type: "element",
-    attributes: {
-      x1: screenGroupAnchorX.toString(),
-      y1: screenGroupAnchorY.toString(),
-      x2: screenComponentX.toString(),
-      y2: screenComponentY.toString(),
-      stroke: "#ffffff",
-      "stroke-width": "0.5",
-      "stroke-dasharray": "3,3",
-      opacity: "0.5",
-      class: "anchor-offset-connector"
-    },
-    children: [],
-    value: ""
-  });
-  objects.push({
-    name: "circle",
-    type: "element",
-    attributes: {
-      cx: screenComponentX.toString(),
-      cy: screenComponentY.toString(),
-      r: "2",
-      fill: "#ffffff",
-      opacity: "0.7",
-      class: "anchor-offset-component-marker"
-    },
-    children: [],
-    value: ""
-  });
-  const yDistance = Math.abs(screenComponentY - screenGroupAnchorY);
-  const xDistance = Math.abs(screenComponentX - screenGroupAnchorX);
-  const totalDistance = Math.sqrt(xDistance * xDistance + yDistance * yDistance);
-  const componentHeightOffset = screenComponentHeight / 2 + COMPONENT_GAP_PX;
-  const dynamicOffset = Math.max(
-    componentHeightOffset,
-    Math.min(MAX_OFFSET_PX, totalDistance * DISTANCE_MULTIPLIER)
-  );
-  const horizontalLineY = offsetY > 0 ? screenComponentY - dynamicOffset : screenComponentY + dynamicOffset;
-  const componentWidthOffset = screenComponentWidth / 2 + COMPONENT_SIDE_GAP_PX;
-  const verticalLineX = offsetX > 0 ? screenComponentX + componentWidthOffset : screenComponentX - componentWidthOffset;
-  if (Math.abs(offsetX) > OFFSET_THRESHOLD_MM) {
-    objects.push(
-      ...createHorizontalDimension({
-        startX: screenGroupAnchorX,
-        endX: screenComponentX,
-        y: horizontalLineY,
-        offsetMm: offsetX,
-        offsetY
-      })
-    );
-  }
-  if (Math.abs(offsetY) > OFFSET_THRESHOLD_MM) {
-    objects.push(
-      ...createVerticalDimension({
-        x: verticalLineX,
-        startY: screenGroupAnchorY,
-        endY: screenComponentY,
-        offsetMm: -offsetY,
-        offsetX
-      })
-    );
-  }
-  return objects;
-}
-function createAnchorMarker(x, y) {
-  return {
-    name: "g",
-    type: "element",
-    attributes: {
-      class: "anchor-offset-marker",
-      "data-type": "anchor_offset_marker"
-    },
-    children: [
-      {
-        name: "line",
-        type: "element",
-        attributes: {
-          x1: x.toString(),
-          y1: (y - ANCHOR_MARKER_SIZE_PX).toString(),
-          x2: x.toString(),
-          y2: (y + ANCHOR_MARKER_SIZE_PX).toString(),
-          stroke: "#ffffff",
-          "stroke-width": ANCHOR_MARKER_STROKE_WIDTH_PX.toString(),
-          "stroke-linecap": "round"
-        },
-        children: [],
-        value: ""
-      },
-      {
-        name: "line",
-        type: "element",
-        attributes: {
-          x1: (x - ANCHOR_MARKER_SIZE_PX).toString(),
-          y1: y.toString(),
-          x2: (x + ANCHOR_MARKER_SIZE_PX).toString(),
-          y2: y.toString(),
-          stroke: "#ffffff",
-          "stroke-width": ANCHOR_MARKER_STROKE_WIDTH_PX.toString(),
-          "stroke-linecap": "round"
-        },
-        children: [],
-        value: ""
-      }
-    ],
-    value: ""
-  };
-}
-function createHorizontalDimension({
-  startX,
-  endX,
-  y,
-  offsetMm,
-  offsetY
-}) {
-  const objects = [];
-  objects.push({
-    name: "line",
-    type: "element",
-    attributes: {
-      x1: startX.toString(),
-      y1: y.toString(),
-      x2: endX.toString(),
-      y2: y.toString(),
-      stroke: "#ffffff",
-      "stroke-width": STROKE_WIDTH_PX.toString(),
-      class: "anchor-offset-dimension-x"
-    },
-    children: [],
-    value: ""
-  });
-  objects.push({
-    name: "line",
-    type: "element",
-    attributes: {
-      x1: startX.toString(),
-      y1: (y - TICK_SIZE_PX).toString(),
-      x2: startX.toString(),
-      y2: (y + TICK_SIZE_PX).toString(),
-      stroke: "#ffffff",
-      "stroke-width": STROKE_WIDTH_PX.toString()
-    },
-    children: [],
-    value: ""
-  });
-  objects.push({
-    name: "line",
-    type: "element",
-    attributes: {
-      x1: endX.toString(),
-      y1: (y - TICK_SIZE_PX).toString(),
-      x2: endX.toString(),
-      y2: (y + TICK_SIZE_PX).toString(),
-      stroke: "#ffffff",
-      "stroke-width": STROKE_WIDTH_PX.toString()
-    },
-    children: [],
-    value: ""
-  });
-  const midX = (startX + endX) / 2;
-  const labelY = offsetY > 0 ? y - TICK_SIZE_PX - LABEL_GAP_PX : y + TICK_SIZE_PX + LABEL_GAP_PX;
-  objects.push({
-    name: "text",
+    }
+  ];
+  const defs = {
+    name: "defs",
     type: "element",
-    attributes: {
-      x: midX.toString(),
-      y: labelY.toString(),
-      fill: "#ffffff",
-      "font-size": LABEL_FONT_SIZE_PX.toString(),
-      "font-family": "Arial, sans-serif",
-      "text-anchor": "middle",
-      "dominant-baseline": offsetY > 0 ? "baseline" : "hanging",
-      class: "anchor-offset-label"
-    },
+    value: "",
+    attributes: {},
     children: [
       {
-        type: "text",
-        value: `X: ${offsetMm.toFixed(2)}mm`,
-        name: "",
-        attributes: {},
-        children: []
+        name: "pattern",
+        type: "element",
+        value: "",
+        attributes: {
+          id: GRID_PATTERN_ID,
+          width: hasMajorGrid ? majorCellSize.toString() : gridCellSize.toString(),
+          height: hasMajorGrid ? majorCellSize.toString() : gridCellSize.toString(),
+          patternUnits: "userSpaceOnUse"
+        },
+        children: patternChildren
       }
-    ],
-    value: ""
-  });
-  return objects;
-}
-function createVerticalDimension({
-  x,
-  startY,
-  endY,
-  offsetMm,
-  offsetX
-}) {
-  const objects = [];
-  objects.push({
-    name: "line",
-    type: "element",
-    attributes: {
-      x1: x.toString(),
-      y1: startY.toString(),
-      x2: x.toString(),
-      y2: endY.toString(),
-      stroke: "#ffffff",
-      "stroke-width": STROKE_WIDTH_PX.toString(),
-      class: "anchor-offset-dimension-y"
-    },
-    children: [],
-    value: ""
-  });
-  objects.push({
-    name: "line",
-    type: "element",
-    attributes: {
-      x1: (x - TICK_SIZE_PX).toString(),
-      y1: startY.toString(),
-      x2: (x + TICK_SIZE_PX).toString(),
-      y2: startY.toString(),
-      stroke: "#ffffff",
-      "stroke-width": STROKE_WIDTH_PX.toString()
-    },
-    children: [],
-    value: ""
-  });
-  objects.push({
-    name: "line",
-    type: "element",
-    attributes: {
-      x1: (x - TICK_SIZE_PX).toString(),
-      y1: endY.toString(),
-      x2: (x + TICK_SIZE_PX).toString(),
-      y2: endY.toString(),
-      stroke: "#ffffff",
-      "stroke-width": STROKE_WIDTH_PX.toString()
-    },
-    children: [],
-    value: ""
-  });
-  const midY = (startY + endY) / 2;
-  const labelX = offsetX < 0 ? x - TICK_SIZE_PX - 4 : x + TICK_SIZE_PX + 4;
-  objects.push({
-    name: "text",
+    ]
+  };
+  const rect = {
+    name: "rect",
     type: "element",
+    value: "",
     attributes: {
-      x: labelX.toString(),
-      y: midY.toString(),
-      fill: "#ffffff",
-      "font-size": LABEL_FONT_SIZE_PX.toString(),
-      "font-family": "Arial, sans-serif",
-      "text-anchor": offsetX < 0 ? "end" : "start",
-      "dominant-baseline": "middle",
-      class: "anchor-offset-label"
+      x: "0",
+      y: "0",
+      width: svgWidth.toString(),
+      height: svgHeight.toString(),
+      fill: `url(#${GRID_PATTERN_ID})`,
+      "pointer-events": "none",
+      "data-type": "pcb_grid",
+      "data-pcb-layer": "global"
     },
-    children: [
-      {
-        type: "text",
-        value: `Y: ${offsetMm.toFixed(2)}mm`,
-        name: "",
-        attributes: {},
-        children: []
-      }
-    ],
-    value: ""
-  });
-  return objects;
+    children: []
+  };
+  return { defs, rect };
+}
+function createMajorGridPatternChildren(cellSize, majorCellSize, lineColor, majorLineColor) {
+  const children = [];
+  const steps = Math.round(majorCellSize / cellSize);
+  for (let step = 0; step < steps; step += 1) {
+    const offset = Number((step * cellSize).toFixed(6));
+    const offsetString = offset.toString();
+    const color = step === 0 ? majorLineColor : lineColor;
+    const majorSizeString = majorCellSize.toString();
+    children.push({
+      name: "line",
+      type: "element",
+      value: "",
+      attributes: {
+        x1: offsetString,
+        y1: "0",
+        x2: offsetString,
+        y2: majorSizeString,
+        stroke: color,
+        "stroke-width": "1",
+        "shape-rendering": "crispEdges"
+      },
+      children: []
+    });
+    children.push({
+      name: "line",
+      type: "element",
+      value: "",
+      attributes: {
+        x1: "0",
+        y1: offsetString,
+        x2: majorSizeString,
+        y2: offsetString,
+        stroke: color,
+        "stroke-width": "1",
+        "shape-rendering": "crispEdges"
+      },
+      children: []
+    });
+  }
+  return children;
 }
 
 // lib/pcb/svg-object-fns/create-svg-objects-from-pcb-component.ts
+import { applyToPoint as applyToPoint31 } from "transformation-matrix";
 function createSvgObjectsFromPcbComponent(component, ctx) {
   const { transform, circuitJson } = ctx;
   const { center, width, height, rotation = 0 } = component;
-  const [x, y] = applyToPoint30(transform, [center.x, center.y]);
+  const [x, y] = applyToPoint31(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}) scale(1, -1)`;
@@ -5134,7 +5410,7 @@ function createSvgObjectsFromPcbComponent(component, ctx) {
 }
 
 // lib/pcb/svg-object-fns/create-svg-objects-from-pcb-group.ts
-import { applyToPoint as applyToPoint31 } from "transformation-matrix";
+import { applyToPoint as applyToPoint32 } from "transformation-matrix";
 var DEFAULT_GROUP_COLOR = "rgba(100, 200, 255, 0.6)";
 var DEFAULT_STROKE_WIDTH = 0.1;
 function createSvgObjectsFromPcbGroup(pcbGroup, ctx) {
@@ -5161,7 +5437,7 @@ function createSvgObjectsFromPcbGroup(pcbGroup, ctx) {
     (point) => point && typeof point.x === "number" && typeof point.y === "number"
   )) {
     const path = outline.map((point, index) => {
-      const [x, y] = applyToPoint31(transform, [point.x, point.y]);
+      const [x, y] = applyToPoint32(transform, [point.x, point.y]);
       return index === 0 ? `M ${x} ${y}` : `L ${x} ${y}`;
     }).join(" ");
     return [
@@ -5183,11 +5459,11 @@ function createSvgObjectsFromPcbGroup(pcbGroup, ctx) {
   }
   const halfWidth = width / 2;
   const halfHeight = height / 2;
-  const [topLeftX, topLeftY] = applyToPoint31(transform, [
+  const [topLeftX, topLeftY] = applyToPoint32(transform, [
     center.x - halfWidth,
     center.y + halfHeight
   ]);
-  const [bottomRightX, bottomRightY] = applyToPoint31(transform, [
+  const [bottomRightX, bottomRightY] = applyToPoint32(transform, [
     center.x + halfWidth,
     center.y - halfHeight
   ]);
@@ -5223,7 +5499,7 @@ function getSoftwareUsedString(circuitJson) {
 var package_default = {
   name: "circuit-to-svg",
   type: "module",
-  version: "0.0.282",
+  version: "0.0.284",
   description: "Convert Circuit JSON to SVG",
   main: "dist/index.js",
   files: [
@@ -5241,22 +5517,26 @@ var package_default = {
   license: "ISC",
   devDependencies: {
     "@biomejs/biome": "^1.9.4",
+    "@tscircuit/alphabet": "^0.0.8",
     "@types/bun": "^1.2.8",
     "@vitejs/plugin-react": "5.0.0",
     biome: "^0.3.3",
     "bun-match-svg": "^0.0.12",
+    "circuit-json": "^0.0.327",
     esbuild: "^0.20.2",
     "performance-now": "^2.1.0",
-    "circuit-json": "^0.0.319",
     react: "19.1.0",
     "react-cosmos": "7.0.0",
     "react-cosmos-plugin-vite": "7.0.0",
     "react-dom": "19.1.0",
-    tscircuit: "^0.0.937",
+    tscircuit: "^0.0.1018",
     tsup: "^8.0.2",
     typescript: "^5.4.5",
     "vite-tsconfig-paths": "^5.0.1"
   },
+  peerDependencies: {
+    "@tscircuit/alphabet": "*"
+  },
   dependencies: {
     "@types/node": "^22.5.5",
     "bun-types": "^1.1.40",
@@ -5452,8 +5732,8 @@ function convertCircuitJsonToPcbSvg(circuitJson, options) {
   for (const circuitJsonElm of circuitJson) {
     if (circuitJsonElm.type === "pcb_panel") {
       const panel = circuitJsonElm;
-      const width = distance.parse(panel.width);
-      const height = distance.parse(panel.height);
+      const width = distance2.parse(panel.width);
+      const height = distance2.parse(panel.height);
       if (width === void 0 || height === void 0) {
         continue;
       }
@@ -5480,7 +5760,7 @@ function convertCircuitJsonToPcbSvg(circuitJson, options) {
       if (pad.shape === "rect" || pad.shape === "rotated_rect" || pad.shape === "pill") {
         updateBounds({ x: pad.x, y: pad.y }, pad.width, pad.height);
       } else if (pad.shape === "circle") {
-        const radius = distance.parse(pad.radius);
+        const radius = distance2.parse(pad.radius);
         if (radius !== void 0) {
           updateBounds({ x: pad.x, y: pad.y }, radius * 2, radius * 2);
         }
@@ -5502,7 +5782,7 @@ function convertCircuitJsonToPcbSvg(circuitJson, options) {
       if (cutout.shape === "rect") {
         updateBounds(cutout.center, cutout.width, cutout.height);
       } else if (cutout.shape === "circle") {
-        const radius = distance.parse(cutout.radius);
+        const radius = distance2.parse(cutout.radius);
         if (radius !== void 0) {
           updateBounds(cutout.center, radius * 2, radius * 2);
         }
@@ -5511,6 +5791,8 @@ function convertCircuitJsonToPcbSvg(circuitJson, options) {
       }
     } else if (circuitJsonElm.type === "pcb_silkscreen_text" || circuitJsonElm.type === "pcb_silkscreen_rect" || circuitJsonElm.type === "pcb_silkscreen_circle" || circuitJsonElm.type === "pcb_silkscreen_line") {
       updateSilkscreenBounds(circuitJsonElm);
+    } else if (circuitJsonElm.type === "pcb_copper_text") {
+      updateBounds(circuitJsonElm.anchor_position, 0, 0);
     } else if (circuitJsonElm.type === "pcb_copper_pour") {
       if (circuitJsonElm.shape === "rect") {
         updateBounds(
@@ -5557,12 +5839,12 @@ function convertCircuitJsonToPcbSvg(circuitJson, options) {
   const scaleFactor = Math.min(scaleX, scaleY);
   const offsetX = (svgWidth - circuitWidth * scaleFactor) / 2;
   const offsetY = (svgHeight - circuitHeight * scaleFactor) / 2;
-  const transform = compose5(
-    translate5(
+  const transform = compose6(
+    translate6(
       offsetX - boundsMinX * scaleFactor + padding * scaleFactor,
       svgHeight - offsetY + boundsMinY * scaleFactor - padding * scaleFactor
     ),
-    scale2(scaleFactor, -scaleFactor)
+    scale3(scaleFactor, -scaleFactor)
     // Flip in y-direction
   );
   const ctx = {
@@ -5678,11 +5960,11 @@ function convertCircuitJsonToPcbSvg(circuitJson, options) {
   }
   function updateBounds(center, width, height) {
     if (!center) return;
-    const centerX = distance.parse(center.x);
-    const centerY = distance.parse(center.y);
+    const centerX = distance2.parse(center.x);
+    const centerY = distance2.parse(center.y);
     if (centerX === void 0 || centerY === void 0) return;
-    const numericWidth = distance.parse(width) ?? 0;
-    const numericHeight = distance.parse(height) ?? 0;
+    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);
@@ -5693,11 +5975,11 @@ function convertCircuitJsonToPcbSvg(circuitJson, options) {
   }
   function updateBoardBounds(center, width, height) {
     if (!center) return;
-    const centerX = distance.parse(center.x);
-    const centerY = distance.parse(center.y);
+    const centerX = distance2.parse(center.x);
+    const centerY = distance2.parse(center.y);
     if (centerX === void 0 || centerY === void 0) return;
-    const numericWidth = distance.parse(width) ?? 0;
-    const numericHeight = distance.parse(height) ?? 0;
+    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);
@@ -5710,8 +5992,8 @@ function convertCircuitJsonToPcbSvg(circuitJson, options) {
   function updateBoundsToIncludeOutline(outline) {
     let updated = false;
     for (const point of outline) {
-      const x = distance.parse(point.x);
-      const y = distance.parse(point.y);
+      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);
@@ -5726,8 +6008,8 @@ function convertCircuitJsonToPcbSvg(circuitJson, options) {
   function updateBoardBoundsToIncludeOutline(outline) {
     let updated = false;
     for (const point of outline) {
-      const x = distance.parse(point.x);
-      const y = distance.parse(point.y);
+      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);
@@ -5743,8 +6025,8 @@ function convertCircuitJsonToPcbSvg(circuitJson, options) {
   function updateTraceBounds(route) {
     let updated = false;
     for (const point of route) {
-      const x = distance.parse(point?.x);
-      const y = distance.parse(point?.y);
+      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);
@@ -5764,7 +6046,7 @@ function convertCircuitJsonToPcbSvg(circuitJson, options) {
     } else if (item.type === "pcb_silkscreen_rect") {
       updateBounds(item.center, item.width, item.height);
     } else if (item.type === "pcb_silkscreen_circle") {
-      const radius = distance.parse(item.radius);
+      const radius = distance2.parse(item.radius);
       if (radius !== void 0) {
         updateBounds(item.center, radius * 2, radius * 2);
       }
@@ -5776,7 +6058,7 @@ function convertCircuitJsonToPcbSvg(circuitJson, options) {
       if (cutout.shape === "rect") {
         updateBounds(cutout.center, cutout.width, cutout.height);
       } else if (cutout.shape === "circle") {
-        const radius = distance.parse(cutout.radius);
+        const radius = distance2.parse(cutout.radius);
         if (radius !== void 0) {
           updateBounds(cutout.center, radius * 2, radius * 2);
         }
@@ -5822,6 +6104,8 @@ function createSvgObjects({
       return createSvgObjectsFromPcbSilkscreenCircle(elm, ctx);
     case "pcb_silkscreen_line":
       return createSvgObjectsFromPcbSilkscreenLine(elm, ctx);
+    case "pcb_copper_text":
+      return createSvgObjectsFromPcbCopperText(elm, ctx);
     case "pcb_courtyard_rect":
       if (!ctx.showCourtyards) return [];
       return createSvgObjectsFromPcbCourtyardRect(elm, ctx);
@@ -5860,8 +6144,8 @@ function createSvgObjects({
   }
 }
 function createSvgObjectFromPcbBoundary(transform, minX, minY, maxX, maxY) {
-  const [x1, y1] = applyToPoint32(transform, [minX, minY]);
-  const [x2, y2] = applyToPoint32(transform, [maxX, maxY]);
+  const [x1, y1] = applyToPoint33(transform, [minX, minY]);
+  const [x2, y2] = applyToPoint33(transform, [maxX, maxY]);
   const width = Math.abs(x2 - x1);
   const height = Math.abs(y2 - y1);
   const x = Math.min(x1, x2);
@@ -5891,14 +6175,14 @@ var circuitJsonToPcbSvg = convertCircuitJsonToPcbSvg;
 import { stringify as stringify2 } from "svgson";
 import { su as su3 } from "@tscircuit/circuit-json-util";
 import {
-  applyToPoint as applyToPoint39,
-  compose as compose6,
-  scale as scale3,
-  translate as translate6
+  applyToPoint as applyToPoint40,
+  compose as compose7,
+  scale as scale4,
+  translate as translate7
 } from "transformation-matrix";
 
 // lib/assembly/svg-object-fns/create-svg-objects-from-assembly-board.ts
-import { applyToPoint as applyToPoint33 } from "transformation-matrix";
+import { applyToPoint as applyToPoint34 } from "transformation-matrix";
 var DEFAULT_BOARD_STYLE = {
   fill: "none",
   stroke: "rgb(0,0,0)",
@@ -5910,25 +6194,25 @@ function createSvgObjectsFromAssemblyBoard(pcbBoard, transform, style = {}) {
   let path;
   if (outline && Array.isArray(outline) && outline.length >= 3) {
     path = outline.map((point, index) => {
-      const [x, y] = applyToPoint33(transform, [point.x, point.y]);
+      const [x, y] = applyToPoint34(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 = applyToPoint33(transform, [
+    const topLeft = applyToPoint34(transform, [
       center.x - halfWidth,
       center.y - halfHeight
     ]);
-    const topRight = applyToPoint33(transform, [
+    const topRight = applyToPoint34(transform, [
       center.x + halfWidth,
       center.y - halfHeight
     ]);
-    const bottomRight = applyToPoint33(transform, [
+    const bottomRight = applyToPoint34(transform, [
       center.x + halfWidth,
       center.y + halfHeight
     ]);
-    const bottomLeft = applyToPoint33(transform, [
+    const bottomLeft = applyToPoint34(transform, [
       center.x - halfWidth,
       center.y + halfHeight
     ]);
@@ -5954,7 +6238,7 @@ function createSvgObjectsFromAssemblyBoard(pcbBoard, transform, style = {}) {
 }
 
 // lib/assembly/svg-object-fns/create-svg-objects-from-assembly-component.ts
-import { applyToPoint as applyToPoint35 } from "transformation-matrix";
+import { applyToPoint as applyToPoint36 } from "transformation-matrix";
 
 // lib/utils/get-sch-font-size.ts
 import "transformation-matrix";
@@ -5980,8 +6264,8 @@ function createSvgObjectsFromAssemblyComponent(params, ctx) {
   const { center, width, height, rotation = 0, layer = "top" } = elm;
   if (!center || typeof width !== "number" || typeof height !== "number")
     return null;
-  const [x, y] = applyToPoint35(transform, [center.x, center.y]);
-  const [pinX, pinY] = applyToPoint35(transform, [portPosition.x, portPosition.y]);
+  const [x, y] = applyToPoint36(transform, [center.x, center.y]);
+  const [pinX, pinY] = applyToPoint36(transform, [portPosition.x, portPosition.y]);
   const scaledWidth = width * Math.abs(transform.a);
   const scaledHeight = height * Math.abs(transform.d);
   const isTopLayer = layer === "top";
@@ -6143,11 +6427,11 @@ function getRectPathData(w, h, rotation) {
 }
 
 // lib/assembly/svg-object-fns/create-svg-objects-from-assembly-hole.ts
-import { applyToPoint as applyToPoint36 } from "transformation-matrix";
+import { applyToPoint as applyToPoint37 } from "transformation-matrix";
 var HOLE_COLOR2 = "rgb(190, 190, 190)";
 function createSvgObjectsFromAssemblyHole(hole, ctx) {
   const { transform } = ctx;
-  const [x, y] = applyToPoint36(transform, [hole.x, hole.y]);
+  const [x, y] = applyToPoint37(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;
@@ -6211,12 +6495,12 @@ function createSvgObjectsFromAssemblyHole(hole, ctx) {
 }
 
 // lib/assembly/svg-object-fns/create-svg-objects-from-assembly-plated-hole.ts
-import { applyToPoint as applyToPoint37 } from "transformation-matrix";
+import { applyToPoint as applyToPoint38 } from "transformation-matrix";
 var PAD_COLOR = "rgb(210, 210, 210)";
 var HOLE_COLOR3 = "rgb(190, 190, 190)";
 function createSvgObjectsFromAssemblyPlatedHole(hole, ctx) {
   const { transform } = ctx;
-  const [x, y] = applyToPoint37(transform, [hole.x, hole.y]);
+  const [x, y] = applyToPoint38(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);
@@ -6311,7 +6595,7 @@ function createSvgObjectsFromAssemblyPlatedHole(hole, ctx) {
     const scaledRectPadHeight = circularHole.rect_pad_height * Math.abs(transform.a);
     const scaledRectBorderRadius = (circularHole.rect_border_radius ?? 0) * Math.abs(transform.a);
     const holeRadius = scaledHoleDiameter / 2;
-    const [holeCx, holeCy] = applyToPoint37(transform, [
+    const [holeCx, holeCy] = applyToPoint38(transform, [
       circularHole.x + circularHole.hole_offset_x,
       circularHole.y + circularHole.hole_offset_y
     ]);
@@ -6369,7 +6653,7 @@ function createSvgObjectsFromAssemblyPlatedHole(hole, ctx) {
     const pillHoleWithOffsets = pillHole;
     const holeOffsetX = pillHoleWithOffsets.hole_offset_x ?? 0;
     const holeOffsetY = pillHoleWithOffsets.hole_offset_y ?? 0;
-    const [holeCenterX, holeCenterY] = applyToPoint37(transform, [
+    const [holeCenterX, holeCenterY] = applyToPoint38(transform, [
       pillHole.x + holeOffsetX,
       pillHole.y + holeOffsetY
     ]);
@@ -6431,7 +6715,7 @@ function createSvgObjectsFromAssemblyPlatedHole(hole, ctx) {
     const rotatedHoleWithOffsets = rotatedHole;
     const holeOffsetX = rotatedHoleWithOffsets.hole_offset_x ?? 0;
     const holeOffsetY = rotatedHoleWithOffsets.hole_offset_y ?? 0;
-    const [holeCenterX, holeCenterY] = applyToPoint37(transform, [
+    const [holeCenterX, holeCenterY] = applyToPoint38(transform, [
       rotatedHole.x + holeOffsetX,
       rotatedHole.y + holeOffsetY
     ]);
@@ -6487,14 +6771,14 @@ function createSvgObjectsFromAssemblyPlatedHole(hole, ctx) {
 }
 
 // lib/assembly/svg-object-fns/create-svg-objects-from-assembly-smt-pad.ts
-import { applyToPoint as applyToPoint38 } from "transformation-matrix";
+import { applyToPoint as applyToPoint39 } from "transformation-matrix";
 var PAD_COLOR2 = "rgb(210, 210, 210)";
 function createSvgObjectsFromAssemblySmtPad(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] = applyToPoint38(transform, [pad.x, pad.y]);
+    const [x, y] = applyToPoint39(transform, [pad.x, pad.y]);
     const scaledBorderRadius = (pad.rect_border_radius ?? 0) * Math.abs(transform.a);
     if (pad.shape === "rotated_rect" && pad.ccw_rotation) {
       return [
@@ -6546,7 +6830,7 @@ function createSvgObjectsFromAssemblySmtPad(pad, ctx) {
     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] = applyToPoint38(transform, [pad.x, pad.y]);
+    const [x, y] = applyToPoint39(transform, [pad.x, pad.y]);
     return [
       {
         name: "rect",
@@ -6569,7 +6853,7 @@ function createSvgObjectsFromAssemblySmtPad(pad, ctx) {
   }
   if (pad.shape === "circle") {
     const radius = pad.radius * Math.abs(transform.a);
-    const [x, y] = applyToPoint38(transform, [pad.x, pad.y]);
+    const [x, y] = applyToPoint39(transform, [pad.x, pad.y]);
     return [
       {
         name: "circle",
@@ -6589,7 +6873,7 @@ function createSvgObjectsFromAssemblySmtPad(pad, ctx) {
   }
   if (pad.shape === "polygon") {
     const points = (pad.points ?? []).map(
-      (point) => applyToPoint38(transform, [point.x, point.y])
+      (point) => applyToPoint39(transform, [point.x, point.y])
     );
     return [
       {
@@ -6643,12 +6927,12 @@ function convertCircuitJsonToAssemblySvg(soup, options) {
   const scaleFactor = Math.min(scaleX, scaleY);
   const offsetX = (svgWidth - circuitWidth * scaleFactor) / 2;
   const offsetY = (svgHeight - circuitHeight * scaleFactor) / 2;
-  const transform = compose6(
-    translate6(
+  const transform = compose7(
+    translate7(
       offsetX - minX * scaleFactor + padding * scaleFactor,
       svgHeight - offsetY + minY * scaleFactor - padding * scaleFactor
     ),
-    scale3(scaleFactor, -scaleFactor)
+    scale4(scaleFactor, -scaleFactor)
     // Flip in y-direction
   );
   const ctx = { transform };
@@ -6773,8 +7057,8 @@ function createSvgObjects2(elm, ctx, soup) {
   }
 }
 function createSvgObjectFromAssemblyBoundary(transform, minX, minY, maxX, maxY) {
-  const [x1, y1] = applyToPoint39(transform, [minX, minY]);
-  const [x2, y2] = applyToPoint39(transform, [maxX, maxY]);
+  const [x1, y1] = applyToPoint40(transform, [minX, minY]);
+  const [x2, y2] = applyToPoint40(transform, [maxX, maxY]);
   const width = Math.abs(x2 - x1);
   const height = Math.abs(y2 - y1);
   const x = Math.min(x1, x2);
@@ -6797,13 +7081,13 @@ function createSvgObjectFromAssemblyBoundary(transform, minX, minY, maxX, maxY)
 // lib/pinout/convert-circuit-json-to-pinout-svg.ts
 import { stringify as stringify3 } from "svgson";
 import {
-  compose as compose7,
+  compose as compose8,
   scale as matrixScale,
-  translate as translate7
+  translate as translate8
 } from "transformation-matrix";
 
 // lib/pinout/svg-object-fns/create-svg-objects-from-pinout-board.ts
-import { applyToPoint as applyToPoint40 } from "transformation-matrix";
+import { applyToPoint as applyToPoint41 } 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)";
@@ -6817,25 +7101,25 @@ function createSvgObjectsFromPinoutBoard(pcbBoard, ctx) {
   let path;
   if (outline && Array.isArray(outline) && outline.length >= 3) {
     path = outline.map((point, index) => {
-      const [x, y] = applyToPoint40(transform, [point.x, point.y]);
+      const [x, y] = applyToPoint41(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 = applyToPoint40(transform, [
+    const topLeft = applyToPoint41(transform, [
       center.x - halfWidth,
       center.y - halfHeight
     ]);
-    const topRight = applyToPoint40(transform, [
+    const topRight = applyToPoint41(transform, [
       center.x + halfWidth,
       center.y - halfHeight
     ]);
-    const bottomRight = applyToPoint40(transform, [
+    const bottomRight = applyToPoint41(transform, [
       center.x + halfWidth,
       center.y + halfHeight
     ]);
-    const bottomLeft = applyToPoint40(transform, [
+    const bottomLeft = applyToPoint41(transform, [
       center.x - halfWidth,
       center.y + halfHeight
     ]);
@@ -6853,10 +7137,10 @@ function createSvgObjectsFromPinoutBoard(pcbBoard, ctx) {
       const halfWidth = width2 / 2;
       const halfHeight = height2 / 2;
       const [tl, tr, br, bl] = [
-        applyToPoint40(transform, [x - halfWidth, y - halfHeight]),
-        applyToPoint40(transform, [x + halfWidth, y - halfHeight]),
-        applyToPoint40(transform, [x + halfWidth, y + halfHeight]),
-        applyToPoint40(transform, [x - halfWidth, y + halfHeight])
+        applyToPoint41(transform, [x - halfWidth, y - halfHeight]),
+        applyToPoint41(transform, [x + halfWidth, y - halfHeight]),
+        applyToPoint41(transform, [x + halfWidth, y + halfHeight]),
+        applyToPoint41(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") {
@@ -6906,7 +7190,7 @@ function createSvgObjectsFromPinoutBoard(pcbBoard, ctx) {
 
 // lib/pinout/svg-object-fns/create-svg-objects-from-pinout-component.ts
 import { su as su5 } from "@tscircuit/circuit-json-util";
-import { applyToPoint as applyToPoint41 } from "transformation-matrix";
+import { applyToPoint as applyToPoint42 } 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) {
@@ -6916,7 +7200,7 @@ function createSvgObjectsFromPinoutComponent(elm, ctx) {
   if (!center || typeof width !== "number" || typeof height !== "number" || width === 0 || height === 0) {
     return [];
   }
-  const [x, y] = applyToPoint41(transform, [center.x, center.y]);
+  const [x, y] = applyToPoint42(transform, [center.x, center.y]);
   const scaledWidth = width * Math.abs(transform.a);
   const scaledHeight = height * Math.abs(transform.d);
   const transformStr = `translate(${x}, ${y})`;
@@ -6977,11 +7261,11 @@ function createSvgObjectsFromPinoutComponent(elm, ctx) {
 }
 
 // lib/pinout/svg-object-fns/create-svg-objects-from-pinout-hole.ts
-import { applyToPoint as applyToPoint42 } from "transformation-matrix";
+import { applyToPoint as applyToPoint43 } from "transformation-matrix";
 var HOLE_COLOR4 = "rgb(50, 50, 50)";
 function createSvgObjectsFromPinoutHole(hole, ctx) {
   const { transform } = ctx;
-  const [x, y] = applyToPoint42(transform, [hole.x, hole.y]);
+  const [x, y] = applyToPoint43(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;
@@ -7045,12 +7329,12 @@ function createSvgObjectsFromPinoutHole(hole, ctx) {
 }
 
 // lib/pinout/svg-object-fns/create-svg-objects-from-pinout-plated-hole.ts
-import { applyToPoint as applyToPoint43 } from "transformation-matrix";
+import { applyToPoint as applyToPoint44 } 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] = applyToPoint43(transform, [hole.x, hole.y]);
+  const [x, y] = applyToPoint44(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);
@@ -7285,14 +7569,14 @@ function createSvgObjectsFromPinoutPlatedHole(hole, ctx) {
 }
 
 // lib/pinout/svg-object-fns/create-svg-objects-from-pinout-smt-pad.ts
-import { applyToPoint as applyToPoint44 } from "transformation-matrix";
+import { applyToPoint as applyToPoint45 } 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] = applyToPoint44(transform, [pad.x, pad.y]);
+    const [x, y] = applyToPoint45(transform, [pad.x, pad.y]);
     if (pad.shape === "rotated_rect" && pad.ccw_rotation) {
       return [
         {
@@ -7335,7 +7619,7 @@ function createSvgObjectsFromPinoutSmtPad(pad, ctx) {
     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] = applyToPoint44(transform, [pad.x, pad.y]);
+    const [x, y] = applyToPoint45(transform, [pad.x, pad.y]);
     return [
       {
         name: "rect",
@@ -7358,7 +7642,7 @@ function createSvgObjectsFromPinoutSmtPad(pad, ctx) {
   }
   if (pad.shape === "circle") {
     const radius = pad.radius * Math.abs(transform.a);
-    const [x, y] = applyToPoint44(transform, [pad.x, pad.y]);
+    const [x, y] = applyToPoint45(transform, [pad.x, pad.y]);
     return [
       {
         name: "circle",
@@ -7378,7 +7662,7 @@ function createSvgObjectsFromPinoutSmtPad(pad, ctx) {
   }
   if (pad.shape === "polygon") {
     const points = (pad.points ?? []).map(
-      (point) => applyToPoint44(transform, [point.x, point.y])
+      (point) => applyToPoint45(transform, [point.x, point.y])
     );
     return [
       {
@@ -7399,7 +7683,7 @@ function createSvgObjectsFromPinoutSmtPad(pad, ctx) {
 }
 
 // lib/pinout/svg-object-fns/create-svg-objects-from-pinout-port.ts
-import { applyToPoint as applyToPoint45 } from "transformation-matrix";
+import { applyToPoint as applyToPoint46 } from "transformation-matrix";
 import { calculateElbow } from "calculate-elbow";
 
 // lib/pinout/svg-object-fns/pinout-label-box.ts
@@ -7476,7 +7760,7 @@ 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] = applyToPoint45(ctx.transform, [pcb_port.x, pcb_port.y]);
+  const [port_x, port_y] = applyToPoint46(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(
@@ -7617,7 +7901,7 @@ function createSvgObjectsFromPinoutPort(pcb_port, ctx) {
 }
 
 // lib/pinout/calculate-label-positions.ts
-import { applyToPoint as applyToPoint46 } from "transformation-matrix";
+import { applyToPoint as applyToPoint47 } from "transformation-matrix";
 
 // lib/pinout/constants.ts
 var LABEL_RECT_HEIGHT_BASE_MM = 1.6;
@@ -7655,7 +7939,7 @@ function calculateVerticalEdgeLabels(edge, pinout_labels, {
     );
     const mapToEdgePort = (pinout_label) => ({
       pcb_port: pinout_label.pcb_port,
-      y: applyToPoint46(transform, [
+      y: applyToPoint47(transform, [
         pinout_label.pcb_port.x,
         pinout_label.pcb_port.y
       ])[1],
@@ -7670,7 +7954,7 @@ function calculateVerticalEdgeLabels(edge, pinout_labels, {
   } else {
     edge_ports = pinout_labels.map((pinout_label) => ({
       pcb_port: pinout_label.pcb_port,
-      y: applyToPoint46(transform, [
+      y: applyToPoint47(transform, [
         pinout_label.pcb_port.x,
         pinout_label.pcb_port.y
       ])[1],
@@ -7678,7 +7962,7 @@ function calculateVerticalEdgeLabels(edge, pinout_labels, {
     })).sort((a, b) => a.y - b.y);
   }
   if (edge_ports.length === 0) return;
-  const board_edge_x = applyToPoint46(transform, [
+  const board_edge_x = applyToPoint47(transform, [
     edge === "left" ? board_bounds.minX : board_bounds.maxX,
     0
   ])[0];
@@ -7998,8 +8282,8 @@ function convertCircuitJsonToPinoutSvg(soup, options) {
   const pxPerMm = Math.min(pxPerMmX, pxPerMmY);
   const offsetX = (svgWidth - circuitWidth * pxPerMm) / 2;
   const offsetY = (svgHeight - circuitHeight * pxPerMm) / 2;
-  const transform = compose7(
-    translate7(
+  const transform = compose8(
+    translate8(
       offsetX - expandedMinX * pxPerMm + paddingMm * pxPerMm,
       svgHeight - offsetY + minY * pxPerMm - paddingMm * pxPerMm
     ),
@@ -8100,14 +8384,14 @@ import {
 } from "transformation-matrix";
 
 // lib/sch/draw-schematic-grid.ts
-import { applyToPoint as applyToPoint47 } from "transformation-matrix";
+import { applyToPoint as applyToPoint48 } 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] = applyToPoint47(params.transform, [x, y]);
+    const [transformedX, transformedY] = applyToPoint48(params.transform, [x, y]);
     return { x: transformedX, y: transformedY };
   };
   for (let x = Math.floor(minX); x <= Math.ceil(maxX); x += cellSize) {
@@ -8188,15 +8472,15 @@ function drawSchematicGrid(params) {
 }
 
 // lib/sch/draw-schematic-labeled-points.ts
-import { applyToPoint as applyToPoint48 } from "transformation-matrix";
+import { applyToPoint as applyToPoint49 } from "transformation-matrix";
 function drawSchematicLabeledPoints(params) {
   const { points, transform } = params;
   const labeledPointsGroup = [];
   for (const point of points) {
-    const [x1, y1] = applyToPoint48(transform, [point.x - 0.1, point.y - 0.1]);
-    const [x2, y2] = applyToPoint48(transform, [point.x + 0.1, point.y + 0.1]);
-    const [x3, y3] = applyToPoint48(transform, [point.x - 0.1, point.y + 0.1]);
-    const [x4, y4] = applyToPoint48(transform, [point.x + 0.1, point.y - 0.1]);
+    const [x1, y1] = applyToPoint49(transform, [point.x - 0.1, point.y - 0.1]);
+    const [x2, y2] = applyToPoint49(transform, [point.x + 0.1, point.y + 0.1]);
+    const [x3, y3] = applyToPoint49(transform, [point.x - 0.1, point.y + 0.1]);
+    const [x4, y4] = applyToPoint49(transform, [point.x + 0.1, point.y - 0.1]);
     labeledPointsGroup.push({
       name: "path",
       type: "element",
@@ -8207,7 +8491,7 @@ function drawSchematicLabeledPoints(params) {
         "stroke-opacity": "0.7"
       }
     });
-    const [labelX, labelY] = applyToPoint48(transform, [
+    const [labelX, labelY] = applyToPoint49(transform, [
       point.x + 0.15,
       point.y - 0.15
     ]);
@@ -9301,8 +9585,8 @@ import { su as su7 } from "@tscircuit/circuit-json-util";
 import { symbols } from "schematic-symbols";
 import "svgson";
 import {
-  applyToPoint as applyToPoint50,
-  compose as compose9
+  applyToPoint as applyToPoint51,
+  compose as compose10
 } from "transformation-matrix";
 
 // lib/utils/get-sch-stroke-size.ts
@@ -9372,26 +9656,26 @@ var matchSchPortsToSymbolPorts = ({
 };
 
 // lib/utils/point-pairs-to-matrix.ts
-import { compose as compose8, scale as scale4, translate as translate8 } from "transformation-matrix";
+import { compose as compose9, scale as scale5, translate as translate9 } 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 = translate8(tx, ty);
-  const scaleMatrix = scale4(a, a);
-  return compose8(translateMatrix, scaleMatrix);
+  const translateMatrix = translate9(tx, ty);
+  const scaleMatrix = scale5(a, a);
+  return compose9(translateMatrix, scaleMatrix);
 }
 
 // lib/sch/svg-object-fns/create-svg-error-text.ts
-import { applyToPoint as applyToPoint49 } from "transformation-matrix";
+import { applyToPoint as applyToPoint50 } from "transformation-matrix";
 var createSvgSchErrorText = ({
   text,
   realCenter,
   realToScreenTransform
 }) => {
-  const screenCenter = applyToPoint49(realToScreenTransform, realCenter);
+  const screenCenter = applyToPoint50(realToScreenTransform, realCenter);
   return {
     type: "element",
     name: "text",
@@ -9500,12 +9784,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] = applyToPoint50(
-    compose9(realToScreenTransform, transformFromSymbolToReal),
+  const [screenMinX, screenMinY] = applyToPoint51(
+    compose10(realToScreenTransform, transformFromSymbolToReal),
     [bounds.minX, bounds.minY]
   );
-  const [screenMaxX, screenMaxY] = applyToPoint50(
-    compose9(realToScreenTransform, transformFromSymbolToReal),
+  const [screenMaxX, screenMaxY] = applyToPoint51(
+    compose10(realToScreenTransform, transformFromSymbolToReal),
     [bounds.maxX, bounds.maxY]
   );
   const rectHeight = Math.abs(screenMaxY - screenMinY);
@@ -9533,8 +9817,8 @@ var createSvgObjectsFromSchematicComponentWithSymbol = ({
       name: "path",
       attributes: {
         d: points.map((p, i) => {
-          const [x, y] = applyToPoint50(
-            compose9(realToScreenTransform, transformFromSymbolToReal),
+          const [x, y] = applyToPoint51(
+            compose10(realToScreenTransform, transformFromSymbolToReal),
             [p.x, p.y]
           );
           return `${i === 0 ? "M" : "L"} ${x} ${y}`;
@@ -9549,8 +9833,8 @@ var createSvgObjectsFromSchematicComponentWithSymbol = ({
     });
   }
   for (const text of texts) {
-    const screenTextPos = applyToPoint50(
-      compose9(realToScreenTransform, transformFromSymbolToReal),
+    const screenTextPos = applyToPoint51(
+      compose10(realToScreenTransform, transformFromSymbolToReal),
       text
     );
     let textValue = "";
@@ -9601,11 +9885,11 @@ var createSvgObjectsFromSchematicComponentWithSymbol = ({
     });
   }
   for (const box of boxes) {
-    const screenBoxPos = applyToPoint50(
-      compose9(realToScreenTransform, transformFromSymbolToReal),
+    const screenBoxPos = applyToPoint51(
+      compose10(realToScreenTransform, transformFromSymbolToReal),
       box
     );
-    const symbolToScreenScale = compose9(
+    const symbolToScreenScale = compose10(
       realToScreenTransform,
       transformFromSymbolToReal
     ).a;
@@ -9625,8 +9909,8 @@ var createSvgObjectsFromSchematicComponentWithSymbol = ({
   }
   for (const port of symbol.ports) {
     if (connectedSymbolPorts.has(port)) continue;
-    const screenPortPos = applyToPoint50(
-      compose9(realToScreenTransform, transformFromSymbolToReal),
+    const screenPortPos = applyToPoint51(
+      compose10(realToScreenTransform, transformFromSymbolToReal),
       port
     );
     svgObjects.push({
@@ -9645,8 +9929,8 @@ var createSvgObjectsFromSchematicComponentWithSymbol = ({
     });
   }
   for (const circle of circles) {
-    const screenCirclePos = applyToPoint50(
-      compose9(realToScreenTransform, transformFromSymbolToReal),
+    const screenCirclePos = applyToPoint51(
+      compose10(realToScreenTransform, transformFromSymbolToReal),
       circle
     );
     const screenRadius = Math.abs(circle.radius * realToScreenTransform.a);
@@ -9672,14 +9956,14 @@ var createSvgObjectsFromSchematicComponentWithSymbol = ({
 import { su as su10 } from "@tscircuit/circuit-json-util";
 import "schematic-symbols";
 import "svgson";
-import { applyToPoint as applyToPoint56 } from "transformation-matrix";
+import { applyToPoint as applyToPoint57 } 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 applyToPoint51 } from "transformation-matrix";
+import { applyToPoint as applyToPoint52 } 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) => {
@@ -9732,8 +10016,8 @@ var createSvgObjectsForSchPortBoxLine = ({
       realEdgePos.y += realPinLineLength;
       break;
   }
-  const screenSchPortPos = applyToPoint51(transform, schPort.center);
-  const screenRealEdgePos = applyToPoint51(transform, realEdgePos);
+  const screenSchPortPos = applyToPoint52(transform, schPort.center);
+  const screenRealEdgePos = applyToPoint52(transform, realEdgePos);
   const isConnected = isSourcePortConnected(circuitJson, schPort.source_port_id);
   const realLineEnd = { ...schPort.center };
   if (!isConnected) {
@@ -9752,7 +10036,7 @@ var createSvgObjectsForSchPortBoxLine = ({
         break;
     }
   }
-  const screenLineEnd = applyToPoint51(transform, realLineEnd);
+  const screenLineEnd = applyToPoint52(transform, realLineEnd);
   svgObjects.push({
     name: "line",
     type: "element",
@@ -9873,7 +10157,7 @@ var createSvgObjectsForSchPortBoxLine = ({
 };
 
 // lib/sch/svg-object-fns/create-svg-objects-for-sch-port-pin-number-text.ts
-import { applyToPoint as applyToPoint52 } from "transformation-matrix";
+import { applyToPoint as applyToPoint53 } from "transformation-matrix";
 var createSvgObjectsForSchPortPinNumberText = (params) => {
   const svgObjects = [];
   const { schPort, schComponent, transform, circuitJson } = params;
@@ -9891,7 +10175,7 @@ var createSvgObjectsForSchPortPinNumberText = (params) => {
   } else {
     realPinNumberPos.y += 0.02;
   }
-  const screenPinNumberTextPos = applyToPoint52(transform, realPinNumberPos);
+  const screenPinNumberTextPos = applyToPoint53(transform, realPinNumberPos);
   svgObjects.push({
     name: "text",
     type: "element",
@@ -9921,7 +10205,7 @@ var createSvgObjectsForSchPortPinNumberText = (params) => {
 };
 
 // lib/sch/svg-object-fns/create-svg-objects-for-sch-port-pin-label.ts
-import { applyToPoint as applyToPoint53 } from "transformation-matrix";
+import { applyToPoint as applyToPoint54 } from "transformation-matrix";
 var LABEL_DIST_FROM_EDGE_MM = 0.1;
 var createSvgObjectsForSchPortPinLabel = (params) => {
   const svgObjects = [];
@@ -9935,7 +10219,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 = applyToPoint53(transform, realPinNumberPos);
+  const screenPinNumberTextPos = applyToPoint54(transform, realPinNumberPos);
   const label = schPort.display_pin_label ?? schComponent.port_labels?.[`${schPort.pin_number}`];
   if (!label) return [];
   const isNegated = label.startsWith("N_");
@@ -9983,13 +10267,13 @@ var createSvgObjectsFromSchPortOnBox = (params) => {
 };
 
 // lib/sch/svg-object-fns/create-svg-objects-for-sch-text.ts
-import { applyToPoint as applyToPoint55 } from "transformation-matrix";
+import { applyToPoint as applyToPoint56 } from "transformation-matrix";
 var createSvgSchText = ({
   elm,
   transform,
   colorMap: colorMap2
 }) => {
-  const center = applyToPoint55(transform, elm.position);
+  const center = applyToPoint56(transform, elm.position);
   const textAnchorMap = {
     center: "middle",
     center_right: "end",
@@ -10073,11 +10357,11 @@ var createSvgObjectsFromSchematicComponentWithBox = ({
   colorMap: colorMap2
 }) => {
   const svgObjects = [];
-  const componentScreenTopLeft = applyToPoint56(transform, {
+  const componentScreenTopLeft = applyToPoint57(transform, {
     x: schComponent.center.x - schComponent.size.width / 2,
     y: schComponent.center.y + schComponent.size.height / 2
   });
-  const componentScreenBottomRight = applyToPoint56(transform, {
+  const componentScreenBottomRight = applyToPoint57(transform, {
     x: schComponent.center.x + schComponent.size.width / 2,
     y: schComponent.center.y - schComponent.size.height / 2
   });
@@ -10163,13 +10447,13 @@ function createSvgObjectsFromSchematicComponent(params) {
 }
 
 // lib/sch/svg-object-fns/create-svg-objects-from-sch-voltage-probe.ts
-import { applyToPoint as applyToPoint57 } from "transformation-matrix";
+import { applyToPoint as applyToPoint58 } from "transformation-matrix";
 function createSvgObjectsFromSchVoltageProbe({
   probe,
   transform,
   colorMap: colorMap2
 }) {
-  const [screenX, screenY] = applyToPoint57(transform, [
+  const [screenX, screenY] = applyToPoint58(transform, [
     probe.position.x,
     probe.position.y
   ]);
@@ -10276,17 +10560,17 @@ function createSvgObjectsFromSchVoltageProbe({
 }
 
 // lib/sch/svg-object-fns/create-svg-objects-from-sch-debug-object.ts
-import { applyToPoint as applyToPoint58 } from "transformation-matrix";
+import { applyToPoint as applyToPoint59 } from "transformation-matrix";
 function createSvgObjectsFromSchDebugObject({
   debugObject,
   transform
 }) {
   if (debugObject.shape === "rect") {
-    let [screenLeft, screenTop] = applyToPoint58(transform, [
+    let [screenLeft, screenTop] = applyToPoint59(transform, [
       debugObject.center.x - debugObject.size.width / 2,
       debugObject.center.y - debugObject.size.height / 2
     ]);
-    let [screenRight, screenBottom] = applyToPoint58(transform, [
+    let [screenRight, screenBottom] = applyToPoint59(transform, [
       debugObject.center.x + debugObject.size.width / 2,
       debugObject.center.y + debugObject.size.height / 2
     ]);
@@ -10296,7 +10580,7 @@ function createSvgObjectsFromSchDebugObject({
     ];
     const width = Math.abs(screenRight - screenLeft);
     const height = Math.abs(screenBottom - screenTop);
-    const [screenCenterX, screenCenterY] = applyToPoint58(transform, [
+    const [screenCenterX, screenCenterY] = applyToPoint59(transform, [
       debugObject.center.x,
       debugObject.center.y
     ]);
@@ -10342,11 +10626,11 @@ function createSvgObjectsFromSchDebugObject({
     ];
   }
   if (debugObject.shape === "line") {
-    const [screenStartX, screenStartY] = applyToPoint58(transform, [
+    const [screenStartX, screenStartY] = applyToPoint59(transform, [
       debugObject.start.x,
       debugObject.start.y
     ]);
-    const [screenEndX, screenEndY] = applyToPoint58(transform, [
+    const [screenEndX, screenEndY] = applyToPoint59(transform, [
       debugObject.end.x,
       debugObject.end.y
     ]);
@@ -10396,7 +10680,7 @@ function createSvgObjectsFromSchDebugObject({
 }
 
 // lib/sch/svg-object-fns/create-svg-objects-from-sch-trace.ts
-import { applyToPoint as applyToPoint59 } from "transformation-matrix";
+import { applyToPoint as applyToPoint60 } from "transformation-matrix";
 function createSchematicTrace({
   trace,
   transform,
@@ -10410,11 +10694,11 @@ function createSchematicTrace({
   for (let edgeIndex = 0; edgeIndex < edges.length; edgeIndex++) {
     const edge = edges[edgeIndex];
     if (edge.is_crossing) continue;
-    const [screenFromX, screenFromY] = applyToPoint59(transform, [
+    const [screenFromX, screenFromY] = applyToPoint60(transform, [
       edge.from.x,
       edge.from.y
     ]);
-    const [screenToX, screenToY] = applyToPoint59(transform, [
+    const [screenToX, screenToY] = applyToPoint60(transform, [
       edge.to.x,
       edge.to.y
     ]);
@@ -10458,11 +10742,11 @@ function createSchematicTrace({
   }
   for (const edge of edges) {
     if (!edge.is_crossing) continue;
-    const [screenFromX, screenFromY] = applyToPoint59(transform, [
+    const [screenFromX, screenFromY] = applyToPoint60(transform, [
       edge.from.x,
       edge.from.y
     ]);
-    const [screenToX, screenToY] = applyToPoint59(transform, [
+    const [screenToX, screenToY] = applyToPoint60(transform, [
       edge.to.x,
       edge.to.y
     ]);
@@ -10506,7 +10790,7 @@ function createSchematicTrace({
   }
   if (trace.junctions) {
     for (const junction of trace.junctions) {
-      const [screenX, screenY] = applyToPoint59(transform, [
+      const [screenX, screenY] = applyToPoint60(transform, [
         junction.x,
         junction.y
       ]);
@@ -10560,6 +10844,15 @@ function createSchematicTrace({
 }
 
 // lib/sch/svg-object-fns/create-svg-objects-for-sch-net-label.ts
+import {
+  applyToPoint as applyToPoint62,
+  compose as compose12,
+  rotate as rotate7,
+  scale as scale7,
+  translate as translate12
+} from "transformation-matrix";
+
+// lib/sch/svg-object-fns/create-svg-objects-for-sch-net-label-with-symbol.ts
 import {
   applyToPoint as applyToPoint61,
   compose as compose11,
@@ -10567,15 +10860,6 @@ import {
   scale as scale6,
   translate as translate11
 } from "transformation-matrix";
-
-// lib/sch/svg-object-fns/create-svg-objects-for-sch-net-label-with-symbol.ts
-import {
-  applyToPoint as applyToPoint60,
-  compose as compose10,
-  rotate as rotate5,
-  scale as scale5,
-  translate as translate10
-} from "transformation-matrix";
 import { symbols as symbols3 } from "schematic-symbols";
 var createSvgObjectsForSchNetLabelWithSymbol = ({
   schNetLabel,
@@ -10618,7 +10902,7 @@ var createSvgObjectsForSchNetLabelWithSymbol = ({
     y: schNetLabel.center.y - realTextGrowthVec.y * fullWidthFsr * fontSizeMm / 2
   };
   const pathRotation = 0;
-  const rotationMatrix = rotate5(pathRotation / 180 * Math.PI);
+  const rotationMatrix = rotate6(pathRotation / 180 * Math.PI);
   const symbolBounds = {
     minX: Math.min(
       ...symbol.primitives.flatMap(
@@ -10645,22 +10929,22 @@ var createSvgObjectsForSchNetLabelWithSymbol = ({
     x: symbolBounds.minX,
     y: (symbolBounds.minY + symbolBounds.maxY) / 2
   };
-  const rotatedSymbolEnd = applyToPoint60(rotationMatrix, symbolEndPoint);
-  const symbolToRealTransform = compose10(
-    translate10(
+  const rotatedSymbolEnd = applyToPoint61(rotationMatrix, symbolEndPoint);
+  const symbolToRealTransform = compose11(
+    translate11(
       realAnchorPosition.x - rotatedSymbolEnd.x,
       realAnchorPosition.y - rotatedSymbolEnd.y
     ),
     rotationMatrix,
-    scale5(1)
+    scale6(1)
     // Use full symbol size
   );
-  const [screenMinX, screenMinY] = applyToPoint60(
-    compose10(realToScreenTransform, symbolToRealTransform),
+  const [screenMinX, screenMinY] = applyToPoint61(
+    compose11(realToScreenTransform, symbolToRealTransform),
     [bounds.minX, bounds.minY]
   );
-  const [screenMaxX, screenMaxY] = applyToPoint60(
-    compose10(realToScreenTransform, symbolToRealTransform),
+  const [screenMaxX, screenMaxY] = applyToPoint61(
+    compose11(realToScreenTransform, symbolToRealTransform),
     [bounds.maxX, bounds.maxY]
   );
   const rectHeight = Math.abs(screenMaxY - screenMinY);
@@ -10683,8 +10967,8 @@ var createSvgObjectsForSchNetLabelWithSymbol = ({
   });
   for (const path of symbolPaths) {
     const symbolPath = path.points.map((p, i) => {
-      const [x, y] = applyToPoint60(
-        compose10(realToScreenTransform, symbolToRealTransform),
+      const [x, y] = applyToPoint61(
+        compose11(realToScreenTransform, symbolToRealTransform),
         [p.x, p.y]
       );
       return `${i === 0 ? "M" : "L"} ${x} ${y}`;
@@ -10704,8 +10988,8 @@ var createSvgObjectsForSchNetLabelWithSymbol = ({
     });
   }
   for (const text of symbolTexts) {
-    const screenTextPos = applyToPoint60(
-      compose10(realToScreenTransform, symbolToRealTransform),
+    const screenTextPos = applyToPoint61(
+      compose11(realToScreenTransform, symbolToRealTransform),
       text
     );
     let textValue = text.text;
@@ -10714,8 +10998,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
@@ -10746,11 +11030,11 @@ var createSvgObjectsForSchNetLabelWithSymbol = ({
     });
   }
   for (const box of symbolBoxes) {
-    const screenBoxPos = applyToPoint60(
-      compose10(realToScreenTransform, symbolToRealTransform),
+    const screenBoxPos = applyToPoint61(
+      compose11(realToScreenTransform, symbolToRealTransform),
       box
     );
-    const symbolToScreenScale = compose10(
+    const symbolToScreenScale = compose11(
       realToScreenTransform,
       symbolToRealTransform
     ).a;
@@ -10769,11 +11053,11 @@ var createSvgObjectsForSchNetLabelWithSymbol = ({
     });
   }
   for (const circle of symbolCircles) {
-    const screenCirclePos = applyToPoint60(
-      compose10(realToScreenTransform, symbolToRealTransform),
+    const screenCirclePos = applyToPoint61(
+      compose11(realToScreenTransform, symbolToRealTransform),
       circle
     );
-    const symbolToScreenScale = compose10(
+    const symbolToScreenScale = compose11(
       realToScreenTransform,
       symbolToRealTransform
     ).a;
@@ -10814,14 +11098,14 @@ var createSvgObjectsForSchNetLabel = ({
   const fontSizePx = getSchScreenFontSize(realToScreenTransform, "net_label");
   const fontSizeMm = getSchMmFontSize("net_label");
   const textWidthFSR = estimateTextWidth(labelText || "");
-  const screenCenter = applyToPoint61(realToScreenTransform, schNetLabel.center);
+  const screenCenter = applyToPoint62(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 ? applyToPoint61(realToScreenTransform, schNetLabel.anchor_position) : {
+  const screenAnchorPosition = schNetLabel.anchor_position ? applyToPoint62(realToScreenTransform, schNetLabel.anchor_position) : {
     x: screenCenter.x - screenTextGrowthVec.x * fullWidthFsr * fontSizePx / 2,
     y: screenCenter.y - screenTextGrowthVec.y * fullWidthFsr * fontSizePx / 2
   };
@@ -10862,12 +11146,12 @@ var createSvgObjectsForSchNetLabel = ({
       y: -0.6
     }
   ].map(
-    (fontRelativePoint) => applyToPoint61(
-      compose11(
+    (fontRelativePoint) => applyToPoint62(
+      compose12(
         realToScreenTransform,
-        translate11(realAnchorPosition.x, realAnchorPosition.y),
-        scale6(fontSizeMm),
-        rotate6(pathRotation / 180 * Math.PI)
+        translate12(realAnchorPosition.x, realAnchorPosition.y),
+        scale7(fontSizeMm),
+        rotate7(pathRotation / 180 * Math.PI)
       ),
       fontRelativePoint
     )
@@ -10939,17 +11223,17 @@ var createSvgObjectsForSchNetLabel = ({
 };
 
 // lib/sch/svg-object-fns/create-svg-objects-from-sch-box.ts
-import { applyToPoint as applyToPoint62 } from "transformation-matrix";
+import { applyToPoint as applyToPoint63 } from "transformation-matrix";
 var createSvgObjectsFromSchematicBox = ({
   schematicBox,
   transform,
   colorMap: colorMap2
 }) => {
-  const topLeft = applyToPoint62(transform, {
+  const topLeft = applyToPoint63(transform, {
     x: schematicBox.x,
     y: schematicBox.y
   });
-  const bottomRight = applyToPoint62(transform, {
+  const bottomRight = applyToPoint63(transform, {
     x: schematicBox.x + schematicBox.width,
     y: schematicBox.y + schematicBox.height
   });
@@ -10985,7 +11269,7 @@ var createSvgObjectsFromSchematicBox = ({
 };
 
 // lib/sch/svg-object-fns/create-svg-objects-from-sch-table.ts
-import { applyToPoint as applyToPoint63 } from "transformation-matrix";
+import { applyToPoint as applyToPoint64 } from "transformation-matrix";
 var createSvgObjectsFromSchematicTable = ({
   schematicTable,
   transform,
@@ -11018,11 +11302,11 @@ var createSvgObjectsFromSchematicTable = ({
   const svgObjects = [];
   const borderStrokeWidth = border_width * Math.abs(transform.a);
   const gridStrokeWidth = getSchStrokeSize(transform);
-  const [screenTopLeftX, screenTopLeftY] = applyToPoint63(transform, [
+  const [screenTopLeftX, screenTopLeftY] = applyToPoint64(transform, [
     topLeftX,
     topLeftY
   ]);
-  const [screenBottomRightX, screenBottomRightY] = applyToPoint63(transform, [
+  const [screenBottomRightX, screenBottomRightY] = applyToPoint64(transform, [
     topLeftX + totalWidth,
     topLeftY - totalHeight
   ]);
@@ -11054,8 +11338,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 = applyToPoint63(transform, { x: currentX, y: segmentStartY });
-        const end = applyToPoint63(transform, { x: currentX, y: segmentEndY });
+        const start = applyToPoint64(transform, { x: currentX, y: segmentStartY });
+        const end = applyToPoint64(transform, { x: currentX, y: segmentEndY });
         svgObjects.push({
           name: "line",
           type: "element",
@@ -11084,11 +11368,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 = applyToPoint63(transform, {
+        const start = applyToPoint64(transform, {
           x: segmentStartX,
           y: currentY
         });
-        const end = applyToPoint63(transform, { x: segmentEndX, y: currentY });
+        const end = applyToPoint64(transform, { x: segmentEndX, y: currentY });
         svgObjects.push({
           name: "line",
           type: "element",
@@ -11130,7 +11414,7 @@ var createSvgObjectsFromSchematicTable = ({
       } else if (vertical_align === "bottom") {
         realTextAnchorPos.y = cellTopLeftY - cellHeight + cell_padding;
       }
-      const screenTextAnchorPos = applyToPoint63(transform, realTextAnchorPos);
+      const screenTextAnchorPos = applyToPoint64(transform, realTextAnchorPos);
       const fontSize = getSchScreenFontSize(
         transform,
         "reference_designator",
@@ -11186,13 +11470,13 @@ var createSvgObjectsFromSchematicTable = ({
 
 // lib/sch/svg-object-fns/create-svg-objects-for-sch-port-hover.ts
 import { su as su11 } from "@tscircuit/circuit-json-util";
-import { applyToPoint as applyToPoint64 } from "transformation-matrix";
+import { applyToPoint as applyToPoint65 } from "transformation-matrix";
 var PIN_CIRCLE_RADIUS_MM2 = 0.02;
 var createSvgObjectsForSchPortHover = ({
   schPort,
   transform
 }) => {
-  const screenSchPortPos = applyToPoint64(transform, schPort.center);
+  const screenSchPortPos = applyToPoint65(transform, schPort.center);
   const pinRadiusPx = Math.abs(transform.a) * PIN_CIRCLE_RADIUS_MM2 * 2;
   return [
     {
@@ -11237,14 +11521,14 @@ var createSvgObjectsForSchComponentPortHovers = ({
 };
 
 // lib/sch/svg-object-fns/create-svg-objects-from-sch-line.ts
-import { applyToPoint as applyToPoint65 } from "transformation-matrix";
+import { applyToPoint as applyToPoint66 } from "transformation-matrix";
 function createSvgObjectsFromSchematicLine({
   schLine,
   transform,
   colorMap: colorMap2
 }) {
-  const p1 = applyToPoint65(transform, { x: schLine.x1, y: schLine.y1 });
-  const p2 = applyToPoint65(transform, { x: schLine.x2, y: schLine.y2 });
+  const p1 = applyToPoint66(transform, { x: schLine.x1, y: schLine.y1 });
+  const p2 = applyToPoint66(transform, { x: schLine.x2, y: schLine.y2 });
   const strokeWidth = schLine.stroke_width ?? 0.02;
   const transformedStrokeWidth = Math.abs(transform.a) * strokeWidth;
   return [
@@ -11273,13 +11557,13 @@ function createSvgObjectsFromSchematicLine({
 }
 
 // lib/sch/svg-object-fns/create-svg-objects-from-sch-circle.ts
-import { applyToPoint as applyToPoint66 } from "transformation-matrix";
+import { applyToPoint as applyToPoint67 } from "transformation-matrix";
 function createSvgObjectsFromSchematicCircle({
   schCircle,
   transform,
   colorMap: colorMap2
 }) {
-  const center = applyToPoint66(transform, schCircle.center);
+  const center = applyToPoint67(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;
@@ -11309,13 +11593,13 @@ function createSvgObjectsFromSchematicCircle({
 }
 
 // lib/sch/svg-object-fns/create-svg-objects-from-sch-rect.ts
-import { applyToPoint as applyToPoint67 } from "transformation-matrix";
+import { applyToPoint as applyToPoint68 } from "transformation-matrix";
 function createSvgObjectsFromSchematicRect({
   schRect,
   transform,
   colorMap: colorMap2
 }) {
-  const center = applyToPoint67(transform, schRect.center);
+  const center = applyToPoint68(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;
@@ -11351,13 +11635,13 @@ function createSvgObjectsFromSchematicRect({
 }
 
 // lib/sch/svg-object-fns/create-svg-objects-from-sch-arc.ts
-import { applyToPoint as applyToPoint68 } from "transformation-matrix";
+import { applyToPoint as applyToPoint69 } from "transformation-matrix";
 function createSvgObjectsFromSchematicArc({
   schArc,
   transform,
   colorMap: colorMap2
 }) {
-  const center = applyToPoint68(transform, schArc.center);
+  const center = applyToPoint69(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;
@@ -12364,9 +12648,9 @@ function convertCircuitJsonToSchematicSimulationSvg({
   const rawSchematicHeight = Math.max(1, height * clampedRatio);
   const rawSimulationHeight = Math.max(1, height - rawSchematicHeight);
   const totalRawHeight = rawSchematicHeight + rawSimulationHeight;
-  const scale9 = totalRawHeight === 0 ? 1 : height / totalRawHeight;
-  const schematicHeight = rawSchematicHeight * scale9;
-  const simulationHeight = rawSimulationHeight * scale9;
+  const scale10 = totalRawHeight === 0 ? 1 : height / totalRawHeight;
+  const schematicHeight = rawSchematicHeight * scale10;
+  const simulationHeight = rawSimulationHeight * scale10;
   const schematicSvg = convertCircuitJsonToSchematicSvg(schematicElements, {
     ...schematicOptions,
     width,
@@ -12458,21 +12742,21 @@ function formatNumber2(value) {
 }
 
 // lib/pcb/convert-circuit-json-to-solder-paste-mask.ts
-import { distance as distance2 } from "circuit-json";
+import { distance as distance3 } from "circuit-json";
 import { stringify as stringify7 } from "svgson";
 import {
-  applyToPoint as applyToPoint71,
-  compose as compose14,
-  scale as scale8,
-  translate as translate14
+  applyToPoint as applyToPoint72,
+  compose as compose15,
+  scale as scale9,
+  translate as translate15
 } from "transformation-matrix";
 
 // lib/pcb/svg-object-fns/convert-circuit-json-to-solder-paste-mask.ts
-import { applyToPoint as applyToPoint70 } from "transformation-matrix";
+import { applyToPoint as applyToPoint71 } from "transformation-matrix";
 function createSvgObjectsFromSolderPaste(solderPaste, ctx) {
   const { transform, layer: layerFilter } = ctx;
   if (layerFilter && solderPaste.layer !== layerFilter) return [];
-  const [x, y] = applyToPoint70(transform, [solderPaste.x, solderPaste.y]);
+  const [x, y] = applyToPoint71(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);
@@ -12576,8 +12860,8 @@ function convertCircuitJsonToSolderPasteMask(circuitJson, options) {
       }
     } else if (item.type === "pcb_panel") {
       const panel = item;
-      const width = distance2.parse(panel.width);
-      const height = distance2.parse(panel.height);
+      const width = distance3.parse(panel.width);
+      const height = distance3.parse(panel.height);
       if (width !== void 0 && height !== void 0) {
         const center = panel.center ?? { x: width / 2, y: height / 2 };
         updateBounds(center, width, height);
@@ -12596,12 +12880,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 = compose14(
-    translate14(
+  const transform = compose15(
+    translate15(
       offsetX - minX * scaleFactor + padding * scaleFactor,
       svgHeight - offsetY + minY * scaleFactor - padding * scaleFactor
     ),
-    scale8(scaleFactor, -scaleFactor)
+    scale9(scaleFactor, -scaleFactor)
     // Flip in y-direction
   );
   const ctx = {
@@ -12698,8 +12982,8 @@ function createSvgObjects4({ elm, ctx }) {
   }
 }
 function createSvgObjectFromPcbBoundary2(transform, minX, minY, maxX, maxY) {
-  const [x1, y1] = applyToPoint71(transform, [minX, minY]);
-  const [x2, y2] = applyToPoint71(transform, [maxX, maxY]);
+  const [x1, y1] = applyToPoint72(transform, [minX, minY]);
+  const [x2, y2] = applyToPoint72(transform, [maxX, maxY]);
   const width = Math.abs(x2 - x1);
   const height = Math.abs(y2 - y1);
   const x = Math.min(x1, x2);