@sakuzu/maplibre-gl-draw 1.0.0

package/dist/geometry/buffer.js

@@ -0,0 +1,218 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Buffer
+ *
+ * Generated in meters without interposing a map projection. A point becomes a circle; a
+ * line becomes the union of the circle of each vertex and the band of each edge (a
+ * quadrilateral offset by the distance ±90 degrees from the bearing of the edge); a
+ * polygon becomes the union (positive value) or the difference (negative value) of the
+ * line buffer of its outer and inner rings and the original polygon.
+ *
+ * The offsets are points reached along great circles (destinationPoint, the direct problem
+ * on the sphere), so the distances hold at any latitude; the edges between the generated
+ * points are straight in longitude and latitude. An input out of scope gives null: a
+ * coordinate that is not finite, a vertex whose buffer distance reaches a pole (the parts
+ * would wrap the pole, which a ring in longitude and latitude cannot express), or an edge
+ * that spans more than 180 degrees of longitude (the planar edge then runs the other way
+ * round the globe from its bearing).
+ */
+import { difference, union, unionAll } from './boolean.js';
+import { generateCirclePolygon, normalizeCircleSegments } from './circle.js';
+import { closeRing, isFiniteCoordinate, toMultiPolygonCoordinates } from './coords.js';
+import { destinationPoint, initialBearingDegrees } from './distance.js';
+import { EARTH_RADIUS_METERS, toDegrees } from './units.js';
+/** The default number of segments per circle of {@link buffer}: 64. */
+export const DEFAULT_BUFFER_SEGMENTS = 64;
+/**
+ * The buffer of a point (a geodesic circle)
+ */
+function circlePolygon(center, radius, segments) {
+    return [generateCirclePolygon(center, radius, segments)];
+}
+/**
+ * Drops the duplicates of identical coordinates (the order is preserved)
+ */
+function dedupeVertices(line) {
+    const seen = new Set();
+    const result = [];
+    for (const vertex of line) {
+        const key = `${vertex[0]},${vertex[1]}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        result.push(vertex);
+    }
+    return result;
+}
+/**
+ * Generates the parts that make up the buffer of a line
+ *
+ * Returns the geodesic circle of each vertex and the band of each edge lined up. Taking
+ * the union is up to the caller.
+ */
+function lineBufferParts(line, radius, segments) {
+    // Vertices at identical coordinates produce the same circle twice. The end of a
+    // closed ring is the typical case; drop them for the robustness of polygon-clipping
+    const vertices = dedupeVertices(line);
+    const parts = [];
+    for (const vertex of vertices) {
+        parts.push(circlePolygon(vertex, radius, segments));
+    }
+    for (let i = 0; i < line.length - 1; i++) {
+        const start = line[i];
+        const end = line[i + 1];
+        // An edge of length 0 has no determined bearing. It is covered by the vertex
+        // circles alone
+        if (start[0] === end[0] && start[1] === end[1]) {
+            continue;
+        }
+        // A quadrilateral offset by the distance ±90 degrees from the direction of the great
+        // circle of the edge at each end: the initial bearing at the start and the final bearing
+        // (the reverse bearing turned by 180 degrees) at the end
+        const startBearing = initialBearingDegrees(start, end);
+        const endBearing = initialBearingDegrees(end, start) + 180;
+        parts.push([
+            closeRing([
+                destinationPoint(start, radius, startBearing - 90),
+                destinationPoint(end, radius, endBearing - 90),
+                destinationPoint(end, radius, endBearing + 90),
+                destinationPoint(start, radius, startBearing + 90),
+            ]),
+        ]);
+    }
+    return parts;
+}
+/**
+ * Takes out the lines that make up a geometry (each ring in the case of a polygon)
+ */
+function collectLines(geometry) {
+    switch (geometry.type) {
+        case 'Point':
+            return [[geometry.coordinates]];
+        case 'MultiPoint':
+            return geometry.coordinates.map((coordinate) => [coordinate]);
+        case 'LineString':
+            return [geometry.coordinates];
+        case 'MultiLineString':
+            return geometry.coordinates;
+        default:
+            return toMultiPolygonCoordinates(geometry.coordinates).flat();
+    }
+}
+/**
+ * Determines whether the buffer of the lines at the given radius is out of scope
+ *
+ * Out of scope are a coordinate that is not finite, a vertex whose circle reaches a pole
+ * (the parts would wrap the pole, which a ring in longitude and latitude cannot express) and an edge that spans more
+ * than 180 degrees of longitude (its bearing points the other way round the globe from the
+ * planar edge, so the band would wrap the whole world).
+ */
+function isOutOfScope(lines, radius) {
+    const radiusDegrees = toDegrees(radius / EARTH_RADIUS_METERS);
+    for (const line of lines) {
+        for (let i = 0; i < line.length; i++) {
+            const vertex = line[i];
+            if (!isFiniteCoordinate(vertex) || Math.abs(vertex[1]) + radiusDegrees >= 90) {
+                return true;
+            }
+            if (i > 0 && Math.abs(vertex[0] - line[i - 1][0]) > 180) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Determines whether the geometry is a polygon-family geometry
+ */
+function isAreaGeometry(geometry) {
+    return geometry.type === 'Polygon' || geometry.type === 'MultiPolygon';
+}
+/**
+ * Builds the area within a distance in meters of a geometry.
+ *
+ * The distances are laid out without a map projection, through {@link destinationPoint},
+ * the direct problem on the sphere. Every generated vertex lies at the buffer distance from
+ * its source vertex at any latitude, up to floating-point rounding; the edges between the
+ * generated vertices are straight in longitude and latitude. A point becomes a circle (the
+ * same as {@link generateCirclePolygon}); a line becomes the union of a circle at each
+ * vertex and a band along each edge, offset ±90 degrees from the great-circle bearing of
+ * the edge; a polygon becomes the union (positive distance) or the difference (negative
+ * distance) of the original polygon and the band along its rings.
+ *
+ * | Input | Positive | 0 | Negative |
+ * | --- | --- | --- | --- |
+ * | Point / MultiPoint | circle | `null` | `null` |
+ * | LineString / MultiLineString | band | `null` | `null` |
+ * | Polygon / MultiPolygon | expansion | normalized original | contraction |
+ *
+ * With a negative distance, parts narrower than `2 * |meters|` disappear, and an empty array
+ * is returned when the whole polygon disappears. `null` means the operation is not defined
+ * for the input: the table above, a distance that is not finite, a coordinate that is not
+ * finite, a vertex whose distance reaches a pole (`|lat|` plus the distance in degrees of
+ * latitude is 90 or more), and an edge that spans more than 180 degrees of longitude.
+ *
+ * @param geometry The geometry to buffer, coordinates in degrees
+ * @param meters The buffer distance in meters. A negative value shrinks a polygon
+ * @param options The number of segments per circle
+ * @returns The normalized MultiPolygon coordinates of the area. An empty array when a
+ *   shrunk polygon vanishes. `null` when the operation is not defined for the input
+ * @throws {@link GeometryError} when the boolean operation engine fails even after the
+ *   retry on the 1e-9 degree grid
+ *
+ * @example
+ * ```ts
+ * import { buffer } from '@sakuzu/maplibre-gl-draw/geometry';
+ *
+ * // The area within 100 m of a line
+ * const corridor = buffer(
+ *   { type: 'LineString', coordinates: [[139.76, 35.68], [139.77, 35.69]] },
+ *   100,
+ *   { segments: 32 },
+ * );
+ *
+ * // Shrink a polygon by 50 m
+ * const shrunk = buffer(
+ *   {
+ *     type: 'Polygon',
+ *     coordinates: [[[139.76, 35.68], [139.77, 35.68], [139.77, 35.69], [139.76, 35.68]]],
+ *   },
+ *   -50,
+ * );
+ * if (shrunk === null) {
+ *   // Not defined for the input
+ * } else if (shrunk.length === 0) {
+ *   // The whole area vanished
+ * }
+ * ```
+ */
+export function buffer(geometry, meters, options) {
+    if (!Number.isFinite(meters)) {
+        return null;
+    }
+    const segments = normalizeCircleSegments(options?.segments, DEFAULT_BUFFER_SEGMENTS);
+    const radius = Math.abs(meters);
+    const area = isAreaGeometry(geometry);
+    // The erosion of a point or a line is not defined
+    if (!area && meters <= 0) {
+        return null;
+    }
+    // A zero distance on a polygon is its normalized form, which needs no offset
+    if (area && meters === 0) {
+        return unionAll([geometry.coordinates]);
+    }
+    const lines = collectLines(geometry);
+    if (isOutOfScope(lines, radius)) {
+        return null;
+    }
+    if (!area) {
+        return unionAll(lines.flatMap((line) => lineBufferParts(line, radius, segments)));
+    }
+    const areaCoordinates = geometry.coordinates;
+    // The line buffer of the outer and inner rings (a band of distance |meters| from the
+    // boundary)
+    const boundary = unionAll(lines.flatMap((ring) => lineBufferParts(ring, radius, segments)));
+    return meters > 0 ? union(areaCoordinates, boundary) : difference(areaCoordinates, boundary);
+}

package/dist/geometry/circle.d.ts

@@ -0,0 +1,55 @@
+import type { BBox, Coordinate } from './types.js';
+/**
+ * Normalizes a requested number of vertices of a circle
+ *
+ * The value is rounded down to an integer and clamped to 3-1024. An omitted value and NaN
+ * give the default, so no input makes the generation loop run forever or return a ring
+ * without positions.
+ *
+ * @param segments The requested number of vertices
+ * @param fallback The number used when it is omitted or NaN
+ */
+export declare function normalizeCircleSegments(segments: number | undefined, fallback?: number): number;
+/**
+ * Approximates a geodesic circle with a closed ring.
+ *
+ * The vertices come from {@link destinationPoint}, so each lies at the radius from the
+ * center at any latitude, up to floating-point rounding; only the straight edges between
+ * them fall slightly inside the circle. The first vertex is due north of the center and the
+ * ring runs clockwise. The number of vertices is rounded down and clamped to 3-1024; NaN
+ * gives 64. A circle that reaches a pole cannot be expressed as a ring in longitude and
+ * latitude and is out of scope.
+ *
+ * @param center The center `[lng, lat]` in degrees
+ * @param radiusMeters The radius in meters. 0 gives a ring of identical positions
+ * @param segments The number of vertices (64 by default)
+ * @returns The ring, `segments + 1` positions `[lng, lat]` with the first repeated at the
+ *   end. An empty array for a center that is not finite and for a radius that is negative
+ *   or not finite
+ *
+ * @example
+ * ```ts
+ * import { generateCirclePolygon } from '@sakuzu/maplibre-gl-draw/geometry';
+ *
+ * const ring = generateCirclePolygon([139.767, 35.681], 500, 32);
+ * ring.length; // 33
+ * const polygon = [ring]; // Polygon coordinates
+ * ```
+ */
+export declare function generateCirclePolygon(center: Coordinate, radiusMeters: number, segments?: number): Coordinate[];
+/**
+ * The bounding box of a geodesic circle
+ *
+ * The north and south extremes lie on the meridian of the center. The east and west extremes
+ * are where the circle touches a meridian, at the bearing `acos(tan δ · tan φ)` from the
+ * center (δ the angular radius, φ the latitude of the center), which is poleward of due east
+ * and west. The box is taken from the points reached at those bearings, so it contains the
+ * polygon of {@link generateCirclePolygon} for any number of vertices. A circle that
+ * contains a pole spans 360 degrees of longitude from the center and reaches the pole.
+ *
+ * @param center Center coordinate [lng, lat]
+ * @param radiusMeters Radius (meters)
+ * @returns [minLng, minLat, maxLng, maxLat]. null for a center that is not finite or a
+ *   radius that is negative or not finite
+ */
+export declare function circleBoundingBox(center: Coordinate, radiusMeters: number): BBox | null;

package/dist/geometry/circle.js

@@ -0,0 +1,107 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Circle generation
+ *
+ * Approximates a geodesic circle with a polygon (64 vertices by default). Rendering of the
+ * Circle feature and the buffer of a point share this implementation. The vertices come
+ * from {@link destinationPoint}, the direct problem on the sphere, so every vertex lies at
+ * the radius from the center in haversine distance at any latitude; only the straight
+ * edges between the vertices fall inside the circle.
+ */
+import { isFiniteCoordinate } from './coords.js';
+import { destinationPoint } from './distance.js';
+import { EARTH_RADIUS_METERS, toDegrees } from './units.js';
+/** The default number of vertices of a circle */
+const DEFAULT_CIRCLE_SEGMENTS = 64;
+/** The lower bound of the number of vertices (fewer than a triangle is not a polygon) */
+const MIN_CIRCLE_SEGMENTS = 3;
+/** The upper bound of the number of vertices */
+const MAX_CIRCLE_SEGMENTS = 1024;
+/**
+ * Normalizes a requested number of vertices of a circle
+ *
+ * The value is rounded down to an integer and clamped to 3-1024. An omitted value and NaN
+ * give the default, so no input makes the generation loop run forever or return a ring
+ * without positions.
+ *
+ * @param segments The requested number of vertices
+ * @param fallback The number used when it is omitted or NaN
+ */
+export function normalizeCircleSegments(segments, fallback = DEFAULT_CIRCLE_SEGMENTS) {
+    const requested = segments === undefined || Number.isNaN(segments) ? fallback : segments;
+    return Math.min(MAX_CIRCLE_SEGMENTS, Math.max(MIN_CIRCLE_SEGMENTS, Math.floor(requested)));
+}
+/**
+ * Approximates a geodesic circle with a closed ring.
+ *
+ * The vertices come from {@link destinationPoint}, so each lies at the radius from the
+ * center at any latitude, up to floating-point rounding; only the straight edges between
+ * them fall slightly inside the circle. The first vertex is due north of the center and the
+ * ring runs clockwise. The number of vertices is rounded down and clamped to 3-1024; NaN
+ * gives 64. A circle that reaches a pole cannot be expressed as a ring in longitude and
+ * latitude and is out of scope.
+ *
+ * @param center The center `[lng, lat]` in degrees
+ * @param radiusMeters The radius in meters. 0 gives a ring of identical positions
+ * @param segments The number of vertices (64 by default)
+ * @returns The ring, `segments + 1` positions `[lng, lat]` with the first repeated at the
+ *   end. An empty array for a center that is not finite and for a radius that is negative
+ *   or not finite
+ *
+ * @example
+ * ```ts
+ * import { generateCirclePolygon } from '@sakuzu/maplibre-gl-draw/geometry';
+ *
+ * const ring = generateCirclePolygon([139.767, 35.681], 500, 32);
+ * ring.length; // 33
+ * const polygon = [ring]; // Polygon coordinates
+ * ```
+ */
+export function generateCirclePolygon(center, radiusMeters, segments = DEFAULT_CIRCLE_SEGMENTS) {
+    if (!isFiniteCoordinate(center) || !Number.isFinite(radiusMeters) || radiusMeters < 0) {
+        return [];
+    }
+    const count = normalizeCircleSegments(segments);
+    const coords = [];
+    for (let i = 0; i < count; i++) {
+        // Divide evenly from 0 to 360 degrees (clockwise with north as 0 degrees)
+        const angleDegrees = (360 / count) * i;
+        coords.push(destinationPoint(center, radiusMeters, angleDegrees));
+    }
+    // Append the first point to make the polygon closed
+    coords.push(coords[0]);
+    return coords;
+}
+/**
+ * The bounding box of a geodesic circle
+ *
+ * The north and south extremes lie on the meridian of the center. The east and west extremes
+ * are where the circle touches a meridian, at the bearing `acos(tan δ · tan φ)` from the
+ * center (δ the angular radius, φ the latitude of the center), which is poleward of due east
+ * and west. The box is taken from the points reached at those bearings, so it contains the
+ * polygon of {@link generateCirclePolygon} for any number of vertices. A circle that
+ * contains a pole spans 360 degrees of longitude from the center and reaches the pole.
+ *
+ * @param center Center coordinate [lng, lat]
+ * @param radiusMeters Radius (meters)
+ * @returns [minLng, minLat, maxLng, maxLat]. null for a center that is not finite or a
+ *   radius that is negative or not finite
+ */
+export function circleBoundingBox(center, radiusMeters) {
+    if (!isFiniteCoordinate(center) || !Number.isFinite(radiusMeters) || radiusMeters < 0) {
+        return null;
+    }
+    const [lng, lat] = center;
+    const radiusDegrees = toDegrees(radiusMeters / EARTH_RADIUS_METERS);
+    const north = lat + radiusDegrees;
+    const south = lat - radiusDegrees;
+    if (north >= 90 || south <= -90) {
+        return [lng - 180, Math.max(-90, south), lng + 180, Math.min(90, north)];
+    }
+    const tangent = Math.tan(radiusMeters / EARTH_RADIUS_METERS) * Math.tan((lat * Math.PI) / 180);
+    const eastBearing = toDegrees(Math.acos(Math.min(1, Math.max(-1, tangent))));
+    const east = destinationPoint(center, radiusMeters, eastBearing)[0];
+    const west = destinationPoint(center, radiusMeters, 360 - eastBearing)[0];
+    return [Math.min(west, lng), south, Math.max(east, lng), north];
+}

package/dist/geometry/coords.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Discrimination and normalization of coordinate shapes
+ *
+ * Shared helpers for the operations that accept both Polygon coordinates and
+ * MultiPolygon coordinates.
+ */
+import type { AreaCoordinates, Coordinate, MultiPolygonCoordinates, Ring } from './types.js';
+/**
+ * Determines whether polygon coordinates are MultiPolygon coordinates rather than Polygon
+ * coordinates.
+ *
+ * Polygon coordinates are Ring[] and MultiPolygon coordinates are Ring[][]. The first
+ * non-empty element at the second level is a position of a ring for a Polygon and a ring
+ * for a MultiPolygon, so the two are told apart by whether that element starts with an
+ * array. Empty rings and empty parts are skipped, so a MultiPolygon whose first part is
+ * empty is still recognized. Coordinates with no position at all are treated as a Polygon.
+ *
+ * @param coordinates Polygon or MultiPolygon coordinates
+ * @returns `true` for MultiPolygon coordinates (a type guard). `false` for Polygon
+ *   coordinates and for coordinates with no position
+ *
+ * @example
+ * ```ts
+ * import { isMultiPolygonCoordinates } from '@sakuzu/maplibre-gl-draw/geometry';
+ *
+ * const ring: [number, number][] = [[0, 0], [1, 0], [1, 1], [0, 0]];
+ * isMultiPolygonCoordinates([ring]); // false (Polygon)
+ * isMultiPolygonCoordinates([[ring]]); // true (MultiPolygon)
+ * ```
+ */
+export declare function isMultiPolygonCoordinates(coordinates: AreaCoordinates): coordinates is MultiPolygonCoordinates;
+/**
+ * Determines whether a value is a coordinate whose longitude and latitude are finite
+ * numbers
+ */
+export declare function isFiniteCoordinate(value: unknown): value is Coordinate;
+/**
+ * Determines whether a ring can bound an area: at least 3 positions, every one finite
+ *
+ * A ring that fails this has no area. The functions that take polygons drop such a ring the
+ * same way, and drop a whole part whose outer ring fails (its holes then have nothing to be
+ * holes of).
+ */
+export declare function isUsableRing(ring: Ring): boolean;
+/**
+ * Keeps only the parts and rings that can bound an area (see {@link isUsableRing})
+ *
+ * Returns MultiPolygon coordinates. The arrays of the rings that are kept are not copied.
+ */
+export declare function usableAreaParts(coordinates: AreaCoordinates): MultiPolygonCoordinates;
+/**
+ * Returns Polygon or MultiPolygon coordinates as MultiPolygon coordinates.
+ *
+ * The input array is not copied: MultiPolygon coordinates are returned as they are, and
+ * Polygon coordinates are wrapped as a single part. Nothing is validated or normalized; use
+ * {@link normalizeArea} for that.
+ *
+ * @param coordinates Polygon or MultiPolygon coordinates
+ * @returns MultiPolygon coordinates. An empty array for an empty input
+ */
+export declare function toMultiPolygonCoordinates(coordinates: AreaCoordinates): MultiPolygonCoordinates;
+/**
+ * Determines whether a ring is closed, that is whether its first and last positions are
+ * equal.
+ *
+ * The comparison is exact (`===` on longitude and latitude).
+ *
+ * @param ring A coordinate sequence
+ * @returns `true` when the first and last positions are equal. `false` for fewer than 2
+ *   positions
+ */
+export declare function isRingClosed(ring: Ring): boolean;
+/**
+ * Closes a ring by appending its first position at the end when needed.
+ *
+ * @param ring A coordinate sequence
+ * @returns A new closed array. The input itself when it is already closed or empty
+ *
+ * @example
+ * ```ts
+ * import { closeRing } from '@sakuzu/maplibre-gl-draw/geometry';
+ *
+ * closeRing([[0, 0], [1, 0], [1, 1]]); // [[0, 0], [1, 0], [1, 1], [0, 0]]
+ * ```
+ */
+export declare function closeRing(ring: Ring): Ring;
+/**
+ * Returns every position of Polygon or MultiPolygon coordinates as one flat array.
+ *
+ * Positions are listed part by part and ring by ring, holes included, closing positions
+ * included. Nothing is validated.
+ *
+ * @param coordinates Polygon or MultiPolygon coordinates
+ * @returns A new array of the positions (the position arrays themselves are not copied).
+ *   An empty array for an empty input
+ */
+export declare function flattenAreaCoordinates(coordinates: AreaCoordinates): Coordinate[];

package/dist/geometry/coords.js

@@ -0,0 +1,149 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Determines whether polygon coordinates are MultiPolygon coordinates rather than Polygon
+ * coordinates.
+ *
+ * Polygon coordinates are Ring[] and MultiPolygon coordinates are Ring[][]. The first
+ * non-empty element at the second level is a position of a ring for a Polygon and a ring
+ * for a MultiPolygon, so the two are told apart by whether that element starts with an
+ * array. Empty rings and empty parts are skipped, so a MultiPolygon whose first part is
+ * empty is still recognized. Coordinates with no position at all are treated as a Polygon.
+ *
+ * @param coordinates Polygon or MultiPolygon coordinates
+ * @returns `true` for MultiPolygon coordinates (a type guard). `false` for Polygon
+ *   coordinates and for coordinates with no position
+ *
+ * @example
+ * ```ts
+ * import { isMultiPolygonCoordinates } from '@sakuzu/maplibre-gl-draw/geometry';
+ *
+ * const ring: [number, number][] = [[0, 0], [1, 0], [1, 1], [0, 0]];
+ * isMultiPolygonCoordinates([ring]); // false (Polygon)
+ * isMultiPolygonCoordinates([[ring]]); // true (MultiPolygon)
+ * ```
+ */
+export function isMultiPolygonCoordinates(coordinates) {
+    for (const element of coordinates) {
+        if (!Array.isArray(element))
+            continue;
+        for (const item of element) {
+            if (Array.isArray(item) && item.length > 0)
+                return Array.isArray(item[0]);
+        }
+    }
+    return false;
+}
+/**
+ * Determines whether a value is a coordinate whose longitude and latitude are finite
+ * numbers
+ */
+export function isFiniteCoordinate(value) {
+    return (Array.isArray(value) &&
+        value.length >= 2 &&
+        typeof value[0] === 'number' &&
+        typeof value[1] === 'number' &&
+        Number.isFinite(value[0]) &&
+        Number.isFinite(value[1]));
+}
+/**
+ * Determines whether a ring can bound an area: at least 3 positions, every one finite
+ *
+ * A ring that fails this has no area. The functions that take polygons drop such a ring the
+ * same way, and drop a whole part whose outer ring fails (its holes then have nothing to be
+ * holes of).
+ */
+export function isUsableRing(ring) {
+    return Array.isArray(ring) && ring.length >= 3 && ring.every(isFiniteCoordinate);
+}
+/**
+ * Keeps only the parts and rings that can bound an area (see {@link isUsableRing})
+ *
+ * Returns MultiPolygon coordinates. The arrays of the rings that are kept are not copied.
+ */
+export function usableAreaParts(coordinates) {
+    const result = [];
+    for (const polygon of toMultiPolygonCoordinates(coordinates)) {
+        if (!Array.isArray(polygon) || polygon.length === 0 || !isUsableRing(polygon[0]))
+            continue;
+        result.push(polygon.filter(isUsableRing));
+    }
+    return result;
+}
+/**
+ * Returns Polygon or MultiPolygon coordinates as MultiPolygon coordinates.
+ *
+ * The input array is not copied: MultiPolygon coordinates are returned as they are, and
+ * Polygon coordinates are wrapped as a single part. Nothing is validated or normalized; use
+ * {@link normalizeArea} for that.
+ *
+ * @param coordinates Polygon or MultiPolygon coordinates
+ * @returns MultiPolygon coordinates. An empty array for an empty input
+ */
+export function toMultiPolygonCoordinates(coordinates) {
+    if (coordinates.length === 0) {
+        return [];
+    }
+    if (isMultiPolygonCoordinates(coordinates)) {
+        return coordinates;
+    }
+    return [coordinates];
+}
+/**
+ * Determines whether a ring is closed, that is whether its first and last positions are
+ * equal.
+ *
+ * The comparison is exact (`===` on longitude and latitude).
+ *
+ * @param ring A coordinate sequence
+ * @returns `true` when the first and last positions are equal. `false` for fewer than 2
+ *   positions
+ */
+export function isRingClosed(ring) {
+    if (ring.length < 2) {
+        return false;
+    }
+    const first = ring[0];
+    const last = ring[ring.length - 1];
+    return first[0] === last[0] && first[1] === last[1];
+}
+/**
+ * Closes a ring by appending its first position at the end when needed.
+ *
+ * @param ring A coordinate sequence
+ * @returns A new closed array. The input itself when it is already closed or empty
+ *
+ * @example
+ * ```ts
+ * import { closeRing } from '@sakuzu/maplibre-gl-draw/geometry';
+ *
+ * closeRing([[0, 0], [1, 0], [1, 1]]); // [[0, 0], [1, 0], [1, 1], [0, 0]]
+ * ```
+ */
+export function closeRing(ring) {
+    if (ring.length === 0 || isRingClosed(ring)) {
+        return ring;
+    }
+    return [...ring, ring[0]];
+}
+/**
+ * Returns every position of Polygon or MultiPolygon coordinates as one flat array.
+ *
+ * Positions are listed part by part and ring by ring, holes included, closing positions
+ * included. Nothing is validated.
+ *
+ * @param coordinates Polygon or MultiPolygon coordinates
+ * @returns A new array of the positions (the position arrays themselves are not copied).
+ *   An empty array for an empty input
+ */
+export function flattenAreaCoordinates(coordinates) {
+    const result = [];
+    for (const polygon of toMultiPolygonCoordinates(coordinates)) {
+        for (const ring of polygon) {
+            for (const coordinate of ring) {
+                result.push(coordinate);
+            }
+        }
+    }
+    return result;
+}