@jbroll/jscad-modeling 2.12.8 → 2.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbroll/jscad-modeling",
-  "version": "2.12.8",
+  "version": "2.13.0",
   "description": "Constructive Solid Geometry (CSG) Library for JSCAD (performance-optimized fork)",
   "homepage": "https://github.com/jbroll/OpenJSCAD.org",
   "repository": "https://github.com/jbroll/OpenJSCAD.org",
@@ -9,6 +9,7 @@
   "unpkg": "dist/jscad-modeling.min.js",
   "scripts": {
     "bench": "node benchmarks/run.js",
+    "bench:compare": "node --expose-gc benchmarks/compare.js",
     "build": "browserify src/index.js -o dist/jscad-modeling.min.js -g uglifyify --standalone jscadModeling",
     "coverage": "nyc --all --reporter=html --reporter=text npm test",
     "test": "ava 'src/**/*.test.js' --verbose --timeout 2m",

package/src/geometries/poly3/create.js

@@ -18,7 +18,11 @@ const create = (vertices) => {
   if (vertices === undefined || vertices.length < 3) {
     vertices = [] // empty contents
   }
-  return { vertices }
+  // Initialize all properties upfront for consistent object shape.
+  // V8 optimizes property access when objects have the same hidden class.
+  // Without this, polygons get different shapes (vertices only, vertices+plane,
+  // vertices+plane+boundingSphere) causing megamorphic property access.
+  return { vertices, plane: null, boundingSphere: null }
 }
 
 module.exports = create

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

@@ -4,6 +4,6 @@ const { create } = require('./index')
 
 test('poly3: create() should return a poly3 with initial values', (t) => {
   const obs = create()
-  const exp = { vertices: [] }
+  const exp = { vertices: [], plane: null, boundingSphere: null }
   t.deepEqual(obs, exp)
 })

package/src/geometries/poly3/fromPointsAndPlane.js

@@ -9,9 +9,8 @@ const create = require('./create')
  * @alias module:modeling/geometries/poly3.fromPointsAndPlane
  */
 const fromPointsAndPlane = (vertices, plane) => {
-  const poly = create(vertices)
-  poly.plane = plane // retain the plane for later use
-  return poly
+  // Create with same shape as create() for V8 hidden class consistency
+  return { vertices, plane, boundingSphere: null }
 }
 
 module.exports = fromPointsAndPlane

package/src/geometries/poly3/invert.js

@@ -9,7 +9,13 @@ const create = require('./create')
  * @alias module:modeling/geometries/poly3.invert
  */
 const invert = (polygon) => {
-  const vertices = polygon.vertices.slice().reverse()
+  // Reverse vertices directly without intermediate slice() allocation
+  const src = polygon.vertices
+  const len = src.length
+  const vertices = new Array(len)
+  for (let i = 0; i < len; i++) {
+    vertices[i] = src[len - 1 - i]
+  }
   const inverted = create(vertices)
   if (polygon.plane) {
     // Flip existing plane to save recompute

package/src/geometries/poly3/measureBoundingSphere.js

@@ -1,7 +1,5 @@
 const vec4 = require('../../maths/vec4')
 
-const cache = new WeakMap()
-
 /**
  * Measure the bounding sphere of the given polygon.
  * @param {poly3} polygon - the polygon to measure
@@ -9,8 +7,10 @@ const cache = new WeakMap()
  * @alias module:modeling/geometries/poly3.measureBoundingSphere
  */
 const measureBoundingSphere = (polygon) => {
-  const boundingSphere = cache.get(polygon)
-  if (boundingSphere) return boundingSphere
+  // Use direct property cache instead of WeakMap for faster lookup.
+  // WeakMap.get() was consuming ~12% of boolean operation time due to
+  // 15+ million lookups. Direct property access is ~2x faster.
+  if (polygon.boundingSphere) return polygon.boundingSphere
 
   const vertices = polygon.vertices
   const out = vec4.create()
@@ -31,14 +31,16 @@ const measureBoundingSphere = (polygon) => {
   let maxy = minx
   let maxz = minx
 
-  vertices.forEach((v) => {
+  // Use for loop instead of forEach for better performance in hot path
+  for (let i = 0; i < vertices.length; i++) {
+    const v = vertices[i]
     if (minx[0] > v[0]) minx = v
     if (miny[1] > v[1]) miny = v
     if (minz[2] > v[2]) minz = v
     if (maxx[0] < v[0]) maxx = v
     if (maxy[1] < v[1]) maxy = v
     if (maxz[2] < v[2]) maxz = v
-  })
+  }
 
   out[0] = (minx[0] + maxx[0]) * 0.5 // center of sphere
   out[1] = (miny[1] + maxy[1]) * 0.5
@@ -48,7 +50,7 @@ const measureBoundingSphere = (polygon) => {
   const z = out[2] - maxz[2]
   out[3] = Math.sqrt(x * x + y * y + z * z) // radius of sphere
 
-  cache.set(polygon, out)
+  polygon.boundingSphere = out
 
   return out
 }

package/src/index.d.ts

@@ -11,6 +11,7 @@ export * as booleans from './operations/booleans'
 export * as expansions from './operations/expansions'
 export * as extrusions from './operations/extrusions'
 export * as hulls from './operations/hulls'
+export * as minkowski from './operations/minkowski'
 export * as modifiers from './operations/modifiers'
 export * as transforms from './operations/transforms'
 

package/src/index.js

@@ -12,6 +12,7 @@ module.exports = {
   expansions: require('./operations/expansions'),
   extrusions: require('./operations/extrusions'),
   hulls: require('./operations/hulls'),
+  minkowski: require('./operations/minkowski'),
   modifiers: require('./operations/modifiers'),
   transforms: require('./operations/transforms')
 }

package/src/operations/booleans/trees/splitPolygonByPlane.js

@@ -9,14 +9,26 @@ const splitLineSegmentByPlane = require('./splitLineSegmentByPlane')
 
 const EPS_SQUARED = EPS * EPS
 
+// Object pool for reducing allocations in hot path.
+// The result object is safe to reuse because callers extract front/back immediately.
+// The temporary arrays are only used within splitPolygonByPlane.
+const pool = {
+  result: { type: null, front: null, back: null },
+  vertexIsBack: new Array(64), // Pre-allocated, grows if needed
+  frontvertices: new Array(32),
+  backvertices: new Array(32)
+}
+
 // Remove consecutive duplicate vertices from a polygon vertex list.
 // Compares last vertex to first to handle wraparound.
-// Returns a new array (does not modify input).
-const removeConsecutiveDuplicates = (vertices) => {
-  if (vertices.length < 3) return vertices
+// Returns a new array (polygon vertices must be fresh arrays since they're stored in geometry).
+// Accepts optional count parameter for use with pre-allocated pooled arrays.
+const removeConsecutiveDuplicates = (vertices, count) => {
+  const vertexCount = count !== undefined ? count : vertices.length
+  if (vertexCount < 3) return vertices.slice(0, vertexCount)
   const result = []
-  let prevvertex = vertices[vertices.length - 1]
-  for (let i = 0; i < vertices.length; i++) {
+  let prevvertex = vertices[vertexCount - 1]
+  for (let i = 0; i < vertexCount; i++) {
     const vertex = vertices[i]
     if (vec3.squaredDistance(vertex, prevvertex) >= EPS_SQUARED) {
       result.push(vertex)
@@ -36,12 +48,15 @@ const removeConsecutiveDuplicates = (vertices) => {
 // In case the polygon is spanning, returns:
 // .front: a Polygon3 of the front part
 // .back: a Polygon3 of the back part
+//
+// IMPORTANT: The returned object is reused between calls to reduce allocations.
+// Callers must extract .front and .back before the next call to splitPolygonByPlane.
 const splitPolygonByPlane = (splane, polygon) => {
-  const result = {
-    type: null,
-    front: null,
-    back: null
-  }
+  const result = pool.result
+  result.type = null
+  result.front = null
+  result.back = null
+
   // cache in local lets (speedup):
   const vertices = polygon.vertices
   const numvertices = vertices.length
@@ -51,12 +66,16 @@ const splitPolygonByPlane = (splane, polygon) => {
   } else {
     let hasfront = false
     let hasback = false
-    const vertexIsBack = []
+    // Use pooled array, grow if needed
+    let vertexIsBack = pool.vertexIsBack
+    if (vertexIsBack.length < numvertices) {
+      vertexIsBack = pool.vertexIsBack = new Array(numvertices * 2)
+    }
     const MINEPS = -EPS
     for (let i = 0; i < numvertices; i++) {
       const t = vec3.dot(splane, vertices[i]) - splane[3]
       const isback = (t < MINEPS)
-      vertexIsBack.push(isback)
+      vertexIsBack[i] = isback
       if (t > EPS) hasfront = true
       if (t < MINEPS) hasback = true
     }
@@ -71,8 +90,19 @@ const splitPolygonByPlane = (splane, polygon) => {
     } else {
       // spanning
       result.type = 4
-      const frontvertices = []
-      const backvertices = []
+      // Use pooled arrays, grow if needed (max 2 vertices added per original vertex)
+      const maxVerts = numvertices * 2
+      let frontvertices = pool.frontvertices
+      let backvertices = pool.backvertices
+      if (frontvertices.length < maxVerts) {
+        frontvertices = pool.frontvertices = new Array(maxVerts)
+      }
+      if (backvertices.length < maxVerts) {
+        backvertices = pool.backvertices = new Array(maxVerts)
+      }
+      let frontCount = 0
+      let backCount = 0
+
       let isback = vertexIsBack[0]
       for (let vertexindex = 0; vertexindex < numvertices; vertexindex++) {
         const vertex = vertices[vertexindex]
@@ -82,34 +112,39 @@ const splitPolygonByPlane = (splane, polygon) => {
         if (isback === nextisback) {
           // line segment is on one side of the plane:
           if (isback) {
-            backvertices.push(vertex)
+            backvertices[backCount++] = vertex
           } else {
-            frontvertices.push(vertex)
+            frontvertices[frontCount++] = vertex
           }
         } else {
           // line segment intersects plane:
           const nextpoint = vertices[nextvertexindex]
           const intersectionpoint = splitLineSegmentByPlane(splane, vertex, nextpoint)
           if (isback) {
-            backvertices.push(vertex)
-            backvertices.push(intersectionpoint)
-            frontvertices.push(intersectionpoint)
+            backvertices[backCount++] = vertex
+            backvertices[backCount++] = intersectionpoint
+            frontvertices[frontCount++] = intersectionpoint
           } else {
-            frontvertices.push(vertex)
-            frontvertices.push(intersectionpoint)
-            backvertices.push(intersectionpoint)
+            frontvertices[frontCount++] = vertex
+            frontvertices[frontCount++] = intersectionpoint
+            backvertices[backCount++] = intersectionpoint
           }
         }
         isback = nextisback
       } // for vertexindex
-      // remove consecutive duplicate vertices
-      const backFiltered = removeConsecutiveDuplicates(backvertices)
-      const frontFiltered = removeConsecutiveDuplicates(frontvertices)
-      if (frontFiltered.length >= 3) {
-        result.front = poly3.fromPointsAndPlane(frontFiltered, pplane)
+      // remove consecutive duplicate vertices and create final polygons
+      // We need fresh arrays for the polygon vertices since they become part of the geometry
+      if (frontCount >= 3) {
+        const frontFiltered = removeConsecutiveDuplicates(frontvertices, frontCount)
+        if (frontFiltered.length >= 3) {
+          result.front = poly3.fromPointsAndPlane(frontFiltered, pplane)
+        }
       }
-      if (backFiltered.length >= 3) {
-        result.back = poly3.fromPointsAndPlane(backFiltered, pplane)
+      if (backCount >= 3) {
+        const backFiltered = removeConsecutiveDuplicates(backvertices, backCount)
+        if (backFiltered.length >= 3) {
+          result.back = poly3.fromPointsAndPlane(backFiltered, pplane)
+        }
       }
     }
   }

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

@@ -0,0 +1,2 @@
+export { default as isConvex } from './isConvex'
+export { default as minkowskiSum } from './minkowskiSum'

package/src/operations/minkowski/index.js

@@ -0,0 +1,18 @@
+/**
+ * Minkowski sum operations for 3D geometries.
+ *
+ * The Minkowski sum of two shapes A and B is the set of all points that are
+ * the sum of a point in A and a point in B. This is useful for:
+ * - Offsetting/inflating shapes (using a sphere creates rounded edges)
+ * - Collision detection (shapes collide iff their Minkowski difference contains origin)
+ * - Motion planning and swept volumes
+ *
+ * @module modeling/operations/minkowski
+ * @example
+ * const { minkowski } = require('@jscad/modeling').operations
+ * const rounded = minkowski.minkowskiSum(cube, sphere)
+ */
+module.exports = {
+  isConvex: require('./isConvex'),
+  minkowskiSum: require('./minkowskiSum')
+}

package/src/operations/minkowski/isConvex.d.ts

@@ -0,0 +1,5 @@
+import { Geom3 } from '../../geometries/types'
+
+export default isConvex
+
+declare function isConvex(geometry: Geom3): boolean

package/src/operations/minkowski/isConvex.js

@@ -0,0 +1,67 @@
+const { EPS } = require('../../maths/constants')
+const vec3 = require('../../maths/vec3')
+
+const geom3 = require('../../geometries/geom3')
+const poly3 = require('../../geometries/poly3')
+
+/**
+ * Test if a 3D geometry is convex.
+ *
+ * A polyhedron is convex if every vertex lies on or behind every face plane
+ * (i.e., on the interior side of the plane).
+ *
+ * @param {geom3} geometry - the geometry to test
+ * @returns {boolean} true if the geometry is convex
+ * @alias module:modeling/operations/minkowski.isConvex
+ *
+ * @example
+ * const { primitives, minkowski } = require('@jscad/modeling')
+ * const cube = primitives.cuboid({ size: [10, 10, 10] })
+ * console.log(minkowski.isConvex(cube)) // true
+ */
+const isConvex = (geometry) => {
+  if (!geom3.isA(geometry)) {
+    throw new Error('isConvex requires a geom3 geometry')
+  }
+
+  const polygons = geom3.toPolygons(geometry)
+
+  if (polygons.length === 0) {
+    return true // Empty geometry is trivially convex
+  }
+
+  // Collect all unique vertices
+  const vertices = []
+  const found = new Set()
+  for (let i = 0; i < polygons.length; i++) {
+    const verts = polygons[i].vertices
+    for (let j = 0; j < verts.length; j++) {
+      const v = verts[j]
+      const key = `${v[0]},${v[1]},${v[2]}`
+      if (!found.has(key)) {
+        found.add(key)
+        vertices.push(v)
+      }
+    }
+  }
+
+  // For each face plane, check that all vertices are on or behind it
+  for (let i = 0; i < polygons.length; i++) {
+    const plane = poly3.plane(polygons[i])
+
+    for (let j = 0; j < vertices.length; j++) {
+      const v = vertices[j]
+      // Distance from point to plane: dot(normal, point) - w
+      const distance = vec3.dot(plane, v) - plane[3]
+
+      // If any vertex is in front of any face (positive distance), not convex
+      if (distance > EPS) {
+        return false
+      }
+    }
+  }
+
+  return true
+}
+
+module.exports = isConvex

package/src/operations/minkowski/isConvex.test.js

@@ -0,0 +1,48 @@
+const test = require('ava')
+
+const { geom3 } = require('../../geometries')
+const { cuboid, sphere, cylinderElliptic } = require('../../primitives')
+const { subtract } = require('../booleans')
+
+const isConvex = require('./isConvex')
+
+test('isConvex: throws for non-geom3 input', (t) => {
+  t.throws(() => isConvex('invalid'), { message: /requires a geom3/ })
+  t.throws(() => isConvex(null), { message: /requires a geom3/ })
+})
+
+test('isConvex: empty geometry is convex', (t) => {
+  const empty = geom3.create()
+  t.true(isConvex(empty))
+})
+
+test('isConvex: cuboid is convex', (t) => {
+  const cube = cuboid({ size: [10, 10, 10] })
+  t.true(isConvex(cube))
+})
+
+test('isConvex: sphere is convex', (t) => {
+  const sph = sphere({ radius: 5, segments: 16 })
+  t.true(isConvex(sph))
+})
+
+test('isConvex: cylinder is convex', (t) => {
+  const cyl = cylinderElliptic({ height: 10, startRadius: [3, 3], endRadius: [3, 3], segments: 16 })
+  t.true(isConvex(cyl))
+})
+
+test('isConvex: cube with hole is not convex', (t) => {
+  const cube = cuboid({ size: [10, 10, 10] })
+  const hole = cuboid({ size: [4, 4, 20] }) // Hole through the cube
+
+  const withHole = subtract(cube, hole)
+  t.false(isConvex(withHole))
+})
+
+test('isConvex: L-shaped solid is not convex', (t) => {
+  const big = cuboid({ size: [10, 10, 10], center: [0, 0, 0] })
+  const corner = cuboid({ size: [6, 6, 12], center: [3, 3, 0] })
+
+  const lShape = subtract(big, corner)
+  t.false(isConvex(lShape))
+})

package/src/operations/minkowski/minkowskiSum.d.ts

@@ -0,0 +1,6 @@
+import { Geom3 } from '../../geometries/types'
+
+export default minkowskiSum
+
+declare function minkowskiSum(geometryA: Geom3, geometryB: Geom3): Geom3
+declare function minkowskiSum(...geometries: Geom3[]): Geom3

package/src/operations/minkowski/minkowskiSum.js

@@ -0,0 +1,223 @@
+const flatten = require('../../utils/flatten')
+
+const geom3 = require('../../geometries/geom3')
+const poly3 = require('../../geometries/poly3')
+
+const hullPoints3 = require('../hulls/hullPoints3')
+const union = require('../booleans/union')
+
+const isConvex = require('./isConvex')
+
+/**
+ * Compute the Minkowski sum of two 3D geometries.
+ *
+ * The Minkowski sum A ⊕ B is the set of all points a + b where a ∈ A and b ∈ B.
+ * Geometrically, this "inflates" geometry A by the shape of geometry B.
+ *
+ * Common use cases:
+ * - Offset a solid by a sphere to round all edges and corners
+ * - Offset a solid by a cube to create chamfered edges
+ * - Collision detection (if Minkowski sum contains origin, shapes overlap)
+ *
+ * For best performance, use convex geometries. Non-convex geometries are supported
+ * when the second operand is convex, but require decomposition and are slower.
+ *
+ * @param {...Object} geometries - two geom3 geometries (second should be convex for non-convex first)
+ * @returns {geom3} new 3D geometry representing the Minkowski sum
+ * @alias module:modeling/operations/minkowski.minkowskiSum
+ *
+ * @example
+ * const { primitives, minkowski } = require('@jscad/modeling')
+ * const cube = primitives.cuboid({ size: [10, 10, 10] })
+ * const sphere = primitives.sphere({ radius: 2, segments: 16 })
+ * const rounded = minkowski.minkowskiSum(cube, sphere)
+ */
+const minkowskiSum = (...geometries) => {
+  geometries = flatten(geometries)
+
+  if (geometries.length < 2) {
+    throw new Error('minkowskiSum requires at least two geometries')
+  }
+
+  if (geometries.length > 2) {
+    throw new Error('minkowskiSum currently supports exactly two geometries')
+  }
+
+  const [geomA, geomB] = geometries
+
+  if (!geom3.isA(geomA) || !geom3.isA(geomB)) {
+    throw new Error('minkowskiSum requires geom3 geometries')
+  }
+
+  const aConvex = isConvex(geomA)
+  const bConvex = isConvex(geomB)
+
+  // Fast path: both convex
+  if (aConvex && bConvex) {
+    return minkowskiSumConvex(geomA, geomB)
+  }
+
+  // Non-convex A + convex B: decompose A into tetrahedra
+  if (!aConvex && bConvex) {
+    return minkowskiSumNonConvexConvex(geomA, geomB)
+  }
+
+  // Convex A + non-convex B: swap operands (Minkowski sum is commutative)
+  if (aConvex && !bConvex) {
+    return minkowskiSumNonConvexConvex(geomB, geomA)
+  }
+
+  // Both non-convex: not yet supported
+  throw new Error('minkowskiSum of two non-convex geometries is not yet supported')
+}
+
+/**
+ * Compute Minkowski sum of non-convex A with convex B.
+ *
+ * Decomposes A into tetrahedra, computes Minkowski sum of each with B,
+ * then unions all results.
+ */
+const minkowskiSumNonConvexConvex = (geomA, geomB) => {
+  const tetrahedra = decomposeIntoTetrahedra(geomA)
+
+  if (tetrahedra.length === 0) {
+    return geom3.create()
+  }
+
+  // Compute Minkowski sum for each tetrahedron
+  const parts = tetrahedra.map((tet) => minkowskiSumConvex(tet, geomB))
+
+  // Union all parts
+  if (parts.length === 1) {
+    return parts[0]
+  }
+
+  return union(parts)
+}
+
+/**
+ * Decompose a geom3 into tetrahedra using fan triangulation from centroid.
+ * Each resulting tetrahedron is guaranteed to be convex.
+ */
+const decomposeIntoTetrahedra = (geometry) => {
+  const polygons = geom3.toPolygons(geometry)
+
+  if (polygons.length === 0) {
+    return []
+  }
+
+  // Compute centroid of the geometry
+  const centroid = computeCentroid(geometry)
+
+  const tetrahedra = []
+
+  // For each polygon, create tetrahedra from centroid to each triangle
+  for (let i = 0; i < polygons.length; i++) {
+    const vertices = polygons[i].vertices
+
+    // Fan triangulate the polygon and create tetrahedra
+    for (let j = 1; j < vertices.length - 1; j++) {
+      const v0 = vertices[0]
+      const v1 = vertices[j]
+      const v2 = vertices[j + 1]
+
+      // Create tetrahedron from centroid and triangle
+      const tetPolygons = createTetrahedronPolygons(centroid, v0, v1, v2)
+      tetrahedra.push(geom3.create(tetPolygons))
+    }
+  }
+
+  return tetrahedra
+}
+
+/**
+ * Create the 4 triangular faces of a tetrahedron.
+ */
+const createTetrahedronPolygons = (p0, p1, p2, p3) => {
+  // Tetrahedron has 4 faces, each a triangle
+  // We need to ensure consistent winding (outward-facing normals)
+  return [
+    poly3.create([p0, p2, p1]), // base seen from p3
+    poly3.create([p0, p1, p3]), // face opposite p2
+    poly3.create([p1, p2, p3]), // face opposite p0
+    poly3.create([p2, p0, p3])  // face opposite p1
+  ]
+}
+
+/**
+ * Compute the centroid of a geom3.
+ */
+const computeCentroid = (geometry) => {
+  const vertices = extractUniqueVertices(geometry)
+
+  if (vertices.length === 0) {
+    return [0, 0, 0]
+  }
+
+  let x = 0, y = 0, z = 0
+  for (let i = 0; i < vertices.length; i++) {
+    x += vertices[i][0]
+    y += vertices[i][1]
+    z += vertices[i][2]
+  }
+
+  const n = vertices.length
+  return [x / n, y / n, z / n]
+}
+
+/**
+ * Compute Minkowski sum of two convex polyhedra.
+ *
+ * For convex polyhedra, the Minkowski sum equals the convex hull of
+ * all pairwise vertex sums. This is O(n*m) for n and m vertices,
+ * plus the cost of the convex hull algorithm.
+ */
+const minkowskiSumConvex = (geomA, geomB) => {
+  const pointsA = extractUniqueVertices(geomA)
+  const pointsB = extractUniqueVertices(geomB)
+
+  if (pointsA.length === 0 || pointsB.length === 0) {
+    return geom3.create()
+  }
+
+  // Compute all pairwise sums
+  const summedPoints = []
+  for (let i = 0; i < pointsA.length; i++) {
+    const a = pointsA[i]
+    for (let j = 0; j < pointsB.length; j++) {
+      const b = pointsB[j]
+      summedPoints.push([a[0] + b[0], a[1] + b[1], a[2] + b[2]])
+    }
+  }
+
+  // Compute convex hull of the summed points
+  const hullPolygons = hullPoints3(summedPoints)
+
+  return geom3.create(hullPolygons)
+}
+
+/**
+ * Extract unique vertices from a geom3.
+ * Uses a Set with string keys for deduplication.
+ */
+const extractUniqueVertices = (geometry) => {
+  const found = new Set()
+  const unique = []
+
+  const polygons = geom3.toPolygons(geometry)
+  for (let i = 0; i < polygons.length; i++) {
+    const vertices = polygons[i].vertices
+    for (let j = 0; j < vertices.length; j++) {
+      const v = vertices[j]
+      const key = `${v[0]},${v[1]},${v[2]}`
+      if (!found.has(key)) {
+        found.add(key)
+        unique.push(v)
+      }
+    }
+  }
+
+  return unique
+}
+
+module.exports = minkowskiSum