mapshaper 0.5.110 → 0.5.113

package/mapshaper.js

@@ -1,6 +1,6 @@
 (function () {
 
-  var VERSION = "0.5.110";
+  var VERSION = "0.5.113";
 
 
   var utils = /*#__PURE__*/Object.freeze({
@@ -2725,21 +2725,30 @@
     message(utils.format("Snapped %s point%s", snapCount, utils.pluralSuffix(snapCount)));
   }
 
+  function snapCoordsByInterval(arcs, snapDist) {
+    if (snapDist > 0 === false) return 0;
+    var ids = getCoordinateIds(arcs);
+    return snapCoordsInternal(ids, arcs, snapDist);
+  }
+
+  function snapEndpointsByInterval(arcs, snapDist) {
+    if (snapDist > 0 === false) return 0;
+    var ids = getEndpointIds(arcs);
+    return snapCoordsInternal(ids, arcs, snapDist);
+  }
+
   // Snap together points within a small threshold
   //
-  function snapCoordsByInterval(arcs, snapDist) {
+  function snapCoordsInternal(ids, arcs, snapDist) {
     var snapCount = 0,
-        data = arcs.getVertexData(),
-        ids;
+        n = ids.length,
+        data = arcs.getVertexData();
 
-    if (snapDist > 0) {
-      // Get sorted coordinate ids
-      // Consider: speed up sorting -- try bucket sort as first pass.
-      //
-      ids = sortCoordinateIds(data.xx);
-      for (var i=0, n=ids.length; i<n; i++) {
-        snapCount += snapPoint(i, snapDist, ids, data.xx, data.yy);
-      }
+    quicksortIds(data.xx, ids, 0, n-1);
+
+    // Consider: speed up sorting -- try bucket sort as first pass.
+    for (var i=0; i<n; i++) {
+      snapCount += snapPoint(i, snapDist, ids, data.xx, data.yy);
     }
     return snapCount;
 
@@ -2765,13 +2774,25 @@
     }
   }
 
-  function sortCoordinateIds(a) {
-    var n = a.length,
+  function getCoordinateIds(arcs) {
+    var data = arcs.getVertexData(),
+        n = data.xx.length,
         ids = new Uint32Array(n);
     for (var i=0; i<n; i++) {
       ids[i] = i;
     }
-    quicksortIds(a, ids, 0, ids.length-1);
+    return ids;
+  }
+
+  function getEndpointIds(arcs) {
+    var i = 0;
+    var ids = [];
+    var data = arcs.getVertexData();
+    data.nn.forEach(function(n) {
+      if (n > 0 === false) return;
+      ids.push(i, i+n-1);
+      i += n;
+    });
     return ids;
   }
 
@@ -2871,7 +2892,9 @@
     getHighPrecisionSnapInterval: getHighPrecisionSnapInterval,
     snapCoords: snapCoords,
     snapCoordsByInterval: snapCoordsByInterval,
-    sortCoordinateIds: sortCoordinateIds
+    snapEndpointsByInterval: snapEndpointsByInterval,
+    getCoordinateIds: getCoordinateIds,
+    getEndpointIds: getEndpointIds
   });
 
   // Find the intersection between two 2D segments
@@ -9500,6 +9523,140 @@
     };
   }
 
+  // convert targets from [{layers: [...], dataset: <>}, ...] format to
+  // [{layer: <>, dataset: <>}, ...] format
+  function expandCommandTargets(targets) {
+    return targets.reduce(function(memo, target) {
+      target.layers.forEach(function(lyr) {
+        memo.push({layer: lyr, dataset: target.dataset});
+      });
+      return memo;
+    }, []);
+  }
+
+
+  function findCommandTargets(layers, pattern, type) {
+    var targets = [];
+    var matches = findMatchingLayers(layers, pattern, true);
+    if (type) {
+      matches = matches.filter(function(o) {return o.layer.geometry_type == type;});
+    }
+    // assign target_id to matched layers
+    // (kludge so layers can be sorted in the order that they match; used by -o command)
+    layers.forEach(function(o) {o.layer.target_id = -1;});
+    matches.forEach(function(o, i) {o.layer.target_id = i;});
+    return groupLayersByDataset(matches);
+  }
+
+  // arr: array of {layer: <>, dataset: <>} objects
+  function groupLayersByDataset(arr) {
+    var datasets = [];
+    var targets = [];
+    arr.forEach(function(o) {
+      var i = datasets.indexOf(o.dataset);
+      if (i == -1) {
+        datasets.push(o.dataset);
+        targets.push({layers: [o.layer], dataset: o.dataset});
+      } else {
+        targets[i].layers.push(o.layer);
+      }
+    });
+    return targets;
+  }
+
+  // layers: array of {layer: <>, dataset: <>} objects
+  // pattern: is a layer identifier or a comma-sep. list of identifiers.
+  // An identifier is a literal name, a pattern containing "*" wildcard or
+  // a 1-based index (1..n)
+  function findMatchingLayers(layers, pattern, throws) {
+    var matchedLayers = [];
+    var unmatchedIds = [];
+    var index = {};
+    pattern.split(',').forEach(function(subpattern, i) {
+      var test = getLayerMatch(subpattern);
+      var matched = false;
+      layers.forEach(function(o, layerId) {
+        // if (matchedLayers.indexOf(lyr) > -1) return; // performance bottleneck with 1000s of layers
+        if (layerId in index) {
+          matched = true;
+        } else if (test(o.layer, layerId + 1)) {  // layers are 1-indexed
+          matchedLayers.push(o);
+          index[layerId] = true;
+          matched = true;
+        }
+      });
+      if (matched == false) {
+        unmatchedIds.push(subpattern);
+      }
+    });
+    if (throws && unmatchedIds.length) {
+      stop(utils.format('Missing layer%s: %s', unmatchedIds.length == 1 ? '' : 's', unmatchedIds.join(',')));
+    }
+    return matchedLayers;
+  }
+
+  function getLayerMatch(pattern) {
+    var isIndex = utils.isInteger(Number(pattern));
+    var nameRxp = isIndex ? null : utils.wildcardToRegExp(pattern);
+    return function(lyr, i) {
+      return isIndex ? String(i) == pattern : nameRxp.test(lyr.name || '');
+    };
+  }
+
+  function countTargetLayers(targets) {
+    return targets.reduce(function(memo, target) {
+      return memo + target.layers.length;
+    }, 0);
+  }
+
+  // get an identifier for a layer that can be used in a target= option
+  // (returns name if layer has a unique name, or a numerical id)
+  function getLayerTargetId(catalog, lyr) {
+    var nameCount = 0,
+        name = lyr.name,
+        id;
+    catalog.getLayers().forEach(function(o, i) {
+      if (lyr.name && o.layer.name == lyr.name) nameCount++;
+      if (lyr == o.layer) id = String(i + 1);
+    });
+    if (!id) error('Layer not found');
+    return nameCount == 1 ? lyr.name : id;
+  }
+
+  var TargetUtils = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    expandCommandTargets: expandCommandTargets,
+    findCommandTargets: findCommandTargets,
+    groupLayersByDataset: groupLayersByDataset,
+    findMatchingLayers: findMatchingLayers,
+    getLayerMatch: getLayerMatch,
+    countTargetLayers: countTargetLayers,
+    getLayerTargetId: getLayerTargetId
+  });
+
+  function getNullLayerProxy(targets) {
+    var obj = {};
+    var n = countTargetLayers(targets);
+    var getters = {
+      name: error,
+      data: error,
+      type: error,
+      size: error,
+      empty: error,
+      bbox: error
+    };
+    addGetters(obj, getters);
+    obj.field_exists = error;
+    obj.field_type = error;
+    obj.field_includes = error;
+    return obj;
+    function error() {
+      throw Error(`This expression requires a single target layer; Received ${n} layers.`);
+    }
+  }
+
+
+
   // Returns an object representing a layer in a JS expression
   function getLayerProxy(lyr, arcs) {
     var obj = {};
@@ -9509,10 +9666,10 @@
       data: records,
       type: lyr.geometry_type,
       size: getFeatureCount(lyr),
-      empty: getFeatureCount(lyr) === 0
+      empty: getFeatureCount(lyr) === 0,
+      bbox: getBBoxGetter(obj, lyr, arcs)
     };
     addGetters(obj, getters);
