@sakuzu/maplibre-gl-draw 1.0.0

package/dist/geometry/measure.js

@@ -0,0 +1,236 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Measurement
+ *
+ * The length is the sum of haversine distances, and the area is based on the spherical
+ * excess of a spherical polygon. The centroid and the representative point are computed
+ * on the lng/lat plane, assuming shapes of the scale of an edit.
+ */
+import { boundingBox } from './bbox.js';
+import { normalizeArea } from './boolean.js';
+import { toMultiPolygonCoordinates } from './coords.js';
+import { haversineDistanceMeters } from './distance.js';
+import { pointInPolygon } from './predicates.js';
+import { EARTH_RADIUS_METERS, toRadians } from './units.js';
+/**
+ * Returns the geodesic length of a path in meters.
+ *
+ * The sum of the {@link haversineDistanceMeters} of each section. For the perimeter of a
+ * polygon pass its closed ring.
+ *
+ * @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;
+    for (let i = 0; i < path.length - 1; i++) {
+        total += haversineDistanceMeters(path[i], path[i + 1]);
+    }
+    return total;
+}
+/**
+ * The spherical area of a ring (signed, square meters)
+ */
+function sphericalRingArea(ring) {
+    if (ring.length < 3) {
+        return 0;
+    }
+    let total = 0;
+    const n = ring.length;
+    for (let i = 0; i < n; i++) {
+        const lower = ring[i];
+        const middle = ring[(i + 1) % n];
+        const upper = ring[(i + 2) % n];
+        total += (toRadians(upper[0]) - toRadians(lower[0])) * Math.sin(toRadians(middle[1]));
+    }
+    return (total * EARTH_RADIUS_METERS * EARTH_RADIUS_METERS) / 2;
+}
+/**
+ * Returns the area of a polygon on the sphere in square meters.
+ *
+ * The input is normalized with {@link normalizeArea} first, so self-intersections are
+ * resolved, a hole outside its outer ring is dropped, a hole larger than its outer ring
+ * empties the part, and rings that cannot bound an area are dropped. The holes of the
+ * normalized form lie inside their outer ring, so subtracting them never makes the result
+ * negative. For a MultiPolygon the sum of each part is returned. Ring orientation does not
+ * matter. The area is based on the spherical excess on a sphere of radius
+ * {@link EARTH_RADIUS_METERS}.
+ *
+ * @param polygon Polygon or MultiPolygon coordinates in degrees
+ * @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;
+    for (const part of normalizeArea(polygon)) {
+        for (let i = 0; i < part.length; i++) {
+            const ringArea = Math.abs(sphericalRingArea(part[i]));
+            total += i === 0 ? ringArea : -ringArea;
+        }
+    }
+    return total;
+}
+/**
+ * Returns the centroid of a ring (weighted by area) and its signed area
+ */
+function ringCentroid(ring) {
+    if (ring.length < 3) {
+        return null;
+    }
+    let cx = 0;
+    let cy = 0;
+    let doubleArea = 0;
+    for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+        const cross = ring[j][0] * ring[i][1] - ring[i][0] * ring[j][1];
+        doubleArea += cross;
+        cx += (ring[j][0] + ring[i][0]) * cross;
+        cy += (ring[j][1] + ring[i][1]) * cross;
+    }
+    if (doubleArea === 0) {
+        return null;
+    }
+    const area = doubleArea / 2;
+    return { centroid: [cx / (6 * area), cy / (6 * area)], area };
+}
+/**
+ * The mean coordinate of all the vertices (the fallback for a shape whose area is 0)
+ */
+function verticesMean(polygon) {
+    let sumLng = 0;
+    let sumLat = 0;
+    let count = 0;
+    for (const part of toMultiPolygonCoordinates(polygon)) {
+        for (const ring of part) {
+            for (const [lng, lat] of ring) {
+                sumLng += lng;
+                sumLat += lat;
+                count++;
+            }
+        }
+    }
+    return count === 0 ? null : [sumLng / count, sumLat / count];
+}
+/**
+ * Returns the area-weighted centroid of a polygon.
+ *
+ * The area of the holes is subtracted, and the parts of a MultiPolygon are combined with
+ * their areas as the weights. The computation is on the lng/lat plane, an approximation
+ * meant for shapes of the scale of an edit. The centroid of a concave shape can fall
+ * outside it; use {@link pointOnSurface} for a point that is always inside.
+ *
+ * @param polygon Polygon or MultiPolygon coordinates in degrees
+ * @returns The centroid `[lng, lat]` in degrees. The mean of all the vertices when the area
+ *   is 0. `null` when there is not a single position
+ */
+export function centroid(polygon) {
+    let sumLng = 0;
+    let sumLat = 0;
+    let sumArea = 0;
+    for (const part of toMultiPolygonCoordinates(polygon)) {
+        for (let i = 0; i < part.length; i++) {
+            const result = ringCentroid(part[i]);
+            if (result === null) {
+                continue;
+            }
+            // Give the outer ring a positive weight and the inner rings a negative one
+            const weight = i === 0 ? Math.abs(result.area) : -Math.abs(result.area);
+            sumLng += result.centroid[0] * weight;
+            sumLat += result.centroid[1] * weight;
+            sumArea += weight;
+        }
+    }
+    if (sumArea === 0) {
+        return verticesMean(polygon);
+    }
+    return [sumLng / sumArea, sumLat / sumArea];
+}
+/**
+ * Returns, in ascending order, the longitudes of the intersections of the horizontal
+ * scanline at the given latitude with each ring
+ */
+function scanlineCrossings(polygon, lat) {
+    const crossings = [];
+    for (const part of toMultiPolygonCoordinates(polygon)) {
+        for (const ring of part) {
+            for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+                const [xi, yi] = ring[i];
+                const [xj, yj] = ring[j];
+                // Counting on a half-open interval avoids double-counting a vertex
+                if (yi > lat !== yj > lat) {
+                    crossings.push(xi + ((lat - yi) / (yj - yi)) * (xj - xi));
+                }
+            }
+        }
+    }
+    return crossings.sort((a, b) => a - b);
+}
+/**
+ * Returns a representative point that lies inside a polygon, such as a label anchor.
+ *
+ * If the {@link centroid} is inside the polygon, it is returned. If it is outside (a
+ * concave shape, or a centroid in a hole), a horizontal scanline is drawn at the latitude of
+ * the centroid and the midpoint of the longest interior section is returned. For a
+ * degenerate shape the scanline does not cross, the center of the bounding box is returned.
+ *
+ * @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);
+    if (center === null) {
+        return null;
+    }
+    if (pointInPolygon(center, polygon)) {
+        return center;
+    }
+    const lat = center[1];
+    const crossings = scanlineCrossings(polygon, lat);
+    let bestStart = Number.NaN;
+    let bestWidth = -1;
+    // By the even-odd rule, the intervals formed by pairing the intersections two at a
+    // time in ascending order are the interior
+    for (let i = 0; i + 1 < crossings.length; i += 2) {
+        const width = crossings[i + 1] - crossings[i];
+        if (width > bestWidth) {
+            bestWidth = width;
+            bestStart = crossings[i];
+        }
+    }
+    if (bestWidth < 0) {
+        // A degenerate shape in which the scanline does not pass through the interior.
+        // Fall back to the center of the bbox
+        const box = boundingBox(polygon);
+        return box === null ? center : [(box[0] + box[2]) / 2, (box[1] + box[3]) / 2];
+    }
+    return [bestStart + bestWidth / 2, lat];
+}

package/dist/geometry/predicates.d.ts

@@ -0,0 +1,62 @@
+import type { AreaCoordinates, Coordinate } from './types.js';
+/**
+ * Determines whether a point is inside a polygon, holes taken into account.
+ *
+ * The test is ray casting on the lng/lat plane; the result for a point exactly on the
+ * boundary is undefined. Ring orientation does not matter. No boolean operation is run, so
+ * it never throws.
+ *
+ * @param point The position `[lng, lat]` in degrees
+ * @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;
+/**
+ * Determines whether two polygons overlap with a positive area.
+ *
+ * A touch that shares only the boundary has no area, so it gives `false`. The bounding boxes
+ * are compared first, and the boolean operation runs only when they overlap.
+ *
+ * @param a Polygon or MultiPolygon coordinates in degrees
+ * @param b Polygon or MultiPolygon coordinates in degrees
+ * @returns `true` when the common part has an area. `false` when either input has no
+ *   finite position
+ * @throws {@link GeometryError} when the boolean operation engine fails even after the
+ *   retry on the 1e-9 degree grid
+ */
+export declare function intersects(a: AreaCoordinates, b: AreaCoordinates): boolean;
+/**
+ * Determines whether one polygon completely contains another.
+ *
+ * Sharing the boundary is allowed. The bounding boxes are compared first.
+ *
+ * @param outer The containing Polygon or MultiPolygon coordinates, in degrees
+ * @param inner The contained Polygon or MultiPolygon coordinates, in degrees
+ * @returns `true` when no part of `inner` lies outside `outer`. `false` when `inner` has no
+ *   area
+ * @throws {@link GeometryError} when the boolean operation engine fails even after the
+ *   retry on the 1e-9 degree grid
+ */
+export declare function contains(outer: AreaCoordinates, inner: AreaCoordinates): boolean;
+/**
+ * Determines whether one polygon lies completely inside another; {@link contains} with its
+ * arguments swapped.
+ *
+ * @param inner The contained Polygon or MultiPolygon coordinates, in degrees
+ * @param outer The containing Polygon or MultiPolygon coordinates, in degrees
+ * @returns `true` when no part of `inner` lies outside `outer`. `false` when `inner` has no
+ *   area
+ * @throws {@link GeometryError} when the boolean operation engine fails even after the
+ *   retry on the 1e-9 degree grid
+ */
+export declare function within(inner: AreaCoordinates, outer: AreaCoordinates): boolean;

