mapshaper 0.5.74 → 0.5.78

package/www/mapshaper.js

@@ -1,6 +1,6 @@
 (function () {
 
-  var VERSION = "0.5.72";
+  var VERSION = "0.5.78";
 
 
   var utils = /*#__PURE__*/Object.freeze({
@@ -52,6 +52,7 @@
     get initializeArray () { return initializeArray; },
     get replaceArray () { return replaceArray; },
     get repeatString () { return repeatString; },
+    get splitLines () { return splitLines; },
     get pluralSuffix () { return pluralSuffix; },
     get endsWith () { return endsWith; },
     get lpad () { return lpad; },
@@ -61,7 +62,9 @@
     get rtrim () { return rtrim; },
     get addThousandsSep () { return addThousandsSep; },
     get numToStr () { return numToStr; },
-    get formatNumber () { return formatNumber$2; },
+    get formatNumber () { return formatNumber; },
+    get formatIntlNumber () { return formatIntlNumber; },
+    get formatNumberForDisplay () { return formatNumberForDisplay; },
     get shuffle () { return shuffle; },
     get sortOn () { return sortOn; },
     get genericSort () { return genericSort; },
@@ -532,6 +535,10 @@
     return str;
   }
 
+  function splitLines(str) {
+    return str.split(/\r?\n/);
+  }
+
   function pluralSuffix(count) {
     return count != 1 ? 's' : '';
   }
@@ -584,7 +591,16 @@
     return decimals >= 0 ? num.toFixed(decimals) : String(num);
   }
 
-  function formatNumber$2(num, decimals, nullStr, showPos) {
+  function formatNumber(val) {
+    return val + '';
+  }
+
+  function formatIntlNumber(val) {
+    var str = formatNumber(val);
+    return '"' + str.replace('.', ',') + '"'; // need to quote if comma-delimited
+  }
+
+  function formatNumberForDisplay(num, decimals, nullStr, showPos) {
     var fmt;
     if (isNaN(num)) {
       fmt = nullStr || '-';
@@ -862,7 +878,8 @@
         str = str.toUpperCase();
     }
     else if (isNumber) {
-      str = numToStr(val, isInt ? 0 : decimals);
+      // str = formatNumberForDisplay(val, isInt ? 0 : decimals);
+      str = numToStr(val, decimals);
       if (str[0] == '-') {
         isNeg = true;
         str = str.substr(1);
@@ -2967,12 +2984,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 +8174,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 +8251,7 @@
     __proto__: null,
     roundToSignificantDigits: roundToSignificantDigits,
     roundToDigits: roundToDigits,
+    roundToTenths: roundToTenths,
     getRoundingFunction: getRoundingFunction,
     getBoundsPrecisionForDisplay: getBoundsPrecisionForDisplay,
     getRoundedCoordString: getRoundedCoordString,
@@ -10270,6 +10313,12 @@
     };
   }
 
+  /*
+
+
+
+  */
+
   // TODO: use polygon pathfinder shared code
   function collectPolylineArcs(ids, nodes, testArc, useArc) {
     var parts = [];
@@ -11839,7 +11888,6 @@
   });
 
   // Map positive or negative integer ids to non-negative integer ids
-
   function IdLookupIndex(n, clearable) {
     var fwdIndex = new Int32Array(n);
     var revIndex = new Int32Array(n);
@@ -13811,7 +13859,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 + ')';
     }
@@ -15539,6 +15587,139 @@ ${svg}
     }];
   }
 