-    addBBoxGetter(obj, lyr, arcs);
     obj.field_exists = function(name) {
       return lyr.data && lyr.data.fieldExists(name) ? true : false;
     };
@@ -9541,16 +9698,14 @@
     return ctx;
   }
 
-  function addBBoxGetter(obj, lyr, arcs) {
+  function getBBoxGetter(obj, lyr, arcs) {
     var bbox;
-    addGetters(obj, {
-      bbox: function() {
-        if (!bbox) {
-          bbox = getBBox$1(lyr, arcs);
-        }
-        return bbox;
+    return function() {
+      if (!bbox) {
+        bbox = getBBox$1(lyr, arcs);
       }
-    });
+      return bbox;
+    };
   }
 
   function getBBox$1(lyr, arcs) {
@@ -13589,6 +13744,14 @@
     return p.length > 2 && p[2] == 'C';
   }
 
+  function stringifyPolygonCoords(coords) {
+    var parts = [];
+    for (var i=0; i<coords.length; i++) {
+      parts.push(stringifyLineStringCoords(coords[i]) + ' Z');
+    }
+    return parts.length > 0 ? parts.join(' ') : '';
+  }
+
   function stringifyLineStringCoords(coords) {
     if (coords.length === 0) return '';
     var d = 'M';
@@ -13619,6 +13782,7 @@
 
   var SvgPathUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    stringifyPolygonCoords: stringifyPolygonCoords,
     stringifyLineStringCoords: stringifyLineStringCoords
   });
 
@@ -13886,6 +14050,7 @@
     'stroke-dasharray': 'dasharray',
     'stroke-width': 'number',
     'stroke-opacity': 'number',
+    'stroke-miterlimit': 'number',
     'fill-opacity': 'number',
     'text-anchor': null
   };
@@ -13920,12 +14085,30 @@
 
   var propertiesBySymbolType = {
     polygon: utils.arrayToIndex(commonProperties.concat('fill', 'fill-pattern')),
-    polyline: utils.arrayToIndex(commonProperties.concat('stroke-linecap', 'stroke-linejoin')),
+    polyline: utils.arrayToIndex(commonProperties.concat('stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit')),
     point: utils.arrayToIndex(commonProperties.concat('fill', 'r')),
     label: utils.arrayToIndex(commonProperties.concat(
-      'fill,r,font-family,font-size,text-anchor,font-weight,font-style,letter-spacing,dominant-baseline'.split(',')))
+      'fill,font-family,font-size,text-anchor,font-weight,font-style,letter-spacing,dominant-baseline'.split(',')))
   };
 
+  // symType: point, polygon, polyline, label
+  function applyStyleAttributes(svgObj, symType, rec, filter) {
+    var fields = findPropertiesBySymbolGeom(Object.keys(rec || {}), symType);
+    for (var i=0, n=fields.length; i<n; i++) {
+      if (filter && !filter(fields[i])) continue;
+      setAttribute(svgObj, fields[i], rec[fields[i]]);
+    }
+  }
+
+  function setAttribute(obj, k, v) {
+    if (!obj.properties) obj.properties = {};
+    obj.properties[k] = v;
+    if (k == 'stroke-dasharray' && v) {
+      // kludge for cleaner dashes... make butt the default?
+      obj.properties['stroke-linecap'] = 'butt';
+    }
+  }
+
   function isSupportedSvgStyleProperty(name) {
     return name in stylePropertyTypes;
   }
@@ -14081,6 +14264,7 @@
 
   var SvgProperties = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    applyStyleAttributes: applyStyleAttributes,
     isSupportedSvgStyleProperty: isSupportedSvgStyleProperty,
     findPropertiesBySymbolGeom: findPropertiesBySymbolGeom,
     getSymbolDataAccessor: getSymbolDataAccessor,
@@ -14094,7 +14278,69 @@
     isSvgColor: isSvgColor
   });
 
-  var symbolRenderers = {};
+  function toLabelString(val) {
+    if (val || val === 0 || val === false) return String(val);
+    return '';
+  }
+
+  // Kludge for applying fill and other styles to a <text> element
+  // (for rendering labels in the GUI with the dot in Canvas, not SVG)
+  function renderStyledLabel(rec) {
+    var o = renderLabel(rec);
+    applyStyleAttributes(o, 'label', rec);
+    return o;
+  }
+
+  function renderLabel(rec) {
+    var line = toLabelString(rec['label-text']);
+    var morelines, obj;
+    // Accepting \n (two chars) as an alternative to the newline character
+    // (sometimes, '\n' is not converted to newline, e.g. in a Makefile)
+    // Also accepting <br>
+    var newline = /\n|\\n|<br>/i;
+    var dx = rec.dx || 0;
+    var dy = rec.dy || 0;
+    var properties = {
+      // using x, y instead of dx, dy for shift, because Illustrator doesn't apply
+      // dx value when importing text with text-anchor=end
+      y: dy,
+      x: dx
+    };
+    if (newline.test(line)) {
+      morelines = line.split(newline);
+      line = morelines.shift();
+    }
+    obj = {
+      tag: 'text',
+      value: line,
+      properties: properties
+    };
+    if (morelines) {
+      // multiline label
+      obj.children = [];
+      morelines.forEach(function(line) {
+        var tspan = {
+          tag: 'tspan',
+          value: line,
+          properties: {
+            x: dx,
+            dy: rec['line-height'] || '1.1em'
+          }
+        };
+        obj.children.push(tspan);
+      });
+    }
+    return obj;
+  }
+
+  var SvgLabels = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    renderStyledLabel: renderStyledLabel,
+    renderLabel: renderLabel
+  });
+
+  // convert data records (properties like svg-symbol, label-text, fill, r) to svg symbols
+
 
   function getTransform(xy, scale) {
     var str = 'translate(' + roundToTenths(xy[0]) + ' ' + roundToTenths(xy[1]) + ')';
@@ -14104,27 +14350,197 @@
     return str;
   }
 
