@sindicum/libre-draw 0.1.0

package/dist/modes/SelectMode.d.ts

@@ -0,0 +1,158 @@
+import type { Mode } from './Mode';
+import type { NormalizedInputEvent } from '../types/input';
+import type { LibreDrawFeature, Position, Action } from '../types/features';
+import type { LibreDrawEventMap } from '../types/events';
+/**
+ * Callbacks that SelectMode needs from the host application.
+ */
+export interface SelectModeCallbacks {
+    /** Remove a feature from the store. */
+    removeFeatureFromStore(id: string): LibreDrawFeature | undefined;
+    /** Push an action to the history manager. */
+    pushToHistory(action: Action): void;
+    /** Emit an event through the event bus. */
+    emitEvent<K extends keyof LibreDrawEventMap>(type: K, payload: LibreDrawEventMap[K]): void;
+    /** Re-render all features. */
+    renderFeatures(): void;
+    /** Get a feature by ID. */
+    getFeatureById(id: string): LibreDrawFeature | undefined;
+    /** Get all features in the store. */
+    getAllFeatures(): LibreDrawFeature[];
+    /** Convert a geographic coordinate to a screen point. */
+    getScreenPoint(lngLat: {
+        lng: number;
+        lat: number;
+    }): {
+        x: number;
+        y: number;
+    };
+    /** Update a feature in the store. */
+    updateFeatureInStore(id: string, feature: LibreDrawFeature): void;
+    /** Render vertex and midpoint markers for editing. */
+    renderVertices(featureId: string, vertices: Position[], midpoints: Position[], highlightIndex?: number): void;
+    /** Clear vertex/midpoint markers. */
+    clearVertices(): void;
+    /** Enable or disable map drag panning. */
+    setDragPan(enabled: boolean): void;
+}
+/**
+ * Selection and editing mode for existing polygons.
+ *
+ * Users click on a polygon to select it. Selected polygons display
+ * vertex handles that can be dragged to reshape the polygon. Midpoint
+ * handles appear between vertices and can be dragged to add new vertices.
+ * Double-clicking a vertex removes it (minimum 3 vertices maintained).
+ */
+export declare class SelectMode implements Mode {
+    private selectedIds;
+    private isActive;
+    private callbacks;
+    private onSelectionChange?;
+    private dragging;
+    private dragVertexIndex;
+    private dragStartFeature;
+    private draggingPolygon;
+    private dragPolygonStartLngLat;
+    private highlightedVertexIndex;
+    constructor(callbacks: SelectModeCallbacks, onSelectionChange?: (selectedIds: string[]) => void);
+    activate(): void;
+    deactivate(): void;
+    /**
+     * Get the currently selected feature IDs.
+     */
+    getSelectedIds(): string[];
+    /**
+     * Programmatically select a feature by ID.
+     *
+     * Replaces any existing selection. Renders vertex handles and
+     * emits a selectionchange event. Cancels any in-progress drag.
+     *
+     * @param id - The feature ID to select.
+     * @returns `true` if the feature was found and selected, `false` otherwise.
+     */
+    selectFeature(id: string): boolean;
+    /**
+     * Programmatically clear the current selection.
+     *
+     * Removes vertex handles and emits a selectionchange event.
+     * No-op if nothing is selected or mode is not active.
+     */
+    clearSelection(): void;
+    onPointerDown(event: NormalizedInputEvent): void;
+    onPointerMove(event: NormalizedInputEvent): void;
+    onPointerUp(_event: NormalizedInputEvent): void;
+    onDoubleClick(event: NormalizedInputEvent): void;
+    onLongPress(event: NormalizedInputEvent): void;
+    onKeyDown(key: string, _event: KeyboardEvent): void;
+    /**
+     * Get the hit-test threshold based on input type.
+     */
+    private getThreshold;
+    /**
+     * Get the unique vertices (excluding closing point) of a polygon.
+     */
+    private getVertices;
+    /**
+     * Find the nearest vertex within the hit threshold.
+     * @returns The vertex index, or -1 if none is close enough.
+     */
+    private findNearestVertex;
+    /**
+     * Find the nearest point (vertex or midpoint) within the hit threshold.
+     * @returns The index, or -1 if none is close enough.
+     */
+    private findNearestPoint;
+    /**
+     * Compute midpoints for each edge of the polygon.
+     */
+    private computeMidpoints;
+    /**
+     * Start a vertex drag operation.
+     */
+    private startDrag;
+    /**
+     * Start a polygon drag (whole-polygon move) operation.
+     */
+    private startPolygonDrag;
+    /**
+     * End a drag operation and restore map interactions.
+     */
+    private endDrag;
+    /**
+     * Create a new feature with a vertex moved to a new position.
+     */
+    private moveVertex;
+    /**
+     * Create a new feature with all vertices translated by the given delta.
+     */
+    private movePolygon;
+    /**
+     * Create a new feature with a vertex inserted at the given index.
+     */
+    private insertVertex;
+    /**
+     * Create a new feature with a vertex removed at the given index.
+     */
+    private removeVertex;
+    /**
+     * Refresh vertex/midpoint handles for the currently selected feature.
+     * Call this after external geometry changes (e.g. undo/redo).
+     */
+    refreshVertexHandles(): void;
+    /**
+     * Show vertex and midpoint handles for a selected feature.
+     */
+    private showVertexHandles;
+    /**
+     * Get the first selected feature ID.
+     */
+    private getFirstSelectedId;
+    /**
+     * Delete all currently selected features.
+     */
+    private deleteSelected;
+    /**
+     * Notify the host about selection changes.
+     */
+    private notifySelectionChange;
+}