package/dist/geometry/predicates.js

@@ -0,0 +1,132 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Predicates
+ *
+ * A test between polygons returns false early with the preliminary check on the bbox
+ * before proceeding to the topological test by polygon-clipping. Every test is
+ * area-based, so a touch that shares only the boundary is not regarded as an
+ * intersection.
+ */
+import { bboxContains, bboxIntersects, boundingBox } from './bbox.js';
+import { difference, intersection, normalizeArea } from './boolean.js';
+import { toMultiPolygonCoordinates } from './coords.js';
+/**
+ * Whether a point is inside a ring (ray casting; the treatment on the boundary is
+ * undefined)
+ */
+function pointInRing(point, ring) {
+    const [x, y] = point;
+    let inside = false;
+    for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+        const [xi, yi] = ring[i];
+        const [xj, yj] = ring[j];
+        // Whether the scanline y crosses the edge (counted on a half-open interval, which
+        // avoids double-counting a vertex)
+        if (yi > y !== yj > y) {
+            const t = (y - yi) / (yj - yi);
+            if (x < xi + t * (xj - xi)) {
+                inside = !inside;
+            }
+        }
+    }
+    return inside;
+}
+/**
+ * Determines whether a point is inside a polygon, holes taken into account.
+ *
+ * The test is ray casting on the lng/lat plane; the result for a point exactly on the
+ * boundary is undefined. Ring orientation does not matter. No boolean operation is run, so
+ * it never throws.
+ *
+ * @param point The position `[lng, lat]` in degrees
+ * @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)) {
+        if (part.length === 0 || !pointInRing(point, part[0])) {
+            continue;
+        }
+        let inHole = false;
+        for (let i = 1; i < part.length; i++) {
+            if (pointInRing(point, part[i])) {
+                inHole = true;
+                break;
+            }
+        }
+        if (!inHole) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Determines whether two polygons overlap with a positive area.
+ *
+ * A touch that shares only the boundary has no area, so it gives `false`. The bounding boxes
+ * are compared first, and the boolean operation runs only when they overlap.
+ *
+ * @param a Polygon or MultiPolygon coordinates in degrees
+ * @param b Polygon or MultiPolygon coordinates in degrees
+ * @returns `true` when the common part has an area. `false` when either input has no
+ *   finite position
+ * @throws {@link GeometryError} when the boolean operation engine fails even after the
+ *   retry on the 1e-9 degree grid
+ */
+export function intersects(a, b) {
+    const boxA = boundingBox(a);
+    const boxB = boundingBox(b);
+    if (boxA === null || boxB === null || !bboxIntersects(boxA, boxB)) {
+        return false;
+    }
+    return intersection(a, b).length > 0;
+}
+/**
+ * Determines whether one polygon completely contains another.
+ *
+ * Sharing the boundary is allowed. The bounding boxes are compared first.
+ *
+ * @param outer The containing Polygon or MultiPolygon coordinates, in degrees
+ * @param inner The contained Polygon or MultiPolygon coordinates, in degrees
+ * @returns `true` when no part of `inner` lies outside `outer`. `false` when `inner` has no
+ *   area
+ * @throws {@link GeometryError} when the boolean operation engine fails even after the
+ *   retry on the 1e-9 degree grid
+ */
+export function contains(outer, inner) {
+    const boxOuter = boundingBox(outer);
+    const boxInner = boundingBox(inner);
+    if (boxOuter === null || boxInner === null || !bboxContains(boxOuter, boxInner)) {
+        return false;
+    }
+    // When inner has no area, it is not subject to the test
+    if (normalizeArea(inner).length === 0) {
+        return false;
+    }
+    return difference(inner, outer).length === 0;
+}
+/**
+ * Determines whether one polygon lies completely inside another; {@link contains} with its
+ * arguments swapped.
+ *
+ * @param inner The contained Polygon or MultiPolygon coordinates, in degrees
+ * @param outer The containing Polygon or MultiPolygon coordinates, in degrees
+ * @returns `true` when no part of `inner` lies outside `outer`. `false` when `inner` has no
+ *   area
+ * @throws {@link GeometryError} when the boolean operation engine fails even after the
+ *   retry on the 1e-9 degree grid
+ */
+export function within(inner, outer) {
+    return contains(outer, inner);
+}

