@jbroll/jscad-modeling 2.12.7

package/src/operations/extrusions/slice/repair.js

@@ -0,0 +1,62 @@
+const vec3 = require('../../../maths/vec3')
+const create = require('./create')
+
+/*
+ * Mend gaps in a 2D slice to make it a closed polygon
+ */
+const repair = (slice) => {
+  if (!slice.edges) return slice
+  let edges = slice.edges
+  const vertexMap = new Map() // string key to vertex map
+  const edgeCount = new Map() // count of (in - out) edges
+
+  // Remove self-edges
+  edges = edges.filter((e) => !vec3.equals(e[0], e[1]))
+
+  // build vertex and edge count maps
+  edges.forEach((edge) => {
+    const inKey = edge[0].toString()
+    const outKey = edge[1].toString()
+    vertexMap.set(inKey, edge[0])
+    vertexMap.set(outKey, edge[1])
+    edgeCount.set(inKey, (edgeCount.get(inKey) || 0) + 1) // in
+    edgeCount.set(outKey, (edgeCount.get(outKey) || 0) - 1) // out
+  })
+
+  // find vertices which are missing in or out edges
+  const missingIn = []
+  const missingOut = []
+  edgeCount.forEach((count, vertex) => {
+    if (count < 0) missingIn.push(vertex)
+    if (count > 0) missingOut.push(vertex)
+  })
+
+  // pairwise distance of bad vertices
+  missingIn.forEach((key1) => {
+    const v1 = vertexMap.get(key1)
+
+    // find the closest vertex that is missing an out edge
+    let bestDistance = Infinity
+    let bestReplacement
+    missingOut.forEach((key2) => {
+      const v2 = vertexMap.get(key2)
+      const distance = vec3.distance(v1, v2)
+      if (distance < bestDistance) {
+        bestDistance = distance
+        bestReplacement = v2
+      }
+    })
+    console.warn(`slice.repair: repairing vertex gap ${v1} to ${bestReplacement} distance ${bestDistance}`)
+
+    // merge broken vertices
+    edges = edges.map((edge) => {
+      if (edge[0].toString() === key1) return [bestReplacement, edge[1]]
+      if (edge[1].toString() === key1) return [edge[0], bestReplacement]
+      return edge
+    })
+  })
+
+  return create(edges)
+}
+
+module.exports = repair

package/src/operations/extrusions/slice/reverse.d.ts

@@ -0,0 +1,6 @@
+import Slice from './type'
+
+export default reverse
+
+declare function reverse(slice: Slice): Slice
+declare function reverse(out: Slice, slice: Slice): Slice

package/src/operations/extrusions/slice/reverse.js

@@ -0,0 +1,26 @@
+const create = require('./create')
+
+/**
+ * Reverse the edges of the given slice.
+ *
+ * @param {slice} [out] - receiving slice
+ * @param {slice} slice - slice to reverse
+ * @returns {slice} reverse of the slice
+ * @alias module:modeling/extrusions/slice.reverse
+ */
+const reverse = (...params) => {
+  let out
+  let slice
+  if (params.length === 1) {
+    out = create()
+    slice = params[0]
+  } else {
+    out = params[0]
+    slice = params[1]
+  }
+  // reverse the edges
+  out.edges = slice.edges.map((edge) => [edge[1], edge[0]])
+  return out
+}
+
+module.exports = reverse

package/src/operations/extrusions/slice/toEdges.d.ts

@@ -0,0 +1,5 @@
+import Slice from './type'
+
+export default toEdges
+
+declare function toEdges(slice: Slice): Slice['edges']

package/src/operations/extrusions/slice/toEdges.js

@@ -0,0 +1,13 @@
+/**
+ * Produces an array of edges from the given slice.
+ * The returned array should not be modified as the data is shared with the slice.
+ * @param {slice} slice - the slice
+ * @returns {Array} an array of edges, each edge contains an array of two points (3D)
+ * @alias module:modeling/extrusions/slice.toEdges
+ *
+ * @example
+ * let sharededges = toEdges(slice)
+ */
+const toEdges = (slice) => slice.edges
+
+module.exports = toEdges

