mapshaper 0.5.73 → 0.5.77

package/www/mapshaper.js

@@ -1,6 +1,6 @@
 (function () {
 
-  var VERSION = "0.5.72";
+  var VERSION = "0.5.76";
 
 
   var utils = /*#__PURE__*/Object.freeze({
@@ -2967,12 +2967,33 @@
         orient2D(cx, cy, dx, dy, bx, by) <= 0;
   }
 
+  // Useful for determining if a segment that intersects another segment is
+  // entering or leaving an enclosed buffer area
+  // returns -1 if angle of p1p2 -> p3p4 is counter-clockwise (left turn)
+  // returns 1 if angle is clockwise
+  // return 0 if segments are collinear
+  function segmentTurn(p1, p2, p3, p4) {
+    var ax = p1[0],
+        ay = p1[1],
+        bx = p2[0],
+        by = p2[1],
+        // shift p3p4 segment to start at p2
+        dx = bx - p3[0],
+        dy = by - p3[1],
+        cx = p4[0] + dx,
+        cy = p4[1] + dy,
+        orientation = orient2D(ax, ay, bx, by, cx, cy);
+      if (!orientation) return 0;
+      return orientation < 0 ? 1 : -1;
+  }
+
   var SegmentGeom = /*#__PURE__*/Object.freeze({
     __proto__: null,
     segmentIntersection: segmentIntersection,
     findClosestPointOnSeg: findClosestPointOnSeg,
     orient2D: orient2D,
-    segmentHit: segmentHit
+    segmentHit: segmentHit,
+    segmentTurn: segmentTurn
   });
 
   var geom = Object.assign({}, Geom, PolygonGeom, PathGeom, SegmentGeom, PolygonCentroid);
@@ -8136,10 +8157,14 @@
   }
 
   function roundToDigits(n, d) {
-    return +n.toFixed(d);
+    return +n.toFixed(d); // string conversion makes this slow
   }
 
-  // inc: Rounding incrememnt (e.g. 0.001 rounds to thousandths)
+  function roundToTenths(n) {
+    return (Math.round(n * 10)) / 10;
+  }
+
+  // inc: Rounding increment (e.g. 0.001 rounds to thousandths)
   function getRoundingFunction(inc) {
     if (!utils.isNumber(inc) || inc === 0) {
       error("Rounding increment must be a non-zero number.");
@@ -8209,6 +8234,7 @@
     __proto__: null,
     roundToSignificantDigits: roundToSignificantDigits,
     roundToDigits: roundToDigits,
+    roundToTenths: roundToTenths,
     getRoundingFunction: getRoundingFunction,
     getBoundsPrecisionForDisplay: getBoundsPrecisionForDisplay,
     getRoundedCoordString: getRoundedCoordString,
@@ -13811,7 +13837,7 @@
   var symbolRenderers = {};
 
   function getTransform(xy, scale) {
-    var str = 'translate(' + xy[0] + ' ' + xy[1] + ')';
+    var str = 'translate(' + roundToTenths(xy[0]) + ' ' + roundToTenths(xy[1]) + ')';
     if (scale && scale != 1) {
       str += ' scale(' + scale + ')';
     }
@@ -18947,6 +18973,28 @@ ${svg}
           '$ mapshaper data.json -colorizer name=getColor nodata=#eee breaks=20,40 \\\n' +
           '  colors=#e0f3db,#a8ddb5,#43a2ca -each \'fill = getColor(RATING)\' -o output.json');
 
+    parser.command('dashlines')
+      .describe('split lines into sections, with or without a gap')
+      .oldAlias('split-lines')
+      .option('dash-length', {
+        type: 'distance',
+        describe: 'length of split-apart lines (e.g. 200km)'
+      })
+      .option('gap-length', {
+        type: 'distance',
+        describe: 'length of gaps between dashes (default is 0)'
+      })
+      .option('scaled', {
+        type: 'flag',
+        describe: 'scale dashes and gaps to prevent partial dashes'
+      })
+      .option('planar', {
+        type: 'flag',
+        describe: 'use planar geometry'
+      })
+      .option('where', whereOpt)
+      .option('target', targetOpt);
+
     parser.command('define')
       // .describe('define expression variables')
       .option('expression', {
@@ -26263,97 +26311,6 @@ ${svg}
       geom.segmentIntersection(a[0], a[1], b[0], b[1], bb.xmax, bb.ymin, bb.xmin, bb.ymin));
   }
 
-  function getGeodesic(P) {
-    if (!isLatLngCRS(P)) error('Expected an unprojected CRS');
-    var f = P.es / (1 + Math.sqrt(P.one_es));
-    var GeographicLib = require('mproj').internal.GeographicLib;
-    return new GeographicLib.Geodesic.Geodesic(P.a, f);
-  }
-
-  function getPlanarSegmentEndpoint(x, y, bearing, meterDist) {
-    var rad = bearing / 180 * Math.PI;
-    var dx = Math.sin(rad) * meterDist;
-    var dy = Math.cos(rad) * meterDist;
-    return [x + dx, y + dy];
-  }
-
-  // source: https://github.com/mapbox/cheap-ruler/blob/master/index.js
-  function fastGeodeticSegmentFunction(lng, lat, bearing, meterDist) {
-    var D2R = Math.PI / 180;
-    var cos = Math.cos(lat * D2R);
-    var cos2 = 2 * cos * cos - 1;
-    var cos3 = 2 * cos * cos2 - cos;
-    var cos4 = 2 * cos * cos3 - cos2;
-    var cos5 = 2 * cos * cos4 - cos3;
-    var kx = (111.41513 * cos - 0.09455 * cos3 + 0.00012 * cos5) * 1000;
-    var ky = (111.13209 - 0.56605 * cos2 + 0.0012 * cos4) * 1000;
-    var bearingRad = bearing * D2R;
-    var lat2 = lat + Math.cos(bearingRad) * meterDist / ky;
-    var lng2 = lng + Math.sin(bearingRad) * meterDist / kx;
-    return [lng2, lat2];
-  }
-
-  function getGeodeticSegmentFunction(P) {
-    if (!isLatLngCRS(P)) {
-      return getPlanarSegmentEndpoint;
-    }
-    var g = getGeodesic(P);
-    return function(lng, lat, bearing, meterDist) {
-      var o = g.Direct(lat, lng, bearing, meterDist);
-      var p = [o.lon2, o.lat2];
-      return p;
-    };
-  }
-
-  function getFastGeodeticSegmentFunction(P) {
-    // CAREFUL: this function has higher error at very large distances and at the poles
-    // also, it wouldn't work for other planets than Earth
-    return isLatLngCRS(P) ? fastGeodeticSegmentFunction : getPlanarSegmentEndpoint;
-  }
-
-  // Useful for determining if a segment that intersects another segment is
-  // entering or leaving an enclosed buffer area
-  // returns -1 if angle of p1p2 -> p3p4 is counter-clockwise (left turn)
-  // returns 1 if angle is clockwise
-  // return 0 if segments are collinear
-  function segmentTurn(p1, p2, p3, p4) {
-    var ax = p1[0],
-        ay = p1[1],
-        bx = p2[0],
-        by = p2[1],
-        // shift p3p4 segment to start at p2
-        dx = bx - p3[0],
-        dy = by - p3[1],
-        cx = p4[0] + dx,
-        cy = p4[1] + dy,
-        orientation = geom.orient2D(ax, ay, bx, by, cx, cy);
-      if (!orientation) return 0;
-      return orientation < 0 ? 1 : -1;
-  }
-
-  function bearingDegrees(a, b, c, d) {
-    return geom.bearing(a, b, c, d) * 180 / Math.PI;
-  }
-
-  function bearingDegrees2D(a, b, c, d) {
-    return geom.bearing2D(a, b, c, d) * 180 / Math.PI;
-  }
-
-  // return function to calculate bearing of a segment in degrees
-  function getBearingFunction(dataset) {
-    var P = getDatasetCRS(dataset);
-    return isLatLngCRS(P) ? bearingDegrees : bearingDegrees2D;
-  }
-
-  var Geodesic = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    getPlanarSegmentEndpoint: getPlanarSegmentEndpoint,
-    getGeodeticSegmentFunction: getGeodeticSegmentFunction,
-    getFastGeodeticSegmentFunction: getFastGeodeticSegmentFunction,
-    segmentTurn: segmentTurn,
-    getBearingFunction: getBearingFunction
-  });
-
   function getPolylineBufferMaker2(arcs, geod, getBearing, opts) {
     var makeLeftBuffer = getPathBufferMaker2(arcs, geod, getBearing, opts);
     var geomType = opts.geometry_type;
@@ -26647,6 +26604,101 @@ ${svg}
     };
   }
 
+  // GeographicLib docs: https://geographiclib.sourceforge.io/html/js/
+  //   https://geographiclib.sourceforge.io/html/js/module-GeographicLib_Geodesic.Geodesic.html
+  //   https://geographiclib.sourceforge.io/html/js/tutorial-2-interface.html
+  function getGeodesic(P) {
+    if (!isLatLngCRS(P)) error('Expected an unprojected CRS');
+    var f = P.es / (1 + Math.sqrt(P.one_es));
+    var GeographicLib = require('mproj').internal.GeographicLib;
+    return new GeographicLib.Geodesic.Geodesic(P.a, f);
+  }
+
+  function interpolatePoint2D(ax, ay, bx, by, k) {
+    var j = 1 - k;
+    return [ax * j + bx * k, ay * j + by * k];
+  }
+
+  function getInterpolationFunction(P) {
+    var spherical = P && isLatLngCRS(P);
+    if (!spherical) return interpolatePoint2D;
+    var geod = getGeodesic(P);
+    return function(lng, lat, lng2, lat2, k) {
+      var r = geod.Inverse(lat, lng, lat2, lng2);
+      var dist = r.s12 * k;
+      var r2 = geod.Direct(lat, lng, r.azi1, dist);
+      return [r2.lon2, r2.lat2];
+    };
+  }
+
+  function getPlanarSegmentEndpoint(x, y, bearing, meterDist) {
+    var rad = bearing / 180 * Math.PI;
+    var dx = Math.sin(rad) * meterDist;
+    var dy = Math.cos(rad) * meterDist;
+    return [x + dx, y + dy];
+  }
+
+  // source: https://github.com/mapbox/cheap-ruler/blob/master/index.js
+  function fastGeodeticSegmentFunction(lng, lat, bearing, meterDist) {
+    var D2R = Math.PI / 180;
+    var cos = Math.cos(lat * D2R);
+    var cos2 = 2 * cos * cos - 1;
+    var cos3 = 2 * cos * cos2 - cos;
+    var cos4 = 2 * cos * cos3 - cos2;
+    var cos5 = 2 * cos * cos4 - cos3;
+    var kx = (111.41513 * cos - 0.09455 * cos3 + 0.00012 * cos5) * 1000;
+    var ky = (111.13209 - 0.56605 * cos2 + 0.0012 * cos4) * 1000;
+    var bearingRad = bearing * D2R;
+    var lat2 = lat + Math.cos(bearingRad) * meterDist / ky;
+    var lng2 = lng + Math.sin(bearingRad) * meterDist / kx;
+    return [lng2, lat2];
+  }
+
+  function getGeodeticSegmentFunction(P) {
+    if (!isLatLngCRS(P)) {
+      return getPlanarSegmentEndpoint;
+    }
+    var g = getGeodesic(P);
+    return function(lng, lat, bearing, meterDist) {
+      var o = g.Direct(lat, lng, bearing, meterDist);
+      var p = [o.lon2, o.lat2];
+      return p;
+    };
+  }
+
+  function getFastGeodeticSegmentFunction(P) {
+    // CAREFUL: this function has higher error at very large distances and at the poles
+    // also, it wouldn't work for other planets than Earth
+    return isLatLngCRS(P) ? fastGeodeticSegmentFunction : getPlanarSegmentEndpoint;
+  }
+
+
+  function bearingDegrees(a, b, c, d) {
+    return geom.bearing(a, b, c, d) * 180 / Math.PI;
+  }
+
+  function bearingDegrees2D(a, b, c, d) {
+    return geom.bearing2D(a, b, c, d) * 180 / Math.PI;
+  }
+
+  // return function to calculate bearing of a segment in degrees
+  function getBearingFunction(dataset) {
+    var P = getDatasetCRS(dataset);
+    return isLatLngCRS(P) ? bearingDegrees : bearingDegrees2D;
+  }
+
+  var Geodesic = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    interpolatePoint2D: interpolatePoint2D,
+    getInterpolationFunction: getInterpolationFunction,
+    getPlanarSegmentEndpoint: getPlanarSegmentEndpoint,
+    getGeodeticSegmentFunction: getGeodeticSegmentFunction,
+    getFastGeodeticSegmentFunction: getFastGeodeticSegmentFunction,
+    bearingDegrees: bearingDegrees,
+    bearingDegrees2D: bearingDegrees2D,
+    getBearingFunction: getBearingFunction
+  });
+
   function makePolylineBuffer(lyr, dataset, opts) {
     var geojson = makeShapeBufferGeoJSON(lyr, dataset, opts);
     var dataset2 = importGeoJSON(geojson, {});
@@ -29682,6 +29734,178 @@ ${svg}
     getColorizerFunction: getColorizerFunction
   });
 
