@sakuzu/maplibre-gl-draw 1.0.0 → 2.1.0

package/dist/geometry/geojson.js

@@ -0,0 +1,173 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { invalidInput } from './errors.js';
+/** The geometry types that carry `coordinates` */
+const COORDINATE_TYPES = new Set([
+    'Point',
+    'MultiPoint',
+    'LineString',
+    'MultiLineString',
+    'Polygon',
+    'MultiPolygon',
+]);
+function isObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+/** Whether a value is an array whose first two elements are numbers */
+function isPosition(value) {
+    return (Array.isArray(value) &&
+        value.length >= 2 &&
+        typeof value[0] === 'number' &&
+        typeof value[1] === 'number');
+}
+/**
+ * Returns the geometry of a geometry, or of anything that carries one in a `geometry` field
+ * (a GeoJSON feature, a feature of the drawing)
+ *
+ * A value whose `geometry` member is a geometry is read as a feature first, whatever its own
+ * `type` says: a feature of the drawing names its feature type there (`'Polygon'`,
+ * `'Circle'`, `'Freehand'` and so on), which is not the type of a geometry it is.
+ *
+ * @throws GeometryError (`invalid-input`) for a value that is neither, and for a feature
+ *   without a geometry
+ */
+export function geometryOf(input, operation) {
+    const value = input;
+    if (!isObject(value)) {
+        throw invalidInput(operation, 'the input is not a geometry or a feature');
+    }
+    if ('geometry' in value || value.type === 'Feature') {
+        const geometry = value.geometry;
+        if (isObject(geometry) && isGeometryType(geometry.type)) {
+            return geometryOf(geometry, operation);
+        }
+        if (!isGeometry(value)) {
+            throw invalidInput(operation, 'the feature has no geometry');
+        }
+    }
+    if (value.type === 'GeometryCollection' && !Array.isArray(value.geometries)) {
+        throw invalidInput(operation, 'the geometry collection has no geometries');
+    }
+    if (!isGeometry(value)) {
+        throw invalidInput(operation, 'the input is not a geometry or a feature');
+    }
+    return value;
+}
+/** Whether an object has the type of a geometry and the member that type carries */
+function isGeometry(value) {
+    if (!isGeometryType(value.type))
+        return false;
+    if (value.type === 'GeometryCollection')
+        return Array.isArray(value.geometries);
+    return Array.isArray(value.coordinates);
+}
+/** Whether a value names a GeoJSON geometry type */
+function isGeometryType(type) {
+    return typeof type === 'string' && (COORDINATE_TYPES.has(type) || type === 'GeometryCollection');
+}
+/**
+ * Returns the coordinates of a point given as a position or a Point
+ *
+ * @throws GeometryError (`invalid-input`) for anything else
+ */
+export function positionOf(input, operation) {
+    if (isPosition(input))
+        return input;
+    if (isObject(input) && input.type === 'Point' && isPosition(input.coordinates)) {
+        return input.coordinates;
+    }
+    throw invalidInput(operation, 'the input is not a position or a Point');
+}
+/**
+ * Returns the geometry of a Polygon or a MultiPolygon, given as it is or in a feature
+ *
+ * @throws GeometryError (`invalid-input`) for any other geometry
+ */
+export function areaGeometryOf(input, operation) {
+    const geometry = geometryOf(input, operation);
+    if (geometry.type !== 'Polygon' && geometry.type !== 'MultiPolygon') {
+        throw invalidInput(operation, 'the input is not a Polygon or a MultiPolygon');
+    }
+    return geometry;
+}
+/**
+ * Returns the coordinates of a Polygon or a MultiPolygon, given as it is or in a feature
+ *
+ * @throws GeometryError (`invalid-input`) for any other geometry
+ */
+export function areaOf(input, operation) {
+    return areaGeometryOf(input, operation).coordinates;
+}
+/**
+ * Returns the coordinates of each polygon in an array
+ *
+ * @throws GeometryError (`invalid-input`) for a value that is not an array, and for an
+ *   element that is not a Polygon or a MultiPolygon
+ */
+export function areasOf(inputs, operation) {
+    if (!Array.isArray(inputs)) {
+        throw invalidInput(operation, 'the input is not an array of polygons');
+    }
+    return inputs.map((input) => areaOf(input, operation));
+}
+/**
+ * Returns the coordinates of a LineString, given as it is or in a feature
+ *
+ * @throws GeometryError (`invalid-input`) for any other geometry
+ */
+export function lineOf(input, operation) {
+    const geometry = geometryOf(input, operation);
+    if (geometry.type !== 'LineString') {
+        throw invalidInput(operation, 'the input is not a LineString');
+    }
+    return geometry.coordinates;
+}
+/**
+ * Returns the lines of a LineString or a MultiLineString, given as it is or in a feature
+ *
+ * @throws GeometryError (`invalid-input`) for any other geometry
+ */
+export function linesOf(input, operation) {
+    const geometry = geometryOf(input, operation);
+    if (geometry.type === 'LineString')
+        return [geometry.coordinates];
+    if (geometry.type === 'MultiLineString')
+        return geometry.coordinates;
+    throw invalidInput(operation, 'the input is not a LineString or a MultiLineString');
+}
+/** Every position of a geometry, the members of a collection included */
+export function positionsOf(geometry) {
+    switch (geometry.type) {
+        case 'Point':
+            return [geometry.coordinates];
+        case 'MultiPoint':
+        case 'LineString':
+            return geometry.coordinates;
+        case 'MultiLineString':
+        case 'Polygon':
+            return geometry.coordinates.flat();
+        case 'MultiPolygon':
+            return geometry.coordinates.flat(2);
+        case 'GeometryCollection':
+            return geometry.geometries.flatMap(positionsOf);
+    }
+}
+/** A copy of a position, as returned by the public functions */
+export function toPosition(coordinate) {
+    return [coordinate[0], coordinate[1]];
+}
+/** A Point geometry at a position */
+export function toPoint(coordinate) {
+    return { type: 'Point', coordinates: toPosition(coordinate) };
+}
+/**
+ * Wraps MultiPolygon coordinates into a geometry: a Polygon for one part, a MultiPolygon for
+ * several, and null for none
+ */
+export function toAreaGeometry(coordinates) {
+    if (coordinates.length === 0)
+        return null;
+    if (coordinates.length === 1)
+        return { type: 'Polygon', coordinates: coordinates[0] };
+    return { type: 'MultiPolygon', coordinates };
+}

