mapshaper 0.7.55 → 0.7.58

package/mapshaper.js

@@ -351,7 +351,7 @@
   // Calc sum, skip falsy and NaN values
   // Assumes: no other non-numeric objects in array
   //
-  function sum$1(arr, info) {
+  function sum$2(arr, info) {
     if (!isArrayLike(arr)) error$1 ("sum() expects an array, received:", arr);
     var tot = 0,
         nan = 0,
@@ -1117,7 +1117,7 @@
     quicksort: quicksort$1, quicksortPartition,
     range, regexEscape, reorderArray: reorderArray$1, repeat: repeat$1, repeatString,
     replaceArray, rpad, rtrim,
-    shuffle, some, sortArrayIndex, sortOn, splitLines, sum: sum$1,
+    shuffle, some, sortArrayIndex, sortOn, splitLines, sum: sum$2,
     toArray: toArray$1, toBuffer, trim, trimQuotes,
     uniq, uniqifyNames,
     wildcardToRegExp
@@ -5793,10 +5793,13 @@
 
   function layerOnlyHasRectangles(lyr, arcs) {
     if (!layerHasPaths(lyr)) return false;
-    if (countMultiPartFeatures(lyr) > 0) return false;
     return lyr.shapes.every(function(shp) {
       if (!shp) return true;
-      return pathIsRectangle(shp[0], arcs);
+      // Every part is tested: a shape whose first ring is rectangular may well
+      // have others that are not.
+      return shp.every(function(path) {
+        return pathIsRectangle(path, arcs);
+      });
     });
   }
 
@@ -5886,7 +5889,7 @@
 
   function requireSinglePointLayer(lyr, msg) {
     requirePointLayer(lyr);
-    if (countMultiPartFeatures(lyr) > 0) {
+    if (countMultiPartFeatures(lyr.shapes) > 0) {
       stop$1(msg || 'This command requires single points; layer contains multi-point features.');
     }
   }
@@ -6030,8 +6033,16 @@
     return copy;
   }
 
+  // shapes: one layer's "shapes" array
+  // Guards against being passed a layer instead: several callers made that
+  // mistake, and reading .length off a layer object silently returned 0, which
+  // disabled the multi-part checks that depend on this function.
   function countMultiPartFeatures(shapes) {
     var count = 0;
+    if (!shapes) return 0;
+    if (!Array.isArray(shapes)) {
+      error('countMultiPartFeatures() expects an array of shapes');
+    }
     for (var i=0, n=shapes.length; i<n; i++) {
       if (shapes[i] && shapes[i].length > 1) count++;
     }
@@ -9869,7 +9880,7 @@
       id: piece.id,
       source_region: piece.source_region,
       copy: piece.copy,
-      projected_boundary: closeRing$1(piece.boundary)
+      projected_boundary: closeRing$2(piece.boundary)
     };
   }
 
@@ -9877,7 +9888,7 @@
     return {
       id: piece.id,
       source_region: piece.source_region,
-      projected_boundary: closeRing$1(piece.boundary)
+      projected_boundary: closeRing$2(piece.boundary)
     };
   }
 
@@ -9959,7 +9970,7 @@
     return paths;
   }
 
