@tscircuit/footprinter 0.0.78 → 0.0.80

package/dist/index.js

@@ -32,6 +32,7 @@ __export(fn_exports, {
   sot723: () => sot723,
   ssop: () => ssop,
   stampboard: () => stampboard,
+  stampreceiver: () => stampreceiver,
   tssop: () => tssop
 });
 
@@ -63,6 +64,23 @@ var platedhole = (pn, x, y, id, od) => {
 // src/fn/dip.ts
 import { z } from "zod";
 import { length } from "circuit-json";
+
+// src/helpers/silkscreenRef.ts
+var silkscreenRef = (x, y, font_size) => {
+  return {
+    type: "pcb_silkscreen_text",
+    pcb_silkscreen_text_id: "silkscreen_text_1",
+    font: "tscircuit2024",
+    font_size,
+    pcb_component_id: "pcb_component_1",
+    text: "{REF}",
+    layer: "top",
+    anchor_position: { x, y },
+    anchor_alignment: "center"
+  };
+};
+
+// src/fn/dip.ts
 var extendDipDef = (newDefaults) => z.object({
   fn: z.string(),
   dip: z.literal(true),
@@ -163,8 +181,14 @@ var dip = (raw_params) => {
     };
     silkscreenPins.push(silkscreenPin);
   }
+  const silkscreenRefText = silkscreenRef(0, sh / 2 + 0.5, 0.4);
   return {
-    circuitJson: [...platedHoles, silkscreenBorder, ...silkscreenPins],
+    circuitJson: [
+      ...platedHoles,
+      silkscreenBorder,
+      silkscreenRefText,
+      ...silkscreenPins
+    ],
     parameters
   };
 };
@@ -332,15 +356,18 @@ var passive = (params) => {
     throw new Error("could not infer pad width");
   if (ph === void 0)
     throw new Error("could not infer pad width");
+  const silkscreenRefText = silkscreenRef(0, h / 2, h / 12);
   if (tht) {
     return [
       platedhole(1, -p / 2, 0, pw, pw * 1 / 0.8),
-      platedhole(2, p / 2, 0, pw, pw * 1 / 0.8)
+      platedhole(2, p / 2, 0, pw, pw * 1 / 0.8),
+      silkscreenRefText
     ];
   } else {
     return [
       rectpad(["1", "left"], -p / 2, 0, pw, ph),
-      rectpad(["2", "right"], p / 2, 0, pw, ph)
+      rectpad(["2", "right"], p / 2, 0, pw, ph),
+      silkscreenRefText
     ];
   }
 };
@@ -439,8 +466,8 @@ var bga_def = z5.object({
       const m = s.match(/([A-Z]+)(\d+)/);
       if (!m)
         return s;
-      let Y = ALPHABET.indexOf(m[1]);
-      let X = parseInt(m[2]) - 1;
+      const Y = ALPHABET.indexOf(m[1]);
+      const X = Number.parseInt(m[2]) - 1;
       return Y * a.grid.x + X + 1;
     });
   }
@@ -503,7 +530,15 @@ ${JSON.stringify(
       );
     }
   }
-  return { circuitJson: [...pads], parameters };
+  const silkscreenRefText = silkscreenRef(
+    0,
+    grid.y * p / 2,
+    0.2
+  );
+  return {
+    circuitJson: [...pads, silkscreenRefText],
+    parameters
+  };
 };
 
 // src/fn/soic.ts
@@ -571,6 +606,11 @@ var soicWithoutParsing = (parameters) => {
   const m = Math.min(1, parameters.p / 2);
   const sw = parameters.w - (parameters.legsoutside ? 0 : parameters.pl * 2) - 0.2;
   const sh = (parameters.num_pins / 2 - 1) * parameters.p + parameters.pw + m;
+  const silkscreenRefText = silkscreenRef(
+    0,
+    sh / 2 + 0.4,
+    sh / 12
+  );
   const silkscreenBorder = {
     type: "pcb_silkscreen_path",
     layer: "top",
@@ -590,7 +630,7 @@ var soicWithoutParsing = (parameters) => {
       { x: -sw / 2, y: -sh / 2 }
     ]
   };
-  return [...pads, silkscreenBorder];
+  return [...pads, silkscreenBorder, silkscreenRefText];
 };
 
 // src/fn/quad.ts
