@konfirm/geojson 1.0.0 → 1.0.1

package/dist/main.global.js

@@ -0,0 +1,853 @@
+var GeoJSON = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  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") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // source/main.ts
+  var main_exports = {};
+  __export(main_exports, {
+    SimpleGeometryIterator: () => SimpleGeometryIterator,
+    distance: () => distance,
+    intersect: () => intersect,
+    isFeature: () => isFeature,
+    isFeatureCollection: () => isFeatureCollection,
+    isGeoJSON: () => isGeoJSON,
+    isGeometry: () => isGeometry,
+    isGeometryCollection: () => isGeometryCollection,
+    isLineString: () => isLineString,
+    isMultiLineString: () => isMultiLineString,
+    isMultiPoint: () => isMultiPoint,
+    isMultiPolygon: () => isMultiPolygon,
+    isPoint: () => isPoint,
+    isPolygon: () => isPolygon,
+    isPosition: () => isPosition,
+    isStrictFeature: () => isStrictFeature,
+    isStrictFeatureCollection: () => isStrictFeatureCollection,
+    isStrictGeoJSON: () => isStrictGeoJSON,
+    isStrictGeometry: () => isStrictGeometry,
+    isStrictGeometryCollection: () => isStrictGeometryCollection,
+    isStrictLineString: () => isStrictLineString,
+    isStrictMultiLineString: () => isStrictMultiLineString,
+    isStrictMultiPoint: () => isStrictMultiPoint,
+    isStrictMultiPolygon: () => isStrictMultiPolygon,
+    isStrictPoint: () => isStrictPoint,
+    isStrictPolygon: () => isStrictPolygon,
+    isStrictPosition: () => isStrictPosition
+  });
+
+  // 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
+  function isTuple(...rules) {
+    return (value) => isArray(value) && value.length === rules.length && rules.every((rule, index) => rule(value[index]));
+  }
+
+  // source/Domain/Constants.ts
+  var EARTH_RADIUS = 63710087714e-4;
+  var EARTH_RADIUS_MAJOR = 6378137;
+  var EARTH_RADIUS_MINOR = 6356752314245e-6;
+  var EARTH_FLATTENING = 298.257223563;
+  var GPS_SATELLITE_ORBIT = 2018e4;
+
+  // source/Domain/Guards/Number.ts
+  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);
+    return (value) => isNumberValue(value) && value >= min && value <= max;
+  }
+
+  // source/Domain/GeoJSON/Concept/Altitude.ts
+  function isAltitude(value) {
+    return isNumberValue(value);
+  }
+  var isStrictAltitude = isNumberBetween(
+    -EARTH_RADIUS,
+    GPS_SATELLITE_ORBIT
+  );
+
+  // source/Domain/GeoJSON/Concept/Latitude.ts
+  function isLatitude(value) {
+    return isNumberValue(value);
+  }
+  var isStrictLatitude = isNumberBetween(-90, 90);
+
+  // source/Domain/GeoJSON/Concept/Longitude.ts
+  function isLongitude(value) {
+    return isNumberValue(value);
+  }
+  var isStrictLongitude = isNumberBetween(-180, 180);
+
+  // source/Domain/GeoJSON/Concept/Position.ts
+  var isPosition = any(
+    isTuple(isLongitude, isLatitude),
+    isTuple(isLongitude, isLatitude, isAltitude)
+  );
+  var isStrictPosition = any(
+    isTuple(isStrictLongitude, isStrictLatitude),
+    isTuple(isStrictLongitude, isStrictLatitude, isStrictAltitude)
+  );
+
+  // source/Domain/GeoJSON/Concept/BoundingBox.ts
+  var isBoundingBoxWithAltitude = all(
+    isTuple(
+      isLongitude,
+      isLatitude,
+      isAltitude,
+      isLongitude,
+      isLatitude,
+      isAltitude
+    ),
+    ([, s, , , n]) => s <= n
+  );
+  var isBoundingBoxWithoutAltitude = all(
+    isTuple(isLongitude, isLatitude, isLongitude, isLatitude),
+    ([, s, , n]) => s <= n
+  );
+  var isBoundingBox = any(
+    isBoundingBoxWithAltitude,
+    isBoundingBoxWithoutAltitude
+  );
+  var isStrictBoundingBox = any(
+    all(
+      isTuple(
+        isStrictLongitude,
+        isStrictLatitude,
+        isStrictAltitude,
+        isStrictLongitude,
+        isStrictLatitude,
+        isStrictAltitude
+      ),
+      isBoundingBoxWithAltitude
+    ),
+    all(
+      isTuple(
+        isStrictLongitude,
+        isStrictLatitude,
+        isStrictLongitude,
+        isStrictLatitude
+      ),
+      isBoundingBoxWithoutAltitude
+    )
+  );
+
+  // source/Domain/GeoJSON/Concept/GeoJSONObject.ts
+  function isGeoJSONObject(type) {
+    return isStructure(
+      {
+        type: all(isString, (value) => value === type),
+        bbox: isBoundingBox
+      },
+      "bbox"
+    );
+  }
+
+  // source/Domain/GeoJSON/GeometryObject.ts
+  function isGeometryObject(type, isCoordinates) {
+    return all(
+      isGeoJSONObject(type),
+      isKeyOfType("coordinates", isCoordinates)
+    );
+  }
+
+  // source/Domain/GeoJSON/Geometry/Point.ts
+  var isPointCoordinates = isPosition;
+  var isPoint = isGeometryObject(
+    "Point",
+    isPointCoordinates
+  );
+  var isStrictPointCoordinates = isStrictPosition;
+  var isStrictPoint = isGeometryObject(
+    "Point",
+    isStrictPointCoordinates
+  );
+
+  // source/Domain/GeoJSON/Geometry/MultiPoint.ts
+  var isMultiPointCoordinates = isArrayOfType(isPointCoordinates);
+  var isMultiPoint = isGeometryObject(
+    "MultiPoint",
+    isMultiPointCoordinates
+  );
+  var isStrictMultiPointCoordinates = isArrayOfType(isStrictPointCoordinates);
+  var isStrictMultiPoint = isGeometryObject(
+    "MultiPoint",
+    isStrictMultiPointCoordinates
+  );
+
+  // source/Domain/GeoJSON/Geometry/LineString.ts
+  var isLineStringCoordinates = isMultiPointCoordinates;
+  var isLineString = isGeometryObject(
+    "LineString",
+    isLineStringCoordinates
+  );
+  var isStrictLineStringCoordinates = isStrictMultiPointCoordinates;
+  var isStrictLineString = isGeometryObject("LineString", isStrictLineStringCoordinates);
+
+  // source/Domain/GeoJSON/Geometry/MultiLineString.ts
+  var isMultiLineStringCoordinates = isArrayOfType(
+    isLineStringCoordinates
+  );
+  var isMultiLineString = isGeometryObject(
+    "MultiLineString",
+    isMultiLineStringCoordinates
+  );
+  var isStrictMultiLineStringCoordinates = isArrayOfType(
+    isStrictLineStringCoordinates
+  );
+  var isStrictMultiLineString = isGeometryObject(
+    "MultiLineString",
+    isStrictMultiLineStringCoordinates
+  );
+
+  // 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);
+    }, 0);
+  }
+  var isPositionArray = isArrayOfType(isPosition);
+  function isClockwiseWinding(value) {
+    return isPositionArray(value) && winding(value) <= 0;
+  }
+  function isCounterClockwiseWinding(value) {
+    return isPositionArray(value) && winding(value) >= 0;
+  }
+
+  // source/Domain/GeoJSON/Concept/LinearRing.ts
+  var isLinearRing = all(
+    isArrayOfType(isPosition),
+    isArrayOfSize(4),
+    (value) => value[value.length - 1].every((v, i) => v === value[0][i])
+  );
+  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 = all(isLinearRing);
+  var isStrictExteriorRing = all(
+    isStrictLinearRing,
+    isCounterClockwiseWinding
+  );
+
+  // source/Domain/GeoJSON/Concept/InteriorRing.ts
+  var isInteriorRing = all(isLinearRing);
+  var isStrictInteriorRing = all(
+    isStrictLinearRing,
+    isClockwiseWinding
+  );
+
+  // source/Domain/GeoJSON/Geometry/Polygon.ts
+  var isPolygonCoordinates = all(isArrayOfType(isLinearRing));
+  var isPolygon = isGeometryObject(
+    "Polygon",
+    isPolygonCoordinates
+  );
+  var isStrictPolygonCoordinates = all(
+    isArrayOfType(isStrictLinearRing),
+    (value) => isExteriorRing(value[0]),
+    (value) => value.slice(1).every(isInteriorRing)
+  );
+  var isStrictPolygon = isGeometryObject(
+    "Polygon",
+    isStrictPolygonCoordinates
+  );
+
+  // source/Domain/GeoJSON/Geometry/MultiPolygon.ts
+  var isMultiPolygonCoordinates = isArrayOfType(isPolygonCoordinates);
+  var isMultiPolygon = isGeometryObject(
+    "MultiPolygon",
+    isMultiPolygonCoordinates
+  );
+  var isStrictMultiPolygonCoordinates = isArrayOfType(
+    isStrictPolygonCoordinates
+  );
+  var isStrictMultiPolygon = isGeometryObject(
+    "MultiPolygon",
+    isStrictMultiPolygonCoordinates
+  );
+
+  // source/Domain/GeoJSON/Geometry.ts
+  var isGeometry = any(
+    isPoint,
+    isMultiPoint,
+    isLineString,
+    isMultiLineString,
+    isPolygon,
+    isMultiPolygon
+  );
+  var isStrictGeometry = any(
+    isStrictPoint,
+    isStrictMultiPoint,
+    isStrictLineString,
+    isStrictMultiLineString,
+    isStrictPolygon,
+    isStrictMultiPolygon
+  );
+
+  // source/Domain/GeoJSON/GeometryCollection.ts
+  var isGeometryCollectionObject = all(
+    isGeoJSONObject("GeometryCollection"),
+    isKeyOfType(
+      "geometries",
+      isArrayOfType(any(isGeometry, isGeometryCollection))
+    )
+  );
+  var isStrictGeometryCollectionObject = all(
+    isGeoJSONObject("GeometryCollection"),
+    isKeyOfType(
+      "geometries",
+      isArrayOfType(any(isStrictGeometry, isStrictGeometryCollection))
+    )
+  );
+  function isGeometryCollection(value) {
+    return isGeometryCollectionObject(value);
+  }
+  function isStrictGeometryCollection(value) {
+    return isStrictGeometryCollectionObject(value);
+  }
+
+  // source/Domain/GeoJSON/Feature.ts
+  var isFeature = all(
+    isGeoJSONObject("Feature"),
+    isStructure({
+      geometry: any(isGeometry, isGeometryCollection),
+      properties: any(isNULL, isObject)
+    })
+  );
+  var isStrictFeature = all(
+    isGeoJSONObject("Feature"),
+    isStructure({
+      geometry: any(isStrictGeometry, isStrictGeometryCollection),
+      properties: any(isNULL, isObject)
+    })
+  );
+
+  // source/Domain/GeoJSON/FeatureCollection.ts
+  var isFeatureCollection = all(
+    isGeoJSONObject("FeatureCollection"),
+    isKeyOfType("features", isArrayOfType(isFeature))
+  );
+  var isStrictFeatureCollection = all(
+    isGeoJSONObject("FeatureCollection"),
+    isKeyOfType("features", isArrayOfType(isStrictFeature))
+  );
+
+  // source/Domain/GeoJSON/GeoJSON.ts
+  var isGeoJSON = any(
+    isGeometry,
+    isGeometryCollection,
+    isFeature,
+    isFeatureCollection
+  );
+  var isStrictGeoJSON = any(
+    isStrictGeometry,
+    isStrictGeometryCollection,
+    isStrictFeature,
+    isStrictFeatureCollection
+  );
+
+  // source/Domain/Iterator/SimpleGeometry.ts
+  var reducers = {
+    *MultiPoint({ coordinates, ...rest }, unwrap) {
+      for (const pair of coordinates) {
+        yield* unwrap({
+          coordinates: pair,
+          ...rest,
+          type: "Point"
+        });
+      }
+    },
+    *MultiLineString({ coordinates, ...rest }, unwrap) {
+      for (const pair of coordinates) {
+        yield* unwrap({
+          coordinates: pair,
+          ...rest,
+          type: "LineString"
+        });
+      }
+    },
+    *MultiPolygon({ coordinates, ...rest }, unwrap) {
+      for (const pair of coordinates) {
+        yield* unwrap({
+          coordinates: pair,
+          ...rest,
+          type: "Polygon"
+        });
+      }
+    },
+    *GeometryCollection({ geometries: geometries3 }, unwrap) {
+      for (const geometry of geometries3) {
+        yield* unwrap(geometry);
+      }
+    },
+    *Feature({ geometry }, unwrap) {
+      yield* unwrap(geometry);
+    },
+    *FeatureCollection({ features }, unwrap) {
+      for (const { geometry } of features) {
+        yield* unwrap(geometry);
+      }
+    }
+  };
+  var SimpleGeometryIterator = class {
+    constructor(...inputs) {
+      this.inputs = [];
+      this.inputs = inputs;
+    }
+    /**
+     * Generator yielding all SimpleGeometry objects from the provided GeoJSON structure(s)
+     *
+     * @return {*}  {Iterator<SimpleGeometry>}
+     * @memberof SimpleGeometryIterator
+     */
+    *[Symbol.iterator]() {
+      for (const input of this.inputs) {
+        for (const simple of this.unwrap(input)) {
+          yield simple;
+        }
+      }
+    }
+    /**
+     * unwrap any GeoJSON object into one or more SimpleGeometry object
+     *
+     * @private
+     * @param {GeoJSON} geo
+     * @return {*}  {Iterable<SimpleGeometry>}
+     * @memberof SimpleGeometryIterator
+     */
+    *unwrap(geo) {
+      geo.type in reducers ? yield* reducers[geo.type](
+        geo,
+        (g) => this.unwrap(g)
+      ) : yield geo;
+    }
+  };
+
+  // source/Domain/Iterator/IterablePair.ts
+  var IterablePairIterator = class {
+    /**
+     * Constructs a new instance of IterablePairIterator
+     *
+     * @param iterators
+     */
+    constructor(...iterators) {
+      this.iterators = [];
+      this.iterators = iterators;
+    }
+    /**
+     * Generator yielding all value pairs from the provided iterators
+     *
+     * @return {*}  {Iterator<[T, T]>}
+     * @memberof IterablePairIterator
+     */
+    *[Symbol.iterator]() {
+      for (const [a, b] of this.pairs(this.iterators)) {
+        for (const one of a) {
+          for (const two of b) {
+            yield [one, two];
+          }
+        }
+      }
+    }
+    /**
+     * Create unique Iterator<T> combinations to traverse over
+     *
+     * @private
+     * @param {Array<Iterable<T>>} source
+     * @return {*}  {Array<[Iterable<T>, Iterable<T>]>}
+     * @memberof IterablePairIterator
+     */
+    pairs(source) {
+      return source.flatMap(
+        (a, i) => source.slice(i + 1).map((b) => [a, b])
+      );
+    }
+  };
+
+  // source/Domain/Utility/Box.ts
+  function* positions(coordinates) {
+    if (typeof coordinates[0] === "number") {
+      yield coordinates;
+    } else {
+      for (const child of coordinates) {
+        yield* positions(child);
+      }
+    }
+  }
+  function boxFromPositions(source) {
+    let minLon = Infinity, minLat = Infinity, maxLon = -Infinity, maxLat = -Infinity;
+    for (const [lon, lat] of source) {
+      if (lon < minLon) minLon = lon;
+      if (lat < minLat) minLat = lat;
+      if (lon > maxLon) maxLon = lon;
+      if (lat > maxLat) maxLat = lat;
+    }
+    return [minLon, minLat, maxLon, maxLat];
+  }
+  function createBoxFromCoordinates(coordinates) {
+    return boxFromPositions(positions(coordinates));
+  }
+  function isWithinBox([lon, lat], [minLon, minLat, maxLon, maxLat]) {
+    return lon >= minLon && lon <= maxLon && lat >= minLat && lat <= maxLat;
+  }
+
+  // source/Domain/Utility/Calculate.ts
+  var D2R = 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;
+  }
+  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;
+  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);
+    }
+  };
+  function getClosestPointOnLineByPoint(point, line) {
+    const [[px, py], [ax, ay], [bx, by]] = [point, ...line];
+    const [abx, aby] = [bx - ax, by - ay];
+    const [apx, apy] = [px - ax, py - ay];
+    const t = constrain(
+      (apx * abx + apy * aby) / (abx * abx + aby * aby),
+      0,
+      1
+    );
+    return t === 0 || t === 1 ? line[t] : [ax + abx * t, ay + aby * t];
+  }
+  function getDistanceOfPointToPoint(a, b, calculation) {
+    const calc = typeof calculation === "function" ? calculation : PointToPoint[calculation];
+    if (typeof calc === "function") {
+      return calc(a, b);
+    }
+    throw new Error(`Not a PointToPoint calculation function ${calculation}`);
+  }
+  function getDistanceOfPointToLine(point, line, calculation) {
+    return getDistanceOfPointToPoint(
+      point,
+      getClosestPointOnLineByPoint(point, line),
+      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 isLinesCrossing(a, b) {
+    const [[a1x, a1y], [a2x, a2y]] = a;
+    const [[b1x, b1y], [b2x, b2y]] = b;
+    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);
+    return s >= 0 && s <= 1 && t >= 0 && t <= 1;
+  }
+  function isPointOnLine(point, line, threshold = 1e-14) {
+    return getDistanceOfPointToLine(point, line, "cartesian") < threshold;
+  }
+  function isPointInRing(p, ring) {
+    if (!isWithinBox(p, createBoxFromCoordinates(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]
+      ) : odd2;
+    }, 0);
+    return odd !== 0 || ring.slice(1).some((a, index) => isPointOnLine(p, [ring[index], a]));
+  }
+
+  // source/Domain/Utility/Segments.ts
+  function segments(line) {
+    return line.slice(1).map((point, index) => [line[index], point]);
+  }
+
+  // source/Domain/Utility/Distance.ts
+  var geometries = {
+    PointPoint(a, b, calculation) {
+      return getDistanceOfPointToPoint(a, b, calculation);
+    },
+    LineStringPoint(a, b, calculation) {
+      return Math.min(
+        ...segments(a).map(
+          (line) => getDistanceOfPointToLine(b, line, calculation)
+        )
+      );
+    },
+    LineStringLineString(a, b, calculation) {
+      const sa = segments(a);
+      const sb = segments(b);
+      return sa.reduce(
+        (carry, a2) => sb.reduce(
+          (carry2, b2) => carry2 > 0 ? Math.min(
+            carry2,
+            getDistanceOfLineToLine(a2, b2, calculation)
+          ) : carry2,
+          carry
+        ),
+        Infinity
+      );
+    },
+    PolygonPoint([exterior, ...interior], b, calculation) {
+      if (isPointInRing(b, exterior)) {
+        const [excluded] = interior.filter(
+          (ring) => isPointInRing(b, ring)
+        );
+        return excluded ? this.LineStringPoint(excluded, b, calculation) : 0;
+      }
+      return this.LineStringPoint(exterior, b, 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;
+      return ring ? Math.min(
+        ...segments(ring).map(
+          (a2) => Math.min(
+            ...line.map(
+              (b2) => getDistanceOfLineToLine(a2, b2, calculation)
+            )
+          )
+        )
+      ) : 0;
+    },
+    PolygonPolygon(a, b, calculation) {
+      return Math.min(
+        this.PolygonLineString(a, b[0], calculation),
+        this.PolygonLineString(b, a[0], calculation)
+      );
+    }
+  };
+  function distance(a, b, calculation = "cartesian") {
+    const lookup = geometries;
+    return Math.min(
+      ...[
+        ...new IterablePairIterator(
+          new SimpleGeometryIterator(a),
+          new SimpleGeometryIterator(b)
+        )
+      ].map(([a2, b2]) => {
+        return a2.type + b2.type in lookup ? lookup[a2.type + b2.type](
+          a2.coordinates,
+          b2.coordinates,
+          calculation
+        ) : b2.type + a2.type in lookup ? lookup[b2.type + a2.type](
+          b2.coordinates,
+          a2.coordinates,
+          calculation
+        ) : Infinity;
+      })
+    );
+  }
+
+  // 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]);
+    },
+    LineStringPoint(a, b) {
+      return a.some((a2) => this.PointPoint(a2, b)) || segments(a).some((line) => isPointOnLine(b, line));
+    },
+    LineStringLineString(a, b) {
+      const lines = segments(b);
+      return segments(a).some(
+        (a2) => lines.some((b2) => isLinesCrossing(a2, b2))
+      );
+    },
+    PolygonPoint([exterior, ...interior], b) {
+      return (this.LineStringPoint(exterior, b) || isPointInRing(b, exterior)) && (!interior.length || interior.every((ring) => !isPointInRing(b, ring)));
+    },
+    PolygonLineString(a, b) {
+      return a.some((ring) => this.LineStringLineString(ring, b)) || b.some((point) => this.PolygonPoint(a, 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))
+      );
+    }
+  };
+  function intersect(a, b) {
+    const lookup = geometries2;
+    for (const [itA, itB] of new IterablePairIterator(
+      new SimpleGeometryIterator(a),
+      new SimpleGeometryIterator(b)
+    )) {
+      if (itA.type + itB.type in lookup && lookup[itA.type + itB.type](
+        itA.coordinates,
+        itB.coordinates
+      ) || itB.type + itA.type in lookup && lookup[itB.type + itA.type](itB.coordinates, itA.coordinates)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  return __toCommonJS(main_exports);
+})();
+//# sourceMappingURL=main.global.js.map