mapshaper 0.6.43 → 0.6.45

package/mapshaper.js

@@ -1,6 +1,6 @@
 (function () {
 
-  var VERSION = "0.6.43";
+  var VERSION = "0.6.45";
 
 
   var utils = /*#__PURE__*/Object.freeze({
@@ -8,6 +8,7 @@
     get default () { return utils; },
     get getUniqueName () { return getUniqueName; },
     get isFunction () { return isFunction; },
+    get isPromise () { return isPromise; },
     get isObject () { return isObject; },
     get clamp () { return clamp; },
     get isArray () { return isArray; },
@@ -147,6 +148,10 @@
     return typeof obj == 'function';
   }
 
+  function isPromise(arg) {
+    return arg ? isFunction(arg.then) : false;
+  }
+
   function isObject(obj) {
     return obj === Object(obj); // via underscore
   }
@@ -1877,12 +1882,67 @@
     arcs.updateVertexData(nn, xx2, yy2, zz2);
   }
 
+  function countFilteredVertices(zz, zlimit) {
+    var count = 0;
+    for (var i=0, n = zz.length; i<n; i++) {
+      if (zz[i] >= zlimit) count++;
+    }
+    return count;
+  }
+
+  function filterVertexData(o, zlimit) {
+    if (!o.zz) error('Expected simplification data');
+    var xx = o.xx,
+        yy = o.yy,
+        zz = o.zz,
+        len2 = countFilteredVertices(zz, zlimit),
+        arcCount = o.nn.length,
+        xx2 = new Float64Array(len2),
+        yy2 = new Float64Array(len2),
+        zz2 = new Float64Array(len2),
+        nn2 = new Int32Array(arcCount),
+        i = 0, i2 = 0,
+        n, n2;
+
+    for (var arcId=0; arcId < arcCount; arcId++) {
+      n2 = 0;
+      n = o.nn[arcId];
+      for (var end = i+n; i < end; i++) {
+        if (zz[i] >= zlimit) {
+          xx2[i2] = xx[i];
+          yy2[i2] = yy[i];
+          zz2[i2] = zz[i];
+          i2++;
+          n2++;
+        }
+      }
+      if (n2 == 1) {
+        error("Collapsed arc");
+        // This should not happen (endpoints should be z == Infinity)
+        // Could handle like this, instead of throwing an error:
+        // n2 = 0;
+        // xx2.pop();
+        // yy2.pop();
+        // zz2.pop();
+      }
+      nn2[arcId] = n2;
+    }
+    return {
+      xx: xx2,
+      yy: yy2,
+      zz: zz2,
+      nn: nn2
+    };
+  }
+
   var ArcUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
     absArcId: absArcId,
     calcArcBounds: calcArcBounds,
     deleteVertex: deleteVertex,
-    insertVertex: insertVertex
+    insertVertex: insertVertex,
+    countFilteredVertices: countFilteredVertices,
+    filterVertexData: filterVertexData
   });
 
   var WGS84 = {
@@ -5354,17 +5414,6 @@
       initZData(zz || null);
     };
 
