mapshaper 0.6.23 → 0.6.25

package/www/mapshaper.js

@@ -1,6 +1,6 @@
 (function () {
 
-  var VERSION = "0.6.23";
+  var VERSION = "0.6.25";
 
 
   var utils = /*#__PURE__*/Object.freeze({
@@ -2449,6 +2449,17 @@
     getPathCentroid: getPathCentroid
   });
 
+  function testSegmentBoundsIntersection(a, b, bb) {
+    if (bb.containsPoint(a[0], a[1])) {
+      return true;
+    }
+    return !!(
+      geom.segmentIntersection(a[0], a[1], b[0], b[1], bb.xmin, bb.ymin, bb.xmin, bb.ymax) ||
+      geom.segmentIntersection(a[0], a[1], b[0], b[1], bb.xmin, bb.ymax, bb.xmax, bb.ymax) ||
+      geom.segmentIntersection(a[0], a[1], b[0], b[1], bb.xmax, bb.ymax, bb.xmax, bb.ymin) ||
+      geom.segmentIntersection(a[0], a[1], b[0], b[1], bb.xmax, bb.ymin, bb.xmin, bb.ymin));
+  }
+
   // A compactness measure designed for testing electoral districts for gerrymandering.
   // Returns value in [0-1] range. 1 = perfect circle, 0 = collapsed polygon
   function calcPolsbyPopperCompactness(area, perimeter) {
@@ -2496,21 +2507,32 @@
   //   }, 0);
   // }
 
+  // test if a rectangle is completely enclosed in a planar polygon
+  function testBoundsInPolygon(bounds, shp, arcs) {
+    if (!shp || !testPointInPolygon(bounds.xmin, bounds.ymin, shp, arcs)) return false;
+    var isIn = true;
+    shp.forEach(function(ids) {
+      forEachSegmentInPath(ids, arcs, function(a, b, xx, yy) {
+        isIn = isIn && !testSegmentBoundsIntersection([xx[a], yy[a]], [xx[b], yy[b]], bounds);
+      });
+    });
+    return isIn;
+  }
+
   // Return true if point is inside or on boundary of a shape
   //
   function testPointInPolygon(x, y, shp, arcs) {
     var isIn = false,
         isOn = false;
-    if (shp) {
-      shp.forEach(function(ids) {
-        var inRing = testPointInRing(x, y, ids, arcs);
-        if (inRing == 1) {
-          isIn = !isIn;
-        } else if (inRing == -1) {
-          isOn = true;
-        }
-      });
-    }
+    if (!shp) return false;
+    shp.forEach(function(ids) {
+      var inRing = testPointInRing(x, y, ids, arcs);
+      if (inRing == 1) {
+        isIn = !isIn;
+      } else if (inRing == -1) {
+        isOn = true;
+      }
+    });
     return isOn || isIn;
   }
 
@@ -2518,6 +2540,8 @@
     return ay + (x - ax) * (by - ay) / (bx - ax);
   }
 
+
+
   // Test if point (x, y) is inside, outside or on the boundary of a polygon ring
   // Return 0: outside; 1: inside; -1: on boundary
   //
@@ -2708,6 +2732,7 @@
     getShapeArea: getShapeArea,
     getPlanarShapeArea: getPlanarShapeArea,
     getSphericalShapeArea: getSphericalShapeArea,
+    testBoundsInPolygon: testBoundsInPolygon,
     testPointInPolygon: testPointInPolygon,
     testPointInRing: testPointInRing,
     testRayIntersection: testRayIntersection,
@@ -7251,7 +7276,7 @@
   			let size = source.length;
   			let value = this ? this.unpack(source, size) : defaultUnpackr.unpack(source, size);
   			if (forEach) {
-  				forEach(value);
+  				if (forEach(value) === false) return;
   				while(position$1 < size) {
   					lastPosition = position$1;
   					if (forEach(checkedRead()) === false) {
@@ -8193,7 +8218,7 @@
   let safeEnd;
   let bundledStrings = null;
   let writeStructSlots;
-  const MAX_BUNDLE_SIZE = 0xf000;
+  const MAX_BUNDLE_SIZE = 0x5500; // maximum characters such that the encoded bytes fits in 16 bits.
   const hasNonLatin = /[\u0080-\uFFFF]/;
   const RECORD_SYMBOL = Symbol('record-id');
   class Packr extends Unpackr {
@@ -8222,7 +8247,7 @@
   		if (maxSharedStructures > 8160)
   			throw new Error('Maximum maxSharedStructure is 8160')
   		if (options.structuredClone && options.moreTypes == undefined) {
-  			options.moreTypes = true;
+  			this.moreTypes = true;
   		}
   		let maxOwnStructures = options.maxOwnStructures;
   		if (maxOwnStructures == null)
@@ -8917,12 +8942,11 @@
   				if (notifySharedUpdate)
   					return hasSharedUpdate = true;
   				position = newPosition;
-  				if (start > 0) {
-  					pack(value);
-  					if (start == 0)
-  						return { position, targetView, target }; // indicate the buffer was re-allocated
-  				} else
-  					pack(value);
+  				let startTarget = target;
+  				pack(value);
+  				if (startTarget !== target) {
+  					return { position, targetView, target }; // indicate the buffer was re-allocated
+  				}
   				return position;
   			}, this);
   			if (newPosition === 0) // bail and go to a msgpack object
@@ -10620,7 +10644,8 @@
       buf = new Uint8Array(buf);
     }
     opts = opts || {};
-    var out = await utils.promisify(gunzip)(buf, opts);
+    var gunzip$1 = runningInBrowser() ? utils.promisify(gunzip) : utils.promisify(require('zlib').gunzip);
+    var out = await gunzip$1(buf, opts);
     if (opts.filename && !isImportableAsBinary(opts.filename)) {
       out = strFromU8(out);
     }
@@ -10628,8 +10653,6 @@
   }
 
   function gunzipSync(buf, filename) {
-    // TODO: use native module in Node
-    // require('zlib').
     if (buf instanceof ArrayBuffer) {
       buf = new Uint8Array(buf);
     }
@@ -10768,16 +10791,39 @@
   // gui: (optional) gui instance
   //
   async function exportDatasetsToPack(datasets, opts) {
-    return {
+    var obj = {
       version: 1,
       created: (new Date).toISOString(),
-      datasets: await Promise.all(datasets.map(d => exportDataset(d, opts || {})))
+      datasets: await Promise.all(datasets.map(exportDataset))
     };
+    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));
+    });
+    await Promise.all(promises);
+  }
+
+  async function compressArcs(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));
+    var results = await Promise.all(promises);
+    obj.nn = results.shift();
+    obj.xx = results.shift();
+    obj.yy = results.shift();
+    if (obj.zz) obj.zz = results.shift();
   }
 
   async function exportDataset(dataset, opts) {
     return {
-      arcs: dataset.arcs ? await exportArcs(dataset.arcs, opts) : null,
+      arcs: dataset.arcs ? exportArcs(dataset.arcs) : null,
       info: dataset.info ? exportInfo(dataset.info) : null,
       layers: await Promise.all((dataset.layers || []).map(exportLayer))
     };
@@ -10787,38 +10833,22 @@
     return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
   }
 
