@sakuzu/maplibre-gl-draw 1.0.0 → 2.0.0

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

@@ -0,0 +1,170 @@
+/**
+ * Measure: the public functions that measure distances, bearings, lengths and areas
+ *
+ * Every distance is taken along great circles on the sphere of EARTH_RADIUS_METERS, the
+ * same as the internal haversine and direct-problem functions.
+ */
+import type { Geometry, LineString, MultiLineString, MultiPolygon, Point, Polygon, Position } from 'geojson';
+/**
+ * Returns the great-circle distance in meters between two points.
+ *
+ * @param from The first point, a position `[lng, lat]` in degrees or a Point
+ * @param to The second point, a position `[lng, lat]` in degrees or a Point
+ * @returns The distance in meters on the sphere of {@link EARTH_RADIUS_METERS}. NaN when a
+ *   coordinate is not finite
+ * @throws {@link GeometryError} (`invalid-input`) when an argument is not a position or a
+ *   Point
+ *
+ * @example
+ * ```ts
+ * import { distance } from '@sakuzu/maplibre-gl-draw/geometry';
+ *
+ * distance([139.767, 35.681], [135.495, 34.702]); // about 403,139 m
+ * ```
+ */
+export declare function distance(from: Position | Point, to: Position | Point): number;
+/**
+ * Returns the initial bearing in degrees of the great circle from one point to another.
+ *
+ * @param from The start, a position `[lng, lat]` in degrees or a Point
+ * @param to The end, a position `[lng, lat]` in degrees or a Point
+ * @returns The bearing at the start in degrees, clockwise from north, in [0, 360). 0 when the
+ *   points are identical
+ * @throws {@link GeometryError} (`invalid-input`) when an argument is not a position or a
+ *   Point
+ */
+export declare function bearing(from: Position | Point, to: Position | Point): number;
+/**
+ * Returns the point reached from an origin after a distance in meters along a great circle
+ * that starts at a bearing in degrees.
+ *
+ * @param origin The start, a position `[lng, lat]` in degrees or a Point
+ * @param distanceMeters The distance in meters; a negative value goes the opposite way
+ * @param bearingDegrees The initial bearing in degrees, clockwise from north
+ * @returns The position `[lng, lat]` in degrees. The longitude continues from the origin
+ *   and is not wrapped into [-180, 180]
+ * @throws {@link GeometryError} (`invalid-input`) when the origin is not a position or a
+ *   Point
+ */
+export declare function destination(origin: Position | Point, distanceMeters: number, bearingDegrees: number): Position;
+/**
+ * Returns the point halfway between two points along the great circle that joins them.
+ *
+ * @param from The first point, a position `[lng, lat]` in degrees or a Point
+ * @param to The second point, a position `[lng, lat]` in degrees or a Point
+ * @returns The position `[lng, lat]` in degrees, at the same distance in meters from both
+ *   points. The longitude continues from `from`
+ * @throws {@link GeometryError} (`invalid-input`) when an argument is not a position or a
+ *   Point
+ */
+export declare function midpoint(from: Position | Point, to: Position | Point): Position;
+/**
+ * Returns the point at a distance in meters along a line, measured from its start.
+ *
+ * @param line The LineString, or a feature whose geometry is one; coordinates in degrees
+ * @param distanceMeters The distance from the start in meters. 0 or less gives the start,
+ *   and a distance longer than the line gives its end
+ * @returns The position `[lng, lat]` in degrees
+ * @throws {@link GeometryError} (`invalid-input`) when the line is not a LineString or has no
+ *   position, and when the distance is not a finite number
+ */
+export declare function along(line: LineString | {
+    readonly geometry: Geometry;
+}, distanceMeters: number): Position;
+/**
+ * Returns the point of a line nearest to a given point, with its distance in meters and the
+ * index of the segment it lies on.
+ *
+ * @param line The LineString or MultiLineString, or a feature whose geometry is one;
+ *   coordinates in degrees. Each segment is taken as a great-circle arc
+ * @param point The point, a position `[lng, lat]` in degrees or a Point
+ * @returns `position`, the nearest point `[lng, lat]` in degrees; `distanceMeters`, its
+ *   distance from `point` in meters; and `segmentIndex`, the segment it lies on, counted from
+ *   0 across the lines of a MultiLineString in order (segment `i` of a LineString joins its
+ *   positions `i` and `i + 1`)
+ * @throws {@link GeometryError} (`invalid-input`) when the line is not a LineString or a
+ *   MultiLineString or has no position, and when the point is not a position or a Point
+ */
+export declare function nearestPointOnLine(line: LineString | MultiLineString | {
+    readonly geometry: Geometry;
+}, point: Position | Point): {
+    position: Position;
+    distanceMeters: number;
+    segmentIndex: number;
+};
+/**
+ * Returns the length in meters of a line.
+ *
+ * @param line The LineString or MultiLineString, or a feature whose geometry is one;
+ *   coordinates in degrees
+ * @returns The sum of the great-circle distances of the segments, in meters. 0 for a line
+ *   with fewer than 2 positions
+ * @throws {@link GeometryError} (`invalid-input`) when the input is not a LineString or a
+ *   MultiLineString
+ */
+export declare function length(line: LineString | MultiLineString | {
+    readonly geometry: Geometry;
+}): number;
+/**
+ * Returns the area in square meters of a polygon on the sphere.
+ *
+ * @param polygon The Polygon or MultiPolygon, or a feature whose geometry is one; coordinates
+ *   in degrees. Self-intersections are resolved and ring orientation does not matter
+ * @returns The area in square meters, holes subtracted. 0 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 resolving its self-intersections fails
+ *
+ * @example
+ * ```ts
+ * import { area } from '@sakuzu/maplibre-gl-draw/geometry';
+ *
+ * // A 1 x 1 degree square on the equator
+ * area({ type: 'Polygon', coordinates: [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]] });
+ * // about 1.236e10 m²
+ * ```
+ */
+export declare function area(polygon: Polygon | MultiPolygon | {
+    readonly geometry: Geometry;
+}): number;
+/**
+ * Returns the length in meters of the boundary of a polygon, the rings of its holes included.
+ *
+ * @param polygon The Polygon or MultiPolygon, or a feature whose geometry is one; coordinates
+ *   in degrees. An open ring is measured as if closed; a ring with fewer than 3 positions or a
+ *   position that is not finite is left out
+ * @returns The sum of the great-circle lengths of every ring, in meters
+ * @throws {@link GeometryError} (`invalid-input`) when the input is not a Polygon or a
+ *   MultiPolygon
+ */
+export declare function perimeter(polygon: Polygon | MultiPolygon | {
+    readonly geometry: Geometry;
+}): number;
+/**
+ * Returns the centroid of a polygon, weighted by area.
+ *
+ * @param polygon The Polygon or MultiPolygon, or a feature whose geometry is one; coordinates
+ *   in degrees. Holes are subtracted and the parts are weighted by their areas on the lng/lat
+ *   plane
+ * @returns The centroid as a Point, in degrees; it can fall outside a concave polygon (see
+ *   {@link pointOnSurface}). The mean of the positions when the area is 0. null when there is
+ *   no position
+ * @throws {@link GeometryError} (`invalid-input`) when the input is not a Polygon or a
+ *   MultiPolygon
+ */
+export declare function centroid(polygon: Polygon | MultiPolygon | {
+    readonly geometry: Geometry;
+}): Point | null;
+/**
+ * Returns a point that always lies inside a polygon, such as the anchor of a label.
+ *
+ * @param polygon The Polygon or MultiPolygon, or a feature whose geometry is one; coordinates
+ *   in degrees
+ * @returns The {@link centroid} when it lies inside, otherwise the middle of the widest
+ *   section of the polygon along the parallel of the centroid, as a Point in degrees. null
+ *   when there is no position
+ * @throws {@link GeometryError} (`invalid-input`) when the input is not a Polygon or a
+ *   MultiPolygon
+ */
+export declare function pointOnSurface(polygon: Polygon | MultiPolygon | {
+    readonly geometry: Geometry;
+}): Point | null;

