@kalisio/common-geospatial 0.2.0 → 0.3.0

package/dist/index.mjs

@@ -1,369 +1,369 @@
-import { assert as l, is as i, has as M, conform as T, optional as C } from "@kalisio/common-core";
-const d = {
+import { assert as p, is as f, has as ie, conform as P, optional as ae } from "@kalisio/common-core";
+const w = {
   LATITUDE: "LAT",
   LONGITUDE: "LON",
   ALTITUDE: "ALT"
 };
-function Z(e) {
-  return l.that(e, i.string, "axis must be a string"), Object.values(d).includes(e);
+function je(t) {
+  return p.that(t, f.string, "axis must be a string"), Object.values(w).includes(t);
 }
-function R(e) {
-  return l.that(e, i.string, "axis must be a string"), e === d.LATITUDE;
+function ee(t) {
+  return p.that(t, f.string, "axis must be a string"), t === w.LATITUDE;
 }
-function W(e) {
-  return l.that(e, i.string, "axis must be a string"), e === d.LONGITUDE;
+function Se(t) {
+  return p.that(t, f.string, "axis must be a string"), t === w.LONGITUDE;
 }
-function We(e) {
-  return l.that(e, i.string, "axis must be a string"), e === d.ALTITUDE;
+function tr(t) {
+  return p.that(t, f.string, "axis must be a string"), t === w.ALTITUDE;
 }
-const J = { NORTH: { label: "Nord", symbol: "N" }, SOUTH: { label: "Sud", symbol: "S" }, EAST: { label: "Est", symbol: "E" }, WEST: { label: "Ouest", symbol: "O" } }, ee = {
-  DIRECTIONS: J
-}, te = { NORTH: { label: "North", symbol: "N" }, SOUTH: { label: "South", symbol: "S" }, EAST: { label: "East", symbol: "E" }, WEST: { label: "West", symbol: "W" } }, ne = {
-  DIRECTIONS: te
-}, re = {
+const We = { NORTH: { label: "Nord", symbol: "N" }, SOUTH: { label: "Sud", symbol: "S" }, EAST: { label: "Est", symbol: "E" }, WEST: { label: "Ouest", symbol: "O" } }, Ve = {
+  DIRECTIONS: We
+}, Be = { NORTH: { label: "North", symbol: "N" }, SOUTH: { label: "South", symbol: "S" }, EAST: { label: "East", symbol: "E" }, WEST: { label: "West", symbol: "W" } }, Ke = {
+  DIRECTIONS: Be
+}, Ze = {
   DIRECTIONS: {
-    NORTH: { label: i.string, symbol: i.string },
-    SOUTH: { label: i.string, symbol: i.string },
-    EAST: { label: i.string, symbol: i.string },
-    WEST: { label: i.string, symbol: i.string }
-  }
-}, O = {
-  en: ne,
-  fr: ee
+    NORTH: { label: f.string, symbol: f.string },
+    SOUTH: { label: f.string, symbol: f.string },
+    EAST: { label: f.string, symbol: f.string },
+    WEST: { label: f.string, symbol: f.string }
+  }
+}, k = {
+  en: Ke,
+  fr: Ve
 };
-let w = "en";
-function Be() {
-  return Object.keys(O);
-}
-function je(e, t) {
-  l.all([
-    { value: e, validator: i.string, message: "code must be a string" },
-    { value: e, validator: (n) => !M.key(O, n), message: "locale already registered" },
-    { value: t, validator: i.plainObject, message: "content must be an object" },
-    { value: t, validator: (n) => T.schema(n, re), message: "content does not conform to schema" }
-  ]), O[e] = t;
-}
-function Ke(e) {
-  l.all([
-    { value: e, validator: i.string, message: "code must be a string" },
-    { value: e, validator: (t) => M.key(O, t), message: "code is unknown" }
-  ]), w = e;
-}
-function ie() {
+let te = "en";
+function rr() {
+  return Object.keys(k);
+}
+function nr(t, e) {
+  p.all([
+    { value: t, validator: f.string, message: "code must be a string" },
+    { value: t, validator: (r) => !ie.key(k, r), message: "locale already registered" },
+    { value: e, validator: f.plainObject, message: "content must be an object" },
+    { value: e, validator: (r) => P.schema(r, Ze), message: "content does not conform to schema" }
+  ]), k[t] = e;
+}
+function ir(t) {
+  p.all([
+    { value: t, validator: f.string, message: "code must be a string" },
+    { value: t, validator: (e) => ie.key(k, e), message: "code is unknown" }
+  ]), te = t;
+}
+function Ye() {
   return {
-    code: w,
-    content: O[w]
+    code: te,
+    content: k[te]
   };
 }
-function y() {
-  return ie().content.DIRECTIONS;
+function R() {
+  return Ye().content.DIRECTIONS;
 }
-function S(e, t) {
-  const n = y(), r = n[e].label.toUpperCase(), s = n[e].symbol.toUpperCase();
-  return t.toUpperCase() === r || t.toUpperCase() === s;
+function W(t, e) {
+  const r = R(), n = r[t].label.toUpperCase(), i = r[t].symbol.toUpperCase();
+  return e.toUpperCase() === n || e.toUpperCase() === i;
 }
-function Ye(e = null) {
-  const t = y();
-  return i.defined(e) ? (l.that(e, Z, "axis must be a valid axis"), R(e) ? [t.SOUTH, t.NORTH] : W(e) ? [t.EAST, t.WEST] : []) : [t.SOUTH, t.NORTH, t.EAST, t.WEST];
+function ar(t = null) {
+  const e = R();
+  return f.defined(t) ? (p.that(t, je, "axis must be a valid axis"), ee(t) ? [e.SOUTH, e.NORTH] : Se(t) ? [e.EAST, e.WEST] : []) : [e.SOUTH, e.NORTH, e.EAST, e.WEST];
 }
-function qe() {
-  return y().NORTH;
+function sr() {
+  return R().NORTH;
 }
-function ze() {
-  return y().SOUTH;
+function or() {
+  return R().SOUTH;
 }
-function Qe() {
-  return y().EAST;
+function lr() {
+  return R().EAST;
 }
-function Xe() {
-  return y().WEST;
+function ur() {
+  return R().WEST;
 }
-function v(e) {
-  return l.that(e, i.string, "dir must be a string"), se(e) || B(e) || j(e) || $(e);
+function D(t) {
+  return p.that(t, f.string, "dir must be a string"), Je(t) || Le(t) || Te(t) || se(t);
 }
-function se(e) {
-  return l.that(e, i.string, "dir must be a string"), S("NORTH", e);
+function Je(t) {
+  return p.that(t, f.string, "dir must be a string"), W("NORTH", t);
 }
-function B(e) {
-  return l.that(e, i.string, "dir must be a string"), S("SOUTH", e);
+function Le(t) {
+  return p.that(t, f.string, "dir must be a string"), W("SOUTH", t);
 }
-function j(e) {
-  return l.that(e, i.string, "dir must be a string"), S("EAST", e);
+function Te(t) {
+  return p.that(t, f.string, "dir must be a string"), W("EAST", t);
 }
-function $(e) {
-  return l.that(e, i.string, "dir must be a string"), S("WEST", e);
+function se(t) {
+  return p.that(t, f.string, "dir must be a string"), W("WEST", t);
 }
-function ae(e) {
-  return l.that(e, v, "dir must be a direction"), $(e) || j(e) ? d.LONGITUDE : d.LATITUDE;
+function Qe(t) {
+  return p.that(t, D, "dir must be a direction"), se(t) || Te(t) ? w.LONGITUDE : w.LATITUDE;
 }
-const oe = {
-  degrees: i.number,
-  direction: C(v)
-}, ue = /^(-?\d{1,3}(?:\.\d+)?)°?$/, le = /^(\d{1,3}(?:\.\d+)?)°?([NSEW])$/;
-function L(e) {
-  let t = null, n = null;
-  if (i.plainObject(e) && T.schema(e, oe))
-    i.defined(e.direction) ? e.degrees >= 0 && (t = e.degrees, n = e.direction) : t = e.degrees;
-  else if (i.string(e)) {
-    const r = e.replace(/\s+/g, ""), s = r.match(ue) ?? r.match(le);
-    s && (t = parseFloat(s[1]), n = s[2] ?? null);
+const Xe = {
+  degrees: f.number,
+  direction: ae(D)
+}, et = /^(-?\d{1,3}(?:\.\d+)?)°?$/, tt = /^(\d{1,3}(?:\.\d+)?)°?([NSEW])$/;
+function U(t) {
+  let e = null, r = null;
+  if (f.plainObject(t) && P.schema(t, Xe))
+    f.defined(t.direction) ? t.degrees >= 0 && (e = t.degrees, r = t.direction) : e = t.degrees;
+  else if (f.string(t)) {
+    const n = t.replace(/\s+/g, ""), i = n.match(et) ?? n.match(tt);
+    i && (e = parseFloat(i[1]), r = i[2] ?? null);
   }
   return {
     get degrees() {
-      return t;
+      return e;
     },
     get direction() {
-      return n;
+      return r;
     },
     get format() {
       return "DD";
     },
     isValid() {
-      return i.number(t);
+      return f.number(e);
     },
-    toString(r) {
-      if (l.that(r, i.positiveInteger, "decimalPlaces must be a positive integer"), !this.isValid()) return "";
-      let s = `${t.toFixed(r)}°`;
-      return n && (s += ` ${n}`), s;
+    toString(n) {
+      if (p.that(n, f.positiveInteger, "decimalPlaces must be a positive integer"), !this.isValid()) return "";
+      let i = `${e.toFixed(n)}°`;
+      return r && (i += ` ${r}`), i;
     },
     toDecimal() {
-      return this.isValid() ? L({ degrees: t, direction: n }) : null;
+      return this.isValid() ? U({ degrees: e, direction: r }) : null;
     }
   };
 }
-const ce = {
-  degrees: i.integer,
-  minutes: (e) => i.inRangeExclusiveMax(e, 0, 60),
-  direction: C(v)
-}, ge = /^(-?\d{1,3})°(\d{1,2}(?:\.\d+)?)'?$/, fe = /^(\d{1,3})°(\d{1,2}(?:\.\d+)?)'?([NSEW])$/;
-function K(e) {
-  let t = null, n = null, r = null;
-  if (i.plainObject(e) && T.schema(e, ce))
-    i.defined(e.direction) ? e.degrees >= 0 && (t = e.degrees, n = e.minutes, r = e.direction) : (t = e.degrees, n = e.minutes);
-  else if (i.string(e)) {
-    const s = e.replace(/\s+/g, ""), a = s.match(ge) ?? s.match(fe);
-    a && (t = parseFloat(a[1]), n = parseFloat(a[2]), r = a[3] ?? null);
+const rt = {
+  degrees: f.integer,
+  minutes: (t) => f.inRangeExclusiveMax(t, 0, 60),
+  direction: ae(D)
+}, nt = /^(-?\d{1,3})°(\d{1,2}(?:\.\d+)?)'?$/, it = /^(\d{1,3})°(\d{1,2}(?:\.\d+)?)'?([NSEW])$/;
+function Ce(t) {
+  let e = null, r = null, n = null;
+  if (f.plainObject(t) && P.schema(t, rt))
+    f.defined(t.direction) ? t.degrees >= 0 && (e = t.degrees, r = t.minutes, n = t.direction) : (e = t.degrees, r = t.minutes);
+  else if (f.string(t)) {
+    const i = t.replace(/\s+/g, ""), a = i.match(nt) ?? i.match(it);
+    a && (e = parseFloat(a[1]), r = parseFloat(a[2]), n = a[3] ?? null);
   }
   return {
     get degrees() {
-      return t;
+      return e;
     },
     get minutes() {
-      return n;
+      return r;
     },
     get direction() {
-      return r;
+      return n;
     },
     get format() {
       return "DDM";
     },
     isValid() {
-      return i.integer(t) && i.inRangeExclusiveMax(n, 0, 60);
+      return f.integer(e) && f.inRangeExclusiveMax(r, 0, 60);
     },
-    toString(s) {
-      if (l.that(s, i.positiveInteger, "decimalPlaces must be a positive integer"), !this.isValid()) return "";
-      let a = `${t}° ${n.toFixed(s)}'`;
-      return r && (a += ` ${r}`), a;
+    toString(i) {
+      if (p.that(i, f.positiveInteger, "decimalPlaces must be a positive integer"), !this.isValid()) return "";
+      let a = `${e}° ${r.toFixed(i)}'`;
+      return n && (a += ` ${n}`), a;
     },
     toDecimal() {
-      return this.isValid() ? L({ degrees: t + n / 60, direction: r }) : null;
+      return this.isValid() ? U({ degrees: e + r / 60, direction: n }) : null;
     }
   };
 }
-const me = {
-  degrees: i.nonNegativeInteger,
-  minutes: (e) => i.inRangeExclusiveMax(e, 0, 60),
-  direction: v
-}, de = /^(\d{2})(\d{3})([NS])$/, Ee = /^(\d{3})(\d{3})([EW])$/;
-function Y(e) {
-  let t = null, n = null, r = null;
-  if (i.plainObject(e) && T.schema(e, me))
-    t = e.degrees, n = e.minutes, r = e.direction;
-  else if (i.string(e)) {
-    const s = e.trim(), a = s.match(de) ?? s.match(Ee);
-    a && (t = parseFloat(a[1]), n = parseFloat(a[2]) / 10, r = a[3]);
+const at = {
+  degrees: f.nonNegativeInteger,
+  minutes: (t) => f.inRangeExclusiveMax(t, 0, 60),
+  direction: D
+}, st = /^(\d{2})(\d{3})([NS])$/, ot = /^(\d{3})(\d{3})([EW])$/;
+function Ie(t) {
+  let e = null, r = null, n = null;
+  if (f.plainObject(t) && P.schema(t, at))
+    e = t.degrees, r = t.minutes, n = t.direction;
+  else if (f.string(t)) {
+    const i = t.trim(), a = i.match(st) ?? i.match(ot);
+    a && (e = parseFloat(a[1]), r = parseFloat(a[2]) / 10, n = a[3]);
   }
   return {
     get degrees() {
-      return t;
+      return e;
     },
     get minutes() {
-      return n;
+      return r;
     },
     get direction() {
-      return r;
+      return n;
     },
     get format() {
       return "DDM_AERO";
     },
     isValid() {
-      return i.nonNegativeInteger(t) && i.inRangeExclusiveMax(n, 0, 60) && v(r);
+      return f.nonNegativeInteger(e) && f.inRangeExclusiveMax(r, 0, 60) && D(n);
     },
     toString() {
       if (!this.isValid()) return "";
-      const s = r === "E" || r === "W", a = String(t).padStart(s ? 3 : 2, "0"), o = Math.floor(n * 10).toString().padStart(3, "0");
-      return `${a}${o}${r}`;
+      const i = n === "E" || n === "W", a = String(e).padStart(i ? 3 : 2, "0"), s = Math.floor(r * 10).toString().padStart(3, "0");
+      return `${a}${s}${n}`;
     },
     toDecimal() {
-      return this.isValid() ? L({ degrees: t + n / 60, direction: r }) : null;
+      return this.isValid() ? U({ degrees: e + r / 60, direction: n }) : null;
     }
   };
 }
-const pe = {
-  degrees: i.integer,
-  minutes: (e) => i.integer(e) && i.inRange(e, 0, 59),
-  seconds: (e) => i.inRangeExclusiveMax(e, 0, 60),
-  direction: C(v)
-}, ve = /^(-?\d{1,3})°(\d{1,2})'(\d{1,2}(?:\.\d+)?)"?$/, he = /^(\d{1,3})°(\d{1,2})'(\d{1,2}(?:\.\d+)?)"?([NSEW])$/;
-function q(e) {
-  let t = null, n = null, r = null, s = null;
-  if (i.plainObject(e) && T.schema(e, pe))
-    i.defined(e.direction) ? e.degrees >= 0 && (t = e.degrees, n = e.minutes, r = e.seconds, s = e.direction) : (t = e.degrees, n = e.minutes, r = e.seconds);
-  else if (i.string(e)) {
-    const a = e.replace(/\s+/g, ""), o = a.match(ve) ?? a.match(he);
-    o && (t = parseFloat(o[1]), n = parseFloat(o[2]), r = parseFloat(o[3]), s = o[4] ?? null);
+const lt = {
+  degrees: f.integer,
+  minutes: (t) => f.integer(t) && f.inRange(t, 0, 59),
+  seconds: (t) => f.inRangeExclusiveMax(t, 0, 60),
+  direction: ae(D)
+}, ut = /^(-?\d{1,3})°(\d{1,2})'(\d{1,2}(?:\.\d+)?)"?$/, ft = /^(\d{1,3})°(\d{1,2})'(\d{1,2}(?:\.\d+)?)"?([NSEW])$/;
+function Ne(t) {
+  let e = null, r = null, n = null, i = null;
+  if (f.plainObject(t) && P.schema(t, lt))
+    f.defined(t.direction) ? t.degrees >= 0 && (e = t.degrees, r = t.minutes, n = t.seconds, i = t.direction) : (e = t.degrees, r = t.minutes, n = t.seconds);
+  else if (f.string(t)) {
+    const a = t.replace(/\s+/g, ""), s = a.match(ut) ?? a.match(ft);
+    s && (e = parseFloat(s[1]), r = parseFloat(s[2]), n = parseFloat(s[3]), i = s[4] ?? null);
   }
   return {
     get degrees() {
-      return t;
+      return e;
     },
     get minutes() {
-      return n;
+      return r;
     },
     get seconds() {
-      return r;
+      return n;
     },
     get direction() {
-      return s;
+      return i;
     },
     get format() {
       return "DMS";
     },
     isValid() {
-      return i.integer(t) && i.integer(n) && i.inRange(n, 0, 59) && i.inRangeExclusiveMax(r, 0, 60);
+      return f.integer(e) && f.integer(r) && f.inRange(r, 0, 59) && f.inRangeExclusiveMax(n, 0, 60);
     },
     toString(a) {
-      if (l.that(a, i.positiveInteger, "decimalPlaces must be a positive integer"), !this.isValid()) return "";
-      let o = `${t}° ${n}' ${r.toFixed(a)}"`;
-      return s && (o += ` ${s}`), o;
+      if (p.that(a, f.positiveInteger, "decimalPlaces must be a positive integer"), !this.isValid()) return "";
+      let s = `${e}° ${r}' ${n.toFixed(a)}"`;
+      return i && (s += ` ${i}`), s;
     },
     toDecimal() {
-      return this.isValid() ? L({ degrees: t + n / 60 + r / 3600, direction: s }) : null;
+      return this.isValid() ? U({ degrees: e + r / 60 + n / 3600, direction: i }) : null;
     }
   };
 }
-function F(e) {
-  const t = Math.floor(e.degrees), n = (e.degrees - t) * 60;
-  return { degrees: t, minutes: n, direction: e.direction };
+function pe(t) {
+  const e = Math.floor(t.degrees), r = (t.degrees - e) * 60;
+  return { degrees: e, minutes: r, direction: t.direction };
 }
-function ye(e) {
-  const t = Math.floor(e.degrees), n = (e.degrees - t) * 60, r = Math.floor(n), s = (n - r) * 60;
-  return { degrees: t, minutes: r, seconds: s, direction: e.direction };
+function ct(t) {
+  const e = Math.floor(t.degrees), r = (t.degrees - e) * 60, n = Math.floor(r), i = (r - n) * 60;
+  return { degrees: e, minutes: n, seconds: i, direction: t.direction };
 }
-const k = {
-  DD: (e) => (l.that(e, (t) => t.isValid(), "dd must be a valid coordinate"), e),
-  DDM: (e) => {
-    l.that(e, (s) => s.isValid(), "dd must be a valid coordinate");
-    const { degrees: t, minutes: n, direction: r } = F(e);
-    return K(r ? { degrees: t, minutes: n, direction: r } : { degrees: t, minutes: n });
+const ge = {
+  DD: (t) => (p.that(t, (e) => e.isValid(), "dd must be a valid coordinate"), t),
+  DDM: (t) => {
+    p.that(t, (i) => i.isValid(), "dd must be a valid coordinate");
+    const { degrees: e, minutes: r, direction: n } = pe(t);
+    return Ce(n ? { degrees: e, minutes: r, direction: n } : { degrees: e, minutes: r });
   },
-  DMS: (e) => {
-    l.that(e, (a) => a.isValid(), "dd must be a valid coordinate");
-    const { degrees: t, minutes: n, seconds: r, direction: s } = ye(e);
-    return q(s ? { degrees: t, minutes: n, seconds: r, direction: s } : { degrees: t, minutes: n, seconds: r });
+  DMS: (t) => {
+    p.that(t, (a) => a.isValid(), "dd must be a valid coordinate");
+    const { degrees: e, minutes: r, seconds: n, direction: i } = ct(t);
+    return Ne(i ? { degrees: e, minutes: r, seconds: n, direction: i } : { degrees: e, minutes: r, seconds: n });
   },
-  DDM_AERO: (e) => {
-    l.that(e, (s) => s.isValid(), "dd must be a valid coordinate");
-    const { degrees: t, minutes: n, direction: r } = F(e);
-    return Y({ degrees: t, minutes: n, direction: r });
+  DDM_AERO: (t) => {
+    p.that(t, (i) => i.isValid(), "dd must be a valid coordinate");
+    const { degrees: e, minutes: r, direction: n } = pe(t);
+    return Ie({ degrees: e, minutes: r, direction: n });
   }
-}, N = {
+}, re = {
   DD: "DD",
   DDM: "DDM",
   DDM_AERO: "DDM_AERO",
   DMS: "DMS"
-}, be = {
-  DD: L,
-  DDM: K,
-  DDM_AERO: Y,
-  DMS: q
-}, _ = Array.from({ length: 9 }, (e, t) => 10 ** t);
-function P(e, t) {
-  if (l.that(e, i.number, "coord must be a number"), i.defined(t))
-    return l.that(t, v, "dir must be a direction"), ae(t);
-  if (Math.abs(e) > 90) return d.LONGITUDE;
-}
-function H(e) {
-  l.that(e, i.number, "coord must be a number");
-  const t = e.toExponential(), [n, r] = t.split("e").map(Number), s = (n.toString().split(".")[1] || "").length;
-  return Math.max(0, s - r);
-}
-function Ze(e, t = 7) {
-  l.all([
-    { value: e, validator: i.number, message: "coord must be a number" },
-    { value: t, validator: (r) => i.inRange(r, 0, 8), message: "precision must be in range [0, 8]" }
+}, ht = {
+  DD: U,
+  DDM: Ce,
+  DDM_AERO: Ie,
+  DMS: Ne
+}, oe = Array.from({ length: 9 }, (t, e) => 10 ** e);
+function ye(t, e) {
+  if (p.that(t, f.number, "coord must be a number"), f.defined(e))
+    return p.that(e, D, "dir must be a direction"), Qe(e);
+  if (Math.abs(t) > 90) return w.LONGITUDE;
+}
+function de(t) {
+  p.that(t, f.number, "coord must be a number");
+  const e = t.toExponential(), [r, n] = e.split("e").map(Number), i = (r.toString().split(".")[1] || "").length;
+  return Math.max(0, i - n);
+}
+function fr(t, e = 7) {
+  p.all([
+    { value: t, validator: f.number, message: "coord must be a number" },
+    { value: e, validator: (n) => f.inRange(n, 0, 8), message: "precision must be in range [0, 8]" }
   ]);
-  const n = _[t];
-  return Math.round(e * n) / n;
-}
-function Je(e, t) {
-  if (l.all([
-    { value: e, validator: i.number, message: "coord must be a number" },
-    { value: t, validator: (r) => W(r) || R(r), message: "axis must be either a longitude or latitude" }
-  ]), R(t))
-    return Math.max(-90, Math.min(90, e));
-  let n = ((e + 180) % 360 + 360) % 360 - 180;
-  return n === -180 && (n = 180), Object.is(n, -0) && (n = 0), n;
-}
-function et(e, t) {
-  l.all([
-    { value: e, validator: (r) => i.defined(r) && r.isValid(), message: "from must be a valid coordinate" },
-    { value: t, validator: (r) => M.key(k, r), message: `unknown format: ${t}` }
+  const r = oe[e];
+  return Math.round(t * r) / r;
+}
+function cr(t, e) {
+  if (p.all([
+    { value: t, validator: f.number, message: "coord must be a number" },
+    { value: e, validator: (n) => Se(n) || ee(n), message: "axis must be either a longitude or latitude" }
+  ]), ee(e))
+    return Math.max(-90, Math.min(90, t));
+  let r = ((t + 180) % 360 + 360) % 360 - 180;
+  return r === -180 && (r = 180), Object.is(r, -0) && (r = 0), r;
+}
+function hr(t, e) {
+  p.all([
+    { value: t, validator: (n) => f.defined(n) && n.isValid(), message: "from must be a valid coordinate" },
+    { value: e, validator: (n) => ie.key(ge, n), message: `unknown format: ${e}` }
   ]);
-  const n = e.format === N.DD ? e : e.toDecimal();
-  return n.isValid() ? t === N.DD ? n : k[t](n) : null;
-}
-function Oe(e) {
-  l.that(e, i.nonEmptyString, "pattern must be a non empty string");
-  for (const t of Object.keys(N)) {
-    const n = be[t](e);
-    if (n.isValid()) return n;
+  const r = t.format === re.DD ? t : t.toDecimal();
+  return r.isValid() ? e === re.DD ? r : ge[e](r) : null;
+}
+function pt(t) {
+  p.that(t, f.nonEmptyString, "pattern must be a non empty string");
+  for (const e of Object.keys(re)) {
+    const r = ht[e](t);
+    if (r.isValid()) return r;
   }
   return null;
 }
-function tt(e) {
-  l.that(e, (f) => i.nonEmptyString(f), "pattern must be a non-empty string");
-  const t = e.split(/[,;|]/);
-  if (t.length !== 2) return null;
-  const [n, r] = t.map(Oe);
-  if (!n || !r) return null;
-  const s = n.toDecimal(), a = r.toDecimal(), o = P(s.degrees, s.direction), u = P(a.degrees, a.direction), c = (f) => {
-    const { degrees: m, direction: g } = f;
-    return g && ($(g) || B(g)) ? -m : m;
+function pr(t) {
+  p.that(t, (o) => f.nonEmptyString(o), "pattern must be a non-empty string");
+  const e = t.split(/[,;|]/);
+  if (e.length !== 2) return null;
+  const [r, n] = e.map(pt);
+  if (!r || !n) return null;
+  const i = r.toDecimal(), a = n.toDecimal(), s = ye(i.degrees, i.direction), l = ye(a.degrees, a.direction), u = (o) => {
+    const { degrees: c, direction: h } = o;
+    return h && (se(h) || Le(h)) ? -c : c;
   };
-  if (o === d.LONGITUDE && u === d.LATITUDE) return [c(s), c(a)];
-  if (u === d.LONGITUDE && o === d.LATITUDE) return [c(a), c(s)];
-  if (o === d.LONGITUDE && !u) return [c(s), a];
-  if (o === d.LATITUDE && !u) return [c(a), c(s)];
-  if (u === d.LONGITUDE && !o) return [c(a), c(s)];
-  if (u === d.LATITUDE && !o) return [c(s), c(a)];
-  if (!o && !u)
+  if (s === w.LONGITUDE && l === w.LATITUDE) return [u(i), u(a)];
+  if (l === w.LONGITUDE && s === w.LATITUDE) return [u(a), u(i)];
+  if (s === w.LONGITUDE && !l) return [u(i), a];
+  if (s === w.LATITUDE && !l) return [u(a), u(i)];
+  if (l === w.LONGITUDE && !s) return [u(a), u(i)];
+  if (l === w.LATITUDE && !s) return [u(i), u(a)];
+  if (!s && !l)
     return [
-      [c(s), c(a)],
-      [c(a), c(s)]
+      [u(i), u(a)],
+      [u(a), u(i)]
     ];
 }
-function Te(e) {
-  return !i.arrayOfLength(e, 4) && !i.arrayOfLength(e, 6) ? !1 : e.every(i.number);
+function gt(t) {
+  return !f.arrayOfLength(t, 4) && !f.arrayOfLength(t, 6) ? !1 : t.every(f.number);
 }
-const D = {
+const z = {
   NAME: "name",
   LINK: "link"
 };
-function nt(e) {
-  return i.plainObject(e) ? e.type === D.NAME ? i.nonEmptyString(e.properties?.name) : e.type === D.LINK ? i.nonEmptyString(e.properties?.href) : !1 : !1;
+function gr(t) {
+  return f.plainObject(t) ? t.type === z.NAME ? f.nonEmptyString(t.properties?.name) : t.type === z.LINK ? f.nonEmptyString(t.properties?.href) : !1 : !1;
 }
-const p = {
+const v = {
   POINT: "Point",
   MULTI_POINT: "MultiPoint",
   LINESTRING: "LineString",
@@ -372,122 +372,1910 @@ const p = {
   MULTI_POLYGON: "MultiPolygon",
   GEOMETRY_COLLECTION: "GeometryCollection"
 };
-function Le(e) {
-  return !i.plainObject(e) || !i.oneOf(e.type, Object.values(p)) ? !1 : e.type === p.GEOMETRY_COLLECTION ? i.array(e.geometries) : i.array(e.coordinates);
+function le(t) {
+  return !f.plainObject(t) || !f.oneOf(t.type, Object.values(v)) ? !1 : t.type === v.GEOMETRY_COLLECTION ? f.array(t.geometries) : f.array(t.coordinates);
 }
-const h = {
+const I = {
   FEATURE: "Feature",
   FEATURE_COLLECTION: "FeatureCollection"
 };
-function De(e) {
-  return i.plainObject(e) ? h.FEATURE === e.type : !1;
+function yt(t) {
+  return f.plainObject(t) ? I.FEATURE === t.type : !1;
+}
+function dt(t) {
+  return !f.plainObject(t) || t.type !== I.FEATURE_COLLECTION ? !1 : f.array(t.features);
+}
+function De(t) {
+  return f.plainObject(t) ? le(t) || yt(t) ? !0 : dt(t) : !1;
+}
+function mt(t) {
+  return f.arrayOfLengthBetween(t, 2, 3) ? t.every(f.number) : !1;
 }
-function Ie(e) {
-  return !i.plainObject(e) || e.type !== h.FEATURE_COLLECTION ? !1 : i.array(e.features);
+const vt = {}, H = bt(globalThis, vt);
+function bt(t, e) {
+  return new Proxy(t, {
+    get(r, n, i) {
+      return n in e ? e[n] : t[n];
+    },
+    set(r, n, i) {
+      return n in e && delete e[n], t[n] = i, !0;
+    },
+    deleteProperty(r, n) {
+      let i = !1;
+      return n in e && (delete e[n], i = !0), n in t && (delete t[n], i = !0), i;
+    },
+    ownKeys(r) {
+      const n = Reflect.ownKeys(t), i = Reflect.ownKeys(e), a = new Set(i);
+      return [...n.filter((s) => !a.has(s)), ...i];
+    },
+    defineProperty(r, n, i) {
+      return n in e && delete e[n], Reflect.defineProperty(t, n, i), !0;
+    },
+    getOwnPropertyDescriptor(r, n) {
+      return n in e ? Reflect.getOwnPropertyDescriptor(e, n) : Reflect.getOwnPropertyDescriptor(t, n);
+    },
+    has(r, n) {
+      return n in e || n in t;
+    }
+  });
 }
-function rt(e) {
-  return i.plainObject(e) ? Le(e) || De(e) ? !0 : Ie(e) : !1;
+function xe(t = []) {
+  return C.getLogger(t);
 }
-function Se(e) {
-  return i.arrayOfLengthBetween(e, 2, 3) ? e.every(i.number) : !1;
+const B = /* @__PURE__ */ Symbol.for("logtape.rootLogger");
+class C {
+  static getLogger(e = []) {
+    let r = B in H ? H[B] ?? null : null;
+    return r == null && (r = new C(null, []), H[B] = r), typeof e == "string" ? r.getChild(e) : e.length === 0 ? r : r.getChild(e);
+  }
+  constructor(e, r) {
+    Object.defineProperty(this, "parent", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "children", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "category", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "sinks", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "parentSinks", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "inherit"
+    }), Object.defineProperty(this, "filters", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "contextLocalStorage", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), this.parent = e, this.children = {}, this.category = r, this.sinks = [], this.filters = [];
+  }
+  getChild(e) {
+    const r = typeof e == "string" ? e : e[0], n = this.children[r];
+    let i = n instanceof C ? n : n?.deref();
+    return i == null && (i = new C(this, [...this.category, r]), this.children[r] = "WeakRef" in H ? new WeakRef(i) : i), typeof e == "string" || e.length === 1 ? i : i.getChild(e.slice(1));
+  }
+  /**
+   * Reset the logger.  This removes all sinks and filters from the logger.
+   */
+  reset() {
+    for (; this.sinks.length > 0; )
+      this.sinks.shift();
+    for (this.parentSinks = "inherit"; this.filters.length > 0; )
+      this.filters.shift();
+  }
+  /**
+   * Reset the logger and all its descendants.  This removes all sinks and
+   * filters from the logger and all its descendants.
+   */
+  resetDescendants() {
+    for (const e of Object.values(this.children)) {
+      const r = e instanceof C ? e : e.deref();
+      r?.resetDescendants();
+    }
+    this.reset();
+  }
+  with(e) {
+    return new ue(this, { ...e });
+  }
+  filter(e) {
+    for (const r of this.filters)
+      if (!r(e))
+        return !1;
+    return this.filters.length < 1 ? this.parent?.filter(e) ?? !0 : !0;
+  }
+  *getSinks() {
+    if (this.parent != null && this.parentSinks === "inherit")
+      for (const e of this.parent.getSinks())
+        yield e;
+    for (const e of this.sinks)
+      yield e;
+  }
+  emit(e, r) {
+    if (this.filter(e)) {
+      for (const n of this.getSinks())
+        if (!r?.has(n))
+          try {
+            n(e);
+          } catch (i) {
+            const a = new Set(r);
+            a.add(n), At.log("fatal", "Failed to emit a log record to sink {sink}: {error}", { sink: n, error: i, record: e }, a);
+          }
+    }
+  }
+  log(e, r, n, i) {
+    const a = C.getLogger().contextLocalStorage?.getStore() ?? {};
+    let s;
+    const l = typeof n == "function" ? {
+      category: this.category,
+      level: e,
+      timestamp: Date.now(),
+      get message() {
+        return me(r, this.properties);
+      },
+      rawMessage: r,
+      get properties() {
+        return s == null && (s = {
+          ...a,
+          ...n()
+        }), s;
+      }
+    } : {
+      category: this.category,
+      level: e,
+      timestamp: Date.now(),
+      message: me(r, {
+        ...a,
+        ...n
+      }),
+      rawMessage: r,
+      properties: { ...a, ...n }
+    };
+    this.emit(l, i);
+  }
+  logLazily(e, r, n = {}) {
+    const i = C.getLogger().contextLocalStorage?.getStore() ?? {};
+    let a, s;
+    function l() {
+      if ((s == null || a == null) && (s = r((u, ...o) => (a = u, ve(u, o))), a == null))
+        throw new TypeError("No log record was made.");
+      return [s, a];
+    }
+    this.emit({
+      category: this.category,
+      level: e,
+      get message() {
+        return l()[0];
+      },
+      get rawMessage() {
+        return l()[1];
+      },
+      timestamp: Date.now(),
+      properties: { ...i, ...n }
+    });
+  }
+  logTemplate(e, r, n, i = {}) {
+    const a = C.getLogger().contextLocalStorage?.getStore() ?? {};
+    this.emit({
+      category: this.category,
+      level: e,
+      message: ve(r, n),
+      rawMessage: r,
+      timestamp: Date.now(),
+      properties: { ...a, ...i }
+    });
+  }
+  debug(e, ...r) {
+    typeof e == "string" ? this.log("debug", e, r[0] ?? {}) : typeof e == "function" ? this.logLazily("debug", e) : this.logTemplate("debug", e, r);
+  }
+  info(e, ...r) {
+    typeof e == "string" ? this.log("info", e, r[0] ?? {}) : typeof e == "function" ? this.logLazily("info", e) : this.logTemplate("info", e, r);
+  }
+  warn(e, ...r) {
+    typeof e == "string" ? this.log("warning", e, r[0] ?? {}) : typeof e == "function" ? this.logLazily("warning", e) : this.logTemplate("warning", e, r);
+  }
+  error(e, ...r) {
+    typeof e == "string" ? this.log("error", e, r[0] ?? {}) : typeof e == "function" ? this.logLazily("error", e) : this.logTemplate("error", e, r);
+  }
+  fatal(e, ...r) {
+    typeof e == "string" ? this.log("fatal", e, r[0] ?? {}) : typeof e == "function" ? this.logLazily("fatal", e) : this.logTemplate("fatal", e, r);
+  }
+}
+class ue {
+  constructor(e, r) {
+    Object.defineProperty(this, "logger", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "properties", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), this.logger = e, this.properties = r;
+  }
+  get category() {
+    return this.logger.category;
+  }
+  get parent() {
+    return this.logger.parent;
+  }
+  getChild(e) {
+    return this.logger.getChild(e).with(this.properties);
+  }
+  with(e) {
+    return new ue(this.logger, { ...this.properties, ...e });
+  }
+  log(e, r, n, i) {
+    this.logger.log(e, r, typeof n == "function" ? () => ({
+      ...this.properties,
+      ...n()
+    }) : { ...this.properties, ...n }, i);
+  }
+  logLazily(e, r) {
+    this.logger.logLazily(e, r, this.properties);
+  }
+  logTemplate(e, r, n) {
+    this.logger.logTemplate(e, r, n, this.properties);
+  }
+  debug(e, ...r) {
+    typeof e == "string" ? this.log("debug", e, r[0] ?? {}) : typeof e == "function" ? this.logLazily("debug", e) : this.logTemplate("debug", e, r);
+  }
+  info(e, ...r) {
+    typeof e == "string" ? this.log("info", e, r[0] ?? {}) : typeof e == "function" ? this.logLazily("info", e) : this.logTemplate("info", e, r);
+  }
+  warn(e, ...r) {
+    typeof e == "string" ? this.log("warning", e, r[0] ?? {}) : typeof e == "function" ? this.logLazily("warning", e) : this.logTemplate("warning", e, r);
+  }
+  error(e, ...r) {
+    typeof e == "string" ? this.log("error", e, r[0] ?? {}) : typeof e == "function" ? this.logLazily("error", e) : this.logTemplate("error", e, r);
+  }
+  fatal(e, ...r) {
+    typeof e == "string" ? this.log("fatal", e, r[0] ?? {}) : typeof e == "function" ? this.logLazily("fatal", e) : this.logTemplate("fatal", e, r);
+  }
+}
+const At = C.getLogger(["logtape", "meta"]);
+function me(t, e) {
+  const r = [];
+  let n = "";
+  for (let i = 0; i < t.length; i++) {
+    const a = t.charAt(i), s = t.charAt(i + 1);
+    if (a === "{" && s === "{")
+      n = n + a, i++;
+    else if (a === "}" && s === "}")
+      n = n + a, i++;
+    else if (a === "{")
+      r.push(n), n = "";
+    else if (a === "}") {
+      let l;
+      n.match(/^\s|\s$/) ? l = n in e ? e[n] : e[n.trim()] : l = e[n], r.push(l), n = "";
+    } else
+      n = n + a;
+  }
+  return r.push(n), r;
+}
+function ve(t, e) {
+  const r = [];
+  for (let n = 0; n < t.length; n++)
+    r.push(t[n]), n < e.length && r.push(e[n]);
+  return r;
+}
+function _e(t) {
+  return t && t.__esModule && Object.prototype.hasOwnProperty.call(t, "default") ? t.default : t;
+}
+function Re(t) {
+  throw new Error('Could not dynamically require "' + t + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+}
+var K, be;
+function wt() {
+  if (be) return K;
+  be = 1;
+  let t = null;
+  if (typeof window > "u" && ("process" in globalThis && "versions" in globalThis.process && "node" in globalThis.process.versions && typeof globalThis.caches > "u" && typeof globalThis.addEventListener != "function" || "Bun" in globalThis))
+    try {
+      t = [Re][0](`${["node", "util"].join(":")}`);
+    } catch {
+      t = null;
+    }
+  return K = t, K;
+}
+var Ot = wt();
+const q = /* @__PURE__ */ _e(Ot), Ae = {
+  debug: "DBG",
+  info: "INF",
+  warning: "WRN",
+  error: "ERR",
+  fatal: "FTL"
+}, Me = (
+  // @ts-ignore: Deno global
+  // dnt-shim-ignore
+  "Deno" in globalThis && "inspect" in globalThis.Deno && // @ts-ignore: Deno global
+  // dnt-shim-ignore
+  typeof globalThis.Deno.inspect == "function" ? (t, e) => (
+    // @ts-ignore: Deno global
+    // dnt-shim-ignore
+    globalThis.Deno.inspect(t, {
+      strAbbreviateSize: 1 / 0,
+      iterableLimit: 1 / 0,
+      ...e
+    })
+  ) : q != null && "inspect" in q && typeof q.inspect == "function" ? (t, e) => (
+    // @ts-ignore: Node.js global
+    // dnt-shim-ignore
+    q.inspect(t, {
+      maxArrayLength: 1 / 0,
+      maxStringLength: 1 / 0,
+      ...e
+    })
+  ) : (t) => JSON.stringify(t)
+);
+function $e(t = {}) {
+  const e = t.timestamp == null || t.timestamp === "date-time-timezone" ? (s) => new Date(s).toISOString().replace("T", " ").replace("Z", " +00:00") : t.timestamp === "date-time-tz" ? (s) => new Date(s).toISOString().replace("T", " ").replace("Z", " +00") : t.timestamp === "date-time" ? (s) => new Date(s).toISOString().replace("T", " ").replace("Z", "") : t.timestamp === "time-timezone" ? (s) => new Date(s).toISOString().replace(/.*T/, "").replace("Z", " +00:00") : t.timestamp === "time-tz" ? (s) => new Date(s).toISOString().replace(/.*T/, "").replace("Z", " +00") : t.timestamp === "time" ? (s) => new Date(s).toISOString().replace(/.*T/, "").replace("Z", "") : t.timestamp === "date" ? (s) => new Date(s).toISOString().replace(/T.*/, "") : t.timestamp === "rfc3339" ? (s) => new Date(s).toISOString() : t.timestamp, r = t.category ?? "·", n = t.value ?? Me, i = t.level == null || t.level === "ABBR" ? (s) => Ae[s] : t.level === "abbr" ? (s) => Ae[s].toLowerCase() : t.level === "FULL" ? (s) => s.toUpperCase() : t.level === "full" ? (s) => s : t.level === "L" ? (s) => s.charAt(0).toUpperCase() : t.level === "l" ? (s) => s.charAt(0) : t.level, a = t.format ?? (({ timestamp: s, level: l, category: u, message: o }) => `${s} [${l}] ${u}: ${o}`);
+  return (s) => {
+    let l = "";
+    for (let g = 0; g < s.message.length; g++)
+      g % 2 === 0 ? l += s.message[g] : l += n(s.message[g]);
+    const u = e(s.timestamp), o = i(s.level), c = typeof r == "function" ? r(s.category) : s.category.join(r);
+    return `${a({
+      timestamp: u,
+      level: o,
+      category: c,
+      message: l,
+      record: s
+    })}
+`;
+  };
+}
+$e();
+const Z = "\x1B[0m", Y = {
+  black: "\x1B[30m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m"
+}, J = {
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  italic: "\x1B[3m",
+  underline: "\x1B[4m",
+  strikethrough: "\x1B[9m"
+}, Et = {
+  debug: "blue",
+  info: "green",
+  warning: "yellow",
+  error: "red",
+  fatal: "magenta"
+};
+function St(t = {}) {
+  const e = t.format, r = typeof t.timestampStyle > "u" ? "dim" : t.timestampStyle, n = t.timestampColor ?? null, i = `${r == null ? "" : J[r]}${n == null ? "" : Y[n]}`, a = r == null && n == null ? "" : Z, s = typeof t.levelStyle > "u" ? "bold" : t.levelStyle, l = t.levelColors ?? Et, u = typeof t.categoryStyle > "u" ? "dim" : t.categoryStyle, o = t.categoryColor ?? null, c = `${u == null ? "" : J[u]}${o == null ? "" : Y[o]}`, h = u == null && o == null ? "" : Z;
+  return $e({
+    timestamp: "date-time-tz",
+    value(g) {
+      return Me(g, { colors: !0 });
+    },
+    ...t,
+    format({ timestamp: g, level: m, category: S, message: G, record: F }) {
+      const L = l[F.level];
+      return g = `${i}${g}${a}`, m = `${s == null ? "" : J[s]}${L == null ? "" : Y[L]}${m}${s == null && L == null ? "" : Z}`, e == null ? `${g} ${m} ${c}${S}:${h} ${G}` : e({
+        timestamp: g,
+        level: m,
+        category: `${c}${S}${h}`,
+        message: G,
+        record: F
+      });
+    }
+  });
+}
+St();
+var Q, we;
+function Lt() {
+  if (we) return Q;
+  we = 1;
+  let t = null;
+  if (typeof window > "u" && ("process" in globalThis && "versions" in globalThis.process && "node" in globalThis.process.versions && typeof globalThis.caches > "u" && typeof globalThis.addEventListener != "function" || "Bun" in globalThis))
+    try {
+      t = [Re][0](`${["node", "fs"].join(":")}`);
+    } catch {
+      t = null;
+    }
+  return Q = t, Q;
+}
+var Tt = Lt();
+const Ct = /* @__PURE__ */ _e(Tt), It = {}, _ = Ct;
+_ == null || (_.writeSync, _.fsyncSync, _.closeSync, _.statSync, _.renameSync);
+var d = function(t, e, r, n) {
+  function i(a) {
+    return a instanceof r ? a : new r(function(s) {
+      s(a);
+    });
+  }
+  return new (r || (r = Promise))(function(a, s) {
+    function l(c) {
+      try {
+        o(n.next(c));
+      } catch (h) {
+        s(h);
+      }
+    }
+    function u(c) {
+      try {
+        o(n.throw(c));
+      } catch (h) {
+        s(h);
+      }
+    }
+    function o(c) {
+      c.done ? a(c.value) : i(c.value).then(l, u);
+    }
+    o((n = n.apply(t, e || [])).next());
+  });
+}, y = function(t, e) {
+  var r = { label: 0, sent: function() {
+    if (a[0] & 1) throw a[1];
+    return a[1];
+  }, trys: [], ops: [] }, n, i, a, s = Object.create((typeof Iterator == "function" ? Iterator : Object).prototype);
+  return s.next = l(0), s.throw = l(1), s.return = l(2), typeof Symbol == "function" && (s[Symbol.iterator] = function() {
+    return this;
+  }), s;
+  function l(o) {
+    return function(c) {
+      return u([o, c]);
+    };
+  }
+  function u(o) {
+    if (n) throw new TypeError("Generator is already executing.");
+    for (; s && (s = 0, o[0] && (r = 0)), r; ) try {
+      if (n = 1, i && (a = o[0] & 2 ? i.return : o[0] ? i.throw || ((a = i.return) && a.call(i), 0) : i.next) && !(a = a.call(i, o[1])).done) return a;
+      switch (i = 0, a && (o = [o[0] & 2, a.value]), o[0]) {
+        case 0:
+        case 1:
+          a = o;
+          break;
+        case 4:
+          return r.label++, { value: o[1], done: !1 };
+        case 5:
+          r.label++, i = o[1], o = [0];
+          continue;
+        case 7:
+          o = r.ops.pop(), r.trys.pop();
+          continue;
+        default:
+          if (a = r.trys, !(a = a.length > 0 && a[a.length - 1]) && (o[0] === 6 || o[0] === 2)) {
+            r = 0;
+            continue;
+          }
+          if (o[0] === 3 && (!a || o[1] > a[0] && o[1] < a[3])) {
+            r.label = o[1];
+            break;
+          }
+          if (o[0] === 6 && r.label < a[1]) {
+            r.label = a[1], a = o;
+            break;
+          }
+          if (a && r.label < a[2]) {
+            r.label = a[2], r.ops.push(o);
+            break;
+          }
+          a[2] && r.ops.pop(), r.trys.pop();
+          continue;
+      }
+      o = e.call(t, r);
+    } catch (c) {
+      o = [6, c], i = 0;
+    } finally {
+      n = a = 0;
+    }
+    if (o[0] & 5) throw o[1];
+    return { value: o[0] ? o[1] : void 0, done: !0 };
+  }
+}, O = function(t, e) {
+  var r = typeof Symbol == "function" && t[Symbol.iterator];
+  if (!r) return t;
+  var n = r.call(t), i, a = [], s;
+  try {
+    for (; (e === void 0 || e-- > 0) && !(i = n.next()).done; ) a.push(i.value);
+  } catch (l) {
+    s = { error: l };
+  } finally {
+    try {
+      i && !i.done && (r = n.return) && r.call(n);
+    } finally {
+      if (s) throw s.error;
+    }
+  }
+  return a;
+}, E = function(t, e, r) {
+  if (r || arguments.length === 2) for (var n = 0, i = e.length, a; n < i; n++)
+    (a || !(n in e)) && (a || (a = Array.prototype.slice.call(e, 0, n)), a[n] = e[n]);
+  return t.concat(a || Array.prototype.slice.call(e));
+}, Oe = function(t) {
+  var e = typeof Symbol == "function" && Symbol.iterator, r = e && t[e], n = 0;
+  if (r) return r.call(t);
+  if (t && typeof t.length == "number") return {
+    next: function() {
+      return t && n >= t.length && (t = void 0), { value: t && t[n++], done: !t };
+    }
+  };
+  throw new TypeError(e ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+(function() {
+  function t(e) {
+    e === void 0 && (e = t.minComparator);
+    var r = this;
+    this.compare = e, this.heapArray = [], this._limit = 0, this.offer = this.add, this.element = this.peek, this.poll = this.pop, this._invertedCompare = function(n, i) {
+      return r.compare(n, i).then(function(a) {
+        return -1 * a;
+      });
+    };
+  }
+  return t.getChildrenIndexOf = function(e) {
+    return [e * 2 + 1, e * 2 + 2];
+  }, t.getParentIndexOf = function(e) {
+    if (e <= 0)
+      return -1;
+    var r = e % 2 ? 1 : 2;
+    return Math.floor((e - r) / 2);
+  }, t.getSiblingIndexOf = function(e) {
+    if (e <= 0)
+      return -1;
+    var r = e % 2 ? 1 : -1;
+    return e + r;
+  }, t.minComparator = function(e, r) {
+    return d(this, void 0, void 0, function() {
+      return y(this, function(n) {
+        return e > r ? [2, 1] : e < r ? [2, -1] : [2, 0];
+      });
+    });
+  }, t.maxComparator = function(e, r) {
+    return d(this, void 0, void 0, function() {
+      return y(this, function(n) {
+        return r > e ? [2, 1] : r < e ? [2, -1] : [2, 0];
+      });
+    });
+  }, t.minComparatorNumber = function(e, r) {
+    return d(this, void 0, void 0, function() {
+      return y(this, function(n) {
+        return [2, e - r];
+      });
+    });
+  }, t.maxComparatorNumber = function(e, r) {
+    return d(this, void 0, void 0, function() {
+      return y(this, function(n) {
+        return [2, r - e];
+      });
+    });
+  }, t.defaultIsEqual = function(e, r) {
+    return d(this, void 0, void 0, function() {
+      return y(this, function(n) {
+        return [2, e === r];
+      });
+    });
+  }, t.print = function(e) {
+    function r(c) {
+      var h = t.getParentIndexOf(c);
+      return Math.floor(Math.log2(h + 1));
+    }
+    function n(c, h) {
+      for (var g = ""; h > 0; --h)
+        g += c;
+      return g;
+    }
+    for (var i = 0, a = [], s = r(e.length - 1) + 2, l = 0; i < e.length; ) {
+      var u = r(i) + 1;
+      i === 0 && (u = 0);
+      var o = String(e.get(i));
+      o.length > l && (l = o.length), a[u] = a[u] || [], a[u].push(o), i += 1;
+    }
+    return a.map(function(c, h) {
+      var g = Math.pow(2, s - h) - 1;
+      return n(" ", Math.floor(g / 2) * l) + c.map(function(m) {
+        var S = (l - m.length) / 2;
+        return n(" ", Math.ceil(S)) + m + n(" ", Math.floor(S));
+      }).join(n(" ", g * l));
+    }).join(`
+`);
+  }, t.heapify = function(e, r) {
+    return d(this, void 0, void 0, function() {
+      var n;
+      return y(this, function(i) {
+        switch (i.label) {
+          case 0:
+            return n = new t(r), n.heapArray = e, [4, n.init()];
+          case 1:
+            return i.sent(), [2, n];
+        }
+      });
+    });
+  }, t.heappop = function(e, r) {
+    var n = new t(r);
+    return n.heapArray = e, n.pop();
+  }, t.heappush = function(e, r, n) {
+    return d(this, void 0, void 0, function() {
+      var i;
+      return y(this, function(a) {
+        switch (a.label) {
+          case 0:
+            return i = new t(n), i.heapArray = e, [4, i.push(r)];
+          case 1:
+            return a.sent(), [
+              2
+              /*return*/
+            ];
+        }
+      });
+    });
+  }, t.heappushpop = function(e, r, n) {
+    var i = new t(n);
+    return i.heapArray = e, i.pushpop(r);
+  }, t.heapreplace = function(e, r, n) {
+    var i = new t(n);
+    return i.heapArray = e, i.replace(r);
+  }, t.heaptop = function(e, r, n) {
+    r === void 0 && (r = 1);
+    var i = new t(n);
+    return i.heapArray = e, i.top(r);
+  }, t.heapbottom = function(e, r, n) {
+    r === void 0 && (r = 1);
+    var i = new t(n);
+    return i.heapArray = e, i.bottom(r);
+  }, t.nlargest = function(e, r, n) {
+    return d(this, void 0, void 0, function() {
+      var i;
+      return y(this, function(a) {
+        switch (a.label) {
+          case 0:
+            return i = new t(n), i.heapArray = E([], O(r), !1), [4, i.init()];
+          case 1:
+            return a.sent(), [2, i.top(e)];
+        }
+      });
+    });
+  }, t.nsmallest = function(e, r, n) {
+    return d(this, void 0, void 0, function() {
+      var i;
+      return y(this, function(a) {
+        switch (a.label) {
+          case 0:
+            return i = new t(n), i.heapArray = E([], O(r), !1), [4, i.init()];
+          case 1:
+            return a.sent(), [2, i.bottom(e)];
+        }
+      });
+    });
+  }, t.prototype.add = function(e) {
+    return d(this, void 0, void 0, function() {
+      return y(this, function(r) {
+        switch (r.label) {
+          case 0:
+            return [4, this._sortNodeUp(this.heapArray.push(e) - 1)];
+          case 1:
+            return r.sent(), this._applyLimit(), [2, !0];
+        }
+      });
+    });
+  }, t.prototype.addAll = function(e) {
+    return d(this, void 0, void 0, function() {
+      var r, n, i;
+      return y(this, function(a) {
+        switch (a.label) {
+          case 0:
+            r = this.length, (i = this.heapArray).push.apply(i, E([], O(e), !1)), n = this.length, a.label = 1;
+          case 1:
+            return r < n ? [4, this._sortNodeUp(r)] : [3, 4];
+          case 2:
+            a.sent(), a.label = 3;
+          case 3:
+            return ++r, [3, 1];
+          case 4:
+            return this._applyLimit(), [2, !0];
+        }
+      });
+    });
+  }, t.prototype.bottom = function() {
+    return d(this, arguments, void 0, function(e) {
+      return e === void 0 && (e = 1), y(this, function(r) {
+        return this.heapArray.length === 0 || e <= 0 ? [2, []] : this.heapArray.length === 1 ? [2, [this.heapArray[0]]] : e >= this.heapArray.length ? [2, E([], O(this.heapArray), !1)] : [2, this._bottomN_push(~~e)];
+      });
+    });
+  }, t.prototype.check = function() {
+    return d(this, void 0, void 0, function() {
+      var e, r, n, i, a, s, l, u, o;
+      return y(this, function(c) {
+        switch (c.label) {
+          case 0:
+            e = 0, c.label = 1;
+          case 1:
+            if (!(e < this.heapArray.length)) return [3, 10];
+            r = this.heapArray[e], n = this.getChildrenOf(e), c.label = 2;
+          case 2:
+            c.trys.push([2, 7, 8, 9]), i = (u = void 0, Oe(n)), a = i.next(), c.label = 3;
+          case 3:
+            return a.done ? [3, 6] : (s = a.value, [4, this.compare(r, s)]);
+          case 4:
+            if (c.sent() > 0)
+              return [2, r];
+            c.label = 5;
+          case 5:
+            return a = i.next(), [3, 3];
+          case 6:
+            return [3, 9];
+          case 7:
+            return l = c.sent(), u = { error: l }, [3, 9];
+          case 8:
+            try {
+              a && !a.done && (o = i.return) && o.call(i);
+            } finally {
+              if (u) throw u.error;
+            }
+            return [
+              7
+              /*endfinally*/
+            ];
+          case 9:
+            return ++e, [3, 1];
+          case 10:
+            return [
+              2
+              /*return*/
+            ];
+        }
+      });
+    });
+  }, t.prototype.clear = function() {
+    this.heapArray = [];
+  }, t.prototype.clone = function() {
+    var e = new t(this.comparator());
+    return e.heapArray = this.toArray(), e._limit = this._limit, e;
+  }, t.prototype.comparator = function() {
+    return this.compare;
+  }, t.prototype.contains = function(e) {
+    return d(this, arguments, void 0, function(r, n) {
+      var i, a, s, l, u, o;
+      return n === void 0 && (n = t.defaultIsEqual), y(this, function(c) {
+        switch (c.label) {
+          case 0:
+            c.trys.push([0, 5, 6, 7]), i = Oe(this.heapArray), a = i.next(), c.label = 1;
+          case 1:
+            return a.done ? [3, 4] : (s = a.value, [4, n(s, r)]);
+          case 2:
+            if (c.sent())
+              return [2, !0];
+            c.label = 3;
+          case 3:
+            return a = i.next(), [3, 1];
+          case 4:
+            return [3, 7];
+          case 5:
+            return l = c.sent(), u = { error: l }, [3, 7];
+          case 6:
+            try {
+              a && !a.done && (o = i.return) && o.call(i);
+            } finally {
+              if (u) throw u.error;
+            }
+            return [
+              7
+              /*endfinally*/
+            ];
+          case 7:
+            return [2, !1];
+        }
+      });
+    });
+  }, t.prototype.init = function(e) {
+    return d(this, void 0, void 0, function() {
+      var r;
+      return y(this, function(n) {
+        switch (n.label) {
+          case 0:
+            e && (this.heapArray = E([], O(e), !1)), r = t.getParentIndexOf(this.length - 1), n.label = 1;
+          case 1:
+            return r >= 0 ? [4, this._sortNodeDown(r)] : [3, 4];
+          case 2:
+            n.sent(), n.label = 3;
+          case 3:
+            return --r, [3, 1];
+          case 4:
+            return this._applyLimit(), [
+              2
+              /*return*/
+            ];
+        }
+      });
+    });
+  }, t.prototype.isEmpty = function() {
+    return this.length === 0;
+  }, t.prototype.leafs = function() {
+    if (this.heapArray.length === 0)
+      return [];
+    var e = t.getParentIndexOf(this.heapArray.length - 1);
+    return this.heapArray.slice(e + 1);
+  }, Object.defineProperty(t.prototype, "length", {
+    /**
+     * Length of the heap.
+     * @return {Number}
+     */
+    get: function() {
+      return this.heapArray.length;
+    },
+    enumerable: !1,
+    configurable: !0
+  }), Object.defineProperty(t.prototype, "limit", {
+    /**
+     * Get length limit of the heap.
+     * @return {Number}
+     */
+    get: function() {
+      return this._limit;
+    },
+    /**
+     * Set length limit of the heap.
+     * @return {Number}
+     */
+    set: function(e) {
+      this._limit = ~~e, this._applyLimit();
+    },
+    enumerable: !1,
+    configurable: !0
+  }), t.prototype.peek = function() {
+    return this.heapArray[0];
+  }, t.prototype.pop = function() {
+    return d(this, void 0, void 0, function() {
+      var e;
+      return y(this, function(r) {
+        return e = this.heapArray.pop(), this.length > 0 && e !== void 0 ? [2, this.replace(e)] : [2, e];
+      });
+    });
+  }, t.prototype.push = function() {
+    for (var e = [], r = 0; r < arguments.length; r++)
+      e[r] = arguments[r];
+    return d(this, void 0, void 0, function() {
+      return y(this, function(n) {
+        return e.length < 1 ? [2, !1] : e.length === 1 ? [2, this.add(e[0])] : [2, this.addAll(e)];
+      });
+    });
+  }, t.prototype.pushpop = function(e) {
+    return d(this, void 0, void 0, function() {
+      var r;
+      return y(this, function(n) {
+        switch (n.label) {
+          case 0:
+            return [4, this.compare(this.heapArray[0], e)];
+          case 1:
+            return n.sent() < 0 ? (r = O([this.heapArray[0], e], 2), e = r[0], this.heapArray[0] = r[1], [4, this._sortNodeDown(0)]) : [3, 3];
+          case 2:
+            n.sent(), n.label = 3;
+          case 3:
+            return [2, e];
+        }
+      });
+    });
+  }, t.prototype.remove = function(e) {
+    return d(this, arguments, void 0, function(r, n) {
+      var i, a, s, l = this;
+      return n === void 0 && (n = t.defaultIsEqual), y(this, function(u) {
+        switch (u.label) {
+          case 0:
+            return this.heapArray.length ? r !== void 0 ? [3, 2] : [4, this.pop()] : [2, !1];
+          case 1:
+            return u.sent(), [2, !0];
+          case 2:
+            i = [0], u.label = 3;
+          case 3:
+            return i.length ? (a = i.shift(), [4, n(this.heapArray[a], r)]) : [3, 13];
+          case 4:
+            return u.sent() ? a !== 0 ? [3, 6] : [4, this.pop()] : [3, 11];
+          case 5:
+            return u.sent(), [3, 10];
+          case 6:
+            return a !== this.heapArray.length - 1 ? [3, 7] : (this.heapArray.pop(), [3, 10]);
+          case 7:
+            return this.heapArray.splice(a, 1, this.heapArray.pop()), [4, this._sortNodeUp(a)];
+          case 8:
+            return u.sent(), [4, this._sortNodeDown(a)];
+          case 9:
+            u.sent(), u.label = 10;
+          case 10:
+            return [2, !0];
+          case 11:
+            s = t.getChildrenIndexOf(a).filter(function(o) {
+              return o < l.heapArray.length;
+            }), i.push.apply(i, E([], O(s), !1)), u.label = 12;
+          case 12:
+            return [3, 3];
+          case 13:
+            return [2, !1];
+        }
+      });
+    });
+  }, t.prototype.replace = function(e) {
+    return d(this, void 0, void 0, function() {
+      var r;
+      return y(this, function(n) {
+        switch (n.label) {
+          case 0:
+            return r = this.heapArray[0], this.heapArray[0] = e, [4, this._sortNodeDown(0)];
+          case 1:
+            return n.sent(), [2, r];
+        }
+      });
+    });
+  }, t.prototype.size = function() {
+    return this.length;
+  }, t.prototype.top = function() {
+    return d(this, arguments, void 0, function(e) {
+      return e === void 0 && (e = 1), y(this, function(r) {
+        return this.heapArray.length === 0 || e <= 0 ? [2, []] : this.heapArray.length === 1 || e === 1 ? [2, [this.heapArray[0]]] : e >= this.heapArray.length ? [2, E([], O(this.heapArray), !1)] : [2, this._topN_push(~~e)];
+      });
+    });
+  }, t.prototype.toArray = function() {
+    return E([], O(this.heapArray), !1);
+  }, t.prototype.toString = function() {
+    return this.heapArray.toString();
+  }, t.prototype.get = function(e) {
+    return this.heapArray[e];
+  }, t.prototype.getChildrenOf = function(e) {
+    var r = this;
+    return t.getChildrenIndexOf(e).map(function(n) {
+      return r.heapArray[n];
+    }).filter(function(n) {
+      return n !== void 0;
+    });
+  }, t.prototype.getParentOf = function(e) {
+    var r = t.getParentIndexOf(e);
+    return this.heapArray[r];
+  }, t.prototype[Symbol.iterator] = function() {
+    return y(this, function(e) {
+      switch (e.label) {
+        case 0:
+          return this.length ? [4, this.pop()] : [3, 2];
+        case 1:
+          return e.sent(), [3, 0];
+        case 2:
+          return [
+            2
+            /*return*/
+          ];
+      }
+    });
+  }, t.prototype.iterator = function() {
+    return this;
+  }, t.prototype._applyLimit = function() {
+    if (this._limit && this._limit < this.heapArray.length)
+      for (var e = this.heapArray.length - this._limit; e; )
+        this.heapArray.pop(), --e;
+  }, t.prototype._bottomN_push = function(e) {
+    return d(this, void 0, void 0, function() {
+      var r, n, i, a, l, s, l;
+      return y(this, function(u) {
+        switch (u.label) {
+          case 0:
+            return r = new t(this.compare), r.limit = e, r.heapArray = this.heapArray.slice(-e), [4, r.init()];
+          case 1:
+            for (u.sent(), n = this.heapArray.length - 1 - e, i = t.getParentIndexOf(n), a = [], l = n; l > i; --l)
+              a.push(l);
+            s = this.heapArray, u.label = 2;
+          case 2:
+            return a.length ? (l = a.shift(), [4, this.compare(s[l], r.peek())]) : [3, 6];
+          case 3:
+            return u.sent() > 0 ? [4, r.replace(s[l])] : [3, 5];
+          case 4:
+            u.sent(), l % 2 && a.push(t.getParentIndexOf(l)), u.label = 5;
+          case 5:
+            return [3, 2];
+          case 6:
+            return [2, r.toArray()];
+        }
+      });
+    });
+  }, t.prototype._moveNode = function(e, r) {
+    var n = this.heapArray[e];
+    this.heapArray[e] = this.heapArray[r], this.heapArray[r] = n;
+  }, t.prototype._sortNodeDown = function(e) {
+    return d(this, void 0, void 0, function() {
+      var r, n, i, a, s, l, u;
+      return y(this, function(o) {
+        switch (o.label) {
+          case 0:
+            r = this.heapArray.length, n = e, i = this.heapArray[e], a = 2 * e + 1, o.label = 1;
+          case 1:
+            return a < r ? (s = a + 1, u = s >= r, u ? [3, 3] : [4, this.compare(this.heapArray[a], this.heapArray[s])]) : [3, 5];
+          case 2:
+            u = o.sent() < 0, o.label = 3;
+          case 3:
+            return l = u ? a : s, [4, this.compare(this.heapArray[l], i)];
+          case 4:
+            if (o.sent() < 0)
+              this.heapArray[e] = this.heapArray[l], e = l, a = 2 * e + 1;
+            else
+              return [3, 5];
+            return [3, 1];
+          case 5:
+            return e !== n && (this.heapArray[e] = i), [
+              2
+              /*return*/
+            ];
+        }
+      });
+    });
+  }, t.prototype._sortNodeUp = function(e) {
+    return d(this, void 0, void 0, function() {
+      var r, n, i;
+      return y(this, function(a) {
+        switch (a.label) {
+          case 0:
+            r = this.heapArray[e], n = e, a.label = 1;
+          case 1:
+            return e > 0 ? (i = t.getParentIndexOf(e), [4, this.compare(r, this.heapArray[i])]) : [3, 3];
+          case 2:
+            if (a.sent() < 0)
+              this.heapArray[e] = this.heapArray[i], e = i;
+            else
+              return [3, 3];
+            return [3, 1];
+          case 3:
+            return e !== n && (this.heapArray[e] = r), [
+              2
+              /*return*/
+            ];
+        }
+      });
+    });
+  }, t.prototype._topN_push = function(e) {
+    return d(this, void 0, void 0, function() {
+      var r, n, i, a;
+      return y(this, function(s) {
+        switch (s.label) {
+          case 0:
+            r = new t(this._invertedCompare), r.limit = e, n = [0], i = this.heapArray, s.label = 1;
+          case 1:
+            return n.length ? (a = n.shift(), a < i.length ? r.length < e ? [4, r.push(i[a])] : [3, 3] : [3, 6]) : [3, 7];
+          case 2:
+            return s.sent(), n.push.apply(n, E([], O(t.getChildrenIndexOf(a)), !1)), [3, 6];
+          case 3:
+            return [4, this.compare(i[a], r.peek())];
+          case 4:
+            return s.sent() < 0 ? [4, r.replace(i[a])] : [3, 6];
+          case 5:
+            s.sent(), n.push.apply(n, E([], O(t.getChildrenIndexOf(a)), !1)), s.label = 6;
+          case 6:
+            return [3, 1];
+          case 7:
+            return [2, r.toArray()];
+        }
+      });
+    });
+  }, t.prototype._topN_fill = function(e) {
+    return d(this, void 0, void 0, function() {
+      var r, n, i, a, s, s;
+      return y(this, function(l) {
+        switch (l.label) {
+          case 0:
+            return r = this.heapArray, n = new t(this._invertedCompare), n.limit = e, n.heapArray = r.slice(0, e), [4, n.init()];
+          case 1:
+            for (l.sent(), i = t.getParentIndexOf(e - 1) + 1, a = [], s = i; s < e; ++s)
+              a.push.apply(a, E([], O(t.getChildrenIndexOf(s).filter(function(u) {
+                return u < r.length;
+              })), !1));
+            (e - 1) % 2 && a.push(e), l.label = 2;
+          case 2:
+            return a.length ? (s = a.shift(), s < r.length ? [4, this.compare(r[s], n.peek())] : [3, 5]) : [3, 6];
+          case 3:
+            return l.sent() < 0 ? [4, n.replace(r[s])] : [3, 5];
+          case 4:
+            l.sent(), a.push.apply(a, E([], O(t.getChildrenIndexOf(s)), !1)), l.label = 5;
+          case 5:
+            return [3, 2];
+          case 6:
+            return [2, n.toArray()];
+        }
+      });
+    });
+  }, t.prototype._topN_heap = function(e) {
+    return d(this, void 0, void 0, function() {
+      var r, n, i, a, s;
+      return y(this, function(l) {
+        switch (l.label) {
+          case 0:
+            r = this.clone(), n = [], i = 0, l.label = 1;
+          case 1:
+            return i < e ? (s = (a = n).push, [4, r.pop()]) : [3, 4];
+          case 2:
+            s.apply(a, [l.sent()]), l.label = 3;
+          case 3:
+            return ++i, [3, 1];
+          case 4:
+            return [2, n];
+        }
+      });
+    });
+  }, t.prototype._topIdxOf = function(e) {
+    return d(this, void 0, void 0, function() {
+      var r, n, i, a;
+      return y(this, function(s) {
+        switch (s.label) {
+          case 0:
+            if (!e.length)
+              return [2, -1];
+            r = 0, n = e[r], i = 1, s.label = 1;
+          case 1:
+            return i < e.length ? [4, this.compare(e[i], n)] : [3, 4];
+          case 2:
+            a = s.sent(), a < 0 && (r = i, n = e[i]), s.label = 3;
+          case 3:
+            return ++i, [3, 1];
+          case 4:
+            return [2, r];
+        }
+      });
+    });
+  }, t.prototype._topOf = function() {
+    for (var e = [], r = 0; r < arguments.length; r++)
+      e[r] = arguments[r];
+    return d(this, void 0, void 0, function() {
+      var n;
+      return y(this, function(i) {
+        switch (i.label) {
+          case 0:
+            return n = new t(this.compare), [4, n.init(e)];
+          case 1:
+            return i.sent(), [2, n.peek()];
+        }
+      });
+    });
+  }, t;
+})();
+var Nt = function(t, e) {
+  var r = { label: 0, sent: function() {
+    if (a[0] & 1) throw a[1];
+    return a[1];
+  }, trys: [], ops: [] }, n, i, a, s = Object.create((typeof Iterator == "function" ? Iterator : Object).prototype);
+  return s.next = l(0), s.throw = l(1), s.return = l(2), typeof Symbol == "function" && (s[Symbol.iterator] = function() {
+    return this;
+  }), s;
+  function l(o) {
+    return function(c) {
+      return u([o, c]);
+    };
+  }
+  function u(o) {
+    if (n) throw new TypeError("Generator is already executing.");
+    for (; s && (s = 0, o[0] && (r = 0)), r; ) try {
+      if (n = 1, i && (a = o[0] & 2 ? i.return : o[0] ? i.throw || ((a = i.return) && a.call(i), 0) : i.next) && !(a = a.call(i, o[1])).done) return a;
+      switch (i = 0, a && (o = [o[0] & 2, a.value]), o[0]) {
+        case 0:
+        case 1:
+          a = o;
+          break;
+        case 4:
+          return r.label++, { value: o[1], done: !1 };
+        case 5:
+          r.label++, i = o[1], o = [0];
+          continue;
+        case 7:
+          o = r.ops.pop(), r.trys.pop();
+          continue;
+        default:
+          if (a = r.trys, !(a = a.length > 0 && a[a.length - 1]) && (o[0] === 6 || o[0] === 2)) {
+            r = 0;
+            continue;
+          }
+          if (o[0] === 3 && (!a || o[1] > a[0] && o[1] < a[3])) {
+            r.label = o[1];
+            break;
+          }
+          if (o[0] === 6 && r.label < a[1]) {
+            r.label = a[1], a = o;
+            break;
+          }
+          if (a && r.label < a[2]) {
+            r.label = a[2], r.ops.push(o);
+            break;
+          }
+          a[2] && r.ops.pop(), r.trys.pop();
+          continue;
+      }
+      o = e.call(t, r);
+    } catch (c) {
+      o = [6, c], i = 0;
+    } finally {
+      n = a = 0;
+    }
+    if (o[0] & 5) throw o[1];
+    return { value: o[0] ? o[1] : void 0, done: !0 };
+  }
+}, b = function(t, e) {
+  var r = typeof Symbol == "function" && t[Symbol.iterator];
+  if (!r) return t;
+  var n = r.call(t), i, a = [], s;
+  try {
+    for (; (e === void 0 || e-- > 0) && !(i = n.next()).done; ) a.push(i.value);
+  } catch (l) {
+    s = { error: l };
+  } finally {
+    try {
+      i && !i.done && (r = n.return) && r.call(n);
+    } finally {
+      if (s) throw s.error;
+    }
+  }
+  return a;
+}, A = function(t, e, r) {
+  if (r || arguments.length === 2) for (var n = 0, i = e.length, a; n < i; n++)
+    (a || !(n in e)) && (a || (a = Array.prototype.slice.call(e, 0, n)), a[n] = e[n]);
+  return t.concat(a || Array.prototype.slice.call(e));
+}, Dt = (
+  /** @class */
+  (function() {
+    function t(e) {
+      e === void 0 && (e = t.minComparator);
+      var r = this;
+      this.compare = e, this.heapArray = [], this._limit = 0, this.offer = this.add, this.element = this.peek, this.poll = this.pop, this.removeAll = this.clear, this._invertedCompare = function(n, i) {
+        return -1 * r.compare(n, i);
+      };
+    }
+    return t.getChildrenIndexOf = function(e) {
+      return [e * 2 + 1, e * 2 + 2];
+    }, t.getParentIndexOf = function(e) {
+      return e <= 0 ? -1 : e - 1 >> 1;
+    }, t.getSiblingIndexOf = function(e) {
+      if (e <= 0)
+        return -1;
+      var r = e % 2 ? 1 : -1;
+      return e + r;
+    }, t.minComparator = function(e, r) {
+      return e > r ? 1 : e < r ? -1 : 0;
+    }, t.maxComparator = function(e, r) {
+      return r > e ? 1 : r < e ? -1 : 0;
+    }, t.minComparatorNumber = function(e, r) {
+      return e - r;
+    }, t.maxComparatorNumber = function(e, r) {
+      return r - e;
+    }, t.defaultIsEqual = function(e, r) {
+      return e === r;
+    }, t.print = function(e) {
+      function r(c) {
+        var h = t.getParentIndexOf(c);
+        return Math.floor(Math.log2(h + 1));
+      }
+      function n(c, h) {
+        for (var g = ""; h > 0; --h)
+          g += c;
+        return g;
+      }
+      for (var i = 0, a = [], s = r(e.length - 1) + 2, l = 0; i < e.length; ) {
+        var u = r(i) + 1;
+        i === 0 && (u = 0);
+        var o = String(e.get(i));
+        o.length > l && (l = o.length), a[u] = a[u] || [], a[u].push(o), i += 1;
+      }
+      return a.map(function(c, h) {
+        var g = Math.pow(2, s - h) - 1;
+        return n(" ", Math.floor(g / 2) * l) + c.map(function(m) {
+          var S = (l - m.length) / 2;
+          return n(" ", Math.ceil(S)) + m + n(" ", Math.floor(S));
+        }).join(n(" ", g * l));
+      }).join(`
+`);
+    }, t.heapify = function(e, r) {
+      var n = new t(r);
+      return n.heapArray = e, n.init(), n;
+    }, t.heappop = function(e, r) {
+      var n = new t(r);
+      return n.heapArray = e, n.pop();
+    }, t.heappush = function(e, r, n) {
+      var i = new t(n);
+      i.heapArray = e, i.push(r);
+    }, t.heappushpop = function(e, r, n) {
+      var i = new t(n);
+      return i.heapArray = e, i.pushpop(r);
+    }, t.heapreplace = function(e, r, n) {
+      var i = new t(n);
+      return i.heapArray = e, i.replace(r);
+    }, t.heaptop = function(e, r, n) {
+      r === void 0 && (r = 1);
+      var i = new t(n);
+      return i.heapArray = e, i.top(r);
+    }, t.heapbottom = function(e, r, n) {
+      r === void 0 && (r = 1);
+      var i = new t(n);
+      return i.heapArray = e, i.bottom(r);
+    }, t.nlargest = function(e, r, n) {
+      var i = new t(n);
+      return i.heapArray = A([], b(r), !1), i.init(), i.top(e);
+    }, t.nsmallest = function(e, r, n) {
+      var i = new t(n);
+      return i.heapArray = A([], b(r), !1), i.init(), i.bottom(e);
+    }, t.prototype.add = function(e) {
+      return this._sortNodeUp(this.heapArray.push(e) - 1), this._applyLimit(), !0;
+    }, t.prototype.addAll = function(e) {
+      var r, n = this.length;
+      (r = this.heapArray).push.apply(r, A([], b(e), !1));
+      for (var i = this.length; n < i; ++n)
+        this._sortNodeUp(n);
+      return this._applyLimit(), !0;
+    }, t.prototype.bottom = function(e) {
+      return e === void 0 && (e = 1), this.heapArray.length === 0 || e <= 0 ? [] : this.heapArray.length === 1 ? [this.heapArray[0]] : e >= this.heapArray.length ? A([], b(this.heapArray), !1) : this._bottomN_push(~~e);
+    }, t.prototype.check = function() {
+      var e = this;
+      return this.heapArray.find(function(r, n) {
+        return !!e.getChildrenOf(n).find(function(i) {
+          return e.compare(r, i) > 0;
+        });
+      });
+    }, t.prototype.clear = function() {
+      this.heapArray = [];
+    }, t.prototype.clone = function() {
+      var e = new t(this.comparator());
+      return e.heapArray = this.toArray(), e._limit = this._limit, e;
+    }, t.prototype.comparator = function() {
+      return this.compare;
+    }, t.prototype.contains = function(e, r) {
+      return r === void 0 && (r = t.defaultIsEqual), this.indexOf(e, r) !== -1;
+    }, t.prototype.init = function(e) {
+      e && (this.heapArray = A([], b(e), !1));
+      for (var r = t.getParentIndexOf(this.length - 1); r >= 0; --r)
+        this._sortNodeDown(r);
+      this._applyLimit();
+    }, t.prototype.isEmpty = function() {
+      return this.length === 0;
+    }, t.prototype.indexOf = function(e, r) {
+      if (r === void 0 && (r = t.defaultIsEqual), this.heapArray.length === 0)
+        return -1;
+      for (var n = [], i = 0; i < this.heapArray.length; ) {
+        var a = this.heapArray[i];
+        if (r(a, e))
+          return i;
+        this.compare(a, e) <= 0 && n.push.apply(n, A([], b(t.getChildrenIndexOf(i)), !1)), i = n.shift() || this.heapArray.length;
+      }
+      return -1;
+    }, t.prototype.indexOfEvery = function(e, r) {
+      if (r === void 0 && (r = t.defaultIsEqual), this.heapArray.length === 0)
+        return [];
+      for (var n = [], i = [], a = 0; a < this.heapArray.length; ) {
+        var s = this.heapArray[a];
+        r(s, e) ? (i.push(a), n.push.apply(n, A([], b(t.getChildrenIndexOf(a)), !1))) : this.compare(s, e) <= 0 && n.push.apply(n, A([], b(t.getChildrenIndexOf(a)), !1)), a = n.shift() || this.heapArray.length;
+      }
+      return i;
+    }, t.prototype.leafs = function() {
+      if (this.heapArray.length === 0)
+        return [];
+      var e = t.getParentIndexOf(this.heapArray.length - 1);
+      return this.heapArray.slice(e + 1);
+    }, Object.defineProperty(t.prototype, "length", {
+      /**
+       * Length of the heap. Aliases: {@link size}.
+       * @return {Number}
+       * @see size
+       */
+      get: function() {
+        return this.heapArray.length;
+      },
+      enumerable: !1,
+      configurable: !0
+    }), Object.defineProperty(t.prototype, "limit", {
+      /**
+       * Get length limit of the heap.
+       * Use {@link setLimit} or {@link limit} to set the limit.
+       * @return {Number}
+       * @see setLimit
+       */
+      get: function() {
+        return this._limit;
+      },
+      /**
+       * Set length limit of the heap. Same as using {@link setLimit}.
+       * @description If the heap is longer than the limit, the needed amount of leafs are removed.
+       * @param {Number} _l Limit, defaults to 0 (no limit). Negative, Infinity, or NaN values set the limit to 0.
+       * @see setLimit
+       */
+      set: function(e) {
+        e < 0 || isNaN(e) ? this._limit = 0 : this._limit = ~~e, this._applyLimit();
+      },
+      enumerable: !1,
+      configurable: !0
+    }), t.prototype.setLimit = function(e) {
+      return this.limit = e, e < 0 || isNaN(e) ? NaN : this._limit;
+    }, t.prototype.peek = function() {
+      return this.heapArray[0];
+    }, t.prototype.pop = function() {
+      var e = this.heapArray.pop();
+      return this.length > 0 && e !== void 0 ? this.replace(e) : e;
+    }, t.prototype.push = function() {
+      for (var e = [], r = 0; r < arguments.length; r++)
+        e[r] = arguments[r];
+      return e.length < 1 ? !1 : e.length === 1 ? this.add(e[0]) : this.addAll(e);
+    }, t.prototype.pushpop = function(e) {
+      var r;
+      return this.compare(this.heapArray[0], e) < 0 && (r = b([this.heapArray[0], e], 2), e = r[0], this.heapArray[0] = r[1], this._sortNodeDown(0)), e;
+    }, t.prototype.remove = function(e, r) {
+      var n = this;
+      if (r === void 0 && (r = t.defaultIsEqual), !this.heapArray.length)
+        return !1;
+      if (e === void 0)
+        return this.pop(), !0;
+      for (var i = [0]; i.length; ) {
+        var a = i.shift();
+        if (r(this.heapArray[a], e))
+          return a === 0 ? this.pop() : a === this.heapArray.length - 1 ? this.heapArray.pop() : (this.heapArray.splice(a, 1, this.heapArray.pop()), this._sortNodeUp(a), this._sortNodeDown(a)), !0;
+        if (this.compare(this.heapArray[a], e) <= 0) {
+          var s = t.getChildrenIndexOf(a).filter(function(l) {
+            return l < n.heapArray.length;
+          });
+          i.push.apply(i, A([], b(s), !1));
+        }
+      }
+      return !1;
+    }, t.prototype.replace = function(e) {
+      var r = this.heapArray[0];
+      return this.heapArray[0] = e, this._sortNodeDown(0), r;
+    }, t.prototype.size = function() {
+      return this.length;
+    }, t.prototype.top = function(e) {
+      return e === void 0 && (e = 1), this.heapArray.length === 0 || e <= 0 ? [] : this.heapArray.length === 1 || e === 1 ? [this.heapArray[0]] : e >= this.heapArray.length ? A([], b(this.heapArray), !1) : this._topN_push(~~e);
+    }, t.prototype.toArray = function() {
+      return A([], b(this.heapArray), !1);
+    }, t.prototype.toString = function() {
+      return this.heapArray.toString();
+    }, t.prototype.get = function(e) {
+      return this.heapArray[e];
+    }, t.prototype.getChildrenOf = function(e) {
+      var r = this;
+      return t.getChildrenIndexOf(e).map(function(n) {
+        return r.heapArray[n];
+      }).filter(function(n) {
+        return n !== void 0;
+      });
+    }, t.prototype.getParentOf = function(e) {
+      var r = t.getParentIndexOf(e);
+      return this.heapArray[r];
+    }, t.prototype[Symbol.iterator] = function() {
+      return Nt(this, function(e) {
+        switch (e.label) {
+          case 0:
+            return this.length ? [4, this.pop()] : [3, 2];
+          case 1:
+            return e.sent(), [3, 0];
+          case 2:
+            return [
+              2
+              /*return*/
+            ];
+        }
+      });
+    }, t.prototype.iterator = function() {
+      return this.toArray();
+    }, t.prototype._applyLimit = function() {
+      if (this._limit > 0 && this._limit < this.heapArray.length)
+        for (var e = this.heapArray.length - this._limit; e; )
+          this.heapArray.pop(), --e;
+    }, t.prototype._bottomN_push = function(e) {
+      var r = new t(this.compare);
+      r.limit = e, r.heapArray = this.heapArray.slice(-e), r.init();
+      for (var n = this.heapArray.length - 1 - e, i = t.getParentIndexOf(n), a = [], s = n; s > i; --s)
+        a.push(s);
+      for (var l = this.heapArray; a.length; ) {
+        var s = a.shift();
+        this.compare(l[s], r.peek()) > 0 && (r.replace(l[s]), s % 2 && a.push(t.getParentIndexOf(s)));
+      }
+      return r.toArray();
+    }, t.prototype._moveNode = function(e, r) {
+      var n = this.heapArray[e];
+      this.heapArray[e] = this.heapArray[r], this.heapArray[r] = n;
+    }, t.prototype._sortNodeDown = function(e) {
+      for (var r = this.heapArray.length, n = e, i = this.heapArray[e], a = 2 * e + 1; a < r; ) {
+        var s = a + 1, l = s >= r || this.compare(this.heapArray[a], this.heapArray[s]) < 0 ? a : s;
+        if (this.compare(this.heapArray[l], i) < 0)
+          this.heapArray[e] = this.heapArray[l], e = l, a = 2 * e + 1;
+        else
+          break;
+      }
+      e !== n && (this.heapArray[e] = i);
+    }, t.prototype._sortNodeUp = function(e) {
+      for (var r = this.heapArray[e], n = e; e > 0; ) {
+        var i = t.getParentIndexOf(e);
+        if (this.compare(r, this.heapArray[i]) < 0)
+          this.heapArray[e] = this.heapArray[i], e = i;
+        else
+          break;
+      }
+      e !== n && (this.heapArray[e] = r);
+    }, t.prototype._topN_push = function(e) {
+      var r = new t(this._invertedCompare);
+      r.limit = e;
+      for (var n = [0], i = this.heapArray; n.length; ) {
+        var a = n.shift();
+        a < i.length && (r.length < e ? (r.push(i[a]), n.push.apply(n, A([], b(t.getChildrenIndexOf(a)), !1))) : this.compare(i[a], r.peek()) < 0 && (r.replace(i[a]), n.push.apply(n, A([], b(t.getChildrenIndexOf(a)), !1))));
+      }
+      return r.toArray();
+    }, t.prototype._topN_fill = function(e) {
+      var r = this.heapArray, n = new t(this._invertedCompare);
+      n.limit = e, n.heapArray = r.slice(0, e), n.init();
+      for (var i = t.getParentIndexOf(e - 1) + 1, a = [], s = i; s < e; ++s)
+        a.push.apply(a, A([], b(t.getChildrenIndexOf(s).filter(function(l) {
+          return l < r.length;
+        })), !1));
+      for ((e - 1) % 2 && a.push(e); a.length; ) {
+        var s = a.shift();
+        s < r.length && this.compare(r[s], n.peek()) < 0 && (n.replace(r[s]), a.push.apply(a, A([], b(t.getChildrenIndexOf(s)), !1)));
+      }
+      return n.toArray();
+    }, t.prototype._topN_heap = function(e) {
+      for (var r = this.clone(), n = [], i = 0; i < e; ++i)
+        n.push(r.pop());
+      return n;
+    }, t.prototype._topIdxOf = function(e) {
+      if (!e.length)
+        return -1;
+      for (var r = 0, n = e[r], i = 1; i < e.length; ++i) {
+        var a = this.compare(e[i], n);
+        a < 0 && (r = i, n = e[i]);
+      }
+      return r;
+    }, t.prototype._topOf = function() {
+      for (var e = [], r = 0; r < arguments.length; r++)
+        e[r] = arguments[r];
+      var n = new t(this.compare);
+      return n.init(e), n.peek();
+    }, t;
+  })()
+);
+function xt(t, e, r) {
+  return Math.abs(
+    (t[0] * (e[1] - r[1]) + e[0] * (r[1] - t[1]) + r[0] * (t[1] - e[1])) / 2
+  );
 }
-function it(e, t = 7) {
-  l.all([
-    { value: e, validator: Te, message: "bbox must be bounding box" },
-    { value: t, validator: (r) => i.inRange(r, 0, 8), message: "precision must be in range [0, 8]" }
+function X(t, { tolerance: e = 0, getWeight: r = () => 1 } = {}) {
+  if (t.length <= 2) return t;
+  const n = t.map((o, c) => ({ coord: o, i: c, area: 1 / 0, removed: !1, prev: null, next: null }));
+  for (let o = 0; o < n.length; o++)
+    o > 0 && (n[o].prev = n[o - 1]), o < n.length - 1 && (n[o].next = n[o + 1]);
+  const i = (o) => !o.prev || !o.next ? 1 / 0 : xt(o.prev.coord, o.coord, o.next.coord) * r(o.coord, o.i), a = new Dt((o, c) => o.area - c.area);
+  for (let o = 1; o < n.length - 1; o++)
+    n[o].area = i(n[o]), n[o]._currentArea = n[o].area, a.push(n[o]);
+  let s = 0;
+  for (; a.size() > 0; ) {
+    const o = a.pop();
+    if (!o.removed && o.area === o._currentArea) {
+      if (o.area < s ? o.area = s : s = o.area, o.area >= e) break;
+      o.removed = !0, o.prev && (o.prev.next = o.next), o.next && (o.next.prev = o.prev), o.prev?.prev && (o.prev.area = i(o.prev), o.prev._currentArea = o.prev.area, a.push(o.prev)), o.next?.next && (o.next.area = i(o.next), o.next._currentArea = o.next.area, a.push(o.next));
+    }
+  }
+  const l = [];
+  let u = n[0];
+  for (; u; )
+    u.removed || l.push(u.coord), u = u.next;
+  return l;
+}
+function fe(t, e) {
+  switch (p.all([
+    { value: t, validator: le, message: "geometry must be a GeoJson geometry" }
+  ]), t.type) {
+    case v.LINESTRING:
+      t.coordinates = X(t.coordinates, e);
+      break;
+    case v.POLYGON:
+    case v.MULTI_LINESTRING:
+      t.coordinates = t.coordinates.map((r) => X(r, e));
+      break;
+    case v.MULTI_POLYGON:
+      t.coordinates = t.coordinates.map((r) => r.map((n) => X(n, e)));
+      break;
+    case v.GEOMETRY_COLLECTION:
+      t.geometries.forEach((r) => fe(r, e));
+      break;
+  }
+  return t;
+}
+const _t = xe(["common-ekosystem", "simplify", "geojson"]);
+function ke(t, e) {
+  if (t.type === I.FEATURE)
+    t.geometry && fe(t.geometry, e);
+  else if (t.type === I.FEATURE_COLLECTION)
+    for (const r of t.features) ke(r, e);
+  else
+    _t.warn('Unknown feature type "{type}", skipping.', { type: t.type });
+  return t;
+}
+function yr(t, e) {
+  return p.all([
+    { value: t, validator: De, message: "geoJson must be a GeoJson object" }
+  ]), f.oneOf(t.type, Object.values(v)) ? fe(t, e) : ke(t, e);
+}
+function Pe(t, e = 7) {
+  p.all([
+    { value: t, validator: gt, message: "bbox must be bounding box" },
+    { value: e, validator: (n) => f.inRange(n, 0, 8), message: "precision must be in range [0, 8]" }
   ]);
-  const n = _[t];
-  for (let r = 0; r < e.length; r++)
-    e[r] = Math.round(e[r] * n) / n;
-  return e;
+  const r = oe[e];
+  for (let n = 0; n < t.length; n++)
+    t[n] = Math.round(t[n] * r) / r;
+  return t;
+}
+function Rt(t, e, r = {}) {
+  const n = { type: "Feature" };
+  return (r.id === 0 || r.id) && (n.id = r.id), r.bbox && (n.bbox = r.bbox), n.properties = {}, n.geometry = t, n;
 }
-function st(e, t = 7) {
-  l.all([
-    { value: e, validator: Se, message: "position must be a position" },
-    { value: t, validator: (r) => i.inRange(r, 0, 8), message: "precision must be in range [0, 8]" }
+function Mt(t, e, r = {}) {
+  if (!t)
+    throw new Error("coordinates is required");
+  if (!Array.isArray(t))
+    throw new Error("coordinates must be an Array");
+  if (t.length < 2)
+    throw new Error("coordinates must be at least 2 numbers long");
+  if (!Ee(t[0]) || !Ee(t[1]))
+    throw new Error("coordinates must contain numbers");
+  return Rt({
+    type: "Point",
+    coordinates: t
+  }, e, r);
+}
+function Ee(t) {
+  return !isNaN(t) && t !== null && !Array.isArray(t);
+}
+function $t(t) {
+  return t !== null && typeof t == "object" && !Array.isArray(t);
+}
+function Ue(t, e, r) {
+  if (t !== null)
+    for (var n, i, a, s, l, u, o, c = 0, h = 0, g, m = t.type, S = m === "FeatureCollection", G = m === "Feature", F = S ? t.features.length : 1, L = 0; L < F; L++) {
+      o = S ? (
+        // @ts-expect-error: Known type conflict
+        t.features[L].geometry
+      ) : G ? (
+        // @ts-expect-error: Known type conflict
+        t.geometry
+      ) : t, g = o ? o.type === "GeometryCollection" : !1, l = g ? o.geometries.length : 1;
+      for (var V = 0; V < l; V++) {
+        var T = 0, N = 0;
+        if (s = g ? o.geometries[V] : o, s !== null) {
+          u = s.coordinates;
+          var x = s.type;
+          switch (c = 0, x) {
+            case null:
+              break;
+            case "Point":
+              if (
+                // @ts-expect-error: Known type conflict
+                e(
+                  u,
+                  h,
+                  L,
+                  T,
+                  N
+                ) === !1
+              )
+                return !1;
+              h++, T++;
+              break;
+            case "LineString":
+            case "MultiPoint":
+              for (n = 0; n < u.length; n++) {
+                if (
+                  // @ts-expect-error: Known type conflict
+                  e(
+                    u[n],
+                    h,
+                    L,
+                    T,
+                    N
+                  ) === !1
+                )
+                  return !1;
+                h++, x === "MultiPoint" && T++;
+              }
+              x === "LineString" && T++;
+              break;
+            case "Polygon":
+            case "MultiLineString":
+              for (n = 0; n < u.length; n++) {
+                for (i = 0; i < u[n].length - c; i++) {
+                  if (
+                    // @ts-expect-error: Known type conflict
+                    e(
+                      u[n][i],
+                      h,
+                      L,
+                      T,
+                      N
+                    ) === !1
+                  )
+                    return !1;
+                  h++;
+                }
+                x === "MultiLineString" && T++, x === "Polygon" && N++;
+              }
+              x === "Polygon" && T++;
+              break;
+            case "MultiPolygon":
+              for (n = 0; n < u.length; n++) {
+                for (N = 0, i = 0; i < u[n].length; i++) {
+                  for (a = 0; a < u[n][i].length - c; a++) {
+                    if (
+                      // @ts-expect-error: Known type conflict
+                      e(
+                        u[n][i][a],
+                        h,
+                        L,
+                        T,
+                        N
+                      ) === !1
+                    )
+                      return !1;
+                    h++;
+                  }
+                  N++;
+                }
+                T++;
+              }
+              break;
+            case "GeometryCollection":
+              for (n = 0; n < s.geometries.length; n++)
+                if (
+                  // @ts-expect-error: Known type conflict
+                  Ue(s.geometries[n], e) === !1
+                )
+                  return !1;
+              break;
+            default:
+              throw new Error("Unknown Geometry Type");
+          }
+        }
+      }
+    }
+}
+function kt(t, e) {
+  if (e = e ?? {}, !$t(e)) throw new Error("options is invalid");
+  var r = e.precision, n = e.coordinates, i = e.mutate;
+  if (r = r == null || isNaN(r) ? 6 : r, n = n == null || isNaN(n) ? 3 : n, !t) throw new Error("<geojson> is required");
+  if (typeof r != "number")
+    throw new Error("<precision> must be a number");
+  if (typeof n != "number")
+    throw new Error("<coordinates> must be a number");
+  (i === !1 || i === void 0) && (t = JSON.parse(JSON.stringify(t)));
+  var a = Math.pow(10, r);
+  return Ue(t, function(s) {
+    Pt(s, a, n);
+  }), t;
+}
+function Pt(t, e, r) {
+  t.length > r && t.splice(r, t.length);
+  for (var n = 0; n < t.length; n++)
+    t[n] = Math.round(t[n] * e) / e;
+  return t;
+}
+var Ut = kt;
+function Ge(t, e = 7) {
+  p.all([
+    { value: t, validator: le, message: "geometry must be a GeoJson geometry" },
+    { value: e, validator: (n) => f.inRange(n, 0, 8), message: "precision must be in range [0, 8]" }
   ]);
-  const n = _[t];
-  for (let r = 0; r < e.length; r++)
-    e[r] = Math.round(e[r] * n) / n;
-  return e;
+  const r = Ut(t, { precision: e, mutate: !0 });
+  return r.bbox && Pe(r.bbox, e), r;
+}
+const Gt = xe(["common-ekosystem", "truncate", "geojson"]);
+function Fe(t, e) {
+  if (t.type === I.FEATURE)
+    t.geometry && Ge(t.geometry, e);
+  else if (t.type === I.FEATURE_COLLECTION)
+    for (const r of t.features) Fe(r, e);
+  else
+    Gt.warn('Unknown feature type "{type}", skipping.', { type: t.type });
+  return t.bbox && Pe(t.bbox, e), t;
+}
+function dr(t, e = 7) {
+  return p.all([
+    { value: t, validator: De, message: "geoJson must be a valid GeoJson" },
+    { value: e, validator: (r) => f.inRange(r, 0, 8), message: "precision must be in range [0, 8]" }
+  ]), f.oneOf(t.type, Object.values(v)) ? Ge(t, e) : Fe(t, e);
+}
+function mr(t, e = 7) {
+  p.all([
+    { value: t, validator: mt, message: "position must be a position" },
+    { value: e, validator: (n) => f.inRange(n, 0, 8), message: "precision must be in range [0, 8]" }
+  ]);
+  const r = oe[e];
+  for (let n = 0; n < t.length; n++)
+    t[n] = Math.round(t[n] * r) / r;
+  return t;
 }
-function I(e) {
-  if (!i.arrayOfLengthBetween(e, 2, 3))
+function j(t) {
+  if (!f.arrayOfLengthBetween(t, 2, 3))
     return {
       valid: !1,
       errors: [{ message: "Invalid coordinates: must be an array of 2 or 3 coordinates" }],
       warnings: []
     };
-  if (!i.inRange(e[0], -180, 180))
+  if (!f.inRange(t[0], -180, 180))
     return {
       valid: !1,
       errors: [{ message: "Invalid coordinates: longitude must be in the range -180 to 180" }],
       warnings: []
     };
-  if (!i.inRange(e[1], -90, 90))
+  if (!f.inRange(t[1], -90, 90))
     return {
       valid: !1,
       errors: [{ message: "Invalid coordinates: latitude must be in the range -90 to 90" }],
       warnings: []
     };
-  if (e.length === 3 && !i.number(e[2]))
+  if (t.length === 3 && !f.number(t[2]))
     return {
       valid: !1,
       errors: [{ message: "Invalid coordinates: altitude must be a number" }],
       warnings: []
     };
-  const t = { valid: !0, errors: [], warnings: [] }, n = H(e[0]);
-  n > 6 && t.warnings.push({ message: `longitude precision is high (${n} decimals, max recommended: 6)` });
-  const r = H(e[1]);
-  return r > 6 && t.warnings.push({ message: `latitude precision is high (${r} decimals, max recommended: 6)` }), t;
+  const e = { valid: !0, errors: [], warnings: [] }, r = de(t[0]);
+  r > 6 && e.warnings.push({ message: `longitude precision is high (${r} decimals, max recommended: 6)` });
+  const n = de(t[1]);
+  return n > 6 && e.warnings.push({ message: `latitude precision is high (${n} decimals, max recommended: 6)` }), e;
 }
-function Re(e) {
-  if (!i.arrayOfLength(e, 4) && !i.arrayOfLength(e, 6))
+function Ft(t) {
+  if (!f.arrayOfLength(t, 4) && !f.arrayOfLength(t, 6))
     return {
       valid: !1,
       errors: [{ message: "Invalid bbox: must be an array of 4 (2D) or 6 (3D) numbers" }],
       warnings: []
     };
-  const t = e.length === 4, n = t ? [e[0], e[1]] : [e[0], e[1], e[2]], r = t ? [e[2], e[3]] : [e[3], e[4], e[5]], s = I(n);
-  if (!s.valid)
+  const e = t.length === 4, r = e ? [t[0], t[1]] : [t[0], t[1], t[2]], n = e ? [t[2], t[3]] : [t[3], t[4], t[5]], i = j(r);
+  if (!i.valid)
     return {
       valid: !1,
-      errors: s.errors.map((g) => ({ ...g, message: `Invalid bbox south-west: ${g.message}` })),
+      errors: i.errors.map((h) => ({ ...h, message: `Invalid bbox south-west: ${h.message}` })),
       warnings: []
     };
-  const a = I(r);
+  const a = j(n);
   if (!a.valid)
     return {
       valid: !1,
-      errors: a.errors.map((g) => ({ ...g, message: `Invalid bbox north-east: ${g.message}` })),
+      errors: a.errors.map((h) => ({ ...h, message: `Invalid bbox north-east: ${h.message}` })),
       warnings: []
     };
-  const [o, u] = n, [c, f] = r;
-  if (u > f)
+  const [s, l] = r, [u, o] = n;
+  if (l > o)
     return {
       valid: !1,
-      errors: [{ message: `Invalid bbox: south (${u}) must be <= north (${f})` }],
+      errors: [{ message: `Invalid bbox: south (${l}) must be <= north (${o})` }],
       warnings: []
     };
-  const m = { valid: !0, errors: [], warnings: [] };
-  return o > c && m.warnings.push({ message: `bbox crosses the antimeridian (west: ${o} > east: ${c})` }), m.warnings.push(...s.warnings.map((g) => ({ ...g, message: `south-west: ${g.message}` }))), m.warnings.push(...a.warnings.map((g) => ({ ...g, message: `north-east: ${g.message}` }))), m;
+  const c = { valid: !0, errors: [], warnings: [] };
+  return s > u && c.warnings.push({ message: `bbox crosses the antimeridian (west: ${s} > east: ${u})` }), c.warnings.push(...i.warnings.map((h) => ({ ...h, message: `south-west: ${h.message}` }))), c.warnings.push(...a.warnings.map((h) => ({ ...h, message: `north-east: ${h.message}` }))), c;
 }
-function we(e) {
-  if (!i.plainObject(e))
+function Ht(t) {
+  if (!f.plainObject(t))
     return {
       valid: !1,
       errors: [{ message: "Invalid crs: must be an object" }],
       warnings: []
     };
-  switch (e.type) {
-    case D.NAME:
-      return i.nonEmptyString(e.properties?.name) ? { valid: !0, errors: [], warnings: [] } : {
+  switch (t.type) {
+    case z.NAME:
+      return f.nonEmptyString(t.properties?.name) ? { valid: !0, errors: [], warnings: [] } : {
         valid: !1,
         errors: [{ message: "Invalid crs: linked crs must have a non-empty properties.name string" }],
         warnings: []
       };
-    case D.LINK:
-      return i.nonEmptyString(e.properties?.href) ? { valid: !0, errors: [], warnings: [] } : {
+    case z.LINK:
+      return f.nonEmptyString(t.properties?.href) ? { valid: !0, errors: [], warnings: [] } : {
         valid: !1,
         errors: [{ message: "Invalid crs: linked crs must have a non-empty properties.href string" }],
         warnings: []
@@ -495,334 +2283,351 @@ function we(e) {
     default:
       return {
         valid: !1,
-        errors: [{ message: `Invalid crs: unknown type: ${e.type}` }],
+        errors: [{ message: `Invalid crs: unknown type: ${t.type}` }],
         warnings: []
       };
   }
 }
-function Ne(e, t, n = {}) {
-  const r = { type: "Feature" };
-  return (n.id === 0 || n.id) && (r.id = n.id), n.bbox && (r.bbox = n.bbox), r.properties = {}, r.geometry = e, r;
-}
-function Ae(e, t, n = {}) {
-  if (!e)
-    throw new Error("coordinates is required");
-  if (!Array.isArray(e))
-    throw new Error("coordinates must be an Array");
-  if (e.length < 2)
-    throw new Error("coordinates must be at least 2 numbers long");
-  if (!V(e[0]) || !V(e[1]))
-    throw new Error("coordinates must contain numbers");
-  return Ne({
-    type: "Point",
-    coordinates: e
-  }, t, n);
-}
-function V(e) {
-  return !isNaN(e) && e !== null && !Array.isArray(e);
-}
-function Me(e) {
-  if (Array.isArray(e))
-    return e;
-  if (e.type === "Feature") {
-    if (e.geometry !== null)
-      return e.geometry.coordinates;
-  } else if (e.coordinates)
-    return e.coordinates;
+function qt(t) {
+  if (Array.isArray(t))
+    return t;
+  if (t.type === "Feature") {
+    if (t.geometry !== null)
+      return t.geometry.coordinates;
+  } else if (t.coordinates)
+    return t.coordinates;
   throw new Error(
     "coords must be GeoJSON Feature, Geometry Object or an Array"
   );
 }
-function Ce(e) {
-  const t = Me(e);
-  let n = 0, r = 1, s, a;
-  for (; r < t.length; )
-    s = a || t[0], a = t[r], n += (a[0] - s[0]) * (a[1] + s[1]), r++;
-  return n > 0;
-}
-var $e = Ce;
-function _e(e) {
-  let t, n;
-  const r = {
+function zt(t) {
+  const e = qt(t);
+  let r = 0, n = 1, i, a;
+  for (; n < e.length; )
+    i = a || e[0], a = e[n], r += (a[0] - i[0]) * (a[1] + i[1]), n++;
+  return r > 0;
+}
+var jt = zt;
+function Wt(t) {
+  let e, r;
+  const n = {
     type: "FeatureCollection",
     features: []
   };
-  if (e.type === "Feature" ? n = e.geometry : n = e, n.type === "LineString")
-    t = [n.coordinates];
-  else if (n.type === "MultiLineString")
-    t = n.coordinates;
-  else if (n.type === "MultiPolygon")
-    t = [].concat(...n.coordinates);
-  else if (n.type === "Polygon")
-    t = n.coordinates;
+  if (t.type === "Feature" ? r = t.geometry : r = t, r.type === "LineString")
+    e = [r.coordinates];
+  else if (r.type === "MultiLineString")
+    e = r.coordinates;
+  else if (r.type === "MultiPolygon")
+    e = [].concat(...r.coordinates);
+  else if (r.type === "Polygon")
+    e = r.coordinates;
   else
     throw new Error(
       "Input must be a LineString, MultiLineString, Polygon, or MultiPolygon Feature or Geometry"
     );
-  return t.forEach((s) => {
-    t.forEach((a) => {
-      for (let o = 0; o < s.length - 1; o++)
-        for (let u = o; u < a.length - 1; u++) {
-          if (s === a && (Math.abs(o - u) === 1 || // segments are first and last segment of lineString
-          o === 0 && u === s.length - 2 && // lineString is closed
-          s[o][0] === s[s.length - 1][0] && s[o][1] === s[s.length - 1][1]))
+  return e.forEach((i) => {
+    e.forEach((a) => {
+      for (let s = 0; s < i.length - 1; s++)
+        for (let l = s; l < a.length - 1; l++) {
+          if (i === a && (Math.abs(s - l) === 1 || // segments are first and last segment of lineString
+          s === 0 && l === i.length - 2 && // lineString is closed
+          i[s][0] === i[i.length - 1][0] && i[s][1] === i[i.length - 1][1]))
             continue;
-          const c = Ue(
-            s[o][0],
-            s[o][1],
-            s[o + 1][0],
-            s[o + 1][1],
-            a[u][0],
-            a[u][1],
-            a[u + 1][0],
-            a[u + 1][1]
+          const u = Vt(
+            i[s][0],
+            i[s][1],
+            i[s + 1][0],
+            i[s + 1][1],
+            a[l][0],
+            a[l][1],
+            a[l + 1][0],
+            a[l + 1][1]
           );
-          c && r.features.push(Ae([c[0], c[1]]));
+          u && n.features.push(Mt([u[0], u[1]]));
         }
     });
-  }), r;
+  }), n;
 }
-function Ue(e, t, n, r, s, a, o, u) {
-  let c, f, m, g, x;
-  const E = {
+function Vt(t, e, r, n, i, a, s, l) {
+  let u, o, c, h, g;
+  const m = {
     x: null,
     y: null,
     onLine1: !1,
     onLine2: !1
   };
-  return c = (u - a) * (n - e) - (o - s) * (r - t), c === 0 ? E.x !== null && E.y !== null ? E : !1 : (f = t - a, m = e - s, g = (o - s) * f - (u - a) * m, x = (n - e) * f - (r - t) * m, f = g / c, m = x / c, E.x = e + f * (n - e), E.y = t + f * (r - t), f >= 0 && f <= 1 && (E.onLine1 = !0), m >= 0 && m <= 1 && (E.onLine2 = !0), E.onLine1 && E.onLine2 ? [E.x, E.y] : !1);
-}
-var Ge = _e;
-function xe(e, t) {
-  if (!i.defined(e.crs)) return t;
-  const n = we(e.crs);
-  return n.valid || (t.valid = !1, t.errors.push(...n.errors.map((r) => ({ ...r, path: "/crs" })))), t.warnings.push(...n.warnings.map((r) => ({ ...r, path: "/crs" }))), t;
-}
-function A(e, t, n = "") {
-  if (!i.defined(e.bbox)) return t;
-  const r = Re(e.bbox);
-  return r.valid || (t.valid = !1, t.errors.push(...r.errors.map((s) => ({ ...s, path: `${n}/bbox` })))), t.warnings.push(...r.warnings.map((s) => ({ ...s, path: `${n}/bbox` }))), t;
+  return u = (l - a) * (r - t) - (s - i) * (n - e), u === 0 ? m.x !== null && m.y !== null ? m : !1 : (o = e - a, c = t - i, h = (s - i) * o - (l - a) * c, g = (r - t) * o - (n - e) * c, o = h / u, c = g / u, m.x = t + o * (r - t), m.y = e + o * (n - e), o >= 0 && o <= 1 && (m.onLine1 = !0), c >= 0 && c <= 1 && (m.onLine2 = !0), m.onLine1 && m.onLine2 ? [m.x, m.y] : !1);
+}
+var Bt = Wt;
+function $() {
+  return { Feature: 0, FeatureCollection: 0, geometries: {} };
+}
+function Kt(...t) {
+  const e = $();
+  for (const r of t) {
+    const n = r.statistics;
+    if (n) {
+      e.Feature += n.Feature ?? 0, e.FeatureCollection += n.FeatureCollection ?? 0;
+      for (const [i, a] of Object.entries(n.geometries ?? {}))
+        e.geometries[i] = (e.geometries[i] ?? 0) + a;
+    }
+  }
+  return e;
 }
-function b(e, t, n = "") {
-  const r = {
+function M(t, e, r = "") {
+  const n = {
     valid: !0,
     errors: [],
     warnings: []
   };
-  for (let s = 0; s < e.length; s++) {
-    const a = `${n}/${s}`, o = t(e[s], a, s);
-    if (!o.valid) {
-      r.valid = !1, r.errors = r.errors.concat(o.errors.map((u) => ({ ...u, path: u.path || a, index: s })));
+  for (let i = 0; i < t.length; i++) {
+    const a = `${r}/${i}`, s = e(t[i], a, i);
+    if (!s.valid) {
+      n.valid = !1, n.errors = n.errors.concat(s.errors.map((l) => ({ ...l, path: l.path || a, index: i })));
       continue;
     }
-    i.empty(o.warnings) || (r.warnings = r.warnings.concat(o.warnings.map((u) => ({ ...u, path: u.path || a, index: s }))));
+    f.empty(s.warnings) || (n.warnings = n.warnings.concat(s.warnings.map((l) => ({ ...l, path: l.path || a, index: i })))), s.statistics && (n.statistics = Kt(n, s));
   }
-  return r;
+  return n;
+}
+function Zt(t, e) {
+  if (!f.defined(t.crs)) return e;
+  const r = Ht(t.crs);
+  return r.valid || (e.valid = !1, e.errors.push(...r.errors.map((n) => ({ ...n, path: "/crs" })))), e.warnings.push(...r.warnings.map((n) => ({ ...n, path: "/crs" }))), e;
 }
-function U(e, t = 0, n = "") {
-  return i.arrayOfLengthAtLeast(e, t) ? b(e, I, n) : {
+function ne(t, e, r = "") {
+  if (!f.defined(t.bbox)) return e;
+  const n = Ft(t.bbox);
+  return n.valid || (e.valid = !1, e.errors.push(...n.errors.map((i) => ({ ...i, path: `${r}/bbox` })))), e.warnings.push(...n.warnings.map((i) => ({ ...i, path: `${r}/bbox` }))), e;
+}
+function ce(t, e = 0, r = "") {
+  return f.arrayOfLengthAtLeast(t, e) ? M(t, j, r) : {
     valid: !1,
-    errors: [{ message: `Invalid coordinates: must have at least ${t} positions`, path: n }],
+    errors: [{ message: `Invalid coordinates: must have at least ${e} positions`, path: r }],
     warnings: []
   };
 }
-function z(e, t = "") {
-  const n = U(e, 2, t);
-  if (!n.valid) return n;
-  for (let r = 0; r < e.length - 1; r++) {
-    const s = e[r][0], a = e[r + 1][0];
-    Math.abs(a - s) > 180 && n.warnings.push({
-      message: `LineString crosses the antimeridian between positions ${r} and ${r + 1}, consider using MultiLineString`,
-      path: `${t}/${r}`
+function He(t, e = "") {
+  const r = ce(t, 2, e);
+  if (!r.valid) return r;
+  for (let n = 0; n < t.length - 1; n++) {
+    const i = t[n][0], a = t[n + 1][0];
+    Math.abs(a - i) > 180 && r.warnings.push({
+      message: `LineString crosses the antimeridian between positions ${n} and ${n + 1}, consider using MultiLineString`,
+      path: `${e}/${n}`
     });
   }
-  return n;
+  return r;
 }
-function Fe(e, t = "") {
-  return i.nonEmptyArray(e) ? b(e, z, t) : {
+function Yt(t, e = "") {
+  return f.nonEmptyArray(t) ? M(t, He, e) : {
     valid: !1,
-    errors: [{ message: "Invalid MultiLineString: coordinates must be a non empty array", path: t }],
+    errors: [{ message: "Invalid MultiLineString: coordinates must be a non empty array", path: e }],
     warnings: []
   };
 }
-function ke(e, t, n = "") {
-  const r = U(e, 4, n);
-  if (!r.valid) return r;
-  const s = e[0], a = e[e.length - 1];
-  if (s[0] !== a[0] || s[1] !== a[1])
-    return r.valid = !1, r.errors.push({ message: "Invalid LinearRing: first and last position must be identical", path: n }), r;
-  const u = $e(e) ? "clockwise" : "counter-clockwise";
-  u !== t && r.warnings.push({ message: `Ring must be ${t} but is ${u}`, path: n });
-  const c = Ge({ type: "Polygon", coordinates: [e] });
-  return c.features.length > 0 && (r.valid = !1, r.errors.push({ message: `Invalid LinearRing: ${c.features.length} self-intersection(s) detected`, path: n })), r;
-}
-function Q(e, t = "") {
-  return i.nonEmptyArray(e) ? b(e, (n, r, s) => ke(n, s === 0 ? "counter-clockwise" : "clockwise", r), t) : {
+function Jt(t, e, r = "") {
+  const n = ce(t, 4, r);
+  if (!n.valid) return n;
+  const i = t[0], a = t[t.length - 1];
+  if (i[0] !== a[0] || i[1] !== a[1])
+    return n.valid = !1, n.errors.push({ message: "Invalid LinearRing: first and last position must be identical", path: r }), n;
+  const l = jt(t) ? "clockwise" : "counter-clockwise";
+  l !== e && n.warnings.push({ message: `Ring must be ${e} but is ${l}`, path: r });
+  const u = Bt({ type: "Polygon", coordinates: [t] });
+  return u.features.length > 0 && (n.valid = !1, n.errors.push({ message: `Invalid LinearRing: ${u.features.length} self-intersection(s) detected`, path: r })), n;
+}
+function qe(t, e = "") {
+  return f.nonEmptyArray(t) ? M(t, (r, n, i) => Jt(r, i === 0 ? "counter-clockwise" : "clockwise", n), e) : {
     valid: !1,
-    errors: [{ message: "Invalid Polygon: coordinates must be a non empty array", path: t }],
+    errors: [{ message: "Invalid Polygon: coordinates must be a non empty array", path: e }],
     warnings: []
   };
 }
-function Pe(e, t = "") {
-  return i.nonEmptyArray(e) ? b(e, (n, r) => Q(n, r), t) : {
+function Qt(t, e = "") {
+  return f.nonEmptyArray(t) ? M(t, (r, n) => qe(r, n), e) : {
     valid: !1,
-    errors: [{ message: "Invalid MultiPolygon: coordinates must be a non empty array", path: t }],
+    errors: [{ message: "Invalid MultiPolygon: coordinates must be a non empty array", path: e }],
     warnings: []
   };
 }
-function He(e, t = "") {
-  return i.nonEmptyArray(e) ? b(e, (n, r) => G(n, r), t) : {
+function Xt(t, e = "") {
+  return f.nonEmptyArray(t) ? M(t, (r, n) => he(r, n), e) : {
     valid: !1,
-    errors: [{ message: "Invalid geometries: geometries must be a non empty array", path: t }],
+    errors: [{ message: "Invalid geometries: geometries must be a non empty array", path: e }],
     warnings: []
   };
 }
-function G(e, t = "") {
-  if (!i.nonEmptyObject(e))
+function he(t, e = "") {
+  if (!f.nonEmptyObject(t))
     return {
       valid: !1,
-      errors: [{ message: "Invalid geometry: geometry must be a non empty object", path: t }],
+      errors: [{ message: "Invalid geometry: geometry must be a non empty object", path: e }],
       warnings: []
     };
-  const n = `${t}/coordinates`;
-  let r;
-  switch (e.type) {
-    case p.POINT: {
-      const s = I(e.coordinates);
-      r = {
-        valid: s.valid,
-        errors: s.errors.map((a) => ({ ...a, path: n })),
-        warnings: s.warnings.map((a) => ({ ...a, path: n }))
+  const r = `${e}/coordinates`;
+  let n;
+  switch (t.type) {
+    case v.POINT: {
+      const i = j(t.coordinates);
+      n = {
+        valid: i.valid,
+        errors: i.errors.map((a) => ({ ...a, path: r })),
+        warnings: i.warnings.map((a) => ({ ...a, path: r }))
       };
       break;
     }
-    case p.MULTI_POINT: {
-      r = U(e.coordinates, 0, n);
+    case v.MULTI_POINT: {
+      n = ce(t.coordinates, 0, r);
       break;
     }
-    case p.LINESTRING: {
-      r = z(e.coordinates, n);
+    case v.LINESTRING: {
+      n = He(t.coordinates, r);
       break;
     }
-    case p.MULTI_LINESTRING: {
-      r = Fe(e.coordinates, n);
+    case v.MULTI_LINESTRING: {
+      n = Yt(t.coordinates, r);
       break;
     }
-    case p.POLYGON: {
-      r = Q(e.coordinates, n);
+    case v.POLYGON: {
+      n = qe(t.coordinates, r);
       break;
     }
-    case p.MULTI_POLYGON: {
-      r = Pe(e.coordinates, n);
+    case v.MULTI_POLYGON: {
+      n = Qt(t.coordinates, r);
       break;
     }
-    case p.GEOMETRY_COLLECTION: {
-      r = He(e.geometries, `${t}/geometries`);
+    case v.GEOMETRY_COLLECTION: {
+      n = Xt(t.geometries, `${e}/geometries`);
       break;
     }
     default:
       return {
         valid: !1,
-        errors: [{ message: `Invalid geometry type: ${e.type}`, path: t }],
+        errors: [{ message: `Invalid geometry type: ${t.type}`, path: e }],
         warnings: []
       };
   }
-  return A(e, r, t);
+  return ne(t, n, e);
 }
-function X(e, t = "") {
-  if (!i.nonEmptyObject(e))
+function ze(t, e = "") {
+  if (!f.nonEmptyObject(t))
     return {
       valid: !1,
-      errors: [{ message: "Invalid feature: must be a non empty object", path: t }],
-      warnings: []
+      errors: [{ message: "Invalid feature: must be a non empty object", path: e }],
+      warnings: [],
+      statistics: $()
     };
-  if (e.type === h.FEATURE) {
-    if (i.nonEmptyObject(e.geometry)) {
-      const n = G(e.geometry, `${t}/geometry`);
-      return A(e, n, t);
+  if (t.type === I.FEATURE) {
+    if (f.nonEmptyObject(t.geometry)) {
+      const r = he(t.geometry, `${e}/geometry`);
+      return {
+        ...ne(t, r, e),
+        statistics: {
+          Feature: 1,
+          FeatureCollection: 0,
+          geometries: { [t.geometry.type]: 1 }
+        }
+      };
     }
     return {
       valid: !0,
       errors: [],
-      warnings: [{ message: "Feature has no geometry", path: t }]
+      warnings: [{ message: "Feature has no geometry", path: e }],
+      statistics: { Feature: 1, FeatureCollection: 0, geometries: {} }
     };
   }
-  if (e.type === h.FEATURE_COLLECTION) {
-    if (i.nonEmptyArray(e.features)) {
-      const n = b(e.features, X, `${t}/features`);
-      return A(e, n, t);
+  if (t.type === I.FEATURE_COLLECTION) {
+    if (f.nonEmptyArray(t.features)) {
+      const r = M(t.features, ze, `${e}/features`);
+      return {
+        ...ne(t, r, e),
+        statistics: { ...r.statistics, FeatureCollection: r.statistics.FeatureCollection + 1 }
+      };
     }
     return {
       valid: !1,
-      errors: [{ message: "Invalid FeatureCollection: features must be a non empty array", path: t }],
-      warnings: []
+      errors: [{ message: "Invalid FeatureCollection: features must be a non empty array", path: e }],
+      warnings: [],
+      statistics: $()
     };
   }
   return {
     valid: !1,
-    errors: [{ message: `Invalid feature: unknown type: ${e.type}`, path: t }],
-    warnings: []
+    errors: [{ message: `Invalid feature: unknown type: ${t.type}`, path: e }],
+    warnings: [],
+    statistics: $()
   };
 }
-function at(e) {
-  if (l.that(e, i.nonEmptyObject, "geojson must be a non empty object"), i.oneOf(e.type, Object.values(p))) return G(e, "");
-  if (e.type === h.FEATURE || e.type === h.FEATURE_COLLECTION) {
-    const t = X(e, "");
-    return xe(e, t);
+function vr(t) {
+  if (p.that(t, f.nonEmptyObject, "geojson must be a non empty object"), f.oneOf(t.type, Object.values(v)))
+    return {
+      ...he(t, ""),
+      statistics: { Feature: 0, FeatureCollection: 0, geometries: { [t.type]: 1 } }
+    };
+  if (t.type === I.FEATURE || t.type === I.FEATURE_COLLECTION) {
+    const e = ze(t, "");
+    return Zt(t, e);
   }
   return {
     valid: !1,
     errors: [{ message: "Invalid GeoJson: type must be either a Geometry, a Feature or a FeatureCollection" }],
-    warnings: []
+    warnings: [],
+    statistics: $()
   };
 }
 export {
-  d as AXES,
-  N as COORDINATE_FORMATS,
-  be as COORDINATE_MODELS,
-  _ as COORDINATE_TRUNCATION_FACTORS,
-  D as CRS_TYPES,
-  h as FEATURE_TYPES,
-  p as GEOMETRY_TYPES,
-  et as convertCoordinate,
-  H as getCoordinatePrecision,
-  ae as getDirectionAxis,
-  Ye as getDirections,
-  Qe as getEast,
-  ie as getLocale,
-  qe as getNorth,
-  ze as getSouth,
-  Xe as getWest,
-  P as guessCoordinateAxis,
-  We as isAltitude,
-  Z as isAxis,
-  v as isDirection,
-  j as isEast,
-  R as isLatitude,
-  Te as isLikeBBox,
-  nt as isLikeCRS,
-  De as isLikeFeature,
-  Ie as isLikeFeatureCollection,
-  rt as isLikeGeoJson,
-  Le as isLikeGeometry,
-  Se as isLikePosition,
-  W as isLongitude,
-  se as isNorth,
-  B as isSouth,
-  $ as isWest,
-  Be as listLocales,
-  Je as normalizeCoordinate,
-  Oe as parseCoordinate,
-  tt as parsePosition,
-  je as registerLocale,
-  Ke as setLocale,
-  it as truncateBBox,
-  Ze as truncateCoordinate,
-  st as truncatePosition,
-  Re as validateBBox,
-  we as validateCRS,
-  at as validateGeoJson,
-  G as validateGeometry,
-  I as validatePosition
+  w as AXES,
+  re as COORDINATE_FORMATS,
+  ht as COORDINATE_MODELS,
+  oe as COORDINATE_TRUNCATION_FACTORS,
+  z as CRS_TYPES,
+  I as FEATURE_TYPES,
+  v as GEOMETRY_TYPES,
+  hr as convertCoordinate,
+  de as getCoordinatePrecision,
+  Qe as getDirectionAxis,
+  ar as getDirections,
+  lr as getEast,
+  Ye as getLocale,
+  sr as getNorth,
+  or as getSouth,
+  ur as getWest,
+  ye as guessCoordinateAxis,
+  tr as isAltitude,
+  je as isAxis,
+  D as isDirection,
+  Te as isEast,
+  ee as isLatitude,
+  gt as isLikeBBox,
+  gr as isLikeCRS,
+  yt as isLikeFeature,
+  dt as isLikeFeatureCollection,
+  De as isLikeGeoJson,
+  le as isLikeGeometry,
+  mt as isLikePosition,
+  Se as isLongitude,
+  Je as isNorth,
+  Le as isSouth,
+  se as isWest,
+  rr as listLocales,
+  cr as normalizeCoordinate,
+  pt as parseCoordinate,
+  pr as parsePosition,
+  nr as registerLocale,
+  ir as setLocale,
+  yr as simplifyGeoJson,
+  fe as simplifyGeometry,
+  Pe as truncateBBox,
+  fr as truncateCoordinate,
+  dr as truncateGeoJson,
+  Ge as truncateGeometry,
+  mr as truncatePosition,
+  Ft as validateBBox,
+  Ht as validateCRS,
+  vr as validateGeoJson,
+  he as validateGeometry,
+  j as validatePosition
 };
 //# sourceMappingURL=index.mjs.map