@sakuzu/maplibre-gl-draw 1.0.0 → 2.0.0

package/dist/geometry/index.js

@@ -1,38 +1,50 @@
 // SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
 // SPDX-License-Identifier: AGPL-3.0-only
 /**
- * Geometry module
+ * Geometry calculations that need no map.
  *
- * A collection of pure functions independent of the rendering and editing machinery.
- * It does not depend on maplibre, the DOM, wasm, the Store or events, and its only
- * runtime dependency is polygon-clipping. The same input produces the same output
- * regardless of the environment, and determinism is guaranteed by the version of the
- * package.
+ * Measure lengths and areas, build circles and buffers, combine polygons, test whether a
+ * point lies in a polygon, and tidy shapes. They also work in code that does not use the
+ * drawing engine (workers, servers, tests).
  *
- * As a limitation, crossing the ±180 degree meridian and the vicinity of the poles are
- * out of scope.
+ * ```ts
+ * import { area, buffer, union } from '@sakuzu/maplibre-gl-draw/geometry';
+ *
+ * const a = draw.features.get('park');
+ * const b = draw.features.get('lake');
+ * const merged = union([a, b]);            // Polygon | MultiPolygon | null
+ * const zone = buffer(merged, 300);        // the area within 300 m
+ * console.log(area(zone) / 1e6, 'km²');
+ * ```
+ *
+ * The functions take GeoJSON geometries, or anything with a `geometry` field whose geometry
+ * they use (GeoJSON features and the features of the drawing), and return GeoJSON geometries. Lengths, distances, radii and tolerances are in meters, areas in
+ * square meters, and bearings and coordinates in degrees. An input whose shape a function
+ * cannot take throws a {@link GeometryError}; a computation whose result is empty returns null.
+ * Crossing the ±180 degree meridian and the vicinity of the poles are out of scope.
+ *
+ * Read next: the guide
+ * [snapping and geometry](https://sakuzu.github.io/maplibre-gl-draw/guides/snapping-geometry),
+ * which also shows the operations that change the drawing (`draw.features.union` and the
+ * rest). The functions used most are {@link area}, {@link length}, {@link buffer} and
+ * {@link union}.
+ *
+ * @module geometry
  */
-// Coordinate generation from a bearing
-export { getPointAtAngle } from './angle.js';
-// Bounding box
-export { bboxContains, bboxIntersects, boundingBox, coordinatesBBox } from './bbox.js';
-// Boolean operations
-export { clip, difference, differenceAll, intersection, intersectionAll, normalizeArea, union, unionAll, } from './boolean.js';
-export { buffer, DEFAULT_BUFFER_SEGMENTS } from './buffer.js';
-// Geodesic circle
-export { generateCirclePolygon } from './circle.js';
-// Discrimination and normalization of coordinate shapes
-export { closeRing, flattenAreaCoordinates, isMultiPolygonCoordinates, isRingClosed, toMultiPolygonCoordinates, } from './coords.js';
-// Geodesic distance and bearing
-export { destinationPoint, haversineDistanceMeters, initialBearingDegrees } from './distance.js';
+// biome-ignore-all assist/source/organizeImports: the exports are grouped by section
+// Measure
+export { along, area, bearing, centroid, destination, distance, length, midpoint, nearestPointOnLine, perimeter, pointOnSurface, } from './public-measure.js';
+// Create
+export { buffer, circle } from './public-create.js';
+// Combine
+export { difference, intersection, split, union } from './public-combine.js';
+// Test
+export { bboxContains, bboxIntersects } from './bbox.js';
+export { contains, overlaps, pointInPolygon } from './public-predicates.js';
+// Repair
+export { makeValid, rewind, simplify } from './public-repair.js';
+// Bounds and units
+export { bbox } from './public-bounds.js';
+export { metersToDegrees } from './units.js';
 export { GeometryError } from './errors.js';
-// Measurement
-export { centroid, geodesicLength, pointOnSurface, sphericalArea } from './measure.js';
-// Predicates
-export { contains, intersects, pointInPolygon, within } from './predicates.js';
-// Shaping
-export { isRingClockwise, normalizeMultiPolygonOrientation, normalizePolygonOrientation, normalizeRingOrientation, signedRingArea, simplify, } from './simplify.js';
-// Splitting by a line
-export { segmentIntersection, splitArea } from './split.js';
-// Unit conversion and geodetic constants
-export { EARTH_RADIUS_METERS, toDegrees, toRadians } from './units.js';
+export { EARTH_RADIUS_METERS } from './units.js';

