ts-maps 0.3.2 → 0.3.4

package/dist/core-map/geo/index.js

@@ -1013,6 +1013,807 @@ var init_EPSG3857 = __esm(() => {
   };
 });
 
+// src/core-map/geo/area.ts
+function ringArea(ring) {
+  if (ring.length < 3)
+    return 0;
+  let total = 0;
+  for (let i = 0, len = ring.length;i < len; i++) {
+    const p1 = ring[i];
+    const p2 = ring[(i + 1) % len];
+    let dLng = p2[0] - p1[0];
+    if (dLng > 180)
+      dLng -= 360;
+    else if (dLng < -180)
+      dLng += 360;
+    total += dLng * RAD * (2 + Math.sin(p1[1] * RAD) + Math.sin(p2[1] * RAD));
+  }
+  return total * EARTH_RADIUS * EARTH_RADIUS / 2;
+}
+function polygonArea(polygon) {
+  if (polygon.length === 0)
+    return 0;
+  let total = Math.abs(ringArea(polygon[0]));
+  for (let i = 1;i < polygon.length; i++)
+    total -= Math.abs(ringArea(polygon[i]));
+  return Math.max(0, total);
+}
+function multiPolygonArea(multi) {
+  let total = 0;
+  for (const polygon of multi)
+    total += polygonArea(polygon);
+  return total;
+}
+function ringPerimeter(ring, closed = true) {
+  let total = 0;
+  const end = closed ? ring.length : ring.length - 1;
+  for (let i = 0;i < end; i++)
+    total += haversine(ring[i], ring[(i + 1) % ring.length]);
+  return total;
+}
+function haversine(a, b) {
+  const dLat = (b[1] - a[1]) * RAD;
+  const dLng = (b[0] - a[0]) * RAD;
+  const lat1 = a[1] * RAD;
+  const lat2 = b[1] * RAD;
+  const h = Math.sin(dLat / 2) ** 2 + Math.sin(dLng / 2) ** 2 * Math.cos(lat1) * Math.cos(lat2);
+  return 2 * EARTH_RADIUS * Math.asin(Math.min(1, Math.sqrt(h)));
+}
+function formatArea(squareMetres, options = {}) {
+  const locale = options.locale;
+  const value = Math.max(0, squareMetres);
+  if (options.units === "imperial") {
+    const squareFeet = value * 10.763910417;
+    if (squareFeet < 43560)
+      return `${round(squareFeet, 0).toLocaleString(locale)} ft²`;
+    const acres = value / 4046.8564224;
+    if (acres < 640)
+      return `${round(acres, acres < 10 ? 2 : 1).toLocaleString(locale)} acres`;
+    return `${round(value / 2589988.110336, 2).toLocaleString(locale)} mi²`;
+  }
+  if (value < 1e4)
+    return `${round(value, 0).toLocaleString(locale)} m²`;
+  if (value < 1e6)
+    return `${round(value / 1e4, value < 1e5 ? 2 : 1).toLocaleString(locale)} ha`;
+  return `${round(value / 1e6, value < 1e7 ? 2 : 1).toLocaleString(locale)} km²`;
+}
+function formatDistance(metres, options = {}) {
+  const locale = options.locale;
+  const value = Math.max(0, metres);
+  if (options.units === "imperial") {
+    const miles = value / 1609.344;
+    if (miles < 0.1)
+      return `${round(value * 3.280839895, 0).toLocaleString(locale)} ft`;
+    return `${round(miles, 2).toLocaleString(locale)} mi`;
+  }
+  if (value < 1000)
+    return `${round(value, 0).toLocaleString(locale)} m`;
+  return `${round(value / 1000, 2).toLocaleString(locale)} km`;
+}
+function round(value, places) {
+  const factor = 10 ** places;
+  return Math.round(value * factor) / factor;
+}
+var EARTH_RADIUS = 6371008.8, RAD;
+var init_area = __esm(() => {
+  RAD = Math.PI / 180;
+});
+
+// src/core-map/geo/polygonClip.ts
+class SweepEvent {
+  point;
+  left;
+  otherEvent;
+  isSubject;
+  type;
+  inOut;
+  otherInOut;
+  inResult;
+  contourId;
+  constructor(point, left, otherEvent, isSubject, type = NORMAL) {
+    this.point = point;
+    this.left = left;
+    this.otherEvent = otherEvent;
+    this.isSubject = isSubject;
+    this.type = type;
+    this.inOut = false;
+    this.otherInOut = false;
+    this.inResult = false;
+    this.contourId = 0;
+  }
+  isBelow(p) {
+    const a = this.point;
+    const b = this.otherEvent.point;
+    return this.left ? signedArea(a, b, p) > 0 : signedArea(b, a, p) > 0;
+  }
+  isAbove(p) {
+    return !this.isBelow(p);
+  }
+  isVertical() {
+    return this.point[0] === this.otherEvent.point[0];
+  }
+}
+function signedArea(p0, p1, p2) {
+  return (p0[0] - p2[0]) * (p1[1] - p2[1]) - (p1[0] - p2[0]) * (p0[1] - p2[1]);
+}
+function equals(a, b) {
+  return a[0] === b[0] && a[1] === b[1];
+}
+function compareEvents(e1, e2) {
+  const p1 = e1.point;
+  const p2 = e2.point;
+  if (p1[0] > p2[0])
+    return 1;
+  if (p1[0] < p2[0])
+    return -1;
+  if (p1[1] !== p2[1])
+    return p1[1] > p2[1] ? 1 : -1;
+  if (e1.left !== e2.left)
+    return e1.left ? 1 : -1;
+  if (signedArea(p1, e1.otherEvent.point, e2.otherEvent.point) !== 0)
+    return e1.isBelow(e2.otherEvent.point) ? -1 : 1;
+  return !e1.isSubject && e2.isSubject ? 1 : -1;
+}
+function compareSegments(le1, le2) {
+  if (le1 === le2)
+    return 0;
+  if (signedArea(le1.point, le1.otherEvent.point, le2.point) !== 0 || signedArea(le1.point, le1.otherEvent.point, le2.otherEvent.point) !== 0) {
+    if (equals(le1.point, le2.point))
+      return le1.isBelow(le2.otherEvent.point) ? -1 : 1;
+    if (le1.point[0] === le2.point[0])
+      return le1.point[1] < le2.point[1] ? -1 : 1;
+    if (compareEvents(le1, le2) === 1)
+      return le2.isAbove(le1.point) ? -1 : 1;
+    return le1.isBelow(le2.point) ? -1 : 1;
+  }
+  if (le1.isSubject === le2.isSubject) {
+    let p1 = le1.point;
+    let p2 = le2.point;
+    if (p1[0] === p2[0] && p1[1] === p2[1]) {
+      p1 = le1.otherEvent.point;
+      p2 = le2.otherEvent.point;
+      if (p1[0] === p2[0] && p1[1] === p2[1])
+        return 0;
+      return le1.contourId > le2.contourId ? 1 : -1;
+    }
+    return compareEvents(le1, le2) === 1 ? 1 : -1;
+  }
+  return le1.isSubject ? -1 : 1;
+}
+
+class EventQueue {
+  _data = [];
+  get length() {
+    return this._data.length;
+  }
+  push(event) {
+    const data = this._data;
+    data.push(event);
+    let pos = data.length - 1;
+    while (pos > 0) {
+      const parent = pos - 1 >> 1;
+      if (compareEvents(data[pos], data[parent]) >= 0)
+        break;
+      const tmp = data[parent];
+      data[parent] = data[pos];
+      data[pos] = tmp;
+      pos = parent;
+    }
+  }
+  pop() {
+    const data = this._data;
+    const top = data[0];
+    const last = data.pop();
+    if (data.length === 0)
+      return top;
+    data[0] = last;
+    let pos = 0;
+    const half = data.length >> 1;
+    while (pos < half) {
+      let child = 2 * pos + 1;
+      const right = child + 1;
+      if (right < data.length && compareEvents(data[right], data[child]) < 0)
+        child = right;
+      if (compareEvents(data[child], data[pos]) >= 0)
+        break;
+      const tmp = data[child];
+      data[child] = data[pos];
+      data[pos] = tmp;
+      pos = child;
+    }
+    return top;
+  }
+}
+
+class SweepStatus {
+  _items = [];
+  insert(event) {
+    let low = 0;
+    let high = this._items.length;
+    while (low < high) {
+      const mid = low + high >> 1;
+      if (compareSegments(this._items[mid], event) < 0)
+        low = mid + 1;
+      else
+        high = mid;
+    }
+    this._items.splice(low, 0, event);
+    return low;
+  }
+  remove(event) {
+    const index = this._items.indexOf(event);
+    if (index !== -1)
+      this._items.splice(index, 1);
+  }
+  indexOf(event) {
+    return this._items.indexOf(event);
+  }
+  at(index) {
+    return index >= 0 && index < this._items.length ? this._items[index] : null;
+  }
+}
+function segmentIntersection(a1, a2, b1, b2) {
+  const va = [a2[0] - a1[0], a2[1] - a1[1]];
+  const vb = [b2[0] - b1[0], b2[1] - b1[1]];
+  const e = [b1[0] - a1[0], b1[1] - a1[1]];
+  const cross = (u, v) => u[0] * v[1] - u[1] * v[0];
+  const dot = (u, v) => u[0] * v[0] + u[1] * v[1];
+  const at = (base, s, v) => [base[0] + s * v[0], base[1] + s * v[1]];
+  const kross = cross(va, vb);
+  if (kross * kross > 0) {
+    const s = cross(e, vb) / kross;
+    if (s < 0 || s > 1)
+      return null;
+    const t = cross(e, va) / kross;
+    if (t < 0 || t > 1)
+      return null;
+    if (s === 0 || s === 1)
+      return [at(a1, s, va)];
+    if (t === 0 || t === 1)
+      return [at(b1, t, vb)];
+    return [at(a1, s, va)];
+  }
+  if (cross(e, va) ** 2 > 0)
+    return null;
+  const sqrLenA = dot(va, va);
+  if (sqrLenA === 0)
+    return null;
+  const sa = dot(e, va) / sqrLenA;
+  const sb = sa + dot(vb, va) / sqrLenA;
+  const s0 = Math.max(Math.min(sa, sb), 0);
+  const s1 = Math.min(Math.max(sa, sb), 1);
+  if (s0 > s1)
+    return null;
+  if (s0 === s1)
+    return [at(a1, s0, va)];
+  return [at(a1, s0, va), at(a1, s1, va)];
+}
+function divideSegment(se, p, queue) {
+  const right = new SweepEvent(p, false, se, se.isSubject);
+  const left = new SweepEvent(p, true, se.otherEvent, se.isSubject);
+  right.contourId = se.contourId;
+  left.contourId = se.contourId;
+  if (compareEvents(left, se.otherEvent) > 0) {
+    se.otherEvent.left = true;
+    left.left = false;
+  }
+  se.otherEvent.otherEvent = left;
+  se.otherEvent = right;
+  queue.push(left);
+  queue.push(right);
+}
+function possibleIntersection(se1, se2, queue) {
+  const inter = segmentIntersection(se1.point, se1.otherEvent.point, se2.point, se2.otherEvent.point);
+  if (!inter)
+    return 0;
+  const count = inter.length;
+  if (count === 1 && (equals(se1.point, se2.point) || equals(se1.otherEvent.point, se2.otherEvent.point)))
+    return 0;
+  if (count === 2 && se1.isSubject === se2.isSubject)
+    return 0;
+  if (count === 1) {
+    if (!equals(se1.point, inter[0]) && !equals(se1.otherEvent.point, inter[0]))
+      divideSegment(se1, inter[0], queue);
+    if (!equals(se2.point, inter[0]) && !equals(se2.otherEvent.point, inter[0]))
+      divideSegment(se2, inter[0], queue);
+    return 1;
+  }
+  const events = [];
+  let leftCoincide = false;
+  let rightCoincide = false;
+  if (equals(se1.point, se2.point))
+    leftCoincide = true;
+  else if (compareEvents(se1, se2) === 1)
+    events.push(se2, se1);
+  else
+    events.push(se1, se2);
+  if (equals(se1.otherEvent.point, se2.otherEvent.point))
+    rightCoincide = true;
+  else if (compareEvents(se1.otherEvent, se2.otherEvent) === 1)
+    events.push(se2.otherEvent, se1.otherEvent);
+  else
+    events.push(se1.otherEvent, se2.otherEvent);
+  if (leftCoincide) {
+    se2.type = NON_CONTRIBUTING;
+    se1.type = se2.inOut === se1.inOut ? SAME_TRANSITION : DIFFERENT_TRANSITION;
+    if (!rightCoincide)
+      divideSegment(events[1].otherEvent, events[0].point, queue);
+    return 2;
+  }
+  if (rightCoincide) {
+    divideSegment(events[0], events[1].point, queue);
+    return 3;
+  }
+  if (events[0] !== events[3].otherEvent) {
+    divideSegment(events[0], events[1].point, queue);
+    divideSegment(events[1], events[2].point, queue);
+    return 3;
+  }
+  divideSegment(events[0], events[1].point, queue);
+  divideSegment(events[3].otherEvent, events[2].point, queue);
+  return 3;
+}
+function edgeInResult(event, operation) {
+  switch (event.type) {
+    case NORMAL:
+      switch (operation) {
+        case INTERSECTION:
+          return !event.otherInOut;
+        case UNION:
+          return event.otherInOut;
+        case DIFFERENCE:
+          return event.isSubject && event.otherInOut || !event.isSubject && !event.otherInOut;
+        case XOR:
+          return true;
+      }
+      return false;
+    case SAME_TRANSITION:
+      return operation === INTERSECTION || operation === UNION;
+    case DIFFERENT_TRANSITION:
+      return operation === DIFFERENCE;
+    default:
+      return false;
+  }
+}
+function computeFields(event, prev, operation) {
+  if (prev === null) {
+    event.inOut = false;
+    event.otherInOut = true;
+  } else if (event.isSubject === prev.isSubject) {
+    event.inOut = !prev.inOut;
+    event.otherInOut = prev.otherInOut;
+  } else {
+    event.inOut = !prev.otherInOut;
+    event.otherInOut = prev.isVertical() ? !prev.inOut : prev.inOut;
+  }
+  event.inResult = edgeInResult(event, operation);
+}
+function sweep(subject, clip, operation) {
+  const queue = new EventQueue;
+  let contourId = 0;
+  const addPolygonSet = (polygons, isSubject) => {
+    for (const polygon of polygons) {
+      for (const ring of polygon) {
+        contourId++;
+        const points = normaliseRing(ring);
+        for (let i = 0;i < points.length; i++) {
+          const a = points[i];
+          const b = points[(i + 1) % points.length];
+          if (equals(a, b))
+            continue;
+          const e1 = new SweepEvent(a, false, null, isSubject);
+          const e2 = new SweepEvent(b, false, e1, isSubject);
+          e1.otherEvent = e2;
+          e1.contourId = contourId;
+          e2.contourId = contourId;
+          if (compareEvents(e1, e2) > 0)
+            e2.left = true;
+          else
+            e1.left = true;
+          queue.push(e1);
+          queue.push(e2);
+        }
+      }
+    }
+  };
+  addPolygonSet(subject, true);
+  addPolygonSet(clip, false);
+  const status = new SweepStatus;
+  const results = [];
+  while (queue.length > 0) {
+    const event = queue.pop();
+    if (event.left) {
+      const position = status.insert(event);
+      const prev = status.at(position - 1);
+      const next = status.at(position + 1);
+      computeFields(event, prev, operation);
+      if (next && possibleIntersection(event, next, queue) === 2) {
+        computeFields(event, prev, operation);
+        computeFields(next, event, operation);
+      }
+      if (prev && possibleIntersection(prev, event, queue) === 2) {
+        const prevOfPrev = status.at(status.indexOf(prev) - 1);
+        computeFields(prev, prevOfPrev, operation);
+        computeFields(event, prev, operation);
+      }
+      results.push(event);
+    } else {
+      const left = event.otherEvent;
+      const position = status.indexOf(left);
+      if (position !== -1) {
+        const prev = status.at(position - 1);
+        const next = status.at(position + 1);
+        status.remove(left);
+        if (prev && next)
+          possibleIntersection(prev, next, queue);
+      }
+    }
+  }
+  const edges = [];
+  for (const event of results) {
+    if (event.inResult && event.type !== NON_CONTRIBUTING)
+      edges.push({ from: event.point, to: event.otherEvent.point });
+  }
+  return edges;
+}
+function normaliseRing(ring) {
+  const points = [];
+  for (const point of ring) {
+    const last = points[points.length - 1];
+    if (!last || !equals(last, point))
+      points.push([point[0], point[1]]);
+  }
+  while (points.length > 1 && equals(points[0], points[points.length - 1]))
+    points.pop();
+  return points;
+}
+function key2(p) {
+  return `${p[0]},${p[1]}`;
+}
+function buildRings(edges) {
+  const used = Array.from({ length: edges.length }, () => false);
+  const outgoing = new Map;
+  const link = (from, to, edge) => {
+    const arc = { edge, to, angle: Math.atan2(to[1] - from[1], to[0] - from[0]) };
+    const k = key2(from);
+    const list = outgoing.get(k);
+    if (list)
+      list.push(arc);
+    else
+      outgoing.set(k, [arc]);
+  };
+  for (let i = 0;i < edges.length; i++) {
+    const { from, to } = edges[i];
+    if (equals(from, to)) {
+      used[i] = true;
+      continue;
+    }
+    link(from, to, i);
+    link(to, from, i);
+  }
+  const rings = [];
+  for (let seed = 0;seed < edges.length; seed++) {
+    if (used[seed])
+      continue;
+    const origin = edges[seed].from;
+    const ring = [origin];
+    let from = origin;
+    let to = edges[seed].to;
+    used[seed] = true;
+    for (let guard = 0;guard <= edges.length + 1; guard++) {
+      ring.push(to);
+      if (equals(to, origin))
+        break;
+      const candidates = outgoing.get(key2(to));
+      if (!candidates)
+        break;
+      const back = Math.atan2(from[1] - to[1], from[0] - to[0]);
+      let best = null;
+      let bestTurn = Infinity;
+      for (const candidate of candidates) {
+        if (used[candidate.edge])
+          continue;
+        let turn = back - candidate.angle;
+        while (turn <= 0)
+          turn += Math.PI * 2;
+        while (turn > Math.PI * 2)
+          turn -= Math.PI * 2;
+        if (turn < bestTurn) {
+          bestTurn = turn;
+          best = candidate;
+        }
+      }
+      if (!best)
+        break;
+      used[best.edge] = true;
+      from = to;
+      to = best.to;
+    }
+    if (ring.length >= 4 && equals(ring[0], ring[ring.length - 1]))
+      rings.push(ring);
+  }
+  return rings;
+}
+function ringSignedArea(ring) {
+  let sum = 0;
+  for (let i = 0, len = ring.length - 1;i < len; i++)
+    sum += (ring[i + 1][0] - ring[i][0]) * (ring[i + 1][1] + ring[i][1]);
+  return sum;
+}
+function pointInRing(point, ring) {
+  let inside = false;
+  for (let i = 0, j = ring.length - 2;i < ring.length - 1; j = i++) {
+    const xi = ring[i][0];
+    const yi = ring[i][1];
+    const xj = ring[j][0];
+    const yj = ring[j][1];
+    if (yi > point[1] !== yj > point[1] && point[0] < (xj - xi) * (point[1] - yi) / (yj - yi) + xi) {
+      inside = !inside;
+    }
+  }
+  return inside;
+}
+function interiorPoint(ring) {
+  for (let i = 0;i < ring.length - 1; i++) {
+    const a = ring[i];
+    const b = ring[(i + 1) % (ring.length - 1)];
+    const candidate = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
+    const dx = b[0] - a[0];
+    const dy = b[1] - a[1];
+    const len = Math.hypot(dx, dy);
+    if (len === 0)
+      continue;
+    const scale = len * 0.000001;
+    const inward = [candidate[0] - dy / len * scale, candidate[1] + dx / len * scale];
+    if (pointInRing(inward, ring))
+      return inward;
+    const other = [candidate[0] + dy / len * scale, candidate[1] - dx / len * scale];
+    if (pointInRing(other, ring))
+      return other;
+  }
+  return ring[0];
+}
+function assemblePolygons(rings) {
+  const kept = rings.filter((ring) => Math.abs(ringSignedArea(ring)) > 0);
+  const samples = kept.map(interiorPoint);
+  const parents = kept.map(() => -1);
+  const depths = kept.map(() => 0);
+  for (let i = 0;i < kept.length; i++) {
+    let bestParent = -1;
+    let bestArea = Infinity;
+    for (let j = 0;j < kept.length; j++) {
+      if (i === j)
+        continue;
+      if (!pointInRing(samples[i], kept[j]))
+        continue;
+      const area = Math.abs(ringSignedArea(kept[j]));
+      if (area < bestArea) {
+        bestArea = area;
+        bestParent = j;
+      }
+      depths[i]++;
+    }
+    parents[i] = bestParent;
+  }
+  const polygons = [];
+  const polygonOf = new Map;
+  for (let i = 0;i < kept.length; i++) {
+    if (depths[i] % 2 !== 0)
+      continue;
+    polygonOf.set(i, polygons.length);
+    polygons.push([orient(kept[i], true)]);
+  }
+  for (let i = 0;i < kept.length; i++) {
+    if (depths[i] % 2 === 0)
+      continue;
+    const target = parents[i] === -1 ? undefined : polygonOf.get(parents[i]);
+    if (target === undefined) {
+      continue;
+    }
+    polygons[target].push(orient(kept[i], false));
+  }
+  return polygons;
+}
+function orient(ring, outer) {
+  const clockwise = ringSignedArea(ring) > 0;
+  const copy = ring.map((p) => [p[0], p[1]]);
+  if (clockwise === outer)
+    copy.reverse();
+  return copy;
+}
+function run(subject, clip, operation) {
+  if (subject.length === 0) {
+    if (operation === UNION || operation === XOR)
+      return clone(clip);
+    return [];
+  }
+  if (clip.length === 0) {
+    if (operation === UNION || operation === DIFFERENCE || operation === XOR)
+      return clone(subject);
+    return [];
+  }
+  return assemblePolygons(buildRings(sweep(subject, clip, operation)));
+}
+function clone(multi) {
+  return multi.map((polygon) => polygon.map((ring) => ring.map((p) => [p[0], p[1]])));
+}
+function union(subject, clip) {
+  return run(subject, clip, UNION);
+}
+function intersection(subject, clip) {
+  return run(subject, clip, INTERSECTION);
+}
+function difference(subject, clip) {
+  return run(subject, clip, DIFFERENCE);
+}
+function xor(subject, clip) {
+  return run(subject, clip, XOR);
+}
+function intersects(subject, clip) {
+  return intersection(subject, clip).length > 0;
+}
+function contains(multi, point) {
+  for (const polygon of multi) {
+    if (polygon.length === 0 || !pointInRing(point, closeRing(polygon[0])))
+      continue;
+    let inHole = false;
+    for (let i = 1;i < polygon.length; i++) {
+      if (pointInRing(point, closeRing(polygon[i]))) {
+        inHole = true;
+        break;
+      }
+    }
+    if (!inHole)
+      return true;
+  }
+  return false;
+}
+function closeRing(ring) {
+  if (ring.length > 0 && !equals(ring[0], ring[ring.length - 1]))
+    return [...ring, ring[0]];
+  return ring;
+}
+var INTERSECTION = 0, UNION = 1, DIFFERENCE = 2, XOR = 3, NORMAL = 0, NON_CONTRIBUTING = 1, SAME_TRANSITION = 2, DIFFERENT_TRANSITION = 3;
+
+// src/core-map/geo/validate.ts
+function validateRing(ring) {
+  if (!Array.isArray(ring))
+    throw new InvalidGeometryError("ring must be an array of positions");
+  if (ring.length < 4)
+    throw new InvalidGeometryError(`ring needs at least 4 positions to enclose an area, got ${ring.length}`);
+  for (let i = 0;i < ring.length; i++) {
+    const position = ring[i];
+    if (!Array.isArray(position) || position.length < 2)
+      throw new InvalidGeometryError(`position ${i} is not a [lng, lat] pair`);
+    const [lng, lat] = position;
+    if (!Number.isFinite(lng) || !Number.isFinite(lat))
+      throw new InvalidGeometryError(`position ${i} is not finite: [${lng}, ${lat}] — a receiver losing lock reports this`);
+    if (lat < -90 || lat > 90)
+      throw new InvalidGeometryError(`position ${i} has latitude ${lat}, outside [-90, 90]`);
+  }
+}
+function unwrapRing(ring) {
+  let crosses = false;
+  for (let i = 1;i < ring.length; i++) {
+    if (Math.abs(ring[i][0] - ring[i - 1][0]) > 180) {
+      crosses = true;
+      break;
+    }
+  }
+  if (!crosses)
+    return ring;
+  const out = [[ring[0][0], ring[0][1]]];
+  let offset = 0;
+  for (let i = 1;i < ring.length; i++) {
+    const delta = ring[i][0] - ring[i - 1][0];
+    if (delta > 180)
+      offset -= 360;
+    else if (delta < -180)
+      offset += 360;
+    out.push([ring[i][0] + offset, ring[i][1]]);
+  }
+  return out;
+}
+function splitSelfIntersecting(ring) {
+  const points = closeRing2(ring).slice(0, -1);
+  const count = points.length;
+  if (count < 3)
+    return [closeRing2(ring)];
+  const loops = [];
+  const open = [];
+  for (let i = 0;i < count; i++) {
+    const a1 = points[i];
+    const a2 = points[(i + 1) % count];
+    open.push(a1);
+    for (let j = 0;j + 2 < open.length; j++) {
+      const point = crossingPoint(a1, a2, open[j], open[j + 1]);
+      if (!point)
+        continue;
+      loops.push([point, ...open.slice(j + 1), point]);
+      open.length = j + 1;
+      open.push(point);
+      break;
+    }
+  }
+  loops.push([...open, open[0]]);
+  return loops.filter((loop) => loop.length >= 4);
+}
+function resolveSelfIntersections(ring) {
+  const single = [[closeRing2(ring)]];
+  if (!selfIntersects(ring))
+    return single;
+  const loops = splitSelfIntersecting(ring);
+  if (loops.length <= 1)
+    return single;
+  let result = [];
+  for (const loop of loops)
+    result = union(result, [[loop]]);
+  return result;
+}
+function crossingPoint(a1, a2, b1, b2) {
+  const ax = a2[0] - a1[0];
+  const ay = a2[1] - a1[1];
+  const bx = b2[0] - b1[0];
+  const by = b2[1] - b1[1];
+  const denominator = ax * by - ay * bx;
+  if (denominator === 0)
+    return null;
+  const dx = b1[0] - a1[0];
+  const dy = b1[1] - a1[1];
+  const t = (dx * by - dy * bx) / denominator;
+  const u = (dx * ay - dy * ax) / denominator;
+  if (t <= 0 || t >= 1 || u <= 0 || u >= 1)
+    return null;
+  return [a1[0] + ax * t, a1[1] + ay * t];
+}
+function selfIntersects(ring) {
+  const points = closeRing2(ring);
+  const count = points.length - 1;
+  if (count < 4)
+    return false;
+  for (let i = 0;i < count; i++) {
+    for (let j = i + 2;j < count; j++) {
+      if (i === 0 && j === count - 1)
+        continue;
+      if (segmentsCross(points[i], points[i + 1], points[j], points[j + 1]))
+        return true;
+    }
+  }
+  return false;
+}
+function segmentsCross(a1, a2, b1, b2) {
+  const d1 = cross(a1, a2, b1);
+  const d2 = cross(a1, a2, b2);
+  const d3 = cross(b1, b2, a1);
+  const d4 = cross(b1, b2, a2);
+  return (d1 > 0 && d2 < 0 || d1 < 0 && d2 > 0) && (d3 > 0 && d4 < 0 || d3 < 0 && d4 > 0);
+}
+function cross(o, a, b) {
+  return (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
+}
+function closeRing2(ring) {
+  if (ring.length === 0)
+    return ring;
+  const first = ring[0];
+  const last = ring[ring.length - 1];
+  if (first[0] === last[0] && first[1] === last[1])
+    return ring;
+  return [...ring, first];
+}
+function prepareClaim(ring) {
+  validateRing(ring);
+  return resolveSelfIntersections(unwrapRing(ring));
+}
+var InvalidGeometryError;
+var init_validate = __esm(() => {
+  InvalidGeometryError = class InvalidGeometryError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "InvalidGeometryError";
+    }
+  };
+});
+
 // src/core-map/geo/index.ts
 init_LatLng();
 init_LatLngBounds();
@@ -1181,24 +1982,48 @@ class SimpleCRS extends CRS {
     return Math.sqrt(dx * dx + dy * dy);
   }
 }
+// src/core-map/geo/index.ts
+init_area();
+init_validate();
 export {
   CRS,
+  EARTH_RADIUS,
   EPSG3395,
   EPSG3857,
   EPSG4326,
   EPSG900913,
   EarthCRS,
+  InvalidGeometryError,
   LatLng,
   LatLngBounds,
   exports_projection as Projection,
   SimpleCRS,
   TerrainSource,
   buildTerrainMesh,
+  contains,
   decodeElevationGrid,
   decodeMapboxRGB,
   decodeTerrariumRGB,
+  difference,
+  formatArea,
+  formatDistance,
   getElevationDecoder,
+  haversine,
+  intersection,
+  intersects,
+  multiPolygonArea,
+  polygonArea,
+  prepareClaim,
+  resolveSelfIntersections,
+  ringArea,
+  ringPerimeter,
   sampleElevationBilinear,
+  selfIntersects,
+  splitSelfIntersecting,
   toLatLng,
-  toLatLngBounds
+  toLatLngBounds,
+  union,
+  unwrapRing,
+  validateRing,
+  xor
 };