+  function expressionUsesGeoJSON(exp) {
+    return exp.includes('this.geojson');
+  }
+
+  function getFeatureEditor(lyr, dataset) {
+    var changed = false;
+    var api = {};
+    // need to copy attribute to avoid circular references if geojson is assigned
+    // to a data property.
+    var copy = copyLayer(lyr);
+    var features = exportLayerAsGeoJSON(copy, dataset, {}, true);
+
+    api.get = function(i) {
+      return features[i];
+    };
+
+    api.set = function(feat, i) {
+      changed = true;
+      if (utils.isString(feat)) {
+        feat = JSON.parse(feat);
+      }
+      features[i] = GeoJSON.toFeature(feat); // TODO: validate
+    };
+
+    api.done = function() {
+      if (!changed) return; // read-only expression
+      // TODO: validate number of features, etc.
+      var geojson = {
+        type: 'FeatureCollection',
+        features: features
+      };
+
+      // console.log(JSON.stringify(geojson, null, 2))
+      return importGeoJSON(geojson);
+    };
+    return api;
+  }
+
+  cmd.dashlines = function(lyr, dataset, opts) {
+    var crs = getDatasetCRS(dataset);
+    var defs = getStateVar('defs');
+    var exp = `this.geojson = splitFeature(this.geojson)`;
+    requirePolylineLayer(lyr);
+    defs.splitFeature = getSplitFeatureFunction(crs, opts);
+    cmd.evaluateEachFeature(lyr, dataset, exp, opts);
+    delete defs.splitFeature;
+  };
+
+  function getSplitFeatureFunction(crs, opts) {
+    var dashLen = opts.dash_length ? convertDistanceParam(opts.dash_length, crs) : 0;
+    var gapLen = opts.gap_length ? convertDistanceParam(opts.gap_length, crs) : 0;
+    if (dashLen > 0 === false) {
+      stop('Missing required dash-length parameter');
+    }
+    if (gapLen >= 0 == false) {
+      stop('Invalid gap-length option');
+    }
+    var splitLine = getSplitLineFunction(crs, dashLen, gapLen, opts);
+    return function(feat) {
+      var geom = feat.geometry;
+      if (!geom) return feat;
+      if (geom.type == 'LineString') {
+        geom.type = 'MultiLineString';
+        geom.coordinates = [geom.coordinates];
+      }
+      if (geom.type != 'MultiLineString') {
+        error('Unexpected geometry:', geom.type);
+      }
+      geom.coordinates = geom.coordinates.reduce(function(memo, coords) {
+        try {
+          var parts = splitLine(coords);
+          memo = memo.concat(parts);
+        } catch(e) {
+          console.error(e);
+          throw e;
+        }
+        return memo;
+      }, []);
+
+      return feat;
+    };
+  }
+
+  function getSplitLineFunction(crs, dashLen, gapLen, opts) {
+    var planar = !!opts.planar;
+    var interpolate = getInterpolationFunction(planar ? null : crs);
+    var distance =  isLatLngCRS(crs) ? greatCircleDistance : distance2D;
+    var inDash, parts2, interval, scale;
+    function addPart(coords) {
+      if (inDash) parts2.push(coords);
+      if (gapLen > 0) {
+        inDash = !inDash;
+        interval = scale * (inDash ? dashLen : gapLen);
+      }
+    }
+
+    return function splitLineString(coords) {
+      var elapsedDist = 0;
+      var p = coords[0];
+      var coords2 = [p];
+      var segLen, pct, prev;
+      if (opts.scaled) {
+        scale = scaleDashes(dashLen, gapLen, getLineLength(coords, distance));
+      } else {
+        scale = 1;
+      }
+      // init this LineString
+      inDash = gapLen > 0 ? false : true;
+      interval = scale * (inDash ? dashLen : gapLen);
+      if (!inDash) {
+        // start gapped lines with a half-gap
+        // (a half-gap or a half-dash is probably better for rings and intersecting lines)
+        interval *= 0.5;
+      }
+      parts2 = [];
+      for (var i=1, n=coords.length; i<n; i++) {
+        prev = p;
+        p = coords[i];
+        segLen = distance(prev[0], prev[1], p[0], p[1]);
+        if (segLen <= 0) continue;
+        while (elapsedDist + segLen >= interval) {
+          // this segment contains a break either within it or at the far endpoint
+          pct = (interval - elapsedDist) / segLen;
+          if (pct > 0.999 && i == n - 1) {
+            // snap to endpoint (so fp rounding errors don't result in a tiny
+            // last segment)
+            pct = 1;
+          }
+          if (pct < 1) {
+            prev = interpolate(prev[0], prev[1], p[0], p[1], pct);
+          } else {
+            prev = p;
+          }
+          coords2.push(prev);
+          addPart(coords2);
+          // start a new part
+          coords2 = pct < 1 ? [prev] : [];
+          elapsedDist = 0;
+          segLen = (1 - pct) * segLen;
+        }
+        coords2.push(p);
+        elapsedDist += segLen;
+      }
+      if (elapsedDist > 0 && coords2.length > 1) {
+        addPart(coords2);
+      }
+      return parts2;
+    };
+  }
+
+  function getLineLength(coords, distance) {
+    var len = 0;
+    for (var i=1, n=coords.length; i<n; i++) {
+      len += distance(coords[i-1][0], coords[i-1][1], coords[i][0], coords[i][1]);
+    }
+    return len;
+  }
+
+  function scaleDashes(dash, gap, len) {
+    var dash2, gap2;
+    var n = len / (dash + gap); // number of dashes
+    var n1 = Math.floor(n);
+    var n2 = Math.ceil(n);
+    var k1 = len / (n1 * (dash + gap)); // scaled-up dashes, >1
+    var k2 = len / (n2 * (dash + gap)); // scaled-down dashes <1
+    var k = k2;
+    if (k1 < 1/k2 && n1 > 0) {
+      k = k1; // pick the smaller of the two scales
+    }
+    return k;
+  }
+
   // This function creates a continuous mosaic of data values in a
   // given field by assigning data from adjacent polygon features to polygons
   // that contain null values.
