mapshaper 0.5.80 → 0.5.84

package/mapshaper.js

@@ -1,6 +1,6 @@
 (function () {
 
-  var VERSION = "0.5.79";
+  var VERSION = "0.5.83";
 
 
   var utils = /*#__PURE__*/Object.freeze({
@@ -16,6 +16,8 @@
     get isFiniteNumber () { return isFiniteNumber; },
     get isNonNegNumber () { return isNonNegNumber; },
     get isInteger () { return isInteger; },
+    get isEven () { return isEven; },
+    get isOdd () { return isOdd; },
     get isString () { return isString; },
     get isDate () { return isDate; },
     get isBoolean () { return isBoolean; },
@@ -149,6 +151,14 @@
     return isNumber(obj) && ((obj | 0) === obj);
   }
 
+  function isEven(obj) {
+    return (obj % 2) === 0;
+  }
+
+  function isOdd(obj) {
+    return (obj % 2) === 1;
+  }
+
   function isString(obj) {
     return obj != null && obj.toString === String.prototype.toString;
     // TODO: replace w/ something better.
@@ -2359,6 +2369,12 @@
     }, 0);
   }
 
+  // export function getEllipsoidalShapeArea(shp, arcs, crs) {
+  //   return (shp || []).reduce(function(area, ids) {
+  //     return area + getEllipsoidalPathArea(ids, arcs, crs);
+  //   }, 0);
+  // }
+
   // Return true if point is inside or on boundary of a shape
   //
   function testPointInPolygon(x, y, shp, arcs) {
@@ -13692,14 +13708,18 @@
     length: 'number', // e.g. arrow length
     rotation: 'number',
     radius: 'number',
-    'arrow-length': 'number',
-    'arrow-direction': 'number',
-    'arrow-head-angle': 'number',
-    'arrow-head-width': 'number',
-    'arrow-stem-width': 'number',
-    'arrow-stem-curve': 'number', // degrees of arc
-    'arrow-stem-taper': 'number',
-    'arrow-min-stem': 'number',
+    radii: null, // string, parsed by function
+    flipped: 'boolean',
+    rotated: 'boolean',
+    direction: 'number',
+    'head-angle': 'number',
+    'head-width': 'number',
+    'head-length': 'number',
+    'stem-width': 'number',
+    'stem-curve': 'number', // degrees of arc
+    'stem-taper': 'number',
+    'stem-length': 'number',
+    'min-stem-ratio': 'number',
     'arrow-scaling': 'number',
     effect: null // e.g. "fade"
   }, stylePropertyTypes);