package/src/operations/extrusions/slice/toPolygons.d.ts

@@ -0,0 +1,7 @@
+import Poly3 from '../../../geometries/poly3/type'
+
+import Slice from './type'
+
+export default toPolygons
+
+declare function toPolygons(slice: Slice): Array<Poly3>

package/src/operations/extrusions/slice/toPolygons.js

@@ -0,0 +1,40 @@
+const poly3 = require('../../../geometries/poly3')
+const earcut = require('../earcut')
+const PolygonHierarchy = require('../earcut/polygonHierarchy')
+
+/**
+ * Return a list of polygons which are enclosed by the slice.
+ * @param {slice} slice - the slice
+ * @return {Array} a list of polygons (3D)
+ * @alias module:modeling/extrusions/slice.toPolygons
+ */
+const toPolygons = (slice) => {
+  const hierarchy = new PolygonHierarchy(slice)
+
+  const polygons = []
+  hierarchy.roots.forEach(({ solid, holes }) => {
+    // hole indices
+    let index = solid.length
+    const holesIndex = []
+    holes.forEach((hole, i) => {
+      holesIndex.push(index)
+      index += hole.length
+    })
+
+    // compute earcut triangulation for each solid
+    const vertices = [solid, ...holes].flat()
+    const data = vertices.flat()
+    // Get original 3D vertex by index
+    const getVertex = (i) => hierarchy.to3D(vertices[i])
+    const indices = earcut(data, holesIndex)
+    for (let i = 0; i < indices.length; i += 3) {
+      // Map back to original vertices
+      const tri = indices.slice(i, i + 3).map(getVertex)
+      polygons.push(poly3.fromPointsAndPlane(tri, hierarchy.plane))
+    }
+  })
+
+  return polygons
+}
+
+module.exports = toPolygons

package/src/operations/extrusions/slice/toString.d.ts

@@ -0,0 +1,5 @@
+import Slice from './type'
+
+export default toString
+
+declare function toString(slice: Slice): string

package/src/operations/extrusions/slice/toString.js

@@ -0,0 +1,15 @@
+const vec3 = require('../../../maths/vec3')
+
+const edgesToString = (edges) =>
+  edges.reduce((result, edge) => (
+    result += `[${vec3.toString(edge[0])}, ${vec3.toString(edge[1])}], `
+  ), '')
+
+/**
+ * @param {slice} slice - the slice
+ * @return {String} the string representation
+ * @alias module:modeling/extrusions/slice.toString
+ */
+const toString = (slice) => `[${edgesToString(slice.edges)}]`
+
+module.exports = toString

package/src/operations/extrusions/slice/transform.d.ts

@@ -0,0 +1,7 @@
+import Mat4 from '../../../maths/mat4/type'
+
+import Slice from './type'
+
+export default transform
+
+declare function transform(matrix: Mat4, slice: Slice): Slice

package/src/operations/extrusions/slice/transform.js

@@ -0,0 +1,21 @@
+const vec3 = require('../../../maths/vec3')
+
+const create = require('./create')
+
+/**
+ * Transform the given slice using the given matrix.
+ * @param {mat4} matrix - transform matrix
+ * @param {slice} slice - slice to transform
+ * @returns {slice} the transformed slice
+ * @alias module:modeling/extrusions/slice.transform
+ *
+ * @example
+ * let matrix = mat4.fromTranslation([1, 2, 3])
+ * let newslice = transform(matrix, oldslice)
+ */
+const transform = (matrix, slice) => {
+  const edges = slice.edges.map((edge) => [vec3.transform(vec3.create(), edge[0], matrix), vec3.transform(vec3.create(), edge[1], matrix)])
+  return create(edges)
+}
+
+module.exports = transform

package/src/operations/extrusions/slice/transform.test.js

