@sakuzu/maplibre-gl-draw 1.0.0 → 2.1.0

package/dist/geometry/public-predicates.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Test: the public predicates between points, lines and polygons
+ *
+ * The tests run on the lng/lat plane. A point or a line is contained when it lies inside the
+ * polygon or on its boundary; a polygon is contained when no part of it lies outside.
+ */
+import type { Geometry, MultiPolygon, Point, Polygon, Position } from 'geojson';
+/**
+ * Determines whether a point lies inside a polygon, holes taken into account.
+ *
+ * @param point The point, a position `[lng, lat]` in degrees or a Point
+ * @param polygon The Polygon or MultiPolygon, or a feature whose geometry is one; coordinates
+ *   in degrees
+ * @returns `true` when the point lies inside an outer ring and inside none of its holes. The
+ *   result for a point exactly on the boundary is not defined
+ * @throws {@link GeometryError} (`invalid-input`) when an argument is not of the expected type
+ */
+export declare function pointInPolygon(point: Position | Point, polygon: Polygon | MultiPolygon | {
+    readonly geometry: Geometry;
+}): boolean;
+/**
+ * Determines whether two polygons share an area.
+ *
+ * @param a The Polygon or MultiPolygon, or a feature whose geometry is one; coordinates in
+ *   degrees
+ * @param b The Polygon or MultiPolygon, or a feature whose geometry is one; coordinates in
+ *   degrees
+ * @returns `true` when the common part has an area. `false` when they only touch along an edge
+ *   or at a vertex
+ * @throws {@link GeometryError} (`invalid-input`) when an argument is not a Polygon or a
+ *   MultiPolygon, and (`engine-failure`) when the boolean operation fails
+ */
+export declare function overlaps(a: Polygon | MultiPolygon | {
+    readonly geometry: Geometry;
+}, b: Polygon | MultiPolygon | {
+    readonly geometry: Geometry;
+}): boolean;
+/**
+ * Determines whether a polygon completely contains a geometry.
+ *
+ * @param outer The containing Polygon or MultiPolygon, or a feature whose geometry is one;
+ *   coordinates in degrees
+ * @param inner The contained geometry, or a feature whose geometry it is; coordinates in
+ *   degrees. It may share the boundary of `outer`
+ * @returns `true` when no part of `inner` lies outside `outer`. `false` for a polygon without
+ *   an area and for an empty geometry
+ * @throws {@link GeometryError} (`invalid-input`) when an argument is not of the expected
+ *   type, and (`engine-failure`) when the boolean operation fails
+ */
+export declare function contains(outer: Polygon | MultiPolygon | {
+    readonly geometry: Geometry;
+}, inner: Geometry | {
+    readonly geometry: Geometry;
+}): boolean;

package/dist/geometry/public-predicates.js

