jscad-electronics 0.0.200 → 0.0.202

package/dist/vanilla.js

@@ -183,24 +183,24 @@ var FootprintPlatedHole = ({
 import { buttonScrewModelDefinitionSchema } from "@tscircuit/modelprinter";
 
 // lib/model-registry.ts
-function defineModelRenderer(model15) {
-  return model15;
+function defineModelRenderer(model17) {
+  return model17;
 }
 var ModelRendererRegistry = class {
   models = /* @__PURE__ */ new Map();
-  register(model15) {
-    if (typeof model15.name !== "string" || !/^[a-z]+$/.test(model15.name)) {
+  register(model17) {
+    if (typeof model17.name !== "string" || !/^[a-z]+$/.test(model17.name)) {
       throw new Error(
         "Model renderer names must contain only lowercase letters"
       );
     }
-    if (this.models.has(model15.name)) {
-      throw new Error(`Model renderer "${model15.name}" is already registered`);
+    if (this.models.has(model17.name)) {
+      throw new Error(`Model renderer "${model17.name}" is already registered`);
     }
-    if (model15.pads !== "none" && model15.pads !== "footprinter") {
+    if (model17.pads !== "none" && model17.pads !== "footprinter") {
       throw new Error('Model renderer pads must be "none" or "footprinter"');
     }
-    const { name, schema, render: render2, pads } = model15;
+    const { name, schema, render: render2, pads } = model17;
     this.models.set(name, {
       name,
       schema,
@@ -372,6 +372,301 @@ function register(registry) {
   registry.register(model);
 }
 
+// lib/models/cablegrommet/register.tsx
+import { cableGrommetModelDefinitionSchema } from "@tscircuit/modelprinter";
+
+// lib/models/cablegrommet/mesh.ts
+import {
+  cableGrommetModelPropsSchema,
+  getCableGrommetDimensions
+} from "@tscircuit/modelprinter";
+function createCableGrommetMesh(input, options = {}) {
+  const props = cableGrommetModelPropsSchema.parse(input);
+  const dimensions = getCableGrommetDimensions(props);
+  const inner = props.innerDiameter / 2;
+  const root = dimensions.grooveRootDiameter / 2;
+  const outer = props.outerDiameter / 2;
+  const requested = options.radialSegments ?? 96;
+  if (!Number.isInteger(requested) || requested < 12 || requested > 4096 || requested % 4 !== 0)
+    throw new Error(
+      "Grommet radial segments must be a multiple of four in [12,4096]"
+    );
+  const wallAngle = Math.acos((inner + root) / (2 * root));
+  const segments = Math.max(requested, 4 * Math.ceil(Math.PI / wallAngle / 4));
+  if (!Number.isFinite(segments) || segments > 4096)
+    throw new Error(
+      "Grommet wall exceeds mesh resolution limit (4096 segments)"
+    );
+  const section = [
+    [inner, -props.height / 2],
+    [outer, -props.height / 2],
+    [outer, dimensions.grooveStartZ],
+    [root, dimensions.grooveStartZ],
+    [root, dimensions.grooveEndZ],
+    [outer, dimensions.grooveEndZ],
+    [outer, props.height / 2],
+    [inner, props.height / 2]
+  ];
+  const positions = [];
+  const indices = [];
+  for (const [radius, z] of section)
+    for (let sample = 0; sample < segments; sample++) {
+      const angle = sample * 2 * Math.PI / segments;
+      positions.push(radius * Math.cos(angle), radius * Math.sin(angle), z);
+    }
+  for (let ring = 0; ring < section.length; ring++) {
+    const a = ring * segments;
+    const b = (ring + 1) % section.length * segments;
+    for (let sample = 0; sample < segments; sample++) {
+      const next = (sample + 1) % segments;
+      indices.push(
+        a + sample,
+        a + next,
+        b + next,
+        a + sample,
+        b + next,
+        b + sample
+      );
+    }
+  }
+  return { positions, indices };
+}
+
+// lib/models/cablegrommet/CableGrommet.tsx
+function createCableGrommetGeom(input) {
+  return indexedMeshToGeom3(createCableGrommetMesh(input));
+}
+function CableGrommet({
+  color = "#343943",
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createCableGrommetGeom(props) }) });
+}
+
+// lib/models/cablegrommet/register.tsx
+var model2 = defineModelRenderer({
+  name: "cablegrommet",
+  schema: cableGrommetModelDefinitionSchema,
+  render: ({ fn, ...props }) => /* @__PURE__ */ jsx(CableGrommet, { ...props }),
+  pads: "none"
+});
+function register2(registry) {
+  registry.register(model2);
+}
+
+// lib/models/compressionspring/register.tsx
+import { compressionSpringModelDefinitionSchema } from "@tscircuit/modelprinter";
+
+// lib/models/compressionspring/mesh.ts
+import {
+  compressionSpringModelPropsSchema,
+  getCompressionSpringCenterlinePoint,
+  getCompressionSpringDimensions
+} from "@tscircuit/modelprinter";
+
+// lib/mechanical/clip-mesh-to-z-range.ts
+import earcut from "earcut";
+function clipMeshToZRange(mesh, lower, upper) {
+  const originals = [];
+  const tolerance = 32 * Number.EPSILON * (upper - lower);
+  for (let index = 0; index < mesh.positions.length / 3; index++)
+    originals.push({
+      key: `v${index}`,
+      coordinates: [
+        mesh.positions[index * 3],
+        mesh.positions[index * 3 + 1],
+        Math.abs(mesh.positions[index * 3 + 2] - lower) <= tolerance ? lower : Math.abs(mesh.positions[index * 3 + 2] - upper) <= tolerance ? upper : mesh.positions[index * 3 + 2]
+      ]
+    });
+  const intersections = /* @__PURE__ */ new Map();
+  const crossing = (a, b, plane) => {
+    if (a.coordinates[2] === plane) return a;
+    if (b.coordinates[2] === plane) return b;
+    const [first, second] = a.key < b.key ? [a, b] : [b, a];
+    const key = `${plane}:${first.key}:${second.key}`;
+    let point = intersections.get(key);
+    if (!point) {
+      const fraction = (plane - first.coordinates[2]) / (second.coordinates[2] - first.coordinates[2]);
+      point = {
+        key,
+        coordinates: [
+          first.coordinates[0] + fraction * (second.coordinates[0] - first.coordinates[0]),
+          first.coordinates[1] + fraction * (second.coordinates[1] - first.coordinates[1]),
+          plane
+        ]
+      };
+      intersections.set(key, point);
+    }
+    return point;
+  };
+  const clip = (polygon, plane, keepAbove) => {
+    const result = [];
+    const inside = (point) => keepAbove ? point.coordinates[2] >= plane : point.coordinates[2] <= plane;
+    for (let index = 0; index < polygon.length; index++) {
+      const a = polygon[index];
+      const b = polygon[(index + 1) % polygon.length];
+      if (inside(a)) result.push(a);
+      if (inside(a) !== inside(b)) result.push(crossing(a, b, plane));
+    }
+    return result.filter(
+      (point, index) => point.key !== result[(index + result.length - 1) % result.length]?.key
+    );
+  };
+  const positions = [];
+  const indices = [];
+  const pointIndices = /* @__PURE__ */ new Map();
+  const vertex = (point) => {
+    let index = pointIndices.get(point.key);
+    if (index === void 0) {
+      index = positions.length / 3;
+      positions.push(...point.coordinates);
+      pointIndices.set(point.key, index);
+    }
+    return index;
+  };
+  for (let index = 0; index < mesh.indices.length; index += 3) {
+    const triangle = mesh.indices.slice(index, index + 3).map((i) => originals[i]);
+    const polygon = clip(clip(triangle, lower, true), upper, false);
+    for (let corner = 1; corner + 1 < polygon.length; corner++) {
+      const points = [polygon[0], polygon[corner], polygon[corner + 1]];
+      if (new Set(points.map((point) => point.key)).size === 3)
+        indices.push(...points.map(vertex));
+    }
+  }
+  const edges = /* @__PURE__ */ new Map();
+  for (let index = 0; index < indices.length; index += 3)
+    for (let side = 0; side < 3; side++) {
+      const from = indices[index + side];
+      const to = indices[index + (side + 1) % 3];
+      const key = `${Math.min(from, to)},${Math.max(from, to)}`;
+      const prior = edges.get(key);
+      if (prior) prior.count++;
+      else edges.set(key, { from, to, count: 1 });
+    }
+  const boundary = [...edges.values()].filter((edge) => edge.count === 1);
+  const outgoing = new Map(boundary.map(({ from, to }) => [from, to]));
+  if (outgoing.size !== boundary.length)
+    throw new Error("Ground clipping produced an ambiguous boundary");
+  while (outgoing.size > 0) {
+    const start = outgoing.keys().next().value;
+    const loop = [];
+    let current = start;
+    do {
+      loop.push(current);
+      const next = outgoing.get(current);
+      if (next === void 0)
+        throw new Error("Ground clipping produced an open boundary");
+      outgoing.delete(current);
+      current = next;
+    } while (current !== start);
+    const plane = positions[3 * start + 2];
+    if (plane !== lower && plane !== upper || loop.some((i) => positions[3 * i + 2] !== plane))
+      throw new Error("Ground clipping boundary must lie on an end plane");
+    const coordinates = loop.flatMap((i) => [
+      positions[3 * i],
+      positions[3 * i + 1]
+    ]);
+    const cap = earcut(coordinates);
+    for (let index = 0; index < cap.length; index += 3) {
+      const a = loop[cap[index]];
+      let b = loop[cap[index + 1]];
+      let c = loop[cap[index + 2]];
+      const cross = (positions[b * 3] - positions[a * 3]) * (positions[c * 3 + 1] - positions[a * 3 + 1]) - (positions[b * 3 + 1] - positions[a * 3 + 1]) * (positions[c * 3] - positions[a * 3]);
+      if (plane === lower && cross > 0 || plane === upper && cross < 0)
+        [b, c] = [c, b];
+      indices.push(a, b, c);
+    }
+  }
+  return { positions, indices };
+}
+
+// lib/models/compressionspring/mesh.ts
+function createCompressionSpringMesh(input, options = {}) {
+  const props = compressionSpringModelPropsSchema.parse(input);
+  const dimensions = getCompressionSpringDimensions(props);
+  const segmentsPerTurn = options.segmentsPerTurn ?? 64;
+  const wireSegments = options.wireSegments ?? 24;
+  for (const [name, value, minimum, maximum] of [
+    ["segmentsPerTurn", segmentsPerTurn, 16, 256],
+    ["wireSegments", wireSegments, 8, 64]
+  ])
+    if (!Number.isInteger(value) || value < minimum || value > maximum || value % 4 !== 0)
+      throw new Error(
+        `${name} must be a multiple of four in [${minimum},${maximum}]`
+      );
+  const steps = props.totalTurns * segmentsPerTurn;
+  if (!Number.isSafeInteger(steps) || (steps + 1) * wireSegments > 25e4)
+    throw new Error("Spring exceeds mesh resolution limit (250000 vertices)");
+  const scale = Math.max(props.outerDiameter, props.freeLength);
+  if (dimensions.activePitch - props.wireDiameter <= scale * 1e-10 || props.wireDiameter <= scale * 1e-10 || dimensions.insideDiameter <= scale * 1e-10)
+    throw new Error("Spring clearance exceeds mesh resolution limit");
+  const positions = [];
+  const indices = [];
+  const wireRadius = props.wireDiameter / 2;
+  for (let step = 0; step <= steps; step++) {
+    const center = getCompressionSpringCenterlinePoint(
+      props,
+      step / segmentsPerTurn
+    );
+    const meanRadius = Math.hypot(center.x, center.y);
+    for (let sample = 0; sample < wireSegments; sample++) {
+      const angle = sample * 2 * Math.PI / wireSegments;
+      const cosine = sample === wireSegments / 4 || sample === 3 * wireSegments / 4 ? 0 : Math.cos(angle);
+      const sine = sample === 0 || sample === wireSegments / 2 ? 0 : Math.sin(angle);
+      const radialOffset = wireRadius * cosine;
+      positions.push(
+        center.x + radialOffset * center.x / meanRadius,
+        center.y + radialOffset * center.y / meanRadius,
+        center.z + wireRadius * sine
+      );
+    }
+  }
+  const triangle = (a, b, c) => {
+    if (props.hand === "left") indices.push(a, c, b);
+    else indices.push(a, b, c);
+  };
+  for (let step = 0; step < steps; step++)
+    for (let sample = 0; sample < wireSegments; sample++) {
+      const next = (sample + 1) % wireSegments;
+      const a = step * wireSegments;
+      const b = (step + 1) * wireSegments;
+      triangle(a + sample, b + sample, b + next);
+      triangle(a + sample, b + next, a + next);
+    }
+  for (let corner = 1; corner + 1 < wireSegments; corner++) {
+    triangle(0, corner, corner + 1);
+    const end = steps * wireSegments;
+    triangle(end, end + corner + 1, end + corner);
+  }
+  return clipMeshToZRange(
+    { positions, indices },
+    dimensions.lowerBearingZ,
+    dimensions.upperBearingZ
+  );
+}
+
+// lib/models/compressionspring/CompressionSpring.tsx
+function createCompressionSpringGeom(input) {
+  return indexedMeshToGeom3(createCompressionSpringMesh(input));
+}
+function CompressionSpring({
+  color = "#737e8f",
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(Colorize, { color, children: /* @__PURE__ */ jsx(Custom, { geometry: createCompressionSpringGeom(props) }) });
+}
+
+// lib/models/compressionspring/register.tsx
+var model3 = defineModelRenderer({
+  name: "compressionspring",
+  schema: compressionSpringModelDefinitionSchema,
+  render: ({ fn, ...props }) => /* @__PURE__ */ jsx(CompressionSpring, { ...props }),
+  pads: "none"
+});
+function register3(registry) {
+  registry.register(model3);
+}
+
 // lib/models/flangedbushing/register.tsx
 import { flangedBushingModelDefinitionSchema } from "@tscircuit/modelprinter";
 
@@ -425,14 +720,14 @@ function FlangedBushing({
 }
 
 // lib/models/flangedbushing/register.tsx
-var model2 = defineModelRenderer({
+var model4 = defineModelRenderer({
   name: "flangedbushing",
   schema: flangedBushingModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(FlangedBushing, { ...props }),
   pads: "none"
 });
-function register2(registry) {
-  registry.register(model2);
+function register4(registry) {
+  registry.register(model4);
 }
 
 // lib/models/flatheadscrew/register.tsx
@@ -565,14 +860,14 @@ function FlatHeadScrew({
 }
 
 // lib/models/flatheadscrew/register.tsx
-var model3 = defineModelRenderer({
+var model5 = defineModelRenderer({
   name: "flatheadscrew",
   schema: flatHeadScrewModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(FlatHeadScrew, { ...props }),
   pads: "none"
 });
-function register3(registry) {
-  registry.register(model3);
+function register5(registry) {
+  registry.register(model5);
 }
 
 // lib/models/flexscreen/register.tsx
@@ -1250,14 +1545,14 @@ var FlexScreen = (props) => {
 };
 
 // lib/models/flexscreen/register.tsx
-var model4 = defineModelRenderer({
+var model6 = defineModelRenderer({
   name: "flexscreen",
   schema: flexScreenModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(FlexScreen, { ...props }),
   pads: "footprinter"
 });
-function register4(registry) {
-  registry.register(model4);
+function register6(registry) {
+  registry.register(model6);
 }
 
 // lib/models/helicalgear/register.tsx
@@ -1274,7 +1569,7 @@ import {
   getSpurGearDimensions,
   spurGearModelPropsSchema
 } from "@tscircuit/modelprinter";
-import earcut from "earcut";
+import earcut2 from "earcut";
 function createSpurGearMesh(input) {
   return createTwistedSpurGearMesh(input);
 }
@@ -1380,7 +1675,7 @@ function createTwistedSpurGearMesh(input, twist = 0, segmentsPerTurn = 32) {
   };
   const cap = (outer, outerStart, upward, inner) => {
     const points = inner ? [...outer, ...inner.points] : outer;
-    const triangles = earcut(
+    const triangles = earcut2(
       points.flatMap(([x, y]) => [x, y]),
       inner ? [outer.length] : []
     );
@@ -1463,14 +1758,14 @@ function HelicalGear({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/helicalgear/register.tsx
-var model5 = defineModelRenderer({
+var model7 = defineModelRenderer({
   name: "helicalgear",
   schema: helicalGearModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HelicalGear, { ...props }),
   pads: "none"
 });
-function register5(registry) {
-  registry.register(model5);
+function register7(registry) {
+  registry.register(model7);
 }
 
 // lib/models/hexbolt/register.tsx
@@ -1611,14 +1906,14 @@ function HexBolt({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/hexbolt/register.tsx
-var model6 = defineModelRenderer({
+var model8 = defineModelRenderer({
   name: "hexbolt",
   schema: hexBoltModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HexBolt, { ...props }),
   pads: "none"
 });
-function register6(registry) {
-  registry.register(model6);
+function register8(registry) {
+  registry.register(model8);
 }
 
 // lib/models/hexnut/register.tsx
@@ -1741,14 +2036,14 @@ function HexNut({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/hexnut/register.tsx
-var model7 = defineModelRenderer({
+var model9 = defineModelRenderer({
   name: "hexnut",
   schema: hexNutModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HexNut, { ...props }),
   pads: "none"
 });
-function register7(registry) {
-  registry.register(model7);
+function register9(registry) {
+  registry.register(model9);
 }
 
 // lib/models/hexsocketbolt/register.tsx
@@ -1860,14 +2155,14 @@ function HexSocketBolt({
 }
 
 // lib/models/hexsocketbolt/register.tsx
-var model8 = defineModelRenderer({
+var model10 = defineModelRenderer({
   name: "hexsocketbolt",
   schema: hexSocketBoltModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(HexSocketBolt, { ...props }),
   pads: "none"
 });
-function register8(registry) {
-  registry.register(model8);
+function register10(registry) {
+  registry.register(model10);
 }
 
 // lib/models/nema/register.tsx
@@ -2136,14 +2431,14 @@ var NEMA17 = (props) => /* @__PURE__ */ jsx(NemaMotor, { ...props, nemaSize: 17
 var NEMA23 = (props) => /* @__PURE__ */ jsx(NemaMotor, { ...props, nemaSize: 23 });
 
 // lib/models/nema/register.tsx
-var model9 = defineModelRenderer({
+var model11 = defineModelRenderer({
   name: "nema",
   schema: nemaMotorModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(NemaMotor, { ...props }),
   pads: "none"
 });
-function register9(registry) {
-  registry.register(model9);
+function register11(registry) {
+  registry.register(model11);
 }
 
 // lib/models/panscrew/register.tsx
@@ -2355,14 +2650,14 @@ function PanScrew({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/panscrew/register.tsx
-var model10 = defineModelRenderer({
+var model12 = defineModelRenderer({
   name: "panscrew",
   schema: panScrewModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(PanScrew, { ...props }),
   pads: "none"
 });
-function register10(registry) {
-  registry.register(model10);
+function register12(registry) {
+  registry.register(model12);
 }
 
 // lib/models/plainbushing/register.tsx
@@ -2425,21 +2720,21 @@ function PlainBushing({
 }
 
 // lib/models/plainbushing/register.tsx
-var model11 = defineModelRenderer({
+var model13 = defineModelRenderer({
   name: "plainbushing",
   schema: plainBushingModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(PlainBushing, { ...props }),
   pads: "none"
 });
-function register11(registry) {
-  registry.register(model11);
+function register13(registry) {
+  registry.register(model13);
 }
 
 // lib/models/sheetmetal/register.tsx
 import { sheetMetalModelDefinitionSchema } from "@tscircuit/modelprinter";
 
 // lib/mechanical/sheet-metal-mesh.ts
-import earcut2 from "earcut";
+import earcut3 from "earcut";
 import {
   sheetMetalModelPropsSchema
 } from "@tscircuit/modelprinter";
@@ -2507,7 +2802,7 @@ function createSheetMetalMesh(input) {
     const loops = [outline, ...holes.map((hole) => [...hole].reverse())];
     const points = loops.flat();
     const starts = holes.map((_, i) => 4 + i * 64);
-    const triangles = earcut2(
+    const triangles = earcut3(
       points.flatMap((p) => [p.u, p.v]),
       starts
     );
@@ -2592,14 +2887,14 @@ function SheetMetal({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/sheetmetal/register.tsx
-var model12 = defineModelRenderer({
+var model14 = defineModelRenderer({
   name: "sheetmetal",
   schema: sheetMetalModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(SheetMetal, { ...props }),
   pads: "none"
 });
-function register12(registry) {
-  registry.register(model12);
+function register14(registry) {
+  registry.register(model14);
 }
 
 // lib/models/spurgear/register.tsx
@@ -2614,14 +2909,14 @@ function SpurGear({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/spurgear/register.tsx
-var model13 = defineModelRenderer({
+var model15 = defineModelRenderer({
   name: "spurgear",
   schema: spurGearModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(SpurGear, { ...props }),
   pads: "none"
 });
-function register13(registry) {
-  registry.register(model13);
+function register15(registry) {
+  registry.register(model15);
 }
 
 // lib/models/wormgear/register.tsx
@@ -2632,7 +2927,7 @@ import {
   getWormGearDimensions,
   wormGearModelPropsSchema
 } from "@tscircuit/modelprinter";
-import earcut3 from "earcut";
+import earcut4 from "earcut";
 var createWormGearMesh = (input) => {
   const props = wormGearModelPropsSchema.parse(input);
   const { outsideDiameter, rootDiameter, axialPitch, lead, toothThickness } = getWormGearDimensions(props);
@@ -2785,7 +3080,7 @@ var createWormGearMesh = (input) => {
         positions[vertex * 3],
         positions[vertex * 3 + 1]
       ]);
-      const triangles = earcut3(flat, [count], 2);
+      const triangles = earcut4(flat, [count], 2);
       for (let index = 0; index < triangles.length; index += 3) {
         const a = vertices[triangles[index]];
         const b = vertices[triangles[index + 1]];
@@ -2813,14 +3108,14 @@ function WormGear({ color = "#737e8f", ...props }) {
 }
 
 // lib/models/wormgear/register.tsx
-var model14 = defineModelRenderer({
+var model16 = defineModelRenderer({
   name: "wormgear",
   schema: wormGearModelDefinitionSchema,
   render: ({ fn, ...props }) => /* @__PURE__ */ jsx(WormGear, { ...props }),
   pads: "none"
 });
-function register14(registry) {
-  registry.register(model14);
+function register16(registry) {
+  registry.register(model16);
 }
 
 // lib/generated/model-renderers.ts
@@ -2839,6 +3134,8 @@ function registerAllModelRenderers(registry) {
   register12(registry);
   register13(registry);
   register14(registry);
+  register15(registry);
+  register16(registry);
 }
 
 // lib/default-model-registry.ts
@@ -10395,10 +10692,10 @@ var SOT143 = ({ footprint = "sot143" }) => {
 var Footprinter3d = ({ footprint }) => {
   const modelFn = mp3.string(footprint.split("_", 1)[0]).params().fn;
   if (mp3.getModelNames().includes(modelFn)) {
-    const model15 = mp3.string(footprint).json();
-    const renderer = modelRendererRegistry.get(model15.fn);
+    const model17 = mp3.string(footprint).json();
+    const renderer = modelRendererRegistry.get(model17.fn);
     if (renderer) {
-      return renderer.render(model15);
+      return renderer.render(model17);
     }
   }
   let normalizedFootprint = footprint;
@@ -11350,6 +11647,8 @@ function createJSCADRenderer(jscad4) {
 }
 export {
   ButtonScrew,
+  CableGrommet,
+  CompressionSpring,
   FlangedBushing,
   FlatHeadScrew,
   Fragment,
@@ -11369,6 +11668,10 @@ export {
   convertCSGToThreeGeom,
   createButtonScrewGeom,
   createButtonScrewMesh,
+  createCableGrommetGeom,
+  createCableGrommetMesh,
+  createCompressionSpringGeom,
+  createCompressionSpringMesh,
   createFlangedBushingGeom,
   createFlangedBushingMesh,
   createFlatHeadScrewGeom,