mapshaper 0.5.85 → 0.5.89

package/www/mapshaper.js

@@ -1,6 +1,6 @@
 (function () {
 
-  var VERSION = "0.5.83";
+  var VERSION = "0.5.88";
 
 
   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,35 @@
     };
   }
 
+  // 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,
+      size: getFeatureCount(lyr),
+      empty: getFeatureCount(lyr) === 0
+    };
+    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;
+  }
+
   function addBBoxGetter(obj, lyr, arcs) {
     var bbox;
     addGetters(obj, {
@@ -9354,32 +9401,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 +9597,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 +9732,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 +9787,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 +9842,6 @@
   var Expressions = /*#__PURE__*/Object.freeze({
     __proto__: null,
     compileValueExpression: compileValueExpression,
-    cleanExpression: cleanExpression,
     compileFeaturePairFilterExpression: compileFeaturePairFilterExpression,
     compileFeaturePairExpression: compileFeaturePairExpression,
     compileFeatureExpression: compileFeatureExpression,
@@ -18564,6 +18584,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;
     };
@@ -19527,14 +19554,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', {
@@ -20093,45 +20112,46 @@ ${svg}
      .option('target', targetOpt);
 
     parser.command('symbols')
-      // .describe('symbolize points as polygons, circles, stars or arrows')
+      .describe('symbolize points as arrows, circles, stars, polygons, etc.')
       .option('type', {
-        describe: 'symbol type (e.g. star, polygon, circle, arrow)'
+        describe: 'symbol type (e.g. arrow, circle, square, star, polygon, ring)'
       })
-      .option('scale', {
-        describe: 'scale symbols by a factor',
-        type: 'number'
-      })
-      .option('pixel-scale', {
-        describe: 'symbol scale in meters-per-pixel (see polygons option)',
-        type: 'number',
+      .option('stroke', {})
+      .option('stroke-width', {})
+      .option('fill', {
+        describe: 'symbol fill color'
       })
       .option('polygons', {
         describe: 'generate symbols as polygons instead of SVG objects',
         type: 'flag'
       })
-      .option('radius', {
-        describe: 'distance from center to farthest point on the symbol',
-        type: 'distance'
-      })
-      .option('sides', {
-        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('pixel-scale', {
+        describe: 'set symbol scale in meters-per-pixel (for polygons option)',
+        type: 'number',
       })
+      // .option('flipped', {
+      //   type: 'flag',
+      //   describe: 'symbol is vertically flipped'
+      // })
       .option('rotated', {
         type: 'flag',
-        describe: 'symbol is rotated to a different orientation'
+        describe: 'symbol is rotated to an alternate orientation'
       })
       .option('rotation', {
         describe: 'rotation of symbol in degrees'
       })
+      .option('scale', {
+        describe: 'scale symbols by a multiplier',
+        type: 'number'
+      })
+      .option('radius', {
+        describe: 'distance from center to farthest point on the symbol',
+        type: 'distance'
+      })
+      .option('sides', {
+        describe: '(polygon) number of sides of a (regular) polygon symbol',
+        type: 'number'
+      })
       .option('points', {
         describe: '(star) number of points'
       })
@@ -20149,7 +20169,7 @@ ${svg}
       })
       .option('direction', {
         old_alias: 'arrow-direction',
-        describe: '(arrow) angle off vertical (-90 = left-pointing)'
+        describe: '(arrow) angle off of vertical (-90 = left-pointing)'
       })
       .option('head-angle', {
         old_alias: 'arrow-head-angle',
@@ -20184,17 +20204,12 @@ ${svg}
       })
       .option('min-stem-ratio', {
         old_alias: 'arrow-min-stem',
-        describe: '(arrow) min ratio of stem to total length',
+        describe: '(arrow) minimum 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', {
-        describe: 'symbol fill color'
-      })
       .option('effect', {})
       // .option('where', whereOpt)
       .option('name', nameOpt)
@@ -20497,6 +20512,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')
@@ -34169,6 +34227,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');
@@ -34715,6 +34908,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) {
@@ -34801,6 +35016,8 @@ ${svg}
   var VertexUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
     findNearestVertices: findNearestVertices,
+    findInsertionPoint: findInsertionPoint,
+    snapVerticesToPoint: snapVerticesToPoint,
     snapPointToArcEndpoint: snapPointToArcEndpoint,
     findVertexIds: findVertexIds,
     getVertexCoords: getVertexCoords,
@@ -38088,7 +38305,8 @@ ${svg}
   }
 
   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
 
@@ -38187,7 +38405,9 @@ ${svg}
     if (d.anchor == 'end') {
       scaleAndShiftCoords(coords, 1, [-dx, -dy - headLen]);
     } else if (d.anchor == 'middle') {
-      scaleAndShiftCoords(coords, 1, [-dx/2, (-dy - headLen)/2]);
+      // 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);
@@ -38231,71 +38451,31 @@ ${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(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 && 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) {
+    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 *= starRatio;
-      }
-      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,
@@ -38308,6 +38488,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');
@@ -38362,6 +38588,8 @@ ${svg}
       } else if (d.type == 'ring') {
         coords = getRingCoords(d);
         geojsonType = 'MultiPolygon';
+      } else if (d.type == 'star') {
+        coords = getStarCoords(d);
       } else {
         coords = getPolygonCoords(d);
       }
@@ -38856,8 +39084,13 @@ ${svg}
         targets,
         targetDataset,
         targetLayers,
+        target,
         arcs;
 
+    if (skipCommand(name)) {
+      return done(null);
+    }
+
     try { // catch errors from synchronous functions
 
       T$1.start();
@@ -39024,6 +39257,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);
 
@@ -39256,6 +39497,7 @@ ${svg}
     });
   }
 
+
   // Apply a command to an array of target layers
   function applyCommandToEachLayer(func, targetLayers) {
     var args = utils.toArray(arguments).slice(2);
@@ -39514,6 +39756,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) {