@jscad/modeling 3.0.5-alpha.0 → 3.0.6-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jscad/modeling",
-  "version": "3.0.5-alpha.0",
+  "version": "3.0.6-alpha.0",
   "description": "Constructive Solid Geometry (CSG) Library for JSCAD",
   "homepage": "https://openjscad.xyz/",
   "repository": "https://github.com/jscad/OpenJSCAD.org",
@@ -63,5 +63,5 @@
     "c8": "^10.1.0",
     "rollup": "^4.52.0"
   },
-  "gitHead": "942d9a5eab2f234f2e1c617d5896e0230f353330"
+  "gitHead": "201d3987b309fd1f383b10b5555dd0a2765cad43"
 }

package/src/colors/hsvToRgb.js

@@ -56,6 +56,7 @@ export const hsvToRgb = (...values) => {
       b = v
       break
     case 5:
+    default:
       r = v
       g = p
       b = q

package/src/colors/rgbToHsl.js

@@ -24,7 +24,8 @@ export const rgbToHsl = (...values) => {
   const l = (max + min) / 2
 
   if (max === min) {
-    h = s = 0 // achromatic
+    h = 0
+    s = 0 // achromatic
   } else {
     const d = max - min
     s = l > 0.5 ? d / (2 - max - min) : d / (max + min)
@@ -36,6 +37,7 @@ export const rgbToHsl = (...values) => {
         h = (b - r) / d + 2
         break
       case b:
+      default:
         h = (r - g) / d + 4
         break
     }

package/src/colors/rgbToHsv.js

@@ -35,6 +35,7 @@ export const rgbToHsv = (...values) => {
         h = (b - r) / d + 2
         break
       case b:
+      default:
         h = (r - g) / d + 4
         break
     }

package/src/curves/bezier/create.js

@@ -51,7 +51,7 @@ const getPointType = function (points) {
       })
       pType = 'float_' + point.length
     } else throw new Error('Bezier points must all be numbers or arrays of number.')
-    if (firstPointType == null) {
+    if (firstPointType === null) {
       firstPointType = pType
     } else {
       if (firstPointType !== pType) {

package/src/geometries/geom2/transform.js

@@ -18,6 +18,7 @@ import { reverse } from './reverse.js'
  */
 export const transform = (matrix, geometry) => {
   const transforms = mat4.multiply(mat4.create(), matrix, geometry.transforms)
+  // use Object.assign in order to assign EXTRA attributes like color, name, etc
   const transformed = Object.assign({}, geometry, { transforms })
   // determine if the transform is mirroring in 2D
   if (matrix[0] * matrix[5] - matrix[4] * matrix[1] < 0) {

package/src/geometries/geom3/transform.js

@@ -17,5 +17,6 @@ import * as mat4 from '../../maths/mat4/index.js'
  */
 export const transform = (matrix, geometry) => {
   const transforms = mat4.multiply(mat4.create(), matrix, geometry.transforms)
+  // use Object.assign in order to assign EXTRA attributes like color, name, etc
   return Object.assign({}, geometry, { transforms })
 }

package/src/geometries/geom3/validate.js

@@ -22,7 +22,17 @@ export const validate = (object) => {
   }
 
   // check polygons
-  object.polygons.forEach(poly3.validate)
+  object.polygons.forEach((p, i) => {
+    if (p.vertices.length < 3) {
+      throw new Error(`invalid polygon ${i}: only ${p.vertices.length} vertices`)
+    }
+
+    try {
+      poly3.validate(p)
+    } catch (e) {
+      throw new Error(`invalid polygon ${i}: ${e}`)
+    }
+  })
   validateManifold(object)
 
   // check transforms

package/src/geometries/path2/appendArc.js

@@ -1,7 +1,7 @@
 import { TAU } from '../../maths/constants.js'
 import * as vec2 from '../../maths/vec2/index.js'
 
-import { fromPoints } from './fromPoints.js'
+import { appendPoints } from './appendPoints.js'
 import { toPoints } from './toPoints.js'
 
 /**
@@ -27,19 +27,19 @@ import { toPoints } from './toPoints.js'
  * myShape = path2.appendArc({endpoint: [12.5, -22.96875], radius: [15, -19.6875]}, myShape);
  */
 export const appendArc = (options, geometry) => {
-  const defaults = {
-    radius: [0, 0], // X and Y radius
-    xaxisRotation: 0,
-    clockwise: false,
-    large: false,
-    segments: 16
-  }
-  let { endpoint, radius, xaxisRotation, clockwise, large, segments } = Object.assign({}, defaults, options)
+  const {
+    endpoint = null,
+    radius = [0, 0], // X and Y radius
+    xaxisRotation = 0,
+    clockwise = false,
+    large = false,
+    segments = 16
+  } = options
 
   // validate the given options
   if (!Array.isArray(endpoint)) throw new Error('endpoint must be an array of X and Y values')
-  if (endpoint.length < 2) throw new Error('endpoint must contain X and Y values')
-  endpoint = vec2.clone(endpoint)
+  if (endpoint.length !== 2) throw new Error('endpoint must contain X and Y values')
+  let xendPoint = vec2.clone(endpoint)
 
   if (!Array.isArray(radius)) throw new Error('radius must be an array of X and Y values')
   if (radius.length < 2) throw new Error('radius must contain X and Y values')
@@ -48,11 +48,6 @@ export const appendArc = (options, geometry) => {
 
   const decimals = 100000
 
-  // validate the given geometry
-  if (geometry.isClosed) {
-    throw new Error('the given path cannot be closed')
-  }
-
   const points = toPoints(geometry)
   if (points.length < 1) {
     throw new Error('the given path must contain one or more points (as the starting point for the arc)')
@@ -65,14 +60,14 @@ export const appendArc = (options, geometry) => {
   // round to precision in order to have determinate calculations
   xRadius = Math.round(xRadius * decimals) / decimals
   yRadius = Math.round(yRadius * decimals) / decimals
-  endpoint = vec2.fromValues(Math.round(endpoint[0] * decimals) / decimals, Math.round(endpoint[1] * decimals) / decimals)
+  xendPoint = vec2.fromValues(Math.round(xendPoint[0] * decimals) / decimals, Math.round(xendPoint[1] * decimals) / decimals)
 
   const sweepFlag = !clockwise
-  let newPoints = []
+  const newPoints = []
   if ((xRadius === 0) || (yRadius === 0)) {
     // http://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes:
     // If rx = 0 or ry = 0, then treat this as a straight line from (x1, y1) to (x2, y2) and stop
-    newPoints.push(endpoint)
+    newPoints.push(xendPoint)
   } else {
     xRadius = Math.abs(xRadius)
     yRadius = Math.abs(yRadius)
@@ -81,7 +76,7 @@ export const appendArc = (options, geometry) => {
     const phi = xaxisRotation
     const cosPhi = Math.cos(phi)
     const sinPhi = Math.sin(phi)
-    const minusHalfDistance = vec2.subtract(vec2.create(), startpoint, endpoint)
+    const minusHalfDistance = vec2.subtract(vec2.create(), startpoint, xendPoint)
     vec2.scale(minusHalfDistance, minusHalfDistance, 0.5)
     // F.6.5.1:
     // round to precision in order to have determinate calculations
@@ -106,7 +101,7 @@ export const appendArc = (options, geometry) => {
     vec2.scale(centerTranslated, centerTranslated, multiplier1)
     // F.6.5.3:
     let center = vec2.fromValues(cosPhi * centerTranslated[0] - sinPhi * centerTranslated[1], sinPhi * centerTranslated[0] + cosPhi * centerTranslated[1])
-    center = vec2.add(center, center, vec2.scale(vec2.create(), vec2.add(vec2.create(), startpoint, endpoint), 0.5))
+    center = vec2.add(center, center, vec2.scale(vec2.create(), vec2.add(vec2.create(), startpoint, xendPoint), 0.5))
 
     // F.6.5.5:
     const vector1 = vec2.fromValues((startTranslated[0] - centerTranslated[0]) / xRadius, (startTranslated[1] - centerTranslated[1]) / yRadius)
@@ -134,9 +129,8 @@ export const appendArc = (options, geometry) => {
       newPoints.push(point)
     }
     // ensure end point is precisely what user gave as parameter
-    if (numSteps) newPoints.push(options.endpoint)
+    if (numSteps) newPoints.push(endpoint)
   }
-  newPoints = points.concat(newPoints)
-  const result = fromPoints({}, newPoints)
-  return result
+
+  return appendPoints(newPoints, geometry)
 }

package/src/geometries/path2/appendBezier.js

@@ -1,6 +1,6 @@
 import { TAU } from '../../maths/constants.js'
 import * as vec2 from '../../maths/vec2/index.js'
-import * as vec3 from '../../maths/vec3/index.js' // FIXME why vec3?
+import * as vec3 from '../../maths/vec3/index.js' // required due to vec2.cross()
 
 import { appendPoints } from './appendPoints.js'
 import { toPoints } from './toPoints.js'
@@ -27,10 +27,10 @@ import { toPoints } from './toPoints.js'
  * myShape = path2.appendBezier({controlPoints: [null, [25,-30],[40,-30],[40,-20]]}, myShape)
  */
 export const appendBezier = (options, geometry) => {
-  const defaults = {
-    segments: 16
-  }
-  let { controlPoints, segments } = Object.assign({}, defaults, options)
+  let {
+    controlPoints = null,
+    segments = 16
+  } = options
 
   // validate the given options
   if (!Array.isArray(controlPoints)) throw new Error('controlPoints must be an array of one or more points')
@@ -39,10 +39,6 @@ export const appendBezier = (options, geometry) => {
   if (segments < 4) throw new Error('segments must be four or more')
 
   // validate the given geometry
-  if (geometry.isClosed) {
-    throw new Error('the given geometry cannot be closed')
-  }
-
   const points = toPoints(geometry)
   if (points.length < 1) {
     throw new Error('the given path must contain one or more points (as the starting point for the bezier curve)')
@@ -148,9 +144,10 @@ export const appendBezier = (options, geometry) => {
   }
 
   // append to the new points to the given path
-  // but skip the first new point because it is identical to the last point in the given path
-  newPoints.shift()
   const result = appendPoints(newPoints, geometry)
+
+  // add a hint for the next bezier
   result.lastBezierControlPoint = controlPoints[controlPoints.length - 2]
+
   return result
 }

package/src/geometries/path2/appendPoints.js

@@ -1,5 +1,7 @@
-import { concat } from './concat.js'
-import { create } from './create.js'
+import { equals } from '../../maths/vec2/equals.js'
+
+import { fromPoints } from './fromPoints.js'
+import { toPoints } from './toPoints.js'
 
 /**
  * Append the given list of points to the end of the given geometry.
@@ -12,4 +14,20 @@ import { create } from './create.js'
  * @example
  * let newPath = path2.appendPoints([[3, 4], [4, 5]], oldPath)
  */
-export const appendPoints = (points, geometry) => concat(geometry, create(points))
+export const appendPoints = (points, geometry) => {
+  let originalPoints = toPoints(geometry)
+
+  if (geometry.isClosed && originalPoints.length > 1) {
+    // add the closing point to the originalPoints
+    originalPoints = originalPoints.slice()
+    originalPoints.push(originalPoints[0])
+  }
+
+  if (originalPoints.length > 0) {
+    // remove redundant points
+    const lastPoint = originalPoints[originalPoints.length - 1]
+    while (points.length > 0 && equals(points[0], lastPoint)) points.shift()
+  }
+
+  return fromPoints({}, originalPoints.concat(points))
+}

package/src/geometries/path2/appendPoints.test.js

@@ -12,10 +12,16 @@ test('appendPoints: appending to an empty path produces a new path with expected
 
 test('appendPoints: appending to a path produces a new path with expected points', (t) => {
   const p1 = fromPoints({}, [[1, 1], [2, 2]])
-  const obs = appendPoints([[3, 3], [4, 4]], p1)
-  const pts = toPoints(obs)
+  let obs = appendPoints([[3, 3], [4, 4]], p1)
+  let pts = toPoints(obs)
   t.not(p1, obs)
   t.is(pts.length, 4)
+
+  const p2 = fromPoints({ closed: true }, [[0, 0], [1, 0], [0, 1]])
+  obs = appendPoints([[0, -1], [0, -2]], p2)
+  pts = toPoints(obs)
+  t.not(p2, obs)
+  t.is(pts.length, 6)
 })
 
 test('appendPoints: appending empty points to a path produces a new path with expected points', (t) => {
@@ -28,8 +34,14 @@ test('appendPoints: appending empty points to a path produces a new path with ex
 
 test('appendPoints: appending same points to a path produces a new path with expected points', (t) => {
   const p1 = fromPoints({}, [[1, 1], [2, 2]])
-  const obs = appendPoints([[2, 2], [3, 3]], p1)
-  const pts = toPoints(obs)
+  let obs = appendPoints([[2, 2], [3, 3]], p1)
+  let pts = toPoints(obs)
   t.not(p1, obs)
   t.is(pts.length, 3)
+
+  const p2 = fromPoints({ closed: true }, [[0, 0], [1, 0], [0, 1]])
+  obs = appendPoints([[0, 0], [0, 0], [0, -1]], p2)
+  pts = toPoints(obs)
+  t.not(p2, obs)
+  t.is(pts.length, 5)
 })

package/src/geometries/path2/close.js

@@ -1,8 +1,6 @@
 import { EPS } from '../../maths/constants.js'
 
-import * as vec2 from '../../maths/vec2/index.js'
-
-import { clone } from './clone.js'
+import { distance } from '../../maths/vec2/distance.js'
 
 /**
  * Close the given geometry.
@@ -17,19 +15,18 @@ import { clone } from './clone.js'
 export const close = (geometry) => {
   if (geometry.isClosed) return geometry
 
-  const cloned = clone(geometry)
-  cloned.isClosed = true
-
-  if (cloned.points.length > 1) {
+  const isClosed = true
+  const points = geometry.points.slice()
+  if (points.length > 1) {
     // make sure the paths are formed properly
-    const points = cloned.points
     const p0 = points[0]
     let pn = points[points.length - 1]
-    while (vec2.distance(p0, pn) < (EPS * EPS)) {
+    while (distance(p0, pn) < EPS) {
       points.pop()
       if (points.length === 1) break
       pn = points[points.length - 1]
     }
   }
-  return cloned
+  // use Object.assign in order to assign EXTRA attributes like color, name, etc
+  return Object.assign({}, geometry, { isClosed, points })
 }

package/src/geometries/path2/concat.js

@@ -1,4 +1,4 @@
-import { equals } from '../../maths/vec2/index.js'
+import { equals } from '../../maths/vec2/equals.js'
 
 import { fromPoints } from './fromPoints.js'
 import { toPoints } from './toPoints.js'
@@ -6,7 +6,7 @@ import { toPoints } from './toPoints.js'
 /**
  * Concatenate the given paths.
  *
- * If both contain the same point at the junction, merge it into one.
+ * If paths contain the same junction point, merge it into one.
  * A concatenation of zero paths is an empty, open path.
  * A concatenation of one closed path to a series of open paths produces a closed path.
  * A concatenation of a path to a closed path is an error.

package/src/geometries/path2/fromPoints.js

@@ -1,6 +1,6 @@
 import { EPS } from '../../maths/constants.js'
 
-import * as vec2 from '../../maths/vec2/index.js'
+import { distance } from '../../maths/vec2/distance.js'
 
 import { close } from './close.js'
 import { create } from './create.js'
@@ -18,20 +18,20 @@ import { create } from './create.js'
  * @alias module:modeling/path2.fromPoints
  *
  * @example
- * my newPath = path2.fromPoints({closed: true}, [[10, 10], [-10, 10]])
+ * let newPath = path2.fromPoints({closed: true}, [[10, 10], [-10, 10]])
  */
 export const fromPoints = (options, points) => {
-  const defaults = { closed: false }
-  let { closed } = Object.assign({}, defaults, options)
+  let {
+    closed = false
+  } = options
 
-  let created = create()
-  created.points = points.map((point) => vec2.clone(point))
+  let created = create(points.slice())
 
   // check if first and last points are equal
   if (created.points.length > 1) {
     const p0 = created.points[0]
     const pn = created.points[created.points.length - 1]
-    if (vec2.distance(p0, pn) < (EPS * EPS)) {
+    if (distance(p0, pn) < EPS) {
       // and close automatically
       closed = true
     }

package/src/geometries/path2/reverse.js

@@ -14,7 +14,7 @@ import { clone } from './clone.js'
  */
 export const reverse = (geometry) => {
   // NOTE: this only updates the order of the points
-  const cloned = clone(geometry)
-  cloned.points = geometry.points.slice().reverse()
-  return cloned
+  const points = geometry.points.slice().reverse()
+  // use Object.assign in order to assign EXTRA attributes like color, name, etc
+  return Object.assign({}, geometry, { points })
 }

package/src/geometries/path2/transform.js

@@ -16,5 +16,6 @@ import * as mat4 from '../../maths/mat4/index.js'
  */
 export const transform = (matrix, geometry) => {
   const transforms = mat4.multiply(mat4.create(), matrix, geometry.transforms)
+  // use Object.assign in order to assign EXTRA attributes like color, name, etc
   return Object.assign({}, geometry, { transforms })
 }

package/src/geometries/path2/validate.js

@@ -1,4 +1,4 @@
-import * as vec2 from '../../maths/vec2/index.js'
+import { equals } from '../../maths/vec2/equals.js'
 
 import { isA } from './isA.js'
 
@@ -24,7 +24,7 @@ export const validate = (object) => {
   // check for duplicate points
   if (object.points.length > 1) {
     for (let i = 0; i < object.points.length; i++) {
-      if (vec2.equals(object.points[i], object.points[(i + 1) % object.points.length])) {
+      if (equals(object.points[i], object.points[(i + 1) % object.points.length])) {
         throw new Error(`path2 has duplicate point ${object.points[i]}`)
       }
     }

package/src/geometries/path3/close.js

@@ -1,6 +1,6 @@
 import { EPS } from '../../maths/constants.js'
 
-import * as vec3 from '../../maths/vec3/index.js'
+import { distance } from '../../maths/vec3/distance.js'
 
 /**
  * Close the given geometry.
@@ -15,19 +15,18 @@ import * as vec3 from '../../maths/vec3/index.js'
 export const close = (geometry) => {
   if (geometry.isClosed) return geometry
 
-  const cloned = Object.assign({}, geometry)
-  cloned.isClosed = true
-
-  if (cloned.vertices.length > 1) {
+  const isClosed = true
+  const vertices = geometry.vertices.slice()
+  if (vertices.length > 1) {
     // make sure the paths are formed properly
-    const vertices = cloned.vertices
     const p0 = vertices[0]
     let pn = vertices[vertices.length - 1]
-    while (vec3.distance(p0, pn) < (EPS * EPS)) {
+    while (distance(p0, pn) < EPS) {
       vertices.pop()
       if (vertices.length === 1) break
       pn = vertices[vertices.length - 1]
     }
   }
-  return cloned
+  // use Object.assign in order to assign EXTRA attributes like color, name, etc
+  return Object.assign({}, geometry, { isClosed, vertices })
 }

package/src/geometries/path3/transform.js

@@ -16,5 +16,6 @@ import * as mat4 from '../../maths/mat4/index.js'
  */
 export const transform = (matrix, geometry) => {
   const transforms = mat4.multiply(mat4.create(), matrix, geometry.transforms)
+  // use Object.assign in order to assign EXTRA attributes like color, name, etc
   return Object.assign({}, geometry, { transforms })
 }

package/src/geometries/slice/earcut/index.js

@@ -28,8 +28,10 @@ export const triangulate = (data, holeIndices, dim = 2) => {
 
   // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
   if (data.length > 80 * dim) {
-    minX = maxX = data[0]
-    minY = maxY = data[1]
+    minX = data[0]
+    maxX = data[0]
+    minY = data[1]
+    maxY = data[1]
 
     for (let i = dim; i < outerLen; i += dim) {
       const x = data[i]

package/src/geometries/slice/earcut/linkedPolygon.js

@@ -39,7 +39,8 @@ export const filterPoints = (start, end) => {
 
     if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
       removeNode(p)
-      p = end = p.prev
+      p = p.prev
+      end = p.prev
       if (p === p.next) break
       again = true
     } else {
@@ -68,7 +69,8 @@ export const cureLocalIntersections = (start, triangles, dim) => {
       removeNode(p)
       removeNode(p.next)
 
-      p = start = b
+      p = b
+      start = b
     }
 
     p = p.next

package/src/geometries/slice/transform.js

@@ -16,5 +16,6 @@ import { create } from './create.js'
  */
 export const transform = (matrix, slice) => {
   const contours = slice.contours.map((contour) => contour.map((vertex) => vec3.transform(vec3.create(), vertex, matrix)))
-  return create(contours)
+  // use Object.assign in order to assign EXTRA attributes like color, name, etc
+  return Object.assign({}, slice, { contours })
 }

package/src/maths/line2/intersectPointOfLines.js

@@ -14,7 +14,4 @@ import { solve2Linear } from '../utils/solve2Linear.js'
  * @return {Vec2} the point of intersection
  * @alias module:modeling/maths/line2.intersectPointOfLines
  */
-export const intersectPointOfLines = (line1, line2) => {
-  const point = solve2Linear(line1[0], line1[1], line2[0], line2[1], line1[2], line2[2])
-  return vec2.clone(point)
-}
+export const intersectPointOfLines = (line1, line2) => solve2Linear(line1[0], line1[1], line2[0], line2[1], line1[2], line2[2])

package/src/operations/booleans/martinez/computeFields.js

@@ -70,6 +70,8 @@ const inResult = (event, operation) => {
                   (!event.isSubject && !event.otherInOut)
         case XOR:
           return true
+        default:
+          throw new Error('computeFields01')
       }
       break
     case SAME_TRANSITION:
@@ -78,6 +80,8 @@ const inResult = (event, operation) => {
       return operation === DIFFERENCE
     case NON_CONTRIBUTING:
       return false
+    default:
+      throw new Error('computeFields02')
   }
   return false
 }
@@ -104,6 +108,8 @@ const determineResultTransition = (event, operation) => {
         isIn = thatIn && !thisIn
       }
       break
+    default:
+      throw new Error('computeFields03')
   }
   return isIn ? +1 : -1
 }

package/src/operations/booleans/martinez/divideSegment.js

@@ -12,7 +12,8 @@ export const divideSegment = (segment, point, queue) => {
   const r = new SweepEvent(point, false, segment, segment.isSubject)
   const l = new SweepEvent(point, true, segment.otherEvent, segment.isSubject)
 
-  r.contourId = l.contourId = segment.contourId
+  r.contourId = segment.contourId
+  l.contourId = segment.contourId
 
   // avoid a rounding error. The left event would be processed after the right event
   if (compareEvents(l, segment.otherEvent) > 0) {

package/src/operations/booleans/martinez/fillQueue.js

@@ -25,7 +25,9 @@ const processPolygon = (contourOrHole, isSubject, ringId, queue, bbox, isExterio
       continue // skip collapsed edges, or it breaks
     }
 
-    e1.contourId = e2.contourId = ringId
+    e1.contourId = ringId
+    e2.contourId = ringId
+
     if (!isExteriorRing) {
       e1.isExteriorRing = false
       e2.isExteriorRing = false

package/src/operations/booleans/martinez/subdivideSegments.js

@@ -32,14 +32,14 @@ export const subdivideSegments = (eventQueue, subject, clipping, sbbox, cbbox, o
     }
 
     if (event.left) {
-      next = prev = sweepLine.insert(event)
+      prev = sweepLine.insert(event)
       begin = sweepLine.minNode()
 
+      next = sweepLine.next(prev)
+
       if (prev !== begin) prev = sweepLine.prev(prev)
       else prev = null
 
-      next = sweepLine.next(next)
-
       const prevEvent = prev ? prev.key : null
       let prevprevEvent
       computeFields(event, prevEvent, operation)
@@ -62,7 +62,8 @@ export const subdivideSegments = (eventQueue, subject, clipping, sbbox, cbbox, o
         }
       }
     } else {
-      next = prev = sweepLine.find(event.otherEvent)
+      prev = sweepLine.find(event.otherEvent)
+      next = prev
 
       if (prev && next) {
         // FIXME is this correct? begin is assigned if event.left, not every iterration

package/src/operations/booleans/subtractGeom3Sub.js

@@ -13,7 +13,7 @@ import { mayOverlap } from './mayOverlap.js'
  */
 export const subtractGeom3Sub = (geometry1, geometry2) => {
   if (!mayOverlap(geometry1, geometry2)) {
-    return geom3.clone(geometry1)
+    return geometry1
   }
 
   const a = new Tree(geom3.toPolygons(geometry1))

package/src/operations/booleans/trees/PolygonTreeNode.js

@@ -215,6 +215,9 @@ export class PolygonTreeNode {
           backNodes.push(backNode)
         }
         break
+
+      default:
+        throw new Error('PolygonTreeNode05')
     }
   }