@@ -31206,43 +31430,6 @@ ${svg}
     }
   };
 
-  function expressionUsesGeoJSON(exp) {
-    return exp.includes('this.geojson');
-  }
-
-  function getFeatureEditor(lyr, dataset) {
-    var changed = false;
-    var api = {};
-    // need to copy attribute to avoid circular references if geojson is assigned
-    // to a data property.
-    var copy = copyLayer(lyr);
-    var features = exportLayerAsGeoJSON(copy, dataset, {}, true);
-
-    api.get = function(i) {
-      return features[i];
-    };
-
-    api.set = function(feat, i) {
-      changed = true;
-      if (utils.isString(feat)) {
-        feat = JSON.parse(feat);
-      }
-      features[i] = GeoJSON.toFeature(feat); // TODO: validate
-    };
-
-    api.done = function() {
-      if (!changed) return; // read-only expression
-      // TODO: validate number of features, etc.
-      var geojson = {
-        type: 'FeatureCollection',
-        features: features
-      };
-      // console.log(JSON.stringify(geojson, null, 2))
-      return importGeoJSON(geojson);
-    };
-    return api;
-  }
-
   cmd.evaluateEachFeature = function(lyr, dataset, exp, opts) {
     var n = getFeatureCount(lyr),
         arcs = dataset.arcs,
@@ -31848,7 +32035,6 @@ ${svg}
     return joinTableToLayer(targetLyr, polygonLyr.data, joinFunction, opts);
   }
 
