leaflet-polydraw 0.9.5 → 1.0.0

package/dist/polydraw.es.js

@@ -2,7 +2,7 @@ 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";
+import * as L$1 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 };
@@ -37,6 +37,11 @@ const defaultConfig = {
   bezier: bezier$1,
   colors
 };
+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";
@@ -15955,7 +15960,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 +15971,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 +16771,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,43 +17247,561 @@ class TurfHelper {
     return feature2;
   }
 }
+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;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * Checks if we're running Leaflet v1.x
+   * @returns true if running v1.x
+   */
+  static isV1() {
+    return this.getVersion() === LeafletVersion.V1;
+  }
+  /**
+   * Checks if we're running Leaflet v2.x
+   * @returns true if running v2.x
+   */
+  static isV2() {
+    return this.getVersion() === LeafletVersion.V2;
+  }
+  /**
+   * Resets the cached version detection (useful for testing)
+   */
+  static reset() {
+    this._detectedVersion = null;
+  }
+  /**
+   * Gets detailed version information for debugging
+   * @returns Object with version details
+   */
+  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"
+    };
+  }
+}
+__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();
+  }
+  /**
+   * 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);
+    }
+  }
+  /**
+   * 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);
+    }
+  }
+  /**
+   * 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);
+    }
+  }
+  /**
+   * 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);
+    }
+  }
+  /**
+   * 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);
+    }
+  }
+  /**
+   * 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);
+    }
+  }
+  /**
+   * 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);
+    }
+  }
+  /**
+   * 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();
 function createButtons(container, subContainer, config, onActivateToggle, onDrawClick, onSubtractClick, onEraseClick, onPointToPointClick) {
-  const activate = L.DomUtil.create("a", "icon-activate", container);
+  const activate = leafletAdapter.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);
+  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 = L.DomUtil.create("a", "icon-draw", subContainer);
+    const draw = leafletAdapter.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);
+    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.stop).on(draw, "click", onDrawClick);
   }
   if (config.modes.subtract) {
-    const subtract = L.DomUtil.create("a", "icon-subtract", subContainer);
+    const subtract = leafletAdapter.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);
+    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.stop).on(subtract, "click", onSubtractClick);
   }
-  if (config.modes.p2p && !isTouchDevice()) {
-    const p2p = L.DomUtil.create("a", "icon-p2p", subContainer);
+  if (config.modes.p2p) {
+    const p2p = leafletAdapter.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);
+    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.stop).on(p2p, "click", onPointToPointClick);
   }
   if (config.modes.deleteAll) {
-    const erase = L.DomUtil.create("a", "icon-erase", subContainer);
+    const erase = leafletAdapter.domUtil.create(
+      "a",
+      "icon-erase",
+      subContainer
+    );
     erase.href = "#";
     erase.title = "Erase All";
     erase.innerHTML = `<?xml version="1.0" encoding="utf-8"?>
@@ -17297,9 +17820,9 @@ function createButtons(container, subContainer, config, onActivateToggle, onDraw
 	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);
+    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.stop).on(erase, "click", onEraseClick);
   }
 }
 class PolygonUtil {
@@ -17367,13 +17890,13 @@ class PolygonUtil {
     return bounds.getEast();
   }
   static getSqmArea(polygon2) {
-    const poly = new L.Polygon(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.Polygon(polygon2);
+    const poly = new L$1.Polygon(polygon2);
     const geoJsonPoly = poly.toGeoJSON();
     const perimeter = this.turfHelper.getPolygonPerimeter(geoJsonPoly);
     return perimeter * 1e3;
@@ -17399,7 +17922,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;
   }
@@ -17952,15 +18475,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 +18491,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 +18520,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();
           }
         });
@@ -18022,6 +18545,17 @@ class PolygonDrawManager {
       this.completePointToPointPolygon();
     }
   }
+  /**
+   * Handle double-tap to complete point-to-point polygon (touch devices)
+   */
+  handleDoubleTap(_e) {
+    if (this.modeManager.getCurrentMode() !== DrawMode.PointToPoint) {
+      return;
+    }
+    if (this.p2pMarkers.length >= 3) {
+      this.completePointToPointPolygon();
+    }
+  }
   /**
    * Complete point-to-point polygon drawing
    */
@@ -18090,12 +18624,21 @@ 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;
+    }
     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
    */
