mapshaper 0.6.63 → 0.6.66

package/mapshaper.js

@@ -4010,6 +4010,59 @@
     return applyFieldOrder(names, order);
   }
 
+
+  function parseUnknownType(str) {
+    var val = getInputParser('number')(str);
+    if (val !== null) return val;
+    val = getInputParser('object')(str);
+    if (val !== null) return val;
+    return str;
+  }
+
+  // used by GUI data editing
+  function getInputParser(type) {
+    return inputParsers[type || 'multiple'];
+  }
+
+  var inputParsers = {
+    date: function(raw) {
+      var d = new Date(raw);
+      return isNaN(+d) ? null : d;
+    },
+    string: function(raw) {
+      return raw;
+    },
+    number: function(raw) {
+      var val = Number(raw);
+      if (raw == 'NaN') {
+        val = NaN;
+      } else if (isNaN(val)) {
+        val = null;
+      }
+      return val;
+    },
+    object: function(raw) {
+      var val = null;
+      try {
+        val = JSON.parse(raw);
+      } catch(e) {}
+      return val;
+    },
+    boolean: function(raw) {
+      var val = null;
+      if (raw == 'true') {
+        val = true;
+      } else if (raw == 'false') {
+        val = false;
+      }
+      return val;
+    },
+    multiple: function(raw) {
+      var val = Number(raw);
+      return isNaN(val) ? raw : val;
+    }
+  };
+
   var DataUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
     copyRecord: copyRecord,
@@ -4024,7 +4077,9 @@
     getUniqFieldValues: getUniqFieldValues,
     applyFieldOrder: applyFieldOrder,
     getFirstNonEmptyRecord: getFirstNonEmptyRecord,
-    findFieldNames: findFieldNames
+    findFieldNames: findFieldNames,
+    parseUnknownType: parseUnknownType,
+    getInputParser: getInputParser
   });
 
   function DataTable(obj) {
@@ -4122,6 +4177,30 @@
     }
   };
 