-  var SvgCommon = /*#__PURE__*/Object.freeze({
+  var symbolRenderers = {
+    line: line,
+    polygon: polygon,
+    polyline: polyline,
+    circle: circle,
+    square: square,
+    image: image,
+    group: group,
+    label: label
+  };
+
+  // render label and/or point symbol
+  function renderPoint(rec) {
+    var children = [];
+    // var halfSize = rec.r || 0; // radius or half of symbol size
+    if (featureHasSvgSymbol(rec)) {
+      children.push(renderSymbol(rec));
+    }
+    if (featureHasLabel(rec)) {
+      children.push(renderStyledLabel(rec));
+    }
+    var o = children.length > 1 ? {tag: 'g', children: children} : children[0];
+    if (!o) return null;
+    o.properties = o.properties || {};
+    return o;
+  }
+
+  function renderSymbol(d) {
+    if (d['svg-symbol']) {
+      return renderComplexSymbol(d['svg-symbol']);
+    }
+    if (d.r > 0) {
+      return circle(d);
+    }
+    return empty();
+  }
+
+  function renderComplexSymbol(sym, x, y) {
+    if (utils.isString(sym)) {
+      sym = JSON.parse(sym);
+    }
+    if (sym.tag) {
+      // symbol appears to already use mapshaper's svg notation... pass through
+      return sym;
+    }
+    var renderer = symbolRenderers[sym.type];
+    if (!renderer) {
+      message(sym.type ? 'Unknown symbol type: ' + sym.type : 'Symbol is missing a type property');
+      return empty();
+    }
+    var o = renderer(sym, x || 0, y || 0);
+    if (sym.opacity) {
+      o.properties.opacity = sym.opacity;
+    }
+    return o;
+  }
+
+  function empty() {
+    return {tag: 'g', properties: {}, children: []};
+  }
+
+  function circle(d, x, y) {
+    var o = {
+      tag: 'circle',
+      properties: {
+        cx: x || 0,
+        cy: y || 0
+      }
+    };
+    applyStyleAttributes(o, 'point', d);
+    return o;
+  }
+
+  function label(d, x, y) {
+    var o = renderStyledLabel(d);
+    if (x || y) {
+      o.properties.x = x || 0;
+      o.properties.y = y || 0;
+    }
+    return o;
+  }
+
+  function image(d, x, y) {
+    var w = d.width || 20,
+        h = d.height || 20;
+    var o = {
+      tag: 'image',
+      properties: {
+        width: w,
+        height: h,
+        x: (x || 0) - w / 2,
+        y: (y || 0) - h / 2,
+        href: d.href || ''
+      }
+    };
+    return o;
+  }
+
+  function square(d, x, y) {
+    var r = d.r || 0;
+    var o = {
+      tag: 'rect',
+      properties: {
+        x: x - r,
+        y: y - r,
+        width: r * 2,
+        height: r * 2
+      }
+    };
+    applyStyleAttributes(o, 'point', d);
+    return o;
+  }
+
+  function line(d, x, y) {
+    var coords, o;
+    coords = [[x, y], [x + (d.dx || 0), y + (d.dy || 0)]];
+    o = importLineString(coords);
+    applyStyleAttributes(o, 'polyline', d);
+    return o;
+  }
+
+  // polyline coords are like GeoJSON MultiLineString coords: an array of 0 or more paths
+  function polyline(d, x, y) {
+    var coords = d.coordinates || [];
+    var o = importMultiLineString(coords);
+    applyStyleAttributes(o, 'polyline', d);
+    return o;
+  }
+
+  // polygon coords are an array of rings (and holes), like flattened MultiPolygon coords
+  function polygon(d, x, y) {
+    var coords = d.coordinates || [];
+    var o = importPolygon(coords);
+    applyStyleAttributes(o, 'polygon', d);
+    return o;
+  }
+
+  function group(d, x, y) {
+    var parts = (d.parts || []).map(function(o) {
+      var sym = renderComplexSymbol(o, x, y);
+      if (d.chained) {
+      //if (o.chained) {
+        x += (o.dx || 0);
+        y += (o.dy || 0);
+      }
+      return sym;
+    });
+    if (parts.length == 1) return parts[0];
+    return {
+      tag: 'g',
+      children: parts
+    };
+  }
+
+  var SvgSymbols = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    getTransform: getTransform,
     symbolRenderers: symbolRenderers,
-    getTransform: getTransform
+    renderPoint: renderPoint
   });
 