package/dist/geometry/measure.d.ts

@@ -8,13 +8,6 @@ import type { AreaCoordinates, Coordinate } from './types.js';
  * @param path The vertices `[lng, lat]` in degrees
  * @returns The length in meters. 0 for fewer than 2 positions. NaN when a position is not
  *   finite
- *
- * @example
- * ```ts
- * import { geodesicLength } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * geodesicLength([[0, 0], [1, 0], [1, 1]]); // about 222,390 m
- * ```
  */
 export declare function geodesicLength(path: Coordinate[]): number;
 /**
@@ -32,14 +25,6 @@ export declare function geodesicLength(path: Coordinate[]): number;
  * @returns The area in square meters. 0 when nothing with an area remains
  * @throws {@link GeometryError} when the boolean operation engine fails even after the
  *   retry on the 1e-9 degree grid
- *
- * @example
- * ```ts
- * import { sphericalArea } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * // A 1 x 1 degree square on the equator
- * sphericalArea([[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]]); // about 1.236e10 m²
- * ```
  */
 export declare function sphericalArea(polygon: AreaCoordinates): number;
 /**
@@ -65,17 +50,5 @@ export declare function centroid(polygon: AreaCoordinates): Coordinate | null;
  *
  * @param polygon Polygon or MultiPolygon coordinates in degrees
  * @returns The point `[lng, lat]` in degrees. `null` when there is not a single position
- *
- * @example
- * ```ts
- * import { centroid, pointOnSurface } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * // A U shape: the centroid falls in the gap between the arms
- * const u: [number, number][][] = [
- *   [[0, 0], [3, 0], [3, 3], [2, 3], [2, 1], [1, 1], [1, 3], [0, 3], [0, 0]],
- * ];
- * centroid(u); // [1.5, 1.357...] (outside)
- * pointOnSurface(u); // [0.5, 1.357...] (inside the left arm)
- * ```
  */
 export declare function pointOnSurface(polygon: AreaCoordinates): Coordinate | null;

package/dist/geometry/measure.js

@@ -22,13 +22,6 @@ import { EARTH_RADIUS_METERS, toRadians } from './units.js';
  * @param path The vertices `[lng, lat]` in degrees
  * @returns The length in meters. 0 for fewer than 2 positions. NaN when a position is not
  *   finite
