mapshaper 0.7.69 → 0.7.71

package/www/mapshaper.js

@@ -5882,13 +5882,13 @@
     return msg;
   }
 
-  function requirePointLayer$1(lyr, msg) {
+  function requirePointLayer$2(lyr, msg) {
     if (!lyr || lyr.geometry_type !== 'point')
       stop$1(layerTypeMessage(lyr, "Expected a point layer", msg));
   }
 
   function requireSinglePointLayer(lyr, msg) {
-    requirePointLayer$1(lyr);
+    requirePointLayer$2(lyr);
     if (countMultiPartFeatures(lyr.shapes) > 0) {
       stop$1(msg || 'This command requires single points; layer contains multi-point features.');
     }
@@ -6128,7 +6128,7 @@
     requireDataFields: requireDataFields,
     requireNotRasterLayer: requireNotRasterLayer,
     requirePathLayer: requirePathLayer,
-    requirePointLayer: requirePointLayer$1,
+    requirePointLayer: requirePointLayer$2,
     requirePolygonLayer: requirePolygonLayer,
     requirePolylineLayer: requirePolylineLayer,
     requireSinglePointLayer: requireSinglePointLayer,
@@ -7549,19 +7549,19 @@
       pointN = [CK.lengthMG, CK.lengthMG * Math.tan(30 * D2R$5)];
       CK.pointA = [CK.lengthMA, 0];
       CK.pointB = lineIntersection(CK.pointM, 30, CK.pointA, 45);
-      CK.lengthAG = distance$1(CK.pointA, CK.pointG);
-      CK.lengthAB = distance$1(CK.pointA, CK.pointB);
-      lengthMB = distance$1(CK.pointM, CK.pointB);
-      lengthMN = distance$1(CK.pointM, pointN);
-      lengthNG = distance$1(pointN, CK.pointG);
+      CK.lengthAG = distance$2(CK.pointA, CK.pointG);
+      CK.lengthAB = distance$2(CK.pointA, CK.pointB);
+      lengthMB = distance$2(CK.pointM, CK.pointB);
+      lengthMN = distance$2(CK.pointM, pointN);
+      lengthNG = distance$2(pointN, CK.pointG);
       CK.pointD = interpolate(lengthMB, lengthMN, pointN, CK.pointM);
       CK.pointF = [CK.lengthMG, lengthNG - lengthMB];
       CK.pointE = [
         pointN[0] - CK.lengthMA * Math.sin(30 * D2R$5),
         pointN[1] - CK.lengthMA * Math.cos(30 * D2R$5)
       ];
-      CK.lengthGF = distance$1(CK.pointG, CK.pointF);
-      CK.lengthBD = distance$1(CK.pointB, CK.pointD);
+      CK.lengthGF = distance$2(CK.pointG, CK.pointF);
+      CK.lengthBD = distance$2(CK.pointB, CK.pointD);
       CK.lengthGFE = CK.lengthGF + CK.lengthAB;
       CK.deltaMEq = CK.lengthGFE / 45;
       CK.lengthAP75 = 15 * CK.lengthParallel73to90At0;
@@ -7588,7 +7588,7 @@
           k * CK.pointD[0] - CK.pointD[1])
       );
       CK.pointC[0] = k * CK.pointC[1];
-      CK.radius = distance$1(CK.pointC, CK.pointD);
+      CK.radius = distance$2(CK.pointC, CK.pointD);
     }
 
     function ll2mp(lon, lat) {
@@ -7619,12 +7619,12 @@
       );
       var l15;
       if (hit[0]) {
-        l15 = lT + distance$1(jointT(m), hit[1]);
+        l15 = lT + distance$2(jointT(m), hit[1]);
       } else {
         hit = circleLineIntersection(
           CK.pointC, CK.radius, jointE(m), jointT(m)
         );
-        l15 = lT - distance$1(jointT(m), hit[1]);
+        l15 = lT - distance$2(jointT(m), hit[1]);
       }
       return p <= 15 ? zoneK(m, p, l15) : zoneL(m, p, l15);
     }
@@ -7660,8 +7660,8 @@
     function zoneH(m, p) {
       var p75 = parallel75(45);
       var p73 = parallel73(m).parallel73;
-      var lF = distance$1(CK.pointT, CK.pointB);
-      var lF75 = distance$1(CK.pointB, p75);
+      var lF = distance$2(CK.pointT, CK.pointB);
+      var lF75 = distance$2(CK.pointB, p75);
       var l = (75 - p) * (lF75 + lF) / 2;
       return l <= lF75 ?
         interpolate(l, lF75, p75, CK.pointB) :
@@ -7688,7 +7688,7 @@
     function zoneJ(m, p) {
       var p75 = parallel75(m);
       var p73a = parallel73(m);
-      var lF75 = distance$1(jointF(m), p75);
+      var lF75 = distance$2(jointF(m), p75);
       var l = (75 - p) * (lF75 - p73a.lengthParallel73) / 2;
       return l <= lF75 ?
         interpolate(l, lF75, p75, jointF(m)) :
@@ -7745,11 +7745,11 @@
     }
 
     function lengthTorridSegment(m) {
-      return distance$1(jointE(m), jointT(m));
+      return distance$2(jointE(m), jointT(m));
     }
 
     function lengthMiddleSegment(m) {
-      return distance$1(jointT(m), jointF(m));
+      return distance$2(jointT(m), jointF(m));
     }
 
     function parallel73(m) {
@@ -7757,15 +7757,15 @@
       var jF = jointF(m);
       if (m <= 30) {
         p73 = radialPoint(CK.pointA, CK.lengthAP73, m);
-        lF = distance$1(jF, p73);
+        lF = distance$2(jF, p73);
       } else {
         p73 = lineIntersection(CK.pointT, -60, jF, m);
-        lF = distance$1(jF, p73);
+        lF = distance$2(jF, p73);
         if (m > 44) {
           xy = lineIntersection(CK.pointT, -60, jF, 2 * m / 3);
           if (xy[0] > p73[0]) {
             p73 = xy;
-            lF = -distance$1(jF, p73);
+            lF = -distance$2(jF, p73);
           }
         }
       }
@@ -7838,7 +7838,7 @@
     return createCahillKeyesTransform(mg, true);
   }
 
-  function distance$1(a, b) {
+  function distance$2(a, b) {
     return Math.hypot(a[0] - b[0], a[1] - b[1]);
   }
 
@@ -26245,10 +26245,10 @@
       parts.unshift('hatches');
       obj = parseHatches(parts); // hatches is the default, name can be omitted
     }
-    if (!obj) {
-      // consider
-      message('Invalid pattern, ignoring:', str);
-    }
+    // Silent: this is also how a value is tested for being a pattern at all
+    // (-style tries every value as a literal before trying it as an
+    // expression), so a failure here is not necessarily a mistake. The SVG
+    // exporter reports the patterns it has to drop.
     return obj;
   }
 
@@ -26365,10 +26365,116 @@
     return String(str).trim().split(splitRxp);
   }
 
+  // The id of the <pattern> element a fill-pattern code is exported as. It is
+  // also how the code is recovered when an exported SVG is imported again (see
+  // decodePatternId()), so a change here has to keep decoding the ids of files
+  // that are already out there.
   function getHashId(str) {
     return ('hash_' + str).replace(/[()# ,_]+/g, '_'); // replace some chars that occur in colors
   }
 
+  // The fill-pattern code a <pattern> id was made from, or null if the id is not
+  // one of ours. The id keeps the tokens of the code but drops the # of a hex
+  // colour and the parentheses and commas of rgb() and hsl(), so those are put
+  // back by where the colours fall in each pattern type's syntax. A hex colour
+  // has to have its # back even where the parser would not need it: without it,
+  // a colour of digits reads as a number.
+  function decodePatternId(id) {
+    var tokens, code;
+    if (!/^hash_./.test(id || '')) return null;
+    tokens = mergeColorFunctions(id.substr(5).split('_').filter(Boolean));
+    tokens = restoreHexColors(tokens);
+    if (!tokens) return null;
+    code = tokens.join(' ');
+    return parsePattern(code) ? code : null;
+  }
+
+  function mergeColorFunctions(tokens) {
+    var out = [];
+    var tok, argc, args;
+    for (var i=0; i<tokens.length; i++) {
+      tok = tokens[i];
+      if (/^(rgb|hsl)a?$/i.test(tok)) {
+        argc = /a$/i.test(tok) ? 4 : 3;
+        args = tokens.slice(i + 1, i + 1 + argc);
+        i += args.length;
+        if (tokens[i + 1] == '/' && i + 2 < tokens.length) {
+          // space-separated form with an alpha: rgb(0 0 0 / 50%)
+          out.push(tok + '(' + args.join(' ') + ' / ' + tokens[i + 2] + ')');
+          i += 2;
+        } else {
+          out.push(tok + '(' + args.join(',') + ')');
+        }
+      } else {
+        out.push(tok);
+      }
+    }
+    return out;
+  }
+
+  // Marks each token as a colour or not, by pattern type, and gives the colours
+  // that look like hex values their # back. Returns null for an unknown type.
+  function restoreHexColors(tokens) {
+    var type = tokens[0] || '';
+    var colorAt;
+    if (type.startsWith('dot') || type.startsWith('square')) {
+      colorAt = getDotColorPositions(tokens);
+    } else if (type.startsWith('dash')) {
+      colorAt = getDashColorPositions(tokens);
+    } else if (type.startsWith('hatch') || isNumberToken(type)) {
+      colorAt = getHatchColorPositions(tokens);
+    } else {
+      return null;
+    }
+    return tokens.map(function(tok, i) {
+      return colorAt[i] && /^[0-9a-f]+$/i.test(tok) && [3, 4, 6, 8].includes(tok.length) ?
+        '#' + tok : tok;
+    });
+  }
+
+  // [hatches] [rotation] width1 color1 [width2 color2 ...]
+  function getHatchColorPositions(tokens) {
+    var start = isNumberToken(tokens[0]) ? 0 : 1;
+    var rest = tokens.length - start;
+    var first = start + (rest % 2 == 1 ? 1 : 0); // odd count: a rotation first
+    return tokens.map(function(tok, i) {
+      return i >= first && (i - first) % 2 == 1;
+    });
+  }
+
+  // dots|squares [rotation] size color1 [color2 ...] spacing background
+  function getDotColorPositions(tokens) {
+    var last = tokens.length - 1;
+    // A rotation is there if the second number is also a size -- but a colour
+    // of digits looks like a number too, so a bare one counts as a colour
+    // unless a unit or a decimal point says otherwise.
+    var rotated = /deg$/.test(tokens[1] || '') ||
+      last >= 5 && isNumberToken(tokens[2]) && !mightBeHexDigits(tokens[2]);
+    var firstColor = rotated ? 3 : 2;
+    return tokens.map(function(tok, i) {
+      return i == last || i >= firstColor && i < last - 1;
+    });
+  }
+
+  // dashes [rotation] dash-length space-length width color1 [color2 ...] spacing background
+  function getDashColorPositions(tokens) {
+    var last = tokens.length - 1;
+    var rotated = /deg$/.test(tokens[1] || '') ||
+      last >= 7 && isNumberToken(tokens[4]) && !mightBeHexDigits(tokens[4]);
+    var firstColor = rotated ? 5 : 4;
+    return tokens.map(function(tok, i) {
+      return i == last || i >= firstColor && i < last - 1;
+    });
+  }
+
+  function isNumberToken(tok) {
+    return /^-?(\d+\.?\d*|\.\d+)(px|deg)?$/.test(tok || '');
+  }
+
+  function mightBeHexDigits(tok) {
+    return /^\d+$/.test(tok) && [3, 4, 6, 8].includes(tok.length);
+  }
+
   // properties: properties object of a path data object (prior to conversion to SVG)
   // defs: array of definition objects
   //
@@ -26382,13 +26488,19 @@
       if (!hash) return;
       defs.push(hash);
     }
-    properties.fill = hash.href;
+    // The feature's own fill is kept as the paint's fallback colour, which SVG
+    // draws only if the pattern cannot be. It is also how the fill survives
+    // being exported and imported again.
+    properties.fill = properties.fill ? hash.href + ' ' + properties.fill : hash.href;
   }
 
   function makeSVGPatternFill(str, id) {
     var o = parsePattern(str);
     var svg;
-    if (!o) return null;
+    if (!o) {
+      message('Invalid pattern, ignoring:', str);
+      return null;
+    }
     if (o.type == 'hatches') {
       svg = makeHatchPatternSVG(o);
     } else if (o.type == 'dots' || o.type == 'squares') {
@@ -26459,6 +26571,8 @@
   var SvgHatch = /*#__PURE__*/Object.freeze({
     __proto__: null,
     convertFillPattern: convertFillPattern,
+    decodePatternId: decodePatternId,
+    getHashId: getHashId,
     parseDashes: parseDashes,
     parseDots: parseDots,
     parseHatches: parseHatches,
@@ -26756,6 +26870,11 @@
     'callout-color': 'color',
     'callout-width': 'number',
     'callout-opacity': 'number',
+    // arrowheads at the ends of a line -- see svg-line-arrows.mjs. Drawn as
+    // shapes, not written as attributes, so not in propertiesBySymbolType.
+    'line-start': 'lineend',
+    'line-end': 'lineend',
+    'line-end-size': 'number',
     'letter-spacing': 'measure',
     'line-height': 'measure',
     opacity: 'number',
@@ -27067,6 +27186,8 @@
       val = parseCalloutType(strVal);
     } else if (type == 'calloutend') {
       val = parseCalloutEnd(strVal);
+    } else if (type == 'lineend') {
+      val = parseLineEnd(strVal);
     } else if (type == 'pointpair') {
       val = parsePointPair(strVal);
       val = val ? formatPointPair(val) : null;
@@ -27118,6 +27239,12 @@
     return /^(arrow|open-arrow|none)$/.test(end) ? end : null;
   }
 
+  // A line's ends take a callout's markers, and a dot
+  function parseLineEnd(str) {
+    var end = String(str).trim().toLowerCase();
+    return end == 'dot' ? end : parseCalloutEnd(end);
+  }
+
   // "x,y" -> [x, y], or null. Stored as a string so that a pair is set and
   // cleared as one value and reads plainly in a table.
   function parsePointPair(str) {
@@ -27237,6 +27364,7 @@
     parseCalloutEnd: parseCalloutEnd,
     parseCalloutType: parseCalloutType,
     parseLabelPosition: parseLabelPosition,
+    parseLineEnd: parseLineEnd,
     parsePointPair: parsePointPair,
     parseStyleLiteral: parseStyleLiteral,
     parseSvgMeasure: parseSvgMeasure,
@@ -27383,6 +27511,126 @@
     splitLabelHalos: splitLabelHalos
   });
 
+  // Bold words inside a label: label-text='Israel <b>restricted access</b> here'.
+  //
+  // The markup is part of the text rather than a column beside it, so that the
+  // words and their weight cannot drift apart: an expression, a join or a -labels
+  // text= that rewrites the text rewrites the bold with it. The GUI editor never
+  // shows the tags -- it reads them into ranges and writes them back.
+  //
+  // Only a matched <b>...</b> pair with no other b tag inside it is markup.
+  // Anything else -- an unclosed <b>, a stray </b>, "a < b" -- is text, and is
+  // drawn as typed.
+  //
+  // See docs/development/label-tool-design.md.
+
+  var BOLD_PAIR_RXP = /<b>((?:(?!<\/?b>)[\s\S])*?)<\/b>/gi;
+  var BOLD_TAG_RXP = /<\/?b>/i;
+
+  // The font-weight a bold run is drawn with: the keyword, which a browser and
+  // the Node text measurer both resolve to the family's own bold face.
+  var LABEL_BOLD_WEIGHT = 'bold';
+
+  // @str -> {text, bold}: the text with its bold pairs removed, and the bold
+  // stretches as ascending, non-overlapping [start, end) offsets into it.
+  function parseBoldMarkup(str) {
+    var s = str === null || str === undefined ? '' : String(str);
+    var text = '', bold = [], last = 0, m;
+    if (!BOLD_TAG_RXP.test(s)) return {text: s, bold: bold};
+    BOLD_PAIR_RXP.lastIndex = 0;
+    while ((m = BOLD_PAIR_RXP.exec(s))) {
+      text += s.substring(last, m.index);
+      if (m[1]) {
+        bold.push([text.length, text.length + m[1].length]);
+        text += m[1];
+      }
+      last = m.index + m[0].length;
+    }
+    text += s.substring(last);
+    return {text: text, bold: normalizeBoldRanges(bold)};
+  }
+
+  function stripBoldMarkup(str) {
+    return parseBoldMarkup(str).text;
+  }
+
+  // Sorted, clipped to non-empty, with touching and overlapping ranges merged.
+  // Returns a new array.
+  function normalizeBoldRanges(ranges) {
+    var sorted = (ranges || []).filter(function(r) {
+      return r && r[1] > r[0];
+    }).map(function(r) {
+      return [r[0], r[1]];
+    }).sort(function(a, b) {
+      return a[0] - b[0];
+    });
+    var out = [];
+    sorted.forEach(function(r) {
+      var prev = out[out.length - 1];
+      if (prev && r[0] <= prev[1]) {
+        prev[1] = Math.max(prev[1], r[1]);
+      } else {
+        out.push(r);
+      }
+    });
+    return out;
+  }
+
+  // The characters [start, end) of @text as runs of one weight:
+  // [{text, bold}, ...], with nothing for an empty stretch.
+  function getBoldRuns(text, bold, start, end) {
+    var runs = [], pos = start, i, r, a, b;
+    for (i = 0; i < bold.length && pos < end; i++) {
+      r = bold[i];
+      a = Math.max(r[0], pos);
+      b = Math.min(r[1], end);
+      if (b <= a) continue;
+      if (a > pos) runs.push({text: text.substring(pos, a), bold: false});
+      runs.push({text: text.substring(a, b), bold: true});
+      pos = b;
+    }
+    if (pos < end) runs.push({text: text.substring(pos, end), bold: false});
+    return runs;
+  }
+
+  // @runs -> @obj with the first plain run as its value and the rest as <tspan>s,
+  // which is the shape the stringifier writes as mixed content. A label with no
+  // bold in it comes out exactly as it did before bold existed: one value and no
+  // children. Returns @obj.
+  function applyRunsToSvgObject(obj, runs) {
+    var i = 0;
+    var children = [];
+    if (runs.length > 0 && !runs[0].bold) {
+      obj.value = runs[0].text;
+      i = 1;
+    } else {
+      obj.value = '';
+    }
+    for (; i < runs.length; i++) {
+      children.push(renderRun(runs[i]));
+    }
+    if (children.length > 0) {
+      obj.children = children.concat(obj.children || []);
+    }
+    return obj;
+  }
+
+  function renderRun(run) {
+    var o = {tag: 'tspan', value: run.text};
+    if (run.bold) o.properties = {'font-weight': LABEL_BOLD_WEIGHT};
+    return o;
+  }
+
+  var SvgLabelMarkup = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    LABEL_BOLD_WEIGHT: LABEL_BOLD_WEIGHT,
+    applyRunsToSvgObject: applyRunsToSvgObject,
+    getBoldRuns: getBoldRuns,
+    normalizeBoldRanges: normalizeBoldRanges,
+    parseBoldMarkup: parseBoldMarkup,
+    stripBoldMarkup: stripBoldMarkup
+  });
+
   // Accepting \n (two chars) as an alternative to the newline character
   // (sometimes, '\n' is not converted to newline, e.g. in a Makefile)
   // Also accepting <br>
