@jscad/modeling 2.11.1 → 3.0.0-alpha.0

package/src/geometries/geom2/validate.js

@@ -1,6 +1,9 @@
-const vec2 = require('../../maths/vec2')
-const isA = require('./isA')
-const toOutlines = require('./toOutlines')
+import * as vec2 from '../../maths/vec2/index.js'
+
+import { intersect } from '../../maths/utils/intersect.js'
+
+import { isA } from './isA.js'
+import { toOutlines } from './toOutlines.js'
 
 /**
  * Determine if the given object is a valid geom2.
@@ -8,22 +11,42 @@ const toOutlines = require('./toOutlines')
  *
  * **If the geometry is not valid, an exception will be thrown with details of the geometry error.**
  *
- * @param {Object} object - the object to interrogate
+ * @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) => {
+export const validate = (object) => {
   if (!isA(object)) {
     throw new Error('invalid geom2 structure')
   }
 
-  // check for closedness
-  toOutlines(object)
+  object.outlines.forEach((outline, i) => {
+    if (outline.length < 3) {
+      throw new Error(`geom2 outline ${i} must contain at least 3 points`)
+    }
+    // check for duplicate points
+    for (let i = 0; i < outline.length; i++) {
+      const j = (i + 1) % outline.length
+      if (vec2.equals(outline[i], outline[j])) {
+        throw new Error(`geom2 outline ${i} has duplicate point ${outline[i]}`)
+      }
+    }
+  })
 
-  // check for self-edges
-  object.sides.forEach((side) => {
-    if (vec2.equals(side[0], side[1])) {
-      throw new Error(`geom2 self-edge ${side[0]}`)
+  // check for self-intersection
+  toOutlines(object).forEach((outline, i) => {
+    // check for intersection between [a1, a2] and [b1, b2]
+    for (let a1 = 0; a1 < outline.length; a1++) {
+      const a2 = (a1 + 1) % outline.length
+      for (let b1 = 0; b1 < outline.length; b1++) {
+        const b2 = (b1 + 1) % outline.length
+        if (a1 !== b1) {
+          const int = intersect(outline[a1], outline[a2], outline[b1], outline[b2], false)
+          if (int) {
+            throw new Error(`geom2 outline ${i} self intersection at ${int}`)
+          }
+        }
+      }
     }
   })
 
@@ -32,5 +55,3 @@ const validate = (object) => {
     throw new Error(`geom2 invalid transforms ${object.transforms}`)
   }
 }
-
-module.exports = validate

package/src/geometries/geom2/validate.test.js

@@ -0,0 +1,39 @@
+import test from 'ava'
+
+import * as vec2 from '../../maths/vec2/index.js'
+import { create, validate } from './index.js'
+
+// points of a square
+// D-C
+// | |
+// A-B
+const a = vec2.fromValues(0, 0)
+const b = vec2.fromValues(1, 0)
+const c = vec2.fromValues(1, 1)
+const d = vec2.fromValues(0, 1)
+
+test('validate: allow valid geom2', (t) => {
+  const geometry = create([[a, b, c, d]])
+  t.notThrows(() => validate(geometry))
+})
+
+test('validate: throw exception for self-edge', (t) => {
+  const geometry = create([[a, b, b, c]])
+  t.throws(() => validate(geometry))
+})
+
+test('validate: throw exception for self-intersecting polygon', (t) => {
+  const bowtie = [a, d, b, c]
+  const geometry = create([bowtie])
+  t.throws(() => validate(geometry))
+})
+
+test('validate: throw exception for nan', (t) => {
+  const geometry = create([[a, b, c, [0, NaN]]])
+  t.throws(() => validate(geometry))
+})
+
+test('validate: throw exception for infinity', (t) => {
+  const geometry = create([[a, b, c, [0, Infinity]]])
+  t.throws(() => validate(geometry))
+})

package/src/geometries/geom3/applyTransforms.js

@@ -1,16 +1,16 @@
-const mat4 = require('../../maths/mat4')
+import * as mat4 from '../../maths/mat4/index.js'
 
-const poly3 = require('../poly3')
+import * as poly3 from '../poly3/index.js'
 
 /*
  * Apply the transforms of the given geometry.
  * NOTE: This function must be called BEFORE exposing any data. See toPolygons.
- * @param {geom3} geometry - the geometry to transform
- * @returns {geom3} the given geometry
+ * @param {Geom3} geometry - the geometry to transform
+ * @returns {Geom3} the given geometry
  * @example
  * geometry = applyTransforms(geometry)
  */
