@konfirm/geojson 1.0.0 → 1.0.1

package/dist/main.mjs

@@ -0,0 +1,772 @@
+// source/Domain/GeoJSON/Concept/Position.ts
+import { any } from "@konfirm/guard";
+
+// source/Domain/Guards/Tuple.ts
+import { isArray } from "@konfirm/guard";
+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
+import { isNumber } from "@konfirm/guard";
+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/Feature.ts
+import { all as all9, any as any5, isNULL, isObject, isStructure as isStructure2 } from "@konfirm/guard";
+
+// source/Domain/GeoJSON/Concept/GeoJSONObject.ts
+import { all as all2, isString, isStructure } from "@konfirm/guard";
+
+// source/Domain/GeoJSON/Concept/BoundingBox.ts
+import { all, any as any2 } from "@konfirm/guard";
+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 = any2(
+  isBoundingBoxWithAltitude,
+  isBoundingBoxWithoutAltitude
+);
+var isStrictBoundingBox = any2(
+  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: all2(isString, (value) => value === type),
+      bbox: isBoundingBox
+    },
+    "bbox"
+  );
+}
+
+// source/Domain/GeoJSON/Geometry.ts
+import { any as any3 } from "@konfirm/guard";
+
+// source/Domain/GeoJSON/GeometryObject.ts
+import { all as all3, isKeyOfType } from "@konfirm/guard";
+function isGeometryObject(type, isCoordinates) {
+  return all3(
+    isGeoJSONObject(type),
+    isKeyOfType("coordinates", isCoordinates)
+  );
+}
+
+// source/Domain/GeoJSON/Geometry/MultiPoint.ts
+import { isArrayOfType } from "@konfirm/guard";
+
+// 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
+import { isArrayOfType as isArrayOfType2 } from "@konfirm/guard";
+var isMultiLineStringCoordinates = isArrayOfType2(
+  isLineStringCoordinates
+);
+var isMultiLineString = isGeometryObject(
+  "MultiLineString",
+  isMultiLineStringCoordinates
+);
+var isStrictMultiLineStringCoordinates = isArrayOfType2(
+  isStrictLineStringCoordinates
+);
+var isStrictMultiLineString = isGeometryObject(
+  "MultiLineString",
+  isStrictMultiLineStringCoordinates
+);
+
+// source/Domain/GeoJSON/Geometry/MultiPolygon.ts
+import { isArrayOfType as isArrayOfType6 } from "@konfirm/guard";
+
+// source/Domain/GeoJSON/Geometry/Polygon.ts
+import { all as all7, isArrayOfType as isArrayOfType5 } from "@konfirm/guard";
+
+// source/Domain/GeoJSON/Concept/ExteriorRing.ts
+import { all as all5 } from "@konfirm/guard";
+
+// source/Domain/Utility/Winding.ts
+import { isArrayOfType as isArrayOfType3 } from "@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);
+  }, 0);
+}
+var isPositionArray = isArrayOfType3(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
+import { all as all4, isArrayOfSize, isArrayOfType as isArrayOfType4 } from "@konfirm/guard";
+var isLinearRing = all4(
+  isArrayOfType4(isPosition),
+  isArrayOfSize(4),
+  (value) => value[value.length - 1].every((v, i) => v === value[0][i])
+);
+var isStrictLinearRing = all4(
+  isArrayOfType4(isStrictPosition),
+  isArrayOfSize(4),
+  (value) => value[value.length - 1].every((v, i) => v === value[0][i])
+);
+
+// source/Domain/GeoJSON/Concept/ExteriorRing.ts
+var isExteriorRing = all5(isLinearRing);
+var isStrictExteriorRing = all5(
+  isStrictLinearRing,
+  isCounterClockwiseWinding
+);
+
+// source/Domain/GeoJSON/Concept/InteriorRing.ts
+import { all as all6 } from "@konfirm/guard";
+var isInteriorRing = all6(isLinearRing);
+var isStrictInteriorRing = all6(
+  isStrictLinearRing,
+  isClockwiseWinding
+);
+
+// source/Domain/GeoJSON/Geometry/Polygon.ts
+var isPolygonCoordinates = all7(isArrayOfType5(isLinearRing));
+var isPolygon = isGeometryObject(
+  "Polygon",
+  isPolygonCoordinates
+);
+var isStrictPolygonCoordinates = all7(
+  isArrayOfType5(isStrictLinearRing),
+  (value) => isExteriorRing(value[0]),
+  (value) => value.slice(1).every(isInteriorRing)
+);
+var isStrictPolygon = isGeometryObject(
+  "Polygon",
+  isStrictPolygonCoordinates
+);
+
+// source/Domain/GeoJSON/Geometry/MultiPolygon.ts
+var isMultiPolygonCoordinates = isArrayOfType6(isPolygonCoordinates);
+var isMultiPolygon = isGeometryObject(
+  "MultiPolygon",
+  isMultiPolygonCoordinates
+);
+var isStrictMultiPolygonCoordinates = isArrayOfType6(
+  isStrictPolygonCoordinates
+);
+var isStrictMultiPolygon = isGeometryObject(
+  "MultiPolygon",
+  isStrictMultiPolygonCoordinates
+);
+
+// source/Domain/GeoJSON/Geometry.ts
+var isGeometry = any3(
+  isPoint,
+  isMultiPoint,
+  isLineString,
+  isMultiLineString,
+  isPolygon,
+  isMultiPolygon
+);
+var isStrictGeometry = any3(
+  isStrictPoint,
+  isStrictMultiPoint,
+  isStrictLineString,
+  isStrictMultiLineString,
+  isStrictPolygon,
+  isStrictMultiPolygon
+);
+
+// source/Domain/GeoJSON/GeometryCollection.ts
+import { all as all8, any as any4, isArrayOfType as isArrayOfType7, isKeyOfType as isKeyOfType2 } from "@konfirm/guard";
+var isGeometryCollectionObject = all8(
+  isGeoJSONObject("GeometryCollection"),
+  isKeyOfType2(
+    "geometries",
+    isArrayOfType7(any4(isGeometry, isGeometryCollection))
+  )
+);
+var isStrictGeometryCollectionObject = all8(
+  isGeoJSONObject("GeometryCollection"),
+  isKeyOfType2(
+    "geometries",
+    isArrayOfType7(any4(isStrictGeometry, isStrictGeometryCollection))
+  )
+);
+function isGeometryCollection(value) {
+  return isGeometryCollectionObject(value);
+}
+function isStrictGeometryCollection(value) {
+  return isStrictGeometryCollectionObject(value);
+}
+
+// source/Domain/GeoJSON/Feature.ts
+var isFeature = all9(
+  isGeoJSONObject("Feature"),
+  isStructure2({
+    geometry: any5(isGeometry, isGeometryCollection),
+    properties: any5(isNULL, isObject)
+  })
+);
+var isStrictFeature = all9(
+  isGeoJSONObject("Feature"),
+  isStructure2({
+    geometry: any5(isStrictGeometry, isStrictGeometryCollection),
+    properties: any5(isNULL, isObject)
+  })
+);
+
+// source/Domain/GeoJSON/FeatureCollection.ts
+import { all as all10, isArrayOfType as isArrayOfType8, isKeyOfType as isKeyOfType3 } from "@konfirm/guard";
+var isFeatureCollection = all10(
+  isGeoJSONObject("FeatureCollection"),
+  isKeyOfType3("features", isArrayOfType8(isFeature))
+);
+var isStrictFeatureCollection = all10(
+  isGeoJSONObject("FeatureCollection"),
+  isKeyOfType3("features", isArrayOfType8(isStrictFeature))
+);
+
+// source/Domain/GeoJSON/GeoJSON.ts
+import { any as any6 } from "@konfirm/guard";
+var isGeoJSON = any6(
+  isGeometry,
+  isGeometryCollection,
+  isFeature,
+  isFeatureCollection
+);
+var isStrictGeoJSON = any6(
+  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;
+}
+export {
+  SimpleGeometryIterator,
+  distance,
+  intersect,
+  isFeature,
+  isFeatureCollection,
+  isGeoJSON,
+  isGeometry,
+  isGeometryCollection,
+  isLineString,
+  isMultiLineString,
+  isMultiPoint,
+  isMultiPolygon,
+  isPoint,
+  isPolygon,
+  isPosition,
+  isStrictFeature,
+  isStrictFeatureCollection,
+  isStrictGeoJSON,
+  isStrictGeometry,
+  isStrictGeometryCollection,
+  isStrictLineString,
+  isStrictMultiLineString,
+  isStrictMultiPoint,
+  isStrictMultiPolygon,
+  isStrictPoint,
+  isStrictPolygon,
+  isStrictPosition
+};
+//# sourceMappingURL=main.mjs.map