-    // Give access to raw data arrays...
-    this.getVertexData = function() {
-      return {
-        xx: _xx,
-        yy: _yy,
-        zz: _zz,
-        bb: _bb,
-        nn: _nn,
-        ii: _ii
-      };
-    };
 
     this.getCopy = function() {
       var copy = new ArcCollection(new Int32Array(_nn), new Float64Array(_xx),
@@ -5376,55 +5425,28 @@
       return copy;
     };
 
+
+    // Give access to raw data arrays...
+    this.getVertexData = getVertexData;
+
+    function getVertexData() {
+      return {
+        xx: _xx,
+        yy: _yy,
+        zz: _zz,
+        bb: _bb,
+        nn: _nn,
+        ii: _ii
+      };
+    }
+
     function getFilteredPointCount() {
-      var zz = _zz, z = _zlimit;
-      if (!zz || !z) return this.getPointCount();
-      var count = 0;
-      for (var i=0, n = zz.length; i<n; i++) {
-        if (zz[i] >= z) count++;
-      }
-      return count;
+      if (!_zz || !_zlimit) return this.getPointCount();
+      return countFilteredVertices(_zz, _zlimit);
     }
 
     function getFilteredVertexData() {
-      var len2 = getFilteredPointCount();
-      var arcCount = _nn.length;
-      var xx2 = new Float64Array(len2),
-          yy2 = new Float64Array(len2),
-          zz2 = new Float64Array(len2),
-          nn2 = new Int32Array(arcCount),
-          i=0, i2 = 0,
-          n, n2;
-
-      for (var arcId=0; arcId < arcCount; arcId++) {
-        n2 = 0;
-        n = _nn[arcId];
-        for (var end = i+n; i < end; i++) {
-          if (_zz[i] >= _zlimit) {
-            xx2[i2] = _xx[i];
-            yy2[i2] = _yy[i];
-            zz2[i2] = _zz[i];
-            i2++;
-            n2++;
-          }
-        }
-        if (n2 == 1) {
-          error("Collapsed arc");
-          // This should not happen (endpoints should be z == Infinity)
-          // Could handle like this, instead of throwing an error:
-          // n2 = 0;
-          // xx2.pop();
-          // yy2.pop();
-          // zz2.pop();
-        }
-        nn2[arcId] = n2;
-      }
-      return {
-        xx: xx2,
-        yy: yy2,
-        zz: zz2,
-        nn: nn2
-      };
+      return filterVertexData(getVertexData(), _zlimit);
     }
 
     this.getFilteredCopy = function() {
@@ -10823,28 +10845,59 @@
   }
 
   // gui: (optional) gui instance
-  //
+  // opts examples:
+  //    exporting from command line: { compact: true, file: 'tmp.msx', final: true }
+  //    exporting from gui export menu: {compact: true, format: 'msx'}
+  //    saving gui temp snapshot: {compact: false}
   async function exportDatasetsToPack(datasets, opts) {
     var obj = {
       version: 1,
       created: (new Date).toISOString(),
-      datasets: await Promise.all(datasets.map(exportDataset))
+      datasets: await Promise.all(datasets.map(dataset => exportDataset(dataset, opts)))
     };
-    if (opts.compact) {
-      await applyCompression(obj);
-    }
     return obj;
   }
 
-  async function applyCompression(obj, opts) {
-    var promises = [];
-    obj.datasets.forEach(d => {
-      if (d.arcs) promises.push(compressArcs(d.arcs, opts));
+  async function exportDataset(dataset, opts) {
+    var arcs = dataset.arcs;
+    var arcData = null;
+    if (arcs) {
+      arcData = arcs.getVertexData();
+      arcData.zlimit = arcs.getRetainedInterval(); // TODO: add this to getVertexData()
+      arcData = await exportArcData(arcData, opts);
+    }
+    return {
+      arcs: arcData,
+      info: dataset.info ? exportInfo(dataset.info) : null,
+      layers: await Promise.all((dataset.layers || []).map(exportLayer))
+    };
+  }
+
+  // compress unpacked + uncompressed snapshot data in-place
+  async function compressSnapshotForExport(obj) {
+    var promises = obj.datasets.map(d => {
+      compressDatasetForExport(d);
     });
     await Promise.all(promises);
+    return;
   }
 
-  async function compressArcs(obj, opts) {
+  async function compressDatasetForExport(obj) {
+    if (!obj.arcs) return;
+    var arcData = importArcData(obj.arcs); // convert buffers to typed arrays
+    obj.arcs = await exportArcData(arcData, {compact: true}); // re-export to compressed buffers
+  }
+
+  function flattenArcs(arcData) {
+    if (arcData.zz && arcData.zlimit) {
+      // replace unfiltered arc data with flattened arc data
+      arcData = filterVertexData(arcData, arcData.zlimit);
+      delete arcData.zz;
+    }
+    return arcData;
+  }
+
+  async function gzipArcData(obj, opts) {
     var gzipOpts = Object.assign({level: 1, consume: false}, opts);
     var promises = [gzipAsync(obj.nn, gzipOpts), gzipAsync(obj.xx, gzipOpts), gzipAsync(obj.yy, gzipOpts)];
     if (obj.zz) promises.push(gzipAsync(obj.zz, gzipOpts));
@@ -10855,27 +10908,36 @@
     if (obj.zz) obj.zz = results.shift();
   }
 
-  async function exportDataset(dataset, opts) {
+  function importArcData(obj) {
     return {
-      arcs: dataset.arcs ? exportArcs(dataset.arcs) : null,
-      info: dataset.info ? exportInfo(dataset.info) : null,
-      layers: await Promise.all((dataset.layers || []).map(exportLayer))
+      nn: new Uint32Array(obj.nn.buffer, 0, obj.nn.length / 4),
+      xx: new Float64Array(obj.xx.buffer, 0, obj.xx.length / 8),
+      yy: new Float64Array(obj.yy.buffer, 0, obj.yy.length / 8),
+      zz: obj.zz ? new Float64Array(obj.zz.buffer, 0, obj.zz.length / 8) : null,
+      zlimit: obj.zlimit || 0
     };
   }
 
-  function typedArrayToBuffer(arr) {
-    return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
-  }
-
-  function exportArcs(arcs) {
-    var data = arcs.getVertexData();
-    return {
+  async function exportArcData(data, opts) {
+    // TODO: consider removing arcs that are not referenced by any layer
+    if (opts.compact && data.zz) {
+      data = flattenArcs(data); // bake in any simplification
+    }
+    var output = {
       nn: typedArrayToBuffer(data.nn),
       xx: typedArrayToBuffer(data.xx),
       yy: typedArrayToBuffer(data.yy),
       zz: data.zz ? typedArrayToBuffer(data.zz) : null,
-      zlimit: arcs.getRetainedInterval()
+      zlimit: data.zlimit || 0
     };
+    if (opts.compact && data.zz) {
+      await gzipArcData(output);
+    }
+    return output;
+  }
+
+  function typedArrayToBuffer(arr) {
+    return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
   }
 
   async function exportLayer(lyr) {
@@ -10909,8 +10971,8 @@
     exportPackedDatasets: exportPackedDatasets,
     pack: pack,
     exportDatasetsToPack: exportDatasetsToPack,
-    applyCompression: applyCompression,
     exportDataset: exportDataset,
+    compressSnapshotForExport: compressSnapshotForExport,
     exportInfo: exportInfo
   });
 
@@ -12488,7 +12550,6 @@
     return +n.toPrecision(d);
   }
 
-
   function roundToDigits(n, d) {
     return +n.toFixed(d); // string conversion makes this slow
   }
@@ -12552,6 +12613,37 @@
     });
   }
 
+  const fround2 = (function() {
+    var arr = new Float32Array(1);
+    return function(x) {
+      arr[0] = x;
+      return arr[0];
+    };
+  })();
+
+  // This function rounds towards 0 (i.e. floor). TODO: round properly
+  // @bits: number of bits to round
+  // performance: about 3x slower than Math.fround()
+  function getBinaryRoundingFunction(bits) {
+    // double: sign (1) exponent (11) fraction (52)
+    // single: sign (1) exponent (8) fraction (23)
+    if ((bits >= 1 && bits <= 32) === false) {
+      error('Invalid bits argument:', bits);
+    }
+    var isLE = require('os').endianness() == 'LE';
+    var fp = new Float64Array(1);
+    var leastBits = new Uint32Array(fp.buffer, isLE ? 0 : 4, 1);
+    var mask = 2 ** 32 - 2 ** bits;  // e.g. bits = 4 -> 0b11110000
+    return function(x) {
+      fp[0] = x;
+      leastBits[0] = leastBits[0] & mask;
+      return fp[0];
+    };
+  }
+
+  // "round to even" on the 23rd bit of the mantissa
+  const fround = Math.fround || fround2;
+
   function setCoordinatePrecision(dataset, precision) {
     var round = getRoundingFunction(precision);
     // var dissolvePolygon, nodes;
@@ -12586,6 +12678,9 @@
     getRoundedCoordString: getRoundedCoordString,
     getRoundedCoords: getRoundedCoords,
     roundPoints: roundPoints,
+    fround2: fround2,
+    getBinaryRoundingFunction: getBinaryRoundingFunction,
+    fround: fround,
     setCoordinatePrecision: setCoordinatePrecision
   });
 
@@ -15914,6 +16009,67 @@
     formatIntersectingSegment: formatIntersectingSegment
   });
 