+  // TODO: make this stricter (could give false positive on some degenerate paths)
+  function pathIsRectangle(ids, arcs) {
+    var bbox = arcs.getSimpleShapeBounds(ids).toArray();
+    var iter = arcs.getShapeIter(ids);
+    while (iter.hasNext()) {
+      if (iter.x != bbox[0] && iter.x != bbox[2] ||
+          iter.y != bbox[1] && iter.y != bbox[3]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  function bboxToCoords(bbox) {
+    return [[bbox[0], bbox[1]], [bbox[0], bbox[3]], [bbox[2], bbox[3]],
+        [bbox[2], bbox[1]], [bbox[0], bbox[1]]];
+  }
+
+  var RectangleUtils = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    pathIsRectangle: pathIsRectangle,
+    bboxToCoords: bboxToCoords
+  });
+
   // Insert a column of values into a (new or existing) data field
   function insertFieldValues(lyr, fieldName, values) {
     var size = getFeatureCount(lyr) || values.length,
@@ -4162,6 +4241,19 @@
     return lyr.geometry_type == 'point' && layerHasNonNullShapes(lyr);
   }
 
+  function layerIsRectangle(lyr, arcs) {
+    return layerOnlyHasRectangles(lyr, arcs) && lyr.shapes.length == 1;
+  }
+
+  function layerOnlyHasRectangles(lyr, arcs) {
+    if (!layerHasPaths(lyr)) return false;
+    if (countMultiPartFeatures(lyr) > 0) return false;
+    return lyr.shapes.every(function(shp) {
+      if (!shp) return true;
+      return pathIsRectangle(shp[0], arcs);
+    });
+  }
+
   function layerHasNonNullShapes(lyr) {
     return utils.some(lyr.shapes || [], function(shp) {
       return !!shp;
@@ -4405,6 +4497,8 @@
     layerHasGeometry: layerHasGeometry,
     layerHasPaths: layerHasPaths,
     layerHasPoints: layerHasPoints,
+    layerIsRectangle: layerIsRectangle,
+    layerOnlyHasRectangles: layerOnlyHasRectangles,
     layerHasNonNullShapes: layerHasNonNullShapes,
     deleteFeatureById: deleteFeatureById,
     transformPointsInLayer: transformPointsInLayer,
@@ -5002,10 +5096,10 @@
   // x, y: a point location in projected coordinates
   // Returns k, the ratio of coordinate distance to distance on the ground
   function getScaleFactorAtXY(x, y, crs) {
-    var dist = 1;
+    var dist = 1 / crs.to_meter;
     var lp = mproj.pj_inv_deg({x: x, y: y}, crs);
     var lp2 = mproj.pj_inv_deg({x: x + dist, y: y}, crs);
-    var k = dist / geom.greatCircleDistance(lp.lam, lp.phi, lp2.lam, lp2.phi);
+    var k = 1 / geom.greatCircleDistance(lp.lam, lp.phi, lp2.lam, lp2.phi);
     return k;
   }
 
@@ -11058,7 +11152,7 @@
   // File looks like an importable file type
   // name: filename or path
   function looksLikeImportableFile(name) {
-    return !!guessInputFileType(name);
+    return !!guessInputFileType(name) || isImportableAsBinary(name);
   }
 
   // File looks like a directly readable data file type
@@ -13301,6 +13395,18 @@
     miles: 1609.344 // International Statute Mile
   };
 
+  // str: display size in px, pt or in
+  // using: 72pt per inch, 1pt per pixel.
+  function parseSizeParam(str) {
+    var num = parseFloat(str),
+        units = /px$/.test(str) && 'px' || /pt$/.test(str) && 'pt' ||
+          /in$/.test(str) && 'in' || !isNaN(+str) && 'px' || null;
+    if (isNaN(num) || !units) {
+      stop('Invalid size:', str);
+    }
+    return units == 'in' && num * 72 || num;
+  }
+
   // Return coeff. for converting a distance measure to dataset coordinates
   // @paramUnits: units code of distance param, or null if units are not specified
   // @crs: Proj.4 CRS object, or null (unknown latlong CRS);
@@ -13444,6 +13550,7 @@
 
   var Units = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    parseSizeParam: parseSizeParam,
     getIntervalConversionFactor: getIntervalConversionFactor,
     parseMeasure: parseMeasure,
     parseMeasure2: parseMeasure2,
@@ -18121,7 +18228,7 @@
     var frameLyr = findFrameLayerInDataset(dataset);
     var frameData;
     if (frameLyr) {
-      frameData = Object.assign({}, getFurnitureLayerData(frameLyr));
+      frameData = getFrameLayerData(frameLyr, dataset);
     } else {
       frameData = calcFrameData(dataset, exportOpts);
     }
@@ -18129,6 +18236,25 @@
     return frameData;
   }
 
+
+  function getFrameLayerData(lyr, dataset) {
+    var bounds = getLayerBounds(lyr, dataset.arcs);
+    var d = lyr.data.getReadOnlyRecordAt(0);
+    var w = d.width || 800;
+    var h = w * bounds.height() / bounds.width();
+    return {
+      type: 'frame',
+      width: w,
+      height: h,
+      bbox: bounds.toArray()
+    };
+  }
+
+  // export function getFrameLayerData(lyr) {
+  //   return lyr.data && lyr.data.getReadOnlyRecordAt(0);
+  // }
+
+
   function calcFrameData(dataset, opts) {
     var bounds;
     if (opts.svg_bbox) {
@@ -18146,10 +18272,6 @@
     };
   }
 
-  function getFrameLayerData(lyr) {
-    return lyr.data && lyr.data.getReadOnlyRecordAt(0);
-  }
-
   // Used by mapshaper-frame and mapshaper-pixel-transform. TODO: refactor
   function getFrameSize(bounds, opts) {
     var aspectRatio = bounds.width() / bounds.height();
@@ -18165,26 +18287,27 @@
 
 
   // @lyr dataset layer
-  function isFrameLayer(lyr) {
-    return getFurnitureLayerType(lyr) == 'frame';
+  function isFrameLayer(lyr, dataset) {
+    return getFurnitureLayerType(lyr) == 'frame' &&
+      layerIsRectangle(lyr, dataset.arcs);
   }
 
   function findFrameLayerInDataset(dataset) {
     return utils.find(dataset.layers, function(lyr) {
-      return isFrameLayer(lyr);
+      return isFrameLayer(lyr, dataset);
     });
   }
 
   function findFrameDataset(catalog) {
     var target = utils.find(catalog.getLayers(), function(o) {
-      return isFrameLayer(o.layer);
+      return isFrameLayer(o.layer, o.dataset);
     });
     return target ? target.dataset : null;
   }
 
   function findFrameLayer(catalog) {
     var target = utils.find(catalog.getLayers(), function(o) {
-      return isFrameLayer(o.layer);
+      return isFrameLayer(o.layer, o.dataset);
     });
     return target && target.layer || null;
   }
@@ -18322,7 +18445,6 @@
   var FrameData = /*#__PURE__*/Object.freeze({
     __proto__: null,
     getFrameData: getFrameData,
-    getFrameLayerData: getFrameLayerData,
     getFrameSize: getFrameSize,
     findFrameLayerInDataset: findFrameLayerInDataset,
     findFrameDataset: findFrameDataset,
@@ -18825,6 +18947,10 @@
       if (filter && !filter(fields[i])) continue;
       setAttribute(svgObj, fields[i], rec[fields[i]]);
     }
+    // kludge to prevent default black fill on polygons with stroke styles
+    if ((symType == 'polygon' || symType == 'circle') && rec.stroke && !rec.fill) {
+      setAttribute(svgObj, 'fill', 'none');
+    }
   }
 
   function setAttribute(obj, k, v) {
@@ -19407,99 +19533,136 @@
   }
 
   // TODO: generalize to other kinds of furniture as they are developed
-  function getScalebarPosition(d) {
-    var opts = { // defaults
-      valign: 'top',
-      halign: 'left',
-      voffs: 10,
-      hoffs: 10
+  function getScalebarPosition(opts) {
+    var pos = opts.position || 'top-left';
+    return {
+      valign: pos.includes('top') ? 'top' : 'bottom',
+      halign: pos.includes('left') ? 'left' : 'right'
     };
-    if (+d.left > 0) {
-      opts.hoffs = +d.left;
+  }
+
+  var styleOpts = {
+    a: {
+      bar_width: 3,
+      tic_length: 0
+    },
+    b: {
+      bar_width: 1,
+      tic_length: 5
     }
-    if (+d.top > 0) {
-      opts.voffs = +d.top;
+  };
+
+  var defaultOpts = {
+    position: 'top-left',
+    label_position: 'top',
+    label_offset: 4,
+    font_size: 12,
+    margin: 12
+  };
+
+  function getScalebarOpts(d) {
+    var style = d.style == 'b' || d.style == 'B' ? 'b' : 'a';
+    return Object.assign({}, defaultOpts, styleOpts[style], d, {style: style});
+  }
+
+  // approximate pixel height of the scalebar
+  function getScalebarHeight(opts) {
+    return Math.round(opts.bar_width + opts.label_offset +
+        opts.tic_length + opts.font_size * 0.8);
+  }
+
+  function renderAsSvg(length, text, opts) {
+    // label part
+    var xOff = opts.style == 'b' ? Math.round(opts.font_size / 4) : 0;
+    var alignLeft = opts.style == 'a' && opts.position.includes('left');
+    var anchorX = alignLeft ? -xOff : length + xOff;
+    var anchorY = opts.bar_width + + opts.tic_length + opts.label_offset;
+    if (opts.label_position == 'top') {
+      anchorY = -opts.label_offset - opts.tic_length;
     }
-    if (+d.right > 0) {
-      opts.hoffs = +d.right;
-      opts.halign = 'right';
+    var labelOpts = {
+        'label-text': text,
+        'font-size': opts.font_size,
+        'text-anchor': alignLeft ? 'start': 'end',
+        'dominant-baseline': opts.label_position == 'top' ? 'auto' : 'hanging'
+        //// 'dominant-baseline': labelPos == 'top' ? 'text-after-edge' : 'text-before-edge'
+        // 'text-after-edge' is buggy in Safari and unsupported by Illustrator,
+        // 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 labelPart = symbolRenderers.label(labelOpts, anchorX, anchorY);
+    var zeroOpts = Object.assign({}, labelOpts, {'label-text': '0', 'text-anchor': 'start'});
+    var zeroLabel = symbolRenderers.label(zeroOpts, -xOff, anchorY);
+
+    // bar part
+    var y = 0;
+    var y2 = opts.tic_length + opts.bar_width / 2;
+    var coords;
+    if (opts.label_position == "top") {
+      y2 = -y2;
     }
-    if (+d.bottom > 0) {
-      opts.voffs = +d.bottom;
-      opts.valign = 'bottom';
+    if (opts.tic_length > 0) {
+      coords = [[0, y2], [0, y], [length, y], [length, y2]];
+    } else {
+      coords = [[0, y], [length, y]];
     }
-    return opts;
+    var barPart = importLineString(coords);
+    Object.assign(barPart.properties, {
+      stroke: 'black',
+      fill: 'none',
+      'stroke-width': opts.bar_width,
+      'stroke-linecap': 'butt',
+      'stroke-linejoin': 'miter'
+    });
+    var parts = opts.style == 'b' ? [zeroLabel, labelPart, barPart] : [labelPart, barPart];
+    return {
+      tag: 'g',
+      children: parts
+    };
   }
 
   function renderScalebar(d, frame) {
-    var pos = getScalebarPosition(d);
+    if (!frame.crs) {
+      message('Unable to render scalebar: unknown CRS.');
+      return [];
+    }
+    if (frame.width > 0 === false) {
+      return [];
+    }
+
+    var opts = getScalebarOpts(d);
     var metersPerPx = getMapFrameMetersPerPixel(frame);
     var frameWidthPx = frame.width;
     var unit = d.label ? parseScalebarUnits(d.label) : 'mile';
     var number = d.label ? parseScalebarNumber(d.label) : null;
     var label = number && unit ? d.label : getAutoScalebarLabel(frameWidthPx, metersPerPx, unit);
-    var scalebarKm = parseScalebarLabelToKm(label);
-    var barHeight = 3;
-    var labelOffs = 4;
-    var fontSize = +d.font_size || 12;
-    var width = Math.round(scalebarKm / metersPerPx * 1000);
-    var height = Math.round(barHeight + labelOffs + fontSize * 0.8);
-    var labelPos = d.label_position == 'top' ? 'top' : 'bottom';
-    var anchorX = pos.halign == 'left' ? 0 : width;
-    var anchorY = barHeight + labelOffs;
-    var dx = pos.halign == 'right' ? frameWidthPx - width - pos.hoffs : pos.hoffs;
-    var dy = pos.valign == 'bottom' ? frame.height - height - pos.voffs : pos.voffs;
 
+    var scalebarKm = parseScalebarLabelToKm(label);
     if (scalebarKm > 0 === false) {
       message('Unusable scalebar label:', label);
       return [];
     }
 
-    if (frameWidthPx > 0 === false) {
-      return [];
-    }
-
-    if (!frame.crs) {
-      message('Unable to render scalebar: unknown CRS.');
-      return [];
+    var width = Math.round(scalebarKm / metersPerPx * 1000);
+    if (width > 0 === false) {
+      stop("Null scalebar length");
     }
 
-    if (labelPos == 'top') {
-      anchorY = -labelOffs;
-      dy += Math.round(labelOffs + fontSize * 0.8);
+    var pos = getScalebarPosition(opts);
+    var height = getScalebarHeight(opts);
+    var dx = pos.halign == 'right' ? frameWidthPx - width - opts.margin : opts.margin;
+    var dy = pos.valign == 'bottom' ? frame.height - height - opts.margin : opts.margin;
+    if (opts.label_position == 'top') {
+      dy += Math.round(opts.label_offset + opts.tic_length + opts.font_size * 0.8 + opts.bar_width / 2);
+    } else {
+      dy += Math.round(opts.bar_width / 2);
     }
 
-    if (width > 0 === false) {
-      stop("Null scalebar length");
-    }
-    var barObj = {
-      tag: 'rect',
-      properties: {
-        fill: 'black',
-        x: 0,
-        y: 0,
-        width: width,
-        height: barHeight
-      }
-    };
-    var labelOpts = {
-        'label-text': label,
-        'font-size': fontSize,
-        'text-anchor': pos.halign == 'left' ? 'start': 'end',
-        'dominant-baseline': labelPos == 'top' ? 'auto' : 'hanging'
-        //// 'dominant-baseline': labelPos == 'top' ? 'text-after-edge' : 'text-before-edge'
-        // 'text-after-edge' is buggy in Safari and unsupported by Illustrator,
-        // 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);
-    var g = {
-      tag: 'g',
-      children: [barObj, labelObj],
-      properties: {
-        transform: 'translate(' + dx + ' ' + dy + ')'
-      }
+    var g = renderAsSvg(width, label, opts);
+    g.properties = {
+      transform: 'translate(' + dx + ' ' + dy + ')'
     };
+
     return [g];
   }
 
@@ -19615,6 +19778,7 @@
     }).reverse().join(',');
   }
 
+
   function renderFrame(d) {
     var lineWidth = 1,
         // inset stroke by half of line width
@@ -21986,7 +22150,13 @@ ${svg}
 
   // @targets - non-empty output from Catalog#findCommandTargets()
   //
-  async function exportTargetLayers(targets, opts) {
+  async function exportTargetLayers(catalog, targets, opts) {
+    // kludge: get extent of 'fit-extent' layer (if given)
+    if (opts.fit_extent) {
+      var target = catalog.findSingleLayer(opts.fit_extent);
+      var bounds = getLayerBounds(target.layer, target.dataset.arcs);
+      opts = Object.assign({svg_bbox: bounds.toArray()}, opts);
+    }
     // convert target fmt to dataset fmt
     var datasets = targets.map(function(target) {
       return utils.defaults({layers: target.layers}, target.dataset);
@@ -24068,6 +24238,9 @@ ${svg}
         describe: '[SVG] bounding box of SVG map in projected map units',
         type: 'bbox'
       })
+      .option('fit-extent', {
+        describe: '[SVG] layer to use for the map extent'
+      })
       .option('point-symbol', {
         describe: '[SVG] circle or square (default is circle)'
       })
@@ -25018,6 +25191,10 @@ ${svg}
         type: 'bbox'
       })
       .option('offset', offsetOpt)
+      .option('width', {
+        // describe: 'set viewport width in pixels',
+        type: 'number'
+      })
       .option('aspect-ratio', aspectRatioOpt)
       .option('source', {
         describe: 'name of layer to enclose'
@@ -25691,13 +25868,33 @@ ${svg}
         DEFAULT: true,
         describe: 'distance label, e.g. "35 miles"'
       })
-      .option('top', {})
-      .option('right', {})
-      .option('bottom', {})
-      .option('left', {})
-      .option('font-size', {})
-      // .option('font-family', {})
-      .option('label-position', {}); // top or bottom
+      .option('style', {
+        describe: 'two options: a or b'
+      })
+      .option('font-size', {
+        type: 'number'
+      })
+      .option('tic-length', {
+        describe: 'length of tic marks (style b)',
+        type: 'number'
+      })
+      .option('bar-width', {
+        describe: 'line width of bar',
+        type: 'number'
+      })
+      .option('label-offset', {
+        type: 'number'
+      })
+      .option('position', {
+        describe: 'e.g. bottom-right (default is top-left)'
+      })
+      .option('label-position', {
+        describe: 'top or bottom'
+      })
+      .option('margin', {
+        describe: 'offset in pixels from edge of map',
+        type: 'number'
+      });
 
     parser.command('shape')
       .describe('create a polyline or polygon from coordinates')
@@ -35673,11 +35870,285 @@ ${svg}
     };
   }
 
+  var MAX_RULE_LEN = 50;
+
+  cmd.info = function(targets, opts) {
+    var layers = expandCommandTargets(targets);
+    var arr = layers.map(function(o) {
+      return getLayerInfo(o.layer, o.dataset);
+    });
+
+    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);
+    }
+    if (opts.to_layer) {
+      return {
+        info: {},
+        layers: [{
+          name: opts.name || 'info',
+          data: new DataTable(arr)
+        }]
+      };
+    }
+    message(formatInfo(arr));
+  };
+
+  cmd.printInfo = cmd.info; // old name
+
+  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,
+      null_data_count: lyr.data ? countNullRecords(lyr.data.getRecords()) : n
+    };
+    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);
+    }
+    o.source_file = getLayerSourceFile(lyr, dataset) || null;
+    o.attribute_data = getAttributeTableInfo(lyr);
+    return o;
+  }
+
+  // i: (optional) record index
+  function getAttributeTableInfo(lyr, i) {
+    if (!lyr.data || lyr.data.size() === 0 || lyr.data.getFields().length === 0) {
+      return null;
+    }
+    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 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 formatLayerInfo(data) {
+    var str = '';
+    str += "Type:     " + (data.geometry_type || "tabular data") + "\n";
+    str += utils.format("Records:  %,d\n",data.feature_count);
+    if (data.null_shape_count > 0) {
+      str += utils.format("Nulls:     %'d", data.null_shape_count) + "\n";
+    }
+    if (data.geometry_type && data.feature_count > data.null_shape_count) {
+      str += "Bounds:   " + data.bbox.join(',') + "\n";
+      str += "CRS:      " + data.proj4 + "\n";
+    }
+    str += "Source:   " + (data.source_file || 'n/a') + "\n";
+    return str;
+  }
+
+  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)) {
+        max = Math.max(max, countIntegralChars(val));
+      }
+      return max;
+    }, 0);
+    var col1Arr = ['Field'].concat(fields);
+    var col2Arr = vals.reduce(function(memo, val) {
+      memo.push(formatTableValue(val, maxIntegralChars));
+      return memo;
+    }, [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 = '';
+    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 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) {
+    return arr.reduce(function(memo, str) {
+      var w = stringDisplayWidth(str);
+      return w > memo ? w : memo;
+    }, 0);
+  }
+
+  function formatString(str) {
+    var replacements = {
+      '\n': '\\n',
+      '\r': '\\r',
+      '\t': '\\t'
+    };
+    var cleanChar = function(c) {
+      // convert newlines and carriage returns
+      // TODO: better handling of non-printing chars
+      return c in replacements ? replacements[c] : '';
+    };
+    str = str.replace(/[\r\t\n]/g, cleanChar);
+    return "'" + str + "'";
+  }
+
+  function countIntegralChars(val) {
+    return utils.isNumber(val) ? (utils.formatNumber(val) + '.').indexOf('.') : 0;
+  }
+
+  function formatTableValue(val, integralChars) {
+    var str;
+    if (utils.isNumber(val)) {
+      str = utils.lpad("", integralChars - countIntegralChars(val), ' ') +
+        utils.formatNumber(val);
+    } else if (utils.isString(val)) {
+      str = formatString(val);
+    } else if (utils.isDate(val)) {
+      str = utils.formatDateISO(val) + ' (Date)';
+    } else if (utils.isObject(val)) { // if {} or [], display JSON
+      str = JSON.stringify(val);
+    } else {
+      str = String(val);
+    }
+
+    if (typeof str != 'string') {
+      // e.g. JSON.stringify converts functions to undefined
+      str = '[' + (typeof val) + ']';
+    }
+
+    return str;
+  }
+
+  var Info = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getLayerInfo: getLayerInfo,
+    getAttributeTableInfo: getAttributeTableInfo,
+    formatAttributeTableInfo: formatAttributeTableInfo,
+    formatTableValue: formatTableValue
+  });
+
+  // import { importGeoJSON } from '../geojson/geojson-import';
+
+
+  function addTargetProxies(targets, ctx) {
+    if (targets && targets.length > 0) {
+      var proxies = expandCommandTargets(targets).reduce(function(memo, target) {
+        var proxy = getTargetProxy(target);
+        memo.push(proxy);
+        // index targets by layer name too
+        if (target.layer.name) {
+          memo[target.layer.name] = proxy;
+        }
+        return memo;
+      }, []);
+      Object.defineProperty(ctx, 'targets', {value: proxies});
+      if (proxies.length == 1) {
+        Object.defineProperty(ctx, 'target', {value: proxies[0]});
+      }
+    }
+  }
+
+  function getTargetProxy(target) {
+    var proxy = getLayerInfo(target.layer, target.dataset); // layer_name, feature_count etc
+    proxy.layer = target.layer;
+    proxy.dataset = target.dataset;
+    addGetters(proxy, {
+      // export as an object, not a string or buffer
+      geojson: getGeoJSON
+    });
+
+    function getGeoJSON() {
+      var features = exportLayerAsGeoJSON(target.layer, target.dataset, {rfc7946: true}, true);
+      return {
+        type: 'FeatureCollection',
+        features: features
+      };
+    }
+
+    return proxy;
+  }
+
   function compileIfCommandExpression(expr, catalog, opts) {
     return compileLayerExpression(expr, catalog, opts);
   }
 
-
   function compileLayerExpression(expr, catalog, opts) {
     var targetId = opts.layer || opts.target || null;
     var targets = catalog.findCommandTargets(targetId);
@@ -35693,6 +36164,10 @@ ${svg}
     } else {
       ctx = getNullLayerProxy(targets);
     }
+
+    // add target/targets proxies, for consistency with the -run command
+    addTargetProxies(targets, ctx);
+
     ctx.global = defs; // TODO: remove duplication with mapshaper.expressions.mjs
     var func = compileExpressionToFunction(expr, opts);
 
@@ -38039,7 +38514,7 @@ ${svg}
         getPointFeatureBounds(shp) : targetDataset.arcs.getMultiShapeBounds(shp);
       bounds = applyRectangleOptions(bounds, crsInfo.crs, opts);
       if (!bounds) return null;
-      return convertBboxToGeoJSON(bounds.toArray(), opts);
+      return bboxToPolygon(bounds.toArray(), opts);
     });
     var geojson = {
       type: 'FeatureCollection',
@@ -38089,8 +38564,16 @@ ${svg}
     if (!bounds || !bounds.hasBounds()) {
       stop('Missing rectangle extent');
     }
-    var geojson = convertBboxToGeoJSON(bounds.toArray(), opts);
-    var dataset = importGeoJSON(geojson, {});
+    var feature = {
+      type: 'Feature',
+      properties: {},
+      geometry: bboxToPolygon(bounds.toArray(), opts)
+    };
+    if (opts.width > 0) {
+      feature.properties.width = opts.width;
+      feature.properties.type = 'frame';
+    }
+    var dataset = importGeoJSON(feature, {});
     dataset.layers[0].name = opts.name || 'rectangle';
     setDatasetCrsInfo(dataset, crsInfo);
     return dataset;
@@ -38140,17 +38623,13 @@ ${svg}
     return bounds;
   }
 