+  function exportRecordsAsFixedWidthString(fields, records, opts) {
+    var rows = [], col;
+    for (var i=0; i<fields.length; i++) {
+      col = formatFixedWidthColumn(fields[i], records, opts);
+      if (i === 0) {
+        rows = col;
+      } else for (var j=0; j<rows.length; j++) {
+        rows[j] += ' ' + col[j];
+      }
+    }
+    return rows.join('\n');
+  }
+
+  function formatFixedWidthColumn(field, records, opts) {
+    var arr = [],
+        maxLen = field.length,
+        n = records.length,
+        i, val;
+    arr.push(field);
+    for (i=0; i<n; i++) {
+      val = formatFixedWidthValue(records[i][field], opts);
+      maxLen = Math.max(maxLen, val.length);
+      arr.push(val);
+    }
+    for (i=0; i<arr.length; i++) {
+      arr[i] = arr[i].padEnd(maxLen, ' ');
+    }
+    return arr;
+  }
+
+  function formatFixedWidthValue(val, opts) {
+    // TODO: remove duplication with mapshaper-delim-export.js
+    var s;
+    if (val == null) {
+      s = '';
+    } else if (utils.isString(val)) {
+      s = val; // TODO: handle wide characters, newlines etc.
+    } else if (utils.isNumber(val)) {
+      s = opts.decimal_comma ? utils.formatIntlNumber(val) : utils.formatNumber(val);
+    } else if (utils.isObject(val)) {
+      s = JSON.stringify(val);
+    } else {
+      s = val + '';
+    }
+    return s;
+  }
+
+
+  function readFixedWidthRecords(reader, opts) {
+    var str = reader.toString(opts.encoding || 'ascii');
+    return readFixedWidthRecordsFromString(str, opts);
+  }
+
+  function readFixedWidthRecordsFromString(str, ops) {
+    var fields = parseFixedWidthInfo(str.substring(0, 2000));
+    if (!fields) return [];
+    var lines = utils.splitLines(str);
+    if (lines[lines.length - 1] === '') lines.pop(); // handle newline at end of string
+    var records = [];
+    for (var i=1; i<lines.length; i++) {
+      records.push(parseFixedWidthLine(lines[i], fields));
+    }
+    return records;
+  }
+
+  function parseFixedWidthInfo(sample) {
+    var lines = utils.splitLines(sample);
+    if (lines.length > 2) lines.pop(); // remove possible partial line
+    var n = getMaxLineLength(lines);
+    var headerLine = lines[0];
+    var colInfo = [];
+    var colStart = 0;
+    var inContent = false;
+    var inHeader = false;
+    var isContentChar, isHeaderChar, isColStart, colEnd;
+    for (var i=0; i<=n; i++) {
+      isHeaderChar = testContentChar(headerLine, i);
+      isContentChar = !testEmptyCol(lines, i);
+      isColStart = isHeaderChar && !inHeader;
+      if (isColStart && inContent) {
+        // all lines should have a space char in the position right before a header starts
+        return null;
+      }
+      if (i == n || i > 0 && isColStart) {
+        colEnd = i == n ? undefined : i-1;
+        colInfo.push({
+          name: readValue$1(headerLine, colStart, colEnd),
+          end: colEnd,
+          start: colStart
+        });
+        colStart = i;
+      }
+      inContent = isContentChar;
+      inHeader = isHeaderChar;
+    }
+    return colInfo.length > 0 ? colInfo : null;
+  }
+
+  function getMaxLineLength(lines) {
+    var max = 0;
+    for (var i=0; i<lines.length; i++) {
+      max = Math.max(max, lines[i].length);
+    }
+    return max;
+  }
+
+  function readValue$1(line, start, end) {
+    return line.substring(start, end).trim();
+  }
+
+  function parseFixedWidthLine(str, fields) {
+    var obj = {}, field;
+    for (var i=0; i<fields.length; i++) {
+      field = fields[i];
+      obj[field.name] = readValue$1(str, field.start, field.end);
+    }
+    return obj;
+  }
+
+  function testContentChar(str, i) {
+    return i < str.length && str[i] !== ' ';
+  }
+
+  // return true iff all samples are blank at index i
+  function testEmptyCol(samples, i) {
+    var line;
+    for (var j=0; j<samples.length; j++) {
+      line = samples[j];
+      if (testContentChar(line, i)) return false;
+    }
+    return true;
+  }
+
   // Generate output content from a dataset object
   function exportDelim(dataset, opts) {
     var delim = getExportDelimiter(dataset.info, opts),
@@ -15560,6 +15741,9 @@ ${svg}
     var encoding = opts.encoding || 'utf8';
     var records = lyr.data.getRecords();
     var fields = findFieldNames(records, opts.field_order);
+    if (delim == ' ') {
+      return exportRecordsAsFixedWidthString(fields, records, opts);
+    }
     var formatRow = getDelimRowFormatter(fields, delim, opts);
     // exporting utf8 and ascii text as string by default (for now)
     var exportAsString = encodingIsUtf8(encoding) && !opts.to_buffer &&
@@ -15617,15 +15801,6 @@ ${svg}
     };
   }
 