@@ -0,0 +1,66 @@
+const test = require('ava')
+
+const { transform, fromPoints, toEdges } = require('./index')
+
+test('slice: transform() should return a new slice with correct values', (t) => {
+  const identityMatrix = [
+    1, 0, 0, 0,
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1
+  ]
+
+  const org1 = fromPoints([[0, 0], [1, 0], [1, 1]])
+  const ret1 = transform(identityMatrix, org1)
+  t.not(org1, ret1)
+
+  const edges1 = toEdges(ret1)
+  const exp1 = [
+    [[1, 1, 0], [0, 0, 0]],
+    [[0, 0, 0], [1, 0, 0]],
+    [[1, 0, 0], [1, 1, 0]]
+  ]
+  t.deepEqual(edges1, exp1)
+
+  const x = 1
+  const y = 5
+  const z = 7
+  const translationMatrix = [
+    1, 0, 0, 0,
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    x, y, z, 1
+  ]
+
+  const org2 = fromPoints([[0, 0], [1, 0], [1, 1]])
+  const ret2 = transform(translationMatrix, org2)
+  t.not(org2, ret2)
+
+  const edges2 = toEdges(ret2)
+  const exp2 = [
+    [[2, 6, 7], [1, 5, 7]],
+    [[1, 5, 7], [2, 5, 7]],
+    [[2, 5, 7], [2, 6, 7]]
+  ]
+  t.deepEqual(edges2, exp2)
+
+  const r = (90 * 0.017453292519943295)
+  const rotateZMatrix = [
+    Math.cos(r), -Math.sin(r), 0, 0,
+    Math.sin(r), Math.cos(r), 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1
+  ]
+
+  const org3 = fromPoints([[0, 0], [1, 0], [1, 1]])
+  const ret3 = transform(rotateZMatrix, org3)
+  t.not(org3, ret3)
+
+  const edges3 = toEdges(ret3)
+  const exp3 = [
+    [[1, -0.9999999999999999, 0], [0, 0, 0]],
+    [[0, 0, 0], [6.123233995736766e-17, -1, 0]],
+    [[6.123233995736766e-17, -1, 0], [1, -0.9999999999999999, 0]]
+  ]
+  t.deepEqual(edges3, exp3)
+})

package/src/operations/extrusions/slice/type.d.ts

@@ -0,0 +1,7 @@
+import Vec3 from '../../../maths/vec3/type'
+
+interface Slice {
+  edges: Array<[Vec3, Vec3]>
+}
+
+export default Slice

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

@@ -0,0 +1,8 @@
+import { Geom2, Geom3, Path2 } from '../../geometries/types'
+import RecursiveArray from '../../utils/recursiveArray'
+
+export default hull
+
+declare function hull(...geometries: RecursiveArray<Geom2>): Geom2
+declare function hull(...geometries: RecursiveArray<Geom3>): Geom3
+declare function hull(...geometries: RecursiveArray<Path2>): Path2

package/src/operations/hulls/hull.js

@@ -0,0 +1,52 @@
+const flatten = require('../../utils/flatten')
+const areAllShapesTheSameType = require('../../utils/areAllShapesTheSameType')
+
+const geom2 = require('../../geometries/geom2')
+const geom3 = require('../../geometries/geom3')
+const path2 = require('../../geometries/path2')
+
+const hullPath2 = require('./hullPath2')
+const hullGeom2 = require('./hullGeom2')
+const hullGeom3 = require('./hullGeom3')
+
+/**
+ * Create a convex hull of the given geometries.
+ * The given geometries should be of the same type, either geom2 or geom3 or path2.
+ * @param {...Objects} geometries - list of geometries from which to create a hull
+ * @returns {geom2|geom3} new geometry
+ * @alias module:modeling/hulls.hull
+ *
+ * @example
+ * let myshape = hull(rectangle({center: [-5,-5]}), ellipse({center: [5,5]}))
+ *
+ * @example
+ * +-------+           +-------+
+ * |       |           |        \
+ * |   A   |           |         \
+ * |       |           |          \
+ * +-------+           +           \
+ *                  =   \           \
+ *       +-------+       \           +
+ *       |       |        \          |
+ *       |   B   |         \         |
+ *       |       |          \        |
+ *       +-------+           +-------+
+ */
+const hull = (...geometries) => {
+  geometries = flatten(geometries)
+  if (geometries.length === 0) throw new Error('wrong number of arguments')
+
+  if (!areAllShapesTheSameType(geometries)) {
+    throw new Error('only hulls of the same type are supported')
+  }
+
+  const geometry = geometries[0]
+  if (path2.isA(geometry)) return hullPath2(geometries)
+  if (geom2.isA(geometry)) return hullGeom2(geometries)
+  if (geom3.isA(geometry)) return hullGeom3(geometries)
+
+  // FIXME should this throw an error for unknown geometries?
+  return geometry
+}
+
+module.exports = hull

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

