mapshaper 0.6.109 → 0.6.111

package/mapshaper.js

@@ -1328,13 +1328,21 @@
 
   function verbose() {
     // verbose can be set globally with the -verbose command or separately for each command
-    if (getStashedVar('VERBOSE')) {
+    if (useVerbose()) {
       message.apply(null, arguments);
     }
   }
 
+  function useVerbose() {
+    return getStashedVar('VERBOSE');
+  }
+
+  function useDebug() {
+    return getStashedVar('DEBUG');
+  }
+
   function debug() {
-    if (getStashedVar('DEBUG')) {
+    if (useDebug()) {
       logArgs(arguments);
     }
   }
@@ -1458,6 +1466,8 @@
     setLoggingFunctions: setLoggingFunctions,
     stop: stop,
     truncateString: truncateString,
+    useDebug: useDebug,
+    useVerbose: useVerbose,
     verbose: verbose,
     warn: warn
   });
@@ -2265,44 +2275,6 @@
     return dist * R$1;
   }
 
-  // TODO: make this safe for small angles
-  function innerAngle(ax, ay, bx, by, cx, cy) {
-    var ab = distance2D(ax, ay, bx, by),
-        bc = distance2D(bx, by, cx, cy),
-        theta, dotp;
-    if (ab === 0 || bc === 0) {
-      theta = 0;
-    } else {
-      dotp = ((ax - bx) * (cx - bx) + (ay - by) * (cy - by)) / (ab * bc);
-      if (dotp >= 1 - 1e-14) {
-        theta = 0;
-      } else if (dotp <= -1 + 1e-14) {
-        theta = Math.PI;
-      } else {
-        theta = Math.acos(dotp); // consider using other formula at small dp
-      }
-    }
-    return theta;
-  }
-
-  function innerAngle3D(ax, ay, az, bx, by, bz, cx, cy, cz) {
-    var ab = distance3D(ax, ay, az, bx, by, bz),
-        bc = distance3D(bx, by, bz, cx, cy, cz),
-        theta, dotp;
-    if (ab === 0 || bc === 0) {
-      theta = 0;
-    } else {
-      dotp = ((ax - bx) * (cx - bx) + (ay - by) * (cy - by) + (az - bz) * (cz - bz)) / (ab * bc);
-      if (dotp >= 1) {
-        theta = 0;
-      } else if (dotp <= -1) {
-        theta = Math.PI;
-      } else {
-        theta = Math.acos(dotp); // consider using other formula at small dp
-      }
-    }
-    return theta;
-  }
 
   function triangleArea(ax, ay, bx, by, cx, cy) {
     var area = Math.abs(((ay - cy) * (bx - cx) + (by - cy) * (cx - ax)) / 2);
@@ -2391,36 +2363,10 @@
     return distanceSq(px, py, ax + t * (bx - ax), ay + t * (by - ay));
   }
 
-
-  // internal.reversePathCoords = function(arr, start, len) {
-  //   var i = start,
-  //       j = start + len - 1,
-  //       tmp;
-  //   while (i < j) {
-  //     tmp = arr[i];
-  //     arr[i] = arr[j];
-  //     arr[j] = tmp;
-  //     i++;
-  //     j--;
-  //   }
-  // };
-
-  // merge B into A
-  // function mergeBounds(a, b) {
-  //   if (b[0] < a[0]) a[0] = b[0];
-  //   if (b[1] < a[1]) a[1] = b[1];
-  //   if (b[2] > a[2]) a[2] = b[2];
-  //   if (b[3] > a[3]) a[3] = b[3];
-  // }
-
   function containsBounds(a, b) {
     return a[0] <= b[0] && a[2] >= b[2] && a[1] <= b[1] && a[3] >= b[3];
   }
 
-  // function boundsArea(b) {
-  //   return (b[2] - b[0]) * (b[3] - b[1]);
-  // }
-
   var Geom = /*#__PURE__*/Object.freeze({
     __proto__: null,
     D2R: D2R,
@@ -2438,9 +2384,7 @@
     distanceSq: distanceSq,
     distanceSq3D: distanceSq3D,
     greatCircleDistance: greatCircleDistance,
-    innerAngle: innerAngle,
     innerAngle2: innerAngle2,
-    innerAngle3D: innerAngle3D,
     lngLatToXYZ: lngLatToXYZ,
     pointSegDistSq: pointSegDistSq,
     pointSegDistSq2: pointSegDistSq2,
@@ -2962,7 +2906,22 @@
   // @coords: Array of relevant coordinates (e.g. bbox coordinates of vertex coordinates
   //   of two intersecting segments).
   //
+
+  // Updated the original function with a smaller interval... which works
+  // better on a (limited) set of real-world sample data
+  // (less likely to create erroneous output)
   function getHighPrecisionSnapInterval(coords) {
+    var n = Math.max.apply(null, coords.map(Math.abs));
+    var ceil = n <= 1 ? 1 : 2 ** Math.ceil(Math.log2(n));
+    // console.log(ceil < ceil + ceil / 2 ** 51) // true
+    // console.log(ceil < ceil + ceil / 2 ** 52) // true
+    // console.log(ceil < ceil + ceil / 2 ** 53) // false
+    var interval = ceil / 2 ** 51;
+    // console.log('interval:', interval)
+    return interval;
+  }
+
+  function getHighPrecisionSnapInterval_old(coords) {
     var maxCoord = Math.max.apply(null, coords.map(Math.abs));
     return maxCoord * 1e-14;
   }
@@ -3148,11 +3107,77 @@
     getCoordinateIds: getCoordinateIds,
     getEndpointIds: getEndpointIds,
     getHighPrecisionSnapInterval: getHighPrecisionSnapInterval,
+    getHighPrecisionSnapInterval_old: getHighPrecisionSnapInterval_old,
     snapCoords: snapCoords,
     snapCoordsByInterval: snapCoordsByInterval,
     snapEndpointsByInterval: snapEndpointsByInterval
   });
 
+  function toScaledStr(num, k) {
+    var abs = Math.abs(num);
+    var signed = num != abs;
+    // String() matches behavior of big.js
+    // (as opposed to toFixed() or toPrecision())
+    var s = abs < 1e-6 ? abs.toFixed(k) : String(abs);
+    var parts = s.split('.');
+    var integer = parts[0] == '0' ? '' : parts[0];
+    var decimal = parts.length == 2 ? parts[1] : '';
+    if (decimal.length < k) {
+      decimal = decimal.padEnd(k, '0');
+    } else if (decimal.length > k) {
+      decimal = decimal.slice(0, k);
+    }
+    var s2 = integer + decimal;
+    // remove any leading 0s
+    while (s2[0] == 0 && s2.length > 1) {
+      s2 = s2.slice(1);
+    }
+    if (signed) {
+      s2 = '-' + s2;
+    }
+    return s2;
+  }
+
+  // returns Number
+  function fromScaledStr(s, decimals) {
+    var signed = s[0] == '-';
+    var uns = signed ? s.slice(1) : s;
+    var s2, len;
+    len = uns.length;
+    if (len > decimals) {
+      s2 = uns.slice(0, len - decimals) + '.' + uns.slice(-decimals);
+    } else if (len == decimals) {
+      s2 = '0.' + uns;
+    } else {
+      s2 = '0.' + uns.padStart(decimals, '0');
+    }
+    if (signed) {
+      s2 = '-' + s2;
+    }
+    return Number(s2);
+  }
+
+  function findBigIntScaleFactor() {
+    var minVal = Infinity;
+    var intLen = 0, s;
+    for (var i=0, n=arguments.length; i<n; i++) {
+      minVal = Math.min(minVal, Math.abs(arguments[i]));
+    }
+    if (minVal >= 1) {
+      s = minVal.toFixed(1);
+      intLen = s.indexOf('.');
+    } else if (minVal !== 0) {
+      s = minVal.toFixed(10).slice(2); // decimal part, up to _ decimals
+      while (s[0] === '0') {
+        intLen--;
+        s = s.slice(1);
+      }
+    }
+    return 17 - intLen;
+  }
+
+  //import { findCrossIntersection_big } from '../geom/mapshaper-segment-geom-big';
+
   // Find the intersection between two 2D segments
   // Returns 0, 1 or 2 [x, y] locations as null, [x, y], or [x1, y1, x2, y2]
   // Special cases:
@@ -3164,43 +3189,59 @@
   function segmentIntersection(ax, ay, bx, by, cx, cy, dx, dy, epsArg) {
     // Use a small tolerance interval, so collinear segments and T-intersections
     // are detected (floating point rounding often causes exact functions to fail)
-    var eps = epsArg >= 0 ? epsArg :
+    var eps = epsArg > 0 ? epsArg :
         getHighPrecisionSnapInterval([ax, ay, bx, by, cx, cy, dx, dy]);
     var epsSq = eps * eps;
     var touches, cross;
+
     // Detect 0, 1 or 2 'touch' intersections, where a vertex of one segment
     // is very close to the other segment's linear portion.
     // One touch indicates either a T-intersection or two overlapping collinear
     // segments that share an endpoint. Two touches indicates overlapping
     // collinear segments that do not share an endpoint.
     touches = findPointSegTouches(epsSq, ax, ay, bx, by, cx, cy, dx, dy);
-    // if (touches) return touches;
     // Ignore endpoint-only intersections
     if (!touches && testEndpointHit(epsSq, ax, ay, bx, by, cx, cy, dx, dy)) {
       return null;
     }
     // Detect cross intersection
-    cross = findCrossIntersection(ax, ay, bx, by, cx, cy, dx, dy, eps);
+    // (TODO: consider cross intersections that are also endpoint hits)
+    if (!touches) {
+      cross = findCrossIntersection(ax, ay, bx, by, cx, cy, dx, dy, eps);
+    }
     return touches || cross || null;
   }
 