-  function convertBboxToGeoJSON(bbox, optsArg) {
+  function bboxToPolygon(bbox, optsArg) {
     var opts = optsArg || {};
-    var coords = [[bbox[0], bbox[1]], [bbox[0], bbox[3]], [bbox[2], bbox[3]],
-        [bbox[2], bbox[1]], [bbox[0], bbox[1]]];
+    var coords = bboxToCoords(bbox);
     if (opts.interval > 0) {
       coords = densifyPathByInterval(coords, opts.interval);
     }
-    return opts.geometry_type == 'polyline' ? {
-      type: 'LineString',
-      coordinates: coords
-    } : {
+    return {
       type: 'Polygon',
       coordinates: [coords]
     };
@@ -38159,7 +38638,7 @@ ${svg}
   var Rectangle = /*#__PURE__*/Object.freeze({
     __proto__: null,
     applyAspectRatio: applyAspectRatio,
-    convertBboxToGeoJSON: convertBboxToGeoJSON
+    bboxToPolygon: bboxToPolygon
   });
 
   function getSemiMinorAxis(P) {
@@ -38713,8 +39192,7 @@ ${svg}
     var rotation = getRotationParams(dest);
     if (!bbox) error('Missing expected clip bbox.');
     opts = Object.assign({interval: 0.5}, opts); // make sure edges can curve
-    var geojson = convertBboxToGeoJSON(bbox, opts);
-    var dataset = importGeoJSON(geojson);
+    var dataset = importGeoJSON(bboxToPolygon(bbox, opts));
     if (rotation) {
       rotateDataset(dataset, {rotation: rotation, invert: true});
     }
@@ -38903,7 +39381,7 @@ ${svg}
     var e = 1e-8;
     var bbox = [lon-e, -91, lon+e, 91];
     // densify (so cut line can curve, e.g. Cupola projection)
-    var geojson = convertBboxToGeoJSON(bbox, {interval: 0.5});
+    var geojson = bboxToPolygon(bbox, {interval: 0.5});
     var clip = importGeoJSON(geojson);
     clipLayersInPlace(pathLayers, clip, dataset, 'erase');
   }
@@ -39206,7 +39684,6 @@ ${svg}
 
   function createProjectedGraticule(dest, opts) {
     var src = parseCrsString('wgs84');
-    // var outline = getOutlineDataset(src, dest, {inset: 0, geometry_type: 'polyline'});
     var outline = getOutlineDataset(src, dest, {});
     var graticule = importGeoJSON(createGraticule(dest, !!outline, opts));
     projectDataset(graticule, src, dest, {no_clip: false}); // TODO: densify?
@@ -39388,7 +39865,6 @@ ${svg}
   }
 
   function skipCommand(cmdName, job) {
-    // allow all control commands to run
     if (jobIsStopped(job)) return true;
     if (isControlFlowCommand(cmdName)) return false;
     return !inActiveBranch(job);
@@ -39481,240 +39957,6 @@ ${svg}
     utils.extend(getStashedVar('defs'), obj);
   };
 
-  var MAX_RULE_LEN = 50;
-
-  cmd.info = function(targets, opts) {
-    var layers = expandCommandTargets(targets);
-    var arr = layers.map(function(o) {
-      return getLayerInfo(o.layer, o.dataset);
-    });
-
-    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);
-    }
-    if (opts.to_layer) {
-      return {
-        info: {},
-        layers: [{
-          name: opts.name || 'info',
-          data: new DataTable(arr)
-        }]
-      };
-    }
-    message(formatInfo(arr));
-  };
-
-  cmd.printInfo = cmd.info; // old name
-
-  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,
-      null_data_count: lyr.data ? countNullRecords(lyr.data.getRecords()) : n
-    };
-    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);
-    }
-    o.source_file = getLayerSourceFile(lyr, dataset) || null;
-    o.attribute_data = getAttributeTableInfo(lyr);
-    return o;
-  }
-
-  // i: (optional) record index
-  function getAttributeTableInfo(lyr, i) {
-    if (!lyr.data || lyr.data.size() === 0 || lyr.data.getFields().length === 0) {
-      return null;
-    }
-    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 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 formatLayerInfo(data) {
-    var str = '';
-    str += "Type:     " + (data.geometry_type || "tabular data") + "\n";
-    str += utils.format("Records:  %,d\n",data.feature_count);
-    if (data.null_shape_count > 0) {
-      str += utils.format("Nulls:     %'d", data.null_shape_count) + "\n";
-    }
-    if (data.geometry_type && data.feature_count > data.null_shape_count) {
-      str += "Bounds:   " + data.bbox.join(',') + "\n";
-      str += "CRS:      " + data.proj4 + "\n";
-    }
-    str += "Source:   " + (data.source_file || 'n/a') + "\n";
-    return str;
-  }
-
-  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)) {
-        max = Math.max(max, countIntegralChars(val));
-      }
-      return max;
-    }, 0);
-    var col1Arr = ['Field'].concat(fields);
-    var col2Arr = vals.reduce(function(memo, val) {
-      memo.push(formatTableValue(val, maxIntegralChars));
-      return memo;
-    }, [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 = '';
-    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 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) {
-    return arr.reduce(function(memo, str) {
-      var w = stringDisplayWidth(str);
-      return w > memo ? w : memo;
-    }, 0);
-  }
-
-  function formatString(str) {
-    var replacements = {
-      '\n': '\\n',
-      '\r': '\\r',
-      '\t': '\\t'
-    };
-    var cleanChar = function(c) {
-      // convert newlines and carriage returns
-      // TODO: better handling of non-printing chars
-      return c in replacements ? replacements[c] : '';
-    };
-    str = str.replace(/[\r\t\n]/g, cleanChar);
-    return "'" + str + "'";
-  }
-
-  function countIntegralChars(val) {
-    return utils.isNumber(val) ? (utils.formatNumber(val) + '.').indexOf('.') : 0;
-  }
-
-  function formatTableValue(val, integralChars) {
-    var str;
-    if (utils.isNumber(val)) {
-      str = utils.lpad("", integralChars - countIntegralChars(val), ' ') +
-        utils.formatNumber(val);
-    } else if (utils.isString(val)) {
-      str = formatString(val);
-    } else if (utils.isDate(val)) {
-      str = utils.formatDateISO(val) + ' (Date)';
-    } else if (utils.isObject(val)) { // if {} or [], display JSON
-      str = JSON.stringify(val);
-    } else {
-      str = String(val);
-    }
-
-    if (typeof str != 'string') {
-      // e.g. JSON.stringify converts functions to undefined
-      str = '[' + (typeof val) + ']';
-    }
-
-    return str;
-  }
-
-  var Info = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    getLayerInfo: getLayerInfo,
-    getAttributeTableInfo: getAttributeTableInfo,
-    formatAttributeTableInfo: formatAttributeTableInfo,
-    formatTableValue: formatTableValue
-  });
-
   // TODO: make sure that the inlay shapes and data are not shared
   cmd.inlay = function(targetLayers, src, targetDataset, opts) {
     var mergedDataset = mergeLayersForOverlay(targetLayers, targetDataset, src, opts);
@@ -42031,49 +42273,13 @@ ${svg}
     }, {});
   }
 