@@ -27399,21 +27647,45 @@
   var anyLabelBreakRxp = /(\n|\\n|<br>|<wbr>)/i;
   var softBreakRxp = /^<wbr>$/i;
 
-  // The lines a label's text is drawn as. Whitespace before a soft break is
-  // dropped: a trailing space would move an end- or middle-justified line by a
-  // space's width.
+  // The lines a label's text is drawn as, without its bold markup.
   function splitLabelLines(text) {
-    var parts = String(text).split(anyLabelBreakRxp);
-    var lines = [parts[0]];
+    return splitLabelLineRuns(text).map(function(runs) {
+      return runs.map(function(run) { return run.text; }).join('');
+    });
+  }
+
+  // The lines a label's text is drawn as, each one a list of runs of one weight:
+  // [[{text, bold}, ...], ...]. A bold stretch can cross a line break, and is
+  // then a run on each line.
+  //
+  // Whitespace before a soft break is dropped: a trailing space would move an
+  // end- or middle-justified line by a space's width.
+  function splitLabelLineRuns(text) {
+    var o = parseBoldMarkup(String(text));
+    var parts = o.text.split(anyLabelBreakRxp);
+    var pos = parts[0].length;
+    var lines = [getBoldRuns(o.text, o.bold, 0, pos)];
     for (var i = 1; i < parts.length; i += 2) {
       if (softBreakRxp.test(parts[i])) {
-        lines[lines.length - 1] = lines[lines.length - 1].replace(/\s+$/, '');
+        trimTrailingSpace(lines[lines.length - 1]);
       }
-      lines.push(parts[i + 1]);
+      pos += parts[i].length;
+      lines.push(getBoldRuns(o.text, o.bold, pos, pos + parts[i + 1].length));
+      pos += parts[i + 1].length;
     }
     return lines;
   }
 
+  function trimTrailingSpace(runs) {
+    var last;
+    while (runs.length > 0) {
+      last = runs[runs.length - 1];
+      last.text = last.text.replace(/\s+$/, '');
+      if (last.text) return;
+      runs.pop();
+    }
+  }
+
   function removeSoftBreaks(text) {
     return String(text).replace(/<wbr>/gi, '');
   }
@@ -27464,7 +27736,7 @@
     // already been through it, so calling it here as well costs nothing and means
     // every way into the renderer draws a label in the position it is stored in.
     var rec = resolveLabelPosition(recArg);
-    var morelines = splitLabelLines(toLabelString(rec['label-text']));
+    var morelines = splitLabelLineRuns(toLabelString(rec['label-text']));
     var line = morelines.shift();
     var obj;
     var dx = applyAlignmentShift(rec);
@@ -27475,23 +27747,21 @@
       y: dy,
       x: dx
     };
-    obj = {
+    obj = applyRunsToSvgObject({
       tag: 'text',
-      value: line,
       properties: properties
-    };
+    }, line);
     if (morelines.length > 0) {
       // multiline label
-      obj.children = [];
+      obj.children = obj.children || [];
       morelines.forEach(function(line) {
-        var tspan = {
+        var tspan = applyRunsToSvgObject({
           tag: 'tspan',
-          value: line,
           properties: {
             x: dx,
             dy: getLineHeightDy(rec['line-height'])
           }
-        };
+        }, line);
         obj.children.push(tspan);
       });
     }
@@ -27591,11 +27861,91 @@
     removeSoftBreaks: removeSoftBreaks,
     renderLabel: renderLabel$1,
     renderStyledLabel: renderStyledLabel,
+    splitLabelLineRuns: splitLabelLineRuns,
     splitLabelLines: splitLabelLines,
     toLabelString: toLabelString,
     toPixels: toPixels
   });
 
+  // Arrowhead geometry shared by label callouts (svg-label-callout.mjs) and the
+  // ends of line features (svg-line-arrows.mjs), so that the two draw the same
+  // heads. Everything is in px, y down.
+
+  // The angle at an arrowhead's point, degrees. The open one is wider, since a
+  // narrow chevron drawn with a line reads as a thickened line more than as an
+  // arrow.
+  var ARROW_ANGLE = 35;
+  var OPEN_ARROW_ANGLE = 70;
+  // How far into a solid arrowhead the line reaches, as a fraction of the
+  // head's length: far enough that its cap is hidden, short of the tip.
+  var ARROW_LINE_OVERLAP = 0.7;
+
+  var DEFAULT_LINE_WIDTH$2 = 1;
+
+  // An arrowhead's size when nothing says, in px: the length of its sides. 10
+  // for a 1px line, growing with the line, so that a heavier line does not end
+  // in a head too small to read.
+  function getDefaultArrowSize(lineWidth) {
+    var w = lineWidth > 0 ? lineWidth : DEFAULT_LINE_WIDTH$2;
+    return 7 + 3 * w;
+  }
+
+  // [tip, wing, wing], for a head with sides @side long meeting at @angle degrees,
+  // pointing at @tip from direction @dir (a unit vector from the tip back along
+  // the line)
+  function getArrowHead(tip, dir, side, angle) {
+    var len = getArrowHeadLength(side, angle);
+    var half = side * Math.sin(angle / 2 * Math.PI / 180);
+    var bx = tip[0] + dir[0] * len;
+    var by = tip[1] + dir[1] * len;
+    return [tip, [bx - dir[1] * half, by + dir[0] * half], [bx + dir[1] * half, by - dir[0] * half]];
+  }
+
+  // How far along the line a head with sides @side long reaches
+  function getArrowHeadLength(side, angle) {
+    return side * Math.cos(angle / 2 * Math.PI / 180);
+  }
+
+  // The part of polyline @coords after it first leaves the circle of radius @r
+  // around its first point, starting on the circle; or null if it never does.
+  function trimPolyline$1(coords, r) {
+    var p0 = coords[0];
+    for (var i = 1; i < coords.length; i++) {
+      if (distance$1(p0, coords[i]) > r) {
+        return [getCircleExit(p0, r, coords[i - 1], coords[i])].concat(coords.slice(i));
+      }
+    }
+    return null;
+  }
+
+  // The point where segment @p-@q, which starts inside the circle and ends
+  // outside it, crosses it.
+  function getCircleExit(c, r, p, q) {
+    var dx = q[0] - p[0];
+    var dy = q[1] - p[1];
+    var ex = p[0] - c[0];
+    var ey = p[1] - c[1];
+    var a = dx * dx + dy * dy;
+    var b = 2 * (dx * ex + dy * ey);
+    var k = ex * ex + ey * ey - r * r;
+    var s = (-b + Math.sqrt(Math.max(0, b * b - 4 * a * k))) / (2 * a);
+    s = Math.max(0, Math.min(1, s));
+    return [p[0] + s * dx, p[1] + s * dy];
+  }
+
+  function getUnitVector(p, q) {
+    var dx = q[0] - p[0];
+    var dy = q[1] - p[1];
+    var len = Math.sqrt(dx * dx + dy * dy);
+    return len > 0 ? [dx / len, dy / len] : null;
+  }
+
+  function distance$1(p, q) {
+    var dx = q[0] - p[0];
+    var dy = q[1] - p[1];
+    return Math.sqrt(dx * dx + dy * dy);
+  }
+
   // A callout: a line from a label's anchor to its text, straight, elbowed or
   // curved, optionally ending in an arrowhead at the anchor. A dot at the anchor
   // is the label's icon, not a callout marker.
@@ -27608,7 +27958,7 @@
   // See docs/development/text-annotation-design.md.
 
   var DEFAULT_PADDING$1 = 3;
-  var DEFAULT_LINE_WIDTH = 1;
+  var DEFAULT_LINE_WIDTH$1 = 1;
   // 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
@@ -27616,14 +27966,6 @@
   // The shortest first leg an automatic elbow into the top or bottom of the text
   // is drawn with, px
   var MIN_LEG = 8;
-  // The angle at an arrowhead's point, degrees. The open one is wider, since a
-  // narrow chevron drawn with a line reads as a thickened line more than as an
-  // arrow.
-  var ARROW_ANGLE = 44;
-  var OPEN_ARROW_ANGLE = 70;
-  // How far into a solid arrowhead the line reaches, as a fraction of the
-  // head's length: far enough that its cap is hidden, short of the tip.
-  var ARROW_LINE_OVERLAP = 0.7;
   // Where glyphs sit relative to their baseline, in ems, for estimating the
   // height of a block of text that is measured only for its width
   var ASCENT = 0.8;
@@ -27668,8 +28010,7 @@
   // default line, and growing with the line, so that a heavier line does not end
   // in a head too small to read.
   function getDefaultCalloutEndSize(end, lineWidth) {
-    var w = lineWidth > 0 ? lineWidth : DEFAULT_LINE_WIDTH;
-    return 7 + 3 * w;
+    return getDefaultArrowSize(lineWidth);
   }
 
   // 'arrow', 'open-arrow' or 'none'
@@ -27777,7 +28118,7 @@
       v = o.via || getAutoElbow(a, t, box);
       // A corner on either end is no corner -- straight under the text, say --
       // and a leg of no length has no direction for an arrowhead to take.
-      path = {kind: 'polyline', coords: distance(a, v) > 0 && distance(v, t) > 0 ?
+      path = {kind: 'polyline', coords: distance$1(a, v) > 0 && distance$1(v, t) > 0 ?
         [a, v, t] : [a, t]};
     } else if (o.type == 'curve') {
       v = o.via || getAutoBend(a, t);
@@ -27805,7 +28146,7 @@
       // the chevron's point: the point is set back by that much, so that the
       // arrow ends where a filled one would. The join and the round cap at the
       // far end each add half a line width to an arm, which is taken off it.
-      lineWidth = o.width > 0 ? o.width : DEFAULT_LINE_WIDTH;
+      lineWidth = o.width > 0 ? o.width : DEFAULT_LINE_WIDTH$1;
       path = trimPath(path, lineWidth / 2) || path;
       dir = getStartDirection(path);
       if (!dir) return null;
@@ -27982,44 +28323,21 @@
   function hasLength(path) {
     var c = path.coords;
     for (var i = 1; i < c.length; i++) {
-      if (distance(c[0], c[i]) > 0) return true;
+      if (distance$1(c[0], c[i]) > 0) return true;
     }
     return false;
   }
 
   function trimPolyline(coords, r) {
-    var p0 = coords[0];
-    for (var i = 1; i < coords.length; i++) {
-      if (distance(p0, coords[i]) > r) {
-        return {
-          kind: 'polyline',
-          coords: [getCircleExit(p0, r, coords[i - 1], coords[i])].concat(coords.slice(i))
-        };
-      }
-    }
-    return null;
-  }
-
-  // The point where segment @p-@q, which starts inside the circle and ends
-  // outside it, crosses it.
-  function getCircleExit(c, r, p, q) {
-    var dx = q[0] - p[0];
-    var dy = q[1] - p[1];
-    var ex = p[0] - c[0];
-    var ey = p[1] - c[1];
-    var a = dx * dx + dy * dy;
-    var b = 2 * (dx * ex + dy * ey);
-    var k = ex * ex + ey * ey - r * r;
-    var s = (-b + Math.sqrt(Math.max(0, b * b - 4 * a * k))) / (2 * a);
-    s = Math.max(0, Math.min(1, s));
-    return [p[0] + s * dx, p[1] + s * dy];
+    var trimmed = trimPolyline$1(coords, r);
+    return trimmed ? {kind: 'polyline', coords: trimmed} : null;
   }
 
   function trimBezier(c, r) {
     var steps = 64;
     var lo = 0, hi = -1, mid, i;
     for (i = 1; i <= steps; i++) {
-      if (distance(c[0], getBezierPoint(c, i / steps)) > r) {
+      if (distance$1(c[0], getBezierPoint(c, i / steps)) > r) {
         hi = i / steps;
         lo = (i - 1) / steps;
         break;
@@ -28028,7 +28346,7 @@
     if (hi < 0) return null;
     for (i = 0; i < 24; i++) {
       mid = (lo + hi) / 2;
-      if (distance(c[0], getBezierPoint(c, mid)) > r) hi = mid;
+      if (distance$1(c[0], getBezierPoint(c, mid)) > r) hi = mid;
       else lo = mid;
     }
     return {kind: 'bezier', coords: splitBezier(c, hi)};
@@ -28054,7 +28372,7 @@
   function getStartDirection(path) {
     var c = path.coords;
     var next = c[1];
-    if (path.kind == 'bezier' && distance(c[0], c[1]) === 0) next = c[2];
+    if (path.kind == 'bezier' && distance$1(c[0], c[1]) === 0) next = c[2];
     return getUnitVector(c[0], next);
   }
 
@@ -28086,8 +28404,8 @@
     ctrl = intersectRays(start, dir, end, getUnitVector(end, rest.coords[1]));
     // A curve that doubles back, or runs straight on: a control point on the
     // head's axis still takes the line out of the head straight.
-    if (!ctrl) ctrl = [start[0] + dir[0] * distance(start, end) / 2,
-      start[1] + dir[1] * distance(start, end) / 2];
+    if (!ctrl) ctrl = [start[0] + dir[0] * distance$1(start, end) / 2,
+      start[1] + dir[1] * distance$1(start, end) / 2];
     return {dir: dir, path: {kind: 'bezier', coords: [start, ctrl, end]}};
   }
 
@@ -28105,20 +28423,6 @@
     return s > 0 && u > 0 ? [p[0] + d[0] * s, p[1] + d[1] * s] : null;
   }
 
-  // [tip, wing, wing], for a head with sides @side long meeting at @angle degrees
-  function getArrowHead(tip, dir, side, angle) {
-    var len = getArrowHeadLength(side, angle);
-    var half = side * Math.sin(angle / 2 * Math.PI / 180);
-    var bx = tip[0] + dir[0] * len;
-    var by = tip[1] + dir[1] * len;
-    return [tip, [bx - dir[1] * half, by + dir[0] * half], [bx + dir[1] * half, by - dir[0] * half]];
-  }
-
-  // How far along the line a head with sides @side long reaches
-  function getArrowHeadLength(side, angle) {
-    return side * Math.cos(angle / 2 * Math.PI / 180);
-  }
-
   // Utilities
 
   function padBox$1(box, pad) {
@@ -28135,19 +28439,6 @@
     return p[0] > box.xmin && p[0] < box.xmax && p[1] > box.ymin && p[1] < box.ymax;
   }
 
-  function getUnitVector(p, q) {
-    var dx = q[0] - p[0];
-    var dy = q[1] - p[1];
-    var len = Math.sqrt(dx * dx + dy * dy);
-    return len > 0 ? [dx / len, dy / len] : null;
-  }
-
-  function distance(p, q) {
-    var dx = q[0] - p[0];
-    var dy = q[1] - p[1];
-    return Math.sqrt(dx * dx + dy * dy);
-  }
-
   function lerp(p, q, t) {
     return [p[0] + (q[0] - p[0]) * t, p[1] + (q[1] - p[1]) * t];
   }
@@ -28157,8 +28448,8 @@
   }
 
   function getLineWidth(rec) {
-    var w = getNumber(rec['callout-width'], DEFAULT_LINE_WIDTH);
-    return w > 0 ? w : DEFAULT_LINE_WIDTH;
+    var w = getNumber(rec['callout-width'], DEFAULT_LINE_WIDTH$1);
+    return w > 0 ? w : DEFAULT_LINE_WIDTH$1;
   }
 
   function getFontSizeInPx$1(rec) {
@@ -28211,6 +28502,9 @@
     return str;
   }
 
+  // A ring icon's stroke, unless the record sets one; 1px read as too faint.
+  var RING_STROKE_WIDTH = 1.5;
+
   var symbolRenderers = {
     line: line,
     polygon: polygon,
@@ -28283,6 +28577,7 @@
     if (type == 'square') return square(getIconStyleData(d, r), 0, 0);
     if (type == 'ring') return ring(getIconStyleData(d, r), 0, 0);
     if (type == 'star') return star(getIconStyleData(d, r));
+    if (type == 'nyt-star') return nytStar(getIconStyleData(d, r));
     return empty();
   }
 
@@ -28292,8 +28587,11 @@
       return d.r > 0 ? d.r : 5;
     }
     size = d['icon-size'];
-    if (type == 'circle' || type == 'ring') {
+    if (type == 'circle') {
       size -= 1;
+    } else if (type == 'ring') {
+      // the stroke's outer half is inside icon-size
+      size -= RING_STROKE_WIDTH;
     } else if (type == 'star') {
       size += 1;
     }
@@ -28400,7 +28698,7 @@
     o.properties.fill = 'none';
     o.properties.stroke = d.fill;
     if (!o.properties['stroke-width']) {
-      o.properties['stroke-width'] = 1;
+      o.properties['stroke-width'] = RING_STROKE_WIDTH;
     }
     return o;
   }
@@ -28412,6 +28710,43 @@
     return o;
   }
 
