npm - mapshaper - Versions diffs - 0.6.102 → 0.6.104 - Mend

mapshaper 0.6.102 → 0.6.104

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/www/mapshaper.js CHANGED Viewed

@@ -2,104 +2,105 @@
   var utils = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    get addThousandsSep () { return addThousandsSep; },
+    get addslashes () { return addslashes; },
+    get arrayToIndex () { return arrayToIndex; },
+    get clamp () { return clamp; },
+    get cleanNumericString () { return cleanNumericString; },
+    get contains () { return contains; },
+    get copyElements () { return copyElements; },
+    get countValues () { return countValues; },
+    get createBuffer () { return createBuffer; },
     get default () { return utils; },
+    get defaults () { return defaults; },
+    get difference () { return difference; },
+    get endsWith () { return endsWith; },
+    get every () { return every; },
+    get expandoBuffer () { return expandoBuffer; },
+    get extend () { return extend$1; },
+    get extendBuffer () { return extendBuffer; },
+    get find () { return find; },
+    get findMedian () { return findMedian; },
+    get findQuantile () { return findQuantile; },
+    get findRankByValue () { return findRankByValue; },
+    get findStringPrefix () { return findStringPrefix; },
+    get findValueByPct () { return findValueByPct; },
+    get findValueByRank () { return findValueByRank; },
+    get forEach () { return forEach; },
+    get forEachProperty () { return forEachProperty; },
+    get format () { return format; },
+    get formatDateISO () { return formatDateISO; },
+    get formatIntlNumber () { return formatIntlNumber; },
+    get formatNumber () { return formatNumber$1; },
+    get formatNumberForDisplay () { return formatNumberForDisplay; },
+    get formatVersionedName () { return formatVersionedName; },
+    get formatter () { return formatter; },
+    get genericSort () { return genericSort; },
+    get getArrayBounds () { return getArrayBounds; },
+    get getGenericComparator () { return getGenericComparator; },
+    get getKeyComparator () { return getKeyComparator; },
+    get getSortedIds () { return getSortedIds; },
     get getUniqueName () { return getUniqueName; },
-    get isFunction () { return isFunction; },
-    get isPromise () { return isPromise; },
-    get isObject () { return isObject; },
-    get clamp () { return clamp; },
+    get groupBy () { return groupBy; },
+    get htmlEscape () { return htmlEscape; },
+    get indexOf () { return indexOf; },
+    get indexOn () { return indexOn; },
+    get inherit () { return inherit; },
+    get initializeArray () { return initializeArray; },
+    get intersection () { return intersection; },
     get isArray () { return isArray; },
-    get isNumber () { return isNumber; },
-    get isValidNumber () { return isValidNumber; },
+    get isArrayLike () { return isArrayLike; },
+    get isBoolean () { return isBoolean; },
+    get isDate () { return isDate; },
+    get isEven () { return isEven; },
     get isFiniteNumber () { return isFiniteNumber; },
-    get isNonNegNumber () { return isNonNegNumber; },
+    get isFunction () { return isFunction; },
     get isInteger () { return isInteger; },
-    get isEven () { return isEven; },
+    get isNonNegNumber () { return isNonNegNumber; },
+    get isNumber () { return isNumber; },
+    get isObject () { return isObject; },
     get isOdd () { return isOdd$1; },
+    get isPromise () { return isPromise; },
     get isString () { return isString; },
-    get isDate () { return isDate; },
-    get isBoolean () { return isBoolean; },
-    get formatDateISO () { return formatDateISO; },
-    get toArray () { return toArray; },
-    get isArrayLike () { return isArrayLike; },
-    get addslashes () { return addslashes; },
-    get regexEscape () { return regexEscape; },
-    get htmlEscape () { return htmlEscape; },
-    get defaults () { return defaults; },
-    get extend () { return extend$1; },
-    get inherit () { return inherit; },
-    get promisify () { return promisify; },
-    get reduceAsync () { return reduceAsync; },
+    get isValidNumber () { return isValidNumber; },
+    get lpad () { return lpad; },
+    get ltrim () { return ltrim; },
+    get mean () { return mean; },
     get merge () { return merge; },
-    get difference () { return difference; },
-    get intersection () { return intersection; },
-    get indexOf () { return indexOf; },
-    get contains () { return contains; },
-    get some () { return some; },
-    get every () { return every; },
-    get find () { return find; },
+    get mergeNames () { return mergeNames; },
+    get numToStr () { return numToStr; },
+    get parseIntlNumber () { return parseIntlNumber; },
+    get parseNumber () { return parseNumber; },
+    get parsePercent () { return parsePercent; },
+    get parseString () { return parseString; },
+    get pickOne () { return pickOne; },
+    get pluck () { return pluck; },
+    get pluralSuffix () { return pluralSuffix; },
+    get promisify () { return promisify; },
+    get quicksort () { return quicksort$1; },
+    get quicksortPartition () { return quicksortPartition; },
     get range () { return range; },
+    get reduceAsync () { return reduceAsync; },
+    get regexEscape () { return regexEscape; },
+    get reorderArray () { return reorderArray; },
     get repeat () { return repeat; },
-    get sum () { return sum$1; },
-    get getArrayBounds () { return getArrayBounds; },
-    get uniq () { return uniq; },
-    get pluck () { return pluck; },
-    get countValues () { return countValues; },
-    get indexOn () { return indexOn; },
-    get groupBy () { return groupBy; },
-    get arrayToIndex () { return arrayToIndex; },
-    get forEach () { return forEach; },
-    get forEachProperty () { return forEachProperty; },
-    get initializeArray () { return initializeArray; },
-    get replaceArray () { return replaceArray; },
     get repeatString () { return repeatString; },
-    get splitLines () { return splitLines; },
-    get pluralSuffix () { return pluralSuffix; },
-    get endsWith () { return endsWith; },
-    get lpad () { return lpad; },
+    get replaceArray () { return replaceArray; },
     get rpad () { return rpad; },
-    get trim () { return trim; },
-    get ltrim () { return ltrim; },
     get rtrim () { return rtrim; },
-    get addThousandsSep () { return addThousandsSep; },
-    get numToStr () { return numToStr; },
-    get formatNumber () { return formatNumber$1; },
-    get formatIntlNumber () { return formatIntlNumber; },
-    get formatNumberForDisplay () { return formatNumberForDisplay; },
     get shuffle () { return shuffle; },
-    get sortOn () { return sortOn; },
-    get genericSort () { return genericSort; },
-    get getSortedIds () { return getSortedIds; },
+    get some () { return some; },
     get sortArrayIndex () { return sortArrayIndex; },
-    get reorderArray () { return reorderArray; },
-    get getKeyComparator () { return getKeyComparator; },
-    get getGenericComparator () { return getGenericComparator; },
-    get quicksort () { return quicksort$1; },
-    get quicksortPartition () { return quicksortPartition; },
-    get findRankByValue () { return findRankByValue; },
-    get findValueByPct () { return findValueByPct; },
-    get findValueByRank () { return findValueByRank; },
-    get findMedian () { return findMedian; },
-    get findQuantile () { return findQuantile; },
-    get mean () { return mean; },
-    get format () { return format; },
-    get formatter () { return formatter; },
-    get wildcardToRegExp () { return wildcardToRegExp; },
-    get createBuffer () { return createBuffer; },
+    get sortOn () { return sortOn; },
+    get splitLines () { return splitLines; },
+    get sum () { return sum$1; },
+    get toArray () { return toArray; },
     get toBuffer () { return toBuffer; },
-    get expandoBuffer () { return expandoBuffer; },
-    get copyElements () { return copyElements; },
-    get extendBuffer () { return extendBuffer; },
-    get mergeNames () { return mergeNames; },
-    get findStringPrefix () { return findStringPrefix; },
-    get parsePercent () { return parsePercent; },
-    get formatVersionedName () { return formatVersionedName; },
+    get trim () { return trim; },
+    get trimQuotes () { return trimQuotes; },
+    get uniq () { return uniq; },
     get uniqifyNames () { return uniqifyNames; },
-    get parseString () { return parseString; },
-    get parseNumber () { return parseNumber; },
-    get parseIntlNumber () { return parseIntlNumber; },
-    get cleanNumericString () { return cleanNumericString; },
-    get trimQuotes () { return trimQuotes; }
+    get wildcardToRegExp () { return wildcardToRegExp; }
   });
   // This module provides a way for multiple jobs to run together asynchronously
@@ -128,13 +129,29 @@
   var Stash = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    stashVar: stashVar,
+    clearStash: clearStash,
     getStashedVar: getStashedVar,
-    clearStash: clearStash
+    stashVar: stashVar
   });
+  // Several dependencies are loaded via require()
+  var f;
+  if (typeof require == 'function') {
+    // Node.js context: native require() function
+    f = require;
+  } else if (typeof window == 'object' && window.modules) {
+    // running in web GUI
+    f = function(name) {
+      return window.modules[name];
+    };
+  } else {
+    // stub to avoid runtime error in a handful of tests
+    f = function() {};
+  }
+  var require$1 = f;
   // Fall back to browserify's Buffer polyfill
-  var B$3 = typeof Buffer != 'undefined' ? Buffer : require('buffer').Buffer;
+  var B$3 = typeof Buffer != 'undefined' ? Buffer : require$1('buffer').Buffer;
   var uniqCount = 0;
   function getUniqueName(prefix) {
@@ -684,6 +701,10 @@
     }
   }
+  function pickOne(arr) {
+    return arr[Math.floor(Math.random() * arr.length)];
+  }
   // Sort an array of objects based on one or more properties.
   // Usage: sortOn(array, key1, asc?[, key2, asc? ...])
   //
@@ -1295,7 +1316,6 @@
     if (parts.length > 1 || true) {
       return '\nError details:\n' + parts[0];
     }
-    return '';
   }
   // print a message to stdout
@@ -1418,28 +1438,28 @@
   var Logging = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    getLoggingSetter: getLoggingSetter,
-    setLoggingForCLI: setLoggingForCLI,
+    NonFatalError: NonFatalError,
+    UserError: UserError,
+    debug: debug,
     enableLogging: enableLogging,
-    loggingEnabled: loggingEnabled,
     error: error,
-    stop: stop,
+    formatColumns: formatColumns,
+    formatLogArgs: formatLogArgs,
+    formatStringsAsGrid: formatStringsAsGrid,
+    getErrorDetail: getErrorDetail,
+    getLoggingSetter: getLoggingSetter,
     interrupt: interrupt,
+    logArgs: logArgs,
+    loggingEnabled: loggingEnabled,
     message: message,
-    warn: warn,
-    setLoggingFunctions: setLoggingFunctions,
-    getErrorDetail: getErrorDetail,
     print: print,
-    verbose: verbose,
-    debug: debug,
     printError: printError,
-    UserError: UserError,
-    NonFatalError: NonFatalError,
-    formatColumns: formatColumns,
-    formatStringsAsGrid: formatStringsAsGrid,
-    formatLogArgs: formatLogArgs,
-    logArgs: logArgs,
-    truncateString: truncateString
+    setLoggingForCLI: setLoggingForCLI,
+    setLoggingFunctions: setLoggingFunctions,
+    stop: stop,
+    truncateString: truncateString,
+    verbose: verbose,
+    warn: warn
   });
   function Transform() {
@@ -1756,12 +1776,29 @@
     return count;
   }
+  // export function getPointBounds(shapes) {
+  //   var bounds = new Bounds();
+  //   forEachPoint(shapes, function(p) {
+  //     bounds.mergePoint(p[0], p[1]);
+  //   });
+  //   return bounds;
+  // }
   function getPointBounds$1(shapes) {
-    var bounds = new Bounds();
-    forEachPoint(shapes, function(p) {
-      bounds.mergePoint(p[0], p[1]);
-    });
-    return bounds;
+    new Bounds();
+    var shp, x, y, xmin = Infinity, ymin = Infinity, xmax = -Infinity, ymax = -Infinity;
+    for (var i=0, n=shapes.length; i<n; i++) {
+      shp = shapes[i];
+      for (var j=0, m=shp ? shp.length : 0; j<m; j++) {
+        x = shp[j][0];
+        y = shp[j][1];
+        if (x > xmax) xmax = x;
+        if (x < xmin) xmin = x;
+        if (y > ymax) ymax = y;
+        if (y < ymin) ymin = y;
+      }
+    }
+    return shp ? new Bounds(xmin, ymin, xmax, ymax) : new Bounds();
   }
   function getPointFeatureBounds(shape, bounds) {
@@ -1799,10 +1836,10 @@
   var PointUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
     countPointsInLayer: countPointsInLayer,
+    forEachPoint: forEachPoint,
     getPointBounds: getPointBounds$1,
     getPointFeatureBounds: getPointFeatureBounds,
-    getPointsInLayer: getPointsInLayer,
-    forEachPoint: forEachPoint
+    getPointsInLayer: getPointsInLayer
   });
   function absArcId(arcId) {
@@ -2022,26 +2059,22 @@
   var ArcUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
     absArcId: absArcId,
-    calcArcBounds: calcArcBounds,
-    getUnfilteredArcLength: getUnfilteredArcLength,
-    getUnfilteredArcCoords: getUnfilteredArcCoords,
-    findArcIdFromVertexId: findArcIdFromVertexId,
-    deleteLastArc: deleteLastArc,
-    deleteVertex: deleteVertex,
     appendEmptyArc: appendEmptyArc,
     appendVertex: appendVertex,
-    insertVertex: insertVertex,
+    calcArcBounds: calcArcBounds,
     countFilteredVertices: countFilteredVertices,
-    filterVertexData: filterVertexData
+    deleteLastArc: deleteLastArc,
+    deleteVertex: deleteVertex,
+    filterVertexData: filterVertexData,
+    findArcIdFromVertexId: findArcIdFromVertexId,
+    getUnfilteredArcCoords: getUnfilteredArcCoords,
+    getUnfilteredArcLength: getUnfilteredArcLength,
+    insertVertex: insertVertex
   });
   var WGS84 = {
     // https://en.wikipedia.org/wiki/Earth_radius
-    SEMIMAJOR_AXIS: 6378137,
-    SEMIMINOR_AXIS: 6356752.3142,
-    AUTHALIC_RADIUS: 6371007.2,
-    VOLUMETRIC_RADIUS: 6371000.8
-  };
+    SEMIMAJOR_AXIS: 6378137};
   // TODO: remove this constant, use actual data from dataset CRS,
   // also consider using ellipsoidal formulas where greater accuracy might be important.
@@ -2390,35 +2423,35 @@
   var Geom = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    R: R$1,
     D2R: D2R,
+    R: R$1,
     R2D: R2D,
+    bearing: bearing,
+    bearing2D: bearing2D,
+    containsBounds: containsBounds,
+    convLngLatToSph: convLngLatToSph,
+    cosine: cosine,
+    cosine3D: cosine3D,
     degreesToMeters: degreesToMeters,
+    distance2D: distance2D,
     distance3D: distance3D,
     distanceSq: distanceSq,
-    distance2D: distance2D,
     distanceSq3D: distanceSq3D,
+    greatCircleDistance: greatCircleDistance,
+    innerAngle: innerAngle,
     innerAngle2: innerAngle2,
-    standardAngle: standardAngle,
+    innerAngle3D: innerAngle3D,
+    lngLatToXYZ: lngLatToXYZ,
+    pointSegDistSq: pointSegDistSq,
+    pointSegDistSq2: pointSegDistSq2,
+    pointSegDistSq3D: pointSegDistSq3D,
     signedAngle: signedAngle,
-    bearing2D: bearing2D,
-    bearing: bearing,
     signedAngleSph: signedAngleSph,
-    convLngLatToSph: convLngLatToSph,
-    xyzToLngLat: xyzToLngLat,
-    lngLatToXYZ: lngLatToXYZ,
     sphericalDistance: sphericalDistance,
-    greatCircleDistance: greatCircleDistance,
-    innerAngle: innerAngle,
-    innerAngle3D: innerAngle3D,
+    standardAngle: standardAngle,
     triangleArea: triangleArea,
-    cosine: cosine,
-    cosine3D: cosine3D,
     triangleArea3D: triangleArea3D,
-    pointSegDistSq: pointSegDistSq,
-    pointSegDistSq3D: pointSegDistSq3D,
-    pointSegDistSq2: pointSegDistSq2,
-    containsBounds: containsBounds
+    xyzToLngLat: xyzToLngLat
   });
   function pathIsClosed(ids, arcs) {
@@ -2564,16 +2597,16 @@
   var PathGeom = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    pathIsClosed: pathIsClosed,
+    get calcPathLen () { return calcPathLen; },
+    countVerticesInPath: countVerticesInPath,
+    getAvgPathXY: getAvgPathXY,
+    getMaxPath: getMaxPath,
+    getPathBounds: getPathBounds$1,
     getPointToPathDistance: getPointToPathDistance,
     getPointToPathInfo: getPointToPathInfo,
     getPointToShapeDistance: getPointToShapeDistance,
     getPointToShapeInfo: getPointToShapeInfo,
-    getAvgPathXY: getAvgPathXY,
-    getMaxPath: getMaxPath,
-    countVerticesInPath: countVerticesInPath,
-    getPathBounds: getPathBounds$1,
-    get calcPathLen () { return calcPathLen; }
+    pathIsClosed: pathIsClosed
   });
   // Get the centroid of the largest ring of a polygon
@@ -2617,8 +2650,8 @@
   var PolygonCentroid = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    getShapeCentroid: getShapeCentroid,
