mapshaper 0.5.75 → 0.5.79

package/mapshaper.js

@@ -1,6 +1,6 @@
 (function () {
 
-  var VERSION = "0.5.74";
+  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);
@@ -1313,9 +1330,10 @@
   }
 
   function logArgs(args) {
-    if (LOGGING && !getStateVar('QUIET') && utils.isArrayLike(args)) {
-      (!STDOUT && console.error || console.log).call(console, formatLogArgs(args));
-    }
+    if (!LOGGING || getStateVar('QUIET') || !utils.isArrayLike(args)) return;
+    var msg = formatLogArgs(args);
+    if (STDOUT) console.log(msg);
+    else console.error(msg);
   }
 
   var Logging = /*#__PURE__*/Object.freeze({
@@ -2967,12 +2985,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 +8175,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 +8252,7 @@
     __proto__: null,
     roundToSignificantDigits: roundToSignificantDigits,
     roundToDigits: roundToDigits,
+    roundToTenths: roundToTenths,
     getRoundingFunction: getRoundingFunction,
     getBoundsPrecisionForDisplay: getBoundsPrecisionForDisplay,
     getRoundedCoordString: getRoundedCoordString,
@@ -10270,6 +10314,12 @@
     };
   }
 
+  /*
+
+
+
+  */
+
   // TODO: use polygon pathfinder shared code
   function collectPolylineArcs(ids, nodes, testArc, useArc) {
     var parts = [];
@@ -11839,7 +11889,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 +13860,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 +15588,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 +15742,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 +15802,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 +15818,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 +15861,6 @@ ${svg}
     __proto__: null,
     exportDelim: exportDelim,
     exportLayerAsDSV: exportLayerAsDSV,
-    formatNumber: formatNumber$1,
-    formatIntlNumber: formatIntlNumber,
     getDelimValueFormatter: getDelimValueFormatter
   });
 
@@ -17050,8 +17224,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 +17249,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 +17653,7 @@ ${svg}
     };
   }
 
-  var supportedDelimiters = ['|', '\t', ',', ';'];
+  var supportedDelimiters = ['|', '\t', ',', ';', ' '];
 
   function isSupportedDelimiter(d) {
     return utils.contains(supportedDelimiters, d);
@@ -17838,9 +18014,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 +19135,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 +19353,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 +19925,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'
@@ -20122,6 +20341,16 @@ ${svg}
       })
       .option('name', nameOpt);
 
+    // parser.command('shapes')
+    //   .describe('convert points to shapes')
+    //   .option('type', {
+    //   })
+    //   .option('size', {
+    //   })
+    //   .option('rotation', {
+    //   })
+
+
     parser.command('subdivide')
       .describe('recursively split a layer using a JS expression')
       .validate(validateExpressionOpt)
@@ -20990,7 +21219,7 @@ ${svg}
     var header = parseHeader(shpFile.readToBinArray(0, 100));
     var shpSize = shpFile.size();
     var RecordClass = new ShpRecordClass(header.type);
