leaflet-anvil 0.2.2 → 0.3.0

package/dist/index.js

@@ -39,7 +39,7 @@ __export(index_exports, {
   anvilControl: () => anvilControl
 });
 module.exports = __toCommonJS(index_exports);
-var L22 = __toESM(require("leaflet"));
+var L23 = __toESM(require("leaflet"));
 
 // src/types.ts
 var AnvilMode = /* @__PURE__ */ ((AnvilMode2) => {
@@ -59,6 +59,7 @@ var AnvilMode = /* @__PURE__ */ ((AnvilMode2) => {
   AnvilMode2["Union"] = "union";
   AnvilMode2["Subtract"] = "subtract";
   AnvilMode2["Edit"] = "edit";
+  AnvilMode2["Topology"] = "topology";
   AnvilMode2["Delete"] = "delete";
   AnvilMode2["Off"] = "off";
   return AnvilMode2;
@@ -159,30 +160,35 @@ function getSnapLatLng(map, latlng, store, options, additionalPoints = [], skipL
   const verifiedAdditionalPoints = Array.isArray(additionalPoints) ? additionalPoints : [];
   const snapDistance = options.snapDistance || 10;
   const basePoint = map.latLngToContainerPoint(latlng);
+  const minPoint = basePoint.subtract(L.point(snapDistance, snapDistance));
+  const maxPoint = basePoint.add(L.point(snapDistance, snapDistance));
+  const searchBounds = L.latLngBounds(
+    map.containerPointToLatLng(minPoint),
+    map.containerPointToLatLng(maxPoint)
+  );
   let closestPoint = null;
   let minDistance = snapDistance;
   const skipLayers = Array.isArray(skipLayer) ? skipLayer : skipLayer ? [skipLayer] : [];
-  const bounds = map.getBounds().pad(0.1);
   store.getGroup().eachLayer((layer) => {
     if (skipLayers.includes(layer)) return;
-    if (layer.getBounds && !bounds.intersects(layer.getBounds())) return;
+    if (layer.getBounds && !searchBounds.intersects(layer.getBounds())) return;
     const pointsToCheck = [];
     if (layer instanceof L.Marker || layer instanceof L.CircleMarker || layer instanceof L.Circle) {
       pointsToCheck.push(layer.getLatLng());
     } else if (layer instanceof L.Polyline) {
       const latlngs = layer.getLatLngs();
-      const flatten5 = (arr) => {
+      const flatten4 = (arr) => {
         let result = [];
         arr.forEach((item) => {
           if (Array.isArray(item)) {
-            result = result.concat(flatten5(item));
+            result = result.concat(flatten4(item));
           } else if (item instanceof L.LatLng) {
             result.push(item);
           }
         });
         return result;
       };
-      pointsToCheck.push(...flatten5(latlngs));
+      pointsToCheck.push(...flatten4(latlngs));
     }
     pointsToCheck.forEach((p) => {
       const containerPoint = map.latLngToContainerPoint(p);
@@ -235,30 +241,6 @@ function causesSelfIntersection(map, points, nextPoint, isClosing = false) {
   }
   return false;
 }
-function isSelfIntersecting(map, latlngs, isPolygon) {
-  const flatten5 = (arr) => {
-    if (!Array.isArray(arr)) return [];
-    if (arr[0] instanceof L2.LatLng) return arr;
-    return arr.reduce((acc, val) => acc.concat(flatten5(val)), []);
-  };
-  const points = flatten5(latlngs);
-  if (points.length < 4) return false;
-  const projectedPoints = points.map((p) => map.latLngToLayerPoint(p));
-  const len = projectedPoints.length;
-  for (let i = 0; i < len; i++) {
-    const a = projectedPoints[i];
-    const b = projectedPoints[(i + 1) % len];
-    if (!isPolygon && i === len - 1) break;
-    for (let j = i + 2; j < len; j++) {
-      if (isPolygon && (j + 1) % len === i) continue;
-      if (!isPolygon && j === len - 1) break;
-      const c = projectedPoints[j];
-      const d = projectedPoints[(j + 1) % len];
-      if (segmentsIntersect(a, b, c, d)) return true;
-    }
-  }
-  return false;
-}
 
 // src/modes/draw-polygon-mode.ts
 var DrawPolygonMode = class {
@@ -339,27 +321,27 @@ var DrawPolygonMode = class {
       ).addTo(this.map);
     }
     if (this.points.length === 1 && this.markers.length === 0) {
-      const marker3 = L3.circleMarker(
+      const marker2 = L3.circleMarker(
         this.points[0],
         getModeHandleOptions(this.options, "polygon" /* Polygon */, {
           radius: 5,
           color: "#3388ff"
         })
       ).addTo(this.map);
-      marker3.on("click", (e) => {
+      marker2.on("click", (e) => {
         L3.DomEvent.stopPropagation(e);
         this.finish();
       });
-      this.markers.push(marker3);
+      this.markers.push(marker2);
     }
   }
   finish() {
     if (this.points.length < 3) return;
-    const polygon7 = L3.polygon(
+    const polygon8 = L3.polygon(
       this.points,
       getModePathOptions(this.options, "polygon" /* Polygon */)
     ).addTo(this.map);
-    this.map.fire(ANVIL_EVENTS.CREATED, { layer: polygon7 });
+    this.map.fire(ANVIL_EVENTS.CREATED, { layer: polygon8 });
     this.reset();
   }
   reset() {
@@ -483,8 +465,8 @@ var DrawMarkerMode = class {
   }
   onClick(e) {
     const latlng = this.store ? getSnapLatLng(this.map, e.latlng, this.store, this.options) : e.latlng;
-    const marker3 = L5.marker(latlng, getModeVertexOptions(this.options, "marker" /* Marker */)).addTo(this.map);
-    this.map.fire(ANVIL_EVENTS.CREATED, { layer: marker3 });
+    const marker2 = L5.marker(latlng, getModeVertexOptions(this.options, "marker" /* Marker */)).addTo(this.map);
+    this.map.fire(ANVIL_EVENTS.CREATED, { layer: marker2 });
   }
 };
 
@@ -598,7 +580,7 @@ var DrawSquareMode = class {
     if (!this.startLatLng) return;
     const currentLatLng = this.store ? getSnapLatLng(this.map, e.latlng, this.store, this.options) : e.latlng;
     const squareBounds = this.getSquareBounds(this.startLatLng, currentLatLng);
-    const polygon7 = L7.polygon(
+    const polygon8 = L7.polygon(
       [
         squareBounds.getNorthWest(),
         squareBounds.getNorthEast(),
@@ -607,7 +589,7 @@ var DrawSquareMode = class {
       ],
       getModePathOptions(this.options, "square" /* Square */)
     ).addTo(this.map);
-    this.map.fire(ANVIL_EVENTS.CREATED, { layer: polygon7 });
+    this.map.fire(ANVIL_EVENTS.CREATED, { layer: polygon8 });
     this.reset();
   }
   getSquareBounds(start, end) {
@@ -677,11 +659,11 @@ var DrawTriangleMode = class {
     if (!this.startLatLng) return;
     const currentLatLng = this.store ? getSnapLatLng(this.map, e.latlng, this.store, this.options) : e.latlng;
     const trianglePoints = this.getTrianglePoints(this.startLatLng, currentLatLng);
-    const polygon7 = L8.polygon(
+    const polygon8 = L8.polygon(
       trianglePoints,
       getModePathOptions(this.options, "triangle" /* Triangle */)
     ).addTo(this.map);
-    this.map.fire(ANVIL_EVENTS.CREATED, { layer: polygon7 });
+    this.map.fire(ANVIL_EVENTS.CREATED, { layer: polygon8 });
     this.reset();
   }
   getTrianglePoints(start, end) {
@@ -930,18 +912,18 @@ var CutMode = class {
       ).addTo(this.map);
     }
     if (this.points.length === 1 && this.markers.length === 0) {
-      const marker3 = L11.circleMarker(
+      const marker2 = L11.circleMarker(
         this.points[0],
         getModeHandleOptions(this.options, "cut" /* Cut */, {
           radius: 6,
           color: "#ff0000"
         })
       ).addTo(this.map);
-      marker3.on("click", (e) => {
+      marker2.on("click", (e) => {
         L11.DomEvent.stopPropagation(e);
         if (this.points.length >= 3) this.finish();
       });
-      this.markers.push(marker3);
+      this.markers.push(marker2);
     }
   }
   finish() {
@@ -960,12 +942,12 @@ var CutMode = class {
       this.resetDrawing();
       return;
     }
-    intersectedLayers.forEach((polygon7) => {
-      const polyGeo = polygon7.toGeoJSON();
+    intersectedLayers.forEach((polygon8) => {
+      const polyGeo = polygon8.toGeoJSON();
       const result = turf2.difference(turf2.featureCollection([polyGeo, holeGeo]));
       if (result) {
-        this.map.fire(ANVIL_EVENTS.DELETED, { layer: polygon7 });
-        this.map.removeLayer(polygon7);
+        this.map.fire(ANVIL_EVENTS.DELETED, { layer: polygon8 });
+        this.map.removeLayer(polygon8);
         const flattened = turf2.flatten(result);
         flattened.features.forEach((f) => {
           const l = L11.geoJSON(f, {
@@ -990,8 +972,260 @@ var CutMode = class {
 };
 
 // src/modes/split-mode.ts
+var L13 = __toESM(require("leaflet"));
+var turf4 = __toESM(require("@turf/turf"));
+
+// src/utils/polygon-topology.ts
 var L12 = __toESM(require("leaflet"));
 var turf3 = __toESM(require("@turf/turf"));
+function createCoverageSnapshot(layers) {
+  const features = layers.map((layer) => sanitizePolygonFeature(layer.toGeoJSON())).filter((feature) => Boolean(feature));
+  if (features.length === 0) return null;
+  const target = unionPolygonFeatures(features);
+  if (!target) return null;
+  return { target };
+}
+function hasSharedBoundaryCoverage(layers) {
+  const features = layers.map((layer) => sanitizePolygonFeature(layer.toGeoJSON())).filter((feature) => Boolean(feature)).map((feature) => ({
+    feature,
+    boundary: turf3.polygonToLine(feature)
+  }));
+  for (let i = 0; i < features.length; i++) {
+    for (let j = i + 1; j < features.length; j++) {
+      if (getBoundaryContactLength(features[i].boundary, features[j].boundary) > 0) {
+        return true;
+      }
+      try {
+        const overlap = turf3.intersect(
+          turf3.featureCollection([features[i].feature, features[j].feature])
+        );
+        if (overlap && turf3.area(overlap) > 0) {
+          return true;
+        }
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+function repairPolygonCoverage(layers, snapshot) {
+  const target = sanitizePolygonFeature(snapshot.target);
+  if (!target) return [];
+  const current = layers.map((layer) => {
+    const feature = sanitizePolygonFeature(layer.toGeoJSON());
+    if (!feature) return null;
+    return {
+      layer,
+      feature,
+      boundary: turf3.polygonToLine(feature)
+    };
+  }).filter((entry) => Boolean(entry));
+  if (current.length < 2) return [];
+  const currentUnion = unionPolygonFeatures(current.map(({ feature }) => feature));
+  if (!currentUnion) return [];
+  let missingCoverage = null;
+  try {
+    missingCoverage = turf3.difference(
+      turf3.featureCollection([target, currentUnion])
+    );
+  } catch {
+    return [];
+  }
+  if (!missingCoverage) return [];
+  const gaps = [];
+  turf3.flattenEach(missingCoverage, (feature) => {
+    const sanitized = sanitizePolygonFeature(feature);
+    if (sanitized && sanitized.geometry.type === "Polygon") {
+      gaps.push(sanitized);
+    }
+  });
+  if (gaps.length === 0) return [];
+  const assignments = new Map(current.map(({ layer }) => [layer, []]));
+  gaps.forEach((gap) => {
+    const owner = pickOwnerForCell(gap, current);
+    if (!owner) return;
+    assignments.get(owner.layer)?.push(gap);
+  });
+  const repaired = [];
+  assignments.forEach((cells, layer) => {
+    if (cells.length === 0) return;
+    const existing = current.find((entry) => entry.layer === layer)?.feature;
+    if (!existing) return;
+    const merged = unionPolygonFeatures([existing, ...cells]);
+    if (!merged) return;
+    layer.setLatLngs(toLeafletLatLngs(merged.geometry));
+    layer.redraw();
+    repaired.push(layer);
+  });
+  return repaired;
+}
+function collectTouchingPolygons(group, seedLayers) {
+  const seeds = seedLayers.map((layer) => ({
+    layer,
+    feature: sanitizePolygonFeature(layer.toGeoJSON())
+  })).filter((entry) => Boolean(entry.feature));
+  const related = new Set(seedLayers);
+  group.eachLayer((layer) => {
+    if (!(layer instanceof L12.Polygon) || related.has(layer)) return;
+    const feature = sanitizePolygonFeature(layer.toGeoJSON());
+    if (!feature) return;
+    const touchesSeed = seeds.some((seed) => {
+      try {
+        return turf3.booleanIntersects(seed.feature, feature);
+      } catch {
+        return false;
+      }
+    });
+    if (touchesSeed) related.add(layer);
+  });
+  return Array.from(related);
+}
+function pickOwnerForCell(cell, current) {
+  const point5 = turf3.pointOnFeature(cell);
+  const containing = current.filter(({ feature }) => {
+    try {
+      return turf3.booleanPointInPolygon(point5, feature) || turf3.booleanWithin(point5, feature);
+    } catch {
+      return false;
+    }
+  });
+  if (containing.length === 1) return containing[0];
+  if (containing.length > 1) return containing[0];
+  const cellBoundary = turf3.polygonToLine(cell);
+  let best = null;
+  current.forEach((entry) => {
+    const score = getBoundaryContactLength(cellBoundary, entry.boundary);
+    if (!best || score > best.score) {
+      best = { entry, score };
+    }
+  });
+  if (best && best.score > 0) return best.entry;
+  let nearest = null;
+  current.forEach((entry) => {
+    try {
+      const distance = turf3.pointToLineDistance(point5, entry.boundary);
+      if (!nearest || distance < nearest.distance) {
+        nearest = { entry, distance };
+      }
+    } catch {
+    }
+  });
+  return nearest?.entry ?? null;
+}
+function getPolygonOverlapArea(first, second) {
+  try {
+    const firstBbox = turf3.bbox(first);
+    const secondBbox = turf3.bbox(second);
+    if (firstBbox[2] < secondBbox[0] || secondBbox[2] < firstBbox[0] || firstBbox[3] < secondBbox[1] || secondBbox[3] < firstBbox[1]) {
+      return 0;
+    }
+    const intersection = turf3.intersect(
+      turf3.featureCollection([first, second])
+    );
+    return intersection ? turf3.area(intersection) : 0;
+  } catch {
+    return 0;
+  }
+}
+function getBoundaryContactLength(cellBoundary, boundary) {
+  try {
+    const overlaps = turf3.lineOverlap(cellBoundary, boundary, { tolerance: 1e-12 });
+    return overlaps.features.reduce((sum, feature) => sum + turf3.length(feature), 0);
+  } catch {
+    return 0;
+  }
+}
+function unionPolygonFeatures(features) {
+  if (features.length === 0) return null;
+  let merged = sanitizePolygonFeature(features[0]);
+  if (!merged) return null;
+  for (const feature of features.slice(1)) {
+    const next = sanitizePolygonFeature(feature);
+    if (!next) continue;
+    try {
+      const unioned = turf3.union(turf3.featureCollection([merged, next]));
+      if (!unioned) continue;
+      const sanitizedUnion = sanitizePolygonFeature(unioned);
+      if (sanitizedUnion) merged = sanitizedUnion;
+    } catch {
+      return null;
+    }
+  }
+  return merged;
+}
+function sanitizePolygonFeature(feature) {
+  let cleaned;
+  try {
+    cleaned = turf3.cleanCoords(feature, { mutate: false });
+  } catch {
+    cleaned = {
+      ...feature,
+      geometry: clonePolygonGeometry(feature.geometry)
+    };
+  }
+  if (cleaned.geometry.type === "Polygon") {
+    const rings = cleaned.geometry.coordinates.map((ring) => normalizeRing(ring)).filter((ring) => isValidRing(ring));
+    if (rings.length === 0) return null;
+    return turf3.polygon(rings, cleaned.properties || {}, {
+      bbox: cleaned.bbox,
+      id: cleaned.id
+    });
+  }
+  const polygons = cleaned.geometry.coordinates.map((polygon8) => polygon8.map((ring) => normalizeRing(ring)).filter((ring) => isValidRing(ring))).filter((polygon8) => polygon8.length > 0);
+  if (polygons.length === 0) return null;
+  return turf3.multiPolygon(polygons, cleaned.properties || {}, {
+    bbox: cleaned.bbox,
+    id: cleaned.id
+  });
+}
+function clonePolygonGeometry(geometry) {
+  if (geometry.type === "Polygon") {
+    return {
+      type: "Polygon",
+      coordinates: geometry.coordinates.map((ring) => ring.map((coord) => [...coord]))
+    };
+  }
+  return {
+    type: "MultiPolygon",
+    coordinates: geometry.coordinates.map(
+      (polygon8) => polygon8.map((ring) => ring.map((coord) => [...coord]))
+    )
+  };
+}
+function normalizeRing(ring) {
+  const deduped = removeSequentialDuplicateCoords(ring);
+  if (deduped.length === 0) return deduped;
+  const first = deduped[0];
+  const last = deduped[deduped.length - 1];
+  if (coordKey(first) !== coordKey(last)) {
+    deduped.push([...first]);
+  }
+  return deduped;
+}
+function removeSequentialDuplicateCoords(coords) {
+  const result = [];
+  coords.forEach((coord) => {
+    if (result.length === 0 || coordKey(result[result.length - 1]) !== coordKey(coord)) {
+      result.push([...coord]);
+    }
+  });
+  return result;
+}
+function isValidRing(ring) {
+  if (ring.length < 4) return false;
+  if (coordKey(ring[0]) !== coordKey(ring[ring.length - 1])) return false;
+  const uniqueCoords = new Set(ring.slice(0, -1).map((coord) => coordKey(coord)));
+  return uniqueCoords.size >= 3;
+}
+function coordKey(coord) {
+  return `${coord[0].toFixed(12)},${coord[1].toFixed(12)}`;
+}
+function toLeafletLatLngs(geometry) {
+  const levelsDeep = geometry.type === "Polygon" ? 1 : 2;
+  return L12.GeoJSON.coordsToLatLngs(geometry.coordinates, levelsDeep);
+}
+
+// src/modes/split-mode.ts
 var SplitMode = class {
   constructor(map, store, options = {}) {
     this.map = map;
@@ -1005,13 +1239,13 @@ var SplitMode = class {
   enable() {
     this.map.on("click", this.onMapClick, this);
     this.map.on("mousemove", this.onMouseMove, this);
-    L12.DomEvent.on(window, "keydown", this.onKeyDown, this);
+    L13.DomEvent.on(window, "keydown", this.onKeyDown, this);
     this.map.getContainer().style.cursor = "crosshair";
   }
   disable() {
     this.map.off("click", this.onMapClick, this);
     this.map.off("mousemove", this.onMouseMove, this);
-    L12.DomEvent.off(window, "keydown", this.onKeyDown, this);
+    L13.DomEvent.off(window, "keydown", this.onKeyDown, this);
     this.map.getContainer().style.cursor = "";
     this.resetDrawing();
   }
@@ -1034,7 +1268,7 @@ var SplitMode = class {
     const snapLatLng = getSnapLatLng(this.map, e.latlng, this.store, this.options, this.points);
     const lastPoint = this.points[this.points.length - 1];
     if (!this.ghostLine) {
-      this.ghostLine = L12.polyline(
+      this.ghostLine = L13.polyline(
         [lastPoint, snapLatLng],
         getModeGhostPathOptions(this.options, "split" /* Split */, {
           dashArray: "5, 5",
@@ -1055,7 +1289,7 @@ var SplitMode = class {
     if (this.polyline) {
       this.polyline.setLatLngs(this.points);
     } else {
-      this.polyline = L12.polyline(
+      this.polyline = L13.polyline(
         this.points,
         getModePathOptions(this.options, "split" /* Split */, {
           color: "#ff3300",
@@ -1065,18 +1299,18 @@ var SplitMode = class {
     }
     const lastPoint = this.points[this.points.length - 1];
     if (this.markers.length === 0) {
-      const marker3 = L12.circleMarker(
+      const marker2 = L13.circleMarker(
         lastPoint,
         getModeHandleOptions(this.options, "split" /* Split */, {
           radius: 5,
           color: "#ff3300"
         })
       ).addTo(this.map);
-      marker3.on("click", (e) => {
-        L12.DomEvent.stopPropagation(e);
+      marker2.on("click", (e) => {
+        L13.DomEvent.stopPropagation(e);
         this.finish();
       });
-      this.markers.push(marker3);
+      this.markers.push(marker2);
     } else {
       this.markers[0].setLatLng(lastPoint);
     }
@@ -1086,13 +1320,12 @@ var SplitMode = class {
       this.resetDrawing();
       return;
     }
-    const lineGeo = L12.polyline(this.points).toGeoJSON();
-    const coords = turf3.getCoords(lineGeo);
+    const lineGeo = L13.polyline(this.points).toGeoJSON();
     const layersToSplit = [];
     this.store.getGroup().eachLayer((layer) => {
-      if (layer instanceof L12.Polygon) {
+      if (layer instanceof L13.Polygon) {
         const polyGeo = layer.toGeoJSON();
-        const intersections = turf3.lineIntersect(lineGeo, polyGeo);
+        const intersections = turf4.lineIntersect(lineGeo, polyGeo);
         if (intersections.features.length >= 2) {
           layersToSplit.push(layer);
         }
@@ -1102,62 +1335,321 @@ var SplitMode = class {
       this.resetDrawing();
       return;
     }
-    const p1 = coords[0];
-    const p2 = coords[coords.length - 1];
-    const dx = p2[0] - p1[0];
-    const dy = p2[1] - p1[1];
-    const factor = 1e3;
-    const start = [p1[0] - dx * factor, p1[1] - dy * factor];
-    const end = [p2[0] + dx * factor, p2[1] + dy * factor];
-    const angle = Math.atan2(dy, dx);
-    const perp = angle + Math.PI / 2;
-    const width = 1e3;
-    const blade = turf3.polygon([[
-      start,
-      end,
-      [end[0] + Math.cos(perp) * width, end[1] + Math.sin(perp) * width],
-      [start[0] + Math.cos(perp) * width, start[1] + Math.sin(perp) * width],
-      start
-    ]]);
-    layersToSplit.forEach((polygon7) => {
-      const polyGeo = polygon7.toGeoJSON();
-      if (this.options.magnetic) {
-        const intersections = turf3.lineIntersect(lineGeo, polyGeo);
-        this.insertVerticesIntoNeighbors(intersections, polygon7);
-      }
-      const part1 = turf3.difference(turf3.featureCollection([polyGeo, blade]));
-      const part2 = turf3.intersect(turf3.featureCollection([polyGeo, blade]));
-      if (part1 && part2) {
-        const processResult = (result) => {
-          const flattened = turf3.flatten(result);
-          flattened.features.forEach((f) => {
-            const l = L12.geoJSON(f, {
-              style: getModePathOptions(this.options, "split" /* Split */)
-            }).getLayers()[0];
-            l.addTo(this.map);
-            this.map.fire(ANVIL_EVENTS.CREATED, { layer: l });
-          });
-        };
-        this.map.fire(ANVIL_EVENTS.DELETED, { layer: polygon7 });
-        this.map.removeLayer(polygon7);
-        processResult(part1);
-        processResult(part2);
+    const repairCandidates = collectTouchingPolygons(this.store.getGroup(), layersToSplit);
+    const coverageSnapshot = createCoverageSnapshot(repairCandidates);
+    const deletedPolygons = /* @__PURE__ */ new Set();
+    const createdPolygons = [];
+    layersToSplit.forEach((polygon8) => {
+      const polyGeo = polygon8.toGeoJSON();
+      const sourceStyle = { ...polygon8.options };
+      const intersections = turf4.lineIntersect(lineGeo, polyGeo);
+      this.insertVerticesIntoNeighbors(intersections, polygon8);
+      const parts = this.normalizeSplitParts(
+        polyGeo,
+        this.splitPolygonAlongLine(polyGeo, lineGeo)
+      );
+      if (parts.length >= 2) {
+        deletedPolygons.add(polygon8);
+        this.map.fire(ANVIL_EVENTS.DELETED, { layer: polygon8 });
+        this.map.removeLayer(polygon8);
+        parts.forEach((feature) => {
+          const l = L13.geoJSON(feature, {
+            style: sourceStyle
+          }).getLayers()[0];
+          l.addTo(this.map);
+          createdPolygons.push(l);
+          this.map.fire(ANVIL_EVENTS.CREATED, { layer: l });
+        });
       }
     });
+    if (coverageSnapshot) {
+      const currentRepairLayers = [
+        ...repairCandidates.filter((layer) => !deletedPolygons.has(layer) && this.map.hasLayer(layer)),
+        ...createdPolygons
+      ].filter((layer, index, arr) => arr.indexOf(layer) === index);
+      repairPolygonCoverage(currentRepairLayers, coverageSnapshot).forEach((layer) => this.map.fire(ANVIL_EVENTS.EDITED, { layer }));
+    }
     this.resetDrawing();
   }
+  splitPolygonAlongLine(polygon8, line) {
+    const sanitizedPolygon = this.sanitizePolygonFeature(polygon8);
+    const sanitizedLine = this.sanitizeLineStringFeature(line);
+    if (!sanitizedPolygon || !sanitizedLine) return [];
+    const boundaryLines = this.getBoundaryLines(sanitizedPolygon);
+    if (boundaryLines.length === 0) return [];
+    const intersectionCoords = this.getIntersectionCoords(sanitizedLine, boundaryLines);
+    if (intersectionCoords.length < 2) return [];
+    const splitter = turf4.multiPoint(intersectionCoords);
+    const splitBoundary = [];
+    boundaryLines.forEach((boundaryLine) => {
+      turf4.lineSplit(boundaryLine, splitter).features.forEach((segment) => {
+        const sanitizedSegment = this.sanitizeLineStringFeature(segment);
+        if (sanitizedSegment) splitBoundary.push(sanitizedSegment);
+      });
+    });
+    const splitLine = turf4.lineSplit(sanitizedLine, splitter);
+    const innerSegments = splitLine.features.map((segment) => this.sanitizeLineStringFeature(segment)).filter((segment) => Boolean(segment)).filter((segment) => this.isSegmentInsidePolygon(segment, sanitizedPolygon));
+    if (innerSegments.length === 0) return [];
+    try {
+      const polygonized = turf4.polygonize(
+        turf4.featureCollection([
+          ...splitBoundary,
+          ...innerSegments
+        ])
+      );
+      return polygonized.features.map((feature) => this.sanitizePolygonFeature(feature)).filter((feature) => Boolean(feature) && feature.geometry.type === "Polygon").filter((feature) => this.isPolygonInsideOriginal(feature, sanitizedPolygon));
+    } catch {
+      return [];
+    }
+  }
+  normalizeSplitParts(target, parts) {
+    const sanitizedTarget = this.sanitizePolygonFeature(target);
+    if (!sanitizedTarget) return [];
+    const rawParts = parts.map((part) => this.sanitizePolygonFeature(part)).filter((part) => Boolean(part) && part.geometry.type === "Polygon");
+    if (rawParts.length < 2) return rawParts;
+    const assigned = rawParts.map(() => []);
+    let remainder = sanitizedTarget;
+    rawParts.forEach((part, index) => {
+      if (!remainder) return;
+      const clipped = this.intersectPolygonFeatures(part, remainder);
+      assigned[index].push(...clipped);
+      remainder = this.subtractPolygonFeature(remainder, part);
+    });
+    if (remainder) {
+      this.flattenPolygonFeatures(remainder).forEach((gap) => {
+        const ownerIndex = this.pickBestPartIndex(gap, rawParts);
+        if (ownerIndex >= 0) {
+          assigned[ownerIndex].push(gap);
+        }
+      });
+    }
+    return assigned.flatMap((cells) => {
+      if (cells.length === 0) return [];
+      const merged = this.unionPolygonFeatures(cells);
+      if (!merged) return [];
+      return this.flattenPolygonFeatures(merged);
+    });
+  }
+  isSegmentInsidePolygon(segment, polygon8) {
+    const coords = segment.geometry.coordinates;
+    if (coords.length < 2) return false;
+    const midpoint2 = turf4.midpoint(
+      turf4.point(coords[0]),
+      turf4.point(coords[coords.length - 1])
+    );
+    return turf4.booleanWithin(midpoint2, polygon8) || turf4.booleanPointInPolygon(midpoint2, polygon8);
+  }
+  isPolygonInsideOriginal(candidate, original) {
+    const point5 = turf4.pointOnFeature(candidate);
+    return turf4.booleanWithin(point5, original) || turf4.booleanPointInPolygon(point5, original);
+  }
+  intersectPolygonFeatures(first, second) {
+    try {
+      const intersection = turf4.intersect(
+        turf4.featureCollection([first, second])
+      );
+      if (!intersection) return [];
+      return this.flattenPolygonFeatures(intersection);
+    } catch {
+      return [];
+    }
+  }
+  subtractPolygonFeature(base, subtractor) {
+    try {
+      const diff = turf4.difference(
+        turf4.featureCollection([base, subtractor])
+      );
+      if (!diff) return null;
+      return this.sanitizePolygonFeature(diff);
+    } catch {
+      return base;
+    }
+  }
+  unionPolygonFeatures(features) {
+    if (features.length === 0) return null;
+    let merged = this.sanitizePolygonFeature(features[0]);
+    if (!merged) return null;
+    for (const feature of features.slice(1)) {
+      const next = this.sanitizePolygonFeature(feature);
+      if (!next) continue;
+      try {
+        const unioned = turf4.union(turf4.featureCollection([merged, next]));
+        if (!unioned) continue;
+        const sanitizedUnion = this.sanitizePolygonFeature(unioned);
+        if (sanitizedUnion) merged = sanitizedUnion;
+      } catch {
+        return null;
+      }
+    }
+    return merged;
+  }
+  flattenPolygonFeatures(feature) {
+    const polygons = [];
+    turf4.flattenEach(feature, (flattened) => {
+      const sanitized = this.sanitizePolygonFeature(flattened);
+      if (sanitized && sanitized.geometry.type === "Polygon") {
+        polygons.push(sanitized);
+      }
+    });
+    return polygons;
+  }
+  pickBestPartIndex(cell, parts) {
+    const cellBoundary = turf4.polygonToLine(cell);
+    let bestIndex = -1;
+    let bestScore = -1;
+    parts.forEach((part, index) => {
+      const boundary = turf4.polygonToLine(part);
+      const score = this.getBoundaryContactLength(cellBoundary, boundary);
+      if (score > bestScore) {
+        bestScore = score;
+        bestIndex = index;
+      }
+    });
+    if (bestScore > 0) return bestIndex;
+    const point5 = turf4.pointOnFeature(cell);
+    let nearestIndex = -1;
+    let nearestDistance = Infinity;
+    parts.forEach((part, index) => {
+      try {
+        const boundary = turf4.polygonToLine(part);
+        const distance = turf4.pointToLineDistance(point5, boundary);
+        if (distance < nearestDistance) {
+          nearestDistance = distance;
+          nearestIndex = index;
+        }
+      } catch {
+      }
+    });
+    return nearestIndex;
+  }
+  getBoundaryContactLength(first, second) {
+    try {
+      const overlaps = turf4.lineOverlap(first, second, { tolerance: 1e-12 });
+      return overlaps.features.reduce((sum, feature) => sum + turf4.length(feature), 0);
+    } catch {
+      return 0;
+    }
+  }
+  getBoundaryLines(polygon8) {
+    const boundary = turf4.polygonToLine(polygon8);
+    const lines = [];
+    turf4.flattenEach(boundary, (feature) => {
+      const sanitized = this.sanitizeLineStringFeature(feature);
+      if (sanitized) lines.push(sanitized);
+    });
+    return lines;
+  }
+  getIntersectionCoords(line, boundaryLines) {
+    const intersections = /* @__PURE__ */ new Map();
+    boundaryLines.forEach((boundaryLine) => {
+      turf4.lineIntersect(line, boundaryLine).features.forEach((feature) => {
+        const coord = turf4.getCoord(feature);
+        intersections.set(this.coordKey(coord), coord);
+      });
+    });
+    return Array.from(intersections.values());
+  }
+  sanitizeLineStringFeature(feature) {
+    let cleaned;
+    try {
+      cleaned = turf4.cleanCoords(feature, { mutate: false });
+    } catch {
+      cleaned = {
+        ...feature,
+        geometry: {
+          ...feature.geometry,
+          coordinates: feature.geometry.coordinates.map((coord) => [...coord])
+        }
+      };
+    }
+    if (cleaned.geometry.type !== "LineString") return null;
+    const coordinates = this.removeSequentialDuplicateCoords(cleaned.geometry.coordinates);
+    const uniqueCoords = new Set(coordinates.map((coord) => this.coordKey(coord)));
+    if (coordinates.length < 2 || uniqueCoords.size < 2) return null;
+    return turf4.lineString(coordinates, cleaned.properties || {}, {
+      bbox: cleaned.bbox,
+      id: cleaned.id
+    });
+  }
+  sanitizePolygonFeature(feature) {
+    let cleaned;
+    try {
+      cleaned = turf4.cleanCoords(feature, { mutate: false });
+    } catch {
+      cleaned = {
+        ...feature,
+        geometry: this.clonePolygonGeometry(feature.geometry)
+      };
+    }
+    if (cleaned.geometry.type === "Polygon") {
+      const rings = cleaned.geometry.coordinates.map((ring) => this.normalizeRing(ring)).filter((ring) => this.isValidRing(ring));
+      if (rings.length === 0) return null;
+      return turf4.polygon(rings, cleaned.properties || {}, {
+        bbox: cleaned.bbox,
+        id: cleaned.id
+      });
+    }
+    const polygons = cleaned.geometry.coordinates.map((polygon8) => polygon8.map((ring) => this.normalizeRing(ring)).filter((ring) => this.isValidRing(ring))).filter((polygon8) => polygon8.length > 0);
+    if (polygons.length === 0) return null;
+    return turf4.multiPolygon(polygons, cleaned.properties || {}, {
+      bbox: cleaned.bbox,
+      id: cleaned.id
+    });
+  }
+  normalizeRing(ring) {
+    const deduped = this.removeSequentialDuplicateCoords(ring);
+    if (deduped.length === 0) return deduped;
+    const first = deduped[0];
+    const last = deduped[deduped.length - 1];
+    if (this.coordKey(first) !== this.coordKey(last)) {
+      deduped.push([...first]);
+    }
+    return deduped;
+  }
+  removeSequentialDuplicateCoords(coords) {
+    const result = [];
+    coords.forEach((coord) => {
+      if (result.length === 0 || this.coordKey(result[result.length - 1]) !== this.coordKey(coord)) {
+        result.push([...coord]);
+      }
+    });
+    return result;
+  }
+  isValidRing(ring) {
+    if (ring.length < 4) return false;
+    if (this.coordKey(ring[0]) !== this.coordKey(ring[ring.length - 1])) return false;
+    const uniqueCoords = new Set(ring.slice(0, -1).map((coord) => this.coordKey(coord)));
+    return uniqueCoords.size >= 3;
+  }
+  coordKey(coord) {
+    return `${coord[0].toFixed(12)},${coord[1].toFixed(12)}`;
+  }
+  clonePolygonGeometry(geometry) {
+    if (geometry.type === "Polygon") {
+      return {
+        type: "Polygon",
+        coordinates: geometry.coordinates.map((ring) => ring.map((coord) => [...coord]))
+      };
+    }
+    return {
+      type: "MultiPolygon",
+      coordinates: geometry.coordinates.map(
+        (polygon8) => polygon8.map((ring) => ring.map((coord) => [...coord]))
+      )
+    };
+  }
   insertVerticesIntoNeighbors(intersections, activePolygon) {
-    const intersectionCoords = intersections.features.map((f) => turf3.getCoord(f));
+    const intersectionCoords = intersections.features.map((f) => turf4.getCoord(f));
     const layers = this.store.getGroup().getLayers();
     layers.forEach((layer) => {
-      if (!(layer instanceof L12.Polyline) || layer === activePolygon) return;
+      if (!(layer instanceof L13.Polyline) || layer === activePolygon) return;
       const latlngs = layer.getLatLngs();
       let changed = false;
       const processArr = (arr) => {
         if (arr.length === 0) return;
-        if (arr[0] instanceof L12.LatLng || typeof arr[0].lat === "number") {
+        if (arr[0] instanceof L13.LatLng || typeof arr[0].lat === "number") {
           const ring = arr;
-          const isPolygon = layer instanceof L12.Polygon;
+          const isPolygon = layer instanceof L13.Polygon;
           const ringLen = ring.length;
           for (let i = ringLen - 1; i >= 0; i--) {
             if (i === ringLen - 1 && !isPolygon) continue;
@@ -1166,9 +1658,9 @@ var SplitMode = class {
             const a = this.map.latLngToContainerPoint(p1);
             const b = this.map.latLngToContainerPoint(p2);
             intersectionCoords.forEach((coord) => {
-              const intersectLL = L12.latLng(coord[1], coord[0]);
+              const intersectLL = L13.latLng(coord[1], coord[0]);
               const p = this.map.latLngToContainerPoint(intersectLL);
-              const closest = L12.LineUtil.closestPointOnSegment(p, a, b);
+              const closest = L13.LineUtil.closestPointOnSegment(p, a, b);
               if (p.distanceTo(closest) < 1) {
                 const alreadyExists = ring.some(
                   (ll) => this.map.latLngToContainerPoint(ll).distanceTo(p) < 1
@@ -1204,7 +1696,7 @@ var SplitMode = class {
 };
 
 // src/modes/drag-mode.ts
-var L13 = __toESM(require("leaflet"));
+var L14 = __toESM(require("leaflet"));
 var DragMode = class {
   constructor(map, store, options = {}) {
     this.map = map;
@@ -1235,31 +1727,31 @@ var DragMode = class {
     this.stopDragging();
   }
   addLayerListener(layer) {
-    if (layer instanceof L13.Path || layer instanceof L13.Marker) {
+    if (layer instanceof L14.Path || layer instanceof L14.Marker) {
       layer.on("mousedown", this.onMouseDown, this);
       layer.getElement()?.style.setProperty("cursor", "move");
     }
   }
   removeLayerListener(layer) {
-    if (layer instanceof L13.Path || layer instanceof L13.Marker) {
+    if (layer instanceof L14.Path || layer instanceof L14.Marker) {
       layer.off("mousedown", this.onMouseDown, this);
       layer.getElement()?.style.setProperty("cursor", "");
     }
   }
   onMouseDown(e) {
-    L13.DomEvent.stopPropagation(e);
+    L14.DomEvent.stopPropagation(e);
     const layer = e.target;
     if (!this.store.hasLayer(layer)) {
       return;
     }
     this.draggingLayer = layer;
     this.startLatLng = e.latlng;
-    if (this.draggingLayer instanceof L13.Marker) {
+    if (this.draggingLayer instanceof L14.Marker) {
       this.initialLatLngs = this.draggingLayer.getLatLng();
-    } else if (this.draggingLayer instanceof L13.Path) {
-      if (this.draggingLayer instanceof L13.Circle) {
+    } else if (this.draggingLayer instanceof L14.Path) {
+      if (this.draggingLayer instanceof L14.Circle) {
         this.initialLatLngs = this.draggingLayer.getLatLng();
-      } else if (this.draggingLayer instanceof L13.Polyline) {
+      } else if (this.draggingLayer instanceof L14.Polyline) {
         this.initialLatLngs = JSON.parse(JSON.stringify(this.draggingLayer.getLatLngs()));
       }
       this.originalPathStyle = { ...this.draggingLayer.options };
@@ -1286,10 +1778,10 @@ var DragMode = class {
     );
     const deltaLat = currentLatLng.lat - this.startLatLng.lat;
     const deltaLng = currentLatLng.lng - this.startLatLng.lng;
-    if (this.draggingLayer instanceof L13.Marker || this.draggingLayer instanceof L13.Circle) {
+    if (this.draggingLayer instanceof L14.Marker || this.draggingLayer instanceof L14.Circle) {
       const start = this.initialLatLngs;
       this.draggingLayer.setLatLng([start.lat + deltaLat, start.lng + deltaLng]);
-    } else if (this.draggingLayer instanceof L13.Polyline) {
+    } else if (this.draggingLayer instanceof L14.Polyline) {
       const newLatLngs = this.moveLatLngs(this.initialLatLngs, deltaLat, deltaLng);
       this.draggingLayer.setLatLngs(newLatLngs);
     }
@@ -1298,11 +1790,11 @@ var DragMode = class {
     if (Array.isArray(latlngs)) {
       return latlngs.map((item) => this.moveLatLngs(item, deltaLat, deltaLng));
     }
-    return L13.latLng(latlngs.lat + deltaLat, latlngs.lng + deltaLng);
+    return L14.latLng(latlngs.lat + deltaLat, latlngs.lng + deltaLng);
   }
   onMouseUp() {
     if (this.draggingLayer) {
-      if (this.draggingLayer instanceof L13.Path) {
+      if (this.draggingLayer instanceof L14.Path) {
         this.draggingLayer.setStyle(this.originalPathStyle || {});
       }
       this.map.fire(ANVIL_EVENTS.EDITED, { layer: this.draggingLayer });
@@ -1313,7 +1805,7 @@ var DragMode = class {
     this.map.off("mousemove", this.onMouseMove, this);
     this.map.off("mouseup", this.onMouseUp, this);
     this.map.dragging.enable();
-    if (this.draggingLayer instanceof L13.Path && this.originalPathStyle) {
+    if (this.draggingLayer instanceof L14.Path && this.originalPathStyle) {
       this.draggingLayer.setStyle(this.originalPathStyle);
     }
     this.draggingLayer = null;
@@ -1324,7 +1816,7 @@ var DragMode = class {
 };
 
 // src/modes/scale-mode.ts
-var L14 = __toESM(require("leaflet"));
+var L15 = __toESM(require("leaflet"));
 var ScaleMode = class {
   constructor(map, store, options = {}) {
     this.map = map;
@@ -1339,7 +1831,7 @@ var ScaleMode = class {
   }
   enable() {
     this.store.getGroup().eachLayer((layer) => {
-      if (layer instanceof L14.Path) {
+      if (layer instanceof L15.Path) {
         layer.on("mousedown", this.onMouseDown, this);
         layer.getElement()?.style.setProperty("cursor", "nwse-resize");
       }
@@ -1347,7 +1839,7 @@ var ScaleMode = class {
   }
   disable() {
     this.store.getGroup().eachLayer((layer) => {
-      if (layer instanceof L14.Path) {
+      if (layer instanceof L15.Path) {
         layer.off("mousedown", this.onMouseDown, this);
         layer.getElement()?.style.setProperty("cursor", "");
       }
@@ -1355,17 +1847,17 @@ var ScaleMode = class {
     this.stopScaling();
   }
   onMouseDown(e) {
-    L14.DomEvent.stopPropagation(e);
+    L15.DomEvent.stopPropagation(e);
     const layer = e.target;
     if (!this.store.hasLayer(layer)) {
       return;
     }
     this.selectedLayer = layer;
-    if (this.selectedLayer instanceof L14.Circle) {
+    if (this.selectedLayer instanceof L15.Circle) {
       this.centerLatLng = this.selectedLayer.getLatLng();
       this.initialRadius = this.selectedLayer.getRadius();
     }
-    if (this.selectedLayer instanceof L14.Path) {
+    if (this.selectedLayer instanceof L15.Path) {
       this.originalPathStyle = { ...this.selectedLayer.options };
       this.selectedLayer.setStyle(
         getModeSelectionPathOptions(this.options, "scale" /* Scale */, this.originalPathStyle, {
@@ -1373,7 +1865,7 @@ var ScaleMode = class {
           color: "#ffcc00"
         })
       );
-      if (!(this.selectedLayer instanceof L14.Circle)) {
+      if (!(this.selectedLayer instanceof L15.Circle)) {
         const bounds = this.selectedLayer.getBounds();
         this.centerLatLng = bounds.getCenter();
         this.initialLatLngs = JSON.parse(JSON.stringify(this.selectedLayer.getLatLngs()));
@@ -1390,9 +1882,9 @@ var ScaleMode = class {
     if (!this.selectedLayer || !this.centerLatLng || this.initialDistance === 0) return;
     const currentDistance = this.map.distance(this.centerLatLng, e.latlng);
     const ratio = currentDistance / this.initialDistance;
-    if (this.selectedLayer instanceof L14.Circle) {
+    if (this.selectedLayer instanceof L15.Circle) {
       this.selectedLayer.setRadius(this.initialRadius * ratio);
-    } else if (this.selectedLayer instanceof L14.Path) {
+    } else if (this.selectedLayer instanceof L15.Path) {
       const newLatLngs = this.scaleLatLngs(this.initialLatLngs, this.centerLatLng, ratio);
       this.selectedLayer.setLatLngs(newLatLngs);
     }
@@ -1403,11 +1895,11 @@ var ScaleMode = class {
     }
     const lat = center.lat + (latlngs.lat - center.lat) * ratio;
     const lng = center.lng + (latlngs.lng - center.lng) * ratio;
-    return L14.latLng(lat, lng);
+    return L15.latLng(lat, lng);
   }
   onMouseUp() {
     if (this.selectedLayer) {
-      if (this.selectedLayer instanceof L14.Path) {
+      if (this.selectedLayer instanceof L15.Path) {
         this.selectedLayer.setStyle(this.originalPathStyle || {});
       }
       this.map.fire(ANVIL_EVENTS.EDITED, { layer: this.selectedLayer });
@@ -1418,7 +1910,7 @@ var ScaleMode = class {
     this.map.off("mousemove", this.onMouseMove, this);
     this.map.off("mouseup", this.onMouseUp, this);
     this.map.dragging.enable();
-    if (this.selectedLayer instanceof L14.Path && this.originalPathStyle) {
+    if (this.selectedLayer instanceof L15.Path && this.originalPathStyle) {
       this.selectedLayer.setStyle(this.originalPathStyle);
     }
     this.selectedLayer = null;
@@ -1429,7 +1921,7 @@ var ScaleMode = class {
 };
 
 // src/modes/rotate-mode.ts
-var L15 = __toESM(require("leaflet"));
+var L16 = __toESM(require("leaflet"));
 var RotateMode = class {
   constructor(map, store, options = {}) {
     this.map = map;
@@ -1443,7 +1935,7 @@ var RotateMode = class {
   }
   enable() {
     this.store.getGroup().eachLayer((layer) => {
-      if (layer instanceof L15.Path) {
+      if (layer instanceof L16.Path) {
         layer.on("mousedown", this.onMouseDown, this);
         layer.getElement()?.style.setProperty("cursor", "crosshair");
       }
@@ -1451,7 +1943,7 @@ var RotateMode = class {
   }
   disable() {
     this.store.getGroup().eachLayer((layer) => {
-      if (layer instanceof L15.Path) {
+      if (layer instanceof L16.Path) {
         layer.off("mousedown", this.onMouseDown, this);
         layer.getElement()?.style.setProperty("cursor", "");
       }
@@ -1459,9 +1951,9 @@ var RotateMode = class {
     this.stopRotating();
   }
   onMouseDown(e) {
-    L15.DomEvent.stopPropagation(e);
+    L16.DomEvent.stopPropagation(e);
     const layer = e.target;
-    if (!this.store.hasLayer(layer) || !(layer instanceof L15.Path) || layer instanceof L15.Circle) {
+    if (!this.store.hasLayer(layer) || !(layer instanceof L16.Path) || layer instanceof L16.Circle) {
       return;
     }
     const pathLayer = layer;
@@ -1470,9 +1962,9 @@ var RotateMode = class {
     this.centerLatLng = bounds.getCenter();
     this.initialLatLngs = JSON.parse(JSON.stringify(pathLayer.getLatLngs()));
     this.originalPathStyle = { ...pathLayer.options };
-    const point2 = this.map.latLngToContainerPoint(e.latlng);
+    const point5 = this.map.latLngToContainerPoint(e.latlng);
     const centerPoint = this.map.latLngToContainerPoint(this.centerLatLng);
-    this.startAngle = Math.atan2(point2.y - centerPoint.y, point2.x - centerPoint.x);
+    this.startAngle = Math.atan2(point5.y - centerPoint.y, point5.x - centerPoint.x);
     pathLayer.setStyle(
       getModeSelectionPathOptions(this.options, "rotate" /* Rotate */, this.originalPathStyle, {
         weight: 4,
@@ -1485,9 +1977,9 @@ var RotateMode = class {
   }
   onMouseMove(e) {
     if (!this.selectedLayer || !this.centerLatLng) return;
-    const point2 = this.map.latLngToContainerPoint(e.latlng);
+    const point5 = this.map.latLngToContainerPoint(e.latlng);
     const centerPoint = this.map.latLngToContainerPoint(this.centerLatLng);
-    const currentAngle = Math.atan2(point2.y - centerPoint.y, point2.x - centerPoint.x);
+    const currentAngle = Math.atan2(point5.y - centerPoint.y, point5.x - centerPoint.x);
     const rotationAngle = currentAngle - this.startAngle;
     const newLatLngs = this.rotateLatLngs(this.initialLatLngs, this.centerLatLng, rotationAngle);
     this.selectedLayer.setLatLngs(newLatLngs);
@@ -1496,12 +1988,12 @@ var RotateMode = class {
     if (Array.isArray(latlngs)) {
       return latlngs.map((item) => this.rotateLatLngs(item, center, angle));
     }
-    const point2 = this.map.latLngToContainerPoint(latlngs);
+    const point5 = this.map.latLngToContainerPoint(latlngs);
     const centerPoint = this.map.latLngToContainerPoint(center);
     const cos = Math.cos(angle);
     const sin = Math.sin(angle);
-    const dx = point2.x - centerPoint.x;
-    const dy = point2.y - centerPoint.y;
+    const dx = point5.x - centerPoint.x;
+    const dy = point5.y - centerPoint.y;
     const nx = dx * cos - dy * sin + centerPoint.x;
     const ny = dx * sin + dy * cos + centerPoint.y;
     return this.map.containerPointToLatLng([nx, ny]);
@@ -1528,8 +2020,8 @@ var RotateMode = class {
 };
 
 // src/modes/union-mode.ts
-var L16 = __toESM(require("leaflet"));
-var turf4 = __toESM(require("@turf/turf"));
+var L17 = __toESM(require("leaflet"));
+var turf5 = __toESM(require("@turf/turf"));
 var UnionMode = class {
   constructor(map, store, options = {}) {
     this.map = map;
@@ -1540,7 +2032,7 @@ var UnionMode = class {
   }
   enable() {
     this.store.getGroup().eachLayer((layer) => {
-      if (layer instanceof L16.Polygon) {
+      if (layer instanceof L17.Polygon) {
         layer.on("click", this.onLayerClick, this);
         layer.getElement()?.style.setProperty("cursor", "pointer");
       }
@@ -1548,7 +2040,7 @@ var UnionMode = class {
   }
   disable() {
     this.store.getGroup().eachLayer((layer) => {
-      if (layer instanceof L16.Polygon) {
+      if (layer instanceof L17.Polygon) {
         layer.off("click", this.onLayerClick, this);
         layer.getElement()?.style.setProperty("cursor", "");
       }
@@ -1556,7 +2048,7 @@ var UnionMode = class {
     this.reset();
   }
   onLayerClick(e) {
-    L16.DomEvent.stopPropagation(e);
+    L17.DomEvent.stopPropagation(e);
     const layer = e.target;
     if (!this.firstLayer) {
       this.firstLayer = layer;
@@ -1575,7 +2067,7 @@ var UnionMode = class {
     }
     const g1 = this.firstLayer.toGeoJSON();
     const g2 = layer.toGeoJSON();
-    const united = turf4.union(turf4.featureCollection([g1, g2]));
+    const united = turf5.union(turf5.featureCollection([g1, g2]));
     if (!united) {
       console.error("Union failed - results null");
       this.reset();
@@ -1585,9 +2077,9 @@ var UnionMode = class {
     this.map.fire(ANVIL_EVENTS.DELETED, { layer });
     this.map.removeLayer(this.firstLayer);
     this.map.removeLayer(layer);
-    const flattened = turf4.flatten(united);
+    const flattened = turf5.flatten(united);
     flattened.features.forEach((f) => {
-      const newLayerGroup = L16.geoJSON(f, {
+      const newLayerGroup = L17.geoJSON(f, {
         style: getModePathOptions(this.options, "union" /* Union */)
       });
       const l = newLayerGroup.getLayers()[0];
@@ -1607,8 +2099,8 @@ var UnionMode = class {
 };
 
 // src/modes/subtract-mode.ts
-var L17 = __toESM(require("leaflet"));
-var turf5 = __toESM(require("@turf/turf"));
+var L18 = __toESM(require("leaflet"));
+var turf6 = __toESM(require("@turf/turf"));
 var SubtractMode = class {
   constructor(map, store, options = {}) {
     this.map = map;
@@ -1619,7 +2111,7 @@ var SubtractMode = class {
   }
   enable() {
     this.store.getGroup().eachLayer((layer) => {
-      if (layer instanceof L17.Polygon) {
+      if (layer instanceof L18.Polygon) {
         layer.on("click", this.onLayerClick, this);
         layer.getElement()?.style.setProperty("cursor", "pointer");
       }
@@ -1627,7 +2119,7 @@ var SubtractMode = class {
   }
   disable() {
     this.store.getGroup().eachLayer((layer) => {
-      if (layer instanceof L17.Polygon) {
+      if (layer instanceof L18.Polygon) {
         layer.off("click", this.onLayerClick, this);
         layer.getElement()?.style.setProperty("cursor", "");
       }
@@ -1635,7 +2127,7 @@ var SubtractMode = class {
     this.reset();
   }
   onLayerClick(e) {
-    L17.DomEvent.stopPropagation(e);
+    L18.DomEvent.stopPropagation(e);
     const layer = e.target;
     if (!this.baseLayer) {
       this.baseLayer = layer;
@@ -1654,15 +2146,15 @@ var SubtractMode = class {
     }
     const g1 = this.baseLayer.toGeoJSON();
     const g2 = layer.toGeoJSON();
-    const diff = turf5.difference(turf5.featureCollection([g1, g2]));
+    const diff = turf6.difference(turf6.featureCollection([g1, g2]));
     this.map.fire(ANVIL_EVENTS.DELETED, { layer: this.baseLayer });
     this.map.fire(ANVIL_EVENTS.DELETED, { layer });
     this.map.removeLayer(this.baseLayer);
     this.map.removeLayer(layer);
     if (diff) {
-      const flattened = turf5.flatten(diff);
+      const flattened = turf6.flatten(diff);
       flattened.features.forEach((f) => {
-        const newLayerGroup = L17.geoJSON(f, {
+        const newLayerGroup = L18.geoJSON(f, {
           style: getModePathOptions(this.options, "subtract" /* Subtract */)
         });
         const l = newLayerGroup.getLayers()[0];
@@ -1683,9 +2175,9 @@ var SubtractMode = class {
 };
 
 // src/modes/edit-mode.ts
-var L18 = __toESM(require("leaflet"));
-var EditMode = class {
-  constructor(map, store, options = {}) {
+var L19 = __toESM(require("leaflet"));
+var _EditMode = class _EditMode {
+  constructor(map, store, options = {}, config = {}) {
     this.map = map;
     this.store = store;
     this.options = options;
@@ -1693,38 +2185,90 @@ var EditMode = class {
     __publicField(this, "markers", []);
     __publicField(this, "ghostMarker", null);
     __publicField(this, "segments", []);
-    __publicField(this, "_isDragging", false);
+    __publicField(this, "isDragging", false);
+    __publicField(this, "dragState", null);
+    __publicField(this, "suppressNextClick", false);
     __publicField(this, "originalLayerStyles", /* @__PURE__ */ new Map());
+    __publicField(this, "handleRenderer");
+    __publicField(this, "handlePaneName", "anvil-edit-handles");
+    __publicField(this, "config");
+    __publicField(this, "coverageSnapshot", null);
+    __publicField(this, "dragRollbackState", null);
+    this.config = {
+      modeId: "edit" /* Edit */,
+      autoSelectAll: false,
+      allowLayerSelection: true,
+      clearSelectionOnMapClick: true,
+      defaultSelectionPathOptions: {
+        color: "#ff00ff",
+        weight: 4
+      },
+      defaultHandleOptions: {
+        radius: 6,
+        color: "#ff00ff",
+        fillColor: "#fff",
+        fillOpacity: 1,
+        weight: 2
+      },
+      defaultGhostHandleOptions: {
+        radius: 5,
+        color: "#fff",
+        fillColor: "#ff00ff",
+        fillOpacity: 0.85,
+        weight: 2
+      },
+      ...config
+    };
   }
   enable() {
+    this.ensureHandlePane();
+    this.handleRenderer = this.createHandleRenderer();
     this.store.getGroup().eachLayer((layer) => {
-      if (layer instanceof L18.Path || layer instanceof L18.Marker) {
-        layer.on("click", this.onLayerClick, this);
-        layer.on("mousemove", this.onMouseMove, this);
-        layer.getElement()?.style.setProperty("cursor", "pointer");
-      }
+      this.bindLayerEvents(layer);
     });
     this.map.on("click", this.onMapClick, this);
-    this.map.on("mousemove", this.onMouseMove, this);
+    this.map.on("mousedown", this.onMapMouseDown, this);
+    this.map.on("mousemove", this.onMapMouseMove, this);
+    this.map.on("mouseup", this.onMapMouseUp, this);
+    this.map.on("contextmenu", this.onMapContextMenu, this);
+    this.map.on(ANVIL_EVENTS.CREATED, this.onLayerCreated, this);
+    this.map.on(ANVIL_EVENTS.DELETED, this.onLayerDeleted, this);
+    L19.DomEvent.on(window, "mousemove", this.onWindowMouseMove, this);
+    L19.DomEvent.on(window, "mouseup", this.onWindowMouseUp, this);
+    if (this.config.autoSelectAll) {
+      this.syncAutoSelection();
+    }
   }
   disable() {
+    this.finishDrag(false);
     this.store.getGroup().eachLayer((layer) => {
-      if (layer instanceof L18.Path || layer instanceof L18.Marker) {
-        layer.off("click", this.onLayerClick, this);
-        layer.off("mousemove", this.onMouseMove, this);
-        layer.getElement()?.style.setProperty("cursor", "");
-      }
+      this.unbindLayerEvents(layer);
     });
     this.map.off("click", this.onMapClick, this);
-    this.map.off("mousemove", this.onMouseMove, this);
+    this.map.off("mousedown", this.onMapMouseDown, this);
+    this.map.off("mousemove", this.onMapMouseMove, this);
+    this.map.off("mouseup", this.onMapMouseUp, this);
+    this.map.off("contextmenu", this.onMapContextMenu, this);
+    this.map.off(ANVIL_EVENTS.CREATED, this.onLayerCreated, this);
+    this.map.off(ANVIL_EVENTS.DELETED, this.onLayerDeleted, this);
+    L19.DomEvent.off(window, "mousemove", this.onWindowMouseMove, this);
+    L19.DomEvent.off(window, "mouseup", this.onWindowMouseUp, this);
     this.restoreAllPathStyles();
     this.clearMarkers();
     this.activeLayers.clear();
   }
   onLayerClick(e) {
-    L18.DomEvent.stopPropagation(e);
+    if (this.suppressNextClick) {
+      this.stopLeafletEvent(e);
+      return;
+    }
+    this.stopLeafletEvent(e);
+    this.blurActiveElement();
+    if (!this.config.allowLayerSelection) {
+      return;
+    }
     const layer = e.target;
-    const isMultiSelect = e.originalEvent.shiftKey || this.options.magnetic;
+    const isMultiSelect = e.originalEvent.shiftKey;
     if (!isMultiSelect) {
       if (this.activeLayers.has(layer) && this.activeLayers.size === 1) return;
       this.restoreAllPathStyles();
@@ -1734,131 +2278,317 @@ var EditMode = class {
     } else {
       if (this.activeLayers.has(layer)) {
         this.activeLayers.delete(layer);
-        if (layer instanceof L18.Path) this.restorePathStyle(layer);
+        if (layer instanceof L19.Path) this.restorePathStyle(layer);
       } else {
         this.activeLayers.add(layer);
       }
       this.clearMarkers();
     }
-    this.activeLayers.forEach((l) => {
-      if (l instanceof L18.Path) this.applySelectionStyle(l);
+    this.activeLayers.forEach((activeLayer) => {
+      if (activeLayer instanceof L19.Path) this.applySelectionStyle(activeLayer);
     });
     this.createMarkers();
   }
   onMapClick() {
+    if (this.suppressNextClick) {
+      this.suppressNextClick = false;
+      return;
+    }
+    if (this.isDragging) return;
+    if (!this.config.clearSelectionOnMapClick) return;
     this.restoreAllPathStyles();
     this.clearMarkers();
     this.activeLayers.clear();
   }
+  onLayerCreated(e) {
+    this.bindLayerEvents(e.layer);
+    if (this.config.autoSelectAll) this.syncAutoSelection();
+  }
+  onLayerDeleted(e) {
+    this.unbindLayerEvents(e.layer);
+    this.activeLayers.delete(e.layer);
+    if (e.layer instanceof L19.Path) this.originalLayerStyles.delete(e.layer);
+    if (this.config.autoSelectAll) this.syncAutoSelection();
+  }
+  onMapMouseDown(e) {
+    if (this.activeLayers.size === 0 || this.dragState) return;
+    const hit = this.hitTestHandle(e.latlng);
+    if (!hit) return;
+    this.stopLeafletEvent(e);
+    this.blurActiveElement();
+    this.suppressNextClick = true;
+    if (hit.kind === "ghost") {
+      this.startGhostDrag(hit.segment, hit.marker);
+      return;
+    }
+    if (hit.kind === "circle") {
+      this.startCircleDrag(hit.circle, hit.marker);
+      return;
+    }
+    this.startVertexDrag(hit.group, hit.marker);
+  }
+  onMapMouseMove(e) {
+    if (this.dragState) {
+      this.updateDrag(e.latlng);
+      return;
+    }
+    if (this.activeLayers.size === 0 || this.segments.length === 0) {
+      this.removeGhost();
+      return;
+    }
+    const mousePoint = this.map.latLngToContainerPoint(e.latlng);
+    const isOverVertex = this.markers.some((marker2) => {
+      const markerPoint = this.map.latLngToContainerPoint(marker2.getLatLng());
+      return markerPoint.distanceTo(mousePoint) < 15;
+    });
+    if (isOverVertex) {
+      this.removeGhost();
+      return;
+    }
+    let closestSegment = null;
+    let minDistance = 24;
+    let bestLatLng = null;
+    this.segments.forEach((segment) => {
+      const a = this.map.latLngToContainerPoint(segment.p1);
+      const b = this.map.latLngToContainerPoint(segment.p2);
+      const projection = L19.LineUtil.closestPointOnSegment(mousePoint, a, b);
+      const distance = mousePoint.distanceTo(projection);
+      if (distance < minDistance) {
+        minDistance = distance;
+        closestSegment = segment;
+        bestLatLng = this.map.containerPointToLatLng(projection);
+      }
+    });
+    if (closestSegment && bestLatLng) {
+      this.showGhost(bestLatLng, closestSegment);
+    } else {
+      this.removeGhost();
+    }
+  }
+  onMapMouseUp() {
+    this.finishDrag();
+  }
+  onMapContextMenu(e) {
+    const hit = this.hitTestHandle(e.latlng);
+    if (!hit || hit.kind === "ghost") return;
+    this.stopLeafletEvent(e);
+    this.blurActiveElement();
+    this.suppressNextClick = true;
+    if (hit.kind === "circle") {
+      this.activeLayers.delete(hit.circle);
+      this.originalLayerStyles.delete(hit.circle);
+      this.map.removeLayer(hit.circle);
+      this.map.fire(ANVIL_EVENTS.DELETED, { layer: hit.circle });
+      this.refreshMarkers();
+      return;
+    }
+    this.deleteVertex(hit.group);
+  }
+  onWindowMouseMove(e) {
+    if (!this.dragState) return;
+    const rect = this.map.getContainer().getBoundingClientRect();
+    const point5 = L19.point(e.clientX - rect.left, e.clientY - rect.top);
+    this.updateDrag(this.map.containerPointToLatLng(point5));
+  }
+  onWindowMouseUp() {
+    this.finishDrag();
+  }
   createMarkers() {
     this.clearMarkers();
     if (this.activeLayers.size === 0) return;
     const vertexMap = /* @__PURE__ */ new Map();
-    this.segments = [];
     const segmentMap = /* @__PURE__ */ new Map();
-    const getPosKey = (ll) => `${ll.lat.toFixed(6)},${ll.lng.toFixed(6)}`;
+    this.segments = [];
+    const getPosKey = (latlng) => `${latlng.lat.toFixed(6)},${latlng.lng.toFixed(6)}`;
     this.activeLayers.forEach((layer) => {
-      if (layer instanceof L18.Marker) {
-        this.handleMarkerEdit(layer);
-      } else if (layer instanceof L18.Circle) {
-        this.handleCircleEdit(layer);
-      } else if (layer instanceof L18.Polyline) {
-        const latlngs = layer.getLatLngs();
-        const traverse = (arr, currentPath) => {
-          if (!arr) return;
-          if (Array.isArray(arr) && arr.length > 0 && (arr[0] instanceof L18.LatLng || typeof arr[0].lat === "number")) {
-            const isPolygon = layer instanceof L18.Polygon;
-            let ringLen = arr.length;
-            if (isPolygon && ringLen > 1) {
-              if (getPosKey(arr[0]) === getPosKey(arr[ringLen - 1])) {
-                ringLen--;
-              }
+      if (layer instanceof L19.Marker) {
+        this.enableMarkerEditing(layer);
+        return;
+      }
+      if (layer instanceof L19.Circle) {
+        this.createCircleHandle(layer);
+        return;
+      }
+      if (!(layer instanceof L19.Polyline)) return;
+      const traverse = (arr, currentPath) => {
+        if (!arr) return;
+        if (Array.isArray(arr) && arr.length > 0 && (arr[0] instanceof L19.LatLng || typeof arr[0].lat === "number")) {
+          const isPolygon = layer instanceof L19.Polygon;
+          let ringLen = arr.length;
+          if (isPolygon && ringLen > 1 && getPosKey(arr[0]) === getPosKey(arr[ringLen - 1])) {
+            ringLen--;
+          }
+          arr.forEach((latlng, index) => {
+            if (index >= ringLen) return;
+            const key = getPosKey(latlng);
+            if (!vertexMap.has(key)) {
+              vertexMap.set(key, { latlng, refs: [], marker: null });
             }
-            arr.forEach((ll, i) => {
-              if (i >= ringLen) return;
-              const key = getPosKey(ll);
-              if (!vertexMap.has(key)) vertexMap.set(key, { latlng: ll, refs: [], marker: null });
-              vertexMap.get(key).refs.push({ layer, path: [...currentPath, i] });
-              if (i < ringLen - 1 || isPolygon) {
-                const nextIndex = (i + 1) % ringLen;
-                const nextLL = arr[nextIndex];
-                if (getPosKey(ll) === getPosKey(nextLL)) return;
-                const k1 = getPosKey(ll);
-                const k2 = getPosKey(nextLL);
-                const midKey = [k1, k2].sort().join("|");
-                if (!segmentMap.has(midKey)) {
-                  segmentMap.set(midKey, { p1: ll, p2: nextLL, refs: [] });
-                }
-                segmentMap.get(midKey).refs.push({ layer, path: [...currentPath, i] });
+            vertexMap.get(key).refs.push({ layer, path: [...currentPath, index] });
+            if (index < ringLen - 1 || isPolygon) {
+              const nextIndex = (index + 1) % ringLen;
+              const nextLatLng = arr[nextIndex];
+              if (getPosKey(latlng) === getPosKey(nextLatLng)) return;
+              const segmentKey = [getPosKey(latlng), getPosKey(nextLatLng)].sort().join("|");
+              if (!segmentMap.has(segmentKey)) {
+                segmentMap.set(segmentKey, { p1: latlng, p2: nextLatLng, refs: [] });
               }
-            });
-          } else if (Array.isArray(arr)) {
-            arr.forEach((item, i) => traverse(item, [...currentPath, i]));
-          }
-        };
-        traverse(latlngs, []);
-      }
+              segmentMap.get(segmentKey).refs.push({ layer, path: [...currentPath, index] });
+            }
+          });
+          return;
+        }
+        if (Array.isArray(arr)) {
+          arr.forEach((item, index) => traverse(item, [...currentPath, index]));
+        }
+      };
+      traverse(layer.getLatLngs(), []);
     });
     this.segments = Array.from(segmentMap.values());
     vertexMap.forEach((group) => {
-      const marker3 = this.createEditMarker(group.latlng);
-      group.marker = marker3;
-      this.markers.push(marker3);
-      marker3.on("dragstart", () => {
-        this._isDragging = true;
-      });
-      marker3.on("drag", (e) => {
-        const mouseEvent = e;
-        const skipLayersArray = Array.from(this.activeLayers);
-        const additionalPoints = [
-          ...this.markers.filter((m) => m !== marker3).map((m) => m.getLatLng()),
-          ...Array.from(this.activeLayers).filter((l) => l instanceof L18.Marker).map((l) => l.getLatLng())
-        ];
-        const snapped = getSnapLatLng(this.map, mouseEvent.latlng, this.store, this.options, additionalPoints, skipLayersArray);
-        if (this.options.preventSelfIntersection) {
-          let wouldIntersect = false;
-          group.refs.forEach((ref) => {
-            const fullStructure = ref.layer.getLatLngs();
-            let target = fullStructure;
-            for (let i = 0; i < ref.path.length - 1; i++) {
-              target = target[ref.path[i]];
-            }
-            const oldPos = target[ref.path[ref.path.length - 1]];
-            target[ref.path[ref.path.length - 1]] = snapped;
-            if (isSelfIntersecting(this.map, fullStructure, ref.layer instanceof L18.Polygon)) {
-              wouldIntersect = true;
-            }
-            target[ref.path[ref.path.length - 1]] = oldPos;
-          });
-          if (wouldIntersect) return;
+      const marker2 = this.createHandle(group.latlng);
+      group.marker = marker2;
+      this.setHandleMeta(marker2, { kind: "vertex", group });
+      this.markers.push(marker2);
+    });
+  }
+  startVertexDrag(group, marker2) {
+    this.captureCoverageSnapshotIfNeeded();
+    this.captureDragRollbackState(group.refs.map((ref) => ref.layer));
+    this.removeGhost();
+    this.dragState = { kind: "vertex", group, marker: marker2 };
+    this.isDragging = true;
+    this.map.dragging?.disable();
+  }
+  startGhostDrag(segment, marker2) {
+    this.captureCoverageSnapshotIfNeeded();
+    this.captureDragRollbackState(segment.refs.map((ref) => ref.layer));
+    const startLatLng = marker2.getLatLng();
+    segment.refs.forEach((ref) => {
+      const fullStructure = ref.layer.getLatLngs();
+      let target = fullStructure;
+      for (let i = 0; i < ref.path.length - 1; i++) {
+        target = target[ref.path[i]];
+      }
+      target.splice(ref.path[ref.path.length - 1] + 1, 0, startLatLng);
+      ref.layer.setLatLngs(fullStructure);
+    });
+    this.dragState = { kind: "ghost", segment, marker: marker2 };
+    this.isDragging = true;
+    this.map.dragging?.disable();
+  }
+  startCircleDrag(circle2, marker2) {
+    this.coverageSnapshot = null;
+    this.captureDragRollbackState([circle2]);
+    this.removeGhost();
+    this.dragState = { kind: "circle", circle: circle2, marker: marker2 };
+    this.isDragging = true;
+    this.map.dragging?.disable();
+  }
+  updateDrag(latlng) {
+    if (!this.dragState) return;
+    if (this.dragState.kind === "vertex") {
+      this.updateVertexDrag(this.dragState.group, this.dragState.marker, latlng);
+      return;
+    }
+    if (this.dragState.kind === "ghost") {
+      this.updateGhostDrag(this.dragState.segment, this.dragState.marker, latlng);
+      return;
+    }
+    this.updateCircleDrag(this.dragState.circle, this.dragState.marker, latlng);
+  }
+  updateVertexDrag(group, marker2, latlng) {
+    const skipLayersArray = Array.from(this.activeLayers);
+    const snapped = getSnapLatLng(this.map, latlng, this.store, this.options, [], skipLayersArray);
+    if (this.options.preventSelfIntersection) {
+      let wouldIntersect = false;
+      group.refs.forEach((ref) => {
+        if (this.wouldVertexMoveSelfIntersect(ref, snapped)) {
+          wouldIntersect = true;
         }
-        marker3.setLatLng(snapped);
-        group.latlng = snapped;
-        group.refs.forEach((ref) => {
-          const fullStructure = ref.layer.getLatLngs();
-          let target = fullStructure;
-          for (let i = 0; i < ref.path.length - 1; i++) {
-            target = target[ref.path[i]];
-          }
-          target[ref.path[ref.path.length - 1]] = snapped;
-          ref.layer.setLatLngs(fullStructure);
-          ref.layer.redraw();
-        });
       });
-      marker3.on("dragend", () => {
-        this._isDragging = false;
-        this.activeLayers.forEach((l) => this.map.fire(ANVIL_EVENTS.EDITED, { layer: l }));
-        this.refreshMarkers();
-      });
-      marker3.on("contextmenu", (e) => {
-        const mouseEvent = e;
-        L18.DomEvent.stopPropagation(mouseEvent);
-        this.deleteVertex(group);
+      if (wouldIntersect) return;
+    }
+    marker2.setLatLng(snapped);
+    group.latlng = snapped;
+    group.refs.forEach((ref) => {
+      const fullStructure = ref.layer.getLatLngs();
+      let target = fullStructure;
+      for (let i = 0; i < ref.path.length - 1; i++) {
+        target = target[ref.path[i]];
+      }
+      target[ref.path[ref.path.length - 1]] = snapped;
+      ref.layer.setLatLngs(fullStructure);
+      ref.layer.redraw();
+    });
+  }
+  updateGhostDrag(segment, marker2, latlng) {
+    const skipLayersArray = Array.from(this.activeLayers);
+    const snapped = getSnapLatLng(this.map, latlng, this.store, this.options, [], skipLayersArray);
+    if (this.options.preventSelfIntersection) {
+      let wouldIntersect = false;
+      segment.refs.forEach((ref) => {
+        if (this.wouldInsertedVertexSelfIntersect(ref, snapped)) {
+          wouldIntersect = true;
+        }
       });
+      if (wouldIntersect) return;
+    }
+    marker2.setLatLng(snapped);
+    segment.refs.forEach((ref) => {
+      const fullStructure = ref.layer.getLatLngs();
+      let target = fullStructure;
+      for (let i = 0; i < ref.path.length - 1; i++) {
+        target = target[ref.path[i]];
+      }
+      target[ref.path[ref.path.length - 1] + 1] = snapped;
+      ref.layer.setLatLngs(fullStructure);
+      ref.layer.redraw();
     });
   }
+  updateCircleDrag(circle2, marker2, latlng) {
+    const additionalPoints = this.markers.filter((candidate) => candidate !== marker2).map((candidate) => candidate.getLatLng());
+    const snapped = getSnapLatLng(this.map, latlng, this.store, this.options, additionalPoints, circle2);
+    marker2.setLatLng(snapped);
+    circle2.setLatLng(snapped);
+  }
+  finishDrag(emitEdited = true) {
+    if (!this.dragState) return;
+    const editedLayers = /* @__PURE__ */ new Set();
+    if (this.dragState.kind === "vertex") {
+      this.dragState.group.refs.forEach((ref) => editedLayers.add(ref.layer));
+    } else if (this.dragState.kind === "ghost") {
+      this.dragState.segment.refs.forEach((ref) => editedLayers.add(ref.layer));
+    } else {
+      editedLayers.add(this.dragState.circle);
+    }
+    this.dragState = null;
+    this.isDragging = false;
+    this.suppressNextClick = true;
+    if (this.map.dragging && !this.map.dragging.enabled()) {
+      this.map.dragging.enable();
+    }
+    if (this.options.preventSelfIntersection && this.wouldCurrentDragCreateOverlap()) {
+      this.restoreDragRollbackState();
+      this.coverageSnapshot = null;
+      this.refreshMarkers();
+      return;
+    }
+    this.repairCoverageIfNeeded().forEach((layer) => editedLayers.add(layer));
+    this.dragRollbackState = null;
+    if (emitEdited) {
+      editedLayers.forEach((layer) => this.map.fire(ANVIL_EVENTS.EDITED, { layer }));
+    }
+    this.refreshMarkers();
+  }
   deleteVertex(group) {
+    this.captureCoverageSnapshotIfNeeded();
+    if (this.options.preventSelfIntersection) {
+      const wouldIntersect = group.refs.some((ref) => this.wouldDeletedVertexSelfIntersect(ref));
+      if (wouldIntersect) return;
+    }
     const layersToDelete = /* @__PURE__ */ new Set();
+    const editedLayers = /* @__PURE__ */ new Set();
     group.refs.forEach((ref) => {
       const fullStructure = ref.layer.getLatLngs();
       let target = fullStructure;
@@ -1866,230 +2596,166 @@ var EditMode = class {
         target = target[ref.path[i]];
       }
       const index = ref.path[ref.path.length - 1];
-      const isPolygon = ref.layer instanceof L18.Polygon;
-      const minVertices = isPolygon ? 3 : 2;
+      const minVertices = ref.layer instanceof L19.Polygon ? 3 : 2;
       if (target.length > minVertices) {
         target.splice(index, 1);
         ref.layer.setLatLngs(fullStructure);
         ref.layer.redraw();
-        this.map.fire(ANVIL_EVENTS.EDITED, { layer: ref.layer });
+        editedLayers.add(ref.layer);
       } else {
         layersToDelete.add(ref.layer);
       }
     });
     layersToDelete.forEach((layer) => {
       this.activeLayers.delete(layer);
-      if (layer instanceof L18.Path) {
-        this.originalLayerStyles.delete(layer);
-      }
+      if (layer instanceof L19.Path) this.originalLayerStyles.delete(layer);
       this.map.removeLayer(layer);
       this.map.fire(ANVIL_EVENTS.DELETED, { layer });
     });
-    this.refreshMarkers();
-  }
-  onMouseMove(e) {
-    const mouseEvent = e;
-    if (this.activeLayers.size === 0 || this.segments.length === 0 || this._isDragging) {
-      if (!this._isDragging) this.removeGhost();
-      return;
-    }
-    const mousePoint = this.map.latLngToContainerPoint(mouseEvent.latlng);
-    const isOverVertex = this.markers.some((m) => {
-      const p = this.map.latLngToContainerPoint(m.getLatLng());
-      return p.distanceTo(mousePoint) < 15;
-    });
-    if (isOverVertex) {
-      this.removeGhost();
-      return;
-    }
-    let closestSeg = null;
-    let minDistance = 24;
-    let bestLatLng = null;
-    this.segments.forEach((seg) => {
-      const A = this.map.latLngToContainerPoint(seg.p1);
-      const B = this.map.latLngToContainerPoint(seg.p2);
-      const proj = L18.LineUtil.closestPointOnSegment(mousePoint, A, B);
-      const dist = mousePoint.distanceTo(proj);
-      if (dist < minDistance) {
-        minDistance = dist;
-        closestSeg = seg;
-        bestLatLng = this.map.containerPointToLatLng(proj);
-      }
-    });
-    if (closestSeg && bestLatLng) {
-      this.showGhost(bestLatLng, closestSeg);
+    if (layersToDelete.size === 0) {
+      this.repairCoverageIfNeeded().forEach((layer) => editedLayers.add(layer));
     } else {
-      this.removeGhost();
+      this.coverageSnapshot = null;
     }
-  }
-  createEditMarker(latlng) {
-    const visuals = this.getEditHandleVisuals();
-    return L18.marker(latlng, {
-      draggable: true,
-      zIndexOffset: 2e3,
-      icon: L18.divIcon({
-        className: "anvil-edit-marker",
-        html: this.createHandleHtml(visuals.size, visuals.fillColor, visuals.borderColor, visuals.borderWidth),
-        iconSize: [visuals.size, visuals.size],
-        iconAnchor: [visuals.size / 2, visuals.size / 2]
-      })
-    }).addTo(this.map);
+    editedLayers.forEach((layer) => this.map.fire(ANVIL_EVENTS.EDITED, { layer }));
+    this.refreshMarkers();
   }
   showGhost(latlng, segment) {
     if (this.ghostMarker) {
-      if (!this._isDragging) {
-        this.ghostMarker.setLatLng(latlng);
-        this.ghostMarker._activeSeg = segment;
-      }
+      this.ghostMarker.setLatLng(latlng);
+      this.ghostMarker._activeSeg = segment;
       return;
     }
-    const visuals = this.getGhostHandleVisuals();
-    this.ghostMarker = L18.marker(latlng, {
-      draggable: true,
-      opacity: 0.7,
-      zIndexOffset: 3e3,
-      icon: L18.divIcon({
-        className: "anvil-ghost-marker",
-        html: this.createHandleHtml(visuals.size, visuals.fillColor, visuals.borderColor, visuals.borderWidth),
-        iconSize: [visuals.size, visuals.size],
-        iconAnchor: [visuals.size / 2, visuals.size / 2]
-      })
-    }).addTo(this.map);
-    this.ghostMarker.on("dragstart", () => {
-      this._isDragging = true;
-      const activeSeg = this.ghostMarker._activeSeg || segment;
-      const startLL = this.ghostMarker.getLatLng();
-      activeSeg.refs.forEach((ref) => {
-        const fullStructure = ref.layer.getLatLngs();
-        let target = fullStructure;
-        for (let i = 0; i < ref.path.length - 1; i++) {
-          target = target[ref.path[i]];
-        }
-        target.splice(ref.path[ref.path.length - 1] + 1, 0, startLL);
-        ref.layer.setLatLngs(fullStructure);
-      });
-    });
-    this.ghostMarker.on("drag", (e) => {
-      const mouseEvent = e;
-      const skipLayersArray = Array.from(this.activeLayers);
-      const additionalPoints = [
-        ...this.markers.map((m) => m.getLatLng()),
-        ...Array.from(this.activeLayers).filter((l) => l instanceof L18.Marker).map((l) => l.getLatLng())
-      ];
-      const snapped = getSnapLatLng(this.map, mouseEvent.latlng, this.store, this.options, additionalPoints, skipLayersArray);
-      if (this.options.preventSelfIntersection) {
-        let wouldIntersect = false;
-        const activeSeg2 = this.ghostMarker._activeSeg || segment;
-        activeSeg2.refs.forEach((ref) => {
-          const fullStructure = ref.layer.getLatLngs();
-          let target = fullStructure;
-          for (let i = 0; i < ref.path.length - 1; i++) {
-            target = target[ref.path[i]];
-          }
-          const oldPos = target[ref.path[ref.path.length - 1] + 1];
-          target[ref.path[ref.path.length - 1] + 1] = snapped;
-          if (isSelfIntersecting(this.map, fullStructure, ref.layer instanceof L18.Polygon)) {
-            wouldIntersect = true;
-          }
-          target[ref.path[ref.path.length - 1] + 1] = oldPos;
-        });
-        if (wouldIntersect) return;
-      }
-      this.ghostMarker.setLatLng(snapped);
-      const activeSeg = this.ghostMarker._activeSeg || segment;
-      activeSeg.refs.forEach((ref) => {
-        const fullStructure = ref.layer.getLatLngs();
-        let target = fullStructure;
-        for (let i = 0; i < ref.path.length - 1; i++) {
-          target = target[ref.path[i]];
-        }
-        target[ref.path[ref.path.length - 1] + 1] = snapped;
-        ref.layer.setLatLngs(fullStructure);
-        ref.layer.redraw();
-      });
-    });
-    this.ghostMarker.on("dragend", () => {
-      this._isDragging = false;
-      this.activeLayers.forEach((l) => this.map.fire(ANVIL_EVENTS.EDITED, { layer: l }));
-      this.removeGhost();
-      this.refreshMarkers();
-    });
+    const marker2 = this.createGhostHandle(latlng);
+    marker2._activeSeg = segment;
+    this.ghostMarker = marker2;
   }
   removeGhost() {
-    if (this.ghostMarker && !this._isDragging) {
-      this.map.removeLayer(this.ghostMarker);
-      this.ghostMarker = null;
-    }
-  }
-  handleMarkerEdit(marker3) {
-    marker3.dragging?.enable();
-    marker3.on("drag", (e) => {
-      const mouseEvent = e;
-      const additionalPoints = this.markers.map((m) => m.getLatLng());
-      const snapped = getSnapLatLng(this.map, mouseEvent.latlng, this.store, this.options, additionalPoints, marker3);
-      marker3.setLatLng(snapped);
+    if (!this.ghostMarker || this.isDragging) return;
+    this.ghostMarker.off();
+    this.map.removeLayer(this.ghostMarker);
+    this.ghostMarker = null;
+  }
+  enableMarkerEditing(marker2) {
+    marker2.dragging?.enable();
+    marker2.off("drag");
+    marker2.off("dragend");
+    marker2.off("contextmenu");
+    marker2.on("drag", (e) => {
+      const additionalPoints = this.markers.map((candidate) => candidate.getLatLng());
+      const snapped = getSnapLatLng(this.map, e.latlng, this.store, this.options, additionalPoints, marker2);
+      marker2.setLatLng(snapped);
     });
-    marker3.on("dragend", () => {
-      this.map.fire(ANVIL_EVENTS.EDITED, { layer: marker3 });
+    marker2.on("dragend", () => {
+      this.map.fire(ANVIL_EVENTS.EDITED, { layer: marker2 });
     });
-    marker3.on("contextmenu", (e) => {
-      const mouseEvent = e;
-      L18.DomEvent.stopPropagation(mouseEvent);
-      this.activeLayers.delete(marker3);
-      this.map.removeLayer(marker3);
-      this.map.fire(ANVIL_EVENTS.DELETED, { layer: marker3 });
+    marker2.on("contextmenu", (e) => {
+      this.stopLeafletEvent(e);
+      this.activeLayers.delete(marker2);
+      this.map.removeLayer(marker2);
+      this.map.fire(ANVIL_EVENTS.DELETED, { layer: marker2 });
       this.refreshMarkers();
     });
   }
-  handleCircleEdit(circle2) {
-    const marker3 = this.createEditMarker(circle2.getLatLng());
-    marker3.on("drag", (e) => {
-      const mouseEvent = e;
-      const additionalPoints = this.markers.filter((m) => m !== marker3).map((m) => m.getLatLng());
-      const snapped = getSnapLatLng(this.map, mouseEvent.latlng, this.store, this.options, additionalPoints, circle2);
-      marker3.setLatLng(snapped);
-      circle2.setLatLng(snapped);
-    });
-    marker3.on("dragend", () => {
-      this.map.fire(ANVIL_EVENTS.EDITED, { layer: circle2 });
-    });
-    marker3.on("contextmenu", (e) => {
-      const mouseEvent = e;
-      L18.DomEvent.stopPropagation(mouseEvent);
-      this.activeLayers.delete(circle2);
-      this.originalLayerStyles.delete(circle2);
-      this.map.removeLayer(circle2);
-      this.map.fire(ANVIL_EVENTS.DELETED, { layer: circle2 });
-      this.refreshMarkers();
-    });
-    this.markers.push(marker3);
+  createCircleHandle(circle2) {
+    const marker2 = this.createHandle(circle2.getLatLng());
+    this.setHandleMeta(marker2, { kind: "circle", circle: circle2 });
+    this.markers.push(marker2);
   }
   clearMarkers() {
     this.activeLayers.forEach((layer) => {
-      if (layer instanceof L18.Marker) {
+      if (layer instanceof L19.Marker) {
         layer.dragging?.disable();
         layer.off("drag");
         layer.off("dragend");
         layer.off("contextmenu");
       }
     });
-    this.markers.forEach((m) => this.map.removeLayer(m));
+    this.markers.forEach((marker2) => {
+      this.map.removeLayer(marker2);
+    });
     this.markers = [];
-    this.removeGhost();
+    this.segments = [];
+    this.dragState = null;
+    this.isDragging = false;
+    this.coverageSnapshot = null;
+    this.dragRollbackState = null;
+    if (this.ghostMarker) {
+      this.map.removeLayer(this.ghostMarker);
+      this.ghostMarker = null;
+    }
+    if (this.map.dragging && !this.map.dragging.enabled()) {
+      this.map.dragging.enable();
+    }
   }
   refreshMarkers() {
+    if (this.config.autoSelectAll) {
+      this.syncAutoSelection();
+      return;
+    }
     this.clearMarkers();
     this.createMarkers();
   }
+  bindLayerEvents(layer) {
+    if (!this.isEditableLayer(layer)) return;
+    layer.on("click", this.onLayerClick, this);
+    layer.on("mousemove", this.onMapMouseMove, this);
+    layer.getElement()?.style.setProperty("cursor", "pointer");
+  }
+  unbindLayerEvents(layer) {
+    if (!this.isEditableLayer(layer)) return;
+    layer.off("click", this.onLayerClick, this);
+    layer.off("mousemove", this.onMapMouseMove, this);
+    layer.getElement()?.style.setProperty("cursor", "");
+  }
+  isEditableLayer(layer) {
+    return layer instanceof L19.Path || layer instanceof L19.Marker;
+  }
+  getActivePolygonLayers() {
+    return Array.from(this.activeLayers).filter((layer) => layer instanceof L19.Polygon);
+  }
+  shouldMaintainCoverage() {
+    const polygons = this.getActivePolygonLayers();
+    return polygons.length > 1 && hasSharedBoundaryCoverage(polygons);
+  }
+  captureCoverageSnapshotIfNeeded() {
+    if (!this.shouldMaintainCoverage()) {
+      this.coverageSnapshot = null;
+      return;
+    }
+    this.coverageSnapshot = createCoverageSnapshot(this.getActivePolygonLayers());
+  }
+  repairCoverageIfNeeded() {
+    if (!this.coverageSnapshot) return [];
+    const polygons = this.getActivePolygonLayers();
+    const repaired = polygons.length > 1 ? repairPolygonCoverage(polygons, this.coverageSnapshot) : [];
+    this.coverageSnapshot = null;
+    return repaired;
+  }
+  syncAutoSelection() {
+    this.restoreAllPathStyles();
+    this.clearMarkers();
+    this.activeLayers.clear();
+    this.store.getGroup().eachLayer((layer) => {
+      if (!this.isEditableLayer(layer)) return;
+      this.activeLayers.add(layer);
+    });
+    this.activeLayers.forEach((layer) => {
+      if (layer instanceof L19.Path) this.applySelectionStyle(layer);
+    });
+    this.createMarkers();
+  }
   applySelectionStyle(layer) {
     if (!this.originalLayerStyles.has(layer)) {
       this.originalLayerStyles.set(layer, { ...layer.options });
     }
     layer.setStyle(
-      getModeSelectionPathOptions(this.options, "edit" /* Edit */, this.originalLayerStyles.get(layer) || {}, {
-        color: "#ff00ff",
-        weight: 4
-      })
+      getModeSelectionPathOptions(
+        this.options,
+        this.config.modeId,
+        this.originalLayerStyles.get(layer) || {},
+        this.config.defaultSelectionPathOptions
+      )
     );
   }
   restorePathStyle(layer) {
@@ -2104,45 +2770,319 @@ var EditMode = class {
     });
     this.originalLayerStyles.clear();
   }
-  getEditHandleVisuals() {
-    const selection = getModeSelectionPathOptions(this.options, "edit" /* Edit */, {}, { color: "#ff00ff" });
-    const handle = getModeHandleOptions(this.options, "edit" /* Edit */, {
-      radius: 6,
-      color: selection.color || "#ff00ff",
-      fillColor: "#fff",
-      fillOpacity: 1,
-      weight: 2
-    });
+  createHandle(latlng) {
+    const marker2 = L19.circleMarker(latlng, this.getEditHandleOptions()).addTo(this.map);
+    marker2.bringToFront();
+    return marker2;
+  }
+  createGhostHandle(latlng) {
+    const marker2 = L19.circleMarker(latlng, this.getGhostHandleOptions()).addTo(this.map);
+    marker2.bringToFront();
+    return marker2;
+  }
+  getEditHandleOptions() {
+    const handle = getModeHandleOptions(this.options, this.config.modeId, this.config.defaultHandleOptions);
     return {
-      size: (handle.radius || 6) * 2,
-      fillColor: handle.fillColor || "#fff",
-      borderColor: handle.color || (selection.color || "#ff00ff"),
-      borderWidth: handle.weight || 2
+      ...handle,
+      pane: this.handlePaneName,
+      renderer: this.handleRenderer,
+      interactive: false,
+      bubblingMouseEvents: false
     };
   }
-  getGhostHandleVisuals() {
-    const selection = getModeSelectionPathOptions(this.options, "edit" /* Edit */, {}, { color: "#ff00ff" });
-    const handle = getModeHandleOptions(this.options, "edit" /* Edit */, {
-      radius: 5,
-      color: "#fff",
-      fillColor: selection.color || "#ff00ff",
-      fillOpacity: 1,
-      weight: 2
-    });
+  getGhostHandleOptions() {
+    const handle = getModeHandleOptions(this.options, this.config.modeId, this.config.defaultGhostHandleOptions);
     return {
-      size: (handle.radius || 5) * 2,
-      fillColor: handle.fillColor || (selection.color || "#ff00ff"),
-      borderColor: handle.color || "#fff",
-      borderWidth: handle.weight || 2
+      ...handle,
+      pane: this.handlePaneName,
+      renderer: this.handleRenderer,
+      interactive: false,
+      bubblingMouseEvents: false
     };
   }
-  createHandleHtml(size, fillColor, borderColor, borderWidth) {
-    return `<div style="width: ${size}px; height: ${size}px; background: ${fillColor}; border: ${borderWidth}px solid ${borderColor}; border-radius: 50%; box-sizing: border-box; box-shadow: 0 0 4px rgba(0,0,0,0.3);"></div>`;
+  wouldVertexMoveSelfIntersect(ref, latlng) {
+    const ring = this.getEditableRing(ref);
+    if (!ring) return false;
+    const { points, index, isPolygon } = ring;
+    const updatedPoints = points.slice();
+    updatedPoints[index] = latlng;
+    const changedSegments = [
+      index - 1,
+      index
+    ];
+    if (isPolygon) {
+      if (changedSegments[0] < 0) changedSegments[0] = points.length - 1;
+      if (changedSegments[1] >= points.length) changedSegments[1] = 0;
+    }
+    return this.changedSegmentsIntersect(updatedPoints, changedSegments, isPolygon);
+  }
+  wouldInsertedVertexSelfIntersect(ref, latlng) {
+    const ring = this.getEditableRing(ref);
+    if (!ring) return false;
+    const { points, index, isPolygon } = ring;
+    const insertAt = index + 1;
+    const updatedPoints = [
+      ...points.slice(0, insertAt),
+      latlng,
+      ...points.slice(insertAt)
+    ];
+    return this.changedSegmentsIntersect(updatedPoints, [index, index + 1], isPolygon);
+  }
+  wouldDeletedVertexSelfIntersect(ref) {
+    const ring = this.getEditableRing(ref);
+    if (!ring) return false;
+    const { points, index, isPolygon } = ring;
+    const minVertices = isPolygon ? 3 : 2;
+    if (points.length <= minVertices) return false;
+    if (!isPolygon && (index === 0 || index === points.length - 1)) return false;
+    const updatedPoints = points.slice();
+    updatedPoints.splice(index, 1);
+    if (updatedPoints.length < minVertices) return false;
+    const changedSegmentIndex = isPolygon ? (index - 1 + updatedPoints.length) % updatedPoints.length : index - 1;
+    return this.changedSegmentsIntersect(updatedPoints, [changedSegmentIndex], isPolygon);
+  }
+  getEditableRing(ref) {
+    const fullStructure = ref.layer.getLatLngs();
+    let target = fullStructure;
+    for (let i = 0; i < ref.path.length - 1; i++) {
+      target = target[ref.path[i]];
+    }
+    if (!Array.isArray(target)) return null;
+    const isPolygon = ref.layer instanceof L19.Polygon;
+    const ring = target;
+    let points = ring.slice();
+    if (isPolygon && points.length > 1 && this.sameLatLng(points[0], points[points.length - 1])) {
+      points = points.slice(0, -1);
+    }
+    return {
+      points,
+      index: ref.path[ref.path.length - 1],
+      isPolygon
+    };
+  }
+  captureDragRollbackState(layers) {
+    const rollback = /* @__PURE__ */ new Map();
+    layers.forEach((layer) => {
+      if (rollback.has(layer)) return;
+      if (layer instanceof L19.Polyline) {
+        const state = {
+          latlngs: this.cloneLatLngStructure(layer.getLatLngs())
+        };
+        if (layer instanceof L19.Polygon) {
+          const feature = sanitizePolygonFeature(
+            layer.toGeoJSON()
+          );
+          if (feature) state.feature = feature;
+        }
+        rollback.set(layer, state);
+        return;
+      }
+      if (layer instanceof L19.Circle || layer instanceof L19.Marker) {
+        rollback.set(layer, { latlng: L19.latLng(layer.getLatLng().lat, layer.getLatLng().lng) });
+      }
+    });
+    this.dragRollbackState = rollback;
+  }
+  restoreDragRollbackState() {
+    if (!this.dragRollbackState) return;
+    this.dragRollbackState.forEach((state, layer) => {
+      if (layer instanceof L19.Polyline && state.latlngs) {
+        layer.setLatLngs(this.cloneLatLngStructure(state.latlngs));
+        layer.redraw();
+        return;
+      }
+      if ((layer instanceof L19.Circle || layer instanceof L19.Marker) && state.latlng) {
+        layer.setLatLng(L19.latLng(state.latlng.lat, state.latlng.lng));
+      }
+    });
+    this.dragRollbackState = null;
+  }
+  wouldCurrentDragCreateOverlap() {
+    if (!this.dragRollbackState) return false;
+    const changedPolygonLayers = Array.from(this.dragRollbackState.entries()).filter((entry) => entry[0] instanceof L19.Polygon && Boolean(entry[1].feature));
+    if (changedPolygonLayers.length === 0) return false;
+    const allPolygons = this.store.getLayers().filter((layer) => layer instanceof L19.Polygon);
+    const currentFeatures = /* @__PURE__ */ new Map();
+    allPolygons.forEach((layer) => {
+      const feature = sanitizePolygonFeature(
+        layer.toGeoJSON()
+      );
+      if (feature) currentFeatures.set(layer, feature);
+    });
+    const changedLayerSet = new Set(changedPolygonLayers.map(([layer]) => layer));
+    for (const [changedLayer, snapshot] of changedPolygonLayers) {
+      const beforeChanged = snapshot.feature;
+      const afterChanged = currentFeatures.get(changedLayer);
+      if (!beforeChanged || !afterChanged) continue;
+      for (const otherLayer of allPolygons) {
+        if (otherLayer === changedLayer) continue;
+        if (changedLayerSet.has(otherLayer) && !this.shouldCheckChangedPair(changedLayer, otherLayer)) continue;
+        const beforeOther = this.dragRollbackState.get(otherLayer)?.feature ?? currentFeatures.get(otherLayer);
+        const afterOther = currentFeatures.get(otherLayer);
+        if (!beforeOther || !afterOther) continue;
+        const beforeOverlap = getPolygonOverlapArea(beforeChanged, beforeOther);
+        const afterOverlap = getPolygonOverlapArea(afterChanged, afterOther);
+        if (afterOverlap > beforeOverlap + _EditMode.OVERLAP_AREA_TOLERANCE) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  shouldCheckChangedPair(first, second) {
+    const layers = Array.from(this.dragRollbackState?.keys() ?? []).filter(
+      (layer) => layer instanceof L19.Polygon
+    );
+    return layers.indexOf(first) < layers.indexOf(second);
+  }
+  cloneLatLngStructure(value) {
+    if (!Array.isArray(value)) return value;
+    return value.map((item) => {
+      if (Array.isArray(item)) {
+        return this.cloneLatLngStructure(item);
+      }
+      if (item instanceof L19.LatLng || typeof item?.lat === "number") {
+        return L19.latLng(item.lat, item.lng);
+      }
+      return item;
+    });
+  }
+  changedSegmentsIntersect(points, changedSegments, isPolygon) {
+    if (points.length < (isPolygon ? 3 : 2)) return false;
+    const segmentCount = isPolygon ? points.length : points.length - 1;
+    if (segmentCount < 2) return false;
+    const projected = points.map((point5) => this.map.latLngToLayerPoint(point5));
+    for (const changedIndex of changedSegments) {
+      if (changedIndex < 0 || changedIndex >= segmentCount) continue;
+      const aIndex = changedIndex;
+      const bIndex = this.segmentEndIndex(changedIndex, points.length, isPolygon);
+      for (let otherIndex = 0; otherIndex < segmentCount; otherIndex++) {
+        if (otherIndex === changedIndex) continue;
+        const cIndex = otherIndex;
+        const dIndex = this.segmentEndIndex(otherIndex, points.length, isPolygon);
+        if (this.segmentsShareEndpoint(aIndex, bIndex, cIndex, dIndex)) continue;
+        if (segmentsIntersect(
+          projected[aIndex],
+          projected[bIndex],
+          projected[cIndex],
+          projected[dIndex]
+        )) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  segmentEndIndex(segmentIndex, pointCount, isPolygon) {
+    return isPolygon ? (segmentIndex + 1) % pointCount : segmentIndex + 1;
+  }
+  segmentsShareEndpoint(aStart, aEnd, bStart, bEnd) {
+    return aStart === bStart || aStart === bEnd || aEnd === bStart || aEnd === bEnd;
+  }
+  sameLatLng(a, b) {
+    return a.lat === b.lat && a.lng === b.lng;
+  }
+  setHandleMeta(marker2, meta) {
+    marker2._anvilHandleMeta = meta;
+  }
+  hitTestHandle(latlng) {
+    const mousePoint = this.map.latLngToContainerPoint(latlng);
+    let bestMatch = null;
+    let bestDistance = 12;
+    const considerMarker = (marker2, meta) => {
+      const point5 = this.map.latLngToContainerPoint(marker2.getLatLng());
+      const distance = point5.distanceTo(mousePoint);
+      if (distance >= bestDistance) return;
+      bestDistance = distance;
+      if (meta.kind === "ghost") {
+        bestMatch = { kind: "ghost", segment: meta.segment, marker: marker2 };
+        return;
+      }
+      if (meta.kind === "circle") {
+        bestMatch = { kind: "circle", circle: meta.circle, marker: marker2 };
+        return;
+      }
+      bestMatch = { kind: "vertex", group: meta.group, marker: marker2 };
+    };
+    this.markers.forEach((marker2) => {
+      const meta = marker2._anvilHandleMeta;
+      if (meta) considerMarker(marker2, meta);
+    });
+    if (this.ghostMarker) {
+      const segment = this.ghostMarker._activeSeg;
+      if (segment) considerMarker(this.ghostMarker, { kind: "ghost", segment });
+    }
+    return bestMatch;
+  }
+  createHandleRenderer() {
+    if (typeof document === "undefined") return void 0;
+    if (typeof navigator !== "undefined" && /jsdom|node\.js/i.test(navigator.userAgent)) return void 0;
+    try {
+      const canvas2 = document.createElement("canvas");
+      if (typeof canvas2.getContext === "function" && canvas2.getContext("2d")) {
+        return L19.canvas({ padding: 0.5, pane: this.handlePaneName });
+      }
+    } catch {
+      return void 0;
+    }
+    return L19.svg({ padding: 0.5, pane: this.handlePaneName });
+  }
+  ensureHandlePane() {
+    const existingPane = this.map.getPane(this.handlePaneName);
+    const pane = existingPane || this.map.createPane(this.handlePaneName);
+    pane.style.zIndex = "650";
+    pane.style.pointerEvents = "none";
+  }
+  stopLeafletEvent(e) {
+    L19.DomEvent.stopPropagation(e);
+    const originalEvent = e?.originalEvent;
+    if (originalEvent) {
+      L19.DomEvent.preventDefault(originalEvent);
+      L19.DomEvent.stopPropagation(originalEvent);
+    }
+  }
+  blurActiveElement() {
+    if (typeof document === "undefined") return;
+    const activeElement = document.activeElement;
+    activeElement?.blur?.();
+  }
+};
+__publicField(_EditMode, "OVERLAP_AREA_TOLERANCE", 1e-3);
+var EditMode = _EditMode;
+
+// src/modes/topology-mode.ts
+var TopologyMode = class extends EditMode {
+  constructor(map, store, options = {}) {
+    super(map, store, options, {
+      modeId: "topology" /* Topology */,
+      autoSelectAll: true,
+      allowLayerSelection: false,
+      clearSelectionOnMapClick: false,
+      defaultSelectionPathOptions: {
+        color: "#0891b2",
+        weight: 3,
+        opacity: 0.95
+      },
+      defaultHandleOptions: {
+        radius: 5,
+        color: "#0891b2",
+        fillColor: "#ecfeff",
+        fillOpacity: 1,
+        weight: 2
+      },
+      defaultGhostHandleOptions: {
+        radius: 4,
+        color: "#cffafe",
+        fillColor: "#0891b2",
+        fillOpacity: 0.9,
+        weight: 2
+      }
+    });
   }
 };
 
 // src/modes/delete-mode.ts
-var L19 = __toESM(require("leaflet"));
+var L20 = __toESM(require("leaflet"));
 var DeleteMode = class {
   constructor(map, store) {
     this.map = map;
@@ -2168,18 +3108,18 @@ var DeleteMode = class {
   }
   addLayerListener(layer) {
     layer.on("click", this.onClick, this);
-    if (layer instanceof L19.Path || layer instanceof L19.Marker) {
+    if (layer instanceof L20.Path || layer instanceof L20.Marker) {
       layer.getElement()?.style.setProperty("cursor", "pointer");
     }
   }
   removeLayerListener(layer) {
     layer.off("click", this.onClick, this);
-    if (layer instanceof L19.Path || layer instanceof L19.Marker) {
+    if (layer instanceof L20.Path || layer instanceof L20.Marker) {
       layer.getElement()?.style.setProperty("cursor", "");
     }
   }
   onClick(e) {
-    L19.DomEvent.stopPropagation(e);
+    L20.DomEvent.stopPropagation(e);
     const layer = e.target;
     this.map.removeLayer(layer);
     this.map.fire(ANVIL_EVENTS.DELETED, { layer });
@@ -2187,11 +3127,11 @@ var DeleteMode = class {
 };
 
 // src/layers/layer-store.ts
-var L20 = __toESM(require("leaflet"));
+var L21 = __toESM(require("leaflet"));
 var LayerStore = class {
   constructor(map, layerGroup) {
     __publicField(this, "group");
-    this.group = layerGroup || L20.featureGroup();
+    this.group = layerGroup || L21.featureGroup();
     this.group.addTo(map);
   }
   addLayer(layer) {
@@ -2212,29 +3152,31 @@ var LayerStore = class {
 };
 
 // src/controls/anvil-control.ts
-var L21 = __toESM(require("leaflet"));
+var L22 = __toESM(require("leaflet"));
 var import_lucide = require("lucide");
 var ANVIL_TOOLBAR_STYLE_ID = "anvil-toolbar-styles";
 var MODE_CONFIGS = [
-  { id: "marker" /* Marker */, title: "Marker", icon: import_lucide.MapPin },
-  { id: "polyline" /* Polyline */, title: "Line", icon: import_lucide.Waypoints },
-  { id: "polygon" /* Polygon */, title: "Polygon", icon: import_lucide.Pentagon },
-  { id: "rectangle" /* Rectangle */, title: "Rectangle", icon: import_lucide.RectangleHorizontal },
-  { id: "square" /* Square */, title: "Square", icon: import_lucide.Square },
-  { id: "triangle" /* Triangle */, title: "Triangle", icon: import_lucide.Triangle },
-  { id: "circle" /* Circle */, title: "Circle", icon: import_lucide.Circle },
-  { id: "freehand" /* Freehand */, title: "Freehand", icon: import_lucide.Hand },
-  { id: "cut" /* Cut */, title: "Cut", icon: import_lucide.Scissors },
-  { id: "split" /* Split */, title: "Split", icon: import_lucide.Split },
-  { id: "union" /* Union */, title: "Union", icon: import_lucide.SquaresUnite },
-  { id: "subtract" /* Subtract */, title: "Subtract", icon: import_lucide.SquaresSubtract },
-  { id: "drag" /* Drag */, title: "Drag", icon: import_lucide.Move },
-  { id: "scale" /* Scale */, title: "Scale", icon: import_lucide.Scaling },
-  { id: "rotate" /* Rotate */, title: "Rotate", icon: import_lucide.RotateCw },
-  { id: "edit" /* Edit */, title: "Edit", icon: import_lucide.SquarePen },
-  { id: "delete" /* Delete */, title: "Delete", icon: import_lucide.Trash2 },
-  { id: "off" /* Off */, title: "Turn Off", icon: import_lucide.Power }
+  { id: "marker" /* Marker */, defaultTooltip: "Marker", icon: import_lucide.MapPin },
+  { id: "polyline" /* Polyline */, defaultTooltip: "Line", icon: import_lucide.Waypoints },
+  { id: "polygon" /* Polygon */, defaultTooltip: "Polygon", icon: import_lucide.Pentagon },
+  { id: "rectangle" /* Rectangle */, defaultTooltip: "Rectangle", icon: import_lucide.RectangleHorizontal },
+  { id: "square" /* Square */, defaultTooltip: "Square", icon: import_lucide.Square },
+  { id: "triangle" /* Triangle */, defaultTooltip: "Triangle", icon: import_lucide.Triangle },
+  { id: "circle" /* Circle */, defaultTooltip: "Circle", icon: import_lucide.Circle },
+  { id: "freehand" /* Freehand */, defaultTooltip: "Freehand", icon: import_lucide.Hand },
+  { id: "cut" /* Cut */, defaultTooltip: "Cut", icon: import_lucide.Scissors },
+  { id: "split" /* Split */, defaultTooltip: "Split", icon: import_lucide.Split },
+  { id: "union" /* Union */, defaultTooltip: "Union", icon: import_lucide.SquaresUnite },
+  { id: "subtract" /* Subtract */, defaultTooltip: "Subtract", icon: import_lucide.SquaresSubtract },
+  { id: "drag" /* Drag */, defaultTooltip: "Drag", icon: import_lucide.Move },
+  { id: "scale" /* Scale */, defaultTooltip: "Scale", icon: import_lucide.Scaling },
+  { id: "rotate" /* Rotate */, defaultTooltip: "Rotate", icon: import_lucide.RotateCw },
+  { id: "edit" /* Edit */, defaultTooltip: "Edit", icon: import_lucide.SquarePen },
+  { id: "topology" /* Topology */, defaultTooltip: "Topology", icon: import_lucide.Network },
+  { id: "delete" /* Delete */, defaultTooltip: "Delete", icon: import_lucide.Trash2 },
+  { id: "off" /* Off */, defaultTooltip: "Turn Off", icon: import_lucide.Power }
 ];
+var MODE_CONFIGS_BY_ID = new Map(MODE_CONFIGS.map((config) => [config.id, config]));
 function ensureToolbarStyles() {
   if (typeof document === "undefined" || document.getElementById(ANVIL_TOOLBAR_STYLE_ID)) return;
   const style = document.createElement("style");
@@ -2304,9 +3246,15 @@ function buildIcon(iconNode) {
     focusable: "false"
   });
 }
-var AnvilControl = class extends L21.Control {
+function resolveModeTooltip(config, modeTooltips) {
+  if (typeof modeTooltips === "function") {
+    return modeTooltips(config.id, config.defaultTooltip) ?? config.defaultTooltip;
+  }
+  return modeTooltips?.[config.id] ?? config.defaultTooltip;
+}
+var AnvilControl = class extends L22.Control {
   constructor(anvil, options) {
-    super(L21.Util.extend({ position: "topleft" }, options));
+    super(L22.Util.extend({ position: "topleft" }, options));
     __publicField(this, "_btns", {});
     __publicField(this, "_anvil");
     __publicField(this, "_options");
@@ -2315,19 +3263,24 @@ var AnvilControl = class extends L21.Control {
   }
   onAdd(map) {
     ensureToolbarStyles();
-    const container = L21.DomUtil.create("div", "anvil-toolbar-container");
+    const container = L22.DomUtil.create("div", "anvil-toolbar-container");
     const modesInput = this._options.modes || MODE_CONFIGS.filter(({ id }) => id !== "off" /* Off */).map(({ id }) => id);
     const blocks = Array.isArray(modesInput[0]) ? modesInput : [modesInput];
     const createButton = (group, config) => {
-      const btn = L21.DomUtil.create("a", "anvil-control-btn", group);
+      const btn = L22.DomUtil.create("a", "anvil-control-btn", group);
       btn.href = "#";
-      btn.title = config.title;
       btn.setAttribute("role", "button");
-      btn.setAttribute("aria-label", config.title);
       btn.appendChild(buildIcon(config.icon));
-      L21.DomEvent.disableClickPropagation(btn);
-      L21.DomEvent.on(btn, "click", (e) => {
-        L21.DomEvent.preventDefault(e);
+      const syncTooltip = () => {
+        const tooltip = resolveModeTooltip(config, this._options.modeTooltips);
+        btn.title = tooltip;
+        btn.setAttribute("aria-label", tooltip);
+      };
+      syncTooltip();
+      L22.DomEvent.disableClickPropagation(btn);
+      L22.DomEvent.on(btn, "mouseover focus", syncTooltip);
+      L22.DomEvent.on(btn, "click", (e) => {
+        L22.DomEvent.preventDefault(e);
         if (config.id === "off" /* Off */) {
           this._anvil.disable();
         } else {
@@ -2337,14 +3290,14 @@ var AnvilControl = class extends L21.Control {
       this._btns[config.id] = btn;
     };
     blocks.forEach((block, index) => {
-      const group = L21.DomUtil.create("div", "leaflet-bar anvil-toolbar-group", container);
+      const group = L22.DomUtil.create("div", "leaflet-bar anvil-toolbar-group", container);
       block.forEach((modeId) => {
-        const config = MODE_CONFIGS.find(({ id }) => id === modeId);
+        const config = MODE_CONFIGS_BY_ID.get(modeId);
         if (!config) return;
         createButton(group, config);
       });
       if (index === blocks.length - 1 && !this._btns["off" /* Off */]) {
-        createButton(group, MODE_CONFIGS.find(({ id }) => id === "off" /* Off */));
+        createButton(group, MODE_CONFIGS_BY_ID.get("off" /* Off */));
       }
     });
     const updateFn = (mode) => {
@@ -2363,6 +3316,21 @@ function anvilControl(anvil, options) {
 }
 
 // src/anvil.ts
+var ANVIL_INTERACTION_STYLE_ID = "anvil-interaction-styles";
+function ensureInteractionStyles() {
+  if (typeof document === "undefined" || document.getElementById(ANVIL_INTERACTION_STYLE_ID)) return;
+  const style = document.createElement("style");
+  style.id = ANVIL_INTERACTION_STYLE_ID;
+  style.textContent = `
+        .leaflet-container .leaflet-pane .leaflet-interactive:focus,
+        .leaflet-container .leaflet-pane .leaflet-interactive:focus-visible,
+        .leaflet-container .leaflet-pane svg path:focus,
+        .leaflet-container .leaflet-pane svg path:focus-visible {
+            outline: none !important;
+        }
+    `;
+  document.head.appendChild(style);
+}
 var Anvil = class {
   constructor(map, options) {
     this.map = map;
@@ -2370,6 +3338,7 @@ var Anvil = class {
     __publicField(this, "store");
     __publicField(this, "options");
     __publicField(this, "control");
+    ensureInteractionStyles();
     this.options = {
       snapping: false,
       snapDistance: 10,
@@ -2429,6 +3398,9 @@ var Anvil = class {
     if (flattenedModes.includes("edit" /* Edit */)) {
       this.modeManager.addMode("edit" /* Edit */, new EditMode(this.map, this.store, this.options));
     }
+    if (flattenedModes.includes("topology" /* Topology */)) {
+      this.modeManager.addMode("topology" /* Topology */, new TopologyMode(this.map, this.store, this.options));
+    }
     if (flattenedModes.includes("delete" /* Delete */)) {
       this.modeManager.addMode("delete" /* Delete */, new DeleteMode(map, this.store));
     }
@@ -2440,7 +3412,8 @@ var Anvil = class {
     });
     this.control = anvilControl(this, {
       position: this.options.controlPosition,
-      modes: modesFromOptions
+      modes: modesFromOptions,
+      modeTooltips: this.options.modeTooltips
     });
     this.control?.addTo(this.map);
   }
@@ -2456,7 +3429,7 @@ var Anvil = class {
 };
 
 // src/index.ts
-var leaflet = L22;
+var leaflet = L23;
 leaflet.Anvil = Anvil;
 leaflet.anvil = (map, options) => new Anvil(map, options);
 if (leaflet.Control) {