-    getPathCentroid: getPathCentroid
+    getPathCentroid: getPathCentroid,
+    getShapeCentroid: getShapeCentroid
   });
   function testSegmentBoundsIntersection(a, b, bb) {
@@ -2900,25 +2933,25 @@
     __proto__: null,
     calcPolsbyPopperCompactness: calcPolsbyPopperCompactness,
     calcSchwartzbergCompactness: calcSchwartzbergCompactness,
+    getPathArea: getPathArea,
+    getPathPerimeter: getPathPerimeter,
     getPathWinding: getPathWinding,
-    getShapeArea: getShapeArea,
+    getPlanarPathArea: getPlanarPathArea,
+    getPlanarPathArea2: getPlanarPathArea2,
+    getPlanarPathPerimeter: getPlanarPathPerimeter,
     getPlanarShapeArea: getPlanarShapeArea,
-    getSphericalShapeArea: getSphericalShapeArea,
-    testBoundsInPolygon: testBoundsInPolygon,
-    testPointInPolygon: testPointInPolygon,
-    testPointInRing: testPointInRing,
-    testRayIntersection: testRayIntersection,
     getRayIntersection: getRayIntersection,
-    getPathArea: getPathArea,
+    getShapeArea: getShapeArea,
+    getShapePerimeter: getShapePerimeter,
     getSphericalPathArea: getSphericalPathArea,
     getSphericalPathArea2: getSphericalPathArea2,
-    getPlanarPathArea2: getPlanarPathArea2,
-    getPlanarPathArea: getPlanarPathArea,
-    getPathPerimeter: getPathPerimeter,
-    getShapePerimeter: getShapePerimeter,
+    getSphericalPathPerimeter: getSphericalPathPerimeter,
+    getSphericalShapeArea: getSphericalShapeArea,
     getSphericalShapePerimeter: getSphericalShapePerimeter,
-    getPlanarPathPerimeter: getPlanarPathPerimeter,
-    getSphericalPathPerimeter: getSphericalPathPerimeter
+    testBoundsInPolygon: testBoundsInPolygon,
+    testPointInPolygon: testPointInPolygon,
+    testPointInRing: testPointInRing,
+    testRayIntersection: testRayIntersection
   });
   // Returns an interval for snapping together coordinates that be co-incident bug
@@ -3112,12 +3145,12 @@
   var Snapping = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    getCoordinateIds: getCoordinateIds,
+    getEndpointIds: getEndpointIds,
     getHighPrecisionSnapInterval: getHighPrecisionSnapInterval,
     snapCoords: snapCoords,
     snapCoordsByInterval: snapCoordsByInterval,
-    snapEndpointsByInterval: snapEndpointsByInterval,
-    getCoordinateIds: getCoordinateIds,
-    getEndpointIds: getEndpointIds
+    snapEndpointsByInterval: snapEndpointsByInterval
   });
   // Find the intersection between two 2D segments
@@ -3346,10 +3379,10 @@
   var SegmentGeom = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    segmentIntersection: segmentIntersection,
     findClosestPointOnSeg: findClosestPointOnSeg,
     orient2D: orient2D,
     segmentHit: segmentHit,
+    segmentIntersection: segmentIntersection,
     segmentTurn: segmentTurn
   });
@@ -3616,23 +3649,23 @@
   var PathUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    getAvgSegment: getAvgSegment,
-    getAvgSegment2: getAvgSegment2,
-    getDirectedArcPresenceTest: getDirectedArcPresenceTest,
-    getArcPresenceTest: getArcPresenceTest,
-    countArcsInShapes: countArcsInShapes,
-    getPathBounds: getPathBounds,
-    findShapesByArcId: findShapesByArcId,
-    reversePath: reversePath,
     clampIntervalByPct: clampIntervalByPct,
+    countArcsInShapes: countArcsInShapes,
+    filterEmptyArcs: filterEmptyArcs,
     findNextRemovableVertex: findNextRemovableVertex,
+    findShapesByArcId: findShapesByArcId,
     forEachArcId: forEachArcId,
-    forEachSegmentInShape: forEachSegmentInShape,
     forEachSegmentInPath: forEachSegmentInPath,
-    traversePaths: traversePaths,
-    filterEmptyArcs: filterEmptyArcs,
+    forEachSegmentInShape: forEachSegmentInShape,
+    getArcPresenceTest: getArcPresenceTest,
+    getAvgSegment: getAvgSegment,
+    getAvgSegment2: getAvgSegment2,
+    getDirectedArcPresenceTest: getDirectedArcPresenceTest,
+    getPathBounds: getPathBounds,
     getPathMetadata: getPathMetadata,
-    quantizeArcs: quantizeArcs
+    quantizeArcs: quantizeArcs,
+    reversePath: reversePath,
+    traversePaths: traversePaths
   });
   // Utility functions for both paths and points
@@ -3709,26 +3742,12 @@
     __proto__: null,
     cloneShape: cloneShape,
     cloneShapes: cloneShapes,
-    forEachShapePart: forEachShapePart,
-    editShapes: editShapes,
     editShapeParts: editShapeParts,
-    findMaxPartCount: findMaxPartCount
+    editShapes: editShapes,
+    findMaxPartCount: findMaxPartCount,
+    forEachShapePart: forEachShapePart
   });
-  // Several dependencies are loaded via require() ... this module returns a
-  // stub function when require() does not exist as a global function,
-  // to avoid runtime errors (this should only happen in some tests when single
-  // modules are imported)
-  var f;
-  if (typeof require == 'function') {
-    f = require;
-  } else {
-    f = function() {
-      // console.error('Unable to load module', name);
-    };
-  }
-  var require$1 = f;
   var iconv = require$1('iconv-lite');
   // import iconv from 'iconv-lite';
@@ -3873,19 +3892,19 @@
   var Encodings = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    getEncodings: getEncodings,
-    validateEncoding: validateEncoding,
-    stringsAreAscii: stringsAreAscii,
-    stringIsAscii: stringIsAscii,
-    encodingIsUtf8: encodingIsUtf8,
-    encodingIsAsciiCompat: encodingIsAsciiCompat,
-    standardizeEncodingName: standardizeEncodingName,
     bufferToString: bufferToString,
-    encodeString: encodeString,
     decodeString: decodeString,
+    encodeString: encodeString,
+    encodingIsAsciiCompat: encodingIsAsciiCompat,
     encodingIsSupported: encodingIsSupported,
+    encodingIsUtf8: encodingIsUtf8,
+    getEncodings: getEncodings,
+    printEncodings: printEncodings,
+    standardizeEncodingName: standardizeEncodingName,
+    stringIsAscii: stringIsAscii,
+    stringsAreAscii: stringsAreAscii,
     trimBOM: trimBOM,
-    printEncodings: printEncodings
+    validateEncoding: validateEncoding
   });
   // Not a general-purpose deep copy function
@@ -4129,21 +4148,21 @@
   var DataUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    applyFieldOrder: applyFieldOrder,
     copyRecord: copyRecord,
-    getValueType: getValueType,
-    fixInconsistentFields: fixInconsistentFields,
+    deleteFields: deleteFields,
     fieldListContainsAll: fieldListContainsAll,
+    findFieldNames: findFieldNames,
+    fixInconsistentFields: fixInconsistentFields,
     getColumnType: getColumnType,
-    deleteFields: deleteFields,
-    isInvalidFieldName: isInvalidFieldName,
-    getUniqFieldNames: getUniqFieldNames,
     getFieldValues: getFieldValues,
-    getUniqFieldValues: getUniqFieldValues,
-    applyFieldOrder: applyFieldOrder,
     getFirstNonEmptyRecord: getFirstNonEmptyRecord,
-    findFieldNames: findFieldNames,
-    parseUnknownType: parseUnknownType,
-    getInputParser: getInputParser
+    getInputParser: getInputParser,
+    getUniqFieldNames: getUniqFieldNames,
+    getUniqFieldValues: getUniqFieldValues,
+    getValueType: getValueType,
+    isInvalidFieldName: isInvalidFieldName,
+    parseUnknownType: parseUnknownType
   });
   function DataTable(obj) {
@@ -4265,8 +4284,8 @@
   var RectangleUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    pathIsRectangle: pathIsRectangle,
-    bboxToCoords: bboxToCoords
+    bboxToCoords: bboxToCoords,
+    pathIsRectangle: pathIsRectangle
   });
   // Insert a column of values into a (new or existing) data field
@@ -4567,42 +4586,42 @@
   var LayerUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    insertFieldValues: insertFieldValues,
+    copyLayer: copyLayer,
+    copyLayerShapes: copyLayerShapes,
+    countArcsInLayers: countArcsInLayers,
+    countMultiPartFeatures: countMultiPartFeatures,
+    deleteFeatureById: deleteFeatureById,
+    divideFeaturesByType: divideFeaturesByType,
+    filterPathLayerByArcIds: filterPathLayerByArcIds,
+    getArcPresenceTest2: getArcPresenceTest2,
+    getFeatureCount: getFeatureCount,
+    getLayerBounds: getLayerBounds,
     getLayerDataTable: getLayerDataTable,
+    getLayerSourceFile: getLayerSourceFile,
+    getOutputLayer: getOutputLayer,
+    initDataTable: initDataTable,
+    insertFieldValues: insertFieldValues,
+    isolateLayer: isolateLayer,
     layerHasAttributeData: layerHasAttributeData,
-    layerHasNonNullData: layerHasNonNullData,
     layerHasGeometry: layerHasGeometry,
-    layerIsGeometric: layerIsGeometric,
+    layerHasNonNullData: layerHasNonNullData,
+    layerHasNonNullShapes: layerHasNonNullShapes,
     layerHasPaths: layerHasPaths,
     layerHasPoints: layerHasPoints,
+    layerIsEmpty: layerIsEmpty,
+    layerIsGeometric: layerIsGeometric,
     layerIsRectangle: layerIsRectangle,
     layerOnlyHasRectangles: layerOnlyHasRectangles,
-    layerHasNonNullShapes: layerHasNonNullShapes,
-    deleteFeatureById: deleteFeatureById,
-    transformPointsInLayer: transformPointsInLayer,
-    getFeatureCount: getFeatureCount,
-    layerIsEmpty: layerIsEmpty,
+    layerTypeMessage: layerTypeMessage,
     requireDataField: requireDataField,
     requireDataFields: requireDataFields,
-    layerTypeMessage: layerTypeMessage,
+    requirePathLayer: requirePathLayer,
     requirePointLayer: requirePointLayer,
-    requireSinglePointLayer: requireSinglePointLayer,
-    requirePolylineLayer: requirePolylineLayer,
     requirePolygonLayer: requirePolygonLayer,
-    requirePathLayer: requirePathLayer,
-    getLayerSourceFile: getLayerSourceFile,
-    divideFeaturesByType: divideFeaturesByType,
-    getOutputLayer: getOutputLayer,
+    requirePolylineLayer: requirePolylineLayer,
+    requireSinglePointLayer: requireSinglePointLayer,
     setOutputLayerName: setOutputLayerName,
-    copyLayer: copyLayer,
-    filterPathLayerByArcIds: filterPathLayerByArcIds,
-    copyLayerShapes: copyLayerShapes,
-    countMultiPartFeatures: countMultiPartFeatures,
-    getArcPresenceTest2: getArcPresenceTest2,
-    countArcsInLayers: countArcsInLayers,
-    getLayerBounds: getLayerBounds,
-    isolateLayer: isolateLayer,
-    initDataTable: initDataTable
+    transformPointsInLayer: transformPointsInLayer
   });
   // A matrix class that supports affine transformations (scaling, translation, rotation).
@@ -4819,7 +4838,7 @@
     var AK = {
       name: 'AK',
       proj: '+proj=aea +lat_1=55 +lat_2=70 +lat_0=65 +lon_0=-148 +x_0=0 +y_0=0',
-      bbox: [-172.26,50.89,-127.00,73.21],
+      bbox: [-172.26,50.89,-127,73.21],
       origin: [-152, 63],
       placement: [-1882782,-969242],
       scale: 0.37
@@ -4827,7 +4846,7 @@
     var HI = {
       name: 'HI',
       proj: '+proj=aea +lat_1=19 +lat_2=24 +lat_0=20.9 +lon_0=-156.5 +x_0=0 +y_0=0',
-      bbox: [-160.50,18.72,-154.57,22.58],
+      bbox: [-160.5,18.72,-154.57,22.58],
       origin: [-157, 21],
       placement: [-1050326,-1055362]
     };
@@ -4904,9 +4923,9 @@
   var CustomProjections = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    parseCustomProjection: parseCustomProjection,
     AlbersUSA: AlbersUSA,
-    parseCustomParams: parseCustomParams
+    parseCustomParams: parseCustomParams,
+    parseCustomProjection: parseCustomProjection
   });
   function getWorldBounds(e) {
@@ -4934,10 +4953,10 @@
   var LatLon = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    getWorldBounds: getWorldBounds,
-    probablyDecimalDegreeBounds: probablyDecimalDegreeBounds,
     clampToWorldBounds: clampToWorldBounds,
-    getAntimeridian: getAntimeridian
+    getAntimeridian: getAntimeridian,
+    getWorldBounds: getWorldBounds,
+    probablyDecimalDegreeBounds: probablyDecimalDegreeBounds
   });
   var mproj = require$1('mproj');
@@ -5252,37 +5271,37 @@
   var Projections = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    initProjLibrary: initProjLibrary,
-    setProjectionLoader: setProjectionLoader,
-    findProjLibs: findProjLibs,
-    getProjTransform: getProjTransform,
-    getProjTransform2: getProjTransform2,
-    toLngLat: toLngLat,
-    projectPoint: projectPoint,
-    getProjInfo: getProjInfo,
-    crsToProj4: crsToProj4,
-    crsToPrj: crsToPrj,
     crsAreEqual: crsAreEqual,
-    isProjAlias: isProjAlias,
-    getProjDefn: getProjDefn,
-    looksLikeProj4String: looksLikeProj4String,
+    crsToPrj: crsToPrj,
+    crsToProj4: crsToProj4,
+    findProjLibs: findProjLibs,
     getCrsInfo: getCrsInfo,
-    parseCrsString: parseCrsString,
-    requireProjectedDataset: requireProjectedDataset,
-    setDatasetCrsInfo: setDatasetCrsInfo,
-    getDatasetCrsInfo: getDatasetCrsInfo,
     getDatasetCRS: getDatasetCRS,
-    requireDatasetsHaveCompatibleCRS: requireDatasetsHaveCompatibleCRS,
+    getDatasetCrsInfo: getDatasetCrsInfo,
+    getProjDefn: getProjDefn,
+    getProjInfo: getProjInfo,
+    getProjTransform: getProjTransform,
+    getProjTransform2: getProjTransform2,
     getScaleFactorAtXY: getScaleFactorAtXY,
-    isProjectedCRS: isProjectedCRS,
+    initProjLibrary: initProjLibrary,
     isInvertibleCRS: isInvertibleCRS,
     isLatLngCRS: isLatLngCRS,
+    isLatLngDataset: isLatLngDataset,
+    isProjAlias: isProjAlias,
+    isProjectedCRS: isProjectedCRS,
     isWGS84: isWGS84,
     isWebMercator: isWebMercator,
-    isLatLngDataset: isLatLngDataset,
+    looksLikeProj4String: looksLikeProj4String,
+    parseCrsString: parseCrsString,
+    parsePrj: parsePrj,
     printProjections: printProjections,
-    translatePrj: translatePrj,
-    parsePrj: parsePrj
+    projectPoint: projectPoint,
+    requireDatasetsHaveCompatibleCRS: requireDatasetsHaveCompatibleCRS,
+    requireProjectedDataset: requireProjectedDataset,
+    setDatasetCrsInfo: setDatasetCrsInfo,
+    setProjectionLoader: setProjectionLoader,
+    toLngLat: toLngLat,
+    translatePrj: translatePrj
   });
   // Coordinate iterators
@@ -5396,7 +5415,6 @@
   }
   function MultiShapeIter(arcs) {
-    new ShapeIter(arcs);
   }
@@ -5449,10 +5467,10 @@
   var ShapeIter$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    PointIter: PointIter,
     ArcIter: ArcIter,
     FilteredArcIter: FilteredArcIter,
     MultiShapeIter: MultiShapeIter,
+    PointIter: PointIter,
     ShapeIter: ShapeIter
   });
@@ -5501,8 +5519,8 @@
   var SimplifyPct = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    getThresholdFunction: getThresholdFunction,
-    getThresholdByPct: getThresholdByPct
+    getThresholdByPct: getThresholdByPct,
+    getThresholdFunction: getThresholdFunction
   });
   // An interface for managing a collection of paths.
@@ -6546,8 +6564,8 @@
   var Topology = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    buildTopology: buildTopology,
-    buildPathTopology: buildPathTopology
+    buildPathTopology: buildPathTopology,
+    buildTopology: buildTopology
   });
   // Merge arcs from one or more source datasets into target dataset
@@ -6691,12 +6709,12 @@
   var Merging = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    mergeDatasetsIntoDataset: mergeDatasetsIntoDataset,
-    mergeDatasetsForExport: mergeDatasetsForExport,
+    mergeArcs: mergeArcs,
     mergeCommandTargets: mergeCommandTargets,
-    mergeDatasets: mergeDatasets,
     mergeDatasetInfo: mergeDatasetInfo$1,
-    mergeArcs: mergeArcs
+    mergeDatasets: mergeDatasets,
+    mergeDatasetsForExport: mergeDatasetsForExport,
+    mergeDatasetsIntoDataset: mergeDatasetsIntoDataset
   });
   // Test if the second endpoint of an arc is the endpoint of any path in any layer
