mapshaper 0.5.109 → 0.5.112

package/www/mapshaper.js

@@ -1,6 +1,6 @@
 (function () {
 
-  var VERSION = "0.5.109";
+  var VERSION = "0.5.112";
 
 
   var utils = /*#__PURE__*/Object.freeze({
@@ -101,6 +101,37 @@
     get trimQuotes () { return trimQuotes; }
   });
 
+  // This module provides a way for multiple jobs to run together asynchronously
+  // while keeping job-level context variables (like "defs") separate.
+
+  var stash = {};
+
+  function stashVar(key, val) {
+    if (key in stash) {
+      error('Tried to replace a stashed variable:', key);
+    }
+    stash[key] = val;
+  }
+
+  function getStashedVar(key) {
+    if (key in stash === false) {
+      return undefined; // to support running commands in tests
+      // error('Tried to read a nonexistent variable from the stash:', key);
+    }
+    return stash[key];
+  }
+
+  function clearStash() {
+    stash = {};
+  }
+
+  var Stash = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    stashVar: stashVar,
+    getStashedVar: getStashedVar,
+    clearStash: clearStash
+  });
+
   var Buffer = require('buffer').Buffer; // works with browserify
 
   var uniqCount = 0;
@@ -1133,62 +1164,6 @@
     return raw;
   }
 
-  var context = createContext(); // command context (persist for the current command cycle)
-
-  function runningInBrowser() {
-    return typeof window !== 'undefined' && typeof window.document !== 'undefined';
-  }
-
-  function getStateVar(key) {
-    return context[key];
-  }
-
-  function setStateVar(key, val) {
-    context[key] = val;
-  }
-
-  function createContext() {
-    return {
-      DEBUG: false,
-      QUIET: false,
-      VERBOSE: false,
-      defs: {},
-      input_files: []
-    };
-  }
-
-  // Install a new set of context variables, clear them when an async callback is called.
-  // @cb callback function to wrap
-  // returns wrapped callback function
-  function createAsyncContext(cb) {
-    context = createContext();
-    return function() {
-      cb.apply(null, utils.toArray(arguments));
-      // clear context after cb(), so output/errors can be handled in current context
-      context = createContext();
-    };
-  }
-
-  // Save the current context, restore it when an async callback is called
-  // @cb callback function to wrap
-  // returns wrapped callback function
-  function preserveContext(cb) {
-    var ctx = context;
-    return function() {
-      context = ctx;
-      cb.apply(null, utils.toArray(arguments));
-    };
-  }
-
-  var State = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    runningInBrowser: runningInBrowser,
-    getStateVar: getStateVar,
-    setStateVar: setStateVar,
-    createAsyncContext: createAsyncContext,
-    preserveContext: preserveContext
-  });
-
   var LOGGING = false;
   var STDOUT = false; // use stdout for status messages
   var _error, _stop, _message;
@@ -1268,13 +1243,13 @@
 
   function verbose() {
     // verbose can be set globally with the -verbose command or separately for each command
-    if (getStateVar('VERBOSE') || getStateVar('verbose')) {
+    if (getStashedVar('VERBOSE')) {
       message.apply(null, arguments);
     }
   }
 
   function debug() {
-    if (getStateVar('DEBUG') || getStateVar('debug')) {
+    if (getStashedVar('DEBUG')) {
       logArgs(arguments);
     }
   }
@@ -1354,7 +1329,7 @@
 
   function messageArgs(args) {
     var arr = utils.toArray(args);
-    var cmd = getStateVar('current_command');
+    var cmd = getStashedVar('current_command');
     if (cmd && cmd != 'help') {
       arr.unshift('[' + cmd + ']');
     }
@@ -1362,7 +1337,7 @@
   }
 
   function logArgs(args) {
-    if (!LOGGING || getStateVar('QUIET') || !utils.isArrayLike(args)) return;
+    if (!LOGGING || getStashedVar('QUIET') || !utils.isArrayLike(args)) return;
     var msg = formatLogArgs(args);
     if (STDOUT) console.log(msg);
     else console.error(msg);
@@ -2750,21 +2725,30 @@
     message(utils.format("Snapped %s point%s", snapCount, utils.pluralSuffix(snapCount)));
   }
 
+  function snapCoordsByInterval(arcs, snapDist) {
+    if (snapDist > 0 === false) return 0;
+    var ids = getCoordinateIds(arcs);
+    return snapCoordsInternal(ids, arcs, snapDist);
+  }
+
+  function snapEndpointsByInterval(arcs, snapDist) {
+    if (snapDist > 0 === false) return 0;
+    var ids = getEndpointIds(arcs);
+    return snapCoordsInternal(ids, arcs, snapDist);
+  }
+
   // Snap together points within a small threshold
   //
-  function snapCoordsByInterval(arcs, snapDist) {
+  function snapCoordsInternal(ids, arcs, snapDist) {
     var snapCount = 0,
-        data = arcs.getVertexData(),
-        ids;
+        n = ids.length,
+        data = arcs.getVertexData();
 
-    if (snapDist > 0) {
-      // Get sorted coordinate ids
-      // Consider: speed up sorting -- try bucket sort as first pass.
-      //
-      ids = sortCoordinateIds(data.xx);
-      for (var i=0, n=ids.length; i<n; i++) {
-        snapCount += snapPoint(i, snapDist, ids, data.xx, data.yy);
-      }
+    quicksortIds(data.xx, ids, 0, n-1);
+
+    // Consider: speed up sorting -- try bucket sort as first pass.
+    for (var i=0; i<n; i++) {
+      snapCount += snapPoint(i, snapDist, ids, data.xx, data.yy);
     }
     return snapCount;
 
@@ -2790,13 +2774,25 @@
     }
   }
 
-  function sortCoordinateIds(a) {
-    var n = a.length,
+  function getCoordinateIds(arcs) {
+    var data = arcs.getVertexData(),
+        n = data.xx.length,
         ids = new Uint32Array(n);
     for (var i=0; i<n; i++) {
       ids[i] = i;
     }
-    quicksortIds(a, ids, 0, ids.length-1);
+    return ids;
+  }
+
+  function getEndpointIds(arcs) {
+    var i = 0;
+    var ids = [];
+    var data = arcs.getVertexData();
+    data.nn.forEach(function(n) {
+      if (n > 0 === false) return;
+      ids.push(i, i+n-1);
+      i += n;
+    });
     return ids;
   }
 
@@ -2896,7 +2892,9 @@
     getHighPrecisionSnapInterval: getHighPrecisionSnapInterval,
     snapCoords: snapCoords,
     snapCoordsByInterval: snapCoordsByInterval,
-    sortCoordinateIds: sortCoordinateIds
+    snapEndpointsByInterval: snapEndpointsByInterval,
+    getCoordinateIds: getCoordinateIds,
+    getEndpointIds: getEndpointIds
   });
 
   // Find the intersection between two 2D segments
@@ -4122,6 +4120,7 @@
           s = [],
           dataNulls = 0,
           rec;
+
       for (var i=0, n=shapes.length; i<n; i++) {
         if (types[i] != geoType) continue;
         if (geoType) s.push(shapes[i]);
@@ -4132,7 +4131,7 @@
       return {
         geometry_type: geoType,
         shapes: s,
-        data: dataNulls < s.length ? new DataTable(p) : null
+        data: dataNulls < p.length ? new DataTable(p) : null
       };
     });
     return layers;
@@ -4742,9 +4741,9 @@
       defn = projectionAliases[str];  // defn is a function
     } else if (looksLikeInitString(str)) {
       defn = '+init=' + str.toLowerCase();
-    } else if (str in getStateVar('defs')) {
+    } else if (str in (getStashedVar('defs') || {})) {
       // a proj4 alias could be dynamically created in a -calc expression
-      defn = getStateVar('defs')[str];
+      defn = getStashedVar('defs')[str];
     } else {
       defn = parseCustomProjection(str);
     }
@@ -7031,6 +7030,15 @@
     transformPoints: transformPoints
   });
 