package/dist/geometry/simplify.d.ts

@@ -0,0 +1,74 @@
+import type { Coordinate, MultiPolygonCoordinates, PolygonCoordinates, Ring } from './types.js';
+/**
+ * Simplifies a coordinate sequence by the Douglas-Peucker algorithm.
+ *
+ * The tolerance is a distance on the lng/lat plane in degrees, not in meters: 0.00001
+ * degrees is about 1.1 m of latitude, and a degree of longitude shrinks with `cos(lat)`.
+ * The endpoints always remain. When the input is a closed ring, it is returned still
+ * closed. When the ring would collapse to fewer than 4 points it would lose its area, so
+ * the input is returned as it is. A tolerance that is not a positive number (0, a negative value or NaN) simplifies
+ * nothing and returns a copy of the input.
+ *
+ * @param path The vertices `[lng, lat]` in degrees
+ * @param toleranceDegrees The largest distance in degrees a dropped vertex may lie from the
+ *   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[];
+/**
+ * Returns the signed planar area of a ring in square degrees; counter-clockwise is
+ * positive.
+ *
+ * The shoelace formula on the lng/lat plane, meant for orientation tests. For an area in
+ * square meters use {@link sphericalArea}. The ring may be open or closed.
+ *
+ * @param ring The ring `[lng, lat][]` in degrees
+ * @returns The signed area in square degrees. 0 for fewer than 3 positions
+ */
+export declare function signedRingArea(ring: Ring): number;
+/**
+ * Determines whether a ring runs clockwise on the lng/lat plane.
+ *
+ * @param ring The ring `[lng, lat][]` in degrees
+ * @returns `true` when it is clockwise. `false` when it is counter-clockwise and for a
+ *   degenerate ring whose area is 0
+ */
+export declare function isRingClockwise(ring: Ring): boolean;
+/**
+ * Returns a ring in the given orientation.
+ *
+ * A degenerate ring with area 0 counts as counter-clockwise.
+ *
+ * @param ring The ring `[lng, lat][]` in degrees
+ * @param clockwise `true` for clockwise and `false` for counter-clockwise
+ * @returns The input itself when it already has the orientation, otherwise a new reversed
+ *   array
+ */
+export declare function normalizeRingOrientation(ring: Ring, clockwise: boolean): Ring;
+/**
+ * Orients the rings of a Polygon as GeoJSON (RFC 7946) recommends: the outer ring
+ * counter-clockwise and the holes clockwise.
+ *
+ * Only the orientation changes; self-intersections and degenerate rings are left as they
+ * are (use {@link normalizeArea} for those).
+ *
+ * @param polygon Polygon coordinates in degrees
+ * @returns New Polygon coordinates; rings already in the orientation are reused
+ */
+export declare function normalizePolygonOrientation(polygon: PolygonCoordinates): PolygonCoordinates;
+/**
+ * Orients the rings of every part of a MultiPolygon as
+ * {@link normalizePolygonOrientation} does.
+ *
+ * @param multiPolygon MultiPolygon coordinates in degrees
+ * @returns New MultiPolygon coordinates; rings already in the orientation are reused
+ */
+export declare function normalizeMultiPolygonOrientation(multiPolygon: MultiPolygonCoordinates): MultiPolygonCoordinates;