package/dist/geometry/public-measure.js

@@ -0,0 +1,283 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { closeRing, usableAreaParts } from './coords.js';
+import { destinationPoint, haversineDistanceMeters, initialBearingDegrees } from './distance.js';
+import { invalidInput, withOperation } from './errors.js';
+import { areaOf, lineOf, linesOf, positionOf, toPoint, toPosition } from './geojson.js';
+import { geodesicLength, centroid as planarCentroid, pointOnSurface as planarPointOnSurface, sphericalArea, } from './measure.js';
+import { toDegrees, toRadians } from './units.js';
+/**
+ * Returns the great-circle distance in meters between two points.
+ *
+ * @param from The first point, a position `[lng, lat]` in degrees or a Point
+ * @param to The second point, a position `[lng, lat]` in degrees or a Point
+ * @returns The distance in meters on the sphere of {@link EARTH_RADIUS_METERS}. NaN when a
+ *   coordinate is not finite
+ * @throws {@link GeometryError} (`invalid-input`) when an argument is not a position or a
+ *   Point
+ *
+ * @example
+ * ```ts
+ * import { distance } from '@sakuzu/maplibre-gl-draw/geometry';
+ *
+ * distance([139.767, 35.681], [135.495, 34.702]); // about 403,139 m
+ * ```
+ */
+export function distance(from, to) {
+    return haversineDistanceMeters(positionOf(from, 'distance'), positionOf(to, 'distance'));
+}
+/**
+ * Returns the initial bearing in degrees of the great circle from one point to another.
+ *
+ * @param from The start, a position `[lng, lat]` in degrees or a Point
+ * @param to The end, a position `[lng, lat]` in degrees or a Point
+ * @returns The bearing at the start in degrees, clockwise from north, in [0, 360). 0 when the
+ *   points are identical
+ * @throws {@link GeometryError} (`invalid-input`) when an argument is not a position or a
+ *   Point
+ */
+export function bearing(from, to) {
+    return initialBearingDegrees(positionOf(from, 'bearing'), positionOf(to, 'bearing'));
+}
+/**
+ * Returns the point reached from an origin after a distance in meters along a great circle
+ * that starts at a bearing in degrees.
+ *
+ * @param origin The start, a position `[lng, lat]` in degrees or a Point
+ * @param distanceMeters The distance in meters; a negative value goes the opposite way
+ * @param bearingDegrees The initial bearing in degrees, clockwise from north
+ * @returns The position `[lng, lat]` in degrees. The longitude continues from the origin
+ *   and is not wrapped into [-180, 180]
+ * @throws {@link GeometryError} (`invalid-input`) when the origin is not a position or a
+ *   Point
+ */
+export function destination(origin, distanceMeters, bearingDegrees) {
+    return toPosition(destinationPoint(positionOf(origin, 'destination'), distanceMeters, bearingDegrees));
+}
+/**
+ * Returns the point halfway between two points along the great circle that joins them.
+ *
+ * @param from The first point, a position `[lng, lat]` in degrees or a Point
+ * @param to The second point, a position `[lng, lat]` in degrees or a Point
+ * @returns The position `[lng, lat]` in degrees, at the same distance in meters from both
+ *   points. The longitude continues from `from`
+ * @throws {@link GeometryError} (`invalid-input`) when an argument is not a position or a
+ *   Point
+ */
+export function midpoint(from, to) {
+    const [lng1, lat1] = positionOf(from, 'midpoint');
+    const [lng2, lat2] = positionOf(to, 'midpoint');
+    const phi1 = toRadians(lat1);
+    const phi2 = toRadians(lat2);
+    const dLambda = toRadians(lng2 - lng1);
+    const bx = Math.cos(phi2) * Math.cos(dLambda);
+    const by = Math.cos(phi2) * Math.sin(dLambda);
+    const phi = Math.atan2(Math.sin(phi1) + Math.sin(phi2), Math.sqrt((Math.cos(phi1) + bx) ** 2 + by ** 2));
+    const lambda = Math.atan2(by, Math.cos(phi1) + bx);
+    return [lng1 + toDegrees(lambda), toDegrees(phi)];
+}
+/**
+ * Returns the point at a distance in meters along a line, measured from its start.
+ *
+ * @param line The LineString, or a feature whose geometry is one; coordinates in degrees
+ * @param distanceMeters The distance from the start in meters. 0 or less gives the start,
+ *   and a distance longer than the line gives its end
+ * @returns The position `[lng, lat]` in degrees
+ * @throws {@link GeometryError} (`invalid-input`) when the line is not a LineString or has no
+ *   position, and when the distance is not a finite number
+ */
+export function along(line, distanceMeters) {
+    const path = lineOf(line, 'along');
+    if (path.length === 0) {
+        throw invalidInput('along', 'the line has no position');
+    }
+    if (!Number.isFinite(distanceMeters)) {
+        throw invalidInput('along', 'the distance is not a finite number');
+    }
+    let remaining = distanceMeters;
+    if (remaining <= 0)
+        return toPosition(path[0]);
+    for (let i = 0; i < path.length - 1; i++) {
+        const start = path[i];
+        const end = path[i + 1];
+        const section = haversineDistanceMeters(start, end);
+        if (remaining < section) {
+            return toPosition(destinationPoint(start, remaining, initialBearingDegrees(start, end)));
+        }
+        remaining -= section;
+    }
+    return toPosition(path[path.length - 1]);
+}
+function toVector([lng, lat]) {
+    const lambda = toRadians(lng);
+    const phi = toRadians(lat);
+    return [Math.cos(phi) * Math.cos(lambda), Math.cos(phi) * Math.sin(lambda), Math.sin(phi)];
+}
+function cross(a, b) {
+    return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+}
+function dot(a, b) {
+    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function norm(a) {
+    return Math.hypot(a[0], a[1], a[2]);
+}
+/** The vectors shorter than this are treated as zero (a degenerate great circle) */
+const VECTOR_EPSILON = 1e-15;
+/**
+ * The position of a unit vector, with the longitude taken nearest to a reference longitude
+ */
+function toCoordinate(v, nearLng) {
+    const lat = toDegrees(Math.atan2(v[2], Math.hypot(v[0], v[1])));
+    const lng = toDegrees(Math.atan2(v[1], v[0]));
+    return [lng + 360 * Math.round((nearLng - lng) / 360), lat];
+}
+/**
+ * The point of the great-circle arc from a to b nearest to p
+ *
+ * p is projected onto the plane of the great circle through a and b. When the projection
+ * falls on the arc between them, it is the nearest point; otherwise the nearer end is.
+ */
+function nearestOnSegment(p, a, b) {
+    const va = toVector(a);
+    const vb = toVector(b);
+    const vp = toVector(p);
+    const normal = cross(va, vb);
+    const normalLength = norm(normal);
+    if (normalLength < VECTOR_EPSILON)
+        return a;
+    const n = [normal[0] / normalLength, normal[1] / normalLength, normal[2] / normalLength];
+    const offset = dot(vp, n);
+    const projected = [vp[0] - offset * n[0], vp[1] - offset * n[1], vp[2] - offset * n[2]];
+    if (norm(projected) >= VECTOR_EPSILON && dot(cross(va, projected), n) >= 0) {
+        if (dot(cross(projected, vb), n) >= 0) {
+            const size = norm(projected);
+            return toCoordinate([projected[0] / size, projected[1] / size, projected[2] / size], a[0]);
+        }
+    }
+    return haversineDistanceMeters(p, a) <= haversineDistanceMeters(p, b) ? a : b;
+}
+/**
+ * Returns the point of a line nearest to a given point, with its distance in meters and the
+ * index of the segment it lies on.
+ *
+ * @param line The LineString or MultiLineString, or a feature whose geometry is one;
+ *   coordinates in degrees. Each segment is taken as a great-circle arc
+ * @param point The point, a position `[lng, lat]` in degrees or a Point
+ * @returns `position`, the nearest point `[lng, lat]` in degrees; `distanceMeters`, its
+ *   distance from `point` in meters; and `segmentIndex`, the segment it lies on, counted from
+ *   0 across the lines of a MultiLineString in order (segment `i` of a LineString joins its
+ *   positions `i` and `i + 1`)
+ * @throws {@link GeometryError} (`invalid-input`) when the line is not a LineString or a
+ *   MultiLineString or has no position, and when the point is not a position or a Point
+ */
+export function nearestPointOnLine(line, point) {
+    const lines = linesOf(line, 'nearestPointOnLine');
+    const target = positionOf(point, 'nearestPointOnLine');
+    let best = null;
+    let segmentIndex = 0;
+    for (const path of lines) {
+        if (path.length === 0)
+            continue;
+        const segments = Math.max(1, path.length - 1);
+        for (let i = 0; i < segments; i++) {
+            const candidate = path.length === 1 ? path[0] : nearestOnSegment(target, path[i], path[i + 1]);
+            const distanceMeters = haversineDistanceMeters(target, candidate);
+            if (best === null || distanceMeters < best.distanceMeters) {
+                best = { position: candidate, distanceMeters, segmentIndex };
+            }
+            segmentIndex++;
+        }
+    }
+    if (best === null) {
+        throw invalidInput('nearestPointOnLine', 'the line has no position');
+    }
+    return { ...best, position: toPosition(best.position) };
+}
+/**
+ * Returns the length in meters of a line.
+ *
+ * @param line The LineString or MultiLineString, or a feature whose geometry is one;
+ *   coordinates in degrees
+ * @returns The sum of the great-circle distances of the segments, in meters. 0 for a line
+ *   with fewer than 2 positions
+ * @throws {@link GeometryError} (`invalid-input`) when the input is not a LineString or a
+ *   MultiLineString
+ */
+export function length(line) {
+    let total = 0;
+    for (const path of linesOf(line, 'length'))
+        total += geodesicLength(path);
+    return total;
+}
+/**
+ * Returns the area in square meters of a polygon on the sphere.
+ *
+ * @param polygon The Polygon or MultiPolygon, or a feature whose geometry is one; coordinates
+ *   in degrees. Self-intersections are resolved and ring orientation does not matter
+ * @returns The area in square meters, holes subtracted. 0 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 resolving its self-intersections fails
+ *
+ * @example
+ * ```ts
+ * import { area } from '@sakuzu/maplibre-gl-draw/geometry';
+ *
+ * // A 1 x 1 degree square on the equator
+ * area({ type: 'Polygon', coordinates: [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]] });
+ * // about 1.236e10 m²
+ * ```
+ */
+export function area(polygon) {
+    const coordinates = areaOf(polygon, 'area');
+    return withOperation('area', () => sphericalArea(coordinates));
+}
+/**
+ * Returns the length in meters of the boundary of a polygon, the rings of its holes included.
+ *
+ * @param polygon The Polygon or MultiPolygon, or a feature whose geometry is one; coordinates
+ *   in degrees. An open ring is measured as if closed; a ring with fewer than 3 positions or a
+ *   position that is not finite is left out
+ * @returns The sum of the great-circle lengths of every ring, in meters
+ * @throws {@link GeometryError} (`invalid-input`) when the input is not a Polygon or a
+ *   MultiPolygon
+ */
+export function perimeter(polygon) {
+    let total = 0;
+    for (const part of usableAreaParts(areaOf(polygon, 'perimeter'))) {
+        for (const ring of part)
+            total += geodesicLength(closeRing(ring));
+    }
+    return total;
+}
+/**
+ * Returns the centroid of a polygon, weighted by area.
+ *
+ * @param polygon The Polygon or MultiPolygon, or a feature whose geometry is one; coordinates
+ *   in degrees. Holes are subtracted and the parts are weighted by their areas on the lng/lat
+ *   plane
+ * @returns The centroid as a Point, in degrees; it can fall outside a concave polygon (see
+ *   {@link pointOnSurface}). The mean of the positions when the area is 0. null when there is
+ *   no position
+ * @throws {@link GeometryError} (`invalid-input`) when the input is not a Polygon or a
+ *   MultiPolygon
+ */
+export function centroid(polygon) {
+    const result = planarCentroid(areaOf(polygon, 'centroid'));
+    return result === null ? null : toPoint(result);
+}
+/**
+ * Returns a point that always lies inside a polygon, such as the anchor of a label.
+ *
+ * @param polygon The Polygon or MultiPolygon, or a feature whose geometry is one; coordinates
+ *   in degrees
+ * @returns The {@link centroid} when it lies inside, otherwise the middle of the widest
+ *   section of the polygon along the parallel of the centroid, as a Point in degrees. null
+ *   when there is no position
+ * @throws {@link GeometryError} (`invalid-input`) when the input is not a Polygon or a
+ *   MultiPolygon
+ */
+export function pointOnSurface(polygon) {
+    const result = planarPointOnSurface(areaOf(polygon, 'pointOnSurface'));
+    return result === null ? null : toPoint(result);
+}

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));
+}