mapshaper 0.6.103 → 0.6.105

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 (6) hide show
  1. package/mapshaper.js +588 -616
  2. package/package.json +5 -4
  3. package/www/basemap.js +2 -1
  4. package/www/mapshaper-gui.js +123 -112
  5. package/www/mapshaper.js +588 -616
  6. package/www/modules.js +7120 -1894
package/www/mapshaper.js CHANGED
@@ -2,105 +2,105 @@
2
2
 
3
3
  var utils = /*#__PURE__*/Object.freeze({
4
4
  __proto__: null,
5
+ get addThousandsSep () { return addThousandsSep; },
6
+ get addslashes () { return addslashes; },
7
+ get arrayToIndex () { return arrayToIndex; },
8
+ get clamp () { return clamp; },
9
+ get cleanNumericString () { return cleanNumericString; },
10
+ get contains () { return contains; },
11
+ get copyElements () { return copyElements; },
12
+ get countValues () { return countValues; },
13
+ get createBuffer () { return createBuffer; },
5
14
  get default () { return utils; },
15
+ get defaults () { return defaults; },
16
+ get difference () { return difference; },
17
+ get endsWith () { return endsWith; },
18
+ get every () { return every; },
19
+ get expandoBuffer () { return expandoBuffer; },
20
+ get extend () { return extend$1; },
21
+ get extendBuffer () { return extendBuffer; },
22
+ get find () { return find; },
23
+ get findMedian () { return findMedian; },
24
+ get findQuantile () { return findQuantile; },
25
+ get findRankByValue () { return findRankByValue; },
26
+ get findStringPrefix () { return findStringPrefix; },
27
+ get findValueByPct () { return findValueByPct; },
28
+ get findValueByRank () { return findValueByRank; },
29
+ get forEach () { return forEach; },
30
+ get forEachProperty () { return forEachProperty; },
31
+ get format () { return format; },
32
+ get formatDateISO () { return formatDateISO; },
33
+ get formatIntlNumber () { return formatIntlNumber; },
34
+ get formatNumber () { return formatNumber$1; },
35
+ get formatNumberForDisplay () { return formatNumberForDisplay; },
36
+ get formatVersionedName () { return formatVersionedName; },
37
+ get formatter () { return formatter; },
38
+ get genericSort () { return genericSort; },
39
+ get getArrayBounds () { return getArrayBounds; },
40
+ get getGenericComparator () { return getGenericComparator; },
41
+ get getKeyComparator () { return getKeyComparator; },
42
+ get getSortedIds () { return getSortedIds; },
6
43
  get getUniqueName () { return getUniqueName; },
7
- get isFunction () { return isFunction; },
8
- get isPromise () { return isPromise; },
9
- get isObject () { return isObject; },
10
- get clamp () { return clamp; },
44
+ get groupBy () { return groupBy; },
45
+ get htmlEscape () { return htmlEscape; },
46
+ get indexOf () { return indexOf; },
47
+ get indexOn () { return indexOn; },
48
+ get inherit () { return inherit; },
49
+ get initializeArray () { return initializeArray; },
50
+ get intersection () { return intersection; },
11
51
  get isArray () { return isArray; },
12
- get isNumber () { return isNumber; },
13
- get isValidNumber () { return isValidNumber; },
52
+ get isArrayLike () { return isArrayLike; },
53
+ get isBoolean () { return isBoolean; },
54
+ get isDate () { return isDate; },
55
+ get isEven () { return isEven; },
14
56
  get isFiniteNumber () { return isFiniteNumber; },
15
- get isNonNegNumber () { return isNonNegNumber; },
57
+ get isFunction () { return isFunction; },
16
58
  get isInteger () { return isInteger; },
17
- get isEven () { return isEven; },
59
+ get isNonNegNumber () { return isNonNegNumber; },
60
+ get isNumber () { return isNumber; },
61
+ get isObject () { return isObject; },
18
62
  get isOdd () { return isOdd$1; },
63
+ get isPromise () { return isPromise; },
19
64
  get isString () { return isString; },
20
- get isDate () { return isDate; },
21
- get isBoolean () { return isBoolean; },
22
- get formatDateISO () { return formatDateISO; },
23
- get toArray () { return toArray; },
24
- get isArrayLike () { return isArrayLike; },
25
- get addslashes () { return addslashes; },
26
- get regexEscape () { return regexEscape; },
27
- get htmlEscape () { return htmlEscape; },
28
- get defaults () { return defaults; },
29
- get extend () { return extend$1; },
30
- get inherit () { return inherit; },
31
- get promisify () { return promisify; },
32
- get reduceAsync () { return reduceAsync; },
65
+ get isValidNumber () { return isValidNumber; },
66
+ get lpad () { return lpad; },
67
+ get ltrim () { return ltrim; },
68
+ get mean () { return mean; },
33
69
  get merge () { return merge; },
34
- get difference () { return difference; },
35
- get intersection () { return intersection; },
36
- get indexOf () { return indexOf; },
37
- get contains () { return contains; },
38
- get some () { return some; },
39
- get every () { return every; },
40
- get find () { return find; },
70
+ get mergeNames () { return mergeNames; },
71
+ get numToStr () { return numToStr; },
72
+ get parseIntlNumber () { return parseIntlNumber; },
73
+ get parseNumber () { return parseNumber; },
74
+ get parsePercent () { return parsePercent; },
75
+ get parseString () { return parseString; },
76
+ get pickOne () { return pickOne; },
77
+ get pluck () { return pluck; },
78
+ get pluralSuffix () { return pluralSuffix; },
79
+ get promisify () { return promisify; },
80
+ get quicksort () { return quicksort$1; },
81
+ get quicksortPartition () { return quicksortPartition; },
41
82
  get range () { return range; },
83
+ get reduceAsync () { return reduceAsync; },
84
+ get regexEscape () { return regexEscape; },
85
+ get reorderArray () { return reorderArray; },
42
86
  get repeat () { return repeat; },
43
- get sum () { return sum$1; },
44
- get getArrayBounds () { return getArrayBounds; },
45
- get uniq () { return uniq; },
46
- get pluck () { return pluck; },
47
- get countValues () { return countValues; },
48
- get indexOn () { return indexOn; },
49
- get groupBy () { return groupBy; },
50
- get arrayToIndex () { return arrayToIndex; },
51
- get forEach () { return forEach; },
52
- get forEachProperty () { return forEachProperty; },
53
- get initializeArray () { return initializeArray; },
54
- get replaceArray () { return replaceArray; },
55
87
  get repeatString () { return repeatString; },
56
- get splitLines () { return splitLines; },
57
- get pluralSuffix () { return pluralSuffix; },
58
- get endsWith () { return endsWith; },
59
- get lpad () { return lpad; },
88
+ get replaceArray () { return replaceArray; },
60
89
  get rpad () { return rpad; },
61
- get trim () { return trim; },
62
- get ltrim () { return ltrim; },
63
90
  get rtrim () { return rtrim; },
64
- get addThousandsSep () { return addThousandsSep; },
65
- get numToStr () { return numToStr; },
66
- get formatNumber () { return formatNumber$1; },
67
- get formatIntlNumber () { return formatIntlNumber; },
68
- get formatNumberForDisplay () { return formatNumberForDisplay; },
69
91
  get shuffle () { return shuffle; },
70
- get pickOne () { return pickOne; },
71
- get sortOn () { return sortOn; },
72
- get genericSort () { return genericSort; },
73
- get getSortedIds () { return getSortedIds; },
92
+ get some () { return some; },
74
93
  get sortArrayIndex () { return sortArrayIndex; },
75
- get reorderArray () { return reorderArray; },
76
- get getKeyComparator () { return getKeyComparator; },
77
- get getGenericComparator () { return getGenericComparator; },
78
- get quicksort () { return quicksort$1; },
79
- get quicksortPartition () { return quicksortPartition; },
80
- get findRankByValue () { return findRankByValue; },
81
- get findValueByPct () { return findValueByPct; },
82
- get findValueByRank () { return findValueByRank; },
83
- get findMedian () { return findMedian; },
84
- get findQuantile () { return findQuantile; },
85
- get mean () { return mean; },
86
- get format () { return format; },
87
- get formatter () { return formatter; },
88
- get wildcardToRegExp () { return wildcardToRegExp; },
89
- get createBuffer () { return createBuffer; },
94
+ get sortOn () { return sortOn; },
95
+ get splitLines () { return splitLines; },
96
+ get sum () { return sum$1; },
97
+ get toArray () { return toArray; },
90
98
  get toBuffer () { return toBuffer; },
91
- get expandoBuffer () { return expandoBuffer; },
92
- get copyElements () { return copyElements; },
93
- get extendBuffer () { return extendBuffer; },
94
- get mergeNames () { return mergeNames; },
95
- get findStringPrefix () { return findStringPrefix; },
96
- get parsePercent () { return parsePercent; },
97
- get formatVersionedName () { return formatVersionedName; },
99
+ get trim () { return trim; },
100
+ get trimQuotes () { return trimQuotes; },
101
+ get uniq () { return uniq; },
98
102
  get uniqifyNames () { return uniqifyNames; },
99
- get parseString () { return parseString; },
100
- get parseNumber () { return parseNumber; },
101
- get parseIntlNumber () { return parseIntlNumber; },
102
- get cleanNumericString () { return cleanNumericString; },
103
- get trimQuotes () { return trimQuotes; }
103
+ get wildcardToRegExp () { return wildcardToRegExp; }
104
104
  });
105
105
 
106
106
  // This module provides a way for multiple jobs to run together asynchronously
@@ -129,9 +129,9 @@
129
129
 
130
130
  var Stash = /*#__PURE__*/Object.freeze({
131
131
  __proto__: null,
132
- stashVar: stashVar,
132
+ clearStash: clearStash,
133
133
  getStashedVar: getStashedVar,
134
- clearStash: clearStash
134
+ stashVar: stashVar
135
135
  });
136
136
 
137
137
  // Several dependencies are loaded via require()
@@ -1316,7 +1316,6 @@
1316
1316
  if (parts.length > 1 || true) {
1317
1317
  return '\nError details:\n' + parts[0];
1318
1318
  }
1319
- return '';
1320
1319
  }
1321
1320
 
1322
1321
  // print a message to stdout
@@ -1439,28 +1438,28 @@
1439
1438
 
1440
1439
  var Logging = /*#__PURE__*/Object.freeze({
1441
1440
  __proto__: null,
1442
- getLoggingSetter: getLoggingSetter,
1443
- setLoggingForCLI: setLoggingForCLI,
1441
+ NonFatalError: NonFatalError,
1442
+ UserError: UserError,
1443
+ debug: debug,
1444
1444
  enableLogging: enableLogging,
1445
- loggingEnabled: loggingEnabled,
1446
1445
  error: error,
1447
- stop: stop,
1446
+ formatColumns: formatColumns,
1447
+ formatLogArgs: formatLogArgs,
1448
+ formatStringsAsGrid: formatStringsAsGrid,
1449
+ getErrorDetail: getErrorDetail,
1450
+ getLoggingSetter: getLoggingSetter,
1448
1451
  interrupt: interrupt,
1452
+ logArgs: logArgs,
1453
+ loggingEnabled: loggingEnabled,
1449
1454
  message: message,
1450
- warn: warn,
1451
- setLoggingFunctions: setLoggingFunctions,
1452
- getErrorDetail: getErrorDetail,
1453
1455
  print: print,
1454
- verbose: verbose,
1455
- debug: debug,
1456
1456
  printError: printError,
1457
- UserError: UserError,
1458
- NonFatalError: NonFatalError,
1459
- formatColumns: formatColumns,
1460
- formatStringsAsGrid: formatStringsAsGrid,
1461
- formatLogArgs: formatLogArgs,
1462
- logArgs: logArgs,
1463
- truncateString: truncateString
1457
+ setLoggingForCLI: setLoggingForCLI,
1458
+ setLoggingFunctions: setLoggingFunctions,
1459
+ stop: stop,
1460
+ truncateString: truncateString,
1461
+ verbose: verbose,
1462
+ warn: warn
1464
1463
  });
1465
1464
 