+  function runningInBrowser() {
+    return typeof window !== 'undefined' && typeof window.document !== 'undefined';
+  }
+
+  var State = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    runningInBrowser: runningInBrowser
+  });
+
   function getPathSep(path) {
     // TODO: improve
     return path.indexOf('/') == -1 && path.indexOf('\\') != -1 ? '\\' : '/';
@@ -7139,7 +7147,8 @@
     } else if (fname == '/dev/stdin') {
       content = require('rw').readFileSync(fname);
     } else {
-      getStateVar('input_files').push(fname);
+      // kludge to prevent overwriting of input files
+      (getStashedVar('input_files') || []).push(fname);
       content = require('fs').readFileSync(fname);
     }
     if (encoding && Buffer.isBuffer(content)) {
@@ -7164,7 +7173,7 @@
     var fs = require('rw');
     cli.createDirIfNeeded(fname);
     if (cb) {
-      fs.writeFile(fname, content, preserveContext(cb));
+      fs.writeFile(fname, content, cb);
     } else {
       fs.writeFileSync(fname, content);
     }
@@ -7259,7 +7268,7 @@
       return cli.writeFile('/dev/stdout', exports[0].content, cb);
     } else {
       var paths = getOutputPaths(utils.pluck(exports, 'filename'), opts);
-      var inputFiles = getStateVar('input_files');
+      var inputFiles = getStashedVar('input_files');
       exports.forEach(function(obj, i) {
         var path = paths[i];
         if (obj.content instanceof ArrayBuffer) {
@@ -9514,6 +9523,140 @@
     };
   }
 
+  // convert targets from [{layers: [...], dataset: <>}, ...] format to
+  // [{layer: <>, dataset: <>}, ...] format
+  function expandCommandTargets(targets) {
+    return targets.reduce(function(memo, target) {
+      target.layers.forEach(function(lyr) {
+        memo.push({layer: lyr, dataset: target.dataset});
+      });
+      return memo;
+    }, []);
+  }
+
+
+  function findCommandTargets(layers, pattern, type) {
+    var targets = [];
+    var matches = findMatchingLayers(layers, pattern, true);
+    if (type) {
+      matches = matches.filter(function(o) {return o.layer.geometry_type == type;});
+    }
+    // assign target_id to matched layers
+    // (kludge so layers can be sorted in the order that they match; used by -o command)
+    layers.forEach(function(o) {o.layer.target_id = -1;});
+    matches.forEach(function(o, i) {o.layer.target_id = i;});
+    return groupLayersByDataset(matches);
+  }
+
+  // arr: array of {layer: <>, dataset: <>} objects
+  function groupLayersByDataset(arr) {
+    var datasets = [];
+    var targets = [];
+    arr.forEach(function(o) {
+      var i = datasets.indexOf(o.dataset);
+      if (i == -1) {
+        datasets.push(o.dataset);
+        targets.push({layers: [o.layer], dataset: o.dataset});
+      } else {
+        targets[i].layers.push(o.layer);
+      }
+    });
+    return targets;
+  }
+
+  // layers: array of {layer: <>, dataset: <>} objects
+  // pattern: is a layer identifier or a comma-sep. list of identifiers.
+  // An identifier is a literal name, a pattern containing "*" wildcard or
+  // a 1-based index (1..n)
+  function findMatchingLayers(layers, pattern, throws) {
+    var matchedLayers = [];
+    var unmatchedIds = [];
+    var index = {};
+    pattern.split(',').forEach(function(subpattern, i) {
+      var test = getLayerMatch(subpattern);
+      var matched = false;
+      layers.forEach(function(o, layerId) {
+        // if (matchedLayers.indexOf(lyr) > -1) return; // performance bottleneck with 1000s of layers
+        if (layerId in index) {
+          matched = true;
+        } else if (test(o.layer, layerId + 1)) {  // layers are 1-indexed
+          matchedLayers.push(o);
+          index[layerId] = true;
+          matched = true;
+        }
+      });
+      if (matched == false) {
+        unmatchedIds.push(subpattern);
+      }
+    });
+    if (throws && unmatchedIds.length) {
+      stop(utils.format('Missing layer%s: %s', unmatchedIds.length == 1 ? '' : 's', unmatchedIds.join(',')));
+    }
+    return matchedLayers;
+  }
+
+  function getLayerMatch(pattern) {
+    var isIndex = utils.isInteger(Number(pattern));
+    var nameRxp = isIndex ? null : utils.wildcardToRegExp(pattern);
+    return function(lyr, i) {
+      return isIndex ? String(i) == pattern : nameRxp.test(lyr.name || '');
+    };
+  }
+
+  function countTargetLayers(targets) {
+    return targets.reduce(function(memo, target) {
+      return memo + target.layers.length;
+    }, 0);
+  }
+
+  // get an identifier for a layer that can be used in a target= option
+  // (returns name if layer has a unique name, or a numerical id)
+  function getLayerTargetId(catalog, lyr) {
+    var nameCount = 0,
+        name = lyr.name,
+        id;
+    catalog.getLayers().forEach(function(o, i) {
+      if (lyr.name && o.layer.name == lyr.name) nameCount++;
+      if (lyr == o.layer) id = String(i + 1);
+    });
+    if (!id) error('Layer not found');
+    return nameCount == 1 ? lyr.name : id;
+  }
+
+  var TargetUtils = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    expandCommandTargets: expandCommandTargets,
+    findCommandTargets: findCommandTargets,
+    groupLayersByDataset: groupLayersByDataset,
+    findMatchingLayers: findMatchingLayers,
+    getLayerMatch: getLayerMatch,
+    countTargetLayers: countTargetLayers,
+    getLayerTargetId: getLayerTargetId
+  });
+
+  function getNullLayerProxy(targets) {
+    var obj = {};
+    var n = countTargetLayers(targets);
+    var getters = {
+      name: error,
+      data: error,
+      type: error,
+      size: error,
+      empty: error,
+      bbox: error
+    };
+    addGetters(obj, getters);
+    obj.field_exists = error;
+    obj.field_type = error;
+    obj.field_includes = error;
+    return obj;
+    function error() {
+      throw Error(`This expression requires a single target layer; Received ${n} layers.`);
+    }
+  }
+
+
+
   // Returns an object representing a layer in a JS expression
   function getLayerProxy(lyr, arcs) {
     var obj = {};
@@ -9523,10 +9666,10 @@
       data: records,
       type: lyr.geometry_type,
       size: getFeatureCount(lyr),
-      empty: getFeatureCount(lyr) === 0
+      empty: getFeatureCount(lyr) === 0,
+      bbox: getBBoxGetter(obj, lyr, arcs)
     };
     addGetters(obj, getters);
-    addBBoxGetter(obj, lyr, arcs);
     obj.field_exists = function(name) {
       return lyr.data && lyr.data.fieldExists(name) ? true : false;
     };
@@ -9555,16 +9698,14 @@
     return ctx;
   }
 
-  function addBBoxGetter(obj, lyr, arcs) {
+  function getBBoxGetter(obj, lyr, arcs) {
     var bbox;
-    addGetters(obj, {
-      bbox: function() {
-        if (!bbox) {
-          bbox = getBBox$1(lyr, arcs);
-        }
-        return bbox;
+    return function() {
+      if (!bbox) {
+        bbox = getBBox$1(lyr, arcs);
       }
-    });
+      return bbox;
+    };
   }
 
   function getBBox$1(lyr, arcs) {
@@ -9965,7 +10106,7 @@
   }
 
   function getExpressionContext(lyr, mixins, opts) {
-    var defs = getStateVar('defs');
+    var defs = getStashedVar('defs');
     var env = getBaseContext();
     var ctx = {};
     var fields = lyr.data ? lyr.data.getFields() : [];
@@ -10154,7 +10295,7 @@
     }
     // Save any assigned variables to the defs object, so they will be available
     // for later -each expressions to use.
-    defs = getStateVar('defs');
+    defs = getStashedVar('defs');
     compiled = compileCalcExpression(lyr, arcs, opts.expression);
     result = compiled(null, defs);
     message(msg + ":  " + result);
@@ -13937,9 +14078,27 @@
     polyline: utils.arrayToIndex(commonProperties.concat('stroke-linecap', 'stroke-linejoin')),
     point: utils.arrayToIndex(commonProperties.concat('fill', 'r')),
     label: utils.arrayToIndex(commonProperties.concat(
-      'fill,r,font-family,font-size,text-anchor,font-weight,font-style,letter-spacing,dominant-baseline'.split(',')))
+      'fill,font-family,font-size,text-anchor,font-weight,font-style,letter-spacing,dominant-baseline'.split(',')))
   };
 
+  // symType: point, polygon, polyline, label
+  function applyStyleAttributes(svgObj, symType, rec, filter) {
+    var fields = findPropertiesBySymbolGeom(Object.keys(rec || {}), symType);
+    for (var i=0, n=fields.length; i<n; i++) {
+      if (filter && !filter(fields[i])) continue;
+      setAttribute(svgObj, fields[i], rec[fields[i]]);
+    }
+  }
+
+  function setAttribute(obj, k, v) {
+    if (!obj.properties) obj.properties = {};
+    obj.properties[k] = v;
+    if (k == 'stroke-dasharray' && v) {
+      // kludge for cleaner dashes... make butt the default?
+      obj.properties['stroke-linecap'] = 'butt';
+    }
+  }
+
   function isSupportedSvgStyleProperty(name) {
     return name in stylePropertyTypes;
   }
@@ -14022,7 +14181,6 @@
   function parseStyleExpression(strVal, lyr) {
     var func;
     try {
-      // func = compileValueExpression(strVal, lyr, null, {context: getStateVar('defs'), no_warn: true});
       func = compileValueExpression(strVal, lyr, null, {no_warn: true});
       func(0); // check for runtime errors (e.g. undefined variables)
     } catch(e) {
@@ -14096,6 +14254,7 @@
 
   var SvgProperties = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    applyStyleAttributes: applyStyleAttributes,
     isSupportedSvgStyleProperty: isSupportedSvgStyleProperty,
     findPropertiesBySymbolGeom: findPropertiesBySymbolGeom,
     getSymbolDataAccessor: getSymbolDataAccessor,
@@ -14109,7 +14268,69 @@
     isSvgColor: isSvgColor
   });
 
-  var symbolRenderers = {};
+  function toLabelString(val) {
+    if (val || val === 0 || val === false) return String(val);
+    return '';
+  }
+
+  // Kludge for applying fill and other styles to a <text> element
+  // (for rendering labels in the GUI with the dot in Canvas, not SVG)
+  function renderStyledLabel(rec) {
+    var o = renderLabel(rec);
+    applyStyleAttributes(o, 'label', rec);
+    return o;
+  }
+
+  function renderLabel(rec) {
+    var line = toLabelString(rec['label-text']);
+    var morelines, obj;
+    // Accepting \n (two chars) as an alternative to the newline character
+    // (sometimes, '\n' is not converted to newline, e.g. in a Makefile)
+    // Also accepting <br>
+    var newline = /\n|\\n|<br>/i;
+    var dx = rec.dx || 0;
+    var dy = rec.dy || 0;
+    var properties = {
+      // using x, y instead of dx, dy for shift, because Illustrator doesn't apply
+      // dx value when importing text with text-anchor=end
+      y: dy,
+      x: dx
+    };
+    if (newline.test(line)) {
+      morelines = line.split(newline);
+      line = morelines.shift();
+    }
+    obj = {
+      tag: 'text',
+      value: line,
+      properties: properties
+    };
+    if (morelines) {
+      // multiline label
+      obj.children = [];
+      morelines.forEach(function(line) {
+        var tspan = {
+          tag: 'tspan',
+          value: line,
+          properties: {
+            x: dx,
+            dy: rec['line-height'] || '1.1em'
+          }
+        };
+        obj.children.push(tspan);
+      });
+    }
+    return obj;
+  }
+
+  var SvgLabels = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    renderStyledLabel: renderStyledLabel,
+    renderLabel: renderLabel
+  });
+
+  // convert data records (properties like svg-symbol, label-text, fill, r) to svg symbols
+
 
   function getTransform(xy, scale) {
     var str = 'translate(' + roundToTenths(xy[0]) + ' ' + roundToTenths(xy[1]) + ')';
@@ -14119,10 +14340,149 @@
     return str;
   }
 
