@kalisio/common-geospatial 0.8.0 → 0.10.0

package/dist/index.mjs

@@ -1,1059 +1,102 @@
-import { assert as u, is as i, has as w, conform as E, optional as p } from "@kalisio/common-core";
-import { coordAll as R } from "@turf/meta";
-import { convex as de } from "@turf/convex";
-import { featureCollection as ve, feature as he } from "@turf/helpers";
-import { Heap as pe } from "heap-js";
-import Ee from "@turf/truncate";
-import ye from "@turf/boolean-clockwise";
-import Oe from "@turf/kinks";
-const d = {
-  LATITUDE: "LAT",
-  LONGITUDE: "LON",
-  ALTITUDE: "ALT"
-};
-function Te(e) {
-  return u.that(e, i.string, "axis must be a string"), Object.values(d).includes(e);
-}
-function k(e) {
-  return u.that(e, i.string, "axis must be a string"), e === d.LATITUDE;
-}
-function ne(e) {
-  return u.that(e, i.string, "axis must be a string"), e === d.LONGITUDE;
-}
-function Ot(e) {
-  return u.that(e, i.string, "axis must be a string"), e === d.ALTITUDE;
-}
-const Ie = { NORTH: { label: "Nord", symbol: "N" }, SOUTH: { label: "Sud", symbol: "S" }, EAST: { label: "Est", symbol: "E" }, WEST: { label: "Ouest", symbol: "O" } }, Le = {
-  DIRECTIONS: Ie
-}, Se = { NORTH: { label: "North", symbol: "N" }, SOUTH: { label: "South", symbol: "S" }, EAST: { label: "East", symbol: "E" }, WEST: { label: "West", symbol: "W" } }, be = {
-  DIRECTIONS: Se
-}, De = {
-  DIRECTIONS: {
-    NORTH: { label: i.string, symbol: i.char },
-    SOUTH: { label: i.string, symbol: i.char },
-    EAST: { label: i.string, symbol: i.char },
-    WEST: { label: i.string, symbol: i.char }
-  }
-}, I = {
-  en: be,
-  fr: Le
-};
-let S = "en";
-const z = "en";
-function Tt() {
-  return Object.keys(I);
-}
-function It(e, t) {
-  u.all([
-    { value: e, validator: i.string, message: "code must be a string" },
-    { value: e, validator: (n) => !w.key(I, n), message: "locale already registered" },
-    { value: t, validator: i.plainObject, message: "content must be an object" },
-    { value: t, validator: (n) => E.schema(n, De), message: "content does not conform to schema" }
-  ]), I[e] = t;
-}
-function Lt(e) {
-  u.all([
-    { value: e, validator: i.string, message: "code must be a string" },
-    { value: e, validator: (t) => w.key(I, t), message: "code is unknown" }
-  ]), S = e;
-}
-function Re() {
-  return S;
-}
-function B(e) {
-  return u.all([
-    { value: e, validator: i.string, message: "code must be a string" },
-    { value: e, validator: (t) => w.key(I, t), message: "code is unknown" }
-  ]), I[e];
-}
-function re() {
-  return S === z ? [S] : [S, z];
-}
-function H(e) {
-  const t = /* @__PURE__ */ new Set();
-  for (const n of re()) {
-    const { DIRECTIONS: r } = B(n);
-    for (const a of e) t.add(r[a].symbol);
-  }
-  return [...t];
-}
-function Ae() {
-  return H(["NORTH", "SOUTH"]);
-}
-function Me() {
-  return H(["EAST", "WEST"]);
-}
-function j() {
-  return H(["NORTH", "SOUTH", "EAST", "WEST"]);
-}
-function b() {
-  return B(Re()).DIRECTIONS;
-}
-function _(e, t) {
-  const n = t.toUpperCase();
-  return re().some((r) => {
-    const { label: a, symbol: s } = B(r).DIRECTIONS[e];
-    return n === a.toUpperCase() || n === s.toUpperCase();
-  });
-}
-function St(e = null) {
-  const t = b();
-  return i.defined(e) ? (u.that(e, Te, "axis must be a valid axis"), k(e) ? [t.SOUTH, t.NORTH] : ne(e) ? [t.EAST, t.WEST] : []) : [t.SOUTH, t.NORTH, t.EAST, t.WEST];
-}
-function bt() {
-  return b().NORTH;
-}
-function Dt() {
-  return b().SOUTH;
-}
-function Rt() {
-  return b().EAST;
-}
-function At() {
-  return b().WEST;
-}
-function O(e) {
-  return u.that(e, i.string, "dir must be a string"), Ce(e) || ie(e) || V(e) || $(e);
-}
-function Ce(e) {
-  return u.that(e, i.string, "dir must be a string"), _("NORTH", e);
-}
-function ie(e) {
-  return u.that(e, i.string, "dir must be a string"), _("SOUTH", e);
-}
-function V(e) {
-  return u.that(e, i.string, "dir must be a string"), _("EAST", e);
-}
-function $(e) {
-  return u.that(e, i.string, "dir must be a string"), _("WEST", e);
-}
-function Ne(e) {
-  return u.that(e, O, "dir must be a direction"), $(e) || V(e) ? d.LONGITUDE : d.LATITUDE;
-}
-const we = {
-  degrees: i.number,
-  direction: p(O)
-}, _e = /^(-?\d{1,3}(?:\.\d+)?)°?$/;
-function $e() {
-  return new RegExp(`^(\\d{1,3}(?:\\.\\d+)?)°?([${j()}])$`, "i");
-}
-function D(e) {
-  let t = null, n = null;
-  if (i.plainObject(e) && E.schema(e, we))
-    i.defined(e.direction) ? e.degrees >= 0 && (t = e.degrees, n = e.direction) : t = e.degrees;
-  else if (i.string(e)) {
-    const r = e.replace(/\s+/g, ""), a = r.match(_e) ?? r.match($e());
-    a && (t = parseFloat(a[1]), n = a[2] ?? null);
-  }
-  return {
-    get degrees() {
-      return t;
-    },
-    get direction() {
-      return n;
-    },
-    get format() {
-      return "DD";
-    },
-    isValid() {
-      return i.number(t);
-    },
-    toString(r) {
-      if (u.that(r, i.positiveInteger, "decimalPlaces must be a positive integer"), !this.isValid()) return "";
-      let a = `${t.toFixed(r)}°`;
-      return n && (a += ` ${n}`), a;
-    },
-    toDecimal() {
-      return this.isValid() ? D({ degrees: t, direction: n }) : null;
-    }
-  };
-}
-const Fe = {
-  degrees: i.integer,
-  minutes: (e) => i.inRangeExclusiveMax(e, 0, 60),
-  direction: p(O)
-}, xe = /^(-?\d{1,3})°(\d{1,2}(?:\.\d+)?)'?$/;
-function Ue() {
-  return new RegExp(`^(\\d{1,3})°(\\d{1,2}(?:\\.\\d+)?)'?([${j().join("")}])$`, "i");
-}
-function ae(e) {
-  let t = null, n = null, r = null;
-  if (i.plainObject(e) && E.schema(e, Fe))
-    i.defined(e.direction) ? e.degrees >= 0 && (t = e.degrees, n = e.minutes, r = e.direction) : (t = e.degrees, n = e.minutes);
-  else if (i.string(e)) {
-    const a = e.replace(/\s+/g, ""), s = a.match(xe) ?? a.match(Ue());
-    s && (t = parseFloat(s[1]), n = parseFloat(s[2]), r = s[3] ?? null);
-  }
-  return {
-    get degrees() {
-      return t;
-    },
-    get minutes() {
-      return n;
-    },
-    get direction() {
-      return r;
-    },
-    get format() {
-      return "DDM";
-    },
-    isValid() {
-      return i.integer(t) && i.inRangeExclusiveMax(n, 0, 60);
-    },
-    toString(a) {
-      if (u.that(a, i.positiveInteger, "decimalPlaces must be a positive integer"), !this.isValid()) return "";
-      let s = `${t}° ${n.toFixed(a)}'`;
-      return r && (s += ` ${r}`), s;
-    },
-    toDecimal() {
-      return this.isValid() ? D({ degrees: t + n / 60, direction: r }) : null;
-    }
-  };
-}
-const Ge = {
-  degrees: i.nonNegativeInteger,
-  minutes: (e) => i.inRangeExclusiveMax(e, 0, 60),
-  direction: O
-};
-function ke() {
-  return new RegExp(`^(\\d{2})(\\d{3})([${Ae().join("")}])$`, "i");
-}
-function Pe() {
-  return new RegExp(`^(\\d{3})(\\d{3})([${Me().join("")}])$`, "i");
-}
-function se(e) {
-  let t = null, n = null, r = null;
-  if (i.plainObject(e) && E.schema(e, Ge))
-    t = e.degrees, n = e.minutes, r = e.direction;
-  else if (i.string(e)) {
-    const a = e.trim(), s = a.match(ke()) ?? a.match(Pe());
-    s && (t = parseFloat(s[1]), n = parseFloat(s[2]) / 10, r = s[3]);
-  }
-  return {
-    get degrees() {
-      return t;
-    },
-    get minutes() {
-      return n;
-    },
-    get direction() {
-      return r;
-    },
-    get format() {
-      return "DDM_AERO";
-    },
-    isValid() {
-      return i.nonNegativeInteger(t) && i.inRangeExclusiveMax(n, 0, 60) && O(r);
-    },
-    toString() {
-      if (!this.isValid()) return "";
-      const a = V(r) || $(r), s = String(t).padStart(a ? 3 : 2, "0"), l = Math.floor(n * 10).toString().padStart(3, "0");
-      return `${s}${l}${r}`;
-    },
-    toDecimal() {
-      return this.isValid() ? D({ degrees: t + n / 60, direction: r }) : null;
-    }
-  };
-}
-const Be = {
-  degrees: i.integer,
-  minutes: (e) => i.integer(e) && i.inRange(e, 0, 59),
-  seconds: (e) => i.inRangeExclusiveMax(e, 0, 60),
-  direction: p(O)
-}, He = /^(-?\d{1,3})°(\d{1,2})'(\d{1,2}(?:\.\d+)?)"?$/;
-function je() {
-  return new RegExp(`^(\\d{1,3})°(\\d{1,2})'(\\d{1,2}(?:\\.\\d+)?)"?([${j().join("")}])$`, "i");
-}
-function oe(e) {
-  let t = null, n = null, r = null, a = null;
-  if (i.plainObject(e) && E.schema(e, Be))
-    i.defined(e.direction) ? e.degrees >= 0 && (t = e.degrees, n = e.minutes, r = e.seconds, a = e.direction) : (t = e.degrees, n = e.minutes, r = e.seconds);
-  else if (i.string(e)) {
-    const s = e.replace(/\s+/g, ""), l = s.match(He) ?? s.match(je());
-    l && (t = parseFloat(l[1]), n = parseFloat(l[2]), r = parseFloat(l[3]), a = l[4] ?? null);
-  }
-  return {
-    get degrees() {
-      return t;
-    },
-    get minutes() {
-      return n;
-    },
-    get seconds() {
-      return r;
-    },
-    get direction() {
-      return a;
-    },
-    get format() {
-      return "DMS";
-    },
-    isValid() {
-      return i.integer(t) && i.integer(n) && i.inRange(n, 0, 59) && i.inRangeExclusiveMax(r, 0, 60);
-    },
-    toString(s) {
-      if (u.that(s, i.positiveInteger, "decimalPlaces must be a positive integer"), !this.isValid()) return "";
-      let l = `${t}° ${n}' ${r.toFixed(s)}"`;
-      return a && (l += ` ${a}`), l;
-    },
-    toDecimal() {
-      return this.isValid() ? D({ degrees: t + n / 60 + r / 3600, direction: a }) : null;
-    }
-  };
-}
-function q(e) {
-  const t = Math.floor(e.degrees), n = (e.degrees - t) * 60;
-  return { degrees: t, minutes: n, direction: e.direction };
-}
-function Ve(e) {
-  const t = Math.floor(e.degrees), n = (e.degrees - t) * 60, r = Math.floor(n), a = (n - r) * 60;
-  return { degrees: t, minutes: r, seconds: a, direction: e.direction };
-}
-const Q = {
-  DD: (e) => (u.that(e, (t) => t.isValid(), "dd must be a valid coordinate"), e),
-  DDM: (e) => {
-    u.that(e, (a) => a.isValid(), "dd must be a valid coordinate");
-    const { degrees: t, minutes: n, direction: r } = q(e);
-    return ae(r ? { degrees: t, minutes: n, direction: r } : { degrees: t, minutes: n });
-  },
-  DMS: (e) => {
-    u.that(e, (s) => s.isValid(), "dd must be a valid coordinate");
-    const { degrees: t, minutes: n, seconds: r, direction: a } = Ve(e);
-    return oe(a ? { degrees: t, minutes: n, seconds: r, direction: a } : { degrees: t, minutes: n, seconds: r });
-  },
-  DDM_AERO: (e) => {
-    u.that(e, (a) => a.isValid(), "dd must be a valid coordinate");
-    const { degrees: t, minutes: n, direction: r } = q(e);
-    return se({ degrees: t, minutes: n, direction: r });
-  }
-}, P = {
-  DD: "DD",
-  DDM: "DDM",
-  DDM_AERO: "DDM_AERO",
-  DMS: "DMS"
-}, Ye = {
-  DD: D,
-  DDM: ae,
-  DDM_AERO: se,
-  DMS: oe
-}, Y = Array.from({ length: 9 }, (e, t) => 10 ** t);
-function Z(e, t) {
-  if (u.that(e, i.number, "coord must be a number"), i.defined(t))
-    return u.that(t, O, "dir must be a direction"), Ne(t);
-  if (Math.abs(e) > 90) return d.LONGITUDE;
-}
-function J(e) {
-  u.that(e, i.number, "coord must be a number");
-  const t = e.toExponential(), [n, r] = t.split("e").map(Number), a = (n.toString().split(".")[1] || "").length;
-  return Math.max(0, a - r);
-}
-function Mt(e, t = 7) {
-  u.all([
-    { value: e, validator: i.number, message: "coord must be a number" },
-    { value: t, validator: (r) => i.inRange(r, 0, 8), message: "precision must be in range [0, 8]" }
-  ]);
-  const n = Y[t];
-  return Math.round(e * n) / n;
-}
-function Ct(e, t) {
-  if (u.all([
-    { value: e, validator: i.number, message: "coord must be a number" },
-    { value: t, validator: (r) => ne(r) || k(r), message: "axis must be either a longitude or latitude" }
-  ]), k(t))
-    return Math.max(-90, Math.min(90, e));
-  let n = ((e + 180) % 360 + 360) % 360 - 180;
-  return n === -180 && (n = 180), Object.is(n, -0) && (n = 0), n;
-}
-function Nt(e, t) {
-  u.all([
-    { value: e, validator: (r) => i.defined(r) && r.isValid(), message: "from must be a valid coordinate" },
-    { value: t, validator: (r) => w.key(Q, r), message: `unknown format: ${t}` }
-  ]);
-  const n = e.format === P.DD ? e : e.toDecimal();
-  return n.isValid() ? t === P.DD ? n : Q[t](n) : null;
-}
-function We(e) {
-  u.that(e, i.nonEmptyString, "pattern must be a non empty string");
-  for (const t of Object.keys(P)) {
-    const n = Ye[t](e);
-    if (n.isValid()) return n;
-  }
-  return null;
-}
-function wt(e) {
-  u.that(e, (o) => i.nonEmptyString(o), "pattern must be a non-empty string");
-  const t = e.split(/[,;|]/);
-  if (t.length !== 2) return null;
-  const [n, r] = t.map(We);
-  if (!n || !r) return null;
-  const a = n.toDecimal(), s = r.toDecimal(), l = Z(a.degrees, a.direction), m = Z(s.degrees, s.direction), c = (o) => {
-    const { degrees: v, direction: f } = o;
-    return f && ($(f) || ie(f)) ? -v : v;
-  };
-  if (l === d.LONGITUDE && m === d.LATITUDE) return [c(a), c(s)];
-  if (m === d.LONGITUDE && l === d.LATITUDE) return [c(s), c(a)];
-  if (l === d.LONGITUDE && !m) return [c(a), s];
-  if (l === d.LATITUDE && !m) return [c(s), c(a)];
-  if (m === d.LONGITUDE && !l) return [c(s), c(a)];
-  if (m === d.LATITUDE && !l) return [c(a), c(s)];
-  if (!l && !m)
-    return [
-      [c(a), c(s)],
-      [c(s), c(a)]
-    ];
-}
-function y(e) {
-  return !(!i.arrayOfLengthBetween(e, 2, 3) || !i.number(e[0]) || !i.number(e[1]) || !i.inRange(e[0], -180, 180) || !i.inRange(e[1], -90, 90) || e.length === 3 && !i.number(e[2]));
-}
-function Xe(e) {
-  return u.that(e, y, "position must be a valid position"), i.arrayOfLength(e, 3);
-}
-const Ke = {
-  precision: p(i.number),
-  consider3D: p(i.boolean)
-};
-function _t(e, t, n = {}) {
-  u.all([
-    {
-      value: e,
-      validator: y,
-      message: "position1 must be a valid position"
-    },
-    {
-      value: t,
-      validator: y,
-      message: "position2 must be a valid position"
-    },
-    {
-      value: n,
-      validator: (l) => E.schema(l, Ke),
-      message: "options must be a valid options object"
-    }
-  ]);
-  const { precision: r = 10, consider3D: a = !1 } = n, s = a ? Math.max(e.length, t.length) : 2;
-  return Array.from(
-    { length: s },
-    (l, m) => (e[m] ?? 0).toFixed(r) === (t[m] ?? 0).toFixed(r)
-  ).every(Boolean);
-}
-function $t(e, t = 7) {
-  u.all([
-    { value: e, validator: y, message: "position must be a position" },
-    { value: t, validator: (r) => i.inRange(r, 0, 8), message: "precision must be in range [0, 8]" }
-  ]);
-  const n = Y[t];
-  for (let r = 0; r < e.length; r++)
-    e[r] = Math.round(e[r] * n) / n;
-  return e;
-}
-function A(e) {
-  if (!i.arrayOfLength(e, 4) && !i.arrayOfLength(e, 6)) return !1;
-  const t = e.length === 4, n = t ? [e[0], e[1]] : [e[0], e[1], e[2]], r = t ? [e[2], e[3]] : [e[3], e[4], e[5]];
-  if (!y(n) || !y(r)) return !1;
-  const [, a] = n, [, s] = r;
-  return !(a > s || !t && e[2] > e[5]);
-}
-function ee(e) {
-  return u.that(e, A, "bbox must be a valid bounding-box"), i.arrayOfLength(e, 6);
-}
-function Ft(e, t) {
-  return u.all([
-    { value: e, validator: A, message: "bbox1 must be a valid bounding-box" },
-    { value: t, validator: A, message: "bbox2 must be a valid bounding-box" }
-  ]), ee(e) && ee(t) ? [
-    Math.min(e[0], t[0]),
-    Math.min(e[1], t[1]),
-    Math.min(e[2], t[2]),
-    Math.max(e[3], t[3]),
-    Math.max(e[4], t[4]),
-    Math.max(e[5], t[5])
-  ] : [
-    Math.min(e[0], t[0]),
-    Math.min(e[1], t[1]),
-    Math.max(e[2], t[2]),
-    Math.max(e[3], t[3])
-  ];
-}
-const ze = {
-  ignore3D: p(i.boolean)
-};
-function x(e, t = {}) {
-  u.all([
-    {
-      value: e,
-      validator: i.nonEmptyArray,
-      message: "positions must be a non-empty array"
-    },
-    {
-      value: e,
-      validator: (a) => a.every(y),
-      message: "positions must be an array of valid positions"
-    },
-    {
-      value: t,
-      validator: (a) => E.schema(a, ze),
-      message: "options must be a valid options object"
-    }
-  ]);
-  const { ignore3D: n = !1 } = t;
-  return !n && e.some(Xe) ? e.reduce((a, s) => [
-    Math.min(a[0], s[0]),
-    Math.min(a[1], s[1]),
-    Math.min(a[2], s[2] ?? 0),
-    Math.max(a[3], s[0]),
-    Math.max(a[4], s[1]),
-    Math.max(a[5], s[2] ?? 0)
-  ], [1 / 0, 1 / 0, 1 / 0, -1 / 0, -1 / 0, -1 / 0]) : e.reduce((a, s) => [
-    Math.min(a[0], s[0]),
-    Math.min(a[1], s[1]),
-    Math.max(a[2], s[0]),
-    Math.max(a[3], s[1])
-  ], [1 / 0, 1 / 0, -1 / 0, -1 / 0]);
-}
-function ue(e, t = 7) {
-  u.all([
-    { value: e, validator: A, message: "bbox must be a valid bounding box" },
-    { value: t, validator: (r) => i.inRange(r, 0, 8), message: "precision must be in range [0, 8]" }
-  ]);
-  const n = Y[t];
-  for (let r = 0; r < e.length; r++)
-    e[r] = Math.round(e[r] * n) / n;
-  return e;
-}
-const M = {
-  NAME: "name",
-  LINK: "link"
-};
-function xt(e) {
-  return i.plainObject(e) ? e.type === M.NAME ? i.nonEmptyString(e.properties?.name) : e.type === M.LINK ? i.nonEmptyString(e.properties?.href) : !1 : !1;
-}
-function Ut(e) {
-  return i.arrayOfLengthBetween(e, 2, 3) ? e.every(i.number) : !1;
-}
-function Gt(e) {
-  return !i.arrayOfLength(e, 4) && !i.arrayOfLength(e, 6) ? !1 : e.every(i.number);
-}
-const g = {
-  POINT: "Point",
-  MULTI_POINT: "MultiPoint",
-  LINESTRING: "LineString",
-  MULTI_LINESTRING: "MultiLineString",
-  POLYGON: "Polygon",
-  MULTI_POLYGON: "MultiPolygon",
-  GEOMETRY_COLLECTION: "GeometryCollection"
-};
-function qe(e) {
-  return !i.plainObject(e) || !i.oneOf(e.type, Object.values(g)) ? !1 : e.type === g.GEOMETRY_COLLECTION ? i.array(e.geometries) : i.array(e.coordinates);
-}
-const h = {
-  FEATURE: "Feature",
-  FEATURE_COLLECTION: "FeatureCollection"
-};
-function Qe(e) {
-  return i.plainObject(e) && e.type === h.FEATURE;
-}
-function Ze(e) {
-  return i.plainObject(e) && e.type === h.FEATURE_COLLECTION && i.array(e.features);
-}
-function Je(e) {
-  return Qe(e) || Ze(e);
-}
-function F(e) {
-  return Je(e) || qe(e);
-}
-const et = {
-  ignore3D: p(i.boolean)
-};
-function kt(e, t = {}) {
-  if (u.all([
-    { value: e, validator: F, message: "geoJson must be a GeoJson object" },
-    { value: t, validator: (n) => E.schema(n, et), message: "options must be a valid options object" }
-  ]), e.type === h.FEATURE)
-    return e.geometry ? x(R(e.geometry), t) : null;
-  if (e.type === h.FEATURE_COLLECTION) {
-    const n = R(e);
-    return n.length ? x(n, t) : null;
-  }
-  return x(R(e), t);
-}
-function tt(e) {
-  if (e.length === 0) return null;
-  if (e.length === 1) return { type: "Point", coordinates: e[0] };
-  if (e.length === 2) return { type: "LineString", coordinates: [e[0], e[1]] };
-  const t = de(ve(e.map((n) => he({ type: "Point", coordinates: n }))));
-  return t ? t.geometry : { type: "LineString", coordinates: [e[0], e[e.length - 1]] };
-}
-function nt(e) {
-  if (u.that(e, F, "geoJson must be a GeoJson object"), e.type === h.FEATURE)
-    return e.geometry ? nt(e.geometry) : null;
-  const t = R(e).map((n) => [n[0], n[1]]);
-  return tt(t);
-}
-function rt(e, t, n) {
-  return Math.abs(
-    (e[0] * (t[1] - n[1]) + t[0] * (n[1] - e[1]) + n[0] * (e[1] - t[1])) / 2
-  );
-}
-function U(e, { tolerance: t = 0, getWeight: n = () => 1 } = {}) {
-  if (e.length <= 2) return e;
-  const r = e.map((o, v) => ({ coord: o, i: v, area: 1 / 0, removed: !1, prev: null, next: null }));
-  for (let o = 0; o < r.length; o++)
-    o > 0 && (r[o].prev = r[o - 1]), o < r.length - 1 && (r[o].next = r[o + 1]);
-  const a = (o) => !o.prev || !o.next ? 1 / 0 : rt(o.prev.coord, o.coord, o.next.coord) * n(o.coord, o.i), s = new pe((o, v) => o.area - v.area);
-  for (let o = 1; o < r.length - 1; o++)
-    r[o].area = a(r[o]), r[o]._currentArea = r[o].area, s.push(r[o]);
-  let l = 0;
-  for (; s.size() > 0; ) {
-    const o = s.pop();
-    if (!o.removed && o.area === o._currentArea) {
-      if (o.area < l ? o.area = l : l = o.area, o.area >= t) break;
-      o.removed = !0, o.prev && (o.prev.next = o.next), o.next && (o.next.prev = o.prev), o.prev?.prev && (o.prev.area = a(o.prev), o.prev._currentArea = o.prev.area, s.push(o.prev)), o.next?.next && (o.next.area = a(o.next), o.next._currentArea = o.next.area, s.push(o.next));
-    }
-  }
-  const m = [];
-  let c = r[0];
-  for (; c; )
-    c.removed || m.push(c.coord), c = c.next;
-  return m;
-}
-const it = {
-  tolerance: p(i.number),
-  getWeight: p(i.function)
-};
-function G(e, t = {}) {
-  if (u.all([
-    { value: e, validator: F, message: "geoJson must be a GeoJson object" },
-    { value: t, validator: (n) => E.schema(n, it), message: "options must be a valid options object" }
-  ]), e.type === h.FEATURE)
-    return e.geometry && G(e.geometry, t), e;
-  if (e.type === h.FEATURE_COLLECTION) {
-    for (const n of e.features) G(n, t);
-    return e;
-  }
-  switch (e.type) {
-    case g.LINESTRING:
-      e.coordinates = U(e.coordinates, t);
-      break;
-    case g.POLYGON:
-    case g.MULTI_LINESTRING:
-      e.coordinates = e.coordinates.map((n) => U(n, t));
-      break;
-    case g.MULTI_POLYGON:
-      e.coordinates = e.coordinates.map((n) => n.map((r) => U(r, t)));
-      break;
-    case g.GEOMETRY_COLLECTION:
-      e.geometries.forEach((n) => G(n, t));
-      break;
-  }
-  return e;
-}
-function le(e, t = 7) {
-  const n = Ee(e, { precision: t, mutate: !0 });
-  return n.bbox && ue(n.bbox, t), n;
-}
-function ce(e, t) {
-  if (e.type === h.FEATURE)
-    e.geometry && le(e.geometry, t);
-  else
-    for (const n of e.features) ce(n, t);
-  return e.bbox && ue(e.bbox, t), e;
-}
-function Pt(e, t = 7) {
-  return u.all([
-    { value: e, validator: F, message: "geoJson must be a valid GeoJson" },
-    { value: t, validator: (n) => i.inRange(n, 0, 8), message: "precision must be in range [0, 8]" }
-  ]), i.oneOf(e.type, Object.values(g)) ? le(e, t) : ce(e, t);
-}
-function C(e) {
-  if (!i.arrayOfLengthBetween(e, 2, 3))
-    return {
-      valid: !1,
-      errors: [{ message: "Invalid coordinates: must be an array of 2 or 3 coordinates" }],
-      warnings: []
-    };
-  if (!i.number(e[0]) || !i.number(e[1]))
-    return {
-      valid: !1,
-      errors: [{ message: "Invalid coordinates: longitude and latitude must be numbers" }],
-      warnings: []
-    };
-  if (!i.inRange(e[0], -180, 180))
-    return {
-      valid: !1,
-      errors: [{ message: "Invalid coordinates: longitude must be in the range -180 to 180" }],
-      warnings: []
-    };
-  if (!i.inRange(e[1], -90, 90))
-    return {
-      valid: !1,
-      errors: [{ message: "Invalid coordinates: latitude must be in the range -90 to 90" }],
-      warnings: []
-    };
-  if (e.length === 3 && !i.number(e[2]))
-    return {
-      valid: !1,
-      errors: [{ message: "Invalid coordinates: altitude must be a number" }],
-      warnings: []
-    };
-  const t = { valid: !0, errors: [], warnings: [] }, n = J(e[0]);
-  n > 6 && t.warnings.push({ message: `longitude precision is high (${n} decimals, max recommended: 6)` });
-  const r = J(e[1]);
-  return r > 6 && t.warnings.push({ message: `latitude precision is high (${r} decimals, max recommended: 6)` }), t;
-}
-function at(e) {
-  if (!i.arrayOfLength(e, 4) && !i.arrayOfLength(e, 6))
-    return {
-      valid: !1,
-      errors: [{ message: "Invalid bbox: must be an array of 4 (2D) or 6 (3D) numbers" }],
-      warnings: []
-    };
-  const t = e.length === 4, n = t ? [e[0], e[1]] : [e[0], e[1], e[2]], r = t ? [e[2], e[3]] : [e[3], e[4], e[5]], a = C(n);
-  if (!a.valid)
-    return {
-      valid: !1,
-      errors: a.errors.map((f) => ({ ...f, message: `Invalid bbox south-west: ${f.message}` })),
-      warnings: []
-    };
-  const s = C(r);
-  if (!s.valid)
-    return {
-      valid: !1,
-      errors: s.errors.map((f) => ({ ...f, message: `Invalid bbox north-east: ${f.message}` })),
-      warnings: []
-    };
-  const [l, m] = n, [c, o] = r;
-  if (m > o)
-    return {
-      valid: !1,
-      errors: [{ message: `Invalid bbox: south (${m}) must be <= north (${o})` }],
-      warnings: []
-    };
-  if (!t) {
-    const f = e[2], K = e[5];
-    if (f > K)
-      return {
-        valid: !1,
-        errors: [{ message: `Invalid bbox: min altitude (${f}) must be <= max altitude (${K})` }],
-        warnings: []
-      };
-  }
-  const v = { valid: !0, errors: [], warnings: [] };
-  return l > c && v.warnings.push({ message: `bbox crosses the antimeridian (west: ${l} > east: ${c})` }), v.warnings.push(...a.warnings.map((f) => ({ ...f, message: `south-west: ${f.message}` }))), v.warnings.push(...s.warnings.map((f) => ({ ...f, message: `north-east: ${f.message}` }))), v;
-}
-function st(e) {
-  if (!i.plainObject(e))
-    return {
-      valid: !1,
-      errors: [{ message: "Invalid crs: must be an object" }],
-      warnings: []
-    };
-  switch (e.type) {
-    case M.NAME:
-      return i.nonEmptyString(e.properties?.name) ? { valid: !0, errors: [], warnings: [] } : {
-        valid: !1,
-        errors: [{ message: "Invalid crs: linked crs must have a non-empty properties.name string" }],
-        warnings: []
-      };
-    case M.LINK:
-      return i.nonEmptyString(e.properties?.href) ? { valid: !0, errors: [], warnings: [] } : {
-        valid: !1,
-        errors: [{ message: "Invalid crs: linked crs must have a non-empty properties.href string" }],
-        warnings: []
-      };
-    default:
-      return {
-        valid: !1,
-        errors: [{ message: `Invalid crs: unknown type: ${e.type}` }],
-        warnings: []
-      };
-  }
-}
-function T() {
-  return { Feature: 0, FeatureCollection: 0, geometries: {} };
-}
-function ot(...e) {
-  const t = T();
-  for (const n of e) {
-    const r = n.statistics;
-    if (r) {
-      t.Feature += r.Feature ?? 0, t.FeatureCollection += r.FeatureCollection ?? 0;
-      for (const [a, s] of Object.entries(r.geometries ?? {}))
-        t.geometries[a] = (t.geometries[a] ?? 0) + s;
-    }
-  }
-  return t;
-}
-function L(e, t, n = "") {
-  const r = {
-    valid: !0,
-    errors: [],
-    warnings: [],
-    statistics: T()
-  };
-  for (let a = 0; a < e.length; a++) {
-    const s = `${n}/${a}`, l = t(e[a], s, a);
-    if (l.statistics && (r.statistics = ot(r, l)), !l.valid) {
-      r.valid = !1, r.errors = r.errors.concat(l.errors.map((m) => ({ ...m, path: m.path || s, index: a })));
-      continue;
-    }
-    i.empty(l.warnings) || (r.warnings = r.warnings.concat(l.warnings.map((m) => ({ ...m, path: m.path || s, index: a }))));
-  }
-  return r;
-}
-function te(e, t) {
-  if (!i.defined(e.crs)) return t;
-  const n = st(e.crs);
-  return n.valid || (t.valid = !1, t.errors.push(...n.errors.map((r) => ({ ...r, path: "/crs" })))), t.warnings.push(...n.warnings.map((r) => ({ ...r, path: "/crs" }))), t;
-}
-function N(e, t, n = "") {
-  if (!i.defined(e.bbox)) return t;
-  const r = at(e.bbox);
-  return r.valid || (t.valid = !1, t.errors.push(...r.errors.map((a) => ({ ...a, path: `${n}/bbox` })))), t.warnings.push(...r.warnings.map((a) => ({ ...a, path: `${n}/bbox` }))), t;
-}
-function W(e, t = 0, n = "") {
-  return i.arrayOfLengthAtLeast(e, t) ? L(e, C, n) : {
-    valid: !1,
-    errors: [{ message: `Invalid coordinates: must have at least ${t} positions`, path: n }],
-    warnings: []
-  };
-}
-function me(e, t = "") {
-  const n = W(e, 2, t);
-  if (!n.valid) return n;
-  for (let r = 0; r < e.length - 1; r++) {
-    const a = e[r][0], s = e[r + 1][0];
-    Math.abs(s - a) > 180 && n.warnings.push({
-      message: `LineString crosses the antimeridian between positions ${r} and ${r + 1}, consider using MultiLineString`,
-      path: `${t}/${r}`
-    });
-  }
-  return n;
-}
-function ut(e, t = "") {
-  return i.nonEmptyArray(e) ? L(e, me, t) : {
-    valid: !1,
-    errors: [{ message: "Invalid MultiLineString: coordinates must be a non empty array", path: t }],
-    warnings: []
-  };
-}
-function lt(e, t, n = "") {
-  const r = W(e, 4, n);
-  if (!r.valid) return r;
-  const a = e[0], s = e[e.length - 1];
-  if (a[0] !== s[0] || a[1] !== s[1])
-    return r.valid = !1, r.errors.push({ message: "Invalid LinearRing: first and last position must be identical", path: n }), r;
-  const m = ye(e) ? "clockwise" : "counter-clockwise";
-  m !== t && r.warnings.push({ message: `Ring must be ${t} but is ${m}`, path: n });
-  const c = Oe({ type: "Polygon", coordinates: [e] });
-  return c.features.length > 0 && (r.valid = !1, r.errors.push({ message: `Invalid LinearRing: ${c.features.length} self-intersection(s) detected`, path: n })), r;
-}
-function fe(e, t = "") {
-  return i.nonEmptyArray(e) ? L(e, (n, r, a) => lt(n, a === 0 ? "counter-clockwise" : "clockwise", r), t) : {
-    valid: !1,
-    errors: [{ message: "Invalid Polygon: coordinates must be a non empty array", path: t }],
-    warnings: []
-  };
-}
-function ct(e, t = "") {
-  return i.nonEmptyArray(e) ? L(e, (n, r) => fe(n, r), t) : {
-    valid: !1,
-    errors: [{ message: "Invalid MultiPolygon: coordinates must be a non empty array", path: t }],
-    warnings: []
-  };
-}
-function mt(e, t = "") {
-  return i.nonEmptyArray(e) ? L(e, (n, r) => X(n, r), t) : {
-    valid: !1,
-    errors: [{ message: "Invalid geometries: geometries must be a non empty array", path: t }],
-    warnings: []
-  };
-}
-function X(e, t = "") {
-  if (!i.nonEmptyObject(e))
-    return {
-      valid: !1,
-      errors: [{ message: "Invalid geometry: geometry must be a non empty object", path: t }],
-      warnings: []
-    };
-  const n = `${t}/coordinates`;
-  let r;
-  switch (e.type) {
-    case g.POINT: {
-      const a = C(e.coordinates);
-      r = {
-        valid: a.valid,
-        errors: a.errors.map((s) => ({ ...s, path: n })),
-        warnings: a.warnings.map((s) => ({ ...s, path: n }))
-      };
-      break;
-    }
-    case g.MULTI_POINT: {
-      r = W(e.coordinates, 0, n);
-      break;
-    }
-    case g.LINESTRING: {
-      r = me(e.coordinates, n);
-      break;
-    }
-    case g.MULTI_LINESTRING: {
-      r = ut(e.coordinates, n);
-      break;
-    }
-    case g.POLYGON: {
-      r = fe(e.coordinates, n);
-      break;
-    }
-    case g.MULTI_POLYGON: {
-      r = ct(e.coordinates, n);
-      break;
-    }
-    case g.GEOMETRY_COLLECTION: {
-      r = mt(e.geometries, `${t}/geometries`);
-      break;
-    }
-    default:
-      return {
-        valid: !1,
-        errors: [{ message: `Invalid geometry type: ${e.type}`, path: t }],
-        warnings: []
-      };
-  }
-  return r = N(e, r, t), r.statistics = { geometries: { [e.type]: 1 } }, r;
-}
-function ge(e, t = "") {
-  if (!i.nonEmptyObject(e))
-    return {
-      valid: !1,
-      errors: [{ message: "Invalid feature: must be a non empty object", path: t }],
-      warnings: [],
-      statistics: T()
-    };
-  if (e.type === h.FEATURE) {
-    if (i.nonEmptyObject(e.geometry)) {
-      const n = X(e.geometry, `${t}/geometry`);
-      return {
-        ...N(e, n, t),
-        statistics: {
-          Feature: 1,
-          FeatureCollection: 0,
-          // Geometry counting is owned by validateGeometry.
-          geometries: { ...n.statistics.geometries }
-        }
-      };
-    }
-    return {
-      valid: !0,
-      errors: [],
-      warnings: [{ message: "Feature has no geometry", path: t }],
-      statistics: { Feature: 1, FeatureCollection: 0, geometries: {} }
-    };
-  }
-  if (e.type === h.FEATURE_COLLECTION) {
-    if (i.nonEmptyArray(e.features)) {
-      const n = L(e.features, ge, `${t}/features`);
-      return {
-        ...N(e, n, t),
-        statistics: { ...n.statistics, FeatureCollection: n.statistics.FeatureCollection + 1 }
-      };
-    }
-    return {
-      valid: !1,
-      errors: [{ message: "Invalid FeatureCollection: features must be a non empty array", path: t }],
-      warnings: [],
-      statistics: T()
-    };
-  }
-  return {
-    valid: !1,
-    errors: [{ message: `Invalid feature: unknown type: ${e.type}`, path: t }],
-    warnings: [],
-    statistics: T()
-  };
-}
-function Bt(e) {
-  if (u.that(e, i.nonEmptyObject, "geojson must be a non empty object"), i.oneOf(e.type, Object.values(g))) {
-    const t = X(e, ""), n = N(e, t, "");
-    return {
-      ...te(e, n),
-      // Geometry counting is owned by validateGeometry.
-      statistics: { Feature: 0, FeatureCollection: 0, geometries: { ...t.statistics.geometries } }
-    };
-  }
-  if (e.type === h.FEATURE || e.type === h.FEATURE_COLLECTION) {
-    const t = ge(e, "");
-    return te(e, t);
-  }
-  return {
-    valid: !1,
-    errors: [{ message: "Invalid GeoJson: type must be either a Geometry, a Feature or a FeatureCollection", path: "" }],
-    warnings: [],
-    statistics: T()
-  };
-}
+import { A as e, C as i, a as o, b as t, D as n, E as r, I as c, M as l, T as C, W as S, c as g, d, e as O, f as P, g as A, h as E, i as R, j as T, k as u, l as I, m as x, n as N, o as _, p as L, q as m, r as B, s as G, t as D, u as p, v as J, w as F, x as f, y as k, z as j, B as M, F as V, G as h, H as b, J as v, K as U, L as H, N as W, O as Y, P as y, Q as z, R as w, S as X, U as q, V as K, X as Q, Y as Z, Z as $, _ as ss, $ as as, a0 as es, a1 as is, a2 as os, a3 as ts, a4 as ns, a5 as rs, a6 as cs, a7 as ls, a8 as Cs, a9 as Ss, aa as gs, ab as ds, ac as Os, ad as Ps, ae as As, af as Es } from "./ring-Cks2pGr8.js";
+import { i as Ts, l as us } from "./line-CcfAx7LP.js";
+import { C as xs, F as Ns, G as _s, V as Ls, c as ms, f as Bs, i as Gs, a as Ds, b as ps, d as Js, e as Fs, g as fs, h as ks, j as js, k as Ms, s as Vs, v as hs } from "./geojson-CJ6QZ9pN.js";
+import { c as vs, e as Us, a as Hs, b as Ws, r as Ys, t as ys } from "./truncate-Cs8jmwOi.js";
 export {
-  d as AXES,
-  P as COORDINATE_FORMATS,
-  Ye as COORDINATE_MODELS,
-  Y as COORDINATE_TRUNCATION_FACTORS,
-  M as CRS_TYPES,
-  h as FEATURE_TYPES,
-  g as GEOMETRY_TYPES,
-  x as computeBBox,
-  kt as computeGeoJsonBoundingBox,
-  nt as computeGeoJsonConvexHull,
-  Nt as convertCoordinate,
-  re as getActiveLocales,
-  j as getAllDirectionSymbols,
-  J as getCoordinatePrecision,
-  Ne as getDirectionAxis,
-  St as getDirections,
-  Rt as getEast,
-  Ae as getLatitudeSymbols,
-  Re as getLocale,
-  B as getLocaleByCode,
-  Me as getLongitudeSymbols,
-  bt as getNorth,
-  Dt as getSouth,
-  At as getWest,
-  Z as guessCoordinateAxis,
-  ee as is3DBBox,
-  Xe as is3DPosition,
-  Ot as isAltitude,
-  Te as isAxis,
-  O as isDirection,
-  V as isEast,
-  k as isLatitude,
-  Gt as isLikeBBox,
-  xt as isLikeCRS,
-  Qe as isLikeFeature,
-  Ze as isLikeFeatureCollection,
-  Je as isLikeFeatureOrFeatureCollection,
-  F as isLikeGeoJson,
-  qe as isLikeGeometry,
-  Ut as isLikePosition,
-  ne as isLongitude,
-  Ce as isNorth,
-  _t as isSamePosition,
-  ie as isSouth,
-  A as isValidBBox,
-  y as isValidPosition,
-  $ as isWest,
-  Tt as listLocales,
-  Ft as mergeBBox,
-  Ct as normalizeCoordinate,
-  We as parseCoordinate,
-  wt as parsePosition,
-  It as registerLocale,
-  Lt as setLocale,
-  G as simplifyGeoJson,
-  ue as truncateBBox,
-  Mt as truncateCoordinate,
-  Pt as truncateGeoJson,
-  $t as truncatePosition,
-  at as validateBBox,
-  st as validateCRS,
-  Bt as validateGeoJson,
-  X as validateGeometry,
-  C as validatePosition
+  e as AXES,
+  i as COORDINATE_FORMATS,
+  o as COORDINATE_MODELS,
+  t as COORDINATE_TRUNCATION_FACTORS,
+  xs as CRS_TYPES,
+  n as DEFAULT_COORDINATE_PRECISION,
+  r as EARTH_RADIUS,
+  Ns as FEATURE_TYPES,
+  _s as GEOMETRY_TYPES,
+  c as IS_SAME_POSITION_OPTIONS_SCHEMA,
+  l as MAX_COORDINATE_PRECISION,
+  C as TRUNCATE_POSITIONS_OPTIONS_SCHEMA,
+  Ls as VALIDATION_CODES,
+  S as WGS84,
+  g as closeRing,
+  d as computeBBox,
+  ms as computeGeoJsonBoundingBox,
+  vs as computeGeoJsonConvexHull,
+  O as convertCoordinate,
+  P as deduplicatePositions,
+  A as defineProjection,
+  E as denormalizeCrsName,
+  R as destinationFromPosition,
+  T as distanceBetweenPositions,
+  Us as extractGeoJsonBBox,
+  Hs as extractGeoJsonCRS,
+  Ws as extractGeoJsonNode,
+  Bs as fixGeoJson,
+  u as getActiveLocales,
+  I as getCoordinatePrecision,
+  x as getDirectionAxis,
+  N as getDirectionSymbols,
+  _ as getDirections,
+  L as getEast,
+  m as getLocale,
+  B as getMessages,
+  G as getNorth,
+  D as getProjection,
+  p as getSouth,
+  J as getWest,
+  F as guessCoordinateAxis,
+  f as hasProjection,
+  k as is3DBBox,
+  j as is3DPosition,
+  M as isAltitude,
+  V as isClockwiseRing,
+  h as isClosedRing,
+  b as isEast,
+  Gs as isGeoJsonFixable,
+  v as isLatitude,
+  Ds as isLikeBBox,
+  ps as isLikeCRS,
+  Js as isLikeFeature,
+  Fs as isLikeFeatureCollection,
+  fs as isLikeFeatureOrFeatureCollection,
+  ks as isLikeGeoJson,
+  js as isLikeGeometry,
+  Ms as isLikePosition,
+  U as isLongitude,
+  H as isNorth,
+  W as isSamePosition,
+  Y as isSouth,
+  y as isValidAxis,
+  z as isValidBBox,
+  w as isValidDirection,
+  Ts as isValidLine,
+  X as isValidPosition,
+  q as isValidPositions,
+  K as isValidRing,
+  Q as isWGS84Projection,
+  Z as isWest,
+  us as lineLength,
+  $ as listLocales,
+  ss as listProjections,
+  as as mergeBBox,
+  es as normalizeCoordinate,
+  is as normalizeCrsName,
+  os as parseCoordinate,
+  ts as parsePosition,
+  ns as registerMessages,
+  Ys as reprojectGeoJson,
+  rs as reprojectPosition,
+  cs as reprojectPositions,
+  ls as ringSelfIntersections,
+  Cs as ringsIntersect,
+  Ss as setLocale,
+  Vs as simplifyGeoJson,
+  gs as sphericalRingArea,
+  ds as truncateBBox,
+  Os as truncateCoordinate,
+  ys as truncateGeoJson,
+  Ps as truncatePosition,
+  As as truncatePositions,
+  Es as truncateRing,
+  hs as validateGeoJson
 };
 //# sourceMappingURL=index.mjs.map