+  // A white nine-pointed star with a heavy outline in the icon's colour, drawn
+  // from the source artwork's 40-unit box. The box includes the outline and its
+  // mitred points, so icon-size is the width of the whole symbol.
+  var NYT_STAR_BOX = 40;
+  var NYT_STAR_STROKE = 5;
+  var NYT_STAR_POINTS = [19.9843, 5.7196, 23.1494, 11.7629, 29.4528, 9.1512,
+    27.9924, 15.8152, 34.5, 17.8645, 29.0961, 22.0321, 32.7631, 27.7841,
+    25.9457, 27.504, 25.0572, 34.2675, 20.0149, 29.6714, 14.9847, 34.2804,
+    14.0769, 27.5192, 7.2619, 27.8167, 10.9166, 22.0553, 5.5, 17.9016,
+    12.0024, 15.8357, 10.527, 9.1754, 16.835, 11.771];
+
+  function nytStar(d) {
+    var k = d.r * 2 / NYT_STAR_BOX;
+    var o = importPolygon([getNytStarCoords(k)]);
+    applyStyleAttributes(o, 'point', d, nonCirclePointFilter);
+    o.properties.stroke = o.properties.fill;
+    o.properties.fill = '#fff';
+    o.properties['stroke-width'] = roundToHundredths(NYT_STAR_STROKE * k);
+    o.properties['stroke-miterlimit'] = 10;
+    return o;
+  }
+
+  function getNytStarCoords(k) {
+    var c = NYT_STAR_BOX / 2;
+    var coords = [];
+    for (var i=0; i<NYT_STAR_POINTS.length; i+=2) {
+      coords.push([roundToHundredths((NYT_STAR_POINTS[i] - c) * k),
+        roundToHundredths((NYT_STAR_POINTS[i + 1] - c) * k)]);
+    }
+    coords.push(coords[0].concat());
+    return coords;
+  }
+
+  function roundToHundredths(n) {
+    return Math.round(n * 100) / 100;
+  }
+
   function nonCirclePointFilter(k) {
     return k != 'r';
   }
@@ -28491,6 +28826,7 @@
 
   var SvgSymbols = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    RING_STROKE_WIDTH: RING_STROKE_WIDTH,
     featureHasIcon: featureHasIcon,
     getAnchorSymbolRadius: getAnchorSymbolRadius,
     getIconRadius: getIconRadius,
@@ -29627,16 +29963,14 @@
       // a <tspan> inside a <textPath> advances along the path instead of
       // stacking below it, so the lines are joined rather than dropping
       // everything after the first one
-      text = text.split(labelNewlineRxp).join(' ');
       addToReport(report, 'joined', id);
     }
-    textPath = {
+    textPath = applyRunsToSvgObject({
       tag: 'textPath',
-      value: text,
       properties: {
         startOffset: rec['label-start-offset'] || getDefaultStartOffset(rec)
       }
-    };
+    }, joinLineRuns(splitLabelLineRuns(text)));
     // the caller replaces this with a reference to a <defs> entry
     textPath.properties[LABEL_PATH_PROPERTY] = d;
     if (rec['label-side']) {
@@ -29700,6 +30034,28 @@
     return '50%';
   }
 
+  // A path label's lines as one line of runs, with a space for each break. The
+  // space takes the weight of the text before it, and runs of one weight that
+  // the join brings together are merged, so that text with no bold in it is a
+  // single run.
+  function joinLineRuns(lines) {
+    var out = [];
+    lines.forEach(function(runs, i) {
+      if (i > 0) appendRun(out, {text: ' ', bold: out.length > 0 && out[out.length - 1].bold});
+      runs.forEach(function(run) { appendRun(out, run); });
+    });
+    return out;
+  }
+
+  function appendRun(runs, run) {
+    var last = runs[runs.length - 1];
+    if (last && last.bold == run.bold) {
+      last.text += run.text;
+    } else {
+      runs.push({text: run.text, bold: run.bold});
+    }
+  }
+
   function addToReport(report, key, id) {
     if (report && report[key]) report[key].push(id);
   }
@@ -29913,6 +30269,198 @@
   }
   */
 
+  // Markers at the ends of line features: line-start= and line-end= take
+  // arrow (a filled triangle), open-arrow (a stroked chevron), dot (a filled
+  // circle centred on the end) or none, and line-end-size= is the length of a
+  // head's sides in px, for both ends, or a dot's diameter. A dot with no size
+  // of its own is DOT_SIZE_RATIO of an arrowhead's default size.
+  //
+  // The heads are drawn as shapes rather than as SVG <marker>s, so that the
+  // canvas in the GUI and the exported SVG draw the same thing, and so that a
+  // solid head can have the line stop inside it, where its cap is hidden. Every
+  // part of a multi-part line gets its own heads: part order is not something
+  // the commands that make multi-part lines preserve.
+  //
+  // Coordinates are px, y down: the SVG export's space, or the canvas's.
+
+  var DEFAULT_LINE_WIDTH = 1;
+  // 6px across at the default size for a 1px line
+  var DOT_SIZE_RATIO = 0.6;
+
+  // 'arrow', 'open-arrow', 'dot' or 'none'
+  function getLineEndType(rec, field) {
+    return rec && rec[field] && parseLineEnd(rec[field]) || 'none';
+  }
+
+  function lineHasArrows(rec) {
+    return getLineEndType(rec, 'line-start') != 'none' ||
+      getLineEndType(rec, 'line-end') != 'none';
+  }
+
+  // What getLineArrowShape() needs from a record, at scale @scale (the factor
+  // the canvas multiplies line widths by; 1 for SVG).
+  function getLineArrowOpts(rec, scale) {
+    return makeLineArrowOpts(rec['line-start'], rec['line-end'], rec['line-end-size'],
+      rec['stroke-width'], scale);
+  }
+
+  // The same, from the values themselves, for the canvas, which has them in a
+  // style object rather than a record.
+  function makeLineArrowOpts(start, end, size, strokeWidth, scale) {
+    var k = scale > 0 ? scale : 1;
+    var w = isSvgNumber(strokeWidth) && Number(strokeWidth) >= 0 ?
+      Number(strokeWidth) : DEFAULT_LINE_WIDTH;
+    var hasSize = isSvgNumber(size) && Number(size) > 0;
+    var side = hasSize ? Number(size) : getDefaultArrowSize(w);
+    return {
+      start: start && parseLineEnd(start) || 'none',
+      end: end && parseLineEnd(end) || 'none',
+      size: side * k,
+      dotSize: (hasSize ? side : side * DOT_SIZE_RATIO) * k,
+      width: w * k
+    };
+  }
+
+  // Field names, for a layer that may have them
+  var lineArrowFields = ['line-start', 'line-end', 'line-end-size'];
+
+  // One part of a line, with its heads: {coords, heads}, where coords is the
+  // line to stroke -- cut back into a solid head, so that its cap does not show
+  // past the tip -- and heads is a list of {type, points}: a solid head's
+  // triangle, tip first, or an open head's chevron, wing to tip to wing. A dot
+  // is {type, center, radius}.
+  //
+  // A head points along the chord from its tip to where the line first reaches
+  // the head's length from it, rather than along the last segment, which on
+  // detailed or noisy data can be a jog of a fraction of a pixel pointing
+  // anywhere. The line is then straightened to meet the head along its axis. An
+  // end whose part is too short to hold its head gets none.
+  function getLineArrowShape(coords, opts) {
+    var out = {coords: coords, heads: []};
+    var end;
+    if (opts.start != 'none') {
+      addHead(out, opts.start, opts);
+    }
+    if (opts.end != 'none') {
+      end = {coords: out.coords.slice().reverse(), heads: out.heads};
+      addHead(end, opts.end, opts);
+      out.coords = end.coords.reverse();
+    }
+    return out;
+  }
+
+  // Puts a head of @type at the first point of @shape.coords
+  function addHead(shape, type, opts) {
+    var coords = shape.coords;
+    var width = opts.width > 0 ? opts.width : DEFAULT_LINE_WIDTH;
+    var tip, side, angle, len, rest, dir, head;
+    if (!coords || coords.length < 2) return;
+    if (type == 'dot') {
+      addDot(shape, (opts.dotSize || opts.size * DOT_SIZE_RATIO) / 2);
+      return;
+    }
+    if (type == 'open-arrow') {
+      // Stroked with a round join, which reaches half a line width past the
+      // chevron's point: the point is set back by that much, so that the arrow
+      // ends where a solid one would, and the arms lose half a line width each
+      // to the join and the cap.
+      coords = trimPolyline$1(coords, width / 2);
+      if (!coords) return;
+      side = Math.max(opts.size - width, opts.size / 2);
+      angle = OPEN_ARROW_ANGLE;
+    } else {
+      side = opts.size;
+      angle = ARROW_ANGLE;
+    }
+    tip = coords[0];
+    len = getArrowHeadLength(side, angle);
+    rest = trimPolyline$1(coords, len);
+    dir = rest ? getUnitVector(tip, rest[0]) : null;
+    if (!dir) return;
+    head = getArrowHead(tip, dir, side, angle);
+    if (type == 'open-arrow') {
+      shape.heads.push({type: type, points: [head[1], head[0], head[2]]});
+      shape.coords = [tip].concat(rest);
+    } else {
+      shape.heads.push({type: type, points: head});
+      shape.coords = [[tip[0] + dir[0] * len * ARROW_LINE_OVERLAP,
+        tip[1] + dir[1] * len * ARROW_LINE_OVERLAP]].concat(rest);
+    }
+  }
+
+  // The line stops halfway to the dot's edge, which hides its cap in the dot
+  // (for lines narrower than the dot's radius) while overlapping it no more than
+  // a solid head does. A part too short to be cut back keeps its dot.
+  function addDot(shape, radius) {
+    var center = shape.coords[0];
+    var rest = trimPolyline$1(shape.coords, radius / 2);
+    shape.heads.push({type: 'dot', center: center, radius: radius});
+    if (rest) shape.coords = rest;
+  }
+
+  // A line feature with arrowheads, as SVG: a group holding the line and its
+  // heads, for the feature's style attributes to go on. @parts is a list of
+  // polylines (a LineString's coordinates are one).
+  function renderArrowLine(parts, rec) {
+    var opts = getLineArrowOpts(rec, 1);
+    var color = rec.stroke || 'black';
+    var lines = [];
+    var children = [];
+    parts.forEach(function(part) {
+      var shape = getLineArrowShape(part, opts);
+      lines.push(shape.coords.map(roundPoint));
+      shape.heads.forEach(function(head) {
+        children.push(renderHead(head, color, rec));
+      });
+    });
+    children.unshift(importMultiLineString(lines));
+    return {tag: 'g', properties: {}, children: children};
+  }
+
+  function renderHead(head, color, rec) {
+    var points, center;
+    if (head.type == 'dot') {
+      center = roundPoint(head.center);
+      return {tag: 'circle', properties: addFillOpacity({cx: center[0], cy: center[1],
+        r: Math.round(head.radius * 100) / 100, fill: color, stroke: 'none'}, rec)};
+    }
+    points = head.points.map(roundPoint);
+    var d = 'M ' + points.map(function(p) { return p[0] + ' ' + p[1]; }).join(' L ');
+    var props;
+    if (head.type == 'arrow') {
+      props = addFillOpacity({d: d + ' Z', fill: color, stroke: 'none'}, rec);
+    } else {
+      // The line's own dashes would break the chevron up, and its cap may be
+      // square or butt; the chevron is always drawn whole and rounded.
+      props = {d: d, fill: 'none', 'stroke-dasharray': 'none',
+        'stroke-linecap': 'round', 'stroke-linejoin': 'round'};
+    }
+    return {tag: 'path', properties: props};
+  }
+
+  // A filled marker is as transparent as the line it is drawn in
+  function addFillOpacity(props, rec) {
+    if (isSvgNumber(rec['stroke-opacity'])) {
+      props['fill-opacity'] = Number(rec['stroke-opacity']);
+    }
+    return props;
+  }
+
+  function roundPoint(p) {
+    return [Math.round(p[0] * 100) / 100, Math.round(p[1] * 100) / 100];
+  }
+
+  var SvgLineArrows = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getLineArrowOpts: getLineArrowOpts,
+    getLineArrowShape: getLineArrowShape,
+    getLineEndType: getLineEndType,
+    lineArrowFields: lineArrowFields,
+    lineHasArrows: lineHasArrows,
+    makeLineArrowOpts: makeLineArrowOpts,
+    renderArrowLine: renderArrowLine
+  });
+
   var geojsonImporters = {
     Point: importPoint,
     Polygon: importPolygon,
@@ -29935,6 +30483,9 @@
         // rather than several labels at several points
         svgObj = renderPathLabel(d, geom.coordinates,
           {report: opts.path_label_report, id: featureId});
+      } else if (msType == 'polyline' && geom.coordinates && lineHasArrows(d)) {
+        svgObj = renderArrowLine(geomType == 'LineString' ?
+          [geom.coordinates] : geom.coordinates, d);
       } else if (geomType && geom.coordinates) {
         svgObj = geojsonImporters[geomType](geom.coordinates, d);
       }