@@ -0,0 +1,144 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { usableAreaParts } from './coords.js';
+import { withOperation } from './errors.js';
+import { areaOf, geometryOf, positionOf } from './geojson.js';
+import { contains as containsArea, intersects, pointInPolygon as pointInArea, } from './predicates.js';
+import { segmentIntersection } from './split.js';
+/**
+ * Determines whether a point lies inside a polygon, holes taken into account.
+ *
+ * @param point The point, a position `[lng, lat]` in degrees or a Point
+ * @param polygon The Polygon or MultiPolygon, or a feature whose geometry is one; coordinates
+ *   in degrees
+ * @returns `true` when the point lies inside an outer ring and inside none of its holes. The
+ *   result for a point exactly on the boundary is not defined
+ * @throws {@link GeometryError} (`invalid-input`) when an argument is not of the expected type
+ */
+export function pointInPolygon(point, polygon) {
+    return pointInArea(positionOf(point, 'pointInPolygon'), areaOf(polygon, 'pointInPolygon'));
+}
+/**
+ * Determines whether two polygons share an area.
+ *
+ * @param a The Polygon or MultiPolygon, or a feature whose geometry is one; coordinates in
+ *   degrees
+ * @param b The Polygon or MultiPolygon, or a feature whose geometry is one; coordinates in
+ *   degrees
+ * @returns `true` when the common part has an area. `false` when they only touch along an edge
+ *   or at a vertex
+ * @throws {@link GeometryError} (`invalid-input`) when an argument is not a Polygon or a
+ *   MultiPolygon, and (`engine-failure`) when the boolean operation fails
+ */
+export function overlaps(a, b) {
+    const left = areaOf(a, 'overlaps');
+    const right = areaOf(b, 'overlaps');
+    return withOperation('overlaps', () => intersects(left, right));
+}
+/** The distance in degrees within which a point counts as on the boundary */
+const BOUNDARY_EPSILON = 1e-12;
+/** The square of the planar distance from a point to a segment */
+function squaredSegmentDistance(p, a, b) {
+    const dx = b[0] - a[0];
+    const dy = b[1] - a[1];
+    const lengthSquared = dx * dx + dy * dy;
+    const t = lengthSquared === 0
+        ? 0
+        : Math.min(1, Math.max(0, ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / lengthSquared));
+    const x = p[0] - (a[0] + t * dx);
+    const y = p[1] - (a[1] + t * dy);
+    return x * x + y * y;
+}
+/** Calls a function with every edge of every ring, the closing edge included */
+function forEachEdge(parts, visit) {
+    for (const part of parts) {
+        for (const ring of part) {
+            for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+                if (visit(ring[j], ring[i]) === true)
+                    return true;
+            }
+        }
+    }
+    return false;
+}
+function onBoundary(point, parts) {
+    const limit = BOUNDARY_EPSILON * BOUNDARY_EPSILON;
+    return forEachEdge(parts, (a, b) => squaredSegmentDistance(point, a, b) <= limit);
+}
+function coversPoint(parts, point) {
+    return pointInArea(point, parts) || onBoundary(point, parts);
+}
+/**
+ * Whether a line lies inside the polygon or on its boundary
+ *
+ * Each segment is cut where it crosses an edge; every vertex and the middle of every piece
+ * must be covered.
+ */
+function coversLine(parts, line) {
+    if (line.length === 0)
+        return false;
+    if (!line.every((vertex) => coversPoint(parts, vertex)))
+        return false;
+    for (let i = 0; i < line.length - 1; i++) {
+        const a = line[i];
+        const b = line[i + 1];
+        const dx = b[0] - a[0];
+        const dy = b[1] - a[1];
+        const alongX = Math.abs(dx) >= Math.abs(dy);
+        const cuts = [0, 1];
+        forEachEdge(parts, (c, d) => {
+            const crossing = segmentIntersection(a, b, c, d);
+            if (crossing !== null) {
+                cuts.push(alongX ? (crossing[0] - a[0]) / dx : (crossing[1] - a[1]) / dy);
+            }
+            return undefined;
+        });
+        cuts.sort((x, y) => x - y);
+        for (let k = 0; k < cuts.length - 1; k++) {
+            if (cuts[k + 1] - cuts[k] <= BOUNDARY_EPSILON)
+                continue;
+            const t = (cuts[k] + cuts[k + 1]) / 2;
+            if (!coversPoint(parts, [a[0] + t * dx, a[1] + t * dy]))
+                return false;
+        }
+    }
+    return true;
+}
+function containsGeometry(outer, inner) {
+    const parts = usableAreaParts(outer);
+    switch (inner.type) {
+        case 'Polygon':
+        case 'MultiPolygon':
+            return containsArea(outer, inner.coordinates);
+        case 'Point':
+            return coversPoint(parts, inner.coordinates);
+        case 'MultiPoint':
+            return (inner.coordinates.length > 0 &&
+                inner.coordinates.every((point) => coversPoint(parts, point)));
+        case 'LineString':
+            return coversLine(parts, inner.coordinates);
+        case 'MultiLineString':
+            return (inner.coordinates.length > 0 &&
+                inner.coordinates.every((line) => coversLine(parts, line)));
+        case 'GeometryCollection':
+            return (inner.geometries.length > 0 &&
+                inner.geometries.every((member) => containsGeometry(outer, geometryOf(member, 'contains'))));
+    }
+}
+/**
+ * Determines whether a polygon completely contains a geometry.
+ *
+ * @param outer The containing Polygon or MultiPolygon, or a feature whose geometry is one;
+ *   coordinates in degrees
+ * @param inner The contained geometry, or a feature whose geometry it is; coordinates in
+ *   degrees. It may share the boundary of `outer`
+ * @returns `true` when no part of `inner` lies outside `outer`. `false` for a polygon without
+ *   an area and for an empty geometry
+ * @throws {@link GeometryError} (`invalid-input`) when an argument is not of the expected
+ *   type, and (`engine-failure`) when the boolean operation fails
+ */
+export function contains(outer, inner) {
+    const area = areaOf(outer, 'contains');
+    const geometry = geometryOf(inner, 'contains');
+    return withOperation('contains', () => containsGeometry(area, geometry));
+}

