@tscircuit/3d-viewer 0.0.476 → 0.0.477

package/dist/index.js

@@ -805,13 +805,13 @@ var require_cross = __commonJS({
 var require_distance = __commonJS({
   "node_modules/@jscad/modeling/src/maths/vec3/distance.js"(exports, module) {
     "use strict";
-    var distance2 = (a, b) => {
+    var distance3 = (a, b) => {
       const x = b[0] - a[0];
       const y = b[1] - a[1];
       const z138 = b[2] - a[2];
       return Math.sqrt(x * x + y * y + z138 * z138);
     };
-    module.exports = distance2;
+    module.exports = distance3;
   }
 });
 
@@ -1933,12 +1933,12 @@ var require_cross2 = __commonJS({
 var require_distance2 = __commonJS({
   "node_modules/@jscad/modeling/src/maths/vec2/distance.js"(exports, module) {
     "use strict";
-    var distance2 = (a, b) => {
+    var distance3 = (a, b) => {
       const x = b[0] - a[0];
       const y = b[1] - a[1];
       return Math.sqrt(x * x + y * y);
     };
-    module.exports = distance2;
+    module.exports = distance3;
   }
 });
 
@@ -2861,7 +2861,7 @@ var require_Vertex = __commonJS({
 var require_HalfEdge = __commonJS({
   "node_modules/@jscad/modeling/src/operations/hulls/quickhull/HalfEdge.js"(exports, module) {
     "use strict";
-    var distance2 = require_distance();
+    var distance3 = require_distance();
     var squaredDistance = require_squaredDistance();
     var HalfEdge = class {
       constructor(vertex, face) {
@@ -2879,7 +2879,7 @@ var require_HalfEdge = __commonJS({
       }
       length() {
         if (this.tail()) {
-          return distance2(
+          return distance3(
             this.tail().point,
             this.head().point
           );
@@ -3216,8 +3216,8 @@ var require_QuickHull = __commonJS({
             let nextVertex;
             for (let vertex = faceVertices; vertex; vertex = nextVertex) {
               nextVertex = vertex.next;
-              const distance2 = absorbingFace.distanceToPlane(vertex.point);
-              if (distance2 > this.tolerance) {
+              const distance3 = absorbingFace.distanceToPlane(vertex.point);
+              if (distance3 > this.tolerance) {
                 this.addVertexToFace(vertex, absorbingFace);
               } else {
                 this.unclaimed.add(vertex);
@@ -3304,9 +3304,9 @@ var require_QuickHull = __commonJS({
         let maxDistance = 0;
         let indexMax = 0;
         for (i = 0; i < 3; i += 1) {
-          const distance2 = max2[i].point[i] - min2[i].point[i];
-          if (distance2 > maxDistance) {
-            maxDistance = distance2;
+          const distance3 = max2[i].point[i] - min2[i].point[i];
+          if (distance3 > maxDistance) {
+            maxDistance = distance3;
             indexMax = i;
           }
         }
@@ -3316,13 +3316,13 @@ var require_QuickHull = __commonJS({
         for (i = 0; i < this.vertices.length; i += 1) {
           const vertex = this.vertices[i];
           if (vertex !== v0 && vertex !== v1) {
-            const distance2 = pointLineDistance(
+            const distance3 = pointLineDistance(
               vertex.point,
               v0.point,
               v1.point
             );
-            if (distance2 > maxDistance) {
-              maxDistance = distance2;
+            if (distance3 > maxDistance) {
+              maxDistance = distance3;
               v2 = vertex;
             }
           }
@@ -3333,9 +3333,9 @@ var require_QuickHull = __commonJS({
         for (i = 0; i < this.vertices.length; i += 1) {
           const vertex = this.vertices[i];
           if (vertex !== v0 && vertex !== v1 && vertex !== v2) {
-            const distance2 = Math.abs(dot(normal, vertex.point) - distPO);
-            if (distance2 > maxDistance) {
-              maxDistance = distance2;
+            const distance3 = Math.abs(dot(normal, vertex.point) - distPO);
+            if (distance3 > maxDistance) {
+              maxDistance = distance3;
               v3 = vertex;
             }
           }
@@ -3375,9 +3375,9 @@ var require_QuickHull = __commonJS({
             maxDistance = this.tolerance;
             let maxFace;
             for (j = 0; j < 4; j += 1) {
-              const distance2 = faces[j].distanceToPlane(vertex.point);
-              if (distance2 > maxDistance) {
-                maxDistance = distance2;
+              const distance3 = faces[j].distanceToPlane(vertex.point);
+              if (distance3 > maxDistance) {
+                maxDistance = distance3;
                 maxFace = faces[j];
               }
             }
@@ -3433,9 +3433,9 @@ var require_QuickHull = __commonJS({
           let maxDistance = 0;
           const eyeFace = this.claimed.first().face;
           for (vertex = eyeFace.outside; vertex && vertex.face === eyeFace; vertex = vertex.next) {
-            const distance2 = eyeFace.distanceToPlane(vertex.point);
-            if (distance2 > maxDistance) {
-              maxDistance = distance2;
+            const distance3 = eyeFace.distanceToPlane(vertex.point);
+            if (distance3 > maxDistance) {
+              maxDistance = distance3;
               eyeVertex = vertex;
             }
           }
@@ -6069,13 +6069,13 @@ var require_arcLengthToT = __commonJS({
         distance: 0,
         segments: 100
       };
-      const { distance: distance2, segments } = Object.assign({}, defaults, options);
+      const { distance: distance3, segments } = Object.assign({}, defaults, options);
       const arcLengths = lengths(segments, bezier);
       let startIndex = 0;
       let endIndex = segments;
       while (startIndex <= endIndex) {
         const middleIndex = Math.floor(startIndex + (endIndex - startIndex) / 2);
-        const diff = arcLengths[middleIndex] - distance2;
+        const diff = arcLengths[middleIndex] - distance3;
         if (diff < 0) {
           startIndex = middleIndex + 1;
         } else if (diff > 0) {
@@ -6086,13 +6086,13 @@ var require_arcLengthToT = __commonJS({
         }
       }
       const targetIndex = endIndex;
-      if (arcLengths[targetIndex] === distance2) {
+      if (arcLengths[targetIndex] === distance3) {
         return targetIndex / segments;
       }
       const lengthBefore = arcLengths[targetIndex];
       const lengthAfter = arcLengths[targetIndex + 1];
       const segmentLength = lengthAfter - lengthBefore;
-      const segmentFraction = (distance2 - lengthBefore) / segmentLength;
+      const segmentFraction = (distance3 - lengthBefore) / segmentLength;
       return (targetIndex + segmentFraction) / segments;
     };
     module.exports = arcLengthToT;
@@ -6342,9 +6342,9 @@ var require_distanceToPoint = __commonJS({
     "use strict";
     var vec2 = require_vec2();
     var distanceToPoint = (line2, point2) => {
-      let distance2 = vec2.dot(point2, line2);
-      distance2 = Math.abs(distance2 - line2[2]);
-      return distance2;
+      let distance3 = vec2.dot(point2, line2);
+      distance3 = Math.abs(distance3 - line2[2]);
+      return distance3;
     };
     module.exports = distanceToPoint;
   }
@@ -6368,10 +6368,10 @@ var require_fromPoints6 = __commonJS({
       const vector = vec2.subtract(vec2.create(), point2, point1);
       vec2.normal(vector, vector);
       vec2.normalize(vector, vector);
-      const distance2 = vec2.dot(point1, vector);
+      const distance3 = vec2.dot(point1, vector);
       out[0] = vector[0];
       out[1] = vector[1];
-      out[2] = distance2;
+      out[2] = distance3;
       return out;
     };
     module.exports = fromPoints;
@@ -6513,8 +6513,8 @@ var require_reverse3 = __commonJS({
     var fromValues = require_fromValues5();
     var reverse = (out, line2) => {
       const normal = vec2.negate(vec2.create(), line2);
-      const distance2 = -line2[2];
-      return copy(out, fromValues(normal[0], normal[1], distance2));
+      const distance3 = -line2[2];
+      return copy(out, fromValues(normal[0], normal[1], distance3));
     };
     module.exports = reverse;
   }
@@ -7862,7 +7862,7 @@ var require_polyhedron = __commonJS({
         colors: void 0,
         orientation: "outward"
       };
-      const { points, faces, colors: colors2, orientation } = Object.assign({}, defaults, options);
+      const { points, faces, colors: colors2, orientation: orientation2 } = Object.assign({}, defaults, options);
       if (!(Array.isArray(points) && Array.isArray(faces))) {
         throw new Error("points and faces must be arrays");
       }
@@ -7887,7 +7887,7 @@ var require_polyhedron = __commonJS({
         if (face.length < 3) throw new Error(`face ${i} must contain 3 or more indexes`);
         if (!isNumberArray(face, face.length)) throw new Error(`face ${i} must be an array of numbers`);
       });
-      if (orientation !== "outward") {
+      if (orientation2 !== "outward") {
         faces.forEach((face) => face.reverse());
       }
       const polygons = faces.map((face, findex) => {
@@ -8052,7 +8052,7 @@ var require_polygon = __commonJS({
         paths: [],
         orientation: "counterclockwise"
       };
-      const { points, paths, orientation } = Object.assign({}, defaults, options);
+      const { points, paths, orientation: orientation2 } = Object.assign({}, defaults, options);
       if (!(Array.isArray(points) && Array.isArray(paths))) throw new Error("points and paths must be arrays");
       let listofpolys = points;
       if (Array.isArray(points[0])) {
@@ -8082,7 +8082,7 @@ var require_polygon = __commonJS({
         sides2 = sides2.concat(geom2.toSides(geometry2));
       });
       let geometry = geom2.create(sides2);
-      if (orientation === "clockwise") {
+      if (orientation2 === "clockwise") {
         geometry = geom2.reverse(geometry);
       }
       return geometry;
@@ -8597,16 +8597,16 @@ var require_calculatePlane = __commonJS({
     var calculatePlane = (slice) => {
       const edges = slice.edges;
       if (edges.length < 3) throw new Error("slices must have 3 or more edges to calculate a plane");
-      const midpoint = edges.reduce((point2, edge) => vec3.add(vec3.create(), point2, edge[0]), vec3.create());
-      vec3.scale(midpoint, midpoint, 1 / edges.length);
+      const midpoint2 = edges.reduce((point2, edge) => vec3.add(vec3.create(), point2, edge[0]), vec3.create());
+      vec3.scale(midpoint2, midpoint2, 1 / edges.length);
       let farthestEdge;
-      let distance2 = 0;
+      let distance3 = 0;
       edges.forEach((edge) => {
         if (!vec3.equals(edge[0], edge[1])) {
-          const d = vec3.squaredDistance(midpoint, edge[0]);
-          if (d > distance2) {
+          const d = vec3.squaredDistance(midpoint2, edge[0]);
+          if (d > distance3) {
             farthestEdge = edge;
-            distance2 = d;
+            distance3 = d;
           }
         }
       });
@@ -8969,13 +8969,13 @@ var require_linkedPolygon = __commonJS({
       const o3 = Math.sign(area(p2, q2, p1));
       const o4 = Math.sign(area(p2, q2, q1));
       if (o1 !== o2 && o3 !== o4) return true;
-      if (o1 === 0 && onSegment(p1, p2, q1)) return true;
-      if (o2 === 0 && onSegment(p1, q2, q1)) return true;
-      if (o3 === 0 && onSegment(p2, p1, q2)) return true;
-      if (o4 === 0 && onSegment(p2, q1, q2)) return true;
+      if (o1 === 0 && onSegment2(p1, p2, q1)) return true;
+      if (o2 === 0 && onSegment2(p1, q2, q1)) return true;
+      if (o3 === 0 && onSegment2(p2, p1, q2)) return true;
+      if (o4 === 0 && onSegment2(p2, q1, q2)) return true;
       return false;
     };
-    var onSegment = (p, q, r) => q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
+    var onSegment2 = (p, q, r) => q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
     var signedArea = (data, start, end, dim) => {
       let sum = 0;
       for (let i = start, j = end - dim; i < end; i += dim) {
@@ -9454,9 +9454,9 @@ var require_repair = __commonJS({
         let bestReplacement;
         missingOut.forEach((key2) => {
           const v2 = vertexMap.get(key2);
-          const distance2 = vec3.distance(v1, v2);
-          if (distance2 < bestDistance) {
-            bestDistance = distance2;
+          const distance3 = vec3.distance(v1, v2);
+          if (distance3 < bestDistance) {
+            bestDistance = distance3;
             bestReplacement = v2;
           }
         });
@@ -11802,7 +11802,7 @@ var require_offsetFromPoints = __commonJS({
       if (Math.abs(delta) < EPS) return points;
       let rotation2 = options.closed ? area(points) : 1;
       if (rotation2 === 0) rotation2 = 1;
-      const orientation = rotation2 > 0 && delta >= 0 || rotation2 < 0 && delta < 0;
+      const orientation2 = rotation2 > 0 && delta >= 0 || rotation2 < 0 && delta < 0;
       delta = Math.abs(delta);
       let previousSegment = null;
       let newPoints = [];
@@ -11813,7 +11813,7 @@ var require_offsetFromPoints = __commonJS({
         const j = (i + 1) % n;
         const p0 = points[i];
         const p1 = points[j];
-        orientation ? vec2.subtract(of, p0, p1) : vec2.subtract(of, p1, p0);
+        orientation2 ? vec2.subtract(of, p0, p1) : vec2.subtract(of, p1, p0);
         vec2.normal(of, of);
         vec2.normalize(of, of);
         vec2.scale(of, of, delta);
@@ -11877,11 +11877,11 @@ var require_offsetFromPoints = __commonJS({
         newCorners.forEach((corner) => {
           let rotation3 = vec2.angle(vec2.subtract(v0, corner.s1[0], corner.c));
           rotation3 -= vec2.angle(vec2.subtract(v0, corner.s0[1], corner.c));
-          if (orientation && rotation3 < 0) {
+          if (orientation2 && rotation3 < 0) {
             rotation3 = rotation3 + Math.PI;
             if (rotation3 < 0) rotation3 = rotation3 + Math.PI;
           }
-          if (!orientation && rotation3 > 0) {
+          if (!orientation2 && rotation3 > 0) {
             rotation3 = rotation3 - Math.PI;
             if (rotation3 > 0) rotation3 = rotation3 - Math.PI;
           }
@@ -12718,8 +12718,8 @@ var require_hullPoints2 = __commonJS({
       const points = [];
       uniquePoints.forEach((point2) => {
         const angle = fakeAtan2(point2[1] - min2[1], point2[0] - min2[0]);
-        const distSq = vec2.squaredDistance(point2, min2);
-        points.push({ point: point2, angle, distSq });
+        const distSq2 = vec2.squaredDistance(point2, min2);
+        points.push({ point: point2, angle, distSq: distSq2 });
       });
       points.sort((pt1, pt2) => pt1.angle !== pt2.angle ? pt1.angle - pt2.angle : pt1.distSq - pt2.distSq);
       const stack = [];
@@ -13361,11 +13361,11 @@ var require_triangulatePolygons = __commonJS({
       const nv = polygon3.vertices.length;
       if (nv > 3) {
         if (nv > 4) {
-          const midpoint = [0, 0, 0];
-          polygon3.vertices.forEach((vertice) => vec3.add(midpoint, midpoint, vertice));
-          vec3.snap(midpoint, vec3.divide(midpoint, midpoint, [nv, nv, nv]), epsilon);
+          const midpoint2 = [0, 0, 0];
+          polygon3.vertices.forEach((vertice) => vec3.add(midpoint2, midpoint2, vertice));
+          vec3.snap(midpoint2, vec3.divide(midpoint2, midpoint2, [nv, nv, nv]), epsilon);
           for (let i = 0; i < nv; i++) {
-            const poly = poly3.create([midpoint, polygon3.vertices[i], polygon3.vertices[(i + 1) % nv]]);
+            const poly = poly3.create([midpoint2, polygon3.vertices[i], polygon3.vertices[(i + 1) % nv]]);
             if (polygon3.color) poly.color = polygon3.color;
             triangles.push(poly);
           }
@@ -18225,12 +18225,12 @@ var bga_def = z510.object({
 });
 var bga = (raw_params) => {
   const parameters = bga_def.parse(raw_params);
-  let { num_pins, grid, p, w, h: h2, ball, pad: pad2, missing } = parameters;
+  let { num_pins, grid: grid2, p, w, h: h2, ball, pad: pad2, missing } = parameters;
   ball ??= 0.75 / 1.27 * p;
   pad2 ??= ball * 0.8;
   const pads = [];
   const missing_pin_nums = (missing ?? []).filter((a) => typeof a === "number");
-  const num_pins_missing = grid.x * grid.y - num_pins;
+  const num_pins_missing = grid2.x * grid2.y - num_pins;
   if (missing.length === 0 && num_pins_missing > 0) {
     if (Math.sqrt(num_pins_missing) % 1 === 0) {
       missing.push("center");
@@ -18240,11 +18240,11 @@ var bga = (raw_params) => {
   }
   if (missing?.includes("center")) {
     const square_size = Math.floor(Math.sqrt(num_pins_missing));
-    const inner_square_x = Math.floor((grid.x - square_size) / 2);
-    const inner_square_y = Math.floor((grid.y - square_size) / 2);
+    const inner_square_x = Math.floor((grid2.x - square_size) / 2);
+    const inner_square_y = Math.floor((grid2.y - square_size) / 2);
     for (let y = inner_square_y; y < inner_square_y + square_size; y++) {
       for (let x = inner_square_x; x < inner_square_x + square_size; x++) {
-        missing_pin_nums.push(y * grid.x + x + 1);
+        missing_pin_nums.push(y * grid2.x + x + 1);
       }
     }
   }
@@ -18253,30 +18253,30 @@ var bga = (raw_params) => {
   }
   const missing_pin_nums_set = new Set(missing_pin_nums);
   let missing_pins_passed = 0;
-  for (let y = 0; y < grid.y; y++) {
-    for (let x = 0; x < grid.x; x++) {
-      const pad_x = (x - (grid.x - 1) / 2) * p;
-      const pad_y = (y - (grid.y - 1) / 2) * p;
+  for (let y = 0; y < grid2.y; y++) {
+    for (let x = 0; x < grid2.x; x++) {
+      const pad_x = (x - (grid2.x - 1) / 2) * p;
+      const pad_y = (y - (grid2.y - 1) / 2) * p;
       let pin_x = x;
       let pin_y = y;
       switch (parameters.origin) {
         case "bl":
           pin_x = x;
-          pin_y = grid.y - 1 - y;
+          pin_y = grid2.y - 1 - y;
           break;
         case "br":
-          pin_x = grid.x - 1 - x;
-          pin_y = grid.y - 1 - y;
+          pin_x = grid2.x - 1 - x;
+          pin_y = grid2.y - 1 - y;
           break;
         case "tr":
-          pin_x = grid.x - 1 - x;
+          pin_x = grid2.x - 1 - x;
           pin_y = y;
           break;
         case "tl":
         default:
           break;
       }
-      let pin_num = pin_y * grid.x + pin_x + 1;
+      let pin_num = pin_y * grid2.x + pin_x + 1;
       if (missing_pin_nums_set.has(pin_num)) {
         missing_pins_passed++;
         continue;
@@ -18294,13 +18294,13 @@ var bga = (raw_params) => {
   }
   const silkscreenRefText = silkscreenRef(
     0,
-    grid.y * p / 2,
+    grid2.y * p / 2,
     0.2
   );
   const pin1MarkerSize = p / 6;
   let markerRoute;
-  const edgeX = grid.x * p / 2;
-  const edgeY = grid.y * p / 2;
+  const edgeX = grid2.x * p / 2;
+  const edgeY = grid2.y * p / 2;
   switch (parameters.origin) {
     case "bl":
       markerRoute = [
@@ -18614,7 +18614,7 @@ var quad = (raw_params) => {
     const {
       x,
       y,
-      o: orientation
+      o: orientation2
     } = getQuadCoords({
       pin_count: parameters.num_pins,
       pn: i + 1,
@@ -18626,7 +18626,7 @@ var quad = (raw_params) => {
     });
     let pw = parameters.pw;
     let pl = parameters.pl;
-    if (orientation === "vert") {
+    if (orientation2 === "vert") {
       ;
       [pw, pl] = [pl, pw];
     }
@@ -25622,7 +25622,7 @@ var QFN = ({
     const {
       x,
       y,
-      o: orientation
+      o: orientation2
     } = getQuadCoords2({
       pin_count: num_pins,
       pn: i + 1,
@@ -25634,7 +25634,7 @@ var QFN = ({
     });
     let pw = padWidth;
     let pl = padLength;
-    if (orientation === "vert") {
+    if (orientation2 === "vert") {
       ;
       [pw, pl] = [pl, pw];
     }
@@ -29492,7 +29492,7 @@ import * as THREE15 from "three";
 // package.json
 var package_default = {
   name: "@tscircuit/3d-viewer",
-  version: "0.0.475",
+  version: "0.0.476",
   main: "./dist/index.js",
   module: "./dist/index.js",
   type: "module",
@@ -29652,12 +29652,12 @@ var CameraControllerProvider = ({ children, defaultTarget, initialCameraPosition
   );
   const baseDistance = useMemo8(() => {
     const [x, y, z138] = initialCameraPosition ?? [5, -5, 5];
-    const distance2 = Math.hypot(
+    const distance3 = Math.hypot(
       x - defaultTarget.x,
       y - defaultTarget.y,
       z138 - defaultTarget.z
     );
-    return distance2 > 0 ? distance2 : 5;
+    return distance3 > 0 ? distance3 : 5;
   }, [initialCameraPosition, defaultTarget]);
   const getPresetConfig = useCallback4(
     (preset) => {
@@ -29668,13 +29668,13 @@ var CameraControllerProvider = ({ children, defaultTarget, initialCameraPosition
       ];
       const camera = mainCameraRef.current;
       const controls = controlsRef.current;
-      let distance2 = baseDistance;
+      let distance3 = baseDistance;
       if (camera && controls) {
-        distance2 = camera.position.distanceTo(controls.target);
+        distance3 = camera.position.distanceTo(controls.target);
       }
       switch (preset) {
         case "Top Center Angled": {
-          const angledOffset = distance2 / Math.sqrt(2);
+          const angledOffset = distance3 / Math.sqrt(2);
           return {
             position: [
               defaultTarget.x,
@@ -29690,7 +29690,7 @@ var CameraControllerProvider = ({ children, defaultTarget, initialCameraPosition
             position: [
               defaultTarget.x,
               defaultTarget.y,
-              defaultTarget.z + distance2
+              defaultTarget.z + distance3
             ],
             target: targetVector,
             up: [0, 0, 1]
@@ -29698,9 +29698,9 @@ var CameraControllerProvider = ({ children, defaultTarget, initialCameraPosition
         case "Top Left Corner":
           return {
             position: [
-              defaultTarget.x - distance2 * 0.6,
-              defaultTarget.y - distance2 * 0.6,
-              defaultTarget.z + distance2 * 0.6
+              defaultTarget.x - distance3 * 0.6,
+              defaultTarget.y - distance3 * 0.6,
+              defaultTarget.z + distance3 * 0.6
             ],
             target: targetVector,
             up: [0, 0, 1]
@@ -29708,9 +29708,9 @@ var CameraControllerProvider = ({ children, defaultTarget, initialCameraPosition
         case "Top Right Corner":
           return {
             position: [
-              defaultTarget.x + distance2 * 0.6,
-              defaultTarget.y - distance2 * 0.6,
-              defaultTarget.z + distance2 * 0.6
+              defaultTarget.x + distance3 * 0.6,
+              defaultTarget.y - distance3 * 0.6,
+              defaultTarget.z + distance3 * 0.6
             ],
             target: targetVector,
             up: [0, 0, 1]
@@ -29718,7 +29718,7 @@ var CameraControllerProvider = ({ children, defaultTarget, initialCameraPosition
         case "Left Sideview":
           return {
             position: [
-              defaultTarget.x - distance2,
+              defaultTarget.x - distance3,
               defaultTarget.y,
               defaultTarget.z
             ],
@@ -29728,7 +29728,7 @@ var CameraControllerProvider = ({ children, defaultTarget, initialCameraPosition
         case "Right Sideview":
           return {
             position: [
-              defaultTarget.x + distance2,
+              defaultTarget.x + distance3,
               defaultTarget.y,
               defaultTarget.z
             ],
@@ -29739,7 +29739,7 @@ var CameraControllerProvider = ({ children, defaultTarget, initialCameraPosition
           return {
             position: [
               defaultTarget.x,
-              defaultTarget.y - distance2,
+              defaultTarget.y - distance3,
               defaultTarget.z
             ],
             target: targetVector,
@@ -30321,13 +30321,13 @@ import { useEffect as useEffect15, useRef as useRef7 } from "react";
 import * as THREE14 from "three";
 import { Text as TroikaText } from "troika-three-text";
 import { jsx as jsx12 } from "react/jsx-runtime";
-function computePointInFront(rotationVector, distance2) {
+function computePointInFront(rotationVector, distance3) {
   const quaternion = new THREE14.Quaternion().setFromEuler(
     new THREE14.Euler(rotationVector.x, rotationVector.y, rotationVector.z)
   );
   const forwardVector = new THREE14.Vector3(0, 0, 1);
   forwardVector.applyQuaternion(quaternion);
-  const result = forwardVector.multiplyScalar(distance2);
+  const result = forwardVector.multiplyScalar(distance3);
   return result;
 }
 var OrientationCubeCanvas = () => {
@@ -32607,6 +32607,58 @@ import { su as su9 } from "@tscircuit/circuit-json-util";
 // src/utils/soldermask-texture.ts
 import * as THREE18 from "three";
 import { su as su5 } from "@tscircuit/circuit-json-util";
+
+// node_modules/@tscircuit/math-utils/dist/chunk-5N7UJNVK.js
+var getBoundsFromPoints = (points) => {
+  if (points.length === 0) {
+    return null;
+  }
+  let minX = points[0].x;
+  let minY = points[0].y;
+  let maxX = points[0].x;
+  let maxY = points[0].y;
+  for (let i = 1; i < points.length; i++) {
+    const point2 = points[i];
+    if (point2.x < minX) minX = point2.x;
+    if (point2.y < minY) minY = point2.y;
+    if (point2.x > maxX) maxX = point2.x;
+    if (point2.y > maxY) maxY = point2.y;
+  }
+  return { minX, minY, maxX, maxY };
+};
+
+// src/utils/outline-bounds.ts
+function calculateOutlineBounds(boardData) {
+  if (boardData.outline && boardData.outline.length >= 3) {
+    const bounds2 = getBoundsFromPoints(boardData.outline);
+    return {
+      ...bounds2,
+      width: bounds2.maxX - bounds2.minX,
+      height: bounds2.maxY - bounds2.minY,
+      centerX: (bounds2.minX + bounds2.maxX) / 2,
+      centerY: (bounds2.minY + bounds2.maxY) / 2
+    };
+  }
+  const boardWidth = boardData.width ?? 0;
+  const boardHeight = boardData.height ?? 0;
+  const boardCenterX = boardData.center?.x ?? 0;
+  const boardCenterY = boardData.center?.y ?? 0;
+  const bounds = {
+    minX: boardCenterX - boardWidth / 2,
+    maxX: boardCenterX + boardWidth / 2,
+    minY: boardCenterY - boardHeight / 2,
+    maxY: boardCenterY + boardHeight / 2
+  };
+  return {
+    ...bounds,
+    width: boardWidth,
+    height: boardHeight,
+    centerX: boardCenterX,
+    centerY: boardCenterY
+  };
+}
+
+// src/utils/soldermask-texture.ts
 function createSoldermaskTextureForLayer({
   layer,
   circuitJson,
@@ -32614,9 +32666,14 @@ function createSoldermaskTextureForLayer({
   soldermaskColor,
   traceTextureResolution
 }) {
+  const boardOutlineBounds = calculateOutlineBounds(boardData);
   const canvas = document.createElement("canvas");
-  const canvasWidth = Math.floor(boardData.width * traceTextureResolution);
-  const canvasHeight = Math.floor(boardData.height * traceTextureResolution);
+  const canvasWidth = Math.floor(
+    boardOutlineBounds.width * traceTextureResolution
+  );
+  const canvasHeight = Math.floor(
+    boardOutlineBounds.height * traceTextureResolution
+  );
   canvas.width = canvasWidth;
   canvas.height = canvasHeight;
   const ctx = canvas.getContext("2d");
@@ -32625,8 +32682,8 @@ function createSoldermaskTextureForLayer({
     ctx.translate(0, canvasHeight);
     ctx.scale(1, -1);
   }
-  const canvasXFromPcb = (pcbX) => (pcbX - boardData.center.x + boardData.width / 2) * traceTextureResolution;
-  const canvasYFromPcb = (pcbY) => (-(pcbY - boardData.center.y) + boardData.height / 2) * traceTextureResolution;
+  const canvasXFromPcb = (pcbX) => (pcbX - boardOutlineBounds.minX) * traceTextureResolution;
+  const canvasYFromPcb = (pcbY) => (boardOutlineBounds.maxY - pcbY) * traceTextureResolution;
   ctx.fillStyle = soldermaskColor;
   if (boardData.outline && boardData.outline.length >= 3) {
     ctx.beginPath();
@@ -33409,9 +33466,14 @@ function createSilkscreenTextureForLayer({
   if (textsOnLayer.length === 0 && pathsOnLayer.length === 0 && linesOnLayer.length === 0 && rectsOnLayer.length === 0 && circlesOnLayer.length === 0 && fabricationNoteRectsOnLayer.length === 0 && noteLinesOnLayer.length === 0) {
     return null;
   }
+  const boardOutlineBounds = calculateOutlineBounds(boardData);
   const canvas = document.createElement("canvas");
-  const canvasWidth = Math.floor(boardData.width * traceTextureResolution);
-  const canvasHeight = Math.floor(boardData.height * traceTextureResolution);
+  const canvasWidth = Math.floor(
+    boardOutlineBounds.width * traceTextureResolution
+  );
+  const canvasHeight = Math.floor(
+    boardOutlineBounds.height * traceTextureResolution
+  );
   canvas.width = canvasWidth;
   canvas.height = canvasHeight;
   const ctx = canvas.getContext("2d");
@@ -33422,8 +33484,8 @@ function createSilkscreenTextureForLayer({
   }
   ctx.strokeStyle = silkscreenColor;
   ctx.fillStyle = silkscreenColor;
-  const canvasXFromPcb = (pcbX) => (pcbX - boardData.center.x + boardData.width / 2) * traceTextureResolution;
-  const canvasYFromPcb = (pcbY) => (-(pcbY - boardData.center.y) + boardData.height / 2) * traceTextureResolution;
+  const canvasXFromPcb = (pcbX) => (pcbX - boardOutlineBounds.minX) * traceTextureResolution;
+  const canvasYFromPcb = (pcbY) => (boardOutlineBounds.maxY - pcbY) * traceTextureResolution;
   linesOnLayer.forEach((lineEl) => {
     const startXmm = parseDimensionToMm(lineEl.x1) ?? 0;
     const startYmm = parseDimensionToMm(lineEl.y1) ?? 0;
@@ -33789,9 +33851,14 @@ function createTraceTextureForLayer({
     (t) => t.route.some((p) => isWireRoutePoint(p) && p.layer === layer)
   );
   if (tracesOnLayer.length === 0) return null;
+  const boardOutlineBounds = calculateOutlineBounds(boardData);
   const canvas = document.createElement("canvas");
-  const canvasWidth = Math.floor(boardData.width * traceTextureResolution);
-  const canvasHeight = Math.floor(boardData.height * traceTextureResolution);
+  const canvasWidth = Math.floor(
+    boardOutlineBounds.width * traceTextureResolution
+  );
+  const canvasHeight = Math.floor(
+    boardOutlineBounds.height * traceTextureResolution
+  );
   canvas.width = canvasWidth;
   canvas.height = canvasHeight;
   const ctx = canvas.getContext("2d");
@@ -33817,8 +33884,8 @@ function createTraceTextureForLayer({
       const pcbY = point2.y;
       currentLineWidth = point2.width * traceTextureResolution;
       ctx.lineWidth = currentLineWidth;
-      const canvasX = (pcbX - boardData.center.x + boardData.width / 2) * traceTextureResolution;
-      const canvasY = (-(pcbY - boardData.center.y) + boardData.height / 2) * traceTextureResolution;
+      const canvasX = (pcbX - boardOutlineBounds.minX) * traceTextureResolution;
+      const canvasY = (boardOutlineBounds.maxY - pcbY) * traceTextureResolution;
       if (firstPoint) {
         ctx.moveTo(canvasX, canvasY);
         firstPoint = false;
@@ -33833,8 +33900,8 @@ function createTraceTextureForLayer({
   ctx.globalCompositeOperation = "destination-out";
   ctx.fillStyle = "black";
   allPcbVias.forEach((via) => {
-    const canvasX = (via.x - boardData.center.x + boardData.width / 2) * traceTextureResolution;
-    const canvasY = (-(via.y - boardData.center.y) + boardData.height / 2) * traceTextureResolution;
+    const canvasX = (via.x - boardOutlineBounds.minX) * traceTextureResolution;
+    const canvasY = (boardOutlineBounds.maxY - via.y) * traceTextureResolution;
     const canvasRadius = via.outer_diameter / 2 * traceTextureResolution;
     ctx.beginPath();
     ctx.arc(canvasX, canvasY, canvasRadius, 0, 2 * Math.PI, false);
@@ -33842,8 +33909,8 @@ function createTraceTextureForLayer({
   });
   allPcbPlatedHoles.forEach((ph) => {
     if (ph.layers.includes(layer) && ph.shape === "circle") {
-      const canvasX = (ph.x - boardData.center.x + boardData.width / 2) * traceTextureResolution;
-      const canvasY = (-(ph.y - boardData.center.y) + boardData.height / 2) * traceTextureResolution;
+      const canvasX = (ph.x - boardOutlineBounds.minX) * traceTextureResolution;
+      const canvasY = (boardOutlineBounds.maxY - ph.y) * traceTextureResolution;
       const canvasRadius = ph.outer_diameter / 2 * traceTextureResolution;
       ctx.beginPath();
       ctx.arc(canvasX, canvasY, canvasRadius, 0, 2 * Math.PI, false);
@@ -34038,9 +34105,14 @@ function createCopperTextTextureForLayer({
   if (textsOnLayer.length === 0) {
     return null;
   }
+  const boardOutlineBounds = calculateOutlineBounds(boardData);
   const canvas = document.createElement("canvas");
-  const canvasWidth = Math.floor(boardData.width * traceTextureResolution);
-  const canvasHeight = Math.floor(boardData.height * traceTextureResolution);
+  const canvasWidth = Math.floor(
+    boardOutlineBounds.width * traceTextureResolution
+  );
+  const canvasHeight = Math.floor(
+    boardOutlineBounds.height * traceTextureResolution
+  );
   canvas.width = canvasWidth;
   canvas.height = canvasHeight;
   const ctx = canvas.getContext("2d");
@@ -34051,8 +34123,8 @@ function createCopperTextTextureForLayer({
   }
   ctx.strokeStyle = copperColor;
   ctx.fillStyle = copperColor;
-  const canvasXFromPcb = (pcbX) => (pcbX - boardData.center.x + boardData.width / 2) * traceTextureResolution;
-  const canvasYFromPcb = (pcbY) => (-(pcbY - boardData.center.y) + boardData.height / 2) * traceTextureResolution;
+  const canvasXFromPcb = (pcbX) => (pcbX - boardOutlineBounds.minX) * traceTextureResolution;
+  const canvasYFromPcb = (pcbY) => (boardOutlineBounds.maxY - pcbY) * traceTextureResolution;
   textsOnLayer.forEach((textS) => {
     const fontSize = typeof textS.font_size === "number" ? textS.font_size : 0.2;
     const textStrokeWidth = Math.max(0.02, fontSize * 0.08) * traceTextureResolution;
@@ -34287,9 +34359,10 @@ function JscadBoardTextures({
     const meshes = [];
     const createTexturePlane = (texture, zOffset, isBottomLayer, name, usePolygonOffset = false, depthWrite = false) => {
       if (!texture) return null;
+      const boardOutlineBounds = calculateOutlineBounds(boardData);
       const planeGeom = new THREE23.PlaneGeometry(
-        boardData.width,
-        boardData.height
+        boardOutlineBounds.width,
+        boardOutlineBounds.height
       );
       const material = new THREE23.MeshBasicMaterial({
         map: texture,
@@ -34301,7 +34374,11 @@ function JscadBoardTextures({
         polygonOffsetUnits: usePolygonOffset ? -1 : 0
       });
       const mesh = new THREE23.Mesh(planeGeom, material);
-      mesh.position.set(boardData.center.x, boardData.center.y, zOffset);
+      mesh.position.set(
+        boardOutlineBounds.centerX,
+        boardOutlineBounds.centerY,
+        zOffset
+      );
       if (isBottomLayer) {
         mesh.rotation.set(Math.PI, 0, 0);
       }
@@ -36393,7 +36470,11 @@ function createTextureMeshes(textures, boardData, pcbThickness) {
   if (!textures || !boardData || pcbThickness === null) return meshes;
   const createTexturePlane = (texture, yOffset, isBottomLayer, keySuffix, usePolygonOffset = false, renderOrder = 0) => {
     if (!texture) return null;
-    const planeGeom = new THREE32.PlaneGeometry(boardData.width, boardData.height);
+    const boardOutlineBounds = calculateOutlineBounds(boardData);
+    const planeGeom = new THREE32.PlaneGeometry(
+      boardOutlineBounds.width,
+      boardOutlineBounds.height
+    );
     const material = new THREE32.MeshBasicMaterial({
       map: texture,
       transparent: true,
@@ -36405,7 +36486,11 @@ function createTextureMeshes(textures, boardData, pcbThickness) {
       polygonOffsetUnits: usePolygonOffset ? -4 : 0
     });
     const mesh = new THREE32.Mesh(planeGeom, material);
-    mesh.position.set(boardData.center.x, boardData.center.y, yOffset);
+    mesh.position.set(
+      boardOutlineBounds.centerX,
+      boardOutlineBounds.centerY,
+      yOffset
+    );
     if (isBottomLayer) {
       mesh.rotation.set(Math.PI, 0, 0);
     }
@@ -38108,7 +38193,7 @@ var oppositeAlignmentMap = {
   start: "end",
   end: "start"
 };
-function clamp(start, value, end) {
+function clamp2(start, value, end) {
   return max(start, min(value, end));
 }
 function evaluate(value, param) {
@@ -38461,7 +38546,7 @@ var arrow = (options) => ({
     const min$1 = minPadding;
     const max2 = clientSize - arrowDimensions[length2] - maxPadding;
     const center = clientSize / 2 - arrowDimensions[length2] / 2 + centerToReference;
-    const offset4 = clamp(min$1, center, max2);
+    const offset4 = clamp2(min$1, center, max2);
     const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset4 && rects.reference[length2] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length2] / 2 < 0;
     const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max2 : 0;
     return {
@@ -38758,14 +38843,14 @@ var shift = function(options) {
         const maxSide = mainAxis === "y" ? "bottom" : "right";
         const min2 = mainAxisCoord + overflow[minSide];
         const max2 = mainAxisCoord - overflow[maxSide];
-        mainAxisCoord = clamp(min2, mainAxisCoord, max2);
+        mainAxisCoord = clamp2(min2, mainAxisCoord, max2);
       }
       if (checkCrossAxis) {
         const minSide = crossAxis === "y" ? "top" : "left";
         const maxSide = crossAxis === "y" ? "bottom" : "right";
         const min2 = crossAxisCoord + overflow[minSide];
         const max2 = crossAxisCoord - overflow[maxSide];
-        crossAxisCoord = clamp(min2, crossAxisCoord, max2);
+        crossAxisCoord = clamp2(min2, crossAxisCoord, max2);
       }
       const limitedCoords = limiter.fn({
         ...state,
@@ -40470,7 +40555,7 @@ RovingFocusGroup.displayName = GROUP_NAME;
 var RovingFocusGroupImpl = React34.forwardRef((props, forwardedRef) => {
   const {
     __scopeRovingFocusGroup,
-    orientation,
+    orientation: orientation2,
     loop = false,
     dir,
     currentTabStopId: currentTabStopIdProp,
@@ -40505,7 +40590,7 @@ var RovingFocusGroupImpl = React34.forwardRef((props, forwardedRef) => {
     RovingFocusProvider,
     {
       scope: __scopeRovingFocusGroup,
-      orientation,
+      orientation: orientation2,
       dir: direction,
       loop,
       currentTabStopId,
@@ -40526,7 +40611,7 @@ var RovingFocusGroupImpl = React34.forwardRef((props, forwardedRef) => {
         Primitive.div,
         {
           tabIndex: isTabbingBackOut || focusableItemsCount === 0 ? -1 : 0,
-          "data-orientation": orientation,
+          "data-orientation": orientation2,
           ...groupProps,
           ref: composedRefs,
           style: { outline: "none", ...props.style },
@@ -40642,10 +40727,10 @@ function getDirectionAwareKey(key, dir) {
   if (dir !== "rtl") return key;
   return key === "ArrowLeft" ? "ArrowRight" : key === "ArrowRight" ? "ArrowLeft" : key;
 }
-function getFocusIntent(event, orientation, dir) {
+function getFocusIntent(event, orientation2, dir) {
   const key = getDirectionAwareKey(event.key, dir);
-  if (orientation === "vertical" && ["ArrowLeft", "ArrowRight"].includes(key)) return void 0;
-  if (orientation === "horizontal" && ["ArrowUp", "ArrowDown"].includes(key)) return void 0;
+  if (orientation2 === "vertical" && ["ArrowLeft", "ArrowRight"].includes(key)) return void 0;
+  if (orientation2 === "horizontal" && ["ArrowUp", "ArrowDown"].includes(key)) return void 0;
   return MAP_KEY_TO_FOCUS_INTENT[key];
 }
 function focusFirst2(candidates, preventScroll = false) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/3d-viewer",
-  "version": "0.0.476",
+  "version": "0.0.477",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "type": "module",