-  async function exportArcs(arcs, opts) {
+  function exportArcs(arcs) {
     var data = arcs.getVertexData();
-    var obj = {
+    return {
       nn: typedArrayToBuffer(data.nn),
       xx: typedArrayToBuffer(data.xx),
       yy: typedArrayToBuffer(data.yy),
       zz: data.zz ? typedArrayToBuffer(data.zz) : null,
       zlimit: arcs.getRetainedInterval()
     };
-
-    // gzipping typically sees about 70% compression on unrounded coordinates
-    // -- possibly not worth the time
-    if (opts.compact) {
-      var gzipOpts = {level: 1, consume: false};
-      var promises = [gzipAsync(obj.nn, gzipOpts), gzipAsync(obj.xx, gzipOpts), gzipAsync(obj.yy, gzipOpts)];
-      if (obj.zz) promises.push(gzipAsync(obj.zz, gzipOpts));
-      var results = await Promise.all(promises);
-      obj.nn = results.shift();
-      obj.xx = results.shift();
-      obj.yy = results.shift();
-      if (obj.zz) obj.zz = results.shift();
-    }
-    return obj;
   }
 
   async function exportLayer(lyr) {
-    // console.time('table')
     var data = null;
     if (lyr.data) {
       data = await exportTable2(lyr.data);
     }
-    // console.timeEnd('table')
     return {
       name: lyr.name || null,
       geometry_type: lyr.geometry_type || null,
@@ -10845,6 +10875,7 @@
     exportPackedDatasets: exportPackedDatasets,
     pack: pack,
     exportDatasetsToPack: exportDatasetsToPack,
+    applyCompression: applyCompression,
     exportDataset: exportDataset
   });
 
@@ -13722,6 +13753,11 @@
         return rect.contains(bbox);
       };
 
+      // TODO
+      // ctx.intersectsRectangle = function(a, b, c, d) {}; // paths... points too?
+      // ctx.containsPoint = function(x, y) {}; // polygon only
+      // ctx.containedByRectangle(a, b, c, d); // paths and points... how do multipart points work?
+
       addGetters(ctx, {
         // TODO: count hole/s + containing ring as one part
         partCount: function() {
@@ -24595,6 +24631,21 @@ ${svg}
     // Experimental commands
     parser.section('Experimental commands (may give unexpected results)');
 
+    parser.command('add-shape')
+      .describe('')
+      .option('geojson', {
+
+      })
+      .option('coordinates', {
+
+      })
+      .option('properties', {
+
+      })
+      .option('name', nameOpt)
+      .option('target', targetOpt)
+      .option('no-replace', noReplaceOpt);
+
     parser.command('alpha-shapes')
       // .describe('convert points to alpha shapes (aka concave hulls)')
       .option('interval', {
@@ -24922,6 +24973,9 @@ ${svg}
 
     parser.command('info')
       .describe('print information about data layers')
+      .option('save-to', {
+        describe: 'name of file to save info in JSON format'
+      })
       .option('target', targetOpt);
 
     parser.command('inspect')
@@ -27457,12 +27511,14 @@ ${svg}
   // Import datasets contained in a BSON blob
   // Return command target as a dataset
   //
-  async function unpackSession(buf) {
-    var obj = unpack(buf, {});
+  async function unpackSessionData(buf) {
+    return restoreSessionData(unpack(buf, {}));
+  }
+
+  async function restoreSessionData(obj) {
     if (!isValidSession(obj)) {
       stop('Invalid mapshaper session data object');
     }
-
     var datasets = await Promise.all(obj.datasets.map(importDataset));
     return Object.assign(obj, {datasets: datasets});
   }
@@ -27539,7 +27595,8 @@ ${svg}
 
   var Unpack = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    unpackSession: unpackSession
+    unpackSessionData: unpackSessionData,
+    restoreSessionData: restoreSessionData
   });
 
   cmd.importFiles = async function(catalog, opts) {
@@ -27593,7 +27650,7 @@ ${svg}
 
   async function importMshpFile(file, catalog, opts) {
     var buf = cli.readFile(file, null, opts.input);
-    var obj = await unpackSession(buf);
+    var obj = await unpackSessionData(buf);
     obj.datasets.forEach(catalog.addDataset, catalog);
     return obj.target;
   }
@@ -28063,6 +28120,136 @@ ${svg}
     stashVar('input_files', job.input_files);
   }
 
+  cmd.addShape = addShape;
+
+  function addShape(targetLayers, targetDataset, opts) {
+    if (targetLayers.length > 1) {
+      stop('Command expects a single target layer');
+    }
+    var targetLyr = targetLayers[0]; // may be undefined
+    var targetType = !opts.no_replace && targetLyr && targetLyr.geometry_type || null;
+    var dataset = importGeoJSON(toFeature(opts, targetType));
+    var outputLyr = mergeDatasetsIntoDataset(targetDataset, [dataset])[0];
+    if (opts.no_replace || !targetLyr) {
+      // create new layer
+      setOutputLayerName(outputLyr, targetLyr && targetLyr.name, null, opts);
+      return [outputLyr];
+    }
+    // merge into target layer
+    return cmd.mergeLayers([targetLyr, outputLyr], {force: true});
+  }
+
+  function toFeature(opts, geomType) {
+    if (opts.geojson) {
+      return parseArg(opts.geojson);
+    }
+
+    var geom = opts.coordinates && parseCoordsAsGeometry(opts.coordinates) || null;
+
+    if (!geom) {
+      stop('Missing required shape coordinates');
+    }
+
+    if (geomType == 'point' && geom.type != 'Point') {
+      stop('Expected point coordinates, received', geom.type);
+    }
+
+    if (geomType == 'polygon' && geom.type != 'Polygon') {
+      stop('Expected polygon coordinates, received', geom.type);
+    }
+
+    if (geomType == 'polyline') {
+      if (geom.type == 'Polygon') {
+        geom.coordinates = geom.coordinates[0];
+        geom.type = 'LineString';
+      } else {
+        stop('Expected polyline coordinates, received', geom.type);
+      }
+    }
+
+    return {
+      type: 'Feature',
+      properties: parseProperties(opts.properties),
+      geometry: geom
+    };
+  }
+
+  function parseArg(obj) {
+    return typeof obj == 'string' ? JSON.parse(obj) : obj;
+  }
+
+  function parseProperties(arg) {
+    if (!arg) return null;
+    return parseArg(arg);
+  }
+
+  function isArrayOfNumbers(arr) {
+    return arr.length >= 2 && arr.every(utils.isNumber);
+  }
+
+  function isClosedPath$1(arr) {
+    return isArrayOfPoints(arr) && arr.length > 3 && samePoint$1(arr[0], arr[arr.length - 1]);
+  }
+
+  function samePoint$1(a, b) {
+    return a[0] == b[0] && a[1] == b[1];
+  }
+
+  function isArrayOfPoints(arr) {
+    return arr.every(isPoint);
+  }
+
+  function isPoint(arr) {
+    return arr && arr.length == 2 && isArrayOfNumbers(arr);
+  }
+
+  function transposeCoords(arr) {
+    var coords = [];
+    for (var i=0; i<arr.length; i+=2) {
+      coords.push([arr[i], arr[i+1]]);
+    }
+    if (!isArrayOfPoints(coords)) {
+      stop('Unable to parse x,y,x,y... coordinates');
+    }
+    return coords;
+  }
+
+  function parseCoordsAsGeometry(arg) {
+    if (typeof arg == 'string') {
+      arg = arg.trim();
+      if (!arg.startsWith('[') && !arg.endsWith(']')) {
+        arg = '[' + arg + ']';
+      }
+    }
+    var arr = parseArg(arg);
+    if (isPoint(arr)) {
+      return {
+        type: 'Point',
+        coordinates: arr
+      };
+    }
+
+    if (isArrayOfNumbers(arr)) {
+      arr = transposeCoords(arr);
+    }
+
+    if (isClosedPath$1(arr)) {
+      return {
+        type: 'Polygon',
+        coordinates: [arr]
+      };
+    }
+
+    if (isArrayOfPoints(arr)) {
+      return {
+        type: 'LineString',
+        coordinates: arr
+      };
+    }
+
+    stop('Unable to import coordinates');
+  }
+
   const epsilon = 1.1102230246251565e-16;
   const splitter = 134217729;
   const resulterrbound = (3 + 8 * epsilon) * epsilon;
@@ -29251,17 +29438,6 @@ ${svg}
     bufferIntersection: bufferIntersection
   });
 
-  function testSegmentBoundsIntersection(a, b, bb) {
-    if (bb.containsPoint(a[0], a[1])) {
-      return true;
-    }
-    return !!(
-      geom.segmentIntersection(a[0], a[1], b[0], b[1], bb.xmin, bb.ymin, bb.xmin, bb.ymax) ||
-      geom.segmentIntersection(a[0], a[1], b[0], b[1], bb.xmin, bb.ymax, bb.xmax, bb.ymax) ||
-      geom.segmentIntersection(a[0], a[1], b[0], b[1], bb.xmax, bb.ymax, bb.xmax, bb.ymin) ||
-      geom.segmentIntersection(a[0], a[1], b[0], b[1], bb.xmax, bb.ymin, bb.xmin, bb.ymin));
-  }
-
   function getPolylineBufferMaker2(arcs, geod, getBearing, opts) {
     var makeLeftBuffer = getPathBufferMaker2(arcs, geod, getBearing, opts);
     var geomType = opts.geometry_type;
@@ -37082,7 +37258,7 @@ ${svg}
     editor.done();
     if (!opts.debug) {
       buildTopology(dataset);
-      cleanProjectedLayers(dataset);
+      cleanProjectedPathLayers(dataset);
     }
   }
 
@@ -37593,15 +37769,41 @@ ${svg}
     } else {
       clipData = getClippingDataset(src, dest, opts);
     }
+    // clip data to projection limits (some projections), if content exceeds the limit
+    //
     if (clipData) {
-      // TODO: don't bother to clip content that is fully within
-      // the clipping shape. But how to tell?
-      clipLayersInPlace(dataset.layers, clipData, dataset, 'clip');
-      clipped = true;
+      clipped = clipLayersIfNeeded(dataset, clipData);
     }
     return cut || clipped;
   }
 
+  function clipLayersIfNeeded(dataset, clipData) {
+    // Avoid clipping layers that are fully enclosed within the projectable
+    // coordinate space (represented by a dataset containing a single
+    // polygon layer, @clipData). This avoids performing unnecessary intersection
+    // tests on each line segment.
+    var layers = dataset.layers.filter(function(lyr) {
+      return !layerIsFullyEnclosed(lyr, dataset, clipData);
+    });
+    if (layers.length > 0) {
+      clipLayersInPlace(layers, clipData, dataset, 'clip');
+      return true;
+    }
+    return false;
+  }
+
+  // @clipData: a dataset containing a polygon layer
+  function layerIsFullyEnclosed(lyr, dataset, clipData) {
+    // This test uses the layer's bounding box to represent the extent of the
+    // layer, and can produce false negatives.
+    var dataBounds = getLayerBounds(lyr, dataset.arcs);
+    var enclosed = false;
+    clipData.layers[0].shapes.forEach(function(shp, i) {
+      enclosed = enclosed || testBoundsInPolygon(dataBounds, shp, clipData.arcs);
+    });
+    return enclosed;
+  }
+
 
   function insertPreProjectionCuts(dataset, src, dest) {
     var antimeridian = getAntimeridian(dest.lam0 * 180 / Math.PI);
@@ -37796,7 +37998,6 @@ ${svg}
     var badArcs = 0;
     var badPoints = 0;
     var clipped = preProjectionClip(dataset, src, dest, opts);
-
     dataset.layers.forEach(function(lyr) {
       if (layerHasPoints(lyr)) {
         badPoints += projectPointLayer(lyr, proj); // v2 compatible (invalid points are removed)
@@ -37813,7 +38014,7 @@ ${svg}
     if (clipped) {
       // TODO: could more selective in cleaning clipped layers
       // (probably only needed when clipped area crosses the antimeridian or includes a pole)
-      cleanProjectedLayers(dataset);
+      cleanProjectedPathLayers(dataset);
     }
 
     if (badArcs > 0 && !opts.quiet) {
@@ -37829,7 +38030,7 @@ ${svg}
   // * Removes line intersections
   // * TODO: what if a layer contains polygons with desired overlaps? should
   //   we ignore overlaps between different features?
-  function cleanProjectedLayers(dataset) {
+  function cleanProjectedPathLayers(dataset) {
     // TODO: only clean affected polygons (cleaning all polygons can be slow)
     var polygonLayers = dataset.layers.filter(lyr => lyr.geometry_type == 'polygon');
     // clean options: force a topology update (by default, this only happens when
@@ -37897,7 +38098,7 @@ ${svg}
     __proto__: null,
     fetchCrsInfo: fetchCrsInfo,
     projectDataset: projectDataset,
-    cleanProjectedLayers: cleanProjectedLayers,
+    cleanProjectedPathLayers: cleanProjectedPathLayers,
     projectPointLayer: projectPointLayer,
     projectArcs: projectArcs,
     projectArcs2: projectArcs2
@@ -38240,55 +38441,27 @@ ${svg}
 
   var MAX_RULE_LEN = 50;
 
-  cmd.printInfo = function(layers) {
-    var str = '';
-    layers.forEach(function(o, i) {
-      var title =  'Layer:    ' + (o.layer.name || '[unnamed layer]');
-      var tableStr = getAttributeTableInfo(o.layer);
-      var tableWidth = measureLongestLine(tableStr);
-      var ruleLen = Math.min(Math.max(title.length, tableWidth), MAX_RULE_LEN);
-      str += '\n';
-      str += utils.lpad('', ruleLen, '=') + '\n';
-      str += title + '\n';
-      str += utils.lpad('', ruleLen, '-') + '\n';
-      str += getLayerInfo(o.layer, o.dataset);
-      str += tableStr;
+  cmd.info = function(targets, opts) {
+    var layers = expandCommandTargets(targets);
+    var arr = layers.map(function(o) {
+      return getLayerInfo(o.layer, o.dataset);
     });
-    message(str);
+    message(formatInfo(arr));
+    if (opts.save_to) {
+      var output = [{
+        filename: opts.save_to + (opts.save_to.endsWith('.json') ? '' : '.json'),
+        content: JSON.stringify(arr, null, 2)
+      }];
+      writeFiles(output, opts);
+    }
   };
 
-  function measureLongestLine(str) {
-    return Math.max.apply(null, str.split('\n').map(function(line) {return stringDisplayWidth(line);}));
-  }
+  cmd.printInfo = cmd.info; // old name
 
-  function stringDisplayWidth(str) {
-    var w = 0;
-    for (var i = 0, n=str.length; i < n; i++) {
-      w += charDisplayWidth(str.charCodeAt(i));
-    }
-    return w;
-  }
-
-  // see https://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
-  // this is a simplified version, focusing on double-width CJK chars and ignoring nonprinting etc chars
-  function charDisplayWidth(c) {
-    if (c >= 0x1100 &&
-      (c <= 0x115f || c == 0x2329 || c == 0x232a ||
-      (c >= 0x2e80 && c <= 0xa4cf && c != 0x303f) || /* CJK ... Yi */
-      (c >= 0xac00 && c <= 0xd7a3) || /* Hangul Syllables */
-      (c >= 0xf900 && c <= 0xfaff) || /* CJK Compatibility Ideographs */
-      (c >= 0xfe10 && c <= 0xfe19) || /* Vertical forms */
-      (c >= 0xfe30 && c <= 0xfe6f) || /* CJK Compatibility Forms */
-      (c >= 0xff00 && c <= 0xff60) || /* Fullwidth Forms */
-      (c >= 0xffe0 && c <= 0xffe6) ||
-      (c >= 0x20000 && c <= 0x2fffd) ||
-      (c >= 0x30000 && c <= 0x3fffd))) return 2;
-    return 1;
-  }
-
-  function getLayerData(lyr, dataset) {
+  function getLayerInfo(lyr, dataset) {
     var n = getFeatureCount(lyr);
     var o = {
+      layer_name: lyr.name,
       geometry_type: lyr.geometry_type,
       feature_count: n,
       null_shape_count: 0,
@@ -38296,31 +38469,47 @@ ${svg}
     };
     if (lyr.shapes && lyr.shapes.length > 0) {
       o.null_shape_count = countNullShapes(lyr.shapes);
-      o.bbox =getLayerBounds(lyr, dataset.arcs).toArray();
+      o.bbox = getLayerBounds(lyr, dataset.arcs).toArray();
       o.proj4 = getProjInfo(dataset);
     }
+    o.source_file = getLayerSourceFile(lyr, dataset) || null;
+    o.attribute_data = getAttributeTableInfo(lyr);
     return o;
   }
 
-  // TODO: consider polygons with zero area or other invalid geometries
-  function countNullShapes(shapes) {
-    var count = 0;
-    for (var i=0; i<shapes.length; i++) {
-      if (!shapes[i] || shapes[i].length === 0) count++;
+  // i: (optional) record index
+  function getAttributeTableInfo(lyr, i) {
+    if (!lyr.data || lyr.data.size() === 0 || lyr.data.getFields().length === 0) {
+      return null;
     }
-    return count;
+    var fields = applyFieldOrder(lyr.data.getFields(), 'ascending');
+    var valueName = i === undefined ? 'first_value' : 'value';
+    return fields.map(function(fname) {
+      return {
+        field: fname,
+        [valueName]: lyr.data.getReadOnlyRecordAt(i || 0)[fname]
+      };
+    });
   }
 
-  function countNullRecords(records) {
-    var count = 0;
-    for (var i=0; i<records.length; i++) {
-      if (!records[i]) count++;
-    }
-    return count;
+  function formatInfo(arr) {
+    var str = '';
+    arr.forEach(function(info, i) {
+      var title =  'Layer:    ' + (info.layer_name || '[unnamed layer]');
+      var tableStr = formatAttributeTableInfo(info.attribute_data);
+      var tableWidth = measureLongestLine(tableStr);
+      var ruleLen = Math.min(Math.max(title.length, tableWidth), MAX_RULE_LEN);
+      str += '\n';
+      str += utils.lpad('', ruleLen, '=') + '\n';
+      str += title + '\n';
+      str += utils.lpad('', ruleLen, '-') + '\n';
+      str += formatLayerInfo(info);
+      str += tableStr;
+    });
+    return str;
   }
 
-  function getLayerInfo(lyr, dataset) {
-    var data = getLayerData(lyr, dataset);
+  function formatLayerInfo(data) {
     var str = '';
     str += "Type:     " + (data.geometry_type || "tabular data") + "\n";
     str += utils.format("Records:  %,d\n",data.feature_count);
@@ -38331,21 +38520,19 @@ ${svg}
       str += "Bounds:   " + data.bbox.join(',') + "\n";
       str += "CRS:      " + data.proj4 + "\n";
     }
-    str += "Source:   " + (getLayerSourceFile(lyr, dataset) || 'n/a') + "\n";
+    str += "Source:   " + (data.source_file || 'n/a') + "\n";
     return str;
   }
 
-  function getAttributeTableInfo(lyr, i) {
-    if (!lyr.data || lyr.data.size() === 0 || lyr.data.getFields().length === 0) {
-      return "Attribute data: [none]\n";
-    }
-    return "\nAttribute data\n" + formatAttributeTable(lyr.data, i);
-  }
-
-  function formatAttributeTable(data, i) {
-    var fields = applyFieldOrder(data.getFields(), 'ascending');
-    var vals = fields.map(function(fname) {
-      return data.getReadOnlyRecordAt(i || 0)[fname];
+  function formatAttributeTableInfo(arr) {
+    if (!arr) return "Attribute data: [none]\n";
+    var header = "\nAttribute data\n";
+    var valKey = 'first_value' in arr[0] ? 'first_value' : 'value';
+    var vals = [];
+    var fields = [];
+    arr.forEach(function(o) {
+      fields.push(o.field);
+      vals.push(o[valKey]);
     });
     var maxIntegralChars = vals.reduce(function(max, val) {
       if (utils.isNumber(val)) {
@@ -38357,20 +38544,66 @@ ${svg}
     var col2Arr = vals.reduce(function(memo, val) {
       memo.push(formatTableValue(val, maxIntegralChars));
       return memo;
-    }, [i >= 0 ? 'Value' : 'First value']);
+    }, [valKey == 'first_value' ? 'First value' : 'Value']);
     var col1Chars = maxChars(col1Arr);
     var col2Chars = maxChars(col2Arr);
     var sepStr = (utils.rpad('', col1Chars + 2, '-') + '+' +
         utils.rpad('', col2Chars + 2, '-')).substr(0, MAX_RULE_LEN);
     var sepLine = sepStr + '\n';
-    var table = sepLine;
+    var table = '';
     col1Arr.forEach(function(col1, i) {
       var w = stringDisplayWidth(col1);
       table += ' ' + col1 + utils.rpad('', col1Chars - w, ' ') + ' | ' +
         col2Arr[i] + '\n';
       if (i === 0) table += sepLine; // separator after first line
     });
-    return table + sepLine;
+    return header + sepLine + table + sepLine;
+  }
+
+  function measureLongestLine(str) {
+    return Math.max.apply(null, str.split('\n').map(function(line) {return stringDisplayWidth(line);}));
+  }
+
+  function stringDisplayWidth(str) {
+    var w = 0;
+    for (var i = 0, n=str.length; i < n; i++) {
+      w += charDisplayWidth(str.charCodeAt(i));
+    }
+    return w;
+  }
+
+  // see https://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
+  // this is a simplified version, focusing on double-width CJK chars and ignoring nonprinting etc chars
+  function charDisplayWidth(c) {
+    if (c >= 0x1100 &&
+      (c <= 0x115f || c == 0x2329 || c == 0x232a ||
+      (c >= 0x2e80 && c <= 0xa4cf && c != 0x303f) || /* CJK ... Yi */
+      (c >= 0xac00 && c <= 0xd7a3) || /* Hangul Syllables */
+      (c >= 0xf900 && c <= 0xfaff) || /* CJK Compatibility Ideographs */
+      (c >= 0xfe10 && c <= 0xfe19) || /* Vertical forms */
+      (c >= 0xfe30 && c <= 0xfe6f) || /* CJK Compatibility Forms */
+      (c >= 0xff00 && c <= 0xff60) || /* Fullwidth Forms */
+      (c >= 0xffe0 && c <= 0xffe6) ||
+      (c >= 0x20000 && c <= 0x2fffd) ||
+      (c >= 0x30000 && c <= 0x3fffd))) return 2;
+    return 1;
+  }
+
+  // TODO: consider polygons with zero area or other invalid geometries
+  function countNullShapes(shapes) {
+    var count = 0;
+    for (var i=0; i<shapes.length; i++) {
+      if (!shapes[i] || shapes[i].length === 0) count++;
+    }
+    return count;
+  }
+
+  function countNullRecords(records) {
+    var count = 0;
+    for (var i=0; i<records.length; i++) {
+      if (!records[i]) count++;
+    }
+    return count;
   }
 
   function maxChars(arr) {
@@ -38424,8 +38657,9 @@ ${svg}
 
   var Info = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    getLayerData: getLayerData,
+    getLayerInfo: getLayerInfo,
     getAttributeTableInfo: getAttributeTableInfo,
+    formatAttributeTableInfo: formatAttributeTableInfo,
     formatTableValue: formatTableValue
   });
 
@@ -38477,7 +38711,7 @@ ${svg}
   function getFeatureInfo(id, lyr, arcs) {
       var msg = "Feature " + id + '\n';
       msg += getShapeInfo(id, lyr, arcs);
-      msg += getAttributeTableInfo(lyr, id);
+      msg += formatAttributeTableInfo(getAttributeTableInfo(lyr, id));
       return msg;
   }
 
@@ -38838,12 +39072,12 @@ ${svg}
   function polylineToMidpoints(shp, arcs, opts) {
     if (!shp) return null;
     var points = shp.map(function(path) {
-      return findPathMidpoint(path, arcs);
+      return findPathMidpoint(path, arcs, false);
     });
     return points;
   }
 
-  function findPathMidpoint(path, arcs) {
+  function findPathMidpoint(path, arcs, useNearestVertex) {
     var halfLen = calcPathLen(path, arcs, false) / 2;
     var partialLen = 0;
     var p;
@@ -38860,7 +39094,11 @@ ${svg}
       var k;
       if (partialLen + segLen >= halfLen) {
         k = (halfLen - partialLen) / segLen;
-        p = [a + k * (c - a), b + k * (d - b)];
+        if (useNearestVertex) {
+          k = k < 0.5 ? 0 : 1;
+        }
+        // p = [a + k * (c - a), b + k * (d - b)];
+        p = [(1 - k) * a + k * c, (1 - k) * b + k * d];
       }
       partialLen += segLen;
     });
@@ -40589,7 +40827,7 @@ ${svg}
 
   function getRunCommandData(target) {
     var lyr = target.layers[0];
-    var data = getLayerData(lyr, target.dataset);
+    var data = getLayerInfo(lyr, target.dataset);
     data.layer = lyr;
     data.dataset = target.dataset;
     return data;
@@ -42740,7 +42978,7 @@ ${svg}
       name == 'point-grid' || name == 'shape' || name == 'rectangle' ||
       name == 'require' || name == 'run' || name == 'define' ||
       name == 'include' || name == 'print' || name == 'comment' || name == 'if' || name == 'elif' ||
-      name == 'else' || name == 'endif' || name == 'stop';
+      name == 'else' || name == 'endif' || name == 'stop' || name == 'add-shape';
   }
 
   async function runCommand(command, job) {
@@ -42814,7 +43052,14 @@ ${svg}
         source = findCommandSource(convertSourceName(opts.source, targets), job.catalog, opts);
       }
 
-      if (name == 'affine') {
+      if (name == 'add-shape') {
+        if (!targetDataset) {
+          targetDataset = {info: {}, layers: []};
+          targetLayers = targetDataset.layers;
+          job.catalog.addDataset(targetDataset);
+        }
+        outputLayers = cmd.addShape(targetLayers, targetDataset, opts);
+      } else if (name == 'affine') {
         cmd.affine(targetLayers, targetDataset, opts);
 
       } else if (name == 'alpha-shapes') {
@@ -42939,7 +43184,7 @@ ${svg}
         cmd.include(opts);
 
       } else if (name == 'info') {
-        cmd.printInfo(expandCommandTargets(targets));
+        cmd.info(targets, opts);
 
       } else if (name == 'inlay') {
         outputLayers = cmd.inlay(targetLayers, source, targetDataset, opts);
@@ -43305,13 +43550,13 @@ ${svg}
     commands = runAndRemoveInfoCommands(commands);
     if (commands.length === 0) return done(null);
 
-    // add options to -i -o -join -clip -erase commands to bypass file i/o
+    // add options to -i -o -join -clip -erase etc. commands to bypass file i/o
     // TODO: find a less kludgy solution
     commands.forEach(function(cmd) {
       if (commandTakesFileInput(cmd.name) && inputObj) {
         cmd.options.input = inputObj;
       }
-      if (cmd.name == 'o' && outputArr) {
+      if (outputArr && (cmd.name == 'o' || cmd.name == 'info' && cmd.options.save_to)) {
         cmd.options.output = outputArr;
       }
     });