@jscad/modeling 2.7.2 → 2.9.1

package/src/operations/expansions/offset.test.js

@@ -12,6 +12,7 @@ test('offset: offsetting a straight line produces expected geometry', (t) => {
   // offset it by 2.
   let offsetLinePath2 = offset({ delta: 2, corners: 'edge', segments: 8 }, linePath2)
   let offsetPoints = path2.toPoints(offsetLinePath2)
+  t.notThrows(() => path2.validate(offsetLinePath2))
   t.is(offsetPoints.length, 2)
   let boundingBox = measureBoundingBox(offsetLinePath2)
   t.true(comparePoints(boundingBox, [[2, 0, 0], [2, 10, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
@@ -19,6 +20,7 @@ test('offset: offsetting a straight line produces expected geometry', (t) => {
   // offset it by -2.
   offsetLinePath2 = offset({ delta: -2, corners: 'edge', segments: 8 }, linePath2)
   offsetPoints = path2.toPoints(offsetLinePath2)
+  t.notThrows(() => path2.validate(offsetLinePath2))
   t.is(offsetPoints.length, 2)
   boundingBox = measureBoundingBox(offsetLinePath2)
   t.true(comparePoints(boundingBox, [[-2, 0, 0], [-2, 10, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
@@ -27,6 +29,7 @@ test('offset: offsetting a straight line produces expected geometry', (t) => {
   linePath2 = path2.fromPoints({ closed: false }, points.reverse())
   offsetLinePath2 = offset({ delta: 2, corners: 'edge', segments: 8 }, linePath2)
   offsetPoints = path2.toPoints(offsetLinePath2)
+  t.notThrows(() => path2.validate(offsetLinePath2))
   t.is(offsetPoints.length, 2)
   boundingBox = measureBoundingBox(offsetLinePath2)
   t.true(comparePoints(boundingBox, [[-2, 0, 0], [-2, 10, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
@@ -39,6 +42,7 @@ test('offset: offsetting a bent line produces expected geometry', (t) => {
   // offset it by 2.
   let offsetLinePath2 = offset({ delta: 2, corners: 'edge', segments: 8 }, linePath2)
   let offsetPoints = path2.toPoints(offsetLinePath2)
+  t.notThrows(() => path2.validate(offsetLinePath2))
   t.is(offsetPoints.length, 5)
   let boundingBox = measureBoundingBox(offsetLinePath2)
   t.true(comparePoints(boundingBox, [[2, 0, 0], [10, 8, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
@@ -46,7 +50,8 @@ test('offset: offsetting a bent line produces expected geometry', (t) => {
   // offset it by -2.
   offsetLinePath2 = offset({ delta: -2, corners: 'edge', segments: 8 }, linePath2)
   offsetPoints = path2.toPoints(offsetLinePath2)
-  t.is(offsetPoints.length, 7)
+  t.notThrows(() => path2.validate(offsetLinePath2))
+  t.is(offsetPoints.length, 5)
   boundingBox = measureBoundingBox(offsetLinePath2)
   t.true(comparePoints(boundingBox, [[-2, 0, 0], [10, 12, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
 })
@@ -56,6 +61,7 @@ test('offset: offsetting a 2 segment straight line produces expected geometry',
   const linePath2 = path2.fromPoints({ closed: false }, points)
   const offsetLinePath2 = offset({ delta: 2, corners: 'edge', segments: 8 }, linePath2)
   const offsetPoints = path2.toPoints(offsetLinePath2)
+  t.notThrows(() => path2.validate(offsetLinePath2))
   t.is(offsetPoints.length, 3)
   const boundingBox = measureBoundingBox(offsetLinePath2)
   t.true(comparePoints(boundingBox, [[2, 0, 0], [2, 10, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
@@ -71,6 +77,7 @@ test('offset (corners: chamfer): offset of a path2 produces expected offset path
   let pts = path2.toPoints(obs)
   let exp = [
   ]
+  t.notThrows(() => path2.validate(obs))
   t.true(comparePoints(pts, exp))
 
   // expand +
@@ -82,6 +89,7 @@ test('offset (corners: chamfer): offset of a path2 produces expected offset path
     [5.707106781186548, 0.7071067811865475],
     [0.7071067811865475, 5.707106781186548]
   ]
+  t.notThrows(() => path2.validate(obs))
   t.true(comparePoints(pts, exp))
 
   obs = offset({ delta: 1, corners: 'chamfer' }, closeline)
@@ -94,6 +102,7 @@ test('offset (corners: chamfer): offset of a path2 produces expected offset path
     [-1, 5],
     [-1, 6.123233995736766e-17]
   ]
+  t.notThrows(() => path2.validate(obs))
   t.true(comparePoints(pts, exp))
 
   // contract -
@@ -104,6 +113,7 @@ test('offset (corners: chamfer): offset of a path2 produces expected offset path
     [2.5857864376269046, 1],
     [-0.7071067811865475, 4.292893218813452]
   ]
+  t.notThrows(() => path2.validate(obs))
   t.true(comparePoints(pts, exp))
 
   obs = offset({ delta: -1, corners: 'chamfer' }, closeline)
@@ -113,6 +123,7 @@ test('offset (corners: chamfer): offset of a path2 produces expected offset path
     [2.5857864376269046, 1],
     [0.9999999999999996, 2.585786437626905]
   ]
+  t.notThrows(() => path2.validate(obs))
   t.true(comparePoints(pts, exp))
 })
 
@@ -124,48 +135,30 @@ test('offset (corners: edge): offset of a path2 produces expected offset path2',
   let pts = path2.toPoints(obs)
   let exp = [
     [-5, -6],
-    [5, -6],
     [6, -6],
-    [6, -5],
-    [6, 5],
     [6, 6],
-    [5, 6],
-    [3, 6],
     [2, 6],
-    [2, 5],
     [2, 1],
     [-2, 1],
-    [-2, 5],
     [-1.9999999999999996, 6],
-    [-3, 6],
     [-5, 6]
   ]
+  t.notThrows(() => path2.validate(obs))
   t.true(comparePoints(pts, exp))
 
   obs = offset({ delta: 1, corners: 'edge' }, closeline)
   pts = path2.toPoints(obs)
   exp = [
-    [-6, -6],
-    [-5, -6],
-    [5, -6],
     [6, -6],
-    [6, -5],
-    [6, 5],
     [6, 6],
-    [5, 6],
-    [3, 6],
     [2, 6],
-    [2, 5],
     [2, 1],
     [-2, 1],
-    [-2, 5],
     [-1.9999999999999996, 6],
-    [-3, 6],
-    [-5, 6],
     [-6, 6],
-    [-6, 5],
-    [-6, -5]
+    [-6, -6]
   ]
+  t.notThrows(() => path2.validate(obs))
   t.true(comparePoints(pts, exp))
 
   obs = offset({ delta: -0.5, corners: 'edge' }, openline)
@@ -175,15 +168,12 @@ test('offset (corners: edge): offset of a path2 produces expected offset path2',
     [4.5, -4.5],
     [4.5, 4.5],
     [3.5, 4.5],
-    [3.5, -3.061616997868383e-17],
     [3.4999999999999996, -0.5],
-    [3, -0.5],
-    [-3, -0.5],
     [-3.5, -0.4999999999999996],
-    [-3.5, 3.061616997868383e-17],
     [-3.5, 4.5],
     [-5, 4.5]
   ]
+  t.notThrows(() => path2.validate(obs))
   t.true(comparePoints(pts, exp))
 
   obs = offset({ delta: -0.5, corners: 'edge' }, closeline)
@@ -193,15 +183,12 @@ test('offset (corners: edge): offset of a path2 produces expected offset path2',
     [4.5, -4.5],
     [4.5, 4.5],
     [3.5, 4.5],
-    [3.5, -3.061616997868383e-17],
     [3.4999999999999996, -0.5],
-    [3, -0.5],
-    [-3, -0.5],
     [-3.5, -0.4999999999999996],
-    [-3.5, 3.061616997868383e-17],
     [-3.5, 4.5],
     [-4.5, 4.5]
   ]
+  t.notThrows(() => path2.validate(obs))
   t.true(comparePoints(pts, exp))
 })
 
@@ -237,6 +224,7 @@ test('offset (corners: round): offset of a path2 produces expected offset path2'
     [-3, 6],
     [-5, 6]
   ]
+  t.notThrows(() => path2.validate(obs))
   t.true(comparePoints(pts, exp))
 
   obs = offset({ delta: 1, corners: 'round', segments: 16 }, closeline)
@@ -275,6 +263,7 @@ test('offset (corners: round): offset of a path2 produces expected offset path2'
     [-6, 5],
     [-6, -5]
   ]
+  t.notThrows(() => path2.validate(obs))
   t.true(comparePoints(pts, exp))
 })
 
@@ -317,6 +306,7 @@ test('offset (corners: round): offset of a CW path2 produces expected offset pat
     [5, -6],
     [-5, -6]
   ]
+  t.notThrows(() => path2.validate(obs))
   t.true(comparePoints(pts, exp))
 })
 
@@ -329,6 +319,7 @@ test('offset (options): offsetting of a simple geom2 produces expected offset ge
   let pts = geom2.toPoints(obs)
   let exp = [
   ]
+  t.notThrows(() => geom2.validate(obs))
   t.true(comparePoints(pts, exp))
 
   // expand +
@@ -350,6 +341,7 @@ test('offset (options): offsetting of a simple geom2 produces expected offset ge
     [-6, 5],
     [-6, -5]
   ]
+  t.notThrows(() => geom2.validate(obs))
   t.true(comparePoints(pts, exp))
 
   // contract -
@@ -367,33 +359,23 @@ test('offset (options): offsetting of a simple geom2 produces expected offset ge
     [-3.5, 4.5],
     [-4.5, 4.5]
   ]
+  t.notThrows(() => geom2.validate(obs))
   t.true(comparePoints(pts, exp))
 
   // segments 1 - sharp points at corner
   obs = offset({ delta: 1, corners: 'edge' }, geometry)
   pts = geom2.toPoints(obs)
   exp = [
-    [-6, -6],
-    [-5, -6],
-    [5, -6],
     [6, -6],
-    [6, -5],
-    [6, 5],
     [6, 6],
-    [5, 6],
-    [3, 6],
     [2, 6],
-    [2, 5],
     [2, 1],
     [-2, 1],
-    [-2, 5],
     [-1.9999999999999996, 6],
-    [-3, 6],
-    [-5, 6],
     [-6, 6],
-    [-6, 5],
-    [-6, -5]
+    [-6, -6]
   ]
+  t.notThrows(() => geom2.validate(obs))
   t.true(comparePoints(pts, exp))
 
   // segments 16 - rounded corners
@@ -417,83 +399,61 @@ test('offset (options): offsetting of a simple geom2 produces expected offset ge
     [-3.5, 4.5],
     [-4.5, 4.5]
   ]
+  t.notThrows(() => geom2.validate(obs))
   t.true(comparePoints(pts, exp))
 })
 
 test('offset (options): offsetting of a complex geom2 produces expected offset geom2', (t) => {
   const geometry = geom2.create([
-    [[-75.00000, 75.00000], [-75.00000, -75.00000]],
-    [[-75.00000, -75.00000], [75.00000, -75.00000]],
-    [[75.00000, -75.00000], [75.00000, 75.00000]],
-    [[-40.00000, 75.00000], [-75.00000, 75.00000]],
-    [[75.00000, 75.00000], [40.00000, 75.00000]],
-    [[40.00000, 75.00000], [40.00000, 0.00000]],
-    [[40.00000, 0.00000], [-40.00000, 0.00000]],
-    [[-40.00000, 0.00000], [-40.00000, 75.00000]],
-    [[15.00000, -10.00000], [15.00000, -40.00000]],
-    [[-15.00000, -10.00000], [15.00000, -10.00000]],
-    [[-15.00000, -40.00000], [-15.00000, -10.00000]],
-    [[-8.00000, -40.00000], [-15.00000, -40.00000]],
-    [[15.00000, -40.00000], [8.00000, -40.00000]],
-    [[-8.00000, -25.00000], [-8.00000, -40.00000]],
-    [[8.00000, -25.00000], [-8.00000, -25.00000]],
-    [[8.00000, -40.00000], [8.00000, -25.00000]],
-    [[-2.00000, -15.00000], [-2.00000, -19.00000]],
-    [[-2.00000, -19.00000], [2.00000, -19.00000]],
-    [[2.00000, -19.00000], [2.00000, -15.00000]],
-    [[2.00000, -15.00000], [-2.00000, -15.00000]]
+    [[-75, 75], [-75, -75]],
+    [[-75, -75], [75, -75]],
+    [[75, -75], [75, 75]],
+    [[-40, 75], [-75, 75]],
+    [[75, 75], [40, 75]],
+    [[40, 75], [40, 0]],
+    [[40, 0], [-40, 0]],
+    [[-40, 0], [-40, 75]],
+    [[15, -10], [15, -40]],
+    [[-15, -10], [15, -10]],
+    [[-15, -40], [-15, -10]],
+    [[-8, -40], [-15, -40]],
+    [[15, -40], [8, -40]],
+    [[-8, -25], [-8, -40]],
+    [[8, -25], [-8, -25]],
+    [[8, -40], [8, -25]],
+    [[-2, -15], [-2, -19]],
+    [[-2, -19], [2, -19]],
+    [[2, -19], [2, -15]],
+    [[2, -15], [-2, -15]]
   ])
 
   // expand +
   const obs = offset({ delta: 2, corners: 'edge' }, geometry)
   const pts = geom2.toPoints(obs)
   const exp = [
-    [-77, -77],
-    [-75, -77],
-    [75, -77],
     [77, -77],
-    [77, -75],
-    [77, 75],
     [77, 77],
-    [75, 77],
-    [40, 77],
     [38, 77],
-    [38, 75],
     [38, 2],
     [-38, 2],
-    [-38, 75],
     [-37.99999999999999, 77],
-    [-40, 77],
-    [-75, 77],
     [-77, 77],
-    [-77, 75],
     [13, -12],
     [13, -38],
     [10, -38],
-    [10, -25],
     [10, -23],
-    [8, -23],
-    [-8, -23],
     [-10, -23],
-    [-10, -25],
     [-10, -38],
     [-13, -38],
     [-13, -12],
-    [-4, -19],
     [-4, -21],
-    [-2, -21],
-    [1.9999999999999998, -21],
     [3.9999999999999996, -21],
-    [4, -19],
-    [4, -15],
     [4, -13],
-    [2, -13],
-    [-1.9999999999999998, -13],
     [-4, -13],
-    [-4, -15],
-    [-77, -75]
+    [-77, -77]
   ]
-  t.is(pts.length, 44)
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 20)
   t.true(comparePoints(pts, exp))
 })
 
@@ -537,6 +497,7 @@ test('offset (options): offsetting of round geom2 produces expected offset geom2
     [6.7105900605102855, -6.710590060510285],
     [8.767810140100096, -3.6317399864658024]
   ]
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 16)
   t.true(comparePoints(pts, exp))
 })

package/src/operations/expansions/offsetFromPoints.js

@@ -34,7 +34,7 @@ const offsetFromPoints = (options, points) => {
   delta = Math.abs(delta) // sign is no longer required
 
   let previousSegment = null
-  const newPoints = []
+  let newPoints = []
   const newCorners = []
   const of = vec2.create()
   const n = points.length
@@ -94,6 +94,10 @@ const offsetFromPoints = (options, points) => {
   // generate corners if necessary
 
   if (corners === 'edge') {
+    // map for fast point index lookup
+    const pointIndex = new Map() // {point: index}
+    newPoints.forEach((point, index) => pointIndex.set(point, index))
+
     // create edge corners
     const line0 = line2.create()
     const line1 = line2.create()
@@ -103,16 +107,17 @@ const offsetFromPoints = (options, points) => {
       const ip = line2.intersectPointOfLines(line0, line1)
       if (Number.isFinite(ip[0]) && Number.isFinite(ip[1])) {
         const p0 = corner.s0[1]
-        let i = newPoints.findIndex((point) => vec2.equals(p0, point))
-        i = (i + 1) % newPoints.length
-        newPoints.splice(i, 0, ip)
+        const i = pointIndex.get(p0)
+        newPoints[i] = ip
+        newPoints[(i + 1) % newPoints.length] = undefined
       } else {
         // paralell segments, drop one
         const p0 = corner.s1[0]
-        const i = newPoints.findIndex((point) => vec2.equals(p0, point))
-        newPoints.splice(i, 1)
+        const i = pointIndex.get(p0)
+        newPoints[i] = undefined
       }
     })
+    newPoints = newPoints.filter((p) => p !== undefined)
   }
 
   if (corners === 'round') {

package/src/operations/extrusions/earcut/assignHoles.js

@@ -0,0 +1,91 @@
+const { area } = require('../../../maths/utils')
+const { toOutlines } = require('../../../geometries/geom2')
+const { arePointsInside } = require('../../../geometries/poly2')
+
+/*
+ * Constructs a polygon hierarchy of solids and holes.
+ * The hierarchy is represented as a forest of trees. All trees shall be depth at most 2.
+ * If a solid exists inside the hole of another solid, it will be split out as its own root.
+ *
+ * @param {geom2} geometry
+ * @returns {Array} an array of polygons with associated holes
+ * @alias module:modeling/geometries/geom2.toTree
+ *
+ * @example
+ * const geometry = subtract(rectangle({size: [5, 5]}), rectangle({size: [3, 3]}))
+ * console.log(assignHoles(geometry))
+ * [{
+ *   "solid": [[-2.5,-2.5],[2.5,-2.5],[2.5,2.5],[-2.5,2.5]],
+ *   "holes": [[[-1.5,1.5],[1.5,1.5],[1.5,-1.5],[-1.5,-1.5]]]
+ * }]
+ */
+const assignHoles = (geometry) => {
+  const outlines = toOutlines(geometry)
+  const solids = [] // solid indices
+  const holes = [] // hole indices
+  outlines.forEach((outline, i) => {
+    const a = area(outline)
+    if (a < 0) {
+      holes.push(i)
+    } else if (a > 0) {
+      solids.push(i)
+    }
+  })
+
+  // for each hole, determine what solids it is inside of
+  const children = [] // child holes of solid[i]
+  const parents = [] // parent solids of hole[i]
+  solids.forEach((s, i) => {
+    const solid = outlines[s]
+    children[i] = []
+    holes.forEach((h, j) => {
+      const hole = outlines[h]
+      // check if a point of hole j is inside solid i
+      if (arePointsInside([hole[0]], { vertices: solid })) {
+        children[i].push(h)
+        if (!parents[j]) parents[j] = []
+        parents[j].push(i)
+      }
+    })
+  })
+
+  // check if holes have multiple parents and choose one with fewest children
+  holes.forEach((h, j) => {
+    // ensure at least one parent exists
+    if (parents[j] && parents[j].length > 1) {
+      // the solid directly containing this hole
+      const directParent = minIndex(parents[j], (p) => children[p].length)
+      parents[j].forEach((p, i) => {
+        if (i !== directParent) {
+          // Remove hole from skip level parents
+          children[p] = children[p].filter((c) => c !== h)
+        }
+      })
+    }
+  })
+
+  // map indices back to points
+  return children.map((holes, i) => ({
+    solid: outlines[solids[i]],
+    holes: holes.map((h) => outlines[h])
+  }))
+}
+
+/*
+ * Find the item in the list with smallest score(item).
+ * If the list is empty, return undefined.
+ */
+const minIndex = (list, score) => {
+  let bestIndex
+  let best
+  list.forEach((item, index) => {
+    const value = score(item)
+    if (best === undefined || value < best) {
+      bestIndex = index
+      best = value
+    }
+  })
+  return bestIndex
+}
+
+module.exports = assignHoles

package/src/operations/extrusions/earcut/assignHoles.test.js

@@ -0,0 +1,74 @@
+const test = require('ava')
+
+const { subtract, union } = require('../../../operations/booleans')
+const square = require('../../../primitives/square')
+const assignHoles = require('./assignHoles')
+
+test('slice: assignHoles() should return a polygon hierarchy', (t) => {
+  const exp1 = [{
+    solid: [
+      [-3.000013333333334, -3.000013333333334],
+      [3.000013333333334, -3.000013333333334],
+      [3.000013333333334, 3.000013333333334],
+      [-3.000013333333334, 3.000013333333334]
+    ],
+    holes: [[
+      [-1.9999933333333335, 1.9999933333333335],
+      [1.9999933333333335, 1.9999933333333335],
+      [1.9999933333333335, -1.9999933333333335],
+      [-1.9999933333333335, -1.9999933333333335]
+    ]]
+  }]
+  const geometry = subtract(
+    square({ size: 6 }),
+    square({ size: 4 })
+  )
+  const obs1 = assignHoles(geometry)
+  t.deepEqual(obs1, exp1)
+})
+
+test('slice: assignHoles() should handle nested holes', (t) => {
+  const geometry = union(
+    subtract(
+      square({ size: 6 }),
+      square({ size: 4 })
+    ),
+    subtract(
+      square({ size: 10 }),
+      square({ size: 8 })
+    )
+  )
+  const obs1 = assignHoles(geometry)
+
+  const exp1 = [
+    {
+      solid: [
+        [-3.0000006060444444, -3.0000006060444444],
+        [3.0000006060444444, -3.0000006060444444],
+        [3.0000006060444444, 3.0000006060444444],
+        [-3.0000006060444444, 3.0000006060444444]
+      ],
+      holes: [[
+        [-2.0000248485333336, 2.0000248485333336],
+        [2.0000248485333336, 2.0000248485333336],
+        [2.0000248485333336, -2.0000248485333336],
+        [-2.0000248485333336, -2.0000248485333336]
+      ]]
+    },
+    {
+      solid: [
+        [-5.000025454577778, -5.000025454577778],
+        [5.000025454577778, -5.000025454577778],
+        [5.000025454577778, 5.000025454577778],
+        [-5.000025454577778, 5.000025454577778]
+      ],
+      holes: [[
+        [-3.9999763635555556, 3.9999763635555556],
+        [3.9999763635555556, 3.9999763635555556],
+        [3.9999763635555556, -3.9999763635555556],
+        [-3.9999763635555556, -3.9999763635555556]
+      ]]
+    }
+  ]
+  t.deepEqual(obs1, exp1)
+})

package/src/operations/extrusions/earcut/eliminateHoles.js

@@ -0,0 +1,131 @@
+const { filterPoints, linkedPolygon, locallyInside, splitPolygon } = require('./linkedPolygon')
+const { area, pointInTriangle } = require('./triangle')
+
+/*
+ * link every hole into the outer loop, producing a single-ring polygon without holes
+ *
+ * Original source from https://github.com/mapbox/earcut
+ * Copyright (c) 2016 Mapbox
+ */
+const eliminateHoles = (data, holeIndices, outerNode, dim) => {
+  const queue = []
+
+  for (let i = 0, len = holeIndices.length; i < len; i++) {
+    const start = holeIndices[i] * dim
+    const end = i < len - 1 ? holeIndices[i + 1] * dim : data.length
+    const list = linkedPolygon(data, start, end, dim, false)
+    if (list === list.next) list.steiner = true
+    queue.push(getLeftmost(list))
+  }
+
+  queue.sort((a, b) => a.x - b.x) // compare X
+
+  // process holes from left to right
+  for (let i = 0; i < queue.length; i++) {
+    outerNode = eliminateHole(queue[i], outerNode)
+    outerNode = filterPoints(outerNode, outerNode.next)
+  }
+
+  return outerNode
+}
+
+/*
+ * find a bridge between vertices that connects hole with an outer ring and link it
+ */
+const eliminateHole = (hole, outerNode) => {
+  const bridge = findHoleBridge(hole, outerNode)
+  if (!bridge) {
+    return outerNode
+  }
+
+  const bridgeReverse = splitPolygon(bridge, hole)
+
+  // filter colinear points around the cuts
+  const filteredBridge = filterPoints(bridge, bridge.next)
+  filterPoints(bridgeReverse, bridgeReverse.next)
+
+  // Check if input node was removed by the filtering
+  return outerNode === bridge ? filteredBridge : outerNode
+}
+
+/*
+ * David Eberly's algorithm for finding a bridge between hole and outer polygon
+ */
+const findHoleBridge = (hole, outerNode) => {
+  let p = outerNode
+  const hx = hole.x
+  const hy = hole.y
+  let qx = -Infinity
+  let m
+
+  // find a segment intersected by a ray from the hole's leftmost point to the left
+  // segment's endpoint with lesser x will be potential connection point
+  do {
+    if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
+      const x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y)
+      if (x <= hx && x > qx) {
+        qx = x
+        if (x === hx) {
+          if (hy === p.y) return p
+          if (hy === p.next.y) return p.next
+        }
+
+        m = p.x < p.next.x ? p : p.next
+      }
+    }
+
+    p = p.next
+  } while (p !== outerNode)
+
+  if (!m) return null
+
+  if (hx === qx) return m // hole touches outer segment; pick leftmost endpoint
+
+  // look for points inside the triangle of hole point, segment intersection and endpoint
+  // if there are no points found, we have a valid connection
+  // otherwise choose the point of the minimum angle with the ray as connection point
+
+  const stop = m
+  const mx = m.x
+  const my = m.y
+  let tanMin = Infinity
+
+  p = m
+
+  do {
+    if (hx >= p.x && p.x >= mx && hx !== p.x &&
+        pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
+      const tan = Math.abs(hy - p.y) / (hx - p.x) // tangential
+
+      if (locallyInside(p, hole) && (tan < tanMin || (tan === tanMin && (p.x > m.x || (p.x === m.x && sectorContainsSector(m, p)))))) {
+        m = p
+        tanMin = tan
+      }
+    }
+
+    p = p.next
+  } while (p !== stop)
+
+  return m
+}
+
+/*
+ * whether sector in vertex m contains sector in vertex p in the same coordinates
+ */
+const sectorContainsSector = (m, p) => area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0
+
+/*
+ * find the leftmost node of a polygon ring
+ */
+const getLeftmost = (start) => {
+  let p = start
+  let leftmost = start
+  do {
+    if (p.x < leftmost.x || (p.x === leftmost.x && p.y < leftmost.y)) leftmost = p
+    p = p.next
+  } while (p !== start)
+
+  return leftmost
+}
+
+module.exports = eliminateHoles