@konfirm/geojson 1.0.1 → 2.0.0-beta.0

package/dist/main.js

@@ -2,9 +2,9 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all11) => {
-  for (var name in all11)
-    __defProp(target, name, { get: all11[name], enumerable: true });
+var __export = (target, all2) => {
+  for (var name in all2)
+    __defProp(target, name, { get: all2[name], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -20,13 +20,16 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 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,
@@ -39,23 +42,114 @@ __export(main_exports, {
   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
 });
 module.exports = __toCommonJS(main_exports);
 
-// source/Domain/GeoJSON/Concept/Position.ts
-var import_guard3 = require("@konfirm/guard");
+// node_modules/@konfirm/guard/dist/guard.es.js
+var TypeMapper = class {
+  constructor(mapping = {}) {
+    this.mapping = Object.keys(mapping).map((key) => (value) => mapping[key](value) ? key : void 0).concat((value) => typeof value);
+  }
+  map(value) {
+    return this.mapping.reduce((carry, map) => carry || map(value), void 0);
+  }
+};
+var ValueMapper = class {
+  constructor(types2 = new TypeMapper(), mapping = {}) {
+    this.types = types2;
+    this.mapping = mapping;
+  }
+  map(value) {
+    const type = this.types.map(value);
+    const map = (value2) => this.map(value2);
+    return type in this.mapping ? this.mapping[type](value, map) : (value === null || value === void 0 ? void 0 : value.toString()) || "undefined";
+  }
+};
+var types = new TypeMapper({
+  date: (value) => value instanceof Date,
+  regexp: (value) => value instanceof RegExp,
+  array: (value) => Array.isArray(value),
+  null: (value) => value === null
+});
+var stringifier = new ValueMapper(types, {
+  string: (value) => value ? `"${value}"` : "EmptyString",
+  date: (value, map) => map(value.toISOString()),
+  object: (value, map) => {
+    const string = String(value);
+    if (/^\[([a-z]+) \1\]$/i.test(string)) {
+      const mapped = Object.keys(value).map((key) => `${key}:${map(value[key])}`);
+      return `{${mapped.join(",")}}`;
+    }
+    return string;
+  },
+  array: (value, map) => `[${value.map(map).join(",")}]`,
+  null: () => "NULL",
+  undefined: () => "Undefined",
+  function: (value) => {
+    const { constructor: { name: cname }, name } = value;
+    const [, async, generator, func] = cname.match(/^(async)?(generator)?(function)$/i);
+    const [, stype, sname] = value.toString().match(/^(?:async)?(?:[\s\*]+)?(class|function)?(?:[\s\*]+)?([a-z_]\w*)?\s*[\(\{]?/i);
+    const parts = [].concat(stype && !(name || sname) ? "anonymous" : []).concat(name && !stype && sname ? "shorthand" : []).concat(async || [], generator || []).concat(!(stype || sname) ? "arrow" : []).concat(stype || func).map((key) => key[0].toUpperCase() + key.slice(1));
+    return [parts.join("")].concat(name || []).join(" ");
+  }
+});
+function is(type) {
+  return (value) => typeof value === type;
+}
+function any(...checks) {
+  return (value) => checks.some((check) => check(value));
+}
+function all(...checks) {
+  return (value) => checks.every((check) => check(value));
+}
+function not(...checks) {
+  return (value) => checks.every((check) => !check(value));
+}
+var isArray = (value) => Array.isArray(value);
+var isBigInt = is("bigint");
+var isBoolean = is("boolean");
+var isFunction = is("function");
+var isNULL = (value) => value === null;
+var isNumber = is("number");
+var isObject = all(not(isArray), not(isNULL), is("object"));
+var isString = is("string");
+var isSymbol = is("symbol");
+var isUndefined = is("undefined");
+function isArrayOfType(...validators) {
+  const check = all(...validators);
+  return all(isArray, (value) => value.every(check));
+}
+function isArrayOfSize(min, max = Infinity) {
+  return all(isArray, (value) => value.length >= min && value.length <= max);
+}
+function isKey(key) {
+  return all(isObject, (value) => key in value);
+}
+function isKeyOfType(key, ...validators) {
+  return all(isKey(key), (value) => validators.every((check) => check(value[key])));
+}
+function isOptionalKeyOfType(key, ...validators) {
+  return any(all(isObject, not(isKey(key))), isKeyOfType(key, ...validators));
+}
+function isStructure(struct, ...options) {
+  const optional = options.reduce((carry, key) => carry.concat(key), []);
+  const validators = Object.keys(struct).map((key) => (optional.includes(key) ? isOptionalKeyOfType : isKeyOfType)(key, struct[key]));
+  return all(isObject, ...validators);
+}
 
 // source/Domain/Guards/Tuple.ts
-var import_guard = require("@konfirm/guard");
 function isTuple(...rules) {
-  return (value) => (0, import_guard.isArray)(value) && value.length === rules.length && rules.every((rule, index) => rule(value[index]));
+  return (value) => isArray(value) && value.length === rules.length && rules.every((rule, index) => rule(value[index]));
 }
 
 // source/Domain/Constants.ts
@@ -66,13 +160,12 @@ var EARTH_FLATTENING = 298.257223563;
 var GPS_SATELLITE_ORBIT = 2018e4;
 
 // source/Domain/Guards/Number.ts
-var import_guard2 = require("@konfirm/guard");
 function isNumberValue(value) {
-  return (0, import_guard2.isNumber)(value) && Number.isFinite(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;
 }
 
@@ -98,24 +191,17 @@ function isLongitude(value) {
 var isStrictLongitude = isNumberBetween(-180, 180);
 
 // source/Domain/GeoJSON/Concept/Position.ts
-var isPosition = (0, import_guard3.any)(
+var isPosition = any(
   isTuple(isLongitude, isLatitude),
   isTuple(isLongitude, isLatitude, isAltitude)
 );
-var isStrictPosition = (0, import_guard3.any)(
+var isStrictPosition = any(
   isTuple(isStrictLongitude, isStrictLatitude),
   isTuple(isStrictLongitude, isStrictLatitude, isStrictAltitude)
 );
 
-// source/Domain/GeoJSON/Feature.ts
-var import_guard17 = require("@konfirm/guard");
-
-// source/Domain/GeoJSON/Concept/GeoJSONObject.ts
-var import_guard5 = require("@konfirm/guard");
-
 // source/Domain/GeoJSON/Concept/BoundingBox.ts
-var import_guard4 = require("@konfirm/guard");
-var isBoundingBoxWithAltitude = (0, import_guard4.all)(
+var isBoundingBoxWithAltitude = all(
   isTuple(
     isLongitude,
     isLatitude,
@@ -124,18 +210,18 @@ var isBoundingBoxWithAltitude = (0, import_guard4.all)(
     isLatitude,
     isAltitude
   ),
-  ([, s, , , n]) => s <= n
+  ([, s, , , n2]) => s <= n2
 );
-var isBoundingBoxWithoutAltitude = (0, import_guard4.all)(
+var isBoundingBoxWithoutAltitude = all(
   isTuple(isLongitude, isLatitude, isLongitude, isLatitude),
-  ([, s, , n]) => s <= n
+  ([, s, , n2]) => s <= n2
 );
-var isBoundingBox = (0, import_guard4.any)(
+var isBoundingBox = any(
   isBoundingBoxWithAltitude,
   isBoundingBoxWithoutAltitude
 );
-var isStrictBoundingBox = (0, import_guard4.any)(
-  (0, import_guard4.all)(
+var isStrictBoundingBox = any(
+  all(
     isTuple(
       isStrictLongitude,
       isStrictLatitude,
@@ -146,7 +232,7 @@ var isStrictBoundingBox = (0, import_guard4.any)(
     ),
     isBoundingBoxWithAltitude
   ),
-  (0, import_guard4.all)(
+  all(
     isTuple(
       isStrictLongitude,
       isStrictLatitude,
@@ -159,30 +245,23 @@ var isStrictBoundingBox = (0, import_guard4.any)(
 
 // source/Domain/GeoJSON/Concept/GeoJSONObject.ts
 function isGeoJSONObject(type) {
-  return (0, import_guard5.isStructure)(
+  return isStructure(
     {
-      type: (0, import_guard5.all)(import_guard5.isString, (value) => value === type),
+      type: all(isString, (value) => value === type),
       bbox: isBoundingBox
     },
     "bbox"
   );
 }
 
-// source/Domain/GeoJSON/Geometry.ts
-var import_guard15 = require("@konfirm/guard");
-
 // source/Domain/GeoJSON/GeometryObject.ts
-var import_guard6 = require("@konfirm/guard");
 function isGeometryObject(type, isCoordinates) {
-  return (0, import_guard6.all)(
+  return all(
     isGeoJSONObject(type),
-    (0, import_guard6.isKeyOfType)("coordinates", isCoordinates)
+    isKeyOfType("coordinates", isCoordinates)
   );
 }
 
-// source/Domain/GeoJSON/Geometry/MultiPoint.ts
-var import_guard7 = require("@konfirm/guard");
-
 // source/Domain/GeoJSON/Geometry/Point.ts
 var isPointCoordinates = isPosition;
 var isPoint = isGeometryObject(
@@ -196,12 +275,12 @@ var isStrictPoint = isGeometryObject(
 );
 
 // source/Domain/GeoJSON/Geometry/MultiPoint.ts
-var isMultiPointCoordinates = (0, import_guard7.isArrayOfType)(isPointCoordinates);
+var isMultiPointCoordinates = isArrayOfType(isPointCoordinates);
 var isMultiPoint = isGeometryObject(
   "MultiPoint",
   isMultiPointCoordinates
 );
-var isStrictMultiPointCoordinates = (0, import_guard7.isArrayOfType)(isStrictPointCoordinates);
+var isStrictMultiPointCoordinates = isArrayOfType(isStrictPointCoordinates);
 var isStrictMultiPoint = isGeometryObject(
   "MultiPoint",
   isStrictMultiPointCoordinates
@@ -217,15 +296,14 @@ var isStrictLineStringCoordinates = isStrictMultiPointCoordinates;
 var isStrictLineString = isGeometryObject("LineString", isStrictLineStringCoordinates);
 
 // source/Domain/GeoJSON/Geometry/MultiLineString.ts
-var import_guard8 = require("@konfirm/guard");
-var isMultiLineStringCoordinates = (0, import_guard8.isArrayOfType)(
+var isMultiLineStringCoordinates = isArrayOfType(
   isLineStringCoordinates
 );
 var isMultiLineString = isGeometryObject(
   "MultiLineString",
   isMultiLineStringCoordinates
 );
-var isStrictMultiLineStringCoordinates = (0, import_guard8.isArrayOfType)(
+var isStrictMultiLineStringCoordinates = isArrayOfType(
   isStrictLineStringCoordinates
 );
 var isStrictMultiLineString = isGeometryObject(
@@ -233,69 +311,57 @@ var isStrictMultiLineString = isGeometryObject(
   isStrictMultiLineStringCoordinates
 );
 
-// source/Domain/GeoJSON/Geometry/MultiPolygon.ts
-var import_guard14 = require("@konfirm/guard");
-
-// source/Domain/GeoJSON/Geometry/Polygon.ts
-var import_guard13 = require("@konfirm/guard");
-
-// source/Domain/GeoJSON/Concept/ExteriorRing.ts
-var import_guard11 = require("@konfirm/guard");
-
 // source/Domain/Utility/Winding.ts
-var import_guard9 = require("@konfirm/guard");
-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 = (0, import_guard9.isArrayOfType)(isPosition);
+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
-var import_guard10 = require("@konfirm/guard");
-var isLinearRing = (0, import_guard10.all)(
-  (0, import_guard10.isArrayOfType)(isPosition),
-  (0, import_guard10.isArrayOfSize)(4),
+var isLinearRing = all(
+  isArrayOfType(isPosition),
+  isArrayOfSize(4),
   (value) => value[value.length - 1].every((v, i) => v === value[0][i])
 );
-var isStrictLinearRing = (0, import_guard10.all)(
-  (0, import_guard10.isArrayOfType)(isStrictPosition),
-  (0, import_guard10.isArrayOfSize)(4),
+var isStrictLinearRing = all(
+  isArrayOfType(isStrictPosition),
+  isArrayOfSize(4),
   (value) => value[value.length - 1].every((v, i) => v === value[0][i])
 );
 
 // source/Domain/GeoJSON/Concept/ExteriorRing.ts
-var isExteriorRing = (0, import_guard11.all)(isLinearRing);
-var isStrictExteriorRing = (0, import_guard11.all)(
+var isExteriorRing = all(isLinearRing);
+var isStrictExteriorRing = all(
   isStrictLinearRing,
   isCounterClockwiseWinding
 );
 
 // source/Domain/GeoJSON/Concept/InteriorRing.ts
-var import_guard12 = require("@konfirm/guard");
-var isInteriorRing = (0, import_guard12.all)(isLinearRing);
-var isStrictInteriorRing = (0, import_guard12.all)(
+var isInteriorRing = all(isLinearRing);
+var isStrictInteriorRing = all(
   isStrictLinearRing,
   isClockwiseWinding
 );
 
 // source/Domain/GeoJSON/Geometry/Polygon.ts
-var isPolygonCoordinates = (0, import_guard13.all)((0, import_guard13.isArrayOfType)(isLinearRing));
+var isPolygonCoordinates = all(isArrayOfType(isLinearRing));
 var isPolygon = isGeometryObject(
   "Polygon",
   isPolygonCoordinates
 );
-var isStrictPolygonCoordinates = (0, import_guard13.all)(
-  (0, import_guard13.isArrayOfType)(isStrictLinearRing),
-  (value) => isExteriorRing(value[0]),
-  (value) => value.slice(1).every(isInteriorRing)
+var isStrictPolygonCoordinates = all(
+  isArrayOfType(isStrictLinearRing),
+  (value) => isStrictExteriorRing(value[0]),
+  (value) => value.slice(1).every(isStrictInteriorRing)
 );
 var isStrictPolygon = isGeometryObject(
   "Polygon",
@@ -303,12 +369,12 @@ var isStrictPolygon = isGeometryObject(
 );
 
 // source/Domain/GeoJSON/Geometry/MultiPolygon.ts
-var isMultiPolygonCoordinates = (0, import_guard14.isArrayOfType)(isPolygonCoordinates);
+var isMultiPolygonCoordinates = isArrayOfType(isPolygonCoordinates);
 var isMultiPolygon = isGeometryObject(
   "MultiPolygon",
   isMultiPolygonCoordinates
 );
-var isStrictMultiPolygonCoordinates = (0, import_guard14.isArrayOfType)(
+var isStrictMultiPolygonCoordinates = isArrayOfType(
   isStrictPolygonCoordinates
 );
 var isStrictMultiPolygon = isGeometryObject(
@@ -317,7 +383,7 @@ var isStrictMultiPolygon = isGeometryObject(
 );
 
 // source/Domain/GeoJSON/Geometry.ts
-var isGeometry = (0, import_guard15.any)(
+var isGeometryPrimitive = any(
   isPoint,
   isMultiPoint,
   isLineString,
@@ -325,7 +391,7 @@ var isGeometry = (0, import_guard15.any)(
   isPolygon,
   isMultiPolygon
 );
-var isStrictGeometry = (0, import_guard15.any)(
+var isStrictGeometryPrimitive = any(
   isStrictPoint,
   isStrictMultiPoint,
   isStrictLineString,
@@ -333,66 +399,77 @@ var isStrictGeometry = (0, import_guard15.any)(
   isStrictPolygon,
   isStrictMultiPolygon
 );
-
-// source/Domain/GeoJSON/GeometryCollection.ts
-var import_guard16 = require("@konfirm/guard");
-var isGeometryCollectionObject = (0, import_guard16.all)(
+var isGeometry = any(
+  isGeometryPrimitive,
+  isGeometryCollection
+);
+var isStrictGeometry = any(
+  isStrictGeometryPrimitive,
+  isStrictGeometryCollection
+);
+var isGeometryCollectionObject = all(
   isGeoJSONObject("GeometryCollection"),
-  (0, import_guard16.isKeyOfType)(
-    "geometries",
-    (0, import_guard16.isArrayOfType)((0, import_guard16.any)(isGeometry, isGeometryCollection))
-  )
+  isKeyOfType("geometries", isArrayOfType(isGeometry))
 );
-var isStrictGeometryCollectionObject = (0, import_guard16.all)(
+var isStrictGeometryCollectionObject = all(
   isGeoJSONObject("GeometryCollection"),
-  (0, import_guard16.isKeyOfType)(
-    "geometries",
-    (0, import_guard16.isArrayOfType)((0, import_guard16.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 = (0, import_guard17.all)(
+var isFeatureObject = all(
   isGeoJSONObject("Feature"),
-  (0, import_guard17.isStructure)({
-    geometry: (0, import_guard17.any)(isGeometry, isGeometryCollection),
-    properties: (0, import_guard17.any)(import_guard17.isNULL, import_guard17.isObject)
+  isStructure({
+    geometry: any(isNULL, isGeometry),
+    properties: any(isNULL, isObject)
   })
 );
-var isStrictFeature = (0, import_guard17.all)(
+var isStrictFeatureObject = all(
   isGeoJSONObject("Feature"),
-  (0, import_guard17.isStructure)({
-    geometry: (0, import_guard17.any)(isStrictGeometry, isStrictGeometryCollection),
-    properties: (0, import_guard17.any)(import_guard17.isNULL, import_guard17.isObject)
+  isStructure({
+    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 import_guard18 = require("@konfirm/guard");
-var isFeatureCollection = (0, import_guard18.all)(
+var isFeatureCollectionObject = all(
   isGeoJSONObject("FeatureCollection"),
-  (0, import_guard18.isKeyOfType)("features", (0, import_guard18.isArrayOfType)(isFeature))
+  isKeyOfType("features", isArrayOfType(isFeature))
 );
-var isStrictFeatureCollection = (0, import_guard18.all)(
+var isStrictFeatureCollectionObject = all(
   isGeoJSONObject("FeatureCollection"),
-  (0, import_guard18.isKeyOfType)("features", (0, import_guard18.isArrayOfType)(isStrictFeature))
+  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 import_guard19 = require("@konfirm/guard");
-var isGeoJSON = (0, import_guard19.any)(
+var isGeoJSON = any(
   isGeometry,
   isGeometryCollection,
   isFeature,
   isFeatureCollection
 );
-var isStrictGeoJSON = (0, import_guard19.any)(
+var isStrictGeoJSON = any(
   isStrictGeometry,
   isStrictGeometryCollection,
   isStrictFeature,
@@ -434,11 +511,15 @@ var reducers = {
     }
   },
   *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);
+      }
     }
   }
 };
@@ -494,9 +575,9 @@ var IterablePairIterator = class {
    * @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];
         }
       }
@@ -512,7 +593,7 @@ var IterablePairIterator = class {
    */
   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])
     );
   }
 };
@@ -544,70 +625,605 @@ function isWithinBox([lon, lat], [minLon, minLat, maxLon, maxLat]) {
   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];
@@ -620,10 +1236,10 @@ function getClosestPointOnLineByPoint(point, line) {
   );
   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}`);
 }
@@ -634,15 +1250,15 @@ function getDistanceOfPointToLine(point, line, calculation) {
     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);
@@ -656,13 +1272,13 @@ function isPointInRing(p, ring) {
     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
@@ -672,76 +1288,88 @@ function segments(line) {
 
 // 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;
     })
@@ -750,37 +1378,37 @@ function distance(a, b, calculation = "cartesian") {
 
 // 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,
@@ -794,13 +1422,16 @@ function intersect(a, b) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SimpleGeometryIterator,
+  cartesian,
   distance,
+  haversine,
   intersect,
   isFeature,
   isFeatureCollection,
   isGeoJSON,
   isGeometry,
   isGeometryCollection,
+  isGeometryPrimitive,
   isLineString,
   isMultiLineString,
   isMultiPoint,
@@ -813,12 +1444,15 @@ function intersect(a, b) {
   isStrictGeoJSON,
   isStrictGeometry,
   isStrictGeometryCollection,
+  isStrictGeometryPrimitive,
   isStrictLineString,
   isStrictMultiLineString,
   isStrictMultiPoint,
   isStrictMultiPolygon,
   isStrictPoint,
   isStrictPolygon,
-  isStrictPosition
+  isStrictPosition,
+  karney,
+  vincenty
 });
 //# sourceMappingURL=main.js.map