@tscircuit/footprinter 0.0.286 → 0.0.288

package/dist/index.js

@@ -519,25 +519,25 @@ var led = (parameters) => {
 
 // src/helpers/chipArray.ts
 var chipArray = (params) => {
-  const { padSpacing: padSpacing6, padWidth: padWidth6, padHeight: padHeight6, padPitch: padPitch6, numRows, textbottom } = params;
+  const { padSpacing: padSpacing7, padWidth, padHeight, padPitch, numRows, textbottom } = params;
   const yPositions = [];
-  const halfRange = (numRows - 1) * (padPitch6 / 2);
+  const halfRange = (numRows - 1) * (padPitch / 2);
   for (let i = 0; i < numRows; i++) {
-    yPositions.push(halfRange - i * padPitch6);
+    yPositions.push(halfRange - i * padPitch);
   }
   const pads = [];
   yPositions.forEach((y, index) => {
-    pads.push(rectpad(index + 1, -padSpacing6 / 2, y, padWidth6, padHeight6));
+    pads.push(rectpad(index + 1, -padSpacing7 / 2, y, padWidth, padHeight));
   });
   yPositions.slice().reverse().forEach((y, index) => {
     pads.push(
-      rectpad(index + numRows + 1, padSpacing6 / 2, y, padWidth6, padHeight6)
+      rectpad(index + numRows + 1, padSpacing7 / 2, y, padWidth, padHeight)
     );
   });
-  const top = Math.max(...yPositions) + padHeight6 / 2 + 0.4;
-  const bottom = Math.min(...yPositions) - padHeight6 / 2 - 0.4;
-  const left = -padSpacing6 / 2 - padWidth6 / 2 - 0.4;
-  const right = padSpacing6 / 2 + padWidth6 / 2 + 0.4;
+  const top = Math.max(...yPositions) + padHeight / 2 + 0.4;
+  const bottom = Math.min(...yPositions) - padHeight / 2 - 0.4;
+  const left = -padSpacing7 / 2 - padWidth / 2 - 0.4;
+  const right = padSpacing7 / 2 + padWidth / 2 + 0.4;
   const silkscreenTop = {
     type: "pcb_silkscreen_path",
     layer: "top",
@@ -560,11 +560,11 @@ var chipArray = (params) => {
     stroke_width: 0.12,
     pcb_silkscreen_path_id: "silkscreen_bottom"
   };
-  const pin1X = -padSpacing6 / 2;
+  const pin1X = -padSpacing7 / 2;
   const pin1Y = Math.max(...yPositions);
   const pin1MarkerSize = 0.2;
-  const pin1Left = pin1X - padWidth6 / 2 - 0.1;
-  const pin1Top = pin1Y + padHeight6 / 2 + 0.1;
+  const pin1Left = pin1X - padWidth / 2 - 0.1;
+  const pin1Top = pin1Y + padHeight / 2 + 0.1;
   const pin1Marker = {
     type: "pcb_silkscreen_path",
     layer: "top",
@@ -590,11 +590,20 @@ var chipArray = (params) => {
 };
 
 // src/helpers/res0402-array2.ts
+import { z as z4 } from "zod";
+import mm4 from "@tscircuit/mm";
+var res0402Array2_def = base_def.extend({
+  pw: z4.string().default("0.5mm"),
+  ph: z4.string().default("0.4mm"),
+  p: z4.string().default("0.7mm"),
+  textbottom: z4.boolean().optional()
+});
 var padSpacing = 1;
-var padWidth = 0.5;
-var padHeight = 0.4;
-var padPitch = 0.7;
-var res0402Array2 = (params) => {
+var res0402Array2 = (rawParams) => {
+  const params = res0402Array2_def.parse(rawParams);
+  const padWidth = mm4(params.pw);
+  const padHeight = mm4(params.ph);
+  const padPitch = mm4(params.p);
   return chipArray({
     padSpacing,
     padWidth,
@@ -606,69 +615,130 @@ var res0402Array2 = (params) => {
 };
 
 // src/helpers/res0402-array4.ts
+import { z as z5 } from "zod";
+import mm5 from "@tscircuit/mm";
+var res0402Array4_def = base_def.extend({
+  pw: z5.string().default("0.5mm"),
+  ph: z5.string().default("0.32mm"),
+  p: z5.string().default("0.5mm"),
+  textbottom: z5.boolean().optional()
+});
 var padSpacing2 = 1;
-var padWidth2 = 0.5;
-var padHeight2 = 0.32;
-var padPitch2 = 0.5;
-var res0402Array4 = (params) => {
+var res0402Array4 = (rawParams) => {
+  const params = res0402Array4_def.parse(rawParams);
+  const padWidth = mm5(params.pw);
+  const padHeight = mm5(params.ph);
+  const padPitch = mm5(params.p);
   return chipArray({
     padSpacing: padSpacing2,
-    padWidth: padWidth2,
-    padHeight: padHeight2,
-    padPitch: padPitch2,
+    padWidth,
+    padHeight,
+    padPitch,
     numRows: 4,
     textbottom: params.textbottom
   });
 };
 
 // src/helpers/res0603-array2.ts
+import { z as z6 } from "zod";
+import mm6 from "@tscircuit/mm";
+var res0603Array2_def = base_def.extend({
+  pw: z6.string().default("0.9mm"),
+  ph: z6.string().default("0.4mm"),
+  p: z6.string().default("0.8mm"),
+  textbottom: z6.boolean().optional()
+});
 var padSpacing3 = 1.7;
-var padWidth3 = 0.9;
-var padHeight3 = 0.4;
-var padPitch3 = 0.8;
-var res0603Array2 = (params) => {
+var res0603Array2 = (rawParams) => {
+  const params = res0603Array2_def.parse(rawParams);
+  const padWidth = mm6(params.pw);
+  const padHeight = mm6(params.ph);
+  const padPitch = mm6(params.p);
   return chipArray({
     padSpacing: padSpacing3,
-    padWidth: padWidth3,
-    padHeight: padHeight3,
-    padPitch: padPitch3,
+    padWidth,
+    padHeight,
+    padPitch,
     numRows: 2,
     textbottom: params.textbottom
   });
 };
 
 // src/helpers/res0603-array4.ts
+import { z as z7 } from "zod";
+import mm7 from "@tscircuit/mm";
+var res0603Array4_def = base_def.extend({
+  pw: z7.string().default("0.9mm"),
+  ph: z7.string().default("0.4mm"),
+  p: z7.string().default("0.8mm"),
+  textbottom: z7.boolean().optional()
+});
 var padSpacing4 = 1.7;
-var padWidth4 = 0.9;
-var padHeight4 = 0.4;
-var padPitch4 = 0.8;
-var res0603Array4 = (params) => {
+var res0603Array4 = (rawParams) => {
+  const params = res0603Array4_def.parse(rawParams);
+  const padWidth = mm7(params.pw);
+  const padHeight = mm7(params.ph);
+  const padPitch = mm7(params.p);
   return chipArray({
     padSpacing: padSpacing4,
-    padWidth: padWidth4,
-    padHeight: padHeight4,
-    padPitch: padPitch4,
+    padWidth,
+    padHeight,
+    padPitch,
     numRows: 4,
     textbottom: params.textbottom
   });
 };
 
 // src/helpers/res0606-array2.ts
+import { z as z8 } from "zod";
+import mm8 from "@tscircuit/mm";
+var res0606Array2_def = base_def.extend({
+  pw: z8.string().default("0.7mm"),
+  ph: z8.string().default("0.64mm"),
+  p: z8.string().default("0.94mm"),
+  textbottom: z8.boolean().optional()
+});
 var padSpacing5 = 1.4;
-var padWidth5 = 0.7;
-var padHeight5 = 0.64;
-var padPitch5 = 0.94;
-var res0606Array2 = (params) => {
+var res0606Array2 = (rawParams) => {
+  const params = res0606Array2_def.parse(rawParams);
+  const padWidth = mm8(params.pw);
+  const padHeight = mm8(params.ph);
+  const padPitch = mm8(params.p);
   return chipArray({
     padSpacing: padSpacing5,
-    padWidth: padWidth5,
-    padHeight: padHeight5,
-    padPitch: padPitch5,
+    padWidth,
+    padHeight,
+    padPitch,
     numRows: 2,
     textbottom: params.textbottom
   });
 };
 
+// src/helpers/res1206-array4.ts
+import { z as z9 } from "zod";
+import mm9 from "@tscircuit/mm";
+var res1206Array4_def = base_def.extend({
+  pw: z9.string().default("0.9mm"),
+  ph: z9.string().default("0.9mm"),
+  p: z9.string().default("1.34mm"),
+  textbottom: z9.boolean().optional()
+});
+var padSpacing6 = 3;
+var res1206Array4 = (rawParams) => {
+  const params = res1206Array4_def.parse(rawParams);
+  const padWidth = mm9(params.pw);
+  const padHeight = mm9(params.ph);
+  const padPitch = mm9(params.p);
+  return chipArray({
+    padSpacing: padSpacing6,
+    padWidth,
+    padHeight,
+    padPitch,
+    numRows: 4,
+    textbottom: params.textbottom
+  });
+};
+
 // src/fn/res.ts
 var getArrayCount = (parameters) => {
   const arrayValue = parameters.array ?? parameters.x;
@@ -726,6 +796,12 @@ var res = (rawParameters) => {
       parameters: rawParameters
     };
   }
+  if (arrayCount === 4 && imperialBase === "1206") {
+    return {
+      circuitJson: res1206Array4(rawParameters),
+      parameters: rawParameters
+    };
+  }
   return { circuitJson: passive(rawParameters), parameters: rawParameters };
 };
 
@@ -747,27 +823,27 @@ var circlepad = (pn, { x, y, radius }) => {
 var ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 
 // src/fn/bga.ts
-import { z as z6 } from "zod";
+import { z as z12 } from "zod";
 import { length as length2, distance as distance2 } from "circuit-json";
 
 // src/helpers/zod/dim-2d.ts
-import { z as z4 } from "zod";
-var dim2d = z4.string().transform((a) => {
+import { z as z10 } from "zod";
+var dim2d = z10.string().transform((a) => {
   const [x, y] = a.split(/[x ]/);
   return {
     x: parseFloat(x),
     y: parseFloat(y)
   };
 }).pipe(
-  z4.object({
-    x: z4.number(),
-    y: z4.number()
+  z10.object({
+    x: z10.number(),
+    y: z10.number()
   })
 );
 
 // src/helpers/zod/function-call.ts
-import { z as z5 } from "zod";
-var function_call = z5.string().or(z5.array(z5.any())).transform((a) => {
+import { z as z11 } from "zod";
+var function_call = z11.string().or(z11.array(z11.any())).transform((a) => {
   if (Array.isArray(a)) return a;
   if (a.startsWith("(") && a.endsWith(")")) {
     a = a.slice(1, -1);
@@ -776,24 +852,24 @@ var function_call = z5.string().or(z5.array(z5.any())).transform((a) => {
     const numVal = Number(v);
     return isNaN(numVal) ? v : numVal;
   });
-}).pipe(z5.array(z5.string().or(z5.number())));
+}).pipe(z11.array(z11.string().or(z11.number())));
 
 // src/fn/bga.ts
 import "circuit-json";
 var bga_def = base_def.extend({
-  fn: z6.string(),
-  num_pins: z6.number().optional().default(64),
+  fn: z12.string(),
+  num_pins: z12.number().optional().default(64),
   grid: dim2d.optional(),
   p: distance2.default("0.8mm"),
   w: length2.optional(),
   h: length2.optional(),
   ball: length2.optional().describe("ball diameter"),
   pad: length2.optional().describe("pad width/height"),
-  circularpads: z6.boolean().optional().describe("use circular pads"),
-  tlorigin: z6.boolean().optional(),
-  blorigin: z6.boolean().optional(),
-  trorigin: z6.boolean().optional(),
-  brorigin: z6.boolean().optional(),
+  circularpads: z12.boolean().optional().describe("use circular pads"),
+  tlorigin: z12.boolean().optional(),
+  blorigin: z12.boolean().optional(),
+  trorigin: z12.boolean().optional(),
+  brorigin: z12.boolean().optional(),
   missing: function_call.default([])
 }).transform((a) => {
   let origin = "tl";
@@ -963,7 +1039,7 @@ var bga = (raw_params) => {
 };
 
 // src/fn/soic.ts
-import { z as z7 } from "zod";
+import { z as z13 } from "zod";
 import { length as length3 } from "circuit-json";
 
 // src/helpers/pillpad.ts
@@ -984,15 +1060,15 @@ var pillpad = (pn, x, y, w, h) => {
 
 // src/fn/soic.ts
 var extendSoicDef = (newDefaults) => base_def.extend({
-  fn: z7.string(),
-  num_pins: z7.number().optional().default(8),
+  fn: z13.string(),
+  num_pins: z13.number().optional().default(8),
   w: length3.default(length3.parse(newDefaults.w ?? "5.3mm")),
   p: length3.default(length3.parse(newDefaults.p ?? "1.27mm")),
   pw: length3.default(length3.parse(newDefaults.pw ?? "0.6mm")),
   pl: length3.default(length3.parse(newDefaults.pl ?? "1.0mm")),
-  legsoutside: z7.boolean().optional().default(newDefaults.legsoutside ?? false),
-  pillpads: z7.boolean().optional().default(newDefaults.pillpads ?? false),
-  silkscreen_stroke_width: z7.number().optional().default(0.1)
+  legsoutside: z13.boolean().optional().default(newDefaults.legsoutside ?? false),
+  pillpads: z13.boolean().optional().default(newDefaults.pillpads ?? false),
+  silkscreen_stroke_width: z13.number().optional().default(0.1)
 }).transform((v) => {
   if (!v.pw && !v.pl) {
     v.pw = length3.parse("0.6mm");
@@ -1076,12 +1152,12 @@ var soicWithoutParsing = (parameters) => {
 };
 
 // src/fn/quad.ts
-import { z as z9 } from "zod";
+import { z as z15 } from "zod";
 import { length as length4 } from "circuit-json";
 
 // src/helpers/zod/pin-order-specifier.ts
-import { z as z8 } from "zod";
-var pin_order_specifier = z8.enum([
+import { z as z14 } from "zod";
+var pin_order_specifier = z14.enum([
   "leftside",
   "topside",
   "rightside",
@@ -1157,18 +1233,18 @@ var getQuadPinMap = ({
 
 // src/fn/quad.ts
 var base_quad_def = base_def.extend({
-  fn: z9.string(),
-  cc: z9.boolean().default(true).optional(),
-  ccw: z9.boolean().default(true).optional(),
-  startingpin: z9.string().or(z9.array(pin_order_specifier)).transform((a) => typeof a === "string" ? a.slice(1, -1).split(",") : a).pipe(z9.array(pin_order_specifier)).optional(),
-  num_pins: z9.number().optional().default(64),
+  fn: z15.string(),
+  cc: z15.boolean().default(true).optional(),
+  ccw: z15.boolean().default(true).optional(),
+  startingpin: z15.string().or(z15.array(pin_order_specifier)).transform((a) => typeof a === "string" ? a.slice(1, -1).split(",") : a).pipe(z15.array(pin_order_specifier)).optional(),
+  num_pins: z15.number().optional().default(64),
   w: length4.optional(),
   h: length4.optional(),
   p: length4.default(length4.parse("0.5mm")),
   pw: length4.optional(),
   pl: length4.optional(),
-  thermalpad: z9.union([z9.literal(true), dim2d]).optional(),
-  legsoutside: z9.boolean().default(false)
+  thermalpad: z15.union([z15.literal(true), dim2d]).optional(),
+  legsoutside: z15.boolean().default(false)
 });
 var quadTransform = (v) => {
   if (v.w && !v.h) {
@@ -1590,17 +1666,17 @@ var sot363 = (raw_params) => {
 };
 
 // src/fn/sot886.ts
-import { z as z10 } from "zod";
+import { z as z16 } from "zod";
 import { length as length5 } from "circuit-json";
 var sot886_def = base_def.extend({
-  fn: z10.string(),
-  num_pins: z10.literal(6).default(6),
-  w: z10.string().default("1.01mm"),
-  h: z10.string().default("1.45mm"),
-  p: z10.string().default("0.5mm"),
-  pl: z10.string().default("0.33mm"),
-  pw: z10.string().default("0.27mm"),
-  string: z10.string().optional()
+  fn: z16.string(),
+  num_pins: z16.literal(6).default(6),
+  w: z16.string().default("1.01mm"),
+  h: z16.string().default("1.45mm"),
+  p: z16.string().default("0.5mm"),
+  pl: z16.string().default("0.33mm"),
+  pw: z16.string().default("0.27mm"),
+  string: z16.string().optional()
 });
 var sot886 = (raw_params) => {
   const parameters = sot886_def.parse({ fn: "sot886", ...raw_params });
@@ -1671,16 +1747,16 @@ var getSot886PadCoord = (pn, w, p, pl) => {
 };
 
 // src/fn/sot23.ts
-import { z as z11 } from "zod";
+import { z as z17 } from "zod";
 var sot23_def = base_def.extend({
-  fn: z11.string(),
-  num_pins: z11.number().default(3),
-  w: z11.string().default("1.92mm"),
-  h: z11.string().default("2.74mm"),
-  pl: z11.string().default("1.32mm"),
-  pw: z11.string().default("0.6mm"),
-  p: z11.string().default("0.95mm"),
-  string: z11.string().optional()
+  fn: z17.string(),
+  num_pins: z17.number().default(3),
+  w: z17.string().default("1.92mm"),
+  h: z17.string().default("2.74mm"),
+  pl: z17.string().default("1.32mm"),
+  pw: z17.string().default("0.6mm"),
+  p: z17.string().default("0.95mm"),
+  string: z17.string().optional()
 });
 var sot23_6_or_8_def = extendSoicDef({
   p: "0.95mm",
@@ -1970,7 +2046,7 @@ var dfn = (raw_params) => {
 };
 
 // src/fn/pinrow.ts
-import { z as z14 } from "zod";
+import { z as z20 } from "zod";
 import { length as length6 } from "circuit-json";
 
 // src/helpers/silkscreenPin.ts
@@ -2058,28 +2134,28 @@ function determinePinlabelAnchorSide({
 
 // src/fn/pinrow.ts
 var pinrow_def = base_def.extend({
-  fn: z14.string(),
-  num_pins: z14.number().optional().default(6),
-  rows: z14.union([z14.string(), z14.number()]).transform((val) => Number(val)).optional().default(1).describe("number of rows"),
+  fn: z20.string(),
+  num_pins: z20.number().optional().default(6),
+  rows: z20.union([z20.string(), z20.number()]).transform((val) => Number(val)).optional().default(1).describe("number of rows"),
   p: length6.default("0.1in").describe("pitch"),
   id: length6.default("1.0mm").describe("inner diameter"),
   od: length6.default("1.5mm").describe("outer diameter"),
-  male: z14.boolean().optional().describe("for male pin headers"),
-  female: z14.boolean().optional().describe("for female pin headers"),
-  smd: z14.boolean().optional().describe("surface mount device"),
-  surfacemount: z14.boolean().optional().describe("surface mount device (verbose)"),
-  rightangle: z14.boolean().optional().describe("right angle"),
+  male: z20.boolean().optional().describe("for male pin headers"),
+  female: z20.boolean().optional().describe("for female pin headers"),
+  smd: z20.boolean().optional().describe("surface mount device"),
+  surfacemount: z20.boolean().optional().describe("surface mount device (verbose)"),
+  rightangle: z20.boolean().optional().describe("right angle"),
   pw: length6.optional().default("1.0mm").describe("pad width for SMD"),
   pl: length6.optional().default("2.0mm").describe("pad length for SMD"),
-  pinlabeltextalignleft: z14.boolean().optional().default(false),
-  pinlabeltextaligncenter: z14.boolean().optional().default(false),
-  pinlabeltextalignright: z14.boolean().optional().default(false),
-  pinlabelverticallyinverted: z14.boolean().optional().default(false),
-  pinlabelorthogonal: z14.boolean().optional().default(false),
-  nosquareplating: z14.boolean().optional().default(false).describe("do not use rectangular pad for pin 1"),
-  nopinlabels: z14.boolean().optional().default(false).describe("omit silkscreen pin labels"),
-  doublesidedpinlabel: z14.boolean().optional().default(false).describe("add silkscreen pins in top and bottom layers"),
-  bottomsidepinlabel: z14.boolean().optional().default(false).describe(
+  pinlabeltextalignleft: z20.boolean().optional().default(false),
+  pinlabeltextaligncenter: z20.boolean().optional().default(false),
+  pinlabeltextalignright: z20.boolean().optional().default(false),
+  pinlabelverticallyinverted: z20.boolean().optional().default(false),
+  pinlabelorthogonal: z20.boolean().optional().default(false),
+  nosquareplating: z20.boolean().optional().default(false).describe("do not use rectangular pad for pin 1"),
+  nopinlabels: z20.boolean().optional().default(false).describe("omit silkscreen pin labels"),
+  doublesidedpinlabel: z20.boolean().optional().default(false).describe("add silkscreen pins in top and bottom layers"),
+  bottomsidepinlabel: z20.boolean().optional().default(false).describe(
     "place the silkscreen reference text on the bottom layer instead of top"
   )
 }).transform((data) => {
@@ -2095,7 +2171,7 @@ var pinrow_def = base_def.extend({
 }).superRefine((data, ctx) => {
   if (data.male && data.female) {
     ctx.addIssue({
-      code: z14.ZodIssueCode.custom,
+      code: z20.ZodIssueCode.custom,
       message: "'male' and 'female' cannot both be true; it should be male or female.",
       path: ["male", "female"]
     });
@@ -2326,17 +2402,17 @@ var pinrow = (raw_params) => {
 };
 
 // src/fn/sot563.ts
-import { z as z15 } from "zod";
+import { z as z21 } from "zod";
 import { length as length7 } from "circuit-json";
 var sot563_def = base_def.extend({
-  fn: z15.string(),
-  num_pins: z15.literal(6).default(6),
-  w: z15.string().default("2.1mm"),
-  h: z15.string().default("2.45mm"),
-  p: z15.string().default("0.5mm"),
-  pl: z15.string().default("0.675mm"),
-  pw: z15.string().default("0.35mm"),
-  string: z15.string().optional()
+  fn: z21.string(),
+  num_pins: z21.literal(6).default(6),
+  w: z21.string().default("2.1mm"),
+  h: z21.string().default("2.45mm"),
+  p: z21.string().default("0.5mm"),
+  pl: z21.string().default("0.675mm"),
+  pw: z21.string().default("0.35mm"),
+  string: z21.string().optional()
 });
 var sot563 = (raw_params) => {
   const parameters = sot563_def.parse({ ...raw_params, fn: "sot563" });
@@ -2436,15 +2512,15 @@ var ms013 = (raw_params) => {
 
 // src/fn/sot723.ts
 import { length as length8 } from "circuit-json";
-import { z as z16 } from "zod";
+import { z as z22 } from "zod";
 var sot723_def = base_def.extend({
-  fn: z16.string(),
-  num_pins: z16.literal(3).default(3),
-  w: z16.string().default("1.2mm"),
-  h: z16.string().default("1.2mm"),
-  pw: z16.string().default("0.40mm"),
-  pl: z16.string().default("0.45mm"),
-  p: z16.string().default("0.575mm")
+  fn: z22.string(),
+  num_pins: z22.literal(3).default(3),
+  w: z22.string().default("1.2mm"),
+  h: z22.string().default("1.2mm"),
+  pw: z22.string().default("0.40mm"),
+  pl: z22.string().default("0.45mm"),
+  p: z22.string().default("0.575mm")
 });
 var sot723 = (raw_params) => {
   const parameters = sot723_def.parse(raw_params);
@@ -2494,16 +2570,16 @@ var sot723WithoutParsing = (parameters) => {
 };
 
 // src/fn/sod123.ts
-import { z as z17 } from "zod";
+import { z as z23 } from "zod";
 import { length as length9 } from "circuit-json";
 var sod_def = base_def.extend({
-  fn: z17.string(),
-  num_pins: z17.literal(2).default(2),
-  w: z17.string().default("2.36mm"),
-  h: z17.string().default("1.22mm"),
-  pl: z17.string().default("0.9mm"),
-  pw: z17.string().default("1.2mm"),
-  p: z17.string().default("3.30mm")
+  fn: z23.string(),
+  num_pins: z23.literal(2).default(2),
+  w: z23.string().default("2.36mm"),
+  h: z23.string().default("1.22mm"),
+  pl: z23.string().default("0.9mm"),
+  pw: z23.string().default("1.2mm"),
+  p: z23.string().default("3.30mm")
 });
 var sod123 = (raw_params) => {
   const parameters = sod_def.parse(raw_params);
@@ -2551,9 +2627,9 @@ var sodWithoutParsing = (parameters) => {
 import {
   length as length10
 } from "circuit-json";
-import { z as z18 } from "zod";
+import { z as z24 } from "zod";
 var axial_def = base_def.extend({
-  fn: z18.string(),
+  fn: z24.string(),
   p: length10.optional().default("2.54mm"),
   id: length10.optional().default("0.7mm"),
   od: length10.optional().default("1.4mm")
@@ -2591,7 +2667,7 @@ var axial = (raw_params) => {
 import {
   length as length11
 } from "circuit-json";
-import { z as z19 } from "zod";
+import { z as z25 } from "zod";
 
 // src/helpers/generateCircleArcs.ts
 var generateCircleArcs = (centerX, centerY, radius, cut, cutHeight, segmentLength = 0.1) => {
@@ -2622,13 +2698,13 @@ var generateCircleArcs = (centerX, centerY, radius, cut, cutHeight, segmentLengt
 
 // src/fn/radial.ts
 var radial_def = base_def.extend({
-  fn: z19.string(),
+  fn: z25.string(),
   p: length11.optional().default("5mm"),
   id: length11.optional().default("0.8mm"),
   od: length11.optional().default("1.6mm"),
-  ceramic: z19.boolean().optional(),
-  electrolytic: z19.boolean().optional(),
-  polarized: z19.boolean().optional()
+  ceramic: z25.boolean().optional(),
+  electrolytic: z25.boolean().optional(),
+  polarized: z25.boolean().optional()
 });
 var radial = (raw_params) => {
   const parameters = radial_def.parse(raw_params);
@@ -2726,7 +2802,7 @@ var radial = (raw_params) => {
 
 // src/fn/pushbutton.ts
 import { length as length12 } from "circuit-json";
-import { z as z20 } from "zod";
+import { z as z26 } from "zod";
 
 // src/helpers/silkscreenpath.ts
 var silkscreenpath = (route, options = {}) => {
@@ -2742,7 +2818,7 @@ var silkscreenpath = (route, options = {}) => {
 
 // src/fn/pushbutton.ts
 var pushbutton_def = base_def.extend({
-  fn: z20.literal("pushbutton"),
+  fn: z26.literal("pushbutton"),
   w: length12.default(4.5),
   h: length12.default(6.5),
   id: length12.default(1),
@@ -2795,9 +2871,9 @@ var pushbutton = (raw_params) => {
 import {
   length as length13
 } from "circuit-json";
-import { z as z21 } from "zod";
+import { z as z27 } from "zod";
 var stampboard_def = base_def.extend({
-  fn: z21.string(),
+  fn: z27.string(),
   w: length13.default("22.58mm"),
   h: length13.optional(),
   left: length13.optional().default(20),
@@ -2807,9 +2883,9 @@ var stampboard_def = base_def.extend({
   p: length13.default(length13.parse("2.54mm")),
   pw: length13.default(length13.parse("1.6mm")),
   pl: length13.default(length13.parse("2.4mm")),
-  innerhole: z21.boolean().default(false),
+  innerhole: z27.boolean().default(false),
   innerholeedgedistance: length13.default(length13.parse("1.61mm")),
-  silkscreenlabels: z21.boolean().default(false),
+  silkscreenlabels: z27.boolean().default(false),
   silkscreenlabelmargin: length13.default(length13.parse("0.1mm"))
 });
 var getHeight = (parameters) => {
@@ -3221,9 +3297,9 @@ var stampboard = (raw_params) => {
 import {
   length as length14
 } from "circuit-json";
-import { z as z22 } from "zod";
+import { z as z28 } from "zod";
 var stampreceiver_def = base_def.extend({
-  fn: z22.string(),
+  fn: z28.string(),
   w: length14.default("22.58mm"),
   h: length14.optional(),
   left: length14.optional().default(20),
@@ -3233,7 +3309,7 @@ var stampreceiver_def = base_def.extend({
   p: length14.default(length14.parse("2.54mm")),
   pw: length14.default(length14.parse("1.6mm")),
   pl: length14.default(length14.parse("3.2mm")),
-  innerhole: z22.boolean().default(false),
+  innerhole: z28.boolean().default(false),
   innerholeedgedistance: length14.default(length14.parse("1.61mm"))
 });
 var getHeight2 = (parameters) => {
@@ -3537,9 +3613,9 @@ var lqfp = (parameters) => {
 import {
   length as length15
 } from "circuit-json";
-import { z as z23 } from "zod";
+import { z as z29 } from "zod";
 var breakoutheaders_def = base_def.extend({
-  fn: z23.string(),
+  fn: z29.string(),
   w: length15.default("10mm"),
   h: length15.optional(),
   left: length15.optional().default(20),
@@ -3742,7 +3818,7 @@ var breakoutheaders = (raw_params) => {
 import {
   length as length16
 } from "circuit-json";
-import { z as z24 } from "zod";
+import { z as z30 } from "zod";
 var generate_u_curve = (centerX, centerY, radius, direction) => {
   return Array.from({ length: 25 }, (_, i) => {
     const theta = i / 24 * Math.PI - Math.PI / 2;
@@ -3753,7 +3829,7 @@ var generate_u_curve = (centerX, centerY, radius, direction) => {
   });
 };
 var hc49_def = base_def.extend({
-  fn: z24.string(),
+  fn: z30.string(),
   p: length16.optional().default("4.88mm"),
   id: length16.optional().default("0.8mm"),
   od: length16.optional().default("1.5mm"),
@@ -3800,15 +3876,15 @@ var hc49 = (raw_params) => {
 // src/fn/pad.ts
 import "zod";
 import { length as length17 } from "circuit-json";
-import { mm as mm5 } from "@tscircuit/mm";
+import { mm as mm11 } from "@tscircuit/mm";
 var pad_def = base_def.extend({
   w: length17,
   h: length17
 });
 var pad = (params) => {
   const { w, h } = params;
-  const width = mm5(w);
-  const height = mm5(h);
+  const width = mm11(w);
+  const height = mm11(h);
   return {
     circuitJson: [
       rectpad(1, 0, 0, width, height),
@@ -3819,11 +3895,11 @@ var pad = (params) => {
 };
 
 // src/fn/to92.ts
-import { z as z26 } from "zod";
+import { z as z32 } from "zod";
 import "@tscircuit/mm";
 
 // src/helpers/platedHolePill.ts
-import { mm as mm6 } from "@tscircuit/mm";
+import { mm as mm12 } from "@tscircuit/mm";
 var platedHolePill = (pn, x, y, holeDiameter, outerWidth, outerHeight) => {
   return {
     pcb_plated_hole_id: "",
@@ -3831,10 +3907,10 @@ var platedHolePill = (pn, x, y, holeDiameter, outerWidth, outerHeight) => {
     shape: "pill",
     x,
     y,
-    outer_width: mm6(outerWidth),
-    outer_height: mm6(outerHeight),
-    hole_width: mm6(holeDiameter),
-    hole_height: mm6(holeDiameter),
+    outer_width: mm12(outerWidth),
+    outer_height: mm12(outerHeight),
+    hole_width: mm12(holeDiameter),
+    hole_height: mm12(holeDiameter),
     pcb_port_id: "",
     layers: ["top", "bottom"],
     port_hints: [pn.toString()],
@@ -3844,15 +3920,15 @@ var platedHolePill = (pn, x, y, holeDiameter, outerWidth, outerHeight) => {
 
 // src/fn/to92.ts
 var to92_def = base_def.extend({
-  fn: z26.string(),
-  num_pins: z26.union([z26.literal(3), z26.literal(2)]).default(3),
-  p: z26.string().default("1.27mm"),
-  id: z26.string().default("0.72mm"),
-  od: z26.string().default("0.95mm"),
-  w: z26.string().default("4.5mm"),
-  h: z26.string().default("4.5mm"),
-  inline: z26.boolean().default(false),
-  string: z26.string().optional()
+  fn: z32.string(),
+  num_pins: z32.union([z32.literal(3), z32.literal(2)]).default(3),
+  p: z32.string().default("1.27mm"),
+  id: z32.string().default("0.72mm"),
+  od: z32.string().default("0.95mm"),
+  w: z32.string().default("4.5mm"),
+  h: z32.string().default("4.5mm"),
+  inline: z32.boolean().default(false),
+  string: z32.string().optional()
 });
 var generateSemicircle = (centerX, centerY, radius) => {
   return Array.from({ length: 25 }, (_, i) => {
@@ -3872,41 +3948,41 @@ var to92 = (raw_params) => {
   });
   const { p, id, od, w, h, inline } = parameters;
   const holeY = Number.parseFloat(h) / 2;
-  const padSpacing6 = Number.parseFloat(p);
+  const padSpacing7 = Number.parseFloat(p);
   const holeDia = Number.parseFloat(id);
   const padDia = Number.parseFloat(od);
-  const padWidth6 = padDia;
-  const padHeight6 = padDia * (1.5 / 1.05);
+  const padWidth = padDia;
+  const padHeight = padDia * (1.5 / 1.05);
   let platedHoles = [];
   if (parameters.num_pins === 3) {
     if (inline) {
       platedHoles = [
         platedHoleWithRectPad(
           1,
-          -padSpacing6,
-          holeY - padSpacing6,
+          -padSpacing7,
+          holeY - padSpacing7,
           holeDia,
           padDia,
-          padHeight6,
+          padHeight,
           0,
           0
         ),
-        platedHolePill(2, 0, holeY - padSpacing6, holeDia, padWidth6, padHeight6),
+        platedHolePill(2, 0, holeY - padSpacing7, holeDia, padWidth, padHeight),
         platedHolePill(
           3,
-          padSpacing6,
-          holeY - padSpacing6,
+          padSpacing7,
+          holeY - padSpacing7,
           holeDia,
-          padWidth6,
-          padHeight6
+          padWidth,
+          padHeight
         )
       ];
     } else {
       platedHoles = [
         platedHoleWithRectPad(
           1,
-          -padSpacing6,
-          holeY - padSpacing6,
+          -padSpacing7,
+          holeY - padSpacing7,
           holeDia,
           padDia,
           padDia,
@@ -3914,28 +3990,28 @@ var to92 = (raw_params) => {
           0
         ),
         platedhole(2, 0, holeY, holeDia, padDia),
-        platedhole(3, padSpacing6, holeY - padSpacing6, holeDia, padDia)
+        platedhole(3, padSpacing7, holeY - padSpacing7, holeDia, padDia)
       ];
     }
   } else if (parameters.num_pins === 2) {
     platedHoles = [
       platedHoleWithRectPad(
         1,
-        -padSpacing6,
-        holeY - padSpacing6,
+        -padSpacing7,
+        holeY - padSpacing7,
         holeDia,
-        padWidth6,
-        padHeight6,
+        padWidth,
+        padHeight,
         0,
         0
       ),
       platedHolePill(
         2,
-        padSpacing6,
-        holeY - padSpacing6,
+        padSpacing7,
+        holeY - padSpacing7,
         holeDia,
-        padWidth6,
-        padHeight6
+        padWidth,
+        padHeight
       )
     ];
   } else {
@@ -3968,16 +4044,16 @@ var to92 = (raw_params) => {
 };
 
 // src/fn/sod523.ts
-import { z as z27 } from "zod";
+import { z as z33 } from "zod";
 import { length as length18 } from "circuit-json";
 var sod_def2 = base_def.extend({
-  fn: z27.string(),
-  num_pins: z27.literal(2).default(2),
-  w: z27.string().default("2.15mm"),
-  h: z27.string().default("1.20mm"),
-  pl: z27.string().default("0.5mm"),
-  pw: z27.string().default("0.6mm"),
-  p: z27.string().default("1.4mm")
+  fn: z33.string(),
+  num_pins: z33.literal(2).default(2),
+  w: z33.string().default("2.15mm"),
+  h: z33.string().default("1.20mm"),
+  pl: z33.string().default("0.5mm"),
+  pw: z33.string().default("0.6mm"),
+  p: z33.string().default("1.4mm")
 });
 var sod523 = (raw_params) => {
   const parameters = sod_def2.parse(raw_params);
@@ -4093,16 +4169,16 @@ var sop8 = (raw_params) => {
 };
 
 // src/fn/sod80.ts
-import { z as z28 } from "zod";
+import { z as z34 } from "zod";
 import { length as length19 } from "circuit-json";
 var sod80_def = base_def.extend({
-  fn: z28.string(),
-  num_pins: z28.literal(2).default(2),
-  w: z28.string().default("5.0mm"),
-  h: z28.string().default("2.30mm"),
-  pl: z28.string().default("1.25mm"),
-  pw: z28.string().default("2mm"),
-  p: z28.string().default("3.75mm")
+  fn: z34.string(),
+  num_pins: z34.literal(2).default(2),
+  w: z34.string().default("5.0mm"),
+  h: z34.string().default("2.30mm"),
+  pl: z34.string().default("1.25mm"),
+  pw: z34.string().default("2mm"),
+  p: z34.string().default("3.75mm")
 });
 var sod80 = (raw_params) => {
   const parameters = sod80_def.parse(raw_params);
@@ -4169,16 +4245,16 @@ var sod80WithoutParsing = (parameters) => {
 };
 
 // src/fn/sod123w.ts
-import { z as z29 } from "zod";
+import { z as z35 } from "zod";
 import { length as length20 } from "circuit-json";
 var sod_def3 = base_def.extend({
-  fn: z29.string(),
-  num_pins: z29.literal(2).default(2),
-  w: z29.string().default("4.4mm"),
-  h: z29.string().default("2.1mm"),
-  pl: z29.string().default("1.2mm"),
-  pw: z29.string().default("1.2mm"),
-  p: z29.string().default("2.9mm")
+  fn: z35.string(),
+  num_pins: z35.literal(2).default(2),
+  w: z35.string().default("4.4mm"),
+  h: z35.string().default("2.1mm"),
+  pl: z35.string().default("1.2mm"),
+  pw: z35.string().default("1.2mm"),
+  p: z35.string().default("2.9mm")
 });
 var sod123w = (raw_params) => {
   const parameters = sod_def3.parse(raw_params);
@@ -4248,16 +4324,16 @@ var sodWithoutParsing3 = (parameters) => {
 };
 
 // src/fn/sod323.ts
-import { z as z30 } from "zod";
+import { z as z36 } from "zod";
 import { length as length21 } from "circuit-json";
 var sod_def4 = base_def.extend({
-  fn: z30.string(),
-  num_pins: z30.literal(2).default(2),
-  w: z30.string().default("3.30mm"),
-  h: z30.string().default("1.80mm"),
-  pl: z30.string().default("0.60mm"),
-  pw: z30.string().default("0.45mm"),
-  p: z30.string().default("2.1mm")
+  fn: z36.string(),
+  num_pins: z36.literal(2).default(2),
+  w: z36.string().default("3.30mm"),
+  h: z36.string().default("1.80mm"),
+  pl: z36.string().default("0.60mm"),
+  pw: z36.string().default("0.45mm"),
+  p: z36.string().default("2.1mm")
 });
 var sod323 = (raw_params) => {
   const parameters = sod_def4.parse(raw_params);
@@ -4327,16 +4403,16 @@ var sodWithoutParsing4 = (parameters) => {
 };
 
 // src/fn/sod923.ts
-import { z as z31 } from "zod";
+import { z as z37 } from "zod";
 import { length as length22 } from "circuit-json";
 var sod_def5 = base_def.extend({
-  fn: z31.string(),
-  num_pins: z31.literal(2).default(2),
-  w: z31.string().default("1.4mm"),
-  h: z31.string().default("0.9mm"),
-  pl: z31.string().default("0.36mm"),
-  pw: z31.string().default("0.25mm"),
-  p: z31.string().default("0.85mm")
+  fn: z37.string(),
+  num_pins: z37.literal(2).default(2),
+  w: z37.string().default("1.4mm"),
+  h: z37.string().default("0.9mm"),
+  pl: z37.string().default("0.36mm"),
+  pw: z37.string().default("0.25mm"),
+  p: z37.string().default("0.85mm")
 });
 var sod923 = (raw_params) => {
   const parameters = sod_def5.parse(raw_params);
@@ -4407,16 +4483,16 @@ var sodWithoutParsing5 = (parameters) => {
 };
 
 // src/fn/sod882.ts
-import { z as z32 } from "zod";
+import { z as z38 } from "zod";
 import { length as length23 } from "circuit-json";
 var sod_def6 = base_def.extend({
-  fn: z32.string(),
-  num_pins: z32.literal(2).default(2),
-  w: z32.string().default("1.3mm"),
-  h: z32.string().default("0.9mm"),
-  pl: z32.string().default("0.4mm"),
-  pw: z32.string().default("0.7mm"),
-  p: z32.string().default("0.7mm")
+  fn: z38.string(),
+  num_pins: z38.literal(2).default(2),
+  w: z38.string().default("1.3mm"),
+  h: z38.string().default("0.9mm"),
+  pl: z38.string().default("0.4mm"),
+  pw: z38.string().default("0.7mm"),
+  p: z38.string().default("0.7mm")
 });
 var sod882 = (raw_params) => {
   const parameters = sod_def6.parse(raw_params);
@@ -4487,16 +4563,16 @@ var sodWithoutParsing6 = (parameters) => {
 };
 
 // src/fn/sod323f.ts
-import { z as z33 } from "zod";
+import { z as z39 } from "zod";
 import { length as length24 } from "circuit-json";
 var sod_def7 = base_def.extend({
-  fn: z33.string(),
-  num_pins: z33.literal(2).default(2),
-  w: z33.string().default("3,05mm"),
-  h: z33.string().default("1.65mm"),
-  pl: z33.string().default("0.6mm"),
-  pw: z33.string().default("0.6mm"),
-  pad_spacing: z33.string().default("2.2mm")
+  fn: z39.string(),
+  num_pins: z39.literal(2).default(2),
+  w: z39.string().default("3,05mm"),
+  h: z39.string().default("1.65mm"),
+  pl: z39.string().default("0.6mm"),
+  pw: z39.string().default("0.6mm"),
+  pad_spacing: z39.string().default("2.2mm")
 });
 var sod323f = (raw_params) => {
   const parameters = sod_def7.parse(raw_params);
@@ -4567,16 +4643,16 @@ var sodWithoutParsing7 = (parameters) => {
 };
 
 // src/fn/sod123f.ts
-import { z as z34 } from "zod";
+import { z as z40 } from "zod";
 import { length as length25 } from "circuit-json";
 var sod_def8 = base_def.extend({
-  fn: z34.string(),
-  num_pins: z34.literal(2).default(2),
-  w: z34.string().default("4.4mm"),
-  h: z34.string().default("2.1mm"),
-  pl: z34.string().default("1.2mm"),
-  pw: z34.string().default("1.2mm"),
-  p: z34.string().default("2.9mm")
+  fn: z40.string(),
+  num_pins: z40.literal(2).default(2),
+  w: z40.string().default("4.4mm"),
+  h: z40.string().default("2.1mm"),
+  pl: z40.string().default("1.2mm"),
+  pw: z40.string().default("1.2mm"),
+  p: z40.string().default("2.9mm")
 });
 var sod123f = (raw_params) => {
   const parameters = sod_def8.parse(raw_params);
@@ -4647,16 +4723,16 @@ var sodWithoutParsing8 = (parameters) => {
 };
 
 // src/fn/sod123fl.ts
-import { z as z35 } from "zod";
+import { z as z41 } from "zod";
 import { length as length26 } from "circuit-json";
 var sod123FL_def = base_def.extend({
-  fn: z35.string(),
-  num_pins: z35.literal(2).default(2),
-  w: z35.string().default("4.4mm"),
-  h: z35.string().default("2.1mm"),
-  pl: z35.string().default("0.91mm"),
-  pw: z35.string().default("1.22mm"),
-  p: z35.string().default("3.146mm")
+  fn: z41.string(),
+  num_pins: z41.literal(2).default(2),
+  w: z41.string().default("4.4mm"),
+  h: z41.string().default("2.1mm"),
+  pl: z41.string().default("0.91mm"),
+  pw: z41.string().default("1.22mm"),
+  p: z41.string().default("3.146mm")
 });
 var sod123fl = (raw_params) => {
   const parameters = sod123FL_def.parse(raw_params);
@@ -4727,16 +4803,16 @@ var sodWithoutParsing9 = (parameters) => {
 };
 
 // src/fn/sod723.ts
-import { z as z36 } from "zod";
+import { z as z42 } from "zod";
 import { length as length27 } from "circuit-json";
 var sod_def9 = base_def.extend({
-  fn: z36.string(),
-  num_pins: z36.literal(2).default(2),
-  w: z36.string().default("1.80mm"),
-  h: z36.string().default("1.00mm"),
-  pl: z36.string().default("0.66mm"),
-  pw: z36.string().default("0.5mm"),
-  p: z36.string().default("0.8mm")
+  fn: z42.string(),
+  num_pins: z42.literal(2).default(2),
+  w: z42.string().default("1.80mm"),
+  h: z42.string().default("1.00mm"),
+  pl: z42.string().default("0.66mm"),
+  pw: z42.string().default("0.5mm"),
+  p: z42.string().default("0.8mm")
 });
 var sod723 = (raw_params) => {
   const parameters = sod_def9.parse(raw_params);
@@ -4807,16 +4883,16 @@ var sodWithoutParsing10 = (parameters) => {
 };
 
 // src/fn/sod128.ts
-import { z as z37 } from "zod";
+import { z as z43 } from "zod";
 import { length as length28 } from "circuit-json";
 var sod_def10 = base_def.extend({
-  fn: z37.string(),
-  num_pins: z37.literal(2).default(2),
-  w: z37.string().default("6.2mm"),
-  h: z37.string().default("3.4mm"),
-  pl: z37.string().default("1.4mm"),
-  pw: z37.string().default("2.1mm"),
-  p: z37.string().default("4.4mm")
+  fn: z43.string(),
+  num_pins: z43.literal(2).default(2),
+  w: z43.string().default("6.2mm"),
+  h: z43.string().default("3.4mm"),
+  pl: z43.string().default("1.4mm"),
+  pw: z43.string().default("2.1mm"),
+  p: z43.string().default("4.4mm")
 });
 var sod128 = (raw_params) => {
   const parameters = sod_def10.parse(raw_params);
@@ -4887,29 +4963,29 @@ var sodWithoutParsing11 = (parameters) => {
 };
 
 // src/fn/sot89.ts
-import { z as z38 } from "zod";
+import { z as z44 } from "zod";
 var sot89_def = base_def.extend({
-  fn: z38.string(),
-  num_pins: z38.union([z38.literal(3), z38.literal(5)]).default(3),
-  w: z38.string().default("4.20mm"),
-  h: z38.string().default("4.80mm"),
-  pl: z38.string().default("1.3mm"),
-  pw: z38.string().default("0.9mm"),
-  p: z38.string().default("1.5mm"),
-  string: z38.string().optional()
+  fn: z44.string(),
+  num_pins: z44.union([z44.literal(3), z44.literal(5)]).default(3),
+  w: z44.string().default("4.20mm"),
+  h: z44.string().default("4.80mm"),
+  pl: z44.string().default("1.3mm"),
+  pw: z44.string().default("0.9mm"),
+  p: z44.string().default("1.5mm"),
+  string: z44.string().optional()
 });
 var sot89_3 = (parameters) => {
   const pads = [];
   const padGap = Number.parseFloat(parameters.p);
-  const padWidth6 = Number.parseFloat(parameters.pw);
+  const padWidth = Number.parseFloat(parameters.pw);
   const length51 = Number.parseFloat(parameters.w);
-  const padHeight6 = Number.parseFloat(parameters.pl);
+  const padHeight = Number.parseFloat(parameters.pl);
   const centerExtra = 0.175;
-  const outerPadXShift = (padHeight6 - (padHeight6 + centerExtra)) / 2;
+  const outerPadXShift = (padHeight - (padHeight + centerExtra)) / 2;
   pads.push(
-    rectpad(1, -length51 / 2 + outerPadXShift, padGap, padHeight6, padWidth6),
-    rectpad(2, -length51 / 2, 0, padHeight6 + centerExtra, padWidth6),
-    rectpad(3, -length51 / 2 + outerPadXShift, -padGap, padHeight6, padWidth6)
+    rectpad(1, -length51 / 2 + outerPadXShift, padGap, padHeight, padWidth),
+    rectpad(2, -length51 / 2, 0, padHeight + centerExtra, padWidth),
+    rectpad(3, -length51 / 2 + outerPadXShift, -padGap, padHeight, padWidth)
   );
   const silkscreenRefText = silkscreenRef(0, 0, 0.3);
   const width = Number.parseFloat(parameters.w) / 2 - 1;
@@ -4948,7 +5024,7 @@ var sot89_3 = (parameters) => {
 var sot89_5 = (parameters) => {
   const pads = [];
   const padGap = Number.parseFloat(parameters.p);
-  const padWidth6 = Number.parseFloat(parameters.pw);
+  const padWidth = Number.parseFloat(parameters.pw);
   const length51 = Number.parseFloat(parameters.w);
   pads.push(
     rectpad(1, -1.85, -1.5, 1.5, 0.7),
@@ -5019,16 +5095,16 @@ var sot89 = (raw_params) => {
 import {
   length as length29
 } from "circuit-json";
-import { z as z39 } from "zod";
+import { z as z45 } from "zod";
 var to220_def = base_def.extend({
-  fn: z39.string(),
+  fn: z45.string(),
   p: length29.optional().default("5.0mm"),
   id: length29.optional().default("1.0mm"),
   od: length29.optional().default("1.9mm"),
   w: length29.optional().default("13mm"),
   h: length29.optional().default("7mm"),
-  num_pins: z39.number().optional(),
-  string: z39.string().optional()
+  num_pins: z45.number().optional(),
+  string: z45.string().optional()
 });
 var to220 = (raw_params) => {
   const parameters = to220_def.parse(raw_params);
@@ -5108,16 +5184,16 @@ var to220 = (raw_params) => {
 };
 
 // src/fn/minimelf.ts
-import { z as z40 } from "zod";
+import { z as z46 } from "zod";
 import { length as length30 } from "circuit-json";
 var minimelf_def = base_def.extend({
-  fn: z40.string(),
-  num_pins: z40.literal(2).default(2),
-  w: z40.string().default("5.40mm"),
-  h: z40.string().default("2.30mm"),
-  pl: z40.string().default("1.30mm"),
-  pw: z40.string().default("1.70mm"),
-  p: z40.string().default("3.5mm")
+  fn: z46.string(),
+  num_pins: z46.literal(2).default(2),
+  w: z46.string().default("5.40mm"),
+  h: z46.string().default("2.30mm"),
+  pl: z46.string().default("1.30mm"),
+  pw: z46.string().default("1.70mm"),
+  p: z46.string().default("3.5mm")
 });
 var minimelf = (raw_params) => {
   const parameters = minimelf_def.parse(raw_params);
@@ -5184,16 +5260,16 @@ var miniMelfWithoutParsing = (parameters) => {
 };
 
 // src/fn/sod882d.ts
-import { z as z41 } from "zod";
+import { z as z47 } from "zod";
 import { length as length31 } from "circuit-json";
 var sod_def11 = base_def.extend({
-  fn: z41.string(),
-  num_pins: z41.literal(2).default(2),
-  w: z41.string().default("1.90mm"),
-  h: z41.string().default("1.33mm"),
-  pl: z41.string().default("0.5mm"),
-  pw: z41.string().default("0.7mm"),
-  p: z41.string().default("0.8mm")
+  fn: z47.string(),
+  num_pins: z47.literal(2).default(2),
+  w: z47.string().default("1.90mm"),
+  h: z47.string().default("1.33mm"),
+  pl: z47.string().default("0.5mm"),
+  pw: z47.string().default("0.7mm"),
+  p: z47.string().default("0.8mm")
 });
 var sod882d = (raw_params) => {
   const parameters = sod_def11.parse(raw_params);
@@ -5264,16 +5340,16 @@ var sodWithoutParsing12 = (parameters) => {
 };
 
 // src/fn/melf.ts
-import { z as z42 } from "zod";
+import { z as z48 } from "zod";
 import { length as length32 } from "circuit-json";
 var melf_def = base_def.extend({
-  fn: z42.string(),
-  num_pins: z42.literal(2).default(2),
-  w: z42.string().default("7.0mm"),
-  h: z42.string().default("3.35mm"),
-  pl: z42.string().default("1.50mm"),
-  pw: z42.string().default("2.70mm"),
-  p: z42.string().default("4.8mm")
+  fn: z48.string(),
+  num_pins: z48.literal(2).default(2),
+  w: z48.string().default("7.0mm"),
+  h: z48.string().default("3.35mm"),
+  pl: z48.string().default("1.50mm"),
+  pw: z48.string().default("2.70mm"),
+  p: z48.string().default("4.8mm")
 });
 var melf = (raw_params) => {
   const parameters = melf_def.parse(raw_params);
@@ -5344,16 +5420,16 @@ var melfWithoutParsing = (parameters) => {
 };
 
 // src/fn/micromelf.ts
-import { z as z43 } from "zod";
+import { z as z49 } from "zod";
 import { length as length33 } from "circuit-json";
 var micromelf_def = base_def.extend({
-  fn: z43.string(),
-  num_pins: z43.literal(2).default(2),
-  w: z43.string().default("3.0mm"),
-  h: z43.string().default("1.80mm"),
-  pl: z43.string().default("0.80mm"),
-  pw: z43.string().default("1.20mm"),
-  p: z43.string().default("1.6mm")
+  fn: z49.string(),
+  num_pins: z49.literal(2).default(2),
+  w: z49.string().default("3.0mm"),
+  h: z49.string().default("1.80mm"),
+  pl: z49.string().default("0.80mm"),
+  pw: z49.string().default("1.20mm"),
+  p: z49.string().default("1.6mm")
 });
 var micromelf = (raw_params) => {
   const parameters = micromelf_def.parse(raw_params);
@@ -5424,16 +5500,16 @@ var microMelfWithoutParsing = (parameters) => {
 };
 
 // src/fn/sma.ts
-import { z as z44 } from "zod";
+import { z as z50 } from "zod";
 import { length as length34 } from "circuit-json";
 var sma_def = base_def.extend({
-  fn: z44.string(),
-  num_pins: z44.literal(2).default(2),
-  w: z44.string().default("7.10mm"),
-  h: z44.string().default("3.40mm"),
-  pl: z44.string().default("2.45mm"),
-  pw: z44.string().default("1.80mm"),
-  p: z44.string().default("4.05mm")
+  fn: z50.string(),
+  num_pins: z50.literal(2).default(2),
+  w: z50.string().default("7.10mm"),
+  h: z50.string().default("3.40mm"),
+  pl: z50.string().default("2.45mm"),
+  pw: z50.string().default("1.80mm"),
+  p: z50.string().default("4.05mm")
 });
 var sma = (raw_params) => {
   const parameters = sma_def.parse(raw_params);
@@ -5503,16 +5579,16 @@ var smaWithoutParsing = (parameters) => {
 };
 
 // src/fn/smf.ts
-import { z as z45 } from "zod";
+import { z as z51 } from "zod";
 import { length as length35 } from "circuit-json";
 var smf_def = base_def.extend({
-  fn: z45.string(),
-  num_pins: z45.literal(2).default(2),
-  w: z45.string().default("4.80mm"),
-  h: z45.string().default("2.10mm"),
-  pl: z45.string().default("1.30mm"),
-  pw: z45.string().default("1.40mm"),
-  p: z45.string().default("2.9mm")
+  fn: z51.string(),
+  num_pins: z51.literal(2).default(2),
+  w: z51.string().default("4.80mm"),
+  h: z51.string().default("2.10mm"),
+  pl: z51.string().default("1.30mm"),
+  pw: z51.string().default("1.40mm"),
+  p: z51.string().default("2.9mm")
 });
 var smf = (raw_params) => {
   const parameters = smf_def.parse(raw_params);
@@ -5583,16 +5659,16 @@ var smfWithoutParsing = (parameters) => {
 };
 
 // src/fn/smb.ts
-import { z as z46 } from "zod";
+import { z as z52 } from "zod";
 import { length as length36 } from "circuit-json";
 var smb_def = base_def.extend({
-  fn: z46.string(),
-  num_pins: z46.literal(2).default(2),
-  w: z46.string().default("7.30mm"),
-  h: z46.string().default("4.40mm"),
-  pl: z46.string().default("2.50mm"),
-  pw: z46.string().default("2.30mm"),
-  p: z46.string().default("4.30mm")
+  fn: z52.string(),
+  num_pins: z52.literal(2).default(2),
+  w: z52.string().default("7.30mm"),
+  h: z52.string().default("4.40mm"),
+  pl: z52.string().default("2.50mm"),
+  pw: z52.string().default("2.30mm"),
+  p: z52.string().default("4.30mm")
 });
 var smb = (raw_params) => {
   const parameters = smb_def.parse(raw_params);
@@ -5663,16 +5739,16 @@ var smbWithoutParsing = (parameters) => {
 };
 
 // src/fn/smc.ts
-import { z as z47 } from "zod";
+import { z as z53 } from "zod";
 import { length as length37 } from "circuit-json";
 var smc_def = base_def.extend({
-  fn: z47.string(),
-  num_pins: z47.literal(2).default(2),
-  w: z47.string().default("10.70mm"),
-  h: z47.string().default("6.60mm"),
-  pl: z47.string().default("3.30mm"),
-  pw: z47.string().default("2.50mm"),
-  p: z47.string().default("6.80mm")
+  fn: z53.string(),
+  num_pins: z53.literal(2).default(2),
+  w: z53.string().default("10.70mm"),
+  h: z53.string().default("6.60mm"),
+  pl: z53.string().default("3.30mm"),
+  pw: z53.string().default("2.50mm"),
+  p: z53.string().default("6.80mm")
 });
 var smc = (raw_params) => {
   const parameters = smc_def.parse(raw_params);
@@ -5738,16 +5814,16 @@ var smcWithoutParsing = (parameters) => {
 };
 
 // src/fn/sot223.ts
-import { z as z48 } from "zod";
+import { z as z54 } from "zod";
 var sot223_def = base_def.extend({
-  fn: z48.string(),
-  num_pins: z48.number().default(4),
-  w: z48.string().default("8.50mm"),
-  h: z48.string().default("6.90mm"),
-  pl: z48.string().default("2mm"),
-  pw: z48.string().default("1.5mm"),
-  p: z48.string().default("2.30mm"),
-  string: z48.string().optional()
+  fn: z54.string(),
+  num_pins: z54.number().default(4),
+  w: z54.string().default("8.50mm"),
+  h: z54.string().default("6.90mm"),
+  pl: z54.string().default("2mm"),
+  pw: z54.string().default("1.5mm"),
+  p: z54.string().default("2.30mm"),
+  string: z54.string().optional()
 });
 var sot223 = (raw_params) => {
   const match = raw_params.string?.match(/^sot223_(\d+)/);
@@ -5993,16 +6069,16 @@ var sot223_6 = (parameters) => {
 };
 
 // src/fn/sot23w.ts
-import { z as z49 } from "zod";
+import { z as z55 } from "zod";
 var sot23w_def = base_def.extend({
-  fn: z49.string(),
-  num_pins: z49.number().default(3),
-  w: z49.string().default("3.40mm"),
-  h: z49.string().default("3.30mm"),
-  pl: z49.string().default("1mm"),
-  pw: z49.string().default("0.7mm"),
-  p: z49.string().default("1.2mm"),
-  string: z49.string().optional()
+  fn: z55.string(),
+  num_pins: z55.number().default(3),
+  w: z55.string().default("3.40mm"),
+  h: z55.string().default("3.30mm"),
+  pl: z55.string().default("1mm"),
+  pw: z55.string().default("0.7mm"),
+  p: z55.string().default("1.2mm"),
+  string: z55.string().optional()
 });
 var sot23w = (raw_params) => {
   const match = raw_params.string?.match(/^sot23w_(\d+)/);
@@ -6090,34 +6166,34 @@ var sot23w_3 = (parameters) => {
 };
 
 // src/fn/to92s.ts
-import { z as z50 } from "zod";
+import { z as z56 } from "zod";
 var to92s_def = base_def.extend({
-  fn: z50.string(),
-  num_pins: z50.union([z50.literal(3), z50.literal(2)]).default(3),
-  p: z50.string().default("1.27mm"),
-  id: z50.string().default("0.72mm"),
-  od: z50.string().default("0.95mm"),
-  w: z50.string().default("2.5mm"),
-  h: z50.string().default("4.2mm"),
-  string: z50.string().optional()
+  fn: z56.string(),
+  num_pins: z56.union([z56.literal(3), z56.literal(2)]).default(3),
+  p: z56.string().default("1.27mm"),
+  id: z56.string().default("0.72mm"),
+  od: z56.string().default("0.95mm"),
+  w: z56.string().default("2.5mm"),
+  h: z56.string().default("4.2mm"),
+  string: z56.string().optional()
 });
 var to92s_3 = (parameters) => {
   const { p, id, od, w, h } = parameters;
   const holeY = Number.parseFloat(h) / 2;
-  const padSpacing6 = Number.parseFloat(p);
+  const padSpacing7 = Number.parseFloat(p);
   return [
-    platedhole(1, -padSpacing6, holeY - padSpacing6, id, od),
-    platedhole(2, 0, holeY - padSpacing6, id, od),
-    platedhole(3, padSpacing6, holeY - padSpacing6, id, od)
+    platedhole(1, -padSpacing7, holeY - padSpacing7, id, od),
+    platedhole(2, 0, holeY - padSpacing7, id, od),
+    platedhole(3, padSpacing7, holeY - padSpacing7, id, od)
   ];
 };
 var to92s_2 = (parameters) => {
   const { p, id, od, h } = parameters;
   const holeY = Number.parseFloat(h) / 2;
-  const padSpacing6 = Number.parseFloat(p);
+  const padSpacing7 = Number.parseFloat(p);
   return [
-    platedhole(1, -padSpacing6, holeY - padSpacing6, id, od),
-    platedhole(2, padSpacing6, holeY - padSpacing6, id, od)
+    platedhole(1, -padSpacing7, holeY - padSpacing7, id, od),
+    platedhole(2, padSpacing7, holeY - padSpacing7, id, od)
   ];
 };
 var to92s = (raw_params) => {
@@ -6136,19 +6212,19 @@ var to92s = (raw_params) => {
     throw new Error("Invalid number of pins for TO-92");
   }
   const holeY = Number.parseFloat(parameters.h) / 2;
-  const padSpacing6 = Number.parseFloat(parameters.p);
+  const padSpacing7 = Number.parseFloat(parameters.p);
   const silkscreenBody = {
     type: "pcb_silkscreen_path",
     layer: "top",
     pcb_component_id: "",
     route: [
-      { x: -holeY, y: holeY - padSpacing6 },
+      { x: -holeY, y: holeY - padSpacing7 },
       { x: -1.9, y: 0 },
       { x: 1.9, y: 0 },
-      { x: holeY, y: holeY - padSpacing6 },
+      { x: holeY, y: holeY - padSpacing7 },
       { x: 1.5, y: Number.parseFloat(parameters.h) / 2 + 0.5 },
       { x: -1.5, y: Number.parseFloat(parameters.h) / 2 + 0.5 },
-      { x: -holeY, y: holeY - padSpacing6 }
+      { x: -holeY, y: holeY - padSpacing7 }
     ],
     stroke_width: 0.1,
     pcb_silkscreen_path_id: ""
@@ -6168,16 +6244,16 @@ var to92s = (raw_params) => {
 import {
   length as length38
 } from "circuit-json";
-import { z as z51 } from "zod";
+import { z as z57 } from "zod";
 var jst_def = base_def.extend({
-  fn: z51.string(),
+  fn: z57.string(),
   p: length38.optional(),
   id: length38.optional(),
   pw: length38.optional(),
   pl: length38.optional(),
   w: length38.optional(),
   h: length38.optional(),
-  sh: z51.union([z51.boolean(), z51.string(), z51.number()]).optional().transform((v) => {
+  sh: z57.union([z57.boolean(), z57.string(), z57.number()]).optional().transform((v) => {
     if (typeof v === "string") {
       const n = Number(v);
       return Number.isNaN(n) ? true : n;
@@ -6186,10 +6262,10 @@ var jst_def = base_def.extend({
   }).describe(
     'JST SH (Surface-mount) connector family. SH stands for "Super High-density".'
   ),
-  ph: z51.boolean().optional().describe(
+  ph: z57.boolean().optional().describe(
     'JST PH (Through-hole) connector family. PH stands for "Pin Header".'
   ),
-  string: z51.string().optional()
+  string: z57.string().optional()
 });
 var variantDefaults = {
   ph: {
@@ -6304,16 +6380,16 @@ var jst = (raw_params) => {
 };
 
 // src/fn/sod110.ts
-import { z as z52 } from "zod";
+import { z as z58 } from "zod";
 import { length as length39 } from "circuit-json";
 var sod_def12 = base_def.extend({
-  fn: z52.string(),
-  num_pins: z52.literal(2).default(2),
-  w: z52.string().default("3.30mm"),
-  h: z52.string().default("1.70mm"),
-  pl: z52.string().default("0.80mm"),
-  pw: z52.string().default("1mm"),
-  p: z52.string().default("1.90mm")
+  fn: z58.string(),
+  num_pins: z58.literal(2).default(2),
+  w: z58.string().default("3.30mm"),
+  h: z58.string().default("1.70mm"),
+  pl: z58.string().default("0.80mm"),
+  pw: z58.string().default("1mm"),
+  p: z58.string().default("1.90mm")
 });
 var sod110 = (raw_params) => {
   const parameters = sod_def12.parse(raw_params);
@@ -6383,7 +6459,7 @@ var sodWithoutParsing13 = (parameters) => {
 };
 
 // src/fn/vssop.ts
-import { z as z53 } from "zod";
+import { z as z59 } from "zod";
 import { length as length40 } from "circuit-json";
 var getDefaultValues = (num_pins) => {
   switch (num_pins) {
@@ -6414,14 +6490,14 @@ var getDefaultValues = (num_pins) => {
   }
 };
 var vssop_def = base_def.extend({
-  fn: z53.string(),
-  num_pins: z53.union([z53.literal(8), z53.literal(10)]).default(8),
-  w: z53.string().optional(),
-  h: z53.string().optional(),
-  p: z53.string().optional(),
-  pl: z53.string().optional(),
-  pw: z53.string().optional(),
-  string: z53.string().optional()
+  fn: z59.string(),
+  num_pins: z59.union([z59.literal(8), z59.literal(10)]).default(8),
+  w: z59.string().optional(),
+  h: z59.string().optional(),
+  p: z59.string().optional(),
+  pl: z59.string().optional(),
+  pw: z59.string().optional(),
+  string: z59.string().optional()
 });
 var vssop = (raw_params) => {
   const parameters = vssop_def.parse(raw_params);
@@ -6513,7 +6589,7 @@ var getVssopPadCoord = (pinCount, pn, w, p) => {
 };
 
 // src/fn/msop.ts
-import { z as z54 } from "zod";
+import { z as z60 } from "zod";
 import { length as length41 } from "circuit-json";
 var getDefaultValues2 = (num_pins) => {
   switch (num_pins) {
@@ -6552,14 +6628,14 @@ var getDefaultValues2 = (num_pins) => {
   }
 };
 var msop_def = base_def.extend({
-  fn: z54.string(),
-  num_pins: z54.union([z54.literal(8), z54.literal(10), z54.literal(12), z54.literal(16)]).default(8),
-  w: z54.string().optional(),
-  h: z54.string().optional(),
-  p: z54.string().optional(),
-  pl: z54.string().optional(),
-  pw: z54.string().optional(),
-  string: z54.string().optional()
+  fn: z60.string(),
+  num_pins: z60.union([z60.literal(8), z60.literal(10), z60.literal(12), z60.literal(16)]).default(8),
+  w: z60.string().optional(),
+  h: z60.string().optional(),
+  p: z60.string().optional(),
+  pl: z60.string().optional(),
+  pw: z60.string().optional(),
+  string: z60.string().optional()
 });
 var getMsopCoords = (pinCount, pn, w, p) => {
   const half = pinCount / 2;
@@ -6649,16 +6725,16 @@ var msop = (raw_params) => {
 };
 
 // src/fn/sod323w.ts
-import { z as z55 } from "zod";
+import { z as z61 } from "zod";
 import { length as length42 } from "circuit-json";
 var sod323w_def = base_def.extend({
-  fn: z55.string(),
-  num_pins: z55.literal(2).default(2),
-  w: z55.string().default("3.8mm"),
-  h: z55.string().default("1.65mm"),
-  pl: z55.string().default("1.2mm"),
-  pw: z55.string().default("1.2mm"),
-  pad_spacing: z55.string().default("2.6mm")
+  fn: z61.string(),
+  num_pins: z61.literal(2).default(2),
+  w: z61.string().default("3.8mm"),
+  h: z61.string().default("1.65mm"),
+  pl: z61.string().default("1.2mm"),
+  pw: z61.string().default("1.2mm"),
+  pad_spacing: z61.string().default("2.6mm")
 });
 var sod323w = (raw_params) => {
   const parameters = sod323w_def.parse(raw_params);
@@ -6729,16 +6805,16 @@ var sodWithoutParsing14 = (parameters) => {
 };
 
 // src/fn/sod323fl.ts
-import { z as z56 } from "zod";
+import { z as z62 } from "zod";
 import { length as length43 } from "circuit-json";
 var sod323FL_def = base_def.extend({
-  fn: z56.string(),
-  num_pins: z56.literal(2).default(2),
-  w: z56.string().default("3.20mm"),
-  h: z56.string().default("1.65mm"),
-  pl: z56.string().default("0.8mm"),
-  pw: z56.string().default("0.9mm"),
-  pad_spacing: z56.string().default("2.1mm")
+  fn: z62.string(),
+  num_pins: z62.literal(2).default(2),
+  w: z62.string().default("3.20mm"),
+  h: z62.string().default("1.65mm"),
+  pl: z62.string().default("0.8mm"),
+  pw: z62.string().default("0.9mm"),
+  pad_spacing: z62.string().default("2.1mm")
 });
 var sod323fl = (raw_params) => {
   const parameters = sod323FL_def.parse(raw_params);
@@ -6809,20 +6885,20 @@ var sodWithoutParsing15 = (parameters) => {
 };
 
 // src/fn/son.ts
-import { z as z57 } from "zod";
+import { z as z63 } from "zod";
 import { length as length44 } from "circuit-json";
 var son_def = base_def.extend({
-  fn: z57.string(),
-  num_pins: z57.union([z57.literal(6), z57.literal(8)]).default(8),
-  w: z57.string().default("3mm"),
-  h: z57.string().default("3mm"),
-  p: z57.string().default("0.5mm"),
-  pl: z57.string().default("0.52mm"),
-  pw: z57.string().default("0.35mm"),
-  epw: z57.string().default("1.40mm"),
-  eph: z57.string().default("1.60mm"),
-  string: z57.string().optional(),
-  ep: z57.boolean().default(false)
+  fn: z63.string(),
+  num_pins: z63.union([z63.literal(6), z63.literal(8)]).default(8),
+  w: z63.string().default("3mm"),
+  h: z63.string().default("3mm"),
+  p: z63.string().default("0.5mm"),
+  pl: z63.string().default("0.52mm"),
+  pw: z63.string().default("0.35mm"),
+  epw: z63.string().default("1.40mm"),
+  eph: z63.string().default("1.60mm"),
+  string: z63.string().optional(),
+  ep: z63.boolean().default(false)
 });
 var son = (raw_params) => {
   if (raw_params.string && raw_params.string.includes("_ep")) {
@@ -6927,13 +7003,13 @@ var getSonPadCoord = (num_pins, pn, w, p) => {
 import { length as length45 } from "circuit-json";
 var solderjumper = (params) => {
   const { num_pins, bridged, p = 2.54, pw = 1.5, ph = 1.5 } = params;
-  const padSpacing6 = length45.parse(p);
-  const padWidth6 = length45.parse(pw);
-  const padHeight6 = length45.parse(ph);
-  const traceWidth = Math.min(padHeight6 / 4, 0.5);
+  const padSpacing7 = length45.parse(p);
+  const padWidth = length45.parse(pw);
+  const padHeight = length45.parse(ph);
+  const traceWidth = Math.min(padHeight / 4, 0.5);
   const pads = [];
   for (let i = 0; i < num_pins; i++) {
-    pads.push(rectpad(i + 1, i * padSpacing6, 0, padWidth6, padHeight6));
+    pads.push(rectpad(i + 1, i * padSpacing7, 0, padWidth, padHeight));
   }
   let traces = [];
   if (bridged) {
@@ -6943,11 +7019,11 @@ var solderjumper = (params) => {
         const from = pins[i];
         const to = pins[i + 1];
         if (typeof from === "number" && typeof to === "number" && !isNaN(from) && !isNaN(to)) {
-          const xCenterFrom = (from - 1) * padSpacing6;
-          const xCenterTo = (to - 1) * padSpacing6;
+          const xCenterFrom = (from - 1) * padSpacing7;
+          const xCenterTo = (to - 1) * padSpacing7;
           const directionMult = Math.sign(xCenterTo - xCenterFrom);
-          const x1 = xCenterFrom + directionMult * (padWidth6 / 2);
-          const x2 = xCenterTo - directionMult * (padWidth6 / 2);
+          const x1 = xCenterFrom + directionMult * (padWidth / 2);
+          const x2 = xCenterTo - directionMult * (padWidth / 2);
           traces.push({
             type: "pcb_trace",
             pcb_trace_id: "",
@@ -6974,9 +7050,9 @@ var solderjumper = (params) => {
       }
     }
   }
-  const outlineWidth = (num_pins - 1) * padSpacing6 + padWidth6 + 0.7;
-  const outlineHeight = padHeight6 + 1;
-  const outlineCenterX = (num_pins - 1) * padSpacing6 / 2;
+  const outlineWidth = (num_pins - 1) * padSpacing7 + padWidth + 0.7;
+  const outlineHeight = padHeight + 1;
+  const outlineCenterX = (num_pins - 1) * padSpacing7 / 2;
   const outlineCenterY = 0;
   const silkscreenRect = {
     type: "pcb_silkscreen_path",
@@ -7017,34 +7093,34 @@ var solderjumper = (params) => {
 };
 
 // src/fn/sot457.ts
-import { z as z58 } from "zod";
+import { z as z64 } from "zod";
 var commonSchema = {
-  fn: z58.literal("sot457"),
-  num_pins: z58.literal(6).default(6),
-  pillh: z58.string().default("0.45mm"),
-  pillw: z58.string().default("1.45mm"),
-  pl: z58.string(),
-  pw: z58.string(),
-  p: z58.string(),
-  wave: z58.boolean().optional(),
-  reflow: z58.boolean().optional()
+  fn: z64.literal("sot457"),
+  num_pins: z64.literal(6).default(6),
+  pillh: z64.string().default("0.45mm"),
+  pillw: z64.string().default("1.45mm"),
+  pl: z64.string(),
+  pw: z64.string(),
+  p: z64.string(),
+  wave: z64.boolean().optional(),
+  reflow: z64.boolean().optional()
 };
 var sot457DefSchema = base_def.extend({
   ...commonSchema,
-  h: z58.string().default("2.5mm"),
-  w: z58.string().default("2.7mm"),
-  pl: z58.string().default("0.8mm"),
-  pw: z58.string().default("0.55mm"),
-  p: z58.string().default("0.95mm")
+  h: z64.string().default("2.5mm"),
+  w: z64.string().default("2.7mm"),
+  pl: z64.string().default("0.8mm"),
+  pw: z64.string().default("0.55mm"),
+  p: z64.string().default("0.95mm")
 });
 var sot457WaveSchema = base_def.extend({
   ...commonSchema,
-  h: z58.string().default("3mm"),
-  w: z58.string().default("4mm"),
-  pillr: z58.string().default("0.225mm"),
-  pl: z58.string().default("1.45mm"),
-  pw: z58.string().default("1.5mm"),
-  p: z58.string().default("1.475mm")
+  h: z64.string().default("3mm"),
+  w: z64.string().default("4mm"),
+  pillr: z64.string().default("0.225mm"),
+  pl: z64.string().default("1.45mm"),
+  pw: z64.string().default("1.5mm"),
+  p: z64.string().default("1.475mm")
 }).transform((data) => ({
   ...data,
   wave: data.wave ?? (data.reflow === void 0 ? true : !data.reflow),
@@ -7077,40 +7153,40 @@ var generateSot457Elements = (params) => {
   const pads = [];
   const pitch = parseDimension(params.p);
   const padLength = parseDimension(params.pl);
-  const padWidth6 = parseDimension(params.pw);
+  const padWidth = parseDimension(params.pw);
   const width = parseDimension(params.w);
   const height = parseDimension(params.h);
   if (params.wave) {
     const pinConfigs = {
-      1: ({ padWidth: padWidth7, padHeight: padHeight6 }) => rectpad(1, -pitch, pitch, padHeight6, padWidth7),
-      2: ({ padWidth: padWidth7, padHeight: padHeight6 }) => rectpad(2, -pitch, -pitch, padHeight6, padWidth7),
-      3: ({ padWidth: padWidth7, padHeight: padHeight6 }) => pillpad(
+      1: ({ padWidth: padWidth2, padHeight }) => rectpad(1, -pitch, pitch, padHeight, padWidth2),
+      2: ({ padWidth: padWidth2, padHeight }) => rectpad(2, -pitch, -pitch, padHeight, padWidth2),
+      3: ({ padWidth: padWidth2, padHeight }) => pillpad(
         3,
         -pitch,
         0,
         parseDimension(params.pillw),
         parseDimension(params.pillh)
       ),
-      4: ({ padWidth: padWidth7, padHeight: padHeight6 }) => pillpad(
+      4: ({ padWidth: padWidth2, padHeight }) => pillpad(
         4,
         pitch,
         0,
         parseDimension(params.pillw),
         parseDimension(params.pillh)
       ),
-      5: ({ padWidth: padWidth7, padHeight: padHeight6 }) => rectpad(5, pitch, pitch, padHeight6, padWidth7),
-      6: ({ padWidth: padWidth7, padHeight: padHeight6 }) => rectpad(6, pitch, -pitch, padHeight6, padWidth7)
+      5: ({ padWidth: padWidth2, padHeight }) => rectpad(5, pitch, pitch, padHeight, padWidth2),
+      6: ({ padWidth: padWidth2, padHeight }) => rectpad(6, pitch, -pitch, padHeight, padWidth2)
     };
     for (let i = 1; i <= params.num_pins; i++) {
       const config = pinConfigs[i];
       if (config) {
-        pads.push(config({ padWidth: padLength, padHeight: padWidth6 }));
+        pads.push(config({ padWidth: padLength, padHeight: padWidth }));
       }
     }
   } else {
     for (let i = 1; i <= params.num_pins; i++) {
       const { x, y } = getCcwSot457Coords({ pitch, width, pinNumber: i });
-      pads.push(rectpad(i, x, y, padLength, padWidth6));
+      pads.push(rectpad(i, x, y, padLength, padWidth));
     }
   }
   const silkscreenPath1 = {
@@ -7139,7 +7215,7 @@ var generateSot457Elements = (params) => {
   const pin1Position = getCcwSot457Coords({ pitch, width, pinNumber: 1 });
   const triangleHeight = params.wave ? 1 : 0.5;
   const triangleWidth = params.wave ? 0.7 : 0.3;
-  pin1Position.x -= params.wave ? padWidth6 : padWidth6 * 1.7;
+  pin1Position.x -= params.wave ? padWidth : padWidth * 1.7;
   const pin1Indicator = {
     type: "pcb_silkscreen_path",
     layer: "top",
@@ -7183,17 +7259,17 @@ var sot457 = (rawParams) => {
 };
 
 // src/fn/sot963.ts
-import { z as z59 } from "zod";
+import { z as z65 } from "zod";
 import { length as length46 } from "circuit-json";
 var sot963_def = base_def.extend({
-  fn: z59.string(),
-  num_pins: z59.literal(6).default(6),
-  w: z59.string().default("1.1mm"),
-  h: z59.string().default("1.45mm"),
-  p: z59.string().default("0.35mm"),
-  pl: z59.string().default("0.2mm"),
-  pw: z59.string().default("0.2mm"),
-  string: z59.string().optional()
+  fn: z65.string(),
+  num_pins: z65.literal(6).default(6),
+  w: z65.string().default("1.1mm"),
+  h: z65.string().default("1.45mm"),
+  p: z65.string().default("0.35mm"),
+  pl: z65.string().default("0.2mm"),
+  pw: z65.string().default("0.2mm"),
+  string: z65.string().optional()
 });
 var sot963 = (raw_params) => {
   const parameters = sot963_def.parse({ ...raw_params, fn: "sot963" });
@@ -7264,19 +7340,19 @@ var getSot963PadCoord = (pn, w, p, pl) => {
 };
 
 // src/fn/potentiometer.ts
-import { z as z60 } from "zod";
+import { z as z66 } from "zod";
 var potentiometer_def = base_def.extend({
-  fn: z60.string(),
-  num_pins: z60.union([z60.literal(3), z60.literal(2)]).default(3),
-  p: z60.string().default("3.8mm"),
-  id: z60.string().default("1.25mm"),
-  od: z60.string().default("2.35mm"),
-  ca: z60.string().default("14mm").describe(
+  fn: z66.string(),
+  num_pins: z66.union([z66.literal(3), z66.literal(2)]).default(3),
+  p: z66.string().default("3.8mm"),
+  id: z66.string().default("1.25mm"),
+  od: z66.string().default("2.35mm"),
+  ca: z66.string().default("14mm").describe(
     "Caliper axis (width or diameter of the potentiometer body or adjustment knob)"
   ),
-  w: z60.string().default("5.35mm"),
-  h: z60.string().default("4mm"),
-  string: z60.string().optional()
+  w: z66.string().default("5.35mm"),
+  h: z66.string().default("4mm"),
+  string: z66.string().optional()
 });
 var potentiometer_acp = (parameters) => {
   const { p, id, od, h, ca } = parameters;
@@ -7345,9 +7421,9 @@ var potentiometer = (raw_params) => {
 import {
   length as length47
 } from "circuit-json";
-import { z as z61 } from "zod";
+import { z as z67 } from "zod";
 var electrolytic_def = base_def.extend({
-  fn: z61.string(),
+  fn: z67.string(),
   p: length47.optional().default("7.5mm"),
   id: length47.optional().default("1mm"),
   od: length47.optional().default("2mm"),
@@ -7458,16 +7534,16 @@ var electrolytic = (raw_params) => {
 };
 
 // src/fn/smbf.ts
-import { z as z62 } from "zod";
+import { z as z68 } from "zod";
 import { length as length48 } from "circuit-json";
 var smbf_def = base_def.extend({
-  fn: z62.string(),
-  num_pins: z62.literal(2).default(2),
-  w: z62.string().default("6.5mm"),
-  h: z62.string().default("3mm"),
-  pl: z62.string().default("1.75mm"),
-  pw: z62.string().default("2.40mm"),
-  p: z62.string().default("4.75mm")
+  fn: z68.string(),
+  num_pins: z68.literal(2).default(2),
+  w: z68.string().default("6.5mm"),
+  h: z68.string().default("3mm"),
+  pl: z68.string().default("1.75mm"),
+  pw: z68.string().default("2.40mm"),
+  p: z68.string().default("4.75mm")
 });
 var smbf = (raw_params) => {
   const parameters = smbf_def.parse(raw_params);
@@ -7537,16 +7613,16 @@ var smbfWithoutParsing = (parameters) => {
 };
 
 // src/fn/sot323.ts
-import { z as z63 } from "zod";
+import { z as z69 } from "zod";
 var sot323_def = base_def.extend({
-  fn: z63.string(),
-  num_pins: z63.number().default(3),
-  w: z63.string().default("2.45mm"),
-  h: z63.string().default("2.40mm"),
-  pl: z63.string().default("1.225mm"),
-  pw: z63.string().default("0.5mm"),
-  p: z63.string().default("0.95mm"),
-  string: z63.string().optional()
+  fn: z69.string(),
+  num_pins: z69.number().default(3),
+  w: z69.string().default("2.45mm"),
+  h: z69.string().default("2.40mm"),
+  pl: z69.string().default("1.225mm"),
+  pw: z69.string().default("0.5mm"),
+  p: z69.string().default("0.95mm"),
+  string: z69.string().optional()
 });
 var sot323 = (raw_params) => {
   const match = raw_params.string?.match(/^sot323_(\d+)/);
@@ -7634,15 +7710,15 @@ var sot323_3 = (parameters) => {
 };
 
 // src/fn/smtpad.ts
-import { z as z64 } from "zod";
+import { z as z70 } from "zod";
 import { length as length49 } from "circuit-json";
-import { mm as mm8 } from "@tscircuit/mm";
+import { mm as mm14 } from "@tscircuit/mm";
 var smtpad_def = base_def.extend({
-  fn: z64.string(),
-  circle: z64.boolean().optional(),
-  rect: z64.boolean().optional(),
-  square: z64.boolean().optional(),
-  pill: z64.boolean().optional(),
+  fn: z70.string(),
+  circle: z70.boolean().optional(),
+  rect: z70.boolean().optional(),
+  square: z70.boolean().optional(),
+  pill: z70.boolean().optional(),
   d: length49.optional(),
   pd: length49.optional(),
   diameter: length49.optional(),
@@ -7657,7 +7733,7 @@ var smtpad_def = base_def.extend({
   height: length49.optional(),
   s: length49.optional(),
   size: length49.optional(),
-  string: z64.string().optional()
+  string: z70.string().optional()
 }).transform((v) => {
   let shape = "rect";
   if (v.circle) shape = "circle";
@@ -7668,27 +7744,27 @@ var smtpad_def = base_def.extend({
   let width;
   let height;
   if (shape === "circle") {
-    if (v.r !== void 0) radius = mm8(v.r);
-    else if (v.pr !== void 0) radius = mm8(v.pr);
-    else if (v.radius !== void 0) radius = mm8(v.radius);
-    else if (v.d !== void 0) radius = mm8(v.d) / 2;
-    else if (v.pd !== void 0) radius = mm8(v.pd) / 2;
-    else if (v.diameter !== void 0) radius = mm8(v.diameter) / 2;
-    else radius = mm8("1mm") / 2;
+    if (v.r !== void 0) radius = mm14(v.r);
+    else if (v.pr !== void 0) radius = mm14(v.pr);
+    else if (v.radius !== void 0) radius = mm14(v.radius);
+    else if (v.d !== void 0) radius = mm14(v.d) / 2;
+    else if (v.pd !== void 0) radius = mm14(v.pd) / 2;
+    else if (v.diameter !== void 0) radius = mm14(v.diameter) / 2;
+    else radius = mm14("1mm") / 2;
   } else {
-    if (v.w !== void 0) width = mm8(v.w);
-    else if (v.pw !== void 0) width = mm8(v.pw);
-    else if (v.width !== void 0) width = mm8(v.width);
-    else if (v.s !== void 0) width = mm8(v.s);
-    else if (v.size !== void 0) width = mm8(v.size);
-    else width = mm8("1mm");
-    if (v.h !== void 0) height = mm8(v.h);
-    else if (v.ph !== void 0) height = mm8(v.ph);
-    else if (v.height !== void 0) height = mm8(v.height);
+    if (v.w !== void 0) width = mm14(v.w);
+    else if (v.pw !== void 0) width = mm14(v.pw);
+    else if (v.width !== void 0) width = mm14(v.width);
+    else if (v.s !== void 0) width = mm14(v.s);
+    else if (v.size !== void 0) width = mm14(v.size);
+    else width = mm14("1mm");
+    if (v.h !== void 0) height = mm14(v.h);
+    else if (v.ph !== void 0) height = mm14(v.ph);
+    else if (v.height !== void 0) height = mm14(v.height);
     else if (shape === "square") height = width;
     else if (shape === "rect")
       height = width;
-    else height = mm8("1mm");
+    else height = mm14("1mm");
   }
   return {
     fn: v.fn,
@@ -7723,28 +7799,28 @@ var smtpad = (raw_params) => {
 };
 
 // src/fn/platedhole.ts
-import { z as z65 } from "zod";
+import { z as z71 } from "zod";
 import { length as length50 } from "circuit-json";
-import { mm as mm9 } from "@tscircuit/mm";
+import { mm as mm15 } from "@tscircuit/mm";
 var platedhole_def = base_def.extend({
-  fn: z65.string(),
+  fn: z71.string(),
   d: length50.optional(),
   hd: length50.optional(),
   r: length50.optional(),
   hr: length50.optional(),
   pd: length50.optional(),
   pr: length50.optional(),
-  squarepad: z65.boolean().optional().default(false)
+  squarepad: z71.boolean().optional().default(false)
 }).transform((v) => {
   let holeD;
-  if (v.d !== void 0) holeD = mm9(v.d);
-  else if (v.hd !== void 0) holeD = mm9(v.hd);
-  else if (v.r !== void 0) holeD = mm9(v.r) * 2;
-  else if (v.hr !== void 0) holeD = mm9(v.hr) * 2;
-  else holeD = mm9("1mm");
+  if (v.d !== void 0) holeD = mm15(v.d);
+  else if (v.hd !== void 0) holeD = mm15(v.hd);
+  else if (v.r !== void 0) holeD = mm15(v.r) * 2;
+  else if (v.hr !== void 0) holeD = mm15(v.hr) * 2;
+  else holeD = mm15("1mm");
   let padD;
-  if (v.pd !== void 0) padD = mm9(v.pd);
-  else if (v.pr !== void 0) padD = mm9(v.pr) * 2;
+  if (v.pd !== void 0) padD = mm15(v.pd);
+  else if (v.pr !== void 0) padD = mm15(v.pr) * 2;
   else padD = holeD * (1.5 / 1);
   return {
     fn: v.fn,
@@ -7766,14 +7842,14 @@ var platedhole2 = (raw_params) => {
 };
 
 // src/fn/sot.ts
-import { z as z66 } from "zod";
+import { z as z72 } from "zod";
 var sot_def = base_def.extend({
-  fn: z66.string(),
-  num_pins: z66.literal(6).default(6),
-  h: z66.string().default("1.6mm"),
-  pl: z66.string().default("1mm"),
-  pw: z66.string().default("0.7mm"),
-  p: z66.string().default("0.95mm")
+  fn: z72.string(),
+  num_pins: z72.literal(6).default(6),
+  h: z72.string().default("1.6mm"),
+  pl: z72.string().default("1mm"),
+  pw: z72.string().default("0.7mm"),
+  p: z72.string().default("0.95mm")
 });
 var sot = (raw_params) => {
   const parameters = sot_def.parse(raw_params);
@@ -7890,16 +7966,16 @@ var sotWithoutParsing = (parameters) => {
 };
 
 // src/fn/sot343.ts
-import { z as z67 } from "zod";
+import { z as z73 } from "zod";
 var sot343_def = base_def.extend({
-  fn: z67.string(),
-  num_pins: z67.number().default(4),
-  w: z67.string().default("3.2mm"),
-  h: z67.string().default("2.6mm"),
-  pl: z67.string().default("1.35mm"),
-  pw: z67.string().default("0.50mm"),
-  p: z67.string().default("0.6mm"),
-  string: z67.string().optional()
+  fn: z73.string(),
+  num_pins: z73.number().default(4),
+  w: z73.string().default("3.2mm"),
+  h: z73.string().default("2.6mm"),
+  pl: z73.string().default("1.35mm"),
+  pw: z73.string().default("0.50mm"),
+  p: z73.string().default("0.6mm"),
+  string: z73.string().optional()
 });
 var sot343 = (raw_params) => {
   const match = raw_params.string?.match(/^sot343_(\d+)/);
@@ -7994,14 +8070,14 @@ var sot343_4 = (parameters) => {
 };
 
 // src/fn/m2host.ts
-import { z as z68 } from "zod";
+import { z as z74 } from "zod";
 var m2host_def = base_def.extend({
-  fn: z68.string()
+  fn: z74.string()
 });
 var m2host = (raw_params) => {
   const parameters = m2host_def.parse(raw_params);
   const pads = [];
-  const padWidth6 = 0.5 - 0.15;
+  const padWidth = 0.5 - 0.15;
   const padLength = 1.5;
   const pitch = 0.5;
   const halfPitch = pitch / 2;
@@ -8016,7 +8092,7 @@ var m2host = (raw_params) => {
     const padLengthWithOffset = padLength + (isBottomLayer ? 0.25 : 0);
     const rightEdgeOffset = 0.5;
     const x = rightEdgeOffset - padLengthWithOffset / 2;
-    const pad2 = rectpad(pn, x, y, padLengthWithOffset, padWidth6);
+    const pad2 = rectpad(pn, x, y, padLengthWithOffset, padWidth);
     pad2.layer = isBottomLayer ? "bottom" : "top";
     pads.push(pad2);
   }
@@ -8099,16 +8175,16 @@ var m2host = (raw_params) => {
 };
 
 // src/fn/to92l.ts
-import { z as z69 } from "zod";
+import { z as z75 } from "zod";
 var to92l_def = base_def.extend({
-  fn: z69.string(),
-  num_pins: z69.number().default(3),
-  inline: z69.boolean().default(false),
-  p: z69.string().default("1.27mm"),
-  id: z69.string().default("0.75mm"),
-  od: z69.string().default("1.3mm"),
-  w: z69.string().default("4.8mm"),
-  h: z69.string().default("4.0mm")
+  fn: z75.string(),
+  num_pins: z75.number().default(3),
+  inline: z75.boolean().default(false),
+  p: z75.string().default("1.27mm"),
+  id: z75.string().default("0.75mm"),
+  od: z75.string().default("1.3mm"),
+  w: z75.string().default("4.8mm"),
+  h: z75.string().default("4.0mm")
 });
 var to92l = (raw_params) => {
   const parameters = to92l_def.parse(raw_params);