@kalisio/common-geospatial 0.7.0 → 0.9.0

package/dist/index.mjs

@@ -1,416 +1,1106 @@
-import { assert as u, is as i, has as A, conform as T, optional as $ } from "@kalisio/common-core";
-import { getLogger as Q } from "@logtape/logtape";
-import { Heap as fe } from "heap-js";
-import me from "@turf/truncate";
-import de from "@turf/boolean-clockwise";
-import pe from "@turf/kinks";
-const d = {
+import { optional as h, is as l, conform as V, assert as _, object as St } from "@kalisio/common-core";
+import b from "proj4";
+import { coordAll as W } from "@turf/meta";
+import { convex as _t } from "@turf/convex";
+import { featureCollection as ht, feature as bt } from "@turf/helpers";
+import Rt from "@turf/buffer";
+import { Heap as Dt } from "heap-js";
+const ie = typeof process > "u" || process.env?.NODE_ENV !== "production";
+class Ie extends Error {
+  constructor(t) {
+    super(t), this.name = "AssertionError";
+  }
+}
+function ye(e, t, n) {
+  if (!t(e)) throw new Ie(n);
+}
+const u = {
+  that(e, t, n) {
+    ie && ye(e, t, n);
+  },
+  all(e) {
+    if (ie)
+      for (const { value: t, validator: n, message: r } of e)
+        ye(t, n, r);
+  },
+  any(e) {
+    if (!(!ie || e.length === 0) && !e.some(({ value: t, validator: n }) => n(t)))
+      throw new Ie(e.map(({ message: t }) => t).join(" or "));
+  }
+}, a = {
+  defined(e) {
+    return e != null;
+  },
+  nil(e) {
+    return !a.defined(e);
+  },
+  plainObject(e) {
+    return a.defined(e) && typeof e == "object" && !Array.isArray(e) && e.constructor === Object;
+  },
+  emptyObject(e) {
+    return a.plainObject(e) && Object.keys(e).length === 0;
+  },
+  nonEmptyObject(e) {
+    return a.plainObject(e) && Object.keys(e).length > 0;
+  },
+  boolean(e) {
+    return typeof e == "boolean";
+  },
+  booleanTrue(e) {
+    return e === !0;
+  },
+  booleanFalse(e) {
+    return e === !1;
+  },
+  string(e) {
+    return typeof e == "string";
+  },
+  emptyString(e) {
+    return a.string(e) && e.trim().length === 0;
+  },
+  nonEmptyString(e) {
+    return a.string(e) && e.trim().length > 0;
+  },
+  char(e) {
+    return a.string(e) && /^.$/u.test(e);
+  },
+  hex(e) {
+    return a.nonEmptyString(e) && e.length % 2 === 0 && /^[0-9a-fA-F]*$/.test(e);
+  },
+  dataUri(e) {
+    return a.string(e) ? e.startsWith("data:") && e.includes(";base64,") : !1;
+  },
+  url(e) {
+    if (typeof e != "string") return !1;
+    const t = /^([a-z][a-z0-9+.-]*:\/\/)([^/?#]+)(\/[^?#]*)?(\?[^#]*)?(#.*)?$/i.exec(e);
+    if (!t?.[2].includes(",")) return URL.canParse(e);
+    const [, n, r, i = "", s = "", o = ""] = t;
+    return r.split(",").every((c, g) => (c = c.trim(), !c || g > 0 && c.includes("@") ? !1 : URL.canParse(`${n}${c}${i}${s}${o}`)));
+  },
+  email(e) {
+    if (!a.string(e)) return !1;
+    const t = /^[-!#$%&'*+/0-9=?A-Z^_a-z`{|}~](\.?[-!#$%&'*+/0-9=?A-Z^_a-z`{|}~])*@[a-zA-Z0-9](-?\.?[a-zA-Z0-9])*\.[a-zA-Z](-?[a-zA-Z0-9])+$/, [n, r] = e.split("@");
+    return !n || !r || n.length > 64 || r.length > 255 || r.split(".").some((i) => i.length > 63) ? !1 : t.test(e);
+  },
+  regularExpression(e) {
+    return a.defined(e) && e instanceof RegExp;
+  },
+  number(e) {
+    return typeof e == "number" && !isNaN(e) && isFinite(e);
+  },
+  positive(e) {
+    return a.number(e) && e > 0;
+  },
+  nonPositive(e) {
+    return a.number(e) && e <= 0;
+  },
+  negative(e) {
+    return a.number(e) && e < 0;
+  },
+  nonNegative(e) {
+    return a.number(e) && e >= 0;
+  },
+  inRange(e, t, n) {
+    return u.that(n, (r) => r >= t, "max must be greater than or equal to min"), a.number(e) && e >= t && e <= n;
+  },
+  inRangeExclusive(e, t, n) {
+    return u.that(n, (r) => r > t, "max must be greater than min"), a.number(e) && e > t && e < n;
+  },
+  inRangeExclusiveMin(e, t, n) {
+    return u.that(n, (r) => r > t, "max must be greater than min"), a.number(e) && e > t && e <= n;
+  },
+  inRangeExclusiveMax(e, t, n) {
+    return u.that(n, (r) => r >= t, "max must be greater than or equal to min"), a.number(e) && e >= t && e < n;
+  },
+  integer(e) {
+    return a.number(e) && Number.isInteger(e);
+  },
+  positiveInteger(e) {
+    return a.integer(e) && a.positive(e);
+  },
+  nonPositiveInteger(e) {
+    return a.integer(e) && a.nonPositive(e);
+  },
+  negativeInteger(e) {
+    return a.integer(e) && a.negative(e);
+  },
+  nonNegativeInteger(e) {
+    return a.integer(e) && a.nonNegative(e);
+  },
+  array(e) {
+    return Array.isArray(e);
+  },
+  emptyArray(e) {
+    return a.array(e) && e.length === 0;
+  },
+  nonEmptyArray(e) {
+    return a.array(e) && e.length > 0;
+  },
+  arrayOfLength(e, t) {
+    return u.that(t, a.nonNegativeInteger, "length must be a non negative integer"), a.array(e) && e.length === t;
+  },
+  arrayOfLengthAtLeast(e, t) {
+    return u.that(t, a.nonNegativeInteger, "minLength must be a non negative integer"), a.array(e) && e.length >= t;
+  },
+  arrayOfLengthAtMost(e, t) {
+    return u.that(t, a.nonNegativeInteger, "maxLength must be a non negative integer"), a.array(e) && e.length <= t;
+  },
+  arrayOfLengthBetween(e, t, n) {
+    return u.all([
+      { value: t, validator: a.nonNegativeInteger, message: "minLength must be a non negative integer" },
+      { value: n, validator: a.nonNegativeInteger, message: "maxLength must be a non negative integer" },
+      { value: t, validator: (r) => r <= n, message: "minLength must be less than or equal to maxLength" }
+    ]), a.array(e) && e.length >= t && e.length <= n;
+  },
+  map(e) {
+    return a.defined(e) && e instanceof Map;
+  },
+  emptyMap(e) {
+    return a.map(e) && e.size === 0;
+  },
+  nonEmptyMap(e) {
+    return a.map(e) && e.size > 0;
+  },
+  set(e) {
+    return a.defined(e) && e instanceof Set;
+  },
+  emptySet(e) {
+    return a.set(e) && e.size === 0;
+  },
+  nonEmptySet(e) {
+    return a.set(e) && e.size > 0;
+  },
+  function(e) {
+    return typeof e == "function";
+  },
+  oneOf(e, t) {
+    return u.that(t, a.nonEmptyArray, "allowed values must be a non empty array"), t.includes(e);
+  },
+  empty(e) {
+    return a.nil(e) ? !0 : a.string(e) ? a.emptyString(e) : a.array(e) ? a.emptyArray(e) : a.plainObject(e) ? a.emptyObject(e) : a.map(e) ? a.emptyMap(e) : a.set(e) ? a.emptySet(e) : !1;
+  }
+}, A = {
+  key(e, t) {
+    return u.all([
+      { value: e, validator: a.plainObject, message: "obj must be an object" },
+      { value: t, validator: a.nonEmptyString, message: "key must be a non empty string" }
+    ]), Object.hasOwn(e, t);
+  },
+  keys(e, t) {
+    return u.all([
+      { value: e, validator: a.plainObject, message: "obj must be an object" },
+      { value: t, validator: (n) => a.array(n) && n.length > 0 && n.every(a.nonEmptyString), message: "keys must be an array of non empty strings" }
+    ]), t.every((n) => A.key(e, n));
+  },
+  keyWithValue(e, t) {
+    return A.key(e, t) && a.defined(e[t]);
+  },
+  path(e, t) {
+    u.all([
+      { value: e, validator: a.plainObject, message: "obj must be an object" },
+      { value: t, validator: a.nonEmptyString, message: "path must be a non empty string" }
+    ]);
+    let n = e;
+    for (const r of t.split(".")) {
+      if (!n || !a.plainObject(n) || !(r in n)) return !1;
+      n = n[r];
+    }
+    return !0;
+  }
+};
+function Ye(e, t, n = "") {
+  return Object.entries(t).every(([r, i]) => {
+    const s = n ? `${n}.${r}` : r;
+    if (!A.key(e, r))
+      return i._optional === !0;
+    const o = e[r];
+    if (a.plainObject(i))
+      return a.plainObject(o) && Ye(o, i, s);
+    if (typeof i == "function")
+      return i(o);
+    throw new Ie(`Invalid validator for key "${s}"`);
+  });
+}
+const y = {
+  schema(e, t) {
+    return u.all([
+      { value: e, validator: a.plainObject, message: "obj must be an object" },
+      { value: t, validator: a.plainObject, message: "schema must be an object" }
+    ]), Ye(e, t);
+  }
+};
+function N(e) {
+  u.that(e, a.function, "validator must be a function");
+  function t(n) {
+    return a.nil(n) ? !0 : e(n);
+  }
+  return t._optional = !0, t;
+}
+const O = {
   LATITUDE: "LAT",
   LONGITUDE: "LON",
   ALTITUDE: "ALT"
 };
-function ve(e) {
-  return u.that(e, i.string, "axis must be a string"), Object.values(d).includes(e);
+function He(e) {
+  return u.that(e, a.string, "axis must be a string"), Object.values(O).includes(e);
 }
-function M(e) {
-  return u.that(e, i.string, "axis must be a string"), e === d.LATITUDE;
+function X(e) {
+  return u.that(e, a.string, "axis must be a string"), e === O.LATITUDE;
 }
-function Z(e) {
-  return u.that(e, i.string, "axis must be a string"), e === d.LONGITUDE;
+function Ee(e) {
+  return u.that(e, a.string, "axis must be a string"), e === O.LONGITUDE;
 }
-function ut(e) {
-  return u.that(e, i.string, "axis must be a string"), e === d.ALTITUDE;
+function zn(e) {
+  return u.that(e, a.string, "axis must be a string"), e === O.ALTITUDE;
 }
-const Ee = { NORTH: { label: "Nord", symbol: "N" }, SOUTH: { label: "Sud", symbol: "S" }, EAST: { label: "Est", symbol: "E" }, WEST: { label: "Ouest", symbol: "O" } }, be = {
-  DIRECTIONS: Ee
-}, he = { NORTH: { label: "North", symbol: "N" }, SOUTH: { label: "South", symbol: "S" }, EAST: { label: "East", symbol: "E" }, WEST: { label: "West", symbol: "W" } }, ye = {
-  DIRECTIONS: he
-}, Oe = {
+const At = { NORTH: { label: "Nord", symbol: "N" }, SOUTH: { label: "Sud", symbol: "S" }, EAST: { label: "Est", symbol: "E" }, WEST: { label: "Ouest", symbol: "O" } }, yt = { EMPTY_OBJECT: "L'objet est vide", UNKNOWN_TYPE: "Le type GeoJSON est inconnu", MISSING_GEOMETRY: "La géométrie est manquante", INVALID_FEATURES_ARRAY: "Le tableau de features est invalide", INVALID_GEOMETRY: "La géométrie est invalide", INVALID_GEOMETRY_TYPE: "Le type de géométrie est invalide", INVALID_COORDINATES_LENGTH: "Le nombre de coordonnées est invalide", INVALID_MULTI_LINESTRING_COORDINATES: "Les coordonnées du MultiLineString sont invalides", INVALID_POLYGON_COORDINATES: "Les coordonnées du Polygon sont invalides", INVALID_MULTIPOLYGON_COORDINATES: "Les coordonnées du MultiPolygon sont invalides", INVALID_GEOMETRYCOLLECTION_GEOMETRIES: "Les géométries de la GeometryCollection sont invalides", RING_NOT_CLOSED: "L'anneau n'est pas fermé", INVALID_WINDING_ORDER: "L'ordre d'orientation de l'anneau est invalide", SELF_INTERSECTION: "Une auto-intersection a été détectée", HOLE_INTERSECTS_SHELL: "Un trou intersecte le contour extérieur", ANTIMERIDIAN_CROSSING: "La géométrie traverse l'antiméridien", DUPLICATE_POSITION: "Une position consécutive est dupliquée", INVALID_POSITION_LENGTH: "Le nombre de coordonnées de la position est invalide", INVALID_POSITION_COORDINATES: "Les coordonnées de la position sont invalides", INVALID_LONGITUDE_RANGE: "La longitude est hors limites", INVALID_LATITUDE_RANGE: "La latitude est hors limites", INVALID_ALTITUDE: "L'altitude est invalide", EXCESSIVE_LONGITUDE_PRECISION: "La précision de la longitude est excessive", EXCESSIVE_LATITUDE_PRECISION: "La précision de la latitude est excessive", INVALID_BBOX_LENGTH: "Le nombre de coordonnées de la boîte englobante est invalide", INVALID_BBOX_LATITUDE_ORDER: "L'ordre des latitudes de la boîte englobante est invalide", INVALID_BBOX_LONGITUDE_ORDER: "L'ordre des longitudes de la boîte englobante est invalide", INVALID_BBOX_ALTITUDE_ORDER: "L'ordre des altitudes de la boîte englobante est invalide", BBOX_ANTIMERIDIAN_CROSSING: "La boîte englobante traverse l'antiméridien", INVALID_CRS_OBJECT: "L'objet CRS est invalide", INVALID_CRS_NAME: "Le nom du CRS est invalide", INVALID_CRS_LINK: "Le lien du CRS est invalide", INVALID_CRS_TYPE: "Le type de CRS est invalide", UNSUPPORTED_CRS: "Le CRS n'est pas pris en charge", UNSUPPORTED_LINK_CRS: "Le lien CRS n'est pas pris en charge", UNSUPPORTED_NESTED_CRS: "Le CRS imbriqué n'est pas pris en charge" }, Ct = {
+  DIRECTIONS: At,
+  VALIDATION: yt
+}, Gt = { NORTH: { label: "North", symbol: "N" }, SOUTH: { label: "South", symbol: "S" }, EAST: { label: "East", symbol: "E" }, WEST: { label: "West", symbol: "W" } }, Mt = { EMPTY_OBJECT: "Object is empty", UNKNOWN_TYPE: "Unknown GeoJSON type", MISSING_GEOMETRY: "Geometry is missing", INVALID_FEATURES_ARRAY: "Features array is invalid", INVALID_GEOMETRY: "Geometry is invalid", INVALID_GEOMETRY_TYPE: "Geometry type is invalid", INVALID_COORDINATES_LENGTH: "Coordinates length is invalid", INVALID_MULTI_LINESTRING_COORDINATES: "MultiLineString coordinates are invalid", INVALID_POLYGON_COORDINATES: "Polygon coordinates are invalid", INVALID_MULTIPOLYGON_COORDINATES: "MultiPolygon coordinates are invalid", INVALID_GEOMETRYCOLLECTION_GEOMETRIES: "GeometryCollection geometries are invalid", RING_NOT_CLOSED: "Ring is not closed", INVALID_WINDING_ORDER: "Ring winding order is invalid", SELF_INTERSECTION: "Self-intersection detected", HOLE_INTERSECTS_SHELL: "A hole intersects the exterior ring", ANTIMERIDIAN_CROSSING: "Geometry crosses the antimeridian", DUPLICATE_POSITION: "Consecutive position is duplicated", INVALID_POSITION_LENGTH: "Position length is invalid", INVALID_POSITION_COORDINATES: "Position coordinates are invalid", INVALID_LONGITUDE_RANGE: "Longitude is out of range", INVALID_LATITUDE_RANGE: "Latitude is out of range", INVALID_ALTITUDE: "Altitude is invalid", EXCESSIVE_LONGITUDE_PRECISION: "Longitude precision is excessive", EXCESSIVE_LATITUDE_PRECISION: "Latitude precision is excessive", INVALID_BBOX_LENGTH: "Bounding box length is invalid", INVALID_BBOX_LATITUDE_ORDER: "Bounding box latitude order is invalid", INVALID_BBOX_LONGITUDE_ORDER: "Bounding box longitude order is invalid", INVALID_BBOX_ALTITUDE_ORDER: "Bounding box altitude order is invalid", BBOX_ANTIMERIDIAN_CROSSING: "Bounding box crosses the antimeridian", INVALID_CRS_OBJECT: "CRS object is invalid", INVALID_CRS_NAME: "CRS name is invalid", INVALID_CRS_LINK: "CRS link is invalid", INVALID_CRS_TYPE: "CRS type is invalid", UNSUPPORTED_CRS: "CRS is not supported", UNSUPPORTED_LINK_CRS: "CRS link is not supported", UNSUPPORTED_NESTED_CRS: "Nested CRS is not supported" }, We = {
+  DIRECTIONS: Gt,
+  VALIDATION: Mt
+}, Pt = {
   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 }
-  }
-}, h = {
-  en: ye,
-  fr: be
+    NORTH: { label: a.string, symbol: a.char },
+    SOUTH: { label: a.string, symbol: a.char },
+    EAST: { label: a.string, symbol: a.char },
+    WEST: { label: a.string, symbol: a.char }
+  }
+}, P = {
+  en: We,
+  fr: Ct
 };
-let O = "en";
-const Y = "en";
-function lt() {
-  return Object.keys(h);
+let x = "en";
+const Ce = "en";
+function Kn() {
+  return Object.keys(P);
 }
-function ct(e, t) {
+function qn(e) {
   u.all([
-    { value: e, validator: i.string, message: "code must be a string" },
-    { value: e, validator: (r) => !A.key(h, r), message: "locale already registered" },
-    { value: t, validator: i.plainObject, message: "content must be an object" },
-    { value: t, validator: (r) => T.schema(r, Oe), message: "content does not conform to schema" }
-  ]), h[e] = t;
+    { value: e, validator: a.string, message: "code must be a string" },
+    { value: e, validator: (t) => A.key(P, t), message: "code is unknown" }
+  ]), x = e;
 }
-function gt(e) {
-  u.all([
-    { value: e, validator: i.string, message: "code must be a string" },
-    { value: e, validator: (t) => A.key(h, t), message: "code is unknown" }
-  ]), O = e;
+function Ut() {
+  return x;
 }
-function Te() {
-  return O;
+function Xe() {
+  return x === Ce ? [x] : [x, Ce];
 }
-function U(e) {
+function Zn(e, t) {
+  u.all([
+    { value: e, validator: a.string, message: "code must be a string" },
+    { value: e, validator: (n) => !A.key(P, n), message: "messages already registered" },
+    { value: t, validator: a.plainObject, message: "messages must be an object" },
+    { value: t, validator: (n) => y.schema(n, Pt), message: "messages do not conform to schema" }
+  ]), P[e] = t;
+}
+function Oe(e) {
   return u.all([
-    { value: e, validator: i.string, message: "code must be a string" },
-    { value: e, validator: (t) => A.key(h, t), message: "code is unknown" }
-  ]), h[e];
+    { value: e, validator: a.string, message: "code must be a string" },
+    { value: e, validator: (t) => A.key(P, t), message: "code is unknown" }
+  ]), P[e];
 }
-function J() {
-  return O === Y ? [O] : [O, Y];
+function $() {
+  return Oe(Ut()).DIRECTIONS;
 }
-function _(e) {
+function ae(e) {
   const t = /* @__PURE__ */ new Set();
-  for (const r of J()) {
-    const { DIRECTIONS: n } = U(r);
-    for (const s of e) t.add(n[s].symbol);
+  for (const n of Xe()) {
+    const { DIRECTIONS: r } = Oe(n);
+    for (const i of e) t.add(r[i].symbol);
   }
   return [...t];
 }
-function Ie() {
-  return _(["NORTH", "SOUTH"]);
-}
-function Le() {
-  return _(["EAST", "WEST"]);
-}
-function F() {
-  return _(["NORTH", "SOUTH", "EAST", "WEST"]);
-}
-function I() {
-  return U(Te()).DIRECTIONS;
-}
-function w(e, t) {
-  const r = t.toUpperCase();
-  return J().some((n) => {
-    const { label: s, symbol: o } = U(n).DIRECTIONS[e];
-    return r === s.toUpperCase() || r === o.toUpperCase();
+function te(e, t) {
+  const n = t.toUpperCase();
+  return Xe().some((r) => {
+    const { label: i, symbol: s } = Oe(r).DIRECTIONS[e];
+    return n === i.toUpperCase() || n === s.toUpperCase();
   });
 }
-function ft(e = null) {
-  const t = I();
-  return i.defined(e) ? (u.that(e, ve, "axis must be a valid axis"), M(e) ? [t.SOUTH, t.NORTH] : Z(e) ? [t.EAST, t.WEST] : []) : [t.SOUTH, t.NORTH, t.EAST, t.WEST];
+function Qn(e = null) {
+  const t = $();
+  return a.defined(e) ? (u.that(e, He, "axis must be a valid axis"), X(e) ? [t.SOUTH, t.NORTH] : Ee(e) ? [t.EAST, t.WEST] : []) : [t.SOUTH, t.NORTH, t.EAST, t.WEST];
 }
-function mt() {
-  return I().NORTH;
+function B(e = null) {
+  return a.defined(e) ? (u.that(e, He, "axis must be a valid axis"), X(e) ? ae(["NORTH", "SOUTH"]) : Ee(e) ? ae(["EAST", "WEST"]) : []) : ae(["NORTH", "SOUTH", "EAST", "WEST"]);
 }
-function dt() {
-  return I().SOUTH;
+function Jn() {
+  return $().NORTH;
 }
-function pt() {
-  return I().EAST;
+function er() {
+  return $().SOUTH;
 }
-function vt() {
-  return I().WEST;
+function tr() {
+  return $().EAST;
 }
-function E(e) {
-  return u.that(e, i.string, "dir must be a string"), Se(e) || ee(e) || k(e) || C(e);
+function nr() {
+  return $().WEST;
 }
-function Se(e) {
-  return u.that(e, i.string, "dir must be a string"), w("NORTH", e);
+function C(e) {
+  return u.that(e, a.string, "dir must be a string"), Vt(e) || ze(e) || Ne(e) || ne(e);
 }
-function ee(e) {
-  return u.that(e, i.string, "dir must be a string"), w("SOUTH", e);
+function Vt(e) {
+  return u.that(e, a.string, "dir must be a string"), te("NORTH", e);
 }
-function k(e) {
-  return u.that(e, i.string, "dir must be a string"), w("EAST", e);
+function ze(e) {
+  return u.that(e, a.string, "dir must be a string"), te("SOUTH", e);
 }
-function C(e) {
-  return u.that(e, i.string, "dir must be a string"), w("WEST", e);
-}
-function Re(e) {
-  return u.that(e, E, "dir must be a direction"), C(e) || k(e) ? d.LONGITUDE : d.LATITUDE;
-}
-const De = {
-  degrees: i.number,
-  direction: $(E)
-}, Ae = /^(-?\d{1,3}(?:\.\d+)?)°?$/;
-function we() {
-  return new RegExp(`^(\\d{1,3}(?:\\.\\d+)?)°?([${F()}])$`, "i");
-}
-function L(e) {
-  let t = null, r = null;
-  if (i.plainObject(e) && T.schema(e, De))
-    i.defined(e.direction) ? e.degrees >= 0 && (t = e.degrees, r = e.direction) : t = e.degrees;
-  else if (i.string(e)) {
-    const n = e.replace(/\s+/g, ""), s = n.match(Ae) ?? n.match(we());
-    s && (t = parseFloat(s[1]), r = s[2] ?? null);
+function Ne(e) {
+  return u.that(e, a.string, "dir must be a string"), te("EAST", e);
+}
+function ne(e) {
+  return u.that(e, a.string, "dir must be a string"), te("WEST", e);
+}
+function wt(e) {
+  return u.that(e, C, "dir must be a direction"), ne(e) || Ne(e) ? O.LONGITUDE : O.LATITUDE;
+}
+const jt = {
+  degrees: l.number,
+  direction: h(C)
+}, xt = /^(-?\d{1,3}(?:\.\d+)?)°?$/;
+function kt() {
+  return new RegExp(`^(\\d{1,3}(?:\\.\\d+)?)°?([${B()}])$`, "i");
+}
+function Y(e) {
+  let t = null, n = null;
+  if (l.plainObject(e) && V.schema(e, jt))
+    l.defined(e.direction) ? e.degrees >= 0 && (t = e.degrees, n = e.direction) : t = e.degrees;
+  else if (l.string(e)) {
+    const r = e.replace(/\s+/g, ""), i = r.match(xt) ?? r.match(kt());
+    i && (t = parseFloat(i[1]), n = i[2] ?? null);
   }
   return {
     get degrees() {
       return t;
     },
     get direction() {
-      return r;
+      return n;
     },
     get format() {
       return "DD";
     },
     isValid() {
-      return i.number(t);
+      return l.number(t);
     },
-    toString(n) {
-      if (u.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 (_.that(r, l.positiveInteger, "decimalPlaces must be a positive integer"), !this.isValid()) return "";
+      let i = `${t.toFixed(r)}°`;
+      return n && (i += ` ${n}`), i;
     },
     toDecimal() {
-      return this.isValid() ? L({ degrees: t, direction: r }) : null;
+      return this.isValid() ? Y({ degrees: t, direction: n }) : null;
     }
   };
 }
-const Ce = {
-  degrees: i.integer,
-  minutes: (e) => i.inRangeExclusiveMax(e, 0, 60),
-  direction: $(E)
-}, Ne = /^(-?\d{1,3})°(\d{1,2}(?:\.\d+)?)'?$/;
-function Me() {
-  return new RegExp(`^(\\d{1,3})°(\\d{1,2}(?:\\.\\d+)?)'?([${F().join("")}])$`, "i");
-}
-function te(e) {
-  let t = null, r = null, n = null;
-  if (i.plainObject(e) && T.schema(e, Ce))
-    i.defined(e.direction) ? e.degrees >= 0 && (t = e.degrees, r = e.minutes, n = e.direction) : (t = e.degrees, r = e.minutes);
-  else if (i.string(e)) {
-    const s = e.replace(/\s+/g, ""), o = s.match(Ne) ?? s.match(Me());
-    o && (t = parseFloat(o[1]), r = parseFloat(o[2]), n = o[3] ?? null);
+const Ft = {
+  degrees: l.integer,
+  minutes: (e) => l.inRangeExclusiveMax(e, 0, 60),
+  direction: h(C)
+}, $t = /^(-?\d{1,3})°(\d{1,2}(?:\.\d+)?)'?$/;
+function Bt() {
+  return new RegExp(`^(\\d{1,3})°(\\d{1,2}(?:\\.\\d+)?)'?([${B().join("")}])$`, "i");
+}
+function Ke(e) {
+  let t = null, n = null, r = null;
+  if (l.plainObject(e) && V.schema(e, Ft))
+    l.defined(e.direction) ? e.degrees >= 0 && (t = e.degrees, n = e.minutes, r = e.direction) : (t = e.degrees, n = e.minutes);
+  else if (l.string(e)) {
+    const i = e.replace(/\s+/g, ""), s = i.match($t) ?? i.match(Bt());
+    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 l.integer(t) && l.inRangeExclusiveMax(n, 0, 60);
     },
-    toString(s) {
-      if (u.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(i) {
+      if (_.that(i, l.positiveInteger, "decimalPlaces must be a positive integer"), !this.isValid()) return "";
+      let s = `${t}° ${n.toFixed(i)}'`;
+      return r && (s += ` ${r}`), s;
     },
     toDecimal() {
-      return this.isValid() ? L({ degrees: t + r / 60, direction: n }) : null;
+      return this.isValid() ? Y({ degrees: t + n / 60, direction: r }) : null;
     }
   };
 }
-const xe = {
-  degrees: i.nonNegativeInteger,
-  minutes: (e) => i.inRangeExclusiveMax(e, 0, 60),
-  direction: E
+const Yt = {
+  degrees: l.nonNegativeInteger,
+  minutes: (e) => l.inRangeExclusiveMax(e, 0, 60),
+  direction: C
 };
-function $e() {
-  return new RegExp(`^(\\d{2})(\\d{3})([${Ie().join("")}])$`, "i");
+function Ht() {
+  return new RegExp(`^(\\d{2})(\\d{3})([${B(O.LATITUDE).join("")}])$`, "i");
 }
-function Ue() {
-  return new RegExp(`^(\\d{3})(\\d{3})([${Le().join("")}])$`, "i");
+function Wt() {
+  return new RegExp(`^(\\d{3})(\\d{3})([${B(O.LONGITUDE).join("")}])$`, "i");
 }
-function ne(e) {
-  let t = null, r = null, n = null;
-  if (i.plainObject(e) && T.schema(e, xe))
-    t = e.degrees, r = e.minutes, n = e.direction;
-  else if (i.string(e)) {
-    const s = e.trim(), o = s.match($e()) ?? s.match(Ue());
-    o && (t = parseFloat(o[1]), r = parseFloat(o[2]) / 10, n = o[3]);
+function qe(e) {
+  let t = null, n = null, r = null;
+  if (l.plainObject(e) && V.schema(e, Yt))
+    t = e.degrees, n = e.minutes, r = e.direction;
+  else if (l.string(e)) {
+    const i = e.trim(), s = i.match(Ht()) ?? i.match(Wt());
+    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 l.nonNegativeInteger(t) && l.inRangeExclusiveMax(n, 0, 60) && C(r);
     },
     toString() {
       if (!this.isValid()) return "";
-      const s = k(n) || C(n), o = String(t).padStart(s ? 3 : 2, "0"), l = Math.floor(r * 10).toString().padStart(3, "0");
-      return `${o}${l}${n}`;
+      const i = Ne(r) || ne(r), s = String(t).padStart(i ? 3 : 2, "0"), o = Math.floor(n * 10).toString().padStart(3, "0");
+      return `${s}${o}${r}`;
     },
     toDecimal() {
-      return this.isValid() ? L({ degrees: t + r / 60, direction: n }) : null;
+      return this.isValid() ? Y({ degrees: t + n / 60, direction: r }) : null;
     }
   };
 }
-const _e = {
-  degrees: i.integer,
-  minutes: (e) => i.integer(e) && i.inRange(e, 0, 59),
-  seconds: (e) => i.inRangeExclusiveMax(e, 0, 60),
-  direction: $(E)
-}, Fe = /^(-?\d{1,3})°(\d{1,2})'(\d{1,2}(?:\.\d+)?)"?$/;
-function ke() {
-  return new RegExp(`^(\\d{1,3})°(\\d{1,2})'(\\d{1,2}(?:\\.\\d+)?)"?([${F().join("")}])$`, "i");
-}
-function re(e) {
-  let t = null, r = null, n = null, s = null;
-  if (i.plainObject(e) && T.schema(e, _e))
-    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);
-  else if (i.string(e)) {
-    const o = e.replace(/\s+/g, ""), l = o.match(Fe) ?? o.match(ke());
-    l && (t = parseFloat(l[1]), r = parseFloat(l[2]), n = parseFloat(l[3]), s = l[4] ?? null);
+const Xt = {
+  degrees: l.integer,
+  minutes: (e) => l.integer(e) && l.inRange(e, 0, 59),
+  seconds: (e) => l.inRangeExclusiveMax(e, 0, 60),
+  direction: h(C)
+}, zt = /^(-?\d{1,3})°(\d{1,2})'(\d{1,2}(?:\.\d+)?)"?$/;
+function Kt() {
+  return new RegExp(`^(\\d{1,3})°(\\d{1,2})'(\\d{1,2}(?:\\.\\d+)?)"?([${B().join("")}])$`, "i");
+}
+function Ze(e) {
+  let t = null, n = null, r = null, i = null;
+  if (l.plainObject(e) && V.schema(e, Xt))
+    l.defined(e.direction) ? e.degrees >= 0 && (t = e.degrees, n = e.minutes, r = e.seconds, i = e.direction) : (t = e.degrees, n = e.minutes, r = e.seconds);
+  else if (l.string(e)) {
+    const s = e.replace(/\s+/g, ""), o = s.match(zt) ?? s.match(Kt());
+    o && (t = parseFloat(o[1]), n = parseFloat(o[2]), r = parseFloat(o[3]), i = o[4] ?? null);
   }
   return {
     get degrees() {
       return t;
     },
     get minutes() {
-      return r;
+      return n;
     },
     get seconds() {
-      return n;
+      return r;
     },
     get direction() {
-      return s;
+      return i;
     },
     get format() {
       return "DMS";
     },
     isValid() {
-      return i.integer(t) && i.integer(r) && i.inRange(r, 0, 59) && i.inRangeExclusiveMax(n, 0, 60);
+      return l.integer(t) && l.integer(n) && l.inRange(n, 0, 59) && l.inRangeExclusiveMax(r, 0, 60);
     },
-    toString(o) {
-      if (u.that(o, i.positiveInteger, "decimalPlaces must be a positive integer"), !this.isValid()) return "";
-      let l = `${t}° ${r}' ${n.toFixed(o)}"`;
-      return s && (l += ` ${s}`), l;
+    toString(s) {
+      if (_.that(s, l.positiveInteger, "decimalPlaces must be a positive integer"), !this.isValid()) return "";
+      let o = `${t}° ${n}' ${r.toFixed(s)}"`;
+      return i && (o += ` ${i}`), o;
     },
     toDecimal() {
-      return this.isValid() ? L({ degrees: t + r / 60 + n / 3600, direction: s }) : null;
+      return this.isValid() ? Y({ degrees: t + n / 60 + r / 3600, direction: i }) : null;
     }
   };
 }
-function W(e) {
-  const t = Math.floor(e.degrees), r = (e.degrees - t) * 60;
-  return { degrees: t, minutes: r, direction: e.direction };
-}
 function Ge(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 };
+  const t = Math.floor(e.degrees), n = (e.degrees - t) * 60;
+  return { degrees: t, minutes: n, direction: e.direction };
+}
+function qt(e) {
+  const t = Math.floor(e.degrees), n = (e.degrees - t) * 60, r = Math.floor(n), i = (n - r) * 60;
+  return { degrees: t, minutes: r, seconds: i, direction: e.direction };
 }
-const K = {
-  DD: (e) => (u.that(e, (t) => t.isValid(), "dd must be a valid coordinate"), e),
+const Me = {
+  DD: (e) => (_.that(e, (t) => t.isValid(), "dd must be a valid coordinate"), e),
   DDM: (e) => {
-    u.that(e, (s) => s.isValid(), "dd must be a valid coordinate");
-    const { degrees: t, minutes: r, direction: n } = W(e);
-    return te(n ? { degrees: t, minutes: r, direction: n } : { degrees: t, minutes: r });
+    _.that(e, (i) => i.isValid(), "dd must be a valid coordinate");
+    const { degrees: t, minutes: n, direction: r } = Ge(e);
+    return Ke(r ? { degrees: t, minutes: n, direction: r } : { degrees: t, minutes: n });
   },
   DMS: (e) => {
-    u.that(e, (o) => o.isValid(), "dd must be a valid coordinate");
-    const { degrees: t, minutes: r, seconds: n, direction: s } = Ge(e);
-    return re(s ? { degrees: t, minutes: r, seconds: n, direction: s } : { degrees: t, minutes: r, seconds: n });
+    _.that(e, (s) => s.isValid(), "dd must be a valid coordinate");
+    const { degrees: t, minutes: n, seconds: r, direction: i } = qt(e);
+    return Ze(i ? { degrees: t, minutes: n, seconds: r, direction: i } : { degrees: t, minutes: n, seconds: r });
   },
   DDM_AERO: (e) => {
-    u.that(e, (s) => s.isValid(), "dd must be a valid coordinate");
-    const { degrees: t, minutes: r, direction: n } = W(e);
-    return ne({ degrees: t, minutes: r, direction: n });
+    _.that(e, (i) => i.isValid(), "dd must be a valid coordinate");
+    const { degrees: t, minutes: n, direction: r } = Ge(e);
+    return qe({ degrees: t, minutes: n, direction: r });
   }
-}, x = {
+}, fe = {
   DD: "DD",
   DDM: "DDM",
   DDM_AERO: "DDM_AERO",
   DMS: "DMS"
-}, Pe = {
-  DD: L,
-  DDM: te,
-  DDM_AERO: ne,
-  DMS: re
-}, G = Array.from({ length: 9 }, (e, t) => 10 ** t);
-function X(e, t) {
-  if (u.that(e, i.number, "coord must be a number"), i.defined(t))
-    return u.that(t, E, "dir must be a direction"), Re(t);
-  if (Math.abs(e) > 90) return d.LONGITUDE;
-}
-function z(e) {
-  u.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 Et(e, t = 7) {
+}, Zt = {
+  DD: Y,
+  DDM: Ke,
+  DDM_AERO: qe,
+  DMS: Ze
+}, v = 7, R = 8, Qt = Array.from({ length: R + 1 }, (e, t) => 10 ** t);
+function Pe(e, t) {
+  if (u.that(e, a.number, "coord must be a number"), a.defined(t))
+    return u.that(t, C, "dir must be a direction"), wt(t);
+  if (Math.abs(e) > 90) return O.LONGITUDE;
+}
+function Ue(e) {
+  u.that(e, a.number, "coord must be a number");
+  const t = e.toExponential(), [n, r] = t.split("e").map(Number), i = (n.toString().split(".")[1] || "").length;
+  return Math.max(0, i - r);
+}
+function Qe(e, t = v) {
   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: e,
+      validator: a.number,
+      message: "coord must be a number"
+    },
+    {
+      value: t,
+      validator: (r) => a.inRange(r, 0, R),
+      message: `precision must be in range [0, ${R}]`
+    }
   ]);
-  const r = G[t];
-  return Math.round(e * r) / r;
+  const n = Qt[t];
+  return Math.round(e * n) / n;
 }
-function bt(e, t) {
+function rr(e, t) {
   if (u.all([
-    { value: e, validator: i.number, message: "coord must be a number" },
-    { value: t, validator: (n) => Z(n) || M(n), message: "axis must be either a longitude or latitude" }
-  ]), M(t))
+    { value: e, validator: a.number, message: "coord must be a number" },
+    { value: t, validator: (r) => Ee(r) || X(r), message: "axis must be either a longitude or latitude" }
+  ]), X(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 ht(e, t) {
+function ir(e, t) {
   u.all([
-    { value: e, validator: (n) => i.defined(n) && n.isValid(), message: "from must be a valid coordinate" },
-    { value: t, validator: (n) => A.key(K, n), message: `unknown format: ${t}` }
+    { value: e, validator: (r) => a.defined(r) && r.isValid(), message: "from must be a valid coordinate" },
+    { value: t, validator: (r) => A.key(Me, r), message: `unknown format: ${t}` }
   ]);
-  const r = e.format === x.DD ? e : e.toDecimal();
-  return r.isValid() ? t === x.DD ? r : K[t](r) : null;
-}
-function He(e) {
-  u.that(e, i.nonEmptyString, "pattern must be a non empty string");
-  for (const t of Object.keys(x)) {
-    const r = Pe[t](e);
-    if (r.isValid()) return r;
+  const n = e.format === fe.DD ? e : e.toDecimal();
+  return n.isValid() ? t === fe.DD ? n : Me[t](n) : null;
+}
+function Jt(e) {
+  u.that(e, a.nonEmptyString, "pattern must be a non empty string");
+  for (const t of Object.keys(fe)) {
+    const n = Zt[t](e);
+    if (n.isValid()) return n;
   }
   return null;
 }
-function yt(e) {
-  u.that(e, (a) => i.nonEmptyString(a), "pattern must be a non-empty string");
+typeof process < "u" && process.versions?.node != null, typeof WorkerGlobalScope < "u" && self instanceof WorkerGlobalScope, typeof ServiceWorkerGlobalScope < "u" && self instanceof ServiceWorkerGlobalScope, typeof process < "u" && process.env.NODE_ENV, typeof process < "u" && process.env.NODE_ENV, typeof process < "u" && process.env.NODE_ENV;
+const T = {
+  clamp(e, t, n) {
+    return u.all([
+      { value: e, validator: a.number, message: "value must be a number" },
+      { value: t, validator: a.number, message: "min must be a number" },
+      { value: n, validator: a.number, message: "max must be a number" }
+    ]), Math.min(Math.max(e, t), n);
+  },
+  round(e, t = 2) {
+    u.all([
+      { value: e, validator: a.number, message: "value must be a number" },
+      { value: t, validator: a.nonNegativeInteger, message: "precision must be a non-negative integer" }
+    ]);
+    const n = 10 ** t;
+    return Math.round(e * n) / n;
+  },
+  sign(e, t = 0) {
+    return u.all([
+      { value: e, validator: a.number, message: "value must be a number" },
+      { value: t, validator: a.nonNegative, message: "epsilon must be a non-negative number" }
+    ]), e > t ? 1 : e < -t ? -1 : 0;
+  },
+  percentage(e, t) {
+    return u.all([
+      { value: e, validator: a.number, message: "value must be a number" },
+      { value: t, validator: a.number, message: "total must be a number" }
+    ]), T.round(e / t * 100, 2);
+  },
+  exponential(e, t = 2) {
+    if (u.all([
+      { value: e, validator: a.number, message: "value must be a number" },
+      { value: t, validator: a.nonNegativeInteger, message: "decimals must be a non-negative integer" }
+    ]), e === 0) return `0.${"0".repeat(t)}e+0`;
+    const n = Math.floor(Math.log10(Math.abs(e)));
+    return `${(e / Math.pow(10, n)).toFixed(t)}e${n >= 0 ? "+" : ""}${n}`;
+  },
+  linear(e, t = 0, n = 1) {
+    return u.all([
+      { value: e, validator: (r) => a.inRange(r, 0, 1), message: "t must be in range [0, 1]" },
+      { value: t, validator: a.number, message: "initial must be a number" },
+      { value: n, validator: a.number, message: "final must be a number" }
+    ]), t + e * (n - t);
+  },
+  to: {
+    radians(e) {
+      return u.that(e, a.number, "degrees must be a number"), e * Math.PI / 180;
+    },
+    degrees(e) {
+      return u.that(e, a.number, "radians must be a number"), e * 180 / Math.PI;
+    }
+  },
+  pow: {
+    square(e) {
+      return u.that(e, a.number, "value must be a number"), e * e;
+    },
+    cube(e) {
+      return u.that(e, a.number, "value must be a number"), T.pow.square(e) * e;
+    }
+  },
+  ease: {
+    in(e, t = 0.5) {
+      return u.all([
+        { value: e, validator: (n) => a.inRange(n, 0, 1), message: "t must be in range [0, 1]" },
+        { value: t, validator: a.number, message: "linearity must be a number" }
+      ]), Math.pow(e, 1 / t);
+    },
+    out(e, t = 0.5) {
+      return u.all([
+        { value: e, validator: (n) => a.inRange(n, 0, 1), message: "t must be in range [0, 1]" },
+        { value: t, validator: a.number, message: "linearity must be a number" }
+      ]), 1 - Math.pow(1 - e, 1 / t);
+    },
+    cubicBezier(e, t = 0.42, n = 0, r = 0.58, i = 1) {
+      u.that(e, (g) => a.inRange(g, 0, 1), "t must be in range [0, 1]");
+      const s = 1 - e, o = e * e, c = s * s;
+      return c * s * n + 3 * c * e * t + 3 * s * o * r + o * e * i;
+    }
+  },
+  stats: {
+    sum(e) {
+      return u.that(e, a.array, "values must be an array"), e.reduce((t, n) => t + n, 0);
+    },
+    average(e) {
+      return u.that(e, a.nonEmptyArray, "values must be a non-empty array"), T.stats.sum(e) / e.length;
+    },
+    median(e) {
+      u.that(e, a.nonEmptyArray, "values must be a non-empty array");
+      const t = [...e].sort((r, i) => r - i), n = Math.floor(t.length / 2);
+      return t.length % 2 === 0 ? T.linear(0.5, t[n - 1], t[n]) : t[n];
+    }
+  }
+};
+N(a.boolean), N(a.boolean), N(a.boolean), N(a.string);
+N(a.boolean), N(a.boolean), N(a.boolean), N(a.string);
+N(a.array);
+const z = T.to.radians(1), en = 1e-12;
+function U(e) {
+  const t = e[0] * z, n = e[1] * z, r = Math.cos(n);
+  return [r * Math.cos(t), r * Math.sin(t), Math.sin(n)];
+}
+function tn(e) {
+  const t = Math.atan2(e[1], e[0]), n = Math.asin(e[2]);
+  return [t / z, n / z];
+}
+function j(e, t) {
+  return e[0] * t[0] + e[1] * t[1] + e[2] * t[2];
+}
+function k(e, t) {
+  return [
+    e[1] * t[2] - e[2] * t[1],
+    e[2] * t[0] - e[0] * t[2],
+    e[0] * t[1] - e[1] * t[0]
+  ];
+}
+function Je(e, t) {
+  return [e[0] + t[0], e[1] + t[1], e[2] + t[2]];
+}
+function K(e, t) {
+  return [e[0] * t, e[1] * t, e[2] * t];
+}
+function q(e) {
+  return Math.sqrt(e[0] * e[0] + e[1] * e[1] + e[2] * e[2]);
+}
+function nn(e) {
+  const t = q(e);
+  return [e[0] / t, e[1] / t, e[2] / t];
+}
+function rn(e, t) {
+  return Math.atan2(q(k(e, t)), j(e, t));
+}
+function an(e) {
+  return k(e, et(e));
+}
+function et(e) {
+  return nn(k([0, 0, 1], e));
+}
+function sn(e, t) {
+  const n = an(e), r = et(e);
+  return Je(
+    K(n, Math.cos(t)),
+    K(r, Math.sin(t))
+  );
+}
+function on(e, t, n) {
+  const r = sn(e, t);
+  return Je(
+    K(e, Math.cos(n)),
+    K(r, Math.sin(n))
+  );
+}
+function tt(e, t, n, r, i = en) {
+  const s = k(e, t), o = k(n, r), c = q(s), g = q(o);
+  if (c <= i || g <= i) return !1;
+  const E = T.sign(j(s, n) / c, i), f = T.sign(j(s, r) / c, i);
+  if (E * f !== -1) return !1;
+  const I = T.sign(j(o, e) / g, i), D = T.sign(j(o, t) / g, i);
+  return I * D === -1;
+}
+const nt = "WGS84", M = "+proj=longlat +datum=WGS84 +no_defs", un = {
+  WGS84: M,
+  "CRS:84": M,
+  CRS84: M,
+  "urn:ogc:def:crs:OGC:1.3:CRS84": M,
+  "urn:ogc:def:crs:OGC:2:84": M,
+  "urn:ogc:def:crs:EPSG::4326": M,
+  "EPSG:2154": "+proj=lcc +lat_1=49 +lat_2=44 +lat_0=46.5 +lon_0=3 +x_0=700000 +y_0=6600000 +ellps=GRS80 +units=m +no_defs"
+};
+for (const [e, t] of Object.entries(un))
+  b.defs(e) || b.defs(e, t);
+const ln = /^urn:ogc:def:crs:EPSG::(\d+)$/i;
+function rt(e) {
+  u.that(e, a.nonEmptyString, "name must be a non empty string");
+  const t = e.match(ln);
+  return t ? `EPSG:${t[1]}` : e;
+}
+function ar() {
+  return Object.keys(b.defs);
+}
+function sr(e, t) {
+  u.all([
+    {
+      value: e,
+      validator: a.nonEmptyString,
+      message: "name must be a non empty string"
+    },
+    {
+      value: t,
+      validator: (n) => a.nonEmptyString(n) || a.nonEmptyObject(n),
+      message: "definition must be a non empty string or a non empty object"
+    }
+  ]), b.defs(e, t);
+}
+function F(e) {
+  return u.that(e, a.nonEmptyString, "name must be a non empty string"), a.defined(b.defs(e));
+}
+function or(e) {
+  return u.that(e, a.nonEmptyString, "name must be a non empty string"), b.defs(e);
+}
+function it(e) {
+  u.that(e, a.nonEmptyString, "name must be a non empty string");
+  const t = b.defs(e);
+  if (!t) return !1;
+  const n = b.defs("EPSG:4326");
+  return t.projName === n.projName && t.datumCode === n.datumCode;
+}
+const re = {
+  precision: N(a.number),
+  consider3D: N(a.boolean)
+}, at = 63710088e-1;
+function ur(e) {
+  u.that(e, (E) => a.nonEmptyString(E), "pattern must be a non-empty string");
   const t = e.split(/[,;|]/);
   if (t.length !== 2) return null;
-  const [r, n] = t.map(He);
-  if (!r || !n) return null;
-  const s = r.toDecimal(), o = n.toDecimal(), l = X(s.degrees, s.direction), g = X(o.degrees, o.direction), c = (a) => {
-    const { degrees: p, direction: f } = a;
-    return f && (C(f) || ee(f)) ? -p : p;
+  const [n, r] = t.map(Jt);
+  if (!n || !r) return null;
+  const i = n.toDecimal(), s = r.toDecimal(), o = Pe(i.degrees, i.direction), c = Pe(s.degrees, s.direction), g = (E) => {
+    const { degrees: f, direction: I } = E;
+    return I && (ne(I) || ze(I)) ? -f : f;
   };
-  if (l === d.LONGITUDE && g === d.LATITUDE) return [c(s), c(o)];
-  if (g === d.LONGITUDE && l === d.LATITUDE) return [c(o), c(s)];
-  if (l === d.LONGITUDE && !g) return [c(s), o];
-  if (l === d.LATITUDE && !g) return [c(o), c(s)];
-  if (g === d.LONGITUDE && !l) return [c(o), c(s)];
-  if (g === d.LATITUDE && !l) return [c(s), c(o)];
-  if (!l && !g)
-    return [
-      [c(s), c(o)],
-      [c(o), c(s)]
-    ];
+  return o === O.LONGITUDE && c === O.LATITUDE ? [g(i), g(s)] : c === O.LONGITUDE && o === O.LATITUDE ? [g(s), g(i)] : o === O.LONGITUDE && !c ? [g(i), g(s)] : o === O.LATITUDE && !c ? [g(s), g(i)] : c === O.LONGITUDE && !o ? [g(s), g(i)] : c === O.LATITUDE && !o ? [g(i), g(s)] : !o && !c ? [
+    [g(i), g(s)],
+    [g(s), g(i)]
+  ] : null;
+}
+function S(e) {
+  return a.arrayOfLengthBetween(e, 2, 3) ? e.every(a.number) : !1;
+}
+function cn(e) {
+  return u.that(e, S, "position must be a valid position"), a.arrayOfLength(e, 3);
+}
+function pe(e, t, n = {}) {
+  u.all([
+    {
+      value: e,
+      validator: S,
+      message: "position1 must be a valid position"
+    },
+    {
+      value: t,
+      validator: S,
+      message: "position2 must be a valid position"
+    },
+    {
+      value: n,
+      validator: (o) => y.schema(o, re),
+      message: "options must be a valid options object"
+    }
+  ]);
+  const { precision: r = v, consider3D: i = !1 } = n, s = i ? Math.max(e.length, t.length) : 2;
+  return Array.from(
+    { length: s },
+    (o, c) => (e[c] ?? 0).toFixed(r) === (t[c] ?? 0).toFixed(r)
+  ).every(Boolean);
+}
+function st(e, t = v) {
+  u.all([
+    {
+      value: e,
+      validator: S,
+      message: "position must be a position"
+    },
+    {
+      value: t,
+      validator: (n) => a.inRange(n, 0, R),
+      message: `precision must be in range [0, ${R}]`
+    }
+  ]);
+  for (let n = 0; n < e.length; n++)
+    e[n] = Qe(e[n], t);
+  return e;
+}
+function ot(e, t, n) {
+  return u.all([
+    {
+      value: e,
+      validator: S,
+      message: "position must be a valid position"
+    },
+    {
+      value: t,
+      validator: F,
+      message: `unknown source projection: ${t}`
+    },
+    {
+      value: n,
+      validator: F,
+      message: `unknown target projection: ${n}`
+    }
+  ]), b(t, n, e);
+}
+function lr(e, t, n) {
+  u.all([
+    { value: e, validator: S, message: "position must be a valid position" },
+    { value: t, validator: a.number, message: "bearing must be a number" },
+    { value: n, validator: a.number, message: "distance must be a number" }
+  ]);
+  const r = on(
+    U(e),
+    T.to.radians(t),
+    n / at
+  );
+  return tn(r);
+}
+function dn(e, t) {
+  return u.all([
+    { value: e, validator: S, message: "position1 must be a valid position" },
+    { value: t, validator: S, message: "position2 must be a valid position" }
+  ]), rn(U(e), U(t)) * at;
+}
+function Z(e) {
+  if (!a.arrayOfLength(e, 4) && !a.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 (!S(n) || !S(r)) return !1;
+  const [, i] = n, [, s] = r;
+  return !(i > s || !t && e[2] > e[5]);
 }
 function Ve(e) {
-  return !i.arrayOfLength(e, 4) && !i.arrayOfLength(e, 6) ? !1 : e.every(i.number);
+  return u.that(e, Z, "bbox must be a valid bounding-box"), a.arrayOfLength(e, 6);
 }
-const S = {
-  NAME: "name",
-  LINK: "link"
+function cr(e, t) {
+  return u.all([
+    { value: e, validator: Z, message: "bbox1 must be a valid bounding-box" },
+    { value: t, validator: Z, message: "bbox2 must be a valid bounding-box" }
+  ]), Ve(e) && Ve(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 fn = {
+  ignore3D: N(a.boolean)
+};
+function se(e, t = {}) {
+  u.all([
+    {
+      value: e,
+      validator: a.nonEmptyArray,
+      message: "positions must be a non-empty array"
+    },
+    {
+      value: e,
+      validator: (i) => i.every(S),
+      message: "positions must be an array of valid positions"
+    },
+    {
+      value: t,
+      validator: (i) => y.schema(i, fn),
+      message: "options must be a valid options object"
+    }
+  ]);
+  const { ignore3D: n = !1 } = t;
+  return !n && e.some(cn) ? e.reduce((i, s) => [
+    Math.min(i[0], s[0]),
+    Math.min(i[1], s[1]),
+    Math.min(i[2], s[2] ?? 0),
+    Math.max(i[3], s[0]),
+    Math.max(i[4], s[1]),
+    Math.max(i[5], s[2] ?? 0)
+  ], [1 / 0, 1 / 0, 1 / 0, -1 / 0, -1 / 0, -1 / 0]) : e.reduce((i, s) => [
+    Math.min(i[0], s[0]),
+    Math.min(i[1], s[1]),
+    Math.max(i[2], s[0]),
+    Math.max(i[3], s[1])
+  ], [1 / 0, 1 / 0, -1 / 0, -1 / 0]);
+}
+function ut(e, t = v) {
+  u.all([
+    {
+      value: e,
+      validator: Z,
+      message: "bbox must be a valid bounding box"
+    },
+    {
+      value: t,
+      validator: (n) => a.inRange(n, 0, R),
+      message: `precision must be in range [0, ${R}]`
+    }
+  ]);
+  for (let n = 0; n < e.length; n++)
+    e[n] = Qe(e[n], t);
+  return e;
+}
+const mn = {
+  ...re,
+  deduplicate: N(a.boolean)
 };
-function Ot(e) {
-  return i.plainObject(e) ? e.type === S.NAME ? i.nonEmptyString(e.properties?.name) : e.type === S.LINK ? i.nonEmptyString(e.properties?.href) : !1 : !1;
+function ve(e) {
+  return a.array(e) && e.every(S);
+}
+function lt(e, t = {}) {
+  u.that(t, (s) => y.schema(s, re), "options must be a valid options object");
+  const { precision: n = v, consider3D: r = !1 } = t, i = [];
+  for (const s of e) {
+    const o = i[i.length - 1];
+    (!o || !pe(s, o, { precision: n, consider3D: r })) && i.push(s);
+  }
+  return i;
+}
+function me(e, t = {}) {
+  u.all([
+    {
+      value: e,
+      validator: a.array,
+      message: "positions must be an array"
+    },
+    {
+      value: t,
+      validator: (o) => y.schema(o, mn),
+      message: "options must be a valid options object"
+    }
+  ]);
+  const { precision: n = v, deduplicate: r = !1, consider3D: i = !1 } = t, s = e.map((o) => st(o, n));
+  return r ? lt(s, { precision: n, consider3D: i }) : s;
+}
+function oe(e, t, n) {
+  return u.that(e, a.array, "positions must be an array"), e.map((r) => ot(r, t, n));
+}
+function dr(e) {
+  return a.arrayOfLengthAtLeast(e, 2) && ve(e);
+}
+function fr(e) {
+  u.that(e, ve, "line must be a valid array of positions");
+  let t = 0;
+  for (let n = 0; n < e.length - 1; n++)
+    t += dn(e[n], e[n + 1]);
+  return t;
+}
+function Q(e, t = {}) {
+  return !a.arrayOfLengthAtLeast(e, 4) || !ve(e) ? !1 : Le(e, t);
+}
+function Le(e, t = {}) {
+  if (u.that(t, (i) => y.schema(i, re), "options must be a valid options object"), !a.arrayOfLengthAtLeast(e, 1)) return !1;
+  const n = e[0], r = e[e.length - 1];
+  return pe(n, r, t);
 }
-const m = {
+function gn(e, t = {}) {
+  return !a.nonEmptyArray(e) || Le(e, t) ? e : [...e, [...e[0]]];
+}
+function we(e, t = {}) {
+  const n = me(e, { deduplicate: !0, ...t });
+  return gn(n, t);
+}
+function In(e) {
+  u.that(e, Q, "ring must be a valid closed ring of at least 4 positions");
+  let t = 0;
+  for (let n = 0; n < e.length - 1; n++) {
+    const [r, i] = e[n], [s, o] = e[n + 1];
+    t += T.to.radians(s - r) * (2 + Math.sin(T.to.radians(i)) + Math.sin(T.to.radians(o)));
+  }
+  return -t / 2;
+}
+function ct(e) {
+  return In(e) < 0;
+}
+function dt(e, t) {
+  u.all([
+    { value: e, validator: Q, message: "ring1 must be a valid closed ring" },
+    { value: t, validator: Q, message: "ring2 must be a valid closed ring" }
+  ]);
+  const n = e.map(U), r = t.map(U);
+  for (let i = 0; i < n.length - 1; i++)
+    for (let s = 0; s < r.length - 1; s++)
+      if (tt(n[i], n[i + 1], r[s], r[s + 1]))
+        return !0;
+  return !1;
+}
+function ft(e) {
+  u.that(e, Q, "ring must be a valid closed ring");
+  const t = e.map(U), n = [], r = t.length - 1;
+  for (let i = 0; i < r; i++)
+    for (let s = i + 1; s < r; s++)
+      s !== i + 1 && (i === 0 && s === r - 1 || tt(t[i], t[i + 1], t[s], t[s + 1]) && n.push([i, s]));
+  return n;
+}
+const J = {
+  NAME: "name",
+  LINK: "link"
+}, m = {
   POINT: "Point",
   MULTI_POINT: "MultiPoint",
   LINESTRING: "LineString",
@@ -418,514 +1108,815 @@ const m = {
   POLYGON: "Polygon",
   MULTI_POLYGON: "MultiPolygon",
   GEOMETRY_COLLECTION: "GeometryCollection"
-};
-function P(e) {
-  return !i.plainObject(e) || !i.oneOf(e.type, Object.values(m)) ? !1 : e.type === m.GEOMETRY_COLLECTION ? i.array(e.geometries) : i.array(e.coordinates);
-}
-const v = {
+}, p = {
   FEATURE: "Feature",
   FEATURE_COLLECTION: "FeatureCollection"
 };
-function je(e) {
-  return i.plainObject(e) ? v.FEATURE === e.type : !1;
+function mr(e) {
+  return a.plainObject(e) ? e.type === J.NAME ? a.nonEmptyString(e.properties?.name) : e.type === J.LINK ? a.nonEmptyString(e.properties?.href) : !1 : !1;
+}
+function gr(e) {
+  return S(e);
+}
+function Ir(e) {
+  return !a.arrayOfLength(e, 4) && !a.arrayOfLength(e, 6) ? !1 : e.every(a.number);
+}
+function En(e) {
+  return !a.plainObject(e) || !a.oneOf(e.type, Object.values(m)) ? !1 : e.type === m.GEOMETRY_COLLECTION ? a.array(e.geometries) : a.array(e.coordinates);
+}
+function On(e) {
+  return a.plainObject(e) && e.type === p.FEATURE;
+}
+function Nn(e) {
+  return a.plainObject(e) && e.type === p.FEATURE_COLLECTION && a.array(e.features);
+}
+function pn(e) {
+  return On(e) || Nn(e);
+}
+function G(e) {
+  return pn(e) || En(e);
+}
+const vn = {
+  ignore3D: N(a.boolean)
+};
+function Er(e, t = {}) {
+  if (u.all([
+    { value: e, validator: G, message: "geoJson must be a GeoJson object" },
+    { value: t, validator: (n) => y.schema(n, vn), message: "options must be a valid options object" }
+  ]), e.type === p.FEATURE)
+    return e.geometry ? se(W(e.geometry), t) : null;
+  if (e.type === p.FEATURE_COLLECTION) {
+    const n = W(e);
+    return n.length ? se(n, t) : null;
+  }
+  return se(W(e), t);
+}
+function Ln(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 = _t(ht(e.map((n) => bt({ type: "Point", coordinates: n }))));
+  return t ? t.geometry : { type: "LineString", coordinates: [e[0], e[e.length - 1]] };
+}
+function Tn(e) {
+  if (u.that(e, G, "geoJson must be a GeoJson object"), e.type === p.FEATURE)
+    return e.geometry ? Tn(e.geometry) : null;
+  const t = W(e).map((n) => [n[0], n[1]]);
+  return Ln(t);
+}
+function mt(e, t) {
+  return _.that(e, G, "geoJson must be a GeoJson object"), St.lookup(e, t);
+}
+function Or(e) {
+  return mt(e, "bbox");
+}
+function Sn(e) {
+  const t = mt(e, "crs");
+  if (!l.defined(t)) return nt;
+  const n = t.properties?.name;
+  return l.nonEmptyString(n) ? rt(n) : n;
+}
+const d = Object.freeze(
+  Object.fromEntries(
+    Object.keys(We.VALIDATION).map((e) => [e, e])
+  )
+), _n = [m.POLYGON, m.MULTI_POLYGON], hn = [
+  m.LINESTRING,
+  m.MULTI_LINESTRING,
+  m.POLYGON,
+  m.MULTI_POLYGON
+], ge = [
+  d.INVALID_WINDING_ORDER,
+  d.SELF_INTERSECTION,
+  d.HOLE_INTERSECTS_SHELL,
+  d.DUPLICATE_POSITION
+], bn = {
+  validation: l.nonEmptyObject,
+  windingOrder: h(l.boolean),
+  selfIntersection: h(l.boolean),
+  holeIntersectsShell: h(l.boolean),
+  duplicatePosition: h(l.boolean),
+  // Coordinate precision (decimal places) used to decide when two positions are
+  // the same during deduplication -- the same notion validate uses, so fix and
+  // validate stay in lockstep on duplicates.
+  precision: h(l.number)
+};
+function je(e, t) {
+  return ct(e) !== t ? (e.reverse(), !0) : !1;
+}
+function xe(e) {
+  let t = !1;
+  je(e[0], !1) && (t = !0);
+  for (let n = 1; n < e.length; n++)
+    je(e[n], !0) && (t = !0);
+  return t;
 }
-function Be(e) {
-  return !i.plainObject(e) || e.type !== v.FEATURE_COLLECTION ? !1 : i.array(e.features);
+function Rn(e) {
+  if (e.type === m.POLYGON)
+    return xe(e.coordinates);
+  let t = !1;
+  for (const n of e.coordinates)
+    xe(n) && (t = !0);
+  return t;
+}
+function Dn(e) {
+  return e.type === m.POLYGON ? e.coordinates : e.coordinates.flat(1);
 }
-function ie(e) {
-  return i.plainObject(e) ? P(e) || je(e) ? !0 : Be(e) : !1;
+function An(e) {
+  return e.type === m.POLYGON ? [e.coordinates] : e.coordinates;
 }
-function Ye(e) {
-  return i.arrayOfLengthBetween(e, 2, 3) ? e.every(i.number) : !1;
+function ke(e) {
+  return Dn(e).some((t) => ft(t).length > 0);
+}
+function Fe(e) {
+  return An(e).some((t) => {
+    const n = t[0];
+    for (let r = 1; r < t.length; r++)
+      if (dt(n, t[r])) return !0;
+    return !1;
+  });
+}
+function yn(e) {
+  const n = Rt({ type: "Feature", properties: {}, geometry: e }, 0);
+  return n ? { type: n.geometry.type, coordinates: n.geometry.coordinates } : null;
+}
+function Cn(e, t) {
+  let n = !1;
+  const r = (i) => {
+    const s = i.length, o = lt(i, { precision: t });
+    return o.length !== s && (n = !0), o;
+  };
+  switch (e.type) {
+    case m.LINESTRING:
+      e.coordinates = r(e.coordinates);
+      break;
+    case m.MULTI_LINESTRING:
+      e.coordinates = e.coordinates.map(r);
+      break;
+    case m.POLYGON:
+      e.coordinates = e.coordinates.map(r);
+      break;
+    case m.MULTI_POLYGON:
+      e.coordinates = e.coordinates.map((i) => i.map(r));
+      break;
+  }
+  return n;
+}
+function Gn(e, t) {
+  const n = t.selfIntersection, r = t.holeIntersectsShell;
+  if (!n && !r) return [];
+  const i = n && ke(e), s = r && Fe(e), o = [];
+  if (n && !i && o.push(d.SELF_INTERSECTION), r && !s && o.push(d.HOLE_INTERSECTS_SHELL), !i && !s) return o;
+  const c = yn(e);
+  return !c || i && ke(c) || s && Fe(c) || (e.type = c.type, e.coordinates = c.coordinates, i && o.push(d.SELF_INTERSECTION), s && o.push(d.HOLE_INTERSECTS_SHELL)), o;
+}
+function Mn(e, t) {
+  const n = [], r = t.precision ?? v;
+  if (t.duplicatePosition && hn.includes(e.type) && Cn(e, r) && n.push({ code: d.DUPLICATE_POSITION }), !_n.includes(e.type))
+    return { fixed: e, corrections: n };
+  t.windingOrder && Rn(e) && n.push({ code: d.INVALID_WINDING_ORDER });
+  for (const i of Gn(e, t))
+    n.push({ code: i });
+  return { fixed: e, corrections: n };
+}
+function ue(e, t) {
+  return e.filter((n) => n.path === t || n.path?.startsWith(`${t}/`));
+}
+function le(e, t, n, r) {
+  const i = {
+    windingOrder: r.windingOrder !== !1 && t.some((E) => E.code === d.INVALID_WINDING_ORDER),
+    selfIntersection: r.selfIntersection !== !1 && t.some((E) => E.code === d.SELF_INTERSECTION),
+    holeIntersectsShell: r.holeIntersectsShell !== !1 && t.some((E) => E.code === d.HOLE_INTERSECTS_SHELL),
+    duplicatePosition: r.duplicatePosition !== !1 && t.some((E) => E.code === d.DUPLICATE_POSITION),
+    precision: r.precision
+  }, s = i.windingOrder || i.selfIntersection || i.holeIntersectsShell || i.duplicatePosition ? Mn(e, i) : { corrections: [] }, o = new Set(s.corrections.map((E) => E.code)), c = s.corrections.map((E) => ({ ...E, path: n })), g = t.filter((E) => !o.has(E.code));
+  return { corrections: c, unfixed: g };
+}
+function Nr(e, t) {
+  _.all([
+    { value: e, validator: G, message: "geoJson must be a GeoJson object" },
+    { value: t, validator: (c) => V.schema(c, bn), message: "options must be a valid options object, with a mandatory validation result" }
+  ]);
+  const n = [...t.validation.errors, ...t.validation.warnings], r = n.filter((c) => ge.includes(c.code)), i = n.filter((c) => !ge.includes(c.code));
+  if (r.length === 0) return { fixed: e, corrections: [], unfixed: i };
+  if (e.type === p.FEATURE_COLLECTION) {
+    const c = [];
+    return e.features.forEach((g, E) => {
+      const f = `/features/${E}/geometry`, I = ue(r, f);
+      if (I.length === 0) return;
+      const D = le(g.geometry, I, f, t);
+      c.push(...D.corrections), i.push(...D.unfixed);
+    }), { fixed: e, corrections: c, unfixed: i };
+  }
+  if (e.type === p.FEATURE) {
+    const c = ue(r, "/geometry"), g = le(e.geometry, c, "/geometry", t);
+    return { fixed: e, corrections: g.corrections, unfixed: [...i, ...g.unfixed] };
+  }
+  const s = ue(r, ""), o = le(e, s, "", t);
+  return { fixed: e, corrections: o.corrections, unfixed: [...i, ...o.unfixed] };
+}
+function pr(e) {
+  return _.all([
+    {
+      value: e,
+      validator: l.nonEmptyObject,
+      message: "validation must be a non-empty object"
+    },
+    {
+      value: e?.errors,
+      validator: l.array,
+      message: "validation.errors must be an array"
+    }
+  ]), e.errors.length === 0 ? !1 : e.errors.every(
+    (t) => ge.includes(t.code)
+  );
+}
+function Pn(e) {
+  const t = e.match(/^EPSG:(\d+)$/i);
+  return t ? `urn:ogc:def:crs:EPSG::${t[1]}` : e;
+}
+function Te(e, t, n) {
+  switch (e.type) {
+    case m.POINT:
+      e.coordinates = ot(e.coordinates, t, n);
+      break;
+    case m.MULTI_POINT:
+    case m.LINESTRING:
+      e.coordinates = oe(e.coordinates, t, n);
+      break;
+    case m.MULTI_LINESTRING:
+    case m.POLYGON:
+      e.coordinates = e.coordinates.map(
+        (r) => oe(r, t, n)
+      );
+      break;
+    case m.MULTI_POLYGON:
+      e.coordinates = e.coordinates.map(
+        (r) => r.map(
+          (i) => oe(i, t, n)
+        )
+      );
+      break;
+    case m.GEOMETRY_COLLECTION:
+      for (const r of e.geometries)
+        Te(r, t, n);
+      break;
+  }
+  return delete e.bbox, delete e.crs, e;
 }
-function We(e, t, r) {
+function gt(e, t, n) {
+  if (e.type === p.FEATURE)
+    e.geometry && Te(e.geometry, t, n);
+  else
+    for (const r of e.features)
+      gt(r, t, n);
+  return delete e.bbox, delete e.crs, e;
+}
+function vr(e, t) {
+  u.that(e, G, "geoJson must be a GeoJson object");
+  const n = Sn(e);
+  return u.all([
+    { value: n, validator: F, message: `unknown source projection: ${n}` },
+    { value: t, validator: F, message: `unknown target projection: ${t}` }
+  ]), a.oneOf(e.type, Object.values(m)) ? Te(e, n, t) : gt(e, n, t), it(t) ? delete e.crs : e.crs = {
+    type: "name",
+    properties: { name: Pn(t) }
+  }, e;
+}
+const Un = {
+  tolerance: h(l.number),
+  getWeight: h(l.function)
+};
+function Vn(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 N(e, { tolerance: t = 0, getWeight: r = () => 1 } = {}) {
+function ce(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 : We(a.prev.coord, a.coord, a.next.coord) * r(a.coord, a.i), o = new fe((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 l = 0;
-  for (; o.size() > 0; ) {
-    const a = o.pop();
-    if (!a.removed && a.area === a._currentArea) {
-      if (a.area < l ? a.area = l : l = 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((f, I) => ({ coord: f, i: I, area: 1 / 0, removed: !1, prev: null, next: null }));
+  for (let f = 0; f < r.length; f++)
+    f > 0 && (r[f].prev = r[f - 1]), f < r.length - 1 && (r[f].next = r[f + 1]);
+  const i = (f) => !f.prev || !f.next ? 1 / 0 : Vn(f.prev.coord, f.coord, f.next.coord) * n(f.coord, f.i), s = new Dt((f, I) => f.area - I.area), o = (f) => {
+    f.area = i(f), s.push({ node: f, area: f.area });
+  };
+  for (let f = 1; f < r.length - 1; f++) o(r[f]);
+  let c = 0;
+  for (; s.size() > 0; ) {
+    const f = s.pop(), I = f.node;
+    if (!I.removed && f.area === I.area) {
+      if (I.area < c ? I.area = c : c = I.area, I.area >= t) break;
+      I.removed = !0, I.prev && (I.prev.next = I.next), I.next && (I.next.prev = I.prev), I.prev?.prev && o(I.prev), I.next?.next && o(I.next);
     }
   }
   const g = [];
-  let c = n[0];
-  for (; c; )
-    c.removed || g.push(c.coord), c = c.next;
+  let E = r[0];
+  for (; E; )
+    E.removed || g.push(E.coord), E = E.next;
   return g;
 }
-function H(e, t) {
-  switch (u.all([
-    { value: e, validator: P, message: "geometry must be a GeoJson geometry" }
-  ]), e.type) {
+function de(e, t = {}) {
+  if (_.all([
+    { value: e, validator: G, message: "geoJson must be a GeoJson object" },
+    { value: t, validator: (n) => V.schema(n, Un), message: "options must be a valid options object" }
+  ]), e.type === p.FEATURE)
+    return e.geometry && de(e.geometry, t), e;
+  if (e.type === p.FEATURE_COLLECTION) {
+    for (const n of e.features) de(n, t);
+    return e;
+  }
+  switch (e.type) {
     case m.LINESTRING:
-      e.coordinates = N(e.coordinates, t);
+      e.coordinates = ce(e.coordinates, t);
       break;
     case m.POLYGON:
     case m.MULTI_LINESTRING:
-      e.coordinates = e.coordinates.map((r) => N(r, t));
+      e.coordinates = e.coordinates.map((n) => ce(n, t));
       break;
     case m.MULTI_POLYGON:
-      e.coordinates = e.coordinates.map((r) => r.map((n) => N(n, t)));
+      e.coordinates = e.coordinates.map((n) => n.map((r) => ce(r, t)));
       break;
     case m.GEOMETRY_COLLECTION:
-      e.geometries.forEach((r) => H(r, t));
+      e.geometries.forEach((n) => de(n, t));
       break;
   }
   return e;
 }
-const Ke = Q(["common-ekosystem", "simplify", "geojson"]);
-function se(e, t) {
-  if (e.type === v.FEATURE)
-    e.geometry && H(e.geometry, t);
-  else if (e.type === v.FEATURE_COLLECTION)
-    for (const r of e.features) se(r, t);
-  else
-    Ke.warn('Unknown feature type "{type}", skipping.', { type: e.type });
-  return e;
-}
-function Tt(e, t) {
-  return u.all([
-    { value: e, validator: ie, message: "geoJson must be a GeoJson object" }
-  ]), i.oneOf(e.type, Object.values(m)) ? H(e, t) : se(e, t);
-}
-function ae(e, t = 7) {
-  u.all([
-    { value: e, validator: Ve, 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 = G[t];
-  for (let n = 0; n < e.length; n++)
-    e[n] = Math.round(e[n] * r) / r;
-  return e;
-}
-function oe(e, t = 7) {
-  u.all([
-    { value: e, validator: P, 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 = me(e, { precision: t, mutate: !0 });
-  return r.bbox && ae(r.bbox, t), r;
+function Se(e, t, n) {
+  switch (e.type) {
+    case m.POINT:
+      st(e.coordinates, t);
+      break;
+    case m.MULTI_POINT:
+    case m.LINESTRING:
+      me(e.coordinates, { precision: t });
+      break;
+    case m.MULTI_LINESTRING:
+      for (const r of e.coordinates) me(r, { precision: t });
+      break;
+    case m.POLYGON:
+      e.coordinates = e.coordinates.map((r) => we(r, { precision: t, consider3D: n }));
+      break;
+    case m.MULTI_POLYGON:
+      e.coordinates = e.coordinates.map(
+        (r) => r.map((i) => we(i, { precision: t, consider3D: n }))
+      );
+      break;
+    case m.GEOMETRY_COLLECTION:
+      for (const r of e.geometries) Se(r, t, n);
+      break;
+  }
+  return e.bbox && ut(e.bbox, t), e;
 }
-const Xe = Q(["common-ekosystem", "truncate", "geojson"]);
-function ue(e, t) {
-  if (e.type === v.FEATURE)
-    e.geometry && oe(e.geometry, t);
-  else if (e.type === v.FEATURE_COLLECTION)
-    for (const r of e.features) ue(r, t);
+function It(e, t, n) {
+  if (e.type === p.FEATURE)
+    e.geometry && Se(e.geometry, t, n);
   else
-    Xe.warn('Unknown feature type "{type}", skipping.', { type: e.type });
-  return e.bbox && ae(e.bbox, t), e;
+    for (const r of e.features) It(r, t, n);
+  return e.bbox && ut(e.bbox, t), e;
 }
-function It(e, t = 7) {
+function Lr(e, t = {}) {
+  const { precision: n = v, consider3D: r = !1 } = t;
   return u.all([
-    { value: e, validator: ie, 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(m)) ? oe(e, t) : ue(e, t);
-}
-function Lt(e, t = 7) {
-  u.all([
-    { value: e, validator: Ye, message: "position must be a position" },
-    { value: t, validator: (n) => i.inRange(n, 0, 8), message: "precision must be in range [0, 8]" }
-  ]);
-  const r = G[t];
-  for (let n = 0; n < e.length; n++)
-    e[n] = Math.round(e[n] * r) / r;
-  return e;
+    {
+      value: e,
+      validator: G,
+      message: "geoJson must be a valid GeoJson"
+    },
+    {
+      value: n,
+      validator: (i) => a.inRange(i, 0, R),
+      message: `precision must be in range [0, ${R}]`
+    }
+  ]), a.oneOf(e.type, Object.values(m)) ? Se(e, n, r) : It(e, n, r);
 }
-function R(e) {
-  if (!i.arrayOfLengthBetween(e, 2, 3))
+const $e = "/crs";
+function Et(e, t = "", n = {}) {
+  if (!l.defined(e))
+    return t === $e ? (n.geodesic = !0, { crs: nt, valid: !0 }) : { valid: !0 };
+  if (t !== $e)
     return {
       valid: !1,
-      errors: [{ message: "Invalid coordinates: must be an array of 2 or 3 coordinates" }],
+      errors: [{ code: d.UNSUPPORTED_NESTED_CRS, path: t }],
       warnings: []
     };
-  if (!i.number(e[0]) || !i.number(e[1]))
+  if (!l.plainObject(e))
     return {
       valid: !1,
-      errors: [{ message: "Invalid coordinates: longitude and latitude must be numbers" }],
+      errors: [{ code: d.INVALID_CRS_OBJECT, path: t }],
       warnings: []
     };
-  if (!i.inRange(e[0], -180, 180))
+  switch (e.type) {
+    case J.NAME: {
+      if (!l.nonEmptyString(e.properties?.name))
+        return {
+          valid: !1,
+          errors: [{ code: d.INVALID_CRS_NAME, path: t }],
+          warnings: []
+        };
+      const r = rt(e.properties.name);
+      return F(r) ? (n.geodesic = it(r), {
+        crs: r,
+        valid: !0,
+        errors: [],
+        warnings: []
+      }) : {
+        valid: !1,
+        errors: [{
+          code: d.UNSUPPORTED_CRS,
+          path: t,
+          params: { name: e.properties.name }
+        }],
+        warnings: []
+      };
+    }
+    case J.LINK:
+      return l.nonEmptyString(e.properties?.href) ? {
+        valid: !1,
+        errors: [{ code: d.UNSUPPORTED_LINK_CRS, path: t }],
+        warnings: []
+      } : {
+        valid: !1,
+        errors: [{ code: d.INVALID_CRS_LINK, path: t }],
+        warnings: []
+      };
+    default:
+      return {
+        valid: !1,
+        errors: [{
+          code: d.INVALID_CRS_TYPE,
+          path: t,
+          params: { type: e.type }
+        }],
+        warnings: []
+      };
+  }
+}
+function ee(e, t = "", n = {}) {
+  const r = n.geodesic;
+  if (!l.arrayOfLengthBetween(e, 2, 3))
     return {
       valid: !1,
-      errors: [{ message: "Invalid coordinates: longitude must be in the range -180 to 180" }],
+      errors: [{ code: d.INVALID_POSITION_LENGTH, path: t }],
       warnings: []
     };
-  if (!i.inRange(e[1], -90, 90))
+  if (!l.number(e[0]) || !l.number(e[1]))
     return {
       valid: !1,
-      errors: [{ message: "Invalid coordinates: latitude must be in the range -90 to 90" }],
+      errors: [{ code: d.INVALID_POSITION_COORDINATES, path: t }],
       warnings: []
     };
-  if (e.length === 3 && !i.number(e[2]))
+  if (r) {
+    if (!l.inRange(e[0], -180, 180))
+      return {
+        valid: !1,
+        errors: [{ code: d.INVALID_LONGITUDE_RANGE, path: t, params: { value: e[0] } }],
+        warnings: []
+      };
+    if (!l.inRange(e[1], -90, 90))
+      return {
+        valid: !1,
+        errors: [{ code: d.INVALID_LATITUDE_RANGE, path: t, params: { value: e[1] } }],
+        warnings: []
+      };
+  }
+  if (e.length === 3 && !l.number(e[2]))
     return {
       valid: !1,
-      errors: [{ message: "Invalid coordinates: altitude must be a number" }],
+      errors: [{ code: d.INVALID_ALTITUDE, path: t }],
       warnings: []
     };
-  const t = { valid: !0, errors: [], warnings: [] }, r = z(e[0]);
-  r > 6 && t.warnings.push({ message: `longitude precision is high (${r} decimals, max recommended: 6)` });
-  const n = z(e[1]);
-  return n > 6 && t.warnings.push({ message: `latitude precision is high (${n} decimals, max recommended: 6)` }), t;
+  const i = { valid: !0, errors: [], warnings: [] };
+  if (r) {
+    const s = n.precision ?? v, o = Ue(e[0]);
+    o > s && i.warnings.push({ code: d.EXCESSIVE_LONGITUDE_PRECISION, path: t, params: { precision: o, max: s } });
+    const c = Ue(e[1]);
+    c > s && i.warnings.push({ code: d.EXCESSIVE_LATITUDE_PRECISION, path: t, params: { precision: c, max: s } });
+  }
+  return i;
 }
-function ze(e) {
-  if (!i.arrayOfLength(e, 4) && !i.arrayOfLength(e, 6))
+function Ot(e, t = "", n = {}) {
+  const r = n?.geodesic;
+  if (!l.defined(e))
     return {
-      valid: !1,
-      errors: [{ message: "Invalid bbox: must be an array of 4 (2D) or 6 (3D) numbers" }],
-      warnings: []
+      valid: !0
     };
-  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 = R(r);
-  if (!s.valid)
+  if (!l.arrayOfLength(e, 4) && !l.arrayOfLength(e, 6))
     return {
       valid: !1,
-      errors: s.errors.map((f) => ({ ...f, message: `Invalid bbox south-west: ${f.message}` })),
+      errors: [{ code: d.INVALID_BBOX_LENGTH, path: t }],
       warnings: []
     };
-  const o = R(n);
-  if (!o.valid)
+  const i = e.length === 4, s = i ? [e[0], e[1]] : [e[0], e[1], e[2]], o = i ? [e[2], e[3]] : [e[3], e[4], e[5]], c = ee(s, `${t}/min`, n);
+  if (!c.valid)
+    return { valid: !1, errors: c.errors, warnings: [] };
+  const g = ee(o, `${t}/max`, n);
+  if (!g.valid)
+    return { valid: !1, errors: g.errors, warnings: [] };
+  const [E, f] = s, [I, D] = o;
+  if (f > D)
     return {
       valid: !1,
-      errors: o.errors.map((f) => ({ ...f, message: `Invalid bbox north-east: ${f.message}` })),
+      errors: [{ code: d.INVALID_BBOX_LATITUDE_ORDER, path: t, params: { south: f, north: D } }],
       warnings: []
     };
-  const [l, g] = r, [c, a] = n;
-  if (g > a)
+  if (!r && E > I)
     return {
       valid: !1,
-      errors: [{ message: `Invalid bbox: south (${g}) must be <= north (${a})` }],
+      errors: [{ code: d.INVALID_BBOX_LONGITUDE_ORDER, path: t, params: { west: E, east: I } }],
       warnings: []
     };
-  if (!t) {
-    const f = e[2], B = e[5];
-    if (f > B)
+  if (!i) {
+    const De = e[2], Ae = e[5];
+    if (De > Ae)
       return {
         valid: !1,
-        errors: [{ message: `Invalid bbox: min altitude (${f}) must be <= max altitude (${B})` }],
+        errors: [{ code: d.INVALID_BBOX_ALTITUDE_ORDER, path: t, params: { minAlt: De, maxAlt: Ae } }],
         warnings: []
       };
   }
-  const p = { valid: !0, errors: [], warnings: [] };
-  return l > c && p.warnings.push({ message: `bbox crosses the antimeridian (west: ${l} > east: ${c})` }), p.warnings.push(...s.warnings.map((f) => ({ ...f, message: `south-west: ${f.message}` }))), p.warnings.push(...o.warnings.map((f) => ({ ...f, message: `north-east: ${f.message}` }))), p;
+  const H = { valid: !0, errors: [], warnings: [] };
+  return r && E > I && H.warnings.push({ code: d.BBOX_ANTIMERIDIAN_CROSSING, path: t, params: { west: E, east: I } }), H.warnings.push(...c.warnings), H.warnings.push(...g.warnings), H;
 }
-function qe(e) {
-  if (!i.plainObject(e))
-    return {
-      valid: !1,
-      errors: [{ message: "Invalid crs: must be an object" }],
-      warnings: []
-    };
-  switch (e.type) {
-    case S.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 S.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 b() {
+function _e() {
   return { Feature: 0, FeatureCollection: 0, geometries: {} };
 }
-function Qe(...e) {
-  const t = b();
-  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 he() {
+  return {
+    crs: void 0,
+    valid: !0,
+    errors: [],
+    warnings: [],
+    statistics: _e()
+  };
+}
+function Nt(...e) {
+  const t = _e();
+  for (const n of e) {
+    const r = n.statistics;
+    if (r) {
+      t.Feature += r.Feature ?? 0, t.FeatureCollection += r.FeatureCollection ?? 0;
+      for (const [i, s] of Object.entries(r.geometries ?? {}))
+        t.geometries[i] = (t.geometries[i] ?? 0) + s;
     }
   }
   return t;
 }
-function y(e, t, r = "") {
-  const n = {
+function L(e, ...t) {
+  for (const n of t)
+    e.valid = e.valid && (n.valid ?? !0), n.errors && e.errors.push(...n.errors), n.warnings && e.warnings.push(...n.warnings), n.crs !== void 0 && (e.crs = n.crs);
+  return e.statistics = Nt(e, ...t), e;
+}
+function w(e, t, n = "") {
+  const r = {
     valid: !0,
     errors: [],
     warnings: [],
-    statistics: b()
+    statistics: _e()
   };
-  for (let s = 0; s < e.length; s++) {
-    const o = `${r}/${s}`, l = t(e[s], o, s);
-    if (l.statistics && (n.statistics = Qe(n, l)), !l.valid) {
-      n.valid = !1, n.errors = n.errors.concat(l.errors.map((g) => ({ ...g, path: g.path || o, index: s })));
-      continue;
-    }
-    i.empty(l.warnings) || (n.warnings = n.warnings.concat(l.warnings.map((g) => ({ ...g, path: g.path || o, index: s }))));
+  for (let i = 0; i < e.length; i++) {
+    const s = `${n}/${i}`, o = t(e[i], s, i);
+    o.statistics && (r.statistics = Nt(r, o)), o.valid || (r.valid = !1, r.errors = r.errors.concat(o.errors.map((c) => ({ ...c, path: c.path || s, index: i })))), l.empty(o.warnings) || (r.warnings = r.warnings.concat(o.warnings.map((c) => ({ ...c, path: c.path || s, index: i }))));
   }
-  return n;
+  return r;
 }
-function q(e, t) {
-  if (!i.defined(e.crs)) return t;
-  const r = qe(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;
+function Be(e, t = 0, n = v) {
+  for (let r = t; r < e.length - 1; r++)
+    if (pe(e[r], e[r + 1], { precision: n })) return r;
+  return -1;
 }
-function D(e, t, r = "") {
-  if (!i.defined(e.bbox)) return t;
-  const n = ze(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;
+function pt(e, t, n, r = v) {
+  let i = Be(e, 0, r);
+  for (; i !== -1; )
+    n.push({ code: d.DUPLICATE_POSITION, path: `${t}/${i}` }), i = Be(e, i + 1, r);
 }
-function V(e, t = 0, r = "") {
-  return i.arrayOfLengthAtLeast(e, t) ? y(e, R, r) : {
+function be(e, t = 0, n = "", r = {}) {
+  return l.arrayOfLengthAtLeast(e, t) ? w(e, (i, s) => ee(i, s, r), n) : {
     valid: !1,
-    errors: [{ message: `Invalid coordinates: must have at least ${t} positions`, path: r }],
+    errors: [{ code: d.INVALID_COORDINATES_LENGTH, path: n, params: { minimumLength: t } }],
     warnings: []
   };
 }
-function le(e, t = "") {
-  const r = V(e, 2, t);
+function vt(e, t = "", n = {}) {
+  const r = be(e, 2, t, n);
   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}`
-    });
-  }
+  if (pt(e, t, r.warnings, n.precision ?? v), n.geodesic ?? !0)
+    for (let i = 0; i < e.length - 1; i++) {
+      const s = e[i][0], o = e[i + 1][0];
+      Math.abs(o - s) > 180 && r.warnings.push({ code: d.ANTIMERIDIAN_CROSSING, path: `${t}/${i}` });
+    }
   return r;
 }
-function Ze(e, t = "") {
-  return i.nonEmptyArray(e) ? y(e, le, t) : {
+function wn(e, t = "", n = {}) {
+  return l.nonEmptyArray(e) ? w(e, (r, i) => vt(r, i, n), t) : {
     valid: !1,
-    errors: [{ message: "Invalid MultiLineString: coordinates must be a non empty array", path: t }],
+    errors: [{ code: d.INVALID_MULTI_LINESTRING_COORDINATES, path: t }],
     warnings: []
   };
 }
-function Je(e, t, r = "") {
-  const n = V(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 = de(e) ? "clockwise" : "counter-clockwise";
-  g !== t && n.warnings.push({ message: `Ring must be ${t} but is ${g}`, path: r });
-  const c = pe({ 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 ce(e, t = "") {
-  return i.nonEmptyArray(e) ? y(e, (r, n, s) => Je(r, s === 0 ? "counter-clockwise" : "clockwise", n), t) : {
-    valid: !1,
-    errors: [{ message: "Invalid Polygon: coordinates must be a non empty array", path: t }],
-    warnings: []
-  };
+function jn(e, t, n = "", r = {}) {
+  const i = r.precision ?? v, s = r.geodesic ?? !0, o = be(e, 4, n, r);
+  if (!o.valid) return o;
+  if (!Le(e, { precision: i }))
+    return o.valid = !1, o.errors.push({ code: d.RING_NOT_CLOSED, path: n }), o;
+  if (pt(e, n, o.warnings, i), s) {
+    const c = ct(e) ? "clockwise" : "counter-clockwise";
+    c !== t && (o.valid = !1, o.errors.push({
+      code: d.INVALID_WINDING_ORDER,
+      path: n,
+      params: { expected: t, actual: c }
+    }));
+    const g = ft(e);
+    g.length > 0 && (o.valid = !1, o.errors.push({
+      code: d.SELF_INTERSECTION,
+      path: n,
+      params: { count: g.length }
+    }));
+  }
+  return o;
 }
-function et(e, t = "") {
-  return i.nonEmptyArray(e) ? y(e, (r, n) => ce(r, n), t) : {
+function Lt(e, t = "", n = {}) {
+  if (!l.nonEmptyArray(e))
+    return {
+      valid: !1,
+      errors: [{ code: d.INVALID_POLYGON_COORDINATES, path: t }],
+      warnings: []
+    };
+  const r = w(e, (i, s, o) => jn(i, o === 0 ? "counter-clockwise" : "clockwise", s, n), t);
+  if ((n.geodesic ?? !0) && r.valid && e.length > 1) {
+    const i = e[0];
+    for (let s = 1; s < e.length; s++)
+      dt(i, e[s]) && (r.valid = !1, r.errors.push({ code: d.HOLE_INTERSECTS_SHELL, path: `${t}/${s}` }));
+  }
+  return r;
+}
+function xn(e, t = "", n = {}) {
+  return l.nonEmptyArray(e) ? w(e, (r, i) => Lt(r, i, n), t) : {
     valid: !1,
-    errors: [{ message: "Invalid MultiPolygon: coordinates must be a non empty array", path: t }],
+    errors: [{ code: d.INVALID_MULTIPOLYGON_COORDINATES, path: t }],
     warnings: []
   };
 }
-function tt(e, t = "") {
-  return i.nonEmptyArray(e) ? y(e, (r, n) => j(r, n), t) : {
+function kn(e, t = "", n = {}) {
+  return l.nonEmptyArray(e) ? w(e, (r, i) => Re(r, i, n), t) : {
     valid: !1,
-    errors: [{ message: "Invalid geometries: geometries must be a non empty array", path: t }],
+    errors: [{ code: d.INVALID_GEOMETRYCOLLECTION_GEOMETRIES, path: t }],
     warnings: []
   };
 }
-function j(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;
+function Re(e, t = "", n = {}) {
+  let r = he();
+  if (!l.nonEmptyObject(e))
+    return r.valid = !1, r.errors.push({ code: d.INVALID_GEOMETRY, path: t }), r;
+  r = L(r, Et(e.crs, `${t}/crs`, n)), r = L(r, Ot(e.bbox, `${t}/bbox`, n));
+  const i = `${t}/coordinates`;
   switch (e.type) {
-    case m.POINT: {
-      const s = R(e.coordinates);
-      n = {
-        valid: s.valid,
-        errors: s.errors.map((o) => ({ ...o, path: r })),
-        warnings: s.warnings.map((o) => ({ ...o, path: r }))
-      };
+    case m.POINT:
+      r = L(r, ee(e.coordinates, i, n));
       break;
-    }
-    case m.MULTI_POINT: {
-      n = V(e.coordinates, 0, r);
+    case m.MULTI_POINT:
+      r = L(r, be(e.coordinates, 0, i, n));
       break;
-    }
-    case m.LINESTRING: {
-      n = le(e.coordinates, r);
+    case m.LINESTRING:
+      r = L(r, vt(e.coordinates, i, n));
       break;
-    }
-    case m.MULTI_LINESTRING: {
-      n = Ze(e.coordinates, r);
+    case m.MULTI_LINESTRING:
+      r = L(r, wn(e.coordinates, i, n));
       break;
-    }
-    case m.POLYGON: {
-      n = ce(e.coordinates, r);
+    case m.POLYGON:
+      r = L(r, Lt(e.coordinates, i, n));
       break;
-    }
-    case m.MULTI_POLYGON: {
-      n = et(e.coordinates, r);
+    case m.MULTI_POLYGON:
+      r = L(r, xn(e.coordinates, i, n));
       break;
-    }
-    case m.GEOMETRY_COLLECTION: {
-      n = tt(e.geometries, `${t}/geometries`);
+    case m.GEOMETRY_COLLECTION:
+      r = L(r, kn(e.geometries, `${t}/geometries`, n));
       break;
-    }
     default:
-      return {
-        valid: !1,
-        errors: [{ message: `Invalid geometry type: ${e.type}`, path: t }],
-        warnings: []
-      };
-  }
-  return n = D(e, n, t), n.statistics = { geometries: { [e.type]: 1 } }, n;
-}
-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: b()
-    };
-  if (e.type === v.FEATURE) {
-    if (i.nonEmptyObject(e.geometry)) {
-      const r = j(e.geometry, `${t}/geometry`);
-      return {
-        ...D(e, r, t),
-        statistics: {
-          Feature: 1,
-          FeatureCollection: 0,
-          // Geometry counting is owned by validateGeometry.
-          geometries: { ...r.statistics.geometries }
-        }
-      };
-    }
-    return {
-      valid: !0,
-      errors: [],
-      warnings: [{ message: "Feature has no geometry", path: t }],
-      statistics: { Feature: 1, FeatureCollection: 0, geometries: {} }
-    };
+      return r.valid = !1, r.errors.push({ code: d.INVALID_GEOMETRY_TYPE, path: t, params: { type: e.type } }), r;
   }
-  if (e.type === v.FEATURE_COLLECTION) {
-    if (i.nonEmptyArray(e.features)) {
-      const r = y(e.features, ge, `${t}/features`);
-      return {
-        ...D(e, r, t),
-        statistics: { ...r.statistics, FeatureCollection: r.statistics.FeatureCollection + 1 }
-      };
-    }
-    return {
-      valid: !1,
-      errors: [{ message: "Invalid FeatureCollection: features must be a non empty array", path: t }],
-      warnings: [],
-      statistics: b()
-    };
-  }
-  return {
+  return r.statistics = { Feature: 0, FeatureCollection: 0, geometries: { [e.type]: 1 } }, r;
+}
+function Tt(e, t, n) {
+  let r = he();
+  return l.nonEmptyObject(e) ? (r = L(r, Et(e.crs, `${t}/crs`, n)), r = L(r, Ot(e.bbox, `${t}/bbox`, n)), e.type === p.FEATURE ? (r.statistics.Feature++, l.nonEmptyObject(e.geometry) ? r = L(r, Re(e.geometry, `${t}/geometry`, n)) : r.warnings.push({
+    code: d.MISSING_GEOMETRY,
+    path: t
+  }), r) : (r.statistics.FeatureCollection++, l.nonEmptyArray(e.features) ? r = L(r, w(e.features, (i, s) => Tt(i, s, n), `${t}/features`)) : l.array(e.features) || (r.valid = !1, r.errors.push({
+    code: d.INVALID_FEATURES_ARRAY,
+    path: t
+  })), r)) : (r.valid = !1, r.errors.push({
+    code: d.EMPTY_OBJECT,
+    path: t
+  }), r);
+}
+function Tr(e, t = {}) {
+  _.that(e, l.nonEmptyObject, "geojson must be a non empty object");
+  const { precision: n = v } = t;
+  return e.type === p.FEATURE || e.type === p.FEATURE_COLLECTION ? Tt(e, "", { precision: n }) : l.oneOf(e.type, Object.values(m)) ? Re(e, "", { precision: n }) : {
+    ...he(),
     valid: !1,
-    errors: [{ message: `Invalid feature: unknown type: ${e.type}`, path: t }],
-    warnings: [],
-    statistics: b()
-  };
-}
-function St(e) {
-  if (u.that(e, i.nonEmptyObject, "geojson must be a non empty object"), i.oneOf(e.type, Object.values(m))) {
-    const t = j(e, ""), r = D(e, t, "");
-    return {
-      ...q(e, r),
-      // 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 = ge(e, "");
-    return q(e, t);
-  }
-  return {
-    valid: !1,
-    errors: [{ message: "Invalid GeoJson: type must be either a Geometry, a Feature or a FeatureCollection", path: "" }],
-    warnings: [],
-    statistics: b()
+    errors: [{
+      code: d.UNKNOWN_TYPE,
+      path: "",
+      params: { type: e.type }
+    }]
   };
 }
 export {
-  d as AXES,
-  x as COORDINATE_FORMATS,
-  Pe as COORDINATE_MODELS,
-  G as COORDINATE_TRUNCATION_FACTORS,
-  S as CRS_TYPES,
-  v as FEATURE_TYPES,
+  O as AXES,
+  fe as COORDINATE_FORMATS,
+  Zt as COORDINATE_MODELS,
+  Qt as COORDINATE_TRUNCATION_FACTORS,
+  J as CRS_TYPES,
+  v as DEFAULT_COORDINATE_PRECISION,
+  at as EARTH_RADIUS,
+  p as FEATURE_TYPES,
   m as GEOMETRY_TYPES,
-  ht as convertCoordinate,
-  J as getActiveLocales,
-  F as getAllDirectionSymbols,
-  z as getCoordinatePrecision,
-  Re as getDirectionAxis,
-  ft as getDirections,
-  pt as getEast,
-  Ie as getLatitudeSymbols,
-  Te as getLocale,
-  U as getLocaleByCode,
-  Le as getLongitudeSymbols,
-  mt as getNorth,
-  dt as getSouth,
-  vt as getWest,
-  X as guessCoordinateAxis,
-  ut as isAltitude,
-  ve as isAxis,
-  E as isDirection,
-  k as isEast,
-  M as isLatitude,
-  Ve as isLikeBBox,
-  Ot as isLikeCRS,
-  je as isLikeFeature,
-  Be as isLikeFeatureCollection,
-  ie as isLikeGeoJson,
-  P as isLikeGeometry,
-  Ye as isLikePosition,
-  Z as isLongitude,
-  Se as isNorth,
-  ee as isSouth,
-  C as isWest,
-  lt as listLocales,
-  bt as normalizeCoordinate,
-  He as parseCoordinate,
-  yt as parsePosition,
-  ct as registerLocale,
-  gt as setLocale,
-  Tt as simplifyGeoJson,
-  H as simplifyGeometry,
-  ae as truncateBBox,
-  Et as truncateCoordinate,
-  It as truncateGeoJson,
-  oe as truncateGeometry,
-  Lt as truncatePosition,
-  ze as validateBBox,
-  qe as validateCRS,
-  St as validateGeoJson,
-  j as validateGeometry,
-  R as validatePosition
+  re as IS_SAME_POSITION_OPTIONS_SCHEMA,
+  R as MAX_COORDINATE_PRECISION,
+  mn as TRUNCATE_POSITIONS_OPTIONS_SCHEMA,
+  d as VALIDATION_CODES,
+  nt as WGS84,
+  gn as closeRing,
+  se as computeBBox,
+  Er as computeGeoJsonBoundingBox,
+  Tn as computeGeoJsonConvexHull,
+  ir as convertCoordinate,
+  lt as deduplicatePositions,
+  sr as defineProjection,
+  lr as destinationFromPosition,
+  dn as distanceBetweenPositions,
+  Or as extractGeoJsonBBox,
+  Sn as extractGeoJsonCRS,
+  mt as extractGeoJsonNode,
+  Nr as fixGeoJson,
+  Xe as getActiveLocales,
+  Ue as getCoordinatePrecision,
+  wt as getDirectionAxis,
+  B as getDirectionSymbols,
+  Qn as getDirections,
+  tr as getEast,
+  Ut as getLocale,
+  Oe as getMessages,
+  Jn as getNorth,
+  or as getProjection,
+  er as getSouth,
+  nr as getWest,
+  Pe as guessCoordinateAxis,
+  F as hasProjection,
+  Ve as is3DBBox,
+  cn as is3DPosition,
+  zn as isAltitude,
+  ct as isClockwiseRing,
+  Le as isClosedRing,
+  Ne as isEast,
+  pr as isGeoJsonFixable,
+  X as isLatitude,
+  Ir as isLikeBBox,
+  mr as isLikeCRS,
+  On as isLikeFeature,
+  Nn as isLikeFeatureCollection,
+  pn as isLikeFeatureOrFeatureCollection,
+  G as isLikeGeoJson,
+  En as isLikeGeometry,
+  gr as isLikePosition,
+  Ee as isLongitude,
+  Vt as isNorth,
+  pe as isSamePosition,
+  ze as isSouth,
+  He as isValidAxis,
+  Z as isValidBBox,
+  C as isValidDirection,
+  dr as isValidLine,
+  S as isValidPosition,
+  ve as isValidPositions,
+  Q as isValidRing,
+  it as isWGS84Projection,
+  ne as isWest,
+  fr as lineLength,
+  Kn as listLocales,
+  ar as listProjections,
+  cr as mergeBBox,
+  rr as normalizeCoordinate,
+  rt as normalizeCrsName,
+  Jt as parseCoordinate,
+  ur as parsePosition,
+  Zn as registerMessages,
+  vr as reprojectGeoJson,
+  ot as reprojectPosition,
+  oe as reprojectPositions,
+  ft as ringSelfIntersections,
+  dt as ringsIntersect,
+  qn as setLocale,
+  de as simplifyGeoJson,
+  In as sphericalRingArea,
+  ut as truncateBBox,
+  Qe as truncateCoordinate,
+  Lr as truncateGeoJson,
+  st as truncatePosition,
+  me as truncatePositions,
+  we as truncateRing,
+  Tr as validateGeoJson
 };
 //# sourceMappingURL=index.mjs.map