@kalisio/common-geospatial 0.9.0 → 0.10.0

package/dist/index.mjs

@@ -1,1922 +1,102 @@
-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 He(e) {
-  return u.that(e, a.string, "axis must be a string"), Object.values(O).includes(e);
-}
-function X(e) {
-  return u.that(e, a.string, "axis must be a string"), e === O.LATITUDE;
-}
-function Ee(e) {
-  return u.that(e, a.string, "axis must be a string"), e === O.LONGITUDE;
-}
-function zn(e) {
-  return u.that(e, a.string, "axis must be a string"), e === O.ALTITUDE;
-}
-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: 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 x = "en";
-const Ce = "en";
-function Kn() {
-  return Object.keys(P);
-}
-function qn(e) {
-  u.all([
-    { 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 Ut() {
-  return x;
-}
-function Xe() {
-  return x === Ce ? [x] : [x, Ce];
-}
-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: a.string, message: "code must be a string" },
-    { value: e, validator: (t) => A.key(P, t), message: "code is unknown" }
-  ]), P[e];
-}
-function $() {
-  return Oe(Ut()).DIRECTIONS;
-}
-function ae(e) {
-  const t = /* @__PURE__ */ new Set();
-  for (const n of Xe()) {
-    const { DIRECTIONS: r } = Oe(n);
-    for (const i of e) t.add(r[i].symbol);
-  }
-  return [...t];
-}
-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 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 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 Jn() {
-  return $().NORTH;
-}
-function er() {
-  return $().SOUTH;
-}
-function tr() {
-  return $().EAST;
-}
-function nr() {
-  return $().WEST;
-}
-function C(e) {
-  return u.that(e, a.string, "dir must be a string"), Vt(e) || ze(e) || Ne(e) || ne(e);
-}
-function Vt(e) {
-  return u.that(e, a.string, "dir must be a string"), te("NORTH", e);
-}
-function ze(e) {
-  return u.that(e, a.string, "dir must be a string"), te("SOUTH", e);
-}
-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 n;
-    },
-    get format() {
-      return "DD";
-    },
-    isValid() {
-      return l.number(t);
-    },
-    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() ? Y({ degrees: t, direction: n }) : 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 n;
-    },
-    get direction() {
-      return r;
-    },
-    get format() {
-      return "DDM";
-    },
-    isValid() {
-      return l.integer(t) && l.inRangeExclusiveMax(n, 0, 60);
-    },
-    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() ? Y({ degrees: t + n / 60, direction: r }) : null;
-    }
-  };
-}
-const Yt = {
-  degrees: l.nonNegativeInteger,
-  minutes: (e) => l.inRangeExclusiveMax(e, 0, 60),
-  direction: C
-};
-function Ht() {
-  return new RegExp(`^(\\d{2})(\\d{3})([${B(O.LATITUDE).join("")}])$`, "i");
-}
-function Wt() {
-  return new RegExp(`^(\\d{3})(\\d{3})([${B(O.LONGITUDE).join("")}])$`, "i");
-}
-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 n;
-    },
-    get direction() {
-      return r;
-    },
-    get format() {
-      return "DDM_AERO";
-    },
-    isValid() {
-      return l.nonNegativeInteger(t) && l.inRangeExclusiveMax(n, 0, 60) && C(r);
-    },
-    toString() {
-      if (!this.isValid()) return "";
-      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() ? Y({ degrees: t + n / 60, direction: r }) : 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 n;
-    },
-    get seconds() {
-      return r;
-    },
-    get direction() {
-      return i;
-    },
-    get format() {
-      return "DMS";
-    },
-    isValid() {
-      return l.integer(t) && l.integer(n) && l.inRange(n, 0, 59) && l.inRangeExclusiveMax(r, 0, 60);
-    },
-    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() ? Y({ degrees: t + n / 60 + r / 3600, direction: i }) : null;
-    }
-  };
-}
-function Ge(e) {
-  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 Me = {
-  DD: (e) => (_.that(e, (t) => t.isValid(), "dd must be a valid coordinate"), e),
-  DDM: (e) => {
-    _.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) => {
-    _.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) => {
-    _.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 });
-  }
-}, fe = {
-  DD: "DD",
-  DDM: "DDM",
-  DDM_AERO: "DDM_AERO",
-  DMS: "DMS"
-}, 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: 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 n = Qt[t];
-  return Math.round(e * n) / n;
-}
-function rr(e, t) {
-  if (u.all([
-    { 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 n = ((e + 180) % 360 + 360) % 360 - 180;
-  return n === -180 && (n = 180), Object.is(n, -0) && (n = 0), n;
-}
-function ir(e, t) {
-  u.all([
-    { 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 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;
-}
-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 [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;
-  };
-  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 u.that(e, Z, "bbox must be a valid bounding-box"), a.arrayOfLength(e, 6);
-}
-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 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);
-}
-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",
-  MULTI_LINESTRING: "MultiLineString",
-  POLYGON: "Polygon",
-  MULTI_POLYGON: "MultiPolygon",
-  GEOMETRY_COLLECTION: "GeometryCollection"
-}, p = {
-  FEATURE: "Feature",
-  FEATURE_COLLECTION: "FeatureCollection"
-};
-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 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 An(e) {
-  return e.type === m.POLYGON ? [e.coordinates] : e.coordinates;
-}
-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 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] - n[1]) + t[0] * (n[1] - e[1]) + n[0] * (e[1] - t[1])) / 2
-  );
-}
-function ce(e, { tolerance: t = 0, getWeight: n = () => 1 } = {}) {
-  if (e.length <= 2) return e;
-  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 E = r[0];
-  for (; E; )
-    E.removed || g.push(E.coord), E = E.next;
-  return g;
-}
-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 = ce(e.coordinates, t);
-      break;
-    case m.POLYGON:
-    case m.MULTI_LINESTRING:
-      e.coordinates = e.coordinates.map((n) => ce(n, t));
-      break;
-    case m.MULTI_POLYGON:
-      e.coordinates = e.coordinates.map((n) => n.map((r) => ce(r, t)));
-      break;
-    case m.GEOMETRY_COLLECTION:
-      e.geometries.forEach((n) => de(n, t));
-      break;
-  }
-  return e;
-}
-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;
-}
-function It(e, t, n) {
-  if (e.type === p.FEATURE)
-    e.geometry && Se(e.geometry, t, n);
-  else
-    for (const r of e.features) It(r, t, n);
-  return e.bbox && ut(e.bbox, t), e;
-}
-function Lr(e, t = {}) {
-  const { precision: n = v, consider3D: r = !1 } = t;
-  return u.all([
-    {
-      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);
-}
-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: [{ code: d.UNSUPPORTED_NESTED_CRS, path: t }],
-      warnings: []
-    };
-  if (!l.plainObject(e))
-    return {
-      valid: !1,
-      errors: [{ code: d.INVALID_CRS_OBJECT, path: t }],
-      warnings: []
-    };
-  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: [{ code: d.INVALID_POSITION_LENGTH, path: t }],
-      warnings: []
-    };
-  if (!l.number(e[0]) || !l.number(e[1]))
-    return {
-      valid: !1,
-      errors: [{ code: d.INVALID_POSITION_COORDINATES, path: t }],
-      warnings: []
-    };
-  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: [{ code: d.INVALID_ALTITUDE, path: t }],
-      warnings: []
-    };
-  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 Ot(e, t = "", n = {}) {
-  const r = n?.geodesic;
-  if (!l.defined(e))
-    return {
-      valid: !0
-    };
-  if (!l.arrayOfLength(e, 4) && !l.arrayOfLength(e, 6))
-    return {
-      valid: !1,
-      errors: [{ code: d.INVALID_BBOX_LENGTH, path: t }],
-      warnings: []
-    };
-  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: [{ code: d.INVALID_BBOX_LATITUDE_ORDER, path: t, params: { south: f, north: D } }],
-      warnings: []
-    };
-  if (!r && E > I)
-    return {
-      valid: !1,
-      errors: [{ code: d.INVALID_BBOX_LONGITUDE_ORDER, path: t, params: { west: E, east: I } }],
-      warnings: []
-    };
-  if (!i) {
-    const De = e[2], Ae = e[5];
-    if (De > Ae)
-      return {
-        valid: !1,
-        errors: [{ code: d.INVALID_BBOX_ALTITUDE_ORDER, path: t, params: { minAlt: De, maxAlt: Ae } }],
-        warnings: []
-      };
-  }
-  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 _e() {
-  return { Feature: 0, FeatureCollection: 0, geometries: {} };
-}
-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 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: _e()
-  };
-  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 r;
-}
-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 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 be(e, t = 0, n = "", r = {}) {
-  return l.arrayOfLengthAtLeast(e, t) ? w(e, (i, s) => ee(i, s, r), n) : {
-    valid: !1,
-    errors: [{ code: d.INVALID_COORDINATES_LENGTH, path: n, params: { minimumLength: t } }],
-    warnings: []
-  };
-}
-function vt(e, t = "", n = {}) {
-  const r = be(e, 2, t, n);
-  if (!r.valid) return r;
-  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 wn(e, t = "", n = {}) {
-  return l.nonEmptyArray(e) ? w(e, (r, i) => vt(r, i, n), t) : {
-    valid: !1,
-    errors: [{ code: d.INVALID_MULTI_LINESTRING_COORDINATES, 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 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: [{ code: d.INVALID_MULTIPOLYGON_COORDINATES, path: t }],
-    warnings: []
-  };
-}
-function kn(e, t = "", n = {}) {
-  return l.nonEmptyArray(e) ? w(e, (r, i) => Re(r, i, n), t) : {
-    valid: !1,
-    errors: [{ code: d.INVALID_GEOMETRYCOLLECTION_GEOMETRIES, path: t }],
-    warnings: []
-  };
-}
-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:
-      r = L(r, ee(e.coordinates, i, n));
-      break;
-    case m.MULTI_POINT:
-      r = L(r, be(e.coordinates, 0, i, n));
-      break;
-    case m.LINESTRING:
-      r = L(r, vt(e.coordinates, i, n));
-      break;
-    case m.MULTI_LINESTRING:
-      r = L(r, wn(e.coordinates, i, n));
-      break;
-    case m.POLYGON:
-      r = L(r, Lt(e.coordinates, i, n));
-      break;
-    case m.MULTI_POLYGON:
-      r = L(r, xn(e.coordinates, i, n));
-      break;
-    case m.GEOMETRY_COLLECTION:
-      r = L(r, kn(e.geometries, `${t}/geometries`, n));
-      break;
-    default:
-      return r.valid = !1, r.errors.push({ code: d.INVALID_GEOMETRY_TYPE, path: t, params: { type: e.type } }), r;
-  }
-  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: [{
-      code: d.UNKNOWN_TYPE,
-      path: "",
-      params: { type: e.type }
-    }]
-  };
-}
+import { A as e, C as i, a as o, b as t, D as n, E as r, I as c, M as l, T as C, W as S, c as g, d, e as O, f as P, g as A, h as E, i as R, j as T, k as u, l as I, m as x, n as N, o as _, p as L, q as m, r as B, s as G, t as D, u as p, v as J, w as F, x as f, y as k, z as j, B as M, F as V, G as h, H as b, J as v, K as U, L as H, N as W, O as Y, P as y, Q as z, R as w, S as X, U as q, V as K, X as Q, Y as Z, Z as $, _ as ss, $ as as, a0 as es, a1 as is, a2 as os, a3 as ts, a4 as ns, a5 as rs, a6 as cs, a7 as ls, a8 as Cs, a9 as Ss, aa as gs, ab as ds, ac as Os, ad as Ps, ae as As, af as Es } from "./ring-Cks2pGr8.js";
+import { i as Ts, l as us } from "./line-CcfAx7LP.js";
+import { C as xs, F as Ns, G as _s, V as Ls, c as ms, f as Bs, i as Gs, a as Ds, b as ps, d as Js, e as Fs, g as fs, h as ks, j as js, k as Ms, s as Vs, v as hs } from "./geojson-CJ6QZ9pN.js";
+import { c as vs, e as Us, a as Hs, b as Ws, r as Ys, t as ys } from "./truncate-Cs8jmwOi.js";
 export {
-  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,
-  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
+  e as AXES,
+  i as COORDINATE_FORMATS,
+  o as COORDINATE_MODELS,
+  t as COORDINATE_TRUNCATION_FACTORS,
+  xs as CRS_TYPES,
+  n as DEFAULT_COORDINATE_PRECISION,
+  r as EARTH_RADIUS,
+  Ns as FEATURE_TYPES,
+  _s as GEOMETRY_TYPES,
+  c as IS_SAME_POSITION_OPTIONS_SCHEMA,
+  l as MAX_COORDINATE_PRECISION,
+  C as TRUNCATE_POSITIONS_OPTIONS_SCHEMA,
+  Ls as VALIDATION_CODES,
+  S as WGS84,
+  g as closeRing,
+  d as computeBBox,
+  ms as computeGeoJsonBoundingBox,
+  vs as computeGeoJsonConvexHull,
+  O as convertCoordinate,
+  P as deduplicatePositions,
+  A as defineProjection,
+  E as denormalizeCrsName,
+  R as destinationFromPosition,
+  T as distanceBetweenPositions,
+  Us as extractGeoJsonBBox,
+  Hs as extractGeoJsonCRS,
+  Ws as extractGeoJsonNode,
+  Bs as fixGeoJson,
+  u as getActiveLocales,
+  I as getCoordinatePrecision,
+  x as getDirectionAxis,
+  N as getDirectionSymbols,
+  _ as getDirections,
+  L as getEast,
+  m as getLocale,
+  B as getMessages,
+  G as getNorth,
+  D as getProjection,
+  p as getSouth,
+  J as getWest,
+  F as guessCoordinateAxis,
+  f as hasProjection,
+  k as is3DBBox,
+  j as is3DPosition,
+  M as isAltitude,
+  V as isClockwiseRing,
+  h as isClosedRing,
+  b as isEast,
+  Gs as isGeoJsonFixable,
+  v as isLatitude,
+  Ds as isLikeBBox,
+  ps as isLikeCRS,
+  Js as isLikeFeature,
+  Fs as isLikeFeatureCollection,
+  fs as isLikeFeatureOrFeatureCollection,
+  ks as isLikeGeoJson,
+  js as isLikeGeometry,
+  Ms as isLikePosition,
+  U as isLongitude,
+  H as isNorth,
+  W as isSamePosition,
+  Y as isSouth,
+  y as isValidAxis,
+  z as isValidBBox,
+  w as isValidDirection,
+  Ts as isValidLine,
+  X as isValidPosition,
+  q as isValidPositions,
+  K as isValidRing,
+  Q as isWGS84Projection,
+  Z as isWest,
+  us as lineLength,
+  $ as listLocales,
+  ss as listProjections,
+  as as mergeBBox,
+  es as normalizeCoordinate,
+  is as normalizeCrsName,
+  os as parseCoordinate,
+  ts as parsePosition,
+  ns as registerMessages,
+  Ys as reprojectGeoJson,
+  rs as reprojectPosition,
+  cs as reprojectPositions,
+  ls as ringSelfIntersections,
+  Cs as ringsIntersect,
+  Ss as setLocale,
+  Vs as simplifyGeoJson,
+  gs as sphericalRingArea,
+  ds as truncateBBox,
+  Os as truncateCoordinate,
+  ys as truncateGeoJson,
+  Ps as truncatePosition,
+  As as truncatePositions,
+  Es as truncateRing,
+  hs as validateGeoJson
 };
 //# sourceMappingURL=index.mjs.map