@jgphilpott/polytree 0.1.3 → 0.1.5

package/polytree.bundle.browser.esm.js

@@ -0,0 +1,3759 @@
+// polytree.bundle.browser.js
+import { Vector2, Vector3, Box3, Line3, Sphere, Matrix3, Triangle, Ray, Raycaster, Mesh, DoubleSide, BufferGeometry, BufferAttribute, Plane as ThreePlane } from "three";
+var ASYNC_OPERATION_TIMEOUT;
+var DEBUG_COLOR_BACK;
+var DEBUG_COLOR_COPLANAR;
+var DEBUG_COLOR_FRONT;
+var DEBUG_COLOR_SPANNING;
+var DEBUG_GEOMETRY_VALIDATION;
+var DEBUG_INTERSECTION_VERIFICATION;
+var DEBUG_PERFORMANCE_TIMING;
+var DEBUG_VERBOSE_LOGGING;
+var DEFAULT_BUFFER_SIZE;
+var DEFAULT_COORDINATE_PRECISION;
+var DEFAULT_MATERIAL_INDEX;
+var GARBAGE_COLLECTION_THRESHOLD;
+var GEOMETRIC_EPSILON;
+var GEOMETRY_CACHE_SIZE;
+var INTERSECTION_CACHE_SIZE;
+var MAX_REFINEMENT_ITERATIONS;
+var MAX_WORKER_THREADS;
+var MEMORY_USAGE_WARNING_LIMIT;
+var POINT_COINCIDENCE_THRESHOLD;
+var POLYGON_BACK;
+var POLYGON_COPLANAR;
+var POLYGON_FRONT;
+var POLYGON_SPANNING;
+var POLYTREE_MAX_DEPTH;
+var POLYTREE_MAX_POLYGONS_PER_NODE;
+var POLYTREE_MIN_NODE_SIZE;
+var RAY_INTERSECTION_EPSILON;
+var TRIANGLE_2D_EPSILON;
+var WINDING_NUMBER_FULL_ROTATION;
+var defaultRayDirection;
+var meshOperationNormalVector;
+var meshOperationVertexVector;
+var polygonID;
+var rayTriangleEdge1;
+var rayTriangleEdge2;
+var rayTriangleHVector;
+var rayTriangleQVector;
+var rayTriangleSVector;
+var temporaryBoundingBox;
+var temporaryMatrix3;
+var temporaryMatrixWithNormalCalc;
+var temporaryRay;
+var temporaryRaycaster;
+var temporaryTriangleVertex;
+var temporaryTriangleVertexSecondary;
+var temporaryVector3Primary;
+var temporaryVector3Quaternary;
+var temporaryVector3Secondary;
+var temporaryVector3Tertiary;
+var windingNumberEpsilonOffsets;
+var windingNumberEpsilonOffsetsCount;
+var windingNumberMatrix3;
+var windingNumberTestPoint;
+var windingNumberVector1;
+var windingNumberVector2;
+var windingNumberVector3;
+GEOMETRIC_EPSILON = 1e-8;
+RAY_INTERSECTION_EPSILON = 1e-12;
+TRIANGLE_2D_EPSILON = 1e-14;
+WINDING_NUMBER_FULL_ROTATION = 4 * Math.PI;
+POLYGON_COPLANAR = 0;
+POLYGON_FRONT = 1;
+POLYGON_BACK = 2;
+POLYGON_SPANNING = 3;
+temporaryVector3Primary = new Vector3();
+temporaryVector3Secondary = new Vector3();
+temporaryVector3Tertiary = new Vector3();
+temporaryVector3Quaternary = new Vector3();
+temporaryBoundingBox = new Box3();
+temporaryRaycaster = new Raycaster();
+temporaryRay = new Ray();
+defaultRayDirection = new Vector3(0, 0, 1);
+windingNumberVector1 = new Vector3();
+windingNumberVector2 = new Vector3();
+windingNumberVector3 = new Vector3();
+windingNumberTestPoint = new Vector3();
+windingNumberEpsilonOffsets = [new Vector3(GEOMETRIC_EPSILON, 0, 0), new Vector3(0, GEOMETRIC_EPSILON, 0), new Vector3(0, 0, GEOMETRIC_EPSILON), new Vector3(-GEOMETRIC_EPSILON, 0, 0), new Vector3(0, -GEOMETRIC_EPSILON, 0), new Vector3(0, 0, -GEOMETRIC_EPSILON)];
+windingNumberEpsilonOffsetsCount = windingNumberEpsilonOffsets.length;
+windingNumberMatrix3 = new Matrix3();
+rayTriangleEdge1 = new Vector3();
+rayTriangleEdge2 = new Vector3();
+rayTriangleHVector = new Vector3();
+rayTriangleSVector = new Vector3();
+rayTriangleQVector = new Vector3();
+temporaryTriangleVertex = new Vector3();
+temporaryTriangleVertexSecondary = new Vector3();
+temporaryMatrix3 = new Matrix3();
+temporaryMatrixWithNormalCalc = new Matrix3();
+temporaryMatrixWithNormalCalc.getNormalMatrix = function(matrix) {
+  return this.setFromMatrix4(matrix).invert().transpose();
+};
+meshOperationNormalVector = new Vector3();
+meshOperationVertexVector = new Vector3();
+POLYTREE_MAX_DEPTH = 1e3;
+POLYTREE_MAX_POLYGONS_PER_NODE = 1e5;
+POLYTREE_MIN_NODE_SIZE = 1e-6;
+DEFAULT_MATERIAL_INDEX = 0;
+MAX_REFINEMENT_ITERATIONS = 1e4;
+DEFAULT_COORDINATE_PRECISION = 15;
+POINT_COINCIDENCE_THRESHOLD = 1e-15;
+DEFAULT_BUFFER_SIZE = 16384;
+MAX_WORKER_THREADS = Infinity;
+ASYNC_OPERATION_TIMEOUT = Infinity;
+GARBAGE_COLLECTION_THRESHOLD = 1e5;
+MEMORY_USAGE_WARNING_LIMIT = 0.95;
+GEOMETRY_CACHE_SIZE = Infinity;
+INTERSECTION_CACHE_SIZE = Infinity;
+polygonID = 0;
+DEBUG_VERBOSE_LOGGING = false;
+DEBUG_PERFORMANCE_TIMING = false;
+DEBUG_GEOMETRY_VALIDATION = false;
+DEBUG_INTERSECTION_VERIFICATION = false;
+DEBUG_COLOR_FRONT = 65280;
+DEBUG_COLOR_BACK = 16711680;
+DEBUG_COLOR_COPLANAR = 255;
+DEBUG_COLOR_SPANNING = 16776960;
+if (typeof module !== "undefined" && module.exports) {
+}
+var calculateWindingNumberFromBuffer;
+var checkMemoryUsage;
+var clearGeometryCache;
+var clearIntersectionCache;
+var createIntersectionCacheKey;
+var createVector2Buffer;
+var createVector3Buffer;
+var disposePolytreeResources;
+var extractCoordinatesFromArray;
+var geometryCache;
+var geometryCacheKeys;
+var handleIntersectingPolytrees;
+var intersectionCache;
+var intersectionCacheKeys;
+var operationCounter;
+var prepareTriangleBufferFromPolygons;
+var roundPointCoordinates;
+var signedVolumeOfTriangle;
+var sortRaycastIntersectionsByDistance;
+var splitPolygonByPlane;
+var splitPolygonVertexArray;
+var testPolygonInsideUsingWindingNumber;
+var testRayTriangleIntersection;
+intersectionCache = /* @__PURE__ */ new Map();
+intersectionCacheKeys = [];
+geometryCache = /* @__PURE__ */ new Map();
+geometryCacheKeys = [];
+operationCounter = 0;
+clearIntersectionCache = function() {
+  var i, key, keysToRemove, len, results;
+  if (INTERSECTION_CACHE_SIZE !== Infinity && intersectionCache.size > INTERSECTION_CACHE_SIZE) {
+    keysToRemove = intersectionCacheKeys.splice(0, Math.floor(INTERSECTION_CACHE_SIZE / 2));
+    results = [];
+    for (i = 0, len = keysToRemove.length; i < len; i++) {
+      key = keysToRemove[i];
+      results.push(intersectionCache.delete(key));
+    }
+    return results;
+  }
+};
+clearGeometryCache = function() {
+  var i, key, keysToRemove, len, results;
+  if (GEOMETRY_CACHE_SIZE !== Infinity && geometryCache.size > GEOMETRY_CACHE_SIZE) {
+    keysToRemove = geometryCacheKeys.splice(0, Math.floor(GEOMETRY_CACHE_SIZE / 2));
+    results = [];
+    for (i = 0, len = keysToRemove.length; i < len; i++) {
+      key = keysToRemove[i];
+      results.push(geometryCache.delete(key));
+    }
+    return results;
+  }
+};
+createIntersectionCacheKey = function(polygonA, polygonB) {
+  return `${polygonA.id}_${polygonB.id}`;
+};
+checkMemoryUsage = function() {
+  var heapTotalMB, heapUsedMB, memoryUsage, usageRatio;
+  if (typeof process !== "undefined" && process.memoryUsage) {
+    memoryUsage = process.memoryUsage();
+    heapUsedMB = memoryUsage.heapUsed / 1024 / 1024;
+    heapTotalMB = memoryUsage.heapTotal / 1024 / 1024;
+    usageRatio = memoryUsage.heapUsed / memoryUsage.heapTotal;
+    if (DEBUG_VERBOSE_LOGGING) {
+      console.log(`Memory usage: ${heapUsedMB.toFixed(2)}MB / ${heapTotalMB.toFixed(2)}MB (${(usageRatio * 100).toFixed(1)}%)`);
+    }
+    if (usageRatio > MEMORY_USAGE_WARNING_LIMIT) {
+      console.warn(`Memory usage is high: ${(usageRatio * 100).toFixed(1)}%`);
+      if (typeof (typeof global !== "undefined" && global !== null ? global.gc : void 0) === "function") {
+        console.log("Triggering garbage collection...");
+        global.gc();
+      }
+    }
+    return usageRatio;
+  }
+  return 0;
+};
+createVector2Buffer = function(vectorCount = DEFAULT_BUFFER_SIZE) {
+  return {
+    top: 0,
+    array: new Float32Array(vectorCount * 2),
+    write: function(vector) {
+      this.array[this.top++] = vector.x;
+      return this.array[this.top++] = vector.y;
+    }
+  };
+};
+createVector3Buffer = function(vectorCount = DEFAULT_BUFFER_SIZE) {
+  return {
+    top: 0,
+    array: new Float32Array(vectorCount * 3),
+    write: function(vector) {
+      this.array[this.top++] = vector.x;
+      this.array[this.top++] = vector.y;
+      return this.array[this.top++] = vector.z;
+    }
+  };
+};
+sortRaycastIntersectionsByDistance = function(intersectionA, intersectionB) {
+  return intersectionA.distance - intersectionB.distance;
+};
+roundPointCoordinates = function(point, decimalPlaces = DEFAULT_COORDINATE_PRECISION) {
+  point.x = +point.x.toFixed(decimalPlaces);
+  point.y = +point.y.toFixed(decimalPlaces);
+  point.z = +point.z.toFixed(decimalPlaces);
+  return point;
+};
+extractCoordinatesFromArray = function(coordinatesArray, startIndex) {
+  return {
+    x: coordinatesArray[startIndex],
+    y: coordinatesArray[startIndex + 1],
+    z: coordinatesArray[startIndex + 2]
+  };
+};
+splitPolygonByPlane = function(polygon, plane, result = []) {
+  var backPolygonFragments, backVertices, currentVertex, currentVertexType, distanceToPlane, fragmentIndex, frontPolygonFragments, frontVertices, i, interpolatedVertex, intersectionParameter, j, k, l, nextVertex, nextVertexIndex, nextVertexType, polygonType, ref, ref1, ref2, ref3, returnPolygon, vertexIndex, vertexType, vertexTypes;
+  returnPolygon = {
+    polygon,
+    type: "undecided"
+  };
+  polygonType = 0;
+  vertexTypes = [];
+  for (vertexIndex = i = 0, ref = polygon.vertices.length; 0 <= ref ? i < ref : i > ref; vertexIndex = 0 <= ref ? ++i : --i) {
+    distanceToPlane = plane.normal.dot(polygon.vertices[vertexIndex].pos) - plane.distanceFromOrigin;
+    vertexType = distanceToPlane < -GEOMETRIC_EPSILON ? POLYGON_BACK : distanceToPlane > GEOMETRIC_EPSILON ? POLYGON_FRONT : POLYGON_COPLANAR;
+    polygonType |= vertexType;
+    vertexTypes.push(vertexType);
+  }
+  switch (polygonType) {
+    case POLYGON_COPLANAR:
+      returnPolygon.type = plane.normal.dot(polygon.plane.normal) > 0 ? "coplanar-front" : "coplanar-back";
+      result.push(returnPolygon);
+      break;
+    case POLYGON_FRONT:
+      returnPolygon.type = "front";
+      result.push(returnPolygon);
+      break;
+    case POLYGON_BACK:
+      returnPolygon.type = "back";
+      result.push(returnPolygon);
+      break;
+    case POLYGON_SPANNING:
+      frontVertices = [];
+      backVertices = [];
+      for (vertexIndex = j = 0, ref1 = polygon.vertices.length; 0 <= ref1 ? j < ref1 : j > ref1; vertexIndex = 0 <= ref1 ? ++j : --j) {
+        nextVertexIndex = (vertexIndex + 1) % polygon.vertices.length;
+        currentVertexType = vertexTypes[vertexIndex];
+        nextVertexType = vertexTypes[nextVertexIndex];
+        currentVertex = polygon.vertices[vertexIndex];
+        nextVertex = polygon.vertices[nextVertexIndex];
+        if (currentVertexType !== POLYGON_BACK) {
+          frontVertices.push(currentVertex);
+        }
+        if (currentVertexType !== POLYGON_FRONT) {
+          backVertices.push(currentVertexType !== POLYGON_BACK ? currentVertex.clone() : currentVertex);
+        }
+        if ((currentVertexType | nextVertexType) === POLYGON_SPANNING) {
+          intersectionParameter = (plane.distanceFromOrigin - plane.normal.dot(currentVertex.pos)) / plane.normal.dot(temporaryTriangleVertex.copy(nextVertex.pos).sub(currentVertex.pos));
+          interpolatedVertex = currentVertex.interpolate(nextVertex, intersectionParameter);
+          frontVertices.push(interpolatedVertex);
+          backVertices.push(interpolatedVertex.clone());
+        }
+      }
+      if (frontVertices.length >= 3) {
+        if (frontVertices.length > 3) {
+          frontPolygonFragments = splitPolygonVertexArray(frontVertices);
+          for (fragmentIndex = k = 0, ref2 = frontPolygonFragments.length; 0 <= ref2 ? k < ref2 : k > ref2; fragmentIndex = 0 <= ref2 ? ++k : --k) {
+            result.push({
+              polygon: new Polygon(frontPolygonFragments[fragmentIndex], polygon.shared),
+              type: "front"
+            });
+          }
+        } else {
+          result.push({
+            polygon: new Polygon(frontVertices, polygon.shared),
+            type: "front"
+          });
+        }
+      }
+      if (backVertices.length >= 3) {
+        if (backVertices.length > 3) {
+          backPolygonFragments = splitPolygonVertexArray(backVertices);
+          for (fragmentIndex = l = 0, ref3 = backPolygonFragments.length; 0 <= ref3 ? l < ref3 : l > ref3; fragmentIndex = 0 <= ref3 ? ++l : --l) {
+            result.push({
+              polygon: new Polygon(backPolygonFragments[fragmentIndex], polygon.shared),
+              type: "back"
+            });
+          }
+        } else {
+          result.push({
+            polygon: new Polygon(backVertices, polygon.shared),
+            type: "back"
+          });
+        }
+      }
+  }
+  if (result.length === 0) {
+    result.push(returnPolygon);
+  }
+  return result;
+};
+splitPolygonVertexArray = function(vertexArray) {
+  var i, ref, triangleFragments, triangleIndex, triangleVertices;
+  triangleFragments = [];
+  if (vertexArray.length > 4) {
+    console.warn("[splitPolygonVertexArray] vertexArray.length > 4", vertexArray.length);
+    for (triangleIndex = i = 3, ref = vertexArray.length; 3 <= ref ? i <= ref : i >= ref; triangleIndex = 3 <= ref ? ++i : --i) {
+      triangleVertices = [];
+      triangleVertices.push(vertexArray[0].clone());
+      triangleVertices.push(vertexArray[triangleIndex - 2].clone());
+      triangleVertices.push(vertexArray[triangleIndex - 1].clone());
+      triangleFragments.push(triangleVertices);
+    }
+  } else {
+    if (vertexArray[0].pos.distanceTo(vertexArray[2].pos) <= vertexArray[1].pos.distanceTo(vertexArray[3].pos)) {
+      triangleFragments.push([vertexArray[0].clone(), vertexArray[1].clone(), vertexArray[2].clone()], [vertexArray[0].clone(), vertexArray[2].clone(), vertexArray[3].clone()]);
+    } else {
+      triangleFragments.push([vertexArray[0].clone(), vertexArray[1].clone(), vertexArray[3].clone()], [vertexArray[1].clone(), vertexArray[2].clone(), vertexArray[3].clone()]);
+    }
+  }
+  return triangleFragments;
+};
+calculateWindingNumberFromBuffer = function(triangleDataArray, testPoint) {
+  var i, ref, solidAngle, triangleStartIndex, vectorLengthA, vectorLengthB, vectorLengthC, windingNumber;
+  windingNumber = 0;
+  for (triangleStartIndex = i = 0, ref = triangleDataArray.length; i < ref; triangleStartIndex = i += 9) {
+    windingNumberVector1.subVectors(extractCoordinatesFromArray(triangleDataArray, triangleStartIndex), testPoint);
+    windingNumberVector2.subVectors(extractCoordinatesFromArray(triangleDataArray, triangleStartIndex + 3), testPoint);
+    windingNumberVector3.subVectors(extractCoordinatesFromArray(triangleDataArray, triangleStartIndex + 6), testPoint);
+    vectorLengthA = windingNumberVector1.length();
+    vectorLengthB = windingNumberVector2.length();
+    vectorLengthC = windingNumberVector3.length();
+    if (vectorLengthA < POINT_COINCIDENCE_THRESHOLD || vectorLengthB < POINT_COINCIDENCE_THRESHOLD || vectorLengthC < POINT_COINCIDENCE_THRESHOLD) {
+      continue;
+    }
+    windingNumberMatrix3.set(windingNumberVector1.x, windingNumberVector1.y, windingNumberVector1.z, windingNumberVector2.x, windingNumberVector2.y, windingNumberVector2.z, windingNumberVector3.x, windingNumberVector3.y, windingNumberVector3.z);
+    solidAngle = 2 * Math.atan2(windingNumberMatrix3.determinant(), vectorLengthA * vectorLengthB * vectorLengthC + windingNumberVector1.dot(windingNumberVector2) * vectorLengthC + windingNumberVector2.dot(windingNumberVector3) * vectorLengthA + windingNumberVector3.dot(windingNumberVector1) * vectorLengthB);
+    windingNumber += solidAngle;
+  }
+  windingNumber = Math.round(windingNumber / WINDING_NUMBER_FULL_ROTATION);
+  return windingNumber;
+};
+testPolygonInsideUsingWindingNumber = function(triangleDataArray, testPoint, isCoplanar) {
+  var i, isInside, maxOffsetTests, offsetIndex, ref, windingNumber;
+  isInside = false;
+  windingNumberTestPoint.copy(testPoint);
+  windingNumber = calculateWindingNumberFromBuffer(triangleDataArray, windingNumberTestPoint);
+  if (windingNumber === 0) {
+    if (isCoplanar) {
+      maxOffsetTests = Math.min(windingNumberEpsilonOffsetsCount, MAX_REFINEMENT_ITERATIONS);
+      for (offsetIndex = i = 0, ref = maxOffsetTests; 0 <= ref ? i < ref : i > ref; offsetIndex = 0 <= ref ? ++i : --i) {
+        windingNumberTestPoint.copy(testPoint).add(windingNumberEpsilonOffsets[offsetIndex]);
+        windingNumber = calculateWindingNumberFromBuffer(triangleDataArray, windingNumberTestPoint);
+        if (windingNumber !== 0) {
+          isInside = true;
+          break;
+        }
+      }
+    }
+  } else {
+    isInside = true;
+  }
+  return isInside;
+};
+prepareTriangleBufferFromPolygons = function(polygonArray) {
+  var bufferIndex, coordinateArray, i, polygonIndex, ref, triangle, triangleCount;
+  triangleCount = polygonArray.length;
+  coordinateArray = new Float32Array(triangleCount * 3 * 3);
+  bufferIndex = 0;
+  for (polygonIndex = i = 0, ref = triangleCount; 0 <= ref ? i < ref : i > ref; polygonIndex = 0 <= ref ? ++i : --i) {
+    triangle = polygonArray[polygonIndex].triangle;
+    coordinateArray[bufferIndex++] = triangle.a.x;
+    coordinateArray[bufferIndex++] = triangle.a.y;
+    coordinateArray[bufferIndex++] = triangle.a.z;
+    coordinateArray[bufferIndex++] = triangle.b.x;
+    coordinateArray[bufferIndex++] = triangle.b.y;
+    coordinateArray[bufferIndex++] = triangle.b.z;
+    coordinateArray[bufferIndex++] = triangle.c.x;
+    coordinateArray[bufferIndex++] = triangle.c.y;
+    coordinateArray[bufferIndex++] = triangle.c.z;
+  }
+  return coordinateArray;
+};
+testRayTriangleIntersection = function(ray, triangle, targetVector = new Vector3()) {
+  var determinant, firstBarycentricCoordinate, intersectionDistance, inverseDeterminant, secondBarycentricCoordinate;
+  rayTriangleEdge1.subVectors(triangle.b, triangle.a);
+  rayTriangleEdge2.subVectors(triangle.c, triangle.a);
+  rayTriangleHVector.crossVectors(ray.direction, rayTriangleEdge2);
+  determinant = rayTriangleEdge1.dot(rayTriangleHVector);
+  if (determinant > -RAY_INTERSECTION_EPSILON && determinant < RAY_INTERSECTION_EPSILON) {
+    return null;
+  }
+  inverseDeterminant = 1 / determinant;
+  rayTriangleSVector.subVectors(ray.origin, triangle.a);
+  firstBarycentricCoordinate = inverseDeterminant * rayTriangleSVector.dot(rayTriangleHVector);
+  if (firstBarycentricCoordinate < 0 || firstBarycentricCoordinate > 1) {
+    return null;
+  }
+  rayTriangleQVector.crossVectors(rayTriangleSVector, rayTriangleEdge1);
+  secondBarycentricCoordinate = inverseDeterminant * ray.direction.dot(rayTriangleQVector);
+  if (secondBarycentricCoordinate < 0 || firstBarycentricCoordinate + secondBarycentricCoordinate > 1) {
+    return null;
+  }
+  intersectionDistance = inverseDeterminant * rayTriangleEdge2.dot(rayTriangleQVector);
+  if (intersectionDistance > RAY_INTERSECTION_EPSILON) {
+    return targetVector.copy(ray.direction).multiplyScalar(intersectionDistance).add(ray.origin);
+  }
+  return null;
+};
+handleIntersectingPolytrees = function(polytreeA, polytreeB, processBothDirections = true) {
+  var polytreeABuffer, polytreeBBuffer;
+  operationCounter++;
+  if (operationCounter >= GARBAGE_COLLECTION_THRESHOLD) {
+    operationCounter = 0;
+    clearIntersectionCache();
+    clearGeometryCache();
+    checkMemoryUsage();
+  }
+  polytreeABuffer = void 0;
+  polytreeBBuffer = void 0;
+  if (Polytree.useWindingNumber === true) {
+    if (processBothDirections) {
+      polytreeABuffer = prepareTriangleBufferFromPolygons(polytreeA.getPolygons());
+    }
+    polytreeBBuffer = prepareTriangleBufferFromPolygons(polytreeB.getPolygons());
+  }
+  polytreeA.handleIntersectingPolygons(polytreeB, polytreeBBuffer);
+  if (processBothDirections) {
+    polytreeB.handleIntersectingPolygons(polytreeA, polytreeABuffer);
+  }
+  if (polytreeABuffer !== void 0) {
+    polytreeABuffer = void 0;
+  }
+  if (polytreeBBuffer !== void 0) {
+    return polytreeBBuffer = void 0;
+  }
+};
+signedVolumeOfTriangle = function(vertex1, vertex2, vertex3) {
+  temporaryVector3Primary.copy(vertex2).cross(vertex3);
+  return vertex1.dot(temporaryVector3Primary) / 6;
+};
+disposePolytreeResources = function(...polytreeInstances) {
+  if (Polytree.disposePolytree) {
+    return polytreeInstances.forEach(function(polytreeInstance) {
+      return polytreeInstance.delete();
+    });
+  }
+};
+var handleObjectForOperation;
+var operationHandler;
+operationHandler = function(operationObject, returnPolytrees = false, buildTargetPolytree = true, options = {
+  objCounter: 0
+}, firstRun = true, async = true) {
+  var allPolygons, defaultMaterial, finalMesh, firstOperand, materialForMesh, ref, resultPolytree, secondOperand;
+  if (async) {
+    return new Promise(function(resolve, reject) {
+      var asyncError, firstOperand2, materialForMesh2, operandPromise, operandPromises, originalMaterialA, originalMaterialB, ref2, ref1, resultPolytree2, secondOperand2;
+      try {
+        firstOperand2 = void 0;
+        secondOperand2 = void 0;
+        resultPolytree2 = void 0;
+        materialForMesh2 = void 0;
+        originalMaterialA = (ref2 = operationObject.objA) != null ? ref2.material : void 0;
+        originalMaterialB = (ref1 = operationObject.objB) != null ? ref1.material : void 0;
+        if (operationObject.material) {
+          materialForMesh2 = operationObject.material;
+        }
+        operandPromises = [];
+        if (operationObject.objA) {
+          operandPromise = handleObjectForOperation(operationObject.objA, returnPolytrees, buildTargetPolytree, options, 0, async);
+          operandPromises.push(operandPromise);
+        }
+        if (operationObject.objB) {
+          operandPromise = handleObjectForOperation(operationObject.objB, returnPolytrees, buildTargetPolytree, options, 1, async);
+          operandPromises.push(operandPromise);
+        }
+        return Promise.allSettled(operandPromises).then(function(promiseResults) {
+          var operationPromise;
+          promiseResults.forEach(function(promiseResult) {
+            if (promiseResult.status === "fulfilled") {
+              if (promiseResult.value.objIndex === 0) {
+                return firstOperand2 = promiseResult.value;
+              } else if (promiseResult.value.objIndex === 1) {
+                return secondOperand2 = promiseResult.value;
+              }
+            }
+          });
+          if (returnPolytrees === true) {
+            if (firstOperand2) {
+              operationObject.objA = firstOperand2.original;
+              firstOperand2 = firstOperand2.result;
+            }
+            if (secondOperand2) {
+              operationObject.objB = secondOperand2.original;
+              secondOperand2 = secondOperand2.result;
+            }
+          }
+          operationPromise = void 0;
+          switch (operationObject.op) {
+            case "unite":
+              if (firstOperand2 && secondOperand2) {
+                operationPromise = Polytree.async.unite(firstOperand2, secondOperand2, buildTargetPolytree);
+              } else {
+                operationPromise = Promise.resolve(firstOperand2 || secondOperand2 || new Polytree());
+              }
+              break;
+            case "subtract":
+              if (firstOperand2 && secondOperand2) {
+                operationPromise = Polytree.async.subtract(firstOperand2, secondOperand2, buildTargetPolytree);
+              } else {
+                operationPromise = Promise.resolve(firstOperand2 || new Polytree());
+              }
+              break;
+            case "intersect":
+              if (firstOperand2 && secondOperand2) {
+                operationPromise = Polytree.async.intersect(firstOperand2, secondOperand2, buildTargetPolytree);
+              } else {
+                operationPromise = Promise.resolve(new Polytree());
+              }
+              break;
+            default:
+              operationPromise = Promise.resolve(new Polytree());
+          }
+          return operationPromise.then(function(resultPolytree3) {
+            var allPolygons2, defaultMaterial2, finalMesh2;
+            if (resultPolytree3 && !resultPolytree3.box && resultPolytree3.bounds) {
+              resultPolytree3.buildTree();
+            }
+            if (firstRun && !returnPolytrees) {
+              allPolygons2 = resultPolytree3.getPolygons();
+              if (!resultPolytree3 || allPolygons2.length === 0) {
+                resolve(void 0);
+                return;
+              }
+              if (materialForMesh2) {
+                finalMesh2 = Polytree.toMesh(resultPolytree3, materialForMesh2);
+              } else {
+                defaultMaterial2 = void 0;
+                if (originalMaterialA) {
+                  defaultMaterial2 = Array.isArray(originalMaterialA) ? originalMaterialA[0] : originalMaterialA;
+                  defaultMaterial2 = defaultMaterial2.clone();
+                } else if (originalMaterialB) {
+                  defaultMaterial2 = Array.isArray(originalMaterialB) ? originalMaterialB[0] : originalMaterialB;
+                  defaultMaterial2 = defaultMaterial2.clone();
+                } else {
+                  resolve(void 0);
+                  return;
+                }
+                finalMesh2 = Polytree.toMesh(resultPolytree3, defaultMaterial2);
+              }
+              disposePolytreeResources(resultPolytree3);
+              resolve(finalMesh2);
+            } else if (firstRun && returnPolytrees) {
+              if (materialForMesh2) {
+                finalMesh2 = Polytree.toMesh(resultPolytree3, materialForMesh2);
+                disposePolytreeResources(resultPolytree3);
+                resolve({
+                  result: finalMesh2,
+                  operationTree: operationObject
+                });
+              } else {
+                resolve({
+                  result: resultPolytree3,
+                  operationTree: operationObject
+                });
+              }
+            } else {
+              resolve(resultPolytree3);
+            }
+            if (!returnPolytrees) {
+              if (firstOperand2 || secondOperand2) {
+                return disposePolytreeResources(firstOperand2, secondOperand2);
+              }
+            }
+          }).catch(function(operationError) {
+            return reject(operationError);
+          });
+        });
+      } catch (error) {
+        asyncError = error;
+        return reject(asyncError);
+      }
+    });
+  } else {
+    firstOperand = void 0;
+    secondOperand = void 0;
+    resultPolytree = void 0;
+    materialForMesh = void 0;
+    if (operationObject.material) {
+      materialForMesh = operationObject.material;
+    }
+    if (operationObject.objA) {
+      firstOperand = handleObjectForOperation(operationObject.objA, returnPolytrees, buildTargetPolytree, options, void 0, async);
+      if (returnPolytrees === true) {
+        operationObject.objA = firstOperand.original;
+        firstOperand = firstOperand.result;
+      }
+    }
+    if (operationObject.objB) {
+      secondOperand = handleObjectForOperation(operationObject.objB, returnPolytrees, buildTargetPolytree, options, void 0, async);
+      if (returnPolytrees === true) {
+        operationObject.objB = secondOperand.original;
+        secondOperand = secondOperand.result;
+      }
+    }
+    switch (operationObject.op) {
+      case "unite":
+        if (firstOperand && secondOperand) {
+          resultPolytree = Polytree.unite(firstOperand, secondOperand, false);
+        } else {
+          resultPolytree = firstOperand || secondOperand || new Polytree();
+        }
+        break;
+      case "subtract":
+        if (firstOperand && secondOperand) {
+          resultPolytree = Polytree.subtract(firstOperand, secondOperand, false);
+        } else {
+          resultPolytree = firstOperand || new Polytree();
+        }
+        break;
+      case "intersect":
+        if (firstOperand && secondOperand) {
+          resultPolytree = Polytree.intersect(firstOperand, secondOperand, false);
+        } else {
+          resultPolytree = new Polytree();
+        }
+        break;
+      default:
+        resultPolytree = new Polytree();
+    }
+    if (resultPolytree && !resultPolytree.box && resultPolytree.bounds) {
+      resultPolytree.buildTree();
+    }
+    if (!returnPolytrees) {
+      if (firstOperand || secondOperand) {
+        disposePolytreeResources(firstOperand, secondOperand);
+      }
+    }
+    if (firstRun && !returnPolytrees) {
+      allPolygons = resultPolytree.getPolygons();
+      if (!resultPolytree || allPolygons.length === 0) {
+        return void 0;
+      }
+      if (materialForMesh) {
+        finalMesh = Polytree.toMesh(resultPolytree, materialForMesh);
+      } else {
+        defaultMaterial = void 0;
+        if ((ref = operationObject.objA) != null ? ref.material : void 0) {
+          defaultMaterial = Array.isArray(operationObject.objA.material) ? operationObject.objA.material[0] : operationObject.objA.material;
+          defaultMaterial = defaultMaterial.clone();
+        } else {
+          return void 0;
+        }
+        finalMesh = Polytree.toMesh(resultPolytree, defaultMaterial);
+      }
+      disposePolytreeResources(resultPolytree);
+      return finalMesh;
+    }
+    if (firstRun && returnPolytrees) {
+      return {
+        result: resultPolytree,
+        operationTree: operationObject
+      };
+    }
+    return resultPolytree;
+  }
+};
+handleObjectForOperation = function(inputObject, returnPolytrees, buildTargetPolytree, options, objectIndex, async = true) {
+  var processedObject;
+  if (async) {
+    return new Promise(function(resolve, reject) {
+      var processedObject2, processingError;
+      try {
+        processedObject2 = void 0;
+        if (inputObject.isMesh) {
+          processedObject2 = Polytree.fromMesh(inputObject, options.objCounter++);
+          if (returnPolytrees) {
+            processedObject2 = {
+              result: processedObject2,
+              original: processedObject2.clone()
+            };
+          }
+          processedObject2.objIndex = objectIndex;
+          return resolve(processedObject2);
+        } else if (inputObject.isPolytree) {
+          processedObject2 = inputObject;
+          if (returnPolytrees) {
+            processedObject2 = {
+              result: inputObject,
+              original: inputObject.clone()
+            };
+          }
+          processedObject2.objIndex = objectIndex;
+          return resolve(processedObject2);
+        } else if (inputObject.op) {
+          return Polytree.operation(inputObject, returnPolytrees, buildTargetPolytree, options, false, async).then(function(nestedResult) {
+            if (returnPolytrees) {
+              nestedResult = {
+                result: nestedResult,
+                original: inputObject
+              };
+            }
+            nestedResult.objIndex = objectIndex;
+            return resolve(nestedResult);
+          });
+        }
+      } catch (error) {
+        processingError = error;
+        return reject(processingError);
+      }
+    });
+  } else {
+    processedObject = void 0;
+    if (inputObject.isMesh) {
+      processedObject = Polytree.fromMesh(inputObject, options.objCounter++);
+      if (returnPolytrees) {
+        processedObject = {
+          result: processedObject,
+          original: processedObject.clone()
+        };
+      }
+    } else if (inputObject.isPolytree) {
+      processedObject = inputObject;
+      if (returnPolytrees) {
+        processedObject = {
+          result: inputObject,
+          original: inputObject.clone()
+        };
+      }
+    } else if (inputObject.op) {
+      processedObject = Polytree.operation(inputObject, returnPolytrees, buildTargetPolytree, options, false, async);
+      if (returnPolytrees) {
+        processedObject = {
+          result: processedObject,
+          original: inputObject
+        };
+      }
+    }
+    return processedObject;
+  }
+};
+var Polytree;
+Polytree = (function() {
+  class Polytree2 {
+    // Main constructor for creating Polytree nodes.
+    // Initializes core properties and sets up polygon array management.
+    // @param box - Optional bounding box for this tree node (used internally for polytree subdivision).
+    // @param parent - Optional parent Polytree node (used internally, null for root).
+    constructor(box = null, parent = null) {
+      this.box = box;
+      this.polygons = [];
+      this.replacedPolygons = [];
+      this.parent = parent;
+      this.subTrees = [];
+      this.level = 0;
+      this.originalMatrixWorld;
+      this.mesh;
+      this.polygonArrays = void 0;
+      this.addPolygonsArrayToRoot(this.polygons);
+    }
+    // === SMALL HELPERS AND GETTERS/SETTERS ===
+    isEmpty() {
+      return this.polygons.length === 0;
+    }
+    getMesh() {
+      var current, ref, visited;
+      visited = /* @__PURE__ */ new Set();
+      current = this;
+      while (current && !visited.has(current)) {
+        visited.add(current);
+        if (!current.parent) {
+          return (ref = current.mesh) != null ? ref : null;
+        }
+        current = current.parent;
+      }
+      return null;
+    }
+    newPolytree(box, parent) {
+      return new this.constructor(box, parent);
+    }
+    setPolygonIndex(index) {
+      if (index === void 0) {
+        return;
+      }
+      if (this.polygonArrays) {
+        return this.polygonArrays.forEach(function(polygonsArray) {
+          if (polygonsArray != null ? polygonsArray.length : void 0) {
+            return polygonsArray.forEach(function(polygon) {
+              return polygon.shared = index;
+            });
+          }
+        });
+      }
+    }
+    // === OBJECT CREATION AND COPYING ===
+    clone() {
+      return new this.constructor().copy(this);
+    }
+    copy(source) {
+      var i, k, ref, ref1, subTree;
+      if (!source) {
+        return this;
+      }
+      this.deletePolygonsArrayFromRoot(this.polygons);
+      this.polygons = source.polygons ? source.polygons.map(function(polygon) {
+        return polygon.clone();
+      }) : [];
+      this.addPolygonsArrayToRoot(this.polygons);
+      this.replacedPolygons = source.replacedPolygons ? source.replacedPolygons.map(function(polygon) {
+        return polygon.clone();
+      }) : [];
+      if (source.mesh) {
+        this.mesh = source.mesh;
+      }
+      if (source.originalMatrixWorld) {
+        this.originalMatrixWorld = source.originalMatrixWorld.clone();
+      }
+      this.box = source.box ? source.box.clone() : null;
+      this.level = (ref = source.level) != null ? ref : 0;
+      if (source.subTrees) {
+        for (i = k = 0, ref1 = source.subTrees.length; 0 <= ref1 ? k < ref1 : k > ref1; i = 0 <= ref1 ? ++k : --k) {
+          subTree = new this.constructor(void 0, this).copy(source.subTrees[i]);
+          this.subTrees.push(subTree);
+        }
+      }
+      return this;
+    }
+    // === CSG OPERATIONS (INSTANCE METHODS) ===
+    // Perform union operation (combines both meshes).
+    unite(mesh1, mesh2, targetMaterial = null) {
+      return Polytree2.unite(mesh1, mesh2, targetMaterial);
+    }
+    // Perform subtraction operation (mesh1 minus mesh2).
+    subtract(mesh1, mesh2, targetMaterial = null) {
+      return Polytree2.subtract(mesh1, mesh2, targetMaterial);
+    }
+    // Perform intersection operation (keep only overlapping volume).
+    intersect(mesh1, mesh2, targetMaterial = null) {
+      return Polytree2.intersect(mesh1, mesh2, targetMaterial);
+    }
+    // === POLYGON ARRAY MANAGEMENT ===
+    // Add polygon array to root node's collection (internal helper).
+    addPolygonsArrayToRoot(array) {
+      if (this.parent) {
+        return this.parent.addPolygonsArrayToRoot(array);
+      } else {
+        if (this.polygonArrays === void 0) {
+          this.polygonArrays = [];
+        }
+        return this.polygonArrays.push(array);
+      }
+    }
+    // Remove polygon array from root node's collection (internal helper).
+    deletePolygonsArrayFromRoot(array) {
+      var index;
+      if (this.parent) {
+        return this.parent.deletePolygonsArrayFromRoot(array);
+      } else {
+        index = this.polygonArrays.indexOf(array);
+        if (index > -1) {
+          return this.polygonArrays.splice(index, 1);
+        }
+      }
+    }
+    // === CORE POLYGON OPERATIONS ===
+    // Add a polygon to this tree node with spatial bounds calculation.
+    addPolygon(polygon, trianglesSet) {
+      var triangle;
+      if (!this.bounds) {
+        this.bounds = new Box3();
+      }
+      triangle = polygon.triangle;
+      if (trianglesSet && !isUniqueTriangle(triangle, trianglesSet)) {
+        return this;
+      }
+      this.bounds.expandByPoint(triangle.a);
+      this.bounds.expandByPoint(triangle.b);
+      this.bounds.expandByPoint(triangle.c);
+      this.polygons.push(polygon);
+      return this;
+    }
+    calcBox() {
+      var offset;
+      if (!this.bounds) {
+        this.bounds = new Box3();
+      }
+      this.box = this.bounds.clone();
+      offset = POLYTREE_MIN_NODE_SIZE;
+      this.box.min.x -= offset;
+      this.box.min.y -= offset;
+      this.box.min.z -= offset;
+      this.box.max.x += offset;
+      this.box.max.y += offset;
+      this.box.max.z += offset;
+      return this;
+    }
+    // === TREE CONSTRUCTION AND SPATIAL PARTITIONING ===
+    // Split this node into 8 octree children based on spatial subdivision.
+    // This creates a polytree by recursively subdividing space until polygon density is acceptable.
+    split(level) {
+      var box, found, halfSize, i, k, l, len, m, maxDepthLimit, n, nodeSize, o, polygon, polygonLimit, ref, ref1, subTrees, vectorPosition, x, y, z;
+      subTrees = [];
+      if (!this.box) {
+        return this;
+      }
+      halfSize = temporaryVector3Secondary.copy(this.box.max).sub(this.box.min).multiplyScalar(0.5);
+      for (x = k = 0; k <= 1; x = ++k) {
+        for (y = l = 0; l <= 1; y = ++l) {
+          for (z = m = 0; m <= 1; z = ++m) {
+            box = new Box3();
+            vectorPosition = temporaryVector3Primary.set(x, y, z);
+            box.min.copy(this.box.min).add(vectorPosition.multiply(halfSize));
+            box.max.copy(box.min).add(halfSize);
+            box.expandByScalar(GEOMETRIC_EPSILON);
+            subTrees.push(this.newPolytree(box, this));
+          }
+        }
+      }
+      polygon = void 0;
+      while (polygon = this.polygons.pop()) {
+        found = false;
+        for (i = n = 0, ref = subTrees.length; 0 <= ref ? n < ref : n > ref; i = 0 <= ref ? ++n : --n) {
+          if (subTrees[i].box.containsPoint(polygon.getMidpoint())) {
+            subTrees[i].polygons.push(polygon);
+            found = true;
+          }
+        }
+        if (!found) {
+          throw new Error(`Unable to find subtree for triangle at level ${level}.`);
+        }
+      }
+      for (i = o = 0, ref1 = subTrees.length; 0 <= ref1 ? o < ref1 : o > ref1; i = 0 <= ref1 ? ++o : --o) {
+        subTrees[i].level = level + 1;
+        len = subTrees[i].polygons.length;
+        nodeSize = subTrees[i].box.getSize(temporaryVector3Tertiary).length();
+        maxDepthLimit = Math.min(Polytree2.maxLevel, POLYTREE_MAX_DEPTH);
+        polygonLimit = Math.min(Polytree2.polygonsPerTree, POLYTREE_MAX_POLYGONS_PER_NODE);
+        if (len > polygonLimit && level < maxDepthLimit && nodeSize > POLYTREE_MIN_NODE_SIZE) {
+          subTrees[i].split(level + 1);
+        }
+        this.subTrees.push(subTrees[i]);
+      }
+      return this;
+    }
+    buildTree() {
+      this.calcBox();
+      this.split(0);
+      this.processTree();
+      return this;
+    }
+    // Process tree nodes to update bounding boxes after polygon distribution.
+    processTree() {
+      var i, k, l, ref, ref1, results;
+      if (!this.isEmpty()) {
+        temporaryBoundingBox.copy(this.box);
+        for (i = k = 0, ref = this.polygons.length; 0 <= ref ? k < ref : k > ref; i = 0 <= ref ? ++k : --k) {
+          this.box.expandByPoint(this.polygons[i].triangle.a);
+          this.box.expandByPoint(this.polygons[i].triangle.b);
+          this.box.expandByPoint(this.polygons[i].triangle.c);
+        }
+        this.expandParentBox();
+      }
+      results = [];
+      for (i = l = 0, ref1 = this.subTrees.length; 0 <= ref1 ? l < ref1 : l > ref1; i = 0 <= ref1 ? ++l : --l) {
+        results.push(this.subTrees[i].processTree());
+      }
+      return results;
+    }
+    // Recursively expand parent bounding boxes up the tree hierarchy.
+    expandParentBox(visited = /* @__PURE__ */ new Set()) {
+      if (this.parent && !visited.has(this.parent)) {
+        visited.add(this.parent);
+        this.parent.box.expandByPoint(this.box.min);
+        this.parent.box.expandByPoint(this.box.max);
+        return this.parent.expandParentBox(visited);
+      }
+    }
+    // === POLYGON QUERIES AND INTERSECTION TESTING ===
+    // Invert all polygons by flipping their face normals.
+    invert() {
+      return this.polygonArrays.forEach(function(polygonsArray) {
+        if (polygonsArray.length) {
+          return polygonsArray.forEach(function(polygon) {
+            return polygon.flip();
+          });
+        }
+      });
+    }
+    // Get all valid polygons from all polygon arrays in this tree.
+    getPolygons(polygons = []) {
+      this.polygonArrays.forEach(function(polygonsArray) {
+        var i, k, ref, results;
+        if (polygonsArray.length) {
+          results = [];
+          for (i = k = 0, ref = polygonsArray.length; 0 <= ref ? k < ref : k > ref; i = 0 <= ref ? ++k : --k) {
+            if (polygonsArray[i].valid) {
+              if (polygons.indexOf(polygonsArray[i]) === -1) {
+                results.push(polygons.push(polygonsArray[i]));
+              } else {
+                results.push(void 0);
+              }
+            } else {
+              results.push(void 0);
+            }
+          }
+          return results;
+        }
+      });
+      return polygons;
+    }
+    // Extract triangles from all valid polygons in the tree.
+    // This provides triangle data format as complement to getPolygons().
+    getTriangles(triangles = []) {
+      var polygons;
+      polygons = this.getPolygons();
+      polygons.forEach(function(polygon) {
+        return triangles.push(polygon.triangle);
+      });
+      return triangles;
+    }
+    // Collect polygons that intersect with a ray for raycasting operations.
+    getRayPolygons(ray, polygons = []) {
+      var i, k, l, ref, ref1;
+      if (this.polygons.length > 0) {
+        for (i = k = 0, ref = this.polygons.length; 0 <= ref ? k < ref : k > ref; i = 0 <= ref ? ++k : --k) {
+          if (this.polygons[i].valid && this.polygons[i].originalValid) {
+            if (polygons.indexOf(this.polygons[i]) === -1) {
+              polygons.push(this.polygons[i]);
+            }
+          }
+        }
+      }
+      if (this.replacedPolygons.length > 0) {
+        polygons.push(...this.replacedPolygons);
+      }
+      for (i = l = 0, ref1 = this.subTrees.length; 0 <= ref1 ? l < ref1 : l > ref1; i = 0 <= ref1 ? ++l : --l) {
+        if (ray.intersectsBox(this.subTrees[i].box)) {
+          this.subTrees[i].getRayPolygons(ray, polygons);
+        }
+      }
+      return polygons;
+    }
+    // Extract triangles from polygons that intersect with a ray.
+    // This provides triangle data format as complement to getRayPolygons().
+    getRayTriangles(ray, triangles = []) {
+      var polygons;
+      polygons = this.getRayPolygons(ray);
+      polygons.forEach(function(polygon) {
+        return triangles.push(polygon.triangle);
+      });
+      return triangles;
+    }
+    // Perform ray intersection testing against all polygons in the tree.
+    // Returns array of intersection results sorted by distance.
+    rayIntersect(ray, matrixWorld, intersects = []) {
+      var distance, i, k, newDistance, polygons, ref, result;
+      if (ray.direction.length() === 0) {
+        return [];
+      }
+      distance = 1e100;
+      polygons = this.getRayPolygons(ray);
+      for (i = k = 0, ref = polygons.length; 0 <= ref ? k < ref : k > ref; i = 0 <= ref ? ++k : --k) {
+        result = void 0;
+        if (Polytree2.rayIntersectTriangleType === "regular") {
+          result = ray.intersectTriangle(polygons[i].triangle.a, polygons[i].triangle.b, polygons[i].triangle.c, false, temporaryVector3Primary);
+          if (result) {
+            temporaryVector3Primary.applyMatrix4(matrixWorld);
+            distance = temporaryVector3Primary.distanceTo(ray.origin);
+            if (distance < 0 || distance > Infinity) {
+              console.warn("[rayIntersect] Failed ray distance check.", ray);
+            } else {
+              intersects.push({
+                distance,
+                polygon: polygons[i],
+                position: temporaryVector3Primary.clone()
+              });
+            }
+          }
+        } else {
+          result = testRayTriangleIntersection(ray, polygons[i].triangle, temporaryVector3Primary);
+          if (result) {
+            newDistance = result.clone().sub(ray.origin).length();
+            if (distance > newDistance) {
+              distance = newDistance;
+            }
+            if (distance < 1e100) {
+              intersects.push({
+                distance,
+                polygon: polygons[i],
+                position: result.clone().add(ray.origin)
+              });
+            }
+          }
+        }
+      }
+      intersects.length && intersects.sort(sortRaycastIntersectionsByDistance);
+      return intersects;
+    }
+    // Get all polygons marked as intersecting from polygon arrays.
+    getIntersectingPolygons(polygons = []) {
+      this.polygonArrays.forEach(function(polygonsArray) {
+        var i, k, ref, results;
+        if (polygonsArray.length) {
+          results = [];
+          for (i = k = 0, ref = polygonsArray.length; 0 <= ref ? k < ref : k > ref; i = 0 <= ref ? ++k : --k) {
+            if (polygonsArray[i].valid && polygonsArray[i].intersects) {
+              results.push(polygons.push(polygonsArray[i]));
+            } else {
+              results.push(void 0);
+            }
+          }
+          return results;
+        }
+      });
+      return polygons;
+    }
+    // Find all polygons that intersect with a target polygon using spatial partitioning.
+    getPolygonsIntersectingPolygon(targetPolygon, polygons = []) {
+      var allPolygons, i, k, l, m, polygon, ref, ref1, ref2;
+      if (this.box.intersectsTriangle(targetPolygon.triangle)) {
+        if (this.polygons.length > 0) {
+          allPolygons = this.polygons.slice();
+          if (this.replacedPolygons.length > 0) {
+            for (i = k = 0, ref = this.replacedPolygons.length; 0 <= ref ? k < ref : k > ref; i = 0 <= ref ? ++k : --k) {
+              allPolygons.push(this.replacedPolygons[i]);
+            }
+          }
+          for (i = l = 0, ref1 = allPolygons.length; 0 <= ref1 ? l < ref1 : l > ref1; i = 0 <= ref1 ? ++l : --l) {
+            polygon = allPolygons[i];
+            if (!(polygon.originalValid && polygon.valid && polygon.intersects)) {
+              continue;
+            }
+            if (triangleIntersectsTriangle(targetPolygon.triangle, polygon.triangle)) {
+              polygons.push(polygon);
+            }
+          }
+        }
+      }
+      for (i = m = 0, ref2 = this.subTrees.length; 0 <= ref2 ? m < ref2 : m > ref2; i = 0 <= ref2 ? ++m : --m) {
+        this.subTrees[i].getPolygonsIntersectingPolygon(targetPolygon, polygons);
+      }
+      return polygons;
+    }
+    // === POLYGON MODIFICATION AND STATE MANAGEMENT ===
+    // Replace a polygon with one or more new polygons during CSG operations.
+    replacePolygon(polygon, newPolygons) {
+      var i, k, polygonIndex, ref, results;
+      if (!Array.isArray(newPolygons)) {
+        newPolygons = [newPolygons];
+      }
+      if (this.polygons.length > 0) {
+        polygonIndex = this.polygons.indexOf(polygon);
+        if (polygonIndex > -1) {
+          if (polygon.originalValid === true) {
+            this.replacedPolygons.push(polygon);
+          } else {
+            polygon.setInvalid();
+          }
+          this.polygons.splice(polygonIndex, 1, ...newPolygons);
+        }
+      }
+      results = [];
+      for (i = k = 0, ref = this.subTrees.length; 0 <= ref ? k < ref : k > ref; i = 0 <= ref ? ++k : --k) {
+        results.push(this.subTrees[i].replacePolygon(polygon, newPolygons));
+      }
+      return results;
+    }
+    // === COMPLEX CSG OPERATIONS AND STATE MANAGEMENT ===
+    // Delete polygons based on complex state rules for CSG operations.
+    // This implements the polygon classification logic for boolean operations.
+    deletePolygonsByStateRules(rulesArr, firstRun = true) {
+      return this.polygonArrays.forEach(function(polygonsArray) {
+        var polygonArr;
+        if (polygonsArray.length) {
+          polygonArr = polygonsArray.filter(function(polygon) {
+            return polygon.valid === true && polygon.intersects === true;
+          });
+          return polygonArr.forEach(function(polygon) {
+            var found, i, j, k, l, mainStatesObj, polygonIndex, ref, ref1, state, states, statesObj;
+            found = false;
+            for (j = k = 0, ref = rulesArr.length; 0 <= ref ? k < ref : k > ref; j = 0 <= ref ? ++k : --k) {
+              if (rulesArr[j].array) {
+                states = rulesArr[j].rule;
+                if (states.includes(polygon.state) && (polygon.previousState !== "undecided" && states.includes(polygon.previousState) || polygon.previousState === "undecided")) {
+                  found = true;
+                  statesObj = {};
+                  mainStatesObj = {};
+                  states.forEach(function(state2) {
+                    return statesObj[state2] = false;
+                  });
+                  states.forEach(function(state2) {
+                    return mainStatesObj[state2] = false;
+                  });
+                  statesObj[polygon.state] = true;
+                  for (i = l = 0, ref1 = polygon.previousStates.length; 0 <= ref1 ? l < ref1 : l > ref1; i = 0 <= ref1 ? ++l : --l) {
+                    if (!states.includes(polygon.previousStates[i])) {
+                      found = false;
+                      break;
+                    } else {
+                      statesObj[polygon.previousStates[i]] = true;
+                    }
+                  }
+                  if (found) {
+                    for (state in statesObj) {
+                      if (statesObj[state] === false) {
+                        found = false;
+                        break;
+                      }
+                    }
+                    if (found) {
+                      break;
+                    }
+                  }
+                }
+              } else {
+                if (polygon.checkAllStates(rulesArr[j].rule)) {
+                  found = true;
+                  break;
+                }
+              }
+            }
+            if (found) {
+              polygonIndex = polygonsArray.indexOf(polygon);
+              if (polygonIndex > -1) {
+                polygon.setInvalid();
+                polygonsArray.splice(polygonIndex, 1);
+              }
+              if (firstRun) {
+                return polygon.delete();
+              }
+            }
+          });
+        }
+      });
+    }
+    // Delete polygons based on their intersection status (simpler filtering).
+    deletePolygonsByIntersection(intersects, firstRun = true) {
+      if (intersects === void 0) {
+        return;
+      }
+      return this.polygonArrays.forEach(function(polygonsArray) {
+        var polygonArr;
+        if (polygonsArray.length) {
+          polygonArr = polygonsArray.slice();
+          return polygonArr.forEach(function(polygon) {
+            var polygonIndex;
+            if (polygon.valid) {
+              if (polygon.intersects === intersects) {
+                polygonIndex = polygonsArray.indexOf(polygon);
+                if (polygonIndex > -1) {
+                  polygon.setInvalid();
+                  polygonsArray.splice(polygonIndex, 1);
+                }
+                if (firstRun) {
+                  return polygon.delete();
+                }
+              }
+            }
+          });
+        }
+      });
+    }
+    // Check if a polygon intersects with this tree's bounding box.
+    isPolygonIntersecting(polygon) {
+      if (!this.box.intersectsTriangle(polygon.triangle)) {
+        return false;
+      }
+      return true;
+    }
+    // Mark polygons as intersecting with target polytree.
+    markIntesectingPolygons(targetPolytree) {
+      return this.polygonArrays.forEach(function(polygonsArray) {
+        if (polygonsArray.length) {
+          return polygonsArray.forEach(function(polygon) {
+            return polygon.intersects = targetPolytree.isPolygonIntersecting(polygon);
+          });
+        }
+      });
+    }
+    // Reset polygon states for CSG operation preparation.
+    resetPolygons(resetOriginal = true) {
+      return this.polygonArrays.forEach(function(polygonsArray) {
+        if (polygonsArray.length) {
+          return polygonsArray.forEach(function(polygon) {
+            return polygon.reset(resetOriginal);
+          });
+        }
+      });
+    }
+    // Complex CSG intersection handling - splits and classifies polygons.
+    // This is the core method for polygon classification in boolean operations.
+    handleIntersectingPolygons(targetPolytree, targetPolytreeBuffer) {
+      var currentPolygon, i, inside, intersects, j, k, l, m, n, o, point, polygon, polygonStack, ref, ref1, ref2, ref3, ref4, results, splitResults, target, targetPolygons;
+      if (this.polygons.length > 0) {
+        polygonStack = this.polygons.filter(function(polygon2) {
+          return polygon2.valid === true && polygon2.intersects === true && polygon2.state === "undecided";
+        });
+        currentPolygon = polygonStack.pop();
+        while (currentPolygon) {
+          if (currentPolygon.state !== "undecided") {
+            continue;
+          }
+          if (!currentPolygon.valid) {
+            continue;
+          }
+          targetPolygons = targetPolytree.getPolygonsIntersectingPolygon(currentPolygon);
+          if (targetPolygons.length > 0) {
+            for (j = k = 0, ref = targetPolygons.length; 0 <= ref ? k < ref : k > ref; j = 0 <= ref ? ++k : --k) {
+              target = targetPolygons[j];
+              splitResults = splitPolygonByPlane(currentPolygon, target.plane);
+              if (splitResults.length > 1) {
+                for (i = l = 0, ref1 = splitResults.length; 0 <= ref1 ? l < ref1 : l > ref1; i = 0 <= ref1 ? ++l : --l) {
+                  polygon = splitResults[i].polygon;
+                  polygon.intersects = currentPolygon.intersects;
+                  polygon.newPolygon = true;
+                  polygonStack.push(polygon);
+                }
+                this.replacePolygon(currentPolygon, splitResults.map(function(result) {
+                  return result.polygon;
+                }));
+                break;
+              } else {
+                if (currentPolygon.id !== splitResults[0].polygon.id) {
+                  splitResults[0].polygon.intersects = currentPolygon.intersects;
+                  splitResults[0].polygon.newPolygon = true;
+                  polygonStack.push(splitResults[0].polygon);
+                  this.replacePolygon(currentPolygon, splitResults[0].polygon);
+                  break;
+                } else {
+                  if (splitResults[0].type === "coplanar-front" || splitResults[0].type === "coplanar-back") {
+                    currentPolygon.setState(splitResults[0].type);
+                    currentPolygon.coplanar = true;
+                  }
+                }
+              }
+            }
+          }
+          currentPolygon = polygonStack.pop();
+        }
+        polygonStack = this.polygons.filter(function(polygon2) {
+          return polygon2.valid === true && polygon2.intersects === true;
+        });
+        currentPolygon = polygonStack.pop();
+        inside = false;
+        while (currentPolygon) {
+          if (!currentPolygon.valid) {
+            continue;
+          }
+          inside = false;
+          if (targetPolytree.box.containsPoint(currentPolygon.getMidpoint())) {
+            if (Polytree2.useWindingNumber === true) {
+              inside = testPolygonInsideUsingWindingNumber(targetPolytreeBuffer, currentPolygon.getMidpoint(), currentPolygon.coplanar);
+            } else {
+              point = roundPointCoordinates(temporaryVector3Secondary.copy(currentPolygon.getMidpoint()));
+              if (Polytree2.usePolytreeRay !== true && targetPolytree.mesh) {
+                defaultRayDirection.copy(currentPolygon.plane.normal);
+                temporaryRaycaster.set(point, defaultRayDirection);
+                intersects = temporaryRaycaster.intersectObject(targetPolytree.mesh);
+                if (intersects.length) {
+                  if (defaultRayDirection.dot(intersects[0].face.normal) > 0) {
+                    inside = true;
+                  }
+                }
+                if (!(inside || !currentPolygon.coplanar)) {
+                  for (j = m = 0, ref2 = windingNumberEpsilonOffsetsCount; 0 <= ref2 ? m < ref2 : m > ref2; j = 0 <= ref2 ? ++m : --m) {
+                    temporaryRaycaster.ray.origin.copy(point).add(windingNumberEpsilonOffsets[j]);
+                    intersects = temporaryRaycaster.intersectObject(targetPolytree.mesh);
+                    if (intersects.length) {
+                      if (defaultRayDirection.dot(intersects[0].face.normal) > 0) {
+                        inside = true;
+                        break;
+                      }
+                    }
+                  }
+                }
+              } else {
+                temporaryRay.origin.copy(point);
+                defaultRayDirection.copy(currentPolygon.plane.normal);
+                temporaryRay.direction.copy(currentPolygon.plane.normal);
+                intersects = targetPolytree.rayIntersect(temporaryRay, targetPolytree.originalMatrixWorld);
+                if (intersects.length) {
+                  if (defaultRayDirection.dot(intersects[0].polygon.plane.normal) > 0) {
+                    inside = true;
+                  }
+                }
+                if (!(inside || !currentPolygon.coplanar)) {
+                  for (j = n = 0, ref3 = windingNumberEpsilonOffsetsCount; 0 <= ref3 ? n < ref3 : n > ref3; j = 0 <= ref3 ? ++n : --n) {
+                    temporaryRay.origin.copy(point).add(windingNumberEpsilonOffsets[j]);
+                    defaultRayDirection.copy(currentPolygon.plane.normal);
+                    temporaryRay.direction.copy(currentPolygon.plane.normal);
+                    intersects = targetPolytree.rayIntersect(temporaryRay, targetPolytree.originalMatrixWorld);
+                    if (intersects.length) {
+                      if (defaultRayDirection.dot(intersects[0].polygon.plane.normal) > 0) {
+                        inside = true;
+                        break;
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+          if (inside === true) {
+            currentPolygon.setState("inside");
+          } else {
+            currentPolygon.setState("outside");
+          }
+          currentPolygon = polygonStack.pop();
+        }
+      }
+      results = [];
+      for (i = o = 0, ref4 = this.subTrees.length; 0 <= ref4 ? o < ref4 : o > ref4; i = 0 <= ref4 ? ++o : --o) {
+        results.push(this.subTrees[i].handleIntersectingPolygons(targetPolytree, targetPolytreeBuffer));
+      }
+      return results;
+    }
+    // Apply transformation matrix to all polygons in this tree.
+    applyMatrix(matrix, normalMatrix, firstRun = true) {
+      var i, k, l, ref, ref1;
+      if (matrix.isMesh) {
+        matrix.updateMatrix();
+        matrix = matrix.matrix;
+      }
+      if (this.box) {
+        this.box.makeEmpty();
+      }
+      normalMatrix = normalMatrix || temporaryMatrixWithNormalCalc.getNormalMatrix(matrix);
+      if (this.polygons.length > 0) {
+        for (i = k = 0, ref = this.polygons.length; 0 <= ref ? k < ref : k > ref; i = 0 <= ref ? ++k : --k) {
+          if (this.polygons[i].valid) {
+            this.polygons[i].applyMatrix(matrix, normalMatrix);
+          }
+        }
+      }
+      for (i = l = 0, ref1 = this.subTrees.length; 0 <= ref1 ? l < ref1 : l > ref1; i = 0 <= ref1 ? ++l : --l) {
+        this.subTrees[i].applyMatrix(matrix, normalMatrix, false);
+      }
+      if (firstRun) {
+        return this.processTree();
+      }
+    }
+    // === ADVANCED COLLISION DETECTION ===
+    // Test intersection between a sphere and a triangle.
+    // Returns intersection data or false if no intersection.
+    // @param sphere - Sphere object with center and radius properties.
+    // @param triangle - Triangle object with a, b, c vertex properties.
+    // @return Object with normal, point, depth properties or false if no intersection.
+    triangleSphereIntersect(sphere, triangle) {
+      var distanceSquared, i, intersectionDepth, k, planePoint, radiusSquared, ref, temporaryLine, temporaryVector1, temporaryVector2, triangleEdges, trianglePlane;
+      temporaryVector1 = new Vector3();
+      temporaryVector2 = new Vector3();
+      temporaryLine = new Line3();
+      trianglePlane = new ThreePlane();
+      triangle.getPlane(trianglePlane);
+      if (!sphere.intersectsPlane(trianglePlane)) {
+        return false;
+      }
+      intersectionDepth = Math.abs(trianglePlane.distanceToSphere(sphere));
+      radiusSquared = sphere.radius * sphere.radius - intersectionDepth * intersectionDepth;
+      planePoint = trianglePlane.projectPoint(sphere.center, temporaryVector1);
+      if (triangle.containsPoint(sphere.center)) {
+        return {
+          depth: Math.abs(trianglePlane.distanceToSphere(sphere)),
+          normal: trianglePlane.normal.clone(),
+          point: planePoint.clone()
+        };
+      }
+      triangleEdges = [[triangle.a, triangle.b], [triangle.b, triangle.c], [triangle.c, triangle.a]];
+      for (i = k = 0, ref = triangleEdges.length; 0 <= ref ? k < ref : k > ref; i = 0 <= ref ? ++k : --k) {
+        temporaryLine.set(triangleEdges[i][0], triangleEdges[i][1]);
+        temporaryLine.closestPointToPoint(planePoint, true, temporaryVector2);
+        distanceSquared = temporaryVector2.distanceToSquared(sphere.center);
+        if (distanceSquared < radiusSquared) {
+          return {
+            depth: sphere.radius - Math.sqrt(distanceSquared),
+            normal: sphere.center.clone().sub(temporaryVector2).normalize(),
+            point: temporaryVector2.clone()
+          };
+        }
+      }
+      return false;
+    }
+    // Collect triangles that intersect with a sphere using spatial partitioning.
+    // This method recursively traverses the polytree to find relevant triangles.
+    // @param sphere - Sphere object to test intersection against.
+    // @param triangles - Array to collect intersecting triangles.
+    getSphereTriangles(sphere, triangles) {
+      var currentPolygon, currentSubTree, k, polygonIndex, ref, results, subTreeIndex;
+      results = [];
+      for (subTreeIndex = k = 0, ref = this.subTrees.length; 0 <= ref ? k < ref : k > ref; subTreeIndex = 0 <= ref ? ++k : --k) {
+        currentSubTree = this.subTrees[subTreeIndex];
+        if (!sphere.intersectsBox(currentSubTree.box)) {
+          continue;
+        }
+        if (currentSubTree.polygons.length > 0) {
+          results.push((function() {
+            var l, ref1, results1;
+            results1 = [];
+            for (polygonIndex = l = 0, ref1 = currentSubTree.polygons.length; 0 <= ref1 ? l < ref1 : l > ref1; polygonIndex = 0 <= ref1 ? ++l : --l) {
+              currentPolygon = currentSubTree.polygons[polygonIndex];
+              if (!currentPolygon.valid) {
+                continue;
+              }
+              if (triangles.indexOf(currentPolygon.triangle) === -1) {
+                results1.push(triangles.push(currentPolygon.triangle));
+              } else {
+                results1.push(void 0);
+              }
+            }
+            return results1;
+          })());
+        } else {
+          results.push(currentSubTree.getSphereTriangles(sphere, triangles));
+        }
+      }
+      return results;
+    }
+    // Perform high-level sphere intersection testing against the entire polytree.
+    // Returns collision data with adjusted position and penetration depth.
+    // @param sphere - Sphere object to test collision against.
+    // @return Object with normal and depth properties or false if no collision.
+    sphereIntersect(sphere) {
+      var adjustedSphere, collisionDetected, collisionVector, currentTriangle, intersectingTriangles, intersectionResult, k, penetrationDepth, ref, triangleIndex;
+      collisionDetected = false;
+      intersectionResult = void 0;
+      intersectingTriangles = [];
+      adjustedSphere = new Sphere();
+      adjustedSphere.copy(sphere);
+      this.getSphereTriangles(sphere, intersectingTriangles);
+      for (triangleIndex = k = 0, ref = intersectingTriangles.length; 0 <= ref ? k < ref : k > ref; triangleIndex = 0 <= ref ? ++k : --k) {
+        currentTriangle = intersectingTriangles[triangleIndex];
+        if (intersectionResult = this.triangleSphereIntersect(adjustedSphere, currentTriangle)) {
+          collisionDetected = true;
+          adjustedSphere.center.add(intersectionResult.normal.multiplyScalar(intersectionResult.depth));
+        }
+      }
+      if (collisionDetected) {
+        collisionVector = adjustedSphere.center.clone().sub(sphere.center);
+        penetrationDepth = collisionVector.length();
+        return {
+          normal: collisionVector.normalize(),
+          depth: penetrationDepth
+        };
+      }
+      return false;
+    }
+    // Build polytree from Three.js scene graph (Group or Object3D).
+    // This method traverses the scene graph and converts all meshes to polytree data.
+    // @param group - Three.js Group or Object3D to traverse.
+    fromGraphNode(sceneGraphNode) {
+      var targetPolytreeInstance;
+      sceneGraphNode.updateWorldMatrix(true, true);
+      targetPolytreeInstance = this;
+      sceneGraphNode.traverse(function(sceneObject) {
+        if (sceneObject.isMesh === true) {
+          return Polytree2.fromMesh(sceneObject, void 0, targetPolytreeInstance, false);
+        }
+      });
+      return this.buildTree();
+    }
+    // === CLEANUP AND DISPOSAL METHODS ===
+    // Clean up replaced polygons from CSG operations.
+    deleteReplacedPolygons() {
+      var i, k, ref, results;
+      if (this.replacedPolygons.length > 0) {
+        this.replacedPolygons.forEach(function(polygon) {
+          return polygon.delete();
+        });
+        this.replacedPolygons.length = 0;
+      }
+      results = [];
+      for (i = k = 0, ref = this.subTrees.length; 0 <= ref ? k < ref : k > ref; i = 0 <= ref ? ++k : --k) {
+        results.push(this.subTrees[i].deleteReplacedPolygons());
+      }
+      return results;
+    }
+    // Mark all polygons as original (not generated by CSG operations).
+    markPolygonsAsOriginal() {
+      return this.polygonArrays.forEach(function(polygonsArray) {
+        if (polygonsArray.length) {
+          return polygonsArray.forEach(function(polygon) {
+            return polygon.originalValid = true;
+          });
+        }
+      });
+    }
+    // Get polygon clones via callback for CSG operations.
+    getPolygonCloneCallback(cbFunc, trianglesSet) {
+      return this.polygonArrays.forEach(function(polygonsArray) {
+        var i, k, ref, results;
+        if (polygonsArray.length) {
+          results = [];
+          for (i = k = 0, ref = polygonsArray.length; 0 <= ref ? k < ref : k > ref; i = 0 <= ref ? ++k : --k) {
+            if (polygonsArray[i].valid) {
+              results.push(cbFunc(polygonsArray[i].clone(), trianglesSet));
+            } else {
+              results.push(void 0);
+            }
+          }
+          return results;
+        }
+      });
+    }
+    // Delete this tree and all its data (primary cleanup method).
+    delete(deletePolygons = true) {
+      var i, k, ref;
+      if (this.polygons.length > 0 && deletePolygons) {
+        this.polygons.forEach(function(polygon) {
+          return polygon.delete();
+        });
+        this.polygons.length = 0;
+      }
+      if (this.replacedPolygons.length > 0 && deletePolygons) {
+        this.replacedPolygons.forEach(function(polygon) {
+          return polygon.delete();
+        });
+        this.replacedPolygons.length = 0;
+      }
+      if (this.polygonArrays) {
+        this.polygonArrays.length = 0;
+      }
+      if (this.subTrees.length) {
+        for (i = k = 0, ref = this.subTrees.length; 0 <= ref ? k < ref : k > ref; i = 0 <= ref ? ++k : --k) {
+          this.subTrees[i].delete(deletePolygons);
+        }
+        this.subTrees.length = 0;
+      }
+      this.mesh = void 0;
+      this.originalMatrixWorld = void 0;
+      this.box = void 0;
+      this.parent = void 0;
+      return this.level = void 0;
+    }
+    // Dispose of this tree (alias for delete).
+    dispose(deletePolygons = true) {
+      return this.delete(deletePolygons);
+    }
+  }
+  ;
+  Polytree2.prototype.isPolytree = true;
+  Polytree2.usePolytreeRay = true;
+  Polytree2.disposePolytree = true;
+  Polytree2.useWindingNumber = false;
+  Polytree2.maxLevel = POLYTREE_MAX_DEPTH;
+  Polytree2.polygonsPerTree = POLYTREE_MAX_POLYGONS_PER_NODE;
+  Polytree2.rayIntersectTriangleType = "MollerTrumbore";
+  Polytree2.operation = operationHandler;
+  Polytree2.rayIntersectsTriangle = testRayTriangleIntersection;
+  return Polytree2;
+}).call(void 0);
+Polytree.toGeometry = function(polytree) {
+  var colors, defaultGroup, geometry, groupBase, groups, i, index, k, l, len, len1, m, n, normals, polygon, polygons, positions, ref, ref1, totalTriangles, uvs, vertices, verticesLen;
+  groups = [];
+  defaultGroup = [];
+  uvs = void 0;
+  colors = void 0;
+  totalTriangles = 0;
+  polygons = polytree.getPolygons();
+  for (k = 0, len = polygons.length; k < len; k++) {
+    polygon = polygons[k];
+    totalTriangles += Math.max(0, polygon.vertices.length - 2);
+  }
+  positions = createVector3Buffer(totalTriangles * 3);
+  normals = createVector3Buffer(totalTriangles * 3);
+  for (l = 0, len1 = polygons.length; l < len1; l++) {
+    polygon = polygons[l];
+    vertices = polygon.vertices;
+    verticesLen = vertices.length;
+    if (polygon.shared !== void 0) {
+      if (!groups[polygon.shared]) {
+        groups[polygon.shared] = [];
+      }
+    }
+    if (verticesLen > 0) {
+      if (vertices[0].uv !== void 0) {
+        uvs || (uvs = createVector2Buffer(totalTriangles * 3));
+      }
+      if (vertices[0].color !== void 0) {
+        colors || (colors = createVector3Buffer(totalTriangles * 3));
+      }
+    }
+    for (i = m = 3, ref = verticesLen; 3 <= ref ? m <= ref : m >= ref; i = 3 <= ref ? ++m : --m) {
+      (polygon.shared === void 0 ? defaultGroup : groups[polygon.shared]).push(positions.top / 3, positions.top / 3 + 1, positions.top / 3 + 2);
+      positions.write(vertices[0].pos);
+      positions.write(vertices[i - 2].pos);
+      positions.write(vertices[i - 1].pos);
+      normals.write(vertices[0].normal);
+      normals.write(vertices[i - 2].normal);
+      normals.write(vertices[i - 1].normal);
+      if (uvs != null) {
+        uvs.write(vertices[0].uv);
+        uvs.write(vertices[i - 2].uv);
+        uvs.write(vertices[i - 1].uv);
+      }
+      if (colors != null) {
+        colors.write(vertices[0].color);
+        colors.write(vertices[i - 2].color);
+        colors.write(vertices[i - 1].color);
+      }
+    }
+  }
+  geometry = new BufferGeometry();
+  geometry.setAttribute("position", new BufferAttribute(positions.array, 3));
+  geometry.setAttribute("normal", new BufferAttribute(normals.array, 3));
+  uvs && geometry.setAttribute("uv", new BufferAttribute(uvs.array, 2));
+  colors && geometry.setAttribute("color", new BufferAttribute(colors.array, 3));
+  if (groups.length > 0) {
+    index = [];
+    groupBase = 0;
+    for (i = n = 0, ref1 = groups.length; 0 <= ref1 ? n < ref1 : n > ref1; i = 0 <= ref1 ? ++n : --n) {
+      groups[i] = groups[i] || [];
+      geometry.addGroup(groupBase, groups[i].length, i);
+      groupBase += groups[i].length;
+      index = index.concat(groups[i]);
+    }
+    if (defaultGroup.length) {
+      geometry.addGroup(groupBase, defaultGroup.length, groups.length);
+      index = index.concat(defaultGroup);
+    }
+    geometry.setIndex(index);
+  }
+  return geometry;
+};
+Polytree.toMesh = function(polytree, toMaterial) {
+  var geometry;
+  geometry = Polytree.toGeometry(polytree);
+  return new Mesh(geometry, toMaterial);
+};
+Polytree.fromMesh = function(obj, objectIndex, polytree = new Polytree(), buildTargetPolytree = true) {
+  var color, colorattr, geometry, group, groups, i, index, j, k, l, len, m, n, normal, normalattr, polygon, polys, pos, posattr, positionIndex, ref, ref1, uvCoords, uvIndex, uvattr, vertexIndex, vertices;
+  if (obj.isPolytree) {
+    return obj;
+  }
+  if (Polytree.rayIntersectTriangleType === "regular") {
+    polytree.originalMatrixWorld = obj.matrixWorld.clone();
+  }
+  obj.updateWorldMatrix(true, true);
+  geometry = obj.geometry;
+  temporaryMatrixWithNormalCalc.getNormalMatrix(obj.matrix);
+  groups = geometry.groups;
+  uvattr = geometry.attributes.uv;
+  colorattr = geometry.attributes.color;
+  posattr = geometry.attributes.position;
+  normalattr = geometry.attributes.normal;
+  index = geometry.index ? geometry.index.array : Array(posattr.array.length / posattr.itemSize | 0).fill().map(function(_, i2) {
+    return i2;
+  });
+  polys = [];
+  for (i = k = 0, ref = index.length; k < ref; i = k += 3) {
+    vertices = [];
+    for (j = l = 0; l < 3; j = ++l) {
+      vertexIndex = index[i + j];
+      positionIndex = vertexIndex * 3;
+      uvIndex = vertexIndex * 2;
+      pos = new Vector3(posattr.array[positionIndex], posattr.array[positionIndex + 1], posattr.array[positionIndex + 2]);
+      normal = new Vector3(normalattr.array[positionIndex], normalattr.array[positionIndex + 1], normalattr.array[positionIndex + 2]);
+      pos.applyMatrix4(obj.matrix);
+      normal.applyMatrix3(temporaryMatrixWithNormalCalc);
+      uvCoords = uvattr ? {
+        x: uvattr.array[uvIndex],
+        y: uvattr.array[uvIndex + 1]
+      } : void 0;
+      color = colorattr ? {
+        x: colorattr.array[uvIndex],
+        y: colorattr.array[uvIndex + 1],
+        z: colorattr.array[uvIndex + 2]
+      } : void 0;
+      vertices.push(new Vertex(pos, normal, uvCoords, color));
+    }
+    if (objectIndex === void 0 && groups && groups.length > 0) {
+      polygon = void 0;
+      for (m = 0, len = groups.length; m < len; m++) {
+        group = groups[m];
+        if (index[i] >= group.start && index[i] < group.start + group.count) {
+          polygon = new Polygon(vertices, group.materialIndex);
+          polygon.originalValid = true;
+        }
+      }
+      if (polygon) {
+        polys.push(polygon);
+      }
+    } else {
+      polygon = new Polygon(vertices, objectIndex);
+      polygon.originalValid = true;
+      polys.push(polygon);
+    }
+  }
+  for (i = n = 0, ref1 = polys.length; 0 <= ref1 ? n < ref1 : n > ref1; i = 0 <= ref1 ? ++n : --n) {
+    if (isValidTriangle(polys[i].triangle)) {
+      polytree.addPolygon(polys[i]);
+    } else {
+      polys[i].delete();
+    }
+  }
+  buildTargetPolytree && polytree.buildTree();
+  if (Polytree.usePolytreeRay !== true) {
+    polytree.mesh = obj;
+  }
+  return polytree;
+};
+Polytree.getSurface = function(meshOrGeometry) {
+  var geometry, i, index, k, posattr, ref, surface, triangle, v1, v1Index, v2, v2Index, v3, v3Index;
+  surface = 0;
+  if (!meshOrGeometry) {
+    throw new Error("Input is required.");
+  }
+  geometry = meshOrGeometry.geometry ? meshOrGeometry.geometry : meshOrGeometry;
+  if (!(geometry && geometry.attributes)) {
+    throw new Error("No geometry found.");
+  }
+  posattr = geometry.attributes.position;
+  if (!posattr) {
+    throw new Error("Geometry has no position attribute.");
+  }
+  index = geometry.index ? geometry.index.array : Array(posattr.array.length / posattr.itemSize | 0).fill().map(function(_, i2) {
+    return i2;
+  });
+  for (i = k = 0, ref = index.length; k < ref; i = k += 3) {
+    v1Index = index[i + 0] * 3;
+    v2Index = index[i + 1] * 3;
+    v3Index = index[i + 2] * 3;
+    v1 = new Vector3(posattr.array[v1Index], posattr.array[v1Index + 1], posattr.array[v1Index + 2]);
+    v2 = new Vector3(posattr.array[v2Index], posattr.array[v2Index + 1], posattr.array[v2Index + 2]);
+    v3 = new Vector3(posattr.array[v3Index], posattr.array[v3Index + 1], posattr.array[v3Index + 2]);
+    triangle = new Triangle(v1, v2, v3);
+    surface += triangle.getArea();
+  }
+  return surface;
+};
+Polytree.prototype.getSurface = function(meshOrGeometry) {
+  return Polytree.getSurface(meshOrGeometry);
+};
+Polytree.getVolume = function(input) {
+  var bufferGeometry, face, faces, geometry, index, k, l, position, ref, ref1, v1, v2, v3, volume;
+  volume = 0;
+  v1 = new Vector3();
+  v2 = new Vector3();
+  v3 = new Vector3();
+  geometry = null;
+  if (input.isMesh) {
+    geometry = input.geometry;
+  } else if (input.isBufferGeometry) {
+    geometry = input;
+  } else {
+    throw new Error("Input must be a Three.js Mesh or BufferGeometry.");
+  }
+  bufferGeometry = (typeof geometry.toBuffer === "function" ? geometry.toBuffer() : void 0) || geometry;
+  if (!bufferGeometry.isBufferGeometry) {
+    throw new Error("Unable to convert input to BufferGeometry.");
+  }
+  position = bufferGeometry.attributes.position;
+  if (!position) {
+    return 0;
+  }
+  if (bufferGeometry.index) {
+    index = bufferGeometry.index;
+    faces = index.count / 3;
+    for (face = k = 0, ref = faces; 0 <= ref ? k < ref : k > ref; face = 0 <= ref ? ++k : --k) {
+      v1.fromBufferAttribute(position, index.array[face * 3 + 0]);
+      v2.fromBufferAttribute(position, index.array[face * 3 + 1]);
+      v3.fromBufferAttribute(position, index.array[face * 3 + 2]);
+      volume += signedVolumeOfTriangle(v1, v2, v3);
+    }
+  } else {
+    faces = position.count / 3;
+    for (face = l = 0, ref1 = faces; 0 <= ref1 ? l < ref1 : l > ref1; face = 0 <= ref1 ? ++l : --l) {
+      v1.fromBufferAttribute(position, face * 3 + 0);
+      v2.fromBufferAttribute(position, face * 3 + 1);
+      v3.fromBufferAttribute(position, face * 3 + 2);
+      volume += signedVolumeOfTriangle(v1, v2, v3);
+    }
+  }
+  return Math.abs(volume);
+};
+Polytree.prototype.getVolume = function(input) {
+  return Polytree.getVolume(input);
+};
+var convertToPolytree;
+convertToPolytree = function(input) {
+  var tempMaterial, tempMesh;
+  if (!input) {
+    return null;
+  }
+  if (input.isPolytree) {
+    return {
+      polytree: input,
+      shouldCleanup: false
+    };
+  } else if (input.isMesh) {
+    return {
+      polytree: Polytree.fromMesh(input),
+      shouldCleanup: true
+    };
+  } else if (input.isBufferGeometry) {
+    tempMaterial = {
+      isMaterial: true,
+      type: "MeshBasicMaterial"
+    };
+    tempMesh = new Mesh(input, tempMaterial);
+    return {
+      polytree: Polytree.fromMesh(tempMesh),
+      shouldCleanup: true
+    };
+  } else {
+    return null;
+  }
+};
+Polytree.closestPointToPoint = function(input, targetPoint, target = {}, maxDistance = Infinity) {
+  var closestDistance, closestPoint, closestTriangle, currentDistance, j, len, polytree, result, shouldCleanup, testTriangle, triangle, trianglePoint, triangles;
+  if (!(input && targetPoint)) {
+    return null;
+  }
+  result = convertToPolytree(input);
+  if (!result) {
+    return null;
+  }
+  ({ polytree, shouldCleanup } = result);
+  closestDistance = maxDistance;
+  closestPoint = null;
+  closestTriangle = null;
+  triangles = polytree.getTriangles();
+  for (j = 0, len = triangles.length; j < len; j++) {
+    triangle = triangles[j];
+    testTriangle = new Triangle(triangle.a, triangle.b, triangle.c);
+    trianglePoint = new Vector3();
+    testTriangle.closestPointToPoint(targetPoint, trianglePoint);
+    currentDistance = trianglePoint.distanceTo(targetPoint);
+    if (currentDistance < closestDistance) {
+      closestDistance = currentDistance;
+      closestPoint = trianglePoint.clone();
+      closestTriangle = triangle;
+    }
+  }
+  if (closestPoint) {
+    target.point = closestPoint;
+    target.distance = closestDistance;
+    target.triangle = closestTriangle;
+    shouldCleanup && polytree.delete();
+    return target;
+  }
+  shouldCleanup && polytree.delete();
+  return null;
+};
+Polytree.distanceToPoint = function(input, targetPoint) {
+  var result;
+  result = Polytree.closestPointToPoint(input, targetPoint);
+  return (result != null ? result.distance : void 0) || Infinity;
+};
+Polytree.intersectsSphere = function(input, sphere) {
+  var closestPoint, distance, j, len, polytree, result, shouldCleanup, testTriangle, triangle, triangles;
+  if (!(input && sphere)) {
+    return false;
+  }
+  result = convertToPolytree(input);
+  if (!result) {
+    return false;
+  }
+  ({ polytree, shouldCleanup } = result);
+  triangles = polytree.getTriangles();
+  for (j = 0, len = triangles.length; j < len; j++) {
+    triangle = triangles[j];
+    testTriangle = new Triangle(triangle.a, triangle.b, triangle.c);
+    closestPoint = new Vector3();
+    testTriangle.closestPointToPoint(sphere.center, closestPoint);
+    distance = closestPoint.distanceTo(sphere.center);
+    if (distance <= sphere.radius) {
+      shouldCleanup && polytree.delete();
+      return true;
+    }
+  }
+  shouldCleanup && polytree.delete();
+  return false;
+};
+Polytree.intersectsBox = function(input, boundingBox) {
+  var j, len, polytree, result, shouldCleanup, testTriangle, triangle, triangles;
+  if (!(input && boundingBox)) {
+    return false;
+  }
+  result = convertToPolytree(input);
+  if (!result) {
+    return false;
+  }
+  ({ polytree, shouldCleanup } = result);
+  triangles = polytree.getTriangles();
+  for (j = 0, len = triangles.length; j < len; j++) {
+    triangle = triangles[j];
+    testTriangle = new Triangle(triangle.a, triangle.b, triangle.c);
+    if (boundingBox.intersectsTriangle(testTriangle)) {
+      shouldCleanup && polytree.delete();
+      return true;
+    }
+  }
+  shouldCleanup && polytree.delete();
+  return false;
+};
+Polytree.intersectPlane = function(input, plane, target = []) {
+  var edge, endDist, endPoint, intersectionPoint, intersectionPoints, j, k, len, len1, pointExists, polytree, pt, result, shouldCleanup, startDist, startPoint, t, testTriangle, triangle, triangleEdges, triangles;
+  if (!(input && plane)) {
+    return target;
+  }
+  result = convertToPolytree(input);
+  if (!result) {
+    return target;
+  }
+  ({ polytree, shouldCleanup } = result);
+  triangles = polytree.getTriangles();
+  for (j = 0, len = triangles.length; j < len; j++) {
+    triangle = triangles[j];
+    testTriangle = new Triangle(triangle.a, triangle.b, triangle.c);
+    intersectionPoints = [];
+    pointExists = function(point, array, tolerance = 1e-10) {
+      var existingPoint, k2, len12;
+      for (k2 = 0, len12 = array.length; k2 < len12; k2++) {
+        existingPoint = array[k2];
+        if (existingPoint.distanceToSquared(point) < tolerance) {
+          return true;
+        }
+      }
+      return false;
+    };
+    triangleEdges = [[triangle.a, triangle.b], [triangle.b, triangle.c], [triangle.c, triangle.a]];
+    for (k = 0, len1 = triangleEdges.length; k < len1; k++) {
+      edge = triangleEdges[k];
+      startPoint = edge[0];
+      endPoint = edge[1];
+      startDist = plane.normal.dot(startPoint) + plane.constant;
+      endDist = plane.normal.dot(endPoint) + plane.constant;
+      if (startDist === 0 && endDist === 0) {
+        continue;
+      }
+      if (startDist * endDist <= 0) {
+        if (startDist === 0) {
+          pt = startPoint.clone();
+          if (!pointExists(pt, intersectionPoints)) {
+            intersectionPoints.push(pt);
+          }
+        } else if (endDist === 0) {
+          pt = endPoint.clone();
+          if (!pointExists(pt, intersectionPoints)) {
+            intersectionPoints.push(pt);
+          }
+        } else {
+          t = startDist / (startDist - endDist);
+          intersectionPoint = new Vector3();
+          intersectionPoint.lerpVectors(startPoint, endPoint, t);
+          intersectionPoints.push(intersectionPoint);
+        }
+      }
+    }
+    if (intersectionPoints.length === 2) {
+      target.push(new Line3(intersectionPoints[0], intersectionPoints[1]));
+    }
+  }
+  shouldCleanup && polytree.delete();
+  return target;
+};
+Polytree.sliceIntoLayers = function(input, layerHeight, minZ, maxZ, normal = new Vector3(0, 0, 1)) {
+  var absEndDist, absStartDist, angleFactor, baseEpsilon, currentZ, dotWithNormal, edge, edgeDir, edgeLength, edgeVector, endDist, endPoint, epsilon, intersectionPoint, intersectionPoints, j, k, layerSegments, layers, len, len1, planeConstant, planeNormal, pointExists, polytree, pt, result, shouldCleanup, startDist, startPoint, t, triangle, triangleEdges, triangles;
+  if (!(input && layerHeight > 0 && minZ <= maxZ)) {
+    return [];
+  }
+  result = convertToPolytree(input);
+  if (!result) {
+    return [];
+  }
+  ({ polytree, shouldCleanup } = result);
+  layers = [];
+  currentZ = minZ;
+  while (currentZ <= maxZ) {
+    planeNormal = normal.clone();
+    planeConstant = -currentZ;
+    layerSegments = [];
+    triangles = polytree.getTriangles();
+    for (j = 0, len = triangles.length; j < len; j++) {
+      triangle = triangles[j];
+      intersectionPoints = [];
+      pointExists = function(point, array, tolerance = 1e-10) {
+        var existingPoint, k2, len12;
+        for (k2 = 0, len12 = array.length; k2 < len12; k2++) {
+          existingPoint = array[k2];
+          if (existingPoint.distanceToSquared(point) < tolerance) {
+            return true;
+          }
+        }
+        return false;
+      };
+      triangleEdges = [[triangle.a, triangle.b], [triangle.b, triangle.c], [triangle.c, triangle.a]];
+      for (k = 0, len1 = triangleEdges.length; k < len1; k++) {
+        edge = triangleEdges[k];
+        startPoint = edge[0];
+        endPoint = edge[1];
+        startDist = planeNormal.dot(startPoint) + planeConstant;
+        endDist = planeNormal.dot(endPoint) + planeConstant;
+        edgeVector = new Vector3().subVectors(endPoint, startPoint);
+        edgeLength = edgeVector.length();
+        if (edgeLength < 1e-10) {
+          continue;
+        }
+        edgeDir = edgeVector.clone().divideScalar(edgeLength);
+        dotWithNormal = Math.abs(edgeDir.dot(planeNormal));
+        baseEpsilon = Math.max(1e-10, edgeLength * 1e-9);
+        angleFactor = dotWithNormal < 0.02 ? 100 : 1;
+        epsilon = baseEpsilon * angleFactor;
+        absStartDist = Math.abs(startDist);
+        absEndDist = Math.abs(endDist);
+        if (absStartDist < epsilon && absEndDist < epsilon) {
+          continue;
+        }
+        if (startDist * endDist <= 0) {
+          if (absStartDist < epsilon) {
+            pt = startPoint.clone();
+            if (!pointExists(pt, intersectionPoints)) {
+              intersectionPoints.push(pt);
+            }
+          } else if (absEndDist < epsilon) {
+            pt = endPoint.clone();
+            if (!pointExists(pt, intersectionPoints)) {
+              intersectionPoints.push(pt);
+            }
+          } else {
+            t = startDist / (startDist - endDist);
+            intersectionPoint = new Vector3();
+            intersectionPoint.lerpVectors(startPoint, endPoint, t);
+            intersectionPoints.push(intersectionPoint);
+          }
+        }
+      }
+      if (intersectionPoints.length === 2) {
+        layerSegments.push(new Line3(intersectionPoints[0], intersectionPoints[1]));
+      }
+    }
+    layers.push(layerSegments);
+    currentZ += layerHeight;
+  }
+  shouldCleanup && polytree.delete();
+  return layers;
+};
+Polytree.shapecast = function(input, queryCallback, collectCallback = null) {
+  var j, len, polytree, result, results, shouldCleanup, testTriangle, triangle, triangles;
+  if (!(input && queryCallback)) {
+    return [];
+  }
+  result = convertToPolytree(input);
+  if (!result) {
+    return [];
+  }
+  ({ polytree, shouldCleanup } = result);
+  results = [];
+  triangles = polytree.getTriangles();
+  for (j = 0, len = triangles.length; j < len; j++) {
+    triangle = triangles[j];
+    testTriangle = new Triangle(triangle.a, triangle.b, triangle.c);
+    if (queryCallback(testTriangle, triangle)) {
+      if (collectCallback) {
+        result = collectCallback(testTriangle, triangle);
+        if (result != null) {
+          results.push(result);
+        }
+      } else {
+        results.push(triangle);
+      }
+    }
+  }
+  shouldCleanup && polytree.delete();
+  return results;
+};
+Polytree.getTrianglesNearPoint = function(input, targetPoint, searchRadius) {
+  if (!(input && targetPoint && searchRadius > 0)) {
+    return [];
+  }
+  return Polytree.shapecast(input, function(testTriangle, originalTriangle) {
+    return testTriangle.a.distanceTo(targetPoint) <= searchRadius || testTriangle.b.distanceTo(targetPoint) <= searchRadius || testTriangle.c.distanceTo(targetPoint) <= searchRadius;
+  });
+};
+Polytree.estimateVolumeViaSampling = function(input, sampleCount = 1e4, boundingBox = null) {
+  var boxSize, boxVolume, i, identityMatrix, insideCount, intersections, j, k, len, polytree, ref, result, samplePoint, shouldCleanup, testRay, triangle, triangles, volumeRatio;
+  if (!input) {
+    return 0;
+  }
+  result = convertToPolytree(input);
+  if (!result) {
+    return 0;
+  }
+  ({ polytree, shouldCleanup } = result);
+  if (!boundingBox) {
+    boundingBox = new Box3();
+    triangles = polytree.getTriangles();
+    for (j = 0, len = triangles.length; j < len; j++) {
+      triangle = triangles[j];
+      boundingBox.expandByPoint(triangle.a);
+      boundingBox.expandByPoint(triangle.b);
+      boundingBox.expandByPoint(triangle.c);
+    }
+  }
+  boxSize = new Vector3();
+  boundingBox.getSize(boxSize);
+  boxVolume = boxSize.x * boxSize.y * boxSize.z;
+  if (boxVolume === 0) {
+    return 0;
+  }
+  insideCount = 0;
+  for (i = k = 0, ref = sampleCount; 0 <= ref ? k < ref : k > ref; i = 0 <= ref ? ++k : --k) {
+    samplePoint = new Vector3(boundingBox.min.x + Math.random() * boxSize.x, boundingBox.min.y + Math.random() * boxSize.y, boundingBox.min.z + Math.random() * boxSize.z);
+    testRay = new Ray(samplePoint, new Vector3(1, 0, 0));
+    identityMatrix = {
+      elements: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
+      isMatrix4: true
+    };
+    intersections = polytree.rayIntersect(testRay, identityMatrix);
+    if (intersections.length % 2 === 1) {
+      insideCount++;
+    }
+  }
+  volumeRatio = insideCount / sampleCount;
+  shouldCleanup && polytree.delete();
+  return volumeRatio * boxVolume;
+};
+var uniteRules;
+uniteRules = {
+  // Rules for object A: Remove polygons that are inside B or coplanar-back with B.
+  a: [
+    {
+      array: true,
+      rule: [
+        "inside",
+        "coplanar-back"
+      ]
+    },
+    {
+      array: false,
+      rule: "inside"
+    }
+  ],
+  // Rules for object B: Remove polygons inside A or coplanar with A.
+  b: [
+    {
+      array: true,
+      rule: [
+        "inside",
+        "coplanar-back"
+      ]
+    },
+    {
+      array: true,
+      rule: [
+        "inside",
+        "coplanar-front"
+      ]
+    },
+    {
+      array: false,
+      rule: "inside"
+    }
+  ]
+};
+Polytree.unite = function(mesh1, mesh2, async = true) {
+  var polytreeA, polytreeB, resultMesh, resultPolytree, targetMaterial;
+  if (async) {
+    if (mesh1.isPolytree && mesh2.isPolytree) {
+      return Polytree.async.unite(mesh1, mesh2, true);
+    } else {
+      polytreeA = Polytree.fromMesh(mesh1);
+      polytreeB = Polytree.fromMesh(mesh2);
+      targetMaterial = Array.isArray(mesh1.material) ? mesh1.material[0] : mesh1.material;
+      targetMaterial = targetMaterial.clone();
+      return Polytree.async.unite(polytreeA, polytreeB, false).then(function(resultPolytree2) {
+        var resultMesh2;
+        resultMesh2 = Polytree.toMesh(resultPolytree2, targetMaterial);
+        disposePolytreeResources(polytreeA, polytreeB, resultPolytree2);
+        return resultMesh2;
+      });
+    }
+  }
+  if (mesh1.isPolytree && mesh2.isPolytree) {
+    polytreeA = mesh1;
+    polytreeB = mesh2;
+    return this.uniteCore(polytreeA, polytreeB, true);
+  } else {
+    polytreeA = Polytree.fromMesh(mesh1);
+    polytreeB = Polytree.fromMesh(mesh2);
+    targetMaterial = Array.isArray(mesh1.material) ? mesh1.material[0] : mesh1.material;
+    targetMaterial = targetMaterial.clone();
+    resultPolytree = this.uniteCore(polytreeA, polytreeB, false);
+    resultMesh = Polytree.toMesh(resultPolytree, targetMaterial);
+    disposePolytreeResources(polytreeA, polytreeB, resultPolytree);
+    return resultMesh;
+  }
+};
+Polytree.uniteCore = function(polytreeA, polytreeB, buildTargetPolytree = true) {
+  var currentMeshSideA, currentMeshSideB, polytree, trianglesSet;
+  polytree = new Polytree();
+  trianglesSet = /* @__PURE__ */ new Set();
+  if (polytreeA.box.intersectsBox(polytreeB.box)) {
+    currentMeshSideA = void 0;
+    currentMeshSideB = void 0;
+    if (polytreeA.mesh) {
+      currentMeshSideA = polytreeA.mesh.material.side;
+      polytreeA.mesh.material.side = DoubleSide;
+    }
+    if (polytreeB.mesh) {
+      currentMeshSideB = polytreeB.mesh.material.side;
+      polytreeB.mesh.material.side = DoubleSide;
+    }
+    polytreeA.resetPolygons(false);
+    polytreeB.resetPolygons(false);
+    polytreeA.markIntesectingPolygons(polytreeB);
+    polytreeB.markIntesectingPolygons(polytreeA);
+    handleIntersectingPolytrees(polytreeA, polytreeB);
+    polytreeA.deleteReplacedPolygons();
+    polytreeB.deleteReplacedPolygons();
+    polytreeA.deletePolygonsByStateRules(uniteRules.a);
+    polytreeB.deletePolygonsByStateRules(uniteRules.b);
+    polytreeA.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    polytreeB.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    if (polytreeA.mesh && polytreeA.mesh.material.side !== currentMeshSideA) {
+      polytreeA.mesh.material.side = currentMeshSideA;
+    }
+    if (polytreeB.mesh && polytreeB.mesh.material.side !== currentMeshSideB) {
+      polytreeB.mesh.material.side = currentMeshSideB;
+    }
+  } else {
+    polytreeA.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    polytreeB.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+  }
+  trianglesSet.clear();
+  trianglesSet = void 0;
+  polytree.markPolygonsAsOriginal();
+  buildTargetPolytree && polytree.buildTree();
+  return polytree;
+};
+var subtractRules;
+subtractRules = {
+  // Rules for object A: Remove polygons that are inside B.
+  a: [
+    {
+      array: true,
+      rule: [
+        "inside",
+        "coplanar-back"
+      ]
+    },
+    {
+      array: true,
+      rule: [
+        "inside",
+        "coplanar-front"
+      ]
+    },
+    {
+      array: false,
+      rule: "inside"
+    }
+  ],
+  // Rules for object B: Remove polygons that are outside A.
+  b: [
+    {
+      array: true,
+      rule: [
+        "outside",
+        "coplanar-back"
+      ]
+    },
+    {
+      array: true,
+      rule: [
+        "outside",
+        "coplanar-front"
+      ]
+    },
+    {
+      array: true,
+      rule: [
+        "inside",
+        "coplanar-front"
+      ]
+    },
+    {
+      array: false,
+      rule: "outside"
+    }
+  ]
+};
+Polytree.subtract = function(mesh1, mesh2, async = true) {
+  var polytreeA, polytreeB, resultMesh, resultPolytree, targetMaterial;
+  if (async) {
+    if (mesh1.isPolytree && mesh2.isPolytree) {
+      return Polytree.async.subtract(mesh1, mesh2, true);
+    } else {
+      polytreeA = Polytree.fromMesh(mesh1);
+      polytreeB = Polytree.fromMesh(mesh2);
+      targetMaterial = Array.isArray(mesh1.material) ? mesh1.material[0] : mesh1.material;
+      targetMaterial = targetMaterial.clone();
+      return Polytree.async.subtract(polytreeA, polytreeB, false).then(function(resultPolytree2) {
+        var resultMesh2;
+        resultMesh2 = Polytree.toMesh(resultPolytree2, targetMaterial);
+        disposePolytreeResources(polytreeA, polytreeB, resultPolytree2);
+        return resultMesh2;
+      });
+    }
+  }
+  if (mesh1.isPolytree && mesh2.isPolytree) {
+    polytreeA = mesh1;
+    polytreeB = mesh2;
+    return this.subtractCore(polytreeA, polytreeB, true);
+  } else {
+    polytreeA = Polytree.fromMesh(mesh1);
+    polytreeB = Polytree.fromMesh(mesh2);
+    targetMaterial = Array.isArray(mesh1.material) ? mesh1.material[0] : mesh1.material;
+    targetMaterial = targetMaterial.clone();
+    resultPolytree = this.subtractCore(polytreeA, polytreeB, false);
+    resultMesh = Polytree.toMesh(resultPolytree, targetMaterial);
+    disposePolytreeResources(polytreeA, polytreeB, resultPolytree);
+    return resultMesh;
+  }
+};
+Polytree.subtractCore = function(polytreeA, polytreeB, buildTargetPolytree = true) {
+  var currentMeshSideA, currentMeshSideB, polytree, trianglesSet;
+  polytree = new Polytree();
+  trianglesSet = /* @__PURE__ */ new Set();
+  if (polytreeA.box.intersectsBox(polytreeB.box)) {
+    currentMeshSideA = void 0;
+    currentMeshSideB = void 0;
+    if (polytreeA.mesh) {
+      currentMeshSideA = polytreeA.mesh.material.side;
+      polytreeA.mesh.material.side = DoubleSide;
+    }
+    if (polytreeB.mesh) {
+      currentMeshSideB = polytreeB.mesh.material.side;
+      polytreeB.mesh.material.side = DoubleSide;
+    }
+    polytreeA.resetPolygons(false);
+    polytreeB.resetPolygons(false);
+    polytreeA.markIntesectingPolygons(polytreeB);
+    polytreeB.markIntesectingPolygons(polytreeA);
+    handleIntersectingPolytrees(polytreeA, polytreeB);
+    polytreeA.deleteReplacedPolygons();
+    polytreeB.deleteReplacedPolygons();
+    polytreeA.deletePolygonsByStateRules(subtractRules.a);
+    polytreeB.deletePolygonsByStateRules(subtractRules.b);
+    polytreeB.deletePolygonsByIntersection(false);
+    polytreeB.invert();
+    polytreeA.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    polytreeB.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    if (polytreeA.mesh && polytreeA.mesh.material.side !== currentMeshSideA) {
+      polytreeA.mesh.material.side = currentMeshSideA;
+    }
+    if (polytreeB.mesh && polytreeB.mesh.material.side !== currentMeshSideB) {
+      polytreeB.mesh.material.side = currentMeshSideB;
+    }
+  } else {
+    polytreeA.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+  }
+  trianglesSet.clear();
+  trianglesSet = void 0;
+  polytree.markPolygonsAsOriginal();
+  buildTargetPolytree && polytree.buildTree();
+  return polytree;
+};
+var intersectRules;
+intersectRules = {
+  // Rules for object A: Remove inside+coplanar-back, outside+coplanar-front/back, and outside.
+  a: [
+    {
+      array: true,
+      rule: [
+        "inside",
+        "coplanar-back"
+      ]
+    },
+    {
+      array: true,
+      rule: [
+        "outside",
+        "coplanar-front"
+      ]
+    },
+    {
+      array: true,
+      rule: [
+        "outside",
+        "coplanar-back"
+      ]
+    },
+    {
+      array: false,
+      rule: "outside"
+    }
+  ],
+  // Rules for object B: Remove inside+coplanar-front/back, outside+coplanar-front/back, and outside.
+  b: [
+    {
+      array: true,
+      rule: [
+        "inside",
+        "coplanar-front"
+      ]
+    },
+    {
+      array: true,
+      rule: [
+        "inside",
+        "coplanar-back"
+      ]
+    },
+    {
+      array: true,
+      rule: [
+        "outside",
+        "coplanar-front"
+      ]
+    },
+    {
+      array: true,
+      rule: [
+        "outside",
+        "coplanar-back"
+      ]
+    },
+    {
+      array: false,
+      rule: "outside"
+    }
+  ]
+};
+Polytree.intersect = function(mesh1, mesh2, async = true) {
+  var polytreeA, polytreeB, resultMesh, resultPolytree, targetMaterial;
+  if (async) {
+    if (mesh1.isPolytree && mesh2.isPolytree) {
+      return Polytree.async.intersect(mesh1, mesh2, true);
+    } else {
+      polytreeA = Polytree.fromMesh(mesh1);
+      polytreeB = Polytree.fromMesh(mesh2);
+      targetMaterial = Array.isArray(mesh1.material) ? mesh1.material[0] : mesh1.material;
+      targetMaterial = targetMaterial.clone();
+      return Polytree.async.intersect(polytreeA, polytreeB, false).then(function(resultPolytree2) {
+        var resultMesh2;
+        resultMesh2 = Polytree.toMesh(resultPolytree2, targetMaterial);
+        disposePolytreeResources(polytreeA, polytreeB, resultPolytree2);
+        return resultMesh2;
+      });
+    }
+  }
+  if (mesh1.isPolytree && mesh2.isPolytree) {
+    polytreeA = mesh1;
+    polytreeB = mesh2;
+    return this.intersectCore(polytreeA, polytreeB, true);
+  } else {
+    polytreeA = Polytree.fromMesh(mesh1);
+    polytreeB = Polytree.fromMesh(mesh2);
+    targetMaterial = Array.isArray(mesh1.material) ? mesh1.material[0] : mesh1.material;
+    targetMaterial = targetMaterial.clone();
+    resultPolytree = this.intersectCore(polytreeA, polytreeB, false);
+    resultMesh = Polytree.toMesh(resultPolytree, targetMaterial);
+    disposePolytreeResources(polytreeA, polytreeB, resultPolytree);
+    return resultMesh;
+  }
+};
+Polytree.intersectCore = function(polytreeA, polytreeB, buildTargetPolytree = true) {
+  var currentMeshSideA, currentMeshSideB, polytree, trianglesSet;
+  polytree = new Polytree();
+  trianglesSet = /* @__PURE__ */ new Set();
+  if (polytreeA.box.intersectsBox(polytreeB.box)) {
+    currentMeshSideA = void 0;
+    currentMeshSideB = void 0;
+    if (polytreeA.mesh) {
+      currentMeshSideA = polytreeA.mesh.material.side;
+      polytreeA.mesh.material.side = DoubleSide;
+    }
+    if (polytreeB.mesh) {
+      currentMeshSideB = polytreeB.mesh.material.side;
+      polytreeB.mesh.material.side = DoubleSide;
+    }
+    polytreeA.resetPolygons(false);
+    polytreeB.resetPolygons(false);
+    polytreeA.markIntesectingPolygons(polytreeB);
+    polytreeB.markIntesectingPolygons(polytreeA);
+    handleIntersectingPolytrees(polytreeA, polytreeB);
+    polytreeA.deleteReplacedPolygons();
+    polytreeB.deleteReplacedPolygons();
+    polytreeA.deletePolygonsByStateRules(intersectRules.a);
+    polytreeB.deletePolygonsByStateRules(intersectRules.b);
+    polytreeA.deletePolygonsByIntersection(false);
+    polytreeB.deletePolygonsByIntersection(false);
+    polytreeA.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    polytreeB.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    if (polytreeA.mesh && polytreeA.mesh.material.side !== currentMeshSideA) {
+      polytreeA.mesh.material.side = currentMeshSideA;
+    }
+    if (polytreeB.mesh && polytreeB.mesh.material.side !== currentMeshSideB) {
+      polytreeB.mesh.material.side = currentMeshSideB;
+    }
+  }
+  trianglesSet.clear();
+  trianglesSet = void 0;
+  polytree.markPolygonsAsOriginal();
+  buildTargetPolytree && polytree.buildTree();
+  return polytree;
+};
+Polytree.async = {
+  // Default batch size for processing large arrays of objects.
+  // Objects arrays larger than this size will be processed in batches to prevent memory issues.
+  batchSize: DEFAULT_BUFFER_SIZE,
+  // Maximum worker threads hint for parallel processing (informational).
+  // Set to Infinity for unlimited parallelism when supported by the environment.
+  maxWorkerThreads: MAX_WORKER_THREADS,
+  // Perform asynchronous union operation between two polytree objects.
+  // Creates a new polytree containing the combined volume of both input polytrees.
+  // @param polytreeA - First polytree operand for the union operation.
+  // @param polytreeB - Second polytree operand for the union operation.
+  // @param buildTargetPolytree - Whether to build the target polytree structure (default: true).
+  // @return Promise that resolves to the resulting polytree from the union operation.
+  unite: function(polytreeA, polytreeB, buildTargetPolytree = true) {
+    return new Promise(function(resolve, reject) {
+      var error, result, timeoutId;
+      timeoutId = null;
+      if (ASYNC_OPERATION_TIMEOUT !== Infinity) {
+        timeoutId = setTimeout(function() {
+          return reject(new Error(`Union operation timed out after ${ASYNC_OPERATION_TIMEOUT}ms`));
+        }, ASYNC_OPERATION_TIMEOUT);
+      }
+      try {
+        result = Polytree.uniteCore(polytreeA, polytreeB, buildTargetPolytree);
+        disposePolytreeResources(polytreeA, polytreeB);
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        return resolve(result);
+      } catch (error1) {
+        error = error1;
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        disposePolytreeResources(polytreeA, polytreeB);
+        return reject(error);
+      }
+    });
+  },
+  // Perform asynchronous subtraction operation between two polytree objects.
+  // Creates a new polytree by removing the volume of polytreeB from polytreeA.
+  // @param polytreeA - The polytree to subtract from (minuend).
+  // @param polytreeB - The polytree to subtract (subtrahend).
+  // @param buildTargetPolytree - Whether to build the target polytree structure (default: true).
+  // @return Promise that resolves to the resulting polytree from the subtraction operation.
+  subtract: function(polytreeA, polytreeB, buildTargetPolytree = true) {
+    return new Promise(function(resolve, reject) {
+      var error, result, timeoutId;
+      timeoutId = null;
+      if (ASYNC_OPERATION_TIMEOUT !== Infinity) {
+        timeoutId = setTimeout(function() {
+          return reject(new Error(`Subtract operation timed out after ${ASYNC_OPERATION_TIMEOUT}ms`));
+        }, ASYNC_OPERATION_TIMEOUT);
+      }
+      try {
+        result = Polytree.subtractCore(polytreeA, polytreeB, buildTargetPolytree);
+        disposePolytreeResources(polytreeA, polytreeB);
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        return resolve(result);
+      } catch (error1) {
+        error = error1;
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        disposePolytreeResources(polytreeA, polytreeB);
+        return reject(error);
+      }
+    });
+  },
+  // Perform asynchronous intersection operation between two polytree objects.
+  // Creates a new polytree containing only the overlapping volume of both input polytrees.
+  // @param polytreeA - First polytree operand for the intersection operation.
+  // @param polytreeB - Second polytree operand for the intersection operation.
+  // @param buildTargetPolytree - Whether to build the target polytree structure (default: true).
+  // @return Promise that resolves to the resulting polytree from the intersection operation.
+  intersect: function(polytreeA, polytreeB, buildTargetPolytree = true) {
+    return new Promise(function(resolve, reject) {
+      var error, result, timeoutId;
+      timeoutId = null;
+      if (ASYNC_OPERATION_TIMEOUT !== Infinity) {
+        timeoutId = setTimeout(function() {
+          return reject(new Error(`Intersect operation timed out after ${ASYNC_OPERATION_TIMEOUT}ms`));
+        }, ASYNC_OPERATION_TIMEOUT);
+      }
+      try {
+        result = Polytree.intersectCore(polytreeA, polytreeB, buildTargetPolytree);
+        disposePolytreeResources(polytreeA, polytreeB);
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        return resolve(result);
+      } catch (error1) {
+        error = error1;
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        disposePolytreeResources(polytreeA, polytreeB);
+        return reject(error);
+      }
+    });
+  },
+  // Perform asynchronous union operation on an array of objects.
+  // Efficiently processes large arrays using batching and parallel execution.
+  // This method can handle arrays of meshes or polytrees and will convert them as needed.
+  // @param objectArray - Array of meshes or polytrees to unite.
+  // @param materialIndexMax - Maximum material index for assignment (default: Infinity).
+  // @return Promise that resolves to a single polytree containing the union of all objects.
+  uniteArray: function(objectArray, materialIndexMax = Infinity) {
+    return Polytree.async.processArrayWithOperation(objectArray, materialIndexMax, Polytree.async.unite, Polytree.async.uniteArray, "union");
+  },
+  // Perform asynchronous subtraction operation on an array of objects.
+  // Efficiently processes large arrays using batching and parallel execution.
+  // This method subtracts all subsequent objects from the first object in the array.
+  // @param objectArray - Array of meshes or polytrees to process with subtraction.
+  // @param materialIndexMax - Maximum material index for assignment (default: Infinity).
+  // @return Promise that resolves to a single polytree with all subtractions applied.
+  subtractArray: function(objectArray, materialIndexMax = Infinity) {
+    return Polytree.async.processArrayWithOperation(objectArray, materialIndexMax, Polytree.async.subtract, Polytree.async.subtractArray, "subtraction");
+  },
+  // Perform asynchronous intersection operation on an array of objects.
+  // Efficiently processes large arrays using batching and parallel execution.
+  // This method finds the overlapping volume common to all objects in the array.
+  // @param objectArray - Array of meshes or polytrees to intersect.
+  // @param materialIndexMax - Maximum material index for assignment (default: Infinity).
+  // @return Promise that resolves to a single polytree containing the intersection of all objects.
+  intersectArray: function(objectArray, materialIndexMax = Infinity) {
+    return Polytree.async.processArrayWithOperation(objectArray, materialIndexMax, Polytree.async.intersect, Polytree.async.intersectArray, "intersection");
+  },
+  // Main operation handler that delegates to the synchronous operation method.
+  // This provides a unified interface for complex CSG operations with async support.
+  // @param operationObject - Object containing the operation definition.
+  // @param returnPolytrees - Whether to return polytree objects instead of meshes.
+  // @param buildTargetPolytree - Whether to build the target polytree structure.
+  // @param options - Configuration options including objCounter for unique IDs.
+  // @param firstRun - Whether this is the top-level operation call.
+  // @return Result of the operation (mesh, polytree, or operation tree).
+  operation: function(operationObject, returnPolytrees = false, buildTargetPolytree = true, options = {
+    objCounter: 0
+  }, firstRun = true) {
+    return Polytree.operation(operationObject, returnPolytrees, buildTargetPolytree, options, firstRun, true);
+  },
+  // Generic helper method for processing array operations with any CSG operation.
+  // This reduces code duplication between uniteArray, subtractArray, and intersectArray.
+  // @param objectArray - Array of meshes or polytrees to process.
+  // @param materialIndexMax - Maximum material index for assignment.
+  // @param operationMethod - The async CSG method to use (unite, subtract, or intersect).
+  // @param arrayOperationMethod - The corresponding array method for recursive calls.
+  // @param operationName - Name of the operation for error messages.
+  // @return Promise that resolves to the final result polytree.
+  processArrayWithOperation: function(objectArray, materialIndexMax, operationMethod, arrayOperationMethod, operationName) {
+    return new Promise(function(resolve, reject) {
+      var batchArray, batchPromise, convertedPolytree, currentBatch, currentBatchIndex, error, i, isMainPolytreeUsed, j, leftOverPolytree, leftOverPromise, mainPolytree, materialIndex, objectIndex, operationPromises, pairPromise, pairStartIndex, polytreesArray, ref, ref1, shouldUseBatching;
+      try {
+        shouldUseBatching = Polytree.async.batchSize > 4 && Polytree.async.batchSize < objectArray.length;
+        mainPolytree = void 0;
+        isMainPolytreeUsed = false;
+        operationPromises = [];
+        if (shouldUseBatching) {
+          batchArray = [];
+          currentBatchIndex = 0;
+          while (currentBatchIndex < objectArray.length) {
+            batchArray.push(objectArray.slice(currentBatchIndex, currentBatchIndex + Polytree.async.batchSize));
+            currentBatchIndex += Polytree.async.batchSize;
+          }
+          currentBatch = batchArray.shift();
+          while (currentBatch) {
+            batchPromise = arrayOperationMethod(currentBatch, 0);
+            operationPromises.push(batchPromise);
+            currentBatch = batchArray.shift();
+          }
+          shouldUseBatching = true;
+          isMainPolytreeUsed = true;
+          objectArray.length = 0;
+        } else {
+          polytreesArray = [];
+          for (objectIndex = i = 0, ref = objectArray.length; 0 <= ref ? i < ref : i > ref; objectIndex = 0 <= ref ? ++i : --i) {
+            materialIndex = objectIndex > materialIndexMax ? materialIndexMax : objectIndex;
+            convertedPolytree = void 0;
+            if (objectArray[objectIndex].isMesh) {
+              convertedPolytree = Polytree.fromMesh(objectArray[objectIndex], materialIndexMax > -1 ? materialIndex : void 0);
+            } else {
+              convertedPolytree = objectArray[objectIndex];
+              if (materialIndexMax > -1) {
+                convertedPolytree.setPolygonIndex(materialIndex);
+              }
+            }
+            convertedPolytree.polytreeIndex = objectIndex;
+            polytreesArray.push(convertedPolytree);
+          }
+          mainPolytree = polytreesArray.shift();
+          leftOverPolytree = void 0;
+          for (pairStartIndex = j = 0, ref1 = polytreesArray.length; j < ref1; pairStartIndex = j += 2) {
+            if (pairStartIndex + 1 >= polytreesArray.length) {
+              leftOverPolytree = polytreesArray[pairStartIndex];
+              break;
+            }
+            pairPromise = operationMethod(polytreesArray[pairStartIndex], polytreesArray[pairStartIndex + 1]);
+            operationPromises.push(pairPromise);
+          }
+          if (leftOverPolytree) {
+            leftOverPromise = operationMethod(mainPolytree, leftOverPolytree);
+            operationPromises.push(leftOverPromise);
+            isMainPolytreeUsed = true;
+          }
+        }
+        return Promise.allSettled(operationPromises).then(function(promiseResults) {
+          var successfulPolytrees;
+          successfulPolytrees = [];
+          promiseResults.forEach(function(promiseResult) {
+            if (promiseResult.status === "fulfilled") {
+              return successfulPolytrees.push(promiseResult.value);
+            }
+          });
+          if (!isMainPolytreeUsed) {
+            successfulPolytrees.unshift(mainPolytree);
+          }
+          if (successfulPolytrees.length > 0) {
+            if (successfulPolytrees.length === 1) {
+              return resolve(successfulPolytrees[0]);
+            } else if (successfulPolytrees.length > 3) {
+              return arrayOperationMethod(successfulPolytrees, shouldUseBatching ? 0 : -1).then(function(finalResult) {
+                return resolve(finalResult);
+              }).catch(function(error2) {
+                return reject(error2);
+              });
+            } else {
+              return operationMethod(successfulPolytrees[0], successfulPolytrees[1]).then(function(intermediateResult) {
+                if (successfulPolytrees.length === 3) {
+                  return operationMethod(intermediateResult, successfulPolytrees[2]).then(function(finalResult) {
+                    return resolve(finalResult);
+                  }).catch(function(error2) {
+                    return reject(error2);
+                  });
+                } else {
+                  return resolve(intermediateResult);
+                }
+              }).catch(function(error2) {
+                return reject(error2);
+              });
+            }
+          } else {
+            return reject(`Unable to find any result polytree after ${operationName} operation.`);
+          }
+        });
+      } catch (error1) {
+        error = error1;
+        return reject(error);
+      }
+    });
+  }
+};
+var Plane;
+Plane = class Plane2 {
+  // Main constructor for creating plane instances.
+  // Creates a plane defined by the equation: normal·point = distanceFromOrigin
+  // @param normal - Three.js Vector3 representing the plane's normal direction.
+  // @param distanceFromOrigin - Distance from origin along the normal direction.
+  constructor(normal, distanceFromOrigin) {
+    this.normal = normal;
+    this.distanceFromOrigin = distanceFromOrigin;
+  }
+  // === OBJECT CREATION AND COPYING ===
+  clone() {
+    return new Plane2(this.normal.clone(), this.distanceFromOrigin);
+  }
+  // === GEOMETRIC TRANSFORMATIONS ===
+  flip() {
+    this.normal.negate();
+    return this.distanceFromOrigin = -this.distanceFromOrigin;
+  }
+  // === COMPARISON OPERATIONS ===
+  // Test if this plane is identical to another plane.
+  // Compares both normal vector and distance parameter for equality.
+  // @param otherPlane - The other plane to compare against.
+  // @return Boolean indicating whether planes are identical.
+  equals(otherPlane) {
+    return this.normal.equals(otherPlane.normal) && this.distanceFromOrigin === otherPlane.distanceFromOrigin;
+  }
+  // === CLEANUP AND DISPOSAL METHODS ===
+  // Clean up plane data by setting all properties to undefined.
+  // Used for memory management during intensive operations.
+  delete() {
+    this.normal = void 0;
+    return this.distanceFromOrigin = void 0;
+  }
+  // === STATIC FACTORY METHODS ===
+  // Create a plane from three points in 3D space.
+  // Uses cross product to compute normal and dot product for distance.
+  // Points should be ordered counter-clockwise when viewed from the front face.
+  // @param firstPoint - First point (Three.js Vector3).
+  // @param secondPoint - Second point (Three.js Vector3).
+  // @param thirdPoint - Third point (Three.js Vector3).
+  // @return New Plane instance passing through the three points.
+  static fromPoints(firstPoint, secondPoint, thirdPoint) {
+    var planeNormal;
+    planeNormal = temporaryTriangleVertex.copy(secondPoint).sub(firstPoint).cross(temporaryTriangleVertexSecondary.copy(thirdPoint).sub(firstPoint)).normalize().clone();
+    return new Plane2(planeNormal, planeNormal.dot(firstPoint));
+  }
+};
+var Polygon;
+Polygon = class Polygon2 {
+  // Main constructor for creating polygon instances.
+  // Initializes all geometric and state properties for CSG processing.
+  // @param vertices - Array of Vertex instances representing the polygon corners.
+  // @param shared - Material or shared data index for grouping polygons.
+  constructor(vertices, shared) {
+    this.id = polygonID++;
+    this.vertices = vertices.map(function(vertex) {
+      return vertex.clone();
+    });
+    this.shared = shared;
+    this.plane = Plane.fromPoints(this.vertices[0].pos, this.vertices[1].pos, this.vertices[2].pos);
+    this.triangle = new Triangle(this.vertices[0].pos, this.vertices[1].pos, this.vertices[2].pos);
+    this.intersects = false;
+    this.state = "undecided";
+    this.previousState = "undecided";
+    this.previousStates = [];
+    this.valid = true;
+    this.coplanar = false;
+    this.originalValid = false;
+    this.newPolygon = false;
+  }
+  // === SMALL HELPERS AND GETTERS ===
+  // Get the midpoint of the polygon triangle.
+  // Caches the result for performance optimization.
+  // @return Three.js Vector3 representing the triangle midpoint.
+  getMidpoint() {
+    if (this.triangle.midPoint) {
+      return this.triangle.midPoint;
+    } else {
+      return this.triangle.midPoint = this.triangle.getMidpoint(new Vector3());
+    }
+  }
+  // === GEOMETRIC TRANSFORMATIONS ===
+  // Apply a transformation matrix to the polygon vertices and update derived geometry.
+  // Updates vertex positions, normals, and recalculates plane and triangle data.
+  // @param matrix - Three.js Matrix4 transformation to apply to vertices.
+  // @param normalMatrix - Three.js Matrix3 for transforming normals (auto-calculated if not provided).
+  applyMatrix(matrix, normalMatrix) {
+    normalMatrix = normalMatrix || temporaryMatrixWithNormalCalc.getNormalMatrix(matrix);
+    this.vertices.forEach(function(vertex) {
+      vertex.pos.applyMatrix4(matrix);
+      return vertex.normal.applyMatrix3(normalMatrix);
+    });
+    this.plane.delete();
+    this.plane = Plane.fromPoints(this.vertices[0].pos, this.vertices[1].pos, this.vertices[2].pos);
+    this.triangle.set(this.vertices[0].pos, this.vertices[1].pos, this.vertices[2].pos);
+    if (this.triangle.midPoint) {
+      return this.triangle.getMidpoint(this.triangle.midPoint);
+    }
+  }
+  // Flip the polygon orientation by reversing vertex order and flipping normals.
+  // Used for changing polygon winding and surface normal direction.
+  flip() {
+    var tmp;
+    this.vertices.reverse().forEach(function(vertex) {
+      return vertex.flip();
+    });
+    tmp = this.triangle.a;
+    this.triangle.a = this.triangle.c;
+    this.triangle.c = tmp;
+    return this.plane.flip();
+  }
+  // === CSG STATE MANAGEMENT ===
+  // Reset polygon state to initial values for fresh CSG operations.
+  // Clears intersection flags and classification states.
+  // @param resetOriginal - Whether to reset the originalValid flag (default: true).
+  reset(resetOriginal = true) {
+    this.intersects = false;
+    this.state = "undecided";
+    this.previousState = "undecided";
+    this.previousStates.length = 0;
+    this.valid = true;
+    this.coplanar = false;
+    resetOriginal && (this.originalValid = false);
+    return this.newPolygon = false;
+  }
+  // Set the classification state of the polygon during CSG operations.
+  // Maintains state history for complex CSG rule evaluation.
+  // @param state - New state to assign ("inside", "outside", "coplanar-front", etc.).
+  // @param keepState - State to preserve (won't change if current state matches this).
+  setState(state, keepState) {
+    if (this.state === keepState) {
+      return;
+    }
+    this.previousState = this.state;
+    this.state !== "undecided" && this.previousStates.push(this.state);
+    return this.state = state;
+  }
+  // Check if polygon has consistently been in the specified state.
+  // Used for CSG rule evaluation requiring state consistency.
+  // @param state - State to check for consistency.
+  // @return Boolean indicating if all states match the specified state.
+  checkAllStates(state) {
+    var i, len, previousState, ref;
+    if (this.state !== state || this.previousState !== state && this.previousState !== "undecided") {
+      return false;
+    }
+    ref = this.previousStates;
+    for (i = 0, len = ref.length; i < len; i++) {
+      previousState = ref[i];
+      if (previousState !== state) {
+        return false;
+      }
+    }
+    return true;
+  }
+  // === VALIDITY MANAGEMENT ===
+  // Mark polygon as invalid (will be excluded from processing).
+  setInvalid() {
+    return this.valid = false;
+  }
+  // Mark polygon as valid (will be included in processing).
+  setValid() {
+    return this.valid = true;
+  }
+  // === OBJECT CREATION AND COPYING ===
+  // Create a polygon with default material index.
+  // Convenience method for creating polygons without specifying material.
+  // @param vertices - Array of Vertex instances representing the polygon corners.
+  // @return New Polygon instance with default material.
+  static createWithDefaultMaterial(vertices) {
+    return new Polygon2(vertices, DEFAULT_MATERIAL_INDEX);
+  }
+  // Create a deep copy of this polygon with all properties.
+  // Preserves all state information and geometric data.
+  // @return New Polygon instance with copied data.
+  clone() {
+    var polygon;
+    polygon = new Polygon2(this.vertices.map(function(vertex) {
+      return vertex.clone();
+    }), this.shared);
+    polygon.intersects = this.intersects;
+    polygon.valid = this.valid;
+    polygon.coplanar = this.coplanar;
+    polygon.state = this.state;
+    polygon.originalValid = this.originalValid;
+    polygon.newPolygon = this.newPolygon;
+    polygon.previousState = this.previousState;
+    polygon.previousStates = this.previousStates.slice();
+    if (this.triangle.midPoint) {
+      polygon.triangle.midPoint = this.triangle.midPoint.clone();
+    }
+    return polygon;
+  }
+  // === CLEANUP AND DISPOSAL METHODS ===
+  // Clean up polygon data and free memory.
+  // Deletes vertices, geometric objects, and marks polygon as invalid.
+  delete() {
+    this.vertices.forEach(function(vertex) {
+      return vertex.delete();
+    });
+    this.vertices.length = 0;
+    if (this.plane) {
+      this.plane.delete();
+      this.plane = void 0;
+    }
+    this.triangle = void 0;
+    this.shared = void 0;
+    return this.setInvalid();
+  }
+};
+var constructIntersection;
+var intersectionTestEdge2D;
+var intersectionTestVertex2D;
+var isUniqueTriangle;
+var isValidTriangle;
+var pointInTriangleInclusive2D;
+var pointOnSegmentInclusive2D;
+var pointsEqual2D;
+var resolveCoplanarTriangleIntersection;
+var resolveTriangleIntersection;
+var triangleIntersectionCCW2D;
+var triangleIntersectsTriangle;
+var triangleOrientation2D;
+var trianglesOverlap2D;
+isValidTriangle = function(triangle) {
+  if (triangle.a.equals(triangle.b)) {
+    return false;
+  }
+  if (triangle.a.equals(triangle.c)) {
+    return false;
+  }
+  if (triangle.b.equals(triangle.c)) {
+    return false;
+  }
+  return true;
+};
+isUniqueTriangle = function(triangle, set, map) {
+  var hash1;
+  hash1 = `{${triangle.a.x},${triangle.a.y},${triangle.a.z}}-{${triangle.b.x},${triangle.b.y},${triangle.b.z}}-{${triangle.c.x},${triangle.c.y},${triangle.c.z}}`;
+  if (set.has(hash1) === true) {
+    return false;
+  } else {
+    set.add(hash1);
+    if (map) {
+      map.set(triangle, triangle);
+    }
+    return true;
+  }
+};
+pointsEqual2D = function(p, q, eps = TRIANGLE_2D_EPSILON) {
+  return Math.abs(p.x - q.x) <= eps && Math.abs(p.y - q.y) <= eps;
+};
+pointOnSegmentInclusive2D = function(p, a, b, eps = TRIANGLE_2D_EPSILON) {
+  var maxX, maxY, minX, minY;
+  if (pointsEqual2D(a, b, eps)) {
+    return pointsEqual2D(p, a, eps) || pointsEqual2D(p, b, eps);
+  }
+  if (Math.abs(triangleOrientation2D(p, a, b)) > eps) {
+    return false;
+  }
+  minX = Math.min(a.x, b.x) - eps;
+  maxX = Math.max(a.x, b.x) + eps;
+  minY = Math.min(a.y, b.y) - eps;
+  maxY = Math.max(a.y, b.y) + eps;
+  return p.x >= minX && p.x <= maxX && p.y >= minY && p.y <= maxY;
+};
+pointInTriangleInclusive2D = function(p, a, b, c, eps = TRIANGLE_2D_EPSILON) {
+  var o, s1, s2, s3;
+  o = triangleOrientation2D(a, b, c);
+  if (o > eps) {
+    s1 = triangleOrientation2D(p, a, b);
+    s2 = triangleOrientation2D(p, b, c);
+    s3 = triangleOrientation2D(p, c, a);
+    return s1 >= -eps && s2 >= -eps && s3 >= -eps;
+  } else if (o < -eps) {
+    s1 = triangleOrientation2D(p, a, b);
+    s2 = triangleOrientation2D(p, b, c);
+    s3 = triangleOrientation2D(p, c, a);
+    return s1 <= eps && s2 <= eps && s3 <= eps;
+  } else {
+    if (pointsEqual2D(a, b, eps) && pointsEqual2D(b, c, eps)) {
+      return pointsEqual2D(p, a, eps);
+    }
+    if (pointsEqual2D(a, b, eps)) {
+      return pointOnSegmentInclusive2D(p, b, c, eps);
+    }
+    if (pointsEqual2D(b, c, eps)) {
+      return pointOnSegmentInclusive2D(p, a, b, eps);
+    }
+    if (pointsEqual2D(c, a, eps)) {
+      return pointOnSegmentInclusive2D(p, a, b, eps);
+    }
+    return pointOnSegmentInclusive2D(p, a, b, eps) || pointOnSegmentInclusive2D(p, b, c, eps) || pointOnSegmentInclusive2D(p, c, a, eps);
+  }
+};
+triangleIntersectsTriangle = function(triangleA, triangleB, additions = {
+  coplanar: false,
+  source: new Vector3(),
+  target: new Vector3()
+}) {
+  var distanceVertex1A, distanceVertex1B, distanceVertex2A, distanceVertex2B, distanceVertex3A, distanceVertex3B, normal1, normal2, vertex1TriangleA, vertex1TriangleB, vertex2TriangleA, vertex2TriangleB, vertex3TriangleA, vertex3TriangleB;
+  vertex1TriangleA = triangleA.a;
+  vertex2TriangleA = triangleA.b;
+  vertex3TriangleA = triangleA.c;
+  vertex1TriangleB = triangleB.a;
+  vertex2TriangleB = triangleB.b;
+  vertex3TriangleB = triangleB.c;
+  temporaryVector3Primary.copy(vertex1TriangleB).sub(vertex3TriangleB);
+  temporaryVector3Secondary.copy(vertex2TriangleB).sub(vertex3TriangleB);
+  normal2 = new Vector3().copy(temporaryVector3Primary).cross(temporaryVector3Secondary);
+  temporaryVector3Primary.copy(vertex1TriangleA).sub(vertex3TriangleB);
+  distanceVertex1A = temporaryVector3Primary.dot(normal2);
+  temporaryVector3Primary.copy(vertex2TriangleA).sub(vertex3TriangleB);
+  distanceVertex2A = temporaryVector3Primary.dot(normal2);
+  temporaryVector3Primary.copy(vertex3TriangleA).sub(vertex3TriangleB);
+  distanceVertex3A = temporaryVector3Primary.dot(normal2);
+  if (distanceVertex1A * distanceVertex2A > 0 && distanceVertex1A * distanceVertex3A > 0) {
+    return false;
+  }
+  temporaryVector3Primary.copy(vertex2TriangleA).sub(vertex1TriangleA);
+  temporaryVector3Secondary.copy(vertex3TriangleA).sub(vertex1TriangleA);
+  normal1 = new Vector3().copy(temporaryVector3Primary).cross(temporaryVector3Secondary);
+  temporaryVector3Primary.copy(vertex1TriangleB).sub(vertex3TriangleA);
+  distanceVertex1B = temporaryVector3Primary.dot(normal1);
+  temporaryVector3Primary.copy(vertex2TriangleB).sub(vertex3TriangleA);
+  distanceVertex2B = temporaryVector3Primary.dot(normal1);
+  temporaryVector3Primary.copy(vertex3TriangleB).sub(vertex3TriangleA);
+  distanceVertex3B = temporaryVector3Primary.dot(normal1);
+  if (distanceVertex1B * distanceVertex2B > 0 && distanceVertex1B * distanceVertex3B > 0) {
+    return false;
+  }
+  additions.normal1 = normal1;
+  additions.normal2 = normal2;
+  if (distanceVertex1A > 0) {
+    if (distanceVertex2A > 0) {
+      return resolveTriangleIntersection(vertex3TriangleA, vertex1TriangleA, vertex2TriangleA, vertex1TriangleB, vertex3TriangleB, vertex2TriangleB, distanceVertex1B, distanceVertex3B, distanceVertex2B, additions);
+    } else if (distanceVertex3A > 0) {
+      return resolveTriangleIntersection(vertex2TriangleA, vertex3TriangleA, vertex1TriangleA, vertex1TriangleB, vertex3TriangleB, vertex2TriangleB, distanceVertex1B, distanceVertex3B, distanceVertex2B, additions);
+    } else {
+      return resolveTriangleIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, distanceVertex1B, distanceVertex2B, distanceVertex3B, additions);
+    }
+  } else if (distanceVertex1A < 0) {
+    if (distanceVertex2A < 0) {
+      return resolveTriangleIntersection(vertex3TriangleA, vertex1TriangleA, vertex2TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, distanceVertex1B, distanceVertex2B, distanceVertex3B, additions);
+    } else if (distanceVertex3A < 0) {
+      return resolveTriangleIntersection(vertex2TriangleA, vertex3TriangleA, vertex1TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, distanceVertex1B, distanceVertex2B, distanceVertex3B, additions);
+    } else {
+      return resolveTriangleIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex3TriangleB, vertex2TriangleB, distanceVertex1B, distanceVertex3B, distanceVertex2B, additions);
+    }
+  } else {
+    if (distanceVertex2A < 0) {
+      if (distanceVertex3A >= 0) {
+        return resolveTriangleIntersection(vertex2TriangleA, vertex3TriangleA, vertex1TriangleA, vertex1TriangleB, vertex3TriangleB, vertex2TriangleB, distanceVertex1B, distanceVertex3B, distanceVertex2B, additions);
+      } else {
+        return resolveTriangleIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, distanceVertex1B, distanceVertex2B, distanceVertex3B, additions);
+      }
+    } else if (distanceVertex2A > 0) {
+      if (distanceVertex3A > 0) {
+        return resolveTriangleIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex3TriangleB, vertex2TriangleB, distanceVertex1B, distanceVertex3B, distanceVertex2B, additions);
+      } else {
+        return resolveTriangleIntersection(vertex2TriangleA, vertex3TriangleA, vertex1TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, distanceVertex1B, distanceVertex2B, distanceVertex3B, additions);
+      }
+    } else {
+      if (distanceVertex3A > 0) {
+        return resolveTriangleIntersection(vertex3TriangleA, vertex1TriangleA, vertex2TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, distanceVertex1B, distanceVertex2B, distanceVertex3B, additions);
+      } else if (distanceVertex3A < 0) {
+        return resolveTriangleIntersection(vertex3TriangleA, vertex1TriangleA, vertex2TriangleA, vertex1TriangleB, vertex3TriangleB, vertex2TriangleB, distanceVertex1B, distanceVertex3B, distanceVertex2B, additions);
+      } else {
+        additions.coplanar = true;
+        return resolveCoplanarTriangleIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, normal1, normal2);
+      }
+    }
+  }
+};
+resolveTriangleIntersection = function(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, distanceVertex1B, distanceVertex2B, distanceVertex3B, additions) {
+  if (distanceVertex1B > 0 && distanceVertex2B > 0 && distanceVertex3B > 0 || distanceVertex1B < 0 && distanceVertex2B < 0 && distanceVertex3B < 0) {
+    return false;
+  }
+  if (distanceVertex1B > 0) {
+    if (distanceVertex2B > 0) {
+      return constructIntersection(vertex1TriangleA, vertex3TriangleA, vertex2TriangleA, vertex3TriangleB, vertex1TriangleB, vertex2TriangleB, additions);
+    } else if (distanceVertex3B > 0) {
+      return constructIntersection(vertex1TriangleA, vertex3TriangleA, vertex2TriangleA, vertex2TriangleB, vertex3TriangleB, vertex1TriangleB, additions);
+    } else {
+      return constructIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, additions);
+    }
+  } else if (distanceVertex1B < 0) {
+    if (distanceVertex2B < 0) {
+      return constructIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex3TriangleB, vertex1TriangleB, vertex2TriangleB, additions);
+    } else if (distanceVertex3B < 0) {
+      return constructIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex2TriangleB, vertex3TriangleB, vertex1TriangleB, additions);
+    } else {
+      return constructIntersection(vertex1TriangleA, vertex3TriangleA, vertex2TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, additions);
+    }
+  } else {
+    if (distanceVertex2B < 0) {
+      if (distanceVertex3B >= 0) {
+        return constructIntersection(vertex1TriangleA, vertex3TriangleA, vertex2TriangleA, vertex2TriangleB, vertex3TriangleB, vertex1TriangleB, additions);
+      } else {
+        return constructIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, additions);
+      }
+    } else if (distanceVertex2B > 0) {
+      if (distanceVertex3B > 0) {
+        return constructIntersection(vertex1TriangleA, vertex3TriangleA, vertex2TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, additions);
+      } else {
+        return constructIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex2TriangleB, vertex3TriangleB, vertex1TriangleB, additions);
+      }
+    } else {
+      if (distanceVertex3B > 0) {
+        return constructIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex3TriangleB, vertex1TriangleB, vertex2TriangleB, additions);
+      } else if (distanceVertex3B < 0) {
+        return constructIntersection(vertex1TriangleA, vertex3TriangleA, vertex2TriangleA, vertex3TriangleB, vertex1TriangleB, vertex2TriangleB, additions);
+      } else {
+        additions.coplanar = true;
+        return resolveCoplanarTriangleIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, additions.normal1, additions.normal2);
+      }
+    }
+  }
+};
+resolveCoplanarTriangleIntersection = function(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, normalTriangleA, normalTriangleB) {
+  var normalAbsX, normalAbsY, normalAbsZ, vertex1TriangleA2D, vertex1TriangleB2D, vertex2TriangleA2D, vertex2TriangleB2D, vertex3TriangleA2D, vertex3TriangleB2D;
+  vertex1TriangleA2D = new Vector2();
+  vertex2TriangleA2D = new Vector2();
+  vertex3TriangleA2D = new Vector2();
+  vertex1TriangleB2D = new Vector2();
+  vertex2TriangleB2D = new Vector2();
+  vertex3TriangleB2D = new Vector2();
+  normalAbsX = Math.abs(normalTriangleA.x);
+  normalAbsY = Math.abs(normalTriangleA.y);
+  normalAbsZ = Math.abs(normalTriangleA.z);
+  if (normalAbsX > normalAbsZ && normalAbsX >= normalAbsY) {
+    vertex1TriangleA2D.set(vertex1TriangleA.y, vertex1TriangleA.z);
+    vertex2TriangleA2D.set(vertex2TriangleA.y, vertex2TriangleA.z);
+    vertex3TriangleA2D.set(vertex3TriangleA.y, vertex3TriangleA.z);
+    vertex1TriangleB2D.set(vertex1TriangleB.y, vertex1TriangleB.z);
+    vertex2TriangleB2D.set(vertex2TriangleB.y, vertex2TriangleB.z);
+    vertex3TriangleB2D.set(vertex3TriangleB.y, vertex3TriangleB.z);
+  } else if (normalAbsY > normalAbsZ && normalAbsY >= normalAbsX) {
+    vertex1TriangleA2D.set(vertex1TriangleA.x, vertex1TriangleA.z);
+    vertex2TriangleA2D.set(vertex2TriangleA.x, vertex2TriangleA.z);
+    vertex3TriangleA2D.set(vertex3TriangleA.x, vertex3TriangleA.z);
+    vertex1TriangleB2D.set(vertex1TriangleB.x, vertex1TriangleB.z);
+    vertex2TriangleB2D.set(vertex2TriangleB.x, vertex2TriangleB.z);
+    vertex3TriangleB2D.set(vertex3TriangleB.x, vertex3TriangleB.z);
+  } else {
+    vertex1TriangleA2D.set(vertex1TriangleA.x, vertex1TriangleA.y);
+    vertex2TriangleA2D.set(vertex2TriangleA.x, vertex2TriangleA.y);
+    vertex3TriangleA2D.set(vertex3TriangleA.x, vertex3TriangleA.y);
+    vertex1TriangleB2D.set(vertex1TriangleB.x, vertex1TriangleB.y);
+    vertex2TriangleB2D.set(vertex2TriangleB.x, vertex2TriangleB.y);
+    vertex3TriangleB2D.set(vertex3TriangleB.x, vertex3TriangleB.y);
+  }
+  return trianglesOverlap2D(vertex1TriangleA2D, vertex2TriangleA2D, vertex3TriangleA2D, vertex1TriangleB2D, vertex2TriangleB2D, vertex3TriangleB2D);
+};
+trianglesOverlap2D = function(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB) {
+  var aE, aMax, aMin, aS, bE, bMax, bMin, bS, extractSegment, isLineDegenerate, maxAx, maxAy, maxBx, maxBy, minAx, minAy, minBx, minBy, spanAx, spanAy;
+  if (pointsEqual2D(vertex1TriangleB, vertex2TriangleB, TRIANGLE_2D_EPSILON) && pointsEqual2D(vertex2TriangleB, vertex3TriangleB, TRIANGLE_2D_EPSILON)) {
+    return pointInTriangleInclusive2D(vertex1TriangleB, vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, TRIANGLE_2D_EPSILON);
+  }
+  if (pointsEqual2D(vertex1TriangleA, vertex2TriangleA, TRIANGLE_2D_EPSILON) && pointsEqual2D(vertex2TriangleA, vertex3TriangleA, TRIANGLE_2D_EPSILON)) {
+    return pointInTriangleInclusive2D(vertex1TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, TRIANGLE_2D_EPSILON);
+  }
+  isLineDegenerate = function(v1, v2, v3) {
+    return pointsEqual2D(v1, v2, TRIANGLE_2D_EPSILON) && !pointsEqual2D(v2, v3, TRIANGLE_2D_EPSILON) || pointsEqual2D(v2, v3, TRIANGLE_2D_EPSILON) && !pointsEqual2D(v1, v2, TRIANGLE_2D_EPSILON) || pointsEqual2D(v3, v1, TRIANGLE_2D_EPSILON) && !pointsEqual2D(v1, v2, TRIANGLE_2D_EPSILON);
+  };
+  extractSegment = function(v1, v2, v3) {
+    if (pointsEqual2D(v1, v2, TRIANGLE_2D_EPSILON)) {
+      return [v2, v3];
+    } else if (pointsEqual2D(v2, v3, TRIANGLE_2D_EPSILON)) {
+      return [v1, v2];
+    } else {
+      return [
+        v1,
+        v2
+        // fallback (should not reach if collinear case handled earlier)
+      ];
+    }
+  };
+  if (isLineDegenerate(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA) && isLineDegenerate(vertex1TriangleB, vertex2TriangleB, vertex3TriangleB)) {
+    [aS, aE] = extractSegment(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA);
+    [bS, bE] = extractSegment(vertex1TriangleB, vertex2TriangleB, vertex3TriangleB);
+    minAx = Math.min(aS.x, aE.x);
+    maxAx = Math.max(aS.x, aE.x);
+    minAy = Math.min(aS.y, aE.y);
+    maxAy = Math.max(aS.y, aE.y);
+    minBx = Math.min(bS.x, bE.x);
+    maxBx = Math.max(bS.x, bE.x);
+    minBy = Math.min(bS.y, bE.y);
+    maxBy = Math.max(bS.y, bE.y);
+    if (maxAx < minBx - TRIANGLE_2D_EPSILON || maxBx < minAx - TRIANGLE_2D_EPSILON || maxAy < minBy - TRIANGLE_2D_EPSILON || maxBy < minAy - TRIANGLE_2D_EPSILON) {
+      return false;
+    }
+    if (Math.abs(triangleOrientation2D(aS, aE, bS)) > TRIANGLE_2D_EPSILON) {
+      return false;
+    }
+    spanAx = Math.abs(aE.x - aS.x);
+    spanAy = Math.abs(aE.y - aS.y);
+    if (spanAx >= spanAy) {
+      aMin = Math.min(aS.x, aE.x) - TRIANGLE_2D_EPSILON;
+      aMax = Math.max(aS.x, aE.x) + TRIANGLE_2D_EPSILON;
+      bMin = Math.min(bS.x, bE.x) - TRIANGLE_2D_EPSILON;
+      bMax = Math.max(bS.x, bE.x) + TRIANGLE_2D_EPSILON;
+      return !(aMax < bMin || bMax < aMin);
+    } else {
+      aMin = Math.min(aS.y, aE.y) - TRIANGLE_2D_EPSILON;
+      aMax = Math.max(aS.y, aE.y) + TRIANGLE_2D_EPSILON;
+      bMin = Math.min(bS.y, bE.y) - TRIANGLE_2D_EPSILON;
+      bMax = Math.max(bS.y, bE.y) + TRIANGLE_2D_EPSILON;
+      return !(aMax < bMin || bMax < aMin);
+    }
+  }
+  if (triangleOrientation2D(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA) < 0) {
+    if (triangleOrientation2D(vertex1TriangleB, vertex2TriangleB, vertex3TriangleB) < 0) {
+      return triangleIntersectionCCW2D(vertex1TriangleA, vertex3TriangleA, vertex2TriangleA, vertex1TriangleB, vertex3TriangleB, vertex2TriangleB);
+    } else {
+      return triangleIntersectionCCW2D(vertex1TriangleA, vertex3TriangleA, vertex2TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB);
+    }
+  } else {
+    if (triangleOrientation2D(vertex1TriangleB, vertex2TriangleB, vertex3TriangleB) < 0) {
+      return triangleIntersectionCCW2D(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex3TriangleB, vertex2TriangleB);
+    } else {
+      return triangleIntersectionCCW2D(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB);
+    }
+  }
+};
+triangleOrientation2D = function(a, b, c) {
+  return (a.x - c.x) * (b.y - c.y) - (a.y - c.y) * (b.x - c.x);
+};
+triangleIntersectionCCW2D = function(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB) {
+  if (triangleOrientation2D(vertex1TriangleB, vertex2TriangleB, vertex1TriangleA) >= 0) {
+    if (triangleOrientation2D(vertex2TriangleB, vertex3TriangleB, vertex1TriangleA) >= 0) {
+      if (triangleOrientation2D(vertex3TriangleB, vertex1TriangleB, vertex1TriangleA) >= 0) {
+        return true;
+      } else {
+        return intersectionTestEdge2D(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB);
+      }
+    } else {
+      if (triangleOrientation2D(vertex3TriangleB, vertex1TriangleB, vertex1TriangleA) >= 0) {
+        return intersectionTestEdge2D(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex3TriangleB, vertex1TriangleB, vertex2TriangleB);
+      } else {
+        return intersectionTestVertex2D(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB);
+      }
+    }
+  } else {
+    if (triangleOrientation2D(vertex2TriangleB, vertex3TriangleB, vertex1TriangleA) >= 0) {
+      if (triangleOrientation2D(vertex3TriangleB, vertex1TriangleB, vertex1TriangleA) >= 0) {
+        return intersectionTestEdge2D(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex2TriangleB, vertex3TriangleB, vertex1TriangleB);
+      } else {
+        return intersectionTestVertex2D(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex2TriangleB, vertex3TriangleB, vertex1TriangleB);
+      }
+    } else {
+      return intersectionTestVertex2D(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex3TriangleB, vertex1TriangleB, vertex2TriangleB);
+    }
+  }
+};
+intersectionTestEdge2D = function(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB) {
+  var a1, a2, b1, b2, edgesA, edgesB, i, j, len, len1, segmentIntersectsInclusive;
+  segmentIntersectsInclusive = function(a12, a22, b12, b22) {
+    var maxAx, maxAy, maxBx, maxBy, minAx, minAy, minBx, minBy, o1, o2, o3, o4;
+    minAx = Math.min(a12.x, a22.x);
+    maxAx = Math.max(a12.x, a22.x);
+    minAy = Math.min(a12.y, a22.y);
+    maxAy = Math.max(a12.y, a22.y);
+    minBx = Math.min(b12.x, b22.x);
+    maxBx = Math.max(b12.x, b22.x);
+    minBy = Math.min(b12.y, b22.y);
+    maxBy = Math.max(b12.y, b22.y);
+    if (maxAx < minBx || maxBx < minAx || maxAy < minBy || maxBy < minAy) {
+      return false;
+    }
+    o1 = triangleOrientation2D(a12, a22, b12);
+    o2 = triangleOrientation2D(a12, a22, b22);
+    o3 = triangleOrientation2D(b12, b22, a12);
+    o4 = triangleOrientation2D(b12, b22, a22);
+    if ((o1 > 0 && o2 < 0 || o1 < 0 && o2 > 0) && (o3 > 0 && o4 < 0 || o3 < 0 && o4 > 0)) {
+      return true;
+    }
+    if (Math.abs(o1) <= TRIANGLE_2D_EPSILON && pointOnSegmentInclusive2D(b12, a12, a22, TRIANGLE_2D_EPSILON)) {
+      return true;
+    }
+    if (Math.abs(o2) <= TRIANGLE_2D_EPSILON && pointOnSegmentInclusive2D(b22, a12, a22, TRIANGLE_2D_EPSILON)) {
+      return true;
+    }
+    if (Math.abs(o3) <= TRIANGLE_2D_EPSILON && pointOnSegmentInclusive2D(a12, b12, b22, TRIANGLE_2D_EPSILON)) {
+      return true;
+    }
+    if (Math.abs(o4) <= TRIANGLE_2D_EPSILON && pointOnSegmentInclusive2D(a22, b12, b22, TRIANGLE_2D_EPSILON)) {
+      return true;
+    }
+    return false;
+  };
+  edgesA = [[vertex1TriangleA, vertex2TriangleA], [vertex2TriangleA, vertex3TriangleA], [vertex3TriangleA, vertex1TriangleA]];
+  edgesB = [[vertex1TriangleB, vertex2TriangleB], [vertex2TriangleB, vertex3TriangleB], [vertex3TriangleB, vertex1TriangleB]];
+  for (i = 0, len = edgesA.length; i < len; i++) {
+    [a1, a2] = edgesA[i];
+    for (j = 0, len1 = edgesB.length; j < len1; j++) {
+      [b1, b2] = edgesB[j];
+      if (segmentIntersectsInclusive(a1, a2, b1, b2)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+intersectionTestVertex2D = function(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB) {
+  if (pointInTriangleInclusive2D(vertex1TriangleB, vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, TRIANGLE_2D_EPSILON)) {
+    return true;
+  }
+  if (pointInTriangleInclusive2D(vertex2TriangleB, vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, TRIANGLE_2D_EPSILON)) {
+    return true;
+  }
+  if (pointInTriangleInclusive2D(vertex3TriangleB, vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, TRIANGLE_2D_EPSILON)) {
+    return true;
+  }
+  if (pointInTriangleInclusive2D(vertex1TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, TRIANGLE_2D_EPSILON)) {
+    return true;
+  }
+  if (pointInTriangleInclusive2D(vertex2TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, TRIANGLE_2D_EPSILON)) {
+    return true;
+  }
+  if (pointInTriangleInclusive2D(vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, TRIANGLE_2D_EPSILON)) {
+    return true;
+  }
+  return false;
+};
+constructIntersection = function(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, additions) {
+  var alpha, crossNormal;
+  alpha = void 0;
+  crossNormal = new Vector3();
+  temporaryVector3Primary.subVectors(vertex2TriangleA, vertex1TriangleA);
+  temporaryVector3Secondary.subVectors(vertex3TriangleB, vertex1TriangleA);
+  crossNormal.copy(temporaryVector3Primary).cross(temporaryVector3Secondary);
+  temporaryVector3Quaternary.subVectors(vertex1TriangleB, vertex1TriangleA);
+  if (temporaryVector3Quaternary.dot(crossNormal) > 0) {
+    temporaryVector3Primary.subVectors(vertex3TriangleA, vertex1TriangleA);
+    crossNormal.copy(temporaryVector3Primary).cross(temporaryVector3Secondary);
+    if (temporaryVector3Quaternary.dot(crossNormal) <= 0) {
+      temporaryVector3Secondary.subVectors(vertex2TriangleB, vertex1TriangleA);
+      crossNormal.copy(temporaryVector3Primary).cross(temporaryVector3Secondary);
+      if (temporaryVector3Quaternary.dot(crossNormal) > 0) {
+        temporaryVector3Primary.subVectors(vertex1TriangleA, vertex1TriangleB);
+        temporaryVector3Secondary.subVectors(vertex1TriangleA, vertex3TriangleA);
+        alpha = temporaryVector3Primary.dot(additions.normal2) / temporaryVector3Secondary.dot(additions.normal2);
+        if (!isFinite(alpha)) {
+          return false;
+        }
+        temporaryVector3Primary.copy(temporaryVector3Secondary).multiplyScalar(alpha);
+        additions.source.subVectors(vertex1TriangleA, temporaryVector3Primary);
+        temporaryVector3Primary.subVectors(vertex1TriangleB, vertex1TriangleA);
+        temporaryVector3Secondary.subVectors(vertex1TriangleB, vertex3TriangleB);
+        alpha = temporaryVector3Primary.dot(additions.normal1) / temporaryVector3Secondary.dot(additions.normal1);
+        if (!isFinite(alpha)) {
+          return false;
+        }
+        temporaryVector3Primary.copy(temporaryVector3Secondary).multiplyScalar(alpha);
+        additions.target.subVectors(vertex1TriangleB, temporaryVector3Primary);
+        return true;
+      } else {
+        temporaryVector3Primary.subVectors(vertex1TriangleB, vertex1TriangleA);
+        temporaryVector3Secondary.subVectors(vertex1TriangleB, vertex2TriangleB);
+        alpha = temporaryVector3Primary.dot(additions.normal1) / temporaryVector3Secondary.dot(additions.normal1);
+        if (!isFinite(alpha)) {
+          return false;
+        }
+        temporaryVector3Primary.copy(temporaryVector3Secondary).multiplyScalar(alpha);
+        additions.source.subVectors(vertex1TriangleB, temporaryVector3Primary);
+        temporaryVector3Primary.subVectors(vertex1TriangleB, vertex1TriangleA);
+        temporaryVector3Secondary.subVectors(vertex1TriangleB, vertex3TriangleB);
+        alpha = temporaryVector3Primary.dot(additions.normal1) / temporaryVector3Secondary.dot(additions.normal1);
+        if (!isFinite(alpha)) {
+          return false;
+        }
+        temporaryVector3Primary.copy(temporaryVector3Secondary).multiplyScalar(alpha);
+        additions.target.subVectors(vertex1TriangleB, temporaryVector3Primary);
+        return true;
+      }
+    } else {
+      return false;
+    }
+  } else {
+    temporaryVector3Secondary.subVectors(vertex2TriangleB, vertex1TriangleA);
+    crossNormal.copy(temporaryVector3Primary).cross(temporaryVector3Secondary);
+    if (temporaryVector3Quaternary.dot(crossNormal) < 0) {
+      return false;
+    } else {
+      temporaryVector3Primary.subVectors(vertex3TriangleA, vertex1TriangleA);
+      crossNormal.copy(temporaryVector3Primary).cross(temporaryVector3Secondary);
+      if (temporaryVector3Quaternary.dot(crossNormal) < 0) {
+        temporaryVector3Primary.subVectors(vertex1TriangleB, vertex1TriangleA);
+        temporaryVector3Secondary.subVectors(vertex1TriangleB, vertex2TriangleB);
+        alpha = temporaryVector3Primary.dot(additions.normal1) / temporaryVector3Secondary.dot(additions.normal1);
+        if (!isFinite(alpha)) {
+          return false;
+        }
+        temporaryVector3Primary.copy(temporaryVector3Secondary).multiplyScalar(alpha);
+        additions.source.subVectors(vertex1TriangleB, temporaryVector3Primary);
+        temporaryVector3Primary.subVectors(vertex1TriangleB, vertex1TriangleA);
+        temporaryVector3Secondary.subVectors(vertex1TriangleB, vertex3TriangleB);
+        alpha = temporaryVector3Primary.dot(additions.normal1) / temporaryVector3Secondary.dot(additions.normal1);
+        if (!isFinite(alpha)) {
+          return false;
+        }
+        temporaryVector3Primary.copy(temporaryVector3Secondary).multiplyScalar(alpha);
+        additions.target.subVectors(vertex1TriangleB, temporaryVector3Primary);
+        return true;
+      } else {
+        temporaryVector3Primary.subVectors(vertex1TriangleA, vertex1TriangleB);
+        temporaryVector3Secondary.subVectors(vertex1TriangleA, vertex3TriangleA);
+        alpha = temporaryVector3Primary.dot(additions.normal2) / temporaryVector3Secondary.dot(additions.normal2);
+        if (!isFinite(alpha)) {
+          return false;
+        }
+        temporaryVector3Primary.copy(temporaryVector3Secondary).multiplyScalar(alpha);
+        additions.source.subVectors(vertex1TriangleA, temporaryVector3Primary);
+        temporaryVector3Primary.subVectors(vertex1TriangleA, vertex1TriangleB);
+        temporaryVector3Secondary.subVectors(vertex1TriangleA, vertex2TriangleA);
+        alpha = temporaryVector3Primary.dot(additions.normal2) / temporaryVector3Secondary.dot(additions.normal2);
+        if (!isFinite(alpha)) {
+          return false;
+        }
+        temporaryVector3Primary.copy(temporaryVector3Secondary).multiplyScalar(alpha);
+        additions.target.subVectors(vertex1TriangleA, temporaryVector3Primary);
+        return true;
+      }
+    }
+  }
+  return false;
+};
+var Vertex;
+Vertex = class Vertex2 {
+  // Main constructor for creating vertex instances.
+  // Initializes position, normal, and optional texture/color attributes.
+  // @param pos - Three.js Vector3 representing the vertex position in 3D space.
+  // @param normal - Three.js Vector3 representing the surface normal at this vertex.
+  // @param uv - Optional Three.js Vector2 for texture coordinates.
+  // @param color - Optional Three.js Vector3 for vertex color information.
+  constructor(pos, normal, uv, color) {
+    this.pos = new Vector3().copy(pos);
+    this.normal = new Vector3().copy(normal);
+    uv && (this.uv = new Vector2().copy(uv));
+    color && (this.color = new Vector3().copy(color));
+  }
+  // === OBJECT CREATION AND COPYING ===
+  clone() {
+    return new Vertex2(this.pos.clone(), this.normal.clone(), this.uv && this.uv.clone(), this.color && this.color.clone());
+  }
+  // === GEOMETRIC TRANSFORMATIONS ===
+  flip() {
+    return this.normal.negate();
+  }
+  // Creates a new vertex interpolated between this vertex and another.
+  // All properties (position, normal, UV, color) are interpolated if present on both vertices.
+  // @param other - The target vertex to interpolate towards.
+  // @param interpolationFactor - Factor from 0.0 (this vertex) to 1.0 (other vertex).
+  // @return New interpolated Vertex instance.
+  interpolate(other, interpolationFactor) {
+    return new Vertex2(this.pos.clone().lerp(other.pos, interpolationFactor), this.normal.clone().lerp(other.normal, interpolationFactor), this.uv && other.uv && this.uv.clone().lerp(other.uv, interpolationFactor), this.color && other.color && this.color.clone().lerp(other.color, interpolationFactor));
+  }
+  // === CLEANUP AND DISPOSAL METHODS ===
+  // Clean up vertex data by setting all properties to undefined.
+  // Used for memory management during intensive operations.
+  delete() {
+    this.pos = void 0;
+    this.normal = void 0;
+    this.uv && (this.uv = void 0);
+    return this.color && (this.color = void 0);
+  }
+};
+var _export_toGeometry = Polytree.toGeometry;
+var _export_toMesh = Polytree.toMesh;
+var _export_fromMesh = Polytree.fromMesh;
+var _export_getSurface = Polytree.getSurface;
+var _export_getVolume = Polytree.getVolume;
+var _export_closestPointToPoint = Polytree.closestPointToPoint;
+var _export_distanceToPoint = Polytree.distanceToPoint;
+var _export_intersectsSphere = Polytree.intersectsSphere;
+var _export_intersectsBox = Polytree.intersectsBox;
+var _export_intersectPlane = Polytree.intersectPlane;
+var _export_sliceIntoLayers = Polytree.sliceIntoLayers;
+var _export_shapecast = Polytree.shapecast;
+var _export_getTrianglesNearPoint = Polytree.getTrianglesNearPoint;
+var _export_estimateVolumeViaSampling = Polytree.estimateVolumeViaSampling;
+var polytree_bundle_browser_default = Polytree;
+export {
+  ASYNC_OPERATION_TIMEOUT,
+  DEBUG_COLOR_BACK,
+  DEBUG_COLOR_COPLANAR,
+  DEBUG_COLOR_FRONT,
+  DEBUG_COLOR_SPANNING,
+  DEBUG_GEOMETRY_VALIDATION,
+  DEBUG_INTERSECTION_VERIFICATION,
+  DEBUG_PERFORMANCE_TIMING,
+  DEBUG_VERBOSE_LOGGING,
+  DEFAULT_BUFFER_SIZE,
+  DEFAULT_COORDINATE_PRECISION,
+  DEFAULT_MATERIAL_INDEX,
+  GARBAGE_COLLECTION_THRESHOLD,
+  GEOMETRIC_EPSILON,
+  GEOMETRY_CACHE_SIZE,
+  INTERSECTION_CACHE_SIZE,
+  MAX_REFINEMENT_ITERATIONS,
+  MAX_WORKER_THREADS,
+  MEMORY_USAGE_WARNING_LIMIT,
+  POINT_COINCIDENCE_THRESHOLD,
+  POLYGON_BACK,
+  POLYGON_COPLANAR,
+  POLYGON_FRONT,
+  POLYGON_SPANNING,
+  POLYTREE_MAX_DEPTH,
+  POLYTREE_MAX_POLYGONS_PER_NODE,
+  POLYTREE_MIN_NODE_SIZE,
+  Plane,
+  Polygon,
+  Polytree,
+  RAY_INTERSECTION_EPSILON,
+  TRIANGLE_2D_EPSILON,
+  Vertex,
+  WINDING_NUMBER_FULL_ROTATION,
+  calculateWindingNumberFromBuffer,
+  _export_closestPointToPoint as closestPointToPoint,
+  constructIntersection,
+  createVector2Buffer,
+  createVector3Buffer,
+  polytree_bundle_browser_default as default,
+  defaultRayDirection,
+  disposePolytreeResources,
+  _export_distanceToPoint as distanceToPoint,
+  _export_estimateVolumeViaSampling as estimateVolumeViaSampling,
+  extractCoordinatesFromArray,
+  _export_fromMesh as fromMesh,
+  _export_getSurface as getSurface,
+  _export_getTrianglesNearPoint as getTrianglesNearPoint,
+  _export_getVolume as getVolume,
+  handleIntersectingPolytrees,
+  _export_intersectPlane as intersectPlane,
+  intersectionTestEdge2D,
+  intersectionTestVertex2D,
+  _export_intersectsBox as intersectsBox,
+  _export_intersectsSphere as intersectsSphere,
+  isUniqueTriangle,
+  isValidTriangle,
+  meshOperationNormalVector,
+  meshOperationVertexVector,
+  polygonID,
+  prepareTriangleBufferFromPolygons,
+  testRayTriangleIntersection as rayIntersectsTriangle,
+  rayTriangleEdge1,
+  rayTriangleEdge2,
+  rayTriangleHVector,
+  rayTriangleQVector,
+  rayTriangleSVector,
+  resolveCoplanarTriangleIntersection,
+  resolveTriangleIntersection,
+  roundPointCoordinates,
+  _export_shapecast as shapecast,
+  signedVolumeOfTriangle,
+  _export_sliceIntoLayers as sliceIntoLayers,
+  sortRaycastIntersectionsByDistance,
+  splitPolygonByPlane,
+  splitPolygonVertexArray,
+  temporaryBoundingBox,
+  temporaryMatrix3,
+  temporaryMatrixWithNormalCalc,
+  temporaryRay,
+  temporaryRaycaster,
+  temporaryTriangleVertex,
+  temporaryTriangleVertexSecondary,
+  temporaryVector3Primary,
+  temporaryVector3Quaternary,
+  temporaryVector3Secondary,
+  temporaryVector3Tertiary,
+  testPolygonInsideUsingWindingNumber,
+  testRayTriangleIntersection,
+  _export_toGeometry as toGeometry,
+  _export_toMesh as toMesh,
+  triangleIntersectionCCW2D,
+  triangleIntersectsTriangle,
+  triangleOrientation2D,
+  trianglesOverlap2D,
+  windingNumberEpsilonOffsets,
+  windingNumberEpsilonOffsetsCount,
+  windingNumberMatrix3,
+  windingNumberTestPoint,
+  windingNumberVector1,
+  windingNumberVector2,
+  windingNumberVector3
+};