@@ -40716,6 +41267,22 @@ ${svg}
     }
   }
 
+  // -labels adds a label when given coordinates=, and styles the target's labels
+  // otherwise. Options that belong to one of these are refused in the other,
+  // rather than ignored.
+  function validateLabelsOpts(cmd) {
+    var o = cmd.options;
+    if ('coordinates' in o) {
+      if (o.where || o.ids) {
+        stop$1('where= and ids= select labels to style, and can not be used with coordinates=');
+      }
+    } else if (o.properties) {
+      stop$1('properties= requires coordinates=');
+    } else if ('name' in o && !o.no_replace) {
+      stop$1('name= requires coordinates= or +');
+    }
+  }
+
   function validateExpressionOpt(cmd) {
     if (!cmd.options.expression) {
       error('Command requires a JavaScript expression');
@@ -41696,17 +42263,17 @@ ${svg}
         nameOpt2 = { // for -calc and -info
           describe: 'name the output layer'
         },
-        // label style properties accepted by -add-label, so that a label can be
-        // created and styled in one command. These are a subset of the
-        // properties -style accepts -- the ones that apply to text.
+        // label style properties accepted by -labels and -add-label. -style
+        // accepts these too, for backward compatibility, but leaves them out of
+        // its help.
         labelStyleOpts = {
-          'font-family': {describe: 'label font, e.g. Georgia'},
-          'font-size': {describe: 'label font size, e.g. 14'},
+          'font-family': {describe: 'CSS font family, e.g. Georgia (default is sans-serif)'},
+          'font-size': {describe: 'font size (default is 12)'},
           'font-style': {describe: 'normal or italic'},
           '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; a bare number is a multiple of the font size'},
+          'line-height': {describe: 'spacing between lines of a multi-line label; a bare number is a multiple of the font size (default is 1.1)'},
           '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'},
@@ -41717,23 +42284,30 @@ ${svg}
           dy: {describe: 'vertical offset from the anchor'},
           fill: {describe: 'text color'},
           opacity: {describe: 'text opacity'},
-          'halo-width': {describe: 'width of a halo around the text in px'},
+          'halo-width': {describe: 'width of a halo around the text in px (default is 0, no halo)'},
           'halo-color': {describe: 'halo color (default is white)'},
           'halo-opacity': {describe: 'halo opacity, 0-1'},
-          'label-width': {describe: 'width of a fixed-width text block in px'},
+          'label-width': {describe: 'width of a fixed-width text block in px (lines are wrapped in the web UI)'},
           callout: {describe: 'line from the anchor to the text: line, elbow or curve'},
           'callout-end': {describe: 'arrowhead at the anchor end: arrow, open-arrow or none'},
-          'callout-end-size': {describe: 'length of an arrowhead\'s sides in px'},
+          'callout-end-size': {describe: 'length of an arrowhead\'s sides in px (default is 10)'},
           'callout-via': {describe: 'x,y of an elbow\'s corner or a point on a curve, in px'},
           'callout-attach': {describe: 'where the callout meets the text, as x,y fractions'},
           'callout-gap': {describe: 'px between the callout and the anchor'},
-          'callout-padding': {describe: 'px between the callout and the text'},
+          'callout-padding': {describe: 'px between the callout and the text (default is 3)'},
           'callout-color': {describe: 'callout color (defaults to the text color)'},
-          'callout-width': {describe: 'callout line width in px'},
+          'callout-width': {describe: 'callout line width in px (default is 1)'},
           'callout-opacity': {describe: 'callout opacity, 0-1'},
           css: {describe: 'inline css style'},
           class: {describe: 'name of CSS class or classes (space-separated)'}
         },
+        // a label can carry a symbol at its anchor
+        labelIconOpts = {
+          icon: {describe: 'symbol drawn at the label anchor: circle, square, ring, star'},
+          'icon-size': {describe: 'size of the anchor symbol in px'},
+          'icon-color': {describe: 'color of the anchor symbol (defaults to the text color)'},
+          'icon-opacity': {describe: 'opacity of the anchor symbol, 0-1'}
+        },
         noReplaceOpt2 = { // for -calc and -info
           alias: '+',
           type: 'flag',
@@ -41813,6 +42387,18 @@ ${svg}
           type: 'distance'
         };
 
+    // The label options -style used to document, before -labels took them over.
+    // fill, opacity, css and class are left out because -style documents them
+    // for every kind of feature.
+    function getHiddenLabelStyleOpts() {
+      var shared = ['fill', 'opacity', 'css', 'class'];
+      var opts = {'label-text': {}};
+      Object.keys(labelStyleOpts).forEach(function(name) {
+        if (shared.indexOf(name) == -1) opts[name] = {};
+      });
+      return opts;
+    }
+
     var parser = new CommandParser();
     parser.usage('Usage:  mapshaper -<command> [options] ...');
 
@@ -43181,6 +43767,32 @@ ${svg}
       .option('encoding', encodingOpt)
       .option('target', targetOpt);
 
+    parser.command('labels')
+      .describe('style labels, convert points to labels or add a label')
+      .validate(validateLabelsOpts)
+      .option('text', {
+        describe: 'label text (a field, JS expression or literal value)'
+      })
+      .option('label-text', {
+        alias_to: 'text'
+      })
+      .option('coordinates', {
+        describe: 'add a label at x,y, or a path label along x,y,x,y,...'
+      })
+      .option('where', whereOpt)
+      .option('ids', {
+        describe: 'comma-sep. list of ids of the labels to style',
+        type: 'numbers'
+      })
+      .options(labelStyleOpts)
+      .options(labelIconOpts)
+      .option('properties', {
+        describe: 'with coordinates=, other attributes as a JSON object'
+      })
+      .option('name', nameOpt)
+      .option('no-replace', noReplaceOpt)
+      .option('target', targetOpt);
+
     parser.command('lines')
       .describe('convert a polygon or point layer to a polyline layer')
       .option('fields', {
@@ -43728,6 +44340,15 @@ ${svg}
       .option('stroke-opacity', {
         describe: 'stroke opacity'
       })
+      .option('line-start', {
+        describe: 'marker at the start of each line: arrow, open-arrow, dot or none'
+      })
+      .option('line-end', {
+        describe: 'marker at the end of each line: arrow, open-arrow, dot or none'
+      })
+      .option('line-end-size', {
+        describe: 'length of an arrowhead\'s sides in px (default grows with stroke-width)'
+      })
       .option('opacity', {
         describe: 'opacity; example: 0.5'
       })
@@ -43744,99 +44365,11 @@ ${svg}
         describe: 'point icon color (defaults to fill color, then black)'
       })
       .option('icon-opacity', {
-        describe: 'point icon opacity, 0-1 (defaults to the label\'s opacity)'
-      })
-      .option('label-text', {
-        describe: 'label text (set this to export points as labels)'
-      })
-      .option('label-pos', {
-        describe: 'label position; one of: n, s, e, w, ne, se, nw, sw, c'
-      })
-      .option('text-anchor', {
-        describe: 'label alignment; one of: start, end, middle (default)'
-      })
-      .option('label-align', {
-        describe: 'alignment of the lines of multi-line labels; left, center or right'
-      })
-      .option('halo-width', {
-        describe: 'width of a halo around label text in px (default is 0, no halo)'
-      })
-      .option('halo-color', {
-        describe: 'color of label halos (default is white)'
-      })
-      .option('halo-opacity', {
-        describe: 'opacity of label halos, 0-1'
-      })
-      .option('dx', {
-        describe: 'x offset of labels (default is 0)'
-      })
-      .option('dy', {
-        describe: 'y offset of labels (default is 0/baseline-aligned)'
-      })
-      .option('font-size', {
-        describe: 'size of label text (default is 12)'
-      })
-      .option('font-family', {
-        describe: 'CSS font family of labels (default is sans-serif)'
+        describe: 'point icon opacity, 0-1'
       })
-      .option('font-weight', {
-        describe: 'CSS font weight property of labels (e.g. bold, 700)'
-      })
-      .option('font-style', {
-        describe: 'CSS font style property of labels (e.g. italic)'
-      })
-      .option('font-stretch', {
-        describe: 'CSS font stretch property of labels (e.g. condensed)'
-      })
-      .option('letter-spacing', {
-        describe: 'CSS letter-spacing property of labels'
-      })
-       .option('line-height', {
-        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)'
-      })
-      .option('label-side', {
-        describe: 'which side of its path a label sits on: left or right'
-      })
-      .option('label-start-offset', {
-        describe: 'where label text starts along its path, e.g. 50%'
-      })
-      .option('label-width', {
-        describe: 'width of a fixed-width text block in px (lines are wrapped in the web UI)'
-      })
-      .option('callout', {
-        describe: 'line from a label\'s anchor to its text: line, elbow or curve'
-      })
-      .option('callout-end', {
-        describe: 'arrowhead at the anchor end of a callout: arrow (solid), open-arrow or none'
-      })
-      .option('callout-end-size', {
-        describe: 'length of an arrowhead\'s sides in px (default 10, more for a thicker line)'
-      })
-      .option('callout-via', {
-        describe: 'x,y of an elbow\'s corner or a point on a curve, in px from the anchor'
-      })
-      .option('callout-attach', {
-        describe: 'where a callout meets its text, as x,y fractions of the text box'
-      })
-      .option('callout-gap', {
-        describe: 'px between a callout and its anchor (default: a line meets the icon, an arrow clears it)'
-      })
-      .option('callout-padding', {
-        describe: 'px between a callout and its text (default is 3)'
-      })
-      .option('callout-color', {
-        describe: 'callout color (defaults to the text color)'
-      })
-      .option('callout-width', {
-        describe: 'callout line width in px (default is 1)'
-      })
-      .option('callout-opacity', {
-        describe: 'callout opacity, 0-1'
-      })
-     .option('target', targetOpt);
+      // deprecated in favor of -labels; accepted, but left out of the help
+      .options(getHiddenLabelStyleOpts())
+      .option('target', targetOpt);
 
     parser.command('repel')
       .describe('move overlapping point symbols apart')
@@ -44082,23 +44615,10 @@ ${svg}
       .option('text', {
         describe: 'label text'
       })
-      // label style properties, so that creating and styling a label is one
-      // command; anything not listed here can be set with a following -style
+      // superseded by -labels coordinates=; kept so that older session
+      // histories still run
       .options(labelStyleOpts)
-      // a label can carry a symbol at its anchor, so these come along too even
-      // though they are not text properties
-      .option('icon', {
-        describe: 'symbol drawn at the label anchor: circle, square, ring, star'
-      })
-      .option('icon-size', {
-        describe: 'size of the anchor symbol in px'
-      })
-      .option('icon-color', {
-        describe: 'color of the anchor symbol (defaults to the text color)'
-      })
-      .option('icon-opacity', {
-        describe: 'opacity of the anchor symbol, 0-1'
-      })
+      .options(labelIconOpts)
       .option('properties', {
         describe: 'other attributes, as a JSON object'
       })
@@ -49441,9 +49961,28 @@ ${svg}
         props[key] = val;
       }
     }
+    importPatternFill(props);
     return props;
   }
 
+  // A fill of url(#id), with or without a fallback colour after it, is a
+  // reference to a paint server in <defs>. The ones mapshaper exports are
+  // pattern fills whose id encodes the fill-pattern code, and the fallback is
+  // the feature's own fill. A reference that is not one of those is dropped:
+  // nothing can draw a url() stored as a colour. Its fallback, if any, is kept.
+  function importPatternFill(props) {
+    var match = /^url\(\s*['"]?#([^'")]+)['"]?\s*\)\s*(.*)$/.exec(String(props.fill || '').trim());
+    var code;
+    if (!match) return;
+    code = decodePatternId(match[1]);
+    if (code) props['fill-pattern'] = code;
+    if (match[2]) {
+      props.fill = match[2];
+    } else {
+      delete props.fill;
+    }
+  }
+
   function getNodeStyles(node) {
     var styles = {};
     var attrs = node.attributes || [];
@@ -51395,6 +51934,626 @@ ${svg}
     return d;
   }
 
