@konfirm/geojson 1.0.1 → 2.0.0-beta.0

package/dist/main.global.js

@@ -21,13 +21,16 @@ var GeoJSON = (() => {
   var main_exports = {};
   __export(main_exports, {
     SimpleGeometryIterator: () => SimpleGeometryIterator,
+    cartesian: () => cartesian2,
     distance: () => distance,
+    haversine: () => haversine2,
     intersect: () => intersect,
     isFeature: () => isFeature,
     isFeatureCollection: () => isFeatureCollection,
     isGeoJSON: () => isGeoJSON,
     isGeometry: () => isGeometry,
     isGeometryCollection: () => isGeometryCollection,
+    isGeometryPrimitive: () => isGeometryPrimitive,
     isLineString: () => isLineString,
     isMultiLineString: () => isMultiLineString,
     isMultiPoint: () => isMultiPoint,
@@ -40,13 +43,16 @@ var GeoJSON = (() => {
     isStrictGeoJSON: () => isStrictGeoJSON,
     isStrictGeometry: () => isStrictGeometry,
     isStrictGeometryCollection: () => isStrictGeometryCollection,
+    isStrictGeometryPrimitive: () => isStrictGeometryPrimitive,
     isStrictLineString: () => isStrictLineString,
     isStrictMultiLineString: () => isStrictMultiLineString,
     isStrictMultiPoint: () => isStrictMultiPoint,
     isStrictMultiPolygon: () => isStrictMultiPolygon,
     isStrictPoint: () => isStrictPoint,
     isStrictPolygon: () => isStrictPolygon,
-    isStrictPosition: () => isStrictPosition
+    isStrictPosition: () => isStrictPosition,
+    karney: () => karney2,
+    vincenty: () => vincenty2
   });
 
   // node_modules/@konfirm/guard/dist/guard.es.js
@@ -157,9 +163,9 @@ var GeoJSON = (() => {
   function isNumberValue(value) {
     return isNumber(value) && Number.isFinite(value);
   }
-  function isNumberBetween(a, b = Infinity) {
-    const min = Math.min(a, b);
-    const max = Math.max(a, b);
+  function isNumberBetween(a2, b2 = Infinity) {
+    const min = Math.min(a2, b2);
+    const max = Math.max(a2, b2);
     return (value) => isNumberValue(value) && value >= min && value <= max;
   }
 
@@ -204,11 +210,11 @@ var GeoJSON = (() => {
       isLatitude,
       isAltitude
     ),
-    ([, s, , , n]) => s <= n
+    ([, s, , , n2]) => s <= n2
   );
   var isBoundingBoxWithoutAltitude = all(
     isTuple(isLongitude, isLatitude, isLongitude, isLatitude),
-    ([, s, , n]) => s <= n
+    ([, s, , n2]) => s <= n2
   );
   var isBoundingBox = any(
     isBoundingBoxWithAltitude,
@@ -306,18 +312,18 @@ var GeoJSON = (() => {
   );
 
   // source/Domain/Utility/Winding.ts
-  function winding(positions2) {
-    return positions2.reduce((carry, [x, y], i, a) => {
-      const [nx, ny] = a[(i + 1) % a.length];
-      return carry + (nx - x) * (ny + y);
+  function shoelace(positions2) {
+    return positions2.reduce((carry, [x, y], i, a2) => {
+      const [nx, ny] = a2[(i + 1) % a2.length];
+      return carry + (x * ny - nx * y);
     }, 0);
   }
   var isPositionArray = isArrayOfType(isPosition);
   function isClockwiseWinding(value) {
-    return isPositionArray(value) && winding(value) <= 0;
+    return isPositionArray(value) && shoelace(value) <= 0;
   }
   function isCounterClockwiseWinding(value) {
-    return isPositionArray(value) && winding(value) >= 0;
+    return isPositionArray(value) && shoelace(value) >= 0;
   }
 
   // source/Domain/GeoJSON/Concept/LinearRing.ts
@@ -354,8 +360,8 @@ var GeoJSON = (() => {
   );
   var isStrictPolygonCoordinates = all(
     isArrayOfType(isStrictLinearRing),
-    (value) => isExteriorRing(value[0]),
-    (value) => value.slice(1).every(isInteriorRing)
+    (value) => isStrictExteriorRing(value[0]),
+    (value) => value.slice(1).every(isStrictInteriorRing)
   );
   var isStrictPolygon = isGeometryObject(
     "Polygon",
@@ -377,7 +383,7 @@ var GeoJSON = (() => {
   );
 
   // source/Domain/GeoJSON/Geometry.ts
-  var isGeometry = any(
+  var isGeometryPrimitive = any(
     isPoint,
     isMultiPoint,
     isLineString,
@@ -385,7 +391,7 @@ var GeoJSON = (() => {
     isPolygon,
     isMultiPolygon
   );
-  var isStrictGeometry = any(
+  var isStrictGeometryPrimitive = any(
     isStrictPoint,
     isStrictMultiPoint,
     isStrictLineString,
@@ -393,54 +399,68 @@ var GeoJSON = (() => {
     isStrictPolygon,
     isStrictMultiPolygon
   );
-
-  // source/Domain/GeoJSON/GeometryCollection.ts
+  var isGeometry = any(
+    isGeometryPrimitive,
+    isGeometryCollection
+  );
+  var isStrictGeometry = any(
+    isStrictGeometryPrimitive,
+    isStrictGeometryCollection
+  );
   var isGeometryCollectionObject = all(
     isGeoJSONObject("GeometryCollection"),
-    isKeyOfType(
-      "geometries",
-      isArrayOfType(any(isGeometry, isGeometryCollection))
-    )
+    isKeyOfType("geometries", isArrayOfType(isGeometry))
   );
   var isStrictGeometryCollectionObject = all(
     isGeoJSONObject("GeometryCollection"),
-    isKeyOfType(
-      "geometries",
-      isArrayOfType(any(isStrictGeometry, isStrictGeometryCollection))
-    )
+    isKeyOfType("geometries", isArrayOfType(isStrictGeometry))
   );
-  function isGeometryCollection(value) {
-    return isGeometryCollectionObject(value);
+  function isGeometryCollection(value, isG = isGeometryPrimitive) {
+    return isGeometryCollectionObject(value) && value.geometries.every((g) => isG(g) || isGeometryCollection(g, isG));
   }
-  function isStrictGeometryCollection(value) {
-    return isStrictGeometryCollectionObject(value);
+  function isStrictGeometryCollection(value, isG = isStrictGeometryPrimitive) {
+    return isStrictGeometryCollectionObject(value) && value.geometries.every(
+      (g) => isG(g) || isStrictGeometryCollection(g, isG)
+    );
   }
 
   // source/Domain/GeoJSON/Feature.ts
-  var isFeature = all(
+  var isFeatureObject = all(
     isGeoJSONObject("Feature"),
     isStructure({
-      geometry: any(isGeometry, isGeometryCollection),
+      geometry: any(isNULL, isGeometry),
       properties: any(isNULL, isObject)
     })
   );
-  var isStrictFeature = all(
+  var isStrictFeatureObject = all(
     isGeoJSONObject("Feature"),
     isStructure({
-      geometry: any(isStrictGeometry, isStrictGeometryCollection),
+      geometry: any(isNULL, isStrictGeometry),
       properties: any(isNULL, isObject)
     })
   );
+  function isFeature(input, isG = any(isNULL, isGeometry)) {
+    return isFeatureObject(input) && isG(input.geometry);
+  }
+  function isStrictFeature(input, isG = any(isNULL, isStrictGeometry)) {
+    return isStrictFeatureObject(input) && isG(input.geometry);
+  }
 
   // source/Domain/GeoJSON/FeatureCollection.ts
-  var isFeatureCollection = all(
+  var isFeatureCollectionObject = all(
     isGeoJSONObject("FeatureCollection"),
     isKeyOfType("features", isArrayOfType(isFeature))
   );
-  var isStrictFeatureCollection = all(
+  var isStrictFeatureCollectionObject = all(
     isGeoJSONObject("FeatureCollection"),
     isKeyOfType("features", isArrayOfType(isStrictFeature))
   );
+  function isFeatureCollection(value, isG = any(isNULL, isGeometry)) {
+    return isFeatureCollectionObject(value) && value.features.every((feature) => isFeature(feature, isG));
+  }
+  function isStrictFeatureCollection(value, isG = any(isNULL, isGeometry)) {
+    return isStrictFeatureCollectionObject(value) && value.features.every((feature) => isStrictFeature(feature, isG));
+  }
 
   // source/Domain/GeoJSON/GeoJSON.ts
   var isGeoJSON = any(
@@ -491,11 +511,15 @@ var GeoJSON = (() => {
       }
     },
     *Feature({ geometry }, unwrap) {
-      yield* unwrap(geometry);
+      if (geometry) {
+        yield* unwrap(geometry);
+      }
     },
     *FeatureCollection({ features }, unwrap) {
       for (const { geometry } of features) {
-        yield* unwrap(geometry);
+        if (geometry) {
+          yield* unwrap(geometry);
+        }
       }
     }
   };
@@ -551,9 +575,9 @@ var GeoJSON = (() => {
      * @memberof IterablePairIterator
      */
     *[Symbol.iterator]() {
-      for (const [a, b] of this.pairs(this.iterators)) {
-        for (const one of a) {
-          for (const two of b) {
+      for (const [a2, b2] of this.pairs(this.iterators)) {
+        for (const one of a2) {
+          for (const two of b2) {
             yield [one, two];
           }
         }
@@ -569,7 +593,7 @@ var GeoJSON = (() => {
      */
     pairs(source) {
       return source.flatMap(
-        (a, i) => source.slice(i + 1).map((b) => [a, b])
+        (a2, i) => source.slice(i + 1).map((b2) => [a2, b2])
       );
     }
   };
@@ -601,70 +625,605 @@ var GeoJSON = (() => {
     return lon >= minLon && lon <= maxLon && lat >= minLat && lat <= maxLat;
   }
 
-  // source/Domain/Utility/Calculate.ts
+  // source/Domain/Utility/Common.ts
+  function values(_, ...values2) {
+    return values2;
+  }
+
+  // source/Domain/Utility/Numeric.ts
+  function squared(n2) {
+    return n2 * n2;
+  }
+
+  // source/Domain/Utility/Geodesic.ts
+  var a = EARTH_RADIUS_MAJOR;
+  var f = 1 / EARTH_FLATTENING;
+  var f1 = 1 - f;
+  var n = f / (2 - f);
+  var b = a * f1;
+  var ep2 = f * (2 - f) / (f1 * f1);
   var D2R = Math.PI / 180;
+  var TINY = Number.EPSILON;
+  var TOL0 = Number.EPSILON;
+  var TOL1 = 200 * TOL0;
+  var TOL2 = Math.sqrt(TOL0);
+  var TOLB = TOL0 * TOL2;
+  var XTHRESH = 1e3 * TOL2;
+  var MAXIT1 = 20;
+  var MAXIT2 = MAXIT1 + 80;
+  var ETOL2 = 0.1 * TOL2 / Math.sqrt(Math.max(1e-3, Math.abs(f)) * Math.min(1, 1 - f / 2) / 2);
+  var ORDER = 6;
+  var A1M1_COEFF = [1, 4, 64, 0, 256];
+  var C1_COEFF = values`
+	${-1}     ${6}  ${-16}     ${32},
+	${-9}    ${64}  ${-128}  ${2048},
+	 ${9}   ${-16}  ${768}
+	 ${3}    ${-5}  ${512}
+	${-7}  ${1280}
+	${-7}  ${2048}
+`;
+  var A2M1_COEFF = [-11, -28, -192, 0, 256];
+  var C2_COEFF = values`
+	 ${1}     ${2}   ${16}    ${32}
+	${35}    ${64}  ${384}  ${2048}
+	${15}    ${80}  ${768}
+	 ${7}    ${35}  ${512}
+	${63}  ${1280}
+	${77}  ${2048}
+`;
+  var A3_COEFF = values`
+	${-3}  ${128}
+	${-2}   ${-3}  ${64}
+	${-1}   ${-3}  ${-1}  ${16}
+	 ${3}   ${-1}  ${-2}   ${8}
+	 ${1}   ${-1}   ${2}
+	 ${1}    ${1}
+`;
+  var C3_COEFF = values`
+	  ${3}   ${128}
+	  ${2}     ${5}  ${128}
+ 	 ${-1}     ${3}    ${3}   ${64}
+	 ${-1}     ${0}    ${1}    ${8}
+	 ${-1}     ${1}    ${4}
+	  ${5}   ${256}
+	  ${1}     ${3}  ${128}
+	 ${-3}    ${-2}    ${3}   ${64}
+	  ${1}    ${-3}    ${2}   ${32}
+	  ${7}   ${512}
+	${-10}     ${9}  ${384}
+	  ${5}    ${-9}    ${5}  ${192}
+	  ${7}   ${512}
+	${-14}     ${7}  ${512}
+	 ${21}  ${2560}
+`;
+  function hypot(x, y) {
+    return Math.sqrt(x * x + y * y);
+  }
+  function copysign(x, y) {
+    return Math.abs(x) * (y < 0 || y === 0 && 1 / y < 0 ? -1 : 1);
+  }
+  function polyval(N, p, s, x) {
+    let i = s;
+    let n2 = N;
+    let y = p[i++];
+    while (n2-- > 0) y = y * x + p[i++];
+    return y;
+  }
+  function angNormalize(x) {
+    const v = x % 360;
+    return v <= -180 ? v + 360 : v > 180 ? v - 360 : v;
+  }
+  function sinCosSeries(sinx, cosx, c) {
+    let k = c.length;
+    let cn = k - 1;
+    const ar = 2 * (cosx - sinx) * (cosx + sinx);
+    let y0 = cn & 1 ? c[--k] : 0;
+    let y1 = 0;
+    cn = Math.floor(cn / 2);
+    while (cn--) {
+      y1 = ar * y0 - y1 + c[--k];
+      y0 = ar * y1 - y0 + c[--k];
+    }
+    return 2 * sinx * cosx * y0;
+  }
+  function astroid(x, y) {
+    const p = squared(x);
+    const q = squared(y);
+    const r = (p + q - 1) / 6;
+    const S = p * q / 4;
+    const r2 = squared(r);
+    const r3 = r * r2;
+    const disc = S * (S + 2 * r3);
+    let u = r;
+    if (disc >= 0) {
+      let T3 = S + r3;
+      T3 += Math.sqrt(disc);
+      const T = Math.cbrt(T3);
+      u += T + r2 / T;
+    } else {
+      const ang = Math.atan2(Math.sqrt(-disc), -(S + r3));
+      u += 2 * r * Math.cos(ang / 3);
+    }
+    const v = Math.sqrt(squared(u) + q);
+    const uv = u < 0 ? q / (v - u) : u + v;
+    const w = (uv - q) / (2 * v);
+    return uv / (Math.sqrt(uv + squared(w)) + w);
+  }
+  function A1m1f(eps) {
+    const p = Math.floor(ORDER / 2);
+    const t = polyval(p, A1M1_COEFF, 0, squared(eps)) / A1M1_COEFF[p + 1];
+    return (t + eps) / (1 - eps);
+  }
+  function C1f(eps, c) {
+    const eps2 = squared(eps);
+    let d = eps;
+    let o = 0;
+    for (let l = 1; l <= ORDER; l++) {
+      const p = Math.floor((ORDER - l) / 2);
+      c[l] = d * polyval(p, C1_COEFF, o, eps2) / C1_COEFF[o + p + 1];
+      o += p + 2;
+      d *= eps;
+    }
+  }
+  function A2m1f(eps) {
+    const p = Math.floor(ORDER / 2);
+    const t = polyval(p, A2M1_COEFF, 0, squared(eps)) / A2M1_COEFF[p + 1];
+    return (t - eps) / (1 + eps);
+  }
+  function C2f(eps, c) {
+    const eps2 = squared(eps);
+    let d = eps;
+    let o = 0;
+    for (let l = 1; l <= ORDER; l++) {
+      const p = Math.floor((ORDER - l) / 2);
+      c[l] = d * polyval(p, C2_COEFF, o, eps2) / C2_COEFF[o + p + 1];
+      o += p + 2;
+      d *= eps;
+    }
+  }
+  function buildA3x() {
+    const ax = new Array(ORDER);
+    let o = 0;
+    let k = 0;
+    for (let j = ORDER - 1; j >= 0; j--) {
+      const p = Math.min(ORDER - j - 1, j);
+      ax[k++] = polyval(p, A3_COEFF, o, n) / A3_COEFF[o + p + 1];
+      o += p + 2;
+    }
+    return ax;
+  }
+  function buildC3x() {
+    const cx = [];
+    let o = 0;
+    for (let l = 1; l < ORDER; l++) {
+      for (let j = ORDER - 1; j >= l; j--) {
+        const p = Math.min(ORDER - j - 1, j);
+        cx.push(polyval(p, C3_COEFF, o, n) / C3_COEFF[o + p + 1]);
+        o += p + 2;
+      }
+    }
+    return cx;
+  }
+  var A3x = buildA3x();
+  var C3x = buildC3x();
+  function A3f(eps) {
+    return polyval(ORDER - 1, A3x, 0, eps);
+  }
+  function C3f(eps, c) {
+    let mult = 1;
+    let o = 0;
+    for (let l = 1; l < ORDER; l++) {
+      const p = ORDER - l - 1;
+      mult *= eps;
+      c[l] = mult * polyval(p, C3x, o, eps);
+      o += p + 1;
+    }
+  }
+  function geodesicLengths(eps, sig12, ssig1, csig1, dn1, ssig2, csig2, dn2, C1a, C2a) {
+    C1f(eps, C1a);
+    C2f(eps, C2a);
+    const a1 = A1m1f(eps);
+    const a2 = A2m1f(eps);
+    const m0x = a1 - a2;
+    const A1 = 1 + a1;
+    const A2 = 1 + a2;
+    const B1 = sinCosSeries(ssig2, csig2, C1a) - sinCosSeries(ssig1, csig1, C1a);
+    const B2 = sinCosSeries(ssig2, csig2, C2a) - sinCosSeries(ssig1, csig1, C2a);
+    const J12 = m0x * sig12 + (A1 * B1 - A2 * B2);
+    return {
+      s12b: A1 * (sig12 + B1),
+      m12b: dn2 * (csig1 * ssig2) - dn1 * (ssig1 * csig2) - csig1 * csig2 * J12
+    };
+  }
+  function Lambda12(sbet1, cbet1, dn1, sbet2, cbet2, dn2, salp1, calp1, slam12, clam12, _diffp, C1a, C2a, C3a) {
+    const salp0 = salp1 * cbet1;
+    const calp0 = hypot(calp1, salp1 * sbet1);
+    let ssig1 = sbet1;
+    const somg1 = salp0 * sbet1;
+    let csig1 = calp1 * cbet1;
+    const comg1 = csig1;
+    let t = hypot(ssig1, csig1);
+    ssig1 /= t;
+    csig1 /= t;
+    const salp2 = cbet2 !== cbet1 ? salp0 / cbet2 : salp1;
+    const calp2 = cbet2 !== cbet1 || Math.abs(sbet2) !== -sbet1 ? Math.sqrt(
+      squared(calp1 * cbet1) + (cbet1 < -sbet1 ? (cbet2 - cbet1) * (cbet1 + cbet2) : (sbet1 - sbet2) * (sbet1 + sbet2))
+    ) / cbet2 : Math.abs(calp1);
+    let ssig2 = sbet2;
+    const somg2 = salp0 * sbet2;
+    let csig2 = calp2 * cbet2;
+    const comg2 = csig2;
+    t = hypot(ssig2, csig2);
+    ssig2 /= t;
+    csig2 /= t;
+    const sig12 = Math.atan2(
+      Math.max(0, csig1 * ssig2 - ssig1 * csig2),
+      csig1 * csig2 + ssig1 * ssig2
+    );
+    const somg12 = Math.max(0, comg1 * somg2 - somg1 * comg2);
+    const comg12 = comg1 * comg2 + somg1 * somg2;
+    const eta = Math.atan2(
+      somg12 * clam12 - comg12 * slam12,
+      comg12 * clam12 + somg12 * slam12
+    );
+    const k2 = squared(calp0) * ep2;
+    const eps = k2 / (2 * (1 + Math.sqrt(1 + k2)) + k2);
+    C3f(eps, C3a);
+    const B312 = sinCosSeries(ssig2, csig2, C3a) - sinCosSeries(ssig1, csig1, C3a);
+    const domg12 = -f * A3f(eps) * salp0 * (sig12 + B312);
+    const lam12 = eta + domg12;
+    let dlam12;
+    if (calp2 === 0) {
+      dlam12 = -2 * f1 * dn1 / sbet1;
+    } else {
+      const nv = geodesicLengths(
+        eps,
+        sig12,
+        ssig1,
+        csig1,
+        dn1,
+        ssig2,
+        csig2,
+        dn2,
+        C1a,
+        C2a
+      );
+      dlam12 = nv.m12b * f1 / (calp2 * cbet2);
+    }
+    return {
+      lam12,
+      dlam12,
+      salp2,
+      calp2,
+      sig12,
+      ssig1,
+      csig1,
+      ssig2,
+      csig2,
+      eps
+    };
+  }
+  function inverseStart(sbet1, cbet1, _dn1, sbet2, cbet2, _dn2, lam12, slam12, clam12, _C1a, _C2a) {
+    const sbet12 = sbet2 * cbet1 - cbet2 * sbet1;
+    const cbet12 = cbet2 * cbet1 + sbet2 * sbet1;
+    const sbet12a = sbet2 * cbet1 + cbet2 * sbet1;
+    const shortline = cbet12 >= 0 && sbet12 < 0.5 && cbet2 * lam12 < 0.5;
+    let somg12;
+    let comg12;
+    let dnm = 1;
+    if (shortline) {
+      const sbetm2 = squared(sbet1 + sbet2) / (squared(sbet1 + sbet2) + squared(cbet1 + cbet2));
+      dnm = Math.sqrt(1 + ep2 * sbetm2);
+      const omg12 = lam12 / (f1 * dnm);
+      somg12 = Math.sin(omg12);
+      comg12 = Math.cos(omg12);
+    } else {
+      somg12 = slam12;
+      comg12 = clam12;
+    }
+    let salp1 = cbet2 * somg12;
+    let calp1 = comg12 >= 0 ? sbet12 + cbet2 * sbet1 * squared(somg12) / (1 + comg12) : sbet12a - cbet2 * sbet1 * squared(somg12) / (1 - comg12);
+    const ssig12 = hypot(salp1, calp1);
+    const csig12 = sbet1 * sbet2 + cbet1 * cbet2 * comg12;
+    let salp2 = 0;
+    let calp2 = 0;
+    let sig12 = -1;
+    if (shortline && ssig12 < ETOL2) {
+      salp2 = cbet1 * somg12;
+      calp2 = sbet12 - cbet1 * sbet2 * squared(somg12) / (1 + comg12);
+      const nt = hypot(salp2, calp2);
+      salp2 /= nt;
+      calp2 /= nt;
+      sig12 = Math.atan2(ssig12, csig12);
+    } else if (Math.abs(n) > 0.1 || csig12 >= 0 || ssig12 >= 6 * Math.abs(n) * Math.PI * squared(cbet1)) {
+    } else {
+      const lam12x = Math.atan2(-slam12, -clam12);
+      const k2 = squared(sbet1) * ep2;
+      const eps = k2 / (2 * (1 + Math.sqrt(1 + k2)) + k2);
+      const lamscale = f * cbet1 * A3f(eps) * Math.PI;
+      const betscale = lamscale * cbet1;
+      const x = lam12x / lamscale;
+      const y = sbet12a / betscale;
+      if (y > -TOL1 && x > -1 - XTHRESH) {
+        salp1 = Math.min(1, -x);
+        calp1 = -Math.sqrt(1 - squared(salp1));
+      } else {
+        const k = astroid(x, y);
+        const omg12a = lamscale * (-x * k / (1 + k));
+        somg12 = Math.sin(omg12a);
+        comg12 = -Math.cos(omg12a);
+        salp1 = cbet2 * somg12;
+        calp1 = sbet12a - cbet2 * sbet1 * squared(somg12) / (1 - comg12);
+      }
+    }
+    if (!(salp1 <= 0)) {
+      const nt = hypot(salp1, calp1);
+      salp1 /= nt;
+      calp1 /= nt;
+    } else {
+      salp1 = 1;
+      calp1 = 0;
+    }
+    return { sig12, salp1, calp1, salp2, calp2, dnm };
+  }
+  function inverseDistance(lat1, lon1, lat2, lon2) {
+    let \u03C61 = Math.max(-90, Math.min(90, lat1));
+    let \u03C62 = Math.max(-90, Math.min(90, lat2));
+    let lon12 = angNormalize(angNormalize(lon2) - angNormalize(lon1));
+    const lonsign = lon12 >= 0 ? 1 : -1;
+    lon12 = lonsign * lon12;
+    const slam12 = lon12 === 180 ? 0 : Math.sin(lon12 * D2R);
+    const clam12 = Math.cos(lon12 * D2R);
+    const swapp = Math.abs(\u03C61) >= Math.abs(\u03C62) ? 1 : -1;
+    if (swapp < 0) [\u03C62, \u03C61] = [\u03C61, \u03C62];
+    const latsign = \u03C61 <= 0 ? 1 : -1;
+    \u03C61 *= latsign;
+    \u03C62 *= latsign;
+    let sbet1 = f1 * Math.sin(\u03C61 * D2R);
+    let cbet1 = Math.cos(\u03C61 * D2R);
+    let t = hypot(sbet1, cbet1);
+    sbet1 /= t;
+    cbet1 /= t;
+    cbet1 = Math.max(TINY, cbet1);
+    let sbet2 = f1 * Math.sin(\u03C62 * D2R);
+    let cbet2 = Math.cos(\u03C62 * D2R);
+    t = hypot(sbet2, cbet2);
+    sbet2 /= t;
+    cbet2 /= t;
+    cbet2 = Math.max(TINY, cbet2);
+    if (cbet1 < -sbet1) {
+      if (cbet2 === cbet1) sbet2 = copysign(sbet1, sbet2);
+    } else {
+      if (Math.abs(sbet2) === -sbet1) cbet2 = cbet1;
+    }
+    const dn1 = Math.sqrt(1 + ep2 * squared(sbet1));
+    const dn2 = Math.sqrt(1 + ep2 * squared(sbet2));
+    const lam12 = lon12 * D2R;
+    const C1a = new Array(ORDER + 1);
+    const C2a = new Array(ORDER + 1);
+    const C3a = new Array(ORDER);
+    let s12b;
+    let calp1;
+    let salp1;
+    let calp2;
+    let ssig1;
+    let csig1;
+    let ssig2;
+    let csig2;
+    let eps;
+    const meridian = \u03C61 === -90 || slam12 === 0;
+    if (meridian) {
+      calp1 = clam12;
+      salp1 = slam12;
+      calp2 = 1;
+      ssig1 = sbet1;
+      csig1 = calp1 * cbet1;
+      ssig2 = sbet2;
+      csig2 = calp2 * cbet2;
+      const sig12m = Math.atan2(
+        Math.max(0, csig1 * ssig2 - ssig1 * csig2),
+        csig1 * csig2 + ssig1 * ssig2
+      );
+      eps = n;
+      const nv2 = geodesicLengths(
+        eps,
+        sig12m,
+        ssig1,
+        csig1,
+        dn1,
+        ssig2,
+        csig2,
+        dn2,
+        C1a,
+        C2a
+      );
+      s12b = nv2.s12b;
+      if (sig12m < 3 * TINY) {
+        s12b = 0;
+      }
+      return b * s12b;
+    }
+    if (sbet1 === 0 && (f <= 0 || 180 - lon12 >= f * 180)) {
+      return a * lam12;
+    }
+    const ns = inverseStart(
+      sbet1,
+      cbet1,
+      dn1,
+      sbet2,
+      cbet2,
+      dn2,
+      lam12,
+      slam12,
+      clam12,
+      C1a,
+      C2a
+    );
+    let sig12 = ns.sig12;
+    salp1 = ns.salp1;
+    calp1 = ns.calp1;
+    if (sig12 >= 0) {
+      calp2 = ns.calp2;
+      s12b = sig12 * b * ns.dnm;
+      return s12b;
+    }
+    calp2 = 0;
+    ssig1 = 0;
+    csig1 = 0;
+    ssig2 = 0;
+    csig2 = 0;
+    eps = 0;
+    let salp1a = TINY;
+    let calp1a = 1;
+    let salp1b = TINY;
+    let calp1b = -1;
+    let tripn = false;
+    let tripb = false;
+    for (let numit = 0; ; ++numit) {
+      const lv = Lambda12(
+        sbet1,
+        cbet1,
+        dn1,
+        sbet2,
+        cbet2,
+        dn2,
+        salp1,
+        calp1,
+        slam12,
+        clam12,
+        numit < MAXIT1,
+        C1a,
+        C2a,
+        C3a
+      );
+      const v = lv.lam12;
+      calp2 = lv.calp2;
+      sig12 = lv.sig12;
+      ssig1 = lv.ssig1;
+      csig1 = lv.csig1;
+      ssig2 = lv.ssig2;
+      csig2 = lv.csig2;
+      eps = lv.eps;
+      const dv = lv.dlam12;
+      if (tripb || !(Math.abs(v) >= (tripn ? 8 : 1) * TOL0) || numit === MAXIT2)
+        break;
+      if (v > 0) {
+        salp1b = salp1;
+        calp1b = calp1;
+      }
+      if (v < 0) {
+        salp1a = salp1;
+        calp1a = calp1;
+      }
+      {
+        const dalp1 = -v / dv;
+        const sdalp1 = Math.sin(dalp1);
+        const cdalp1 = Math.cos(dalp1);
+        const nsalp1 = salp1 * cdalp1 + calp1 * sdalp1;
+        if (nsalp1 > 0) {
+          calp1 = calp1 * cdalp1 - salp1 * sdalp1;
+          salp1 = nsalp1;
+          t = hypot(salp1, calp1);
+          salp1 /= t;
+          calp1 /= t;
+          tripn = Math.abs(v) <= 16 * TOL0;
+          continue;
+        }
+      }
+      salp1 = (salp1a + salp1b) / 2;
+      calp1 = (calp1a + calp1b) / 2;
+      t = hypot(salp1, calp1);
+      salp1 /= t;
+      calp1 /= t;
+      tripn = false;
+      tripb = Math.abs(salp1a - salp1) + (calp1a - calp1) < TOLB || Math.abs(salp1 - salp1b) + (calp1 - calp1b) < TOLB;
+    }
+    const nv = geodesicLengths(
+      eps,
+      sig12,
+      ssig1,
+      csig1,
+      dn1,
+      ssig2,
+      csig2,
+      dn2,
+      C1a,
+      C2a
+    );
+    return b * nv.s12b;
+  }
+  function karney([lon1, lat1], [lon2, lat2]) {
+    return inverseDistance(lat1, lon1, lat2, lon2);
+  }
+
+  // source/Domain/Utility/Calculate.ts
+  var D2R2 = Math.PI / 180;
   var \u03C0 = Math.PI;
   function constrain(value, min, max) {
     return Math.max(Math.min(value, max), min);
   }
-  function squared(n) {
-    return n * n;
-  }
-  function rad(n) {
-    return n * D2R;
+  function rad(n2) {
+    return n2 * D2R2;
   }
   var EARTH_RADIUS_MAJOR_SQUARED = squared(EARTH_RADIUS_MAJOR);
   var EARTH_RADIUS_MINOR_SQUARED = squared(EARTH_RADIUS_MINOR);
   var EARTH_RADIUS_FACTOR = (EARTH_RADIUS_MAJOR_SQUARED - EARTH_RADIUS_MINOR_SQUARED) / EARTH_RADIUS_MINOR_SQUARED;
   var EARTH_INVERSE_FLATTENING = 1 / EARTH_FLATTENING;
+  function cartesian([\u03BBa, \u03C6a], [\u03BBb, \u03C6b]) {
+    return EARTH_RADIUS * rad(Math.sqrt(squared(\u03BBb - \u03BBa) + squared(\u03C6b - \u03C6a)));
+  }
+  function haversine([\u03BBa, \u03C6a], [\u03BBb, \u03C6b]) {
+    const \u0394 = squared(Math.sin(rad(\u03C6b - \u03C6a) / 2)) + Math.cos(rad(\u03C6a)) * Math.cos(rad(\u03C6b)) * squared(Math.sin(rad(\u03BBb - \u03BBa) / 2));
+    return EARTH_RADIUS * Math.atan2(Math.sqrt(\u0394), Math.sqrt(1 - \u0394)) * 2;
+  }
+  function vincenty(a2, b2) {
+    const [[\u03BB1, \u03C61], [\u03BB2, \u03C62]] = [a2, b2].map((p) => p.map(rad));
+    const L = \u03BB2 - \u03BB1;
+    const tanU1 = (1 - EARTH_INVERSE_FLATTENING) * Math.tan(\u03C61), cosU1 = 1 / Math.sqrt(1 + tanU1 * tanU1), sinU1 = tanU1 * cosU1;
+    const tanU2 = (1 - EARTH_INVERSE_FLATTENING) * Math.tan(\u03C62), cosU2 = 1 / Math.sqrt(1 + tanU2 * tanU2), sinU2 = tanU2 * cosU2;
+    const antipodal = Math.abs(L) > \u03C0 / 2 || Math.abs(\u03C62 - \u03C61) > \u03C0 / 2;
+    let \u03BB = L;
+    let sin\u03BB = null;
+    let cos\u03BB = null;
+    let \u03C3 = antipodal ? \u03C0 : 0;
+    let sin\u03C3 = 0;
+    let cos\u03C3 = antipodal ? -1 : 1;
+    let sinSq\u03C3 = null;
+    let cos2\u03C3\u2098 = 1;
+    let cosSq\u03B1 = 1;
+    let \u03BB\u02B9 = null;
+    let prev\u0394\u03BB = Infinity;
+    let iterations = 0;
+    do {
+      sin\u03BB = Math.sin(\u03BB);
+      cos\u03BB = Math.cos(\u03BB);
+      sinSq\u03C3 = (cosU2 * sin\u03BB) ** 2 + (cosU1 * sinU2 - sinU1 * cosU2 * cos\u03BB) ** 2;
+      if (Math.abs(sinSq\u03C3) < 1e-24) break;
+      sin\u03C3 = Math.sqrt(sinSq\u03C3);
+      cos\u03C3 = sinU1 * sinU2 + cosU1 * cosU2 * cos\u03BB;
+      \u03C3 = Math.atan2(sin\u03C3, cos\u03C3);
+      const sin\u03B1 = cosU1 * cosU2 * sin\u03BB / sin\u03C3;
+      cosSq\u03B1 = 1 - sin\u03B1 * sin\u03B1;
+      cos2\u03C3\u2098 = cosSq\u03B1 !== 0 ? cos\u03C3 - 2 * sinU1 * sinU2 / cosSq\u03B1 : 0;
+      const C = EARTH_INVERSE_FLATTENING / 16 * cosSq\u03B1 * (4 + EARTH_INVERSE_FLATTENING * (4 - 3 * cosSq\u03B1));
+      \u03BB\u02B9 = \u03BB;
+      \u03BB = L + (1 - C) * EARTH_INVERSE_FLATTENING * sin\u03B1 * (\u03C3 + C * sin\u03C3 * (cos2\u03C3\u2098 + C * cos\u03C3 * (-1 + 2 * cos2\u03C3\u2098 * cos2\u03C3\u2098)));
+      const \u0394\u03BB = Math.abs(\u03BB - \u03BB\u02B9);
+      if (\u0394\u03BB !== 0 && \u0394\u03BB === prev\u0394\u03BB || ++iterations > 1e3)
+        throw new EvalError("Vincenty formula failed to converge");
+      prev\u0394\u03BB = \u0394\u03BB;
+    } while (Math.abs(\u03BB - \u03BB\u02B9) > 1e-12);
+    const uSq = cosSq\u03B1 * EARTH_RADIUS_FACTOR;
+    const A = 1 + uSq / 16384 * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)));
+    const B = uSq / 1024 * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)));
+    const \u0394\u03C3 = B * sin\u03C3 * (cos2\u03C3\u2098 + B / 4 * (cos\u03C3 * (-1 + 2 * cos2\u03C3\u2098 * cos2\u03C3\u2098) - B / 6 * cos2\u03C3\u2098 * (-3 + 4 * sin\u03C3 * sin\u03C3) * (-3 + 4 * cos2\u03C3\u2098 * cos2\u03C3\u2098)));
+    return EARTH_RADIUS_MINOR * A * (\u03C3 - \u0394\u03C3);
+  }
   var PointToPoint = {
-    cartesian([\u03BBa, \u03C6a], [\u03BBb, \u03C6b]) {
-      return EARTH_RADIUS * rad(Math.sqrt(squared(\u03BBb - \u03BBa) + squared(\u03C6b - \u03C6a)));
-    },
-    haversine([\u03BBa, \u03C6a], [\u03BBb, \u03C6b]) {
-      const \u0394 = squared(Math.sin(rad(\u03C6b - \u03C6a) / 2)) + Math.cos(rad(\u03C6a)) * Math.cos(rad(\u03C6b)) * squared(Math.sin(rad(\u03BBb - \u03BBa) / 2));
-      return EARTH_RADIUS * Math.atan2(Math.sqrt(\u0394), Math.sqrt(1 - \u0394)) * 2;
-    },
-    vincenty(...points) {
-      const [[\u03BB1, \u03C61], [\u03BB2, \u03C62]] = points.map(
-        (p) => p.map(rad)
-      );
-      const L = \u03BB2 - \u03BB1;
-      const tanU1 = (1 - EARTH_INVERSE_FLATTENING) * Math.tan(\u03C61), cosU1 = 1 / Math.sqrt(1 + tanU1 * tanU1), sinU1 = tanU1 * cosU1;
-      const tanU2 = (1 - EARTH_INVERSE_FLATTENING) * Math.tan(\u03C62), cosU2 = 1 / Math.sqrt(1 + tanU2 * tanU2), sinU2 = tanU2 * cosU2;
-      const antipodal = Math.abs(L) > \u03C0 / 2 || Math.abs(\u03C62 - \u03C61) > \u03C0 / 2;
-      let \u03BB = L;
-      let sin\u03BB = null;
-      let cos\u03BB = null;
-      let \u03C3 = antipodal ? \u03C0 : 0;
-      let sin\u03C3 = 0;
-      let cos\u03C3 = antipodal ? -1 : 1;
-      let sinSq\u03C3 = null;
-      let cos2\u03C3\u2098 = 1;
-      let cosSq\u03B1 = 1;
-      let \u03BB\u02B9 = null;
-      let iterations = 0;
-      do {
-        sin\u03BB = Math.sin(\u03BB);
-        cos\u03BB = Math.cos(\u03BB);
-        sinSq\u03C3 = (cosU2 * sin\u03BB) ** 2 + (cosU1 * sinU2 - sinU1 * cosU2 * cos\u03BB) ** 2;
-        if (Math.abs(sinSq\u03C3) < 1e-24) break;
-        sin\u03C3 = Math.sqrt(sinSq\u03C3);
-        cos\u03C3 = sinU1 * sinU2 + cosU1 * cosU2 * cos\u03BB;
-        \u03C3 = Math.atan2(sin\u03C3, cos\u03C3);
-        const sin\u03B1 = cosU1 * cosU2 * sin\u03BB / sin\u03C3;
-        cosSq\u03B1 = 1 - sin\u03B1 * sin\u03B1;
-        cos2\u03C3\u2098 = cosSq\u03B1 !== 0 ? cos\u03C3 - 2 * sinU1 * sinU2 / cosSq\u03B1 : 0;
-        const C = EARTH_INVERSE_FLATTENING / 16 * cosSq\u03B1 * (4 + EARTH_INVERSE_FLATTENING * (4 - 3 * cosSq\u03B1));
-        \u03BB\u02B9 = \u03BB;
-        \u03BB = L + (1 - C) * EARTH_INVERSE_FLATTENING * sin\u03B1 * (\u03C3 + C * sin\u03C3 * (cos2\u03C3\u2098 + C * cos\u03C3 * (-1 + 2 * cos2\u03C3\u2098 * cos2\u03C3\u2098)));
-      } while (Math.abs(\u03BB - \u03BB\u02B9) > 1e-12 && ++iterations < 1e3);
-      const uSq = cosSq\u03B1 * EARTH_RADIUS_FACTOR;
-      const A = 1 + uSq / 16384 * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)));
-      const B = uSq / 1024 * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)));
-      const \u0394\u03C3 = B * sin\u03C3 * (cos2\u03C3\u2098 + B / 4 * (cos\u03C3 * (-1 + 2 * cos2\u03C3\u2098 * cos2\u03C3\u2098) - B / 6 * cos2\u03C3\u2098 * (-3 + 4 * sin\u03C3 * sin\u03C3) * (-3 + 4 * cos2\u03C3\u2098 * cos2\u03C3\u2098)));
-      return EARTH_RADIUS_MINOR * A * (\u03C3 - \u0394\u03C3);
-    }
+    cartesian,
+    haversine,
+    vincenty,
+    karney
   };
   function getClosestPointOnLineByPoint(point, line) {
     const [[px, py], [ax, ay], [bx, by]] = [point, ...line];
@@ -677,10 +1236,10 @@ var GeoJSON = (() => {
     );
     return t === 0 || t === 1 ? line[t] : [ax + abx * t, ay + aby * t];
   }
-  function getDistanceOfPointToPoint(a, b, calculation) {
+  function getDistanceOfPointToPoint(a2, b2, calculation) {
     const calc = typeof calculation === "function" ? calculation : PointToPoint[calculation];
     if (typeof calc === "function") {
-      return calc(a, b);
+      return calc(a2, b2);
     }
     throw new Error(`Not a PointToPoint calculation function ${calculation}`);
   }
@@ -691,15 +1250,15 @@ var GeoJSON = (() => {
       calculation
     );
   }
-  function getDistanceOfLineToLine(a, b, calculation) {
-    return isLinesCrossing(a, b) ? 0 : Math.min(
-      ...a.map((a2) => getDistanceOfPointToLine(a2, b, calculation)),
-      ...b.map((b2) => getDistanceOfPointToLine(b2, a, calculation))
+  function getDistanceOfLineToLine(a2, b2, calculation) {
+    return isLinesCrossing(a2, b2) ? 0 : Math.min(
+      ...a2.map((a3) => getDistanceOfPointToLine(a3, b2, calculation)),
+      ...b2.map((b3) => getDistanceOfPointToLine(b3, a2, calculation))
     );
   }
-  function isLinesCrossing(a, b) {
-    const [[a1x, a1y], [a2x, a2y]] = a;
-    const [[b1x, b1y], [b2x, b2y]] = b;
+  function isLinesCrossing(a2, b2) {
+    const [[a1x, a1y], [a2x, a2y]] = a2;
+    const [[b1x, b1y], [b2x, b2y]] = b2;
     const [s1x, s1y, s2x, s2y] = [a2x - a1x, a2y - a1y, b2x - b1x, b2y - b1y];
     const s = (-s1y * (a1x - b1x) + s1x * (a1y - b1y)) / (-s2x * s1y + s1x * s2y);
     const t = (s2x * (a1y - b1y) - s2y * (a1x - b1x)) / (-s2x * s1y + s1x * s2y);
@@ -713,13 +1272,13 @@ var GeoJSON = (() => {
       return false;
     }
     const { length } = ring;
-    const odd = ring.reduce((odd2, a, i) => {
-      const b = ring[(length + i - 1) % length];
-      return (a[1] < p[1] && b[1] >= p[1] || b[1] < p[1] && a[1] >= p[1]) && (a[0] <= p[0] || b[0] <= p[0]) ? odd2 ^ Number(
-        a[0] + (p[1] - a[1]) / (b[1] - a[1]) * (b[0] - a[0]) < p[0]
+    const odd = ring.reduce((odd2, a2, i) => {
+      const b2 = ring[(length + i - 1) % length];
+      return (a2[1] < p[1] && b2[1] >= p[1] || b2[1] < p[1] && a2[1] >= p[1]) && (a2[0] <= p[0] || b2[0] <= p[0]) ? odd2 ^ Number(
+        a2[0] + (p[1] - a2[1]) / (b2[1] - a2[1]) * (b2[0] - a2[0]) < p[0]
       ) : odd2;
     }, 0);
-    return odd !== 0 || ring.slice(1).some((a, index) => isPointOnLine(p, [ring[index], a]));
+    return odd !== 0 || ring.slice(1).some((a2, index) => isPointOnLine(p, [ring[index], a2]));
   }
 
   // source/Domain/Utility/Segments.ts
@@ -729,76 +1288,88 @@ var GeoJSON = (() => {
 
   // source/Domain/Utility/Distance.ts
   var geometries = {
-    PointPoint(a, b, calculation) {
-      return getDistanceOfPointToPoint(a, b, calculation);
+    PointPoint(a2, b2, calculation) {
+      return getDistanceOfPointToPoint(a2, b2, calculation);
     },
-    LineStringPoint(a, b, calculation) {
+    LineStringPoint(a2, b2, calculation) {
       return Math.min(
-        ...segments(a).map(
-          (line) => getDistanceOfPointToLine(b, line, calculation)
+        ...segments(a2).map(
+          (line) => getDistanceOfPointToLine(b2, line, calculation)
         )
       );
     },
-    LineStringLineString(a, b, calculation) {
-      const sa = segments(a);
-      const sb = segments(b);
+    LineStringLineString(a2, b2, calculation) {
+      const sa = segments(a2);
+      const sb = segments(b2);
       return sa.reduce(
-        (carry, a2) => sb.reduce(
-          (carry2, b2) => carry2 > 0 ? Math.min(
+        (carry, a3) => sb.reduce(
+          (carry2, b3) => carry2 > 0 ? Math.min(
             carry2,
-            getDistanceOfLineToLine(a2, b2, calculation)
+            getDistanceOfLineToLine(a3, b3, calculation)
           ) : carry2,
           carry
         ),
         Infinity
       );
     },
-    PolygonPoint([exterior, ...interior], b, calculation) {
-      if (isPointInRing(b, exterior)) {
+    PolygonPoint([exterior, ...interior], b2, calculation) {
+      if (isPointInRing(b2, exterior)) {
         const [excluded] = interior.filter(
-          (ring) => isPointInRing(b, ring)
+          (ring) => isPointInRing(b2, ring)
         );
-        return excluded ? this.LineStringPoint(excluded, b, calculation) : 0;
+        return excluded ? this.LineStringPoint(excluded, b2, calculation) : 0;
       }
-      return this.LineStringPoint(exterior, b, calculation);
+      return this.LineStringPoint(exterior, b2, calculation);
     },
-    PolygonLineString(a, b, calculation) {
-      const [exterior, ...interior] = a;
-      const line = segments(b);
-      const ring = b.some((b2) => isPointInRing(b2, exterior)) ? interior.find((a2) => b.every((b2) => isPointInRing(b2, a2))) : exterior;
+    PolygonLineString(a2, b2, calculation) {
+      const [exterior, ...interior] = a2;
+      const line = segments(b2);
+      const ring = b2.some((b3) => isPointInRing(b3, exterior)) ? interior.find((a3) => b2.every((b3) => isPointInRing(b3, a3))) : exterior;
       return ring ? Math.min(
         ...segments(ring).map(
-          (a2) => Math.min(
+          (a3) => Math.min(
             ...line.map(
-              (b2) => getDistanceOfLineToLine(a2, b2, calculation)
+              (b3) => getDistanceOfLineToLine(a3, b3, calculation)
             )
           )
         )
       ) : 0;
     },
-    PolygonPolygon(a, b, calculation) {
+    PolygonPolygon(a2, b2, calculation) {
       return Math.min(
-        this.PolygonLineString(a, b[0], calculation),
-        this.PolygonLineString(b, a[0], calculation)
+        this.PolygonLineString(a2, b2[0], calculation),
+        this.PolygonLineString(b2, a2[0], calculation)
       );
     }
   };
-  function distance(a, b, calculation = "cartesian") {
+  function cartesian2(a2, b2) {
+    return distance(a2, b2, cartesian);
+  }
+  function haversine2(a2, b2) {
+    return distance(a2, b2, haversine);
+  }
+  function vincenty2(a2, b2) {
+    return distance(a2, b2, vincenty);
+  }
+  function karney2(a2, b2) {
+    return distance(a2, b2, karney);
+  }
+  function distance(a2, b2, calculation = "haversine") {
     const lookup = geometries;
     return Math.min(
       ...[
         ...new IterablePairIterator(
-          new SimpleGeometryIterator(a),
-          new SimpleGeometryIterator(b)
+          new SimpleGeometryIterator(a2),
+          new SimpleGeometryIterator(b2)
         )
-      ].map(([a2, b2]) => {
-        return a2.type + b2.type in lookup ? lookup[a2.type + b2.type](
-          a2.coordinates,
-          b2.coordinates,
+      ].map(([a3, b3]) => {
+        return a3.type + b3.type in lookup ? lookup[a3.type + b3.type](
+          a3.coordinates,
+          b3.coordinates,
           calculation
-        ) : b2.type + a2.type in lookup ? lookup[b2.type + a2.type](
-          b2.coordinates,
-          a2.coordinates,
+        ) : b3.type + a3.type in lookup ? lookup[b3.type + a3.type](
+          b3.coordinates,
+          a3.coordinates,
           calculation
         ) : Infinity;
       })
@@ -807,37 +1378,37 @@ var GeoJSON = (() => {
 
   // source/Domain/Utility/Intersect.ts
   var geometries2 = {
-    PointPoint(a, b) {
-      return a.length >= 2 && b.length >= 2 && a.slice(0, 2).every((v, i) => v === b[i]);
+    PointPoint(a2, b2) {
+      return a2.length >= 2 && b2.length >= 2 && a2.slice(0, 2).every((v, i) => v === b2[i]);
     },
-    LineStringPoint(a, b) {
-      return a.some((a2) => this.PointPoint(a2, b)) || segments(a).some((line) => isPointOnLine(b, line));
+    LineStringPoint(a2, b2) {
+      return a2.some((a3) => this.PointPoint(a3, b2)) || segments(a2).some((line) => isPointOnLine(b2, line));
     },
-    LineStringLineString(a, b) {
-      const lines = segments(b);
-      return segments(a).some(
-        (a2) => lines.some((b2) => isLinesCrossing(a2, b2))
+    LineStringLineString(a2, b2) {
+      const lines = segments(b2);
+      return segments(a2).some(
+        (a3) => lines.some((b3) => isLinesCrossing(a3, b3))
       );
     },
-    PolygonPoint([exterior, ...interior], b) {
-      return (this.LineStringPoint(exterior, b) || isPointInRing(b, exterior)) && (!interior.length || interior.every((ring) => !isPointInRing(b, ring)));
+    PolygonPoint([exterior, ...interior], b2) {
+      return (this.LineStringPoint(exterior, b2) || isPointInRing(b2, exterior)) && (!interior.length || interior.every((ring) => !isPointInRing(b2, ring)));
     },
-    PolygonLineString(a, b) {
-      return a.some((ring) => this.LineStringLineString(ring, b)) || b.some((point) => this.PolygonPoint(a, point));
+    PolygonLineString(a2, b2) {
+      return a2.some((ring) => this.LineStringLineString(ring, b2)) || b2.some((point) => this.PolygonPoint(a2, point));
     },
-    PolygonPolygon(a, b) {
-      return b.some(
-        (b1) => this.PolygonLineString(a, b1) || b1.some((b2) => this.PolygonPoint(a, b2))
-      ) || a.some(
-        (a1) => this.PolygonLineString(b, a1) || a1.some((a2) => this.PolygonPoint(b, a2))
+    PolygonPolygon(a2, b2) {
+      return b2.some(
+        (b1) => this.PolygonLineString(a2, b1) || b1.some((b22) => this.PolygonPoint(a2, b22))
+      ) || a2.some(
+        (a1) => this.PolygonLineString(b2, a1) || a1.some((a22) => this.PolygonPoint(b2, a22))
       );
     }
   };
-  function intersect(a, b) {
+  function intersect(a2, b2) {
     const lookup = geometries2;
     for (const [itA, itB] of new IterablePairIterator(
-      new SimpleGeometryIterator(a),
-      new SimpleGeometryIterator(b)
+      new SimpleGeometryIterator(a2),
+      new SimpleGeometryIterator(b2)
     )) {
       if (itA.type + itB.type in lookup && lookup[itA.type + itB.type](
         itA.coordinates,