+  // Remap any references to duplicate arcs in paths to use the same arcs
+  // Remove any unused arcs from the dataset's ArcCollection.
+  // Return a NodeCollection
+  function cleanArcReferences(dataset) {
+    var nodes = new NodeCollection(dataset.arcs);
+    var map = findDuplicateArcs(nodes);
+    var dropCount;
+    if (map) {
+      replaceIndexedArcIds(dataset, map);
+    }
+    dropCount = deleteUnusedArcs(dataset);
+    if (dropCount > 0) {
+      // rebuild nodes if arcs have changed
+      nodes = new NodeCollection(dataset.arcs);
+    }
+    return nodes;
+  }
+
+  function deleteUnusedArcs(dataset) {
+    var test = getArcPresenceTest2(dataset.layers, dataset.arcs);
+    var count1 = dataset.arcs.size();
+    var map = dataset.arcs.deleteArcs(test); // condenses arcs
+    var count2 = dataset.arcs.size();
+    var deleteCount = count1 - count2;
+    if (deleteCount > 0) {
+      replaceIndexedArcIds(dataset, map);
+    }
+    return deleteCount;
+  }
+
+  // @map an Object mapping old to new ids
+  function replaceIndexedArcIds(dataset, map) {
+    var remapPath = function(ids) {
+      var arcId, absId, id2;
+      for (var i=0; i<ids.length; i++) {
+        arcId = ids[i];
+        absId = absArcId(arcId);
+        id2 = map[absId];
+        ids[i] = arcId == absId ? id2 : ~id2;
+      }
+      return ids;
+    };
+    dataset.layers.forEach(function(lyr) {
+      if (layerHasPaths(lyr)) {
+        editShapes(lyr.shapes, remapPath);
+      }
+    });
+  }
+
+  function findDuplicateArcs(nodes) {
+    var map = new Int32Array(nodes.arcs.size()),
+        count = 0,
+        i2;
+    for (var i=0, n=nodes.arcs.size(); i<n; i++) {
+      i2 = nodes.findDuplicateArc(i);
+      map[i] = i2;
+      if (i != i2) count++;
+    }
+    return count > 0 ? map : null;
+  }
+
   // Functions for dividing polygons and polygons at points where arc-segments intersect
 
   // TODO:
