@vitessce/spatial-utils 4.0.9 → 4.1.0

package/dist/{index-BpQ3fbd8.js → index-DgWO5osR.js}

@@ -112,7 +112,7 @@ var reTrimStart = /^\s+/;
 function baseTrim(string) {
   return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, "") : string;
 }
-function isObject$5(value) {
+function isObject$3(value) {
   var type = typeof value;
   return value != null && (type == "object" || type == "function");
 }
@@ -128,9 +128,9 @@ function toNumber(value) {
   if (isSymbol(value)) {
     return NAN;
   }
-  if (isObject$5(value)) {
+  if (isObject$3(value)) {
     var other = typeof value.valueOf == "function" ? value.valueOf() : value;
-    value = isObject$5(other) ? other + "" : other;
+    value = isObject$3(other) ? other + "" : other;
   }
   if (typeof value != "string") {
     return value === 0 ? value : +value;
@@ -153,7 +153,7 @@ function toFinite$1(value) {
 }
 var asyncTag = "[object AsyncFunction]", funcTag$1 = "[object Function]", genTag = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
 function isFunction$2(value) {
-  if (!isObject$5(value)) {
+  if (!isObject$3(value)) {
     return false;
   }
   var tag2 = baseGetTag(value);
@@ -191,7 +191,7 @@ var reIsNative = RegExp(
   "^" + funcToString.call(hasOwnProperty$a).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
 );
 function baseIsNative(value) {
-  if (!isObject$5(value) || isMasked(value)) {
+  if (!isObject$3(value) || isMasked(value)) {
     return false;
   }
   var pattern = isFunction$2(value) ? reIsNative : reIsHostCtor;
@@ -223,7 +223,7 @@ function isArrayLike(value) {
   return value != null && isLength(value.length) && !isFunction$2(value);
 }
 function isIterateeCall(value, index2, object2) {
-  if (!isObject$5(object2)) {
+  if (!isObject$3(object2)) {
     return false;
   }
   var type = typeof index2;
@@ -1620,10 +1620,10 @@ function normalize$4(out, a2) {
   out[2] = a2[2] * len2;
   return out;
 }
-function dot$4(a2, b) {
+function dot$3(a2, b) {
   return a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2];
 }
-function cross$1(out, a2, b) {
+function cross(out, a2, b) {
   var ax = a2[0], ay = a2[1], az = a2[2];
   var bx = b[0], by = b[1], bz = b[2];
   out[0] = ay * bz - az * by;
@@ -1712,8 +1712,8 @@ function rotateZ$2(out, a2, b, rad) {
   out[2] = r2[2] + b[2];
   return out;
 }
-function angle$2(a2, b) {
-  var ax = a2[0], ay = a2[1], az = a2[2], bx = b[0], by = b[1], bz = b[2], mag1 = Math.sqrt(ax * ax + ay * ay + az * az), mag2 = Math.sqrt(bx * bx + by * by + bz * bz), mag = mag1 * mag2, cosine2 = mag && dot$4(a2, b) / mag;
+function angle$1(a2, b) {
+  var ax = a2[0], ay = a2[1], az = a2[2], bx = b[0], by = b[1], bz = b[2], mag1 = Math.sqrt(ax * ax + ay * ay + az * az), mag2 = Math.sqrt(bx * bx + by * by + bz * bz), mag = mag1 * mag2, cosine2 = mag && dot$3(a2, b) / mag;
   return Math.acos(Math.min(Math.max(cosine2, -1), 1));
 }
 var sub$1 = subtract$1;
@@ -1812,10 +1812,10 @@ class Vector3 extends Vector {
     this[2] = checkNumber(value);
   }
   angle(vector) {
-    return angle$2(this, vector);
+    return angle$1(this, vector);
   }
   cross(vector) {
-    cross$1(this, this, vector);
+    cross(this, this, vector);
     return this.check();
   }
   rotateX({
@@ -2932,7 +2932,7 @@ function normalize$3(out, a2) {
   out[3] = w2 * len2;
   return out;
 }
-function dot$3(a2, b) {
+function dot$2(a2, b) {
   return a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2] + a2[3] * b[3];
 }
 function lerp$2(out, a2, b, t) {
@@ -3548,7 +3548,7 @@ function fromMat3(out, m) {
 }
 var add$3 = add$4;
 var scale = scale$1;
-var dot$2 = dot$3;
+var dot$1 = dot$2;
 var lerp$1 = lerp$2;
 var length$2 = length$3;
 var squaredLength = squaredLength$1;
@@ -3558,10 +3558,10 @@ var rotationTo = function() {
   var xUnitVec3 = fromValues(1, 0, 0);
   var yUnitVec3 = fromValues(0, 1, 0);
   return function(out, a2, b) {
-    var dot2 = dot$4(a2, b);
+    var dot2 = dot$3(a2, b);
     if (dot2 < -0.999999) {
-      cross$1(tmpvec3, xUnitVec3, a2);
-      if (len(tmpvec3) < 1e-6) cross$1(tmpvec3, yUnitVec3, a2);
+      cross(tmpvec3, xUnitVec3, a2);
+      if (len(tmpvec3) < 1e-6) cross(tmpvec3, yUnitVec3, a2);
       normalize$4(tmpvec3, tmpvec3);
       setAxisAngle(out, tmpvec3, Math.PI);
       return out;
@@ -3572,7 +3572,7 @@ var rotationTo = function() {
       out[3] = 1;
       return out;
     } else {
-      cross$1(tmpvec3, a2, b);
+      cross(tmpvec3, a2, b);
       out[0] = tmpvec3[0];
       out[1] = tmpvec3[1];
       out[2] = tmpvec3[2];
@@ -3686,7 +3686,7 @@ class Quaternion extends MathArray {
     return squaredLength(this);
   }
   dot(a2) {
-    return dot$2(this, a2);
+    return dot$1(this, a2);
   }
   rotationTo(vectorA, vectorB) {
     rotationTo(this, vectorA, vectorB);
@@ -4610,7 +4610,7 @@ function isDate(x) {
 function isRegExp(x) {
   return x instanceof RegExp;
 }
-function isObject$4(x) {
+function isObject$2(x) {
   return !!(x && typeof x === "object" && x.constructor === Object && !isComplex(x) && !isFraction(x));
 }
 function isNull(x) {
@@ -4717,7 +4717,7 @@ function mapObject(object2, callback) {
   }
   return clone2;
 }
-function extend$1(a2, b) {
+function extend(a2, b) {
   for (var prop in b) {
     if (hasOwnProperty$2(b, prop)) {
       a2[prop] = b[prop];
@@ -6615,7 +6615,7 @@ var createTyped = /* @__PURE__ */ factory("typed", dependencies$Q, function crea
     },
     {
       name: "Object",
-      test: isObject$4
+      test: isObject$2
     }
     // order 'Object' last, it matches on other classes too
   ];
@@ -13690,7 +13690,7 @@ var createMultiply = /* @__PURE__ */ factory(name$v, dependencies$o, (_ref) => {
     cptr[bcolumns] = cindex.length;
     return c;
   }
-  return typed2(name$v, extend$1({
+  return typed2(name$v, extend({
     // we extend the signatures of multiplyScalar with signatures dealing with matrices
     "Array, Array": function ArrayArray(x, y) {
       _validateMatrixDimensions(arraySize(x), arraySize(y));
@@ -19109,7 +19109,7 @@ var createDivide = /* @__PURE__ */ factory(name$7, dependencies, (_ref) => {
   var algorithm14 = createAlgorithm14({
     typed: typed2
   });
-  return typed2("divide", extend$1({
+  return typed2("divide", extend({
     // we extend the signatures of divideScalar with signatures dealing with matrices
     "Array | Matrix, Array | Matrix": function ArrayMatrixArrayMatrix(x, y) {
       return multiply2(x, inv2(y));
@@ -19244,7 +19244,7 @@ var FibonacciHeap = /* @__PURE__ */ createFibonacciHeapClass({
   larger,
   smaller: smaller$1
 });
-var dot$1 = /* @__PURE__ */ createDot({
+var dot = /* @__PURE__ */ createDot({
   addScalar,
   conj,
   multiplyScalar,
@@ -19260,7 +19260,7 @@ var floor = /* @__PURE__ */ createFloor({
 });
 var multiply = /* @__PURE__ */ createMultiply({
   addScalar,
-  dot: dot$1,
+  dot,
   equalScalar,
   matrix,
   multiplyScalar,
@@ -19293,7 +19293,7 @@ var subtract = /* @__PURE__ */ createSubtract({
   typed,
   unaryMinus
 });
-var equal$2 = /* @__PURE__ */ createEqual({
+var equal = /* @__PURE__ */ createEqual({
   DenseMatrix,
   equalScalar,
   matrix,
@@ -19372,7 +19372,7 @@ var Unit = /* @__PURE__ */ createUnitClass({
   addScalar,
   config: config$1,
   divideScalar,
-  equal: equal$2,
+  equal,
   fix,
   format,
   isNumeric: isNumeric$1,
@@ -21049,15 +21049,15 @@ function dirname(url) {
 }
 const isBoolean = (x) => typeof x === "boolean";
 const isFunction = (x) => typeof x === "function";
-const isObject$3 = (x) => x !== null && typeof x === "object";
-const isPureObject = (x) => isObject$3(x) && x.constructor === {}.constructor;
+const isObject$1 = (x) => x !== null && typeof x === "object";
+const isPureObject = (x) => isObject$1(x) && x.constructor === {}.constructor;
 const isIterable = (x) => x && typeof x[Symbol.iterator] === "function";
 const isAsyncIterable$1 = (x) => x && typeof x[Symbol.asyncIterator] === "function";
 const isResponse = (x) => typeof Response !== "undefined" && x instanceof Response || x && x.arrayBuffer && x.text && x.json;
 const isBlob = (x) => typeof Blob !== "undefined" && x instanceof Blob;
 const isBuffer = (x) => x && typeof x === "object" && x.isBuffer;
-const isReadableDOMStream = (x) => typeof ReadableStream !== "undefined" && x instanceof ReadableStream || isObject$3(x) && isFunction(x.tee) && isFunction(x.cancel) && isFunction(x.getReader);
-const isReadableNodeStream = (x) => isObject$3(x) && isFunction(x.read) && isFunction(x.pipe) && isBoolean(x.readable);
+const isReadableDOMStream = (x) => typeof ReadableStream !== "undefined" && x instanceof ReadableStream || isObject$1(x) && isFunction(x.tee) && isFunction(x.cancel) && isFunction(x.getReader);
+const isReadableNodeStream = (x) => isObject$1(x) && isFunction(x.read) && isFunction(x.pipe) && isBoolean(x.readable);
 const isReadableStream = (x) => isReadableDOMStream(x) || isReadableNodeStream(x);
 const DATA_URL_PATTERN = /^data:([-\w.]+\/[-\w.+]+)(;|,)/;
 const MIME_TYPE_PATTERN = /^([-\w.]+\/[-\w.+]+)/;
@@ -21856,7 +21856,7 @@ function getFetchFunction(options, context) {
   if (typeof fetchOptions.fetch === "function") {
     return fetchOptions.fetch;
   }
-  if (isObject$3(fetchOptions.fetch)) {
+  if (isObject$1(fetchOptions.fetch)) {
     return (url) => fetchFile(url, fetchOptions);
   }
   if (context !== null && context !== void 0 && context.fetch) {
@@ -21877,7 +21877,7 @@ function validateOptionsObject(options, id, defaultOptions, deprecatedOptions, l
   const loaderName = id || "Top level";
   const prefix = id ? "".concat(id, ".") : "";
   for (const key in options) {
-    const isSubOptions = !id && isObject$3(options[key]);
+    const isSubOptions = !id && isObject$1(options[key]);
     const isBaseUriOption = key === "baseUri" && !id;
     const isWorkerUrlOption = key === "workerUrl" && id;
     if (!(key in defaultOptions) && !isBaseUriOption && !isWorkerUrlOption) {
@@ -45057,7 +45057,7 @@ function getPropTypes(props) {
 const ERR_NOT_OBJECT = "count(): argument not an object";
 const ERR_NOT_CONTAINER = "count(): argument not a container";
 function count(container) {
-  if (!isObject$2(container)) {
+  if (!isObject(container)) {
     throw new Error(ERR_NOT_OBJECT);
   }
   if (typeof container.count === "function") {
@@ -45077,7 +45077,7 @@ function count(container) {
 function isPlainObject(value) {
   return value !== null && typeof value === "object" && value.constructor === Object;
 }
-function isObject$2(value) {
+function isObject(value) {
   return value !== null && typeof value === "object";
 }
 function mergeShaders(target, source) {
@@ -49410,35 +49410,35 @@ function getPointAtIndex(positions, index2, size2, offset, out = []) {
   }
   return out;
 }
-function intersect(a2, b, edge, bbox2, out = []) {
+function intersect(a2, b, edge, bbox, out = []) {
   let t;
   let snap;
   if (edge & 8) {
-    t = (bbox2[3] - a2[1]) / (b[1] - a2[1]);
+    t = (bbox[3] - a2[1]) / (b[1] - a2[1]);
     snap = 3;
   } else if (edge & 4) {
-    t = (bbox2[1] - a2[1]) / (b[1] - a2[1]);
+    t = (bbox[1] - a2[1]) / (b[1] - a2[1]);
     snap = 1;
   } else if (edge & 2) {
-    t = (bbox2[2] - a2[0]) / (b[0] - a2[0]);
+    t = (bbox[2] - a2[0]) / (b[0] - a2[0]);
     snap = 2;
   } else if (edge & 1) {
-    t = (bbox2[0] - a2[0]) / (b[0] - a2[0]);
+    t = (bbox[0] - a2[0]) / (b[0] - a2[0]);
     snap = 0;
   } else {
     return null;
   }
   for (let i2 = 0; i2 < a2.length; i2++) {
-    out[i2] = (snap & 1) === i2 ? bbox2[snap] : t * (b[i2] - a2[i2]) + a2[i2];
+    out[i2] = (snap & 1) === i2 ? bbox[snap] : t * (b[i2] - a2[i2]) + a2[i2];
   }
   return out;
 }
-function bitCode(p, bbox2) {
+function bitCode(p, bbox) {
   let code = 0;
-  if (p[0] < bbox2[0]) code |= 1;
-  else if (p[0] > bbox2[2]) code |= 2;
-  if (p[1] < bbox2[1]) code |= 4;
-  else if (p[1] > bbox2[3]) code |= 8;
+  if (p[0] < bbox[0]) code |= 1;
+  else if (p[0] > bbox[2]) code |= 2;
+  if (p[1] < bbox[1]) code |= 4;
+  else if (p[1] > bbox[3]) code |= 8;
   return code;
 }
 function cutPolylineByGrid(positions, options) {
@@ -49508,7 +49508,7 @@ function cutPolygonByGrid(positions, holeIndices = null, options) {
     types: edgeTypes ? new Array(positions.length / size2).fill(TYPE_BORDER) : null,
     holes: holeIndices || []
   }];
-  const bbox2 = [[], []];
+  const bbox = [[], []];
   let cell = [];
   while (queue.length) {
     const {
@@ -49516,9 +49516,9 @@ function cutPolygonByGrid(positions, holeIndices = null, options) {
       types,
       holes
     } = queue.shift();
-    getBoundingBox$2(pos, size2, holes[0] || pos.length, bbox2);
-    cell = getGridCell(bbox2[0], gridResolution, gridOffset, cell);
-    const code = bitCode(bbox2[1], cell);
+    getBoundingBox$2(pos, size2, holes[0] || pos.length, bbox);
+    cell = getGridCell(bbox[0], gridResolution, gridOffset, cell);
+    const code = bitCode(bbox[1], cell);
     if (code) {
       let parts = bisectPolygon(pos, types, size2, 0, holes[0] || pos.length, cell, code);
       const polygonLow = {
@@ -49564,7 +49564,7 @@ function cutPolygonByGrid(positions, holeIndices = null, options) {
   }
   return result;
 }
-function bisectPolygon(positions, edgeTypes, size2, startIndex, endIndex, bbox2, edge) {
+function bisectPolygon(positions, edgeTypes, size2, startIndex, endIndex, bbox, edge) {
   const numPoints = (endIndex - startIndex) / size2;
   const resultLow = [];
   const resultHigh = [];
@@ -49575,16 +49575,16 @@ function bisectPolygon(positions, edgeTypes, size2, startIndex, endIndex, bbox2,
   let side;
   let type;
   const prev = getPointAtIndex(positions, numPoints - 1, size2, startIndex);
-  let prevSide = Math.sign(edge & 8 ? prev[1] - bbox2[3] : prev[0] - bbox2[2]);
+  let prevSide = Math.sign(edge & 8 ? prev[1] - bbox[3] : prev[0] - bbox[2]);
   let prevType = edgeTypes && edgeTypes[numPoints - 1];
   let lowPointCount = 0;
   let highPointCount = 0;
   for (let i2 = 0; i2 < numPoints; i2++) {
     p = getPointAtIndex(positions, i2, size2, startIndex, p);
-    side = Math.sign(edge & 8 ? p[1] - bbox2[3] : p[0] - bbox2[2]);
+    side = Math.sign(edge & 8 ? p[1] - bbox[3] : p[0] - bbox[2]);
     type = edgeTypes && edgeTypes[startIndex / size2 + i2];
     if (side && prevSide && prevSide !== side) {
-      intersect(prev, p, edge, bbox2, scratchPoint);
+      intersect(prev, p, edge, bbox, scratchPoint);
       push(resultLow, scratchPoint) && typesLow.push(prevType);
       push(resultHigh, scratchPoint) && typesHigh.push(prevType);
     }
@@ -50716,7 +50716,7 @@ function requireEarcut() {
     var p = start;
     do {
       var a2 = p.prev, b = p.next.next;
-      if (!equals2(a2, b) && intersects2(a2, p, p.next, b) && locallyInside(a2, b) && locallyInside(b, a2)) {
+      if (!equals2(a2, b) && intersects(a2, p, p.next, b) && locallyInside(a2, b) && locallyInside(b, a2)) {
         triangles.push(a2.i / dim | 0);
         triangles.push(p.i / dim | 0);
         triangles.push(b.i / dim | 0);
@@ -50891,7 +50891,7 @@ function requireEarcut() {
   function equals2(p1, p2) {
     return p1.x === p2.x && p1.y === p2.y;
   }
-  function intersects2(p1, q1, p2, q2) {
+  function intersects(p1, q1, p2, q2) {
     var o1 = sign2(area2(p1, q1, p2));
     var o2 = sign2(area2(p1, q1, q2));
     var o3 = sign2(area2(p2, q2, p1));
@@ -50912,7 +50912,7 @@ function requireEarcut() {
   function intersectsPolygon(a2, b) {
     var p = a2;
     do {
-      if (p.i !== a2.i && p.next.i !== a2.i && p.i !== b.i && p.next.i !== b.i && intersects2(p, p.next, a2, b)) return true;
+      if (p.i !== a2.i && p.next.i !== a2.i && p.i !== b.i && p.next.i !== b.i && intersects(p, p.next, a2, b)) return true;
       p = p.next;
     } while (p !== a2);
     return false;
@@ -56948,7 +56948,7 @@ class Tile2DHeader {
     const {
       index: index2,
       id,
-      bbox: bbox2,
+      bbox,
       userData,
       zoom
     } = this;
@@ -56974,7 +56974,7 @@ class Tile2DHeader {
       tileData = await getData({
         index: index2,
         id,
-        bbox: bbox2,
+        bbox,
         userData,
         zoom,
         signal
@@ -57848,8 +57848,8 @@ const urlType = {
     return true;
   }
 };
-function transformBox(bbox2, modelMatrix2) {
-  const transformedCoords = [modelMatrix2.transformAsPoint([bbox2[0], bbox2[1]]), modelMatrix2.transformAsPoint([bbox2[2], bbox2[1]]), modelMatrix2.transformAsPoint([bbox2[0], bbox2[3]]), modelMatrix2.transformAsPoint([bbox2[2], bbox2[3]])];
+function transformBox(bbox, modelMatrix2) {
+  const transformedCoords = [modelMatrix2.transformAsPoint([bbox[0], bbox[1]]), modelMatrix2.transformAsPoint([bbox[2], bbox[1]]), modelMatrix2.transformAsPoint([bbox[0], bbox[3]]), modelMatrix2.transformAsPoint([bbox[2], bbox[3]])];
   const transformedBox = [Math.min(...transformedCoords.map((i2) => i2[0])), Math.min(...transformedCoords.map((i2) => i2[1])), Math.max(...transformedCoords.map((i2) => i2[0])), Math.max(...transformedCoords.map((i2) => i2[1]))];
   return transformedBox;
 }
@@ -57917,12 +57917,12 @@ function getCullBoundsInViewport(viewport, z, cullRect) {
   const bounds1 = getCullBoundsInViewport(viewport, z[1], cullRect);
   return [Math.min(bounds0[0], bounds1[0]), Math.min(bounds0[1], bounds1[1]), Math.max(bounds0[2], bounds1[2]), Math.max(bounds0[3], bounds1[3])];
 }
-function getIndexingCoords(bbox2, scale2, modelMatrixInverse) {
+function getIndexingCoords(bbox, scale2, modelMatrixInverse) {
   if (modelMatrixInverse) {
-    const transformedTileIndex = transformBox(bbox2, modelMatrixInverse).map((i2) => i2 * scale2 / TILE_SIZE$1);
+    const transformedTileIndex = transformBox(bbox, modelMatrixInverse).map((i2) => i2 * scale2 / TILE_SIZE$1);
     return transformedTileIndex;
   }
-  return bbox2.map((i2) => i2 * scale2 / TILE_SIZE$1);
+  return bbox.map((i2) => i2 * scale2 / TILE_SIZE$1);
 }
 function getScale(z, tileSize) {
   return Math.pow(2, z) * TILE_SIZE$1 / tileSize;
@@ -57959,9 +57959,9 @@ function tileToBoundingBox(viewport, x, y, z, tileSize = TILE_SIZE$1) {
   };
 }
 function getIdentityTileIndices(viewport, z, tileSize, extent2, modelMatrixInverse) {
-  const bbox2 = getBoundingBox(viewport, null, extent2);
+  const bbox = getBoundingBox(viewport, null, extent2);
   const scale2 = getScale(z, tileSize);
-  const [minX, minY, maxX, maxY] = getIndexingCoords(bbox2, scale2, modelMatrixInverse);
+  const [minX, minY, maxX, maxY] = getIndexingCoords(bbox, scale2, modelMatrixInverse);
   const indices = [];
   for (let x = Math.floor(minX); x < maxX; x++) {
     for (let y = Math.floor(minY); y < maxY; y++) {
@@ -58150,16 +58150,16 @@ class Tileset2D {
         cullRect
       });
       const {
-        bbox: bbox2
+        bbox
       } = tile;
       for (const [minX, minY, maxX, maxY] of boundsArr) {
         let overlaps;
-        if ("west" in bbox2) {
-          overlaps = bbox2.west < maxX && bbox2.east > minX && bbox2.south < maxY && bbox2.north > minY;
+        if ("west" in bbox) {
+          overlaps = bbox.west < maxX && bbox.east > minX && bbox.south < maxY && bbox.north > minY;
         } else {
-          const y02 = Math.min(bbox2.top, bbox2.bottom);
-          const y12 = Math.max(bbox2.top, bbox2.bottom);
-          overlaps = bbox2.left < maxX && bbox2.right > minX && y02 < maxY && y12 > minY;
+          const y02 = Math.min(bbox.top, bbox.bottom);
+          const y12 = Math.max(bbox.top, bbox.bottom);
+          overlaps = bbox.left < maxX && bbox.right > minX && y02 < maxY && y12 > minY;
         }
         if (overlaps) {
           return true;
@@ -75449,7 +75449,7 @@ class Ellipsoid {
     h.copy(scratchCartesian).subtract(point2);
     const longitude = Math.atan2(normal.y, normal.x);
     const latitude = Math.asin(normal.z);
-    const height = Math.sign(dot$4(h, scratchCartesian)) * length$4(h);
+    const height = Math.sign(dot$3(h, scratchCartesian)) * length$4(h);
     return toCartographicFromRadians([longitude, latitude, height], result);
   }
   eastNorthUpToFixedFrame(origin, result = new Matrix4()) {
@@ -79853,13 +79853,13 @@ class TerrainLayer extends CompositeLayer {
     let bottomLeft = [0, 0];
     let topRight = [0, 0];
     if (viewport.isGeospatial) {
-      const bbox2 = tile.bbox;
-      bottomLeft = viewport.projectFlat([bbox2.west, bbox2.south]);
-      topRight = viewport.projectFlat([bbox2.east, bbox2.north]);
+      const bbox = tile.bbox;
+      bottomLeft = viewport.projectFlat([bbox.west, bbox.south]);
+      topRight = viewport.projectFlat([bbox.east, bbox.north]);
     } else {
-      const bbox2 = tile.bbox;
-      bottomLeft = [bbox2.left, bbox2.bottom];
-      topRight = [bbox2.right, bbox2.top];
+      const bbox = tile.bbox;
+      bottomLeft = [bbox.left, bbox.bottom];
+      topRight = [bbox.right, bbox.top];
     }
     const bounds2 = [bottomLeft[0], bottomLeft[1], topRight[0], topRight[1]];
     const terrain = this.loadTerrain({
@@ -80230,27 +80230,27 @@ function Point([pointX, pointY], [nw, se], viewport) {
   const y = lerp$5(nw[1], se[1], pointY);
   return viewport.unprojectFlat([x, y]);
 }
-function getPoints(geometry2, bbox2, viewport) {
-  return geometry2.map((g2) => Point(g2, bbox2, viewport));
+function getPoints(geometry2, bbox, viewport) {
+  return geometry2.map((g2) => Point(g2, bbox, viewport));
 }
-function MultiPoint(multiPoint, bbox2, viewport) {
-  return getPoints(multiPoint, bbox2, viewport);
+function MultiPoint(multiPoint, bbox, viewport) {
+  return getPoints(multiPoint, bbox, viewport);
 }
-function LineString(line, bbox2, viewport) {
-  return getPoints(line, bbox2, viewport);
+function LineString(line, bbox, viewport) {
+  return getPoints(line, bbox, viewport);
 }
-function MultiLineString(multiLineString, bbox2, viewport) {
-  return multiLineString.map((lineString2) => LineString(lineString2, bbox2, viewport));
+function MultiLineString(multiLineString, bbox, viewport) {
+  return multiLineString.map((lineString) => LineString(lineString, bbox, viewport));
 }
-function Polygon(polygon2, bbox2, viewport) {
-  return polygon2.map((polygonRing) => getPoints(polygonRing, bbox2, viewport));
+function Polygon(polygon2, bbox, viewport) {
+  return polygon2.map((polygonRing) => getPoints(polygonRing, bbox, viewport));
 }
-function MultiPolygon(multiPolygon2, bbox2, viewport) {
-  return multiPolygon2.map((polygon2) => Polygon(polygon2, bbox2, viewport));
+function MultiPolygon(multiPolygon2, bbox, viewport) {
+  return multiPolygon2.map((polygon2) => Polygon(polygon2, bbox, viewport));
 }
-function transform$1(geometry2, bbox2, viewport) {
-  const nw = viewport.projectFlat([bbox2.west, bbox2.north]);
-  const se = viewport.projectFlat([bbox2.east, bbox2.south]);
+function transform$1(geometry2, bbox, viewport) {
+  const nw = viewport.projectFlat([bbox.west, bbox.north]);
+  const se = viewport.projectFlat([bbox.east, bbox.south]);
   const projectedBbox = [nw, se];
   return {
     ...geometry2,
@@ -80640,11 +80640,11 @@ class MVTLayer extends TileLayer {
               return [];
             }
             const {
-              bbox: bbox2
+              bbox
             } = tile;
-            if (tile._contentWGS84 === void 0 && isGeoBoundingBox(bbox2)) {
+            if (tile._contentWGS84 === void 0 && isGeoBoundingBox(bbox)) {
               const content = this.state.binary ? binaryToGeojson(tile.content) : tile.content;
-              tile._contentWGS84 = content.map((feature2) => transformTileCoordsToWGS84(feature2, bbox2, this.context.viewport));
+              tile._contentWGS84 = content.map((feature2) => transformTileCoordsToWGS84(feature2, bbox, this.context.viewport));
             }
             return tile._contentWGS84;
           }
@@ -80671,7 +80671,7 @@ function getFeatureLayerName(feature2) {
 function isFeatureIdDefined(value) {
   return value !== void 0 && value !== null && value !== "";
 }
-function transformTileCoordsToWGS84(object2, bbox2, viewport) {
+function transformTileCoordsToWGS84(object2, bbox, viewport) {
   const feature2 = {
     ...object2,
     geometry: {
@@ -80680,7 +80680,7 @@ function transformTileCoordsToWGS84(object2, bbox2, viewport) {
   };
   Object.defineProperty(feature2.geometry, "coordinates", {
     get: () => {
-      const wgs84Geom = transform$1(object2.geometry, bbox2, viewport);
+      const wgs84Geom = transform$1(object2.geometry, bbox, viewport);
       return wgs84Geom.coordinates;
     }
   });
@@ -80851,16 +80851,6 @@ function polygons(coordinates2, properties, options = {}) {
     options
   );
 }
-function lineString(coordinates2, properties, options = {}) {
-  if (coordinates2.length < 2) {
-    throw new Error("coordinates must be an array of two or more positions");
-  }
-  const geom = {
-    type: "LineString",
-    coordinates: coordinates2
-  };
-  return feature$1(geom, properties, options);
-}
 function featureCollection(features, options = {}) {
   const fc = { type: "FeatureCollection" };
   if (options.id) {
@@ -80886,10 +80876,6 @@ function radiansToLength(radians2, units = "kilometers") {
   }
   return radians2 * factor;
 }
-function radiansToDegrees(radians2) {
-  const normalisedRadians = radians2 % (2 * Math.PI);
-  return normalisedRadians * 180 / Math.PI;
-}
 function degreesToRadians(degrees2) {
   const normalisedDegrees = degrees2 % 360;
   return normalisedDegrees * Math.PI / 180;
@@ -80897,428 +80883,6 @@ function degreesToRadians(degrees2) {
 function isNumber(num) {
   return !isNaN(num) && num !== null && !Array.isArray(num);
 }
-function isObject$1(input) {
-  return input !== null && typeof input === "object" && !Array.isArray(input);
-}
-function coordEach(geojson, callback, excludeWrapCoord) {
-  if (geojson === null) return;
-  var j, k, l2, geometry2, stopG, coords, geometryMaybeCollection, wrapShrink = 0, coordIndex = 0, isGeometryCollection, type = geojson.type, isFeatureCollection = type === "FeatureCollection", isFeature = type === "Feature", stop = isFeatureCollection ? geojson.features.length : 1;
-  for (var featureIndex = 0; featureIndex < stop; featureIndex++) {
-    geometryMaybeCollection = isFeatureCollection ? geojson.features[featureIndex].geometry : isFeature ? geojson.geometry : geojson;
-    isGeometryCollection = geometryMaybeCollection ? geometryMaybeCollection.type === "GeometryCollection" : false;
-    stopG = isGeometryCollection ? geometryMaybeCollection.geometries.length : 1;
-    for (var geomIndex = 0; geomIndex < stopG; geomIndex++) {
-      var multiFeatureIndex = 0;
-      var geometryIndex = 0;
-      geometry2 = isGeometryCollection ? geometryMaybeCollection.geometries[geomIndex] : geometryMaybeCollection;
-      if (geometry2 === null) continue;
-      coords = geometry2.coordinates;
-      var geomType = geometry2.type;
-      wrapShrink = 0;
-      switch (geomType) {
-        case null:
-          break;
-        case "Point":
-          if (callback(
-            coords,
-            coordIndex,
-            featureIndex,
-            multiFeatureIndex,
-            geometryIndex
-          ) === false)
-            return false;
-          coordIndex++;
-          multiFeatureIndex++;
-          break;
-        case "LineString":
-        case "MultiPoint":
-          for (j = 0; j < coords.length; j++) {
-            if (callback(
-              coords[j],
-              coordIndex,
-              featureIndex,
-              multiFeatureIndex,
-              geometryIndex
-            ) === false)
-              return false;
-            coordIndex++;
-            if (geomType === "MultiPoint") multiFeatureIndex++;
-          }
-          if (geomType === "LineString") multiFeatureIndex++;
-          break;
-        case "Polygon":
-        case "MultiLineString":
-          for (j = 0; j < coords.length; j++) {
-            for (k = 0; k < coords[j].length - wrapShrink; k++) {
-              if (callback(
-                coords[j][k],
-                coordIndex,
-                featureIndex,
-                multiFeatureIndex,
-                geometryIndex
-              ) === false)
-                return false;
-              coordIndex++;
-            }
-            if (geomType === "MultiLineString") multiFeatureIndex++;
-            if (geomType === "Polygon") geometryIndex++;
-          }
-          if (geomType === "Polygon") multiFeatureIndex++;
-          break;
-        case "MultiPolygon":
-          for (j = 0; j < coords.length; j++) {
-            geometryIndex = 0;
-            for (k = 0; k < coords[j].length; k++) {
-              for (l2 = 0; l2 < coords[j][k].length - wrapShrink; l2++) {
-                if (callback(
-                  coords[j][k][l2],
-                  coordIndex,
-                  featureIndex,
-                  multiFeatureIndex,
-                  geometryIndex
-                ) === false)
-                  return false;
-                coordIndex++;
-              }
-              geometryIndex++;
-            }
-            multiFeatureIndex++;
-          }
-          break;
-        case "GeometryCollection":
-          for (j = 0; j < geometry2.geometries.length; j++)
-            if (coordEach(geometry2.geometries[j], callback) === false)
-              return false;
-          break;
-        default:
-          throw new Error("Unknown Geometry Type");
-      }
-    }
-  }
-}
-function featureEach(geojson, callback) {
-  if (geojson.type === "Feature") {
-    callback(geojson, 0);
-  } else if (geojson.type === "FeatureCollection") {
-    for (var i2 = 0; i2 < geojson.features.length; i2++) {
-      if (callback(geojson.features[i2], i2) === false) break;
-    }
-  }
-}
-function geomEach(geojson, callback) {
-  var i2, j, g2, geometry2, stopG, geometryMaybeCollection, isGeometryCollection, featureProperties, featureBBox, featureId2, featureIndex = 0, isFeatureCollection = geojson.type === "FeatureCollection", isFeature = geojson.type === "Feature", stop = isFeatureCollection ? geojson.features.length : 1;
-  for (i2 = 0; i2 < stop; i2++) {
-    geometryMaybeCollection = isFeatureCollection ? geojson.features[i2].geometry : isFeature ? geojson.geometry : geojson;
-    featureProperties = isFeatureCollection ? geojson.features[i2].properties : isFeature ? geojson.properties : {};
-    featureBBox = isFeatureCollection ? geojson.features[i2].bbox : isFeature ? geojson.bbox : void 0;
-    featureId2 = isFeatureCollection ? geojson.features[i2].id : isFeature ? geojson.id : void 0;
-    isGeometryCollection = geometryMaybeCollection ? geometryMaybeCollection.type === "GeometryCollection" : false;
-    stopG = isGeometryCollection ? geometryMaybeCollection.geometries.length : 1;
-    for (g2 = 0; g2 < stopG; g2++) {
-      geometry2 = isGeometryCollection ? geometryMaybeCollection.geometries[g2] : geometryMaybeCollection;
-      if (geometry2 === null) {
-        if (callback(
-          null,
-          featureIndex,
-          featureProperties,
-          featureBBox,
-          featureId2
-        ) === false)
-          return false;
-        continue;
-      }
-      switch (geometry2.type) {
-        case "Point":
-        case "LineString":
-        case "MultiPoint":
-        case "Polygon":
-        case "MultiLineString":
-        case "MultiPolygon": {
-          if (callback(
-            geometry2,
-            featureIndex,
-            featureProperties,
-            featureBBox,
-            featureId2
-          ) === false)
-            return false;
-          break;
-        }
-        case "GeometryCollection": {
-          for (j = 0; j < geometry2.geometries.length; j++) {
-            if (callback(
-              geometry2.geometries[j],
-              featureIndex,
-              featureProperties,
-              featureBBox,
-              featureId2
-            ) === false)
-              return false;
-          }
-          break;
-        }
-        default:
-          throw new Error("Unknown Geometry Type");
-      }
-    }
-    featureIndex++;
-  }
-}
-function geomReduce(geojson, callback, initialValue) {
-  var previousValue = initialValue;
-  geomEach(
-    geojson,
-    function(currentGeometry, featureIndex, featureProperties, featureBBox, featureId2) {
-      previousValue = callback(
-        previousValue,
-        currentGeometry,
-        featureIndex,
-        featureProperties,
-        featureBBox,
-        featureId2
-      );
-    }
-  );
-  return previousValue;
-}
-function flattenEach(geojson, callback) {
-  geomEach(geojson, function(geometry2, featureIndex, properties, bbox2, id) {
-    var type = geometry2 === null ? null : geometry2.type;
-    switch (type) {
-      case null:
-      case "Point":
-      case "LineString":
-      case "Polygon":
-        if (callback(
-          feature$1(geometry2, properties, { bbox: bbox2, id }),
-          featureIndex,
-          0
-        ) === false)
-          return false;
-        return;
-    }
-    var geomType;
-    switch (type) {
-      case "MultiPoint":
-        geomType = "Point";
-        break;
-      case "MultiLineString":
-        geomType = "LineString";
-        break;
-      case "MultiPolygon":
-        geomType = "Polygon";
-        break;
-    }
-    for (var multiFeatureIndex = 0; multiFeatureIndex < geometry2.coordinates.length; multiFeatureIndex++) {
-      var coordinate = geometry2.coordinates[multiFeatureIndex];
-      var geom = {
-        type: geomType,
-        coordinates: coordinate
-      };
-      if (callback(feature$1(geom, properties), featureIndex, multiFeatureIndex) === false)
-        return false;
-    }
-  });
-}
-function flattenReduce(geojson, callback, initialValue) {
-  var previousValue = initialValue;
-  flattenEach(
-    geojson,
-    function(currentFeature, featureIndex, multiFeatureIndex) {
-      if (featureIndex === 0 && multiFeatureIndex === 0 && initialValue === void 0)
-        previousValue = currentFeature;
-      else
-        previousValue = callback(
-          previousValue,
-          currentFeature,
-          featureIndex,
-          multiFeatureIndex
-        );
-    }
-  );
-  return previousValue;
-}
-function segmentEach(geojson, callback) {
-  flattenEach(geojson, function(feature2, featureIndex, multiFeatureIndex) {
-    var segmentIndex = 0;
-    if (!feature2.geometry) return;
-    var type = feature2.geometry.type;
-    if (type === "Point" || type === "MultiPoint") return;
-    var previousCoords;
-    var previousFeatureIndex = 0;
-    var previousMultiIndex = 0;
-    var prevGeomIndex = 0;
-    if (coordEach(
-      feature2,
-      function(currentCoord, coordIndex, featureIndexCoord, multiPartIndexCoord, geometryIndex) {
-        if (previousCoords === void 0 || featureIndex > previousFeatureIndex || multiPartIndexCoord > previousMultiIndex || geometryIndex > prevGeomIndex) {
-          previousCoords = currentCoord;
-          previousFeatureIndex = featureIndex;
-          previousMultiIndex = multiPartIndexCoord;
-          prevGeomIndex = geometryIndex;
-          segmentIndex = 0;
-          return;
-        }
-        var currentSegment = lineString(
-          [previousCoords, currentCoord],
-          feature2.properties
-        );
-        if (callback(
-          currentSegment,
-          featureIndex,
-          multiFeatureIndex,
-          geometryIndex,
-          segmentIndex
-        ) === false)
-          return false;
-        segmentIndex++;
-        previousCoords = currentCoord;
-      }
-    ) === false)
-      return false;
-  });
-}
-function bbox$1(geojson, options = {}) {
-  if (geojson.bbox != null && true !== options.recompute) {
-    return geojson.bbox;
-  }
-  const result = [Infinity, Infinity, -Infinity, -Infinity];
-  coordEach(geojson, (coord) => {
-    if (result[0] > coord[0]) {
-      result[0] = coord[0];
-    }
-    if (result[1] > coord[1]) {
-      result[1] = coord[1];
-    }
-    if (result[2] < coord[0]) {
-      result[2] = coord[0];
-    }
-    if (result[3] < coord[1]) {
-      result[3] = coord[1];
-    }
-  });
-  return result;
-}
-function getCoord(coord) {
-  if (!coord) {
-    throw new Error("coord is required");
-  }
-  if (!Array.isArray(coord)) {
-    if (coord.type === "Feature" && coord.geometry !== null && coord.geometry.type === "Point") {
-      return [...coord.geometry.coordinates];
-    }
-    if (coord.type === "Point") {
-      return [...coord.coordinates];
-    }
-  }
-  if (Array.isArray(coord) && coord.length >= 2 && !Array.isArray(coord[0]) && !Array.isArray(coord[1])) {
-    return [...coord];
-  }
-  throw new Error("coord must be GeoJSON Point or an Array of numbers");
-}
-function getCoords(coords) {
-  if (Array.isArray(coords)) {
-    return coords;
-  }
-  if (coords.type === "Feature") {
-    if (coords.geometry !== null) {
-      return coords.geometry.coordinates;
-    }
-  } else {
-    if (coords.coordinates) {
-      return coords.coordinates;
-    }
-  }
-  throw new Error(
-    "coords must be GeoJSON Feature, Geometry Object or an Array"
-  );
-}
-function getGeom(geojson) {
-  if (geojson.type === "Feature") {
-    return geojson.geometry;
-  }
-  return geojson;
-}
-function booleanPointOnLine(pt, line, options = {}) {
-  const ptCoords = getCoord(pt);
-  const lineCoords = getCoords(line);
-  for (let i2 = 0; i2 < lineCoords.length - 1; i2++) {
-    let ignoreBoundary = false;
-    if (options.ignoreEndVertices) {
-      if (i2 === 0) {
-        ignoreBoundary = "start";
-      }
-      if (i2 === lineCoords.length - 2) {
-        ignoreBoundary = "end";
-      }
-      if (i2 === 0 && i2 + 1 === lineCoords.length - 1) {
-        ignoreBoundary = "both";
-      }
-    }
-    if (isPointOnLineSegment(
-      lineCoords[i2],
-      lineCoords[i2 + 1],
-      ptCoords,
-      ignoreBoundary,
-      typeof options.epsilon === "undefined" ? null : options.epsilon
-    )) {
-      return true;
-    }
-  }
-  return false;
-}
-function isPointOnLineSegment(lineSegmentStart, lineSegmentEnd, pt, excludeBoundary, epsilon3) {
-  const x = pt[0];
-  const y = pt[1];
-  const x12 = lineSegmentStart[0];
-  const y12 = lineSegmentStart[1];
-  const x2 = lineSegmentEnd[0];
-  const y2 = lineSegmentEnd[1];
-  const dxc = pt[0] - x12;
-  const dyc = pt[1] - y12;
-  const dxl = x2 - x12;
-  const dyl = y2 - y12;
-  const cross2 = dxc * dyl - dyc * dxl;
-  if (epsilon3 !== null) {
-    if (Math.abs(cross2) > epsilon3) {
-      return false;
-    }
-  } else if (cross2 !== 0) {
-    return false;
-  }
-  if (Math.abs(dxl) === Math.abs(dyl) && Math.abs(dxl) === 0) {
-    if (excludeBoundary) {
-      return false;
-    }
-    if (pt[0] === lineSegmentStart[0] && pt[1] === lineSegmentStart[1]) {
-      return true;
-    } else {
-      return false;
-    }
-  }
-  if (!excludeBoundary) {
-    if (Math.abs(dxl) >= Math.abs(dyl)) {
-      return dxl > 0 ? x12 <= x && x <= x2 : x2 <= x && x <= x12;
-    }
-    return dyl > 0 ? y12 <= y && y <= y2 : y2 <= y && y <= y12;
-  } else if (excludeBoundary === "start") {
-    if (Math.abs(dxl) >= Math.abs(dyl)) {
-      return dxl > 0 ? x12 < x && x <= x2 : x2 <= x && x < x12;
-    }
-    return dyl > 0 ? y12 < y && y <= y2 : y2 <= y && y < y12;
-  } else if (excludeBoundary === "end") {
-    if (Math.abs(dxl) >= Math.abs(dyl)) {
-      return dxl > 0 ? x12 <= x && x < x2 : x2 < x && x <= x12;
-    }
-    return dyl > 0 ? y12 <= y && y < y2 : y2 < y && y <= y12;
-  } else if (excludeBoundary === "both") {
-    if (Math.abs(dxl) >= Math.abs(dyl)) {
-      return dxl > 0 ? x12 < x && x < x2 : x2 < x && x < x12;
-    }
-    return dyl > 0 ? y12 < y && y < y2 : y2 < y && y < y12;
-  }
-  return false;
-}
 const epsilon$1 = 11102230246251565e-32;
 const splitter = 134217729;
 const resulterrbound = (3 + 8 * epsilon$1) * epsilon$1;
@@ -81615,6 +81179,29 @@ function pointInPolygon(p, polygon2) {
   }
   return true;
 }
+function getCoord(coord) {
+  if (!coord) {
+    throw new Error("coord is required");
+  }
+  if (!Array.isArray(coord)) {
+    if (coord.type === "Feature" && coord.geometry !== null && coord.geometry.type === "Point") {
+      return [...coord.geometry.coordinates];
+    }
+    if (coord.type === "Point") {
+      return [...coord.coordinates];
+    }
+  }
+  if (Array.isArray(coord) && coord.length >= 2 && !Array.isArray(coord[0]) && !Array.isArray(coord[1])) {
+    return [...coord];
+  }
+  throw new Error("coord must be GeoJSON Point or an Array of numbers");
+}
+function getGeom(geojson) {
+  if (geojson.type === "Feature") {
+    return geojson.geometry;
+  }
+  return geojson;
+}
 function booleanPointInPolygon(point2, polygon2, options = {}) {
   if (!point2) {
     throw new Error("point is required");
@@ -81625,9 +81212,9 @@ function booleanPointInPolygon(point2, polygon2, options = {}) {
   const pt = getCoord(point2);
   const geom = getGeom(polygon2);
   const type = geom.type;
-  const bbox2 = polygon2.bbox;
+  const bbox = polygon2.bbox;
   let polys = geom.coordinates;
-  if (bbox2 && inBBox(pt, bbox2) === false) {
+  if (bbox && inBBox(pt, bbox) === false) {
     return false;
   }
   if (type === "Polygon") {
@@ -81641,1607 +81228,8 @@ function booleanPointInPolygon(point2, polygon2, options = {}) {
   }
   return result;
 }
-function inBBox(pt, bbox2) {
-  return bbox2[0] <= pt[0] && bbox2[1] <= pt[1] && bbox2[2] >= pt[0] && bbox2[3] >= pt[1];
-}
-function booleanWithin(feature1, feature2) {
-  var geom1 = getGeom(feature1);
-  var geom2 = getGeom(feature2);
-  var type1 = geom1.type;
-  var type2 = geom2.type;
-  switch (type1) {
-    case "Point":
-      switch (type2) {
-        case "MultiPoint":
-          return isPointInMultiPoint$1(geom1, geom2);
-        case "LineString":
-          return booleanPointOnLine(geom1, geom2, { ignoreEndVertices: true });
-        case "Polygon":
-        case "MultiPolygon":
-          return booleanPointInPolygon(geom1, geom2, { ignoreBoundary: true });
-        default:
-          throw new Error("feature2 " + type2 + " geometry not supported");
-      }
-    case "MultiPoint":
-      switch (type2) {
-        case "MultiPoint":
-          return isMultiPointInMultiPoint$1(geom1, geom2);
-        case "LineString":
-          return isMultiPointOnLine$1(geom1, geom2);
-        case "Polygon":
-        case "MultiPolygon":
-          return isMultiPointInPoly$1(geom1, geom2);
-        default:
-          throw new Error("feature2 " + type2 + " geometry not supported");
-      }
-    case "LineString":
-      switch (type2) {
-        case "LineString":
-          return isLineOnLine$1(geom1, geom2);
-        case "Polygon":
-        case "MultiPolygon":
-          return isLineInPoly$1(geom1, geom2);
-        default:
-          throw new Error("feature2 " + type2 + " geometry not supported");
-      }
-    case "Polygon":
-      switch (type2) {
-        case "Polygon":
-        case "MultiPolygon":
-          return isPolyInPoly$1(geom1, geom2);
-        default:
-          throw new Error("feature2 " + type2 + " geometry not supported");
-      }
-    default:
-      throw new Error("feature1 " + type1 + " geometry not supported");
-  }
-}
-function isPointInMultiPoint$1(point2, multiPoint) {
-  var i2;
-  var output = false;
-  for (i2 = 0; i2 < multiPoint.coordinates.length; i2++) {
-    if (compareCoords$1(multiPoint.coordinates[i2], point2.coordinates)) {
-      output = true;
-      break;
-    }
-  }
-  return output;
-}
-function isMultiPointInMultiPoint$1(multiPoint1, multiPoint2) {
-  for (var i2 = 0; i2 < multiPoint1.coordinates.length; i2++) {
-    var anyMatch = false;
-    for (var i22 = 0; i22 < multiPoint2.coordinates.length; i22++) {
-      if (compareCoords$1(multiPoint1.coordinates[i2], multiPoint2.coordinates[i22])) {
-        anyMatch = true;
-      }
-    }
-    if (!anyMatch) {
-      return false;
-    }
-  }
-  return true;
-}
-function isMultiPointOnLine$1(multiPoint, lineString2) {
-  var foundInsidePoint = false;
-  for (var i2 = 0; i2 < multiPoint.coordinates.length; i2++) {
-    if (!booleanPointOnLine(multiPoint.coordinates[i2], lineString2)) {
-      return false;
-    }
-    if (!foundInsidePoint) {
-      foundInsidePoint = booleanPointOnLine(
-        multiPoint.coordinates[i2],
-        lineString2,
-        { ignoreEndVertices: true }
-      );
-    }
-  }
-  return foundInsidePoint;
-}
-function isMultiPointInPoly$1(multiPoint, polygon2) {
-  var output = true;
-  var isInside = false;
-  for (var i2 = 0; i2 < multiPoint.coordinates.length; i2++) {
-    isInside = booleanPointInPolygon(multiPoint.coordinates[i2], polygon2);
-    if (!isInside) {
-      output = false;
-      break;
-    }
-    {
-      isInside = booleanPointInPolygon(multiPoint.coordinates[i2], polygon2, {
-        ignoreBoundary: true
-      });
-    }
-  }
-  return output && isInside;
-}
-function isLineOnLine$1(lineString1, lineString2) {
-  for (var i2 = 0; i2 < lineString1.coordinates.length; i2++) {
-    if (!booleanPointOnLine(lineString1.coordinates[i2], lineString2)) {
-      return false;
-    }
-  }
-  return true;
-}
-function isLineInPoly$1(linestring, polygon2) {
-  var polyBbox = bbox$1(polygon2);
-  var lineBbox = bbox$1(linestring);
-  if (!doBBoxOverlap$1(polyBbox, lineBbox)) {
-    return false;
-  }
-  var foundInsidePoint = false;
-  for (var i2 = 0; i2 < linestring.coordinates.length; i2++) {
-    if (!booleanPointInPolygon(linestring.coordinates[i2], polygon2)) {
-      return false;
-    }
-    if (!foundInsidePoint) {
-      foundInsidePoint = booleanPointInPolygon(
-        linestring.coordinates[i2],
-        polygon2,
-        { ignoreBoundary: true }
-      );
-    }
-    if (!foundInsidePoint && i2 < linestring.coordinates.length - 1) {
-      var midpoint = getMidpoint$1(
-        linestring.coordinates[i2],
-        linestring.coordinates[i2 + 1]
-      );
-      foundInsidePoint = booleanPointInPolygon(midpoint, polygon2, {
-        ignoreBoundary: true
-      });
-    }
-  }
-  return foundInsidePoint;
-}
-function isPolyInPoly$1(geometry1, geometry2) {
-  var poly1Bbox = bbox$1(geometry1);
-  var poly2Bbox = bbox$1(geometry2);
-  if (!doBBoxOverlap$1(poly2Bbox, poly1Bbox)) {
-    return false;
-  }
-  for (var i2 = 0; i2 < geometry1.coordinates[0].length; i2++) {
-    if (!booleanPointInPolygon(geometry1.coordinates[0][i2], geometry2)) {
-      return false;
-    }
-  }
-  return true;
-}
-function doBBoxOverlap$1(bbox1, bbox2) {
-  if (bbox1[0] > bbox2[0]) return false;
-  if (bbox1[2] < bbox2[2]) return false;
-  if (bbox1[1] > bbox2[1]) return false;
-  if (bbox1[3] < bbox2[3]) return false;
-  return true;
-}
-function compareCoords$1(pair1, pair2) {
-  return pair1[0] === pair2[0] && pair1[1] === pair2[1];
-}
-function getMidpoint$1(pair1, pair2) {
-  return [(pair1[0] + pair2[0]) / 2, (pair1[1] + pair2[1]) / 2];
-}
-function booleanContains(feature1, feature2) {
-  const geom1 = getGeom(feature1);
-  const geom2 = getGeom(feature2);
-  const type1 = geom1.type;
-  const type2 = geom2.type;
-  const coords1 = geom1.coordinates;
-  const coords2 = geom2.coordinates;
-  switch (type1) {
-    case "Point":
-      switch (type2) {
-        case "Point":
-          return compareCoords(coords1, coords2);
-        default:
-          throw new Error("feature2 " + type2 + " geometry not supported");
-      }
-    case "MultiPoint":
-      switch (type2) {
-        case "Point":
-          return isPointInMultiPoint(geom1, geom2);
-        case "MultiPoint":
-          return isMultiPointInMultiPoint(geom1, geom2);
-        default:
-          throw new Error("feature2 " + type2 + " geometry not supported");
-      }
-    case "LineString":
-      switch (type2) {
-        case "Point":
-          return booleanPointOnLine(geom2, geom1, { ignoreEndVertices: true });
-        case "LineString":
-          return isLineOnLine(geom1, geom2);
-        case "MultiPoint":
-          return isMultiPointOnLine(geom1, geom2);
-        default:
-          throw new Error("feature2 " + type2 + " geometry not supported");
-      }
-    case "Polygon":
-      switch (type2) {
-        case "Point":
-          return booleanPointInPolygon(geom2, geom1, { ignoreBoundary: true });
-        case "LineString":
-          return isLineInPoly(geom1, geom2);
-        case "Polygon":
-          return isPolyInPoly(geom1, geom2);
-        case "MultiPoint":
-          return isMultiPointInPoly(geom1, geom2);
-        default:
-          throw new Error("feature2 " + type2 + " geometry not supported");
-      }
-    case "MultiPolygon":
-      switch (type2) {
-        case "Polygon":
-          return isPolygonInMultiPolygon(geom1, geom2);
-        default:
-          throw new Error("feature2 " + type2 + " geometry not supported");
-      }
-    default:
-      throw new Error("feature1 " + type1 + " geometry not supported");
-  }
-}
-function isPolygonInMultiPolygon(multiPolygon2, polygon2) {
-  return multiPolygon2.coordinates.some(
-    (coords) => isPolyInPoly({ type: "Polygon", coordinates: coords }, polygon2)
-  );
-}
-function isPointInMultiPoint(multiPoint, pt) {
-  let i2;
-  let output = false;
-  for (i2 = 0; i2 < multiPoint.coordinates.length; i2++) {
-    if (compareCoords(multiPoint.coordinates[i2], pt.coordinates)) {
-      output = true;
-      break;
-    }
-  }
-  return output;
-}
-function isMultiPointInMultiPoint(multiPoint1, multiPoint2) {
-  for (const coord2 of multiPoint2.coordinates) {
-    let matchFound = false;
-    for (const coord1 of multiPoint1.coordinates) {
-      if (compareCoords(coord2, coord1)) {
-        matchFound = true;
-        break;
-      }
-    }
-    if (!matchFound) {
-      return false;
-    }
-  }
-  return true;
-}
-function isMultiPointOnLine(lineString2, multiPoint) {
-  let haveFoundInteriorPoint = false;
-  for (const coord of multiPoint.coordinates) {
-    if (booleanPointOnLine(coord, lineString2, { ignoreEndVertices: true })) {
-      haveFoundInteriorPoint = true;
-    }
-    if (!booleanPointOnLine(coord, lineString2)) {
-      return false;
-    }
-  }
-  if (haveFoundInteriorPoint) {
-    return true;
-  }
-  return false;
-}
-function isMultiPointInPoly(polygon2, multiPoint) {
-  for (const coord of multiPoint.coordinates) {
-    if (!booleanPointInPolygon(coord, polygon2, { ignoreBoundary: true })) {
-      return false;
-    }
-  }
-  return true;
-}
-function isLineOnLine(lineString1, lineString2) {
-  let haveFoundInteriorPoint = false;
-  for (const coords of lineString2.coordinates) {
-    if (booleanPointOnLine({ type: "Point", coordinates: coords }, lineString1, {
-      ignoreEndVertices: true
-    })) {
-      haveFoundInteriorPoint = true;
-    }
-    if (!booleanPointOnLine({ type: "Point", coordinates: coords }, lineString1, {
-      ignoreEndVertices: false
-    })) {
-      return false;
-    }
-  }
-  return haveFoundInteriorPoint;
-}
-function isLineInPoly(polygon2, linestring) {
-  let output = false;
-  let i2 = 0;
-  const polyBbox = bbox$1(polygon2);
-  const lineBbox = bbox$1(linestring);
-  if (!doBBoxOverlap(polyBbox, lineBbox)) {
-    return false;
-  }
-  for (i2; i2 < linestring.coordinates.length - 1; i2++) {
-    const midPoint = getMidpoint(
-      linestring.coordinates[i2],
-      linestring.coordinates[i2 + 1]
-    );
-    if (booleanPointInPolygon({ type: "Point", coordinates: midPoint }, polygon2, {
-      ignoreBoundary: true
-    })) {
-      output = true;
-      break;
-    }
-  }
-  return output;
-}
-function isPolyInPoly(feature1, feature2) {
-  if (feature1.type === "Feature" && feature1.geometry === null) {
-    return false;
-  }
-  if (feature2.type === "Feature" && feature2.geometry === null) {
-    return false;
-  }
-  const poly1Bbox = bbox$1(feature1);
-  const poly2Bbox = bbox$1(feature2);
-  if (!doBBoxOverlap(poly1Bbox, poly2Bbox)) {
-    return false;
-  }
-  const coords = getGeom(feature2).coordinates;
-  for (const ring of coords) {
-    for (const coord of ring) {
-      if (!booleanPointInPolygon(coord, feature1)) {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-function doBBoxOverlap(bbox1, bbox2) {
-  if (bbox1[0] > bbox2[0]) {
-    return false;
-  }
-  if (bbox1[2] < bbox2[2]) {
-    return false;
-  }
-  if (bbox1[1] > bbox2[1]) {
-    return false;
-  }
-  if (bbox1[3] < bbox2[3]) {
-    return false;
-  }
-  return true;
-}
-function compareCoords(pair1, pair2) {
-  return pair1[0] === pair2[0] && pair1[1] === pair2[1];
-}
-function getMidpoint(pair1, pair2) {
-  return [(pair1[0] + pair2[0]) / 2, (pair1[1] + pair2[1]) / 2];
-}
-function quickselect(arr, k, left, right, compare2) {
-  quickselectStep(arr, k, left || 0, right || arr.length - 1, compare2 || defaultCompare$1);
-}
-function quickselectStep(arr, k, left, right, compare2) {
-  while (right > left) {
-    if (right - left > 600) {
-      var n3 = right - left + 1;
-      var m = k - left + 1;
-      var z = Math.log(n3);
-      var s2 = 0.5 * Math.exp(2 * z / 3);
-      var sd = 0.5 * Math.sqrt(z * s2 * (n3 - s2) / n3) * (m - n3 / 2 < 0 ? -1 : 1);
-      var newLeft = Math.max(left, Math.floor(k - m * s2 / n3 + sd));
-      var newRight = Math.min(right, Math.floor(k + (n3 - m) * s2 / n3 + sd));
-      quickselectStep(arr, k, newLeft, newRight, compare2);
-    }
-    var t = arr[k];
-    var i2 = left;
-    var j = right;
-    swap(arr, left, k);
-    if (compare2(arr[right], t) > 0) swap(arr, left, right);
-    while (i2 < j) {
-      swap(arr, i2, j);
-      i2++;
-      j--;
-      while (compare2(arr[i2], t) < 0) i2++;
-      while (compare2(arr[j], t) > 0) j--;
-    }
-    if (compare2(arr[left], t) === 0) swap(arr, left, j);
-    else {
-      j++;
-      swap(arr, j, right);
-    }
-    if (j <= k) left = j + 1;
-    if (k <= j) right = j - 1;
-  }
-}
-function swap(arr, i2, j) {
-  var tmp = arr[i2];
-  arr[i2] = arr[j];
-  arr[j] = tmp;
-}
-function defaultCompare$1(a2, b) {
-  return a2 < b ? -1 : a2 > b ? 1 : 0;
-}
-class RBush {
-  constructor(maxEntries = 9) {
-    this._maxEntries = Math.max(4, maxEntries);
-    this._minEntries = Math.max(2, Math.ceil(this._maxEntries * 0.4));
-    this.clear();
-  }
-  all() {
-    return this._all(this.data, []);
-  }
-  search(bbox2) {
-    let node2 = this.data;
-    const result = [];
-    if (!intersects(bbox2, node2)) return result;
-    const toBBox = this.toBBox;
-    const nodesToSearch = [];
-    while (node2) {
-      for (let i2 = 0; i2 < node2.children.length; i2++) {
-        const child = node2.children[i2];
-        const childBBox = node2.leaf ? toBBox(child) : child;
-        if (intersects(bbox2, childBBox)) {
-          if (node2.leaf) result.push(child);
-          else if (contains$1(bbox2, childBBox)) this._all(child, result);
-          else nodesToSearch.push(child);
-        }
-      }
-      node2 = nodesToSearch.pop();
-    }
-    return result;
-  }
-  collides(bbox2) {
-    let node2 = this.data;
-    if (!intersects(bbox2, node2)) return false;
-    const nodesToSearch = [];
-    while (node2) {
-      for (let i2 = 0; i2 < node2.children.length; i2++) {
-        const child = node2.children[i2];
-        const childBBox = node2.leaf ? this.toBBox(child) : child;
-        if (intersects(bbox2, childBBox)) {
-          if (node2.leaf || contains$1(bbox2, childBBox)) return true;
-          nodesToSearch.push(child);
-        }
-      }
-      node2 = nodesToSearch.pop();
-    }
-    return false;
-  }
-  load(data) {
-    if (!(data && data.length)) return this;
-    if (data.length < this._minEntries) {
-      for (let i2 = 0; i2 < data.length; i2++) {
-        this.insert(data[i2]);
-      }
-      return this;
-    }
-    let node2 = this._build(data.slice(), 0, data.length - 1, 0);
-    if (!this.data.children.length) {
-      this.data = node2;
-    } else if (this.data.height === node2.height) {
-      this._splitRoot(this.data, node2);
-    } else {
-      if (this.data.height < node2.height) {
-        const tmpNode = this.data;
-        this.data = node2;
-        node2 = tmpNode;
-      }
-      this._insert(node2, this.data.height - node2.height - 1, true);
-    }
-    return this;
-  }
-  insert(item) {
-    if (item) this._insert(item, this.data.height - 1);
-    return this;
-  }
-  clear() {
-    this.data = createNode([]);
-    return this;
-  }
-  remove(item, equalsFn) {
-    if (!item) return this;
-    let node2 = this.data;
-    const bbox2 = this.toBBox(item);
-    const path = [];
-    const indexes = [];
-    let i2, parent, goingUp;
-    while (node2 || path.length) {
-      if (!node2) {
-        node2 = path.pop();
-        parent = path[path.length - 1];
-        i2 = indexes.pop();
-        goingUp = true;
-      }
-      if (node2.leaf) {
-        const index2 = findItem(item, node2.children, equalsFn);
-        if (index2 !== -1) {
-          node2.children.splice(index2, 1);
-          path.push(node2);
-          this._condense(path);
-          return this;
-        }
-      }
-      if (!goingUp && !node2.leaf && contains$1(node2, bbox2)) {
-        path.push(node2);
-        indexes.push(i2);
-        i2 = 0;
-        parent = node2;
-        node2 = node2.children[0];
-      } else if (parent) {
-        i2++;
-        node2 = parent.children[i2];
-        goingUp = false;
-      } else node2 = null;
-    }
-    return this;
-  }
-  toBBox(item) {
-    return item;
-  }
-  compareMinX(a2, b) {
-    return a2.minX - b.minX;
-  }
-  compareMinY(a2, b) {
-    return a2.minY - b.minY;
-  }
-  toJSON() {
-    return this.data;
-  }
-  fromJSON(data) {
-    this.data = data;
-    return this;
-  }
-  _all(node2, result) {
-    const nodesToSearch = [];
-    while (node2) {
-      if (node2.leaf) result.push(...node2.children);
-      else nodesToSearch.push(...node2.children);
-      node2 = nodesToSearch.pop();
-    }
-    return result;
-  }
-  _build(items, left, right, height) {
-    const N2 = right - left + 1;
-    let M = this._maxEntries;
-    let node2;
-    if (N2 <= M) {
-      node2 = createNode(items.slice(left, right + 1));
-      calcBBox(node2, this.toBBox);
-      return node2;
-    }
-    if (!height) {
-      height = Math.ceil(Math.log(N2) / Math.log(M));
-      M = Math.ceil(N2 / Math.pow(M, height - 1));
-    }
-    node2 = createNode([]);
-    node2.leaf = false;
-    node2.height = height;
-    const N22 = Math.ceil(N2 / M);
-    const N1 = N22 * Math.ceil(Math.sqrt(M));
-    multiSelect(items, left, right, N1, this.compareMinX);
-    for (let i2 = left; i2 <= right; i2 += N1) {
-      const right2 = Math.min(i2 + N1 - 1, right);
-      multiSelect(items, i2, right2, N22, this.compareMinY);
-      for (let j = i2; j <= right2; j += N22) {
-        const right3 = Math.min(j + N22 - 1, right2);
-        node2.children.push(this._build(items, j, right3, height - 1));
-      }
-    }
-    calcBBox(node2, this.toBBox);
-    return node2;
-  }
-  _chooseSubtree(bbox2, node2, level, path) {
-    while (true) {
-      path.push(node2);
-      if (node2.leaf || path.length - 1 === level) break;
-      let minArea = Infinity;
-      let minEnlargement = Infinity;
-      let targetNode;
-      for (let i2 = 0; i2 < node2.children.length; i2++) {
-        const child = node2.children[i2];
-        const area2 = bboxArea(child);
-        const enlargement = enlargedArea(bbox2, child) - area2;
-        if (enlargement < minEnlargement) {
-          minEnlargement = enlargement;
-          minArea = area2 < minArea ? area2 : minArea;
-          targetNode = child;
-        } else if (enlargement === minEnlargement) {
-          if (area2 < minArea) {
-            minArea = area2;
-            targetNode = child;
-          }
-        }
-      }
-      node2 = targetNode || node2.children[0];
-    }
-    return node2;
-  }
-  _insert(item, level, isNode2) {
-    const bbox2 = isNode2 ? item : this.toBBox(item);
-    const insertPath = [];
-    const node2 = this._chooseSubtree(bbox2, this.data, level, insertPath);
-    node2.children.push(item);
-    extend(node2, bbox2);
-    while (level >= 0) {
-      if (insertPath[level].children.length > this._maxEntries) {
-        this._split(insertPath, level);
-        level--;
-      } else break;
-    }
-    this._adjustParentBBoxes(bbox2, insertPath, level);
-  }
-  // split overflowed node into two
-  _split(insertPath, level) {
-    const node2 = insertPath[level];
-    const M = node2.children.length;
-    const m = this._minEntries;
-    this._chooseSplitAxis(node2, m, M);
-    const splitIndex = this._chooseSplitIndex(node2, m, M);
-    const newNode = createNode(node2.children.splice(splitIndex, node2.children.length - splitIndex));
-    newNode.height = node2.height;
-    newNode.leaf = node2.leaf;
-    calcBBox(node2, this.toBBox);
-    calcBBox(newNode, this.toBBox);
-    if (level) insertPath[level - 1].children.push(newNode);
-    else this._splitRoot(node2, newNode);
-  }
-  _splitRoot(node2, newNode) {
-    this.data = createNode([node2, newNode]);
-    this.data.height = node2.height + 1;
-    this.data.leaf = false;
-    calcBBox(this.data, this.toBBox);
-  }
-  _chooseSplitIndex(node2, m, M) {
-    let index2;
-    let minOverlap = Infinity;
-    let minArea = Infinity;
-    for (let i2 = m; i2 <= M - m; i2++) {
-      const bbox1 = distBBox(node2, 0, i2, this.toBBox);
-      const bbox2 = distBBox(node2, i2, M, this.toBBox);
-      const overlap = intersectionArea(bbox1, bbox2);
-      const area2 = bboxArea(bbox1) + bboxArea(bbox2);
-      if (overlap < minOverlap) {
-        minOverlap = overlap;
-        index2 = i2;
-        minArea = area2 < minArea ? area2 : minArea;
-      } else if (overlap === minOverlap) {
-        if (area2 < minArea) {
-          minArea = area2;
-          index2 = i2;
-        }
-      }
-    }
-    return index2 || M - m;
-  }
-  // sorts node children by the best axis for split
-  _chooseSplitAxis(node2, m, M) {
-    const compareMinX = node2.leaf ? this.compareMinX : compareNodeMinX;
-    const compareMinY = node2.leaf ? this.compareMinY : compareNodeMinY;
-    const xMargin = this._allDistMargin(node2, m, M, compareMinX);
-    const yMargin = this._allDistMargin(node2, m, M, compareMinY);
-    if (xMargin < yMargin) node2.children.sort(compareMinX);
-  }
-  // total margin of all possible split distributions where each node is at least m full
-  _allDistMargin(node2, m, M, compare2) {
-    node2.children.sort(compare2);
-    const toBBox = this.toBBox;
-    const leftBBox = distBBox(node2, 0, m, toBBox);
-    const rightBBox = distBBox(node2, M - m, M, toBBox);
-    let margin = bboxMargin(leftBBox) + bboxMargin(rightBBox);
-    for (let i2 = m; i2 < M - m; i2++) {
-      const child = node2.children[i2];
-      extend(leftBBox, node2.leaf ? toBBox(child) : child);
-      margin += bboxMargin(leftBBox);
-    }
-    for (let i2 = M - m - 1; i2 >= m; i2--) {
-      const child = node2.children[i2];
-      extend(rightBBox, node2.leaf ? toBBox(child) : child);
-      margin += bboxMargin(rightBBox);
-    }
-    return margin;
-  }
-  _adjustParentBBoxes(bbox2, path, level) {
-    for (let i2 = level; i2 >= 0; i2--) {
-      extend(path[i2], bbox2);
-    }
-  }
-  _condense(path) {
-    for (let i2 = path.length - 1, siblings; i2 >= 0; i2--) {
-      if (path[i2].children.length === 0) {
-        if (i2 > 0) {
-          siblings = path[i2 - 1].children;
-          siblings.splice(siblings.indexOf(path[i2]), 1);
-        } else this.clear();
-      } else calcBBox(path[i2], this.toBBox);
-    }
-  }
-}
-function findItem(item, items, equalsFn) {
-  if (!equalsFn) return items.indexOf(item);
-  for (let i2 = 0; i2 < items.length; i2++) {
-    if (equalsFn(item, items[i2])) return i2;
-  }
-  return -1;
-}
-function calcBBox(node2, toBBox) {
-  distBBox(node2, 0, node2.children.length, toBBox, node2);
-}
-function distBBox(node2, k, p, toBBox, destNode) {
-  if (!destNode) destNode = createNode(null);
-  destNode.minX = Infinity;
-  destNode.minY = Infinity;
-  destNode.maxX = -Infinity;
-  destNode.maxY = -Infinity;
-  for (let i2 = k; i2 < p; i2++) {
-    const child = node2.children[i2];
-    extend(destNode, node2.leaf ? toBBox(child) : child);
-  }
-  return destNode;
-}
-function extend(a2, b) {
-  a2.minX = Math.min(a2.minX, b.minX);
-  a2.minY = Math.min(a2.minY, b.minY);
-  a2.maxX = Math.max(a2.maxX, b.maxX);
-  a2.maxY = Math.max(a2.maxY, b.maxY);
-  return a2;
-}
-function compareNodeMinX(a2, b) {
-  return a2.minX - b.minX;
-}
-function compareNodeMinY(a2, b) {
-  return a2.minY - b.minY;
-}
-function bboxArea(a2) {
-  return (a2.maxX - a2.minX) * (a2.maxY - a2.minY);
-}
-function bboxMargin(a2) {
-  return a2.maxX - a2.minX + (a2.maxY - a2.minY);
-}
-function enlargedArea(a2, b) {
-  return (Math.max(b.maxX, a2.maxX) - Math.min(b.minX, a2.minX)) * (Math.max(b.maxY, a2.maxY) - Math.min(b.minY, a2.minY));
-}
-function intersectionArea(a2, b) {
-  const minX = Math.max(a2.minX, b.minX);
-  const minY = Math.max(a2.minY, b.minY);
-  const maxX = Math.min(a2.maxX, b.maxX);
-  const maxY = Math.min(a2.maxY, b.maxY);
-  return Math.max(0, maxX - minX) * Math.max(0, maxY - minY);
-}
-function contains$1(a2, b) {
-  return a2.minX <= b.minX && a2.minY <= b.minY && b.maxX <= a2.maxX && b.maxY <= a2.maxY;
-}
-function intersects(a2, b) {
-  return b.minX <= a2.maxX && b.minY <= a2.maxY && b.maxX >= a2.minX && b.maxY >= a2.minY;
-}
-function createNode(children) {
-  return {
-    children,
-    height: 1,
-    leaf: true,
-    minX: Infinity,
-    minY: Infinity,
-    maxX: -Infinity,
-    maxY: -Infinity
-  };
-}
-function multiSelect(arr, left, right, n3, compare2) {
-  const stack2 = [left, right];
-  while (stack2.length) {
-    right = stack2.pop();
-    left = stack2.pop();
-    if (right - left <= n3) continue;
-    const mid = left + Math.ceil((right - left) / n3 / 2) * n3;
-    quickselect(arr, mid, left, right, compare2);
-    stack2.push(left, mid, mid, right);
-  }
-}
-function geojsonRbush(maxEntries) {
-  var tree = new RBush(maxEntries);
-  tree.insert = function(feature2) {
-    if (feature2.type !== "Feature") throw new Error("invalid feature");
-    feature2.bbox = feature2.bbox ? feature2.bbox : bbox$1(feature2);
-    return RBush.prototype.insert.call(this, feature2);
-  };
-  tree.load = function(features) {
-    var load2 = [];
-    if (Array.isArray(features)) {
-      features.forEach(function(feature2) {
-        if (feature2.type !== "Feature") throw new Error("invalid features");
-        feature2.bbox = feature2.bbox ? feature2.bbox : bbox$1(feature2);
-        load2.push(feature2);
-      });
-    } else {
-      featureEach(features, function(feature2) {
-        if (feature2.type !== "Feature") throw new Error("invalid features");
-        feature2.bbox = feature2.bbox ? feature2.bbox : bbox$1(feature2);
-        load2.push(feature2);
-      });
-    }
-    return RBush.prototype.load.call(this, load2);
-  };
-  tree.remove = function(feature2, equals2) {
-    if (feature2.type !== "Feature") throw new Error("invalid feature");
-    feature2.bbox = feature2.bbox ? feature2.bbox : bbox$1(feature2);
-    return RBush.prototype.remove.call(this, feature2, equals2);
-  };
-  tree.clear = function() {
-    return RBush.prototype.clear.call(this);
-  };
-  tree.search = function(geojson) {
-    var features = RBush.prototype.search.call(this, this.toBBox(geojson));
-    return featureCollection(features);
-  };
-  tree.collides = function(geojson) {
-    return RBush.prototype.collides.call(this, this.toBBox(geojson));
-  };
-  tree.all = function() {
-    var features = RBush.prototype.all.call(this);
-    return featureCollection(features);
-  };
-  tree.toJSON = function() {
-    return RBush.prototype.toJSON.call(this);
-  };
-  tree.fromJSON = function(json) {
-    return RBush.prototype.fromJSON.call(this, json);
-  };
-  tree.toBBox = function(geojson) {
-    var bbox2;
-    if (geojson.bbox) bbox2 = geojson.bbox;
-    else if (Array.isArray(geojson) && geojson.length === 4) bbox2 = geojson;
-    else if (Array.isArray(geojson) && geojson.length === 6)
-      bbox2 = [geojson[0], geojson[1], geojson[3], geojson[4]];
-    else if (geojson.type === "Feature") bbox2 = bbox$1(geojson);
-    else if (geojson.type === "FeatureCollection") bbox2 = bbox$1(geojson);
-    else throw new Error("invalid geojson");
-    return {
-      minX: bbox2[0],
-      minY: bbox2[1],
-      maxX: bbox2[2],
-      maxY: bbox2[3]
-    };
-  };
-  return tree;
-}
-function lineSegment(geojson) {
-  if (!geojson) {
-    throw new Error("geojson is required");
-  }
-  const results = [];
-  flattenEach(geojson, (feature2) => {
-    lineSegmentFeature(feature2, results);
-  });
-  return featureCollection(results);
-}
-function lineSegmentFeature(geojson, results) {
-  let coords = [];
-  const geometry2 = geojson.geometry;
-  if (geometry2 !== null) {
-    switch (geometry2.type) {
-      case "Polygon":
-        coords = getCoords(geometry2);
-        break;
-      case "LineString":
-        coords = [getCoords(geometry2)];
-    }
-    coords.forEach((coord) => {
-      const segments = createSegments(coord, geojson.properties);
-      segments.forEach((segment) => {
-        segment.id = results.length;
-        results.push(segment);
-      });
-    });
-  }
-}
-function createSegments(coords, properties) {
-  const segments = [];
-  coords.reduce((previousCoords, currentCoords) => {
-    const segment = lineString([previousCoords, currentCoords], properties);
-    segment.bbox = bbox(previousCoords, currentCoords);
-    segments.push(segment);
-    return currentCoords;
-  });
-  return segments;
-}
-function bbox(coords1, coords2) {
-  const x12 = coords1[0];
-  const y12 = coords1[1];
-  const x2 = coords2[0];
-  const y2 = coords2[1];
-  const west = x12 < x2 ? x12 : x2;
-  const south = y12 < y2 ? y12 : y2;
-  const east = x12 > x2 ? x12 : x2;
-  const north = y12 > y2 ? y12 : y2;
-  return [west, south, east, north];
-}
-function distance$1(from, to, options = {}) {
-  var coordinates1 = getCoord(from);
-  var coordinates2 = getCoord(to);
-  var dLat = degreesToRadians(coordinates2[1] - coordinates1[1]);
-  var dLon = degreesToRadians(coordinates2[0] - coordinates1[0]);
-  var lat1 = degreesToRadians(coordinates1[1]);
-  var lat2 = degreesToRadians(coordinates2[1]);
-  var a2 = Math.pow(Math.sin(dLat / 2), 2) + Math.pow(Math.sin(dLon / 2), 2) * Math.cos(lat1) * Math.cos(lat2);
-  return radiansToLength(
-    2 * Math.atan2(Math.sqrt(a2), Math.sqrt(1 - a2)),
-    options.units
-  );
-}
-var __defProp$2 = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a2, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp$1(a2, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp$1(a2, prop, b[prop]);
-    }
-  return a2;
-};
-var __spreadProps = (a2, b) => __defProps(a2, __getOwnPropDescs(b));
-function nearestPointOnLine(lines, pt, options = {}) {
-  if (!lines || !pt) {
-    throw new Error("lines and pt are required arguments");
-  }
-  const ptPos = getCoord(pt);
-  let closestPt = point([Infinity, Infinity], {
-    dist: Infinity,
-    index: -1,
-    multiFeatureIndex: -1,
-    location: -1
-  });
-  let length2 = 0;
-  flattenEach(
-    lines,
-    function(line, _featureIndex, multiFeatureIndex) {
-      const coords = getCoords(line);
-      for (let i2 = 0; i2 < coords.length - 1; i2++) {
-        const start = point(coords[i2]);
-        start.properties.dist = distance$1(pt, start, options);
-        const startPos = getCoord(start);
-        const stop = point(coords[i2 + 1]);
-        stop.properties.dist = distance$1(pt, stop, options);
-        const stopPos = getCoord(stop);
-        const sectionLength = distance$1(start, stop, options);
-        let intersectPos;
-        let wasEnd;
-        if (startPos[0] === ptPos[0] && startPos[1] === ptPos[1]) {
-          [intersectPos, , wasEnd] = [startPos, void 0, false];
-        } else if (stopPos[0] === ptPos[0] && stopPos[1] === ptPos[1]) {
-          [intersectPos, , wasEnd] = [stopPos, void 0, true];
-        } else {
-          [intersectPos, , wasEnd] = nearestPointOnSegment(
-            start.geometry.coordinates,
-            stop.geometry.coordinates,
-            getCoord(pt)
-          );
-        }
-        let intersectPt;
-        if (intersectPos) {
-          intersectPt = point(intersectPos, {
-            dist: distance$1(pt, intersectPos, options),
-            multiFeatureIndex,
-            location: length2 + distance$1(start, intersectPos, options)
-          });
-        }
-        if (intersectPt && intersectPt.properties.dist < closestPt.properties.dist) {
-          closestPt = __spreadProps(__spreadValues({}, intersectPt), {
-            properties: __spreadProps(__spreadValues({}, intersectPt.properties), {
-              // Legacy behaviour where index progresses to next segment # if we
-              // went with the end point this iteration.
-              index: wasEnd ? i2 + 1 : i2
-            })
-          });
-        }
-        length2 += sectionLength;
-      }
-    }
-  );
-  return closestPt;
-}
-function dot(v12, v2) {
-  const [v1x, v1y, v1z] = v12;
-  const [v2x, v2y, v2z] = v2;
-  return v1x * v2x + v1y * v2y + v1z * v2z;
-}
-function cross(v12, v2) {
-  const [v1x, v1y, v1z] = v12;
-  const [v2x, v2y, v2z] = v2;
-  return [v1y * v2z - v1z * v2y, v1z * v2x - v1x * v2z, v1x * v2y - v1y * v2x];
-}
-function magnitude(v) {
-  return Math.sqrt(Math.pow(v[0], 2) + Math.pow(v[1], 2) + Math.pow(v[2], 2));
-}
-function angle$1(v12, v2) {
-  const theta = dot(v12, v2) / (magnitude(v12) * magnitude(v2));
-  return Math.acos(Math.min(Math.max(theta, -1), 1));
-}
-function lngLatToVector(a2) {
-  const lat = degreesToRadians(a2[1]);
-  const lng = degreesToRadians(a2[0]);
-  return [
-    Math.cos(lat) * Math.cos(lng),
-    Math.cos(lat) * Math.sin(lng),
-    Math.sin(lat)
-  ];
-}
-function vectorToLngLat(v) {
-  const [x, y, z] = v;
-  const lat = radiansToDegrees(Math.asin(z));
-  const lng = radiansToDegrees(Math.atan2(y, x));
-  return [lng, lat];
-}
-function nearestPointOnSegment(posA, posB, posC) {
-  const A2 = lngLatToVector(posA);
-  const B2 = lngLatToVector(posB);
-  const C3 = lngLatToVector(posC);
-  const [Cx, Cy, Cz] = C3;
-  const [D2, E2, F] = cross(A2, B2);
-  const a2 = E2 * Cz - F * Cy;
-  const b = F * Cx - D2 * Cz;
-  const c = D2 * Cy - E2 * Cx;
-  const f2 = c * E2 - b * F;
-  const g2 = a2 * F - c * D2;
-  const h = b * D2 - a2 * E2;
-  const t = 1 / Math.sqrt(Math.pow(f2, 2) + Math.pow(g2, 2) + Math.pow(h, 2));
-  const I1 = [f2 * t, g2 * t, h * t];
-  const I2 = [-1 * f2 * t, -1 * g2 * t, -1 * h * t];
-  const angleAB = angle$1(A2, B2);
-  const angleAI1 = angle$1(A2, I1);
-  const angleBI1 = angle$1(B2, I1);
-  const angleAI2 = angle$1(A2, I2);
-  const angleBI2 = angle$1(B2, I2);
-  let I3;
-  if (angleAI1 < angleAI2 && angleAI1 < angleBI2 || angleBI1 < angleAI2 && angleBI1 < angleBI2) {
-    I3 = I1;
-  } else {
-    I3 = I2;
-  }
-  if (angle$1(A2, I3) > angleAB || angle$1(B2, I3) > angleAB) {
-    if (distance$1(vectorToLngLat(I3), vectorToLngLat(A2)) <= distance$1(vectorToLngLat(I3), vectorToLngLat(B2))) {
-      return [vectorToLngLat(A2), true, false];
-    } else {
-      return [vectorToLngLat(B2), false, true];
-    }
-  }
-  return [vectorToLngLat(I3), false, false];
-}
-var fastDeepEqual;
-var hasRequiredFastDeepEqual;
-function requireFastDeepEqual() {
-  if (hasRequiredFastDeepEqual) return fastDeepEqual;
-  hasRequiredFastDeepEqual = 1;
-  fastDeepEqual = function equal2(a2, b) {
-    if (a2 === b) return true;
-    if (a2 && b && typeof a2 == "object" && typeof b == "object") {
-      if (a2.constructor !== b.constructor) return false;
-      var length2, i2, keys2;
-      if (Array.isArray(a2)) {
-        length2 = a2.length;
-        if (length2 != b.length) return false;
-        for (i2 = length2; i2-- !== 0; )
-          if (!equal2(a2[i2], b[i2])) return false;
-        return true;
-      }
-      if (a2.constructor === RegExp) return a2.source === b.source && a2.flags === b.flags;
-      if (a2.valueOf !== Object.prototype.valueOf) return a2.valueOf() === b.valueOf();
-      if (a2.toString !== Object.prototype.toString) return a2.toString() === b.toString();
-      keys2 = Object.keys(a2);
-      length2 = keys2.length;
-      if (length2 !== Object.keys(b).length) return false;
-      for (i2 = length2; i2-- !== 0; )
-        if (!Object.prototype.hasOwnProperty.call(b, keys2[i2])) return false;
-      for (i2 = length2; i2-- !== 0; ) {
-        var key = keys2[i2];
-        if (!equal2(a2[key], b[key])) return false;
-      }
-      return true;
-    }
-    return a2 !== a2 && b !== b;
-  };
-  return fastDeepEqual;
-}
-var fastDeepEqualExports = requireFastDeepEqual();
-const equal$1 = /* @__PURE__ */ getDefaultExportFromCjs(fastDeepEqualExports);
-function lineOverlap(line1, line2, options = {}) {
-  options = options || {};
-  if (!isObject$1(options)) throw new Error("options is invalid");
-  var tolerance = options.tolerance || 0;
-  var features = [];
-  var tree = geojsonRbush();
-  const line = lineSegment(line1);
-  tree.load(line);
-  var overlapSegment;
-  let additionalSegments = [];
-  segmentEach(line2, function(segment) {
-    var doesOverlaps = false;
-    if (!segment) {
-      return;
-    }
-    featureEach(tree.search(segment), function(match) {
-      if (doesOverlaps === false) {
-        var coordsSegment = getCoords(segment).sort();
-        var coordsMatch = getCoords(match).sort();
-        if (equal$1(coordsSegment, coordsMatch)) {
-          doesOverlaps = true;
-          if (overlapSegment) {
-            overlapSegment = concatSegment(overlapSegment, segment) || overlapSegment;
-          } else overlapSegment = segment;
-        } else if (tolerance === 0 ? booleanPointOnLine(coordsSegment[0], match) && booleanPointOnLine(coordsSegment[1], match) : nearestPointOnLine(match, coordsSegment[0]).properties.dist <= tolerance && nearestPointOnLine(match, coordsSegment[1]).properties.dist <= tolerance) {
-          doesOverlaps = true;
-          if (overlapSegment) {
-            overlapSegment = concatSegment(overlapSegment, segment) || overlapSegment;
-          } else overlapSegment = segment;
-        } else if (tolerance === 0 ? booleanPointOnLine(coordsMatch[0], segment) && booleanPointOnLine(coordsMatch[1], segment) : nearestPointOnLine(segment, coordsMatch[0]).properties.dist <= tolerance && nearestPointOnLine(segment, coordsMatch[1]).properties.dist <= tolerance) {
-          if (overlapSegment) {
-            const combinedSegment = concatSegment(overlapSegment, match);
-            if (combinedSegment) {
-              overlapSegment = combinedSegment;
-            } else {
-              additionalSegments.push(match);
-            }
-          } else overlapSegment = match;
-        }
-      }
-    });
-    if (doesOverlaps === false && overlapSegment) {
-      features.push(overlapSegment);
-      if (additionalSegments.length) {
-        features = features.concat(additionalSegments);
-        additionalSegments = [];
-      }
-      overlapSegment = void 0;
-    }
-  });
-  if (overlapSegment) features.push(overlapSegment);
-  return featureCollection(features);
-}
-function concatSegment(line, segment) {
-  var coords = getCoords(segment);
-  var lineCoords = getCoords(line);
-  var start = lineCoords[0];
-  var end = lineCoords[lineCoords.length - 1];
-  var geom = line.geometry.coordinates;
-  if (equal$1(coords[0], start)) geom.unshift(coords[1]);
-  else if (equal$1(coords[0], end)) geom.push(coords[1]);
-  else if (equal$1(coords[1], start)) geom.unshift(coords[0]);
-  else if (equal$1(coords[1], end)) geom.push(coords[0]);
-  else return;
-  return line;
-}
-class TinyQueue {
-  constructor(data = [], compare2 = defaultCompare) {
-    this.data = data;
-    this.length = this.data.length;
-    this.compare = compare2;
-    if (this.length > 0) {
-      for (let i2 = (this.length >> 1) - 1; i2 >= 0; i2--) this._down(i2);
-    }
-  }
-  push(item) {
-    this.data.push(item);
-    this.length++;
-    this._up(this.length - 1);
-  }
-  pop() {
-    if (this.length === 0) return void 0;
-    const top = this.data[0];
-    const bottom = this.data.pop();
-    this.length--;
-    if (this.length > 0) {
-      this.data[0] = bottom;
-      this._down(0);
-    }
-    return top;
-  }
-  peek() {
-    return this.data[0];
-  }
-  _up(pos) {
-    const { data, compare: compare2 } = this;
-    const item = data[pos];
-    while (pos > 0) {
-      const parent = pos - 1 >> 1;
-      const current = data[parent];
-      if (compare2(item, current) >= 0) break;
-      data[pos] = current;
-      pos = parent;
-    }
-    data[pos] = item;
-  }
-  _down(pos) {
-    const { data, compare: compare2 } = this;
-    const halfLength = this.length >> 1;
-    const item = data[pos];
-    while (pos < halfLength) {
-      let left = (pos << 1) + 1;
-      let best = data[left];
-      const right = left + 1;
-      if (right < this.length && compare2(data[right], best) < 0) {
-        left = right;
-        best = data[right];
-      }
-      if (compare2(best, item) >= 0) break;
-      data[pos] = best;
-      pos = left;
-    }
-    data[pos] = item;
-  }
-}
-function defaultCompare(a2, b) {
-  return a2 < b ? -1 : a2 > b ? 1 : 0;
-}
-function checkWhichEventIsLeft(e1, e2) {
-  if (e1.p.x > e2.p.x) return 1;
-  if (e1.p.x < e2.p.x) return -1;
-  if (e1.p.y !== e2.p.y) return e1.p.y > e2.p.y ? 1 : -1;
-  return 1;
-}
-function checkWhichSegmentHasRightEndpointFirst(seg1, seg2) {
-  if (seg1.rightSweepEvent.p.x > seg2.rightSweepEvent.p.x) return 1;
-  if (seg1.rightSweepEvent.p.x < seg2.rightSweepEvent.p.x) return -1;
-  if (seg1.rightSweepEvent.p.y !== seg2.rightSweepEvent.p.y) return seg1.rightSweepEvent.p.y < seg2.rightSweepEvent.p.y ? 1 : -1;
-  return 1;
-}
-class Event {
-  constructor(p, featureId2, ringId2, eventId2) {
-    this.p = {
-      x: p[0],
-      y: p[1]
-    };
-    this.featureId = featureId2;
-    this.ringId = ringId2;
-    this.eventId = eventId2;
-    this.otherEvent = null;
-    this.isLeftEndpoint = null;
-  }
-  isSamePoint(eventToCheck) {
-    return this.p.x === eventToCheck.p.x && this.p.y === eventToCheck.p.y;
-  }
-}
-function fillEventQueue(geojson, eventQueue) {
-  if (geojson.type === "FeatureCollection") {
-    const features = geojson.features;
-    for (let i2 = 0; i2 < features.length; i2++) {
-      processFeature(features[i2], eventQueue);
-    }
-  } else {
-    processFeature(geojson, eventQueue);
-  }
-}
-let featureId = 0;
-let ringId = 0;
-let eventId = 0;
-function processFeature(featureOrGeometry, eventQueue) {
-  const geom = featureOrGeometry.type === "Feature" ? featureOrGeometry.geometry : featureOrGeometry;
-  let coords = geom.coordinates;
-  if (geom.type === "Polygon" || geom.type === "MultiLineString") coords = [coords];
-  if (geom.type === "LineString") coords = [[coords]];
-  for (let i2 = 0; i2 < coords.length; i2++) {
-    for (let ii = 0; ii < coords[i2].length; ii++) {
-      let currentP = coords[i2][ii][0];
-      let nextP = null;
-      ringId = ringId + 1;
-      for (let iii = 0; iii < coords[i2][ii].length - 1; iii++) {
-        nextP = coords[i2][ii][iii + 1];
-        const e1 = new Event(currentP, featureId, ringId, eventId);
-        const e2 = new Event(nextP, featureId, ringId, eventId + 1);
-        e1.otherEvent = e2;
-        e2.otherEvent = e1;
-        if (checkWhichEventIsLeft(e1, e2) > 0) {
-          e2.isLeftEndpoint = true;
-          e1.isLeftEndpoint = false;
-        } else {
-          e1.isLeftEndpoint = true;
-          e2.isLeftEndpoint = false;
-        }
-        eventQueue.push(e1);
-        eventQueue.push(e2);
-        currentP = nextP;
-        eventId = eventId + 1;
-      }
-    }
-  }
-  featureId = featureId + 1;
-}
-let Segment$1 = class Segment {
-  constructor(event) {
-    this.leftSweepEvent = event;
-    this.rightSweepEvent = event.otherEvent;
-  }
-};
-function testSegmentIntersect(seg1, seg2) {
-  if (seg1 === null || seg2 === null) return false;
-  if (seg1.leftSweepEvent.ringId === seg2.leftSweepEvent.ringId && (seg1.rightSweepEvent.isSamePoint(seg2.leftSweepEvent) || seg1.rightSweepEvent.isSamePoint(seg2.leftSweepEvent) || seg1.rightSweepEvent.isSamePoint(seg2.rightSweepEvent) || seg1.leftSweepEvent.isSamePoint(seg2.leftSweepEvent) || seg1.leftSweepEvent.isSamePoint(seg2.rightSweepEvent))) return false;
-  const x12 = seg1.leftSweepEvent.p.x;
-  const y12 = seg1.leftSweepEvent.p.y;
-  const x2 = seg1.rightSweepEvent.p.x;
-  const y2 = seg1.rightSweepEvent.p.y;
-  const x3 = seg2.leftSweepEvent.p.x;
-  const y3 = seg2.leftSweepEvent.p.y;
-  const x4 = seg2.rightSweepEvent.p.x;
-  const y4 = seg2.rightSweepEvent.p.y;
-  const denom = (y4 - y3) * (x2 - x12) - (x4 - x3) * (y2 - y12);
-  const numeA = (x4 - x3) * (y12 - y3) - (y4 - y3) * (x12 - x3);
-  const numeB = (x2 - x12) * (y12 - y3) - (y2 - y12) * (x12 - x3);
-  if (denom === 0) {
-    if (numeA === 0 && numeB === 0) return false;
-    return false;
-  }
-  const uA = numeA / denom;
-  const uB = numeB / denom;
-  if (uA >= 0 && uA <= 1 && uB >= 0 && uB <= 1) {
-    const x = x12 + uA * (x2 - x12);
-    const y = y12 + uA * (y2 - y12);
-    return [x, y];
-  }
-  return false;
-}
-function runCheck(eventQueue, ignoreSelfIntersections) {
-  ignoreSelfIntersections = ignoreSelfIntersections ? ignoreSelfIntersections : false;
-  const intersectionPoints = [];
-  const outQueue = new TinyQueue([], checkWhichSegmentHasRightEndpointFirst);
-  while (eventQueue.length) {
-    const event = eventQueue.pop();
-    if (event.isLeftEndpoint) {
-      const segment = new Segment$1(event);
-      for (let i2 = 0; i2 < outQueue.data.length; i2++) {
-        const otherSeg = outQueue.data[i2];
-        if (ignoreSelfIntersections) {
-          if (otherSeg.leftSweepEvent.featureId === event.featureId) continue;
-        }
-        const intersection2 = testSegmentIntersect(segment, otherSeg);
-        if (intersection2 !== false) intersectionPoints.push(intersection2);
-      }
-      outQueue.push(segment);
-    } else if (event.isLeftEndpoint === false) {
-      outQueue.pop();
-    }
-  }
-  return intersectionPoints;
-}
-function sweeplineIntersections$1(geojson, ignoreSelfIntersections) {
-  const eventQueue = new TinyQueue([], checkWhichEventIsLeft);
-  fillEventQueue(geojson, eventQueue);
-  return runCheck(eventQueue, ignoreSelfIntersections);
-}
-const sweeplineIntersections_esm = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  default: sweeplineIntersections$1
-}, Symbol.toStringTag, { value: "Module" }));
-var sweeplineIntersections = sweeplineIntersections$1;
-function lineIntersect(line1, line2, options = {}) {
-  const { removeDuplicates = true, ignoreSelfIntersections = true } = options;
-  let features = [];
-  if (line1.type === "FeatureCollection")
-    features = features.concat(line1.features);
-  else if (line1.type === "Feature") features.push(line1);
-  else if (line1.type === "LineString" || line1.type === "Polygon" || line1.type === "MultiLineString" || line1.type === "MultiPolygon") {
-    features.push(feature$1(line1));
-  }
-  if (line2.type === "FeatureCollection")
-    features = features.concat(line2.features);
-  else if (line2.type === "Feature") features.push(line2);
-  else if (line2.type === "LineString" || line2.type === "Polygon" || line2.type === "MultiLineString" || line2.type === "MultiPolygon") {
-    features.push(feature$1(line2));
-  }
-  const intersections = sweeplineIntersections(
-    featureCollection(features),
-    ignoreSelfIntersections
-  );
-  let results = [];
-  if (removeDuplicates) {
-    const unique2 = {};
-    intersections.forEach((intersection2) => {
-      const key = intersection2.join(",");
-      if (!unique2[key]) {
-        unique2[key] = true;
-        results.push(intersection2);
-      }
-    });
-  } else {
-    results = intersections;
-  }
-  return featureCollection(results.map((r2) => point(r2)));
-}
-var __defProp$1 = Object.defineProperty;
-var __name = (target, value) => __defProp$1(target, "name", { value, configurable: true });
-var _GeojsonEquality = class _GeojsonEquality2 {
-  constructor(opts) {
-    this.direction = false;
-    this.compareProperties = true;
-    var _a2, _b, _c;
-    this.precision = 10 ** -((_a2 = opts == null ? void 0 : opts.precision) != null ? _a2 : 17);
-    this.direction = (_b = opts == null ? void 0 : opts.direction) != null ? _b : false;
-    this.compareProperties = (_c = opts == null ? void 0 : opts.compareProperties) != null ? _c : true;
-  }
-  compare(g1, g2) {
-    if (g1.type !== g2.type) {
-      return false;
-    }
-    if (!sameLength(g1, g2)) {
-      return false;
-    }
-    switch (g1.type) {
-      case "Point":
-        return this.compareCoord(g1.coordinates, g2.coordinates);
-      case "LineString":
-        return this.compareLine(g1.coordinates, g2.coordinates);
-      case "Polygon":
-        return this.comparePolygon(g1, g2);
-      case "GeometryCollection":
-        return this.compareGeometryCollection(g1, g2);
-      case "Feature":
-        return this.compareFeature(g1, g2);
-      case "FeatureCollection":
-        return this.compareFeatureCollection(g1, g2);
-      default:
-        if (g1.type.startsWith("Multi")) {
-          const g1s = explode(g1);
-          const g2s = explode(
-            g2
-          );
-          return g1s.every(
-            (g1part) => g2s.some((g2part) => this.compare(g1part, g2part))
-          );
-        }
-    }
-    return false;
-  }
-  compareCoord(c1, c2) {
-    return c1.length === c2.length && c1.every((c, i2) => Math.abs(c - c2[i2]) < this.precision);
-  }
-  compareLine(path1, path2, ind = 0, isPoly = false) {
-    if (!sameLength(path1, path2)) {
-      return false;
-    }
-    const p1 = path1;
-    let p2 = path2;
-    if (isPoly && !this.compareCoord(p1[0], p2[0])) {
-      const startIndex = this.fixStartIndex(p2, p1);
-      if (!startIndex) {
-        return false;
-      } else {
-        p2 = startIndex;
-      }
-    }
-    const sameDirection = this.compareCoord(p1[ind], p2[ind]);
-    if (this.direction || sameDirection) {
-      return this.comparePath(p1, p2);
-    } else {
-      if (this.compareCoord(p1[ind], p2[p2.length - (1 + ind)])) {
-        return this.comparePath(p1.slice().reverse(), p2);
-      }
-      return false;
-    }
-  }
-  fixStartIndex(sourcePath, targetPath) {
-    let correctPath, ind = -1;
-    for (let i2 = 0; i2 < sourcePath.length; i2++) {
-      if (this.compareCoord(sourcePath[i2], targetPath[0])) {
-        ind = i2;
-        break;
-      }
-    }
-    if (ind >= 0) {
-      correctPath = [].concat(
-        sourcePath.slice(ind, sourcePath.length),
-        sourcePath.slice(1, ind + 1)
-      );
-    }
-    return correctPath;
-  }
-  comparePath(p1, p2) {
-    return p1.every((c, i2) => this.compareCoord(c, p2[i2]));
-  }
-  comparePolygon(g1, g2) {
-    if (this.compareLine(g1.coordinates[0], g2.coordinates[0], 1, true)) {
-      const holes1 = g1.coordinates.slice(1, g1.coordinates.length);
-      const holes2 = g2.coordinates.slice(1, g2.coordinates.length);
-      return holes1.every(
-        (h1) => holes2.some((h2) => this.compareLine(h1, h2, 1, true))
-      );
-    }
-    return false;
-  }
-  compareGeometryCollection(g1, g2) {
-    return sameLength(g1.geometries, g2.geometries) && this.compareBBox(g1, g2) && g1.geometries.every((g3, i2) => this.compare(g3, g2.geometries[i2]));
-  }
-  compareFeature(g1, g2) {
-    return g1.id === g2.id && (this.compareProperties ? equal(g1.properties, g2.properties) : true) && this.compareBBox(g1, g2) && this.compare(g1.geometry, g2.geometry);
-  }
-  compareFeatureCollection(g1, g2) {
-    return sameLength(g1.features, g2.features) && this.compareBBox(g1, g2) && g1.features.every((f2, i2) => this.compare(f2, g2.features[i2]));
-  }
-  compareBBox(g1, g2) {
-    return Boolean(!g1.bbox && !g2.bbox) || (g1.bbox && g2.bbox ? this.compareCoord(g1.bbox, g2.bbox) : false);
-  }
-};
-__name(_GeojsonEquality, "GeojsonEquality");
-var GeojsonEquality = _GeojsonEquality;
-function sameLength(g1, g2) {
-  return g1.coordinates ? g1.coordinates.length === g2.coordinates.length : g1.length === g2.length;
-}
-__name(sameLength, "sameLength");
-function explode(g2) {
-  return g2.coordinates.map((part) => ({
-    type: g2.type.replace("Multi", ""),
-    coordinates: part
-  }));
-}
-__name(explode, "explode");
-function geojsonEquality(g1, g2, opts) {
-  const eq2 = new GeojsonEquality(opts);
-  return eq2.compare(g1, g2);
-}
-__name(geojsonEquality, "geojsonEquality");
-function equal(object1, object2) {
-  if (object1 === null && object2 === null) {
-    return true;
-  }
-  if (object1 === null || object2 === null) {
-    return false;
-  }
-  const objKeys1 = Object.keys(object1);
-  const objKeys2 = Object.keys(object2);
-  if (objKeys1.length !== objKeys2.length) return false;
-  for (var key of objKeys1) {
-    const value1 = object1[key];
-    const value2 = object2[key];
-    const isObjects = isObject(value1) && isObject(value2);
-    if (isObjects && !equal(value1, value2) || !isObjects && value1 !== value2) {
-      return false;
-    }
-  }
-  return true;
-}
-__name(equal, "equal");
-var isObject = /* @__PURE__ */ __name((object2) => {
-  return object2 != null && typeof object2 === "object";
-}, "isObject");
-function booleanOverlap(feature1, feature2) {
-  const geom1 = getGeom(feature1);
-  const geom2 = getGeom(feature2);
-  const type1 = geom1.type;
-  const type2 = geom2.type;
-  if (type1 === "MultiPoint" && type2 !== "MultiPoint" || (type1 === "LineString" || type1 === "MultiLineString") && type2 !== "LineString" && type2 !== "MultiLineString" || (type1 === "Polygon" || type1 === "MultiPolygon") && type2 !== "Polygon" && type2 !== "MultiPolygon") {
-    throw new Error("features must be of the same type");
-  }
-  if (type1 === "Point") throw new Error("Point geometry not supported");
-  if (geojsonEquality(feature1, feature2, { precision: 6 }))
-    return false;
-  let overlap = 0;
-  switch (type1) {
-    case "MultiPoint":
-      for (var i2 = 0; i2 < geom1.coordinates.length; i2++) {
-        for (var j = 0; j < geom2.coordinates.length; j++) {
-          var coord1 = geom1.coordinates[i2];
-          var coord2 = geom2.coordinates[j];
-          if (coord1[0] === coord2[0] && coord1[1] === coord2[1]) {
-            return true;
-          }
-        }
-      }
-      return false;
-    case "LineString":
-    case "MultiLineString":
-      segmentEach(feature1, (segment1) => {
-        segmentEach(feature2, (segment2) => {
-          if (lineOverlap(segment1, segment2).features.length) overlap++;
-        });
-      });
-      break;
-    case "Polygon":
-    case "MultiPolygon":
-      segmentEach(feature1, (segment1) => {
-        segmentEach(feature2, (segment2) => {
-          if (lineIntersect(segment1, segment2).features.length) overlap++;
-        });
-      });
-      break;
-  }
-  return overlap > 0;
+function inBBox(pt, bbox) {
+  return bbox[0] <= pt[0] && bbox[1] <= pt[1] && bbox[2] >= pt[0] && bbox[3] >= pt[1];
 }
 var distEs6$2 = {};
 var style$1 = {};
@@ -83338,7 +81326,7 @@ function requireCjs$f() {
       case "Point":
         return point2(coordinates2).geometry;
       case "LineString":
-        return lineString2(coordinates2).geometry;
+        return lineString(coordinates2).geometry;
       case "Polygon":
         return polygon2(coordinates2).geometry;
       case "MultiPoint":
@@ -83408,7 +81396,7 @@ function requireCjs$f() {
       options
     );
   }
-  function lineString2(coordinates2, properties, options = {}) {
+  function lineString(coordinates2, properties, options = {}) {
     if (coordinates2.length < 2) {
       throw new Error("coordinates must be an array of two or more positions");
     }
@@ -83421,7 +81409,7 @@ function requireCjs$f() {
   function lineStrings(coordinates2, properties, options = {}) {
     return featureCollection2(
       coordinates2.map((coords) => {
-        return lineString2(coords, properties);
+        return lineString(coords, properties);
       }),
       options
     );
@@ -83487,7 +81475,7 @@ function requireCjs$f() {
     return distance2 / factor;
   }
   function lengthToDegrees(distance2, units) {
-    return radiansToDegrees2(lengthToRadians(distance2, units));
+    return radiansToDegrees(lengthToRadians(distance2, units));
   }
   function bearingToAzimuth(bearing) {
     let angle2 = bearing % 360;
@@ -83505,7 +81493,7 @@ function requireCjs$f() {
     }
     return angle2;
   }
-  function radiansToDegrees2(radians2) {
+  function radiansToDegrees(radians2) {
     const normalisedRadians = radians2 % (2 * Math.PI);
     return normalisedRadians * 180 / Math.PI;
   }
@@ -83539,17 +81527,17 @@ function requireCjs$f() {
   function isObject2(input) {
     return input !== null && typeof input === "object" && !Array.isArray(input);
   }
-  function validateBBox(bbox2) {
-    if (!bbox2) {
+  function validateBBox(bbox) {
+    if (!bbox) {
       throw new Error("bbox is required");
     }
-    if (!Array.isArray(bbox2)) {
+    if (!Array.isArray(bbox)) {
       throw new Error("bbox must be an Array");
     }
-    if (bbox2.length !== 4 && bbox2.length !== 6) {
+    if (bbox.length !== 4 && bbox.length !== 6) {
       throw new Error("bbox must be an Array of 4 or 6 numbers");
     }
-    bbox2.forEach((num) => {
+    bbox.forEach((num) => {
       if (!isNumber2(num)) {
         throw new Error("bbox must only contain numbers");
       }
@@ -83579,7 +81567,7 @@ function requireCjs$f() {
   cjs$f.isObject = isObject2;
   cjs$f.lengthToDegrees = lengthToDegrees;
   cjs$f.lengthToRadians = lengthToRadians;
-  cjs$f.lineString = lineString2;
+  cjs$f.lineString = lineString;
   cjs$f.lineStrings = lineStrings;
   cjs$f.multiLineString = multiLineString;
   cjs$f.multiPoint = multiPoint;
@@ -83588,7 +81576,7 @@ function requireCjs$f() {
   cjs$f.points = points;
   cjs$f.polygon = polygon2;
   cjs$f.polygons = polygons2;
-  cjs$f.radiansToDegrees = radiansToDegrees2;
+  cjs$f.radiansToDegrees = radiansToDegrees;
   cjs$f.radiansToLength = radiansToLength2;
   cjs$f.round = round2;
   cjs$f.validateBBox = validateBBox;
@@ -83603,7 +81591,7 @@ function requireCjs$e() {
   hasRequiredCjs$e = 1;
   Object.defineProperty(cjs$d, "__esModule", { value: true });
   var _helpers = /* @__PURE__ */ requireCjs$f();
-  function coordEach2(geojson, callback, excludeWrapCoord) {
+  function coordEach(geojson, callback, excludeWrapCoord) {
     if (geojson === null) return;
     var j, k, l2, geometry2, stopG, coords, geometryMaybeCollection, wrapShrink = 0, coordIndex = 0, isGeometryCollection, type = geojson.type, isFeatureCollection = type === "FeatureCollection", isFeature = type === "Feature", stop = isFeatureCollection ? geojson.features.length : 1;
     for (var featureIndex = 0; featureIndex < stop; featureIndex++) {
@@ -83690,7 +81678,7 @@ function requireCjs$e() {
             break;
           case "GeometryCollection":
             for (j = 0; j < geometry2.geometries.length; j++)
-              if (coordEach2(geometry2.geometries[j], callback, excludeWrapCoord) === false)
+              if (coordEach(geometry2.geometries[j], callback, excludeWrapCoord) === false)
                 return false;
             break;
           default:
@@ -83701,7 +81689,7 @@ function requireCjs$e() {
   }
   function coordReduce(geojson, callback, initialValue, excludeWrapCoord) {
     var previousValue = initialValue;
-    coordEach2(
+    coordEach(
       geojson,
       function(currentCoord, coordIndex, featureIndex, multiFeatureIndex, geometryIndex) {
         if (coordIndex === 0 && initialValue === void 0)
@@ -83743,7 +81731,7 @@ function requireCjs$e() {
     });
     return previousValue;
   }
-  function featureEach2(geojson, callback) {
+  function featureEach(geojson, callback) {
     if (geojson.type === "Feature") {
       callback(geojson, 0);
     } else if (geojson.type === "FeatureCollection") {
@@ -83754,7 +81742,7 @@ function requireCjs$e() {
   }
   function featureReduce(geojson, callback, initialValue) {
     var previousValue = initialValue;
-    featureEach2(geojson, function(currentFeature, featureIndex) {
+    featureEach(geojson, function(currentFeature, featureIndex) {
       if (featureIndex === 0 && initialValue === void 0)
         previousValue = currentFeature;
       else previousValue = callback(previousValue, currentFeature, featureIndex);
@@ -83763,7 +81751,7 @@ function requireCjs$e() {
   }
   function coordAll(geojson) {
     var coords = [];
-    coordEach2(geojson, function(coord) {
+    coordEach(geojson, function(coord) {
       coords.push(coord);
     });
     return coords;
@@ -83848,7 +81836,7 @@ function requireCjs$e() {
     return previousValue;
   }
   function flattenEach2(geojson, callback) {
-    geomEach2(geojson, function(geometry2, featureIndex, properties, bbox2, id) {
+    geomEach2(geojson, function(geometry2, featureIndex, properties, bbox, id) {
       var type = geometry2 === null ? null : geometry2.type;
       switch (type) {
         case null:
@@ -83856,7 +81844,7 @@ function requireCjs$e() {
         case "LineString":
         case "Polygon":
           if (callback(
-            _helpers.feature.call(void 0, geometry2, properties, { bbox: bbox2, id }),
+            _helpers.feature.call(void 0, geometry2, properties, { bbox, id }),
             featureIndex,
             0
           ) === false)
@@ -83904,7 +81892,7 @@ function requireCjs$e() {
     );
     return previousValue;
   }
-  function segmentEach2(geojson, callback) {
+  function segmentEach(geojson, callback) {
     flattenEach2(geojson, function(feature2, featureIndex, multiFeatureIndex) {
       var segmentIndex = 0;
       if (!feature2.geometry) return;
@@ -83914,7 +81902,7 @@ function requireCjs$e() {
       var previousFeatureIndex = 0;
       var previousMultiIndex = 0;
       var prevGeomIndex = 0;
-      if (coordEach2(
+      if (coordEach(
         feature2,
         function(currentCoord, coordIndex, featureIndexCoord, multiPartIndexCoord, geometryIndex) {
           if (previousCoords === void 0 || featureIndex > previousFeatureIndex || multiPartIndexCoord > previousMultiIndex || geometryIndex > prevGeomIndex) {
@@ -83948,7 +81936,7 @@ function requireCjs$e() {
   function segmentReduce(geojson, callback, initialValue) {
     var previousValue = initialValue;
     var started = false;
-    segmentEach2(
+    segmentEach(
       geojson,
       function(currentSegment, featureIndex, multiFeatureIndex, geometryIndex, segmentIndex) {
         if (started === false && initialValue === void 0)
@@ -84175,9 +82163,9 @@ function requireCjs$e() {
     throw new Error("geojson is invalid");
   }
   cjs$d.coordAll = coordAll;
-  cjs$d.coordEach = coordEach2;
+  cjs$d.coordEach = coordEach;
   cjs$d.coordReduce = coordReduce;
-  cjs$d.featureEach = featureEach2;
+  cjs$d.featureEach = featureEach;
   cjs$d.featureReduce = featureReduce;
   cjs$d.findPoint = findPoint;
   cjs$d.findSegment = findSegment;
@@ -84189,7 +82177,7 @@ function requireCjs$e() {
   cjs$d.lineReduce = lineReduce;
   cjs$d.propEach = propEach;
   cjs$d.propReduce = propReduce;
-  cjs$d.segmentEach = segmentEach2;
+  cjs$d.segmentEach = segmentEach;
   cjs$d.segmentReduce = segmentReduce;
   return cjs$d;
 }
@@ -84199,7 +82187,7 @@ function requireCjs$d() {
   hasRequiredCjs$d = 1;
   Object.defineProperty(cjs$e, "__esModule", { value: true });
   var _meta = /* @__PURE__ */ requireCjs$e();
-  function bbox2(geojson, options = {}) {
+  function bbox(geojson, options = {}) {
     if (geojson.bbox != null && true !== options.recompute) {
       return geojson.bbox;
     }
@@ -84220,8 +82208,8 @@ function requireCjs$d() {
     });
     return result;
   }
-  var turf_bbox_default = bbox2;
-  cjs$e.bbox = bbox2;
+  var turf_bbox_default = bbox;
+  cjs$e.bbox = bbox;
   cjs$e.default = turf_bbox_default;
   return cjs$e;
 }
@@ -84305,7 +82293,7 @@ function requireJs$p() {
         case "Point":
           return point2(coordinates2).geometry;
         case "LineString":
-          return lineString2(coordinates2).geometry;
+          return lineString(coordinates2).geometry;
         case "Polygon":
           return polygon2(coordinates2).geometry;
         case "MultiPoint":
@@ -84382,7 +82370,7 @@ function requireJs$p() {
       }), options);
     }
     exports2.polygons = polygons2;
-    function lineString2(coordinates2, properties, options) {
+    function lineString(coordinates2, properties, options) {
       if (options === void 0) {
         options = {};
       }
@@ -84395,13 +82383,13 @@ function requireJs$p() {
       };
       return feature2(geom, properties, options);
     }
-    exports2.lineString = lineString2;
+    exports2.lineString = lineString;
     function lineStrings(coordinates2, properties, options) {
       if (options === void 0) {
         options = {};
       }
       return featureCollection2(coordinates2.map(function(coords) {
-        return lineString2(coords, properties);
+        return lineString(coords, properties);
       }), options);
     }
     exports2.lineStrings = lineStrings;
@@ -84498,7 +82486,7 @@ function requireJs$p() {
     }
     exports2.lengthToRadians = lengthToRadians;
     function lengthToDegrees(distance2, units) {
-      return radiansToDegrees2(lengthToRadians(distance2, units));
+      return radiansToDegrees(lengthToRadians(distance2, units));
     }
     exports2.lengthToDegrees = lengthToDegrees;
     function bearingToAzimuth(bearing) {
@@ -84509,11 +82497,11 @@ function requireJs$p() {
       return angle2;
     }
     exports2.bearingToAzimuth = bearingToAzimuth;
-    function radiansToDegrees2(radians2) {
+    function radiansToDegrees(radians2) {
       var degrees2 = radians2 % (2 * Math.PI);
       return degrees2 * 180 / Math.PI;
     }
-    exports2.radiansToDegrees = radiansToDegrees2;
+    exports2.radiansToDegrees = radiansToDegrees;
     function degreesToRadians2(degrees2) {
       var radians2 = degrees2 % 360;
       return radians2 * Math.PI / 180;
@@ -84561,17 +82549,17 @@ function requireJs$p() {
       return !!input && input.constructor === Object;
     }
     exports2.isObject = isObject2;
-    function validateBBox(bbox2) {
-      if (!bbox2) {
+    function validateBBox(bbox) {
+      if (!bbox) {
         throw new Error("bbox is required");
       }
-      if (!Array.isArray(bbox2)) {
+      if (!Array.isArray(bbox)) {
         throw new Error("bbox must be an Array");
       }
-      if (bbox2.length !== 4 && bbox2.length !== 6) {
+      if (bbox.length !== 4 && bbox.length !== 6) {
         throw new Error("bbox must be an Array of 4 or 6 numbers");
       }
-      bbox2.forEach(function(num) {
+      bbox.forEach(function(num) {
         if (!isNumber2(num)) {
           throw new Error("bbox must only contain numbers");
         }
@@ -84596,22 +82584,22 @@ function requireJs$o() {
   hasRequiredJs$o = 1;
   Object.defineProperty(js$p, "__esModule", { value: true });
   var helpers_1 = /* @__PURE__ */ requireJs$p();
-  function bboxPolygon(bbox2, options) {
+  function bboxPolygon(bbox, options) {
     if (options === void 0) {
       options = {};
     }
-    var west = Number(bbox2[0]);
-    var south = Number(bbox2[1]);
-    var east = Number(bbox2[2]);
-    var north = Number(bbox2[3]);
-    if (bbox2.length === 6) {
+    var west = Number(bbox[0]);
+    var south = Number(bbox[1]);
+    var east = Number(bbox[2]);
+    var north = Number(bbox[3]);
+    if (bbox.length === 6) {
       throw new Error("@turf/bbox-polygon does not support BBox with 6 positions");
     }
     var lowLeft = [west, south];
     var topLeft = [west, north];
     var topRight = [east, north];
     var lowRight = [east, south];
-    return helpers_1.polygon([[lowLeft, lowRight, topRight, topLeft, lowLeft]], options.properties, { bbox: bbox2, id: options.id });
+    return helpers_1.polygon([[lowLeft, lowRight, topRight, topLeft, lowLeft]], options.properties, { bbox, id: options.id });
   }
   js$p.default = bboxPolygon;
   return js$p;
@@ -84626,7 +82614,7 @@ function requireJs$n() {
   hasRequiredJs$n = 1;
   Object.defineProperty(js$k, "__esModule", { value: true });
   var helpers = /* @__PURE__ */ requireJs$p();
-  function coordEach2(geojson, callback, excludeWrapCoord) {
+  function coordEach(geojson, callback, excludeWrapCoord) {
     if (geojson === null) return;
     var j, k, l2, geometry2, stopG, coords, geometryMaybeCollection, wrapShrink = 0, coordIndex = 0, isGeometryCollection, type = geojson.type, isFeatureCollection = type === "FeatureCollection", isFeature = type === "Feature", stop = isFeatureCollection ? geojson.features.length : 1;
     for (var featureIndex = 0; featureIndex < stop; featureIndex++) {
@@ -84713,7 +82701,7 @@ function requireJs$n() {
             break;
           case "GeometryCollection":
             for (j = 0; j < geometry2.geometries.length; j++)
-              if (coordEach2(geometry2.geometries[j], callback, excludeWrapCoord) === false)
+              if (coordEach(geometry2.geometries[j], callback, excludeWrapCoord) === false)
                 return false;
             break;
           default:
@@ -84724,7 +82712,7 @@ function requireJs$n() {
   }
   function coordReduce(geojson, callback, initialValue, excludeWrapCoord) {
     var previousValue = initialValue;
-    coordEach2(
+    coordEach(
       geojson,
       function(currentCoord, coordIndex, featureIndex, multiFeatureIndex, geometryIndex) {
         if (coordIndex === 0 && initialValue === void 0)
@@ -84766,7 +82754,7 @@ function requireJs$n() {
     });
     return previousValue;
   }
-  function featureEach2(geojson, callback) {
+  function featureEach(geojson, callback) {
     if (geojson.type === "Feature") {
       callback(geojson, 0);
     } else if (geojson.type === "FeatureCollection") {
@@ -84777,7 +82765,7 @@ function requireJs$n() {
   }
   function featureReduce(geojson, callback, initialValue) {
     var previousValue = initialValue;
-    featureEach2(geojson, function(currentFeature, featureIndex) {
+    featureEach(geojson, function(currentFeature, featureIndex) {
       if (featureIndex === 0 && initialValue === void 0)
         previousValue = currentFeature;
       else previousValue = callback(previousValue, currentFeature, featureIndex);
@@ -84786,7 +82774,7 @@ function requireJs$n() {
   }
   function coordAll(geojson) {
     var coords = [];
-    coordEach2(geojson, function(coord) {
+    coordEach(geojson, function(coord) {
       coords.push(coord);
     });
     return coords;
@@ -84871,7 +82859,7 @@ function requireJs$n() {
     return previousValue;
   }
   function flattenEach2(geojson, callback) {
-    geomEach2(geojson, function(geometry2, featureIndex, properties, bbox2, id) {
+    geomEach2(geojson, function(geometry2, featureIndex, properties, bbox, id) {
       var type = geometry2 === null ? null : geometry2.type;
       switch (type) {
         case null:
@@ -84879,7 +82867,7 @@ function requireJs$n() {
         case "LineString":
         case "Polygon":
           if (callback(
-            helpers.feature(geometry2, properties, { bbox: bbox2, id }),
+            helpers.feature(geometry2, properties, { bbox, id }),
             featureIndex,
             0
           ) === false)
@@ -84927,7 +82915,7 @@ function requireJs$n() {
     );
     return previousValue;
   }
-  function segmentEach2(geojson, callback) {
+  function segmentEach(geojson, callback) {
     flattenEach2(geojson, function(feature2, featureIndex, multiFeatureIndex) {
       var segmentIndex = 0;
       if (!feature2.geometry) return;
@@ -84937,7 +82925,7 @@ function requireJs$n() {
       var previousFeatureIndex = 0;
       var previousMultiIndex = 0;
       var prevGeomIndex = 0;
-      if (coordEach2(
+      if (coordEach(
         feature2,
         function(currentCoord, coordIndex, featureIndexCoord, multiPartIndexCoord, geometryIndex) {
           if (previousCoords === void 0 || featureIndex > previousFeatureIndex || multiPartIndexCoord > previousMultiIndex || geometryIndex > prevGeomIndex) {
@@ -84970,7 +82958,7 @@ function requireJs$n() {
   function segmentReduce(geojson, callback, initialValue) {
     var previousValue = initialValue;
     var started = false;
-    segmentEach2(
+    segmentEach(
       geojson,
       function(currentSegment, featureIndex, multiFeatureIndex, geometryIndex, segmentIndex) {
         if (started === false && initialValue === void 0)
@@ -85192,9 +83180,9 @@ function requireJs$n() {
     throw new Error("geojson is invalid");
   }
   js$k.coordAll = coordAll;
-  js$k.coordEach = coordEach2;
+  js$k.coordEach = coordEach;
   js$k.coordReduce = coordReduce;
-  js$k.featureEach = featureEach2;
+  js$k.featureEach = featureEach;
   js$k.featureReduce = featureReduce;
   js$k.findPoint = findPoint;
   js$k.findSegment = findSegment;
@@ -85206,7 +83194,7 @@ function requireJs$n() {
   js$k.lineReduce = lineReduce;
   js$k.propEach = propEach;
   js$k.propReduce = propReduce;
-  js$k.segmentEach = segmentEach2;
+  js$k.segmentEach = segmentEach;
   js$k.segmentReduce = segmentReduce;
   return js$k;
 }
@@ -85216,7 +83204,7 @@ function requireJs$m() {
   hasRequiredJs$m = 1;
   Object.defineProperty(js$l, "__esModule", { value: true });
   var meta_1 = /* @__PURE__ */ requireJs$n();
-  function bbox2(geojson) {
+  function bbox(geojson) {
     var result = [Infinity, Infinity, -Infinity, -Infinity];
     meta_1.coordEach(geojson, function(coord) {
       if (result[0] > coord[0]) {
@@ -85234,8 +83222,8 @@ function requireJs$m() {
     });
     return result;
   }
-  bbox2["default"] = bbox2;
-  js$l.default = bbox2;
+  bbox["default"] = bbox;
+  js$l.default = bbox;
   return js$l;
 }
 var hasRequiredJs$l;
@@ -95466,7 +93454,7 @@ function length$1(object2) {
   return +lengthSum$1;
 }
 var coordinates = [null, null], object = { type: "LineString", coordinates };
-function distance(a2, b) {
+function distance$1(a2, b) {
   coordinates[0] = a2;
   coordinates[1] = b;
   return length$1(object);
@@ -95519,10 +93507,10 @@ function containsGeometry(geometry2, point2) {
   return geometry2 && containsGeometryType.hasOwnProperty(geometry2.type) ? containsGeometryType[geometry2.type](geometry2, point2) : false;
 }
 function containsPoint(coordinates2, point2) {
-  return distance(coordinates2, point2) === 0;
+  return distance$1(coordinates2, point2) === 0;
 }
 function containsLine(coordinates2, point2) {
-  var ab = distance(coordinates2[0], coordinates2[1]), ao = distance(coordinates2[0], point2), ob = distance(point2, coordinates2[1]);
+  var ab = distance$1(coordinates2[0], coordinates2[1]), ao = distance$1(coordinates2[0], point2), ob = distance$1(point2, coordinates2[1]);
   return ao + ob <= ab + epsilon;
 }
 function containsPolygon(coordinates2, point2) {
@@ -96739,7 +94727,7 @@ const d3Geo = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePropert
   geoConicEquidistant: conicEquidistant,
   geoConicEquidistantRaw: conicEquidistantRaw,
   geoContains: contains,
-  geoDistance: distance,
+  geoDistance: distance$1,
   geoEquirectangular: equirectangular,
   geoEquirectangularRaw: equirectangularRaw,
   geoGnomonic: gnomonic,
@@ -97439,8 +95427,8 @@ function requirePolygonClipping_umd() {
         sort(keys2, values, left, j, compare2);
         sort(keys2, values, j + 1, right, compare2);
       }
-      var isInBbox2 = function isInBbox3(bbox2, point2) {
-        return bbox2.ll.x <= point2.x && point2.x <= bbox2.ur.x && bbox2.ll.y <= point2.y && point2.y <= bbox2.ur.y;
+      var isInBbox2 = function isInBbox3(bbox, point2) {
+        return bbox.ll.x <= point2.x && point2.x <= bbox.ur.x && bbox.ll.y <= point2.y && point2.y <= bbox.ur.y;
       };
       var getBboxOverlap2 = function getBboxOverlap3(b1, b2) {
         if (b2.ur.x < b1.ll.x || b1.ur.x < b2.ll.x || b2.ur.y < b1.ll.y || b1.ur.y < b2.ll.y) return null;
@@ -97820,7 +95808,7 @@ function requirePolygonClipping_umd() {
           }
         }, {
           key: "bbox",
-          value: function bbox2() {
+          value: function bbox() {
             var y12 = this.leftSE.point.y;
             var y2 = this.rightSE.point.y;
             return {
@@ -98757,7 +96745,7 @@ function requireJs$j() {
     throw new Error("coord must be GeoJSON Point or an Array of numbers");
   }
   js$i.getCoord = getCoord2;
-  function getCoords2(coords) {
+  function getCoords(coords) {
     if (Array.isArray(coords)) {
       return coords;
     }
@@ -98772,7 +96760,7 @@ function requireJs$j() {
     }
     throw new Error("coords must be GeoJSON Feature, Geometry Object or an Array");
   }
-  js$i.getCoords = getCoords2;
+  js$i.getCoords = getCoords;
   function containsNumber(coordinates2) {
     if (coordinates2.length > 1 && helpers_1.isNumber(coordinates2[0]) && helpers_1.isNumber(coordinates2[1])) {
       return true;
@@ -98902,7 +96890,7 @@ function requireCjs$c() {
     }
     throw new Error("coord must be GeoJSON Point or an Array of numbers");
   }
-  function getCoords2(coords) {
+  function getCoords(coords) {
     if (Array.isArray(coords)) {
       return coords;
     }
@@ -99004,7 +96992,7 @@ function requireCjs$c() {
   cjs$b.featureOf = featureOf;
   cjs$b.geojsonType = geojsonType;
   cjs$b.getCoord = getCoord2;
-  cjs$b.getCoords = getCoords2;
+  cjs$b.getCoords = getCoords;
   cjs$b.getGeom = getGeom2;
   cjs$b.getType = getType;
   return cjs$b;
@@ -99477,7 +97465,7 @@ function requireFeature() {
       }
       _createClass(Feature2, [{
         key: "getCoords",
-        value: function getCoords2() {
+        value: function getCoords() {
           return this.geoJson.geometry.coordinates;
         }
       }]);
@@ -101658,7 +99646,7 @@ function requireCjs$a() {
   var __defProp2 = Object.defineProperty;
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __getOwnPropNames = Object.getOwnPropertyNames;
-  var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
   var __export = (target, all) => {
     for (var name2 in all)
       __defProp2(target, name2, { get: all[name2], enumerable: true });
@@ -101666,7 +99654,7 @@ function requireCjs$a() {
   var __copyProps = (to, from, except, desc) => {
     if (from && typeof from === "object" || typeof from === "function") {
       for (let key of __getOwnPropNames(from))
-        if (!__hasOwnProp2.call(to, key) && key !== except)
+        if (!__hasOwnProp.call(to, key) && key !== except)
           __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
     }
     return to;
@@ -102372,7 +100360,7 @@ function requireCjs$9() {
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __getProtoOf = Object.getPrototypeOf;
-  var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
   var __export = (target, all) => {
     for (var name2 in all)
       __defProp2(target, name2, { get: all[name2], enumerable: true });
@@ -102380,7 +100368,7 @@ function requireCjs$9() {
   var __copyProps = (to, from, except, desc) => {
     if (from && typeof from === "object" || typeof from === "function") {
       for (let key of __getOwnPropNames(from))
-        if (!__hasOwnProp2.call(to, key) && key !== except)
+        if (!__hasOwnProp.call(to, key) && key !== except)
           __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
     }
     return to;
@@ -102462,8 +100450,8 @@ function requireCjs$9() {
     };
   };
   var precision2 = set2();
-  var isInBbox2 = (bbox2, point2) => {
-    return bbox2.ll.x.isLessThanOrEqualTo(point2.x) && point2.x.isLessThanOrEqualTo(bbox2.ur.x) && bbox2.ll.y.isLessThanOrEqualTo(point2.y) && point2.y.isLessThanOrEqualTo(bbox2.ur.y);
+  var isInBbox2 = (bbox, point2) => {
+    return bbox.ll.x.isLessThanOrEqualTo(point2.x) && point2.x.isLessThanOrEqualTo(bbox.ur.x) && bbox.ll.y.isLessThanOrEqualTo(point2.y) && point2.y.isLessThanOrEqualTo(bbox.ur.y);
   };
   var getBboxOverlap2 = (b1, b2) => {
     if (b2.ur.x.isLessThan(b1.ll.x) || b1.ur.x.isLessThan(b2.ll.x) || b2.ur.y.isLessThan(b1.ll.y) || b1.ur.y.isLessThan(b2.ll.y))
@@ -104038,7 +102026,7 @@ function requireUtils$2() {
   utils$2.distance2d = distance2d;
   utils$2.mix = mix;
   utils$2.nearestPointOnProjectedLine = nearestPointOnProjectedLine;
-  utils$2.nearestPointOnLine = nearestPointOnLine2;
+  utils$2.nearestPointOnLine = nearestPointOnLine;
   utils$2.getPickedEditHandle = getPickedEditHandle;
   utils$2.getPickedSnapSourceEditHandle = getPickedSnapSourceEditHandle;
   utils$2.getNonGuidePicks = getNonGuidePicks;
@@ -104135,12 +102123,12 @@ function requireUtils$2() {
     return false;
   }
   function generatePointsParallelToLinePoints(p1, p2, mapCoords) {
-    var lineString2 = {
+    var lineString = {
       type: "LineString",
       coordinates: [p1, p2]
     };
     var pt = (0, _helpers.point)(mapCoords);
-    var ddistance = (0, _pointToLineDistance["default"])(pt, lineString2);
+    var ddistance = (0, _pointToLineDistance["default"])(pt, lineString);
     var lineBearing = (0, _bearing["default"])(p1, p2);
     var isPointToLeftOfLine = (mapCoords[0] - p1[0]) * (p2[1] - p1[1]) - (mapCoords[1] - p1[1]) * (p2[0] - p1[0]);
     var orthogonalBearing = isPointToLeftOfLine < 0 ? lineBearing - 90 : lineBearing - 270;
@@ -104206,7 +102194,7 @@ function requireUtils$2() {
       }
     };
   }
-  function nearestPointOnLine2(lines, inPoint, viewport) {
+  function nearestPointOnLine(lines, inPoint, viewport) {
     var _lines$geometry, _lines$geometry2;
     var mercator2;
     if (viewport) {
@@ -104726,8 +102714,8 @@ function requireImmutableFeatureCollection() {
   }
   function pruneMultiLineStringIfNecessary(geometry2) {
     for (var lineStringIndex = 0; lineStringIndex < geometry2.coordinates.length; lineStringIndex++) {
-      var lineString2 = geometry2.coordinates[lineStringIndex];
-      if (lineString2.length === 1) {
+      var lineString = geometry2.coordinates[lineStringIndex];
+      if (lineString.length === 1) {
         geometry2.coordinates.splice(lineStringIndex, 1);
         lineStringIndex--;
       }
@@ -105316,8 +103304,8 @@ function requireModifyMode() {
             var intermediatePoint = null;
             var positionIndexPrefix = [];
             var referencePoint = (0, _helpers.point)(mapCoords);
-            (0, _utils.recursivelyTraverseNestedArrays)(featureAsPick.object.geometry.coordinates, [], function(lineString2, prefix) {
-              var lineStringFeature = (0, _helpers.lineString)(lineString2);
+            (0, _utils.recursivelyTraverseNestedArrays)(featureAsPick.object.geometry.coordinates, [], function(lineString, prefix) {
+              var lineStringFeature = (0, _helpers.lineString)(lineString);
               var candidateIntermediatePoint = _this.getNearestPoint(
                 // @ts-ignore
                 lineStringFeature,
@@ -105493,29 +103481,29 @@ function requireCjs$6() {
   hasRequiredCjs$6 = 1;
   Object.defineProperty(cjs$6, "__esModule", { value: true });
   var __defProp2 = Object.defineProperty;
-  var __defProps2 = Object.defineProperties;
-  var __getOwnPropDescs2 = Object.getOwnPropertyDescriptors;
-  var __getOwnPropSymbols2 = Object.getOwnPropertySymbols;
-  var __hasOwnProp2 = Object.prototype.hasOwnProperty;
-  var __propIsEnum2 = Object.prototype.propertyIsEnumerable;
+  var __defProps = Object.defineProperties;
+  var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+  var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __propIsEnum = Object.prototype.propertyIsEnumerable;
   var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __spreadValues2 = (a2, b) => {
+  var __spreadValues = (a2, b) => {
     for (var prop in b || (b = {}))
-      if (__hasOwnProp2.call(b, prop))
+      if (__hasOwnProp.call(b, prop))
         __defNormalProp2(a2, prop, b[prop]);
-    if (__getOwnPropSymbols2)
-      for (var prop of __getOwnPropSymbols2(b)) {
-        if (__propIsEnum2.call(b, prop))
+    if (__getOwnPropSymbols)
+      for (var prop of __getOwnPropSymbols(b)) {
+        if (__propIsEnum.call(b, prop))
           __defNormalProp2(a2, prop, b[prop]);
       }
     return a2;
   };
-  var __spreadProps2 = (a2, b) => __defProps2(a2, __getOwnPropDescs2(b));
+  var __spreadProps = (a2, b) => __defProps(a2, __getOwnPropDescs(b));
   var _distance = /* @__PURE__ */ requireCjs$b();
   var _meta = /* @__PURE__ */ requireCjs$e();
   var _helpers = /* @__PURE__ */ requireCjs$f();
   var _invariant = /* @__PURE__ */ requireCjs$c();
-  function nearestPointOnLine2(lines, pt, options = {}) {
+  function nearestPointOnLine(lines, pt, options = {}) {
     if (!lines || !pt) {
       throw new Error("lines and pt are required arguments");
     }
@@ -105547,7 +103535,7 @@ function requireCjs$6() {
           } else if (stopPos[0] === ptPos[0] && stopPos[1] === ptPos[1]) {
             [intersectPos, , wasEnd] = [stopPos, void 0, true];
           } else {
-            [intersectPos, , wasEnd] = nearestPointOnSegment2(
+            [intersectPos, , wasEnd] = nearestPointOnSegment(
               start.geometry.coordinates,
               stop.geometry.coordinates,
               _invariant.getCoord.call(void 0, pt)
@@ -105562,8 +103550,8 @@ function requireCjs$6() {
             });
           }
           if (intersectPt && intersectPt.properties.dist < closestPt.properties.dist) {
-            closestPt = __spreadProps2(__spreadValues2({}, intersectPt), {
-              properties: __spreadProps2(__spreadValues2({}, intersectPt.properties), {
+            closestPt = __spreadProps(__spreadValues({}, intersectPt), {
+              properties: __spreadProps(__spreadValues({}, intersectPt.properties), {
                 // Legacy behaviour where index progresses to next segment # if we
                 // went with the end point this iteration.
                 index: wasEnd ? i2 + 1 : i2
@@ -105586,14 +103574,14 @@ function requireCjs$6() {
     const [v2x, v2y, v2z] = v2;
     return [v1y * v2z - v1z * v2y, v1z * v2x - v1x * v2z, v1x * v2y - v1y * v2x];
   }
-  function magnitude2(v) {
+  function magnitude(v) {
     return Math.sqrt(Math.pow(v[0], 2) + Math.pow(v[1], 2) + Math.pow(v[2], 2));
   }
   function angle2(v12, v2) {
-    const theta = dot2(v12, v2) / (magnitude2(v12) * magnitude2(v2));
+    const theta = dot2(v12, v2) / (magnitude(v12) * magnitude(v2));
     return Math.acos(Math.min(Math.max(theta, -1), 1));
   }
-  function lngLatToVector2(a2) {
+  function lngLatToVector(a2) {
     const lat = _helpers.degreesToRadians.call(void 0, a2[1]);
     const lng = _helpers.degreesToRadians.call(void 0, a2[0]);
     return [
@@ -105602,16 +103590,16 @@ function requireCjs$6() {
       Math.sin(lat)
     ];
   }
-  function vectorToLngLat2(v) {
+  function vectorToLngLat(v) {
     const [x, y, z] = v;
     const lat = _helpers.radiansToDegrees.call(void 0, Math.asin(z));
     const lng = _helpers.radiansToDegrees.call(void 0, Math.atan2(y, x));
     return [lng, lat];
   }
-  function nearestPointOnSegment2(posA, posB, posC) {
-    const A2 = lngLatToVector2(posA);
-    const B2 = lngLatToVector2(posB);
-    const C3 = lngLatToVector2(posC);
+  function nearestPointOnSegment(posA, posB, posC) {
+    const A2 = lngLatToVector(posA);
+    const B2 = lngLatToVector(posB);
+    const C3 = lngLatToVector(posC);
     const [Cx, Cy, Cz] = C3;
     const [D2, E2, F] = cross2(A2, B2);
     const a2 = E2 * Cz - F * Cy;
@@ -105635,17 +103623,17 @@ function requireCjs$6() {
       I3 = I2;
     }
     if (angle2(A2, I3) > angleAB || angle2(B2, I3) > angleAB) {
-      if (_distance.distance.call(void 0, vectorToLngLat2(I3), vectorToLngLat2(A2)) <= _distance.distance.call(void 0, vectorToLngLat2(I3), vectorToLngLat2(B2))) {
-        return [vectorToLngLat2(A2), true, false];
+      if (_distance.distance.call(void 0, vectorToLngLat(I3), vectorToLngLat(A2)) <= _distance.distance.call(void 0, vectorToLngLat(I3), vectorToLngLat(B2))) {
+        return [vectorToLngLat(A2), true, false];
       } else {
-        return [vectorToLngLat2(B2), false, true];
+        return [vectorToLngLat(B2), false, true];
       }
     }
-    return [vectorToLngLat2(I3), false, false];
+    return [vectorToLngLat(I3), false, false];
   }
-  var turf_nearest_point_on_line_default = nearestPointOnLine2;
+  var turf_nearest_point_on_line_default = nearestPointOnLine;
   cjs$6.default = turf_nearest_point_on_line_default;
-  cjs$6.nearestPointOnLine = nearestPointOnLine2;
+  cjs$6.nearestPointOnLine = nearestPointOnLine;
   return cjs$6;
 }
 var cjs$5 = {};
@@ -105845,8 +103833,8 @@ function requireResizeCircleMode() {
             var intermediatePoint = null;
             var positionIndexPrefix = [];
             var referencePoint = (0, _helpers.point)(mapCoords);
-            (0, _utils.recursivelyTraverseNestedArrays)(featureAsPick.object.geometry.coordinates, [], function(lineString2, prefix) {
-              var lineStringFeature = (0, _helpers.lineString)(lineString2);
+            (0, _utils.recursivelyTraverseNestedArrays)(featureAsPick.object.geometry.coordinates, [], function(lineString, prefix) {
+              var lineStringFeature = (0, _helpers.lineString)(lineString);
               var candidateIntermediatePoint = _this2.getNearestPoint(
                 // @ts-ignore
                 lineStringFeature,
@@ -106484,11 +104472,11 @@ function requireJs$4() {
     if (origin === void 0 || origin === null) origin = "centroid";
     if (Array.isArray(origin) || typeof origin === "object")
       return invariant.getCoord(origin);
-    var bbox2 = geojson.bbox ? geojson.bbox : turfBBox__default["default"](geojson);
-    var west = bbox2[0];
-    var south = bbox2[1];
-    var east = bbox2[2];
-    var north = bbox2[3];
+    var bbox = geojson.bbox ? geojson.bbox : turfBBox__default["default"](geojson);
+    var west = bbox[0];
+    var south = bbox[1];
+    var east = bbox[2];
+    var north = bbox[3];
     switch (origin) {
       case "sw":
       case "southwest":
@@ -107844,9 +105832,9 @@ function requireCjs$2() {
     const pt = _invariant.getCoord.call(void 0, point2);
     const geom = _invariant.getGeom.call(void 0, polygon2);
     const type = geom.type;
-    const bbox2 = polygon2.bbox;
+    const bbox = polygon2.bbox;
     let polys = geom.coordinates;
-    if (bbox2 && inBBox2(pt, bbox2) === false) {
+    if (bbox && inBBox2(pt, bbox) === false) {
       return false;
     }
     if (type === "Polygon") {
@@ -107860,8 +105848,8 @@ function requireCjs$2() {
     }
     return result;
   }
-  function inBBox2(pt, bbox2) {
-    return bbox2[0] <= pt[0] && bbox2[1] <= pt[1] && bbox2[2] >= pt[0] && bbox2[3] >= pt[1];
+  function inBBox2(pt, bbox) {
+    return bbox[0] <= pt[0] && bbox[1] <= pt[1] && bbox[2] >= pt[0] && bbox[3] >= pt[1];
   }
   var turf_boolean_point_in_polygon_default = booleanPointInPolygon2;
   cjs$3.booleanPointInPolygon = booleanPointInPolygon2;
@@ -107869,6 +105857,206 @@ function requireCjs$2() {
   return cjs$3;
 }
 var cjs$1 = {};
+class TinyQueue {
+  constructor(data = [], compare2 = defaultCompare$1) {
+    this.data = data;
+    this.length = this.data.length;
+    this.compare = compare2;
+    if (this.length > 0) {
+      for (let i2 = (this.length >> 1) - 1; i2 >= 0; i2--) this._down(i2);
+    }
+  }
+  push(item) {
+    this.data.push(item);
+    this.length++;
+    this._up(this.length - 1);
+  }
+  pop() {
+    if (this.length === 0) return void 0;
+    const top = this.data[0];
+    const bottom = this.data.pop();
+    this.length--;
+    if (this.length > 0) {
+      this.data[0] = bottom;
+      this._down(0);
+    }
+    return top;
+  }
+  peek() {
+    return this.data[0];
+  }
+  _up(pos) {
+    const { data, compare: compare2 } = this;
+    const item = data[pos];
+    while (pos > 0) {
+      const parent = pos - 1 >> 1;
+      const current = data[parent];
+      if (compare2(item, current) >= 0) break;
+      data[pos] = current;
+      pos = parent;
+    }
+    data[pos] = item;
+  }
+  _down(pos) {
+    const { data, compare: compare2 } = this;
+    const halfLength = this.length >> 1;
+    const item = data[pos];
+    while (pos < halfLength) {
+      let left = (pos << 1) + 1;
+      let best = data[left];
+      const right = left + 1;
+      if (right < this.length && compare2(data[right], best) < 0) {
+        left = right;
+        best = data[right];
+      }
+      if (compare2(best, item) >= 0) break;
+      data[pos] = best;
+      pos = left;
+    }
+    data[pos] = item;
+  }
+}
+function defaultCompare$1(a2, b) {
+  return a2 < b ? -1 : a2 > b ? 1 : 0;
+}
+function checkWhichEventIsLeft(e1, e2) {
+  if (e1.p.x > e2.p.x) return 1;
+  if (e1.p.x < e2.p.x) return -1;
+  if (e1.p.y !== e2.p.y) return e1.p.y > e2.p.y ? 1 : -1;
+  return 1;
+}
+function checkWhichSegmentHasRightEndpointFirst(seg1, seg2) {
+  if (seg1.rightSweepEvent.p.x > seg2.rightSweepEvent.p.x) return 1;
+  if (seg1.rightSweepEvent.p.x < seg2.rightSweepEvent.p.x) return -1;
+  if (seg1.rightSweepEvent.p.y !== seg2.rightSweepEvent.p.y) return seg1.rightSweepEvent.p.y < seg2.rightSweepEvent.p.y ? 1 : -1;
+  return 1;
+}
+class Event {
+  constructor(p, featureId2, ringId2, eventId2) {
+    this.p = {
+      x: p[0],
+      y: p[1]
+    };
+    this.featureId = featureId2;
+    this.ringId = ringId2;
+    this.eventId = eventId2;
+    this.otherEvent = null;
+    this.isLeftEndpoint = null;
+  }
+  isSamePoint(eventToCheck) {
+    return this.p.x === eventToCheck.p.x && this.p.y === eventToCheck.p.y;
+  }
+}
+function fillEventQueue(geojson, eventQueue) {
+  if (geojson.type === "FeatureCollection") {
+    const features = geojson.features;
+    for (let i2 = 0; i2 < features.length; i2++) {
+      processFeature(features[i2], eventQueue);
+    }
+  } else {
+    processFeature(geojson, eventQueue);
+  }
+}
+let featureId = 0;
+let ringId = 0;
+let eventId = 0;
+function processFeature(featureOrGeometry, eventQueue) {
+  const geom = featureOrGeometry.type === "Feature" ? featureOrGeometry.geometry : featureOrGeometry;
+  let coords = geom.coordinates;
+  if (geom.type === "Polygon" || geom.type === "MultiLineString") coords = [coords];
+  if (geom.type === "LineString") coords = [[coords]];
+  for (let i2 = 0; i2 < coords.length; i2++) {
+    for (let ii = 0; ii < coords[i2].length; ii++) {
+      let currentP = coords[i2][ii][0];
+      let nextP = null;
+      ringId = ringId + 1;
+      for (let iii = 0; iii < coords[i2][ii].length - 1; iii++) {
+        nextP = coords[i2][ii][iii + 1];
+        const e1 = new Event(currentP, featureId, ringId, eventId);
+        const e2 = new Event(nextP, featureId, ringId, eventId + 1);
+        e1.otherEvent = e2;
+        e2.otherEvent = e1;
+        if (checkWhichEventIsLeft(e1, e2) > 0) {
+          e2.isLeftEndpoint = true;
+          e1.isLeftEndpoint = false;
+        } else {
+          e1.isLeftEndpoint = true;
+          e2.isLeftEndpoint = false;
+        }
+        eventQueue.push(e1);
+        eventQueue.push(e2);
+        currentP = nextP;
+        eventId = eventId + 1;
+      }
+    }
+  }
+  featureId = featureId + 1;
+}
+let Segment$1 = class Segment {
+  constructor(event) {
+    this.leftSweepEvent = event;
+    this.rightSweepEvent = event.otherEvent;
+  }
+};
+function testSegmentIntersect(seg1, seg2) {
+  if (seg1 === null || seg2 === null) return false;
+  if (seg1.leftSweepEvent.ringId === seg2.leftSweepEvent.ringId && (seg1.rightSweepEvent.isSamePoint(seg2.leftSweepEvent) || seg1.rightSweepEvent.isSamePoint(seg2.leftSweepEvent) || seg1.rightSweepEvent.isSamePoint(seg2.rightSweepEvent) || seg1.leftSweepEvent.isSamePoint(seg2.leftSweepEvent) || seg1.leftSweepEvent.isSamePoint(seg2.rightSweepEvent))) return false;
+  const x12 = seg1.leftSweepEvent.p.x;
+  const y12 = seg1.leftSweepEvent.p.y;
+  const x2 = seg1.rightSweepEvent.p.x;
+  const y2 = seg1.rightSweepEvent.p.y;
+  const x3 = seg2.leftSweepEvent.p.x;
+  const y3 = seg2.leftSweepEvent.p.y;
+  const x4 = seg2.rightSweepEvent.p.x;
+  const y4 = seg2.rightSweepEvent.p.y;
+  const denom = (y4 - y3) * (x2 - x12) - (x4 - x3) * (y2 - y12);
+  const numeA = (x4 - x3) * (y12 - y3) - (y4 - y3) * (x12 - x3);
+  const numeB = (x2 - x12) * (y12 - y3) - (y2 - y12) * (x12 - x3);
+  if (denom === 0) {
+    if (numeA === 0 && numeB === 0) return false;
+    return false;
+  }
+  const uA = numeA / denom;
+  const uB = numeB / denom;
+  if (uA >= 0 && uA <= 1 && uB >= 0 && uB <= 1) {
+    const x = x12 + uA * (x2 - x12);
+    const y = y12 + uA * (y2 - y12);
+    return [x, y];
+  }
+  return false;
+}
+function runCheck(eventQueue, ignoreSelfIntersections) {
+  ignoreSelfIntersections = ignoreSelfIntersections ? ignoreSelfIntersections : false;
+  const intersectionPoints = [];
+  const outQueue = new TinyQueue([], checkWhichSegmentHasRightEndpointFirst);
+  while (eventQueue.length) {
+    const event = eventQueue.pop();
+    if (event.isLeftEndpoint) {
+      const segment = new Segment$1(event);
+      for (let i2 = 0; i2 < outQueue.data.length; i2++) {
+        const otherSeg = outQueue.data[i2];
+        if (ignoreSelfIntersections) {
+          if (otherSeg.leftSweepEvent.featureId === event.featureId) continue;
+        }
+        const intersection2 = testSegmentIntersect(segment, otherSeg);
+        if (intersection2 !== false) intersectionPoints.push(intersection2);
+      }
+      outQueue.push(segment);
+    } else if (event.isLeftEndpoint === false) {
+      outQueue.pop();
+    }
+  }
+  return intersectionPoints;
+}
+function sweeplineIntersections(geojson, ignoreSelfIntersections) {
+  const eventQueue = new TinyQueue([], checkWhichEventIsLeft);
+  fillEventQueue(geojson, eventQueue);
+  return runCheck(eventQueue, ignoreSelfIntersections);
+}
+const sweeplineIntersections_esm = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: sweeplineIntersections
+}, Symbol.toStringTag, { value: "Module" }));
 const require$$1$1 = /* @__PURE__ */ getAugmentedNamespace(sweeplineIntersections_esm);
 var hasRequiredCjs$1;
 function requireCjs$1() {
@@ -107882,7 +106070,7 @@ function requireCjs$1() {
   var _sweeplineintersections = require$$1$1;
   var _sweeplineintersections2 = _interopRequireDefault(_sweeplineintersections);
   var sweeplineIntersections2 = _sweeplineintersections2.default;
-  function lineIntersect2(line1, line2, options = {}) {
+  function lineIntersect(line1, line2, options = {}) {
     const { removeDuplicates = true, ignoreSelfIntersections = true } = options;
     let features = [];
     if (line1.type === "FeatureCollection")
@@ -107916,9 +106104,9 @@ function requireCjs$1() {
     }
     return _helpers.featureCollection.call(void 0, results.map((r2) => _helpers.point.call(void 0, r2)));
   }
-  var turf_line_intersect_default = lineIntersect2;
+  var turf_line_intersect_default = lineIntersect;
   cjs$1.default = turf_line_intersect_default;
-  cjs$1.lineIntersect = lineIntersect2;
+  cjs$1.lineIntersect = lineIntersect;
   return cjs$1;
 }
 var hasRequiredSplitPolygonMode;
@@ -111782,8 +109970,8 @@ function requireDraw90degreePolygonMode() {
           return;
         }
         if (clickSequence.length === 3 && tentativeFeature.geometry.type === "LineString") {
-          var lineString2 = tentativeFeature.geometry;
-          clickSequence[clickSequence.length - 1] = lineString2.coordinates[lineString2.coordinates.length - 1];
+          var lineString = tentativeFeature.geometry;
+          clickSequence[clickSequence.length - 1] = lineString.coordinates[lineString.coordinates.length - 1];
         } else if (clickSequence.length > 3 && tentativeFeature.geometry.type === "Polygon") {
           var polygon2 = tentativeFeature.geometry;
           clickSequence[clickSequence.length - 1] = polygon2.coordinates[0][polygon2.coordinates[0].length - 2];
@@ -117653,12 +115841,12 @@ function requireUtils$1() {
     return false;
   }
   function generatePointsParallelToLinePoints(p1, p2, groundCoords) {
-    var lineString2 = {
+    var lineString = {
       type: "LineString",
       coordinates: [p1, p2]
     };
     var pt = (0, _helpers.point)(groundCoords);
-    var ddistance = (0, _pointToLineDistance["default"])(pt, lineString2);
+    var ddistance = (0, _pointToLineDistance["default"])(pt, lineString);
     var lineBearing = (0, _bearing["default"])(p1, p2);
     var isPointToLeftOfLine = (groundCoords[0] - p1[0]) * (p2[1] - p1[1]) - (groundCoords[1] - p1[1]) * (p2[0] - p1[0]);
     var orthogonalBearing = isPointToLeftOfLine < 0 ? lineBearing - 90 : lineBearing - 270;
@@ -119326,31 +117514,35 @@ class SelectionLayer extends CompositeLayer {
     const { flipY, obsLayers } = this.props;
     const flippedCoordinates = flipY ? coordinates2.map((poly) => poly.map((p) => [p[0], -p[1]])) : coordinates2;
     const selectedPolygon = polygon(flippedCoordinates);
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    flippedCoordinates[0].forEach(([x, y]) => {
+      minX = Math.min(minX, x);
+      minY = Math.min(minY, y);
+      maxX = Math.max(maxX, x);
+      maxY = Math.max(maxY, y);
+    });
     obsLayers.forEach((obsLayer) => {
       const { getObsCoords, obsQuadTree, obsIndex, onSelect: layerOnSelect } = obsLayer;
-      const pickingInfos = [];
+      const pickingIds = [];
       obsQuadTree?.visit((node2, x02, y02, x12, y12) => {
-        const nodePoints = [[[x02, y02], [x12, y02], [x12, y12], [x02, y12], [x02, y02]]];
-        const nodePolygon = polygon(nodePoints);
-        const nodePolygonContainsSelectedPolygon = booleanContains(nodePolygon, selectedPolygon);
-        const nodePolygonWithinSelectedPolygon = booleanWithin(nodePolygon, selectedPolygon);
-        const nodePolygonOverlapsSelectedPolgyon = booleanOverlap(nodePolygon, selectedPolygon);
-        if (!nodePolygonContainsSelectedPolygon && !nodePolygonWithinSelectedPolygon && !nodePolygonOverlapsSelectedPolgyon) {
+        if (x02 > maxX || y02 > maxY || x12 < minX || y12 < minY) {
           return true;
         }
-        if (node2.data) {
+        if (!node2.length) {
           let current = node2;
           while (current) {
-            const pointCoords = [].slice.call(getObsCoords(current.data));
-            if (booleanPointInPolygon(point(pointCoords), selectedPolygon)) {
-              pickingInfos.push(current.data);
+            const [x, y] = getObsCoords(current.data);
+            if (booleanPointInPolygon([x, y], selectedPolygon)) {
+              pickingIds.push(obsIndex[current.data]);
             }
             current = current.next;
           }
         }
         return false;
       });
-      const pickingIds = pickingInfos.map((obsI) => obsIndex[obsI]);
       layerOnSelect(pickingIds);
     });
   }
@@ -120525,22 +118717,22 @@ function addDecoder(cases, importFn) {
   }
   cases.forEach((c) => registry$2.set(c, importFn));
 }
-addDecoder([void 0, 1], () => import("./raw-taMYakY-.js").then((m) => m.default));
-addDecoder(5, () => import("./lzw-D7u1eQSe.js").then((m) => m.default));
+addDecoder([void 0, 1], () => import("./raw-ByPggEEh.js").then((m) => m.default));
+addDecoder(5, () => import("./lzw-Dlr30Fct.js").then((m) => m.default));
 addDecoder(6, () => {
   throw new Error("old style JPEG compression is not supported.");
 });
-addDecoder(7, () => import("./jpeg-ISmJxKn1.js").then((m) => m.default));
-addDecoder([8, 32946], () => import("./deflate-CNjgm89Q.js").then((m) => m.default));
-addDecoder(32773, () => import("./packbits-D4yNoB9e.js").then((m) => m.default));
+addDecoder(7, () => import("./jpeg-CFLEL8IV.js").then((m) => m.default));
+addDecoder([8, 32946], () => import("./deflate-7a1deX0W.js").then((m) => m.default));
+addDecoder(32773, () => import("./packbits-C6ye2Wmf.js").then((m) => m.default));
 addDecoder(
   34887,
-  () => import("./lerc-Bx1iViC_.js").then(async (m) => {
+  () => import("./lerc-CT-nNr9A.js").then(async (m) => {
     await m.zstd.init();
     return m;
   }).then((m) => m.default)
 );
-addDecoder(50001, () => import("./webimage-DjvdutBx.js").then((m) => m.default));
+addDecoder(50001, () => import("./webimage-C8dSzGbX.js").then((m) => m.default));
 function decodeRowAcc(row, stride) {
   let length2 = row.length - stride;
   let offset = 0;
@@ -120708,6 +118900,50 @@ async function N(A2, I2) {
   if (0 === g2.length) throw Error("Failed to decode with LZW decoder.");
   return g2;
 }
+function quickselect(arr, k, left, right, compare2) {
+  quickselectStep(arr, k, left || 0, right || arr.length - 1, defaultCompare);
+}
+function quickselectStep(arr, k, left, right, compare2) {
+  while (right > left) {
+    if (right - left > 600) {
+      var n3 = right - left + 1;
+      var m = k - left + 1;
+      var z = Math.log(n3);
+      var s2 = 0.5 * Math.exp(2 * z / 3);
+      var sd = 0.5 * Math.sqrt(z * s2 * (n3 - s2) / n3) * (m - n3 / 2 < 0 ? -1 : 1);
+      var newLeft = Math.max(left, Math.floor(k - m * s2 / n3 + sd));
+      var newRight = Math.min(right, Math.floor(k + (n3 - m) * s2 / n3 + sd));
+      quickselectStep(arr, k, newLeft, newRight, compare2);
+    }
+    var t = arr[k];
+    var i2 = left;
+    var j = right;
+    swap(arr, left, k);
+    if (compare2(arr[right], t) > 0) swap(arr, left, right);
+    while (i2 < j) {
+      swap(arr, i2, j);
+      i2++;
+      j--;
+      while (compare2(arr[i2], t) < 0) i2++;
+      while (compare2(arr[j], t) > 0) j--;
+    }
+    if (compare2(arr[left], t) === 0) swap(arr, left, j);
+    else {
+      j++;
+      swap(arr, j, right);
+    }
+    if (j <= k) left = j + 1;
+    if (k <= j) right = j - 1;
+  }
+}
+function swap(arr, i2, j) {
+  var tmp = arr[i2];
+  arr[i2] = arr[j];
+  arr[j] = tmp;
+}
+function defaultCompare(a2, b) {
+  return a2 < b ? -1 : a2 > b ? 1 : 0;
+}
 var util;
 (function(util2) {
   util2.assertEqual = (val) => val;
@@ -132074,17 +130310,17 @@ function sizeToMeters(size2, unit2) {
   throw new Error("Received unknown unit");
 }
 function snapValue(value) {
-  let magnitude2 = 0;
+  let magnitude = 0;
   if (value < MIN_TARGET || value > MAX_TARGET) {
-    magnitude2 = Math.floor(Math.log10(value));
+    magnitude = Math.floor(Math.log10(value));
   }
   let snappedUnit = SI_PREFIXES.find(
-    (p) => p.exponent % 3 === 0 && p.exponent <= magnitude2
+    (p) => p.exponent % 3 === 0 && p.exponent <= magnitude
   );
   let adjustedValue = value / 10 ** snappedUnit.exponent;
   if (adjustedValue > 500 && adjustedValue <= 1e3) {
     snappedUnit = SI_PREFIXES.find(
-      (p) => p.exponent % 3 === 0 && p.exponent <= magnitude2 + 3
+      (p) => p.exponent % 3 === 0 && p.exponent <= magnitude + 3
     );
     adjustedValue = value / 10 ** snappedUnit.exponent;
   }
@@ -134636,6 +132872,139 @@ class BitmaskLayer2 extends XRLayer {
 }
 BitmaskLayer2.layerName = "BitmaskLayer";
 BitmaskLayer2.defaultProps = defaultProps$2;
+function geomEach(geojson, callback) {
+  var i2, j, g2, geometry2, stopG, geometryMaybeCollection, isGeometryCollection, featureProperties, featureBBox, featureId2, featureIndex = 0, isFeatureCollection = geojson.type === "FeatureCollection", isFeature = geojson.type === "Feature", stop = isFeatureCollection ? geojson.features.length : 1;
+  for (i2 = 0; i2 < stop; i2++) {
+    geometryMaybeCollection = isFeatureCollection ? geojson.features[i2].geometry : isFeature ? geojson.geometry : geojson;
+    featureProperties = isFeatureCollection ? geojson.features[i2].properties : isFeature ? geojson.properties : {};
+    featureBBox = isFeatureCollection ? geojson.features[i2].bbox : isFeature ? geojson.bbox : void 0;
+    featureId2 = isFeatureCollection ? geojson.features[i2].id : isFeature ? geojson.id : void 0;
+    isGeometryCollection = geometryMaybeCollection ? geometryMaybeCollection.type === "GeometryCollection" : false;
+    stopG = isGeometryCollection ? geometryMaybeCollection.geometries.length : 1;
+    for (g2 = 0; g2 < stopG; g2++) {
+      geometry2 = isGeometryCollection ? geometryMaybeCollection.geometries[g2] : geometryMaybeCollection;
+      if (geometry2 === null) {
+        if (callback(
+          null,
+          featureIndex,
+          featureProperties,
+          featureBBox,
+          featureId2
+        ) === false)
+          return false;
+        continue;
+      }
+      switch (geometry2.type) {
+        case "Point":
+        case "LineString":
+        case "MultiPoint":
+        case "Polygon":
+        case "MultiLineString":
+        case "MultiPolygon": {
+          if (callback(
+            geometry2,
+            featureIndex,
+            featureProperties,
+            featureBBox,
+            featureId2
+          ) === false)
+            return false;
+          break;
+        }
+        case "GeometryCollection": {
+          for (j = 0; j < geometry2.geometries.length; j++) {
+            if (callback(
+              geometry2.geometries[j],
+              featureIndex,
+              featureProperties,
+              featureBBox,
+              featureId2
+            ) === false)
+              return false;
+          }
+          break;
+        }
+        default:
+          throw new Error("Unknown Geometry Type");
+      }
+    }
+    featureIndex++;
+  }
+}
+function geomReduce(geojson, callback, initialValue) {
+  var previousValue = initialValue;
+  geomEach(
+    geojson,
+    function(currentGeometry, featureIndex, featureProperties, featureBBox, featureId2) {
+      previousValue = callback(
+        previousValue,
+        currentGeometry,
+        featureIndex,
+        featureProperties,
+        featureBBox,
+        featureId2
+      );
+    }
+  );
+  return previousValue;
+}
+function flattenEach(geojson, callback) {
+  geomEach(geojson, function(geometry2, featureIndex, properties, bbox, id) {
+    var type = geometry2 === null ? null : geometry2.type;
+    switch (type) {
+      case null:
+      case "Point":
+      case "LineString":
+      case "Polygon":
+        if (callback(
+          feature$1(geometry2, properties, { bbox, id }),
+          featureIndex,
+          0
+        ) === false)
+          return false;
+        return;
+    }
+    var geomType;
+    switch (type) {
+      case "MultiPoint":
+        geomType = "Point";
+        break;
+      case "MultiLineString":
+        geomType = "LineString";
+        break;
+      case "MultiPolygon":
+        geomType = "Polygon";
+        break;
+    }
+    for (var multiFeatureIndex = 0; multiFeatureIndex < geometry2.coordinates.length; multiFeatureIndex++) {
+      var coordinate = geometry2.coordinates[multiFeatureIndex];
+      var geom = {
+        type: geomType,
+        coordinates: coordinate
+      };
+      if (callback(feature$1(geom, properties), featureIndex, multiFeatureIndex) === false)
+        return false;
+    }
+  });
+}
+function flattenReduce(geojson, callback, initialValue) {
+  var previousValue = initialValue;
+  flattenEach(
+    geojson,
+    function(currentFeature, featureIndex, multiFeatureIndex) {
+      if (featureIndex === 0 && multiFeatureIndex === 0 && initialValue === void 0)
+        previousValue = currentFeature;
+      else
+        previousValue = callback(
+          previousValue,
+          currentFeature,
+          featureIndex,
+          multiFeatureIndex
+        );
+    }
+  );
+  return previousValue;
+}
 var isNumeric = /^-?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i, mathceil = Math.ceil, mathfloor = Math.floor, bignumberError = "[BigNumber Error] ", tooManyDigits = bignumberError + "Number primitive has more than 15 significant digits: ", BASE = 1e14, LOG_BASE = 14, MAX_SAFE_INTEGER = 9007199254740991, POWS_TEN = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13], SQRT_BASE = 1e7, MAX = 1e9;
 function clone(configObject) {
   var div2, convertBase2, parseNumeric, P2 = BigNumber2.prototype = { constructor: BigNumber2, toString: null, valueOf: null }, ONE = new BigNumber2(1), DECIMAL_PLACES = 20, ROUNDING_MODE = 4, TO_EXP_NEG = -7, TO_EXP_POS = 21, MIN_EXP = -1e7, MAX_EXP = 1e7, CRYPTO = false, MODULO_MODE = 1, POW_PRECISION = 0, FORMAT = {
@@ -136476,8 +134845,8 @@ var set = (eps) => {
   };
 };
 var precision = set();
-var isInBbox = (bbox2, point2) => {
-  return bbox2.ll.x.isLessThanOrEqualTo(point2.x) && point2.x.isLessThanOrEqualTo(bbox2.ur.x) && bbox2.ll.y.isLessThanOrEqualTo(point2.y) && point2.y.isLessThanOrEqualTo(bbox2.ur.y);
+var isInBbox = (bbox, point2) => {
+  return bbox.ll.x.isLessThanOrEqualTo(point2.x) && point2.x.isLessThanOrEqualTo(bbox.ur.x) && bbox.ll.y.isLessThanOrEqualTo(point2.y) && point2.y.isLessThanOrEqualTo(bbox.ur.y);
 };
 var getBboxOverlap = (b1, b2) => {
   if (b2.ur.x.isLessThan(b1.ll.x) || b1.ur.x.isLessThan(b2.ll.x) || b2.ur.y.isLessThan(b1.ll.y) || b1.ur.y.isLessThan(b2.ll.y))
@@ -137577,6 +135946,19 @@ function ringArea(coords) {
   }
   return total * FACTOR;
 }
+function distance(from, to, options = {}) {
+  var coordinates1 = getCoord(from);
+  var coordinates2 = getCoord(to);
+  var dLat = degreesToRadians(coordinates2[1] - coordinates1[1]);
+  var dLon = degreesToRadians(coordinates2[0] - coordinates1[0]);
+  var lat1 = degreesToRadians(coordinates1[1]);
+  var lat2 = degreesToRadians(coordinates2[1]);
+  var a2 = Math.pow(Math.sin(dLat / 2), 2) + Math.pow(Math.sin(dLon / 2), 2) * Math.cos(lat1) * Math.cos(lat2);
+  return radiansToLength(
+    2 * Math.atan2(Math.sqrt(a2), Math.sqrt(1 - a2)),
+    options.units
+  );
+}
 const DEFAULT_THRESHOLD = 1;
 const defaultProps$1 = {
   // for text
@@ -137673,7 +136055,7 @@ class ContourLayerWithText extends ContourLayer {
         const circlePoint = point(circleCoord);
         polygonVertices.forEach((polyCoord) => {
           const polyPoint = point(polyCoord);
-          const dist2 = distance$1(circlePoint, polyPoint);
+          const dist2 = distance(circlePoint, polyPoint);
           if (dist2 < minDist) {
             minDist = dist2;
             minCirclePoint = circleCoord;
@@ -138146,10 +136528,8 @@ function createAnnotationLayers(shapes = [], zoom = 0, selectedShapeUid = null,
         getLineColor: strokeColor,
         getLineWidth: strokeWidth,
         lineWidthUnits: "pixels",
-        ...dashArray ? {
-          extensions: [new PathStyleExtension({ dash: true })],
-          getDashArray: dashArray
-        } : {}
+        extensions: dashExt,
+        getDashArray: getDash
       }));
       if (shape.text && labelOpacity > 0) {
         layers.push(new TextLayer({
@@ -138184,8 +136564,8 @@ function createAnnotationLayers(shapes = [], zoom = 0, selectedShapeUid = null,
       layers.push(new PathLayer({
         ...base,
         id: `annotation-line-${uid2}-${i2}`,
-        extensions: [new PathStyleExtension({ dash: true })],
-        getDashArray: dashArray ?? [0, 0],
+        extensions: dashExt,
+        getDashArray: getDash,
         data: [{ path: [[srcX, srcY], [tgtX, tgtY]] }],
         getPath: (d) => d.path,
         getColor: strokeColor,
@@ -138333,10 +136713,8 @@ function createAnnotationLayers(shapes = [], zoom = 0, selectedShapeUid = null,
         getLineColor: strokeColor,
         getLineWidth: strokeWidth,
         lineWidthUnits: "pixels",
-        ...dashArray ? {
-          extensions: [new PathStyleExtension({ dash: true })],
-          getDashArray: dashArray
-        } : {}
+        extensions: dashExt,
+        getDashArray: getDash
       }));
       if (shape.text && labelOpacity > 0) {
         layers.push(new TextLayer({