+  var geojsonImporters = {
+    Point: importPoint,
+    Polygon: importPolygon,
+    LineString: importLineString,
+    MultiPoint: importMultiPoint,
+    MultiLineString: importMultiLineString,
+    MultiPolygon: importMultiPolygon
+  };
+
   function importGeoJSONFeatures(features, opts) {
     opts = opts || {};
     return features.map(function(obj, i) {
       var geom = obj.type == 'Feature' ? obj.geometry : obj; // could be null
       var geomType = geom && geom.type;
+      var msType = GeoJSON.translateGeoJSONType(geomType);
+      var d = obj.properties || {};
       var svgObj = null;
       if (geomType && geom.coordinates) {
-        svgObj = geojsonImporters[geomType](geom.coordinates, obj.properties, opts);
+        svgObj = geojsonImporters[geomType](geom.coordinates, d);
       }
       if (!svgObj) {
         return {tag: 'g'}; // empty element
-      }
-      // TODO: fix error caused by null svgObj (caused by e.g. MultiPolygon with [] coordinates)
-      if (obj.properties) {
-        applyStyleAttributes(svgObj, geomType, obj.properties);
+      } else if (msType == 'polyline' || msType == 'polygon') {
+        applyStyleAttributes(svgObj, msType, d);
+      } else if (msType == 'point' && isSimpleCircle(d)) {
+        // kludge -- maintains bw compatibility/passes tests -- style attributes
+        // are applied to the <g> container, 'r' property is applied to circle
+        applyStyleAttributes(svgObj, msType, d, simpleCircleFilter);
+      } else {
+        // other point symbols: attributes are complicated, added downstream
       }
       if ('id' in obj) {
         if (!svgObj.properties) {
@@ -14136,34 +14552,37 @@
     });
   }
 
-  function applyStyleAttributes(svgObj, geomType, rec) {
-    var symbolType = GeoJSON.translateGeoJSONType(geomType);
-    if (symbolType == 'point' && ('label-text' in rec)) {
-      symbolType = 'label';
-    }
-    var fields = findPropertiesBySymbolGeom(Object.keys(rec), symbolType);
-    for (var i=0, n=fields.length; i<n; i++) {
-      setAttribute(svgObj, fields[i], rec[fields[i]]);
+  function importPoint(coords, rec) {
+    rec = rec || {};
+    if (isSimpleCircle(rec)) {
+      return {
+        tag: 'circle',
+        properties: {
+          cx: coords[0],
+          cy: coords[1],
+          r: rec.r
+        }
+      };
     }
+    var o = renderPoint(rec, coords);
+    if (o) o.properties.transform = getTransform(coords);
+    return o;
   }
 
-  function setAttribute(obj, k, v) {
-    if (k == 'r') {
-      // assigned by importPoint()
-    } else {
-      if (!obj.properties) obj.properties = {};
-      obj.properties[k] = v;
-      if (k == 'stroke-dasharray' && v) {
-        // kludge for cleaner dashes... make butt the default?
-        obj.properties['stroke-linecap'] = 'butt';
-      }
-    }
+  function simpleCircleFilter(k) {
+    return k != 'r';
   }
 
-  function importMultiPoint(coords, rec, layerOpts) {
+  // just a dot, no label or icon
+  function isSimpleCircle(rec) {
+    return rec && (rec.r > 0 && !rec['svg-symbol'] && !rec['label-text']);
+  }
+
+  function importMultiPoint(coords, rec) {
     var children = [], p;
     for (var i=0; i<coords.length; i++) {
-      p = importPoint(coords[i], rec, layerOpts);
+      p = importPoint(coords[i], rec);
+      if (!p) continue;
       if (p.tag == 'g' && p.children) {
         children = children.concat(p.children);
       } else {
@@ -14173,18 +14592,6 @@
     return children.length > 0 ? {tag: 'g', children: children} : null;
   }
 
-  function importMultiPath(coords, importer) {
-    var o;
-    for (var i=0; i<coords.length; i++) {
-      if (i === 0) {
-        o = importer(coords[i]);
-      } else {
-        o.properties.d += ' ' + importer(coords[i]).properties.d;
-      }
-    }
-    return o;
-  }
-
   function importLineString(coords) {
     var d = stringifyLineStringCoords(coords);
     return {
@@ -14193,7 +14600,6 @@
     };
   }
 
-
   function importMultiLineString(coords) {
     var d = coords.map(stringifyLineStringCoords).join(' ');
     return {
@@ -14202,180 +14608,38 @@
     };
   }
 
-  // Kludge for applying fill and other styles to a <text> element
-  // (for rendering labels in the GUI with the dot in Canvas, not SVG)
-  function importStyledLabel(rec, p) {
-    var o = importLabel(rec, p);
-    applyStyleAttributes(o, 'Point', rec);
-    return o;
-  }
-
-  function toLabelString(val) {
-    if (val || val === 0 || val === false) return String(val);
-    return '';
+  function importMultiPolygon(coords) {
+   return importPolygon(flattenMultiPolygonCoords(coords));
   }
 
-  function importLabel(rec, p) {
-    var line = toLabelString(rec['label-text']);
-    var morelines, obj;
-    // Accepting \n (two chars) as an alternative to the newline character
-    // (sometimes, '\n' is not converted to newline, e.g. in a Makefile)
-    // Also accepting <br>
-    var newline = /\n|\\n|<br>/i;
-    var dx = rec.dx || 0;
-    var dy = rec.dy || 0;
-    var properties = {
-      // using x, y instead of dx, dy for shift, because Illustrator doesn't apply
-      // dx value when importing text with text-anchor=end
-      y: dy,
-      x: dx
-    };
-    if (p) {
-      properties.transform = getTransform(p);
-    }
-    if (newline.test(line)) {
-      morelines = line.split(newline);
-      line = morelines.shift();
-    }
-    obj = {
-      tag: 'text',
-      value: line,
-      properties: properties
-    };
-    if (morelines) {
-      // multiline label
-      obj.children = [];
-      morelines.forEach(function(line) {
-        var tspan = {
-          tag: 'tspan',
-          value: line,
-          properties: {
-            x: dx,
-            dy: rec['line-height'] || '1.1em'
-          }
-        };
-        obj.children.push(tspan);
-      });
-    }
-    return obj;
-  }
-
-  function getEmptySymbol() {
-    return {tag: 'g', properties: {}, children: []};
-  }
-
-
-  function renderSymbol(d, x, y) {
-    var renderer = symbolRenderers[d.type];
-     if (!renderer) {
-      stop(d.type ? 'Unknown symbol type: ' + d.type : 'Symbol is missing a type property');
-    }
-    return renderer(d, x || 0, y || 0);
+  function flattenMultiPolygonCoords(coords) {
+    return coords.reduce(function(memo, poly) {
+      return memo.concat(poly);
+    }, []);
   }
 
-  // d: svg-symbol object from feature data object
-  function importSymbol(d, xy) {
-    var renderer;
-    if (!d) {
-      return getEmptySymbol();
-    }
-    if (utils.isString(d)) {
-      d = JSON.parse(d);
-    }
-    return {
-      tag: 'g',
+  function importPolygon(coords) {
+    if (coords.length === 0) return null;
+    var o = {
+      tag: 'path',
       properties: {
-        'class': 'mapshaper-svg-symbol',
-        transform: xy ? getTransform(xy) : null
-      },
-      children: renderSymbol(d)
+        d: stringifyPolygonCoords(coords)
+      }
     };
-  }
-
-  function importPoint(coords, rec, layerOpts) {
-    rec = rec || {};
-    if ('svg-symbol' in rec) {
-      return importSymbol(rec['svg-symbol'], coords);
-    }
-    return importStandardPoint(coords, rec, layerOpts || {});
-  }
-
-  function importPolygon(coords) {
-    var d, o;
-    for (var i=0; i<coords.length; i++) {
-      d = o ? o.properties.d + ' ' : '';
-      o = importLineString(coords[i]);
-      o.properties.d = d + o.properties.d + ' Z';
-    }
     if (coords.length > 1) {
       o.properties['fill-rule'] = 'evenodd'; // support polygons with holes
     }
     return o;
   }
 
-  function importStandardPoint(coords, rec, layerOpts) {
-    var isLabel = 'label-text' in rec;
-    var symbolType = layerOpts.point_symbol || '';
-    var children = [];
-    var halfSize = rec.r || 0; // radius or half of symbol size
-    var p;
-    // if not a label, create a symbol even without a size
-    // (circle radius can be set via CSS)
-    if (halfSize > 0 || !isLabel) {
-      if (symbolType == 'square') {
-        p = {
-          tag: 'rect',
-          properties: {
-            x: coords[0] - halfSize,
-            y: coords[1] - halfSize,
-            width: halfSize * 2,
-            height: halfSize * 2
-          }};
-      } else { // default is circle
-        p = {
-          tag: 'circle',
-          properties: {
-            cx: coords[0],
-            cy: coords[1]
-          }};
-        if (halfSize > 0) {
-          p.properties.r = halfSize;
-        }
-      }
-      children.push(p);
-    }
-    if (isLabel) {
-      children.push(importLabel(rec, coords));
-    }
-    return children.length > 1 ? {tag: 'g', children: children} : children[0];
-  }
-
-  var geojsonImporters = {
-    Point: importPoint,
-    Polygon: importPolygon,
-    LineString: importLineString,
-    MultiPoint: function(coords, rec, opts) {
-      return importMultiPoint(coords, rec, opts);
-    },
-    MultiLineString: function(coords) {
-      return importMultiPath(coords, importLineString);
-    },
-    MultiPolygon: function(coords) {
-      return importMultiPath(coords, importPolygon);
-    }
-  };
-
   var GeojsonToSvg = /*#__PURE__*/Object.freeze({
     __proto__: null,
     importGeoJSONFeatures: importGeoJSONFeatures,
-    applyStyleAttributes: applyStyleAttributes,
+    importPoint: importPoint,
     importLineString: importLineString,
     importMultiLineString: importMultiLineString,
-    importStyledLabel: importStyledLabel,
-    importLabel: importLabel,
-    renderSymbol: renderSymbol,
-    importSymbol: importSymbol,
-    importPoint: importPoint,
+    importMultiPolygon: importMultiPolygon,
+    flattenMultiPolygonCoords: flattenMultiPolygonCoords,
     importPolygon: importPolygon
   });
 
@@ -14834,6 +15098,7 @@
     return svg;
   }
 
+  // href: A URL or a local path
   // TODO: download SVG files asynchronously
   // (currently, files are downloaded synchronously, which is obviously undesirable)
   //
@@ -14841,7 +15106,7 @@
     var content;
     if (href.indexOf('http') === 0) {
       content = fetchFileSync(href);
-    } else if (require('fs').existsSync(href)) { // assume href is a relative path
+    } else if (require('fs').existsSync(href)) {
       content = require('fs').readFileSync(href, 'utf8');
     } else {
       stop("Invalid SVG location:", href);
@@ -14916,15 +15181,25 @@
       convertPropertiesToDefinitions(obj, defs);
       return stringify(obj);
     }).join('\n');
+
     if (defs.length > 0) {
       svg = '<defs>\n' + utils.pluck(defs, 'svg').join('') + '</defs>\n' + svg;
     }
+
     if (svg.includes('xlink:')) {
       namespace += ' xmlns:xlink="http://www.w3.org/1999/xlink"';
     }
+
+    // default line style properties
     var capStyle = opts.default_linecap || 'round';
+    var lineProps = `stroke-linecap="${capStyle}" stroke-linejoin="round"`;
+    if (svg.includes('stroke-linejoin="miter"')) {
+      // the default limit in Illustrator seems to be 10 -- too large for mapping
+      // (Mapbox uses 2 as the default in their styles)
+      lineProps += ' stroke-miterlimit="2"';
+    }
     var template = `<?xml version="1.0"?>
-<svg ${namespace} version="1.2" baseProfile="tiny" width="%d" height="%d" viewBox="%s %s %s %s" stroke-linecap="${capStyle}" stroke-linejoin="round">${style}
+<svg ${namespace} version="1.2" baseProfile="tiny" width="%d" height="%d" viewBox="%s %s %s %s" ${lineProps}>${style}
 ${svg}
 </svg>`;
     svg = utils.format(template,size[0], size[1], 0, 0, size[0], size[1]);
@@ -15090,6 +15365,15 @@ ${svg}
     return layerObj;
   }
 
+  function featureHasSvgSymbol(d) {
+    return !!(d && (d['svg-symbol'] || d.r));
+  }
+
+  function featureHasLabel(d) {
+    var text = d && d['label-text'];
+    return text || text === 0; // accept numerical 0 as label text
+  }
+
   function layerHasSvgSymbols(lyr) {
     return lyr.geometry_type == 'point' && lyr.data && lyr.data.fieldExists('svg-symbol');
   }
@@ -15109,6 +15393,8 @@ ${svg}
     validateSvgDataFields: validateSvgDataFields,
     exportDataAttributesForSVG: exportDataAttributesForSVG,
     getEmptyLayerForSVG: getEmptyLayerForSVG,
+    featureHasSvgSymbol: featureHasSvgSymbol,
+    featureHasLabel: featureHasLabel,
     layerHasSvgSymbols: layerHasSvgSymbols,
     layerHasLabels: layerHasLabels
   });
@@ -17169,116 +17455,6 @@ ${svg}
     formatVersionedFileName: formatVersionedFileName
   });
 
-  // convert targets from [{layers: [...], dataset: <>}, ...] format to
-  // [{layer: <>, dataset: <>}, ...] format
-  function expandCommandTargets(targets) {
-    return targets.reduce(function(memo, target) {
-      target.layers.forEach(function(lyr) {
-        memo.push({layer: lyr, dataset: target.dataset});
-      });
-      return memo;
-    }, []);
-  }
-
-  function findCommandTargets(layers, pattern, type) {
-    var targets = [];
-    var matches = findMatchingLayers(layers, pattern, true);
-    if (type) {
-      matches = matches.filter(function(o) {return o.layer.geometry_type == type;});
-    }
-    // assign target_id to matched layers
-    // (kludge so layers can be sorted in the order that they match; used by -o command)
-    layers.forEach(function(o) {o.layer.target_id = -1;});
-    matches.forEach(function(o, i) {o.layer.target_id = i;});
-    return groupLayersByDataset(matches);
-  }
-
-  // arr: array of {layer: <>, dataset: <>} objects
-  function groupLayersByDataset(arr) {
-    var datasets = [];
-    var targets = [];
-    arr.forEach(function(o) {
-      var i = datasets.indexOf(o.dataset);
-      if (i == -1) {
-        datasets.push(o.dataset);
-        targets.push({layers: [o.layer], dataset: o.dataset});
-      } else {
-        targets[i].layers.push(o.layer);
-      }
-    });
-    return targets;
-  }
-
-  // layers: array of {layer: <>, dataset: <>} objects
-  // pattern: is a layer identifier or a comma-sep. list of identifiers.
-  // An identifier is a literal name, a pattern containing "*" wildcard or
-  // a 1-based index (1..n)
-  function findMatchingLayers(layers, pattern, throws) {
-    var matchedLayers = [];
-    var unmatchedIds = [];
-    var index = {};
-    pattern.split(',').forEach(function(subpattern, i) {
-      var test = getLayerMatch(subpattern);
-      var matched = false;
-      layers.forEach(function(o, layerId) {
-        // if (matchedLayers.indexOf(lyr) > -1) return; // performance bottleneck with 1000s of layers
-        if (layerId in index) {
-          matched = true;
-        } else if (test(o.layer, layerId + 1)) {  // layers are 1-indexed
-          matchedLayers.push(o);
-          index[layerId] = true;
-          matched = true;
-        }
-      });
-      if (matched == false) {
-        unmatchedIds.push(subpattern);
-      }
-    });
-    if (throws && unmatchedIds.length) {
-      stop(utils.format('Missing layer%s: %s', unmatchedIds.length == 1 ? '' : 's', unmatchedIds.join(',')));
-    }
-    return matchedLayers;
-  }
-
-  function getLayerMatch(pattern) {
-    var isIndex = utils.isInteger(Number(pattern));
-    var nameRxp = isIndex ? null : utils.wildcardToRegExp(pattern);
-    return function(lyr, i) {
-      return isIndex ? String(i) == pattern : nameRxp.test(lyr.name || '');
-    };
-  }
-
-  function countTargetLayers(targets) {
-    return targets.reduce(function(memo, target) {
-      return memo + target.layers.length;
-    }, 0);
-  }
-
-  // get an identifier for a layer that can be used in a target= option
-  // (returns name if layer has a unique name, or a numerical id)
-  function getLayerTargetId(catalog, lyr) {
-    var nameCount = 0,
-        name = lyr.name,
-        id;
-    catalog.getLayers().forEach(function(o, i) {
-      if (lyr.name && o.layer.name == lyr.name) nameCount++;
-      if (lyr == o.layer) id = String(i + 1);
-    });
-    if (!id) error('Layer not found');
-    return nameCount == 1 ? lyr.name : id;
-  }
-
-  var TargetUtils = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    expandCommandTargets: expandCommandTargets,
-    findCommandTargets: findCommandTargets,
-    groupLayersByDataset: groupLayersByDataset,
-    findMatchingLayers: findMatchingLayers,
-    getLayerMatch: getLayerMatch,
-    countTargetLayers: countTargetLayers,
-    getLayerTargetId: getLayerTargetId
-  });
-
   function readFirstChars(reader, n) {
     return bufferToString(reader.readSync(0, Math.min(n || 1000, reader.size())));
   }
@@ -20154,6 +20330,10 @@ ${svg}
         DEFAULT: true,
         type: 'distance'
       })
