@sakuzu/maplibre-gl-draw 1.0.0 → 2.1.0

package/dist/extension/feature-handler.d.ts

@@ -1,182 +1 @@
-/**
- * The feature handler contract of an extension
- *
- * The shape an extension implements to add a custom feature type: its renderer, its hit
- * testing, its box selection, its bounding boxes, its resize and its snapping candidates, all
- * registered at once with `registerFeatureHandler`. It is types only and sits low in the layer
- * order, so the view, snapping and operations layers read it without reaching up into api.
- */
-import type { BoxSelectionStrategy } from '../dispatcher/hit-test/box-strategy.js';
-import type { HitTestStrategy } from '../dispatcher/hit-test/strategies/index.js';
-import type { ResizeState } from '../operations/resize.js';
-import type { HandleType } from '../shared/config/constants.js';
-import type { BoundingBox, Coordinate, Feature } from '../shared/types/model.js';
-import type { BoundingBoxCoords } from '../shared/types/selection-box.js';
-import type { SnapCandidate, SnapProviderContext } from '../snapping/types.js';
-import type { HandleInfo } from '../view/ui/handles.js';
-import type { PointFrameExtent } from '../view/ui/selection-ui/index.js';
-import type { CustomFeatureRenderer } from './renderers.js';
-/**
- * Custom resize result
- *
- * The result of the resize computation for a custom feature.
- * Used when processing different from the standard resize (changing scale) is needed.
- */
-export interface CustomResizeResult {
-    /** The new coordinates */
-    coordinates: Coordinate;
-    /** The new width (in pixels, optional) */
-    width?: number;
-    /** The new height (in pixels, optional) */
-    height?: number;
-}
-/**
- * The type of a custom resize computation function
- */
-export type CustomResizeCalculator = (handle: HandleType, state: ResizeState, currentLngLat: {
-    lng: number;
-    lat: number;
-}, feature: Feature) => CustomResizeResult | null;
-/**
- * A custom feature type: how its features are drawn, hit, selected, resized and snapped to
- *
- * Register it with `draw.registerFeatureHandler(handler)`, usually from `onInstall` of a
- * {@link Plugin}. The registration belongs to that draw instance, and the returned function
- * removes it. Features of the type are ordinary features in the Store (`type` is the name of
- * the handler), so they are saved, exported, grouped and stacked like the built-in types;
- * GeoJSON export writes the type in `maplibre-gl-draw:featureType` so that it comes back.
- *
- * `type`, `renderer` and `hitTest` are required. The rest have fallbacks: box selection and
- * the bounding box use the coordinates, and without `getSelectionBoundingBox` no selection UI
- * is drawn.
- *
- * @example
- * ```ts
- * import type { CustomFeatureHandler, Feature } from '@sakuzu/maplibre-gl-draw';
- *
- * // A "marker" type: one coordinate, drawn as a square, hit within the tolerance
- * const distanceTo = (feature: Feature, [lng, lat]: [number, number]) => {
- *   const [x, y] = feature.coordinates as [number, number];
- *   return Math.hypot(x - lng, y - lat);
- * };
- *
- * const markerHandler: CustomFeatureHandler = {
- *   type: 'marker',
- *   renderer: markerRenderer, // see CustomFeatureRenderer
- *   hitTest: {
- *     geometryType: 'marker',
- *     test: (feature, coordinate, tolerance) => distanceTo(feature, coordinate) <= tolerance,
- *     distance: (feature, coordinate) => distanceTo(feature, coordinate),
- *   },
- * };
- *
- * const unregister = draw.registerFeatureHandler(markerHandler);
- * draw.addFeature({ type: 'marker', coordinates: [139.767, 35.681] });
- * ```
- */
-export interface CustomFeatureHandler {
-    /** The feature type name */
-    readonly type: string;
-    /** The custom renderer */
-    readonly renderer: CustomFeatureRenderer;
-    /** The custom hit testing strategy */
-    readonly hitTest: HitTestStrategy;
-    /** The custom box selection strategy (when omitted, a coordinate-based fallback is used) */
-    readonly boxSelection?: BoxSelectionStrategy;
-    /**
-     * The resize strategy (applied when computeCustomResize returns null)
-     * - 'scale': changes the scale property (as an Image does)
-     * - 'coordinates': changes the coordinates directly (the same as Polygon and LineString)
-     * - when omitted: a generic check (decided by the presence of the scale property)
-     */
-    readonly resizeStrategy?: 'scale' | 'coordinates';
-    /**
-     * Bounding box computation
-     *
-     * Used for viewport filtering in SpatialIndex.
-     * When omitted, a simple bounding box is computed from the coordinates.
-     *
-     * @param feature The target feature
-     * @param tileSize The tile size (512 by default)
-     */
-    getBoundingBox?(feature: Feature, tileSize: number): BoundingBox;
-    /**
-     * The additional reach for narrowing down candidates (in CSS pixels)
-     *
-     * The first stage of hit testing narrows down candidates with a radius equivalent to
-     * clickTolerance, so when the hitTest strategy of this type treats a wider area as a hit
-     * (icons and the like), the candidate is dropped before the precise test is reached.
-     * Registering "how far from the center a hit can occur" here widens the candidate search
-     * radius by that much.
-     *
-     * The test itself is still decided by the hitTest strategy as before (only the number of
-     * candidates increases slightly). A value that changes with zoom or with settings is
-     * registered as a function (it is evaluated on every query).
-     */
-    readonly candidateReachPx?: number | (() => number);
-    /**
-     * The half width and half height of the selection box of a zero-area point (in CSS pixels)
-     *
-     * A point keeps its zero area and is treated with the "point appearance" (box only, no resize
-     * or rotation handles, move inside the box). This function only decides the dimensions of that
-     * box (the special treatment of zero area itself does not change).
-     *
-     * When it is omitted, or returns null, the default 12px square is used.
-     *
-     * @param feature The target feature
-     */
-    getPointFrameExtent?(feature: Feature): PointFrameExtent | null;
-    /**
-     * Bounding box computation for the selection UI
-     *
-     * Used for the visual feedback of the selected state (bounding box, handles).
-     * Returns an OBB (Oriented Bounding Box) that takes rotation into account.
-     * When omitted, no selection UI is drawn.
-     *
-     * @param feature The target feature
-     * @param tileSize The tile size (512 by default)
-     */
-    getSelectionBoundingBox?(feature: Feature, tileSize: number): BoundingBoxCoords;
-    /**
-     * Returns additional resize handles
-     *
-     * Returns the handles to display in addition to the standard four corner handles.
-     * When omitted, only the four corner handles are shown.
-     * Called only for a single selection.
-     *
-     * @param feature The target feature
-     * @param bbox The bounding box for the selection UI
-     */
-    getAdditionalResizeHandles?(feature: Feature, bbox: BoundingBoxCoords): HandleInfo[];
-    /**
-     * Custom resize computation
-     *
-     * Provides custom resize logic such as edge-midpoint handles.
-     * Returning null applies the standard resize (changing scale).
-     *
-     * @param handle The type of the handle being operated
-     * @param state The state of the resize operation
-     * @param currentLngLat The current mouse coordinate
-     * @param feature The target feature
-     */
-    computeCustomResize?(handle: HandleType, state: ResizeState, currentLngLat: {
-        lng: number;
-        lat: number;
-    }, feature: Feature): CustomResizeResult | null;
-    /**
-     * Returns the snapping candidates
-     *
-     * An extension point that lets a custom type provide its own vertices and edges as snapping
-     * targets. The built-in vertex provider calls this when there is a registration for the type
-     * of the target feature (when it is called, the standard enumeration of the vertices and edges
-     * of that feature is not performed).
-     *
-     * The returned candidates may be either point candidates that have a coordinate
-     * (kind: 'vertex' and the like) or segment candidates that have two endpoints (kind: 'edge').
-     * The nearest point on a segment candidate is computed by SnapService.
-     *
-     * @param feature The target feature
-     * @param ctx The snapping context (includes the cursor position, the tolerance and exclusions)
-     */
-    getSnapTargets?(feature: Feature, ctx: SnapProviderContext): SnapCandidate[];
-}
+export {};

