@jscad/modeling 2.9.0 → 2.9.3

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@jscad/modeling",
-  "version": "2.9.0",
+  "version": "2.9.3",
   "description": "Constructive Solid Geometry (CSG) Library for JSCAD",
+  "homepage": "https://openjscad.xyz/",
   "repository": "https://github.com/jscad/OpenJSCAD.org",
   "main": "src/index.js",
   "types": "src/index.d.ts",
@@ -60,5 +61,5 @@
     "nyc": "15.1.0",
     "uglifyify": "5.0.2"
   },
-  "gitHead": "45fbcb7298fcacf3e45d67fdca32d0744ab7f2de"
+  "gitHead": "85fa1fcdfb2d516a201ecf31da242e64b5b3274e"
 }

package/src/colors/colorize.test.js

@@ -38,7 +38,7 @@ test('color (rgba on geometry)', (t) => {
   const obj0 = geom2.fromPoints([[0, 0], [1, 0], [0, 1]])
   const obj1 = geom3.fromPoints([[[0, 0, 0], [1, 0, 0], [1, 0, 1]]])
   const obj2 = path2.fromPoints({ closed: true }, [[0, 0], [1, 0], [1, 1]])
-  const obj3 = poly3.fromPoints([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
+  const obj3 = poly3.create([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
 
   const obs = colorize([1, 1, 0.5, 0.8], obj0, obj1, obj2, obj3)
   t.is(obs.length, 4)

package/src/geometries/geom2/index.d.ts

@@ -10,6 +10,7 @@ export { default as toSides } from './toSides'
 export { default as toString } from './toString'
 export { default as toCompactBinary } from './toCompactBinary'
 export { default as transform } from './transform'
+export { default as validate } from './validate'
 
 export { default as Geom2 } from './type'
 export as namespace geom2

package/src/geometries/geom2/index.js

@@ -25,5 +25,6 @@ module.exports = {
   toSides: require('./toSides'),
   toString: require('./toString'),
   toCompactBinary: require('./toCompactBinary'),
-  transform: require('./transform')
+  transform: require('./transform'),
+  validate: require('./validate')
 }

package/src/geometries/geom2/toOutlines.js

@@ -6,22 +6,42 @@ const toSides = require('./toSides')
  * Create a list of edges which SHARE vertices.
  * This allows the edges to be traversed in order.
  */
-const toEdges = (sides) => {
-  const vertices = {}
+const toSharedVertices = (sides) => {
+  const unique = new Map() // {key: vertex}
   const getUniqueVertex = (vertex) => {
     const key = vertex.toString()
-    if (!vertices[key]) {
-      vertices[key] = vertex
+    if (unique.has(key)) {
+      return unique.get(key)
+    } else {
+      unique.set(key, vertex)
+      return vertex
     }
-    return vertices[key]
   }
 
   return sides.map((side) => side.map(getUniqueVertex))
 }
 
+/*
+ * Convert a list of sides into a map from vertex to edges.
+ */
+const toVertexMap = (sides) => {
+  const vertexMap = new Map()
+  // first map to edges with shared vertices
+  const edges = toSharedVertices(sides)
+  // construct adjacent edges map
+  edges.forEach((edge) => {
+    if (vertexMap.has(edge[0])) {
+      vertexMap.get(edge[0]).push(edge)
+    } else {
+      vertexMap.set(edge[0], [edge])
+    }
+  })
+  return vertexMap
+}
+
 /**
  * Create the outline(s) of the given geometry.
- * @param  {geom2} geometry
+ * @param {geom2} geometry - geometry to create outlines from
  * @returns {Array} an array of outlines, where each outline is an array of ordered points
  * @alias module:modeling/geometries/geom2.toOutlines
  *
@@ -30,65 +50,35 @@ const toEdges = (sides) => {
  * let outlines = toOutlines(geometry) // returns two outlines
  */
 const toOutlines = (geometry) => {
-  const vertexMap = new Map()
-  const edges = toEdges(toSides(geometry))
-  edges.forEach((edge) => {
-    if (!(vertexMap.has(edge[0]))) {
-      vertexMap.set(edge[0], [])
-    }
-    const sideslist = vertexMap.get(edge[0])
-    sideslist.push(edge)
-  })
-
+  const vertexMap = toVertexMap(toSides(geometry)) // {vertex: [edges]}
   const outlines = []
   while (true) {
-    let startside
+    let startSide
     for (const [vertex, edges] of vertexMap) {
-      startside = edges.shift()
-      if (!startside) {
+      startSide = edges.shift()
+      if (!startSide) {
         vertexMap.delete(vertex)
         continue
       }
       break
     }
-    if (startside === undefined) break // all starting sides have been visited
+    if (startSide === undefined) break // all starting sides have been visited
 
     const connectedVertexPoints = []
-    const startvertex = startside[0]
-    const v0 = vec2.create()
+    const startVertex = startSide[0]
     while (true) {
-      connectedVertexPoints.push(startside[0])
-      const nextvertex = startside[1]
-      if (nextvertex === startvertex) break // the outline has been closed
-      const nextpossiblesides = vertexMap.get(nextvertex)
-      if (!nextpossiblesides) {
-        throw new Error('the given geometry is not closed. verify proper construction')
+      connectedVertexPoints.push(startSide[0])
+      const nextVertex = startSide[1]
+      if (nextVertex === startVertex) break // the outline has been closed
+      const nextPossibleSides = vertexMap.get(nextVertex)
+      if (!nextPossibleSides) {
+        throw new Error(`geometry is not closed at vertex ${nextVertex}`)
       }
-      let nextsideindex = -1
-      if (nextpossiblesides.length === 1) {
-        nextsideindex = 0
-      } else {
-        // more than one side starting at the same vertex
-        let bestangle
-        const startangle = vec2.angleDegrees(vec2.subtract(v0, startside[1], startside[0]))
-        for (let sideindex = 0; sideindex < nextpossiblesides.length; sideindex++) {
-          const nextpossibleside = nextpossiblesides[sideindex]
-          const nextangle = vec2.angleDegrees(vec2.subtract(v0, nextpossibleside[1], nextpossibleside[0]))
-          let angledif = nextangle - startangle
-          if (angledif < -180) angledif += 360
-          if (angledif >= 180) angledif -= 360
-          if ((nextsideindex < 0) || (angledif > bestangle)) {
-            nextsideindex = sideindex
-            bestangle = angledif
-          }
-        }
+      const nextSide = popNextSide(startSide, nextPossibleSides)
+      if (nextPossibleSides.length === 0) {
+        vertexMap.delete(nextVertex)
       }
-      const nextside = nextpossiblesides[nextsideindex]
-      nextpossiblesides.splice(nextsideindex, 1) // remove side from list
-      if (nextpossiblesides.length === 0) {
-        vertexMap.delete(nextvertex)
-      }
-      startside = nextside
+      startSide = nextSide
     } // inner loop
 
     // due to the logic of fromPoints()
@@ -102,4 +92,28 @@ const toOutlines = (geometry) => {
   return outlines
 }
 
+// find the first counter-clockwise edge from startSide and pop from nextSides
+const popNextSide = (startSide, nextSides) => {
+  if (nextSides.length === 1) {
+    return nextSides.pop()
+  }
+  const v0 = vec2.create()
+  const startAngle = vec2.angleDegrees(vec2.subtract(v0, startSide[1], startSide[0]))
+  let bestAngle
+  let bestIndex
+  nextSides.forEach((nextSide, index) => {
+    const nextAngle = vec2.angleDegrees(vec2.subtract(v0, nextSide[1], nextSide[0]))
+    let angle = nextAngle - startAngle
+    if (angle < -180) angle += 360
+    if (angle >= 180) angle -= 360
+    if (bestIndex === undefined || angle > bestAngle) {
+      bestIndex = index
+      bestAngle = angle
+    }
+  })
+  const nextSide = nextSides[bestIndex]
+  nextSides.splice(bestIndex, 1) // remove side from list
+  return nextSide
+}
+
 module.exports = toOutlines

package/src/geometries/geom2/validate.d.ts

@@ -0,0 +1,3 @@
+export default validate
+
+declare function validate(object: any): void

package/src/geometries/geom2/validate.js

@@ -0,0 +1,36 @@
+const vec2 = require('../../maths/vec2')
+const isA = require('./isA')
+const toOutlines = require('./toOutlines')
+
+/**
+ * Determine if the given object is a valid geom2.
+ * Checks for closedness, self-edges, and valid data points.
+ *
+ * **If the geometry is not valid, an exception will be thrown with details of the geometry error.**
+ *
+ * @param {Object} object - the object to interrogate
+ * @throws {Error} error if the geometry is not valid
+ * @alias module:modeling/geometries/geom2.validate
+ */
+const validate = (object) => {
+  if (!isA(object)) {
+    throw new Error('invalid geom2 structure')
+  }
+
+  // check for closedness
+  toOutlines(object)
+
+  // check for self-edges
+  object.sides.forEach((side) => {
+    if (vec2.equals(side[0], side[1])) {
+      throw new Error(`geom2 self-edge ${side[0]}`)
+    }
+  })
+
+  // check transforms
+  if (!object.transforms.every(Number.isFinite)) {
+    throw new Error(`geom2 invalid transforms ${object.transforms}`)
+  }
+}
+
+module.exports = validate

package/src/geometries/geom3/create.js

@@ -18,7 +18,7 @@ const create = (polygons) => {
     polygons = [] // empty contents
   }
   return {
-    polygons: polygons,
+    polygons,
     transforms: mat4.create()
   }
 }

package/src/geometries/geom3/create.test.js

@@ -14,7 +14,7 @@ test('create: Creates an empty geom3', (t) => {
 
 test('create: Creates a populated geom3', (t) => {
   const points = [[0, 0, 0], [0, 10, 0], [0, 10, 10]]
-  const polygon = poly3.fromPoints(points)
+  const polygon = poly3.create(points)
 
   const polygons = [polygon]
   const expected = {

package/src/geometries/geom3/fromPoints.js

@@ -18,7 +18,7 @@ const fromPoints = (listofpoints) => {
 
   const polygons = listofpoints.map((points, index) => {
     // TODO catch the error, and rethrow with index
-    const polygon = poly3.fromPoints(points)
+    const polygon = poly3.create(points)
     return polygon
   })
   const result = create(polygons)

package/src/geometries/geom3/index.d.ts

@@ -9,6 +9,7 @@ export { default as toPolygons } from './toPolygons'
 export { default as toString } from './toString'
 export { default as toCompactBinary } from './toCompactBinary'
 export { default as transform } from './transform'
+export { default as validate } from './validate'
 
 export { default as Geom3 } from './type'
 export as namespace geom3

package/src/geometries/geom3/index.js

@@ -31,5 +31,6 @@ module.exports = {
   toPolygons: require('./toPolygons'),
   toString: require('./toString'),
   toCompactBinary: require('./toCompactBinary'),
-  transform: require('./transform')
+  transform: require('./transform'),
+  validate: require('./validate')
 }

package/src/geometries/geom3/isA.js

@@ -1,6 +1,6 @@
 /**
  * Determine if the given object is a 3D geometry.
- * @param {object} object - the object to interrogate
+ * @param {Object} object - the object to interrogate
  * @returns {Boolean} true if the object matches a geom3
  * @alias module:modeling/geometries/geom3.isA
  */

package/src/geometries/geom3/validate.d.ts

@@ -0,0 +1,3 @@
+export default validate
+
+declare function validate(object: any): void

package/src/geometries/geom3/validate.js

@@ -0,0 +1,62 @@
+const poly3 = require('../poly3')
+const isA = require('./isA')
+
+/**
+ * Determine if the given object is a valid 3D geometry.
+ * Checks for valid data structure, convex polygon faces, and manifold edges.
+ *
+ * **If the geometry is not valid, an exception will be thrown with details of the geometry error.**
+ *
+ * @param {Object} object - the object to interrogate
+ * @throws {Error} error if the geometry is not valid
+ * @alias module:modeling/geometries/geom3.validate
+ */
+const validate = (object) => {
+  if (!isA(object)) {
+    throw new Error('invalid geom3 structure')
+  }
+
+  // check polygons
+  object.polygons.forEach(poly3.validate)
+  validateManifold(object)
+
+  // check transforms
+  if (!object.transforms.every(Number.isFinite)) {
+    throw new Error(`geom3 invalid transforms ${object.transforms}`)
+  }
+
+  // TODO: check for self-intersecting
+}
+
+/*
+ * Check manifold edge condition: Every edge is in exactly 2 faces
+ */
+const validateManifold = (object) => {
+  // count of each edge
+  const edgeCount = new Map()
+  object.polygons.forEach(({ vertices }) => {
+    vertices.forEach((v, i) => {
+      const v1 = `${v}`
+      const v2 = `${vertices[(i + 1) % vertices.length]}`
+      // sort for undirected edge
+      const edge = `${v1}/${v2}`
+      const count = edgeCount.has(edge) ? edgeCount.get(edge) : 0
+      edgeCount.set(edge, count + 1)
+    })
+  })
+
+  // check that edges are always matched
+  const nonManifold = []
+  edgeCount.forEach((count, edge) => {
+    const complementEdge = edge.split('/').reverse().join('/')
+    const complementCount = edgeCount.get(complementEdge)
+    if (count !== complementCount) {
+      nonManifold.push(edge.replace('/', ' -> '))
+    }
+  })
+  if (nonManifold.length > 0) {
+    throw new Error(`non-manifold edges ${nonManifold.length}\n${nonManifold.join('\n')}`)
+  }
+}
+
+module.exports = validate

package/src/geometries/path2/index.d.ts

@@ -5,7 +5,6 @@ export { default as clone } from './clone'
 export { default as close } from './close'
 export { default as concat } from './concat'
 export { default as create } from './create'
-export { default as eachPoint, EachPointOptions } from './eachPoint'
 export { default as equals } from './equals'
 export { default as fromPoints, FromPointsOptions } from './fromPoints'
 export { default as fromCompactBinary } from './fromCompactBinary'
@@ -15,6 +14,7 @@ export { default as toPoints } from './toPoints'
 export { default as toString } from './toString'
 export { default as toCompactBinary } from './toCompactBinary'
 export { default as transform } from './transform'
+export { default as validate } from './validate'
 
 export { default as Path2 } from './type'
 export as namespace path2

package/src/geometries/path2/index.js

@@ -22,7 +22,6 @@ module.exports = {
   close: require('./close'),
   concat: require('./concat'),
   create: require('./create'),
-  eachPoint: require('./eachPoint'),
   equals: require('./equals'),
   fromPoints: require('./fromPoints'),
   fromCompactBinary: require('./fromCompactBinary'),
@@ -31,5 +30,6 @@ module.exports = {
   toPoints: require('./toPoints'),
   toString: require('./toString'),
   toCompactBinary: require('./toCompactBinary'),
-  transform: require('./transform')
+  transform: require('./transform'),
+  validate: require('./validate')
 }

package/src/geometries/path2/validate.d.ts

@@ -0,0 +1,3 @@
+export default validate
+
+declare function validate(object: any): void

package/src/geometries/path2/validate.js

@@ -0,0 +1,41 @@
+const vec2 = require('../../maths/vec2')
+const isA = require('./isA')
+
+/**
+ * Determine if the given object is a valid path2.
+ * Checks for valid data points, and duplicate points.
+ *
+ * **If the geometry is not valid, an exception will be thrown with details of the geometry error.**
+ *
+ * @param {Object} object - the object to interrogate
+ * @throws {Error} error if the geometry is not valid
+ * @alias module:modeling/geometries/path2.validate
+ */
+const validate = (object) => {
+  if (!isA(object)) {
+    throw new Error('invalid path2 structure')
+  }
+
+  // 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])) {
+        throw new Error(`path2 duplicate points ${object.points[i]}`)
+      }
+    }
+  }
+
+  // check for infinity, nan
+  object.points.forEach((point) => {
+    if (!point.every(Number.isFinite)) {
+      throw new Error(`path2 invalid point ${point}`)
+    }
+  })
+
+  // check transforms
+  if (!object.transforms.every(Number.isFinite)) {
+    throw new Error(`path2 invalid transforms ${object.transforms}`)
+  }
+}
+
+module.exports = validate

package/src/geometries/poly2/arePointsInside.js

@@ -23,41 +23,6 @@ const arePointsInside = (points, polygon) => {
   return sum === points.length ? 1 : 0
 }
 
-/*
- * Determine if the given point is inside the polygon.
- *
- * @see http://geomalgorithms.com/a03-_inclusion.html
- * @param {Array} point - an array with X and Y values
- * @param {Array} polygon - a list of points, where each point is an array with X and Y values
- * @return {Integer} 1 if the point is inside, 0 if outside
- */
-const isPointInsideOld = (point, polygon) => {
-  let wn = 0
-  const n = polygon.length
-  const x = point[0]
-  const y = point[1]
-  for (let i = 0; i < polygon.length; i++) {
-    const p1 = polygon[i]
-    const p2 = polygon[(i + 1) % n]
-    if (x !== p1[0] && y !== p1[1] && x !== p2[0] && y !== p2[1]) { // no overlap of points
-      if (p1[1] <= y) {
-        if (p2[1] > y) { // upward crossing
-          if (isLeft(p1, p2, point) > 0) { // point left of edge
-            wn++
-          }
-        }
-      } else {
-        if (p2[1] <= y) { // downward crossing
-          if (isLeft(p1, p2, point) < 0) { // point right of edge
-            wn--
-          }
-        }
-      }
-    }
-  }
-  return wn === 0 ? 1 : 0
-}
-
 /*
  * Determine if the given point is inside the polygon.
  *

package/src/geometries/poly3/create.js

@@ -18,7 +18,7 @@ const create = (vertices) => {
   if (vertices === undefined || vertices.length < 3) {
     vertices = [] // empty contents
   }
-  return { vertices: vertices }
+  return { vertices }
 }
 
 module.exports = create

package/src/geometries/poly3/index.d.ts

@@ -13,6 +13,7 @@ export { default as plane } from './plane'
 export { default as toPoints } from './toPoints'
 export { default as toString } from './toString'
 export { default as transform } from './transform'
+export { default as validate } from './validate'
 
 export { default as Poly3 } from './type'
 export as namespace poly3

package/src/geometries/poly3/index.js

@@ -24,5 +24,6 @@ module.exports = {
   plane: require('./plane'),
   toPoints: require('./toPoints'),
   toString: require('./toString'),
-  transform: require('./transform')
+  transform: require('./transform'),
+  validate: require('./validate')
 }

package/src/geometries/poly3/measureArea.test.js

@@ -62,10 +62,10 @@ test('poly3: measureArea() should return correct values', (t) => {
   ret2 = measureArea(ply2)
   ret3 = measureArea(ply3)
   ret4 = measureArea(ply4)
-  nearlyEqual(ret1, 0.0, Number.EPSILON)
-  nearlyEqual(ret2, 50.0, Number.EPSILON)
-  nearlyEqual(ret3, 100.0, Number.EPSILON)
-  nearlyEqual(ret4, 19.5, Number.EPSILON)
+  nearlyEqual(t, ret1, 0.0, Number.EPSILON)
+  nearlyEqual(t, ret2, 50.0, Number.EPSILON)
+  nearlyEqual(t, ret3, 100.0, Number.EPSILON)
+  nearlyEqual(t, ret4, 19.5, Number.EPSILON)
 
   rotation = mat4.fromYRotation(mat4.create(), (45 * 0.017453292519943295))
   ply1 = transform(rotation, ply1)
@@ -76,10 +76,10 @@ test('poly3: measureArea() should return correct values', (t) => {
   ret2 = measureArea(ply2)
   ret3 = measureArea(ply3)
   ret4 = measureArea(ply4)
-  nearlyEqual(ret1, 0.0, Number.EPSILON)
-  nearlyEqual(ret2, 50.0, Number.EPSILON)
-  nearlyEqual(ret3, 100.0, Number.EPSILON)
-  nearlyEqual(ret4, 19.5, Number.EPSILON)
+  nearlyEqual(t, ret1, 0.0, Number.EPSILON)
+  nearlyEqual(t, ret2, 50.0, Number.EPSILON)
+  nearlyEqual(t, ret3, 100.0, Number.EPSILON)
+  nearlyEqual(t, ret4, 19.5, Number.EPSILON)
 
   rotation = mat4.fromXRotation(mat4.create(), (45 * 0.017453292519943295))
   ply1 = transform(rotation, ply1)
@@ -90,10 +90,10 @@ test('poly3: measureArea() should return correct values', (t) => {
   ret2 = measureArea(ply2)
   ret3 = measureArea(ply3)
   ret4 = measureArea(ply4)
-  nearlyEqual(ret1, 0.0, Number.EPSILON)
-  nearlyEqual(ret2, 50.0, Number.EPSILON)
-  nearlyEqual(ret3, 100.0, Number.EPSILON)
-  nearlyEqual(ret4, 19.5, Number.EPSILON)
+  nearlyEqual(t, ret1, 0.0, Number.EPSILON)
+  nearlyEqual(t, ret2, 50.0, Number.EPSILON)
+  nearlyEqual(t, ret3, 100.0, Number.EPSILON)
+  nearlyEqual(t, ret4, 19.5, Number.EPSILON)
 
   // inverted
   ply1 = invert(ply1)
@@ -104,8 +104,8 @@ test('poly3: measureArea() should return correct values', (t) => {
   ret2 = measureArea(ply2)
   ret3 = measureArea(ply3)
   ret4 = measureArea(ply4)
-  nearlyEqual(ret1, 0.0, Number.EPSILON)
-  nearlyEqual(ret2, 50.0, Number.EPSILON)
-  nearlyEqual(ret3, 100.0, Number.EPSILON)
-  nearlyEqual(ret4, 19.5, Number.EPSILON)
+  nearlyEqual(t, ret1, 0.0, Number.EPSILON)
+  nearlyEqual(t, ret2, 50.0, Number.EPSILON)
+  nearlyEqual(t, ret3, 100.0, Number.EPSILON)
+  nearlyEqual(t, ret4, 19.5, Number.EPSILON * 2)
 })

package/src/geometries/poly3/measureBoundingSphere.test.js

@@ -10,21 +10,21 @@ test('poly3: measureBoundingSphere() should return correct values', (t) => {
   let exp1 = [[0, 0, 0], 0]
   let ret1 = measureBoundingSphere(ply1)
   t.true(compareVectors(ret1[0], exp1[0]))
-  nearlyEqual(ret1[1], exp1[1], Number.EPSILON)
+  nearlyEqual(t, ret1[1], exp1[1], Number.EPSILON)
 
   // simple triangle
   let ply2 = fromPoints([[0, 0, 0], [0, 10, 0], [0, 10, 10]])
   let exp2 = [[0, 5, 5], 7.0710678118654755]
   let ret2 = measureBoundingSphere(ply2)
   t.true(compareVectors(ret2[0], exp2[0]))
-  nearlyEqual(ret2[1], exp2[1], Number.EPSILON)
+  nearlyEqual(t, ret2[1], exp2[1], Number.EPSILON)
 
   // simple square
   let ply3 = fromPoints([[0, 0, 0], [0, 10, 0], [0, 10, 10], [0, 0, 10]])
   let exp3 = [[0, 5, 5], 7.0710678118654755]
   let ret3 = measureBoundingSphere(ply3)
   t.true(compareVectors(ret3[0], exp3[0]))
-  nearlyEqual(ret3[1], exp3[1], Number.EPSILON)
+  nearlyEqual(t, ret3[1], exp3[1], Number.EPSILON)
 
   // V-shape
   const points = [
@@ -43,7 +43,7 @@ test('poly3: measureBoundingSphere() should return correct values', (t) => {
   let exp4 = [[0, 4.5, 3], 4.6097722286464435]
   let ret4 = measureBoundingSphere(ply4)
   t.true(compareVectors(ret4[0], exp4[0]))
-  nearlyEqual(ret4[1], exp4[1], Number.EPSILON)
+  nearlyEqual(t, ret4[1], exp4[1], Number.EPSILON)
 
   // rotated to various angles
   const rotation = mat4.fromZRotation(mat4.create(), (45 * 0.017453292519943295))
@@ -57,14 +57,14 @@ test('poly3: measureBoundingSphere() should return correct values', (t) => {
   ret4 = measureBoundingSphere(ply4)
   exp1 = [[0, 0, 0], 0]
   t.true(compareVectors(ret1[0], exp1[0]))
-  nearlyEqual(ret1[1], exp1[1], Number.EPSILON)
+  nearlyEqual(t, ret1[1], exp1[1], Number.EPSILON)
   exp2 = [[-3.5355339059327373, 3.5355339059327378, 5], 7.0710678118654755]
   t.true(compareVectors(ret2[0], exp2[0]))
-  nearlyEqual(ret2[1], exp2[1], Number.EPSILON)
+  nearlyEqual(t, ret2[1], exp2[1], Number.EPSILON)
   exp3 = [[-3.5355339059327373, 3.5355339059327378, 5], 7.0710678118654755]
   t.true(compareVectors(ret3[0], exp3[0]))
-  nearlyEqual(ret3[1], exp3[1], Number.EPSILON)
+  nearlyEqual(t, ret3[1], exp3[1], Number.EPSILON)
   exp4 = [[-3.181980515339464, 3.1819805153394642, 3], 4.6097722286464435]
   t.true(compareVectors(ret4[0], exp4[0]))
-  nearlyEqual(ret4[1], exp4[1], Number.EPSILON)
+  nearlyEqual(t, ret4[1], exp4[1], Number.EPSILON)
 })

package/src/geometries/poly3/validate.d.ts

@@ -0,0 +1,4 @@
+
+export default validate
+
+declare function validate(object: any): void