-
   function prepJoinLayers(targetLyr, srcLyr) {
     if (!targetLyr.data) {
       // create an empty data table if target layer is missing attributes
@@ -34176,6 +34362,32 @@ ${svg}
     return d;
   }
 
+  function findNearestVertices(p, shp, arcs) {
+    var p2 = findNearestVertex(p[0], p[1], shp, arcs);
+    return findVertexIds(p2.x, p2.y, arcs);
+  }
+
+  // p: point to snap
+  // ids: ids of nearby vertices, possibly including an arc endpoint
+  function snapPointToArcEndpoint(p, ids, arcs) {
+    var p2, p3, 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.
@@ -34238,6 +34450,18 @@ ${svg}
     return minLen < Infinity ? {x: minX, y: minY} : null;
   }
 
+  var VertexUtils = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    findNearestVertices: findNearestVertices,
+    snapPointToArcEndpoint: snapPointToArcEndpoint,
+    findVertexIds: findVertexIds,
+    getVertexCoords: getVertexCoords,
+    vertexIsArcEnd: vertexIsArcEnd,
+    vertexIsArcStart: vertexIsArcStart,
+    setVertexCoords: setVertexCoords,
+    findNearestVertex: findNearestVertex
+  });
+
   // Returns x,y coordinates of the point that is at the midpoint of each polyline feature
   // Uses 2d cartesian geometry
   // TODO: optionally use spherical geometry