package/dist/extension/index.d.ts

@@ -1,9 +1,6 @@
 /**
- * The contracts an extension implements
- *
- * The types a plugin, a custom feature type or an overlay implements to plug into the
- * extension points of a draw instance. The registration itself is on the instance
- * (`registerFeatureHandler`, `addOverlayRenderer` and so on).
+ * The contracts of the engine for the feature types that are not built in and for the
+ * overlays. The extension contract of `api/extension/` is installed into them.
  */
-export type { CustomFeatureHandler, CustomResizeCalculator, CustomResizeResult, } from './feature-handler.js';
-export type { CustomFeatureRenderer, CustomOverlayRenderer, CustomRendererDrawContext, LayerAwareOverlayRenderer, } from './renderers.js';
+export type { FeatureTypeHandler, TypeResizeCalculator, TypeResizeResult, } from './feature-handler.js';
+export type { EngineOverlayRenderer, FeatureTypeRenderer, FrameDrawContext, LayeredOverlayRenderer, } from './renderers.js';

package/dist/extension/renderers.d.ts

@@ -1,208 +1 @@
-/**
- * The renderer contracts of an extension
- *
- * The shapes an extension implements to draw with the WebGL context of a draw instance: the
- * renderer of a custom feature type and the overlay renderers. They are types only and sit low
- * in the layer order, so the view and snapping layers read them without reaching up into api.
- */
-import type { Map as MapLibreMap, ProjectionData } from 'maplibre-gl';
-import type { SDFLineRenderer } from '../view/renderers/line/sdf-line.js';
-import type { PointShapeRenderer } from '../view/renderers/point/point-shape.js';
-import type { FillShaderManager } from '../view/renderers/polygon/fill.js';
-import type { TerrainContext } from '../view/terrain/context.js';
-/**
- * Rendering context for custom renderers
- *
- * Provides the shader data and offset information needed when using QuadShader and the like.
- * It also holds references to the shared renderers, which makes high-quality rendering possible.
- */
-export interface CustomRendererDrawContext {
-    /** Shader data (vertexShaderPrelude, define, variantName) */
-    shaderData: {
-        vertexShaderPrelude: string;
-        define: string;
-        variantName: string;
-    };
-    /** Viewport center coordinate [lng, lat] */
-    centerLngLat: [number, number];
-    /** The mainMatrix converted into an array */
-    mainMatrixArray: number[];
-    /**
-     * The resolved rendering scale factor (the conversion factor from CSS pixels to device pixels)
-     *
-     * It is the value of `pixelRatio` in Options when one has been injected, and otherwise the
-     * `window.devicePixelRatio` read in that frame. Renderers on the extension side use this
-     * instead of reading `window.devicePixelRatio` directly.
-     */
-    pixelRatio: number;
-    /**
-     * The terrain state of the draw instance being drawn
-     *
-     * A renderer that owns a `ProjectionUniformManager` or a `QuadShader` passes it with
-     * `setTerrain(context.terrain)` before drawing, and the anchor functions (`projectAnchor`,
-     * `anchorElevationMeters`, `anchorGhostOpacity`, `drawQuadSurfaceOnTerrain` and so on) take
-     * it as their first argument. It is valid for this draw call only; a renderer shared between
-     * draw instances must not keep it.
-     */
-    terrain: TerrainContext;
-    /**
-     * The opacity of the layer being drawn, from 0 to 1 (`Layer.opacity`)
-     *
-     * Core multiplies it into everything it draws for the layer, and a renderer multiplies it
-     * into its own alpha, so that what it draws fades with the layer. It is the opacity of the
-     * layer of the feature for a {@link CustomFeatureRenderer} and a feature companion, and 1 for
-     * an overlay (which does not belong to a layer). The shared renderers of this context do not
-     * apply it by themselves. It changes nothing about hit testing: a feature in a layer at
-     * opacity 0 can still be selected.
-     */
-    opacity: number;
-    /** SDF line rendering (high-quality line rendering, anti-aliasing, dashes and so on) */
-    sdfLineRenderer: SDFLineRenderer;
-    /** Polygon fill rendering */
-    fillShaderManager: FillShaderManager;
-    /** Point shape rendering */
-    pointShapeRenderer: PointShapeRenderer;
-}
-/**
- * Draws the features of a custom feature type with the WebGL context of the map
- *
- * It is the `renderer` of a {@link CustomFeatureHandler}. `onAdd` runs when the draw layer is
- * added to the map (create the WebGL resources there), `draw` runs for each visible feature of
- * the type in stacking order on every frame, and `onRemove` runs when the layer is removed. The
- * shared renderers of the context draw lines, fills and point shapes the same way the built-in
- * types are drawn, terrain included.
- *
- * @example
- * ```ts
- * import type { CustomFeatureRenderer, PointStyle } from '@sakuzu/maplibre-gl-draw';
- *
- * const markerStyle: PointStyle = {
- *   shape: 'square',
- *   size: 14,
- *   fillColor: [0, 0.4, 1, 1],
- *   fillOpacity: 1,
- *   strokeColor: [1, 1, 1, 1],
- *   strokeWidth: 2,
- *   strokeOpacity: 1,
- * };
- *
- * const markerRenderer: CustomFeatureRenderer = {
- *   name: 'marker',
- *   onAdd() {}, // nothing to create: the shared point renderer does the drawing
- *   draw(feature, _projectionData, zoom, context) {
- *     const coordinate = feature.coordinates as [number, number];
- *     // Fade with the layer: the opacity of the layer is multiplied into the alpha
- *     const style = {
- *       ...markerStyle,
- *       fillOpacity: markerStyle.fillOpacity * context.opacity,
- *       strokeOpacity: markerStyle.strokeOpacity * context.opacity,
- *     };
- *     context.pointShapeRenderer.draw(coordinate, style, zoom, feature.id);
- *   },
- *   onRemove() {},
- * };
- * ```
- */
-export interface CustomFeatureRenderer {
-    /** Renderer name (for debugging) */
-    readonly name: string;
-    /**
-     * Initializes the WebGL resources
-     */
-    onAdd(gl: WebGL2RenderingContext, map: MapLibreMap): void;
-    /**
-     * Draws a feature
-     *
-     * @param feature The feature to draw
-     * @param projectionData MapLibre's ProjectionData
-     * @param zoom The current zoom level
-     * @param context The rendering context (shader data, offset information, and the opacity of
-     *   the layer of the feature, which the renderer multiplies into its own alpha)
-     */
-    draw(feature: {
-        id: string;
-        type: string;
-        coordinates: unknown;
-        properties: Record<string, unknown>;
-        style?: unknown;
-    }, projectionData: ProjectionData, zoom: number, context: CustomRendererDrawContext): void;
-    /**
-     * Releases the WebGL resources
-     */
-    onRemove(): void;
-}
-/**
- * Custom renderer
- *
- * Responsible for overlay rendering (independent of features).
- */
-export interface CustomOverlayRenderer {
-    /** Renderer name (for debugging) */
-    readonly name: string;
-    /**
-     * The priority in the draw order
-     * - 'background': drawn behind the features
-     * - 'foreground': drawn in front of the features (behind the selection UI)
-     * - 'overlay': drawn in front of the selection UI
-     */
-    readonly order: 'background' | 'foreground' | 'overlay';
-    /**
-     * Initializes the WebGL resources
-     */
-    onAdd(gl: WebGL2RenderingContext, map: MapLibreMap): void;
-    /**
-     * Draws
-     *
-     * @param projectionData MapLibre's ProjectionData
-     * @param zoom The current zoom level
-     * @param context The rendering context (shared renderers, shader data and so on)
-     */
-    draw(projectionData: ProjectionData, zoom: number, context: CustomRendererDrawContext): void;
-    /**
-     * Releases the WebGL resources
-     */
-    onRemove(): void;
-    /**
-     * Whether the renderer still has work that later frames finish on their own and that will
-     * change what it draws (resources it prepares over several frames, say). Optional: a renderer
-     * without it has none
-     *
-     * `MapLibreGLDraw.hasPendingWork` asks every overlay renderer, so a host that waits for a
-     * complete picture waits for this renderer too. A renderer that returns true requests the
-     * repaints that finish the work itself. With `timeSlicing: false` in the rendering settings,
-     * a renderer should finish in the frame what it would otherwise spread over frames.
-     */
-    hasPendingWork?(): boolean;
-}
-/**
- * Layer-aware overlay renderer
- *
- * An extension of CustomOverlayRenderer that supports rendering per layer.
- * Used for rendering that follows the layer order, such as Tentative.
- */
-export interface LayerAwareOverlayRenderer extends CustomOverlayRenderer {
-    /**
-     * Performs the rendering that corresponds to the given layer (lines and fills only)
-     *
-     * Called in the per-layer rendering loop, after the features of each layer have been drawn.
-     * When this method exists, it is used instead of draw().
-     * Vertices are drawn in the foreground, so they are not drawn here.
-     *
-     * @param layerId The ID of the target layer
-     * @param projectionData MapLibre's ProjectionData
-     * @param zoom The current zoom level
-     * @param context The rendering context
-     */
-    drawForLayer(layerId: string, projectionData: ProjectionData, zoom: number, context: CustomRendererDrawContext): void;
-    /**
-     * Draws the vertices in the foreground
-     *
-     * Called after the selection UI, it draws the vertices of all layers in the foreground at once.
-     * This is needed so that the vertices stay visible even while drawing on a layer that is behind.
-     *
-     * @param projectionData MapLibre's ProjectionData
-     * @param zoom The current zoom level
-     * @param context The rendering context
-     */
-    drawVertices?(projectionData: ProjectionData, zoom: number, context: CustomRendererDrawContext): void;
-}
+export {};