@@ -13735,6 +13755,7 @@
   function getSymbolDataAccessor(lyr, opts) {
     var functions = {};
     var properties = [];
+    var fields = lyr.data ? lyr.data.getFields() : [];
 
     Object.keys(opts).forEach(function(optName) {
       var svgName = optName.replace(/_/g, '-');
@@ -13746,6 +13767,8 @@
       properties.push(svgName);
     });
 
+    // TODO: consider applying values of existing fields with names of symbol properties
+
     return function(id) {
       var d = {}, name;
       for (var i=0; i<properties.length; i++) {
@@ -13761,8 +13784,9 @@
   // * ???
   //
   function mightBeExpression(str, fields) {
+    fields = fields || [];
     if (fields.indexOf(str.trim()) > -1) return true;
-    return /[(){}.+-/*?:&|=\[]/.test(str);
+    return /[(){}./*?:&|=\[+-]/.test(str);
   }
 
   function getSymbolPropertyAccessor(val, svgName, lyr) {
@@ -13783,6 +13807,7 @@
       // treating the string as a literal value
       literalVal = strVal;
     }
+    // console.log("literalVal:", mightBeExpression(strVal, fields), strVal, fields)
     if (accessor) return accessor;
     if (literalVal !== null) return function(id) {return literalVal;};
     stop('Unexpected value for', svgName + ':', strVal);
@@ -13816,6 +13841,8 @@
       val = isDashArray(strVal) ? strVal : null;
     } else if (type == 'pattern') {
       val = isPattern(strVal) ? strVal : null;
+    } else if (type == 'boolean') {
+      val = parseBoolean(strVal);
     }
     //  else {
     //   // unknown type -- assume literal value
@@ -13836,10 +13863,17 @@
     return /^( ?[_a-z][-_a-z0-9]*\b)+$/i.test(str);
   }
 
+
   function isSvgNumber(o) {
     return utils.isFiniteNumber(o) || utils.isString(o) && /^-?[.0-9]+$/.test(o);
   }
 
+  function parseBoolean(o) {
+    if (o === true || o === 'true') return true;
+    if (o === false || o === 'false') return false;
+    return null;
+  }
+
   function isSvgMeasure(o) {
     return utils.isFiniteNumber(o) || utils.isString(o) && /^-?[.0-9]+[a-z]*$/.test(o);
   }
@@ -13863,6 +13897,7 @@
     getSymbolPropertyAccessor: getSymbolPropertyAccessor,
     isSvgClassName: isSvgClassName,
     isSvgNumber: isSvgNumber,
+    parseBoolean: parseBoolean,
     isSvgMeasure: isSvgMeasure,
     parseSvgMeasure: parseSvgMeasure,
     isSvgColor: isSvgColor
@@ -14081,6 +14116,9 @@
       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;
   }
 
@@ -17997,6 +18035,10 @@ ${svg}
     return chunks;
   }
 
+  function parseNumberList(token) {
+    return token.split(',').map(parseFloat);
+  }
+
   // Split comma-delimited list, trim quotes from entire list and
   // individual members
   function parseStringList(token) {
@@ -18032,9 +18074,9 @@ ${svg}
     // Updated: don't trim space from tokens like [delimeter= ]
     argv = argv.map(function(s) {
       if (!/= $/.test(s)) {
-        s = s.trimEnd();
+        s = utils.rtrim(s);
       }
-      s = s.trimStart();
+      s = utils.ltrim(s);
       return s;
     });
     argv = argv.filter(function(s) {return s !== '';}); // remove empty tokens
@@ -18086,6 +18128,7 @@ ${svg}
   var OptionParsingUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
     splitShellTokens: splitShellTokens,
+    parseNumberList: parseNumberList,
     parseStringList: parseStringList,
     parseColorList: parseColorList,
     cleanArgv: cleanArgv,
@@ -18277,7 +18320,7 @@ ${svg}
         } else if (type == 'strings') {
           val = parseStringList(token);
         } else if (type == 'bbox' || type == 'numbers') {
-          val = token.split(',').map(parseFloat);
+          val = parseNumberList(token);
         } else if (type == 'percent') {
           // val = utils.parsePercent(token);
           val = token; // string value is parsed by command function
@@ -20071,42 +20114,73 @@ ${svg}
         describe: 'sides of a polygon or star symbol',
         type: 'number'
       })
+      .option('orientation', {
+        // describe: 'use orientation=b for a rotated or flipped orientation'
+      })
+      .option('flipped', {
+        type: 'flag',
+        describe: 'symbol is vertically flipped'
+      })
+      .option('rotated', {
+        type: 'flag',
+        describe: 'symbol is rotated to a different orientation'
+      })
       .option('rotation', {
         describe: 'rotation of symbol in degrees'
       })
-      .option('orientation', {
-        describe: 'use orientation=b for a rotated or flipped orientation'
-      })
       .option('length', {
         // alias for arrow-length
       })
-      .option('star-ratio', {
-        describe: 'ratio of major to minor radius of star',
+      .option('point-ratio', {
+        old_alias: 'star-ratio',
+        describe: '(star) ratio of minor to major radius of star',
         type: 'number'
       })
-      .option('arrow-length', {
-        describe: 'length of arrows in pixels (use with type=arrow)'
+      .option('radii', {
+        describe: '(ring) comma-sep. list of concentric radii, ascending order'
+      })
+      .option('length', {
+        old_alias: 'arrow-length',
+        describe: '(arrow) length of arrow in pixels'
+      })
+      .option('direction', {
+        old_alias: 'arrow-direction',
+        describe: '(arrow) angle off vertical (-90 = left-pointing)'
+      })
+      .option('head-angle', {
+        old_alias: 'arrow-head-angle',
+        describe: '(arrow) angle of tip of arrow (default is 40 degrees)'
+      })
+      .option('head-width', {
+        old_alias: 'arrow-head-width',
+        describe: '(arrow) width of arrow head from side to side'
       })
-      .option('arrow-direction', {
-        describe: 'angle off of vertical (-90 = left-pointing arrow)'
+      .option('head-length', {
+        old_alias: 'arrow-head-width',
+        describe: '(arrow) length of head (alternative to head-angle)'
       })
-      .option('arrow-head-angle', {
-        describe: 'angle of tip of arrow (default is 40 degrees)'
+      .option('head-shape', {
+        // describe: 'options: a b c'
       })
-      .option('arrow-head-width', {
-        describe: 'size of arrow head from side to side'
+      .option('stem-width', {
+        old_alias: 'arrow-stem-width',
+        describe: '(arrow) width of stem at its widest point'
       })
-      .option('arrow-stem-width', {
-        describe: 'width of stem at its widest point'
+      .option('stem-length', {
+        old_alias: 'arrow-stem-length',
+        describe: '(arrow) alternative to length'
       })
-      .option('arrow-stem-taper', {
-        describe: 'factor for tapering the width of the stem'
+      .option('stem-taper', {
+        old_alias: 'arrow-stem-taper',
+        describe: '(arrow) factor for tapering the width of the stem (0-1)'
       })
-      .option('arrow-stem-curve', {
-        describe: 'curvature in degrees (arrows are straight by default)'
+      .option('stem-curve', {
+        old_alias: 'arrow-stem-curve',
+        describe: '(arrow) curvature in degrees (default is 0)'
       })
-      .option('arrow-min-stem', {
-        describe: 'min ratio of stem to total length (for small arrows)',
+      .option('min-stem-ratio', {
+        old_alias: 'arrow-min-stem',
+        describe: '(arrow) min ratio of stem to total length',
         type: 'number'
       })
       .option('stroke', {})
@@ -21643,7 +21717,7 @@ ${svg}
           collectionType = 'mixed';
         }
       } else if (currType != t) {
-        stop("Unable to import mixed-geometry GeoJSON features");
+        stop("Unable to import mixed-geometry features");
       }
     }
 
@@ -21754,6 +21828,33 @@ ${svg}
     importShp: importShp
   });
 
+  function importGeoJSON(src, optsArg) {
+    var opts = optsArg || {};
+    var supportedGeometries = Object.keys(GeoJSON.pathImporters),
+        srcObj = utils.isString(src) ? JSON.parse(src) : src,
+        importer = new GeoJSONParser(opts),
+        srcCollection, dataset;
+
+    // Convert single feature or geometry into a collection with one member
+    if (srcObj.type == 'Feature') {
+      srcCollection = {
+        type: 'FeatureCollection',
+        features: [srcObj]
+      };
+    } else if (supportedGeometries.includes(srcObj.type)) {
+      srcCollection = {
+        type: 'GeometryCollection',
+        geometries: [srcObj]
+      };
+    } else {
+      srcCollection = srcObj;
+    }
+    (srcCollection.features || srcCollection.geometries || []).forEach(importer.parseObject);
+    dataset = importer.done();
+    importCRS(dataset, srcObj); // TODO: remove this
+    return dataset;
+  }
+
   function GeoJSONParser(opts) {
     var idField = opts.id_field || GeoJSON.ID_FIELD,
         importer = new PathImporter(opts),
@@ -21775,8 +21876,11 @@ ${svg}
         geom = o;
       }
       // TODO: improve so geometry_type option skips features instead of creating null geometries
-      importer.startShape(rec);
-      if (geom) GeoJSON.importGeometry(geom, importer, opts);
+      if (geom && geom.type == 'GeometryCollection') {
+        GeoJSON.importComplexFeature(importer, geom, rec, opts);
+      } else {
+        GeoJSON.importSimpleFeature(importer, geom, rec, opts);
+      }
     };
 
     this.done = function() {
@@ -21784,50 +21888,58 @@ ${svg}
     };
   }
 
-  function importGeoJSON(src, optsArg) {
-    var opts = optsArg || {};
-    var supportedGeometries = Object.keys(GeoJSON.pathImporters),
-        srcObj = utils.isString(src) ? JSON.parse(src) : src,
-        importer = new GeoJSONParser(opts),
-        srcCollection, dataset;
-
-    // Convert single feature or geometry into a collection with one member
-    if (srcObj.type == 'Feature') {
-      srcCollection = {
-        type: 'FeatureCollection',
-        features: [srcObj]
-      };
-    } else if (supportedGeometries.includes(srcObj.type)) {
-      srcCollection = {
-        type: 'GeometryCollection',
-        geometries: [srcObj]
-      };
-    } else {
-      srcCollection = srcObj;
+  GeoJSON.importComplexFeature = function(importer, geom, rec, opts) {
+    var types = divideGeometriesByType(geom.geometries || []);
+    if (types.length === 0) {
+      importer.startShape(rec); // import a feature with null geometry
+      return;
     }
-    (srcCollection.features || srcCollection.geometries || []).forEach(importer.parseObject);
-    dataset = importer.done();
-    importCRS(dataset, srcObj); // TODO: remove this
-    return dataset;
+    types.forEach(function(geometries, i) {
+      importer.startShape(copyRecord(rec));
+      geometries.forEach(function(geom) {
+        GeoJSON.importSimpleGeometry(importer, geom, opts);
+      });
+    });
+  };
+
+  function divideGeometriesByType(geometries, index) {
+    index = index || {};
+    geometries.forEach(function(geom) {
+      if (!geom) return;
+      var mtype = GeoJSON.translateGeoJSONType(geom.type);
+      if (mtype) {
+        if (mtype in index === false) {
+          index[mtype] = [];
+        }
+        index[mtype].push(geom);
+      } else if (geom.type == 'GeometryCollection') {
+        divideGeometriesByType(geom.geometries || [], index);
+      }
+    });
+    return Object.values(index);
   }
 
-  GeoJSON.importGeometry = function(geom, importer, opts) {
-    var type = geom.type;
-    if (type in GeoJSON.pathImporters) {
+  GeoJSON.importSimpleFeature = function(importer, geom, rec, opts) {
+    importer.startShape(rec);
+    GeoJSON.importSimpleGeometry(importer, geom, opts);
+  };
+
+  GeoJSON.importSimpleGeometry = function(importer, geom, opts) {
+    var type = geom ? geom.type : null;
+    if (type === null) {
+      // no geometry to import
+    } else if (type in GeoJSON.pathImporters) {
       if (opts.geometry_type && opts.geometry_type != GeoJSON.translateGeoJSONType(type)) {
         // kludge to filter out all but one type of geometry
         return;
       }
       GeoJSON.pathImporters[type](geom.coordinates, importer);
-    } else if (type == 'GeometryCollection') {
-      geom.geometries.forEach(function(geom) {
-        GeoJSON.importGeometry(geom, importer, opts);
-      });
     } else {
-      verbose("GeoJSON.importGeometry() Unsupported geometry type:", geom.type);
+      verbose("Unsupported geometry type:", geom.type);
     }
   };
 
+
   // Functions for importing geometry coordinates using a PathImporter
   //
   GeoJSON.pathImporters = {
@@ -21866,8 +21978,8 @@ ${svg}
 
   var GeojsonImport = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    GeoJSONParser: GeoJSONParser,
     importGeoJSON: importGeoJSON,
+    GeoJSONParser: GeoJSONParser,
     importCRS: importCRS
   });
 
@@ -37929,91 +38041,131 @@ ${svg}
     points.push(p2);
   }
 
-  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)];
-
-    rotateCoords(stem, d.rotation);
-    rotateCoords(head, d.rotation);
-    return [stem, head];
-  }
-
-  function getMinStemRatio(d) {
-    return d['arrow-min-stem'] >= 0 ? d['arrow-min-stem'] : 0.4;
-  }
-
-  function getFilledArrowCoords(totalLen, d) {
-    var minStemRatio = getMinStemRatio(d),
-        headAngle = d['arrow-head-angle'] || 40,
-        direction = d.rotation || d['arrow-direction'] || 0,
-        unscaledStemWidth = d['arrow-stem-width'] || 2,
-        unscaledHeadWidth = d['arrow-head-width'] || unscaledStemWidth * 3,
-        unscaledHeadLen = getHeadLength(unscaledHeadWidth, headAngle),
-        scale = getScale(totalLen, unscaledHeadLen, minStemRatio),
-        headWidth = unscaledHeadWidth * scale,
-        headLen = unscaledHeadLen * scale,
-        stemWidth = unscaledStemWidth * scale,
-        stemTaper = d['arrow-stem-taper'] || 0,
-        stemCurve = d['arrow-stem-curve'] || 0,
-        stemLen = totalLen - headLen;
-
-    var headDx = headWidth / 2,
-        stemDx = stemWidth / 2,
-        baseDx = stemDx * (1 - stemTaper);
+  // 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)];
 
-    var coords;
+  //   rotateCoords(stem, d.rotation);
+  //   rotateCoords(head, d.rotation);
+  //   return [stem, head];
+  // }
+
+  // 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 addPoints(a, b) {
+  //   return [a[0] + b[0], a[1] + b[1]];
+  // }
+
+  function getFilledArrowCoords(d) {
+    var direction = d.rotation || d.direction || 0,
+        stemTaper = d['stem-taper'] || 0,
+        stemCurve = d['stem-curve'] || 0,
+        size = calcArrowSize(d);
+
+    if (!size) return null;
+
+    var headDx = size.headWidth / 2,
+        stemDx = size.stemWidth / 2,
+        baseDx = stemDx * (1 - stemTaper),
+        coords;
 
     if (!stemCurve || Math.abs(stemCurve) > 90) {
-      coords = [[baseDx, 0], [stemDx, stemLen], [headDx, stemLen], [0, stemLen + headLen],
-          [-headDx, stemLen], [-stemDx, stemLen], [-baseDx, 0], [baseDx, 0]];
+      coords = calcStraightArrowCoords(size.stemLen, size.headLen, stemDx, headDx, baseDx);
     } else {
       if (direction > 0) stemCurve = -stemCurve;
-      coords = getCurvedArrowCoords(stemLen, headLen, stemCurve, stemDx, headDx, baseDx);
+      coords = getCurvedArrowCoords(size.stemLen, size.headLen, stemCurve, stemDx, headDx, baseDx);
     }
 
     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 getScale(totalLen, headLen, minStemRatio) {
+  function calcArrowSize(d) {
+    var totalLen = d.radius || d.length || d.r || 0,
+        scale = 1,
+        o = initArrowSize(d); // calc several parameters
+
+    if (totalLen > 0) {
+      scale = calcScale(totalLen, o.headLen, d);
+      o.stemWidth *= scale;
+      o.headWidth *= scale;
+      o.headLen *= scale;
+      o.stemLen = totalLen - o.headLen;
+    }
+
+    if (o.headWidth < o.stemWidth) {
+      stop('Arrow head must be at least as wide as the stem.');
+    }
+    return o;
+  }
+
+  function calcScale(totalLen, headLen, d) {
+    var minStemRatio = d['min-stem-ratio'] >= 0 ? d['min-stem-ratio'] : 0;
+    var stemLen = d['stem-length'] || 0;
     var maxHeadPct = 1 - minStemRatio;
     var headPct = headLen / totalLen;
+    var scale = 1;
+
     if (headPct > maxHeadPct) {
-      return maxHeadPct / headPct;
+      scale = maxHeadPct / headPct;
+    } else if (stemLen + headLen > totalLen) {
+      scale = totalLen / (stemLen + headLen);
     }
-    return 1;
+    return scale;
   }
 
-  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 addPoints(a, b) {
-    return [a[0] + b[0], a[1] + b[1]];
+  function initArrowSize(d) {
+    var sizeRatio = getHeadSizeRatio(d['head-angle'] || 40); // length to width
+    var o = {
+      stemWidth: d['stem-width'] || 2,
+      stemLen: d['stem-length'] || 0,
+      headWidth: d['head-width'],
+      headLen: d['head-length']
+    };
+    if (!o.headWidth) {
+      if (o.headLen) {
+        o.headWidth = o.headLen / sizeRatio;
+      } else {
+        o.headWidth = o.stemWidth * 3; // assumes stemWidth has been set
+      }
+    }
+    if (!o.headLen) {
+      o.headLen = o.headWidth * sizeRatio;
+    }
+    return o;
   }
 
 
-  function getHeadLength(headWidth, headAngle) {
-    var headRatio = 1 / Math.tan(Math.PI * headAngle / 180 / 2) / 2; // length-to-width head ratio
-    return headWidth * headRatio;
+  // Returns ratio of head length to head width
+  function getHeadSizeRatio(headAngle) {
+    return 1 / Math.tan(Math.PI * headAngle / 180 / 2) / 2;
   }
 
   function getCurvedArrowCoords(stemLen, headLen, curvature, stemDx, headDx, baseDx) {
@@ -38028,15 +38180,18 @@ ${svg}
     var ay = baseDx * Math.sin(theta) * -sign;
     var leftStem = getCurvedStemCoords(-ax, -ay, -stemDx + dx, dy, theta);
     var rightStem = getCurvedStemCoords(ax, ay, stemDx + dx, dy, theta);
-    // if (stemTaper == 1) leftStem.pop();
     var stem = leftStem.concat(rightStem.reverse());
-    stem.pop();
+    // stem.pop();
     return stem.concat(head);
   }
 
   // ax, ay: point on the base
   // bx, by: point on the stem
   function getCurvedStemCoords(ax, ay, bx, by, theta0) {
+    // case: curved side intrudes into head (because stem is too short)
+    if (ay > by) {
+      return [[ax * by / ay, by]];
+    }
     var dx = bx - ax,
         dy = by - ay,
         dy1 = (dy * dy - dx * dx) / (2 * dy),
@@ -38048,10 +38203,9 @@ ${svg}
         leftBend = bx > ax,
         sign = leftBend ? 1 : -1,
         points = Math.round(degrees / 5) + 2,
-        // points = theta > 2 && 7 || theta > 1 && 6 || 5,
-        increment = theta / (points + 1);
+        increment = theta / (points + 1),
+        coords = [[bx, by]];
 
-    var coords = [[bx, by]];
     for (var i=1; i<= points; i++) {
       var phi = i * increment / 2;
       var sinPhi = Math.sin(phi);
@@ -38068,9 +38222,11 @@ ${svg}
   // sides: e.g. 5-pointed star has 10 sides
   // radius: distance from center to point
   //
-  function getPolygonCoords(radius, opts) {
-    var type = opts.type;
-    var sides = +opts.sides || getDefaultSides(type);
+  function getPolygonCoords(d) {
+    var radius = d.radius || d.length || d.r;
+    if (radius > 0 === false) return null;
+    var type = d.type;
+    var sides = +d.sides || getDefaultSides(type);
     var isStar = type == 'star';
     if (isStar && (sides < 6 || sides % 2 !== 0)) {
       stop(`Invalid number of sides for a star (${sides})`);
@@ -38081,14 +38237,14 @@ ${svg}
         angle = 360 / sides,
         b = isStar ? 1 : 0.5,
         theta, even, len;
-    if (opts.orientation == 'b') {
+    if (d.orientation == 'b' || d.flipped || d.rotated) {
       b = 0;
     }
     for (var i=0; i<sides; i++) {
       even = i % 2 == 0;
       len = radius;
       if (isStar && even) {
-        len *= (opts.star_ratio || 0.5);
+        len *= (d.star_ratio || 0.5);
       }
       theta = (i + b) * angle % 360;
       coords.push(getPlanarSegmentEndpoint(0, 0, theta, len));
@@ -38112,6 +38268,37 @@ ${svg}
     }[type] || 4;
   }
 
+  // Returns GeoJSON MultiPolygon coords
+  function getRingCoords(d) {
+    var radii = parseRings(d.radii || '2');
+    var coords = [];
+    var solidCenter = utils.isOdd(radii.length);
+    var ring, hole;
+    for (var i=0; i<radii.length; i++) {
+      ring = getPolygonCoords({
+        type: 'circle',
+        radius: radii[i]
+      });
+      if (!solidCenter || i > 0) {
+        i++;
+        hole = ring;
+        ring = getPolygonCoords({
+          type: 'circle',
+          radius: radii[i]
+        });
+        ring.push(hole[0]);
+      }
+      coords.push(ring);
+    }
+    return coords;
+  }
+
+  function parseRings(arg) {
+    var arr = Array.isArray(arg) ? arg : parseNumberList(arg);
+    utils.genericSort(arr, true);
+    return utils.uniq(arr);
+  }
+
   // TODO: refactor to remove duplication in mapshaper-svg-style.js
   cmd.symbols = function(inputLyr, dataset, opts) {
     requireSinglePointLayer(inputLyr);
@@ -38128,16 +38315,17 @@ ${svg}
       if (!shp) return null;
       var d = getSymbolData(i);
       var rec = records[i] || {};
-      var coords, size, constructor;
+      var geojsonType = 'Polygon';
+      var coords;
       if (d.type == 'arrow') {
-        size = d.radius || d.length || d['arrow-length'] || d.r;
-        constructor = getFilledArrowCoords;
+        coords = getFilledArrowCoords(d);
+      } else if (d.type == 'ring') {
+        coords = getRingCoords(d);
+        geojsonType = 'MultiPolygon';
       } else {
-        size = d.radius || d.length || d.r;
-        constructor = getPolygonCoords;
+        coords = getPolygonCoords(d);
       }
-      if (size > 0 === false) return null;
-      coords = constructor(size, d, opts);
+      if (!coords) return null;
       rotateCoords(coords, +d.rotation || 0);
       if (!polygonMode) {
         flipY(coords);
@@ -38148,9 +38336,9 @@ ${svg}
       if (polygonMode) {
         scaleAndShiftCoords(coords, metersPerPx, shp[0]);
         if (d.tfill) rec.fill = d.fill;
-        return createGeometry(coords);
+        return createGeometry(coords, geojsonType);
       } else {
-        rec['svg-symbol'] = makeSvgSymbol(coords, d);
+        rec['svg-symbol'] = makeSvgPolygonSymbol(coords, d, geojsonType);
       }
     });
 
@@ -38181,9 +38369,9 @@ ${svg}
     return importGeoJSON(geojson);
   }
 
-  function createGeometry(coords) {
+  function createGeometry(coords, type) {
     return {
-      type: 'Polygon',
+      type: type,
       coordinates: coords
     };
   }
@@ -38196,7 +38384,12 @@ ${svg}
   }
 
   // Returns an svg-symbol data object for one symbol
-  function makeSvgSymbol(coords, properties) {
+  function makeSvgPolygonSymbol(coords, properties, geojsonType) {
+    if (geojsonType == 'MultiPolygon') {
+      coords = convertMultiPolygonCoords(coords);
+    } else if (geojsonType != 'Polygon') {
+      error('Unsupported type:', geojsonType);
+    }
     roundCoordsForSVG(coords);
     return {
       type: 'polygon',
@@ -38205,9 +38398,14 @@ ${svg}
     };
   }
 
+  function convertMultiPolygonCoords(coords) {
+    return coords.reduce(function(memo, poly) {
+      return memo.concat(poly);
+    }, []);
+  }
+
   var Symbols = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    makeSvgSymbol: makeSvgSymbol
+    __proto__: null
   });
 
   cmd.target = function(catalog, opts) {