+  // Insert cutting points in arcs, where bbox intersects other shapes
+  // Return a polygon layer containing the bounding box vectors, divided at cutting points.
+  function divideDatasetByBBox(dataset, bbox) {
+    var arcs = dataset.arcs;
+    var data = findBBoxCutPoints(arcs, bbox);
+    var map = insertCutPoints(data.cutPoints, arcs);
+    arcs.dedupCoords();
+    remapDividedArcs(dataset, map);
+    // merge bbox dataset with target dataset,
+    // so arcs are shared between target layers and bbox layer
+    var clipDataset = bboxPointsToClipDataset(data.bboxPoints);
+    var mergedDataset = mergeDatasets([dataset, clipDataset]);
+    // TODO: detect if we need to rebuild topology (unlikely), like with the full clip command
+    // buildTopology(mergedDataset);
+    var clipLyr = mergedDataset.layers.pop();
+    dataset.arcs = mergedDataset.arcs;
+    dataset.layers = mergedDataset.layers;
+    return clipLyr;
+  }
+
+  function bboxPointsToClipDataset(arr) {
+    var arcs = [];
+    var shape = [];
+    var layer = {geometry_type: 'polygon', shapes: [[shape]]};
+    var p1, p2;
+    for (var i=0, n=arr.length - 1; i<n; i++) {
+      p1 = arr[i];
+      p2 = arr[i+1];
+      arcs.push([[p1.x, p1.y], [p2.x, p2.y]]);
+      shape.push(i);
+    }
+    return {
+      arcs: new ArcCollection(arcs),
+      layers: [layer]
+    };
+  }
+
+  function findBBoxCutPoints(arcs, bbox) {
+    var left = bbox[0],
+        bottom = bbox[1],
+        right = bbox[2],
+        top = bbox[3];
+
+    // arrays of intersection points along each bbox edge
+    var tt = [],
+        rr = [],
+        bb = [],
+        ll = [];
+
+    arcs.forEachSegment(function(i, j, xx, yy) {
+      var ax = xx[i],
+          ay = yy[i],
+          bx = xx[j],
+          by = yy[j];
+      var hit;
+      if (segmentOutsideBBox(ax, ay, bx, by, left, bottom, right, top)) return;
+      if (segmentInsideBBox(ax, ay, bx, by, left, bottom, right, top)) return;
+
+      hit = geom.segmentIntersection(left, top, right, top, ax, ay, bx, by);
+      if (hit) addHit(tt, hit, i, j, xx, yy);
+
+      hit = geom.segmentIntersection(left, bottom, right, bottom, ax, ay, bx, by);
+      if (hit) addHit(bb, hit, i, j, xx, yy);
+
+      hit = geom.segmentIntersection(left, bottom, left, top, ax, ay, bx, by);
+      if (hit) addHit(ll, hit, i, j, xx, yy);
+
+      hit = geom.segmentIntersection(right, bottom, right, top, ax, ay, bx, by);
+      if (hit) addHit(rr, hit, i, j, xx, yy);
+    });
+
+    return {
+      cutPoints: ll.concat(bb, rr, tt),
+      bboxPoints: getDividedBBoxPoints(bbox, ll, tt, rr, bb)
+    };
+
+    function addHit(arr, hit, i, j, xx, yy) {
+      if (!hit) return;
+      arr.push(formatHit(hit[0], hit[1], i, j, xx, yy));
+      if (hit.length == 4) {
+        arr.push(formatHit(hit[2], hit[3], i, j, xx, yy));
+      }
+    }
+
+    function formatHit(x, y, i, j, xx, yy) {
+      var ids = formatIntersectingSegment(x, y, i, j, xx, yy);
+      return getCutPoint(x, y, ids[0], ids[1]);
+    }
+  }
+
+  function segmentOutsideBBox(ax, ay, bx, by, xmin, ymin, xmax, ymax) {
+    return ax < xmin && bx < xmin || ax > xmax && bx > xmax ||
+        ay < ymin && by < ymin || ay > ymax && by > ymax;
+  }
+
+  function segmentInsideBBox(ax, ay, bx, by, xmin, ymin, xmax, ymax) {
+    return ax > xmin && bx > xmin && ax < xmax && bx < xmax &&
+        ay > ymin && by > ymin && ay < ymax && by < ymax;
+  }
+
+  // Returns an array of points representing the vertices in
+  // the bbox with cutting points inserted.
+  function getDividedBBoxPoints(bbox, ll, tt, rr, bb) {
+    var bl = {x: bbox[0], y: bbox[1]},
+        tl = {x: bbox[0], y: bbox[3]},
+        tr = {x: bbox[2], y: bbox[3]},
+        br = {x: bbox[2], y: bbox[1]};
+    ll = utils.sortOn(ll.concat([bl, tl]), 'y', true);
+    tt = utils.sortOn(tt.concat([tl, tr]), 'x', true);
+    rr = utils.sortOn(rr.concat([tr, br]), 'y', false);
+    bb = utils.sortOn(bb.concat([br, bl]), 'x', false);
+    return ll.concat(tt, rr, bb).reduce(function(memo, p2) {
+      var p1 = memo.length > 0 ? memo[memo.length-1] : null;
+      if (p1 === null || p1.x != p2.x || p1.y != p2.y) memo.push(p2);
+      return memo;
+    }, []);
+  }
+
+  var Bbox2Clipping = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    divideDatasetByBBox: divideDatasetByBBox,
+    segmentInsideBBox: segmentInsideBBox,
+    segmentOutsideBBox: segmentOutsideBBox
+  });
+
+  cmd.filterGeom = function(lyr, arcs, opts) {
+    if (!layerHasGeometry$1(lyr)) {
+      stop$1("Layer is missing geometry");
+    }
+    if (opts.bbox) {
+      filterByBoundsIntersection(lyr, arcs, opts);
+    }
+    cmd.filterFeatures(lyr, arcs, {remove_empty: true, verbose: false});
+  };
+
+  function filterByBoundsIntersection(lyr, arcs, opts) {
+    var filter = getBoundsIntersectionFilter(opts.bbox, lyr, arcs);
+    noteLayerWillChange(lyr, {operation: 'filter-geom', unit: 'shapes'});
+    editShapes(lyr.shapes, filter);
+    markLayerChanged(lyr, {operation: 'filter-geom', unit: 'shapes'});
+  }
+
+  function getBoundsIntersectionFilter(bbox, lyr, arcs) {
+    var bounds = new Bounds(bbox);
+    var filter = lyr.geometry_type == 'point' ?
+          getPointInBoundsTest(bounds) :
+          getPathBoundsIntersectionTest(bounds, arcs);
+    return filter;
+  }
+
+  function getPointInBoundsTest(bounds) {
+    return function(xy) {
+      var contains =  bounds.containsPoint(xy[0], xy[1]);
+      return contains ? xy : null;
+    };
+  }
+
+  // V1 too-simple test: bounding-box intersection
+  // internal.getPathBoundsIntersectionTest = function(bounds, arcs) {
+  //   return function(path) {
+  //     return bounds.intersects(arcs.getSimpleShapeBounds(path)) ? path : null;
+  //   };
+  // };
+
+  function getPathBoundsIntersectionTest(bounds, arcs) {
+    var bbox = bounds.toArray(),
+      left = bbox[0],
+      bottom = bbox[1],
+      right = bbox[2],
+      top = bbox[3];
+
+    return function(path) {
+      // case: bounding boxes don't intersect -> the path doesn't intersect the box
+      if (!bounds.intersects(arcs.getSimpleShapeBounds(path))) {
+        return null;
+      }
+      var intersects = false;
+      var ax, ay, bx, by;
+      var iter = arcs.getShapeIter(path);
+
+      if (iter.hasNext()) {
+        ax = iter.x;
+        ay = iter.y;
+      }
+      while (iter.hasNext()) {
+        bx = ax;
+        by = ay;
+        ax = iter.x;
+        ay = iter.y;
+        if (segmentOutsideBBox(ax, ay, bx, by, left, bottom, right, top)) continue;
+        if (segmentInsideBBox(ax, ay, bx, by, left, bottom, right, top)) {
+          intersects = true;
+          break;
+        }
+        if (geom.segmentIntersection(left, top, right, top, ax, ay, bx, by) ||
+            geom.segmentIntersection(left, bottom, right, bottom, ax, ay, bx, by) ||
+            geom.segmentIntersection(left, bottom, left, top, ax, ay, bx, by) ||
+            geom.segmentIntersection(right, bottom, right, top, ax, ay, bx, by)) {
+          intersects = true;
+          break;
+        }
+      }
+
+      // case: bbox is entirely inside this ring
+      if (!intersects && geom.testPointInRing(left, bottom, path, arcs)) {
+        intersects = true;
+      }
+      return intersects ? path : null;
+    };
+  }
+
+  // Return a function for testing if a shape (path or point) intersects a bounding box
+  // TODO: move this function to a different file
+  function getBBoxIntersectionTest(bbox, lyr, arcs) {
+    var filter = getBoundsIntersectionFilter(bbox, lyr, arcs);
+    return function(shapeId) {
+      var shp = lyr.shapes[shapeId];
+      if (!shp) return false;
+      for (var i=0; i<shp.length; i++) {
+        if (filter(shp[i])) return true;
+      }
+      return false;
+    };
+  }
+
+  // return array of shape ids
+  function findShapesIntersectingBBox(bbox, lyr, arcs) {
+    var test = getBBoxIntersectionTest(bbox, lyr, arcs);
+    var ids = [];
+    for (var i=0; i<lyr.shapes.length; i++) {
+      if (test(i)) ids.push(i);
+    }
+    return ids;
+  }
+
+  var FilterGeom = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    findShapesIntersectingBBox: findShapesIntersectingBBox,
+    getBBoxIntersectionTest: getBBoxIntersectionTest
+  });
+
+  cmd.filterFeatures = function(lyr, arcs, opts) {
+    var records = lyr.data ? lyr.data.getRecords() : null,
+        shapes = lyr.shapes || null,
+        n = getFeatureCount(lyr),
+        filteredShapes = shapes ? [] : null,
+        filteredRecords = records ? [] : null,
+        filteredLyr = getOutputLayer(lyr, opts),
+        invert = !!opts.invert,
+        filter;
+
+    if (opts.expression) {
+      filter = compileFeatureExpression(opts.expression, lyr, arcs);
+    }
+
+    if (opts.ids) {
+      filter = combineFilters(filter, getIdFilter(opts.ids));
+    }
+
+    if (opts.remove_empty) {
+      filter = combineFilters(filter, getNullGeometryFilter(lyr, arcs));
+    }
+
+    if (opts.bbox) {
+      filter = combineFilters(filter, getBBoxIntersectionTest(opts.bbox, lyr, arcs));
+    }
+
+    if (!filter) {
+      stop$1("Missing a filter criterion");
+    }
+
+    utils.repeat(n, function(shapeId) {
+      var result = filter(shapeId);
+      requireBooleanResult(result);
+      if (invert) result = !result;
+      if (result === true) {
+        if (shapes) filteredShapes.push(shapes[shapeId] || null);
+        if (records) filteredRecords.push(records[shapeId] || null);
+      }
+    });
+
+    if (filteredLyr == lyr) {
+      noteLayerWillChange(lyr, {operation: 'filter'});
+    }
+    filteredLyr.shapes = filteredShapes;
+    filteredLyr.data = filteredRecords ? new DataTable(filteredRecords) : null;
+    if (filteredLyr == lyr) {
+      markLayerChanged(lyr, {operation: 'filter'});
+    }
+    if (opts.no_replace) {
+      // if adding a layer, don't share objects between source and filtered layer
+      filteredLyr = copyLayer(filteredLyr);
+    }
+
+    if (opts.verbose !== false && !opts.quiet) {
+      message(utils.format('Retained %,d of %,d features', getFeatureCount(filteredLyr), n));
+    }
+
+    return filteredLyr;
+  };
+
+  // TODO: update filter command to use this function
+  function filterLayerInPlace(lyr, filter, invert) {
+    var records = lyr.data ? lyr.data.getRecords() : null,
+        shapes = lyr.shapes || null,
+        n = getFeatureCount(lyr),
+        filteredShapes = shapes ? [] : null,
+        filteredRecords = records ? [] : null;
+    utils.repeat(n, function(shapeId) {
+      var result = filter(shapeId);
+      requireBooleanResult(result);
+      if (result === true) {
+        if (shapes) filteredShapes.push(shapes[shapeId] || null);
+        if (records) filteredRecords.push(records[shapeId] || null);
+      }
+    });
+    noteLayerWillChange(lyr, {operation: 'filterLayerInPlace'});
+    lyr.shapes = filteredShapes;
+    lyr.data = filteredRecords ? new DataTable(filteredRecords) : null;
+    markLayerChanged(lyr, {operation: 'filterLayerInPlace'});
+  }
+
+  function getIdFilter(ids) {
+    var set = new Set(ids);
+    return function(i) {
+      return set.has(i);
+    };
+  }
+
+  function getNullGeometryFilter(lyr, arcs) {
+    var shapes = lyr.shapes;
+    if (lyr.geometry_type == 'polygon') {
+      return getEmptyPolygonFilter(shapes, arcs);
+    }
+    return function(i) {return !!shapes[i];};
+  }
+
+  function getEmptyPolygonFilter(shapes, arcs) {
+    return function(i) {
+      var shp = shapes[i];
+      return !!shp && geom.getPlanarShapeArea(shapes[i], arcs) > 0;
+    };
+  }
+
+  function combineFilters(a, b) {
+    return a && b ? function(id) {
+        return a(id) && b(id);
+      } : (a || b);
+  }
+
+  // The icon names accepted by the icon= property of the -style command.
+  // Kept in a module of its own so that both the renderer (svg-symbols.mjs) and
+  // the -style command can use it without forming an import cycle.
+
+  var iconNames = ['circle', 'square', 'ring', 'star'];
+
+  // Icons that render everywhere but are not advertised: the GUI offers them only
+  // to some users (see gui-nyt.mjs), and a map made with one has to draw the same
+  // for anyone who opens it.
+  var unlistedIconNames = ['nyt-star'];
+
+  function isSupportedIconName(name) {
+    return iconNames.indexOf(name) > -1 || unlistedIconNames.indexOf(name) > -1;
+  }
+
+  cmd.svgStyle = function(lyr, dataset, opts) {
+    var filterFn, table, fields, hasNewFields, optFields, clearedByPosition, fieldsBefore;
+
+    function hadField(field) {
+      return field in fieldsBefore;
+    }
+
+    if (getFeatureCount(lyr) === 0) {
+      return;
+    }
+    if (!lyr.data) {
+      initDataTable(lyr);
+    }
+    if (opts.where) {
+      filterFn = compileFeatureExpression(opts.where, lyr, dataset.arcs);
+    }
+    if (opts.ids) {
+      filterFn = combineFilters(filterFn, getIdFilter(opts.ids));
+    }
+    if (opts.clear) {
+      lyr.data.getFields().filter(isSupportedSvgStyleProperty).forEach(lyr.data.deleteField, lyr.data);
+    }
+    table = getLayerDataTable(lyr);
+    optFields = getOptionFields(opts);
+    fields = getStyleFields(optFields);
+    // Which of dx/dy/text-anchor a label-pos in this command clears: not the ones
+    // the same command also sets, so that `label-pos=n dx=3` keeps the nudge it
+    // was given instead of clearing it a moment later.
+    //
+    // Clearing at all is what keeps the shorthand usable, since a value on the
+    // record wins over the position: without it, setting a position on a label
+    // that had been dragged would appear to do nothing.
+    clearedByPosition = labelPositionDerivedFields.filter(function(field) {
+      return optFields.indexOf(field) == -1;
+    });
+    hasNewFields = fields.some(function(field) {
+      return !table.fieldExists(field);
+    });
+    // The table's columns as this command found them. Taken once, because the
+    // command adds to them as it runs, and a blanked property must be judged
+    // against what was there before rather than against what it has just made.
+    fieldsBefore = utils.arrayToIndex(table.getFields());
+    if (fields.length > 0) {
+      if (hasNewFields) {
+        table.captureSchemaBefore({operation: 'style', fields: fields});
+      } else {
+        table.captureFieldsBefore(fields, {operation: 'style'});
+      }
+    }
+    Object.keys(opts).forEach(function(optName) {
+      // undo cli parser name conversion; the regex must be global, or a
+      // property with more than one hyphen (e.g. label-start-offset) is silently
+      // skipped rather than applied
+      var svgName = optName.replace(/_/g, '-');
+      if (!isSupportedSvgStyleProperty(svgName)) {
+        return;
+      }
+      var strVal = opts[optName].trim();
+      // An empty value removes the property, rather than being rejected as an
+      // unparseable one. This is how a control gives a property back: a label
+      // dragged off its position clears label-pos, and there is otherwise no
+      // per-property unset -- only -style clear, which clears all of them.
+      var unset = strVal === '' && emptyValueUnsetsProperty(svgName);
+      var accessor = unset ? null : getSymbolPropertyAccessor(strVal, svgName, lyr);
+      var badIcons = svgName == 'icon' ? [] : null;
+      // Removing a position is not setting one, so it neither validates the
+      // value nor clears the offsets the position would have stood for.
+      var posOnPaths = svgName == 'label-pos' && !unset ? [] : null;
+      table.getRecords().forEach(function(rec, i) {
+        if (filterFn && !filterFn(i)) {
+          // make sure field exists if record is excluded by filter
+          setUndefinedFields(rec, [svgName]);
+          if (svgName == 'label-pos') {
+            // ...but a field the position would only have cleared is one this
+            // command is not writing anywhere, so an excluded record has nothing
+            // to stay consistent with
+            setUndefinedFields(rec, labelPositionDerivedFields, {has: hadField});
+          }
+        } else if (unset) {
+          // Nothing to remove, and so nothing to create: removing a property no
+          // record has would otherwise add an empty column for it.
+          if (hadField(svgName) || svgName in rec) rec[svgName] = undefined;
+        } else {
+          rec[svgName] = accessor(i);
+          if (badIcons) {
+            addUnsupportedIconName(badIcons, rec.icon);
+          }
+          if (posOnPaths) {
+            if (!parseLabelPosition(rec['label-pos'])) {
+              stop$1('Unexpected value for label-pos:', rec['label-pos']);
+            }
+            if (shapeIsPathLabel(lyr.shapes && lyr.shapes[i], rec)) {
+              // Not stored, so that ignoring it means ignoring it: a stored
+              // position would show up in the style panel and would start
+              // applying if the label ever lost all but one of its knots. Its
+              // text-anchor is left alone too -- that one does place text along a
+              // path, so a position that had no effect must not clear it.
+              posOnPaths.push(i);
+              rec['label-pos'] = undefined;
+            } else {
+              setUndefinedFields(rec, clearedByPosition, {overwrite: true, has: hadField});
+            }
+          }
+        }
+      });
+      if (badIcons && badIcons.length > 0) {
+        warn(formatUnsupportedIconMessage(badIcons));
+      }
+      if (posOnPaths && posOnPaths.length > 0) {
+        warn(formatPositionOnPathMessage(posOnPaths));
+      }
+    });
+    if (fields.length > 0) {
+      if (hasNewFields) {
+        table.markSchemaChanged({operation: 'style'});
+      } else {
+        table.markFieldsChanged(fields, {operation: 'style'});
+      }
+    }
+  };
+
+  // The style properties this command was given, in SVG spelling.
+  function getOptionFields(opts) {
+    var fields = [];
+    Object.keys(opts).forEach(function(optName) {
+      var svgName = optName.replace(/_/g, '-');
+      if (isSupportedSvgStyleProperty(svgName)) addField(fields, svgName);
+    });
+    return fields;
+  }
+
+  // The fields the command will write, which is what the undo capture covers.
+  // label-pos reaches dx/dy/text-anchor as well -- it no longer stores values in
+  // them, but it does clear them.
+  function getStyleFields(optFields) {
+    var fields = [];
+    optFields.forEach(function(svgName) {
+      addField(fields, svgName);
+      if (svgName == 'label-pos') {
+        labelPositionFields.forEach(function(field) {
+          addField(fields, field);
+        });
+      }
+    });
+    return fields;
+  }
+
+  function addField(fields, field) {
+    if (fields.indexOf(field) == -1) {
+      fields.push(field);
+    }
+  }
+
+  // Icon names can not be validated when options are parsed, because an icon=
+  // value may be a field name or an expression. The assigned values are checked
+  // instead, so that computed names are covered too. Unsupported names are a
+  // warning, not an error -- features with an unsupported name render without an
+  // icon.
+  var maxReportedIconNames = 4;
+
+  function addUnsupportedIconName(names, val) {
+    var name;
+    if (!val) return; // a blank value removes the icon
+    name = String(val);
+    if (isSupportedIconName(name) || names.indexOf(name) > -1) return;
+    names.push(name);
+  }
+
+  function formatUnsupportedIconMessage(names) {
+    var extra = names.length - maxReportedIconNames;
+    var listed = extra > 0 ? names.slice(0, maxReportedIconNames) : names;
+    var str = 'Unsupported icon ' + (names.length > 1 ? 'names' : 'name') + ': ' +
+      listed.join(', ');
+    if (extra > 0) {
+      str += ' (and ' + extra + ' more)';
+    }
+    return str + '. Expected one of: ' + iconNames.join(', ');
+  }
+
+  // Adds @fields to @rec with no value, so that a record the filter excluded
+  // still has the same schema as the ones it kept. With overwrite, also blanks a
+  // value already there -- which is how setting a position takes back the offsets
+  // a label was carrying.
+  //
+  // @has: optional test for whether the layer carries a field at all. A field
+  // nobody has is not created in order to be blanked: -style label-pos=n clears
+  // dx, dy and text-anchor because a value on the record wins over the position,
+  // and there is nothing to win with when the column does not exist. Without
+  // this, clicking a position in the style panel put three empty columns in the
+  // user's table, and three empty columns in their CSV.
+  function setUndefinedFields(rec, fields, opts) {
+    var overwrite = !!(opts && opts.overwrite);
+    var has = opts && opts.has;
+    fields.forEach(function(field) {
+      if (has && !has(field) && field in rec === false) return;
+      if (overwrite || field in rec === false) {
+        rec[field] = undefined;
+      }
+    });
+  }
+
+  // label-pos places text around an anchor point, which a label strung along a
+  // path does not have: its text runs from a start offset in the direction the
+  // path goes. A warning rather than an error, because a layer can hold both
+  // kinds of label and styling all of it at once is reasonable.
+  function formatPositionOnPathMessage(ids) {
+    var extra = ids.length - maxReportedIds;
+    var listed = (extra > 0 ? ids.slice(0, maxReportedIds) : ids).join(', ');
+    return 'Ignoring label-pos on ' + ids.length + ' path ' +
+      (ids.length > 1 ? 'labels' : 'label') + ' (' + listed +
+      (extra > 0 ? ' and ' + extra + ' more' : '') + '). ' +
+      'Use label-start-offset= and text-anchor= to place text along a path.';
+  }
+
+  var maxReportedIds = 4;
+
+  // -labels styles the labels in a point layer, or turns a point layer into
+  // labels by giving it text=. With coordinates=, it adds one label instead; that
+  // case is cmd.addLabel(), dispatched separately because it accepts an empty
+  // target.
+  //
+  // Styling writes the same properties -style writes, through the same code, so
+  // a label styled by either command is the same label.
+  cmd.labels = function(targetLayers, dataset, opts) {
+    var styleOpts = getStyleOpts(opts);
+    var output = targetLayers.map(function(lyr) {
+      var out;
+      requirePointLayer$1(lyr);
+      out = opts.no_replace ? copyLayer(lyr) : lyr;
+      cmd.svgStyle(out, dataset, styleOpts);
+      return out;
+    });
+    return opts.no_replace ? output : null;
+  };
+
+  // text= is label-text= under the name that reads naturally in this command.
+  function getStyleOpts(opts) {
+    var o = Object.assign({}, opts);
+    if ('text' in o) {
+      o.label_text = o.text;
+      delete o.text;
+    }
+    return o;
+  }
+
+  // Labels are drawn at points. A layer with no geometry is let through, since
+  // it has nothing to conflict with.
+  function requirePointLayer$1(lyr) {
+    if (lyr.geometry_type && lyr.geometry_type != 'point') {
+      stop$1('Labels can only be applied to a point layer; layer "' +
+        (lyr.name || '[unnamed]') + '" contains ' + lyr.geometry_type + 's. ' +
+        'Use -points to make a point layer to label.');
+    }
+  }
+
   cmd.addLayer = addLayer;
 
   var GEOMETRY_TYPES = ['point', 'polygon', 'polyline'];