@@ -7345,22 +7363,22 @@
   var DatasetUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    splitDataset: splitDataset,
-    mergeDatasetInfo: mergeDatasetInfo,
-    copyDatasetInfo: copyDatasetInfo,
-    splitApartLayers: splitApartLayers,
+    cleanupArcs: cleanupArcs,
     copyDataset: copyDataset,
     copyDatasetForExport: copyDatasetForExport,
     copyDatasetForRenaming: copyDatasetForRenaming,
-    getDatasetBounds: getDatasetBounds,
-    datasetIsEmpty: datasetIsEmpty,
+    copyDatasetInfo: copyDatasetInfo,
     datasetHasGeometry: datasetHasGeometry,
     datasetHasPaths: datasetHasPaths,
-    cleanupArcs: cleanupArcs,
+    datasetIsEmpty: datasetIsEmpty,
+    getDatasetBounds: getDatasetBounds,
+    mergeDatasetInfo: mergeDatasetInfo,
+    mergeOutputLayerIntoDataset: mergeOutputLayerIntoDataset,
     pruneArcs: pruneArcs,
-    replaceLayers: replaceLayers,
     replaceLayerContents: replaceLayerContents,
-    mergeOutputLayerIntoDataset: mergeOutputLayerIntoDataset,
+    replaceLayers: replaceLayers,
+    splitApartLayers: splitApartLayers,
+    splitDataset: splitDataset,
     transformPoints: transformPoints
   });
@@ -7440,14 +7458,14 @@
   var FilenameUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    parseLocalPath: parseLocalPath,
+    getCommonFileBase: getCommonFileBase,
     getFileBase: getFileBase,
     getFileExtension: getFileExtension,
+    getOutputFileBase: getOutputFileBase,
     getPathBase: getPathBase,
+    parseLocalPath: parseLocalPath,
     replaceFileExtension: replaceFileExtension,
-    toLowerCaseExtension: toLowerCaseExtension,
-    getCommonFileBase: getCommonFileBase,
-    getOutputFileBase: getOutputFileBase
+    toLowerCaseExtension: toLowerCaseExtension
   });
   var decoder;
@@ -7627,13 +7645,7 @@
   				currentStructures.length = sharedLength;
   		}
   		let result;
-  		if (currentUnpackr.randomAccessStructure && src[position$1] < 0x40 && src[position$1] >= 0x20 && readStruct) {
-  			result = readStruct(src, position$1, srcEnd, currentUnpackr);
-  			src = null; // dispose of this so that recursive unpack calls don't save state
-  			if (!(options && options.lazy) && result)
-  				result = result.toJSON();
-  			position$1 = srcEnd;
-  		} else
+  		if (currentUnpackr.randomAccessStructure && src[position$1] < 0x40 && src[position$1] >= 0x20 && readStruct) ; else
   			result = read();
   		if (bundledStrings$1) { // bundled strings to skip past
   			position$1 = bundledStrings$1.postBundlePosition;
@@ -8475,7 +8487,7 @@
   	else if (data.length == 12)// TODO: Implement support for negative
   		return new Date(
   			((data[0] << 24) + (data[1] << 16) + (data[2] << 8) + data[3]) / 1000000 +
-  			(((data[4] & 0x80) ? -0x1000000000000 : 0) + data[6] * 0x10000000000 + data[7] * 0x100000000 + data[8] * 0x1000000 + (data[9] << 16) + (data[10] << 8) + data[11]) * 1000)
+  			(((data[4] & 0x80) ? -281474976710656 : 0) + data[6] * 0x10000000000 + data[7] * 0x100000000 + data[8] * 0x1000000 + (data[9] << 16) + (data[10] << 8) + data[11]) * 1000)
   	else
   		return new Date('invalid')
   }; // notepack defines extension 0 to mean undefined, so use that as the default here
@@ -8892,12 +8904,12 @@
   						position += 4;
   					}
   				} else if (value >> 0 === value) { // negative integer
-  					if (value >= -0x20) {
+  					if (value >= -32) {
   						target[position++] = 0x100 + value;
-  					} else if (value >= -0x80) {
+  					} else if (value >= -128) {
   						target[position++] = 0xd0;
   						target[position++] = value + 0x100;
-  					} else if (value >= -0x8000) {
+  					} else if (value >= -32768) {
   						target[position++] = 0xd1;
   						targetView.setInt16(position, value);
   						position += 2;
@@ -8908,7 +8920,7 @@
   					}
   				} else {
   					let useFloat32;
-  					if ((useFloat32 = this.useFloat32) > 0 && value < 0x100000000 && value >= -0x80000000) {
+  					if ((useFloat32 = this.useFloat32) > 0 && value < 0x100000000 && value >= -2147483648) {
   						target[position++] = 0xca;
   						targetView.setFloat32(position, value);
   						let xShifted;
@@ -9615,11 +9627,10 @@
   });
   // aliases for shorter compressed code (most minifers don't do this)
-  var u8 = Uint8Array, u16 = Uint16Array, u32 = Uint32Array;
+  var u8 = Uint8Array, u16 = Uint16Array, i32 = Int32Array;
   // fixed length extra bits
   var fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, /* unused */ 0, 0, /* impossible */ 0]);
   // fixed distance extra bits
-  // see fleb note
   var fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, /* unused */ 0, 0]);
   // code length index map
   var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
@@ -9630,26 +9641,26 @@
           b[i] = start += 1 << eb[i - 1];
       }
       // numbers here are at max 18 bits
-      var r = new u32(b[30]);
+      var r = new i32(b[30]);
       for (var i = 1; i < 30; ++i) {
           for (var j = b[i]; j < b[i + 1]; ++j) {
               r[j] = ((j - b[i]) << 5) | i;
           }
       }
-      return [b, r];
+      return { b: b, r: r };
   };
-  var _a = freb(fleb, 2), fl = _a[0], revfl = _a[1];
+  var _a = freb(fleb, 2), fl = _a.b, revfl = _a.r;
   // we can ignore the fact that the other numbers are wrong; they never happen anyway
   fl[28] = 258, revfl[258] = 28;
-  var _b = freb(fdeb, 0), fd = _b[0], revfd = _b[1];
+  var _b = freb(fdeb, 0), fd = _b.b, revfd = _b.r;
   // map of value to reverse (assuming 16 bits)
   var rev = new u16(32768);
   for (var i = 0; i < 32768; ++i) {
       // reverse table algorithm from SO
-      var x = ((i & 0xAAAA) >>> 1) | ((i & 0x5555) << 1);
-      x = ((x & 0xCCCC) >>> 2) | ((x & 0x3333) << 2);
-      x = ((x & 0xF0F0) >>> 4) | ((x & 0x0F0F) << 4);
-      rev[i] = (((x & 0xFF00) >>> 8) | ((x & 0x00FF) << 8)) >>> 1;
+      var x = ((i & 0xAAAA) >> 1) | ((i & 0x5555) << 1);
+      x = ((x & 0xCCCC) >> 2) | ((x & 0x3333) << 2);
+      x = ((x & 0xF0F0) >> 4) | ((x & 0x0F0F) << 4);
+      rev[i] = (((x & 0xFF00) >> 8) | ((x & 0x00FF) << 8)) >> 1;
   }
   // create huffman tree from u8 "map": index -> code length for code index
   // mb (max bits) must be at most 15
@@ -9667,7 +9678,7 @@
       }
       // u16 "map": index -> minimum code for bit length = index
       var le = new u16(mb);
-      for (i = 0; i < mb; ++i) {
+      for (i = 1; i < mb; ++i) {
           le[i] = (le[i - 1] + l[i - 1]) << 1;
       }
       var co;
@@ -9688,7 +9699,7 @@
                   // m is end value
                   for (var m = v | ((1 << r_1) - 1); v <= m; ++v) {
                       // every 16 bit value starting with the code yields the same result
-                      co[rev[v] >>> rvb] = sv;
+                      co[rev[v] >> rvb] = sv;
                   }
               }
           }
@@ -9697,7 +9708,7 @@
           co = new u16(s);
           for (i = 0; i < s; ++i) {
               if (cd[i]) {
-                  co[i] = rev[le[cd[i] - 1]++] >>> (15 - cd[i]);
+                  co[i] = rev[le[cd[i] - 1]++] >> (15 - cd[i]);
               }
           }
       }
@@ -9750,9 +9761,7 @@
       if (e == null || e > v.length)
           e = v.length;
       // can't use .constructor in case user-supplied
-      var n = new (v.BYTES_PER_ELEMENT == 2 ? u16 : v.BYTES_PER_ELEMENT == 4 ? u32 : u8)(e - s);
-      n.set(v.subarray(s, e));
-      return n;
+      return new u8(v.subarray(s, e));
   };
   // error codes
   var ec = [
@@ -9782,19 +9791,18 @@
       return e;
   };
   // expands raw DEFLATE data
-  var inflt = function (dat, buf, st) {
-      // source length
-      var sl = dat.length;
-      if (!sl || (st && st.f && !st.l))
+  var inflt = function (dat, st, buf, dict) {
+      // source length       dict length
+      var sl = dat.length, dl = dict ? dict.length : 0;
+      if (!sl || st.f && !st.l)
           return buf || new u8(0);
+      var noBuf = !buf;
       // have to estimate size
-      var noBuf = !buf || st;
+      var resize = noBuf || st.i != 2;
       // no state
-      var noSt = !st || st.i;
-      if (!st)
-          st = {};
+      var noSt = st.i;
       // Assumes roughly 33% compression ratio average
-      if (!buf)
+      if (noBuf)
           buf = new u8(sl * 3);
       // ensure buffer can fit at least l elements
       var cbuf = function (l) {
@@ -9827,7 +9835,7 @@
                       break;
                   }
                   // ensure size
-                  if (noBuf)
+                  if (resize)
                       cbuf(bt + l);
                   // Copy over uncompressed data
                   buf.set(dat.subarray(s, t), bt);
@@ -9860,7 +9868,7 @@
                       // bits read
                       pos += r & 15;
                       // symbol
-                      var s = r >>> 4;
+                      var s = r >> 4;
                       // code length to copy
                       if (s < 16) {
                           ldt[i++] = s;
@@ -9896,14 +9904,14 @@
               }
           }
           // Make sure the buffer can hold this + the largest possible addition
-          // Maximum chunk size (practically, theoretically infinite) is 2^17;
-          if (noBuf)
+          // Maximum chunk size (practically, theoretically infinite) is 2^17
+          if (resize)
               cbuf(bt + 131072);
           var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
           var lpos = pos;
           for (;; lpos = pos) {
               // bits read, code
-              var c = lm[bits16(dat, pos) & lms], sym = c >>> 4;
+              var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
               pos += c & 15;
               if (pos > tbts) {
                   if (noSt)
@@ -9928,52 +9936,55 @@
                       pos += b;
                   }
                   // dist
-                  var d = dm[bits16(dat, pos) & dms], dsym = d >>> 4;
+                  var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
                   if (!d)
                       err(3);
                   pos += d & 15;
                   var dt = fd[dsym];
                   if (dsym > 3) {
                       var b = fdeb[dsym];
-                      dt += bits16(dat, pos) & ((1 << b) - 1), pos += b;
+                      dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
                   }
                   if (pos > tbts) {
                       if (noSt)
                           err(0);
                       break;
                   }
-                  if (noBuf)
+                  if (resize)
                       cbuf(bt + 131072);
                   var end = bt + add;
-                  for (; bt < end; bt += 4) {
-                      buf[bt] = buf[bt - dt];
-                      buf[bt + 1] = buf[bt + 1 - dt];
-                      buf[bt + 2] = buf[bt + 2 - dt];
-                      buf[bt + 3] = buf[bt + 3 - dt];
+                  if (bt < dt) {
+                      var shift = dl - dt, dend = Math.min(dt, end);
+                      if (shift + bt < 0)
+                          err(3);
+                      for (; bt < dend; ++bt)
+                          buf[bt] = dict[shift + bt];
                   }
-                  bt = end;
+                  for (; bt < end; ++bt)
+                      buf[bt] = buf[bt - dt];
               }
           }
           st.l = lm, st.p = lpos, st.b = bt, st.f = final;
           if (lm)
               final = 1, st.m = lbt, st.d = dm, st.n = dbt;
       } while (!final);
-      return bt == buf.length ? buf : slc(buf, 0, bt);
+      // don't reallocate for streams or user buffers
+      return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
   };
   // starting at p, write the minimum number of bits that can hold v to d
   var wbits = function (d, p, v) {
       v <<= p & 7;
       var o = (p / 8) | 0;
       d[o] |= v;
-      d[o + 1] |= v >>> 8;
+      d[o + 1] |= v >> 8;
   };
   // starting at p, write the minimum number of bits (>8) that can hold v to d
   var wbits16 = function (d, p, v) {
       v <<= p & 7;
       var o = (p / 8) | 0;
       d[o] |= v;
-      d[o + 1] |= v >>> 8;
-      d[o + 2] |= v >>> 16;
+      d[o + 1] |= v >> 8;
+      d[o + 2] |= v >> 16;
   };
   // creates code lengths from a frequency table
   var hTree = function (d, mb) {
@@ -9986,11 +9997,11 @@
       var s = t.length;
       var t2 = t.slice();
       if (!s)
-          return [et, 0];
+          return { t: et, l: 0 };
       if (s == 1) {
           var v = new u8(t[0].s + 1);
           v[t[0].s] = 1;
-          return [v, 1];
+          return { t: v, l: 1 };
       }
       t.sort(function (a, b) { return a.f - b.f; });
       // after i2 reaches last ind, will be stopped
@@ -10034,7 +10045,7 @@
               else
                   break;
           }
-          dt >>>= lft;
+          dt >>= lft;
           while (dt > 0) {
               var i2_2 = t2[i].s;
               if (tr[i2_2] < mb)
@@ -10051,7 +10062,7 @@
           }
           mbt = mb;
       }
-      return [new u8(tr), mbt];
+      return { t: new u8(tr), l: mbt };
   };
   // get the max length and assign length codes
   var ln = function (n, l, d) {
@@ -10094,7 +10105,7 @@
               cln = c[i];
           }
       }
-      return [cl.subarray(0, cli), s];
+      return { c: cl.subarray(0, cli), n: s };
   };
   // calculate the length of output from tree, code lengths
   var clen = function (cf, cl) {
@@ -10110,7 +10121,7 @@
       var s = dat.length;
       var o = shft(pos + 2);
       out[o] = s & 255;
-      out[o + 1] = s >>> 8;
+      out[o + 1] = s >> 8;
       out[o + 2] = out[o] ^ 255;
       out[o + 3] = out[o + 1] ^ 255;
       for (var i = 0; i < s; ++i)
@@ -10121,23 +10132,23 @@
   var wblk = function (dat, out, final, syms, lf, df, eb, li, bs, bl, p) {
       wbits(out, p++, final);
       ++lf[256];
-      var _a = hTree(lf, 15), dlt = _a[0], mlb = _a[1];
-      var _b = hTree(df, 15), ddt = _b[0], mdb = _b[1];
-      var _c = lc(dlt), lclt = _c[0], nlc = _c[1];
-      var _d = lc(ddt), lcdt = _d[0], ndc = _d[1];
+      var _a = hTree(lf, 15), dlt = _a.t, mlb = _a.l;
+      var _b = hTree(df, 15), ddt = _b.t, mdb = _b.l;
+      var _c = lc(dlt), lclt = _c.c, nlc = _c.n;
+      var _d = lc(ddt), lcdt = _d.c, ndc = _d.n;
       var lcfreq = new u16(19);
       for (var i = 0; i < lclt.length; ++i)
-          lcfreq[lclt[i] & 31]++;
+          ++lcfreq[lclt[i] & 31];
       for (var i = 0; i < lcdt.length; ++i)
-          lcfreq[lcdt[i] & 31]++;
-      var _e = hTree(lcfreq, 7), lct = _e[0], mlcb = _e[1];
+          ++lcfreq[lcdt[i] & 31];
+      var _e = hTree(lcfreq, 7), lct = _e.t, mlcb = _e.l;
       var nlcc = 19;
       for (; nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc)
           ;
       var flen = (bl + 5) << 3;
       var ftlen = clen(lf, flt) + clen(df, fdt) + eb;
-      var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + (2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18]);
-      if (flen <= ftlen && flen <= dtlen)
+      var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + 2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18];
+      if (bs >= 0 && flen <= ftlen && flen <= dtlen)
           return wfblk(out, p, dat.subarray(bs, bs + bl));
       var lm, ll, dm, dl;
       wbits(out, p, 1 + (dtlen < ftlen)), p += 2;
@@ -10158,7 +10169,7 @@
                   var len = clct[i] & 31;
                   wbits(out, p, llm[len]), p += lct[len];
                   if (len > 15)
-                      wbits(out, p, (clct[i] >>> 5) & 127), p += clct[i] >>> 12;
+                      wbits(out, p, (clct[i] >> 5) & 127), p += clct[i] >> 12;
               }
           }
       }