-  function formatNumber$1(val) {
-    return val + '';
-  }
-
-  function formatIntlNumber(val) {
-    var str = formatNumber$1(val);
-    return '"' + str.replace('.', ',') + '"'; // need to quote if comma-delimited
-  }
-
   function getDelimValueFormatter(delim, opts) {
     var dquoteRxp = new RegExp('["\n\r' + delim + ']');
     var decimalComma = opts && opts.decimal_comma || false;
@@ -15642,7 +15817,7 @@ ${svg}
       } else if (utils.isString(val)) {
         s = formatString(val);
       } else if (utils.isNumber(val)) {
-        s = decimalComma ? formatIntlNumber(val) : formatNumber$1(val);
+        s = decimalComma ? utils.formatIntlNumber(val) : utils.formatNumber(val);
       } else if (utils.isObject(val)) {
         s = formatString(JSON.stringify(val));
       } else {
@@ -15685,8 +15860,6 @@ ${svg}
     __proto__: null,
     exportDelim: exportDelim,
     exportLayerAsDSV: exportLayerAsDSV,
-    formatNumber: formatNumber$1,
-    formatIntlNumber: formatIntlNumber,
     getDelimValueFormatter: getDelimValueFormatter
   });
 
@@ -17050,8 +17223,9 @@ ${svg}
   //
   // TODO: confirm compatibility with all supported encodings
   function readDelimRecords(reader, delim, optsArg) {
+    var opts = optsArg || {};
+    if (delim == ' ') return readFixedWidthRecords(reader, opts);
     var reader2 = new Reader2(reader),
-        opts = optsArg || {},
         headerStr = readLinesAsString(reader2, getDelimHeaderLines(opts), opts.encoding),
         header = parseDelimHeaderSection(headerStr, delim, opts),
         convertRowArr = getRowConverter(header.import_fields),
@@ -17074,6 +17248,7 @@ ${svg}
   // for delimiter characters and newlines. Input size is limited by the maximum
   // string size.
   function readDelimRecordsFromString(str, delim, opts) {
+    if (delim == ' ') return readFixedWidthRecordsFromString(str, opts);
     var header = parseDelimHeaderSection(str, delim, opts);
     if (header.import_fields.length === 0 || !header.remainder) return [];
     var convert = getRowConverter(header.import_fields);
@@ -17477,7 +17652,7 @@ ${svg}
     };
   }
 
-  var supportedDelimiters = ['|', '\t', ',', ';'];
+  var supportedDelimiters = ['|', '\t', ',', ';', ' '];
 
   function isSupportedDelimiter(d) {
     return utils.contains(supportedDelimiters, d);
@@ -17838,9 +18013,21 @@ ${svg}
   }
 
   function cleanArgv(argv) {
-    argv = argv.map(function(s) {return s.trim();}); // trim whitespace
+    // Note: original trim caused some quoted spaces to be removed
+    // (e.g. bash shell seems to convert [delimiter=" "] to [delimiter= ],
+    //  which then got trimmed to [delimiter=] below)
+    //// argv = argv.map(function(s) {return s.trim();}); // trim whitespace
+
+    // Updated: don't trim space from tokens like [delimeter= ]
+    argv = argv.map(function(s) {
+      if (!/= $/.test(s)) {
+        s = s.trimEnd();
+      }
+      s = s.trimStart();
+      return s;
+    });
     argv = argv.filter(function(s) {return s !== '';}); // remove empty tokens
-    // removing trimQuotes() call... now, strings like 'name="Meg"' will no longer
+    // Note: removing trimQuotes() call... now, strings like 'name="Meg"' will no longer
     // be parsed the same way as name=Meg and name="Meg"
     //// argv = argv.map(utils.trimQuotes); // remove one level of single or dbl quotes
     return argv;
@@ -18947,6 +19134,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', {
@@ -19143,6 +19352,10 @@ ${svg}
       .option('keep-shapes', {
         type: 'flag'
       })
+      .option('ids', {
+        // describe: 'filter on a list of feature ids',
+        type: 'numbers'
+      })
       .option('cleanup', {type: 'flag'}) // TODO: document
       .option('name', nameOpt)
       .option('target', targetOpt)
@@ -19711,6 +19924,11 @@ ${svg}
         DEFAULT: true,
         describe: 'expression or field for grouping features and naming split layers'
       })