@@ -18162,7 +18705,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 +18737,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 +19104,7 @@ class IconFactory {
    */
   static createDivIcon(classNames) {
     const classes = classNames.join(" ");
-    return L.divIcon({ className: classes });
+    return leafletAdapter.createDivIcon({ className: classes });
   }
 }
 class PolygonInteractionManager {
@@ -18611,6 +19154,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();
       }
@@ -18694,7 +19239,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 +19255,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 +19268,7 @@ class PolygonInteractionManager {
           this.markerDragEnd(fg);
         }
         this._activeMarker = null;
-        L.DomEvent.stopPropagation(e);
+        L$1.DomEvent.stopPropagation(e);
         setTimeout(() => {
           this.isDraggingMarker = false;
         }, 10);
@@ -18836,7 +19381,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 +19389,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 +19446,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 +19462,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 +19475,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 +19580,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 +19588,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 = [];
@@ -19138,12 +19683,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 +19727,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 +19755,43 @@ 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.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 +19820,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 +19843,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);
         }
       });
@@ -19325,7 +19910,7 @@ class PolygonInteractionManager {
       } catch (error) {
       }
     }
-    L.DomEvent.stopPropagation(e);
+    L$1.DomEvent.stopPropagation(e);
   }
   highlightEdgeOnHover(edgePolyline, isHovering) {
     if (isHovering) {
@@ -19431,7 +20016,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 +20025,7 @@ class PolygonInteractionManager {
     }
     const posarrays = polygonLayer.getLatLngs();
     let length2 = 0;
-    const markers2 = layers.filter((layer) => layer instanceof L.Marker);
+    const markers2 = layers.filter((layer) => layer instanceof L$1.Marker);
     if (posarrays.length > 1) {
       for (let index = 0; index < posarrays.length; index++) {
         testarray = [];
@@ -19573,7 +20158,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 +20180,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 +20204,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);
@@ -19720,7 +20309,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) {
@@ -20006,7 +20595,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) {
@@ -20137,14 +20726,14 @@ class PolygonInteractionManager {
       });
       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 +20743,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 +20845,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 +21091,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 +21131,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 +21401,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 +21412,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 +21448,7 @@ class PolygonMutationManager {
     try {
       let polygon2 = null;
       featureGroup.eachLayer((layer) => {
-        if (layer instanceof L.Polygon) {
+        if (layer instanceof L$1.Polygon) {
           polygon2 = layer;
         }
       });
@@ -21033,7 +21622,7 @@ class PolygonMutationManager {
     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 +21738,402 @@ 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;
+  // }
+}
+class Polydraw extends L$1.Control {
   constructor(options) {
     super(options);
     __publicField(this, "map");
@@ -21172,6 +22156,11 @@ 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.
      */
@@ -21179,13 +22168,13 @@ class Polydraw extends L.Control {
       const container = this.getContainer();
       if (!container) return;
       const activate = container.querySelector(".icon-activate");
-      if (L.DomUtil.hasClass(activate, "active")) {
-        L.DomUtil.removeClass(activate, "active");
+      if (leafletAdapter.domUtil.hasClass(activate, "active")) {
+        leafletAdapter.domUtil.removeClass(activate, "active");
         if (this.subContainer) {
           this.subContainer.style.maxHeight = "0px";
         }
       } else {
-        L.DomUtil.addClass(activate, "active");
+        leafletAdapter.domUtil.addClass(activate, "active");
         if (this.subContainer) {
           this.subContainer.style.maxHeight = "250px";
         }
@@ -21278,7 +22267,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,7 +22275,7 @@ 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();
@@ -21323,10 +22312,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");
     }
@@ -21428,16 +22418,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";
@@ -21477,9 +22467,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);
@@ -21512,7 +22502,7 @@ class Polydraw extends L.Control {
    * 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
     });
@@ -21592,9 +22582,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) {
@@ -21661,7 +22651,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 +22709,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 +22731,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 +22748,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) {
+      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) {
+      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 +22931,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);
   }
   /**
@@ -21943,7 +22984,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);
         }
       });
@@ -22018,18 +23059,21 @@ 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");
+    const isPanelClosed = !leafletAdapter.domUtil.hasClass(activateButton, "active");
     if (hasPolygons && isPanelClosed) {
-      L.DomUtil.addClass(activateButton, "polydraw-indicator-active");
+      leafletAdapter.domUtil.addClass(activateButton, "polydraw-indicator-active");
     } else {
-      L.DomUtil.removeClass(activateButton, "polydraw-indicator-active");
+      leafletAdapter.domUtil.removeClass(activateButton, "polydraw-indicator-active");
     }
   }
 }
-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