package/dist/geometry/angle.d.ts

@@ -35,13 +35,5 @@ import type { Coordinate } from './types.js';
  * @param radiusMeters The distance from the center in meters
  * @param angleDegrees The bearing in degrees, clockwise with north as 0
  * @returns The position `[lng, lat]` in degrees
- *
- * @example
- * ```ts
- * import { getPointAtAngle } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * // 1 km due east of Tokyo Station, on the same parallel
- * getPointAtAngle([139.767, 35.681], 1000, 90); // [139.77807..., 35.681]
- * ```
  */
 export declare function getPointAtAngle(center: Coordinate, radiusMeters: number, angleDegrees: number): Coordinate;

package/dist/geometry/angle.js

@@ -21,14 +21,6 @@ import { EARTH_RADIUS_METERS, toRadians } from './units.js';
  * @param radiusMeters The distance from the center in meters
  * @param angleDegrees The bearing in degrees, clockwise with north as 0
  * @returns The position `[lng, lat]` in degrees
- *
- * @example
- * ```ts
- * import { getPointAtAngle } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * // 1 km due east of Tokyo Station, on the same parallel
- * getPointAtAngle([139.767, 35.681], 1000, 90); // [139.77807..., 35.681]
- * ```
  */
 export function getPointAtAngle(center, radiusMeters, angleDegrees) {
     const earthRadius = EARTH_RADIUS_METERS;

package/dist/geometry/bbox.d.ts

@@ -9,14 +9,6 @@ import type { AreaCoordinates, BBox, Coordinate } from './types.js';
  * @param coordinates Positions `[lng, lat]` in degrees
  * @returns `[minLng, minLat, maxLng, maxLat]` in degrees. `null` when there is not a single
  *   finite coordinate (an empty array included)
- *
- * @example
- * ```ts
- * import { coordinatesBBox } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * coordinatesBBox([[139.7, 35.6], [139.8, 35.7]]); // [139.7, 35.6, 139.8, 35.7]
- * coordinatesBBox([]); // null
- * ```
  */
 export declare function coordinatesBBox(coordinates: Coordinate[]): BBox | null;
 /**
@@ -33,16 +25,16 @@ export declare function boundingBox(coordinates: AreaCoordinates): BBox | null;
 /**
  * Determines whether two bounding boxes overlap, touching included.
  *
- * @param a A box `[minLng, minLat, maxLng, maxLat]`
- * @param b A box `[minLng, minLat, maxLng, maxLat]`
+ * @param a A box `[minLng, minLat, maxLng, maxLat]` in degrees
+ * @param b A box `[minLng, minLat, maxLng, maxLat]` in degrees
  * @returns `true` when the boxes share at least one point, an edge or a corner included
  */
 export declare function bboxIntersects(a: BBox, b: BBox): boolean;
 /**
  * Determines whether one bounding box contains another, coincident boundaries included.
  *
- * @param outer The containing box `[minLng, minLat, maxLng, maxLat]`
- * @param inner The contained box `[minLng, minLat, maxLng, maxLat]`
+ * @param outer The containing box `[minLng, minLat, maxLng, maxLat]` in degrees
+ * @param inner The contained box `[minLng, minLat, maxLng, maxLat]` in degrees
  * @returns `true` when every point of `inner` lies in `outer`. A box contains itself
  */
 export declare function bboxContains(outer: BBox, inner: BBox): boolean;

package/dist/geometry/bbox.js

@@ -17,14 +17,6 @@ import { flattenAreaCoordinates, isFiniteCoordinate } from './coords.js';
  * @param coordinates Positions `[lng, lat]` in degrees
  * @returns `[minLng, minLat, maxLng, maxLat]` in degrees. `null` when there is not a single
  *   finite coordinate (an empty array included)
- *
- * @example
- * ```ts
- * import { coordinatesBBox } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * coordinatesBBox([[139.7, 35.6], [139.8, 35.7]]); // [139.7, 35.6, 139.8, 35.7]
- * coordinatesBBox([]); // null
- * ```
  */
 export function coordinatesBBox(coordinates) {
     let found = false;
@@ -64,8 +56,8 @@ export function boundingBox(coordinates) {
 /**
  * Determines whether two bounding boxes overlap, touching included.
  *
- * @param a A box `[minLng, minLat, maxLng, maxLat]`
- * @param b A box `[minLng, minLat, maxLng, maxLat]`
+ * @param a A box `[minLng, minLat, maxLng, maxLat]` in degrees
+ * @param b A box `[minLng, minLat, maxLng, maxLat]` in degrees
  * @returns `true` when the boxes share at least one point, an edge or a corner included
  */
 export function bboxIntersects(a, b) {
@@ -74,8 +66,8 @@ export function bboxIntersects(a, b) {
 /**
  * Determines whether one bounding box contains another, coincident boundaries included.
  *
- * @param outer The containing box `[minLng, minLat, maxLng, maxLat]`
- * @param inner The contained box `[minLng, minLat, maxLng, maxLat]`
+ * @param outer The containing box `[minLng, minLat, maxLng, maxLat]` in degrees
+ * @param inner The contained box `[minLng, minLat, maxLng, maxLat]` in degrees
  * @returns `true` when every point of `inner` lies in `outer`. A box contains itself
  */
 export function bboxContains(outer, inner) {

package/dist/geometry/boolean.d.ts

@@ -12,15 +12,6 @@ import type { AreaCoordinates, MultiPolygonCoordinates } from './types.js';
  *   the input has no area
  * @throws {@link GeometryError} when the boolean operation engine fails even after the
  *   retry on the 1e-9 degree grid
- *
- * @example
- * ```ts
- * import { normalizeArea } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * // A self-intersecting bow tie becomes two triangles
- * normalizeArea([[[0, 0], [1, 1], [1, 0], [0, 1], [0, 0]]]);
- * // [[[[0, 0], [0.5, 0.5], [0, 1], [0, 0]]], [[[0.5, 0.5], [1, 0], [1, 1], [0.5, 0.5]]]]
- * ```
  */
 export declare function normalizeArea(coordinates: AreaCoordinates): MultiPolygonCoordinates;
 /**
@@ -36,16 +27,6 @@ export declare function normalizeArea(coordinates: AreaCoordinates): MultiPolygo
  *   several parts. An empty array when neither input has an area
  * @throws {@link GeometryError} when the boolean operation engine fails even after the
  *   retry on the 1e-9 degree grid
- *
- * @example
- * ```ts
- * import type { PolygonCoordinates } from '@sakuzu/maplibre-gl-draw/geometry';
- * import { union } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * const a: PolygonCoordinates = [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]];
- * const b: PolygonCoordinates = [[[0.5, 0], [1.5, 0], [1.5, 1], [0.5, 1], [0.5, 0]]];
- * union(a, b); // [[[[0, 0], [1.5, 0], [1.5, 1], [0, 1], [0, 0]]]]
- * ```
  */
 export declare function union(a: AreaCoordinates, b: AreaCoordinates): MultiPolygonCoordinates;
 /**
@@ -59,16 +40,6 @@ export declare function union(a: AreaCoordinates, b: AreaCoordinates): MultiPoly
  *   when `a` has no area or `b` covers it. `a` normalized when `b` has no area
  * @throws {@link GeometryError} when the boolean operation engine fails even after the
  *   retry on the 1e-9 degree grid
- *
- * @example
- * ```ts
- * import type { PolygonCoordinates } from '@sakuzu/maplibre-gl-draw/geometry';
- * import { difference } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * const a: PolygonCoordinates = [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]];
- * const b: PolygonCoordinates = [[[0.5, 0], [1.5, 0], [1.5, 1], [0.5, 1], [0.5, 0]]];
- * difference(a, b); // [[[[0, 0], [0.5, 0], [0.5, 1], [0, 1], [0, 0]]]]
- * ```
  */
 export declare function difference(a: AreaCoordinates, b: AreaCoordinates): MultiPolygonCoordinates;
 /**
@@ -81,16 +52,6 @@ export declare function difference(a: AreaCoordinates, b: AreaCoordinates): Mult
  *   area
  * @throws {@link GeometryError} when the boolean operation engine fails even after the
  *   retry on the 1e-9 degree grid
- *
- * @example
- * ```ts
- * import type { PolygonCoordinates } from '@sakuzu/maplibre-gl-draw/geometry';
- * import { intersection } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * const a: PolygonCoordinates = [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]];
- * const b: PolygonCoordinates = [[[0.5, 0], [1.5, 0], [1.5, 1], [0.5, 1], [0.5, 0]]];
- * intersection(a, b); // [[[[0.5, 0], [1, 0], [1, 1], [0.5, 1], [0.5, 0]]]]
- * ```
  */
 export declare function intersection(a: AreaCoordinates, b: AreaCoordinates): MultiPolygonCoordinates;
 /**
@@ -120,18 +81,6 @@ export declare function clip(subject: AreaCoordinates, clipRegion: AreaCoordinat
  *   empty array and when no element has an area
  * @throws {@link GeometryError} when the boolean operation engine fails even after the
  *   retry on the 1e-9 degree grid
- *
- * @example
- * ```ts
- * import { unionAll } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * const merged = unionAll([
- *   [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]],
- *   [[[0.5, 0], [1.5, 0], [1.5, 1], [0.5, 1], [0.5, 0]]],
- *   [[[5, 5], [6, 5], [6, 6], [5, 5]]],
- * ]);
- * merged.length; // 2 (the overlapping squares fuse; the triangle stays apart)
- * ```
  */
 export declare function unionAll(geometries: AreaCoordinates[]): MultiPolygonCoordinates;
 /**

package/dist/geometry/boolean.js

@@ -106,15 +106,6 @@ function normalize(coordinates) {
  *   the input has no area
  * @throws {@link GeometryError} when the boolean operation engine fails even after the
  *   retry on the 1e-9 degree grid
- *
- * @example
- * ```ts
- * import { normalizeArea } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * // A self-intersecting bow tie becomes two triangles
- * normalizeArea([[[0, 0], [1, 1], [1, 0], [0, 1], [0, 0]]]);
- * // [[[[0, 0], [0.5, 0.5], [0, 1], [0, 0]]], [[[0.5, 0.5], [1, 0], [1, 1], [0.5, 0.5]]]]
- * ```
  */
 export function normalizeArea(coordinates) {
     return normalize(sanitize(coordinates));
@@ -132,16 +123,6 @@ export function normalizeArea(coordinates) {
  *   several parts. An empty array when neither input has an area
  * @throws {@link GeometryError} when the boolean operation engine fails even after the
  *   retry on the 1e-9 degree grid
- *
- * @example
- * ```ts
- * import type { PolygonCoordinates } from '@sakuzu/maplibre-gl-draw/geometry';
- * import { union } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * const a: PolygonCoordinates = [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]];
- * const b: PolygonCoordinates = [[[0.5, 0], [1.5, 0], [1.5, 1], [0.5, 1], [0.5, 0]]];
- * union(a, b); // [[[[0, 0], [1.5, 0], [1.5, 1], [0, 1], [0, 0]]]]
- * ```
  */
 export function union(a, b) {
     const left = sanitize(a);
@@ -165,16 +146,6 @@ export function union(a, b) {
  *   when `a` has no area or `b` covers it. `a` normalized when `b` has no area
  * @throws {@link GeometryError} when the boolean operation engine fails even after the
  *   retry on the 1e-9 degree grid
- *
- * @example
- * ```ts
- * import type { PolygonCoordinates } from '@sakuzu/maplibre-gl-draw/geometry';
- * import { difference } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * const a: PolygonCoordinates = [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]];
- * const b: PolygonCoordinates = [[[0.5, 0], [1.5, 0], [1.5, 1], [0.5, 1], [0.5, 0]]];
- * difference(a, b); // [[[[0, 0], [0.5, 0], [0.5, 1], [0, 1], [0, 0]]]]
- * ```
  */
 export function difference(a, b) {
     const left = sanitize(a);
@@ -197,16 +168,6 @@ export function difference(a, b) {
  *   area
  * @throws {@link GeometryError} when the boolean operation engine fails even after the
  *   retry on the 1e-9 degree grid
- *
- * @example
- * ```ts
- * import type { PolygonCoordinates } from '@sakuzu/maplibre-gl-draw/geometry';
- * import { intersection } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * const a: PolygonCoordinates = [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]];
- * const b: PolygonCoordinates = [[[0.5, 0], [1.5, 0], [1.5, 1], [0.5, 1], [0.5, 0]]];
- * intersection(a, b); // [[[[0.5, 0], [1, 0], [1, 1], [0.5, 1], [0.5, 0]]]]
- * ```
  */
 export function intersection(a, b) {
     const left = sanitize(a);
@@ -245,18 +206,6 @@ export function clip(subject, clipRegion) {
  *   empty array and when no element has an area
  * @throws {@link GeometryError} when the boolean operation engine fails even after the
  *   retry on the 1e-9 degree grid
- *
- * @example
- * ```ts
- * import { unionAll } from '@sakuzu/maplibre-gl-draw/geometry';
- *
- * const merged = unionAll([
- *   [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]],
- *   [[[0.5, 0], [1.5, 0], [1.5, 1], [0.5, 1], [0.5, 0]]],
- *   [[[5, 5], [6, 5], [6, 6], [5, 5]]],
- * ]);
- * merged.length; // 2 (the overlapping squares fuse; the triangle stays apart)
- * ```
  */
 export function unionAll(geometries) {
     const parts = geometries.map(sanitize).filter((part) => part.length > 0);