-  // import { importGeoJSON } from '../geojson/geojson-import';
-
-  function getTargetProxy(target) {
-    var proxy = getLayerInfo(target.layer, target.dataset); // layer_name, feature_count etc
-    proxy.layer = target.layer;
-    proxy.dataset = target.dataset;
-    addGetters(proxy, {
-      // export as an object, not a string or buffer
-      geojson: getGeoJSON
-    });
-
-    function getGeoJSON() {
-      var features = exportLayerAsGeoJSON(target.layer, target.dataset, {rfc7946: true}, true);
-      return {
-        type: 'FeatureCollection',
-        features: features
-      };
-    }
-
-    return proxy;
-  }
-
   // Support for evaluating expressions embedded in curly-brace templates
 
   // Returns: a string (e.g. a command string used by the -run command)
   async function evalTemplateExpression(expression, targets, ctx) {
     ctx = ctx || getBaseContext();
     // TODO: throw an error if target is used when there are multiple targets
-    if (targets) {
-      var proxies = expandCommandTargets(targets).reduce(function(memo, target) {
-        var proxy = getTargetProxy(target);
-        memo.push(proxy);
-        // index targets by layer name too
-        if (target.layer.name) {
-          memo[target.layer.name] = proxy;
-        }
-        return memo;
-      }, []);
-      Object.defineProperty(ctx, 'targets', {value: proxies});
-      if (proxies.length == 1) {
-        Object.defineProperty(ctx, 'target', {value: proxies[0]});
-      }
-    }
+    addTargetProxies(targets, ctx);
     // Add global functions and data to the expression context
     // (e.g. functions imported via the -require command)
     var globals = getStashedVar('defs') || {};
@@ -44564,6 +44770,10 @@ ${svg}
       return done(null);
     }
 