@@ -34365,11 +34589,6 @@ ${svg}
     });
   }
 
-  function interpolatePoint2D(ax, ay, bx, by, k) {
-    var j = 1 - k;
-    return [ax * j + bx * k, ay * j + by * k];
-  }
-
   function interpolatePointsAlongArc(ids, arcs, interval) {
     var iter = arcs.getShapeIter(ids);
     var distance = arcs.isPlanar() ? geom.distance2D : geom.greatCircleDistance;
@@ -34621,6 +34840,38 @@ ${svg}
     }
   }
 
+  function pointsFromPolylinesForJoin(lyr, dataset) {
+    var shapes = lyr.shapes.map(function(shp) {
+      return polylineToMidpoints(shp, dataset.arcs);
+    });
+    return {
+      geometry_type: 'point',
+      shapes: shapes,
+      data: lyr.data // TODO copy if needed
+    };
+  }
+
+  function validateOpts(opts) {
+    if (!opts.point_method) {
+      stop('The "point-method" flag is required for polyline-polygon joins');
+    }
+  }
+
+  function joinPolylinesToPolygons(targetLyr, targetDataset, source, opts) {
+    validateOpts(opts);
+    var pointLyr = pointsFromPolylinesForJoin(source.layer, source.dataset);
+    var retn = joinPointsToPolygons(targetLyr, targetDataset.arcs, pointLyr, opts);
+    return retn;
+  }
+
+  function joinPolygonsToPolylines(targetLyr, targetDataset, source, opts) {
+    validateOpts(opts);
+    var pointLyr = pointsFromPolylinesForJoin(targetLyr, targetDataset);
+    var retn = joinPolygonsToPoints(pointLyr, source.layer, source.dataset.arcs, opts);
+    targetLyr.data = pointLyr.data;
+    return retn;
+  }
+
   class TinyQueue {
       constructor(data = [], compare = defaultCompare) {
           this.data = data;
@@ -34944,7 +35195,7 @@ ${svg}
 
   cmd.join = function(targetLyr, targetDataset, src, opts) {
     var srcType, targetType, retn;
-    if (!src || !src.layer.data || !src.dataset) {
+    if (!src || !src.dataset) {
       stop("Missing a joinable data source");
     }
     if (opts.keys) {
@@ -34952,9 +35203,18 @@ ${svg}
       if (opts.keys.length != 2) {
         stop("Expected two key fields: a target field and a source field");
       }
+      if (!src.layer.data) {
+        stop("Source layer is missing attribute data");
+      }
       retn = joinAttributesToFeatures(targetLyr, src.layer.data, opts);
     } else {
       // spatial join
+      if (!src.layer.data) {
+        // KLUDGE -- users might want to join a layer without attributes
+        // to test for intersection... the simplest way to support this is
+        // to add an empty data table to the source layer
+        initDataTable(src.layer);
+      }
       requireDatasetsHaveCompatibleCRS([targetDataset, src.dataset]);
       srcType = src.layer.geometry_type;
       targetType = targetLyr.geometry_type;
@@ -34966,6 +35226,10 @@ ${svg}
         retn = joinPointsToPoints(targetLyr, src.layer, getDatasetCRS(targetDataset), opts);
       } else if (srcType == 'polygon' && targetType == 'polygon') {
         retn = joinPolygonsToPolygons(targetLyr, targetDataset, src, opts);
+      } else if (srcType == 'polyline' && targetType == 'polygon') {
+        retn = joinPolylinesToPolygons(targetLyr, targetDataset, src, opts);
+      } else if (srcType == 'polygon' && targetType == 'polyline') {
+        retn = joinPolygonsToPolylines(targetLyr, targetDataset, src, opts);
       } else {
         stop(utils.format("Unable to join %s geometry to %s geometry",
             srcType || 'null', targetType || 'null'));
@@ -37990,6 +38254,9 @@ ${svg}
       } else if (name == 'colorizer') {
         outputLayers = cmd.colorizer(opts);
 
+      } else if (name == 'dashlines') {
+        applyCommandToEachLayer(cmd.dashlines, targetLayers, targetDataset, opts);
+
       } else if (name == 'define') {
         cmd.define(opts);
 
@@ -39097,7 +39364,8 @@ ${svg}
     TopojsonImport,
     Topology,
     Units,
-    SvgHatch
+    SvgHatch,
+    VertexUtils
   );
 
   // The entry point for the core mapshaper module

package/www/page.css

@@ -32,7 +32,7 @@ html, body {
 body {
 	overflow: hidden;
 	background-color: #fff;
-	font: 14px/1.4 'Source Sans Pro', Helvetica, sans-serif;
+	font: 14px/1.4 'Source Sans Pro', Arial, sans-serif;
 	color: #444;
 	user-select: none;
 	-webkit-user-select: none;