@@ -16003,68 +16159,6 @@
   }
 
 
-  // Remap any references to duplicate arcs in paths to use the same arcs
-  // Remove any unused arcs from the dataset's ArcCollection.
-  // Return a NodeCollection
-  function cleanArcReferences(dataset) {
-    var nodes = new NodeCollection(dataset.arcs);
-    var map = findDuplicateArcs(nodes);
-    var dropCount;
-    if (map) {
-      replaceIndexedArcIds(dataset, map);
-    }
-    dropCount = deleteUnusedArcs(dataset);
-    if (dropCount > 0) {
-      // rebuild nodes if arcs have changed
-      nodes = new NodeCollection(dataset.arcs);
-    }
-    return nodes;
-  }
-
-
-  // @map an Object mapping old to new ids
-  function replaceIndexedArcIds(dataset, map) {
-    var remapPath = function(ids) {
-      var arcId, absId, id2;
-      for (var i=0; i<ids.length; i++) {
-        arcId = ids[i];
-        absId = absArcId(arcId);
-        id2 = map[absId];
-        ids[i] = arcId == absId ? id2 : ~id2;
-      }
-      return ids;
-    };
-    dataset.layers.forEach(function(lyr) {
-      if (layerHasPaths(lyr)) {
-        editShapes(lyr.shapes, remapPath);
-      }
-    });
-  }
-
-  function findDuplicateArcs(nodes) {
-    var map = new Int32Array(nodes.arcs.size()),
-        count = 0,
-        i2;
-    for (var i=0, n=nodes.arcs.size(); i<n; i++) {
-      i2 = nodes.findDuplicateArc(i);
-      map[i] = i2;
-      if (i != i2) count++;
-    }
-    return count > 0 ? map : null;
-  }
-
-  function deleteUnusedArcs(dataset) {
-    var test = getArcPresenceTest2(dataset.layers, dataset.arcs);
-    var count1 = dataset.arcs.size();
-    var map = dataset.arcs.deleteArcs(test); // condenses arcs
-    var count2 = dataset.arcs.size();
-    var deleteCount = count1 - count2;
-    if (deleteCount > 0) {
-      replaceIndexedArcIds(dataset, map);
-    }
-    return deleteCount;
-  }
-
   // Return a function for updating a path (array of arc ids)
   // @map array generated by insertCutPoints()
   // @arcCount number of arcs in divided collection (kludge)