+      .option('endpoints', {
+        describe: 'only snap together the endpoints of lines',
+        type: 'flag'
+      })
       .option('precision', {
         describe: 'round all coordinates to a given decimal precision (e.g. 0.000001)',
         type: 'number'
@@ -20297,14 +20477,21 @@ ${svg}
       .option('stroke', {})
       .option('stroke-width', {})
       .option('fill', {
-        describe: 'symbol fill color'
+        describe: 'symbol fill color (filled symbols only)'
       })
-      .option('polygons', {
-        describe: 'generate symbols as polygons instead of SVG objects',
+      .option('stroke', {
+        describe: 'symbol line color (linear symbols only)'
+      })
+      .option('stroke-width', {
+        describe: 'symbol line width (linear symbols only)'
+      })
+      .option('geographic', {
+        old_alias: 'polygons',
+         describe: 'make geographic shapes instead of SVG objects',
         type: 'flag'
       })
       .option('pixel-scale', {
-        describe: 'set symbol scale in meters-per-pixel (for polygons option)',
+        describe: 'set symbol scale in meters per pixel (geographic option)',
         type: 'number',
       })
       // .option('flipped', {
@@ -20341,6 +20528,9 @@ ${svg}
       .option('radii', {
         describe: '(ring) comma-sep. list of concentric radii, ascending order'
       })
+      .option('arrow-style', {
+        describe: '(arrow) options: stick, standard (default is standard)'
+      })
       .option('length', {
         old_alias: 'arrow-length',
         describe: '(arrow) length of arrow in pixels'
@@ -20695,16 +20885,16 @@ ${svg}
     var ifOpts = {
       expression: {
         DEFAULT: true,
-        describe: 'JS expression targeting a single layer'
-      },
-      empty: {
-        describe: 'run if layer is empty',
-        type: 'flag'
-      },
-      'not-empty': {
-        describe: 'run if layer is not empty',
-        type: 'flag'
+        describe: 'JS expression'
       },
+      // empty: {
+      //   describe: 'run if layer is empty',
+      //   type: 'flag'
+      // },
+      // 'not-empty': {
+      //   describe: 'run if layer is not empty',
+      //   type: 'flag'
+      // },
       layer: {
         describe: 'name or id of layer to test (default is current target)'
       },
@@ -34689,13 +34879,27 @@ ${svg}
     return job.control || (job.control = {});
   }
 
-  function compileIfCommandExpression(expr, catalog, targ, opts) {
-    var ctx = getLayerProxy(targ.layer, targ.dataset.arcs, opts);
+  function compileIfCommandExpression(expr, catalog, opts) {
+    var targetId = opts.layer || opts.target || null;
+    var targets = catalog.findCommandTargets(targetId);
+    var isSingle = targets.length == 1 && targets[0].layers.length == 1;
+    if (targets.length === 0 && targetId) {
+      stop('Layer not found:', targetId);
+    }
+    var ctx;
+    if (isSingle) {
+      ctx = getLayerProxy(targets[0].layers[0], targets[0].dataset.arcs, opts);
+    } else {
+      ctx = getNullLayerProxy(targets);
+    }
     var exprOpts = Object.assign({returns: true}, opts);
     var func = compileExpressionToFunction(expr, exprOpts);
 
-    ctx.layer_exists = function(name) {
-      return !!catalog.findSingleLayer(name);
+    // @geoType: optional geometry type (polygon, polyline, point, null);
+    ctx.layer_exists = function(name, geoType) {
+      var targets = catalog.findCommandTargets(name, geoType);
+      if (targets.length === 0) return false;
+      return true;
     };
 
     ctx.file_exists = function(file) {
@@ -34754,49 +34958,28 @@ ${svg}
     return ['if','elif','else','endif'].includes(cmd);
   }
 
-  function testLayer(catalog, opts) {
-    var targ = getTargetLayer(catalog, opts);
+  function test(catalog, opts) {
+    // var targ = getTargetLayer(catalog, opts);
     if (opts.expression) {
-      return compileIfCommandExpression(opts.expression, catalog, targ, opts)();
-    }
-    if (opts.empty) {
-      return layerIsEmpty(targ.layer);
-    }
-    if (opts.not_empty) {
-      return !layerIsEmpty(targ.layer);
+      return compileIfCommandExpression(opts.expression, catalog, opts)();
     }
+    // if (opts.empty) {
+    //   return layerIsEmpty(targ.layer);
+    // }
+    // if (opts.not_empty) {
+    //   return !layerIsEmpty(targ.layer);
+    // }
     return true;
   }
 
   function evaluateIf(job, opts) {
-    if (!blockWasActive(job) && testLayer(job.catalog, opts)) {
+    if (!blockWasActive(job) && test(job.catalog, opts)) {
       enterActiveBranch(job);
     } else {
       enterInactiveBranch(job);
     }
   }
 
-  // layerId: optional layer identifier
-  //
-  function getTargetLayer(catalog, opts) {
-    var layerId = opts.layer || opts.target;
-    var targets = catalog.findCommandTargets(layerId);
-    if (targets.length === 0) {
-      if (layerId) {
-        stop('Layer not found:', layerId);
-      } else {
-        stop('Missing a target layer.');
-      }
-    }
-    if (targets.length > 1 || targets[0].layers.length > 1) {
-      stop('Command requires a single target layer.');
-    }
-    return {
-      layer: targets[0].layers[0],
-      dataset: targets[0].dataset
-    };
-  }
-
   cmd.ignore = function(targetLayer, dataset, opts) {
     if (opts.empty && layerIsEmpty(targetLayer)) {
       interrupt('Layer is empty, stopping processing');
@@ -37238,72 +37421,6 @@ ${svg}
     }
   };
 
-  symbolRenderers.circle = function(d, x, y) {
-    var o = importPoint([x, y], d, {});
-    applyStyleAttributes(o, 'Point', d);
-    return [o];
-  };
-
-  symbolRenderers.label = function(d, x, y) {
-    var o = importStyledLabel(d, [x, y]);
-    return [o];
-  };
-
-  symbolRenderers.image = function(d, x, y) {
-    var w = d.width || 20,
-        h = d.height || 20;
-    var o = {
-      tag: 'image',
-      properties: {
-        width: w,
-        height: h,
-        x: x - w / 2,
-        y: y - h / 2,
-        href: d.href || ''
-      }
-    };
-    return [o];
-  };
-
-  symbolRenderers.square = function(d, x, y) {
-    var o = importPoint([x, y], d, {point_symbol: 'square'});
-    applyStyleAttributes(o, 'Point', d);
-    return [o];
-  };
-
-  symbolRenderers.line = function(d, x, y) {
-    var coords, o;
-    coords = [[x, y], [x + (d.dx || 0), y + (d.dy || 0)]];
-    o = importLineString(coords);
-    applyStyleAttributes(o, 'LineString', d);
-    return [o];
-  };
-
-  symbolRenderers.polyline = function(d, x, y) {
-    var coords = d.coordinates || [];
-    var o = importMultiLineString(coords);
-    applyStyleAttributes(o, 'LineString', d);
-    return [o];
-  };
-
-  symbolRenderers.polygon = function(d, x, y) {
-    var coords = d.coordinates || [];
-    var o = importPolygon(coords);
-    applyStyleAttributes(o, 'Polygon', d);
-    return [o];
-  };
-
-  symbolRenderers.group = function(d, x, y) {
-    return (d.parts || []).reduce(function(memo, o) {
-      var sym = renderSymbol(o, x, y);
-      if (d.chained) {
-        x += (o.dx || 0);
-        y += (o.dy || 0);
-      }
-      return memo.concat(sym);
-    }, []);
-  };
-
   cmd.scalebar = function(catalog, opts) {
     var frame = findFrameDataset(catalog);
     var obj, lyr;
@@ -37387,7 +37504,7 @@ ${svg}
         // so I'm using 'hanging' and 'auto', which seem to be well supported.
         // downside: requires a kludgy multiplier to calculate scalebar height (see above)
       };
-    var labelObj = symbolRenderers.label(labelOpts, anchorX, anchorY)[0];
+    var labelObj = symbolRenderers.label(labelOpts, anchorX, anchorY);
     var g = {
       tag: 'g',
       children: [barObj, labelObj],
@@ -38490,7 +38607,12 @@ ${svg}
       interval = getHighPrecisionSnapInterval(arcBounds.toArray());
     }
     arcs.flatten(); // bake in any simplification
-    if (interval > 0) {
+    if (interval > 0 && opts.endpoints) {
+      // snaps line endpoints together
+      // TODO: also snap endpoints to line segments to remove undershoots and overshoots
+      snapCount = snapEndpointsByInterval(arcs, interval);
+      message(utils.format("Snapped %s endpoint%s", snapCount, utils.pluralSuffix(snapCount)));
+    } else if (interval > 0) {
       snapCount = snapCoordsByInterval(arcs, interval);
       message(utils.format("Snapped %s point%s", snapCount, utils.pluralSuffix(snapCount)));
     }
@@ -38633,6 +38755,19 @@ ${svg}
 
   var roundCoord = getRoundingFunction(0.01);
 
+  function getSymbolFillColor(d) {
+    return d.fill || 'magenta';
+  }
+
+  function getSymbolStrokeColor(d) {
+    return d.stroke || d.fill || 'magenta';
+  }
+
+  function getSymbolRadius(d) {
+    if (d.radius === 0 || d.length === 0 || d.r === 0) return 0;
+    return d.radius || d.length || d.r || 5; // use a default value
+  }
+
   function forEachSymbolCoord(coords, cb) {
     var isPoint = coords && utils.isNumber(coords[0]);
     var isNested = !isPoint && coords && Array.isArray(coords[0]);
@@ -38701,57 +38836,104 @@ ${svg}
     points.push(p2);
   }
 
-  // export function getStickArrowCoords(d, totalLen) {
-  //   var minStemRatio = getMinStemRatio(d);
-  //   var headAngle = d['arrow-head-angle'] || 90;
-  //   var curve = d['arrow-stem-curve'] || 0;
-  //   var unscaledHeadWidth = d['arrow-head-width'] || 9;
-  //   var unscaledHeadLen = getHeadLength(unscaledHeadWidth, headAngle);
-  //   var scale = getScale(totalLen, unscaledHeadLen, minStemRatio);
-  //   var headWidth = unscaledHeadWidth * scale;
-  //   var headLen = unscaledHeadLen * scale;
-  //   var tip = getStickArrowTip(totalLen, curve);
-  //   var stem = [[0, 0], tip.concat()];
-  //   if (curve) {
-  //     addBezierArcControlPoints(stem, curve);
-  //   }
-  //   if (!headLen) return [stem];
-  //   var head = [addPoints([-headWidth / 2, -headLen], tip), tip.concat(), addPoints([headWidth / 2, -headLen], tip)];
+  function getStickArrowCoords(d) {
+    return getArrowCoords(d, 'stick');
+  }
 
-  //   rotateCoords(stem, d.rotation);
-  //   rotateCoords(head, d.rotation);
-  //   return [stem, head];
-  // }
+  function getFilledArrowCoords(d) {
+    return getArrowCoords(d, 'standard');
+  }
 
-  // function getStickArrowTip(totalLen, curve) {
-  //   // curve/2 intersects the arrowhead at 90deg (trigonometry)
-  //   var theta = Math.abs(curve/2) / 180 * Math.PI;
-  //   var dx = totalLen * Math.sin(theta) * (curve > 0 ? -1 : 1);
-  //   var dy = totalLen * Math.cos(theta);
-  //   return [dx, dy];
-  // }
+  function getArrowCoords(d, style) {
+    var stickArrow = style == 'stick',
+        // direction = d.rotation || d.direction || 0,
+        direction = d.direction || 0, // rotation is an independent parameter
+        stemTaper = d['stem-taper'] || 0,
+        curvature = d['stem-curve'] || 0,
+        size = calcArrowSize(d, stickArrow);
+    if (!size) return null;
+    var stemLen = size.stemLen,
+        headLen = size.headLen,
+        headDx = size.headWidth / 2,
+        stemDx = size.stemWidth / 2,
+        baseDx = stemDx * (1 - stemTaper),
+        head, stem, coords, dx, dy;
 
-  // function addPoints(a, b) {
-  //   return [a[0] + b[0], a[1] + b[1]];
-  // }
+    if (curvature) {
+      // make curved stem
+      if (direction > 0) curvature = -curvature;
+      var theta = Math.abs(curvature) / 180 * Math.PI;
+      var sign = curvature > 0 ? 1 : -1;
+      var ax = baseDx * Math.cos(theta); // rotate arrow base
+      var ay = baseDx * Math.sin(theta) * -sign;
+      dx = stemLen * Math.sin(theta / 2) * sign;
+      dy = stemLen * Math.cos(theta / 2);
+
+      if (stickArrow) {
+        stem = getCurvedStemCoords(-ax, -ay, dx, dy, theta);
+      } else {
+        var leftStem = getCurvedStemCoords(-ax, -ay, -stemDx + dx, dy, theta);
+        var rightStem = getCurvedStemCoords(ax, ay, stemDx + dx, dy, theta);
+        stem = leftStem.concat(rightStem.reverse());
+      }
+
+    } else {
+      // make straight stem
+      dx = 0;
+      dy = stemLen;
+      if (stickArrow) {
+        stem = [[0, 0], [0, stemLen]];
+      } else {
+        stem = [[-baseDx, 0], [baseDx, 0]];
+      }
+    }
+
+    if (stickArrow) {
+      // make stick arrow
+      head = [[-headDx + dx, stemLen - headLen], [dx, stemLen], [headDx + dx, stemLen - headLen]];
+      coords = [stem, head]; // MultiLineString coords
+    } else {
+      // make filled arrow
+      // coordinates go counter clockwise, starting from the leftmost head coordinate
+      head = [[stemDx + dx, dy], [headDx + dx, dy],
+          [dx, headLen + dy], [-headDx + dx, dy], [-stemDx + dx, dy]];
+      coords = stem.concat(head);
+      coords.push(stem[0].concat()); // closed path
+      coords = [coords]; // Polygon coords
+    }
+
+    if (d.anchor == 'end') {
+      scaleAndShiftCoords(coords, 1, [-dx, -dy - headLen]);
+    } else if (d.anchor == 'middle') {
+      // shift midpoint away from the head a bit for a more balanced placement
+      // scaleAndShiftCoords(coords, 1, [-dx/2, (-dy - headLen)/2]);
+      scaleAndShiftCoords(coords, 1, [-dx * 0.5, -dy * 0.5 - headLen * 0.25]);
+    }
+
+    rotateCoords(coords, direction);
+    if (d.flipped) {
+      flipY(coords);
+    }
+    return coords;
+  }
 
   function calcStraightArrowCoords(stemLen, headLen, stemDx, headDx, baseDx) {
     return [[baseDx, 0], [stemDx, stemLen], [headDx, stemLen], [0, stemLen + headLen],
           [-headDx, stemLen], [-stemDx, stemLen], [-baseDx, 0], [baseDx, 0]];
   }
 
-  function calcArrowSize(d) {
+  function calcArrowSize(d, stickArrow) {
     // don't display arrows with negative length
     var totalLen = Math.max(d.radius || d.length || d.r || 0, 0),
         scale = 1,
         o = initArrowSize(d); // calc several parameters
 
-    if (totalLen > 0) {
+    if (totalLen >= 0) {
       scale = calcScale(totalLen, o.headLen, d);
       o.stemWidth *= scale;
       o.headWidth *= scale;
       o.headLen *= scale;
-      o.stemLen = totalLen - o.headLen;
+      o.stemLen = stickArrow ? totalLen : totalLen - o.headLen;
     }
 
     if (o.headWidth < o.stemWidth) {
@@ -38772,7 +38954,7 @@ ${svg}
     } else if (stemLen + headLen > totalLen) {
       scale = totalLen / (stemLen + headLen);
     }
-    return scale;
+    return scale || 0;
   }
 
   function initArrowSize(d) {
@@ -38802,56 +38984,6 @@ ${svg}
     return 1 / Math.tan(Math.PI * headAngle / 180 / 2) / 2;
   }
 
-  function getFilledArrowCoords(d) {
-    var direction = d.rotation || d.direction || 0,
-        stemTaper = d['stem-taper'] || 0,
-        curvature = d['stem-curve'] || 0,
-        size = calcArrowSize(d);
-    if (!size) return null;
-    var stemLen = size.stemLen,
-        headLen = size.headLen,
-        headDx = size.headWidth / 2,
-        stemDx = size.stemWidth / 2,
-        baseDx = stemDx * (1 - stemTaper),
-        head, stem, coords, dx, dy;
-
-    if (curvature) {
-      if (direction > 0) curvature = -curvature;
-      var theta = Math.abs(curvature) / 180 * Math.PI;
-      var sign = curvature > 0 ? 1 : -1;
-      var ax = baseDx * Math.cos(theta); // rotate arrow base
-      var ay = baseDx * Math.sin(theta) * -sign;
-      dx = stemLen * Math.sin(theta / 2) * sign;
-      dy = stemLen * Math.cos(theta / 2);
-      var leftStem = getCurvedStemCoords(-ax, -ay, -stemDx + dx, dy, theta);
-      var rightStem = getCurvedStemCoords(ax, ay, stemDx + dx, dy, theta);
-      stem = leftStem.concat(rightStem.reverse());
-
-    } else {
-      dx = 0;
-      dy = stemLen;
-      stem = [[-baseDx, 0], [baseDx, 0], [baseDx, 0]];
-    }
-
-    // coordinates go counter clockwise, starting from the leftmost head coordinate
-    head = [[stemDx + dx, dy], [headDx + dx, dy],
-        [dx, headLen + dy], [-headDx + dx, dy], [-stemDx + dx, dy]];
-
-    coords = stem.concat(head);
-    if (d.anchor == 'end') {
-      scaleAndShiftCoords(coords, 1, [-dx, -dy - headLen]);
-    } else if (d.anchor == 'middle') {
-      // shift midpoint away from the head a bit for a more balanced placement
-      // scaleAndShiftCoords(coords, 1, [-dx/2, (-dy - headLen)/2]);
-      scaleAndShiftCoords(coords, 1, [-dx * 0.5, -dy * 0.5 - headLen * 0.25]);
-    }
-
-    rotateCoords(coords, direction);
-    if (d.flipped) {
-      flipY(coords);
-    }
-    return [coords];
-  }
 
   // ax, ay: point on the base
   // bx, by: point on the stem
@@ -38887,8 +39019,19 @@ ${svg}
     return coords;
   }
 
+  function makeCircleSymbol(d, opts) {
+    var radius = getSymbolRadius(d);
+    // TODO: remove duplication with svg-symbols.js
+    if (+opts.scale) radius *= +opts.scale;
+    return {
+      type: 'circle',
+      fill: getSymbolFillColor(d),
+      r: radius
+    };
+  }
+
   function getPolygonCoords(d) {
-    var radius = d.radius || d.length || d.r,
+    var radius = getSymbolRadius(d),
         sides = +d.sides || getSidesByType(d.type),
         rotated = sides % 2 == 1,
         coords = [],
@@ -38925,7 +39068,7 @@ ${svg}
   }
 
   function getStarCoords(d) {
-    var radius = d.radius || d.length || d.r,
+    var radius = getSymbolRadius(d),
         points = d.points || d.sides && d.sides / 2 || 5,
         sides = points * 2,
         minorRadius = getMinorRadius(points) * radius,
@@ -38970,6 +39113,35 @@ ${svg}
     return 180 - centerAngle;
   }
 
+  // Returns a svg-symbol object
+  function makeRingSymbol(d, opts) {
+    var scale = +opts.scale || 1;
+    var radii = parseRings(d.radii || '2').map(function(r) { return r * scale; });
+    var solidCenter = utils.isOdd(radii.length);
+    var color = getSymbolFillColor(d);
+    var parts = [];
+    if (solidCenter) {
+      parts.push({
+        type: 'circle',
+        fill: color,
+        r: radii.shift()
+      });
+    }
+    for (var i=0; i<radii.length; i+= 2) {
+      parts.push({
+        type: 'circle',
+        fill: 'none', // TODO remove default black fill so this is not needed
+        stroke: color,
+        'stroke-width':  roundToTenths(radii[i+1] - radii[i]),
+        r: roundToTenths(radii[i+1] * 0.5 + radii[i] * 0.5)
+      });
+    }
+    return {
+      type: 'group',
+      parts: parts
+    };
+  }
+
   // Returns GeoJSON MultiPolygon coords
   function getRingCoords(d) {
     var radii = parseRings(d.radii || '2');
@@ -39001,13 +39173,36 @@ ${svg}
     return utils.uniq(arr);
   }
 
+  // Returns an svg-symbol data object for one symbol
+  function makePathSymbol(coords, properties, geojsonType) {
+    var sym;
+    if (geojsonType == 'MultiPolygon' || geojsonType == 'Polygon') {
+      sym = {
+        type: 'polygon',
+        fill: getSymbolFillColor(properties),
+        coordinates: geojsonType == 'Polygon' ? coords : flattenMultiPolygonCoords(coords)
+      };
+    } else if (geojsonType == 'LineString' || geojsonType == 'MultiLineString') {
+      sym = {
+        type: 'polyline',
+        stroke: getSymbolStrokeColor(properties),
+        'stroke-width': properties['stroke-width'] || 2,
+        coordinates: geojsonType == 'LineString' ? [coords] : coords
+      };
+    } else {
+      error('Unsupported type:', geojsonType);
+    }
+    roundCoordsForSVG(sym.coordinates);
+    return sym;
+  }
+
   // TODO: refactor to remove duplication in mapshaper-svg-style.js
   cmd.symbols = function(inputLyr, dataset, opts) {
     requireSinglePointLayer(inputLyr);
     var lyr = opts.no_replace ? copyLayer(inputLyr) : inputLyr;
-    var polygonMode = !!opts.polygons;
+    var shapeMode = !!opts.geographic;
     var metersPerPx;
-    if (polygonMode) {
+    if (shapeMode) {
       requireProjectedDataset(dataset);
       metersPerPx = opts.pixel_scale || getMetersPerPixel(lyr, dataset);
     }
@@ -39017,9 +39212,24 @@ ${svg}
       if (!shp) return null;
       var d = getSymbolData(i);
       var rec = records[i] || {};
+
+      // non-polygon symbols
+      if (!shapeMode && d.type == 'circle') {
+        rec['svg-symbol'] = makeCircleSymbol(d, opts);
+        return;
+      }
+      if (!shapeMode && d.type == 'ring') {
+        rec['svg-symbol'] = makeRingSymbol(d, opts);
+        return;
+      }
+
       var geojsonType = 'Polygon';
       var coords;
-      if (d.type == 'arrow') {
+      // these symbols get converted to polygon shapes
+      if (d.type == 'arrow' && opts.arrow_style == 'stick') {
+        coords = getStickArrowCoords(d);
+        geojsonType = 'MultiLineString';
+      } else if (d.type == 'arrow') {
         coords = getFilledArrowCoords(d);
       } else if (d.type == 'ring') {
         coords = getRingCoords(d);
@@ -39031,23 +39241,24 @@ ${svg}
       }
       if (!coords) return null;
       rotateCoords(coords, +d.rotation || 0);
-      if (!polygonMode) {
+      if (!shapeMode) {
         flipY(coords);
       }
       if (+opts.scale) {
         scaleAndShiftCoords(coords, +opts.scale, [0, 0]);
       }
-      if (polygonMode) {
+      if (shapeMode) {
         scaleAndShiftCoords(coords, metersPerPx, shp[0]);
-        if (d.tfill) rec.fill = d.fill;
+        if (d.fill) rec.fill = d.fill;
+        if (d.stroke) rec.stroke = d.stroke;
         return createGeometry(coords, geojsonType);
       } else {
-        rec['svg-symbol'] = makeSvgPolygonSymbol(coords, d, geojsonType);
+        rec['svg-symbol'] = makePathSymbol(coords, d, geojsonType);
       }
     });
 
     var outputLyr, dataset2;
-    if (polygonMode) {
+    if (shapeMode) {
       dataset2 = importGeometries(geometries, records);
       outputLyr = mergeOutputLayerIntoDataset(inputLyr, dataset, dataset2, opts);
       outputLyr.data = lyr.data;
@@ -39081,31 +39292,10 @@ ${svg}
   }
 
   function getMetersPerPixel(lyr, dataset) {
-
-    // TODO: handle single point, no extent
     var bounds = getLayerBounds(lyr);
-    return bounds.width() / 800;
-  }
-
-  // Returns an svg-symbol data object for one symbol
-  function makeSvgPolygonSymbol(coords, properties, geojsonType) {
-    if (geojsonType == 'MultiPolygon') {
-      coords = convertMultiPolygonCoords(coords);
-    } else if (geojsonType != 'Polygon') {
-      error('Unsupported type:', geojsonType);
-    }
-    roundCoordsForSVG(coords);
-    return {
-      type: 'polygon',
-      coordinates: coords,
-      fill: properties.fill || 'magenta'
-    };
-  }
-
-  function convertMultiPolygonCoords(coords) {
-    return coords.reduce(function(memo, poly) {
-      return memo.concat(poly);
-    }, []);
+    // TODO: need a better way to handle a single point with no extent
+    var extent = bounds.width() || bounds.height() || 1000;
+    return extent / 800;
   }
 
   var Symbols = /*#__PURE__*/Object.freeze({
@@ -39510,6 +39700,19 @@ ${svg}
     return [lyr1, lyr2];
   }
 
+  function commandAcceptsMultipleTargetDatasets(name) {
+    return name == 'rotate' || name == 'info' || name == 'proj' ||
+      name == 'drop' || name == 'target' || name == 'if' || name == 'elif' ||
+      name == 'else' || name == 'endif';
+  }
+
+  function commandAcceptsEmptyTarget(name) {
+    return name == 'graticule' || name == 'i' || name == 'help' ||
+      name == 'point-grid' || name == 'shape' || name == 'rectangle' ||
+      name == 'include' || name == 'print' || name == 'if' || name == 'elif' ||
+      name == 'else' || name == 'endif';
+  }
+
   function runCommand(command, job, cb) {
     var name = command.name,
         opts = command.options,
@@ -39531,7 +39734,6 @@ ${svg}
     job.startCommand(command);
 
     try { // catch errors from synchronous functions
-
       T$1.start();
 
       if (name == 'rename-layers') {
@@ -39546,13 +39748,11 @@ ${svg}
         // TODO: check that combine_layers is only used w/ GeoJSON output
         targets = job.catalog.findCommandTargets(opts.target || opts.combine_layers && '*');
 
-      } else if (name == 'rotate' || name == 'info' || name == 'proj' || name == 'drop' || name == 'target') {
-        // these commands accept multiple target datasets
+      } else if (commandAcceptsMultipleTargetDatasets(name)) {
         targets = job.catalog.findCommandTargets(opts.target);
 
       } else {
         targets = job.catalog.findCommandTargets(opts.target);
-
         // special case to allow -merge-layers and -union to combine layers from multiple datasets
         // TODO: support multi-dataset targets for other commands
         if (targets.length > 1 && (name == 'merge-layers' || name == 'union')) {
@@ -39576,9 +39776,7 @@ ${svg}
           stop(utils.format('Missing target: %s\nAvailable layers: %s',
               opts.target, getFormattedLayerList(job.catalog)));
         }
-        if (!(name == 'graticule' || name == 'i' || name == 'help' ||
-            name == 'point-grid' || name == 'shape' || name == 'rectangle' ||
-            name == 'include' || name == 'print')) {
+        if (!commandAcceptsEmptyTarget(name)) {
           throw new UserError("No data is available");
         }
       }
@@ -40606,7 +40804,8 @@ ${svg}
   //       export only functions called by the GUI.
 
   var internal = {};
-  internal.svg = Object.assign({}, SvgCommon, SvgStringify, SvgPathUtils, GeojsonToSvg);
+
+  internal.svg = Object.assign({}, SvgStringify, SvgPathUtils, GeojsonToSvg, SvgLabels, SvgSymbols);
 
   // Assign functions and objects exported from modules to the 'internal' namespace
   // to maintain compatibility with tests and to expose (some of) them to the GUI.