package/dist/geometry/index.d.ts

@@ -1,28 +1,43 @@
 /**
- * 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
  */
-export { getPointAtAngle } from './angle.js';
-export { bboxContains, bboxIntersects, boundingBox, coordinatesBBox } from './bbox.js';
-export { clip, difference, differenceAll, intersection, intersectionAll, normalizeArea, union, unionAll, } from './boolean.js';
-export type { BufferOptions } from './buffer.js';
-export { buffer, DEFAULT_BUFFER_SEGMENTS } from './buffer.js';
-export { generateCirclePolygon } from './circle.js';
-export { closeRing, flattenAreaCoordinates, isMultiPolygonCoordinates, isRingClosed, toMultiPolygonCoordinates, } from './coords.js';
-export { destinationPoint, haversineDistanceMeters, initialBearingDegrees } from './distance.js';
-export type { GeometryErrorCode, GeometryOperation } from './errors.js';
+export { along, area, bearing, centroid, destination, distance, length, midpoint, nearestPointOnLine, perimeter, pointOnSurface, } from './public-measure.js';
+export { buffer, circle } from './public-create.js';
+export { difference, intersection, split, union } from './public-combine.js';
+export { bboxContains, bboxIntersects } from './bbox.js';
+export { contains, overlaps, pointInPolygon } from './public-predicates.js';
+export { makeValid, rewind, simplify } from './public-repair.js';
+export { bbox } from './public-bounds.js';
+export { metersToDegrees } from './units.js';
+export type { GeometryErrorCode } from './errors.js';
 export { GeometryError } from './errors.js';
-export { centroid, geodesicLength, pointOnSurface, sphericalArea } from './measure.js';
-export { contains, intersects, pointInPolygon, within } from './predicates.js';
-export { isRingClockwise, normalizeMultiPolygonOrientation, normalizePolygonOrientation, normalizeRingOrientation, signedRingArea, simplify, } from './simplify.js';
-export { segmentIntersection, splitArea } from './split.js';
-export type { AreaCoordinates, BBox, Coordinate, GeometryInput, LineStringGeometry, MultiLineStringGeometry, MultiPointGeometry, MultiPolygonCoordinates, MultiPolygonGeometry, PointGeometry, PolygonCoordinates, PolygonGeometry, Ring, } from './types.js';
-export { EARTH_RADIUS_METERS, toDegrees, toRadians } from './units.js';
+export type { BBox } from './types.js';
+export { EARTH_RADIUS_METERS } from './units.js';

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[];