mapshaper 0.5.84 → 0.5.88

package/mapshaper.js

@@ -1,6 +1,6 @@
 (function () {
 
-  var VERSION = "0.5.83";
+  var VERSION = "0.5.87";
 
 
   var utils = /*#__PURE__*/Object.freeze({
@@ -4895,6 +4895,11 @@
     };
   }
 
+  function MultiShapeIter(arcs) {
+    var iter = new ShapeIter(arcs);
+
+  }
+
   // Iterate along a path made up of one or more arcs.
   //
   function ShapeIter(arcs) {
@@ -4945,6 +4950,7 @@
     PointIter: PointIter,
     ArcIter: ArcIter,
     FilteredArcIter: FilteredArcIter,
+    MultiShapeIter: MultiShapeIter,
     ShapeIter: ShapeIter
   });
 
@@ -8222,10 +8228,21 @@
     return +n.toPrecision(d);
   }
 
+
   function roundToDigits(n, d) {
     return +n.toFixed(d); // string conversion makes this slow
   }
 
+  // Used in mapshaper-expression-utils.js
+  // TODO: choose between this and the above function
+  function roundToDigits2(n, d) {
+    var k = 1;
+    if (!n && n !== 0) return n; // don't coerce null to 0
+    d = d | 0;
+    while (d-- > 0) k *= 10;
+    return Math.round(n * k) / k;
+  }
+
   function roundToTenths(n) {
     return (Math.round(n * 10)) / 10;
   }
@@ -8300,6 +8317,7 @@
     __proto__: null,
     roundToSignificantDigits: roundToSignificantDigits,
     roundToDigits: roundToDigits,
+    roundToDigits2: roundToDigits2,
     roundToTenths: roundToTenths,
     getRoundingFunction: getRoundingFunction,
     getBoundsPrecisionForDisplay: getBoundsPrecisionForDisplay,
@@ -8938,15 +8956,15 @@
     });
   }
 
