mapshaper 0.7.70 → 0.7.72

package/mapshaper.js

@@ -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]);
   }
 
@@ -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,7 +26488,10 @@
       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) {
@@ -26462,6 +26571,8 @@
   var SvgHatch = /*#__PURE__*/Object.freeze({
     __proto__: null,
     convertFillPattern: convertFillPattern,
+    decodePatternId: decodePatternId,
+    getHashId: getHashId,
     parseDashes: parseDashes,
     parseDots: parseDots,
     parseHatches: parseHatches,
@@ -26719,6 +26830,14 @@
     fill: 'color',
     'fill-pattern': 'pattern',
     'fill-effect': null, // todo: validate effect names
+    // soft glows along a polygon's edges -- see svg-glow.mjs. Drawn with a
+    // filter, not written as attributes, so not in propertiesBySymbolType.
+    'outer-glow-color': 'color',
+    'outer-glow-opacity': 'number',
+    'outer-glow-width': 'number',
+    'inner-glow-color': 'color',
+    'inner-glow-opacity': 'number',
+    'inner-glow-width': 'number',
     'font-family': null,
     'font-size': null,
     'font-style': null,
@@ -26759,6 +26878,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',
@@ -27070,6 +27194,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,7 +27244,13 @@
 
   function parseCalloutEnd(str) {
     var end = String(str).trim().toLowerCase();
-    return /^(arrow|open-arrow|none)$/.test(end) ? end : null;
+    return /^(arrow|open-arrow|ring|none)$/.test(end) ? end : null;
+  }
+
+  // A line's ends take a callout's arrowheads, and a dot
+  function parseLineEnd(str) {
+    var end = String(str).trim().toLowerCase();
+    return /^(arrow|open-arrow|dot|none)$/.test(end) ? end : null;
   }
 
   // "x,y" -> [x, y], or null. Stored as a string so that a pair is set and
@@ -27240,6 +27372,7 @@
     parseCalloutEnd: parseCalloutEnd,
     parseCalloutType: parseCalloutType,
     parseLabelPosition: parseLabelPosition,
+    parseLineEnd: parseLineEnd,
     parsePointPair: parsePointPair,
     parseStyleLiteral: parseStyleLiteral,
     parseSvgMeasure: parseSvgMeasure,
@@ -27742,6 +27875,85 @@
     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.
@@ -27754,7 +27966,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
@@ -27762,14 +27974,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;
@@ -27812,13 +28016,21 @@
 
   // An arrowhead's size when callout-end-size does not say, in px: 10 for the
   // default line, and growing with the line, so that a heavier line does not end
-  // in a head too small to read.
+  // in a head too small to read. A ring is twice that across, which is room to
+  // circle a point and its symbol.
   function getDefaultCalloutEndSize(end, lineWidth) {
-    var w = lineWidth > 0 ? lineWidth : DEFAULT_LINE_WIDTH;
-    return 7 + 3 * w;
+    var size = getDefaultArrowSize(lineWidth);
+    return end == 'ring' ? size * 2 : size;
+  }
+
+  // A ring's size is its diameter, stroke and all, as an icon ring's is; this
+  // is the radius of the circle its stroke is centred on.
+  function getRingRadius(size, lineWidth) {
+    var w = lineWidth > 0 ? lineWidth : DEFAULT_LINE_WIDTH$1;
+    return Math.max(size - w, w) / 2;
   }
 
-  // 'arrow', 'open-arrow' or 'none'
+  // 'arrow', 'open-arrow', 'ring' or 'none'
   function getCalloutEndType(rec) {
     return rec && parseCalloutEnd(rec['callout-end'] || '') || 'none';
   }
@@ -27883,7 +28095,8 @@
   // Where a line meets a callout's text and how it gets there from the anchor.
   //
   // o.type     'line', 'elbow' or 'curve'
-  // o.end      'arrow' (filled), 'open-arrow' (stroked) or 'none'
+  // o.end      'arrow' (filled), 'open-arrow' (stroked), 'ring' (a hollow circle
+  //            around the anchor, in the line's width) or 'none'
   // o.box      the text box, from getLabelTextBox()
   // o.via      [x, y] the elbow's corner or a point the curve passes through, or null
   // o.attach   [fx, fy] where the line meets the text, as fractions of the padded
@@ -27895,21 +28108,22 @@
   //            the line width. The size is the length of the head's sides, as
   //            drawn, stroke and all: the two styles are different shapes, and
   //            what makes one look the size of the other is sides the same
-  //            length, not the same length along the line.
+  //            length, not the same length along the line. A ring's size is its
+  //            diameter.
   //
-  // Returns {kind, coords, head, openHead, box, attach, via, tip} with coords
+  // Returns {kind, coords, head, openHead, ring, box, attach, via, tip} with coords
   // from the anchor end to the text end -- a polyline's vertices, or a quadratic
   // Bezier's three points -- or null when there is nothing to draw: the anchor
   // inside the padded box, or a gap that leaves no line. head is a filled
   // triangle, openHead the three points of a stroked chevron, wing to tip to
-  // wing. The rest is what the shape was worked out from: the padded box, the
+  // wing, ring {center, radius} a stroked circle. The rest is what the shape was worked out from: the padded box, the
   // point where the line meets it, the elbow's corner or the curve's midpoint
   // (null for a straight line), and where the line stops short of the anchor.
   function getCalloutShape(o) {
     var box = padBox$1(o.box, o.padding || 0);
     var a = [0, 0];
     var size = o.endSize > 0 ? o.endSize : getDefaultCalloutEndSize(o.end, o.width);
-    var t, v, path, tip, dir, out, lineWidth, headLen, curved;
+    var t, v, path, tip, dir, out, lineWidth, headLen, curved, ringRadius;
     if (boxContains(box, a)) return null;
     t = o.attach ? getBoxPoint(box, o.attach) :
       getAutoAttachment(o.type, box, o.via || null);
@@ -27923,7 +28137,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);
@@ -27931,10 +28145,14 @@
     } else {
       path = {kind: 'polyline', coords: [a, t]};
     }
-    path = trimPath(path, o.gap || 0);
+    // A ring is centred on the anchor, and the line starts at its stroke, or
+    // at the gap if that is further out -- round a symbol bigger than the ring.
+    ringRadius = o.end == 'ring' ? getRingRadius(size, o.width) : 0;
+    path = trimPath(path, Math.max(o.gap || 0, ringRadius));
     if (!path) return null;
     tip = path.coords[0];
     out = {kind: path.kind, coords: path.coords, head: null, openHead: null,
+      ring: ringRadius > 0 ? {center: a, radius: ringRadius} : null,
       box: box, attach: t, via: v || null, tip: tip};
     if (o.end == 'arrow') {
       headLen = getArrowHeadLength(size, ARROW_ANGLE);
@@ -27951,7 +28169,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;
@@ -28001,6 +28219,19 @@
         }
       });
     }