1466
1465
  function Transform() {
@@ -1837,10 +1836,10 @@
1837
1836
  var PointUtils = /*#__PURE__*/Object.freeze({
1838
1837
  __proto__: null,
1839
1838
  countPointsInLayer: countPointsInLayer,
1839
+ forEachPoint: forEachPoint,
1840
1840
  getPointBounds: getPointBounds$1,
1841
1841
  getPointFeatureBounds: getPointFeatureBounds,
1842
- getPointsInLayer: getPointsInLayer,
1843
- forEachPoint: forEachPoint
1842
+ getPointsInLayer: getPointsInLayer
1844
1843
  });
1845
1844
 
1846
1845
  function absArcId(arcId) {
@@ -2060,26 +2059,22 @@
2060
2059
  var ArcUtils = /*#__PURE__*/Object.freeze({
2061
2060
  __proto__: null,
2062
2061
  absArcId: absArcId,
2063
- calcArcBounds: calcArcBounds,
2064
- getUnfilteredArcLength: getUnfilteredArcLength,
2065
- getUnfilteredArcCoords: getUnfilteredArcCoords,
2066
- findArcIdFromVertexId: findArcIdFromVertexId,
2067
- deleteLastArc: deleteLastArc,
2068
- deleteVertex: deleteVertex,
2069
2062
  appendEmptyArc: appendEmptyArc,
2070
2063
  appendVertex: appendVertex,
2071
- insertVertex: insertVertex,
2064
+ calcArcBounds: calcArcBounds,
2072
2065
  countFilteredVertices: countFilteredVertices,
2073
- filterVertexData: filterVertexData
2066
+ deleteLastArc: deleteLastArc,
2067
+ deleteVertex: deleteVertex,
2068
+ filterVertexData: filterVertexData,
2069
+ findArcIdFromVertexId: findArcIdFromVertexId,
2070
+ getUnfilteredArcCoords: getUnfilteredArcCoords,
2071
+ getUnfilteredArcLength: getUnfilteredArcLength,
2072
+ insertVertex: insertVertex
2074
2073
  });
2075
2074
 
2076
2075
  var WGS84 = {
2077
2076
  // https://en.wikipedia.org/wiki/Earth_radius
2078
- SEMIMAJOR_AXIS: 6378137,
2079
- SEMIMINOR_AXIS: 6356752.3142,
2080
- AUTHALIC_RADIUS: 6371007.2,
2081
- VOLUMETRIC_RADIUS: 6371000.8
2082
- };
2077
+ SEMIMAJOR_AXIS: 6378137};
2083
2078
 
2084
2079
  // TODO: remove this constant, use actual data from dataset CRS,
2085
2080
  // also consider using ellipsoidal formulas where greater accuracy might be important.
@@ -2428,35 +2423,35 @@
2428
2423
 
2429
2424
  var Geom = /*#__PURE__*/Object.freeze({
2430
2425
  __proto__: null,
2431
- R: R$1,
2432
2426
  D2R: D2R,
2427
+ R: R$1,
2433
2428
  R2D: R2D,
2429
+ bearing: bearing,
2430
+ bearing2D: bearing2D,
2431
+ containsBounds: containsBounds,
2432
+ convLngLatToSph: convLngLatToSph,
2433
+ cosine: cosine,
2434
+ cosine3D: cosine3D,
2434
2435
  degreesToMeters: degreesToMeters,
2436
+ distance2D: distance2D,
2435
2437
  distance3D: distance3D,
2436
2438
  distanceSq: distanceSq,
2437
- distance2D: distance2D,
2438
2439
  distanceSq3D: distanceSq3D,
2440
+ greatCircleDistance: greatCircleDistance,
2441
+ innerAngle: innerAngle,
2439
2442
  innerAngle2: innerAngle2,
2440
- standardAngle: standardAngle,
2443
+ innerAngle3D: innerAngle3D,
2444
+ lngLatToXYZ: lngLatToXYZ,
2445
+ pointSegDistSq: pointSegDistSq,
2446
+ pointSegDistSq2: pointSegDistSq2,
2447
+ pointSegDistSq3D: pointSegDistSq3D,
2441
2448
  signedAngle: signedAngle,
2442
- bearing2D: bearing2D,
2443
- bearing: bearing,
2444
2449
  signedAngleSph: signedAngleSph,
2445
- convLngLatToSph: convLngLatToSph,
2446
- xyzToLngLat: xyzToLngLat,
2447
- lngLatToXYZ: lngLatToXYZ,
2448
2450
  sphericalDistance: sphericalDistance,
2449
- greatCircleDistance: greatCircleDistance,
2450
- innerAngle: innerAngle,
2451
- innerAngle3D: innerAngle3D,
2451
+ standardAngle: standardAngle,
2452
2452
  triangleArea: triangleArea,
2453
- cosine: cosine,
2454
- cosine3D: cosine3D,
2455
2453
  triangleArea3D: triangleArea3D,
2456
- pointSegDistSq: pointSegDistSq,
2457
- pointSegDistSq3D: pointSegDistSq3D,
2458
- pointSegDistSq2: pointSegDistSq2,
2459
- containsBounds: containsBounds
2454
+ xyzToLngLat: xyzToLngLat
2460
2455
  });
2461
2456
 
2462
2457
  function pathIsClosed(ids, arcs) {
@@ -2602,16 +2597,16 @@
2602
2597
 
2603
2598
  var PathGeom = /*#__PURE__*/Object.freeze({
2604
2599
  __proto__: null,
2605
- pathIsClosed: pathIsClosed,
2600
+ get calcPathLen () { return calcPathLen; },
2601
+ countVerticesInPath: countVerticesInPath,
2602
+ getAvgPathXY: getAvgPathXY,
2603
+ getMaxPath: getMaxPath,
2604
+ getPathBounds: getPathBounds$1,
2606
2605
  getPointToPathDistance: getPointToPathDistance,
2607
2606
  getPointToPathInfo: getPointToPathInfo,
2608
2607
  getPointToShapeDistance: getPointToShapeDistance,
2609
2608
  getPointToShapeInfo: getPointToShapeInfo,
2610
- getAvgPathXY: getAvgPathXY,
2611
- getMaxPath: getMaxPath,
2612
- countVerticesInPath: countVerticesInPath,
2613
- getPathBounds: getPathBounds$1,
2614
- get calcPathLen () { return calcPathLen; }
2609
+ pathIsClosed: pathIsClosed
2615
2610
  });
2616
2611
 
2617
2612
  // Get the centroid of the largest ring of a polygon
@@ -2655,8 +2650,8 @@
2655
2650
 
2656
2651
  var PolygonCentroid = /*#__PURE__*/Object.freeze({
2657
2652
  __proto__: null,
2658
- getShapeCentroid: getShapeCentroid,
2659
- getPathCentroid: getPathCentroid
2653
+ getPathCentroid: getPathCentroid,
2654
+ getShapeCentroid: getShapeCentroid
2660
2655
  });
2661
2656
 
2662
2657
  function testSegmentBoundsIntersection(a, b, bb) {
@@ -2938,25 +2933,25 @@
2938
2933
  __proto__: null,
2939
2934
  calcPolsbyPopperCompactness: calcPolsbyPopperCompactness,
2940
2935
  calcSchwartzbergCompactness: calcSchwartzbergCompactness,
2936
+ getPathArea: getPathArea,
2937
+ getPathPerimeter: getPathPerimeter,
2941
2938
  getPathWinding: getPathWinding,
2942
- getShapeArea: getShapeArea,
2939
+ getPlanarPathArea: getPlanarPathArea,
2940
+ getPlanarPathArea2: getPlanarPathArea2,
2941
+ getPlanarPathPerimeter: getPlanarPathPerimeter,
2943
2942
  getPlanarShapeArea: getPlanarShapeArea,
2944
- getSphericalShapeArea: getSphericalShapeArea,
2945
- testBoundsInPolygon: testBoundsInPolygon,
2946
- testPointInPolygon: testPointInPolygon,
2947
- testPointInRing: testPointInRing,
2948
- testRayIntersection: testRayIntersection,
2949
2943
  getRayIntersection: getRayIntersection,
2950
- getPathArea: getPathArea,
2944
+ getShapeArea: getShapeArea,
2945
+ getShapePerimeter: getShapePerimeter,
2951
2946
  getSphericalPathArea: getSphericalPathArea,
2952
2947
  getSphericalPathArea2: getSphericalPathArea2,
2953
- getPlanarPathArea2: getPlanarPathArea2,
2954
- getPlanarPathArea: getPlanarPathArea,
2955
- getPathPerimeter: getPathPerimeter,
2956
- getShapePerimeter: getShapePerimeter,
2948
+ getSphericalPathPerimeter: getSphericalPathPerimeter,
2949
+ getSphericalShapeArea: getSphericalShapeArea,
2957
2950
  getSphericalShapePerimeter: getSphericalShapePerimeter,
2958
- getPlanarPathPerimeter: getPlanarPathPerimeter,
2959
- getSphericalPathPerimeter: getSphericalPathPerimeter
2951
+ testBoundsInPolygon: testBoundsInPolygon,
2952
+ testPointInPolygon: testPointInPolygon,
2953
+ testPointInRing: testPointInRing,
2954
+ testRayIntersection: testRayIntersection
2960
2955
  });
2961
2956
 
2962
2957
  // Returns an interval for snapping together coordinates that be co-incident bug
@@ -3150,12 +3145,12 @@
3150
3145
 
3151
3146
  var Snapping = /*#__PURE__*/Object.freeze({
3152
3147
  __proto__: null,
3148
+ getCoordinateIds: getCoordinateIds,
3149
+ getEndpointIds: getEndpointIds,
3153
3150
  getHighPrecisionSnapInterval: getHighPrecisionSnapInterval,
3154
3151
  snapCoords: snapCoords,
3155
3152
  snapCoordsByInterval: snapCoordsByInterval,
3156
- snapEndpointsByInterval: snapEndpointsByInterval,
3157
- getCoordinateIds: getCoordinateIds,
3158
- getEndpointIds: getEndpointIds
3153
+ snapEndpointsByInterval: snapEndpointsByInterval
3159
3154
  });
3160
3155
 
3161
3156
  // Find the intersection between two 2D segments
@@ -3384,10 +3379,10 @@
3384
3379
 
3385
3380
  var SegmentGeom = /*#__PURE__*/Object.freeze({
3386
3381
  __proto__: null,
3387
- segmentIntersection: segmentIntersection,
3388
3382
  findClosestPointOnSeg: findClosestPointOnSeg,
3389
3383
  orient2D: orient2D,
3390
3384
  segmentHit: segmentHit,
3385
+ segmentIntersection: segmentIntersection,
3391
3386
  segmentTurn: segmentTurn
3392
3387
  });
3393
3388
 
@@ -3654,23 +3649,23 @@
3654
3649
 
3655
3650
  var PathUtils = /*#__PURE__*/Object.freeze({
3656
3651
  __proto__: null,
3657
- getAvgSegment: getAvgSegment,
3658
- getAvgSegment2: getAvgSegment2,
3659
- getDirectedArcPresenceTest: getDirectedArcPresenceTest,
3660
- getArcPresenceTest: getArcPresenceTest,
3661
- countArcsInShapes: countArcsInShapes,
3662
- getPathBounds: getPathBounds,
3663
- findShapesByArcId: findShapesByArcId,
3664
- reversePath: reversePath,
3665
3652
  clampIntervalByPct: clampIntervalByPct,
3653
+ countArcsInShapes: countArcsInShapes,
3654
+ filterEmptyArcs: filterEmptyArcs,
3666
3655
  findNextRemovableVertex: findNextRemovableVertex,
3656
+ findShapesByArcId: findShapesByArcId,
3667
3657
  forEachArcId: forEachArcId,
3668
- forEachSegmentInShape: forEachSegmentInShape,
3669
3658
  forEachSegmentInPath: forEachSegmentInPath,
3670
- traversePaths: traversePaths,
3671
- filterEmptyArcs: filterEmptyArcs,
3659
+ forEachSegmentInShape: forEachSegmentInShape,
3660
+ getArcPresenceTest: getArcPresenceTest,
3661
+ getAvgSegment: getAvgSegment,
3662
+ getAvgSegment2: getAvgSegment2,
3663
+ getDirectedArcPresenceTest: getDirectedArcPresenceTest,
3664
+ getPathBounds: getPathBounds,
3672
3665
  getPathMetadata: getPathMetadata,
3673
- quantizeArcs: quantizeArcs
3666
+ quantizeArcs: quantizeArcs,
3667
+ reversePath: reversePath,
3668
+ traversePaths: traversePaths
3674
3669
  });
3675
3670
 
3676
3671
  // Utility functions for both paths and points
@@ -3747,10 +3742,10 @@
3747
3742
  __proto__: null,
3748
3743
  cloneShape: cloneShape,
3749
3744
  cloneShapes: cloneShapes,
3750
- forEachShapePart: forEachShapePart,
3751
- editShapes: editShapes,
3752
3745
  editShapeParts: editShapeParts,
3753
- findMaxPartCount: findMaxPartCount
3746
+ editShapes: editShapes,
3747
+ findMaxPartCount: findMaxPartCount,
3748
+ forEachShapePart: forEachShapePart
3754
3749
  });
3755
3750
 
3756
3751
  var iconv = require$1('iconv-lite');
@@ -3897,19 +3892,19 @@
3897
3892
 
3898
3893
  var Encodings = /*#__PURE__*/Object.freeze({
3899
3894
  __proto__: null,
3900
- getEncodings: getEncodings,
3901
- validateEncoding: validateEncoding,
3902
- stringsAreAscii: stringsAreAscii,
3903
- stringIsAscii: stringIsAscii,
3904
- encodingIsUtf8: encodingIsUtf8,
3905
- encodingIsAsciiCompat: encodingIsAsciiCompat,
3906
- standardizeEncodingName: standardizeEncodingName,
3907
3895
  bufferToString: bufferToString,
3908
- encodeString: encodeString,
3909
3896
  decodeString: decodeString,
3897
+ encodeString: encodeString,
3898
+ encodingIsAsciiCompat: encodingIsAsciiCompat,
3910
3899
  encodingIsSupported: encodingIsSupported,
3900
+ encodingIsUtf8: encodingIsUtf8,
3901
+ getEncodings: getEncodings,
3902
+ printEncodings: printEncodings,
3903
+ standardizeEncodingName: standardizeEncodingName,
3904
+ stringIsAscii: stringIsAscii,
3905
+ stringsAreAscii: stringsAreAscii,
3911
3906
  trimBOM: trimBOM,
3912
- printEncodings: printEncodings
3907
+ validateEncoding: validateEncoding
3913
3908
  });
3914
3909
 
3915
3910
  // Not a general-purpose deep copy function
@@ -4153,21 +4148,21 @@
4153
4148
 
4154
4149
  var DataUtils = /*#__PURE__*/Object.freeze({
4155
4150
  __proto__: null,
4151
+ applyFieldOrder: applyFieldOrder,
4156
4152
  copyRecord: copyRecord,
4157
- getValueType: getValueType,
4158
- fixInconsistentFields: fixInconsistentFields,
4153
+ deleteFields: deleteFields,
4159
4154
  fieldListContainsAll: fieldListContainsAll,
4155
+ findFieldNames: findFieldNames,
4156
+ fixInconsistentFields: fixInconsistentFields,
4160
4157
  getColumnType: getColumnType,
4161
- deleteFields: deleteFields,
4162
- isInvalidFieldName: isInvalidFieldName,
4163
- getUniqFieldNames: getUniqFieldNames,
4164
4158
  getFieldValues: getFieldValues,
4165
- getUniqFieldValues: getUniqFieldValues,
4166
- applyFieldOrder: applyFieldOrder,
4167
4159
  getFirstNonEmptyRecord: getFirstNonEmptyRecord,
4168
- findFieldNames: findFieldNames,
4169
- parseUnknownType: parseUnknownType,
4170
- getInputParser: getInputParser
4160
+ getInputParser: getInputParser,
4161
+ getUniqFieldNames: getUniqFieldNames,
4162
+ getUniqFieldValues: getUniqFieldValues,
4163
+ getValueType: getValueType,
4164
+ isInvalidFieldName: isInvalidFieldName,
4165
+ parseUnknownType: parseUnknownType
4171
4166
  });
4172
4167
 
