geojs 1.14.0 → 1.14.2

package/geo.js

@@ -26745,6 +26745,11 @@ var _quadFeature = function quadFeature(arg) {
             coordbasis.y = 1 - coordbasis.y;
           }
           if (coordbasis) {
+            if (quad.crop && quad.crop.x !== undefined && quad.crop.y !== undefined && (coordbasis.x >= quad.crop.x || coordbasis.y >= quad.crop.y)) {
+              indices.pop();
+              found.pop();
+              return;
+            }
             extra[quad.idx] = {
               basis: coordbasis,
               _quad: quad
@@ -28164,7 +28169,7 @@ module.exports = _sceneObject;
  * @constant
  * @type {string}
  */
-module.exports = "43f61353e44a71f669a4f0d631f102a517605fe9";
+module.exports = "8e2a6bf94ba85a370a33f2144165d89dd6061439";
 
 /***/ }),
 
@@ -32855,6 +32860,8 @@ var _trackFeature = function trackFeature(arg) {
           highidx = testidx;
         }
       }
+      // todo: if we want non-linear travel between points, we would adjust
+      // fl and fh here
       var fh = (time - lowt) / (hight - lowt),
         fl = 1 - fh;
       return {
@@ -40049,7 +40056,7 @@ module.exports = _vectorFeature;
  * @constant
  * @type {string}
  */
-module.exports = "1.14.0";
+module.exports = "1.14.2";
 
 /***/ }),
 
