@tscircuit/3d-viewer 0.0.539 → 0.0.540

package/dist/index.js

@@ -881,13 +881,13 @@ var require_squaredLength = __commonJS({
 var require_subtract = __commonJS({
   "node_modules/@jscad/modeling/src/maths/vec3/subtract.js"(exports, module) {
     "use strict";
-    var subtract5 = (out, a, b) => {
+    var subtract4 = (out, a, b) => {
       out[0] = a[0] - b[0];
       out[1] = a[1] - b[1];
       out[2] = a[2] - b[2];
       return out;
     };
-    module.exports = subtract5;
+    module.exports = subtract4;
   }
 });
 
@@ -1428,7 +1428,7 @@ var require_scale2 = __commonJS({
 var require_subtract2 = __commonJS({
   "node_modules/@jscad/modeling/src/maths/mat4/subtract.js"(exports, module) {
     "use strict";
-    var subtract5 = (out, a, b) => {
+    var subtract4 = (out, a, b) => {
       out[0] = a[0] - b[0];
       out[1] = a[1] - b[1];
       out[2] = a[2] - b[2];
@@ -1447,7 +1447,7 @@ var require_subtract2 = __commonJS({
       out[15] = a[15] - b[15];
       return out;
     };
-    module.exports = subtract5;
+    module.exports = subtract4;
   }
 });
 
@@ -1957,12 +1957,12 @@ var require_squaredLength2 = __commonJS({
 var require_subtract3 = __commonJS({
   "node_modules/@jscad/modeling/src/maths/vec2/subtract.js"(exports, module) {
     "use strict";
-    var subtract5 = (out, a, b) => {
+    var subtract4 = (out, a, b) => {
       out[0] = a[0] - b[0];
       out[1] = a[1] - b[1];
       return out;
     };
-    module.exports = subtract5;
+    module.exports = subtract4;
   }
 });
 
@@ -2423,14 +2423,14 @@ var require_point_line_distance = __commonJS({
   "node_modules/@jscad/modeling/src/operations/hulls/quickhull/point-line-distance.js"(exports, module) {
     "use strict";
     var cross = require_cross();
-    var subtract5 = require_subtract();
+    var subtract4 = require_subtract();
     var squaredLength = require_squaredLength();
     var distanceSquared = (p, a, b) => {
       const ab = [];
       const ap = [];
       const cr = [];
-      subtract5(ab, b, a);
-      subtract5(ap, p, a);
+      subtract4(ab, b, a);
+      subtract4(ap, p, a);
       const area = squaredLength(cross(cr, ap, ab));
       const s = squaredLength(ab);
       if (s === 0) {
@@ -2449,11 +2449,11 @@ var require_get_plane_normal = __commonJS({
     "use strict";
     var cross = require_cross();
     var normalize = require_normalize();
-    var subtract5 = require_subtract();
+    var subtract4 = require_subtract();
     var planeNormal = (out, point1, point2, point3) => {
       const tmp = [0, 0, 0];
-      subtract5(out, point1, point2);
-      subtract5(tmp, point2, point3);
+      subtract4(out, point1, point2);
+      subtract4(tmp, point2, point3);
       cross(out, out, tmp);
       return normalize(out, out);
     };
@@ -2667,7 +2667,7 @@ var require_Face = __commonJS({
     var length62 = require_length();
     var normalize = require_normalize();
     var scale2 = require_scale();
-    var subtract5 = require_subtract();
+    var subtract4 = require_subtract();
     var HalfEdge = require_HalfEdge();
     var VISIBLE = 0;
     var NON_CONVEX = 1;
@@ -2701,14 +2701,14 @@ var require_Face = __commonJS({
         const e0 = this.edge;
         const e1 = e0.next;
         let e2 = e1.next;
-        const v2 = subtract5([], e1.head().point, e0.head().point);
+        const v2 = subtract4([], e1.head().point, e0.head().point);
         const t = [];
         const v1 = [];
         this.nVertices = 2;
         this.normal = [0, 0, 0];
         while (e2 !== e0) {
           copy(v1, v2);
-          subtract5(v2, e2.head().point, e0.head().point);
+          subtract4(v2, e2.head().point, e0.head().point);
           add(this.normal, this.normal, cross(t, v1, v2));
           e2 = e2.next;
           this.nVertices += 1;
@@ -2732,7 +2732,7 @@ var require_Face = __commonJS({
           } while (edge !== this.edge);
           const p1 = maxEdge.tail().point;
           const p2 = maxEdge.head().point;
-          const maxVector = subtract5([], p2, p1);
+          const maxVector = subtract4([], p2, p1);
           const maxLength = Math.sqrt(maxSquaredLength);
           scale2(maxVector, maxVector, 1 / maxLength);
           const maxProjection = dot(this.normal, maxVector);
@@ -3854,11 +3854,11 @@ var require_invert2 = __commonJS({
     "use strict";
     var plane = require_plane();
     var create = require_create6();
-    var invert = (polygon3) => {
-      const vertices = polygon3.vertices.slice().reverse();
+    var invert = (polygon2) => {
+      const vertices = polygon2.vertices.slice().reverse();
       const inverted = create(vertices);
-      if (polygon3.plane) {
-        inverted.plane = plane.flip(plane.create(), polygon3.plane);
+      if (polygon2.plane) {
+        inverted.plane = plane.flip(plane.create(), polygon2.plane);
       }
       return inverted;
     };
@@ -3890,7 +3890,7 @@ var require_isConvex = __commonJS({
     "use strict";
     var plane = require_plane();
     var vec3 = require_vec3();
-    var isConvex = (polygon3) => areVerticesConvex(polygon3.vertices);
+    var isConvex = (polygon2) => areVerticesConvex(polygon2.vertices);
     var areVerticesConvex = (vertices) => {
       const numvertices = vertices.length;
       if (numvertices > 2) {
@@ -3926,11 +3926,11 @@ var require_plane2 = __commonJS({
   "node_modules/@jscad/modeling/src/geometries/poly3/plane.js"(exports, module) {
     "use strict";
     var mplane = require_plane();
-    var plane = (polygon3) => {
-      if (!polygon3.plane) {
-        polygon3.plane = mplane.fromPoints(mplane.create(), ...polygon3.vertices);
+    var plane = (polygon2) => {
+      if (!polygon2.plane) {
+        polygon2.plane = mplane.fromPoints(mplane.create(), ...polygon2.vertices);
       }
-      return polygon3.plane;
+      return polygon2.plane;
     };
     module.exports = plane;
   }
@@ -3941,13 +3941,13 @@ var require_measureArea = __commonJS({
   "node_modules/@jscad/modeling/src/geometries/poly3/measureArea.js"(exports, module) {
     "use strict";
     var plane = require_plane2();
-    var measureArea = (polygon3) => {
-      const n = polygon3.vertices.length;
+    var measureArea = (polygon2) => {
+      const n = polygon2.vertices.length;
       if (n < 3) {
         return 0;
       }
-      const vertices = polygon3.vertices;
-      const normal = plane(polygon3);
+      const vertices = polygon2.vertices;
+      const normal = plane(polygon2);
       const ax = Math.abs(normal[0]);
       const ay = Math.abs(normal[1]);
       const az = Math.abs(normal[2]);
@@ -4006,8 +4006,8 @@ var require_measureBoundingBox = __commonJS({
   "node_modules/@jscad/modeling/src/geometries/poly3/measureBoundingBox.js"(exports, module) {
     "use strict";
     var vec3 = require_vec3();
-    var measureBoundingBox = (polygon3) => {
-      const vertices = polygon3.vertices;
+    var measureBoundingBox = (polygon2) => {
+      const vertices = polygon2.vertices;
       const numvertices = vertices.length;
       const min2 = numvertices === 0 ? vec3.create() : vec3.clone(vertices[0]);
       const max2 = vec3.clone(min2);
@@ -4085,10 +4085,10 @@ var require_measureBoundingSphere = __commonJS({
     "use strict";
     var vec4 = require_vec4();
     var cache = /* @__PURE__ */ new WeakMap();
-    var measureBoundingSphere = (polygon3) => {
-      const boundingSphere = cache.get(polygon3);
+    var measureBoundingSphere = (polygon2) => {
+      const boundingSphere = cache.get(polygon2);
       if (boundingSphere) return boundingSphere;
-      const vertices = polygon3.vertices;
+      const vertices = polygon2.vertices;
       const out = vec4.create();
       if (vertices.length === 0) {
         out[0] = 0;
@@ -4118,7 +4118,7 @@ var require_measureBoundingSphere = __commonJS({
       const y = out[1] - maxy[1];
       const z21 = out[2] - maxz[2];
       out[3] = Math.sqrt(x * x + y * y + z21 * z21);
-      cache.set(polygon3, out);
+      cache.set(polygon2, out);
       return out;
     };
     module.exports = measureBoundingSphere;
@@ -4130,9 +4130,9 @@ var require_measureSignedVolume = __commonJS({
   "node_modules/@jscad/modeling/src/geometries/poly3/measureSignedVolume.js"(exports, module) {
     "use strict";
     var vec3 = require_vec3();
-    var measureSignedVolume = (polygon3) => {
+    var measureSignedVolume = (polygon2) => {
       let signedVolume = 0;
-      const vertices = polygon3.vertices;
+      const vertices = polygon2.vertices;
       const cross = vec3.create();
       for (let i = 0; i < vertices.length - 2; i++) {
         vec3.cross(cross, vertices[i + 1], vertices[i + 2]);
@@ -4149,7 +4149,7 @@ var require_measureSignedVolume = __commonJS({
 var require_toPoints2 = __commonJS({
   "node_modules/@jscad/modeling/src/geometries/poly3/toPoints.js"(exports, module) {
     "use strict";
-    var toPoints = (polygon3) => polygon3.vertices;
+    var toPoints = (polygon2) => polygon2.vertices;
     module.exports = toPoints;
   }
 });
@@ -4159,9 +4159,9 @@ var require_toString6 = __commonJS({
   "node_modules/@jscad/modeling/src/geometries/poly3/toString.js"(exports, module) {
     "use strict";
     var vec3 = require_vec3();
-    var toString = (polygon3) => {
+    var toString = (polygon2) => {
       let result = "poly3: vertices: [";
-      polygon3.vertices.forEach((vertex) => {
+      polygon2.vertices.forEach((vertex) => {
         result += `${vec3.toString(vertex)}, `;
       });
       result += "]";
@@ -4178,8 +4178,8 @@ var require_transform6 = __commonJS({
     var mat4 = require_mat4();
     var vec3 = require_vec3();
     var create = require_create6();
-    var transform = (matrix, polygon3) => {
-      const vertices = polygon3.vertices.map((vertex) => vec3.transform(vec3.create(), vertex, matrix));
+    var transform = (matrix, polygon2) => {
+      const vertices = polygon2.vertices.map((vertex) => vec3.transform(vec3.create(), vertex, matrix));
       if (mat4.isMirroring(matrix)) {
         vertices.reverse();
       }
@@ -4295,8 +4295,8 @@ var require_fromPoints4 = __commonJS({
         throw new Error("the given points must be an array");
       }
       const polygons = listofpoints.map((points, index2) => {
-        const polygon3 = poly3.create(points);
-        return polygon3;
+        const polygon2 = poly3.create(points);
+        return polygon2;
       });
       const result = create(polygons);
       return result;
@@ -4347,7 +4347,7 @@ var require_applyTransforms2 = __commonJS({
     var poly3 = require_poly3();
     var applyTransforms = (geometry) => {
       if (mat4.isIdentity(geometry.transforms)) return geometry;
-      geometry.polygons = geometry.polygons.map((polygon3) => poly3.transform(geometry.transforms, polygon3));
+      geometry.polygons = geometry.polygons.map((polygon2) => poly3.transform(geometry.transforms, polygon2));
       geometry.transforms = mat4.create();
       return geometry;
     };
@@ -4374,7 +4374,7 @@ var require_invert3 = __commonJS({
     var toPolygons = require_toPolygons();
     var invert = (geometry) => {
       const polygons = toPolygons(geometry);
-      const newpolygons = polygons.map((polygon3) => poly3.invert(polygon3));
+      const newpolygons = polygons.map((polygon2) => poly3.invert(polygon2));
       return create(newpolygons);
     };
     module.exports = invert;
@@ -4453,7 +4453,7 @@ var require_toPoints3 = __commonJS({
     var toPolygons = require_toPolygons();
     var toPoints = (geometry) => {
       const polygons = toPolygons(geometry);
-      const listofpoints = polygons.map((polygon3) => poly3.toPoints(polygon3));
+      const listofpoints = polygons.map((polygon2) => poly3.toPoints(polygon2));
       return listofpoints;
     };
     module.exports = toPoints;
@@ -4469,8 +4469,8 @@ var require_toString7 = __commonJS({
     var toString = (geometry) => {
       const polygons = toPolygons(geometry);
       let result = "geom3 (" + polygons.length + " polygons):\n";
-      polygons.forEach((polygon3) => {
-        result += "  " + poly3.toString(polygon3) + "\n";
+      polygons.forEach((polygon2) => {
+        result += "  " + poly3.toString(polygon2) + "\n";
       });
       return result;
     };
@@ -4487,7 +4487,7 @@ var require_toCompactBinary2 = __commonJS({
       const polygons = geometry.polygons;
       const transforms = geometry.transforms;
       const numberOfPolygons = polygons.length;
-      const numberOfVertices = polygons.reduce((count3, polygon3) => count3 + polygon3.vertices.length, 0);
+      const numberOfVertices = polygons.reduce((count3, polygon2) => count3 + polygon2.vertices.length, 0);
       let color = [-1, -1, -1, -1];
       if (geometry.color) color = geometry.color;
       const compacted = new Float32Array(1 + 16 + 4 + 1 + numberOfPolygons + numberOfVertices * 3);
@@ -4515,8 +4515,8 @@ var require_toCompactBinary2 = __commonJS({
       compacted[21] = numberOfVertices;
       let ci = 22;
       let vi = ci + numberOfPolygons;
-      polygons.forEach((polygon3) => {
-        const points = poly3.toPoints(polygon3);
+      polygons.forEach((polygon2) => {
+        const points = poly3.toPoints(polygon2);
         compacted[ci] = points.length;
         ci++;
         for (let i = 0; i < points.length; i++) {
@@ -5945,7 +5945,7 @@ var require_measureArea2 = __commonJS({
   "node_modules/@jscad/modeling/src/geometries/poly2/measureArea.js"(exports, module) {
     "use strict";
     var area = require_area();
-    var measureArea = (polygon3) => area(polygon3.vertices);
+    var measureArea = (polygon2) => area(polygon2.vertices);
     module.exports = measureArea;
   }
 });
@@ -5969,8 +5969,8 @@ var require_flip2 = __commonJS({
   "node_modules/@jscad/modeling/src/geometries/poly2/flip.js"(exports, module) {
     "use strict";
     var create = require_create10();
-    var flip4 = (polygon3) => {
-      const vertices = polygon3.vertices.slice().reverse();
+    var flip4 = (polygon2) => {
+      const vertices = polygon2.vertices.slice().reverse();
       return create(vertices);
     };
     module.exports = flip4;
@@ -5983,22 +5983,22 @@ var require_arePointsInside = __commonJS({
     "use strict";
     var measureArea = require_measureArea2();
     var flip4 = require_flip2();
-    var arePointsInside = (points, polygon3) => {
+    var arePointsInside = (points, polygon2) => {
       if (points.length === 0) return 0;
-      const vertices = polygon3.vertices;
+      const vertices = polygon2.vertices;
       if (vertices.length < 3) return 0;
-      if (measureArea(polygon3) < 0) {
-        polygon3 = flip4(polygon3);
+      if (measureArea(polygon2) < 0) {
+        polygon2 = flip4(polygon2);
       }
       const sum = points.reduce((acc, point) => acc + isPointInside(point, vertices), 0);
       return sum === points.length ? 1 : 0;
     };
-    var isPointInside = (point, polygon3) => {
-      const numverts = polygon3.length;
+    var isPointInside = (point, polygon2) => {
+      const numverts = polygon2.length;
       const tx = point[0];
       const ty = point[1];
-      let vtx0 = polygon3[numverts - 1];
-      let vtx1 = polygon3[0];
+      let vtx0 = polygon2[numverts - 1];
+      let vtx1 = polygon2[0];
       let yflag0 = vtx0[1] > ty;
       let insideFlag = 0;
       let i = 0;
@@ -6017,7 +6017,7 @@ var require_arePointsInside = __commonJS({
         }
         yflag0 = yflag1;
         vtx0 = vtx1;
-        vtx1 = polygon3[++i];
+        vtx1 = polygon2[++i];
       }
       return insideFlag;
     };
@@ -6696,7 +6696,7 @@ var require_measureArea3 = __commonJS({
       let area = cache.get(geometry);
       if (area) return area;
       const polygons = geom3.toPolygons(geometry);
-      area = polygons.reduce((area2, polygon3) => area2 + poly3.measureArea(polygon3), 0);
+      area = polygons.reduce((area2, polygon2) => area2 + poly3.measureArea(polygon2), 0);
       cache.set(geometry, area);
       return area;
     };
@@ -6799,8 +6799,8 @@ var require_measureBoundingBox2 = __commonJS({
         vec3.copy(minpoint, points[0]);
       }
       let maxpoint = vec3.clone(minpoint);
-      polygons.forEach((polygon3) => {
-        poly3.toPoints(polygon3).forEach((point) => {
+      polygons.forEach((polygon2) => {
+        poly3.toPoints(polygon2).forEach((point) => {
           vec3.min(minpoint, minpoint, point);
           vec3.max(maxpoint, maxpoint, point);
         });
@@ -6907,7 +6907,7 @@ var require_measureVolume = __commonJS({
       let volume = cache.get(geometry);
       if (volume) return volume;
       const polygons = geom3.toPolygons(geometry);
-      volume = polygons.reduce((volume2, polygon3) => volume2 + poly3.measureSignedVolume(polygon3), 0);
+      volume = polygons.reduce((volume2, polygon2) => volume2 + poly3.measureSignedVolume(polygon2), 0);
       cache.set(geometry, volume);
       return volume;
     };
@@ -7012,15 +7012,15 @@ var require_measureBoundingSphere2 = __commonJS({
       const polygons = geom3.toPolygons(geometry);
       if (polygons.length > 0) {
         let numPoints = 0;
-        polygons.forEach((polygon3) => {
-          poly3.toPoints(polygon3).forEach((point) => {
+        polygons.forEach((polygon2) => {
+          poly3.toPoints(polygon2).forEach((point) => {
             vec3.add(centroid, centroid, point);
             numPoints++;
           });
         });
         vec3.scale(centroid, centroid, 1 / numPoints);
-        polygons.forEach((polygon3) => {
-          poly3.toPoints(polygon3).forEach((point) => {
+        polygons.forEach((polygon2) => {
+          poly3.toPoints(polygon2).forEach((point) => {
             radius = Math.max(radius, vec3.squaredDistance(centroid, point));
           });
         });
@@ -7108,8 +7108,8 @@ var require_measureCenterOfMass = __commonJS({
       if (polygons.length === 0) return centerOfMass;
       let totalVolume = 0;
       const vector = vec3.create();
-      polygons.forEach((polygon3) => {
-        const vertices = polygon3.vertices;
+      polygons.forEach((polygon2) => {
+        const vertices = polygon2.vertices;
         for (let i = 0; i < vertices.length - 2; i++) {
           vec3.cross(vector, vertices[i + 1], vertices[i + 2]);
           const volume = vec3.dot(vertices[0], vector) / 6;
@@ -7690,9 +7690,9 @@ var require_polyhedron = __commonJS({
         faces.forEach((face) => face.reverse());
       }
       const polygons = faces.map((face, findex) => {
-        const polygon3 = poly3.create(face.map((pindex) => points[pindex]));
-        if (colors2 && colors2[findex]) polygon3.color = colors2[findex];
-        return polygon3;
+        const polygon2 = poly3.create(face.map((pindex) => points[pindex]));
+        if (colors2 && colors2[findex]) polygon2.color = colors2[findex];
+        return polygon2;
       });
       return geom3.create(polygons);
     };
@@ -7845,7 +7845,7 @@ var require_polygon = __commonJS({
   "node_modules/@jscad/modeling/src/primitives/polygon.js"(exports, module) {
     "use strict";
     var geom2 = require_geom2();
-    var polygon3 = (options) => {
+    var polygon2 = (options) => {
       const defaults = {
         points: [],
         paths: [],
@@ -7886,7 +7886,7 @@ var require_polygon = __commonJS({
       }
       return geometry;
     };
-    module.exports = polygon3;
+    module.exports = polygon2;
   }
 });
 
@@ -10156,12 +10156,12 @@ var require_fromFakePolygons = __commonJS({
     "use strict";
     var vec2 = require_vec2();
     var geom2 = require_geom2();
-    var fromFakePolygon = (epsilon, polygon3) => {
-      if (polygon3.vertices.length < 4) {
+    var fromFakePolygon = (epsilon, polygon2) => {
+      if (polygon2.vertices.length < 4) {
         return null;
       }
       const vert1Indices = [];
-      const points3D = polygon3.vertices.filter((vertex, i) => {
+      const points3D = polygon2.vertices.filter((vertex, i) => {
         if (vertex[2] > 0) {
           vert1Indices.push(i);
           return true;
@@ -10188,7 +10188,7 @@ var require_fromFakePolygons = __commonJS({
       return points2D;
     };
     var fromFakePolygons = (epsilon, polygons) => {
-      const sides2 = polygons.map((polygon3) => fromFakePolygon(epsilon, polygon3)).filter((polygon3) => polygon3 !== null);
+      const sides2 = polygons.map((polygon2) => fromFakePolygon(epsilon, polygon2)).filter((polygon2) => polygon2 !== null);
       return geom2.create(sides2);
     };
     module.exports = fromFakePolygons;
@@ -10549,8 +10549,8 @@ var require_reTesselateCoplanarPolygons = __commonJS({
               prevpolygon.outpolygon.leftpoints.reverse();
               const points2d = prevpolygon.outpolygon.rightpoints.concat(prevpolygon.outpolygon.leftpoints);
               const vertices3d = points2d.map((point2d) => orthobasis.to3D(point2d));
-              const polygon3 = poly3.fromPointsAndPlane(vertices3d, plane);
-              if (polygon3.vertices.length) destpolygons.push(polygon3);
+              const polygon2 = poly3.fromPointsAndPlane(vertices3d, plane);
+              if (polygon2.vertices.length) destpolygons.push(polygon2);
             }
           }
         }
@@ -10594,7 +10594,7 @@ var require_retessellate = __commonJS({
       if (geometry.isRetesselated) {
         return geometry;
       }
-      const polygons = geom3.toPolygons(geometry).map((polygon3, index2) => ({ vertices: polygon3.vertices, plane: poly3.plane(polygon3), index: index2 }));
+      const polygons = geom3.toPolygons(geometry).map((polygon2, index2) => ({ vertices: polygon2.vertices, plane: poly3.plane(polygon2), index: index2 }));
       const classified = classifyPolygons(polygons);
       const destPolygons = [];
       classified.forEach((group) => {
@@ -10642,8 +10642,8 @@ var require_retessellate = __commonJS({
       clusters.forEach((cluster) => {
         if (cluster[0]) result[cluster[0].index] = cluster;
       });
-      nonCoplanar.forEach((polygon3) => {
-        result[polygon3.index] = polygon3;
+      nonCoplanar.forEach((polygon2) => {
+        result[polygon2.index] = polygon2;
       });
       return result;
     };
@@ -10848,15 +10848,15 @@ var require_splitPolygonByPlane = __commonJS({
       }
       return result;
     };
-    var splitPolygonByPlane = (splane, polygon3) => {
+    var splitPolygonByPlane = (splane, polygon2) => {
       const result = {
         type: null,
         front: null,
         back: null
       };
-      const vertices = polygon3.vertices;
+      const vertices = polygon2.vertices;
       const numvertices = vertices.length;
-      const pplane = poly3.plane(polygon3);
+      const pplane = poly3.plane(polygon2);
       if (plane.equals(pplane, splane)) {
         result.type = 0;
       } else {
@@ -10939,10 +10939,10 @@ var require_PolygonTreeNode = __commonJS({
     var splitPolygonByPlane = require_splitPolygonByPlane();
     var PolygonTreeNode = class _PolygonTreeNode {
       // constructor creates the root node
-      constructor(parent, polygon3) {
+      constructor(parent, polygon2) {
         this.parent = parent;
         this.children = [];
-        this.polygon = polygon3;
+        this.polygon = polygon2;
         this.removed = false;
       }
       // fill the tree with polygons. Should be called on the root node only; child nodes must
@@ -10952,8 +10952,8 @@ var require_PolygonTreeNode = __commonJS({
           throw new Error("Assertion failed");
         }
         const _this = this;
-        polygons.forEach((polygon3) => {
-          _this.addChild(polygon3);
+        polygons.forEach((polygon2) => {
+          _this.addChild(polygon2);
         });
       }
       // remove a node
@@ -11033,9 +11033,9 @@ var require_PolygonTreeNode = __commonJS({
       }
       // only to be called for nodes with no children
       _splitByPlane(splane, coplanarfrontnodes, coplanarbacknodes, frontnodes, backnodes) {
-        const polygon3 = this.polygon;
-        if (polygon3) {
-          const bound = poly3.measureBoundingSphere(polygon3);
+        const polygon2 = this.polygon;
+        if (polygon2) {
+          const bound = poly3.measureBoundingSphere(polygon2);
           const sphereradius = bound[3] + EPS;
           const spherecenter = bound;
           const d = vec3.dot(splane, spherecenter) - splane[3];
@@ -11044,7 +11044,7 @@ var require_PolygonTreeNode = __commonJS({
           } else if (d < -sphereradius) {
             backnodes.push(this);
           } else {
-            const splitresult = splitPolygonByPlane(splane, polygon3);
+            const splitresult = splitPolygonByPlane(splane, polygon2);
             switch (splitresult.type) {
               case 0:
                 coplanarfrontnodes.push(this);
@@ -11077,8 +11077,8 @@ var require_PolygonTreeNode = __commonJS({
       // this should be called whenever the polygon is split
       // a child should be created for every fragment of the split polygon
       // returns the newly created child
-      addChild(polygon3) {
-        const newchild = new _PolygonTreeNode(this, polygon3);
+      addChild(polygon2) {
+        const newchild = new _PolygonTreeNode(this, polygon2);
         this.children.push(newchild);
         return newchild;
       }
@@ -11420,8 +11420,8 @@ var require_minkowskiSum = __commonJS({
       }
       const tetrahedra = [];
       for (let i = 0; i < polygons.length; i++) {
-        const polygon3 = polygons[i];
-        const vertices = polygon3.vertices;
+        const polygon2 = polygons[i];
+        const vertices = polygon2.vertices;
         let cx = 0, cy = 0, cz = 0;
         for (let k = 0; k < vertices.length; k++) {
           cx += vertices[k][0];
@@ -11431,7 +11431,7 @@ var require_minkowskiSum = __commonJS({
         cx /= vertices.length;
         cy /= vertices.length;
         cz /= vertices.length;
-        const plane = poly3.plane(polygon3);
+        const plane = poly3.plane(polygon2);
         const nx = plane[0], ny = plane[1], nz = plane[2];
         const offset4 = 0.1;
         const apex = [
@@ -11527,14 +11527,14 @@ var require_scissionGeom3 = __commonJS({
       const pl = polygons.length;
       const indexesPerPoint = /* @__PURE__ */ new Map();
       const temp = vec3.create();
-      polygons.forEach((polygon3, index2) => {
-        polygon3.vertices.forEach((point) => {
+      polygons.forEach((polygon2, index2) => {
+        polygon2.vertices.forEach((point) => {
           insertMapping(indexesPerPoint, vec3.snap(temp, point, eps), index2);
         });
       });
-      const indexesPerPolygon = polygons.map((polygon3) => {
+      const indexesPerPolygon = polygons.map((polygon2) => {
         let indexes = [];
-        polygon3.vertices.forEach((point) => {
+        polygon2.vertices.forEach((point) => {
           indexes = indexes.concat(findMapping(indexesPerPoint, vec3.snap(temp, point, eps)));
         });
         return { e: 1, d: sortNb(indexes) };
@@ -11629,7 +11629,7 @@ var require_subtractGeom3 = __commonJS({
     var flatten = require_flatten();
     var retessellate = require_retessellate();
     var subtractSub = require_subtractGeom3Sub();
-    var subtract5 = (...geometries) => {
+    var subtract4 = (...geometries) => {
       geometries = flatten(geometries);
       let newgeometry = geometries.shift();
       geometries.forEach((geometry) => {
@@ -11638,7 +11638,7 @@ var require_subtractGeom3 = __commonJS({
       newgeometry = retessellate(newgeometry);
       return newgeometry;
     };
-    module.exports = subtract5;
+    module.exports = subtract4;
   }
 });
 
@@ -11652,14 +11652,14 @@ var require_subtractGeom2 = __commonJS({
     var fromFakePolygons = require_fromFakePolygons();
     var to3DWalls = require_to3DWalls();
     var subtractGeom3 = require_subtractGeom3();
-    var subtract5 = (...geometries) => {
+    var subtract4 = (...geometries) => {
       geometries = flatten(geometries);
       const newgeometries = geometries.map((geometry) => to3DWalls({ z0: -1, z1: 1 }, geometry));
       const newgeom3 = subtractGeom3(newgeometries);
       const epsilon = measureEpsilon(newgeom3);
       return fromFakePolygons(epsilon, geom3.toPolygons(newgeom3));
     };
-    module.exports = subtract5;
+    module.exports = subtract4;
   }
 });
 
@@ -11673,7 +11673,7 @@ var require_subtract4 = __commonJS({
     var geom3 = require_geom3();
     var subtractGeom2 = require_subtractGeom2();
     var subtractGeom3 = require_subtractGeom3();
-    var subtract5 = (...geometries) => {
+    var subtract4 = (...geometries) => {
       geometries = flatten(geometries);
       if (geometries.length === 0) throw new Error("wrong number of arguments");
       if (!areAllShapesTheSameType(geometries)) {
@@ -11684,7 +11684,7 @@ var require_subtract4 = __commonJS({
       if (geom3.isA(geometry)) return subtractGeom3(geometries);
       return geometry;
     };
-    module.exports = subtract5;
+    module.exports = subtract4;
   }
 });
 
@@ -11929,19 +11929,19 @@ var require_extrudePolygon = __commonJS({
         polygon1 = poly3.invert(polygon1);
       }
       const newpolygons = [polygon1];
-      const polygon22 = poly3.transform(mat4.fromTranslation(mat4.create(), offsetvector), polygon1);
+      const polygon2 = poly3.transform(mat4.fromTranslation(mat4.create(), offsetvector), polygon1);
       const numvertices = polygon1.vertices.length;
       for (let i = 0; i < numvertices; i++) {
         const nexti = i < numvertices - 1 ? i + 1 : 0;
         const sideFacePolygon = poly3.create([
           polygon1.vertices[i],
-          polygon22.vertices[i],
-          polygon22.vertices[nexti],
+          polygon2.vertices[i],
+          polygon2.vertices[nexti],
           polygon1.vertices[nexti]
         ]);
         newpolygons.push(sideFacePolygon);
       }
-      newpolygons.push(poly3.invert(polygon22));
+      newpolygons.push(poly3.invert(polygon2));
       return geom3.create(newpolygons);
     };
     module.exports = extrudePolygon;
@@ -12002,17 +12002,17 @@ var require_expandShell = __commonJS({
       const v1 = vec3.create();
       const v2 = vec3.create();
       const polygons = geom3.toPolygons(geometry);
-      polygons.forEach((polygon3, index2) => {
-        const extrudevector = vec3.scale(vec3.create(), poly3.plane(polygon3), 2 * delta);
-        const translatedpolygon = poly3.transform(mat4.fromTranslation(mat4.create(), vec3.scale(vec3.create(), extrudevector, -0.5)), polygon3);
+      polygons.forEach((polygon2, index2) => {
+        const extrudevector = vec3.scale(vec3.create(), poly3.plane(polygon2), 2 * delta);
+        const translatedpolygon = poly3.transform(mat4.fromTranslation(mat4.create(), vec3.scale(vec3.create(), extrudevector, -0.5)), polygon2);
         const extrudedface = extrudePolygon(extrudevector, translatedpolygon);
         result = unionGeom3Sub(result, extrudedface);
-        const vertices = polygon3.vertices;
+        const vertices = polygon2.vertices;
         for (let i = 0; i < vertices.length; i++) {
-          mapPlaneToVertex(vertices2planes, vertices[i], poly3.plane(polygon3));
+          mapPlaneToVertex(vertices2planes, vertices[i], poly3.plane(polygon2));
           const j = (i + 1) % vertices.length;
           const edge = [vertices[i], vertices[j]];
-          mapPlaneToEdge(edges2planes, edge, poly3.plane(polygon3));
+          mapPlaneToEdge(edges2planes, edge, poly3.plane(polygon2));
         }
       });
       edges2planes.forEach((item) => {
@@ -12066,8 +12066,8 @@ var require_expandShell = __commonJS({
               startfacevertices.push(p1);
               endfacevertices.push(p2);
               const points = [prevp2, p2, p1, prevp1];
-              const polygon3 = poly3.create(points);
-              polygons2.push(polygon3);
+              const polygon2 = poly3.create(points);
+              polygons2.push(polygon2);
             }
             prevp1 = p1;
             prevp2 = p2;
@@ -12269,7 +12269,7 @@ var require_offsetGeom2 = __commonJS({
       }
       const outlines = geom2.toOutlines(geometry);
       const newoutlines = outlines.map((outline) => {
-        const level = outlines.reduce((acc, polygon3) => acc + poly2.arePointsInside(outline, poly2.create(polygon3)), 0);
+        const level = outlines.reduce((acc, polygon2) => acc + poly2.arePointsInside(outline, poly2.create(polygon2)), 0);
         const outside = level % 2 === 0;
         options = {
           delta: outside ? delta : -delta,
@@ -12875,24 +12875,24 @@ var require_snapPolygons = __commonJS({
     "use strict";
     var vec3 = require_vec3();
     var poly3 = require_poly3();
-    var isValidPoly3 = (epsilon, polygon3) => {
-      const area = Math.abs(poly3.measureArea(polygon3));
+    var isValidPoly3 = (epsilon, polygon2) => {
+      const area = Math.abs(poly3.measureArea(polygon2));
       return Number.isFinite(area) && area > epsilon;
     };
     var snapPolygons = (epsilon, polygons) => {
-      let newpolygons = polygons.map((polygon3) => {
-        const snapvertices = polygon3.vertices.map((vertice) => vec3.snap(vec3.create(), vertice, epsilon));
+      let newpolygons = polygons.map((polygon2) => {
+        const snapvertices = polygon2.vertices.map((vertice) => vec3.snap(vec3.create(), vertice, epsilon));
         const newvertices = [];
         for (let i = 0; i < snapvertices.length; i++) {
           const j = (i + 1) % snapvertices.length;
           if (!vec3.equals(snapvertices[i], snapvertices[j])) newvertices.push(snapvertices[i]);
         }
         const newpolygon = poly3.create(newvertices);
-        if (polygon3.color) newpolygon.color = polygon3.color;
+        if (polygon2.color) newpolygon.color = polygon2.color;
         return newpolygon;
       });
       const epsilonArea = epsilon * epsilon * Math.sqrt(3) / 4;
-      newpolygons = newpolygons.filter((polygon3) => isValidPoly3(epsilonArea, polygon3));
+      newpolygons = newpolygons.filter((polygon2) => isValidPoly3(epsilonArea, polygon2));
       return newpolygons;
     };
     module.exports = snapPolygons;
@@ -12906,8 +12906,8 @@ var require_mergePolygons = __commonJS({
     var aboutEqualNormals = require_aboutEqualNormals();
     var vec3 = require_vec3();
     var poly3 = require_poly3();
-    var createEdges = (polygon3) => {
-      const points = poly3.toPoints(polygon3);
+    var createEdges = (polygon2) => {
+      const points = poly3.toPoints(polygon2);
       const edges = [];
       for (let i = 0; i < points.length; i++) {
         const j = (i + 1) % points.length;
@@ -12956,7 +12956,7 @@ var require_mergePolygons = __commonJS({
       return vec3.dot(d0, normal);
     };
     var createPolygonAnd = (edge) => {
-      let polygon3;
+      let polygon2;
       const points = [];
       while (edge.next) {
         const next = edge.next;
@@ -12967,8 +12967,8 @@ var require_mergePolygons = __commonJS({
         edge.prev = null;
         edge = next;
       }
-      if (points.length > 0) polygon3 = poly3.create(points);
-      return polygon3;
+      if (points.length > 0) polygon2 = poly3.create(points);
+      return polygon2;
     };
     var mergeCoplanarPolygons = (sourcepolygons) => {
       if (sourcepolygons.length < 2) return sourcepolygons;
@@ -12976,8 +12976,8 @@ var require_mergePolygons = __commonJS({
       const polygons = sourcepolygons.slice();
       const edgeList = /* @__PURE__ */ new Map();
       while (polygons.length > 0) {
-        const polygon3 = polygons.shift();
-        const edges = createEdges(polygon3);
+        const polygon2 = polygons.shift();
+        const edges = createEdges(polygon2);
         for (let i = 0; i < edges.length; i++) {
           const current = edges[i];
           const opposite = findOppositeEdge(edgeList, current);
@@ -13033,8 +13033,8 @@ var require_mergePolygons = __commonJS({
       }
       const destpolygons = [];
       edgeList.forEach((edge) => {
-        const polygon3 = createPolygonAnd(edge);
-        if (polygon3) destpolygons.push(polygon3);
+        const polygon2 = createPolygonAnd(edge);
+        if (polygon2) destpolygons.push(polygon2);
       });
       edgeList.clear();
       return destpolygons;
@@ -13047,13 +13047,13 @@ var require_mergePolygons = __commonJS({
     };
     var mergePolygons = (epsilon, polygons) => {
       const polygonsPerPlane = [];
-      polygons.forEach((polygon3) => {
-        const mapping = polygonsPerPlane.find((element) => coplanar(element[0], poly3.plane(polygon3)));
+      polygons.forEach((polygon2) => {
+        const mapping = polygonsPerPlane.find((element) => coplanar(element[0], poly3.plane(polygon2)));
         if (mapping) {
           const polygons2 = mapping[1];
-          polygons2.push(polygon3);
+          polygons2.push(polygon2);
         } else {
-          polygonsPerPlane.push([poly3.plane(polygon3), [polygon3]]);
+          polygonsPerPlane.push([poly3.plane(polygon2), [polygon2]]);
         }
       });
       let destpolygons = [];
@@ -13149,15 +13149,15 @@ var require_insertTjunctions = __commonJS({
     var insertTjunctions = (polygons) => {
       const sidemap = /* @__PURE__ */ new Map();
       for (let polygonindex = 0; polygonindex < polygons.length; polygonindex++) {
-        const polygon3 = polygons[polygonindex];
-        const numvertices = polygon3.vertices.length;
+        const polygon2 = polygons[polygonindex];
+        const numvertices = polygon2.vertices.length;
         if (numvertices >= 3) {
-          let vertex = polygon3.vertices[0];
+          let vertex = polygon2.vertices[0];
           let vertextag = getTag(vertex);
           for (let vertexindex = 0; vertexindex < numvertices; vertexindex++) {
             let nextvertexindex = vertexindex + 1;
             if (nextvertexindex === numvertices) nextvertexindex = 0;
-            const nextvertex = polygon3.vertices[nextvertexindex];
+            const nextvertex = polygon2.vertices[nextvertexindex];
             const nextvertextag = getTag(nextvertex);
             const sidetag = `${vertextag}/${nextvertextag}`;
             const reversesidetag = `${nextvertextag}/${vertextag}`;
@@ -13265,17 +13265,17 @@ var require_insertTjunctions = __commonJS({
                       const distancesquared = vec3.squaredDistance(closestpoint, endpos);
                       if (distancesquared < constants.EPS * constants.EPS) {
                         const polygonindex = matchingside.polygonindex;
-                        const polygon3 = newpolygons[polygonindex];
+                        const polygon2 = newpolygons[polygonindex];
                         const insertionvertextag = getTag(matchingside.vertex1);
                         let insertionvertextagindex = -1;
-                        for (let i = 0; i < polygon3.vertices.length; i++) {
-                          if (getTag(polygon3.vertices[i]) === insertionvertextag) {
+                        for (let i = 0; i < polygon2.vertices.length; i++) {
+                          if (getTag(polygon2.vertices[i]) === insertionvertextag) {
                             insertionvertextagindex = i;
                             break;
                           }
                         }
                         if (assert && insertionvertextagindex < 0) throw new Error("assert failed");
-                        const newvertices = polygon3.vertices.slice(0);
+                        const newvertices = polygon2.vertices.slice(0);
                         newvertices.splice(insertionvertextagindex, 0, endvertex);
                         const newpolygon = poly3.create(newvertices);
                         newpolygons[polygonindex] = newpolygon;
@@ -13315,35 +13315,35 @@ var require_triangulatePolygons = __commonJS({
     "use strict";
     var vec3 = require_vec3();
     var poly3 = require_poly3();
-    var triangulatePolygon = (epsilon, polygon3, triangles) => {
-      const nv = polygon3.vertices.length;
+    var triangulatePolygon = (epsilon, polygon2, triangles) => {
+      const nv = polygon2.vertices.length;
       if (nv > 3) {
         if (nv > 4) {
           const midpoint2 = [0, 0, 0];
-          polygon3.vertices.forEach((vertice) => vec3.add(midpoint2, midpoint2, vertice));
+          polygon2.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([midpoint2, polygon3.vertices[i], polygon3.vertices[(i + 1) % nv]]);
-            if (polygon3.color) poly.color = polygon3.color;
+            const poly = poly3.create([midpoint2, polygon2.vertices[i], polygon2.vertices[(i + 1) % nv]]);
+            if (polygon2.color) poly.color = polygon2.color;
             triangles.push(poly);
           }
           return;
         }
-        const poly0 = poly3.create([polygon3.vertices[0], polygon3.vertices[1], polygon3.vertices[2]]);
-        const poly1 = poly3.create([polygon3.vertices[0], polygon3.vertices[2], polygon3.vertices[3]]);
-        if (polygon3.color) {
-          poly0.color = polygon3.color;
-          poly1.color = polygon3.color;
+        const poly0 = poly3.create([polygon2.vertices[0], polygon2.vertices[1], polygon2.vertices[2]]);
+        const poly1 = poly3.create([polygon2.vertices[0], polygon2.vertices[2], polygon2.vertices[3]]);
+        if (polygon2.color) {
+          poly0.color = polygon2.color;
+          poly1.color = polygon2.color;
         }
         triangles.push(poly0, poly1);
         return;
       }
-      triangles.push(polygon3);
+      triangles.push(polygon2);
     };
     var triangulatePolygons = (epsilon, polygons) => {
       const triangles = [];
-      polygons.forEach((polygon3) => {
-        triangulatePolygon(epsilon, polygon3, triangles);
+      polygons.forEach((polygon2) => {
+        triangulatePolygon(epsilon, polygon2, triangles);
       });
       return triangles;
     };
@@ -23981,8 +23981,8 @@ var SmdChipLead = (props) => {
   const { thickness, width: width10, padContactLength, bodyDistance, height: height10, rotation } = props;
   const N = 15;
   const points = Array.from({ length: N }).map((_, i) => i / (N - 1) * bodyDistance).map((x) => [x, calculateSCurve(x, props)]);
-  const polygon3 = getExpandedStroke(points, thickness);
-  return /* @__PURE__ */ jsx2(Colorize, { color: "#fff", children: /* @__PURE__ */ jsx2(Translate, { offset: { z: 0, y: 0, x: 0, ...props.position }, children: /* @__PURE__ */ jsx2(Rotate, { rotation: ["90deg", 0, rotation ?? 0], children: /* @__PURE__ */ jsx2(Translate, { offset: { x: 0, y: 0, z: -width10 / 2 }, children: /* @__PURE__ */ jsx2(ExtrudeLinear, { height: width10, children: /* @__PURE__ */ jsx2(Polygon, { points: polygon3.map((p) => [p.x, p.y]) }) }) }) }) }) });
+  const polygon2 = getExpandedStroke(points, thickness);
+  return /* @__PURE__ */ jsx2(Colorize, { color: "#fff", children: /* @__PURE__ */ jsx2(Translate, { offset: { z: 0, y: 0, x: 0, ...props.position }, children: /* @__PURE__ */ jsx2(Rotate, { rotation: ["90deg", 0, rotation ?? 0], children: /* @__PURE__ */ jsx2(Translate, { offset: { x: 0, y: 0, z: -width10 / 2 }, children: /* @__PURE__ */ jsx2(ExtrudeLinear, { height: width10, children: /* @__PURE__ */ jsx2(Polygon, { points: polygon2.map((p) => [p.x, p.y]) }) }) }) }) }) });
 };
 var Tssop = ({
   pinCount,
@@ -25262,7 +25262,7 @@ var PushButtonLeg = (props) => {
     [-verticalLength / 5, horizontalLength / 4],
     [0, 0]
   ];
-  const polygon3 = getExpandedStroke(points, thickness);
+  const polygon2 = getExpandedStroke(points, thickness);
   return /* @__PURE__ */ jsx2(Colorize, { color: "#f2f2f2", children: /* @__PURE__ */ jsx2(
     Translate,
     {
@@ -25271,7 +25271,7 @@ var PushButtonLeg = (props) => {
         y: position?.y || 0,
         z: position?.z || 0
       },
-      children: /* @__PURE__ */ jsx2(Rotate, { rotation: [0, 55, rotation], children: /* @__PURE__ */ jsx2(ExtrudeLinear, { height: width10, children: /* @__PURE__ */ jsx2(Polygon, { points: polygon3.map((p) => [p.y, p.x]) }) }) })
+      children: /* @__PURE__ */ jsx2(Rotate, { rotation: [0, 55, rotation], children: /* @__PURE__ */ jsx2(ExtrudeLinear, { height: width10, children: /* @__PURE__ */ jsx2(Polygon, { points: polygon2.map((p) => [p.y, p.x]) }) }) })
     }
   ) });
 };
@@ -28421,8 +28421,8 @@ function convertCSGToThreeGeom(csg) {
     const indices = [];
     const colors2 = [];
     let idx = 0;
-    for (const polygon3 of csg.polygons) {
-      for (const vertex of polygon3.vertices) {
+    for (const polygon2 of csg.polygons) {
+      for (const vertex of polygon2.vertices) {
         vertex.index = idx;
         vertices.push(vertex[0], vertex[1], vertex[2]);
         if (csg.color && csg.color.length >= 3) {
@@ -28432,10 +28432,10 @@ function convertCSGToThreeGeom(csg) {
         }
         idx++;
       }
-      const first = polygon3.vertices[0].index;
-      for (let i = 2; i < polygon3.vertices.length; i++) {
-        const second = polygon3.vertices[i - 1].index;
-        const third = polygon3.vertices[i].index;
+      const first = polygon2.vertices[0].index;
+      for (let i = 2; i < polygon2.vertices.length; i++) {
+        const second = polygon2.vertices[i - 1].index;
+        const third = polygon2.vertices[i].index;
         indices.push(first, second, third);
       }
     }
@@ -29732,7 +29732,7 @@ import * as THREE16 from "three";
 // package.json
 var package_default = {
   name: "@tscircuit/3d-viewer",
-  version: "0.0.538",
+  version: "0.0.539",
   main: "./dist/index.js",
   module: "./dist/index.js",
   type: "module",
@@ -32594,7 +32594,7 @@ import { su as su8 } from "@tscircuit/circuit-json-util";
 import { useEffect as useEffect24, useMemo as useMemo19 } from "react";
 
 // src/textures/create-combined-board-textures.ts
-import * as THREE28 from "three";
+import * as THREE29 from "three";
 
 // node_modules/@tscircuit/math-utils/dist/chunk-5N7UJNVK.js
 var getBoundsFromPoints = (points) => {
@@ -33058,11 +33058,128 @@ function createCopperTextTextureForLayer({
   return texture;
 }
 
-// src/textures/create-fabrication-note-texture-for-layer.ts
+// src/textures/create-copper-pour-texture-for-layer.ts
 import * as THREE23 from "three";
+import { CircuitToCanvasDrawer as CircuitToCanvasDrawer4 } from "circuit-to-canvas";
+var toRgb = (colorArr) => {
+  const [r = 0, g = 0, b = 0] = colorArr;
+  return `rgb(${Math.round(r * 255)}, ${Math.round(g * 255)}, ${Math.round(
+    b * 255
+  )})`;
+};
+var COPPER_POUR_OPACITY_COMPENSATION_PASSES = 8;
+function createCopperPourTextureForLayer({
+  layer,
+  circuitJson,
+  boardData,
+  traceTextureResolution = TRACE_TEXTURE_RESOLUTION,
+  copperColor = toRgb(colors.copper)
+}) {
+  const copperPours = circuitJson.filter(
+    (e) => e.type === "pcb_copper_pour"
+  );
+  const pcbRenderLayer = layer === "top" ? "top_copper" : "bottom_copper";
+  const poursOnLayer = copperPours.filter((p) => p.layer === layer);
+  if (poursOnLayer.length === 0) return null;
+  const boardOutlineBounds = calculateOutlineBounds(boardData);
+  const canvas = document.createElement("canvas");
+  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");
+  if (!ctx) return null;
+  if (layer === "bottom") {
+    ctx.translate(0, canvasHeight);
+    ctx.scale(1, -1);
+  }
+  const transparent = "rgba(0,0,0,0)";
+  const coveredColor = copperColor;
+  const uncoveredColor = copperColor;
+  const setColorAndDraw = (pours, copperPourColor) => {
+    if (pours.length === 0) return;
+    const drawer = new CircuitToCanvasDrawer4(ctx);
+    drawer.configure({
+      colorOverrides: {
+        copper: {
+          top: copperPourColor,
+          bottom: copperPourColor,
+          inner1: copperPourColor,
+          inner2: copperPourColor,
+          inner3: copperPourColor,
+          inner4: copperPourColor,
+          inner5: copperPourColor,
+          inner6: copperPourColor
+        },
+        copperPour: {
+          top: transparent,
+          bottom: transparent
+        },
+        drill: transparent,
+        boardOutline: transparent,
+        substrate: transparent,
+        keepout: transparent,
+        fabricationNote: transparent,
+        courtyard: { top: transparent, bottom: transparent },
+        silkscreen: { top: transparent, bottom: transparent },
+        soldermask: { top: transparent, bottom: transparent },
+        soldermaskWithCopperUnderneath: {
+          top: transparent,
+          bottom: transparent
+        },
+        soldermaskOverCopper: {
+          top: transparent,
+          bottom: transparent
+        }
+      }
+    });
+    drawer.setCameraBounds({
+      minX: boardOutlineBounds.minX,
+      maxX: boardOutlineBounds.maxX,
+      minY: boardOutlineBounds.minY,
+      maxY: boardOutlineBounds.maxY
+    });
+    drawer.drawElements(pours, {
+      layers: [pcbRenderLayer],
+      drawSoldermask: false,
+      drawSoldermaskTop: false,
+      drawSoldermaskBottom: false
+    });
+    for (let i = 1; i < COPPER_POUR_OPACITY_COMPENSATION_PASSES; i += 1) {
+      drawer.drawElements(pours, {
+        layers: [pcbRenderLayer],
+        drawSoldermask: false,
+        drawSoldermaskTop: false,
+        drawSoldermaskBottom: false
+      });
+    }
+  };
+  const coveredPours = poursOnLayer.filter(
+    (p) => p.covered_with_solder_mask !== false
+  );
+  const uncoveredPours = poursOnLayer.filter(
+    (p) => p.covered_with_solder_mask === false
+  );
+  setColorAndDraw(coveredPours, coveredColor);
+  setColorAndDraw(uncoveredPours, uncoveredColor);
+  const texture = new THREE23.CanvasTexture(canvas);
+  texture.generateMipmaps = true;
+  texture.minFilter = THREE23.LinearMipmapLinearFilter;
+  texture.magFilter = THREE23.LinearFilter;
+  texture.anisotropy = 16;
+  texture.needsUpdate = true;
+  return texture;
+}
+
+// src/textures/create-fabrication-note-texture-for-layer.ts
+import * as THREE24 from "three";
 
 // src/textures/fabrication-note/fabrication-note-drawing.ts
-import { CircuitToCanvasDrawer as CircuitToCanvasDrawer4 } from "circuit-to-canvas";
+import { CircuitToCanvasDrawer as CircuitToCanvasDrawer5 } from "circuit-to-canvas";
 
 // src/utils/units.ts
 var MM_PER_INCH = 25.4;
@@ -33160,7 +33277,7 @@ var drawFabricationNoteLayer = ({
 }) => {
   const renderLayer = `${layer}_fabrication_note`;
   const normalizedElements = elements.map(normalizeFabricationElement);
-  const drawer = new CircuitToCanvasDrawer4(ctx);
+  const drawer = new CircuitToCanvasDrawer5(ctx);
   drawer.configure({
     colorOverrides: {
       copper: {
@@ -33286,20 +33403,20 @@ function createFabricationNoteTextureForLayer({
     bounds,
     elements
   });
-  const texture = new THREE23.CanvasTexture(canvas);
+  const texture = new THREE24.CanvasTexture(canvas);
   texture.generateMipmaps = true;
-  texture.minFilter = THREE23.LinearMipmapLinearFilter;
-  texture.magFilter = THREE23.LinearFilter;
+  texture.minFilter = THREE24.LinearMipmapLinearFilter;
+  texture.magFilter = THREE24.LinearFilter;
   texture.anisotropy = 16;
   texture.needsUpdate = true;
   return texture;
 }
 
 // src/textures/create-pcb-note-texture-for-layer.ts
-import * as THREE24 from "three";
+import * as THREE25 from "three";
 
 // src/textures/pcb-note/pcb-note-drawing.ts
-import { CircuitToCanvasDrawer as CircuitToCanvasDrawer5 } from "circuit-to-canvas";
+import { CircuitToCanvasDrawer as CircuitToCanvasDrawer6 } from "circuit-to-canvas";
 var TRANSPARENT2 = "rgba(0,0,0,0)";
 var setDrawerBounds3 = (drawer, bounds) => {
   drawer.setCameraBounds({
@@ -33378,7 +33495,7 @@ var drawPcbNoteLayer = ({
   elements
 }) => {
   const normalizedElements = elements.map(normalizePcbNoteElement);
-  const drawer = new CircuitToCanvasDrawer5(ctx);
+  const drawer = new CircuitToCanvasDrawer6(ctx);
   drawer.configure({
     colorOverrides: {
       copper: {
@@ -33447,20 +33564,20 @@ function createPcbNoteTextureForLayer({
     bounds,
     elements
   });
-  const texture = new THREE24.CanvasTexture(canvas);
+  const texture = new THREE25.CanvasTexture(canvas);
   texture.generateMipmaps = true;
-  texture.minFilter = THREE24.LinearMipmapLinearFilter;
-  texture.magFilter = THREE24.LinearFilter;
+  texture.minFilter = THREE25.LinearMipmapLinearFilter;
+  texture.magFilter = THREE25.LinearFilter;
   texture.anisotropy = 16;
   texture.needsUpdate = true;
   return texture;
 }
 
 // src/textures/create-silkscreen-texture-for-layer.ts
-import * as THREE25 from "three";
+import * as THREE26 from "three";
 
 // src/textures/silkscreen/silkscreen-drawing.ts
-import { CircuitToCanvasDrawer as CircuitToCanvasDrawer6 } from "circuit-to-canvas";
+import { CircuitToCanvasDrawer as CircuitToCanvasDrawer7 } from "circuit-to-canvas";
 var FABRICATION_NOTE_COLOR2 = "rgb(255,243,204)";
 var TRANSPARENT3 = "rgba(0,0,0,0)";
 var setDrawerBounds4 = (drawer, bounds) => {
@@ -33479,7 +33596,7 @@ var drawSilkscreenLayer = ({
   silkscreenColor
 }) => {
   const renderLayer = layer === "top" ? "top_silkscreen" : "bottom_silkscreen";
-  const drawer = new CircuitToCanvasDrawer6(ctx);
+  const drawer = new CircuitToCanvasDrawer7(ctx);
   drawer.configure({
     colorOverrides: {
       copper: {
@@ -33566,35 +33683,35 @@ function createSilkscreenTextureForLayer({
     elements,
     silkscreenColor
   });
-  const texture = new THREE25.CanvasTexture(canvas);
+  const texture = new THREE26.CanvasTexture(canvas);
   texture.generateMipmaps = true;
-  texture.minFilter = THREE25.LinearMipmapLinearFilter;
-  texture.magFilter = THREE25.LinearFilter;
+  texture.minFilter = THREE26.LinearMipmapLinearFilter;
+  texture.magFilter = THREE26.LinearFilter;
   texture.anisotropy = 16;
   texture.needsUpdate = true;
   return texture;
 }
 
 // src/textures/create-soldermask-texture-for-layer.ts
-import * as THREE26 from "three";
+import * as THREE27 from "three";
 
 // src/textures/soldermask/soldermask-drawing.ts
-import { CircuitToCanvasDrawer as CircuitToCanvasDrawer7 } from "circuit-to-canvas";
-var toRgb = (colorArr) => {
+import { CircuitToCanvasDrawer as CircuitToCanvasDrawer8 } from "circuit-to-canvas";
+var toRgb2 = (colorArr) => {
   const [r = 0, g = 0, b = 0] = colorArr;
   return `rgb(${Math.round(r * 255)}, ${Math.round(g * 255)}, ${Math.round(
     b * 255
   )})`;
 };
 var getSoldermaskPalette = (material) => {
-  const soldermask = toRgb(
+  const soldermask = toRgb2(
     soldermaskColors[material] ?? colors.fr4SolderMaskGreen
   );
-  const soldermaskOverCopper = material === "fr1" ? toRgb(colors.fr1TracesWithMaskCopper) : toRgb(colors.fr4TracesWithMaskGreen);
+  const soldermaskOverCopper = material === "fr1" ? toRgb2(colors.fr1TracesWithMaskCopper) : toRgb2(colors.fr4TracesWithMaskGreen);
   return {
     soldermask,
     soldermaskOverCopper,
-    copper: toRgb(colors.copper),
+    copper: toRgb2(colors.copper),
     transparent: "rgba(0,0,0,0)"
   };
 };
@@ -33615,7 +33732,7 @@ var drawSoldermaskLayer = ({
 }) => {
   const palette = getSoldermaskPalette(boardMaterial);
   const copperRenderLayer = layer === "top" ? "top_copper" : "bottom_copper";
-  const drawer = new CircuitToCanvasDrawer7(ctx);
+  const drawer = new CircuitToCanvasDrawer8(ctx);
   drawer.configure({
     colorOverrides: {
       copper: {
@@ -33659,7 +33776,7 @@ var drawSoldermaskLayer = ({
   if (uncoveredPours.length > 0) {
     ctx.save();
     ctx.globalCompositeOperation = "destination-out";
-    const cutoutDrawer = new CircuitToCanvasDrawer7(ctx);
+    const cutoutDrawer = new CircuitToCanvasDrawer8(ctx);
     cutoutDrawer.configure({
       colorOverrides: {
         copper: {
@@ -33708,20 +33825,20 @@ function createSoldermaskTextureForLayer({
     elements,
     boardMaterial: boardData.material
   });
-  const texture = new THREE26.CanvasTexture(canvas);
+  const texture = new THREE27.CanvasTexture(canvas);
   texture.generateMipmaps = true;
-  texture.minFilter = THREE26.LinearMipmapLinearFilter;
-  texture.magFilter = THREE26.LinearFilter;
+  texture.minFilter = THREE27.LinearMipmapLinearFilter;
+  texture.magFilter = THREE27.LinearFilter;
   texture.anisotropy = 16;
   texture.needsUpdate = true;
   return texture;
 }
 
 // src/textures/create-through-hole-texture-for-layer.ts
-import * as THREE27 from "three";
+import * as THREE28 from "three";
 
 // src/textures/through-hole/through-hole-drawing.ts
-import { CircuitToCanvasDrawer as CircuitToCanvasDrawer8 } from "circuit-to-canvas";
+import { CircuitToCanvasDrawer as CircuitToCanvasDrawer9 } from "circuit-to-canvas";
 var setDrawerBounds6 = (drawer, bounds) => {
   drawer.setCameraBounds({
     minX: bounds.minX,
@@ -33739,7 +33856,7 @@ var drawThroughHoleLayer = ({
 }) => {
   const renderLayer = layer === "top" ? "top_copper" : "bottom_copper";
   const transparent = "rgba(0,0,0,0)";
-  const drawer = new CircuitToCanvasDrawer8(ctx);
+  const drawer = new CircuitToCanvasDrawer9(ctx);
   drawer.configure({
     colorOverrides: {
       copper: {
@@ -33811,17 +33928,17 @@ function createThroughHoleTextureForLayer({
     elements,
     copperColor
   });
-  const texture = new THREE27.CanvasTexture(canvas);
+  const texture = new THREE28.CanvasTexture(canvas);
   texture.generateMipmaps = true;
-  texture.minFilter = THREE27.LinearMipmapLinearFilter;
-  texture.magFilter = THREE27.LinearFilter;
+  texture.minFilter = THREE28.LinearMipmapLinearFilter;
+  texture.magFilter = THREE28.LinearFilter;
   texture.anisotropy = 16;
   texture.needsUpdate = true;
   return texture;
 }
 
 // src/textures/create-combined-board-textures.ts
-var toRgb2 = (colorArr) => {
+var toRgb3 = (colorArr) => {
   const [r = 0, g = 0, b = 0] = colorArr;
   return `rgb(${Math.round(r * 255)}, ${Math.round(g * 255)}, ${Math.round(
     b * 255
@@ -33852,10 +33969,10 @@ var createCombinedTexture = ({
     const image = texture.image;
     ctx.drawImage(image, 0, 0, canvasWidth, canvasHeight);
   });
-  const combinedTexture = new THREE28.CanvasTexture(canvas);
+  const combinedTexture = new THREE29.CanvasTexture(canvas);
   combinedTexture.generateMipmaps = false;
-  combinedTexture.minFilter = THREE28.LinearFilter;
-  combinedTexture.magFilter = THREE28.LinearFilter;
+  combinedTexture.minFilter = THREE29.LinearFilter;
+  combinedTexture.magFilter = THREE29.LinearFilter;
   combinedTexture.premultiplyAlpha = true;
   combinedTexture.anisotropy = 16;
   combinedTexture.needsUpdate = true;
@@ -33867,9 +33984,9 @@ function createCombinedBoardTextures({
   traceTextureResolution,
   visibility
 }) {
-  const traceColor = toRgb2(colors.copper);
+  const traceColor = toRgb3(colors.copper);
   const silkscreenColor = "rgb(255,255,255)";
-  const copperColor = toRgb2(colors.copper);
+  const copperColor = toRgb3(colors.copper);
   const showBoardBody = visibility?.boardBody ?? true;
   const buildForLayer = (layer) => {
     const showMask = (layer === "top" ? visibility?.topMask : visibility?.bottomMask) ?? true;
@@ -33888,6 +34005,13 @@ function createCombinedBoardTextures({
       traceColor,
       traceTextureResolution
     }) : null;
+    const copperPourTexture = showCopper ? createCopperPourTextureForLayer({
+      layer,
+      circuitJson,
+      boardData,
+      traceTextureResolution,
+      copperColor
+    }) : null;
     const copperTextTexture = showCopper ? createCopperTextTextureForLayer({
       layer,
       circuitJson,
@@ -33937,6 +34061,7 @@ function createCombinedBoardTextures({
     }) : null;
     return createCombinedTexture({
       textures: [
+        copperPourTexture,
         traceTexture,
         padTexture,
         throughHoleTexture,
@@ -33958,14 +34083,6 @@ function createCombinedBoardTextures({
   };
 }
 
-// src/textures/create-copper-pour-texture-for-layer.ts
-import * as THREE29 from "three";
-import { CircuitToCanvasDrawer as CircuitToCanvasDrawer9 } from "circuit-to-canvas";
-
-// src/geoms/brep-converter.ts
-var import_primitives7 = __toESM(require_primitives(), 1);
-var import_booleans5 = __toESM(require_booleans(), 1);
-
 // src/textures/create-three-texture-meshes.ts
 import * as THREE30 from "three";
 function createTexturePlane(config, boardData) {
@@ -41652,12 +41769,12 @@ function getNextMatch(values, search, currentMatch) {
   );
   return nextMatch !== currentMatch ? nextMatch : void 0;
 }
-function isPointInPolygon(point, polygon3) {
+function isPointInPolygon(point, polygon2) {
   const { x, y } = point;
   let inside = false;
-  for (let i = 0, j = polygon3.length - 1; i < polygon3.length; j = i++) {
-    const ii = polygon3[i];
-    const jj = polygon3[j];
+  for (let i = 0, j = polygon2.length - 1; i < polygon2.length; j = i++) {
+    const ii = polygon2[i];
+    const jj = polygon2[j];
     const xi = ii.x;
     const yi = ii.y;
     const xj = jj.x;
@@ -43124,17 +43241,17 @@ function createGeometryFromPolygons(polygons) {
   const geometry = new BufferGeometry4();
   const vertices = [];
   const normals = [];
-  for (const polygon3 of polygons) {
-    for (let i = 1; i < polygon3.vertices.length - 1; i++) {
+  for (const polygon2 of polygons) {
+    for (let i = 1; i < polygon2.vertices.length - 1; i++) {
       vertices.push(
-        ...polygon3.vertices[0],
-        ...polygon3.vertices[i],
-        ...polygon3.vertices[i + 1]
+        ...polygon2.vertices[0],
+        ...polygon2.vertices[i],
+        ...polygon2.vertices[i + 1]
         // Third vertex
       );
-      const v1 = new THREE40.Vector3(...polygon3.vertices[0]);
-      const v2 = new THREE40.Vector3(...polygon3.vertices[i]);
-      const v3 = new THREE40.Vector3(...polygon3.vertices[i + 1]);
+      const v1 = new THREE40.Vector3(...polygon2.vertices[0]);
+      const v2 = new THREE40.Vector3(...polygon2.vertices[i]);
+      const v3 = new THREE40.Vector3(...polygon2.vertices[i + 1]);
       const normal = new THREE40.Vector3().crossVectors(
         new THREE40.Vector3().subVectors(v2, v1),
         new THREE40.Vector3().subVectors(v3, v1)