package/dist/geometry/simplify.js

@@ -0,0 +1,159 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Shaping
+ *
+ * Simplification by Douglas-Peucker, and the normalization of the ring orientations.
+ * The tolerance is given in degrees (a distance on the lng/lat plane).
+ */
+import { isRingClosed } from './coords.js';
+/**
+ * The square of the distance from a point to a segment (square degrees)
+ */
+function squaredSegmentDistance(point, start, end) {
+    let x = start[0];
+    let y = start[1];
+    const dx = end[0] - x;
+    const dy = end[1] - y;
+    if (dx !== 0 || dy !== 0) {
+        const t = ((point[0] - x) * dx + (point[1] - y) * dy) / (dx * dx + dy * dy);
+        if (t > 1) {
+            x = end[0];
+            y = end[1];
+        }
+        else if (t > 0) {
+            x += dx * t;
+            y += dy * t;
+        }
+    }
+    const px = point[0] - x;
+    const py = point[1] - y;
+    return px * px + py * py;
+}
+/**
+ * The recursive body of Douglas-Peucker (marks the indices that are adopted)
+ */
+function markKeep(path, first, last, squaredTolerance, keep) {
+    let maxSquared = squaredTolerance;
+    let index = -1;
+    for (let i = first + 1; i < last; i++) {
+        const squared = squaredSegmentDistance(path[i], path[first], path[last]);
+        if (squared > maxSquared) {
+            maxSquared = squared;
+            index = i;
+        }
+    }
+    if (index === -1) {
+        return;
+    }
+    keep[index] = true;
+    if (index - first > 1) {
+        markKeep(path, first, index, squaredTolerance, keep);
+    }
+    if (last - index > 1) {
+        markKeep(path, index, last, squaredTolerance, keep);
+    }
+}
+/**
+ * Simplifies a coordinate sequence by the Douglas-Peucker algorithm.
+ *
+ * The tolerance is a distance on the lng/lat plane in degrees, not in meters: 0.00001
+ * degrees is about 1.1 m of latitude, and a degree of longitude shrinks with `cos(lat)`.
+ * The endpoints always remain. When the input is a closed ring, it is returned still
+ * closed. When the ring would collapse to fewer than 4 points it would lose its area, so
+ * the input is returned as it is. A tolerance that is not a positive number (0, a negative value or NaN) simplifies
+ * nothing and returns a copy of the input.
+ *
+ * @param path The vertices `[lng, lat]` in degrees
+ * @param toleranceDegrees The largest distance in degrees a dropped vertex may lie from the
+ *   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)) {
+        return [...path];
+    }
+    const keep = new Array(path.length).fill(false);
+    keep[0] = true;
+    keep[path.length - 1] = true;
+    markKeep(path, 0, path.length - 1, toleranceDegrees * toleranceDegrees, keep);
+    const result = path.filter((_, index) => keep[index]);
+    if (isRingClosed(path) && result.length < 4) {
+        return [...path];
+    }
+    return result;
+}
+/**
+ * Returns the signed planar area of a ring in square degrees; counter-clockwise is
+ * positive.
+ *
+ * The shoelace formula on the lng/lat plane, meant for orientation tests. For an area in
+ * square meters use {@link sphericalArea}. The ring may be open or closed.
+ *
+ * @param ring The ring `[lng, lat][]` in degrees
+ * @returns The signed area in square degrees. 0 for fewer than 3 positions
+ */
+export function signedRingArea(ring) {
+    if (ring.length < 3) {
+        return 0;
+    }
+    let total = 0;
+    for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+        total += (ring[j][0] + ring[i][0]) * (ring[j][1] - ring[i][1]);
+    }
+    return -total / 2;
+}
+/**
+ * Determines whether a ring runs clockwise on the lng/lat plane.
+ *
+ * @param ring The ring `[lng, lat][]` in degrees
+ * @returns `true` when it is clockwise. `false` when it is counter-clockwise and for a
+ *   degenerate ring whose area is 0
+ */
+export function isRingClockwise(ring) {
+    return signedRingArea(ring) < 0;
+}
+/**
+ * Returns a ring in the given orientation.
+ *
+ * A degenerate ring with area 0 counts as counter-clockwise.
+ *
+ * @param ring The ring `[lng, lat][]` in degrees
+ * @param clockwise `true` for clockwise and `false` for counter-clockwise
+ * @returns The input itself when it already has the orientation, otherwise a new reversed
+ *   array
+ */
+export function normalizeRingOrientation(ring, clockwise) {
+    return isRingClockwise(ring) === clockwise ? ring : [...ring].reverse();
+}
+/**
+ * Orients the rings of a Polygon as GeoJSON (RFC 7946) recommends: the outer ring
+ * counter-clockwise and the holes clockwise.
+ *
+ * Only the orientation changes; self-intersections and degenerate rings are left as they
+ * are (use {@link normalizeArea} for those).
+ *
+ * @param polygon Polygon coordinates in degrees
+ * @returns New Polygon coordinates; rings already in the orientation are reused
+ */
+export function normalizePolygonOrientation(polygon) {
+    return polygon.map((ring, index) => normalizeRingOrientation(ring, index > 0));
+}
+/**
+ * Orients the rings of every part of a MultiPolygon as
+ * {@link normalizePolygonOrientation} does.
+ *
+ * @param multiPolygon MultiPolygon coordinates in degrees
+ * @returns New MultiPolygon coordinates; rings already in the orientation are reused
+ */
+export function normalizeMultiPolygonOrientation(multiPolygon) {
+    return multiPolygon.map(normalizePolygonOrientation);
+}