@tscircuit/props 0.0.108 → 0.0.110

package/dist/index.js

@@ -1,120 +1,14 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
 // lib/index.ts
-var lib_exports = {};
-__export(lib_exports, {
-  autorouterConfig: () => autorouterConfig,
-  autorouterProp: () => autorouterProp,
-  baseGroupProps: () => baseGroupProps,
-  batteryPins: () => batteryPins,
-  batteryProps: () => batteryProps,
-  boardProps: () => boardProps,
-  bugProps: () => bugProps,
-  cadModelBase: () => cadModelBase,
-  cadModelJscad: () => cadModelJscad,
-  cadModelObj: () => cadModelObj,
-  cadModelProp: () => cadModelProp,
-  cadModelStl: () => cadModelStl,
-  capacitorPins: () => capacitorPins,
-  capacitorProps: () => capacitorProps,
-  chipProps: () => chipProps,
-  circleSmtPadProps: () => circleSmtPadProps,
-  circleSolderPasteProps: () => circleSolderPasteProps,
-  commonComponentProps: () => commonComponentProps,
-  commonLayoutProps: () => commonLayoutProps,
-  componentProps: () => componentProps,
-  constrainedLayoutProps: () => constrainedLayoutProps,
-  constraintProps: () => constraintProps,
-  crystalPins: () => crystalPins,
-  crystalProps: () => crystalProps,
-  diodePins: () => diodePins,
-  diodeProps: () => diodeProps,
-  direction: () => direction,
-  directionAlongEdge: () => directionAlongEdge,
-  distanceOrMultiplier: () => distanceOrMultiplier2,
-  explicitPinSideDefinition: () => explicitPinSideDefinition,
-  fabricationNotePathProps: () => fabricationNotePathProps,
-  fabricationNoteTextProps: () => fabricationNoteTextProps,
-  footprintProp: () => footprintProp,
-  footprintProps: () => footprintProps,
-  groupProps: () => groupProps,
-  holeProps: () => holeProps,
-  inductorPins: () => inductorPins,
-  inductorProps: () => inductorProps,
-  jumperProps: () => jumperProps,
-  ledPins: () => ledPins,
-  ledProps: () => ledProps,
-  lrPins: () => lrPins,
-  lrPolarPins: () => lrPolarPins,
-  netAliasProps: () => netAliasProps,
-  netProps: () => netProps,
-  pcbKeepoutProps: () => pcbKeepoutProps,
-  pcbLayoutProps: () => pcbLayoutProps,
-  pcbSameXConstraintProps: () => pcbSameXConstraintProps,
-  pcbSameYConstraintProps: () => pcbSameYConstraintProps,
-  pcbTraceProps: () => pcbTraceProps,
-  pcbXDistConstraintProps: () => pcbXDistConstraintProps,
-  pcbYDistConstraintProps: () => pcbYDistConstraintProps,
-  pinHeaderProps: () => pinHeaderProps,
-  pinLabelsProp: () => pinLabelsProp,
-  platedHoleProps: () => platedHoleProps,
-  point3: () => point3,
-  portHints: () => portHints,
-  portProps: () => portProps,
-  portRef: () => portRef,
-  potentiometerPins: () => potentiometerPins,
-  potentiometerProps: () => potentiometerProps,
-  powerSourceProps: () => powerSourceProps,
-  pushButtonProps: () => pushButtonProps,
-  rectSmtPadProps: () => rectSmtPadProps,
-  rectSolderPasteProps: () => rectSolderPasteProps,
-  resistorPins: () => resistorPins,
-  resistorProps: () => resistorProps,
-  rotatedRectSmtPadProps: () => rotatedRectSmtPadProps,
-  rotationPoint3: () => rotationPoint3,
-  routeHintPointProps: () => routeHintPointProps,
-  schematicBoxProps: () => schematicBoxProps,
-  schematicLineProps: () => schematicLineProps,
-  schematicPathProps: () => schematicPathProps,
-  schematicPinStyle: () => schematicPinStyle,
-  schematicPortArrangement: () => schematicPortArrangement,
-  schematicTextProps: () => schematicTextProps,
-  silkscreenCircleProps: () => silkscreenCircleProps,
-  silkscreenLineProps: () => silkscreenLineProps,
-  silkscreenPathProps: () => silkscreenPathProps,
-  silkscreenRectProps: () => silkscreenRectProps,
-  silkscreenTextProps: () => silkscreenTextProps,
-  smtPadProps: () => smtPadProps,
-  solderPasteProps: () => solderPasteProps,
-  subcircuitGroupProps: () => subcircuitGroupProps,
-  subcircuitGroupPropsWithBool: () => subcircuitGroupPropsWithBool,
-  subcircuitProps: () => subcircuitProps,
-  supplierProps: () => supplierProps,
-  switchProps: () => switchProps,
-  traceHintProps: () => traceHintProps,
-  traceProps: () => traceProps,
-  viaProps: () => viaProps
-});
-module.exports = __toCommonJS(lib_exports);
-var import_circuit_json19 = require("circuit-json");
-var import_zod30 = require("zod");
+import {
+  distance as distance12,
+  inductance,
+  layer_ref as layer_ref3,
+  length as length3,
+  point as point2,
+  route_hint_point as route_hint_point2,
+  voltage
+} from "circuit-json";
+import { z as z31 } from "zod";
 
 // lib/typecheck.ts
 var expectTypesMatch = (shouldBe) => {
@@ -125,9 +19,9 @@ expectTypesMatch(true);
 expectTypesMatch("property a has mismatched types");
 
 // lib/common/direction.ts
-var import_zod = require("zod");
-var direction = import_zod.z.enum(["up", "down", "left", "right"]);
-var directionAlongEdge = import_zod.z.enum([
+import { z } from "zod";
+var direction = z.enum(["up", "down", "left", "right"]);
+var directionAlongEdge = z.enum([
   "top-to-bottom",
   "left-to-right",
   "bottom-to-top",
@@ -137,50 +31,55 @@ expectTypesMatch(true);
 expectTypesMatch(true);
 
 // lib/common/portHints.ts
-var import_zod2 = require("zod");
-var portHints = import_zod2.z.array(import_zod2.z.string().or(import_zod2.z.number()));
+import { z as z2 } from "zod";
+var portHints = z2.array(z2.string().or(z2.number()));
 expectTypesMatch(true);
 
 // lib/common/layout.ts
-var import_circuit_json2 = require("circuit-json");
-var import_zod6 = require("zod");
+import {
+  distance as distance2,
+  layer_ref,
+  rotation,
+  supplier_name
+} from "circuit-json";
+import { z as z6 } from "zod";
 
 // lib/common/cadModel.ts
-var import_zod4 = require("zod");
+import { z as z4 } from "zod";
 
 // lib/common/point3.ts
-var import_circuit_json = require("circuit-json");
-var import_zod3 = require("zod");
-var point3 = import_zod3.z.object({
-  x: import_circuit_json.distance,
-  y: import_circuit_json.distance,
-  z: import_circuit_json.distance
+import { distance } from "circuit-json";
+import { z as z3 } from "zod";
+var point3 = z3.object({
+  x: distance,
+  y: distance,
+  z: distance
 });
 
 // lib/common/cadModel.ts
-var rotationPoint3 = import_zod4.z.object({
-  x: import_zod4.z.union([import_zod4.z.number(), import_zod4.z.string()]),
-  y: import_zod4.z.union([import_zod4.z.number(), import_zod4.z.string()]),
-  z: import_zod4.z.union([import_zod4.z.number(), import_zod4.z.string()])
+var rotationPoint3 = z4.object({
+  x: z4.union([z4.number(), z4.string()]),
+  y: z4.union([z4.number(), z4.string()]),
+  z: z4.union([z4.number(), z4.string()])
 });
-var cadModelBase = import_zod4.z.object({
-  rotationOffset: import_zod4.z.number().or(rotationPoint3).optional(),
+var cadModelBase = z4.object({
+  rotationOffset: z4.number().or(rotationPoint3).optional(),
   positionOffset: point3.optional(),
   size: point3.optional()
 });
 expectTypesMatch(true);
 var cadModelStl = cadModelBase.extend({
-  stlUrl: import_zod4.z.string()
+  stlUrl: z4.string()
 });
 var cadModelObj = cadModelBase.extend({
-  objUrl: import_zod4.z.string(),
-  mtlUrl: import_zod4.z.string().optional()
+  objUrl: z4.string(),
+  mtlUrl: z4.string().optional()
 });
 var cadModelJscad = cadModelBase.extend({
-  jscad: import_zod4.z.record(import_zod4.z.any())
+  jscad: z4.record(z4.any())
 });
-var cadModelProp = import_zod4.z.union([
-  import_zod4.z.string(),
+var cadModelProp = z4.union([
+  z4.string(),
   cadModelStl,
   cadModelObj,
   cadModelJscad
@@ -188,38 +87,38 @@ var cadModelProp = import_zod4.z.union([
 expectTypesMatch(true);
 
 // lib/common/footprintProp.ts
-var import_zod5 = require("zod");
-var footprintProp = import_zod5.z.custom((v) => true);
+import { z as z5 } from "zod";
+var footprintProp = z5.custom((v) => true);
 
 // lib/common/layout.ts
-var pcbLayoutProps = import_zod6.z.object({
-  pcbX: import_circuit_json2.distance.optional(),
-  pcbY: import_circuit_json2.distance.optional(),
-  pcbRotation: import_circuit_json2.rotation.optional(),
-  layer: import_circuit_json2.layer_ref.optional()
-});
-expectTypesMatch(true);
-var commonLayoutProps = import_zod6.z.object({
-  pcbX: import_circuit_json2.distance.optional(),
-  pcbY: import_circuit_json2.distance.optional(),
-  pcbRotation: import_circuit_json2.rotation.optional(),
-  schX: import_circuit_json2.distance.optional(),
-  schY: import_circuit_json2.distance.optional(),
-  schRotation: import_circuit_json2.rotation.optional(),
-  layer: import_circuit_json2.layer_ref.optional(),
+var pcbLayoutProps = z6.object({
+  pcbX: distance2.optional(),
+  pcbY: distance2.optional(),
+  pcbRotation: rotation.optional(),
+  layer: layer_ref.optional()
+});
+expectTypesMatch(true);
+var commonLayoutProps = z6.object({
+  pcbX: distance2.optional(),
+  pcbY: distance2.optional(),
+  pcbRotation: rotation.optional(),
+  schX: distance2.optional(),
+  schY: distance2.optional(),
+  schRotation: rotation.optional(),
+  layer: layer_ref.optional(),
   footprint: footprintProp.optional()
 });
 expectTypesMatch(true);
-var supplierProps = import_zod6.z.object({
-  supplierPartNumbers: import_zod6.z.record(import_circuit_json2.supplier_name, import_zod6.z.array(import_zod6.z.string())).optional()
+var supplierProps = z6.object({
+  supplierPartNumbers: z6.record(supplier_name, z6.array(z6.string())).optional()
 });
 expectTypesMatch(true);
 var commonComponentProps = commonLayoutProps.merge(supplierProps).extend({
-  key: import_zod6.z.any().optional(),
-  name: import_zod6.z.string(),
+  key: z6.any().optional(),
+  name: z6.string(),
   cadModel: cadModelProp.optional(),
-  children: import_zod6.z.any().optional(),
-  symbolName: import_zod6.z.string().optional()
+  children: z6.any().optional(),
+  symbolName: z6.string().optional()
 });
 expectTypesMatch(true);
 var lrPins = ["pin1", "left", "pin2", "right"];
@@ -233,28 +132,28 @@ var lrPolarPins = [
   "cathode",
   "neg"
 ];
-var distanceOrMultiplier = import_circuit_json2.distance.or(import_zod6.z.enum(["2x", "3x", "4x"]));
+var distanceOrMultiplier = distance2.or(z6.enum(["2x", "3x", "4x"]));
 
 // lib/common/schematicPinDefinitions.ts
-var import_zod7 = require("zod");
-var explicitPinSideDefinition = import_zod7.z.object({
-  pins: import_zod7.z.array(import_zod7.z.union([import_zod7.z.number(), import_zod7.z.string()])),
-  direction: import_zod7.z.union([
-    import_zod7.z.literal("top-to-bottom"),
-    import_zod7.z.literal("left-to-right"),
-    import_zod7.z.literal("bottom-to-top"),
-    import_zod7.z.literal("right-to-left")
+import { z as z7 } from "zod";
+var explicitPinSideDefinition = z7.object({
+  pins: z7.array(z7.union([z7.number(), z7.string()])),
+  direction: z7.union([
+    z7.literal("top-to-bottom"),
+    z7.literal("left-to-right"),
+    z7.literal("bottom-to-top"),
+    z7.literal("right-to-left")
   ])
 });
-var schematicPortArrangement = import_zod7.z.object({
-  leftSize: import_zod7.z.number().optional().describe("@deprecated, use leftPinCount"),
-  topSize: import_zod7.z.number().optional().describe("@deprecated, use topPinCount"),
-  rightSize: import_zod7.z.number().optional().describe("@deprecated, use rightPinCount"),
-  bottomSize: import_zod7.z.number().optional().describe("@deprecated, use bottomPinCount"),
-  leftPinCount: import_zod7.z.number().optional(),
-  rightPinCount: import_zod7.z.number().optional(),
-  topPinCount: import_zod7.z.number().optional(),
-  bottomPinCount: import_zod7.z.number().optional(),
+var schematicPortArrangement = z7.object({
+  leftSize: z7.number().optional().describe("@deprecated, use leftPinCount"),
+  topSize: z7.number().optional().describe("@deprecated, use topPinCount"),
+  rightSize: z7.number().optional().describe("@deprecated, use rightPinCount"),
+  bottomSize: z7.number().optional().describe("@deprecated, use bottomPinCount"),
+  leftPinCount: z7.number().optional(),
+  rightPinCount: z7.number().optional(),
+  topPinCount: z7.number().optional(),
+  bottomPinCount: z7.number().optional(),
   leftSide: explicitPinSideDefinition.optional(),
   rightSide: explicitPinSideDefinition.optional(),
   topSide: explicitPinSideDefinition.optional(),
@@ -263,69 +162,69 @@ var schematicPortArrangement = import_zod7.z.object({
 expectTypesMatch(true);
 
 // lib/common/schematicPinStyle.ts
-var import_circuit_json3 = require("circuit-json");
-var import_zod8 = require("zod");
-var schematicPinStyle = import_zod8.z.record(
-  import_zod8.z.object({
-    leftMargin: import_circuit_json3.distance.optional(),
-    rightMargin: import_circuit_json3.distance.optional(),
-    topMargin: import_circuit_json3.distance.optional(),
-    bottomMargin: import_circuit_json3.distance.optional()
+import { distance as distance3 } from "circuit-json";
+import { z as z8 } from "zod";
+var schematicPinStyle = z8.record(
+  z8.object({
+    leftMargin: distance3.optional(),
+    rightMargin: distance3.optional(),
+    topMargin: distance3.optional(),
+    bottomMargin: distance3.optional()
   })
 );
 expectTypesMatch(true);
 
 // lib/components/board.ts
-var import_circuit_json6 = require("circuit-json");
+import { distance as distance5 } from "circuit-json";
 
 // lib/common/point.ts
-var import_circuit_json4 = require("circuit-json");
-var import_zod9 = require("zod");
-var point = import_zod9.z.object({
-  x: import_circuit_json4.distance,
-  y: import_circuit_json4.distance
+import { distance as distance4 } from "circuit-json";
+import { z as z9 } from "zod";
+var point = z9.object({
+  x: distance4,
+  y: distance4
 });
 
 // lib/components/board.ts
-var import_zod11 = require("zod");
+import { z as z11 } from "zod";
 
 // lib/components/group.ts
-var import_circuit_json5 = require("circuit-json");
-var import_zod10 = require("zod");
-var autorouterConfig = import_zod10.z.object({
-  serverUrl: import_zod10.z.string().optional(),
-  inputFormat: import_zod10.z.enum(["simplified", "circuit-json"]).optional(),
-  serverMode: import_zod10.z.enum(["job", "solve-endpoint"]).optional(),
-  cache: import_zod10.z.custom((v) => true).optional()
-});
-var autorouterProp = import_zod10.z.union([
+import { length } from "circuit-json";
+import { z as z10 } from "zod";
+var autorouterConfig = z10.object({
+  serverUrl: z10.string().optional(),
+  inputFormat: z10.enum(["simplified", "circuit-json"]).optional(),
+  serverMode: z10.enum(["job", "solve-endpoint"]).optional(),
+  cache: z10.custom((v) => true).optional()
+});
+var autorouterProp = z10.union([
   autorouterConfig,
-  import_zod10.z.literal("sequential-trace"),
-  import_zod10.z.literal("subcircuit"),
-  import_zod10.z.literal("auto"),
-  import_zod10.z.literal("auto-local"),
-  import_zod10.z.literal("auto-cloud")
+  z10.literal("sequential-trace"),
+  z10.literal("subcircuit"),
+  z10.literal("auto"),
+  z10.literal("auto-local"),
+  z10.literal("auto-cloud")
 ]);
 var baseGroupProps = commonLayoutProps.extend({
-  name: import_zod10.z.string().optional(),
-  children: import_zod10.z.any().optional()
+  name: z10.string().optional(),
+  children: z10.any().optional()
 });
 var subcircuitGroupProps = baseGroupProps.extend({
-  layout: import_zod10.z.custom((v) => true).optional(),
-  manualEdits: import_zod10.z.custom((v) => true).optional(),
-  schAutoLayoutEnabled: import_zod10.z.boolean().optional(),
-  routingDisabled: import_zod10.z.boolean().optional(),
-  defaultTraceWidth: import_circuit_json5.length.optional(),
-  minTraceWidth: import_circuit_json5.length.optional(),
-  partsEngine: import_zod10.z.custom((v) => "findPart" in v).optional(),
-  pcbRouteCache: import_zod10.z.custom((v) => true).optional(),
+  layout: z10.custom((v) => true).optional(),
+  manualEdits: z10.custom((v) => true).optional(),
+  schAutoLayoutEnabled: z10.boolean().optional(),
+  routingDisabled: z10.boolean().optional(),
+  defaultTraceWidth: length.optional(),
+  minTraceWidth: length.optional(),
+  partsEngine: z10.custom((v) => "findPart" in v).optional(),
+  pcbRouteCache: z10.custom((v) => true).optional(),
   autorouter: autorouterProp.optional()
 });
 var subcircuitGroupPropsWithBool = subcircuitGroupProps.extend({
-  subcircuit: import_zod10.z.literal(true)
+  subcircuit: z10.literal(true)
 });
-var groupProps = import_zod10.z.discriminatedUnion("subcircuit", [
-  baseGroupProps.extend({ subcircuit: import_zod10.z.literal(false).optional() }),
+var groupProps = z10.discriminatedUnion("subcircuit", [
+  baseGroupProps.extend({ subcircuit: z10.literal(false).optional() }),
   subcircuitGroupPropsWithBool
 ]);
 expectTypesMatch(true);
@@ -334,187 +233,189 @@ expectTypesMatch(true);
 
 // lib/components/board.ts
 var boardProps = subcircuitGroupProps.extend({
-  width: import_circuit_json6.distance.optional(),
-  height: import_circuit_json6.distance.optional(),
-  outline: import_zod11.z.array(point).optional()
+  width: distance5.optional(),
+  height: distance5.optional(),
+  outline: z11.array(point).optional()
 });
 expectTypesMatch(true);
 
 // lib/components/chip.ts
-var import_circuit_json7 = require("circuit-json");
-var import_zod12 = require("zod");
-var pinLabelsProp = import_zod12.z.record(
-  import_zod12.z.number().or(import_zod12.z.string()),
-  import_zod12.z.string().or(import_zod12.z.array(import_zod12.z.string()).readonly()).or(import_zod12.z.array(import_zod12.z.string()))
+import { distance as distance6 } from "circuit-json";
+import { z as z12 } from "zod";
+var pinLabelsProp = z12.record(
+  z12.number().or(z12.string()),
+  z12.string().or(z12.array(z12.string()).readonly()).or(z12.array(z12.string()))
 );
 expectTypesMatch(true);
 var chipProps = commonComponentProps.extend({
-  manufacturerPartNumber: import_zod12.z.string().optional(),
-  pinLabels: import_zod12.z.record(
-    import_zod12.z.number().or(import_zod12.z.string()),
-    import_zod12.z.string().or(import_zod12.z.array(import_zod12.z.string()).readonly())
+  manufacturerPartNumber: z12.string().optional(),
+  pinLabels: z12.record(
+    z12.number().or(z12.string()),
+    z12.string().or(z12.array(z12.string()).readonly())
   ).optional(),
   schPortArrangement: schematicPortArrangement.optional(),
   schPinStyle: schematicPinStyle.optional(),
-  schPinSpacing: import_circuit_json7.distance.optional(),
-  schWidth: import_circuit_json7.distance.optional(),
-  schHeight: import_circuit_json7.distance.optional()
+  schPinSpacing: distance6.optional(),
+  schWidth: distance6.optional(),
+  schHeight: distance6.optional()
 });
 var bugProps = chipProps;
 expectTypesMatch(true);
 
 // lib/components/jumper.ts
-var import_circuit_json8 = require("circuit-json");
-var import_zod13 = require("zod");
+import { distance as distance7 } from "circuit-json";
+import { z as z13 } from "zod";
 var jumperProps = commonComponentProps.extend({
-  manufacturerPartNumber: import_zod13.z.string().optional(),
-  pinLabels: import_zod13.z.record(import_zod13.z.number().or(import_zod13.z.string()), import_zod13.z.string().or(import_zod13.z.array(import_zod13.z.string()))).optional(),
+  manufacturerPartNumber: z13.string().optional(),
+  pinLabels: z13.record(z13.number().or(z13.string()), z13.string().or(z13.array(z13.string()))).optional(),
   schPinStyle: schematicPinStyle.optional(),
-  schPinSpacing: import_circuit_json8.distance.optional(),
-  schWidth: import_circuit_json8.distance.optional(),
-  schHeight: import_circuit_json8.distance.optional(),
-  schDirection: import_zod13.z.enum(["left", "right"]).optional(),
+  schPinSpacing: distance7.optional(),
+  schWidth: distance7.optional(),
+  schHeight: distance7.optional(),
+  schDirection: z13.enum(["left", "right"]).optional(),
   schPortArrangement: schematicPortArrangement.optional()
 });
 expectTypesMatch(true);
 
 // lib/components/platedhole.ts
-var import_circuit_json9 = require("circuit-json");
-var import_zod14 = require("zod");
-var platedHoleProps = import_zod14.z.discriminatedUnion("shape", [
+import { distance as distance8 } from "circuit-json";
+import { z as z14 } from "zod";
+var platedHoleProps = z14.discriminatedUnion("shape", [
   pcbLayoutProps.omit({ pcbRotation: true, layer: true }).extend({
-    name: import_zod14.z.string().optional(),
-    shape: import_zod14.z.literal("circle"),
-    holeDiameter: import_circuit_json9.distance,
-    outerDiameter: import_circuit_json9.distance,
+    name: z14.string().optional(),
+    shape: z14.literal("circle"),
+    holeDiameter: distance8,
+    outerDiameter: distance8,
     portHints: portHints.optional()
   }),
   pcbLayoutProps.omit({ pcbRotation: true, layer: true }).extend({
-    name: import_zod14.z.string().optional(),
-    shape: import_zod14.z.literal("oval"),
-    outerWidth: import_circuit_json9.distance,
-    outerHeight: import_circuit_json9.distance,
-    innerWidth: import_circuit_json9.distance,
-    innerHeight: import_circuit_json9.distance,
+    name: z14.string().optional(),
+    shape: z14.literal("oval"),
+    outerWidth: distance8,
+    outerHeight: distance8,
+    innerWidth: distance8,
+    innerHeight: distance8,
     portHints: portHints.optional()
   }),
   pcbLayoutProps.omit({ pcbRotation: true, layer: true }).extend({
-    name: import_zod14.z.string().optional(),
-    shape: import_zod14.z.literal("pill"),
-    outerWidth: import_circuit_json9.distance,
-    outerHeight: import_circuit_json9.distance,
-    innerWidth: import_circuit_json9.distance,
-    innerHeight: import_circuit_json9.distance,
+    name: z14.string().optional(),
+    shape: z14.literal("pill"),
+    outerWidth: distance8,
+    outerHeight: distance8,
+    innerWidth: distance8,
+    innerHeight: distance8,
     portHints: portHints.optional()
   })
 ]);
 expectTypesMatch(true);
 
 // lib/components/resistor.ts
-var import_circuit_json10 = require("circuit-json");
-var import_zod15 = require("zod");
+import { resistance } from "circuit-json";
+import { z as z15 } from "zod";
 var resistorProps = commonComponentProps.extend({
-  resistance: import_circuit_json10.resistance,
-  pullupFor: import_zod15.z.string().optional(),
-  pullupTo: import_zod15.z.string().optional(),
-  pulldownFor: import_zod15.z.string().optional(),
-  pulldownTo: import_zod15.z.string().optional()
+  resistance,
+  pullupFor: z15.string().optional(),
+  pullupTo: z15.string().optional(),
+  pulldownFor: z15.string().optional(),
+  pulldownTo: z15.string().optional()
 });
 var resistorPins = lrPins;
 expectTypesMatch(true);
 
 // lib/components/potentiometer.ts
-var import_circuit_json11 = require("circuit-json");
+import { resistance as resistance2 } from "circuit-json";
 var potentiometerProps = commonComponentProps.extend({
-  maxResistance: import_circuit_json11.resistance
+  maxResistance: resistance2
 });
 var potentiometerPins = lrPins;
 expectTypesMatch(true);
 
 // lib/components/crystal.ts
-var import_circuit_json12 = require("circuit-json");
+import { frequency, capacitance } from "circuit-json";
+import { z as z16 } from "zod";
 var crystalProps = commonComponentProps.extend({
-  frequency: import_circuit_json12.frequency,
-  loadCapacitance: import_circuit_json12.capacitance
+  frequency,
+  loadCapacitance: capacitance,
+  pinVariant: z16.enum(["2pin", "4pin"]).optional()
 });
 var crystalPins = lrPins;
 expectTypesMatch(true);
 
 // lib/components/capacitor.ts
-var import_circuit_json13 = require("circuit-json");
-var import_zod16 = require("zod");
+import { capacitance as capacitance2 } from "circuit-json";
+import { z as z17 } from "zod";
 var capacitorProps = commonComponentProps.extend({
-  capacitance: import_circuit_json13.capacitance,
-  polarized: import_zod16.z.boolean().optional().default(false),
-  decouplingFor: import_zod16.z.string().optional(),
-  decouplingTo: import_zod16.z.string().optional(),
-  bypassFor: import_zod16.z.string().optional(),
-  bypassTo: import_zod16.z.string().optional()
+  capacitance: capacitance2,
+  polarized: z17.boolean().optional().default(false),
+  decouplingFor: z17.string().optional(),
+  decouplingTo: z17.string().optional(),
+  bypassFor: z17.string().optional(),
+  bypassTo: z17.string().optional()
 });
 var capacitorPins = lrPolarPins;
 expectTypesMatch(true);
 
 // lib/components/net.ts
-var import_zod17 = require("zod");
-var netProps = import_zod17.z.object({
-  name: import_zod17.z.string()
+import { z as z18 } from "zod";
+var netProps = z18.object({
+  name: z18.string()
 });
 expectTypesMatch(true);
 
 // lib/components/constrainedlayout.ts
-var import_zod18 = require("zod");
-var constrainedLayoutProps = import_zod18.z.object({
-  name: import_zod18.z.string().optional(),
-  pcbOnly: import_zod18.z.boolean().optional(),
-  schOnly: import_zod18.z.boolean().optional()
+import { z as z19 } from "zod";
+var constrainedLayoutProps = z19.object({
+  name: z19.string().optional(),
+  pcbOnly: z19.boolean().optional(),
+  schOnly: z19.boolean().optional()
 });
 expectTypesMatch(true);
 
 // lib/common/distance.ts
-var import_zod19 = require("zod");
-var import_circuit_json14 = require("circuit-json");
+import "zod";
+import { distance as distance9, length as length2 } from "circuit-json";
 
 // lib/components/constraint.ts
-var import_zod20 = require("zod");
-var pcbXDistConstraintProps = import_zod20.z.object({
-  pcb: import_zod20.z.literal(true).optional(),
-  xDist: import_circuit_json14.distance,
-  left: import_zod20.z.string(),
-  right: import_zod20.z.string(),
-  edgeToEdge: import_zod20.z.literal(true).optional(),
-  centerToCenter: import_zod20.z.literal(true).optional()
+import { z as z21 } from "zod";
+var pcbXDistConstraintProps = z21.object({
+  pcb: z21.literal(true).optional(),
+  xDist: distance9,
+  left: z21.string(),
+  right: z21.string(),
+  edgeToEdge: z21.literal(true).optional(),
+  centerToCenter: z21.literal(true).optional()
 });
 expectTypesMatch(
   true
 );
-var pcbYDistConstraintProps = import_zod20.z.object({
-  pcb: import_zod20.z.literal(true).optional(),
-  yDist: import_circuit_json14.distance,
-  top: import_zod20.z.string(),
-  bottom: import_zod20.z.string(),
-  edgeToEdge: import_zod20.z.literal(true).optional(),
-  centerToCenter: import_zod20.z.literal(true).optional()
+var pcbYDistConstraintProps = z21.object({
+  pcb: z21.literal(true).optional(),
+  yDist: distance9,
+  top: z21.string(),
+  bottom: z21.string(),
+  edgeToEdge: z21.literal(true).optional(),
+  centerToCenter: z21.literal(true).optional()
 });
 expectTypesMatch(
   true
 );
-var pcbSameYConstraintProps = import_zod20.z.object({
-  pcb: import_zod20.z.literal(true).optional(),
-  sameY: import_zod20.z.literal(true).optional(),
-  for: import_zod20.z.array(import_zod20.z.string())
+var pcbSameYConstraintProps = z21.object({
+  pcb: z21.literal(true).optional(),
+  sameY: z21.literal(true).optional(),
+  for: z21.array(z21.string())
 });
 expectTypesMatch(
   true
 );
-var pcbSameXConstraintProps = import_zod20.z.object({
-  pcb: import_zod20.z.literal(true).optional(),
-  sameX: import_zod20.z.literal(true).optional(),
-  for: import_zod20.z.array(import_zod20.z.string())
+var pcbSameXConstraintProps = z21.object({
+  pcb: z21.literal(true).optional(),
+  sameX: z21.literal(true).optional(),
+  for: z21.array(z21.string())
 });
 expectTypesMatch(
   true
 );
-var constraintProps = import_zod20.z.union([
+var constraintProps = z21.union([
   pcbXDistConstraintProps,
   pcbYDistConstraintProps,
   pcbSameYConstraintProps,
@@ -523,29 +424,29 @@ var constraintProps = import_zod20.z.union([
 expectTypesMatch(true);
 
 // lib/components/smtpad.ts
-var import_zod21 = require("zod");
+import { z as z22 } from "zod";
 var rectSmtPadProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  shape: import_zod21.z.literal("rect"),
-  width: import_circuit_json14.distance,
-  height: import_circuit_json14.distance,
+  shape: z22.literal("rect"),
+  width: distance9,
+  height: distance9,
   portHints: portHints.optional()
 });
 expectTypesMatch(true);
 var rotatedRectSmtPadProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  shape: import_zod21.z.literal("rotated_rect"),
-  width: import_circuit_json14.distance,
-  height: import_circuit_json14.distance,
-  ccwRotation: import_zod21.z.number(),
+  shape: z22.literal("rotated_rect"),
+  width: distance9,
+  height: distance9,
+  ccwRotation: z22.number(),
   portHints: portHints.optional()
 });
 expectTypesMatch(true);
 var circleSmtPadProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  shape: import_zod21.z.literal("circle"),
-  radius: import_circuit_json14.distance,
+  shape: z22.literal("circle"),
+  radius: distance9,
   portHints: portHints.optional()
 });
 expectTypesMatch(true);
-var smtPadProps = import_zod21.z.union([
+var smtPadProps = z22.union([
   circleSmtPadProps,
   rectSmtPadProps,
   rotatedRectSmtPadProps
@@ -553,30 +454,30 @@ var smtPadProps = import_zod21.z.union([
 expectTypesMatch(true);
 
 // lib/components/solderpaste.ts
-var import_zod22 = require("zod");
+import { z as z23 } from "zod";
 var rectSolderPasteProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  shape: import_zod22.z.literal("rect"),
-  width: import_circuit_json14.distance,
-  height: import_circuit_json14.distance
+  shape: z23.literal("rect"),
+  width: distance9,
+  height: distance9
 });
 expectTypesMatch(true);
 var circleSolderPasteProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  shape: import_zod22.z.literal("circle"),
-  radius: import_circuit_json14.distance
+  shape: z23.literal("circle"),
+  radius: distance9
 });
 expectTypesMatch(true);
-var solderPasteProps = import_zod22.z.union([
+var solderPasteProps = z23.union([
   circleSolderPasteProps,
   rectSolderPasteProps
 ]);
 expectTypesMatch(true);
 
 // lib/components/hole.ts
-var import_zod23 = require("zod");
+import { z as z24 } from "zod";
 var holeProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  name: import_zod23.z.string().optional(),
-  diameter: import_circuit_json14.distance.optional(),
-  radius: import_circuit_json14.distance.optional()
+  name: z24.string().optional(),
+  diameter: distance9.optional(),
+  radius: distance9.optional()
 }).transform((d) => ({
   ...d,
   diameter: d.diameter ?? 2 * d.radius,
@@ -585,24 +486,24 @@ var holeProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
 expectTypesMatch(true);
 
 // lib/components/trace.ts
-var import_circuit_json15 = require("circuit-json");
-var import_zod24 = require("zod");
-var portRef = import_zod24.z.union([
-  import_zod24.z.string(),
-  import_zod24.z.custom(
+import { distance as distance10, route_hint_point } from "circuit-json";
+import { z as z25 } from "zod";
+var portRef = z25.union([
+  z25.string(),
+  z25.custom(
     (v) => Boolean(v.getPortSelector)
   )
 ]);
-var baseTraceProps = import_zod24.z.object({
-  key: import_zod24.z.string().optional(),
-  thickness: import_circuit_json15.distance.optional(),
-  schematicRouteHints: import_zod24.z.array(point).optional(),
-  pcbRouteHints: import_zod24.z.array(import_circuit_json15.route_hint_point).optional(),
-  schDisplayLabel: import_zod24.z.string().optional()
-});
-var traceProps = import_zod24.z.union([
+var baseTraceProps = z25.object({
+  key: z25.string().optional(),
+  thickness: distance10.optional(),
+  schematicRouteHints: z25.array(point).optional(),
+  pcbRouteHints: z25.array(route_hint_point).optional(),
+  schDisplayLabel: z25.string().optional()
+});
+var traceProps = z25.union([
   baseTraceProps.extend({
-    path: import_zod24.z.array(portRef)
+    path: z25.array(portRef)
   }),
   baseTraceProps.extend({
     from: portRef,
@@ -611,16 +512,16 @@ var traceProps = import_zod24.z.union([
 ]);
 
 // lib/components/footprint.ts
-var import_circuit_json16 = require("circuit-json");
-var import_zod25 = require("zod");
-var footprintProps = import_zod25.z.object({
-  originalLayer: import_circuit_json16.layer_ref.default("top").optional()
+import { layer_ref as layer_ref2 } from "circuit-json";
+import { z as z26 } from "zod";
+var footprintProps = z26.object({
+  originalLayer: layer_ref2.default("top").optional()
 });
 expectTypesMatch(true);
 
 // lib/components/battery.ts
-var import_zod26 = require("zod");
-var capacity = import_zod26.z.number().or(import_zod26.z.string().endsWith("mAh")).transform((v) => {
+import { z as z27 } from "zod";
+var capacity = z27.number().or(z27.string().endsWith("mAh")).transform((v) => {
   if (typeof v === "string") {
     const valString = v.replace("mAh", "");
     const num = Number.parseFloat(valString);
@@ -638,35 +539,35 @@ var batteryPins = lrPolarPins;
 expectTypesMatch(true);
 
 // lib/components/pin-header.ts
-var import_circuit_json17 = require("circuit-json");
-var import_zod27 = require("zod");
+import { distance as distance11 } from "circuit-json";
+import { z as z28 } from "zod";
 var pinHeaderProps = commonComponentProps.extend({
-  pinCount: import_zod27.z.number(),
-  pitch: import_circuit_json17.distance.optional(),
-  gender: import_zod27.z.enum(["male", "female"]).optional().default("male"),
-  showSilkscreenPinLabels: import_zod27.z.boolean().optional(),
-  doubleRow: import_zod27.z.boolean().optional(),
-  holeDiameter: import_circuit_json17.distance.optional(),
-  platedDiameter: import_circuit_json17.distance.optional(),
-  pinLabels: import_zod27.z.array(import_zod27.z.string()).optional(),
-  facingDirection: import_zod27.z.enum(["left", "right"]).optional()
+  pinCount: z28.number(),
+  pitch: distance11.optional(),
+  gender: z28.enum(["male", "female"]).optional().default("male"),
+  showSilkscreenPinLabels: z28.boolean().optional(),
+  doubleRow: z28.boolean().optional(),
+  holeDiameter: distance11.optional(),
+  platedDiameter: distance11.optional(),
+  pinLabels: z28.array(z28.string()).optional(),
+  facingDirection: z28.enum(["left", "right"]).optional()
 });
 expectTypesMatch(true);
 
 // lib/components/netalias.ts
-var import_zod28 = require("zod");
-var import_circuit_json18 = require("circuit-json");
-var netAliasProps = import_zod28.z.object({
-  net: import_zod28.z.string().optional(),
-  schX: import_circuit_json14.distance.optional(),
-  schY: import_circuit_json14.distance.optional(),
-  schRotation: import_circuit_json18.rotation.optional(),
-  anchorSide: import_zod28.z.enum(["left", "up", "right", "down"]).optional()
+import { z as z29 } from "zod";
+import { rotation as rotation2 } from "circuit-json";
+var netAliasProps = z29.object({
+  net: z29.string().optional(),
+  schX: distance9.optional(),
+  schY: distance9.optional(),
+  schRotation: rotation2.optional(),
+  anchorSide: z29.enum(["left", "up", "right", "down"]).optional()
 });
 expectTypesMatch(true);
 
 // lib/components/push-button.ts
-var import_zod29 = require("zod");
+import "zod";
 var pushButtonProps = commonComponentProps.extend({});
 
 // lib/components/subcircuit.ts
@@ -675,134 +576,133 @@ expectTypesMatch(true);
 
 // lib/index.ts
 var inductorProps = commonComponentProps.extend({
-  inductance: import_circuit_json19.inductance
+  inductance
 });
 var inductorPins = lrPins;
 var diodeProps = commonComponentProps.extend({});
 var diodePins = lrPolarPins;
 var ledProps = commonComponentProps.extend({
-  color: import_zod30.z.string().optional()
+  color: z31.string().optional()
 });
 var ledPins = lrPolarPins;
 var switchProps = commonComponentProps.extend({
-  ftype: import_zod30.z.literal("switch"),
-  switchType: import_zod30.z.enum(["spst"]).default("spst"),
-  isNormallyClosed: import_zod30.z.boolean().default(false)
+  ftype: z31.literal("switch"),
+  switchType: z31.enum(["spst"]).default("spst"),
+  isNormallyClosed: z31.boolean().default(false)
 });
-var distanceOrMultiplier2 = import_circuit_json19.distance.or(import_zod30.z.enum(["2x", "3x", "4x"]));
+var distanceOrMultiplier2 = distance12.or(z31.enum(["2x", "3x", "4x"]));
 var viaProps = commonLayoutProps.extend({
-  fromLayer: import_circuit_json19.layer_ref,
-  toLayer: import_circuit_json19.layer_ref,
-  holeDiameter: import_circuit_json19.distance,
-  outerDiameter: import_circuit_json19.distance
+  fromLayer: layer_ref3,
+  toLayer: layer_ref3,
+  holeDiameter: distance12,
+  outerDiameter: distance12
 });
-var pcbKeepoutProps = import_zod30.z.union([
+var pcbKeepoutProps = z31.union([
   pcbLayoutProps.omit({ pcbRotation: true }).extend({
-    shape: import_zod30.z.literal("circle"),
-    radius: import_circuit_json19.distance
+    shape: z31.literal("circle"),
+    radius: distance12
   }),
   pcbLayoutProps.extend({
-    shape: import_zod30.z.literal("rect"),
-    width: import_circuit_json19.distance,
-    height: import_circuit_json19.distance
+    shape: z31.literal("rect"),
+    width: distance12,
+    height: distance12
   })
 ]);
-var schematicBoxProps = import_zod30.z.object({
-  schX: import_circuit_json19.distance,
-  schY: import_circuit_json19.distance,
-  width: import_circuit_json19.distance,
-  height: import_circuit_json19.distance
-});
-var schematicTextProps = import_zod30.z.object({
-  schX: import_circuit_json19.distance,
-  schY: import_circuit_json19.distance,
-  text: import_zod30.z.string()
-});
-var schematicLineProps = import_zod30.z.object({
-  x1: import_circuit_json19.distance,
-  y1: import_circuit_json19.distance,
-  x2: import_circuit_json19.distance,
-  y2: import_circuit_json19.distance
-});
-var schematicPathProps = import_zod30.z.object({
-  points: import_zod30.z.array(import_circuit_json19.point),
-  isFilled: import_zod30.z.boolean().optional().default(false),
-  fillColor: import_zod30.z.enum(["red", "blue"]).optional()
+var schematicBoxProps = z31.object({
+  schX: distance12,
+  schY: distance12,
+  width: distance12,
+  height: distance12
+});
+var schematicTextProps = z31.object({
+  schX: distance12,
+  schY: distance12,
+  text: z31.string()
+});
+var schematicLineProps = z31.object({
+  x1: distance12,
+  y1: distance12,
+  x2: distance12,
+  y2: distance12
+});
+var schematicPathProps = z31.object({
+  points: z31.array(point2),
+  isFilled: z31.boolean().optional().default(false),
+  fillColor: z31.enum(["red", "blue"]).optional()
 });
 var componentProps = commonComponentProps;
 var powerSourceProps = commonComponentProps.extend({
-  voltage: import_circuit_json19.voltage
+  voltage
 });
 var portProps = commonLayoutProps.extend({
-  name: import_zod30.z.string(),
-  pinNumber: import_zod30.z.number().optional(),
-  aliases: import_zod30.z.array(import_zod30.z.string()).optional(),
+  name: z31.string(),
+  pinNumber: z31.number().optional(),
+  aliases: z31.array(z31.string()).optional(),
   direction
 });
 var silkscreenTextProps = pcbLayoutProps.extend({
-  text: import_zod30.z.string(),
-  anchorAlignment: import_zod30.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
-  font: import_zod30.z.enum(["tscircuit2024"]).optional(),
-  fontSize: import_circuit_json19.length.optional()
+  text: z31.string(),
+  anchorAlignment: z31.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
+  font: z31.enum(["tscircuit2024"]).optional(),
+  fontSize: length3.optional()
 });
 var silkscreenPathProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotation: true }).extend({
-  route: import_zod30.z.array(import_circuit_json19.route_hint_point),
-  strokeWidth: import_circuit_json19.length.optional()
+  route: z31.array(route_hint_point2),
+  strokeWidth: length3.optional()
 });
 var silkscreenLineProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotation: true }).extend({
-  strokeWidth: import_circuit_json19.distance,
-  x1: import_circuit_json19.distance,
-  y1: import_circuit_json19.distance,
-  x2: import_circuit_json19.distance,
-  y2: import_circuit_json19.distance
+  strokeWidth: distance12,
+  x1: distance12,
+  y1: distance12,
+  x2: distance12,
+  y2: distance12
 });
 var silkscreenRectProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  isFilled: import_zod30.z.boolean().optional(),
-  isOutline: import_zod30.z.boolean().optional(),
-  strokeWidth: import_circuit_json19.distance.optional(),
-  width: import_circuit_json19.distance,
-  height: import_circuit_json19.distance
+  isFilled: z31.boolean().optional(),
+  isOutline: z31.boolean().optional(),
+  strokeWidth: distance12.optional(),
+  width: distance12,
+  height: distance12
 });
 var silkscreenCircleProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  isFilled: import_zod30.z.boolean().optional(),
-  isOutline: import_zod30.z.boolean().optional(),
-  strokeWidth: import_circuit_json19.distance.optional(),
-  radius: import_circuit_json19.distance
-});
-var routeHintPointProps = import_zod30.z.object({
-  x: import_circuit_json19.distance,
-  y: import_circuit_json19.distance,
-  via: import_zod30.z.boolean().optional(),
-  toLayer: import_circuit_json19.layer_ref.optional()
-});
-var traceHintProps = import_zod30.z.object({
-  for: import_zod30.z.string().optional().describe(
+  isFilled: z31.boolean().optional(),
+  isOutline: z31.boolean().optional(),
+  strokeWidth: distance12.optional(),
+  radius: distance12
+});
+var routeHintPointProps = z31.object({
+  x: distance12,
+  y: distance12,
+  via: z31.boolean().optional(),
+  toLayer: layer_ref3.optional()
+});
+var traceHintProps = z31.object({
+  for: z31.string().optional().describe(
     "Selector for the port you're targeting, not required if you're inside a trace"
   ),
-  order: import_zod30.z.number().optional(),
-  offset: import_circuit_json19.route_hint_point.or(routeHintPointProps).optional(),
-  offsets: import_zod30.z.array(import_circuit_json19.route_hint_point).or(import_zod30.z.array(routeHintPointProps)).optional(),
-  traceWidth: import_zod30.z.number().optional()
+  order: z31.number().optional(),
+  offset: route_hint_point2.or(routeHintPointProps).optional(),
+  offsets: z31.array(route_hint_point2).or(z31.array(routeHintPointProps)).optional(),
+  traceWidth: z31.number().optional()
 });
-var pcbTraceProps = import_zod30.z.object({
-  layer: import_zod30.z.string().optional(),
-  thickness: import_circuit_json19.distance.optional(),
-  route: import_zod30.z.array(import_circuit_json19.route_hint_point)
+var pcbTraceProps = z31.object({
+  layer: z31.string().optional(),
+  thickness: distance12.optional(),
+  route: z31.array(route_hint_point2)
 });
 var fabricationNoteTextProps = pcbLayoutProps.extend({
-  text: import_zod30.z.string(),
-  anchorAlignment: import_zod30.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
-  font: import_zod30.z.enum(["tscircuit2024"]).optional(),
-  fontSize: import_circuit_json19.length.optional(),
-  color: import_zod30.z.string().optional()
+  text: z31.string(),
+  anchorAlignment: z31.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
+  font: z31.enum(["tscircuit2024"]).optional(),
+  fontSize: length3.optional(),
+  color: z31.string().optional()
 });
 var fabricationNotePathProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotation: true }).extend({
-  route: import_zod30.z.array(import_circuit_json19.route_hint_point),
-  strokeWidth: import_circuit_json19.length.optional(),
-  color: import_zod30.z.string().optional()
+  route: z31.array(route_hint_point2),
+  strokeWidth: length3.optional(),
+  color: z31.string().optional()
 });
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   autorouterConfig,
   autorouterProp,
   baseGroupProps,
@@ -831,7 +731,7 @@ var fabricationNotePathProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcb
   diodeProps,
   direction,
   directionAlongEdge,
-  distanceOrMultiplier,
+  distanceOrMultiplier2 as distanceOrMultiplier,
   explicitPinSideDefinition,
   fabricationNotePathProps,
   fabricationNoteTextProps,
@@ -894,5 +794,5 @@ var fabricationNotePathProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcb
   traceHintProps,
   traceProps,
   viaProps
-});
+};
 //# sourceMappingURL=index.js.map