-const applyTransforms = (geometry) => {
+export const applyTransforms = (geometry) => {
   if (mat4.isIdentity(geometry.transforms)) return geometry
 
   // apply transforms to each polygon
@@ -19,5 +19,3 @@ const applyTransforms = (geometry) => {
   geometry.transforms = mat4.create()
   return geometry
 }
-
-module.exports = applyTransforms

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

@@ -1,13 +1,13 @@
-const test = require('ava')
+import test from 'ava'
 
-const { fromPoints } = require('./index')
+import { fromPoints } from './index.js'
 
-const applyTransforms = require('./applyTransforms')
+import { applyTransforms } from './applyTransforms.js'
 
-const { comparePolygons, compareVectors } = require('../../../test/helpers/')
+import { comparePolygons, compareVectors } from '../../../test/helpers/index.js'
 
 test('applyTransforms: Updates a geom3 with transformed polygons', (t) => {
-  const points = [[[0, 0, 0], [1, 0, 0], [1, 0, 1]]]
+  const vertices = [[[0, 0, 0], [1, 0, 0], [1, 0, 1]]]
   const expected = {
     polygons: [
       { vertices: [[0, 0, 0], [1, 0, 0], [1, 0, 1]] }
@@ -15,7 +15,7 @@ test('applyTransforms: Updates a geom3 with transformed polygons', (t) => {
     isRetesselated: false,
     transforms: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
   }
-  const geometry = fromPoints(points)
+  const geometry = fromPoints(vertices)
   const updated = applyTransforms(geometry)
   t.is(geometry, updated)
   t.true(comparePolygons(updated.polygons[0], expected.polygons[0]))

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

@@ -1,5 +1,3 @@
-import Geom3 from './type'
+import type { Geom3 } from './type.d.ts'
 
-export default clone
-
-declare function clone(geometry: Geom3): Geom3
+export function clone(geometry: Geom3): Geom3

package/src/geometries/geom3/clone.js

@@ -1,9 +1,7 @@
 /**
  * Performs a shallow clone of the given geometry.
- * @param {geom3} geometry - the geometry to clone
- * @returns {geom3} a new geometry
+ * @param {Geom3} geometry - the geometry to clone
+ * @returns {Geom3} a new geometry
  * @alias module:modeling/geometries/geom3.clone
  */
-const clone = (geometry) => Object.assign({}, geometry)
-
-module.exports = clone
+export const clone = (geometry) => Object.assign({}, geometry)

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

@@ -1,8 +1,8 @@
-const test = require('ava')
+import test from 'ava'
 
-const { clone, create, fromPoints } = require('./index')
+import { clone, create, fromPoints } from './index.js'
 
-const { comparePolygons, compareVectors } = require('../../../test/helpers/')
+import { comparePolygons, compareVectors } from '../../../test/helpers/index.js'
 
 test('clone: Creates a clone on an empty geom3', (t) => {
   const expected = {
@@ -16,14 +16,14 @@ test('clone: Creates a clone on an empty geom3', (t) => {
 })
 
 test('clone: Creates a clone of a populated geom3', (t) => {
-  const points = [[[0, 0, 0], [1, 0, 0], [1, 0, 1]]]
+  const vertices = [[[0, 0, 0], [1, 0, 0], [1, 0, 1]]]
   const expected = {
     polygons: [
       { vertices: [[0, 0, 0], [1, 0, 0], [1, 0, 1]] }
     ],
     transforms: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
   }
-  const geometry = fromPoints(points)
+  const geometry = fromPoints(vertices)
   const another = clone(geometry)
   t.not(another, geometry)
   t.true(comparePolygons(another.polygons[0], expected.polygons[0]))

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

@@ -1,6 +1,4 @@
-import Geom3 from './type'
-import Poly3 from '../poly3/type'
+import type { Geom3 } from './type.d.ts'
+import type { Poly3 } from '../poly3/type.d.ts'
 
-export default create
-
-declare function create(polygons?: Array<Poly3>): Geom3
+export function create(polygons?: Array<Poly3>): Geom3

package/src/geometries/geom3/create.js

@@ -1,19 +1,30 @@
-const mat4 = require('../../maths/mat4')
+import * as mat4 from '../../maths/mat4/index.js'
 
 /**
  * Represents a 3D geometry consisting of a list of polygons.
- * @typedef {Object} geom3
- * @property {Array} polygons - list of polygons, each polygon containing three or more points
- * @property {mat4} transforms - transforms to apply to the polygons, see transform()
+ * @property {Array} polygons - list of polygons, each polygon containing three or more vertices
+ * @property {Mat4} transforms - transforms to apply to the polygons, see transform()
+ * @example
+ * {
+ *   "polygons": [
+ *     {"vertices": [[-1,-1,-1], [-1,-1,1], [-1,1,1], [-1,1,-1]]},
+ *     {"vertices": [[1,-1,-1], [1,1,-1], [1,1,1], [1,-1,1]]},
+ *     {"vertices": [[-1,-1,-1], [1,-1,-1], [1,-1,1], [-1,-1,1]]},
+ *     {"vertices": [[-1,1,-1], [-1,1,1], [1,1,1], [1,1,-1]]},
+ *     {"vertices": [[-1,-1,-1], [-1,1,-1], [1,1,-1], [1,-1,-1]]},
+ *     {"vertices": [[-1,-1,1], [1,-1,1], [1,1,1], [-1,1,1]]}
+ *   ],
+ *   "transforms": [1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],
+ * }
  */
 
 /**
  * Create a new 3D geometry composed of the given polygons.
  * @param {Array} [polygons] - list of polygons, or undefined
- * @returns {geom3} a new geometry
+ * @returns {Geom3} a new geometry
  * @alias module:modeling/geometries/geom3.create
  */
-const create = (polygons) => {
+export const create = (polygons) => {
   if (polygons === undefined) {
     polygons = [] // empty contents
   }
@@ -22,5 +33,3 @@ const create = (polygons) => {
     transforms: mat4.create()
   }
 }
-
-module.exports = create

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

@@ -1,8 +1,8 @@
-const test = require('ava')
+import test from 'ava'
 
-const poly3 = require('../poly3')
+import { poly3 } from '../index.js'
 
-const { create } = require('./index')
+import { create } from './index.js'
 
 test('create: Creates an empty geom3', (t) => {
   const expected = {
@@ -13,8 +13,8 @@ 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.create(points)
+  const vertices = [[0, 0, 0], [0, 10, 0], [0, 10, 10]]
+  const polygon = poly3.create(vertices)
 
   const polygons = [polygon]
   const expected = {

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

@@ -1,5 +1,3 @@
-import Geom3 from './type'
+import type { Geom3 } from './type.d.ts'
 
-export default fromCompactBinary
-
-declare function fromCompactBinary(data: Array<number> | Float32Array | Float64Array): Geom3
+export function fromCompactBinary(data: Array<number> | Float32Array | Float64Array): Geom3

package/src/geometries/geom3/fromCompactBinary.js

@@ -1,17 +1,17 @@
-const vec3 = require('../../maths/vec3')
-const mat4 = require('../../maths/mat4')
+import * as vec3 from '../../maths/vec3/index.js'
+import * as mat4 from '../../maths/mat4/index.js'
 
-const poly3 = require('../poly3')
+import * as poly3 from '../poly3/index.js'
 
-const create = require('./create')
+import { create } from './create.js'
 
 /**
  * Construct a new 3D geometry from the given compact binary data.
  * @param {TypedArray} data - compact binary data
- * @returns {geom3} a new geometry
+ * @returns {Geom3} a new geometry
  * @alias module:modeling/geometries/geom3.fromCompactBinary
  */
-const fromCompactBinary = (data) => {
+export const fromCompactBinary = (data) => {
   if (data[0] !== 1) throw new Error('invalid compact binary data')
 
   const created = create()
@@ -40,5 +40,3 @@ const fromCompactBinary = (data) => {
   // TODO: how about custom properties or fields ?
   return created
 }
-
-module.exports = fromCompactBinary

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

@@ -1,6 +1,4 @@
-import Geom3 from './type'
-import Vec3 from '../../maths/vec3/type'
+import type { Geom3 } from './type.d.ts'
+import type { Vec3 } from '../../maths/vec3/type.d.ts'
 
-export default fromPoints
-
-declare function fromPoints(points: Array<Array<Vec3>>): Geom3
+export function fromPoints(points: Array<Array<Vec3>>): Geom3

package/src/geometries/geom3/fromPoints.js

@@ -1,28 +1,20 @@
-const poly3 = require('../poly3')
+import * as poly3 from '../poly3/index.js'
 
-const create = require('./create')
+import { create } from './create.js'
 
 /**
- * Construct a new 3D geometry from a list of points.
- * The list of points should contain sub-arrays, each defining a single polygon of points.
- * In addition, the points should follow the right-hand rule for rotation in order to
+ * Construct a new 3D geometry from a list of vertices.
+ * The list of vertices should contain sub-arrays, each defining a single polygon of vertices.
+ * In addition, the vertices should follow the right-hand rule for rotation in order to
  * define an external facing polygon.
- * @param {Array} listofpoints - list of lists, where each list is a set of points to construct a polygon
- * @returns {geom3} a new geometry
+ * @param {Array} listOfLists - list of lists, where each list is a set of vertices to construct a polygon
+ * @returns {Geom3} a new geometry
  * @alias module:modeling/geometries/geom3.fromPoints
  */
-const fromPoints = (listofpoints) => {
-  if (!Array.isArray(listofpoints)) {
-    throw new Error('the given points must be an array')
+export const fromPoints = (listOfLists) => {
+  if (!Array.isArray(listOfLists)) {
+    throw new Error('the given vertices must be an array')
   }
 
-  const polygons = listofpoints.map((points, index) => {
-    // TODO catch the error, and rethrow with index
-    const polygon = poly3.create(points)
-    return polygon
-  })
-  const result = create(polygons)
-  return result
+  return create(listOfLists.map(poly3.create))
 }
-
-module.exports = fromPoints

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

@@ -1,11 +1,11 @@
-const test = require('ava')
+import test from 'ava'
 
-const { fromPoints } = require('./index')
+import { fromPoints } from './index.js'
 
-const { comparePolygons, compareVectors } = require('../../../test/helpers/')
+import { comparePolygons, compareVectors } from '../../../test/helpers/index.js'
 
 test('fromPoints: Creates a populated geom3', (t) => {
-  const points = [[[0, 0, 0], [1, 0, 0], [1, 0, 1]]]
+  const vertices = [[[0, 0, 0], [1, 0, 0], [1, 0, 1]]]
   const expected = {
     polygons: [
       { vertices: [[0, 0, 0], [1, 0, 0], [1, 0, 1]] }
@@ -13,12 +13,12 @@ test('fromPoints: Creates a populated geom3', (t) => {
     isRetesselated: false,
     transforms: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
   }
-  const obs = fromPoints(points)
+  const obs = fromPoints(vertices)
   t.true(comparePolygons(obs.polygons[0], expected.polygons[0]))
   t.true(compareVectors(obs.transforms, expected.transforms))
 })
 
-test('fromPoints: throws for improper points', (t) => {
+test('fromPoints: throws for improper vertices', (t) => {
   t.throws(() => fromPoints(), { instanceOf: Error })
   t.throws(() => fromPoints(0, 0, 0), { instanceOf: Error })
 })

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

@@ -1,6 +1,6 @@
-const test = require('ava')
+import test from 'ava'
 
-const { fromCompactBinary, toCompactBinary, create, fromPoints } = require('./index')
+import { fromCompactBinary, toCompactBinary, create, fromPoints } from './index.js'
 
 test('toCompactBinary: converts geom3 (default)', (t) => {
   const geometry = create()
@@ -20,9 +20,9 @@ test('toCompactBinary: converts geom3 (default)', (t) => {
 })
 
 test('toCompactBinary: converts geom3 into a compact form', (t) => {
-  // two polygons; 3 points, 4 points
-  const points = [[[0, 0, 0], [1, 0, 0], [2, 0, 2]], [[0, 0, 0], [1, 0, 0], [2, 0, 2], [-3, 0, 3]]]
-  const geometry = fromPoints(points)
+  // two polygons; 3 vertices, 4 vertices
+  const vertices = [[[0, 0, 0], [1, 0, 0], [2, 0, 2]], [[0, 0, 0], [1, 0, 0], [2, 0, 2], [-3, 0, 3]]]
+  const geometry = fromPoints(vertices)
   const compacted = toCompactBinary(geometry)
   const expected = new Float32Array(
     [
@@ -107,8 +107,8 @@ test('fromCompactBinary: convert a compact form into a geom3', (t) => {
     2, 0, 2,
     -3, 0, 3
   ]
-  const points = [[[0, 0, 0], [1, 0, 0], [2, 0, 2]], [[0, 0, 0], [1, 0, 0], [2, 0, 2], [-3, 0, 3]]]
-  expected = fromPoints(points)
+  const vertices = [[[0, 0, 0], [1, 0, 0], [2, 0, 2]], [[0, 0, 0], [1, 0, 0], [2, 0, 2], [-3, 0, 3]]]
+  expected = fromPoints(vertices)
   geometry = fromCompactBinary(compacted1)
 
   t.deepEqual(geometry, expected)

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

@@ -1,15 +1,14 @@
-export { default as clone } from './clone'
-export { default as create } from './create'
-export { default as fromPoints } from './fromPoints'
-export { default as fromCompactBinary } from './fromCompactBinary'
-export { default as invert } from './invert'
-export { default as isA } from './isA'
-export { default as toPoints } from './toPoints'
-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 { clone } from './clone.js'
+export { create } from './create.js'
+export { fromPoints } from './fromPoints.js'
+export { fromCompactBinary } from './fromCompactBinary.js'
+export { invert } from './invert.js'
+export { isA } from './isA.js'
+export { toPoints } from './toPoints.js'
+export { toPolygons } from './toPolygons.js'
+export { toString } from './toString.js'
+export { toCompactBinary } from './toCompactBinary.js'
+export { transform } from './transform.js'
+export { validate } from './validate.js'
 
-export { default as Geom3 } from './type'
-export as namespace geom3
+export type { Geom3 } from './type.d.ts'

package/src/geometries/geom3/index.js

@@ -4,33 +4,25 @@
  * @module modeling/geometries/geom3
  *
  * @example
- * colorize([0,0.5,1,0.6], cube()) // transparent ice cube
- *
- * @example
- * {
- *   "polygons": [
- *     {"vertices": [[-1,-1,-1], [-1,-1,1], [-1,1,1], [-1,1,-1]]},
- *     {"vertices": [[1,-1,-1], [1,1,-1], [1,1,1], [1,-1,1]]},
- *     {"vertices": [[-1,-1,-1], [1,-1,-1], [1,-1,1], [-1,-1,1]]},
- *     {"vertices": [[-1,1,-1], [-1,1,1], [1,1,1], [1,1,-1]]},
- *     {"vertices": [[-1,-1,-1], [-1,1,-1], [1,1,-1], [1,-1,-1]]},
- *     {"vertices": [[-1,-1,1], [1,-1,1], [1,1,1], [-1,1,1]]}
- *   ],
- *   "transforms": [1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],
- *   "color": [0,0.5,1,0.6]
- * }
+ * import { geometries } from '@jscad/modeling'
+ * const myShape = geometries.geom3.fromPoints([
+ *   [[-1,-1,-1], [-1,-1,1], [-1,1,1], [-1,1,-1]],
+ *   [[1,-1,-1], [1,1,-1], [1,1,1], [1,-1,1]],
+ *   [[-1,-1,-1], [1,-1,-1], [1,-1,1], [-1,-1,1]]
+ *   [[-1,1,-1], [-1,1,1], [1,1,1], [1,1,-1]],
+ *   [[-1,-1,-1], [-1,1,-1], [1,1,-1], [1,-1,-1]],
+ *   [[-1,-1,1], [1,-1,1], [1,1,1], [-1,1,1]]
+ * ])
  */
-module.exports = {
-  clone: require('./clone'),
-  create: require('./create'),
-  fromPoints: require('./fromPoints'),
-  fromCompactBinary: require('./fromCompactBinary'),
-  invert: require('./invert'),
-  isA: require('./isA'),
-  toPoints: require('./toPoints'),
-  toPolygons: require('./toPolygons'),
-  toString: require('./toString'),
-  toCompactBinary: require('./toCompactBinary'),
-  transform: require('./transform'),
-  validate: require('./validate')
-}
+export { clone } from './clone.js'
+export { create } from './create.js'
+export { fromPoints } from './fromPoints.js'
+export { fromCompactBinary } from './fromCompactBinary.js'
+export { invert } from './invert.js'
+export { isA } from './isA.js'
+export { toPoints } from './toPoints.js'
+export { toPolygons } from './toPolygons.js'
+export { toString } from './toString.js'
+export { toCompactBinary } from './toCompactBinary.js'
+export { transform } from './transform.js'
+export { validate } from './validate.js'

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

@@ -1,5 +1,3 @@
-import Geom3 from './type'
+import type { Geom3 } from './type.d.ts'
 
-export default invert
-
-declare function invert(geometry: Geom3): Geom3
+export function invert(geometry: Geom3): Geom3

package/src/geometries/geom3/invert.js

@@ -1,18 +1,16 @@
-const poly3 = require('../poly3')
+import * as poly3 from '../poly3/index.js'
 
-const create = require('./create')
-const toPolygons = require('./toPolygons')
+import { create } from './create.js'
+import { toPolygons } from './toPolygons.js'
 
 /**
  * Invert the given geometry, transposing solid and empty space.
- * @param {geom3} geometry - the geometry to invert
- * @return {geom3} a new geometry
+ * @param {Geom3} geometry - the geometry to invert
+ * @returns {Geom3} a new geometry
  * @alias module:modeling/geometries/geom3.invert
  */
-const invert = (geometry) => {
+export const invert = (geometry) => {
   const polygons = toPolygons(geometry)
-  const newpolygons = polygons.map((polygon) => poly3.invert(polygon))
-  return create(newpolygons)
+  const newPolygons = polygons.map((polygon) => poly3.invert(polygon))
+  return create(newPolygons)
 }
-
-module.exports = invert

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

@@ -1,8 +1,8 @@
-const test = require('ava')
+import test from 'ava'
 
-const { invert, create, fromPoints } = require('./index')
+import { invert, create, fromPoints } from './index.js'
 
-const { comparePolygons, compareVectors } = require('../../../test/helpers/')
+import { comparePolygons, compareVectors } from '../../../test/helpers/index.js'
 
 test('invert: Creates a invert on an empty geom3', (t) => {
   const expected = {
@@ -16,14 +16,14 @@ test('invert: Creates a invert on an empty geom3', (t) => {
 })
 
 test('invert: Creates a invert of a populated geom3', (t) => {
-  const points = [[[0, 0, 0], [1, 0, 0], [1, 0, 1]]]
+  const vertices = [[[0, 0, 0], [1, 0, 0], [1, 0, 1]]]
   const expected = {
     polygons: [
       { vertices: [[1, 0, 1], [1, 0, 0], [0, 0, 0]] }
     ],
     transforms: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
   }
-  const geometry = fromPoints(points)
+  const geometry = fromPoints(vertices)
   const another = invert(geometry)
   t.not(another, geometry)
   t.true(comparePolygons(another.polygons[0], expected.polygons[0]))

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

@@ -1,5 +1,3 @@
-import Geom3 from './type'
+import type { Geom3 } from './type.d.ts'
 
-export default isA
-
-declare function isA(object: any): object is Geom3
+export function isA(object: any): object is Geom3

package/src/geometries/geom3/isA.js

@@ -1,10 +1,10 @@
 /**
  * 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
  */
-const isA = (object) => {
+export const isA = (object) => {
   if (object && typeof object === 'object') {
     if ('polygons' in object && 'transforms' in object) {
       if (Array.isArray(object.polygons) && 'length' in object.transforms) {
@@ -14,5 +14,3 @@ const isA = (object) => {
   }
   return false
 }
-
-module.exports = isA

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

@@ -1,6 +1,6 @@
-const test = require('ava')
+import test from 'ava'
 
-const { isA, create, fromPoints } = require('./index')
+import { isA, create, fromPoints } from './index.js'
 
 test('isA: identifies created geom3', (t) => {
   const p1 = create()