@@ -10166,63 +10177,55 @@
           lm = flm, ll = flt, dm = fdm, dl = fdt;
       }
       for (var i = 0; i < li; ++i) {
-          if (syms[i] > 255) {
-              var len = (syms[i] >>> 18) & 31;
+          var sym = syms[i];
+          if (sym > 255) {
+              var len = (sym >> 18) & 31;
               wbits16(out, p, lm[len + 257]), p += ll[len + 257];
               if (len > 7)
-                  wbits(out, p, (syms[i] >>> 23) & 31), p += fleb[len];
-              var dst = syms[i] & 31;
+                  wbits(out, p, (sym >> 23) & 31), p += fleb[len];
+              var dst = sym & 31;
               wbits16(out, p, dm[dst]), p += dl[dst];
               if (dst > 3)
-                  wbits16(out, p, (syms[i] >>> 5) & 8191), p += fdeb[dst];
+                  wbits16(out, p, (sym >> 5) & 8191), p += fdeb[dst];
           }
           else {
-              wbits16(out, p, lm[syms[i]]), p += ll[syms[i]];
+              wbits16(out, p, lm[sym]), p += ll[sym];
           }
       }
       wbits16(out, p, lm[256]);
       return p + ll[256];
   };
   // deflate options (nice << 13) | chain
-  var deo = /*#__PURE__*/ new u32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]);
+  var deo = /*#__PURE__*/ new i32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]);
   // empty
   var et = /*#__PURE__*/ new u8(0);
   // compresses data into a raw DEFLATE buffer
-  var dflt = function (dat, lvl, plvl, pre, post, lst) {
-      var s = dat.length;
+  var dflt = function (dat, lvl, plvl, pre, post, st) {
+      var s = st.z || dat.length;
       var o = new u8(pre + s + 5 * (1 + Math.ceil(s / 7000)) + post);
       // writing to this writes to the output buffer
       var w = o.subarray(pre, o.length - post);
-      var pos = 0;
-      if (!lvl || s < 8) {
-          for (var i = 0; i <= s; i += 65535) {
-              // end
-              var e = i + 65535;
-              if (e >= s) {
-                  // write final block
-                  w[pos >> 3] = lst;
-              }
-              pos = wfblk(w, pos + 1, dat.subarray(i, e));
-          }
-      }
-      else {
+      var lst = st.l;
+      var pos = (st.r || 0) & 7;
+      if (lvl) {
+          if (pos)
+              w[0] = st.r >> 3;
           var opt = deo[lvl - 1];
-          var n = opt >>> 13, c = opt & 8191;
+          var n = opt >> 13, c = opt & 8191;
           var msk_1 = (1 << plvl) - 1;
           //    prev 2-byte val map    curr 2-byte val map
-          var prev = new u16(32768), head = new u16(msk_1 + 1);
+          var prev = st.p || new u16(32768), head = st.h || new u16(msk_1 + 1);
           var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1;
           var hsh = function (i) { return (dat[i] ^ (dat[i + 1] << bs1_1) ^ (dat[i + 2] << bs2_1)) & msk_1; };
           // 24576 is an arbitrary number of maximum symbols per block
           // 424 buffer for last block
-          var syms = new u32(25000);
+          var syms = new i32(25000);
           // length/literal freq   distance freq
           var lf = new u16(288), df = new u16(32);
-          //  l/lcnt  exbits  index  l/lind  waitdx  bitpos
-          var lc_1 = 0, eb = 0, i = 0, li = 0, wi = 0, bs = 0;
-          for (; i < s; ++i) {
+          //  l/lcnt  exbits  index          l/lind  waitdx          blkpos
+          var lc_1 = 0, eb = 0, i = st.i || 0, li = 0, wi = st.w || 0, bs = 0;
+          for (; i + 2 < s; ++i) {
               // hash value
-              // deopt when i > s - 3 - at end, deopt acceptable
               var hv = hsh(i);
               // index mod 32768    previous index mod
               var imod = i & 32767, pimod = head[hv];
@@ -10233,7 +10236,7 @@
               if (wi <= i) {
                   // bytes remaining
                   var rem = s - i;
-                  if ((lc_1 > 7000 || li > 24576) && rem > 423) {
+                  if ((lc_1 > 7000 || li > 24576) && (rem > 423 || !lst)) {
                       pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i - bs, pos);
                       li = lc_1 = eb = 0, bs = i;
                       for (var j = 0; j < 286; ++j)
@@ -10242,7 +10245,7 @@
                           df[j] = 0;
                   }
                   //  len    dist   chain
-                  var l = 2, d = 0, ch_1 = c, dif = (imod - pimod) & 32767;
+                  var l = 2, d = 0, ch_1 = c, dif = imod - pimod & 32767;
                   if (rem > 2 && hv == hsh(i - dif)) {
                       var maxn = Math.min(n, rem) - 1;
                       var maxd = Math.min(32767, i);
@@ -10265,9 +10268,9 @@
                                   var mmd = Math.min(dif, nl - 2);
                                   var md = 0;
                                   for (var j = 0; j < mmd; ++j) {
-                                      var ti = (i - dif + j + 32768) & 32767;
+                                      var ti = i - dif + j & 32767;
                                       var pti = prev[ti];
-                                      var cd = (ti - pti + 32768) & 32767;
+                                      var cd = ti - pti & 32767;
                                       if (cd > md)
                                           md = cd, pimod = ti;
                                   }
@@ -10275,12 +10278,12 @@
                           }
                           // check the previous match
                           imod = pimod, pimod = prev[imod];
-                          dif += (imod - pimod + 32768) & 32767;
+                          dif += imod - pimod & 32767;
                       }
                   }
                   // d will be nonzero only when a match was found
                   if (d) {
-                      // store both dist and len data in one Uint32
+                      // store both dist and len data in one int32
                       // Make sure this is recognized as a len/dist with 28th bit (2^28)
                       syms[li++] = 268435456 | (revfl[l] << 18) | revfd[d];
                       var lin = revfl[l] & 31, din = revfd[d] & 31;
@@ -10296,10 +10299,30 @@
                   }
               }
           }
+          for (i = Math.max(i, wi); i < s; ++i) {
+              syms[li++] = dat[i];
+              ++lf[dat[i]];
+          }
           pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i - bs, pos);
-          // this is the easiest way to avoid needing to maintain state
-          if (!lst && pos & 7)
-              pos = wfblk(w, pos + 1, et);
+          if (!lst) {
+              st.r = (pos & 7) | w[(pos / 8) | 0] << 3;
+              // shft(pos) now 1 less if pos & 7 != 0
+              pos -= 7;
+              st.h = head, st.p = prev, st.i = i, st.w = wi;
+          }
+      }
+      else {
+          for (var i = st.w || 0; i < s + lst; i += 65535) {
+              // end
+              var e = i + 65535;
+              if (e >= s) {
+                  // write final block
+                  w[(pos / 8) | 0] = lst;
+                  e = s;
+              }
+              pos = wfblk(w, pos + 1, dat.subarray(i, e));
+          }
+          st.i = s;
       }
       return slc(o, 0, pre + shft(pos) + post);
   };
@@ -10330,7 +10353,18 @@
   };
   // deflate with opts
   var dopt = function (dat, opt, pre, post, st) {
-      return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : (12 + opt.mem), pre, post, !st);
+      if (!st) {
+          st = { l: 1 };
+          if (opt.dictionary) {
+              var dict = opt.dictionary.subarray(-32768);
+              var newDat = new u8(dict.length + dat.length);
+              newDat.set(dict);
+              newDat.set(dat, dict.length);
+              dat = newDat;
+              st.w = dict.length;
+          }
+      }
+      return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? (st.l ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : 20) : (12 + opt.mem), pre, post, st);
   };
   // Walmart object spread
   var mrg = function (a, b) {
@@ -10375,7 +10409,7 @@
           else
               td[k] = v;
       }
-      return [fnStr, td];
+      return fnStr;
   };
   var ch = [];
   // clone bufs
@@ -10390,27 +10424,29 @@
   };
   // use a worker to execute code
   var wrkr = function (fns, init, id, cb) {
-      var _a;
       if (!ch[id]) {
           var fnStr = '', td_1 = {}, m = fns.length - 1;
           for (var i = 0; i < m; ++i)
-              _a = wcln(fns[i], fnStr, td_1), fnStr = _a[0], td_1 = _a[1];
-          ch[id] = wcln(fns[m], fnStr, td_1);
+              fnStr = wcln(fns[i], fnStr, td_1);
+          ch[id] = { c: wcln(fns[m], fnStr, td_1), e: td_1 };
       }
-      var td = mrg({}, ch[id][1]);
-      return wk(ch[id][0] + ';onmessage=function(e){for(var k in e.data)self[k]=e.data[k];onmessage=' + init.toString() + '}', id, td, cbfs(td), cb);
+      var td = mrg({}, ch[id].e);
+      return wk(ch[id].c + ';onmessage=function(e){for(var k in e.data)self[k]=e.data[k];onmessage=' + init.toString() + '}', id, td, cbfs(td), cb);
   };
   // base async inflate fn
-  var bInflt = function () { return [u8, u16, u32, fleb, fdeb, clim, fl, fd, flrm, fdrm, rev, ec, hMap, max, bits, bits16, shft, slc, err, inflt, inflateSync, pbf, gu8]; };
-  var bDflt = function () { return [u8, u16, u32, fleb, fdeb, clim, revfl, revfd, flm, flt, fdm, fdt, rev, deo, et, hMap, wbits, wbits16, hTree, ln, lc, clen, wfblk, wblk, shft, slc, dflt, dopt, deflateSync, pbf]; };
+  var bInflt = function () { return [u8, u16, i32, fleb, fdeb, clim, fl, fd, flrm, fdrm, rev, ec, hMap, max, bits, bits16, shft, slc, err, inflt, inflateSync, pbf, gopt]; };
+  var bDflt = function () { return [u8, u16, i32, fleb, fdeb, clim, revfl, revfd, flm, flt, fdm, fdt, rev, deo, et, hMap, wbits, wbits16, hTree, ln, lc, clen, wfblk, wblk, shft, slc, dflt, dopt, deflateSync, pbf]; };
   // gzip extra
   var gze = function () { return [gzh, gzhl, wbytes, crc, crct]; };
   // gunzip extra
   var guze = function () { return [gzs, gzl]; };
   // post buf
   var pbf = function (msg) { return postMessage(msg, [msg.buffer]); };
-  // get u8
-  var gu8 = function (o) { return o && o.size && new u8(o.size); };
+  // get opts
+  var gopt = function (o) { return o && {
+      out: o.size && new u8(o.size),
+      dictionary: o.dictionary
+  }; };
   // async helper
   var cbify = function (dat, opts, fns, init, id, cb) {
       var w = wrkr(fns, init, id, function (err, dat) {
@@ -10450,7 +10486,7 @@
       var flg = d[3];
       var st = 10;
       if (flg & 4)
-          st += d[10] | (d[11] << 8) + 2;
+          st += (d[10] | d[11] << 8) + 2;
       for (var zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++])
           ;
       return st + (flg & 2);
@@ -10458,10 +10494,10 @@
   // gzip length
   var gzl = function (d) {
       var l = d.length;
-      return ((d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16) | (d[l - 1] << 24)) >>> 0;
+      return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0;
   };
   // gzip header length
-  var gzhl = function (o) { return 10 + ((o.filename && (o.filename.length + 1)) || 0); };
+  var gzhl = function (o) { return 10 + (o.filename ? o.filename.length + 1 : 0); };
   function deflate(data, opts, cb) {
       if (!cb)
           cb = opts, opts = {};
@@ -10487,16 +10523,16 @@
           err(7);
       return cbify(data, opts, [
           bInflt
-      ], function (ev) { return pbf(inflateSync(ev.data[0], gu8(ev.data[1]))); }, 1, cb);
+      ], function (ev) { return pbf(inflateSync(ev.data[0], gopt(ev.data[1]))); }, 1, cb);
   }
   /**
    * Expands DEFLATE data with no wrapper
    * @param data The data to decompress
-   * @param out Where to write the data. Saves memory if you know the decompressed size and provide an output buffer of that length.
+   * @param opts The decompression options
    * @returns The decompressed version of the data
    */
-  function inflateSync(data, out) {
-      return inflt(data, out);
+  function inflateSync(data, opts) {
+      return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);
   }
   function gzip(data, opts, cb) {
       if (!cb)
@@ -10532,16 +10568,19 @@
           bInflt,
           guze,
           function () { return [gunzipSync$1]; }
-      ], function (ev) { return pbf(gunzipSync$1(ev.data[0])); }, 3, cb);
+      ], function (ev) { return pbf(gunzipSync$1(ev.data[0], ev.data[1])); }, 3, cb);
   }
   /**
    * Expands GZIP data
    * @param data The data to decompress
-   * @param out Where to write the data. GZIP already encodes the output size, so providing this doesn't save memory.
+   * @param opts The decompression options
    * @returns The decompressed version of the data
    */
-  function gunzipSync$1(data, out) {
-      return inflt(data.subarray(gzs(data), -8), out || new u8(gzl(data)));
+  function gunzipSync$1(data, opts) {
+      var st = gzs(data);
+      if (st + 8 > data.length)
+          err(6, 'invalid gzip data');
+      return inflt(data.subarray(st, -8), { i: 2 }, opts && opts.out || new u8(gzl(data)), opts && opts.dictionary);
   }
   // flatten a directory structure
   var fltn = function (d, p, t, o) {
@@ -10574,7 +10613,7 @@
           var c = d[i++];
           var eb = (c > 127) + (c > 223) + (c > 239);
           if (i + eb > d.length)
-              return [r, slc(d, i - 1)];
+              return { s: r, r: slc(d, i - 1) };
           if (!eb)
               r += String.fromCharCode(c);
           else if (eb == 3) {
@@ -10595,12 +10634,7 @@
    * @returns The string encoded in UTF-8/Latin-1 binary
    */
   function strToU8(str, latin1) {
-      if (latin1) {
-          var ar_1 = new u8(str.length);
-          for (var i = 0; i < str.length; ++i)
-              ar_1[i] = str.charCodeAt(i);
-          return ar_1;
-      }
+      var i;
       if (te)
           return te.encode(str);
       var l = str.length;
@@ -10640,13 +10674,14 @@
               r += String.fromCharCode.apply(null, dat.subarray(i, i + 16384));
           return r;
       }
-      else if (td)
+      else if (td) {
           return td.decode(dat);
+      }
       else {
-          var _a = dutf8(dat), out = _a[0], ext = _a[1];
-          if (ext.length)
+          var _a = dutf8(dat), s = _a.s, r = _a.r;
+          if (r.length)
               err(8);
-          return out;
+          return s;
       }
   }
   // skip local zip header
@@ -10689,7 +10724,7 @@
       var dt = new Date(f.mtime == null ? Date.now() : f.mtime), y = dt.getFullYear() - 1980;
       if (y < 0 || y > 119)
           err(10);
-      wbytes(d, b, (y << 25) | ((dt.getMonth() + 1) << 21) | (dt.getDate() << 16) | (dt.getHours() << 11) | (dt.getMinutes() << 5) | (dt.getSeconds() >>> 1)), b += 4;
+      wbytes(d, b, (y << 25) | ((dt.getMonth() + 1) << 21) | (dt.getDate() << 16) | (dt.getHours() << 11) | (dt.getMinutes() << 5) | (dt.getSeconds() >> 1)), b += 4;
       if (c != -1) {
           wbytes(d, b, f.crc);
           wbytes(d, b + 4, c < 0 ? -c - 2 : c);
@@ -10929,9 +10964,10 @@
                       cbl(null, slc(data, b, b + sc));
                   else if (c_1 == 8) {
                       var infl = data.subarray(b, b + sc);
-                      if (sc < 320000) {
+                      // Synchronously decompress under 512KB, or barely-compressed data
+                      if (su < 524288 || sc > 0.8 * su) {
                           try {
-                              cbl(null, inflateSync(infl, new u8(su)));
+                              cbl(null, inflateSync(infl, { out: new u8(su) }));
                           }
                           catch (e) {
                               cbl(e, null);
@@ -10994,7 +11030,7 @@
               if (!c_2)
                   files[fn] = slc(data, b, b + sc);
               else if (c_2 == 8)
-                  files[fn] = inflateSync(data.subarray(b, b + sc), new u8(su));
+                  files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8(su) });
               else
                   err(14, 'unknown compression type ' + c_2);
           }
@@ -11062,11 +11098,11 @@
   var Gzip = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    isGzipped: isGzipped,
-    gzipSync: gzipSync,
-    gzipAsync: gzipAsync,
     gunzipAsync: gunzipAsync,
-    gunzipSync: gunzipSync
+    gunzipSync: gunzipSync,
+    gzipAsync: gzipAsync,
+    gzipSync: gzipSync,
+    isGzipped: isGzipped
   });
   // Export in a column-first format
@@ -11310,12 +11346,12 @@
   var Pack = /*#__PURE__*/Object.freeze({
     __proto__: null,
     PACKAGE_EXT: PACKAGE_EXT,
-    exportPackedDatasets: exportPackedDatasets,
-    pack: pack,
-    exportDatasetsToPack: exportDatasetsToPack,
-    exportDataset: exportDataset,
     compressSnapshotForExport: compressSnapshotForExport,
-    exportInfo: exportInfo
+    exportDataset: exportDataset,
+    exportDatasetsToPack: exportDatasetsToPack,
+    exportInfo: exportInfo,
+    exportPackedDatasets: exportPackedDatasets,
+    pack: pack
   });
   // Guess the type of a data file from file extension, or return null if not sure
@@ -11440,24 +11476,24 @@
   var FileTypes = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    guessInputFileType: guessInputFileType,
-    isAuxiliaryInputFileType: isAuxiliaryInputFileType,
+    couldBeDsvFile: couldBeDsvFile,
+    filenameIsUnsupportedOutputType: filenameIsUnsupportedOutputType,
+    getFormatName: getFormatName,
     guessInputContentType: guessInputContentType,
+    guessInputFileType: guessInputFileType,
     guessInputType: guessInputType,
-    stringLooksLikeJSON: stringLooksLikeJSON,
-    stringLooksLikeKML: stringLooksLikeKML,
-    couldBeDsvFile: couldBeDsvFile,
-    looksLikeImportableFile: looksLikeImportableFile,
-    looksLikeContentFile: looksLikeContentFile,
-    isPackageFile: isPackageFile,
-    isZipFile: isZipFile,
-    isKmzFile: isKmzFile,
+    isAuxiliaryInputFileType: isAuxiliaryInputFileType,
     isGzipFile: isGzipFile,
-    isSupportedOutputFormat: isSupportedOutputFormat,
-    getFormatName: getFormatName,
-    isSupportedBinaryInputType: isSupportedBinaryInputType,
     isImportableAsBinary: isImportableAsBinary,
-    filenameIsUnsupportedOutputType: filenameIsUnsupportedOutputType
+    isKmzFile: isKmzFile,
+    isPackageFile: isPackageFile,
+    isSupportedBinaryInputType: isSupportedBinaryInputType,
+    isSupportedOutputFormat: isSupportedOutputFormat,
+    isZipFile: isZipFile,
+    looksLikeContentFile: looksLikeContentFile,
+    looksLikeImportableFile: looksLikeImportableFile,
+    stringLooksLikeJSON: stringLooksLikeJSON,
+    stringLooksLikeKML: stringLooksLikeKML
   });
   // input: A file path or a buffer
