mapshaper 0.5.81 → 0.5.85

package/www/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,21 @@
     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',
+    sides: 'number', // polygons and stars
+    points: 'number', // polygons and stars
+    anchor: null, // arrows; takes start, middle, end
+    '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 +13758,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 +13770,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 +13787,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 +13810,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 +13844,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 +13866,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 +13900,7 @@
     getSymbolPropertyAccessor: getSymbolPropertyAccessor,
     isSvgClassName: isSvgClassName,
     isSvgNumber: isSvgNumber,
+    parseBoolean: parseBoolean,
     isSvgMeasure: isSvgMeasure,
     parseSvgMeasure: parseSvgMeasure,
     isSvgColor: isSvgColor
@@ -14081,6 +14119,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 +18038,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) {
@@ -18086,6 +18131,7 @@ ${svg}
   var OptionParsingUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
     splitShellTokens: splitShellTokens,
+    parseNumberList: parseNumberList,
     parseStringList: parseStringList,
     parseColorList: parseColorList,
     cleanArgv: cleanArgv,
@@ -18277,7 +18323,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
@@ -20068,47 +20114,82 @@ ${svg}
         type: 'distance'
       })
       .option('sides', {
-        describe: 'sides of a polygon or star symbol',
+        describe: 'number of sides of a polygon symbol',
         type: 'number'
       })
+      .option('orientation', {
+        // TODO: removed (replaced by flipped and rotated)
+        // 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('points', {
+        describe: '(star) number of points'
+      })
+      .option('point-ratio', {
+        old_alias: 'star-ratio',
+        describe: '(star) ratio of minor to major radius of star',
+        type: 'number'
+      })
+      .option('radii', {
+        describe: '(ring) comma-sep. list of concentric radii, ascending order'
       })
       .option('length', {
-        // alias for arrow-length
+        old_alias: 'arrow-length',
+        describe: '(arrow) length of arrow in pixels'
       })
