mapshaper 0.5.67 → 0.5.71

package/mapshaper.js

@@ -1,6 +1,6 @@
 (function () {
 
-  var VERSION = "0.5.66";
+  var VERSION = "0.5.69";
 
 
   var utils = /*#__PURE__*/Object.freeze({
@@ -1167,6 +1167,10 @@
     throw new UserError(formatLogArgs(arguments));
   };
 
+  var _interrupt = function() {
+    throw new NonFatalError(formatLogArgs(arguments));
+  };
+
   var _message = function() {
     logArgs(arguments);
   };
@@ -1185,10 +1189,14 @@
   }
 
   // Handle an error caused by invalid input or misuse of API
-  function stop () {
+  function stop() {
     _stop.apply(null, utils.toArray(arguments));
   }
 
+  function interrupt() {
+    _interrupt.apply(null, utils.toArray(arguments));
+  }
+
   // Print a status message
   function message() {
     _message.apply(null, messageArgs(arguments));
@@ -1228,7 +1236,9 @@
     if (utils.isString(err)) {
       err = new UserError(err);
     }
-    if (err.name == 'UserError') {
+    if (err.name == 'NonFatalError') {
+      console.error(messageArgs([err.message]).join(' '));
+    } else if (err.name == 'UserError') {
       msg = err.message;
       if (!/Error/.test(msg)) {
         msg = "Error: " + msg;
@@ -1248,6 +1258,12 @@
     return err;
   }
 
+  function NonFatalError(msg) {
+    var err = new Error(msg);
+    err.name = 'NonFatalError';
+    return err;
+  }
+
   function formatColumns(arr, alignments) {
     var widths = arr.reduce(function(memo, line) {
       return line.map(function(str, i) {
@@ -1308,6 +1324,7 @@
     loggingEnabled: loggingEnabled,
     error: error,
     stop: stop,
+    interrupt: interrupt,
     message: message,
     setLoggingFunctions: setLoggingFunctions,
     print: print,
@@ -1315,6 +1332,7 @@
     debug: debug,
     printError: printError,
     UserError: UserError,
+    NonFatalError: NonFatalError,
     formatColumns: formatColumns,
     formatStringsAsGrid: formatStringsAsGrid,
     formatLogArgs: formatLogArgs,
@@ -14306,7 +14324,7 @@
       joinStr = obj.tag == 'text' || obj.tag == 'tspan' ? '' : '\n';
       svg += '>' + joinStr;
       if (obj.value) {
-        svg += obj.value;
+        svg += stringEscape(obj.value);
       }
       if (obj.children) {
         svg += obj.children.map(stringify).join(joinStr);
@@ -14329,8 +14347,13 @@
         "'": '''
       };
   function stringEscape(s) {
-    return String(s).replace(rxp, function(s) {
-      return map[s];
+    return String(s).replace(rxp, function(match, i) {
+      var entity = map[match];
+      // don't replace & with &
+      if (match == '&' && s.substr(i, entity.length) == entity) {
+        return '&';
+      }
+      return entity;
     });
   }
 
@@ -18416,6 +18439,9 @@ ${svg}
         type: 'strings',
         describe: '[CSV] comma-sep. list of fields to import'
       })
+      // .option('csv-comment', {
+      //   describe: '[CSV] comment line character(s)'
+      // })
       .option('decimal-comma', {
         type: 'flag',
         describe: '[CSV] import numbers formatted like 1.000,01 or 1 000,01'
@@ -18652,7 +18678,8 @@ ${svg}
       .option('no-replace', noReplaceOpt);
 
     parser.command('classify')
-      .describe('apply sequential or categorical classification')
+      // .describe('apply sequential or categorical classification')
+      .describe('assign colors or values using one of several methods')
       .option('field', {
         describe: 'name of field to classify',
         DEFAULT: true
@@ -18672,6 +18699,10 @@ ${svg}
         // deprecated in favor of colors=
         // describe: 'name of a predefined color scheme (see -colors command)'
       })
+      .option('non-adjacent', {
+        describe: 'assign non-adjacent colors to a polygon layer',
+        assign_to: 'method'
+      })
       .option('stops', {
         describe: 'a pair of values (0-100) for limiting a color ramp',
         type: 'numbers'
@@ -18756,7 +18787,6 @@ ${svg}
       .option('key-last-suffix', {
         describe: 'string to append to last label'
       })
-
       .option('target', targetOpt);
 
     parser.command('clean')
@@ -19165,6 +19195,14 @@ ${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('inlay')
       .describe('inscribe a polygon layer inside another polygon layer')
       .option('source', {
@@ -19236,6 +19274,10 @@ ${svg}
         // describe: 'use planar geometry when interpolating by area' // useful for testing
         type: 'flag'
       })
+      .option('duplication', {
+        describe: 'duplicate target features on many-to-one joins',
+        type: 'flag'
+      })
       .option('string-fields', stringFieldsOpt)
       .option('field-types', fieldTypesOpt)
       .option('sum-fields', {
@@ -28025,25 +28067,241 @@ ${svg}
     return maxId + 1;
   }
 
-  cmd.classify = function(lyr, optsArg) {
+  // Returns a function for constructing a query function that accepts an arc id and
+  // returns information about the polygon or polygons that use the given arc.
+  // TODO: explain this better.
+  //
+  // options:
+  //   filter: optional filter function; signature: function(idA, idB or -1) : boolean
+  //   reusable: flag that lets an arc be queried multiple times.
+  function getArcClassifier(shapes, arcs) {
+    var opts = arguments[2] || {},
+        useOnce = !opts.reusable,
+        n = arcs.size(),
+        a = new Int32Array(n),
+        b = new Int32Array(n);
+
+    utils.initializeArray(a, -1);
+    utils.initializeArray(b, -1);
+
+    traversePaths(shapes, function(o) {
+      var i = absArcId(o.arcId);
+      var shpId = o.shapeId;
+      var aval = a[i];
+      if (aval == -1) {
+        a[i] = shpId;
+      } else if (shpId < aval) {
+        b[i] = aval;
+        a[i] = shpId;
+      } else {
+        b[i] = shpId;
+      }
+    });
+
+    function classify(arcId, getKey) {
+      var i = absArcId(arcId);
+      var shpA = a[i];
+      var shpB = b[i];
+      var key;
+      if (shpA == -1) return null;
+      key = getKey(shpA, shpB);
+      if (key === null || key === false) return null;
+      if (useOnce) {
+        // arc can only be queried once
+        a[i] = -1;
+        b[i] = -1;
+      }
+      // use optional filter to exclude some arcs
+      if (opts.filter && !opts.filter(shpA, shpB)) return null;
+      return key;
+    }
+
+    return function(getKey) {
+      return function(arcId) {
+        return classify(arcId, getKey);
+      };
+    };
+  }
+
+  var ArcClassifier = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getArcClassifier: getArcClassifier
+  });
+
+  // Returns a function for querying the neighbors of a given shape. The function
+  // can be called in either of two ways:
+  //
+  // 1. function(shapeId, callback)
+  //    Callback signature: function(adjacentShapeId, arcId)
+  //    The callback function is called once for each arc that the given feature
+  //    shares with another feature.
+  //
+  // 2. function(shapeId)
+  //    The function returns an array of unique ids of neighboring shapes, or
+  //    an empty array if a shape has no neighbors.
+  //
+  function getNeighborLookupFunction(lyr, arcs) {
+    var classifier = getArcClassifier(lyr.shapes, arcs, {reusable: true});
+    var classify = classifier(onShapes);
+    var currShapeId;
+    var neighbors;
+    var callback;
+
+    function onShapes(a, b) {
+      if (b == -1) return -1; // outer edges are b == -1
+      return a == currShapeId ? b : a;
+    }
+
+    function onArc(arcId) {
+      var nabeId = classify(arcId);
+      if (nabeId == -1) return;
+      if (callback) {
+        callback(nabeId, arcId);
+      } else if (neighbors.indexOf(nabeId) == -1) {
+        neighbors.push(nabeId);
+      }
+    }
+
+    return function(shpId, cb) {
+      currShapeId = shpId;
+      if (cb) {
+        callback = cb;
+        forEachArcId(lyr.shapes[shpId], onArc);
+        callback = null;
+      } else {
+        neighbors = [];
+        forEachArcId(lyr.shapes[shpId], onArc);
+        return neighbors;
+      }
+    };
+  }
+
+
+  // Returns an array containing all pairs of adjacent shapes
+  // in a collection of polygon shapes. A pair of shapes is represented as
+  // an array of two shape indexes [a, b].
+  function findPairsOfNeighbors(shapes, arcs) {
+    var getKey = function(a, b) {
+      return b > -1 && a > -1 ? [a, b] : null;
+    };
+    var classify = getArcClassifier(shapes, arcs)(getKey);
+    var arr = [];
+    var index = {};
+    var onArc = function(arcId) {
+      var obj = classify(arcId);
+      var key;
+      if (obj) {
+        key = obj.join('~');
+        if (key in index === false) {
+          arr.push(obj);
+          index[key] = true;
+        }
+      }
+    };
+    forEachArcId(shapes, onArc);
+    return arr;
+  }
+
+  var PolygonNeighbors = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getNeighborLookupFunction: getNeighborLookupFunction,
+    findPairsOfNeighbors: findPairsOfNeighbors
+  });
+
+  function getNonAdjacentClassifier(lyr, dataset, colors) {
+    requirePolygonLayer(lyr);
+    var getNeighbors = getNeighborLookupFunction(lyr, dataset.arcs);
+    var errorCount = 0;
+    var data = utils.range(getFeatureCount(lyr)).map(function(shpId) {
+      var nabes = getNeighbors(shpId) || [];
+      return {
+        nabes: nabes,
+        n: nabes.length,
+        colorId: -1
+      };
+    });
+    var getSortedColorIds = getUpdateFunction(colors.length);
+    var colorIds = getSortedColorIds();
+    // Sort adjacency data by number of neighbors in descending order
+    var sorted = data.concat();
+    utils.sortOn(sorted, 'n', false);
+    // Assign colors, starting with polygons with the largest number of neighbors
+    sorted.forEach(function(d) {
+      var colorId = pickColor(d, data, colorIds);
+      if (colorId == -1) {
+        errorCount++;
+        colorId = colorIds[0];
+      }
+      d.colorId = colorId;
+      colorIds = getSortedColorIds(colorId);
+    });
+
+    if (errorCount > 0) {
+      message(`Unable to find non-adjacent colors for ${errorCount} ${errorCount == 1 ? 'polygon' : 'polygons'}`);
+    }
+    return function(shpId) {
+      return colors[data[shpId].colorId];
+    };
+  }
+
+  // Pick the id of a color that is not shared with a neighboring polygon
+  function pickColor(d, data, colorIds) {
+    var candidateId;
+    for (var i=0; i<colorIds.length; i++) {
+      candidateId = colorIds[i];
+      if (isAvailableColor(d, data, candidateId)) {
+        return candidateId;
+      }
+    }
+    return -1; // no colors are available
+  }
+
+  function isAvailableColor(d, data, colorId) {
+    var nabes = d.nabes;
+    for (var i=0; i<nabes.length; i++) {
+      if (data[nabes[i]].colorId === colorId) return false;
+    }
+    return true;
+  }
+
+  // Update function returns an array of ids, sorted in descending order of preference
+  // (less-used ids are preferred).
+  // Function recieves an (optional) id that was just used.
+  function getUpdateFunction(n) {
+    var ids = utils.range(n);
+    var counts = new Uint32Array(n);
+    return function(i) {
+      if (i >= 0 && i < n) {
+        counts[i]++;
+        utils.sortArrayIndex(ids, counts, true);
+      } else if (i !== undefined) {
+        error('Unexpected color index:', i);
+      }
+      return ids;
+    };
+  }
+
+  cmd.classify = function(lyr, dataset, optsArg) {
+    if (!lyr.data) {
+      initDataTable(lyr);
+    }
     var opts = optsArg || {};
     var records = lyr.data && lyr.data.getRecords();
     var nullValue = opts.null_value || null;
     var looksLikeColors = !!opts.colors || !!opts.color_scheme;
     var colorScheme;
-    var classValues, classify;
+    var classValues, classifyByValue, classifyById;
     var numBuckets, numValues;
     var dataField, outputField;
 
     // validate explicitly set classes
     if (opts.classes) {
       if (!utils.isInteger(opts.classes) || opts.classes > 1 === false) {
-        stop('Invalid classes= value:', opts.classes);
+        stop('Invalid number of classes:', opts.classes, '(expected a value greater than 1)');
       }
       numBuckets = opts.classes;
     }
 
-
     // TODO: better validation of breaks values
     if (opts.breaks) {
       numBuckets = opts.breaks.length + 1;
@@ -28061,9 +28319,6 @@ ${svg}
 
     } else if (opts.field) {
       dataField = opts.field;
-
-    } else {
-      stop('Missing a data field to classify');
     }
 
     // expand categories if value is '*'
@@ -28071,7 +28326,18 @@ ${svg}
       opts.categories = getUniqFieldValues(records, dataField);
     }
 
-    requireDataField(lyr.data, dataField);
+    if (opts.method == 'non-adjacent') {
+      if (lyr.geometry_type != 'polygon') {
+        stop('The non-adjacent option requires a polygon layer');
+      }
+      if (dataField) {
+        stop('The non-adjacent option does not accept a data field argument');
+      }
+    } else if (!dataField) {
+      stop('Missing a data field to classify');
+    } else {
+      requireDataField(lyr.data, dataField);
+    }
 
     if (numBuckets) {
       numValues = opts.continuous ? numBuckets + 1 : numBuckets;
@@ -28139,15 +28405,25 @@ ${svg}
 
     // get a function to convert input data to class indexes
     //
-    if (opts.index_field) {
+    if (opts.method == 'non-adjacent') {
+      classifyById = getNonAdjacentClassifier(lyr, dataset, classValues);
+    } else if (opts.index_field) {
       // data is pre-classified... just read the index from a field
-      classify = getIndexedClassifier(classValues, nullValue, opts);
+      classifyByValue = getIndexedClassifier(classValues, nullValue, opts);
     } else if (opts.categories) {
-      classify = getCategoricalClassifier(classValues, nullValue, opts);
+      classifyByValue = getCategoricalClassifier(classValues, nullValue, opts);
     } else {
-      classify = getSequentialClassifier(classValues, nullValue, getFieldValues(records, dataField), opts);
+      classifyByValue = getSequentialClassifier(classValues, nullValue, getFieldValues(records, dataField), opts);
+    }
+
+    if (classifyByValue) {
+      classifyById = function(id) {
+        var d = records[id] || {};
+        return classifyByValue(d[dataField]);
+      };
     }
 
+
     // get the name of the output field
     //
     if (looksLikeColors) {
@@ -28163,8 +28439,7 @@ ${svg}
     }
 
     records.forEach(function(d, i) {
-      d = d || {};
-      d[outputField] = classify(d[dataField]);
+      d[outputField] = classifyById(i);
     });
   };
 
@@ -28976,147 +29251,6 @@ ${svg}
     getClipMessage: getClipMessage
   });
 
-  // Returns a function for constructing a query function that accepts an arc id and
-  // returns information about the polygon or polygons that use the given arc.
-  // TODO: explain this better.
-  //
-  // options:
-  //   filter: optional filter function; signature: function(idA, idB or -1) : boolean
-  //   reusable: flag that lets an arc be queried multiple times.
-  function getArcClassifier(shapes, arcs) {
-    var opts = arguments[2] || {},
-        useOnce = !opts.reusable,
-        n = arcs.size(),
-        a = new Int32Array(n),
-        b = new Int32Array(n);
-
-    utils.initializeArray(a, -1);
-    utils.initializeArray(b, -1);
-
-    traversePaths(shapes, function(o) {
-      var i = absArcId(o.arcId);
-      var shpId = o.shapeId;
-      var aval = a[i];
-      if (aval == -1) {
-        a[i] = shpId;
-      } else if (shpId < aval) {
-        b[i] = aval;
-        a[i] = shpId;
-      } else {
-        b[i] = shpId;
-      }
-    });
-
-    function classify(arcId, getKey) {
-      var i = absArcId(arcId);
-      var shpA = a[i];
-      var shpB = b[i];
-      var key;
-      if (shpA == -1) return null;
-      key = getKey(shpA, shpB);
-      if (key === null || key === false) return null;
-      if (useOnce) {
-        // arc can only be queried once
-        a[i] = -1;
-        b[i] = -1;
-      }
-      // use optional filter to exclude some arcs
-      if (opts.filter && !opts.filter(shpA, shpB)) return null;
-      return key;
-    }
-
-    return function(getKey) {
-      return function(arcId) {
-        return classify(arcId, getKey);
-      };
-    };
-  }
-
-  var ArcClassifier = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    getArcClassifier: getArcClassifier
-  });
-
-  // Returns a function for querying the neighbors of a given shape. The function
-  // can be called in either of two ways:
-  //
-  // 1. function(shapeId, callback)
-  //    Callback signature: function(adjacentShapeId, arcId)
-  //    The callback function is called once for each arc that the given feature
-  //    shares with another feature.
-  //
-  // 2. function(shapeId)
-  //    The function returns an array of unique ids of neighboring shapes, or
-  //    an empty array if a shape has no neighbors.
-  //
-  function getNeighborLookupFunction(lyr, arcs) {
-    var classifier = getArcClassifier(lyr.shapes, arcs, {reusable: true});
-    var classify = classifier(onShapes);
-    var currShapeId;
-    var neighbors;
-    var callback;
-
-    function onShapes(a, b) {
-      if (b == -1) return -1; // outer edges are b == -1
-      return a == currShapeId ? b : a;
-    }
-
-    function onArc(arcId) {
-      var nabeId = classify(arcId);
-      if (nabeId == -1) return;
-      if (callback) {
-        callback(nabeId, arcId);
-      } else if (neighbors.indexOf(nabeId) == -1) {
-        neighbors.push(nabeId);
-      }
-    }
-
-    return function(shpId, cb) {
-      currShapeId = shpId;
-      if (cb) {
-        callback = cb;
-        forEachArcId(lyr.shapes[shpId], onArc);
-        callback = null;
-      } else {
-        neighbors = [];
-        forEachArcId(lyr.shapes[shpId], onArc);
-        return neighbors;
-      }
-    };
-  }
-
-
-  // Returns an array containing all pairs of adjacent shapes
-  // in a collection of polygon shapes. A pair of shapes is represented as
-  // an array of two shape indexes [a, b].
-  function findPairsOfNeighbors(shapes, arcs) {
-    var getKey = function(a, b) {
-      return b > -1 && a > -1 ? [a, b] : null;
-    };
-    var classify = getArcClassifier(shapes, arcs)(getKey);
-    var arr = [];
-    var index = {};
-    var onArc = function(arcId) {
-      var obj = classify(arcId);
-      var key;
-      if (obj) {
-        key = obj.join('~');
-        if (key in index === false) {
-          arr.push(obj);
-          index[key] = true;
-        }
-      }
-    };
-    forEachArcId(shapes, onArc);
-    return arr;
-  }
-
-  var PolygonNeighbors = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    getNeighborLookupFunction: getNeighborLookupFunction,
-    findPairsOfNeighbors: findPairsOfNeighbors
-  });
-
   // Assign a cluster id to each polygon in a dataset, which can be used with
   //   one of the dissolve commands to dissolve the clusters
   // Works by iteratively grouping pairs of polygons with the smallest distance
@@ -29803,12 +29937,19 @@ ${svg}
   });
 
   // Join data from @src table to records in @dest table
+  function joinTables(dest, src, join, opts) {
+    return joinTableToLayer({data: dest}, src, join, opts);
+  }
+
+  // Join data from @src table to records in @destLyr layer.
   // @join function
   //    Receives index of record in the dest table
   //    Returns array of matching records in src table, or null if no matches
   //
-  function joinTables(dest, src, join, opts) {
-    var srcRecords = src.getRecords(),
+  function joinTableToLayer(destLyr, src, join, opts) {
+    var dest = destLyr.data,
+        useDuplication = !!opts.duplication,
+        srcRecords = src.getRecords(),
         destRecords = dest.getRecords(),
         prefix = opts.prefix || '',
         unmatchedRecords = [],
@@ -29823,6 +29964,14 @@ ${svg}
         retn = {},
         srcRec, srcId, destRec, joins, count, filter, calc, i, j, n, m;
 
+    // support for duplication of destination records
+    var duplicateRecords, destShapes;
+    if (useDuplication) {
+      if (opts.calc) stop('duplication and calc options cannot be used together');
+      duplicateRecords = dest.clone().getRecords();
+      destShapes = destLyr.shapes || [];
+    }
+
     if (opts.where) {
       filter = getJoinFilter(src, opts.where);
     }
@@ -29832,7 +29981,8 @@ ${svg}
     }
 
     // join source records to target records
-    for (i=0, n=destRecords.length; i<n; i++) {
+    n = destRecords.length;
+    for (i=0; i<n; i++) {
       destRec = destRecords[i];
       joins = join(i);
       if (joins && filter) {
@@ -29843,7 +29993,13 @@ ${svg}
       for (j=0, count=0, m=joins ? joins.length : 0; j<m; j++) {
         srcId = joins[j];
         srcRec = srcRecords[srcId];
-        if (count === 0) {
+        // duplication mode: many-to-one joins add new features to the target layer.
+        if (count > 0 && useDuplication) {
+          destRec = copyRecord(duplicateRecords[i]);
+          destRecords.push(destRec);
+          destShapes.push(cloneShape(destShapes[i]));
+        }
+        if (count === 0 || useDuplication) {
           if (copyFields.length > 0) {
             // only copying the first match
             joinByCopy(destRec, srcRec, copyFields, prefix);
@@ -29875,7 +30031,7 @@ ${svg}
       }
     }
 
-    printJoinMessage(matchCount, destRecords.length,
+    printJoinMessage(matchCount, n,
         countJoins(joinCounts), srcRecords.length, skipCount, collisionCount, collisionFields);
 
     if (opts.unjoined) {
@@ -29903,6 +30059,7 @@ ${svg}
     });
   }
 
+
   function countJoins(counts) {
     var joinCount = 0;
     for (var i=0, n=counts.length; i<n; i++) {
@@ -29965,14 +30122,16 @@ ${svg}
 
   function printJoinMessage(matches, n, joins, m, skipped, collisions, collisionFields) {
     // TODO: add tip for troubleshooting join problems, if join is less than perfect.
+    var unmatched = n - matches;
     if (matches > 0 === false) {
       message("No records could be joined");
       return;
     }
     message(utils.format("Joined data from %'d source record%s to %'d target record%s",
         joins, utils.pluralSuffix(joins), matches, utils.pluralSuffix(matches)));
-    if (matches < n) {
-      message(utils.format('%d/%d target records received no data', n-matches, n));
+    if (unmatched > 0) {
+      message(utils.format('%d target record%s received no data', unmatched, utils.pluralSuffix(unmatched)));
+      // message(utils.format('%d target records received no data', n-matches));
     }
     if (joins < m) {
       message(utils.format("%d/%d source records could not be joined", m-joins, m));
@@ -30021,6 +30180,7 @@ ${svg}
   var JoinTables = /*#__PURE__*/Object.freeze({
     __proto__: null,
     joinTables: joinTables,
+    joinTableToLayer: joinTableToLayer,
     validateFieldNames: validateFieldNames,
     updateUnmatchedRecord: updateUnmatchedRecord,
     findCollisionFields: findCollisionFields,
@@ -31487,13 +31647,13 @@ ${svg}
     // TODO: option to copy points that can't be joined to a new layer
     var joinFunction = getPolygonToPointsFunction(targetLyr, arcs, pointLyr, opts);
     prepJoinLayers(targetLyr, pointLyr);
-    return joinTables(targetLyr.data, pointLyr.data, joinFunction, opts);
+    return joinTableToLayer(targetLyr, pointLyr.data, joinFunction, opts);
   }
 
   function joinPolygonsToPoints(targetLyr, polygonLyr, arcs, opts) {
     var joinFunction = getPointToPolygonsFunction(targetLyr, polygonLyr, arcs, opts);
     prepJoinLayers(targetLyr, polygonLyr);
-    return joinTables(targetLyr.data, polygonLyr.data, joinFunction, opts);
+    return joinTableToLayer(targetLyr, polygonLyr.data, joinFunction, opts);
   }
 
 
@@ -33279,6 +33439,12 @@ ${svg}
     };
   }
 
+  cmd.ignore = function(targetLayer, dataset, opts) {
+    if (opts.empty && layerIsEmpty(targetLayer)) {
+      interrupt('Layer is empty, stopping processing');
+    }
+  };
+
   cmd.include = function(opts) {
     var content, obj, context;
     // TODO: handle web context
@@ -33654,9 +33820,10 @@ ${svg}
 
     var joinOpts = utils.extend({}, opts);
     var joinFunction = getPolygonToPolygonFunction(targetLyr, sourceLyr, mosaicIndex, opts);
-    var retn = joinTables(targetLyr.data, sourceLyr.data, joinFunction, joinOpts);
+    var retn = joinTableToLayer(targetLyr, sourceLyr.data, joinFunction, joinOpts);
 
     if (opts.interpolate) {
+      if (opts.duplication) stop('duplication and interpolate options cannot be used together');
       interpolateFieldsByArea(targetLyr, sourceLyr, mosaicIndex, opts);
     }
     return retn;
@@ -34571,7 +34738,7 @@ ${svg}
   function joinPointsToPoints(targetLyr, srcLyr, crs, opts) {
     var joinFunction = getPointToPointFunction(targetLyr, srcLyr, crs, opts);
     prepJoinLayers(targetLyr, srcLyr);
-    return joinTables(targetLyr.data, srcLyr.data, joinFunction, opts);
+    return joinTableToLayer(targetLyr, srcLyr.data, joinFunction, opts);
   }
 
   function getPointToPointFunction(targetLyr, srcLyr, crs, opts) {
@@ -34621,14 +34788,14 @@ ${svg}
     }
   };
 
-  function joinAttributesToFeatures(lyr, srcTable, opts) {
+  function joinAttributesToFeatures(destLyr, srcTable, opts) {
     var keys = opts.keys,
         destKey = keys[0],
         srcKey = keys[1],
-        destTable = lyr.data,
+        destTable = destLyr.data,
         joinFunction = getJoinByKey(destTable, destKey, srcTable, srcKey);
     validateFieldNames(keys);
-    return joinTables(destTable, srcTable, joinFunction, opts);
+    return joinTableToLayer(destLyr, srcTable, joinFunction, opts);
   }
 
   // Return a function for translating a target id to an array of source ids based on values
@@ -37620,7 +37787,7 @@ ${svg}
         applyCommandToEachLayer(cmd.calc, targetLayers, arcs, opts);
 
       } else if (name == 'classify') {
-        applyCommandToEachLayer(cmd.classify, targetLayers, opts);
+        applyCommandToEachLayer(cmd.classify, targetLayers, targetDataset, opts);
 
       } else if (name == 'clean') {
         cmd.cleanLayers(targetLayers, targetDataset, opts);
@@ -37704,6 +37871,9 @@ ${svg}
           outputLayers = targetDataset.layers; // kludge to allow layer naming below
         }
 
+      } else if (name == 'ignore') {
+        applyCommandToEachLayer(cmd.ignore, targetLayers, targetDataset, opts);
+
       } else if (name == 'include') {
         cmd.include(opts);
 
@@ -38074,6 +38244,7 @@ ${svg}
         cmd.options.output = outputArr;
       }
     });
+
     runParsedCommands(commands, null, callback);
   }
 
@@ -38134,10 +38305,6 @@ ${svg}
       error("Changed in v0.4: runParsedCommands() takes a Catalog object");
     }
 
-    if (!utils.isFunction(done)) {
-      error("Missing a callback function");
-    }
-
     if (!utils.isArray(commands)) {
       error("Expected an array of parsed commands");
     }
@@ -38158,18 +38325,25 @@ ${svg}
       // that it can modify the output dataset in-place instead of making a copy.
       commands[commands.length-1].options.final = true;
     }
-    commands = divideImportCommand(commands);
-    utils.reduceAsync(commands, catalog, nextCommand, done);
 
-    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);
+    var groups = divideImportCommand(commands);
+    if (groups.length == 1) {
+      // run a simple sequence of commands (input files are not batched)
+      return runParsedCommands2(commands, catalog, done);
+    }
+
+    // run duplicated commands (i.e. batch mode)
+    utils.reduceAsync(groups, catalog, nextGroup, done);
+
+    function nextGroup(catalog, commands, next) {
+      runParsedCommands2(commands, catalog, function(err, catalog) {
+        err = filterError(err);
+        next(err, catalog);
+      });
     }
 
     function done(err, catalog) {
-      if (err) printError(err);
+      err = filterError(err);
       cb(err, catalog);
       setStateVar('current_command', null);
       setStateVar('verbose', false);
@@ -38177,11 +38351,31 @@ ${svg}
     }
   }
 
+  function filterError(err) {
+    if (err) printError(err);
+    if (err && err.name == 'NonFatalError') {
+      return null;
+    }
+    return err;
+  }
+
+  function runParsedCommands2(commands, catalog, cb) {
+    utils.reduceAsync(commands, catalog, 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);
+    }
+  }
+
+
   // If an initial import command indicates that several input files should be
   //   processed separately, then duplicate the sequence of commands to run
   //   once for each input file
   // @commands Array of parsed commands
-  // Returns: either original command array or array of duplicated commands.
+  // Returns: Array of one or more sequences of parsed commands
   //
   function divideImportCommand(commands) {
     var firstCmd = commands[0],
@@ -38189,23 +38383,23 @@ ${svg}
 
     if (firstCmd.name != 'i' || opts.stdin || opts.merge_files ||
       opts.combine_files || !opts.files || opts.files.length < 2) {
-      return commands;
+      return [commands];
     }
 
-    return (opts.files).reduce(function(memo, file) {
-      var importCmd = {
+    return opts.files.map(function(file) {
+      var group = [{
         name: 'i',
         options: utils.defaults({
           files:[file],
           replace: true  // kludge to replace data catalog
         }, opts)
-      };
-      memo.push(importCmd);
-      memo.push.apply(memo, commands.slice(1));
-      return memo;
-    }, []);
+      }];
+      group.push.apply(group, commands.slice(1));
+      return group;
+    });
   }
 
+
   function printStartupMessages() {
     // print heap memory message if running with a custom amount
     var rxp = /^--max-old-space-size=([0-9]+)$/;