package/dist/geometry/public-repair.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Repair: the public functions that tidy polygons and reduce vertices
+ */
+import type { Geometry, LineString, MultiPolygon, Polygon } from 'geojson';
+/**
+ * Returns a polygon with its self-intersections resolved, its rings oriented and its rings
+ * without an area removed.
+ *
+ * @param polygon The Polygon or MultiPolygon, or a feature whose geometry is one; coordinates
+ *   in degrees. A ring with fewer than 3 positions or a position that is not finite is dropped
+ * @returns A Polygon, or a MultiPolygon when the result falls apart (a figure eight becomes two
+ *   parts), with outer rings counter-clockwise and holes clockwise. null when nothing with an
+ *   area remains
+ * @throws {@link GeometryError} (`invalid-input`) when the input is not a Polygon or a
+ *   MultiPolygon, and (`engine-failure`) when the boolean operation fails
+ */
+export declare function makeValid(polygon: Polygon | MultiPolygon | {
+    readonly geometry: Geometry;
+}): Polygon | MultiPolygon | null;
+/**
+ * Returns a polygon with its rings oriented as RFC 7946 recommends: outer rings
+ * counter-clockwise and holes clockwise.
+ *
+ * @param polygon The Polygon or MultiPolygon, or a feature whose geometry is one; coordinates
+ *   in degrees. Only the orientation changes; self-intersections are left as they are (see
+ *   {@link makeValid})
+ * @returns A geometry of the same type as the input
+ * @throws {@link GeometryError} (`invalid-input`) when the input is not a Polygon or a
+ *   MultiPolygon
+ */
+export declare function rewind(polygon: Polygon | {
+    readonly geometry: Polygon;
+}): Polygon;
+export declare function rewind(polygon: MultiPolygon | {
+    readonly geometry: MultiPolygon;
+}): MultiPolygon;
+export declare function rewind(polygon: Polygon | MultiPolygon | {
+    readonly geometry: Geometry;
+}): Polygon | MultiPolygon;
+/**
+ * Reduces the vertices of a line or a polygon with the Douglas-Peucker algorithm and a
+ * tolerance in meters.
+ *
+ * @param geometry The LineString, Polygon or MultiPolygon, or a feature whose geometry is one;
+ *   coordinates in degrees
+ * @param toleranceMeters The largest distance in meters a removed vertex may lie from the
+ *   simplified line, measured on a plane at the latitude of the center of the bounding box. 0
+ *   or less removes nothing
+ * @returns A geometry of the same type. The ends of a line always remain, and a ring that
+ *   would keep fewer than 4 positions is kept as it is. The result may intersect itself (see
+ *   {@link makeValid})
+ * @throws {@link GeometryError} (`invalid-input`) when the input is not a LineString, a
+ *   Polygon or a MultiPolygon, and when the tolerance is not a finite number
+ *
+ * @example
+ * ```ts
+ * import { simplify } from '@sakuzu/maplibre-gl-draw/geometry';
+ *
+ * // The middle vertex lies about 1 m off the line, within the 5 m tolerance
+ * simplify({ type: 'LineString', coordinates: [[0, 0], [0.001, 0.00001], [0.002, 0]] }, 5);
+ * // { type: 'LineString', coordinates: [[0, 0], [0.002, 0]] }
+ * ```
+ */
+export declare function simplify(geometry: LineString | {
+    readonly geometry: LineString;
+}, toleranceMeters: number): LineString;
+export declare function simplify(geometry: Polygon | {
+    readonly geometry: Polygon;
+}, toleranceMeters: number): Polygon;
+export declare function simplify(geometry: MultiPolygon | {
+    readonly geometry: MultiPolygon;
+}, toleranceMeters: number): MultiPolygon;
+export declare function simplify(geometry: LineString | Polygon | MultiPolygon | {
+    readonly geometry: Geometry;
+}, toleranceMeters: number): LineString | Polygon | MultiPolygon;