@@ -840,7 +880,8 @@ var quad = (raw_params) => {
             y: corner_y - csz * dy
           }
         ],
-        type: "pcb_silkscreen_path"
+        type: "pcb_silkscreen_path",
+        stroke_width: 0.1
       });
     }
     if ((arrow === "in1" || arrow === "in2") && !parameters.legsoutside) {
@@ -859,7 +900,8 @@ var quad = (raw_params) => {
               y: corner_y
             }
           ],
-          type: "pcb_silkscreen_path"
+          type: "pcb_silkscreen_path",
+          stroke_width: 0
         },
         {
           layer: "top",
@@ -875,7 +917,8 @@ var quad = (raw_params) => {
               y: corner_y - csz * dy
             }
           ],
-          type: "pcb_silkscreen_path"
+          type: "pcb_silkscreen_path",
+          stroke_width: 0.1
         }
       );
     }
@@ -902,12 +945,22 @@ var quad = (raw_params) => {
             y: arrow_y + 0.2 * rotate_arrow
           }
         ],
-        type: "pcb_silkscreen_path"
+        type: "pcb_silkscreen_path",
+        stroke_width: 0.1
       });
     }
   }
+  const silkscreenRefText = silkscreenRef(
+    0,
+    parameters.h / 2 + (parameters.legsoutside ? parameters.pl * 1.2 : 0.5),
+    0.3
+  );
   return {
-    circuitJson: [...pads, ...silkscreen_corners],
+    circuitJson: [
+      ...pads,
+      ...silkscreen_corners,
+      silkscreenRefText
+    ],
     parameters
   };
 };
@@ -1080,21 +1133,26 @@ var sot23WithoutParsing = (parameters) => {
     const { x, y } = getCcwSot23Coords({
       num_pins: parameters.num_pins,
       pn: i + 1,
-      w: parseFloat(parameters.w),
-      h: parseFloat(parameters.h),
-      pl: parseFloat(parameters.pl)
+      w: Number.parseFloat(parameters.w),
+      h: Number.parseFloat(parameters.h),
+      pl: Number.parseFloat(parameters.pl)
     });
     pads.push(
       rectpad(
         i + 1,
         x,
         y,
-        parseFloat(parameters.pl),
-        parseFloat(parameters.pw)
+        Number.parseFloat(parameters.pl),
+        Number.parseFloat(parameters.pw)
       )
     );
   }
-  return pads;
+  const silkscreenRefText = silkscreenRef(
+    0,
+    Number(parameters.h),
+    0.3
+  );
+  return [...pads, silkscreenRefText];
 };
 
 // src/fn/dfn.ts
@@ -1141,7 +1199,8 @@ var dfn = (raw_params) => {
         { x: dx * sw / 2, y: dy * sh / 2 },
         { x: dx * sw / 2, y: dy * sh / 2 - dy * parameters.p }
       ],
-      type: "pcb_silkscreen_path"
+      type: "pcb_silkscreen_path",
+      stroke_width: 0.1
     });
   }
   const as = parameters.p / 4;
@@ -1169,10 +1228,20 @@ var dfn = (raw_params) => {
         x: atx,
         y: aty
       }
-    ]
+    ],
+    stroke_width: 0.1
   });
+  const silkscreenRefText = silkscreenRef(
+    0,
+    sh / 2 + 0.4,
+    sh / 12
+  );
   return {
-    circuitJson: [...pads, ...silkscreenPaths],
+    circuitJson: [
+      ...pads,
+      silkscreenRefText,
+      ...silkscreenPaths
+    ],
     parameters
   };
 };
@@ -1196,7 +1265,11 @@ var pinrow = (raw_params) => {
   for (let i = 0; i < parameters.num_pins; i++) {
     holes.push(platedhole(i + 1, xoff + i * p, 0, id, od));
   }
-  return { circuitJson: holes, parameters };
+  const silkscreenRefText = silkscreenRef(0, p / 2, 0.5);
+  return {
+    circuitJson: [...holes, silkscreenRefText],
+    parameters
+  };
 };
 
 // src/fn/sot563.ts
