@jscad/modeling 2.7.0 → 2.8.0

package/src/maths/vec3/angle.js

@@ -15,8 +15,8 @@ const angle = (a, b) => {
   const bx = b[0]
   const by = b[1]
   const bz = b[2]
-  const mag1 = Math.sqrt(ax * ax + ay * ay + az * az)
-  const mag2 = Math.sqrt(bx * bx + by * by + bz * bz)
+  const mag1 = Math.hypot(ax, ay, az)
+  const mag2 = Math.hypot(bx, by, bz)
   const mag = mag1 * mag2
   const cosine = mag && dot(a, b) / mag
   return Math.acos(Math.min(Math.max(cosine, -1), 1))

package/src/maths/vec3/angle.test.js

@@ -25,5 +25,22 @@ test('vec3: angle() should return correct values', (t) => {
   const angle4 = angle(veca4, vec4)
   nearlyEqual(t, angle4, 3.14159, EPS)
 
+  const vec5a = fromValues(1, 0, 0)
+  const vec5b = fromValues(1, 1, 0)
+  const angle5 = angle(vec5a, vec5b)
+  nearlyEqual(t, angle5, 0.785398, EPS)
+
+  // tiny values
+  const vec6a = fromValues(1, 0, 0)
+  const vec6b = fromValues(1e-200, 1e-200, 0)
+  const angle6 = angle(vec6a, vec6b)
+  nearlyEqual(t, angle6, 0.785398, EPS)
+
+  // huge values
+  const vec7a = fromValues(1, 0, 0)
+  const vec7b = fromValues(1e200, 1e200, 0)
+  const angle7 = angle(vec7a, vec7b)
+  nearlyEqual(t, angle7, 0.785398, EPS)
+
   t.true(true)
 })

package/src/maths/vec3/cross.test.js

@@ -3,7 +3,7 @@ const { cross, fromValues } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
-test('vec3: cross() called with three paramerters should update a vec3 with correct values', (t) => {
+test('vec3: cross() called with three parameters should update a vec3 with correct values', (t) => {
   const obs1 = fromValues(0, 0, 0)
   const ret1 = cross(obs1, [0, 0, 0], [0, 0, 0])
   t.true(compareVectors(obs1, [0, 0, 0]))

package/src/maths/vec3/divide.test.js

@@ -3,7 +3,7 @@ const { divide, fromValues } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
-test('vec3: divide() called with three paramerters should update a vec3 with correct values', (t) => {
+test('vec3: divide() called with three parameters should update a vec3 with correct values', (t) => {
   const obs1 = fromValues(0, 0, 0)
   const ret1 = divide(obs1, [0, 0, 0], [0, 0, 0])
   t.true(compareVectors(obs1, [0 / 0, 0 / 0, 0 / 0]))

package/src/maths/vec3/fromScalar.js

@@ -4,7 +4,7 @@
  *
  * @param {vec3} out - receiving vector
  * @param {Number} scalar
- * @returns {Vec3} out
+ * @returns {vec3} out
  * @alias module:modeling/maths/vec3.fromScalar
  */
 const fromScalar = (out, scalar) => {

package/src/maths/vec3/fromVec2.d.ts

@@ -3,4 +3,4 @@ import Vec2 from '../vec2/type'
 
 export default fromVector2
 
-declare function fromVector2(out: Vec3, vec2: Vec2, z?: number): Vec3
+declare function fromVector2(out: Vec3, vector: Vec2, z?: number): Vec3

package/src/maths/vec3/fromVec2.js

@@ -7,9 +7,9 @@
  * @returns {vec3} out
  * @alias module:modeling/maths/vec3.fromVec2
  */
-const fromVector2 = (out, vec2, z = 0) => {
-  out[0] = vec2[0]
-  out[1] = vec2[1]
+const fromVector2 = (out, vector, z = 0) => {
+  out[0] = vector[0]
+  out[1] = vector[1]
   out[2] = z
   return out
 }

package/src/maths/vec3/length.d.ts

@@ -2,4 +2,4 @@ import Vec3 from './type'
 
 export default length
 
-declare function length(a: Vec3): number
+declare function length(vector: Vec3): number

package/src/maths/vec3/length.js

@@ -5,10 +5,10 @@
  * @returns {Number} length
  * @alias module:modeling/maths/vec3.length
  */
-const length = (a) => {
-  const x = a[0]
-  const y = a[1]
-  const z = a[2]
+const length = (vector) => {
+  const x = vector[0]
+  const y = vector[1]
+  const z = vector[2]
   return Math.hypot(x, y, z)
 }
 

package/src/maths/vec3/length.test.js

@@ -41,5 +41,15 @@ test('vec3: length() should return correct values', (t) => {
   const length9 = length(vec9)
   nearlyEqual(t, length9, 3.74165, EPS)
 
+  // huge vector
+  const vec10 = fromValues(1e200, 0, 1e200)
+  const length10 = length(vec10)
+  nearlyEqual(t, length10, Math.SQRT2 * 1e200, EPS)
+
+  // tiny vector
+  const vec11 = fromValues(1e-200, 0, 1e-200)
+  const length11 = length(vec11)
+  nearlyEqual(t, length11, Math.SQRT2 * 1e-200, EPS)
+
   t.true(true)
 })

package/src/maths/vec3/lerp.test.js

@@ -3,7 +3,7 @@ const { lerp, fromValues } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
-test('vec3: lerp() called with three paramerters should update a vec3 with correct values', (t) => {
+test('vec3: lerp() called with three parameters should update a vec3 with correct values', (t) => {
   const obs1 = fromValues(0, 0, 0)
   const ret1 = lerp(obs1, [0, 0, 0], [0, 0, 0], 0)
   t.true(compareVectors(obs1, [0, 0, 0]))

package/src/maths/vec3/multiply.test.js

@@ -3,7 +3,7 @@ const { multiply, fromValues } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
-test('vec3: multiply() called with three paramerters should update a vec3 with correct values', (t) => {
+test('vec3: multiply() called with three parameters should update a vec3 with correct values', (t) => {
   const obs1 = fromValues(0, 0, 0)
   const ret1 = multiply(obs1, [0, 0, 0], [0, 0, 0])
   t.true(compareVectors(obs1, [0, 0, 0]))

package/src/maths/vec3/negate.d.ts

@@ -2,4 +2,4 @@ import Vec3 from './type'
 
 export default negate
 
-declare function negate(out: Vec3, vec: Vec3): Vec3
+declare function negate(out: Vec3, vector: Vec3): Vec3

package/src/maths/vec3/negate.test.js

@@ -3,7 +3,7 @@ const { negate, fromValues } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
-test('vec3: negate() called with two paramerters should update a vec3 with correct values', (t) => {
+test('vec3: negate() called with two parameters should update a vec3 with correct values', (t) => {
   const obs1 = fromValues(0, 0, 0)
   const ret1 = negate(obs1, [0, 0, 0])
   t.true(compareVectors(obs1, [-0, -0, -0]))

package/src/maths/vec3/normalize.d.ts

@@ -2,4 +2,4 @@ import Vec3 from './type'
 
 export default normalize
 
-declare function normalize(out: Vec3, vec:  Vec3): Vec3
+declare function normalize(out: Vec3, vector: Vec3): Vec3

package/src/maths/vec3/normalize.test.js

@@ -3,7 +3,7 @@ const { normalize, fromValues } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
-test('vec3: normalize() called with two paramerters should update a vec3 with correct values', (t) => {
+test('vec3: normalize() called with two parameters should update a vec3 with correct values', (t) => {
   const obs1 = fromValues(0, 0, 0)
   const ret1 = normalize(obs1, [0, 0, 0])
   t.true(compareVectors(obs1, [0, 0, 0]))

package/src/maths/vec3/rotateX.test.js

@@ -3,7 +3,7 @@ const { rotateX, fromValues } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
-test('vec3: rotateX() called with four paramerters should update a vec3 with correct values', (t) => {
+test('vec3: rotateX() called with four parameters should update a vec3 with correct values', (t) => {
   const radians = 90 * Math.PI / 180
 
   const obs1 = fromValues(0, 0, 0)

package/src/maths/vec3/rotateY.test.js

@@ -3,7 +3,7 @@ const { rotateY, fromValues } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
-test('vec3: rotateY() called with three paramerters should update a vec3 with correct values', (t) => {
+test('vec3: rotateY() called with three parameters should update a vec3 with correct values', (t) => {
   const radians = 90 * Math.PI / 180
 
   const obs1 = fromValues(0, 0, 0)

package/src/maths/vec3/rotateZ.test.js

@@ -3,7 +3,7 @@ const { rotateZ, fromValues } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
-test('vec3: rotateZ() called with four paramerters should update a vec3 with correct values', (t) => {
+test('vec3: rotateZ() called with four parameters should update a vec3 with correct values', (t) => {
   const radians = 90 * Math.PI / 180
 
   const obs1 = fromValues(0, 0, 0)

package/src/maths/vec3/scale.test.js

@@ -3,7 +3,7 @@ const { scale, fromValues } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
-test('vec3: scale() called with three paramerters should update a vec3 with correct values', (t) => {
+test('vec3: scale() called with three parameters should update a vec3 with correct values', (t) => {
   const obs1 = fromValues(0, 0, 0)
   const ret1 = scale(obs1, [0, 0, 0], 0)
   t.true(compareVectors(obs1, [0, 0, 0]))

package/src/maths/vec3/squaredLength.d.ts

@@ -2,4 +2,4 @@ import Vec3 from './type'
 
 export default squaredLength
 
-declare function squaredLength(vec: Vec3): number
+declare function squaredLength(vector: Vec3): number

package/src/maths/vec3/squaredLength.js

@@ -5,10 +5,10 @@
  * @returns {Number} squared length
  * @alias module:modeling/maths/vec3.squaredLength
  */
-const squaredLength = (a) => {
-  const x = a[0]
-  const y = a[1]
-  const z = a[2]
+const squaredLength = (vector) => {
+  const x = vector[0]
+  const y = vector[1]
+  const z = vector[2]
   return x * x + y * y + z * z
 }
 

package/src/maths/vec3/subtract.test.js

@@ -3,7 +3,7 @@ const { subtract, fromValues } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
-test('vec3: subtract() called with three paramerters should update a vec3 with correct values', (t) => {
+test('vec3: subtract() called with three parameters should update a vec3 with correct values', (t) => {
   const obs1 = fromValues(0, 0, 0)
   const ret1 = subtract(obs1, [0, 0, 0], [0, 0, 0])
   t.true(compareVectors(obs1, [0, 0, 0]))

package/src/maths/vec3/toString.js

@@ -1,6 +1,6 @@
 /**
  * Convert the given vector to a representative string.
- * @param {vec3} vector - vector of reference
+ * @param {vec3} vec - vector of reference
  * @returns {String} string representation
  * @alias module:modeling/maths/vec3.toString
  */

package/src/maths/vec3/transform.test.js

@@ -3,7 +3,7 @@ const { transform, fromValues } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
-test('vec3: transform() called with three paramerters should update a vec3 with correct values', (t) => {
+test('vec3: transform() called with three parameters should update a vec3 with correct values', (t) => {
   const identityMatrix = [
     1, 0, 0, 0,
     0, 1, 0, 0,

package/src/maths/vec4/toString.js

@@ -1,7 +1,7 @@
 /**
  * Convert the given vector to a representative string.
  *
- * @param {vec4} vector - vector to convert
+ * @param {vec4} vec - vector to convert
  * @returns {String} representative string
  * @alias module:modeling/maths/vec4.toString
  */

package/src/maths/vec4/transform.test.js

@@ -3,7 +3,7 @@ const { transform, fromValues } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
-test('vec4: transform() called with three paramerters should update a vec4 with correct values', (t) => {
+test('vec4: transform() called with three parameters should update a vec4 with correct values', (t) => {
   const identityMatrix = [
     1, 0, 0, 0,
     0, 1, 0, 0,

package/src/measurements/measureBoundingBox.js

@@ -2,7 +2,6 @@ const flatten = require('../utils/flatten')
 
 const vec2 = require('../maths/vec2')
 const vec3 = require('../maths/vec3')
-const mat4 = require('../maths/mat4')
 
 const geom2 = require('../geometries/geom2')
 const geom3 = require('../geometries/geom3')
@@ -12,129 +11,86 @@ const poly3 = require('../geometries/poly3')
 const cache = new WeakMap()
 
 /*
- * Measure the min and max bounds of the given (path2) geometry.points.
- * @return {Array[]} the min and max bounds for the geometry.points
+ * Measure the min and max bounds of the given (path2) geometry.
+ * @return {Array[]} the min and max bounds for the geometry
  */
-const measureBoundingBoxOfPath2Points = (points) => {
-  let boundingBox = cache.get(points)
+const measureBoundingBoxOfPath2 = (geometry) => {
+  let boundingBox = cache.get(geometry)
   if (boundingBox) return boundingBox
 
+  const points = path2.toPoints(geometry)
+
   let minpoint
   if (points.length === 0) {
     minpoint = vec2.create()
   } else {
     minpoint = vec2.clone(points[0])
   }
-  const maxpoint = vec2.clone(minpoint)
+  let maxpoint = vec2.clone(minpoint)
 
   points.forEach((point) => {
     vec2.min(minpoint, minpoint, point)
     vec2.max(maxpoint, maxpoint, point)
   })
-  boundingBox = [[minpoint[0], minpoint[1], 0], [maxpoint[0], maxpoint[1], 0]]
+  minpoint = [minpoint[0], minpoint[1], 0]
+  maxpoint = [maxpoint[0], maxpoint[1], 0]
+
+  boundingBox = [minpoint, maxpoint]
+
+  cache.set(geometry, boundingBox)
 
-  cache.set(points, boundingBox)
   return boundingBox
 }
 
 /*
- * Measure the min and max bounds of the given (path2) geometry.
+ * Measure the min and max bounds of the given (geom2) geometry.
  * @return {Array[]} the min and max bounds for the geometry
  */
-const measureBoundingBoxOfPath2 = (geometry) => {
+const measureBoundingBoxOfGeom2 = (geometry) => {
   let boundingBox = cache.get(geometry)
   if (boundingBox) return boundingBox
 
-  if (mat4.isOnlyTransformScale(geometry.transforms)) {
-    // get boundingBox of original points and transform it
-    boundingBox = transformBoundingBox(measureBoundingBoxOfPath2Points(geometry.points), geometry.transforms)
+  const points = geom2.toPoints(geometry)
+
+  let minpoint
+  if (points.length === 0) {
+    minpoint = vec2.create()
   } else {
-    // transform the points and then caclulate the boundingBox
-    boundingBox = measureBoundingBoxOfPath2Points(path2.toPoints(geometry))
+    minpoint = vec2.clone(points[0])
   }
+  let maxpoint = vec2.clone(minpoint)
 
-  cache.set(geometry, boundingBox)
-  return boundingBox
-}
-
-/*
- * Measure the min and max bounds of the given (geom2) geometry.points/sides.
- * @return {Array[]} the min and max bounds for the geometr.points/sidesy
- */
-const measureBoundingBoxOfGeom2Points = ({ points, sides }) => {
-  const cacheKey = points || sides
-
-  let boundingBox = cache.get(cacheKey)
-  if (boundingBox) return boundingBox
+  points.forEach((point) => {
+    vec2.min(minpoint, minpoint, point)
+    vec2.max(maxpoint, maxpoint, point)
+  })
 
-  let minpoint, maxpoint
+  minpoint = [minpoint[0], minpoint[1], 0]
+  maxpoint = [maxpoint[0], maxpoint[1], 0]
 
-  if (points) {
-    if (points.length === 0) {
-      minpoint = vec2.create()
-    } else {
-      minpoint = vec2.clone(points[0])
-    }
-    maxpoint = vec2.clone(minpoint)
+  boundingBox = [minpoint, maxpoint]
 
-    points.forEach((point) => {
-      vec2.min(minpoint, minpoint, point)
-      vec2.max(maxpoint, maxpoint, point)
-    })
-  } else { // sides
-    // to avoid calling costly toPoints, we take advantage of the knowlege how the toPoints works
-    if (sides.length === 0) {
-      minpoint = vec2.create()
-    } else {
-      minpoint = vec2.clone(sides[0][0])
-    }
-    maxpoint = vec2.clone(minpoint)
-
-    sides.forEach((side) => {
-      vec2.min(minpoint, minpoint, side[0])
-      vec2.max(maxpoint, maxpoint, side[0])
-    })
-  }
-  boundingBox = [[minpoint[0], minpoint[1], 0], [maxpoint[0], maxpoint[1], 0]]
+  cache.set(geometry, boundingBox)
 
-  cache.set(cacheKey, boundingBox)
   return boundingBox
 }
 
 /*
- * Measure the min and max bounds of the given (geom2) geometry.
+ * Measure the min and max bounds of the given (geom3) geometry.
  * @return {Array[]} the min and max bounds for the geometry
  */
-const measureBoundingBoxOfGeom2 = (geometry) => {
+const measureBoundingBoxOfGeom3 = (geometry) => {
   let boundingBox = cache.get(geometry)
   if (boundingBox) return boundingBox
 
-  if (mat4.isOnlyTransformScale(geometry.transforms)) {
-    // get boundingBox of original points and transform it
-    boundingBox = transformBoundingBox(measureBoundingBoxOfGeom2Points(geometry), geometry.transforms)
-  } else {
-    // transform the points and then caclulate the boundingBox
-    boundingBox = measureBoundingBoxOfGeom2Points({ points: geom2.toPoints(geometry) })
-  }
-
-  cache.set(geometry, boundingBox)
-  return boundingBox
-}
-
-/*
- * Measure the min and max bounds of the given (geom3) geometry.polygons.
- * @return {Array[]} the min and max bounds for the geometry.polygons
- */
-const measureBoundingBoxOfGeom3Polygons = (polygons) => {
-  let boundingBox = cache.get(polygons)
-  if (boundingBox) return boundingBox
+  const polygons = geom3.toPolygons(geometry)
 
-  const minpoint = vec3.create()
+  let minpoint = vec3.create()
   if (polygons.length > 0) {
     const points = poly3.toPoints(polygons[0])
     vec3.copy(minpoint, points[0])
   }
-  const maxpoint = vec3.clone(minpoint)
+  let maxpoint = vec3.clone(minpoint)
 
   polygons.forEach((polygon) => {
     poly3.toPoints(polygon).forEach((point) => {
@@ -143,59 +99,13 @@ const measureBoundingBoxOfGeom3Polygons = (polygons) => {
     })
   })
 
-  boundingBox = [[minpoint[0], minpoint[1], minpoint[2]], [maxpoint[0], maxpoint[1], maxpoint[2]]]
+  minpoint = [minpoint[0], minpoint[1], minpoint[2]]
+  maxpoint = [maxpoint[0], maxpoint[1], maxpoint[2]]
 
-  cache.set(polygons, boundingBox)
-  return boundingBox
-}
-
-/*
- * Measure the min and max bounds of the given (geom3) geometry.
- * @return {Array[]} the min and max bounds for the geometry
- */
-const measureBoundingBoxOfGeom3 = (geometry) => {
-  let boundingBox = cache.get(geometry)
-  if (boundingBox) return boundingBox
-
-  if (mat4.isOnlyTransformScale(geometry.transforms)) {
-    // get boundingBox of original points and transform it
-    boundingBox = transformBoundingBox(measureBoundingBoxOfGeom3Polygons(geometry.polygons), geometry.transforms)
-  } else {
-    // transform the points and then caclulate the boundingBox
-    boundingBox = measureBoundingBoxOfGeom3Polygons(geom3.toPolygons(geometry))
-  }
+  boundingBox = [minpoint, maxpoint]
 
   cache.set(geometry, boundingBox)
-  return boundingBox
-}
 
-/*
- * swap values if specific axis value in the second vector has lower value than the axis value in first vector
- */
-const fixBound = (i, v1, v2) => {
-  if (v1[i] > v2[i]) {
-    const tmp = v1[i]
-    v1[i] = v2[i]
-    v2[i] = tmp
-  }
-}
-
-/*
- * Transform the given bounding box
- */
-const transformBoundingBox = (boundingBox, transforms) => {
-  if (!mat4.isIdentity(transforms)) {
-    vec3.transform(boundingBox[0], boundingBox[0], transforms)
-    vec3.transform(boundingBox[1], boundingBox[1], transforms)
-
-    // we now have a new 2 vectors:  [v1,v2] => [ [x1,y1,z1],  [x2,y2,z2] ]
-    // transform can move bounding box corner in such way that it is no longer true that
-    //  - v1 = [min(x1,x2),min(y1,y2),min(z1,z2)]
-    //  - v2 = [max(x1,x2),max(y1,y2),max(z1,z2)]
-    fixBound(0, ...boundingBox) // swap x, if higher value is in first vector
-    fixBound(1, ...boundingBox) // swap y, if higher value is in first vector
-    fixBound(2, ...boundingBox) // swap z, if higher value is in first vector
-  }
   return boundingBox
 }
 

package/src/measurements/measureBoundingSphere.js

@@ -24,7 +24,7 @@ const measureBoundingSphereOfPath2 = (geometry) => {
   const points = path2.toPoints(geometry)
 
   if (points.length > 0) {
-    // calculate the centriod of the geometry
+    // calculate the centroid of the geometry
     let numPoints = 0
     const temp = vec3.create()
     points.forEach((point) => {
@@ -60,7 +60,7 @@ const measureBoundingSphereOfGeom2 = (geometry) => {
   const sides = geom2.toSides(geometry)
 
   if (sides.length > 0) {
-    // calculate the centriod of the geometry
+    // calculate the centroid of the geometry
     let numPoints = 0
     const temp = vec3.create()
     sides.forEach((side) => {
@@ -96,7 +96,7 @@ const measureBoundingSphereOfGeom3 = (geometry) => {
   const polygons = geom3.toPolygons(geometry)
 
   if (polygons.length > 0) {
-    // calculate the centriod of the geometry
+    // calculate the centroid of the geometry
     let numPoints = 0
     polygons.forEach((polygon) => {
       poly3.toPoints(polygon).forEach((point) => {
@@ -122,7 +122,7 @@ const measureBoundingSphereOfGeom3 = (geometry) => {
 }
 
 /**
- * Measure the (aproximate) bounding sphere of the given geometries.
+ * Measure the (approximate) bounding sphere of the given geometries.
  * @see https://en.wikipedia.org/wiki/Bounding_sphere
  * @param {...Object} geometries - the geometries to measure
  * @return {Array} the bounding sphere for each geometry, i.e. [centroid, radius]

package/src/measurements/measureCenterOfMass.js

@@ -61,7 +61,7 @@ const measureCenterOfMassGeom3 = (geometry) => {
   let totalVolume = 0
   const vector = vec3.create() // for speed
   polygons.forEach((polygon) => {
-    // calculate volume and center of each tetrahedon
+    // calculate volume and center of each tetrahedron
     const vertices = polygon.vertices
     for (let i = 0; i < vertices.length - 2; i++) {
       vec3.cross(vector, vertices[i + 1], vertices[i + 2])

package/src/operations/booleans/mayOverlap.js

@@ -4,9 +4,9 @@ const measureBoundingBox = require('../../measurements/measureBoundingBox')
 
 /*
  * Determine if the given geometries overlap by comparing min and max bounds.
- * NOTE: This is used in union for performace gains.
- * @param {geom3} geometry1 - geometry for comparision
- * @param {geom3} geometry2 - geometry for comparision
+ * NOTE: This is used in union for performance gains.
+ * @param {geom3} geometry1 - geometry for comparison
+ * @param {geom3} geometry2 - geometry for comparison
  * @returns {boolean} true if the geometries overlap
  */
 const mayOverlap = (geometry1, geometry2) => {

package/src/operations/booleans/retessellate.js

@@ -3,16 +3,14 @@ const poly3 = require('../../geometries/poly3')
 
 const reTesselateCoplanarPolygons = require('./reTesselateCoplanarPolygons')
 
-// Normals are directional vectors with component values from 0 to 1.0, requiring specialized comparision
-// This EPS is derived from a serieas of tests to determine the optimal precision for comparing coplanar polygons,
+// Normals are directional vectors with component values from 0 to 1.0, requiring specialized comparison
+// This EPS is derived from a series of tests to determine the optimal precision for comparing coplanar polygons,
 // as provided by the sphere primitive at high segmentation
 // This EPS is for 64 bit Number values
 const NEPS = 1e-13
 
 // Compare two normals (unit vectors) for equality.
-const aboutEqualNormals = (a, b) => {
-  return (Math.abs(a[0] - b[0]) <= NEPS && Math.abs(a[1] - b[1]) <= NEPS && Math.abs(a[2] - b[2]) <= NEPS)
-}
+const aboutEqualNormals = (a, b) => (Math.abs(a[0] - b[0]) <= NEPS && Math.abs(a[1] - b[1]) <= NEPS && Math.abs(a[2] - b[2]) <= NEPS)
 
 const coplanar = (plane1, plane2) => {
   // expect the same distance from the origin, within tolerance

package/src/operations/booleans/scission.js

@@ -9,7 +9,7 @@ const scissionGeom3 = require('./scissionGeom3')
 /**
  * Scission (divide) the given geometry into the component pieces.
  *
- * @param {...Object} geometries - list of geometries
+ * @param {...Object} objects - list of geometries
  * @returns {Array} list of pieces from each geometry
  * @alias module:modeling/booleans.scission
  *

package/src/operations/booleans/subtract.js

@@ -17,7 +17,7 @@ const subtractGeom3 = require('./subtractGeom3')
  * @alias module:modeling/booleans.subtract
  *
  * @example
- * let myshape = subtract(cubiod({size: [5,5,5]}), cubiod({size: [5,5,5], center: [5,5,5]}))
+ * let myshape = subtract(cuboid({size: [5,5,5]}), cuboid({size: [5,5,5], center: [5,5,5]}))
  *
  * @example
  * +-------+            +-------+

package/src/operations/booleans/union.test.js

@@ -198,7 +198,7 @@ test('union of one or more geom3 objects produces expected geometry', (t) => {
 
 test('union of geom3 with rounding issues #137', (t) => {
   const geometry1 = center({ relativeTo: [0, 0, -1] }, cuboid({ size: [44, 26, 5] }))
-  const geometry2 = center({ relativeTo: [0, 0, -4.400001] }, cuboid({ size: [44, 26, 1.8] })) // introduce percision error
+  const geometry2 = center({ relativeTo: [0, 0, -4.400001] }, cuboid({ size: [44, 26, 1.8] })) // introduce precision error
 
   const obs = union(geometry1, geometry2)
   const pts = geom3.toPoints(obs)