+    if (shape.ring) {
+      children.push({
+        tag: 'circle',
+        properties: {
+          cx: shape.ring.center[0],
+          cy: shape.ring.center[1],
+          r: Math.round(shape.ring.radius * 100) / 100,
+          fill: 'none',
+          stroke: color,
+          'stroke-width': getLineWidth(rec)
+        }
+      });
+    }
     if (opacity < 1) props.opacity = opacity;
     return {tag: 'g', properties: props, children: children};
   }
@@ -28128,44 +28359,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;
@@ -28174,7 +28382,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)};
@@ -28200,7 +28408,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);
   }
 
@@ -28232,8 +28440,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]}};
   }
 
@@ -28251,20 +28459,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) {
@@ -28281,19 +28475,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];
   }
@@ -28303,8 +28484,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) {
@@ -28357,6 +28538,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,
@@ -28429,6 +28613,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();
   }
 
@@ -28438,8 +28623,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;
     }
@@ -28546,7 +28734,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;
   }
@@ -28558,6 +28746,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';
   }
@@ -28637,6 +28862,7 @@
 
   var SvgSymbols = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    RING_STROKE_WIDTH: RING_STROKE_WIDTH,
     featureHasIcon: featureHasIcon,
     getAnchorSymbolRadius: getAnchorSymbolRadius,
     getIconRadius: getIconRadius,