+      .option('ids', {
+        // used by gui history to split on selected features
+        // describe: 'split on a list of feature ids',
+        type: 'numbers'
+      })
       .option('apart', {
         describe: 'save output layers to independent datasets',
         type: 'flag'
@@ -26263,97 +26481,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 +26774,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 +29904,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 +31600,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,
@@ -31485,6 +31842,10 @@ ${svg}
       filter = compileValueExpression(opts.expression, lyr, arcs);
     }
 
+    if (opts.ids) {
+      filter = combineFilters(filter, getIdFilter(opts.ids));
+    }
+
     if (opts.remove_empty) {
       filter = combineFilters(filter, getNullGeometryFilter(lyr, arcs));
     }
@@ -31543,6 +31904,13 @@ ${svg}
     lyr.data = filteredRecords ? new DataTable(filteredRecords) : null;
   }
 
+  function getIdFilter(ids) {
+    var set = new Set(ids);
+    return function(i) {
+      return set.has(i);
+    };
+  }
+
   function getNullGeometryFilter(lyr, arcs) {
     var shapes = lyr.shapes;
     if (lyr.geometry_type == 'polygon') {
@@ -31848,7 +32216,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
@@ -33816,10 +34183,6 @@ ${svg}
 
 
 
-  function formatNumber(val) {
-    return val + '';
-  }
-
   function maxChars(arr) {
     return arr.reduce(function(memo, str) {
       var w = stringDisplayWidth(str);
@@ -33843,14 +34206,14 @@ ${svg}
   }
 
   function countIntegralChars(val) {
-    return utils.isNumber(val) ? (formatNumber(val) + '.').indexOf('.') : 0;
+    return utils.isNumber(val) ? (utils.formatNumber(val) + '.').indexOf('.') : 0;
   }
 
   function formatTableValue(val, integralChars) {
     var str;
     if (utils.isNumber(val)) {
       str = utils.lpad("", integralChars - countIntegralChars(val), ' ') +
-        formatNumber(val);
+        utils.formatNumber(val);
     } else if (utils.isString(val)) {
       str = formatString(val);
     } else if (utils.isDate(val)) {
@@ -34176,6 +34539,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 +34627,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 +34766,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 +35017,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 +35372,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 +35380,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 +35403,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'));
@@ -37144,13 +37585,20 @@ ${svg}
 
   // @expression: optional field name or expression
   //
-  cmd.splitLayer = function(src, expression, opts) {
-    var lyr0 = opts && opts.no_replace ? copyLayer(src) : src,
+  cmd.splitLayer = function(src, expression, optsArg) {
+    var opts = optsArg || {},
+        lyr0 = opts.no_replace ? copyLayer(src) : src,
         properties = lyr0.data ? lyr0.data.getRecords() : null,
         shapes = lyr0.shapes,
         index = {},
         splitLayers = [],
-        namer = getSplitNameFunction(lyr0, expression);
+        namer;
+
+    if (opts.ids) {
+      namer = getIdSplitFunction(opts.ids);
+    } else {
+      namer = getSplitNameFunction(lyr0, expression);
+    }
 
     // if (splitField) {
     //   internal.requireDataField(lyr0, splitField);
@@ -37182,15 +37630,24 @@ ${svg}
     return splitLayers;
   };
 
+  function getIdSplitFunction(ids) {
+    var set = new Set(ids);
+    return function(i) {
+      return set.has(i) ? '1' : '2';
+    };
+  }
+
+  function getDefaultSplitFunction(lyr) {
+    // if not splitting on an expression and layer is unnamed, name split-apart layers
+    // like: split-1, split-2, ...
+    return function(i) {
+      return (lyr && lyr.name || 'split') + '-' + (i + 1);
+    };
+  }
+
   function getSplitNameFunction(lyr, exp) {
     var compiled;
-    if (!exp) {
-      // if not splitting on an expression and layer is unnamed, name split-apart layers
-      // like: split-1, split-2, ...
-      return function(i) {
-        return (lyr && lyr.name || 'split') + '-' + (i + 1);
-      };
-    }
+    if (!exp) return getDefaultSplitFunction(lyr);
     lyr = {name: lyr.name, data: lyr.data}; // remove shape info
     compiled = compileValueExpression(exp, lyr, null);
     return function(i) {
@@ -37990,6 +38447,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 +39557,8 @@ ${svg}
     TopojsonImport,
     Topology,
     Units,
-    SvgHatch
+    SvgHatch,
+    VertexUtils
   );
 
   // The entry point for the core mapshaper module