@@ -52297,13 +53456,17 @@ ${svg}
     var sw;
     if (!(r > 0)) return null;
     if (type == 'ring') {
-      // drawn as a stroke, one px wide unless stroke-width says otherwise
+      // drawn as a stroke, RING_STROKE_WIDTH wide unless stroke-width says otherwise
       sw = +d['stroke-width'];
-      return getSquareBox(r + (sw > 0 ? sw : 1) / 2, 0, 0);
+      return getSquareBox(r + (sw > 0 ? sw : RING_STROKE_WIDTH) / 2, 0, 0);
     }
     if (type == 'circle' || type == 'square' || type == 'star') {
       return getSquareBox(r + getStrokeOutset(d), 0, 0);
     }
+    if (type == 'nyt-star') {
+      // the outline is part of the symbol's size (see nytStar())
+      return getSquareBox(r, 0, 0);
+    }
     return null; // unsupported icons are not drawn
   }
 
@@ -53263,10 +54426,10 @@ ${svg}
   }
 
   function isClosedPath$1(arr) {
-    return isArrayOfPoints(arr) && arr.length > 3 && samePoint$2(arr[0], arr[arr.length - 1]);
+    return isArrayOfPoints(arr) && arr.length > 3 && samePoint$3(arr[0], arr[arr.length - 1]);
   }
 
-  function samePoint$2(a, b) {
+  function samePoint$3(a, b) {
     return a[0] == b[0] && a[1] == b[1];
   }
 
@@ -54072,7 +55235,7 @@ ${svg}
   }
 
   cmd.alphaShapes = function(pointLyr, targetDataset, opts) {
-    requirePointLayer$1(pointLyr);
+    requirePointLayer$2(pointLyr);
     if (opts.interval > 0 === false) {
       stop$1('Expected a non-negative interval parameter');
     }
@@ -55453,12 +56616,12 @@ ${svg}
     return arr[arr.length - 1];
   }
 
-  function samePoint$1(a, b) {
+  function samePoint$2(a, b) {
     return a && b && a[0] === b[0] && a[1] === b[1];
   }
 
   function isClosedPath(arr) {
-    return samePoint$1(arr[0], lastEl(arr));
+    return samePoint$2(arr[0], lastEl(arr));
   }
 
   // remove likely rounding errors
@@ -55619,7 +56782,7 @@ ${svg}
       if (!nextPart) {
         return null;
       }
-      if (samePoint$1(ring[0], nextPart[0])) {
+      if (samePoint$2(ring[0], nextPart[0])) {
         // done!
         ring.push(ring[0]); // close the ring
         return ring;
@@ -55668,7 +56831,7 @@ ${svg}
 
   function findPartStartingAt(parts, firstPoint) {
     for (var i=0; i<parts.length; i++) {
-      if (samePoint$1(parts[i][0], firstPoint)) {
+      if (samePoint$2(parts[i][0], firstPoint)) {
         return parts[i];
       }
     }
@@ -55692,7 +56855,7 @@ ${svg}
     var part = [];
     var firstPoint = path[0];
     var lastPoint = lastEl(path);
-    var closed = samePoint$1(firstPoint, lastPoint);
+    var closed = samePoint$2(firstPoint, lastPoint);
     var p, pp, y;
     for (var i=0, n=path.length; i<n; i++) {
       p = path[i];
@@ -60358,10 +61521,10 @@ ${svg}
       var p = recenteredVertex(ctx, points[i]);
       // Successive off-center vertices can re-center onto the same neck point;
       // keep one copy so the chain has no zero-length segments.
-      if (!samePoint(p, out[out.length - 1])) out.push(p);
+      if (!samePoint$1(p, out[out.length - 1])) out.push(p);
     }
     var last = points[points.length - 1];
-    if (!samePoint(last, out[out.length - 1])) out.push(last);
+    if (!samePoint$1(last, out[out.length - 1])) out.push(last);
     return out.length >= 2 ? out : points;
   }
 
@@ -60464,7 +61627,7 @@ ${svg}
     out[1] = ay + t * dy;
   }
 
-  function samePoint(a, b) {
+  function samePoint$1(a, b) {
     return a[0] === b[0] && a[1] === b[1];
   }
 
@@ -61713,131 +62876,6 @@ ${svg}
     normalizeOverlaySource: normalizeOverlaySource
   });
 
-  // Insert cutting points in arcs, where bbox intersects other shapes
-  // Return a polygon layer containing the bounding box vectors, divided at cutting points.
-  function divideDatasetByBBox(dataset, bbox) {
-    var arcs = dataset.arcs;
-    var data = findBBoxCutPoints(arcs, bbox);
-    var map = insertCutPoints(data.cutPoints, arcs);
-    arcs.dedupCoords();
-    remapDividedArcs(dataset, map);
-    // merge bbox dataset with target dataset,
-    // so arcs are shared between target layers and bbox layer
-    var clipDataset = bboxPointsToClipDataset(data.bboxPoints);
-    var mergedDataset = mergeDatasets([dataset, clipDataset]);
-    // TODO: detect if we need to rebuild topology (unlikely), like with the full clip command
-    // buildTopology(mergedDataset);
-    var clipLyr = mergedDataset.layers.pop();
-    dataset.arcs = mergedDataset.arcs;
-    dataset.layers = mergedDataset.layers;
-    return clipLyr;
-  }
-
-  function bboxPointsToClipDataset(arr) {
-    var arcs = [];
-    var shape = [];
-    var layer = {geometry_type: 'polygon', shapes: [[shape]]};
-    var p1, p2;
-    for (var i=0, n=arr.length - 1; i<n; i++) {
-      p1 = arr[i];
-      p2 = arr[i+1];
-      arcs.push([[p1.x, p1.y], [p2.x, p2.y]]);
-      shape.push(i);
-    }
-    return {
-      arcs: new ArcCollection(arcs),
-      layers: [layer]
-    };
-  }
-
-  function findBBoxCutPoints(arcs, bbox) {
-    var left = bbox[0],
-        bottom = bbox[1],
-        right = bbox[2],
-        top = bbox[3];
-
-    // arrays of intersection points along each bbox edge
-    var tt = [],
-        rr = [],
-        bb = [],
-        ll = [];
-
-    arcs.forEachSegment(function(i, j, xx, yy) {
-      var ax = xx[i],
-          ay = yy[i],
-          bx = xx[j],
-          by = yy[j];
-      var hit;
-      if (segmentOutsideBBox(ax, ay, bx, by, left, bottom, right, top)) return;
-      if (segmentInsideBBox(ax, ay, bx, by, left, bottom, right, top)) return;
-
-      hit = geom.segmentIntersection(left, top, right, top, ax, ay, bx, by);
-      if (hit) addHit(tt, hit, i, j, xx, yy);
-
-      hit = geom.segmentIntersection(left, bottom, right, bottom, ax, ay, bx, by);
-      if (hit) addHit(bb, hit, i, j, xx, yy);
-
-      hit = geom.segmentIntersection(left, bottom, left, top, ax, ay, bx, by);
-      if (hit) addHit(ll, hit, i, j, xx, yy);
-
-      hit = geom.segmentIntersection(right, bottom, right, top, ax, ay, bx, by);
-      if (hit) addHit(rr, hit, i, j, xx, yy);
-    });
-
-    return {
-      cutPoints: ll.concat(bb, rr, tt),
-      bboxPoints: getDividedBBoxPoints(bbox, ll, tt, rr, bb)
-    };
-
-    function addHit(arr, hit, i, j, xx, yy) {
-      if (!hit) return;
-      arr.push(formatHit(hit[0], hit[1], i, j, xx, yy));
-      if (hit.length == 4) {
-        arr.push(formatHit(hit[2], hit[3], i, j, xx, yy));
-      }
-    }
-
-    function formatHit(x, y, i, j, xx, yy) {
-      var ids = formatIntersectingSegment(x, y, i, j, xx, yy);
-      return getCutPoint(x, y, ids[0], ids[1]);
-    }
-  }
-
-  function segmentOutsideBBox(ax, ay, bx, by, xmin, ymin, xmax, ymax) {
-    return ax < xmin && bx < xmin || ax > xmax && bx > xmax ||
-        ay < ymin && by < ymin || ay > ymax && by > ymax;
-  }
-
-  function segmentInsideBBox(ax, ay, bx, by, xmin, ymin, xmax, ymax) {
-    return ax > xmin && bx > xmin && ax < xmax && bx < xmax &&
-        ay > ymin && by > ymin && ay < ymax && by < ymax;
-  }
-
-  // Returns an array of points representing the vertices in
-  // the bbox with cutting points inserted.
-  function getDividedBBoxPoints(bbox, ll, tt, rr, bb) {
-    var bl = {x: bbox[0], y: bbox[1]},
-        tl = {x: bbox[0], y: bbox[3]},
-        tr = {x: bbox[2], y: bbox[3]},
-        br = {x: bbox[2], y: bbox[1]};
-    ll = utils.sortOn(ll.concat([bl, tl]), 'y', true);
-    tt = utils.sortOn(tt.concat([tl, tr]), 'x', true);
-    rr = utils.sortOn(rr.concat([tr, br]), 'y', false);
-    bb = utils.sortOn(bb.concat([br, bl]), 'x', false);
-    return ll.concat(tt, rr, bb).reduce(function(memo, p2) {
-      var p1 = memo.length > 0 ? memo[memo.length-1] : null;
-      if (p1 === null || p1.x != p2.x || p1.y != p2.y) memo.push(p2);
-      return memo;
-    }, []);
-  }
-
-  var Bbox2Clipping = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    divideDatasetByBBox: divideDatasetByBBox,
-    segmentInsideBBox: segmentInsideBBox,
-    segmentOutsideBBox: segmentOutsideBBox
-  });
-
   cmd.clipLayers = function(target, src, dataset, opts) {
     return clipLayers(target, src, dataset, "clip", opts);
   };
@@ -64949,7 +65987,7 @@ ${svg}
           debug('Short ring', coords);
           return;
         }