@@ -29949,11 +30175,302 @@
     getSphereEffectParams: getSphereEffectParams
   });
 
+  // Soft glows along the edges of polygons: an outer glow outside the shape and
+  // an inner glow inside it, each with a color, an opacity and a width.
+  //
+  //   outer-glow-color    a glow is drawn when its color is set, and not
+  //   inner-glow-color    otherwise (or if the color is "none")
+  //   outer-glow-width    how far the glow reaches from the edge, in px;
+  //   inner-glow-width    default 10, and 0 draws no glow
+  //   outer-glow-opacity  0-1, default 1
+  //   inner-glow-opacity
+  //
+  // A glow is a Gaussian blur of the shape's coverage, with a standard deviation
+  // of half the width: it has faded to about 2% of its opacity at that distance.
+  // The canvas renders the same blur as a shadow, whose shadowBlur is defined as
+  // twice the standard deviation -- so shadowBlur is the width itself.
+  //
+  // A glow is computed from everything the shape paints, its fill and its
+  // stroke, faded by its opacity -- which is what an SVG filter on a group sees.
+  //
+  // Inner glows belong to each shape. An outer glow belongs to the layer as a
+  // whole when every shape in the layer has the same one: it then follows the
+  // outline of all of them together, like a drop shadow, instead of spilling
+  // over each neighbor's edge. See getLayerOuterGlow().
+  //
+  // Illustrator drops a filter that is applied to a <path> with more than one
+  // ring (it imports one as a compound path), and keeps one that is applied to a
+  // group. A glowing shape is therefore always wrapped in a <g> that carries the
+  // filter.
+
+  var glowFields = [
+    'outer-glow-color', 'outer-glow-opacity', 'outer-glow-width',
+    'inner-glow-color', 'inner-glow-opacity', 'inner-glow-width'
+  ];
+
+  var DEFAULT_GLOW_WIDTH = 10;
+
+  // How far a glow is drawn past the edge, as a multiple of its width: three
+  // standard deviations, where the blur is gone for all practical purposes.
+  var GLOW_REACH = 1.5;
+
+  // Filter regions are given as a percentage of the bounding box of what they
+  // filter, and a small shape needs a larger percentage than a big one to leave
+  // room for the same glow. Rounding up to one of these keeps the number of
+  // distinct filters small; Illustrator lists every one of them in its menu.
+  var regionMargins = [10, 25, 50, 100, 200, 500, 1000, 2500, 5000, 10000];
+
+  // {color, opacity, width} for one of a record's glows, or null if it has none.
+  // @type: 'outer' or 'inner'
+  function getPolygonGlow(rec, type) {
+    var prefix = type + '-glow-';
+    var width, color, opacity;
+    if (!rec) return null;
+    color = rec[prefix + 'color'];
+    if (isBlank(color) || String(color).trim().toLowerCase() == 'none') return null;
+    width = rec[prefix + 'width'];
+    if (isBlank(width)) width = DEFAULT_GLOW_WIDTH;
+    if (!isSvgNumber(width) || !(Number(width) > 0)) return null;
+    opacity = rec[prefix + 'opacity'];
+    opacity = isSvgNumber(opacity) ? Math.min(Math.max(Number(opacity), 0), 1) : 1;
+    if (opacity === 0) return null;
+    return {color: String(color).trim(), opacity: opacity, width: Number(width)};
+  }
+
+  function isBlank(val) {
+    return val === undefined || val === null || String(val).trim() === '';
+  }
+
+  function polygonHasGlow(rec) {
+    return !!(getPolygonGlow(rec, 'outer') || getPolygonGlow(rec, 'inner'));
+  }
+
+  function getGlowKey(glow) {
+    return glow ? glow.color + ' ' + glow.opacity + ' ' + glow.width : '';
+  }
+
+  // The outer glow of a polygon layer as a whole, or null. A layer has one when
+  // every feature with a shape has the same outer glow; features without a shape
+  // are left out, since they draw nothing. Decided from the data rather than
+  // from what is drawn, so that it does not change with the view.
+  function getLayerOuterGlow(lyr) {
+    var records, shapes, glow, key, g, k;
+    if (!lyr || lyr.geometry_type != 'polygon' || !lyr.data || !lyr.shapes) return null;
+    records = lyr.data.getRecords();
+    shapes = lyr.shapes;
+    glow = null;
+    for (var i=0, n=shapes.length; i<n; i++) {
+      if (!shapes[i] || shapes[i].length === 0) continue;
+      g = getPolygonGlow(records[i], 'outer');
+      if (!g) return null;
+      k = getGlowKey(g);
+      if (!glow) {
+        glow = g;
+        key = k;
+      } else if (k != key) {
+        return null;
+      }
+    }
+    return glow;
+  }
+
+  // The widest glow of any feature in a layer, in px, or 0.
+  function getMaxGlowWidth(records) {
+    var max = 0, g;
+    for (var i=0, n=records ? records.length : 0; i<n; i++) {
+      g = getPolygonGlow(records[i], 'outer');
+      if (g && g.width > max) max = g.width;
+      g = getPolygonGlow(records[i], 'inner');
+      if (g && g.width > max) max = g.width;
+    }
+    return max;
+  }
+
+  // What a <g> needs for a glow filter: the glows and the size of what it
+  // wraps, so that the filter region can be made large enough.
+  // @bbox: [xmin, ymin, xmax, ymax] of the wrapped content, in px
+  // @strokeWidth: the widest stroke in it, which reaches past the bbox
+  function getGlowFilterSpec(outer, inner, bbox, strokeWidth) {
+    var width = Math.max(outer ? outer.width : 0, inner ? inner.width : 0);
+    var reach = width * GLOW_REACH + (strokeWidth > 0 ? strokeWidth / 2 : 0) + 1;
+    return {
+      outer: outer || null,
+      inner: inner || null,
+      marginX: getRegionMargin(reach, bbox[2] - bbox[0]),
+      marginY: getRegionMargin(reach, bbox[3] - bbox[1])
+    };
+  }
+
+  function getRegionMargin(reach, size) {
+    var pct = size > 0 ? reach / size * 100 : Infinity;
+    for (var i=0; i<regionMargins.length; i++) {
+      if (regionMargins[i] >= pct) return regionMargins[i];
+    }
+    return regionMargins[regionMargins.length - 1];
+  }
+
+  function getGlowFilterKey(spec) {
+    return getGlowKey(spec.outer) + '|' + getGlowKey(spec.inner) + '|' +
+      spec.marginX + ' ' + spec.marginY;
+  }
+
+  // The <filter> element for @spec. The outer glow is the blurred coverage of
+  // the source outside the source; the inner glow is the blurred coverage of
+  // everything outside the source, inside the source. The inversion is made
+  // by cutting the source out of a flood rather than with feComponentTransfer,
+  // which Safari fades toward the corners of the source's bounding box.
+  function renderGlowFilter(id, spec) {
+    var mx = spec.marginX, my = spec.marginY;
+    var parts = [];
+    var merge = [];
+    if (spec.outer) {
+      parts.push(
+        `<feGaussianBlur in="SourceAlpha" stdDeviation="${getGlowDeviation(spec.outer)}" result="outer-blur"/>`,
+        `<feFlood flood-color="${escapeAttr(spec.outer.color)}" flood-opacity="${spec.outer.opacity}"/>`,
+        '<feComposite in2="outer-blur" operator="in"/>',
+        '<feComposite in2="SourceAlpha" operator="out" result="outer"/>');
+      merge.push('outer');
+    }
+    merge.push('SourceGraphic');
+    if (spec.inner) {
+      parts.push(
+        '<feFlood flood-color="#000000" flood-opacity="1"/>',
+        '<feComposite in2="SourceAlpha" operator="out"/>',
+        `<feGaussianBlur stdDeviation="${getGlowDeviation(spec.inner)}" result="inner-blur"/>`,
+        `<feFlood flood-color="${escapeAttr(spec.inner.color)}" flood-opacity="${spec.inner.opacity}"/>`,
+        '<feComposite in2="inner-blur" operator="in"/>',
+        '<feComposite in2="SourceAlpha" operator="in" result="inner"/>');
+      merge.push('inner');
+    }
+    return `<filter id="${id}" x="${-mx}%" y="${-my}%" width="${100 + 2 * mx}%" height="${100 + 2 * my}%" color-interpolation-filters="sRGB">\n` +
+      parts.join('\n') + '\n<feMerge>' +
+      merge.map(function(name) { return `<feMergeNode in="${name}"/>`; }).join('') +
+      '</feMerge>\n</filter>\n';
+  }
+
+  function getGlowDeviation(glow) {
+    return Math.round(glow.width / 2 * 1000) / 1000;
+  }
+
+  function escapeAttr(str) {
+    return String(str).replace(/[&<>"]/g, '');
+  }
+
+  // Wraps each glowing shape in a <g> that will carry its filter, and marks the
+  // layer's own <g> if the layer has an outer glow of its own. The filters
+  // themselves are added to <defs> later, by convertGlowFilter().
+  // @children: the SVG objects for @features, one each, in order
+  function applyPolygonGlows(layerObj, children, features, lyr) {
+    var layerGlow = getLayerOuterGlow(lyr);
+    var layerBBox = null;
+    var maxStroke = 0;
+    children.forEach(function(child, i) {
+      var feature = features[i];
+      var geom = feature && (feature.type == 'Feature' ? feature.geometry : feature);
+      var rec = feature && feature.properties || {};
+      var bbox, outer, inner, strokeWidth, wrapper;
+      if (!child || !child.properties || !geom || !geom.coordinates) return;
+      bbox = getCoordinatesBBox(geom.coordinates);
+      if (!bbox) return;
+      strokeWidth = getStrokeWidth(rec);
+      if (strokeWidth > maxStroke) maxStroke = strokeWidth;
+      layerBBox = layerBBox ? mergeBBoxes(layerBBox, bbox) : bbox;
+      outer = layerGlow ? null : getPolygonGlow(rec, 'outer');
+      inner = getPolygonGlow(rec, 'inner');
+      if (!outer && !inner) return;
+      wrapper = {tag: 'g', properties: {}, children: [child],
+        glowFilter: getGlowFilterSpec(outer, inner, bbox, strokeWidth)};
+      // The group is the feature now, so its id goes with it (and the data
+      // attributes of svg-data=, which are added to the layer's children).
+      if ('id' in child.properties) {
+        wrapper.properties.id = child.properties.id;
+        delete child.properties.id;
+      }
+      children[i] = wrapper;
+    });
+    if (layerGlow && layerBBox) {
+      layerObj.glowFilter = getGlowFilterSpec(layerGlow, null, layerBBox, maxStroke);
+    }
+  }
+
+  // Replaces the glow filter an object was marked with by a reference to a
+  // <filter> in @defs, which shapes with the same glows share.
+  function convertGlowFilter(obj, defs) {
+    var spec = obj.glowFilter;
+    var key = getGlowFilterKey(spec);
+    var item = defs.find(function(o) { return o.glowFilterKey === key; });
+    var count;
+    if (!item) {
+      count = defs.filter(function(o) { return !!o.glowFilterKey; }).length;
+      item = {glowFilterKey: key, id: 'glow-' + (count + 1)};
+      item.svg = renderGlowFilter(item.id, spec);
+      defs.push(item);
+    }
+    delete obj.glowFilter;
+    if (!obj.properties) obj.properties = {};
+    obj.properties.filter = 'url(#' + item.id + ')';
+  }
+
+  function getStrokeWidth(rec) {
+    var w = rec['stroke-width'];
+    if (!rec.stroke || rec.stroke == 'none') return 0;
+    return isSvgNumber(w) ? Number(w) : 1;
+  }
+
+  function getCoordinatesBBox(coords) {
+    var bbox = [Infinity, Infinity, -Infinity, -Infinity];
+    extendBBox(bbox, coords);
+    return bbox[0] <= bbox[2] ? bbox : null;
+  }
+
+  function extendBBox(bbox, coords) {
+    var x, y;
+    if (!coords || coords.length === 0) return;
+    if (typeof coords[0] == 'number') {
+      x = coords[0];
+      y = coords[1];
+      if (x < bbox[0]) bbox[0] = x;
+      if (y < bbox[1]) bbox[1] = y;
+      if (x > bbox[2]) bbox[2] = x;
+      if (y > bbox[3]) bbox[3] = y;
+      return;
+    }
+    for (var i=0; i<coords.length; i++) {
+      extendBBox(bbox, coords[i]);
+    }
+  }
+
+  function mergeBBoxes(a, b) {
+    return [Math.min(a[0], b[0]), Math.min(a[1], b[1]),
+      Math.max(a[2], b[2]), Math.max(a[3], b[3])];
+  }
+
+  var SvgGlow = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    DEFAULT_GLOW_WIDTH: DEFAULT_GLOW_WIDTH,
+    GLOW_REACH: GLOW_REACH,
+    applyPolygonGlows: applyPolygonGlows,
+    convertGlowFilter: convertGlowFilter,
+    getGlowDeviation: getGlowDeviation,
+    getGlowFilterKey: getGlowFilterKey,
+    getGlowFilterSpec: getGlowFilterSpec,
+    getGlowKey: getGlowKey,
+    getLayerOuterGlow: getLayerOuterGlow,
+    getMaxGlowWidth: getMaxGlowWidth,
+    getPolygonGlow: getPolygonGlow,
+    glowFields: glowFields,
+    polygonHasGlow: polygonHasGlow,
+    renderGlowFilter: renderGlowFilter
+  });
+
   // convert object properties to definitions for images and hatch fills
   function convertPropertiesToDefinitions(obj, defs) {
     procNode(obj);
 
     function procNode(obj) {
+      if (obj.glowFilter) {
+        convertGlowFilter(obj, defs);
+      }
       if (obj.tag == 'textPath' && obj.properties && obj.properties[LABEL_PATH_PROPERTY]) {
         convertLabelPath(obj.properties, defs);
       }
@@ -30079,6 +30596,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,
@@ -30101,6 +30810,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);
       }