@@ -75967,7 +75974,7 @@ module.exports = "/* lineFeature fragment shader */\n\n#ifdef GL_ES\n  #ifdef GL
 /***/ 9336:
 /***/ (function(module) {
 
-module.exports = "/* lineFeature vertex shader */\n\n#ifdef GL_ES\n  precision highp float;\n#endif\nattribute vec3 pos;\nattribute vec3 prev;\nattribute vec3 next;\nattribute vec3 far;\nattribute float flags;\n\nattribute vec3 strokeColor;\nattribute float strokeOpacity;\nattribute float strokeWidth;\n\nuniform mat4 modelViewMatrix;\nuniform mat4 projectionMatrix;\nuniform float pixelWidth;\nuniform float aspect;\nuniform float miterLimit;\nuniform float antialiasing;\n\nvarying vec4 strokeColorVar;\nvarying vec4 subpos;  /* px, py, length - px, width */\nvarying vec4 info;  /* near mode, far mode, offset */\nvarying vec4 angles; /* near angle cos, sin, far angle cos, sin */\n\nconst float PI = 3.14159265358979323846264;\n\nvec4 viewCoord(vec3 c) {\n  vec4 result = projectionMatrix * modelViewMatrix * vec4(c.xyz, 1.0);\n  if (result.w != 0.0)  result = result / result.w;\n  return result;\n}\n\nfloat atan2(float y, float x) {\n  if (x > 0.0)  return atan(y / x);\n  if (x < 0.0 && y >= 0.0)  return atan(y / x) + PI;\n  if (x < 0.0)  return atan(y / x) - PI;\n  return sign(y) * 0.5 * PI;\n}\n\nvoid main(void)\n{\n  /* If any vertex has been deliberately set to a negative opacity,\n   * skip doing computations on it. */\n  if (strokeOpacity < 0.0) {\n    gl_Position = vec4(2.0, 2.0, 0.0, 1.0);\n    return;\n  }\n  /* convert coordinates.  We have four values, since we need to\n   * calculate the angles between the lines formed by prev-pos and\n   * pos-next, and between pos-next and next-far, plus know the angle\n   *   (prev)---(pos)---(next)---(far) => A---B---C---D */\n  vec4 A = viewCoord(prev);\n  vec4 B = viewCoord(pos);\n  vec4 C = viewCoord(next);\n  vec4 D = viewCoord(far);\n  // calculate line segment vector and angle\n  vec2 deltaCB = C.xy - B.xy;\n  if (deltaCB == vec2(0.0, 0.0)) {\n    gl_Position = vec4(2.0, 2.0, 0.0, 1.0);\n    return;\n  }\n  float angleCB = atan2(deltaCB.y, deltaCB.x * aspect);\n  // values we need to pass along\n  strokeColorVar = vec4(strokeColor, strokeOpacity);\n  // extract values from our flags field\n  int vertex = int(mod(flags, 4.0));\n  int nearMode = int(mod(floor(flags / 4.0), 8.0));\n  int farMode = int(mod(floor(flags / 32.0), 8.0));\n  // we use 11 bits of the flags for the offset, where -1023 to 1023\n  // maps to -1 to 1.  The 11 bits are a signed value, so simply\n  // selecting the bits will result in an unsigned values that may be\n  // greater than 1, in which case we have to subtract appropriately.\n  float offset = mod(floor(flags / 256.0), 2048.0) / 1023.0;\n  if (offset > 1.0)  offset -= 2048.0 / 1023.0;\n  // by default, offset by the width and don't extend lines.  Later,\n  // calculate line extensions based on end cap and end join modes\n  float yOffset = strokeWidth + antialiasing;\n  if (vertex == 0 || vertex == 2)  yOffset *= -1.0;\n  yOffset += strokeWidth * offset;\n  float xOffset = 0.0;\n  // end caps\n  if (nearMode == 0) {\n    xOffset = antialiasing;\n  } else if (nearMode == 1 || nearMode == 2) {\n    xOffset = strokeWidth + antialiasing;\n  }\n\n  // If joining lines, calculate the angles in screen space formed by\n  // the near end (A-B-C) and far end (B-C-D), and determine how much\n  // space is needed for the particular join.\n  //   This could be changed: if the lines are not a uniform width and\n  // offset, then the functional join angle is not simply half the\n  // angle between the two lines, but rather half the angle of the\n  // inside edge of the the two lines.\n  float cosABC = 1.0, sinABC = 0.0, cosBCD = 1.0, sinBCD = 0.0;  // of half angles\n  // handle near end\n  if (nearMode >= 4) {\n    float angleBA = atan2(B.y - A.y, (B.x - A.x) * aspect);\n    if (A.xy == B.xy)  angleBA = angleCB;\n    float angleABC = angleCB - angleBA;\n    // ensure angle is in the range [-PI, PI], then take the half angle\n    angleABC = (mod(angleABC + 3.0 * PI, 2.0 * PI) - PI) / 2.0;\n    cosABC = cos(angleABC);  sinABC = sin(angleABC);\n    // if this angle is close to flat, pass-through the join\n    if (nearMode >= 4 && cosABC > 0.999999) {\n      nearMode = 3;\n    }\n    // miter, miter-clip\n    if (nearMode == 4 || nearMode == 7) {\n      if (cosABC < 0.000001 || 1.0 / cosABC > miterLimit) {\n        if (nearMode == 4) {\n          nearMode = 5;\n        } else {\n          xOffset = miterLimit * strokeWidth * (1.0 - offset * sign(sinABC)) + antialiasing;\n        }\n      } else {\n        // we add an extra 1.0 to the xOffset to make sure that fragment\n        // shader is doing the clipping\n        xOffset = abs(sinABC / cosABC) * strokeWidth * (1.0 - offset * sign(sinABC)) + antialiasing + 1.0;\n        nearMode = 4;\n      }\n    }\n    // bevel or round join\n    if (nearMode == 5 || nearMode == 6) {\n      xOffset = strokeWidth * (1.0 - offset * sign(sinABC)) + antialiasing;\n    }\n  }\n\n  // handle far end\n  if (farMode >= 4) {\n    float angleDC = atan2(D.y - C.y, (D.x - C.x) * aspect);\n    if (D.xy == C.xy)  angleDC = angleCB;\n    float angleBCD = angleDC - angleCB;\n    // ensure angle is in the range [-PI, PI], then take the half angle\n    angleBCD = (mod(angleBCD + 3.0 * PI, 2.0 * PI) - PI) / 2.0;\n    cosBCD = cos(angleBCD);  sinBCD = sin(angleBCD);\n    // if this angle is close to flat, pass-through the join\n    if (farMode >= 4 && cosBCD > 0.999999) {\n      farMode = 3;\n    }\n    // miter, miter-clip\n    if (farMode == 4 || farMode == 7) {\n      if (cosBCD < 0.000001 || 1.0 / cosBCD > miterLimit) {\n        if (farMode == 4)  farMode = 5;\n      } else {\n        farMode = 4;\n      }\n    }\n  }\n\n  // compute the location of a vertex to include everything that might\n  // need to be rendered\n  xOffset *= -1.0;\n  gl_Position = vec4(\n    B.x + (xOffset * cos(angleCB) - yOffset * sin(angleCB)) * pixelWidth,\n    B.y + (xOffset * sin(angleCB) + yOffset * cos(angleCB)) * pixelWidth * aspect,\n    B.z, 1.0);\n  // store other values needed to determine which pixels to plot.\n  float lineLength = length(vec2(deltaCB.x, deltaCB.y / aspect)) / pixelWidth;\n\n  if (vertex == 0 || vertex == 1) {\n    subpos = vec4(xOffset, yOffset, lineLength - xOffset, strokeWidth);\n    info = vec4(float(nearMode), float(farMode), offset, 0.0);\n    angles = vec4(cosABC, sinABC, cosBCD, sinBCD);\n  } else {\n    subpos = vec4(lineLength - xOffset, -yOffset, xOffset, strokeWidth);\n    info = vec4(float(farMode), float(nearMode), -offset, 0.0);\n    angles = vec4(cosBCD, -sinBCD, cosABC, -sinABC);\n  }\n}\n"
+module.exports = "/* lineFeature vertex shader */\n\n#ifdef GL_ES\n  precision highp float;\n#endif\nattribute vec3 pos;\nattribute vec3 prev;\nattribute vec3 next;\nattribute vec3 far;\nattribute float flags;\n\nattribute vec3 strokeColor;\nattribute float strokeOpacity;\nattribute float strokeWidth;\n\nuniform mat4 modelViewMatrix;\nuniform mat4 projectionMatrix;\nuniform float pixelWidth;\nuniform float aspect;\nuniform float miterLimit;\nuniform float antialiasing;\n\nvarying vec4 strokeColorVar;\nvarying vec4 subpos;  /* px, py, length - px, width */\nvarying vec4 info;  /* near mode, far mode, offset */\nvarying vec4 angles; /* near angle cos, sin, far angle cos, sin */\n\nconst float PI = 3.14159265358979323846264;\n\nvec4 viewCoord(vec3 c) {\n  vec4 result = projectionMatrix * modelViewMatrix * vec4(c.xyz, 1.0);\n  if (result.w != 0.0)  result = result / result.w;\n  return result;\n}\n\nfloat atan2(float y, float x) {\n  if (x > 0.0)  return atan(y / x);\n  if (x < 0.0 && y >= 0.0)  return atan(y / x) + PI;\n  if (x < 0.0)  return atan(y / x) - PI;\n  return sign(y) * 0.5 * PI;\n}\n\nvoid main(void)\n{\n  /* If any vertex has been deliberately set to a negative opacity,\n   * skip doing computations on it. */\n  if (strokeOpacity < 0.0) {\n    gl_Position = vec4(2.0, 2.0, 0.0, 1.0);\n    return;\n  }\n  /* convert coordinates.  We have four values, since we need to\n   * calculate the angles between the lines formed by prev-pos and\n   * pos-next, and between pos-next and next-far, plus know the angle\n   *   (prev)---(pos)---(next)---(far) => A---B---C---D */\n  vec4 A = viewCoord(prev);\n  vec4 B = viewCoord(pos);\n  vec4 C = viewCoord(next);\n  vec4 D = viewCoord(far);\n  // calculate line segment vector and angle\n  vec2 deltaCB = C.xy - B.xy;\n  if (deltaCB == vec2(0.0, 0.0)) {\n    gl_Position = vec4(2.0, 2.0, 0.0, 1.0);\n    return;\n  }\n  float lineLength = length(vec2(deltaCB.x, deltaCB.y / aspect)) / pixelWidth;\n  // if lines reverse upon themselves and are not nearly the same length, skip\n  // joins.  This is a heuristic; the correct method would to be to pass some\n  // sort of length of the adjacent line to the fragment renderer and adjust\n  // which fragments are rendered, but this is much more complex.\n  float abLimit = length(vec2(A.x - B.x, (A.y - B.y) / aspect)) / pixelWidth;\n  float dcLimit = length(vec2(D.x - C.x, (D.y - C.y) / aspect)) / pixelWidth;\n  if (abLimit >= lineLength - antialiasing - strokeWidth * 0.5 && abLimit <= lineLength + antialiasing + strokeWidth * 0.5) {\n    abLimit = 0.0001;\n  } else {\n    if (abLimit < lineLength)  abLimit = lineLength;\n    abLimit = (strokeWidth - antialiasing) / (abLimit + antialiasing);\n    if (abLimit < 0.0001) abLimit = 0.0001;\n    if (abLimit > 0.1) abLimit = 0.1;\n  }\n  if (dcLimit >= lineLength - antialiasing - strokeWidth * 0.5 && dcLimit <= lineLength + antialiasing + strokeWidth * 0.5) {\n    dcLimit = 0.0001;\n  } else {\n    if (dcLimit < lineLength)  dcLimit = lineLength;\n    dcLimit = (strokeWidth - antialiasing) / (dcLimit + antialiasing);\n    if (dcLimit < 0.0001) dcLimit = 0.0001;\n    if (dcLimit > 0.1) dcLimit = 0.1;\n  }\n  float angleCB = atan2(deltaCB.y, deltaCB.x * aspect);\n  // values we need to pass along\n  strokeColorVar = vec4(strokeColor, strokeOpacity);\n  // extract values from our flags field\n  int vertex = int(mod(flags, 4.0));\n  int nearMode = int(mod(floor(flags / 4.0), 8.0));\n  int farMode = int(mod(floor(flags / 32.0), 8.0));\n  // we use 11 bits of the flags for the offset, where -1023 to 1023\n  // maps to -1 to 1.  The 11 bits are a signed value, so simply\n  // selecting the bits will result in an unsigned values that may be\n  // greater than 1, in which case we have to subtract appropriately.\n  float offset = mod(floor(flags / 256.0), 2048.0) / 1023.0;\n  if (offset > 1.0)  offset -= 2048.0 / 1023.0;\n  // by default, offset by the width and don't extend lines.  Later,\n  // calculate line extensions based on end cap and end join modes\n  float yOffset = strokeWidth + antialiasing;\n  if (vertex == 0)  yOffset *= -1.0;\n  yOffset += strokeWidth * offset;\n  float xOffset = 0.0;\n  // end caps\n  if (nearMode == 0) {\n    xOffset = antialiasing;\n  } else if (nearMode == 1 || nearMode == 2) {\n    xOffset = strokeWidth + antialiasing;\n  }\n\n  // If joining lines, calculate the angles in screen space formed by\n  // the near end (A-B-C) and far end (B-C-D), and determine how much\n  // space is needed for the particular join.\n  //   This could be changed: if the lines are not a uniform width and\n  // offset, then the functional join angle is not simply half the\n  // angle between the two lines, but rather half the angle of the\n  // inside edge of the the two lines.\n  float cosABC = 1.0, sinABC = 0.0, cosBCD = 1.0, sinBCD = 0.0;  // of half angles\n  // handle near end\n  if (nearMode >= 4) {\n    float angleBA = atan2(B.y - A.y, (B.x - A.x) * aspect);\n    if (A.xy == B.xy)  angleBA = angleCB;\n    float angleABC = angleCB - angleBA;\n    // ensure angle is in the range [-PI, PI], then take the half angle\n    angleABC = (mod(angleABC + 3.0 * PI, 2.0 * PI) - PI) / 2.0;\n    cosABC = cos(angleABC);  sinABC = sin(angleABC);\n    // if this angle is close to flat, pass-through the join\n    if (nearMode >= 4 && (cosABC > 0.999999 || cosABC < abLimit)) {\n      nearMode = 3;\n    }\n    // miter, miter-clip\n    if (nearMode == 4 || nearMode == 7) {\n      if (cosABC < 0.000001 || 1.0 / cosABC > miterLimit) {\n        if (nearMode == 4) {\n          nearMode = 5;\n        } else {\n          xOffset = miterLimit * strokeWidth * (1.0 - offset * sign(sinABC)) + antialiasing;\n        }\n      } else {\n        // we add an extra 1.0 to the xOffset to make sure that fragment\n        // shader is doing the clipping\n        xOffset = abs(sinABC / cosABC) * strokeWidth * (1.0 - offset * sign(sinABC)) + antialiasing + 1.0;\n        nearMode = 4;\n      }\n    }\n    // bevel or round join\n    if (nearMode == 5 || nearMode == 6) {\n      xOffset = strokeWidth * (1.0 - offset * sign(sinABC)) + antialiasing;\n    }\n  }\n\n  // handle far end\n  if (farMode >= 4) {\n    float angleDC = atan2(D.y - C.y, (D.x - C.x) * aspect);\n    if (D.xy == C.xy)  angleDC = angleCB;\n    float angleBCD = angleDC - angleCB;\n    // ensure angle is in the range [-PI, PI], then take the half angle\n    angleBCD = (mod(angleBCD + 3.0 * PI, 2.0 * PI) - PI) / 2.0;\n    cosBCD = cos(angleBCD);  sinBCD = sin(angleBCD);\n    // if this angle is close to flat, pass-through the join\n    if (farMode >= 4 && (cosBCD > 0.999999 || cosBCD < dcLimit)) {\n      farMode = 3;\n    }\n    // miter, miter-clip\n    if (farMode == 4 || farMode == 7) {\n      if (cosBCD < 0.000001 || 1.0 / cosBCD > miterLimit) {\n        if (farMode == 4)  farMode = 5;\n      } else {\n        farMode = 4;\n      }\n    }\n  }\n\n  // compute the location of a vertex to include everything that might\n  // need to be rendered\n  xOffset *= -1.0;\n  gl_Position = vec4(\n    B.x + (xOffset * cos(angleCB) - yOffset * sin(angleCB)) * pixelWidth,\n    B.y + (xOffset * sin(angleCB) + yOffset * cos(angleCB)) * pixelWidth * aspect,\n    B.z, 1.0);\n  // store other values needed to determine which pixels to plot.\n  if (vertex == 0 || vertex == 1) {\n    subpos = vec4(xOffset, yOffset, lineLength - xOffset, strokeWidth);\n    info = vec4(float(nearMode), float(farMode), offset, 0.0);\n    angles = vec4(cosABC, sinABC, cosBCD, sinBCD);\n  } else {\n    subpos = vec4(lineLength - xOffset, -yOffset, xOffset, strokeWidth);\n    info = vec4(float(farMode), float(nearMode), -offset, 0.0);\n    angles = vec4(cosBCD, -sinBCD, cosABC, -sinABC);\n  }\n}\n"
 
 /***/ }),
 