-        if (!samePoint$1(coords[0], lastEl(coords))) {
+        if (!samePoint$2(coords[0], lastEl(coords))) {
           error('Open polygon ring');
         }
         rings.push(coords); // accumulate rings
@@ -64982,7 +66020,7 @@ ${svg}
   cmd.lines = function(lyr, dataset, opts) {
     opts = opts || {};
     if (opts.callouts) {
-      requirePointLayer$1(lyr);
+      requirePointLayer$2(lyr);
       return pointsToCallouts(lyr, dataset, opts);
     } else if (lyr.geometry_type == 'point') {
       return pointsToLines(lyr, dataset, opts);
@@ -75469,231 +76507,6 @@ ${svg}
     return api;
   }
 
-  cmd.filterGeom = function(lyr, arcs, opts) {
-    if (!layerHasGeometry$1(lyr)) {
-      stop$1("Layer is missing geometry");
-    }
-    if (opts.bbox) {
-      filterByBoundsIntersection(lyr, arcs, opts);
-    }
-    cmd.filterFeatures(lyr, arcs, {remove_empty: true, verbose: false});
-  };
-
-  function filterByBoundsIntersection(lyr, arcs, opts) {
-    var filter = getBoundsIntersectionFilter(opts.bbox, lyr, arcs);
-    noteLayerWillChange(lyr, {operation: 'filter-geom', unit: 'shapes'});
-    editShapes(lyr.shapes, filter);
-    markLayerChanged(lyr, {operation: 'filter-geom', unit: 'shapes'});
-  }
-
-  function getBoundsIntersectionFilter(bbox, lyr, arcs) {
-    var bounds = new Bounds(bbox);
-    var filter = lyr.geometry_type == 'point' ?
-          getPointInBoundsTest(bounds) :
-          getPathBoundsIntersectionTest(bounds, arcs);
-    return filter;
-  }
-
-  function getPointInBoundsTest(bounds) {
-    return function(xy) {
-      var contains =  bounds.containsPoint(xy[0], xy[1]);
-      return contains ? xy : null;
-    };
-  }
-
-  // V1 too-simple test: bounding-box intersection
-  // internal.getPathBoundsIntersectionTest = function(bounds, arcs) {
-  //   return function(path) {
-  //     return bounds.intersects(arcs.getSimpleShapeBounds(path)) ? path : null;
-  //   };
-  // };
-
-  function getPathBoundsIntersectionTest(bounds, arcs) {
-    var bbox = bounds.toArray(),
-      left = bbox[0],
-      bottom = bbox[1],
-      right = bbox[2],
-      top = bbox[3];
-
-    return function(path) {
-      // case: bounding boxes don't intersect -> the path doesn't intersect the box
-      if (!bounds.intersects(arcs.getSimpleShapeBounds(path))) {
-        return null;
-      }
-      var intersects = false;
-      var ax, ay, bx, by;
-      var iter = arcs.getShapeIter(path);
-
-      if (iter.hasNext()) {
-        ax = iter.x;
-        ay = iter.y;
-      }
-      while (iter.hasNext()) {
-        bx = ax;
-        by = ay;
-        ax = iter.x;
-        ay = iter.y;
-        if (segmentOutsideBBox(ax, ay, bx, by, left, bottom, right, top)) continue;
-        if (segmentInsideBBox(ax, ay, bx, by, left, bottom, right, top)) {
-          intersects = true;
-          break;
-        }
-        if (geom.segmentIntersection(left, top, right, top, ax, ay, bx, by) ||
-            geom.segmentIntersection(left, bottom, right, bottom, ax, ay, bx, by) ||
-            geom.segmentIntersection(left, bottom, left, top, ax, ay, bx, by) ||
-            geom.segmentIntersection(right, bottom, right, top, ax, ay, bx, by)) {
-          intersects = true;
-          break;
-        }
-      }
-
-      // case: bbox is entirely inside this ring
-      if (!intersects && geom.testPointInRing(left, bottom, path, arcs)) {
-        intersects = true;
-      }
-      return intersects ? path : null;
-    };
-  }
-
-  // Return a function for testing if a shape (path or point) intersects a bounding box
-  // TODO: move this function to a different file
-  function getBBoxIntersectionTest(bbox, lyr, arcs) {
-    var filter = getBoundsIntersectionFilter(bbox, lyr, arcs);
-    return function(shapeId) {
-      var shp = lyr.shapes[shapeId];
-      if (!shp) return false;
-      for (var i=0; i<shp.length; i++) {
-        if (filter(shp[i])) return true;
-      }
-      return false;
-    };
-  }
-
-  // return array of shape ids
-  function findShapesIntersectingBBox(bbox, lyr, arcs) {
-    var test = getBBoxIntersectionTest(bbox, lyr, arcs);
-    var ids = [];
-    for (var i=0; i<lyr.shapes.length; i++) {
-      if (test(i)) ids.push(i);
-    }
-    return ids;
-  }
-
-  var FilterGeom = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    findShapesIntersectingBBox: findShapesIntersectingBBox,
-    getBBoxIntersectionTest: getBBoxIntersectionTest
-  });
-
-  cmd.filterFeatures = function(lyr, arcs, opts) {
-    var records = lyr.data ? lyr.data.getRecords() : null,
-        shapes = lyr.shapes || null,
-        n = getFeatureCount(lyr),
-        filteredShapes = shapes ? [] : null,
-        filteredRecords = records ? [] : null,
-        filteredLyr = getOutputLayer(lyr, opts),
-        invert = !!opts.invert,
-        filter;
-
-    if (opts.expression) {
-      filter = compileFeatureExpression(opts.expression, lyr, arcs);
-    }
-
-    if (opts.ids) {
-      filter = combineFilters(filter, getIdFilter(opts.ids));
-    }
-
-    if (opts.remove_empty) {
-      filter = combineFilters(filter, getNullGeometryFilter(lyr, arcs));
-    }
-
-    if (opts.bbox) {
-      filter = combineFilters(filter, getBBoxIntersectionTest(opts.bbox, lyr, arcs));
-    }
-
-    if (!filter) {
-      stop$1("Missing a filter criterion");
-    }
-
-    utils.repeat(n, function(shapeId) {
-      var result = filter(shapeId);
-      requireBooleanResult(result);
-      if (invert) result = !result;
-      if (result === true) {
-        if (shapes) filteredShapes.push(shapes[shapeId] || null);
-        if (records) filteredRecords.push(records[shapeId] || null);
-      }
-    });
-
-    if (filteredLyr == lyr) {
-      noteLayerWillChange(lyr, {operation: 'filter'});
-    }
-    filteredLyr.shapes = filteredShapes;
-    filteredLyr.data = filteredRecords ? new DataTable(filteredRecords) : null;
-    if (filteredLyr == lyr) {
-      markLayerChanged(lyr, {operation: 'filter'});
-    }
-    if (opts.no_replace) {
-      // if adding a layer, don't share objects between source and filtered layer
-      filteredLyr = copyLayer(filteredLyr);
-    }
-
-    if (opts.verbose !== false && !opts.quiet) {
-      message(utils.format('Retained %,d of %,d features', getFeatureCount(filteredLyr), n));
-    }
-
-    return filteredLyr;
-  };
-
-  // TODO: update filter command to use this function
-  function filterLayerInPlace(lyr, filter, invert) {
-    var records = lyr.data ? lyr.data.getRecords() : null,
-        shapes = lyr.shapes || null,
-        n = getFeatureCount(lyr),
-        filteredShapes = shapes ? [] : null,
-        filteredRecords = records ? [] : null;
-    utils.repeat(n, function(shapeId) {
-      var result = filter(shapeId);
-      requireBooleanResult(result);
-      if (result === true) {
-        if (shapes) filteredShapes.push(shapes[shapeId] || null);
-        if (records) filteredRecords.push(records[shapeId] || null);
-      }
-    });
-    noteLayerWillChange(lyr, {operation: 'filterLayerInPlace'});
-    lyr.shapes = filteredShapes;
-    lyr.data = filteredRecords ? new DataTable(filteredRecords) : null;
-    markLayerChanged(lyr, {operation: 'filterLayerInPlace'});
-  }
-
-  function getIdFilter(ids) {
-    var set = new Set(ids);
-    return function(i) {
-      return set.has(i);
-    };
-  }
-
-  function getNullGeometryFilter(lyr, arcs) {
-    var shapes = lyr.shapes;
-    if (lyr.geometry_type == 'polygon') {
-      return getEmptyPolygonFilter(shapes, arcs);
-    }
-    return function(i) {return !!shapes[i];};
-  }
-
-  function getEmptyPolygonFilter(shapes, arcs) {
-    return function(i) {
-      var shp = shapes[i];
-      return !!shp && geom.getPlanarShapeArea(shapes[i], arcs) > 0;
-    };
-  }
-
-  function combineFilters(a, b) {
-    return a && b ? function(id) {
-        return a(id) && b(id);
-      } : (a || b);
-  }
-
   cmd.evaluateEachFeature = function(lyr, dataset, expArg, opts) {
     var n = getFeatureCount(lyr),
         arcs = dataset.arcs,
@@ -79540,7 +80353,7 @@ ${svg}
   }
 
   cmd.pointToGrid = function(targetLayers, targetDataset, opts) {
-    targetLayers.forEach(requirePointLayer$1);
+    targetLayers.forEach(requirePointLayer$2);
     if (opts.interval > 0 === false) {
       stop$1('Expected a non-negative interval parameter');
     }
@@ -82325,232 +83138,6 @@ ${svg}
     stopJob(job);
   };
 
-  // The icon names accepted by the icon= property of the -style command.
-  // Kept in a module of its own so that both the renderer (svg-symbols.mjs) and
-  // the -style command can use it without forming an import cycle.
-
-  var iconNames = ['circle', 'square', 'ring', 'star'];
-
-  function isSupportedIconName(name) {
-    return iconNames.indexOf(name) > -1;
-  }
-
-  cmd.svgStyle = function(lyr, dataset, opts) {
-    var filterFn, table, fields, hasNewFields, optFields, clearedByPosition, fieldsBefore;
-
-    function hadField(field) {
-      return field in fieldsBefore;
-    }
-
-    if (getFeatureCount(lyr) === 0) {
-      return;
-    }
-    if (!lyr.data) {
-      initDataTable(lyr);
-    }
-    if (opts.where) {
-      filterFn = compileFeatureExpression(opts.where, lyr, dataset.arcs);
-    }
-    if (opts.ids) {
-      filterFn = combineFilters(filterFn, getIdFilter(opts.ids));
-    }
-    if (opts.clear) {
-      lyr.data.getFields().filter(isSupportedSvgStyleProperty).forEach(lyr.data.deleteField, lyr.data);
-    }
-    table = getLayerDataTable(lyr);
-    optFields = getOptionFields(opts);
-    fields = getStyleFields(optFields);
-    // Which of dx/dy/text-anchor a label-pos in this command clears: not the ones
-    // the same command also sets, so that `label-pos=n dx=3` keeps the nudge it
-    // was given instead of clearing it a moment later.
-    //
-    // Clearing at all is what keeps the shorthand usable, since a value on the
-    // record wins over the position: without it, setting a position on a label
-    // that had been dragged would appear to do nothing.
-    clearedByPosition = labelPositionDerivedFields.filter(function(field) {
-      return optFields.indexOf(field) == -1;
-    });
-    hasNewFields = fields.some(function(field) {
-      return !table.fieldExists(field);
-    });
-    // The table's columns as this command found them. Taken once, because the
-    // command adds to them as it runs, and a blanked property must be judged
-    // against what was there before rather than against what it has just made.
-    fieldsBefore = utils.arrayToIndex(table.getFields());
-    if (fields.length > 0) {
-      if (hasNewFields) {
-        table.captureSchemaBefore({operation: 'style', fields: fields});
-      } else {
-        table.captureFieldsBefore(fields, {operation: 'style'});
-      }
-    }
-    Object.keys(opts).forEach(function(optName) {
-      // undo cli parser name conversion; the regex must be global, or a
-      // property with more than one hyphen (e.g. label-start-offset) is silently
-      // skipped rather than applied
-      var svgName = optName.replace(/_/g, '-');
-      if (!isSupportedSvgStyleProperty(svgName)) {
-        return;
-      }
-      var strVal = opts[optName].trim();
-      // An empty value removes the property, rather than being rejected as an
-      // unparseable one. This is how a control gives a property back: a label
-      // dragged off its position clears label-pos, and there is otherwise no
-      // per-property unset -- only -style clear, which clears all of them.
-      var unset = strVal === '' && emptyValueUnsetsProperty(svgName);
-      var accessor = unset ? null : getSymbolPropertyAccessor(strVal, svgName, lyr);
-      var badIcons = svgName == 'icon' ? [] : null;
-      // Removing a position is not setting one, so it neither validates the
-      // value nor clears the offsets the position would have stood for.
-      var posOnPaths = svgName == 'label-pos' && !unset ? [] : null;
-      table.getRecords().forEach(function(rec, i) {
-        if (filterFn && !filterFn(i)) {
-          // make sure field exists if record is excluded by filter
-          setUndefinedFields(rec, [svgName]);
-          if (svgName == 'label-pos') {
-            // ...but a field the position would only have cleared is one this
-            // command is not writing anywhere, so an excluded record has nothing
-            // to stay consistent with
-            setUndefinedFields(rec, labelPositionDerivedFields, {has: hadField});
-          }
-        } else if (unset) {
-          // Nothing to remove, and so nothing to create: removing a property no
-          // record has would otherwise add an empty column for it.
-          if (hadField(svgName) || svgName in rec) rec[svgName] = undefined;
-        } else {
-          rec[svgName] = accessor(i);
-          if (badIcons) {
-            addUnsupportedIconName(badIcons, rec.icon);
-          }
-          if (posOnPaths) {
-            if (!parseLabelPosition(rec['label-pos'])) {
-              stop$1('Unexpected value for label-pos:', rec['label-pos']);
-            }
-            if (shapeIsPathLabel(lyr.shapes && lyr.shapes[i], rec)) {
-              // Not stored, so that ignoring it means ignoring it: a stored
-              // position would show up in the style panel and would start
-              // applying if the label ever lost all but one of its knots. Its
-              // text-anchor is left alone too -- that one does place text along a
-              // path, so a position that had no effect must not clear it.
-              posOnPaths.push(i);
-              rec['label-pos'] = undefined;
-            } else {
-              setUndefinedFields(rec, clearedByPosition, {overwrite: true, has: hadField});
-            }
-          }
-        }
-      });
-      if (badIcons && badIcons.length > 0) {
-        warn(formatUnsupportedIconMessage(badIcons));
-      }
-      if (posOnPaths && posOnPaths.length > 0) {
-        warn(formatPositionOnPathMessage(posOnPaths));
-      }
-    });
-    if (fields.length > 0) {
-      if (hasNewFields) {
-        table.markSchemaChanged({operation: 'style'});
-      } else {
-        table.markFieldsChanged(fields, {operation: 'style'});
-      }
-    }
-  };
-
-  // The style properties this command was given, in SVG spelling.
-  function getOptionFields(opts) {
-    var fields = [];
-    Object.keys(opts).forEach(function(optName) {
-      var svgName = optName.replace(/_/g, '-');
-      if (isSupportedSvgStyleProperty(svgName)) addField(fields, svgName);
-    });
-    return fields;
-  }
-
-  // The fields the command will write, which is what the undo capture covers.
-  // label-pos reaches dx/dy/text-anchor as well -- it no longer stores values in
-  // them, but it does clear them.
-  function getStyleFields(optFields) {
-    var fields = [];
-    optFields.forEach(function(svgName) {
-      addField(fields, svgName);
-      if (svgName == 'label-pos') {
-        labelPositionFields.forEach(function(field) {
-          addField(fields, field);
-        });
-      }
-    });
-    return fields;
-  }
-
-  function addField(fields, field) {
-    if (fields.indexOf(field) == -1) {
-      fields.push(field);
-    }
-  }
-
-  // Icon names can not be validated when options are parsed, because an icon=
-  // value may be a field name or an expression. The assigned values are checked
-  // instead, so that computed names are covered too. Unsupported names are a
-  // warning, not an error -- features with an unsupported name render without an
-  // icon.
-  var maxReportedIconNames = 4;
-
-  function addUnsupportedIconName(names, val) {
-    var name;
-    if (!val) return; // a blank value removes the icon
-    name = String(val);
-    if (isSupportedIconName(name) || names.indexOf(name) > -1) return;
-    names.push(name);
-  }
-
-  function formatUnsupportedIconMessage(names) {
-    var extra = names.length - maxReportedIconNames;
-    var listed = extra > 0 ? names.slice(0, maxReportedIconNames) : names;
-    var str = 'Unsupported icon ' + (names.length > 1 ? 'names' : 'name') + ': ' +
-      listed.join(', ');
-    if (extra > 0) {
-      str += ' (and ' + extra + ' more)';
-    }
-    return str + '. Expected one of: ' + iconNames.join(', ');
-  }
-
-  // Adds @fields to @rec with no value, so that a record the filter excluded
-  // still has the same schema as the ones it kept. With overwrite, also blanks a
-  // value already there -- which is how setting a position takes back the offsets
-  // a label was carrying.
-  //
-  // @has: optional test for whether the layer carries a field at all. A field
-  // nobody has is not created in order to be blanked: -style label-pos=n clears
-  // dx, dy and text-anchor because a value on the record wins over the position,
-  // and there is nothing to win with when the column does not exist. Without
-  // this, clicking a position in the style panel put three empty columns in the
-  // user's table, and three empty columns in their CSV.
-  function setUndefinedFields(rec, fields, opts) {
-    var overwrite = !!(opts && opts.overwrite);
-    var has = opts && opts.has;
-    fields.forEach(function(field) {
-      if (has && !has(field) && field in rec === false) return;
-      if (overwrite || field in rec === false) {
-        rec[field] = undefined;
-      }
-    });
-  }
-
-  // label-pos places text around an anchor point, which a label strung along a
-  // path does not have: its text runs from a start offset in the direction the
-  // path goes. A warning rather than an error, because a layer can hold both
-  // kinds of label and styling all of it at once is reasonable.
-  function formatPositionOnPathMessage(ids) {
-    var extra = ids.length - maxReportedIds;
-    var listed = (extra > 0 ? ids.slice(0, maxReportedIds) : ids).join(', ');
-    return 'Ignoring label-pos on ' + ids.length + ' path ' +
-      (ids.length > 1 ? 'labels' : 'label') + ' (' + listed +
-      (extra > 0 ? ' and ' + extra + ' more' : '') + '). ' +
-      'Use label-start-offset= and text-anchor= to place text along a path.';
-  }
-
-  var maxReportedIds = 4;
-
   function getStickArrowCoords(d) {
     return getArrowCoords(d, 'stick');
   }