-  var SvgCommon = /*#__PURE__*/Object.freeze({
+  var symbolRenderers = {
+    line: line,
+    polygon: polygon,
+    polyline: polyline,
+    circle: circle,
+    square: square,
+    image: image,
+    group: group,
+    label: label
+  };
+
+  // render label and/or point symbol
+  function renderPoint(rec) {
+    var children = [];
+    // var halfSize = rec.r || 0; // radius or half of symbol size
+    if (featureHasSvgSymbol(rec)) {
+      children.push(renderSymbol(rec));
+    }
+    if (featureHasLabel(rec)) {
+      children.push(renderStyledLabel(rec));
+    }
+    var o = children.length > 1 ? {tag: 'g', children: children} : children[0];
+    if (!o) return null;
+    o.properties = o.properties || {};
+    return o;
+  }
+
+  function renderSymbol(d) {
+    if (d['svg-symbol']) {
+      return renderComplexSymbol(d['svg-symbol']);
+    }
+    if (d.r > 0) {
+      return circle(d);
+    }
+    return empty();
+  }
+
+  function renderComplexSymbol(sym) {
+    if (utils.isString(sym)) {
+      sym = JSON.parse(sym);
+    }
+    var renderer = symbolRenderers[sym.type];
+    if (!renderer) {
+      message(sym.type ? 'Unknown symbol type: ' + sym.type : 'Symbol is missing a type property');
+      return empty();
+    }
+    return renderer(sym, 0, 0);
+  }
+
+  function empty() {
+    return {tag: 'g', properties: {}, children: []};
+  }
+
+  function circle(d, x, y) {
+    var o = {
+      tag: 'circle',
+      properties: {
+        cx: x || 0,
+        cy: y || 0
+      }
+    };
+    applyStyleAttributes(o, 'point', d);
+    return o;
+  }
+
+  function label(d, x, y) {
+    return renderStyledLabel(d);
+  }
+
+  function image(d, x, y) {
+    var w = d.width || 20,
+        h = d.height || 20;
+    var o = {
+      tag: 'image',
+      properties: {
+        width: w,
+        height: h,
+        x: x - w / 2,
+        y: y - h / 2,
+        href: d.href || ''
+      }
+    };
+    return o;
+  }
+
+  function square(d, x, y) {
+    var r = d.r || 0;
+    var o = {
+      tag: 'rect',
+      properties: {
+        x: x - r,
+        y: y - r,
+        width: r * 2,
+        height: r * 2
+      }
+    };
+    applyStyleAttributes(o, 'point', d);
+    return o;
+  }
+
+  function line(d, x, y) {
+    var coords, o;
+    coords = [[x, y], [x + (d.dx || 0), y + (d.dy || 0)]];
+    o = importLineString(coords);
+    applyStyleAttributes(o, 'polyline', d);
+    return o;
+  }
+
+  function polyline(d, x, y) {
+    var coords = d.coordinates || [];
+    var o = importMultiLineString(coords);
+    applyStyleAttributes(o, 'polyline', d);
+    return o;
+  }
+
+  function polygon(d, x, y) {
+    var coords = d.coordinates || [];
+    var o = importPolygon(coords);
+    applyStyleAttributes(o, 'polygon', d);
+    return o;
+  }
+
+  function group(d, x, y) {
+    var parts = (d.parts || []).reduce(function(memo, o) {
+      var sym = renderSymbol(o, x, y);
+      if (d.chained) {
+        x += (o.dx || 0);
+        y += (o.dy || 0);
+      }
+      return memo.concat(sym);
+    }, []);
+    if (parts.length == 1) return parts[0];
+    return {
+      tag: 'g',
+      children: parts
+    };
+  }
+
+  var SvgSymbols = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    getTransform: getTransform,
     symbolRenderers: symbolRenderers,
-    getTransform: getTransform
+    renderPoint: renderPoint
   });
 
   function importGeoJSONFeatures(features, opts) {
@@ -14130,16 +14490,22 @@
     return features.map(function(obj, i) {
       var geom = obj.type == 'Feature' ? obj.geometry : obj; // could be null
       var geomType = geom && geom.type;
+      var msType = GeoJSON.translateGeoJSONType(geomType);
+      var d = obj.properties || {};
       var svgObj = null;
       if (geomType && geom.coordinates) {
-        svgObj = geojsonImporters[geomType](geom.coordinates, obj.properties, opts);
+        svgObj = geojsonImporters[geomType](geom.coordinates, d);
       }
       if (!svgObj) {
         return {tag: 'g'}; // empty element
-      }
-      // TODO: fix error caused by null svgObj (caused by e.g. MultiPolygon with [] coordinates)
-      if (obj.properties) {
-        applyStyleAttributes(svgObj, geomType, obj.properties);
+      } else if (msType == 'polyline' || msType == 'polygon') {
+        applyStyleAttributes(svgObj, msType, d);
+      } else if (msType == 'point' && isSimpleCircle(d)) {
+        // kludge -- maintains bw compatibility/passes tests -- style attributes
+        // are applied to the <g> container, 'r' property is applied to circle
+        applyStyleAttributes(svgObj, msType, d, simpleCircleFilter);
+      } else {
+        // other point symbols: attributes are complicated, added downstream
       }
       if ('id' in obj) {
         if (!svgObj.properties) {
@@ -14151,34 +14517,37 @@
     });
   }
 
-  function applyStyleAttributes(svgObj, geomType, rec) {
-    var symbolType = GeoJSON.translateGeoJSONType(geomType);
-    if (symbolType == 'point' && ('label-text' in rec)) {
-      symbolType = 'label';
-    }
-    var fields = findPropertiesBySymbolGeom(Object.keys(rec), symbolType);
-    for (var i=0, n=fields.length; i<n; i++) {
-      setAttribute(svgObj, fields[i], rec[fields[i]]);
+  function importPoint(coords, rec) {
+    rec = rec || {};
+    if (isSimpleCircle(rec)) {
+      return {
+        tag: 'circle',
+        properties: {
+          cx: coords[0],
+          cy: coords[1],
+          r: rec.r
+        }
+      };
     }
+    var o = renderPoint(rec, coords);
+    if (o) o.properties.transform = getTransform(coords);
+    return o;
   }
 
-  function setAttribute(obj, k, v) {
-    if (k == 'r') {
-      // assigned by importPoint()
-    } else {
-      if (!obj.properties) obj.properties = {};
-      obj.properties[k] = v;
-      if (k == 'stroke-dasharray' && v) {
-        // kludge for cleaner dashes... make butt the default?
-        obj.properties['stroke-linecap'] = 'butt';
-      }
-    }
+  function simpleCircleFilter(k) {
+    return k != 'r';
+  }
+
+  // just a dot, no label or icon
+  function isSimpleCircle(rec) {
+    return rec && (rec.r > 0 && !rec['svg-symbol'] && !rec['label-text']);
   }
 
-  function importMultiPoint(coords, rec, layerOpts) {
+  function importMultiPoint(coords, rec) {
     var children = [], p;
     for (var i=0; i<coords.length; i++) {
-      p = importPoint(coords[i], rec, layerOpts);
+      p = importPoint(coords[i], rec);
+      if (!p) continue;
       if (p.tag == 'g' && p.children) {
         children = children.concat(p.children);
       } else {
@@ -14208,7 +14577,6 @@
     };
   }
 
-
   function importMultiLineString(coords) {
     var d = coords.map(stringifyLineStringCoords).join(' ');
     return {
@@ -14217,104 +14585,6 @@
     };
   }
 
-  // Kludge for applying fill and other styles to a <text> element
-  // (for rendering labels in the GUI with the dot in Canvas, not SVG)
-  function importStyledLabel(rec, p) {
-    var o = importLabel(rec, p);
-    applyStyleAttributes(o, 'Point', rec);
-    return o;
-  }
-
-  function toLabelString(val) {
-    if (val || val === 0 || val === false) return String(val);
-    return '';
-  }
-
-  function importLabel(rec, p) {
-    var line = toLabelString(rec['label-text']);
-    var morelines, obj;
-    // Accepting \n (two chars) as an alternative to the newline character
-    // (sometimes, '\n' is not converted to newline, e.g. in a Makefile)
-    // Also accepting <br>
-    var newline = /\n|\\n|<br>/i;
-    var dx = rec.dx || 0;
-    var dy = rec.dy || 0;
-    var properties = {
-      // using x, y instead of dx, dy for shift, because Illustrator doesn't apply
-      // dx value when importing text with text-anchor=end
-      y: dy,
-      x: dx
-    };
-    if (p) {
-      properties.transform = getTransform(p);
-    }
-    if (newline.test(line)) {
-      morelines = line.split(newline);
-      line = morelines.shift();
-    }
-    obj = {
-      tag: 'text',
-      value: line,
-      properties: properties
-    };
-    if (morelines) {
-      // multiline label
-      obj.children = [];
-      morelines.forEach(function(line) {
-        var tspan = {
-          tag: 'tspan',
-          value: line,
-          properties: {
-            x: dx,
-            dy: rec['line-height'] || '1.1em'
-          }
-        };
-        obj.children.push(tspan);
-      });
-    }
-    return obj;
-  }
-
-  function getEmptySymbol() {
-    return {tag: 'g', properties: {}, children: []};
-  }
-
-
-  function renderSymbol(d, x, y) {
-    var renderer = symbolRenderers[d.type];
-     if (!renderer) {
-      stop(d.type ? 'Unknown symbol type: ' + d.type : 'Symbol is missing a type property');
-    }
-    return renderer(d, x || 0, y || 0);
-  }
-
-  // d: svg-symbol object from feature data object
-  function importSymbol(d, xy) {
-    var renderer;
-    if (!d) {
-      return getEmptySymbol();
-    }
-    if (utils.isString(d)) {
-      d = JSON.parse(d);
-    }
-    return {
-      tag: 'g',
-      properties: {
-        'class': 'mapshaper-svg-symbol',
-        transform: xy ? getTransform(xy) : null
-      },
-      children: renderSymbol(d)
-    };
-  }
-
-  function importPoint(coords, rec, layerOpts) {
-    rec = rec || {};
-    if ('svg-symbol' in rec) {
-      return importSymbol(rec['svg-symbol'], coords);
-    }
-    return importStandardPoint(coords, rec, layerOpts || {});
-  }
-
   function importPolygon(coords) {
     var d, o;
     for (var i=0; i<coords.length; i++) {
@@ -14328,49 +14598,12 @@
     return o;
   }
 
-  function importStandardPoint(coords, rec, layerOpts) {
-    var isLabel = 'label-text' in rec;
-    var symbolType = layerOpts.point_symbol || '';
-    var children = [];
-    var halfSize = rec.r || 0; // radius or half of symbol size
-    var p;
-    // if not a label, create a symbol even without a size
-    // (circle radius can be set via CSS)
-    if (halfSize > 0 || !isLabel) {
-      if (symbolType == 'square') {
-        p = {
-          tag: 'rect',
-          properties: {
-            x: coords[0] - halfSize,
-            y: coords[1] - halfSize,
-            width: halfSize * 2,
-            height: halfSize * 2
-          }};
-      } else { // default is circle
-        p = {
-          tag: 'circle',
-          properties: {
-            cx: coords[0],
-            cy: coords[1]
-          }};
-        if (halfSize > 0) {
-          p.properties.r = halfSize;
-        }
-      }
-      children.push(p);
-    }
-    if (isLabel) {
-      children.push(importLabel(rec, coords));
-    }
-    return children.length > 1 ? {tag: 'g', children: children} : children[0];
-  }
-
   var geojsonImporters = {
     Point: importPoint,
     Polygon: importPolygon,
     LineString: importLineString,
-    MultiPoint: function(coords, rec, opts) {
-      return importMultiPoint(coords, rec, opts);
+    MultiPoint: function(coords, rec) {
+      return importMultiPoint(coords, rec);
     },
     MultiLineString: function(coords) {
       return importMultiPath(coords, importLineString);
@@ -14383,14 +14616,9 @@
   var GeojsonToSvg = /*#__PURE__*/Object.freeze({
     __proto__: null,
     importGeoJSONFeatures: importGeoJSONFeatures,
-    applyStyleAttributes: applyStyleAttributes,
+    importPoint: importPoint,
     importLineString: importLineString,
     importMultiLineString: importMultiLineString,
-    importStyledLabel: importStyledLabel,
-    importLabel: importLabel,
-    renderSymbol: renderSymbol,
-    importSymbol: importSymbol,
-    importPoint: importPoint,
     importPolygon: importPolygon
   });
 
@@ -15105,6 +15333,15 @@ ${svg}
     return layerObj;
   }
 
+  function featureHasSvgSymbol(d) {
+    return !!(d && (d['svg-symbol'] || d.r));
+  }
+
+  function featureHasLabel(d) {
+    var text = d && d['label-text'];
+    return text || text === 0; // accept numerical 0 as label text
+  }
+
   function layerHasSvgSymbols(lyr) {
     return lyr.geometry_type == 'point' && lyr.data && lyr.data.fieldExists('svg-symbol');
   }
@@ -15124,6 +15361,8 @@ ${svg}
     validateSvgDataFields: validateSvgDataFields,
     exportDataAttributesForSVG: exportDataAttributesForSVG,
     getEmptyLayerForSVG: getEmptyLayerForSVG,
+    featureHasSvgSymbol: featureHasSvgSymbol,
+    featureHasLabel: featureHasLabel,
     layerHasSvgSymbols: layerHasSvgSymbols,
     layerHasLabels: layerHasLabels
   });
@@ -16804,7 +17043,7 @@ ${svg}
   function guessInputFileType(file) {
     var ext = getFileExtension(file || '').toLowerCase(),
         type = null;
-    if (ext == 'dbf' || ext == 'shp' || ext == 'prj' || ext == 'shx') {
+    if (ext == 'dbf' || ext == 'shp' || ext == 'prj' || ext == 'shx' || ext == 'kml') {
       type = ext;
     } else if (/json$/.test(ext)) {
       type = 'json';
@@ -16817,7 +17056,8 @@ ${svg}
   function guessInputContentType(content) {
     var type = null;
     if (utils.isString(content)) {
-      type = stringLooksLikeJSON(content) ? 'json' : 'text';
+      type = stringLooksLikeJSON(content) && 'json' ||
+        stringLooksLikeKML(content) && 'kml' || 'text';
     } else if (utils.isObject(content) && content.type || utils.isArray(content)) {
       type = 'json';
     }
@@ -16828,11 +17068,15 @@ ${svg}
     return guessInputFileType(file) || guessInputContentType(content);
   }
 
-  //
   function stringLooksLikeJSON(str) {
     return /^\s*[{[]/.test(String(str));
   }
 
+  function stringLooksLikeKML(str) {
+    str = String(str);
+    return str.includes('<kml ') && str.includes('xmlns="http://www.opengis.net/kml/');
+  }
+
   function couldBeDsvFile(name) {
     var ext = getFileExtension(name).toLowerCase();
     return /csv|tsv|txt$/.test(ext);
@@ -16877,6 +17121,7 @@ ${svg}
     guessInputContentType: guessInputContentType,
     guessInputType: guessInputType,
     stringLooksLikeJSON: stringLooksLikeJSON,
+    stringLooksLikeKML: stringLooksLikeKML,
     couldBeDsvFile: couldBeDsvFile,
     isZipFile: isZipFile,
     isSupportedOutputFormat: isSupportedOutputFormat,
@@ -17178,116 +17423,6 @@ ${svg}
     formatVersionedFileName: formatVersionedFileName
   });
 
-  // convert targets from [{layers: [...], dataset: <>}, ...] format to
-  // [{layer: <>, dataset: <>}, ...] format
-  function expandCommandTargets(targets) {
-    return targets.reduce(function(memo, target) {
-      target.layers.forEach(function(lyr) {
-        memo.push({layer: lyr, dataset: target.dataset});
-      });
-      return memo;
-    }, []);
-  }
-
-  function findCommandTargets(layers, pattern, type) {
-    var targets = [];
-    var matches = findMatchingLayers(layers, pattern, true);
-    if (type) {
-      matches = matches.filter(function(o) {return o.layer.geometry_type == type;});
-    }
-    // assign target_id to matched layers
-    // (kludge so layers can be sorted in the order that they match; used by -o command)
-    layers.forEach(function(o) {o.layer.target_id = -1;});
-    matches.forEach(function(o, i) {o.layer.target_id = i;});
-    return groupLayersByDataset(matches);
-  }
-
-  // arr: array of {layer: <>, dataset: <>} objects
-  function groupLayersByDataset(arr) {
-    var datasets = [];
-    var targets = [];
-    arr.forEach(function(o) {
-      var i = datasets.indexOf(o.dataset);
-      if (i == -1) {
-        datasets.push(o.dataset);
-        targets.push({layers: [o.layer], dataset: o.dataset});
-      } else {
-        targets[i].layers.push(o.layer);
-      }
-    });
-    return targets;
-  }
-
-  // layers: array of {layer: <>, dataset: <>} objects
-  // pattern: is a layer identifier or a comma-sep. list of identifiers.
-  // An identifier is a literal name, a pattern containing "*" wildcard or
-  // a 1-based index (1..n)
-  function findMatchingLayers(layers, pattern, throws) {
-    var matchedLayers = [];
-    var unmatchedIds = [];
-    var index = {};
-    pattern.split(',').forEach(function(subpattern, i) {
-      var test = getLayerMatch(subpattern);
-      var matched = false;
-      layers.forEach(function(o, layerId) {
-        // if (matchedLayers.indexOf(lyr) > -1) return; // performance bottleneck with 1000s of layers
-        if (layerId in index) {
-          matched = true;
-        } else if (test(o.layer, layerId + 1)) {  // layers are 1-indexed
-          matchedLayers.push(o);
-          index[layerId] = true;
-          matched = true;
-        }
-      });
-      if (matched == false) {
-        unmatchedIds.push(subpattern);
-      }
-    });
-    if (throws && unmatchedIds.length) {
-      stop(utils.format('Missing layer%s: %s', unmatchedIds.length == 1 ? '' : 's', unmatchedIds.join(',')));
-    }
-    return matchedLayers;
-  }
-
-  function getLayerMatch(pattern) {
-    var isIndex = utils.isInteger(Number(pattern));
-    var nameRxp = isIndex ? null : utils.wildcardToRegExp(pattern);
-    return function(lyr, i) {
-      return isIndex ? String(i) == pattern : nameRxp.test(lyr.name || '');
-    };
-  }
-
-  function countTargetLayers(targets) {
-    return targets.reduce(function(memo, target) {
-      return memo + target.layers.length;
-    }, 0);
-  }
-
-  // get an identifier for a layer that can be used in a target= option
-  // (returns name if layer has a unique name, or a numerical id)
-  function getLayerTargetId(catalog, lyr) {
-    var nameCount = 0,
-        name = lyr.name,
-        id;
-    catalog.getLayers().forEach(function(o, i) {
-      if (lyr.name && o.layer.name == lyr.name) nameCount++;
-      if (lyr == o.layer) id = String(i + 1);
-    });
-    if (!id) error('Layer not found');
-    return nameCount == 1 ? lyr.name : id;
-  }
-
-  var TargetUtils = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    expandCommandTargets: expandCommandTargets,
-    findCommandTargets: findCommandTargets,
-    groupLayersByDataset: groupLayersByDataset,
-    findMatchingLayers: findMatchingLayers,
-    getLayerMatch: getLayerMatch,
-    countTargetLayers: countTargetLayers,
-    getLayerTargetId: getLayerTargetId
-  });
-
   function readFirstChars(reader, n) {
     return bufferToString(reader.readSync(0, Math.min(n || 1000, reader.size())));
   }
@@ -17355,8 +17490,8 @@ ${svg}
         DEFAULT_CACHE_LEN = opts && opts.cacheSize || 0x1000000, // 16MB
         DEFAULT_BUFFER_LEN = opts && opts.bufferSize || 0x40000, // 256K
         fd, cacheOffs, cache, binArr;
-
-    getStateVar('input_files').push(path); // bit of a kludge
+    // kludge to let us check if input files are being overwritten
+    (getStashedVar('input_files') || []).push(path);
 
     // Double the default size of the Buffer returned by readSync()
     this.expandBuffer = function() {
@@ -20163,6 +20298,10 @@ ${svg}
         DEFAULT: true,
         type: 'distance'
       })
+      .option('endpoints', {
+        describe: 'only snap together the endpoints of lines',
+        type: 'flag'
+      })
       .option('precision', {
         describe: 'round all coordinates to a given decimal precision (e.g. 0.000001)',
         type: 'number'
@@ -20704,16 +20843,16 @@ ${svg}
     var ifOpts = {
       expression: {
         DEFAULT: true,
-        describe: 'JS expression targeting a single layer'
-      },
-      empty: {
-        describe: 'run if layer is empty',
-        type: 'flag'
-      },
-      'not-empty': {
-        describe: 'run if layer is not empty',
-        type: 'flag'
+        describe: 'JS expression'
       },
+      // empty: {
+      //   describe: 'run if layer is empty',
+      //   type: 'flag'
+      // },
+      // 'not-empty': {
+      //   describe: 'run if layer is not empty',
+      //   type: 'flag'
+      // },
       layer: {
         describe: 'name or id of layer to test (default is current target)'
       },
@@ -23158,6 +23297,13 @@ ${svg}
     importJSON: importJSON
   });
 
+  function importKML(str, opts) {
+    var togeojson = require("@tmcw/togeojson");
+    var Parser = typeof DOMParser == 'undefined' ? require("@xmldom/xmldom").DOMParser : DOMParser;
+    var geojson = togeojson.kml(new Parser().parseFromString(str, "text/xml"));
+    return importGeoJSON(geojson, opts || {});
+  }
+
   // Parse content of one or more input files and return a dataset
   // @obj: file data, indexed by file type
   // File data objects have two properties:
@@ -23194,6 +23340,11 @@ ${svg}
       fileFmt = 'prj';
       data = obj.prj;
       dataset = {layers: [], info: {prj: data.content}};
+
+    } else if (obj.kml) {
+      fileFmt = 'kml';
+      data = obj.kml;
+      dataset = importKML(data.content, opts);
     }
 
     if (!dataset) {
@@ -23375,7 +23526,7 @@ ${svg}
         stop('Expected binary content, received a string');
       }
 
-    } else if (fileType) { // string type
+    } else if (fileType) { // string type, e.g. kml, geojson
       content = cli.readFile(path, encoding || 'utf-8', cache);
 
     } else { // type can't be inferred from filename -- try reading as text
@@ -23664,6 +23815,49 @@ ${svg}
     getFormattedLayerList: getFormattedLayerList
   });
 
+  function Job(catalog) {
+    var currentCmd;
+
+  	var job = {
+      catalog: catalog || new Catalog(),
+      defs: {},
+      settings: {},
+      input_files: []
+  	};
+
+    job.initSettings = function(o) {
+      job.settings = o;
+      stashVars(job, {});
+    };
+
+    job.startCommand = function(cmd) {
+      currentCmd = cmd;
+      stashVars(job, cmd);
+    };
+
+    // Rejected the idea of passing a command reference to compare with the initial command
+    // (for error checking) ... the "-run" command inserts other commands before this call
+    job.endCommand = function() {
+      currentCmd = null;
+      clearStash();
+    };
+
+    job.resumeCommand = function() {
+      stashVars(job, currentCmd);
+    };
+
+    return job;
+  }
+
+  function stashVars(job, cmd) {
+    clearStash();  // prevent errors from overwriting stash
+    stashVar('current_command', cmd.name);
+    stashVar('DEBUG', job.settings.DEBUG || cmd.debug);
+    stashVar('QUIET', job.settings.QUIET || cmd.quiet);
+    stashVar('defs', job.defs);
+    stashVar('input_files', job.input_files);
+  }
+
   const epsilon = 1.1102230246251565e-16;
   const splitter = 134217729;
   const resulterrbound = (3 + 8 * epsilon) * epsilon;
@@ -30407,7 +30601,7 @@ ${svg}
     if (isReservedName(opts.name)) {
       stop('"' + opts.name + '" is a reserved name');
     }
-    getStateVar('defs')[opts.name] = getColorizerFunction(opts);
+    getStashedVar('defs')[opts.name] = getColorizerFunction(opts);
   };
 
   function isReservedName(name) {
@@ -30526,7 +30720,7 @@ ${svg}
 
   cmd.dashlines = function(lyr, dataset, opts) {
     var crs = getDatasetCRS(dataset);
-    var defs = getStateVar('defs');
+    var defs = getStashedVar('defs');
     var exp = `this.geojson = splitFeature(this.geojson)`;
     requirePolylineLayer(lyr);
     defs.splitFeature = getSplitFeatureFunction(crs, opts);
@@ -30930,7 +31124,7 @@ ${svg}
     if (!opts.expression) {
       stop('Missing an assignment expression');
     }
-    var defs = getStateVar('defs');
+    var defs = getStashedVar('defs');
     var compiled = compileFeatureExpression(opts.expression, {}, null, {no_warn: true});
     var result = compiled(null, defs);
   };
@@ -32202,8 +32396,6 @@ ${svg}
     if (opts && opts.where) {
       filter = compileValueExpression(opts.where, lyr, arcs);
     }
-    // 'defs' are now added to the context of all expressions
-    // compiled = compileFeatureExpression(exp, lyr, arcs, {context: getStateVar('defs')});
     compiled = compileFeatureExpression(exp, lyr, arcs, exprOpts);
     // call compiled expression with id of each record
     for (var i=0; i<n; i++) {
@@ -34612,48 +34804,60 @@ ${svg}
     };
   }
 
-  function resetControlFlow() {
-    setStateVar('control', null);
+  function resetControlFlow(job) {
+    job.control = null;
   }
 
-  function inControlBlock() {
-    var state = getState();
-    return !!state.inControlBlock;
+  function inControlBlock(job) {
+    return !!getState(job).inControlBlock;
   }
 
-  function enterActiveBranch() {
-    var state = getState();
+  function enterActiveBranch(job) {
+    var state = getState(job);
     state.inControlBlock = true;
     state.active = true;
     state.complete = true;
   }
 
-  function enterInactiveBranch() {
-    var state = getState();
+  function enterInactiveBranch(job) {
+    var state = getState(job);
     state.inControlBlock = true;
     state.active = false;
   }
 
-  function blockWasActive() {
-    return !!getState().complete;
+  function blockWasActive(job) {
+    return !!getState(job).complete;
   }
 
-  function inActiveBranch() {
-    return !!getState().active;
+  function inActiveBranch(job) {
+    return !!getState(job).active;
   }
 
-  function getState() {
-    var o = getStateVar('control') || setStateVar('control', {}) || getStateVar('control');
-    return o;
+  function getState(job) {
+    return job.control || (job.control = {});
   }
 
-  function compileIfCommandExpression(expr, catalog, targ, opts) {
-    var ctx = getLayerProxy(targ.layer, targ.dataset.arcs, opts);
+  function compileIfCommandExpression(expr, catalog, opts) {
+    var targetId = opts.layer || opts.target || null;
+    var targets = catalog.findCommandTargets(targetId);
+    var isSingle = targets.length == 1 && targets[0].layers.length == 1;
+    if (targets.length === 0 && targetId) {
+      stop('Layer not found:', targetId);
+    }
+    var ctx;
+    if (isSingle) {
+      ctx = getLayerProxy(targets[0].layers[0], targets[0].dataset.arcs, opts);
+    } else {
+      ctx = getNullLayerProxy(targets);
+    }
     var exprOpts = Object.assign({returns: true}, opts);
     var func = compileExpressionToFunction(expr, exprOpts);
 
-    ctx.layer_exists = function(name) {
-      return !!catalog.findSingleLayer(name);
+    // @geoType: optional geometry type (polygon, polyline, point, null);
+    ctx.layer_exists = function(name, geoType) {
+      var targets = catalog.findCommandTargets(name, geoType);
+      if (targets.length === 0) return false;
+      return true;
     };
 
     ctx.file_exists = function(file) {
@@ -34670,89 +34874,68 @@ ${svg}
     };
   }
 
-  function skipCommand(cmdName) {
+  function skipCommand(cmdName, job) {
     // allow all control commands to run
     if (isControlFlowCommand(cmdName)) return false;
-    return inControlBlock() && !inActiveBranch();
+    return inControlBlock(job) && !inActiveBranch(job);
   }
 
-  cmd.if = function(catalog, opts) {
-    if (inControlBlock()) {
+  cmd.if = function(job, opts) {
+    if (inControlBlock(job)) {
       stop('Nested -if commands are not supported.');
     }
-    evaluateIf(catalog, opts);
+    evaluateIf(job, opts);
   };
 
-  cmd.elif = function(catalog, opts) {
-    if (!inControlBlock()) {
+  cmd.elif = function(job, opts) {
+    if (!inControlBlock(job)) {
       stop('-elif command must be preceded by an -if command.');
     }
-    evaluateIf(catalog, opts);
+    evaluateIf(job, opts);
   };
 
-  cmd.else = function() {
-    if (!inControlBlock()) {
+  cmd.else = function(job) {
+    if (!inControlBlock(job)) {
       stop('-else command must be preceded by an -if command.');
     }
-    if (blockWasActive()) {
-      enterInactiveBranch();
+    if (blockWasActive(job)) {
+      enterInactiveBranch(job);
     } else {
-      enterActiveBranch();
+      enterActiveBranch(job);
     }
   };
 
-  cmd.endif = function() {
-    if (!inControlBlock()) {
+  cmd.endif = function(job) {
+    if (!inControlBlock(job)) {
       stop('-endif command must be preceded by an -if command.');
     }
-    resetControlFlow();
+    resetControlFlow(job);
   };
 
   function isControlFlowCommand(cmd) {
     return ['if','elif','else','endif'].includes(cmd);
   }
 
-  function testLayer(catalog, opts) {
-    var targ = getTargetLayer(catalog, opts);
+  function test(catalog, opts) {
+    // var targ = getTargetLayer(catalog, opts);
     if (opts.expression) {
-      return compileIfCommandExpression(opts.expression, catalog, targ, opts)();
-    }
-    if (opts.empty) {
-      return layerIsEmpty(targ.layer);
-    }
-    if (opts.not_empty) {
-      return !layerIsEmpty(targ.layer);
+      return compileIfCommandExpression(opts.expression, catalog, opts)();
     }
+    // if (opts.empty) {
+    //   return layerIsEmpty(targ.layer);
+    // }
+    // if (opts.not_empty) {
+    //   return !layerIsEmpty(targ.layer);
+    // }
     return true;
   }
 
-  function evaluateIf(catalog, opts) {
-    if (!blockWasActive() && testLayer(catalog, opts)) {
-      enterActiveBranch();
+  function evaluateIf(job, opts) {
+    if (!blockWasActive(job) && test(job.catalog, opts)) {
+      enterActiveBranch(job);
     } 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.');
-      }
+      enterInactiveBranch(job);
     }
-    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) {
@@ -34790,7 +34973,7 @@ ${svg}
       obj = content;
     }
 
-    utils.extend(getStateVar('defs'), obj);
+    utils.extend(getStashedVar('defs'), obj);
   };
 
   var MAX_RULE_LEN = 50;
@@ -34849,7 +35032,7 @@ ${svg}
       null_shape_count: 0,
       null_data_count: lyr.data ? countNullRecords(lyr.data.getRecords()) : n
     };
-    if (lyr.shapes) {
+    if (lyr.shapes && lyr.shapes.length > 0) {
       o.null_shape_count = countNullShapes(lyr.shapes);
       o.bbox =getLayerBounds(lyr, dataset.arcs).toArray();
       o.proj4 = getProjInfo(dataset);
@@ -37122,7 +37305,7 @@ ${svg}
     parseConsoleCommands: parseConsoleCommands
   });
 
-  cmd.run = function(targets, catalog, opts, cb) {
+  cmd.run = function(job, targets, opts, cb) {
     var commandStr, commands;
     if (opts.include) {
       cmd.include({file: opts.include});
@@ -37133,7 +37316,7 @@ ${svg}
     commandStr = runGlobalExpression(opts.commands, targets);
     if (commandStr) {
       commands = parseCommands(commandStr);
-      runParsedCommands(commands, catalog, cb);
+      runParsedCommands(commands, job, cb);
     } else {
       cb(null);
     }
@@ -37147,7 +37330,7 @@ ${svg}
       targetData = getRunCommandData(targets[0]);
       Object.defineProperty(ctx, 'target', {value: targetData});
     }
-    utils.extend(ctx, getStateVar('defs'));
+    utils.extend(ctx, getStashedVar('defs'));
     try {
       output = Function('ctx', 'with(ctx) {return (' + expression + ');}').call({}, ctx);
     } catch(e) {
@@ -37166,7 +37349,7 @@ ${svg}
   }
 
   cmd.require = function(targets, opts) {
-    var defs = getStateVar('defs');
+    var defs = getStashedVar('defs');
     var moduleFile, moduleName, mod;
     if (!opts.module) {
       stop("Missing module name or path to module");
@@ -37196,72 +37379,6 @@ ${svg}
     }
   };
 
-  symbolRenderers.circle = function(d, x, y) {
-    var o = importPoint([x, y], d, {});
-    applyStyleAttributes(o, 'Point', d);
-    return [o];
-  };
-
-  symbolRenderers.label = function(d, x, y) {
-    var o = importStyledLabel(d, [x, y]);
-    return [o];
-  };
-
-  symbolRenderers.image = function(d, x, y) {
-    var w = d.width || 20,
-        h = d.height || 20;
-    var o = {
-      tag: 'image',
-      properties: {
-        width: w,
-        height: h,
-        x: x - w / 2,
-        y: y - h / 2,
-        href: d.href || ''
-      }
-    };
-    return [o];
-  };
-
-  symbolRenderers.square = function(d, x, y) {
-    var o = importPoint([x, y], d, {point_symbol: 'square'});
-    applyStyleAttributes(o, 'Point', d);
-    return [o];
-  };
-
-  symbolRenderers.line = function(d, x, y) {
-    var coords, o;
-    coords = [[x, y], [x + (d.dx || 0), y + (d.dy || 0)]];
-    o = importLineString(coords);
-    applyStyleAttributes(o, 'LineString', d);
-    return [o];
-  };
-
-  symbolRenderers.polyline = function(d, x, y) {
-    var coords = d.coordinates || [];
-    var o = importMultiLineString(coords);
-    applyStyleAttributes(o, 'LineString', d);
-    return [o];
-  };
-
-  symbolRenderers.polygon = function(d, x, y) {
-    var coords = d.coordinates || [];
-    var o = importPolygon(coords);
-    applyStyleAttributes(o, 'Polygon', d);
-    return [o];
-  };
-
-  symbolRenderers.group = function(d, x, y) {
-    return (d.parts || []).reduce(function(memo, o) {
-      var sym = renderSymbol(o, x, y);
-      if (d.chained) {
-        x += (o.dx || 0);
-        y += (o.dy || 0);
-      }
-      return memo.concat(sym);
-    }, []);
-  };
-
   cmd.scalebar = function(catalog, opts) {
     var frame = findFrameDataset(catalog);
     var obj, lyr;
@@ -37345,7 +37462,7 @@ ${svg}
         // so I'm using 'hanging' and 'auto', which seem to be well supported.
         // downside: requires a kludgy multiplier to calculate scalebar height (see above)
       };
-    var labelObj = symbolRenderers.label(labelOpts, anchorX, anchorY)[0];
+    var labelObj = symbolRenderers.label(labelOpts, anchorX, anchorY);
     var g = {
       tag: 'g',
       children: [barObj, labelObj],
@@ -38448,7 +38565,12 @@ ${svg}
       interval = getHighPrecisionSnapInterval(arcBounds.toArray());
     }
     arcs.flatten(); // bake in any simplification
-    if (interval > 0) {
+    if (interval > 0 && opts.endpoints) {
+      // snaps line endpoints together
+      // TODO: also snap endpoints to line segments to remove undershoots and overshoots
+      snapCount = snapEndpointsByInterval(arcs, interval);
+      message(utils.format("Snapped %s endpoint%s", snapCount, utils.pluralSuffix(snapCount)));
+    } else if (interval > 0) {
       snapCount = snapCoordsByInterval(arcs, interval);
       message(utils.format("Snapped %s point%s", snapCount, utils.pluralSuffix(snapCount)));
     }
@@ -38591,6 +38713,15 @@ ${svg}
 
   var roundCoord = getRoundingFunction(0.01);
 
+  function getSymbolColor(d) {
+    return d.fill || 'magenta';
+  }
+
+  function getSymbolRadius(d) {
+    if (d.radius === 0 || d.length === 0 || d.r === 0) return 0;
+    return d.radius || d.length || d.r || 5; // use a default value
+  }
+
   function forEachSymbolCoord(coords, cb) {
     var isPoint = coords && utils.isNumber(coords[0]);
     var isNested = !isPoint && coords && Array.isArray(coords[0]);
@@ -38845,8 +38976,19 @@ ${svg}
     return coords;
   }
 
+  function makeCircleSymbol(d, opts) {
+    var radius = getSymbolRadius(d);
+    // TODO: remove duplicatoin with svg-symbols.js
+    if (+opts.scale) radius *= +opts.scale;
+    return {
+      type: 'circle',
+      fill: getSymbolColor(d),
+      r: radius
+    };
+  }
+
   function getPolygonCoords(d) {
-    var radius = d.radius || d.length || d.r,
+    var radius = getSymbolRadius(d),
         sides = +d.sides || getSidesByType(d.type),
         rotated = sides % 2 == 1,
         coords = [],
@@ -38883,7 +39025,7 @@ ${svg}
   }
 
   function getStarCoords(d) {
-    var radius = d.radius || d.length || d.r,
+    var radius = getSymbolRadius(d),
         points = d.points || d.sides && d.sides / 2 || 5,
         sides = points * 2,
         minorRadius = getMinorRadius(points) * radius,
@@ -38928,6 +39070,34 @@ ${svg}
     return 180 - centerAngle;
   }
 
+  function makeRingSymbol(d, opts) {
+    var scale = +opts.scale || 1;
+    var radii = parseRings(d.radii || '2').map(function(r) { return r * scale; });
+    var solidCenter = utils.isOdd(radii.length);
+    var color = getSymbolColor(d);
+    var parts = [];
+    if (solidCenter) {
+      parts.push({
+        type: 'circle',
+        fill: color,
+        r: radii.shift()
+      });
+    }
+    for (var i=0; i<radii.length; i+= 2) {
+      parts.push({
+        type: 'circle',
+        fill: 'none', // TODO remove default black fill so this is not needed
+        stroke: color,
+        'stroke-width':  roundToTenths(radii[i+1] - radii[i]),
+        r: roundToTenths(radii[i+1] * 0.5 + radii[i] * 0.5)
+      });
+    }
+    return {
+      type: 'group',
+      parts: parts
+    };
+  }
+
   // Returns GeoJSON MultiPolygon coords
   function getRingCoords(d) {
     var radii = parseRings(d.radii || '2');
@@ -38959,6 +39129,27 @@ ${svg}
     return utils.uniq(arr);
   }
 
+  // Returns an svg-symbol data object for one symbol
+  function makePolygonSymbol(coords, properties, geojsonType) {
+    if (geojsonType == 'MultiPolygon') {
+      coords = convertMultiPolygonCoords(coords);
+    } else if (geojsonType != 'Polygon') {
+      error('Unsupported type:', geojsonType);
+    }
+    roundCoordsForSVG(coords);
+    return {
+      type: 'polygon',
+      coordinates: coords,
+      fill: getSymbolColor(properties)
+    };
+  }
+
+  function convertMultiPolygonCoords(coords) {
+    return coords.reduce(function(memo, poly) {
+      return memo.concat(poly);
+    }, []);
+  }
+
   // TODO: refactor to remove duplication in mapshaper-svg-style.js
   cmd.symbols = function(inputLyr, dataset, opts) {
     requireSinglePointLayer(inputLyr);
@@ -38975,8 +39166,20 @@ ${svg}
       if (!shp) return null;
       var d = getSymbolData(i);
       var rec = records[i] || {};
+
+      // non-polygon symbols
+      if (!polygonMode && d.type == 'circle') {
+        rec['svg-symbol'] = makeCircleSymbol(d, opts);
+        return;
+      }
+      if (!polygonMode && d.type == 'ring') {
+        rec['svg-symbol'] = makeRingSymbol(d, opts);
+        return;
+      }
+
       var geojsonType = 'Polygon';
       var coords;
+      // these symbols get converted to polygon shapes
       if (d.type == 'arrow') {
         coords = getFilledArrowCoords(d);
       } else if (d.type == 'ring') {
@@ -39000,7 +39203,7 @@ ${svg}
         if (d.tfill) rec.fill = d.fill;
         return createGeometry(coords, geojsonType);
       } else {
-        rec['svg-symbol'] = makeSvgPolygonSymbol(coords, d, geojsonType);
+        rec['svg-symbol'] = makePolygonSymbol(coords, d, geojsonType);
       }
     });
 
@@ -39039,33 +39242,11 @@ ${svg}
   }
 
   function getMetersPerPixel(lyr, dataset) {
-
     // TODO: handle single point, no extent
     var bounds = getLayerBounds(lyr);
     return bounds.width() / 800;
   }
 
-  // Returns an svg-symbol data object for one symbol
-  function makeSvgPolygonSymbol(coords, properties, geojsonType) {
-    if (geojsonType == 'MultiPolygon') {
-      coords = convertMultiPolygonCoords(coords);
-    } else if (geojsonType != 'Polygon') {
-      error('Unsupported type:', geojsonType);
-    }
-    roundCoordsForSVG(coords);
-    return {
-      type: 'polygon',
-      coordinates: coords,
-      fill: properties.fill || 'magenta'
-    };
-  }
-
-  function convertMultiPolygonCoords(coords) {
-    return coords.reduce(function(memo, poly) {
-      return memo.concat(poly);
-    }, []);
-  }
-
   var Symbols = /*#__PURE__*/Object.freeze({
     __proto__: null
   });
@@ -39468,7 +39649,20 @@ ${svg}
     return [lyr1, lyr2];
   }
 
-  function runCommand(command, catalog, cb) {
+  function commandAcceptsMultipleTargetDatasets(name) {
+    return name == 'rotate' || name == 'info' || name == 'proj' ||
+      name == 'drop' || name == 'target' || name == 'if' || name == 'elif' ||
+      name == 'else' || name == 'endif';
+  }
+
+  function commandAcceptsEmptyTarget(name) {
+    return name == 'graticule' || name == 'i' || name == 'help' ||
+      name == 'point-grid' || name == 'shape' || name == 'rectangle' ||
+      name == 'include' || name == 'print' || name == 'if' || name == 'elif' ||
+      name == 'else' || name == 'endif';
+  }
+
+  function runCommand(command, job, cb) {
     var name = command.name,
         opts = command.options,
         source,
@@ -39481,18 +39675,19 @@ ${svg}
         target,
         arcs;
 
-    if (skipCommand(name)) {
+    if (skipCommand(name, job)) {
       return done(null);
     }
 
-    try { // catch errors from synchronous functions
+    if (!job) job = new Job();
+    job.startCommand(command);
 
+    try { // catch errors from synchronous functions
       T$1.start();
-      if (!catalog) catalog = new Catalog();
 
       if (name == 'rename-layers') {
         // default target is all layers
-        targets = catalog.findCommandTargets(opts.target || '*');
+        targets = job.catalog.findCommandTargets(opts.target || '*');
         targetLayers = targets.reduce(function(memo, obj) {
           return memo.concat(obj.layers);
         }, []);
@@ -39500,19 +39695,17 @@ ${svg}
       } else if (name == 'o') {
         // when combining GeoJSON layers, default is all layers
         // TODO: check that combine_layers is only used w/ GeoJSON output
-        targets = catalog.findCommandTargets(opts.target || opts.combine_layers && '*');
+        targets = job.catalog.findCommandTargets(opts.target || opts.combine_layers && '*');
 
-      } else if (name == 'rotate' || name == 'info' || name == 'proj' || name == 'drop' || name == 'target') {
-        // these commands accept multiple target datasets
-        targets = catalog.findCommandTargets(opts.target);
+      } else if (commandAcceptsMultipleTargetDatasets(name)) {
+        targets = job.catalog.findCommandTargets(opts.target);
 
       } else {
-        targets = catalog.findCommandTargets(opts.target);
-
+        targets = job.catalog.findCommandTargets(opts.target);
         // special case to allow -merge-layers and -union to combine layers from multiple datasets
         // TODO: support multi-dataset targets for other commands
         if (targets.length > 1 && (name == 'merge-layers' || name == 'union')) {
-          targets = mergeCommandTargets(targets, catalog);
+          targets = mergeCommandTargets(targets, job.catalog);
         }
 
         if (targets.length == 1) {
@@ -39520,7 +39713,7 @@ ${svg}
           arcs = targetDataset.arcs;
           targetLayers = targets[0].layers;
           // target= option sets default target
-          catalog.setDefaultTarget(targetLayers, targetDataset);
+          job.catalog.setDefaultTarget(targetLayers, targetDataset);
 
         } else if (targets.length > 1) {
           stop("This command does not support targetting layers from different datasets");
@@ -39530,17 +39723,15 @@ ${svg}
       if (targets.length === 0) {
         if (opts.target) {
           stop(utils.format('Missing target: %s\nAvailable layers: %s',
-              opts.target, getFormattedLayerList(catalog)));
+              opts.target, getFormattedLayerList(job.catalog)));
         }
-        if (!(name == 'graticule' || name == 'i' || name == 'help' ||
-            name == 'point-grid' || name == 'shape' || name == 'rectangle' ||
-            name == 'include' || name == 'print')) {
+        if (!commandAcceptsEmptyTarget(name)) {
           throw new UserError("No data is available");
         }
       }
 
       if (opts.source) {
-        source = findCommandSource(convertSourceName(opts.source, targets), catalog, opts);
+        source = findCommandSource(convertSourceName(opts.source, targets), job.catalog, opts);
       }
 
       if (name == 'affine') {
@@ -39594,7 +39785,7 @@ ${svg}
         outputLayers = applyCommandToEachLayer(cmd.dots, targetLayers, arcs, opts);
 
       } else if (name == 'drop') {
-        cmd.drop2(catalog, targets, opts);
+        cmd.drop2(job.catalog, targets, opts);
         // cmd.drop(catalog, targetLayers, targetDataset, opts);
 
       } else if (name == 'each') {
@@ -39631,33 +39822,33 @@ ${svg}
         applyCommandToEachLayer(cmd.filterSlivers, targetLayers, targetDataset, opts);
 
       } else if (name == 'frame') {
-        cmd.frame(catalog, source, opts);
+        cmd.frame(job.catalog, source, opts);
 
       } else if (name == 'fuzzy-join') {
         applyCommandToEachLayer(cmd.fuzzyJoin, targetLayers, arcs, source, opts);
 
       } else if (name == 'graticule') {
-        catalog.addDataset(cmd.graticule(targetDataset, opts));
+        job.catalog.addDataset(cmd.graticule(targetDataset, opts));
 
       } else if (name == 'help') {
         // placing this here to handle errors from invalid command names
         getOptionParser().printHelp(command.options.command);
 
       } else if (name == 'i') {
-        if (opts.replace) catalog = new Catalog();
+        if (opts.replace) job.catalog = new Catalog(); // is this what we want?
         targetDataset = cmd.importFiles(command.options);
         if (targetDataset) {
-          catalog.addDataset(targetDataset);
+          job.catalog.addDataset(targetDataset);
           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);
+        cmd[name](job, opts);
 
       } else if (name == 'else' || name == 'endif') {
-        cmd[name]();
+        cmd[name](job);
 
       } else if (name == 'ignore') {
         applyCommandToEachLayer(cmd.ignore, targetLayers, targetDataset, opts);
@@ -39697,14 +39888,16 @@ ${svg}
         outputFiles = exportTargetLayers(targets, opts);
         if (opts.final) {
           // don't propagate data if output is final
-          catalog = null;
+          //// catalog = null;
+          job.catalog = new Catalog();
         }
-        return writeFiles(outputFiles, opts, done);
+        writeFiles(outputFiles, opts, done);
+        return; // async command
 
       } else if (name == 'point-grid') {
         outputLayers = [cmd.pointGrid(targetDataset, opts)];
         if (!targetDataset) {
-          catalog.addDataset({layers: outputLayers});
+          job.catalog.addDataset({layers: outputLayers});
         }
 
       } else if (name == 'point-to-grid') {
@@ -39724,10 +39917,11 @@ ${svg}
 
       } else if (name == 'proj') {
         initProjLibrary(opts, function() {
+          job.resumeCommand();
           var err = null;
           try {
             targets.forEach(function(targ) {
-              cmd.proj(targ.dataset, catalog, opts);
+              cmd.proj(targ.dataset, job.catalog, opts);
             });
           } catch(e) {
             err = e;
@@ -39738,7 +39932,7 @@ ${svg}
 
       } else if (name == 'rectangle') {
         if (source || opts.bbox || targets.length === 0) {
-          catalog.addDataset(cmd.rectangle(source, opts));
+          job.catalog.addDataset(cmd.rectangle(source, opts));
         } else {
           outputLayers = cmd.rectangle2(targets[0], opts);
         }
@@ -39750,7 +39944,7 @@ ${svg}
         applyCommandToEachLayer(cmd.renameFields, targetLayers, opts.fields);
 
       } else if (name == 'rename-layers') {
-        cmd.renameLayers(targetLayers, opts.names, catalog);
+        cmd.renameLayers(targetLayers, opts.names, job.catalog);
 
       } else if (name == 'require') {
         cmd.require(targets, opts);
@@ -39761,14 +39955,14 @@ ${svg}
         });
 
       } else if (name == 'run') {
-        cmd.run(targets, catalog, opts, done);
-        return;
+        cmd.run(job, targets, opts, done);
+        return; // async command
 
       } else if (name == 'scalebar') {
-        cmd.scalebar(catalog, opts);
+        cmd.scalebar(job.catalog, opts);
 
       } else if (name == 'shape') {
-        catalog.addDataset(cmd.shape(targetDataset, opts));
+        job.catalog.addDataset(cmd.shape(targetDataset, opts));
 
       } else if (name == 'shapes') {
         outputLayers = applyCommandToEachLayer(cmd.shapes, targetLayers, targetDataset, opts);
@@ -39808,7 +40002,7 @@ ${svg}
         outputLayers = applyCommandToEachLayer(cmd.subdivideLayer, targetLayers, arcs, opts.expression);
 
       } else if (name == 'target') {
-        cmd.target(catalog, opts);
+        cmd.target(job.catalog, opts);
 
       } else if (name == 'union') {
         outputLayers = cmd.union(targetLayers, targetDataset, opts);
@@ -39818,7 +40012,7 @@ ${svg}
 
       } else {
         // throws error if command is not registered
-        cmd.runExternalCommand(command, catalog);
+        cmd.runExternalCommand(command, job.catalog);
       }
 
       // apply name parameter
@@ -39830,12 +40024,12 @@ ${svg}
       }
 
       if (outputDataset) {
-        catalog.addDataset(outputDataset); // also sets default target
+        job.catalog.addDataset(outputDataset); // also sets default target
         outputLayers = outputDataset.layers;
         if (targetLayers && !opts.no_replace) {
           // remove target layers from target dataset
           targetLayers.forEach(function(lyr) {
-            catalog.deleteLayer(lyr, targetDataset);
+            job.catalog.deleteLayer(lyr, targetDataset);
           });
         }
       } else if (outputLayers && targetDataset && outputLayers != targetDataset.layers) {
@@ -39858,7 +40052,7 @@ ${svg}
         }
 
         if (opts.apart) {
-          catalog.setDefaultTargets(splitApartLayers( targetDataset, outputLayers).map(function(dataset) {
+          job.catalog.setDefaultTargets(splitApartLayers( targetDataset, outputLayers).map(function(dataset) {
             return {
               dataset: dataset,
               layers: dataset.layers.concat()
@@ -39866,9 +40060,8 @@ ${svg}
           }));
         } else {
           // use command output as new default target
-          catalog.setDefaultTarget(outputLayers, targetDataset);
+          job.catalog.setDefaultTarget(outputLayers, targetDataset);
         }
-
       }
 
       // delete arcs if no longer needed (e.g. after -points command)
@@ -39880,11 +40073,13 @@ ${svg}
       return done(e);
     }
 
+    // non-erroring synchronous commands are done
     done(null);
 
     function done(err) {
+      job.endCommand();
       verbose('-', T$1.stop());
-      cb(err, err ? null : catalog);
+      cb(err, err ? null : job);
     }
   }
 
@@ -39894,7 +40089,6 @@ ${svg}
     });
   }
 
-
   // Apply a command to an array of target layers
   function applyCommandToEachLayer(func, targetLayers) {
     var args = utils.toArray(arguments).slice(2);
@@ -40028,7 +40222,7 @@ ${svg}
     }
 
     // add options to -i -o -join -clip -erase commands to bypass file i/o
-    // TODO: find a less kludgy solution, e.g. storing input data using setStateVar()
+    // TODO: find a less kludgy solution
     commands.forEach(function(cmd) {
       if (commandTakesFileInput(cmd.name) && inputObj) {
         cmd.options.input = inputObj;
@@ -40074,8 +40268,8 @@ ${svg}
 
   // TODO: rewrite tests and remove this function
   function testCommands(argv, done) {
-    _runCommands(argv, {}, function(err, catalog) {
-      var targets = catalog ? catalog.getDefaultTargets() : [];
+    _runCommands(argv, {}, function(err, job) {
+      var targets = job ? job.catalog.getDefaultTargets() : [];
       var output;
       if (!err && targets.length > 0) {
         // returns dataset for compatibility with some older tests
@@ -40087,15 +40281,12 @@ ${svg}
 
   // Execute a sequence of parsed commands
   // @commands Array of parsed commands
-  // @catalog: Optional Catalog object containing previously imported data
+  // @job: Optional Job object containing previously imported data
   // @cb: function(<error>, <catalog>)
   //
-  function runParsedCommands(commands, catalog, cb) {
-    if (!catalog) {
-      cb = createAsyncContext(cb); // use new context when creating new catalog
-      catalog = new Catalog();
-    } else if (catalog instanceof Catalog === false) {
-      error("Changed in v0.4: runParsedCommands() takes a Catalog object");
+  function runParsedCommands(commands, job, cb) {
+    if (!job) {
+      job = new Job();
     }
 
     if (!utils.isArray(commands)) {
@@ -40105,7 +40296,7 @@ ${svg}
     if (commands.length === 0) {
       return done(new UserError("No commands to run"));
     }
-    commands = readAndRemoveSettings(commands);
+    commands = readAndRemoveSettings(job, commands);
     if (!runningInBrowser()) {
       printStartupMessages();
     }
@@ -40122,25 +40313,22 @@ ${svg}
     var groups = divideImportCommand(commands);
     if (groups.length == 1) {
       // run a simple sequence of commands (input files are not batched)
-      return runParsedCommands2(commands, catalog, done);
+      return runParsedCommands2(commands, job, done);
     }
 
     // run duplicated commands (i.e. batch mode)
-    utils.reduceAsync(groups, catalog, nextGroup, done);
+    utils.reduceAsync(groups, job, nextGroup, done);
 
-    function nextGroup(catalog, commands, next) {
-      runParsedCommands2(commands, catalog, function(err, catalog) {
+    function nextGroup(job, commands, next) {
+      runParsedCommands2(commands, job, function(err, job) {
         err = filterError(err);
-        next(err, catalog);
+        next(err, job);
       });
     }
 
-    function done(err, catalog) {
+    function done(err, job) {
       err = filterError(err);
-      cb(err, catalog);
-      setStateVar('current_command', null);
-      setStateVar('verbose', false);
-      setStateVar('debug', false);
+      cb(err, job);
     }
   }
 
@@ -40152,16 +40340,13 @@ ${svg}
     return err;
   }
 
-  function runParsedCommands2(commands, catalog, cb) {
+  function runParsedCommands2(commands, job, cb) {
     // resetting closes any unterminated -if blocks from a previous command sequence
-    resetControlFlow();
-    utils.reduceAsync(commands, catalog, nextCommand, cb);
+    resetControlFlow(job);
+    utils.reduceAsync(commands, job, nextCommand, cb);
 
-    function nextCommand(catalog, cmd, next) {
-      setStateVar('current_command', cmd.name); // for log msgs
-      setStateVar('verbose', !!cmd.options.verbose);
-      setStateVar('debug', !!cmd.options.debug);
-      runCommand(cmd, catalog, next);
+    function nextCommand(job, cmd, next) {
+      runCommand(cmd, job, next);
     }
   }
 
@@ -40207,19 +40392,22 @@ ${svg}
   }
 
   // Some settings use command syntax and are parsed as commands.
-  function readAndRemoveSettings(commands) {
-    return commands.filter(function(cmd) {
+  function readAndRemoveSettings(job, commands) {
+    var settings = {VERBOSE: false, QUIET: false, DEBUG: false};
+    var filtered = commands.filter(function(cmd) {
       if (cmd.name == 'verbose') {
-        setStateVar('VERBOSE', true);
+        settings.VERBOSE = true;
       } else if (cmd.name == 'quiet') {
-        setStateVar('QUIET', true);
+        settings.QUIET = true;
       } else if (cmd.name == 'debug') {
-        setStateVar('DEBUG', true);
+        settings.DEBUG = true;
       } else {
         return true;
       }
       return false;
     });
+    job.initSettings(settings);
+    return filtered;
   }
 
   // Run informational commands and remove them from the array of parsed commands
@@ -40565,12 +40753,14 @@ ${svg}
   //       export only functions called by the GUI.
 
   var internal = {};
-  internal.svg = Object.assign({}, SvgCommon, SvgStringify, SvgPathUtils, GeojsonToSvg);
+
+  internal.svg = Object.assign({}, SvgStringify, SvgPathUtils, GeojsonToSvg, SvgLabels, SvgSymbols);
 
   // Assign functions and objects exported from modules to the 'internal' namespace
   // to maintain compatibility with tests and to expose (some of) them to the GUI.
 
   Object.assign(internal, {
+    Job,
     Dbf,
     DbfReader,
     DouglasPeucker,
@@ -40694,6 +40884,7 @@ ${svg}
     SourceUtils,
     Split,
     State,
+    Stash,
     Stringify,
     Svg,
     SvgProperties,