@@ -30428,7 +31140,7 @@ ${svg}
       lyr = copyLayer(lyr);
       adjustRectangleStyle(lyr);
     }
-    layerObj.children = exportSymbolsForSVG(lyr, dataset, opts);
+    layerObj.children = exportSymbolsForSVG(lyr, dataset, opts, layerObj);
     return layerObj;
   }
 
@@ -30606,7 +31318,7 @@ ${svg}
     return dataUrl.split(',')[1];
   }
 
-  function exportSymbolsForSVG(lyr, dataset, opts) {
+  function exportSymbolsForSVG(lyr, dataset, opts, layerObj) {
     // TODO: convert geojson features one at a time
     var d = utils.defaults({layers: [lyr]}, dataset);
     var geojson = exportDatasetAsGeoJSON(d, opts);
@@ -30618,6 +31330,9 @@ ${svg}
     var children = importGeoJSONFeatures(features,
       utils.defaults({path_label_report: pathLabelReport}, opts));
     reportPathLabels(pathLabelReport, lyr);
+    if (lyr.geometry_type == 'polygon') {
+      applyPolygonGlows(layerObj, children, features, lyr);
+    }
     // Drop empty placeholder <g/> elements (features whose geometry was null in the
     // source data, collapsed during simplification, or otherwise produced no
     // visible output). Keep the layer's records in lockstep so that data-*
@@ -41904,8 +42619,8 @@ ${svg}
           'halo-opacity': {describe: 'halo opacity, 0-1'},
           '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 (default is 10)'},
+          'callout-end': {describe: 'marker at the anchor end: arrow, open-arrow, ring or none'},
+          'callout-end-size': {describe: 'length of an arrowhead\'s sides, or a ring\'s diameter, in px'},
           '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'},