-  function closeRing$1(ring) {
+  function closeRing$2(ring) {
     var copy = ring.map(function(p) { return p.concat(); });
     if (copy.length && !pointsEqual$2(copy[0], copy[copy.length - 1])) {
       copy.push(copy[0].concat());
@@ -14944,6 +14955,27 @@
     return fflatePostprocess(obj);
   }
 
+  // Return the entry names in a zip archive, without decompressing them.
+  // Used to tell a KMZ from an ordinary zip when there is no filename to go by.
+  // input: A file path or a buffer
+  function listZipEntryNames(input) {
+    if (input instanceof ArrayBuffer) {
+      input = new Uint8Array(input);
+    }
+    if (!runningInBrowser()) {
+      var AdmZip = require('adm-zip');
+      return new AdmZip(input).getEntries().map(function(entry) {
+        return entry.entryName;
+      });
+    }
+    var names = [];
+    unzipSync$1(input, {filter: function(file) {
+      names.push(file.name);
+      return false; // collect names only
+    }});
+    return names;
+  }
+
   function unzipAsync(buf, cb) {
     if (!runningInBrowser()) {
       error('Async unzipping only supported in the browser');
@@ -15038,6 +15070,7 @@
   var Zip = /*#__PURE__*/Object.freeze({
     __proto__: null,
     isImportableZipPath: isImportableZipPath,
+    listZipEntryNames: listZipEntryNames,
     unzipAsync: unzipAsync,
     unzipSync: unzipSync,
     zipAsync: zipAsync,
@@ -18618,14 +18651,15 @@
   function parseHexColor(str) {
     var hex = hexRxp.exec(str)[1];
     if (hex.length == 3 || hex.length == 4) {
-      hex = hex.split('').map(function(c) { return c + c; });
+      // expand shorthand, e.g. #f90 -> #ffcc00
+      hex = hex.split('').map(function(c) { return c + c; }).join('');
     }
     if (hex.length != 6 && hex.length != 8) return null;
     return {
       r: parseInt(hex.substr(0, 2), 16),
       g: parseInt(hex.substr(2, 2), 16),
       b: parseInt(hex.substr(4, 2), 16),
-      a: hex.length == 8 ? parseInt(hex.substr(7, 2), 16) / 255 : 1
+      a: hex.length == 8 ? parseInt(hex.substr(6, 2), 16) / 255 : 1
     };
   }
 
@@ -25733,6 +25767,173 @@
     return text || text === 0; // accept numerical 0 as label text
   }
 
+  var assignmentRxp = /^([a-z0-9_+-]+)=(?!=)(.*)$/i; // exclude ==
+
+  function splitShellTokens(str) {
+    var BAREWORD = `([^'"\\s])+`;
+    var DOUBLE_QUOTE = `"((\\\\"|[^"])*?)"`;
+    var SINGLE_QUOTE = `'((\\\\'|[^'])*?)'`;
+    var rxp = new RegExp('(' + BAREWORD + '|' + SINGLE_QUOTE + '|' + DOUBLE_QUOTE + ')*', 'g');
+    var matches = str.match(rxp) || [];
+    var chunks = matches.filter(function(chunk) {
+      // single backslashes may be present in multiline commands pasted from a makefile, e.g.
+      return !!chunk && chunk != '\\';
+    }).map(utils.trimQuotes);
+    return chunks;
+  }
+
+  function parsePercent(o) {
+    var str = String(o);
+    var isPct = str.indexOf('%') > 0;
+    var pct;
+    if (isPct) {
+      pct = Number(str.replace('%', '')) / 100;
+    } else {
+      pct = Number(str);
+    }
+    if (!(pct >= 0 && pct <= 1)) {
+      stop$1(utils.format("Invalid percentage: %s", str));
+    }
+    return pct;
+  }
+
+  function parseNumberList(token) {
+    return token.split(',').map(parseFloat);
+  }
+
+  // Split comma-delimited list, trim quotes from entire list and
+  // individual members
+  function parseStringList(token) {
+    var delim = ',';
+    var list = splitOptionList(token, delim);
+    if (list.length == 1) {
+      list = splitOptionList(list[0], delim);
+    }
+    return list;
+  }
+
+  // Accept spaces and/or commas as delimiters
+  function parseColorList(token) {
+    var delim = ', ';
+    // accept rgb(0 0 0) rgb(0,0,0) rgb(0, 0, 0)
+    var token2 = token.replace(/[ ,] *(?=[^(]*\))/g, '~~~'); // kludge: protect rgba() functions from being split apart
+    var list = splitOptionList(token2, delim);
+    if (list.length == 1) {
+      list = splitOptionList(list[0], delim);
+    }
+    list = list.map(function(str) {
+      return str.replace(/~~~/g, ',');
+    });
+    return list;
+  }
+
+  // Splits a comma-delimited list into items, for the list-valued options of the
+  // -symbols command (radii=, values=, fills=). Unlike parseStringList(), empty
+  // items are kept, so that a blank item in one list still lines up with its
+  // counterpart in another. Commas nested inside parentheses, brackets, braces
+  // or quotes are not delimiters, so items like rgba(0,0,0,0.5), Math.max(A,B)
+  // and [R, R * 0.5] survive as single items.
+  function splitListItems(str) {
+    var items = [];
+    var start = 0;
+    var depth = 0;
+    var quote = '';
+    var c;
+    for (var i=0, n=str.length; i<n; i++) {
+      c = str[i];
+      if (quote) {
+        if (c === quote) quote = '';
+      } else if (c === '"' || c === "'") {
+        quote = c;
+      } else if (c === '(' || c === '[' || c === '{') {
+        depth++;
+      } else if (c === ')' || c === ']' || c === '}') {
+        depth--;
+      } else if (c === ',' && depth <= 0) {
+        items.push(str.slice(start, i));
+        start = i + 1;
+      }
+    }
+    items.push(str.slice(start));
+    return items.map(function(item) {
+      return utils.trimQuotes(item.trim());
+    });
+  }
+
+  function cleanArgv(argv) {
+    // Note: original trim caused some quoted spaces to be removed
+    // (e.g. bash shell seems to convert [delimiter=" "] to [delimiter= ],
+    //  which then got trimmed to [delimiter=] below)
+    //// argv = argv.map(function(s) {return s.trim();}); // trim whitespace
+
+    // Updated: don't trim space from tokens like [delimeter= ]
+    argv = argv.map(function(s) {
+      if (!/= $/.test(s)) {
+        s = utils.rtrim(s);
+      }
+      s = utils.ltrim(s);
+      return s;
+    });
+    argv = argv.filter(function(s) {return s !== '';}); // remove empty tokens
+    // Note: removing trimQuotes() call... now, strings like 'name="Meg"' will no longer
+    // be parsed the same way as name=Meg and name="Meg"
+    //// argv = argv.map(utils.trimQuotes); // remove one level of single or dbl quotes
+    return argv;
+  }
+
+  function splitOptionList(str, delimChars) {
+    var BAREWORD = '([^' + delimChars + '\'"][^' + delimChars + ']*)'; // TODO: make safer
+    var DOUBLE_QUOTE = '"((\\\\"|[^"])*?)"';
+    var SINGLE_QUOTE = '\'((\\\\\'|[^\'])*?)\'';
+    var rxp = new RegExp('^(' + BAREWORD + '|' + SINGLE_QUOTE + '|' + DOUBLE_QUOTE + ')([' + delimChars + ']+|$)');
+    var chunks = [];
+    var match;
+    while ((match = rxp.exec(str)) !== null) {
+      chunks.push(match[1]);
+      str = str.substr(match[0].length);
+    }
+    return chunks.filter(function(chunk) {
+      return !!chunk && chunk != '\\';
+    }).map(utils.trimQuotes);
+  }
+
+  // Prepare a value to be used as an option value.
+  // Places quotes around strings containing spaces.
+  // e.g. converts   Layer 1 -> "Layer 1"
+  //   for use in contexts like: name="Layer 1"
+  function formatOptionValue(val) {
+    val = String(val);
+    if (val.indexOf(' ') > -1) {
+      val = JSON.stringify(val); // quote ids with spaces
+    }
+    return val;
+  }
+
+  function isAssignment(token) {
+    return assignmentRxp.test(token);
+  }
+
+  function splitAssignment(token) {
+    var match = assignmentRxp.exec(token),
+        name = match[1],
+        val = utils.trimQuotes(match[2]);
+    return [name, val];
+  }
+
+  var OptionParsingUtils = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    cleanArgv: cleanArgv,
+    formatOptionValue: formatOptionValue,
+    isAssignment: isAssignment,
+    parseColorList: parseColorList,
+    parseNumberList: parseNumberList,
+    parsePercent: parsePercent,
+    parseStringList: parseStringList,
+    splitAssignment: splitAssignment,
+    splitListItems: splitListItems,
+    splitShellTokens: splitShellTokens
+  });
+
   /* example patterns
   hatches 1px black 1px red 1px white
   1px black 1px red 1px white // same as above (hatches is default)
@@ -26024,7 +26225,10 @@
     length: 'number', // e.g. arrow length
     rotation: 'number',
     radius: 'number',
-    radii: null, // string, parsed by function
+    radii: null, // (ring) list, see symbolListProperties
+    hole: 'number', // (pie) radius of the hole in a donut
+    values: null, // (pie) list, see symbolListProperties
+    fills: null, // (pie) list, see symbolListProperties
     flipped: 'boolean',
     rotated: 'boolean',
     direction: 'number',
@@ -26043,6 +26247,18 @@
     effect: null // e.g. "fade"
   }, stylePropertyTypes);
 
+  // Options that take a list of values -- one for each part of a multi-part
+  // symbol -- instead of a single value. Each item in the list is resolved
+  // separately, so an item can be a literal value, a field name or an
+  // expression. The type hint for fills= is null on purpose: an item that isn't
+  // a recognizable color is passed along as a literal string, so that a symbol
+  // can leave that part unfilled instead of the command failing.
+  var symbolListProperties = {
+    radii: 'number',
+    values: 'number',
+    fills: null
+  };
+
   var commonProperties = 'css,class,opacity,stroke,stroke-width,stroke-dasharray,stroke-opacity,fill-opacity,vector-effect'.split(',');
 
   var propertiesBySymbolType = {
@@ -26118,7 +26334,9 @@
         return;
       }
       var val = opts[optName];
-      functions[svgName] = getSymbolPropertyAccessor(val, svgName, lyr);
+      functions[svgName] = svgName in symbolListProperties ?
+        getSymbolListAccessor(val, svgName, lyr) :
+        getSymbolPropertyAccessor(val, svgName, lyr);
       properties.push(svgName);
     });
 
@@ -26145,8 +26363,35 @@
   }
 
   function getSymbolPropertyAccessor(val, svgName, lyr) {
+    return getPropertyAccessor(val, symbolPropertyTypes[svgName], lyr, svgName);
+  }
+
+  // Returns a function that maps a feature id to an array of values, for options
+  // like values= and fills= that describe the parts of a multi-part symbol.
+  // The option may be given as an array or as a comma-separated list.
+  function getSymbolListAccessor(val, svgName, lyr) {
+    var typeHint = symbolListProperties[svgName];
+    var items = Array.isArray(val) ? val : splitListItems(String(val));
+    var accessors = items.map(function(item) {
+      return getPropertyAccessor(item, typeHint, lyr, svgName);
+    });
+    return function(id) {
+      return accessors.map(function(accessor) {
+        return accessor(id);
+      });
+    };
+  }
+  // Returns a function that maps a feature id to a property value. The value may
+  // be given as a literal, as the name of a data field, or as a JS expression
+  // evaluated against each feature.
+  // typeHint: a type understood by parseSvgLiteralValue(), or null to accept any
+  //   string as a literal value
+  // name: used in error messages
+  // Callers outside the SVG property system pass a type hint directly, rather
+  // than registering an option name in symbolPropertyTypes -- that index also
+  // decides which options the -symbols command treats as symbol properties.
+  function getPropertyAccessor(val, typeHint, lyr, name) {
     var strVal = String(val).trim();
-    var typeHint = symbolPropertyTypes[svgName];
     var fields = lyr.data ? lyr.data.getFields() : [];
     var literalVal = null;
     var accessor;
@@ -26164,7 +26409,7 @@
     }
     if (accessor) return accessor;
     if (literalVal !== null) return function(id) {return literalVal;};
-    stop$1('Unexpected value for', svgName + ':', strVal);
+    stop$1('Unexpected value for', name + ':', strVal);
   }
 
   function parseStyleExpression(strVal, lyr) {
@@ -26270,7 +26515,9 @@
     applyStyleAttributes: applyStyleAttributes,
     findStylePropertiesBySymbolGeom: findStylePropertiesBySymbolGeom,
     getLabelPositionStyle: getLabelPositionStyle,
+    getPropertyAccessor: getPropertyAccessor,
     getSymbolDataAccessor: getSymbolDataAccessor,
+    getSymbolListAccessor: getSymbolListAccessor,
     getSymbolPropertyAccessor: getSymbolPropertyAccessor,
     isSupportedSvgStyleProperty: isSupportedSvgStyleProperty,
     isSvgClassName: isSvgClassName,
@@ -37954,139 +38201,6 @@ ${svg}
     }
   }
 
-  var assignmentRxp = /^([a-z0-9_+-]+)=(?!=)(.*)$/i; // exclude ==
-
-  function splitShellTokens(str) {
-    var BAREWORD = `([^'"\\s])+`;
-    var DOUBLE_QUOTE = `"((\\\\"|[^"])*?)"`;
-    var SINGLE_QUOTE = `'((\\\\'|[^'])*?)'`;
-    var rxp = new RegExp('(' + BAREWORD + '|' + SINGLE_QUOTE + '|' + DOUBLE_QUOTE + ')*', 'g');
-    var matches = str.match(rxp) || [];
-    var chunks = matches.filter(function(chunk) {
-      // single backslashes may be present in multiline commands pasted from a makefile, e.g.
-      return !!chunk && chunk != '\\';
-    }).map(utils.trimQuotes);
-    return chunks;
-  }
-
-  function parsePercent(o) {
-    var str = String(o);
-    var isPct = str.indexOf('%') > 0;
-    var pct;
-    if (isPct) {
-      pct = Number(str.replace('%', '')) / 100;
-    } else {
-      pct = Number(str);
-    }
-    if (!(pct >= 0 && pct <= 1)) {
-      stop$1(utils.format("Invalid percentage: %s", str));
-    }
-    return pct;
-  }
-
-  function parseNumberList(token) {
-    return token.split(',').map(parseFloat);
-  }
-
-  // Split comma-delimited list, trim quotes from entire list and
-  // individual members
-  function parseStringList(token) {
-    var delim = ',';
-    var list = splitOptionList(token, delim);
-    if (list.length == 1) {
-      list = splitOptionList(list[0], delim);
-    }
-    return list;
-  }
-
-  // Accept spaces and/or commas as delimiters
-  function parseColorList(token) {
-    var delim = ', ';
-    // accept rgb(0 0 0) rgb(0,0,0) rgb(0, 0, 0)
-    var token2 = token.replace(/[ ,] *(?=[^(]*\))/g, '~~~'); // kludge: protect rgba() functions from being split apart
-    var list = splitOptionList(token2, delim);
-    if (list.length == 1) {
-      list = splitOptionList(list[0], delim);
-    }
-    list = list.map(function(str) {
-      return str.replace(/~~~/g, ',');
-    });
-    return list;
-  }
-
-  function cleanArgv(argv) {
-    // Note: original trim caused some quoted spaces to be removed
-    // (e.g. bash shell seems to convert [delimiter=" "] to [delimiter= ],
-    //  which then got trimmed to [delimiter=] below)
-    //// argv = argv.map(function(s) {return s.trim();}); // trim whitespace
-
-    // Updated: don't trim space from tokens like [delimeter= ]
-    argv = argv.map(function(s) {
-      if (!/= $/.test(s)) {
-        s = utils.rtrim(s);
-      }
-      s = utils.ltrim(s);
-      return s;
-    });
-    argv = argv.filter(function(s) {return s !== '';}); // remove empty tokens
-    // Note: removing trimQuotes() call... now, strings like 'name="Meg"' will no longer
-    // be parsed the same way as name=Meg and name="Meg"
-    //// argv = argv.map(utils.trimQuotes); // remove one level of single or dbl quotes
-    return argv;
-  }
-
-  function splitOptionList(str, delimChars) {
-    var BAREWORD = '([^' + delimChars + '\'"][^' + delimChars + ']*)'; // TODO: make safer
-    var DOUBLE_QUOTE = '"((\\\\"|[^"])*?)"';
-    var SINGLE_QUOTE = '\'((\\\\\'|[^\'])*?)\'';
-    var rxp = new RegExp('^(' + BAREWORD + '|' + SINGLE_QUOTE + '|' + DOUBLE_QUOTE + ')([' + delimChars + ']+|$)');
-    var chunks = [];
-    var match;
-    while ((match = rxp.exec(str)) !== null) {
-      chunks.push(match[1]);
-      str = str.substr(match[0].length);
-    }
-    return chunks.filter(function(chunk) {
-      return !!chunk && chunk != '\\';
-    }).map(utils.trimQuotes);
-  }
-
-  // Prepare a value to be used as an option value.
-  // Places quotes around strings containing spaces.
-  // e.g. converts   Layer 1 -> "Layer 1"
-  //   for use in contexts like: name="Layer 1"
-  function formatOptionValue(val) {
-    val = String(val);
-    if (val.indexOf(' ') > -1) {
-      val = JSON.stringify(val); // quote ids with spaces
-    }
-    return val;
-  }
-
-  function isAssignment(token) {
-    return assignmentRxp.test(token);
-  }
-
-  function splitAssignment(token) {
-    var match = assignmentRxp.exec(token),
-        name = match[1],
-        val = utils.trimQuotes(match[2]);
-    return [name, val];
-  }
-
-  var OptionParsingUtils = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    cleanArgv: cleanArgv,
-    formatOptionValue: formatOptionValue,
-    isAssignment: isAssignment,
-    parseColorList: parseColorList,
-    parseNumberList: parseNumberList,
-    parsePercent: parsePercent,
-    parseStringList: parseStringList,
-    splitAssignment: splitAssignment,
-    splitShellTokens: splitShellTokens
-  });
-
   function CommandParser() {
     var commandRxp = /^--?([a-z][\w-]*)$/i,
         invalidCommandRxp = /^--?[a-z][\w-]*[=]/i, // e.g. -target=A // could be more general
@@ -38266,6 +38380,7 @@ ${svg}
       // Try to read an option for command @cmdDef from @argv
       function readOption(cmd, argv, cmdDef) {
         var token = argv.shift(),
+            assignedValue = null,
             optName, optDef, parts;
 
         if (isAssignment(token)) {
@@ -38275,7 +38390,10 @@ ${svg}
           if (!optDef) ; else if (optDef.type == 'flag' || optDef.assign_to) {
             stop$1("-" + cmdDef.name + " " + parts[0] + " option doesn't take a value");
           } else {
-            argv.unshift(parts[1]);
+            // Keep the value out of argv: it was written as part of the token,
+            // so it is a value even when it looks like a command name
+            // (e.g. hole=-size, dx=-OFFSET).
+            assignedValue = parts[1];
           }
         } else {
           // try to parse as a flag option,
@@ -38300,6 +38418,8 @@ ${svg}
           cmd.options[optDef.assign_to] = optDef.name;
         } else if (optDef.type == 'flag') {
           cmd.options[optName] = true;
+        } else if (assignedValue !== null) {
+          cmd.options[optName] = parseOptionValue(assignedValue, optDef);
         } else {
           cmd.options[optName] = readOptionValue(argv, optDef);
         }
@@ -41003,10 +41123,41 @@ ${svg}
       })
      .option('target', targetOpt);
 
+    parser.command('repel')
+      .describe('move overlapping point symbols apart')
+      .option('width', {
+        describe: 'display width of the layer in pixels (required if no frame)',
+        type: 'number'
+      })
+      .option('max-shift', {
+        describe: 'max displacement in pixels; may vary by symbol (default is 20)'
+      })
+      .option('padding', {
+        describe: 'pixels of clearance around each symbol; may vary (default is 0)'
+      })
+      .option('margin', {
+        describe: 'pixels of clearance between two symbols; may vary (default is 0)'
+      })
+      .option('ticks', {
+        describe: 'number of solver passes (default is 100)',
+        type: 'number'
+      })
+      .option('strength', {
+        describe: 'portion of each overlap resolved per pass, 0-1 (default is 0.4)',
+        type: 'number'
+      })
+      .option('radius', {
+        describe: 'field or expression giving symbol radius in pixels',
+      })
+      .option('polygons', {
+        describe: 'layer or file of polygons that symbols must stay inside'
+      })
+      .option('target', targetOpt);
+
     parser.command('symbols')
       .describe('symbolize points as arrows, circles, stars, polygons, etc.')
       .option('type', {
-        describe: 'types: arrow, circle, square, star, polygon, ring'
+        describe: 'types: arrow, circle, square, star, polygon, ring, pie'
       })
       .option('stroke', {})
       .option('stroke-width', {})
@@ -41065,6 +41216,15 @@ ${svg}
       .option('radii', {
         describe: '(ring) comma-sep. list of concentric radii, ascending order'
       })
+      .option('hole', {
+        describe: '(pie) radius of the hole in a donut symbol'
+      })
+      .option('values', {
+        describe: '(pie) comma-sep. list of wedge values (numbers or fields)'
+      })
+      .option('fills', {
+        describe: '(pie) comma-sep. list of wedge fill colors'
+      })
       .option('arrow-style', {
         describe: '(arrow) options: stick, standard (default is standard)'
       })
@@ -44316,9 +44476,10 @@ ${svg}
     ({gpkg, tmpPath} = await openGeoPackage(input, geopackage));
     var availableLayers;
     var filterApplied;
+    var unreadableLayers;
     try {
       try {
-        ({datasets, availableLayers, filterApplied} = readFeatureTableDatasets(gpkg, opts));
+        ({datasets, availableLayers, filterApplied, unreadableLayers} = readFeatureTableDatasets(gpkg, opts));
       } catch (e) {
         if (!runningInBrowser() && isLocalCsProjError(e)) {
           gpkg.close();
@@ -44331,7 +44492,7 @@ ${svg}
             throw e;
           }
           gpkg = await geopackage.GeoPackageAPI.open(tmpPath);
-          ({datasets, availableLayers, filterApplied} = readFeatureTableDatasets(gpkg, opts));
+          ({datasets, availableLayers, filterApplied, unreadableLayers} = readFeatureTableDatasets(gpkg, opts));
         } else {
           throw e;
         }
@@ -44346,6 +44507,7 @@ ${svg}
         layers: [{name: '', data: null}],
         info: {
           _gpkg_available_layers: availableLayers,
+          _gpkg_unreadable_layers: unreadableLayers,
           _gpkg_placeholder: !!filterApplied
         }
       };
@@ -44357,6 +44519,7 @@ ${svg}
     mergedArr.forEach(function(ds) {
       ds.info = ds.info || {};
       ds.info._gpkg_available_layers = availableLayers;
+      ds.info._gpkg_unreadable_layers = unreadableLayers;
     });
     return merged;
   }
@@ -44482,10 +44645,38 @@ ${svg}
     var availableLayers = gpkg.getFeatureTables() || [];
     var tables = filterGeoPackageTables(availableLayers, selected);
     var filterApplied = Array.isArray(selected) && selected.length > 0;
-    var datasets = tables.map(function(table) {
-      return readFeatureTable(gpkg, table, opts);
+    var unreadableLayers = [];
+    var datasets = [];
+    tables.forEach(function(table) {
+      try {
+        datasets.push(readFeatureTable(gpkg, table, opts));
+      } catch (e) {
+        // The caller recovers from a CRS parsing failure by rewriting the file's
+        // CRS metadata and re-reading, so that error must not be swallowed here.
+        if (isLocalCsProjError(e)) throw e;
+        unreadableLayers.push(table);
+        warn(formatUnreadableTableMessage(table, e));
+      }
     });
-    return {datasets: datasets, availableLayers: availableLayers, filterApplied: filterApplied};
+    return {
+      datasets: datasets,
+      availableLayers: availableLayers,
+      filterApplied: filterApplied,
+      unreadableLayers: unreadableLayers
+    };
+  }
+
+  // A GeoPackage can advertise feature tables that aren't readable. USGS National
+  // Map vector products, for instance, list a CLIPPOLY table in gpkg_contents and
+  // gpkg_geometry_columns after dropping the table itself from the file. GDAL
+  // skips such layers with a warning; do the same rather than failing the whole
+  // import over one bad table.
+  function formatUnreadableTableMessage(table, err) {
+    var msg = err && err.message ? String(err.message) : '';
+    var reason = /^Table does not exist:/.test(msg) ?
+      'the table is listed in the GeoPackage metadata but is missing from the file' :
+      msg || 'unknown error';
+    return 'Skipping GeoPackage layer "' + table + '": ' + reason;
   }
 
   function getSelectedGeoPackageLayers(opts) {
@@ -46458,12 +46649,12 @@ ${svg}
       var coords = path.coords;
       if (coords.length < 2) return;
       if (forcePolylinePaths) {
-        lines.push(path.closed || pointsEqual$1(coords[0], coords[coords.length - 1]) ? closeRing(coords) : coords);
+        lines.push(path.closed || pointsEqual$1(coords[0], coords[coords.length - 1]) ? closeRing$1(coords) : coords);
         return;
       }
       if (path.closed || pointsEqual$1(coords[0], coords[coords.length - 1])) {
         if (coords.length >= 3) {
-          rings.push(closeRing(coords));
+          rings.push(closeRing$1(coords));
         }
       } else {
         lines.push(coords);
@@ -46767,7 +46958,7 @@ ${svg}
     return /translate\(/i.test(String(str || ''));
   }
 
-  function closeRing(coords) {
+  function closeRing$1(coords) {
     var ring = coords.map(function(p) { return [p[0], p[1]]; });
     if (!pointsEqual$1(ring[0], ring[ring.length - 1])) {
       ring.push([ring[0][0], ring[0][1]]);
@@ -47244,15 +47435,12 @@ ${svg}
     var files = opts.files || [];
     var dataset, datasets, target;
 
+    // copy opts, so parameters can be modified within this command
+    opts = Object.assign({}, opts);
+    opts.input = Object.assign({}, opts.input); // make sure we have a cache
+
     if (opts.stdin) {
-      datasets = await importDatasetsFromFile('/dev/stdin', opts);
-      catalog.addDatasets(datasets);
-      if (datasets.length > 1) {
-        catalog.setDefaultTargets(datasets.map(function(ds) {
-          return {dataset: ds, layers: ds.layers};
-        }));
-      }
-      return normalizeImportedTarget(datasets);
+      files = [readStdinAsFile(opts.input)];
     }
 
     if (files.length > 0 === false) {
@@ -47261,10 +47449,6 @@ ${svg}
 
     verbose("Importing: " + files.join(' '));
 
-    // copy opts, so parameters can be modified within this command
-    opts = Object.assign({}, opts);
-    opts.input = Object.assign({}, opts.input); // make sure we have a cache
-
     convertDataObjects(files, opts.input);
 
     files = expandFiles(files, opts.input);
@@ -47345,6 +47529,41 @@ ${svg}
     return obj.target;
   }
 
+  // Read the stdin stream into @cache and return the filename to import it as.
+  // A zipped dataset is given a .zip or .kmz name, so that it is unpacked by
+  // expandFiles() like an archive passed as a file argument. Stdin carries no
+  // filename to identify its contents, so an archive is detected from the ZIP
+  // magic number, and a KMZ is told from an ordinary zip by its doc.kml entry.
+  function readStdinAsFile(cache) {
+    var path = '/dev/stdin';
+    var content = cli.readFile(path, null, cache);
+    var name = path;
+    if (contentLooksZipped(content)) {
+      name = zipContainsDocKml(content) ? 'stdin.kmz' : 'stdin.zip';
+    }
+    cache[name] = content;
+    return name;
+  }
+
+  // Detect the ZIP local file header signature ("PK\x03\x04")
+  function contentLooksZipped(content) {
+    var bytes = content instanceof ArrayBuffer ? new Uint8Array(content) : content;
+    if (utils.isString(bytes) || !bytes || bytes.length < 4) return false;
+    return bytes[0] == 0x50 && bytes[1] == 0x4b && bytes[2] == 0x03 && bytes[3] == 0x04;
+  }
+
+  function zipContainsDocKml(content) {
+    var names;
+    try {
+      names = listZipEntryNames(content);
+    } catch(e) {
+      return false; // let the unzipping step report a malformed archive
+    }
+    return names.some(function(name) {
+      return parseLocalPath(name).filename.toLowerCase() == 'doc.kml';
+    });
+  }
+
   function expandFiles(files, cache) {
     var files2 = [];
     files.forEach(function(file) {
@@ -47476,6 +47695,7 @@ ${svg}
       content = cli.readFile(path, encoding || 'utf-8', cache);
       fileType = guessInputContentType(content);
       if (fileType == 'text' && content.indexOf('\ufffd') > -1) {
+        // invalidate string data that contains the 'replacement character'
         fileType = null;
       }
     }
@@ -47484,7 +47704,7 @@ ${svg}
       stop$1(getUnsupportedFileMessage(path));
     }
     input[fileType] = {filename: path, content: content};
-    content = null;
+    content = null; // for g.c.
     if (fileType == 'shp' || fileType == 'dbf') {
       readShapefileAuxFiles(path, input, cache);
     } else if (isRasterImageInputType(fileType)) {
@@ -47529,12 +47749,14 @@ ${svg}
   function validateAndCleanGpkgSelection(datasets, opts) {
     var availableSet = new Set();
     var importedSet = new Set();
+    var unreadableSet = new Set();
     var sawGpkg = false;
     datasets.forEach(function(ds) {
       var info = ds && ds.info;
       if (!info || !Array.isArray(info._gpkg_available_layers)) return;
       sawGpkg = true;
       info._gpkg_available_layers.forEach(function(name) { availableSet.add(name); });
+      (info._gpkg_unreadable_layers || []).forEach(function(name) { unreadableSet.add(name); });
       if (!info._gpkg_placeholder) {
         (ds.layers || []).forEach(function(lyr) {
           if (lyr && lyr.name) importedSet.add(lyr.name);
@@ -47542,9 +47764,17 @@ ${svg}
       }
     });
     if (sawGpkg && Array.isArray(opts.layers) && opts.layers.length > 0) {
-      var missing = opts.layers.filter(function(name) {
+      var absent = opts.layers.filter(function(name) {
         return !importedSet.has(name);
       });
+      // A layer that the file advertises but that can't be parsed is skipped with
+      // a warning during import; report it separately here, because saying it is
+      // missing while also listing it as an existing layer is contradictory.
+      var unreadable = absent.filter(function(name) { return unreadableSet.has(name); });
+      var missing = absent.filter(function(name) { return !unreadableSet.has(name); });
+      if (unreadable.length > 0) {
+        stop$1('Unable to read GeoPackage layer(s): ' + unreadable.join(', '));
+      }
       if (missing.length > 0) {
         stop$1(
           'Missing GeoPackage layer(s): ' + missing.join(', ') + '\n' +
@@ -47558,6 +47788,7 @@ ${svg}
     cleaned.forEach(function(ds) {
       if (ds && ds.info) {
         delete ds.info._gpkg_available_layers;
+        delete ds.info._gpkg_unreadable_layers;
         delete ds.info._gpkg_placeholder;
       }
     });
@@ -48368,7 +48599,7 @@ ${svg}
   const resulterrbound = (3 + 8 * epsilon) * epsilon;
 
   // fast_expansion_sum_zeroelim routine from oritinal code
-  function sum(elen, e, flen, f, h) {
+  function sum$1(elen, e, flen, f, h) {
       let Q, Qnew, hh, bvirt;
       let enow = e[0];
       let fnow = f[0];
@@ -48551,7 +48782,7 @@ ${svg}
       bvirt = u3 - _j;
       u[2] = _j - (u3 - bvirt) + (_i - bvirt);
       u[3] = u3;
-      const C1len = sum(4, B$2, 4, u, C1);
+      const C1len = sum$1(4, B$2, 4, u, C1);
 
       s1 = acx * bcytail;
       c = splitter * acx;
@@ -48582,7 +48813,7 @@ ${svg}
       bvirt = u3 - _j;
       u[2] = _j - (u3 - bvirt) + (_i - bvirt);
       u[3] = u3;
-      const C2len = sum(C1len, C1, 4, u, C2);
+      const C2len = sum$1(C1len, C1, 4, u, C2);
 
       s1 = acxtail * bcytail;
       c = splitter * acxtail;
@@ -48613,7 +48844,7 @@ ${svg}
       bvirt = u3 - _j;
       u[2] = _j - (u3 - bvirt) + (_i - bvirt);
       u[3] = u3;
-      const Dlen = sum(C2len, C2, 4, u, D$1);
+      const Dlen = sum$1(C2len, C2, 4, u, D$1);
 
       return D$1[Dlen - 1];
   }
@@ -74984,7 +75215,7 @@ ${svg}
 
     var datasets = [targetDataset];
     var outputLayers = targetLayers.map(function(pointLyr) {
-      if (countMultiPartFeatures(pointLyr) > 0) {
+      if (countMultiPartFeatures(pointLyr.shapes) > 0) {
         stop$1('This command requires single points');
       }
       var dataset = getPolygonDataset(pointLyr, bbox, opts);
@@ -75300,6 +75531,761 @@ ${svg}
     }, {});
   }
 
+  // Keeps each symbol's center inside the polygon that contained it to begin
+  // with, so that a symbol representing one area can't drift into a neighboring
+  // one. Used by -repel via its polygons= option.
+  //
+  // Nodes are laid out in pixel space, at a scale of @pixelsPerUnit pixels per
+  // unit of the polygons' coordinate system. That transform is a pure scale (see
+  // how -repel builds its nodes), so dividing a node position by it gives a
+  // position that can be tested against the polygons directly.
+
+  // Bisection steps used to find how far a symbol can travel before it leaves its
+  // polygon. Six steps locate the crossing to within 1/64 of the attempted move;
+  // finer searches were measured and change the result by a fraction of a pixel.
+  var BISECT_STEPS = 6;
+
+  // Assigns each node the id of the polygon containing its anchor, or -1 if the
+  // anchor isn't inside any of them. Returns the number of unassigned nodes,
+  // which are left free to move.
+  function assignContainingPolygons(nodes, lyr, arcs, pixelsPerUnit) {
+    var index = new PathIndex(lyr.shapes, arcs);
+    var unassigned = 0;
+    nodes.forEach(function(node) {
+      node.polygonId = index.findEnclosingShape([node.x0 / pixelsPerUnit, node.y0 / pixelsPerUnit]);
+      node.insideX = node.x0;
+      node.insideY = node.y0;
+      if (node.polygonId == -1) unassigned++;
+    });
+    return unassigned;
+  }
+
+  // Returns a function that the solver runs after each pass: any symbol that has
+  // left its polygon is pulled back along the path it just travelled, to the
+  // furthest point that is still inside.
+  //
+  // This can't violate the max-shift limit. The position it assigns always lies
+  // between two positions the node has already held, both of which the solver
+  // clamped to within max-shift of the anchor, and a disk is convex.
+  function getContainmentConstraint(lyr, arcs, pixelsPerUnit) {
+    var shapes = lyr.shapes;
+
+    function isInside(node, x, y) {
+      return testPointInPolygon(x / pixelsPerUnit, y / pixelsPerUnit,
+        shapes[node.polygonId], arcs);
+    }
+
+    return function(nodes) {
+      var node, lo, hi, mid, x, y, i, j;
+      for (i=0; i<nodes.length; i++) {
+        node = nodes[i];
+        if (node.polygonId == -1) continue;
+        // A node that hasn't moved since it was last checked is still inside,
+        // so most symbols in a sparse layout cost nothing after the early passes
+        if (node.x === node.insideX && node.y === node.insideY) continue;
+        if (isInside(node, node.x, node.y)) {
+          node.insideX = node.x;
+          node.insideY = node.y;
+          continue;
+        }
+        lo = 0; // known inside
+        hi = 1; // known outside
+        for (j=0; j<BISECT_STEPS; j++) {
+          mid = (lo + hi) / 2;
+          x = node.insideX + (node.x - node.insideX) * mid;
+          y = node.insideY + (node.y - node.insideY) * mid;
+          if (isInside(node, x, y)) lo = mid; else hi = mid;
+        }
+        node.x = node.insideX + (node.x - node.insideX) * lo;
+        node.y = node.insideY + (node.y - node.insideY) * lo;
+        node.insideX = node.x;
+        node.insideY = node.y;
+      }
+    };
+  }
+
+  var roundCoord$1 = getRoundingFunction(0.01);
+
+  function getSymbolFillColor(d) {
+    return d.fill || 'magenta';
+  }
+
+  function getSymbolStrokeColor(d) {
+    return d.stroke || d.fill || 'magenta';
+  }
+
+  function applySymbolStyles(sym, d) {
+    if (sym.type == 'polyline') {
+      sym.stroke = getSymbolStrokeColor(d);
+    } else {
+      sym.fill = getSymbolFillColor(d);
+    }
+    if (d.opacity) {
+      sym.opacity = d.opacity;
+    }
+    return sym;
+  }
+
+  function getSymbolRadius(d) {
+    if (d.radius === 0 || d.length === 0 || d.r === 0) return 0;
+    return d.radius || d.length || d.r || 5; // use a default value
+  }
+
+  // Converts the value of a list-valued option into an array of items. The value
+  // arrives either as a whole string (from a direct call, rather than from the
+  // -symbols option accessor) or as an array of items already resolved one by
+  // one. An item that holds an array of its own, as an expression like
+  // [R, R * 0.5] does, is flattened into the list. Items themselves are left
+  // unsplit, because a single item can contain a comma, as rgba() colors do.
+  function toItemList(val) {
+    var items = utils.isString(val) ? splitListItems(val) : [].concat(val);
+    var list = [];
+    for (var i=0; i<items.length; i++) {
+      if (Array.isArray(items[i])) {
+        list = list.concat(items[i]);
+      } else {
+        list.push(items[i]);
+      }
+    }
+    return list;
+  }
+
+  // Like toItemList(), for options that take numbers. An item that is a string
+  // containing commas is split, so that a data field holding a value like "2,4"
+  // works as a list. Values that aren't numbers become NaN, for the caller to
+  // report or ignore.
+  function toNumberList(val) {
+    var list = [];
+    toItemList(val).forEach(function(item) {
+      if (utils.isString(item) && item.indexOf(',') > -1) {
+        list = list.concat(parseNumberList(item));
+      } else {
+        list.push(Number(item));
+      }
+    });
+    return list;
+  }
+
+  // Returns the radius of the smallest circle centered on a symbol's point that
+  // covers the symbol, or null if the symbol contains a part whose reach can't be
+  // measured.
+  //
+  // Only a symbol drawn around its point can be described this way: a circle, or
+  // a group of the circles and polygons that make up ring, pie and donut symbols.
+  // An arrow is drawn from its point outward, so the circle around its point that
+  // covers it says nothing useful about the space it occupies -- arrows are plain
+  // polygon symbols, which reach this function only as group parts, which they
+  // never are.
+  function getSymbolBoundingRadius(sym) {
+    var max = 0;
+    var parts, r, i;
+    if (!sym) return null;
+    if (sym.type == 'circle') {
+      // Half of a stroke lies outside the circle it follows, which is how a ring
+      // symbol paints its bands.
+      return getPositiveNumber(sym.r) + getStrokeOutset(sym);
+    }
+    if (sym.type == 'polygon') {
+      forEachSymbolCoord(sym.coordinates || [], function(p) {
+        var dist = Math.sqrt(p[0] * p[0] + p[1] * p[1]);
+        if (dist > max) max = dist;
+      });
+      return max + getStrokeOutset(sym);
+    }
+    if (sym.type == 'group') {
+      parts = sym.parts || [];
+      for (i=0; i<parts.length; i++) {
+        r = getSymbolBoundingRadius(parts[i]);
+        if (r === null) return null;
+        if (r > max) max = r;
+      }
+      return max;
+    }
+    return null;
+  }
+
+  // A stroke straddles the path it is drawn on, so half of its width extends
+  // beyond the shape.
+  function getStrokeOutset(sym) {
+    var width = sym['stroke-width'];
+    if (!sym.stroke || sym.stroke == 'none') return 0;
+    // an SVG stroke is one pixel wide unless stroke-width says otherwise
+    if (width === undefined || width === null || width === '') return 0.5;
+    return getPositiveNumber(width) / 2;
+  }
+
+  function getPositiveNumber(val) {
+    var num = +val;
+    return num > 0 ? num : 0;
+  }
+
+  function forEachSymbolCoord(coords, cb) {
+    var isPoint = coords && utils.isNumber(coords[0]);
+    var isNested = !isPoint && coords && Array.isArray(coords[0]);
+    if (isPoint) return cb(coords);
+    for (var i=0; i<coords.length; i++) {
+      if (isNested) forEachSymbolCoord(coords[i], cb);
+    }
+  }
+
+  function flipY(coords) {
+    forEachSymbolCoord(coords, function(p) {
+      p[1] = -p[1];
+    });
+  }
+
+  function scaleAndShiftCoords(coords, scale, shift) {
+    forEachSymbolCoord(coords, function(xy) {
+      xy[0] = xy[0] * scale + shift[0];
+      xy[1] = xy[1] * scale + shift[1];
+    });
+  }
+
+  function roundCoordsForSVG(coords) {
+    forEachSymbolCoord(coords, function(p) {
+      p[0] = roundCoord$1(p[0]);
+      p[1] = roundCoord$1(p[1]);
+    });
+  }
+
+  function rotateCoords(coords, rotation) {
+    if (!rotation) return;
+    var f = getAffineTransform(rotation, 1, [0, 0], [0, 0]);
+    forEachSymbolCoord(coords, function(p) {
+      var p2 = f(p[0], p[1]);
+      p[0] = p2[0];
+      p[1] = p2[1];
+    });
+  }
+
+  // Collision reduction for circular symbols, in the spirit of d3-force's
+  // forceCollide. Overlapping symbols are pushed apart, but each one is kept
+  // within a fixed distance of its true position.
+  //
+  // Nodes are laid out in pixel space; converting to and from map coordinates is
+  // the caller's job. A node is {i, x, y, x0, y0, r, maxShift, margin}, where
+  // x0,y0 is the anchor (the symbol's true position), r includes any padding and
+  // maxShift is the furthest this symbol may be displaced. All three of r,
+  // maxShift and margin are per-node, so the caller can vary them from symbol to
+  // symbol; a node with a maxShift of 0 never moves and so acts as a fixed
+  // obstacle.
+  //
+  // A pair of nodes is kept a.r + b.r + max(a.margin, b.margin) apart, so a
+  // margin is a gap that one symbol claims from every neighbor, whatever the
+  // neighbor asks for, and the larger of the two claims wins. Padding is the
+  // alternative already folded into r, where a pair ends up with the sum of the
+  // two symbols' padding between them. margin is optional; treated as 0 if absent.
+  //
+  // A negative margin lets a pair overlap, but only where both nodes permit it:
+  // max() means one node's 0 outranks another's -5.
+
+  // max_shift is not read by the solver (it is a per-node property); it is here
+  // as the default for callers to apply when building nodes.
+  //
+  // strength is the damping factor of what is essentially Gauss-Seidel
+  // relaxation. A symbol in a cluster is corrected once per overlapping neighbor
+  // in a single pass, so the corrections sum to more than its own overlap and
+  // values near 1 overshoot and oscillate. Given the tick budget below, anything
+  // from 0.3 to 1.0 resolves a layout that can be resolved at all; the value only
+  // matters where crowding exceeds what max-shift can fix, and there the lower
+  // end leaves shallower overlaps and holds symbols closer to their true
+  // positions. Below about 0.4 the solver stops reliably breaking up stacks of
+  // coincident symbols.
+  var symbolCollisionDefaults = {
+    ticks: 100,
+    max_shift: 20,
+    strength: 0.4
+  };
+
+  // Mutates the x,y properties of @nodes. Returns the number of nodes that moved.
+  //
+  // opts.constrain is an optional function(nodes) applied after each pass, for
+  // callers that need to restrict where symbols may go (see
+  // mapshaper-symbol-containment.mjs). It must only move a node to a position
+  // between ones the node has already held, or the max-shift limit no longer
+  // holds.
+  function resolveSymbolCollisions(nodes, opts) {
+    var ticks = opts.ticks,
+        strength = opts.strength,
+        constrain = opts.constrain || null,
+        moved = 0,
+        i;
+    if (nodes.length < 2 || !(ticks > 0) || !anyNodeCanMove(nodes)) return 0;
+    for (i=0; i<ticks; i++) {
+      resolveCollisions(nodes, strength);
+      // Limiting the displacement on every pass (instead of only at the end)
+      // avoids pulling symbols back into the overlaps they just escaped.
+      limitDisplacement(nodes);
+      if (constrain) constrain(nodes);
+    }
+    for (i=0; i<nodes.length; i++) {
+      if (nodes[i].x !== nodes[i].x0 || nodes[i].y !== nodes[i].y0) moved++;
+    }
+    return moved;
+  }
+
+  // Collisions shallower than this are not reported. A converged layout doesn't
+  // leave pairs at exactly the separation they need, it leaves a tail of pairs
+  // short of it by a fraction of a pixel -- on a solved 435-symbol layout, 55
+  // pairs fall short by more than a hundredth of a pixel, 6 by more than half a
+  // pixel, and none by more than one. So a threshold of a pixel is where this
+  // solver's convergence residue ends and genuine unresolved crowding begins, as
+  // well as being about the point where the shortfall becomes visible.
+  var VISIBLE_COLLISION = 1; // pixels
+
+  // Number of pairs that fall visibly short of the separation they need, for
+  // reporting how much of the job got done. Deliberately not a count of every
+  // collision: falling short by a 100th of a pixel and by 15 pixels are not the
+  // same result, and treating them alike makes a layout that is visually finished
+  // look like a failure.
+  //
+  // Note this counts collisions, not overlaps, and padding or a margin can put
+  // the two apart: symbols asked to keep 4px between them and left 3px apart are
+  // colliding, in that the layout hasn't done what was asked, but not overlapping.
+  function countSymbolCollisions(nodes) {
+    var count = 0;
+    forEachCollision(nodes, function(a, b, dx, dy, distSq, sum) {
+      if (sum - Math.sqrt(distSq) > VISIBLE_COLLISION) count++;
+    });
+    return count;
+  }
+
+  // Push colliding nodes apart, in proportion to how far short of their required
+  // separation they are. Larger nodes move less than smaller ones. Which of the
+  // two yields is decided by their radii alone, so asking for a wide margin does
+  // not also make a symbol harder to push.
+  function resolveCollisions(nodes, strength) {
+    forEachCollision(nodes, function(a, b, dx, dy, distSq, sum) {
+      separate(a, b, dx, dy, distSq, sum, strength);
+    });
+  }
+
+  // Sweep along the x axis, using the greatest reach still ahead of the current
+  // node to know when to stop looking for neighbors. A node's reach is its radius
+  // plus its margin if that margin is positive: only a positive margin widens the
+  // area a symbol needs, and clamping is what makes the bound below safe.
+  //
+  // Breaking out of the inner loop is valid because the separation a pair needs,
+  // a.r + b.r + max(a.margin, b.margin), never exceeds a.reach + b.reach. With
+  // margins clamped at 0 that holds, since max(ma, mb) <= max(ma, 0) + max(mb, 0).
+  // Without the clamp it fails for two negative margins -- max(-3, -3) is -3, not
+  // -6 -- and the sweep quietly stops short of pairs that are still colliding.
+  //
+  // Margins are collected into an array in the same pass that builds the bound,
+  // which normalizes a missing margin to 0 once per node instead of guarding every
+  // comparison in the loop below.
+  //
+  // Note the sort happens once per pass while the callback moves nodes as it goes,
+  // so the bound is applied to positions that have already shifted and a pair that
+  // drifts into range mid-pass can be missed until the next pass re-sorts. A
+  // consequence is that padding and an equivalent margin, which ask for the same
+  // separation, don't produce identical output: the margin gives a node a longer
+  // reach, which prunes less and catches a few more of those pairs.
+  function forEachCollision(nodes, cb) {
+    var n = nodes.length,
+        maxAhead = new Float64Array(n),
+        margins = new Float64Array(n),
+        max = 0,
+        a, b, dx, dy, sum, distSq, reach, ma, mb, i, j;
+    nodes.sort(compareX);
+    for (i=n-1; i>=0; i--) {
+      ma = nodes[i].margin || 0;
+      margins[i] = ma;
+      reach = nodes[i].r + (ma > 0 ? ma : 0);
+      if (reach > max) max = reach;
+      maxAhead[i] = max;
+    }
+    for (i=0; i<n; i++) {
+      a = nodes[i];
+      ma = margins[i];
+      reach = a.r + (ma > 0 ? ma : 0);
+      for (j=i+1; j<n; j++) {
+        b = nodes[j];
+        dx = b.x - a.x;
+        if (dx > reach + maxAhead[j]) break;
+        dy = b.y - a.y;
+        mb = margins[j];
+        sum = a.r + b.r + (ma > mb ? ma : mb);
+        // Margins can cancel the pair's radii entirely, which separate() would
+        // read as an overlap and answer by pulling the two nodes together.
+        if (sum <= 0) continue;
+        if (dy > sum || dy < -sum) continue;
+        distSq = dx * dx + dy * dy;
+        if (distSq >= sum * sum) continue;
+        cb(a, b, dx, dy, distSq, sum);
+      }
+    }
+  }
+
+  function compareX(a, b) {
+    // Break ties by original index, so the order of equally positioned nodes
+    // doesn't depend on the engine's sort implementation.
+    return a.x - b.x || a.i - b.i;
+  }
+
+  function separate(a, b, dx, dy, distSq, sum, strength) {
+    var ux, uy, overlap, dist, dir, shift, share;
+    if (distSq > 0) {
+      dist = Math.sqrt(distSq);
+      ux = dx / dist;
+      uy = dy / dist;
+      overlap = sum - dist;
+    } else {
+      // Coincident nodes: pick a repeatable arbitrary direction
+      dir = getPseudoDirection(a.i, b.i);
+      ux = dir[0];
+      uy = dir[1];
+      overlap = sum;
+    }
+    shift = overlap * strength;
+    share = b.r * b.r / (a.r * a.r + b.r * b.r); // portion moved by a
+    a.x -= ux * shift * share;
+    a.y -= uy * shift * share;
+    b.x += ux * shift * (1 - share);
+    b.y += uy * shift * (1 - share);
+  }
+
+  // A deterministic stand-in for d3-force's jiggle(), which uses Math.random()
+  function getPseudoDirection(i, j) {
+    var hash = (Math.imul(i + 1, 2654435761) ^ Math.imul(j + 1, 1597334677)) >>> 0,
+        x = (hash & 0xffff) / 0x8000 - 1,
+        y = ((hash >>> 16) & 0xffff) / 0x8000 - 1,
+        dist = Math.sqrt(x * x + y * y);
+    return dist > 0 ? [x / dist, y / dist] : [1, 0];
+  }
+
+  function anyNodeCanMove(nodes) {
+    for (var i=0; i<nodes.length; i++) {
+      if (nodes[i].maxShift > 0) return true;
+    }
+    return false;
+  }
+
+  // Pull each node back onto the circle of radius node.maxShift around its anchor.
+  function limitDisplacement(nodes) {
+    var node, maxShift, dx, dy, distSq, k, i;
+    for (i=0; i<nodes.length; i++) {
+      node = nodes[i];
+      maxShift = node.maxShift;
+      dx = node.x - node.x0;
+      dy = node.y - node.y0;
+      distSq = dx * dx + dy * dy;
+      if (distSq <= maxShift * maxShift) continue;
+      k = maxShift / Math.sqrt(distSq);
+      node.x = node.x0 + dx * k;
+      node.y = node.y0 + dy * k;
+    }
+  }
+
+  var SymbolCollisions = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    VISIBLE_COLLISION: VISIBLE_COLLISION,
+    countSymbolCollisions: countSymbolCollisions,
+    resolveSymbolCollisions: resolveSymbolCollisions,
+    symbolCollisionDefaults: symbolCollisionDefaults
+  });
+
+  // Move symbols apart to reduce overlaps, keeping each one within a fixed pixel
+  // distance of its true position. Each symbol is laid out as the circle that
+  // covers it, so the command works on the symbol types that are drawn around
+  // their point (see getSymbolLayoutRadius()).
+  //
+  // The layout runs in the pixel space of the map that the symbols will be
+  // rendered in, so the command needs to know the display scale: either from a
+  // frame associated with the target, or from a width= option.
+  //
+  // All targeted layers are laid out in a single simulation, so symbols in
+  // different layers are moved apart from each other as well.
+  //
+  // An optional polygons= layer confines each symbol to the polygon it started
+  // in, so that a symbol standing for one area can't drift into a neighboring
+  // one. Symbols in an area too small to hold them barely move as a result, and
+  // their collisions go unresolved -- that is the point of the option, but it does
+  // mean fewer collisions get fixed.
+  //
+  // Clearance between symbols can be asked for in two ways. padding= surrounds
+  // each symbol, so a pair ends up with the sum of their two paddings between
+  // them; margin= is a gap a symbol claims from every neighbor, so a pair ends up
+  // with the greater of their two margins. Use padding= to make a symbol keep its
+  // distance in proportion to how much of it there is, and margin= to set a gap
+  // that holds however the neighbor is configured.
+  var DEFAULT_PADDING = 0; // pixels
+  var DEFAULT_MARGIN = 0; // pixels
+
+  cmd.repel = function(targetLayers, dataset, catalog, polygonSource, opts) {
+    var solverOpts = {
+      ticks: opts.ticks > 0 ? opts.ticks : symbolCollisionDefaults.ticks,
+      strength: opts.strength > 0 ? opts.strength : symbolCollisionDefaults.strength
+    };
+    var nodes = [];
+
+    // Validated before the display scale is resolved, so that an unusable target
+    // is reported as such instead of as a missing width= option.
+    requireProjectedDataset(dataset);
+    targetLayers.forEach(function(lyr) {
+      requireRepelTarget(lyr, opts);
+    });
+    var pixelsPerUnit = getDisplayScale(targetLayers, dataset, catalog, opts);
+    targetLayers.forEach(function(lyr) {
+      addLayerNodes(nodes, lyr, pixelsPerUnit, opts);
+    });
+    if (nodes.length === 0) {
+      stop$1('Targeted layer(s) contain no symbols to move.');
+    }
+    var unconstrained = addContainment(nodes, dataset, polygonSource, pixelsPerUnit, solverOpts);
+
+    var collisionsBefore = countSymbolCollisions(nodes);
+    var moved = resolveSymbolCollisions(nodes, solverOpts);
+    var collisionsAfter = countSymbolCollisions(nodes);
+    applyDisplacement(nodes, pixelsPerUnit);
+    reportResults(nodes, moved, collisionsBefore, collisionsAfter, !!polygonSource);
+    if (unconstrained > 0) {
+      message(utils.format('%d symbol%s not inside any polygon in %s, and %s left free to move',
+        unconstrained, unconstrained == 1 ? ' is' : 's are', polygonSource.layer.name || 'the polygons= layer',
+        unconstrained == 1 ? 'was' : 'were'));
+    }
+  };
+
+  // Confines symbols to the polygons they start inside. Returns the number of
+  // symbols that no polygon contains, which are left unconstrained.
+  function addContainment(nodes, dataset, polygonSource, pixelsPerUnit, solverOpts) {
+    if (!polygonSource) return 0;
+    var lyr = polygonSource.layer;
+    var arcs = polygonSource.dataset.arcs;
+    requirePolygonLayer(lyr, 'The polygons= option requires a polygon layer.');
+    // Only catches mixing projected with unprojected data; two different
+    // projections are the caller's problem, as with -join
+    requireDatasetsHaveCompatibleCRS([dataset, polygonSource.dataset]);
+    var unconstrained = assignContainingPolygons(nodes, lyr, arcs, pixelsPerUnit);
+    solverOpts.constrain = getContainmentConstraint(lyr, arcs, pixelsPerUnit);
+    return unconstrained;
+  }
+
+  // Symbols are displaced by adding an offset to their original coordinates, so
+  // that symbols that didn't move keep bit-for-bit identical coordinates.
+  // Displaced symbols get a new coordinate array rather than an updated one,
+  // because the GeoJSON importer reuses the arrays it is given and mutating them
+  // would reach back into a caller's input object.
+  function applyDisplacement(nodes, pixelsPerUnit) {
+    var movedNodes = nodes.filter(function(node) {
+      return node.x !== node.x0 || node.y !== node.y0;
+    });
+    var movedLayers = [];
+    movedNodes.forEach(function(node) {
+      if (movedLayers.indexOf(node.lyr) == -1) movedLayers.push(node.lyr);
+    });
+    movedLayers.forEach(function(lyr) {
+      noteLayerWillChange(lyr, {operation: 'repel', unit: 'shapes'});
+    });
+    movedNodes.forEach(function(node) {
+      node.shp[0] = [
+        node.shp[0][0] + (node.x - node.x0) / pixelsPerUnit,
+        node.shp[0][1] + (node.y - node.y0) / pixelsPerUnit
+      ];
+    });
+    movedLayers.forEach(function(lyr) {
+      markLayerChanged(lyr, {operation: 'repel', unit: 'shapes'});
+    });
+  }
+
+  function reportResults(nodes, moved, before, after, contained) {
+    var total = nodes.length;
+    var msg = utils.format('Moved %d of %d symbol%s', moved, total, total == 1 ? '' : 's');
+    // Counts are of visible collisions only, so a layout whose symbols end up at
+    // or a fraction of a pixel short of the separation they need is reported as
+    // finished, and the advice to raise max-shift= is not given when nothing is
+    // left to fix. A collision is not the same as an overlap: two symbols asked to
+    // keep a gap between them collide as soon as the gap closes.
+    if (after > 0) {
+      msg += utils.format('; %d of %d visible collision%s remain (%s)',
+        after, before, before == 1 ? '' : 's',
+        contained ? getMaxShiftAdvice(nodes) + ', or drop polygons=' : getMaxShiftAdvice(nodes));
+    } else if (before > 0) {
+      msg += utils.format('; resolved %d visible collision%s', before, before == 1 ? '' : 's');
+    } else {
+      msg += ' (no visible collisions found)';
+    }
+    message(msg);
+  }
+
+  // max-shift= may vary from symbol to symbol, so report the range in use.
+  function getMaxShiftAdvice(nodes) {
+    var min = Infinity, max = -Infinity;
+    nodes.forEach(function(node) {
+      if (node.maxShift < min) min = node.maxShift;
+      if (node.maxShift > max) max = node.maxShift;
+    });
+    if (min === max) {
+      return utils.format('try a larger max-shift= than %s', min);
+    }
+    return utils.format('try larger max-shift= values, now %s-%s', min, max);
+  }
+
+  function requireRepelTarget(lyr, opts) {
+    requireSinglePointLayer(lyr,
+      '-repel requires single points; layer contains multi-point features.');
+    if (!opts.radius && !layerHasSymbols(lyr)) {
+      stop$1('-repel requires a layer containing symbols ' +
+        '(see the -symbols and -style commands), or a radius= option.');
+    }
+  }
+
+  function layerHasSymbols(lyr) {
+    return !!lyr.data && (lyr.data.fieldExists('svg-symbol') || lyr.data.fieldExists('r'));
+  }
+
+  function addLayerNodes(nodes, lyr, pixelsPerUnit, opts) {
+    var getRadius = getRadiusAccessor(lyr, opts);
+    var getPadding = getPixelValueAccessor(opts.padding, 'padding', DEFAULT_PADDING, lyr);
+    var getMargin = getPixelValueAccessor(opts.margin, 'margin', DEFAULT_MARGIN, lyr, true);
+    var getMaxShift = getPixelValueAccessor(opts.max_shift, 'max-shift',
+        symbolCollisionDefaults.max_shift, lyr);
+    var i, shp, p, r;
+    for (i=0; i<lyr.shapes.length; i++) {
+      shp = lyr.shapes[i];
+      p = shp ? shp[0] : null;
+      if (!p) continue;
+      r = getRadius(i);
+      if (!(r > 0) || !isFinite(p[0]) || !isFinite(p[1])) continue;
+      nodes.push({
+        lyr: lyr,
+        shp: shp,
+        i: nodes.length,
+        x: p[0] * pixelsPerUnit,
+        y: p[1] * pixelsPerUnit,
+        x0: p[0] * pixelsPerUnit,
+        y0: p[1] * pixelsPerUnit,
+        // Padding is added to the radius, so a pair of symbols ends up with
+        // (padding a + padding b) pixels of clearance between them. A margin is
+        // kept separate, because the solver has to compare the two symbols'
+        // margins to find the gap a pair needs.
+        r: r + getPadding(i),
+        margin: getMargin(i),
+        maxShift: getMaxShift(i)
+      });
+    }
+  }
+
+  // padding=, margin= and max-shift= accept a number, a field name or an
+  // expression, and so are resolved for each symbol.
+  //
+  // @allowNegative is for margin=, where a negative value asks that a pair of
+  // symbols be allowed to overlap. Elsewhere a negative value is an error: it
+  // would shrink a radius or a shift limit, neither of which is a coherent
+  // request. A margin still has to be a finite number, so NaN is rejected either
+  // way.
+  function getPixelValueAccessor(optVal, name, defaultVal, lyr, allowNegative) {
+    if (optVal === undefined || optVal === null || optVal === '') {
+      return function(i) {return defaultVal;};
+    }
+    var accessor = getPropertyAccessor(optVal, 'number', lyr, name);
+    return function(i) {
+      var val = +accessor(i);
+      if (allowNegative ? !isFinite(val) : !(val >= 0)) {
+        stop$1(utils.format('Invalid %s= value: %s', name, accessor(i)));
+      }
+      return val;
+    };
+  }
+
+  // Radii come from one of three places: an explicit radius= option, the
+  // svg-symbol field written by -symbols, or the r field written by -style.
+  // Deliberately not using getSymbolRadius(), whose default of 5 would invent
+  // radii for symbols that don't exist.
+  function getRadiusAccessor(lyr, opts) {
+    if (opts.radius) {
+      return getSymbolPropertyAccessor(opts.radius, 'radius', lyr);
+    }
+    var records = lyr.data.getRecords();
+    return function(i) {
+      var rec = records[i];
+      if (!rec) return 0;
+      if (rec['svg-symbol']) return getSymbolLayoutRadius(rec['svg-symbol']);
+      return rec.r > 0 ? +rec.r : 0;
+    };
+  }
+
+  // A symbol is laid out as the circle that covers it, so a symbol type is
+  // supported if it is drawn around its point: a circle, or a group of parts,
+  // which is how ring, pie and donut symbols are made. A symbol drawn from its
+  // point outward, like an arrow, has no meaningful radius and needs radius=.
+  function getSymbolLayoutRadius(sym) {
+    var r;
+    if (utils.isString(sym)) {
+      try {
+        sym = JSON.parse(sym);
+      } catch(e) {
+        return 0;
+      }
+    }
+    if (!sym) return 0;
+    r = sym.type == 'circle' || sym.type == 'group' ?
+      getSymbolBoundingRadius(sym) : null;
+    if (r === null) {
+      stop$1('-repel is unable to size a ' + (sym.type || 'symbol') +
+        ' symbol; use a radius= option to give it a radius.');
+    }
+    return r;
+  }
+
+  // Returns the number of display pixels per map coordinate unit.
+  function getDisplayScale(targetLayers, dataset, catalog, opts) {
+    var frame, bounds, extent;
+    if (opts.width > 0) {
+      bounds = getCombinedBounds(targetLayers, dataset);
+      // A layer of collinear points has no width; fall back to its height so that
+      // width= still gives a usable scale.
+      extent = bounds.width() || bounds.height();
+      if (!(extent > 0)) {
+        stop$1('Unable to calculate a display scale: targeted symbols have no extent.');
+      }
+      return opts.width / extent;
+    }
+    frame = findRepelFrame(dataset, catalog);
+    if (!frame) {
+      stop$1('-repel requires a width= option when the target has no frame.');
+    }
+    warnIfFrameMismatched(frame, targetLayers, dataset);
+    return getFramePixelsPerUnit(frame);
+  }
+
+  function findRepelFrame(dataset, catalog) {
+    var lyr = findFrameLayerInDataset(dataset);
+    var target;
+    if (lyr) return getFrameLayerData(lyr, dataset.arcs);
+    // -frame adds the frame it creates to the catalog as a separate dataset, so a
+    // catalog-wide search is needed to find it (-scalebar does the same).
+    target = catalog ? findFrame(catalog) : null;
+    return target ? getFrameLayerData(target.layer, target.dataset.arcs) : null;
+  }
+
+  // Mirrors the transform applied by fitDatasetToFrame(), so that the layout
+  // matches the pixels that get rendered. A naive width / bbox width differs
+  // whenever the frame bbox and its pixel dimensions have different aspect ratios.
+  function getFramePixelsPerUnit(frameData) {
+    var bounds = new Bounds(frameData.bbox);
+    var bounds2 = frameData.bbox2 ? new Bounds(frameData.bbox2) :
+      new Bounds(0, 0, frameData.width, frameData.height);
+    bounds.fillOut(bounds2.width() / bounds2.height());
+    return bounds.getTransform(bounds2).mx;
+  }
+
+  function warnIfFrameMismatched(frame, targetLayers, dataset) {
+    var bounds = getCombinedBounds(targetLayers, dataset);
+    if (!bounds.hasBounds()) return;
+    if (!new Bounds(frame.bbox).intersects(bounds)) {
+      message('[repel] Warning: the frame does not overlap the targeted symbols. ' +
+        'If the data was projected after the frame was made, the display scale is wrong.');
+    }
+  }
+
+  function getCombinedBounds(targetLayers, dataset) {
+    return targetLayers.reduce(function(memo, lyr) {
+      var bounds = getLayerBounds(lyr, dataset.arcs);
+      return bounds ? memo.mergeBounds(bounds) : memo;
+    }, new Bounds());
+  }
+
   // Support for evaluating expressions embedded in curly-brace templates
 
   // Returns: a string (e.g. a command string used by the -run command)
@@ -77287,72 +78273,6 @@ ${svg}
     });
   }
 
-  var roundCoord$1 = getRoundingFunction(0.01);
-
-  function getSymbolFillColor(d) {
-    return d.fill || 'magenta';
-  }
-
-  function getSymbolStrokeColor(d) {
-    return d.stroke || d.fill || 'magenta';
-  }
-
-  function applySymbolStyles(sym, d) {
-    if (sym.type == 'polyline') {
-      sym.stroke = getSymbolStrokeColor(d);
-    } else {
-      sym.fill = getSymbolFillColor(d);
-    }
-    if (d.opacity) {
-      sym.opacity = d.opacity;
-    }
-    return sym;
-  }
-
-  function getSymbolRadius(d) {
-    if (d.radius === 0 || d.length === 0 || d.r === 0) return 0;
-    return d.radius || d.length || d.r || 5; // use a default value
-  }
-
-  function forEachSymbolCoord(coords, cb) {
-    var isPoint = coords && utils.isNumber(coords[0]);
-    var isNested = !isPoint && coords && Array.isArray(coords[0]);
-    if (isPoint) return cb(coords);
-    for (var i=0; i<coords.length; i++) {
-      if (isNested) forEachSymbolCoord(coords[i], cb);
-    }
-  }
-
-  function flipY(coords) {
-    forEachSymbolCoord(coords, function(p) {
-      p[1] = -p[1];
-    });
-  }
-
-  function scaleAndShiftCoords(coords, scale, shift) {
-    forEachSymbolCoord(coords, function(xy) {
-      xy[0] = xy[0] * scale + shift[0];
-      xy[1] = xy[1] * scale + shift[1];
-    });
-  }
-
-  function roundCoordsForSVG(coords) {
-    forEachSymbolCoord(coords, function(p) {
-      p[0] = roundCoord$1(p[0]);
-      p[1] = roundCoord$1(p[1]);
-    });
-  }
-
-  function rotateCoords(coords, rotation) {
-    if (!rotation) return;
-    var f = getAffineTransform(rotation, 1, [0, 0], [0, 0]);
-    forEachSymbolCoord(coords, function(p) {
-      var p2 = f(p[0], p[1]);
-      p[0] = p2[0];
-      p[1] = p2[1];
-    });
-  }
-
   function getStickArrowCoords(d) {
     return getArrowCoords(d, 'stick');
   }
@@ -77690,11 +78610,176 @@ ${svg}
   }
 
   function parseRings(arg) {
-    var arr = Array.isArray(arg) ? arg : parseNumberList(arg);
+    var arr = toNumberList(arg);
     utils.genericSort(arr, true);
     return utils.uniq(arr);
   }
 
+  // Matches the vertex density of the 72-sided circle made by getPolygonCoords()
+  var DEGREES_PER_SEGMENT = 5;
+
+  // Returns an svg-symbol object containing one polygon part per wedge, or null
+  // if the symbol has nothing to draw.
+  function makePieSymbol(d, opts) {
+    var wedges = getPieWedges(d, +opts.scale || 1);
+    if (wedges.length === 0) return null;
+    var parts = wedges.map(function(wedge) {
+      flipY(wedge.coordinates); // the SVG y-axis points down
+      roundCoordsForSVG(wedge.coordinates);
+      var part = {
+        type: 'polygon',
+        coordinates: wedge.coordinates,
+        fill: wedge.fill
+      };
+      if (d.stroke) part.stroke = d.stroke;
+      if (d['stroke-width']) part['stroke-width'] = d['stroke-width'];
+      // opacity is applied per-part, not to the group: renderComplexSymbol()
+      // assumes a group symbol has a properties object, which group() only
+      // provides for single-part groups.
+      if (d.opacity) part.opacity = d.opacity;
+      return part;
+    });
+    return {type: 'group', parts: parts};
+  }
+
+  // Returns an array of {fill, coordinates} objects, in the y-up coordinate space
+  // shared by the symbol generators, centered on [0, 0]. Coordinates are an array
+  // of rings, like flattened GeoJSON MultiPolygon coordinates.
+  //
+  // The first wedge starts at the top of the symbol and the rest follow in
+  // clockwise order. A wedge with no value, or without a usable fill color, is
+  // left out -- an unfilled wedge becomes a gap in the pie without shifting the
+  // wedges that follow it.
+  function getPieWedges(d, scale) {
+    var values = getPieValues(d);
+    var fills = getPieFills(d);
+    var radii = getPieRadii(d, scale);
+    var rotation = +d.rotation || 0;
+    var total = sum(values);
+    var wedges = [];
+    var start = rotation;
+    var fill, end;
+    if (total > 0 === false || radii.outer > 0 === false) return wedges;
+    for (var i=0; i<values.length; i++) {
+      end = start + values[i] / total * 360;
+      fill = getWedgeFill(fills[i]);
+      if (fill && end > start) {
+        wedges.push({
+          fill: fill,
+          coordinates: getWedgeCoords(start, end, radii.inner, radii.outer)
+        });
+      }
+      start = end;
+    }
+    return wedges;
+  }
+
+  // Returns an array of rings outlining a wedge spanning two bearings.
+  function getWedgeCoords(startAngle, endAngle, inner, outer) {
+    var ring;
+    if (endAngle - startAngle >= 360) {
+      // A single non-zero value covers the whole symbol: a circle, or a pair of
+      // concentric rings if the symbol is a donut.
+      ring = closeRing(getArcCoords(startAngle, startAngle + 360, outer));
+      if (inner > 0) {
+        // wind the hole in the opposite direction from the outer ring
+        return [ring, closeRing(getArcCoords(startAngle + 360, startAngle, inner))];
+      }
+      return [ring];
+    }
+    ring = getArcCoords(startAngle, endAngle, outer);
+    if (inner > 0) {
+      // A wedge of a donut is a simple polygon, so the hole needs no ring of
+      // its own -- the inner arc doubles back inside the outer one.
+      ring = ring.concat(getArcCoords(endAngle, startAngle, inner));
+    } else {
+      ring.push([0, 0]);
+    }
+    ring.push(ring[0].concat());
+    return [ring];
+  }
+
+  // A 360 degree arc starts and ends at the same angle, but rounding leaves its
+  // endpoints a hair apart, so the ring is closed explicitly.
+  function closeRing(ring) {
+    ring[ring.length - 1] = ring[0].concat();
+    return ring;
+  }
+
+  // Returns points along an arc, including both endpoints. Angles are bearings,
+  // which run clockwise from the top of the symbol -- the same convention as
+  // rotateCoords(), so the rotation= option is just an offset to the first angle.
+  function getArcCoords(startAngle, endAngle, radius) {
+    var sweep = endAngle - startAngle;
+    var segments = Math.max(1, Math.ceil(Math.abs(sweep) / DEGREES_PER_SEGMENT));
+    var coords = [];
+    for (var i=0; i<=segments; i++) {
+      coords.push(getPlanarSegmentEndpoint(0, 0, startAngle + sweep * i / segments, radius));
+    }
+    return coords;
+  }
+
+  // Missing, non-numeric and negative values all count as zero.
+  function getPieValues(d) {
+    if (!d.values) {
+      stop$1('A pie symbol requires a values= option.');
+    }
+    return toNumberList(d.values).map(function(num) {
+      return num > 0 ? num : 0;
+    });
+  }
+
+  function getPieFills(d) {
+    if (!d.fills) {
+      stop$1('A pie symbol requires a fills= option.');
+    }
+    return toItemList(d.fills);
+  }
+
+  // Returns the color to fill a wedge with, or null if the wedge should be left
+  // out of the symbol.
+  function getWedgeFill(val) {
+    var str = val === null || val === undefined ? '' : String(val).trim();
+    var name = str.toLowerCase();
+    var rgb;
+    if (!str || name == 'none' || name == 'transparent') {
+      return null;
+    }
+    rgb = parseColor(str);
+    if (!rgb || rgb.a === 0) return null;
+    return str;
+  }
+
+  // Returns {inner, outer} radii in pixels. The hole= option makes a donut. A
+  // negative hole is measured inward from the outer radius, which gives a band
+  // of wedges of a fixed width without having to repeat a data-driven radius=
+  // expression. A hole as wide as the symbol leaves a plain pie, and a
+  // non-positive outer radius is left for the caller to skip, like radius=0 on
+  // the other symbol types.
+  function getPieRadii(d, scale) {
+    var outer = getSymbolRadius(d);
+    var hole = +d.hole;
+    var inner = 0;
+    if (hole > 0) {
+      inner = hole;
+    } else if (hole < 0) {
+      inner = outer + hole;
+    }
+    if (!(inner > 0) || inner >= outer) inner = 0;
+    return {
+      inner: inner * scale,
+      outer: outer * scale
+    };
+  }
+
+  function sum(arr) {
+    var total = 0;
+    for (var i=0; i<arr.length; i++) {
+      total += arr[i];
+    }
+    return total;
+  }
+
   // Returns an svg-symbol data object for one symbol
   function makePathSymbol(coords, properties, geojsonType) {
     var sym;
@@ -77719,11 +78804,16 @@ ${svg}
 
   // TODO: refactor to remove duplication in mapshaper-svg-style.js
   cmd.symbols = function(inputLyr, dataset, opts) {
-    requireSinglePointLayer(inputLyr);
+    requirePointLayer(inputLyr);
     var lyr = opts.no_replace ? copyLayer(inputLyr) : inputLyr;
     var shapeMode = !!opts.geographic;
     var metersPerPx;
     if (shapeMode) {
+      // Only the first point of each feature is used to place a generated shape,
+      // so the other points of a multi-point feature would be dropped. In SVG
+      // mode geometry is untouched and every point gets a symbol, so multi-point
+      // features are fine.
+      requireSinglePointLayer(inputLyr);
       requireProjectedDataset(dataset);
       metersPerPx = opts.pixel_scale || getMetersPerPixel(lyr);
     }
@@ -77746,6 +78836,17 @@ ${svg}
       var d = getSymbolData(i);
       var rec = records[i] || {};
 
+      // A pie has a different fill for each of its wedges, which the single
+      // fill field of a generated shape can't express.
+      if (d.type == 'pie') {
+        if (shapeMode) {
+          stop$1('The pie symbol type does not support the geographic option.');
+        }
+        var pie = makePieSymbol(d, opts);
+        if (pie) rec['svg-symbol'] = pie;
+        return;
+      }
+
       // non-polygon symbols
       if (!shapeMode && d.type == 'circle') {
         rec['svg-symbol'] = makeCircleSymbol(d, opts);
@@ -78313,7 +79414,7 @@ ${svg}
       'filter-islands2', 'filter-points', 'filter-slivers', 'grid', 'grid2',
       'fuzzy-join', 'ignore', 'inlay', 'innerlines', 'inspect', 'join',
       'lines', 'mosaic', 'points', 'polygons', 'rectangles', 'rename-fields',
-      'shapes', 'simplify', 'slice', 'smooth', 'sort', 'split',
+      'repel', 'shapes', 'simplify', 'slice', 'smooth', 'sort', 'split',
       'split-on-grid', 'stitch', 'style', 'subdivide', 'symbols', 'uniq'
     ].indexOf(name) > -1;
   }
@@ -78673,6 +79774,10 @@ ${svg}
       } else if (name == 'rename-layers') {
         cmd.renameLayers(targetLayers, opts.names);
 
+      } else if (name == 'repel') {
+        cmd.repel(targetLayers, targetDataset, job.catalog,
+          await findRepelPolygons(opts, job.catalog, targets), opts);
+
       } else if (name == 'require') {
         await cmd.require(opts);
 
@@ -78865,6 +79970,15 @@ ${svg}
     return job;
   }
 
+  // -repel's polygons= option names a second layer, like source= elsewhere, but
+  // is resolved here rather than by the shared source= machinery: the layer is
+  // only read (never merged into the target's topology), so it needs neither a
+  // topology merge nor the per-target copies that clip and erase require.
+  async function findRepelPolygons(opts, catalog, targets) {
+    if (!opts.polygons) return null;
+    return await findCommandSourceAsync(convertSourceName(opts.polygons, targets), catalog, opts);
+  }
+
   async function resolveSourceForTargets(command, job, targets) {
     job.startCommand(command);
     try {
@@ -78970,7 +80084,7 @@ ${svg}
     return name == 'rectangle' || name == 'rectangles' || name == 'filter' && opts.cleanup;
   }
 
-  var version = "0.7.55";
+  var version = "0.7.58";
 
   // 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.
@@ -81175,6 +82289,7 @@ ${svg}
     Simplify,
     SimplifyFast,
     SimplifyPct,
+    SymbolCollisions,
     Slivers,
     Snapping,
     SourceUtils,