-
-  // Find the intersection point of two segments that cross each other,
-  // or return null if the segments do not cross.
-  // Assumes endpoint intersections have already been detected
   function findCrossIntersection(ax, ay, bx, by, cx, cy, dx, dy, eps) {
-    if (!segmentHit(ax, ay, bx, by, cx, cy, dx, dy)) return null;
-    var den = determinant2D(bx - ax, by - ay, dx - cx, dy - cy);
-    var m = orient2D(cx, cy, dx, dy, ax, ay) / den;
-    var p = [ax + m * (bx - ax), ay + m * (by - ay)];
-    if (Math.abs(den) < 1e-25) {
-      // changed from 1e-18 to 1e-25 (see geom ex1)
-      // assume that collinear and near-collinear segment intersections have been
-      // accounted for already.
-      // TODO: is this a valid assumption?
+    var p;
+    // The normal-precision hit function works for all inputs when eps > 0 because
+    // the geometries that cause the ordinary function fails are detected as
+    // 'touches' or endpoint hits (at least this was true in all the real-world
+    // data samples that were tested).
+    //
+    if (eps > 0 && !segmentHit_fast(ax, ay, bx, by, cx, cy, dx, dy)) {
+      return null;
+    } else if (eps === 0 && !segmentHit_robust(ax, ay, bx, by, cx, cy, dx, dy)) {
       return null;
     }
 
+    // in a typical layer with many intersections along shared polygon boundaries,
+    // robust is preferred in most (>90%) segment intersections in order to keep
+    // the positional error within a small interval (e.g. 50% of eps)
+    //
+    if (useRobustCross(ax, ay, bx, by, cx, cy, dx, dy)) {
+      p = findCrossIntersection_robust(ax, ay, bx, by, cx, cy, dx, dy);
+      // var p2 = findCrossIntersection_big(ax, ay, bx, by, cx, cy, dx, dy);
+      // var dx = p[0] - p2[0];
+      // var dy = p[1] - p2[1];
+      // if (dx != 0 || dy != 0) {
+      //   console.log(dx, dy)
+      // }
+    } else {
+      p = findCrossIntersection_fast(ax, ay, bx, by, cx, cy, dx, dy);
+    }
+    if (!p) return null;
+
     // Snap p to a vertex if very close to one
     // This avoids tiny segments caused by T-intersection overshoots and prevents
     //   pathfinder errors related to f-p rounding.
@@ -3215,9 +3256,90 @@
     return p;
   }
 
+  function findCrossIntersection_fast(ax, ay, bx, by, cx, cy, dx, dy) {
+    var den = determinant2D(bx - ax, by - ay, dx - cx, dy - cy);
+    var m = orient2D(cx, cy, dx, dy, ax, ay) / den;
+    var p = [ax + m * (bx - ax), ay + m * (by - ay)];
+    if (Math.abs(den) < 1e-25) {
+      // changed from 1e-18 to 1e-25 (see geom ex1)
+      // assume that collinear and near-collinear segment intersections have been
+      // accounted for already.
+      // TODO: is this really true?
+      return null;
+    }
+    return p;
+  }
+
+  // this function, using BigInt, is 3-4x faster than the version using big.js
+  function findCrossIntersection_robust(ax, ay, bx, by, cx, cy, dx, dy) {
+    var d = findBigIntScaleFactor(ax, ay, bx, by, cx, cy, dx, dy);
+    var d2 = 16; // scale numerator of integer division by this many decimal digits
+    var k_bi = 10000000000000000n; // matches d2
+    var ax_bi = BigInt(toScaledStr(ax, d));
+    var ay_bi = BigInt(toScaledStr(ay, d));
+    var bx_bi = BigInt(toScaledStr(bx, d));
+    var by_bi = BigInt(toScaledStr(by, d));
+    var cx_bi = BigInt(toScaledStr(cx, d));
+    var cy_bi = BigInt(toScaledStr(cy, d));
+    var dx_bi = BigInt(toScaledStr(dx, d));
+    var dy_bi = BigInt(toScaledStr(dy, d));
+    var den = determinant2D(bx_bi - ax_bi, by_bi - ay_bi, dx_bi - cx_bi, dy_bi - cy_bi);
+    if (den === 0n) {
+      debug('DIV0 error - should have been identified as collinear "touch" intersection.');
+      return null;
+    }
+    var num = orient2D(cx_bi, cy_bi, dx_bi, dy_bi, ax_bi, ay_bi) * k_bi;
+    var m_bi = num / den;
+    var x_bi = ax_bi * k_bi + m_bi * (bx_bi - ax_bi);
+    var y_bi = ay_bi * k_bi + m_bi * (by_bi - ay_bi);
+    var x = fromScaledStr(x_bi.toString(), d + d2);
+    var y = fromScaledStr(y_bi.toString(), d + d2);
+    return [x, y];
+  }
+
+  function useRobustCross(ax, ay, bx, by, cx, cy, dx, dy) {
+    // angle and seg length ratio thresholds were found by comparing
+    // fast and robust outputs on sample data
+    if (innerAngle(ax, ay, bx, by, cx, cy, dx, dy) < 0.1) return true;
+    var len1 = distance2D(ax, ay, bx, by);
+    var len2 = distance2D(cx, cy, dx, dy);
+    var ratio = len1 < len2 ? len1 / len2 : len2 / len1 || 0;
+    if (ratio < 0.001) return true;
+    return false;
+  }
+
+  // Returns smaller of two angles between two segments (unsigned)
+  function innerAngle(ax, ay, bx, by, cx, cy, dx, dy) {
+    var v1x = bx - ax;
+    var v1y = by - ay;
+    var v2x = dx - cx;
+    var v2y = dy - cy;
+    var dot = v1x * v2x + v1y * v2y;
+    var mag1Sq = v1x * v1x + v1y * v1y;
+    var mag2Sq = v2x * v2x + v2y * v2y;
+    if (mag1Sq === 0 || mag2Sq === 0) {
+      return 0;
+    }
+    var cosTheta = dot / Math.sqrt(mag1Sq * mag2Sq);
+    var theta;
+    if (cosTheta > 1 - 1e-14) {
+      theta = 0;
+    } else if (cosTheta < -1 + 1e-14) {
+      theta = Math.PI;
+    } else {
+      theta = Math.acos(cosTheta);
+    }
+    if (theta >= Math.PI / 2) {
+      theta = Math.PI - theta;
+    }
+    return theta;
+  }
+
   function testEndpointHit(epsSq, ax, ay, bx, by, cx, cy, dx, dy) {
-    return distanceSq(ax, ay, cx, cy) <= epsSq || distanceSq(ax, ay, dx, dy) <= epsSq ||
-      distanceSq(bx, by, cx, cy) <= epsSq || distanceSq(bx, by, dx, dy) <= epsSq;
+    return distanceSq(ax, ay, cx, cy) <= epsSq ||
+      distanceSq(ax, ay, dx, dy) <= epsSq ||
+      distanceSq(bx, by, cx, cy) <= epsSq ||
+      distanceSq(bx, by, dx, dy) <= epsSq;
   }
 
   function findPointSegTouches(epsSq, ax, ay, bx, by, cx, cy, dx, dy) {
@@ -3228,6 +3350,9 @@
     collectPointSegTouch(touches, epsSq, dx, dy, ax, ay, bx, by);
     if (touches.length === 0) return null;
     if (touches.length > 4) {
+      // console.log('XX', touches.length)
+      // console.log('Seg 1', getSegFeature(ax, ay, bx, by, true))
+      // console.log('Seg 2', getSegFeature(cx, cy, dx, dy, false))
       // Geometrically, more than two touch intersections can not occur.
       // Is it possible that fp rounding or a bug might result in >2 touches?
       debug('Intersection detection error');
@@ -3244,10 +3369,10 @@
     var pa = distanceSq(ax, ay, px, py);
     var pb = distanceSq(bx, by, px, py);
     if (pa <= epsSq || pb <= epsSq) return; // ignore endpoint hits
+    // console.log("Dist:", Math.sqrt(pab), "eps:", Math.sqrt(epsSq), "p:", px, py)
     arr.push(px, py); // T intersection at P and AB
   }
 
-
   // Used by mapshaper-undershoots.js
   // TODO: make more robust, make sure result is compatible with segmentIntersection()
   // (rounding errors currently must be handled downstream)
@@ -3296,16 +3421,43 @@
     // when a segment is vertical or horizontal. This has caused problems when
     // repeatedly applying bbox clipping along the same segment
     var x = p[0],
-        y = p[1];
+        y = p[1],
+        s1out = false,
+        s2out = false;
+
     // assumes that segment ranges intersect
-    x = clampToCloseRange(x, ax, bx);
-    x = clampToCloseRange(x, cx, dx);
-    y = clampToCloseRange(y, ay, by);
-    y = clampToCloseRange(y, cy, dy);
+    if (outsideRange(x, ax, bx)) {
+      x = clampToClosestEndpoint(x, ax, bx);
+      s1out = true;
+    }
+    if (outsideRange(x, cx, dx)) {
+      x = clampToClosestEndpoint(x, cx, dx);
+      s2out = true;
+    }
+    if (outsideRange(y, ay, by)) {
+      y = clampToClosestEndpoint(y, ay, by);
+      s1out = true;
+    }
+    if (outsideRange(y, cy, dy)) {
+      y = clampToClosestEndpoint(y, cy, dy);
+      s2out = true;
+    }
+    if ((s1out || s2out)) {
+      debug('Clamping a segment intersection point');
+      // console.log("angle:", innerAngle(ax, ay, bx, by, cx, cy, dx, dy))
+      // console.log('Feature 1', getSegFeature(ax, ay, bx, by, s1out));
+      // console.log('Feature 2', getSegFeature(cx, cy, dx, dy, s2out));
+      // console.log('Point:', JSON.stringify({
+      //   type: 'Feature',
+      //   properties: {fill: 'red'},
+      //   geometry: {type: 'Point', coordinates: [p[0], p[1]]}
+      // }));
+    }
     p[0] = x;
     p[1] = y;
   }
 
+
   // a: coordinate of point
   // b: endpoint coordinate of segment
   // c: other endpoint of segment
@@ -3321,16 +3473,13 @@
     return out;
   }
 