@@ -16458,7 +16552,8 @@
       if (id >= 0 && id < n) {
         return index[id] - 1;
       } else {
-        error('Invalid index');
+        return -1;
+        // error('Invalid index');
       }
     };
   }
@@ -17419,8 +17514,9 @@
           exporter = GeoJSON.exporters[lyr.geometry_type],
           geom = shape ? exporter(shape, dataset.arcs, opts) : null,
           obj = null;
+
       if (asFeatures) {
-        obj = GeoJSON.toFeature(geom, properties ? properties[i] : null);
+        obj = composeFeature(geom, properties ? properties[i] : null, opts);
         if (ids) {
           obj.id = ids[i];
         }
@@ -17444,6 +17540,20 @@
     }, []);
   }
 
+  function composeFeature(geom, properties, opts) {
+    var feat = GeoJSON.toFeature(geom, properties);
+    if (Array.isArray(opts.hoist) && properties) {
+      // don't modify properties of source feature
+      feat.properties = Object.assign({}, properties);
+      opts.hoist.forEach(field => {
+        if (properties.hasOwnProperty(field)) {
+          feat[field] = properties[field];
+          delete feat.properties[field];
+        }
+      });
+    }
+    return feat;
+  }
 
   function getRFC7946Warnings(dataset) {
     var P = getDatasetCRS(dataset);
@@ -18412,7 +18522,8 @@
   // null values indicate the lack of a function for parsing/identifying this property
   // (in which case a heuristic is used for distinguishing a string literal from an expression)
   var stylePropertyTypes = {
-    css: null,
+    // css: null,
+    css: 'inlinecss',
     class: 'classname',
     dx: 'measure',
     dy: 'measure',
@@ -18599,6 +18710,8 @@
       val = isPattern(strVal) ? strVal : null;
     } else if (type == 'boolean') {
       val = parseBoolean(strVal);
+    } else if (type == 'inlinecss') {
+      val = strVal; // TODO: validate
     }
     //  else {
     //   // unknown type -- assume literal value
@@ -21534,6 +21647,14 @@ ${svg}
       }
       return memo.concat(exportFileContent(dataset, opts));
     }, []);
+
+    if (opts.bbox_index) {
+      // If rounding or quantization are applied during export, bounds may
+      // change somewhat... consider adding a bounds property to each layer during
+      // export when appropriate.
+      files.push(createIndexFile(datasets));
+    }
+
     // need unique names for multiple output files
     assignUniqueFileNames(files);
 
@@ -21591,15 +21712,7 @@ ${svg}
     }
 
     validateLayerData(dataset.layers);
-
     files = exporter(dataset, opts).concat(files);
