@kalisio/common-geospatial 0.0.0

package/dist/index.mjs

@@ -0,0 +1,828 @@
+import { assert as l, is as i, has as M, conform as T, optional as C } from "@kalisio/common-core";
+const d = {
+  LATITUDE: "LAT",
+  LONGITUDE: "LON",
+  ALTITUDE: "ALT"
+};
+function Z(e) {
+  return l.that(e, i.string, "axis must be a string"), Object.values(d).includes(e);
+}
+function R(e) {
+  return l.that(e, i.string, "axis must be a string"), e === d.LATITUDE;
+}
+function W(e) {
+  return l.that(e, i.string, "axis must be a string"), e === d.LONGITUDE;
+}
+function We(e) {
+  return l.that(e, i.string, "axis must be a string"), e === d.ALTITUDE;
+}
+const J = { NORTH: { label: "Nord", symbol: "N" }, SOUTH: { label: "Sud", symbol: "S" }, EAST: { label: "Est", symbol: "E" }, WEST: { label: "Ouest", symbol: "O" } }, ee = {
+  DIRECTIONS: J
+}, te = { NORTH: { label: "North", symbol: "N" }, SOUTH: { label: "South", symbol: "S" }, EAST: { label: "East", symbol: "E" }, WEST: { label: "West", symbol: "W" } }, ne = {
+  DIRECTIONS: te
+}, re = {
+  DIRECTIONS: {
+    NORTH: { label: i.string, symbol: i.string },
+    SOUTH: { label: i.string, symbol: i.string },
+    EAST: { label: i.string, symbol: i.string },
+    WEST: { label: i.string, symbol: i.string }
+  }
+}, O = {
+  en: ne,
+  fr: ee
+};
+let w = "en";
+function Be() {
+  return Object.keys(O);
+}
+function je(e, t) {
+  l.all([
+    { value: e, validator: i.string, message: "code must be a string" },
+    { value: e, validator: (n) => !M.key(O, n), message: "locale already registered" },
+    { value: t, validator: i.plainObject, message: "content must be an object" },
+    { value: t, validator: (n) => T.schema(n, re), message: "content does not conform to schema" }
+  ]), O[e] = t;
+}
+function Ke(e) {
+  l.all([
+    { value: e, validator: i.string, message: "code must be a string" },
+    { value: e, validator: (t) => M.key(O, t), message: "code is unknown" }
+  ]), w = e;
+}
+function ie() {
+  return {
+    code: w,
+    content: O[w]
+  };
+}
+function y() {
+  return ie().content.DIRECTIONS;
+}
+function S(e, t) {
+  const n = y(), r = n[e].label.toUpperCase(), s = n[e].symbol.toUpperCase();
+  return t.toUpperCase() === r || t.toUpperCase() === s;
+}
+function Ye(e = null) {
+  const t = y();
+  return i.defined(e) ? (l.that(e, Z, "axis must be a valid axis"), R(e) ? [t.SOUTH, t.NORTH] : W(e) ? [t.EAST, t.WEST] : []) : [t.SOUTH, t.NORTH, t.EAST, t.WEST];
+}
+function qe() {
+  return y().NORTH;
+}
+function ze() {
+  return y().SOUTH;
+}
+function Qe() {
+  return y().EAST;
+}
+function Xe() {
+  return y().WEST;
+}
+function v(e) {
+  return l.that(e, i.string, "dir must be a string"), se(e) || B(e) || j(e) || $(e);
+}
+function se(e) {
+  return l.that(e, i.string, "dir must be a string"), S("NORTH", e);
+}
+function B(e) {
+  return l.that(e, i.string, "dir must be a string"), S("SOUTH", e);
+}
+function j(e) {
+  return l.that(e, i.string, "dir must be a string"), S("EAST", e);
+}
+function $(e) {
+  return l.that(e, i.string, "dir must be a string"), S("WEST", e);
+}
+function ae(e) {
+  return l.that(e, v, "dir must be a direction"), $(e) || j(e) ? d.LONGITUDE : d.LATITUDE;
+}
+const oe = {
+  degrees: i.number,
+  direction: C(v)
+}, ue = /^(-?\d{1,3}(?:\.\d+)?)°?$/, le = /^(\d{1,3}(?:\.\d+)?)°?([NSEW])$/;
+function L(e) {
+  let t = null, n = null;
+  if (i.plainObject(e) && T.schema(e, oe))
+    i.defined(e.direction) ? e.degrees >= 0 && (t = e.degrees, n = e.direction) : t = e.degrees;
+  else if (i.string(e)) {
+    const r = e.replace(/\s+/g, ""), s = r.match(ue) ?? r.match(le);
+    s && (t = parseFloat(s[1]), n = s[2] ?? null);
+  }
+  return {
+    get degrees() {
+      return t;
+    },
+    get direction() {
+      return n;
+    },
+    get format() {
+      return "DD";
+    },
+    isValid() {
+      return i.number(t);
+    },
+    toString(r) {
+      if (l.that(r, i.positiveInteger, "decimalPlaces must be a positive integer"), !this.isValid()) return "";
+      let s = `${t.toFixed(r)}°`;
+      return n && (s += ` ${n}`), s;
+    },
+    toDecimal() {
+      return this.isValid() ? L({ degrees: t, direction: n }) : null;
+    }
+  };
+}
+const ce = {
+  degrees: i.integer,
+  minutes: (e) => i.inRangeExclusiveMax(e, 0, 60),
+  direction: C(v)
+}, ge = /^(-?\d{1,3})°(\d{1,2}(?:\.\d+)?)'?$/, fe = /^(\d{1,3})°(\d{1,2}(?:\.\d+)?)'?([NSEW])$/;
+function K(e) {
+  let t = null, n = null, r = null;
+  if (i.plainObject(e) && T.schema(e, ce))
+    i.defined(e.direction) ? e.degrees >= 0 && (t = e.degrees, n = e.minutes, r = e.direction) : (t = e.degrees, n = e.minutes);
+  else if (i.string(e)) {
+    const s = e.replace(/\s+/g, ""), a = s.match(ge) ?? s.match(fe);
+    a && (t = parseFloat(a[1]), n = parseFloat(a[2]), r = a[3] ?? null);
+  }
+  return {
+    get degrees() {
+      return t;
+    },
+    get minutes() {
+      return n;
+    },
+    get direction() {
+      return r;
+    },
+    get format() {
+      return "DDM";
+    },
+    isValid() {
+      return i.integer(t) && i.inRangeExclusiveMax(n, 0, 60);
+    },
+    toString(s) {
+      if (l.that(s, i.positiveInteger, "decimalPlaces must be a positive integer"), !this.isValid()) return "";
+      let a = `${t}° ${n.toFixed(s)}'`;
+      return r && (a += ` ${r}`), a;
+    },
+    toDecimal() {
+      return this.isValid() ? L({ degrees: t + n / 60, direction: r }) : null;
+    }
+  };
+}
+const me = {
+  degrees: i.nonNegativeInteger,
+  minutes: (e) => i.inRangeExclusiveMax(e, 0, 60),
+  direction: v
+}, de = /^(\d{2})(\d{3})([NS])$/, Ee = /^(\d{3})(\d{3})([EW])$/;
+function Y(e) {
+  let t = null, n = null, r = null;
+  if (i.plainObject(e) && T.schema(e, me))
+    t = e.degrees, n = e.minutes, r = e.direction;
+  else if (i.string(e)) {
+    const s = e.trim(), a = s.match(de) ?? s.match(Ee);
+    a && (t = parseFloat(a[1]), n = parseFloat(a[2]) / 10, r = a[3]);
+  }
+  return {
+    get degrees() {
+      return t;
+    },
+    get minutes() {
+      return n;
+    },
+    get direction() {
+      return r;
+    },
+    get format() {
+      return "DDM_AERO";
+    },
+    isValid() {
+      return i.nonNegativeInteger(t) && i.inRangeExclusiveMax(n, 0, 60) && v(r);
+    },
+    toString() {
+      if (!this.isValid()) return "";
+      const s = r === "E" || r === "W", a = String(t).padStart(s ? 3 : 2, "0"), o = Math.floor(n * 10).toString().padStart(3, "0");
+      return `${a}${o}${r}`;
+    },
+    toDecimal() {
+      return this.isValid() ? L({ degrees: t + n / 60, direction: r }) : null;
+    }
+  };
+}
+const pe = {
+  degrees: i.integer,
+  minutes: (e) => i.integer(e) && i.inRange(e, 0, 59),
+  seconds: (e) => i.inRangeExclusiveMax(e, 0, 60),
+  direction: C(v)
+}, ve = /^(-?\d{1,3})°(\d{1,2})'(\d{1,2}(?:\.\d+)?)"?$/, he = /^(\d{1,3})°(\d{1,2})'(\d{1,2}(?:\.\d+)?)"?([NSEW])$/;
+function q(e) {
+  let t = null, n = null, r = null, s = null;
+  if (i.plainObject(e) && T.schema(e, pe))
+    i.defined(e.direction) ? e.degrees >= 0 && (t = e.degrees, n = e.minutes, r = e.seconds, s = e.direction) : (t = e.degrees, n = e.minutes, r = e.seconds);
+  else if (i.string(e)) {
+    const a = e.replace(/\s+/g, ""), o = a.match(ve) ?? a.match(he);
+    o && (t = parseFloat(o[1]), n = parseFloat(o[2]), r = parseFloat(o[3]), s = o[4] ?? null);
+  }
+  return {
+    get degrees() {
+      return t;
+    },
+    get minutes() {
+      return n;
+    },
+    get seconds() {
+      return r;
+    },
+    get direction() {
+      return s;
+    },
+    get format() {
+      return "DMS";
+    },
+    isValid() {
+      return i.integer(t) && i.integer(n) && i.inRange(n, 0, 59) && i.inRangeExclusiveMax(r, 0, 60);
+    },
+    toString(a) {
+      if (l.that(a, i.positiveInteger, "decimalPlaces must be a positive integer"), !this.isValid()) return "";
+      let o = `${t}° ${n}' ${r.toFixed(a)}"`;
+      return s && (o += ` ${s}`), o;
+    },
+    toDecimal() {
+      return this.isValid() ? L({ degrees: t + n / 60 + r / 3600, direction: s }) : null;
+    }
+  };
+}
+function F(e) {
+  const t = Math.floor(e.degrees), n = (e.degrees - t) * 60;
+  return { degrees: t, minutes: n, direction: e.direction };
+}
+function ye(e) {
+  const t = Math.floor(e.degrees), n = (e.degrees - t) * 60, r = Math.floor(n), s = (n - r) * 60;
+  return { degrees: t, minutes: r, seconds: s, direction: e.direction };
+}
+const k = {
+  DD: (e) => (l.that(e, (t) => t.isValid(), "dd must be a valid coordinate"), e),
+  DDM: (e) => {
+    l.that(e, (s) => s.isValid(), "dd must be a valid coordinate");
+    const { degrees: t, minutes: n, direction: r } = F(e);
+    return K(r ? { degrees: t, minutes: n, direction: r } : { degrees: t, minutes: n });
+  },
+  DMS: (e) => {
+    l.that(e, (a) => a.isValid(), "dd must be a valid coordinate");
+    const { degrees: t, minutes: n, seconds: r, direction: s } = ye(e);
+    return q(s ? { degrees: t, minutes: n, seconds: r, direction: s } : { degrees: t, minutes: n, seconds: r });
+  },
+  DDM_AERO: (e) => {
+    l.that(e, (s) => s.isValid(), "dd must be a valid coordinate");
+    const { degrees: t, minutes: n, direction: r } = F(e);
+    return Y({ degrees: t, minutes: n, direction: r });
+  }
+}, N = {
+  DD: "DD",
+  DDM: "DDM",
+  DDM_AERO: "DDM_AERO",
+  DMS: "DMS"
+}, be = {
+  DD: L,
+  DDM: K,
+  DDM_AERO: Y,
+  DMS: q
+}, _ = Array.from({ length: 9 }, (e, t) => 10 ** t);
+function P(e, t) {
+  if (l.that(e, i.number, "coord must be a number"), i.defined(t))
+    return l.that(t, v, "dir must be a direction"), ae(t);
+  if (Math.abs(e) > 90) return d.LONGITUDE;
+}
+function H(e) {
+  l.that(e, i.number, "coord must be a number");
+  const t = e.toExponential(), [n, r] = t.split("e").map(Number), s = (n.toString().split(".")[1] || "").length;
+  return Math.max(0, s - r);
+}
+function Ze(e, t = 7) {
+  l.all([
+    { value: e, validator: i.number, message: "coord must be a number" },
+    { value: t, validator: (r) => i.inRange(r, 0, 8), message: "precision must be in range [0, 8]" }
+  ]);
+  const n = _[t];
+  return Math.round(e * n) / n;
+}
+function Je(e, t) {
+  if (l.all([
+    { value: e, validator: i.number, message: "coord must be a number" },
+    { value: t, validator: (r) => W(r) || R(r), message: "axis must be either a longitude or latitude" }
+  ]), R(t))
+    return Math.max(-90, Math.min(90, e));
+  let n = ((e + 180) % 360 + 360) % 360 - 180;
+  return n === -180 && (n = 180), Object.is(n, -0) && (n = 0), n;
+}
+function et(e, t) {
+  l.all([
+    { value: e, validator: (r) => i.defined(r) && r.isValid(), message: "from must be a valid coordinate" },
+    { value: t, validator: (r) => M.key(k, r), message: `unknown format: ${t}` }
+  ]);
+  const n = e.format === N.DD ? e : e.toDecimal();
+  return n.isValid() ? t === N.DD ? n : k[t](n) : null;
+}
+function Oe(e) {
+  l.that(e, i.nonEmptyString, "pattern must be a non empty string");
+  for (const t of Object.keys(N)) {
+    const n = be[t](e);
+    if (n.isValid()) return n;
+  }
+  return null;
+}
+function tt(e) {
+  l.that(e, (f) => i.nonEmptyString(f), "pattern must be a non-empty string");
+  const t = e.split(/[,;|]/);
+  if (t.length !== 2) return null;
+  const [n, r] = t.map(Oe);
+  if (!n || !r) return null;
+  const s = n.toDecimal(), a = r.toDecimal(), o = P(s.degrees, s.direction), u = P(a.degrees, a.direction), c = (f) => {
+    const { degrees: m, direction: g } = f;
+    return g && ($(g) || B(g)) ? -m : m;
+  };
+  if (o === d.LONGITUDE && u === d.LATITUDE) return [c(s), c(a)];
+  if (u === d.LONGITUDE && o === d.LATITUDE) return [c(a), c(s)];
+  if (o === d.LONGITUDE && !u) return [c(s), a];
+  if (o === d.LATITUDE && !u) return [c(a), c(s)];
+  if (u === d.LONGITUDE && !o) return [c(a), c(s)];
+  if (u === d.LATITUDE && !o) return [c(s), c(a)];
+  if (!o && !u)
+    return [
+      [c(s), c(a)],
+      [c(a), c(s)]
+    ];
+}
+function Te(e) {
+  return !i.arrayOfLength(e, 4) && !i.arrayOfLength(e, 6) ? !1 : e.every(i.number);
+}
+const D = {
+  NAME: "name",
+  LINK: "link"
+};
+function nt(e) {
+  return i.plainObject(e) ? e.type === D.NAME ? i.nonEmptyString(e.properties?.name) : e.type === D.LINK ? i.nonEmptyString(e.properties?.href) : !1 : !1;
+}
+const p = {
+  POINT: "Point",
+  MULTI_POINT: "MultiPoint",
+  LINESTRING: "LineString",
+  MULTI_LINESTRING: "MultiLineString",
+  POLYGON: "Polygon",
+  MULTI_POLYGON: "MultiPolygon",
+  GEOMETRY_COLLECTION: "GeometryCollection"
+};
+function Le(e) {
+  return !i.plainObject(e) || !i.oneOf(e.type, Object.values(p)) ? !1 : e.type === p.GEOMETRY_COLLECTION ? i.array(e.geometries) : i.array(e.coordinates);
+}
+const h = {
+  FEATURE: "Feature",
+  FEATURE_COLLECTION: "FeatureCollection"
+};
+function De(e) {
+  return i.plainObject(e) ? h.FEATURE === e.type : !1;
+}
+function Ie(e) {
+  return !i.plainObject(e) || e.type !== h.FEATURE_COLLECTION ? !1 : i.array(e.features);
+}
+function rt(e) {
+  return i.plainObject(e) ? Le(e) || De(e) ? !0 : Ie(e) : !1;
+}
+function Se(e) {
+  return i.arrayOfLengthBetween(e, 2, 3) ? e.every(i.number) : !1;
+}
+function it(e, t = 7) {
+  l.all([
+    { value: e, validator: Te, message: "bbox must be bounding box" },
+    { value: t, validator: (r) => i.inRange(r, 0, 8), message: "precision must be in range [0, 8]" }
+  ]);
+  const n = _[t];
+  for (let r = 0; r < e.length; r++)
+    e[r] = Math.round(e[r] * n) / n;
+  return e;
+}
+function st(e, t = 7) {
+  l.all([
+    { value: e, validator: Se, message: "position must be a position" },
+    { value: t, validator: (r) => i.inRange(r, 0, 8), message: "precision must be in range [0, 8]" }
+  ]);
+  const n = _[t];
+  for (let r = 0; r < e.length; r++)
+    e[r] = Math.round(e[r] * n) / n;
+  return e;
+}
+function I(e) {
+  if (!i.arrayOfLengthBetween(e, 2, 3))
+    return {
+      valid: !1,
+      errors: [{ message: "Invalid coordinates: must be an array of 2 or 3 coordinates" }],
+      warnings: []
+    };
+  if (!i.inRange(e[0], -180, 180))
+    return {
+      valid: !1,
+      errors: [{ message: "Invalid coordinates: longitude must be in the range -180 to 180" }],
+      warnings: []
+    };
+  if (!i.inRange(e[1], -90, 90))
+    return {
+      valid: !1,
+      errors: [{ message: "Invalid coordinates: latitude must be in the range -90 to 90" }],
+      warnings: []
+    };
+  if (e.length === 3 && !i.number(e[2]))
+    return {
+      valid: !1,
+      errors: [{ message: "Invalid coordinates: altitude must be a number" }],
+      warnings: []
+    };
+  const t = { valid: !0, errors: [], warnings: [] }, n = H(e[0]);
+  n > 6 && t.warnings.push({ message: `longitude precision is high (${n} decimals, max recommended: 6)` });
+  const r = H(e[1]);
+  return r > 6 && t.warnings.push({ message: `latitude precision is high (${r} decimals, max recommended: 6)` }), t;
+}
+function Re(e) {
+  if (!i.arrayOfLength(e, 4) && !i.arrayOfLength(e, 6))
+    return {
+      valid: !1,
+      errors: [{ message: "Invalid bbox: must be an array of 4 (2D) or 6 (3D) numbers" }],
+      warnings: []
+    };
+  const t = e.length === 4, n = t ? [e[0], e[1]] : [e[0], e[1], e[2]], r = t ? [e[2], e[3]] : [e[3], e[4], e[5]], s = I(n);
+  if (!s.valid)
+    return {
+      valid: !1,
+      errors: s.errors.map((g) => ({ ...g, message: `Invalid bbox south-west: ${g.message}` })),
+      warnings: []
+    };
+  const a = I(r);
+  if (!a.valid)
+    return {
+      valid: !1,
+      errors: a.errors.map((g) => ({ ...g, message: `Invalid bbox north-east: ${g.message}` })),
+      warnings: []
+    };
+  const [o, u] = n, [c, f] = r;
+  if (u > f)
+    return {
+      valid: !1,
+      errors: [{ message: `Invalid bbox: south (${u}) must be <= north (${f})` }],
+      warnings: []
+    };
+  const m = { valid: !0, errors: [], warnings: [] };
+  return o > c && m.warnings.push({ message: `bbox crosses the antimeridian (west: ${o} > east: ${c})` }), m.warnings.push(...s.warnings.map((g) => ({ ...g, message: `south-west: ${g.message}` }))), m.warnings.push(...a.warnings.map((g) => ({ ...g, message: `north-east: ${g.message}` }))), m;
+}
+function we(e) {
+  if (!i.plainObject(e))
+    return {
+      valid: !1,
+      errors: [{ message: "Invalid crs: must be an object" }],
+      warnings: []
+    };
+  switch (e.type) {
+    case D.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 D.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 Ne(e, t, n = {}) {
+  const r = { type: "Feature" };
+  return (n.id === 0 || n.id) && (r.id = n.id), n.bbox && (r.bbox = n.bbox), r.properties = {}, r.geometry = e, r;
+}
+function Ae(e, t, n = {}) {
+  if (!e)
+    throw new Error("coordinates is required");
+  if (!Array.isArray(e))
+    throw new Error("coordinates must be an Array");
+  if (e.length < 2)
+    throw new Error("coordinates must be at least 2 numbers long");
+  if (!V(e[0]) || !V(e[1]))
+    throw new Error("coordinates must contain numbers");
+  return Ne({
+    type: "Point",
+    coordinates: e
+  }, t, n);
+}
+function V(e) {
+  return !isNaN(e) && e !== null && !Array.isArray(e);
+}
+function Me(e) {
+  if (Array.isArray(e))
+    return e;
+  if (e.type === "Feature") {
+    if (e.geometry !== null)
+      return e.geometry.coordinates;
+  } else if (e.coordinates)
+    return e.coordinates;
+  throw new Error(
+    "coords must be GeoJSON Feature, Geometry Object or an Array"
+  );
+}
+function Ce(e) {
+  const t = Me(e);
+  let n = 0, r = 1, s, a;
+  for (; r < t.length; )
+    s = a || t[0], a = t[r], n += (a[0] - s[0]) * (a[1] + s[1]), r++;
+  return n > 0;
+}
+var $e = Ce;
+function _e(e) {
+  let t, n;
+  const r = {
+    type: "FeatureCollection",
+    features: []
+  };
+  if (e.type === "Feature" ? n = e.geometry : n = e, n.type === "LineString")
+    t = [n.coordinates];
+  else if (n.type === "MultiLineString")
+    t = n.coordinates;
+  else if (n.type === "MultiPolygon")
+    t = [].concat(...n.coordinates);
+  else if (n.type === "Polygon")
+    t = n.coordinates;
+  else
+    throw new Error(
+      "Input must be a LineString, MultiLineString, Polygon, or MultiPolygon Feature or Geometry"
+    );
+  return t.forEach((s) => {
+    t.forEach((a) => {
+      for (let o = 0; o < s.length - 1; o++)
+        for (let u = o; u < a.length - 1; u++) {
+          if (s === a && (Math.abs(o - u) === 1 || // segments are first and last segment of lineString
+          o === 0 && u === s.length - 2 && // lineString is closed
+          s[o][0] === s[s.length - 1][0] && s[o][1] === s[s.length - 1][1]))
+            continue;
+          const c = Ue(
+            s[o][0],
+            s[o][1],
+            s[o + 1][0],
+            s[o + 1][1],
+            a[u][0],
+            a[u][1],
+            a[u + 1][0],
+            a[u + 1][1]
+          );
+          c && r.features.push(Ae([c[0], c[1]]));
+        }
+    });
+  }), r;
+}
+function Ue(e, t, n, r, s, a, o, u) {
+  let c, f, m, g, x;
+  const E = {
+    x: null,
+    y: null,
+    onLine1: !1,
+    onLine2: !1
+  };
+  return c = (u - a) * (n - e) - (o - s) * (r - t), c === 0 ? E.x !== null && E.y !== null ? E : !1 : (f = t - a, m = e - s, g = (o - s) * f - (u - a) * m, x = (n - e) * f - (r - t) * m, f = g / c, m = x / c, E.x = e + f * (n - e), E.y = t + f * (r - t), f >= 0 && f <= 1 && (E.onLine1 = !0), m >= 0 && m <= 1 && (E.onLine2 = !0), E.onLine1 && E.onLine2 ? [E.x, E.y] : !1);
+}
+var Ge = _e;
+function xe(e, t) {
+  if (!i.defined(e.crs)) return t;
+  const n = we(e.crs);
+  return n.valid || (t.valid = !1, t.errors.push(...n.errors.map((r) => ({ ...r, path: "/crs" })))), t.warnings.push(...n.warnings.map((r) => ({ ...r, path: "/crs" }))), t;
+}
+function A(e, t, n = "") {
+  if (!i.defined(e.bbox)) return t;
+  const r = Re(e.bbox);
+  return r.valid || (t.valid = !1, t.errors.push(...r.errors.map((s) => ({ ...s, path: `${n}/bbox` })))), t.warnings.push(...r.warnings.map((s) => ({ ...s, path: `${n}/bbox` }))), t;
+}
+function b(e, t, n = "") {
+  const r = {
+    valid: !0,
+    errors: [],
+    warnings: []
+  };
+  for (let s = 0; s < e.length; s++) {
+    const a = `${n}/${s}`, o = t(e[s], a, s);
+    if (!o.valid) {
+      r.valid = !1, r.errors = r.errors.concat(o.errors.map((u) => ({ ...u, path: u.path || a, index: s })));
+      continue;
+    }
+    i.empty(o.warnings) || (r.warnings = r.warnings.concat(o.warnings.map((u) => ({ ...u, path: u.path || a, index: s }))));
+  }
+  return r;
+}
+function U(e, t = 0, n = "") {
+  return i.arrayOfLengthAtLeast(e, t) ? b(e, I, n) : {
+    valid: !1,
+    errors: [{ message: `Invalid coordinates: must have at least ${t} positions`, path: n }],
+    warnings: []
+  };
+}
+function z(e, t = "") {
+  const n = U(e, 2, t);
+  if (!n.valid) return n;
+  for (let r = 0; r < e.length - 1; r++) {
+    const s = e[r][0], a = e[r + 1][0];
+    Math.abs(a - s) > 180 && n.warnings.push({
+      message: `LineString crosses the antimeridian between positions ${r} and ${r + 1}, consider using MultiLineString`,
+      path: `${t}/${r}`
+    });
+  }
+  return n;
+}
+function Fe(e, t = "") {
+  return i.nonEmptyArray(e) ? b(e, z, t) : {
+    valid: !1,
+    errors: [{ message: "Invalid MultiLineString: coordinates must be a non empty array", path: t }],
+    warnings: []
+  };
+}
+function ke(e, t, n = "") {
+  const r = U(e, 4, n);
+  if (!r.valid) return r;
+  const s = e[0], a = e[e.length - 1];
+  if (s[0] !== a[0] || s[1] !== a[1])
+    return r.valid = !1, r.errors.push({ message: "Invalid LinearRing: first and last position must be identical", path: n }), r;
+  const u = $e(e) ? "clockwise" : "counter-clockwise";
+  u !== t && r.warnings.push({ message: `Ring must be ${t} but is ${u}`, path: n });
+  const c = Ge({ type: "Polygon", coordinates: [e] });
+  return c.features.length > 0 && (r.valid = !1, r.errors.push({ message: `Invalid LinearRing: ${c.features.length} self-intersection(s) detected`, path: n })), r;
+}
+function Q(e, t = "") {
+  return i.nonEmptyArray(e) ? b(e, (n, r, s) => ke(n, s === 0 ? "counter-clockwise" : "clockwise", r), t) : {
+    valid: !1,
+    errors: [{ message: "Invalid Polygon: coordinates must be a non empty array", path: t }],
+    warnings: []
+  };
+}
+function Pe(e, t = "") {
+  return i.nonEmptyArray(e) ? b(e, (n, r) => Q(n, r), t) : {
+    valid: !1,
+    errors: [{ message: "Invalid MultiPolygon: coordinates must be a non empty array", path: t }],
+    warnings: []
+  };
+}
+function He(e, t = "") {
+  return i.nonEmptyArray(e) ? b(e, (n, r) => G(n, r), t) : {
+    valid: !1,
+    errors: [{ message: "Invalid geometries: geometries must be a non empty array", path: t }],
+    warnings: []
+  };
+}
+function G(e, t = "") {
+  if (!i.nonEmptyObject(e))
+    return {
+      valid: !1,
+      errors: [{ message: "Invalid geometry: geometry must be a non empty object", path: t }],
+      warnings: []
+    };
+  const n = `${t}/coordinates`;
+  let r;
+  switch (e.type) {
+    case p.POINT: {
+      const s = I(e.coordinates);
+      r = {
+        valid: s.valid,
+        errors: s.errors.map((a) => ({ ...a, path: n })),
+        warnings: s.warnings.map((a) => ({ ...a, path: n }))
+      };
+      break;
+    }
+    case p.MULTI_POINT: {
+      r = U(e.coordinates, 0, n);
+      break;
+    }
+    case p.LINESTRING: {
+      r = z(e.coordinates, n);
+      break;
+    }
+    case p.MULTI_LINESTRING: {
+      r = Fe(e.coordinates, n);
+      break;
+    }
+    case p.POLYGON: {
+      r = Q(e.coordinates, n);
+      break;
+    }
+    case p.MULTI_POLYGON: {
+      r = Pe(e.coordinates, n);
+      break;
+    }
+    case p.GEOMETRY_COLLECTION: {
+      r = He(e.geometries, `${t}/geometries`);
+      break;
+    }
+    default:
+      return {
+        valid: !1,
+        errors: [{ message: `Invalid geometry type: ${e.type}`, path: t }],
+        warnings: []
+      };
+  }
+  return A(e, r, t);
+}
+function X(e, t = "") {
+  if (!i.nonEmptyObject(e))
+    return {
+      valid: !1,
+      errors: [{ message: "Invalid feature: must be a non empty object", path: t }],
+      warnings: []
+    };
+  if (e.type === h.FEATURE) {
+    if (i.nonEmptyObject(e.geometry)) {
+      const n = G(e.geometry, `${t}/geometry`);
+      return A(e, n, t);
+    }
+    return {
+      valid: !0,
+      errors: [],
+      warnings: [{ message: "Feature has no geometry", path: t }]
+    };
+  }
+  if (e.type === h.FEATURE_COLLECTION) {
+    if (i.nonEmptyArray(e.features)) {
+      const n = b(e.features, X, `${t}/features`);
+      return A(e, n, t);
+    }
+    return {
+      valid: !1,
+      errors: [{ message: "Invalid FeatureCollection: features must be a non empty array", path: t }],
+      warnings: []
+    };
+  }
+  return {
+    valid: !1,
+    errors: [{ message: `Invalid feature: unknown type: ${e.type}`, path: t }],
+    warnings: []
+  };
+}
+function at(e) {
+  if (l.that(e, i.nonEmptyObject, "geojson must be a non empty object"), i.oneOf(e.type, Object.values(p))) return G(e, "");
+  if (e.type === h.FEATURE || e.type === h.FEATURE_COLLECTION) {
+    const t = X(e, "");
+    return xe(e, t);
+  }
+  return {
+    valid: !1,
+    errors: [{ message: "Invalid GeoJson: type must be either a Geometry, a Feature or a FeatureCollection" }],
+    warnings: []
+  };
+}
+export {
+  d as AXES,
+  N as COORDINATE_FORMATS,
+  be as COORDINATE_MODELS,
+  _ as COORDINATE_TRUNCATION_FACTORS,
+  D as CRS_TYPES,
+  h as FEATURE_TYPES,
+  p as GEOMETRY_TYPES,
+  et as convertCoordinate,
+  H as getCoordinatePrecision,
+  ae as getDirectionAxis,
+  Ye as getDirections,
+  Qe as getEast,
+  ie as getLocale,
+  qe as getNorth,
+  ze as getSouth,
+  Xe as getWest,
+  P as guessCoordinateAxis,
+  We as isAltitude,
+  Z as isAxis,
+  v as isDirection,
+  j as isEast,
+  R as isLatitude,
+  Te as isLikeBBox,
+  nt as isLikeCRS,
+  De as isLikeFeature,
+  Ie as isLikeFeatureCollection,
+  rt as isLikeGeoJson,
+  Le as isLikeGeometry,
+  Se as isLikePosition,
+  W as isLongitude,
+  se as isNorth,
+  B as isSouth,
+  $ as isWest,
+  Be as listLocales,
+  Je as normalizeCoordinate,
+  Oe as parseCoordinate,
+  tt as parsePosition,
+  je as registerLocale,
+  Ke as setLocale,
+  it as truncateBBox,
+  Ze as truncateCoordinate,
+  st as truncatePosition,
+  Re as validateBBox,
+  we as validateCRS,
+  at as validateGeoJson,
+  G as validateGeometry,
+  I as validatePosition
+};
+//# sourceMappingURL=index.mjs.map