-      .option('star-ratio', {
-        describe: 'ratio of major to minor radius of star',
-        type: 'number'
+      .option('direction', {
+        old_alias: 'arrow-direction',
+        describe: '(arrow) angle off vertical (-90 = left-pointing)'
       })
-      .option('arrow-length', {
-        describe: 'length of arrows in pixels (use with type=arrow)'
+      .option('head-angle', {
+        old_alias: 'arrow-head-angle',
+        describe: '(arrow) angle of tip of arrow (default is 40 degrees)'
       })
-      .option('arrow-direction', {
-        describe: 'angle off of vertical (-90 = left-pointing arrow)'
+      .option('head-width', {
+        old_alias: 'arrow-head-width',
+        describe: '(arrow) width of arrow head from side to side'
       })
-      .option('arrow-head-angle', {
-        describe: 'angle of tip of arrow (default is 40 degrees)'
+      .option('head-length', {
+        old_alias: 'arrow-head-width',
+        describe: '(arrow) length of head (alternative to head-angle)'
       })
-      .option('arrow-head-width', {
-        describe: 'size of arrow head from side to side'
+      .option('head-shape', {
+        // describe: 'options: a b c'
       })
-      .option('arrow-stem-width', {
-        describe: 'width of stem at its widest point'
+      .option('stem-width', {
+        old_alias: 'arrow-stem-width',
+        describe: '(arrow) width of stem at its widest point'
       })
-      .option('arrow-stem-taper', {
-        describe: 'factor for tapering the width of the stem'
+      .option('stem-length', {
+        old_alias: 'arrow-stem-length',
+        describe: '(arrow) alternative to length'
       })
-      .option('arrow-stem-curve', {
-        describe: 'curvature in degrees (arrows are straight by default)'
+      .option('stem-taper', {
+        old_alias: 'arrow-stem-taper',
+        describe: '(arrow) factor for tapering the width of the stem (0-1)'
       })
-      .option('arrow-min-stem', {
-        describe: 'min ratio of stem to total length (for small arrows)',
+      .option('stem-curve', {
+        old_alias: 'arrow-stem-curve',
+        describe: '(arrow) curvature in degrees (default is 0)'
+      })
+      .option('min-stem-ratio', {
+        old_alias: 'arrow-min-stem',
+        describe: '(arrow) min ratio of stem to total length',
         type: 'number'
       })
+      .option('anchor', {
+        describe: '(arrow) takes one of: start, middle, end (default is start)'
+      })
       .option('stroke', {})
       .option('stroke-width', {})
       .option('fill', {
@@ -21643,7 +21724,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 +21835,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 +21883,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 +21895,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 +21985,8 @@ ${svg}
 
   var GeojsonImport = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    GeoJSONParser: GeoJSONParser,
     importGeoJSON: importGeoJSON,
+    GeoJSONParser: GeoJSONParser,
     importCRS: importCRS
   });
 
@@ -37929,111 +38048,153 @@ ${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,
-        coords;
-
-    var headDx = headWidth / 2,
-        stemDx = stemWidth / 2,
-        baseDx = stemDx * (1 - stemTaper);
-
-    if (unscaledHeadWidth < unscaledStemWidth) {
-      stop('Arrow head must be at least as wide as the stem.');
-    }
+  // 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)];
+
+  //   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]];
+  // }
 
-    if (!stemCurve || Math.abs(stemCurve) > 90) {
-      coords = [[baseDx, 0], [stemDx, stemLen], [headDx, stemLen], [0, stemLen + headLen],
+  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]];
-    } else {
-      if (direction > 0) stemCurve = -stemCurve;
-      coords = getCurvedArrowCoords(stemLen, headLen, stemCurve, stemDx, headDx, baseDx);
+  }
+
+  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;
     }
 
-    rotateCoords(coords, direction);
-    return [coords];
+    if (o.headWidth < o.stemWidth) {
+      stop('Arrow head must be at least as wide as the stem.');
+    }
+    return o;
   }
 
-
-  function getScale(totalLen, headLen, minStemRatio) {
+  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 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 addPoints(a, b) {
-    return [a[0] + b[0], a[1] + b[1]];
-  }
 
+  // Returns ratio of head length to head width
+  function getHeadSizeRatio(headAngle) {
+    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());
 
-  function getHeadLength(headWidth, headAngle) {
-    var headRatio = 1 / Math.tan(Math.PI * headAngle / 180 / 2) / 2; // length-to-width head ratio
-    return headWidth * headRatio;
-  }
+    } else {
+      dx = 0;
+      dy = stemLen;
+      stem = [[-baseDx, 0], [baseDx, 0], [baseDx, 0]];
+    }
 
-  function getCurvedArrowCoords(stemLen, headLen, curvature, stemDx, headDx, baseDx) {
     // coordinates go counter clockwise, starting from the leftmost head coordinate
-    var theta = Math.abs(curvature) / 180 * Math.PI;
-    var sign = curvature > 0 ? 1 : -1;
-    var dx = stemLen * Math.sin(theta / 2) * sign;
-    var dy = stemLen * Math.cos(theta / 2);
-    var head = [[stemDx + dx, dy], [headDx + dx, dy],
-      [dx, headLen + dy], [-headDx + dx, dy], [-stemDx + dx, dy]];
-    var ax = baseDx * Math.cos(theta); // rotate arrow base
-    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);
-    var stem = leftStem.concat(rightStem.reverse());
-    // stem.pop();
-    return stem.concat(head);
+    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') {
+      scaleAndShiftCoords(coords, 1, [-dx/2, (-dy - headLen)/2]);
+    }
+
+    rotateCoords(coords, direction);
+    if (d.flipped) {
+      flipY(coords);
+    }
+    return [coords];
   }
 
   // ax, ay: point on the base
@@ -38070,15 +38231,45 @@ ${svg}
     return coords;
   }
 
+  function getMinorRadius(points) {
+    var innerAngle = 360 / points;
+    var pointAngle = getDefaultPointAngle(points);
+    var thetaA = Math.PI / 180 * innerAngle / 2;
+    var thetaB = Math.PI / 180 * pointAngle / 2;
+    var a = Math.tan(thetaB) / (Math.tan(thetaB) + Math.tan(thetaA));
+    var c = a / Math.cos(thetaA);
+    return c;
+  }
+
+
+  function getPointAngle(points, skip) {
+    var unitAngle = 360 / points;
+    var centerAngle = unitAngle * (skip + 1);
+    return 180 - centerAngle;
+  }
+
+  function getDefaultPointAngle(points) {
+    var minSkip = 1;
+    var maxSkip = Math.ceil(points / 2) - 2;
+    var skip = Math.floor((maxSkip + minSkip) / 2);
+    return getPointAngle(points, skip);
+  }
+
   // 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})`);
+    if (isStar && d.points > 0) {
+      sides = d.points * 2;
+    }
+    var starRatio = isStar ? d.star_ratio || getMinorRadius(sides / 2) : 0;
+    if (isStar && (sides < 10 || sides % 2 !== 0)) {
+      stop(`Invalid number of points for a star (${sides / 2})`);
     } else if (sides >= 3 === false) {
       stop(`Invalid number of sides (${sides})`);
     }
@@ -38086,14 +38277,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 *= starRatio;
       }
       theta = (i + b) * angle % 360;
       coords.push(getPlanarSegmentEndpoint(0, 0, theta, len));
@@ -38117,6 +38308,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);
@@ -38133,16 +38355,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);
@@ -38153,9 +38376,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);
       }
     });
 
@@ -38186,9 +38409,9 @@ ${svg}
     return importGeoJSON(geojson);
   }
 
-  function createGeometry(coords) {
+  function createGeometry(coords, type) {
     return {
-      type: 'Polygon',
+      type: type,
       coordinates: coords
     };
   }
@@ -38201,7 +38424,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',
@@ -38210,9 +38438,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) {