@@ -11565,11 +11601,11 @@
   var Zip = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    unzipSync: unzipSync,
+    isImportableZipPath: isImportableZipPath,
     unzipAsync: unzipAsync,
-    zipSync: zipSync,
+    unzipSync: unzipSync,
     zipAsync: zipAsync,
-    isImportableZipPath: isImportableZipPath
+    zipSync: zipSync
   });
   var cli = {};
@@ -11797,9 +11833,9 @@
   var FileExport = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    writeFiles: writeFiles,
+    getOutputPaths: getOutputPaths,
     replaceWriteFiles: replaceWriteFiles,
-    getOutputPaths: getOutputPaths
+    writeFiles: writeFiles
   });
   // Returns a search function
@@ -12501,8 +12537,8 @@
   var PathExport = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    exportPointData: exportPointData,
-    exportPathData: exportPathData
+    exportPathData: exportPathData,
+    exportPointData: exportPointData
   });
   function stringifyAsNDJSON(o) {
@@ -12540,8 +12576,8 @@
   var Stringify = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    stringifyAsNDJSON: stringifyAsNDJSON,
-    getFormattedStringify: getFormattedStringify
+    getFormattedStringify: getFormattedStringify,
+    stringifyAsNDJSON: stringifyAsNDJSON
   });
   function isValidArc(arcId, arcs) {
@@ -12662,8 +12698,8 @@
   var PathfinderUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    getRightmostArc: getRightmostArc,
-    chooseRighthandVector: chooseRighthandVector
+    chooseRighthandVector: chooseRighthandVector,
+    getRightmostArc: getRightmostArc
   });
   var FWD_USED = 0x8;
@@ -12681,9 +12717,9 @@
     var idx = absArcId(arcId), // get index of path in
         mask;
     if (idx == arcId) { // arcBits controls fwd path
-      mask = ~3; // target fwd bits
+      mask = -4; // target fwd bits
     } else { // arcBits controls rev. path
-      mask = ~0x30; // target rev bits
+      mask = -49; // target rev bits
       arcBits = arcBits << 4; // shift code to target rev path
     }
     routesArr[idx] &= (arcBits | mask);
@@ -12739,7 +12775,7 @@
         // (these arcs represent shared borders and will not be part of the dissolved path)
         //
         if (dissolve && (newBits & 0x22) === 0x22) {
-          newBits &= ~0x11; // make invisible
+          newBits &= -18; // make invisible
         }
       }
@@ -12757,11 +12793,11 @@
           closeRev = isInv ? fwd : rev;
       if (closeFwd) {
-        if (hide) mask &= ~1;
+        if (hide) mask &= -2;
         mask ^= 0x2;
       }
       if (closeRev) {
-        if (hide) mask &= ~0x10;
+        if (hide) mask &= -17;
         mask ^= 0x20;
       }
       routesArr[idx] = currBits & mask;
@@ -12892,15 +12928,15 @@
   var Pathfinder = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    setBits: setBits,
     andBits: andBits,
-    setRouteBits: setRouteBits,
+    closeArcRoutes: closeArcRoutes,
+    getPathFinder: getPathFinder,
+    getRingIntersector: getRingIntersector,
     getRouteBits: getRouteBits,
     markPathsAsUsed: markPathsAsUsed,
     openArcRoutes: openArcRoutes,
-    closeArcRoutes: closeArcRoutes,
-    getPathFinder: getPathFinder,
-    getRingIntersector: getRingIntersector
+    setBits: setBits,
+    setRouteBits: setRouteBits
   });
   // Keep track of whether positive or negative integer ids are 'used' or not.
@@ -13233,16 +13269,16 @@
   var SegmentIntersection = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    getIntersectionPoints: getIntersectionPoints,
-    getIntersectionLayer: getIntersectionLayer,
-    findSegmentIntersections: findSegmentIntersections,
-    sortIntersections: sortIntersections,
-    dedupIntersections: dedupIntersections,
-    calcSegmentIntersectionStripeCount2: calcSegmentIntersectionStripeCount2,
     calcSegmentIntersectionStripeCount: calcSegmentIntersectionStripeCount,
-    intersectSegments: intersectSegments,
+    calcSegmentIntersectionStripeCount2: calcSegmentIntersectionStripeCount2,
+    dedupIntersections: dedupIntersections,
+    findSegmentIntersections: findSegmentIntersections,
+    formatIntersectingSegment: formatIntersectingSegment,
     formatIntersection: formatIntersection,
-    formatIntersectingSegment: formatIntersectingSegment
+    getIntersectionLayer: getIntersectionLayer,
+    getIntersectionPoints: getIntersectionPoints,
+    intersectSegments: intersectSegments,
+    sortIntersections: sortIntersections
   });
   function findNearestVertices(p, shp, arcs) {
@@ -13370,19 +13406,19 @@
   var VertexUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    findNearestVertex: findNearestVertex,
     findNearestVertices: findNearestVertices,
-    snapVerticesToPoint: snapVerticesToPoint,
-    snapPointToArcEndpoint: snapPointToArcEndpoint,
     findVertexIds: findVertexIds,
-    getVertexCoords: getVertexCoords,
-    vertexIsArcEnd: vertexIsArcEnd,
-    vertexIsArcEndpoint: vertexIsArcEndpoint,
-    vertexIsArcStart: vertexIsArcStart,
-    getArcStartCoords: getArcStartCoords,
     getArcEndCoords: getArcEndCoords,
     getArcEndpointCoords: getArcEndpointCoords,
+    getArcStartCoords: getArcStartCoords,
+    getVertexCoords: getVertexCoords,
     setVertexCoords: setVertexCoords,
-    findNearestVertex: findNearestVertex
+    snapPointToArcEndpoint: snapPointToArcEndpoint,
+    snapVerticesToPoint: snapVerticesToPoint,
+    vertexIsArcEnd: vertexIsArcEnd,
+    vertexIsArcEndpoint: vertexIsArcEndpoint,
+    vertexIsArcStart: vertexIsArcStart
   });
   // arcs: ArcCollection containing original coordinates
@@ -13592,18 +13628,18 @@
   var Rounding = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    roundToSignificantDigits: roundToSignificantDigits,
-    roundToDigits: roundToDigits,
-    roundToDigits2: roundToDigits2,
-    roundToTenths: roundToTenths,
-    getRoundingFunction: getRoundingFunction,
+    fround: fround,
+    fround2: fround2,
+    getBinaryRoundingFunction: getBinaryRoundingFunction,
     getBoundsPrecisionForDisplay: getBoundsPrecisionForDisplay,
     getRoundedCoordString: getRoundedCoordString,
     getRoundedCoords: getRoundedCoords,
+    getRoundingFunction: getRoundingFunction,
     roundPoints: roundPoints,
-    fround2: fround2,
-    getBinaryRoundingFunction: getBinaryRoundingFunction,
-    fround: fround,
+    roundToDigits: roundToDigits,
+    roundToDigits2: roundToDigits2,
+    roundToSignificantDigits: roundToSignificantDigits,
+    roundToTenths: roundToTenths,
     setCoordinatePrecision: setCoordinatePrecision
   });
@@ -13790,16 +13826,16 @@
   var Units = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    parseSizeParam: parseSizeParam,
-    getIntervalConversionFactor: getIntervalConversionFactor,
-    parseMeasure: parseMeasure,
-    parseMeasure2: parseMeasure2,
     convertAreaParam: convertAreaParam,
     convertDistanceParam: convertDistanceParam,
-    convertIntervalParam: convertIntervalParam,
-    convertIntervalPair: convertIntervalPair,
     convertFourSides: convertFourSides,
-    getAreaLabel: getAreaLabel
+    convertIntervalPair: convertIntervalPair,
+    convertIntervalParam: convertIntervalParam,
+    getAreaLabel: getAreaLabel,
+    getIntervalConversionFactor: getIntervalConversionFactor,
+    parseMeasure: parseMeasure,
+    parseMeasure2: parseMeasure2,
+    parseSizeParam: parseSizeParam
   });
   // Used by -clean -dissolve2 -filter-slivers -filter-islands to generate area filters
@@ -13915,11 +13951,11 @@
   var Slivers = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    getSliverFilter: getSliverFilter,
-    getSliverTest: getSliverTest,
-    getSliverAreaFunction: getSliverAreaFunction,
+    calcMaxSliverArea: calcMaxSliverArea,
     getDefaultSliverThreshold: getDefaultSliverThreshold,
-    calcMaxSliverArea: calcMaxSliverArea
+    getSliverAreaFunction: getSliverAreaFunction,
+    getSliverFilter: getSliverFilter,
+    getSliverTest: getSliverTest
   });
   // Returns undefined if not found
@@ -14806,13 +14842,13 @@
   var TargetUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    countTargetLayers: countTargetLayers,
     expandCommandTargets: expandCommandTargets,
     findCommandTargets: findCommandTargets,
-    groupLayersByDataset: groupLayersByDataset,
     findMatchingLayers: findMatchingLayers,
     getLayerMatch: getLayerMatch,
-    countTargetLayers: countTargetLayers,
-    getLayerTargetId: getLayerTargetId
+    getLayerTargetId: getLayerTargetId,
+    groupLayersByDataset: groupLayersByDataset
   });
   function getNullLayerProxy(targets) {
@@ -15262,10 +15298,10 @@
   var Expressions = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    getExpressionFunction: getExpressionFunction,
     compileExpressionToFunction: compileExpressionToFunction,
     getAssignedVars: getAssignedVars,
     getBaseContext: getBaseContext,
+    getExpressionFunction: getExpressionFunction,
     nullifyUnsetProperties: nullifyUnsetProperties
   });
@@ -15392,8 +15428,8 @@
   var FeatureExpressions = /*#__PURE__*/Object.freeze({
     __proto__: null,
     compileFeatureExpression: compileFeatureExpression,
-    compileFeaturePairFilterExpression: compileFeaturePairFilterExpression,
-    compileFeaturePairExpression: compileFeaturePairExpression
+    compileFeaturePairExpression: compileFeaturePairExpression,
+    compileFeaturePairFilterExpression: compileFeaturePairFilterExpression
   });
   function getMode(values) {
@@ -15751,8 +15787,8 @@
   var Calc = /*#__PURE__*/Object.freeze({
     __proto__: null,
     applyCalcExpression: applyCalcExpression,
-    evalCalcExpression: evalCalcExpression,
-    compileCalcExpression: compileCalcExpression
+    compileCalcExpression: compileCalcExpression,
+    evalCalcExpression: evalCalcExpression
   });
   // get function that returns an object containing calculated values
@@ -15880,9 +15916,9 @@
   var DataAggregation = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    aggregateDataRecords: aggregateDataRecords,
     getCategoryClassifier: getCategoryClassifier,
     getMultiFieldKeyFunction: getMultiFieldKeyFunction,
-    aggregateDataRecords: aggregateDataRecords,
     recombineDataRecords: recombineDataRecords
   });
@@ -16519,7 +16555,7 @@
   // split into two rings that touch each other where the original ring crossed itself.
   //
   function getSelfIntersectionSplitter(nodes) {
-    var pathIndex = new IdTestIndex(nodes.arcs.size(), true);
+    var pathIndex = new IdTestIndex(nodes.arcs.size());
     var filter = function(arcId) {
       return pathIndex.hasId(~arcId);
     };
@@ -16616,8 +16652,8 @@
   var PathRepair = /*#__PURE__*/Object.freeze({
     __proto__: null,
     cleanShapes: cleanShapes,
-    removeSpikesInPath: removeSpikesInPath,
     getSelfIntersectionSplitter: getSelfIntersectionSplitter,
+    removeSpikesInPath: removeSpikesInPath,
     splitPathByIds: splitPathByIds
   });
@@ -17013,14 +17049,14 @@
   var IntersectionCuts = /*#__PURE__*/Object.freeze({
     __proto__: null,
     addIntersectionCuts: addIntersectionCuts,
-    divideArcs: divideArcs,
     cutPathsAtIntersections: cutPathsAtIntersections,
-    remapDividedArcs: remapDividedArcs,
-    insertCutPoints: insertCutPoints,
-    getCutPoint: getCutPoint,
-    sortCutPoints: sortCutPoints,
+    divideArcs: divideArcs,
     filterSortedCutPoints: filterSortedCutPoints,
-    findClippingPoints: findClippingPoints
+    findClippingPoints: findClippingPoints,
+    getCutPoint: getCutPoint,
+    insertCutPoints: insertCutPoints,
+    remapDividedArcs: remapDividedArcs,
+    sortCutPoints: sortCutPoints
   });
   // Support for timing using T.start() and T.stop()
@@ -17181,8 +17217,8 @@
   var PolygonMosaic = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    mosaic: mosaic,
-    buildPolygonMosaic: buildPolygonMosaic
+    buildPolygonMosaic: buildPolygonMosaic,
+    mosaic: mosaic
   });
   // Map non-negative integers to non-negative integer ids
@@ -17276,14 +17312,14 @@
   //
   function PolygonTiler(mosaic, arcTileIndex, nodes, opts) {
     var arcs = nodes.arcs;
-    var visitedTileIndex = new IdTestIndex(mosaic.length, true);
+    var visitedTileIndex = new IdTestIndex(mosaic.length);
     var divide = getHoleDivider(nodes);
     // temp vars
     var currHoles; // arc ids of all holes in shape
     var currRingBbox;
     var tilesInShape; // accumulator for tile ids of tiles in current shape
-    var ringIndex = new IdTestIndex(arcs.size(), true);
-    var holeIndex = new IdTestIndex(arcs.size(), true);
+    var ringIndex = new IdTestIndex(arcs.size());
+    var holeIndex = new IdTestIndex(arcs.size());
     // return ids of tiles in shape
     this.getTilesInShape = function(shp, shapeId) {
@@ -17384,7 +17420,7 @@
     // map arc ids to tile ids
     var arcTileIndex = new ShapeArcIndex(mosaic, nodes.arcs);
     // keep track of which tiles have been assigned to shapes
-    var fetchedTileIndex = new IdTestIndex(mosaic.length, true);
+    var fetchedTileIndex = new IdTestIndex(mosaic.length);
     // bidirection index of tile ids <=> shape ids
     var tileShapeIndex = new TileShapeIndex(mosaic, opts);
     // assign tiles to shapes
@@ -17664,9 +17700,9 @@
   var PolygonDissolve2 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    dissolvePolygonLayer2: dissolvePolygonLayer2,
     composeMosaicLayer: composeMosaicLayer,
-    dissolvePolygonGroups2: dissolvePolygonGroups2
+    dissolvePolygonGroups2: dissolvePolygonGroups2,
+    dissolvePolygonLayer2: dissolvePolygonLayer2
   });
   // Assumes intersection cuts have been added and duplicated points removed
@@ -18466,17 +18502,17 @@
   var GeojsonExport = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    'default': GeoJSON,
+    default: GeoJSON,
+    exportDatasetAsGeoJSON: exportDatasetAsGeoJSON,
     exportGeoJSON: exportGeoJSON,
+    exportIds: exportIds,
     exportLayerAsGeoJSON: exportLayerAsGeoJSON,
-    warnIfNotWgs84: warnIfNotWgs84,
+    exportProperties: exportProperties,
     getDatasetBbox: getDatasetBbox,
-    exportDatasetAsGeoJSON: exportDatasetAsGeoJSON,
+    getIdField: getIdField,
     preserveOriginalCRS: preserveOriginalCRS,
     useFeatureCollection: useFeatureCollection,
