@kalisio/common-geospatial 0.6.0 → 0.8.0

package/dist/index.mjs

@@ -1,124 +1,156 @@
-import { assert as l, is as i, has as M, conform as T, optional as $ } from "@kalisio/common-core";
-import { getLogger as j } from "@logtape/logtape";
-import { Heap as se } from "heap-js";
-import ae from "@turf/truncate";
-import oe from "@turf/boolean-clockwise";
-import le from "@turf/kinks";
+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 ue(e) {
-  return l.that(e, i.string, "axis must be a string"), Object.values(d).includes(e);
+function Te(e) {
+  return u.that(e, i.string, "axis must be a string"), Object.values(d).includes(e);
 }
-function N(e) {
-  return l.that(e, i.string, "axis must be a string"), e === d.LATITUDE;
+function k(e) {
+  return u.that(e, i.string, "axis must be a string"), e === d.LATITUDE;
 }
-function Y(e) {
-  return l.that(e, i.string, "axis must be a string"), e === d.LONGITUDE;
+function ne(e) {
+  return u.that(e, i.string, "axis must be a string"), e === d.LONGITUDE;
 }
-function et(e) {
-  return l.that(e, i.string, "axis must be a string"), e === d.ALTITUDE;
+function Ot(e) {
+  return u.that(e, i.string, "axis must be a string"), e === d.ALTITUDE;
 }
-const ce = { NORTH: { label: "Nord", symbol: "N" }, SOUTH: { label: "Sud", symbol: "S" }, EAST: { label: "Est", symbol: "E" }, WEST: { label: "Ouest", symbol: "O" } }, ge = {
-  DIRECTIONS: ce
-}, fe = { NORTH: { label: "North", symbol: "N" }, SOUTH: { label: "South", symbol: "S" }, EAST: { label: "East", symbol: "E" }, WEST: { label: "West", symbol: "W" } }, me = {
-  DIRECTIONS: fe
-}, de = {
+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.string },
-    SOUTH: { label: i.string, symbol: i.string },
-    EAST: { label: i.string, symbol: i.string },
-    WEST: { label: i.string, symbol: i.string }
+    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 }
   }
-}, O = {
-  en: me,
-  fr: ge
+}, I = {
+  en: be,
+  fr: Le
 };
-let A = "en";
-function tt() {
-  return Object.keys(O);
+let S = "en";
+const z = "en";
+function Tt() {
+  return Object.keys(I);
 }
-function nt(e, t) {
-  l.all([
+function It(e, t) {
+  u.all([
     { value: e, validator: i.string, message: "code must be a string" },
-    { value: e, validator: (r) => !M.key(O, r), message: "locale already registered" },
+    { 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: (r) => T.schema(r, de), message: "content does not conform to schema" }
-  ]), O[e] = t;
+    { value: t, validator: (n) => E.schema(n, De), message: "content does not conform to schema" }
+  ]), I[e] = t;
 }
-function rt(e) {
-  l.all([
+function Lt(e) {
+  u.all([
     { value: e, validator: i.string, message: "code must be a string" },
-    { value: e, validator: (t) => M.key(O, t), message: "code is unknown" }
-  ]), A = e;
+    { value: e, validator: (t) => w.key(I, t), message: "code is unknown" }
+  ]), S = e;
 }
-function pe() {
-  return {
-    code: A,
-    content: O[A]
-  };
+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 pe().content.DIRECTIONS;
+  return B(Re()).DIRECTIONS;
 }
-function R(e, t) {
-  const r = b(), n = r[e].label.toUpperCase(), s = r[e].symbol.toUpperCase();
-  return t.toUpperCase() === n || t.toUpperCase() === s;
+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 it(e = null) {
+function St(e = null) {
   const t = b();
-  return i.defined(e) ? (l.that(e, ue, "axis must be a valid axis"), N(e) ? [t.SOUTH, t.NORTH] : Y(e) ? [t.EAST, t.WEST] : []) : [t.SOUTH, t.NORTH, t.EAST, t.WEST];
+  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 st() {
+function bt() {
   return b().NORTH;
 }
-function at() {
+function Dt() {
   return b().SOUTH;
 }
-function ot() {
+function Rt() {
   return b().EAST;
 }
-function lt() {
+function At() {
   return b().WEST;
 }
-function E(e) {
-  return l.that(e, i.string, "dir must be a string"), ve(e) || B(e) || X(e) || _(e);
+function O(e) {
+  return u.that(e, i.string, "dir must be a string"), Ce(e) || ie(e) || V(e) || $(e);
 }
-function ve(e) {
-  return l.that(e, i.string, "dir must be a string"), R("NORTH", e);
+function Ce(e) {
+  return u.that(e, i.string, "dir must be a string"), _("NORTH", e);
 }
-function B(e) {
-  return l.that(e, i.string, "dir must be a string"), R("SOUTH", e);
+function ie(e) {
+  return u.that(e, i.string, "dir must be a string"), _("SOUTH", e);
 }
-function X(e) {
-  return l.that(e, i.string, "dir must be a string"), R("EAST", e);
+function V(e) {
+  return u.that(e, i.string, "dir must be a string"), _("EAST", e);
 }
-function _(e) {
-  return l.that(e, i.string, "dir must be a string"), R("WEST", e);
+function $(e) {
+  return u.that(e, i.string, "dir must be a string"), _("WEST", e);
 }
-function Ee(e) {
-  return l.that(e, E, "dir must be a direction"), _(e) || X(e) ? d.LONGITUDE : d.LATITUDE;
+function Ne(e) {
+  return u.that(e, O, "dir must be a direction"), $(e) || V(e) ? d.LONGITUDE : d.LATITUDE;
 }
-const be = {
+const we = {
   degrees: i.number,
-  direction: $(E)
-}, he = /^(-?\d{1,3}(?:\.\d+)?)°?$/, ye = /^(\d{1,3}(?:\.\d+)?)°?([NSEW])$/;
-function I(e) {
-  let t = null, r = null;
-  if (i.plainObject(e) && T.schema(e, be))
-    i.defined(e.direction) ? e.degrees >= 0 && (t = e.degrees, r = e.direction) : t = e.degrees;
+  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 n = e.replace(/\s+/g, ""), s = n.match(he) ?? n.match(ye);
-    s && (t = parseFloat(s[1]), r = s[2] ?? null);
+    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 r;
+      return n;
     },
     get format() {
       return "DD";
@@ -126,249 +158,382 @@ function I(e) {
     isValid() {
       return i.number(t);
     },
-    toString(n) {
-      if (l.that(n, i.positiveInteger, "decimalPlaces must be a positive integer"), !this.isValid()) return "";
-      let s = `${t.toFixed(n)}°`;
-      return r && (s += ` ${r}`), s;
+    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() ? I({ degrees: t, direction: r }) : null;
+      return this.isValid() ? D({ degrees: t, direction: n }) : null;
     }
   };
 }
-const Oe = {
+const Fe = {
   degrees: i.integer,
   minutes: (e) => i.inRangeExclusiveMax(e, 0, 60),
-  direction: $(E)
-}, Te = /^(-?\d{1,3})°(\d{1,2}(?:\.\d+)?)'?$/, Ie = /^(\d{1,3})°(\d{1,2}(?:\.\d+)?)'?([NSEW])$/;
-function K(e) {
-  let t = null, r = null, n = null;
-  if (i.plainObject(e) && T.schema(e, Oe))
-    i.defined(e.direction) ? e.degrees >= 0 && (t = e.degrees, r = e.minutes, n = e.direction) : (t = e.degrees, r = e.minutes);
+  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 s = e.replace(/\s+/g, ""), o = s.match(Te) ?? s.match(Ie);
-    o && (t = parseFloat(o[1]), r = parseFloat(o[2]), n = o[3] ?? null);
+    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 r;
+      return n;
     },
     get direction() {
-      return n;
+      return r;
     },
     get format() {
       return "DDM";
     },
     isValid() {
-      return i.integer(t) && i.inRangeExclusiveMax(r, 0, 60);
+      return i.integer(t) && i.inRangeExclusiveMax(n, 0, 60);
     },
-    toString(s) {
-      if (l.that(s, i.positiveInteger, "decimalPlaces must be a positive integer"), !this.isValid()) return "";
-      let o = `${t}° ${r.toFixed(s)}'`;
-      return n && (o += ` ${n}`), o;
+    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() ? I({ degrees: t + r / 60, direction: n }) : null;
+      return this.isValid() ? D({ degrees: t + n / 60, direction: r }) : null;
     }
   };
 }
-const Le = {
+const Ge = {
   degrees: i.nonNegativeInteger,
   minutes: (e) => i.inRangeExclusiveMax(e, 0, 60),
-  direction: E
-}, De = /^(\d{2})(\d{3})([NS])$/, Re = /^(\d{3})(\d{3})([EW])$/;
-function z(e) {
-  let t = null, r = null, n = null;
-  if (i.plainObject(e) && T.schema(e, Le))
-    t = e.degrees, r = e.minutes, n = e.direction;
+  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 s = e.trim(), o = s.match(De) ?? s.match(Re);
-    o && (t = parseFloat(o[1]), r = parseFloat(o[2]) / 10, n = o[3]);
+    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 r;
+      return n;
     },
     get direction() {
-      return n;
+      return r;
     },
     get format() {
       return "DDM_AERO";
     },
     isValid() {
-      return i.nonNegativeInteger(t) && i.inRangeExclusiveMax(r, 0, 60) && E(n);
+      return i.nonNegativeInteger(t) && i.inRangeExclusiveMax(n, 0, 60) && O(r);
     },
     toString() {
       if (!this.isValid()) return "";
-      const s = n === "E" || n === "W", o = String(t).padStart(s ? 3 : 2, "0"), u = Math.floor(r * 10).toString().padStart(3, "0");
-      return `${o}${u}${n}`;
+      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() ? I({ degrees: t + r / 60, direction: n }) : null;
+      return this.isValid() ? D({ degrees: t + n / 60, direction: r }) : null;
     }
   };
 }
-const Se = {
+const Be = {
   degrees: i.integer,
   minutes: (e) => i.integer(e) && i.inRange(e, 0, 59),
   seconds: (e) => i.inRangeExclusiveMax(e, 0, 60),
-  direction: $(E)
-}, Ne = /^(-?\d{1,3})°(\d{1,2})'(\d{1,2}(?:\.\d+)?)"?$/, Ae = /^(\d{1,3})°(\d{1,2})'(\d{1,2}(?:\.\d+)?)"?([NSEW])$/;
-function q(e) {
-  let t = null, r = null, n = null, s = null;
-  if (i.plainObject(e) && T.schema(e, Se))
-    i.defined(e.direction) ? e.degrees >= 0 && (t = e.degrees, r = e.minutes, n = e.seconds, s = e.direction) : (t = e.degrees, r = e.minutes, n = e.seconds);
+  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 o = e.replace(/\s+/g, ""), u = o.match(Ne) ?? o.match(Ae);
-    u && (t = parseFloat(u[1]), r = parseFloat(u[2]), n = parseFloat(u[3]), s = u[4] ?? null);
+    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 r;
+      return n;
     },
     get seconds() {
-      return n;
+      return r;
     },
     get direction() {
-      return s;
+      return a;
     },
     get format() {
       return "DMS";
     },
     isValid() {
-      return i.integer(t) && i.integer(r) && i.inRange(r, 0, 59) && i.inRangeExclusiveMax(n, 0, 60);
+      return i.integer(t) && i.integer(n) && i.inRange(n, 0, 59) && i.inRangeExclusiveMax(r, 0, 60);
     },
-    toString(o) {
-      if (l.that(o, i.positiveInteger, "decimalPlaces must be a positive integer"), !this.isValid()) return "";
-      let u = `${t}° ${r}' ${n.toFixed(o)}"`;
-      return s && (u += ` ${s}`), u;
+    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() ? I({ degrees: t + r / 60 + n / 3600, direction: s }) : null;
+      return this.isValid() ? D({ degrees: t + n / 60 + r / 3600, direction: a }) : null;
     }
   };
 }
-function P(e) {
-  const t = Math.floor(e.degrees), r = (e.degrees - t) * 60;
-  return { degrees: t, minutes: r, direction: e.direction };
+function q(e) {
+  const t = Math.floor(e.degrees), n = (e.degrees - t) * 60;
+  return { degrees: t, minutes: n, direction: e.direction };
 }
-function Ce(e) {
-  const t = Math.floor(e.degrees), r = (e.degrees - t) * 60, n = Math.floor(r), s = (r - n) * 60;
-  return { degrees: t, minutes: n, seconds: s, 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 H = {
-  DD: (e) => (l.that(e, (t) => t.isValid(), "dd must be a valid coordinate"), e),
+const Q = {
+  DD: (e) => (u.that(e, (t) => t.isValid(), "dd must be a valid coordinate"), e),
   DDM: (e) => {
-    l.that(e, (s) => s.isValid(), "dd must be a valid coordinate");
-    const { degrees: t, minutes: r, direction: n } = P(e);
-    return K(n ? { degrees: t, minutes: r, direction: n } : { degrees: t, minutes: r });
+    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) => {
-    l.that(e, (o) => o.isValid(), "dd must be a valid coordinate");
-    const { degrees: t, minutes: r, seconds: n, direction: s } = Ce(e);
-    return q(s ? { degrees: t, minutes: r, seconds: n, direction: s } : { degrees: t, minutes: r, seconds: n });
+    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) => {
-    l.that(e, (s) => s.isValid(), "dd must be a valid coordinate");
-    const { degrees: t, minutes: r, direction: n } = P(e);
-    return z({ degrees: t, minutes: r, direction: n });
+    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 });
   }
-}, C = {
+}, P = {
   DD: "DD",
   DDM: "DDM",
   DDM_AERO: "DDM_AERO",
   DMS: "DMS"
-}, we = {
-  DD: I,
-  DDM: K,
-  DDM_AERO: z,
-  DMS: q
-}, x = Array.from({ length: 9 }, (e, t) => 10 ** t);
-function V(e, t) {
-  if (l.that(e, i.number, "coord must be a number"), i.defined(t))
-    return l.that(t, E, "dir must be a direction"), Ee(t);
+}, 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 W(e) {
-  l.that(e, i.number, "coord must be a number");
-  const t = e.toExponential(), [r, n] = t.split("e").map(Number), s = (r.toString().split(".")[1] || "").length;
-  return Math.max(0, s - n);
+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 ut(e, t = 7) {
-  l.all([
+function Mt(e, t = 7) {
+  u.all([
     { value: e, validator: i.number, message: "coord must be a number" },
-    { value: t, validator: (n) => i.inRange(n, 0, 8), message: "precision must be in range [0, 8]" }
+    { value: t, validator: (r) => i.inRange(r, 0, 8), message: "precision must be in range [0, 8]" }
   ]);
-  const r = x[t];
-  return Math.round(e * r) / r;
+  const n = Y[t];
+  return Math.round(e * n) / n;
 }
-function ct(e, t) {
-  if (l.all([
+function Ct(e, t) {
+  if (u.all([
     { value: e, validator: i.number, message: "coord must be a number" },
-    { value: t, validator: (n) => Y(n) || N(n), message: "axis must be either a longitude or latitude" }
-  ]), N(t))
+    { 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 r = ((e + 180) % 360 + 360) % 360 - 180;
-  return r === -180 && (r = 180), Object.is(r, -0) && (r = 0), r;
+  let n = ((e + 180) % 360 + 360) % 360 - 180;
+  return n === -180 && (n = 180), Object.is(n, -0) && (n = 0), n;
 }
-function gt(e, t) {
-  l.all([
-    { value: e, validator: (n) => i.defined(n) && n.isValid(), message: "from must be a valid coordinate" },
-    { value: t, validator: (n) => M.key(H, n), message: `unknown format: ${t}` }
+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 r = e.format === C.DD ? e : e.toDecimal();
-  return r.isValid() ? t === C.DD ? r : H[t](r) : null;
-}
-function Me(e) {
-  l.that(e, i.nonEmptyString, "pattern must be a non empty string");
-  for (const t of Object.keys(C)) {
-    const r = we[t](e);
-    if (r.isValid()) return r;
+  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 ft(e) {
-  l.that(e, (a) => i.nonEmptyString(a), "pattern must be a non-empty string");
+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 [r, n] = t.map(Me);
-  if (!r || !n) return null;
-  const s = r.toDecimal(), o = n.toDecimal(), u = V(s.degrees, s.direction), g = V(o.degrees, o.direction), c = (a) => {
-    const { degrees: p, direction: m } = a;
-    return m && (_(m) || B(m)) ? -p : p;
+  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 (u === d.LONGITUDE && g === d.LATITUDE) return [c(s), c(o)];
-  if (g === d.LONGITUDE && u === d.LATITUDE) return [c(o), c(s)];
-  if (u === d.LONGITUDE && !g) return [c(s), o];
-  if (u === d.LATITUDE && !g) return [c(o), c(s)];
-  if (g === d.LONGITUDE && !u) return [c(o), c(s)];
-  if (g === d.LATITUDE && !u) return [c(s), c(o)];
-  if (!u && !g)
+  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(s), c(o)],
-      [c(o), c(s)]
+      [c(a), c(s)],
+      [c(s), c(a)]
     ];
 }
-function $e(e) {
-  return !i.arrayOfLength(e, 4) && !i.arrayOfLength(e, 6) ? !1 : e.every(i.number);
+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]));
 }
-const L = {
+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 mt(e) {
-  return i.plainObject(e) ? e.type === L.NAME ? i.nonEmptyString(e.properties?.name) : e.type === L.LINK ? i.nonEmptyString(e.properties?.href) : !1 : !1;
+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;
 }
-const f = {
+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",
@@ -377,138 +542,141 @@ const f = {
   MULTI_POLYGON: "MultiPolygon",
   GEOMETRY_COLLECTION: "GeometryCollection"
 };
-function G(e) {
-  return !i.plainObject(e) || !i.oneOf(e.type, Object.values(f)) ? !1 : e.type === f.GEOMETRY_COLLECTION ? i.array(e.geometries) : i.array(e.coordinates);
+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 v = {
+const h = {
   FEATURE: "Feature",
   FEATURE_COLLECTION: "FeatureCollection"
 };
-function _e(e) {
-  return i.plainObject(e) ? v.FEATURE === e.type : !1;
+function Qe(e) {
+  return i.plainObject(e) && e.type === h.FEATURE;
 }
-function xe(e) {
-  return !i.plainObject(e) || e.type !== v.FEATURE_COLLECTION ? !1 : i.array(e.features);
+function Ze(e) {
+  return i.plainObject(e) && e.type === h.FEATURE_COLLECTION && i.array(e.features);
 }
-function Q(e) {
-  return i.plainObject(e) ? G(e) || _e(e) ? !0 : xe(e) : !1;
+function Je(e) {
+  return Qe(e) || Ze(e);
 }
-function Ge(e) {
-  return i.arrayOfLengthBetween(e, 2, 3) ? e.every(i.number) : !1;
+function F(e) {
+  return Je(e) || qe(e);
 }
-function Ue(e, t, r) {
+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] - r[1]) + t[0] * (r[1] - e[1]) + r[0] * (e[1] - t[1])) / 2
+    (e[0] * (t[1] - n[1]) + t[0] * (n[1] - e[1]) + n[0] * (e[1] - t[1])) / 2
   );
 }
-function S(e, { tolerance: t = 0, getWeight: r = () => 1 } = {}) {
+function U(e, { tolerance: t = 0, getWeight: n = () => 1 } = {}) {
   if (e.length <= 2) return e;
-  const n = e.map((a, p) => ({ coord: a, i: p, area: 1 / 0, removed: !1, prev: null, next: null }));
-  for (let a = 0; a < n.length; a++)
-    a > 0 && (n[a].prev = n[a - 1]), a < n.length - 1 && (n[a].next = n[a + 1]);
-  const s = (a) => !a.prev || !a.next ? 1 / 0 : Ue(a.prev.coord, a.coord, a.next.coord) * r(a.coord, a.i), o = new se((a, p) => a.area - p.area);
-  for (let a = 1; a < n.length - 1; a++)
-    n[a].area = s(n[a]), n[a]._currentArea = n[a].area, o.push(n[a]);
-  let u = 0;
-  for (; o.size() > 0; ) {
-    const a = o.pop();
-    if (!a.removed && a.area === a._currentArea) {
-      if (a.area < u ? a.area = u : u = a.area, a.area >= t) break;
-      a.removed = !0, a.prev && (a.prev.next = a.next), a.next && (a.next.prev = a.prev), a.prev?.prev && (a.prev.area = s(a.prev), a.prev._currentArea = a.prev.area, o.push(a.prev)), a.next?.next && (a.next.area = s(a.next), a.next._currentArea = a.next.area, o.push(a.next));
+  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 g = [];
-  let c = n[0];
+  const m = [];
+  let c = r[0];
   for (; c; )
-    c.removed || g.push(c.coord), c = c.next;
-  return g;
-}
-function U(e, t) {
-  switch (l.all([
-    { value: e, validator: G, message: "geometry must be a GeoJson geometry" }
-  ]), e.type) {
-    case f.LINESTRING:
-      e.coordinates = S(e.coordinates, t);
+    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 f.POLYGON:
-    case f.MULTI_LINESTRING:
-      e.coordinates = e.coordinates.map((r) => S(r, t));
+    case g.POLYGON:
+    case g.MULTI_LINESTRING:
+      e.coordinates = e.coordinates.map((n) => U(n, t));
       break;
-    case f.MULTI_POLYGON:
-      e.coordinates = e.coordinates.map((r) => r.map((n) => S(n, t)));
+    case g.MULTI_POLYGON:
+      e.coordinates = e.coordinates.map((n) => n.map((r) => U(r, t)));
       break;
-    case f.GEOMETRY_COLLECTION:
-      e.geometries.forEach((r) => U(r, t));
+    case g.GEOMETRY_COLLECTION:
+      e.geometries.forEach((n) => G(n, t));
       break;
   }
   return e;
 }
-const Fe = j(["common-ekosystem", "simplify", "geojson"]);
-function Z(e, t) {
-  if (e.type === v.FEATURE)
-    e.geometry && U(e.geometry, t);
-  else if (e.type === v.FEATURE_COLLECTION)
-    for (const r of e.features) Z(r, t);
-  else
-    Fe.warn('Unknown feature type "{type}", skipping.', { type: e.type });
-  return e;
-}
-function dt(e, t) {
-  return l.all([
-    { value: e, validator: Q, message: "geoJson must be a GeoJson object" }
-  ]), i.oneOf(e.type, Object.values(f)) ? U(e, t) : Z(e, t);
-}
-function J(e, t = 7) {
-  l.all([
-    { value: e, validator: $e, message: "bbox must be bounding box" },
-    { value: t, validator: (n) => i.inRange(n, 0, 8), message: "precision must be in range [0, 8]" }
-  ]);
-  const r = x[t];
-  for (let n = 0; n < e.length; n++)
-    e[n] = Math.round(e[n] * r) / r;
-  return e;
-}
-function ee(e, t = 7) {
-  l.all([
-    { value: e, validator: G, message: "geometry must be a GeoJson geometry" },
-    { value: t, validator: (n) => i.inRange(n, 0, 8), message: "precision must be in range [0, 8]" }
-  ]);
-  const r = ae(e, { precision: t, mutate: !0 });
-  return r.bbox && J(r.bbox, t), r;
+function le(e, t = 7) {
+  const n = Ee(e, { precision: t, mutate: !0 });
+  return n.bbox && ue(n.bbox, t), n;
 }
-const ke = j(["common-ekosystem", "truncate", "geojson"]);
-function te(e, t) {
-  if (e.type === v.FEATURE)
-    e.geometry && ee(e.geometry, t);
-  else if (e.type === v.FEATURE_COLLECTION)
-    for (const r of e.features) te(r, t);
+function ce(e, t) {
+  if (e.type === h.FEATURE)
+    e.geometry && le(e.geometry, t);
   else
-    ke.warn('Unknown feature type "{type}", skipping.', { type: e.type });
-  return e.bbox && J(e.bbox, t), e;
+    for (const n of e.features) ce(n, t);
+  return e.bbox && ue(e.bbox, t), e;
 }
-function pt(e, t = 7) {
-  return l.all([
-    { value: e, validator: Q, message: "geoJson must be a valid GeoJson" },
-    { value: t, validator: (r) => i.inRange(r, 0, 8), message: "precision must be in range [0, 8]" }
-  ]), i.oneOf(e.type, Object.values(f)) ? ee(e, t) : te(e, t);
-}
-function vt(e, t = 7) {
-  l.all([
-    { value: e, validator: Ge, message: "position must be a position" },
+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]" }
-  ]);
-  const r = x[t];
-  for (let n = 0; n < e.length; n++)
-    e[n] = Math.round(e[n] * r) / r;
-  return e;
+  ]), i.oneOf(e.type, Object.values(g)) ? le(e, t) : ce(e, t);
 }
-function D(e) {
+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,
@@ -527,43 +695,52 @@ function D(e) {
       errors: [{ message: "Invalid coordinates: altitude must be a number" }],
       warnings: []
     };
-  const t = { valid: !0, errors: [], warnings: [] }, r = W(e[0]);
-  r > 6 && t.warnings.push({ message: `longitude precision is high (${r} decimals, max recommended: 6)` });
-  const n = W(e[1]);
-  return n > 6 && t.warnings.push({ message: `latitude precision is high (${n} decimals, max recommended: 6)` }), t;
+  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 Pe(e) {
+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, r = t ? [e[0], e[1]] : [e[0], e[1], e[2]], n = t ? [e[2], e[3]] : [e[3], e[4], e[5]], s = D(r);
-  if (!s.valid)
+  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: s.errors.map((m) => ({ ...m, message: `Invalid bbox south-west: ${m.message}` })),
+      errors: a.errors.map((f) => ({ ...f, message: `Invalid bbox south-west: ${f.message}` })),
       warnings: []
     };
-  const o = D(n);
-  if (!o.valid)
+  const s = C(r);
+  if (!s.valid)
     return {
       valid: !1,
-      errors: o.errors.map((m) => ({ ...m, message: `Invalid bbox north-east: ${m.message}` })),
+      errors: s.errors.map((f) => ({ ...f, message: `Invalid bbox north-east: ${f.message}` })),
       warnings: []
     };
-  const [u, g] = r, [c, a] = n;
-  if (g > a)
+  const [l, m] = n, [c, o] = r;
+  if (m > o)
     return {
       valid: !1,
-      errors: [{ message: `Invalid bbox: south (${g}) must be <= north (${a})` }],
+      errors: [{ message: `Invalid bbox: south (${m}) must be <= north (${o})` }],
       warnings: []
     };
-  const p = { valid: !0, errors: [], warnings: [] };
-  return u > c && p.warnings.push({ message: `bbox crosses the antimeridian (west: ${u} > east: ${c})` }), p.warnings.push(...s.warnings.map((m) => ({ ...m, message: `south-west: ${m.message}` }))), p.warnings.push(...o.warnings.map((m) => ({ ...m, message: `north-east: ${m.message}` }))), p;
+  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 He(e) {
+function st(e) {
   if (!i.plainObject(e))
     return {
       valid: !1,
@@ -571,13 +748,13 @@ function He(e) {
       warnings: []
     };
   switch (e.type) {
-    case L.NAME:
+    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 L.LINK:
+    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" }],
@@ -591,146 +768,147 @@ function He(e) {
       };
   }
 }
-function y() {
+function T() {
   return { Feature: 0, FeatureCollection: 0, geometries: {} };
 }
-function Ve(...e) {
-  const t = y();
-  for (const r of e) {
-    const n = r.statistics;
-    if (n) {
-      t.Feature += n.Feature ?? 0, t.FeatureCollection += n.FeatureCollection ?? 0;
-      for (const [s, o] of Object.entries(n.geometries ?? {}))
-        t.geometries[s] = (t.geometries[s] ?? 0) + o;
+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 h(e, t, r = "") {
-  const n = {
+function L(e, t, n = "") {
+  const r = {
     valid: !0,
     errors: [],
-    warnings: []
+    warnings: [],
+    statistics: T()
   };
-  for (let s = 0; s < e.length; s++) {
-    const o = `${r}/${s}`, u = t(e[s], o, s);
-    if (!u.valid) {
-      n.valid = !1, n.errors = n.errors.concat(u.errors.map((g) => ({ ...g, path: g.path || o, index: s })));
+  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(u.warnings) || (n.warnings = n.warnings.concat(u.warnings.map((g) => ({ ...g, path: g.path || o, index: s })))), u.statistics && (n.statistics = Ve(n, u));
+    i.empty(l.warnings) || (r.warnings = r.warnings.concat(l.warnings.map((m) => ({ ...m, path: m.path || s, index: a }))));
   }
-  return n;
+  return r;
 }
-function We(e, t) {
+function te(e, t) {
   if (!i.defined(e.crs)) return t;
-  const r = He(e.crs);
-  return r.valid || (t.valid = !1, t.errors.push(...r.errors.map((n) => ({ ...n, path: "/crs" })))), t.warnings.push(...r.warnings.map((n) => ({ ...n, path: "/crs" }))), 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 w(e, t, r = "") {
+function N(e, t, n = "") {
   if (!i.defined(e.bbox)) return t;
-  const n = Pe(e.bbox);
-  return n.valid || (t.valid = !1, t.errors.push(...n.errors.map((s) => ({ ...s, path: `${r}/bbox` })))), t.warnings.push(...n.warnings.map((s) => ({ ...s, path: `${r}/bbox` }))), 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 F(e, t = 0, r = "") {
-  return i.arrayOfLengthAtLeast(e, t) ? h(e, D, r) : {
+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: r }],
+    errors: [{ message: `Invalid coordinates: must have at least ${t} positions`, path: n }],
     warnings: []
   };
 }
-function ne(e, t = "") {
-  const r = F(e, 2, t);
-  if (!r.valid) return r;
-  for (let n = 0; n < e.length - 1; n++) {
-    const s = e[n][0], o = e[n + 1][0];
-    Math.abs(o - s) > 180 && r.warnings.push({
-      message: `LineString crosses the antimeridian between positions ${n} and ${n + 1}, consider using MultiLineString`,
-      path: `${t}/${n}`
+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 r;
+  return n;
 }
-function je(e, t = "") {
-  return i.nonEmptyArray(e) ? h(e, ne, t) : {
+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 Ye(e, t, r = "") {
-  const n = F(e, 4, r);
-  if (!n.valid) return n;
-  const s = e[0], o = e[e.length - 1];
-  if (s[0] !== o[0] || s[1] !== o[1])
-    return n.valid = !1, n.errors.push({ message: "Invalid LinearRing: first and last position must be identical", path: r }), n;
-  const g = oe(e) ? "clockwise" : "counter-clockwise";
-  g !== t && n.warnings.push({ message: `Ring must be ${t} but is ${g}`, path: r });
-  const c = le({ type: "Polygon", coordinates: [e] });
-  return c.features.length > 0 && (n.valid = !1, n.errors.push({ message: `Invalid LinearRing: ${c.features.length} self-intersection(s) detected`, path: r })), n;
-}
-function re(e, t = "") {
-  return i.nonEmptyArray(e) ? h(e, (r, n, s) => Ye(r, s === 0 ? "counter-clockwise" : "clockwise", n), t) : {
+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 Be(e, t = "") {
-  return i.nonEmptyArray(e) ? h(e, (r, n) => re(r, n), t) : {
+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 Xe(e, t = "") {
-  return i.nonEmptyArray(e) ? h(e, (r, n) => k(r, n), t) : {
+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 k(e, t = "") {
+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 r = `${t}/coordinates`;
-  let n;
+  const n = `${t}/coordinates`;
+  let r;
   switch (e.type) {
-    case f.POINT: {
-      const s = D(e.coordinates);
-      n = {
-        valid: s.valid,
-        errors: s.errors.map((o) => ({ ...o, path: r })),
-        warnings: s.warnings.map((o) => ({ ...o, path: r }))
+    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 f.MULTI_POINT: {
-      n = F(e.coordinates, 0, r);
+    case g.MULTI_POINT: {
+      r = W(e.coordinates, 0, n);
       break;
     }
-    case f.LINESTRING: {
-      n = ne(e.coordinates, r);
+    case g.LINESTRING: {
+      r = me(e.coordinates, n);
       break;
     }
-    case f.MULTI_LINESTRING: {
-      n = je(e.coordinates, r);
+    case g.MULTI_LINESTRING: {
+      r = ut(e.coordinates, n);
       break;
     }
-    case f.POLYGON: {
-      n = re(e.coordinates, r);
+    case g.POLYGON: {
+      r = fe(e.coordinates, n);
       break;
     }
-    case f.MULTI_POLYGON: {
-      n = Be(e.coordinates, r);
+    case g.MULTI_POLYGON: {
+      r = ct(e.coordinates, n);
       break;
     }
-    case f.GEOMETRY_COLLECTION: {
-      n = Xe(e.geometries, `${t}/geometries`);
+    case g.GEOMETRY_COLLECTION: {
+      r = mt(e.geometries, `${t}/geometries`);
       break;
     }
     default:
@@ -740,25 +918,26 @@ function k(e, t = "") {
         warnings: []
       };
   }
-  return w(e, n, t);
+  return r = N(e, r, t), r.statistics = { geometries: { [e.type]: 1 } }, r;
 }
-function ie(e, t = "") {
+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: y()
+      statistics: T()
     };
-  if (e.type === v.FEATURE) {
+  if (e.type === h.FEATURE) {
     if (i.nonEmptyObject(e.geometry)) {
-      const r = k(e.geometry, `${t}/geometry`);
+      const n = X(e.geometry, `${t}/geometry`);
       return {
-        ...w(e, r, t),
+        ...N(e, n, t),
         statistics: {
           Feature: 1,
           FeatureCollection: 0,
-          geometries: { [e.geometry.type]: 1 }
+          // Geometry counting is owned by validateGeometry.
+          geometries: { ...n.statistics.geometries }
         }
       };
     }
@@ -769,96 +948,112 @@ function ie(e, t = "") {
       statistics: { Feature: 1, FeatureCollection: 0, geometries: {} }
     };
   }
-  if (e.type === v.FEATURE_COLLECTION) {
+  if (e.type === h.FEATURE_COLLECTION) {
     if (i.nonEmptyArray(e.features)) {
-      const r = h(e.features, ie, `${t}/features`);
+      const n = L(e.features, ge, `${t}/features`);
       return {
-        ...w(e, r, t),
-        statistics: { ...r.statistics, FeatureCollection: r.statistics.FeatureCollection + 1 }
+        ...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: y()
+      statistics: T()
     };
   }
   return {
     valid: !1,
     errors: [{ message: `Invalid feature: unknown type: ${e.type}`, path: t }],
     warnings: [],
-    statistics: y()
+    statistics: T()
   };
 }
-function Et(e) {
-  if (l.that(e, i.nonEmptyObject, "geojson must be a non empty object"), i.oneOf(e.type, Object.values(f)))
+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 {
-      ...k(e, ""),
-      statistics: { Feature: 0, FeatureCollection: 0, geometries: { [e.type]: 1 } }
+      ...te(e, n),
+      // Geometry counting is owned by validateGeometry.
+      statistics: { Feature: 0, FeatureCollection: 0, geometries: { ...t.statistics.geometries } }
     };
-  if (e.type === v.FEATURE || e.type === v.FEATURE_COLLECTION) {
-    const t = ie(e, "");
-    return We(e, t);
+  }
+  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" }],
+    errors: [{ message: "Invalid GeoJson: type must be either a Geometry, a Feature or a FeatureCollection", path: "" }],
     warnings: [],
-    statistics: y()
+    statistics: T()
   };
 }
 export {
   d as AXES,
-  C as COORDINATE_FORMATS,
-  we as COORDINATE_MODELS,
-  x as COORDINATE_TRUNCATION_FACTORS,
-  L as CRS_TYPES,
-  v as FEATURE_TYPES,
-  f as GEOMETRY_TYPES,
-  gt as convertCoordinate,
-  W as getCoordinatePrecision,
-  Ee as getDirectionAxis,
-  it as getDirections,
-  ot as getEast,
-  pe as getLocale,
-  st as getNorth,
-  at as getSouth,
-  lt as getWest,
-  V as guessCoordinateAxis,
-  et as isAltitude,
-  ue as isAxis,
-  E as isDirection,
-  X as isEast,
-  N as isLatitude,
-  $e as isLikeBBox,
-  mt as isLikeCRS,
-  _e as isLikeFeature,
-  xe as isLikeFeatureCollection,
-  Q as isLikeGeoJson,
-  G as isLikeGeometry,
-  Ge as isLikePosition,
-  Y as isLongitude,
-  ve as isNorth,
-  B as isSouth,
-  _ as isWest,
-  tt as listLocales,
-  ct as normalizeCoordinate,
-  Me as parseCoordinate,
-  ft as parsePosition,
-  nt as registerLocale,
-  rt as setLocale,
-  dt as simplifyGeoJson,
-  U as simplifyGeometry,
-  J as truncateBBox,
-  ut as truncateCoordinate,
-  pt as truncateGeoJson,
-  ee as truncateGeometry,
-  vt as truncatePosition,
-  Pe as validateBBox,
-  He as validateCRS,
-  Et as validateGeoJson,
-  k as validateGeometry,
-  D as validatePosition
+  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
 };
 //# sourceMappingURL=index.mjs.map