package/dist/geometry/public-repair.js

@@ -0,0 +1,77 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { coordinatesBBox } from './bbox.js';
+import { normalizeArea } from './boolean.js';
+import { invalidInput, withOperation } from './errors.js';
+import { areaGeometryOf, areaOf, geometryOf, positionsOf, toAreaGeometry } from './geojson.js';
+import { normalizeMultiPolygonOrientation, normalizePolygonOrientation, simplify as simplifyPath, } from './simplify.js';
+import { metersToDegrees, toRadians } from './units.js';
+/**
+ * Returns a polygon with its self-intersections resolved, its rings oriented and its rings
+ * without an area removed.
+ *
+ * @param polygon The Polygon or MultiPolygon, or a feature whose geometry is one; coordinates
+ *   in degrees. A ring with fewer than 3 positions or a position that is not finite is dropped
+ * @returns A Polygon, or a MultiPolygon when the result falls apart (a figure eight becomes two
+ *   parts), with outer rings counter-clockwise and holes clockwise. null when nothing with an
+ *   area remains
+ * @throws {@link GeometryError} (`invalid-input`) when the input is not a Polygon or a
+ *   MultiPolygon, and (`engine-failure`) when the boolean operation fails
+ */
+export function makeValid(polygon) {
+    const coordinates = areaOf(polygon, 'makeValid');
+    return withOperation('makeValid', () => toAreaGeometry(normalizeArea(coordinates)));
+}
+export function rewind(polygon) {
+    const geometry = areaGeometryOf(polygon, 'rewind');
+    if (geometry.type === 'Polygon') {
+        return {
+            type: 'Polygon',
+            coordinates: normalizePolygonOrientation(geometry.coordinates),
+        };
+    }
+    return {
+        type: 'MultiPolygon',
+        coordinates: normalizeMultiPolygonOrientation(geometry.coordinates),
+    };
+}
+/**
+ * Simplifies a path with a tolerance in meters: the path is scaled to a local plane in which
+ * a degree of longitude is `cos(latitude)` degrees of latitude, and the tolerance is taken in
+ * degrees of latitude
+ */
+function simplifyInMeters(path, toleranceDegrees, lngScale) {
+    const scaled = path.map((position) => [position[0] * lngScale, position[1]]);
+    const indexOf = new Map();
+    scaled.forEach((position, index) => {
+        indexOf.set(position, index);
+    });
+    return simplifyPath(scaled, toleranceDegrees).map((position) => [
+        ...path[indexOf.get(position) ?? 0],
+    ]);
+}
+export function simplify(geometry, toleranceMeters) {
+    const input = geometryOf(geometry, 'simplify');
+    if (input.type !== 'LineString' && input.type !== 'Polygon' && input.type !== 'MultiPolygon') {
+        throw invalidInput('simplify', 'the input is not a LineString, a Polygon or a MultiPolygon');
+    }
+    if (!Number.isFinite(toleranceMeters)) {
+        throw invalidInput('simplify', 'the tolerance is not a finite number');
+    }
+    const box = coordinatesBBox(positionsOf(input));
+    const latitude = box === null ? 0 : (box[1] + box[3]) / 2;
+    const toleranceDegrees = metersToDegrees(toleranceMeters, latitude).lat;
+    const lngScale = Math.cos(toRadians(latitude));
+    const path = (positions) => simplifyInMeters(positions, toleranceDegrees, lngScale);
+    switch (input.type) {
+        case 'LineString':
+            return { type: 'LineString', coordinates: path(input.coordinates) };
+        case 'Polygon':
+            return { type: 'Polygon', coordinates: input.coordinates.map(path) };
+        case 'MultiPolygon':
+            return {
+                type: 'MultiPolygon',
+                coordinates: input.coordinates.map((polygon) => polygon.map(path)),
+            };
+    }
+}

package/dist/geometry/simplify.d.ts

@@ -14,13 +14,6 @@ import type { Coordinate, MultiPolygonCoordinates, PolygonCoordinates, Ring } fr
  *   simplified line
  * @returns The simplified vertices as a new array. A copy of the input for 2 positions or
  *   fewer, for a tolerance that is not positive, and for a ring that would collapse
