leaflet-polydraw 2.0.0 → 2.0.2

package/dist/polydraw.es.js

@@ -15606,9 +15606,11 @@ class PolygonInteractionManager {
     __publicField(this, "_boundDragEndListener", null);
     __publicField(this, "dragUsesPointerEvents", false);
     __publicField(this, "polygonTouchStartListeners", /* @__PURE__ */ new WeakMap());
+    __publicField(this, "polygonNativeStartListeners", /* @__PURE__ */ new WeakMap());
     __publicField(this, "_openMenuPopup", null);
     __publicField(this, "transformModeActive", false);
     __publicField(this, "transformControllers", /* @__PURE__ */ new WeakMap());
+    __publicField(this, "transformAuxiliaryDisplayValues", /* @__PURE__ */ new WeakMap());
     __publicField(this, "deleteMarkerSuppressUntil", 0);
     __publicField(this, "onModeChange", () => {
       if (this.currentCloneGhost || this.isPolygonDragActive()) {
@@ -15759,7 +15761,6 @@ class PolygonInteractionManager {
     switch (operation2) {
       case "addVertex":
       case "removeVertex":
-      case "removeHole":
       case "toggleOptimization":
         return operation2;
       case "modifierSubtract":
@@ -16347,6 +16348,9 @@ class PolygonInteractionManager {
                   const { level: optimizationLevel, original: originalOptimizationLevel } = this.getOptimizationMetadataFromFeatureGroup(featureGroup);
                   const featureMetadataState = this.getFeatureMetadataState(featureGroup);
                   const newPolygon = this.turfHelper.getMultiPolygon([coords]);
+                  if (this.saveHistoryState) {
+                    this.saveHistoryState("removeHole");
+                  }
                   this.cleanupFeatureGroup(featureGroup);
                   this.removeFeatureGroup(featureGroup);
                   this.emitPolygonUpdated({
@@ -16420,6 +16424,7 @@ class PolygonInteractionManager {
             interactive: true
           }
         );
+        edgePolyline._polydrawAuxiliaryLayer = true;
         edgePolyline._polydrawEdgeInfo = {
           ringIndex,
           edgeIndex: i,
@@ -16476,6 +16481,92 @@ class PolygonInteractionManager {
     if (!this.layerManager) return true;
     return this.layerManager.isInActiveLayer(fg) && this.layerManager.isFeatureGroupEditable(fg);
   }
+  beginPolygonDrag(polygon2, startLatLng, originalEvent, options = {}) {
+    var _a2, _b2;
+    if (this.transformModeActive) return false;
+    if (!this.isPolygonInActiveLayer(polygon2)) return false;
+    if (!this.isPolygonDragModeActive()) return false;
+    if (!this.modeManager.canPerformAction("polygonDrag")) return false;
+    if (!startLatLng) return false;
+    (_a2 = originalEvent.stopPropagation) == null ? void 0 : _a2.call(originalEvent);
+    if (originalEvent.cancelable) {
+      (_b2 = originalEvent.preventDefault) == null ? void 0 : _b2.call(originalEvent);
+    }
+    const existingDragData = polygon2._polydrawDragData;
+    if (this.currentDragPolygon === polygon2 && (existingDragData == null ? void 0 : existingDragData.isDragging)) {
+      return true;
+    }
+    const isCloneMode = this.modeManager.getCurrentMode() === DrawMode.Clone;
+    const isModifierPressed = isCloneMode ? false : this.detectDragSubtractModifierKey(originalEvent);
+    this.currentDragIsClone = isCloneMode;
+    this.currentModifierDragMode = isModifierPressed;
+    this.isModifierKeyHeld = isModifierPressed;
+    if (this.saveHistoryState) {
+      this.saveHistoryState(isCloneMode ? "polygonClone" : "polygonDrag");
+    }
+    polygon2._polydrawDragData = {
+      ...polygon2._polydrawDragData ?? {
+        originalOpacity: polygon2.options.fillOpacity
+      },
+      isDragging: true,
+      startPosition: startLatLng,
+      startLatLngs: polygon2.getLatLngs()
+    };
+    polygon2.setStyle({ fillOpacity: this.config.interaction.drag.opacity });
+    if (isCloneMode) {
+      this.showCloneGhost(polygon2._polydrawDragData.startLatLngs);
+    } else {
+      this.clearCloneGhost();
+    }
+    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.interaction.drag.dragCursor || "move";
+    } catch {
+    }
+    if (options.attachTouchListeners) {
+      this.attachDragTouchListeners();
+    }
+    this.attachDragDocumentListeners();
+    this.attachDragCancelHandlers();
+    this.currentDragPolygon = polygon2;
+    return true;
+  }
+  attachPolygonNativeStartListeners(polygon2) {
+    if (this.polygonNativeStartListeners.has(polygon2)) return;
+    const startFromNativeEvent = (event) => {
+      if (!this.isPolygonDragModeActive()) return;
+      const latlng = EventAdapter.extractCoordinates(
+        event,
+        this.map
+      );
+      this.beginPolygonDrag(polygon2, latlng, event, {
+        attachTouchListeners: event.type === "touchstart"
+      });
+    };
+    const listeners = {
+      mousedown: (event) => startFromNativeEvent(event),
+      pointerdown: (event) => startFromNativeEvent(event),
+      touchstart: (event) => startFromNativeEvent(event)
+    };
+    this.polygonNativeStartListeners.set(polygon2, listeners);
+    const attach = () => {
+      const el = polygon2._path;
+      if (!el) return;
+      el.addEventListener("mousedown", listeners.mousedown, { capture: true });
+      el.addEventListener("pointerdown", listeners.pointerdown, { capture: true });
+      el.addEventListener("touchstart", listeners.touchstart, { capture: true, passive: false });
+    };
+    if (polygon2._path) {
+      attach();
+    } else {
+      polygon2.once("add", attach);
+    }
+  }
   /**
    * Enable polygon dragging functionality
    */
@@ -16489,151 +16580,34 @@ class PolygonInteractionManager {
       originalOpacity: polygon2.options.fillOpacity
     };
     polygon2.on("mousedown", (e) => {
-      if (this.transformModeActive) {
-        return;
-      }
-      if (!this.isPolygonInActiveLayer(polygon2)) {
-        return;
-      }
       if (!this.isPolygonDragModeActive()) {
         L.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);
-      const isCloneMode = this.modeManager.getCurrentMode() === DrawMode.Clone;
-      const isModifierPressed = isCloneMode ? false : this.detectDragSubtractModifierKey(e.originalEvent);
-      this.currentDragIsClone = isCloneMode;
-      this.currentModifierDragMode = isModifierPressed;
-      this.isModifierKeyHeld = isModifierPressed;
-      if (this.saveHistoryState) {
-        this.saveHistoryState(isCloneMode ? "polygonClone" : "polygonDrag");
-      }
-      polygon2._polydrawDragData.isDragging = true;
-      polygon2._polydrawDragData.startPosition = e.latlng;
-      polygon2._polydrawDragData.startLatLngs = polygon2.getLatLngs();
-      polygon2.setStyle({ fillOpacity: this.config.interaction.drag.opacity });
-      if (isCloneMode) {
-        this.showCloneGhost(polygon2._polydrawDragData.startLatLngs);
-      } else {
-        this.clearCloneGhost();
-      }
-      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.interaction.drag.dragCursor || "move";
-      } catch {
-      }
-      this.attachDragDocumentListeners();
-      this.attachDragCancelHandlers();
-      this.currentDragPolygon = polygon2;
+      this.beginPolygonDrag(polygon2, e.latlng, e.originalEvent);
     });
     polygon2.on("pointerdown", ((event) => {
       const e = event;
-      if (this.transformModeActive) {
-        return;
-      }
-      if (!this.isPolygonInActiveLayer(polygon2)) {
-        return;
-      }
       if (!this.isPolygonDragModeActive()) {
         const originalEvent = e.originalEvent ?? e;
         L.DomEvent.stopPropagation(originalEvent);
         this.map.fire("pointerdown", e);
         return;
       }
-      if (!this.modeManager.canPerformAction("polygonDrag")) {
-        return;
-      }
       const orig = e.originalEvent ?? e;
-      L.DomEvent.stopPropagation(orig);
-      L.DomEvent.preventDefault(orig);
-      const isCloneMode = this.modeManager.getCurrentMode() === DrawMode.Clone;
-      const isModifierPressed = isCloneMode ? false : this.detectDragSubtractModifierKey(orig);
-      this.currentDragIsClone = isCloneMode;
-      this.currentModifierDragMode = isModifierPressed;
-      this.isModifierKeyHeld = isModifierPressed;
-      if (this.saveHistoryState) {
-        this.saveHistoryState(isCloneMode ? "polygonClone" : "polygonDrag");
-      }
-      polygon2._polydrawDragData.isDragging = true;
-      polygon2._polydrawDragData.startPosition = e.latlng;
-      polygon2._polydrawDragData.startLatLngs = polygon2.getLatLngs();
-      polygon2.setStyle({ fillOpacity: this.config.interaction.drag.opacity });
-      if (isCloneMode) {
-        this.showCloneGhost(polygon2._polydrawDragData.startLatLngs);
-      } else {
-        this.clearCloneGhost();
-      }
-      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.interaction.drag.dragCursor || "move";
-      } catch {
-      }
-      this.attachDragDocumentListeners();
-      this.attachDragCancelHandlers();
-      this.currentDragPolygon = polygon2;
+      this.beginPolygonDrag(polygon2, e.latlng, orig);
     }));
     if (LeafletVersionDetector.isV1()) {
       const onTouchStart = (e) => {
-        if (this.transformModeActive) return;
-        if (!this.isPolygonInActiveLayer(polygon2)) return;
         if (!this.isPolygonDragModeActive()) {
           return;
         }
-        if (!this.modeManager.canPerformAction("polygonDrag")) {
-          return;
-        }
-        e.stopPropagation();
-        e.preventDefault();
         const latlng = EventAdapter.extractCoordinates(
           e,
           this.map
         );
-        if (!latlng) return;
-        const isCloneMode = this.modeManager.getCurrentMode() === DrawMode.Clone;
-        this.currentDragIsClone = isCloneMode;
-        this.currentModifierDragMode = false;
-        this.isModifierKeyHeld = false;
-        if (this.saveHistoryState) {
-          this.saveHistoryState(isCloneMode ? "polygonClone" : "polygonDrag");
-        }
-        polygon2._polydrawDragData.isDragging = true;
-        polygon2._polydrawDragData.startPosition = latlng;
-        polygon2._polydrawDragData.startLatLngs = polygon2.getLatLngs();
-        polygon2.setStyle({ fillOpacity: this.config.interaction.drag.opacity });
-        if (isCloneMode) {
-          this.showCloneGhost(polygon2._polydrawDragData.startLatLngs);
-        } else {
-          this.clearCloneGhost();
-        }
-        if (this.map.dragging) {
-          this.map.dragging.disable();
-        }
-        this.setSubtractVisualMode(polygon2, false);
-        this.setMarkerVisibility(polygon2, false);
-        try {
-          const container = this.map.getContainer();
-          container.style.cursor = this.config.interaction.drag.dragCursor || "move";
-        } catch {
-        }
-        this.attachDragTouchListeners();
-        this.attachDragDocumentListeners();
-        this.attachDragCancelHandlers();
-        this.currentDragPolygon = polygon2;
+        this.beginPolygonDrag(polygon2, latlng, e, { attachTouchListeners: true });
       };
       this.polygonTouchStartListeners.set(polygon2, onTouchStart);
       const attachTouch = () => {
@@ -16650,6 +16624,7 @@ class PolygonInteractionManager {
         polygon2.once("add", attachTouch);
       }
     }
+    this.attachPolygonNativeStartListeners(polygon2);
     polygon2.on("mouseover", () => {
       if (!this.isPolygonInActiveLayer(polygon2)) return;
       if (!polygon2._polydrawDragData || !polygon2._polydrawDragData.isDragging) {
@@ -16675,6 +16650,7 @@ class PolygonInteractionManager {
    */
   updateMarkerDraggableState() {
     const shouldBeDraggable = this.modeManager.canPerformAction("markerDrag");
+    const markersShouldCapturePointer = this.modeManager.getCurrentMode() !== DrawMode.Clone;
     this.getFeatureGroups().forEach((featureGroup) => {
       const isActiveLayer = this.isFeatureGroupInActiveLayer(featureGroup);
       const effectiveDraggable = shouldBeDraggable && isActiveLayer;
@@ -16683,6 +16659,10 @@ class PolygonInteractionManager {
           const marker = layer;
           try {
             marker.options.draggable = effectiveDraggable;
+            const element = marker.getElement();
+            if (element) {
+              element.style.pointerEvents = markersShouldCapturePointer ? "auto" : "none";
+            }
             if (marker.dragging) {
               if (effectiveDraggable) {
                 marker.dragging.enable();
@@ -16777,6 +16757,7 @@ class PolygonInteractionManager {
       if (layer instanceof L.Marker) {
         this.cleanupMarker(layer);
       } else if (layer instanceof L.Polygon) {
+        this.detachPolygonNativeStartListeners(layer);
         this.detachPolygonTouchStart(layer);
         this.polygonFeatureGroupMap.delete(layer);
       }
@@ -17279,7 +17260,6 @@ class PolygonInteractionManager {
     if (this.dragUsesPointerEvents) {
       document.addEventListener("pointermove", this._boundDragMoveListener);
       document.addEventListener("pointerup", this._boundDragEndListener);
-      return;
     }
     document.addEventListener("mousemove", this._boundDragMoveListener);
     document.addEventListener("mouseup", this._boundDragEndListener);
@@ -17288,17 +17268,15 @@ class PolygonInteractionManager {
     if (this._boundDragMoveListener) {
       if (this.dragUsesPointerEvents) {
         document.removeEventListener("pointermove", this._boundDragMoveListener);
-      } else {
-        document.removeEventListener("mousemove", this._boundDragMoveListener);
       }
+      document.removeEventListener("mousemove", this._boundDragMoveListener);
       this._boundDragMoveListener = null;
     }
     if (this._boundDragEndListener) {
       if (this.dragUsesPointerEvents) {
         document.removeEventListener("pointerup", this._boundDragEndListener);
-      } else {
-        document.removeEventListener("mouseup", this._boundDragEndListener);
       }
+      document.removeEventListener("mouseup", this._boundDragEndListener);
       this._boundDragEndListener = null;
     }
     this.dragUsesPointerEvents = false;
@@ -17331,6 +17309,17 @@ class PolygonInteractionManager {
     }
     this.polygonTouchStartListeners.delete(polygon2);
   }
+  detachPolygonNativeStartListeners(polygon2) {
+    const listeners = this.polygonNativeStartListeners.get(polygon2);
+    if (!listeners) return;
+    const el = polygon2._path;
+    if (el) {
+      el.removeEventListener("mousedown", listeners.mousedown, { capture: true });
+      el.removeEventListener("pointerdown", listeners.pointerdown, { capture: true });
+      el.removeEventListener("touchstart", listeners.touchstart, { capture: true });
+    }
+    this.polygonNativeStartListeners.delete(polygon2);
+  }
   attachDragCancelHandlers() {
     if (this.dragCancelHandlersAttached) return;
     this.dragCancelHandlersAttached = true;
@@ -18033,6 +18022,36 @@ class PolygonInteractionManager {
       }
     });
   }
+  setTransformAuxiliaryVisibility(featureGroup, visible) {
+    const polygon2 = this.getPolygonLayer(featureGroup);
+    if (polygon2) {
+      this.setMarkerVisibility(polygon2, visible);
+    }
+    featureGroup.eachLayer((layer) => {
+      var _a2;
+      if (!this.isPolydrawAuxiliaryPolyline(layer)) {
+        return;
+      }
+      const element = (_a2 = layer.getElement) == null ? void 0 : _a2.call(layer);
+      if (!element) {
+        return;
+      }
+      if (!visible) {
+        if (!this.transformAuxiliaryDisplayValues.has(layer)) {
+          this.transformAuxiliaryDisplayValues.set(layer, element.style.display);
+        }
+        element.style.display = "none";
+        return;
+      }
+      if (this.transformAuxiliaryDisplayValues.has(layer)) {
+        element.style.display = this.transformAuxiliaryDisplayValues.get(layer) ?? "";
+        this.transformAuxiliaryDisplayValues.delete(layer);
+      }
+    });
+  }
+  isPolydrawAuxiliaryPolyline(layer) {
+    return layer instanceof L.Polyline && !(layer instanceof L.Polygon) && layer._polydrawAuxiliaryLayer === true;
+  }
   getBuiltInMenuButtonConfigs() {
     const menuOps = this.config.polygonTools;
     return [
@@ -18266,10 +18285,7 @@ class PolygonInteractionManager {
         (confirmed) => this.handleTransformControllerResult(controller, featureGroup, mode, confirmed)
       );
       this.transformControllers.set(featureGroup, controller);
-      const polygonLayer = this.getPolygonLayer(featureGroup);
-      if (polygonLayer) {
-        this.setMarkerVisibility(polygonLayer, false);
-      }
+      this.setTransformAuxiliaryVisibility(featureGroup, false);
       this.transformModeActive = true;
     } catch {
     }
@@ -18284,7 +18300,7 @@ class PolygonInteractionManager {
       return;
     }
     if (!confirmed) {
-      this.setMarkerVisibility(polygonLayer, true);
+      this.setTransformAuxiliaryVisibility(featureGroup, true);
       return;
     }
     const { level: optimizationLevel, original: originalOptimizationLevel } = this.getOptimizationMetadataFromFeatureGroup(featureGroup);
@@ -19126,6 +19142,7 @@ class PolygonMutationManager {
                   fillColor: this.config.styles.hole.fillColor,
                   fillOpacity: this.config.styles.hole.fillOpacity || 0.5
                 });
+                holePolyline._polydrawAuxiliaryLayer = true;
                 featureGroup.addLayer(holePolyline);
                 this.interactionManager.addHoleMarkers(latLngLiterals, featureGroup);
               }
@@ -21634,12 +21651,17 @@ class Polydraw extends L.Control {
     __publicField(this, "drawEventsAttached", false);
     __publicField(this, "controlEvents", /* @__PURE__ */ new WeakSet());
     __publicField(this, "lastControlPointerDown", null);
+    __publicField(this, "_boundMouseMove");
+    __publicField(this, "_boundMouseUp");
     __publicField(this, "_boundTouchMove");
     __publicField(this, "_boundTouchEnd");
+    __publicField(this, "_boundTouchCancel");
     __publicField(this, "_boundTouchStart");
     __publicField(this, "_boundPointerDown");
     __publicField(this, "_boundPointerMove");
     __publicField(this, "_boundPointerUp");
+    __publicField(this, "_boundPointerCancel");
+    __publicField(this, "_boundContextMenu");
     __publicField(this, "_lastTapTime", 0);
     __publicField(this, "_lastTapLatLng", null);
     __publicField(this, "_tapTimeout", null);
@@ -21653,6 +21675,7 @@ class Polydraw extends L.Control {
     __publicField(this, "_initRequestId", 0);
     __publicField(this, "_historySuppressionDepth", 0);
     __publicField(this, "_lastAppliedVisibleMapOrder", []);
+    __publicField(this, "originalMapTouchAction", null);
     /**
      * Updates map interactions based on the current drawing mode.
      */
@@ -21869,6 +21892,7 @@ class Polydraw extends L.Control {
   comprehensiveCleanup() {
     this.events(false);
     this.drawStartedEvents(false);
+    this.setMapDrawingTouchLock(false);
     this.removeKeyboardHandlers();
     if (this.tracer) {
       try {
@@ -21907,12 +21931,21 @@ class Polydraw extends L.Control {
     if (this._boundKeyUpHandler) {
       this._boundKeyUpHandler = void 0;
     }
+    if (this._boundMouseMove) {
+      this._boundMouseMove = void 0;
+    }
+    if (this._boundMouseUp) {
+      this._boundMouseUp = void 0;
+    }
     if (this._boundTouchMove) {
       this._boundTouchMove = void 0;
     }
     if (this._boundTouchEnd) {
       this._boundTouchEnd = void 0;
     }
+    if (this._boundTouchCancel) {
+      this._boundTouchCancel = void 0;
+    }
     if (this._boundTouchStart) {
       this._boundTouchStart = void 0;
     }
@@ -21925,6 +21958,12 @@ class Polydraw extends L.Control {
     if (this._boundPointerUp) {
       this._boundPointerUp = void 0;
     }
+    if (this._boundPointerCancel) {
+      this._boundPointerCancel = void 0;
+    }
+    if (this._boundContextMenu) {
+      this._boundContextMenu = void 0;
+    }
     if (this._tapTimeout) {
       clearTimeout(this._tapTimeout);
       this._tapTimeout = null;
@@ -23166,9 +23205,28 @@ class Polydraw extends L.Control {
     const mapDragEnabled = this.modeManager.canPerformAction("mapDrag");
     const mapZoomEnabled = this.modeManager.canPerformAction("mapZoom");
     const mapDoubleClickEnabled = this.modeManager.canPerformAction("mapDoubleClickZoom");
-    this.events(this.shouldEnableDrawEvents(this.drawMode));
+    const drawEventsEnabled = this.shouldEnableDrawEvents(this.drawMode);
+    this.events(drawEventsEnabled);
+    this.setMapDrawingTouchLock(drawEventsEnabled);
     this.setLeafletMapEvents(mapDragEnabled, mapDoubleClickEnabled, mapZoomEnabled);
   }
+  setMapDrawingTouchLock(enabled) {
+    if (!this.map) {
+      return;
+    }
+    const container = this.map.getContainer();
+    if (enabled) {
+      if (this.originalMapTouchAction === null) {
+        this.originalMapTouchAction = container.style.touchAction || "";
+      }
+      container.style.touchAction = "none";
+      return;
+    }
+    if (this.originalMapTouchAction !== null) {
+      container.style.touchAction = this.originalMapTouchAction;
+      this.originalMapTouchAction = null;
+    }
+  }
   /**
    * Restore the map state from a history snapshot
    */
@@ -23470,6 +23528,14 @@ class Polydraw extends L.Control {
       this.map[onoroff]("mouseup", this.mouseUpLeave, this);
     }
     if (onoff) {
+      if (!this._boundMouseMove) {
+        this._boundMouseMove = (e) => this.mouseMove(e);
+      }
+      if (!this._boundMouseUp) {
+        this._boundMouseUp = (e) => this.mouseUpLeave(e);
+      }
+      document.addEventListener("mousemove", this._boundMouseMove);
+      document.addEventListener("mouseup", this._boundMouseUp);
       if (!usePointerEvents) {
         if (!this._boundTouchMove) {
           this._boundTouchMove = (e) => this.mouseMove(e);
@@ -23477,8 +23543,12 @@ class Polydraw extends L.Control {
         if (!this._boundTouchEnd) {
           this._boundTouchEnd = (e) => this.mouseUpLeave(e);
         }
-        this.map.getContainer().addEventListener("touchmove", this._boundTouchMove, { passive: false });
-        this.map.getContainer().addEventListener("touchend", this._boundTouchEnd, { passive: false });
+        if (!this._boundTouchCancel) {
+          this._boundTouchCancel = (e) => this.mouseUpLeave(e);
+        }
+        document.addEventListener("touchmove", this._boundTouchMove, { passive: false });
+        document.addEventListener("touchend", this._boundTouchEnd, { passive: false });
+        document.addEventListener("touchcancel", this._boundTouchCancel, { passive: false });
       }
       if (usePointerEvents) {
         if (!this._boundPointerMove) {
@@ -23487,21 +23557,37 @@ class Polydraw extends L.Control {
         if (!this._boundPointerUp) {
           this._boundPointerUp = (e) => this.mouseUpLeave(e);
         }
-        this.map.getContainer().addEventListener("pointermove", this._boundPointerMove, { passive: false });
-        this.map.getContainer().addEventListener("pointerup", this._boundPointerUp, { passive: false });
+        if (!this._boundPointerCancel) {
+          this._boundPointerCancel = (e) => this.mouseUpLeave(e);
+        }
+        document.addEventListener("pointermove", this._boundPointerMove, { passive: false });
+        document.addEventListener("pointerup", this._boundPointerUp, { passive: false });
+        document.addEventListener("pointercancel", this._boundPointerCancel, { passive: false });
       }
     } else {
+      if (this._boundMouseMove) {
+        document.removeEventListener("mousemove", this._boundMouseMove);
+      }
+      if (this._boundMouseUp) {
+        document.removeEventListener("mouseup", this._boundMouseUp);
+      }
       if (this._boundTouchMove) {
-        this.map.getContainer().removeEventListener("touchmove", this._boundTouchMove);
+        document.removeEventListener("touchmove", this._boundTouchMove);
       }
       if (this._boundTouchEnd) {
-        this.map.getContainer().removeEventListener("touchend", this._boundTouchEnd);
+        document.removeEventListener("touchend", this._boundTouchEnd);
+      }
+      if (this._boundTouchCancel) {
+        document.removeEventListener("touchcancel", this._boundTouchCancel);
       }
       if (this._boundPointerMove) {
-        this.map.getContainer().removeEventListener("pointermove", this._boundPointerMove);
+        document.removeEventListener("pointermove", this._boundPointerMove);
       }
       if (this._boundPointerUp) {
-        this.map.getContainer().removeEventListener("pointerup", this._boundPointerUp);
+        document.removeEventListener("pointerup", this._boundPointerUp);
+      }
+      if (this._boundPointerCancel) {
+        document.removeEventListener("pointercancel", this._boundPointerCancel);
       }
     }
   }
@@ -23521,6 +23607,10 @@ class Polydraw extends L.Control {
     }
     this.map[onoroff]("dblclick", this.handleDoubleClick, this);
     if (onoff) {
+      if (!this._boundContextMenu) {
+        this._boundContextMenu = (e) => e.preventDefault();
+      }
+      this.map.getContainer().addEventListener("contextmenu", this._boundContextMenu);
       if (!usePointerEvents) {
         if (!this._boundTouchStart) {
           this._boundTouchStart = (e) => this.handleTouchStart(e);
@@ -23534,6 +23624,9 @@ class Polydraw extends L.Control {
         this.map.getContainer().addEventListener("pointerdown", this._boundPointerDown, { passive: false });
       }
     } else {
+      if (this._boundContextMenu) {
+        this.map.getContainer().removeEventListener("contextmenu", this._boundContextMenu);
+      }
       if (this._boundTouchStart) {
         this.map.getContainer().removeEventListener("touchstart", this._boundTouchStart);
       }
@@ -23547,6 +23640,9 @@ class Polydraw extends L.Control {
    * @param event - The touch event
    */
   handleTouchStart(event) {
+    if (EventAdapter.shouldPreventDefault(event)) {
+      event.preventDefault();
+    }
     const currentTime = Date.now();
     const timeDiff = currentTime - this._lastTapTime;
     const isPointToPointMode = this.modeManager.getCurrentMode() === DrawMode.PointToPoint || this.modeManager.getCurrentMode() === DrawMode.PointToPointSubtract;
@@ -23571,21 +23667,12 @@ class Polydraw extends L.Control {
       clearTimeout(this._tapTimeout);
       this._tapTimeout = null;
     }
-    if (timeDiff < 300 && timeDiff > 0) {
-      this.handleDoubleTap(event);
-      this._lastTapTime = 0;
-    } else {
-      this._lastTapTime = currentTime;
-      this._lastTapLatLng = EventAdapter.extractCoordinates(event, this.map);
-      if (!this.pointerEventsHandled) {
-        this._tapTimeout = window.setTimeout(() => {
-          this.mouseDown(event);
-          this._tapTimeout = null;
-        }, 300);
-      }
-    }
+    this._lastTapTime = currentTime;
+    this._lastTapLatLng = EventAdapter.extractCoordinates(event, this.map);
+    this.mouseDown(event);
   }
   isP2PDoubleTapClose(tapLatLng, timeDiff) {
+    if (!this.map) return false;
     if (!tapLatLng || !this._lastTapLatLng) return false;
     if (timeDiff <= 0 || timeDiff > 300) return false;
     const lastTapPoint = this.map.latLngToLayerPoint(this._lastTapLatLng);
@@ -23751,7 +23838,7 @@ class Polydraw extends L.Control {
    */
   mouseMove(event) {
     var _a2;
-    if (!this.isDrawingInProgress) {
+    if (!this.map || !this.isDrawingInProgress) {
       return;
     }
     const normalizedEvent = EventAdapter.normalizeEvent(event);
@@ -23769,7 +23856,7 @@ class Polydraw extends L.Control {
    */
   async mouseUpLeave(event) {
     var _a2;
-    if (!this.isDrawingInProgress) {
+    if (!this.map || !this.isDrawingInProgress) {
       return;
     }
     const normalizedEvent = EventAdapter.normalizeEvent(event);