@@ -83082,7 +83669,7 @@ ${svg}
 
   // TODO: refactor to remove duplication in mapshaper-svg-style.js
   cmd.symbols = function(inputLyr, dataset, opts) {
-    requirePointLayer$1(inputLyr);
+    requirePointLayer$2(inputLyr);
     var lyr = opts.no_replace ? copyLayer(inputLyr) : inputLyr;
     var shapeMode = !!opts.geographic;
     var metersPerPx;
@@ -83683,6 +84270,9 @@ ${svg}
     if (name == 'rectangle') {
       return !opts.source && !opts.bbox;
     }
+    if (name == 'labels') {
+      return !('coordinates' in opts);
+    }
     return [
       'affine', 'alpha-shapes', 'blur', 'buffer', 'calc', 'check-geometry',
       'classify', 'clean', 'clip', 'cluster', 'contours', 'dashlines', 'data-fill',
@@ -83697,7 +84287,10 @@ ${svg}
     ].indexOf(name) > -1;
   }
 
-  function commandAcceptsEmptyTarget(name) {
+  function commandAcceptsEmptyTarget(name, opts) {
+    if (name == 'labels') {
+      return 'coordinates' in opts;
+    }
     return name == 'graticule' || name == 'i' || name == 'help' ||
       name == 'point-grid' || name == 'shape' || name == 'rectangle' || name == 'frame' ||
       name == 'require' || name == 'run' || name == 'define' ||
@@ -83793,7 +84386,7 @@ ${svg}
           stop$1(utils.format('Missing target: %s\nAvailable layers: %s',
               opts.target, getFormattedLayerList(job.catalog)));
         }
-        if (!commandAcceptsEmptyTarget(name)) {
+        if (!commandAcceptsEmptyTarget(name, opts)) {
           stop$1("No data is available");
         }
       }
@@ -83816,7 +84409,7 @@ ${svg}
         }
         outputLayers = cmd.addShape(targetLayers, targetDataset, opts);
 
-      } else if (name == 'add-label') {
+      } else if (name == 'add-label' || name == 'labels' && 'coordinates' in opts) {
         if (!targetDataset) {
           targetDataset = {info: {}, layers: []};
           targetLayers = targetDataset.layers;
@@ -83824,6 +84417,9 @@ ${svg}
         }
         outputLayers = cmd.addLabel(targetLayers, targetDataset, opts);
 
+      } else if (name == 'labels') {
+        outputLayers = cmd.labels(targetLayers, targetDataset, opts);
+
       } else if (name == 'add-layer') {
         // The new layer arrives in a dataset of its own, so it is added to the
         // catalog here rather than integrated into the target below.
@@ -84401,7 +84997,7 @@ ${svg}
     return name == 'rectangle' || name == 'rectangles' || name == 'filter' && opts.cleanup;
   }
 
-  var version = "0.7.69";
+  var version = "0.7.71";
 
   // 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.
@@ -85216,7 +85812,7 @@ ${svg}
   // parse. Null is what every reader already falls back from.
   function measureLabelText(rec) {
     var text = toLabelString(rec && rec['label-text']);
-    var font, fontSize, spacing, width;
+    var font, fontSize, spacing, width, failed = false;
     if (!text) return null;
     font = getFontForRecord(rec);
     if (!font) return null;
@@ -85225,10 +85821,22 @@ ${svg}
     if (!(fontSize > 0)) return null;
     // The widest line, which is what the block of a multi-line label is as wide
     // as, and what the browser's getBBox() reports for the same text.
-    width = splitLabelLines(text).reduce(function(max, line) {
-      var w = measureLine(font, line, fontSize, spacing);
+    //
+    // A line with bold words in it is measured a run at a time, each in its own
+    // face, which loses the kerning between the last letter of one run and the
+    // first of the next -- a fraction of a pixel at a weight change.
+    width = splitLabelLineRuns(text).reduce(function(max, runs) {
+      var w = runs.reduce(function(sum, run) {
+        var face = run.bold ? getFontForRecord(rec, true) : font;
+        if (!face) {
+          failed = true;
+          return sum;
+        }
+        return sum + measureLine(face, run.text, fontSize, spacing);
+      }, 0);
       return w > max ? w : max;
     }, 0);
+    if (failed) return null;
     return width > 0 ? width : null;
   }
 
@@ -85252,9 +85860,12 @@ ${svg}
   // The font a record is drawn in, opened and remembered. A record with no
   // font-family is drawn in the layer group's default, the same one the GUI
   // measures against -- see getLabelTextDefaults().
-  function getFontForRecord(rec) {
+  //
+  // @bold: the face its bold runs are drawn in, which is the keyword's 700
+  // whatever the label's own weight is, as it is in CSS.
+  function getFontForRecord(rec, bold) {
     var family = rec['font-family'] || 'sans-serif';
-    var weight = getFontWeight(rec);
+    var weight = bold ? WEIGHT_NAMES[LABEL_BOLD_WEIGHT] : getFontWeight(rec);
     var italic = isItalic(rec);
     var stretch = rec['font-stretch'] || '';
     var key = [family, weight, italic ? 'i' : 'n', stretch].join('|');
@@ -86994,6 +87605,257 @@ ${svg}
     restoreCapturedUnits: restoreCapturedUnits
   });
 
+  // Smooths a freehand ("pencil") stroke with a Gaussian kernel while it is
+  // being drawn, placing vertices one at a time, a little behind the pointer.
+  // Vertices never move once they are placed.
+  //
+  // The trace of the pointer samples is densified to even spacing and smoothed
+  // with the Gaussian kernel that -smooth uses, as a plain weighted average in
+  // arc length. (-smooth adds a quadratic correction that keeps bends from being
+  // flattened, but it lets through far more of the jitter of a slow stroke.) A
+  // smoothed point depends only on the trace within a window around it, so it
+  // is final as soon as the trace extends a window radius beyond it. At the
+  // start of the stroke the trace is extended by an odd reflection about its
+  // first point, which keeps the smoothed curve starting exactly there, and the
+  // end is treated the same way when the stroke is finished.
+  //
+  // Vertices are kept from the smoothed points where the curve has turned by a
+  // given angle since the last vertex, or where the chord from the last vertex
+  // would stray too far from a gentle curve -- the rule -smooth uses to space
+  // its output. So vertices are close together at bends and far apart on
+  // straight stretches, and they appear one at a time.
+  //
+  // Distances are in pixels. For samples in other units, the pixelSize option
+  // gives the size of a pixel in those units.
+
+  // Standard deviation of the smoothing kernel, in arc length. Below about 5px,
+  // the jitter of a slow stroke comes through; larger values round off bends a
+  // few pixels across.
+  var SIGMA = 8;
+
+  // Half-width of the smoothing window, in multiples of SIGMA. This is also how
+  // far the pointer has to be ahead of a smoothed point for it to be final.
+  var WINDOW_RADIUS = 3;
+
+  // Spacing of the densified trace, and of the smoothed points that are tested
+  // as vertices. Small enough that a bend of radius SIGMA turns by only a few
+  // degrees per step.
+  var SOURCE_STEP = 0.5;
+  var OUTPUT_STEP = 0.5;
+
+  // Greatest turn between consecutive segments of the output, and greatest
+  // distance of the output from the smoothed curve along gentle bends.
+  var BEND_ANGLE = 12;
+  var MAX_DEVIATION = 0.75;
+
+  // Spacing of the points returned by getPreview(), and the standard deviation
+  // of the kernel that smooths the preview at the pointer. The preview is
+  // smoothed more heavily further from the pointer, up to SIGMA where it meets
+  // the placed vertices, so that it runs into them without a step. A small
+  // kernel at the pointer removes pixel jitter without lagging behind.
+  var PREVIEW_SPACING = 2;
+  var PREVIEW_SIGMA = 2;
+
+  // start: [x, y] first sample
+  // opts: (optional) {sigma, previewSigma, bendAngle (degrees), maxDeviation, pixelSize}
+  function GaussianStrokeFitter(start, opts) {
+    var px = opts && opts.pixelSize > 0 ? opts.pixelSize : 1;
+    var sigma = getOpt(opts, 'sigma', SIGMA) * px;
+    var radius = sigma * WINDOW_RADIUS;
+    var previewSigma = Math.min(getOpt(opts, 'previewSigma', PREVIEW_SIGMA) * px, sigma);
+    var step = SOURCE_STEP * px;
+    var outputStep = OUTPUT_STEP * px;
+    var decimator = new BendDecimator(start, getOpt(opts, 'bendAngle', BEND_ANGLE) * Math.PI / 180,
+      getOpt(opts, 'maxDeviation', MAX_DEVIATION) * px);
+    var samples = [[start[0], start[1]]];
+    // the densified trace: arc length and coordinates
+    var tt = [0], xx = [start[0]], yy = [start[1]];
+    var traceLen = 0; // length of the densified part of the trace
+    var nextT = step; // arc length of the next densified point
+    var phi = outputStep; // arc length of the next smoothed point
+
+    // Returns the vertices placed by the new sample, which may be none.
+    this.addSample = function(p) {
+      var n = samples.length;
+      if (!isSample(p) || samePoint(p, samples[n - 1])) return [];
+      samples.push([p[0], p[1]]);
+      densifySegment(n - 1);
+      return placeSmoothedPoints(traceLen - radius, false);
+    };
+
+    // Returns the vertices that complete the stroke, ending at the last sample.
+    this.finish = function() {
+      var n = samples.length, end, placed, p;
+      if (n < 2) return [];
+      end = samples[n - 1];
+      if (tt[tt.length - 1] < traceLen) {
+        tt.push(traceLen);
+        xx.push(end[0]);
+        yy.push(end[1]);
+      }
+      placed = placeSmoothedPoints(traceLen - outputStep / 2, true);
+      p = decimator.push(end);
+      if (p) placed.push(p);
+      placed.push([end[0], end[1]]);
+      return placed;
+    };
+
+    // Returns points to show between the last placed vertex and the pointer
+    // (not including either): the latest smoothed point, followed by the rest of
+    // the trace, smoothed less and less towards the pointer (see PREVIEW_SIGMA).
+    // These points are not final.
+    this.getPreview = function() {
+      var cand = decimator.getCandidate();
+      var t0 = cand ? phi - outputStep : 0; // arc length of the candidate
+      var spacing = PREVIEW_SPACING * px;
+      var out = cand ? [cand] : [];
+      var t, s;
+      for (t = t0 + spacing; t < traceLen - spacing / 2; t += spacing) {
+        s = previewSigma + (sigma - previewSigma) * (traceLen - t) / (traceLen - t0);
+        out.push(smoothAt(t, true, s));
+      }
+      return out;
+    };
+
+    // Smooths the trace up to arc length @maxT and returns the vertices placed
+    // from the smoothed points.
+    function placeSmoothedPoints(maxT, atEnd) {
+      var placed = [], p;
+      for (; phi <= maxT; phi += outputStep) {
+        p = decimator.push(smoothAt(phi, atEnd));
+        if (p) placed.push(p);
+      }
+      return placed;
+    }
+
+    // atEnd: treat the last sample as the end of the stroke
+    // s: (optional) standard deviation of the kernel, if not sigma
+    function smoothAt(t, atEnd, s) {
+      var r = s ? s * WINDOW_RADIUS : radius,
+          n = tt.length,
+          lo = firstIndexAbove(t - r),
+          hi = firstIndexAbove(t + r),
+          end = samples[samples.length - 1],
+          wt = [], wx = [], wy = [], i;
+      // odd reflection of the start of the trace
+      for (i = Math.min(firstIndexAbove(r - t), n) - 1; i > 0; i--) {
+        wt.push(-tt[i]);
+        wx.push(2 * xx[0] - xx[i]);
+        wy.push(2 * yy[0] - yy[i]);
+      }
+      for (i = lo; i < hi; i++) {
+        wt.push(tt[i]);
+        wx.push(xx[i]);
+        wy.push(yy[i]);
+      }
+      if (atEnd) {
+        // the trace stops short of the last sample until finish() adds it
+        if (tt[n - 1] < traceLen) {
+          wt.push(traceLen);
+          wx.push(end[0]);
+          wy.push(end[1]);
+        }
+        // odd reflection of the end of the trace
+        for (i = n - 1; i >= 0 && 2 * traceLen - tt[i] < t + r; i--) {
+          if (tt[i] >= traceLen) continue;
+          wt.push(2 * traceLen - tt[i]);
+          wx.push(2 * end[0] - xx[i]);
+          wy.push(2 * end[1] - yy[i]);
+        }
+      }
+      return smoothPoint(wt, [wx, wy], 0, wt.length, t, 'gaussian', s || sigma, r, 0);
+    }
+
+    // first index of the trace with arc length > @t
+    function firstIndexAbove(t) {
+      var lo = 0, hi = tt.length, mid;
+      while (lo < hi) {
+        mid = (lo + hi) >> 1;
+        if (tt[mid] <= t) lo = mid + 1;
+        else hi = mid;
+      }
+      return lo;
+    }
+
+    // Adds points to the trace at even spacing from sample @i to the next one.
+    function densifySegment(i) {
+      var a = samples[i],
+          b = samples[i + 1],
+          len = distance(a, b),
+          f;
+      for (; nextT <= traceLen + len; nextT += step) {
+        f = (nextT - traceLen) / len;
+        tt.push(nextT);
+        xx.push(a[0] + (b[0] - a[0]) * f);
+        yy.push(a[1] + (b[1] - a[1]) * f);
+      }
+      traceLen += len;
+    }
+  }
+
+  // Picks vertices from a stream of closely spaced points along a smooth curve,
+  // keeping a point once the curve has turned by @bendAngle (radians) since the
+  // last kept point, or once the chord from the last kept point would bow more
+  // than @maxDeviation from the curve (estimated as for a circular arc). This is
+  // the rule -smooth uses (decimateByBend() in mapshaper-smooth-algos.mjs),
+  // applied one point at a time.
+  function BendDecimator(start, bendAngle, maxDeviation) {
+    var kept = start, prev = start, candidate = null, turn = 0;
+
+    // Returns the point before @p if it is kept, or null.
+    this.push = function(p) {
+      var out = null;
+      if (candidate) {
+        turn += getTurn(prev, candidate, p);
+        if (turn >= bendAngle || distance(kept, p) * turn / 8 >= maxDeviation) {
+          out = kept = candidate;
+          turn = 0;
+        }
+        prev = candidate;
+      }
+      candidate = p;
+      return out;
+    };
+
+    // The latest point, which has not been kept yet
+    this.getCandidate = function() {
+      return candidate;
+    };
+  }
+
+  function getTurn(a, b, c) {
+    var ux = b[0] - a[0], uy = b[1] - a[1],
+        vx = c[0] - b[0], vy = c[1] - b[1],
+        len = Math.sqrt((ux * ux + uy * uy) * (vx * vx + vy * vy)),
+        cos;
+    if (!(len > 0)) return 0;
+    cos = (ux * vx + uy * vy) / len;
+    return Math.acos(Math.min(1, Math.max(-1, cos)));
+  }
+
+  function getOpt(opts, name, defaultVal) {
+    return opts && opts[name] > 0 ? opts[name] : defaultVal;
+  }
+
+  function isSample(p) {
+    return !!p && isFinite(p[0]) && isFinite(p[1]);
+  }
+
+  function samePoint(a, b) {
+    return a[0] == b[0] && a[1] == b[1];
+  }
+
+  function distance(a, b) {
+    var dx = b[0] - a[0], dy = b[1] - a[1];
+    return Math.sqrt(dx * dx + dy * dy);
+  }
+
+  var PencilGaussian = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    BendDecimator: BendDecimator,
+    GaussianStrokeFitter: GaussianStrokeFitter
+  });
+
   // Attach functions exported by modules to the "internal" object,
   // so they can be run by tests and by the GUI.
   // TODO: rewrite tests to import functions directly from modules,
@@ -87003,7 +87865,7 @@ ${svg}
   internal.svg = Object.assign({}, SvgStringify, SvgPathUtils, GeojsonToSvg,
     SvgFeatureUtils,
     SvgLabels, SvgSymbols, SvgLabelPaths, SvgLabelFit, SvgLabelAlign,
-    SvgLabelMetrics, SvgLabelHalo, SvgLabelCallout);
+    SvgLabelMetrics, SvgLabelHalo, SvgLabelCallout, SvgLabelMarkup, SvgLineArrows);
 
   // Reached through the bundle rather than imported from source, unlike most of
   // what tests use, because these modules load fs and fontkit through the
@@ -87128,6 +87990,7 @@ ${svg}
     PathExport,
     Pathfinder,
     PathfinderUtils,
+    PencilGaussian,
     PathImport,
     PathRepair,
     PathUtils,