@@ -1257,8 +1330,14 @@ var sot723_def = z12.object({
 });
 var sot723 = (raw_params) => {
   const parameters = sot723_def.parse(raw_params);
+  const pad = sot723WithoutParsing(parameters);
+  const silkscreenRefText = silkscreenRef(
+    0,
+    Number(parameters.h),
+    0.3
+  );
   return {
-    circuitJson: sot723WithoutParsing(parameters),
+    circuitJson: [...pad, silkscreenRefText],
     parameters
   };
 };
@@ -1297,6 +1376,7 @@ var sot723WithoutParsing = (parameters) => {
 
 // src/fn/sod123.ts
 import { z as z13 } from "zod";
+import "circuit-json";
 var sod_def = z13.object({
   fn: z13.string(),
   w: z13.string().default("2.36mm"),
@@ -1307,8 +1387,15 @@ var sod_def = z13.object({
 });
 var sod123 = (raw_params) => {
   const parameters = sod_def.parse(raw_params);
+  const silkscreenRefText = silkscreenRef(
+    0,
+    Number(parameters.h) / 4 + 0.4,
+    0.3
+  );
   return {
-    circuitJson: sodWithoutParsing(parameters),
+    circuitJson: sodWithoutParsing(parameters).concat(
+      silkscreenRefText
+    ),
     parameters
   };
 };
@@ -1325,15 +1412,15 @@ var sodWithoutParsing = (parameters) => {
   for (let i = 0; i < 2; i++) {
     const { x, y } = getSodCoords({
       pn: i + 1,
-      pad_spacing: parseFloat(parameters.pad_spacing)
+      pad_spacing: Number.parseFloat(parameters.pad_spacing)
     });
     pads.push(
       rectpad(
         i + 1,
         x,
         y,
-        parseFloat(parameters.pl),
-        parseFloat(parameters.pw)
+        Number.parseFloat(parameters.pl),
+        Number.parseFloat(parameters.pw)
       )
     );
   }
@@ -1342,15 +1429,15 @@ var sodWithoutParsing = (parameters) => {
 
 // src/fn/axial.ts
 import {
-  length as length7
+  length as length8
 } from "@tscircuit/soup";
 import { z as z14 } from "zod";
 var axial_def = z14.object({
   fn: z14.string(),
   num_pins: z14.any().transform(() => 2),
-  p: length7.optional().default("2.54mm"),
-  id: length7.optional().default("0.7mm"),
-  od: length7.optional().default("1mm")
+  p: length8.optional().default("2.54mm"),
+  id: length8.optional().default("0.7mm"),
+  od: length8.optional().default("1mm")
 });
 var axial = (raw_params) => {
   const parameters = axial_def.parse(raw_params);
@@ -1370,7 +1457,15 @@ var axial = (raw_params) => {
     stroke_width: 0.1,
     pcb_silkscreen_path_id: ""
   };
-  return { circuitJson: [...plated_holes, silkscreenLine], parameters };
+  const silkscreenRefText = silkscreenRef(0, p / 4, 0.5);
+  return {
+    circuitJson: [
+      ...plated_holes,
+      silkscreenLine,
+      silkscreenRefText
+    ],
+    parameters
+  };
 };
 
 // src/fn/pushbutton.ts
@@ -1424,27 +1519,32 @@ var pushbutton = (raw_params) => {
       { x: width / 5, y: 0 }
     ])
   ];
+  const silkscreenRefText = silkscreenRef(
+    0,
+    height / 2 + 0.4,
+    0.5
+  );
   return {
-    circuitJson: [...holes, ...silkscreenLines],
+    circuitJson: [...holes, ...silkscreenLines, silkscreenRefText],
     parameters
   };
 };
 
 // src/fn/stampboard.ts
 import {
-  length as length8
+  length as length9
 } from "circuit-json";
 import { z as z16 } from "zod";
 var stampboard_def = z16.object({
   fn: z16.string(),
-  w: length8.default("22.58mm"),
-  left: length8.optional(),
-  right: length8.optional(),
-  top: length8.optional(),
-  bottom: length8.optional(),
-  p: length8.default(length8.parse("2.54mm")),
-  pw: length8.default(length8.parse("1.6mm")),
-  pl: length8.default(length8.parse("3.2mm")),
+  w: length9.default("22.58mm"),
+  left: length9.optional(),
+  right: length9.optional(),
+  top: length9.optional(),
+  bottom: length9.optional(),
+  p: length9.default(length9.parse("2.54mm")),
+  pw: length9.default(length9.parse("1.6mm")),
+  pl: length9.default(length9.parse("2.11mm")),
   innerhole: z16.boolean().default(false)
 });
 var getHeight = (parameters) => {
@@ -1460,46 +1560,124 @@ var getHeight = (parameters) => {
   }
   return 51;
 };
+var getTriangleDir = (x, y, side) => {
+  let routes = [];
+  const triangleHeight = 1;
+  const triangleWidth = 0.6;
+  if (side === "right") {
+    routes = [
+      {
+        x: x + triangleHeight / 2,
+        y
+      },
+      // Tip of the triangle (pointing right)
+      {
+        x: x - triangleHeight / 2,
+        y: y + triangleWidth / 2
+      },
+      // Bottom corner of the base
+      {
+        x: x - triangleHeight / 2,
+        y: y - triangleWidth / 2
+      },
+      // Top corner of the base
+      {
+        x: x + triangleHeight / 2,
+        y
+      }
+      // Close the path at the tip
+    ];
+  }
+  if (side === "left") {
+    routes = [
+      {
+        x: x - triangleHeight / 2,
+        y
+      },
+      // Tip of the triangle (pointing left)
+      {
+        x: x + triangleHeight / 2,
+        y: y + triangleWidth / 2
+      },
+      // Top corner of the base
+      {
+        x: x + triangleHeight / 2,
+        y: y - triangleWidth / 2
+      },
+      // Bottom corner of the base
+      {
+        x: x - triangleHeight / 2,
+        y
+      }
+      // Close the path at the tip
+    ];
+  }
+  if (side === "top") {
+    routes = [
+      {
+        x,
+        y: y + triangleHeight / 2
+      },
+      // Tip of the triangle (pointing up)
+      {
+        x: x - triangleWidth / 2,
+        y: y - triangleHeight / 2
+      },
+      // Left corner of the base
+      {
+        x: x + triangleWidth / 2,
+        y: y - triangleHeight / 2
+      },
+      // Right corner of the base
+      {
+        x,
+        y: y + triangleHeight / 2
+      }
+      // Close the path at the tip
+    ];
+  }
+  if (side === "bottom") {
+    routes = [
+      {
+        x,
+        y: y - triangleHeight / 2
+      },
+      // Tip of the triangle (pointing down)
+      {
+        x: x - triangleWidth / 2,
+        y: y + triangleHeight / 2
+      },
+      // Left corner of the base
+      {
+        x: x + triangleWidth / 2,
+        y: y + triangleHeight / 2
+      },
+      // Right corner of the base
+      {
+        x,
+        y: y - triangleHeight / 2
+      }
+      // Close the path at the tip
+    ];
+  }
+  return routes;
+};
 var stampboard = (raw_params) => {
   const params = stampboard_def.parse(raw_params);
   const rectpads = [];
   const holes = [];
-  let firstPinLocation = { x: 0, y: 0 };
   let routes = [];
   const innerDiameter = 1;
   const outerDiameter = 1.2;
-  const triangleHeight = 1;
-  const triangleWidth = 0.6;
   if (params.right) {
     const yoff = -((params.right - 1) / 2) * params.p;
     for (let i = 0; i < params.right; i++) {
       if (i === 0 && !params.left && !params.bottom) {
-        firstPinLocation = {
-          x: params.w / 2 - params.pl * 1.4,
-          y: yoff + i * params.p
-        };
-        routes = [
-          {
-            x: firstPinLocation.x + triangleHeight / 2,
-            y: firstPinLocation.y
-          },
-          // Tip of the triangle (pointing right)
-          {
-            x: firstPinLocation.x - triangleHeight / 2,
-            y: firstPinLocation.y + triangleWidth / 2
-          },
-          // Bottom corner of the base
-          {
-            x: firstPinLocation.x - triangleHeight / 2,
-            y: firstPinLocation.y - triangleWidth / 2
-          },
-          // Top corner of the base
-          {
-            x: firstPinLocation.x + triangleHeight / 2,
-            y: firstPinLocation.y
-          }
-          // Close the path at the tip
-        ];
+        routes = getTriangleDir(
+          params.w / 2 - params.pl * 1.4,
+          yoff + i * params.p,
+          "right"
+        );
       }
       rectpads.push(
         rectpad(
@@ -1536,32 +1714,11 @@ var stampboard = (raw_params) => {
     const yoff = -((params.left - 1) / 2) * params.p;
     for (let i = 0; i < params.left; i++) {
       if (i === params.left - 1) {
-        firstPinLocation = {
-          x: -params.w / 2 + params.pl * 1.4,
-          y: yoff + i * params.p
-        };
-        routes = [
-          {
-            x: firstPinLocation.x - triangleHeight / 2,
-            y: firstPinLocation.y
-          },
-          // Tip of the triangle (pointing left)
-          {
-            x: firstPinLocation.x + triangleHeight / 2,
-            y: firstPinLocation.y + triangleWidth / 2
-          },
-          // Top corner of the base
-          {
-            x: firstPinLocation.x + triangleHeight / 2,
-            y: firstPinLocation.y - triangleWidth / 2
-          },
-          // Bottom corner of the base
-          {
-            x: firstPinLocation.x - triangleHeight / 2,
-            y: firstPinLocation.y
-          }
-          // Close the path at the tip
-        ];
+        routes = getTriangleDir(
+          -params.w / 2 + params.pl * 1.4,
+          yoff + i * params.p,
+          "left"
+        );
       }
       rectpads.push(
         rectpad(
@@ -1598,32 +1755,11 @@ var stampboard = (raw_params) => {
     const xoff = -((params.top - 1) / 2) * params.p;
     for (let i = 0; i < params.top; i++) {
       if (i === params.top - 1 && !params.left && !params.bottom && !params.right) {
-        firstPinLocation = {
-          x: xoff + i * params.p,
-          y: getHeight(params) / 2 - params.pl * 1.4
-        };
-        routes = [
-          {
-            x: firstPinLocation.x,
-            y: firstPinLocation.y + triangleHeight / 2
-          },
-          // Tip of the triangle (pointing up)
-          {
-            x: firstPinLocation.x - triangleWidth / 2,
-            y: firstPinLocation.y - triangleHeight / 2
-          },
-          // Left corner of the base
-          {
-            x: firstPinLocation.x + triangleWidth / 2,
-            y: firstPinLocation.y - triangleHeight / 2
-          },
-          // Right corner of the base
-          {
-            x: firstPinLocation.x,
-            y: firstPinLocation.y + triangleHeight / 2
-          }
-          // Close the path at the tip
-        ];
+        routes = getTriangleDir(
+          xoff + i * params.p,
+          getHeight(params) / 2 - params.pl * 1.4,
+          "top"
+        );
       }
       rectpads.push(
         rectpad(
@@ -1660,32 +1796,11 @@ var stampboard = (raw_params) => {
     const xoff = -((params.bottom - 1) / 2) * params.p;
     for (let i = 0; i < params.bottom; i++) {
       if (i === 0 && !params.left) {
-        firstPinLocation = {
-          x: xoff + i * params.p,
-          y: -getHeight(params) / 2 + params.pl * 1.4
-        };
-        routes = [
-          {
-            x: firstPinLocation.x,
-            y: firstPinLocation.y - triangleHeight / 2
-          },
-          // Tip of the triangle (pointing down)
-          {
-            x: firstPinLocation.x - triangleWidth / 2,
-            y: firstPinLocation.y + triangleHeight / 2
-          },
-          // Left corner of the base
-          {
-            x: firstPinLocation.x + triangleWidth / 2,
-            y: firstPinLocation.y + triangleHeight / 2
-          },
-          // Right corner of the base
-          {
-            x: firstPinLocation.x,
-            y: firstPinLocation.y - triangleHeight / 2
-          }
-          // Close the path at the tip
-        ];
+        routes = getTriangleDir(
+          xoff + i * params.p,
+          -getHeight(params) / 2 + params.pl * 1.4,
+          "bottom"
+        );
       }
       rectpads.push(
         rectpad(
@@ -1740,8 +1855,291 @@ var stampboard = (raw_params) => {
     stroke_width: 0.1,
     layer: "top"
   };
+  const silkscreenRefText = silkscreenRef(
+    0,
+    getHeight(params) / 1.8,
+    getHeight(params) / 25
+  );
+  return {
+    circuitJson: [
+      ...rectpads,
+      ...holes,
+      silkscreenPath,
+      silkscreenTriangle,
+      silkscreenRefText
+    ],
+    parameters: params
+  };
+};
+
+// src/fn/stampreceiver.ts
+import {
+  length as length10
+} from "circuit-json";
+import { z as z17 } from "zod";
+var stampreceiver_def = z17.object({
+  fn: z17.string(),
+  w: length10.default("22.58mm"),
+  left: length10.optional(),
+  right: length10.optional(),
+  top: length10.optional(),
+  bottom: length10.optional(),
+  p: length10.default(length10.parse("2.54mm")),
+  pw: length10.default(length10.parse("1.6mm")),
+  pl: length10.default(length10.parse("3.2mm"))
+});
+var getHeight2 = (parameters) => {
+  const params = stampreceiver_def.parse(parameters);
+  if (params.left && params.right) {
+    return Math.max(params.left, params.right) * params.p;
+  }
+  if (params.left) {
+    return params.left * params.p;
+  }
+  if (params.right) {
+    return params.right * params.p;
+  }
+  return 51;
+};
+var getTriangleDir2 = (x, y, side) => {
+  let routes = [];
+  const triangleHeight = 1;
+  const triangleWidth = 0.6;
+  if (side === "left") {
+    routes = [
+      {
+        x: x + triangleHeight / 2,
+        y
+      },
+      // Tip of the triangle (pointing right)
+      {
+        x: x - triangleHeight / 2,
+        y: y + triangleWidth / 2
+      },
+      // Bottom corner of the base
+      {
+        x: x - triangleHeight / 2,
+        y: y - triangleWidth / 2
+      },
+      // Top corner of the base
+      {
+        x: x + triangleHeight / 2,
+        y
+      }
+      // Close the path at the tip
+    ];
+  }
+  if (side === "right") {
+    routes = [
+      {
+        x: x - triangleHeight / 2,
+        y
+      },
+      // Tip of the triangle (pointing left)
+      {
+        x: x + triangleHeight / 2,
+        y: y + triangleWidth / 2
+      },
+      // Top corner of the base
+      {
+        x: x + triangleHeight / 2,
+        y: y - triangleWidth / 2
+      },
+      // Bottom corner of the base
+      {
+        x: x - triangleHeight / 2,
+        y
+      }
+      // Close the path at the tip
+    ];
+  }
+  if (side === "bottom") {
+    routes = [
+      {
+        x,
+        y: y + triangleHeight / 2
+      },
+      // Tip of the triangle (pointing up)
+      {
+        x: x - triangleWidth / 2,
+        y: y - triangleHeight / 2
+      },
+      // Left corner of the base
+      {
+        x: x + triangleWidth / 2,
+        y: y - triangleHeight / 2
+      },
+      // Right corner of the base
+      {
+        x,
+        y: y + triangleHeight / 2
+      }
+      // Close the path at the tip
+    ];
+  }
+  if (side === "top") {
+    routes = [
+      {
+        x,
+        y: y - triangleHeight / 2
+      },
+      // Tip of the triangle (pointing down)
+      {
+        x: x - triangleWidth / 2,
+        y: y + triangleHeight / 2
+      },
+      // Left corner of the base
+      {
+        x: x + triangleWidth / 2,
+        y: y + triangleHeight / 2
+      },
+      // Right corner of the base
+      {
+        x,
+        y: y - triangleHeight / 2
+      }
+      // Close the path at the tip
+    ];
+  }
+  return routes;
+};
+var stampreceiver = (raw_params) => {
+  const params = stampreceiver_def.parse(raw_params);
+  const rectpads = [];
+  let routes = [];
+  if (params.right) {
+    const yoff = -((params.right - 1) / 2) * params.p;
+    for (let i = 0; i < params.right; i++) {
+      if (i === 0 && !params.left && !params.bottom) {
+        routes = getTriangleDir2(
+          params.w / 2 + params.pl * 1.4,
+          yoff + i * params.p,
+          "right"
+        );
+      }
+      rectpads.push(
+        rectpad(
+          i + 1,
+          params.w / 2 - params.pl / 2,
+          yoff + i * params.p,
+          params.pl,
+          params.pw
+        )
+      );
+    }
+  }
+  if (params.left) {
+    const yoff = -((params.left - 1) / 2) * params.p;
+    for (let i = 0; i < params.left; i++) {
+      if (i === params.left - 1) {
+        routes = getTriangleDir2(
+          -params.w / 2 - params.pl / 3,
+          yoff + i * params.p,
+          "left"
+        );
+      }
+      rectpads.push(
+        rectpad(
+          i + 1,
+          -params.w / 2 + params.pl / 2,
+          yoff + i * params.p,
+          params.pl,
+          params.pw
+        )
+      );
+    }
+  }
+  if (params.top) {
+    const xoff = -((params.top - 1) / 2) * params.p;
+    for (let i = 0; i < params.top; i++) {
+      if (i === params.top - 1 && !params.left && !params.bottom && !params.right) {
+        routes = getTriangleDir2(
+          xoff + i * params.p,
+          getHeight2(params) / 2 + params.pl * 1.4,
+          "top"
+        );
+      }
+      rectpads.push(
+        rectpad(
+          i + 1,
+          xoff + i * params.p,
+          getHeight2(params) / 2 - params.pl / 2,
+          params.pw,
+          params.pl
+        )
+      );
+    }
+  }
+  if (params.bottom) {
+    const xoff = -((params.bottom - 1) / 2) * params.p;
+    for (let i = 0; i < params.bottom; i++) {
+      if (i === 0 && !params.left) {
+        routes = getTriangleDir2(
+          xoff + i * params.p,
+          -getHeight2(params) / 2 - params.pl * 1.4,
+          "bottom"
+        );
+      }
+      rectpads.push(
+        rectpad(
+          i + 1,
+          xoff + i * params.p,
+          -getHeight2(params) / 2 + params.pl / 2,
+          params.pw,
+          params.pl
+        )
+      );
+    }
+  }
+  const silkscreenTriangle = {
+    type: "pcb_silkscreen_path",
+    pcb_silkscreen_path_id: "1",
+    pcb_component_id: "1",
+    layer: "top",
+    route: routes,
+    stroke_width: 0.1
+  };
+  const silkscreenPath = {
+    type: "pcb_silkscreen_path",
+    pcb_silkscreen_path_id: "pcb_silkscreen_path_1",
+    pcb_component_id: "1",
+    route: [
+      {
+        x: -params.w / 2 - params.pl / 3,
+        y: getHeight2(params) / 2 + params.pl / 3
+      },
+      {
+        x: params.w / 2 + params.pl / 3,
+        y: getHeight2(params) / 2 + params.pl / 3
+      },
+      {
+        x: params.w / 2 + params.pl / 3,
+        y: -getHeight2(params) / 2 - params.pl / 3
+      },
+      {
+        x: -params.w / 2 - params.pl / 3,
+        y: -getHeight2(params) / 2 - params.pl / 3
+      },
+      {
+        x: -params.w / 2 - params.pl / 3,
+        y: getHeight2(params) / 2 + params.pl / 3
+      }
+    ],
+    stroke_width: 0.1,
+    layer: "top"
+  };
+  const silkscreenRefText = silkscreenRef(
+    0,
+    getHeight2(params) / 1.8,
+    getHeight2(params) / 25
+  );
   return {
-    circuitJson: [...rectpads, ...holes, silkscreenPath, silkscreenTriangle],
+    circuitJson: [
+      ...rectpads,
+      silkscreenPath,
+      silkscreenTriangle,
+      silkscreenRefText
+    ],
     parameters: params
   };
 };