-    // If rounding or quantization are applied during export, bounds may
-    // change somewhat... consider adding a bounds property to each layer during
-    // export when appropriate.
-    if (opts.bbox_index) {
-      files.push(createIndexFile(dataset));
-    }
-
     validateFileNames(files);
     return files;
   }
@@ -21620,13 +21733,16 @@ ${svg}
   // Generate json file with bounding boxes and names of each export layer
   // TODO: consider making this a command, or at least make format settable
   //
-  function createIndexFile(dataset) {
-    var index = dataset.layers.map(function(lyr) {
-      var bounds = getLayerBounds(lyr, dataset.arcs);
-      return {
-        bbox: bounds.toArray(),
-        name: lyr.name
-      };
+  function createIndexFile(datasets) {
+    var index = [];
+    datasets.forEach(function(dataset) {
+      dataset.layers.forEach(function(lyr) {
+        var bounds = getLayerBounds(lyr, dataset.arcs);
+        index.push({
+          bbox: bounds.toArray(),
+          name: lyr.name
+        });
+      });
     });
 
     return {
@@ -23349,7 +23465,7 @@ ${svg}
       .option('string-fields', stringFieldsOpt)
       .option('field-types', fieldTypesOpt)
       .option('name', {
-        describe: 'Rename the imported layer(s)'
+        describe: 'rename the imported layer(s)'
       })
       .option('geometry-type', {
         // undocumented; GeoJSON import rejects all but one kind of geometry
@@ -23518,6 +23634,10 @@ ${svg}
         describe: '[GeoJSON/JSON] output newline-delimited features or records',
         type: 'flag'
       })
+      .option('hoist', {
+        describe: '[GeoJSON] move properties to the root level of each Feature',
+        type: 'strings'
+      })
       .option('width', {
         describe: '[SVG/TopoJSON] pixel width of output (SVG default is 800)',
         type: 'number'
@@ -24696,9 +24816,9 @@ ${svg}
       .option('class', {
         describe: 'name of CSS class or classes (space-separated)'
       })
-      // .option('css', {
-      //   describe: 'inline css style'
-      // })
+      .option('css', {
+        describe: 'inline css style'
+      })
       .option('fill', {
         describe: 'fill color; examples: #eee pink rgba(0, 0, 0, 0.2)'
       })
@@ -33468,7 +33588,6 @@ ${svg}
       stop('Missing a data field to classify');
     }
 
-
     // get the number of classes and the number of values
     //
     // expand categories if value is '*'
@@ -41274,21 +41393,24 @@ ${svg}
     parseConsoleCommands: parseConsoleCommands
   });
 
-  cmd.run = function(job, targets, opts, cb) {
+  cmd.run = async function(job, targets, opts) {
     var commandStr, commands;
     if (!opts.expression) {
       stop("Missing expression parameter");
     }
     commandStr = runGlobalExpression(opts.expression, targets);
+    // Support async functions as expressions
+    if (utils.isPromise(commandStr)) {
+      commandStr = await commandStr;
+    }
     if (commandStr) {
       message(`command: [${commandStr}]`);
       commands = parseCommands(commandStr);
-      runParsedCommands(commands, job, cb);
-    } else {
-      cb(null);
+      await utils.promisify(runParsedCommands)(commands, job);
     }
   };
 
+  // This could return a Promise or a value or nothing
   function runGlobalExpression(expression, targets) {
     var ctx = getBaseContext();
     var output, targetData;
@@ -42415,6 +42537,7 @@ ${svg}
         shapes = lyr0.shapes,
         index = {},
         splitLayers = [],
+        n = getFeatureCount(lyr0),
         namer;
 
     if (opts.ids) {
@@ -42423,11 +42546,18 @@ ${svg}
       namer = getSplitNameFunction(lyr0, expression);
     }
 
+    // // halt if split field is missing
     // if (splitField) {
     //   internal.requireDataField(lyr0, splitField);
     // }
 
-    utils.repeat(getFeatureCount(lyr0), function(i) {
+    // if input layer is empty, return original layer
+    // TODO: consider halting
+    if (n === 0) {
+      return [lyr0];
+    }
+
+    utils.repeat(n, function(i) {
       var name = namer(i),
           lyr;
 
@@ -42450,6 +42580,7 @@ ${svg}
         lyr.data.getRecords().push(properties[i]);
       }
     });
+
     return splitLayers;
   };
 
@@ -42460,26 +42591,34 @@ ${svg}
     };
   }
 
-  function getDefaultSplitFunction(lyr) {
-    // if not splitting on an expression and layer is unnamed, name split-apart layers
-    // like: split-1, split-2, ...
-    return function(i) {
-      return (lyr && lyr.name || 'split') + '-' + (i + 1);
-    };
-  }
-
-  function getSplitNameFunction(lyr, exp) {
+  function getSplitNameFunction(lyr, arg) {
     var compiled;
-    if (!exp) return getDefaultSplitFunction(lyr);
+    if (!arg) {
+      // if not splitting on an expression and layer is unnamed, name split-apart layers
+      // like: split-1, split-2, ...
+      return function(i) {
+        return (lyr && lyr.name || 'split') + '-' + (i + 1);
+      };
+    }
+    if (lyr.data && lyr.data.fieldExists(arg)) {
+      // Argument is a field name
+      return function(i) {
+        var rec = lyr.data.getRecords()[i];
+        return rec ? valueToLayerName(rec[arg]) : '';
+      };
+    }
+    // Assume: argument is an expression
     lyr = {name: lyr.name, data: lyr.data}; // remove shape info
-    compiled = compileValueExpression(exp, lyr, null);
+    compiled = compileValueExpression(arg, lyr, null);
     return function(i) {
       var val = compiled(i);
-      return String(val);
-      // return val || val === 0 ? String(val) : '';
+      return valueToLayerName(val);
     };
   }
 
+  function valueToLayerName(val) {
+    return String(val);
+  }
 
   // internal.getSplitKey = function(i, field, properties) {
   //   var rec = field && properties ? properties[i] : null;
@@ -42515,6 +42654,9 @@ ${svg}
 
   cmd.svgStyle = function(lyr, dataset, opts) {
     var filter;
+    if (getFeatureCount(lyr) === 0) {
+      return;
+    }
     if (!lyr.data) {
       initDataTable(lyr);
     }
@@ -43820,7 +43962,7 @@ ${svg}
         });
 
       } else if (name == 'run') {
-        await utils.promisify(cmd.run)(job, targets, opts);
+        await cmd.run(job, targets, opts);
 
       } else if (name == 'scalebar') {
         cmd.scalebar(job.catalog, opts);
@@ -43843,7 +43985,7 @@ ${svg}
 
       } else if (name == 'snap') {
         // cmd.snap(targetDataset, opts);
-        applyCommandToEachTarget(targets, opts);
+        applyCommandToEachTarget(cmd.snap, targets, opts);
 
       } else if (name == 'sort') {
         applyCommandToEachLayer(cmd.sortFeatures, targetLayers, arcs, opts);
@@ -44097,6 +44239,13 @@ ${svg}
       }
     });
 
+    var lastCmd = commands[commands.length - 1];
+    if (!runningInBrowser() && lastCmd.name == 'o') {
+      // in CLI, set 'final' flag on final -o command, so the export function knows
+      // that it can modify the output dataset in-place instead of making a copy.
+      lastCmd.options.final = true;
+    }
+
     var batches = divideImportCommand(commands);
     utils.reduceAsync(batches, null, nextGroup, done);
 
@@ -44165,11 +44314,6 @@ ${svg}
   // @done: function([error], [job])
   //
   function runParsedCommands(commands, job, done) {
-    if (!runningInBrowser() && commands[commands.length-1].name == 'o') {
-      // in CLI, set 'final' flag on final -o command, so the export function knows
-      // that it can modify the output dataset in-place instead of making a copy.
-      commands[commands.length-1].options.final = true;
-    }
     if (!job) job = new Job();
     commands = readAndRemoveSettings(job, commands);
     if (!runningInBrowser()) {