@kalisio/common-geospatial 0.9.0 → 0.10.0

package/dist/ring-Cks2pGr8.js

@@ -0,0 +1,1334 @@
+import v from "proj4";
+const z = typeof process > "u" || process.env?.NODE_ENV !== "production";
+class K extends Error {
+  constructor(t) {
+    super(t), this.name = "AssertionError";
+  }
+}
+function Q(e, t, n) {
+  if (!t(e)) throw new K(n);
+}
+const o = {
+  that(e, t, n) {
+    z && Q(e, t, n);
+  },
+  all(e) {
+    if (z)
+      for (const { value: t, validator: n, message: r } of e)
+        Q(t, n, r);
+  },
+  any(e) {
+    if (!(!z || e.length === 0) && !e.some(({ value: t, validator: n }) => n(t)))
+      throw new K(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 = "", u = ""] = t;
+    return r.split(",").every((l, c) => (l = l.trim(), !l || c > 0 && l.includes("@") ? !1 : URL.canParse(`${n}${l}${i}${s}${u}`)));
+  },
+  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 o.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 o.that(n, (r) => r > t, "max must be greater than min"), a.number(e) && e > t && e < n;
+  },
+  inRangeExclusiveMin(e, t, n) {
+    return o.that(n, (r) => r > t, "max must be greater than min"), a.number(e) && e > t && e <= n;
+  },
+  inRangeExclusiveMax(e, t, n) {
+    return o.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 o.that(t, a.nonNegativeInteger, "length must be a non negative integer"), a.array(e) && e.length === t;
+  },
+  arrayOfLengthAtLeast(e, t) {
+    return o.that(t, a.nonNegativeInteger, "minLength must be a non negative integer"), a.array(e) && e.length >= t;
+  },
+  arrayOfLengthAtMost(e, t) {
+    return o.that(t, a.nonNegativeInteger, "maxLength must be a non negative integer"), a.array(e) && e.length <= t;
+  },
+  arrayOfLengthBetween(e, t, n) {
+    return o.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 o.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;
+  }
+}, I = {
+  key(e, t) {
+    return o.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 o.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) => I.key(e, n));
+  },
+  keyWithValue(e, t) {
+    return I.key(e, t) && a.defined(e[t]);
+  },
+  path(e, t) {
+    o.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 se(e, t, n = "") {
+  return Object.entries(t).every(([r, i]) => {
+    const s = n ? `${n}.${r}` : r;
+    if (!I.key(e, r))
+      return i._optional === !0;
+    const u = e[r];
+    if (a.plainObject(i))
+      return a.plainObject(u) && se(u, i, s);
+    if (typeof i == "function")
+      return i(u);
+    throw new K(`Invalid validator for key "${s}"`);
+  });
+}
+const d = {
+  schema(e, t) {
+    return o.all([
+      { value: e, validator: a.plainObject, message: "obj must be an object" },
+      { value: t, validator: a.plainObject, message: "schema must be an object" }
+    ]), se(e, t);
+  }
+};
+function g(e) {
+  o.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 m = {
+  LATITUDE: "LAT",
+  LONGITUDE: "LON",
+  ALTITUDE: "ALT"
+};
+function oe(e) {
+  return o.that(e, a.string, "axis must be a string"), Object.values(m).includes(e);
+}
+function G(e) {
+  return o.that(e, a.string, "axis must be a string"), e === m.LATITUDE;
+}
+function q(e) {
+  return o.that(e, a.string, "axis must be a string"), e === m.LONGITUDE;
+}
+function Et(e) {
+  return o.that(e, a.string, "axis must be a string"), e === m.ALTITUDE;
+}
+const Ne = { NORTH: { label: "Nord", symbol: "N" }, SOUTH: { label: "Sud", symbol: "S" }, EAST: { label: "Est", symbol: "E" }, WEST: { label: "Ouest", symbol: "O" } }, Se = { INVALID_CONTENT: "Le contenu est invalide", EMPTY_OBJECT: "L'objet est vide", UNKNOWN_TYPE: "Le type de l'objet 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" }, De = {
+  DIRECTIONS: Ne,
+  VALIDATION: Se
+}, Le = { NORTH: { label: "North", symbol: "N" }, SOUTH: { label: "South", symbol: "S" }, EAST: { label: "East", symbol: "E" }, WEST: { label: "West", symbol: "W" } }, Te = { INVALID_CONTENT: "Contant is invalid", EMPTY_OBJECT: "Object is empty", UNKNOWN_TYPE: "Unknown object 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" }, ye = {
+  DIRECTIONS: Le,
+  VALIDATION: Te
+}, _e = {
+  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 }
+  }
+}, S = {
+  en: ye,
+  fr: De
+};
+let R = "en";
+const ee = "en";
+function vt() {
+  return Object.keys(S);
+}
+function It(e) {
+  o.all([
+    { value: e, validator: a.string, message: "code must be a string" },
+    { value: e, validator: (t) => I.key(S, t), message: "code is unknown" }
+  ]), R = e;
+}
+function Ae() {
+  return R;
+}
+function ue() {
+  return R === ee ? [R] : [R, ee];
+}
+function bt(e, t) {
+  o.all([
+    { value: e, validator: a.string, message: "code must be a string" },
+    { value: e, validator: (n) => !I.key(S, n), message: "messages already registered" },
+    { value: t, validator: a.plainObject, message: "messages must be an object" },
+    { value: t, validator: (n) => d.schema(n, _e), message: "messages do not conform to schema" }
+  ]), S[e] = t;
+}
+function J(e) {
+  return o.all([
+    { value: e, validator: a.string, message: "code must be a string" },
+    { value: e, validator: (t) => I.key(S, t), message: "code is unknown" }
+  ]), S[e];
+}
+function M() {
+  return J(Ae()).DIRECTIONS;
+}
+function W(e) {
+  const t = /* @__PURE__ */ new Set();
+  for (const n of ue()) {
+    const { DIRECTIONS: r } = J(n);
+    for (const i of e) t.add(r[i].symbol);
+  }
+  return [...t];
+}
+function w(e, t) {
+  const n = t.toUpperCase();
+  return ue().some((r) => {
+    const { label: i, symbol: s } = J(r).DIRECTIONS[e];
+    return n === i.toUpperCase() || n === s.toUpperCase();
+  });
+}
+function ht(e = null) {
+  const t = M();
+  return a.defined(e) ? (o.that(e, oe, "axis must be a valid axis"), G(e) ? [t.SOUTH, t.NORTH] : q(e) ? [t.EAST, t.WEST] : []) : [t.SOUTH, t.NORTH, t.EAST, t.WEST];
+}
+function j(e = null) {
+  return a.defined(e) ? (o.that(e, oe, "axis must be a valid axis"), G(e) ? W(["NORTH", "SOUTH"]) : q(e) ? W(["EAST", "WEST"]) : []) : W(["NORTH", "SOUTH", "EAST", "WEST"]);
+}
+function Ot() {
+  return M().NORTH;
+}
+function Nt() {
+  return M().SOUTH;
+}
+function St() {
+  return M().EAST;
+}
+function Dt() {
+  return M().WEST;
+}
+function h(e) {
+  return o.that(e, a.string, "dir must be a string"), Re(e) || le(e) || Z(e) || k(e);
+}
+function Re(e) {
+  return o.that(e, a.string, "dir must be a string"), w("NORTH", e);
+}
+function le(e) {
+  return o.that(e, a.string, "dir must be a string"), w("SOUTH", e);
+}
+function Z(e) {
+  return o.that(e, a.string, "dir must be a string"), w("EAST", e);
+}
+function k(e) {
+  return o.that(e, a.string, "dir must be a string"), w("WEST", e);
+}
+function Ce(e) {
+  return o.that(e, h, "dir must be a direction"), k(e) || Z(e) ? m.LONGITUDE : m.LATITUDE;
+}
+const Me = {
+  degrees: a.number,
+  direction: g(h)
+}, je = /^(-?\d{1,3}(?:\.\d+)?)°?$/;
+function Ve() {
+  return new RegExp(`^(\\d{1,3}(?:\\.\\d+)?)°?([${j()}])$`, "i");
+}
+function V(e) {
+  let t = null, n = null;
+  if (a.plainObject(e) && d.schema(e, Me))
+    a.defined(e.direction) ? e.degrees >= 0 && (t = e.degrees, n = e.direction) : t = e.degrees;
+  else if (a.string(e)) {
+    const r = e.replace(/\s+/g, ""), i = r.match(je) ?? r.match(Ve());
+    i && (t = parseFloat(i[1]), n = i[2] ?? null);
+  }
+  return {
+    get degrees() {
+      return t;
+    },
+    get direction() {
+      return n;
+    },
+    get format() {
+      return "DD";
+    },
+    isValid() {
+      return a.number(t);
+    },
+    toString(r) {
+      if (o.that(r, a.positiveInteger, "decimalPlaces must be a positive integer"), !this.isValid()) return "";
+      let i = `${t.toFixed(r)}°`;
+      return n && (i += ` ${n}`), i;
+    },
+    toDecimal() {
+      return this.isValid() ? V({ degrees: t, direction: n }) : null;
+    }
+  };
+}
+const Ge = {
+  degrees: a.integer,
+  minutes: (e) => a.inRangeExclusiveMax(e, 0, 60),
+  direction: g(h)
+}, Ue = /^(-?\d{1,3})°(\d{1,2}(?:\.\d+)?)'?$/;
+function Pe() {
+  return new RegExp(`^(\\d{1,3})°(\\d{1,2}(?:\\.\\d+)?)'?([${j().join("")}])$`, "i");
+}
+function ce(e) {
+  let t = null, n = null, r = null;
+  if (a.plainObject(e) && d.schema(e, Ge))
+    a.defined(e.direction) ? e.degrees >= 0 && (t = e.degrees, n = e.minutes, r = e.direction) : (t = e.degrees, n = e.minutes);
+  else if (a.string(e)) {
+    const i = e.replace(/\s+/g, ""), s = i.match(Ue) ?? i.match(Pe());
+    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 a.integer(t) && a.inRangeExclusiveMax(n, 0, 60);
+    },
+    toString(i) {
+      if (o.that(i, a.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() ? V({ degrees: t + n / 60, direction: r }) : null;
+    }
+  };
+}
+const xe = {
+  degrees: a.nonNegativeInteger,
+  minutes: (e) => a.inRangeExclusiveMax(e, 0, 60),
+  direction: h
+};
+function Be() {
+  return new RegExp(`^(\\d{2})(\\d{3})([${j(m.LATITUDE).join("")}])$`, "i");
+}
+function $e() {
+  return new RegExp(`^(\\d{3})(\\d{3})([${j(m.LONGITUDE).join("")}])$`, "i");
+}
+function me(e) {
+  let t = null, n = null, r = null;
+  if (a.plainObject(e) && d.schema(e, xe))
+    t = e.degrees, n = e.minutes, r = e.direction;
+  else if (a.string(e)) {
+    const i = e.trim(), s = i.match(Be()) ?? i.match($e());
+    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 a.nonNegativeInteger(t) && a.inRangeExclusiveMax(n, 0, 60) && h(r);
+    },
+    toString() {
+      if (!this.isValid()) return "";
+      const i = Z(r) || k(r), s = String(t).padStart(i ? 3 : 2, "0"), u = Math.floor(n * 10).toString().padStart(3, "0");
+      return `${s}${u}${r}`;
+    },
+    toDecimal() {
+      return this.isValid() ? V({ degrees: t + n / 60, direction: r }) : null;
+    }
+  };
+}
+const we = {
+  degrees: a.integer,
+  minutes: (e) => a.integer(e) && a.inRange(e, 0, 59),
+  seconds: (e) => a.inRangeExclusiveMax(e, 0, 60),
+  direction: g(h)
+}, ke = /^(-?\d{1,3})°(\d{1,2})'(\d{1,2}(?:\.\d+)?)"?$/;
+function He() {
+  return new RegExp(`^(\\d{1,3})°(\\d{1,2})'(\\d{1,2}(?:\\.\\d+)?)"?([${j().join("")}])$`, "i");
+}
+function ge(e) {
+  let t = null, n = null, r = null, i = null;
+  if (a.plainObject(e) && d.schema(e, we))
+    a.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 (a.string(e)) {
+    const s = e.replace(/\s+/g, ""), u = s.match(ke) ?? s.match(He());
+    u && (t = parseFloat(u[1]), n = parseFloat(u[2]), r = parseFloat(u[3]), i = u[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 a.integer(t) && a.integer(n) && a.inRange(n, 0, 59) && a.inRangeExclusiveMax(r, 0, 60);
+    },
+    toString(s) {
+      if (o.that(s, a.positiveInteger, "decimalPlaces must be a positive integer"), !this.isValid()) return "";
+      let u = `${t}° ${n}' ${r.toFixed(s)}"`;
+      return i && (u += ` ${i}`), u;
+    },
+    toDecimal() {
+      return this.isValid() ? V({ degrees: t + n / 60 + r / 3600, direction: i }) : null;
+    }
+  };
+}
+function te(e) {
+  const t = Math.floor(e.degrees), n = (e.degrees - t) * 60;
+  return { degrees: t, minutes: n, direction: e.direction };
+}
+function ze(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 ne = {
+  DD: (e) => (o.that(e, (t) => t.isValid(), "dd must be a valid coordinate"), e),
+  DDM: (e) => {
+    o.that(e, (i) => i.isValid(), "dd must be a valid coordinate");
+    const { degrees: t, minutes: n, direction: r } = te(e);
+    return ce(r ? { degrees: t, minutes: n, direction: r } : { degrees: t, minutes: n });
+  },
+  DMS: (e) => {
+    o.that(e, (s) => s.isValid(), "dd must be a valid coordinate");
+    const { degrees: t, minutes: n, seconds: r, direction: i } = ze(e);
+    return ge(i ? { degrees: t, minutes: n, seconds: r, direction: i } : { degrees: t, minutes: n, seconds: r });
+  },
+  DDM_AERO: (e) => {
+    o.that(e, (i) => i.isValid(), "dd must be a valid coordinate");
+    const { degrees: t, minutes: n, direction: r } = te(e);
+    return me({ degrees: t, minutes: n, direction: r });
+  }
+}, F = {
+  DD: "DD",
+  DDM: "DDM",
+  DDM_AERO: "DDM_AERO",
+  DMS: "DMS"
+}, We = {
+  DD: V,
+  DDM: ce,
+  DDM_AERO: me,
+  DMS: ge
+}, L = 7, b = 8, Fe = Array.from({ length: b + 1 }, (e, t) => 10 ** t);
+function ae(e, t) {
+  if (o.that(e, a.number, "coord must be a number"), a.defined(t))
+    return o.that(t, h, "dir must be a direction"), Ce(t);
+  if (Math.abs(e) > 90) return m.LONGITUDE;
+}
+function Lt(e) {
+  o.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 de(e, t = L) {
+  o.all([
+    {
+      value: e,
+      validator: a.number,
+      message: "coord must be a number"
+    },
+    {
+      value: t,
+      validator: (r) => a.inRange(r, 0, b),
+      message: `precision must be in range [0, ${b}]`
+    }
+  ]);
+  const n = Fe[t];
+  return Math.round(e * n) / n;
+}
+function Tt(e, t) {
+  if (o.all([
+    { value: e, validator: a.number, message: "coord must be a number" },
+    { value: t, validator: (r) => q(r) || G(r), message: "axis must be either a longitude or latitude" }
+  ]), G(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 yt(e, t) {
+  o.all([
+    { value: e, validator: (r) => a.defined(r) && r.isValid(), message: "from must be a valid coordinate" },
+    { value: t, validator: (r) => I.key(ne, r), message: `unknown format: ${t}` }
+  ]);
+  const n = e.format === F.DD ? e : e.toDecimal();
+  return n.isValid() ? t === F.DD ? n : ne[t](n) : null;
+}
+function Ye(e) {
+  o.that(e, a.nonEmptyString, "pattern must be a non empty string");
+  for (const t of Object.keys(F)) {
+    const n = We[t](e);
+    if (n.isValid()) return n;
+  }
+  return null;
+}
+const _t = {
+  node: typeof process < "u" && process.versions?.node != null,
+  worker: typeof WorkerGlobalScope < "u" && self instanceof WorkerGlobalScope,
+  serviceWorker: typeof ServiceWorkerGlobalScope < "u" && self instanceof ServiceWorkerGlobalScope,
+  test: typeof process < "u" && process.env.NODE_ENV === "test",
+  dev: typeof process < "u" && process.env.NODE_ENV === "development",
+  prod: typeof process < "u" && process.env.NODE_ENV === "production"
+}, fe = {
+  ignoreSpaces: g(a.boolean),
+  ignoreDiacritics: g(a.boolean),
+  ignoreCase: g(a.boolean),
+  locale: g(a.string)
+}, Xe = {
+  ...fe
+};
+function O(e, t, n) {
+  return f.words(e).map((r, i) => t(f.normalize(r, { ignoreDiacritics: !0 }), i)).join(n);
+}
+const f = {
+  DIACRITICS: {
+    a: "aáàäâã",
+    e: "eéëèê",
+    i: "iíïìî",
+    o: "oóöòõô",
+    u: "uüúùû",
+    c: "cç"
+  },
+  normalize(e, t = {}) {
+    o.all([
+      { value: e, validator: a.string, message: "str must be a string" },
+      { value: t, validator: (l) => d.schema(l, fe) }
+    ]);
+    const {
+      ignoreSpaces: n = !1,
+      ignoreDiacritics: r = !1,
+      ignoreCase: i = !1,
+      locale: s = void 0
+      // 'fr-FR'
+    } = t;
+    let u = e;
+    return n && (u = u.replace(/\s+/g, " ").trim()), r && (u = u.normalize("NFKD").replace(new RegExp("\\p{M}", "gu"), "")), i && (u = u.toLocaleLowerCase(s)), u;
+  },
+  compare(e, t, n = {}) {
+    o.all([
+      { value: e, validator: a.string, message: "str1 must be a string" },
+      { value: t, validator: a.string, message: "str2 must be a string" },
+      { value: n, validator: (u) => d.schema(u, Xe) }
+    ]);
+    const r = { ignoreDiacritics: !0, ignoreCase: !0, ...n }, i = f.normalize(e, r), s = f.normalize(t, r);
+    return i.localeCompare(s, n.locale);
+  },
+  makeDiacriticPattern(e, t = {}) {
+    o.that(e, a.string, "pattern must be a string");
+    const { reverse: n = !1 } = t ?? {};
+    let r = "";
+    for (const i of e) {
+      const s = i.toLowerCase();
+      let u = null;
+      for (const l of Object.values(this.DIACRITICS))
+        if (n && l.includes(s) || !n && l.startsWith(s)) {
+          u = l;
+          break;
+        }
+      u ? r += `[${u}]` : r += i;
+    }
+    return r;
+  },
+  initials(e, t = {}) {
+    o.that(e, a.string, "str must be a string");
+    const { max: n = void 0 } = t, r = e.trim().split(/[\s-]+/).filter(Boolean).map((i) => i[0].toUpperCase());
+    return (n ? r.slice(0, n) : r).join("");
+  },
+  words(e) {
+    return o.that(e, a.string, "str must be a string"), e.match(new RegExp("\\p{Lu}+(?=\\p{Lu}\\p{Ll})|\\p{Lu}?\\p{Ll}+|\\p{Lu}+|\\p{Nd}+", "gu")) ?? [];
+  },
+  slugify(e, t = "-") {
+    return o.all([
+      { value: e, validator: a.string, message: "str must be a string" },
+      { value: t, validator: a.char, message: "separator must be a char" }
+    ]), f.normalize(e.trim(), { ignoreDiacritics: !0 }).toLowerCase().replace(/[^a-z0-9]+/gi, t).replace(new RegExp(`^${t}|${t}$`, "g"), "");
+  },
+  capitalize(e) {
+    return o.that(e, a.string, "str must be a string"), e.charAt(0).toUpperCase() + e.slice(1).toLowerCase();
+  },
+  camelCase(e) {
+    return o.that(e, a.string, "str must be a string"), O(e, (t, n) => n === 0 ? t.toLowerCase() : f.capitalize(t), "");
+  },
+  pascalCase(e) {
+    return o.that(e, a.string, "str must be a string"), O(e, (t) => f.capitalize(t), "");
+  },
+  kebabCase(e) {
+    return o.that(e, a.string, "str must be a string"), O(e, (t) => t.toLowerCase(), "-");
+  },
+  snakeCase(e) {
+    return o.that(e, a.string, "str must be a string"), O(e, (t) => t.toLowerCase(), "_");
+  },
+  constantCase(e) {
+    return o.that(e, a.string, "str must be a string"), O(e, (t) => t.toUpperCase(), "_");
+  },
+  dotCase(e) {
+    return o.that(e, a.string, "str must be a string"), O(e, (t) => t.toLowerCase(), ".");
+  },
+  titleCase(e) {
+    return o.that(e, a.string, "str must be a string"), f.words(e).map((t) => f.capitalize(t)).join(" ");
+  }
+}, Y = {
+  ignoreSpaces: g(a.boolean),
+  ignoreDiacritics: g(a.boolean),
+  ignoreCase: g(a.boolean),
+  locale: g(a.string)
+}, Ke = {
+  ...Y,
+  ignoredKeys: g(a.array)
+};
+function X(e, t = {}) {
+  if (!a.defined(e)) return e;
+  const n = t?.ignoredKeys ?? [], r = { ignoreDiacritics: !1, ignoreCase: !1, locale: t.locale };
+  return a.array(e) ? e.map((i) => X(i, t)).sort(
+    (i, s) => f.compare(JSON.stringify(i), JSON.stringify(s), r)
+  ) : a.plainObject(e) ? Object.fromEntries(
+    Object.entries(e).filter(([i]) => !n.includes(i)).sort(([i], [s]) => f.compare(i, s, r)).map(([i, s]) => [
+      i,
+      X(s, t)
+    ])
+  ) : a.string(e) ? f.normalize(e, t) : e;
+}
+const At = {
+  clone(e) {
+    return o.that(e, a.defined, "obj must be defined"), structuredClone(e);
+  },
+  normalize(e, t = {}) {
+    return o.all([
+      { value: e, validator: (n) => a.array(n) || a.plainObject(n), message: "obj must be an array or a plain object" },
+      { value: t, validator: (n) => d.schema(n, Ke) }
+    ]), X(e, t);
+  },
+  reorder(e, t, n = {}) {
+    o.all([
+      { value: e, validator: a.plainObject, message: "obj must be a plain object" },
+      { value: t, validator: a.string, message: "property must be a string" },
+      { value: n, validator: (i) => d.schema(i, Y) }
+    ]);
+    const r = (i, s) => f.compare(i[t], s[t], n);
+    return Object.fromEntries(
+      Object.entries(e).sort(([, i], [, s]) => r(i, s))
+    );
+  },
+  lookup(e, t) {
+    return o.all([
+      { value: e, validator: a.defined, message: "obj must be defined" },
+      { value: t, validator: a.nonEmptyString, message: "path must be a non empty string" }
+    ]), t.split(".").reduce((n, r) => n?.[r], e);
+  },
+  dotify(e) {
+    o.that(e, a.plainObject, "obj must be a plain object");
+    const t = {};
+    function n(r, i) {
+      for (const [s, u] of Object.entries(r)) {
+        const l = i ? `${i}.${s}` : s;
+        a.nonEmptyObject(u) ? n(u, l) : t[l] = u;
+      }
+    }
+    return n(e), t;
+  },
+  sort(e, t, n = {}) {
+    return o.all([
+      { value: e, validator: a.array, message: "arr must be an array" },
+      { value: t, validator: a.string, message: "property must be a string" },
+      { value: n, validator: (r) => d.schema(r, Y) }
+    ]), [...e].sort((r, i) => f.compare(r[t], i[t], n));
+  }
+}, p = {
+  clamp(e, t, n) {
+    return o.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) {
+    o.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 o.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 o.all([
+      { value: e, validator: a.number, message: "value must be a number" },
+      { value: t, validator: a.number, message: "total must be a number" }
+    ]), p.round(e / t * 100, 2);
+  },
+  exponential(e, t = 2) {
+    if (o.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 o.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 o.that(e, a.number, "degrees must be a number"), e * Math.PI / 180;
+    },
+    degrees(e) {
+      return o.that(e, a.number, "radians must be a number"), e * 180 / Math.PI;
+    }
+  },
+  pow: {
+    square(e) {
+      return o.that(e, a.number, "value must be a number"), e * e;
+    },
+    cube(e) {
+      return o.that(e, a.number, "value must be a number"), p.pow.square(e) * e;
+    }
+  },
+  ease: {
+    in(e, t = 0.5) {
+      return o.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 o.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) {
+      o.that(e, (c) => a.inRange(c, 0, 1), "t must be in range [0, 1]");
+      const s = 1 - e, u = e * e, l = s * s;
+      return l * s * n + 3 * l * e * t + 3 * s * u * r + u * e * i;
+    }
+  },
+  stats: {
+    sum(e) {
+      return o.that(e, a.array, "values must be an array"), e.reduce((t, n) => t + n, 0);
+    },
+    average(e) {
+      return o.that(e, a.nonEmptyArray, "values must be a non-empty array"), p.stats.sum(e) / e.length;
+    },
+    median(e) {
+      o.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 ? p.linear(0.5, t[n - 1], t[n]) : t[n];
+    }
+  }
+}, U = p.to.radians(1), qe = 1e-12;
+function D(e) {
+  const t = e[0] * U, n = e[1] * U, r = Math.cos(n);
+  return [r * Math.cos(t), r * Math.sin(t), Math.sin(n)];
+}
+function Je(e) {
+  const t = Math.atan2(e[1], e[0]), n = Math.asin(e[2]);
+  return [t / U, n / U];
+}
+function A(e, t) {
+  return e[0] * t[0] + e[1] * t[1] + e[2] * t[2];
+}
+function C(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 pe(e, t) {
+  return [e[0] + t[0], e[1] + t[1], e[2] + t[2]];
+}
+function P(e, t) {
+  return [e[0] * t, e[1] * t, e[2] * t];
+}
+function x(e) {
+  return Math.sqrt(e[0] * e[0] + e[1] * e[1] + e[2] * e[2]);
+}
+function Ze(e) {
+  const t = x(e);
+  return [e[0] / t, e[1] / t, e[2] / t];
+}
+function Qe(e, t) {
+  return Math.atan2(x(C(e, t)), A(e, t));
+}
+function et(e) {
+  return C(e, Ee(e));
+}
+function Ee(e) {
+  return Ze(C([0, 0, 1], e));
+}
+function tt(e, t) {
+  const n = et(e), r = Ee(e);
+  return pe(
+    P(n, Math.cos(t)),
+    P(r, Math.sin(t))
+  );
+}
+function nt(e, t, n) {
+  const r = tt(e, t);
+  return pe(
+    P(e, Math.cos(n)),
+    P(r, Math.sin(n))
+  );
+}
+function ve(e, t, n, r, i = qe) {
+  const s = C(e, t), u = C(n, r), l = x(s), c = x(u);
+  if (l <= i || c <= i) return !1;
+  const T = p.sign(A(s, n) / l, i), y = p.sign(A(s, r) / l, i);
+  if (T * y !== -1) return !1;
+  const _ = p.sign(A(u, e) / c, i), Oe = p.sign(A(u, t) / c, i);
+  return _ * Oe === -1;
+}
+const Rt = "WGS84", N = "+proj=longlat +datum=WGS84 +no_defs", at = {
+  WGS84: N,
+  "CRS:84": N,
+  CRS84: N,
+  "urn:ogc:def:crs:OGC:1.3:CRS84": N,
+  "urn:ogc:def:crs:OGC:2:84": N,
+  "urn:ogc:def:crs:EPSG::4326": N,
+  "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(at))
+  v.defs(e) || v.defs(e, t);
+const rt = /^urn:ogc:def:crs:EPSG::(\d+)$/i;
+function Ct(e) {
+  o.that(e, a.nonEmptyString, "name must be a non empty string");
+  const t = e.match(rt);
+  return t ? `EPSG:${t[1]}` : e;
+}
+function Mt(e) {
+  o.that(e, a.nonEmptyString, "name must be a non empty string");
+  const t = e.match(/^EPSG:(\d+)$/i);
+  return t ? `urn:ogc:def:crs:EPSG::${t[1]}` : e;
+}
+function jt() {
+  return Object.keys(v.defs);
+}
+function Vt(e, t) {
+  o.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"
+    }
+  ]), v.defs(e, t);
+}
+function re(e) {
+  return o.that(e, a.nonEmptyString, "name must be a non empty string"), a.defined(v.defs(e));
+}
+function Gt(e) {
+  return o.that(e, a.nonEmptyString, "name must be a non empty string"), v.defs(e);
+}
+function Ut(e) {
+  o.that(e, a.nonEmptyString, "name must be a non empty string");
+  const t = v.defs(e);
+  if (!t) return !1;
+  const n = v.defs("EPSG:4326");
+  return t.projName === n.projName && t.datumCode === n.datumCode;
+}
+const H = {
+  precision: g(a.number),
+  consider3D: g(a.boolean)
+}, Ie = 63710088e-1;
+function Pt(e) {
+  o.that(e, (T) => a.nonEmptyString(T), "pattern must be a non-empty string");
+  const t = e.split(/[,;|]/);
+  if (t.length !== 2) return null;
+  const [n, r] = t.map(Ye);
+  if (!n || !r) return null;
+  const i = n.toDecimal(), s = r.toDecimal(), u = ae(i.degrees, i.direction), l = ae(s.degrees, s.direction), c = (T) => {
+    const { degrees: y, direction: _ } = T;
+    return _ && (k(_) || le(_)) ? -y : y;
+  };
+  return u === m.LONGITUDE && l === m.LATITUDE ? [c(i), c(s)] : l === m.LONGITUDE && u === m.LATITUDE ? [c(s), c(i)] : u === m.LONGITUDE && !l ? [c(i), c(s)] : u === m.LATITUDE && !l ? [c(s), c(i)] : l === m.LONGITUDE && !u ? [c(s), c(i)] : l === m.LATITUDE && !u ? [c(i), c(s)] : !u && !l ? [
+    [c(i), c(s)],
+    [c(s), c(i)]
+  ] : null;
+}
+function E(e) {
+  return a.arrayOfLengthBetween(e, 2, 3) ? e.every(a.number) : !1;
+}
+function it(e) {
+  return o.that(e, E, "position must be a valid position"), a.arrayOfLength(e, 3);
+}
+function be(e, t, n = {}) {
+  o.all([
+    {
+      value: e,
+      validator: E,
+      message: "position1 must be a valid position"
+    },
+    {
+      value: t,
+      validator: E,
+      message: "position2 must be a valid position"
+    },
+    {
+      value: n,
+      validator: (u) => d.schema(u, H),
+      message: "options must be a valid options object"
+    }
+  ]);
+  const { precision: r = L, consider3D: i = !1 } = n, s = i ? Math.max(e.length, t.length) : 2;
+  return Array.from(
+    { length: s },
+    (u, l) => (e[l] ?? 0).toFixed(r) === (t[l] ?? 0).toFixed(r)
+  ).every(Boolean);
+}
+function st(e, t = L) {
+  o.all([
+    {
+      value: e,
+      validator: E,
+      message: "position must be a position"
+    },
+    {
+      value: t,
+      validator: (n) => a.inRange(n, 0, b),
+      message: `precision must be in range [0, ${b}]`
+    }
+  ]);
+  for (let n = 0; n < e.length; n++)
+    e[n] = de(e[n], t);
+  return e;
+}
+function ot(e, t, n) {
+  return o.all([
+    {
+      value: e,
+      validator: E,
+      message: "position must be a valid position"
+    },
+    {
+      value: t,
+      validator: re,
+      message: `unknown source projection: ${t}`
+    },
+    {
+      value: n,
+      validator: re,
+      message: `unknown target projection: ${n}`
+    }
+  ]), v(t, n, e);
+}
+function xt(e, t, n) {
+  o.all([
+    { value: e, validator: E, 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 = nt(
+    D(e),
+    p.to.radians(t),
+    n / Ie
+  );
+  return Je(r);
+}
+function Bt(e, t) {
+  return o.all([
+    { value: e, validator: E, message: "position1 must be a valid position" },
+    { value: t, validator: E, message: "position2 must be a valid position" }
+  ]), Qe(D(e), D(t)) * Ie;
+}
+function B(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 (!E(n) || !E(r)) return !1;
+  const [, i] = n, [, s] = r;
+  return !(i > s || !t && e[2] > e[5]);
+}
+function ie(e) {
+  return o.that(e, B, "bbox must be a valid bounding-box"), a.arrayOfLength(e, 6);
+}
+function $t(e, t) {
+  return o.all([
+    { value: e, validator: B, message: "bbox1 must be a valid bounding-box" },
+    { value: t, validator: B, message: "bbox2 must be a valid bounding-box" }
+  ]), ie(e) && ie(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 ut = {
+  ignore3D: g(a.boolean)
+};
+function wt(e, t = {}) {
+  o.all([
+    {
+      value: e,
+      validator: a.nonEmptyArray,
+      message: "positions must be a non-empty array"
+    },
+    {
+      value: e,
+      validator: (i) => i.every(E),
+      message: "positions must be an array of valid positions"
+    },
+    {
+      value: t,
+      validator: (i) => d.schema(i, ut),
+      message: "options must be a valid options object"
+    }
+  ]);
+  const { ignore3D: n = !1 } = t;
+  return !n && e.some(it) ? 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 kt(e, t = L) {
+  o.all([
+    {
+      value: e,
+      validator: B,
+      message: "bbox must be a valid bounding box"
+    },
+    {
+      value: t,
+      validator: (n) => a.inRange(n, 0, b),
+      message: `precision must be in range [0, ${b}]`
+    }
+  ]);
+  for (let n = 0; n < e.length; n++)
+    e[n] = de(e[n], t);
+  return e;
+}
+const lt = {
+  ...H,
+  deduplicate: g(a.boolean)
+};
+function ct(e) {
+  return a.array(e) && e.every(E);
+}
+function mt(e, t = {}) {
+  o.that(t, (s) => d.schema(s, H), "options must be a valid options object");
+  const { precision: n = L, consider3D: r = !1 } = t, i = [];
+  for (const s of e) {
+    const u = i[i.length - 1];
+    (!u || !be(s, u, { precision: n, consider3D: r })) && i.push(s);
+  }
+  return i;
+}
+function gt(e, t = {}) {
+  o.all([
+    {
+      value: e,
+      validator: a.array,
+      message: "positions must be an array"
+    },
+    {
+      value: t,
+      validator: (u) => d.schema(u, lt),
+      message: "options must be a valid options object"
+    }
+  ]);
+  const { precision: n = L, deduplicate: r = !1, consider3D: i = !1 } = t, s = e.map((u) => st(u, n));
+  return r ? mt(s, { precision: n, consider3D: i }) : s;
+}
+function Ht(e, t, n) {
+  return o.that(e, a.array, "positions must be an array"), e.map((r) => ot(r, t, n));
+}
+function $(e, t = {}) {
+  return !a.arrayOfLengthAtLeast(e, 4) || !ct(e) ? !1 : he(e, t);
+}
+function he(e, t = {}) {
+  if (o.that(t, (i) => d.schema(i, H), "options must be a valid options object"), !a.arrayOfLengthAtLeast(e, 1)) return !1;
+  const n = e[0], r = e[e.length - 1];
+  return be(n, r, t);
+}
+function dt(e, t = {}) {
+  return !a.nonEmptyArray(e) || he(e, t) ? e : [...e, [...e[0]]];
+}
+function zt(e, t = {}) {
+  const n = gt(e, { deduplicate: !0, ...t });
+  return dt(n, t);
+}
+function ft(e) {
+  o.that(e, $, "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, u] = e[n + 1];
+    t += p.to.radians(s - r) * (2 + Math.sin(p.to.radians(i)) + Math.sin(p.to.radians(u)));
+  }
+  return -t / 2;
+}
+function Wt(e) {
+  return ft(e) < 0;
+}
+function Ft(e, t) {
+  o.all([
+    { value: e, validator: $, message: "ring1 must be a valid closed ring" },
+    { value: t, validator: $, message: "ring2 must be a valid closed ring" }
+  ]);
+  const n = e.map(D), r = t.map(D);
+  for (let i = 0; i < n.length - 1; i++)
+    for (let s = 0; s < r.length - 1; s++)
+      if (ve(n[i], n[i + 1], r[s], r[s + 1]))
+        return !0;
+  return !1;
+}
+function Yt(e) {
+  o.that(e, $, "ring must be a valid closed ring");
+  const t = e.map(D), 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 || ve(t[i], t[i + 1], t[s], t[s + 1]) && n.push([i, s]));
+  return n;
+}
+export {
+  $t as $,
+  m as A,
+  Et as B,
+  F as C,
+  L as D,
+  Ie as E,
+  Wt as F,
+  he as G,
+  Z as H,
+  H as I,
+  G as J,
+  q as K,
+  Re as L,
+  b as M,
+  be as N,
+  le as O,
+  oe as P,
+  B as Q,
+  h as R,
+  E as S,
+  lt as T,
+  ct as U,
+  $ as V,
+  Rt as W,
+  Ut as X,
+  k as Y,
+  vt as Z,
+  jt as _,
+  We as a,
+  Tt as a0,
+  Ct as a1,
+  Ye as a2,
+  Pt as a3,
+  bt as a4,
+  ot as a5,
+  Ht as a6,
+  Yt as a7,
+  Ft as a8,
+  It as a9,
+  ft as aa,
+  kt as ab,
+  de as ac,
+  st as ad,
+  gt as ae,
+  zt as af,
+  a as ag,
+  o as ah,
+  At as ai,
+  g as aj,
+  d as ak,
+  _t as al,
+  ye as am,
+  Fe as b,
+  dt as c,
+  wt as d,
+  yt as e,
+  mt as f,
+  Vt as g,
+  Mt as h,
+  xt as i,
+  Bt as j,
+  ue as k,
+  Lt as l,
+  Ce as m,
+  j as n,
+  ht as o,
+  St as p,
+  Ae as q,
+  J as r,
+  Ot as s,
+  Gt as t,
+  Nt as u,
+  Dt as v,
+  ae as w,
+  re as x,
+  ie as y,
+  it as z
+};
+//# sourceMappingURL=ring-Cks2pGr8.js.map