-  function clampToCloseRange(a, b, c) {
-    var lim;
-    if (outsideRange(a, b, c)) {
-      lim = Math.abs(a - b) < Math.abs(a - c) ? b : c;
-      if (Math.abs(a - lim) > 1e-15) {
-        debug("[clampToCloseRange()] large clamping interval", a, b, c);
-      }
-      a = lim;
+  function clampToClosestEndpoint(a, b, c) {
+    var lim = Math.abs(a - b) < Math.abs(a - c) ? b : c;
+    var interval = Math.abs(a - lim);
+    if (interval > 1e-15) {
+      debug("[clampToClosestEndpoint()] large clamping interval:", interval);
     }
-    return a;
+    return lim;
   }
 
   // Determinant of matrix
@@ -3348,10 +3497,35 @@
     return determinant2D(ax - cx, ay - cy, bx - cx, by - cy);
   }
 
+  function orient2D_robust(ax, ay, bx, by, cx, cy) {
+    var d = findBigIntScaleFactor(ax, ay, bx, by, cx, cy);
+    var ax_bi = BigInt(toScaledStr(ax, d));
+    var ay_bi = BigInt(toScaledStr(ay, d));
+    var bx_bi = BigInt(toScaledStr(bx, d));
+    var by_bi = BigInt(toScaledStr(by, d));
+    var cx_bi = BigInt(toScaledStr(cx, d));
+    var cy_bi = BigInt(toScaledStr(cy, d));
+    var o2d_bi = orient2D(ax_bi, ay_bi, bx_bi, by_bi, cx_bi, cy_bi);
+    return fromScaledStr(o2d_bi.toString(), d);
+  }
+
+  function segmentHit_robust(ax, ay, bx, by, cx, cy, dx, dy) {
+    var d = findBigIntScaleFactor(ax, ay, bx, by, cx, cy, dx, dy);
+    var ax_bi = BigInt(toScaledStr(ax, d));
+    var ay_bi = BigInt(toScaledStr(ay, d));
+    var bx_bi = BigInt(toScaledStr(bx, d));
+    var by_bi = BigInt(toScaledStr(by, d));
+    var cx_bi = BigInt(toScaledStr(cx, d));
+    var cy_bi = BigInt(toScaledStr(cy, d));
+    var dx_bi = BigInt(toScaledStr(dx, d));
+    var dy_bi = BigInt(toScaledStr(dy, d));
+    return segmentHit_fast(ax_bi, ay_bi, bx_bi, by_bi, cx_bi, cy_bi, dx_bi, dy_bi);
+  }
+
   // Source: Sedgewick, _Algorithms in C_
   // (Other functions were tried that were more sensitive to floating point errors
   //  than this function)
-  function segmentHit(ax, ay, bx, by, cx, cy, dx, dy) {
+  function segmentHit_fast(ax, ay, bx, by, cx, cy, dx, dy) {
     return orient2D(ax, ay, bx, by, cx, cy) *
         orient2D(ax, ay, bx, by, dx, dy) <= 0 &&
         orient2D(cx, cy, dx, dy, ax, ay) *
@@ -3381,8 +3555,10 @@
   var SegmentGeom = /*#__PURE__*/Object.freeze({
     __proto__: null,
     findClosestPointOnSeg: findClosestPointOnSeg,
+    findCrossIntersection_robust: findCrossIntersection_robust,
     orient2D: orient2D,
-    segmentHit: segmentHit,
+    orient2D_robust: orient2D_robust,
+    segmentHit_fast: segmentHit_fast,
     segmentIntersection: segmentIntersection,
     segmentTurn: segmentTurn
   });
@@ -3692,7 +3868,7 @@
   // editPart: callback function
   function editShapes(shapes, editPart) {
     for (var i=0, n=shapes.length; i<n; i++) {
-      shapes[i] = editShapeParts(shapes[i], editPart);
+      shapes[i] = editShapeParts(shapes[i], editPart, i);
     }
   }
 
@@ -3700,8 +3876,9 @@
   // @cb: function(part, i, parts)
   //    If @cb returns an array, it replaces the existing value
   //    If @cb returns null, the path is removed from the feature
+  // @shpId: (optional) id of shape
   //
-  function editShapeParts(parts, cb) {
+  function editShapeParts(parts, cb, shpId) {
     if (!parts) return null; // null geometry not edited
     if (!utils.isArray(parts)) error("Expected an array, received:", parts);
     var nulls = 0,
@@ -3709,7 +3886,7 @@
         retn;
 
     for (var i=0; i<n; i++) {
-      retn = cb(parts[i], i, parts);
+      retn = cb(parts[i], i, parts, shpId);
       if (retn === null) {
         nulls++;
         parts[i] = null;
@@ -5756,7 +5933,7 @@
     //
     this.forEach2 = function(cb) {
       for (var arcId=0, n=this.size(); arcId<n; arcId++) {
-        cb(_ii[arcId], _nn[arcId], _xx, _yy, _zz, arcId);
+        cb(arcId, _ii[arcId], _nn[arcId], _xx, _yy, _zz);
       }
     };
 
@@ -5891,6 +6068,44 @@
     };
 
     this.arcIsDegenerate = function(arcId) {
+      return this.arcHasZeroLength(arcId) || this.arcIsSpike(arcId) || this.arcIsSpike_v1(arcId);
+    };
+
+    // only finds two-segment spikes
+    this.arcIsSpike_v1 = function(arcId) {
+      var iter = this.getArcIter(arcId);
+      var x0, y0;
+      if (iter.hasNext()) {
+        x0 = iter.x;
+        y0 = iter.y;
+      }
+      iter.hasNext(); // ignore second point
+      if (iter.hasNext()) {
+        if (iter.x == x0 && iter.y == y0 && !iter.hasNext()) {
+          // three-vertex arc, first two are the same
+          return true;
+        }
+      }
+      return false;
+    };
+
+    // identifies n-segment spikes
+    this.arcIsSpike = function(arcId) {
+      arcId = absArcId(arcId);
+      var i = _ii[arcId];
+      var j = i + _nn[arcId] - 1;
+      while (j > i) {
+        if (_xx[i] != _xx[j] || _yy[i] != _yy[j]) {
+          return false;
+        }
+        j--;
+        i++;
+      }
+      return true;
+    };
+
+
+    this.arcHasZeroLength = function(arcId) {
       var iter = this.getArcIter(arcId);
       var i = 0,
           x, y;
@@ -6397,10 +6612,10 @@
       // Visit each point in the path, up to but not including the last point
       for (var i = start; i < end; i++) {
         if (pointIsArcEndpoint(i)) {
-          if (firstNodeId > -1) {
-            arcIds.push(addEdge(arcStartId, i));
-          } else {
+          if (firstNodeId == -1) {
             firstNodeId = i;
+          } else {
+            arcIds.push(addEdge(arcStartId, i));
           }
           arcStartId = i;
         }
@@ -6991,7 +7206,7 @@
         yy2 = new Float64Array(n),
         ids2 = new Int32Array(n);
 
-    arcs.forEach2(function(i, n, xx, yy, zz, arcId) {
+    arcs.forEach2(function(arcId, i, n, xx, yy, zz) {
       var start = i,
           end = i + n - 1,
           start2 = arcId * 2,
@@ -7042,7 +7257,7 @@
     layers.forEach(function(lyr) {
       // modify copies of the original shapes; original shapes should be unmodified
       // (need to test this)
-      lyr.shapes = lyr.shapes.map(function(shape) {
+      lyr.shapes = lyr.shapes.map(function(shape, i) {
         return editShapeParts(shape && shape.concat(), translatePath);
       });
     });
@@ -12584,11 +12799,178 @@
     stringifyAsNDJSON: stringifyAsNDJSON
   });
 
+  function findNearestVertices(p, shp, arcs) {
+    var p2 = findNearestVertex(p[0], p[1], shp, arcs);
+    return findVertexIds(p2.x, p2.y, arcs);
+  }
+
+  function snapVerticesToPoint(ids, p, arcs) {
+    var data = arcs.getVertexData();
+    ids.forEach(function(idx) {
+      setVertexCoords(p[0], p[1], idx, arcs);
+      arcs.updateArcBounds(findArcIdFromVertexId(idx, data.ii));
+    });
+  }
+
+
+  // p: point to snap
+  // ids: ids of nearby vertices, possibly including an arc endpoint
+  function snapPointToArcEndpoint(p, ids, arcs) {
+    var p2, dx, dy;
+    ids.forEach(function(idx) {
+      if (vertexIsArcStart(idx, arcs)) {
+        p2 = getVertexCoords(idx + 1, arcs);
+      } else if (vertexIsArcEnd(idx, arcs)) {
+        p2 = getVertexCoords(idx - 1, arcs);
+      }
+    });
+    if (!p2) return;
+    dx = p2[0] - p[0];
+    dy = p2[1] - p[1];
+    if (Math.abs(dx) > Math.abs(dy)) {
+      p[1] = p2[1]; // snap y coord
+    } else {
+      p[0] = p2[0];
+    }
+  }
+
+  // Find ids of vertices with identical coordinates to x,y in an ArcCollection
+  // Caveat: does not exclude vertices that are not visible at the
+  //   current level of simplification.
+  function findVertexIds(x, y, arcs) {
+    var data = arcs.getVertexData(),
+        xx = data.xx,
+        yy = data.yy,
+        ids = [];
+    for (var i=0, n=xx.length; i<n; i++) {
+      if (xx[i] == x && yy[i] == y) ids.push(i);
+    }
+    return ids;
+  }
+
+  function getVertexCoords(i, arcs) {
+    var data = arcs.getVertexData();
+    return [data.xx[i], data.yy[i]];
+  }
+
+  function vertexIsArcEnd(idx, arcs) {
+    // Test whether the vertex at index @idx is the endpoint of an arc
+    var data = arcs.getVertexData(),
+        ii = data.ii,
+        nn = data.nn;
+    for (var j=0, n=ii.length; j<n; j++) {
+      if (idx === ii[j] + nn[j] - 1) return true;
+    }
+    return false;
+  }
+
+  function vertexIsArcEndpoint(idx, arcs) {
+    return vertexIsArcStart(idx, arcs) || vertexIsArcEnd(idx, arcs);
+  }
+
+  function vertexIsArcStart(idx, arcs) {
+    var ii = arcs.getVertexData().ii;
+    for (var j=0, n=ii.length; j<n; j++) {
+      if (idx === ii[j]) return true;
+    }
+    return false;
+  }
+
+  function getArcStartCoords(arcId, arcs) {
+    var coords = getArcEndpointCoords(arcId, arcs);
+    return coords[0];
+  }
+
+  function getArcEndCoords(arcId, arcs) {
+    var coords = getArcEndpointCoords(arcId, arcs);
+    return coords[1];
+  }
+
+  function getArcEndpointCoords(arcId, arcs) {
+    if (arcId < 0) {
+      return getArcEndpointCoords(~arcId, arcs).reverse();
+    }
+    var data = arcs.getVertexData();
+    var i = data.ii[arcId];
+    var n = data.nn[arcId];
+    var a = [data.xx[i], data.yy[i]];
+    var b = [data.xx[i + n - 1], data.yy[i + n - 1]];
+    return [a, b];
+  }
+
+  function setVertexCoords(x, y, i, arcs) {
+    var data = arcs.getVertexData();
+    data.xx[i] = x;
+    data.yy[i] = y;
+  }
+
+  function findNearestVertex(x, y, shp, arcs, spherical) {
+    var calcLen = spherical ? geom.greatCircleDistance : geom.distance2D,
+        minLen = Infinity,
+        minX, minY, dist, iter;
+    for (var i=0; i<shp.length; i++) {
+      iter = arcs.getShapeIter(shp[i]);
+      while (iter.hasNext()) {
+        dist = calcLen(x, y, iter.x, iter.y);
+        if (dist < minLen) {
+          minLen = dist;
+          minX = iter.x;
+          minY = iter.y;
+        }
+      }
+    }
+    return minLen < Infinity ? {x: minX, y: minY} : null;
+  }
+
+  var VertexUtils = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    findNearestVertex: findNearestVertex,
+    findNearestVertices: findNearestVertices,
+    findVertexIds: findVertexIds,
+    getArcEndCoords: getArcEndCoords,
+    getArcEndpointCoords: getArcEndpointCoords,
+    getArcStartCoords: getArcStartCoords,
+    getVertexCoords: getVertexCoords,
+    setVertexCoords: setVertexCoords,
+    snapPointToArcEndpoint: snapPointToArcEndpoint,
+    snapVerticesToPoint: snapVerticesToPoint,
+    vertexIsArcEnd: vertexIsArcEnd,
+    vertexIsArcEndpoint: vertexIsArcEndpoint,
+    vertexIsArcStart: vertexIsArcStart
+  });
+
+  function debugConnectedArcs(ids, arcs) {
+    var colors = ['orange', 'blue', 'green', 'red', 'magenta', 'grey'];
+    var features = ids.map(function(arcId, i) {
+      return getArcFeature(arcId, arcs, {arcId: arcId, stroke: colors[i] || 'black'});
+    });
+    var geojson = '{"type": "FeatureCollection", "features": [' + features.join(',') + ']}';
+    debug(geojson);
+  }
+
+  function getArcFeature(arcId, arcs, properties) {
+    return JSON.stringify({
+      type: "Feature",
+      properties: properties,
+      geometry: GeoJSON.exportLineGeom([[arcId]], arcs)
+    });
+  }
+
   function isValidArc(arcId, arcs) {
     // check for arcs with no vertices
     // TODO: also check for other kinds of degenerate arcs
     // (e.g. collapsed arcs consisting of identical points)
-    return arcs.getArcLength(arcId) > 1;
+    var len = arcs.getArcLength(arcId);
+    if (len >= 2 === false) {
+      return false;
+    }
+    // if (len <=3) {
+    //   var endpoints = getArcEndpointCoords(arcId, arcs);
+    //   if (pointsAreEqual(endpoints[0], endpoints[1])) {
+    //     return false;
+    //   }
+    // }
+    return true;
   }
 
   // Return id of rightmost connected arc in relation to @fromArcId
@@ -12620,11 +13002,11 @@
       error("Duplicate point error");
     }*/
 
-
     for (j=0; j<ids.length; j++) {
       candId = ids[j];
       if (!isValidArc(candId, arcs)) {
         // skip empty arcs
+        debug('skipping one arc:', candId, 'out of:', ids.length, ids);
         continue;
       }
       icand = arcs.indexOfVertex(candId, -2);
@@ -12635,6 +13017,14 @@
         continue;
       }
       code = chooseRighthandPath(fromX, fromY, nodeX, nodeY, xx[ito], yy[ito], xx[icand], yy[icand]);
+
+      if (xx[ito] == xx[icand] && yy[ito] == yy[icand]) {
+        debug("Pathfinder warning: duplicate segments: i:", ito, "j:", icand, "ids:", [fromArcId].concat(ids));
+        if (useDebug()) {
+          // debugDuplicatePathfinderSegments(nodeX, nodeY, ito, icand, nodes.arcs);
+          debugConnectedArcs(ids, nodes.arcs);
+        }
+      }
       if (code == 2) {
         ito = icand;
         toArcId = candId;
@@ -12644,26 +13034,22 @@
 
     if (toArcId == fromArcId) {
       // This shouldn't occur, assuming that other arcs are present
-      error("Pathfinder error");
+      error("Pathfinder error", toArcId, fromArcId);
     }
     return toArcId;
   }
 
-  // TODO: consider using simpler internal.chooseRighthandPath2()
   // Returns 1 if node->a, return 2 if node->b, else return 0
   // TODO: better handling of identical angles (better -- avoid creating them)
   function chooseRighthandPath(fromX, fromY, nodeX, nodeY, ax, ay, bx, by) {
     var angleA = geom.signedAngle(fromX, fromY, nodeX, nodeY, ax, ay);
     var angleB = geom.signedAngle(fromX, fromY, nodeX, nodeY, bx, by);
+    // should use arbitrary precision math to evaluate angles smaller than this
+    // (all observed errors caused by fp rounding occured with smaller angles than this)
+    var smallAngle = 0.001;
     var code;
     if (angleA <= 0 || angleB <= 0) {
       debug("[chooseRighthandPath()] 0 angle(s):", angleA, angleB);
-      if (angleA <= 0) {
-        debug('  A orient2D:', geom.orient2D(fromX, fromY, nodeX, nodeY, ax, ay));
-      }
-      if (angleB <= 0) {
-        debug('  B orient2D:', geom.orient2D(fromX, fromY, nodeX, nodeY, bx, by));
-      }
       // TODO: test against "from" segment
       if (angleA > 0) {
         code = 1;
@@ -12672,23 +13058,23 @@
       } else {
         code = 0;
       }
-    } else if (angleA < angleB) {
+    } else if (angleA < angleB - smallAngle) {
       code = 1;
-    } else if (angleB < angleA) {
+    } else if (angleB < angleA - smallAngle) {
       code = 2;
     } else if (isNaN(angleA) || isNaN(angleB)) {
       // probably a duplicate point, which should not occur
       error('Invalid node geometry');
     } else {
-      // Equal angles: use fallback test that is less sensitive to rounding error
-      code = chooseRighthandVector(ax - nodeX, ay - nodeY, bx - nodeX, by - nodeY);
-      debug('[chooseRighthandPath()] equal angles:', angleA, 'fallback test:', code);
+      // Close-to-equal or equal angles: use more exact test.
+      code = chooseBetweenClosePaths(nodeX, nodeY, ax, ay, bx, by);
+      // debug('[chooseRighthandPath()] close-to-equal angles:', Math.abs(angleA) - Math.abs(angleB), 'hi-res code:', code);
     }
     return code;
   }
 
-  function chooseRighthandVector(ax, ay, bx, by) {
-    var orient = geom.orient2D(ax, ay, 0, 0, bx, by);
+  function chooseBetweenClosePaths(nodeX, nodeY, ax, ay, bx, by) {
+    var orient = orient2D_robust(ax, ay, nodeX, nodeY, bx, by);
     var code;
     if (orient > 0) {
       code = 2;
@@ -12702,7 +13088,7 @@
 
   var PathfinderUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    chooseRighthandVector: chooseRighthandVector,
+    chooseBetweenClosePaths: chooseBetweenClosePaths,
     getRightmostArc: getRightmostArc
   });
 
@@ -13227,7 +13613,7 @@
         }
 
         // test two candidate segments for intersection
-        hit = geom.segmentIntersection(s1p1x, s1p1y, s1p2x, s1p2y,
+        hit = segmentIntersection(s1p1x, s1p1y, s1p2x, s1p2y,
             s2p1x, s2p1y, s2p2x, s2p2y, tolerance);
         if (hit) {
           seg1 = [s1p1, s1p2];
@@ -13285,146 +13671,6 @@
     sortIntersections: sortIntersections
   });
 
-  function findNearestVertices(p, shp, arcs) {
-    var p2 = findNearestVertex(p[0], p[1], shp, arcs);
-    return findVertexIds(p2.x, p2.y, arcs);
-  }
-
-  function snapVerticesToPoint(ids, p, arcs) {
-    var data = arcs.getVertexData();
-    ids.forEach(function(idx) {
-      setVertexCoords(p[0], p[1], idx, arcs);
-      arcs.updateArcBounds(findArcIdFromVertexId(idx, data.ii));
-    });
-  }
-
-
-  // p: point to snap
-  // ids: ids of nearby vertices, possibly including an arc endpoint
-  function snapPointToArcEndpoint(p, ids, arcs) {
-    var p2, dx, dy;
-    ids.forEach(function(idx) {
-      if (vertexIsArcStart(idx, arcs)) {
-        p2 = getVertexCoords(idx + 1, arcs);
-      } else if (vertexIsArcEnd(idx, arcs)) {
-        p2 = getVertexCoords(idx - 1, arcs);
-      }
-    });
-    if (!p2) return;
-    dx = p2[0] - p[0];
-    dy = p2[1] - p[1];
-    if (Math.abs(dx) > Math.abs(dy)) {
-      p[1] = p2[1]; // snap y coord
-    } else {
-      p[0] = p2[0];
-    }
-  }
-
-  // Find ids of vertices with identical coordinates to x,y in an ArcCollection
-  // Caveat: does not exclude vertices that are not visible at the
-  //   current level of simplification.
-  function findVertexIds(x, y, arcs) {
-    var data = arcs.getVertexData(),
-        xx = data.xx,
-        yy = data.yy,
-        ids = [];
-    for (var i=0, n=xx.length; i<n; i++) {
-      if (xx[i] == x && yy[i] == y) ids.push(i);
-    }
-    return ids;
-  }
-
-  function getVertexCoords(i, arcs) {
-    var data = arcs.getVertexData();
-    return [data.xx[i], data.yy[i]];
-  }
-
-  function vertexIsArcEnd(idx, arcs) {
-    // Test whether the vertex at index @idx is the endpoint of an arc
-    var data = arcs.getVertexData(),
-        ii = data.ii,
-        nn = data.nn;
-    for (var j=0, n=ii.length; j<n; j++) {
-      if (idx === ii[j] + nn[j] - 1) return true;
-    }
-    return false;
-  }
-
-  function vertexIsArcEndpoint(idx, arcs) {
-    return vertexIsArcStart(idx, arcs) || vertexIsArcEnd(idx, arcs);
-  }
-
-  function vertexIsArcStart(idx, arcs) {
-    var ii = arcs.getVertexData().ii;
-    for (var j=0, n=ii.length; j<n; j++) {
-      if (idx === ii[j]) return true;
-    }
-    return false;
-  }
-
-  function getArcStartCoords(arcId, arcs) {
-    var coords = getArcEndpointCoords(arcId, arcs);
-    return coords[0];
-  }
-
-  function getArcEndCoords(arcId, arcs) {
-    var coords = getArcEndpointCoords(arcId, arcs);
-    return coords[1];
-  }
-
-  function getArcEndpointCoords(arcId, arcs) {
-    if (arcId < 0) {
-      return getArcEndpointCoords(~arcId, arcs).reverse();
-    }
-    var data = arcs.getVertexData();
-    var i = data.ii[arcId];
-    var n = data.nn[arcId];
-    var a = [data.xx[i], data.yy[i]];
-    var b = [data.xx[i + n - 1], data.yy[i + n - 1]];
-    return [a, b];
-  }
-
-  function setVertexCoords(x, y, i, arcs) {
-    var data = arcs.getVertexData();
-    data.xx[i] = x;
-    data.yy[i] = y;
-  }
-
-  function findNearestVertex(x, y, shp, arcs, spherical) {
-    var calcLen = spherical ? geom.greatCircleDistance : geom.distance2D,
-        minLen = Infinity,
-        minX, minY, dist, iter;
-    for (var i=0; i<shp.length; i++) {
-      iter = arcs.getShapeIter(shp[i]);
-      while (iter.hasNext()) {
-        dist = calcLen(x, y, iter.x, iter.y);
-        if (dist < minLen) {
-          minLen = dist;
-          minX = iter.x;
-          minY = iter.y;
-        }
-      }
-    }
-    return minLen < Infinity ? {x: minX, y: minY} : null;
-  }
-
-  var VertexUtils = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    findNearestVertex: findNearestVertex,
-    findNearestVertices: findNearestVertices,
-    findVertexIds: findVertexIds,
-    getArcEndCoords: getArcEndCoords,
-    getArcEndpointCoords: getArcEndpointCoords,
-    getArcStartCoords: getArcStartCoords,
-    getVertexCoords: getVertexCoords,
-    setVertexCoords: setVertexCoords,
-    snapPointToArcEndpoint: snapPointToArcEndpoint,
-    snapVerticesToPoint: snapVerticesToPoint,
-    vertexIsArcEnd: vertexIsArcEnd,
-    vertexIsArcEndpoint: vertexIsArcEndpoint,
-    vertexIsArcStart: vertexIsArcStart
-  });
-
   // arcs: ArcCollection containing original coordinates
   function getRepairFunction(arcs) {
     var arcsOrig = arcs.getCopy();
@@ -13856,6 +14102,9 @@
         getSliverTest(dataset.arcs, threshold, sliverControl) :
         getMinAreaTest(threshold, dataset);
     var label = getSliverLabel(getAreaLabel(threshold, crs), sliverControl > 0);
+    if (opts.keep_shapes) {
+      filter = keepShapes(filter);
+    }
     return {
       threshold: threshold,
       filter: filter,
@@ -13863,6 +14112,23 @@
     };
   }
 
+  // wrap path filter in a function that ensures at least one part of every shape
+  // is retained.
+  function keepShapes(filter) {
+    var flags;
+    return function(path, pathId, paths) {
+      // console.log("keepShapes()", path, pathId, paths)
+      if (pathId === 0) {
+        flags = paths.map(path => filter(path));
+      }
+      if (flags.length > 0 && flags.every(Boolean)) {
+        // kludge ... assumes that the first path is a valid ring (e.g. not a)
+        flags[0] = false;
+      }
+      return flags[pathId];
+    };
+  }
+
   function getSliverLabel(areaStr, variable) {
     if (variable) {
       areaStr = areaStr.replace(' ', '+ ') + ' variable';
@@ -16508,6 +16774,7 @@
 
   function cleanPath(path, arcs) {
     var nulls = 0;
+    // console.log("[cleanPath()]", path, path?.[0])
     for (var i=0, n=path.length; i<n; i++) {
       if (arcs.arcIsDegenerate(path[i])) {
         nulls++;
@@ -16796,54 +17063,45 @@
     if (changed || opts.rebuild_topology) {
       buildTopology(dataset);
     }
-
-    // Clean shapes by removing collapsed arc references, etc.
-    // TODO: consider alternative -- avoid creating degenerate arcs
-    // in insertCutPoints()
+    // Remove degenerate shapes
+    // Without this step, pathfinder function would encounter dead ends.
     dataset.layers.forEach(function(lyr) {
       if (layerHasPaths(lyr)) {
         cleanShapes(lyr.shapes, arcs, lyr.geometry_type);
       }
     });
-
-    // Further clean-up -- remove duplicate and missing arcs
+    // Further clean-up -- remove duplicate and unused arcs, etc.
     nodes = cleanArcReferences(dataset);
     return nodes;
   }
 
   function snapAndCut(dataset, snapDist) {
     var arcs = dataset.arcs;
-    var cutOpts = snapDist > 0 ? {} : {tolerance: 0};
+    var cutOpts = snapDist > 0 ? {tolerance: snapDist} : {tolerance: 0};
     var coordsHaveChanged = false;
     var snapCount, dupeCount, cutCount;
-    snapCount = snapCoordsByInterval(arcs, snapDist);
-    dupeCount = arcs.dedupCoords();
-
-    // why was topology built here previously????
-    // if (snapCount > 0 || dupeCount > 0) {
-    //   // Detect topology again if coordinates have changed
-    //   internal.buildTopology(dataset);
-    // }
+    var maxLoops = 4, loopCount = 0;
 
-    // cut arcs at points where segments intersect
-    cutCount = cutPathsAtIntersections(dataset, cutOpts);
-    if (cutCount > 0 || snapCount > 0 || dupeCount > 0) {
-      coordsHaveChanged = true;
-    }
-
-    // perform a second snap + cut pass if needed
-    if (cutCount > 0) {
+    // snap + cut until no more cuts are needed
+    do {
+      loopCount++;
       cutCount = 0;
       snapCount = snapCoordsByInterval(arcs, snapDist);
-      arcs.dedupCoords(); // need to do this here?
-      if (snapCount > 0) {
+      dupeCount = arcs.dedupCoords();
+      if (snapCount > 0 || cutCount > 0 || loopCount == 1) {
+        // cut arcs at points where segments intersect
         cutCount = cutPathsAtIntersections(dataset, cutOpts);
       }
-      if (cutCount > 0) {
-        arcs.dedupCoords(); // need to do this here?
-        debug('Second-pass vertices added:', cutCount, 'consider third pass?');
-      }
-    }
+      coordsHaveChanged |= (snapCount + dupeCount + cutCount) > 0;
+      debug("[snapAndCut] pass:", loopCount, "snaps:", snapCount, "dupes:", dupeCount, "cuts:", cutCount);
+    } while (loopCount < maxLoops && cutCount > 0);
+
+    // should this be added?
+    // if (cutCount > 0 && loopCount == maxLoops) {
+    //   snapCount = snapCoordsByInterval(arcs, snapDist);
+    //   arcs.dedupCoords(); // need to do this here?
+    // }
+
     return coordsHaveChanged;
   }
 
@@ -17028,21 +17286,21 @@
   function filterSortedCutPoints(points, arcs) {
     var filtered = [],
         pointId = 0;
-    arcs.forEach2(function(i, n, xx, yy) {
-      var j = i + n - 1,
-          x0 = xx[i],
-          y0 = yy[i],
-          xn = xx[j],
-          yn = yy[j],
+    arcs.forEach2(function(arcId, i, n, xx, yy) {
+      var j = i + n - 1, // idx of second endpoint
+          x1 = xx[i],
+          y1 = yy[i],
+          x2 = xx[j],
+          y2 = yy[j],
           p, pp;
 
       while (pointId < points.length && points[pointId].i <= j) {
         p = points[pointId];
+        pointId++;
         pp = filtered[filtered.length - 1]; // previous point
-        if (p.x == x0 && p.y == y0 || p.x == xn && p.y == yn) ; else if (pp && pp.x == p.x && pp.y == p.y && pp.i == p.i) ; else {
+        if (p.x == x1 && p.y == y1 && p.i == i || p.x == x2 && p.y == y2 && p.i >= j - 1) ; else if (pp && pp.x == p.x && pp.y == p.y && pp.i == p.i) ; else {
           filtered.push(p);
         }
-        pointId++;
       }
     });
     return filtered;
@@ -18370,6 +18628,7 @@
     return geom;
   };
 
+  // ids: shape data (array of array of arc ids)
   GeoJSON.exportLineGeom = function(ids, arcs) {
     var obj = exportPathData(ids, arcs, "polyline");
     if (obj.pointCount === 0) return null;
@@ -18385,6 +18644,7 @@
     };
   };
 
+  // ids: shape data (array of array of arc ids)
   GeoJSON.exportPolygonGeom = function(ids, arcs, opts) {
     var obj = exportPathData(ids, arcs, "polygon");
     if (obj.pointCount === 0) return null;
@@ -18777,203 +19037,6 @@
     catalog.getDatasets().push(o);
   }
 
-  // Apply rotation, scale and/or shift to some or all of the features in a dataset
-  //
-  cmd.affine = function(targetLayers, dataset, opts) {
-    // Need to separate the targeted shapes from any other shapes that share
-    // the same topology. So we duplicate any arcs that are shared by the targeted
-    // shapes and their topological neighbors and remap arc references in the
-    // neighbors to point to the copies.
-    // TODO: explore alternative: if some arcs are shared between transformed and
-    //   non-transformed shapes, first remove topology, then tranform, then rebuild topology
-    //
-    var rotateArg = opts.rotate || 0;
-    var scaleArg = opts.scale || 1;
-    var shiftArg = opts.shift ? convertIntervalPair(opts.shift, getDatasetCRS(dataset)) : [0, 0];
-    var arcs = dataset.arcs;
-    var targetShapes = [];
-    var otherShapes = [];
-    var targetPoints = [];
-    var targetFlags, otherFlags, transform;
-    dataset.layers.filter(layerHasGeometry).forEach(function(lyr) {
-      var hits = [],
-          misses = [],
-          test;
-      if (targetLayers.indexOf(lyr) == -1) {
-        misses = lyr.shapes;
-      } else if (opts.where) {
-        test = compileFeatureExpression(opts.where, lyr, dataset.arcs);
-        lyr.shapes.forEach(function(shp, i) {
-          (test(i) ? hits : misses).push(shp);
-        });
-      } else {
-        hits = lyr.shapes;
-      }
-      if (lyr.geometry_type == 'point') {
-        targetPoints = targetPoints.concat(hits);
-      } else {
-        targetShapes = targetShapes.concat(hits);
-        otherShapes = otherShapes.concat(misses);
-      }
-    });
-    var anchorArg = getAffineAnchor({arcs: dataset.arcs, layers: [{
-      geometry_type: 'point', shapes: targetPoints}, {geometry_type: 'polyline',
-      shapes: targetShapes}]}, opts);
-    transform = getAffineTransform(rotateArg, scaleArg, shiftArg, anchorArg);
-    if (opts.fit_bbox) {
-      transform = getFitBoxTransform(opts.fit_bbox, targetPoints, targetShapes, arcs);
-    }
-    if (targetShapes.length > 0) {
-      targetFlags = new Uint8Array(arcs.size());
-      otherFlags = new Uint8Array(arcs.size());
-      countArcsInShapes(targetShapes, targetFlags);
-      if (otherShapes.length > 0) {
-        countArcsInShapes(otherShapes, otherFlags);
-        applyArrayMask(otherFlags, targetFlags);
-        dataset.arcs = duplicateSelectedArcs(otherShapes, arcs, otherFlags);
-      }
-      dataset.arcs.transformPoints(function(x, y, arcId) {
-        if (arcId < targetFlags.length && targetFlags[arcId] > 0) {
-          return transform(x, y);
-        }
-      });
-    }
-    forEachPoint(targetPoints, function(p) {
-      var p2 = transform(p[0], p[1]);
-      p[0] = p2[0];
-      p[1] = p2[1];
-    });
-  };
-
-  function getAffineAnchor(dataset, opts) {
-    var anchor, bounds;
-    if (opts.anchor) {
-      anchor = opts.anchor;
-    } else {
-      // get bounds of selected shapes to calculate center of rotation/scale
-      bounds = getDatasetBounds(dataset);
-      anchor = [bounds.centerX(), bounds.centerY()];
-    }
-    return anchor;
-  }
-
-  // TODO: handle problems with unprojected datasets
-  //   option 1: don't allow affine transformation of unprojected data
-  //   option 2: error if transformed data exceeds valid coordinate range
-  // source: http://mathworld.wolfram.com/AffineTransformation.html
-  function getAffineTransform(rotation, scale, shift, anchor) {
-    var angle = rotation * Math.PI / 180;
-    var a = scale * Math.cos(angle);
-    var b = -scale * Math.sin(angle);
-    return function(x, y) {
-      var x2 = a * (x - anchor[0]) - b * (y - anchor[1]) + shift[0] + anchor[0];
-      var y2 = b * (x - anchor[0]) + a * (y - anchor[1]) + shift[1] + anchor[1];
-      return [x2, y2];
-    };
-  }
-
-  function getFitBoxTransform(bbox, points, shapes, arcs) {
-    var dataset = {
-      arcs: arcs,
-      layers: []
-    };
-    if (points && points.length) {
-      dataset.layers.push({
-        geometry_type: 'point',
-        shapes: points
-      });
-    }
-    if (shapes && shapes.length) {
-      dataset.layers.push({
-        geometry_type: 'polyline',
-        shapes: shapes
-      });
-    }
-    var frame = calcFrameData(dataset, {fit_bbox: bbox});
-    var fromBounds = new Bounds(frame.bbox);
-    var toBounds = new Bounds(frame.bbox2);
-    var fwd = fromBounds.getTransform(toBounds, false);
-    return function(x, y) {
-      return fwd.transform(x, y);
-    };
-  }
-
-  function applyArrayMask(destArr, maskArr) {
-    for (var i=0, n=destArr.length; i<n; i++) {
-      if (maskArr[i] === 0) destArr[i] = 0;
-    }
-  }
-
-  function duplicateSelectedArcs(shapes, arcs, flags) {
-    var arcCount = 0;
-    var vertexCount = 0;
-    var data = arcs.getVertexData();
-    var xx = [], yy = [], nn = [], map = [], n;
-    for (var i=0, len=flags.length; i<len; i++) {
-      if (flags[i] > 0) {
-        map[i] = arcs.size() + arcCount;
-        n = data.nn[i];
-        utils.copyElements(data.xx, data.ii[i], xx, vertexCount, n);
-        utils.copyElements(data.yy, data.ii[i], yy, vertexCount, n);
-        nn.push(n);
-        vertexCount += n;
-        arcCount++;
-      }
-    }
-    forEachArcId(shapes, function(id) {
-      var absId = absArcId(id);
-      if (flags[absId] > 0) {
-        return id < 0 ? ~map[absId] : map[absId];
-      }
-    });
-    return mergeArcs([arcs, new ArcCollection(nn, xx, yy)]);
-  }
-
-  var roundCoord$2 = getRoundingFunction(0.01);
-
-  function stringifyVertex(p) {
-    return ' ' + roundCoord$2(p[0]) + ' ' + roundCoord$2(p[1]);
-  }
-
-  function isCubicCtrl(p) {
-    return p.length > 2 && p[2] == 'C';
-  }
-
-  function stringifyPolygonCoords(coords) {
-    var parts = [];
-    for (var i=0; i<coords.length; i++) {
-      parts.push(stringifyLineStringCoords(coords[i]) + ' Z');
-    }
-    return parts.length > 0 ? parts.join(' ') : '';
-  }
-
-  function stringifyLineStringCoords(coords) {
-    if (coords.length === 0) return '';
-    var d = 'M';
-    var fromCurve = false;
-    var p, i, n;
-    for (i=0, n=coords.length; i<n; i++) {
-      p = coords[i];
-      if (isCubicCtrl(p)) {
-        // TODO: add defensive check
-        d += ' C' + stringifyVertex(p) + stringifyVertex(coords[++i]) + stringifyVertex(coords[++i]);
-        fromCurve = true;
-      } else if (fromCurve) {
-        d += ' L' + stringifyVertex(p);
-        fromCurve = false;
-      } else {
-        d += stringifyVertex(p);
-      }
-    }
-    return d;
-  }
-
-  var SvgPathUtils = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    stringifyLineStringCoords: stringifyLineStringCoords,
-    stringifyPolygonCoords: stringifyPolygonCoords
-  });
-
   /* example patterns
   hatches 1px black 1px red 1px white
   1px black 1px red 1px white // same as above (hatches is default)
@@ -19562,7 +19625,7 @@
   }
 
   function importLineString(coords) {
-    var d = stringifyLineStringCoords(coords);
+    var d = stringifyLineStringCoords$1(coords);
     return {
       tag: 'path',
       properties: {d: d}
@@ -19570,7 +19633,7 @@
   }
 
   function importMultiLineString(coords) {
-    var d = coords.map(stringifyLineStringCoords).join(' ');
+    var d = coords.map(stringifyLineStringCoords$1).join(' ');
     return {
       tag: 'path',
       properties: {d: d}
@@ -19592,7 +19655,7 @@
     var o = {
       tag: 'path',
       properties: {
-        d: stringifyPolygonCoords(coords)
+        d: stringifyPolygonCoords$1(coords)
       }
     };
     if (coords.length > 1) {
@@ -19601,6 +19664,23 @@
     return o;
   }
 
+  function stringifyPolygonCoords$1(coords) {
+    var parts = [];
+    for (var i=0; i<coords.length; i++) {
+      parts.push(stringifyLineStringCoords$1(coords[i]) + ' Z');
+    }
+    return parts.length > 0 ? parts.join(' ') : '';
+  }
+
+  function stringifyLineStringCoords$1(coords) {
+    if (coords.length === 0) return '';
+    var d = 'M';
+    for (var i=0, n=coords.length; i<n; i++) {
+      d += ' ' + coords[i][0] + ' ' + coords[i][1];
+    }
+    return d;
+  }
+
   var GeojsonToSvg = /*#__PURE__*/Object.freeze({
     __proto__: null,
     flattenMultiPolygonCoords: flattenMultiPolygonCoords,
@@ -20490,7 +20570,7 @@
     opts = Object.assign({invert_y: true, margin: "1"}, opts);
     frame = getFrameData(dataset, opts);
     fitDatasetToFrame(dataset, frame);
-    setCoordinatePrecision(dataset, opts.precision || 0.0001);
+    setCoordinatePrecision(dataset, opts.precision || 0.01);
 
     // error if one or more svg_data fields are not present in any layers
     if (opts.svg_data) validateSvgDataFields(dataset.layers, opts.svg_data);
@@ -22246,7 +22326,7 @@ ${svg}
     if (opts.presimplify) {
       fromZ = getPresimplifyFunction(bounds.width());
     }
-    arcs.forEach2(function(i, n, xx, yy, zz) {
+    arcs.forEach2(function(arcId, i, n, xx, yy, zz) {
       var arc = [], p;
       for (var j=i + n; i<j; i++) {
         p = [xx[i], yy[i]];
@@ -24842,6 +24922,11 @@ ${svg}
       .option('sliver-control', sliverControlOpt)
       .option('snap-interval', snapIntervalOpt)
       .option('no-snap', noSnapOpt)
+      // // not useful in -clean -- clean removes gaps, not slivers
+      // .option('keep-shapes', {
+      //   type: 'flag',
+      //   describe: 'protect sliver polygons from complete removal'
+      // })
       .option('allow-overlaps', {
         describe: 'allow polygons to overlap (disables gap fill)',
         type: 'flag'
@@ -24893,6 +24978,10 @@ ${svg}
         })
       .option('name', nameOpt)
       .option('no-snap', noSnapOpt)
+      .option('no-cleanup', {
+        // for debugging - no documentation
+        type: 'flag'
+      })
       .option('target', targetOpt)
       .option('no-replace', noReplaceOpt);
 
@@ -25128,6 +25217,10 @@ ${svg}
       .option('bbox', bboxOpt)
       .option('name', nameOpt)
       .option('no-snap', noSnapOpt)
+      .option('no-cleanup', {
+        // for debugging - no documentation
+        type: 'flag'
+      })
       .option('target', targetOpt)
       .option('no-replace', noReplaceOpt);
 
@@ -25238,6 +25331,10 @@ ${svg}
         type: 'flag',
         describe: 'delete features with null geometry'
       })
+      .option('keep-shapes', {
+        type: 'flag',
+        describe: 'protect sliver polygons from complete removal'
+      })
       .option('target', targetOpt);
 
     parser.command('graticule')
@@ -25445,9 +25542,8 @@ ${svg}
       .option('calc', calcOpt)
       .option('name', nameOpt)
       .option('target', targetOpt)
-      .option('no-snap', { // undocumented, for debugging
-        type: 'flag'
-      })
+      .option('snap-interval', snapIntervalOpt)
+      .option('no-snap', noSnapOpt)
       .option('no-replace', noReplaceOpt);
 
     parser.command('point-grid')
@@ -29843,6 +29939,158 @@ ${svg}
     stop('Unable to import coordinates');
   }
 
+  // Apply rotation, scale and/or shift to some or all of the features in a dataset
+  //
+  cmd.affine = function(targetLayers, dataset, opts) {
+    // Need to separate the targeted shapes from any other shapes that share
+    // the same topology. So we duplicate any arcs that are shared by the targeted
+    // shapes and their topological neighbors and remap arc references in the
+    // neighbors to point to the copies.
+    // TODO: explore alternative: if some arcs are shared between transformed and
+    //   non-transformed shapes, first remove topology, then tranform, then rebuild topology
+    //
+    var rotateArg = opts.rotate || 0;
+    var scaleArg = opts.scale || 1;
+    var shiftArg = opts.shift ? convertIntervalPair(opts.shift, getDatasetCRS(dataset)) : [0, 0];
+    var arcs = dataset.arcs;
+    var targetShapes = [];
+    var otherShapes = [];
+    var targetPoints = [];
+    var targetFlags, otherFlags, transform;
+    dataset.layers.filter(layerHasGeometry).forEach(function(lyr) {
+      var hits = [],
+          misses = [],
+          test;
+      if (targetLayers.indexOf(lyr) == -1) {
+        misses = lyr.shapes;
+      } else if (opts.where) {
+        test = compileFeatureExpression(opts.where, lyr, dataset.arcs);
+        lyr.shapes.forEach(function(shp, i) {
+          (test(i) ? hits : misses).push(shp);
+        });
+      } else {
+        hits = lyr.shapes;
+      }
+      if (lyr.geometry_type == 'point') {
+        targetPoints = targetPoints.concat(hits);
+      } else {
+        targetShapes = targetShapes.concat(hits);
+        otherShapes = otherShapes.concat(misses);
+      }
+    });
+    var anchorArg = getAffineAnchor({arcs: dataset.arcs, layers: [{
+      geometry_type: 'point', shapes: targetPoints}, {geometry_type: 'polyline',
+      shapes: targetShapes}]}, opts);
+    transform = getAffineTransform(rotateArg, scaleArg, shiftArg, anchorArg);
+    if (opts.fit_bbox) {
+      transform = getFitBoxTransform(opts.fit_bbox, targetPoints, targetShapes, arcs);
+    }
+    if (targetShapes.length > 0) {
+      targetFlags = new Uint8Array(arcs.size());
+      otherFlags = new Uint8Array(arcs.size());
+      countArcsInShapes(targetShapes, targetFlags);
+      if (otherShapes.length > 0) {
+        countArcsInShapes(otherShapes, otherFlags);
+        applyArrayMask(otherFlags, targetFlags);
+        dataset.arcs = duplicateSelectedArcs(otherShapes, arcs, otherFlags);
+      }
+      dataset.arcs.transformPoints(function(x, y, arcId) {
+        if (arcId < targetFlags.length && targetFlags[arcId] > 0) {
+          return transform(x, y);
+        }
+      });
+    }
+    forEachPoint(targetPoints, function(p) {
+      var p2 = transform(p[0], p[1]);
+      p[0] = p2[0];
+      p[1] = p2[1];
+    });
+  };
+
+  function getAffineAnchor(dataset, opts) {
+    var anchor, bounds;
+    if (opts.anchor) {
+      anchor = opts.anchor;
+    } else {
+      // get bounds of selected shapes to calculate center of rotation/scale
+      bounds = getDatasetBounds(dataset);
+      anchor = [bounds.centerX(), bounds.centerY()];
+    }
+    return anchor;
+  }
+
+  // TODO: handle problems with unprojected datasets
+  //   option 1: don't allow affine transformation of unprojected data
+  //   option 2: error if transformed data exceeds valid coordinate range
+  // source: http://mathworld.wolfram.com/AffineTransformation.html
+  function getAffineTransform(rotation, scale, shift, anchor) {
+    var angle = rotation * Math.PI / 180;
+    var a = scale * Math.cos(angle);
+    var b = -scale * Math.sin(angle);
+    return function(x, y) {
+      var x2 = a * (x - anchor[0]) - b * (y - anchor[1]) + shift[0] + anchor[0];
+      var y2 = b * (x - anchor[0]) + a * (y - anchor[1]) + shift[1] + anchor[1];
+      return [x2, y2];
+    };
+  }
+
+  function getFitBoxTransform(bbox, points, shapes, arcs) {
+    var dataset = {
+      arcs: arcs,
+      layers: []
+    };
+    if (points && points.length) {
+      dataset.layers.push({
+        geometry_type: 'point',
+        shapes: points
+      });
+    }
+    if (shapes && shapes.length) {
+      dataset.layers.push({
+        geometry_type: 'polyline',
+        shapes: shapes
+      });
+    }
+    var frame = calcFrameData(dataset, {fit_bbox: bbox});
+    var fromBounds = new Bounds(frame.bbox);
+    var toBounds = new Bounds(frame.bbox2);
+    var fwd = fromBounds.getTransform(toBounds, false);
+    return function(x, y) {
+      return fwd.transform(x, y);
+    };
+  }
+
+  function applyArrayMask(destArr, maskArr) {
+    for (var i=0, n=destArr.length; i<n; i++) {
+      if (maskArr[i] === 0) destArr[i] = 0;
+    }
+  }
+
+  function duplicateSelectedArcs(shapes, arcs, flags) {
+    var arcCount = 0;
+    var vertexCount = 0;
+    var data = arcs.getVertexData();
+    var xx = [], yy = [], nn = [], map = [], n;
+    for (var i=0, len=flags.length; i<len; i++) {
+      if (flags[i] > 0) {
+        map[i] = arcs.size() + arcCount;
+        n = data.nn[i];
+        utils.copyElements(data.xx, data.ii[i], xx, vertexCount, n);
+        utils.copyElements(data.yy, data.ii[i], yy, vertexCount, n);
+        nn.push(n);
+        vertexCount += n;
+        arcCount++;
+      }
+    }
+    forEachArcId(shapes, function(id) {
+      var absId = absArcId(id);
+      if (flags[absId] > 0) {
+        return id < 0 ? ~map[absId] : map[absId];
+      }
+    });
+    return mergeArcs([arcs, new ArcCollection(nn, xx, yy)]);
+  }
+
   const epsilon = 1.1102230246251565e-16;
   const splitter = 134217729;
   const resulterrbound = (3 + 8 * epsilon) * epsilon;
@@ -34876,7 +35124,7 @@ ${svg}
     var ringTest = filterData.filter;
     var removed = 0;
     var pathFilter = function(path, i, paths) {
-      if (ringTest(path)) {
+      if (ringTest(path, i, paths)) {
         removed++;
         return null;
       }
@@ -35016,6 +35264,7 @@ ${svg}
     // or overlapping rings. TODO: try to optimize or remove it for all cases
 
     // skipping shape cleanup when using the experimental fast bbox clipping option
+    // if (!opts.bbox2 && !opts.no_cleanup) {
     if (!opts.bbox2) {
       // clean each target polygon by dissolving its rings
       targetShapes = targetShapes.map(dissolvePolygon);
@@ -35512,7 +35761,7 @@ ${svg}
     } else {
       nodes = new NodeCollection(mergedDataset.arcs);
     }
-    // clipLyr = mergedDataset.layers.pop();
+
     return clipLayersByLayer(targetLayers, clipLyr, nodes, type, opts);
   }
 
@@ -40504,7 +40753,7 @@ ${svg}
 
     function createMeridianPart(x, ymin, ymax) {
       var coords = densifyPathByInterval([[x, ymin], [x, ymax]], precision);
-      meridians.push(graticuleFeature(coords, {type: 'meridian', value: roundCoord$1(x)}));
+      meridians.push(graticuleFeature(coords, {type: 'meridian', value: roundCoord$2(x)}));
     }
 
     function createParallel(y) {
@@ -40514,7 +40763,7 @@ ${svg}
   }
 
   // remove tiny offsets
-  function roundCoord$1(x) {
+  function roundCoord$2(x) {
     return +x.toFixed(3) || 0;
   }
 
@@ -44613,7 +44862,7 @@ ${svg}
     });
   };
 
-  var roundCoord = getRoundingFunction(0.01);
+  var roundCoord$1 = getRoundingFunction(0.01);
 
   function getSymbolFillColor(d) {
     return d.fill || 'magenta';
@@ -44664,8 +44913,8 @@ ${svg}
 
   function roundCoordsForSVG(coords) {
     forEachSymbolCoord(coords, function(p) {
-      p[0] = roundCoord(p[0]);
-      p[1] = roundCoord(p[1]);
+      p[0] = roundCoord$1(p[0]);
+      p[1] = roundCoord$1(p[1]);
     });
   }
 
@@ -45390,7 +45639,7 @@ ${svg}
   // Filter arcs based on an array of thresholds
   function applyArcThresholds(arcs, thresholds) {
     arcs.getVertexData().zz;
-    arcs.forEach2(function(start, n, xx, yy, zz, arcId) {
+    arcs.forEach2(function(arcId, start, n, xx, yy, zz) {
       var arcZ = thresholds[arcId];
       var z;
       for (var i=1; i<n-1; i++) {
@@ -46044,7 +46293,7 @@ ${svg}
     });
   }
 
-  var version = "0.6.109";
+  var version = "0.6.111";
 
   // Parse command line args into commands and run them
   // Function takes an optional Node-style callback. A Promise is returned if no callback is given.
@@ -46376,6 +46625,51 @@ ${svg}
     testCommands: testCommands
   });
 
+  var roundCoord = getRoundingFunction(0.01);
+
+  function stringifyVertex(p) {
+    return ' ' + roundCoord(p[0]) + ' ' + roundCoord(p[1]);
+  }
+
+  function isCubicCtrl(p) {
+    return p.length > 2 && p[2] == 'C';
+  }
+
+  function stringifyPolygonCoords(coords) {
+    var parts = [];
+    for (var i=0; i<coords.length; i++) {
+      parts.push(stringifyLineStringCoords(coords[i]) + ' Z');
+    }
+    return parts.length > 0 ? parts.join(' ') : '';
+  }
+
+  function stringifyLineStringCoords(coords) {
+    if (coords.length === 0) return '';
+    var d = 'M';
+    var fromCurve = false;
+    var p, i, n;
+    for (i=0, n=coords.length; i<n; i++) {
+      p = coords[i];
+      if (isCubicCtrl(p)) {
+        // TODO: add defensive check
+        d += ' C' + stringifyVertex(p) + stringifyVertex(coords[++i]) + stringifyVertex(coords[++i]);
+        fromCurve = true;
+      } else if (fromCurve) {
+        d += ' L' + stringifyVertex(p);
+        fromCurve = false;
+      } else {
+        d += stringifyVertex(p);
+      }
+    }
+    return d;
+  }
+
+  var SvgPathUtils = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    stringifyLineStringCoords: stringifyLineStringCoords,
+    stringifyPolygonCoords: stringifyPolygonCoords
+  });
+
   // Return an array containing points from a path iterator, clipped to a bounding box
   // Currently using this function for clipping styled polygons in the GUI to speed up layer rendering.
   // Artifacts along the edges make this unsuitable for clipping datasets