-    exportProperties: exportProperties,
-    getIdField: getIdField,
-    exportIds: exportIds
+    warnIfNotWgs84: warnIfNotWgs84
   });
   /*
@@ -18715,19 +18751,19 @@
   var FrameUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    getFrameData: getFrameData,
-    fitDatasetToFrame: fitDatasetToFrame,
-    getFrameLayerData: getFrameLayerData,
     calcFrameData: calcFrameData,
-    getFrameSize: getFrameSize,
-    isFrameLayer: isFrameLayer,
-    findFrameLayerInDataset: findFrameLayerInDataset,
+    calcOutputBounds: calcOutputBounds,
+    findFrame: findFrame,
     findFrameDataset: findFrameDataset,
     findFrameLayer: findFrameLayer,
-    findFrame: findFrame,
+    findFrameLayerInDataset: findFrameLayerInDataset,
+    fitDatasetToFrame: fitDatasetToFrame,
+    getFrameData: getFrameData,
     getFrameLayerBounds: getFrameLayerBounds,
+    getFrameLayerData: getFrameLayerData,
+    getFrameSize: getFrameSize,
     getMapFrameMetersPerPixel: getMapFrameMetersPerPixel,
-    calcOutputBounds: calcOutputBounds,
+    isFrameLayer: isFrameLayer,
     parseMarginOption: parseMarginOption
   });
@@ -18837,7 +18873,6 @@
   function getFitBoxTransform(bbox, points, shapes, arcs) {
     var dataset = {
       arcs: arcs,
-      info: {},
       layers: []
     };
     if (points && points.length) {
@@ -18933,8 +18968,8 @@
   var SvgPathUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    stringifyPolygonCoords: stringifyPolygonCoords,
-    stringifyLineStringCoords: stringifyLineStringCoords
+    stringifyLineStringCoords: stringifyLineStringCoords,
+    stringifyPolygonCoords: stringifyPolygonCoords
   });
   /* example patterns
@@ -19178,11 +19213,11 @@
   var SvgHatch = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    parsePattern: parsePattern,
+    convertFillPattern: convertFillPattern,
     parseDashes: parseDashes,
-    parseHatches: parseHatches,
     parseDots: parseDots,
-    convertFillPattern: convertFillPattern
+    parseHatches: parseHatches,
+    parsePattern: parsePattern
   });
   // parsing hints for -style command cli options
@@ -19432,17 +19467,17 @@
   var SvgProperties = /*#__PURE__*/Object.freeze({
     __proto__: null,
     applyStyleAttributes: applyStyleAttributes,
-    isSupportedSvgStyleProperty: isSupportedSvgStyleProperty,
     findPropertiesBySymbolGeom: findPropertiesBySymbolGeom,
     getSymbolDataAccessor: getSymbolDataAccessor,
-    mightBeExpression: mightBeExpression,
     getSymbolPropertyAccessor: getSymbolPropertyAccessor,
+    isSupportedSvgStyleProperty: isSupportedSvgStyleProperty,
     isSvgClassName: isSvgClassName,
+    isSvgColor: isSvgColor,
+    isSvgMeasure: isSvgMeasure,
     isSvgNumber: isSvgNumber,
+    mightBeExpression: mightBeExpression,
     parseBoolean: parseBoolean,
-    isSvgMeasure: isSvgMeasure,
-    parseSvgMeasure: parseSvgMeasure,
-    isSvgColor: isSvgColor
+    parseSvgMeasure: parseSvgMeasure
   });
   var geojsonImporters = {
@@ -19566,12 +19601,12 @@
   var GeojsonToSvg = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    flattenMultiPolygonCoords: flattenMultiPolygonCoords,
     importGeoJSONFeatures: importGeoJSONFeatures,
-    importPoint: importPoint,
     importLineString: importLineString,
     importMultiLineString: importMultiLineString,
     importMultiPolygon: importMultiPolygon,
-    flattenMultiPolygonCoords: flattenMultiPolygonCoords,
+    importPoint: importPoint,
     importPolygon: importPolygon
   });
@@ -19632,11 +19667,12 @@
   var SvgLabels = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    renderStyledLabel: renderStyledLabel,
-    renderLabel: renderLabel$1
+    renderLabel: renderLabel$1,
+    renderStyledLabel: renderStyledLabel
   });
   // convert data records (properties like svg-symbol, label-text, fill, r) to svg symbols
+  //
   function getTransform(xy, scale) {
     var str = 'translate(' + roundToTenths(xy[0]) + ' ' + roundToTenths(xy[1]) + ')';
@@ -19825,8 +19861,8 @@
   var SvgSymbols = /*#__PURE__*/Object.freeze({
     __proto__: null,
     getTransform: getTransform,
-    symbolRenderers: symbolRenderers,
-    renderPoint: renderPoint
+    renderPoint: renderPoint,
+    symbolRenderers: symbolRenderers
   });
   cmd.scalebar = function(catalog, opts) {
@@ -20104,10 +20140,10 @@
   var Scalebar = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    getScalebarLayer: getScalebarLayer,
-    renderScalebar: renderScalebar,
     formatDistanceLabel: formatDistanceLabel,
-    parseScalebarLabelToKm: parseScalebarLabelToKm
+    getScalebarLayer: getScalebarLayer,
+    parseScalebarLabelToKm: parseScalebarLabelToKm,
+    renderScalebar: renderScalebar
   });
   var furnitureRenderers = {
@@ -20153,10 +20189,10 @@
   var Furniture = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    layerHasFurniture: layerHasFurniture,
-    isFurnitureLayer: isFurnitureLayer,
-    getFurnitureLayerType: getFurnitureLayerType,
     getFurnitureLayerData: getFurnitureLayerData,
+    getFurnitureLayerType: getFurnitureLayerType,
+    isFurnitureLayer: isFurnitureLayer,
+    layerHasFurniture: layerHasFurniture,
     renderFurnitureLayer: renderFurnitureLayer
   });
@@ -20223,8 +20259,8 @@
   var SvgStringify = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    stringify: stringify,
     stringEscape: stringEscape,
+    stringify: stringify,
     stringifyProperties: stringifyProperties
   });
@@ -20306,8 +20342,8 @@
   var SvgEffect = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    getSphereEffectParams: getSphereEffectParams,
-    convertFillEffect: convertFillEffect
+    convertFillEffect: convertFillEffect,
+    getSphereEffectParams: getSphereEffectParams
   });
   var cache = {};
@@ -20678,22 +20714,22 @@ ${svg}
   var Svg = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    exportSVG: exportSVG,
+    exportDataAttributesForSVG: exportDataAttributesForSVG,
     exportFurnitureLayerForSVG: exportFurnitureLayerForSVG,
     exportLayerForSVG: exportLayerForSVG,
-    validateSvgDataFields: validateSvgDataFields,
-    exportDataAttributesForSVG: exportDataAttributesForSVG,
-    getEmptyLayerForSVG: getEmptyLayerForSVG,
-    featureHasSvgSymbol: featureHasSvgSymbol,
+    exportSVG: exportSVG,
     featureHasLabel: featureHasLabel,
+    featureHasSvgSymbol: featureHasSvgSymbol,
+    getEmptyLayerForSVG: getEmptyLayerForSVG,
+    layerHasLabels: layerHasLabels,
     layerHasSvgSymbols: layerHasSvgSymbols,
-    layerHasLabels: layerHasLabels
+    validateSvgDataFields: validateSvgDataFields
   });
   // import { isKmzFile } from '../io/mapshaper-file-types';
   function exportKML(dataset, opts) {
-    var toKML = require("@placemarkio/tokml").toKML;
+    var toKML = require$1("@placemarkio/tokml").toKML;
     var geojsonOpts = Object.assign({combine_layers: true, geojson_type: 'FeatureCollection'}, opts);
     var geojson = exportDatasetAsGeoJSON(dataset, geojsonOpts);
     var kml = toKML(geojson);
@@ -20993,8 +21029,8 @@ ${svg}
   var BinArray$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    buffersAreIdentical: buffersAreIdentical,
-    BinArray: BinArray
+    BinArray: BinArray,
+    buffersAreIdentical: buffersAreIdentical
   });
   var Dbf = {};
@@ -22346,8 +22382,8 @@ ${svg}
   var TopojsonExport = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    exportTopoJSON: exportTopoJSON,
-    calcExportBounds: calcExportBounds
+    calcExportBounds: calcExportBounds,
+    exportTopoJSON: exportTopoJSON
   });
   function importJSONTable(arr) {
@@ -22386,9 +22422,9 @@ ${svg}
   var JsonTable = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    importJSONTable: importJSONTable,
     exportJSON: exportJSON,
-    exportJSONTable: exportJSONTable
+    exportJSONTable: exportJSONTable,
+    importJSONTable: importJSONTable
   });
   function getOutputFormat(dataset, opts) {
@@ -22704,10 +22740,10 @@ ${svg}
   var Export = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    exportTargetLayers: exportTargetLayers,
-    exportFileContent: exportFileContent,
-    assignUniqueLayerNames: assignUniqueLayerNames,
     assignUniqueFileNames: assignUniqueFileNames,
+    assignUniqueLayerNames: assignUniqueLayerNames,
+    exportFileContent: exportFileContent,
+    exportTargetLayers: exportTargetLayers,
     formatVersionedFileName: formatVersionedFileName
   });
@@ -22892,10 +22928,10 @@ ${svg}
   var FileReader$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    readFirstChars: readFirstChars,
-    Reader2: Reader2,
     BufferReader: BufferReader,
-    FileReader: FileReader
+    FileReader: FileReader,
+    Reader2: Reader2,
+    readFirstChars: readFirstChars
   });
   // Read and parse a DSV file
@@ -23147,14 +23183,14 @@ ${svg}
   var DelimReader = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    readDelimRecords: readDelimRecords,
-    readDelimRecordsFromString: readDelimRecordsFromString,
-    indexOfLine: indexOfLine,
+    getDelimFieldFilter: getDelimFieldFilter,
     getRowConverter: getRowConverter,
+    indexOfLine: indexOfLine,
     parseDelimHeaderSection: parseDelimHeaderSection,
-    getDelimFieldFilter: getDelimFieldFilter,
-    readLinesAsString: readLinesAsString,
-    parseDelimText: parseDelimText
+    parseDelimText: parseDelimText,
+    readDelimRecords: readDelimRecords,
+    readDelimRecordsFromString: readDelimRecordsFromString,
+    readLinesAsString: readLinesAsString
   });
   function detectEncodingFromBOM(bytes) {
@@ -23286,9 +23322,9 @@ ${svg}
   var EncodingDetection = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    detectEncodingFromBOM: detectEncodingFromBOM,
+    decodeSamples: decodeSamples,
     detectEncoding: detectEncoding,
-    decodeSamples: decodeSamples
+    detectEncodingFromBOM: detectEncodingFromBOM
   });
   // Convert a string containing delimited text data into a dataset object
@@ -23497,12 +23533,12 @@ ${svg}
   var DelimImport = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    adjustRecordTypes: adjustRecordTypes,
+    getFieldTypeHints: getFieldTypeHints,
+    guessDelimiter: guessDelimiter,
     importDelim: importDelim,
     importDelim2: importDelim2,
-    isSupportedDelimiter: isSupportedDelimiter,
-    guessDelimiter: guessDelimiter,
-    getFieldTypeHints: getFieldTypeHints,
-    adjustRecordTypes: adjustRecordTypes
+    isSupportedDelimiter: isSupportedDelimiter
   });
   function validateInputOpts(cmd) {
@@ -23745,14 +23781,14 @@ ${svg}
   var OptionParsingUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    splitShellTokens: splitShellTokens,
-    parseNumberList: parseNumberList,
-    parseStringList: parseStringList,
-    parseColorList: parseColorList,
     cleanArgv: cleanArgv,
     formatOptionValue: formatOptionValue,
     isAssignment: isAssignment,
-    splitAssignment: splitAssignment
+    parseColorList: parseColorList,
+    parseNumberList: parseNumberList,
+    parseStringList: parseStringList,
+    splitAssignment: splitAssignment,
+    splitShellTokens: splitShellTokens
   });
   function CommandParser() {
@@ -25316,6 +25352,14 @@ ${svg}
         describe: '(polygon-polygon join) use max overlap to join one polygon',
         type: 'flag'
       })
+      .option('min-overlap-pct', {
+        describe: '(polygon-polygon join) min overlap as pct of target polygon',
+        type: 'percent'
+      })
+      .option('min-overlap-area', {
+        describe: '(polygon-polygon join) minimum area of overlap',
+        type: 'area'
+      })
       // .option('nearest-point', {
       //   describe: '(point-point join)',
       //   type: 'flag'
@@ -25754,6 +25798,10 @@ ${svg}
     parser.command('style')
       .oldAlias('svg-style')
       .describe('set SVG style properties using JS or literal values')
+      .option('clear', {
+        describe: 'remove all style properties from a layer',
+        type: 'flag'
+      })
       .option('where', whereOpt)
       .option('class', {
         describe: 'name of CSS class or classes (space-separated)'
@@ -26968,8 +27016,8 @@ ${svg}
   var DbfImport = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    importDbfTable: importDbfTable,
-    ShapefileTable: ShapefileTable
+    ShapefileTable: ShapefileTable,
+    importDbfTable: importDbfTable
   });
   function translateShapefileType(shpType) {
@@ -26990,8 +27038,8 @@ ${svg}
   var ShpCommon = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    translateShapefileType: translateShapefileType,
-    isSupportedShapefileType: isSupportedShapefileType
+    isSupportedShapefileType: isSupportedShapefileType,
+    translateShapefileType: translateShapefileType
   });
   function getNullRecord(id) {
@@ -27704,9 +27752,9 @@ ${svg}
   var PathImport = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    PathImporter: PathImporter,
     cleanPathsAfterImport: cleanPathsAfterImport,
-    pointHasValidCoords: pointHasValidCoords,
-    PathImporter: PathImporter
+    pointHasValidCoords: pointHasValidCoords
   });
   // Read Shapefile data from a file, ArrayBuffer or Buffer
@@ -27914,9 +27962,9 @@ ${svg}
   var GeojsonImport = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    importGeoJSON: importGeoJSON,
     GeoJSONParser: GeoJSONParser,
-    importCRS: importCRS
+    importCRS: importCRS,
+    importGeoJSON: importGeoJSON
   });
   // Convert a TopoJSON topology into mapshaper's internal format
@@ -28842,8 +28890,8 @@ ${svg}
   var JsonImport = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    identifyJSONString: identifyJSONString,
     identifyJSONObject: identifyJSONObject,
+    identifyJSONString: identifyJSONString,
     importGeoJSONFile: importGeoJSONFile,
     importJSON: importJSON
   });
@@ -29088,8 +29136,8 @@ ${svg}
   var Unpack = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    unpackSessionData: unpackSessionData,
-    restoreSessionData: restoreSessionData
+    restoreSessionData: restoreSessionData,
+    unpackSessionData: unpackSessionData
   });
   cmd.importFiles = async function(catalog, opts) {
@@ -29345,9 +29393,9 @@ ${svg}
   var FileImport = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    replaceImportFile: replaceImportFile,
     importFile: importFile,
-    importFilesTogether: importFilesTogether
+    importFilesTogether: importFilesTogether,
+    replaceImportFile: replaceImportFile
   });
   function convertSourceName(name, targets) {
@@ -29397,8 +29445,8 @@ ${svg}
   var SourceUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    convertSourceName: convertSourceName,
     convertInterpolatedName: convertInterpolatedName,
+    convertSourceName: convertSourceName,
     findCommandSource: findCommandSource
   });
@@ -30737,13 +30785,13 @@ ${svg}
   var BufferCommon = /*#__PURE__*/Object.freeze({
     __proto__: null,
     dissolveBufferDataset: dissolveBufferDataset,
-    getBufferToleranceFromCircleSegments: getBufferToleranceFromCircleSegments,
     getArcDegreesFromTolerancePct: getArcDegreesFromTolerancePct,
-    getBufferToleranceFromCircleSegments2: getBufferToleranceFromCircleSegments2,
     getArcDegreesFromTolerancePct2: getArcDegreesFromTolerancePct2,
-    parseConstantBufferDistance: parseConstantBufferDistance,
+    getBufferDistanceFunction: getBufferDistanceFunction,
+    getBufferToleranceFromCircleSegments: getBufferToleranceFromCircleSegments,
+    getBufferToleranceFromCircleSegments2: getBufferToleranceFromCircleSegments2,
     getBufferToleranceFunction: getBufferToleranceFunction,
-    getBufferDistanceFunction: getBufferDistanceFunction
+    parseConstantBufferDistance: parseConstantBufferDistance
   });
   // Returns a function for generating GeoJSON geometries (MultiLineString or MultiPolygon)
@@ -30973,9 +31021,9 @@ ${svg}
   var PathBuffer = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    getPolylineBufferMaker: getPolylineBufferMaker,
     addBufferVertex: addBufferVertex,
