leaflet-polydraw 0.9.6 → 1.1.0

package/dist/polydraw.es.js

@@ -2,41 +2,12 @@ var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 var _a, _b;
-import * as L from "leaflet";
-const mergePolygons = true;
-const kinks$1 = false;
-const modes = { "draw": true, "subtract": true, "deleteAll": true, "p2p": true, "attachElbow": true, "dragElbow": true, "dragPolygons": true, "edgeDeletion": true };
-const dragPolygons = { "opacity": 0.7, "dragCursor": "move", "hoverCursor": "grab", "markerBehavior": "hide", "markerAnimationDuration": 200, "modifierSubtract": { "keys": { "windows": "ctrlKey", "mac": "metaKey", "linux": "ctrlKey" }, "hideMarkersOnDrag": true } };
-const edgeDeletion = { "keys": { "windows": "ctrlKey", "mac": "metaKey", "linux": "ctrlKey" }, "minVertices": 3 };
-const markers = { "deleteMarker": true, "infoMarker": true, "menuMarker": true, "coordsTitle": true, "zIndexOffset": 0, "markerIcon": { "styleClasses": ["polygon-marker"], "zIndexOffset": null }, "holeIcon": { "styleClasses": ["polygon-marker", "hole"], "zIndexOffset": null }, "markerInfoIcon": { "position": 3, "showArea": true, "showPerimeter": true, "useMetrics": true, "usePerimeterMinValue": false, "areaLabel": "Area", "perimeterLabel": "Perimeter", "values": { "min": { "metric": "50", "imperial": "100" }, "unknown": { "metric": "-", "imperial": "-" } }, "units": { "unknownUnit": "", "metric": { "onlyMetrics": true, "perimeter": { "m": "m", "km": "km" }, "area": { "m2": "m²", "km2": "km²", "daa": "daa", "ha": "ha" } }, "imperial": { "perimeter": { "feet": "ft", "yards": "yd", "miles": "mi" }, "area": { "feet2": "ft²", "yards2": "yd²", "acres": "ac", "miles2": "mi²" } } }, "styleClasses": ["polygon-marker", "info"], "zIndexOffset": 1e4 }, "markerMenuIcon": { "position": 7, "styleClasses": ["polygon-marker", "menu"], "zIndexOffset": 1e4 }, "markerDeleteIcon": { "position": 5, "styleClasses": ["polygon-marker", "delete"], "zIndexOffset": 1e4 }, "holeMarkers": { "menuMarker": false, "deleteMarker": true, "infoMarker": false }, "visualOptimization": { "sharpAngleThreshold": 30, "thresholdBoundingBox": 0.05, "thresholdDistance": 0.05, "useDistance": true, "useBoundingBox": false, "useAngles": false } };
-const polyLineOptions = { "opacity": 1, "smoothFactor": 0, "noClip": true, "clickable": false, "weight": 2 };
-const subtractLineOptions = { "opacity": 1, "smoothFactor": 0, "noClip": true, "clickable": false, "weight": 2 };
-const polygonOptions = { "smoothFactor": 0.3, "noClip": true };
-const holeOptions = { "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, "multiplier": 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 colors = { "dragPolygons": { "subtract": "#D9460F" }, "p2p": { "closingMarker": "#4CAF50" }, "edgeHover": "#7a9441", "edgeDeletion": { "hover": "#D9460F" }, "polyline": "#50622b", "subtractLine": "#D9460F", "polygon": { "border": "#50622b", "fill": "#b4cd8a" }, "hole": { "border": "#aa0000", "fill": "#ffcccc" }, "styles": { "controlButton": { "backgroundColor": "#fff", "color": "#000" }, "controlButtonHover": { "backgroundColor": "#f4f4f4" }, "controlButtonActive": { "backgroundColor": "rgb(128, 218, 255)", "color": "#fff" }, "indicatorActive": { "backgroundColor": "#ffcc00" }, "p2pMarker": { "backgroundColor": "#fff", "borderColor": "#50622b" } } };
-const defaultConfig = {
-  mergePolygons,
-  kinks: kinks$1,
-  modes,
-  dragPolygons,
-  edgeDeletion,
-  markers,
-  polyLineOptions,
-  subtractLineOptions,
-  polygonOptions,
-  holeOptions,
-  polygonCreation,
-  simplification,
-  menuOperations,
-  boundingBox,
-  bezier: bezier$1,
-  colors
-};
+import * as L$1 from "leaflet";
+var LeafletVersion = /* @__PURE__ */ ((LeafletVersion2) => {
+  LeafletVersion2["V1"] = "1.x";
+  LeafletVersion2["V2"] = "2.x";
+  return LeafletVersion2;
+})(LeafletVersion || {});
 var DrawMode = /* @__PURE__ */ ((DrawMode2) => {
   DrawMode2[DrawMode2["Off"] = 0] = "Off";
   DrawMode2[DrawMode2["Add"] = 1] = "Add";
@@ -45,6 +16,7 @@ var DrawMode = /* @__PURE__ */ ((DrawMode2) => {
   DrawMode2[DrawMode2["AppendMarker"] = 8] = "AppendMarker";
   DrawMode2[DrawMode2["LoadPredefined"] = 16] = "LoadPredefined";
   DrawMode2[DrawMode2["PointToPoint"] = 32] = "PointToPoint";
+  DrawMode2[DrawMode2["PointToPointSubtract"] = 64] = "PointToPointSubtract";
   return DrawMode2;
 })(DrawMode || {});
 var MarkerPosition = /* @__PURE__ */ ((MarkerPosition2) => {
@@ -59,6 +31,244 @@ var MarkerPosition = /* @__PURE__ */ ((MarkerPosition2) => {
   MarkerPosition2[MarkerPosition2["Hole"] = 8] = "Hole";
   return MarkerPosition2;
 })(MarkerPosition || {});
+const defaultConfig = {
+  mergePolygons: true,
+  kinks: false,
+  modes: {
+    draw: true,
+    subtract: true,
+    deleteAll: true,
+    p2p: true,
+    p2pSubtract: true,
+    attachElbow: true,
+    dragElbow: true,
+    dragPolygons: true,
+    edgeDeletion: true
+  },
+  defaultMode: DrawMode.Off,
+  dragPolygons: {
+    opacity: 0.7,
+    dragCursor: "move",
+    hoverCursor: "grab",
+    markerBehavior: "hide",
+    markerAnimationDuration: 200,
+    modifierSubtract: {
+      keys: {
+        windows: "ctrlKey",
+        mac: "metaKey",
+        linux: "ctrlKey"
+      },
+      hideMarkersOnDrag: true
+    }
+  },
+  edgeDeletion: {
+    keys: {
+      windows: "ctrlKey",
+      mac: "metaKey",
+      linux: "ctrlKey"
+    },
+    minVertices: 3
+  },
+  markers: {
+    deleteMarker: true,
+    infoMarker: true,
+    menuMarker: true,
+    coordsTitle: true,
+    zIndexOffset: 0,
+    markerIcon: {
+      styleClasses: ["polygon-marker"],
+      zIndexOffset: null
+    },
+    holeIcon: {
+      styleClasses: ["polygon-marker", "hole"],
+      zIndexOffset: null
+    },
+    markerInfoIcon: {
+      position: 3,
+      showArea: true,
+      showPerimeter: true,
+      useMetrics: true,
+      usePerimeterMinValue: false,
+      areaLabel: "Area",
+      perimeterLabel: "Perimeter",
+      values: {
+        min: {
+          metric: "50",
+          imperial: "100"
+        },
+        unknown: {
+          metric: "-",
+          imperial: "-"
+        }
+      },
+      units: {
+        unknownUnit: "",
+        metric: {
+          onlyMetrics: true,
+          perimeter: {
+            m: "m",
+            km: "km"
+          },
+          area: {
+            m2: "m²",
+            km2: "km²",
+            daa: "daa",
+            ha: "ha"
+          }
+        },
+        imperial: {
+          perimeter: {
+            feet: "ft",
+            yards: "yd",
+            miles: "mi"
+          },
+          area: {
+            feet2: "ft²",
+            yards2: "yd²",
+            acres: "ac",
+            miles2: "mi²"
+          }
+        }
+      },
+      styleClasses: ["polygon-marker", "info"],
+      zIndexOffset: 1e4
+    },
+    markerMenuIcon: {
+      position: 1,
+      styleClasses: ["polygon-marker", "menu"],
+      zIndexOffset: 1e4
+    },
+    markerDeleteIcon: {
+      position: 5,
+      styleClasses: ["polygon-marker", "delete"],
+      zIndexOffset: 1e4
+    },
+    holeMarkers: {
+      menuMarker: false,
+      deleteMarker: true,
+      infoMarker: false
+    },
+    visualOptimization: {
+      sharpAngleThreshold: 30,
+      thresholdBoundingBox: 0.05,
+      thresholdDistance: 0.05,
+      useDistance: true,
+      useBoundingBox: false,
+      useAngles: false
+    }
+  },
+  polyLineOptions: {
+    opacity: 1,
+    weight: 2
+  },
+  subtractLineOptions: {
+    opacity: 1,
+    weight: 2
+  },
+  polygonOptions: {
+    weight: 2,
+    opacity: 1,
+    fillOpacity: 0.2,
+    smoothFactor: 0.3,
+    noClip: true
+  },
+  holeOptions: {
+    weight: 2,
+    opacity: 1,
+    fillOpacity: 0.5
+  },
+  polygonCreation: {
+    method: "concaveman",
+    simplification: {
+      mode: "simple",
+      tolerance: 1e-5,
+      highQuality: false
+    }
+  },
+  simplification: {
+    simplifyTolerance: {
+      tolerance: 1e-4,
+      highQuality: false,
+      mutate: false
+    },
+    dynamicMode: {
+      fractionGuard: 0.9,
+      multiplier: 2
+    }
+  },
+  menuOperations: {
+    simplify: {
+      enabled: true,
+      processHoles: true
+    },
+    doubleElbows: {
+      enabled: true,
+      processHoles: true
+    },
+    bbox: {
+      enabled: true,
+      processHoles: true
+    },
+    bezier: {
+      enabled: true
+    },
+    scale: {
+      enabled: true
+    },
+    rotate: {
+      enabled: true
+    }
+  },
+  boundingBox: {
+    addMidPointMarkers: true
+  },
+  bezier: {
+    resolution: 1e4,
+    sharpness: 0.75
+  },
+  colors: {
+    dragPolygons: {
+      subtract: "#D9460F"
+    },
+    p2p: {
+      closingMarker: "#4CAF50"
+    },
+    edgeHover: "#7a9441",
+    edgeDeletion: {
+      hover: "#D9460F"
+    },
+    polyline: "#50622b",
+    subtractLine: "#D9460F",
+    polygon: {
+      border: "#50622b",
+      fill: "#b4cd8a"
+    },
+    hole: {
+      border: "#aa0000",
+      fill: "#ffcccc"
+    },
+    styles: {
+      controlButton: {
+        backgroundColor: "#fff",
+        color: "#000"
+      },
+      controlButtonHover: {
+        backgroundColor: "#f4f4f4"
+      },
+      controlButtonActive: {
+        backgroundColor: "rgb(128, 218, 255)",
+        color: "#fff"
+      },
+      indicatorActive: {
+        backgroundColor: "#ffcc00"
+      },
+      p2pMarker: {
+        backgroundColor: "#fff",
+        borderColor: "#50622b"
+      }
+    }
+  }
+};
 const EARTH_RADIUS = {
   /**
    * Mean radius in meters - good enough for this tool's precision requirements
@@ -15955,7 +16165,7 @@ class PolyDrawUtil {
       if (isNaN(ll.lat) || isNaN(ll.lng)) ;
       tmpLatLng.push(ll);
     });
-    const polyLine = new L.Polyline(tmpLatLng);
+    const polyLine = new L$1.Polyline(tmpLatLng);
     const bounds = polyLine.getBounds();
     if (padding !== 0) {
       return bounds.pad(padding);
@@ -15966,23 +16176,23 @@ class PolyDrawUtil {
 class Compass {
   constructor(minLat = 0, minLng = 0, maxLat = 0, maxLng = 0) {
     __publicField(this, "direction", {
-      East: new L.LatLng(0, 0),
-      North: new L.LatLng(0, 0),
-      NorthEast: new L.LatLng(0, 0),
-      NorthWest: new L.LatLng(0, 0),
-      South: new L.LatLng(0, 0),
-      SouthEast: new L.LatLng(0, 0),
-      SouthWest: new L.LatLng(0, 0),
-      West: new L.LatLng(0, 0)
+      East: new L$1.LatLng(0, 0),
+      North: new L$1.LatLng(0, 0),
+      NorthEast: new L$1.LatLng(0, 0),
+      NorthWest: new L$1.LatLng(0, 0),
+      South: new L$1.LatLng(0, 0),
+      SouthEast: new L$1.LatLng(0, 0),
+      SouthWest: new L$1.LatLng(0, 0),
+      West: new L$1.LatLng(0, 0)
     });
-    this.direction.North = new L.LatLng(maxLat, (minLng + maxLng) / 2);
-    this.direction.NorthEast = new L.LatLng(maxLat, maxLng);
-    this.direction.East = new L.LatLng((minLat + maxLat) / 2, maxLng);
-    this.direction.SouthEast = new L.LatLng(minLat, maxLng);
-    this.direction.South = new L.LatLng(minLat, (minLng + maxLng) / 2);
-    this.direction.SouthWest = new L.LatLng(minLat, minLng);
-    this.direction.West = new L.LatLng((minLat + maxLat) / 2, minLng);
-    this.direction.NorthWest = new L.LatLng(maxLat, minLng);
+    this.direction.North = new L$1.LatLng(maxLat, (minLng + maxLng) / 2);
+    this.direction.NorthEast = new L$1.LatLng(maxLat, maxLng);
+    this.direction.East = new L$1.LatLng((minLat + maxLat) / 2, maxLng);
+    this.direction.SouthEast = new L$1.LatLng(minLat, maxLng);
+    this.direction.South = new L$1.LatLng(minLat, (minLng + maxLng) / 2);
+    this.direction.SouthWest = new L$1.LatLng(minLat, minLng);
+    this.direction.West = new L$1.LatLng((minLat + maxLat) / 2, minLng);
+    this.direction.NorthWest = new L$1.LatLng(maxLat, minLng);
   }
   getDirection(direction) {
     switch (direction) {
@@ -16766,10 +16976,10 @@ class TurfHelper {
     for (let i = 0; i < effectiveLen; i++) {
       const p1 = points[i];
       const p2 = points[(i + 1) % effectiveLen];
-      doubleized.push(new L.LatLng(p1.lat, p1.lng));
+      doubleized.push(new L$1.LatLng(p1.lat, p1.lng));
       const midPoint = midpoint(point$1([p1.lng, p1.lat]), point$1([p2.lng, p2.lat]));
       doubleized.push(
-        new L.LatLng(midPoint.geometry.coordinates[1], midPoint.geometry.coordinates[0])
+        new L$1.LatLng(midPoint.geometry.coordinates[1], midPoint.geometry.coordinates[0])
       );
     }
     return doubleized;
@@ -17242,141 +17452,697 @@ class TurfHelper {
     return feature2;
   }
 }
-function createButtons(container, subContainer, config, onActivateToggle, onDrawClick, onSubtractClick, onEraseClick, onPointToPointClick) {
-  const activate = L.DomUtil.create("a", "icon-activate", container);
-  activate.href = "#";
-  activate.title = "Activate";
-  activate.innerHTML = '<svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg"><g id="SVGRepo_bgCarrier" stroke-width="0"></g><g id="SVGRepo_tracerCarrier" stroke-linecap="round" stroke-linejoin="round"></g><g id="SVGRepo_iconCarrier"> <path d="M5 17V7M5 17C3.89543 17 3 17.8954 3 19C3 20.1046 3.89543 21 5 21C6.10457 21 7 20.1046 7 19M5 17C6.10457 17 7 17.8954 7 19M5 7C6.10457 7 7 6.10457 7 5M5 7C3.89543 7 3 6.10457 3 5C3 3.89543 3.89543 3 5 3C6.10457 3 7 3.89543 7 5M7 5H17M17 5C17 6.10457 17.8954 7 19 7C20.1046 7 21 6.10457 21 5C21 3.89543 20.1046 3 19 3C17.8954 3 17 3.89543 17 5ZM7 19H17M17 19C17 20.1046 17.8954 21 19 21C20.1046 21 21 20.1046 21 19C21 17.8954 20.1046 17 19 17C17.8954 17 17 17.8954 17 19ZM17.9247 6.6737L15.1955 10.3776M15.1955 13.6223L17.9222 17.3223M16 12C16 13.1046 15.1046 14 14 14C12.8954 14 12 13.1046 12 12C12 10.8954 12.8954 10 14 10C15.1046 10 16 10.8954 16 12Z" stroke="#000000" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"></path> </g></svg>';
-  L.DomEvent.on(activate, "mousedown", L.DomEvent.stopPropagation);
-  L.DomEvent.on(activate, "touchstart", L.DomEvent.stopPropagation);
-  L.DomEvent.on(activate, "click", L.DomEvent.stop).on(activate, "click", onActivateToggle);
-  if (config.modes.draw) {
-    const draw = L.DomUtil.create("a", "icon-draw", subContainer);
-    draw.href = "#";
-    draw.title = "Draw";
-    draw.innerHTML = '<svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg"><g id="SVGRepo_bgCarrier" stroke-width="0"></g><g id="SVGRepo_tracerCarrier" stroke-linecap="round" stroke-linejoin="round"></g><g id="SVGRepo_iconCarrier"> <path d="M15 7.49996L17.5 9.99996M7.5 20L19.25 8.24996C19.9404 7.5596 19.9404 6.44032 19.25 5.74996V5.74996C18.5596 5.0596 17.4404 5.05961 16.75 5.74996L5 17.5V20H7.5ZM7.5 20H15.8787C17.0503 20 18 19.0502 18 17.8786V17.8786C18 17.316 17.7765 16.7765 17.3787 16.3786L17 16M4.5 4.99996C6.5 2.99996 10 3.99996 10 5.99996C10 8.5 4 8.5 4 11C4 11.8759 4.53314 12.5256 5.22583 13" stroke="#000000" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"></path> </g></svg>';
-    L.DomEvent.on(draw, "mousedown", L.DomEvent.stopPropagation);
-    L.DomEvent.on(draw, "touchstart", L.DomEvent.stopPropagation);
-    L.DomEvent.on(draw, "click", L.DomEvent.stop).on(draw, "click", onDrawClick);
+class LeafletVersionDetector {
+  /**
+   * Detects the Leaflet version being used
+   * @returns The detected Leaflet version
+   */
+  static getVersion() {
+    if (this._detectedVersion) {
+      return this._detectedVersion;
+    }
+    this._detectedVersion = this.detectVersion();
+    return this._detectedVersion;
   }
-  if (config.modes.subtract) {
-    const subtract = L.DomUtil.create("a", "icon-subtract", subContainer);
-    subtract.href = "#";
-    subtract.title = "Subtract";
-    subtract.innerHTML = '<svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg"><g id="SVGRepo_bgCarrier" stroke-width="0"></g><g id="SVGRepo_tracerCarrier" stroke-linecap="round" stroke-linejoin="round"></g><g id="SVGRepo_iconCarrier"> <path fill-rule="evenodd" clip-rule="evenodd" d="M15.0722 3.9967L20.7508 9.83395L17.0544 13.5304L13.0758 17.5H21.0041V19H7.93503L4.00195 15.0669L15.0722 3.9967ZM10.952 17.5L15.4628 12.9994L11.8268 9.3634L6.12327 15.0669L8.55635 17.5H10.952Z" fill="#1F2328"></path> </g></svg>';
-    L.DomEvent.on(subtract, "mousedown", L.DomEvent.stopPropagation);
-    L.DomEvent.on(subtract, "touchstart", L.DomEvent.stopPropagation);
-    L.DomEvent.on(subtract, "click", L.DomEvent.stop).on(subtract, "click", onSubtractClick);
+  /**
+   * Performs the actual version detection
+   * @returns The detected Leaflet version
+   */
+  static detectVersion() {
+    if (typeof L === "undefined") {
+      return LeafletVersion.V2;
+    }
+    if (L.version) {
+      if (L.version.startsWith("2.")) {
+        return LeafletVersion.V2;
+      }
+      if (L.version.startsWith("1.")) {
+        return LeafletVersion.V1;
+      }
+    }
+    if (typeof L.marker !== "function") {
+      return LeafletVersion.V2;
+    }
+    if (typeof L.marker === "function" && typeof L.polyline === "function" && typeof L.polygon === "function") {
+      return LeafletVersion.V1;
+    }
+    if (L.Marker && typeof L.Marker === "function" && L.Polyline && typeof L.Polyline === "function") {
+      return LeafletVersion.V2;
+    }
+    return LeafletVersion.V1;
   }
-  if (config.modes.p2p && !isTouchDevice()) {
-    const p2p = L.DomUtil.create("a", "icon-p2p", subContainer);
-    p2p.href = "#";
-    p2p.title = "Point to Point";
-    p2p.innerHTML = '<svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg"><g id="SVGRepo_bgCarrier" stroke-width="0"></g><g id="SVGRepo_tracerCarrier" stroke-linecap="round" stroke-linejoin="round"></g><g id="SVGRepo_iconCarrier"> <path d="M5 17V7M5 17C3.89543 17 3 17.8954 3 19C3 20.1046 3.89543 21 5 21C6.10457 21 7 20.1046 7 19M5 17C6.10457 17 7 17.8954 7 19M5 7C6.10457 7 7 6.10457 7 5M5 7C3.89543 7 3 6.10457 3 5C3 3.89543 3.89543 3 5 3C6.10457 3 7 3.89543 7 5M7 5H17M17 5C17 6.10457 17.8954 7 19 7C20.1046 7 21 6.10457 21 5C21 3.89543 20.1046 3 19 3C17.8954 3 17 3.89543 17 5ZM7 19H17M17 19C17 20.1046 17.8954 21 19 21C20.1046 21 21 20.1046 21 19C21 17.8954 20.1046 17 19 17C17.8954 17 17 17.8954 17 19ZM17.9247 6.6737L15.1955 10.3776M15.1955 13.6223L17.9222 17.3223M16 12C16 13.1046 15.1046 14 14 14C12.8954 14 12 13.1046 12 12C12 10.8954 12.8954 10 14 10C15.1046 10 16 10.8954 16 12Z" stroke="#000000" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"></path> </g></svg>';
-    L.DomEvent.on(p2p, "mousedown", L.DomEvent.stopPropagation);
-    L.DomEvent.on(p2p, "touchstart", L.DomEvent.stopPropagation);
-    L.DomEvent.on(p2p, "click", L.DomEvent.stop).on(p2p, "click", onPointToPointClick);
+  /**
+   * Checks if we're running Leaflet v1.x
+   * @returns true if running v1.x
+   */
+  static isV1() {
+    return this.getVersion() === LeafletVersion.V1;
   }
-  if (config.modes.deleteAll) {
-    const erase = L.DomUtil.create("a", "icon-erase", subContainer);
-    erase.href = "#";
-    erase.title = "Erase All";
-    erase.innerHTML = `<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 21.0.2, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 viewBox="0 0 48 48" style="enable-background:new 0 0 48 48;" xml:space="preserve">
-<style type="text/css">
-	.st0{fill:#000000}
-	.st1{fill:#333333;fill-opacity:0;}
-</style>
-<title>trash</title>
-<rect class="st1" width="48" height="48"/>
-<polygon class="st0" points="26.6,10 26.6,7.8 21.4,7.8 21.4,10 12.6,10 12.6,12.8 35.4,12.8 35.4,10 "/>
-<path class="st0" d="M35.4,15.4H12.6v4.3h1.8V37c0,1.1,0.9,2,2,2h15.2c1.1,0,2-0.9,2-2V19.7h1.8V15.4z M19.7,34.2c0,0.5-0.4,1-1,1
-	c-0.5,0-1-0.4-1-1V22.6c0-0.5,0.4-1,1-1c0.5,0,1,0.4,1,1V34.2z M25.3,33.8c0,0.7-0.6,1.3-1.3,1.3c-0.7,0-1.3-0.6-1.3-1.3V23
-	c0-0.7,0.6-1.3,1.3-1.3c0.7,0,1.3,0.6,1.3,1.3V33.8z M30.3,34.2c0,0.5-0.4,1-1,1c-0.5,0-1-0.4-1-1V22.6c0-0.5,0.4-1,1-1
-	c0.5,0,1,0.4,1,1V34.2z"/>
-</svg>`;
-    L.DomEvent.on(erase, "mousedown", L.DomEvent.stopPropagation);
-    L.DomEvent.on(erase, "touchstart", L.DomEvent.stopPropagation);
-    L.DomEvent.on(erase, "click", L.DomEvent.stop).on(erase, "click", onEraseClick);
+  /**
+   * Checks if we're running Leaflet v2.x
+   * @returns true if running v2.x
+   */
+  static isV2() {
+    return this.getVersion() === LeafletVersion.V2;
   }
-}
-class PolygonUtil {
   /**
-   * Calculates the center of the polygon.
-   * @param polygon Array of LatLng points.
-   * @returns The center LatLng.
+   * Resets the cached version detection (useful for testing)
    */
-  static getCenter(polygon2) {
-    let x = 0;
-    let y = 0;
-    let z = 0;
-    polygon2.forEach((v) => {
-      let lat1 = v.lat;
-      let lon1 = v.lng;
-      lat1 = lat1 * MATH.DEG_TO_RAD;
-      lon1 = lon1 * MATH.DEG_TO_RAD;
-      x += Math.cos(lat1) * Math.cos(lon1);
-      y += Math.cos(lat1) * Math.sin(lon1);
-      z += Math.sin(lat1);
-    });
-    let lng = Math.atan2(y, x);
-    const hyp = Math.sqrt(x * x + y * y);
-    let lat = Math.atan2(z, hyp);
-    lat = lat * MATH.RAD_TO_DEG;
-    lng = lng * MATH.RAD_TO_DEG;
-    const center2 = { lat, lng };
-    return center2;
+  static reset() {
+    this._detectedVersion = null;
   }
   /**
-   * Gets the southwest point of the polygon bounds.
-   * @param polygon Array of LatLng points.
-   * @returns The southwest LatLng.
+   * Gets detailed version information for debugging
+   * @returns Object with version details
    */
-  static getSouthWest(polygon2) {
-    const bounds = this.getBounds(polygon2);
-    return bounds.getSouthWest();
+  static getVersionInfo() {
+    const version = this.getVersion();
+    return {
+      version,
+      leafletVersion: typeof L !== "undefined" ? L.version : void 0,
+      hasFactoryMethods: typeof L !== "undefined" && typeof L.marker === "function",
+      hasConstructors: typeof L !== "undefined" && L.Marker && typeof L.Marker === "function",
+      globalLAvailable: typeof L !== "undefined"
+    };
   }
-  static getNorthEast(polygon2) {
-    const bounds = this.getBounds(polygon2);
-    return bounds.getNorthEast();
+}
+__publicField(LeafletVersionDetector, "_detectedVersion", null);
+class LeafletAdapter {
+  constructor() {
+    __publicField(this, "version");
+    /**
+     * DOM utility methods compatibility
+     */
+    __publicField(this, "domUtil", {
+      create: (tagName, className, container) => {
+        if (typeof L !== "undefined" && L.DomUtil) {
+          return L.DomUtil.create(tagName, className, container);
+        } else {
+          const element = document.createElement(tagName);
+          if (className) {
+            element.className = className;
+          }
+          if (container) {
+            container.appendChild(element);
+          }
+          return element;
+        }
+      },
+      addClass: (el, name) => {
+        if (this.version === LeafletVersion.V1) {
+          L.DomUtil.addClass(el, name);
+        } else {
+          el.classList.add(name);
+        }
+      },
+      removeClass: (el, name) => {
+        if (this.version === LeafletVersion.V1) {
+          L.DomUtil.removeClass(el, name);
+        } else {
+          el.classList.remove(name);
+        }
+      },
+      hasClass: (el, name) => {
+        if (this.version === LeafletVersion.V1) {
+          return L.DomUtil.hasClass(el, name);
+        } else {
+          return el.classList.contains(name);
+        }
+      },
+      setPosition: (el, point2) => {
+        L.DomUtil.setPosition(el, point2);
+      },
+      getPosition: (el) => {
+        return L.DomUtil.getPosition(el);
+      }
+    });
+    /**
+     * DOM event methods compatibility
+     */
+    __publicField(this, "domEvent", {
+      on: (obj, types, fn, context) => {
+        L.DomEvent.on(obj, types, fn, context);
+        return this;
+      },
+      off: (obj, types, fn, context) => {
+        L.DomEvent.off(obj, types, fn, context);
+        return this;
+      },
+      stopPropagation: (e) => {
+        L.DomEvent.stopPropagation(e);
+        return this;
+      },
+      preventDefault: (e) => {
+        L.DomEvent.preventDefault(e);
+        return this;
+      },
+      stop: (e) => {
+        L.DomEvent.stop(e);
+        return this;
+      },
+      disableClickPropagation: (el) => {
+        L.DomEvent.disableClickPropagation(el);
+        return this;
+      },
+      disableScrollPropagation: (el) => {
+        L.DomEvent.disableScrollPropagation(el);
+        return this;
+      },
+      getMousePosition: (e, container) => {
+        if (this.version === LeafletVersion.V1) {
+          return L.DomEvent.getMousePosition(e, container);
+        } else {
+          return L.DomEvent.getPointerPosition ? L.DomEvent.getPointerPosition(e, container) : L.DomEvent.getMousePosition(e, container);
+        }
+      }
+    });
+    /**
+     * Utility methods compatibility
+     */
+    __publicField(this, "util", {
+      extend: (dest, ...sources) => {
+        if (this.version === LeafletVersion.V1) {
+          return L.Util.extend(dest, ...sources);
+        } else {
+          return Object.assign(dest, ...sources);
+        }
+      },
+      bind: (fn, obj) => {
+        if (this.version === LeafletVersion.V1) {
+          return L.Util.bind(fn, obj);
+        } else {
+          return fn.bind(obj);
+        }
+      },
+      stamp: (obj) => {
+        return L.Util.stamp(obj);
+      },
+      throttle: (fn, time, context) => {
+        return L.Util.throttle(fn, time, context);
+      },
+      wrapNum: (x, range, includeMax) => {
+        return L.Util.wrapNum(x, range, includeMax);
+      },
+      falseFn: () => {
+        return L.Util.falseFn();
+      },
+      formatNum: (num, digits) => {
+        return L.Util.formatNum(num, digits);
+      },
+      trim: (str) => {
+        if (this.version === LeafletVersion.V1) {
+          return L.Util.trim(str);
+        } else {
+          return str.trim();
+        }
+      },
+      splitWords: (str) => {
+        return L.Util.splitWords(str);
+      },
+      setOptions: (obj, options) => {
+        return L.Util.setOptions(obj, options);
+      },
+      getParamString: (obj, existingUrl, uppercase) => {
+        if (this.version === LeafletVersion.V1) {
+          return L.Util.getParamString(obj, existingUrl, uppercase);
+        } else {
+          const params = new URLSearchParams();
+          for (const key in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, key)) {
+              const paramKey = uppercase ? key.toUpperCase() : key;
+              params.set(paramKey, obj[key]);
+            }
+          }
+          const paramString = params.toString();
+          if (existingUrl) {
+            const separator = existingUrl.indexOf("?") === -1 ? "?" : "&";
+            return existingUrl + separator + paramString;
+          }
+          return paramString ? "?" + paramString : "";
+        }
+      },
+      template: (str, data) => {
+        return L.Util.template(str, data);
+      },
+      isArray: (obj) => {
+        if (this.version === LeafletVersion.V1) {
+          return L.Util.isArray(obj);
+        } else {
+          return Array.isArray(obj);
+        }
+      },
+      indexOf: (array, item) => {
+        return L.Util.indexOf(array, item);
+      },
+      requestAnimFrame: (fn, context, immediate) => {
+        if (this.version === LeafletVersion.V1) {
+          return L.Util.requestAnimFrame(fn, context, immediate);
+        } else {
+          return requestAnimationFrame(context ? fn.bind(context) : fn);
+        }
+      },
+      cancelAnimFrame: (id) => {
+        if (this.version === LeafletVersion.V1) {
+          L.Util.cancelAnimFrame(id);
+        } else {
+          cancelAnimationFrame(id);
+        }
+      }
+    });
+    this.version = LeafletVersionDetector.getVersion();
   }
-  static getNorthWest(polygon2) {
-    const bounds = this.getBounds(polygon2);
-    return bounds.getNorthWest();
+  /**
+   * Creates a tile layer compatible with both Leaflet versions
+   */
+  createTileLayer(urlTemplate, options) {
+    if (this.version === LeafletVersion.V1) {
+      return L.tileLayer(urlTemplate, options);
+    } else {
+      return new L.TileLayer(urlTemplate, options);
+    }
   }
-  static getSouthEast(polygon2) {
-    const bounds = this.getBounds(polygon2);
-    return bounds.getSouthEast();
+  /**
+   * Creates a map compatible with both Leaflet versions
+   */
+  createMap(element, options) {
+    if (this.version === LeafletVersion.V1) {
+      return L.map(element, options);
+    } else {
+      return new L.Map(element, options);
+    }
   }
-  static getNorth(polygon2) {
-    const bounds = this.getBounds(polygon2);
-    return bounds.getNorth();
+  /**
+   * Creates a marker compatible with both Leaflet versions
+   */
+  createMarker(latlng, options) {
+    if (this.version === LeafletVersion.V1) {
+      return L.marker(latlng, options);
+    } else {
+      return new L.Marker(latlng, options);
+    }
   }
-  static getSouth(polygon2) {
-    const bounds = this.getBounds(polygon2);
-    return bounds.getSouth();
+  /**
+   * Creates a polyline compatible with both Leaflet versions
+   */
+  createPolyline(latlngs, options) {
+    if (this.version === LeafletVersion.V1) {
+      return L.polyline(latlngs, options);
+    } else {
+      return new L.Polyline(latlngs, options);
+    }
   }
-  static getWest(polygon2) {
-    const bounds = this.getBounds(polygon2);
-    return bounds.getWest();
+  /**
+   * Creates a polygon compatible with both Leaflet versions
+   */
+  createPolygon(latlngs, options) {
+    if (this.version === LeafletVersion.V1) {
+      return L.polygon(latlngs, options);
+    } else {
+      return new L.Polygon(latlngs, options);
+    }
   }
-  static getEast(polygon2) {
-    const bounds = this.getBounds(polygon2);
-    return bounds.getEast();
+  /**
+   * Creates a div icon compatible with both Leaflet versions
+   */
+  createDivIcon(options) {
+    if (this.version === LeafletVersion.V1) {
+      return L.divIcon(options);
+    } else {
+      return new L.DivIcon(options);
+    }
   }
-  static getSqmArea(polygon2) {
-    const poly = new L.Polygon(polygon2);
-    const geoJsonPoly = poly.toGeoJSON();
-    const area2 = this.turfHelper.getPolygonArea(geoJsonPoly);
-    return area2;
+  /**
+   * Creates a LatLng object compatible with both Leaflet versions
+   */
+  createLatLng(lat, lng, alt) {
+    if (this.version === LeafletVersion.V1) {
+      return L.latLng(lat, lng, alt);
+    } else {
+      return new L.LatLng(lat, lng, alt);
+    }
   }
-  static getPerimeter(polygon2) {
-    const poly = new L.Polygon(polygon2);
-    const geoJsonPoly = poly.toGeoJSON();
-    const perimeter = this.turfHelper.getPolygonPerimeter(geoJsonPoly);
-    return perimeter * 1e3;
+  /**
+   * Creates a LatLngBounds object compatible with both Leaflet versions
+   */
+  createLatLngBounds(corner1, corner2) {
+    if (this.version === LeafletVersion.V1) {
+      return L.latLngBounds(corner1, corner2);
+    } else {
+      return new L.LatLngBounds(corner1, corner2);
+    }
+  }
+  /**
+   * Creates a Point object compatible with both Leaflet versions
+   */
+  createPoint(x, y, round) {
+    if (this.version === LeafletVersion.V1) {
+      return L.point(x, y, round);
+    } else {
+      return new L.Point(x, y, round);
+    }
+  }
+  /**
+   * Creates a popup compatible with both Leaflet versions
+   */
+  createPopup(options, source) {
+    if (this.version === LeafletVersion.V1) {
+      return L.popup(options, source);
+    } else {
+      return new L.Popup(options, source);
+    }
+  }
+  /**
+   * Creates a feature group compatible with both Leaflet versions
+   */
+  createFeatureGroup(layers) {
+    if (this.version === LeafletVersion.V1) {
+      return L.featureGroup(layers);
+    } else {
+      return new L.FeatureGroup(layers);
+    }
+  }
+  /**
+   * Creates a layer group compatible with both Leaflet versions
+   */
+  createLayerGroup(layers) {
+    if (this.version === LeafletVersion.V1) {
+      return L.layerGroup(layers);
+    } else {
+      return new L.LayerGroup(layers);
+    }
+  }
+  /**
+   * Browser detection compatibility
+   */
+  getBrowser() {
+    const self = this;
+    return {
+      get ie() {
+        return self.version === LeafletVersion.V1 ? L.Browser.ie : false;
+      },
+      get ielt9() {
+        return self.version === LeafletVersion.V1 ? L.Browser.ielt9 : false;
+      },
+      get edge() {
+        return self.version === LeafletVersion.V1 ? L.Browser.edge : false;
+      },
+      get webkit() {
+        return self.version === LeafletVersion.V1 ? L.Browser.webkit : false;
+      },
+      get android() {
+        return self.version === LeafletVersion.V1 ? L.Browser.android : /Android/.test(navigator.userAgent);
+      },
+      get android23() {
+        return self.version === LeafletVersion.V1 ? L.Browser.android23 : false;
+      },
+      get androidStock() {
+        return self.version === LeafletVersion.V1 ? L.Browser.androidStock : false;
+      },
+      get opera() {
+        return self.version === LeafletVersion.V1 ? L.Browser.opera : false;
+      },
+      get chrome() {
+        return self.version === LeafletVersion.V1 ? L.Browser.chrome : /Chrome/.test(navigator.userAgent);
+      },
+      get gecko() {
+        return self.version === LeafletVersion.V1 ? L.Browser.gecko : false;
+      },
+      get safari() {
+        return self.version === LeafletVersion.V1 ? L.Browser.safari : /Safari/.test(navigator.userAgent) && !/Chrome/.test(navigator.userAgent);
+      },
+      get phantom() {
+        return self.version === LeafletVersion.V1 ? L.Browser.phantom : false;
+      },
+      get opera12() {
+        return self.version === LeafletVersion.V1 ? L.Browser.opera12 : false;
+      },
+      get win() {
+        return self.version === LeafletVersion.V1 ? L.Browser.win : /Win/.test(navigator.platform);
+      },
+      get ie3d() {
+        return self.version === LeafletVersion.V1 ? L.Browser.ie3d : false;
+      },
+      get webkit3d() {
+        return self.version === LeafletVersion.V1 ? L.Browser.webkit3d : false;
+      },
+      get gecko3d() {
+        return self.version === LeafletVersion.V1 ? L.Browser.gecko3d : false;
+      },
+      get any3d() {
+        return self.version === LeafletVersion.V1 ? L.Browser.any3d : true;
+      },
+      get mobile() {
+        return L.Browser.mobile;
+      },
+      get mobileWebkit() {
+        return self.version === LeafletVersion.V1 ? L.Browser.mobileWebkit : false;
+      },
+      get mobileWebkit3d() {
+        return self.version === LeafletVersion.V1 ? L.Browser.mobileWebkit3d : false;
+      },
+      get msPointer() {
+        return self.version === LeafletVersion.V1 ? L.Browser.msPointer : false;
+      },
+      get pointer() {
+        return L.Browser.pointer || true;
+      },
+      get touch() {
+        return L.Browser.touch;
+      },
+      get touchNative() {
+        return self.version === LeafletVersion.V1 ? L.Browser.touchNative : false;
+      },
+      get mobileOpera() {
+        return self.version === LeafletVersion.V1 ? L.Browser.mobileOpera : false;
+      },
+      get mobileGecko() {
+        return self.version === LeafletVersion.V1 ? L.Browser.mobileGecko : false;
+      },
+      get retina() {
+        return L.Browser.retina;
+      },
+      get passiveEvents() {
+        return self.version === LeafletVersion.V1 ? L.Browser.passiveEvents : true;
+      },
+      get canvas() {
+        return self.version === LeafletVersion.V1 ? L.Browser.canvas : true;
+      },
+      get svg() {
+        return self.version === LeafletVersion.V1 ? L.Browser.svg : true;
+      },
+      get vml() {
+        return self.version === LeafletVersion.V1 ? L.Browser.vml : false;
+      },
+      get inlineSvg() {
+        return self.version === LeafletVersion.V1 ? L.Browser.inlineSvg : true;
+      }
+    };
+  }
+  /**
+   * Gets the current Leaflet version being used
+   */
+  getVersion() {
+    return this.version;
+  }
+  /**
+   * Checks if we're running Leaflet v1.x
+   */
+  isV1() {
+    return this.version === LeafletVersion.V1;
+  }
+  /**
+   * Checks if we're running Leaflet v2.x
+   */
+  isV2() {
+    return this.version === LeafletVersion.V2;
+  }
+}
+const leafletAdapter = new LeafletAdapter();
+const iconPolydraw2Svg = '<?xml version="1.0" encoding="UTF-8" standalone="no"?>\n<!-- Generated by Pixelmator Pro 3.7 -->\n\n<svg\n   width="512"\n   height="512"\n   viewBox="0 0 512 512"\n   version="1.1"\n   id="svg1"\n   sodipodi:docname="icon-polydraw2.svg"\n   inkscape:version="1.4.2 (ebf0e940, 2025-05-08)"\n   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"\n   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"\n   xmlns="http://www.w3.org/2000/svg"\n   xmlns:svg="http://www.w3.org/2000/svg">\n  <defs\n     id="defs1" />\n  <sodipodi:namedview\n     id="namedview1"\n     pagecolor="#ffffff"\n     bordercolor="#000000"\n     borderopacity="0.25"\n     inkscape:showpageshadow="2"\n     inkscape:pageopacity="0.0"\n     inkscape:pagecheckerboard="0"\n     inkscape:deskcolor="#d1d1d1"\n     inkscape:zoom="2.1854905"\n     inkscape:cx="327.38645"\n     inkscape:cy="233.586"\n     inkscape:window-width="1728"\n     inkscape:window-height="1084"\n     inkscape:window-x="0"\n     inkscape:window-y="33"\n     inkscape:window-maximized="0"\n     inkscape:current-layer="svg1" />\n  <path\n     id="Shape"\n     fill="#000000"\n     fill-rule="evenodd"\n     stroke="none"\n     d="M 73.574318 425.686768 C 72.433441 425.875031 69.474998 425.094574 67 423.952454 C 64.525002 422.810333 61.487499 420.925354 60.25 419.763611 C 58 417.651367 58 417.651367 58 348.144531 C 58 278.637695 58 278.637695 64.15226 268.068848 C 67.536011 262.255981 73.313545 252.549988 76.991226 246.5 C 80.668915 240.450012 89.670906 225.375 96.995644 213 C 104.320389 200.625 112.662483 186.674988 115.533646 182 C 118.4048 177.325012 128.697449 160.120361 138.406174 143.767456 C 148.114914 127.414551 163.517715 101.539551 172.634628 86.267456 C 181.751526 70.995361 190.896469 56.245453 192.956696 53.489868 C 195.254944 50.415955 198.736298 47.372833 201.964966 45.615601 C 205.547699 43.665619 209.185913 42.598907 213.363663 42.27356 C 218.336411 41.886292 220.809326 42.291656 226.404907 44.411316 C 230.202591 45.849945 237.402588 49.329651 242.404907 52.144043 C 247.407211 54.958435 255.774994 59.756927 261 62.807404 C 266.225006 65.857849 274.774994 70.941406 280 74.104187 C 285.225006 77.266937 292.061249 81.349854 295.191681 83.177338 C 298.322083 85.004791 304.593597 88.698059 309.128387 91.384552 C 313.663147 94.071075 319.525085 98.281769 322.154938 100.741699 C 325.42041 103.796173 327.611938 107.003418 329.066864 110.857117 C 330.739197 115.286774 331.103424 118.018188 330.760925 123.56131 C 330.43689 128.805359 329.575104 132.072418 327.412292 136.25589 C 325.810547 139.354187 318.023956 152.826599 310.108765 166.19458 C 302.193604 179.562561 293.868591 193.52121 291.608765 197.213776 C 289.348938 200.906342 284.985504 208.106354 281.912231 213.213776 C 278.838959 218.321198 270.711334 231.950012 263.8508 243.5 C 256.990295 255.049988 247.400177 271.25 242.539444 279.5 C 237.678696 287.75 231.360229 298.325012 228.498383 303 C 225.636551 307.674988 220.191147 316.829224 216.397522 323.342712 C 212.603882 329.856201 205.890396 341.105133 201.478653 348.340332 C 193.756912 361.003967 193.215347 361.63028 186.978653 365.109344 C 183.41539 367.097076 171.620941 373.526276 160.768753 379.396423 C 149.916565 385.266602 131.916565 395.056671 120.768745 401.1521 C 109.620934 407.247559 94.90844 415.184448 88.074318 418.789642 C 81.240189 422.394806 74.715187 425.498535 73.574318 425.686768 Z M 116 376.754456 C 118.096039 376.543518 128.525452 371.474579 142 364.117859 C 154.375 357.361481 165.393753 350.964722 166.486115 349.902863 C 167.980591 348.450134 168.219772 347.57196 167.452347 346.355347 C 166.891403 345.466064 160.147644 341.00293 152.466217 336.437256 C 144.784805 331.871613 135.350006 326.168945 131.5 323.764709 C 127.650002 321.360443 116.453964 314.692322 106.619926 308.946655 C 96.785881 303.200989 87.533401 297.970886 86.058846 297.324219 C 84.417702 296.604492 82.819748 296.493042 81.938927 297.036957 C 80.957619 297.642883 80.340988 300.480957 80 305.960907 C 79.724998 310.380402 79.653214 323.273193 79.840477 334.611572 C 80.180962 355.226837 80.180962 355.226837 83.340477 358.518677 C 85.078217 360.329193 92.349998 365.252136 99.5 369.458588 C 110.254417 375.785583 113.104576 377.045837 116 376.754456 Z M 184.979996 329 C 185.880753 329 187.322388 328.4375 188.183624 327.75 C 189.044861 327.0625 191.986755 322.899994 194.721161 318.5 C 197.455582 314.100006 212.197037 289.575012 227.47995 264 C 242.762863 238.424988 257.119476 214.503387 259.383514 210.840851 C 261.647583 207.178284 265.524994 200.687805 268 196.417542 C 270.475006 192.147247 273.957123 186.14389 275.738068 183.076691 C 277.523224 180.002289 278.981506 176.072205 278.988068 174.317993 C 278.999237 171.335541 278.294434 170.703522 267.75 164.240753 C 261.5625 160.448364 253.125 155.321045 249 152.84668 C 244.875 150.372314 235.754837 144.907379 228.732956 140.702332 C 221.71109 136.497284 212.486084 130.958221 208.232956 128.39328 C 203.979828 125.828369 197.371674 121.899323 193.548157 119.662079 C 189.72464 117.424835 185.418167 115.421448 183.978195 115.210114 C 181.979828 114.916809 180.644867 115.640442 178.338669 118.267059 C 176.676895 120.159729 172.969727 125.711395 170.10054 130.604126 C 167.231339 135.496857 162.066681 144.159821 158.62352 149.855194 C 155.180359 155.550537 149.634521 164.775543 146.299438 170.355194 C 142.964355 175.934845 136.29039 187.024994 131.468384 195 C 126.646393 202.975006 120.571129 213.100006 117.967812 217.5 C 115.364487 221.899994 109.518463 231.575012 104.976639 239 C 100.434822 246.424988 94.708519 255.988464 92.251534 260.252167 C 88.991837 265.908813 87.948189 268.65741 88.390656 270.420349 C 88.845047 272.230804 92.629936 274.990234 103.491547 281.429932 C 111.463524 286.156433 124.176689 293.686981 131.743027 298.16452 C 139.309357 302.642059 149.324997 308.65036 154 311.516296 C 158.675003 314.382263 167.189499 319.488525 172.921127 322.863556 C 178.65274 326.238586 184.079239 329 184.979996 329 Z M 285.661102 134.977844 C 287.97934 134.99408 289.512512 134.179626 291.411102 131.923279 C 292.908417 130.143829 294 127.609955 294 125.913757 C 294 123.644043 293.152191 122.405426 290.25 120.435181 C 288.1875 119.034973 283.720306 116.145264 280.322876 114.01358 C 276.925446 111.881897 270.400452 107.99884 265.822876 105.384521 C 261.2453 102.770203 255.024994 98.976471 252 96.954041 C 248.975006 94.93161 244.25 92.081146 241.5 90.61969 C 238.75 89.158264 233.350006 85.931335 229.5 83.448761 C 224.476532 80.209473 221.661926 79.01474 219.531921 79.217499 C 217.432587 79.417297 215.882141 80.515015 214.234802 82.967804 C 212.798111 85.106964 212.019608 87.555267 212.202881 89.357971 C 212.456848 91.855927 213.807068 93.077637 221.5 97.770203 C 226.449997 100.789642 237.024994 107.196594 245 112.007874 C 252.975006 116.819153 264.674988 123.950684 271 127.855682 C 278.806824 132.675537 283.515167 134.962799 285.661102 134.977844 Z" />\n  <path\n     id="path1"\n     fill="#000000"\n     fill-rule="evenodd"\n     stroke="none"\n     d="M 479.5 119.5 C 479.5 153.5 479.5 153.5 472.5 153.761627 C 468.649994 153.905518 461.225006 154.708954 456 155.547028 C 450.774994 156.385132 443.466675 157.966583 439.759277 159.061371 C 436.05188 160.156189 430.343719 162.619598 427.074493 164.535645 C 423.805267 166.451691 419.672913 169.245789 417.891449 170.744781 C 416.110016 172.243774 412.965179 176.08078 410.902954 179.271454 C 408.507751 182.977295 406.493622 187.858795 405.326721 192.786346 C 403.980774 198.469788 403.509888 204.334198 403.537537 215.067841 C 403.560455 223.970093 404.286011 234.276245 405.403107 241.567841 C 406.408508 248.130524 408.366913 258.674988 409.755096 265 C 411.14325 271.325012 412.907196 279.200012 413.674927 282.5 C 414.442657 285.799988 416.815094 297.049988 418.946991 307.5 C 421.078888 317.950012 423.76297 332.401184 424.911591 339.613708 C 426.481873 349.47406 427 357.319122 427 371.235504 C 427 387.630524 426.716309 390.871338 424.515106 399.621765 C 423.148407 405.05481 420.216461 413.182556 417.999634 417.683472 C 415.167511 423.433655 411.734741 428.242035 406.454742 433.854706 C 401.146912 439.496948 395.939392 443.700836 388.720215 448.171234 C 383.099091 451.652039 375.575012 455.78241 372 457.349823 C 368.424988 458.917206 361.261017 461.749329 356.080017 463.643402 C 350.899017 465.537445 342.574005 467.951355 337.580017 469.007568 C 332.585999 470.063812 324 471.644897 318.5 472.521088 C 311.866943 473.57782 299.745911 474.237183 282.5 474.479462 C 268.200012 474.680359 252 474.489349 246.5 474.054932 C 241 473.620544 230.875 472.51828 224 471.605438 C 217.125 470.692596 207.424561 469.276886 202.443451 468.459412 C 197.462357 467.641907 190.037354 466.282959 185.943451 465.439453 C 181.849548 464.595978 176.25 463.281586 173.5 462.518616 C 170.75 461.755646 165.800003 460.43631 162.5 459.586731 C 159.199997 458.737183 152 456.93927 146.5 455.59137 C 141 454.243469 130.649994 451.291107 123.5 449.030579 C 116.349998 446.77002 108.587502 444.226166 106.25 443.377533 C 103.345978 442.323242 102 441.251038 102 439.992004 C 102 438.763947 105.25164 436.022705 111.75 431.772461 C 117.112503 428.265137 124.951981 423.494568 129.171066 421.171265 C 136.842117 416.947052 136.842117 416.947052 147.671066 419.885193 C 153.626984 421.50116 166.824997 424.88266 177 427.399658 C 187.175003 429.916656 200.449997 432.864655 206.5 433.950775 C 212.550003 435.036896 221.550003 436.377319 226.5 436.929504 C 231.449997 437.481689 241.350006 438.46051 248.5 439.104675 C 256.607147 439.835083 270.156616 440.060425 284.5 439.703461 C 297.763824 439.373352 311.521454 438.469299 317 437.56781 C 322.225006 436.708008 331 434.605408 336.5 432.895386 C 342 431.185333 349.424988 428.45224 353 426.821869 C 356.575012 425.191498 361.75 422.78241 364.5 421.468353 C 367.25 420.154297 372.440887 416.632446 376.035309 413.642029 C 379.923035 410.407593 383.626404 406.239136 385.176788 403.352478 C 386.610199 400.683624 388.82962 395.208862 390.108826 391.18631 C 392.043091 385.103973 392.427551 381.771362 392.392365 371.391907 C 392.368134 364.243286 391.617584 354.764648 390.63559 349.205566 C 389.692627 343.867493 388.22879 335.674988 387.382629 331 C 386.536469 326.325012 384.929169 318.225006 383.810822 313 C 382.692505 307.774994 380.661194 299 379.296814 293.5 C 377.932434 288 375.796661 278.774994 374.55069 273 C 373.304718 267.225006 371.555939 258 370.66452 252.5 C 369.773102 247 368.583893 238.419525 368.021881 233.432281 C 367.459839 228.445038 367.007843 219.445038 367.017456 213.432281 C 367.027069 207.419525 367.668945 198.633209 368.443848 193.907166 C 369.21875 189.181091 370.563477 182.881104 371.432129 179.907166 C 372.300781 176.933228 374.471405 171.682648 376.255737 168.239197 C 378.0401 164.795746 381.511963 159.235352 383.971008 155.882751 C 386.430054 152.530182 392.055054 146.895081 396.471008 143.360352 C 400.886963 139.825592 408.100006 135.196167 412.5 133.072693 C 416.899994 130.949249 424.549988 127.878998 429.5 126.249969 C 434.450012 124.620911 444.125 122.492981 451 121.521179 C 457.875 120.549408 467.100006 119.697083 471.5 119.627167 L 479.5 119.5 Z" />\n  <path\n     id="path2"\n     fill="#B6BCC4"\n     fill-rule="evenodd"\n     stroke="none"\n     d="M 116 375.742615 C 113.270905 375.979401 110.6278 374.942505 104 371.035126 C 99.324997 368.278992 92.867485 364.331085 89.649971 362.261993 C 86.432457 360.192871 83.16996 357.284851 82.399971 355.799683 C 81.305717 353.689026 81 347.452454 81 327.240784 C 81 306.114777 81.26738 301.027008 82.460983 299.441132 C 83.890869 297.541321 84.034538 297.562286 89.210983 300.426575 C 92.119942 302.036163 97.425003 305.010712 101 307.036682 C 104.574997 309.062622 110.100868 312.245667 113.279701 314.110107 C 116.458542 315.974548 123.533379 320.200012 129.001572 323.5 C 134.469757 326.799988 142.838348 331.745026 147.59845 334.488953 C 152.358566 337.232849 158.333725 340.837097 160.876587 342.498352 C 163.445404 344.176575 165.630447 346.4263 165.793533 347.560852 C 166.040268 349.277313 162.373489 351.662323 142.793533 362.520905 C 128.02803 370.709534 118.218613 375.55014 116 375.742615 Z" />\n  <path\n     id="path3"\n     fill="#aaffaa"\n     fill-rule="evenodd"\n     stroke="none"\n     d="M 185.255783 329 C 184.243942 329 179.609955 326.806396 174.958038 324.125366 C 170.306122 321.444336 152.324997 310.802734 135 300.477417 C 117.675003 290.152069 100.349998 279.633148 96.5 277.102051 C 90.249817 272.99295 89.471245 272.125092 89.231583 269 C 89.029724 266.367798 90.047935 263.640442 93.338226 258 C 95.744507 253.875 114.914024 221.924988 135.937164 187 C 156.960297 152.075012 175.408127 121.924988 176.932327 120 C 179.126877 117.228363 180.520828 116.438263 183.630585 116.203308 C 187.107788 115.940613 189.902344 117.306458 208.028793 128.128174 C 219.287949 134.850037 238.175003 146.155121 250 153.25058 C 261.825012 160.346039 273.075012 167.400116 275 168.926331 C 277.098694 170.590271 278.626709 172.762299 278.816498 174.351379 C 279.006622 175.943481 277.794708 179.496368 275.780823 183.250732 C 273.937134 186.687836 254.255646 219.779419 232.044174 256.787598 C 209.832703 293.795776 190.632736 325.183258 189.377579 326.537598 C 188.122437 327.891907 186.267624 329 185.255783 329 Z" />\n</svg>\n';
+const iconP2PSubtractSvg = '<?xml version="1.0" encoding="UTF-8" standalone="no"?>\n<!-- Generated by Pixelmator Pro 3.7 -->\n\n<svg\n   width="512"\n   height="512"\n   viewBox="0 0 512 512"\n   version="1.1"\n   id="svg1"\n   sodipodi:docname="icon-p2p-subtract.svg"\n   inkscape:version="1.4.2 (ebf0e940, 2025-05-08)"\n   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"\n   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"\n   xmlns="http://www.w3.org/2000/svg"\n   xmlns:svg="http://www.w3.org/2000/svg">\n  <defs\n     id="defs1" />\n  <sodipodi:namedview\n     id="namedview1"\n     pagecolor="#ffffff"\n     bordercolor="#000000"\n     borderopacity="0.25"\n     inkscape:showpageshadow="2"\n     inkscape:pageopacity="0.0"\n     inkscape:pagecheckerboard="0"\n     inkscape:deskcolor="#d1d1d1"\n     inkscape:zoom="0.57779708"\n     inkscape:cx="236.24211"\n     inkscape:cy="80.478081"\n     inkscape:window-width="1200"\n     inkscape:window-height="770"\n     inkscape:window-x="218"\n     inkscape:window-y="226"\n     inkscape:window-maximized="0"\n     inkscape:current-layer="svg1"\n     showguides="true">\n    <sodipodi:guide\n       position="294.40467,66.478038"\n       orientation="0,-1"\n       id="guide1"\n       inkscape:locked="false" />\n    <sodipodi:guide\n       position="443.95598,219.9443"\n       orientation="1,0"\n       id="guide2"\n       inkscape:locked="false" />\n    <sodipodi:guide\n       position="479.19058,322.51614"\n       orientation="1,0"\n       id="guide3"\n       inkscape:locked="false" />\n    <sodipodi:guide\n       position="292.83869,31.243437"\n       orientation="0,-1"\n       id="guide4"\n       inkscape:locked="false" />\n    <sodipodi:guide\n       position="263.86802,466.58651"\n       orientation="0,-1"\n       id="guide5"\n       inkscape:locked="false" />\n    <sodipodi:guide\n       position="261.51904,432.1349"\n       orientation="0,-1"\n       id="guide6"\n       inkscape:locked="false" />\n    <sodipodi:guide\n       position="32.885628,329.56306"\n       orientation="1,0"\n       id="guide7"\n       inkscape:locked="false" />\n  </sodipodi:namedview>\n  <path\n     id="path2"\n     fill="#000000"\n     fill-rule="evenodd"\n     stroke="none"\n     d="m 193.81183,478.59424 c -90.05259,0.005 -55.41437,-0.20995 -62.99516,-0.88359 -3.1082,-0.2762 -27.10921,-21.64334 -46.819084,-41.47757 -19.70986,-19.83423 -38.405351,-39.29924 -41.545547,-43.25557 -3.140161,-3.95634 -6.620273,-10.71524 -7.733575,-15.01969 -1.731782,-6.69578 -1.640384,-9.15249 0.632805,-17.00722 2.629257,-9.08499 3.6462,-10.16288 97.354641,-103.18631 67.81987,-67.32409 96.74165,-95.00594 101.89931,-97.5306 4.69396,-2.29769 10.02467,-3.49792 15.30881,-3.44687 5.93187,0.0573 10.33676,1.33387 16.41655,4.7576 5.37383,3.02609 23.90609,20.08661 52.45656,48.29048 24.28094,23.98618 46.73845,47.41164 49.90564,52.05662 4.53335,6.64854 5.89358,10.35999 6.39341,17.4445 0.53601,7.59755 -0.0725,10.28802 -3.90756,17.27501 -3.19113,5.81394 -24.29994,28.16258 -70.95801,75.12564 -36.52859,36.76731 -66.37253,67.62363 -66.92611,68.17388 -19.82934,19.70981 -39.70971,38.18329 -39.48268,38.68369 z M 278.39348,341.263 c -68.04391,-67.49005 -88.70387,-86.89199 -89.81039,-86.65746 -1.10652,0.23458 -27.94601,26.11747 -59.64337,57.51756 -31.697381,31.40008 -57.438314,57.93966 -57.202104,58.97682 0.23622,1.03714 15.75768,17.2724 34.492134,36.07839 34.06266,34.19266 34.06266,34.19266 53.59952,34.19266 19.53691,0 19.53691,0 55.27489,-35.28546 19.65593,-19.40699 41.93704,-41.9313 49.51367,-50.05396 z m 60.93865,-60.02398 c -66.90002,-66.62079 -87.2881,-86.35609 -88.46817,-86.83735 -1.29064,-0.52641 -8.78712,5.68385 -18.81344,15.58544 l -16.66788,16.46053 44.40871,44.02713 c 24.42482,24.21491 44.78655,44.02712 45.24827,44.02712 0.46173,0 8.36641,-7.48416 17.56604,-16.63144 z"\n     style="stroke-width:1.5931"\n     sodipodi:nodetypes="csssssssscssssssccsssssssccsscsscc" />\n  <path\n     style="fill:#800000;fill-opacity:1;stroke:#010101;stroke-width:7.48758"\n     d="m 214.60419,225.76607 35.34452,-32.835 89.30798,87.87273 -34.08219,33.77315 z"\n     id="path3" />\n  <path\n     style="fill:#000000;fill-opacity:1;stroke:none;stroke-width:35;stroke-dasharray:none;stroke-opacity:1"\n     d="m 238.70454,480.61597 240.58456,-0.0328 0,-435.375911 L 32.679361,44.8696 32.918466,80.474658 444.02166,79.593154 443.68404,445.58764 274.55795,445.01091 Z"\n     id="path7"\n     sodipodi:nodetypes="ccccccccc" />\n  <circle\n     style="fill:#000000;fill-opacity:1;stroke:none;stroke-width:35;stroke-dasharray:none;stroke-opacity:1"\n     id="path8"\n     cx="460.39642"\n     cy="461.54739"\n     r="39.133694" />\n  <circle\n     style="fill:#000000;fill-opacity:1;stroke:none;stroke-width:35;stroke-dasharray:none;stroke-opacity:1"\n     id="path8-8"\n     cx="460.77478"\n     cy="65.833855"\n     r="39.133694" />\n  <circle\n     style="fill:#000000;fill-opacity:1;stroke:none;stroke-width:35;stroke-dasharray:none;stroke-opacity:1"\n     id="path8-8-0"\n     cx="67.175827"\n     cy="62.81522"\n     r="39.133694" />\n</svg>\n';
+const iconDrawSvg = '<?xml version="1.0" encoding="UTF-8" standalone="no"?>\n<!-- Generated by Pixelmator Pro 3.7 -->\n\n<svg\n   width="512"\n   height="512"\n   viewBox="0 0 512 512"\n   version="1.1"\n   id="svg1"\n   sodipodi:docname="icon-draw.svg"\n   inkscape:version="1.4.2 (ebf0e940, 2025-05-08)"\n   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"\n   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"\n   xmlns="http://www.w3.org/2000/svg"\n   xmlns:svg="http://www.w3.org/2000/svg">\n  <defs\n     id="defs1" />\n  <sodipodi:namedview\n     id="namedview1"\n     pagecolor="#ffffff"\n     bordercolor="#000000"\n     borderopacity="0.25"\n     inkscape:showpageshadow="2"\n     inkscape:pageopacity="0.0"\n     inkscape:pagecheckerboard="0"\n     inkscape:deskcolor="#d1d1d1"\n     inkscape:zoom="1.4901425"\n     inkscape:cx="137.2352"\n     inkscape:cy="249.97609"\n     inkscape:window-width="1728"\n     inkscape:window-height="1056"\n     inkscape:window-x="0"\n     inkscape:window-y="61"\n     inkscape:window-maximized="0"\n     inkscape:current-layer="svg1" />\n  <path\n     id="Shape"\n     fill="#000000"\n     fill-rule="evenodd"\n     stroke="none"\n     d="M 73.574318 425.686768 C 72.433441 425.875031 69.474998 425.094574 67 423.952454 C 64.525002 422.810333 61.487499 420.925354 60.25 419.763611 C 58 417.651367 58 417.651367 58 348.144531 C 58 278.637695 58 278.637695 64.15226 268.068848 C 67.536011 262.255981 73.313545 252.549988 76.991226 246.5 C 80.668915 240.450012 89.670906 225.375 96.995644 213 C 104.320389 200.625 112.662483 186.674988 115.533646 182 C 118.4048 177.325012 128.697449 160.120361 138.406174 143.767456 C 148.114914 127.414551 163.517715 101.539551 172.634628 86.267456 C 181.751526 70.995361 190.896469 56.245453 192.956696 53.489868 C 195.254944 50.415955 198.736298 47.372833 201.964966 45.615601 C 205.547699 43.665619 209.185913 42.598907 213.363663 42.27356 C 218.336411 41.886292 220.809326 42.291656 226.404907 44.411316 C 230.202591 45.849945 237.402588 49.329651 242.404907 52.144043 C 247.407211 54.958435 255.774994 59.756927 261 62.807404 C 266.225006 65.857849 274.774994 70.941406 280 74.104187 C 285.225006 77.266937 292.061249 81.349854 295.191681 83.177338 C 298.322083 85.004791 304.593597 88.698059 309.128387 91.384552 C 313.663147 94.071075 319.525085 98.281769 322.154938 100.741699 C 325.42041 103.796173 327.611938 107.003418 329.066864 110.857117 C 330.739197 115.286774 331.103424 118.018188 330.760925 123.56131 C 330.43689 128.805359 329.575104 132.072418 327.412292 136.25589 C 325.810547 139.354187 318.023956 152.826599 310.108765 166.19458 C 302.193604 179.562561 293.868591 193.52121 291.608765 197.213776 C 289.348938 200.906342 284.985504 208.106354 281.912231 213.213776 C 278.838959 218.321198 270.711334 231.950012 263.8508 243.5 C 256.990295 255.049988 247.400177 271.25 242.539444 279.5 C 237.678696 287.75 231.360229 298.325012 228.498383 303 C 225.636551 307.674988 220.191147 316.829224 216.397522 323.342712 C 212.603882 329.856201 205.890396 341.105133 201.478653 348.340332 C 193.756912 361.003967 193.215347 361.63028 186.978653 365.109344 C 183.41539 367.097076 171.620941 373.526276 160.768753 379.396423 C 149.916565 385.266602 131.916565 395.056671 120.768745 401.1521 C 109.620934 407.247559 94.90844 415.184448 88.074318 418.789642 C 81.240189 422.394806 74.715187 425.498535 73.574318 425.686768 Z M 116 376.754456 C 118.096039 376.543518 128.525452 371.474579 142 364.117859 C 154.375 357.361481 165.393753 350.964722 166.486115 349.902863 C 167.980591 348.450134 168.219772 347.57196 167.452347 346.355347 C 166.891403 345.466064 160.147644 341.00293 152.466217 336.437256 C 144.784805 331.871613 135.350006 326.168945 131.5 323.764709 C 127.650002 321.360443 116.453964 314.692322 106.619926 308.946655 C 96.785881 303.200989 87.533401 297.970886 86.058846 297.324219 C 84.417702 296.604492 82.819748 296.493042 81.938927 297.036957 C 80.957619 297.642883 80.340988 300.480957 80 305.960907 C 79.724998 310.380402 79.653214 323.273193 79.840477 334.611572 C 80.180962 355.226837 80.180962 355.226837 83.340477 358.518677 C 85.078217 360.329193 92.349998 365.252136 99.5 369.458588 C 110.254417 375.785583 113.104576 377.045837 116 376.754456 Z M 184.979996 329 C 185.880753 329 187.322388 328.4375 188.183624 327.75 C 189.044861 327.0625 191.986755 322.899994 194.721161 318.5 C 197.455582 314.100006 212.197037 289.575012 227.47995 264 C 242.762863 238.424988 257.119476 214.503387 259.383514 210.840851 C 261.647583 207.178284 265.524994 200.687805 268 196.417542 C 270.475006 192.147247 273.957123 186.14389 275.738068 183.076691 C 277.523224 180.002289 278.981506 176.072205 278.988068 174.317993 C 278.999237 171.335541 278.294434 170.703522 267.75 164.240753 C 261.5625 160.448364 253.125 155.321045 249 152.84668 C 244.875 150.372314 235.754837 144.907379 228.732956 140.702332 C 221.71109 136.497284 212.486084 130.958221 208.232956 128.39328 C 203.979828 125.828369 197.371674 121.899323 193.548157 119.662079 C 189.72464 117.424835 185.418167 115.421448 183.978195 115.210114 C 181.979828 114.916809 180.644867 115.640442 178.338669 118.267059 C 176.676895 120.159729 172.969727 125.711395 170.10054 130.604126 C 167.231339 135.496857 162.066681 144.159821 158.62352 149.855194 C 155.180359 155.550537 149.634521 164.775543 146.299438 170.355194 C 142.964355 175.934845 136.29039 187.024994 131.468384 195 C 126.646393 202.975006 120.571129 213.100006 117.967812 217.5 C 115.364487 221.899994 109.518463 231.575012 104.976639 239 C 100.434822 246.424988 94.708519 255.988464 92.251534 260.252167 C 88.991837 265.908813 87.948189 268.65741 88.390656 270.420349 C 88.845047 272.230804 92.629936 274.990234 103.491547 281.429932 C 111.463524 286.156433 124.176689 293.686981 131.743027 298.16452 C 139.309357 302.642059 149.324997 308.65036 154 311.516296 C 158.675003 314.382263 167.189499 319.488525 172.921127 322.863556 C 178.65274 326.238586 184.079239 329 184.979996 329 Z M 285.661102 134.977844 C 287.97934 134.99408 289.512512 134.179626 291.411102 131.923279 C 292.908417 130.143829 294 127.609955 294 125.913757 C 294 123.644043 293.152191 122.405426 290.25 120.435181 C 288.1875 119.034973 283.720306 116.145264 280.322876 114.01358 C 276.925446 111.881897 270.400452 107.99884 265.822876 105.384521 C 261.2453 102.770203 255.024994 98.976471 252 96.954041 C 248.975006 94.93161 244.25 92.081146 241.5 90.61969 C 238.75 89.158264 233.350006 85.931335 229.5 83.448761 C 224.476532 80.209473 221.661926 79.01474 219.531921 79.217499 C 217.432587 79.417297 215.882141 80.515015 214.234802 82.967804 C 212.798111 85.106964 212.019608 87.555267 212.202881 89.357971 C 212.456848 91.855927 213.807068 93.077637 221.5 97.770203 C 226.449997 100.789642 237.024994 107.196594 245 112.007874 C 252.975006 116.819153 264.674988 123.950684 271 127.855682 C 278.806824 132.675537 283.515167 134.962799 285.661102 134.977844 Z"\n     style="stroke:#000000;stroke-opacity:1;stroke-width:20;stroke-dasharray:none" />\n  <path\n     id="path1"\n     fill="#000000"\n     fill-rule="evenodd"\n     stroke="none"\n     d="M 479.5 119.5 C 479.5 153.5 479.5 153.5 472.5 153.761627 C 468.649994 153.905518 461.225006 154.708954 456 155.547028 C 450.774994 156.385132 443.466675 157.966583 439.759277 159.061371 C 436.05188 160.156189 430.343719 162.619598 427.074493 164.535645 C 423.805267 166.451691 419.672913 169.245789 417.891449 170.744781 C 416.110016 172.243774 412.965179 176.08078 410.902954 179.271454 C 408.507751 182.977295 406.493622 187.858795 405.326721 192.786346 C 403.980774 198.469788 403.509888 204.334198 403.537537 215.067841 C 403.560455 223.970093 404.286011 234.276245 405.403107 241.567841 C 406.408508 248.130524 408.366913 258.674988 409.755096 265 C 411.14325 271.325012 412.907196 279.200012 413.674927 282.5 C 414.442657 285.799988 416.815094 297.049988 418.946991 307.5 C 421.078888 317.950012 423.76297 332.401184 424.911591 339.613708 C 426.481873 349.47406 427 357.319122 427 371.235504 C 427 387.630524 426.716309 390.871338 424.515106 399.621765 C 423.148407 405.05481 420.216461 413.182556 417.999634 417.683472 C 415.167511 423.433655 411.734741 428.242035 406.454742 433.854706 C 401.146912 439.496948 395.939392 443.700836 388.720215 448.171234 C 383.099091 451.652039 375.575012 455.78241 372 457.349823 C 368.424988 458.917206 361.261017 461.749329 356.080017 463.643402 C 350.899017 465.537445 342.574005 467.951355 337.580017 469.007568 C 332.585999 470.063812 324 471.644897 318.5 472.521088 C 311.866943 473.57782 299.745911 474.237183 282.5 474.479462 C 268.200012 474.680359 252 474.489349 246.5 474.054932 C 241 473.620544 230.875 472.51828 224 471.605438 C 217.125 470.692596 207.424561 469.276886 202.443451 468.459412 C 197.462357 467.641907 190.037354 466.282959 185.943451 465.439453 C 181.849548 464.595978 176.25 463.281586 173.5 462.518616 C 170.75 461.755646 165.800003 460.43631 162.5 459.586731 C 159.199997 458.737183 152 456.93927 146.5 455.59137 C 141 454.243469 130.649994 451.291107 123.5 449.030579 C 116.349998 446.77002 108.587502 444.226166 106.25 443.377533 C 103.345978 442.323242 102 441.251038 102 439.992004 C 102 438.763947 105.25164 436.022705 111.75 431.772461 C 117.112503 428.265137 124.951981 423.494568 129.171066 421.171265 C 136.842117 416.947052 136.842117 416.947052 147.671066 419.885193 C 153.626984 421.50116 166.824997 424.88266 177 427.399658 C 187.175003 429.916656 200.449997 432.864655 206.5 433.950775 C 212.550003 435.036896 221.550003 436.377319 226.5 436.929504 C 231.449997 437.481689 241.350006 438.46051 248.5 439.104675 C 256.607147 439.835083 270.156616 440.060425 284.5 439.703461 C 297.763824 439.373352 311.521454 438.469299 317 437.56781 C 322.225006 436.708008 331 434.605408 336.5 432.895386 C 342 431.185333 349.424988 428.45224 353 426.821869 C 356.575012 425.191498 361.75 422.78241 364.5 421.468353 C 367.25 420.154297 372.440887 416.632446 376.035309 413.642029 C 379.923035 410.407593 383.626404 406.239136 385.176788 403.352478 C 386.610199 400.683624 388.82962 395.208862 390.108826 391.18631 C 392.043091 385.103973 392.427551 381.771362 392.392365 371.391907 C 392.368134 364.243286 391.617584 354.764648 390.63559 349.205566 C 389.692627 343.867493 388.22879 335.674988 387.382629 331 C 386.536469 326.325012 384.929169 318.225006 383.810822 313 C 382.692505 307.774994 380.661194 299 379.296814 293.5 C 377.932434 288 375.796661 278.774994 374.55069 273 C 373.304718 267.225006 371.555939 258 370.66452 252.5 C 369.773102 247 368.583893 238.419525 368.021881 233.432281 C 367.459839 228.445038 367.007843 219.445038 367.017456 213.432281 C 367.027069 207.419525 367.668945 198.633209 368.443848 193.907166 C 369.21875 189.181091 370.563477 182.881104 371.432129 179.907166 C 372.300781 176.933228 374.471405 171.682648 376.255737 168.239197 C 378.0401 164.795746 381.511963 159.235352 383.971008 155.882751 C 386.430054 152.530182 392.055054 146.895081 396.471008 143.360352 C 400.886963 139.825592 408.100006 135.196167 412.5 133.072693 C 416.899994 130.949249 424.549988 127.878998 429.5 126.249969 C 434.450012 124.620911 444.125 122.492981 451 121.521179 C 457.875 120.549408 467.100006 119.697083 471.5 119.627167 L 479.5 119.5 Z" />\n  <path\n     id="path2"\n     fill="#B6BCC4"\n     fill-rule="evenodd"\n     stroke="none"\n     d="M 116 375.742615 C 113.270905 375.979401 110.6278 374.942505 104 371.035126 C 99.324997 368.278992 92.867485 364.331085 89.649971 362.261993 C 86.432457 360.192871 83.16996 357.284851 82.399971 355.799683 C 81.305717 353.689026 81 347.452454 81 327.240784 C 81 306.114777 81.26738 301.027008 82.460983 299.441132 C 83.890869 297.541321 84.034538 297.562286 89.210983 300.426575 C 92.119942 302.036163 97.425003 305.010712 101 307.036682 C 104.574997 309.062622 110.100868 312.245667 113.279701 314.110107 C 116.458542 315.974548 123.533379 320.200012 129.001572 323.5 C 134.469757 326.799988 142.838348 331.745026 147.59845 334.488953 C 152.358566 337.232849 158.333725 340.837097 160.876587 342.498352 C 163.445404 344.176575 165.630447 346.4263 165.793533 347.560852 C 166.040268 349.277313 162.373489 351.662323 142.793533 362.520905 C 128.02803 370.709534 118.218613 375.55014 116 375.742615 Z" />\n</svg>\n';
+const iconSubtractSvg = '<svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg"><g id="SVGRepo_bgCarrier" stroke-width="0"></g><g id="SVGRepo_tracerCarrier" stroke-linecap="round" stroke-linejoin="round"></g><g id="SVGRepo_iconCarrier"> <path fill-rule="evenodd" clip-rule="evenodd" d="M15.0722 3.9967L20.7508 9.83395L17.0544 13.5304L13.0758 17.5H21.0041V19H7.93503L4.00195 15.0669L15.0722 3.9967ZM10.952 17.5L15.4628 12.9994L11.8268 9.3634L6.12327 15.0669L8.55635 17.5H10.952Z" fill="#1F2328"></path> </g></svg>\n';
+const iconP2PDrawSvg = '<?xml version="1.0" encoding="UTF-8" standalone="no"?>\n<!-- Generated by Pixelmator Pro 3.7 -->\n\n<svg\n   width="512"\n   height="512"\n   viewBox="0 0 512 512"\n   version="1.1"\n   id="svg1"\n   sodipodi:docname="icon-p2p-draw.svg"\n   inkscape:version="1.4.2 (ebf0e940, 2025-05-08)"\n   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"\n   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"\n   xmlns="http://www.w3.org/2000/svg"\n   xmlns:svg="http://www.w3.org/2000/svg">\n  <defs\n     id="defs1" />\n  <sodipodi:namedview\n     id="namedview1"\n     pagecolor="#ffffff"\n     bordercolor="#000000"\n     borderopacity="0.25"\n     inkscape:showpageshadow="2"\n     inkscape:pageopacity="0.0"\n     inkscape:pagecheckerboard="0"\n     inkscape:deskcolor="#d1d1d1"\n     inkscape:zoom="0.54892083"\n     inkscape:cx="330.64878"\n     inkscape:cy="521.93319"\n     inkscape:window-width="1200"\n     inkscape:window-height="770"\n     inkscape:window-x="197"\n     inkscape:window-y="106"\n     inkscape:window-maximized="0"\n     inkscape:current-layer="svg1"\n     showguides="true">\n    <sodipodi:guide\n       position="294.40467,66.478038"\n       orientation="0,-1"\n       id="guide1"\n       inkscape:locked="false" />\n    <sodipodi:guide\n       position="443.95598,219.9443"\n       orientation="1,0"\n       id="guide2"\n       inkscape:locked="false" />\n    <sodipodi:guide\n       position="479.19058,322.51614"\n       orientation="1,0"\n       id="guide3"\n       inkscape:locked="false" />\n    <sodipodi:guide\n       position="292.83869,31.243437"\n       orientation="0,-1"\n       id="guide4"\n       inkscape:locked="false" />\n    <sodipodi:guide\n       position="263.86802,466.58651"\n       orientation="0,-1"\n       id="guide5"\n       inkscape:locked="false" />\n    <sodipodi:guide\n       position="261.51904,432.1349"\n       orientation="0,-1"\n       id="guide6"\n       inkscape:locked="false" />\n    <sodipodi:guide\n       position="32.885628,329.56306"\n       orientation="1,0"\n       id="guide7"\n       inkscape:locked="false" />\n  </sodipodi:namedview>\n  <path\n     style="fill:#000000;fill-opacity:1;stroke:none;stroke-width:35;stroke-dasharray:none;stroke-opacity:1"\n     d="m 155.32706,480.61597 323.96204,-0.0328 V 45.207259 L 32.679361,44.8696 32.918466,80.474658 444.02166,79.593154 443.68404,445.58764 274.55795,445.01091 Z"\n     id="path7"\n     sodipodi:nodetypes="ccccccccc" />\n  <circle\n     style="fill:#000000;fill-opacity:1;stroke:none;stroke-width:35;stroke-dasharray:none;stroke-opacity:1"\n     id="path8"\n     cx="460.39642"\n     cy="461.54739"\n     r="39.133694" />\n  <circle\n     style="fill:#000000;fill-opacity:1;stroke:none;stroke-width:35;stroke-dasharray:none;stroke-opacity:1"\n     id="path8-8"\n     cx="460.77478"\n     cy="65.833855"\n     r="39.133694" />\n  <circle\n     style="fill:#000000;fill-opacity:1;stroke:none;stroke-width:35;stroke-dasharray:none;stroke-opacity:1"\n     id="path8-8-0"\n     cx="67.175827"\n     cy="62.81522"\n     r="39.133694" />\n  <path\n     id="path2"\n     fill="#000000"\n     fill-rule="evenodd"\n     stroke="none"\n     d="m 78.98285,469.62959 c -2.15438,0.59403 -4.66097,-0.18539 -6.41628,-1.99508 -1.75454,-1.80897 -2.51146,-4.39507 -1.93619,-6.61526 0.51947,-2.00492 2.03533,-7.53933 3.36857,-12.29873 1.33325,-4.75939 4.30224,-15.27334 6.59779,-23.36429 2.29555,-8.09095 6.15891,-21.33074 8.58529,-29.42169 2.42637,-8.09095 6.68243,-22.49895 9.45793,-32.01774 2.77548,-9.51878 6.84771,-23.53737 9.04937,-31.15238 2.20168,-7.61501 5.9929,-20.46541 8.42494,-28.55636 2.43204,-8.09095 5.73937,-19.44463 7.34962,-25.23035 1.61019,-5.78571 4.963,-13.27069 7.45058,-16.63326 3.19549,-4.31937 8.82764,-8.13446 19.19001,-12.99886 8.06689,-3.78683 22.22096,-10.28684 31.45345,-14.44449 9.23249,-4.15765 20.18557,-9.15989 24.34021,-11.11606 4.15463,-1.95616 10.95307,-5.04935 15.10771,-6.87384 4.15464,-1.82444 8.50009,-4.18148 9.65667,-5.23786 1.67549,-1.53041 1.53724,-3.40502 -0.68062,-9.22612 -2.27058,-5.95966 -2.43594,-8.49812 -0.89757,-13.77907 1.22082,-4.19103 5.93592,-10.61436 13.37263,-18.21733 6.77176,-6.92313 13.88209,-12.5016 17.32193,-13.59009 4.56226,-1.44363 7.10301,-1.27942 11.64815,0.75263 3.42626,1.5319 23.38864,20.75839 48.61827,46.82593 23.54283,24.3248 45.07136,47.06101 47.84109,50.52486 3.87236,4.84285 5.0359,8.02217 5.0359,13.76037 0,6.66353 -0.98839,8.54701 -9.23249,17.59373 -5.07785,5.57218 -11.80914,12.26634 -14.95838,14.87589 -4.16093,3.44791 -7.61435,4.74461 -12.63592,4.74461 -3.8005,0 -8.65254,-1.25835 -10.78224,-2.79631 -2.1797,-1.57404 -4.50585,-2.14145 -5.3218,-1.29801 -0.79727,0.82403 -5.18683,10.45458 -9.75461,21.4012 -4.56774,10.94662 -11.46849,27.28897 -15.33492,36.3164 -3.86636,9.02739 -10.0263,22.88636 -13.68865,30.79773 -4.61767,9.97496 -8.2174,15.36144 -11.7432,17.57213 -2.79644,1.75334 -10.87912,5.15636 -17.96148,7.56231 -7.0824,2.40588 -20.43095,6.74835 -29.66344,9.64992 -9.2325,2.90152 -25.66143,8.03285 -36.50872,11.40295 -10.8473,3.37012 -31.2427,9.76063 -45.32314,14.20118 -14.08045,4.4406 -32.77692,10.28616 -41.54781,12.9901 -8.77088,2.70399 -17.53807,5.35501 -19.48265,5.89124 z m 33.10612,-25.66048 c 3.12446,-0.52416 14.55766,-3.75462 25.40714,-7.17876 10.84946,-3.4242 33.51103,-10.53042 50.35905,-15.79168 16.84799,-5.2612 39.69735,-12.37246 50.77636,-15.80282 14.11491,-4.3703 21.4678,-7.59596 24.56816,-10.77783 2.43353,-2.49749 8.0037,-13.10782 12.3782,-23.57846 4.37444,-10.47065 10.39747,-24.87865 13.3844,-32.01773 2.98694,-7.13909 8.32653,-19.60006 11.86571,-27.69101 3.53919,-8.09095 6.70998,-17.0473 7.04619,-19.90292 0.55531,-4.71704 -2.16136,-8.0423 -29.69233,-36.34445 -16.66695,-17.1338 -31.77968,-31.39614 -33.58378,-31.69408 -1.80414,-0.29788 -24.6359,9.2685 -50.73726,21.25867 -26.10136,11.99017 -49.09048,23.38251 -51.08698,25.31628 -1.99652,1.93377 -4.8623,7.74509 -6.36841,12.91403 -1.50609,5.16898 -4.69492,16.21648 -7.08629,24.55002 -2.39131,8.33358 -6.53304,22.55059 -9.20379,31.59346 -2.67075,9.04286 -9.07606,30.84953 -14.23398,48.45926 -5.15796,17.60974 -10.02791,34.72173 -10.82216,38.02655 -0.79426,3.30483 -1.1287,6.33395 -0.7432,6.73146 0.38545,0.39738 3.17643,-1.23918 6.20211,-3.63684 3.02568,-2.39771 17.96511,-17.53251 33.19873,-33.63296 15.23362,-16.1004 31.64089,-33.57371 36.46062,-38.82946 8.52144,-9.29247 8.71621,-9.73111 7.06247,-15.9062 -1.16333,-4.34377 -1.14253,-8.48706 0.0656,-13.11331 1.09469,-4.19134 4.27547,-9.10021 8.36474,-12.90922 3.64809,-3.39805 9.2643,-6.66174 12.56077,-7.29928 4.51031,-0.87242 7.90041,-0.1587 13.9207,2.93089 4.84417,2.48596 9.2219,6.36014 11.18725,9.90054 1.77588,3.19904 3.29934,9.20131 3.38545,13.33846 0.0891,4.28531 -1.16789,10.05847 -2.92143,13.41647 -1.69287,3.24193 -6.10927,7.65094 -9.81417,9.79783 -5.66863,3.2847 -8.24032,3.72914 -16.22634,2.80428 -9.49006,-1.09911 -9.49006,-1.09911 -49.7773,40.47775 -22.15799,22.86729 -40.57747,42.46953 -40.93217,43.56045 -0.43839,1.34819 1.17468,1.67829 5.03591,1.03061 z m 90.33008,-98.22453 c 3.35455,0 6.05979,-1.50174 8.52436,-4.73208 2.60114,-3.40941 3.33739,-6.13886 2.63399,-9.76503 -0.53698,-2.76815 -2.29563,-6.0656 -3.90813,-7.32768 -1.61249,-1.26211 -5.13852,-2.31954 -7.83556,-2.34981 -2.69703,-0.0303 -6.28515,1.23389 -7.97352,2.80925 -1.80844,1.68737 -3.06977,5.24293 -3.06977,8.65344 0,3.48156 1.33823,7.16888 3.35727,9.25053 1.84652,1.90378 5.56862,3.46138 8.27136,3.46138 z m 133.61012,-53.65133 c 1.97597,0 7.95481,-4.72004 14.17476,-11.19037 10.06607,-10.47129 10.6202,-11.45446 8.62363,-15.30071 -1.17346,-2.26069 -22.06639,-24.65026 -46.42867,-49.7546 -28.88352,-29.76325 -45.48253,-45.6442 -47.70791,-45.6442 -1.91767,0 -7.85057,4.5222 -13.54224,10.32229 -7.35863,7.49881 -9.99677,11.39096 -9.64468,14.22899 0.30251,2.43813 17.51825,21.46819 45.79618,50.62263 29.62007,30.53813 46.49498,46.71597 48.72893,46.71597 z"\n     style="stroke:#010101;stroke-width:17.0446;stroke-dasharray:none;stroke-opacity:1" />\n  <path\n     style="fill:#008000;fill-opacity:1;stroke:none;stroke-width:18.6862;stroke-dasharray:none;stroke-opacity:1"\n     d="m 243.54683,189.37604 16.45863,-15.44233 96.74466,96.71773 -16.45865,16.25509 z"\n     id="path3" />\n  <circle\n     style="fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:35;stroke-dasharray:none;stroke-opacity:1"\n     id="path9"\n     cx="201.17783"\n     cy="332.21527"\n     r="13.593097" />\n</svg>\n';
+const iconEraseSvg = '<?xml version="1.0" encoding="utf-8"?>\n<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"\n	 viewBox="0 0 48 48" style="enable-background:new 0 0 48 48;" xml:space="preserve">\n<style type="text/css">\n	.st0{fill:#000000}\n	.st1{fill:#333333;fill-opacity:0;}\n</style>\n<title>trash</title>\n<rect class="st1" width="48" height="48"/>\n<polygon class="st0" points="26.6,10 26.6,7.8 21.4,7.8 21.4,10 12.6,10 12.6,12.8 35.4,12.8 35.4,10 "/>\n<path class="st0" d="M35.4,15.4H12.6v4.3h1.8V37c0,1.1,0.9,2,2,2h15.2c1.1,0,2-0.9,2-2V19.7h1.8V15.4z M19.7,34.2c0,0.5-0.4,1-1,1\n	c-0.5,0-1-0.4-1-1V22.6c0-0.5,0.4-1,1-1c0.5,0,1,0.4,1,1V34.2z M25.3,33.8c0,0.7-0.6,1.3-1.3,1.3c-0.7,0-1.3-0.6-1.3-1.3V23\n	c0-0.7,0.6-1.3,1.3-1.3c0.7,0,1.3,0.6,1.3,1.3V33.8z M30.3,34.2c0,0.5-0.4,1-1,1c-0.5,0-1-0.4-1-1V22.6c0-0.5,0.4-1,1-1\n	c0.5,0,1,0.4,1,1V34.2z"/>\n</svg>\n';
+const iconCollapseSvg = '<?xml version="1.0" encoding="UTF-8" standalone="no"?>\n<!-- Generated by Pixelmator Pro 3.7 -->\n\n<svg\n   width="512"\n   height="512"\n   viewBox="0 0 512 512"\n   version="1.1"\n   id="svg1"\n   sodipodi:docname="icon-collapse.svg"\n   inkscape:version="1.4.2 (ebf0e940, 2025-05-08)"\n   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"\n   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"\n   xmlns="http://www.w3.org/2000/svg"\n   xmlns:svg="http://www.w3.org/2000/svg">\n  <defs\n     id="defs1" />\n  <sodipodi:namedview\n     id="namedview1"\n     pagecolor="#ffffff"\n     bordercolor="#000000"\n     borderopacity="0.25"\n     inkscape:showpageshadow="2"\n     inkscape:pageopacity="0.0"\n     inkscape:pagecheckerboard="0"\n     inkscape:deskcolor="#d1d1d1"\n     inkscape:zoom="3.390154"\n     inkscape:cx="264.14729"\n     inkscape:cy="179.04791"\n     inkscape:window-width="1352"\n     inkscape:window-height="797"\n     inkscape:window-x="66"\n     inkscape:window-y="34"\n     inkscape:window-maximized="0"\n     inkscape:current-layer="svg1"\n     showguides="true">\n    <sodipodi:guide\n       position="166.90161,256"\n       orientation="0,1"\n       id="guide2"\n       inkscape:locked="false"\n       inkscape:label=""\n       inkscape:color="rgb(0,134,229)" />\n    <sodipodi:guide\n       position="256,314.14084"\n       orientation="-1,0"\n       id="guide3"\n       inkscape:locked="false"\n       inkscape:label=""\n       inkscape:color="rgb(0,134,229)" />\n    <sodipodi:guide\n       position="299.13272,431.6881"\n       orientation="0,-1"\n       id="guide4"\n       inkscape:locked="false" />\n    <sodipodi:guide\n       position="80,297.83494"\n       orientation="-1,0"\n       id="guide5"\n       inkscape:locked="false"\n       inkscape:label=""\n       inkscape:color="rgb(0,134,229)" />\n    <sodipodi:guide\n       position="432,400.26171"\n       orientation="-1,0"\n       id="guide6"\n       inkscape:locked="false"\n       inkscape:label=""\n       inkscape:color="rgb(0,134,229)" />\n  </sodipodi:namedview>\n  <path\n     style="fill:none;stroke:#000000;stroke-width:25;stroke-dasharray:none;stroke-opacity:1"\n     d="M 80.032872,292.14907 255.78789,117.55799 431.54291,292.14907 v 0 0"\n     id="path6" />\n  <path\n     style="fill:none;stroke:#000000;stroke-width:25;stroke-dasharray:none;stroke-opacity:1"\n     d="M 80.104821,394.53856 255.85984,219.94748 431.61486,394.53856 v 0 0"\n     id="path6-5" />\n</svg>\n';
+const sanitizeSvg = (svg) => svg.replace(/<\?xml[^>]*\?>\s*/g, "").replace(/<!--[\s\S]*?-->/g, "").trim();
+const icons = {
+  activate: sanitizeSvg(iconPolydraw2Svg),
+  draw: sanitizeSvg(iconDrawSvg),
+  subtract: sanitizeSvg(iconSubtractSvg),
+  p2p: sanitizeSvg(iconP2PDrawSvg),
+  p2pSubtract: sanitizeSvg(iconP2PSubtractSvg),
+  erase: sanitizeSvg(iconEraseSvg),
+  collapse: sanitizeSvg(iconCollapseSvg)
+};
+const setButtonIcon = (button, svgMarkup) => {
+  button.innerHTML = svgMarkup;
+  const svgElement = button.querySelector("svg");
+  if (!svgElement) return;
+  svgElement.setAttribute("width", "24");
+  svgElement.setAttribute("height", "24");
+  svgElement.style.pointerEvents = "none";
+  svgElement.querySelectorAll("*").forEach((el) => {
+    el.style.pointerEvents = "none";
+  });
+};
+function createButtons(container, subContainer, config, onActivateToggle, onDrawClick, onSubtractClick, onEraseClick, onPointToPointClick, onPointToPointSubtractClick) {
+  const activate = leafletAdapter.domUtil.create(
+    "a",
+    "icon-activate",
+    container
+  );
+  activate.href = "#";
+  activate.title = "Activate";
+  setButtonIcon(activate, icons.activate);
+  activate.dataset.activeIcon = icons.activate;
+  activate.dataset.collapsedIcon = icons.collapse;
+  L$1.DomEvent.on(activate, "mousedown", L$1.DomEvent.stopPropagation);
+  L$1.DomEvent.on(activate, "touchstart", L$1.DomEvent.stopPropagation);
+  L$1.DomEvent.on(activate, "click", L$1.DomEvent.stop).on(activate, "click", onActivateToggle);
+  if (config.modes.draw) {
+    const draw = leafletAdapter.domUtil.create("a", "icon-draw", subContainer);
+    draw.href = "#";
+    draw.title = "Draw";
+    setButtonIcon(draw, icons.draw);
+    L$1.DomEvent.on(draw, "mousedown", L$1.DomEvent.stopPropagation);
+    L$1.DomEvent.on(draw, "touchstart", L$1.DomEvent.stopPropagation);
+    L$1.DomEvent.on(draw, "click", L$1.DomEvent.stopPropagation);
+    L$1.DomEvent.on(draw, "click", L$1.DomEvent.stop);
+    L$1.DomEvent.on(draw, "click", onDrawClick);
+  }
+  if (config.modes.subtract) {
+    const subtract = leafletAdapter.domUtil.create(
+      "a",
+      "icon-subtract",
+      subContainer
+    );
+    subtract.href = "#";
+    subtract.title = "Subtract";
+    setButtonIcon(subtract, icons.subtract);
+    L$1.DomEvent.on(subtract, "mousedown", L$1.DomEvent.stopPropagation);
+    L$1.DomEvent.on(subtract, "touchstart", L$1.DomEvent.stopPropagation);
+    L$1.DomEvent.on(subtract, "click", L$1.DomEvent.stopPropagation);
+    L$1.DomEvent.on(subtract, "click", L$1.DomEvent.stop);
+    L$1.DomEvent.on(subtract, "click", onSubtractClick);
+  }
+  if (config.modes.p2p) {
+    const p2p = leafletAdapter.domUtil.create("a", "icon-p2p", subContainer);
+    p2p.href = "#";
+    p2p.title = "Point to Point";
+    setButtonIcon(p2p, icons.p2p);
+    L$1.DomEvent.on(p2p, "mousedown", L$1.DomEvent.stopPropagation);
+    L$1.DomEvent.on(p2p, "touchstart", L$1.DomEvent.stopPropagation);
+    L$1.DomEvent.on(p2p, "click", L$1.DomEvent.stopPropagation);
+    L$1.DomEvent.on(p2p, "click", L$1.DomEvent.stop);
+    L$1.DomEvent.on(p2p, "click", onPointToPointClick);
+  }
+  if (config.modes.p2pSubtract) {
+    const p2pSubtract = leafletAdapter.domUtil.create(
+      "a",
+      "icon-p2p-subtract",
+      subContainer
+    );
+    p2pSubtract.href = "#";
+    p2pSubtract.title = "Point to Point Subtract";
+    setButtonIcon(p2pSubtract, icons.p2pSubtract);
+    L$1.DomEvent.on(p2pSubtract, "mousedown", L$1.DomEvent.stopPropagation);
+    L$1.DomEvent.on(p2pSubtract, "touchstart", L$1.DomEvent.stopPropagation);
+    L$1.DomEvent.on(p2pSubtract, "click", L$1.DomEvent.stopPropagation);
+    L$1.DomEvent.on(p2pSubtract, "click", L$1.DomEvent.stop);
+    L$1.DomEvent.on(p2pSubtract, "click", onPointToPointSubtractClick);
+  }
+  if (config.modes.deleteAll) {
+    const erase = leafletAdapter.domUtil.create(
+      "a",
+      "icon-erase",
+      subContainer
+    );
+    erase.href = "#";
+    erase.title = "Erase All";
+    setButtonIcon(erase, icons.erase);
+    L$1.DomEvent.on(erase, "mousedown", L$1.DomEvent.stopPropagation);
+    L$1.DomEvent.on(erase, "touchstart", L$1.DomEvent.stopPropagation);
+    L$1.DomEvent.on(erase, "click", L$1.DomEvent.stopPropagation);
+    L$1.DomEvent.on(erase, "click", L$1.DomEvent.stop);
+    L$1.DomEvent.on(erase, "click", onEraseClick);
+  }
+}
+class PolygonUtil {
+  /**
+   * Calculates the center of the polygon.
+   * @param polygon Array of LatLng points.
+   * @returns The center LatLng.
+   */
+  static getCenter(polygon2) {
+    let x = 0;
+    let y = 0;
+    let z = 0;
+    polygon2.forEach((v) => {
+      let lat1 = v.lat;
+      let lon1 = v.lng;
+      lat1 = lat1 * MATH.DEG_TO_RAD;
+      lon1 = lon1 * MATH.DEG_TO_RAD;
+      x += Math.cos(lat1) * Math.cos(lon1);
+      y += Math.cos(lat1) * Math.sin(lon1);
+      z += Math.sin(lat1);
+    });
+    let lng = Math.atan2(y, x);
+    const hyp = Math.sqrt(x * x + y * y);
+    let lat = Math.atan2(z, hyp);
+    lat = lat * MATH.RAD_TO_DEG;
+    lng = lng * MATH.RAD_TO_DEG;
+    const center2 = { lat, lng };
+    return center2;
+  }
+  /**
+   * Gets the southwest point of the polygon bounds.
+   * @param polygon Array of LatLng points.
+   * @returns The southwest LatLng.
+   */
+  static getSouthWest(polygon2) {
+    const bounds = this.getBounds(polygon2);
+    return bounds.getSouthWest();
+  }
+  static getNorthEast(polygon2) {
+    const bounds = this.getBounds(polygon2);
+    return bounds.getNorthEast();
+  }
+  static getNorthWest(polygon2) {
+    const bounds = this.getBounds(polygon2);
+    return bounds.getNorthWest();
+  }
+  static getSouthEast(polygon2) {
+    const bounds = this.getBounds(polygon2);
+    return bounds.getSouthEast();
+  }
+  static getNorth(polygon2) {
+    const bounds = this.getBounds(polygon2);
+    return bounds.getNorth();
+  }
+  static getSouth(polygon2) {
+    const bounds = this.getBounds(polygon2);
+    return bounds.getSouth();
+  }
+  static getWest(polygon2) {
+    const bounds = this.getBounds(polygon2);
+    return bounds.getWest();
+  }
+  static getEast(polygon2) {
+    const bounds = this.getBounds(polygon2);
+    return bounds.getEast();
+  }
+  static getSqmArea(polygon2) {
+    const poly = new L$1.Polygon(polygon2);
+    const geoJsonPoly = poly.toGeoJSON();
+    const area2 = this.turfHelper.getPolygonArea(geoJsonPoly);
+    return area2;
+  }
+  static getPerimeter(polygon2) {
+    const poly = new L$1.Polygon(polygon2);
+    const geoJsonPoly = poly.toGeoJSON();
+    const perimeter = this.turfHelper.getPolygonPerimeter(geoJsonPoly);
+    return perimeter * 1e3;
   }
   static getPolygonChecksum(polygon2) {
     const uniqueLatLngs = polygon2.filter((v, i, a) => {
@@ -17399,7 +18165,7 @@ class PolygonUtil {
       if (isNaN(ll.lat) || isNaN(ll.lng)) ;
       tmpLatLng.push(ll);
     });
-    const polyLine = new L.Polyline(tmpLatLng);
+    const polyLine = new L$1.Polyline(tmpLatLng);
     const bounds = polyLine.getBounds();
     return bounds;
   }
@@ -17415,6 +18181,60 @@ class PolygonUtil {
       lng: centerOfMass2.geometry.coordinates[0]
     };
   }
+  static getCenterOfPolygonByIndexWithOffsetFromCenterOfMass(polygon2, index) {
+    const centerOfMass2 = this.turfHelper.getCenterOfMass(polygon2);
+    const centerLatLng = {
+      lat: centerOfMass2.geometry.coordinates[1],
+      lng: centerOfMass2.geometry.coordinates[0]
+    };
+    const centerOfPolygonMarker = this.getPolygonLatLngAtIndex(polygon2, index) ?? centerLatLng;
+    const offset = {
+      lat: centerOfPolygonMarker.lat - centerLatLng.lat,
+      lng: centerOfPolygonMarker.lng - centerLatLng.lng
+    };
+    const offsetFraction = 0.5;
+    const adjustedLat = centerLatLng.lat + offset.lat * offsetFraction;
+    const adjustedLng = centerLatLng.lng + offset.lng * offsetFraction;
+    const newCenterOfMass = {
+      geometry: {
+        coordinates: [adjustedLng, adjustedLat]
+      }
+    };
+    return {
+      lat: newCenterOfMass.geometry.coordinates[1],
+      lng: newCenterOfMass.geometry.coordinates[0]
+    };
+  }
+  static getPolygonLatLngAtIndex(polygon2, index) {
+    const geometry = polygon2.geometry;
+    if (!geometry) {
+      return null;
+    }
+    let coordinates;
+    if (geometry.type === "Polygon") {
+      coordinates = geometry.coordinates[0];
+    } else if (geometry.type === "MultiPolygon") {
+      coordinates = geometry.coordinates[0][0];
+    } else {
+      return null;
+    }
+    if (!coordinates || coordinates.length === 0) {
+      return null;
+    }
+    if (coordinates.length > 1) {
+      const first = coordinates[0];
+      const last = coordinates[coordinates.length - 1];
+      if (first[0] === last[0] && first[1] === last[1]) {
+        coordinates = coordinates.slice(0, coordinates.length - 1);
+      }
+    }
+    if (coordinates.length === 0) {
+      return null;
+    }
+    const normalizedIndex = (index % coordinates.length + coordinates.length) % coordinates.length;
+    const selected = coordinates[normalizedIndex];
+    return { lat: selected[1], lng: selected[0] };
+  }
 }
 __publicField(PolygonUtil, "turfHelper", new TurfHelper(defaultConfig));
 class PolygonInfo {
@@ -17723,6 +18543,7 @@ class ModeManager {
         this.setDrawingModeState();
         break;
       case DrawMode.PointToPoint:
+      case DrawMode.PointToPointSubtract:
         this.setPointToPointModeState();
         break;
     }
@@ -17952,15 +18773,15 @@ class PolygonDrawManager {
     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({
+      const pointMarker = new L$1.Marker(clickLatLng, {
+        icon: leafletAdapter.createDivIcon({
           className: markerClassName,
           iconSize: isFirstMarker ? [20, 20] : [16, 16]
         }),
         draggable: this.config.modes.dragElbow
       }).addTo(this.map);
       pointMarker.on("mousedown", (e) => {
-        L.DomEvent.stopPropagation(e);
+        L$1.DomEvent.stopPropagation(e);
       });
       pointMarker.on("drag", () => {
         this.updateP2PTracer();
@@ -17968,7 +18789,7 @@ class PolygonDrawManager {
       pointMarker.on("click", (e) => {
         if (this.isModifierKeyHeld && this.config.modes.edgeDeletion) {
           this.deleteP2PMarker(pointMarker);
-          L.DomEvent.stopPropagation(e);
+          L$1.DomEvent.stopPropagation(e);
         }
       });
       pointMarker.on("mouseover", () => this.onMarkerHoverForEdgeDeletion(pointMarker, true));
@@ -17997,11 +18818,11 @@ class PolygonDrawManager {
         pointMarker.on("click", (e) => {
           if (this.isModifierKeyHeld && this.config.modes.edgeDeletion) {
             this.deleteP2PMarker(pointMarker);
-            L.DomEvent.stopPropagation(e);
+            L$1.DomEvent.stopPropagation(e);
             return;
           }
           if (this.p2pMarkers.length >= 3) {
-            L.DomEvent.stopPropagation(e);
+            L$1.DomEvent.stopPropagation(e);
             this.completePointToPointPolygon();
           }
         });
@@ -18015,7 +18836,18 @@ class PolygonDrawManager {
    * Handle double-click to complete point-to-point polygon
    */
   handleDoubleClick(e) {
-    if (this.modeManager.getCurrentMode() !== DrawMode.PointToPoint) {
+    if (this.modeManager.getCurrentMode() !== DrawMode.PointToPoint && this.modeManager.getCurrentMode() !== DrawMode.PointToPointSubtract) {
+      return;
+    }
+    if (this.p2pMarkers.length >= 3) {
+      this.completePointToPointPolygon();
+    }
+  }
+  /**
+   * Handle double-tap to complete point-to-point polygon (touch devices)
+   */
+  handleDoubleTap(_e) {
+    if (this.modeManager.getCurrentMode() !== DrawMode.PointToPoint && this.modeManager.getCurrentMode() !== DrawMode.PointToPointSubtract) {
       return;
     }
     if (this.p2pMarkers.length >= 3) {
@@ -18043,7 +18875,7 @@ class PolygonDrawManager {
       this.resetTracer();
       this.eventManager.emit("polydraw:polygon:created", {
         polygon: geoPos,
-        mode: DrawMode.PointToPoint,
+        mode: this.modeManager.getCurrentMode(),
         isPointToPoint: true
       });
     } catch (error) {
@@ -18090,12 +18922,22 @@ class PolygonDrawManager {
     if (!firstPoint) return false;
     const zoom = this.map.getZoom();
     const baseTolerance = 5e-4;
-    const tolerance = baseTolerance / Math.pow(2, Math.max(0, zoom - 10));
+    let tolerance = baseTolerance / Math.pow(2, Math.max(0, zoom - 10));
+    if (this.isTouchDevice()) {
+      tolerance *= 5;
+    }
+    tolerance *= 3;
     const latDiff = Math.abs(clickLatLng.lat - firstPoint.lat);
     const lngDiff = Math.abs(clickLatLng.lng - firstPoint.lng);
     const isClicking = latDiff < tolerance && lngDiff < tolerance;
     return isClicking;
   }
+  /**
+   * Check if the current device supports touch
+   */
+  isTouchDevice() {
+    return isTouchDevice();
+  }
   /**
    * Update the tracer polyline based on P2P markers
    */
@@ -18104,8 +18946,10 @@ class PolygonDrawManager {
     this.tracer.setLatLngs(latlngs);
     if (this.p2pMarkers.length >= 2) {
       try {
+        const currentMode = this.modeManager.getCurrentMode();
+        const lineColor = currentMode === DrawMode.PointToPointSubtract ? this.config.colors.subtractLine : this.config.colors.polyline;
         this.tracer.setStyle({
-          color: this.config.colors.polyline,
+          color: lineColor,
           dashArray: "5, 5"
         });
       } catch (error) {
@@ -18143,7 +18987,8 @@ class PolygonDrawManager {
    * Check if currently in point-to-point drawing mode
    */
   isInPointToPointMode() {
-    return this.modeManager.getCurrentMode() === DrawMode.PointToPoint;
+    const mode = this.modeManager.getCurrentMode();
+    return mode === DrawMode.PointToPoint || mode === DrawMode.PointToPointSubtract;
   }
   /**
    * Get current tracer points count
@@ -18162,7 +19007,7 @@ class PolygonDrawManager {
     if (element) {
       element.classList.add("leaflet-polydraw-p2p-first-marker");
       firstMarker.setIcon(
-        L.divIcon({
+        leafletAdapter.createDivIcon({
           className: "leaflet-polydraw-p2p-marker leaflet-polydraw-p2p-first-marker",
           iconSize: [20, 20]
         })
@@ -18194,11 +19039,11 @@ class PolygonDrawManager {
     firstMarker.on("click", (e) => {
       if (this.isModifierKeyHeld && this.config.modes.edgeDeletion) {
         this.deleteP2PMarker(firstMarker);
-        L.DomEvent.stopPropagation(e);
+        L$1.DomEvent.stopPropagation(e);
         return;
       }
       if (this.p2pMarkers.length >= 3) {
-        L.DomEvent.stopPropagation(e);
+        L$1.DomEvent.stopPropagation(e);
         this.completePointToPointPolygon();
       }
     });
@@ -18561,7 +19406,688 @@ class IconFactory {
    */
   static createDivIcon(classNames) {
     const classes = classNames.join(" ");
-    return L.divIcon({ className: classes });
+    return leafletAdapter.createDivIcon({ className: classes });
+  }
+}
+var TransformHandleType = /* @__PURE__ */ ((TransformHandleType2) => {
+  TransformHandleType2["TopLeft"] = "top-left";
+  TransformHandleType2["Top"] = "top";
+  TransformHandleType2["TopRight"] = "top-right";
+  TransformHandleType2["Right"] = "right";
+  TransformHandleType2["BottomRight"] = "bottom-right";
+  TransformHandleType2["Bottom"] = "bottom";
+  TransformHandleType2["BottomLeft"] = "bottom-left";
+  TransformHandleType2["Left"] = "left";
+  TransformHandleType2["Rotate"] = "rotate";
+  TransformHandleType2["Pivot"] = "pivot";
+  return TransformHandleType2;
+})(TransformHandleType || {});
+const cancelIconSvg = '<?xml version="1.0" encoding="UTF-8"?>\n<svg width="512" height="512" viewBox="0 0 512 512" xmlns="http://www.w3.org/2000/svg">\n  <circle cx="256" cy="256" r="236" fill="#212A32"/>\n  <circle cx="256" cy="256" r="190" fill="#ffffff"/>\n  <path id="path2" fill="#800000" fill-rule="evenodd" stroke="none"\n        d="M 156 373.906311 C 140.875 373.871002 127.9375 373.615112 127.25 373.337708 C 126.5625 373.060303 126 372.072937 126 371.143555 C 126 370.214203 146.628433 343.53772 171.840973 311.862488 C 197.053513 280.187286 217.991867 253.463562 218.370667 252.47644 C 218.806335 251.341125 218.221786 249.464233 216.779678 247.368073 C 215.525864 245.545563 196.612503 221.361847 174.75 193.626465 C 152.887497 165.891052 135 142.531311 135 141.715881 C 135 140.900421 136.012497 139.961914 137.25 139.63028 C 138.487503 139.298645 152.408203 139.021179 168.184906 139.013641 C 184.588272 139.005859 197.976456 139.420746 199.454529 139.982727 C 201.182831 140.639801 210.486664 152.319733 227.533463 175.232727 C 241.555283 194.079712 253.994949 210.166199 255.177185 210.980438 C 257.208252 212.379272 257.562622 212.186401 261.607452 207.480438 C 263.961853 204.74118 276.052643 189 288.47583 172.5 C 300.899048 156 312.286682 141.714874 313.781738 140.75528 C 316.198669 139.203949 319.554993 139.009949 344.058868 139.00528 C 366.27774 139.001007 371.993561 139.274811 373.557343 140.418274 C 375.458923 141.808746 375.448914 141.90155 373.046875 145.150452 C 371.699341 146.973114 352.828827 170.746307 331.112396 197.979767 C 309.395966 225.213257 291.465973 248.396271 291.267914 249.497589 C 291.012512 250.91803 304.435944 268.61731 337.453918 310.395416 C 363.05426 342.787903 384 370.077271 384 371.038422 C 384 371.999603 383.288208 373.059174 382.418213 373.393005 C 381.548218 373.726868 367.485718 373.993347 351.168213 373.98526 C 329.591888 373.974548 320.854309 373.633606 319.132629 372.73526 C 317.830597 372.055847 302.980591 353.049988 286.132629 330.5 C 260.059052 295.602051 255.12793 289.5 253 289.5 C 250.878326 289.5 245.808807 295.701355 219.5 330.479431 C 202.449997 353.018127 187.375 372.023987 186 372.714691 C 184.165009 373.636475 176.184906 373.95343 156 373.906311 Z"/>\n</svg>';
+const confirmIconSvg = '<?xml version="1.0" encoding="UTF-8"?>\n<svg width="512" height="512" viewBox="0 0 512 512" xmlns="http://www.w3.org/2000/svg">\n  <circle cx="256" cy="256" r="236" fill="#212A32"/>\n  <circle cx="256" cy="256" r="190" fill="#ffffff"/>\n  <path id="check" fill="#008000" fill-rule="evenodd" stroke="none"\n        d="M 223.844696 360 C 222.79425 360 204.506973 341.170593 178.987274 313.812744 \n           C 144.992401 277.369232 135.966232 267.145691 136.201645 265.351257 \n           C 136.396179 263.868408 143.092361 257.073425 155.444672 245.824249 \n           C 166.363129 235.880859 175.214264 228.571442 176.336426 228.571442 \n           C 177.515594 228.571442 181.716553 232.304138 186.987961 238.035706 \n           C 191.775406 243.241058 201.629044 254.024994 208.884933 262 \n           C 216.140823 269.975006 222.682266 276.635315 223.421478 276.80072 \n           C 224.16246 276.966553 247.742722 250.494751 275.976837 217.800751 \n           C 304.143097 185.185333 328.050385 157.879608 329.104156 157.121368 \n           C 330.785767 155.911316 331.44046 156.0336 334.457672 158.121368 \n           C 336.348328 159.429626 345.368622 167.190216 354.502747 175.367126 \n           C 367.688812 187.171356 371.047394 190.689819 370.805115 192.445557 \n           C 370.635864 193.67218 338.242889 231.469543 298.059082 277.32843 \n           C 253.148834 328.581238 224.944153 360 223.844696 360 Z"/>\n</svg>';
+class TransformOverlay {
+  constructor(map, callbacks, mode, onCancel, onConfirm) {
+    __publicField(this, "map");
+    __publicField(this, "pane");
+    __publicField(this, "root");
+    __publicField(this, "draggingHandle", null);
+    __publicField(this, "callbacks");
+    __publicField(this, "rafId", null);
+    __publicField(this, "mode");
+    __publicField(this, "onCancel");
+    __publicField(this, "onConfirm");
+    __publicField(this, "cancelBtn", null);
+    __publicField(this, "confirmBtn", null);
+    __publicField(this, "currentBBox", null);
+    __publicField(this, "currentRotation", 0);
+    this.map = map;
+    this.callbacks = callbacks;
+    this.mode = mode;
+    this.onCancel = onCancel;
+    this.onConfirm = onConfirm;
+    const paneName = "polydraw-transform";
+    let pane = this.map.getPane ? this.map.getPane(paneName) : void 0;
+    if (!pane) pane = this.map.createPane(paneName);
+    pane.style.zIndex = "650";
+    pane.style.pointerEvents = "none";
+    this.pane = pane;
+    this.root = document.createElement("div");
+    this.root.className = "polydraw-transform-root";
+    this.root.style.position = "absolute";
+    this.root.style.left = "0px";
+    this.root.style.top = "0px";
+    this.pane.appendChild(this.root);
+  }
+  destroy() {
+    if (this.rafId != null) {
+      cancelAnimationFrame(this.rafId);
+      this.rafId = null;
+    }
+    this.root.remove();
+  }
+  update(bbox2, pivot, rotation = 0) {
+    if (this.rafId != null) return;
+    this.rafId = requestAnimationFrame(() => {
+      this.rafId = null;
+      this.render(bbox2, pivot, rotation);
+      if (this.cancelBtn || this.confirmBtn) {
+        const isRotateDrag = this.draggingHandle === TransformHandleType.Rotate && this.mode === "rotate";
+        if (!isRotateDrag) {
+          this.updateButtonPositions(bbox2, rotation);
+        }
+      }
+    });
+  }
+  render(bbox2, _pivot, rotation = 0) {
+    const cancelBtn = this.cancelBtn;
+    const confirmBtn = this.confirmBtn;
+    this.root.innerHTML = "";
+    this.currentBBox = bbox2;
+    this.currentRotation = rotation;
+    this.cancelBtn = cancelBtn;
+    this.confirmBtn = confirmBtn;
+    const width = bbox2.maxX - bbox2.minX;
+    const height = bbox2.maxY - bbox2.minY;
+    const centerX = bbox2.minX + width / 2;
+    const centerY = bbox2.minY + height / 2;
+    const box = document.createElement("div");
+    box.className = "polydraw-transform-box";
+    Object.assign(box.style, {
+      position: "absolute",
+      left: `${centerX}px`,
+      top: `${centerY}px`,
+      width: `${width}px`,
+      height: `${height}px`,
+      marginLeft: `${-width / 2}px`,
+      marginTop: `${-height / 2}px`,
+      border: "1px dashed #2b90d9",
+      pointerEvents: "none",
+      transformOrigin: "center center",
+      transform: `rotate(${rotation * 180 / Math.PI}deg)`
+    });
+    this.root.appendChild(box);
+    const makeHandle = (type, x, y) => {
+      const dx = x - centerX;
+      const dy = y - centerY;
+      const cos2 = Math.cos(rotation);
+      const sin2 = Math.sin(rotation);
+      const rotX = centerX + dx * cos2 - dy * sin2;
+      const rotY = centerY + dx * sin2 + dy * cos2;
+      const h = document.createElement("div");
+      h.className = `polydraw-transform-handle handle-${type}`;
+      Object.assign(h.style, {
+        position: "absolute",
+        left: `${rotX - 5}px`,
+        top: `${rotY - 5}px`,
+        width: "10px",
+        height: "10px",
+        borderRadius: "2px",
+        background: "#2b90d9",
+        boxShadow: "0 0 0 1px #fff",
+        cursor: this.cursorForHandle(type),
+        pointerEvents: "auto"
+      });
+      L$1.DomEvent.on(h, "mousedown", (e) => this.startDrag(type, { x: rotX, y: rotY }, e));
+      L$1.DomEvent.on(h, "touchstart", (e) => this.startDrag(type, { x: rotX, y: rotY }, e));
+      this.root.appendChild(h);
+    };
+    if (this.mode === "scale") {
+      makeHandle(TransformHandleType.TopLeft, bbox2.minX, bbox2.minY);
+      makeHandle(TransformHandleType.TopRight, bbox2.maxX, bbox2.minY);
+      makeHandle(TransformHandleType.BottomRight, bbox2.maxX, bbox2.maxY);
+      makeHandle(TransformHandleType.BottomLeft, bbox2.minX, bbox2.maxY);
+      makeHandle(TransformHandleType.Top, centerX, bbox2.minY);
+      makeHandle(TransformHandleType.Right, bbox2.maxX, centerY);
+      makeHandle(TransformHandleType.Bottom, centerX, bbox2.maxY);
+      makeHandle(TransformHandleType.Left, bbox2.minX, centerY);
+    } else {
+      makeHandle(TransformHandleType.Rotate, bbox2.minX, bbox2.minY);
+      makeHandle(TransformHandleType.Rotate, bbox2.maxX, bbox2.minY);
+      makeHandle(TransformHandleType.Rotate, bbox2.maxX, bbox2.maxY);
+      makeHandle(TransformHandleType.Rotate, bbox2.minX, bbox2.maxY);
+    }
+    if (!this.cancelBtn && !this.confirmBtn) {
+      this.updateButtonPositions(bbox2, rotation);
+    } else {
+      this.updateButtonPositions(bbox2, rotation);
+      if (this.cancelBtn) this.root.appendChild(this.cancelBtn);
+      if (this.confirmBtn) this.root.appendChild(this.confirmBtn);
+    }
+  }
+  cursorForHandle(type) {
+    switch (type) {
+      case TransformHandleType.Top:
+      case TransformHandleType.Bottom:
+        return "ns-resize";
+      case TransformHandleType.Left:
+      case TransformHandleType.Right:
+        return "ew-resize";
+      case TransformHandleType.TopLeft:
+      case TransformHandleType.BottomRight:
+        return "nwse-resize";
+      case TransformHandleType.TopRight:
+      case TransformHandleType.BottomLeft:
+        return "nesw-resize";
+      case TransformHandleType.Rotate:
+        return "grab";
+      case TransformHandleType.Pivot:
+        return "move";
+      default:
+        return "default";
+    }
+  }
+  startDrag(type, start, evt) {
+    var _a2, _b2;
+    (_a2 = evt.stopPropagation) == null ? void 0 : _a2.call(evt);
+    (_b2 = evt.preventDefault) == null ? void 0 : _b2.call(evt);
+    this.draggingHandle = type;
+    if (type === TransformHandleType.Rotate && this.mode === "rotate") {
+      this.hideButtons();
+    }
+    const onMove = (e) => this.onDrag(e);
+    const onUp = (e) => this.endDrag(e);
+    L$1.DomEvent.on(document, "mousemove", onMove);
+    L$1.DomEvent.on(document, "mouseup", onUp);
+    L$1.DomEvent.on(document, "touchmove", onMove);
+    L$1.DomEvent.on(document, "touchend", onUp);
+    this.callbacks.onStartHandleDrag(type, start, evt);
+  }
+  onDrag(evt) {
+    if (this.draggingHandle == null) return;
+    const pos = this.getMouseLayerPoint(evt);
+    this.callbacks.onDragHandle(this.draggingHandle, pos, evt);
+  }
+  endDrag(evt) {
+    if (this.draggingHandle == null) return;
+    const type = this.draggingHandle;
+    const wasRotateDrag = type === TransformHandleType.Rotate && this.mode === "rotate";
+    this.draggingHandle = null;
+    const pos = this.getMouseLayerPoint(evt);
+    this.callbacks.onEndHandleDrag(type, pos, evt);
+    if (wasRotateDrag && this.currentBBox) {
+      this.updateButtonPositions(this.currentBBox, this.currentRotation);
+      this.showButtons();
+    }
+    L$1.DomEvent.off(document, "mousemove", this.onDrag);
+    L$1.DomEvent.off(document, "touchmove", this.onDrag);
+  }
+  getMouseLayerPoint(evt) {
+    const containerPoint = this.map.mouseEventToContainerPoint ? this.map.mouseEventToContainerPoint(evt) : leafletAdapter.domEvent.getMousePosition(evt, this.map.getContainer());
+    const layerPoint = this.map.containerPointToLayerPoint(containerPoint);
+    return { x: layerPoint.x, y: layerPoint.y };
+  }
+  updateButtonPositions(bbox2, rotation) {
+    const width = bbox2.maxX - bbox2.minX;
+    const height = bbox2.maxY - bbox2.minY;
+    const centerX = bbox2.minX + width / 2;
+    const centerY = bbox2.minY + height / 2;
+    const corners = [
+      { x: bbox2.minX, y: bbox2.minY },
+      // top-left
+      { x: bbox2.maxX, y: bbox2.minY },
+      // top-right
+      { x: bbox2.maxX, y: bbox2.maxY },
+      // bottom-right
+      { x: bbox2.minX, y: bbox2.maxY }
+      // bottom-left
+    ];
+    const cos2 = Math.cos(rotation);
+    const sin2 = Math.sin(rotation);
+    let topRightCorner = { x: 0, y: Infinity };
+    let minY = Infinity;
+    for (const corner of corners) {
+      const dx = corner.x - centerX;
+      const dy = corner.y - centerY;
+      const rotX = centerX + dx * cos2 - dy * sin2;
+      const rotY = centerY + dx * sin2 + dy * cos2;
+      const isHigher = rotY < minY;
+      const isSameHeight = Math.abs(rotY - minY) < 1;
+      const isMoreRight = rotX > topRightCorner.x;
+      if (isHigher || isSameHeight && isMoreRight) {
+        minY = rotY;
+        topRightCorner = { x: rotX, y: rotY };
+      }
+    }
+    const rotTopRightX = topRightCorner.x;
+    const rotTopRightY = topRightCorner.y;
+    const buttonY = rotTopRightY - 28;
+    const confirmX = rotTopRightX + 5;
+    const cancelX = rotTopRightX - 29;
+    const cancelSvg = cancelIconSvg;
+    const confirmSvg = confirmIconSvg;
+    if (this.onCancel && !this.cancelBtn) {
+      this.cancelBtn = document.createElement("div");
+      this.cancelBtn.className = "polydraw-transform-cancel";
+      this.cancelBtn.innerHTML = cancelSvg;
+      L$1.DomEvent.on(this.cancelBtn, "mousedown", (e) => {
+        var _a2, _b2;
+        (_a2 = e.stopPropagation) == null ? void 0 : _a2.call(e);
+        (_b2 = e.preventDefault) == null ? void 0 : _b2.call(e);
+        this.onCancel && this.onCancel();
+      });
+      L$1.DomEvent.on(this.cancelBtn, "touchstart", (e) => {
+        var _a2, _b2;
+        (_a2 = e.stopPropagation) == null ? void 0 : _a2.call(e);
+        (_b2 = e.preventDefault) == null ? void 0 : _b2.call(e);
+        this.onCancel && this.onCancel();
+      });
+      this.root.appendChild(this.cancelBtn);
+    }
+    if (this.onConfirm && !this.confirmBtn) {
+      this.confirmBtn = document.createElement("div");
+      this.confirmBtn.className = "polydraw-transform-confirm";
+      this.confirmBtn.innerHTML = confirmSvg;
+      L$1.DomEvent.on(this.confirmBtn, "mousedown", (e) => {
+        var _a2, _b2;
+        (_a2 = e.stopPropagation) == null ? void 0 : _a2.call(e);
+        (_b2 = e.preventDefault) == null ? void 0 : _b2.call(e);
+        this.onConfirm && this.onConfirm();
+      });
+      L$1.DomEvent.on(this.confirmBtn, "touchstart", (e) => {
+        var _a2, _b2;
+        (_a2 = e.stopPropagation) == null ? void 0 : _a2.call(e);
+        (_b2 = e.preventDefault) == null ? void 0 : _b2.call(e);
+        this.onConfirm && this.onConfirm();
+      });
+      this.root.appendChild(this.confirmBtn);
+    }
+    if (this.cancelBtn) {
+      Object.assign(this.cancelBtn.style, {
+        position: "absolute",
+        left: `${cancelX}px`,
+        top: `${buttonY}px`
+      });
+    }
+    if (this.confirmBtn) {
+      Object.assign(this.confirmBtn.style, {
+        position: "absolute",
+        left: `${confirmX}px`,
+        top: `${buttonY}px`
+      });
+    }
+  }
+  hideButtons() {
+    if (this.cancelBtn) this.cancelBtn.style.display = "none";
+    if (this.confirmBtn) this.confirmBtn.style.display = "none";
+  }
+  showButtons() {
+    if (this.cancelBtn) this.cancelBtn.style.display = "";
+    if (this.confirmBtn) this.confirmBtn.style.display = "";
+  }
+}
+function latLngToPixel(map, ll) {
+  const p = map.latLngToLayerPoint(ll);
+  return { x: p.x, y: p.y };
+}
+function pixelToLatLng(map, p) {
+  const ll = map.layerPointToLatLng(leafletAdapter.createPoint(p.x, p.y));
+  return { lat: ll.lat, lng: ll.lng };
+}
+function getPixelBBox(rings) {
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const poly of rings) {
+    for (const ring of poly) {
+      for (const pt of ring) {
+        if (pt.x < minX) minX = pt.x;
+        if (pt.y < minY) minY = pt.y;
+        if (pt.x > maxX) maxX = pt.x;
+        if (pt.y > maxY) maxY = pt.y;
+      }
+    }
+  }
+  return { minX, minY, maxX, maxY };
+}
+function getPixelCentroid(bbox2) {
+  return { x: (bbox2.minX + bbox2.maxX) / 2, y: (bbox2.minY + bbox2.maxY) / 2 };
+}
+function rotatePointAround(p, pivot, radians2) {
+  const cos2 = Math.cos(radians2);
+  const sin2 = Math.sin(radians2);
+  const dx = p.x - pivot.x;
+  const dy = p.y - pivot.y;
+  return { x: pivot.x + dx * cos2 - dy * sin2, y: pivot.y + dx * sin2 + dy * cos2 };
+}
+function scalePointAround(p, pivot, scaleX, scaleY) {
+  const dx = p.x - pivot.x;
+  const dy = p.y - pivot.y;
+  return { x: pivot.x + dx * scaleX, y: pivot.y + dy * scaleY };
+}
+function applyTransform(rings, pivot, scaleX, scaleY, rotation) {
+  return rings.map(
+    (poly) => poly.map(
+      (ring) => ring.map(
+        (pt) => rotatePointAround(scalePointAround(pt, pivot, scaleX, scaleY), pivot, rotation)
+      )
+    )
+  );
+}
+function ensureClosedLatLngRing(ll) {
+  if (ll.length === 0) return ll;
+  const first = ll[0];
+  const last = ll[ll.length - 1];
+  if (first.lat === last.lat && first.lng === last.lng) return ll;
+  return [...ll, { lat: first.lat, lng: first.lng }];
+}
+function normalizeLatLngs(input) {
+  if (!Array.isArray(input)) {
+    return [[input]];
+  }
+  const a = input;
+  if (a.length === 0) return [];
+  if (!Array.isArray(a[0])) {
+    return [[input]];
+  }
+  if (!Array.isArray(a[0][0])) {
+    return [input];
+  }
+  return input;
+}
+function projectLatLngs(map, latLngs) {
+  const rings = [];
+  const ringLengths = [];
+  for (const poly of latLngs) {
+    const polyRings = [];
+    const lengths = [];
+    for (const ring of poly) {
+      const pts = ring.map((ll) => latLngToPixel(map, { lat: ll.lat, lng: ll.lng }));
+      polyRings.push(pts);
+      lengths.push(ring.length);
+    }
+    rings.push(polyRings);
+    ringLengths.push(lengths);
+  }
+  return { rings, ringLengths };
+}
+function unprojectToLatLngs(map, rings, templateLatLngs) {
+  const out = [];
+  for (let i = 0; i < rings.length; i++) {
+    const poly = [];
+    for (let j = 0; j < rings[i].length; j++) {
+      const ringPts = rings[i][j];
+      const ll = ringPts.map((p) => pixelToLatLng(map, p));
+      const templ = templateLatLngs[i][j];
+      const isClosed = templ.length > 2 && templ[0].lat === templ[templ.length - 1].lat && templ[0].lng === templ[templ.length - 1].lng;
+      poly.push(isClosed ? ensureClosedLatLngRing(ll) : ll);
+    }
+    out.push(poly);
+  }
+  return out;
+}
+function snapAngleRadians(angle, stepDeg = 15) {
+  const step = stepDeg * Math.PI / 180;
+  return Math.round(angle / step) * step;
+}
+class PolygonTransformController {
+  constructor(map, featureGroup, mode = "scale", onExit) {
+    __publicField(this, "map");
+    __publicField(this, "polygon");
+    __publicField(this, "overlay");
+    __publicField(this, "state");
+    __publicField(this, "normalizedLatLngs");
+    __publicField(this, "wasMapDraggingEnabled", false);
+    __publicField(this, "mode");
+    __publicField(this, "onExit");
+    __publicField(this, "rotateStartAngle", null);
+    __publicField(this, "rotateBaseRotation", 0);
+    __publicField(this, "onKeyDown", (e) => {
+      if (e.key === "Escape") {
+        this.handleCancel();
+      }
+    });
+    __publicField(this, "updateOverlay", () => {
+      const scaledRings = this.state.originalPixelRings.map(
+        (poly) => poly.map(
+          (ring) => ring.map(
+            (pt) => scalePointAround(pt, this.state.pivot, this.state.scaleX, this.state.scaleY)
+          )
+        )
+      );
+      const bbox2 = getPixelBBox(scaledRings);
+      this.overlay.update(bbox2, this.state.pivot, this.state.rotation);
+    });
+    this.map = map;
+    this.mode = mode;
+    this.onExit = onExit;
+    const polygon2 = featureGroup.getLayers().find((l) => l instanceof L$1.Polygon);
+    if (!polygon2) throw new Error("FeatureGroup does not contain a polygon");
+    this.polygon = polygon2;
+    const originalLatLngs = this.polygon.getLatLngs();
+    this.normalizedLatLngs = normalizeLatLngs(originalLatLngs);
+    const proj = projectLatLngs(this.map, this.normalizedLatLngs);
+    const bbox2 = getPixelBBox(proj.rings);
+    const pivot = getPixelCentroid(bbox2);
+    this.state = {
+      isActive: true,
+      originalLatLngs,
+      originalPixelRings: proj.rings,
+      pivot,
+      scaleX: 1,
+      scaleY: 1,
+      rotation: 0,
+      uniformScale: false,
+      snapRotation: false,
+      scaleFromPivot: false
+    };
+    this.overlay = new TransformOverlay(
+      this.map,
+      {
+        onStartHandleDrag: (type, start, e) => this.onStartDrag(type, start, e),
+        onDragHandle: (type, current, e) => this.onDrag(type, current, e),
+        onEndHandleDrag: (_type, _end, _e) => {
+        }
+      },
+      this.mode,
+      () => this.handleCancel(),
+      () => this.handleConfirm()
+    );
+    this.updateOverlay();
+    this.map.on("zoom viewreset move", this.updateOverlay, this);
+    if (this.map.dragging) {
+      const dragging = this.map.dragging;
+      if (typeof dragging.enabled === "function") {
+        this.wasMapDraggingEnabled = dragging.enabled();
+      }
+      dragging.disable();
+    }
+    document.addEventListener("keydown", this.onKeyDown);
+  }
+  destroy() {
+    document.removeEventListener("keydown", this.onKeyDown);
+    this.map.off("zoom viewreset move", this.updateOverlay, this);
+    this.overlay.destroy();
+    this.state.isActive = false;
+    if (this.map.dragging) {
+      const dragging = this.map.dragging;
+      if (this.wasMapDraggingEnabled && typeof dragging.enable === "function") {
+        dragging.enable();
+      }
+    }
+  }
+  onStartDrag(type, start, evt) {
+    const isMac = navigator.userAgent.toLowerCase().includes("mac");
+    const ctrlOrCmd = isMac ? evt.metaKey : evt.ctrlKey;
+    this.state.uniformScale = !!evt.shiftKey;
+    this.state.scaleFromPivot = !!evt.altKey;
+    this.state.snapRotation = !!ctrlOrCmd;
+    if (type === TransformHandleType.Rotate) {
+      const c = this.state.scaleFromPivot ? this.state.pivot : getPixelCentroid(getPixelBBox(this.state.originalPixelRings));
+      const startAngle = Math.atan2(start.y - c.y, start.x - c.x);
+      this.rotateStartAngle = startAngle;
+      this.rotateBaseRotation = this.state.rotation || 0;
+    }
+  }
+  onDrag(type, current, _evt) {
+    const origBBox = getPixelBBox(this.state.originalPixelRings);
+    switch (type) {
+      case TransformHandleType.Rotate: {
+        const rotationCenter = this.state.scaleFromPivot ? this.state.pivot : getPixelCentroid(origBBox);
+        this.handleRotateDrag(current, rotationCenter);
+        break;
+      }
+      case TransformHandleType.Pivot:
+        this.handlePivotDrag(current);
+        break;
+      default: {
+        const scaleCenter = this.state.scaleFromPivot ? this.state.pivot : getPixelCentroid(origBBox);
+        this.handleScaleDrag(type, current, origBBox, scaleCenter);
+        break;
+      }
+    }
+    this.preview();
+  }
+  handleRotateDrag(current, center2) {
+    if (this.mode !== "rotate") return;
+    const angle = Math.atan2(current.y - center2.y, current.x - center2.x);
+    let theta;
+    if (this.rotateStartAngle != null) {
+      const delta = angle - this.rotateStartAngle;
+      theta = this.rotateBaseRotation + delta;
+    } else {
+      theta = angle;
+    }
+    this.state.rotation = this.state.snapRotation ? snapAngleRadians(theta, 15) : theta;
+  }
+  handlePivotDrag(current) {
+    this.state.pivot = current;
+  }
+  handleScaleDrag(type, current, origBBox, center2) {
+    if (this.mode !== "scale") return;
+    const width = origBBox.maxX - origBBox.minX;
+    const height = origBBox.maxY - origBBox.minY;
+    let scaleX = this.state.scaleX;
+    let scaleY = this.state.scaleY;
+    switch (type) {
+      case TransformHandleType.Left:
+      case TransformHandleType.TopLeft:
+      case TransformHandleType.BottomLeft:
+        scaleX = (center2.x - current.x) / (center2.x - origBBox.minX || 1);
+        break;
+      case TransformHandleType.Right:
+      case TransformHandleType.TopRight:
+      case TransformHandleType.BottomRight:
+        scaleX = (current.x - center2.x) / (origBBox.maxX - center2.x || 1);
+        break;
+    }
+    switch (type) {
+      case TransformHandleType.Top:
+      case TransformHandleType.TopLeft:
+      case TransformHandleType.TopRight:
+        scaleY = (center2.y - current.y) / (center2.y - origBBox.minY || 1);
+        break;
+      case TransformHandleType.Bottom:
+      case TransformHandleType.BottomLeft:
+      case TransformHandleType.BottomRight:
+        scaleY = (current.y - center2.y) / (origBBox.maxY - center2.y || 1);
+        break;
+    }
+    if (type === TransformHandleType.Left || type === TransformHandleType.Right) {
+      scaleY = this.state.scaleY;
+    }
+    if (type === TransformHandleType.Top || type === TransformHandleType.Bottom) {
+      scaleX = this.state.scaleX;
+    }
+    if (this.state.uniformScale) {
+      const uniform = Math.abs(width) > Math.abs(height) ? Math.sign(scaleX) * Math.abs(scaleX) : Math.sign(scaleY) * Math.abs(scaleY);
+      scaleX = uniform;
+      scaleY = uniform;
+    }
+    const hasValidScaleX = Number.isFinite(scaleX) && Math.abs(scaleX) > 1e-3;
+    const hasValidScaleY = Number.isFinite(scaleY) && Math.abs(scaleY) > 1e-3;
+    if (hasValidScaleX) {
+      this.state.scaleX = scaleX;
+    }
+    if (hasValidScaleY) {
+      this.state.scaleY = scaleY;
+    }
+  }
+  preview() {
+    const transformed = applyTransform(
+      this.state.originalPixelRings,
+      this.state.pivot,
+      this.state.scaleX,
+      this.state.scaleY,
+      this.state.rotation
+    );
+    const ll = unprojectToLatLngs(this.map, transformed, this.normalizedLatLngs);
+    this.polygon.setLatLngs(ll);
+    this.updateOverlay();
+  }
+  apply() {
+    const coords = this.polygon.getLatLngs();
+    return normalizeLatLngs(coords);
+  }
+  cancel() {
+    this.polygon.setLatLngs(this.state.originalLatLngs);
+  }
+  handleCancel() {
+    this.cancel();
+    this.destroy();
+    if (this.onExit) this.onExit();
+  }
+  handleConfirm() {
+    if (this.onExit) this.onExit();
+    this.destroy();
+  }
+}
+class PopupFactory {
+  /**
+   * Creates a menu button element.
+   * @param id Unique identifier for the button.
+   * @param title Tooltip text.
+   * @param cssClasses Additional CSS classes to apply.
+   * @param options Optional configuration (alpha banner, etc.).
+   * @returns HTMLDivElement representing the menu button.
+   */
+  static createMenuButton(id, title, cssClasses, options) {
+    const button = document.createElement("div");
+    button.classList.add("marker-menu-button", ...cssClasses);
+    button.title = title;
+    button.setAttribute("data-action-id", id);
+    if (options == null ? void 0 : options.alphaBanner) {
+      const alphaBanner = document.createElement("span");
+      alphaBanner.classList.add("alpha-banner");
+      alphaBanner.textContent = "ALPHA";
+      button.appendChild(alphaBanner);
+    }
+    return button;
+  }
+  /**
+   * Builds a menu popup container structure.
+   * @param buttons Array of button elements to include.
+   * @returns HTMLDivElement containing the complete menu structure.
+   */
+  static buildMenuPopup(buttons) {
+    const outerWrapper = document.createElement("div");
+    outerWrapper.classList.add("alter-marker-outer-wrapper");
+    const wrapper = document.createElement("div");
+    wrapper.classList.add("alter-marker-wrapper");
+    const markerContent = document.createElement("div");
+    markerContent.classList.add("content");
+    const markerContentWrapper = document.createElement("div");
+    markerContentWrapper.classList.add("marker-menu-content");
+    buttons.forEach((button) => {
+      markerContentWrapper.appendChild(button);
+    });
+    markerContent.appendChild(markerContentWrapper);
+    wrapper.appendChild(markerContent);
+    outerWrapper.appendChild(wrapper);
+    return outerWrapper;
+  }
+  /**
+   * Builds an info popup container structure.
+   * @param content HTML element to display inside the popup.
+   * @returns HTMLDivElement containing the complete info popup structure.
+   */
+  static buildInfoPopup(content) {
+    const outerWrapper = document.createElement("div");
+    outerWrapper.classList.add("info-marker-outer-wrapper");
+    const wrapper = document.createElement("div");
+    wrapper.classList.add("info-marker-wrapper");
+    const markerContent = document.createElement("div");
+    markerContent.classList.add("content");
+    markerContent.appendChild(content);
+    wrapper.appendChild(markerContent);
+    outerWrapper.appendChild(wrapper);
+    return outerWrapper;
   }
 }
 class PolygonInteractionManager {
@@ -18581,6 +20107,8 @@ class PolygonInteractionManager {
     __publicField(this, "currentModifierDragMode", false);
     __publicField(this, "isModifierKeyHeld", false);
     __publicField(this, "_openMenuPopup", null);
+    __publicField(this, "transformModeActive", false);
+    __publicField(this, "transformControllers", /* @__PURE__ */ new WeakMap());
     // Read-only access to feature groups
     __publicField(this, "getFeatureGroups");
     __publicField(this, "removeFeatureGroup");
@@ -18611,6 +20139,8 @@ class PolygonInteractionManager {
       dragData.isDragging = false;
       this.map.off("mousemove", this.onPolygonMouseMove, this);
       this.map.off("mouseup", this.onPolygonMouseUp, this);
+      this.map.off("pointermove", this.onPolygonMouseMove, this);
+      this.map.off("pointerup", this.onPolygonMouseUp, this);
       if (this.map.dragging) {
         this.map.dragging.enable();
       }
@@ -18663,6 +20193,12 @@ class PolygonInteractionManager {
     this.getFeatureGroups = featureGroupAccess.getFeatureGroups;
     this.removeFeatureGroup = featureGroupAccess.removeFeatureGroup;
   }
+  /**
+   * Strongly typed helper to emit polygon updated events without casts.
+   */
+  emitPolygonUpdated(data) {
+    this.eventManager.emit("polydraw:polygon:updated", data);
+  }
   /**
    * Add markers to a polygon feature group
    */
@@ -18694,7 +20230,7 @@ class PolygonInteractionManager {
       }
       const processedClasses = Array.isArray(iconClasses) ? iconClasses : [iconClasses];
       const isSpecialMarker = i === menuMarkerIdx && this.config.markers.menuMarker || i === deleteMarkerIdx && this.config.markers.deleteMarker || i === infoMarkerIdx && this.config.markers.infoMarker;
-      const marker = new L.Marker(latlng, {
+      const marker = new L$1.Marker(latlng, {
         icon: this.createDivIcon(processedClasses),
         draggable: this.config.modes.dragElbow,
         title: this.config.markers.coordsTitle ? this.getLatLngInfoString(latlng) : "",
@@ -18710,7 +20246,7 @@ class PolygonInteractionManager {
         var _a2, _b2;
         if (this.isDraggingMarker) {
           (_b2 = (_a2 = e.originalEvent) == null ? void 0 : _a2.stopPropagation) == null ? void 0 : _b2.call(_a2);
-          L.DomEvent.stopPropagation(e);
+          L$1.DomEvent.stopPropagation(e);
         }
       });
       marker.on("dragstart", () => {
@@ -18723,7 +20259,7 @@ class PolygonInteractionManager {
           this.markerDragEnd(fg);
         }
         this._activeMarker = null;
-        L.DomEvent.stopPropagation(e);
+        L$1.DomEvent.stopPropagation(e);
         setTimeout(() => {
           this.isDraggingMarker = false;
         }, 10);
@@ -18768,7 +20304,10 @@ class PolygonInteractionManager {
         marker.options.zIndexOffset = this.config.markers.markerMenuIcon.zIndexOffset ?? this.config.markers.zIndexOffset;
         marker.on("click", () => {
           const polygonGeoJSON = this.getPolygonGeoJSONFromFeatureGroup(featureGroup);
-          const centerOfMass2 = PolygonUtil.getCenterOfMass(polygonGeoJSON);
+          const centerOfMass2 = PolygonUtil.getCenterOfPolygonByIndexWithOffsetFromCenterOfMass(
+            polygonGeoJSON,
+            menuMarkerIdx
+          );
           const menuPopup = this.generateMenuMarkerPopup(latlngs, featureGroup);
           menuPopup.setLatLng(centerOfMass2).openOn(this.map);
         });
@@ -18778,12 +20317,22 @@ class PolygonInteractionManager {
           if (!popupContent) return;
           setTimeout(() => {
             const mapContainer = this.map.getContainer();
-            const mapBounds = mapContainer.getBoundingClientRect();
             const popupBounds = popupContent.getBoundingClientRect();
+            const mapBounds = mapContainer.getBoundingClientRect();
+            let adjustX = 0;
+            let adjustY = 0;
             if (popupBounds.left < mapBounds.left) {
-              popupContent.style.transform = `translateX(${mapBounds.left - popupBounds.left}px)`;
+              adjustX = mapBounds.left - popupBounds.left;
             } else if (popupBounds.right > mapBounds.right) {
-              popupContent.style.transform = `translateX(${mapBounds.right - popupBounds.right}px)`;
+              adjustX = mapBounds.right - popupBounds.right;
+            }
+            if (popupBounds.top < mapBounds.top) {
+              adjustY = mapBounds.top - popupBounds.top;
+            } else if (popupBounds.bottom > mapBounds.bottom) {
+              adjustY = mapBounds.bottom - popupBounds.bottom;
+            }
+            if (adjustX !== 0 || adjustY !== 0) {
+              popupContent.style.transform = `translate(${adjustX}px, ${adjustY}px)`;
             }
           }, 0);
           const container2 = this.map.getContainer();
@@ -18805,7 +20354,10 @@ class PolygonInteractionManager {
         marker.options.zIndexOffset = this.config.markers.markerInfoIcon.zIndexOffset ?? this.config.markers.zIndexOffset;
         marker.on("click", () => {
           const infoPopup = this.generateInfoMarkerPopup(area2, perimeter);
-          const centerOfMass2 = PolygonUtil.getCenterOfMass(polygonGeoJSON);
+          const centerOfMass2 = PolygonUtil.getCenterOfPolygonByIndexWithOffsetFromCenterOfMass(
+            polygonGeoJSON,
+            infoMarkerIdx
+          );
           infoPopup.setLatLng(centerOfMass2).openOn(this.map);
         });
         marker.on("popupopen", (e) => {
@@ -18836,7 +20388,7 @@ class PolygonInteractionManager {
       }
       marker.on("mousedown", (e) => {
         if (!this.modeManager.isInOffMode()) {
-          L.DomEvent.stopPropagation(e);
+          L$1.DomEvent.stopPropagation(e);
           this.map.fire("mousedown", e);
         }
         this._activeMarker = marker;
@@ -18844,7 +20396,7 @@ class PolygonInteractionManager {
       marker.on("click", (e) => {
         if (this.modeManager.isInOffMode()) {
           if (this.isEdgeDeletionModifierKeyPressed(e.originalEvent)) {
-            const polygonLayer = featureGroup.getLayers().find((layer) => layer instanceof L.Polygon);
+            const polygonLayer = featureGroup.getLayers().find((layer) => layer instanceof L$1.Polygon);
             if (polygonLayer) {
               this.elbowClicked(e, polygonLayer, marker.getLatLng());
             }
@@ -18901,7 +20453,7 @@ class PolygonInteractionManager {
       }
       const processedClasses = Array.isArray(iconClasses) ? iconClasses : [iconClasses];
       const isSpecialMarker = i === menuMarkerIdx && holeMenuEnabled || i === deleteMarkerIdx && holeDeleteEnabled || i === infoMarkerIdx && holeInfoEnabled;
-      const marker = new L.Marker(latlng, {
+      const marker = new L$1.Marker(latlng, {
         icon: this.createDivIcon(processedClasses),
         draggable: this.config.modes.dragElbow,
         title: this.config.markers.coordsTitle ? this.getLatLngInfoString(latlng) : "",
@@ -18917,7 +20469,7 @@ class PolygonInteractionManager {
         var _a3, _b3;
         if (this.isDraggingMarker) {
           (_b3 = (_a3 = e.originalEvent) == null ? void 0 : _a3.stopPropagation) == null ? void 0 : _b3.call(_a3);
-          L.DomEvent.stopPropagation(e);
+          L$1.DomEvent.stopPropagation(e);
         }
       });
       marker.on("dragstart", () => {
@@ -18930,7 +20482,7 @@ class PolygonInteractionManager {
           this.markerDragEnd(fg);
         }
         this._activeMarker = null;
-        L.DomEvent.stopPropagation(e);
+        L$1.DomEvent.stopPropagation(e);
         setTimeout(() => {
           this.isDraggingMarker = false;
         }, 10);
@@ -19035,7 +20587,7 @@ class PolygonInteractionManager {
       }
       marker.on("mousedown", (e) => {
         if (!this.modeManager.isInOffMode()) {
-          L.DomEvent.stopPropagation(e);
+          L$1.DomEvent.stopPropagation(e);
           this.map.fire("mousedown", e);
         }
         this._activeMarker = marker;
@@ -19043,14 +20595,14 @@ class PolygonInteractionManager {
       marker.on("click", (e) => {
         if (this.modeManager.isInOffMode()) {
           if (this.isEdgeDeletionModifierKeyPressed(e.originalEvent)) {
-            const polygonLayer = featureGroup.getLayers().find((layer) => layer instanceof L.Polygon);
+            const polygonLayer = featureGroup.getLayers().find((layer) => layer instanceof L$1.Polygon);
             if (polygonLayer) {
               this.elbowClicked(e, polygonLayer, marker.getLatLng());
             }
           } else {
             if (i === deleteMarkerIdx && holeDeleteEnabled) {
               this.map.closePopup();
-              const parentPolygon = featureGroup.getLayers().find((layer) => layer instanceof L.Polygon);
+              const parentPolygon = featureGroup.getLayers().find((layer) => layer instanceof L$1.Polygon);
               if (parentPolygon) {
                 const rawLatLngs = parentPolygon.getLatLngs();
                 let rings = [];
@@ -19089,7 +20641,7 @@ class PolygonInteractionManager {
                   });
                   const newPolygon = this.turfHelper.getMultiPolygon([coords]);
                   this.removeFeatureGroup(featureGroup);
-                  this.eventManager.emit("polydraw:polygon:updated", {
+                  this.emitPolygonUpdated({
                     operation: "removeHole",
                     polygon: newPolygon
                   });
@@ -19138,12 +20690,15 @@ class PolygonInteractionManager {
         if (edgeStart.lat === edgeEnd.lat && edgeStart.lng === edgeEnd.lng) {
           continue;
         }
-        const edgePolyline = L.polyline([edgeStart, edgeEnd], {
-          color: "transparent",
-          weight: 10,
-          opacity: 0,
-          interactive: true
-        });
+        const edgePolyline = leafletAdapter.createPolyline(
+          [edgeStart, edgeEnd],
+          {
+            color: "transparent",
+            weight: 10,
+            opacity: 0,
+            interactive: true
+          }
+        );
         edgePolyline._polydrawEdgeInfo = {
           ringIndex,
           edgeIndex: i,
@@ -19179,15 +20734,15 @@ class PolygonInteractionManager {
     };
     polygon2.on("mousedown", (e) => {
       if (!this.modeManager.isInOffMode()) {
-        L.DomEvent.stopPropagation(e);
+        L$1.DomEvent.stopPropagation(e);
         this.map.fire("mousedown", e);
         return;
       }
       if (!this.modeManager.canPerformAction("polygonDrag")) {
         return;
       }
-      L.DomEvent.stopPropagation(e.originalEvent);
-      L.DomEvent.preventDefault(e.originalEvent);
+      L$1.DomEvent.stopPropagation(e.originalEvent);
+      L$1.DomEvent.preventDefault(e.originalEvent);
       const isModifierPressed = this.detectDragSubtractModifierKey(e.originalEvent);
       this.currentModifierDragMode = isModifierPressed;
       this.isModifierKeyHeld = isModifierPressed;
@@ -19207,6 +20762,46 @@ class PolygonInteractionManager {
       }
       this.map.on("mousemove", this.onPolygonMouseMove, this);
       this.map.on("mouseup", this.onPolygonMouseUp, this);
+      this.map.on("pointermove", this.onPolygonMouseMove, this);
+      this.map.on("pointerup", this.onPolygonMouseUp, this);
+      this.currentDragPolygon = polygon2;
+    });
+    polygon2.on("pointerdown", (e) => {
+      if (this.transformModeActive) {
+        return;
+      }
+      if (!this.modeManager.isInOffMode()) {
+        L$1.DomEvent.stopPropagation(e);
+        this.map.fire("pointerdown", e);
+        return;
+      }
+      if (!this.modeManager.canPerformAction("polygonDrag")) {
+        return;
+      }
+      const orig = e && e.originalEvent ? e.originalEvent : e;
+      L$1.DomEvent.stopPropagation(orig);
+      L$1.DomEvent.preventDefault(orig);
+      const isModifierPressed = this.detectDragSubtractModifierKey(orig);
+      this.currentModifierDragMode = isModifierPressed;
+      this.isModifierKeyHeld = isModifierPressed;
+      polygon2._polydrawDragData.isDragging = true;
+      polygon2._polydrawDragData.startPosition = e.latlng;
+      polygon2._polydrawDragData.startLatLngs = polygon2.getLatLngs();
+      polygon2.setStyle({ fillOpacity: this.config.dragPolygons.opacity });
+      if (this.map.dragging) {
+        this.map.dragging.disable();
+      }
+      this.setSubtractVisualMode(polygon2, isModifierPressed);
+      this.setMarkerVisibility(polygon2, false);
+      try {
+        const container = this.map.getContainer();
+        container.style.cursor = this.config.dragPolygons.dragCursor || "move";
+      } catch (error) {
+      }
+      this.map.on("mousemove", this.onPolygonMouseMove, this);
+      this.map.on("mouseup", this.onPolygonMouseUp, this);
+      this.map.on("pointermove", this.onPolygonMouseMove, this);
+      this.map.on("pointerup", this.onPolygonMouseUp, this);
       this.currentDragPolygon = polygon2;
     });
     polygon2.on("mouseover", () => {
@@ -19235,7 +20830,7 @@ class PolygonInteractionManager {
     const shouldBeDraggable = this.modeManager.canPerformAction("markerDrag");
     this.getFeatureGroups().forEach((featureGroup) => {
       featureGroup.eachLayer((layer) => {
-        if (layer instanceof L.Marker) {
+        if (layer instanceof L$1.Marker) {
           const marker = layer;
           try {
             marker.options.draggable = shouldBeDraggable;
@@ -19258,7 +20853,7 @@ class PolygonInteractionManager {
   updateAllMarkersForEdgeDeletion(showFeedback) {
     this.getFeatureGroups().forEach((featureGroup) => {
       featureGroup.eachLayer((layer) => {
-        if (layer instanceof L.Marker) {
+        if (layer instanceof L$1.Marker) {
           this.updateMarkerForEdgeDeletion(layer, showFeedback);
         }
       });
@@ -19315,7 +20910,7 @@ class PolygonInteractionManager {
             const polydrawPolygon = parentPolygon;
             const optimizationLevel = polydrawPolygon._polydrawOptimizationLevel || 0;
             this.removeFeatureGroup(parentFeatureGroup);
-            this.eventManager.emit("polydraw:polygon:updated", {
+            this.emitPolygonUpdated({
               operation: "addVertex",
               polygon: newPolygon,
               optimizationLevel
@@ -19325,7 +20920,7 @@ class PolygonInteractionManager {
       } catch (error) {
       }
     }
-    L.DomEvent.stopPropagation(e);
+    L$1.DomEvent.stopPropagation(e);
   }
   highlightEdgeOnHover(edgePolyline, isHovering) {
     if (isHovering) {
@@ -19415,7 +21010,7 @@ class PolygonInteractionManager {
       this.removeFeatureGroup(currentFeatureGroup);
     }
     const newPolygon = this.turfHelper.getMultiPolygon([coords]);
-    this.eventManager.emit("polydraw:polygon:updated", {
+    this.emitPolygonUpdated({
       operation: "removeVertex",
       polygon: newPolygon
     });
@@ -19431,7 +21026,7 @@ class PolygonInteractionManager {
     let testarray = [];
     let hole = [];
     const layers = featureGroup.getLayers();
-    const polygonLayer = layers.find((l) => l instanceof L.Polygon);
+    const polygonLayer = layers.find((l) => l instanceof L$1.Polygon);
     if (!polygonLayer) {
       if (!isTestEnvironment()) {
         console.warn("No polygon found in feature group for marker drag.");
@@ -19440,7 +21035,7 @@ class PolygonInteractionManager {
     }
     const posarrays = polygonLayer.getLatLngs();
     let length2 = 0;
-    const markers2 = layers.filter((layer) => layer instanceof L.Marker);
+    const markers = layers.filter((layer) => layer instanceof L$1.Marker);
     if (posarrays.length > 1) {
       for (let index = 0; index < posarrays.length; index++) {
         testarray = [];
@@ -19449,16 +21044,16 @@ class PolygonInteractionManager {
           if (posarrays[0].length > 1) {
             for (let i = 0; i < posarrays[0].length; i++) {
               for (let j = 0; j < posarrays[0][i].length; j++) {
-                if (markers2[j]) {
-                  testarray.push(markers2[j].getLatLng());
+                if (markers[j]) {
+                  testarray.push(markers[j].getLatLng());
                 }
               }
               hole.push(testarray);
             }
           } else {
             for (let j = 0; j < posarrays[0][0].length; j++) {
-              if (markers2[j]) {
-                testarray.push(markers2[j].getLatLng());
+              if (markers[j]) {
+                testarray.push(markers[j].getLatLng());
               }
             }
             hole.push(testarray);
@@ -19467,8 +21062,8 @@ class PolygonInteractionManager {
         } else {
           length2 += posarrays[index - 1].length;
           for (let j = length2; j < posarrays[index][0].length + length2; j++) {
-            if (markers2[j]) {
-              testarray.push(markers2[j].getLatLng());
+            if (markers[j]) {
+              testarray.push(markers[j].getLatLng());
             }
           }
           hole.push(testarray);
@@ -19483,22 +21078,22 @@ class PolygonInteractionManager {
         if (index === 0) {
           if (posarrays[0][index].length > 1) {
             for (let j = 0; j < posarrays[0][index].length; j++) {
-              if (markers2[j]) {
-                testarray.push(markers2[j].getLatLng());
+              if (markers[j]) {
+                testarray.push(markers[j].getLatLng());
               }
             }
           } else {
             for (let j = 0; j < posarrays[0][0].length; j++) {
-              if (markers2[j]) {
-                testarray.push(markers2[j].getLatLng());
+              if (markers[j]) {
+                testarray.push(markers[j].getLatLng());
               }
             }
           }
         } else {
           length22 += posarrays[0][index - 1].length;
           for (let j = length22; j < posarrays[0][index].length + length22; j++) {
-            if (markers2[j]) {
-              testarray.push(markers2[j].getLatLng());
+            if (markers[j]) {
+              testarray.push(markers[j].getLatLng());
             }
           }
         }
@@ -19521,7 +21116,7 @@ class PolygonInteractionManager {
         if (this.turfHelper.hasKinks(feature2)) {
           const unkink = this.turfHelper.getKinks(feature2);
           for (const polygon2 of unkink) {
-            this.eventManager.emit("polydraw:polygon:updated", {
+            this.emitPolygonUpdated({
               operation: "markerDrag",
               polygon: this.turfHelper.getTurfPolygon(polygon2),
               allowMerge: true,
@@ -19531,7 +21126,7 @@ class PolygonInteractionManager {
             });
           }
         } else {
-          this.eventManager.emit("polydraw:polygon:updated", {
+          this.emitPolygonUpdated({
             operation: "markerDrag",
             polygon: feature2,
             allowMerge: true,
@@ -19548,7 +21143,7 @@ class PolygonInteractionManager {
       if (this.turfHelper.hasKinks(feature2)) {
         const unkink = this.turfHelper.getKinks(feature2);
         for (const polygon2 of unkink) {
-          this.eventManager.emit("polydraw:polygon:updated", {
+          this.emitPolygonUpdated({
             operation: "markerDrag",
             polygon: this.turfHelper.getTurfPolygon(polygon2),
             allowMerge: false
@@ -19556,7 +21151,7 @@ class PolygonInteractionManager {
           });
         }
       } else {
-        this.eventManager.emit("polydraw:polygon:updated", {
+        this.emitPolygonUpdated({
           operation: "markerDrag",
           polygon: feature2,
           allowMerge: false
@@ -19573,7 +21168,9 @@ class PolygonInteractionManager {
         (ring) => this.offsetPolygonCoordinates(ring, offsetLat, offsetLng)
       );
     }
-    return latLngs.map((p) => L.latLng(p.lat + offsetLat, p.lng + offsetLng));
+    return latLngs.map(
+      (p) => leafletAdapter.createLatLng(p.lat + offsetLat, p.lng + offsetLng)
+    );
   }
   updateMarkersAndHoleLinesDuringDrag(polygon2, offsetLat, offsetLng) {
     try {
@@ -19593,22 +21190,22 @@ class PolygonInteractionManager {
       if (!featureGroup) {
         return;
       }
-      const dragSessionKey = "_polydrawDragSession_" + Date.now() + "_" + L.Util.stamp(polygon2);
+      const dragSessionKey = "_polydrawDragSession_" + Date.now() + "_" + leafletAdapter.util.stamp(polygon2);
       if (!polygon2._polydrawCurrentDragSession) {
         polygon2._polydrawCurrentDragSession = dragSessionKey;
         polygon2._polydrawOriginalMarkerPositions = /* @__PURE__ */ new Map();
         polygon2._polydrawOriginalHoleLinePositions = /* @__PURE__ */ new Map();
         featureGroup.eachLayer((layer) => {
-          if (layer instanceof L.Marker) {
+          if (layer instanceof L$1.Marker) {
             polygon2._polydrawOriginalMarkerPositions.set(layer, layer.getLatLng());
-          } else if (layer instanceof L.Polyline && !(layer instanceof L.Polygon)) {
+          } else if (layer instanceof L$1.Polyline && !(layer instanceof L$1.Polygon)) {
             const latLngs = layer.getLatLngs();
             polygon2._polydrawOriginalHoleLinePositions.set(layer, latLngs);
           }
         });
       }
       featureGroup.eachLayer((layer) => {
-        if (layer instanceof L.Marker) {
+        if (layer instanceof L$1.Marker) {
           const originalPos = polygon2._polydrawOriginalMarkerPositions.get(layer);
           if (originalPos) {
             const newLatLng = {
@@ -19617,17 +21214,19 @@ class PolygonInteractionManager {
             };
             layer.setLatLng(newLatLng);
           }
-        } else if (layer instanceof L.Polyline && !(layer instanceof L.Polygon)) {
+        } else if (layer instanceof L$1.Polyline && !(layer instanceof L$1.Polygon)) {
           const originalPositions = polygon2._polydrawOriginalHoleLinePositions.get(layer);
           if (originalPositions) {
             let newLatLngs;
             if (Array.isArray(originalPositions[0])) {
               newLatLngs = originalPositions.map(
-                (ring) => ring.map((latlng) => L.latLng(latlng.lat + offsetLat, latlng.lng + offsetLng))
+                (ring) => ring.map(
+                  (latlng) => leafletAdapter.createLatLng(latlng.lat + offsetLat, latlng.lng + offsetLng)
+                )
               );
             } else {
               newLatLngs = originalPositions.map(
-                (latlng) => L.latLng(latlng.lat + offsetLat, latlng.lng + offsetLng)
+                (latlng) => leafletAdapter.createLatLng(latlng.lat + offsetLat, latlng.lng + offsetLng)
               );
             }
             layer.setLatLngs(newLatLngs);
@@ -19661,7 +21260,7 @@ class PolygonInteractionManager {
       }
       this.removeFeatureGroup(featureGroup);
       const feature2 = this.turfHelper.getTurfPolygon(newGeoJSON);
-      this.eventManager.emit("polydraw:polygon:updated", {
+      this.emitPolygonUpdated({
         operation: "polygonDrag",
         polygon: feature2,
         allowMerge: true
@@ -19720,7 +21319,7 @@ class PolygonInteractionManager {
       const fg = featureGroup;
       const hideMarkersOnDrag = this.config.dragPolygons.modifierSubtract.hideMarkersOnDrag;
       fg.eachLayer((layer) => {
-        if (layer instanceof L.Marker) {
+        if (layer instanceof L$1.Marker) {
           const marker = layer;
           const element = marker.getElement();
           if (element) {
@@ -19813,7 +21412,7 @@ class PolygonInteractionManager {
               const coords = this.turfHelper.getCoords(difference3);
               for (const coordSet of coords) {
                 const individualPolygon = this.turfHelper.getMultiPolygon([coordSet]);
-                this.eventManager.emit("polydraw:polygon:updated", {
+                this.emitPolygonUpdated({
                   operation: "modifierSubtract",
                   polygon: this.turfHelper.getTurfPolygon(individualPolygon),
                   allowMerge: false
@@ -19825,7 +21424,7 @@ class PolygonInteractionManager {
             if (!isTestEnvironment()) {
               console.warn("Failed to perform difference operation:", differenceError);
             }
-            this.eventManager.emit("polydraw:polygon:updated", {
+            this.emitPolygonUpdated({
               operation: "modifierSubtractFallback",
               polygon: existingPolygon,
               allowMerge: false
@@ -19933,25 +21532,25 @@ class PolygonInteractionManager {
     );
     return nearestPointIdx;
   }
-  ensureMarkerSeparation(polygonLength, markers2) {
+  ensureMarkerSeparation(polygonLength, markers) {
     const enabledMarkers = [];
-    if (markers2.menu.enabled) {
-      enabledMarkers.push({ type: "menu", index: markers2.menu.index });
+    if (markers.menu.enabled) {
+      enabledMarkers.push({ type: "menu", index: markers.menu.index });
     }
-    if (markers2.delete.enabled) {
-      enabledMarkers.push({ type: "delete", index: markers2.delete.index });
+    if (markers.delete.enabled) {
+      enabledMarkers.push({ type: "delete", index: markers.delete.index });
     }
-    if (markers2.info.enabled) {
-      enabledMarkers.push({ type: "info", index: markers2.info.index });
+    if (markers.info.enabled) {
+      enabledMarkers.push({ type: "info", index: markers.info.index });
     }
     if (enabledMarkers.length < 2) {
       return {
-        menu: markers2.menu.index,
-        delete: markers2.delete.index,
-        info: markers2.info.index
+        menu: markers.menu.index,
+        delete: markers.delete.index,
+        info: markers.info.index
       };
     }
-    const resolvedIndices = { ...markers2 };
+    const resolvedIndices = { ...markers };
     const usedIndices = /* @__PURE__ */ new Set();
     const processingOrder = ["info", "delete", "menu"];
     for (const markerType of processingOrder) {
@@ -20006,7 +21605,7 @@ class PolygonInteractionManager {
     const featureGroup = this.getFeatureGroups().find((fg) => fg.hasLayer(polygon2));
     if (!featureGroup) return;
     featureGroup.eachLayer((layer) => {
-      if (layer instanceof L.Marker) {
+      if (layer instanceof L$1.Marker) {
         const marker = layer;
         const element = marker.getElement();
         if (element) {
@@ -20023,128 +21622,134 @@ class PolygonInteractionManager {
     });
   }
   generateMenuMarkerPopup(latLngs, featureGroup) {
-    const outerWrapper = document.createElement("div");
-    outerWrapper.classList.add("alter-marker-outer-wrapper");
-    const wrapper = document.createElement("div");
-    wrapper.classList.add("alter-marker-wrapper");
-    const markerContent = document.createElement("div");
-    markerContent.classList.add("content");
-    const markerContentWrapper = document.createElement("div");
-    markerContentWrapper.classList.add("marker-menu-content");
-    const simplify3 = document.createElement("div");
-    simplify3.classList.add("marker-menu-button", "simplify");
-    simplify3.title = "Simplify";
-    const doubleElbows = document.createElement("div");
-    doubleElbows.classList.add("marker-menu-button", "double-elbows");
-    doubleElbows.title = "DoubleElbows";
-    const bbox2 = document.createElement("div");
-    bbox2.classList.add("marker-menu-button", "bbox");
-    bbox2.title = "Bounding box";
-    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);
-    wrapper.appendChild(markerContent);
-    markerContent.appendChild(markerContentWrapper);
-    markerContentWrapper.appendChild(simplify3);
-    markerContentWrapper.appendChild(separator.cloneNode());
-    markerContentWrapper.appendChild(doubleElbows);
-    markerContentWrapper.appendChild(separator.cloneNode());
-    markerContentWrapper.appendChild(bbox2);
-    markerContentWrapper.appendChild(separator.cloneNode());
-    markerContentWrapper.appendChild(bezier2);
+    const buttons = [];
+    const menuOps = this.config.menuOperations;
+    if (menuOps.simplify.enabled) {
+      buttons.push(PopupFactory.createMenuButton("simplify", "Simplify", ["simplify"]));
+    }
+    if (menuOps.doubleElbows.enabled) {
+      buttons.push(
+        PopupFactory.createMenuButton("doubleElbows", "DoubleElbows", ["double-elbows"])
+      );
+    }
+    if (menuOps.bbox.enabled) {
+      buttons.push(PopupFactory.createMenuButton("bbox", "Bounding box", ["bbox"]));
+    }
+    if (menuOps.bezier.enabled) {
+      buttons.push(
+        PopupFactory.createMenuButton("bezier", "Curve", ["bezier"], {
+          alphaBanner: true
+        })
+      );
+    }
+    if (menuOps.scale.enabled) {
+      buttons.push(PopupFactory.createMenuButton("scale", "Scale", ["transform-scale"]));
+    }
+    if (menuOps.rotate.enabled) {
+      buttons.push(PopupFactory.createMenuButton("rotate", "Rotate", ["transform-rotate"]));
+    }
+    const outerWrapper = PopupFactory.buildMenuPopup(buttons);
     const closePopupIfOpen = () => {
       if (this._openMenuPopup) {
         this.map.closePopup(this._openMenuPopup);
         this._openMenuPopup = null;
       }
     };
-    simplify3.addEventListener("touchend", (e) => {
-      e.preventDefault();
-      e.stopPropagation();
-      this.eventManager.emit("polydraw:menu:action", {
-        action: "simplify",
-        latLngs,
-        featureGroup
-      });
-      closePopupIfOpen();
-    });
-    simplify3.onclick = () => {
-      this.eventManager.emit("polydraw:menu:action", {
-        action: "simplify",
-        latLngs,
-        featureGroup
+    const attachMenuActionHandler = (button, action) => {
+      button.addEventListener("touchend", (e) => {
+        e.preventDefault();
+        e.stopPropagation();
+        this.eventManager.emit("polydraw:menu:action", {
+          action,
+          latLngs,
+          featureGroup
+        });
+        closePopupIfOpen();
       });
-      closePopupIfOpen();
+      button.onclick = () => {
+        this.eventManager.emit("polydraw:menu:action", {
+          action,
+          latLngs,
+          featureGroup
+        });
+        closePopupIfOpen();
+      };
     };
-    bbox2.addEventListener("touchend", (e) => {
-      e.preventDefault();
-      e.stopPropagation();
-      this.eventManager.emit("polydraw:menu:action", {
-        action: "bbox",
-        latLngs,
-        featureGroup
-      });
-      closePopupIfOpen();
-    });
-    bbox2.onclick = () => {
-      this.eventManager.emit("polydraw:menu:action", {
-        action: "bbox",
-        latLngs,
-        featureGroup
-      });
-      closePopupIfOpen();
+    const startTransform = (mode) => {
+      const existing = this.transformControllers.get(featureGroup);
+      if (existing) {
+        existing.cancel();
+        existing.destroy();
+        this.transformControllers.delete(featureGroup);
+      }
+      try {
+        const controller = new PolygonTransformController(this.map, featureGroup, mode, () => {
+          try {
+            const polygonLayer = featureGroup.getLayers().find((l) => l instanceof L$1.Polygon);
+            if (!polygonLayer) return;
+            const newGeoJSON = polygonLayer.toGeoJSON();
+            this.removeFeatureGroup(featureGroup);
+            this.emitPolygonUpdated({
+              operation: "transform",
+              polygon: this.turfHelper.getTurfPolygon(newGeoJSON),
+              allowMerge: true
+            });
+          } finally {
+            controller.destroy();
+            this.transformControllers.delete(featureGroup);
+            this.transformModeActive = false;
+          }
+        });
+        this.transformControllers.set(featureGroup, controller);
+        const polyLayer = featureGroup.getLayers().find((l) => l instanceof L$1.Polygon);
+        if (polyLayer) this.setMarkerVisibility(polyLayer, false);
+        this.transformModeActive = true;
+      } catch {
+      }
     };
-    doubleElbows.addEventListener("touchend", (e) => {
-      e.preventDefault();
-      e.stopPropagation();
-      this.eventManager.emit("polydraw:menu:action", {
-        action: "doubleElbows",
-        latLngs,
-        featureGroup
-      });
-      closePopupIfOpen();
-    });
-    doubleElbows.onclick = () => {
-      this.eventManager.emit("polydraw:menu:action", {
-        action: "doubleElbows",
-        latLngs,
-        featureGroup
+    const attachTransformHandler = (button, mode) => {
+      button.addEventListener("touchend", (e) => {
+        e.preventDefault();
+        e.stopPropagation();
+        startTransform(mode);
+        closePopupIfOpen();
       });
-      closePopupIfOpen();
+      button.onclick = () => {
+        startTransform(mode);
+        closePopupIfOpen();
+      };
     };
-    bezier2.addEventListener("touchend", (e) => {
-      e.preventDefault();
-      e.stopPropagation();
-      this.eventManager.emit("polydraw:menu:action", {
-        action: "bezier",
-        latLngs,
-        featureGroup
-      });
-      closePopupIfOpen();
+    buttons.forEach((button) => {
+      const actionId = button.getAttribute("data-action-id");
+      switch (actionId) {
+        case "simplify":
+          attachMenuActionHandler(button, "simplify");
+          break;
+        case "doubleElbows":
+          attachMenuActionHandler(button, "doubleElbows");
+          break;
+        case "bbox":
+          attachMenuActionHandler(button, "bbox");
+          break;
+        case "bezier":
+          attachMenuActionHandler(button, "bezier");
+          break;
+        case "scale":
+          attachTransformHandler(button, "scale");
+          break;
+        case "rotate":
+          attachTransformHandler(button, "rotate");
+          break;
+      }
     });
-    bezier2.onclick = () => {
-      this.eventManager.emit("polydraw:menu:action", {
-        action: "bezier",
-        latLngs,
-        featureGroup
-      });
-      closePopupIfOpen();
-    };
-    L.DomEvent.disableClickPropagation(outerWrapper);
+    L$1.DomEvent.disableClickPropagation(outerWrapper);
     outerWrapper.style.pointerEvents = "auto";
     outerWrapper.querySelectorAll(".marker-menu-button").forEach((btn) => {
       btn.style.pointerEvents = "auto";
       btn.addEventListener("click", (e) => e.stopPropagation());
     });
     const isMobile = window.innerWidth <= 600;
-    const popup = L.popup({
+    const popup = leafletAdapter.createPopup({
       closeButton: true,
       autoClose: true,
       className: `menu-popup${isMobile ? " mobile-popup" : ""}`
@@ -20154,7 +21759,7 @@ class PolygonInteractionManager {
   }
   getPolygonGeoJSONFromFeatureGroup(featureGroup) {
     try {
-      const polygonLayer = featureGroup.getLayers().find((layer) => layer instanceof L.Polygon);
+      const polygonLayer = featureGroup.getLayers().find((layer) => layer instanceof L$1.Polygon);
       if (!polygonLayer) {
         throw new Error("No polygon found in feature group");
       }
@@ -20256,14 +21861,14 @@ class PolygonInteractionManager {
     markerContent.appendChild(infoContentWrapper);
     outerWrapper.appendChild(wrapper);
     wrapper.appendChild(markerContent);
-    L.DomEvent.disableClickPropagation(outerWrapper);
+    L$1.DomEvent.disableClickPropagation(outerWrapper);
     outerWrapper.style.pointerEvents = "auto";
     outerWrapper.querySelectorAll("button").forEach((btn) => {
       btn.style.pointerEvents = "auto";
       btn.addEventListener("click", (e) => e.stopPropagation());
     });
     const isMobile = window.innerWidth <= 600;
-    const popup = L.popup({
+    const popup = leafletAdapter.createPopup({
       closeButton: true,
       autoClose: true,
       className: `info-popup${isMobile ? " mobile-popup" : ""}`
@@ -20502,7 +22107,7 @@ class PolygonMutationManager {
       if (!latlngs || !latlngs.geometry || !latlngs.geometry.coordinates) {
         return { success: false, error: "Invalid polygon data" };
       }
-      const featureGroup = new L.FeatureGroup();
+      const featureGroup = new L$1.FeatureGroup();
       const latLngs = simplify3 ? this.turfHelper.getSimplified(latlngs, dynamicTolerance) : latlngs;
       let polygon2;
       try {
@@ -20542,7 +22147,7 @@ class PolygonMutationManager {
             if (ringIndex === 0) {
               this.interactionManager.addMarkers(latLngLiterals, featureGroup);
             } else {
-              const holePolyline = L.polyline(latLngLiterals, {
+              const holePolyline = leafletAdapter.createPolyline(latLngLiterals, {
                 color: this.config.colors.hole.border,
                 weight: this.config.holeOptions.weight || 2,
                 opacity: this.config.holeOptions.opacity || 1,
@@ -20812,7 +22417,7 @@ class PolygonMutationManager {
    * Create a polygon from GeoJSON feature
    */
   getPolygon(latlngs) {
-    const polygon2 = L.GeoJSON.geometryToLayer(latlngs);
+    const polygon2 = L$1.GeoJSON.geometryToLayer(latlngs);
     const polygonStyle = {
       ...this.config.polygonOptions,
       color: this.config.colors.polygon.border,
@@ -20823,7 +22428,7 @@ class PolygonMutationManager {
       fillOpacity: this.config.polygonOptions.fillOpacity || 0.2
     };
     polygon2.setStyle(polygonStyle);
-    polygon2._polydrawUniqueId = L.Util.stamp(polygon2) + "_" + Date.now();
+    polygon2._polydrawUniqueId = leafletAdapter.util.stamp(polygon2) + "_" + Date.now();
     delete polygon2._polydrawDragData;
     delete polygon2._polydrawOriginalLatLngs;
     delete polygon2._polydrawCurrentDragSession;
@@ -20859,7 +22464,7 @@ class PolygonMutationManager {
     try {
       let polygon2 = null;
       featureGroup.eachLayer((layer) => {
-        if (layer instanceof L.Polygon) {
+        if (layer instanceof L$1.Polygon) {
           polygon2 = layer;
         }
       });
@@ -21021,19 +22626,19 @@ class PolygonMutationManager {
   getMarkerIndex(latlngs, position) {
     return 0;
   }
-  ensureMarkerSeparation(polygonLength, markers2) {
+  ensureMarkerSeparation(polygonLength, markers) {
     var _a2, _b2, _c;
     return {
-      menu: ((_a2 = markers2.menu) == null ? void 0 : _a2.index) ?? 0,
-      delete: ((_b2 = markers2.delete) == null ? void 0 : _b2.index) ?? 1,
-      info: ((_c = markers2.info) == null ? void 0 : _c.index) ?? 2
+      menu: ((_a2 = markers.menu) == null ? void 0 : _a2.index) ?? 0,
+      delete: ((_b2 = markers.delete) == null ? void 0 : _b2.index) ?? 1,
+      info: ((_c = markers.info) == null ? void 0 : _c.index) ?? 2
     };
   }
   findAlternativeMarkerPosition(polygonLength, originalIndex, usedIndices) {
     return (originalIndex + 1) % polygonLength;
   }
   createDivIcon(processedClasses) {
-    return L.divIcon({ className: processedClasses.join(" ") });
+    return leafletAdapter.createDivIcon({ className: processedClasses.join(" ") });
   }
   getLatLngInfoString(latlng) {
     return "Latitude: " + latlng.lat + " Longitude: " + latlng.lng;
@@ -21149,7 +22754,419 @@ function injectDynamicStyles(config) {
   `;
   document.head.appendChild(style);
 }
-class Polydraw extends L.Control {
+class EventAdapter {
+  /**
+   * Normalizes events to handle differences between v1 and v2
+   * @param event - The event to normalize
+   * @returns The normalized event
+   */
+  static normalizeEvent(event) {
+    const version = LeafletVersionDetector.getVersion();
+    if (version === LeafletVersion.V2) {
+      if (event.layer && !event.propagatedFrom) {
+        event.propagatedFrom = event.layer;
+      }
+      if (event.type === "mousedown" || event.type === "touchstart") {
+        event._isPointerEvent = true;
+      }
+    }
+    return event;
+  }
+  /**
+   * Gets the appropriate event name for the current Leaflet version
+   * @param eventName - The base event name
+   * @returns The version-appropriate event name
+   */
+  static getEventName(eventName) {
+    const version = LeafletVersionDetector.getVersion();
+    if (version === LeafletVersion.V2) {
+      switch (eventName) {
+        case "mousedown":
+          return "pointerdown";
+        case "mouseup":
+          return "pointerup";
+        case "mousemove":
+          return "pointermove";
+        case "touchstart":
+          return "pointerdown";
+        case "touchend":
+          return "pointerup";
+        case "touchmove":
+          return "pointermove";
+        default:
+          return eventName;
+      }
+    }
+    return eventName;
+  }
+  /**
+   * Checks if pointer events are supported/preferred
+   * @returns true if pointer events should be used
+   */
+  static shouldUsePointerEvents() {
+    const version = LeafletVersionDetector.getVersion();
+    return version === LeafletVersion.V2 && "PointerEvent" in window;
+  }
+  /**
+   * Extracts coordinates from various event types (mouse, touch, pointer)
+   * @param event - The event to extract coordinates from
+   * @param map - The map instance for coordinate conversion
+   * @returns The LatLng coordinates or null if not available
+   */
+  static extractCoordinates(event, map) {
+    if (event.latlng) {
+      return event.latlng;
+    }
+    if (event.touches && event.touches.length > 0) {
+      const rect = map.getContainer().getBoundingClientRect();
+      return map.containerPointToLatLng([
+        event.touches[0].clientX - rect.x,
+        event.touches[0].clientY - rect.y
+      ]);
+    }
+    if (event.pointerType && event.clientX !== void 0) {
+      const rect = map.getContainer().getBoundingClientRect();
+      return map.containerPointToLatLng([event.clientX - rect.x, event.clientY - rect.y]);
+    }
+    if (event.clientX !== void 0) {
+      const rect = map.getContainer().getBoundingClientRect();
+      return map.containerPointToLatLng([event.clientX - rect.x, event.clientY - rect.y]);
+    }
+    return null;
+  }
+  /**
+   * Checks if an event should be prevented from default behavior
+   * @param event - The event to check
+   * @returns true if preventDefault should be called
+   */
+  static shouldPreventDefault(event) {
+    if (event.type && event.type.startsWith("touch")) {
+      return true;
+    }
+    if (event.pointerType && event.isPrimary === false) {
+      return false;
+    }
+    if ("cancelable" in event && event.cancelable) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Gets the appropriate event listener names for the current version
+   * @returns Object with event names for different actions
+   */
+  static getEventNames() {
+    const version = LeafletVersionDetector.getVersion();
+    if (version === LeafletVersion.V2 && this.shouldUsePointerEvents()) {
+      return {
+        start: ["pointerdown"],
+        move: ["pointermove"],
+        end: ["pointerup"]
+      };
+    } else {
+      return {
+        start: ["mousedown", "touchstart"],
+        move: ["mousemove", "touchmove"],
+        end: ["mouseup", "touchend"]
+      };
+    }
+  }
+}
+class GeometryUtils {
+  /**
+   * Calculate angle between three points
+   */
+  static calculateAngle(p1, p2, p3) {
+    const v1 = { x: p1.lng - p2.lng, y: p1.lat - p2.lat };
+    const v2 = { x: p3.lng - p2.lng, y: p3.lat - p2.lat };
+    const dot = v1.x * v2.x + v1.y * v2.y;
+    const mag1 = Math.sqrt(v1.x * v1.x + v1.y * v1.y);
+    const mag2 = Math.sqrt(v2.x * v2.x + v2.y * v2.y);
+    if (mag1 === 0 || mag2 === 0) return 0;
+    const cosAngle = dot / (mag1 * mag2);
+    return Math.acos(Math.max(-1, Math.min(1, cosAngle)));
+  }
+  /**
+   * Calculate distance from point to line between two other points
+   */
+  static calculateDistanceFromLine(p1, point2, p2) {
+    const A = point2.lng - p1.lng;
+    const B2 = point2.lat - p1.lat;
+    const C = p2.lng - p1.lng;
+    const D2 = p2.lat - p1.lat;
+    const dot = A * C + B2 * D2;
+    const lenSq = C * C + D2 * D2;
+    if (lenSq === 0) return Math.sqrt(A * A + B2 * B2);
+    const param = dot / lenSq;
+    let xx, yy;
+    if (param < 0) {
+      xx = p1.lng;
+      yy = p1.lat;
+    } else if (param > 1) {
+      xx = p2.lng;
+      yy = p2.lat;
+    } else {
+      xx = p1.lng + param * C;
+      yy = p1.lat + param * D2;
+    }
+    const dx = point2.lng - xx;
+    const dy = point2.lat - yy;
+    return Math.sqrt(dx * dx + dy * dy);
+  }
+  /**
+   * Calculate centroid of polygon
+   * @deprecated Use PolygonUtil.getCenter() instead for consistency
+   */
+  static calculateCentroid(latlngs) {
+    return PolygonUtil.getCenter(latlngs);
+  }
+  /**
+   * Calculate distance between two points
+   */
+  static calculateDistance(p1, p2) {
+    const dx = p1.lng - p2.lng;
+    const dy = p1.lat - p2.lat;
+    return Math.sqrt(dx * dx + dy * dy);
+  }
+  /**
+   * Apply offset to polygon coordinates
+   * Note: Uses 'any' type for recursive coordinate structures that can be:
+   * - L.LatLngLiteral (single coordinate)
+   * - L.LatLngLiteral[] (array of coordinates)
+   * - L.LatLngLiteral[][] (polygon with holes)
+   * - L.LatLngLiteral[][][] (multipolygon)
+   * This is a legitimate use of 'any' for dynamic recursive data structures.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static offsetPolygonCoordinates(latLngs, offsetLat, offsetLng) {
+    if (!latLngs) return latLngs;
+    if (Array.isArray(latLngs[0])) {
+      return latLngs.map(
+        (ring) => GeometryUtils.offsetPolygonCoordinates(ring, offsetLat, offsetLng)
+      );
+    } else if (latLngs.lat !== void 0 && latLngs.lng !== void 0) {
+      return {
+        lat: latLngs.lat + offsetLat,
+        lng: latLngs.lng + offsetLng
+      };
+    } else {
+      return latLngs.map(
+        (coord) => GeometryUtils.offsetPolygonCoordinates(coord, offsetLat, offsetLng)
+      );
+    }
+  }
+}
+class CoordinateUtils {
+  /**
+   * Convert coordinate arrays to proper format for polygon creation
+   */
+  static convertToCoords(latlngs, turfHelper) {
+    const coords = [];
+    if (latlngs.length > 1 && latlngs.length < 3) {
+      const coordinates = [];
+      const within = turfHelper.isWithin(
+        L$1.GeoJSON.latLngsToCoords(latlngs[latlngs.length - 1]),
+        L$1.GeoJSON.latLngsToCoords(latlngs[0])
+      );
+      if (within) {
+        latlngs.forEach((polygon2) => {
+          coordinates.push(L$1.GeoJSON.latLngsToCoords(polygon2));
+        });
+      } else {
+        latlngs.forEach((polygon2) => {
+          coords.push([L$1.GeoJSON.latLngsToCoords(polygon2)]);
+        });
+      }
+      if (coordinates.length >= 1) {
+        coords.push(coordinates);
+      }
+    } else if (latlngs.length > 2) {
+      const coordinates = [];
+      for (let index = 1; index < latlngs.length - 1; index++) {
+        const within = turfHelper.isWithin(
+          L$1.GeoJSON.latLngsToCoords(latlngs[index]),
+          L$1.GeoJSON.latLngsToCoords(latlngs[0])
+        );
+        if (within) {
+          latlngs.forEach((polygon2) => {
+            coordinates.push(L$1.GeoJSON.latLngsToCoords(polygon2));
+          });
+          coords.push(coordinates);
+        } else {
+          latlngs.forEach((polygon2) => {
+            coords.push([L$1.GeoJSON.latLngsToCoords(polygon2)]);
+          });
+        }
+      }
+    } else {
+      coords.push([L$1.GeoJSON.latLngsToCoords(latlngs[0])]);
+    }
+    return coords;
+  }
+  /**
+   * Apply offset to polygon coordinates
+   */
+  static offsetPolygonCoordinates(latLngs, offsetLat, offsetLng) {
+    return GeometryUtils.offsetPolygonCoordinates(latLngs, offsetLat, offsetLng);
+  }
+  /**
+   * Get latitude/longitude information string
+   */
+  static getLatLngInfoString(latlng) {
+    return "Latitude: " + latlng.lat + " Longitude: " + latlng.lng;
+  }
+  /**
+   * Convert any coordinate format to L.LatLng
+   * Supports multiple input formats with smart auto-detection
+   */
+  static convertToLatLng(coordinate) {
+    if (typeof coordinate === "object" && coordinate !== null) {
+      if ("lat" in coordinate && "lng" in coordinate) {
+        return leafletAdapter.createLatLng(
+          coordinate.lat,
+          coordinate.lng
+        );
+      }
+      if ("latitude" in coordinate && "longitude" in coordinate) {
+        return leafletAdapter.createLatLng(
+          coordinate.latitude,
+          coordinate.longitude
+        );
+      }
+      if ("longitude" in coordinate && "latitude" in coordinate) {
+        return leafletAdapter.createLatLng(
+          coordinate.latitude,
+          coordinate.longitude
+        );
+      }
+      if ("lng" in coordinate && "lat" in coordinate) {
+        return leafletAdapter.createLatLng(
+          coordinate.lat,
+          coordinate.lng
+        );
+      }
+    }
+    if (Array.isArray(coordinate) && coordinate.length >= 2) {
+      const [first, second] = coordinate;
+      if (typeof first === "number" && typeof second === "number") {
+        if (first > 90 || second > 90) {
+          return leafletAdapter.createLatLng(second, first);
+        }
+        if (first > 180 || second > 180) {
+          return leafletAdapter.createLatLng(second, first);
+        }
+        return leafletAdapter.createLatLng(first, second);
+      }
+    }
+    if (typeof coordinate === "string") {
+      const coord = coordinate.trim();
+      if (coord.includes(",") && !coord.includes("°") && !coord.includes("'") && !coord.includes('"')) {
+        const parts = coord.split(",").map((p) => parseFloat(p.trim()));
+        if (parts.length >= 2 && !isNaN(parts[0]) && !isNaN(parts[1])) {
+          return this.convertToLatLng(parts);
+        }
+      }
+      const dmsMatch = coord.match(
+        /(\d+)°(\d+)'(?:(\d+(?:\.\d+)?)")?([NS])\s*,?\s*(\d+)°(\d+)'(?:(\d+(?:\.\d+)?)")?([EW])/i
+      );
+      if (dmsMatch) {
+        const [, latDeg, latMin, latSec, latDir, lngDeg, lngMin, lngSec, lngDir] = dmsMatch;
+        const lat = parseFloat(latDeg) + parseFloat(latMin) / 60 + parseFloat(latSec || "0") / 3600;
+        const lng = parseFloat(lngDeg) + parseFloat(lngMin) / 60 + parseFloat(lngSec || "0") / 3600;
+        const finalLat = latDir.toUpperCase() === "S" ? -lat : lat;
+        const finalLng = lngDir.toUpperCase() === "W" ? -lng : lng;
+        return leafletAdapter.createLatLng(finalLat, finalLng);
+      }
+      const ddmMatch = coord.match(
+        /(\d+)°(\d+(?:\.\d+)?)'([NS])\s*,?\s*(\d+)°(\d+(?:\.\d+)?)'([EW])/i
+      );
+      if (ddmMatch) {
+        const [, latDeg, latMin, latDir, lngDeg, lngMin, lngDir] = ddmMatch;
+        const lat = parseFloat(latDeg) + parseFloat(latMin) / 60;
+        const lng = parseFloat(lngDeg) + parseFloat(lngMin) / 60;
+        const finalLat = latDir.toUpperCase() === "S" ? -lat : lat;
+        const finalLng = lngDir.toUpperCase() === "W" ? -lng : lng;
+        return leafletAdapter.createLatLng(finalLat, finalLng);
+      }
+      const ddMatch = coord.match(/(\d+(?:\.\d+)?)°?\s*([NS])\s*,\s*(\d+(?:\.\d+)?)°?\s*([EW])/i);
+      if (ddMatch) {
+        const [, lat, latDir, lng, lngDir] = ddMatch;
+        const finalLat = latDir.toUpperCase() === "S" ? -parseFloat(lat) : parseFloat(lat);
+        const finalLng = lngDir.toUpperCase() === "W" ? -parseFloat(lng) : parseFloat(lng);
+        return leafletAdapter.createLatLng(finalLat, finalLng);
+      }
+      const neMatch = coord.match(/N\s*(\d+(?:\.\d+)?)\s+E\s*(\d+(?:\.\d+)?)/i);
+      if (neMatch) {
+        const [, lat, lng] = neMatch;
+        return leafletAdapter.createLatLng(parseFloat(lat), parseFloat(lng));
+      }
+      const utmMatch = coord.match(/(?:UTM\s+)?(\d+)([NS])\s+(\d+(?:\.\d+)?)\s+(\d+(?:\.\d+)?)/i);
+      if (utmMatch) {
+        throw new Error(
+          `UTM coordinates detected: ${coord}. UTM conversion requires specialized libraries like proj4js. Please convert to decimal degrees first.`
+        );
+      }
+      const mgrsMatch = coord.match(/(\d+)([A-Z])\s+([A-Z]{2})\s+(\d+)\s+(\d+)/i);
+      if (mgrsMatch) {
+        throw new Error(
+          `MGRS coordinates detected: ${coord}. MGRS conversion requires specialized libraries. Please convert to decimal degrees first.`
+        );
+      }
+      const plusCodeMatch = coord.match(
+        /^[23456789CFGHJMPQRVWX]{2,3}[23456789CFGHJMPQRVWX]{3,7}\+[23456789CFGHJMPQRVWX]{2,3}$/i
+      );
+      if (plusCodeMatch) {
+        throw new Error(
+          `Plus Code detected: ${coord}. Plus Code conversion requires specialized libraries. Please convert to decimal degrees first.`
+        );
+      }
+    }
+    throw new Error(`Unable to convert coordinate: ${JSON.stringify(coordinate)}`);
+  }
+  /**
+   * Convert any coordinate array format to L.LatLng[][][]
+   * Used by addPredefinedPolygon for flexible input handling
+   */
+  static convertToLatLngArray(geoborders) {
+    return geoborders.map(
+      (group) => group.map((polygon2) => polygon2.map((coord) => this.convertToLatLng(coord)))
+    );
+  }
+  // ========================================================================
+  // POTENTIALLY UNUSED METHODS - TO BE REVIEWED FOR DELETION
+  // ========================================================================
+  // /**
+  //  * Simple within check (placeholder for more complex logic)
+  //  * This is a simplified version - in a real implementation this would use proper geometric algorithms
+  //  */
+  // private static isWithin(inner: number[][], outer: number[][]): boolean {
+  //   // Simplified check - just compare first points
+  //   if (!inner || !outer || inner.length === 0 || outer.length === 0) {
+  //     return false;
+  //   }
+  //   // This is a placeholder implementation
+  //   // In the real implementation, this would use proper point-in-polygon algorithms
+  //   return false;
+  // }
+}
+function deepMerge(target, ...sources) {
+  if (!sources.length) return target;
+  for (const source of sources) {
+    if (!source) continue;
+    for (const key in source) {
+      const sourceValue = source[key];
+      const targetValue = target[key];
+      if (sourceValue && typeof sourceValue === "object" && !Array.isArray(sourceValue)) {
+        const base = targetValue && typeof targetValue === "object" && !Array.isArray(targetValue) ? targetValue : {};
+        target[key] = deepMerge(base, sourceValue);
+      } else if (sourceValue !== void 0) {
+        target[key] = sourceValue;
+      }
+    }
+  }
+  return target;
+}
+class Polydraw extends L$1.Control {
   constructor(options) {
     super(options);
     __publicField(this, "map");
@@ -21172,20 +23189,25 @@ class Polydraw extends L.Control {
     __publicField(this, "_boundTouchMove");
     __publicField(this, "_boundTouchEnd");
     __publicField(this, "_boundTouchStart");
+    __publicField(this, "_boundPointerDown");
+    __publicField(this, "_boundPointerMove");
+    __publicField(this, "_boundPointerUp");
+    __publicField(this, "_lastTapTime", 0);
+    __publicField(this, "_tapTimeout", null);
     /**
      * Updates map interactions based on the current drawing mode.
      */
     __publicField(this, "_handleActivateToggle", () => {
       const container = this.getContainer();
       if (!container) return;
-      const activate = container.querySelector(".icon-activate");
-      if (L.DomUtil.hasClass(activate, "active")) {
-        L.DomUtil.removeClass(activate, "active");
+      const activateButton = container.querySelector(".icon-activate");
+      if (leafletAdapter.domUtil.hasClass(activateButton, "active")) {
+        leafletAdapter.domUtil.removeClass(activateButton, "active");
         if (this.subContainer) {
           this.subContainer.style.maxHeight = "0px";
         }
       } else {
-        L.DomUtil.addClass(activate, "active");
+        leafletAdapter.domUtil.addClass(activateButton, "active");
         if (this.subContainer) {
           this.subContainer.style.maxHeight = "250px";
         }
@@ -21239,6 +23261,18 @@ class Polydraw extends L.Control {
       this.setDrawMode(DrawMode.PointToPoint);
       this.polygonInformation.saveCurrentState();
     });
+    __publicField(this, "_handlePointToPointSubtractClick", (e) => {
+      if (e) {
+        e.preventDefault();
+        e.stopPropagation();
+      }
+      if (this.modeManager.getCurrentMode() === DrawMode.PointToPointSubtract) {
+        this.setDrawMode(DrawMode.Off);
+        return;
+      }
+      this.setDrawMode(DrawMode.PointToPointSubtract);
+      this.polygonInformation.saveCurrentState();
+    });
     /**
      * Handle marker hover when modifier key is held - event handler version
      */
@@ -21262,11 +23296,11 @@ class Polydraw extends L.Control {
         element.classList.remove("edge-deletion-hover");
       }
     });
-    this.config = defaultConfig;
+    const baseDefaults = structuredClone(defaultConfig);
+    this.config = deepMerge(baseDefaults, (options == null ? void 0 : options.config) ?? {});
     if (options == null ? void 0 : options.configPath) {
       this.loadExternalConfig(options.configPath, options == null ? void 0 : options.config);
     } else {
-      this.config = { ...defaultConfig, ...(options == null ? void 0 : options.config) || {} };
       this.initializeComponents();
     }
   }
@@ -21278,7 +23312,7 @@ class Polydraw extends L.Control {
    */
   onAdd(_map) {
     const extendedMap = _map;
-    const browser = L.Browser;
+    const browser = L$1.Browser;
     extendedMap._onResize = () => {
     };
     if (browser.touch && browser.mobile) {
@@ -21286,10 +23320,11 @@ class Polydraw extends L.Control {
     }
     this.map = _map;
     this.setupKeyboardHandlers();
-    const container = L.DomUtil.create("div", "leaflet-control leaflet-bar");
+    const container = leafletAdapter.domUtil.create("div", "leaflet-control leaflet-bar");
     this.initializeUI(container);
     this.createTracer();
     this.initializeManagers();
+    this.setDrawMode(this.config.defaultMode);
     this.setupEventListeners();
     return container;
   }
@@ -21323,10 +23358,11 @@ class Polydraw extends L.Control {
   }
   /**
    * Adds a predefined polygon to the map.
-   * @param geographicBorders - An array of LatLng arrays representing the polygon's coordinates.
+   * @param geoborders - Flexible coordinate format: objects ({lat, lng}), arrays ([lat, lng] or [lng, lat]), strings ("lat,lng" or "N59 E10")
    * @param options - Optional parameters, including visual optimization level.
    */
-  async addPredefinedPolygon(geographicBorders, options) {
+  async addPredefinedPolygon(geoborders, options) {
+    const geographicBorders = CoordinateUtils.convertToLatLngArray(geoborders);
     if (!geographicBorders || geographicBorders.length === 0) {
       throw new Error("Cannot add empty polygon array");
     }
@@ -21362,6 +23398,29 @@ class Polydraw extends L.Control {
       }
     }
   }
+  /**
+   * Adds predefined polygons from GeoJSON to the map.
+   * @param geojsonFeatures - An array of GeoJSON Polygon or MultiPolygon features.
+   * @param options - Optional parameters, including visual optimization level.
+   */
+  async addPredefinedGeoJSONs(geojsonFeatures, options) {
+    for (const geojsonFeature of geojsonFeatures) {
+      const { type, coordinates } = geojsonFeature.geometry;
+      if (type === "MultiPolygon") {
+        for (const polygonCoords of coordinates) {
+          const latLngs = polygonCoords.map(
+            (ring) => ring.map((point2) => L$1.latLng(point2[1], point2[0]))
+          );
+          await this.addPredefinedPolygon([latLngs], options);
+        }
+      } else if (type === "Polygon") {
+        const latLngs = coordinates.map(
+          (ring) => ring.map((point2) => L$1.latLng(point2[1], point2[0]))
+        );
+        await this.addPredefinedPolygon([latLngs], options);
+      }
+    }
+  }
   /**
    * Sets the current drawing mode.
    * @param mode - The drawing mode to set.
@@ -21369,12 +23428,12 @@ class Polydraw extends L.Control {
   setDrawMode(mode) {
     const previousMode = this.drawMode;
     this._updateDrawModeState(mode);
-    if (previousMode === DrawMode.PointToPoint && mode !== DrawMode.PointToPoint) {
+    if ((previousMode === DrawMode.PointToPoint || previousMode === DrawMode.PointToPointSubtract) && mode !== DrawMode.PointToPoint && mode !== DrawMode.PointToPointSubtract) {
       this.polygonDrawManager.clearP2pMarkers();
       this.stopDraw();
     } else if (mode === DrawMode.Off) {
       this.stopDraw();
-    } else if (mode !== DrawMode.PointToPoint) {
+    } else if (mode !== DrawMode.PointToPoint && mode !== DrawMode.PointToPointSubtract) {
       this.stopDraw();
     }
     if (this.map) {
@@ -21428,16 +23487,16 @@ class Polydraw extends L.Control {
    */
   initializeUI(container) {
     injectDynamicStyles(this.config);
-    L.DomEvent.disableClickPropagation(container);
-    L.DomEvent.on(container, "mousedown", L.DomEvent.stopPropagation);
-    L.DomEvent.on(container, "touchstart", L.DomEvent.stopPropagation);
-    L.DomEvent.on(container, "click", L.DomEvent.stopPropagation);
+    L$1.DomEvent.disableClickPropagation(container);
+    L$1.DomEvent.on(container, "mousedown", L$1.DomEvent.stopPropagation);
+    L$1.DomEvent.on(container, "touchstart", L$1.DomEvent.stopPropagation);
+    L$1.DomEvent.on(container, "click", L$1.DomEvent.stopPropagation);
     container.style.display = "flex";
     container.style.flexDirection = "column-reverse";
     container.style.pointerEvents = "auto";
     container.style.position = "relative";
     container.style.zIndex = "1000";
-    this.subContainer = L.DomUtil.create("div", "sub-buttons", container);
+    this.subContainer = leafletAdapter.domUtil.create("div", "sub-buttons", container);
     this.subContainer.style.maxHeight = "0px";
     this.subContainer.style.overflow = "hidden";
     this.subContainer.style.transition = "max-height 0.3s ease";
@@ -21451,7 +23510,8 @@ class Polydraw extends L.Control {
       this._handleDrawClick,
       this._handleSubtractClick,
       this._handleEraseClick,
-      this._handlePointToPointClick
+      this._handlePointToPointClick,
+      this._handlePointToPointSubtractClick
     );
     this.ensureButtonTouchResponsiveness(container);
     const uiUpdateListener = (mode) => {
@@ -21477,9 +23537,9 @@ class Polydraw extends L.Control {
       const mapZoomEnabled = this.modeManager.canPerformAction("mapZoom");
       const mapDoubleClickEnabled = this.modeManager.canPerformAction("mapDoubleClickZoom");
       if (shouldShowCrosshair) {
-        L.DomUtil.addClass(this.map.getContainer(), "crosshair-cursor-enabled");
+        leafletAdapter.domUtil.addClass(this.map.getContainer(), "crosshair-cursor-enabled");
       } else {
-        L.DomUtil.removeClass(this.map.getContainer(), "crosshair-cursor-enabled");
+        leafletAdapter.domUtil.removeClass(this.map.getContainer(), "crosshair-cursor-enabled");
       }
       this.events(false);
       this.setLeafletMapEvents(mapDragEnabled, mapDoubleClickEnabled, mapZoomEnabled);
@@ -21494,10 +23554,14 @@ class Polydraw extends L.Control {
     this.eventManager.on("polydraw:polygon:created", async (data) => {
       this.stopDraw();
       if (data.isPointToPoint) {
-        await this.polygonMutationManager.addPolygon(data.polygon, {
-          simplify: false,
-          noMerge: false
-        });
+        if (data.mode === DrawMode.PointToPointSubtract) {
+          await this.polygonMutationManager.subtractPolygon(data.polygon);
+        } else {
+          await this.polygonMutationManager.addPolygon(data.polygon, {
+            simplify: false,
+            noMerge: false
+          });
+        }
       } else {
         await this.handleFreehandDrawCompletion(data.polygon);
       }
@@ -21505,14 +23569,14 @@ class Polydraw extends L.Control {
     });
     this.eventManager.on("polydraw:draw:cancel", () => {
       this.stopDraw();
-      this.setDrawMode(DrawMode.Off);
+      this.setDrawMode(this.config.defaultMode);
     });
   }
   /**
    * Initializes and adds the tracer polyline to the map.
    */
   createTracer() {
-    this.tracer = L.polyline([], {
+    this.tracer = leafletAdapter.createPolyline([], {
       ...this.config.polyLineOptions,
       color: this.config.colors.polyline
     });
@@ -21557,18 +23621,18 @@ class Polydraw extends L.Control {
         );
       }
       const externalConfig = await response.json();
-      this.config = {
-        ...defaultConfig,
-        ...externalConfig,
-        ...inlineConfig || {}
-      };
+      this.config = deepMerge(
+        structuredClone(defaultConfig),
+        externalConfig ?? {},
+        inlineConfig ?? {}
+      );
       this.initializeComponents();
     } catch (error) {
       console.warn(
         "Failed to load external config, falling back to default + inline config:",
         error
       );
-      this.config = { ...defaultConfig, ...inlineConfig || {} };
+      this.config = deepMerge(structuredClone(defaultConfig), inlineConfig ?? {});
       this.initializeComponents();
     }
   }
@@ -21592,9 +23656,9 @@ class Polydraw extends L.Control {
   _updateUIAfterDrawModeChange(mode) {
     const shouldShowCrosshair = this.modeManager.shouldShowCrosshairCursor();
     if (shouldShowCrosshair) {
-      L.DomUtil.addClass(this.map.getContainer(), "crosshair-cursor-enabled");
+      leafletAdapter.domUtil.addClass(this.map.getContainer(), "crosshair-cursor-enabled");
     } else {
-      L.DomUtil.removeClass(this.map.getContainer(), "crosshair-cursor-enabled");
+      leafletAdapter.domUtil.removeClass(this.map.getContainer(), "crosshair-cursor-enabled");
     }
     try {
       switch (mode) {
@@ -21621,6 +23685,12 @@ class Polydraw extends L.Control {
             dashArray: "5, 5"
           });
           break;
+        case DrawMode.PointToPointSubtract:
+          this.tracer.setStyle({
+            color: this.config.colors.subtractLine,
+            dashArray: "5, 5"
+          });
+          break;
       }
     } catch (error) {
     }
@@ -21661,7 +23731,7 @@ class Polydraw extends L.Control {
     const shouldBeDraggable = this.modeManager.canPerformAction("markerDrag");
     this.arrayOfFeatureGroups.forEach((featureGroup) => {
       featureGroup.eachLayer((layer) => {
-        if (layer instanceof L.Marker) {
+        if (layer instanceof L$1.Marker) {
           const marker = layer;
           try {
             marker.options.draggable = shouldBeDraggable;
@@ -21719,12 +23789,19 @@ class Polydraw extends L.Control {
    * @param onoff - A boolean indicating whether to attach or detach the events.
    */
   drawStartedEvents(onoff) {
+    console.log("drawStartedEvents called with onoff:", onoff);
     const onoroff = onoff ? "on" : "off";
     this.map[onoroff]("mousemove", this.mouseMove, this);
     this.map[onoroff]("mouseup", this.mouseUpLeave, this);
     if (onoff) {
       this._boundTouchMove = (e) => this.mouseMove(e);
       this._boundTouchEnd = (e) => this.mouseUpLeave(e);
+      if (LeafletVersionDetector.isV2()) {
+        this._boundPointerMove = (e) => this.mouseMove(e);
+        this._boundPointerUp = (e) => this.mouseUpLeave(e);
+        this.map.getContainer().addEventListener("pointermove", this._boundPointerMove, { passive: false });
+        this.map.getContainer().addEventListener("pointerup", this._boundPointerUp, { passive: false });
+      }
       this.map.getContainer().addEventListener("touchmove", this._boundTouchMove, { passive: false });
       this.map.getContainer().addEventListener("touchend", this._boundTouchEnd, { passive: false });
     } else {
@@ -21734,6 +23811,12 @@ class Polydraw extends L.Control {
       if (this._boundTouchEnd) {
         this.map.getContainer().removeEventListener("touchend", this._boundTouchEnd);
       }
+      if (this._boundPointerMove) {
+        this.map.getContainer().removeEventListener("pointermove", this._boundPointerMove);
+      }
+      if (this._boundPointerUp) {
+        this.map.getContainer().removeEventListener("pointerup", this._boundPointerUp);
+      }
     }
   }
   /**
@@ -21745,74 +23828,111 @@ class Polydraw extends L.Control {
     this.map[onoroff]("mousedown", this.mouseDown, this);
     this.map[onoroff]("dblclick", this.handleDoubleClick, this);
     if (onoff) {
-      this._boundTouchStart = (e) => this.mouseDown(e);
+      this._boundTouchStart = (e) => this.handleTouchStart(e);
+      if (LeafletVersionDetector.isV2()) {
+        this._boundPointerDown = (e) => this.mouseDown(e);
+        this.map.getContainer().addEventListener("pointerdown", this._boundPointerDown, { passive: false });
+      }
       this.map.getContainer().addEventListener("touchstart", this._boundTouchStart, { passive: false });
     } else {
       if (this._boundTouchStart) {
         this.map.getContainer().removeEventListener("touchstart", this._boundTouchStart);
       }
+      if (this._boundPointerDown) {
+        this.map.getContainer().removeEventListener("pointerdown", this._boundPointerDown);
+      }
+    }
+  }
+  /**
+   * Handle touch start events with double-tap detection
+   * @param event - The touch event
+   */
+  handleTouchStart(event) {
+    const currentTime = Date.now();
+    const timeDiff = currentTime - this._lastTapTime;
+    if (this._tapTimeout) {
+      clearTimeout(this._tapTimeout);
+      this._tapTimeout = null;
+    }
+    if (timeDiff < 300 && timeDiff > 0) {
+      this.handleDoubleTap(event);
+      this._lastTapTime = 0;
+    } else {
+      this._lastTapTime = currentTime;
+      this._tapTimeout = window.setTimeout(() => {
+        this.mouseDown(event);
+        this._tapTimeout = null;
+      }, 300);
+    }
+  }
+  /**
+   * Handle double-tap for touch devices
+   * @param event - The touch event
+   */
+  handleDoubleTap(event) {
+    if (this.modeManager.getCurrentMode() !== DrawMode.PointToPoint && this.modeManager.getCurrentMode() !== DrawMode.PointToPointSubtract) {
+      return;
     }
+    this.polygonDrawManager.handleDoubleTap(event);
   }
   /**
    * Handles the mouse down event to start a drawing operation.
-   * @param event - The mouse or touch event.
+   * @param event - The mouse, touch, or pointer event.
    */
   mouseDown(event) {
-    if ("cancelable" in event && event.cancelable) {
-      event.preventDefault();
+    console.log("mouseDown called", event.type, event);
+    const normalizedEvent = EventAdapter.normalizeEvent(event);
+    if (EventAdapter.shouldPreventDefault(normalizedEvent)) {
+      normalizedEvent.preventDefault();
     }
     if (this.modeManager.isInOffMode()) {
+      console.log("In off mode, ignoring");
       return;
     }
-    let clickLatLng;
-    if ("latlng" in event && event.latlng) {
-      clickLatLng = event.latlng;
-    } else if ("touches" in event && event.touches && event.touches.length > 0) {
-      const rect = this.map.getContainer().getBoundingClientRect();
-      clickLatLng = this.map.containerPointToLatLng([
-        event.touches[0].clientX - rect.x,
-        event.touches[0].clientY - rect.y
-      ]);
-    }
+    const clickLatLng = EventAdapter.extractCoordinates(normalizedEvent, this.map);
+    console.log("Extracted coordinates:", clickLatLng);
     if (!clickLatLng) {
+      console.log("No coordinates extracted");
       return;
     }
-    if (this.modeManager.getCurrentMode() === DrawMode.PointToPoint) {
+    if (this.modeManager.getCurrentMode() === DrawMode.PointToPoint || this.modeManager.getCurrentMode() === DrawMode.PointToPointSubtract) {
+      console.log("Point-to-Point mode, calling handlePointToPointClick");
       this.polygonDrawManager.handlePointToPointClick(clickLatLng);
       return;
     }
+    console.log("Normal drawing mode, setting tracer and starting draw");
     this.tracer.setLatLngs([clickLatLng]);
     this.startDraw();
   }
   /**
    * Handles the mouse move event to draw the tracer polyline.
-   * @param event - The mouse or touch event.
+   * @param event - The mouse, touch, or pointer event.
    */
   mouseMove(event) {
-    if ("cancelable" in event && event.cancelable) {
-      event.preventDefault();
-    }
-    if ("latlng" in event && event.latlng) {
-      this.tracer.addLatLng(event.latlng);
-    } else if ("touches" in event && event.touches && event.touches.length > 0) {
-      const rect = this.map.getContainer().getBoundingClientRect();
-      const latlng = this.map.containerPointToLatLng([
-        event.touches[0].clientX - rect.x,
-        event.touches[0].clientY - rect.y
-      ]);
+    console.log("mouseMove called", event.type);
+    const normalizedEvent = EventAdapter.normalizeEvent(event);
+    if (EventAdapter.shouldPreventDefault(normalizedEvent)) {
+      normalizedEvent.preventDefault();
+    }
+    const latlng = EventAdapter.extractCoordinates(normalizedEvent, this.map);
+    if (latlng) {
+      console.log("Adding latlng to tracer:", latlng);
       this.tracer.addLatLng(latlng);
     }
   }
   /**
    * Handles the mouse up event to complete a drawing operation.
-   * @param event - The mouse or touch event.
+   * @param event - The mouse, touch, or pointer event.
    */
   async mouseUpLeave(event) {
-    if ("cancelable" in event && event.cancelable) {
-      event.preventDefault();
+    console.log("mouseUpLeave called", event.type);
+    const normalizedEvent = EventAdapter.normalizeEvent(event);
+    if (EventAdapter.shouldPreventDefault(normalizedEvent)) {
+      normalizedEvent.preventDefault();
     }
     this.polygonInformation.deletePolygonInformationStorage();
     const tracerGeoJSON = this.tracer.toGeoJSON();
+    console.log("Tracer GeoJSON:", tracerGeoJSON);
     if (!tracerGeoJSON || !tracerGeoJSON.geometry || !tracerGeoJSON.geometry.coordinates || tracerGeoJSON.geometry.coordinates.length < 3) {
       this.stopDraw();
       return;
@@ -21891,6 +24011,7 @@ class Polydraw extends L.Control {
    * Starts a drawing operation by attaching the necessary event listeners.
    */
   startDraw() {
+    console.log("startDraw called, attaching draw events");
     this.drawStartedEvents(true);
   }
   /**
@@ -21914,7 +24035,7 @@ class Polydraw extends L.Control {
    */
   handleKeyDown(e) {
     if (e.key === "Escape") {
-      if (this.modeManager.getCurrentMode() === DrawMode.PointToPoint) {
+      if (this.modeManager.getCurrentMode() === DrawMode.PointToPoint || this.modeManager.getCurrentMode() === DrawMode.PointToPointSubtract) {
         this.polygonDrawManager.cancelPointToPointDrawing();
       }
     }
@@ -21943,7 +24064,7 @@ class Polydraw extends L.Control {
   updateAllMarkersForEdgeDeletion(showFeedback) {
     this.arrayOfFeatureGroups.forEach((featureGroup) => {
       featureGroup.eachLayer((layer) => {
-        if (layer instanceof L.Marker) {
+        if (layer instanceof L$1.Marker) {
           this.updateMarkerForEdgeDeletion(layer, showFeedback);
         }
       });
@@ -21970,7 +24091,7 @@ class Polydraw extends L.Control {
    * @param e - The mouse event.
    */
   handleDoubleClick(e) {
-    if (this.modeManager.getCurrentMode() !== DrawMode.PointToPoint) {
+    if (this.modeManager.getCurrentMode() !== DrawMode.PointToPoint && this.modeManager.getCurrentMode() !== DrawMode.PointToPointSubtract) {
       return;
     }
     this.polygonDrawManager.handleDoubleClick(e);
@@ -22018,18 +24139,42 @@ class Polydraw extends L.Control {
     const activateButton = container.querySelector(".icon-activate");
     if (!activateButton) return;
     const hasPolygons = this.arrayOfFeatureGroups.length > 0;
-    const isPanelClosed = !L.DomUtil.hasClass(activateButton, "active");
-    if (hasPolygons && isPanelClosed) {
-      L.DomUtil.addClass(activateButton, "polydraw-indicator-active");
+    const isPanelClosed = !leafletAdapter.domUtil.hasClass(activateButton, "active");
+    const iconMarkup = leafletAdapter.domUtil.hasClass(activateButton, "active") ? activateButton.dataset.collapsedIcon : activateButton.dataset.activeIcon;
+    if (iconMarkup) {
+      this.applyActivateButtonIcon(activateButton, iconMarkup);
+    }
+    const hasIndicator = hasPolygons && isPanelClosed;
+    if (hasIndicator) {
+      leafletAdapter.domUtil.addClass(activateButton, "polydraw-indicator-active");
     } else {
-      L.DomUtil.removeClass(activateButton, "polydraw-indicator-active");
-    }
+      leafletAdapter.domUtil.removeClass(activateButton, "polydraw-indicator-active");
+    }
+    const baseBackground = this.config.colors.styles.controlButton.backgroundColor;
+    const baseColor = this.config.colors.styles.controlButton.color;
+    const indicatorBackground = this.config.colors.styles.indicatorActive.backgroundColor;
+    activateButton.style.backgroundColor = hasIndicator ? indicatorBackground : baseBackground;
+    activateButton.style.color = baseColor;
+  }
+  applyActivateButtonIcon(button, svgMarkup) {
+    button.innerHTML = svgMarkup;
+    const svgElement = button.querySelector("svg");
+    if (!svgElement) return;
+    svgElement.setAttribute("width", "24");
+    svgElement.setAttribute("height", "24");
+    svgElement.style.pointerEvents = "none";
+    svgElement.querySelectorAll("*").forEach((el) => {
+      el.style.pointerEvents = "none";
+    });
   }
 }
-L.control.polydraw = function(options) {
-  return new Polydraw(options);
-};
+if (typeof L$1 !== "undefined" && L$1.control) {
+  L$1.control.polydraw = function(options) {
+    return new Polydraw(options);
+  };
+}
 export {
-  Polydraw as default
+  Polydraw as default,
+  leafletAdapter
 };
 //# sourceMappingURL=polydraw.es.js.map