@@ -0,0 +1,284 @@
+const test = require('ava')
+
+const { geom2, geom3, path2 } = require('../../geometries')
+
+const { measureVolume } = require('../../measurements')
+
+const { sphere, cuboid, ellipsoid, torus } = require('../../primitives')
+
+const { center } = require('../transforms/center')
+
+const { hull } = require('./index')
+
+const comparePolygonsAsPoints = require('../../../test/helpers/comparePolygonsAsPoints')
+
+test('hull (single, geom2)', (t) => {
+  let geometry = geom2.create()
+
+  let obs = hull(geometry)
+  let pts = geom2.toPoints(obs)
+
+  t.notThrows(() => geom2.validate(geometry))
+  t.is(pts.length, 0)
+
+  geometry = geom2.fromPoints([[5, 5], [-5, 5], [-5, -5], [5, -5]])
+  obs = hull(geometry)
+  pts = geom2.toPoints(obs)
+
+  t.notThrows(() => geom2.validate(geometry))
+  t.is(pts.length, 4)
+
+  // convex C shape
+  geometry = geom2.fromPoints([
+    [5.00000, 8.66025],
+    [-5.00000, 8.66025],
+    [-10.00000, 0.00000],
+    [-5.00000, -8.66025],
+    [5.00000, -8.66025],
+    [6.00000, -6.92820],
+    [-2.00000, -6.92820],
+    [-6.00000, 0.00000],
+    [-2.00000, 6.92820],
+    [6.00000, 6.92820]
+  ])
+  obs = hull(geometry)
+  pts = geom2.toPoints(obs)
+
+  t.notThrows(() => geom2.validate(geometry))
+  t.is(pts.length, 7)
+})
+
+test('hull (multiple, overlapping, geom2)', (t) => {
+  const geometry1 = geom2.fromPoints([[5, 5], [-5, 5], [-5, -5], [5, -5]])
+  const geometry2 = geom2.fromPoints([[3, 3], [-3, 3], [-3, -3], [3, -3]])
+  const geometry3 = geom2.fromPoints([[6, 3], [-6, 3], [-6, -3], [6, -3]])
+
+  // convex C shape
+  const geometry4 = geom2.fromPoints([
+    [5.00000, 8.66025],
+    [-5.00000, 8.66025],
+    [-10.00000, 0.00000],
+    [-5.00000, -8.66025],
+    [5.00000, -8.66025],
+    [6.00000, -6.92820],
+    [-2.00000, -6.92820],
+    [-6.00000, 0.00000],
+    [-2.00000, 6.92820],
+    [6.00000, 6.92820]
+  ])
+
+  // same
+  let obs = hull(geometry1, geometry1)
+  let pts = geom2.toPoints(obs)
+
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 4)
+
+  // one inside another
+  obs = hull(geometry1, geometry2)
+  pts = geom2.toPoints(obs)
+
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 4)
+
+  // one overlapping another
+  obs = hull(geometry1, geometry3)
+  pts = geom2.toPoints(obs)
+
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 8)
+
+  obs = hull(geometry2, geometry4)
+  pts = geom2.toPoints(obs)
+
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 7)
+})
+
+test('hull (multiple, various, geom2)', (t) => {
+  const geometry1 = geom2.fromPoints([[6, 6], [0, 6], [0, 0], [6, 0]])
+  const geometry2 = geom2.fromPoints([[6, 3], [-6, 3], [-6, -3], [6, -3]])
+  const geometry3 = geom2.fromPoints([[-10, -10], [0, -20], [10, -10]])
+
+  // convex C shape
+  const geometry4 = geom2.fromPoints([
+    [5.00000, 8.66025],
+    [-5.00000, 8.66025],
+    [-10.00000, 0.00000],
+    [-5.00000, -8.66025],
+    [5.00000, -8.66025],
+    [6.00000, -6.92820],
+    [-2.00000, -6.92820],
+    [-6.00000, 0.00000],
+    [-2.00000, 6.92820],
+    [6.00000, 6.92820]
+  ])
+  const geometry5 = geom2.fromPoints([[-17, -17], [-23, -17], [-23, -23], [-17, -23]])
+
+  let obs = hull(geometry1, geometry2)
+  let pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 5)
+
+  obs = hull(geometry1, geometry3)
+  pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 5)
+
+  obs = hull(geometry2, geometry3)
+  pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 5)
+
+  obs = hull(geometry1, geometry2, geometry3)
+  pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 6)
+
+  obs = hull(geometry5, geometry4)
+  pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 8)
+})
+
+test('hull (single, path2)', (t) => {
+  let geometry = path2.create()
+
+  let obs = hull(geometry)
+  let pts = path2.toPoints(obs)
+
+  t.notThrows(() => path2.validate(obs))
+  t.is(pts.length, 0)
+
+  geometry = path2.fromPoints({}, [[0, 0], [5, 0], [5, 10], [4, 1]])
+
+  obs = hull(geometry)
+  pts = path2.toPoints(obs)
+
+  t.notThrows(() => path2.validate(obs))
+  t.is(pts.length, 3)
+})
+
+test('hull (multiple, various, path2)', (t) => {
+  const geometry1 = path2.fromPoints({ closed: true }, [[6, 6], [0, 6], [0, 0], [6, 0]])
+  const geometry2 = path2.fromPoints({}, [[6, 3], [-6, 3], [-6, -3], [6, -3]])
+  const geometry3 = path2.fromPoints({ closed: true }, [[-10, -10], [0, -20], [10, -10]])
+
+  // convex C shape
+  const geometry4 = path2.fromPoints({}, [
+    [5.00000, 8.66025],
+    [-5.00000, 8.66025],
+    [-10.00000, 0.00000],
+    [-5.00000, -8.66025],
+    [5.00000, -8.66025],
+    [6.00000, -6.92820],
+    [-2.00000, -6.92820],
+    [-6.00000, 0.00000],
+    [-2.00000, 6.92820],
+    [6.00000, 6.92820]
+  ])
+  const geometry5 = path2.fromPoints({ closed: true }, [[-17, -17], [-23, -17], [-23, -23], [-17, -23]])
+
+  let obs = hull(geometry1, geometry2)
+  let pts = path2.toPoints(obs)
+  t.notThrows(() => path2.validate(obs))
+  t.is(pts.length, 5)
+
+  obs = hull(geometry1, geometry3)
+  pts = path2.toPoints(obs)
+  t.notThrows(() => path2.validate(obs))
+  t.is(pts.length, 5)
+
+  obs = hull(geometry2, geometry3)
+  pts = path2.toPoints(obs)
+  t.notThrows(() => path2.validate(obs))
+  t.is(pts.length, 5)
+
+  obs = hull(geometry1, geometry2, geometry3)
+  pts = path2.toPoints(obs)
+  t.notThrows(() => path2.validate(obs))
+  t.is(pts.length, 6)
+
+  obs = hull(geometry5, geometry4)
+  pts = path2.toPoints(obs)
+  t.notThrows(() => path2.validate(obs))
+  t.is(pts.length, 8)
+})
+
+test('hull (single, geom3)', (t) => {
+  let geometry = geom3.create()
+
+  let obs = hull(geometry)
+  let pts = geom3.toPoints(obs)
+
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 0)
+
+  geometry = sphere({ radius: 2, segments: 8 })
+
+  obs = hull(geometry)
+  pts = geom3.toPoints(obs)
+
+  t.notThrows.skip(() => geom3.validate(obs))
+  t.is(pts.length, 32)
+})
+
+test('hull (multiple, geom3)', (t) => {
+  const geometry1 = cuboid({ size: [2, 2, 2] })
+
+  let obs = hull(geometry1, geometry1) // same
+  let pts = geom3.toPoints(obs)
+  let exp = [
+    [[-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]]
+  ]
+
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 6)
+  t.true(comparePolygonsAsPoints(pts, exp))
+
+  const geometry2 = center({ relativeTo: [5, 5, 5] }, cuboid({ size: [3, 3, 3] }))
+
+  obs = hull(geometry1, geometry2)
+  pts = geom3.toPoints(obs)
+  exp = [
+    [[1, -1, -1], [6.5, 3.5, 3.5], [6.5, 3.5, 6.5], [1, -1, 1]],
+    [[-1, -1, 1], [-1, -1, -1], [1, -1, -1], [1, -1, 1]],
+    [[-1, -1, 1], [1, -1, 1], [6.5, 3.5, 6.5], [3.5, 3.5, 6.5]],
+    [[-1, -1, 1], [3.5, 3.5, 6.5], [3.5, 6.5, 6.5], [-1, 1, 1]],
+    [[-1, 1, -1], [-1, 1, 1], [3.5, 6.5, 6.5], [3.5, 6.5, 3.5]],
+    [[-1, 1, -1], [-1, -1, -1], [-1, -1, 1], [-1, 1, 1]],
+    [[6.5, 6.5, 6.5], [6.5, 3.5, 6.5], [6.5, 3.5, 3.5], [6.5, 6.5, 3.5]],
+    [[6.5, 6.5, 6.5], [6.5, 6.5, 3.5], [3.5, 6.5, 3.5], [3.5, 6.5, 6.5]],
+    [[6.5, 6.5, 6.5], [3.5, 6.5, 6.5], [3.5, 3.5, 6.5], [6.5, 3.5, 6.5]],
+    [[1, 1, -1], [1, -1, -1], [-1, -1, -1], [-1, 1, -1]],
+    [[1, 1, -1], [-1, 1, -1], [3.5, 6.5, 3.5], [6.5, 6.5, 3.5]],
+    [[1, 1, -1], [6.5, 6.5, 3.5], [6.5, 3.5, 3.5], [1, -1, -1]]
+  ]
+
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 12)
+  t.true(comparePolygonsAsPoints(pts, exp))
+})
+
+test('hull (multiple, overlapping, geom3)', (t) => {
+  const geometry1 = ellipsoid({ radius: [2, 2, 2], segments: 12 })
+  const geometry2 = center({ relativeTo: [3, -3, 3] }, ellipsoid({ radius: [3, 3, 3], segments: 12 }))
+  const geometry3 = center({ relativeTo: [-3, -3, -3] }, ellipsoid({ radius: [3, 3, 3], segments: 12 }))
+
+  const obs = hull(geometry1, geometry2, geometry3)
+  const pts = geom3.toPoints(obs)
+
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 92)
+})
+
+test('hull (single, unconvex, geom3)', (t) => {
+  const geometry = torus()
+  const obs = hull(geometry)
+  t.assert(measureVolume(obs) > measureVolume(geometry))
+})

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

@@ -0,0 +1,8 @@
+import { Geom2, Geom3, Path2 } from '../../geometries/types'
+import RecursiveArray from '../../utils/recursiveArray'
+
+export default hullChain
+
+declare function hullChain(...geometries: RecursiveArray<Geom2>): Geom2
+declare function hullChain(...geometries: RecursiveArray<Geom3>): Geom3
+declare function hullChain(...geometries: RecursiveArray<Path2>): Path2