package/dist/rendering/RenderManager.d.ts

@@ -0,0 +1,80 @@
+import type { Map as MaplibreMap } from 'maplibre-gl';
+import type { LibreDrawFeature, Position } from '../types/features';
+import { SourceManager } from './SourceManager';
+/**
+ * Layer IDs used by LibreDraw for rendering.
+ */
+export declare const LAYER_IDS: {
+    readonly FILL: "libre-draw-fill";
+    readonly OUTLINE: "libre-draw-outline";
+    readonly VERTICES: "libre-draw-vertices";
+    readonly PREVIEW: "libre-draw-preview";
+    readonly EDIT_VERTICES: "libre-draw-edit-vertices";
+    readonly EDIT_MIDPOINTS: "libre-draw-edit-midpoints";
+};
+/**
+ * Manages the rendering layers for LibreDraw.
+ *
+ * Creates and manages MapLibre layers for:
+ * - Fill: polygon fill rendering
+ * - Outline: polygon border rendering
+ * - Vertices: vertex point rendering
+ * - Preview: in-progress drawing preview
+ *
+ * Uses requestAnimationFrame for batch updates to avoid
+ * redundant re-renders within a single frame.
+ */
+export declare class RenderManager {
+    private map;
+    private sourceManager;
+    private selectedIds;
+    private pendingRender;
+    private pendingFeatures;
+    private initialized;
+    constructor(map: MaplibreMap, sourceManager: SourceManager);
+    /**
+     * Initialize rendering layers on the map.
+     * Should be called after the map style and sources are ready.
+     */
+    initialize(): void;
+    /**
+     * Render features to the map. Uses requestAnimationFrame
+     * to batch multiple render calls within a single frame.
+     * @param features - The features to render.
+     */
+    render(features: LibreDrawFeature[]): void;
+    /**
+     * Render a polygon preview for in-progress drawing.
+     * @param coordinates - The preview polygon coordinates (ring).
+     */
+    renderPreview(coordinates: Position[]): void;
+    /**
+     * Clear the drawing preview.
+     */
+    clearPreview(): void;
+    /**
+     * Render vertex and midpoint markers for editing a selected polygon.
+     * @param vertices - The polygon vertex positions.
+     * @param midpoints - The edge midpoint positions.
+     * @param highlightIndex - Optional index of the vertex to highlight.
+     */
+    renderVertices(vertices: Position[], midpoints: Position[], highlightIndex?: number): void;
+    /**
+     * Clear the vertex/midpoint markers.
+     */
+    clearVertices(): void;
+    /**
+     * Set the IDs of selected features for visual highlighting.
+     * @param ids - The selected feature IDs.
+     */
+    setSelectedIds(ids: string[]): void;
+    /**
+     * Remove all layers and sources from the map.
+     */
+    destroy(): void;
+    /**
+     * Perform the actual render, converting features to GeoJSON
+     * with selection state embedded in properties.
+     */
+    private performRender;
+}

