@kalisio/common-geospatial 0.9.0 → 0.10.0

package/dist/geojson-CJ6QZ9pN.js

@@ -0,0 +1,647 @@
+import { coordAll as g } from "@turf/meta";
+import { ag as a, S as ie, aj as L, ah as v, ak as C, d as P, am as te, f as se, a7 as X, a8 as K, F as z, D as T, W as ae, a1 as oe, x as ce, X as le, l as b, G as ue, N as fe } from "./ring-Cks2pGr8.js";
+import de from "@turf/buffer";
+import { Heap as Ie } from "heap-js";
+const R = {
+  NAME: "name",
+  LINK: "link"
+}, d = {
+  POINT: "Point",
+  MULTI_POINT: "MultiPoint",
+  LINESTRING: "LineString",
+  MULTI_LINESTRING: "MultiLineString",
+  POLYGON: "Polygon",
+  MULTI_POLYGON: "MultiPolygon",
+  GEOMETRY_COLLECTION: "GeometryCollection"
+}, N = {
+  FEATURE: "Feature",
+  FEATURE_COLLECTION: "FeatureCollection"
+};
+function be(e) {
+  return a.plainObject(e) ? e.type === R.NAME ? a.nonEmptyString(e.properties?.name) : e.type === R.LINK ? a.nonEmptyString(e.properties?.href) : !1 : !1;
+}
+function Be(e) {
+  return ie(e);
+}
+function xe(e) {
+  return !a.arrayOfLength(e, 4) && !a.arrayOfLength(e, 6) ? !1 : e.every(a.number);
+}
+function Ee(e) {
+  return !a.plainObject(e) || !a.oneOf(e.type, Object.values(d)) ? !1 : e.type === d.GEOMETRY_COLLECTION ? a.array(e.geometries) : a.array(e.coordinates);
+}
+function Oe(e) {
+  return a.plainObject(e) && e.type === N.FEATURE;
+}
+function Ne(e) {
+  return a.plainObject(e) && e.type === N.FEATURE_COLLECTION && a.array(e.features);
+}
+function Le(e) {
+  return Oe(e) || Ne(e);
+}
+function U(e) {
+  return Le(e) || Ee(e);
+}
+const Te = {
+  ignore3D: L(a.boolean)
+};
+function He(e, r = {}) {
+  if (v.all([
+    { value: e, validator: U, message: "geoJson must be a GeoJson object" },
+    { value: r, validator: (i) => C.schema(i, Te), message: "options must be a valid options object" }
+  ]), e.type === N.FEATURE)
+    return e.geometry ? P(g(e.geometry), r) : null;
+  if (e.type === N.FEATURE_COLLECTION) {
+    const i = g(e);
+    return i.length ? P(i, r) : null;
+  }
+  return P(g(e), r);
+}
+const s = Object.freeze(
+  Object.fromEntries(
+    Object.keys(te.VALIDATION).map((e) => [e, e])
+  )
+), pe = [d.POLYGON, d.MULTI_POLYGON], _e = [
+  d.LINESTRING,
+  d.MULTI_LINESTRING,
+  d.POLYGON,
+  d.MULTI_POLYGON
+], w = [
+  s.INVALID_WINDING_ORDER,
+  s.SELF_INTERSECTION,
+  s.HOLE_INTERSECTS_SHELL,
+  s.DUPLICATE_POSITION
+], Se = {
+  validation: a.nonEmptyObject,
+  windingOrder: L(a.boolean),
+  selfIntersection: L(a.boolean),
+  holeIntersectsShell: L(a.boolean),
+  duplicatePosition: L(a.boolean),
+  precision: L(a.positive)
+};
+function B(e, r) {
+  return z(e) !== r ? (e.reverse(), !0) : !1;
+}
+function x(e) {
+  let r = !1;
+  B(e[0], !1) && (r = !0);
+  for (let i = 1; i < e.length; i++)
+    B(e[i], !0) && (r = !0);
+  return r;
+}
+function ve(e) {
+  if (e.type === d.POLYGON)
+    return x(e.coordinates);
+  let r = !1;
+  for (const i of e.coordinates)
+    x(i) && (r = !0);
+  return r;
+}
+function me(e) {
+  return e.type === d.POLYGON ? e.coordinates : e.coordinates.flat(1);
+}
+function Re(e) {
+  return e.type === d.POLYGON ? [e.coordinates] : e.coordinates;
+}
+function H(e) {
+  return me(e).some((r) => X(r).length > 0);
+}
+function $(e) {
+  return Re(e).some((r) => {
+    const i = r[0];
+    for (let n = 1; n < r.length; n++)
+      if (K(i, r[n])) return !0;
+    return !1;
+  });
+}
+function Ae(e) {
+  const i = de({ type: "Feature", properties: {}, geometry: e }, 0);
+  return i ? { type: i.geometry.type, coordinates: i.geometry.coordinates } : null;
+}
+function Ce(e, r) {
+  let i = !1;
+  const n = (t) => {
+    const c = t.length, o = se(t, { precision: r });
+    return o.length !== c && (i = !0), o;
+  };
+  switch (e.type) {
+    case d.LINESTRING:
+      e.coordinates = n(e.coordinates);
+      break;
+    case d.MULTI_LINESTRING:
+      e.coordinates = e.coordinates.map(n);
+      break;
+    case d.POLYGON:
+      e.coordinates = e.coordinates.map(n);
+      break;
+    case d.MULTI_POLYGON:
+      e.coordinates = e.coordinates.map((t) => t.map(n));
+      break;
+  }
+  return i;
+}
+function ge(e, r) {
+  const i = r.selfIntersection, n = r.holeIntersectsShell;
+  if (!i && !n) return [];
+  const t = i && H(e), c = n && $(e), o = [];
+  if (i && !t && o.push(s.SELF_INTERSECTION), n && !c && o.push(s.HOLE_INTERSECTS_SHELL), !t && !c) return o;
+  const l = Ae(e);
+  return !l || t && H(l) || c && $(l) || (e.type = l.type, e.coordinates = l.coordinates, t && o.push(s.SELF_INTERSECTION), c && o.push(s.HOLE_INTERSECTS_SHELL)), o;
+}
+function Pe(e, r) {
+  const i = [], n = r.precision ?? T;
+  if (r.duplicatePosition && _e.includes(e.type) && Ce(e, n) && i.push({ code: s.DUPLICATE_POSITION }), !pe.includes(e.type))
+    return { fixed: e, corrections: i };
+  r.windingOrder && ve(e) && i.push({ code: s.INVALID_WINDING_ORDER });
+  for (const t of ge(e, r))
+    i.push({ code: t });
+  return { fixed: e, corrections: i };
+}
+function D(e, r) {
+  return e.filter((i) => i.path === r || i.path?.startsWith(`${r}/`));
+}
+function y(e, r, i, n) {
+  const t = {
+    windingOrder: n.windingOrder !== !1 && r.some((I) => I.code === s.INVALID_WINDING_ORDER),
+    selfIntersection: n.selfIntersection !== !1 && r.some((I) => I.code === s.SELF_INTERSECTION),
+    holeIntersectsShell: n.holeIntersectsShell !== !1 && r.some((I) => I.code === s.HOLE_INTERSECTS_SHELL),
+    duplicatePosition: n.duplicatePosition !== !1 && r.some((I) => I.code === s.DUPLICATE_POSITION),
+    precision: n.precision
+  }, c = t.windingOrder || t.selfIntersection || t.holeIntersectsShell || t.duplicatePosition ? Pe(e, t) : { corrections: [] }, o = new Set(c.corrections.map((I) => I.code)), l = c.corrections.map((I) => ({ ...I, path: i })), E = r.filter((I) => !o.has(I.code));
+  return { corrections: l, unfixed: E };
+}
+function $e(e, r) {
+  v.all([
+    {
+      value: e,
+      validator: U,
+      message: "geoJson must be a GeoJson object"
+    },
+    {
+      value: r,
+      validator: (l) => C.schema(l, Se),
+      message: "options must be a valid options object, with a mandatory validation result"
+    }
+  ]);
+  const i = [...r.validation.errors, ...r.validation.warnings], n = i.filter((l) => w.includes(l.code)), t = i.filter((l) => !w.includes(l.code));
+  if (n.length === 0) return { fixed: e, corrections: [], unfixed: t };
+  if (e.type === N.FEATURE_COLLECTION) {
+    const l = [];
+    return e.features.forEach((E, I) => {
+      const u = `/features/${I}/geometry`, f = D(n, u);
+      if (f.length === 0) return;
+      const _ = y(E.geometry, f, u, r);
+      l.push(..._.corrections), t.push(..._.unfixed);
+    }), { fixed: e, corrections: l, unfixed: t };
+  }
+  if (e.type === N.FEATURE) {
+    const l = D(n, "/geometry"), E = y(e.geometry, l, "/geometry", r);
+    return { fixed: e, corrections: E.corrections, unfixed: [...t, ...E.unfixed] };
+  }
+  const c = D(n, ""), o = y(e, c, "", r);
+  return { fixed: e, corrections: o.corrections, unfixed: [...t, ...o.unfixed] };
+}
+function je(e) {
+  return v.all([
+    {
+      value: e,
+      validator: a.nonEmptyObject,
+      message: "validation must be a non-empty object"
+    },
+    {
+      value: e?.errors,
+      validator: a.array,
+      message: "validation.errors must be an array"
+    }
+  ]), e.errors.length === 0 ? !1 : e.errors.every(
+    (r) => w.includes(r.code)
+  );
+}
+const De = {
+  tolerance: L(a.number),
+  getWeight: L(a.function)
+};
+function ye(e, r, i) {
+  return Math.abs(
+    (e[0] * (r[1] - i[1]) + r[0] * (i[1] - e[1]) + i[0] * (e[1] - r[1])) / 2
+  );
+}
+function G(e, { tolerance: r = 0, getWeight: i = () => 1 } = {}) {
+  if (e.length <= 2) return e;
+  const n = e.map((u, f) => ({ coord: u, i: f, area: 1 / 0, removed: !1, prev: null, next: null }));
+  for (let u = 0; u < n.length; u++)
+    u > 0 && (n[u].prev = n[u - 1]), u < n.length - 1 && (n[u].next = n[u + 1]);
+  const t = (u) => !u.prev || !u.next ? 1 / 0 : ye(u.prev.coord, u.coord, u.next.coord) * i(u.coord, u.i), c = new Ie((u, f) => u.area - f.area), o = (u) => {
+    u.area = t(u), c.push({ node: u, area: u.area });
+  };
+  for (let u = 1; u < n.length - 1; u++) o(n[u]);
+  let l = 0;
+  for (; c.size() > 0; ) {
+    const u = c.pop(), f = u.node;
+    if (!f.removed && u.area === f.area) {
+      if (f.area < l ? f.area = l : l = f.area, f.area >= r) break;
+      f.removed = !0, f.prev && (f.prev.next = f.next), f.next && (f.next.prev = f.prev), f.prev?.prev && o(f.prev), f.next?.next && o(f.next);
+    }
+  }
+  const E = [];
+  let I = n[0];
+  for (; I; )
+    I.removed || E.push(I.coord), I = I.next;
+  return E;
+}
+function h(e, r = {}) {
+  if (v.all([
+    { value: e, validator: U, message: "geoJson must be a GeoJson object" },
+    { value: r, validator: (i) => C.schema(i, De), message: "options must be a valid options object" }
+  ]), e.type === N.FEATURE)
+    return e.geometry && h(e.geometry, r), e;
+  if (e.type === N.FEATURE_COLLECTION) {
+    for (const i of e.features) h(i, r);
+    return e;
+  }
+  switch (e.type) {
+    case d.LINESTRING:
+      e.coordinates = G(e.coordinates, r);
+      break;
+    case d.POLYGON:
+    case d.MULTI_LINESTRING:
+      e.coordinates = e.coordinates.map((i) => G(i, r));
+      break;
+    case d.MULTI_POLYGON:
+      e.coordinates = e.coordinates.map((i) => i.map((n) => G(n, r)));
+      break;
+    case d.GEOMETRY_COLLECTION:
+      e.geometries.forEach((i) => h(i, r));
+      break;
+  }
+  return e;
+}
+const j = "/crs";
+function q(e, r = "", i = {}) {
+  if (!a.defined(e))
+    return r === j ? (i.geodesic = !0, { crs: ae, valid: !0 }) : { valid: !0 };
+  if (r !== j)
+    return {
+      valid: !1,
+      errors: [{ code: s.UNSUPPORTED_NESTED_CRS, path: r }],
+      warnings: []
+    };
+  if (!a.plainObject(e))
+    return {
+      valid: !1,
+      errors: [{ code: s.INVALID_CRS_OBJECT, path: r }],
+      warnings: []
+    };
+  switch (e.type) {
+    case R.NAME: {
+      if (!a.nonEmptyString(e.properties?.name))
+        return {
+          valid: !1,
+          errors: [{ code: s.INVALID_CRS_NAME, path: r }],
+          warnings: []
+        };
+      const n = oe(e.properties.name);
+      return ce(n) ? (i.geodesic = le(n), {
+        crs: n,
+        valid: !0,
+        errors: [],
+        warnings: []
+      }) : {
+        valid: !1,
+        errors: [{
+          code: s.UNSUPPORTED_CRS,
+          path: r,
+          params: { name: e.properties.name }
+        }],
+        warnings: []
+      };
+    }
+    case R.LINK:
+      return a.nonEmptyString(e.properties?.href) ? {
+        valid: !1,
+        errors: [{ code: s.UNSUPPORTED_LINK_CRS, path: r }],
+        warnings: []
+      } : {
+        valid: !1,
+        errors: [{ code: s.INVALID_CRS_LINK, path: r }],
+        warnings: []
+      };
+    default:
+      return {
+        valid: !1,
+        errors: [{
+          code: s.INVALID_CRS_TYPE,
+          path: r,
+          params: { type: e.type }
+        }],
+        warnings: []
+      };
+  }
+}
+function A(e, r = "", i = {}) {
+  const n = i.geodesic;
+  if (!a.arrayOfLengthBetween(e, 2, 3))
+    return {
+      valid: !1,
+      errors: [{ code: s.INVALID_POSITION_LENGTH, path: r }],
+      warnings: []
+    };
+  if (!a.number(e[0]) || !a.number(e[1]))
+    return {
+      valid: !1,
+      errors: [{ code: s.INVALID_POSITION_COORDINATES, path: r }],
+      warnings: []
+    };
+  if (n) {
+    if (!a.inRange(e[0], -180, 180))
+      return {
+        valid: !1,
+        errors: [{ code: s.INVALID_LONGITUDE_RANGE, path: r, params: { value: e[0] } }],
+        warnings: []
+      };
+    if (!a.inRange(e[1], -90, 90))
+      return {
+        valid: !1,
+        errors: [{ code: s.INVALID_LATITUDE_RANGE, path: r, params: { value: e[1] } }],
+        warnings: []
+      };
+  }
+  if (e.length === 3 && !a.number(e[2]))
+    return {
+      valid: !1,
+      errors: [{ code: s.INVALID_ALTITUDE, path: r }],
+      warnings: []
+    };
+  const t = { valid: !0, errors: [], warnings: [] };
+  if (n) {
+    const c = i.precision ?? T, o = b(e[0]);
+    o > c && t.warnings.push({ code: s.EXCESSIVE_LONGITUDE_PRECISION, path: r, params: { precision: o, max: c } });
+    const l = b(e[1]);
+    l > c && t.warnings.push({ code: s.EXCESSIVE_LATITUDE_PRECISION, path: r, params: { precision: l, max: c } });
+  }
+  return t;
+}
+function Q(e, r = "", i = {}) {
+  const n = i?.geodesic;
+  if (!a.defined(e))
+    return {
+      valid: !0
+    };
+  if (!a.arrayOfLength(e, 4) && !a.arrayOfLength(e, 6))
+    return {
+      valid: !1,
+      errors: [{ code: s.INVALID_BBOX_LENGTH, path: r }],
+      warnings: []
+    };
+  const t = e.length === 4, c = t ? [e[0], e[1]] : [e[0], e[1], e[2]], o = t ? [e[2], e[3]] : [e[3], e[4], e[5]], l = A(c, `${r}/min`, i);
+  if (!l.valid)
+    return { valid: !1, errors: l.errors, warnings: [] };
+  const E = A(o, `${r}/max`, i);
+  if (!E.valid)
+    return { valid: !1, errors: E.errors, warnings: [] };
+  const [I, u] = c, [f, _] = o;
+  if (u > _)
+    return {
+      valid: !1,
+      errors: [{ code: s.INVALID_BBOX_LATITUDE_ORDER, path: r, params: { south: u, north: _ } }],
+      warnings: []
+    };
+  if (!n && I > f)
+    return {
+      valid: !1,
+      errors: [{ code: s.INVALID_BBOX_LONGITUDE_ORDER, path: r, params: { west: I, east: f } }],
+      warnings: []
+    };
+  if (!t) {
+    const k = e[2], V = e[5];
+    if (k > V)
+      return {
+        valid: !1,
+        errors: [{ code: s.INVALID_BBOX_ALTITUDE_ORDER, path: r, params: { minAlt: k, maxAlt: V } }],
+        warnings: []
+      };
+  }
+  const m = { valid: !0, errors: [], warnings: [] };
+  return n && I > f && m.warnings.push({ code: s.BBOX_ANTIMERIDIAN_CROSSING, path: r, params: { west: I, east: f } }), m.warnings.push(...l.warnings), m.warnings.push(...E.warnings), m;
+}
+function M() {
+  return { Feature: 0, FeatureCollection: 0, geometries: {} };
+}
+function S() {
+  return {
+    crs: void 0,
+    valid: !0,
+    errors: [],
+    warnings: [],
+    statistics: M()
+  };
+}
+function Z(...e) {
+  const r = M();
+  for (const i of e) {
+    const n = i.statistics;
+    if (n) {
+      r.Feature += n.Feature ?? 0, r.FeatureCollection += n.FeatureCollection ?? 0;
+      for (const [t, c] of Object.entries(n.geometries ?? {}))
+        r.geometries[t] = (r.geometries[t] ?? 0) + c;
+    }
+  }
+  return r;
+}
+function O(e, ...r) {
+  for (const i of r)
+    e.valid = e.valid && (i.valid ?? !0), i.errors && e.errors.push(...i.errors), i.warnings && e.warnings.push(...i.warnings), i.crs !== void 0 && (e.crs = i.crs);
+  return e.statistics = Z(e, ...r), e;
+}
+function p(e, r, i = "") {
+  const n = {
+    valid: !0,
+    errors: [],
+    warnings: [],
+    statistics: M()
+  };
+  for (let t = 0; t < e.length; t++) {
+    const c = `${i}/${t}`, o = r(e[t], c, t);
+    o.statistics && (n.statistics = Z(n, o)), o.valid || (n.valid = !1, n.errors = n.errors.concat(o.errors.map((l) => ({ ...l, path: l.path || c, index: t })))), a.empty(o.warnings) || (n.warnings = n.warnings.concat(o.warnings.map((l) => ({ ...l, path: l.path || c, index: t }))));
+  }
+  return n;
+}
+function W(e, r = 0, i = T) {
+  for (let n = r; n < e.length - 1; n++)
+    if (fe(e[n], e[n + 1], { precision: i })) return n;
+  return -1;
+}
+function J(e, r, i, n = T) {
+  let t = W(e, 0, n);
+  for (; t !== -1; )
+    i.push({ code: s.DUPLICATE_POSITION, path: `${r}/${t}` }), t = W(e, t + 1, n);
+}
+function F(e, r = 0, i = "", n = {}) {
+  return a.arrayOfLengthAtLeast(e, r) ? p(e, (t, c) => A(t, c, n), i) : {
+    valid: !1,
+    errors: [{ code: s.INVALID_COORDINATES_LENGTH, path: i, params: { minimumLength: r } }],
+    warnings: []
+  };
+}
+function ee(e, r = "", i = {}) {
+  const n = F(e, 2, r, i);
+  if (!n.valid) return n;
+  if (J(e, r, n.warnings, i.precision ?? T), i.geodesic ?? !0)
+    for (let t = 0; t < e.length - 1; t++) {
+      const c = e[t][0], o = e[t + 1][0];
+      Math.abs(o - c) > 180 && n.warnings.push({ code: s.ANTIMERIDIAN_CROSSING, path: `${r}/${t}` });
+    }
+  return n;
+}
+function Ge(e, r = "", i = {}) {
+  return a.nonEmptyArray(e) ? p(e, (n, t) => ee(n, t, i), r) : {
+    valid: !1,
+    errors: [{ code: s.INVALID_MULTI_LINESTRING_COORDINATES, path: r }],
+    warnings: []
+  };
+}
+function he(e, r, i = "", n = {}) {
+  const t = n.precision ?? T, c = n.geodesic ?? !0, o = F(e, 4, i, n);
+  if (!o.valid) return o;
+  if (!ue(e, { precision: t }))
+    return o.valid = !1, o.errors.push({ code: s.RING_NOT_CLOSED, path: i }), o;
+  if (J(e, i, o.warnings, t), c) {
+    const l = z(e) ? "clockwise" : "counter-clockwise";
+    l !== r && (o.valid = !1, o.errors.push({
+      code: s.INVALID_WINDING_ORDER,
+      path: i,
+      params: { expected: r, actual: l }
+    }));
+    const E = X(e);
+    E.length > 0 && (o.valid = !1, o.errors.push({
+      code: s.SELF_INTERSECTION,
+      path: i,
+      params: { count: E.length }
+    }));
+  }
+  return o;
+}
+function re(e, r = "", i = {}) {
+  if (!a.nonEmptyArray(e))
+    return {
+      valid: !1,
+      errors: [{ code: s.INVALID_POLYGON_COORDINATES, path: r }],
+      warnings: []
+    };
+  const n = p(e, (t, c, o) => he(t, o === 0 ? "counter-clockwise" : "clockwise", c, i), r);
+  if ((i.geodesic ?? !0) && n.valid && e.length > 1) {
+    const t = e[0];
+    for (let c = 1; c < e.length; c++)
+      K(t, e[c]) && (n.valid = !1, n.errors.push({ code: s.HOLE_INTERSECTS_SHELL, path: `${r}/${c}` }));
+  }
+  return n;
+}
+function we(e, r = "", i = {}) {
+  return a.nonEmptyArray(e) ? p(e, (n, t) => re(n, t, i), r) : {
+    valid: !1,
+    errors: [{ code: s.INVALID_MULTIPOLYGON_COORDINATES, path: r }],
+    warnings: []
+  };
+}
+function Ue(e, r = "", i = {}) {
+  return a.nonEmptyArray(e) ? p(e, (n, t) => Y(n, t, i), r) : {
+    valid: !1,
+    errors: [{ code: s.INVALID_GEOMETRYCOLLECTION_GEOMETRIES, path: r }],
+    warnings: []
+  };
+}
+function Y(e, r = "", i = {}) {
+  let n = S();
+  if (!a.nonEmptyObject(e))
+    return n.valid = !1, n.errors.push({ code: s.INVALID_GEOMETRY, path: r }), n;
+  n = O(n, q(e.crs, `${r}/crs`, i)), n = O(n, Q(e.bbox, `${r}/bbox`, i));
+  const t = `${r}/coordinates`;
+  switch (e.type) {
+    case d.POINT:
+      n = O(n, A(e.coordinates, t, i));
+      break;
+    case d.MULTI_POINT:
+      n = O(n, F(e.coordinates, 0, t, i));
+      break;
+    case d.LINESTRING:
+      n = O(n, ee(e.coordinates, t, i));
+      break;
+    case d.MULTI_LINESTRING:
+      n = O(n, Ge(e.coordinates, t, i));
+      break;
+    case d.POLYGON:
+      n = O(n, re(e.coordinates, t, i));
+      break;
+    case d.MULTI_POLYGON:
+      n = O(n, we(e.coordinates, t, i));
+      break;
+    case d.GEOMETRY_COLLECTION:
+      n = O(n, Ue(e.geometries, `${r}/geometries`, i));
+      break;
+    default:
+      return n.valid = !1, n.errors.push({ code: s.INVALID_GEOMETRY_TYPE, path: r, params: { type: e.type } }), n;
+  }
+  return n.statistics = { Feature: 0, FeatureCollection: 0, geometries: { [e.type]: 1 } }, n;
+}
+const Me = {
+  precision: L(a.positiveInteger)
+};
+function ne(e, r, i) {
+  let n = S();
+  return a.nonEmptyObject(e) ? (n = O(n, q(e.crs, `${r}/crs`, i)), n = O(n, Q(e.bbox, `${r}/bbox`, i)), e.type === N.FEATURE ? (n.statistics.Feature++, a.nonEmptyObject(e.geometry) ? n = O(n, Y(e.geometry, `${r}/geometry`, i)) : n.warnings.push({
+    code: s.MISSING_GEOMETRY,
+    path: r
+  }), n) : (n.statistics.FeatureCollection++, a.nonEmptyArray(e.features) ? n = O(n, p(e.features, (t, c) => ne(t, c, i), `${r}/features`)) : a.array(e.features) || (n.valid = !1, n.errors.push({
+    code: s.INVALID_FEATURES_ARRAY,
+    path: r
+  })), n)) : (n.valid = !1, n.errors.push({
+    code: s.EMPTY_OBJECT,
+    path: r
+  }), n);
+}
+function We(e, r = {}) {
+  v.that(r, (n) => C.schema(n, Me), "options must be a valid options object");
+  const { precision: i = T } = r;
+  return a.plainObject(e) ? a.emptyObject(e) ? {
+    ...S(),
+    valid: !1,
+    errors: [{
+      code: s.EMPTY_OBJECT,
+      path: ""
+    }]
+  } : e.type === N.FEATURE || e.type === N.FEATURE_COLLECTION ? ne(e, "", { precision: i }) : a.oneOf(e.type, Object.values(d)) ? Y(e, "", { precision: i }) : {
+    ...S(),
+    valid: !1,
+    errors: [{
+      code: s.UNKNOWN_TYPE,
+      path: "",
+      params: { type: e.type }
+    }]
+  } : {
+    ...S(),
+    valid: !1,
+    errors: [{
+      code: s.INVALID_CONTENT,
+      path: ""
+    }]
+  };
+}
+export {
+  R as C,
+  N as F,
+  d as G,
+  s as V,
+  xe as a,
+  be as b,
+  He as c,
+  Oe as d,
+  Ne as e,
+  $e as f,
+  Le as g,
+  U as h,
+  je as i,
+  Ee as j,
+  Be as k,
+  h as s,
+  We as v
+};
+//# sourceMappingURL=geojson-CJ6QZ9pN.js.map