leaflet-polydraw 0.8.5 → 0.8.8

package/dist/polydraw.es.js

@@ -16,6 +16,7 @@ const polygonOptions = { "smoothFactor": 0.3, "color": "#50622b", "fillColor": "
 const holeOptions = { "color": "#aa0000", "fillColor": "#ffcccc", "weight": 2, "opacity": 1, "fillOpacity": 0.5 };
 const polygonCreation = { "method": "concaveman", "simplification": { "mode": "simple", "tolerance": 1e-5, "highQuality": false } };
 const simplification = { "simplifyTolerance": { "tolerance": 1e-4, "highQuality": false, "mutate": false }, "dynamicMode": { "fractionGuard": 0.9, "multipiler": 2 } };
+const menuOperations = { "simplify": { "processHoles": true }, "doubleElbows": { "processHoles": true }, "bbox": { "processHoles": true } };
 const boundingBox = { "addMidPointMarkers": true };
 const bezier$1 = { "resolution": 1e4, "sharpness": 0.75 };
 const defaultConfig = {
@@ -32,6 +33,7 @@ const defaultConfig = {
   holeOptions,
   polygonCreation,
   simplification,
+  menuOperations,
   boundingBox,
   bezier: bezier$1
 };
@@ -17141,520 +17143,142 @@ class ModeManager {
     this.updateStateForMode(this.state.currentMode);
   }
 }
-class PolygonGeometryManager {
+class PolygonDrawManager {
   constructor(dependencies) {
     __publicField(this, "turfHelper");
+    __publicField(this, "map");
     __publicField(this, "config");
+    __publicField(this, "modeManager");
+    __publicField(this, "tracer");
+    __publicField(this, "eventListeners", /* @__PURE__ */ new Map());
+    // Point-to-Point drawing state
+    __publicField(this, "p2pMarkers", []);
+    __publicField(this, "isModifierKeyHeld", false);
     this.turfHelper = dependencies.turfHelper;
+    this.map = dependencies.map;
     this.config = dependencies.config;
+    this.modeManager = dependencies.modeManager;
+    this.tracer = dependencies.tracer;
   }
   /**
-   * Check if two polygons intersect using multiple detection methods
+   * Add event listener
    */
-  checkPolygonIntersection(polygon1, polygon2) {
-    try {
-      const poly1WithinPoly2 = this.turfHelper.isPolygonCompletelyWithin(polygon1, polygon2);
-      const poly2WithinPoly1 = this.turfHelper.isPolygonCompletelyWithin(polygon2, polygon1);
-      if (poly1WithinPoly2 || poly2WithinPoly1) {
-        return true;
-      }
-    } catch (error) {
-    }
-    try {
-      const result = this.turfHelper.polygonIntersect(polygon1, polygon2);
-      if (result) {
-        return true;
-      }
-    } catch (error) {
-    }
-    try {
-      const intersection3 = this.turfHelper.getIntersection(polygon1, polygon2);
-      if (intersection3 && intersection3.geometry && (intersection3.geometry.type === "Polygon" || intersection3.geometry.type === "MultiPolygon")) {
-        const intersectionArea2 = this.turfHelper.getPolygonArea(intersection3);
-        if (intersectionArea2 > 1e-6) {
-          return true;
-        }
-      }
-    } catch (error) {
-    }
-    try {
-      const coords1 = this.turfHelper.getCoords(polygon1);
-      const coords2 = this.turfHelper.getCoords(polygon2);
-      for (const ring2 of coords2) {
-        for (const coord of ring2[0]) {
-          const point2 = {
-            type: "Feature",
-            geometry: { type: "Point", coordinates: coord },
-            properties: {}
-          };
-          if (this.turfHelper.isPolygonCompletelyWithin(point2, polygon1)) {
-            return true;
-          }
-        }
-      }
-      for (const ring1 of coords1) {
-        for (const coord of ring1[0]) {
-          const point2 = {
-            type: "Feature",
-            geometry: { type: "Point", coordinates: coord },
-            properties: {}
-          };
-          if (this.turfHelper.isPolygonCompletelyWithin(point2, polygon2)) {
-            return true;
-          }
-        }
-      }
-    } catch (error) {
+  on(event, callback) {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, []);
     }
-    return false;
+    this.eventListeners.get(event).push(callback);
   }
   /**
-   * Perform union operation on multiple polygons
+   * Emit event to all listeners
    */
-  unionPolygons(polygons, newPolygon) {
-    try {
-      let result = newPolygon;
-      for (const polygon2 of polygons) {
-        const shouldCreateDonut = this.shouldCreateDonutPolygon(result, polygon2);
-        if (shouldCreateDonut) {
-          const donutPolygon = this.createDonutPolygon(result, polygon2);
-          if (donutPolygon) {
-            result = donutPolygon;
-          } else {
-            const union3 = this.turfHelper.union(result, polygon2);
-            result = union3;
-          }
-        } else {
-          const union3 = this.turfHelper.union(result, polygon2);
-          result = union3;
-        }
-      }
-      return {
-        success: true,
-        result
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error in unionPolygons"
-      };
+  emit(event, data) {
+    const listeners = this.eventListeners.get(event);
+    if (listeners) {
+      listeners.forEach((callback) => callback(data));
     }
   }
   /**
-   * Perform subtraction operation
+   * Handle mouse move during freehand drawing
    */
-  subtractPolygon(existingPolygon, subtractPolygon) {
-    try {
-      const result = this.turfHelper.polygonDifference(existingPolygon, subtractPolygon);
-      if (result) {
-        const coords = this.turfHelper.getCoords(result);
-        const results = [];
-        for (const value of coords) {
-          results.push(this.turfHelper.getMultiPolygon([value]));
-        }
-        return {
-          success: true,
-          results
-        };
-      } else {
-        return {
-          success: true,
-          results: []
-        };
-      }
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error in subtractPolygon"
-      };
+  mouseMove(event) {
+    if ("latlng" in event && event.latlng) {
+      this.tracer.addLatLng(event.latlng);
+    } else if ("touches" in event && event.touches && event.touches.length > 0) {
+      const latlng = this.map.containerPointToLatLng([
+        event.touches[0].clientX,
+        event.touches[0].clientY
+      ]);
+      this.tracer.addLatLng(latlng);
     }
   }
   /**
-   * Simplify a polygon by removing every other point
+   * Handle mouse up/leave to complete freehand drawing
    */
-  simplifyPolygon(polygon2) {
-    try {
-      const coords = this.turfHelper.getCoords(polygon2);
-      if (!coords || coords.length === 0) {
-        return { success: false, error: "Invalid polygon coordinates" };
-      }
-      const simplifiedCoords = coords.map((ring) => {
-        const outerRing = ring[0];
-        if (outerRing.length <= 4) {
-          return ring;
-        }
-        const simplified = [];
-        for (let i = 0; i < outerRing.length; i += 2) {
-          simplified.push(outerRing[i]);
-        }
-        const firstPoint = simplified[0];
-        const lastPoint = simplified[simplified.length - 1];
-        if (firstPoint[0] !== lastPoint[0] || firstPoint[1] !== lastPoint[1]) {
-          simplified.push(firstPoint);
-        }
-        if (simplified.length < 4) {
-          return ring;
-        }
-        return [simplified, ...ring.slice(1)];
-      });
-      const result = this.turfHelper.getMultiPolygon(simplifiedCoords);
-      return {
-        success: true,
-        result: this.turfHelper.getTurfPolygon(result)
-      };
-    } catch (error) {
+  async mouseUpLeave(event) {
+    const tracerGeoJSON = this.tracer.toGeoJSON();
+    if (!tracerGeoJSON || !tracerGeoJSON.geometry || !tracerGeoJSON.geometry.coordinates || tracerGeoJSON.geometry.coordinates.length < 3) {
       return {
         success: false,
-        error: error instanceof Error ? error.message : "Unknown error in simplifyPolygon"
+        error: "Not enough points to form a valid polygon"
       };
     }
-  }
-  /**
-   * Convert polygon to bounding box
-   */
-  convertToBoundingBox(polygon2) {
+    let geoPos;
     try {
-      const result = this.turfHelper.convertToBoundingBoxPolygon(polygon2);
-      return {
-        success: true,
-        result: this.turfHelper.getTurfPolygon(result)
-      };
+      geoPos = this.turfHelper.createPolygonFromTrace(tracerGeoJSON);
     } catch (error) {
       return {
         success: false,
-        error: error instanceof Error ? error.message : "Unknown error in convertToBoundingBox"
+        error: error instanceof Error ? error.message : "Failed to create polygon from trace"
       };
     }
-  }
-  /**
-   * Apply bezier curve to polygon
-   */
-  bezierifyPolygon(polygon2) {
-    try {
-      const coords = this.turfHelper.getCoords(polygon2);
-      const result = this.turfHelper.getBezierMultiPolygon(coords);
-      return {
-        success: true,
-        result: this.turfHelper.getTurfPolygon(result)
-      };
-    } catch (error) {
+    if (!geoPos || !geoPos.geometry || !geoPos.geometry.coordinates || geoPos.geometry.coordinates.length === 0) {
       return {
         success: false,
-        error: error instanceof Error ? error.message : "Unknown error in bezierifyPolygon"
+        error: "Invalid polygon created from trace"
       };
     }
+    this.emit("drawCompleted", {
+      polygon: geoPos,
+      mode: this.modeManager.getCurrentMode()
+    });
+    return {
+      success: true,
+      polygon: geoPos
+    };
   }
   /**
-   * Double the elbows of a polygon
+   * Handle point-to-point click
    */
-  doubleElbowsPolygon(latlngs) {
-    try {
-      const doubleLatLngs = this.turfHelper.getDoubleElbowLatLngs(latlngs);
-      const coords = [
-        [doubleLatLngs.map((latlng) => [latlng.lng, latlng.lat])]
-      ];
-      const result = this.turfHelper.getMultiPolygon(coords);
-      return {
-        success: true,
-        result: this.turfHelper.getTurfPolygon(result)
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error in doubleElbowsPolygon"
-      };
-    }
+  /**
+   * Set the modifier key status
+   * @param isHeld - Whether the modifier key is held down
+   */
+  setModifierKey(isHeld) {
+    this.isModifierKeyHeld = isHeld;
   }
   /**
-   * Helper method to get polygon center
+   * Handle point-to-point click
    */
-  getPolygonCenter(polygon2) {
-    try {
-      if (!polygon2 || !polygon2.geometry || !polygon2.geometry.coordinates) {
-        return null;
-      }
-      let coordinates;
-      if (polygon2.geometry.type === "Polygon") {
-        coordinates = polygon2.geometry.coordinates[0];
-      } else if (polygon2.geometry.type === "MultiPolygon") {
-        coordinates = polygon2.geometry.coordinates[0][0];
-      } else {
-        return null;
-      }
-      if (!Array.isArray(coordinates) || coordinates.length === 0) {
-        return null;
+  handlePointToPointClick(clickLatLng) {
+    if (!clickLatLng) {
+      return;
+    }
+    if (this.p2pMarkers.length >= 3) {
+      const firstPoint = this.p2pMarkers[0].getLatLng();
+      const isClickingFirst = this.isClickingFirstPoint(clickLatLng, firstPoint);
+      if (isClickingFirst) {
+        this.completePointToPointPolygon();
+        return;
       }
-      let latSum = 0;
-      let lngSum = 0;
-      let count = 0;
-      for (const coord of coordinates) {
-        if (Array.isArray(coord) && coord.length >= 2) {
-          const lng = coord[0];
-          const lat = coord[1];
-          if (typeof lng === "number" && typeof lat === "number" && !isNaN(lng) && !isNaN(lat)) {
-            lngSum += lng;
-            latSum += lat;
-            count++;
-          }
-        }
-      }
-      if (count === 0) {
-        return null;
-      }
-      return {
-        lat: latSum / count,
-        lng: lngSum / count
-      };
-    } catch (error) {
-      return null;
-    }
-  }
-  /**
-   * Helper method to get bounding box from polygon
-   */
-  getBoundingBox(polygon2) {
-    try {
-      if (!polygon2 || !polygon2.geometry || !polygon2.geometry.coordinates) {
-        return null;
-      }
-      let coordinates;
-      if (polygon2.geometry.type === "Polygon") {
-        coordinates = polygon2.geometry.coordinates[0];
-      } else if (polygon2.geometry.type === "MultiPolygon") {
-        coordinates = polygon2.geometry.coordinates[0][0];
-      } else {
-        return null;
-      }
-      if (!Array.isArray(coordinates) || coordinates.length === 0) {
-        return null;
-      }
-      let minLat = Infinity;
-      let maxLat = -Infinity;
-      let minLng = Infinity;
-      let maxLng = -Infinity;
-      for (const coord of coordinates) {
-        if (Array.isArray(coord) && coord.length >= 2) {
-          const lng = coord[0];
-          const lat = coord[1];
-          if (typeof lng === "number" && typeof lat === "number" && !isNaN(lng) && !isNaN(lat)) {
-            minLng = Math.min(minLng, lng);
-            maxLng = Math.max(maxLng, lng);
-            minLat = Math.min(minLat, lat);
-            maxLat = Math.max(maxLat, lat);
-          }
-        }
-      }
-      if (minLat === Infinity || maxLat === -Infinity || minLng === Infinity || maxLng === -Infinity) {
-        return null;
-      }
-      return { minLat, maxLat, minLng, maxLng };
-    } catch (error) {
-      return null;
-    }
-  }
-  /**
-   * Determine if two polygons should create a donut instead of a regular union
-   */
-  shouldCreateDonutPolygon(polygon1, polygon2) {
-    try {
-      return false;
-    } catch (error) {
-      console.warn("Error in shouldCreateDonutPolygon:", error.message);
-      return false;
-    }
-  }
-  /**
-   * Create a donut polygon from two intersecting polygons
-   */
-  createDonutPolygon(polygon1, polygon2) {
-    try {
-      const area1 = this.turfHelper.getPolygonArea(polygon1);
-      const area2 = this.turfHelper.getPolygonArea(polygon2);
-      let outerPolygon;
-      let innerPolygon;
-      if (area1 > area2) {
-        outerPolygon = polygon1;
-        innerPolygon = polygon2;
-      } else {
-        outerPolygon = polygon2;
-        innerPolygon = polygon1;
-      }
-      const innerWithinOuter = this.turfHelper.isPolygonCompletelyWithin(
-        innerPolygon,
-        outerPolygon
-      );
-      if (innerWithinOuter) {
-        return this.createDonutFromContainment(outerPolygon, innerPolygon);
-      } else {
-        return this.createDonutFromIntersection(outerPolygon, innerPolygon);
-      }
-    } catch (error) {
-      console.warn("Error in createDonutPolygon:", error.message);
-      return null;
-    }
-  }
-  /**
-   * Create donut when one polygon is completely within another
-   */
-  createDonutFromContainment(outerPolygon, innerPolygon) {
-    try {
-      const outerCoords = this.turfHelper.getCoords(outerPolygon);
-      const innerCoords = this.turfHelper.getCoords(innerPolygon);
-      const donutCoords = [
-        outerCoords[0][0],
-        // Outer ring
-        innerCoords[0][0]
-        // Inner ring as hole
-      ];
-      return {
-        type: "Feature",
-        geometry: {
-          type: "Polygon",
-          coordinates: donutCoords
-        },
-        properties: {}
-      };
-    } catch (error) {
-      console.warn("Error in createDonutFromContainment:", error.message);
-      return null;
-    }
-  }
-  /**
-   * Create donut from intersecting polygons (C-to-O scenario)
-   */
-  createDonutFromIntersection(polygon1, polygon2) {
-    try {
-      const union3 = this.turfHelper.union(polygon1, polygon2);
-      if (!union3) {
-        return null;
-      }
-      const intersection3 = this.turfHelper.getIntersection(polygon1, polygon2);
-      if (!intersection3) {
-        return union3;
-      }
-      const donut = this.turfHelper.polygonDifference(union3, intersection3);
-      return donut;
-    } catch (error) {
-      console.warn("Error in createDonutFromIntersection:", error.message);
-      return null;
-    }
-  }
-}
-class PolygonDrawManager {
-  constructor(dependencies) {
-    __publicField(this, "turfHelper");
-    __publicField(this, "map");
-    __publicField(this, "config");
-    __publicField(this, "modeManager");
-    __publicField(this, "tracer");
-    __publicField(this, "eventListeners", /* @__PURE__ */ new Map());
-    // Point-to-Point drawing state
-    __publicField(this, "p2pMarkers", []);
-    this.turfHelper = dependencies.turfHelper;
-    this.map = dependencies.map;
-    this.config = dependencies.config;
-    this.modeManager = dependencies.modeManager;
-    this.tracer = dependencies.tracer;
-  }
-  /**
-   * Add event listener
-   */
-  on(event, callback) {
-    if (!this.eventListeners.has(event)) {
-      this.eventListeners.set(event, []);
-    }
-    this.eventListeners.get(event).push(callback);
-  }
-  /**
-   * Emit event to all listeners
-   */
-  emit(event, data) {
-    const listeners = this.eventListeners.get(event);
-    if (listeners) {
-      listeners.forEach((callback) => callback(data));
-    }
-  }
-  /**
-   * Handle mouse move during freehand drawing
-   */
-  mouseMove(event) {
-    if ("latlng" in event && event.latlng) {
-      this.tracer.addLatLng(event.latlng);
-    } else if ("touches" in event && event.touches && event.touches.length > 0) {
-      const latlng = this.map.containerPointToLatLng([
-        event.touches[0].clientX,
-        event.touches[0].clientY
-      ]);
-      this.tracer.addLatLng(latlng);
     }
-  }
-  /**
-   * Handle mouse up/leave to complete freehand drawing
-   */
-  async mouseUpLeave(event) {
-    const tracerGeoJSON = this.tracer.toGeoJSON();
-    if (!tracerGeoJSON || !tracerGeoJSON.geometry || !tracerGeoJSON.geometry.coordinates || tracerGeoJSON.geometry.coordinates.length < 3) {
-      return {
-        success: false,
-        error: "Not enough points to form a valid polygon"
-      };
-    }
-    let geoPos;
-    try {
-      geoPos = this.turfHelper.createPolygonFromTrace(tracerGeoJSON);
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Failed to create polygon from trace"
-      };
-    }
-    if (!geoPos || !geoPos.geometry || !geoPos.geometry.coordinates || geoPos.geometry.coordinates.length === 0) {
-      return {
-        success: false,
-        error: "Invalid polygon created from trace"
-      };
-    }
-    this.emit("drawCompleted", {
-      polygon: geoPos,
-      mode: this.modeManager.getCurrentMode()
-    });
-    return {
-      success: true,
-      polygon: geoPos
-    };
-  }
-  /**
-   * Handle point-to-point click
-   */
-  handlePointToPointClick(clickLatLng) {
-    if (!clickLatLng) {
-      return;
-    }
-    const currentPoints = this.tracer.getLatLngs();
-    if (currentPoints.length >= 3 && this.p2pMarkers.length > 0) {
-      const firstPoint = this.p2pMarkers[0].getLatLng();
-      const isClickingFirst = this.isClickingFirstPoint(clickLatLng, firstPoint);
-      if (isClickingFirst) {
-        this.completePointToPointPolygon();
-        return;
-      }
-    }
-    this.tracer.addLatLng(clickLatLng);
     try {
       const isFirstMarker = this.p2pMarkers.length === 0;
       const markerClassName = isFirstMarker ? "leaflet-polydraw-p2p-marker leaflet-polydraw-p2p-first-marker" : "leaflet-polydraw-p2p-marker";
       const pointMarker = new L.Marker(clickLatLng, {
         icon: L.divIcon({
           className: markerClassName,
-          iconSize: isFirstMarker ? [20, 20] : [10, 10]
-        })
+          iconSize: isFirstMarker ? [20, 20] : [16, 16]
+        }),
+        draggable: this.config.modes.dragElbow
       }).addTo(this.map);
       pointMarker.on("mousedown", (e) => {
         L.DomEvent.stopPropagation(e);
       });
+      pointMarker.on("drag", () => {
+        this.updateP2PTracer();
+      });
+      pointMarker.on("click", (e) => {
+        if (this.isModifierKeyHeld && this.config.modes.edgeDeletion) {
+          this.deleteP2PMarker(pointMarker);
+          L.DomEvent.stopPropagation(e);
+        }
+      });
+      pointMarker.on("mouseover", () => this.onMarkerHoverForEdgeDeletion(pointMarker, true));
+      pointMarker.on("mouseout", () => this.onMarkerHoverForEdgeDeletion(pointMarker, false));
       if (isFirstMarker) {
         pointMarker.on("mouseover", () => {
-          if (this.tracer.getLatLngs().length >= 3) {
+          if (this.p2pMarkers.length >= 3) {
             const element = pointMarker.getElement();
             if (element) {
               element.style.backgroundColor = "#4CAF50";
@@ -17674,24 +17298,21 @@ class PolygonDrawManager {
           }
         });
         pointMarker.on("click", (e) => {
-          if (this.tracer.getLatLngs().length >= 3) {
+          if (this.isModifierKeyHeld && this.config.modes.edgeDeletion) {
+            this.deleteP2PMarker(pointMarker);
+            L.DomEvent.stopPropagation(e);
+            return;
+          }
+          if (this.p2pMarkers.length >= 3) {
             L.DomEvent.stopPropagation(e);
             this.completePointToPointPolygon();
           }
         });
       }
       this.p2pMarkers.push(pointMarker);
+      this.updateP2PTracer();
     } catch (error) {
     }
-    if (this.tracer.getLatLngs().length >= 2) {
-      try {
-        this.tracer.setStyle({
-          color: this.config.polyLineOptions.color,
-          dashArray: "5, 5"
-        });
-      } catch (error) {
-      }
-    }
   }
   /**
    * Handle double-click to complete point-to-point polygon
@@ -17700,8 +17321,7 @@ class PolygonDrawManager {
     if (this.modeManager.getCurrentMode() !== DrawMode.PointToPoint) {
       return;
     }
-    const currentPoints = this.tracer.getLatLngs();
-    if (currentPoints.length >= 3) {
+    if (this.p2pMarkers.length >= 3) {
       this.completePointToPointPolygon();
     }
   }
@@ -17709,7 +17329,7 @@ class PolygonDrawManager {
    * Complete point-to-point polygon drawing
    */
   completePointToPointPolygon() {
-    const points = this.tracer.getLatLngs();
+    const points = this.p2pMarkers.map((marker) => marker.getLatLng());
     if (points.length < 3) {
       return;
     }
@@ -17755,6 +17375,12 @@ class PolygonDrawManager {
    */
   resetTracer() {
     this.tracer.setLatLngs([]);
+    try {
+      this.tracer.setStyle({
+        dashArray: null
+      });
+    } catch (error) {
+    }
   }
   /**
    * Check if clicking on the first point to close polygon
@@ -17769,6 +17395,43 @@ class PolygonDrawManager {
     const isClicking = latDiff < tolerance && lngDiff < tolerance;
     return isClicking;
   }
+  /**
+   * Update the tracer polyline based on P2P markers
+   */
+  updateP2PTracer() {
+    const latlngs = this.p2pMarkers.map((marker) => marker.getLatLng());
+    this.tracer.setLatLngs(latlngs);
+    if (this.p2pMarkers.length >= 2) {
+      try {
+        this.tracer.setStyle({
+          color: this.config.polyLineOptions.color,
+          dashArray: "5, 5"
+        });
+      } catch (error) {
+      }
+    } else {
+      try {
+        this.tracer.setStyle({
+          dashArray: null
+        });
+      } catch (error) {
+      }
+    }
+  }
+  /**
+   * Delete a P2P marker
+   */
+  deleteP2PMarker(markerToDelete) {
+    const markerIndex = this.p2pMarkers.findIndex((marker) => marker === markerToDelete);
+    if (markerIndex > -1) {
+      this.p2pMarkers.splice(markerIndex, 1);
+      this.map.removeLayer(markerToDelete);
+      this.updateP2PTracer();
+      if (markerIndex === 0 && this.p2pMarkers.length > 0) {
+        this.setupFirstMarker();
+      }
+    }
+  }
   /**
    * Get current P2P markers (for external access)
    */
@@ -17776,17 +17439,597 @@ class PolygonDrawManager {
     return [...this.p2pMarkers];
   }
   /**
-   * Check if currently in point-to-point drawing mode
+   * Check if currently in point-to-point drawing mode
+   */
+  isInPointToPointMode() {
+    return this.modeManager.getCurrentMode() === DrawMode.PointToPoint;
+  }
+  /**
+   * Get current tracer points count
+   */
+  getTracerPointsCount() {
+    const points = this.tracer.getLatLngs();
+    return points.length;
+  }
+  /**
+   * Set up the first marker with special properties
+   */
+  setupFirstMarker() {
+    if (this.p2pMarkers.length === 0) return;
+    const firstMarker = this.p2pMarkers[0];
+    const element = firstMarker.getElement();
+    if (element) {
+      element.classList.add("leaflet-polydraw-p2p-first-marker");
+      firstMarker.setIcon(
+        L.divIcon({
+          className: "leaflet-polydraw-p2p-marker leaflet-polydraw-p2p-first-marker",
+          iconSize: [20, 20]
+        })
+      );
+    }
+    firstMarker.off("mouseover");
+    firstMarker.off("mouseout");
+    firstMarker.off("click");
+    firstMarker.on("mouseover", () => {
+      if (this.p2pMarkers.length >= 3) {
+        const element2 = firstMarker.getElement();
+        if (element2) {
+          element2.style.backgroundColor = "#4CAF50";
+          element2.style.borderColor = "#4CAF50";
+          element2.style.cursor = "pointer";
+          element2.title = "Click to close polygon";
+        }
+      }
+    });
+    firstMarker.on("mouseout", () => {
+      const element2 = firstMarker.getElement();
+      if (element2) {
+        element2.style.backgroundColor = "";
+        element2.style.borderColor = "";
+        element2.style.cursor = "";
+        element2.title = "";
+      }
+    });
+    firstMarker.on("click", (e) => {
+      if (this.isModifierKeyHeld && this.config.modes.edgeDeletion) {
+        this.deleteP2PMarker(firstMarker);
+        L.DomEvent.stopPropagation(e);
+        return;
+      }
+      if (this.p2pMarkers.length >= 3) {
+        L.DomEvent.stopPropagation(e);
+        this.completePointToPointPolygon();
+      }
+    });
+  }
+  /**
+   * Handle marker hover for edge deletion feedback
+   */
+  onMarkerHoverForEdgeDeletion(marker, isHovering) {
+    const element = marker.getElement();
+    if (!element) return;
+    if (isHovering) {
+      const checkModifierAndUpdate = (e) => {
+        if (this.isModifierKeyHeld && this.config.modes.edgeDeletion) {
+          element.classList.add("edge-deletion-hover");
+          try {
+            const container = this.map.getContainer();
+            container.style.cursor = "pointer";
+          } catch (error) {
+          }
+        } else {
+          element.classList.remove("edge-deletion-hover");
+          try {
+            const container = this.map.getContainer();
+            container.style.cursor = "";
+          } catch (error) {
+          }
+        }
+      };
+      marker._polydrawModifierHandler = checkModifierAndUpdate;
+      document.addEventListener("keydown", checkModifierAndUpdate);
+      document.addEventListener("keyup", checkModifierAndUpdate);
+      element.addEventListener("mousemove", checkModifierAndUpdate);
+    } else {
+      element.classList.remove("edge-deletion-hover");
+      try {
+        const container = this.map.getContainer();
+        container.style.cursor = "";
+      } catch (error) {
+      }
+      const handler = marker._polydrawModifierHandler;
+      if (handler) {
+        document.removeEventListener("keydown", handler);
+        document.removeEventListener("keyup", handler);
+        element.removeEventListener("mousemove", handler);
+        delete marker._polydrawModifierHandler;
+      }
+    }
+  }
+}
+class PolygonGeometryManager {
+  constructor(dependencies) {
+    __publicField(this, "turfHelper");
+    __publicField(this, "config");
+    this.turfHelper = dependencies.turfHelper;
+    this.config = dependencies.config;
+  }
+  /**
+   * Check if two polygons intersect using multiple detection methods
+   */
+  checkPolygonIntersection(polygon1, polygon2) {
+    try {
+      const poly1WithinPoly2 = this.turfHelper.isPolygonCompletelyWithin(polygon1, polygon2);
+      const poly2WithinPoly1 = this.turfHelper.isPolygonCompletelyWithin(polygon2, polygon1);
+      if (poly1WithinPoly2 || poly2WithinPoly1) {
+        return true;
+      }
+    } catch (error) {
+    }
+    try {
+      const result = this.turfHelper.polygonIntersect(polygon1, polygon2);
+      if (result) {
+        return true;
+      }
+    } catch (error) {
+    }
+    try {
+      const intersection3 = this.turfHelper.getIntersection(polygon1, polygon2);
+      if (intersection3 && intersection3.geometry && (intersection3.geometry.type === "Polygon" || intersection3.geometry.type === "MultiPolygon")) {
+        const intersectionArea2 = this.turfHelper.getPolygonArea(intersection3);
+        if (intersectionArea2 > 1e-6) {
+          return true;
+        }
+      }
+    } catch (error) {
+    }
+    try {
+      const coords1 = this.turfHelper.getCoords(polygon1);
+      const coords2 = this.turfHelper.getCoords(polygon2);
+      for (const ring2 of coords2) {
+        for (const coord of ring2[0]) {
+          const point2 = {
+            type: "Feature",
+            geometry: { type: "Point", coordinates: coord },
+            properties: {}
+          };
+          if (this.turfHelper.isPolygonCompletelyWithin(point2, polygon1)) {
+            return true;
+          }
+        }
+      }
+      for (const ring1 of coords1) {
+        for (const coord of ring1[0]) {
+          const point2 = {
+            type: "Feature",
+            geometry: { type: "Point", coordinates: coord },
+            properties: {}
+          };
+          if (this.turfHelper.isPolygonCompletelyWithin(point2, polygon2)) {
+            return true;
+          }
+        }
+      }
+    } catch (error) {
+    }
+    return false;
+  }
+  /**
+   * Perform union operation on multiple polygons
+   */
+  unionPolygons(polygons, newPolygon) {
+    try {
+      let result = newPolygon;
+      for (const polygon2 of polygons) {
+        const shouldCreateDonut = this.shouldCreateDonutPolygon(result, polygon2);
+        if (shouldCreateDonut) {
+          const donutPolygon = this.createDonutPolygon(result, polygon2);
+          if (donutPolygon) {
+            result = donutPolygon;
+          } else {
+            const union3 = this.turfHelper.union(result, polygon2);
+            result = union3;
+          }
+        } else {
+          const union3 = this.turfHelper.union(result, polygon2);
+          result = union3;
+        }
+      }
+      return {
+        success: true,
+        result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error in unionPolygons"
+      };
+    }
+  }
+  /**
+   * Perform subtraction operation
+   */
+  subtractPolygon(existingPolygon, subtractPolygon) {
+    try {
+      const result = this.turfHelper.polygonDifference(existingPolygon, subtractPolygon);
+      if (result) {
+        const coords = this.turfHelper.getCoords(result);
+        const results = [];
+        for (const value of coords) {
+          results.push(this.turfHelper.getMultiPolygon([value]));
+        }
+        return {
+          success: true,
+          results
+        };
+      } else {
+        return {
+          success: true,
+          results: []
+        };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error in subtractPolygon"
+      };
+    }
+  }
+  /**
+   * Simplify a polygon by removing every other point
+   */
+  simplifyPolygon(polygon2) {
+    var _a2, _b2;
+    try {
+      const coords = this.turfHelper.getCoords(polygon2);
+      if (!coords || coords.length === 0) {
+        return { success: false, error: "Invalid polygon coordinates" };
+      }
+      const processHoles = ((_b2 = (_a2 = this.config.menuOperations) == null ? void 0 : _a2.simplify) == null ? void 0 : _b2.processHoles) ?? true;
+      const simplifiedCoords = coords.map((ring) => {
+        const simplifiedRings = [];
+        for (let ringIndex = 0; ringIndex < ring.length; ringIndex++) {
+          const currentRing = ring[ringIndex];
+          const isOuterRing = ringIndex === 0;
+          if (isOuterRing || processHoles) {
+            if (currentRing.length <= 4) {
+              simplifiedRings.push(currentRing);
+              continue;
+            }
+            const simplified = [];
+            for (let i = 0; i < currentRing.length; i += 2) {
+              simplified.push(currentRing[i]);
+            }
+            const firstPoint = simplified[0];
+            const lastPoint = simplified[simplified.length - 1];
+            if (firstPoint[0] !== lastPoint[0] || firstPoint[1] !== lastPoint[1]) {
+              simplified.push(firstPoint);
+            }
+            if (simplified.length < 4) {
+              simplifiedRings.push(currentRing);
+            } else {
+              simplifiedRings.push(simplified);
+            }
+          } else {
+            simplifiedRings.push(currentRing);
+          }
+        }
+        return simplifiedRings;
+      });
+      const result = this.turfHelper.getMultiPolygon(simplifiedCoords);
+      return {
+        success: true,
+        result: this.turfHelper.getTurfPolygon(result)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error in simplifyPolygon"
+      };
+    }
+  }
+  /**
+   * Convert polygon to bounding box
+   */
+  convertToBoundingBox(polygon2) {
+    var _a2, _b2;
+    try {
+      const coords = this.turfHelper.getCoords(polygon2);
+      if (!coords || coords.length === 0) {
+        return { success: false, error: "Invalid polygon coordinates" };
+      }
+      const processHoles = ((_b2 = (_a2 = this.config.menuOperations) == null ? void 0 : _a2.bbox) == null ? void 0 : _b2.processHoles) ?? true;
+      if (!processHoles) {
+        const result2 = this.turfHelper.convertToBoundingBoxPolygon(polygon2);
+        return {
+          success: true,
+          result: this.turfHelper.getTurfPolygon(result2)
+        };
+      }
+      const bboxCoords = coords.map((ring) => {
+        const bboxRings = [];
+        for (let ringIndex = 0; ringIndex < ring.length; ringIndex++) {
+          const currentRing = ring[ringIndex];
+          let minLat = Infinity;
+          let maxLat = -Infinity;
+          let minLng = Infinity;
+          let maxLng = -Infinity;
+          for (const coord of currentRing) {
+            if (Array.isArray(coord) && coord.length >= 2) {
+              const lng = coord[0];
+              const lat = coord[1];
+              if (typeof lng === "number" && typeof lat === "number" && !isNaN(lng) && !isNaN(lat)) {
+                minLng = Math.min(minLng, lng);
+                maxLng = Math.max(maxLng, lng);
+                minLat = Math.min(minLat, lat);
+                maxLat = Math.max(maxLat, lat);
+              }
+            }
+          }
+          if (minLat !== Infinity && maxLat !== -Infinity && minLng !== Infinity && maxLng !== -Infinity) {
+            const rectangularRing = [
+              [minLng, minLat],
+              // Bottom-left
+              [minLng, maxLat],
+              // Top-left
+              [maxLng, maxLat],
+              // Top-right
+              [maxLng, minLat],
+              // Bottom-right
+              [minLng, minLat]
+              // Close the ring
+            ];
+            bboxRings.push(rectangularRing);
+          } else {
+            bboxRings.push(currentRing);
+          }
+        }
+        return bboxRings;
+      });
+      const result = this.turfHelper.getMultiPolygon(bboxCoords);
+      return {
+        success: true,
+        result: this.turfHelper.getTurfPolygon(result)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error in convertToBoundingBox"
+      };
+    }
+  }
+  /**
+   * Apply bezier curve to polygon
+   */
+  bezierifyPolygon(polygon2) {
+    try {
+      const coords = this.turfHelper.getCoords(polygon2);
+      const result = this.turfHelper.getBezierMultiPolygon(coords);
+      return {
+        success: true,
+        result: this.turfHelper.getTurfPolygon(result)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error in bezierifyPolygon"
+      };
+    }
+  }
+  /**
+   * Double the elbows of a polygon
+   */
+  doubleElbowsPolygon(polygon2) {
+    var _a2, _b2;
+    try {
+      const coords = this.turfHelper.getCoords(polygon2);
+      if (!coords || coords.length === 0) {
+        return { success: false, error: "Invalid polygon coordinates" };
+      }
+      const processHoles = ((_b2 = (_a2 = this.config.menuOperations) == null ? void 0 : _a2.doubleElbows) == null ? void 0 : _b2.processHoles) ?? true;
+      const doubleElbowCoords = coords.map((ring) => {
+        const processedRings = [];
+        for (let ringIndex = 0; ringIndex < ring.length; ringIndex++) {
+          const currentRing = ring[ringIndex];
+          const isOuterRing = ringIndex === 0;
+          if (isOuterRing || processHoles) {
+            const latlngs = currentRing.map((coord) => ({ lat: coord[1], lng: coord[0] }));
+            const doubleLatLngs = this.turfHelper.getDoubleElbowLatLngs(latlngs);
+            const doubledCoords = doubleLatLngs.map(
+              (latlng) => [latlng.lng, latlng.lat]
+            );
+            processedRings.push(doubledCoords);
+          } else {
+            processedRings.push(currentRing);
+          }
+        }
+        return processedRings;
+      });
+      const result = this.turfHelper.getMultiPolygon(doubleElbowCoords);
+      return {
+        success: true,
+        result: this.turfHelper.getTurfPolygon(result)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error in doubleElbowsPolygon"
+      };
+    }
+  }
+  /**
+   * Helper method to get polygon center
+   */
+  getPolygonCenter(polygon2) {
+    try {
+      if (!polygon2 || !polygon2.geometry || !polygon2.geometry.coordinates) {
+        return null;
+      }
+      let coordinates;
+      if (polygon2.geometry.type === "Polygon") {
+        coordinates = polygon2.geometry.coordinates[0];
+      } else if (polygon2.geometry.type === "MultiPolygon") {
+        coordinates = polygon2.geometry.coordinates[0][0];
+      } else {
+        return null;
+      }
+      if (!Array.isArray(coordinates) || coordinates.length === 0) {
+        return null;
+      }
+      let latSum = 0;
+      let lngSum = 0;
+      let count = 0;
+      for (const coord of coordinates) {
+        if (Array.isArray(coord) && coord.length >= 2) {
+          const lng = coord[0];
+          const lat = coord[1];
+          if (typeof lng === "number" && typeof lat === "number" && !isNaN(lng) && !isNaN(lat)) {
+            lngSum += lng;
+            latSum += lat;
+            count++;
+          }
+        }
+      }
+      if (count === 0) {
+        return null;
+      }
+      return {
+        lat: latSum / count,
+        lng: lngSum / count
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+  /**
+   * Helper method to get bounding box from polygon
+   */
+  getBoundingBox(polygon2) {
+    try {
+      if (!polygon2 || !polygon2.geometry || !polygon2.geometry.coordinates) {
+        return null;
+      }
+      let coordinates;
+      if (polygon2.geometry.type === "Polygon") {
+        coordinates = polygon2.geometry.coordinates[0];
+      } else if (polygon2.geometry.type === "MultiPolygon") {
+        coordinates = polygon2.geometry.coordinates[0][0];
+      } else {
+        return null;
+      }
+      if (!Array.isArray(coordinates) || coordinates.length === 0) {
+        return null;
+      }
+      let minLat = Infinity;
+      let maxLat = -Infinity;
+      let minLng = Infinity;
+      let maxLng = -Infinity;
+      for (const coord of coordinates) {
+        if (Array.isArray(coord) && coord.length >= 2) {
+          const lng = coord[0];
+          const lat = coord[1];
+          if (typeof lng === "number" && typeof lat === "number" && !isNaN(lng) && !isNaN(lat)) {
+            minLng = Math.min(minLng, lng);
+            maxLng = Math.max(maxLng, lng);
+            minLat = Math.min(minLat, lat);
+            maxLat = Math.max(maxLat, lat);
+          }
+        }
+      }
+      if (minLat === Infinity || maxLat === -Infinity || minLng === Infinity || maxLng === -Infinity) {
+        return null;
+      }
+      return { minLat, maxLat, minLng, maxLng };
+    } catch (error) {
+      return null;
+    }
+  }
+  /**
+   * Determine if two polygons should create a donut instead of a regular union
+   */
+  shouldCreateDonutPolygon(polygon1, polygon2) {
+    try {
+      return false;
+    } catch (error) {
+      console.warn("Error in shouldCreateDonutPolygon:", error.message);
+      return false;
+    }
+  }
+  /**
+   * Create a donut polygon from two intersecting polygons
+   */
+  createDonutPolygon(polygon1, polygon2) {
+    try {
+      const area1 = this.turfHelper.getPolygonArea(polygon1);
+      const area2 = this.turfHelper.getPolygonArea(polygon2);
+      let outerPolygon;
+      let innerPolygon;
+      if (area1 > area2) {
+        outerPolygon = polygon1;
+        innerPolygon = polygon2;
+      } else {
+        outerPolygon = polygon2;
+        innerPolygon = polygon1;
+      }
+      const innerWithinOuter = this.turfHelper.isPolygonCompletelyWithin(
+        innerPolygon,
+        outerPolygon
+      );
+      if (innerWithinOuter) {
+        return this.createDonutFromContainment(outerPolygon, innerPolygon);
+      } else {
+        return this.createDonutFromIntersection(outerPolygon, innerPolygon);
+      }
+    } catch (error) {
+      console.warn("Error in createDonutPolygon:", error.message);
+      return null;
+    }
+  }
+  /**
+   * Create donut when one polygon is completely within another
    */
-  isInPointToPointMode() {
-    return this.modeManager.getCurrentMode() === DrawMode.PointToPoint;
+  createDonutFromContainment(outerPolygon, innerPolygon) {
+    try {
+      const outerCoords = this.turfHelper.getCoords(outerPolygon);
+      const innerCoords = this.turfHelper.getCoords(innerPolygon);
+      const donutCoords = [
+        outerCoords[0][0],
+        // Outer ring
+        innerCoords[0][0]
+        // Inner ring as hole
+      ];
+      return {
+        type: "Feature",
+        geometry: {
+          type: "Polygon",
+          coordinates: donutCoords
+        },
+        properties: {}
+      };
+    } catch (error) {
+      console.warn("Error in createDonutFromContainment:", error.message);
+      return null;
+    }
   }
   /**
-   * Get current tracer points count
+   * Create donut from intersecting polygons (C-to-O scenario)
    */
-  getTracerPointsCount() {
-    const points = this.tracer.getLatLngs();
-    return points.length;
+  createDonutFromIntersection(polygon1, polygon2) {
+    try {
+      const union3 = this.turfHelper.union(polygon1, polygon2);
+      if (!union3) {
+        return null;
+      }
+      const intersection3 = this.turfHelper.getIntersection(polygon1, polygon2);
+      if (!intersection3) {
+        return union3;
+      }
+      const donut = this.turfHelper.polygonDifference(union3, intersection3);
+      return donut;
+    } catch (error) {
+      console.warn("Error in createDonutFromIntersection:", error.message);
+      return null;
+    }
   }
 }
 class IconFactory {
@@ -19125,6 +19368,10 @@ class PolygonInteractionManager {
     const bezier2 = document.createElement("div");
     bezier2.classList.add("marker-menu-button", "bezier");
     bezier2.title = "Curve";
+    const alphaBanner = document.createElement("span");
+    alphaBanner.classList.add("alpha-banner");
+    alphaBanner.textContent = "ALPHA";
+    bezier2.appendChild(alphaBanner);
     const separator = document.createElement("div");
     separator.classList.add("separator");
     outerWrapper.appendChild(wrapper);
@@ -19361,39 +19608,24 @@ class PolygonMutationManager {
    */
   async handleMenuAction(data) {
     const { action, latLngs, featureGroup } = data;
+    const completePolygonGeoJSON = this.getCompletePolygonFromFeatureGroup(featureGroup);
     this.removeFeatureGroupInternal(featureGroup);
     let result;
     switch (action) {
       case "simplify": {
-        const coords = [
-          [latLngs.map((latlng) => [latlng.lng, latlng.lat])]
-        ];
-        const polygon2 = this.turfHelper.getMultiPolygon(coords);
-        result = this.geometryManager.simplifyPolygon(this.turfHelper.getTurfPolygon(polygon2));
+        result = this.geometryManager.simplifyPolygon(completePolygonGeoJSON);
         break;
       }
       case "bbox": {
-        const bboxCoords = [
-          [latLngs.map((latlng) => [latlng.lng, latlng.lat])]
-        ];
-        const bboxPolygon2 = this.turfHelper.getMultiPolygon(bboxCoords);
-        result = this.geometryManager.convertToBoundingBox(
-          this.turfHelper.getTurfPolygon(bboxPolygon2)
-        );
+        result = this.geometryManager.convertToBoundingBox(completePolygonGeoJSON);
         break;
       }
       case "doubleElbows": {
-        result = this.geometryManager.doubleElbowsPolygon(latLngs);
+        result = this.geometryManager.doubleElbowsPolygon(completePolygonGeoJSON);
         break;
       }
       case "bezier": {
-        const bezierCoords = [
-          [latLngs.map((latlng) => [latlng.lng, latlng.lat])]
-        ];
-        const bezierPolygon = this.turfHelper.getMultiPolygon(bezierCoords);
-        result = this.geometryManager.bezierifyPolygon(
-          this.turfHelper.getTurfPolygon(bezierPolygon)
-        );
+        result = this.geometryManager.bezierifyPolygon(completePolygonGeoJSON);
         break;
       }
       default:
@@ -19717,6 +19949,41 @@ class PolygonMutationManager {
     }
     this.map.removeLayer(featureGroup);
   }
+  /**
+   * Get complete polygon GeoJSON including holes from a feature group
+   */
+  getCompletePolygonFromFeatureGroup(featureGroup) {
+    try {
+      let polygon2 = null;
+      featureGroup.eachLayer((layer) => {
+        if (layer instanceof L.Polygon) {
+          polygon2 = layer;
+        }
+      });
+      if (!polygon2) {
+        throw new Error("No polygon found in feature group");
+      }
+      return polygon2.toGeoJSON();
+    } catch (error) {
+      console.warn("Error getting complete polygon GeoJSON from feature group:", error.message);
+      return {
+        type: "Feature",
+        geometry: {
+          type: "Polygon",
+          coordinates: [
+            [
+              [0, 0],
+              [0, 1],
+              [1, 1],
+              [1, 0],
+              [0, 0]
+            ]
+          ]
+        },
+        properties: {}
+      };
+    }
+  }
   // Public methods that delegate to interaction manager
   /**
    * Update marker draggable state
@@ -19971,9 +20238,9 @@ class Polydraw extends L.Control {
     __publicField(this, "mapStateService");
     __publicField(this, "polygonInformation");
     __publicField(this, "modeManager");
+    __publicField(this, "polygonDrawManager");
     __publicField(this, "polygonMutationManager");
     __publicField(this, "arrayOfFeatureGroups", []);
-    __publicField(this, "p2pMarkers", []);
     __publicField(this, "drawMode", DrawMode.Off);
     __publicField(this, "drawModeListeners", []);
     __publicField(this, "_boundKeyDownHandler");
@@ -20044,6 +20311,7 @@ class Polydraw extends L.Control {
     });
     this._boundKeyDownHandler = this.handleKeyDown.bind(this);
     this.polygonMutationManager = null;
+    this.polygonDrawManager = null;
   }
   onAdd(_map) {
     this.map = _map;
@@ -20151,6 +20419,13 @@ class Polydraw extends L.Control {
       this.tracer.addTo(this.map);
     } catch (error) {
     }
+    this.polygonDrawManager = new PolygonDrawManager({
+      turfHelper: this.turfHelper,
+      map: this.map,
+      config: this.config,
+      modeManager: this.modeManager,
+      tracer: this.tracer
+    });
     this.polygonMutationManager = new PolygonMutationManager({
       turfHelper: this.turfHelper,
       polygonInformation: this.polygonInformation,
@@ -20184,6 +20459,22 @@ class Polydraw extends L.Control {
     this.polygonMutationManager.on("polygonDeleted", () => {
       this.updateActivateButtonIndicator();
     });
+    this.polygonDrawManager.on("drawCompleted", async (data) => {
+      this.stopDraw();
+      if (data.isPointToPoint) {
+        await this.polygonMutationManager.addPolygon(data.polygon, {
+          simplify: false,
+          noMerge: false
+        });
+      } else {
+        await this.handleFreehandDrawCompletion(data.polygon);
+      }
+      this.polygonInformation.createPolygonInformationStorage(this.arrayOfFeatureGroups);
+    });
+    this.polygonDrawManager.on("drawCancelled", () => {
+      this.stopDraw();
+      this.setDrawMode(DrawMode.Off);
+    });
     return container;
   }
   addTo(map) {
@@ -20243,7 +20534,7 @@ class Polydraw extends L.Control {
     this.emitDrawModeChanged();
     this.updateMarkerDraggableState();
     if (previousMode === DrawMode.PointToPoint && mode !== DrawMode.PointToPoint) {
-      this.clearP2pMarkers();
+      this.polygonDrawManager.clearP2pMarkers();
       this.stopDraw();
     } else if (mode === DrawMode.Off) {
       this.stopDraw();
@@ -20363,14 +20654,22 @@ class Polydraw extends L.Control {
     this.map[onoroff]("mouseup", this.mouseUpLeave, this);
     if (onoff) {
       try {
-        this.map.getContainer().addEventListener("touchmove", (e) => this.mouseMove(e));
-        this.map.getContainer().addEventListener("touchend", (e) => this.mouseUpLeave(e));
+        this.map.getContainer().addEventListener("touchmove", (e) => this.mouseMove(e), {
+          passive: true
+        });
+        this.map.getContainer().addEventListener("touchend", (e) => this.mouseUpLeave(e), {
+          passive: true
+        });
       } catch (error) {
       }
     } else {
       try {
-        this.map.getContainer().removeEventListener("touchmove", (e) => this.mouseMove(e), true);
-        this.map.getContainer().removeEventListener("touchend", (e) => this.mouseUpLeave(e), true);
+        this.map.getContainer().removeEventListener("touchmove", (e) => this.mouseMove(e), {
+          passive: true
+        });
+        this.map.getContainer().removeEventListener("touchend", (e) => this.mouseUpLeave(e), {
+          passive: true
+        });
       } catch (error) {
       }
     }
@@ -20386,6 +20685,33 @@ class Polydraw extends L.Control {
       this.tracer.addLatLng(latlng);
     }
   }
+  async handleFreehandDrawCompletion(geoPos) {
+    try {
+      switch (this.modeManager.getCurrentMode()) {
+        case DrawMode.Add: {
+          const result = await this.polygonMutationManager.addPolygon(geoPos, {
+            simplify: true,
+            noMerge: false
+          });
+          if (!result.success) {
+            console.error("Error adding polygon via manager:", result.error);
+          }
+          break;
+        }
+        case DrawMode.Subtract: {
+          const subtractResult = await this.polygonMutationManager.subtractPolygon(geoPos);
+          if (!subtractResult.success) {
+            console.error("Error subtracting polygon via manager:", subtractResult.error);
+          }
+          break;
+        }
+        default:
+          break;
+      }
+    } catch (error) {
+      console.error("Error in mouseUpLeave polygon operation:", error);
+    }
+  }
   async mouseUpLeave(event) {
     this.polygonInformation.deletePolygonInformationStorage();
     const tracerGeoJSON = this.tracer.toGeoJSON();
@@ -20438,12 +20764,16 @@ class Polydraw extends L.Control {
     this.map[onoroff]("dblclick", this.handleDoubleClick, this);
     if (onoff) {
       try {
-        this.map.getContainer().addEventListener("touchstart", (e) => this.mouseDown(e));
+        this.map.getContainer().addEventListener("touchstart", (e) => this.mouseDown(e), {
+          passive: true
+        });
       } catch (error) {
       }
     } else {
       try {
-        this.map.getContainer().removeEventListener("touchstart", (e) => this.mouseDown(e), true);
+        this.map.getContainer().removeEventListener("touchstart", (e) => this.mouseDown(e), {
+          passive: true
+        });
       } catch (error) {
       }
     }
@@ -20465,7 +20795,7 @@ class Polydraw extends L.Control {
       return;
     }
     if (this.modeManager.getCurrentMode() === DrawMode.PointToPoint) {
-      this.handlePointToPointClick(clickLatLng);
+      this.polygonDrawManager.handlePointToPointClick(clickLatLng);
       return;
     }
     this.tracer.setLatLngs([clickLatLng]);
@@ -20486,12 +20816,13 @@ class Polydraw extends L.Control {
   handleKeyDown(e) {
     if (e.key === "Escape") {
       if (this.modeManager.getCurrentMode() === DrawMode.PointToPoint) {
-        this.cancelPointToPointDrawing();
+        this.polygonDrawManager.cancelPointToPointDrawing();
       }
     }
     const isModifierPressed = this.isModifierKeyPressed(e);
     if (isModifierPressed && !this.isModifierKeyHeld) {
       this.isModifierKeyHeld = true;
+      this.polygonDrawManager.setModifierKey(true);
       this.updateAllMarkersForEdgeDeletion(true);
     }
   }
@@ -20499,6 +20830,7 @@ class Polydraw extends L.Control {
     const isModifierPressed = this.isModifierKeyPressed(e);
     if (!isModifierPressed && this.isModifierKeyHeld) {
       this.isModifierKeyHeld = false;
+      this.polygonDrawManager.setModifierKey(false);
       this.updateAllMarkersForEdgeDeletion(false);
     }
   }
@@ -20530,125 +20862,11 @@ class Polydraw extends L.Control {
       element.style.borderColor = "";
     }
   }
-  cancelPointToPointDrawing() {
-    this.clearP2pMarkers();
-    this.stopDraw();
-    this.setDrawMode(DrawMode.Off);
-  }
-  // Point-to-Point state management
-  handlePointToPointClick(clickLatLng) {
-    if (!clickLatLng) {
-      return;
-    }
-    const currentPoints = this.tracer.getLatLngs();
-    if (currentPoints.length >= 3 && this.p2pMarkers.length > 0) {
-      const firstPoint = this.p2pMarkers[0].getLatLng();
-      const isClickingFirst = this.isClickingFirstPoint(clickLatLng, firstPoint);
-      if (isClickingFirst) {
-        this.completePointToPointPolygon();
-        return;
-      }
-    }
-    this.tracer.addLatLng(clickLatLng);
-    try {
-      const isFirstMarker = this.p2pMarkers.length === 0;
-      const markerClassName = isFirstMarker ? "leaflet-polydraw-p2p-marker leaflet-polydraw-p2p-first-marker" : "leaflet-polydraw-p2p-marker";
-      const pointMarker = new L.Marker(clickLatLng, {
-        icon: L.divIcon({
-          className: markerClassName,
-          iconSize: isFirstMarker ? [20, 20] : [10, 10]
-        })
-      }).addTo(this.map);
-      pointMarker.on("mousedown", (e) => {
-        L.DomEvent.stopPropagation(e);
-      });
-      if (isFirstMarker) {
-        pointMarker.on("mouseover", () => {
-          if (this.tracer.getLatLngs().length >= 3) {
-            const element = pointMarker.getElement();
-            if (element) {
-              element.style.backgroundColor = "#4CAF50";
-              element.style.borderColor = "#4CAF50";
-              element.style.cursor = "pointer";
-              element.title = "Click to close polygon";
-            }
-          }
-        });
-        pointMarker.on("mouseout", () => {
-          const element = pointMarker.getElement();
-          if (element) {
-            element.style.backgroundColor = "";
-            element.style.borderColor = "";
-            element.style.cursor = "";
-            element.title = "";
-          }
-        });
-        pointMarker.on("click", (e) => {
-          if (this.tracer.getLatLngs().length >= 3) {
-            L.DomEvent.stopPropagation(e);
-            this.completePointToPointPolygon();
-          }
-        });
-      }
-      this.p2pMarkers.push(pointMarker);
-    } catch (error) {
-    }
-    if (this.tracer.getLatLngs().length >= 2) {
-      try {
-        this.tracer.setStyle({
-          color: defaultConfig.polyLineOptions.color,
-          dashArray: "5, 5"
-        });
-      } catch (error) {
-      }
-    }
-  }
-  isClickingFirstPoint(clickLatLng, firstPoint) {
-    if (!firstPoint) return false;
-    const zoom = this.map.getZoom();
-    const baseTolerance = 5e-4;
-    const tolerance = baseTolerance / Math.pow(2, Math.max(0, zoom - 10));
-    const latDiff = Math.abs(clickLatLng.lat - firstPoint.lat);
-    const lngDiff = Math.abs(clickLatLng.lng - firstPoint.lng);
-    const isClicking = latDiff < tolerance && lngDiff < tolerance;
-    return isClicking;
-  }
   handleDoubleClick(e) {
     if (this.modeManager.getCurrentMode() !== DrawMode.PointToPoint) {
       return;
     }
-    const currentPoints = this.tracer.getLatLngs();
-    if (currentPoints.length >= 3) {
-      this.completePointToPointPolygon();
-    }
-  }
-  completePointToPointPolygon() {
-    const points = this.tracer.getLatLngs();
-    if (points.length < 3) {
-      return;
-    }
-    const closedPoints = [...points];
-    const firstPoint = points[0];
-    const lastPoint = points[points.length - 1];
-    if (firstPoint.lat !== lastPoint.lat || firstPoint.lng !== lastPoint.lng) {
-      closedPoints.push(firstPoint);
-    }
-    try {
-      const coordinates = closedPoints.map((point2) => [point2.lng, point2.lat]);
-      const geoPos = this.turfHelper.getMultiPolygon([[coordinates]]);
-      this.clearP2pMarkers();
-      this.stopDraw();
-      this.polygonMutationManager.addPolygon(geoPos, { simplify: false, noMerge: false });
-      this.polygonInformation.createPolygonInformationStorage(this.arrayOfFeatureGroups);
-    } catch (error) {
-      console.warn("Error completing point-to-point polygon:", error);
-      this.clearP2pMarkers();
-      this.stopDraw();
-    }
-  }
-  clearP2pMarkers() {
-    this.p2pMarkers.forEach((marker) => this.map.removeLayer(marker));
-    this.p2pMarkers = [];
+    this.polygonDrawManager.handleDoubleClick(e);
   }
   /**
    * Detect if modifier key is pressed (Ctrl on Windows/Linux, Cmd on Mac)