-    bufferIntersection: bufferIntersection
+    bufferIntersection: bufferIntersection,
+    getPolylineBufferMaker: getPolylineBufferMaker
   });
   function getPolylineBufferMaker2(arcs, geod, getBearing, opts) {
@@ -31352,14 +31400,14 @@ ${svg}
   var Geodesic = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    interpolatePoint2D: interpolatePoint2D,
-    getInterpolationFunction: getInterpolationFunction,
-    getPlanarSegmentEndpoint: getPlanarSegmentEndpoint,
-    getGeodeticSegmentFunction: getGeodeticSegmentFunction,
-    getFastGeodeticSegmentFunction: getFastGeodeticSegmentFunction,
     bearingDegrees: bearingDegrees,
     bearingDegrees2D: bearingDegrees2D,
-    getBearingFunction: getBearingFunction
+    getBearingFunction: getBearingFunction,
+    getFastGeodeticSegmentFunction: getFastGeodeticSegmentFunction,
+    getGeodeticSegmentFunction: getGeodeticSegmentFunction,
+    getInterpolationFunction: getInterpolationFunction,
+    getPlanarSegmentEndpoint: getPlanarSegmentEndpoint,
+    interpolatePoint2D: interpolatePoint2D
   });
   function makePolylineBuffer(lyr, dataset, opts) {
@@ -31729,7 +31777,7 @@ ${svg}
   // Make a single geodetic circle
   function getCircleGeoJSON(center, radius, vertices, opts) {
-    var n = vertices || 360;
+    var n = 360;
     var geod = getGeodeticSegmentFunction(parseCrsString('wgs84')); // ?
     if (opts.inset) {
       radius -= opts.inset;
@@ -32399,10 +32447,10 @@ ${svg}
   const degrees = 180 / Math.PI;
   var A = -0.14861,
-      B = +1.78277,
+      B = 1.78277,
       C = -0.29227,
       D = -0.90649,
-      E = +1.97294,
+      E = 1.97294,
       ED = E * D,
       EB = E * B,
       BC_DA = B * C - D * A;
@@ -33394,18 +33442,22 @@ ${svg}
   function getCategoricalClassifier(classValues, nullVal, opts) {
     // categories: strings to match in the data
     var categories = opts.categories;
+    // index categories for better performance on datasets with many categories
+    var index = categories.reduce((memo, key, i) => {
+      memo[key] = i;
+      return memo;
+    }, {});
     var classToValue = getDiscreteValueGetter(classValues, nullVal, opts.other);
     return function(val) {
-      var i = categories.indexOf(val);
-      var idx = -1;
-      if (i >= 0) {
-        idx = i;
-      } else if (val) {
-        idx = -2; // field contains an 'other' value
+      var i;
+      if (val in index) {
+        i = index[val];
+      } else if (val || val === 0) {
+        i = -2; // -2 indicates an 'other' value
       } else {
-        idx = -1; // field is empty (null value)
+        i = -1; // field is empty (null value)
       }
-      return classToValue(idx);
+      return classToValue(i);
     };
   }
@@ -33550,8 +33602,8 @@ ${svg}
   var PolygonNeighbors = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    getNeighborLookupFunction: getNeighborLookupFunction,
-    findPairsOfNeighbors: findPairsOfNeighbors
+    findPairsOfNeighbors: findPairsOfNeighbors,
+    getNeighborLookupFunction: getNeighborLookupFunction
   });
   function getNonAdjacentClassifier(lyr, dataset, colors) {
@@ -34171,81 +34223,81 @@ ${svg}
   var d3Scales = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    schemeCategory10: category10,
-    schemeAccent: Accent,
-    schemeDark2: Dark2,
-    schemePaired: Paired,
-    schemePastel1: Pastel1,
-    schemePastel2: Pastel2,
-    schemeSet1: Set1,
-    schemeSet2: Set2,
-    schemeSet3: Set3,
-    schemeTableau10: Tableau10,
+    interpolateBlues: Blues,
     interpolateBrBG: BrBG,
-    schemeBrBG: scheme$q,
+    interpolateBuGn: BuGn,
+    interpolateBuPu: BuPu,
+    interpolateCividis: cividis,
+    interpolateCool: cool,
+    interpolateCubehelixDefault: cubehelix,
+    interpolateGnBu: GnBu,
+    interpolateGreens: Greens,
+    interpolateGreys: Greys,
+    interpolateInferno: inferno,
+    interpolateMagma: magma,
+    interpolateOrRd: OrRd,
+    interpolateOranges: Oranges,
     interpolatePRGn: PRGn,
-    schemePRGn: scheme$p,
     interpolatePiYG: PiYG,
-    schemePiYG: scheme$o,
+    interpolatePlasma: plasma,
+    interpolatePuBu: PuBu,
+    interpolatePuBuGn: PuBuGn,
     interpolatePuOr: PuOr,
-    schemePuOr: scheme$n,
+    interpolatePuRd: PuRd,
+    interpolatePurples: Purples,
+    interpolateRainbow: rainbow,
     interpolateRdBu: RdBu,
-    schemeRdBu: scheme$m,
     interpolateRdGy: RdGy,
-    schemeRdGy: scheme$l,
+    interpolateRdPu: RdPu,
     interpolateRdYlBu: RdYlBu,
-    schemeRdYlBu: scheme$k,
     interpolateRdYlGn: RdYlGn,
-    schemeRdYlGn: scheme$j,
+    interpolateReds: Reds,
+    interpolateSinebow: sinebow,
     interpolateSpectral: Spectral,
-    schemeSpectral: scheme$i,
-    interpolateBuGn: BuGn,
+    interpolateTurbo: turbo,
+    interpolateViridis: viridis,
+    interpolateWarm: warm,
+    interpolateYlGn: YlGn,
+    interpolateYlGnBu: YlGnBu,
+    interpolateYlOrBr: YlOrBr,
+    interpolateYlOrRd: YlOrRd,
+    schemeAccent: Accent,
+    schemeBlues: scheme$5,
+    schemeBrBG: scheme$q,
     schemeBuGn: scheme$h,
-    interpolateBuPu: BuPu,
     schemeBuPu: scheme$g,
-    interpolateGnBu: GnBu,
+    schemeCategory10: category10,
+    schemeDark2: Dark2,
     schemeGnBu: scheme$f,
-    interpolateOrRd: OrRd,
+    schemeGreens: scheme$4,
+    schemeGreys: scheme$3,
     schemeOrRd: scheme$e,
-    interpolatePuBuGn: PuBuGn,
-    schemePuBuGn: scheme$d,
-    interpolatePuBu: PuBu,
+    schemeOranges: scheme,
+    schemePRGn: scheme$p,
+    schemePaired: Paired,
+    schemePastel1: Pastel1,
+    schemePastel2: Pastel2,
+    schemePiYG: scheme$o,
     schemePuBu: scheme$c,
-    interpolatePuRd: PuRd,
+    schemePuBuGn: scheme$d,
+    schemePuOr: scheme$n,
     schemePuRd: scheme$b,
-    interpolateRdPu: RdPu,
+    schemePurples: scheme$2,
+    schemeRdBu: scheme$m,
+    schemeRdGy: scheme$l,
     schemeRdPu: scheme$a,
-    interpolateYlGnBu: YlGnBu,
-    schemeYlGnBu: scheme$9,
-    interpolateYlGn: YlGn,
+    schemeRdYlBu: scheme$k,
+    schemeRdYlGn: scheme$j,
+    schemeReds: scheme$1,
+    schemeSet1: Set1,
+    schemeSet2: Set2,
+    schemeSet3: Set3,
+    schemeSpectral: scheme$i,
+    schemeTableau10: Tableau10,
     schemeYlGn: scheme$8,
-    interpolateYlOrBr: YlOrBr,
+    schemeYlGnBu: scheme$9,
     schemeYlOrBr: scheme$7,
-    interpolateYlOrRd: YlOrRd,
-    schemeYlOrRd: scheme$6,
-    interpolateBlues: Blues,
-    schemeBlues: scheme$5,
-    interpolateGreens: Greens,
-    schemeGreens: scheme$4,
-    interpolateGreys: Greys,
-    schemeGreys: scheme$3,
-    interpolatePurples: Purples,
-    schemePurples: scheme$2,
-    interpolateReds: Reds,
-    schemeReds: scheme$1,
-    interpolateOranges: Oranges,
-    schemeOranges: scheme,
-    interpolateCividis: cividis,
-    interpolateCubehelixDefault: cubehelix,
-    interpolateRainbow: rainbow,
-    interpolateWarm: warm,
-    interpolateCool: cool,
-    interpolateSinebow: sinebow,
-    interpolateTurbo: turbo,
-    interpolateViridis: viridis,
-    interpolateMagma: magma,
-    interpolateInferno: inferno,
-    interpolatePlasma: plasma
+    schemeYlOrRd: scheme$6
   });
   var index = {
@@ -34274,7 +34326,6 @@ ${svg}
     addCategoricalScheme('Tableau20',
       '4c78a89ecae9f58518ffbf7954a24b88d27ab79a20f2cf5b43989483bcb6e45756ff9d9879706ebab0acd67195fcbfd2b279a2d6a5c99e765fd8b5a5');
     index.all = [].concat(index.sequential, index.rainbow, index.diverging, index.categorical);
   }
   function standardName(name) {
@@ -34288,8 +34339,15 @@ ${svg}
     return null;
   }
-  function addSchemesFromD3(type, names) {
-    index[type] = index[type].concat(names.split(','));
+  function addSchemesFromD3(type, namesStr) {
+    var names = namesStr.split(',');
+    index[type] = index[type].concat(names);
+    if (type == 'categorical') {
+      // copy categorical colors for simplicity
+      names.forEach(name => {
+        ramps[name] = d3Scales['scheme' + name];
+      });
+    }
   }
   function addCategoricalScheme(name, str) {
@@ -34343,16 +34401,14 @@ ${svg}
     initSchemes();
     var names = index[type];
     if (!names) error('Unknown color scheme type:', type);
-    var i = Math.floor(Math.random() * names.length);
-    return names[i];
+    return utils.pickOne(names);
   }
-  function getRandomColors(n) {
+  function pickRandomCategoricalScheme(n) {
     initSchemes();
-    var colors = getCategoricalColorScheme('Tableau20', 20);
-    utils.shuffle(colors);
-    colors = wrapColors(colors, n);
-    return colors.slice(0, n);
+    var minSize = Math.min(n, 20); // use largest available if n is too large
+    var schemes = index.categorical.filter(name => ramps[name].length >= minSize);
+    return utils.pickOne(schemes) || 'Tableau20';
   }
   function getCategoricalColorScheme(name, n) {
@@ -34461,10 +34517,11 @@ ${svg}
     if (colorArg == 'random') {
       if (categorical) {
-        return getRandomColors(n);
+        colorScheme = pickRandomCategoricalScheme(n);
+      } else {
+        colorScheme = pickRandomColorScheme('sequential');
       }
-      colorScheme = pickRandomColorScheme('sequential');
-      message('Randomly selected color ramp:', colorScheme);
+      message('Randomly selected color scheme:', colorScheme);
     } else if (isColorSchemeName(colorArg)) {
       colorScheme = colorArg;
     } else if (colorArg && !parseColor(colorArg)) {
@@ -34971,7 +35028,7 @@ ${svg}
     // Need to expose clip/erase routes in both directions by setting route
     // in both directions to visible -- this is how cut-out shapes are detected
     // Or-ing with 0x11 makes both directions visible (so reverse paths will block)
-    openArcRoutes(clipShapes, arcs, clipFlags, type == 'clip', type == 'erase', !!"dissolve", 0x11);
+    openArcRoutes(clipShapes, arcs, clipFlags, type == 'clip', type == 'erase', true, 0x11);
     var index = new PathIndex(clipShapes, arcs);
     var clippedShapes = targetShapes.map(function(shape, i) {
       if (shape) {
@@ -35387,8 +35444,8 @@ ${svg}
   var Bbox2Clipping = /*#__PURE__*/Object.freeze({
     __proto__: null,
     divideDatasetByBBox: divideDatasetByBBox,
-    segmentOutsideBBox: segmentOutsideBBox,
-    segmentInsideBBox: segmentInsideBBox
+    segmentInsideBBox: segmentInsideBBox,
+    segmentOutsideBBox: segmentOutsideBBox
   });
   cmd.clipLayers = function(target, src, dataset, opts) {
@@ -35554,10 +35611,10 @@ ${svg}
   var ClipErase = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    clipLayersInPlace: clipLayersInPlace,
     clipLayers: clipLayers,
     clipLayersByBBox: clipLayersByBBox,
     clipLayersByLayer: clipLayersByLayer,
+    clipLayersInPlace: clipLayersInPlace,
     getClipMessage: getClipMessage
   });
@@ -36474,10 +36531,10 @@ ${svg}
   var Info = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    getLayerInfo: getLayerInfo,
-    getAttributeTableInfo: getAttributeTableInfo,
     formatAttributeTableInfo: formatAttributeTableInfo,
-    formatTableValue: formatTableValue
+    formatTableValue: formatTableValue,
+    getAttributeTableInfo: getAttributeTableInfo,
+    getLayerInfo: getLayerInfo
   });
   // import { importGeoJSON } from '../geojson/geojson-import';
@@ -36717,7 +36774,7 @@ ${svg}
   // Join data from @src table to records in @destLyr layer.
   // @join function
-  //    Receives index of record in the dest table
+  //    Receives index of one record in the dest table
   //    Returns array of matching records in src table, or null if no matches
   //
   function joinTableToLayer(destLyr, src, join, opts) {
@@ -36743,7 +36800,7 @@ ${svg}
         collisionFields = [],
         skipCount = 0,
         retn = {},
-        srcRec, srcId, destRec, joins, count, filter, calc, i, j, n, m;
+        srcRec, srcId, destRec, joinIds, count, filter, calc, i, j, n, m;
     // support for duplication of destination records for many-to-one joins
     var duplicateRecords, destShapes;
@@ -36765,14 +36822,14 @@ ${svg}
     n = destRecords.length;
     for (i=0; i<n; i++) {
       destRec = destRecords[i];
-      joins = join(i);
-      if (joins && filter) {
-        skipCount += joins.length;
-        joins = filter(joins, destRec);
-        skipCount -= joins.length;
-      }
-      for (j=0, count=0, m=joins ? joins.length : 0; j<m; j++) {
-        srcId = joins[j];
+      joinIds = join(i);
+      if (joinIds && filter) {
+        skipCount += joinIds.length;
+        joinIds = filter(joinIds, destRec);
+        skipCount -= joinIds.length;
+      }
+      for (j=0, count=0, m=joinIds ? joinIds.length : 0; j<m; j++) {
+        srcId = joinIds[j];
         srcRec = srcRecords[srcId];
         // duplication mode: many-to-one joins add new features to the target layer.
         if (count > 0 && useDuplication) {
@@ -36798,7 +36855,7 @@ ${svg}
         count++;
       }
       if (calc) {
-        calc(joins, destRec);
+        calc(joinIds, destRec);
       }
       if (count > 0) {
         matchCount++;
@@ -36964,12 +37021,12 @@ ${svg}
   var JoinTables = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    joinTables: joinTables,
+    findCollisionFields: findCollisionFields,
+    getFieldsToJoin: getFieldsToJoin,
     joinTableToLayer: joinTableToLayer,
-    validateFieldNames: validateFieldNames,
+    joinTables: joinTables,
     updateUnmatchedRecord: updateUnmatchedRecord,
-    findCollisionFields: findCollisionFields,
-    getFieldsToJoin: getFieldsToJoin
+    validateFieldNames: validateFieldNames
   });
   cmd.divide = function(targetLayers, targetDataset, source, opts) {
@@ -37989,8 +38046,8 @@ ${svg}
   var FilterGeom = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    getBBoxIntersectionTest: getBBoxIntersectionTest,
-    findShapesIntersectingBBox: findShapesIntersectingBBox
+    findShapesIntersectingBBox: findShapesIntersectingBBox,
+    getBBoxIntersectionTest: getBBoxIntersectionTest
   });
   cmd.filterFeatures = function(lyr, arcs, opts) {
@@ -38057,7 +38114,6 @@ ${svg}
     utils.repeat(n, function(shapeId) {
       var result = filter(shapeId);
       requireBooleanResult(result);
-      if (invert) result = !result;
       if (result === true) {
         if (shapes) filteredShapes.push(shapes[shapeId] || null);
         if (records) filteredRecords.push(records[shapeId] || null);
@@ -38377,7 +38433,6 @@ ${svg}
     var coords = [];
     var ascending = a[1] < b[1];
     if (a[0] != b[0]) error('Expected an edge segment');
-    if (interval > 0 === false) error('Expected a positive interval');
     if (ascending) {
       y1 = a[1];
       y2 = b[1];
@@ -39159,10 +39214,10 @@ ${svg}
   var PointPolygonJoin = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    getPolygonToPointsFunction: getPolygonToPointsFunction,
     joinPointsToPolygons: joinPointsToPolygons,
     joinPolygonsToPoints: joinPolygonsToPoints,
-    prepJoinLayers: prepJoinLayers,
-    getPolygonToPointsFunction: getPolygonToPointsFunction
+    prepJoinLayers: prepJoinLayers
   });
   // This is a special-purpose function designed to copy a data field from a points
@@ -39810,9 +39865,9 @@ ${svg}
   var Lines = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    polygonsToLines: polygonsToLines,
     createLineLayer: createLineLayer,
-    extractInnerLines: extractInnerLines
+    extractInnerLines: extractInnerLines,
+    polygonsToLines: polygonsToLines
   });
   function getClippingDataset(src, dest, opts) {
@@ -40116,8 +40171,8 @@ ${svg}
   var ProjectionParams = /*#__PURE__*/Object.freeze({
     __proto__: null,
     expandProjDefn: expandProjDefn,
-    getConicParams: getConicParams,
-    getCenterParams: getCenterParams
+    getCenterParams: getCenterParams,
+    getConicParams: getConicParams
   });
   cmd.proj = function(dataset, catalog, opts) {
@@ -40315,12 +40370,12 @@ ${svg}
   var Proj = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    fetchCrsInfo: fetchCrsInfo,
-    projectDataset: projectDataset,
     cleanProjectedPathLayers: cleanProjectedPathLayers,
-    projectPointLayer: projectPointLayer,
+    fetchCrsInfo: fetchCrsInfo,
     projectArcs: projectArcs,
-    projectArcs2: projectArcs2
+    projectArcs2: projectArcs2,
+    projectDataset: projectDataset,
+    projectPointLayer: projectPointLayer
   });
   cmd.graticule = function(dataset, opts) {
@@ -40753,16 +40808,18 @@ ${svg}
     targetDataset.arcs = mergedDataset.arcs;
     prepJoinLayers(targetLyr, sourceLyr);
     var mergedLyr = {
-      geometry_type: 'polygon',
       shapes: targetLyr.shapes.concat(sourceLyr.shapes)
     };
     // make a mosaic from merged shapes of both layers
     var mosaicIndex = new MosaicIndex(mergedLyr, nodes, {flat: false});
     var joinOpts = utils.extend({}, opts);
-    var joinFunction = getPolygonToPolygonFunction(targetLyr, sourceLyr, mosaicIndex, opts);
-    var retn = joinTableToLayer(targetLyr, sourceLyr.data, joinFunction, joinOpts);
+    if (joinOpts.min_overlap_area) {
+      // convert area arg to square meters (typically)
+      joinOpts.min_overlap_area = convertAreaParam(joinOpts.min_overlap_area, getDatasetCRS(targetDataset));
+    }
+    var joinFunction = getPolygonToPolygonFunction(targetLyr, sourceLyr, mosaicIndex, joinOpts);
+    var retn = joinTableToLayer(targetLyr, sourceLyr.data, joinFunction, joinOpts);
     if (opts.interpolate) {
       if (opts.duplication) stop('duplication and interpolate options cannot be used together');
       interpolateFieldsByArea(targetLyr, sourceLyr, mosaicIndex, opts);
@@ -40776,6 +40833,22 @@ ${svg}
     var sourceFields = opts.interpolate;
     var sourceRecords = sourceLyr.data.getRecords();
+    // Use different interpolation methods for qualitative and quantitative data
+    // Assumes string and boolean fields are qualitative and numeric fields are
+    //   quantitative (TODO: somehow recognize numeric index data as qualitative)
+    var quantitativeFields = [];
+    var qualitativeFields = [];
+    sourceFields.forEach(function(field) {
+      var type = getColumnType(field, sourceRecords);
+      if (type == 'number') {
+        quantitativeFields.push(field);
+      } else if (type == 'string' || type == 'boolean') {
+        qualitativeFields.push(field);
+      } else {
+        message(`"${field}" field appears to contain ${type}-type data. No interpolation method is available.`);
+      }
+    });
     // for each destination polygon, calculate interpolated values,
     // using the data calculated in previous steps
     destLyr.data.getRecords().forEach(function(destRec, destId) {
@@ -40784,9 +40857,13 @@ ${svg}
       for (i=0; i<tileIds.length; i++) {
         tileRecords.push(mosaicRecords[tileIds[i]]);
       }
-      for (i=0; i<sourceFields.length; i++) {
+      for (i=0; i<quantitativeFields.length; i++) {
         field = sourceFields[i];
-        destRec[field] = getInterpolatedValue(field, tileRecords, sourceRecords);
+        destRec[field] = getInterpolatedNumber(field, tileRecords, sourceRecords);
+      }
+      for (i=0; i<qualitativeFields.length; i++) {
+        field = sourceFields[i];
+        destRec[field] = getInterpolatedCategory(field, tileRecords, sourceRecords);
       }
     });
   }
@@ -40839,7 +40916,7 @@ ${svg}
   //   return value;
   // }
-  function getInterpolatedValue(field, tileRecords, sourceRecords) {
+  function getInterpolatedNumber(field, tileRecords, sourceRecords) {
     var value = 0, tileRec, sourceRec, sourceId;
     for (var i=0; i<tileRecords.length; i++) {
       tileRec = tileRecords[i];
@@ -40853,6 +40930,31 @@ ${svg}
     return value;
   }
+  function getInterpolatedCategory(field, tileRecords, sourceRecords) {
+    var value, tileRec, sourceRec, sourceId, idx;
+    var areas = [];
+    var values = [];
+    for (var i=0; i<tileRecords.length; i++) {
+      tileRec = tileRecords[i];
+      if (!tileRec.sourceIds) continue;
+      for (var j=0; j<tileRec.sourceIds.length; j++) {
+        sourceId = tileRec.sourceIds[j];
+        sourceRec = sourceRecords[sourceId];
+        value = sourceRec[field];
+        idx = values.indexOf(value);
+        if (idx == -1) {
+          values.push(value);
+          areas.push(tileRec.area);
+        } else {
+          areas[idx] += tileRec.area;
+        }
+      }
+    }
+    var maxArea = Math.max.apply(null, areas);
+    var maxIdx = areas.indexOf(maxArea);
+    return maxIdx == -1 ? null : values[maxIdx];
+  }
   function getIdConversionFunction(offset, length) {
     return function (mergedIds) {
@@ -40865,17 +40967,50 @@ ${svg}
     };
   }
-  function getMaxOverlapFunction(destLyr, srcLyr, mosaicIndex) {
-    var arcs = mosaicIndex.nodes.arcs;
+  function getMinPctFunction(minPct, destLyr, mosaicIndex) {
+    mosaicIndex.nodes.arcs;
     var destLen = destLyr.shapes.length;
-    function getTotalArea(tileIds) {
-      var area = 0;
-      for (var i=0; i<tileIds.length; i++) {
-        area += geom.getShapeArea(mosaicIndex.mosaic[tileIds[i]], arcs);
-      }
-      return area;
+    return function(destId, srcIds) {
+      var destTileIds = mosaicIndex.getTileIdsByShapeId(destId);
+      var destArea = getAreaOfTiles(destTileIds, mosaicIndex);
+      return srcIds.filter(function(srcId, i) {
+        var srcTileIds = mosaicIndex.getTileIdsByShapeId(srcId + destLen);
+        var sharedIds = utils.intersection(destTileIds, srcTileIds);
+        var overlapArea = getAreaOfTiles(sharedIds, mosaicIndex);
+        var overlapPct = overlapArea / destArea || 0;
+        return overlapPct >= minPct;
+      });
+    };
+  }
+  function getMinAreaFunction(minArea, destLyr, mosaicIndex) {
+    mosaicIndex.nodes.arcs;
+    var destLen = destLyr.shapes.length;
+    return function(destId, srcIds) {
+      var destTileIds = mosaicIndex.getTileIdsByShapeId(destId);
+      return srcIds.filter(function(srcId, i) {
+        var srcTileIds = mosaicIndex.getTileIdsByShapeId(srcId + destLen);
+        var sharedIds = utils.intersection(destTileIds, srcTileIds);
+        var overlapArea = getAreaOfTiles(sharedIds, mosaicIndex);
+        return overlapArea >= minArea;
+      });
+    };
+  }
+  function getAreaOfTiles(tileIds, mosaicIndex) {
+    var arcs = mosaicIndex.nodes.arcs;
+    var area = 0;
+    for (var i=0; i<tileIds.length; i++) {
+      area += geom.getShapeArea(mosaicIndex.mosaic[tileIds[i]], arcs);
     }
+    return area;
+  }
+  function getMaxOverlapFunction(destLyr, mosaicIndex) {
+    var destLen = destLyr.shapes.length;
     return function(destId, srcIds) {
       var destTileIds = mosaicIndex.getTileIdsByShapeId(destId);
@@ -40884,7 +41019,7 @@ ${svg}
       srcIds.forEach(function(srcId, i) {
         var srcTileIds = mosaicIndex.getTileIdsByShapeId(srcId + destLen);
         var sharedIds = utils.intersection(destTileIds, srcTileIds);
-        var area = getTotalArea(sharedIds);
+        var area = getAreaOfTiles(sharedIds, mosaicIndex);
         if (area >= maxArea) {
           maxId = srcId;
           maxArea = area;
@@ -40897,14 +41032,21 @@ ${svg}
   // Returned function converts a target layer feature id to multiple source feature ids
-  // TODO: option to join the source polygon with the greatest overlapping area
   // TODO: option to ignore source polygon with small overlaps
   //       (as a percentage of the area of one or the other polygon?)
   function getPolygonToPolygonFunction(targetLyr, srcLyr, mosaicIndex, opts) {
     var mergedToSourceIds = getIdConversionFunction(targetLyr.shapes.length, srcLyr.shapes.length);
     var selectMaxOverlap;
+    var minAreaFilter;
+    var minPctFilter;
     if (opts.largest_overlap) {
-      selectMaxOverlap = getMaxOverlapFunction(targetLyr, srcLyr, mosaicIndex);
+      selectMaxOverlap = getMaxOverlapFunction(targetLyr, mosaicIndex);
+    }
+    if (opts.min_overlap_pct) {
+      minPctFilter = getMinPctFunction(opts.min_overlap_pct, targetLyr, mosaicIndex);
+    }
+    if (opts.min_overlap_area) {
+      minAreaFilter = getMinAreaFunction(opts.min_overlap_area, targetLyr, mosaicIndex);
     }
     return function(targId) {
@@ -40919,6 +41061,12 @@ ${svg}
       if (sourceIds.length > 1 && opts.largest_overlap) {
         sourceIds = selectMaxOverlap(targId, sourceIds);
       }
+      if (minAreaFilter) {
+        sourceIds = minAreaFilter(targId, sourceIds);
+      }
+      if (minPctFilter) {
+        sourceIds = minPctFilter(targId, sourceIds);
+      }
       return sourceIds;
     };
   }
@@ -40929,7 +41077,7 @@ ${svg}
   function polylineToMidpoints(shp, arcs, opts) {
     if (!shp) return null;
     var points = shp.map(function(path) {
-      return findPathMidpoint(path, arcs, false);
+      return findPathMidpoint(path, arcs);
     });
     return points;
   }
@@ -40951,9 +41099,6 @@ ${svg}
       var k;
       if (partialLen + segLen >= halfLen) {
         k = (halfLen - partialLen) / segLen;
-        if (useNearestVertex) {
-          k = k < 0.5 ? 0 : 1;
-        }
         // p = [a + k * (c - a), b + k * (d - b)];
         p = [(1 - k) * a + k * c, (1 - k) * b + k * d];
       }
@@ -41262,10 +41407,10 @@ ${svg}
   var Points = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    pointsFromPolygons: pointsFromPolygons,
     coordinateFromValue: coordinateFromValue,
     findXField: findXField,
-    findYField: findYField
+    findYField: findYField,
+    pointsFromPolygons: pointsFromPolygons
   });
   function joinPolygonsViaPoints(targetLyr, targetDataset, source, opts) {
@@ -41433,6 +41578,7 @@ ${svg}
   THIS SOFTWARE.
   */
   var earthRadius = 6371;
   var rad = Math.PI / 180;
@@ -41450,7 +41596,6 @@ ${svg}
           left: 0, // left index in the kd-tree array
           right: index.ids.length - 1, // right index
           axis: 0, // 0 for longitude axis and 1 for latitude axis
-          dist: 0, // will hold the lower bound of children's distances to the query point
           minLng: -180, // bounding box of the node
           minLat: -90,
           maxLng: 180,
@@ -41469,7 +41614,7 @@ ${svg}
               // add all points of the leaf node to the queue
               for (var i = left; i <= right; i++) {
                   item = index.points[index.ids[i]];
-                  if (!predicate || predicate(item)) {
+                  {
                       q.push({
                           i: index.ids[i],
                           item: item,
@@ -41486,7 +41631,7 @@ ${svg}
               // add middle point to the queue
               item = index.points[index.ids[m]];
-              if (!predicate || predicate(item)) {
+              {
                   q.push({
                       i: index.ids[m],
                       item: item,
@@ -41831,8 +41976,6 @@ ${svg}
   //
   function getHexGridMaker(bbox, interval, opts) {
     var flatTop = opts.type != 'hex2'; // hex2 is "pointy-top" orientation
-    // origin cell (bottom left) may be "outie" or "innie" ... could be settable
-    var outieOrigin = true;
     var minorInterval = interval * Math.sqrt(3) / 2;
     var _colCounts = _getColCounts(bbox, interval);
     var _rowCounts = _getRowCounts(bbox, interval);
@@ -41990,7 +42133,7 @@ ${svg}
     }
     function _isUpperCell(col) {
-      return isOdd(col) || !outieOrigin ;
+      return isOdd(col) || false;
     }
     function _idxToPoint(id) {
@@ -42602,8 +42745,7 @@ ${svg}
     var empty = [];
     points.forEach(function(p) {
       var bbox = getPointBounds(p, radius);
-      var addNeighbors = true; // TODO: only if radius is > 0?
-      addPointToGridIndex(p, gridIndex, grid, addNeighbors);
+      addPointToGridIndex(p, gridIndex, grid);
       bboxIndex.add.apply(bboxIndex, bbox);
     });
     bboxIndex.finish();
@@ -42627,7 +42769,7 @@ ${svg}
     var i = grid.pointToIdx(p);
     var [c, r] = grid.idxToColRow(i);
     addCellToGridIndex(c, r, grid, index);
-    if (addNeighbors) {
+    {
       grid.forEachNeighbor(c, r, function(c, r) {
         addCellToGridIndex(c, r, grid, index);
       });
@@ -42745,9 +42887,9 @@ ${svg}
   var PointToGrid = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    getPointCircleRadius: getPointCircleRadius,
     calcCellProperties: calcCellProperties,
-    calcWeights: calcWeights
+    calcWeights: calcWeights,
+    getPointCircleRadius: getPointCircleRadius
   });
   function closeUndershoots(lyr, dataset, opts) {
@@ -43177,8 +43319,8 @@ ${svg}
   var ParseCommands = /*#__PURE__*/Object.freeze({
     __proto__: null,
     parseCommands: parseCommands,
-    standardizeConsoleCommands: standardizeConsoleCommands,
-    parseConsoleCommands: parseConsoleCommands
+    parseConsoleCommands: parseConsoleCommands,
+    standardizeConsoleCommands: standardizeConsoleCommands
   });
   function getIOProxy(job) {
@@ -43684,7 +43826,7 @@ ${svg}
     // create a queue of unwind targets
     queue = getUnwindTargets(intersections, zlim, data.zz);
-    utils.sortOn(queue, 'z', !!"ascending");
+    utils.sortOn(queue, 'z', true);
     while (queue.length > 0) {
       target = queue.pop();
@@ -44122,9 +44264,8 @@ ${svg}
   }
   function protectContentEdges(arcs) {
-    var e = 1e-14;
     var bb = arcs.getBounds();
-    bb.padBounds(-e, -e, -e, -e);
+    bb.padBounds(-1e-14, -1e-14, -1e-14, -1e-14);
     limitSimplificationExtent(arcs, bb.toArray(), true);
   }
@@ -44239,17 +44380,17 @@ ${svg}
   var Simplify = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    finalizeSimplification: finalizeSimplification,
-    getStandardSimplifyOpts: getStandardSimplifyOpts,
-    useSphericalSimplify: useSphericalSimplify,
-    simplifyPaths: simplifyPaths,
-    getSimplifyMethod: getSimplifyMethod,
-    protectWorldEdges: protectWorldEdges,
-    parseSimplifyResolution: parseSimplifyResolution,
     calcPlanarInterval: calcPlanarInterval,
     calcSphericalInterval: calcSphericalInterval,
     convertSimplifyInterval: convertSimplifyInterval,
-    convertSimplifyResolution: convertSimplifyResolution
+    convertSimplifyResolution: convertSimplifyResolution,
+    finalizeSimplification: finalizeSimplification,
+    getSimplifyMethod: getSimplifyMethod,
+    getStandardSimplifyOpts: getStandardSimplifyOpts,
+    parseSimplifyResolution: parseSimplifyResolution,
+    protectWorldEdges: protectWorldEdges,
+    simplifyPaths: simplifyPaths,
+    useSphericalSimplify: useSphericalSimplify
   });
   cmd.sortFeatures = function(lyr, arcs, opts) {
@@ -44436,7 +44577,7 @@ ${svg}
   };
   cmd.svgStyle = function(lyr, dataset, opts) {
-    var filter;
+    var filterFn;
     if (getFeatureCount(lyr) === 0) {
       return;
     }
@@ -44444,7 +44585,10 @@ ${svg}
       initDataTable(lyr);
     }
     if (opts.where) {
-      filter = compileFeatureExpression(opts.where, lyr, dataset.arcs);
+      filterFn = compileFeatureExpression(opts.where, lyr, dataset.arcs);
+    }
+    if (opts.clear) {
+      lyr.data.getFields().filter(isSupportedSvgStyleProperty).forEach(lyr.data.deleteField, lyr.data);
     }
     Object.keys(opts).forEach(function(optName) {
       var svgName = optName.replace('_', '-'); // undo cli parser name conversion
@@ -44454,7 +44598,7 @@ ${svg}
       var strVal = opts[optName].trim();
       var accessor = getSymbolPropertyAccessor(strVal, svgName, lyr);
       getLayerDataTable(lyr).getRecords().forEach(function(rec, i) {
-        if (filter && !filter(i)) {
+        if (filterFn && !filterFn(i)) {
           // make sure field exists if record is excluded by filter
           if (svgName in rec === false) {
             rec[svgName] = undefined;
@@ -45083,7 +45227,6 @@ ${svg}
       return name + '_' + n;
     });
     var mergedLyr = {
-      geometry_type: 'polygon',
       shapes: allShapes
     };
     var mosaicIndex = new MosaicIndex(mergedLyr, nodes, {flat: false});
@@ -45898,7 +46041,7 @@ ${svg}
     });
   }
-  var version = "0.6.102";
+  var version = "0.6.104";
   // 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.
@@ -46222,12 +46365,12 @@ ${svg}
   var RunCommands = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    runCommands: runCommands,
     applyCommands: applyCommands,
+    runAndRemoveInfoCommands: runAndRemoveInfoCommands,
+    runCommands: runCommands,
     runCommandsXL: runCommandsXL,
-    testCommands: testCommands,
     runParsedCommands: runParsedCommands,
-    runAndRemoveInfoCommands: runAndRemoveInfoCommands
+    testCommands: testCommands
   });
   // Return an array containing points from a path iterator, clipped to a bounding box