- *
- * @example
- * ```ts
- * import { simplify } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * simplify([[0, 0], [1, 0.00001], [2, 0], [3, 1]], 0.001); // [[0, 0], [2, 0], [3, 1]]
- * ```
  */
 export declare function simplify(path: Coordinate[], toleranceDegrees: number): Coordinate[];
 /**

package/dist/geometry/simplify.js

@@ -69,13 +69,6 @@ function markKeep(path, first, last, squaredTolerance, keep) {
  *   simplified line
  * @returns The simplified vertices as a new array. A copy of the input for 2 positions or
  *   fewer, for a tolerance that is not positive, and for a ring that would collapse
- *
- * @example
- * ```ts
- * import { simplify } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * simplify([[0, 0], [1, 0.00001], [2, 0], [3, 1]], 0.001); // [[0, 0], [2, 0], [3, 1]]
- * ```
  */
 export function simplify(path, toleranceDegrees) {
     if (path.length <= 2 || !(toleranceDegrees > 0)) {

package/dist/geometry/split.d.ts

@@ -18,14 +18,6 @@ import type { AreaCoordinates, Coordinate, MultiPolygonCoordinates } from './typ
  * @param b2 The end of segment B, `[lng, lat]` in degrees
  * @returns The intersection `[lng, lat]`, taken on segment A. `null` when they do not
  *   cross, are parallel or collinear, or either has length 0
- *
- * @example
- * ```ts
- * import { segmentIntersection } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * segmentIntersection([0, 0], [2, 2], [0, 2], [2, 0]); // [1, 1]
- * segmentIntersection([0, 0], [1, 0], [0, 1], [1, 1]); // null (parallel)
- * ```
  */
 export declare function segmentIntersection(a1: Coordinate, a2: Coordinate, b1: Coordinate, b2: Coordinate): Coordinate | null;
 /**
@@ -52,17 +44,5 @@ export declare function segmentIntersection(a1: Coordinate, a2: Coordinate, b1:
  *   input normalized) when it is not split. An empty array when the input has no area
  * @throws {@link GeometryError} when the boolean operation engine fails even after the
  *   retry on the 1e-9 degree grid
- *
- * @example
- * ```ts
- * import { splitArea } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * const square: [number, number][][] = [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]];
- * const parts = splitArea(square, [[0.5, -1], [0.5, 2]]);
- * parts.length; // 2: the halves west and east of longitude 0.5
- * if (parts.length === 1) {
- *   // Not split: the line does not cross the polygon
- * }
- * ```
  */
 export declare function splitArea(area: AreaCoordinates, line: Coordinate[]): MultiPolygonCoordinates[];

package/dist/geometry/split.js

@@ -64,14 +64,6 @@ const NODE_QUANTUM = 1e-9;
  * @param b2 The end of segment B, `[lng, lat]` in degrees
  * @returns The intersection `[lng, lat]`, taken on segment A. `null` when they do not
  *   cross, are parallel or collinear, or either has length 0
- *
- * @example
- * ```ts
- * import { segmentIntersection } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * segmentIntersection([0, 0], [2, 2], [0, 2], [2, 0]); // [1, 1]
- * segmentIntersection([0, 0], [1, 0], [0, 1], [1, 1]); // null (parallel)
- * ```
  */
 export function segmentIntersection(a1, a2, b1, b2) {
     const ax = a2[0] - a1[0];
@@ -119,18 +111,6 @@ export function segmentIntersection(a1, a2, b1, b2) {
  *   input normalized) when it is not split. An empty array when the input has no area
  * @throws {@link GeometryError} when the boolean operation engine fails even after the
  *   retry on the 1e-9 degree grid
- *
- * @example
- * ```ts
- * import { splitArea } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * const square: [number, number][][] = [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]];
- * const parts = splitArea(square, [[0.5, -1], [0.5, 2]]);
- * parts.length; // 2: the halves west and east of longitude 0.5
- * if (parts.length === 1) {
- *   // Not split: the line does not cross the polygon
- * }
- * ```
  */
 export function splitArea(area, line) {
     const normalized = normalizeArea(area);

package/dist/geometry/units.d.ts

@@ -5,25 +5,18 @@
  * whole geometry module.
  */
 /**
- * The radius of the sphere every geodesic function of this module uses, in meters.
+ * The radius in meters of the sphere on which every function of this entry measures.
  *
- * The value is the mean Earth radius, 6,371,000 m. Distances, bearings, areas, circles and
- * buffers all assume this sphere rather than an ellipsoid, so a result differs from an
- * ellipsoidal computation by up to about 0.5%.
+ * The value is the mean Earth radius of the IUGG, 6,371,008.8 m. Distances, bearings, areas,
+ * circles and buffers all assume this sphere rather than an ellipsoid, so a result differs from
+ * an ellipsoidal computation by up to about 0.5%.
  */
-export declare const EARTH_RADIUS_METERS = 6371000;
+export declare const EARTH_RADIUS_METERS = 6371008.8;
 /**
  * Converts an angle in degrees to radians.
  *
  * @param degrees The angle in degrees
  * @returns The angle in radians. NaN and infinities pass through unchanged
- *
- * @example
- * ```ts
- * import { toRadians } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * toRadians(180); // Math.PI
- * ```
  */
 export declare function toRadians(degrees: number): number;
 /**
@@ -33,3 +26,18 @@ export declare function toRadians(degrees: number): number;
  * @returns The angle in degrees. NaN and infinities pass through unchanged
  */
 export declare function toDegrees(radians: number): number;
+/**
+ * Converts a distance at a latitude into degrees of longitude and latitude.
+ *
+ * On the sphere of {@link EARTH_RADIUS_METERS}: a degree of latitude is always the same
+ * length, and a degree of longitude shrinks with the cosine of the latitude. Use it to turn a
+ * tolerance in meters into one in degrees. Near the poles the longitude grows without bound.
+ *
+ * @param meters The distance in meters
+ * @param latitude The latitude in degrees at which the distance is taken
+ * @returns The distance in degrees of longitude (`lng`) and of latitude (`lat`)
+ */
+export declare function metersToDegrees(meters: number, latitude: number): {
+    lng: number;
+    lat: number;
+};

package/dist/geometry/units.js

@@ -7,25 +7,18 @@
  * whole geometry module.
  */
 /**
- * The radius of the sphere every geodesic function of this module uses, in meters.
+ * The radius in meters of the sphere on which every function of this entry measures.
  *
- * The value is the mean Earth radius, 6,371,000 m. Distances, bearings, areas, circles and
- * buffers all assume this sphere rather than an ellipsoid, so a result differs from an
- * ellipsoidal computation by up to about 0.5%.
+ * The value is the mean Earth radius of the IUGG, 6,371,008.8 m. Distances, bearings, areas,
+ * circles and buffers all assume this sphere rather than an ellipsoid, so a result differs from
+ * an ellipsoidal computation by up to about 0.5%.
  */
-export const EARTH_RADIUS_METERS = 6371000;
+export const EARTH_RADIUS_METERS = 6371008.8;
 /**
  * Converts an angle in degrees to radians.
  *
  * @param degrees The angle in degrees
  * @returns The angle in radians. NaN and infinities pass through unchanged
- *
- * @example
- * ```ts
- * import { toRadians } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * toRadians(180); // Math.PI
- * ```
  */
 export function toRadians(degrees) {
     return (degrees * Math.PI) / 180;
@@ -39,3 +32,18 @@ export function toRadians(degrees) {
 export function toDegrees(radians) {
     return (radians * 180) / Math.PI;
 }
+/**
+ * Converts a distance at a latitude into degrees of longitude and latitude.
+ *
+ * On the sphere of {@link EARTH_RADIUS_METERS}: a degree of latitude is always the same
+ * length, and a degree of longitude shrinks with the cosine of the latitude. Use it to turn a
+ * tolerance in meters into one in degrees. Near the poles the longitude grows without bound.
+ *
+ * @param meters The distance in meters
+ * @param latitude The latitude in degrees at which the distance is taken
+ * @returns The distance in degrees of longitude (`lng`) and of latitude (`lat`)
+ */
+export function metersToDegrees(meters, latitude) {
+    const lat = toDegrees(meters / EARTH_RADIUS_METERS);
+    return { lng: lat / Math.cos(toRadians(latitude)), lat };
+}