@jscad/modeling 2.12.5 → 3.0.1-alpha.0

package/src/operations/hulls/hullChain.test.js

@@ -1,18 +1,30 @@
-const test = require('ava')
+import test from 'ava'
 
-const { geom2, geom3 } = require('../../geometries')
+import { geom2, geom3 } from '../../geometries/index.js'
 
-const { hullChain } = require('./index')
+import { measureArea, measureVolume } from '../../measurements/index.js'
+
+import { square } from '../../primitives/square.js'
+
+import { hullChain } from './index.js'
+
+test('hullChain: hullChain single geometry', (t) => {
+  const result = hullChain([square({ size: 1 })])
+  t.notThrows(() => geom2.validate(result))
+  t.is(measureArea(result), 1)
+  t.is(geom2.toPoints(result).length, 4)
+})
 
 test('hullChain (two, geom2)', (t) => {
-  const geometry1 = geom2.fromPoints([[6, 6], [3, 6], [3, 3], [6, 3]])
-  const geometry2 = geom2.fromPoints([[-6, -6], [-9, -6], [-9, -9], [-6, -9]])
+  const geometry1 = geom2.create([[[6, 6], [3, 6], [3, 3], [6, 3]]])
+  const geometry2 = geom2.create([[[-6, -6], [-9, -6], [-9, -9], [-6, -9]]])
 
   // same
   let obs = hullChain(geometry1, geometry1)
   let pts = geom2.toPoints(obs)
 
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 9)
   t.is(pts.length, 4)
 
   // different
@@ -20,13 +32,14 @@ test('hullChain (two, geom2)', (t) => {
   pts = geom2.toPoints(obs)
 
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 81)
   t.is(pts.length, 6)
 })
 
 test('hullChain (three, geom2)', (t) => {
-  const geometry1 = geom2.fromPoints([[6, 6], [3, 6], [3, 3], [6, 3]])
-  const geometry2 = geom2.fromPoints([[-6, -6], [-9, -6], [-9, -9], [-6, -9]])
-  const geometry3 = geom2.fromPoints([[-6, 6], [-3, 6], [-3, 9], [-6, 9]])
+  const geometry1 = geom2.create([[[6, 6], [3, 6], [3, 3], [6, 3]]])
+  const geometry2 = geom2.create([[[-6, -6], [-9, -6], [-9, -9], [-6, -9]]])
+  const geometry3 = geom2.create([[[-6, 6], [-3, 6], [-3, 9], [-6, 9]]])
 
   // open
   let obs = hullChain(geometry1, geometry2, geometry3)
@@ -34,6 +47,7 @@ test('hullChain (three, geom2)', (t) => {
 
   // the sides change based on the bestplane chosen in trees/Node.js
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 126)
   t.is(pts.length, 10)
 
   // closed
@@ -42,6 +56,7 @@ test('hullChain (three, geom2)', (t) => {
 
   // the sides change based on the bestplane chosen in trees/Node.js
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 148.21875)
   t.is(pts.length, 10)
 })
 
@@ -76,6 +91,8 @@ test('hullChain (three, geom3)', (t) => {
   let pts = geom3.toPoints(obs)
 
   t.notThrows.skip(() => geom3.validate(obs))
+  t.is(measureArea(obs), 266.1454764345133)
+  t.is(measureVolume(obs), 239.2012987012987)
   t.is(pts.length, 23)
 
   // closed
@@ -83,5 +100,7 @@ test('hullChain (three, geom3)', (t) => {
   pts = geom3.toPoints(obs)
 
   t.notThrows.skip(() => geom3.validate(obs))
+  t.is(measureArea(obs), 272.2887171436021)
+  t.is(measureVolume(obs), 261.96982218883045)
   t.is(pts.length, 28)
 })

package/src/operations/hulls/hullGeom2.js

@@ -1,21 +1,17 @@
-const flatten = require('../../utils/flatten')
+import * as geom2 from '../../geometries/geom2/index.js'
 
-const geom2 = require('../../geometries/geom2')
-
-const hullPoints2 = require('./hullPoints2')
-const toUniquePoints = require('./toUniquePoints')
+import { hullPoints2 } from './hullPoints2.js'
+import { toUniquePoints } from './toUniquePoints.js'
 
 /*
  * Create a convex hull of the given geom2 geometries.
  *
  * NOTE: The given geometries must be valid geom2 geometries.
  *
- * @param {...geometries} geometries - list of geom2 geometries
- * @returns {geom2} new geometry
+ * @param {Geom2[]} geometries - a flat list of 2D geometries
+ * @returns {Geom2} new geometry
  */
-const hullGeom2 = (...geometries) => {
-  geometries = flatten(geometries)
-
+export const hullGeom2 = (geometries) => {
   // extract the unique points from the geometries
   const unique = toUniquePoints(geometries)
 
@@ -25,7 +21,5 @@ const hullGeom2 = (...geometries) => {
   if (hullPoints.length < 3) return geom2.create()
 
   // assemble a new geometry from the list of points
-  return geom2.fromPoints(hullPoints)
+  return geom2.create([hullPoints])
 }
-
-module.exports = hullGeom2

package/src/operations/hulls/hullGeom3.js

@@ -1,21 +1,17 @@
-const flatten = require('../../utils/flatten')
+import * as geom3 from '../../geometries/geom3/index.js'
 
-const geom3 = require('../../geometries/geom3')
-
-const toUniquePoints = require('./toUniquePoints')
-const hullPoints3 = require('./hullPoints3')
+import { hullPoints3 } from './hullPoints3.js'
+import { toUniquePoints } from './toUniquePoints.js'
 
 /*
  * Create a convex hull of the given geom3 geometries.
  *
  * NOTE: The given geometries must be valid geom3 geometries.
  *
- * @param {...geometries} geometries - list of geom3 geometries
- * @returns {geom3} new geometry
+ * @param {Geom3[]} geometries - a flat list of 3D geometries
+ * @returns {Geom3} new geometry
  */
-const hullGeom3 = (...geometries) => {
-  geometries = flatten(geometries)
-
+export const hullGeom3 = (geometries) => {
   // extract the unique vertices from the geometries
   const unique = toUniquePoints(geometries)
 
@@ -23,5 +19,3 @@ const hullGeom3 = (...geometries) => {
 
   return geom3.create(hullPoints3(unique))
 }
-
-module.exports = hullGeom3

package/src/operations/hulls/hullPath2.js

@@ -1,21 +1,17 @@
-const flatten = require('../../utils/flatten')
+import * as path2 from '../../geometries/path2/index.js'
 
-const path2 = require('../../geometries/path2')
-
-const hullPoints2 = require('./hullPoints2')
-const toUniquePoints = require('./toUniquePoints')
+import { hullPoints2 } from './hullPoints2.js'
+import { toUniquePoints } from './toUniquePoints.js'
 
 /*
  * Create a convex hull of the given path2 geometries.
  *
  * NOTE: The given geometries must be valid path2 geometry.
  *
- * @param {...geometries} geometries - list of path2 geometries
- * @returns {path2} new geometry
+ * @param {Path2[]} geometries - a flat list of path2 geometries
+ * @returns {Path2} new geometry
  */
-const hullPath2 = (...geometries) => {
-  geometries = flatten(geometries)
-
+export const hullPath2 = (geometries) => {
   // extract the unique points from the geometries
   const unique = toUniquePoints(geometries)
 
@@ -24,5 +20,3 @@ const hullPath2 = (...geometries) => {
   // assemble a new geometry from the list of points
   return path2.fromPoints({ closed: true }, hullPoints)
 }
-
-module.exports = hullPath2

package/src/operations/hulls/hullPath2.test.js

@@ -1,15 +1,15 @@
-const test = require('ava')
+import test from 'ava'
 
-const { path2 } = require('../../geometries')
+import { path2 } from '../../geometries/index.js'
 
-const hullPath2 = require('./hullPath2')
+import { hullPath2 } from './hullPath2.js'
 
 test('hullPath2', (t) => {
   const closed = true
   const geometry1 = path2.fromPoints({ closed }, [[0, 0], [-4, 4], [-4, -4]])
   const geometry2 = path2.fromPoints({ closed }, [[0, 0], [4, -4], [4, 4]])
 
-  const obs = hullPath2(geometry1, geometry2)
+  const obs = hullPath2([geometry1, geometry2])
   t.notThrows(() => path2.validate(obs))
   const pts = path2.toPoints(obs)
   t.is(pts.length, 4)

package/src/operations/hulls/hullPoints2.d.ts

@@ -1,5 +1,3 @@
-import Vec2 from '../../maths/vec2/type'
+import type { Vec2 } from '../../maths/vec2/type.d.ts'
 
-export default hullPoints2
-
-declare function hullPoints2(uniquePoints: Array<Vec2>): Array<Vec2>
+export function hullPoints2(uniquePoints: Array<Vec2>): Array<Vec2>

package/src/operations/hulls/hullPoints2.js

@@ -1,14 +1,14 @@
-const vec2 = require('../../maths/vec2')
+import * as vec2 from '../../maths/vec2/index.js'
 
 /**
  * Create a convex hull of the given set of points, where each point is an array of [x,y].
- * @see https://en.wikipedia.org/wiki/Graham_scan
  *
+ * @see https://en.wikipedia.org/wiki/Graham_scan
  * @param {Array} uniquePoints - list of UNIQUE points from which to create a hull
  * @returns {Array} a list of points that form the hull
  * @alias module:modeling/hulls.hullPoints2
  */
-const hullPoints2 = (uniquePoints) => {
+export const hullPoints2 = (uniquePoints) => {
   // find min point
   let min = vec2.fromValues(Infinity, Infinity)
   uniquePoints.forEach((point) => {
@@ -58,5 +58,3 @@ const fakeAtan2 = (y, x) => {
     return -x / y
   }
 }
-
-module.exports = hullPoints2

package/src/operations/hulls/hullPoints2.test.js

@@ -1,6 +1,6 @@
-const test = require('ava')
+import test from 'ava'
 
-const hullPoints2 = require('./hullPoints2')
+import { hullPoints2 } from './hullPoints2.js'
 
 test('hullPoints2 bug #114 2 circles with 18 segments', (t) => {
   const points = [

package/src/operations/hulls/hullPoints3.d.ts

@@ -1,6 +1,4 @@
-import Vec3 from '../../maths/vec3/type'
-import Poly3 from '../../geometries/poly3/type'
+import type { Vec3 } from '../../maths/vec3/type.d.ts'
+import type { Poly3 } from '../../geometries/poly3/type.d.ts'
 
-export default hullPoints3
-
-declare function hullPoints3(uniquePoints: Array<Vec3>): Array<Poly3>
+export function hullPoints3(uniquePoints: Array<Vec3>): Array<Poly3>

package/src/operations/hulls/hullPoints3.js

@@ -1,6 +1,6 @@
-const poly3 = require('../../geometries/poly3')
+import * as poly3 from '../../geometries/poly3/index.js'
 
-const quickhull = require('./quickhull')
+import { runner } from './quickhull/index.js'
 
 /**
  * Create a convex hull of the given set of points, where each point is an array of [x,y,z].
@@ -9,8 +9,8 @@ const quickhull = require('./quickhull')
  * @returns {Array} a list of polygons (poly3)
  * @alias module:modeling/hulls.hullPoints3
  */
-const hullPoints3 = (uniquePoints) => {
-  const faces = quickhull(uniquePoints, { skipTriangulation: true })
+export const hullPoints3 = (uniquePoints) => {
+  const faces = runner(uniquePoints, { skipTriangulation: true })
 
   const polygons = faces.map((face) => {
     const vertices = face.map((index) => uniquePoints[index])
@@ -19,5 +19,3 @@ const hullPoints3 = (uniquePoints) => {
 
   return polygons
 }
-
-module.exports = hullPoints3

package/src/operations/hulls/index.d.ts

@@ -1,6 +1,4 @@
-export { default as hull } from './hull'
-export { default as hullChain } from './hullChain'
-export { default as hullPoints2 } from './hullPoints2'
-export { default as hullPoints3 } from './hullPoints3'
-
-export as namespace hulls
+export { hull } from './hull.js'
+export { hullChain } from './hullChain.js'
+export { hullPoints2 } from './hullPoints2.js'
+export { hullPoints3 } from './hullPoints3.js'

package/src/operations/hulls/index.js

@@ -4,11 +4,9 @@
  * In all cases, the function returns the results, and never changes the original shapes.
  * @module modeling/hulls
  * @example
- * const { hull, hullChain, hullPoints2, hullPoints3 } = require('@jscad/modeling').hulls
+ * import { hull, hullChain, hullPoints2, hullPoints3 } from '@jscad/modeling'
  */
-module.exports = {
-  hull: require('./hull'),
-  hullChain: require('./hullChain'),
-  hullPoints2: require('./hullPoints2'),
-  hullPoints3: require('./hullPoints3')
-}
+export { hull } from './hull.js'
+export { hullChain } from './hullChain.js'
+export { hullPoints2 } from './hullPoints2.js'
+export { hullPoints3 } from './hullPoints3.js'

package/src/operations/hulls/quickhull/Face.js

@@ -1,11 +1,4 @@
-const add = require('../../../maths/vec3/add')
-const copy = require('../../../maths/vec3/copy')
-const cross = require('../../../maths/vec3/cross')
-const dot = require('../../../maths/vec3/dot')
-const length = require('../../../maths/vec3/length')
-const normalize = require('../../../maths/vec3/normalize')
-const scale = require('../../../maths/vec3/scale')
-const subtract = require('../../../maths/vec3/subtract')
+import { add, copy, cross, dot, length, normalize, scale, subtract } from '../../../maths/vec3/index.js'
 
 /*
  * Original source from quickhull3d (https://github.com/mauriciopoppe/quickhull3d)
@@ -14,19 +7,19 @@ const subtract = require('../../../maths/vec3/subtract')
  * Adapted to JSCAD by Jeff Gay
  */
 
-const HalfEdge = require('./HalfEdge')
+import { HalfEdge } from './HalfEdge.js'
 
-const VISIBLE = 0
-const NON_CONVEX = 1
-const DELETED = 2
+export const VISIBLE = 0
+export const NON_CONVEX = 1
+export const DELETED = 2
 
-class Face {
+export class Face {
   constructor () {
     this.normal = []
     this.centroid = []
     // signed distance from face to the origin
     this.offset = 0
-    // pointer to the a vertex in a double linked list this face can see
+    // pointer to the vertex in a double linked list this face can see
     this.outside = null
     this.mark = VISIBLE
     this.edge = null
@@ -325,10 +318,3 @@ class Face {
     return face
   }
 }
-
-module.exports = {
-  VISIBLE,
-  NON_CONVEX,
-  DELETED,
-  Face
-}

package/src/operations/hulls/quickhull/HalfEdge.js

@@ -1,5 +1,4 @@
-const distance = require('../../../maths/vec3/distance')
-const squaredDistance = require('../../../maths/vec3/squaredDistance')
+import { distance, squaredDistance } from '../../../maths/vec3/index.js'
 
 /*
  * Original source from quickhull3d (https://github.com/mauriciopoppe/quickhull3d)
@@ -8,7 +7,7 @@ const squaredDistance = require('../../../maths/vec3/squaredDistance')
  * Adapted to JSCAD by Jeff Gay
  */
 
-class HalfEdge {
+export class HalfEdge {
   constructor (vertex, face) {
     this.vertex = vertex
     this.face = face
@@ -52,5 +51,3 @@ class HalfEdge {
     edge.opposite = this
   }
 }
-
-module.exports = HalfEdge

package/src/operations/hulls/quickhull/QuickHull.js

@@ -1,11 +1,11 @@
-const dot = require('../../../maths/vec3/dot')
+import { dot } from '../../../maths/vec3/index.js'
+import * as plane from '../../../maths/plane/index.js'
 
-const pointLineDistance = require('./point-line-distance')
-const getPlaneNormal = require('./get-plane-normal')
+import { pointLineDistance } from './point-line-distance.js'
 
-const VertexList = require('./VertexList')
-const Vertex = require('./Vertex')
-const { Face, VISIBLE, NON_CONVEX, DELETED } = require('./Face')
+import { VertexList } from './VertexList.js'
+import { Vertex } from './Vertex.js'
+import { Face, VISIBLE, NON_CONVEX, DELETED } from './Face.js'
 
 /*
  * Original source from quickhull3d (https://github.com/mauriciopoppe/quickhull3d)
@@ -15,11 +15,11 @@ const { Face, VISIBLE, NON_CONVEX, DELETED } = require('./Face')
  */
 
 // merge types
-// non convex with respect to the large face
+// non-convex with respect to the large face
 const MERGE_NON_CONVEX_WRT_LARGER_FACE = 1
 const MERGE_NON_CONVEX = 2
 
-class QuickHull {
+export class QuickHull {
   constructor (points) {
     if (!Array.isArray(points)) {
       throw TypeError('input is not a valid array')
@@ -292,9 +292,9 @@ class QuickHull {
       }
     }
 
-    // the next vertes is the one farthest to the plane `v0`, `v1`, `v2`
+    // the next vertex is the one farthest to the plane `v0`, `v1`, `v2`
     // normalize((v2 - v1) x (v0 - v1))
-    const normal = getPlaneNormal([], v0.point, v1.point, v2.point)
+    const normal = plane.fromPoints([], v0.point, v1.point, v2.point)
     // distance from the origin to the plane
     const distPO = dot(v0.point, normal)
     maxDistance = -1
@@ -435,11 +435,11 @@ class QuickHull {
    * Finds the next vertex to make faces with the current hull
    *
    * - let `face` be the first face existing in the `claimed` vertex list
-   *  - if `face` doesn't exist then return since there're no vertices left
+   *  - if `face` doesn't exist then return since there are no vertices left
    *  - otherwise for each `vertex` that face sees find the one furthest away
    *  from `face`
    *
-   * @return {Vertex|undefined} Returns undefined when there're no more
+   * @return {Vertex|undefined} Returns undefined when there are no more
    * visible vertices
    */
   nextVertexToAdd () {
@@ -603,7 +603,7 @@ class QuickHull {
    *
    *    dot(centroid larger face, smaller face normal) - smaller face offset > -tolerance
    *
-   * If true then it means that two faces are non convex (concave), even if the
+   * If true then it means that two faces are non-convex (concave), even if the
    * dot(...) - offset value is > 0 (that's the point of doing the merge in the
    * first place)
    *
@@ -727,7 +727,7 @@ class QuickHull {
     }
 
     // second merge pass
-    // Do the merge on non convex faces (a face is marked as non convex in the
+    // Do the merge on non-convex faces (a face is marked as non-convex in the
     // first pass)
     for (let i = 0; i < this.newFaces.length; i += 1) {
       const face = this.newFaces[i]
@@ -750,5 +750,3 @@ class QuickHull {
     this.reindexFaceAndVertices()
   }
 }
-
-module.exports = QuickHull

package/src/operations/hulls/quickhull/Vertex.js

@@ -5,7 +5,7 @@
  * Adapted to JSCAD by Jeff Gay
  */
 
-class Vertex {
+export class Vertex {
   constructor (point, index) {
     this.point = point
     // index in the input array
@@ -17,5 +17,3 @@ class Vertex {
     this.face = null
   }
 }
-
-module.exports = Vertex

package/src/operations/hulls/quickhull/VertexList.js

@@ -4,8 +4,7 @@
  *
  * Adapted to JSCAD by Jeff Gay
  */
-
-class VertexList {
+export class VertexList {
   constructor () {
     this.head = null
     this.tail = null
@@ -142,5 +141,3 @@ class VertexList {
     return !this.head
   }
 }
-
-module.exports = VertexList

package/src/operations/hulls/quickhull/index.js

@@ -1,4 +1,4 @@
-const QuickHull = require('./QuickHull')
+import { QuickHull } from './QuickHull.js'
 
 /*
  * Original source from quickhull3d (https://github.com/mauriciopoppe/quickhull3d)
@@ -7,10 +7,8 @@ const QuickHull = require('./QuickHull')
  * Adapted to JSCAD by Jeff Gay
  */
 
-const runner = (points, options = {}) => {
+export const runner = (points, options = {}) => {
   const instance = new QuickHull(points)
   instance.build()
   return instance.collectFaces(options.skipTriangulation)
 }
-
-module.exports = runner

package/src/operations/hulls/quickhull/point-line-distance.js

@@ -1,6 +1,4 @@
-const cross = require('../../../maths/vec3/cross')
-const subtract = require('../../../maths/vec3/subtract')
-const squaredLength = require('../../../maths/vec3/squaredLength')
+import { cross, subtract, squaredLength } from '../../../maths/vec3/index.js'
 
 /*
  * Original source from quickhull3d (https://github.com/mauriciopoppe/quickhull3d)
@@ -37,6 +35,4 @@ const distanceSquared = (p, a, b) => {
   return area / s
 }
 
-const pointLineDistance = (point, a, b) => Math.sqrt(distanceSquared(point, a, b))
-
-module.exports = pointLineDistance
+export const pointLineDistance = (point, a, b) => Math.sqrt(distanceSquared(point, a, b))

package/src/operations/hulls/toUniquePoints.js

@@ -1,11 +1,11 @@
-const geom2 = require('../../geometries/geom2')
-const geom3 = require('../../geometries/geom3')
-const path2 = require('../../geometries/path2')
+import * as geom2 from '../../geometries/geom2/index.js'
+import * as geom3 from '../../geometries/geom3/index.js'
+import * as path2 from '../../geometries/path2/index.js'
 
 /*
  * Return the unique vertices of a geometry
  */
-const toUniquePoints = (geometries) => {
+export const toUniquePoints = (geometries) => {
   const found = new Set()
   const uniquePoints = []
 
@@ -30,5 +30,3 @@ const toUniquePoints = (geometries) => {
 
   return uniquePoints
 }
-
-module.exports = toUniquePoints

package/src/operations/modifiers/generalize.d.ts

@@ -1,5 +1,5 @@
-import { Geometry } from '../../geometries/types'
-import RecursiveArray from '../../utils/recursiveArray'
+import type { Geometry } from '../../geometries/types.d.ts'
+import type { RecursiveArray } from '../../utils/recursiveArray.d.ts'
 
 export interface GeneralizeOptions {
   snap?: boolean

package/src/operations/modifiers/generalize.js

@@ -1,15 +1,13 @@
-const flatten = require('../../utils/flatten')
+import { measureEpsilon } from '../../measurements/measureEpsilon.js'
 
-const measureEpsilon = require('../../measurements/measureEpsilon')
+import * as geom2 from '../../geometries/geom2/index.js'
+import * as geom3 from '../../geometries/geom3/index.js'
+import * as path2 from '../../geometries/path2/index.js'
 
-const geom2 = require('../../geometries/geom2')
-const geom3 = require('../../geometries/geom3')
-const path2 = require('../../geometries/path2')
-
-const snapPolygons = require('./snapPolygons')
-const mergePolygons = require('./mergePolygons')
-const insertTjunctions = require('./insertTjunctions')
-const triangulatePolygons = require('./triangulatePolygons')
+import { snapPolygons } from './snapPolygons.js'
+import { mergePolygons } from './mergePolygons.js'
+import { insertTjunctions } from './insertTjunctions.js'
+import { triangulatePolygons } from './triangulatePolygons.js'
 
 /*
  */
@@ -58,25 +56,21 @@ const generalizeGeom3 = (options, geometry) => {
 
 /**
  * Apply various modifications in proper order to produce a generalized geometry.
- * @param {Object} options - options for modifications
- * @param {Boolean} [options.snap=false] the geometries should be snapped to epsilons
- * @param {Boolean} [options.simplify=false] the geometries should be simplified
- * @param {Boolean} [options.triangulate=false] the geometries should be triangulated
+ * @param {object} options - options for modifications
+ * @param {boolean} [options.snap=false] the geometries should be snapped to epsilons
+ * @param {boolean} [options.simplify=false] the geometries should be simplified
+ * @param {boolean} [options.triangulate=false] the geometries should be triangulated
  * @param {...Object} geometries - the geometries to generalize
  * @return {Object|Array} the modified geometry, or a list of modified geometries
  * @alias module:modeling/modifiers.generalize
  */
-const generalize = (options, ...geometries) => {
-  geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('wrong number of arguments')
-
+export const generalize = (options, ...geometries) => {
   const results = geometries.map((geometry) => {
     if (path2.isA(geometry)) return generalizePath2(options, geometry)
     if (geom2.isA(geometry)) return generalizeGeom2(options, geometry)
     if (geom3.isA(geometry)) return generalizeGeom3(options, geometry)
-    throw new Error('invalid geometry')
+    if (Array.isArray(geometry)) return generalize(options, ...geometry)
+    return geometry
   })
   return results.length === 1 ? results[0] : results
 }
-
-module.exports = generalize