mapshaper 0.7.67 → 0.7.69

package/mapshaper.js

@@ -25424,6 +25424,9 @@
   // type/data accessors -- doesn't form an import cycle with the
   // scalebar-aware renderer registry that lives in furniture.mjs.
 
+  // Must match the renderers registered in mapshaper-furniture.mjs
+  var furnitureTypes = ['scalebar'];
+
   // @lyr dataset layer
   function getFurnitureLayerType(lyr) {
     var rec = lyr.data && lyr.data.getReadOnlyRecordAt(0);
@@ -25434,6 +25437,12 @@
     return lyr.data && lyr.data.getReadOnlyRecordAt(0);
   }
 
+  // A data-only layer holding the settings of a map element such as a scalebar
+  function layerIsFurniture(lyr) {
+    return !!lyr && !lyr.geometry_type &&
+      furnitureTypes.includes(getFurnitureLayerType(lyr));
+  }
+
   /*
   {
     width: size[0],
@@ -25629,6 +25638,27 @@
     });
   }
 
+  // Furniture (scalebars, etc.) belongs to a frame by sharing its dataset.
+  // Furniture in a dataset without a frame is an ordinary standalone layer.
+  function getFrameFurnitureLayers(dataset) {
+    if (!dataset || !findFrameLayerInDataset(dataset)) return [];
+    return dataset.layers.filter(layerIsFurniture);
+  }
+
+  function findFrameFurnitureLayer(dataset, type) {
+    return getFrameFurnitureLayers(dataset).find(function(lyr) {
+      return getFurnitureLayerType(lyr) == type;
+    }) || null;
+  }
+
+  // True for a map frame and for the furniture that belongs to it: layers that
+  // describe the map layout rather than holding map content.
+  function isFrameComponentLayer(lyr, dataset) {
+    if (!dataset) return false;
+    if (isFrameLayer(lyr, dataset.arcs)) return true;
+    return layerIsFurniture(lyr) && !!findFrameLayerInDataset(dataset);
+  }
+
   function findFrames(catalog) {
     return catalog.getLayers().filter(function(o) {
       return isFrameLayer(o.layer, o.dataset.arcs);
@@ -25855,6 +25885,7 @@
     demoteFrameLayer: demoteFrameLayer,
     findFrame: findFrame,
     findFrameDataset: findFrameDataset,
+    findFrameFurnitureLayer: findFrameFurnitureLayer,
     findFrameLayer: findFrameLayer,
     findFrameLayerInDataset: findFrameLayerInDataset,
     findFrames: findFrames,
@@ -25863,11 +25894,13 @@
     frameReservedFields: frameReservedFields,
     getActiveFrame: getActiveFrame,
     getFrameData: getFrameData,
+    getFrameFurnitureLayers: getFrameFurnitureLayers,
     getFrameLayerBounds: getFrameLayerBounds,
     getFrameLayerData: getFrameLayerData,
     getFrameSize: getFrameSize,
     getMapFrameMetersPerPixel: getMapFrameMetersPerPixel,
     getSingleFrameRecord: getSingleFrameRecord,
+    isFrameComponentLayer: isFrameComponentLayer,
     isFrameLayer: isFrameLayer,
     isFrameReservedField: isFrameReservedField,
     parseFrameSize: parseFrameSize,
@@ -25875,12 +25908,53 @@
     resolveExportFrame: resolveExportFrame
   });
 
+  // Adds a furniture layer as a standalone dataset, without changing the
+  // default target (so a following -o still exports the content layers)
   function addFurnitureLayer(lyr, catalog) {
     var o = {
       info: {},
       layers: [lyr]
     };
+    catalog.captureCatalogBefore({operation: 'addFurnitureLayer'});
     catalog.getDatasets().push(o);
+    catalog.markCatalogChanged({operation: 'addFurnitureLayer'});
+  }
+
+  // Adds a furniture layer to a frame's dataset, replacing any existing
+  // furniture of the same type. Passing a null layer removes it.
+  // Returns the replaced or removed layer, if any
+  function setFrameFurnitureLayer(frameDataset, type, lyr) {
+    var layers = frameDataset.layers;
+    var idx = layers.findIndex(function(o) {
+      return layerIsFurniture(o) && getFurnitureLayerType(o) == type;
+    });
+    var prev = idx > -1 ? layers[idx] : null;
+    if (!prev && !lyr) return null;
+    noteDatasetWillChange(frameDataset, {operation: 'setFrameFurniture', unit: 'layers'});
+    layers = layers.slice();
+    if (prev && lyr) {
+      lyr.name = prev.name;
+      layers[idx] = lyr;
+    } else if (prev) {
+      layers.splice(idx, 1);
+    } else {
+      layers.push(lyr);
+    }
+    frameDataset.layers = layers;
+    markDatasetChanged(frameDataset, {operation: 'setFrameFurniture', unit: 'layers'});
+    return prev;
+  }
+
+  // Moves a replaced frame's furniture into the dataset of the frame replacing it
+  function moveFrameFurniture(fromDataset, toDataset) {
+    var furniture = fromDataset.layers.filter(layerIsFurniture);
+    if (furniture.length === 0) return;
+    noteDatasetWillChange(fromDataset, {operation: 'moveFrameFurniture', unit: 'layers'});
+    fromDataset.layers = fromDataset.layers.filter(function(lyr) {
+      return !furniture.includes(lyr);
+    });
+    markDatasetChanged(fromDataset, {operation: 'moveFrameFurniture', unit: 'layers'});
+    toDataset.layers = toDataset.layers.concat(furniture);
   }
 
   // Pure geometry-to-SVG-path primitives. Extracted from geojson-to-svg.mjs
@@ -27236,9 +27310,16 @@
   // The two copies are identical apart from their paint, so they sit in exactly
   // the same place whatever the label's position, alignment or path.
   //
-  // The halo copy is unfilled. That matches paint-order, where the fill covers
-  // the stroke's inner half and nothing else, and it keeps a translucent fill
-  // from showing a second colour through it.
+  // The halo copy is unfilled, which matches paint-order, where the fill covers
+  // the stroke's inner half and nothing else. Its halo-opacity is written as
+  // opacity rather than stroke-opacity, which Illustrator ignores on import; the
+  // two look the same on a copy with nothing painted but its stroke.
+  //
+  // Illustrator's GPU preview compounds a translucent halo where glyphs
+  // overlap; its CPU preview and its output do not. Nothing in the SVG was
+  // found to avoid it: filling the copy (imported as two objects, and no
+  // better), and putting the opacity on a group or two nested groups around
+  // the copy, all show the same thing.
   //
   // Things that apply to the label as a whole move to the group: its transform,
   // which places it, and its opacity, which would otherwise fade each copy on its
@@ -27269,6 +27350,10 @@
     delete halo.properties['paint-order'];
     delete halo.properties['fill-opacity'];
     halo.properties.fill = 'none';
+    if ('stroke-opacity' in halo.properties) {
+      halo.properties.opacity = halo.properties['stroke-opacity'];
+      delete halo.properties['stroke-opacity'];
+    }
     HALO_STROKE_PROPERTIES.forEach(function(k) {
       delete text.properties[k];
     });
@@ -27340,6 +27425,23 @@
   // different one would put the label somewhere it is not drawn.
   var DEFAULT_LABEL_FONT_SIZE = 12;
 
+  // The line height a label is drawn with when it carries none, as a multiple of
+  // its font size.
+  var DEFAULT_LINE_HEIGHT = 1.1;
+
+  // The dy of each line after a label's first, from its line-height.
+  //
+  // A bare number is a multiple of the font size, as in CSS, and not px, as a
+  // bare dy would be in SVG -- so it is written in ems. Nobody who types 1.3
+  // into a field called line height wants lines 1.3px apart, and a multiple
+  // keeps its proportions when the font size changes. Values with units are
+  // passed through.
+  function getLineHeightDy(val) {
+    var measure = val === undefined || val === null || val === '' ?
+      DEFAULT_LINE_HEIGHT : parseSvgMeasure(val);
+    return utils.isFiniteNumber(measure) ? measure + 'em' : measure;
+  }
+
   function toLabelString(val) {
     if (val || val === 0 || val === false) return String(val);
     return '';
@@ -27387,7 +27489,7 @@
           value: line,
           properties: {
             x: dx,
-            dy: rec['line-height'] || '1.1em'
+            dy: getLineHeightDy(rec['line-height'])
           }
         };
         obj.children.push(tspan);
@@ -27481,8 +27583,10 @@
   var SvgLabels = /*#__PURE__*/Object.freeze({
     __proto__: null,
     DEFAULT_LABEL_FONT_SIZE: DEFAULT_LABEL_FONT_SIZE,
+    DEFAULT_LINE_HEIGHT: DEFAULT_LINE_HEIGHT,
     LABEL_SOFT_BREAK: LABEL_SOFT_BREAK,
     getDrawnLabelOffset: getDrawnLabelOffset,
+    getLineHeightDy: getLineHeightDy,
     labelNewlineRxp: labelNewlineRxp,
     removeSoftBreaks: removeSoftBreaks,
     renderLabel: renderLabel$1,
@@ -27505,7 +27609,6 @@
 
   var DEFAULT_PADDING$1 = 3;
   var DEFAULT_LINE_WIDTH = 1;
-  var DEFAULT_LINE_HEIGHT = '1.1em';
   // Space left between the anchor's symbol and the end of the line
   var SYMBOL_CLEARANCE = 2;
   // How far an automatic curve bows out, as a fraction of its chord
@@ -27526,6 +27629,9 @@
   var ASCENT = 0.8;
   var DESCENT = 0.2;
   var MIDLINE = 0.35;
+  // Average advance of a character, in ems, for estimating the width of text
+  // that cannot be measured
+  var AVERAGE_CHAR_WIDTH = 0.6;
 
   function labelHasCallout(rec) {
     var type = rec && rec.callout ? parseCalloutType(rec.callout) : null;
@@ -27589,18 +27695,24 @@
   // no measurement the box takes the label's width if it is a text block, and is
   // otherwise a vertical line through the text's origin -- a callout then meets
   // the text where it starts rather than not being drawn.
-  function getLabelTextBox(rec) {
+  //
+  // opts.estimate_width: with no measurement and no label-width, estimate the
+  //   width from the length of the longest line instead of taking it as zero
+  function getLabelTextBox(rec, opts) {
     var fontSize = getFontSizeInPx$1(rec);
     var offset = getDrawnLabelOffset(rec);
     var lines = splitLabelLines(toLabelString(rec['label-text']));
-    var lineHeight = measureToPx(rec['line-height'] || DEFAULT_LINE_HEIGHT, fontSize);
+    var lineHeight = measureToPx(getLineHeightDy(rec['line-height']), fontSize);
     var width = getMeasuredTextWidth(rec) || getNumber(rec['label-width'], 0);
+    if (!width && opts && opts.estimate_width) {
+      width = estimateTextWidth(lines, fontSize);
+    }
     // An anchor the record does not set is inherited from the layer's group,
     // which is 'middle' -- see getLabelTextDefaults().
     var anchor = offset['text-anchor'] || 'middle';
     var xmin = offset.dx - width * (anchor == 'middle' ? 0.5 : anchor == 'end' ? 1 : 0);
     var baseline = offset.dy + getBaselineShift(rec['dominant-baseline']) * fontSize;
-    if (!(lineHeight > 0)) lineHeight = fontSize * 1.1;
+    if (!(lineHeight > 0)) lineHeight = fontSize * DEFAULT_LINE_HEIGHT;
     return {
       xmin: xmin,
       xmax: xmin + width,
@@ -27610,6 +27722,18 @@
     };
   }
 
+  function estimateTextWidth(lines, fontSize) {
+    var chars = lines.reduce(function(max, line) {
+      return Math.max(max, Array.from(line).length);
+    }, 0);
+    return chars * AVERAGE_CHAR_WIDTH * fontSize;
+  }
+
+  // The size a label's text is drawn at, in px
+  function getLabelFontSize(rec) {
+    return getFontSizeInPx$1(rec);
+  }
+
   // Where a line meets a callout's text and how it gets there from the anchor.
   //
   // o.type     'line', 'elbow' or 'curve'
@@ -27636,7 +27760,7 @@
   // point where the line meets it, the elbow's corner or the curve's midpoint
   // (null for a straight line), and where the line stops short of the anchor.
   function getCalloutShape(o) {
-    var box = padBox(o.box, o.padding || 0);
+    var box = padBox$1(o.box, o.padding || 0);
     var a = [0, 0];
     var size = o.endSize > 0 ? o.endSize : getDefaultCalloutEndSize(o.end, o.width);
     var t, v, path, tip, dir, out, lineWidth, headLen, curved;
@@ -27997,7 +28121,7 @@
 
   // Utilities
 
-  function padBox(box, pad) {
+  function padBox$1(box, pad) {
     return {
       xmin: box.xmin - pad,
       xmax: box.xmax + pad,
@@ -28070,6 +28194,7 @@
     getControlPoint: getControlPoint,
     getDefaultCalloutEndSize: getDefaultCalloutEndSize,
     getLabelCalloutShape: getLabelCalloutShape,
+    getLabelFontSize: getLabelFontSize,
     getLabelTextBox: getLabelTextBox,
     labelHasCallout: labelHasCallout,
     renderLabelCallout: renderLabelCallout
@@ -28366,28 +28491,68 @@
 
   var SvgSymbols = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    featureHasIcon: featureHasIcon,
     getAnchorSymbolRadius: getAnchorSymbolRadius,
+    getIconRadius: getIconRadius,
     getTransform: getTransform,
     renderPoint: renderPoint,
     symbolRenderers: symbolRenderers
   });
 
+  // Command options that are stored in the scalebar's data record
+  var scalebarFields = ['label', 'units', 'style', 'font_size', 'font_family',
+    'font_style', 'font_weight', 'color', 'tic_length', 'bar_width', 'label_offset',
+    'position', 'label_position', 'dual_units', 'margin'];
+
+  // With a map frame, the scalebar belongs to the frame, and running the
+  // command again replaces it. Without a frame, each run adds a standalone
+  // scalebar layer, which is exported if it is included in the output layers.
   cmd.scalebar = function(catalog, opts) {
+    var frame = getActiveFrame(catalog);
+    if (opts.remove) {
+      if (!frame || !setFrameFurnitureLayer(frame.dataset, 'scalebar', null)) {
+        stop$1('The map frame has no scalebar to remove');
+      }
+      return;
+    }
+    validateScalebarOpts(opts);
     var lyr = getScalebarLayer(opts);
-    if (opts.label && !parseScalebarUnits(opts.label)) {
-      stop$1(`Expected units of km or miles in scalebar label (received ${opts.label})`);
+    if (frame) {
+      setFrameFurnitureLayer(frame.dataset, 'scalebar', lyr);
+    } else {
+      addFurnitureLayer(lyr, catalog);
     }
-    addFurnitureLayer(lyr, catalog);
   };
 
   function getScalebarLayer(opts) {
-    var obj = utils.defaults({type: 'scalebar'}, opts);
+    var rec = {type: 'scalebar'};
+    scalebarFields.forEach(function(k) {
+      if (opts[k] !== undefined && opts[k] !== null && opts[k] !== '') {
+        rec[k] = opts[k];
+      }
+    });
     return {
-      name: opts.name || 'scalebar',
-      data: new DataTable([obj])
+      name: 'scalebar',
+      data: new DataTable([rec])
     };
   }
 
+  function validateScalebarOpts(opts) {
+    if (opts.label) {
+      splitScalebarLabel(opts.label).forEach(function(str) {
+        if (!parseScalebarUnits(str) && !isBareDistance(str)) {
+          stop$1(`Expected a distance or units of km, meters, miles or feet in scalebar label (received ${str})`);
+        }
+      });
+    }
+    if (opts.units && !parseLabelUnits(opts.units)) {
+      stop$1('Unsupported scalebar units:', opts.units);
+    }
+    if (opts.style && !/^[ab]$/i.test(opts.style)) {
+      stop$1('Unsupported scalebar style:', opts.style);
+    }
+  }
+
   function renderScalebar(d, frame) {
     if (!frame.crs) {
       message('Unable to render scalebar: unknown CRS.');
@@ -28400,14 +28565,15 @@
     var opts = getScalebarOpts(d);
     var metersPerPx = getMapFrameMetersPerPixel(frame);
     var frameWidthPx = frame.width;
-    var labels = d.label ? d.label.split(',') : null;
-    var label1 = labels && labels[0] || null;
-    var props1 = parseScalebarLabel(label1 || getAutoScalebarLabel(frameWidthPx, metersPerPx, 'mile'));
-    var label2 = opts.style == 'b' && labels && labels[1] || null;
+    var labels = d.label ? splitScalebarLabel(d.label) : [];
+    var units = parseLabelUnits(d.units) || 'mile';
+    var label1 = getScalebarLabel(labels[0], frameWidthPx, metersPerPx, units);
+    var props1 = parseScalebarLabel(label1);
+    var label2 = null;
     var props2, length2;
 
     if (props1.km > 0 === false) {
-      message('Unusable scalebar label:', label1);
+      message('Unusable scalebar label:', labels[0] || '');
       return [];
     }
 
@@ -28416,6 +28582,11 @@
       stop$1("Null scalebar length");
     }
 
+    if (opts.style == 'b' && labels[1]) {
+      label2 = completeLabel(labels[1], getOtherUnits(props1.units));
+    } else if (opts.style == 'b' && opts.dual_units) {
+      label2 = getAutoSecondLabel(length1, metersPerPx, getOtherUnits(props1.units));
+    }
     if (label2) {
       props2 = parseScalebarLabel(label2);
       length2 = Math.round(props2.km / metersPerPx * 1000);
@@ -28468,8 +28639,13 @@
   };
 
   function getScalebarOpts(d) {
-    var style = d.style == 'b' || d.style == 'B' ? 'b' : 'a';
-    return Object.assign({}, defaultOpts, styleOpts[style], d, {style: style});
+    var style = d.style == 'b' || d.style == 'B' || !d.style && d.dual_units ? 'b' : 'a';
+    var opts = Object.assign({}, defaultOpts, styleOpts[style]);
+    Object.keys(d).forEach(function(k) {
+      if (d[k] !== undefined && d[k] !== null && d[k] !== '') opts[k] = d[k];
+    });
+    opts.style = style;
+    return opts;
   }
 
   function renderAsSvg(length, text, length2, text2, opts) {
@@ -28487,12 +28663,11 @@
     };
   }
 
-  // TODO: generalize to other kinds of furniture as they are developed
   function getScalebarPosition(opts) {
     var pos = opts.position || 'top-left';
     return {
-      ypos: pos.includes('top') ? 'top' : 'bottom',
-      xpos: pos.includes('left') ? 'left' : 'right'
+      ypos: pos.includes('bottom') ? 'bottom' : 'top',
+      xpos: pos.includes('right') ? 'right' : 'left'
     };
   }
 
@@ -28506,12 +28681,16 @@
         'label-text': text,
         'font-size': opts.font_size,
         'text-anchor': labelPos.anchor,
-        'dominant-baseline': labelPos.ypos == 'top' ? 'auto' : 'hanging'
+        'dominant-baseline': labelPos.ypos == '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)
       };
+    if (opts.color) labelOpts.fill = opts.color;
+    if (opts.font_family) labelOpts['font-family'] = opts.font_family;
+    if (opts.font_style) labelOpts['font-style'] = opts.font_style;
+    if (opts.font_weight) labelOpts['font-weight'] = opts.font_weight;
     return symbolRenderers.label(labelOpts, anchorX, anchorY);
   }
 
@@ -28571,7 +28750,7 @@
     }
     var bar = importMultiLineString(coords);
     Object.assign(bar.properties, {
-      stroke: 'black',
+      stroke: opts.color || 'black',
       fill: 'none',
       'stroke-width': opts.bar_width,
       'stroke-linecap': 'butt',
@@ -28580,35 +28759,132 @@
     return bar;
   }
 
-  // unit: 'km' || 'mile'
+  // Kilometers per unit
+  var unitSizes = {
+    km: 1,
+    m: 0.001,
+    mile: 1.60934,
+    ft: 0.0003048
+  };
+
+  // Candidate lengths for automatic labels, in ascending order of distance
+  var autoLengths = {
+    imperial: [
+      ['ft', '10 20 25 50 100 200 250 500'],
+      // note: removed 1.5 12 and 1,200
+      ['mile', '1/8 1/5 1/4 1/2 1 2 3 4 5 8 10 15 20 25 30 40 50 75 100 150 200 250 ' +
+        '300 350 400 500 750 1,000 1,500 2,000 2,500 3,000 4,000 5,000']
+    ],
+    metric: [
+      ['m', '5 10 20 25 50 100 200 250 500'],
+      ['km', '1 2 3 4 5 8 10 15 20 25 30 40 50 75 100 150 200 250 300 350 ' +
+        '400 500 750 1,000 1,500 2,000 2,500 3,000 4,000 5,000']
+    ]
+  };
+
+  function getAutoLabels(system) {
+    return autoLengths[system].reduce(function(memo, group) {
+      return memo.concat(group[1].split(' ').map(function(str) {
+        return formatDistanceLabel(str, group[0]);
+      }));
+    }, []);
+  }
+
+  function getUnitSystem(units) {
+    return units == 'km' || units == 'm' ? 'metric' : 'imperial';
+  }
+
+  function getOtherUnits(units) {
+    return getUnitSystem(units) == 'metric' ? 'mile' : 'km';
+  }
+
+  // The unit system of the units= option: returns 'km', 'mile' or ''
+  function parseUnitsOption(str) {
+    var units = parseLabelUnits(str);
+    return units ? (getUnitSystem(units) == 'metric' ? 'km' : 'mile') : '';
+  }
+
+  // Accepts the units= option, which also gives the units of a label that is a
+  // bare number; returns 'km', 'm', 'mile', 'ft' or ''
+  function parseLabelUnits(str) {
+    var s = String(str || '').toLowerCase();
+    if (/^(km|kilomet(er|re)s?|metric)$/.test(s)) return 'km';
+    if (/^(m|meters?|metres?)$/.test(s)) return 'm';
+    if (/^(mi|miles?|imperial)$/.test(s)) return 'mile';
+    if (/^(ft|feet)$/.test(s)) return 'ft';
+    return '';
+  }
+
+  // Splits a dual-unit label like "100 km,50 miles". Only a comma after the units
+  // separates two distances, so "1,000 km" and a bare "1,500" stay whole.
+  function splitScalebarLabel(label) {
+    return String(label).split(/(?<=[^\d\s]),\s*/).map(function(str) {
+      return str.trim();
+    }).filter(Boolean);
+  }
+
+  // A distance with no units, e.g. "150" or "1/2" or "1,000"
+  function isBareDistance(str) {
+    return /^[\d\s.,/]+$/.test(str) && parseScalebarNumber(str) > 0;
+  }
+
+  // Adds units to a label that is a bare number
+  function completeLabel(label, units) {
+    return isBareDistance(label) ? formatDistanceLabel(label.trim(), units) : label;
+  }
+
+  // label: a label from the label= option, or empty for an automatic label
+  function getScalebarLabel(label, frameWidthPx, metersPerPx, defaultUnits) {
+    var units;
+    if (label && parseScalebarNumber(label) > 0) return completeLabel(label, defaultUnits);
+    // A label with units but no number gets an automatic length in those units
+    units = label && parseScalebarUnits(label) || defaultUnits;
+    return getAutoScalebarLabel(frameWidthPx, metersPerPx, units);
+  }
+
+  // unit: 'km' || 'mile' (or 'm', 'ft' for the same systems)
+  // The longest length that fits within 20% of the map's width, or the shortest
+  // that is at least 70px long if the map is too narrow for that
   function getAutoScalebarLabel(mapWidth, metersPerPx, unit) {
-    var minWidth = 70; // 100; // TODO: vary min size based on map width
-    var minKm = metersPerPx * minWidth / 1000;
-    // note: removed 1.5 12 and 1,200
-    var options = ('1/8 1/5 1/4 1/2 1 2 3 4 5 8 10 15 20 25 30 40 50 75 ' +
-      '100 150 200 250 300 350 400 500 750 1,000 1,500 2,000 ' +
-      '2,500 3,000 4,000 5,000').split(' ');
-    return options.reduce(function(memo, str) {
-      if (memo) return memo;
-      var label = formatDistanceLabel(str, unit);
-      if (parseScalebarLabelToKm(label) > minKm) {
-         return label;
-      }
-    }, null) || '';
+    var minKm = metersPerPx * 70 / 1000;
+    var maxKm = metersPerPx * mapWidth * 0.2 / 1000;
+    var labels = getAutoLabels(getUnitSystem(unit));
+    var longest = labels.filter(function(label) {
+      var km = parseScalebarLabelToKm(label);
+      return km >= minKm && km <= maxKm;
+    }).pop();
+    return longest || labels.find(function(label) {
+      return parseScalebarLabelToKm(label) >= minKm;
+    }) || '';
+  }
+
+  // The longest automatic length in the given units that fits within the
+  // first part of a dual-unit scalebar
+  function getAutoSecondLabel(maxPx, metersPerPx, unit) {
+    var maxKm = maxPx * metersPerPx / 1000;
+    var minKm = maxKm / 4;
+    var labels = getAutoLabels(getUnitSystem(unit)).filter(function(label) {
+      var km = parseScalebarLabelToKm(label);
+      return km <= maxKm && km >= minKm;
+    });
+    return labels.pop() || null;
   }
 
   function formatDistanceLabel(numStr, unit) {
     var num = parseScalebarNumber(numStr);
-    var unitStr = unit == 'km' && 'KM' || num > 1 && 'MILES' || 'MILE';
+    var unitStr = unit == 'km' && 'KM' ||
+      unit == 'm' && (num > 1 ? 'METERS' : 'METER') ||
+      unit == 'ft' && (num > 1 ? 'FEET' : 'FOOT') ||
+      num > 1 && 'MILES' || 'MILE';
     return numStr + ' ' + unitStr;
   }
 
-  // See test/mapshaper-scalebar.js for examples of supported formats
+  // See test/scalebar-test.mjs for examples of supported formats
   function parseScalebarLabelToKm(str) {
     var units = parseScalebarUnits(str);
     var value = parseScalebarNumber(str);
     if (!units || !value) return NaN;
-    return units == 'mile' ? value * 1.60934 : value;
+    return value * unitSizes[units];
   }
 
   function parseScalebarLabel(label) {
@@ -28616,7 +28892,7 @@
     var units = label ? parseScalebarUnits(label) : 'mile';
     var km = NaN;
     if (units && num) {
-      km =  units == 'mile' ? num * 1.60934 : num;
+      km = num * unitSizes[units];
     }
     return {
       number: num,
@@ -28625,11 +28901,14 @@
     };
   }
 
+  // Returns 'km', 'm', 'mile', 'ft' or ''
   function parseScalebarUnits(str) {
-    var isMiles = /(miles?|mi[.]?|英里)$/.test(str.toLowerCase());
-    var isKm = /(k\.m\.|km|kilometers?|kilom.tres?|公里)$/.test(str.toLowerCase());
-    var units = isMiles && 'mile' || isKm && 'km' || '';
-    return units;
+    var s = String(str).trim().toLowerCase();
+    if (/(miles?|mi[.]?|英里)$/.test(s)) return 'mile';
+    if (/(k\.m\.|km|kilomet(er|re)s?|kilom.tres?|公里)$/.test(s)) return 'km';
+    if (/(^|[\d\s.])(feet|foot|ft[.]?|英尺)$/.test(s)) return 'ft';
+    if (/(^|[\d\s.])(m|m\.|meters?|metres?|mètres?|米)$/.test(s)) return 'm';
+    return '';
   }
 
   function parseScalebarNumber(str) {
@@ -28649,8 +28928,12 @@
     __proto__: null,
     formatDistanceLabel: formatDistanceLabel,
     getScalebarLayer: getScalebarLayer,
+    parseLabelUnits: parseLabelUnits,
     parseScalebarLabelToKm: parseScalebarLabelToKm,
-    renderScalebar: renderScalebar
+    parseScalebarUnits: parseScalebarUnits,
+    parseUnitsOption: parseUnitsOption,
+    renderScalebar: renderScalebar,
+    splitScalebarLabel: splitScalebarLabel
   });
 
   var furnitureRenderers = {
@@ -28672,24 +28955,33 @@
   function renderFurnitureLayer(lyr, frame) {
     var d = getFurnitureLayerData(lyr);
     var renderer = furnitureRenderers[d.type];
+    var problem;
     if (!renderer) {
       stop$1('Missing renderer for', d.type, 'element');
     }
-    if (!frame.crs) {
-      stop$1(`Unable to render ${d.type} (unknown map projection)`);
-    }
-    if (!isProjectedCRS(frame.crs)) {
-      stop$1(`Unable to render ${d.type} (map is unprojected)`);
+    problem = getFurnitureFrameProblem(frame);
+    if (problem) {
+      stop$1(`Unable to render ${d.type} (${problem})`);
     }
     return renderer(d, frame) || [];
   }
 
+  // Returns a reason why furniture can't be drawn in a frame, or null
+  function getFurnitureFrameProblem(frame) {
+    if (!frame) return 'missing map frame';
+    if (!frame.crs) return 'unknown map projection';
+    if (!isProjectedCRS(frame.crs)) return 'map is unprojected';
+    return null;
+  }
+
   var Furniture = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    getFurnitureFrameProblem: getFurnitureFrameProblem,
     getFurnitureLayerData: getFurnitureLayerData,
     getFurnitureLayerType: getFurnitureLayerType,
     isFurnitureLayer: isFurnitureLayer,
     layerHasFurniture: layerHasFurniture,
+    layerIsFurniture: layerIsFurniture,
     renderFurnitureLayer: renderFurnitureLayer
   });
 
@@ -39146,6 +39438,9 @@ ${svg}
   async function exportDatasets(datasets, opts) {
     var format = getOutputFormat(datasets[0], opts);
     var files;
+    if (format != 'svg' && format != PACKAGE_EXT) {
+      datasets = removeFurnitureLayers(datasets);
+    }
     validateRasterExportFormat(datasets, format);
     if (format != 'geoparquet' && opts.level !== undefined) {
       error('The level= option only applies to GeoParquet output');
@@ -39221,6 +39516,25 @@ ${svg}
     return files;
   }
 
+  // Scalebars and other map furniture only have a meaning in SVG output
+  function removeFurnitureLayers(datasets) {
+    var hasFurniture = datasets.some(function(dataset) {
+      return dataset.layers.some(layerIsFurniture);
+    });
+    if (!hasFurniture) return datasets;
+    datasets = datasets.map(function(dataset) {
+      return utils.defaults({
+        layers: dataset.layers.filter(function(lyr) { return !layerIsFurniture(lyr); })
+      }, dataset);
+    }).filter(function(dataset) {
+      return dataset.layers.length > 0;
+    });
+    if (datasets.length === 0) {
+      stop$1('Map furniture layers (e.g. scalebars) can only be exported as SVG');
+    }
+    return datasets;
+  }
+
   function validateRasterExportFormat(datasets, format) {
     if (format == 'geotiff') {
       if (datasetsHaveVectorLayers(datasets)) {
@@ -41392,7 +41706,7 @@ ${svg}
           'font-weight': {describe: 'normal, bold or a numeric weight'},
           'font-stretch': {describe: 'e.g. condensed'},
           'letter-spacing': {describe: 'extra space between letters'},
-          'line-height': {describe: 'spacing between lines of a multi-line label'},
+          'line-height': {describe: 'spacing between lines of a multi-line label; a bare number is a multiple of the font size'},
           'text-anchor': {describe: 'start, middle or end'},
           'label-align': {describe: 'how the lines of a multi-line label align: left, center or right'},
           'dominant-baseline': {describe: 'vertical alignment, e.g. central'},
@@ -43478,7 +43792,7 @@ ${svg}
         describe: 'CSS letter-spacing property of labels'
       })
        .option('line-height', {
-        describe: 'line spacing of multi-line labels (default is 1.1em)'
+        describe: 'line spacing of multi-line labels; a bare number is a multiple of the font size, as in CSS (default is 1.1)'
       })
       .option('dominant-baseline', {
         describe: 'vertical alignment of labels (e.g. central)'
@@ -43812,6 +44126,13 @@ ${svg}
         describe: 'frame coordinates (xmin,ymin,xmax,ymax)',
         type: 'bbox'
       })
+      .option('fit', {
+        describe: 'layer(s) to fit the frame to, including their symbols and labels'
+      })
+      .option('ignore-symbols', {
+        describe: 'with fit=, fit to point locations, not symbol and label extents',
+        type: 'flag'
+      })
       .option('width', {
         describe: 'nominal frame width (e.g. 5in, 10cm, 600px)'
       })
@@ -43963,6 +44284,10 @@ ${svg}
         describe: 'separate offsets for each side, in l,b,r,t order',
         type: 'strings'
       })
+      .option('ignore-symbols', {
+        describe: 'fit to point locations, not the extent of symbols and labels',
+        type: 'flag'
+      })
       .option('name', nameOpt)
       .option('replace', {
         describe: 'replace the existing map frame',
@@ -44067,10 +44392,13 @@ ${svg}
       .option('target', targetOpt);
 
     parser.command('scalebar')
-      .describe('add a simple scale bar to SVG output')
+      .describe('add a scale bar to the map frame and SVG output')
       .option('label', {
         DEFAULT: true,
-        describe: 'distance label, e.g. "35 miles"'
+        describe: 'distance label, e.g. "35 miles" (default is automatic)'
+      })
+      .option('units', {
+        describe: 'units of a bare-number or automatic label: km, meters, miles or feet (default is miles)'
       })
       .option('style', {
         describe: 'two options: a or b'
@@ -44078,6 +44406,18 @@ ${svg}
       .option('font-size', {
         type: 'number'
       })
+      .option('font-family', {
+        describe: 'font family of labels'
+      })
+      .option('font-style', {
+        describe: 'font style of labels, e.g. italic'
+      })
+      .option('font-weight', {
+        describe: 'font weight of labels, e.g. bold'
+      })
+      .option('color', {
+        describe: 'color of bar and labels (default is black)'
+      })
       .option('tic-length', {
         describe: 'length of tic marks (style b)',
         type: 'number'
@@ -44090,18 +44430,22 @@ ${svg}
         type: 'number'
       })
       .option('position', {
-        describe: 'e.g. bottom-right (default is top-left)'
+        describe: 'top-left (default), top-right, bottom-left or bottom-right'
       })
       .option('label-position', {
         describe: 'top, bottom, top-center (style a), etc'
       })
       .option('dual-units', {
-        // describe: 'display both metric and imperial units',
+        describe: 'show both metric and imperial units (style b)',
         type: 'flag'
       })
       .option('margin', {
         describe: 'offset in pixels from edge of map',
         type: 'number'
+      })
+      .option('remove', {
+        describe: 'remove the scale bar from the map frame',
+        type: 'flag'
       });
 
     parser.command('shape')
@@ -51575,8 +51919,639 @@ ${svg}
     bboxToPolygon: bboxToPolygon
   });
 
+  // Apply rotation, scale and/or shift to some or all of the features in a dataset
+  //
+  cmd.affine = function(targetLayers, dataset, opts) {
+    // Need to separate the targeted shapes from any other shapes that share
+    // the same topology. So we duplicate any arcs that are shared by the targeted
+    // shapes and their topological neighbors and remap arc references in the
+    // neighbors to point to the copies.
+    // TODO: explore alternative: if some arcs are shared between transformed and
+    //   non-transformed shapes, first remove topology, then tranform, then rebuild topology
+    //
+    var rotateArg = opts.rotate || 0;
+    var scaleArg = opts.scale || 1;
+    var shiftArg = opts.shift ? convertIntervalPair(opts.shift, getDatasetCRS(dataset)) : [0, 0];
+    var arcs = dataset.arcs;
+    var targetShapes = [];
+    var otherShapes = [];
+    var targetPoints = [];
+    var targetPointLayers = [];
+    var targetFlags, otherFlags, transform;
+    dataset.layers.filter(layerHasGeometry$1).forEach(function(lyr) {
+      var hits = [],
+          misses = [],
+          test;
+      if (targetLayers.indexOf(lyr) == -1) {
+        misses = lyr.shapes;
+      } else if (opts.where) {
+        test = compileFeatureExpression(opts.where, lyr, dataset.arcs);
+        lyr.shapes.forEach(function(shp, i) {
+          (test(i) ? hits : misses).push(shp);
+        });
+      } else {
+        hits = lyr.shapes;
+      }
+      if (lyr.geometry_type == 'point') {
+        targetPoints = targetPoints.concat(hits);
+        if (hits.length > 0) targetPointLayers.push(lyr);
+      } else {
+        targetShapes = targetShapes.concat(hits);
+        otherShapes = otherShapes.concat(misses);
+      }
+    });
+    var anchorArg = getAffineAnchor({arcs: dataset.arcs, layers: [{
+      geometry_type: 'point', shapes: targetPoints}, {geometry_type: 'polyline',
+      shapes: targetShapes}]}, opts);
+    transform = getAffineTransform(rotateArg, scaleArg, shiftArg, anchorArg);
+    if (opts.fit_bbox) {
+      transform = getFitBoxTransform(opts.fit_bbox, targetPoints, targetShapes, arcs);
+    }
+    if (targetShapes.length > 0) {
+      targetFlags = new Uint8Array(arcs.size());
+      otherFlags = new Uint8Array(arcs.size());
+      countArcsInShapes(targetShapes, targetFlags);
+      if (otherShapes.length > 0) {
+        countArcsInShapes(otherShapes, otherFlags);
+        applyArrayMask(otherFlags, targetFlags);
+        noteDatasetWillChange(dataset, {operation: 'affine', unit: 'arcs'});
+        dataset.arcs = duplicateSelectedArcs(otherShapes, arcs, otherFlags);
+        markDatasetChanged(dataset, {operation: 'affine', unit: 'arcs'});
+      }
+      dataset.arcs.transformPoints(function(x, y, arcId) {
+        if (arcId < targetFlags.length && targetFlags[arcId] > 0) {
+          return transform(x, y);
+        }
+      });
+    }
+    targetPointLayers.forEach(function(lyr) {
+      noteLayerWillChange(lyr, {operation: 'affine', unit: 'shapes'});
+    });
+    forEachPoint(targetPoints, function(p) {
+      var p2 = transform(p[0], p[1]);
+      p[0] = p2[0];
+      p[1] = p2[1];
+    });
+    targetPointLayers.forEach(function(lyr) {
+      markLayerChanged(lyr, {operation: 'affine', unit: 'shapes'});
+    });
+  };
+
+  function getAffineAnchor(dataset, opts) {
+    var anchor, bounds;
+    if (opts.anchor) {
+      anchor = opts.anchor;
+    } else {
+      // get bounds of selected shapes to calculate center of rotation/scale
+      bounds = getDatasetBounds(dataset);
+      anchor = [bounds.centerX(), bounds.centerY()];
+    }
+    return anchor;
+  }
+
+  // TODO: handle problems with unprojected datasets
+  //   option 1: don't allow affine transformation of unprojected data
+  //   option 2: error if transformed data exceeds valid coordinate range
+  // source: http://mathworld.wolfram.com/AffineTransformation.html
+  function getAffineTransform(rotation, scale, shift, anchor) {
+    var angle = rotation * Math.PI / 180;
+    var a = scale * Math.cos(angle);
+    var b = -scale * Math.sin(angle);
+    return function(x, y) {
+      var x2 = a * (x - anchor[0]) - b * (y - anchor[1]) + shift[0] + anchor[0];
+      var y2 = b * (x - anchor[0]) + a * (y - anchor[1]) + shift[1] + anchor[1];
+      return [x2, y2];
+    };
+  }
+
+  function getFitBoxTransform(bbox, points, shapes, arcs) {
+    var dataset = {
+      arcs: arcs,
+      layers: []
+    };
+    if (points && points.length) {
+      dataset.layers.push({
+        geometry_type: 'point',
+        shapes: points
+      });
+    }
+    if (shapes && shapes.length) {
+      dataset.layers.push({
+        geometry_type: 'polyline',
+        shapes: shapes
+      });
+    }
+    var frame = calcFrameData(dataset, {fit_bbox: bbox});
+    var fromBounds = new Bounds(frame.bbox);
+    var toBounds = new Bounds(frame.bbox2);
+    var fwd = fromBounds.getTransform(toBounds, false);
+    return function(x, y) {
+      return fwd.transform(x, y);
+    };
+  }
+
+  function applyArrayMask(destArr, maskArr) {
+    for (var i=0, n=destArr.length; i<n; i++) {
+      if (maskArr[i] === 0) destArr[i] = 0;
+    }
+  }
+
+  function duplicateSelectedArcs(shapes, arcs, flags) {
+    var arcCount = 0;
+    var vertexCount = 0;
+    var data = arcs.getVertexData();
+    var xx = [], yy = [], nn = [], map = [], n;
+    for (var i=0, len=flags.length; i<len; i++) {
+      if (flags[i] > 0) {
+        map[i] = arcs.size() + arcCount;
+        n = data.nn[i];
+        utils.copyElements(data.xx, data.ii[i], xx, vertexCount, n);
+        utils.copyElements(data.yy, data.ii[i], yy, vertexCount, n);
+        nn.push(n);
+        vertexCount += n;
+        arcCount++;
+      }
+    }
+    forEachArcId(shapes, function(id) {
+      var absId = absArcId(id);
+      if (flags[absId] > 0) {
+        return id < 0 ? ~map[absId] : map[absId];
+      }
+    });
+    return mergeArcs([arcs, new ArcCollection(nn, xx, yy)]);
+  }
+
+  var roundCoord$1 = getRoundingFunction(0.01);
+
+  function getSymbolFillColor(d) {
+    return d.fill || 'magenta';
+  }
+
+  function getSymbolStrokeColor(d) {
+    return d.stroke || d.fill || 'magenta';
+  }
+
+  function applySymbolStyles(sym, d) {
+    if (sym.type == 'polyline') {
+      sym.stroke = getSymbolStrokeColor(d);
+    } else {
+      sym.fill = getSymbolFillColor(d);
+    }
+    if (d.opacity) {
+      sym.opacity = d.opacity;
+    }
+    return sym;
+  }
+
+  function getSymbolRadius(d) {
+    if (d.radius === 0 || d.length === 0 || d.r === 0) return 0;
+    return d.radius || d.length || d.r || 5; // use a default value
+  }
+
+  // Converts the value of a list-valued option into an array of items. The value
+  // arrives either as a whole string (from a direct call, rather than from the
+  // -symbols option accessor) or as an array of items already resolved one by
+  // one. An item that holds an array of its own, as an expression like
+  // [R, R * 0.5] does, is flattened into the list. Items themselves are left
+  // unsplit, because a single item can contain a comma, as rgba() colors do.
+  function toItemList(val) {
+    var items = utils.isString(val) ? splitListItems(val) : [].concat(val);
+    var list = [];
+    for (var i=0; i<items.length; i++) {
+      if (Array.isArray(items[i])) {
+        list = list.concat(items[i]);
+      } else {
+        list.push(items[i]);
+      }
+    }
+    return list;
+  }
+
+  // Like toItemList(), for options that take numbers. An item that is a string
+  // containing commas is split, so that a data field holding a value like "2,4"
+  // works as a list. Values that aren't numbers become NaN, for the caller to
+  // report or ignore.
+  function toNumberList(val) {
+    var list = [];
+    toItemList(val).forEach(function(item) {
+      if (utils.isString(item) && item.indexOf(',') > -1) {
+        list = list.concat(parseNumberList(item));
+      } else {
+        list.push(Number(item));
+      }
+    });
+    return list;
+  }
+
+  // Returns the radius of the smallest circle centered on a symbol's point that
+  // covers the symbol, or null if the symbol contains a part whose reach can't be
+  // measured.
+  //
+  // Only a symbol drawn around its point can be described this way: a circle, or
+  // a group of the circles and polygons that make up ring, pie and donut symbols.
+  // An arrow is drawn from its point outward, so the circle around its point that
+  // covers it says nothing useful about the space it occupies -- arrows are plain
+  // polygon symbols, which reach this function only as group parts, which they
+  // never are.
+  function getSymbolBoundingRadius(sym) {
+    var max = 0;
+    var parts, r, i;
+    if (!sym) return null;
+    if (sym.type == 'circle') {
+      // Half of a stroke lies outside the circle it follows, which is how a ring
+      // symbol paints its bands.
+      return getPositiveNumber(sym.r) + getStrokeOutset(sym);
+    }
+    if (sym.type == 'polygon') {
+      forEachSymbolCoord(sym.coordinates || [], function(p) {
+        var dist = Math.sqrt(p[0] * p[0] + p[1] * p[1]);
+        if (dist > max) max = dist;
+      });
+      return max + getStrokeOutset(sym);
+    }
+    if (sym.type == 'group') {
+      parts = sym.parts || [];
+      for (i=0; i<parts.length; i++) {
+        r = getSymbolBoundingRadius(parts[i]);
+        if (r === null) return null;
+        if (r > max) max = r;
+      }
+      return max;
+    }
+    return null;
+  }
+
+  // A stroke straddles the path it is drawn on, so half of its width extends
+  // beyond the shape.
+  function getStrokeOutset(sym) {
+    var width = sym['stroke-width'];
+    if (!sym.stroke || sym.stroke == 'none') return 0;
+    // an SVG stroke is one pixel wide unless stroke-width says otherwise
+    if (width === undefined || width === null || width === '') return 0.5;
+    return getPositiveNumber(width) / 2;
+  }
+
+  function getPositiveNumber(val) {
+    var num = +val;
+    return num > 0 ? num : 0;
+  }
+
+  function forEachSymbolCoord(coords, cb) {
+    var isPoint = coords && utils.isNumber(coords[0]);
+    var isNested = !isPoint && coords && Array.isArray(coords[0]);
+    if (isPoint) return cb(coords);
+    for (var i=0; i<coords.length; i++) {
+      if (isNested) forEachSymbolCoord(coords[i], cb);
+    }
+  }
+
+  function flipY(coords) {
+    forEachSymbolCoord(coords, function(p) {
+      p[1] = -p[1];
+    });
+  }
+
+  function scaleAndShiftCoords(coords, scale, shift) {
+    forEachSymbolCoord(coords, function(xy) {
+      xy[0] = xy[0] * scale + shift[0];
+      xy[1] = xy[1] * scale + shift[1];
+    });
+  }
+
+  function roundCoordsForSVG(coords) {
+    forEachSymbolCoord(coords, function(p) {
+      p[0] = roundCoord$1(p[0]);
+      p[1] = roundCoord$1(p[1]);
+    });
+  }
+
+  function rotateCoords(coords, rotation) {
+    if (!rotation) return;
+    var f = getAffineTransform(rotation, 1, [0, 0], [0, 0]);
+    forEachSymbolCoord(coords, function(p) {
+      var p2 = f(p[0], p[1]);
+      p[0] = p2[0];
+      p[1] = p2[1];
+    });
+  }
+
+  // The space that a point's symbol and label take up when drawn, for fitting a
+  // map frame around them.
+  //
+  // Boxes are [xmin, ymin, xmax, ymax] in px, relative to the point, with y down:
+  // the space symbols are drawn in (see renderPoint() in svg-symbols.mjs, which
+  // this follows). A box can leave out parts of what gets drawn -- anti-aliasing,
+  // miter joins, a curve bowing past its control points -- but not by more than a
+  // pixel or so.
+
+  // The box around what renderPoint() draws for @rec, or null if it draws nothing
+  // that can be sized.
+  // @cache: optional Map, for reusing the boxes of svg-symbol strings, which are
+  //   often the same for every feature in a layer
+  function getPointSymbolBox(rec, cache) {
+    var box = null;
+    if (!rec) return null;
+    if (featureHasSvgSymbol(rec)) {
+      box = getSymbolBox(rec, cache);
+    }
+    if (featureHasLabel(rec)) {
+      box = mergeBoxes(box, getLabelBox(rec));
+    }
+    return box;
+  }
+
+  // How far the text of a label drawn along a path can reach from the path, in
+  // px. The side the text sits on turns with the path, so it is allowed for on
+  // every side.
+  function getPathLabelPadding(rec) {
+    return getLabelFontSize(rec) + getHaloWidth(rec);
+  }
+
+  function getLabelBox(rec) {
+    var o = getLabelTextBox(rec, {estimate_width: true});
+    var pad = getHaloWidth(rec);
+    var box = [o.xmin - pad, o.ymin - pad, o.xmax + pad, o.ymax + pad];
+    var via = labelHasCallout(rec) ? parsePointPair(rec['callout-via'] || '') : null;
+    if (via) {
+      box = mergeBoxes(box, [via[0], via[1], via[0], via[1]]);
+    }
+    return box;
+  }
+
+  function getHaloWidth(rec) {
+    var w = +rec['halo-width'];
+    return w > 0 ? w : 0;
+  }
+
+  function getSymbolBox(d, cache) {
+    var sym = d['svg-symbol'];
+    if (sym) return getComplexSymbolBox(sym, cache);
+    if (featureHasIcon(d)) return getIconBox(d);
+    if (d.r > 0) return getSquareBox(+d.r + getStrokeOutset(d), 0, 0);
+    return null;
+  }
+
+  function getIconBox(d) {
+    var type = d.icon || 'circle';
+    var r = getIconRadius(d, type);
+    var sw;
+    if (!(r > 0)) return null;
+    if (type == 'ring') {
+      // drawn as a stroke, one px wide unless stroke-width says otherwise
+      sw = +d['stroke-width'];
+      return getSquareBox(r + (sw > 0 ? sw : 1) / 2, 0, 0);
+    }
+    if (type == 'circle' || type == 'square' || type == 'star') {
+      return getSquareBox(r + getStrokeOutset(d), 0, 0);
+    }
+    return null; // unsupported icons are not drawn
+  }
+
+  function getComplexSymbolBox(sym, cache) {
+    var box;
+    if (!utils.isString(sym)) return getSymbolPartBox(sym, 0, 0);
+    if (cache && cache.has(sym)) return cache.get(sym);
+    try {
+      box = getSymbolPartBox(JSON.parse(sym), 0, 0);
+    } catch(e) {
+      box = null;
+    }
+    if (cache) cache.set(sym, box);
+    return box;
+  }
+
+  // Follows the renderers in svg-symbols.mjs: @x, @y is where the part is drawn,
+  // which circles, squares, images, lines and labels are placed at and polygons
+  // and polylines ignore.
+  function getSymbolPartBox(sym, x, y) {
+    var type = sym && sym.type;
+    var w, h;
+    if (!sym || sym.tag) return null; // raw SVG can't be sized
+    if (type == 'circle' || type == 'square') {
+      return getSquareBox(getPositive(sym.r) + getStrokeOutset(sym), x, y);
+    }
+    if (type == 'image') {
+      w = sym.width || 20;
+      h = sym.height || 20;
+      return [x - w / 2, y - h / 2, x + w / 2, y + h / 2];
+    }
+    if (type == 'polygon') {
+      return padBox(getCoordsBox(sym.coordinates), getStrokeOutset(sym));
+    }
+    if (type == 'polyline') {
+      return padBox(getCoordsBox(sym.coordinates), getLineOutset(sym));
+    }
+    if (type == 'line') {
+      return padBox(getCoordsBox([[x, y], [x + (sym.dx || 0), y + (sym.dy || 0)]]),
+        getLineOutset(sym));
+    }
+    if (type == 'label') {
+      return shiftBox(getLabelBox(sym), x, y);
+    }
+    if (type == 'group') {
+      return getGroupBox(sym, x, y);
+    }
+    return null; // offset draws nothing, and unknown types are not drawn
+  }
+
+  // A line part moves the parts after it to its far end; an offset part moves
+  // them into a group translated by its offset.
+  function getGroupBox(sym, x, y) {
+    var box = null;
+    var ox = 0, oy = 0;
+    (sym.parts || []).forEach(function(part) {
+      box = mergeBoxes(box, shiftBox(getSymbolPartBox(part, x, y), ox, oy));
+      if (!part) return;
+      if (part.type == 'line') {
+        x += part.dx || 0;
+        y += part.dy || 0;
+      } else if (part.type == 'offset') {
+        ox += x + (part.dx || 0);
+        oy += y + (part.dy || 0);
+        x = y = 0;
+      }
+    });
+    return box;
+  }
+
+  // A stroked line is one px wide unless stroke-width says otherwise
+  function getLineOutset(sym) {
+    var sw = +sym['stroke-width'];
+    return (sw > 0 ? sw : 1) / 2;
+  }
+
+  function getCoordsBox(coords) {
+    var box = null;
+    forEachSymbolCoord(coords || [], function(p) {
+      if (!isFinite(p[0]) || !isFinite(p[1])) return;
+      box = mergeBoxes(box, [p[0], p[1], p[0], p[1]]);
+    });
+    return box;
+  }
+
+  function getSquareBox(r, x, y) {
+    return r > 0 ? [x - r, y - r, x + r, y + r] : null;
+  }
+
+  function padBox(box, pad) {
+    return box ? [box[0] - pad, box[1] - pad, box[2] + pad, box[3] + pad] : null;
+  }
+
+  function shiftBox(box, dx, dy) {
+    if (!box || !dx && !dy) return box;
+    return [box[0] + dx, box[1] + dy, box[2] + dx, box[3] + dy];
+  }
+
+  function mergeBoxes(a, b) {
+    if (!a) return b;
+    if (!b) return a;
+    return [Math.min(a[0], b[0]), Math.min(a[1], b[1]),
+      Math.max(a[2], b[2]), Math.max(a[3], b[3])];
+  }
+
+  function getPositive(val) {
+    var num = +val;
+    return num > 0 ? num : 0;
+  }
+
+  // Fitting a map frame to its content, including the symbols and labels drawn
+  // at points, which take up room that the point coordinates alone do not.
+  //
+  // Symbols are sized in output pixels, and how many map units a pixel covers is
+  // set by the frame being fitted, so the extent can't simply be padded. It is
+  // found by solving for the scale instead: the smallest scale s (map units per
+  // output pixel) at which the content -- points and their symbols, drawn at s --
+  // gets a frame whose own scale is no larger than s.
+  //
+  // Every point's box moves each side of the extent linearly with s, so the
+  // extent's width and height are convex, piecewise-linear functions of s, and so
+  // is the frame scale they produce. Newton's method converges on the smallest
+  // fixed point of such a function from below, without overshooting, in as many
+  // steps as there are pieces along the way -- usually two or three.
+
+  var MAX_ITERATIONS = 50;
+  var TOLERANCE = 1e-9;
+
+  // Returns the extent of @targets as a bbox array, padded to hold the symbols
+  // and labels at their points, or null if the targets have no extent.
+  //
+  // @targets   [{layer, dataset}]
+  // @getScale  function(bbox) -> map units per output px of a frame fitted to
+  //            @bbox; this is where the caller's offsets and page shape come in.
+  //            May return NaN for a bbox the frame can't be fitted to.
+  // @opts.ignore_symbols  fit to the coordinates alone
+  function getFrameContentBbox(targets, getScale, opts) {
+    // a data-only layer has no bounds
+    var bounds = targets.reduce(function(memo, o) {
+      var b = getLayerBounds(o.layer, o.dataset.arcs);
+      return b ? memo.mergeBounds(b) : memo;
+    }, new Bounds());
+    var raw, items, bbox;
+    if (!bounds.hasBounds()) return null;
+    raw = bounds.toArray();
+    if (opts && opts.ignore_symbols) return raw;
+    items = getSymbolExtents(targets);
+    if (items.length === 0) return raw;
+    bbox = fitBboxToSymbols(raw, items, getScale);
+    if (!bbox) {
+      warn('Symbols and labels are too large to fit in the frame; ' +
+        'fitting the frame to point locations only.');
+      return raw;
+    }
+    return bbox;
+  }
+
+  // The map units per output px of a frame with extent @bbox and nominal width
+  // @width. A frame with a fixed page shape is filled out to that shape when it is
+  // rendered (see fitDatasetToFrame()), so its scale is set by whichever of its
+  // width and height is the tighter fit.
+  function getFrameScale(bbox, width, fixedAspect) {
+    var w = bbox[2] - bbox[0];
+    var h = bbox[3] - bbox[1];
+    return fixedAspect > 0 ? Math.max(w, h * fixedAspect) / width : w / width;
+  }
+
+  // @raw     bbox of the content without symbols
+  // @items   flat array of [x, y, xmin, ymin, xmax, ymax, ...]: each point and the
+  //          box around it in px, oriented like the map (y up)
+  // Returns the padded bbox, or null if there is no scale at which the symbols
+  // fit -- when they add up to more than the width of the page.
+  function fitBboxToSymbols(raw, items, getScale) {
+    var s = getScale(raw);
+    var bbox, h, delta, slope, i;
+    for (i = 0; i < MAX_ITERATIONS; i++) {
+      if (!isValidScale(s)) return null;
+      bbox = expandBbox(raw, items, s);
+      h = getScale(bbox);
+      if (!isValidScale(h)) return null;
+      // Content with no extent of its own, like a single point, stops here with
+      // s = 0: nothing about it sets a scale.
+      if (h <= s * (1 + TOLERANCE)) return bbox;
+      if (!(s > 0)) return null;
+      delta = s * 1e-7;
+      slope = (getScale(expandBbox(raw, items, s + delta)) - h) / delta;
+      if (!(slope < 1)) return null;
+      s += (h - s) / (1 - slope);
+    }
+    return expandBbox(raw, items, s);
+  }
+
+  function isValidScale(s) {
+    return s >= 0 && s < Infinity;
+  }
+
+  function expandBbox(raw, items, s) {
+    var xmin = raw[0], ymin = raw[1], xmax = raw[2], ymax = raw[3];
+    var x, y, v;
+    for (var i = 0, n = items.length; i < n; i += 6) {
+      x = items[i];
+      y = items[i + 1];
+      v = x + items[i + 2] * s;
+      if (v < xmin) xmin = v;
+      v = y + items[i + 3] * s;
+      if (v < ymin) ymin = v;
+      v = x + items[i + 4] * s;
+      if (v > xmax) xmax = v;
+      v = y + items[i + 5] * s;
+      if (v > ymax) ymax = v;
+    }
+    return [xmin, ymin, xmax, ymax];
+  }
+
+  // Boxes come from the renderer's space, where y is down, and are flipped here
+  // to the map's.
+  function getSymbolExtents(targets) {
+    var items = [];
+    var cache = new Map();
+    targets.forEach(function(o) {
+      var lyr = o.layer;
+      var records;
+      if (lyr.geometry_type != 'point' || !lyr.shapes || !lyr.data) return;
+      records = lyr.data.getRecords();
+      lyr.shapes.forEach(function(shp, i) {
+        var rec = records[i];
+        var box, pad;
+        if (!shp || !rec) return;
+        if (shp.length > 1 && featureHasLabel(rec)) {
+          // a multipoint label is drawn along a path through its points,
+          // with no symbol (see featureIsPathLabel())
+          pad = getPathLabelPadding(rec);
+          box = [-pad, -pad, pad, pad];
+        } else {
+          box = getPointSymbolBox(rec, cache);
+        }
+        if (!box) return;
+        for (var j = 0; j < shp.length; j++) {
+          if (!shp[j] || !isFinite(shp[j][0]) || !isFinite(shp[j][1])) continue;
+          items.push(shp[j][0], shp[j][1], box[0], -box[3], box[2], -box[1]);
+        }
+      });
+    });
+    return items;
+  }
+
   cmd.frame = function(catalog, targets, opts) {
-    var widthPx, heightPx, aspectRatio, bbox;
+    var widthPx, heightPx, bbox;
     var existingFrame = getActiveFrame(catalog);
     if (opts.width) {
       widthPx = parseFrameSize(opts.width).valuePx;
@@ -51612,30 +52587,29 @@ ${svg}
     } else {
       var datasets = utils.pluck(targets, 'dataset');
       requireDatasetsHaveCompatibleCRS(datasets, 'Targets include both projected and unprojected coordinates');
-      bbox = getTargetBbox(targets);
+      bbox = getFrameContentBbox(expandCommandTargets(targets), function(contentBbox) {
+        var extent = getFrameExtent(contentBbox, widthPx, heightPx, opts);
+        return getFrameScale(extent.bbox, extent.width, getFixedAspect$1(extent, opts));
+      }, opts);
+      if (!bbox && !expandCommandTargets(targets).some(function(o) {
+        return layerHasGeometry$1(o.layer);
+      })) {
+        stop$1('Unable to fit a frame to a layer with no geometry. Target a layer containing shapes, or use the bbox= option.');
+      }
       if (!bbox) {
         stop$1('Command target is missing geographical bounds');
       }
     }
 
-    applyPercentageOffsets(bbox, opts.offset || opts.offsets);
-    applyPixelOffsets(bbox, widthPx, heightPx, opts.offset || opts.offsets);
-
-    if (bbox[3] - bbox[1] > 0 === false || bbox[2] - bbox[0] > 0 === false) {
+    var extent = getFrameExtent(bbox, widthPx, heightPx, opts);
+    if (!extent.valid) {
       stop$1('Frame has a collapsed bbox');
     }
 
-    aspectRatio = (bbox[2] - bbox[0]) / (bbox[3] - bbox[1]);
-    if (!widthPx) {
-      widthPx = roundToDigits(heightPx * aspectRatio, 1);
-    } else if (!heightPx) {
-      heightPx = roundToDigits(widthPx / aspectRatio, 1);
-    }
-
     var feature = {
       type: 'Feature',
-      properties: getFrameProperties(widthPx, heightPx, opts),
-      geometry: bboxToPolygon(bbox)
+      properties: getFrameProperties(extent.width, extent.height, opts),
+      geometry: bboxToPolygon(extent.bbox)
     };
     var frameDataset = importGeoJSON(feature);
     // set CRS from target dataset
@@ -51645,16 +52619,47 @@ ${svg}
       var crsInfo = getDatasetCrsInfo(targets[0].dataset);
       setDatasetCrsInfo(frameDataset, crsInfo);
     }
-    frameDataset.layers[0].name = opts.name || 'frame';
+    var frameLyr = frameDataset.layers[0];
+    frameLyr.name = opts.name || 'frame';
     if (existingFrame) {
       if (!opts.replace) {
         stop$1('A map frame already exists:', existingFrame.layer.name || '[unnamed frame]');
       }
+      moveFrameFurniture(existingFrame.dataset, frameDataset);
       demoteFrameLayer(existingFrame.layer);
     }
-    catalog.addDataset(frameDataset);
+    // target the frame, not any furniture that came with it
+    catalog.setDefaultTarget([frameLyr], frameDataset);
   };
 
+  // The frame's extent and nominal size, from the extent of its content and the
+  // size options. Pure, so that fitting to symbols can ask what scale an extent
+  // would give the frame.
+  function getFrameExtent(contentBbox, widthPx, heightPx, opts) {
+    var offsets = opts.offset || opts.offsets;
+    var bbox = contentBbox.slice();
+    var aspectRatio;
+    applyPercentageOffsets(bbox, offsets);
+    applyPixelOffsets(bbox, widthPx, heightPx, offsets);
+    aspectRatio = (bbox[2] - bbox[0]) / (bbox[3] - bbox[1]);
+    if (!widthPx) {
+      widthPx = roundToDigits(heightPx * aspectRatio, 1);
+    } else if (!heightPx) {
+      heightPx = roundToDigits(widthPx / aspectRatio, 1);
+    }
+    return {
+      bbox: bbox,
+      width: widthPx,
+      height: heightPx,
+      valid: bbox[3] - bbox[1] > 0 && bbox[2] - bbox[0] > 0
+    };
+  }
+
+  function getFixedAspect$1(extent, opts) {
+    return opts.aspect_ratio > 0 || opts.width && opts.height ?
+      extent.width / extent.height : null;
+  }
+
   function getFrameProperties(width, height, opts) {
     var properties = {
       type: 'frame',
@@ -51750,14 +52755,6 @@ ${svg}
     return arg;
   }
 
-  function getTargetBbox(targets) {
-    var expanded = expandCommandTargets(targets);
-    var bounds = expanded.reduce(function(memo, o) {
-      return memo.mergeBounds(getLayerBounds(o.layer, o.dataset.arcs));
-    }, new Bounds());
-    return bounds.hasBounds() ? bounds.toArray() : null;
-  }
-
   // Convert width and height args to aspect ratio arg for the rectangle() function
   function getAspectRatioArg(widthArg, heightArg) {
     // heightArg is a string containing either a number or a
@@ -51902,7 +52899,8 @@ ${svg}
 
   var OPERATION$1 = 'update-frame';
 
-  function updateFrame(targetLayers, dataset, opts) {
+  // @fitTargets: [{layer, dataset}] named by the fit= option
+  function updateFrame(targetLayers, dataset, opts, fitTargets) {
     if (!targetLayers || targetLayers.length != 1) {
       stop$1('-update-frame expects a single target layer');
     }
@@ -51926,15 +52924,14 @@ ${svg}
     if (opts.fix_scale && (opts.width !== undefined || opts.height !== undefined)) {
       stop$1('fix-scale cannot be combined with width= or height=');
     }
+    if (opts.bbox !== undefined && opts.fit !== undefined) {
+      stop$1('bbox= and fit= are mutually exclusive');
+    }
 
     var rec = lyr.data.getRecords()[0];
     var frame = getFrameLayerData(lyr, dataset.arcs);
-    var bbox = (opts.bbox || frame.bbox).slice();
-    var offsetArg = opts.offset || opts.offsets;
     var fixedAspect = getFixedAspect(rec);
-    var width = frame.width;
-    var units = rec.frame_units || 'px';
-    var widthSize, heightSize, height, effectiveAspect;
+    var sizes, contentBbox, update;
 
     // 1. Aspect mode, resolved first because whether the page shape is fixed
     // decides whether it may constrain the extent while offsets are applied.
@@ -51946,8 +52943,87 @@ ${svg}
       }
       fixedAspect = opts.aspect_ratio;
     }
+    sizes = parseSizeOptions(opts);
+
+    // 2. Extent, which fit= finds by trying extents out on steps 3 and 4
+    if (opts.fit !== undefined) {
+      contentBbox = getFrameContentBbox(getFitTargets(fitTargets, dataset), function(bbox) {
+        var o = resolveFrameUpdate(bbox, frame, fixedAspect, sizes, opts);
+        return getFrameScale(o.bbox, o.width, o.fixedAspect);
+      }, opts);
+      if (!contentBbox) {
+        stop$1('Layers to fit are missing geographical bounds');
+      }
+    } else {
+      contentBbox = opts.bbox || frame.bbox;
+    }
+
+    update = resolveFrameUpdate(contentBbox, frame, fixedAspect, sizes, opts);
+    if (!update.valid) {
+      stop$1('Frame has a collapsed bbox');
+    }
+    if (opts.fix_scale) {
+      requirePositiveSize(update.width, 'fix-scale', update.width);
+    }
+
+    noteLayerWillChange(lyr, {operation: OPERATION$1, unit: 'shapes'});
+    lyr.data.captureTableBefore({operation: OPERATION$1});
+    rec.width = update.width;
+    rec.height = update.height;
+    rec.frame_units = update.units;
+    if (update.fixedAspect) {
+      rec.frame_aspect_ratio = update.fixedAspect;
+    } else {
+      delete rec.frame_aspect_ratio;
+    }
+    lyr.data.markChanged({operation: OPERATION$1});
+    rebuildFrameLayerGeometry(lyr, dataset, new Bounds(update.bbox));
+    markLayerChanged(lyr, {operation: OPERATION$1, unit: 'shapes'});
+  }
+
+  // The frame's layers are not content to fit, and a frame is only fitted to
+  // layers it shares coordinates with.
+  function getFitTargets(fitTargets, frameDataset) {
+    var targets = (fitTargets || []).filter(function(o) {
+      return !isFrameLayer(o.layer, o.dataset.arcs);
+    });
+    if (targets.length === 0) {
+      stop$1('fit= found no layers to fit the frame to');
+    }
+    requireDatasetsHaveCompatibleCRS(
+      utils.uniq(targets.map(function(o) { return o.dataset; }).concat(frameDataset)),
+      'Layers to fit and the frame have incompatible coordinates'
+    );
+    return targets;
+  }
+
+  function parseSizeOptions(opts) {
+    var sizes = {width: null, height: null};
+    if (opts.width !== undefined) {
+      sizes.width = parseFrameSize(opts.width);
+      requirePositiveSize(sizes.width.valuePx, 'width', opts.width);
+    }
+    if (opts.height !== undefined) {
+      sizes.height = parseFrameSize(opts.height);
+      requirePositiveSize(sizes.height.valuePx, 'height', opts.height);
+    }
+    if (sizes.width && sizes.height && opts.aspect_ratio !== undefined &&
+        ratiosDiffer(sizes.width.valuePx / sizes.height.valuePx, opts.aspect_ratio)) {
+      stop$1('Contradictory width, height and aspect-ratio values');
+    }
+    return sizes;
+  }
 
-    // 2. Extent
+  // Steps 3 and 4 as a pure function of the content extent, so that fit= can
+  // ask what scale an extent would give the frame.
+  function resolveFrameUpdate(contentBbox, frame, fixedAspect, sizes, opts) {
+    var bbox = contentBbox.slice();
+    var offsetArg = opts.offset || opts.offsets;
+    var width = frame.width;
+    var units = frame.units || 'px';
+    var valid, effectiveAspect;
+
+    // 3. Padding
     if (offsetArg) {
       applyPercentageOffsets(bbox, offsetArg);
       // Pass a page height only when the shape is fixed. A derived height
@@ -51956,65 +53032,44 @@ ${svg}
       applyPixelOffsets(bbox, frame.width,
         fixedAspect ? frame.width / fixedAspect : null, offsetArg);
     }
-    requireValidBbox(bbox);
+    valid = isValidBbox(bbox);
     if (fixedAspect) {
       fillOutBbox(bbox, fixedAspect, 1);
     }
 
-    // 3. Nominal size
-    if (opts.width !== undefined) {
-      widthSize = parseFrameSize(opts.width);
-      requirePositiveSize(widthSize.valuePx, 'width', opts.width);
-    }
-    if (opts.height !== undefined) {
-      heightSize = parseFrameSize(opts.height);
-      requirePositiveSize(heightSize.valuePx, 'height', opts.height);
-    }
-    if (widthSize && heightSize) {
-      effectiveAspect = widthSize.valuePx / heightSize.valuePx;
-      if (opts.aspect_ratio !== undefined &&
-          ratiosDiffer(effectiveAspect, opts.aspect_ratio)) {
-        stop$1('Contradictory width, height and aspect-ratio values');
-      }
-      width = widthSize.valuePx;
-      units = widthSize.units;
-      fixedAspect = effectiveAspect;
+    // 4. Nominal size
+    if (sizes.width && sizes.height) {
+      width = sizes.width.valuePx;
+      units = sizes.width.units;
+      fixedAspect = sizes.width.valuePx / sizes.height.valuePx;
       fillOutBbox(bbox, fixedAspect, 1);
-    } else if (widthSize) {
-      width = widthSize.valuePx;
-      units = widthSize.units;
-    } else if (heightSize) {
+    } else if (sizes.width) {
+      width = sizes.width.valuePx;
+      units = sizes.width.units;
+    } else if (sizes.height) {
       effectiveAspect = fixedAspect || getBboxAspect(bbox);
-      width = heightSize.valuePx * effectiveAspect;
-      units = heightSize.units;
+      width = sizes.height.valuePx * effectiveAspect;
+      units = sizes.height.units;
     } else if (opts.fix_scale) {
       // Hold ground units per output pixel, so the page grows and shrinks with
       // the extent instead of the scale changing to fit the extent on it.
       width = frame.width * getBboxWidth(bbox) / getBboxWidth(frame.bbox);
-      requirePositiveSize(width, 'fix-scale', width);
     }
 
-    requireValidBbox(bbox);
     effectiveAspect = fixedAspect || getBboxAspect(bbox);
-    height = Math.round(width / effectiveAspect);
-
-    noteLayerWillChange(lyr, {operation: OPERATION$1, unit: 'shapes'});
-    lyr.data.captureTableBefore({operation: OPERATION$1});
-    rec.width = width;
-    rec.height = height;
-    rec.frame_units = units;
-    if (fixedAspect) {
-      rec.frame_aspect_ratio = fixedAspect;
-    } else {
-      delete rec.frame_aspect_ratio;
-    }
-    lyr.data.markChanged({operation: OPERATION$1});
-    rebuildFrameLayerGeometry(lyr, dataset, new Bounds(bbox));
-    markLayerChanged(lyr, {operation: OPERATION$1, unit: 'shapes'});
+    return {
+      bbox: bbox,
+      width: width,
+      height: Math.round(width / effectiveAspect),
+      units: units,
+      fixedAspect: fixedAspect,
+      valid: valid && isValidBbox(bbox)
+    };
   }
 
   function hasUpdateOptions(opts) {
     return opts.bbox !== undefined ||
+      opts.fit !== undefined ||
       opts.width !== undefined ||
       opts.height !== undefined ||
       opts.aspect_ratio !== undefined ||
@@ -52037,12 +53092,10 @@ ${svg}
     return (bbox[2] - bbox[0]) / (bbox[3] - bbox[1]);
   }
 
-  function requireValidBbox(bbox) {
-    if (!bbox.every(utils.isFiniteNumber) ||
-        bbox[2] - bbox[0] <= 0 ||
-        bbox[3] - bbox[1] <= 0) {
-      stop$1('Frame has a collapsed bbox');
-    }
+  function isValidBbox(bbox) {
+    return bbox.every(utils.isFiniteNumber) &&
+      bbox[2] - bbox[0] > 0 &&
+      bbox[3] - bbox[1] > 0;
   }
 
   function requirePositiveSize(value, name, arg) {
@@ -52272,168 +53325,6 @@ ${svg}
     stop$1('Unable to import coordinates');
   }
 
-  // Apply rotation, scale and/or shift to some or all of the features in a dataset
-  //
-  cmd.affine = function(targetLayers, dataset, opts) {
-    // Need to separate the targeted shapes from any other shapes that share
-    // the same topology. So we duplicate any arcs that are shared by the targeted
-    // shapes and their topological neighbors and remap arc references in the
-    // neighbors to point to the copies.
-    // TODO: explore alternative: if some arcs are shared between transformed and
-    //   non-transformed shapes, first remove topology, then tranform, then rebuild topology
-    //
-    var rotateArg = opts.rotate || 0;
-    var scaleArg = opts.scale || 1;
-    var shiftArg = opts.shift ? convertIntervalPair(opts.shift, getDatasetCRS(dataset)) : [0, 0];
-    var arcs = dataset.arcs;
-    var targetShapes = [];
-    var otherShapes = [];
-    var targetPoints = [];
-    var targetPointLayers = [];
-    var targetFlags, otherFlags, transform;
-    dataset.layers.filter(layerHasGeometry$1).forEach(function(lyr) {
-      var hits = [],
-          misses = [],
-          test;
-      if (targetLayers.indexOf(lyr) == -1) {
-        misses = lyr.shapes;
-      } else if (opts.where) {
-        test = compileFeatureExpression(opts.where, lyr, dataset.arcs);
-        lyr.shapes.forEach(function(shp, i) {
-          (test(i) ? hits : misses).push(shp);
-        });
-      } else {
-        hits = lyr.shapes;
-      }
-      if (lyr.geometry_type == 'point') {
-        targetPoints = targetPoints.concat(hits);
-        if (hits.length > 0) targetPointLayers.push(lyr);
-      } else {
-        targetShapes = targetShapes.concat(hits);
-        otherShapes = otherShapes.concat(misses);
-      }
-    });
-    var anchorArg = getAffineAnchor({arcs: dataset.arcs, layers: [{
-      geometry_type: 'point', shapes: targetPoints}, {geometry_type: 'polyline',
-      shapes: targetShapes}]}, opts);
-    transform = getAffineTransform(rotateArg, scaleArg, shiftArg, anchorArg);
-    if (opts.fit_bbox) {
-      transform = getFitBoxTransform(opts.fit_bbox, targetPoints, targetShapes, arcs);
-    }
-    if (targetShapes.length > 0) {
-      targetFlags = new Uint8Array(arcs.size());
-      otherFlags = new Uint8Array(arcs.size());
-      countArcsInShapes(targetShapes, targetFlags);
-      if (otherShapes.length > 0) {
-        countArcsInShapes(otherShapes, otherFlags);
-        applyArrayMask(otherFlags, targetFlags);
-        noteDatasetWillChange(dataset, {operation: 'affine', unit: 'arcs'});
-        dataset.arcs = duplicateSelectedArcs(otherShapes, arcs, otherFlags);
-        markDatasetChanged(dataset, {operation: 'affine', unit: 'arcs'});
-      }
-      dataset.arcs.transformPoints(function(x, y, arcId) {
-        if (arcId < targetFlags.length && targetFlags[arcId] > 0) {
-          return transform(x, y);
-        }
-      });
-    }
-    targetPointLayers.forEach(function(lyr) {
-      noteLayerWillChange(lyr, {operation: 'affine', unit: 'shapes'});
-    });
-    forEachPoint(targetPoints, function(p) {
-      var p2 = transform(p[0], p[1]);
-      p[0] = p2[0];
-      p[1] = p2[1];
-    });
-    targetPointLayers.forEach(function(lyr) {
-      markLayerChanged(lyr, {operation: 'affine', unit: 'shapes'});
-    });
-  };
-
-  function getAffineAnchor(dataset, opts) {
-    var anchor, bounds;
-    if (opts.anchor) {
-      anchor = opts.anchor;
-    } else {
-      // get bounds of selected shapes to calculate center of rotation/scale
-      bounds = getDatasetBounds(dataset);
-      anchor = [bounds.centerX(), bounds.centerY()];
-    }
-    return anchor;
-  }
-
-  // TODO: handle problems with unprojected datasets
-  //   option 1: don't allow affine transformation of unprojected data
-  //   option 2: error if transformed data exceeds valid coordinate range
-  // source: http://mathworld.wolfram.com/AffineTransformation.html
-  function getAffineTransform(rotation, scale, shift, anchor) {
-    var angle = rotation * Math.PI / 180;
-    var a = scale * Math.cos(angle);
-    var b = -scale * Math.sin(angle);
-    return function(x, y) {
-      var x2 = a * (x - anchor[0]) - b * (y - anchor[1]) + shift[0] + anchor[0];
-      var y2 = b * (x - anchor[0]) + a * (y - anchor[1]) + shift[1] + anchor[1];
-      return [x2, y2];
-    };
-  }
-
-  function getFitBoxTransform(bbox, points, shapes, arcs) {
-    var dataset = {
-      arcs: arcs,
-      layers: []
-    };
-    if (points && points.length) {
-      dataset.layers.push({
-        geometry_type: 'point',
-        shapes: points
-      });
-    }
-    if (shapes && shapes.length) {
-      dataset.layers.push({
-        geometry_type: 'polyline',
-        shapes: shapes
-      });
-    }
-    var frame = calcFrameData(dataset, {fit_bbox: bbox});
-    var fromBounds = new Bounds(frame.bbox);
-    var toBounds = new Bounds(frame.bbox2);
-    var fwd = fromBounds.getTransform(toBounds, false);
-    return function(x, y) {
-      return fwd.transform(x, y);
-    };
-  }
-
-  function applyArrayMask(destArr, maskArr) {
-    for (var i=0, n=destArr.length; i<n; i++) {
-      if (maskArr[i] === 0) destArr[i] = 0;
-    }
-  }
-
-  function duplicateSelectedArcs(shapes, arcs, flags) {
-    var arcCount = 0;
-    var vertexCount = 0;
-    var data = arcs.getVertexData();
-    var xx = [], yy = [], nn = [], map = [], n;
-    for (var i=0, len=flags.length; i<len; i++) {
-      if (flags[i] > 0) {
-        map[i] = arcs.size() + arcCount;
-        n = data.nn[i];
-        utils.copyElements(data.xx, data.ii[i], xx, vertexCount, n);
-        utils.copyElements(data.yy, data.ii[i], yy, vertexCount, n);
-        nn.push(n);
-        vertexCount += n;
-        arcCount++;
-      }
-    }
-    forEachArcId(shapes, function(id) {
-      var absId = absArcId(id);
-      if (flags[absId] > 0) {
-        return id < 0 ? ~map[absId] : map[absId];
-      }
-    });
-    return mergeArcs([arcs, new ArcCollection(nn, xx, yy)]);
-  }
-
   const epsilon = 1.1102230246251565e-16;
   const splitter = 134217729;
   const resulterrbound = (3 + 8 * epsilon) * epsilon;
@@ -75976,7 +76867,7 @@ ${svg}
 
     function createMeridianPart(x, ymin, ymax) {
       var coords = densifyPathByInterval([[x, ymin], [x, ymax]], precision);
-      meridians.push(graticuleFeature(coords, {type: 'meridian', value: roundCoord$1(x)}));
+      meridians.push(graticuleFeature(coords, {type: 'meridian', value: roundCoord(x)}));
     }
 
     function createParallel(y) {
@@ -76010,7 +76901,7 @@ ${svg}
   }
 
   // remove tiny offsets
-  function roundCoord$1(x) {
+  function roundCoord(x) {
     return +x.toFixed(3) || 0;
   }
 
@@ -79050,160 +79941,6 @@ ${svg}
     };
   }
 
-  var roundCoord = getRoundingFunction(0.01);
-
-  function getSymbolFillColor(d) {
-    return d.fill || 'magenta';
-  }
-
-  function getSymbolStrokeColor(d) {
-    return d.stroke || d.fill || 'magenta';
-  }
-
-  function applySymbolStyles(sym, d) {
-    if (sym.type == 'polyline') {
-      sym.stroke = getSymbolStrokeColor(d);
-    } else {
-      sym.fill = getSymbolFillColor(d);
-    }
-    if (d.opacity) {
-      sym.opacity = d.opacity;
-    }
-    return sym;
-  }
-
-  function getSymbolRadius(d) {
-    if (d.radius === 0 || d.length === 0 || d.r === 0) return 0;
-    return d.radius || d.length || d.r || 5; // use a default value
-  }
-
-  // Converts the value of a list-valued option into an array of items. The value
-  // arrives either as a whole string (from a direct call, rather than from the
-  // -symbols option accessor) or as an array of items already resolved one by
-  // one. An item that holds an array of its own, as an expression like
-  // [R, R * 0.5] does, is flattened into the list. Items themselves are left
-  // unsplit, because a single item can contain a comma, as rgba() colors do.
-  function toItemList(val) {
-    var items = utils.isString(val) ? splitListItems(val) : [].concat(val);
-    var list = [];
-    for (var i=0; i<items.length; i++) {
-      if (Array.isArray(items[i])) {
-        list = list.concat(items[i]);
-      } else {
-        list.push(items[i]);
-      }
-    }
-    return list;
-  }
-
-  // Like toItemList(), for options that take numbers. An item that is a string
-  // containing commas is split, so that a data field holding a value like "2,4"
-  // works as a list. Values that aren't numbers become NaN, for the caller to
-  // report or ignore.
-  function toNumberList(val) {
-    var list = [];
-    toItemList(val).forEach(function(item) {
-      if (utils.isString(item) && item.indexOf(',') > -1) {
-        list = list.concat(parseNumberList(item));
-      } else {
-        list.push(Number(item));
-      }
-    });
-    return list;
-  }
-
-  // Returns the radius of the smallest circle centered on a symbol's point that
-  // covers the symbol, or null if the symbol contains a part whose reach can't be
-  // measured.
-  //
-  // Only a symbol drawn around its point can be described this way: a circle, or
-  // a group of the circles and polygons that make up ring, pie and donut symbols.
-  // An arrow is drawn from its point outward, so the circle around its point that
-  // covers it says nothing useful about the space it occupies -- arrows are plain
-  // polygon symbols, which reach this function only as group parts, which they
-  // never are.
-  function getSymbolBoundingRadius(sym) {
-    var max = 0;
-    var parts, r, i;
-    if (!sym) return null;
-    if (sym.type == 'circle') {
-      // Half of a stroke lies outside the circle it follows, which is how a ring
-      // symbol paints its bands.
-      return getPositiveNumber(sym.r) + getStrokeOutset(sym);
-    }
-    if (sym.type == 'polygon') {
-      forEachSymbolCoord(sym.coordinates || [], function(p) {
-        var dist = Math.sqrt(p[0] * p[0] + p[1] * p[1]);
-        if (dist > max) max = dist;
-      });
-      return max + getStrokeOutset(sym);
-    }
-    if (sym.type == 'group') {
-      parts = sym.parts || [];
-      for (i=0; i<parts.length; i++) {
-        r = getSymbolBoundingRadius(parts[i]);
-        if (r === null) return null;
-        if (r > max) max = r;
-      }
-      return max;
-    }
-    return null;
-  }
-
-  // A stroke straddles the path it is drawn on, so half of its width extends
-  // beyond the shape.
-  function getStrokeOutset(sym) {
-    var width = sym['stroke-width'];
-    if (!sym.stroke || sym.stroke == 'none') return 0;
-    // an SVG stroke is one pixel wide unless stroke-width says otherwise
-    if (width === undefined || width === null || width === '') return 0.5;
-    return getPositiveNumber(width) / 2;
-  }
-
-  function getPositiveNumber(val) {
-    var num = +val;
-    return num > 0 ? num : 0;
-  }
-
-  function forEachSymbolCoord(coords, cb) {
-    var isPoint = coords && utils.isNumber(coords[0]);
-    var isNested = !isPoint && coords && Array.isArray(coords[0]);
-    if (isPoint) return cb(coords);
-    for (var i=0; i<coords.length; i++) {
-      if (isNested) forEachSymbolCoord(coords[i], cb);
-    }
-  }
-
-  function flipY(coords) {
-    forEachSymbolCoord(coords, function(p) {
-      p[1] = -p[1];
-    });
-  }
-
-  function scaleAndShiftCoords(coords, scale, shift) {
-    forEachSymbolCoord(coords, function(xy) {
-      xy[0] = xy[0] * scale + shift[0];
-      xy[1] = xy[1] * scale + shift[1];
-    });
-  }
-
-  function roundCoordsForSVG(coords) {
-    forEachSymbolCoord(coords, function(p) {
-      p[0] = roundCoord(p[0]);
-      p[1] = roundCoord(p[1]);
-    });
-  }
-
-  function rotateCoords(coords, rotation) {
-    if (!rotation) return;
-    var f = getAffineTransform(rotation, 1, [0, 0], [0, 0]);
-    forEachSymbolCoord(coords, function(p) {
-      var p2 = f(p[0], p[1]);
-      p[0] = p2[0];
-      p[1] = p2[1];
-    });
-  }
-
   // Collision reduction for circular symbols, in the spirit of d3-force's
   // forceCollide. Overlapping symbols are pushed apart, but each one is kept
   // within a fixed distance of its true position.
@@ -83097,7 +83834,8 @@ ${svg}
         job.catalog.addDataset(cmd.addLayer(targetDataset, opts));
 
       } else if (name == 'update-frame') {
-        cmd.updateFrame(targetLayers, targetDataset, opts);
+        cmd.updateFrame(targetLayers, targetDataset, opts,
+          opts.fit ? expandCommandTargets(job.catalog.findCommandTargets(opts.fit)) : null);
 
       } else if (name == 'update-label') {
         cmd.updateLabel(targetLayers, targetDataset, opts);
@@ -83663,7 +84401,7 @@ ${svg}
     return name == 'rectangle' || name == 'rectangles' || name == 'filter' && opts.cleanup;
   }
 
-  var version = "0.7.67";
+  var version = "0.7.69";
 
   // 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.