4173
4168
  function DataTable(obj) {
@@ -4289,8 +4284,8 @@
4289
4284
 
4290
4285
  var RectangleUtils = /*#__PURE__*/Object.freeze({
4291
4286
  __proto__: null,
4292
- pathIsRectangle: pathIsRectangle,
4293
- bboxToCoords: bboxToCoords
4287
+ bboxToCoords: bboxToCoords,
4288
+ pathIsRectangle: pathIsRectangle
4294
4289
  });
4295
4290
 
4296
4291
  // Insert a column of values into a (new or existing) data field
@@ -4591,42 +4586,42 @@
4591
4586
 
4592
4587
  var LayerUtils = /*#__PURE__*/Object.freeze({
4593
4588
  __proto__: null,
4594
- insertFieldValues: insertFieldValues,
4589
+ copyLayer: copyLayer,
4590
+ copyLayerShapes: copyLayerShapes,
4591
+ countArcsInLayers: countArcsInLayers,
4592
+ countMultiPartFeatures: countMultiPartFeatures,
4593
+ deleteFeatureById: deleteFeatureById,
4594
+ divideFeaturesByType: divideFeaturesByType,
4595
+ filterPathLayerByArcIds: filterPathLayerByArcIds,
4596
+ getArcPresenceTest2: getArcPresenceTest2,
4597
+ getFeatureCount: getFeatureCount,
4598
+ getLayerBounds: getLayerBounds,
4595
4599
  getLayerDataTable: getLayerDataTable,
4600
+ getLayerSourceFile: getLayerSourceFile,
4601
+ getOutputLayer: getOutputLayer,
4602
+ initDataTable: initDataTable,
4603
+ insertFieldValues: insertFieldValues,
4604
+ isolateLayer: isolateLayer,
4596
4605
  layerHasAttributeData: layerHasAttributeData,
4597
- layerHasNonNullData: layerHasNonNullData,
4598
4606
  layerHasGeometry: layerHasGeometry,
4599
- layerIsGeometric: layerIsGeometric,
4607
+ layerHasNonNullData: layerHasNonNullData,
4608
+ layerHasNonNullShapes: layerHasNonNullShapes,
4600
4609
  layerHasPaths: layerHasPaths,
4601
4610
  layerHasPoints: layerHasPoints,
4611
+ layerIsEmpty: layerIsEmpty,
4612
+ layerIsGeometric: layerIsGeometric,
4602
4613
  layerIsRectangle: layerIsRectangle,
4603
4614
  layerOnlyHasRectangles: layerOnlyHasRectangles,
4604
- layerHasNonNullShapes: layerHasNonNullShapes,
4605
- deleteFeatureById: deleteFeatureById,
4606
- transformPointsInLayer: transformPointsInLayer,
4607
- getFeatureCount: getFeatureCount,
4608
- layerIsEmpty: layerIsEmpty,
4615
+ layerTypeMessage: layerTypeMessage,
4609
4616
  requireDataField: requireDataField,
4610
4617
  requireDataFields: requireDataFields,
4611
- layerTypeMessage: layerTypeMessage,
4618
+ requirePathLayer: requirePathLayer,
4612
4619
  requirePointLayer: requirePointLayer,
4613
- requireSinglePointLayer: requireSinglePointLayer,
4614
- requirePolylineLayer: requirePolylineLayer,
4615
4620
  requirePolygonLayer: requirePolygonLayer,
4616
- requirePathLayer: requirePathLayer,
4617
- getLayerSourceFile: getLayerSourceFile,
4618
- divideFeaturesByType: divideFeaturesByType,
4619
- getOutputLayer: getOutputLayer,
4621
+ requirePolylineLayer: requirePolylineLayer,
4622
+ requireSinglePointLayer: requireSinglePointLayer,
4620
4623
  setOutputLayerName: setOutputLayerName,
4621
- copyLayer: copyLayer,
4622
- filterPathLayerByArcIds: filterPathLayerByArcIds,
4623
- copyLayerShapes: copyLayerShapes,
4624
- countMultiPartFeatures: countMultiPartFeatures,
4625
- getArcPresenceTest2: getArcPresenceTest2,
4626
- countArcsInLayers: countArcsInLayers,
4627
- getLayerBounds: getLayerBounds,
4628
- isolateLayer: isolateLayer,
4629
- initDataTable: initDataTable
4624
+ transformPointsInLayer: transformPointsInLayer
4630
4625
  });
4631
4626
 
4632
4627
  // A matrix class that supports affine transformations (scaling, translation, rotation).
@@ -4843,7 +4838,7 @@
4843
4838
  var AK = {
4844
4839
  name: 'AK',
4845
4840
  proj: '+proj=aea +lat_1=55 +lat_2=70 +lat_0=65 +lon_0=-148 +x_0=0 +y_0=0',
4846
- bbox: [-172.26,50.89,-127.00,73.21],
4841
+ bbox: [-172.26,50.89,-127,73.21],
4847
4842
  origin: [-152, 63],
4848
4843
  placement: [-1882782,-969242],
4849
4844
  scale: 0.37
@@ -4851,7 +4846,7 @@
4851
4846
  var HI = {
4852
4847
  name: 'HI',
4853
4848
  proj: '+proj=aea +lat_1=19 +lat_2=24 +lat_0=20.9 +lon_0=-156.5 +x_0=0 +y_0=0',
4854
- bbox: [-160.50,18.72,-154.57,22.58],
4849
+ bbox: [-160.5,18.72,-154.57,22.58],
4855
4850
  origin: [-157, 21],
4856
4851
  placement: [-1050326,-1055362]
4857
4852
  };
@@ -4928,9 +4923,9 @@
4928
4923
 
4929
4924
  var CustomProjections = /*#__PURE__*/Object.freeze({
4930
4925
  __proto__: null,
4931
- parseCustomProjection: parseCustomProjection,
4932
4926
  AlbersUSA: AlbersUSA,
4933
- parseCustomParams: parseCustomParams
4927
+ parseCustomParams: parseCustomParams,
4928
+ parseCustomProjection: parseCustomProjection
4934
4929
  });
4935
4930
 
4936
4931
  function getWorldBounds(e) {
@@ -4958,10 +4953,10 @@
4958
4953
 
4959
4954
  var LatLon = /*#__PURE__*/Object.freeze({
4960
4955
  __proto__: null,
4961
- getWorldBounds: getWorldBounds,
4962
- probablyDecimalDegreeBounds: probablyDecimalDegreeBounds,
4963
4956
  clampToWorldBounds: clampToWorldBounds,
4964
- getAntimeridian: getAntimeridian
4957
+ getAntimeridian: getAntimeridian,
4958
+ getWorldBounds: getWorldBounds,
4959
+ probablyDecimalDegreeBounds: probablyDecimalDegreeBounds
4965
4960
  });
4966
4961
 
4967
4962
  var mproj = require$1('mproj');
@@ -5276,37 +5271,37 @@
5276
5271
 
5277
5272
  var Projections = /*#__PURE__*/Object.freeze({
5278
5273
  __proto__: null,
5279
- initProjLibrary: initProjLibrary,
5280
- setProjectionLoader: setProjectionLoader,
5281
- findProjLibs: findProjLibs,
5282
- getProjTransform: getProjTransform,
5283
- getProjTransform2: getProjTransform2,
5284
- toLngLat: toLngLat,
5285
- projectPoint: projectPoint,
5286
- getProjInfo: getProjInfo,
5287
- crsToProj4: crsToProj4,
5288
- crsToPrj: crsToPrj,
5289
5274
  crsAreEqual: crsAreEqual,
5290
- isProjAlias: isProjAlias,
5291
- getProjDefn: getProjDefn,
5292
- looksLikeProj4String: looksLikeProj4String,
5275
+ crsToPrj: crsToPrj,
5276
+ crsToProj4: crsToProj4,
5277
+ findProjLibs: findProjLibs,
5293
5278
  getCrsInfo: getCrsInfo,
5294
- parseCrsString: parseCrsString,
5295
- requireProjectedDataset: requireProjectedDataset,
5296
- setDatasetCrsInfo: setDatasetCrsInfo,
5297
- getDatasetCrsInfo: getDatasetCrsInfo,
5298
5279
  getDatasetCRS: getDatasetCRS,
5299
- requireDatasetsHaveCompatibleCRS: requireDatasetsHaveCompatibleCRS,
5280
+ getDatasetCrsInfo: getDatasetCrsInfo,
5281
+ getProjDefn: getProjDefn,
5282
+ getProjInfo: getProjInfo,
5283
+ getProjTransform: getProjTransform,
5284
+ getProjTransform2: getProjTransform2,
5300
5285
  getScaleFactorAtXY: getScaleFactorAtXY,
5301
- isProjectedCRS: isProjectedCRS,
5286
+ initProjLibrary: initProjLibrary,
5302
5287
  isInvertibleCRS: isInvertibleCRS,
5303
5288
  isLatLngCRS: isLatLngCRS,
5289
+ isLatLngDataset: isLatLngDataset,
5290
+ isProjAlias: isProjAlias,
5291
+ isProjectedCRS: isProjectedCRS,
5304
5292
  isWGS84: isWGS84,
5305
5293
  isWebMercator: isWebMercator,
5306
- isLatLngDataset: isLatLngDataset,
5294
+ looksLikeProj4String: looksLikeProj4String,
5295
+ parseCrsString: parseCrsString,
5296
+ parsePrj: parsePrj,
5307
5297
  printProjections: printProjections,
5308
- translatePrj: translatePrj,
5309
- parsePrj: parsePrj
5298
+ projectPoint: projectPoint,
5299
+ requireDatasetsHaveCompatibleCRS: requireDatasetsHaveCompatibleCRS,
5300
+ requireProjectedDataset: requireProjectedDataset,
5301
+ setDatasetCrsInfo: setDatasetCrsInfo,
5302
+ setProjectionLoader: setProjectionLoader,
5303
+ toLngLat: toLngLat,
5304
+ translatePrj: translatePrj
5310
5305
  });
5311
5306
 
5312
5307
  // Coordinate iterators
@@ -5420,7 +5415,6 @@
5420
5415
  }
5421
5416
 
5422
5417
  function MultiShapeIter(arcs) {
5423
- new ShapeIter(arcs);
5424
5418
 
5425
5419
  }
5426
5420
 
@@ -5473,10 +5467,10 @@
5473
5467
 
5474
5468
  var ShapeIter$1 = /*#__PURE__*/Object.freeze({
5475
5469
  __proto__: null,
5476
- PointIter: PointIter,
5477
5470
  ArcIter: ArcIter,
5478
5471
  FilteredArcIter: FilteredArcIter,
5479
5472
  MultiShapeIter: MultiShapeIter,
5473
+ PointIter: PointIter,
5480
5474
  ShapeIter: ShapeIter
5481
5475
  });
5482
5476
 
@@ -5525,8 +5519,8 @@
5525
5519
 
5526
5520
  var SimplifyPct = /*#__PURE__*/Object.freeze({
5527
5521
  __proto__: null,
5528
- getThresholdFunction: getThresholdFunction,
5529
- getThresholdByPct: getThresholdByPct
5522
+ getThresholdByPct: getThresholdByPct,
5523
+ getThresholdFunction: getThresholdFunction
5530
5524
  });
5531
5525
 
5532
5526
  // An interface for managing a collection of paths.
@@ -6570,8 +6564,8 @@
6570
6564
 
6571
6565
  var Topology = /*#__PURE__*/Object.freeze({
6572
6566
  __proto__: null,
6573
- buildTopology: buildTopology,
6574
- buildPathTopology: buildPathTopology
6567
+ buildPathTopology: buildPathTopology,
6568
+ buildTopology: buildTopology
6575
6569
  });
6576
6570
 
6577
6571
  // Merge arcs from one or more source datasets into target dataset
@@ -6715,12 +6709,12 @@
6715
6709
 
6716
6710
  var Merging = /*#__PURE__*/Object.freeze({
6717
6711
  __proto__: null,
6718
- mergeDatasetsIntoDataset: mergeDatasetsIntoDataset,
6719
- mergeDatasetsForExport: mergeDatasetsForExport,
6712
+ mergeArcs: mergeArcs,
6720
6713
  mergeCommandTargets: mergeCommandTargets,
6721
- mergeDatasets: mergeDatasets,
6722
6714
  mergeDatasetInfo: mergeDatasetInfo$1,
6723
- mergeArcs: mergeArcs
6715
+ mergeDatasets: mergeDatasets,
6716
+ mergeDatasetsForExport: mergeDatasetsForExport,
6717
+ mergeDatasetsIntoDataset: mergeDatasetsIntoDataset
6724
6718
  });
6725
6719
 
6726
6720
  // Test if the second endpoint of an arc is the endpoint of any path in any layer
@@ -7369,22 +7363,22 @@
7369
7363
 
7370
7364
  var DatasetUtils = /*#__PURE__*/Object.freeze({
7371
7365
  __proto__: null,
7372
- splitDataset: splitDataset,
7373
- mergeDatasetInfo: mergeDatasetInfo,
7374
- copyDatasetInfo: copyDatasetInfo,
7375
- splitApartLayers: splitApartLayers,
7366
+ cleanupArcs: cleanupArcs,
7376
7367
  copyDataset: copyDataset,
7377
7368
  copyDatasetForExport: copyDatasetForExport,
7378
7369
  copyDatasetForRenaming: copyDatasetForRenaming,
7379
- getDatasetBounds: getDatasetBounds,
7380
- datasetIsEmpty: datasetIsEmpty,
7370
+ copyDatasetInfo: copyDatasetInfo,
7381
7371
  datasetHasGeometry: datasetHasGeometry,
7382
7372
  datasetHasPaths: datasetHasPaths,
7383
- cleanupArcs: cleanupArcs,
7373
+ datasetIsEmpty: datasetIsEmpty,
7374
+ getDatasetBounds: getDatasetBounds,
7375
+ mergeDatasetInfo: mergeDatasetInfo,
7376
+ mergeOutputLayerIntoDataset: mergeOutputLayerIntoDataset,
7384
7377
  pruneArcs: pruneArcs,
7385
- replaceLayers: replaceLayers,
7386
7378
  replaceLayerContents: replaceLayerContents,
7387
- mergeOutputLayerIntoDataset: mergeOutputLayerIntoDataset,
7379
+ replaceLayers: replaceLayers,
7380
+ splitApartLayers: splitApartLayers,
7381
+ splitDataset: splitDataset,
7388
7382
  transformPoints: transformPoints
7389
7383
  });
7390
7384
 
@@ -7464,14 +7458,14 @@
7464
7458
 
7465
7459
  var FilenameUtils = /*#__PURE__*/Object.freeze({
7466
7460
  __proto__: null,
7467
- parseLocalPath: parseLocalPath,
7461
+ getCommonFileBase: getCommonFileBase,
7468
7462
  getFileBase: getFileBase,
7469
7463
  getFileExtension: getFileExtension,
7464
+ getOutputFileBase: getOutputFileBase,
7470
7465
  getPathBase: getPathBase,
7466
+ parseLocalPath: parseLocalPath,
7471
7467
  replaceFileExtension: replaceFileExtension,
7472
- toLowerCaseExtension: toLowerCaseExtension,
7473
- getCommonFileBase: getCommonFileBase,
7474
- getOutputFileBase: getOutputFileBase
7468
+ toLowerCaseExtension: toLowerCaseExtension
7475
7469
  });
7476
7470
 
7477
7471
  var decoder;
@@ -7651,13 +7645,7 @@
7651
7645
  currentStructures.length = sharedLength;
7652
7646
  }
7653
7647
  let result;
7654
- if (currentUnpackr.randomAccessStructure && src[position$1] < 0x40 && src[position$1] >= 0x20 && readStruct) {
7655
- result = readStruct(src, position$1, srcEnd, currentUnpackr);
7656
- src = null; // dispose of this so that recursive unpack calls don't save state
7657
- if (!(options && options.lazy) && result)
7658
- result = result.toJSON();
7659
- position$1 = srcEnd;
7660
- } else
7648
+ if (currentUnpackr.randomAccessStructure && src[position$1] < 0x40 && src[position$1] >= 0x20 && readStruct) ; else
7661
7649
  result = read();
7662
7650
  if (bundledStrings$1) { // bundled strings to skip past
7663
7651
  position$1 = bundledStrings$1.postBundlePosition;
@@ -8499,7 +8487,7 @@
8499
8487
  else if (data.length == 12)// TODO: Implement support for negative
8500
8488
  return new Date(
8501
8489
  ((data[0] << 24) + (data[1] << 16) + (data[2] << 8) + data[3]) / 1000000 +
8502
- (((data[4] & 0x80) ? -0x1000000000000 : 0) + data[6] * 0x10000000000 + data[7] * 0x100000000 + data[8] * 0x1000000 + (data[9] << 16) + (data[10] << 8) + data[11]) * 1000)
8490
+ (((data[4] & 0x80) ? -281474976710656 : 0) + data[6] * 0x10000000000 + data[7] * 0x100000000 + data[8] * 0x1000000 + (data[9] << 16) + (data[10] << 8) + data[11]) * 1000)
8503
8491
  else
8504
8492
  return new Date('invalid')
8505
8493
  }; // notepack defines extension 0 to mean undefined, so use that as the default here
@@ -8916,12 +8904,12 @@
8916
8904
  position += 4;
8917
8905
  }