package/dist/rendering/SourceManager.d.ts

@@ -0,0 +1,52 @@
+import type { Map as MaplibreMap } from 'maplibre-gl';
+/**
+ * The GeoJSON source IDs used by LibreDraw.
+ */
+export declare const SOURCE_IDS: {
+    readonly FEATURES: "libre-draw-features";
+    readonly PREVIEW: "libre-draw-preview";
+    readonly EDIT_VERTICES: "libre-draw-edit-vertices";
+};
+/**
+ * Manages MapLibre GeoJSON sources for the drawing layers.
+ *
+ * Provides methods to add, update, and remove the sources that
+ * the RenderManager's layers read from.
+ */
+export declare class SourceManager {
+    private map;
+    private initialized;
+    constructor(map: MaplibreMap);
+    /**
+     * Initialize the GeoJSON sources on the map.
+     * Should be called after the map style has loaded.
+     */
+    initialize(): void;
+    /**
+     * Update the features source with new GeoJSON data.
+     * @param data - A GeoJSON FeatureCollection.
+     */
+    updateFeatures(data: GeoJSON.FeatureCollection): void;
+    /**
+     * Update the preview source with new GeoJSON data.
+     * @param data - A GeoJSON FeatureCollection.
+     */
+    updatePreview(data: GeoJSON.FeatureCollection): void;
+    /**
+     * Clear the preview source.
+     */
+    clearPreview(): void;
+    /**
+     * Update the edit vertices source with new GeoJSON data.
+     * @param data - A GeoJSON FeatureCollection of Point features.
+     */
+    updateEditVertices(data: GeoJSON.FeatureCollection): void;
+    /**
+     * Clear the edit vertices source.
+     */
+    clearEditVertices(): void;
+    /**
+     * Remove all sources from the map.
+     */
+    destroy(): void;
+}

package/dist/types/events.d.ts

@@ -0,0 +1,43 @@
+import type { LibreDrawFeature } from './features';
+/**
+ * Event payload for feature creation.
+ */
+export interface CreateEvent {
+    feature: LibreDrawFeature;
+}
+/**
+ * Event payload for feature update.
+ */
+export interface UpdateEvent {
+    feature: LibreDrawFeature;
+    oldFeature: LibreDrawFeature;
+}
+/**
+ * Event payload for feature deletion.
+ */
+export interface DeleteEvent {
+    feature: LibreDrawFeature;
+}
+/**
+ * Event payload for selection changes.
+ */
+export interface SelectionChangeEvent {
+    selectedIds: string[];
+}
+/**
+ * Event payload for mode changes.
+ */
+export interface ModeChangeEvent {
+    mode: string;
+    previousMode: string;
+}
+/**
+ * Map of all LibreDraw event types to their payloads.
+ */
+export interface LibreDrawEventMap {
+    create: CreateEvent;
+    update: UpdateEvent;
+    delete: DeleteEvent;
+    selectionchange: SelectionChangeEvent;
+    modechange: ModeChangeEvent;
+}

package/dist/types/features.d.ts