@@ -43943,6 +44658,24 @@ ${svg}
       .option('fill-hatch', {
         alias_to: 'fill-pattern'
       })
+      .option('outer-glow-color', {
+        describe: 'color of a glow outside each polygon (adds the glow)'
+      })
+      .option('outer-glow-width', {
+        describe: 'how far the outer glow reaches, in px (default is 10)'
+      })
+      .option('outer-glow-opacity', {
+        describe: 'opacity of the outer glow, 0-1'
+      })
+      .option('inner-glow-color', {
+        describe: 'color of a glow inside each polygon (adds the glow)'
+      })
+      .option('inner-glow-width', {
+        describe: 'how far the inner glow reaches, in px (default is 10)'
+      })
+      .option('inner-glow-opacity', {
+        describe: 'opacity of the inner glow, 0-1'
+      })
       .option('stroke', {
         describe: 'stroke color'
       })
@@ -43955,6 +44688,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'
       })
@@ -49567,9 +50309,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 || [];
@@ -51877,8 +52638,13 @@ ${svg}
 
   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;
+    return iconNames.indexOf(name) > -1 || unlistedIconNames.indexOf(name) > -1;
   }
 
   cmd.svgStyle = function(lyr, dataset, opts) {
@@ -53038,13 +53804,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
   }
 