-    var shpOffset, recordCount, skippedBytes;
+    var shpOffset, recordCount;
     var shxBin, shxFile;
 
     if (shxSrc) {
@@ -21017,61 +21246,36 @@ ${svg}
 
     // Iterator interface for reading shape records
     this.nextShape = function() {
-      var shape = readNextShape();
-      if (!shape) {
-        if (skippedBytes > 0) {
-          // Encountered in files from natural earth v2.0.0:
-          // ne_10m_admin_0_boundary_lines_land.shp
-          // ne_110m_admin_0_scale_rank.shp
-          verbose("Skipped over " + skippedBytes + " non-data bytes in the .shp file.");
-        }
+      var shape = readNextShape(recordCount);
+      if (shape) {
+        recordCount++;
+      } else {
         shpFile.close();
         reset();
       }
       return shape;
     };
 
-    function readNextShape() {
-      var expectedId = recordCount + 1; // Shapefile ids are 1-based
+    // Returns a shape record or null if no more shapes can be read
+    //
+    function readNextShape(i) {
+      var expectedId = i + 1; // Shapefile ids are 1-based
       var shape, offset;
-      if (done()) return null;
       if (shxBin) {
-        shxBin.position(100 + recordCount * 8);
+        if (shxFile.size() <= 100 + i * 8) return null; // done
+        shxBin.position(100 + i * 8);
         offset = shxBin.readUint32() * 2;
-        if (offset > shpOffset) {
-          skippedBytes += offset - shpOffset;
-        }
+        shape = readIndexedShape(shpFile, offset, expectedId);
       } else {
+        // Reading without a .shx file (returns null at end-of-file)
         offset = shpOffset;
-      }
-      shape = readShapeAtOffset(offset);
-      if (!shape) {
-        // Some in-the-wild .shp files contain junk bytes between records. This
-        // is a problem if the .shx index file is not present.
-        // Here, we try to scan past the junk to find the next record.
-        shape = huntForNextShape(offset, expectedId);
-      }
-      if (shape) {
-        if (shape.id < expectedId) {
-          message("Found a Shapefile record with the same id as a previous record (" + shape.id + ") -- skipping.");
-          return readNextShape();
-        } else if (shape.id > expectedId) {
-          stop("Shapefile contains an out-of-sequence record. Possible data corruption -- bailing.");
-        }
-        recordCount++;
+        shape = readNonIndexedShape(shpFile, offset, expectedId);
       }
       return shape || null;
     }
 
-    function done() {
-      if (shxFile && shxFile.size() <= 100 + recordCount * 8) return true;
-      if (shpOffset + 12 > shpSize) return true;
-      return false;
-    }
-
     function reset() {
       shpOffset = 100;
-      skippedBytes = 0;
       recordCount = 0;
     }
 
@@ -21101,7 +21305,8 @@ ${svg}
       return header;
     }
 
-    function readShapeAtOffset(offset) {
+
+    function readShapeAtOffset(shpFile, offset) {
       var shape = null,
           recordSize, recordType, recordId, goodSize, goodType, bin;
 
@@ -21116,32 +21321,62 @@ ${svg}
         if (goodSize && goodType) {
           bin = shpFile.readToBinArray(offset, recordSize);
           shape = new RecordClass(bin, recordSize);
-          shpOffset = offset + shape.byteLength; // advance read position
         }
       }
       return shape;
     }
 
-    // TODO: add tests
-    // Try to scan past unreadable content to find next record
-    function huntForNextShape(start, id) {
-      var offset = start + 4,
+    function readIndexedShape(shpFile, offset, expectedId) {
+      var shape = readShapeAtOffset(shpFile, offset);
+      if (!shape) {
+        stop('Index of Shapefile record', expectedId, 'in the .shx file is invalid.');
+      }
+      if (shape.id != expectedId) {
+        // stop("Found a Shapefile record with an out-of-sequence id (" + shape.id + ") -- bailing.");
+        message(`Warning: A feature has a different record number in .shx (${expectedId}) and .shp (${shape.id}).`);
+      }
+      // TODO: consider printing verbose message if a .shp file contains garbage bytes
+      // example files:
+      // ne_10m_admin_0_boundary_lines_land.shp
+      // ne_110m_admin_0_scale_rank.shp
+      return shape;
+    }
+
+    // The Shapefile specification does not require records to be densely packed or
+    // in consecutive sequence in the .shp file. This is a problem when the .shx
+    // index file is not present.
+    //
+    // Here, we try to scan past invalid content to find the next record.
+    // Records are required to be in sequential order.
+    //
+    function readNonIndexedShape(shpFile, start, expectedId) {
+      var offset = start,
+          fileSize = shpFile.size(),
           shape = null,
-          bin, recordId, recordType, count;
-      while (offset + 12 <= shpSize) {
+          bin, recordId, recordType, isValidType;
+      while (offset + 12 <= fileSize) {
         bin = shpFile.readToBinArray(offset, 12);
         recordId = bin.bigEndian().readUint32();
         recordType = bin.littleEndian().skipBytes(4).readUint32();
-        if (recordId == id && (recordType == header.type || recordType === 0)) {
-          // we have a likely position, but may still be unparsable
-          shape = readShapeAtOffset(offset);
-          break;
+        isValidType = recordType == header.type || recordType === 0;
+        if (!isValidType || recordId != expectedId && recordType === 0) {
+          offset += 4; // keep scanning -- try next integer position
+          continue;
         }
-        offset += 4; // try next integer position
+        shape = readShapeAtOffset(shpFile, offset);
+        if (!shape) break; // probably ran into end of file
+        shpOffset = offset + shape.byteLength; // update
+        if (recordId == expectedId) break; // found an apparently valid shape
+        if (recordId < expectedId) {
+          message("Found a Shapefile record with the same id as a previous record (" + shape.id + ") -- skipping.");
+          offset += shape.byteLength;
+        } else {
+          stop("Shapefile contains an out-of-sequence record. Possible data corruption -- bailing.");
+        }
+      }
+      if (shape && offset > start) {
+        verbose("Skipped over " + (offset - start) + " non-data bytes in the .shp file.");
       }
-      count = shape ? offset - start : shpSize - start;
-      // debug('Skipped', count, 'bytes', shape ? 'before record ' + id : 'at the end of the file');
-      skippedBytes += count;
       return shape;
     }
   }
@@ -26263,97 +26498,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 +26791,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 +29921,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 +31617,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 +31859,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 +31921,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 +32233,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 +34200,6 @@ ${svg}
 
 
 
-  function formatNumber(val) {
-    return val + '';
-  }
-
   function maxChars(arr) {
     return arr.reduce(function(memo, str) {
       var w = stringDisplayWidth(str);
@@ -33843,14 +34223,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)) {
@@ -34403,11 +34783,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;
@@ -34659,6 +35034,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;
@@ -34982,7 +35389,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) {
@@ -34990,9 +35397,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;
@@ -35004,6 +35420,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'));
@@ -37182,13 +37602,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);
@@ -37220,15 +37647,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) {
@@ -38028,6 +38464,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);