@@ -0,0 +1,80 @@
+/**
+ * A geographic coordinate pair [longitude, latitude].
+ */
+export type Position = [number, number];
+/**
+ * GeoJSON Polygon geometry.
+ */
+export interface PolygonGeometry {
+    type: 'Polygon';
+    coordinates: Position[][];
+}
+/**
+ * Arbitrary key-value properties attached to a feature.
+ */
+export interface FeatureProperties {
+    [key: string]: unknown;
+}
+/**
+ * A GeoJSON Feature with Polygon geometry used internally by LibreDraw.
+ */
+export interface LibreDrawFeature {
+    id: string;
+    type: 'Feature';
+    geometry: PolygonGeometry;
+    properties: FeatureProperties;
+}
+/**
+ * The type of history action.
+ */
+export type ActionType = 'create' | 'update' | 'delete';
+/**
+ * A reversible action that can be applied and reverted on a FeatureStore.
+ */
+export interface Action {
+    type: ActionType;
+    apply(store: FeatureStoreInterface): void;
+    revert(store: FeatureStoreInterface): void;
+}
+/**
+ * Minimal interface for the FeatureStore used by actions.
+ * This avoids circular imports between types and core modules.
+ */
+export interface FeatureStoreInterface {
+    add(feature: LibreDrawFeature): void;
+    update(id: string, feature: LibreDrawFeature): void;
+    remove(id: string): void;
+    getById(id: string): LibreDrawFeature | undefined;
+}
+/**
+ * Action that represents the creation of a new feature.
+ */
+export declare class CreateAction implements Action {
+    readonly feature: LibreDrawFeature;
+    readonly type: ActionType;
+    constructor(feature: LibreDrawFeature);
+    apply(store: FeatureStoreInterface): void;
+    revert(store: FeatureStoreInterface): void;
+}
+/**
+ * Action that represents the update of an existing feature.
+ */
+export declare class UpdateAction implements Action {
+    readonly id: string;
+    readonly oldFeature: LibreDrawFeature;
+    readonly newFeature: LibreDrawFeature;
+    readonly type: ActionType;
+    constructor(id: string, oldFeature: LibreDrawFeature, newFeature: LibreDrawFeature);
+    apply(store: FeatureStoreInterface): void;
+    revert(store: FeatureStoreInterface): void;
+}
+/**
+ * Action that represents the deletion of a feature.
+ */
+export declare class DeleteAction implements Action {
+    readonly feature: LibreDrawFeature;
+    readonly type: ActionType;
+    constructor(feature: LibreDrawFeature);
+    apply(store: FeatureStoreInterface): void;
+    revert(store: FeatureStoreInterface): void;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export type { Position, PolygonGeometry, FeatureProperties, LibreDrawFeature, ActionType, Action, FeatureStoreInterface, } from './features';
+export { CreateAction, UpdateAction, DeleteAction, } from './features';
+export type { CreateEvent, UpdateEvent, DeleteEvent, SelectionChangeEvent, ModeChangeEvent, LibreDrawEventMap, } from './events';
+export type { ToolbarPosition, ToolbarControls, ToolbarOptions, LibreDrawOptions, } from './options';
+export type { InputType, NormalizedInputEvent, } from './input';

package/dist/types/input.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The type of input device that generated an event.
+ */
+export type InputType = 'mouse' | 'touch';
+/**
+ * A normalized input event shared across mouse and touch handlers.
+ */
+export interface NormalizedInputEvent {
+    /** The geographic coordinate at the event location. */
+    lngLat: {
+        lng: number;
+        lat: number;
+    };
+    /** The screen pixel coordinate at the event location. */
+    point: {
+        x: number;
+        y: number;
+    };
+    /** The original DOM event. */
+    originalEvent: MouseEvent | TouchEvent;
+    /** The input device type that generated this event. */
+    inputType: InputType;
+}

package/dist/types/options.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Position of the toolbar control on the map.
+ */
+export type ToolbarPosition = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+/**
+ * Configuration for which toolbar controls to display.
+ */
+export interface ToolbarControls {
+    draw?: boolean;
+    select?: boolean;
+    delete?: boolean;
+    undo?: boolean;
+    redo?: boolean;
+}
+/**
+ * Configuration options for the toolbar.
+ */
+export interface ToolbarOptions {
+    position?: ToolbarPosition;
+    controls?: ToolbarControls;
+}
+/**
+ * Options for creating a LibreDraw instance.
+ */
+export interface LibreDrawOptions {
+    /** Whether to show the toolbar, or toolbar configuration options. */
+    toolbar?: boolean | ToolbarOptions;
+    /** Maximum number of undo/redo history entries. Defaults to 100. */
+    historyLimit?: number;
+}

package/dist/ui/Toolbar.d.ts

@@ -0,0 +1,59 @@
+import type { Map as MaplibreMap } from 'maplibre-gl';
+import type { ToolbarOptions } from '../types/options';
+/**
+ * Callbacks that the Toolbar needs from the host application.
+ */
+export interface ToolbarCallbacks {
+    onDrawClick(): void;
+    onSelectClick(): void;
+    onDeleteClick(): void;
+    onUndoClick(): void;
+    onRedoClick(): void;
+}
+/**
+ * Creates and manages the drawing toolbar UI.
+ *
+ * The toolbar is positioned on the map using MapLibre's control
+ * container system. It creates buttons for draw, select, delete,
+ * undo, and redo actions. Button states are updated externally
+ * to reflect the current mode and history state.
+ */
+export declare class Toolbar {
+    private map;
+    private container;
+    private buttons;
+    private callbacks;
+    private options;
+    constructor(map: MaplibreMap, callbacks: ToolbarCallbacks, options?: ToolbarOptions);
+    /**
+     * Update the active mode displayed in the toolbar.
+     * @param mode - The active mode name ('idle', 'draw', 'select').
+     */
+    setActiveMode(mode: string): void;
+    /**
+     * Update the undo/redo button states.
+     * @param canUndo - Whether undo is available.
+     * @param canRedo - Whether redo is available.
+     */
+    setHistoryState(canUndo: boolean, canRedo: boolean): void;
+    /**
+     * Remove the toolbar from the map and clean up.
+     */
+    destroy(): void;
+    /**
+     * Create all toolbar buttons based on the configured controls.
+     */
+    private createButtons;
+    /**
+     * Create a button and add it to the toolbar.
+     */
+    private addButton;
+    /**
+     * Mount the toolbar container to the map's control container.
+     */
+    private mount;
+    /**
+     * Apply CSS styles to the toolbar container.
+     */
+    private applyContainerStyles;
+}

package/dist/ui/ToolbarButton.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Options for creating a toolbar button.
+ */
+export interface ToolbarButtonOptions {
+    /** The unique identifier for this button. */
+    id: string;
+    /** The SVG icon string to display. */
+    icon: string;
+    /** Tooltip text for the button. */
+    title: string;
+    /** Click handler callback. */
+    onClick: () => void;
+    /** Whether this is a toggle button (draw/select) vs. action button (delete/undo/redo). */
+    isToggle?: boolean;
+}
+/**
+ * Creates and manages a single toolbar button DOM element.
+ *
+ * Supports active and disabled states for visual feedback.
+ * All DOM creation uses createElement for security (no innerHTML).
+ */
+export declare class ToolbarButton {
+    private element;
+    private iconContainer;
+    private options;
+    constructor(options: ToolbarButtonOptions);
+    /**
+     * Get the DOM element for this button.
+     */
+    getElement(): HTMLButtonElement;
+    /**
+     * Set the active state of the button.
+     * @param active - Whether the button should appear active.
+     */
+    setActive(active: boolean): void;
+    /**
+     * Set the disabled state of the button.
+     * @param disabled - Whether the button should be disabled.
+     */
+    setDisabled(disabled: boolean): void;
+    /**
+     * Clean up the button element.
+     */
+    destroy(): void;
+    /**
+     * Set the icon SVG content using DOM parsing (no innerHTML).
+     */
+    private setIcon;
+    /**
+     * Apply the base CSS styles to the button.
+     */
+    private applyStyles;
+}

package/dist/ui/icons/delete.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Trash can SVG icon for the delete tool.
+ */
+export declare const deleteIcon = "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" width=\"18\" height=\"18\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><polyline points=\"3 6 5 6 21 6\"/><path d=\"M19 6v14a2 2 0 01-2 2H7a2 2 0 01-2-2V6m3 0V4a2 2 0 012-2h4a2 2 0 012 2v2\"/><line x1=\"10\" y1=\"11\" x2=\"10\" y2=\"17\"/><line x1=\"14\" y1=\"11\" x2=\"14\" y2=\"17\"/></svg>";

package/dist/ui/icons/draw.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Pentagon SVG icon for the draw tool.
+ */
+export declare const drawIcon = "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" width=\"18\" height=\"18\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M12 2l8.5 6.2-3.2 9.8H6.7L3.5 8.2z\"/></svg>";

package/dist/ui/icons/redo.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Right arrow SVG icon for the redo action.
+ */
+export declare const redoIcon = "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" width=\"18\" height=\"18\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><polyline points=\"15 14 20 9 15 4\"/><path d=\"M4 20v-7a4 4 0 014-4h12\"/></svg>";

package/dist/ui/icons/select.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Cursor SVG icon for the select tool.
+ */
+export declare const selectIcon = "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" width=\"18\" height=\"18\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M3 3l7.07 16.97 2.51-7.39 7.39-2.51L3 3z\"/><path d=\"M13 13l6 6\"/></svg>";

package/dist/ui/icons/undo.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Left arrow SVG icon for the undo action.
+ */
+export declare const undoIcon = "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" width=\"18\" height=\"18\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><polyline points=\"9 14 4 9 9 4\"/><path d=\"M20 20v-7a4 4 0 00-4-4H4\"/></svg>";

package/dist/validation/geojson.d.ts

@@ -0,0 +1,20 @@
+import type { LibreDrawFeature } from '../types/features';
+/**
+ * Validate a single GeoJSON-like object as a valid LibreDraw Feature
+ * with Polygon geometry.
+ * @param feature - The object to validate.
+ * @returns The validated feature.
+ * @throws LibreDrawError if the feature is invalid.
+ */
+export declare function validateFeature(feature: unknown): LibreDrawFeature;
+/**
+ * Validate that an unknown value is a valid GeoJSON FeatureCollection
+ * containing only valid Polygon features.
+ * @param geojson - The value to validate.
+ * @returns The validated FeatureCollection.
+ * @throws LibreDrawError if the value is invalid.
+ */
+export declare function validateGeoJSON(geojson: unknown): {
+    type: 'FeatureCollection';
+    features: LibreDrawFeature[];
+};

package/dist/validation/intersection.d.ts

@@ -0,0 +1,28 @@
+import type { Position } from '../types/features';
+/**
+ * Check if two line segments (p1-p2) and (p3-p4) truly intersect.
+ * Segments that share an endpoint are NOT considered intersecting.
+ */
+export declare function segmentsIntersect(p1: Position, p2: Position, p3: Position, p4: Position): boolean;
+/**
+ * Check if a closed polygon ring has any self-intersections.
+ * The ring should include the closing point (first === last).
+ * @param ring - The polygon ring coordinates.
+ * @returns True if the ring has self-intersections.
+ */
+export declare function hasRingSelfIntersection(ring: Position[]): boolean;
+/**
+ * Check if adding a new vertex to the current drawing vertices would cause
+ * the new edge to intersect any existing edge.
+ * @param vertices - Current vertices (NOT closed, no closing point).
+ * @param newVertex - The vertex to add.
+ * @returns True if adding the vertex would cause an intersection.
+ */
+export declare function wouldNewVertexCauseIntersection(vertices: Position[], newVertex: Position): boolean;
+/**
+ * Check if closing the polygon (connecting last vertex to first) would cause
+ * the closing edge to intersect any existing edge.
+ * @param vertices - Current vertices (NOT closed, no closing point).
+ * @returns True if closing would cause an intersection.
+ */
+export declare function wouldClosingCauseIntersection(vertices: Position[]): boolean;