circuit-json-to-gltf 0.0.35 → 0.0.37

package/dist/index.js

@@ -740,7 +740,7 @@ var require_orthogonal = __commonJS({
 var require_rotateX = __commonJS({
   "node_modules/@jscad/modeling/src/maths/vec3/rotateX.js"(exports, module) {
     "use strict";
-    var rotateX2 = (out, vector, origin, radians) => {
+    var rotateX3 = (out, vector, origin, radians) => {
       const p = [];
       const r = [];
       p[0] = vector[0] - origin[0];
@@ -754,7 +754,7 @@ var require_rotateX = __commonJS({
       out[2] = r[2] + origin[2];
       return out;
     };
-    module.exports = rotateX2;
+    module.exports = rotateX3;
   }
 });
 
@@ -1258,7 +1258,7 @@ var require_rotateX2 = __commonJS({
   "node_modules/@jscad/modeling/src/maths/mat4/rotateX.js"(exports, module) {
     "use strict";
     var { sin, cos } = require_trigonometry();
-    var rotateX2 = (out, matrix, radians) => {
+    var rotateX3 = (out, matrix, radians) => {
       const s = sin(radians);
       const c = cos(radians);
       const a10 = matrix[4];
@@ -1289,7 +1289,7 @@ var require_rotateX2 = __commonJS({
       out[11] = a23 * c - a13 * s;
       return out;
     };
-    module.exports = rotateX2;
+    module.exports = rotateX3;
   }
 });
 
@@ -1443,7 +1443,7 @@ var require_toString2 = __commonJS({
 var require_translate = __commonJS({
   "node_modules/@jscad/modeling/src/maths/mat4/translate.js"(exports, module) {
     "use strict";
-    var translate3 = (out, matrix, offsets) => {
+    var translate4 = (out, matrix, offsets) => {
       const x = offsets[0];
       const y = offsets[1];
       const z = offsets[2];
@@ -1496,7 +1496,7 @@ var require_translate = __commonJS({
       }
       return out;
     };
-    module.exports = translate3;
+    module.exports = translate4;
   }
 });
 
@@ -3833,11 +3833,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 = (polygon4) => {
+      const vertices = polygon4.vertices.slice().reverse();
       const inverted = create(vertices);
-      if (polygon3.plane) {
-        inverted.plane = plane.flip(plane.create(), polygon3.plane);
+      if (polygon4.plane) {
+        inverted.plane = plane.flip(plane.create(), polygon4.plane);
       }
       return inverted;
     };
@@ -3869,7 +3869,7 @@ var require_isConvex = __commonJS({
     "use strict";
     var plane = require_plane();
     var vec3 = require_vec3();
-    var isConvex = (polygon3) => areVerticesConvex(polygon3.vertices);
+    var isConvex = (polygon4) => areVerticesConvex(polygon4.vertices);
     var areVerticesConvex = (vertices) => {
       const numvertices = vertices.length;
       if (numvertices > 2) {
@@ -3905,11 +3905,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 = (polygon4) => {
+      if (!polygon4.plane) {
+        polygon4.plane = mplane.fromPoints(mplane.create(), ...polygon4.vertices);
       }
-      return polygon3.plane;
+      return polygon4.plane;
     };
     module.exports = plane;
   }
@@ -3920,13 +3920,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 = (polygon4) => {
+      const n = polygon4.vertices.length;
       if (n < 3) {
         return 0;
       }
-      const vertices = polygon3.vertices;
-      const normal = plane(polygon3);
+      const vertices = polygon4.vertices;
+      const normal = plane(polygon4);
       const ax = Math.abs(normal[0]);
       const ay = Math.abs(normal[1]);
       const az = Math.abs(normal[2]);
@@ -3985,8 +3985,8 @@ var require_measureBoundingBox = __commonJS({
   "node_modules/@jscad/modeling/src/geometries/poly3/measureBoundingBox.js"(exports, module) {
     "use strict";
     var vec3 = require_vec3();
-    var measureBoundingBox2 = (polygon3) => {
-      const vertices = polygon3.vertices;
+    var measureBoundingBox3 = (polygon4) => {
+      const vertices = polygon4.vertices;
       const numvertices = vertices.length;
       const min = numvertices === 0 ? vec3.create() : vec3.clone(vertices[0]);
       const max = vec3.clone(min);
@@ -3996,7 +3996,7 @@ var require_measureBoundingBox = __commonJS({
       }
       return [min, max];
     };
-    module.exports = measureBoundingBox2;
+    module.exports = measureBoundingBox3;
   }
 });
 
@@ -4064,10 +4064,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 = (polygon4) => {
+      const boundingSphere = cache.get(polygon4);
       if (boundingSphere) return boundingSphere;
-      const vertices = polygon3.vertices;
+      const vertices = polygon4.vertices;
       const out = vec4.create();
       if (vertices.length === 0) {
         out[0] = 0;
@@ -4097,7 +4097,7 @@ var require_measureBoundingSphere = __commonJS({
       const y = out[1] - maxy[1];
       const z = out[2] - maxz[2];
       out[3] = Math.sqrt(x * x + y * y + z * z);
-      cache.set(polygon3, out);
+      cache.set(polygon4, out);
       return out;
     };
     module.exports = measureBoundingSphere;
@@ -4109,9 +4109,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 = (polygon4) => {
       let signedVolume = 0;
-      const vertices = polygon3.vertices;
+      const vertices = polygon4.vertices;
       const cross = vec3.create();
       for (let i = 0; i < vertices.length - 2; i++) {
         vec3.cross(cross, vertices[i + 1], vertices[i + 2]);
@@ -4128,7 +4128,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 = (polygon4) => polygon4.vertices;
     module.exports = toPoints;
   }
 });
@@ -4138,9 +4138,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 = (polygon4) => {
       let result = "poly3: vertices: [";
-      polygon3.vertices.forEach((vertex) => {
+      polygon4.vertices.forEach((vertex) => {
         result += `${vec3.toString(vertex)}, `;
       });
       result += "]";
@@ -4157,8 +4157,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, polygon4) => {
+      const vertices = polygon4.vertices.map((vertex) => vec3.transform(vec3.create(), vertex, matrix));
       if (mat4.isMirroring(matrix)) {
         vertices.reverse();
       }
@@ -4274,8 +4274,8 @@ var require_fromPoints4 = __commonJS({
         throw new Error("the given points must be an array");
       }
       const polygons = listofpoints.map((points, index) => {
-        const polygon3 = poly3.create(points);
-        return polygon3;
+        const polygon4 = poly3.create(points);
+        return polygon4;
       });
       const result = create(polygons);
       return result;
@@ -4326,7 +4326,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((polygon4) => poly3.transform(geometry.transforms, polygon4));
       geometry.transforms = mat4.create();
       return geometry;
     };
@@ -4353,7 +4353,7 @@ var require_invert3 = __commonJS({
     var toPolygons2 = require_toPolygons();
     var invert = (geometry) => {
       const polygons = toPolygons2(geometry);
-      const newpolygons = polygons.map((polygon3) => poly3.invert(polygon3));
+      const newpolygons = polygons.map((polygon4) => poly3.invert(polygon4));
       return create(newpolygons);
     };
     module.exports = invert;
@@ -4386,7 +4386,7 @@ var require_toPoints3 = __commonJS({
     var toPolygons2 = require_toPolygons();
     var toPoints = (geometry) => {
       const polygons = toPolygons2(geometry);
-      const listofpoints = polygons.map((polygon3) => poly3.toPoints(polygon3));
+      const listofpoints = polygons.map((polygon4) => poly3.toPoints(polygon4));
       return listofpoints;
     };
     module.exports = toPoints;
@@ -4402,8 +4402,8 @@ var require_toString7 = __commonJS({
     var toString = (geometry) => {
       const polygons = toPolygons2(geometry);
       let result = "geom3 (" + polygons.length + " polygons):\n";
-      polygons.forEach((polygon3) => {
-        result += "  " + poly3.toString(polygon3) + "\n";
+      polygons.forEach((polygon4) => {
+        result += "  " + poly3.toString(polygon4) + "\n";
       });
       return result;
     };
@@ -4420,7 +4420,7 @@ var require_toCompactBinary2 = __commonJS({
       const polygons = geometry.polygons;
       const transforms = geometry.transforms;
       const numberOfPolygons = polygons.length;
-      const numberOfVertices = polygons.reduce((count, polygon3) => count + polygon3.vertices.length, 0);
+      const numberOfVertices = polygons.reduce((count, polygon4) => count + polygon4.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);
@@ -4448,8 +4448,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((polygon4) => {
+        const points = poly3.toPoints(polygon4);
         compacted[ci] = points.length;
         ci++;
         for (let i = 0; i < points.length; i++) {
@@ -5134,7 +5134,7 @@ var require_colorize = __commonJS({
     "use strict";
     var flatten = require_flatten();
     var geom2 = require_geom2();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var path2 = require_path2();
     var poly3 = require_poly3();
     var colorGeom2 = (color, object) => {
@@ -5143,7 +5143,7 @@ var require_colorize = __commonJS({
       return newgeom2;
     };
     var colorGeom3 = (color, object) => {
-      const newgeom3 = geom32.clone(object);
+      const newgeom3 = geom33.clone(object);
       newgeom3.color = color;
       return newgeom3;
     };
@@ -5165,7 +5165,7 @@ var require_colorize = __commonJS({
       if (objects.length === 0) throw new Error("wrong number of arguments");
       const results = objects.map((object) => {
         if (geom2.isA(object)) return colorGeom2(color, object);
-        if (geom32.isA(object)) return colorGeom3(color, object);
+        if (geom33.isA(object)) return colorGeom3(color, object);
         if (path2.isA(object)) return colorPath2(color, object);
         if (poly3.isA(object)) return colorPoly3(color, object);
         object.color = color;
@@ -5877,7 +5877,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 = (polygon4) => area(polygon4.vertices);
     module.exports = measureArea;
   }
 });
@@ -5901,8 +5901,8 @@ var require_flip2 = __commonJS({
   "node_modules/@jscad/modeling/src/geometries/poly2/flip.js"(exports, module) {
     "use strict";
     var create = require_create10();
-    var flip = (polygon3) => {
-      const vertices = polygon3.vertices.slice().reverse();
+    var flip = (polygon4) => {
+      const vertices = polygon4.vertices.slice().reverse();
       return create(vertices);
     };
     module.exports = flip;
@@ -5915,22 +5915,22 @@ var require_arePointsInside = __commonJS({
     "use strict";
     var measureArea = require_measureArea2();
     var flip = require_flip2();
-    var arePointsInside = (points, polygon3) => {
+    var arePointsInside = (points, polygon4) => {
       if (points.length === 0) return 0;
-      const vertices = polygon3.vertices;
+      const vertices = polygon4.vertices;
       if (vertices.length < 3) return 0;
-      if (measureArea(polygon3) < 0) {
-        polygon3 = flip(polygon3);
+      if (measureArea(polygon4) < 0) {
+        polygon4 = flip(polygon4);
       }
       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, polygon4) => {
+      const numverts = polygon4.length;
       const tx = point[0];
       const ty = point[1];
-      let vtx0 = polygon3[numverts - 1];
-      let vtx1 = polygon3[0];
+      let vtx0 = polygon4[numverts - 1];
+      let vtx1 = polygon4[0];
       let yflag0 = vtx0[1] > ty;
       let insideFlag = 0;
       let i = 0;
@@ -5949,7 +5949,7 @@ var require_arePointsInside = __commonJS({
         }
         yflag0 = yflag1;
         vtx0 = vtx1;
-        vtx1 = polygon3[++i];
+        vtx1 = polygon4[++i];
       }
       return insideFlag;
     };
@@ -6610,7 +6610,7 @@ var require_measureArea3 = __commonJS({
     "use strict";
     var flatten = require_flatten();
     var geom2 = require_geom2();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var path2 = require_path2();
     var poly3 = require_poly3();
     var cache = /* @__PURE__ */ new WeakMap();
@@ -6627,8 +6627,8 @@ var require_measureArea3 = __commonJS({
     var measureAreaOfGeom3 = (geometry) => {
       let area = cache.get(geometry);
       if (area) return area;
-      const polygons = geom32.toPolygons(geometry);
-      area = polygons.reduce((area2, polygon3) => area2 + poly3.measureArea(polygon3), 0);
+      const polygons = geom33.toPolygons(geometry);
+      area = polygons.reduce((area2, polygon4) => area2 + poly3.measureArea(polygon4), 0);
       cache.set(geometry, area);
       return area;
     };
@@ -6638,7 +6638,7 @@ var require_measureArea3 = __commonJS({
       const results = geometries.map((geometry) => {
         if (path2.isA(geometry)) return measureAreaOfPath2(geometry);
         if (geom2.isA(geometry)) return measureAreaOfGeom2(geometry);
-        if (geom32.isA(geometry)) return measureAreaOfGeom3(geometry);
+        if (geom33.isA(geometry)) return measureAreaOfGeom3(geometry);
         return 0;
       });
       return results.length === 1 ? results[0] : results;
@@ -6675,7 +6675,7 @@ var require_measureBoundingBox2 = __commonJS({
     var vec2 = require_vec2();
     var vec3 = require_vec3();
     var geom2 = require_geom2();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var path2 = require_path2();
     var poly3 = require_poly3();
     var cache = /* @__PURE__ */ new WeakMap();
@@ -6724,15 +6724,15 @@ var require_measureBoundingBox2 = __commonJS({
     var measureBoundingBoxOfGeom3 = (geometry) => {
       let boundingBox = cache.get(geometry);
       if (boundingBox) return boundingBox;
-      const polygons = geom32.toPolygons(geometry);
+      const polygons = geom33.toPolygons(geometry);
       let minpoint = vec3.create();
       if (polygons.length > 0) {
         const points = poly3.toPoints(polygons[0]);
         vec3.copy(minpoint, points[0]);
       }
       let maxpoint = vec3.clone(minpoint);
-      polygons.forEach((polygon3) => {
-        poly3.toPoints(polygon3).forEach((point) => {
+      polygons.forEach((polygon4) => {
+        poly3.toPoints(polygon4).forEach((point) => {
           vec3.min(minpoint, minpoint, point);
           vec3.max(maxpoint, maxpoint, point);
         });
@@ -6743,18 +6743,18 @@ var require_measureBoundingBox2 = __commonJS({
       cache.set(geometry, boundingBox);
       return boundingBox;
     };
-    var measureBoundingBox2 = (...geometries) => {
+    var measureBoundingBox3 = (...geometries) => {
       geometries = flatten(geometries);
       if (geometries.length === 0) throw new Error("wrong number of arguments");
       const results = geometries.map((geometry) => {
         if (path2.isA(geometry)) return measureBoundingBoxOfPath2(geometry);
         if (geom2.isA(geometry)) return measureBoundingBoxOfGeom2(geometry);
-        if (geom32.isA(geometry)) return measureBoundingBoxOfGeom3(geometry);
+        if (geom33.isA(geometry)) return measureBoundingBoxOfGeom3(geometry);
         return [[0, 0, 0], [0, 0, 0]];
       });
       return results.length === 1 ? results[0] : results;
     };
-    module.exports = measureBoundingBox2;
+    module.exports = measureBoundingBox3;
   }
 });
 
@@ -6765,11 +6765,11 @@ var require_measureAggregateBoundingBox = __commonJS({
     var flatten = require_flatten();
     var vec3min = require_min();
     var vec3max = require_max();
-    var measureBoundingBox2 = require_measureBoundingBox2();
+    var measureBoundingBox3 = require_measureBoundingBox2();
     var measureAggregateBoundingBox = (...geometries) => {
       geometries = flatten(geometries);
       if (geometries.length === 0) throw new Error("measureAggregateBoundingBox: no geometries supplied");
-      const bounds = measureBoundingBox2(geometries);
+      const bounds = measureBoundingBox3(geometries);
       if (geometries.length === 1) {
         return bounds;
       }
@@ -6806,7 +6806,7 @@ var require_measureAggregateEpsilon = __commonJS({
     var flatten = require_flatten();
     var measureAggregateBoundingBox = require_measureAggregateBoundingBox();
     var calculateEpsilonFromBounds = require_calculateEpsilonFromBounds();
-    var { geom2, geom3: geom32, path2 } = require_geometries();
+    var { geom2, geom3: geom33, path2 } = require_geometries();
     var measureAggregateEpsilon = (...geometries) => {
       geometries = flatten(geometries);
       if (geometries.length === 0) throw new Error("measureAggregateEpsilon: no geometries supplied");
@@ -6814,7 +6814,7 @@ var require_measureAggregateEpsilon = __commonJS({
       let dimensions = 0;
       dimensions = geometries.reduce((dimensions2, geometry) => {
         if (path2.isA(geometry) || geom2.isA(geometry)) return Math.max(dimensions2, 2);
-        if (geom32.isA(geometry)) return Math.max(dimensions2, 3);
+        if (geom33.isA(geometry)) return Math.max(dimensions2, 3);
         return 0;
       }, dimensions);
       return calculateEpsilonFromBounds(bounds, dimensions);
@@ -6829,7 +6829,7 @@ var require_measureVolume = __commonJS({
     "use strict";
     var flatten = require_flatten();
     var geom2 = require_geom2();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var path2 = require_path2();
     var poly3 = require_poly3();
     var cache = /* @__PURE__ */ new WeakMap();
@@ -6838,8 +6838,8 @@ var require_measureVolume = __commonJS({
     var measureVolumeOfGeom3 = (geometry) => {
       let volume = cache.get(geometry);
       if (volume) return volume;
-      const polygons = geom32.toPolygons(geometry);
-      volume = polygons.reduce((volume2, polygon3) => volume2 + poly3.measureSignedVolume(polygon3), 0);
+      const polygons = geom33.toPolygons(geometry);
+      volume = polygons.reduce((volume2, polygon4) => volume2 + poly3.measureSignedVolume(polygon4), 0);
       cache.set(geometry, volume);
       return volume;
     };
@@ -6849,7 +6849,7 @@ var require_measureVolume = __commonJS({
       const results = geometries.map((geometry) => {
         if (path2.isA(geometry)) return measureVolumeOfPath2(geometry);
         if (geom2.isA(geometry)) return measureVolumeOfGeom2(geometry);
-        if (geom32.isA(geometry)) return measureVolumeOfGeom3(geometry);
+        if (geom33.isA(geometry)) return measureVolumeOfGeom3(geometry);
         return 0;
       });
       return results.length === 1 ? results[0] : results;
@@ -6886,7 +6886,7 @@ var require_measureBoundingSphere2 = __commonJS({
     var vec2 = require_vec2();
     var vec3 = require_vec3();
     var geom2 = require_geom2();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var path2 = require_path2();
     var poly3 = require_poly3();
     var cacheOfBoundingSpheres = /* @__PURE__ */ new WeakMap();
@@ -6941,18 +6941,18 @@ var require_measureBoundingSphere2 = __commonJS({
       if (boundingSphere !== void 0) return boundingSphere;
       const centroid = vec3.create();
       let radius = 0;
-      const polygons = geom32.toPolygons(geometry);
+      const polygons = geom33.toPolygons(geometry);
       if (polygons.length > 0) {
         let numPoints = 0;
-        polygons.forEach((polygon3) => {
-          poly3.toPoints(polygon3).forEach((point) => {
+        polygons.forEach((polygon4) => {
+          poly3.toPoints(polygon4).forEach((point) => {
             vec3.add(centroid, centroid, point);
             numPoints++;
           });
         });
         vec3.scale(centroid, centroid, 1 / numPoints);
-        polygons.forEach((polygon3) => {
-          poly3.toPoints(polygon3).forEach((point) => {
+        polygons.forEach((polygon4) => {
+          poly3.toPoints(polygon4).forEach((point) => {
             radius = Math.max(radius, vec3.squaredDistance(centroid, point));
           });
         });
@@ -6967,7 +6967,7 @@ var require_measureBoundingSphere2 = __commonJS({
       const results = geometries.map((geometry) => {
         if (path2.isA(geometry)) return measureBoundingSphereOfPath2(geometry);
         if (geom2.isA(geometry)) return measureBoundingSphereOfGeom2(geometry);
-        if (geom32.isA(geometry)) return measureBoundingSphereOfGeom3(geometry);
+        if (geom33.isA(geometry)) return measureBoundingSphereOfGeom3(geometry);
         return [[0, 0, 0], 0];
       });
       return results.length === 1 ? results[0] : results;
@@ -6981,11 +6981,11 @@ var require_measureCenter = __commonJS({
   "node_modules/@jscad/modeling/src/measurements/measureCenter.js"(exports, module) {
     "use strict";
     var flatten = require_flatten();
-    var measureBoundingBox2 = require_measureBoundingBox2();
+    var measureBoundingBox3 = require_measureBoundingBox2();
     var measureCenter = (...geometries) => {
       geometries = flatten(geometries);
       const results = geometries.map((geometry) => {
-        const bounds = measureBoundingBox2(geometry);
+        const bounds = measureBoundingBox3(geometry);
         return [
           bounds[0][0] + (bounds[1][0] - bounds[0][0]) / 2,
           bounds[0][1] + (bounds[1][1] - bounds[0][1]) / 2,
@@ -7005,7 +7005,7 @@ var require_measureCenterOfMass = __commonJS({
     var flatten = require_flatten();
     var vec3 = require_vec3();
     var geom2 = require_geom2();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var cacheOfCenterOfMass = /* @__PURE__ */ new WeakMap();
     var measureCenterOfMassGeom2 = (geometry) => {
       let centerOfMass = cacheOfCenterOfMass.get(geometry);
@@ -7036,12 +7036,12 @@ var require_measureCenterOfMass = __commonJS({
       let centerOfMass = cacheOfCenterOfMass.get(geometry);
       if (centerOfMass !== void 0) return centerOfMass;
       centerOfMass = vec3.create();
-      const polygons = geom32.toPolygons(geometry);
+      const polygons = geom33.toPolygons(geometry);
       if (polygons.length === 0) return centerOfMass;
       let totalVolume = 0;
       const vector = vec3.create();
-      polygons.forEach((polygon3) => {
-        const vertices = polygon3.vertices;
+      polygons.forEach((polygon4) => {
+        const vertices = polygon4.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;
@@ -7060,7 +7060,7 @@ var require_measureCenterOfMass = __commonJS({
       geometries = flatten(geometries);
       const results = geometries.map((geometry) => {
         if (geom2.isA(geometry)) return measureCenterOfMassGeom2(geometry);
-        if (geom32.isA(geometry)) return measureCenterOfMassGeom3(geometry);
+        if (geom33.isA(geometry)) return measureCenterOfMassGeom3(geometry);
         return [0, 0, 0];
       });
       return results.length === 1 ? results[0] : results;
@@ -7074,11 +7074,11 @@ var require_measureDimensions = __commonJS({
   "node_modules/@jscad/modeling/src/measurements/measureDimensions.js"(exports, module) {
     "use strict";
     var flatten = require_flatten();
-    var measureBoundingBox2 = require_measureBoundingBox2();
+    var measureBoundingBox3 = require_measureBoundingBox2();
     var measureDimensions = (...geometries) => {
       geometries = flatten(geometries);
       const results = geometries.map((geometry) => {
-        const boundingBox = measureBoundingBox2(geometry);
+        const boundingBox = measureBoundingBox3(geometry);
         return [
           boundingBox[1][0] - boundingBox[0][0],
           boundingBox[1][1] - boundingBox[0][1],
@@ -7096,19 +7096,19 @@ var require_measureEpsilon = __commonJS({
   "node_modules/@jscad/modeling/src/measurements/measureEpsilon.js"(exports, module) {
     "use strict";
     var flatten = require_flatten();
-    var { geom2, geom3: geom32, path2 } = require_geometries();
+    var { geom2, geom3: geom33, path2 } = require_geometries();
     var calculateEpsilonFromBounds = require_calculateEpsilonFromBounds();
-    var measureBoundingBox2 = require_measureBoundingBox2();
-    var measureEpsilonOfPath2 = (geometry) => calculateEpsilonFromBounds(measureBoundingBox2(geometry), 2);
-    var measureEpsilonOfGeom2 = (geometry) => calculateEpsilonFromBounds(measureBoundingBox2(geometry), 2);
-    var measureEpsilonOfGeom3 = (geometry) => calculateEpsilonFromBounds(measureBoundingBox2(geometry), 3);
+    var measureBoundingBox3 = require_measureBoundingBox2();
+    var measureEpsilonOfPath2 = (geometry) => calculateEpsilonFromBounds(measureBoundingBox3(geometry), 2);
+    var measureEpsilonOfGeom2 = (geometry) => calculateEpsilonFromBounds(measureBoundingBox3(geometry), 2);
+    var measureEpsilonOfGeom3 = (geometry) => calculateEpsilonFromBounds(measureBoundingBox3(geometry), 3);
     var measureEpsilon = (...geometries) => {
       geometries = flatten(geometries);
       if (geometries.length === 0) throw new Error("wrong number of arguments");
       const results = geometries.map((geometry) => {
         if (path2.isA(geometry)) return measureEpsilonOfPath2(geometry);
         if (geom2.isA(geometry)) return measureEpsilonOfGeom2(geometry);
-        if (geom32.isA(geometry)) return measureEpsilonOfGeom3(geometry);
+        if (geom33.isA(geometry)) return measureEpsilonOfGeom3(geometry);
         return 0;
       });
       return results.length === 1 ? results[0] : results;
@@ -7307,7 +7307,7 @@ var require_circle = __commonJS({
 var require_cuboid = __commonJS({
   "node_modules/@jscad/modeling/src/primitives/cuboid.js"(exports, module) {
     "use strict";
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var poly3 = require_poly3();
     var { isNumberArray } = require_commonChecks();
     var cuboid = (options) => {
@@ -7319,8 +7319,8 @@ var require_cuboid = __commonJS({
       if (!isNumberArray(center, 3)) throw new Error("center must be an array of X, Y and Z values");
       if (!isNumberArray(size, 3)) throw new Error("size must be an array of width, depth and height values");
       if (!size.every((n) => n >= 0)) throw new Error("size values must be positive");
-      if (size[0] === 0 || size[1] === 0 || size[2] === 0) return geom32.create();
-      const result = geom32.create(
+      if (size[0] === 0 || size[1] === 0 || size[2] === 0) return geom33.create();
+      const result = geom33.create(
         // adjust a basic shape to size
         [
           [[0, 4, 6, 2], [-1, 0, 0]],
@@ -7373,7 +7373,7 @@ var require_cylinderElliptic = __commonJS({
     "use strict";
     var { EPS, TAU } = require_constants();
     var vec3 = require_vec3();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var poly3 = require_poly3();
     var { sin, cos } = require_trigonometry();
     var { isGT, isGTE, isNumberArray } = require_commonChecks();
@@ -7462,7 +7462,7 @@ var require_cylinderElliptic = __commonJS({
         polygons.push(fromPoints(start, end, point(0, 1, startRadius)));
         polygons.push(fromPoints(point(0, 1, startRadius), end, point(1, 1, endRadius)));
       }
-      const result = geom32.create(polygons);
+      const result = geom33.create(polygons);
       return result;
     };
     module.exports = cylinderElliptic;
@@ -7473,7 +7473,7 @@ var require_cylinderElliptic = __commonJS({
 var require_cylinder = __commonJS({
   "node_modules/@jscad/modeling/src/primitives/cylinder.js"(exports, module) {
     "use strict";
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var cylinderElliptic = require_cylinderElliptic();
     var { isGTE } = require_commonChecks();
     var cylinder2 = (options) => {
@@ -7485,7 +7485,7 @@ var require_cylinder = __commonJS({
       };
       const { center, height, radius, segments } = Object.assign({}, defaults, options);
       if (!isGTE(radius, 0)) throw new Error("radius must be positive");
-      if (height === 0 || radius === 0) return geom32.create();
+      if (height === 0 || radius === 0) return geom33.create();
       const newoptions = {
         center,
         height,
@@ -7505,7 +7505,7 @@ var require_ellipsoid = __commonJS({
     "use strict";
     var { TAU } = require_constants();
     var vec3 = require_vec3();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var poly3 = require_poly3();
     var { sin, cos } = require_trigonometry();
     var { isGTE, isNumberArray } = require_commonChecks();
@@ -7521,7 +7521,7 @@ var require_ellipsoid = __commonJS({
       if (!isNumberArray(radius, 3)) throw new Error("radius must be an array of X, Y and Z values");
       if (!radius.every((n) => n >= 0)) throw new Error("radius values must be positive");
       if (!isGTE(segments, 4)) throw new Error("segments must be four or more");
-      if (radius[0] === 0 || radius[1] === 0 || radius[2] === 0) return geom32.create();
+      if (radius[0] === 0 || radius[1] === 0 || radius[2] === 0) return geom33.create();
       const xvector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), axes[0]), radius[0]);
       const yvector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), axes[1]), radius[1]);
       const zvector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), axes[2]), radius[2]);
@@ -7573,7 +7573,7 @@ var require_ellipsoid = __commonJS({
         }
         prevcylinderpoint = cylinderpoint;
       }
-      return geom32.create(polygons);
+      return geom33.create(polygons);
     };
     module.exports = ellipsoid;
   }
@@ -7583,7 +7583,7 @@ var require_ellipsoid = __commonJS({
 var require_polyhedron = __commonJS({
   "node_modules/@jscad/modeling/src/primitives/polyhedron.js"(exports, module) {
     "use strict";
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var poly3 = require_poly3();
     var { isNumberArray } = require_commonChecks();
     var polyhedron = (options) => {
@@ -7622,11 +7622,11 @@ 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 (colors && colors[findex]) polygon3.color = colors[findex];
-        return polygon3;
+        const polygon4 = poly3.create(face.map((pindex) => points[pindex]));
+        if (colors && colors[findex]) polygon4.color = colors[findex];
+        return polygon4;
       });
-      return geom32.create(polygons);
+      return geom33.create(polygons);
     };
     module.exports = polyhedron;
   }
@@ -7638,7 +7638,7 @@ var require_geodesicSphere = __commonJS({
     "use strict";
     var mat4 = require_mat4();
     var vec3 = require_vec3();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var polyhedron = require_polyhedron();
     var { isGTE } = require_commonChecks();
     var geodesicSphere = (options) => {
@@ -7649,7 +7649,7 @@ var require_geodesicSphere = __commonJS({
       let { radius, frequency } = Object.assign({}, defaults, options);
       if (!isGTE(radius, 0)) throw new Error("radius must be positive");
       if (!isGTE(frequency, 6)) throw new Error("frequency must be six or more");
-      if (radius === 0) return geom32.create();
+      if (radius === 0) return geom33.create();
       frequency = Math.floor(frequency / 6);
       const ci = [
         // hard-coded data of icosahedron (20 faces, all triangles)
@@ -7752,7 +7752,7 @@ var require_geodesicSphere = __commonJS({
         offset = g.offset;
       }
       let geometry = polyhedron({ points, faces, orientation: "inward" });
-      if (radius !== 1) geometry = geom32.transform(mat4.fromScaling(mat4.create(), [radius, radius, radius]), geometry);
+      if (radius !== 1) geometry = geom33.transform(mat4.fromScaling(mat4.create(), [radius, radius, radius]), geometry);
       return geometry;
     };
     module.exports = geodesicSphere;
@@ -7777,7 +7777,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 polygon4 = (options) => {
       const defaults = {
         points: [],
         paths: [],
@@ -7818,7 +7818,7 @@ var require_polygon = __commonJS({
       }
       return geometry;
     };
-    module.exports = polygon3;
+    module.exports = polygon4;
   }
 });
 
@@ -7860,7 +7860,7 @@ var require_roundedCuboid = __commonJS({
     var { EPS, TAU } = require_constants();
     var vec2 = require_vec2();
     var vec3 = require_vec3();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var poly3 = require_poly3();
     var { sin, cos } = require_trigonometry();
     var { isGTE, isNumberArray } = require_commonChecks();
@@ -7965,7 +7965,7 @@ var require_roundedCuboid = __commonJS({
       if (!size.every((n) => n >= 0)) throw new Error("size values must be positive");
       if (!isGTE(roundRadius, 0)) throw new Error("roundRadius must be positive");
       if (!isGTE(segments, 4)) throw new Error("segments must be four or more");
-      if (size[0] === 0 || size[1] === 0 || size[2] === 0) return geom32.create();
+      if (size[0] === 0 || size[1] === 0 || size[2] === 0) return geom33.create();
       if (roundRadius === 0) return cuboid({ center, size });
       size = size.map((v) => v / 2);
       if (roundRadius > size[0] - EPS || roundRadius > size[1] - EPS || roundRadius > size[2] - EPS) throw new Error("roundRadius must be smaller than the radius of all dimensions");
@@ -8000,7 +8000,7 @@ var require_roundedCuboid = __commonJS({
         prevCornersPos = cornersPos;
         prevCornersNeg = cornersNeg;
       }
-      return geom32.create(polygons);
+      return geom33.create(polygons);
     };
     module.exports = roundedCuboid;
   }
@@ -8012,7 +8012,7 @@ var require_roundedCylinder = __commonJS({
     "use strict";
     var { EPS, TAU } = require_constants();
     var vec3 = require_vec3();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var poly3 = require_poly3();
     var { sin, cos } = require_trigonometry();
     var { isGTE, isNumberArray } = require_commonChecks();
@@ -8032,7 +8032,7 @@ var require_roundedCylinder = __commonJS({
       if (!isGTE(roundRadius, 0)) throw new Error("roundRadius must be positive");
       if (roundRadius > radius) throw new Error("roundRadius must be smaller than the radius");
       if (!isGTE(segments, 4)) throw new Error("segments must be four or more");
-      if (height === 0 || radius === 0) return geom32.create();
+      if (height === 0 || radius === 0) return geom33.create();
       if (roundRadius === 0) return cylinder2({ center, height, radius });
       const start = [0, 0, -(height / 2)];
       const end = [0, 0, height / 2];
@@ -8112,7 +8112,7 @@ var require_roundedCylinder = __commonJS({
         }
         prevcylinderpoint = cylinderpoint;
       }
-      const result = geom32.create(polygons);
+      const result = geom33.create(polygons);
       return result;
     };
     module.exports = roundedCylinder;
@@ -8283,7 +8283,7 @@ var require_mirror = __commonJS({
     var mat4 = require_mat4();
     var plane = require_plane();
     var geom2 = require_geom2();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var path2 = require_path2();
     var mirror = (options, ...objects) => {
       const defaults = {
@@ -8302,7 +8302,7 @@ var require_mirror = __commonJS({
       const results = objects.map((object) => {
         if (path2.isA(object)) return path2.transform(matrix, object);
         if (geom2.isA(object)) return geom2.transform(matrix, object);
-        if (geom32.isA(object)) return geom32.transform(matrix, object);
+        if (geom33.isA(object)) return geom33.transform(matrix, object);
         return object;
       });
       return results.length === 1 ? results[0] : results;
@@ -9278,7 +9278,7 @@ var require_extrudeFromSlices = __commonJS({
     "use strict";
     var mat4 = require_mat4();
     var geom2 = require_geom2();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var poly3 = require_poly3();
     var slice = require_slice();
     var repairSlice = require_repair();
@@ -9335,7 +9335,7 @@ var require_extrudeFromSlices = __commonJS({
           polygons = polygons.concat(extrudeWalls(endSlice, startSlice));
         }
       }
-      return geom32.create(polygons);
+      return geom33.create(polygons);
     };
     module.exports = extrudeFromSlices;
   }
@@ -9436,7 +9436,7 @@ var require_rotate3 = __commonJS({
     var flatten = require_flatten();
     var mat4 = require_mat4();
     var geom2 = require_geom2();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var path2 = require_path2();
     var rotate = (angles, ...objects) => {
       if (!Array.isArray(angles)) throw new Error("angles must be an array");
@@ -9451,17 +9451,17 @@ var require_rotate3 = __commonJS({
       const results = objects.map((object) => {
         if (path2.isA(object)) return path2.transform(matrix, object);
         if (geom2.isA(object)) return geom2.transform(matrix, object);
-        if (geom32.isA(object)) return geom32.transform(matrix, object);
+        if (geom33.isA(object)) return geom33.transform(matrix, object);
         return object;
       });
       return results.length === 1 ? results[0] : results;
     };
-    var rotateX2 = (angle, ...objects) => rotate([angle, 0, 0], objects);
+    var rotateX3 = (angle, ...objects) => rotate([angle, 0, 0], objects);
     var rotateY = (angle, ...objects) => rotate([0, angle, 0], objects);
     var rotateZ3 = (angle, ...objects) => rotate([0, 0, angle], objects);
     module.exports = {
       rotate,
-      rotateX: rotateX2,
+      rotateX: rotateX3,
       rotateY,
       rotateZ: rotateZ3
     };
@@ -9475,9 +9475,9 @@ var require_translate2 = __commonJS({
     var flatten = require_flatten();
     var mat4 = require_mat4();
     var geom2 = require_geom2();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var path2 = require_path2();
-    var translate3 = (offset, ...objects) => {
+    var translate4 = (offset, ...objects) => {
       if (!Array.isArray(offset)) throw new Error("offset must be an array");
       objects = flatten(objects);
       if (objects.length === 0) throw new Error("wrong number of arguments");
@@ -9487,16 +9487,16 @@ var require_translate2 = __commonJS({
       const results = objects.map((object) => {
         if (path2.isA(object)) return path2.transform(matrix, object);
         if (geom2.isA(object)) return geom2.transform(matrix, object);
-        if (geom32.isA(object)) return geom32.transform(matrix, object);
+        if (geom33.isA(object)) return geom33.transform(matrix, object);
         return object;
       });
       return results.length === 1 ? results[0] : results;
     };
-    var translateX = (offset, ...objects) => translate3([offset, 0, 0], objects);
-    var translateY = (offset, ...objects) => translate3([0, offset, 0], objects);
-    var translateZ = (offset, ...objects) => translate3([0, 0, offset], objects);
+    var translateX = (offset, ...objects) => translate4([offset, 0, 0], objects);
+    var translateY = (offset, ...objects) => translate4([0, offset, 0], objects);
+    var translateZ = (offset, ...objects) => translate4([0, 0, offset], objects);
     module.exports = {
-      translate: translate3,
+      translate: translate4,
       translateX,
       translateY,
       translateZ
@@ -9511,7 +9511,7 @@ var require_torus = __commonJS({
     var { TAU } = require_constants();
     var extrudeRotate = require_extrudeRotate();
     var { rotate } = require_rotate3();
-    var { translate: translate3 } = require_translate2();
+    var { translate: translate4 } = require_translate2();
     var circle = require_circle();
     var { isGT, isGTE } = require_commonChecks();
     var torus = (options) => {
@@ -9536,7 +9536,7 @@ var require_torus = __commonJS({
       if (innerRotation !== 0) {
         innerCircle = rotate([0, 0, innerRotation], innerCircle);
       }
-      innerCircle = translate3([outerRadius, 0], innerCircle);
+      innerCircle = translate4([outerRadius, 0], innerCircle);
       const extrudeOptions = {
         startAngle,
         angle: outerRotation,
@@ -9970,14 +9970,14 @@ var require_areAllShapesTheSameType = __commonJS({
   "node_modules/@jscad/modeling/src/utils/areAllShapesTheSameType.js"(exports, module) {
     "use strict";
     var geom2 = require_geom2();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var path2 = require_path2();
     var areAllShapesTheSameType = (shapes) => {
       let previousType;
       for (const shape of shapes) {
         let currentType = 0;
         if (geom2.isA(shape)) currentType = 1;
-        if (geom32.isA(shape)) currentType = 2;
+        if (geom33.isA(shape)) currentType = 2;
         if (path2.isA(shape)) currentType = 3;
         if (previousType && currentType !== previousType) return false;
         previousType = currentType;
@@ -10074,12 +10074,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, polygon4) => {
+      if (polygon4.vertices.length < 4) {
         return null;
       }
       const vert1Indices = [];
-      const points3D = polygon3.vertices.filter((vertex, i) => {
+      const points3D = polygon4.vertices.filter((vertex, i) => {
         if (vertex[2] > 0) {
           vert1Indices.push(i);
           return true;
@@ -10106,7 +10106,7 @@ var require_fromFakePolygons = __commonJS({
       return points2D;
     };
     var fromFakePolygons = (epsilon, polygons) => {
-      const sides = polygons.map((polygon3) => fromFakePolygon(epsilon, polygon3)).filter((polygon3) => polygon3 !== null);
+      const sides = polygons.map((polygon4) => fromFakePolygon(epsilon, polygon4)).filter((polygon4) => polygon4 !== null);
       return geom2.create(sides);
     };
     module.exports = fromFakePolygons;
@@ -10119,7 +10119,7 @@ var require_to3DWalls = __commonJS({
     "use strict";
     var vec3 = require_vec3();
     var geom2 = require_geom2();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var poly3 = require_poly3();
     var to3DWall = (z0, z1, side) => {
       const points = [
@@ -10133,7 +10133,7 @@ var require_to3DWalls = __commonJS({
     var to3DWalls = (options, geometry) => {
       const sides = geom2.toSides(geometry);
       const polygons = sides.map((side) => to3DWall(options.z0, options.z1, side));
-      const result = geom32.create(polygons);
+      const result = geom33.create(polygons);
       return result;
     };
     module.exports = to3DWalls;
@@ -10463,8 +10463,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 polygon4 = poly3.fromPointsAndPlane(vertices3d, plane);
+              if (polygon4.vertices.length) destpolygons.push(polygon4);
             }
           }
         }
@@ -10500,7 +10500,7 @@ var require_reTesselateCoplanarPolygons = __commonJS({
 var require_retessellate = __commonJS({
   "node_modules/@jscad/modeling/src/operations/modifiers/retessellate.js"(exports, module) {
     "use strict";
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var poly3 = require_poly3();
     var { NEPS } = require_constants();
     var reTesselateCoplanarPolygons = require_reTesselateCoplanarPolygons();
@@ -10508,7 +10508,7 @@ var require_retessellate = __commonJS({
       if (geometry.isRetesselated) {
         return geometry;
       }
-      const polygons = geom32.toPolygons(geometry).map((polygon3, index) => ({ vertices: polygon3.vertices, plane: poly3.plane(polygon3), index }));
+      const polygons = geom33.toPolygons(geometry).map((polygon4, index) => ({ vertices: polygon4.vertices, plane: poly3.plane(polygon4), index }));
       const classified = classifyPolygons(polygons);
       const destPolygons = [];
       classified.forEach((group) => {
@@ -10519,7 +10519,7 @@ var require_retessellate = __commonJS({
           destPolygons.push(group);
         }
       });
-      const result = geom32.create(destPolygons);
+      const result = geom33.create(destPolygons);
       result.isRetesselated = true;
       return result;
     };
@@ -10554,8 +10554,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((polygon4) => {
+        result[polygon4.index] = polygon4;
       });
       return result;
     };
@@ -10576,15 +10576,15 @@ var require_mayOverlap = __commonJS({
   "node_modules/@jscad/modeling/src/operations/booleans/mayOverlap.js"(exports, module) {
     "use strict";
     var { EPS } = require_constants();
-    var measureBoundingBox2 = require_measureBoundingBox2();
+    var measureBoundingBox3 = require_measureBoundingBox2();
     var mayOverlap = (geometry1, geometry2) => {
       if (geometry1.polygons.length === 0 || geometry2.polygons.length === 0) {
         return false;
       }
-      const bounds1 = measureBoundingBox2(geometry1);
+      const bounds1 = measureBoundingBox3(geometry1);
       const min1 = bounds1[0];
       const max1 = bounds1[1];
-      const bounds2 = measureBoundingBox2(geometry2);
+      const bounds2 = measureBoundingBox3(geometry2);
       const min2 = bounds2[0];
       const max2 = bounds2[1];
       if (min2[0] - max1[0] > EPS) return false;
@@ -10747,15 +10747,15 @@ var require_splitPolygonByPlane = __commonJS({
     var vec3 = require_vec3();
     var poly3 = require_poly3();
     var splitLineSegmentByPlane = require_splitLineSegmentByPlane();
-    var splitPolygonByPlane = (splane, polygon3) => {
+    var splitPolygonByPlane = (splane, polygon4) => {
       const result = {
         type: null,
         front: null,
         back: null
       };
-      const vertices = polygon3.vertices;
+      const vertices = polygon4.vertices;
       const numvertices = vertices.length;
-      const pplane = poly3.plane(polygon3);
+      const pplane = poly3.plane(polygon4);
       if (plane.equals(pplane, splane)) {
         result.type = 0;
       } else {
@@ -10855,10 +10855,10 @@ var require_PolygonTreeNode = __commonJS({
     var splitPolygonByPlane = require_splitPolygonByPlane();
     var PolygonTreeNode = class _PolygonTreeNode {
       // constructor creates the root node
-      constructor(parent, polygon3) {
+      constructor(parent, polygon4) {
         this.parent = parent;
         this.children = [];
-        this.polygon = polygon3;
+        this.polygon = polygon4;
         this.removed = false;
       }
       // fill the tree with polygons. Should be called on the root node only; child nodes must
@@ -10868,8 +10868,8 @@ var require_PolygonTreeNode = __commonJS({
           throw new Error("Assertion failed");
         }
         const _this = this;
-        polygons.forEach((polygon3) => {
-          _this.addChild(polygon3);
+        polygons.forEach((polygon4) => {
+          _this.addChild(polygon4);
         });
       }
       // remove a node
@@ -10946,9 +10946,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 polygon4 = this.polygon;
+        if (polygon4) {
+          const bound = poly3.measureBoundingSphere(polygon4);
           const sphereradius = bound[3] + EPS;
           const spherecenter = bound;
           const d = vec3.dot(splane, spherecenter) - splane[3];
@@ -10957,7 +10957,7 @@ var require_PolygonTreeNode = __commonJS({
           } else if (d < -sphereradius) {
             backnodes.push(this);
           } else {
-            const splitresult = splitPolygonByPlane(splane, polygon3);
+            const splitresult = splitPolygonByPlane(splane, polygon4);
             switch (splitresult.type) {
               case 0:
                 coplanarfrontnodes.push(this);
@@ -10990,8 +10990,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(polygon4) {
+        const newchild = new _PolygonTreeNode(this, polygon4);
         this.children.push(newchild);
         return newchild;
       }
@@ -11125,15 +11125,15 @@ var require_trees = __commonJS({
 var require_intersectGeom3Sub = __commonJS({
   "node_modules/@jscad/modeling/src/operations/booleans/intersectGeom3Sub.js"(exports, module) {
     "use strict";
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var mayOverlap = require_mayOverlap();
     var { Tree } = require_trees();
     var intersectGeom3Sub = (geometry1, geometry2) => {
       if (!mayOverlap(geometry1, geometry2)) {
-        return geom32.create();
+        return geom33.create();
       }
-      const a = new Tree(geom32.toPolygons(geometry1));
-      const b = new Tree(geom32.toPolygons(geometry2));
+      const a = new Tree(geom33.toPolygons(geometry1));
+      const b = new Tree(geom33.toPolygons(geometry2));
       a.invert();
       b.clipTo(a);
       b.invert();
@@ -11142,7 +11142,7 @@ var require_intersectGeom3Sub = __commonJS({
       a.addPolygons(b.allPolygons());
       a.invert();
       const newpolygons = a.allPolygons();
-      return geom32.create(newpolygons);
+      return geom33.create(newpolygons);
     };
     module.exports = intersectGeom3Sub;
   }
@@ -11173,7 +11173,7 @@ var require_intersectGeom2 = __commonJS({
   "node_modules/@jscad/modeling/src/operations/booleans/intersectGeom2.js"(exports, module) {
     "use strict";
     var flatten = require_flatten();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var measureEpsilon = require_measureEpsilon();
     var fromFakePolygons = require_fromFakePolygons();
     var to3DWalls = require_to3DWalls();
@@ -11183,7 +11183,7 @@ var require_intersectGeom2 = __commonJS({
       const newgeometries = geometries.map((geometry) => to3DWalls({ z0: -1, z1: 1 }, geometry));
       const newgeom3 = intersectGeom3(newgeometries);
       const epsilon = measureEpsilon(newgeom3);
-      return fromFakePolygons(epsilon, geom32.toPolygons(newgeom3));
+      return fromFakePolygons(epsilon, geom33.toPolygons(newgeom3));
     };
     module.exports = intersect;
   }
@@ -11196,7 +11196,7 @@ var require_intersect2 = __commonJS({
     var flatten = require_flatten();
     var areAllShapesTheSameType = require_areAllShapesTheSameType();
     var geom2 = require_geom2();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var intersectGeom2 = require_intersectGeom2();
     var intersectGeom3 = require_intersectGeom3();
     var intersect = (...geometries) => {
@@ -11207,7 +11207,7 @@ var require_intersect2 = __commonJS({
       }
       const geometry = geometries[0];
       if (geom2.isA(geometry)) return intersectGeom2(geometries);
-      if (geom32.isA(geometry)) return intersectGeom3(geometries);
+      if (geom33.isA(geometry)) return intersectGeom3(geometries);
       return geometry;
     };
     module.exports = intersect;
@@ -11220,7 +11220,7 @@ var require_scissionGeom3 = __commonJS({
     "use strict";
     var vec3 = require_vec3();
     var measureEpsilon = require_measureEpsilon();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var sortNb = (array) => array.sort((a, b) => a - b).filter((item, pos, ary) => !pos || item !== ary[pos - 1]);
     var insertMapping = (map, point, index) => {
       const key = `${point}`;
@@ -11237,18 +11237,18 @@ var require_scissionGeom3 = __commonJS({
     };
     var scissionGeom3 = (geometry) => {
       const eps = measureEpsilon(geometry);
-      const polygons = geom32.toPolygons(geometry);
+      const polygons = geom33.toPolygons(geometry);
       const pl = polygons.length;
       const indexesPerPoint = /* @__PURE__ */ new Map();
       const temp = vec3.create();
-      polygons.forEach((polygon3, index) => {
-        polygon3.vertices.forEach((point) => {
+      polygons.forEach((polygon4, index) => {
+        polygon4.vertices.forEach((point) => {
           insertMapping(indexesPerPoint, vec3.snap(temp, point, eps), index);
         });
       });
-      const indexesPerPolygon = polygons.map((polygon3) => {
+      const indexesPerPolygon = polygons.map((polygon4) => {
         let indexes = [];
-        polygon3.vertices.forEach((point) => {
+        polygon4.vertices.forEach((point) => {
           indexes = indexes.concat(findMapping(indexesPerPoint, vec3.snap(temp, point, eps)));
         });
         return { e: 1, d: sortNb(indexes) };
@@ -11282,7 +11282,7 @@ var require_scissionGeom3 = __commonJS({
         if (indexesPerPolygon[i].indexes) {
           const newpolygons = [];
           indexesPerPolygon[i].indexes.forEach((e, p) => newpolygons.push(polygons[p]));
-          newgeometries.push(geom32.create(newpolygons));
+          newgeometries.push(geom33.create(newpolygons));
         }
       }
       return newgeometries;
@@ -11296,13 +11296,13 @@ var require_scission = __commonJS({
   "node_modules/@jscad/modeling/src/operations/booleans/scission.js"(exports, module) {
     "use strict";
     var flatten = require_flatten();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var scissionGeom3 = require_scissionGeom3();
     var scission = (...objects) => {
       objects = flatten(objects);
       if (objects.length === 0) throw new Error("wrong number of arguments");
       const results = objects.map((object) => {
-        if (geom32.isA(object)) return scissionGeom3(object);
+        if (geom33.isA(object)) return scissionGeom3(object);
         return object;
       });
       return results.length === 1 ? results[0] : results;
@@ -11315,22 +11315,22 @@ var require_scission = __commonJS({
 var require_subtractGeom3Sub = __commonJS({
   "node_modules/@jscad/modeling/src/operations/booleans/subtractGeom3Sub.js"(exports, module) {
     "use strict";
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var mayOverlap = require_mayOverlap();
     var { Tree } = require_trees();
     var subtractGeom3Sub = (geometry1, geometry2) => {
       if (!mayOverlap(geometry1, geometry2)) {
-        return geom32.clone(geometry1);
+        return geom33.clone(geometry1);
       }
-      const a = new Tree(geom32.toPolygons(geometry1));
-      const b = new Tree(geom32.toPolygons(geometry2));
+      const a = new Tree(geom33.toPolygons(geometry1));
+      const b = new Tree(geom33.toPolygons(geometry2));
       a.invert();
       a.clipTo(b);
       b.clipTo(a, true);
       a.addPolygons(b.allPolygons());
       a.invert();
       const newpolygons = a.allPolygons();
-      return geom32.create(newpolygons);
+      return geom33.create(newpolygons);
     };
     module.exports = subtractGeom3Sub;
   }
@@ -11361,7 +11361,7 @@ var require_subtractGeom2 = __commonJS({
   "node_modules/@jscad/modeling/src/operations/booleans/subtractGeom2.js"(exports, module) {
     "use strict";
     var flatten = require_flatten();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var measureEpsilon = require_measureEpsilon();
     var fromFakePolygons = require_fromFakePolygons();
     var to3DWalls = require_to3DWalls();
@@ -11371,7 +11371,7 @@ var require_subtractGeom2 = __commonJS({
       const newgeometries = geometries.map((geometry) => to3DWalls({ z0: -1, z1: 1 }, geometry));
       const newgeom3 = subtractGeom3(newgeometries);
       const epsilon = measureEpsilon(newgeom3);
-      return fromFakePolygons(epsilon, geom32.toPolygons(newgeom3));
+      return fromFakePolygons(epsilon, geom33.toPolygons(newgeom3));
     };
     module.exports = subtract2;
   }
@@ -11384,7 +11384,7 @@ var require_subtract4 = __commonJS({
     var flatten = require_flatten();
     var areAllShapesTheSameType = require_areAllShapesTheSameType();
     var geom2 = require_geom2();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var subtractGeom2 = require_subtractGeom2();
     var subtractGeom3 = require_subtractGeom3();
     var subtract2 = (...geometries) => {
@@ -11395,7 +11395,7 @@ var require_subtract4 = __commonJS({
       }
       const geometry = geometries[0];
       if (geom2.isA(geometry)) return subtractGeom2(geometries);
-      if (geom32.isA(geometry)) return subtractGeom3(geometries);
+      if (geom33.isA(geometry)) return subtractGeom3(geometries);
       return geometry;
     };
     module.exports = subtract2;
@@ -11406,28 +11406,28 @@ var require_subtract4 = __commonJS({
 var require_unionGeom3Sub = __commonJS({
   "node_modules/@jscad/modeling/src/operations/booleans/unionGeom3Sub.js"(exports, module) {
     "use strict";
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var mayOverlap = require_mayOverlap();
     var { Tree } = require_trees();
     var unionSub = (geometry1, geometry2) => {
       if (!mayOverlap(geometry1, geometry2)) {
         return unionForNonIntersecting(geometry1, geometry2);
       }
-      const a = new Tree(geom32.toPolygons(geometry1));
-      const b = new Tree(geom32.toPolygons(geometry2));
+      const a = new Tree(geom33.toPolygons(geometry1));
+      const b = new Tree(geom33.toPolygons(geometry2));
       a.clipTo(b, false);
       b.clipTo(a);
       b.invert();
       b.clipTo(a);
       b.invert();
       const newpolygons = a.allPolygons().concat(b.allPolygons());
-      const result = geom32.create(newpolygons);
+      const result = geom33.create(newpolygons);
       return result;
     };
     var unionForNonIntersecting = (geometry1, geometry2) => {
-      let newpolygons = geom32.toPolygons(geometry1);
-      newpolygons = newpolygons.concat(geom32.toPolygons(geometry2));
-      return geom32.create(newpolygons);
+      let newpolygons = geom33.toPolygons(geometry1);
+      newpolygons = newpolygons.concat(geom33.toPolygons(geometry2));
+      return geom33.create(newpolygons);
     };
     module.exports = unionSub;
   }
@@ -11459,7 +11459,7 @@ var require_unionGeom2 = __commonJS({
   "node_modules/@jscad/modeling/src/operations/booleans/unionGeom2.js"(exports, module) {
     "use strict";
     var flatten = require_flatten();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var measureEpsilon = require_measureEpsilon();
     var fromFakePolygons = require_fromFakePolygons();
     var to3DWalls = require_to3DWalls();
@@ -11469,7 +11469,7 @@ var require_unionGeom2 = __commonJS({
       const newgeometries = geometries.map((geometry) => to3DWalls({ z0: -1, z1: 1 }, geometry));
       const newgeom3 = unionGeom3(newgeometries);
       const epsilon = measureEpsilon(newgeom3);
-      return fromFakePolygons(epsilon, geom32.toPolygons(newgeom3));
+      return fromFakePolygons(epsilon, geom33.toPolygons(newgeom3));
     };
     module.exports = union;
   }
@@ -11482,7 +11482,7 @@ var require_union = __commonJS({
     var flatten = require_flatten();
     var areAllShapesTheSameType = require_areAllShapesTheSameType();
     var geom2 = require_geom2();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var unionGeom2 = require_unionGeom2();
     var unionGeom3 = require_unionGeom3();
     var union = (...geometries) => {
@@ -11493,7 +11493,7 @@ var require_union = __commonJS({
       }
       const geometry = geometries[0];
       if (geom2.isA(geometry)) return unionGeom2(geometries);
-      if (geom32.isA(geometry)) return unionGeom3(geometries);
+      if (geom33.isA(geometry)) return unionGeom3(geometries);
       return geometry;
     };
     module.exports = union;
@@ -11686,7 +11686,7 @@ var require_extrudePolygon = __commonJS({
     "use strict";
     var mat4 = require_mat4();
     var vec3 = require_vec3();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var poly3 = require_poly3();
     var extrudePolygon = (offsetvector, polygon1) => {
       const direction = vec3.dot(poly3.plane(polygon1), offsetvector);
@@ -11707,7 +11707,7 @@ var require_extrudePolygon = __commonJS({
         newpolygons.push(sideFacePolygon);
       }
       newpolygons.push(poly3.invert(polygon22));
-      return geom32.create(newpolygons);
+      return geom33.create(newpolygons);
     };
     module.exports = extrudePolygon;
   }
@@ -11721,7 +11721,7 @@ var require_expandShell = __commonJS({
     var mat4 = require_mat4();
     var vec3 = require_vec3();
     var fnNumberSort = require_fnNumberSort();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var poly3 = require_poly3();
     var sphere = require_sphere();
     var retessellate = require_retessellate();
@@ -11761,23 +11761,23 @@ var require_expandShell = __commonJS({
         segments: 12
       };
       const { delta, segments } = Object.assign({}, defaults, options);
-      let result = geom32.create();
+      let result = geom33.create();
       const vertices2planes = /* @__PURE__ */ new Map();
       const edges2planes = /* @__PURE__ */ new Map();
       const v1 = vec3.create();
       const v2 = vec3.create();
-      const polygons = geom32.toPolygons(geometry);
-      polygons.forEach((polygon3, index) => {
-        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);
+      const polygons = geom33.toPolygons(geometry);
+      polygons.forEach((polygon4, index) => {
+        const extrudevector = vec3.scale(vec3.create(), poly3.plane(polygon4), 2 * delta);
+        const translatedpolygon = poly3.transform(mat4.fromTranslation(mat4.create(), vec3.scale(vec3.create(), extrudevector, -0.5)), polygon4);
         const extrudedface = extrudePolygon(extrudevector, translatedpolygon);
         result = unionGeom3Sub(result, extrudedface);
-        const vertices = polygon3.vertices;
+        const vertices = polygon4.vertices;
         for (let i = 0; i < vertices.length; i++) {
-          mapPlaneToVertex(vertices2planes, vertices[i], poly3.plane(polygon3));
+          mapPlaneToVertex(vertices2planes, vertices[i], poly3.plane(polygon4));
           const j = (i + 1) % vertices.length;
           const edge = [vertices[i], vertices[j]];
-          mapPlaneToEdge(edges2planes, edge, poly3.plane(polygon3));
+          mapPlaneToEdge(edges2planes, edge, poly3.plane(polygon4));
         }
       });
       edges2planes.forEach((item) => {
@@ -11831,8 +11831,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 polygon4 = poly3.create(points);
+              polygons2.push(polygon4);
             }
             prevp1 = p1;
             prevp2 = p2;
@@ -11841,7 +11841,7 @@ var require_expandShell = __commonJS({
         endfacevertices.reverse();
         polygons2.push(poly3.create(startfacevertices));
         polygons2.push(poly3.create(endfacevertices));
-        const cylinder2 = geom32.create(polygons2);
+        const cylinder2 = geom33.create(polygons2);
         result = unionGeom3Sub(result, cylinder2);
       });
       vertices2planes.forEach((item) => {
@@ -11885,7 +11885,7 @@ var require_expandShell = __commonJS({
 var require_expandGeom3 = __commonJS({
   "node_modules/@jscad/modeling/src/operations/expansions/expandGeom3.js"(exports, module) {
     "use strict";
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var union = require_union();
     var expandShell = require_expandShell();
     var expandGeom3 = (options, geometry) => {
@@ -11898,7 +11898,7 @@ var require_expandGeom3 = __commonJS({
       if (!(corners === "round")) {
         throw new Error('corners must be "round" for 3D geometries');
       }
-      const polygons = geom32.toPolygons(geometry);
+      const polygons = geom33.toPolygons(geometry);
       if (polygons.length === 0) throw new Error("the given geometry cannot be empty");
       options = { delta, corners, segments };
       const expanded = expandShell(options, geometry);
@@ -11995,7 +11995,7 @@ var require_expand = __commonJS({
     "use strict";
     var flatten = require_flatten();
     var geom2 = require_geom2();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var path2 = require_path2();
     var expandGeom2 = require_expandGeom2();
     var expandGeom3 = require_expandGeom3();
@@ -12006,7 +12006,7 @@ var require_expand = __commonJS({
       const results = objects.map((object) => {
         if (path2.isA(object)) return expandPath2(options, object);
         if (geom2.isA(object)) return expandGeom2(options, object);
-        if (geom32.isA(object)) return expandGeom3(options, object);
+        if (geom33.isA(object)) return expandGeom3(options, object);
         return object;
       });
       return results.length === 1 ? results[0] : results;
@@ -12034,7 +12034,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, polygon4) => acc + poly2.arePointsInside(outline, poly2.create(polygon4)), 0);
         const outside = level % 2 === 0;
         options = {
           delta: outside ? delta : -delta,
@@ -12182,7 +12182,7 @@ var require_extrudeLinear = __commonJS({
     var path2 = require_path2();
     var extrudeLinearGeom2 = require_extrudeLinearGeom2();
     var extrudeLinearPath2 = require_extrudeLinearPath2();
-    var extrudeLinear3 = (options, ...objects) => {
+    var extrudeLinear4 = (options, ...objects) => {
       const defaults = {
         height: 1,
         twistAngle: 0,
@@ -12200,7 +12200,7 @@ var require_extrudeLinear = __commonJS({
       });
       return results.length === 1 ? results[0] : results;
     };
-    module.exports = extrudeLinear3;
+    module.exports = extrudeLinear4;
   }
 });
 
@@ -12368,7 +12368,7 @@ var require_project = __commonJS({
     var plane = require_plane();
     var mat4 = require_mat4();
     var geom2 = require_geom2();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var poly3 = require_poly3();
     var measureEpsilon = require_measureEpsilon();
     var unionGeom2 = require_unionGeom2();
@@ -12380,7 +12380,7 @@ var require_project = __commonJS({
       const epsilon = measureEpsilon(geometry);
       const epsilonArea = epsilon * epsilon * Math.sqrt(3) / 4;
       if (epsilon === 0) return geom2.create();
-      const polygons = geom32.toPolygons(geometry);
+      const polygons = geom33.toPolygons(geometry);
       let projpolys = [];
       for (let i = 0; i < polygons.length; i++) {
         const newpoints = polygons[i].vertices.map((v) => plane.projectionOfPoint(projplane, v));
@@ -12409,7 +12409,7 @@ var require_project = __commonJS({
       if (objects.length === 0) throw new Error("wrong number of arguments");
       options = { axis, origin };
       const results = objects.map((object) => {
-        if (geom32.isA(object)) return projectGeom3(options, object);
+        if (geom33.isA(object)) return projectGeom3(options, object);
         return object;
       });
       return results.length === 1 ? results[0] : results;
@@ -12481,7 +12481,7 @@ var require_toUniquePoints = __commonJS({
   "node_modules/@jscad/modeling/src/operations/hulls/toUniquePoints.js"(exports, module) {
     "use strict";
     var geom2 = require_geom2();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var path2 = require_path2();
     var toUniquePoints = (geometries) => {
       const found = /* @__PURE__ */ new Set();
@@ -12496,8 +12496,8 @@ var require_toUniquePoints = __commonJS({
       geometries.forEach((geometry) => {
         if (geom2.isA(geometry)) {
           geom2.toPoints(geometry).forEach(addPoint);
-        } else if (geom32.isA(geometry)) {
-          geom32.toPoints(geometry).forEach((points) => points.forEach(addPoint));
+        } else if (geom33.isA(geometry)) {
+          geom33.toPoints(geometry).forEach((points) => points.forEach(addPoint));
         } else if (path2.isA(geometry)) {
           path2.toPoints(geometry).forEach(addPoint);
         }
@@ -12568,14 +12568,14 @@ var require_hullGeom3 = __commonJS({
   "node_modules/@jscad/modeling/src/operations/hulls/hullGeom3.js"(exports, module) {
     "use strict";
     var flatten = require_flatten();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var toUniquePoints = require_toUniquePoints();
     var hullPoints3 = require_hullPoints3();
     var hullGeom3 = (...geometries) => {
       geometries = flatten(geometries);
       const unique = toUniquePoints(geometries);
-      if (unique.length === 0) return geom32.create();
-      return geom32.create(hullPoints3(unique));
+      if (unique.length === 0) return geom33.create();
+      return geom33.create(hullPoints3(unique));
     };
     module.exports = hullGeom3;
   }
@@ -12588,7 +12588,7 @@ var require_hull = __commonJS({
     var flatten = require_flatten();
     var areAllShapesTheSameType = require_areAllShapesTheSameType();
     var geom2 = require_geom2();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var path2 = require_path2();
     var hullPath2 = require_hullPath2();
     var hullGeom2 = require_hullGeom2();
@@ -12602,7 +12602,7 @@ var require_hull = __commonJS({
       const geometry = geometries[0];
       if (path2.isA(geometry)) return hullPath2(geometries);
       if (geom2.isA(geometry)) return hullGeom2(geometries);
-      if (geom32.isA(geometry)) return hullGeom3(geometries);
+      if (geom33.isA(geometry)) return hullGeom3(geometries);
       return geometry;
     };
     module.exports = hull;
@@ -12648,24 +12648,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, polygon4) => {
+      const area = Math.abs(poly3.measureArea(polygon4));
       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((polygon4) => {
+        const snapvertices = polygon4.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 (polygon4.color) newpolygon.color = polygon4.color;
         return newpolygon;
       });
       const epsilonArea = epsilon * epsilon * Math.sqrt(3) / 4;
-      newpolygons = newpolygons.filter((polygon3) => isValidPoly3(epsilonArea, polygon3));
+      newpolygons = newpolygons.filter((polygon4) => isValidPoly3(epsilonArea, polygon4));
       return newpolygons;
     };
     module.exports = snapPolygons;
@@ -12679,8 +12679,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 = (polygon4) => {
+      const points = poly3.toPoints(polygon4);
       const edges = [];
       for (let i = 0; i < points.length; i++) {
         const j = (i + 1) % points.length;
@@ -12729,7 +12729,7 @@ var require_mergePolygons = __commonJS({
       return vec3.dot(d0, normal);
     };
     var createPolygonAnd = (edge) => {
-      let polygon3;
+      let polygon4;
       const points = [];
       while (edge.next) {
         const next = edge.next;
@@ -12740,8 +12740,8 @@ var require_mergePolygons = __commonJS({
         edge.prev = null;
         edge = next;
       }
-      if (points.length > 0) polygon3 = poly3.create(points);
-      return polygon3;
+      if (points.length > 0) polygon4 = poly3.create(points);
+      return polygon4;
     };
     var mergeCoplanarPolygons = (sourcepolygons) => {
       if (sourcepolygons.length < 2) return sourcepolygons;
@@ -12749,8 +12749,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 polygon4 = polygons.shift();
+        const edges = createEdges(polygon4);
         for (let i = 0; i < edges.length; i++) {
           const current = edges[i];
           const opposite = findOppositeEdge(edgeList, current);
@@ -12806,8 +12806,8 @@ var require_mergePolygons = __commonJS({
       }
       const destpolygons = [];
       edgeList.forEach((edge) => {
-        const polygon3 = createPolygonAnd(edge);
-        if (polygon3) destpolygons.push(polygon3);
+        const polygon4 = createPolygonAnd(edge);
+        if (polygon4) destpolygons.push(polygon4);
       });
       edgeList.clear();
       return destpolygons;
@@ -12820,13 +12820,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((polygon4) => {
+        const mapping = polygonsPerPlane.find((element) => coplanar(element[0], poly3.plane(polygon4)));
         if (mapping) {
           const polygons2 = mapping[1];
-          polygons2.push(polygon3);
+          polygons2.push(polygon4);
         } else {
-          polygonsPerPlane.push([poly3.plane(polygon3), [polygon3]]);
+          polygonsPerPlane.push([poly3.plane(polygon4), [polygon4]]);
         }
       });
       let destpolygons = [];
@@ -12922,15 +12922,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 polygon4 = polygons[polygonindex];
+        const numvertices = polygon4.vertices.length;
         if (numvertices >= 3) {
-          let vertex = polygon3.vertices[0];
+          let vertex = polygon4.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 = polygon4.vertices[nextvertexindex];
             const nextvertextag = getTag(nextvertex);
             const sidetag = `${vertextag}/${nextvertextag}`;
             const reversesidetag = `${nextvertextag}/${vertextag}`;
@@ -13038,17 +13038,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 polygon4 = 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 < polygon4.vertices.length; i++) {
+                          if (getTag(polygon4.vertices[i]) === insertionvertextag) {
                             insertionvertextagindex = i;
                             break;
                           }
                         }
                         if (assert && insertionvertextagindex < 0) throw new Error("assert failed");
-                        const newvertices = polygon3.vertices.slice(0);
+                        const newvertices = polygon4.vertices.slice(0);
                         newvertices.splice(insertionvertextagindex, 0, endvertex);
                         const newpolygon = poly3.create(newvertices);
                         newpolygons[polygonindex] = newpolygon;
@@ -13088,35 +13088,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, polygon4, triangles) => {
+      const nv = polygon4.vertices.length;
       if (nv > 3) {
         if (nv > 4) {
           const midpoint = [0, 0, 0];
-          polygon3.vertices.forEach((vertice) => vec3.add(midpoint, midpoint, vertice));
+          polygon4.vertices.forEach((vertice) => vec3.add(midpoint, midpoint, vertice));
           vec3.snap(midpoint, vec3.divide(midpoint, midpoint, [nv, nv, nv]), epsilon);
           for (let i = 0; i < nv; i++) {
-            const poly = poly3.create([midpoint, polygon3.vertices[i], polygon3.vertices[(i + 1) % nv]]);
-            if (polygon3.color) poly.color = polygon3.color;
+            const poly = poly3.create([midpoint, polygon4.vertices[i], polygon4.vertices[(i + 1) % nv]]);
+            if (polygon4.color) poly.color = polygon4.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([polygon4.vertices[0], polygon4.vertices[1], polygon4.vertices[2]]);
+        const poly1 = poly3.create([polygon4.vertices[0], polygon4.vertices[2], polygon4.vertices[3]]);
+        if (polygon4.color) {
+          poly0.color = polygon4.color;
+          poly1.color = polygon4.color;
         }
         triangles.push(poly0, poly1);
         return;
       }
-      triangles.push(polygon3);
+      triangles.push(polygon4);
     };
     var triangulatePolygons = (epsilon, polygons) => {
       const triangles = [];
-      polygons.forEach((polygon3) => {
-        triangulatePolygon(epsilon, polygon3, triangles);
+      polygons.forEach((polygon4) => {
+        triangulatePolygon(epsilon, polygon4, triangles);
       });
       return triangles;
     };
@@ -13131,7 +13131,7 @@ var require_generalize = __commonJS({
     var flatten = require_flatten();
     var measureEpsilon = require_measureEpsilon();
     var geom2 = require_geom2();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var path2 = require_path2();
     var snapPolygons = require_snapPolygons();
     var mergePolygons = require_mergePolygons();
@@ -13147,7 +13147,7 @@ var require_generalize = __commonJS({
       };
       const { snap, simplify, triangulate } = Object.assign({}, defaults, options);
       const epsilon = measureEpsilon(geometry);
-      let polygons = geom32.toPolygons(geometry);
+      let polygons = geom33.toPolygons(geometry);
       if (snap) {
         polygons = snapPolygons(epsilon, polygons);
       }
@@ -13168,7 +13168,7 @@ var require_generalize = __commonJS({
       const results = geometries.map((geometry) => {
         if (path2.isA(geometry)) return generalizePath2(options, geometry);
         if (geom2.isA(geometry)) return generalizeGeom2(options, geometry);
-        if (geom32.isA(geometry)) return generalizeGeom3(options, geometry);
+        if (geom33.isA(geometry)) return generalizeGeom3(options, geometry);
         throw new Error("invalid geometry");
       });
       return results.length === 1 ? results[0] : results;
@@ -13184,7 +13184,7 @@ var require_snap3 = __commonJS({
     var flatten = require_flatten();
     var vec2 = require_vec2();
     var geom2 = require_geom2();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var path2 = require_path2();
     var measureEpsilon = require_measureEpsilon();
     var snapPolygons = require_snapPolygons();
@@ -13203,9 +13203,9 @@ var require_snap3 = __commonJS({
     };
     var snapGeom3 = (geometry) => {
       const epsilon = measureEpsilon(geometry);
-      const polygons = geom32.toPolygons(geometry);
+      const polygons = geom33.toPolygons(geometry);
       const newpolygons = snapPolygons(epsilon, polygons);
-      return geom32.create(newpolygons);
+      return geom33.create(newpolygons);
     };
     var snap = (...geometries) => {
       geometries = flatten(geometries);
@@ -13213,7 +13213,7 @@ var require_snap3 = __commonJS({
       const results = geometries.map((geometry) => {
         if (path2.isA(geometry)) return snapPath2(geometry);
         if (geom2.isA(geometry)) return snapGeom2(geometry);
-        if (geom32.isA(geometry)) return snapGeom3(geometry);
+        if (geom33.isA(geometry)) return snapGeom3(geometry);
         return geometry;
       });
       return results.length === 1 ? results[0] : results;
@@ -13256,7 +13256,7 @@ var require_align = __commonJS({
     var flatten = require_flatten();
     var padArrayToLength = require_padArrayToLength();
     var measureAggregateBoundingBox = require_measureAggregateBoundingBox();
-    var { translate: translate3 } = require_translate2();
+    var { translate: translate4 } = require_translate2();
     var validateOptions = (options) => {
       if (!Array.isArray(options.modes) || options.modes.length > 3) throw new Error("align(): modes must be an array of length <= 3");
       options.modes = padArrayToLength(options.modes, "none", 3);
@@ -13293,7 +13293,7 @@ var require_align = __commonJS({
           translation[i] = relativeTo[i] - bounds[0][i];
         }
       }
-      return translate3(translation, geometry);
+      return translate4(translation, geometry);
     };
     var align = (options, ...geometries) => {
       const defaults = {
@@ -13327,22 +13327,22 @@ var require_center = __commonJS({
     "use strict";
     var flatten = require_flatten();
     var geom2 = require_geom2();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var path2 = require_path2();
-    var measureBoundingBox2 = require_measureBoundingBox2();
-    var { translate: translate3 } = require_translate2();
+    var measureBoundingBox3 = require_measureBoundingBox2();
+    var { translate: translate4 } = require_translate2();
     var centerGeometry = (options, object) => {
       const defaults = {
         axes: [true, true, true],
         relativeTo: [0, 0, 0]
       };
       const { axes, relativeTo } = Object.assign({}, defaults, options);
-      const bounds = measureBoundingBox2(object);
+      const bounds = measureBoundingBox3(object);
       const offset = [0, 0, 0];
       if (axes[0]) offset[0] = relativeTo[0] - (bounds[0][0] + (bounds[1][0] - bounds[0][0]) / 2);
       if (axes[1]) offset[1] = relativeTo[1] - (bounds[0][1] + (bounds[1][1] - bounds[0][1]) / 2);
       if (axes[2]) offset[2] = relativeTo[2] - (bounds[0][2] + (bounds[1][2] - bounds[0][2]) / 2);
-      return translate3(offset, object);
+      return translate4(offset, object);
     };
     var center = (options, ...objects) => {
       const defaults = {
@@ -13358,7 +13358,7 @@ var require_center = __commonJS({
       const results = objects.map((object) => {
         if (path2.isA(object)) return centerGeometry(options, object);
         if (geom2.isA(object)) return centerGeometry(options, object);
-        if (geom32.isA(object)) return centerGeometry(options, object);
+        if (geom33.isA(object)) return centerGeometry(options, object);
         return object;
       });
       return results.length === 1 ? results[0] : results;
@@ -13382,7 +13382,7 @@ var require_scale4 = __commonJS({
     var flatten = require_flatten();
     var mat4 = require_mat4();
     var geom2 = require_geom2();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var path2 = require_path2();
     var scale = (factors, ...objects) => {
       if (!Array.isArray(factors)) throw new Error("factors must be an array");
@@ -13395,7 +13395,7 @@ var require_scale4 = __commonJS({
       const results = objects.map((object) => {
         if (path2.isA(object)) return path2.transform(matrix, object);
         if (geom2.isA(object)) return geom2.transform(matrix, object);
-        if (geom32.isA(object)) return geom32.transform(matrix, object);
+        if (geom33.isA(object)) return geom33.transform(matrix, object);
         return object;
       });
       return results.length === 1 ? results[0] : results;
@@ -13418,7 +13418,7 @@ var require_transform12 = __commonJS({
     "use strict";
     var flatten = require_flatten();
     var geom2 = require_geom2();
-    var geom32 = require_geom3();
+    var geom33 = require_geom3();
     var path2 = require_path2();
     var transform = (matrix, ...objects) => {
       objects = flatten(objects);
@@ -13426,7 +13426,7 @@ var require_transform12 = __commonJS({
       const results = objects.map((object) => {
         if (path2.isA(object)) return path2.transform(matrix, object);
         if (geom2.isA(object)) return geom2.transform(matrix, object);
-        if (geom32.isA(object)) return geom32.transform(matrix, object);
+        if (geom33.isA(object)) return geom33.transform(matrix, object);
         return object;
       });
       return results.length === 1 ? results[0] : results;
@@ -14969,8 +14969,14 @@ var createBoardMesh = (board, options) => {
 };
 
 // lib/converters/circuit-to-3d.ts
+var import_extrusions3 = __toESM(require_extrusions(), 1);
+var import_primitives3 = __toESM(require_primitives(), 1);
+var import_transforms3 = __toESM(require_transforms(), 1);
+var geom32 = __toESM(require_geom3(), 1);
+var import_measureBoundingBox2 = __toESM(require_measureBoundingBox2(), 1);
 var DEFAULT_BOARD_THICKNESS = 1.6;
 var DEFAULT_COMPONENT_HEIGHT = 2;
+var COPPER_THICKNESS = 0.035;
 function convertRotationFromCadRotation(rot) {
   return {
     x: rot.x * Math.PI / 180,
@@ -14982,6 +14988,7 @@ async function convertCircuitJsonTo3D(circuitJson, options = {}) {
   const {
     pcbColor = "rgba(0,140,0,0.8)",
     componentColor = "rgba(128,128,128,0.5)",
+    copperColor = "#C87B4B",
     boardThickness = DEFAULT_BOARD_THICKNESS,
     defaultComponentHeight = DEFAULT_COMPONENT_HEIGHT,
     renderBoardTextures: shouldRenderTextures = true,
@@ -15042,6 +15049,63 @@ async function convertCircuitJsonTo3D(circuitJson, options = {}) {
     }
     boxes.push(boardBox);
   }
+  const pcbPours = db.pcb_copper_pour?.list?.() ?? [];
+  for (const pour of pcbPours) {
+    const isBottomLayer = pour.layer === "bottom";
+    const y = isBottomLayer ? -(effectiveBoardThickness / 2) - COPPER_THICKNESS / 2 : effectiveBoardThickness / 2 + COPPER_THICKNESS / 2;
+    if (pour.shape === "rect") {
+      const box = {
+        center: {
+          x: pour.center.x,
+          y,
+          z: pour.center.y
+        },
+        size: {
+          x: pour.width,
+          y: COPPER_THICKNESS,
+          z: pour.height
+        },
+        rotation: { x: 0, y: 0, z: 0 },
+        color: pour.covered_with_solder_mask ? pcbColor : copperColor
+      };
+      if (pour.rotation && typeof pour.rotation === "number") {
+        box.rotation.y = -(pour.rotation * Math.PI) / 180;
+      }
+      boxes.push(box);
+    } else if (pour.shape === "polygon") {
+      const { points } = pour;
+      let center_x = 0;
+      let center_y = 0;
+      for (const p of points) {
+        center_x += p.x;
+        center_y += p.y;
+      }
+      center_x /= points.length;
+      center_y /= points.length;
+      const relativePoints = points.map((p) => [
+        p.x - center_x,
+        -(p.y - center_y)
+      ]);
+      if (arePointsClockwise(relativePoints)) {
+        relativePoints.reverse();
+      }
+      const shape2d = (0, import_primitives3.polygon)({ points: relativePoints });
+      let geom = (0, import_extrusions3.extrudeLinear)({ height: COPPER_THICKNESS }, shape2d);
+      geom = (0, import_transforms3.translate)([0, 0, -COPPER_THICKNESS / 2], geom);
+      geom = (0, import_transforms3.rotateX)(-Math.PI / 2, geom);
+      const triangles = geom3ToTriangles(geom);
+      const bbox = createBoundingBox((0, import_measureBoundingBox2.default)(geom));
+      const mesh = { triangles, boundingBox: bbox };
+      const box = {
+        center: { x: center_x, y, z: center_y },
+        size: { x: 1, y: 1, z: 1 },
+        // size doesn't matter much as we provide mesh
+        mesh,
+        color: pour.covered_with_solder_mask ? pcbColor : copperColor
+      };
+      boxes.push(box);
+    }
+  }
   const cadComponents = db.cad_component?.list?.() ?? [];
   const pcbComponentIdsWith3D = /* @__PURE__ */ new Set();
   for (const cad of cadComponents) {