8918
8906
  } else if (value >> 0 === value) { // negative integer
8919
- if (value >= -0x20) {
8907
+ if (value >= -32) {
8920
8908
  target[position++] = 0x100 + value;
8921
- } else if (value >= -0x80) {
8909
+ } else if (value >= -128) {
8922
8910
  target[position++] = 0xd0;
8923
8911
  target[position++] = value + 0x100;
8924
- } else if (value >= -0x8000) {
8912
+ } else if (value >= -32768) {
8925
8913
  target[position++] = 0xd1;
8926
8914
  targetView.setInt16(position, value);
8927
8915
  position += 2;
@@ -8932,7 +8920,7 @@
8932
8920
  }
8933
8921
  } else {
8934
8922
  let useFloat32;
8935
- if ((useFloat32 = this.useFloat32) > 0 && value < 0x100000000 && value >= -0x80000000) {
8923
+ if ((useFloat32 = this.useFloat32) > 0 && value < 0x100000000 && value >= -2147483648) {
8936
8924
  target[position++] = 0xca;
8937
8925
  targetView.setFloat32(position, value);
8938
8926
  let xShifted;
@@ -10646,12 +10634,7 @@
10646
10634
  * @returns The string encoded in UTF-8/Latin-1 binary
10647
10635
  */
10648
10636
  function strToU8(str, latin1) {
10649
- if (latin1) {
10650
- var ar_1 = new u8(str.length);
10651
- for (var i = 0; i < str.length; ++i)
10652
- ar_1[i] = str.charCodeAt(i);
10653
- return ar_1;
10654
- }
10637
+ var i;
10655
10638
  if (te)
10656
10639
  return te.encode(str);
10657
10640
  var l = str.length;
@@ -11115,11 +11098,11 @@
11115
11098
 
11116
11099
  var Gzip = /*#__PURE__*/Object.freeze({
11117
11100
  __proto__: null,
11118
- isGzipped: isGzipped,
11119
- gzipSync: gzipSync,
11120
- gzipAsync: gzipAsync,
11121
11101
  gunzipAsync: gunzipAsync,
11122
- gunzipSync: gunzipSync
11102
+ gunzipSync: gunzipSync,
11103
+ gzipAsync: gzipAsync,
11104
+ gzipSync: gzipSync,
11105
+ isGzipped: isGzipped
11123
11106
  });
11124
11107
 
11125
11108
  // Export in a column-first format
@@ -11363,12 +11346,12 @@
11363
11346
  var Pack = /*#__PURE__*/Object.freeze({
11364
11347
  __proto__: null,
11365
11348
  PACKAGE_EXT: PACKAGE_EXT,
11366
- exportPackedDatasets: exportPackedDatasets,
11367
- pack: pack,
11368
- exportDatasetsToPack: exportDatasetsToPack,
11369
- exportDataset: exportDataset,
11370
11349
  compressSnapshotForExport: compressSnapshotForExport,
11371
- exportInfo: exportInfo
11350
+ exportDataset: exportDataset,
11351
+ exportDatasetsToPack: exportDatasetsToPack,
11352
+ exportInfo: exportInfo,
11353
+ exportPackedDatasets: exportPackedDatasets,
11354
+ pack: pack
11372
11355
  });
11373
11356
 
11374
11357
  // Guess the type of a data file from file extension, or return null if not sure
@@ -11493,24 +11476,24 @@
11493
11476
 
11494
11477
  var FileTypes = /*#__PURE__*/Object.freeze({
11495
11478
  __proto__: null,
11496
- guessInputFileType: guessInputFileType,
11497
- isAuxiliaryInputFileType: isAuxiliaryInputFileType,
11479
+ couldBeDsvFile: couldBeDsvFile,
11480
+ filenameIsUnsupportedOutputType: filenameIsUnsupportedOutputType,
11481
+ getFormatName: getFormatName,
11498
11482
  guessInputContentType: guessInputContentType,
11483
+ guessInputFileType: guessInputFileType,
11499
11484
  guessInputType: guessInputType,
11500
- stringLooksLikeJSON: stringLooksLikeJSON,
11501
- stringLooksLikeKML: stringLooksLikeKML,
11502
- couldBeDsvFile: couldBeDsvFile,
11503
- looksLikeImportableFile: looksLikeImportableFile,
11504
- looksLikeContentFile: looksLikeContentFile,
11505
- isPackageFile: isPackageFile,
11506
- isZipFile: isZipFile,
11507
- isKmzFile: isKmzFile,
11485
+ isAuxiliaryInputFileType: isAuxiliaryInputFileType,
11508
11486
  isGzipFile: isGzipFile,
11509
- isSupportedOutputFormat: isSupportedOutputFormat,
11510
- getFormatName: getFormatName,
11511
- isSupportedBinaryInputType: isSupportedBinaryInputType,
11512
11487
  isImportableAsBinary: isImportableAsBinary,
11513
- filenameIsUnsupportedOutputType: filenameIsUnsupportedOutputType
11488
+ isKmzFile: isKmzFile,
11489
+ isPackageFile: isPackageFile,
11490
+ isSupportedBinaryInputType: isSupportedBinaryInputType,
11491
+ isSupportedOutputFormat: isSupportedOutputFormat,
11492
+ isZipFile: isZipFile,
11493
+ looksLikeContentFile: looksLikeContentFile,
11494
+ looksLikeImportableFile: looksLikeImportableFile,
11495
+ stringLooksLikeJSON: stringLooksLikeJSON,
11496
+ stringLooksLikeKML: stringLooksLikeKML
11514
11497
  });
11515
11498
 
11516
11499
  // input: A file path or a buffer
@@ -11618,11 +11601,11 @@
11618
11601
 
11619
11602
  var Zip = /*#__PURE__*/Object.freeze({
11620
11603
  __proto__: null,
11621
- unzipSync: unzipSync,
11604
+ isImportableZipPath: isImportableZipPath,
11622
11605
  unzipAsync: unzipAsync,
11623
- zipSync: zipSync,
11606
+ unzipSync: unzipSync,
11624
11607
  zipAsync: zipAsync,
11625
- isImportableZipPath: isImportableZipPath
11608
+ zipSync: zipSync
11626
11609
  });
11627
11610
 
11628
11611
  var cli = {};
@@ -11850,9 +11833,9 @@
11850
11833
 
11851
11834
  var FileExport = /*#__PURE__*/Object.freeze({
11852
11835
  __proto__: null,
11853
- writeFiles: writeFiles,
11836
+ getOutputPaths: getOutputPaths,
11854
11837
  replaceWriteFiles: replaceWriteFiles,
11855
- getOutputPaths: getOutputPaths
11838
+ writeFiles: writeFiles
11856
11839
  });
11857
11840
 
11858
11841
  // Returns a search function
@@ -12554,8 +12537,8 @@
12554
12537
 
12555
12538
  var PathExport = /*#__PURE__*/Object.freeze({
12556
12539
  __proto__: null,
12557
- exportPointData: exportPointData,
12558
- exportPathData: exportPathData
12540
+ exportPathData: exportPathData,
12541
+ exportPointData: exportPointData
12559
12542
  });
12560
12543
 
12561
12544
  function stringifyAsNDJSON(o) {
@@ -12593,8 +12576,8 @@
12593
12576
 
12594
12577
  var Stringify = /*#__PURE__*/Object.freeze({
12595
12578
  __proto__: null,
12596
- stringifyAsNDJSON: stringifyAsNDJSON,
12597
- getFormattedStringify: getFormattedStringify
12579
+ getFormattedStringify: getFormattedStringify,
12580
+ stringifyAsNDJSON: stringifyAsNDJSON
12598
12581
  });
12599
12582
 
12600
12583
  function isValidArc(arcId, arcs) {
@@ -12715,8 +12698,8 @@
12715
12698
 
12716
12699
  var PathfinderUtils = /*#__PURE__*/Object.freeze({
12717
12700
  __proto__: null,
12718
- getRightmostArc: getRightmostArc,
12719
- chooseRighthandVector: chooseRighthandVector
12701
+ chooseRighthandVector: chooseRighthandVector,
12702
+ getRightmostArc: getRightmostArc
12720
12703
  });
12721
12704
 
12722
12705
  var FWD_USED = 0x8;
@@ -12734,9 +12717,9 @@
12734
12717
  var idx = absArcId(arcId), // get index of path in
12735
12718
  mask;
12736
12719
  if (idx == arcId) { // arcBits controls fwd path
12737
- mask = ~3; // target fwd bits
12720
+ mask = -4; // target fwd bits
12738
12721
  } else { // arcBits controls rev. path
12739
- mask = ~0x30; // target rev bits
12722
+ mask = -49; // target rev bits
12740
12723
  arcBits = arcBits << 4; // shift code to target rev path
12741
12724
  }
12742
12725
  routesArr[idx] &= (arcBits | mask);
@@ -12792,7 +12775,7 @@
12792
12775
  // (these arcs represent shared borders and will not be part of the dissolved path)
12793
12776
  //
12794
12777
  if (dissolve && (newBits & 0x22) === 0x22) {
12795
- newBits &= ~0x11; // make invisible
12778
+ newBits &= -18; // make invisible
12796
12779
  }
12797
12780
  }
12798
12781
 
@@ -12810,11 +12793,11 @@
12810
12793
  closeRev = isInv ? fwd : rev;
12811
12794
 
12812
12795
  if (closeFwd) {
12813
- if (hide) mask &= ~1;
12796
+ if (hide) mask &= -2;
12814
12797
  mask ^= 0x2;
12815
12798
  }
12816
12799
  if (closeRev) {
12817
- if (hide) mask &= ~0x10;
12800
+ if (hide) mask &= -17;
12818
12801
  mask ^= 0x20;
12819
12802
  }
12820
12803
  routesArr[idx] = currBits & mask;
@@ -12945,15 +12928,15 @@
12945
12928
 
12946
12929
  var Pathfinder = /*#__PURE__*/Object.freeze({
12947
12930
  __proto__: null,
12948
- setBits: setBits,
12949
12931
  andBits: andBits,
12950
- setRouteBits: setRouteBits,
12932
+ closeArcRoutes: closeArcRoutes,
12933
+ getPathFinder: getPathFinder,
12934
+ getRingIntersector: getRingIntersector,
12951
12935
  getRouteBits: getRouteBits,
12952
12936
  markPathsAsUsed: markPathsAsUsed,
12953
12937
  openArcRoutes: openArcRoutes,
12954
- closeArcRoutes: closeArcRoutes,
12955
- getPathFinder: getPathFinder,
12956
- getRingIntersector: getRingIntersector
12938
+ setBits: setBits,
12939
+ setRouteBits: setRouteBits
12957
12940
  });
12958
12941
 
12959
12942
  // Keep track of whether positive or negative integer ids are 'used' or not.
@@ -13286,16 +13269,16 @@
13286
13269
 
13287
13270
  var SegmentIntersection = /*#__PURE__*/Object.freeze({
13288
13271
  __proto__: null,
13289
- getIntersectionPoints: getIntersectionPoints,
13290
- getIntersectionLayer: getIntersectionLayer,
13291
- findSegmentIntersections: findSegmentIntersections,
13292
- sortIntersections: sortIntersections,
13293
- dedupIntersections: dedupIntersections,
13294
- calcSegmentIntersectionStripeCount2: calcSegmentIntersectionStripeCount2,
13295
13272
  calcSegmentIntersectionStripeCount: calcSegmentIntersectionStripeCount,
13296
- intersectSegments: intersectSegments,
13273
+ calcSegmentIntersectionStripeCount2: calcSegmentIntersectionStripeCount2,
13274
+ dedupIntersections: dedupIntersections,
13275
+ findSegmentIntersections: findSegmentIntersections,
13276
+ formatIntersectingSegment: formatIntersectingSegment,
13297
13277
  formatIntersection: formatIntersection,
13298
- formatIntersectingSegment: formatIntersectingSegment
13278
+ getIntersectionLayer: getIntersectionLayer,
13279
+ getIntersectionPoints: getIntersectionPoints,
13280
+ intersectSegments: intersectSegments,
13281
+ sortIntersections: sortIntersections
13299
13282
  });
13300
13283
 
13301
13284
  function findNearestVertices(p, shp, arcs) {
@@ -13423,19 +13406,19 @@
13423
13406
 
13424
13407
  var VertexUtils = /*#__PURE__*/Object.freeze({
13425
13408
  __proto__: null,
13409
+ findNearestVertex: findNearestVertex,
13426
13410
  findNearestVertices: findNearestVertices,
13427
- snapVerticesToPoint: snapVerticesToPoint,
13428
- snapPointToArcEndpoint: snapPointToArcEndpoint,
13429
13411
  findVertexIds: findVertexIds,
13430
- getVertexCoords: getVertexCoords,
13431
- vertexIsArcEnd: vertexIsArcEnd,
13432
- vertexIsArcEndpoint: vertexIsArcEndpoint,
13433
- vertexIsArcStart: vertexIsArcStart,
13434
- getArcStartCoords: getArcStartCoords,
13435
13412
  getArcEndCoords: getArcEndCoords,
13436
13413
  getArcEndpointCoords: getArcEndpointCoords,
13414
+ getArcStartCoords: getArcStartCoords,
13415
+ getVertexCoords: getVertexCoords,
13437
13416
  setVertexCoords: setVertexCoords,
13438
- findNearestVertex: findNearestVertex
13417
+ snapPointToArcEndpoint: snapPointToArcEndpoint,
13418
+ snapVerticesToPoint: snapVerticesToPoint,
13419
+ vertexIsArcEnd: vertexIsArcEnd,
13420
+ vertexIsArcEndpoint: vertexIsArcEndpoint,
13421
+ vertexIsArcStart: vertexIsArcStart
13439
13422
  });
13440
13423
 
13441
13424
  // arcs: ArcCollection containing original coordinates
@@ -13645,18 +13628,18 @@
13645
13628
 
13646
13629
  var Rounding = /*#__PURE__*/Object.freeze({
13647
13630
  __proto__: null,
13648
- roundToSignificantDigits: roundToSignificantDigits,
13649
- roundToDigits: roundToDigits,
13650
- roundToDigits2: roundToDigits2,
13651
- roundToTenths: roundToTenths,
13652
- getRoundingFunction: getRoundingFunction,
13631
+ fround: fround,
13632
+ fround2: fround2,
13633
+ getBinaryRoundingFunction: getBinaryRoundingFunction,
13653
13634
  getBoundsPrecisionForDisplay: getBoundsPrecisionForDisplay,
13654
13635
  getRoundedCoordString: getRoundedCoordString,
13655
13636
  getRoundedCoords: getRoundedCoords,
13637
+ getRoundingFunction: getRoundingFunction,
13656
13638
  roundPoints: roundPoints,
13657
- fround2: fround2,
13658
- getBinaryRoundingFunction: getBinaryRoundingFunction,
13659
- fround: fround,
13639
+ roundToDigits: roundToDigits,
13640
+ roundToDigits2: roundToDigits2,
13641
+ roundToSignificantDigits: roundToSignificantDigits,
13642
+ roundToTenths: roundToTenths,
13660
13643
  setCoordinatePrecision: setCoordinatePrecision
13661
13644
  });
13662
13645
 
@@ -13843,16 +13826,16 @@
13843
13826
 
13844
13827
  var Units = /*#__PURE__*/Object.freeze({
13845
13828
  __proto__: null,
13846
- parseSizeParam: parseSizeParam,
13847
- getIntervalConversionFactor: getIntervalConversionFactor,
13848
- parseMeasure: parseMeasure,
13849
- parseMeasure2: parseMeasure2,
13850
13829
  convertAreaParam: convertAreaParam,
13851
13830
  convertDistanceParam: convertDistanceParam,
13852
- convertIntervalParam: convertIntervalParam,
13853
- convertIntervalPair: convertIntervalPair,
13854
13831
  convertFourSides: convertFourSides,
13855
- getAreaLabel: getAreaLabel
13832
+ convertIntervalPair: convertIntervalPair,
13833
+ convertIntervalParam: convertIntervalParam,
13834
+ getAreaLabel: getAreaLabel,
13835
+ getIntervalConversionFactor: getIntervalConversionFactor,
13836
+ parseMeasure: parseMeasure,
13837
+ parseMeasure2: parseMeasure2,
13838
+ parseSizeParam: parseSizeParam
13856
13839
  });
13857
13840
 
13858
13841
  // Used by -clean -dissolve2 -filter-slivers -filter-islands to generate area filters
@@ -13968,11 +13951,11 @@
13968
13951
 
13969
13952
  var Slivers = /*#__PURE__*/Object.freeze({
13970
13953
  __proto__: null,
13971
- getSliverFilter: getSliverFilter,
13972
- getSliverTest: getSliverTest,
13973
- getSliverAreaFunction: getSliverAreaFunction,
13954
+ calcMaxSliverArea: calcMaxSliverArea,
13974
13955
  getDefaultSliverThreshold: getDefaultSliverThreshold,
13975
- calcMaxSliverArea: calcMaxSliverArea
13956
+ getSliverAreaFunction: getSliverAreaFunction,
13957
+ getSliverFilter: getSliverFilter,
13958
+ getSliverTest: getSliverTest
13976
13959
  });
13977
13960
 
13978
13961
  // Returns undefined if not found
@@ -14859,13 +14842,13 @@
14859
14842
 
14860
14843
  var TargetUtils = /*#__PURE__*/Object.freeze({
14861
14844
  __proto__: null,
14845
+ countTargetLayers: countTargetLayers,
14862
14846
  expandCommandTargets: expandCommandTargets,
14863
14847
  findCommandTargets: findCommandTargets,
14864
- groupLayersByDataset: groupLayersByDataset,
14865
14848
  findMatchingLayers: findMatchingLayers,
14866
14849
  getLayerMatch: getLayerMatch,
14867
- countTargetLayers: countTargetLayers,
14868
- getLayerTargetId: getLayerTargetId
14850
+ getLayerTargetId: getLayerTargetId,
14851
+ groupLayersByDataset: groupLayersByDataset
14869
14852
  });
14870
14853
 
14871
14854
  function getNullLayerProxy(targets) {
@@ -15315,10 +15298,10 @@
15315
15298
 
15316
15299
  var Expressions = /*#__PURE__*/Object.freeze({
15317
15300
  __proto__: null,
15318
- getExpressionFunction: getExpressionFunction,
15319
15301
  compileExpressionToFunction: compileExpressionToFunction,
15320
15302
  getAssignedVars: getAssignedVars,
15321
15303
  getBaseContext: getBaseContext,
15304
+ getExpressionFunction: getExpressionFunction,
15322
15305
  nullifyUnsetProperties: nullifyUnsetProperties
15323
15306
  });
15324
15307
 
@@ -15445,8 +15428,8 @@
15445
15428
  var FeatureExpressions = /*#__PURE__*/Object.freeze({
15446
15429
  __proto__: null,
15447
15430
  compileFeatureExpression: compileFeatureExpression,
15448
- compileFeaturePairFilterExpression: compileFeaturePairFilterExpression,
15449
- compileFeaturePairExpression: compileFeaturePairExpression
15431
+ compileFeaturePairExpression: compileFeaturePairExpression,
15432
+ compileFeaturePairFilterExpression: compileFeaturePairFilterExpression
15450
15433
  });
15451
15434
 
15452
15435
  function getMode(values) {
@@ -15804,8 +15787,8 @@
15804
15787
  var Calc = /*#__PURE__*/Object.freeze({
15805
15788
  __proto__: null,
15806
15789
  applyCalcExpression: applyCalcExpression,
15807
- evalCalcExpression: evalCalcExpression,
15808
- compileCalcExpression: compileCalcExpression
15790
+ compileCalcExpression: compileCalcExpression,
15791
+ evalCalcExpression: evalCalcExpression
15809
15792
  });
15810
15793
 
15811
15794
  // get function that returns an object containing calculated values
@@ -15933,9 +15916,9 @@
15933
15916
 
15934
15917
  var DataAggregation = /*#__PURE__*/Object.freeze({
15935
15918
  __proto__: null,
15919
+ aggregateDataRecords: aggregateDataRecords,
15936
15920
  getCategoryClassifier: getCategoryClassifier,
15937
15921
  getMultiFieldKeyFunction: getMultiFieldKeyFunction,
15938
- aggregateDataRecords: aggregateDataRecords,
15939
15922
  recombineDataRecords: recombineDataRecords
15940
15923
  });
15941
15924
 
@@ -16572,7 +16555,7 @@
16572
16555
  // split into two rings that touch each other where the original ring crossed itself.
16573
16556
  //
16574
16557
  function getSelfIntersectionSplitter(nodes) {
16575
- var pathIndex = new IdTestIndex(nodes.arcs.size(), true);
16558
+ var pathIndex = new IdTestIndex(nodes.arcs.size());
16576
16559
  var filter = function(arcId) {
16577
16560
  return pathIndex.hasId(~arcId);
16578
16561
  };
@@ -16669,8 +16652,8 @@
16669
16652
  var PathRepair = /*#__PURE__*/Object.freeze({
16670
16653
  __proto__: null,
16671
16654
  cleanShapes: cleanShapes,
16672
- removeSpikesInPath: removeSpikesInPath,
16673
16655
  getSelfIntersectionSplitter: getSelfIntersectionSplitter,
16656
+ removeSpikesInPath: removeSpikesInPath,
16674
16657
  splitPathByIds: splitPathByIds
16675
16658
  });
16676
16659
 
@@ -17066,14 +17049,14 @@
17066
17049
  var IntersectionCuts = /*#__PURE__*/Object.freeze({
17067
17050
  __proto__: null,
17068
17051
  addIntersectionCuts: addIntersectionCuts,
17069
- divideArcs: divideArcs,
17070
17052
  cutPathsAtIntersections: cutPathsAtIntersections,
17071
- remapDividedArcs: remapDividedArcs,
17072
- insertCutPoints: insertCutPoints,
17073
- getCutPoint: getCutPoint,
17074
- sortCutPoints: sortCutPoints,
17053
+ divideArcs: divideArcs,
17075
17054
  filterSortedCutPoints: filterSortedCutPoints,
17076
- findClippingPoints: findClippingPoints
17055
+ findClippingPoints: findClippingPoints,
17056
+ getCutPoint: getCutPoint,
17057
+ insertCutPoints: insertCutPoints,
17058
+ remapDividedArcs: remapDividedArcs,
17059
+ sortCutPoints: sortCutPoints
17077
17060
  });
17078
17061
 
17079
17062
  // Support for timing using T.start() and T.stop()
@@ -17234,8 +17217,8 @@
17234
17217
 
17235
17218
  var PolygonMosaic = /*#__PURE__*/Object.freeze({
17236
17219
  __proto__: null,
17237
- mosaic: mosaic,
17238
- buildPolygonMosaic: buildPolygonMosaic
17220
+ buildPolygonMosaic: buildPolygonMosaic,
17221
+ mosaic: mosaic
17239
17222
  });
17240
17223
 
17241
17224
  // Map non-negative integers to non-negative integer ids
@@ -17329,14 +17312,14 @@
17329
17312
  //
17330
17313
  function PolygonTiler(mosaic, arcTileIndex, nodes, opts) {
17331
17314
  var arcs = nodes.arcs;
17332
- var visitedTileIndex = new IdTestIndex(mosaic.length, true);
17315
+ var visitedTileIndex = new IdTestIndex(mosaic.length);
17333
17316
  var divide = getHoleDivider(nodes);
17334
17317
  // temp vars
17335
17318
  var currHoles; // arc ids of all holes in shape
17336
17319
  var currRingBbox;
17337
17320
  var tilesInShape; // accumulator for tile ids of tiles in current shape
17338
- var ringIndex = new IdTestIndex(arcs.size(), true);
17339
- var holeIndex = new IdTestIndex(arcs.size(), true);
17321
+ var ringIndex = new IdTestIndex(arcs.size());
17322
+ var holeIndex = new IdTestIndex(arcs.size());
17340
17323
 
17341
17324
  // return ids of tiles in shape
17342
17325
  this.getTilesInShape = function(shp, shapeId) {
@@ -17437,7 +17420,7 @@
17437
17420
  // map arc ids to tile ids
17438
17421
  var arcTileIndex = new ShapeArcIndex(mosaic, nodes.arcs);
17439
17422
  // keep track of which tiles have been assigned to shapes
17440
- var fetchedTileIndex = new IdTestIndex(mosaic.length, true);
17423
+ var fetchedTileIndex = new IdTestIndex(mosaic.length);
17441
17424
  // bidirection index of tile ids <=> shape ids
17442
17425
  var tileShapeIndex = new TileShapeIndex(mosaic, opts);
17443
17426
  // assign tiles to shapes
@@ -17717,9 +17700,9 @@
17717
17700
 
17718
17701
  var PolygonDissolve2 = /*#__PURE__*/Object.freeze({
17719
17702
  __proto__: null,
17720
- dissolvePolygonLayer2: dissolvePolygonLayer2,
17721
17703
  composeMosaicLayer: composeMosaicLayer,
17722
- dissolvePolygonGroups2: dissolvePolygonGroups2
17704
+ dissolvePolygonGroups2: dissolvePolygonGroups2,
17705
+ dissolvePolygonLayer2: dissolvePolygonLayer2
17723
17706
  });
17724
17707
 
17725
17708
  // Assumes intersection cuts have been added and duplicated points removed
@@ -18519,17 +18502,17 @@
18519
18502
 
18520
18503
  var GeojsonExport = /*#__PURE__*/Object.freeze({
18521
18504
  __proto__: null,
18522
- 'default': GeoJSON,
18505
+ default: GeoJSON,
18506
+ exportDatasetAsGeoJSON: exportDatasetAsGeoJSON,
18523
18507
  exportGeoJSON: exportGeoJSON,
18508
+ exportIds: exportIds,
18524
18509
  exportLayerAsGeoJSON: exportLayerAsGeoJSON,
18525
- warnIfNotWgs84: warnIfNotWgs84,
18510
+ exportProperties: exportProperties,
18526
18511
  getDatasetBbox: getDatasetBbox,
18527
- exportDatasetAsGeoJSON: exportDatasetAsGeoJSON,
18512
+ getIdField: getIdField,
18528
18513
  preserveOriginalCRS: preserveOriginalCRS,
18529
18514
  useFeatureCollection: useFeatureCollection,
18530
- exportProperties: exportProperties,
18531
- getIdField: getIdField,
18532
- exportIds: exportIds
18515
+ warnIfNotWgs84: warnIfNotWgs84
18533
18516
  });
18534
18517
 
18535
18518
  /*
@@ -18768,19 +18751,19 @@
18768
18751
 
18769
18752
  var FrameUtils = /*#__PURE__*/Object.freeze({
18770
18753
  __proto__: null,
18771
- getFrameData: getFrameData,
18772
- fitDatasetToFrame: fitDatasetToFrame,
18773
- getFrameLayerData: getFrameLayerData,
18774
18754
  calcFrameData: calcFrameData,
18775
- getFrameSize: getFrameSize,
18776
- isFrameLayer: isFrameLayer,
18777
- findFrameLayerInDataset: findFrameLayerInDataset,
18755
+ calcOutputBounds: calcOutputBounds,
18756
+ findFrame: findFrame,
18778
18757
  findFrameDataset: findFrameDataset,
18779
18758
  findFrameLayer: findFrameLayer,
18780
- findFrame: findFrame,
18759
+ findFrameLayerInDataset: findFrameLayerInDataset,
18760
+ fitDatasetToFrame: fitDatasetToFrame,
18761
+ getFrameData: getFrameData,
18781
18762
  getFrameLayerBounds: getFrameLayerBounds,
18763
+ getFrameLayerData: getFrameLayerData,
18764
+ getFrameSize: getFrameSize,
18782
18765
  getMapFrameMetersPerPixel: getMapFrameMetersPerPixel,
18783
- calcOutputBounds: calcOutputBounds,
18766
+ isFrameLayer: isFrameLayer,
18784
18767
  parseMarginOption: parseMarginOption
18785
18768
  });
18786
18769
 
@@ -18890,7 +18873,6 @@
18890
18873
  function getFitBoxTransform(bbox, points, shapes, arcs) {
18891
18874
  var dataset = {
18892
18875
  arcs: arcs,
18893
- info: {},
18894
18876
  layers: []
18895
18877
  };
18896
18878
  if (points && points.length) {
@@ -18986,8 +18968,8 @@
18986
18968
 
18987
18969
  var SvgPathUtils = /*#__PURE__*/Object.freeze({
18988
18970
  __proto__: null,
18989
- stringifyPolygonCoords: stringifyPolygonCoords,
18990
- stringifyLineStringCoords: stringifyLineStringCoords
18971
+ stringifyLineStringCoords: stringifyLineStringCoords,
18972
+ stringifyPolygonCoords: stringifyPolygonCoords
18991
18973
  });
18992
18974
 
18993
18975
  /* example patterns
@@ -19231,11 +19213,11 @@
19231
19213
 
19232
19214
  var SvgHatch = /*#__PURE__*/Object.freeze({
19233
19215
  __proto__: null,
19234
- parsePattern: parsePattern,
19216
+ convertFillPattern: convertFillPattern,
19235
19217
  parseDashes: parseDashes,
19236
- parseHatches: parseHatches,
19237
19218
  parseDots: parseDots,
19238
- convertFillPattern: convertFillPattern
19219
+ parseHatches: parseHatches,
19220
+ parsePattern: parsePattern
19239
19221
  });
19240
19222
 
19241
19223
  // parsing hints for -style command cli options
@@ -19485,17 +19467,17 @@
19485
19467
  var SvgProperties = /*#__PURE__*/Object.freeze({
19486
19468
  __proto__: null,
19487
19469
  applyStyleAttributes: applyStyleAttributes,
19488
- isSupportedSvgStyleProperty: isSupportedSvgStyleProperty,
19489
19470
  findPropertiesBySymbolGeom: findPropertiesBySymbolGeom,
19490
19471
  getSymbolDataAccessor: getSymbolDataAccessor,
19491
- mightBeExpression: mightBeExpression,
19492
19472
  getSymbolPropertyAccessor: getSymbolPropertyAccessor,
19473
+ isSupportedSvgStyleProperty: isSupportedSvgStyleProperty,
19493
19474
  isSvgClassName: isSvgClassName,
19475
+ isSvgColor: isSvgColor,
19476
+ isSvgMeasure: isSvgMeasure,
19494
19477
  isSvgNumber: isSvgNumber,
19478
+ mightBeExpression: mightBeExpression,
19495
19479
  parseBoolean: parseBoolean,
19496
- isSvgMeasure: isSvgMeasure,
19497
- parseSvgMeasure: parseSvgMeasure,
19498
- isSvgColor: isSvgColor
19480
+ parseSvgMeasure: parseSvgMeasure
19499
19481
  });
19500
19482
 
19501
19483
  var geojsonImporters = {
@@ -19619,12 +19601,12 @@
19619
19601
 
19620
19602
  var GeojsonToSvg = /*#__PURE__*/Object.freeze({
19621
19603
  __proto__: null,
19604
+ flattenMultiPolygonCoords: flattenMultiPolygonCoords,
19622
19605
  importGeoJSONFeatures: importGeoJSONFeatures,
19623
- importPoint: importPoint,
19624
19606
  importLineString: importLineString,
19625
19607
  importMultiLineString: importMultiLineString,
19626
19608
  importMultiPolygon: importMultiPolygon,
19627
- flattenMultiPolygonCoords: flattenMultiPolygonCoords,
19609
+ importPoint: importPoint,
19628
19610
  importPolygon: importPolygon
19629
19611
  });
19630
19612
 
@@ -19685,11 +19667,12 @@
19685
19667
 
19686
19668
  var SvgLabels = /*#__PURE__*/Object.freeze({
19687
19669
  __proto__: null,
19688
- renderStyledLabel: renderStyledLabel,
19689
- renderLabel: renderLabel$1
19670
+ renderLabel: renderLabel$1,
19671
+ renderStyledLabel: renderStyledLabel
19690
19672
  });
19691
19673
 
19692
19674
  // convert data records (properties like svg-symbol, label-text, fill, r) to svg symbols
19675
+ //
19693
19676
 
19694
19677
  function getTransform(xy, scale) {
19695
19678
  var str = 'translate(' + roundToTenths(xy[0]) + ' ' + roundToTenths(xy[1]) + ')';
@@ -19878,8 +19861,8 @@
19878
19861
  var SvgSymbols = /*#__PURE__*/Object.freeze({
19879
19862
  __proto__: null,
19880
19863
  getTransform: getTransform,
19881
- symbolRenderers: symbolRenderers,
19882
- renderPoint: renderPoint
19864
+ renderPoint: renderPoint,
19865
+ symbolRenderers: symbolRenderers
19883
19866
  });
19884
19867
 
19885
19868
  cmd.scalebar = function(catalog, opts) {
@@ -20157,10 +20140,10 @@
20157
20140
 
20158
20141
  var Scalebar = /*#__PURE__*/Object.freeze({
20159
20142
  __proto__: null,
20160
- getScalebarLayer: getScalebarLayer,
20161
- renderScalebar: renderScalebar,
20162
20143
  formatDistanceLabel: formatDistanceLabel,
20163
- parseScalebarLabelToKm: parseScalebarLabelToKm
20144
+ getScalebarLayer: getScalebarLayer,
20145
+ parseScalebarLabelToKm: parseScalebarLabelToKm,
20146
+ renderScalebar: renderScalebar
20164
20147
  });
20165
20148
 
20166
20149
  var furnitureRenderers = {
@@ -20206,10 +20189,10 @@
20206
20189
 
20207
20190
  var Furniture = /*#__PURE__*/Object.freeze({
20208
20191
  __proto__: null,
20209
- layerHasFurniture: layerHasFurniture,
20210
- isFurnitureLayer: isFurnitureLayer,
20211
- getFurnitureLayerType: getFurnitureLayerType,
20212
20192
  getFurnitureLayerData: getFurnitureLayerData,
20193
+ getFurnitureLayerType: getFurnitureLayerType,
20194
+ isFurnitureLayer: isFurnitureLayer,
20195
+ layerHasFurniture: layerHasFurniture,
20213
20196
  renderFurnitureLayer: renderFurnitureLayer
20214
20197
  });
20215
20198
 
@@ -20276,8 +20259,8 @@
20276
20259
 
20277
20260
  var SvgStringify = /*#__PURE__*/Object.freeze({
20278
20261
  __proto__: null,
20279
- stringify: stringify,
20280
20262
  stringEscape: stringEscape,
20263
+ stringify: stringify,
20281
20264
  stringifyProperties: stringifyProperties
20282
20265
  });
20283
20266
 
@@ -20359,8 +20342,8 @@
20359
20342
 
20360
20343
  var SvgEffect = /*#__PURE__*/Object.freeze({
20361
20344
  __proto__: null,
20362
- getSphereEffectParams: getSphereEffectParams,
20363
- convertFillEffect: convertFillEffect
20345
+ convertFillEffect: convertFillEffect,
20346
+ getSphereEffectParams: getSphereEffectParams
20364
20347
  });
20365
20348
 
20366
20349
  var cache = {};
@@ -20731,16 +20714,16 @@ ${svg}
20731
20714
 
20732
20715
  var Svg = /*#__PURE__*/Object.freeze({
20733
20716
  __proto__: null,
20734
- exportSVG: exportSVG,
20717
+ exportDataAttributesForSVG: exportDataAttributesForSVG,
20735
20718
  exportFurnitureLayerForSVG: exportFurnitureLayerForSVG,
20736
20719
  exportLayerForSVG: exportLayerForSVG,
20737
- validateSvgDataFields: validateSvgDataFields,
20738
- exportDataAttributesForSVG: exportDataAttributesForSVG,
20739
- getEmptyLayerForSVG: getEmptyLayerForSVG,
20740
- featureHasSvgSymbol: featureHasSvgSymbol,
20720
+ exportSVG: exportSVG,
20741
20721
  featureHasLabel: featureHasLabel,
20722
+ featureHasSvgSymbol: featureHasSvgSymbol,
20723
+ getEmptyLayerForSVG: getEmptyLayerForSVG,
20724
+ layerHasLabels: layerHasLabels,
20742
20725
  layerHasSvgSymbols: layerHasSvgSymbols,
20743
- layerHasLabels: layerHasLabels
20726
+ validateSvgDataFields: validateSvgDataFields
20744
20727
  });
20745
20728
 
20746
20729
  // import { isKmzFile } from '../io/mapshaper-file-types';
@@ -21046,8 +21029,8 @@ ${svg}
21046
21029
 
21047
21030
  var BinArray$1 = /*#__PURE__*/Object.freeze({
21048
21031
  __proto__: null,
21049
- buffersAreIdentical: buffersAreIdentical,
21050
- BinArray: BinArray
21032
+ BinArray: BinArray,
21033
+ buffersAreIdentical: buffersAreIdentical
21051
21034
  });
21052
21035
 
21053
21036
  var Dbf = {};
@@ -22399,8 +22382,8 @@ ${svg}
22399
22382
 
22400
22383
  var TopojsonExport = /*#__PURE__*/Object.freeze({
22401
22384
  __proto__: null,
22402
- exportTopoJSON: exportTopoJSON,
22403
- calcExportBounds: calcExportBounds
22385
+ calcExportBounds: calcExportBounds,
22386
+ exportTopoJSON: exportTopoJSON
22404
22387
  });
22405
22388
 
22406
22389
  function importJSONTable(arr) {
@@ -22439,9 +22422,9 @@ ${svg}
22439
22422
 
22440
22423
  var JsonTable = /*#__PURE__*/Object.freeze({
22441
22424
  __proto__: null,
22442
- importJSONTable: importJSONTable,
22443
22425
  exportJSON: exportJSON,
22444
- exportJSONTable: exportJSONTable
22426
+ exportJSONTable: exportJSONTable,
22427
+ importJSONTable: importJSONTable
22445
22428
  });
22446
22429
 
22447
22430
  function getOutputFormat(dataset, opts) {
@@ -22757,10 +22740,10 @@ ${svg}
22757
22740
 
22758
22741
  var Export = /*#__PURE__*/Object.freeze({
22759
22742
  __proto__: null,
22760
- exportTargetLayers: exportTargetLayers,
22761
- exportFileContent: exportFileContent,
22762
- assignUniqueLayerNames: assignUniqueLayerNames,
22763
22743
  assignUniqueFileNames: assignUniqueFileNames,
22744
+ assignUniqueLayerNames: assignUniqueLayerNames,
22745
+ exportFileContent: exportFileContent,
22746
+ exportTargetLayers: exportTargetLayers,
22764
22747
  formatVersionedFileName: formatVersionedFileName
22765
22748
  });
22766
22749
 
@@ -22945,10 +22928,10 @@ ${svg}
22945
22928
 
22946
22929
  var FileReader$1 = /*#__PURE__*/Object.freeze({
22947
22930
  __proto__: null,
22948
- readFirstChars: readFirstChars,
22949
- Reader2: Reader2,
22950
22931
  BufferReader: BufferReader,
22951
- FileReader: FileReader
22932
+ FileReader: FileReader,
22933
+ Reader2: Reader2,
22934
+ readFirstChars: readFirstChars
22952
22935
  });
22953
22936
 
22954
22937
  // Read and parse a DSV file
@@ -23200,14 +23183,14 @@ ${svg}
23200
23183
 
23201
23184
  var DelimReader = /*#__PURE__*/Object.freeze({
23202
23185
  __proto__: null,
23203
- readDelimRecords: readDelimRecords,
23204
- readDelimRecordsFromString: readDelimRecordsFromString,
23205
- indexOfLine: indexOfLine,
23186
+ getDelimFieldFilter: getDelimFieldFilter,
23206
23187
  getRowConverter: getRowConverter,
23188
+ indexOfLine: indexOfLine,
23207
23189
  parseDelimHeaderSection: parseDelimHeaderSection,
23208
- getDelimFieldFilter: getDelimFieldFilter,
23209
- readLinesAsString: readLinesAsString,
23210
- parseDelimText: parseDelimText
23190
+ parseDelimText: parseDelimText,
23191
+ readDelimRecords: readDelimRecords,
23192
+ readDelimRecordsFromString: readDelimRecordsFromString,
23193
+ readLinesAsString: readLinesAsString
23211
23194
  });
23212
23195
 
23213
23196
  function detectEncodingFromBOM(bytes) {
@@ -23339,9 +23322,9 @@ ${svg}
23339
23322
 
23340
23323
  var EncodingDetection = /*#__PURE__*/Object.freeze({
23341
23324
  __proto__: null,
23342
- detectEncodingFromBOM: detectEncodingFromBOM,
23325
+ decodeSamples: decodeSamples,
23343
23326
  detectEncoding: detectEncoding,
23344
- decodeSamples: decodeSamples
23327
+ detectEncodingFromBOM: detectEncodingFromBOM
23345
23328
  });
23346
23329
 
23347
23330
  // Convert a string containing delimited text data into a dataset object
@@ -23550,12 +23533,12 @@ ${svg}
23550
23533
 
23551
23534
  var DelimImport = /*#__PURE__*/Object.freeze({
23552
23535
  __proto__: null,
23536
+ adjustRecordTypes: adjustRecordTypes,
23537
+ getFieldTypeHints: getFieldTypeHints,
23538
+ guessDelimiter: guessDelimiter,
23553
23539
  importDelim: importDelim,
23554
23540
  importDelim2: importDelim2,
23555
- isSupportedDelimiter: isSupportedDelimiter,
23556
- guessDelimiter: guessDelimiter,
23557
- getFieldTypeHints: getFieldTypeHints,
23558
- adjustRecordTypes: adjustRecordTypes
23541
+ isSupportedDelimiter: isSupportedDelimiter
23559
23542
  });
23560
23543
 
23561
23544
  function validateInputOpts(cmd) {
@@ -23798,14 +23781,14 @@ ${svg}
23798
23781
 
23799
23782
  var OptionParsingUtils = /*#__PURE__*/Object.freeze({
23800
23783
  __proto__: null,
23801
- splitShellTokens: splitShellTokens,
23802
- parseNumberList: parseNumberList,
23803
- parseStringList: parseStringList,
23804
- parseColorList: parseColorList,
23805
23784
  cleanArgv: cleanArgv,
23806
23785
  formatOptionValue: formatOptionValue,
23807
23786
  isAssignment: isAssignment,
23808
- splitAssignment: splitAssignment
23787
+ parseColorList: parseColorList,
23788
+ parseNumberList: parseNumberList,
23789
+ parseStringList: parseStringList,
23790
+ splitAssignment: splitAssignment,
23791
+ splitShellTokens: splitShellTokens
23809
23792
  });
23810
23793
 
23811
23794
  function CommandParser() {
@@ -27033,8 +27016,8 @@ ${svg}
27033
27016
 
27034
27017
  var DbfImport = /*#__PURE__*/Object.freeze({
27035
27018
  __proto__: null,
27036
- importDbfTable: importDbfTable,
27037
- ShapefileTable: ShapefileTable
27019
+ ShapefileTable: ShapefileTable,
27020
+ importDbfTable: importDbfTable
27038
27021
  });
27039
27022
 
27040
27023
  function translateShapefileType(shpType) {
@@ -27055,8 +27038,8 @@ ${svg}
27055
27038
 
27056
27039
  var ShpCommon = /*#__PURE__*/Object.freeze({
27057
27040
  __proto__: null,
27058
- translateShapefileType: translateShapefileType,
27059
- isSupportedShapefileType: isSupportedShapefileType
27041
+ isSupportedShapefileType: isSupportedShapefileType,
27042
+ translateShapefileType: translateShapefileType
27060
27043
  });
27061
27044
 
27062
27045
  function getNullRecord(id) {
@@ -27769,9 +27752,9 @@ ${svg}
27769
27752
 
27770
27753
  var PathImport = /*#__PURE__*/Object.freeze({
27771
27754
  __proto__: null,
27755
+ PathImporter: PathImporter,
27772
27756
  cleanPathsAfterImport: cleanPathsAfterImport,
27773
- pointHasValidCoords: pointHasValidCoords,
27774
- PathImporter: PathImporter
27757
+ pointHasValidCoords: pointHasValidCoords
27775
27758
  });
27776
27759
 
27777
27760
  // Read Shapefile data from a file, ArrayBuffer or Buffer
@@ -27979,9 +27962,9 @@ ${svg}
27979
27962
 
27980
27963
  var GeojsonImport = /*#__PURE__*/Object.freeze({
27981
27964
  __proto__: null,
27982
- importGeoJSON: importGeoJSON,
27983
27965
  GeoJSONParser: GeoJSONParser,
27984
- importCRS: importCRS
27966
+ importCRS: importCRS,
27967
+ importGeoJSON: importGeoJSON
27985
27968
  });
27986
27969
 
27987
27970
  // Convert a TopoJSON topology into mapshaper's internal format
@@ -28907,8 +28890,8 @@ ${svg}
28907
28890
 
28908
28891
  var JsonImport = /*#__PURE__*/Object.freeze({
28909
28892
  __proto__: null,
28910
- identifyJSONString: identifyJSONString,
28911
28893
  identifyJSONObject: identifyJSONObject,
28894
+ identifyJSONString: identifyJSONString,
28912
28895
  importGeoJSONFile: importGeoJSONFile,
28913
28896
  importJSON: importJSON
28914
28897
  });
@@ -29153,8 +29136,8 @@ ${svg}
29153
29136
 
29154
29137
  var Unpack = /*#__PURE__*/Object.freeze({
29155
29138
  __proto__: null,
29156
- unpackSessionData: unpackSessionData,
29157
- restoreSessionData: restoreSessionData
29139
+ restoreSessionData: restoreSessionData,
29140
+ unpackSessionData: unpackSessionData
29158
29141
  });
29159
29142
 
29160
29143
  cmd.importFiles = async function(catalog, opts) {
@@ -29410,9 +29393,9 @@ ${svg}
29410
29393
 
29411
29394
  var FileImport = /*#__PURE__*/Object.freeze({
29412
29395
  __proto__: null,
29413
- replaceImportFile: replaceImportFile,
29414
29396
  importFile: importFile,
29415
- importFilesTogether: importFilesTogether
29397
+ importFilesTogether: importFilesTogether,
29398
+ replaceImportFile: replaceImportFile
29416
29399
  });
29417
29400
 
29418
29401
  function convertSourceName(name, targets) {
@@ -29462,8 +29445,8 @@ ${svg}
29462
29445
 
29463
29446
  var SourceUtils = /*#__PURE__*/Object.freeze({
29464
29447
  __proto__: null,
29465
- convertSourceName: convertSourceName,
29466
29448
  convertInterpolatedName: convertInterpolatedName,
29449
+ convertSourceName: convertSourceName,
29467
29450
  findCommandSource: findCommandSource
29468
29451
  });
29469
29452
 
@@ -30802,13 +30785,13 @@ ${svg}
30802
30785
  var BufferCommon = /*#__PURE__*/Object.freeze({
30803
30786
  __proto__: null,
30804
30787
  dissolveBufferDataset: dissolveBufferDataset,
30805
- getBufferToleranceFromCircleSegments: getBufferToleranceFromCircleSegments,
30806
30788
  getArcDegreesFromTolerancePct: getArcDegreesFromTolerancePct,
30807
- getBufferToleranceFromCircleSegments2: getBufferToleranceFromCircleSegments2,
30808
30789
  getArcDegreesFromTolerancePct2: getArcDegreesFromTolerancePct2,
30809
- parseConstantBufferDistance: parseConstantBufferDistance,
30790
+ getBufferDistanceFunction: getBufferDistanceFunction,
30791
+ getBufferToleranceFromCircleSegments: getBufferToleranceFromCircleSegments,
30792
+ getBufferToleranceFromCircleSegments2: getBufferToleranceFromCircleSegments2,
30810
30793
  getBufferToleranceFunction: getBufferToleranceFunction,
30811
- getBufferDistanceFunction: getBufferDistanceFunction
30794
+ parseConstantBufferDistance: parseConstantBufferDistance
30812
30795
  });
30813
30796
 
30814
30797
  // Returns a function for generating GeoJSON geometries (MultiLineString or MultiPolygon)
@@ -31038,9 +31021,9 @@ ${svg}
31038
31021
 
31039
31022
  var PathBuffer = /*#__PURE__*/Object.freeze({
31040
31023
  __proto__: null,
31041
- getPolylineBufferMaker: getPolylineBufferMaker,
31042
31024
  addBufferVertex: addBufferVertex,
31043
- bufferIntersection: bufferIntersection
31025
+ bufferIntersection: bufferIntersection,
31026
+ getPolylineBufferMaker: getPolylineBufferMaker
31044
31027
  });
31045
31028
 
31046
31029
  function getPolylineBufferMaker2(arcs, geod, getBearing, opts) {
@@ -31417,14 +31400,14 @@ ${svg}
31417
31400
 
31418
31401
  var Geodesic = /*#__PURE__*/Object.freeze({
31419
31402
  __proto__: null,
31420
- interpolatePoint2D: interpolatePoint2D,
31421
- getInterpolationFunction: getInterpolationFunction,
31422
- getPlanarSegmentEndpoint: getPlanarSegmentEndpoint,
31423
- getGeodeticSegmentFunction: getGeodeticSegmentFunction,
31424
- getFastGeodeticSegmentFunction: getFastGeodeticSegmentFunction,
31425
31403
  bearingDegrees: bearingDegrees,
31426
31404
  bearingDegrees2D: bearingDegrees2D,
31427
- getBearingFunction: getBearingFunction
31405
+ getBearingFunction: getBearingFunction,
31406
+ getFastGeodeticSegmentFunction: getFastGeodeticSegmentFunction,
31407
+ getGeodeticSegmentFunction: getGeodeticSegmentFunction,
31408
+ getInterpolationFunction: getInterpolationFunction,
31409
+ getPlanarSegmentEndpoint: getPlanarSegmentEndpoint,
31410
+ interpolatePoint2D: interpolatePoint2D
31428
31411
  });
31429
31412
 
31430
31413
  function makePolylineBuffer(lyr, dataset, opts) {
@@ -31794,7 +31777,7 @@ ${svg}
31794
31777
 
31795
31778
  // Make a single geodetic circle
31796
31779
  function getCircleGeoJSON(center, radius, vertices, opts) {
31797
- var n = vertices || 360;
31780
+ var n = 360;
31798
31781
  var geod = getGeodeticSegmentFunction(parseCrsString('wgs84')); // ?
31799
31782
  if (opts.inset) {
31800
31783
  radius -= opts.inset;
@@ -32464,10 +32447,10 @@ ${svg}
32464
32447
  const degrees = 180 / Math.PI;
32465
32448
 
32466
32449
  var A = -0.14861,
32467
- B = +1.78277,
32450
+ B = 1.78277,
32468
32451
  C = -0.29227,
32469
32452
  D = -0.90649,
32470
- E = +1.97294,
32453
+ E = 1.97294,
32471
32454
  ED = E * D,
32472
32455
  EB = E * B,
32473
32456
  BC_DA = B * C - D * A;
@@ -33619,8 +33602,8 @@ ${svg}
33619
33602
 
33620
33603
  var PolygonNeighbors = /*#__PURE__*/Object.freeze({
33621
33604
  __proto__: null,
33622
- getNeighborLookupFunction: getNeighborLookupFunction,
33623
- findPairsOfNeighbors: findPairsOfNeighbors
33605
+ findPairsOfNeighbors: findPairsOfNeighbors,
33606
+ getNeighborLookupFunction: getNeighborLookupFunction
33624
33607
  });
33625
33608
 
33626
33609
  function getNonAdjacentClassifier(lyr, dataset, colors) {
@@ -34240,81 +34223,81 @@ ${svg}
34240
34223
 
34241
34224
  var d3Scales = /*#__PURE__*/Object.freeze({
34242
34225
  __proto__: null,
34243
- schemeCategory10: category10,
34244
- schemeAccent: Accent,
34245
- schemeDark2: Dark2,
34246
- schemePaired: Paired,
34247
- schemePastel1: Pastel1,
34248
- schemePastel2: Pastel2,
34249
- schemeSet1: Set1,
34250
- schemeSet2: Set2,
34251
- schemeSet3: Set3,
34252
- schemeTableau10: Tableau10,
34226
+ interpolateBlues: Blues,
34253
34227
  interpolateBrBG: BrBG,
34254
- schemeBrBG: scheme$q,
34228
+ interpolateBuGn: BuGn,
34229
+ interpolateBuPu: BuPu,
34230
+ interpolateCividis: cividis,
34231
+ interpolateCool: cool,
34232
+ interpolateCubehelixDefault: cubehelix,
34233
+ interpolateGnBu: GnBu,
34234
+ interpolateGreens: Greens,
34235
+ interpolateGreys: Greys,
34236
+ interpolateInferno: inferno,
34237
+ interpolateMagma: magma,
34238
+ interpolateOrRd: OrRd,
34239
+ interpolateOranges: Oranges,
34255
34240
  interpolatePRGn: PRGn,
34256
- schemePRGn: scheme$p,
34257
34241
  interpolatePiYG: PiYG,
34258
- schemePiYG: scheme$o,
34242
+ interpolatePlasma: plasma,
34243
+ interpolatePuBu: PuBu,
34244
+ interpolatePuBuGn: PuBuGn,
34259
34245
  interpolatePuOr: PuOr,
34260
- schemePuOr: scheme$n,
34246
+ interpolatePuRd: PuRd,
34247
+ interpolatePurples: Purples,
34248
+ interpolateRainbow: rainbow,
34261
34249
  interpolateRdBu: RdBu,
34262
- schemeRdBu: scheme$m,
34263
34250
  interpolateRdGy: RdGy,
34264
- schemeRdGy: scheme$l,
34251
+ interpolateRdPu: RdPu,
34265
34252
  interpolateRdYlBu: RdYlBu,
34266
- schemeRdYlBu: scheme$k,
34267
34253
  interpolateRdYlGn: RdYlGn,
34268
- schemeRdYlGn: scheme$j,
34254
+ interpolateReds: Reds,
34255
+ interpolateSinebow: sinebow,
34269
34256
  interpolateSpectral: Spectral,
34270
- schemeSpectral: scheme$i,
34271
- interpolateBuGn: BuGn,
34257
+ interpolateTurbo: turbo,
34258
+ interpolateViridis: viridis,
34259
+ interpolateWarm: warm,
34260
+ interpolateYlGn: YlGn,
34261
+ interpolateYlGnBu: YlGnBu,
34262
+ interpolateYlOrBr: YlOrBr,
34263
+ interpolateYlOrRd: YlOrRd,
34264
+ schemeAccent: Accent,
34265
+ schemeBlues: scheme$5,
34266
+ schemeBrBG: scheme$q,
34272
34267
  schemeBuGn: scheme$h,
34273
- interpolateBuPu: BuPu,
34274
34268
  schemeBuPu: scheme$g,
34275
- interpolateGnBu: GnBu,
34269
+ schemeCategory10: category10,
34270
+ schemeDark2: Dark2,
34276
34271
  schemeGnBu: scheme$f,
34277
- interpolateOrRd: OrRd,
34272
+ schemeGreens: scheme$4,
34273
+ schemeGreys: scheme$3,
34278
34274
  schemeOrRd: scheme$e,
34279
- interpolatePuBuGn: PuBuGn,
34280
- schemePuBuGn: scheme$d,
34281
- interpolatePuBu: PuBu,
34275
+ schemeOranges: scheme,
34276
+ schemePRGn: scheme$p,
34277
+ schemePaired: Paired,
34278
+ schemePastel1: Pastel1,
34279
+ schemePastel2: Pastel2,
34280
+ schemePiYG: scheme$o,
34282
34281
  schemePuBu: scheme$c,
34283
- interpolatePuRd: PuRd,
34282
+ schemePuBuGn: scheme$d,
34283
+ schemePuOr: scheme$n,
34284
34284
  schemePuRd: scheme$b,
34285
- interpolateRdPu: RdPu,
34285
+ schemePurples: scheme$2,
34286
+ schemeRdBu: scheme$m,
34287
+ schemeRdGy: scheme$l,
34286
34288
  schemeRdPu: scheme$a,
34287
- interpolateYlGnBu: YlGnBu,
34288
- schemeYlGnBu: scheme$9,
34289
- interpolateYlGn: YlGn,
34289
+ schemeRdYlBu: scheme$k,
34290
+ schemeRdYlGn: scheme$j,
34291
+ schemeReds: scheme$1,
34292
+ schemeSet1: Set1,
34293
+ schemeSet2: Set2,
34294
+ schemeSet3: Set3,
34295
+ schemeSpectral: scheme$i,
34296
+ schemeTableau10: Tableau10,
34290
34297
  schemeYlGn: scheme$8,
34291
- interpolateYlOrBr: YlOrBr,
34298
+ schemeYlGnBu: scheme$9,
34292
34299
  schemeYlOrBr: scheme$7,
34293
- interpolateYlOrRd: YlOrRd,
34294
- schemeYlOrRd: scheme$6,
34295
- interpolateBlues: Blues,
34296
- schemeBlues: scheme$5,
34297
- interpolateGreens: Greens,
34298
- schemeGreens: scheme$4,
34299
- interpolateGreys: Greys,
34300
- schemeGreys: scheme$3,
34301
- interpolatePurples: Purples,
34302
- schemePurples: scheme$2,
34303
- interpolateReds: Reds,
34304
- schemeReds: scheme$1,
34305
- interpolateOranges: Oranges,
34306
- schemeOranges: scheme,
34307
- interpolateCividis: cividis,
34308
- interpolateCubehelixDefault: cubehelix,
34309
- interpolateRainbow: rainbow,
34310
- interpolateWarm: warm,
34311
- interpolateCool: cool,
34312
- interpolateSinebow: sinebow,
34313
- interpolateTurbo: turbo,
34314
- interpolateViridis: viridis,
34315
- interpolateMagma: magma,
34316
- interpolateInferno: inferno,
34317
- interpolatePlasma: plasma
34300
+ schemeYlOrRd: scheme$6
34318
34301
  });
34319
34302
 
34320
34303
  var index = {
@@ -35045,7 +35028,7 @@ ${svg}
35045
35028
  // Need to expose clip/erase routes in both directions by setting route
35046
35029
  // in both directions to visible -- this is how cut-out shapes are detected
35047
35030
  // Or-ing with 0x11 makes both directions visible (so reverse paths will block)
35048
- openArcRoutes(clipShapes, arcs, clipFlags, type == 'clip', type == 'erase', !!"dissolve", 0x11);
35031
+ openArcRoutes(clipShapes, arcs, clipFlags, type == 'clip', type == 'erase', true, 0x11);
35049
35032
  var index = new PathIndex(clipShapes, arcs);
35050
35033
  var clippedShapes = targetShapes.map(function(shape, i) {
35051
35034
  if (shape) {
@@ -35461,8 +35444,8 @@ ${svg}
35461
35444
  var Bbox2Clipping = /*#__PURE__*/Object.freeze({
35462
35445
  __proto__: null,
35463
35446
  divideDatasetByBBox: divideDatasetByBBox,
35464
- segmentOutsideBBox: segmentOutsideBBox,
35465
- segmentInsideBBox: segmentInsideBBox
35447
+ segmentInsideBBox: segmentInsideBBox,
35448
+ segmentOutsideBBox: segmentOutsideBBox
35466
35449
  });
35467
35450
 
35468
35451
  cmd.clipLayers = function(target, src, dataset, opts) {
@@ -35628,10 +35611,10 @@ ${svg}
35628
35611
 
35629
35612
  var ClipErase = /*#__PURE__*/Object.freeze({
35630
35613
  __proto__: null,
35631
- clipLayersInPlace: clipLayersInPlace,
35632
35614
  clipLayers: clipLayers,
35633
35615
  clipLayersByBBox: clipLayersByBBox,
35634
35616
  clipLayersByLayer: clipLayersByLayer,
35617
+ clipLayersInPlace: clipLayersInPlace,
35635
35618
  getClipMessage: getClipMessage
35636
35619
  });
35637
35620
 
@@ -36548,10 +36531,10 @@ ${svg}
36548
36531
 
36549
36532
  var Info = /*#__PURE__*/Object.freeze({
36550
36533
  __proto__: null,
36551
- getLayerInfo: getLayerInfo,
36552
- getAttributeTableInfo: getAttributeTableInfo,
36553
36534
  formatAttributeTableInfo: formatAttributeTableInfo,
36554
- formatTableValue: formatTableValue
36535
+ formatTableValue: formatTableValue,
36536
+ getAttributeTableInfo: getAttributeTableInfo,
36537
+ getLayerInfo: getLayerInfo
36555
36538
  });
36556
36539
 
36557
36540
  // import { importGeoJSON } from '../geojson/geojson-import';
@@ -37038,12 +37021,12 @@ ${svg}
37038
37021
 
37039
37022
  var JoinTables = /*#__PURE__*/Object.freeze({
37040
37023
  __proto__: null,
37041
- joinTables: joinTables,
37024
+ findCollisionFields: findCollisionFields,
37025
+ getFieldsToJoin: getFieldsToJoin,
37042
37026
  joinTableToLayer: joinTableToLayer,
37043
- validateFieldNames: validateFieldNames,
37027
+ joinTables: joinTables,
37044
37028
  updateUnmatchedRecord: updateUnmatchedRecord,
37045
- findCollisionFields: findCollisionFields,
37046
- getFieldsToJoin: getFieldsToJoin
37029
+ validateFieldNames: validateFieldNames
37047
37030
  });
37048
37031
 
37049
37032
  cmd.divide = function(targetLayers, targetDataset, source, opts) {
@@ -38063,8 +38046,8 @@ ${svg}
38063
38046
 
38064
38047
  var FilterGeom = /*#__PURE__*/Object.freeze({
38065
38048
  __proto__: null,
38066
- getBBoxIntersectionTest: getBBoxIntersectionTest,
38067
- findShapesIntersectingBBox: findShapesIntersectingBBox
38049
+ findShapesIntersectingBBox: findShapesIntersectingBBox,
38050
+ getBBoxIntersectionTest: getBBoxIntersectionTest
38068
38051
  });
38069
38052
 
38070
38053
  cmd.filterFeatures = function(lyr, arcs, opts) {
@@ -38131,7 +38114,6 @@ ${svg}
38131
38114
  utils.repeat(n, function(shapeId) {
38132
38115
  var result = filter(shapeId);
38133
38116
  requireBooleanResult(result);
38134
- if (invert) result = !result;
38135
38117
  if (result === true) {
38136
38118
  if (shapes) filteredShapes.push(shapes[shapeId] || null);
38137
38119
  if (records) filteredRecords.push(records[shapeId] || null);
@@ -38451,7 +38433,6 @@ ${svg}
38451
38433
  var coords = [];
38452
38434
  var ascending = a[1] < b[1];
38453
38435
  if (a[0] != b[0]) error('Expected an edge segment');
38454
- if (interval > 0 === false) error('Expected a positive interval');
38455
38436
  if (ascending) {
38456
38437
  y1 = a[1];
38457
38438
  y2 = b[1];
@@ -39233,10 +39214,10 @@ ${svg}
39233
39214
 
39234
39215
  var PointPolygonJoin = /*#__PURE__*/Object.freeze({
39235
39216
  __proto__: null,
39217
+ getPolygonToPointsFunction: getPolygonToPointsFunction,
39236
39218
  joinPointsToPolygons: joinPointsToPolygons,
39237
39219
  joinPolygonsToPoints: joinPolygonsToPoints,
39238
- prepJoinLayers: prepJoinLayers,
39239
- getPolygonToPointsFunction: getPolygonToPointsFunction
39220
+ prepJoinLayers: prepJoinLayers
39240
39221
  });
39241
39222
 
39242
39223
  // This is a special-purpose function designed to copy a data field from a points
@@ -39884,9 +39865,9 @@ ${svg}
39884
39865
 
39885
39866
  var Lines = /*#__PURE__*/Object.freeze({
39886
39867
  __proto__: null,
39887
- polygonsToLines: polygonsToLines,
39888
39868
  createLineLayer: createLineLayer,
39889
- extractInnerLines: extractInnerLines
39869
+ extractInnerLines: extractInnerLines,
39870
+ polygonsToLines: polygonsToLines
39890
39871
  });
39891
39872
 
39892
39873
  function getClippingDataset(src, dest, opts) {
@@ -40190,8 +40171,8 @@ ${svg}
40190
40171
  var ProjectionParams = /*#__PURE__*/Object.freeze({
40191
40172
  __proto__: null,
40192
40173
  expandProjDefn: expandProjDefn,
40193
- getConicParams: getConicParams,
40194
- getCenterParams: getCenterParams
40174
+ getCenterParams: getCenterParams,
40175
+ getConicParams: getConicParams
40195
40176
  });
40196
40177
 
40197
40178
  cmd.proj = function(dataset, catalog, opts) {
@@ -40389,12 +40370,12 @@ ${svg}
40389
40370
 
40390
40371
  var Proj = /*#__PURE__*/Object.freeze({
40391
40372
  __proto__: null,
40392
- fetchCrsInfo: fetchCrsInfo,
40393
- projectDataset: projectDataset,
40394
40373
  cleanProjectedPathLayers: cleanProjectedPathLayers,
40395
- projectPointLayer: projectPointLayer,
40374
+ fetchCrsInfo: fetchCrsInfo,
40396
40375
  projectArcs: projectArcs,
40397
- projectArcs2: projectArcs2
40376
+ projectArcs2: projectArcs2,
40377
+ projectDataset: projectDataset,
40378
+ projectPointLayer: projectPointLayer
40398
40379
  });
40399
40380
 
40400
40381
  cmd.graticule = function(dataset, opts) {
@@ -40827,7 +40808,6 @@ ${svg}
40827
40808
  targetDataset.arcs = mergedDataset.arcs;
40828
40809
  prepJoinLayers(targetLyr, sourceLyr);
40829
40810
  var mergedLyr = {
40830
- geometry_type: 'polygon',
40831
40811
  shapes: targetLyr.shapes.concat(sourceLyr.shapes)
40832
40812
  };
40833
40813
  // make a mosaic from merged shapes of both layers
@@ -41097,7 +41077,7 @@ ${svg}
41097
41077
  function polylineToMidpoints(shp, arcs, opts) {
41098
41078
  if (!shp) return null;
41099
41079
  var points = shp.map(function(path) {
41100
- return findPathMidpoint(path, arcs, false);
41080
+ return findPathMidpoint(path, arcs);
41101
41081
  });
41102
41082
  return points;
41103
41083
  }
@@ -41119,9 +41099,6 @@ ${svg}
41119
41099
  var k;
41120
41100
  if (partialLen + segLen >= halfLen) {
41121
41101
  k = (halfLen - partialLen) / segLen;
41122
- if (useNearestVertex) {
41123
- k = k < 0.5 ? 0 : 1;
41124
- }
41125
41102
  // p = [a + k * (c - a), b + k * (d - b)];
41126
41103
  p = [(1 - k) * a + k * c, (1 - k) * b + k * d];
41127
41104
  }
@@ -41430,10 +41407,10 @@ ${svg}
41430
41407
 
41431
41408
  var Points = /*#__PURE__*/Object.freeze({
41432
41409
  __proto__: null,
41433
- pointsFromPolygons: pointsFromPolygons,
41434
41410
  coordinateFromValue: coordinateFromValue,
41435
41411
  findXField: findXField,
41436
- findYField: findYField
41412
+ findYField: findYField,
41413
+ pointsFromPolygons: pointsFromPolygons
41437
41414
  });
41438
41415
 
41439
41416
  function joinPolygonsViaPoints(targetLyr, targetDataset, source, opts) {
@@ -41601,6 +41578,7 @@ ${svg}
41601
41578
  THIS SOFTWARE.
41602
41579
  */
41603
41580
 
41581
+
41604
41582
  var earthRadius = 6371;
41605
41583
  var rad = Math.PI / 180;
41606
41584
 
@@ -41618,7 +41596,6 @@ ${svg}
41618
41596
  left: 0, // left index in the kd-tree array
41619
41597
  right: index.ids.length - 1, // right index
41620
41598
  axis: 0, // 0 for longitude axis and 1 for latitude axis
41621
- dist: 0, // will hold the lower bound of children's distances to the query point
41622
41599
  minLng: -180, // bounding box of the node
41623
41600
  minLat: -90,
41624
41601
  maxLng: 180,
@@ -41637,7 +41614,7 @@ ${svg}
41637
41614
  // add all points of the leaf node to the queue
41638
41615
  for (var i = left; i <= right; i++) {
41639
41616
  item = index.points[index.ids[i]];
41640
- if (!predicate || predicate(item)) {
41617
+ {
41641
41618
  q.push({
41642
41619
  i: index.ids[i],
41643
41620
  item: item,
@@ -41654,7 +41631,7 @@ ${svg}
41654
41631
 
41655
41632
  // add middle point to the queue
41656
41633
  item = index.points[index.ids[m]];
41657
- if (!predicate || predicate(item)) {
41634
+ {
41658
41635
  q.push({
41659
41636
  i: index.ids[m],
41660
41637
  item: item,
@@ -41999,8 +41976,6 @@ ${svg}
41999
41976
  //
42000
41977
  function getHexGridMaker(bbox, interval, opts) {
42001
41978
  var flatTop = opts.type != 'hex2'; // hex2 is "pointy-top" orientation
42002
- // origin cell (bottom left) may be "outie" or "innie" ... could be settable
42003
- var outieOrigin = true;
42004
41979
  var minorInterval = interval * Math.sqrt(3) / 2;
42005
41980
  var _colCounts = _getColCounts(bbox, interval);
42006
41981
  var _rowCounts = _getRowCounts(bbox, interval);
@@ -42158,7 +42133,7 @@ ${svg}
42158
42133
  }
42159
42134
 
42160
42135
  function _isUpperCell(col) {
42161
- return isOdd(col) || !outieOrigin ;
42136
+ return isOdd(col) || false;
42162
42137
  }
42163
42138
 
42164
42139
  function _idxToPoint(id) {
@@ -42770,8 +42745,7 @@ ${svg}
42770
42745
  var empty = [];
42771
42746
  points.forEach(function(p) {
42772
42747
  var bbox = getPointBounds(p, radius);
42773
- var addNeighbors = true; // TODO: only if radius is > 0?
42774
- addPointToGridIndex(p, gridIndex, grid, addNeighbors);
42748
+ addPointToGridIndex(p, gridIndex, grid);
42775
42749
  bboxIndex.add.apply(bboxIndex, bbox);
42776
42750
  });
42777
42751
  bboxIndex.finish();
@@ -42795,7 +42769,7 @@ ${svg}
42795
42769
  var i = grid.pointToIdx(p);
42796
42770
  var [c, r] = grid.idxToColRow(i);
42797
42771
  addCellToGridIndex(c, r, grid, index);
42798
- if (addNeighbors) {
42772
+ {
42799
42773
  grid.forEachNeighbor(c, r, function(c, r) {
42800
42774
  addCellToGridIndex(c, r, grid, index);
42801
42775
  });
@@ -42913,9 +42887,9 @@ ${svg}
42913
42887
 
42914
42888
  var PointToGrid = /*#__PURE__*/Object.freeze({
42915
42889
  __proto__: null,
42916
- getPointCircleRadius: getPointCircleRadius,
42917
42890
  calcCellProperties: calcCellProperties,
42918
- calcWeights: calcWeights
42891
+ calcWeights: calcWeights,
42892
+ getPointCircleRadius: getPointCircleRadius
42919
42893
  });
42920
42894
 
42921
42895
  function closeUndershoots(lyr, dataset, opts) {
@@ -43345,8 +43319,8 @@ ${svg}
43345
43319
  var ParseCommands = /*#__PURE__*/Object.freeze({
43346
43320
  __proto__: null,
43347
43321
  parseCommands: parseCommands,
43348
- standardizeConsoleCommands: standardizeConsoleCommands,
43349
- parseConsoleCommands: parseConsoleCommands
43322
+ parseConsoleCommands: parseConsoleCommands,
43323
+ standardizeConsoleCommands: standardizeConsoleCommands
43350
43324
  });
43351
43325
 
43352
43326
  function getIOProxy(job) {
@@ -43852,7 +43826,7 @@ ${svg}
43852
43826
 
43853
43827
  // create a queue of unwind targets
43854
43828
  queue = getUnwindTargets(intersections, zlim, data.zz);
43855
- utils.sortOn(queue, 'z', !!"ascending");
43829
+ utils.sortOn(queue, 'z', true);
43856
43830
 
43857
43831
  while (queue.length > 0) {
43858
43832
  target = queue.pop();
@@ -44290,9 +44264,8 @@ ${svg}
44290
44264
  }
44291
44265
 
44292
44266
  function protectContentEdges(arcs) {
44293
- var e = 1e-14;
44294
44267
  var bb = arcs.getBounds();
44295
- bb.padBounds(-e, -e, -e, -e);
44268
+ bb.padBounds(-1e-14, -1e-14, -1e-14, -1e-14);
44296
44269
  limitSimplificationExtent(arcs, bb.toArray(), true);
44297
44270
  }
44298
44271
 
@@ -44407,17 +44380,17 @@ ${svg}
44407
44380
 
44408
44381
  var Simplify = /*#__PURE__*/Object.freeze({
44409
44382
  __proto__: null,
44410
- finalizeSimplification: finalizeSimplification,
44411
- getStandardSimplifyOpts: getStandardSimplifyOpts,
44412
- useSphericalSimplify: useSphericalSimplify,
44413
- simplifyPaths: simplifyPaths,
44414
- getSimplifyMethod: getSimplifyMethod,
44415
- protectWorldEdges: protectWorldEdges,
44416
- parseSimplifyResolution: parseSimplifyResolution,
44417
44383
  calcPlanarInterval: calcPlanarInterval,
44418
44384
  calcSphericalInterval: calcSphericalInterval,
44419
44385
  convertSimplifyInterval: convertSimplifyInterval,
44420
- convertSimplifyResolution: convertSimplifyResolution
44386
+ convertSimplifyResolution: convertSimplifyResolution,
44387
+ finalizeSimplification: finalizeSimplification,
44388
+ getSimplifyMethod: getSimplifyMethod,
44389
+ getStandardSimplifyOpts: getStandardSimplifyOpts,
44390
+ parseSimplifyResolution: parseSimplifyResolution,
44391
+ protectWorldEdges: protectWorldEdges,
44392
+ simplifyPaths: simplifyPaths,
44393
+ useSphericalSimplify: useSphericalSimplify
44421
44394
  });
44422
44395
 
44423
44396
  cmd.sortFeatures = function(lyr, arcs, opts) {
@@ -45254,7 +45227,6 @@ ${svg}
45254
45227
  return name + '_' + n;
45255
45228
  });
45256
45229
  var mergedLyr = {
45257
- geometry_type: 'polygon',
45258
45230
  shapes: allShapes
45259
45231
  };
45260
45232
  var mosaicIndex = new MosaicIndex(mergedLyr, nodes, {flat: false});
@@ -46069,7 +46041,7 @@ ${svg}
46069
46041
  });
46070
46042
  }
46071
46043
 
46072
- var version = "0.6.103";
46044
+ var version = "0.6.105";
46073
46045
 
46074
46046
  // Parse command line args into commands and run them
46075
46047
  // Function takes an optional Node-style callback. A Promise is returned if no callback is given.
@@ -46393,12 +46365,12 @@ ${svg}
46393
46365
 
46394
46366
  var RunCommands = /*#__PURE__*/Object.freeze({
46395
46367
  __proto__: null,
46396
- runCommands: runCommands,
46397
46368
  applyCommands: applyCommands,
46369
+ runAndRemoveInfoCommands: runAndRemoveInfoCommands,
46370
+ runCommands: runCommands,
46398
46371
  runCommandsXL: runCommandsXL,
46399
- testCommands: testCommands,
46400
46372
  runParsedCommands: runParsedCommands,
46401
- runAndRemoveInfoCommands: runAndRemoveInfoCommands
46373
+ testCommands: testCommands
46402
46374
  });
46403
46375
 
46404
46376
  // Return an array containing points from a path iterator, clipped to a bounding box