- *
- * @example
- * ```ts
- * import { geodesicLength } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * geodesicLength([[0, 0], [1, 0], [1, 1]]); // about 222,390 m
- * ```
  */
 export function geodesicLength(path) {
     let total = 0;
@@ -69,14 +62,6 @@ function sphericalRingArea(ring) {
  * @returns The area in square meters. 0 when nothing with an area remains
  * @throws {@link GeometryError} when the boolean operation engine fails even after the
  *   retry on the 1e-9 degree grid
- *
- * @example
- * ```ts
- * import { sphericalArea } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * // A 1 x 1 degree square on the equator
- * sphericalArea([[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]]); // about 1.236e10 m²
- * ```
  */
 export function sphericalArea(polygon) {
     let total = 0;
@@ -192,18 +177,6 @@ function scanlineCrossings(polygon, lat) {
  *
  * @param polygon Polygon or MultiPolygon coordinates in degrees
  * @returns The point `[lng, lat]` in degrees. `null` when there is not a single position
- *
- * @example
- * ```ts
- * import { centroid, pointOnSurface } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * // A U shape: the centroid falls in the gap between the arms
- * const u: [number, number][][] = [
- *   [[0, 0], [3, 0], [3, 3], [2, 3], [2, 1], [1, 1], [1, 3], [0, 3], [0, 0]],
- * ];
- * centroid(u); // [1.5, 1.357...] (outside)
- * pointOnSurface(u); // [0.5, 1.357...] (inside the left arm)
- * ```
  */
 export function pointOnSurface(polygon) {
     const center = centroid(polygon);

package/dist/geometry/predicates.d.ts

@@ -10,15 +10,6 @@ import type { AreaCoordinates, Coordinate } from './types.js';
  * @param polygon Polygon or MultiPolygon coordinates in degrees
  * @returns `true` when the point is inside an outer ring and inside none of its holes (in
  *   any part of a MultiPolygon). `false` for empty coordinates
- *
- * @example
- * ```ts
- * import { pointInPolygon } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * const square: [number, number][][] = [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]];
- * pointInPolygon([0.5, 0.5], square); // true
- * pointInPolygon([2, 0.5], square); // false
- * ```
  */
 export declare function pointInPolygon(point: Coordinate, polygon: AreaCoordinates): boolean;
 /**

package/dist/geometry/predicates.js

@@ -43,15 +43,6 @@ function pointInRing(point, ring) {
  * @param polygon Polygon or MultiPolygon coordinates in degrees
  * @returns `true` when the point is inside an outer ring and inside none of its holes (in
  *   any part of a MultiPolygon). `false` for empty coordinates
- *
- * @example
- * ```ts
- * import { pointInPolygon } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * const square: [number, number][][] = [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]];
- * pointInPolygon([0.5, 0.5], square); // true
- * pointInPolygon([2, 0.5], square); // false
- * ```
  */
 export function pointInPolygon(point, polygon) {
     for (const part of toMultiPolygonCoordinates(polygon)) {

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

@@ -0,0 +1,26 @@
+/**
+ * Bounds: the public bounding box of a geometry
+ */
+import type { Geometry } from 'geojson';
+import type { BBox } from './types.js';
+/**
+ * Returns the bounding box `[minLng, minLat, maxLng, maxLat]` in degrees of a geometry.
+ *
+ * @param geometry The geometry, or a feature whose geometry it is; coordinates in degrees.
+ *   Every position counts, the holes and the members of a collection included; a position
+ *   that is not finite is skipped. Crossing the ±180 degree meridian is not handled
+ * @returns The box in degrees
+ * @throws {@link GeometryError} (`invalid-input`) when the input is not a geometry or a feature
+ *   with one, and when it has no finite position
+ *
+ * @example
+ * ```ts
+ * import { bbox } from '@sakuzu/maplibre-gl-draw/geometry';
+ *
+ * bbox({ type: 'LineString', coordinates: [[139.7, 35.6], [139.8, 35.7]] });
+ * // [139.7, 35.6, 139.8, 35.7]
+ * ```
+ */
+export declare function bbox(geometry: Geometry | {
+    readonly geometry: Geometry;
+}): BBox;

package/dist/geometry/public-bounds.js

@@ -0,0 +1,30 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { coordinatesBBox } from './bbox.js';
+import { invalidInput } from './errors.js';
+import { geometryOf, positionsOf } from './geojson.js';
+/**
+ * Returns the bounding box `[minLng, minLat, maxLng, maxLat]` in degrees of a geometry.
+ *
+ * @param geometry The geometry, or a feature whose geometry it is; coordinates in degrees.
+ *   Every position counts, the holes and the members of a collection included; a position
+ *   that is not finite is skipped. Crossing the ±180 degree meridian is not handled
+ * @returns The box in degrees
+ * @throws {@link GeometryError} (`invalid-input`) when the input is not a geometry or a feature
+ *   with one, and when it has no finite position
+ *
+ * @example
+ * ```ts
+ * import { bbox } from '@sakuzu/maplibre-gl-draw/geometry';
+ *
+ * bbox({ type: 'LineString', coordinates: [[139.7, 35.6], [139.8, 35.7]] });
+ * // [139.7, 35.6, 139.8, 35.7]
+ * ```
+ */
+export function bbox(geometry) {
+    const box = coordinatesBBox(positionsOf(geometryOf(geometry, 'bbox')));
+    if (box === null) {
+        throw invalidInput('bbox', 'the geometry has no finite position');
+    }
+    return box;
+}

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

@@ -0,0 +1,78 @@
+/**
+ * Combine: the public boolean operations on polygons and the split by a line
+ */
+import type { Geometry, LineString, MultiPolygon, Polygon } from 'geojson';
+/**
+ * Returns the union of polygons.
+ *
+ * @param polygons The Polygons and MultiPolygons, or features whose geometry is one;
+ *   coordinates in degrees. Rings with fewer than 3 positions or a position that is not finite
+ *   are left out
+ * @returns A Polygon, or a MultiPolygon when the union falls apart, with self-intersections
+ *   resolved and the rings oriented as RFC 7946 recommends. null when nothing has an area
+ * @throws {@link GeometryError} (`invalid-input`) when an element is not a Polygon or a
+ *   MultiPolygon, and (`engine-failure`) when the boolean operation fails
+ *
+ * @example
+ * ```ts
+ * import { union } from '@sakuzu/maplibre-gl-draw/geometry';
+ *
+ * union([
+ *   { type: 'Polygon', coordinates: [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]] },
+ *   { type: 'Polygon', coordinates: [[[0.5, 0], [1.5, 0], [1.5, 1], [0.5, 1], [0.5, 0]]] },
+ * ]);
+ * // { type: 'Polygon', coordinates: [[[0, 0], [1.5, 0], [1.5, 1], [0, 1], [0, 0]]] }
+ * ```
+ */
+export declare function union(polygons: readonly (Polygon | MultiPolygon | {
+    readonly geometry: Geometry;
+})[]): Polygon | MultiPolygon | null;
+/**
+ * Returns the part that polygons have in common.
+ *
+ * @param polygons The Polygons and MultiPolygons, or features whose geometry is one;
+ *   coordinates in degrees
+ * @returns A Polygon or a MultiPolygon in the form {@link union} returns. null when the
+ *   polygons share no area (touching boundaries included), when one has no area, and for an
+ *   empty array
+ * @throws {@link GeometryError} (`invalid-input`) when an element is not a Polygon or a
+ *   MultiPolygon, and (`engine-failure`) when the boolean operation fails
+ */
+export declare function intersection(polygons: readonly (Polygon | MultiPolygon | {
+    readonly geometry: Geometry;
+})[]): Polygon | MultiPolygon | null;
+/**
+ * Returns a polygon with other polygons removed from it.
+ *
+ * @param subject The Polygon or MultiPolygon to remove from, or a feature whose geometry is
+ *   one; coordinates in degrees
+ * @param others The Polygons and MultiPolygons to remove, or features whose geometry is one;
+ *   coordinates in degrees
+ * @returns A Polygon or a MultiPolygon in the form {@link union} returns; a removed area inside
+ *   the subject becomes a hole. null when nothing remains
+ * @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 difference(subject: Polygon | MultiPolygon | {
+    readonly geometry: Geometry;
+}, others: readonly (Polygon | MultiPolygon | {
+    readonly geometry: Geometry;
+})[]): Polygon | MultiPolygon | null;
+/**
+ * Cuts a polygon with a line and returns the pieces.
+ *
+ * @param polygon The Polygon or MultiPolygon, or a feature whose geometry is one; coordinates
+ *   in degrees
+ * @param line The cutting LineString, or a feature whose geometry is one; coordinates in
+ *   degrees. A stretch that runs along the boundary does not cut, and positions closer than
+ *   1e-9 degrees count as one
+ * @returns One Polygon per piece, holes kept. When the line does not cut across, the polygon
+ *   itself (one Polygon per part of a MultiPolygon). An empty array when it has no area
+ * @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 split(polygon: Polygon | MultiPolygon | {
+    readonly geometry: Geometry;
+}, line: LineString | {
+    readonly geometry: Geometry;
+}): Polygon[];

package/dist/geometry/public-combine.js

@@ -0,0 +1,82 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { differenceAll, intersectionAll, unionAll } from './boolean.js';
+import { withOperation } from './errors.js';
+import { areaOf, areasOf, lineOf, toAreaGeometry } from './geojson.js';
+import { splitArea } from './split.js';
+/**
+ * Returns the union of polygons.
+ *
+ * @param polygons The Polygons and MultiPolygons, or features whose geometry is one;
+ *   coordinates in degrees. Rings with fewer than 3 positions or a position that is not finite
+ *   are left out
+ * @returns A Polygon, or a MultiPolygon when the union falls apart, with self-intersections
+ *   resolved and the rings oriented as RFC 7946 recommends. null when nothing has an area
+ * @throws {@link GeometryError} (`invalid-input`) when an element is not a Polygon or a
+ *   MultiPolygon, and (`engine-failure`) when the boolean operation fails
+ *
+ * @example
+ * ```ts
+ * import { union } from '@sakuzu/maplibre-gl-draw/geometry';
+ *
+ * union([
+ *   { type: 'Polygon', coordinates: [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]] },
+ *   { type: 'Polygon', coordinates: [[[0.5, 0], [1.5, 0], [1.5, 1], [0.5, 1], [0.5, 0]]] },
+ * ]);
+ * // { type: 'Polygon', coordinates: [[[0, 0], [1.5, 0], [1.5, 1], [0, 1], [0, 0]]] }
+ * ```
+ */
+export function union(polygons) {
+    const inputs = areasOf(polygons, 'union');
+    return withOperation('union', () => toAreaGeometry(unionAll(inputs)));
+}
+/**
+ * Returns the part that polygons have in common.
+ *
+ * @param polygons The Polygons and MultiPolygons, or features whose geometry is one;
+ *   coordinates in degrees
+ * @returns A Polygon or a MultiPolygon in the form {@link union} returns. null when the
+ *   polygons share no area (touching boundaries included), when one has no area, and for an
+ *   empty array
+ * @throws {@link GeometryError} (`invalid-input`) when an element is not a Polygon or a
+ *   MultiPolygon, and (`engine-failure`) when the boolean operation fails
+ */
+export function intersection(polygons) {
+    const inputs = areasOf(polygons, 'intersection');
+    return withOperation('intersection', () => toAreaGeometry(intersectionAll(inputs)));
+}
+/**
+ * Returns a polygon with other polygons removed from it.
+ *
+ * @param subject The Polygon or MultiPolygon to remove from, or a feature whose geometry is
+ *   one; coordinates in degrees
+ * @param others The Polygons and MultiPolygons to remove, or features whose geometry is one;
+ *   coordinates in degrees
+ * @returns A Polygon or a MultiPolygon in the form {@link union} returns; a removed area inside
+ *   the subject becomes a hole. null when nothing remains
+ * @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 difference(subject, others) {
+    const left = areaOf(subject, 'difference');
+    const right = areasOf(others, 'difference');
+    return withOperation('difference', () => toAreaGeometry(differenceAll(left, right)));
+}
+/**
+ * Cuts a polygon with a line and returns the pieces.
+ *
+ * @param polygon The Polygon or MultiPolygon, or a feature whose geometry is one; coordinates
+ *   in degrees
+ * @param line The cutting LineString, or a feature whose geometry is one; coordinates in
+ *   degrees. A stretch that runs along the boundary does not cut, and positions closer than
+ *   1e-9 degrees count as one
+ * @returns One Polygon per piece, holes kept. When the line does not cut across, the polygon
+ *   itself (one Polygon per part of a MultiPolygon). An empty array when it has no area
+ * @throws {@link GeometryError} (`invalid-input`) when an argument is not of the expected
+ *   type, and (`engine-failure`) when the boolean operation fails
+ */
+export function split(polygon, line) {
+    const area = areaOf(polygon, 'split');
+    const path = lineOf(line, 'split');
+    return withOperation('split', () => splitArea(area, path).flatMap((piece) => piece.map((coordinates) => ({ type: 'Polygon', coordinates }))));
+}

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

@@ -0,0 +1,54 @@
+/**
+ * Create: the public functions that build polygons from distances in meters
+ */
+import type { Geometry, MultiPolygon, Point, Polygon, Position } from 'geojson';
+/**
+ * Returns a polygon that approximates the geodesic circle of a radius in meters around a
+ * center.
+ *
+ * @param center The center, a position `[lng, lat]` in degrees or a Point
+ * @param radiusMeters The radius in meters, 0 or more. Every vertex lies at this great-circle
+ *   distance from the center
+ * @param options `segments`, the number of vertices (64 by default, rounded down and clamped
+ *   to 3-1024)
+ * @returns The Polygon, its ring starting due north of the center and running
+ *   counter-clockwise, with the first position repeated at the end
+ * @throws {@link GeometryError} (`invalid-input`) when the center is not a position or a
+ *   Point or is not finite, and when the radius is negative or not finite
+ */
+export declare function circle(center: Position | Point, radiusMeters: number, options?: {
+    segments?: number;
+}): Polygon;
+/**
+ * Returns the area within a distance in meters of a geometry, or a polygon shrunk by it when
+ * the distance is negative.
+ *
+ * @param geometry The geometry, or a feature whose geometry it is; coordinates in degrees. The
+ *   members of a GeometryCollection are buffered one by one and the results merged
+ * @param distanceMeters The distance in meters. A negative distance shrinks a polygon and
+ *   leaves nothing of a point or a line
+ * @param options `segments`, the number of segments of each circle (64 by default, rounded
+ *   down and clamped to 3-1024)
+ * @returns A Polygon, or a MultiPolygon when the area falls apart. null when nothing remains,
+ *   and when a vertex is so close to a pole or an edge so long in longitude (over 180 degrees)
+ *   that the area cannot be drawn in longitude and latitude
+ * @throws {@link GeometryError} (`invalid-input`) when the input is not a geometry or a
+ *   feature with one and when the distance is not a finite number, and (`engine-failure`)
+ *   when merging the parts fails
+ *
+ * @example
+ * ```ts
+ * import { buffer } from '@sakuzu/maplibre-gl-draw/geometry';
+ *
+ * // The area within 100 m of a road
+ * const corridor = buffer(
+ *   { type: 'LineString', coordinates: [[139.76, 35.68], [139.77, 35.69]] },
+ *   100,
+ * );
+ * ```
+ */
+export declare function buffer(geometry: Geometry | {
+    readonly geometry: Geometry;
+}, distanceMeters: number, options?: {
+    segments?: number;
+}): Polygon | MultiPolygon | null;

package/dist/geometry/public-create.js

@@ -0,0 +1,70 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { unionAll } from './boolean.js';
+import { buffer as bufferCoordinates } from './buffer.js';
+import { generateCirclePolygon } from './circle.js';
+import { invalidInput, withOperation } from './errors.js';
+import { geometryOf, positionOf, toAreaGeometry, toPosition } from './geojson.js';
+/**
+ * Returns a polygon that approximates the geodesic circle of a radius in meters around a
+ * center.
+ *
+ * @param center The center, a position `[lng, lat]` in degrees or a Point
+ * @param radiusMeters The radius in meters, 0 or more. Every vertex lies at this great-circle
+ *   distance from the center
+ * @param options `segments`, the number of vertices (64 by default, rounded down and clamped
+ *   to 3-1024)
+ * @returns The Polygon, its ring starting due north of the center and running
+ *   counter-clockwise, with the first position repeated at the end
+ * @throws {@link GeometryError} (`invalid-input`) when the center is not a position or a
+ *   Point or is not finite, and when the radius is negative or not finite
+ */
+export function circle(center, radiusMeters, options) {
+    const ring = generateCirclePolygon(positionOf(center, 'circle'), radiusMeters, options?.segments);
+    if (ring.length === 0) {
+        throw invalidInput('circle', 'the center or the radius is not a finite number');
+    }
+    return { type: 'Polygon', coordinates: [ring.map(toPosition).reverse()] };
+}
+/** The buffer of a geometry as MultiPolygon coordinates, each member of a collection alone */
+function bufferOf(geometry, distanceMeters, segments) {
+    if (geometry.type === 'GeometryCollection') {
+        return unionAll(geometry.geometries.map((member) => bufferOf(geometryOf(member, 'buffer'), distanceMeters, segments)));
+    }
+    return bufferCoordinates(geometry, distanceMeters, { segments }) ?? [];
+}
+/**
+ * Returns the area within a distance in meters of a geometry, or a polygon shrunk by it when
+ * the distance is negative.
+ *
+ * @param geometry The geometry, or a feature whose geometry it is; coordinates in degrees. The
+ *   members of a GeometryCollection are buffered one by one and the results merged
+ * @param distanceMeters The distance in meters. A negative distance shrinks a polygon and
+ *   leaves nothing of a point or a line
+ * @param options `segments`, the number of segments of each circle (64 by default, rounded
+ *   down and clamped to 3-1024)
+ * @returns A Polygon, or a MultiPolygon when the area falls apart. null when nothing remains,
+ *   and when a vertex is so close to a pole or an edge so long in longitude (over 180 degrees)
+ *   that the area cannot be drawn in longitude and latitude
+ * @throws {@link GeometryError} (`invalid-input`) when the input is not a geometry or a
+ *   feature with one and when the distance is not a finite number, and (`engine-failure`)
+ *   when merging the parts fails
+ *
+ * @example
+ * ```ts
+ * import { buffer } from '@sakuzu/maplibre-gl-draw/geometry';
+ *
+ * // The area within 100 m of a road
+ * const corridor = buffer(
+ *   { type: 'LineString', coordinates: [[139.76, 35.68], [139.77, 35.69]] },
+ *   100,
+ * );
+ * ```
+ */
+export function buffer(geometry, distanceMeters, options) {
+    const input = geometryOf(geometry, 'buffer');
+    if (!Number.isFinite(distanceMeters)) {
+        throw invalidInput('buffer', 'the distance is not a finite number');
+    }
+    return withOperation('buffer', () => toAreaGeometry(bufferOf(input, distanceMeters, options?.segments)));
+}