-  function addUtils(env) {
+  function cleanExpression(exp) {
+    // workaround for problem in GNU Make v4: end-of-line backslashes inside
+    // quoted strings are left in the string (other shell environments remove them)
+    return exp.replace(/\\\n/g, ' ');
+  }
+
+  function addFeatureExpressionUtils(env) {
     Object.assign(env, {
-      round: function(val, dig) {
-        var k = 1;
-        if (!val && val !== 0) return val; // don't coerce null to 0
-        dig = dig | 0;
-        while(dig-- > 0) k *= 10;
-        return Math.round(val * k) / k;
-      },
+      round: roundToDigits2,
       int_median: interpolated_median,
       sprintf: utils.format,
       blend: blend
@@ -9325,6 +9343,39 @@
     };
   }
 
+  // Returns an object representing a layer in a JS expression
+  function getLayerProxy(lyr, arcs) {
+    var obj = {};
+    var records = lyr.data ? lyr.data.getRecords() : null;
+    var getters = {
+      name: lyr.name,
+      data: records,
+      type: lyr.geometry_type
+    };
+    addGetters(obj, getters);
+    addBBoxGetter(obj, lyr, arcs);
+    obj.empty = function() {
+      return getFeatureCount(lyr) === 0;
+    };
+    obj.size = function() {
+      return getFeatureCount(lyr);
+    };
+    return obj;
+  }
+
+  function addLayerGetters(ctx, lyr, arcs) {
+    var layerProxy;
+    addGetters(ctx, {
+      layer_name: lyr.name || '', // consider removing this
+      layer: function() {
+        // init on first access (to avoid overhead if not used)
+        if (!layerProxy) layerProxy = getLayerProxy(lyr, arcs);
+        return layerProxy;
+      }
+    });
+    return ctx;
+  }
+
   function addBBoxGetter(obj, lyr, arcs) {
     var bbox;
     addGetters(obj, {
@@ -9354,32 +9405,6 @@
     return bbox;
   }
 
-  // Returns an object representing a layer in a JS expression
-  function getLayerProxy(lyr, arcs) {
-    var obj = {};
-    var records = lyr.data ? lyr.data.getRecords() : null;
-    var getters = {
-      name: lyr.name,
-      data: records
-    };
-    addGetters(obj, getters);
-    addBBoxGetter(obj, lyr, arcs);
-    return obj;
-  }
-
-  function addLayerGetters(ctx, lyr, arcs) {
-    var layerProxy;
-    addGetters(ctx, {
-      layer_name: lyr.name || '', // consider removing this
-      layer: function() {
-        // init on first access (to avoid overhead if not used)
-        if (!layerProxy) layerProxy = getLayerProxy(lyr, arcs);
-        return layerProxy;
-      }
-    });
-    return ctx;
-  }
-
   // Returns a function to return a feature proxy by id
   // (the proxy appears as "this" or "$" in a feature expression)
   function initFeatureProxy(lyr, arcs, optsArg) {
@@ -9576,11 +9601,6 @@
     return compileFeatureExpression(exp, lyr, arcs, opts);
   }
 
-  function cleanExpression(exp) {
-    // workaround for problem in GNU Make v4: end-of-line backslashes inside
-    // quoted strings are left in the string (other shell environments remove them)
-    return exp.replace(/\\\n/g, ' ');
-  }
 
   function compileFeaturePairFilterExpression(exp, lyr, arcs) {
     var func = compileFeaturePairExpression(exp, lyr, arcs);
@@ -9716,14 +9736,19 @@
 
   function compileExpressionToFunction(exp, opts) {
     // $$ added to avoid duplication with data field variables (an error condition)
-    var functionBody = "with($$env){with($$record){ " + (opts.returns ? 'return ' : '') +
-          exp + "}}";
-    var func;
+    var functionBody, func;
+    if (opts.returns) {
+      // functionBody = 'return ' + functionBody;
+      functionBody = 'var $$retn = ' + exp + '; return $$retn;';
+    } else {
+      functionBody = exp;
+    }
+    functionBody = 'with($$env){with($$record){ ' + functionBody + '}}';
     try {
-      func = new Function("$$record,$$env",  functionBody);
+      func = new Function('$$record,$$env',  functionBody);
     } catch(e) {
       // if (opts.quiet) throw e;
-      stop(e.name, "in expression [" + exp + "]");
+      stop(e.name, 'in expression [' + exp + ']');
     }
     return func;
   }
@@ -9766,7 +9791,7 @@
     var ctx = {};
     var fields = lyr.data ? lyr.data.getFields() : [];
     opts = opts || {};
-    addUtils(env); // mix in round(), sprintf(), etc.
+    addFeatureExpressionUtils(env); // mix in round(), sprintf(), etc.
     if (fields.length > 0) {
       // default to null values, so assignments to missing data properties
       // are applied to the data record, not the global object
@@ -9821,7 +9846,6 @@
   var Expressions = /*#__PURE__*/Object.freeze({
     __proto__: null,
     compileValueExpression: compileValueExpression,
-    cleanExpression: cleanExpression,
     compileFeaturePairFilterExpression: compileFeaturePairFilterExpression,
     compileFeaturePairExpression: compileFeaturePairExpression,
     compileFeatureExpression: compileFeatureExpression,
@@ -13712,6 +13736,9 @@
     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',
@@ -18561,6 +18588,13 @@ ${svg}
       return this;
     };
 
+    this.options = function(o) {
+      Object.keys(o).forEach(function(key) {
+        this.option(key, o[key]);
+      }, this);
+      return this;
+    };
+
     this.done = function() {
       return _command;
     };
@@ -19524,14 +19558,6 @@ ${svg}
       .option('target', targetOpt)
       .option('no-replace', noReplaceOpt);
 
-    parser.command('ignore')
-      // .describe('stop processing if a condition is met')
-      .option('empty', {
-        describe: 'ignore empty files',
-        type: 'flag'
-      })
-      .option('target', targetOpt);
-
     parser.command('include')
       .describe('import JS data and functions for use in JS expressions')
       .option('file', {
@@ -20111,16 +20137,17 @@ ${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('flipped', {
+      //   type: 'flag',
+      //   describe: 'symbol is vertically flipped'
+      // })
       .option('rotated', {
         type: 'flag',
         describe: 'symbol is rotated to a different orientation'
@@ -20128,8 +20155,8 @@ ${svg}
       .option('rotation', {
         describe: 'rotation of symbol in degrees'
       })
-      .option('length', {
-        // alias for arrow-length
+      .option('points', {
+        describe: '(star) number of points'
       })
       .option('point-ratio', {
         old_alias: 'star-ratio',
@@ -20183,6 +20210,9 @@ ${svg}
         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', {
@@ -20490,6 +20520,49 @@ ${svg}
       })
       .option('target', targetOpt);
 
+    parser.section('Control flow commands');
+
+    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'
+      },
+      layer: {
+        describe: 'name or id of layer to test (default is current target)'
+      },
+      target: targetOpt
+    };
+
+    parser.command('if')
+      .describe('run the following commands if a condition is met')
+      .options(ifOpts);
+
+    parser.command('elif')
+      .describe('test an alternate condition; used after -if')
+      .options(ifOpts);
+
+    parser.command('else')
+      .describe('run commands if all preceding -if/-elif conditions are false');
+
+    parser.command('endif')
+      .describe('mark the end of an -if sequence');
+
+    parser.command('ignore')
+      // .describe('stop processing if a condition is met')
+      .option('empty', {
+        describe: 'ignore empty files',
+        type: 'flag'
+      })
+      .option('target', targetOpt);
+
     parser.section('Informational commands');
 
     parser.command('calc')
@@ -34162,6 +34235,141 @@ ${svg}
     };
   }
 
+  function resetControlFlow() {
+    setStateVar('control', null);
+  }
+
+  function inControlBlock() {
+    var state = getState();
+    return !!state.inControlBlock;
+  }
+
+  function enterActiveBranch() {
+    var state = getState();
+    state.inControlBlock = true;
+    state.active = true;
+    state.complete = true;
+  }
+
+  function enterInactiveBranch() {
+    var state = getState();
+    state.inControlBlock = true;
+    state.active = false;
+  }
+
+  function blockWasActive() {
+    return !!getState().complete;
+  }
+
+  function inActiveBranch() {
+    return !!getState().active;
+  }
+
+  function getState() {
+    var o = getStateVar('control') || setStateVar('control', {}) || getStateVar('control');
+    return o;
+  }
+
+  function compileLayerExpression(expr, lyr, dataset, opts) {
+    var proxy = getLayerProxy(lyr, dataset.arcs, opts);
+    var exprOpts = Object.assign({returns: true}, opts);
+    var func = compileExpressionToFunction(expr, exprOpts);
+    var ctx = proxy;
+    return function() {
+      try {
+        return func.call(proxy, {}, ctx);
+      } catch(e) {
+        // if (opts.quiet) throw e;
+        stop(e.name, "in expression [" + expr + "]:", e.message);
+      }
+    };
+  }
+
+  function skipCommand(cmdName) {
+    // allow all control commands to run
+    if (isControlFlowCommand(cmdName)) return false;
+    return inControlBlock() && !inActiveBranch();
+  }
+
+  cmd.if = function(catalog, opts) {
+    if (inControlBlock()) {
+      stop('Nested -if commands are not supported.');
+    }
+    evaluateIf(catalog, opts);
+  };
+
+  cmd.elif = function(catalog, opts) {
+    if (!inControlBlock()) {
+      stop('-elif command must be preceded by an -if command.');
+    }
+    evaluateIf(catalog, opts);
+  };
+
+  cmd.else = function() {
+    if (!inControlBlock()) {
+      stop('-else command must be preceded by an -if command.');
+    }
+    if (blockWasActive()) {
+      enterInactiveBranch();
+    } else {
+      enterActiveBranch();
+    }
+  };
+
+  cmd.endif = function() {
+    if (!inControlBlock()) {
+      stop('-endif command must be preceded by an -if command.');
+    }
+    resetControlFlow();
+  };
+
+  function isControlFlowCommand(cmd) {
+    return ['if','elif','else','endif'].includes(cmd);
+  }
+
+  function testLayer(catalog, opts) {
+    var targ = getTargetLayer(catalog, opts);
+    if (opts.expression) {
+      return compileLayerExpression(opts.expression, targ.layer, targ.dataset, opts)();
+    }
+    if (opts.empty) {
+      return layerIsEmpty(targ.layer);
+    }
+    if (opts.not_empty) {
+      return !layerIsEmpty(targ.layer);
+    }
+    return true;
+  }
+
+  function evaluateIf(catalog, opts) {
+    if (!blockWasActive() && testLayer(catalog, opts)) {
+      enterActiveBranch();
+    } else {
+      enterInactiveBranch();
+    }
+  }
+
+  // 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');
@@ -34708,6 +34916,28 @@ ${svg}
     return findVertexIds(p2.x, p2.y, arcs);
   }
 
+  // Given a location @p (e.g. corresponding to the mouse pointer location),
+  // find the midpoint of two vertices on @shp suitable for inserting a new vertex,
+  // but only if:
+  //   1. point @p is closer to the midpoint than either adjacent vertex
+  //   2. the segment containing @p is longer than a minimum distance in pixels.
+  //
+  function findInsertionPoint(p, shp, arcs, pixelSize) {
+    var p2 = findNearestVertex(p[0], p[1], shp, arcs);
+
+  }
+
+  function snapVerticesToPoint(ids, p, arcs, final) {
+    ids.forEach(function(idx) {
+      setVertexCoords(p[0], p[1], idx, arcs);
+    });
+    if (final) {
+      // kludge to get dataset to recalculate internal bounding boxes
+      arcs.transformPoints(function() {});
+    }
+  }
+
+
   // p: point to snap
   // ids: ids of nearby vertices, possibly including an arc endpoint
   function snapPointToArcEndpoint(p, ids, arcs) {
@@ -34794,6 +35024,8 @@ ${svg}
   var VertexUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
     findNearestVertices: findNearestVertices,
+    findInsertionPoint: findInsertionPoint,
+    snapVerticesToPoint: snapVerticesToPoint,
     snapPointToArcEndpoint: snapPointToArcEndpoint,
     findVertexIds: findVertexIds,
     getVertexCoords: getVertexCoords,
@@ -38075,40 +38307,14 @@ ${svg}
   //   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 = calcStraightArrowCoords(size.stemLen, size.headLen, stemDx, headDx, baseDx);
-    } else {
-      if (direction > 0) stemCurve = -stemCurve;
-      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 calcArrowSize(d) {
-    var totalLen = d.radius || d.length || d.r || 0,
+    // 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
 
@@ -38168,21 +38374,55 @@ ${svg}
     return 1 / Math.tan(Math.PI * headAngle / 180 / 2) / 2;
   }
 
-  function getCurvedArrowCoords(stemLen, headLen, curvature, stemDx, headDx, baseDx) {
+  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
-    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') {
+      // 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
@@ -38219,43 +38459,31 @@ ${svg}
     return coords;
   }
 
-  // sides: e.g. 5-pointed star has 10 sides
-  // radius: distance from center to point
-  //
   function getPolygonCoords(d) {
-    var radius = d.radius || d.length || d.r;
+    var radius = d.radius || d.length || d.r,
+        sides = +d.sides || getSidesByType(d.type),
+        rotated = sides % 2 == 1,
+        coords = [],
+        angle, b;
+
     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})`);
-    } else if (sides >= 3 === false) {
+    if (sides >= 3 === false) {
       stop(`Invalid number of sides (${sides})`);
     }
-    var coords = [],
-        angle = 360 / sides,
-        b = isStar ? 1 : 0.5,
-        theta, even, len;
     if (d.orientation == 'b' || d.flipped || d.rotated) {
-      b = 0;
+      rotated = !rotated;
     }
+    b = rotated ? 0 : 0.5;
     for (var i=0; i<sides; i++) {
-      even = i % 2 == 0;
-      len = radius;
-      if (isStar && even) {
-        len *= (d.star_ratio || 0.5);
-      }
-      theta = (i + b) * angle % 360;
-      coords.push(getPlanarSegmentEndpoint(0, 0, theta, len));
+      angle = (i + b) / sides * 360;
+      coords.push(getPlanarSegmentEndpoint(0, 0, angle, radius));
     }
     coords.push(coords[0].concat());
     return [coords];
   }
 
-  function getDefaultSides(type) {
+  function getSidesByType(type) {
     return {
-      star: 10,
       circle: 72,
       triangle: 3,
       square: 4,
@@ -38268,6 +38496,52 @@ ${svg}
     }[type] || 4;
   }
 
+  function getStarCoords(d) {
+    var radius = d.radius || d.length || d.r,
+        points = d.points || d.sides && d.sides / 2 || 5,
+        sides = points * 2,
+        minorRadius = getMinorRadius(points) * radius,
+        b = d.orientation == 'b' || d.flipped || d.rotated ? 0 : 1,
+        coords = [],
+        angle, len;
+
+    if (radius > 0 === false) return null;
+    if (points < 5) {
+      stop(`Invalid number of points for a star (${points})`);
+    }
+    for (var i=0; i<sides; i++) {
+      len = i % 2 == 0 ? minorRadius : radius;
+      angle = (i + b) / sides * 360;
+      coords.push(getPlanarSegmentEndpoint(0, 0, angle, len));
+    }
+    coords.push(coords[0].concat());
+    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 getDefaultPointAngle(points) {
+    var minSkip = 1;
+    var maxSkip = Math.ceil(points / 2) - 2;
+    var skip = Math.floor((maxSkip + minSkip) / 2);
+    return getPointAngle(points, skip);
+  }
+
+  // skip: number of adjacent points to skip when drawing a segment
+  function getPointAngle(points, skip) {
+    var unitAngle = 360 / points;
+    var centerAngle = unitAngle * (skip + 1);
+    return 180 - centerAngle;
+  }
+
   // Returns GeoJSON MultiPolygon coords
   function getRingCoords(d) {
     var radii = parseRings(d.radii || '2');
@@ -38322,6 +38596,8 @@ ${svg}
       } else if (d.type == 'ring') {
         coords = getRingCoords(d);
         geojsonType = 'MultiPolygon';
+      } else if (d.type == 'star') {
+        coords = getStarCoords(d);
       } else {
         coords = getPolygonCoords(d);
       }
@@ -38816,8 +39092,13 @@ ${svg}
         targets,
         targetDataset,
         targetLayers,
+        target,
         arcs;
 
+    if (skipCommand(name)) {
+      return done(null);
+    }
+
     try { // catch errors from synchronous functions
 
       T$1.start();
@@ -38984,6 +39265,14 @@ ${svg}
           outputLayers = targetDataset.layers; // kludge to allow layer naming below
         }
 
+      } else if (name == 'if' || name == 'elif') {
+        // target = findSingleTargetLayer(opts.layer, targets[0], catalog);
+        // cmd[name](target.layer, target.dataset, opts);
+        cmd[name](catalog, opts);
+
+      } else if (name == 'else' || name == 'endif') {
+        cmd[name]();
+
       } else if (name == 'ignore') {
         applyCommandToEachLayer(cmd.ignore, targetLayers, targetDataset, opts);
 
@@ -39216,6 +39505,7 @@ ${svg}
     });
   }
 
+
   // Apply a command to an array of target layers
   function applyCommandToEachLayer(func, targetLayers) {
     var args = utils.toArray(arguments).slice(2);
@@ -39474,6 +39764,8 @@ ${svg}
   }
 
   function runParsedCommands2(commands, catalog, cb) {
+    // resetting closes any unterminated -if blocks from a previous command sequence
+    resetControlFlow();
     utils.reduceAsync(commands, catalog, nextCommand, cb);
 
     function nextCommand(catalog, cmd, next) {