@jgphilpott/polytree 0.0.6 → 0.0.8

package/polytree.bundle.js

@@ -0,0 +1,3653 @@
+// Generated by CoffeeScript 2.7.0
+var Box3, BufferAttribute, BufferGeometry, DoubleSide, Matrix3, Mesh, Ray, Raycaster, Triangle, Vector2, Vector3;
+
+({Vector2, Vector3, Mesh, Triangle, Box3, Matrix3, DoubleSide, Ray, Raycaster, BufferGeometry, BufferAttribute} = require("three"));
+// Generated by CoffeeScript 2.7.0
+var BACK, COPLANAR, CSG_Rules, EPSILON, FRONT, Plane, Polygon, Polytree, RAY_EPSILON, SPANNING, Vertex, _asyncUnionArrayID, _asyncUnionID, _matrix3, _normal1, _polygonID, _wP, _wP_EPS_ARR, _wP_EPS_ARR_COUNT, _wV1, _wV2, _wV3, calcWindingNumber_buffer, disposePolytree, edge1, edge2, h, handleIntersectingPolytrees, handleObjectForOp, handleObjectForOp_async, isUniqueTriangle, isValidTriangle, nbuf2, nbuf3, pointRounding, polyInside_WindingNumber_buffer, prepareTriangleBuffer, q, rayIntersectsTriangle, raycastIntersectAscSort, returnXYZ, s, splitPolygonArr, splitPolygonByPlane, tempBox3, tempRay, tempRayDirection, tempRaycaster, tempVector1, tempVector2, tmpm3, triangleVertex0, triangleVertex1, ttvv0, wNPI;
+
+tempVector1 = new Vector3();
+
+tempVector2 = new Vector3();
+
+tempBox3 = new Box3();
+
+triangleVertex0 = new Vector3();
+
+triangleVertex1 = new Vector3();
+
+tempRaycaster = new Raycaster();
+
+tempRay = new Ray();
+
+tempRayDirection = new Vector3(0, 0, 1);
+
+EPSILON = 1e-5;
+
+COPLANAR = 0;
+
+FRONT = 1;
+
+BACK = 2;
+
+SPANNING = 3;
+
+_polygonID = 0;
+
+Polytree = class Polytree {
+  constructor(box, parent) {
+    this.polygons = [];
+    this.replacedPolygons = [];
+    this.mesh;
+    this.originalMatrixWorld;
+    this.box = box;
+    this.subTrees = [];
+    this.parent = parent;
+    this.level = 0;
+    this.polygonArrays = void 0;
+    // @isPolytree = true
+    this.addPolygonsArrayToRoot(this.polygons);
+  }
+
+  clone() {
+    return (new this.constructor()).copy(this);
+  }
+
+  copy(source) {
+    var i, k, ref, subTree;
+    this.deletePolygonsArrayFromRoot(this.polygons);
+    this.polygons = source.polygons.map(function(p) {
+      return p.clone();
+    });
+    this.addPolygonsArrayToRoot(this.polygons);
+    this.replacedPolygons = source.replacedPolygons.map(function(p) {
+      return p.clone();
+    });
+    if (source.mesh) {
+      this.mesh = source.mesh;
+    }
+    if (source.originalMatrixWorld) {
+      this.originalMatrixWorld = source.originalMatrixWorld.clone();
+    }
+    this.box = source.box.clone();
+    this.level = source.level;
+    for (i = k = 0, ref = source.subTrees.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+      subTree = new this.constructor(void 0, this).copy(source.subTrees[i]);
+      this.subTrees.push(subTree);
+    }
+    return this;
+  }
+
+  addPolygonsArrayToRoot(array) {
+    if (this.parent) {
+      return this.parent.addPolygonsArrayToRoot(array);
+    } else {
+      if (this.polygonArrays === void 0) {
+        this.polygonArrays = [];
+      }
+      return this.polygonArrays.push(array);
+    }
+  }
+
+  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);
+      }
+    }
+  }
+
+  isEmpty() {
+    return this.polygons.length === 0;
+  }
+
+  addPolygon(polygon, trianglesSet) {
+    var triangle;
+    if (!this.bounds) {
+      this.bounds = new Box3();
+    }
+    triangle = polygon.triangle;
+    if (trianglesSet && !isUniqueTriangle(triangle, trianglesSet)) {
+      return this;
+    }
+    this.bounds.min.x = Math.min(this.bounds.min.x, triangle.a.x, triangle.b.x, triangle.c.x);
+    this.bounds.min.y = Math.min(this.bounds.min.y, triangle.a.y, triangle.b.y, triangle.c.y);
+    this.bounds.min.z = Math.min(this.bounds.min.z, triangle.a.z, triangle.b.z, triangle.c.z);
+    this.bounds.max.x = Math.max(this.bounds.max.x, triangle.a.x, triangle.b.x, triangle.c.x);
+    this.bounds.max.y = Math.max(this.bounds.max.y, triangle.a.y, triangle.b.y, triangle.c.y);
+    this.bounds.max.z = Math.max(this.bounds.max.z, triangle.a.z, triangle.b.z, triangle.c.z);
+    this.polygons.push(polygon);
+    return this;
+  }
+
+  calcBox() {
+    if (!this.bounds) {
+      this.bounds = new Box3();
+    }
+    this.box = this.bounds.clone();
+    // offset small ammount to account for regular grid
+    this.box.min.x -= 0.01;
+    this.box.min.y -= 0.01;
+    this.box.min.z -= 0.01;
+    return this;
+  }
+
+  newPolytree(box, parent) {
+    return new this.constructor(box, parent);
+  }
+
+  split(level) {
+    var box, found, halfsize, i, k, l, len, m, n, o, polygon, ref, ref1, subTrees, vectorPosition, x, y, z;
+    if (!this.box) {
+      return;
+    }
+    subTrees = [];
+    halfsize = tempVector2.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 = tempVector1.set(x, y, z);
+          box.min.copy(this.box.min).add(vectorPosition.multiply(halfsize));
+          box.max.copy(box.min).add(halfsize);
+          box.expandByScalar(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) {
+        console.error("ERROR: unable to find subtree for:", polygon.triangle);
+        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;
+      // if (len !== 0) {
+      if (len > Polytree.polygonsPerTree && level < Polytree.maxLevel) {
+        subTrees[i].split(level + 1);
+      }
+      this.subTrees.push(subTrees[i]);
+    }
+    // }
+    return this;
+  }
+
+  buildTree() {
+    this.calcBox();
+    this.split(0);
+    this.processTree();
+    return this;
+  }
+
+  processTree() {
+    var i, k, l, ref, ref1, results1;
+    if (!this.isEmpty()) {
+      tempBox3.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();
+    }
+    results1 = [];
+    for (i = l = 0, ref1 = this.subTrees.length; (0 <= ref1 ? l < ref1 : l > ref1); i = 0 <= ref1 ? ++l : --l) {
+      results1.push(this.subTrees[i].processTree());
+    }
+    return results1;
+  }
+
+  expandParentBox() {
+    if (this.parent) {
+      this.parent.box.expandByPoint(this.box.min);
+      this.parent.box.expandByPoint(this.box.max);
+      return this.parent.expandParentBox();
+    }
+  }
+
+  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;
+  }
+
+  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;
+  }
+
+  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 (Polytree.rayIntersectTriangleType === "regular") {
+        result = ray.intersectTriangle(polygons[i].triangle.a, polygons[i].triangle.b, polygons[i].triangle.c, false, tempVector1);
+        if (result) {
+          tempVector1.applyMatrix4(matrixWorld);
+          distance = tempVector1.distanceTo(ray.origin);
+          if (distance < 0 || distance > 2e308) {
+            console.warn("[rayIntersect] Failed ray distance check", ray);
+          } else {
+            intersects.push({
+              distance: distance,
+              polygon: polygons[i],
+              position: tempVector1.clone()
+            });
+          }
+        }
+      } else {
+        result = rayIntersectsTriangle(ray, polygons[i].triangle, tempVector1);
+        if (result) {
+          newdistance = result.clone().sub(ray.origin).length();
+          if (distance > newdistance) {
+            distance = newdistance;
+          }
+          if (distance < 1e100) {
+            intersects.push({
+              distance: distance,
+              polygon: polygons[i],
+              position: result.clone().add(ray.origin)
+            });
+          }
+        }
+      }
+    }
+    intersects.length && intersects.sort(raycastIntersectAscSort);
+    return intersects;
+  }
+
+  getIntersectingPolygons(polygons = []) {
+    this.polygonArrays.forEach(function(polygonsArray) {
+      var i, k, ref, results1;
+      if (polygonsArray.length) {
+        results1 = [];
+        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) {
+            results1.push(polygons.push(polygonsArray[i]));
+          } else {
+            results1.push(void 0);
+          }
+        }
+        return results1;
+      }
+    });
+    // if (@polygons.length)
+    //     for i in [0...@polygons.length]
+    //         if @polygons[i].valid and @polygons[i].intersects
+    //             polygons.push(@polygons[i])
+    // for i in [0...@subTrees.length]
+    //     @subTrees[i].getIntersectingPolygons(polygons)
+    return polygons;
+  }
+
+  getPolygons(polygons = []) {
+    this.polygonArrays.forEach(function(polygonsArray) {
+      var i, k, ref, results1;
+      if (polygonsArray.length) {
+        results1 = [];
+        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) {
+              results1.push(polygons.push(polygonsArray[i]));
+            } else {
+              results1.push(void 0);
+            }
+          } else {
+            results1.push(void 0);
+          }
+        }
+        return results1;
+      }
+    });
+    // if @polygons.length > 0
+    //     for i in [0...@polygons.length]
+    //         if @polygons[i].valid
+    //             if polygons.indexOf(@polygons[i]) is -1
+    //                 polygons.push(@polygons[i])
+    // for i in [0...@subTrees.length]
+    //     @subTrees[i].getPolygons(polygons)
+    return polygons;
+  }
+
+  invert() {
+    return this.polygonArrays.forEach(function(polygonsArray) {
+      if (polygonsArray.length) {
+        return polygonsArray.forEach(function(p) {
+          return p.flip();
+        });
+      }
+    });
+  }
+
+  // if @polygons.length > 0
+  //     @polygons.forEach (p) -> p.flip()
+  // for i in [0...@subTrees.length]
+  //     @subTrees[i].invert()
+  getMesh() {
+    if (this.parent) {
+      return this.parent.getMesh();
+    } else {
+      return this.mesh;
+    }
+  }
+
+  replacePolygon(polygon, newPolygons) {
+    var i, k, polygonIndex, ref, results1;
+    if (!Array.isArray(newPolygons)) {
+      newPolygons = [newPolygons];
+    }
+    // if @polygons.length > 0
+    //     polygonIndex = @polygons.indexOf(polygon)
+    //     if polygonIndex > -1
+    //         if polygon.originalValid is true
+    //             @replacedPolygons.push(polygon)
+    //         else
+    //             polygon.setInvalid()
+    //         @polygons.splice(polygonIndex, 1, ...newPolygons)
+    // for i in [0...@subTrees.length]
+    //     @subTrees[i].replacePolygon(polygon, 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);
+      }
+    }
+    results1 = [];
+    for (i = k = 0, ref = this.subTrees.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+      results1.push(this.subTrees[i].replacePolygon(polygon, newPolygons));
+    }
+    return results1;
+  }
+
+  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(state) {
+                  return statesObj[state] = false;
+                });
+                states.forEach(function(state) {
+                  return mainStatesObj[state] = 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();
+            }
+          }
+        });
+      }
+    });
+  }
+
+  // if @polygons.length > 0
+  //     polygonArr = @polygons.filter (polygon) -> (polygon.valid == true) and (polygon.intersects == true)
+  //     polygonArr.forEach (polygon) ->
+  //         found = false
+  //         for j in [0...rulesArr.length]
+  //             if rulesArr[j].array
+  //                 states = rulesArr[j].rule
+  //                 if (states.includes(polygon.state)) and (((polygon.previousState isnt "undecided") and (states.includes(polygon.previousState))) or (polygon.previousState is "undecided"))
+  //                     found = true
+  //                     statesObj = {}
+  //                     mainStatesObj = {}
+  //                     states.forEach (state) -> statesObj[state] = false
+  //                     states.forEach (state) -> mainStatesObj[state] = false
+  //                     statesObj[polygon.state] = true
+  //                     for i in [0...polygon.previousStates.length]
+  //                         unless states.includes(polygon.previousStates[i])
+  //                             found = false
+  //                             break
+  //                         else
+  //                             statesObj[polygon.previousStates[i]] = true
+  //                     if found
+  //                         for state of statesObj
+  //                             if statesObj[state] is false
+  //                                 found = false
+  //                                 break
+  //                         if found
+  //                             break
+  //             else
+  //                 if polygon.checkAllStates(rulesArr[j].rule)
+  //                     found = true
+  //                     break
+  //         if found
+  //             polygonIndex = @polygons.indexOf(polygon)
+  //             if polygonIndex > -1
+  //                 polygon.setInvalid()
+  //                 @polygons.splice(polygonIndex, 1)
+  //             if firstRun
+  //                 polygon.delete()
+  // for i in [0...@subTrees.length]
+  //     @subTrees[i].deletePolygonsByStateRules(rulesArr, false)
+  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();
+              }
+            }
+          }
+        });
+      }
+    });
+  }
+
+  // if @polygons.length > 0
+  //     polygonArr = @polygons.slice()
+  //     polygonArr.forEach (polygon) ->
+  //         if polygon.valid
+  //             if polygon.intersects == intersects
+  //                 polygonIndex = @polygons.indexOf(polygon)
+  //                 if polygonIndex > -1
+  //                     polygon.setInvalid()
+  //                     @polygons.splice(polygonIndex, 1)
+  //                 if firstRun
+  //                     polygon.delete()
+  // for i in [0...@subTrees.length]
+  //     @subTrees[i].deletePolygonsByIntersection(intersects, false)
+  isPolygonIntersecting(polygon) {
+    if (!this.box.intersectsTriangle(polygon.triangle)) {
+      return false;
+    }
+    return true;
+  }
+
+  markIntesectingPolygons(targetPolytree) {
+    return this.polygonArrays.forEach(function(polygonsArray) {
+      if (polygonsArray.length) {
+        return polygonsArray.forEach(function(polygon) {
+          return polygon.intersects = targetPolytree.isPolygonIntersecting(polygon);
+        });
+      }
+    });
+  }
+
+  // if @polygons.length > 0
+  //     @polygons.forEach (polygon) ->
+  //         polygon.intersects = targetPolytree.isPolygonIntersecting(polygon)
+  // for i in [0...@subTrees.length]
+  //     @subTrees[i].markIntesectingPolygons(targetPolytree)
+  resetPolygons(resetOriginal = true) {
+    return this.polygonArrays.forEach(function(polygonsArray) {
+      if (polygonsArray.length) {
+        return polygonsArray.forEach(function(polygon) {
+          return polygon.reset(resetOriginal);
+        });
+      }
+    });
+  }
+
+  // if @polygons.length > 0
+  //     @polygons.forEach (polygon) ->
+  //         polygon.reset(resetOriginal)
+  // for i in [0...@subTrees.length]
+  //     @subTrees[i].resetPolygons(resetOriginal)
+  handleIntersectingPolygons(targetPolytree, targetPolytreeBuffer) {
+    var currentPolygon, i, inside, intersects, j, k, l, m, n, o, point, polygon, polygonStack, ref, ref1, ref2, ref3, ref4, results1, splitResults, target, targetPolygons;
+    // if @polygons.length > 0
+    //     polygonStack = @polygons.filter (polygon) -> (polygon.valid == true) and (polygon.intersects == true) and (polygon.state == "undecided")
+    //     currentPolygon = polygonStack.pop()
+    //     while currentPolygon
+    //         if currentPolygon.state isnt "undecided"
+    //             continue
+    //         unless currentPolygon.valid
+    //             continue
+    //         targetPolygons = targetPolytree.getPolygonsIntersectingPolygon(currentPolygon)
+    //         if targetPolygons.length > 0
+    //             for j in [0...targetPolygons.length]
+    //                 target = targetPolygons[j]
+    //                 splitResults = splitPolygonByPlane(currentPolygon, target.plane)
+    //                 if splitResults.length > 1
+    //                     for i in [0...splitResults.length]
+    //                         polygon = splitResults[i].polygon
+    //                         polygon.intersects = currentPolygon.intersects
+    //                         polygon.newPolygon = true
+    //                         polygonStack.push(polygon)
+    //                     @replacePolygon(currentPolygon, splitResults.map((result) -> result.polygon))
+    //                     break
+    //                 else
+    //                     if currentPolygon.id isnt splitResults[0].polygon.id
+    //                         splitResults[0].polygon.intersects = currentPolygon.intersects
+    //                         splitResults[0].polygon.newPolygon = true
+    //                         polygonStack.push(splitResults[0].polygon)
+    //                         @replacePolygon(currentPolygon, splitResults[0].polygon)
+    //                         break
+    //                     else
+    //                         if (splitResults[0].type == "coplanar-front") or (splitResults[0].type == "coplanar-back")
+    //                             currentPolygon.setState(splitResults[0].type)
+    //                             currentPolygon.coplanar = true
+    //         currentPolygon = polygonStack.pop()
+    //     polygonStack = @polygons.filter (polygon) -> (polygon.valid == true) and (polygon.intersects == true)
+    //     currentPolygon = polygonStack.pop()
+    //     inside = false
+    //     while currentPolygon
+    //         unless currentPolygon.valid
+    //             continue
+    //         inside = false
+    //         if targetPolytree.box.containsPoint(currentPolygon.getMidpoint())
+    //             if Polytree.useWindingNumber is true
+    //                 inside = polyInside_WindingNumber_buffer(targetPolytreeBuffer, currentPolygon.getMidpoint(), currentPolygon.coplanar)
+    //             else
+    //                 point = pointRounding(tempVector2.copy(currentPolygon.getMidpoint()))
+    //                 if Polytree.usePolytreeRay isnt true and targetPolytree.mesh
+    //                     tempRayDirection.copy(currentPolygon.plane.normal)
+    //                     tempRaycaster.set(point, tempRayDirection)
+    //                     intersects = tempRaycaster.intersectObject(targetPolytree.mesh)
+    //                     if intersects.length
+    //                         if tempRayDirection.dot(intersects[0].face.normal) > 0
+    //                             inside = true
+    //                     unless inside or not currentPolygon.coplanar
+    //                         for j in [0..._wP_EPS_ARR_COUNT]
+    //                             tempRaycaster.ray.origin.copy(point).add(_wP_EPS_ARR[j])
+    //                             intersects = tempRaycaster.intersectObject(targetPolytree.mesh)
+    //                             if intersects.length
+    //                                 if tempRayDirection.dot(intersects[0].face.normal) > 0
+    //                                     inside = true
+    //                                     break
+    //                 else
+    //                     tempRay.origin.copy(point)
+    //                     tempRayDirection.copy(currentPolygon.plane.normal)
+    //                     tempRay.direction.copy(currentPolygon.plane.normal)
+    //                     intersects = targetPolytree.rayIntersect(tempRay, targetPolytree.originalMatrixWorld)
+    //                     if intersects.length
+    //                         if tempRayDirection.dot(intersects[0].polygon.plane.normal) > 0
+    //                             inside = true
+    //                     unless inside or not currentPolygon.coplanar
+    //                         for j in [0..._wP_EPS_ARR_COUNT]
+    //                             tempRay.origin.copy(point).add(_wP_EPS_ARR[j])
+    //                             tempRayDirection.copy(currentPolygon.plane.normal)
+    //                             tempRay.direction.copy(currentPolygon.plane.normal)
+    //                             intersects = targetPolytree.rayIntersect(tempRay, targetPolytree.originalMatrixWorld)
+    //                             if intersects.length
+    //                                 if tempRayDirection.dot(intersects[0].polygon.plane.normal) > 0
+    //                                     inside = true
+    //                                     break
+    //         if inside is true
+    //             currentPolygon.setState("inside")
+    //         else
+    //             currentPolygon.setState("outside")
+    //         currentPolygon = polygonStack.pop()
+    // for i in [0...@subTrees.length]
+    //     @subTrees[i].handleIntersectingPolygons(targetPolytree, targetPolytreeBuffer)
+    if (this.polygons.length > 0) {
+      polygonStack = this.polygons.filter(function(polygon) {
+        return (polygon.valid === true) && (polygon.intersects === true) && (polygon.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(polygon) {
+        return (polygon.valid === true) && (polygon.intersects === true);
+      });
+      currentPolygon = polygonStack.pop();
+      inside = false;
+      while (currentPolygon) {
+        if (!currentPolygon.valid) {
+          continue;
+        }
+        inside = false;
+        if (targetPolytree.box.containsPoint(currentPolygon.getMidpoint())) {
+          if (Polytree.useWindingNumber === true) {
+            inside = polyInside_WindingNumber_buffer(targetPolytreeBuffer, currentPolygon.getMidpoint(), currentPolygon.coplanar);
+          } else {
+            point = pointRounding(tempVector2.copy(currentPolygon.getMidpoint()));
+            if (Polytree.usePolytreeRay !== true && targetPolytree.mesh) {
+              tempRayDirection.copy(currentPolygon.plane.normal);
+              tempRaycaster.set(point, tempRayDirection);
+              intersects = tempRaycaster.intersectObject(targetPolytree.mesh);
+              if (intersects.length) {
+                if (tempRayDirection.dot(intersects[0].face.normal) > 0) {
+                  inside = true;
+                }
+              }
+              if (!(inside || !currentPolygon.coplanar)) {
+                for (j = m = 0, ref2 = _wP_EPS_ARR_COUNT; (0 <= ref2 ? m < ref2 : m > ref2); j = 0 <= ref2 ? ++m : --m) {
+                  tempRaycaster.ray.origin.copy(point).add(_wP_EPS_ARR[j]);
+                  intersects = tempRaycaster.intersectObject(targetPolytree.mesh);
+                  if (intersects.length) {
+                    if (tempRayDirection.dot(intersects[0].face.normal) > 0) {
+                      inside = true;
+                      break;
+                    }
+                  }
+                }
+              }
+            } else {
+              tempRay.origin.copy(point);
+              tempRayDirection.copy(currentPolygon.plane.normal);
+              tempRay.direction.copy(currentPolygon.plane.normal);
+              intersects = targetPolytree.rayIntersect(tempRay, targetPolytree.originalMatrixWorld);
+              if (intersects.length) {
+                if (tempRayDirection.dot(intersects[0].polygon.plane.normal) > 0) {
+                  inside = true;
+                }
+              }
+              if (!(inside || !currentPolygon.coplanar)) {
+                for (j = n = 0, ref3 = _wP_EPS_ARR_COUNT; (0 <= ref3 ? n < ref3 : n > ref3); j = 0 <= ref3 ? ++n : --n) {
+                  tempRay.origin.copy(point).add(_wP_EPS_ARR[j]);
+                  tempRayDirection.copy(currentPolygon.plane.normal);
+                  tempRay.direction.copy(currentPolygon.plane.normal);
+                  intersects = targetPolytree.rayIntersect(tempRay, targetPolytree.originalMatrixWorld);
+                  if (intersects.length) {
+                    if (tempRayDirection.dot(intersects[0].polygon.plane.normal) > 0) {
+                      inside = true;
+                      break;
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+        if (inside === true) {
+          currentPolygon.setState("inside");
+        } else {
+          currentPolygon.setState("outside");
+        }
+        currentPolygon = polygonStack.pop();
+      }
+    }
+    results1 = [];
+    for (i = o = 0, ref4 = this.subTrees.length; (0 <= ref4 ? o < ref4 : o > ref4); i = 0 <= ref4 ? ++o : --o) {
+      results1.push(this.subTrees[i].handleIntersectingPolygons(targetPolytree, targetPolytreeBuffer));
+    }
+    return results1;
+  }
+
+  delete(deletePolygons = true) {
+    var i, k, ref;
+    if (this.polygons.length > 0 && deletePolygons) {
+      this.polygons.forEach(function(p) {
+        return p.delete();
+      });
+      this.polygons.length = 0;
+    }
+    if (this.replacedPolygons.length > 0 && deletePolygons) {
+      this.replacedPolygons.forEach(function(p) {
+        return p.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(deletePolygons = true) {
+    return this.delete(deletePolygons);
+  }
+
+  getPolygonCloneCallback(cbFunc, trianglesSet) {
+    return this.polygonArrays.forEach(function(polygonsArray) {
+      var i, k, ref, results1;
+      if (polygonsArray.length) {
+        results1 = [];
+        for (i = k = 0, ref = polygonsArray.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+          if (polygonsArray[i].valid) {
+            results1.push(cbFunc(polygonsArray[i].clone(), trianglesSet));
+          } else {
+            results1.push(void 0);
+          }
+        }
+        return results1;
+      }
+    });
+  }
+
+  // if @polygons.length > 0
+  //     for i in [0...@polygons.length]
+  //         if @polygons[i].valid
+  //             cbFunc(@polygons[i].clone(), trianglesSet)
+  // for i in [0...@subTrees.length]
+  //     @subTrees[i].getPolygonCloneCallback(cbFunc, trianglesSet)
+  deleteReplacedPolygons() {
+    var i, k, ref, results1;
+    if (this.replacedPolygons.length > 0) {
+      this.replacedPolygons.forEach(function(p) {
+        return p.delete();
+      });
+      this.replacedPolygons.length = 0;
+    }
+    results1 = [];
+    for (i = k = 0, ref = this.subTrees.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+      results1.push(this.subTrees[i].deleteReplacedPolygons());
+    }
+    return results1;
+  }
+
+  markPolygonsAsOriginal() {
+    return this.polygonArrays.forEach(function(polygonsArray) {
+      if (polygonsArray.length) {
+        return polygonsArray.forEach(function(p) {
+          return p.originalValid = true;
+        });
+      }
+    });
+  }
+
+  // if @polygons.length > 0
+  //     @polygons.forEach (p) -> p.originalValid = true
+  // for i in [0...@subTrees.length]
+  //     @subTrees[i].markPolygonsAsOriginal()
+  applyMatrix(matrix, normalMatrix, firstRun = true) {
+    var i, k, l, ref, ref1;
+    if (matrix.isMesh) {
+      matrix.updateMatrix();
+      matrix = matrix.matrix;
+    }
+    this.box.makeEmpty();
+    normalMatrix = normalMatrix || tmpm3.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();
+    }
+  }
+
+  setPolygonIndex(index) {
+    if (index === void 0) {
+      return;
+    }
+    return this.polygonArrays.forEach(function(polygonsArray) {
+      if (polygonsArray.length) {
+        return polygonsArray.forEach(function(p) {
+          return p.shared = index;
+        });
+      }
+    });
+  }
+
+};
+
+// if @polygons.length > 0
+//     @polygons.forEach (p) -> p.shared = index
+// for i in [0...@subTrees.length]
+//     @subTrees[i].setPolygonIndex(index)
+Polytree.prototype.isPolytree = true;
+
+raycastIntersectAscSort = function(a, b) {
+  return a.distance - b.distance;
+};
+
+pointRounding = function(point, num = 15) {
+  point.x = +point.x.toFixed(num);
+  point.y = +point.y.toFixed(num);
+  point.z = +point.z.toFixed(num);
+  return point;
+};
+
+splitPolygonByPlane = function(polygon, plane, result = []) {
+  var backVertices, currentType, currentVertex, distanceToPlane, frontVertices, i, intersectionParameter, k, l, m, n, newPolygons, nextIndex, nextType, nextVertex, polygonIndex, polygonType, ref, ref1, ref2, ref3, returnPolygon, type, types, vertexParameter;
+  returnPolygon = {
+    polygon: polygon,
+    type: "undecided"
+  };
+  polygonType = 0;
+  types = [];
+  for (i = k = 0, ref = polygon.vertices.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+    distanceToPlane = plane.normal.dot(polygon.vertices[i].pos) - plane.w;
+    type = distanceToPlane < -EPSILON ? BACK : distanceToPlane > EPSILON ? FRONT : COPLANAR;
+    polygonType |= type;
+    types.push(type);
+  }
+  switch (polygonType) {
+    case COPLANAR:
+      returnPolygon.type = plane.normal.dot(polygon.plane.normal) > 0 ? "coplanar-front" : "coplanar-back";
+      result.push(returnPolygon);
+      break;
+    case FRONT:
+      returnPolygon.type = "front";
+      result.push(returnPolygon);
+      break;
+    case BACK:
+      returnPolygon.type = "back";
+      result.push(returnPolygon);
+      break;
+    case SPANNING:
+      frontVertices = [];
+      backVertices = [];
+      for (i = l = 0, ref1 = polygon.vertices.length; (0 <= ref1 ? l < ref1 : l > ref1); i = 0 <= ref1 ? ++l : --l) {
+        nextIndex = (i + 1) % polygon.vertices.length;
+        currentType = types[i];
+        nextType = types[nextIndex];
+        currentVertex = polygon.vertices[i];
+        nextVertex = polygon.vertices[nextIndex];
+        if (currentType !== BACK) {
+          frontVertices.push(currentVertex);
+        }
+        if (currentType !== FRONT) {
+          backVertices.push(currentType !== BACK ? currentVertex.clone() : currentVertex);
+        }
+        if ((currentType | nextType) === SPANNING) {
+          intersectionParameter = (plane.w - plane.normal.dot(currentVertex.pos)) / plane.normal.dot(triangleVertex0.copy(nextVertex.pos).sub(currentVertex.pos));
+          vertexParameter = currentVertex.interpolate(nextVertex, intersectionParameter);
+          frontVertices.push(vertexParameter);
+          backVertices.push(vertexParameter.clone());
+        }
+      }
+      if (frontVertices.length >= 3) {
+        if (frontVertices.length > 3) {
+          newPolygons = splitPolygonArr(frontVertices);
+          for (polygonIndex = m = 0, ref2 = newPolygons.length; (0 <= ref2 ? m < ref2 : m > ref2); polygonIndex = 0 <= ref2 ? ++m : --m) {
+            result.push({
+              polygon: new Polygon(newPolygons[polygonIndex], polygon.shared),
+              type: "front"
+            });
+          }
+        } else {
+          result.push({
+            polygon: new Polygon(frontVertices, polygon.shared),
+            type: "front"
+          });
+        }
+      }
+      if (backVertices.length >= 3) {
+        if (backVertices.length > 3) {
+          newPolygons = splitPolygonArr(backVertices);
+          for (polygonIndex = n = 0, ref3 = newPolygons.length; (0 <= ref3 ? n < ref3 : n > ref3); polygonIndex = 0 <= ref3 ? ++n : --n) {
+            result.push({
+              polygon: new Polygon(newPolygons[polygonIndex], polygon.shared),
+              type: "back"
+            });
+          }
+        } else {
+          result.push({
+            polygon: new Polygon(backVertices, polygon.shared),
+            type: "back"
+          });
+        }
+      }
+  }
+  if (result.length === 0) {
+    result.push(returnPolygon);
+  }
+  return result;
+};
+
+splitPolygonArr = function(arr) {
+  var j, k, ref, result, resultArr;
+  resultArr = [];
+  if (arr.length > 4) {
+    console.warn("[splitPolygonArr] arr.length > 4", arr.length);
+    for (j = k = 3, ref = arr.length; (3 <= ref ? k <= ref : k >= ref); j = 3 <= ref ? ++k : --k) {
+      result = [];
+      result.push(arr[0].clone());
+      result.push(arr[j - 2].clone());
+      result.push(arr[j - 1].clone());
+      resultArr.push(result);
+    }
+  } else {
+    if (arr[0].pos.distanceTo(arr[2].pos) <= arr[1].pos.distanceTo(arr[3].pos)) {
+      resultArr.push([arr[0].clone(), arr[1].clone(), arr[2].clone()], [arr[0].clone(), arr[2].clone(), arr[3].clone()]);
+    } else {
+      resultArr.push([arr[0].clone(), arr[1].clone(), arr[3].clone()], [arr[1].clone(), arr[2].clone(), arr[3].clone()]);
+    }
+    return resultArr;
+  }
+  return resultArr;
+};
+
+CSG_Rules = {
+  union: {
+    a: [
+      {
+        array: true,
+        rule: ["inside",
+      "coplanar-back"]
+      },
+      {
+        array: false,
+        rule: "inside"
+      }
+    ],
+    b: [
+      {
+        array: true,
+        rule: ["inside",
+      "coplanar-back"]
+      },
+      {
+        array: true,
+        rule: ["inside",
+      "coplanar-front"]
+      },
+      {
+        array: false,
+        rule: "inside"
+      }
+    ]
+  },
+  subtract: {
+    a: [
+      {
+        array: true,
+        rule: ["inside",
+      "coplanar-back"]
+      },
+      {
+        array: true,
+        rule: ["inside",
+      "coplanar-front"]
+      },
+      {
+        array: false,
+        rule: "inside"
+      }
+    ],
+    b: [
+      {
+        array: true,
+        rule: ["outside",
+      "coplanar-back"]
+      },
+      {
+        array: true,
+        rule: ["outside",
+      "coplanar-front"]
+      },
+      {
+        array: true,
+        rule: ["inside",
+      "coplanar-front"]
+      },
+      {
+        array: false,
+        rule: "outside"
+      }
+    ]
+  },
+  intersect: {
+    a: [
+      {
+        array: true,
+        rule: ["inside",
+      "coplanar-back"]
+      },
+      {
+        array: true,
+        rule: ["outside",
+      "coplanar-front"]
+      },
+      {
+        array: true,
+        rule: ["outside",
+      "coplanar-back"]
+      },
+      {
+        array: false,
+        rule: "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"
+      }
+    ]
+  }
+};
+
+// class Polytree { };
+/*
+Union:
+- Combine all polygons from A and B, except:
+    - Polygons in A that are inside B or coplanar-back with B
+    - Polygons in B that are inside A or coplanar-back/front with A
+*/
+/*
+Subtract:
+- Keep polygons from A that are outside B or coplanar-front with B
+- Keep polygons from B that are inside A and coplanar-front with A
+*/
+/*
+Intersect:
+1. Delete all polygons in A that are:
+    a. inside and coplanar-back
+    b. outside and coplanar-front
+    c. outside and coplanar-back
+    d. outside
+2. Delete all polygons in B that are:
+    a. inside and coplanar-front
+    b. inside and coplanar-back
+    c. outside and coplanar-front
+    d. outside and coplanar-back
+    e. outside
+*/
+Polytree.union = function(polytreeA, polytreeB, buildTargetPolytree = true) {
+  var currentMeshSideA, currentMeshSideB, polytree, trianglesSet;
+  polytree = new Polytree();
+  trianglesSet = 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(CSG_Rules.union.a);
+    polytreeB.deletePolygonsByStateRules(CSG_Rules.union.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;
+};
+
+Polytree.subtract = function(polytreeA, polytreeB, buildTargetPolytree = true) {
+  var currentMeshSideA, currentMeshSideB, polytree, trianglesSet;
+  polytree = new Polytree();
+  trianglesSet = 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(CSG_Rules.subtract.a);
+    polytreeB.deletePolygonsByStateRules(CSG_Rules.subtract.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();
+  // polytree.invert()
+  return polytree;
+};
+
+Polytree.intersect = function(polytreeA, polytreeB, buildTargetPolytree = true) {
+  var currentMeshSideA, currentMeshSideB, polytree, trianglesSet;
+  polytree = new Polytree();
+  trianglesSet = 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(CSG_Rules.intersect.a);
+    polytreeB.deletePolygonsByStateRules(CSG_Rules.intersect.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;
+};
+
+CSG_Rules = {
+  union: {
+    a: [
+      {
+        array: true,
+        rule: ["inside",
+      "coplanar-back"]
+      },
+      {
+        array: false,
+        rule: "inside"
+      }
+    ],
+    b: [
+      {
+        array: true,
+        rule: ["inside",
+      "coplanar-back"]
+      },
+      {
+        array: true,
+        rule: ["inside",
+      "coplanar-front"]
+      },
+      {
+        array: false,
+        rule: "inside"
+      }
+    ]
+  },
+  subtract: {
+    a: [
+      {
+        array: true,
+        rule: ["inside",
+      "coplanar-back"]
+      },
+      {
+        array: true,
+        rule: ["inside",
+      "coplanar-front"]
+      },
+      {
+        array: false,
+        rule: "inside"
+      }
+    ],
+    b: [
+      {
+        array: true,
+        rule: ["outside",
+      "coplanar-back"]
+      },
+      {
+        array: true,
+        rule: ["outside",
+      "coplanar-front"]
+      },
+      {
+        array: true,
+        rule: ["inside",
+      "coplanar-front"]
+      },
+      {
+        array: false,
+        rule: "outside"
+      }
+    ]
+  },
+  intersect: {
+    a: [
+      {
+        array: true,
+        rule: ["inside",
+      "coplanar-back"]
+      },
+      {
+        array: true,
+        rule: ["outside",
+      "coplanar-front"]
+      },
+      {
+        array: true,
+        rule: ["outside",
+      "coplanar-back"]
+      },
+      {
+        array: false,
+        rule: "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"
+      }
+    ]
+  }
+};
+
+// class Polytree { };
+/*
+Union:
+- Combine all polygons from A and B, except:
+    - Polygons in A that are inside B or coplanar-back with B
+    - Polygons in B that are inside A or coplanar-back/front with A
+*/
+/*
+Subtract:
+- Keep polygons from A that are outside B or coplanar-front with B
+- Keep polygons from B that are inside A and coplanar-front with A
+*/
+/*
+Intersect:
+1. Delete all polygons in A that are:
+    a. inside and coplanar-back
+    b. outside and coplanar-front
+    c. outside and coplanar-back
+    d. outside
+2. Delete all polygons in B that are:
+    a. inside and coplanar-front
+    b. inside and coplanar-back
+    c. outside and coplanar-front
+    d. outside and coplanar-back
+    e. outside
+*/
+Polytree.union = function(polytreeA, polytreeB, buildTargetPolytree = true) {
+  var currentMeshSideA, currentMeshSideB, polytree, trianglesSet;
+  polytree = new Polytree();
+  trianglesSet = 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(CSG_Rules.union.a);
+    polytreeB.deletePolygonsByStateRules(CSG_Rules.union.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;
+};
+
+Polytree.subtract = function(polytreeA, polytreeB, buildTargetPolytree = true) {
+  var currentMeshSideA, currentMeshSideB, polytree, trianglesSet;
+  polytree = new Polytree();
+  trianglesSet = 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(CSG_Rules.subtract.a);
+    polytreeB.deletePolygonsByStateRules(CSG_Rules.subtract.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();
+  // polytree.invert()
+  return polytree;
+};
+
+/*
+Intersect:
+1. Delete all polygons in A that are:
+        a. inside and coplanar-back
+        b. outside and coplanar-front
+        c. outside and coplanar-back
+        d. outside
+2. Delete all polygons in B that are:
+        a. inside and coplanar-front
+        b. inside and coplanar-back
+        c. outside and coplanar-front
+        d. outside and coplanar-back
+        e. outside
+*/
+Polytree.intersect = function(polytreeA, polytreeB, buildTargetPolytree = true) {
+  var currentMeshSideA, currentMeshSideB, polytree, trianglesSet;
+  polytree = new Polytree();
+  trianglesSet = 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(CSG_Rules.intersect.a);
+    polytreeB.deletePolygonsByStateRules(CSG_Rules.intersect.b);
+    polytreeA.deletePolygonsByIntersection(false);
+    polytreeB.deletePolygonsByIntersection(false);
+    polytreeA.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    polytreeB.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    if (polytreeA.mesh) {
+      if (polytreeA.mesh.material.side !== currentMeshSideA) {
+        polytreeA.mesh.material.side = currentMeshSideA;
+      }
+    }
+    if (polytreeB.mesh) {
+      if (polytreeB.mesh.material.side !== currentMeshSideB) {
+        polytreeB.mesh.material.side = currentMeshSideB;
+      }
+    }
+  }
+  trianglesSet.clear();
+  trianglesSet = void 0;
+  polytree.markPolygonsAsOriginal();
+  buildTargetPolytree && polytree.buildTree();
+  return polytree;
+};
+
+Polytree.meshUnion = function(mesh1, mesh2, targetMaterial) {
+  var polytreeA, polytreeB, resultMesh, resultPolytree;
+  polytreeA = void 0;
+  polytreeB = void 0;
+  if (targetMaterial && Array.isArray(targetMaterial)) {
+    polytreeA = Polytree.fromMesh(mesh1, 0);
+    polytreeB = Polytree.fromMesh(mesh2, 1);
+  } else {
+    polytreeA = Polytree.fromMesh(mesh1);
+    polytreeB = Polytree.fromMesh(mesh2);
+    targetMaterial = targetMaterial !== void 0 ? targetMaterial : (Array.isArray(mesh1.material) ? mesh1.material[0] : mesh1.material).clone();
+  }
+  resultPolytree = Polytree.union(polytreeA, polytreeB, false);
+  resultMesh = Polytree.toMesh(resultPolytree, targetMaterial);
+  disposePolytree(polytreeA, polytreeB, resultPolytree);
+  return resultMesh;
+};
+
+Polytree.meshSubtract = function(mesh1, mesh2, targetMaterial) {
+  var polytreeA, polytreeB, resultMesh, resultPolytree;
+  polytreeA = void 0;
+  polytreeB = void 0;
+  if (targetMaterial && Array.isArray(targetMaterial)) {
+    polytreeA = Polytree.fromMesh(mesh1, 0);
+    polytreeB = Polytree.fromMesh(mesh2, 1);
+  } else {
+    polytreeA = Polytree.fromMesh(mesh1);
+    polytreeB = Polytree.fromMesh(mesh2);
+    targetMaterial = targetMaterial !== void 0 ? targetMaterial : (Array.isArray(mesh1.material) ? mesh1.material[0] : mesh1.material).clone();
+  }
+  resultPolytree = Polytree.subtract(polytreeA, polytreeB, false);
+  resultMesh = Polytree.toMesh(resultPolytree, targetMaterial);
+  disposePolytree(polytreeA, polytreeB, resultPolytree);
+  return resultMesh;
+};
+
+Polytree.meshIntersect = function(mesh1, mesh2, targetMaterial) {
+  var polytreeA, polytreeB, resultMesh, resultPolytree;
+  polytreeA = void 0;
+  polytreeB = void 0;
+  if (targetMaterial && Array.isArray(targetMaterial)) {
+    polytreeA = Polytree.fromMesh(mesh1, 0);
+    polytreeB = Polytree.fromMesh(mesh2, 1);
+  } else {
+    polytreeA = Polytree.fromMesh(mesh1);
+    polytreeB = Polytree.fromMesh(mesh2);
+    targetMaterial = targetMaterial !== void 0 ? targetMaterial : (Array.isArray(mesh1.material) ? mesh1.material[0] : mesh1.material).clone();
+  }
+  resultPolytree = Polytree.intersect(polytreeA, polytreeB, false);
+  resultMesh = Polytree.toMesh(resultPolytree, targetMaterial);
+  disposePolytree(polytreeA, polytreeB, resultPolytree);
+  return resultMesh;
+};
+
+_asyncUnionID = 0;
+
+_asyncUnionArrayID = 0;
+
+Polytree.disposePolytree = true;
+
+Polytree.async = {
+  batchSize: 100,
+  union: function(polytreeA, polytreeB, buildTargetPolytree = true) {
+    return new Promise(function(resolve, reject) {
+      var e, result;
+      try {
+        // const id = _asyncUnionID++
+        // console.log("Promise Union ##{id} started")
+        result = Polytree.union(polytreeA, polytreeB, buildTargetPolytree);
+        resolve(result);
+        return disposePolytree(polytreeA, polytreeB);
+      } catch (error) {
+        e = error;
+        return reject(e);
+      }
+    });
+  },
+  subtract: function(polytreeA, polytreeB, buildTargetPolytree = true) {
+    return new Promise(function(resolve, reject) {
+      var e, result;
+      try {
+        result = Polytree.subtract(polytreeA, polytreeB, buildTargetPolytree);
+        resolve(result);
+        return disposePolytree(polytreeA, polytreeB);
+      } catch (error) {
+        e = error;
+        return reject(e);
+      }
+    });
+  },
+  intersect: function(polytreeA, polytreeB, buildTargetPolytree = true) {
+    return new Promise(function(resolve, reject) {
+      var e, result;
+      try {
+        result = Polytree.intersect(polytreeA, polytreeB, buildTargetPolytree);
+        resolve(result);
+        return disposePolytree(polytreeA, polytreeB);
+      } catch (error) {
+        e = error;
+        return reject(e);
+      }
+    });
+  },
+  unionArray: function(objArr, materialIndexMax = 2e308) {
+    return new Promise(function(resolve, reject) {
+      var batch, batches, currentIndex, e, hasLeftOver, i, k, l, leftOverPolytree, mainPolytree, mainPolytreeUsed, materialIndex, polytreesArray, promise, promises, ref, ref1, result, tempPolytree, usingBatches;
+      try {
+        usingBatches = Polytree.async.batchSize > 4 && Polytree.async.batchSize < objArr.length;
+        // const id = _asyncUnionArrayID++
+        // console.log("Promise Union Array ##{id}", usingBatches)
+        mainPolytree = void 0;
+        mainPolytreeUsed = false;
+        promises = [];
+        if (usingBatches) {
+          batches = [];
+          currentIndex = 0;
+          while (currentIndex < objArr.length) {
+            batches.push(objArr.slice(currentIndex, currentIndex + Polytree.async.batchSize));
+            currentIndex += Polytree.async.batchSize;
+          }
+          batch = batches.shift();
+          while (batch) {
+            promise = Polytree.async.unionArray(batch, 0);
+            promises.push(promise);
+            batch = batches.shift();
+          }
+          usingBatches = true;
+          mainPolytreeUsed = true;
+          objArr.length = 0;
+        } else {
+          polytreesArray = [];
+          for (i = k = 0, ref = objArr.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+            materialIndex = i > materialIndexMax ? materialIndexMax : i;
+            tempPolytree = void 0;
+            if (objArr[i].isMesh) {
+              tempPolytree = Polytree.fromMesh(objArr[i], materialIndexMax > -1 ? materialIndex : void 0);
+            } else {
+              tempPolytree = objArr[i];
+              if (materialIndexMax > -1) {
+                tempPolytree.setPolygonIndex(materialIndex);
+              }
+            }
+            tempPolytree.polytreeIndex = i;
+            polytreesArray.push(tempPolytree);
+          }
+          mainPolytree = polytreesArray.shift();
+          result = void 0;
+          hasLeftOver = false;
+          leftOverPolytree = void 0;
+          for (i = l = 0, ref1 = polytreesArray.length; l < ref1; i = l += 2) {
+            if (i + 1 >= polytreesArray.length) {
+              leftOverPolytree = polytreesArray[i];
+              hasLeftOver = true;
+              break;
+            }
+            promise = Polytree.async.union(polytreesArray[i], polytreesArray[i + 1]);
+            promises.push(promise);
+          }
+          if (leftOverPolytree) {
+            promise = Polytree.async.union(mainPolytree, leftOverPolytree);
+            promises.push(promise);
+            mainPolytreeUsed = true;
+          }
+        }
+        return Promise.allSettled(promises).then(function(results) {
+          var polytrees;
+          polytrees = [];
+          results.forEach(function(r) {
+            if (r.status === "fulfilled") {
+              return polytrees.push(r.value);
+            }
+          });
+          if (!mainPolytreeUsed) {
+            polytrees.unshift(mainPolytree);
+          }
+          if (polytrees.length > 0) {
+            if (polytrees.length === 1) {
+              return resolve(polytrees[0]);
+            } else if (polytrees.length > 3) {
+              return Polytree.async.unionArray(polytrees, usingBatches ? 0 : -1).then(function(result) {
+                return resolve(result);
+              }).catch(function(e) {
+                return reject(e);
+              });
+            } else {
+              return Polytree.async.union(polytrees[0], polytrees[1]).then(function(result) {
+                if (polytrees.length === 3) {
+                  return Polytree.async.union(result, polytrees[2]).then(function(result) {
+                    return resolve(result);
+                  }).catch(function(e) {
+                    return reject(e);
+                  });
+                } else {
+                  return resolve(result);
+                }
+              }).catch(function(e) {
+                return reject(e);
+              });
+            }
+          } else {
+            return reject('Unable to find any result polytree');
+          }
+        });
+      } catch (error) {
+        e = error;
+        return reject(e);
+      }
+    });
+  },
+  subtractArray: function(objArr, materialIndexMax = 2e308) {
+    return new Promise(function(resolve, reject) {
+      var batch, batches, currentIndex, e, hasLeftOver, i, k, l, leftOverPolytree, mainPolytree, mainPolytreeUsed, materialIndex, polytreesArray, promise, promises, ref, ref1, result, tempPolytree, usingBatches;
+      try {
+        usingBatches = Polytree.async.batchSize > 4 && Polytree.async.batchSize < objArr.length;
+        mainPolytree = void 0;
+        mainPolytreeUsed = false;
+        promises = [];
+        if (usingBatches) {
+          batches = [];
+          currentIndex = 0;
+          while (currentIndex < objArr.length) {
+            batches.push(objArr.slice(currentIndex, currentIndex + Polytree.async.batchSize));
+            currentIndex += Polytree.async.batchSize;
+          }
+          batch = batches.shift();
+          while (batch) {
+            promise = Polytree.async.subtractArray(batch, 0);
+            promises.push(promise);
+            batch = batches.shift();
+          }
+          usingBatches = true;
+          mainPolytreeUsed = true;
+          objArr.length = 0;
+        } else {
+          polytreesArray = [];
+          for (i = k = 0, ref = objArr.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+            materialIndex = i > materialIndexMax ? materialIndexMax : i;
+            tempPolytree = void 0;
+            if (objArr[i].isMesh) {
+              tempPolytree = Polytree.fromMesh(objArr[i], materialIndexMax > -1 ? materialIndex : void 0);
+            } else {
+              tempPolytree = objArr[i];
+              if (materialIndexMax > -1) {
+                tempPolytree.setPolygonIndex(materialIndex);
+              }
+            }
+            tempPolytree.polytreeIndex = i;
+            polytreesArray.push(tempPolytree);
+          }
+          mainPolytree = polytreesArray.shift();
+          result = void 0;
+          hasLeftOver = false;
+          leftOverPolytree = void 0;
+          for (i = l = 0, ref1 = polytreesArray.length; l < ref1; i = l += 2) {
+            if (i + 1 >= polytreesArray.length) {
+              leftOverPolytree = polytreesArray[i];
+              hasLeftOver = true;
+              break;
+            }
+            promise = Polytree.async.subtract(polytreesArray[i], polytreesArray[i + 1]);
+            promises.push(promise);
+          }
+          if (leftOverPolytree) {
+            promise = Polytree.async.subtract(mainPolytree, leftOverPolytree);
+            promises.push(promise);
+            mainPolytreeUsed = true;
+          }
+        }
+        return Promise.allSettled(promises).then(function(results) {
+          var polytrees;
+          polytrees = [];
+          results.forEach(function(r) {
+            if (r.status === "fulfilled") {
+              return polytrees.push(r.value);
+            }
+          });
+          if (!mainPolytreeUsed) {
+            polytrees.unshift(mainPolytree);
+          }
+          if (polytrees.length > 0) {
+            if (polytrees.length === 1) {
+              return resolve(polytrees[0]);
+            } else if (polytrees.length > 3) {
+              return Polytree.async.subtractArray(polytrees, usingBatches ? 0 : -1).then(function(result) {
+                return resolve(result);
+              }).catch(function(e) {
+                return reject(e);
+              });
+            } else {
+              return Polytree.async.subtract(polytrees[0], polytrees[1]).then(function(result) {
+                if (polytrees.length === 3) {
+                  return Polytree.async.subtract(result, polytrees[2]).then(function(result) {
+                    return resolve(result);
+                  }).catch(function(e) {
+                    return reject(e);
+                  });
+                } else {
+                  return resolve(result);
+                }
+              }).catch(function(e) {
+                return reject(e);
+              });
+            }
+          } else {
+            return reject('Unable to find any result polytree');
+          }
+        });
+      } catch (error) {
+        e = error;
+        return reject(e);
+      }
+    });
+  },
+  intersectArray: function(objArr, materialIndexMax = 2e308) {
+    return new Promise(function(resolve, reject) {
+      var batch, batches, currentIndex, e, hasLeftOver, i, k, l, leftOverPolytree, mainPolytree, mainPolytreeUsed, materialIndex, polytreesArray, promise, promises, ref, ref1, result, tempPolytree, usingBatches;
+      try {
+        usingBatches = Polytree.async.batchSize > 4 && Polytree.async.batchSize < objArr.length;
+        mainPolytree = void 0;
+        mainPolytreeUsed = false;
+        promises = [];
+        if (usingBatches) {
+          batches = [];
+          currentIndex = 0;
+          while (currentIndex < objArr.length) {
+            batches.push(objArr.slice(currentIndex, currentIndex + Polytree.async.batchSize));
+            currentIndex += Polytree.async.batchSize;
+          }
+          batch = batches.shift();
+          while (batch) {
+            promise = Polytree.async.intersectArray(batch, 0);
+            promises.push(promise);
+            batch = batches.shift();
+          }
+          usingBatches = true;
+          mainPolytreeUsed = true;
+          objArr.length = 0;
+        } else {
+          polytreesArray = [];
+          for (i = k = 0, ref = objArr.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+            materialIndex = i > materialIndexMax ? materialIndexMax : i;
+            tempPolytree = void 0;
+            if (objArr[i].isMesh) {
+              tempPolytree = Polytree.fromMesh(objArr[i], materialIndexMax > -1 ? materialIndex : void 0);
+            } else {
+              tempPolytree = objArr[i];
+              if (materialIndexMax > -1) {
+                tempPolytree.setPolygonIndex(materialIndex);
+              }
+            }
+            tempPolytree.polytreeIndex = i;
+            polytreesArray.push(tempPolytree);
+          }
+          mainPolytree = polytreesArray.shift();
+          result = void 0;
+          hasLeftOver = false;
+          leftOverPolytree = void 0;
+          for (i = l = 0, ref1 = polytreesArray.length; l < ref1; i = l += 2) {
+            if (i + 1 >= polytreesArray.length) {
+              leftOverPolytree = polytreesArray[i];
+              hasLeftOver = true;
+              break;
+            }
+            promise = Polytree.async.intersect(polytreesArray[i], polytreesArray[i + 1]);
+            promises.push(promise);
+          }
+          if (leftOverPolytree) {
+            promise = Polytree.async.intersect(mainPolytree, leftOverPolytree);
+            promises.push(promise);
+            mainPolytreeUsed = true;
+          }
+        }
+        return Promise.allSettled(promises).then(function(results) {
+          var polytrees;
+          polytrees = [];
+          results.forEach(function(r) {
+            if (r.status === "fulfilled") {
+              return polytrees.push(r.value);
+            }
+          });
+          if (!mainPolytreeUsed) {
+            polytrees.unshift(mainPolytree);
+          }
+          if (polytrees.length > 0) {
+            if (polytrees.length === 1) {
+              return resolve(polytrees[0]);
+            } else if (polytrees.length > 3) {
+              return Polytree.async.intersectArray(polytrees, usingBatches ? 0 : -1).then(function(result) {
+                return resolve(result);
+              }).catch(function(e) {
+                return reject(e);
+              });
+            } else {
+              return Polytree.async.intersect(polytrees[0], polytrees[1]).then(function(result) {
+                if (polytrees.length === 3) {
+                  return Polytree.async.intersect(result, polytrees[2]).then(function(result) {
+                    return resolve(result);
+                  }).catch(function(e) {
+                    return reject(e);
+                  });
+                } else {
+                  return resolve(result);
+                }
+              }).catch(function(e) {
+                return reject(e);
+              });
+            }
+          } else {
+            return reject('Unable to find any result polytree');
+          }
+        });
+      } catch (error) {
+        e = error;
+        return reject(e);
+      }
+    });
+  },
+  operation: function(obj, returnPolytrees = false, buildTargetPolytree = true, options = {
+      objCounter: 0
+    }, firstRun = true) {
+    return new Promise(function(resolve, reject) {
+      var e, material, polytreeA, polytreeB, promise, promises, resultPolytree;
+      try {
+        polytreeA = void 0;
+        polytreeB = void 0;
+        resultPolytree = void 0;
+        material = void 0;
+        if (obj.material) {
+          material = obj.material;
+        }
+        promises = [];
+        if (obj.objA) {
+          promise = handleObjectForOp_async(obj.objA, returnPolytrees, buildTargetPolytree, options, 0);
+          promises.push(promise);
+        }
+        if (obj.objB) {
+          promise = handleObjectForOp_async(obj.objB, returnPolytrees, buildTargetPolytree, options, 1);
+          promises.push(promise);
+        }
+        return Promise.allSettled(promises).then(function(results) {
+          var polytrees, resultPromise;
+          polytrees = [];
+          results.forEach(function(r) {
+            if (r.status === "fulfilled") {
+              if (r.value.objIndex === 0) {
+                return polytreeA = r.value;
+              } else if (r.value.objIndex === 1) {
+                return polytreeB = r.value;
+              }
+            }
+          });
+          if (returnPolytrees === true) {
+            obj.objA = polytreeA.original;
+            polytreeA = polytreeA.result;
+            obj.objB = polytreeB.original;
+            polytreeB = polytreeB.result;
+          }
+          resultPromise = void 0;
+          switch (obj.op) {
+            case 'union':
+              resultPromise = Polytree.async.union(polytreeA, polytreeB, buildTargetPolytree);
+              break;
+            case 'subtract':
+              resultPromise = Polytree.async.subtract(polytreeA, polytreeB, buildTargetPolytree);
+              break;
+            case 'intersect':
+              resultPromise = Polytree.async.intersect(polytreeA, polytreeB, buildTargetPolytree);
+          }
+          return resultPromise.then(function(resultPolytree) {
+            var mesh;
+            if (firstRun && material) {
+              mesh = Polytree.toMesh(resultPolytree, material);
+              if (!returnPolytrees) {
+                disposePolytree(resultPolytree);
+              }
+              resolve(returnPolytrees ? {
+                result: mesh,
+                operationTree: obj
+              } : mesh);
+            } else if (firstRun && returnPolytrees) {
+              resolve({
+                result: resultPolytree,
+                operationTree: obj
+              });
+            } else {
+              resolve(resultPolytree);
+            }
+            if (!returnPolytrees) {
+              return disposePolytree(polytreeA, polytreeB);
+            }
+          }).catch(function(e) {
+            return reject(e);
+          });
+        });
+      } catch (error) {
+        e = error;
+        return reject(e);
+      }
+    });
+  }
+};
+
+Polytree.unionArray = function(objArr, materialIndexMax = 2e308) {
+  var i, k, materialIndex, polytreeA, polytreeB, polytreesArray, ref, resultPolytree, tempPolytree;
+  polytreesArray = [];
+  for (i = k = 0, ref = objArr.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+    materialIndex = i > materialIndexMax ? materialIndexMax : i;
+    tempPolytree = void 0;
+    if (objArr[i].isMesh) {
+      tempPolytree = Polytree.fromMesh(objArr[i], materialIndex);
+    } else {
+      tempPolytree = objArr[i];
+      tempPolytree.setPolygonIndex(materialIndex);
+    }
+    tempPolytree.polytreeIndex = i;
+    polytreesArray.push(tempPolytree);
+  }
+  polytreeA = polytreesArray.shift();
+  polytreeB = polytreesArray.shift();
+  while (polytreeA && polytreeB) {
+    resultPolytree = Polytree.union(polytreeA, polytreeB);
+    disposePolytree(polytreeA, polytreeB);
+    polytreeA = resultPolytree;
+    polytreeB = polytreesArray.shift();
+  }
+  return polytreeA;
+};
+
+Polytree.subtractArray = function(objArr, materialIndexMax = 2e308) {
+  var i, k, materialIndex, polytreeA, polytreeB, polytreesArray, ref, resultPolytree, tempPolytree;
+  polytreesArray = [];
+  for (i = k = 0, ref = objArr.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+    materialIndex = i > materialIndexMax ? materialIndexMax : i;
+    tempPolytree = void 0;
+    if (objArr[i].isMesh) {
+      tempPolytree = Polytree.fromMesh(objArr[i], materialIndex);
+    } else {
+      tempPolytree = objArr[i];
+      tempPolytree.setPolygonIndex(materialIndex);
+    }
+    tempPolytree.polytreeIndex = i;
+    polytreesArray.push(tempPolytree);
+  }
+  polytreeA = polytreesArray.shift();
+  polytreeB = polytreesArray.shift();
+  while (polytreeA && polytreeB) {
+    resultPolytree = Polytree.subtract(polytreeA, polytreeB);
+    disposePolytree(polytreeA, polytreeB);
+    polytreeA = resultPolytree;
+    polytreeB = polytreesArray.shift();
+  }
+  return polytreeA;
+};
+
+Polytree.intersectArray = function(objArr, materialIndexMax = 2e308) {
+  var i, k, materialIndex, polytreeA, polytreeB, polytreesArray, ref, resultPolytree, tempPolytree;
+  polytreesArray = [];
+  for (i = k = 0, ref = objArr.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+    materialIndex = i > materialIndexMax ? materialIndexMax : i;
+    tempPolytree = void 0;
+    if (objArr[i].isMesh) {
+      tempPolytree = Polytree.fromMesh(objArr[i], materialIndex);
+    } else {
+      tempPolytree = objArr[i];
+      tempPolytree.setPolygonIndex(materialIndex);
+    }
+    tempPolytree.polytreeIndex = i;
+    polytreesArray.push(tempPolytree);
+  }
+  polytreeA = polytreesArray.shift();
+  polytreeB = polytreesArray.shift();
+  while (polytreeA && polytreeB) {
+    resultPolytree = Polytree.intersect(polytreeA, polytreeB);
+    disposePolytree(polytreeA, polytreeB);
+    polytreeA = resultPolytree;
+    polytreeB = polytreesArray.shift();
+  }
+  return polytreeA;
+};
+
+Polytree.operation = function(obj, returnPolytrees = false, buildTargetPolytree = true, options = {
+    objCounter: 0
+  }, firstRun = true) {
+  var material, mesh, polytreeA, polytreeB, resultPolytree;
+  polytreeA = void 0;
+  polytreeB = void 0;
+  resultPolytree = void 0;
+  material = void 0;
+  if (obj.material) {
+    material = obj.material;
+  }
+  if (obj.objA) {
+    polytreeA = handleObjectForOp(obj.objA, returnPolytrees, buildTargetPolytree, options);
+    if (returnPolytrees === true) {
+      obj.objA = polytreeA.original;
+      polytreeA = polytreeA.result;
+    }
+  }
+  if (obj.objB) {
+    polytreeB = handleObjectForOp(obj.objB, returnPolytrees, buildTargetPolytree, options);
+    if (returnPolytrees === true) {
+      obj.objB = polytreeB.original;
+      polytreeB = polytreeB.result;
+    }
+  }
+  switch (obj.op) {
+    case 'union':
+      resultPolytree = Polytree.union(polytreeA, polytreeB, buildTargetPolytree);
+      break;
+    case 'subtract':
+      resultPolytree = Polytree.subtract(polytreeA, polytreeB, buildTargetPolytree);
+      break;
+    case 'intersect':
+      resultPolytree = Polytree.intersect(polytreeA, polytreeB, buildTargetPolytree);
+  }
+  if (!returnPolytrees) {
+    disposePolytree(polytreeA, polytreeB);
+  }
+  if (firstRun && material) {
+    mesh = Polytree.toMesh(resultPolytree, material);
+    disposePolytree(resultPolytree);
+    if (returnPolytrees) {
+      return {
+        result: mesh,
+        operationTree: obj
+      };
+    } else {
+      return mesh;
+    }
+  }
+  if (firstRun && returnPolytrees) {
+    return {
+      result: resultPolytree,
+      operationTree: obj
+    };
+  }
+  return resultPolytree;
+};
+
+handleObjectForOp = function(obj, returnPolytrees, buildTargetPolytree, options) {
+  var returnObj;
+  returnObj = void 0;
+  if (obj.isMesh) {
+    returnObj = Polytree.fromMesh(obj, options.objCounter++);
+    if (returnPolytrees) {
+      returnObj = {
+        result: returnObj,
+        original: returnObj.clone()
+      };
+    }
+  } else if (obj.isPolytree) {
+    returnObj = obj;
+    if (returnPolytrees) {
+      returnObj = {
+        result: obj,
+        original: obj.clone()
+      };
+    }
+  } else if (obj.op) {
+    returnObj = Polytree.operation(obj, returnPolytrees, buildTargetPolytree, options, false);
+    if (returnPolytrees) {
+      returnObj = {
+        result: returnObj,
+        original: obj
+      };
+    }
+  }
+  return returnObj;
+};
+
+handleObjectForOp_async = function(obj, returnPolytrees, buildTargetPolytree, options, objIndex) {
+  return new Promise(function(resolve, reject) {
+    var e, returnObj;
+    try {
+      returnObj = void 0;
+      if (obj.isMesh) {
+        returnObj = Polytree.fromMesh(obj, options.objCounter++);
+        if (returnPolytrees) {
+          returnObj = {
+            result: returnObj,
+            original: returnObj.clone()
+          };
+        }
+        returnObj.objIndex = objIndex;
+        return resolve(returnObj);
+      } else if (obj.isPolytree) {
+        returnObj = obj;
+        if (returnPolytrees) {
+          returnObj = {
+            result: obj,
+            original: obj.clone()
+          };
+        }
+        returnObj.objIndex = objIndex;
+        return resolve(returnObj);
+      } else if (obj.op) {
+        return Polytree.async.operation(obj, returnPolytrees, buildTargetPolytree, options, false).then(function(returnObj) {
+          if (returnPolytrees) {
+            returnObj = {
+              result: returnObj,
+              original: obj
+            };
+          }
+          returnObj.objIndex = objIndex;
+          return resolve(returnObj);
+        });
+      }
+    } catch (error) {
+      e = error;
+      return reject(e);
+    }
+  });
+};
+
+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;
+  }
+};
+
+nbuf3 = function(ct) {
+  return {
+    top: 0,
+    array: new Float32Array(ct),
+    write: function(v) {
+      this.array[this.top++] = v.x;
+      this.array[this.top++] = v.y;
+      return this.array[this.top++] = v.z;
+    }
+  };
+};
+
+nbuf2 = function(ct) {
+  return {
+    top: 0,
+    array: new Float32Array(ct),
+    write: function(v) {
+      this.array[this.top++] = v.x;
+      return this.array[this.top++] = v.y;
+    }
+  };
+};
+
+_normal1 = new Vector3();
+
+tmpm3 = new Matrix3();
+
+ttvv0 = new Vector3();
+
+Polytree.toGeometry = function(polytree) {
+  var colors, defaultGroup, geometry, groupBase, groups, i, index, k, l, len1, m, normals, polygon, polygons, positions, ref, ref1, triangleCount, uvs, vertices, verticesLen;
+  polygons = polytree.getPolygons();
+  triangleCount = polygons.length;
+  // let validPolygons = [];
+  // let trianglesSet = new Set();
+  // let duplicateCount = 0;
+
+  // let triangleCount = 0;
+  // polygons.forEach(polygon => {
+  //     if (isUniqueTriangle(polygon.triangle, trianglesSet)) {
+  //         triangleCount += (polygon.vertices.length - 2);
+  //         validPolygons.push(polygon);
+  //     }
+  // });
+
+  // trianglesSet.clear();
+  // trianglesSet = undefined;
+  positions = nbuf3(triangleCount * 3 * 3);
+  normals = nbuf3(triangleCount * 3 * 3);
+  uvs = void 0;
+  colors = void 0;
+  groups = [];
+  defaultGroup = [];
+  for (k = 0, len1 = polygons.length; k < len1; k++) {
+    polygon = polygons[k];
+    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 = nbuf2(triangleCount * 2 * 3));
+      }
+      if (vertices[0].color !== void 0) {
+        colors || (colors = nbuf3(triangleCount * 3 * 3));
+      }
+    }
+    for (i = l = 3, ref = verticesLen; (3 <= ref ? l <= ref : l >= ref); i = 3 <= ref ? ++l : --l) {
+      (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 = m = 0, ref1 = groups.length; (0 <= ref1 ? m < ref1 : m > ref1); i = 0 <= ref1 ? ++m : --m) {
+      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, len1, 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;
+  tmpm3.getNormalMatrix(obj.matrix);
+  posattr = geometry.attributes.position;
+  normalattr = geometry.attributes.normal;
+  uvattr = geometry.attributes.uv;
+  colorattr = geometry.attributes.color;
+  groups = geometry.groups;
+  index = geometry.index ? geometry.index.array : Array((posattr.array.length / posattr.itemSize) | 0).fill().map(function(_, i) {
+    return i;
+  });
+  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(tmpm3);
+      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, len1 = groups.length; m < len1; 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;
+};
+
+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;
+};
+
+// class Vertex
+Vertex = class Vertex {
+  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));
+  }
+
+  clone() {
+    return new Vertex(this.pos.clone(), this.normal.clone(), this.uv && this.uv.clone(), this.color && this.color.clone());
+  }
+
+  flip() {
+    return this.normal.negate();
+  }
+
+  delete() {
+    this.pos = void 0;
+    this.normal = void 0;
+    this.uv && (this.uv = void 0);
+    return this.color && (this.color = void 0);
+  }
+
+  interpolate(other, t) {
+    return new Vertex(this.pos.clone().lerp(other.pos, t), this.normal.clone().lerp(other.normal, t), this.uv && other.uv && this.uv.clone().lerp(other.uv, t), this.color && other.color && this.color.clone().lerp(other.color, t));
+  }
+
+};
+
+// class Plane
+Plane = class Plane {
+  constructor(normal, w) {
+    this.normal = normal;
+    this.w = w;
+  }
+
+  clone() {
+    return new Plane(this.normal.clone(), this.w);
+  }
+
+  flip() {
+    this.normal.negate();
+    return this.w = -this.w;
+  }
+
+  delete() {
+    this.normal = void 0;
+    return this.w = void 0;
+  }
+
+  equals(p) {
+    return this.normal.equals(p.normal) && this.w === p.w;
+  }
+
+};
+
+Plane.fromPoints = function(a, b, c) {
+  var planeNormal;
+  planeNormal = triangleVertex0.copy(b).sub(a).cross(triangleVertex1.copy(c).sub(a)).normalize().clone();
+  return new Plane(planeNormal, planeNormal.dot(a));
+};
+
+// class Polygon
+Polygon = class Polygon {
+  constructor(vertices, shared) {
+    this.id = _polygonID++;
+    this.vertices = vertices.map(function(v) {
+      return v.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;
+  }
+
+  getMidpoint() {
+    if (this.triangle.midPoint) {
+      return this.triangle.midPoint;
+    } else {
+      return this.triangle.midPoint = this.triangle.getMidpoint(new Vector3());
+    }
+  }
+
+  applyMatrix(matrix, normalMatrix) {
+    normalMatrix = normalMatrix || tmpm3.getNormalMatrix(matrix);
+    this.vertices.forEach(function(v) {
+      v.pos.applyMatrix4(matrix);
+      return v.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);
+    }
+  }
+
+  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;
+  }
+
+  setState(state, keepState) {
+    if (this.state === keepState) {
+      return;
+    }
+    this.previousState = this.state;
+    this.state !== "undecided" && this.previousStates.push(this.state);
+    return this.state = state;
+  }
+
+  checkAllStates(state) {
+    var k, len1, ref, s;
+    if ((this.state !== state) || ((this.previousState !== state) && (this.previousState !== "undecided"))) {
+      return false;
+    }
+    ref = this.previousStates;
+    for (k = 0, len1 = ref.length; k < len1; k++) {
+      s = ref[k];
+      if (s !== state) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  setInvalid() {
+    return this.valid = false;
+  }
+
+  setValid() {
+    return this.valid = true;
+  }
+
+  clone() {
+    var polygon;
+    polygon = new Polygon(this.vertices.map(function(v) {
+      return v.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;
+  }
+
+  flip() {
+    var tmp;
+    this.vertices.reverse().forEach(function(v) {
+      return v.flip();
+    });
+    tmp = this.triangle.a;
+    this.triangle.a = this.triangle.c;
+    this.triangle.c = tmp;
+    return this.plane.flip();
+  }
+
+  delete() {
+    this.vertices.forEach(function(v) {
+      return v.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();
+  }
+
+};
+
+disposePolytree = function(...polytrees) {
+  if (Polytree.disposePolytree) {
+    return polytrees.forEach(function(polytree) {
+      return polytree.delete();
+    });
+  }
+};
+
+// Winding Number algorithm adapted from https://github.com/grame-cncm/faust/blob/master-dev/tools/physicalModeling/mesh2faust/vega/libraries/windingNumber/windingNumber.cpp
+_wV1 = new Vector3();
+
+_wV2 = new Vector3();
+
+_wV3 = new Vector3();
+
+_wP = new Vector3();
+
+_wP_EPS_ARR = [new Vector3(EPSILON, 0, 0), new Vector3(0, EPSILON, 0), new Vector3(0, 0, EPSILON), new Vector3(-EPSILON, 0, 0), new Vector3(0, -EPSILON, 0), new Vector3(0, 0, -EPSILON)];
+
+_wP_EPS_ARR_COUNT = _wP_EPS_ARR.length;
+
+_matrix3 = new Matrix3();
+
+wNPI = 4 * Math.PI;
+
+returnXYZ = function(arr, index) {
+  return {
+    x: arr[index],
+    y: arr[index + 1],
+    z: arr[index + 2]
+  };
+};
+
+calcWindingNumber_buffer = function(trianglesArr, point) {
+  var i, k, lenA, lenB, lenC, omega, ref, wN;
+  wN = 0;
+  for (i = k = 0, ref = trianglesArr.length; k < ref; i = k += 9) {
+    _wV1.subVectors(returnXYZ(trianglesArr, i), point);
+    _wV2.subVectors(returnXYZ(trianglesArr, i + 3), point);
+    _wV3.subVectors(returnXYZ(trianglesArr, i + 6), point);
+    lenA = _wV1.length();
+    lenB = _wV2.length();
+    lenC = _wV3.length();
+    _matrix3.set(_wV1.x, _wV1.y, _wV1.z, _wV2.x, _wV2.y, _wV2.z, _wV3.x, _wV3.y, _wV3.z);
+    omega = 2 * Math.atan2(_matrix3.determinant(), lenA * lenB * lenC + _wV1.dot(_wV2) * lenC + _wV2.dot(_wV3) * lenA + _wV3.dot(_wV1) * lenB);
+    wN += omega;
+  }
+  wN = Math.round(wN / wNPI);
+  return wN;
+};
+
+polyInside_WindingNumber_buffer = function(trianglesArr, point, coplanar) {
+  var j, k, ref, result, wN;
+  result = false;
+  _wP.copy(point);
+  wN = calcWindingNumber_buffer(trianglesArr, _wP);
+  if (wN === 0) {
+    if (coplanar) {
+      for (j = k = 0, ref = _wP_EPS_ARR_COUNT; (0 <= ref ? k < ref : k > ref); j = 0 <= ref ? ++k : --k) {
+        _wP.copy(point).add(_wP_EPS_ARR[j]);
+        wN = calcWindingNumber_buffer(trianglesArr, _wP);
+        if (wN !== 0) {
+          result = true;
+          break;
+        }
+      }
+    }
+  } else {
+    result = true;
+  }
+  return result;
+};
+
+// -----
+handleIntersectingPolytrees = function(polytreeA, polytreeB, bothPolytrees = true) {
+  var polytreeA_buffer, polytreeB_buffer;
+  polytreeA_buffer = void 0;
+  polytreeB_buffer = void 0;
+  if (Polytree.useWindingNumber === true) {
+    if (bothPolytrees) {
+      polytreeA_buffer = prepareTriangleBuffer(polytreeA.getPolygons());
+    }
+    polytreeB_buffer = prepareTriangleBuffer(polytreeB.getPolygons());
+  }
+  polytreeA.handleIntersectingPolygons(polytreeB, polytreeB_buffer);
+  if (bothPolytrees) {
+    polytreeB.handleIntersectingPolygons(polytreeA, polytreeA_buffer);
+  }
+  if (polytreeA_buffer !== void 0) {
+    polytreeA_buffer = void 0;
+    return polytreeB_buffer = void 0;
+  }
+};
+
+prepareTriangleBuffer = function(polygons) {
+  var array, bufferIndex, i, k, numOfTriangles, ref, triangle;
+  numOfTriangles = polygons.length;
+  array = new Float32Array(numOfTriangles * 3 * 3);
+  bufferIndex = 0;
+  for (i = k = 0, ref = numOfTriangles; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+    triangle = polygons[i].triangle;
+    array[bufferIndex++] = triangle.a.x;
+    array[bufferIndex++] = triangle.a.y;
+    array[bufferIndex++] = triangle.a.z;
+    array[bufferIndex++] = triangle.b.x;
+    array[bufferIndex++] = triangle.b.y;
+    array[bufferIndex++] = triangle.b.z;
+    array[bufferIndex++] = triangle.c.x;
+    array[bufferIndex++] = triangle.c.y;
+    array[bufferIndex++] = triangle.c.z;
+  }
+  return array;
+};
+
+// https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm
+edge1 = new Vector3();
+
+edge2 = new Vector3();
+
+h = new Vector3();
+
+s = new Vector3();
+
+q = new Vector3();
+
+RAY_EPSILON = 0.0000001;
+
+rayIntersectsTriangle = function(ray, triangle, target = new Vector3()) {
+  var a, f, t, u, v;
+  edge1.subVectors(triangle.b, triangle.a);
+  edge2.subVectors(triangle.c, triangle.a);
+  h.crossVectors(ray.direction, edge2);
+  a = edge1.dot(h);
+  if (a > -RAY_EPSILON && a < RAY_EPSILON) {
+    return null; // Ray is parallel to the triangle
+  }
+  f = 1 / a;
+  s.subVectors(ray.origin, triangle.a);
+  u = f * s.dot(h);
+  if (u < 0 || u > 1) {
+    return null;
+  }
+  q.crossVectors(s, edge1);
+  v = f * ray.direction.dot(q);
+  if (v < 0 || u + v > 1) {
+    return null;
+  }
+  t = f * edge2.dot(q);
+  if (t > RAY_EPSILON) {
+    return target.copy(ray.direction).multiplyScalar(t).add(ray.origin);
+  }
+  return null;
+};
+
+Polytree.rayIntersectsTriangle = rayIntersectsTriangle;
+
+Polytree.usePolytreeRay = true;
+
+Polytree.useWindingNumber = false;
+
+Polytree.rayIntersectTriangleType = "MollerTrumbore"; // "regular" (three.js' ray.intersectTriangle; "MollerTrumbore" (Moller Trumbore algorithm);
+
+Polytree.maxLevel = 16;
+
+Polytree.polygonsPerTree = 100;
+// Generated by CoffeeScript 2.7.0
+
+/* Determines the intersection segment (if any) between two triangles in 3D space.
+    If an intersection segment exists, its endpoints are written to `additions.source` and `additions.target`.
+
+@param {Vector3} vertex1TriangleA, vertex2TriangleA, vertex3TriangleA - Vertices of triangle A
+@param {Vector3} vertex1TriangleB, vertex2TriangleB, vertex3TriangleB - Vertices of triangle B
+
+@param {Object} additions - Data object used for storing extra intersection info:
+
+    - coplanar {Boolean} whether the triangles lie in the same plane.
+    - source {Vector3} intersection segment start (if applicable).
+    - target {Vector3} intersection segment end (if applicable).
+    - normal1 {Vector3} normal of Triangle A (used in coplanar case).
+    - normal2 {Vector3} normal of Triangle B (used in coplanar case).
+
+@return {Boolean} True if intersection segment exists, false otherwise. */
+    /* Checks for edge intersection between two triangles in 2D.
+
+    @param {Vector2} vertex1TriangleA, vertex2TriangleA, vertex3TriangleA - Vertices of triangle A
+    @param {Vector2} vertex1TriangleB, vertex2TriangleB, vertex3TriangleB - Vertices of triangle B
+
+    @return {Boolean} True if an edge intersection is found, false otherwise. */
+    /* Checks for vertex intersection between two triangles in 2D.
+
+    @param {Vector2} vertex1TriangleA, vertex2TriangleA, vertex3TriangleA - Vertices of triangle A
+    @param {Vector2} vertex1TriangleB, vertex2TriangleB, vertex3TriangleB - Vertices of triangle B
+
+    @return {Boolean} True if a vertex intersection is found, false otherwise. */
+    /* Resolves intersection between two coplanar triangles in 3D space.
+        Since the triangles lie in the same plane, the problem is reduced from 3D to 2D.
+        By projecting both triangles onto the axis-aligned plane (XY, YZ, or XZ) that maximizes the projected area.
+        This minimizes numerical errors when working in 2D. The function then delegates the overlap test to `trianglesOverlap2D`.
+
+    @param {Vector2} vertex1TriangleA, vertex2TriangleA, vertex3TriangleA - Vertices of triangle A
+    @param {Vector2} vertex1TriangleB, vertex2TriangleB, vertex3TriangleB - Vertices of triangle B
+
+    @param {Vector3} normalTriangleA - Normal vector of Triangle A.
+    @param {Vector3} normalTriangleB - Normal vector of Triangle B.
+
+    @returns {Boolean} - True if the coplanar triangles overlap in 2D, false otherwise. */
+    /* Determines the intersection between two 3D triangles given their vertices and the signed distances of Triangle B’s vertices to the plane of Triangle A.
+        Goal: Always pass to `constructIntersection` the triangles arranged so the first vertex of each lies alone on one side of the other triangle’s plane (or is on the plane), and the remaining two share the opposite side.
+        This function chooses one of several vertex orderings based on the sign pattern of (distanceVertex1B, distanceVertex2B, distanceVertex3B).
+        If all three distances for Triangle B are zero → triangles are coplanar and handled by `resolveCoplanarTriangleIntersection`.
+
+    @param {Vector2} vertex1TriangleA, vertex2TriangleA, vertex3TriangleA - Vertices of triangle A
+    @param {Vector2} vertex1TriangleB, vertex2TriangleB, vertex3TriangleB - Vertices of triangle B
+
+    @param {Number} distanceVertex1B - Signed distance of vertex1TriangleB to Triangle A’s plane.
+    @param {Number} distanceVertex2B - Signed distance of vertex2TriangleB to Triangle A’s plane.
+    @param {Number} distanceVertex3B - Signed distance of vertex3TriangleB to Triangle A’s plane.
+
+    @param {Object} additions - Data object used for storing extra intersection info:
+
+        - coplanar {Boolean} whether the triangles lie in the same plane.
+        - source {Vector3} intersection segment start (if applicable).
+        - target {Vector3} intersection segment end (if applicable).
+        - normal1 {Vector3} normal of Triangle A (used in coplanar case).
+        - normal2 {Vector3} normal of Triangle B (used in coplanar case).
+
+    @returns {Boolean} - True if an intersection is found, false otherwise. */
+    /* Determines if two counter-clockwise (CCW) triangles in 2D overlap.
+        The function checks the relative orientation of triangle B's vertices with respect to triangle A.
+        Then recursively tests for edge or vertex intersection depending on the configuration.
+
+    @param {Vector2} vertex1TriangleA, vertex2TriangleA, vertex3TriangleA - Vertices of triangle A (CCW order)
+    @param {Vector2} vertex1TriangleB, vertex2TriangleB, vertex3TriangleB - Vertices of triangle B (CCW order)
+
+    @return {Boolean} True if triangles overlap, false otherwise. */
+    /* Checks whether two triangles in 3D space intersect.
+
+    @param {Object} triangleA - First triangle, with properties {a, b, c} (Vector3 vertices).
+    @param {Object} triangleB - Second triangle, with properties {a, b, c} (Vector3 vertices).
+
+    @param {Object} additions - Optional data object used for storing extra intersection info:
+
+        - coplanar {Boolean} whether the triangles lie in the same plane.
+        - source {Vector3} intersection segment start (if applicable).
+        - target {Vector3} intersection segment end (if applicable).
+
+    @returns {Boolean} - True if the triangles intersect, false otherwise. */
+    /* Computes the orientation (signed area) of a 2D triangle defined by three vertices.
+        The result indicates whether the points are arranged clockwise (CW), counter-clockwise (CCW), or collinear.
+
+        Note: This returns the raw signed area (twice the triangle area), without applying an epsilon threshold.
+        Callers should compare against a small EPS (e.g., EPS2D) when classifying near-collinear inputs.
+
+        Formula: orientation(a, b, c) = (a.x - c.x) * (b.y - c.y) - (a.y - c.y) * (b.x - c.x)
+
+        - If result > 0 → counter-clockwise (CCW).
+        - If result < 0 → clockwise (CW).
+        - If result = 0 → points are collinear.
+
+    @param {Vector2} a - First vertex.
+    @param {Vector2} b - Second vertex.
+    @param {Vector2} c - Third vertex.
+
+    @returns {Number} - Positive if CCW, negative if CW, zero if collinear. */
+    /* Determines whether two triangles in 2D overlap.
+
+        Behavior and notes:
+
+        - Orientation: Triangles may be CW or CCW; inputs are normalized to CCW before testing.
+        - Inclusivity: Overlap is inclusive of shared edges and shared vertices.
+        - Degenerate handling:
+
+            - If one triangle degenerates to a point, returns whether that point lies in (or on) the other triangle.
+            - If both degenerate to points, returns true only if the points coincide within EPS2D.
+            - Degenerate line triangles are handled by the main CCW intersection routine and by point/segment checks where applicable.
+
+    @param {Vector2} vertex1TriangleA, vertex2TriangleA, vertex3TriangleA - Vertices of triangle A
+    @param {Vector2} vertex1TriangleB, vertex2TriangleB, vertex3TriangleB - Vertices of triangle B
+
+    @returns {Boolean} - True if the triangles overlap in 2D, false otherwise. */
+var EPS2D, constructIntersection, intersectionTestEdge2D, intersectionTestVertex2D, pointInTriangleInclusive2D, pointOnSegmentInclusive2D, pointsEqual2D, resolveCoplanarTriangleIntersection, resolveTriangleIntersection, tempVector1, tempVector2, tempVector3, triangleIntersectionCCW2D, triangleIntersectsTriangle, triangleOrientation2D, trianglesOverlap2D;
+
+EPS2D = 1e-10;
+
+tempVector1 = new Vector3();
+
+tempVector2 = new Vector3();
+
+tempVector3 = new Vector3();
+
+// Epsilon-aware 2D point equality.
+pointsEqual2D = function(p, q, eps = EPS2D) {
+  return Math.abs(p.x - q.x) <= eps && Math.abs(p.y - q.y) <= eps;
+};
+
+// Inclusive point-on-segment check for collinear points.
+pointOnSegmentInclusive2D = function(p, a, b, eps = EPS2D) {
+  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;
+};
+
+// Inclusive point-in-triangle test using orientations.
+// - Works for CW or CCW input (auto-detects orientation).
+// - Inclusive of edges/vertices.
+// - Handles degenerate triangles (point or segment) robustly.
+pointInTriangleInclusive2D = function(p, a, b, c, eps = EPS2D) {
+  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 {
+    // Degenerate triangle: either a point (all equal) or a segment (collinear).
+    if (pointsEqual2D(a, b, eps) && pointsEqual2D(b, c, eps)) {
+      return pointsEqual2D(p, a, eps);
+    }
+    // Reduce to the non-degenerate segment and test inclusively.
+    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);
+    }
+    // All three distinct but collinear: test against hull segments.
+    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;
+  // Extract vertices of triangle A.
+  vertex1TriangleA = triangleA.a;
+  vertex2TriangleA = triangleA.b;
+  vertex3TriangleA = triangleA.c;
+  // Extract vertices of triangle B.
+  vertex1TriangleB = triangleB.a;
+  vertex2TriangleB = triangleB.b;
+  vertex3TriangleB = triangleB.c;
+  // Step 1: Compute signed distances of Triangle A’s vertices relative to the plane defined by Triangle B.
+  tempVector1.copy(vertex1TriangleB).sub(vertex3TriangleB);
+  tempVector2.copy(vertex2TriangleB).sub(vertex3TriangleB);
+  normal2 = (new Vector3()).copy(tempVector1).cross(tempVector2);
+  tempVector1.copy(vertex1TriangleA).sub(vertex3TriangleB);
+  distanceVertex1A = tempVector1.dot(normal2);
+  tempVector1.copy(vertex2TriangleA).sub(vertex3TriangleB);
+  distanceVertex2A = tempVector1.dot(normal2);
+  tempVector1.copy(vertex3TriangleA).sub(vertex3TriangleB);
+  distanceVertex3A = tempVector1.dot(normal2);
+  if (((distanceVertex1A * distanceVertex2A) > 0) && ((distanceVertex1A * distanceVertex3A) > 0)) {
+    return false; // All vertices of Triangle A are on the same side of Triangle B’s plane.
+  }
+  
+  // Step 2: Compute signed distances of Triangle B’s vertices relative to the plane defined by Triangle A.
+  tempVector1.copy(vertex2TriangleA).sub(vertex1TriangleA);
+  tempVector2.copy(vertex3TriangleA).sub(vertex1TriangleA);
+  normal1 = (new Vector3()).copy(tempVector1).cross(tempVector2);
+  tempVector1.copy(vertex1TriangleB).sub(vertex3TriangleA);
+  distanceVertex1B = tempVector1.dot(normal1);
+  tempVector1.copy(vertex2TriangleB).sub(vertex3TriangleA);
+  distanceVertex2B = tempVector1.dot(normal1);
+  tempVector1.copy(vertex3TriangleB).sub(vertex3TriangleA);
+  distanceVertex3B = tempVector1.dot(normal1);
+  if (((distanceVertex1B * distanceVertex2B) > 0) && ((distanceVertex1B * distanceVertex3B) > 0)) {
+    return false; // All vertices of Triangle B are on the same side of Triangle A’s plane.
+  }
+  
+  // Step 3: At this point, neither triangle is fully on one side of the other’s plane. This means the triangles potentially intersect.
+  // Next, we use the vertex signed distances to decide which configuration applies and call `resolveTriangleIntersection` (or `resolveCoplanarTriangleIntersection` if the triangles are coplanar).
+  additions.normal1 = normal1;
+  additions.normal2 = normal2;
+  // Decide how to proceed by looking at the signs of distanceVertex1A, distanceVertex2A and distanceVertex3A.
+  // These numbers tell us whether each vertex of Triangle A sits above the flat surface of Triangle B (positive), below it (negative), or exactly on it (zero).
+  // We then pass the vertices to the resolver in a stable order: the single “different-side” vertex first, followed by the two vertices that are on the same side.
+  if (distanceVertex1A > 0) {
+    // If distanceVertex1A is positive (the first vertex of Triangle A is above Triangle B's surface):
+    if (distanceVertex2A > 0) {
+      // Then distanceVertex2A is also positive, while distanceVertex3A is zero or negative.
+      // In plain terms: the third vertex of Triangle A lies on the other side of Triangle B’s surface (or exactly on it).
+      return resolveTriangleIntersection(vertex3TriangleA, vertex1TriangleA, vertex2TriangleA, vertex1TriangleB, vertex3TriangleB, vertex2TriangleB, distanceVertex1B, distanceVertex3B, distanceVertex2B, additions);
+    } else if (distanceVertex3A > 0) {
+      // Then distanceVertex3A is positive, while distanceVertex2A is zero or negative.
+      // That means the second vertex of Triangle A is the one on the other side (or exactly on the surface).
+      return resolveTriangleIntersection(vertex2TriangleA, vertex3TriangleA, vertex1TriangleA, vertex1TriangleB, vertex3TriangleB, vertex2TriangleB, distanceVertex1B, distanceVertex3B, distanceVertex2B, additions);
+    } else {
+      // Here only the first vertex is above the surface; the second and third are on or below it.
+      return resolveTriangleIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, distanceVertex1B, distanceVertex2B, distanceVertex3B, additions);
+    }
+  } else if (distanceVertex1A < 0) {
+    // If distanceVertex1A is negative (the first vertex of Triangle A is below Triangle B's surface):
+    if (distanceVertex2A < 0) {
+      // Then distanceVertex2A is also negative, while distanceVertex3A is zero or positive.
+      // In other words: the third vertex of Triangle A is on the other side (or exactly on the surface).
+      return resolveTriangleIntersection(vertex3TriangleA, vertex1TriangleA, vertex2TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, distanceVertex1B, distanceVertex2B, distanceVertex3B, additions);
+    } else if (distanceVertex3A < 0) {
+      // Then distanceVertex3A is negative, while distanceVertex2A is zero or positive.
+      // So the second vertex is the one on the other side (or exactly on the surface).
+      return resolveTriangleIntersection(vertex2TriangleA, vertex3TriangleA, vertex1TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, distanceVertex1B, distanceVertex2B, distanceVertex3B, additions);
+    } else {
+      // Only the first vertex is below the surface; the second and third are on or above it.
+      // Note: We also swap the order of Triangle B’s vertices here to keep a consistent “one different, two the same” pattern for the resolver.
+      return resolveTriangleIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex3TriangleB, vertex2TriangleB, distanceVertex1B, distanceVertex3B, distanceVertex2B, additions);
+    }
+  } else {
+    // Then the first vertex of Triangle A lies exactly on Triangle B’s surface (distanceVertex1A is zero).
+    // We look at distanceVertex2A and distanceVertex3A to decide which side the other vertices are on.
+    if (distanceVertex2A < 0) {
+      if (distanceVertex3A >= 0) {
+        // The second vertex is below the surface, while the third is on or above it.
+        return resolveTriangleIntersection(vertex2TriangleA, vertex3TriangleA, vertex1TriangleA, vertex1TriangleB, vertex3TriangleB, vertex2TriangleB, distanceVertex1B, distanceVertex3B, distanceVertex2B, additions);
+      } else {
+        // Both the second and third vertices are below the surface.
+        return resolveTriangleIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, distanceVertex1B, distanceVertex2B, distanceVertex3B, additions);
+      }
+    } else if (distanceVertex2A > 0) {
+      if (distanceVertex3A > 0) {
+        // Both the second and third vertices are above the surface.
+        return resolveTriangleIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex3TriangleB, vertex2TriangleB, distanceVertex1B, distanceVertex3B, distanceVertex2B, additions);
+      } else {
+        // The second vertex is above the surface, while the third is on or below it.
+        return resolveTriangleIntersection(vertex2TriangleA, vertex3TriangleA, vertex1TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, distanceVertex1B, distanceVertex2B, distanceVertex3B, additions);
+      }
+    } else {
+      if (distanceVertex3A > 0) {
+        // The second vertex is exactly on the surface, and the third is above it.
+        return resolveTriangleIntersection(vertex3TriangleA, vertex1TriangleA, vertex2TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, distanceVertex1B, distanceVertex2B, distanceVertex3B, additions);
+      } else if (distanceVertex3A < 0) {
+        // The second vertex is exactly on the surface, and the third is below it.
+        return resolveTriangleIntersection(vertex3TriangleA, vertex1TriangleA, vertex2TriangleA, vertex1TriangleB, vertex3TriangleB, vertex2TriangleB, distanceVertex1B, distanceVertex3B, distanceVertex2B, additions);
+      } else {
+        additions.coplanar = true; // All three vertices of Triangle A lie in Triangle B's plane.
+        return resolveCoplanarTriangleIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, normal1, normal2);
+      }
+    }
+  }
+};
+
+resolveTriangleIntersection = function(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, distanceVertex1B, distanceVertex2B, distanceVertex3B, additions) {
+  // Early exit → If all B's distances are strictly positive (totally outside/above) or negative (totally outside/below), there's no intersection.
+  if ((distanceVertex1B > 0 && distanceVertex2B > 0 && distanceVertex3B > 0) || (distanceVertex1B < 0 && distanceVertex2B < 0 && distanceVertex3B < 0)) {
+    return false;
+  }
+  if (distanceVertex1B > 0) { // First vertex of Triangle B is above (positive side of) Triangle A's plane.
+    if (distanceVertex2B > 0) { // First two vertices of B are positive, third is zero or negative.
+      return constructIntersection(vertex1TriangleA, vertex3TriangleA, vertex2TriangleA, vertex3TriangleB, vertex1TriangleB, vertex2TriangleB, additions); // Reorder B as (C, A, B) so differing vertex is last.
+    } else if (distanceVertex3B > 0) { // First and third vertices of B are positive, second is zero or negative.
+      return constructIntersection(vertex1TriangleA, vertex3TriangleA, vertex2TriangleA, vertex2TriangleB, vertex3TriangleB, vertex1TriangleB, additions); // Reorder B as (B, C, A).
+// Only first vertex of B is positive.
+    } else {
+      return constructIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, additions); // Pass original B ordering.
+    }
+  } else if (distanceVertex1B < 0) { // First vertex of Triangle B is below (negative side of) Triangle A's plane.
+    if (distanceVertex2B < 0) { // First two vertices of B are negative, third is zero or positive.
+      return constructIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex3TriangleB, vertex1TriangleB, vertex2TriangleB, additions); // Reorder B as (C, A, B) so differing vertex is last.
+    } else if (distanceVertex3B < 0) { // First and third vertices of B are negative, second is zero or positive.
+      return constructIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex2TriangleB, vertex3TriangleB, vertex1TriangleB, additions); // Reorder B as (B, C, A).
+// Only first vertex of B is negative.
+    } else {
+      return constructIntersection(vertex1TriangleA, vertex3TriangleA, vertex2TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, additions); // Pass A, reordered B.
+  // First vertex of Triangle B is exactly on the plane (distance zero).
+    }
+  } else {
+    if (distanceVertex2B < 0) { // Second vertex is negative, third will decide.
+      if (distanceVertex3B >= 0) { // Second negative, third zero or positive.
+        return constructIntersection(vertex1TriangleA, vertex3TriangleA, vertex2TriangleA, vertex2TriangleB, vertex3TriangleB, vertex1TriangleB, additions); // Mixed across the plane.
+// Second & third negative.
+      } else {
+        return constructIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, additions); // Only first on the plane.
+      }
+    } else if (distanceVertex2B > 0) { // Second vertex is positive.
+      if (distanceVertex3B > 0) { // Both second and third are positive.
+        return constructIntersection(vertex1TriangleA, vertex3TriangleA, vertex2TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, additions); // Both above the plane.
+// Second positive, third zero or negative.
+      } else {
+        return constructIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex2TriangleB, vertex3TriangleB, vertex1TriangleB, additions); // Mixed, split across plane.
+    // Second vertex is exactly on the plane (zero).
+      }
+    } else {
+      if (distanceVertex3B > 0) { // Only third is positive.
+        return constructIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex3TriangleB, vertex1TriangleB, vertex2TriangleB, additions); // Third above, first/second on plane.
+      } else if (distanceVertex3B < 0) { // Only third is negative.
+        return constructIntersection(vertex1TriangleA, vertex3TriangleA, vertex2TriangleA, vertex3TriangleB, vertex1TriangleB, vertex2TriangleB, additions); // Third below plane.
+// All three B vertices are exactly on the plane (coplanar).
+      } else {
+        additions.coplanar = true; // Mark coplanar.
+        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;
+  // Prepare 2D projected vertices.
+  vertex1TriangleA2D = new Vector2();
+  vertex2TriangleA2D = new Vector2();
+  vertex3TriangleA2D = new Vector2();
+  vertex1TriangleB2D = new Vector2();
+  vertex2TriangleB2D = new Vector2();
+  vertex3TriangleB2D = new Vector2();
+  // Absolute values of the triangle's normal components.
+  // Used to determine the dominant axis, which we drop during 2D projection.
+  normalAbsX = Math.abs(normalTriangleA.x);
+  normalAbsY = Math.abs(normalTriangleA.y);
+  normalAbsZ = Math.abs(normalTriangleA.z);
+  // Project triangles into 2D by dropping the dominant axis of the normal.
+  if ((normalAbsX > normalAbsZ) && (normalAbsX >= normalAbsY)) { // Project onto YZ plane.
+    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)) { // Project onto XZ plane.
+    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); // Project onto XY plane
+  } 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;
+  // Early handle point-degenerate cases explicitly and efficiently.
+  if (pointsEqual2D(vertex1TriangleB, vertex2TriangleB, EPS2D) && pointsEqual2D(vertex2TriangleB, vertex3TriangleB, EPS2D)) {
+    return pointInTriangleInclusive2D(vertex1TriangleB, vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, EPS2D);
+  }
+  if (pointsEqual2D(vertex1TriangleA, vertex2TriangleA, EPS2D) && pointsEqual2D(vertex2TriangleA, vertex3TriangleA, EPS2D)) {
+    return pointInTriangleInclusive2D(vertex1TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, EPS2D);
+  }
+  // If both are line-degenerate (not points): reduce to segment overlap test.
+  isLineDegenerate = function(v1, v2, v3) {
+    return (pointsEqual2D(v1, v2, EPS2D) && !pointsEqual2D(v2, v3, EPS2D)) || (pointsEqual2D(v2, v3, EPS2D) && !pointsEqual2D(v1, v2, EPS2D)) || (pointsEqual2D(v3, v1, EPS2D) && !pointsEqual2D(v1, v2, EPS2D));
+  };
+  extractSegment = function(v1, v2, v3) {
+    // Return the two distinct endpoints in stable order.
+    if (pointsEqual2D(v1, v2, EPS2D)) {
+      return [v2, v3];
+    } else if (pointsEqual2D(v2, v3, EPS2D)) {
+      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);
+    // Fast reject by axis-aligned bounding boxes.
+    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 - EPS2D || maxBx < minAx - EPS2D || maxAy < minBy - EPS2D || maxBy < minAy - EPS2D) {
+      return false;
+    }
+    // Collinear check: orientation of any mixed triple should be ~0; since we know each triangle is a line, test one.
+    if (Math.abs(triangleOrientation2D(aS, aE, bS)) > EPS2D) {
+      return false;
+    }
+    // 1D overlap test along dominant axis (choose axis with larger span to reduce precision issues).
+    spanAx = Math.abs(aE.x - aS.x);
+    spanAy = Math.abs(aE.y - aS.y);
+    if (spanAx >= spanAy) {
+      // Project onto X.
+      aMin = Math.min(aS.x, aE.x) - EPS2D;
+      aMax = Math.max(aS.x, aE.x) + EPS2D;
+      bMin = Math.min(bS.x, bE.x) - EPS2D;
+      bMax = Math.max(bS.x, bE.x) + EPS2D;
+      return !(aMax < bMin || bMax < aMin);
+    } else {
+      aMin = Math.min(aS.y, aE.y) - EPS2D;
+      aMax = Math.max(aS.y, aE.y) + EPS2D;
+      bMin = Math.min(bS.y, bE.y) - EPS2D;
+      bMax = Math.max(bS.y, bE.y) + EPS2D;
+      return !(aMax < bMin || bMax < aMin);
+    }
+  }
+  if (triangleOrientation2D(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA) < 0) { // If triangle A is CW.
+    if (triangleOrientation2D(vertex1TriangleB, vertex2TriangleB, vertex3TriangleB) < 0) { // If both A and B are CW → reorder both.
+      return triangleIntersectionCCW2D(vertex1TriangleA, vertex3TriangleA, vertex2TriangleA, vertex1TriangleB, vertex3TriangleB, vertex2TriangleB); // Only A is CW → reorder A.
+    } else {
+      return triangleIntersectionCCW2D(vertex1TriangleA, vertex3TriangleA, vertex2TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB); // Triangle A is CCW.
+    }
+  } else {
+    if (triangleOrientation2D(vertex1TriangleB, vertex2TriangleB, vertex3TriangleB) < 0) { // If only B is CW → reorder B.
+      return triangleIntersectionCCW2D(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex3TriangleB, vertex2TriangleB); // Both A and B are CCW → no reordering.
+    } else {
+      return triangleIntersectionCCW2D(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB);
+    }
+  }
+};
+
+triangleOrientation2D = function(a, b, c) {
+  // Compute the signed area of the triangle (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 vertex1TriangleB is on or to the left of edge vertex1TriangleA-vertex2TriangleA-vertex3TriangleA.
+  if (triangleOrientation2D(vertex1TriangleB, vertex2TriangleB, vertex1TriangleA) >= 0) {
+    // If vertex2TriangleB is on or to the left of edge vertex2TriangleA-vertex3TriangleA-vertex1TriangleA.
+    if (triangleOrientation2D(vertex2TriangleB, vertex3TriangleB, vertex1TriangleA) >= 0) {
+      // If vertex3TriangleB is on or to the left of edge vertex3TriangleA-vertex1TriangleA-vertex1TriangleA.
+      if (triangleOrientation2D(vertex3TriangleB, vertex1TriangleB, vertex1TriangleA) >= 0) {
+        return true; // All vertices of B are inside A.
+// Then vertex3TriangleB is outside, test edge intersection.
+      } else {
+        return intersectionTestEdge2D(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB); // Then vertex2TriangleB is outside.
+      }
+    } else {
+      
+      // If vertex3TriangleB is on or to the left of edge vertex3TriangleA-vertex1TriangleA-vertex1TriangleA, test edge intersection.
+      if (triangleOrientation2D(vertex3TriangleB, vertex1TriangleB, vertex1TriangleA) >= 0) {
+        return intersectionTestEdge2D(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex3TriangleB, vertex1TriangleB, vertex2TriangleB); // Then both vertex2TriangleB and vertex3TriangleB are outside, test vertex intersection.
+      } else {
+        return intersectionTestVertex2D(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB); // Then vertex2TriangleB is on or to the left of edge vertex2TriangleA-vertex3TriangleA-vertex1TriangleA.
+      }
+    }
+  } else {
+    
+    // If vertex2TriangleB is on or to the left of edge vertex2TriangleA-vertex3TriangleA-vertex1TriangleA.
+    if (triangleOrientation2D(vertex2TriangleB, vertex3TriangleB, vertex1TriangleA) >= 0) {
+      // If vertex3TriangleB is on or to the left of edge vertex3TriangleA-vertex1TriangleA-vertex1TriangleA, test edge intersection.
+      if (triangleOrientation2D(vertex3TriangleB, vertex1TriangleB, vertex1TriangleA) >= 0) {
+        return intersectionTestEdge2D(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex2TriangleB, vertex3TriangleB, vertex1TriangleB); // Then vertex3TriangleB is outside, test vertex intersection.
+      } else {
+        return intersectionTestVertex2D(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex2TriangleB, vertex3TriangleB, vertex1TriangleB); // Then both vertex1TriangleB and vertex2TriangleB are outside, test vertex intersection.
+      }
+    } 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(a1, a2, b1, b2) {
+    var maxAx, maxAy, maxBx, maxBy, minAx, minAy, minBx, minBy, o1, o2, o3, o4;
+    // Fast reject by bounding boxes.
+    minAx = Math.min(a1.x, a2.x);
+    maxAx = Math.max(a1.x, a2.x);
+    minAy = Math.min(a1.y, a2.y);
+    maxAy = Math.max(a1.y, a2.y);
+    minBx = Math.min(b1.x, b2.x);
+    maxBx = Math.max(b1.x, b2.x);
+    minBy = Math.min(b1.y, b2.y);
+    maxBy = Math.max(b1.y, b2.y);
+    if (maxAx < minBx || maxBx < minAx || maxAy < minBy || maxBy < minAy) {
+      return false;
+    }
+    o1 = triangleOrientation2D(a1, a2, b1);
+    o2 = triangleOrientation2D(a1, a2, b2);
+    o3 = triangleOrientation2D(b1, b2, a1);
+    o4 = triangleOrientation2D(b1, b2, a2);
+    if ((o1 > 0 && o2 < 0 || o1 < 0 && o2 > 0) && (o3 > 0 && o4 < 0 || o3 < 0 && o4 > 0)) {
+      return true; // Proper intersection.
+    }
+    
+    // Collinear / endpoint inclusion checks.
+    if (Math.abs(o1) <= EPS2D && pointOnSegmentInclusive2D(b1, a1, a2, EPS2D)) {
+      return true;
+    }
+    if (Math.abs(o2) <= EPS2D && pointOnSegmentInclusive2D(b2, a1, a2, EPS2D)) {
+      return true;
+    }
+    if (Math.abs(o3) <= EPS2D && pointOnSegmentInclusive2D(a1, b1, b2, EPS2D)) {
+      return true;
+    }
+    if (Math.abs(o4) <= EPS2D && pointOnSegmentInclusive2D(a2, b1, b2, EPS2D)) {
+      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, EPS2D)) {
+    // Returns true if any vertex of triangle B lies inside (or on) triangle A OR any vertex of triangle A lies inside (or on) triangle B.
+    return true;
+  }
+  if (pointInTriangleInclusive2D(vertex2TriangleB, vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, EPS2D)) {
+    return true;
+  }
+  if (pointInTriangleInclusive2D(vertex3TriangleB, vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, EPS2D)) {
+    return true;
+  }
+  if (pointInTriangleInclusive2D(vertex1TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, EPS2D)) {
+    return true;
+  }
+  if (pointInTriangleInclusive2D(vertex2TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, EPS2D)) {
+    return true;
+  }
+  if (pointInTriangleInclusive2D(vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, EPS2D)) {
+    return true;
+  }
+  return false;
+};
+
+constructIntersection = function(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, additions) {
+  var alpha, crossNormal;
+  alpha = void 0;
+  crossNormal = new Vector3();
+  // Compute cross product for triangle orientation.
+  tempVector1.subVectors(vertex2TriangleA, vertex1TriangleA);
+  tempVector2.subVectors(vertex3TriangleB, vertex1TriangleA);
+  crossNormal.copy(tempVector1).cross(tempVector2);
+  tempVector3.subVectors(vertex1TriangleB, vertex1TriangleA);
+  if (tempVector3.dot(crossNormal) > 0) {
+    // Check orientation with triangle A's third vertex.
+    tempVector1.subVectors(vertex3TriangleA, vertex1TriangleA);
+    crossNormal.copy(tempVector1).cross(tempVector2);
+    if (tempVector3.dot(crossNormal) <= 0) {
+      // Check orientation with triangle B's second vertex.
+      tempVector2.subVectors(vertex2TriangleB, vertex1TriangleA);
+      crossNormal.copy(tempVector1).cross(tempVector2);
+      if (tempVector3.dot(crossNormal) > 0) {
+        // Compute intersection segment endpoints (case 1).
+        tempVector1.subVectors(vertex1TriangleA, vertex1TriangleB);
+        tempVector2.subVectors(vertex1TriangleA, vertex3TriangleA);
+        alpha = tempVector1.dot(additions.normal2) / tempVector2.dot(additions.normal2);
+        if (!isFinite(alpha)) {
+          return false;
+        }
+        tempVector1.copy(tempVector2).multiplyScalar(alpha);
+        additions.source.subVectors(vertex1TriangleA, tempVector1);
+        tempVector1.subVectors(vertex1TriangleB, vertex1TriangleA);
+        tempVector2.subVectors(vertex1TriangleB, vertex3TriangleB);
+        alpha = tempVector1.dot(additions.normal1) / tempVector2.dot(additions.normal1);
+        if (!isFinite(alpha)) {
+          return false;
+        }
+        tempVector1.copy(tempVector2).multiplyScalar(alpha);
+        additions.target.subVectors(vertex1TriangleB, tempVector1);
+        return true;
+      } else {
+        // Compute intersection segment endpoints (case 2).
+        tempVector1.subVectors(vertex1TriangleB, vertex1TriangleA);
+        tempVector2.subVectors(vertex1TriangleB, vertex2TriangleB);
+        alpha = tempVector1.dot(additions.normal1) / tempVector2.dot(additions.normal1);
+        if (!isFinite(alpha)) {
+          return false;
+        }
+        tempVector1.copy(tempVector2).multiplyScalar(alpha);
+        additions.source.subVectors(vertex1TriangleB, tempVector1);
+        tempVector1.subVectors(vertex1TriangleB, vertex1TriangleA);
+        tempVector2.subVectors(vertex1TriangleB, vertex3TriangleB);
+        alpha = tempVector1.dot(additions.normal1) / tempVector2.dot(additions.normal1);
+        if (!isFinite(alpha)) {
+          return false;
+        }
+        tempVector1.copy(tempVector2).multiplyScalar(alpha);
+        additions.target.subVectors(vertex1TriangleB, tempVector1);
+        return true;
+      }
+    } else {
+      return false; // No intersection, orientation test failed.
+    }
+  } else {
+    tempVector2.subVectors(vertex2TriangleB, vertex1TriangleA);
+    crossNormal.copy(tempVector1).cross(tempVector2);
+    if (tempVector3.dot(crossNormal) < 0) {
+      return false; // No intersection, orientation test failed.
+    } else {
+      tempVector1.subVectors(vertex3TriangleA, vertex1TriangleA);
+      crossNormal.copy(tempVector1).cross(tempVector2);
+      if (tempVector3.dot(crossNormal) < 0) {
+        // Compute intersection segment endpoints (case 3).
+        tempVector1.subVectors(vertex1TriangleB, vertex1TriangleA);
+        tempVector2.subVectors(vertex1TriangleB, vertex2TriangleB);
+        alpha = tempVector1.dot(additions.normal1) / tempVector2.dot(additions.normal1);
+        if (!isFinite(alpha)) {
+          return false;
+        }
+        tempVector1.copy(tempVector2).multiplyScalar(alpha);
+        additions.source.subVectors(vertex1TriangleB, tempVector1);
+        tempVector1.subVectors(vertex1TriangleB, vertex1TriangleA);
+        tempVector2.subVectors(vertex1TriangleB, vertex3TriangleB);
+        alpha = tempVector1.dot(additions.normal1) / tempVector2.dot(additions.normal1);
+        if (!isFinite(alpha)) {
+          return false;
+        }
+        tempVector1.copy(tempVector2).multiplyScalar(alpha);
+        additions.target.subVectors(vertex1TriangleB, tempVector1);
+        return true;
+      } else {
+        // Compute intersection segment endpoints (case 4).
+        tempVector1.subVectors(vertex1TriangleA, vertex1TriangleB);
+        tempVector2.subVectors(vertex1TriangleA, vertex3TriangleA);
+        alpha = tempVector1.dot(additions.normal2) / tempVector2.dot(additions.normal2);
+        if (!isFinite(alpha)) {
+          return false;
+        }
+        tempVector1.copy(tempVector2).multiplyScalar(alpha);
+        additions.source.subVectors(vertex1TriangleA, tempVector1);
+        tempVector1.subVectors(vertex1TriangleA, vertex1TriangleB);
+        tempVector2.subVectors(vertex1TriangleA, vertex2TriangleA);
+        alpha = tempVector1.dot(additions.normal2) / tempVector2.dot(additions.normal2);
+        if (!isFinite(alpha)) {
+          return false;
+        }
+        tempVector1.copy(tempVector2).multiplyScalar(alpha);
+        additions.target.subVectors(vertex1TriangleA, tempVector1);
+        return true;
+      }
+    }
+  }
+  return false; // If none of the above, no intersection found.
+};
+// Generated by CoffeeScript 2.7.0
+module.exports.Polytree = Polytree;
+
+module.exports.Plane = Plane;
+
+module.exports.Vertex = Vertex;
+
+module.exports.Polygon = Polygon;
+
+module.exports.rayIntersectsTriangle = rayIntersectsTriangle;
+
+module.exports.triangleIntersectsTriangle = triangleIntersectsTriangle;
+
+module.exports.resolveTriangleIntersection = resolveTriangleIntersection;
+
+module.exports.resolveCoplanarTriangleIntersection = resolveCoplanarTriangleIntersection;
+
+module.exports.trianglesOverlap2D = trianglesOverlap2D;
+
+module.exports.triangleOrientation2D = triangleOrientation2D;
+
+module.exports.triangleIntersectionCCW2D = triangleIntersectionCCW2D;
+
+module.exports.intersectionTestEdge2D = intersectionTestEdge2D;
+
+module.exports.intersectionTestVertex2D = intersectionTestVertex2D;
+
+module.exports.constructIntersection = constructIntersection;