+    if (name == 'comment') {
+      return done(null);
+    }
+
     if (!job) job = new Job();
     job.startCommand(command);
 
@@ -44724,8 +44934,9 @@ ${svg}
       } else if (name == 'filter-slivers') {
         applyCommandToEachLayer(cmd.filterSlivers, targetLayers, targetDataset, opts);
 
-      } else if (name == 'frame') {
-        cmd.frame(job.catalog, source, opts);
+      // // 'frame' and 'rectangle' have merged
+      // } else if (name == 'frame') {
+      // cmd.frame(job.catalog, source, opts);
 
       } else if (name == 'fuzzy-join') {
         applyCommandToEachLayer(cmd.fuzzyJoin, targetLayers, arcs, source, opts);
@@ -44793,7 +45004,8 @@ ${svg}
         outputLayers = cmd.mosaic(targetLayers, targetDataset, opts);
 
       } else if (name == 'o') {
-        outputFiles = await exportTargetLayers(targets, opts);
+        // kludge
+        outputFiles = await exportTargetLayers(job.catalog, targets, opts);
         if (opts.final) {
           // don't propagate data if output is final
           //// catalog = null;
@@ -44826,7 +45038,10 @@ ${svg}
           cmd.proj(targ.dataset, job.catalog, opts);
         });
 
-      } else if (name == 'rectangle') {
+      } else if (name == 'rectangle' || name == 'frame') {
+        if (name == 'frame' && !opts.width) {
+          stop('Command requires a width= argument');
+        }
         if (source || opts.bbox || targets.length === 0) {
           job.catalog.addDataset(cmd.rectangle(source, opts));
         } else {
@@ -44992,7 +45207,7 @@ ${svg}
     });
   }
 
-  var version = "0.6.63";
+  var version = "0.6.66";
 
   // Parse command line args into commands and run them
   // Function takes an optional Node-style callback. A Promise is returned if no callback is given.
@@ -45734,6 +45949,7 @@ ${svg}
     Projections,
     ProjectionParams,
     Rectangle,
+    RectangleUtils,
     Rounding,
     RunCommands,
     Scalebar,