@@ -54004,10 +54774,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];
   }
 
@@ -56194,12 +56964,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
@@ -56360,7 +57130,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;
@@ -56409,7 +57179,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];
       }
     }
@@ -56433,7 +57203,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];
@@ -61099,10 +61869,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;
   }
 
@@ -61205,7 +61975,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];
   }
 
@@ -65565,7 +66335,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
@@ -84575,7 +85345,7 @@ ${svg}
     return name == 'rectangle' || name == 'rectangles' || name == 'filter' && opts.cleanup;
   }
 
-  var version = "0.7.70";
+  var version = "0.7.72";
 
   // 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.
@@ -87183,6 +87953,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,
@@ -87192,7 +88213,8 @@ ${svg}
   internal.svg = Object.assign({}, SvgStringify, SvgPathUtils, GeojsonToSvg,
     SvgFeatureUtils,
     SvgLabels, SvgSymbols, SvgLabelPaths, SvgLabelFit, SvgLabelAlign,
-    SvgLabelMetrics, SvgLabelHalo, SvgLabelCallout, SvgLabelMarkup);
+    SvgLabelMetrics, SvgLabelHalo, SvgLabelCallout, SvgLabelMarkup, SvgLineArrows,
+    SvgGlow);
 
   // Reached through the bundle rather than imported from source, unlike most of
   // what tests use, because these modules load fs and fontkit through the
@@ -87317,6 +88339,7 @@ ${svg}
     PathExport,
     Pathfinder,
     PathfinderUtils,
+    PencilGaussian,
     PathImport,
     PathRepair,
     PathUtils,