@@ -76675,14 +76682,14 @@ function isEar(ear) {
     by = b.y,
     cy = c.y;
 
-  // triangle bbox; min & max are calculated like this for speed
-  var x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx,
-    y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy,
-    x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx,
-    y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy;
+  // triangle bbox
+  var x0 = Math.min(ax, bx, cx),
+    y0 = Math.min(ay, by, cy),
+    x1 = Math.max(ax, bx, cx),
+    y1 = Math.max(ay, by, cy);
   var p = c.next;
   while (p !== a) {
-    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
     p = p.next;
   }
   return true;
@@ -76700,11 +76707,11 @@ function isEarHashed(ear, minX, minY, invSize) {
     by = b.y,
     cy = c.y;
 
-  // triangle bbox; min & max are calculated like this for speed
-  var x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx,
-    y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy,
-    x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx,
-    y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy;
+  // triangle bbox
+  var x0 = Math.min(ax, bx, cx),
+    y0 = Math.min(ay, by, cy),
+    x1 = Math.max(ax, bx, cx),
+    y1 = Math.max(ay, by, cy);
 
   // z-order range for the current triangle bbox;
   var minZ = zOrder(x0, y0, minX, minY, invSize),
@@ -76714,21 +76721,21 @@ function isEarHashed(ear, minX, minY, invSize) {
 
   // look for points inside the triangle in both directions
   while (p && p.z >= minZ && n && n.z <= maxZ) {
-    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
     p = p.prevZ;
-    if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
+    if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
     n = n.nextZ;
   }
 
   // look for remaining points in decreasing z-order
   while (p && p.z >= minZ) {
-    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
     p = p.prevZ;
   }
 
   // look for remaining points in increasing z-order
   while (n && n.z <= maxZ) {
-    if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
+    if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
     n = n.nextZ;
   }
   return true;
@@ -76789,7 +76796,7 @@ function eliminateHoles(data, holeIndices, outerNode, dim) {
     if (list === list.next) list.steiner = true;
     queue.push(getLeftmost(list));
   }
-  queue.sort(compareX);
+  queue.sort(compareXYSlope);
 
   // process holes from left to right
   for (var _i2 = 0; _i2 < queue.length; _i2++) {
@@ -76797,8 +76804,19 @@ function eliminateHoles(data, holeIndices, outerNode, dim) {
   }
   return outerNode;
 }
-function compareX(a, b) {
-  return a.x - b.x;
+function compareXYSlope(a, b) {
+  var result = a.x - b.x;
+  // when the left-most point of 2 holes meet at a vertex, sort the holes counterclockwise so that when we find
+  // the bridge to the outer shell is always the point that they meet at.
+  if (result === 0) {
+    result = a.y - b.y;
+    if (result === 0) {
+      var aSlope = (a.next.y - a.y) / (a.next.x - a.x);
+      var bSlope = (b.next.y - b.y) / (b.next.x - b.x);
+      result = aSlope - bSlope;
+    }
+  }
+  return result;
 }
 
 // find a bridge between vertices that connects hole with an outer ring and and link it
@@ -76824,8 +76842,10 @@ function findHoleBridge(hole, outerNode) {
 
   // 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
+  // unless they intersect at a vertex, then choose the vertex
+  if (equals(hole, p)) return p;
   do {
-    if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
+    if (equals(hole, p.next)) return p.next;else if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
       var x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
       if (x <= hx && x > qx) {
         qx = x;
@@ -76954,6 +76974,11 @@ function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
   return (cx - px) * (ay - py) >= (ax - px) * (cy - py) && (ax - px) * (by - py) >= (bx - px) * (ay - py) && (bx - px) * (cy - py) >= (cx - px) * (by - py);
 }
 
+// check if a point lies within a convex triangle but false if its equal to the first point of the triangle
+function pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, px, py) {
+  return !(ax === px && ay === py) && pointInTriangle(ax, ay, bx, by, cx, cy, px, py);
+}
+
 // check if a diagonal between two polygon nodes is valid (lies in polygon interior)
 function isValidDiagonal(a, b) {
   return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && (

package/geo.lean.js

@@ -23744,6 +23744,11 @@ var _quadFeature = function quadFeature(arg) {
             coordbasis.y = 1 - coordbasis.y;
           }
           if (coordbasis) {
+            if (quad.crop && quad.crop.x !== undefined && quad.crop.y !== undefined && (coordbasis.x >= quad.crop.x || coordbasis.y >= quad.crop.y)) {
+              indices.pop();
+              found.pop();
+              return;
+            }
             extra[quad.idx] = {
               basis: coordbasis,
               _quad: quad
@@ -25163,7 +25168,7 @@ module.exports = _sceneObject;
  * @constant
  * @type {string}
  */
-module.exports = "43f61353e44a71f669a4f0d631f102a517605fe9";
+module.exports = "8e2a6bf94ba85a370a33f2144165d89dd6061439";
 
 /***/ }),
 
@@ -29854,6 +29859,8 @@ var _trackFeature = function trackFeature(arg) {
           highidx = testidx;
         }
       }
+      // todo: if we want non-linear travel between points, we would adjust
+      // fl and fh here
       var fh = (time - lowt) / (hight - lowt),
         fl = 1 - fh;
       return {
@@ -37048,7 +37055,7 @@ module.exports = _vectorFeature;
  * @constant
  * @type {string}
  */
-module.exports = "1.14.0";
+module.exports = "1.14.2";
 
 /***/ }),
 
@@ -72966,7 +72973,7 @@ module.exports = "/* lineFeature fragment shader */\n\n#ifdef GL_ES\n  #ifdef GL
 /***/ 9336:
 /***/ (function(module) {
 
-module.exports = "/* lineFeature vertex shader */\n\n#ifdef GL_ES\n  precision highp float;\n#endif\nattribute vec3 pos;\nattribute vec3 prev;\nattribute vec3 next;\nattribute vec3 far;\nattribute float flags;\n\nattribute vec3 strokeColor;\nattribute float strokeOpacity;\nattribute float strokeWidth;\n\nuniform mat4 modelViewMatrix;\nuniform mat4 projectionMatrix;\nuniform float pixelWidth;\nuniform float aspect;\nuniform float miterLimit;\nuniform float antialiasing;\n\nvarying vec4 strokeColorVar;\nvarying vec4 subpos;  /* px, py, length - px, width */\nvarying vec4 info;  /* near mode, far mode, offset */\nvarying vec4 angles; /* near angle cos, sin, far angle cos, sin */\n\nconst float PI = 3.14159265358979323846264;\n\nvec4 viewCoord(vec3 c) {\n  vec4 result = projectionMatrix * modelViewMatrix * vec4(c.xyz, 1.0);\n  if (result.w != 0.0)  result = result / result.w;\n  return result;\n}\n\nfloat atan2(float y, float x) {\n  if (x > 0.0)  return atan(y / x);\n  if (x < 0.0 && y >= 0.0)  return atan(y / x) + PI;\n  if (x < 0.0)  return atan(y / x) - PI;\n  return sign(y) * 0.5 * PI;\n}\n\nvoid main(void)\n{\n  /* If any vertex has been deliberately set to a negative opacity,\n   * skip doing computations on it. */\n  if (strokeOpacity < 0.0) {\n    gl_Position = vec4(2.0, 2.0, 0.0, 1.0);\n    return;\n  }\n  /* convert coordinates.  We have four values, since we need to\n   * calculate the angles between the lines formed by prev-pos and\n   * pos-next, and between pos-next and next-far, plus know the angle\n   *   (prev)---(pos)---(next)---(far) => A---B---C---D */\n  vec4 A = viewCoord(prev);\n  vec4 B = viewCoord(pos);\n  vec4 C = viewCoord(next);\n  vec4 D = viewCoord(far);\n  // calculate line segment vector and angle\n  vec2 deltaCB = C.xy - B.xy;\n  if (deltaCB == vec2(0.0, 0.0)) {\n    gl_Position = vec4(2.0, 2.0, 0.0, 1.0);\n    return;\n  }\n  float angleCB = atan2(deltaCB.y, deltaCB.x * aspect);\n  // values we need to pass along\n  strokeColorVar = vec4(strokeColor, strokeOpacity);\n  // extract values from our flags field\n  int vertex = int(mod(flags, 4.0));\n  int nearMode = int(mod(floor(flags / 4.0), 8.0));\n  int farMode = int(mod(floor(flags / 32.0), 8.0));\n  // we use 11 bits of the flags for the offset, where -1023 to 1023\n  // maps to -1 to 1.  The 11 bits are a signed value, so simply\n  // selecting the bits will result in an unsigned values that may be\n  // greater than 1, in which case we have to subtract appropriately.\n  float offset = mod(floor(flags / 256.0), 2048.0) / 1023.0;\n  if (offset > 1.0)  offset -= 2048.0 / 1023.0;\n  // by default, offset by the width and don't extend lines.  Later,\n  // calculate line extensions based on end cap and end join modes\n  float yOffset = strokeWidth + antialiasing;\n  if (vertex == 0 || vertex == 2)  yOffset *= -1.0;\n  yOffset += strokeWidth * offset;\n  float xOffset = 0.0;\n  // end caps\n  if (nearMode == 0) {\n    xOffset = antialiasing;\n  } else if (nearMode == 1 || nearMode == 2) {\n    xOffset = strokeWidth + antialiasing;\n  }\n\n  // If joining lines, calculate the angles in screen space formed by\n  // the near end (A-B-C) and far end (B-C-D), and determine how much\n  // space is needed for the particular join.\n  //   This could be changed: if the lines are not a uniform width and\n  // offset, then the functional join angle is not simply half the\n  // angle between the two lines, but rather half the angle of the\n  // inside edge of the the two lines.\n  float cosABC = 1.0, sinABC = 0.0, cosBCD = 1.0, sinBCD = 0.0;  // of half angles\n  // handle near end\n  if (nearMode >= 4) {\n    float angleBA = atan2(B.y - A.y, (B.x - A.x) * aspect);\n    if (A.xy == B.xy)  angleBA = angleCB;\n    float angleABC = angleCB - angleBA;\n    // ensure angle is in the range [-PI, PI], then take the half angle\n    angleABC = (mod(angleABC + 3.0 * PI, 2.0 * PI) - PI) / 2.0;\n    cosABC = cos(angleABC);  sinABC = sin(angleABC);\n    // if this angle is close to flat, pass-through the join\n    if (nearMode >= 4 && cosABC > 0.999999) {\n      nearMode = 3;\n    }\n    // miter, miter-clip\n    if (nearMode == 4 || nearMode == 7) {\n      if (cosABC < 0.000001 || 1.0 / cosABC > miterLimit) {\n        if (nearMode == 4) {\n          nearMode = 5;\n        } else {\n          xOffset = miterLimit * strokeWidth * (1.0 - offset * sign(sinABC)) + antialiasing;\n        }\n      } else {\n        // we add an extra 1.0 to the xOffset to make sure that fragment\n        // shader is doing the clipping\n        xOffset = abs(sinABC / cosABC) * strokeWidth * (1.0 - offset * sign(sinABC)) + antialiasing + 1.0;\n        nearMode = 4;\n      }\n    }\n    // bevel or round join\n    if (nearMode == 5 || nearMode == 6) {\n      xOffset = strokeWidth * (1.0 - offset * sign(sinABC)) + antialiasing;\n    }\n  }\n\n  // handle far end\n  if (farMode >= 4) {\n    float angleDC = atan2(D.y - C.y, (D.x - C.x) * aspect);\n    if (D.xy == C.xy)  angleDC = angleCB;\n    float angleBCD = angleDC - angleCB;\n    // ensure angle is in the range [-PI, PI], then take the half angle\n    angleBCD = (mod(angleBCD + 3.0 * PI, 2.0 * PI) - PI) / 2.0;\n    cosBCD = cos(angleBCD);  sinBCD = sin(angleBCD);\n    // if this angle is close to flat, pass-through the join\n    if (farMode >= 4 && cosBCD > 0.999999) {\n      farMode = 3;\n    }\n    // miter, miter-clip\n    if (farMode == 4 || farMode == 7) {\n      if (cosBCD < 0.000001 || 1.0 / cosBCD > miterLimit) {\n        if (farMode == 4)  farMode = 5;\n      } else {\n        farMode = 4;\n      }\n    }\n  }\n\n  // compute the location of a vertex to include everything that might\n  // need to be rendered\n  xOffset *= -1.0;\n  gl_Position = vec4(\n    B.x + (xOffset * cos(angleCB) - yOffset * sin(angleCB)) * pixelWidth,\n    B.y + (xOffset * sin(angleCB) + yOffset * cos(angleCB)) * pixelWidth * aspect,\n    B.z, 1.0);\n  // store other values needed to determine which pixels to plot.\n  float lineLength = length(vec2(deltaCB.x, deltaCB.y / aspect)) / pixelWidth;\n\n  if (vertex == 0 || vertex == 1) {\n    subpos = vec4(xOffset, yOffset, lineLength - xOffset, strokeWidth);\n    info = vec4(float(nearMode), float(farMode), offset, 0.0);\n    angles = vec4(cosABC, sinABC, cosBCD, sinBCD);\n  } else {\n    subpos = vec4(lineLength - xOffset, -yOffset, xOffset, strokeWidth);\n    info = vec4(float(farMode), float(nearMode), -offset, 0.0);\n    angles = vec4(cosBCD, -sinBCD, cosABC, -sinABC);\n  }\n}\n"
+module.exports = "/* lineFeature vertex shader */\n\n#ifdef GL_ES\n  precision highp float;\n#endif\nattribute vec3 pos;\nattribute vec3 prev;\nattribute vec3 next;\nattribute vec3 far;\nattribute float flags;\n\nattribute vec3 strokeColor;\nattribute float strokeOpacity;\nattribute float strokeWidth;\n\nuniform mat4 modelViewMatrix;\nuniform mat4 projectionMatrix;\nuniform float pixelWidth;\nuniform float aspect;\nuniform float miterLimit;\nuniform float antialiasing;\n\nvarying vec4 strokeColorVar;\nvarying vec4 subpos;  /* px, py, length - px, width */\nvarying vec4 info;  /* near mode, far mode, offset */\nvarying vec4 angles; /* near angle cos, sin, far angle cos, sin */\n\nconst float PI = 3.14159265358979323846264;\n\nvec4 viewCoord(vec3 c) {\n  vec4 result = projectionMatrix * modelViewMatrix * vec4(c.xyz, 1.0);\n  if (result.w != 0.0)  result = result / result.w;\n  return result;\n}\n\nfloat atan2(float y, float x) {\n  if (x > 0.0)  return atan(y / x);\n  if (x < 0.0 && y >= 0.0)  return atan(y / x) + PI;\n  if (x < 0.0)  return atan(y / x) - PI;\n  return sign(y) * 0.5 * PI;\n}\n\nvoid main(void)\n{\n  /* If any vertex has been deliberately set to a negative opacity,\n   * skip doing computations on it. */\n  if (strokeOpacity < 0.0) {\n    gl_Position = vec4(2.0, 2.0, 0.0, 1.0);\n    return;\n  }\n  /* convert coordinates.  We have four values, since we need to\n   * calculate the angles between the lines formed by prev-pos and\n   * pos-next, and between pos-next and next-far, plus know the angle\n   *   (prev)---(pos)---(next)---(far) => A---B---C---D */\n  vec4 A = viewCoord(prev);\n  vec4 B = viewCoord(pos);\n  vec4 C = viewCoord(next);\n  vec4 D = viewCoord(far);\n  // calculate line segment vector and angle\n  vec2 deltaCB = C.xy - B.xy;\n  if (deltaCB == vec2(0.0, 0.0)) {\n    gl_Position = vec4(2.0, 2.0, 0.0, 1.0);\n    return;\n  }\n  float lineLength = length(vec2(deltaCB.x, deltaCB.y / aspect)) / pixelWidth;\n  // if lines reverse upon themselves and are not nearly the same length, skip\n  // joins.  This is a heuristic; the correct method would to be to pass some\n  // sort of length of the adjacent line to the fragment renderer and adjust\n  // which fragments are rendered, but this is much more complex.\n  float abLimit = length(vec2(A.x - B.x, (A.y - B.y) / aspect)) / pixelWidth;\n  float dcLimit = length(vec2(D.x - C.x, (D.y - C.y) / aspect)) / pixelWidth;\n  if (abLimit >= lineLength - antialiasing - strokeWidth * 0.5 && abLimit <= lineLength + antialiasing + strokeWidth * 0.5) {\n    abLimit = 0.0001;\n  } else {\n    if (abLimit < lineLength)  abLimit = lineLength;\n    abLimit = (strokeWidth - antialiasing) / (abLimit + antialiasing);\n    if (abLimit < 0.0001) abLimit = 0.0001;\n    if (abLimit > 0.1) abLimit = 0.1;\n  }\n  if (dcLimit >= lineLength - antialiasing - strokeWidth * 0.5 && dcLimit <= lineLength + antialiasing + strokeWidth * 0.5) {\n    dcLimit = 0.0001;\n  } else {\n    if (dcLimit < lineLength)  dcLimit = lineLength;\n    dcLimit = (strokeWidth - antialiasing) / (dcLimit + antialiasing);\n    if (dcLimit < 0.0001) dcLimit = 0.0001;\n    if (dcLimit > 0.1) dcLimit = 0.1;\n  }\n  float angleCB = atan2(deltaCB.y, deltaCB.x * aspect);\n  // values we need to pass along\n  strokeColorVar = vec4(strokeColor, strokeOpacity);\n  // extract values from our flags field\n  int vertex = int(mod(flags, 4.0));\n  int nearMode = int(mod(floor(flags / 4.0), 8.0));\n  int farMode = int(mod(floor(flags / 32.0), 8.0));\n  // we use 11 bits of the flags for the offset, where -1023 to 1023\n  // maps to -1 to 1.  The 11 bits are a signed value, so simply\n  // selecting the bits will result in an unsigned values that may be\n  // greater than 1, in which case we have to subtract appropriately.\n  float offset = mod(floor(flags / 256.0), 2048.0) / 1023.0;\n  if (offset > 1.0)  offset -= 2048.0 / 1023.0;\n  // by default, offset by the width and don't extend lines.  Later,\n  // calculate line extensions based on end cap and end join modes\n  float yOffset = strokeWidth + antialiasing;\n  if (vertex == 0)  yOffset *= -1.0;\n  yOffset += strokeWidth * offset;\n  float xOffset = 0.0;\n  // end caps\n  if (nearMode == 0) {\n    xOffset = antialiasing;\n  } else if (nearMode == 1 || nearMode == 2) {\n    xOffset = strokeWidth + antialiasing;\n  }\n\n  // If joining lines, calculate the angles in screen space formed by\n  // the near end (A-B-C) and far end (B-C-D), and determine how much\n  // space is needed for the particular join.\n  //   This could be changed: if the lines are not a uniform width and\n  // offset, then the functional join angle is not simply half the\n  // angle between the two lines, but rather half the angle of the\n  // inside edge of the the two lines.\n  float cosABC = 1.0, sinABC = 0.0, cosBCD = 1.0, sinBCD = 0.0;  // of half angles\n  // handle near end\n  if (nearMode >= 4) {\n    float angleBA = atan2(B.y - A.y, (B.x - A.x) * aspect);\n    if (A.xy == B.xy)  angleBA = angleCB;\n    float angleABC = angleCB - angleBA;\n    // ensure angle is in the range [-PI, PI], then take the half angle\n    angleABC = (mod(angleABC + 3.0 * PI, 2.0 * PI) - PI) / 2.0;\n    cosABC = cos(angleABC);  sinABC = sin(angleABC);\n    // if this angle is close to flat, pass-through the join\n    if (nearMode >= 4 && (cosABC > 0.999999 || cosABC < abLimit)) {\n      nearMode = 3;\n    }\n    // miter, miter-clip\n    if (nearMode == 4 || nearMode == 7) {\n      if (cosABC < 0.000001 || 1.0 / cosABC > miterLimit) {\n        if (nearMode == 4) {\n          nearMode = 5;\n        } else {\n          xOffset = miterLimit * strokeWidth * (1.0 - offset * sign(sinABC)) + antialiasing;\n        }\n      } else {\n        // we add an extra 1.0 to the xOffset to make sure that fragment\n        // shader is doing the clipping\n        xOffset = abs(sinABC / cosABC) * strokeWidth * (1.0 - offset * sign(sinABC)) + antialiasing + 1.0;\n        nearMode = 4;\n      }\n    }\n    // bevel or round join\n    if (nearMode == 5 || nearMode == 6) {\n      xOffset = strokeWidth * (1.0 - offset * sign(sinABC)) + antialiasing;\n    }\n  }\n\n  // handle far end\n  if (farMode >= 4) {\n    float angleDC = atan2(D.y - C.y, (D.x - C.x) * aspect);\n    if (D.xy == C.xy)  angleDC = angleCB;\n    float angleBCD = angleDC - angleCB;\n    // ensure angle is in the range [-PI, PI], then take the half angle\n    angleBCD = (mod(angleBCD + 3.0 * PI, 2.0 * PI) - PI) / 2.0;\n    cosBCD = cos(angleBCD);  sinBCD = sin(angleBCD);\n    // if this angle is close to flat, pass-through the join\n    if (farMode >= 4 && (cosBCD > 0.999999 || cosBCD < dcLimit)) {\n      farMode = 3;\n    }\n    // miter, miter-clip\n    if (farMode == 4 || farMode == 7) {\n      if (cosBCD < 0.000001 || 1.0 / cosBCD > miterLimit) {\n        if (farMode == 4)  farMode = 5;\n      } else {\n        farMode = 4;\n      }\n    }\n  }\n\n  // compute the location of a vertex to include everything that might\n  // need to be rendered\n  xOffset *= -1.0;\n  gl_Position = vec4(\n    B.x + (xOffset * cos(angleCB) - yOffset * sin(angleCB)) * pixelWidth,\n    B.y + (xOffset * sin(angleCB) + yOffset * cos(angleCB)) * pixelWidth * aspect,\n    B.z, 1.0);\n  // store other values needed to determine which pixels to plot.\n  if (vertex == 0 || vertex == 1) {\n    subpos = vec4(xOffset, yOffset, lineLength - xOffset, strokeWidth);\n    info = vec4(float(nearMode), float(farMode), offset, 0.0);\n    angles = vec4(cosABC, sinABC, cosBCD, sinBCD);\n  } else {\n    subpos = vec4(lineLength - xOffset, -yOffset, xOffset, strokeWidth);\n    info = vec4(float(farMode), float(nearMode), -offset, 0.0);\n    angles = vec4(cosBCD, -sinBCD, cosABC, -sinABC);\n  }\n}\n"
 
 /***/ }),
 
@@ -73694,14 +73701,14 @@ function isEar(ear) {
     by = b.y,
     cy = c.y;
 
-  // triangle bbox; min & max are calculated like this for speed
-  var x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx,
-    y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy,
-    x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx,
-    y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy;
+  // triangle bbox
+  var x0 = Math.min(ax, bx, cx),
+    y0 = Math.min(ay, by, cy),
+    x1 = Math.max(ax, bx, cx),
+    y1 = Math.max(ay, by, cy);
   var p = c.next;
   while (p !== a) {
-    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
     p = p.next;
   }
   return true;
@@ -73719,11 +73726,11 @@ function isEarHashed(ear, minX, minY, invSize) {
     by = b.y,
     cy = c.y;
 
-  // triangle bbox; min & max are calculated like this for speed
-  var x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx,
-    y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy,
-    x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx,
-    y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy;
+  // triangle bbox
+  var x0 = Math.min(ax, bx, cx),
+    y0 = Math.min(ay, by, cy),
+    x1 = Math.max(ax, bx, cx),
+    y1 = Math.max(ay, by, cy);
 
   // z-order range for the current triangle bbox;
   var minZ = zOrder(x0, y0, minX, minY, invSize),
@@ -73733,21 +73740,21 @@ function isEarHashed(ear, minX, minY, invSize) {
 
   // look for points inside the triangle in both directions
   while (p && p.z >= minZ && n && n.z <= maxZ) {
-    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
     p = p.prevZ;
-    if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
+    if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
     n = n.nextZ;
   }
 
   // look for remaining points in decreasing z-order
   while (p && p.z >= minZ) {
-    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
     p = p.prevZ;
   }
 
   // look for remaining points in increasing z-order
   while (n && n.z <= maxZ) {
-    if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
+    if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
     n = n.nextZ;
   }
   return true;
@@ -73808,7 +73815,7 @@ function eliminateHoles(data, holeIndices, outerNode, dim) {
     if (list === list.next) list.steiner = true;
     queue.push(getLeftmost(list));
   }
-  queue.sort(compareX);
+  queue.sort(compareXYSlope);
 
   // process holes from left to right
   for (var _i2 = 0; _i2 < queue.length; _i2++) {
@@ -73816,8 +73823,19 @@ function eliminateHoles(data, holeIndices, outerNode, dim) {
   }
   return outerNode;
 }
-function compareX(a, b) {
-  return a.x - b.x;
+function compareXYSlope(a, b) {
+  var result = a.x - b.x;
+  // when the left-most point of 2 holes meet at a vertex, sort the holes counterclockwise so that when we find
+  // the bridge to the outer shell is always the point that they meet at.
+  if (result === 0) {
+    result = a.y - b.y;
+    if (result === 0) {
+      var aSlope = (a.next.y - a.y) / (a.next.x - a.x);
+      var bSlope = (b.next.y - b.y) / (b.next.x - b.x);
+      result = aSlope - bSlope;
+    }
+  }
+  return result;
 }
 
 // find a bridge between vertices that connects hole with an outer ring and and link it
@@ -73843,8 +73861,10 @@ function findHoleBridge(hole, outerNode) {
 
   // 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
+  // unless they intersect at a vertex, then choose the vertex
+  if (equals(hole, p)) return p;
   do {
-    if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
+    if (equals(hole, p.next)) return p.next;else if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
       var x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
       if (x <= hx && x > qx) {
         qx = x;
@@ -73973,6 +73993,11 @@ function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
   return (cx - px) * (ay - py) >= (ax - px) * (cy - py) && (ax - px) * (by - py) >= (bx - px) * (ay - py) && (bx - px) * (cy - py) >= (cx - px) * (by - py);
 }
 
+// check if a point lies within a convex triangle but false if its equal to the first point of the triangle
+function pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, px, py) {
+  return !(ax === px && ay === py) && pointInTriangle(ax, ay, bx, by, cx, cy, px, py);
+}
+
 // check if a diagonal between two polygon nodes is valid (lies in polygon interior)
 function isValidDiagonal(a, b) {
   return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && (