@jgphilpott/polytree 0.0.1

package/polytree.js

@@ -0,0 +1,2938 @@
+// Generated by CoffeeScript 2.7.0
+var BACK, Box3, BufferAttribute, BufferGeometry, COPLANAR, CSG_Rules, DoubleSide, EPSILON, FRONT, Matrix3, Mesh, OctreeCSG, Plane, Polygon, RAY_EPSILON, Ray, Raycaster, SPANNING, Triangle, Vector2, Vector3, Vertex, _asyncUnionArrayID, _asyncUnionID, _box3$1, _matrix3, _normal1, _polygonID, _ray, _rayDirection, _raycaster1, _v1, _v2, _wP, _wP_EPS_ARR, _wP_EPS_ARR_COUNT, _wV1, _wV2, _wV3, calcWindingNumber_buffer, disposeOctree, edge1, edge2, h, handleIntersectingOctrees, handleObjectForOp, handleObjectForOp_async, isUniqueTriangle, isValidTriangle, nbuf2, nbuf3, pointRounding, polyInside_WindingNumber_buffer, prepareTriangleBuffer, q, rayIntersectsTriangle, raycastIntersectAscSort, returnXYZ, s, splitPolygonArr, splitPolygonByPlane, tmpm3, triangleIntersectsTriangle, ttvv0, tv0, tv1, wNPI;
+
+({Vector2, Vector3, Box3, DoubleSide, Matrix3, Ray, Triangle, BufferGeometry, BufferAttribute, Mesh, Raycaster} = require("three"));
+
+({triangleIntersectsTriangle} = require("./src/triangle.intersection.js"));
+
+_v1 = new Vector3();
+
+_v2 = new Vector3();
+
+_box3$1 = new Box3();
+
+tv0 = new Vector3();
+
+tv1 = new Vector3();
+
+_raycaster1 = new Raycaster();
+
+_ray = new Ray();
+
+_rayDirection = new Vector3(0, 0, 1);
+
+EPSILON = 1e-5;
+
+COPLANAR = 0;
+
+FRONT = 1;
+
+BACK = 2;
+
+SPANNING = 3;
+
+_polygonID = 0;
+
+OctreeCSG = class OctreeCSG {
+  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;
+    // @isOctree = 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;
+  }
+
+  newOctree(box, parent) {
+    return new this.constructor(box, parent);
+  }
+
+  split(level) {
+    var box, found, halfsize, i, i1, k, l, len, m, o, polygon, ref, ref1, subTrees, v, x, y, z;
+    if (!this.box) {
+      return;
+    }
+    subTrees = [];
+    halfsize = _v2.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();
+          v = _v1.set(x, y, z);
+          box.min.copy(this.box.min).add(v.multiply(halfsize));
+          box.max.copy(box.min).add(halfsize);
+          box.expandByScalar(EPSILON);
+          subTrees.push(this.newOctree(box, this));
+        }
+      }
+    }
+    polygon = void 0;
+    while (polygon = this.polygons.pop()) {
+      found = false;
+      for (i = o = 0, ref = subTrees.length; (0 <= ref ? o < ref : o > ref); i = 0 <= ref ? ++o : --o) {
+        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 = i1 = 0, ref1 = subTrees.length; (0 <= ref1 ? i1 < ref1 : i1 > ref1); i = 0 <= ref1 ? ++i1 : --i1) {
+      subTrees[i].level = level + 1;
+      len = subTrees[i].polygons.length;
+      // if (len !== 0) {
+      if (len > OctreeCSG.polygonsPerTree && level < OctreeCSG.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()) {
+      _box3$1.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 (OctreeCSG.rayIntersectTriangleType === "regular") {
+        result = ray.intersectTriangle(polygons[i].triangle.a, polygons[i].triangle.b, polygons[i].triangle.c, false, _v1);
+        if (result) {
+          _v1.applyMatrix4(matrixWorld);
+          distance = _v1.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: _v1.clone()
+            });
+          }
+        }
+      } else {
+        result = rayIntersectsTriangle(ray, polygons[i].triangle, _v1);
+        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(targetOctree) {
+    return this.polygonArrays.forEach(function(polygonsArray) {
+      if (polygonsArray.length) {
+        return polygonsArray.forEach(function(polygon) {
+          return polygon.intersects = targetOctree.isPolygonIntersecting(polygon);
+        });
+      }
+    });
+  }
+
+  // if @polygons.length > 0
+  //     @polygons.forEach (polygon) ->
+  //         polygon.intersects = targetOctree.isPolygonIntersecting(polygon)
+  // for i in [0...@subTrees.length]
+  //     @subTrees[i].markIntesectingPolygons(targetOctree)
+  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(targetOctree, targetOctreeBuffer) {
+    var currentPolygon, i, i1, inside, intersects, j, k, l, m, 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 = targetOctree.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 targetOctree.box.containsPoint(currentPolygon.getMidpoint())
+    //             if OctreeCSG.useWindingNumber is true
+    //                 inside = polyInside_WindingNumber_buffer(targetOctreeBuffer, currentPolygon.getMidpoint(), currentPolygon.coplanar)
+    //             else
+    //                 point = pointRounding(_v2.copy(currentPolygon.getMidpoint()))
+    //                 if OctreeCSG.useOctreeRay isnt true and targetOctree.mesh
+    //                     _rayDirection.copy(currentPolygon.plane.normal)
+    //                     _raycaster1.set(point, _rayDirection)
+    //                     intersects = _raycaster1.intersectObject(targetOctree.mesh)
+    //                     if intersects.length
+    //                         if _rayDirection.dot(intersects[0].face.normal) > 0
+    //                             inside = true
+    //                     unless inside or not currentPolygon.coplanar
+    //                         for j in [0..._wP_EPS_ARR_COUNT]
+    //                             _raycaster1.ray.origin.copy(point).add(_wP_EPS_ARR[j])
+    //                             intersects = _raycaster1.intersectObject(targetOctree.mesh)
+    //                             if intersects.length
+    //                                 if _rayDirection.dot(intersects[0].face.normal) > 0
+    //                                     inside = true
+    //                                     break
+    //                 else
+    //                     _ray.origin.copy(point)
+    //                     _rayDirection.copy(currentPolygon.plane.normal)
+    //                     _ray.direction.copy(currentPolygon.plane.normal)
+    //                     intersects = targetOctree.rayIntersect(_ray, targetOctree.originalMatrixWorld)
+    //                     if intersects.length
+    //                         if _rayDirection.dot(intersects[0].polygon.plane.normal) > 0
+    //                             inside = true
+    //                     unless inside or not currentPolygon.coplanar
+    //                         for j in [0..._wP_EPS_ARR_COUNT]
+    //                             _ray.origin.copy(point).add(_wP_EPS_ARR[j])
+    //                             _rayDirection.copy(currentPolygon.plane.normal)
+    //                             _ray.direction.copy(currentPolygon.plane.normal)
+    //                             intersects = targetOctree.rayIntersect(_ray, targetOctree.originalMatrixWorld)
+    //                             if intersects.length
+    //                                 if _rayDirection.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(targetOctree, targetOctreeBuffer)
+    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 = targetOctree.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 (targetOctree.box.containsPoint(currentPolygon.getMidpoint())) {
+          if (OctreeCSG.useWindingNumber === true) {
+            inside = polyInside_WindingNumber_buffer(targetOctreeBuffer, currentPolygon.getMidpoint(), currentPolygon.coplanar);
+          } else {
+            point = pointRounding(_v2.copy(currentPolygon.getMidpoint()));
+            if (OctreeCSG.useOctreeRay !== true && targetOctree.mesh) {
+              _rayDirection.copy(currentPolygon.plane.normal);
+              _raycaster1.set(point, _rayDirection);
+              intersects = _raycaster1.intersectObject(targetOctree.mesh);
+              if (intersects.length) {
+                if (_rayDirection.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) {
+                  _raycaster1.ray.origin.copy(point).add(_wP_EPS_ARR[j]);
+                  intersects = _raycaster1.intersectObject(targetOctree.mesh);
+                  if (intersects.length) {
+                    if (_rayDirection.dot(intersects[0].face.normal) > 0) {
+                      inside = true;
+                      break;
+                    }
+                  }
+                }
+              }
+            } else {
+              _ray.origin.copy(point);
+              _rayDirection.copy(currentPolygon.plane.normal);
+              _ray.direction.copy(currentPolygon.plane.normal);
+              intersects = targetOctree.rayIntersect(_ray, targetOctree.originalMatrixWorld);
+              if (intersects.length) {
+                if (_rayDirection.dot(intersects[0].polygon.plane.normal) > 0) {
+                  inside = true;
+                }
+              }
+              if (!(inside || !currentPolygon.coplanar)) {
+                for (j = o = 0, ref3 = _wP_EPS_ARR_COUNT; (0 <= ref3 ? o < ref3 : o > ref3); j = 0 <= ref3 ? ++o : --o) {
+                  _ray.origin.copy(point).add(_wP_EPS_ARR[j]);
+                  _rayDirection.copy(currentPolygon.plane.normal);
+                  _ray.direction.copy(currentPolygon.plane.normal);
+                  intersects = targetOctree.rayIntersect(_ray, targetOctree.originalMatrixWorld);
+                  if (intersects.length) {
+                    if (_rayDirection.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 = i1 = 0, ref4 = this.subTrees.length; (0 <= ref4 ? i1 < ref4 : i1 > ref4); i = 0 <= ref4 ? ++i1 : --i1) {
+      results1.push(this.subTrees[i].handleIntersectingPolygons(targetOctree, targetOctreeBuffer));
+    }
+    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)
+OctreeCSG.prototype.isOctree = 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 b, f, i, j, k, l, m, newPolys, npI, o, polygonType, ref, ref1, ref2, ref3, returnPolygon, t, ti, tj, type, types, v, vi, vj;
+  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) {
+    t = plane.normal.dot(polygon.vertices[i].pos) - plane.w;
+    type = t < -EPSILON ? BACK : t > 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:
+      f = [];
+      b = [];
+      for (i = l = 0, ref1 = polygon.vertices.length; (0 <= ref1 ? l < ref1 : l > ref1); i = 0 <= ref1 ? ++l : --l) {
+        j = (i + 1) % polygon.vertices.length;
+        ti = types[i];
+        tj = types[j];
+        vi = polygon.vertices[i];
+        vj = polygon.vertices[j];
+        if (ti !== BACK) {
+          f.push(vi);
+        }
+        if (ti !== FRONT) {
+          b.push(ti !== BACK ? vi.clone() : vi);
+        }
+        if ((ti | tj) === SPANNING) {
+          t = (plane.w - plane.normal.dot(vi.pos)) / plane.normal.dot(tv0.copy(vj.pos).sub(vi.pos));
+          v = vi.interpolate(vj, t);
+          f.push(v);
+          b.push(v.clone());
+        }
+      }
+      if (f.length >= 3) {
+        if (f.length > 3) {
+          newPolys = splitPolygonArr(f);
+          for (npI = m = 0, ref2 = newPolys.length; (0 <= ref2 ? m < ref2 : m > ref2); npI = 0 <= ref2 ? ++m : --m) {
+            result.push({
+              polygon: new Polygon(newPolys[npI], polygon.shared),
+              type: "front"
+            });
+          }
+        } else {
+          result.push({
+            polygon: new Polygon(f, polygon.shared),
+            type: "front"
+          });
+        }
+      }
+      if (b.length >= 3) {
+        if (b.length > 3) {
+          newPolys = splitPolygonArr(b);
+          for (npI = o = 0, ref3 = newPolys.length; (0 <= ref3 ? o < ref3 : o > ref3); npI = 0 <= ref3 ? ++o : --o) {
+            result.push({
+              polygon: new Polygon(newPolys[npI], polygon.shared),
+              type: "back"
+            });
+          }
+        } else {
+          result.push({
+            polygon: new Polygon(b, 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 OctreeCSG { };
+/*
+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
+*/
+OctreeCSG.union = function(octreeA, octreeB, buildTargetOctree = true) {
+  var currentMeshSideA, currentMeshSideB, octree, trianglesSet;
+  octree = new OctreeCSG();
+  trianglesSet = new Set();
+  if (octreeA.box.intersectsBox(octreeB.box)) {
+    currentMeshSideA = void 0;
+    currentMeshSideB = void 0;
+    if (octreeA.mesh) {
+      currentMeshSideA = octreeA.mesh.material.side;
+      octreeA.mesh.material.side = DoubleSide;
+    }
+    if (octreeB.mesh) {
+      currentMeshSideB = octreeB.mesh.material.side;
+      octreeB.mesh.material.side = DoubleSide;
+    }
+    octreeA.resetPolygons(false);
+    octreeB.resetPolygons(false);
+    octreeA.markIntesectingPolygons(octreeB);
+    octreeB.markIntesectingPolygons(octreeA);
+    handleIntersectingOctrees(octreeA, octreeB);
+    octreeA.deleteReplacedPolygons();
+    octreeB.deleteReplacedPolygons();
+    octreeA.deletePolygonsByStateRules(CSG_Rules.union.a);
+    octreeB.deletePolygonsByStateRules(CSG_Rules.union.b);
+    octreeA.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
+    octreeB.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
+    if (octreeA.mesh && octreeA.mesh.material.side !== currentMeshSideA) {
+      octreeA.mesh.material.side = currentMeshSideA;
+    }
+    if (octreeB.mesh && octreeB.mesh.material.side !== currentMeshSideB) {
+      octreeB.mesh.material.side = currentMeshSideB;
+    }
+  } else {
+    octreeA.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
+    octreeB.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
+  }
+  trianglesSet.clear();
+  trianglesSet = void 0;
+  octree.markPolygonsAsOriginal();
+  buildTargetOctree && octree.buildTree();
+  return octree;
+};
+
+OctreeCSG.subtract = function(octreeA, octreeB, buildTargetOctree = true) {
+  var currentMeshSideA, currentMeshSideB, octree, trianglesSet;
+  octree = new OctreeCSG();
+  trianglesSet = new Set();
+  if (octreeA.box.intersectsBox(octreeB.box)) {
+    currentMeshSideA = void 0;
+    currentMeshSideB = void 0;
+    if (octreeA.mesh) {
+      currentMeshSideA = octreeA.mesh.material.side;
+      octreeA.mesh.material.side = DoubleSide;
+    }
+    if (octreeB.mesh) {
+      currentMeshSideB = octreeB.mesh.material.side;
+      octreeB.mesh.material.side = DoubleSide;
+    }
+    octreeA.resetPolygons(false);
+    octreeB.resetPolygons(false);
+    octreeA.markIntesectingPolygons(octreeB);
+    octreeB.markIntesectingPolygons(octreeA);
+    handleIntersectingOctrees(octreeA, octreeB);
+    octreeA.deleteReplacedPolygons();
+    octreeB.deleteReplacedPolygons();
+    octreeA.deletePolygonsByStateRules(CSG_Rules.subtract.a);
+    octreeB.deletePolygonsByStateRules(CSG_Rules.subtract.b);
+    octreeB.deletePolygonsByIntersection(false);
+    octreeB.invert();
+    octreeA.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
+    octreeB.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
+    if (octreeA.mesh && octreeA.mesh.material.side !== currentMeshSideA) {
+      octreeA.mesh.material.side = currentMeshSideA;
+    }
+    if (octreeB.mesh && octreeB.mesh.material.side !== currentMeshSideB) {
+      octreeB.mesh.material.side = currentMeshSideB;
+    }
+  } else {
+    octreeA.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
+  }
+  trianglesSet.clear();
+  trianglesSet = void 0;
+  octree.markPolygonsAsOriginal();
+  buildTargetOctree && octree.buildTree();
+  // octree.invert()
+  return octree;
+};
+
+OctreeCSG.intersect = function(octreeA, octreeB, buildTargetOctree = true) {
+  var currentMeshSideA, currentMeshSideB, octree, trianglesSet;
+  octree = new OctreeCSG();
+  trianglesSet = new Set();
+  if (octreeA.box.intersectsBox(octreeB.box)) {
+    currentMeshSideA = void 0;
+    currentMeshSideB = void 0;
+    if (octreeA.mesh) {
+      currentMeshSideA = octreeA.mesh.material.side;
+      octreeA.mesh.material.side = DoubleSide;
+    }
+    if (octreeB.mesh) {
+      currentMeshSideB = octreeB.mesh.material.side;
+      octreeB.mesh.material.side = DoubleSide;
+    }
+    octreeA.resetPolygons(false);
+    octreeB.resetPolygons(false);
+    octreeA.markIntesectingPolygons(octreeB);
+    octreeB.markIntesectingPolygons(octreeA);
+    handleIntersectingOctrees(octreeA, octreeB);
+    octreeA.deleteReplacedPolygons();
+    octreeB.deleteReplacedPolygons();
+    octreeA.deletePolygonsByStateRules(CSG_Rules.intersect.a);
+    octreeB.deletePolygonsByStateRules(CSG_Rules.intersect.b);
+    octreeA.deletePolygonsByIntersection(false);
+    octreeB.deletePolygonsByIntersection(false);
+    octreeA.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
+    octreeB.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
+    if (octreeA.mesh && octreeA.mesh.material.side !== currentMeshSideA) {
+      octreeA.mesh.material.side = currentMeshSideA;
+    }
+    if (octreeB.mesh && octreeB.mesh.material.side !== currentMeshSideB) {
+      octreeB.mesh.material.side = currentMeshSideB;
+    }
+  }
+  trianglesSet.clear();
+  trianglesSet = void 0;
+  return octree.markPolygons;
+};
+
+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 OctreeCSG { };
+/*
+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
+*/
+OctreeCSG.union = function(octreeA, octreeB, buildTargetOctree = true) {
+  var currentMeshSideA, currentMeshSideB, octree, trianglesSet;
+  octree = new OctreeCSG();
+  trianglesSet = new Set();
+  if (octreeA.box.intersectsBox(octreeB.box)) {
+    currentMeshSideA = void 0;
+    currentMeshSideB = void 0;
+    if (octreeA.mesh) {
+      currentMeshSideA = octreeA.mesh.material.side;
+      octreeA.mesh.material.side = DoubleSide;
+    }
+    if (octreeB.mesh) {
+      currentMeshSideB = octreeB.mesh.material.side;
+      octreeB.mesh.material.side = DoubleSide;
+    }
+    octreeA.resetPolygons(false);
+    octreeB.resetPolygons(false);
+    octreeA.markIntesectingPolygons(octreeB);
+    octreeB.markIntesectingPolygons(octreeA);
+    handleIntersectingOctrees(octreeA, octreeB);
+    octreeA.deleteReplacedPolygons();
+    octreeB.deleteReplacedPolygons();
+    octreeA.deletePolygonsByStateRules(CSG_Rules.union.a);
+    octreeB.deletePolygonsByStateRules(CSG_Rules.union.b);
+    octreeA.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
+    octreeB.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
+    if (octreeA.mesh && octreeA.mesh.material.side !== currentMeshSideA) {
+      octreeA.mesh.material.side = currentMeshSideA;
+    }
+    if (octreeB.mesh && octreeB.mesh.material.side !== currentMeshSideB) {
+      octreeB.mesh.material.side = currentMeshSideB;
+    }
+  } else {
+    octreeA.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
+    octreeB.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
+  }
+  trianglesSet.clear();
+  trianglesSet = void 0;
+  octree.markPolygonsAsOriginal();
+  buildTargetOctree && octree.buildTree();
+  return octree;
+};
+
+OctreeCSG.subtract = function(octreeA, octreeB, buildTargetOctree = true) {
+  var currentMeshSideA, currentMeshSideB, octree, trianglesSet;
+  octree = new OctreeCSG();
+  trianglesSet = new Set();
+  if (octreeA.box.intersectsBox(octreeB.box)) {
+    currentMeshSideA = void 0;
+    currentMeshSideB = void 0;
+    if (octreeA.mesh) {
+      currentMeshSideA = octreeA.mesh.material.side;
+      octreeA.mesh.material.side = DoubleSide;
+    }
+    if (octreeB.mesh) {
+      currentMeshSideB = octreeB.mesh.material.side;
+      octreeB.mesh.material.side = DoubleSide;
+    }
+    octreeA.resetPolygons(false);
+    octreeB.resetPolygons(false);
+    octreeA.markIntesectingPolygons(octreeB);
+    octreeB.markIntesectingPolygons(octreeA);
+    handleIntersectingOctrees(octreeA, octreeB);
+    octreeA.deleteReplacedPolygons();
+    octreeB.deleteReplacedPolygons();
+    octreeA.deletePolygonsByStateRules(CSG_Rules.subtract.a);
+    octreeB.deletePolygonsByStateRules(CSG_Rules.subtract.b);
+    octreeB.deletePolygonsByIntersection(false);
+    octreeB.invert();
+    octreeA.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
+    octreeB.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
+    if (octreeA.mesh && octreeA.mesh.material.side !== currentMeshSideA) {
+      octreeA.mesh.material.side = currentMeshSideA;
+    }
+    if (octreeB.mesh && octreeB.mesh.material.side !== currentMeshSideB) {
+      octreeB.mesh.material.side = currentMeshSideB;
+    }
+  } else {
+    octreeA.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
+  }
+  trianglesSet.clear();
+  trianglesSet = void 0;
+  octree.markPolygonsAsOriginal();
+  buildTargetOctree && octree.buildTree();
+  // octree.invert()
+  return octree;
+};
+
+/*
+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
+*/
+OctreeCSG.intersect = function(octreeA, octreeB, buildTargetOctree = true) {
+  var currentMeshSideA, currentMeshSideB, octree, trianglesSet;
+  octree = new OctreeCSG();
+  trianglesSet = new Set();
+  if (octreeA.box.intersectsBox(octreeB.box)) {
+    currentMeshSideA = void 0;
+    currentMeshSideB = void 0;
+    if (octreeA.mesh) {
+      currentMeshSideA = octreeA.mesh.material.side;
+      octreeA.mesh.material.side = DoubleSide;
+    }
+    if (octreeB.mesh) {
+      currentMeshSideB = octreeB.mesh.material.side;
+      octreeB.mesh.material.side = DoubleSide;
+    }
+    octreeA.resetPolygons(false);
+    octreeB.resetPolygons(false);
+    octreeA.markIntesectingPolygons(octreeB);
+    octreeB.markIntesectingPolygons(octreeA);
+    handleIntersectingOctrees(octreeA, octreeB);
+    octreeA.deleteReplacedPolygons();
+    octreeB.deleteReplacedPolygons();
+    octreeA.deletePolygonsByStateRules(CSG_Rules.intersect.a);
+    octreeB.deletePolygonsByStateRules(CSG_Rules.intersect.b);
+    octreeA.deletePolygonsByIntersection(false);
+    octreeB.deletePolygonsByIntersection(false);
+    octreeA.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
+    octreeB.getPolygonCloneCallback(octree.addPolygon.bind(octree), trianglesSet);
+    if (octreeA.mesh) {
+      if (octreeA.mesh.material.side !== currentMeshSideA) {
+        octreeA.mesh.material.side = currentMeshSideA;
+      }
+    }
+    if (octreeB.mesh) {
+      if (octreeB.mesh.material.side !== currentMeshSideB) {
+        octreeB.mesh.material.side = currentMeshSideB;
+      }
+    }
+  }
+  trianglesSet.clear();
+  trianglesSet = void 0;
+  octree.markPolygonsAsOriginal();
+  buildTargetOctree && octree.buildTree();
+  return octree;
+};
+
+OctreeCSG.meshUnion = function(mesh1, mesh2, targetMaterial) {
+  var octreeA, octreeB, resultMesh, resultOctree;
+  octreeA = void 0;
+  octreeB = void 0;
+  if (targetMaterial && Array.isArray(targetMaterial)) {
+    octreeA = OctreeCSG.fromMesh(mesh1, 0);
+    octreeB = OctreeCSG.fromMesh(mesh2, 1);
+  } else {
+    octreeA = OctreeCSG.fromMesh(mesh1);
+    octreeB = OctreeCSG.fromMesh(mesh2);
+    targetMaterial = targetMaterial !== void 0 ? targetMaterial : (Array.isArray(mesh1.material) ? mesh1.material[0] : mesh1.material).clone();
+  }
+  resultOctree = OctreeCSG.union(octreeA, octreeB, false);
+  resultMesh = OctreeCSG.toMesh(resultOctree, targetMaterial);
+  disposeOctree(octreeA, octreeB, resultOctree);
+  return resultMesh;
+};
+
+OctreeCSG.meshSubtract = function(mesh1, mesh2, targetMaterial) {
+  var octreeA, octreeB, resultMesh, resultOctree;
+  octreeA = void 0;
+  octreeB = void 0;
+  if (targetMaterial && Array.isArray(targetMaterial)) {
+    octreeA = OctreeCSG.fromMesh(mesh1, 0);
+    octreeB = OctreeCSG.fromMesh(mesh2, 1);
+  } else {
+    octreeA = OctreeCSG.fromMesh(mesh1);
+    octreeB = OctreeCSG.fromMesh(mesh2);
+    targetMaterial = targetMaterial !== void 0 ? targetMaterial : (Array.isArray(mesh1.material) ? mesh1.material[0] : mesh1.material).clone();
+  }
+  resultOctree = OctreeCSG.subtract(octreeA, octreeB, false);
+  resultMesh = OctreeCSG.toMesh(resultOctree, targetMaterial);
+  disposeOctree(octreeA, octreeB, resultOctree);
+  return resultMesh;
+};
+
+OctreeCSG.meshIntersect = function(mesh1, mesh2, targetMaterial) {
+  var octreeA, octreeB, resultMesh, resultOctree;
+  octreeA = void 0;
+  octreeB = void 0;
+  if (targetMaterial && Array.isArray(targetMaterial)) {
+    octreeA = OctreeCSG.fromMesh(mesh1, 0);
+    octreeB = OctreeCSG.fromMesh(mesh2, 1);
+  } else {
+    octreeA = OctreeCSG.fromMesh(mesh1);
+    octreeB = OctreeCSG.fromMesh(mesh2);
+    targetMaterial = targetMaterial !== void 0 ? targetMaterial : (Array.isArray(mesh1.material) ? mesh1.material[0] : mesh1.material).clone();
+  }
+  resultOctree = OctreeCSG.intersect(octreeA, octreeB, false);
+  resultMesh = OctreeCSG.toMesh(resultOctree, targetMaterial);
+  disposeOctree(octreeA, octreeB, resultOctree);
+  return resultMesh;
+};
+
+_asyncUnionID = 0;
+
+_asyncUnionArrayID = 0;
+
+OctreeCSG.disposeOctree = true;
+
+OctreeCSG.async = {
+  batchSize: 100,
+  union: function(octreeA, octreeB, buildTargetOctree = true) {
+    return new Promise(function(resolve, reject) {
+      var e, result;
+      try {
+        // const id = _asyncUnionID++
+        // console.log("Promise Union ##{id} started")
+        result = OctreeCSG.union(octreeA, octreeB, buildTargetOctree);
+        resolve(result);
+        return disposeOctree(octreeA, octreeB);
+      } catch (error) {
+        e = error;
+        return reject(e);
+      }
+    });
+  },
+  subtract: function(octreeA, octreeB, buildTargetOctree = true) {
+    return new Promise(function(resolve, reject) {
+      var e, result;
+      try {
+        result = OctreeCSG.subtract(octreeA, octreeB, buildTargetOctree);
+        resolve(result);
+        return disposeOctree(octreeA, octreeB);
+      } catch (error) {
+        e = error;
+        return reject(e);
+      }
+    });
+  },
+  intersect: function(octreeA, octreeB, buildTargetOctree = true) {
+    return new Promise(function(resolve, reject) {
+      var e, result;
+      try {
+        result = OctreeCSG.intersect(octreeA, octreeB, buildTargetOctree);
+        resolve(result);
+        return disposeOctree(octreeA, octreeB);
+      } 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, leftOverOctree, mainOctree, mainOctreeUsed, materialIndex, octreesArray, promise, promises, ref, ref1, result, tempOctree, usingBatches;
+      try {
+        usingBatches = OctreeCSG.async.batchSize > 4 && OctreeCSG.async.batchSize < objArr.length;
+        // const id = _asyncUnionArrayID++
+        // console.log("Promise Union Array ##{id}", usingBatches)
+        mainOctree = void 0;
+        mainOctreeUsed = false;
+        promises = [];
+        if (usingBatches) {
+          batches = [];
+          currentIndex = 0;
+          while (currentIndex < objArr.length) {
+            batches.push(objArr.slice(currentIndex, currentIndex + OctreeCSG.async.batchSize));
+            currentIndex += OctreeCSG.async.batchSize;
+          }
+          batch = batches.shift();
+          while (batch) {
+            promise = OctreeCSG.async.unionArray(batch, 0);
+            promises.push(promise);
+            batch = batches.shift();
+          }
+          usingBatches = true;
+          mainOctreeUsed = true;
+          objArr.length = 0;
+        } else {
+          octreesArray = [];
+          for (i = k = 0, ref = objArr.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+            materialIndex = i > materialIndexMax ? materialIndexMax : i;
+            tempOctree = void 0;
+            if (objArr[i].isMesh) {
+              tempOctree = OctreeCSG.fromMesh(objArr[i], materialIndexMax > -1 ? materialIndex : void 0);
+            } else {
+              tempOctree = objArr[i];
+              if (materialIndexMax > -1) {
+                tempOctree.setPolygonIndex(materialIndex);
+              }
+            }
+            tempOctree.octreeIndex = i;
+            octreesArray.push(tempOctree);
+          }
+          mainOctree = octreesArray.shift();
+          result = void 0;
+          hasLeftOver = false;
+          leftOverOctree = void 0;
+          for (i = l = 0, ref1 = octreesArray.length; l < ref1; i = l += 2) {
+            if (i + 1 >= octreesArray.length) {
+              leftOverOctree = octreesArray[i];
+              hasLeftOver = true;
+              break;
+            }
+            promise = OctreeCSG.async.union(octreesArray[i], octreesArray[i + 1]);
+            promises.push(promise);
+          }
+          if (leftOverOctree) {
+            promise = OctreeCSG.async.union(mainOctree, leftOverOctree);
+            promises.push(promise);
+            mainOctreeUsed = true;
+          }
+        }
+        return Promise.allSettled(promises).then(function(results) {
+          var octrees;
+          octrees = [];
+          results.forEach(function(r) {
+            if (r.status === "fulfilled") {
+              return octrees.push(r.value);
+            }
+          });
+          if (!mainOctreeUsed) {
+            octrees.unshift(mainOctree);
+          }
+          if (octrees.length > 0) {
+            if (octrees.length === 1) {
+              return resolve(octrees[0]);
+            } else if (octrees.length > 3) {
+              return OctreeCSG.async.unionArray(octrees, usingBatches ? 0 : -1).then(function(result) {
+                return resolve(result);
+              }).catch(function(e) {
+                return reject(e);
+              });
+            } else {
+              return OctreeCSG.async.union(octrees[0], octrees[1]).then(function(result) {
+                if (octrees.length === 3) {
+                  return OctreeCSG.async.union(result, octrees[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 octree');
+          }
+        });
+      } 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, leftOverOctree, mainOctree, mainOctreeUsed, materialIndex, octreesArray, promise, promises, ref, ref1, result, tempOctree, usingBatches;
+      try {
+        usingBatches = OctreeCSG.async.batchSize > 4 && OctreeCSG.async.batchSize < objArr.length;
+        mainOctree = void 0;
+        mainOctreeUsed = false;
+        promises = [];
+        if (usingBatches) {
+          batches = [];
+          currentIndex = 0;
+          while (currentIndex < objArr.length) {
+            batches.push(objArr.slice(currentIndex, currentIndex + OctreeCSG.async.batchSize));
+            currentIndex += OctreeCSG.async.batchSize;
+          }
+          batch = batches.shift();
+          while (batch) {
+            promise = OctreeCSG.async.subtractArray(batch, 0);
+            promises.push(promise);
+            batch = batches.shift();
+          }
+          usingBatches = true;
+          mainOctreeUsed = true;
+          objArr.length = 0;
+        } else {
+          octreesArray = [];
+          for (i = k = 0, ref = objArr.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+            materialIndex = i > materialIndexMax ? materialIndexMax : i;
+            tempOctree = void 0;
+            if (objArr[i].isMesh) {
+              tempOctree = OctreeCSG.fromMesh(objArr[i], materialIndexMax > -1 ? materialIndex : void 0);
+            } else {
+              tempOctree = objArr[i];
+              if (materialIndexMax > -1) {
+                tempOctree.setPolygonIndex(materialIndex);
+              }
+            }
+            tempOctree.octreeIndex = i;
+            octreesArray.push(tempOctree);
+          }
+          mainOctree = octreesArray.shift();
+          result = void 0;
+          hasLeftOver = false;
+          leftOverOctree = void 0;
+          for (i = l = 0, ref1 = octreesArray.length; l < ref1; i = l += 2) {
+            if (i + 1 >= octreesArray.length) {
+              leftOverOctree = octreesArray[i];
+              hasLeftOver = true;
+              break;
+            }
+            promise = OctreeCSG.async.subtract(octreesArray[i], octreesArray[i + 1]);
+            promises.push(promise);
+          }
+          if (leftOverOctree) {
+            promise = OctreeCSG.async.subtract(mainOctree, leftOverOctree);
+            promises.push(promise);
+            mainOctreeUsed = true;
+          }
+        }
+        return Promise.allSettled(promises).then(function(results) {
+          var octrees;
+          octrees = [];
+          results.forEach(function(r) {
+            if (r.status === "fulfilled") {
+              return octrees.push(r.value);
+            }
+          });
+          if (!mainOctreeUsed) {
+            octrees.unshift(mainOctree);
+          }
+          if (octrees.length > 0) {
+            if (octrees.length === 1) {
+              return resolve(octrees[0]);
+            } else if (octrees.length > 3) {
+              return OctreeCSG.async.subtractArray(octrees, usingBatches ? 0 : -1).then(function(result) {
+                return resolve(result);
+              }).catch(function(e) {
+                return reject(e);
+              });
+            } else {
+              return OctreeCSG.async.subtract(octrees[0], octrees[1]).then(function(result) {
+                if (octrees.length === 3) {
+                  return OctreeCSG.async.subtract(result, octrees[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 octree');
+          }
+        });
+      } 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, leftOverOctree, mainOctree, mainOctreeUsed, materialIndex, octreesArray, promise, promises, ref, ref1, result, tempOctree, usingBatches;
+      try {
+        usingBatches = OctreeCSG.async.batchSize > 4 && OctreeCSG.async.batchSize < objArr.length;
+        mainOctree = void 0;
+        mainOctreeUsed = false;
+        promises = [];
+        if (usingBatches) {
+          batches = [];
+          currentIndex = 0;
+          while (currentIndex < objArr.length) {
+            batches.push(objArr.slice(currentIndex, currentIndex + OctreeCSG.async.batchSize));
+            currentIndex += OctreeCSG.async.batchSize;
+          }
+          batch = batches.shift();
+          while (batch) {
+            promise = OctreeCSG.async.intersectArray(batch, 0);
+            promises.push(promise);
+            batch = batches.shift();
+          }
+          usingBatches = true;
+          mainOctreeUsed = true;
+          objArr.length = 0;
+        } else {
+          octreesArray = [];
+          for (i = k = 0, ref = objArr.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+            materialIndex = i > materialIndexMax ? materialIndexMax : i;
+            tempOctree = void 0;
+            if (objArr[i].isMesh) {
+              tempOctree = OctreeCSG.fromMesh(objArr[i], materialIndexMax > -1 ? materialIndex : void 0);
+            } else {
+              tempOctree = objArr[i];
+              if (materialIndexMax > -1) {
+                tempOctree.setPolygonIndex(materialIndex);
+              }
+            }
+            tempOctree.octreeIndex = i;
+            octreesArray.push(tempOctree);
+          }
+          mainOctree = octreesArray.shift();
+          result = void 0;
+          hasLeftOver = false;
+          leftOverOctree = void 0;
+          for (i = l = 0, ref1 = octreesArray.length; l < ref1; i = l += 2) {
+            if (i + 1 >= octreesArray.length) {
+              leftOverOctree = octreesArray[i];
+              hasLeftOver = true;
+              break;
+            }
+            promise = OctreeCSG.async.intersect(octreesArray[i], octreesArray[i + 1]);
+            promises.push(promise);
+          }
+          if (leftOverOctree) {
+            promise = OctreeCSG.async.intersect(mainOctree, leftOverOctree);
+            promises.push(promise);
+            mainOctreeUsed = true;
+          }
+        }
+        return Promise.allSettled(promises).then(function(results) {
+          var octrees;
+          octrees = [];
+          results.forEach(function(r) {
+            if (r.status === "fulfilled") {
+              return octrees.push(r.value);
+            }
+          });
+          if (!mainOctreeUsed) {
+            octrees.unshift(mainOctree);
+          }
+          if (octrees.length > 0) {
+            if (octrees.length === 1) {
+              return resolve(octrees[0]);
+            } else if (octrees.length > 3) {
+              return OctreeCSG.async.intersectArray(octrees, usingBatches ? 0 : -1).then(function(result) {
+                return resolve(result);
+              }).catch(function(e) {
+                return reject(e);
+              });
+            } else {
+              return OctreeCSG.async.intersect(octrees[0], octrees[1]).then(function(result) {
+                if (octrees.length === 3) {
+                  return OctreeCSG.async.intersect(result, octrees[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 octree');
+          }
+        });
+      } catch (error) {
+        e = error;
+        return reject(e);
+      }
+    });
+  },
+  operation: function(obj, returnOctrees = false, buildTargetOctree = true, options = {
+      objCounter: 0
+    }, firstRun = true) {
+    return new Promise(function(resolve, reject) {
+      var e, material, octreeA, octreeB, promise, promises, resultOctree;
+      try {
+        octreeA = void 0;
+        octreeB = void 0;
+        resultOctree = void 0;
+        material = void 0;
+        if (obj.material) {
+          material = obj.material;
+        }
+        promises = [];
+        if (obj.objA) {
+          promise = handleObjectForOp_async(obj.objA, returnOctrees, buildTargetOctree, options, 0);
+          promises.push(promise);
+        }
+        if (obj.objB) {
+          promise = handleObjectForOp_async(obj.objB, returnOctrees, buildTargetOctree, options, 1);
+          promises.push(promise);
+        }
+        return Promise.allSettled(promises).then(function(results) {
+          var octrees, resultPromise;
+          octrees = [];
+          results.forEach(function(r) {
+            if (r.status === "fulfilled") {
+              if (r.value.objIndex === 0) {
+                return octreeA = r.value;
+              } else if (r.value.objIndex === 1) {
+                return octreeB = r.value;
+              }
+            }
+          });
+          if (returnOctrees === true) {
+            obj.objA = octreeA.original;
+            octreeA = octreeA.result;
+            obj.objB = octreeB.original;
+            octreeB = octreeB.result;
+          }
+          resultPromise = void 0;
+          switch (obj.op) {
+            case 'union':
+              resultPromise = OctreeCSG.async.union(octreeA, octreeB, buildTargetOctree);
+              break;
+            case 'subtract':
+              resultPromise = OctreeCSG.async.subtract(octreeA, octreeB, buildTargetOctree);
+              break;
+            case 'intersect':
+              resultPromise = OctreeCSG.async.intersect(octreeA, octreeB, buildTargetOctree);
+          }
+          return resultPromise.then(function(resultOctree) {
+            var mesh;
+            if (firstRun && material) {
+              mesh = OctreeCSG.toMesh(resultOctree, material);
+              if (!returnOctrees) {
+                disposeOctree(resultOctree);
+              }
+              resolve(returnOctrees ? {
+                result: mesh,
+                operationTree: obj
+              } : mesh);
+            } else if (firstRun && returnOctrees) {
+              resolve({
+                result: resultOctree,
+                operationTree: obj
+              });
+            } else {
+              resolve(resultOctree);
+            }
+            if (!returnOctrees) {
+              return disposeOctree(octreeA, octreeB);
+            }
+          }).catch(function(e) {
+            return reject(e);
+          });
+        });
+      } catch (error) {
+        e = error;
+        return reject(e);
+      }
+    });
+  }
+};
+
+OctreeCSG.unionArray = function(objArr, materialIndexMax = 2e308) {
+  var i, k, materialIndex, octreeA, octreeB, octreesArray, ref, resultOctree, tempOctree;
+  octreesArray = [];
+  for (i = k = 0, ref = objArr.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+    materialIndex = i > materialIndexMax ? materialIndexMax : i;
+    tempOctree = void 0;
+    if (objArr[i].isMesh) {
+      tempOctree = OctreeCSG.fromMesh(objArr[i], materialIndex);
+    } else {
+      tempOctree = objArr[i];
+      tempOctree.setPolygonIndex(materialIndex);
+    }
+    tempOctree.octreeIndex = i;
+    octreesArray.push(tempOctree);
+  }
+  octreeA = octreesArray.shift();
+  octreeB = octreesArray.shift();
+  while (octreeA && octreeB) {
+    resultOctree = OctreeCSG.union(octreeA, octreeB);
+    disposeOctree(octreeA, octreeB);
+    octreeA = resultOctree;
+    octreeB = octreesArray.shift();
+  }
+  return octreeA;
+};
+
+OctreeCSG.subtractArray = function(objArr, materialIndexMax = 2e308) {
+  var i, k, materialIndex, octreeA, octreeB, octreesArray, ref, resultOctree, tempOctree;
+  octreesArray = [];
+  for (i = k = 0, ref = objArr.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+    materialIndex = i > materialIndexMax ? materialIndexMax : i;
+    tempOctree = void 0;
+    if (objArr[i].isMesh) {
+      tempOctree = OctreeCSG.fromMesh(objArr[i], materialIndex);
+    } else {
+      tempOctree = objArr[i];
+      tempOctree.setPolygonIndex(materialIndex);
+    }
+    tempOctree.octreeIndex = i;
+    octreesArray.push(tempOctree);
+  }
+  octreeA = octreesArray.shift();
+  octreeB = octreesArray.shift();
+  while (octreeA && octreeB) {
+    resultOctree = OctreeCSG.subtract(octreeA, octreeB);
+    disposeOctree(octreeA, octreeB);
+    octreeA = resultOctree;
+    octreeB = octreesArray.shift();
+  }
+  return octreeA;
+};
+
+OctreeCSG.intersectArray = function(objArr, materialIndexMax = 2e308) {
+  var i, k, materialIndex, octreeA, octreeB, octreesArray, ref, resultOctree, tempOctree;
+  octreesArray = [];
+  for (i = k = 0, ref = objArr.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+    materialIndex = i > materialIndexMax ? materialIndexMax : i;
+    tempOctree = void 0;
+    if (objArr[i].isMesh) {
+      tempOctree = OctreeCSG.fromMesh(objArr[i], materialIndex);
+    } else {
+      tempOctree = objArr[i];
+      tempOctree.setPolygonIndex(materialIndex);
+    }
+    tempOctree.octreeIndex = i;
+    octreesArray.push(tempOctree);
+  }
+  octreeA = octreesArray.shift();
+  octreeB = octreesArray.shift();
+  while (octreeA && octreeB) {
+    resultOctree = OctreeCSG.intersect(octreeA, octreeB);
+    disposeOctree(octreeA, octreeB);
+    octreeA = resultOctree;
+    octreeB = octreesArray.shift();
+  }
+  return octreeA;
+};
+
+OctreeCSG.operation = function(obj, returnOctrees = false, buildTargetOctree = true, options = {
+    objCounter: 0
+  }, firstRun = true) {
+  var material, mesh, octreeA, octreeB, resultOctree;
+  octreeA = void 0;
+  octreeB = void 0;
+  resultOctree = void 0;
+  material = void 0;
+  if (obj.material) {
+    material = obj.material;
+  }
+  if (obj.objA) {
+    octreeA = handleObjectForOp(obj.objA, returnOctrees, buildTargetOctree, options);
+    if (returnOctrees === true) {
+      obj.objA = octreeA.original;
+      octreeA = octreeA.result;
+    }
+  }
+  if (obj.objB) {
+    octreeB = handleObjectForOp(obj.objB, returnOctrees, buildTargetOctree, options);
+    if (returnOctrees === true) {
+      obj.objB = octreeB.original;
+      octreeB = octreeB.result;
+    }
+  }
+  switch (obj.op) {
+    case 'union':
+      resultOctree = OctreeCSG.union(octreeA, octreeB, buildTargetOctree);
+      break;
+    case 'subtract':
+      resultOctree = OctreeCSG.subtract(octreeA, octreeB, buildTargetOctree);
+      break;
+    case 'intersect':
+      resultOctree = OctreeCSG.intersect(octreeA, octreeB, buildTargetOctree);
+  }
+  if (!returnOctrees) {
+    disposeOctree(octreeA, octreeB);
+  }
+  if (firstRun && material) {
+    mesh = OctreeCSG.toMesh(resultOctree, material);
+    disposeOctree(resultOctree);
+    if (returnOctrees) {
+      return {
+        result: mesh,
+        operationTree: obj
+      };
+    } else {
+      return mesh;
+    }
+  }
+  if (firstRun && returnOctrees) {
+    return {
+      result: resultOctree,
+      operationTree: obj
+    };
+  }
+  return resultOctree;
+};
+
+handleObjectForOp = function(obj, returnOctrees, buildTargetOctree, options) {
+  var returnObj;
+  returnObj = void 0;
+  if (obj.isMesh) {
+    returnObj = OctreeCSG.fromMesh(obj, options.objCounter++);
+    if (returnOctrees) {
+      returnObj = {
+        result: returnObj,
+        original: returnObj.clone()
+      };
+    }
+  } else if (obj.isOctree) {
+    returnObj = obj;
+    if (returnOctrees) {
+      returnObj = {
+        result: obj,
+        original: obj.clone()
+      };
+    }
+  } else if (obj.op) {
+    returnObj = OctreeCSG.operation(obj, returnOctrees, buildTargetOctree, options, false);
+    if (returnOctrees) {
+      returnObj = {
+        result: returnObj,
+        original: obj
+      };
+    }
+  }
+  return returnObj;
+};
+
+handleObjectForOp_async = function(obj, returnOctrees, buildTargetOctree, options, objIndex) {
+  return new Promise(function(resolve, reject) {
+    var e, returnObj;
+    try {
+      returnObj = void 0;
+      if (obj.isMesh) {
+        returnObj = OctreeCSG.fromMesh(obj, options.objCounter++);
+        if (returnOctrees) {
+          returnObj = {
+            result: returnObj,
+            original: returnObj.clone()
+          };
+        }
+        returnObj.objIndex = objIndex;
+        return resolve(returnObj);
+      } else if (obj.isOctree) {
+        returnObj = obj;
+        if (returnOctrees) {
+          returnObj = {
+            result: obj,
+            original: obj.clone()
+          };
+        }
+        returnObj.objIndex = objIndex;
+        return resolve(returnObj);
+      } else if (obj.op) {
+        return OctreeCSG.async.operation(obj, returnOctrees, buildTargetOctree, options, false).then(function(returnObj) {
+          if (returnOctrees) {
+            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();
+
+OctreeCSG.toGeometry = function(octree) {
+  var colors, defaultGroup, geometry, groupBase, groups, i, index, k, l, len1, m, normals, polygon, polygons, positions, ref, ref1, triangleCount, uvs, vertices, verticesLen;
+  polygons = octree.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;
+};
+
+OctreeCSG.toMesh = function(octree, toMaterial) {
+  var geometry;
+  geometry = OctreeCSG.toGeometry(octree);
+  return new Mesh(geometry, toMaterial);
+};
+
+OctreeCSG.fromMesh = function(obj, objectIndex, octree = new OctreeCSG(), buildTargetOctree = true) {
+  var color, colorattr, geometry, group, groups, i, index, j, k, l, len1, m, normal, normalattr, o, polygon, polys, pos, posattr, ref, ref1, uv, uvattr, vertices, vi, vp, vt;
+  if (obj.isOctree) {
+    return obj;
+  }
+  if (OctreeCSG.rayIntersectTriangleType === "regular") {
+    octree.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) {
+      vi = index[i + j];
+      vp = vi * 3;
+      vt = vi * 2;
+      pos = new Vector3(posattr.array[vp], posattr.array[vp + 1], posattr.array[vp + 2]);
+      normal = new Vector3(normalattr.array[vp], normalattr.array[vp + 1], normalattr.array[vp + 2]);
+      pos.applyMatrix4(obj.matrix);
+      normal.applyMatrix3(tmpm3);
+      uv = uvattr ? {
+        x: uvattr.array[vt],
+        y: uvattr.array[vt + 1]
+      } : void 0;
+      color = colorattr ? {
+        x: colorattr.array[vt],
+        y: colorattr.array[vt + 1],
+        z: colorattr.array[vt + 2]
+      } : void 0;
+      vertices.push(new Vertex(pos, normal, uv, 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 = o = 0, ref1 = polys.length; (0 <= ref1 ? o < ref1 : o > ref1); i = 0 <= ref1 ? ++o : --o) {
+    if (isValidTriangle(polys[i].triangle)) {
+      octree.addPolygon(polys[i]);
+    } else {
+      polys[i].delete();
+    }
+  }
+  buildTargetOctree && octree.buildTree();
+  if (OctreeCSG.useOctreeRay !== true) {
+    octree.mesh = obj;
+  }
+  return octree;
+};
+
+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 n;
+  n = tv0.copy(b).sub(a).cross(tv1.copy(c).sub(a)).normalize().clone();
+  return new Plane(n, n.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();
+  }
+
+};
+
+disposeOctree = function(...octrees) {
+  if (OctreeCSG.disposeOctree) {
+    return octrees.forEach(function(octree) {
+      return octree.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;
+};
+
+// -----
+handleIntersectingOctrees = function(octreeA, octreeB, bothOctrees = true) {
+  var octreeA_buffer, octreeB_buffer;
+  octreeA_buffer = void 0;
+  octreeB_buffer = void 0;
+  if (OctreeCSG.useWindingNumber === true) {
+    if (bothOctrees) {
+      octreeA_buffer = prepareTriangleBuffer(octreeA.getPolygons());
+    }
+    octreeB_buffer = prepareTriangleBuffer(octreeB.getPolygons());
+  }
+  octreeA.handleIntersectingPolygons(octreeB, octreeB_buffer);
+  if (bothOctrees) {
+    octreeB.handleIntersectingPolygons(octreeA, octreeA_buffer);
+  }
+  if (octreeA_buffer !== void 0) {
+    octreeA_buffer = void 0;
+    return octreeB_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;
+};
+
+OctreeCSG.rayIntersectsTriangle = rayIntersectsTriangle;
+
+OctreeCSG.useOctreeRay = true;
+
+OctreeCSG.useWindingNumber = false;
+
+OctreeCSG.rayIntersectTriangleType = "MollerTrumbore"; // "regular" (three.js' ray.intersectTriangle; "MollerTrumbore" (Moller Trumbore algorithm);
+
+OctreeCSG.maxLevel = 16;
+
+OctreeCSG.polygonsPerTree = 100;
+
+// OctreeCSG.Octree = Octree
+module.exports = {
+  default: OctreeCSG,
+  CSG: OctreeCSG,
+  OctreeCSG: OctreeCSG,
+  Polygon: Polygon,
+  Plane: Plane,
+  Vertex: Vertex,
+  rayIntersectsTriangle: rayIntersectsTriangle
+};