leaflet-polydraw 0.9.4 → 0.9.5

package/dist/polydraw.es.js

@@ -14,11 +14,11 @@ const subtractLineOptions = { "opacity": 1, "smoothFactor": 0, "noClip": true, "
 const polygonOptions = { "smoothFactor": 0.3, "noClip": true };
 const holeOptions = { "weight": 2, "opacity": 1, "fillOpacity": 0.5 };
 const polygonCreation = { "method": "concaveman", "simplification": { "mode": "simple", "tolerance": 1e-5, "highQuality": false } };
-const simplification = { "simplifyTolerance": { "tolerance": 1e-4, "highQuality": false, "mutate": false }, "dynamicMode": { "fractionGuard": 0.9, "multipiler": 2 } };
+const simplification = { "simplifyTolerance": { "tolerance": 1e-4, "highQuality": false, "mutate": false }, "dynamicMode": { "fractionGuard": 0.9, "multiplier": 2 } };
 const menuOperations = { "simplify": { "processHoles": true }, "doubleElbows": { "processHoles": true }, "bbox": { "processHoles": true } };
 const boundingBox = { "addMidPointMarkers": true };
 const bezier$1 = { "resolution": 1e4, "sharpness": 0.75 };
-const colors = { "dragPolygons": { "subtract": "#D9460F" }, "p2p": { "closingMarker": "#4CAF50" }, "edgeHover": "#7a9441", "edgeDeletion": { "hover": "#D9460F" }, "polyline": "#50622b", "subtractLine": "#50622b", "polygon": { "border": "#50622b", "fill": "#b4cd8a" }, "hole": { "border": "#aa0000", "fill": "#ffcccc" }, "styles": { "controlButton": { "backgroundColor": "#fff", "color": "#000" }, "controlButtonHover": { "backgroundColor": "#f4f4f4" }, "controlButtonActive": { "backgroundColor": "rgb(128, 218, 255)", "color": "#fff" }, "indicatorActive": { "backgroundColor": "#ffcc00" }, "p2pMarker": { "backgroundColor": "#fff", "borderColor": "#50622b" } } };
+const colors = { "dragPolygons": { "subtract": "#D9460F" }, "p2p": { "closingMarker": "#4CAF50" }, "edgeHover": "#7a9441", "edgeDeletion": { "hover": "#D9460F" }, "polyline": "#50622b", "subtractLine": "#D9460F", "polygon": { "border": "#50622b", "fill": "#b4cd8a" }, "hole": { "border": "#aa0000", "fill": "#ffcccc" }, "styles": { "controlButton": { "backgroundColor": "#fff", "color": "#000" }, "controlButtonHover": { "backgroundColor": "#f4f4f4" }, "controlButtonActive": { "backgroundColor": "rgb(128, 218, 255)", "color": "#fff" }, "indicatorActive": { "backgroundColor": "#ffcc00" }, "p2pMarker": { "backgroundColor": "#fff", "borderColor": "#50622b" } } };
 const defaultConfig = {
   mergePolygons,
   kinks: kinks$1,
@@ -59,6 +59,174 @@ var MarkerPosition = /* @__PURE__ */ ((MarkerPosition2) => {
   MarkerPosition2[MarkerPosition2["Hole"] = 8] = "Hole";
   return MarkerPosition2;
 })(MarkerPosition || {});
+const EARTH_RADIUS = {
+  /**
+   * Mean radius in meters - good enough for this tool's precision requirements
+   * Used for distance calculations and area conversions
+   */
+  MEAN_METERS: 6371e3,
+  /** Mean radius in kilometers */
+  MEAN_KILOMETERS: 6371,
+  /** Mean radius in miles */
+  MEAN_MILES: 3959
+  // WGS84 ellipsoid values (more precise but overkill for this application)
+  // WGS84_SEMI_MAJOR_AXIS: 6378137.0,      // meters
+  // WGS84_SEMI_MINOR_AXIS: 6356752.314245, // meters
+  // WGS84_FLATTENING: 1 / 298.257223563,
+};
+const MATH = {
+  /** Degrees to radians conversion factor */
+  DEG_TO_RAD: Math.PI / 180,
+  /** Radians to degrees conversion factor */
+  RAD_TO_DEG: 180 / Math.PI
+};
+function point$1(coordinates, properties = {}) {
+  return {
+    type: "Feature",
+    geometry: {
+      type: "Point",
+      coordinates
+    },
+    properties
+  };
+}
+function lineString$1(coordinates, properties = {}) {
+  return {
+    type: "Feature",
+    geometry: {
+      type: "LineString",
+      coordinates
+    },
+    properties
+  };
+}
+function polygon$1(coordinates, properties = {}) {
+  return {
+    type: "Feature",
+    geometry: {
+      type: "Polygon",
+      coordinates
+    },
+    properties
+  };
+}
+function multiPolygon$1(coordinates, properties = {}) {
+  return {
+    type: "Feature",
+    geometry: {
+      type: "MultiPolygon",
+      coordinates
+    },
+    properties
+  };
+}
+function featureCollection$1(features) {
+  return {
+    type: "FeatureCollection",
+    features
+  };
+}
+function getCoords$1(feature2) {
+  if (feature2.geometry.type === "Polygon") {
+    return [feature2.geometry.coordinates];
+  } else if (feature2.geometry.type === "MultiPolygon") {
+    return feature2.geometry.coordinates;
+  }
+  throw new Error("Feature must be a Polygon or MultiPolygon");
+}
+function bbox$1(feature2) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  const processCoordinates = (coords) => {
+    if (Array.isArray(coords[0])) {
+      coords.forEach(processCoordinates);
+    } else {
+      const [x, y] = coords;
+      minX = Math.min(minX, x);
+      minY = Math.min(minY, y);
+      maxX = Math.max(maxX, x);
+      maxY = Math.max(maxY, y);
+    }
+  };
+  processCoordinates(feature2.geometry.coordinates);
+  return [minX, minY, maxX, maxY];
+}
+function bboxPolygon(bboxCoords) {
+  const [minX, minY, maxX, maxY] = bboxCoords;
+  return polygon$1([
+    [
+      [minX, minY],
+      [maxX, minY],
+      [maxX, maxY],
+      [minX, maxY],
+      [minX, minY]
+    ]
+  ]);
+}
+function distance$1(from, to, units = "kilometers") {
+  const fromCoords = Array.isArray(from) ? from : from.geometry.coordinates;
+  const toCoords = Array.isArray(to) ? to : to.geometry.coordinates;
+  const [lon1, lat1] = fromCoords;
+  const [lon2, lat2] = toCoords;
+  const R = units === "miles" ? EARTH_RADIUS.MEAN_MILES : units === "meters" ? EARTH_RADIUS.MEAN_METERS : EARTH_RADIUS.MEAN_KILOMETERS;
+  const dLat = toRadians(lat2 - lat1);
+  const dLon = toRadians(lon2 - lon1);
+  const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) + Math.cos(toRadians(lat1)) * Math.cos(toRadians(lat2)) * Math.sin(dLon / 2) * Math.sin(dLon / 2);
+  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+  return R * c;
+}
+function midpoint(point1, point2) {
+  const coords1 = Array.isArray(point1) ? point1 : point1.geometry.coordinates;
+  const coords2 = Array.isArray(point2) ? point2 : point2.geometry.coordinates;
+  const [lon1, lat1] = coords1;
+  const [lon2, lat2] = coords2;
+  const midLon = (lon1 + lon2) / 2;
+  const midLat = (lat1 + lat2) / 2;
+  return point$1([midLon, midLat]);
+}
+function area$1(feature2) {
+  const coords = getCoords$1(feature2);
+  let totalArea = 0;
+  for (const polygon2 of coords) {
+    for (let i = 0; i < polygon2.length; i++) {
+      const ring = polygon2[i];
+      const ringArea2 = calculateRingArea(ring);
+      totalArea += i === 0 ? Math.abs(ringArea2) : -Math.abs(ringArea2);
+    }
+  }
+  return Math.abs(totalArea);
+}
+function centroid$1(feature2) {
+  const coords = getCoords$1(feature2);
+  let totalX = 0;
+  let totalY = 0;
+  let totalPoints = 0;
+  for (const polygon2 of coords) {
+    for (const ring of polygon2) {
+      for (const coord of ring) {
+        totalX += coord[0];
+        totalY += coord[1];
+        totalPoints++;
+      }
+    }
+  }
+  return point$1([totalX / totalPoints, totalY / totalPoints]);
+}
+function toRadians(degrees2) {
+  return degrees2 * MATH.DEG_TO_RAD;
+}
+function calculateRingArea(ring) {
+  let area2 = 0;
+  const n = ring.length;
+  for (let i = 0; i < n - 1; i++) {
+    const [x12, y12] = ring[i];
+    const [x2, y2] = ring[i + 1];
+    area2 += x12 * y2 - x2 * y12;
+  }
+  return Math.abs(area2) * 0.5 * Math.pow(EARTH_RADIUS.MEAN_METERS * MATH.DEG_TO_RAD, 2);
+}
 var earthRadius = 63710088e-1;
 var factors = {
   centimeters: earthRadius * 100,
@@ -179,10 +347,6 @@ function lengthToRadians(distance2, units = "kilometers") {
   }
   return distance2 / factor;
 }
-function radiansToDegrees(radians2) {
-  const normalisedRadians = radians2 % (2 * Math.PI);
-  return normalisedRadians * 180 / Math.PI;
-}
 function degreesToRadians(degrees2) {
   const normalisedDegrees = degrees2 % 360;
   return normalisedDegrees * Math.PI / 180;
@@ -1221,7 +1385,6 @@ function centroid(geojson, options = {}) {
   );
   return point([xSum / len, ySum / len], options.properties);
 }
-var turf_centroid_default = centroid;
 function getCoord(coord) {
   if (!coord) {
     throw new Error("coord is required");
@@ -4517,7 +4680,6 @@ function bbox(geojson, options = {}) {
   });
   return result;
 }
-var turf_bbox_default = bbox;
 function center(geojson, options = {}) {
   const ext = bbox(geojson);
   const x = (ext[0] + ext[2]) / 2;
@@ -14140,7 +14302,6 @@ function ringArea(coords) {
   }
   return total * FACTOR;
 }
-var turf_area_default = area;
 const epsilon = 11102230246251565e-32;
 const splitter = 134217729;
 const resulterrbound = (3 + 8 * epsilon) * epsilon;
@@ -15027,63 +15188,6 @@ function unkinkPolygon(geojson) {
   return featureCollection(features);
 }
 var turf_unkink_polygon_default = unkinkPolygon;
-function bearing(start, end, options = {}) {
-  if (options.final === true) {
-    return calculateFinalBearing(start, end);
-  }
-  const coordinates1 = getCoord(start);
-  const coordinates2 = getCoord(end);
-  const lon1 = degreesToRadians(coordinates1[0]);
-  const lon2 = degreesToRadians(coordinates2[0]);
-  const lat1 = degreesToRadians(coordinates1[1]);
-  const lat2 = degreesToRadians(coordinates2[1]);
-  const a = Math.sin(lon2 - lon1) * Math.cos(lat2);
-  const b = Math.cos(lat1) * Math.sin(lat2) - Math.sin(lat1) * Math.cos(lat2) * Math.cos(lon2 - lon1);
-  return radiansToDegrees(Math.atan2(a, b));
-}
-function calculateFinalBearing(start, end) {
-  let bear = bearing(end, start);
-  bear = (bear + 180) % 360;
-  return bear;
-}
-function destination(origin, distance2, bearing2, options = {}) {
-  const coordinates1 = getCoord(origin);
-  const longitude1 = degreesToRadians(coordinates1[0]);
-  const latitude1 = degreesToRadians(coordinates1[1]);
-  const bearingRad = degreesToRadians(bearing2);
-  const radians2 = lengthToRadians(distance2, options.units);
-  const latitude2 = Math.asin(
-    Math.sin(latitude1) * Math.cos(radians2) + Math.cos(latitude1) * Math.sin(radians2) * Math.cos(bearingRad)
-  );
-  const longitude2 = longitude1 + Math.atan2(
-    Math.sin(bearingRad) * Math.sin(radians2) * Math.cos(latitude1),
-    Math.cos(radians2) - Math.sin(latitude1) * Math.sin(latitude2)
-  );
-  const lng = radiansToDegrees(longitude2);
-  const lat = radiansToDegrees(latitude2);
-  return point([lng, lat], options.properties);
-}
-function distance(from, to, options = {}) {
-  var coordinates1 = getCoord(from);
-  var coordinates2 = getCoord(to);
-  var dLat = degreesToRadians(coordinates2[1] - coordinates1[1]);
-  var dLon = degreesToRadians(coordinates2[0] - coordinates1[0]);
-  var lat1 = degreesToRadians(coordinates1[1]);
-  var lat2 = degreesToRadians(coordinates2[1]);
-  var a = Math.pow(Math.sin(dLat / 2), 2) + Math.pow(Math.sin(dLon / 2), 2) * Math.cos(lat1) * Math.cos(lat2);
-  return radiansToLength(
-    2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)),
-    options.units
-  );
-}
-var turf_distance_default = distance;
-function midpoint(point1, point2) {
-  const dist = distance(point1, point2);
-  const heading = bearing(point1, point2);
-  const midpoint2 = destination(point1, dist / 2, heading);
-  return midpoint2;
-}
-var turf_midpoint_default = midpoint;
 function booleanPointOnLine(pt, line, options = {}) {
   const ptCoords = getCoord(pt);
   const lineCoords = getCoords(line);
@@ -15508,27 +15612,19 @@ function booleanEqual(feature1, feature2, options = {}) {
   });
 }
 var turf_boolean_equal_default = booleanEqual;
-function bboxPolygon(bbox2, options = {}) {
-  const west = Number(bbox2[0]);
-  const south = Number(bbox2[1]);
-  const east = Number(bbox2[2]);
-  const north = Number(bbox2[3]);
-  if (bbox2.length === 6) {
-    throw new Error(
-      "@turf/bbox-polygon does not support BBox with 6 positions"
-    );
-  }
-  const lowLeft = [west, south];
-  const topLeft = [west, north];
-  const topRight = [east, north];
-  const lowRight = [east, south];
-  return polygon(
-    [[lowLeft, lowRight, topRight, topLeft, lowLeft]],
-    options.properties,
-    { bbox: bbox2, id: options.id }
+function distance(from, to, options = {}) {
+  var coordinates1 = getCoord(from);
+  var coordinates2 = getCoord(to);
+  var dLat = degreesToRadians(coordinates2[1] - coordinates1[1]);
+  var dLon = degreesToRadians(coordinates2[0] - coordinates1[0]);
+  var lat1 = degreesToRadians(coordinates1[1]);
+  var lat2 = degreesToRadians(coordinates2[1]);
+  var a = Math.pow(Math.sin(dLat / 2), 2) + Math.pow(Math.sin(dLon / 2), 2) * Math.cos(lat1) * Math.cos(lat2);
+  return radiansToLength(
+    2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)),
+    options.units
   );
 }
-var turf_bbox_polygon_default = bboxPolygon;
 var __defProp2 = Object.defineProperty;
 var __defProps = Object.defineProperties;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
@@ -15842,113 +15938,366 @@ function length(geojson, options = {}) {
   );
 }
 var turf_length_default = length;
-class TurfHelper {
-  constructor(config) {
-    __publicField(this, "config", defaultConfig);
-    this.config = { ...defaultConfig, ...config };
-  }
-  union(poly1, poly2) {
-    try {
-      const fc = featureCollection([poly1, poly2]);
-      const u2 = turf_union_default(fc);
-      return u2 ? this.getTurfPolygon(u2) : null;
-    } catch (error) {
-      console.warn("Error in union:", error instanceof Error ? error.message : String(error));
-      return null;
-    }
-  }
+const isTouchDevice = () => "ontouchstart" in window || navigator.maxTouchPoints > 0;
+function isTestEnvironment() {
+  return typeof vitest !== "undefined";
+}
+class PolyDrawUtil {
   /**
-   * Create polygon from drawing trace using configured method
+   * Gets the bounds of the polygon with optional padding.
+   * @param polygon Array of LatLng points.
+   * @param padding Padding factor.
+   * @returns The LatLngBounds.
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  createPolygonFromTrace(feature2) {
-    var _a2;
-    const method = ((_a2 = this.config.polygonCreation) == null ? void 0 : _a2.method) || "concaveman";
-    switch (method) {
-      case "concaveman":
-        return this.turfConcaveman(feature2);
-      case "convex":
-        return this.createConvexPolygon(feature2);
-      case "direct":
-        return this.createDirectPolygon(feature2);
-      case "buffer":
-        return this.createBufferedPolygon(feature2);
-      default:
-        console.warn(`Unknown polygon creation method: ${method}, falling back to concaveman`);
-        return this.turfConcaveman(feature2);
+  static getBounds(polygon2, padding = 0) {
+    const tmpLatLng = [];
+    polygon2.forEach((ll) => {
+      if (isNaN(ll.lat) || isNaN(ll.lng)) ;
+      tmpLatLng.push(ll);
+    });
+    const polyLine = new L.Polyline(tmpLatLng);
+    const bounds = polyLine.getBounds();
+    if (padding !== 0) {
+      return bounds.pad(padding);
     }
+    return bounds;
   }
-  /**
-   * Original concaveman implementation
-   */
-  turfConcaveman(feature2) {
-    const points = turf_explode_default(feature2);
-    const coordinates = points.features.map((f) => f.geometry.coordinates);
-    return multiPolygon([[concaveman(coordinates)]]);
+}
+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)
+    });
+    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);
   }
-  /**
-   * Create convex hull polygon (simplest, fewest edges)
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  createConvexPolygon(feature2) {
-    const points = turf_explode_default(feature2);
-    const convexHull = turf_convex_default(points);
-    if (!convexHull) {
-      return this.createDirectPolygon(feature2);
+  getDirection(direction) {
+    switch (direction) {
+      case MarkerPosition.SouthWest:
+        return this.direction.SouthWest;
+      case MarkerPosition.West:
+        return this.direction.West;
+      case MarkerPosition.NorthWest:
+        return this.direction.NorthWest;
+      case MarkerPosition.North:
+        return this.direction.North;
+      case MarkerPosition.NorthEast:
+        return this.direction.NorthEast;
+      case MarkerPosition.East:
+        return this.direction.East;
+      case MarkerPosition.SouthEast:
+        return this.direction.SouthEast;
+      case MarkerPosition.South:
+        return this.direction.South;
+      default:
+        throw new Error();
     }
-    return this.getTurfPolygon(convexHull);
   }
-  /**
-   * Create polygon directly from line coordinates (moderate edge count)
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  createDirectPolygon(feature2) {
-    let coordinates;
-    if (feature2.geometry.type === "LineString") {
-      coordinates = feature2.geometry.coordinates;
-    } else if (feature2.geometry.type === "Polygon") {
-      coordinates = feature2.geometry.coordinates[0];
-    } else {
-      const points = turf_explode_default(feature2);
-      coordinates = points.features.map((f) => f.geometry.coordinates);
+  getPositions(startPosition = MarkerPosition.SouthWest, clockwise = false, addClosingNode = true) {
+    const positions = [];
+    const posArray = this.getPositionAsArray(startPosition, clockwise);
+    posArray.forEach((v) => {
+      positions.push([v.lng, v.lat]);
+    });
+    if (addClosingNode) {
+      positions.push([posArray[0].lng, posArray[0].lat]);
     }
-    if (coordinates.length > 0) {
-      const first = coordinates[0];
-      const last = coordinates[coordinates.length - 1];
-      if (first[0] !== last[0] || first[1] !== last[1]) {
-        coordinates.push([first[0], first[1]]);
-      }
+    return positions;
+  }
+  getPositionAsArray(startPosition = MarkerPosition.NorthEast, clockwise = false) {
+    const positions = [];
+    if (clockwise) {
+      positions.push(this.direction.SouthWest);
+      positions.push(this.direction.West);
+      positions.push(this.direction.NorthWest);
+      positions.push(this.direction.North);
+      positions.push(this.direction.NorthEast);
+      positions.push(this.direction.East);
+      positions.push(this.direction.SouthEast);
+      positions.push(this.direction.South);
+    } else {
+      positions.push(this.direction.SouthWest);
+      positions.push(this.direction.South);
+      positions.push(this.direction.SouthEast);
+      positions.push(this.direction.East);
+      positions.push(this.direction.NorthEast);
+      positions.push(this.direction.North);
+      positions.push(this.direction.NorthWest);
+      positions.push(this.direction.West);
     }
-    if (coordinates.length < 4) {
-      console.warn("Not enough points for direct polygon, falling back to concaveman");
-      return this.turfConcaveman(feature2);
+    if (startPosition !== MarkerPosition.SouthWest) {
+      const chunk = positions.splice(0, startPosition);
+      chunk.forEach((v, i) => {
+        positions.splice(startPosition + i, 0, v);
+      });
     }
-    return multiPolygon([[coordinates]]);
+    return positions;
   }
-  /**
-   * Create polygon using buffer method (smooth curves)
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  createBufferedPolygon(feature2) {
-    try {
-      let line;
-      if (feature2.geometry.type === "LineString") {
-        line = feature2;
-      } else {
-        const points = turf_explode_default(feature2);
-        const coordinates = points.features.map((f) => f.geometry.coordinates);
-        line = lineString(coordinates);
-      }
-      const buffered = turf_buffer_default(line, 1e-3, { units: "kilometers" });
-      if (!buffered) {
-        return this.createDirectPolygon(feature2);
-      }
-      return this.getTurfPolygon(buffered);
+}
+class Perimeter {
+  constructor(length2, config) {
+    __publicField(this, "metricLength", "");
+    __publicField(this, "metricUnit", "");
+    __publicField(this, "imperialLength", "");
+    __publicField(this, "imperialUnit", "");
+    if (length2 !== null || length2 !== void 0) {
+      if (length2 === 0) {
+        if (config.markers.markerInfoIcon.usePerimeterMinValue) {
+          this.metricLength = config.markers.markerInfoIcon.values.min.metric;
+          this.metricUnit = config.markers.markerInfoIcon.units.metric.perimeter.m;
+          this.imperialLength = config.markers.markerInfoIcon.values.min.imperial;
+          this.imperialUnit = config.markers.markerInfoIcon.units.imperial.perimeter.feet;
+        } else {
+          this.metricLength = config.markers.markerInfoIcon.values.unknown.metric;
+          this.metricUnit = config.markers.markerInfoIcon.units.unknownUnit;
+          this.imperialLength = config.markers.markerInfoIcon.values.unknown.imperial;
+          this.imperialUnit = config.markers.markerInfoIcon.units.unknownUnit;
+        }
+      } else if (length2 < 100) {
+        this.metricLength = (Math.ceil(length2 / 10) * 10).toString();
+        this.metricUnit = config.markers.markerInfoIcon.units.metric.perimeter.m;
+      } else if (length2 < 500) {
+        this.metricLength = (Math.ceil(length2 / 50) * 50).toString();
+        this.metricUnit = config.markers.markerInfoIcon.units.metric.perimeter.m;
+      } else if (length2 < 1e3) {
+        this.metricLength = (Math.ceil(length2 / 100) * 100).toString();
+        this.metricUnit = config.markers.markerInfoIcon.units.metric.perimeter.m;
+      } else if (length2 < 1e4) {
+        this.metricLength = (Math.ceil(length2 / 100) * 100 / 1e3).toFixed(1);
+        this.metricUnit = config.markers.markerInfoIcon.units.metric.perimeter.km;
+      } else {
+        this.metricLength = (Math.ceil(length2 / 1e3) * 1e3 / 1e3).toString();
+        this.metricUnit = config.markers.markerInfoIcon.units.metric.perimeter.km;
+      }
+      const inch = length2 / 0.0254;
+      const feet = inch / 12;
+      const yards = feet / 3;
+      const miles = yards / 1760;
+      if (length2 < 1e3 / 2.54) {
+        this.imperialLength = (Math.ceil(feet / 10) * 10).toString();
+        this.imperialUnit = config.markers.markerInfoIcon.units.imperial.perimeter.feet;
+      } else if (length2 < 1e3 / 2.54 * 3) {
+        this.imperialLength = (Math.ceil(yards / 10) * 10).toString();
+        this.imperialUnit = config.markers.markerInfoIcon.units.imperial.perimeter.yards;
+      } else if (length2 < 1609) {
+        this.imperialLength = miles.toFixed(2);
+        this.imperialUnit = config.markers.markerInfoIcon.units.imperial.perimeter.miles;
+      } else if (length2 < 16093) {
+        this.imperialLength = miles.toFixed(1);
+        this.imperialUnit = config.markers.markerInfoIcon.units.imperial.perimeter.miles;
+      } else {
+        this.imperialLength = miles.toFixed(0);
+        this.imperialUnit = config.markers.markerInfoIcon.units.imperial.perimeter.miles;
+      }
+    }
+  }
+}
+class Area {
+  constructor(sqrMeterArea, config) {
+    __publicField(this, "metricArea", "");
+    __publicField(this, "metricUnit", "");
+    __publicField(this, "imperialArea", "");
+    __publicField(this, "imperialUnit", "");
+    const area2 = sqrMeterArea;
+    const onlyMetrics = config.markers.markerInfoIcon.units.metric.onlyMetrics;
+    if (area2 !== null || area2 !== void 0) {
+      if (area2 === 0) {
+        this.metricArea = "-";
+        this.metricUnit = config.markers.markerInfoIcon.units.unknownUnit;
+        this.imperialArea = "-";
+        this.imperialUnit = config.markers.markerInfoIcon.units.unknownUnit;
+      } else if (area2 < 1e4) {
+        this.metricArea = Math.round(area2).toString();
+        this.metricUnit = config.markers.markerInfoIcon.units.metric.area.m2;
+      } else if (area2 < 1e5) {
+        if (onlyMetrics) {
+          this.metricArea = (area2 / 1e6).toFixed(2);
+          this.metricUnit = config.markers.markerInfoIcon.units.metric.area.km2;
+        } else {
+          this.metricArea = (area2 / 1e3).toFixed(1);
+          this.metricUnit = config.markers.markerInfoIcon.units.metric.area.daa;
+        }
+      } else if (area2 < 1e7) {
+        if (onlyMetrics) {
+          this.metricArea = (area2 / 1e6).toFixed(2);
+          this.metricUnit = config.markers.markerInfoIcon.units.metric.area.km2;
+        } else {
+          this.metricArea = Math.round(area2 / 1e3).toString();
+          this.metricUnit = config.markers.markerInfoIcon.units.metric.area.daa;
+        }
+      } else if (area2 < 1e8) {
+        if (onlyMetrics) {
+          this.metricArea = (area2 / 1e6).toFixed(1);
+          this.metricUnit = config.markers.markerInfoIcon.units.metric.area.km2;
+        } else {
+          this.metricArea = Math.round(area2 / 1e4).toString();
+          this.metricUnit = config.markers.markerInfoIcon.units.metric.area.ha;
+        }
+      } else {
+        this.metricArea = Math.round(area2 / 1e6).toString();
+        this.metricUnit = config.markers.markerInfoIcon.units.metric.area.km2;
+      }
+      const inch2 = area2 * 1550;
+      const feet2 = inch2 * 69444e-7;
+      const yards2 = feet2 * 0.11111;
+      const acres = yards2 * 20661e-8;
+      const miles2 = yards2 * 32283e-11;
+      if (area2 < 92.9) {
+        this.imperialArea = Math.round(feet2).toString();
+        this.imperialUnit = config.markers.markerInfoIcon.units.imperial.area.feet2;
+      } else if (area2 < 836.14) {
+        this.imperialArea = yards2.toFixed(0);
+        this.imperialUnit = config.markers.markerInfoIcon.units.imperial.area.yards2;
+      } else if (area2 < 40469.6) {
+        this.imperialArea = acres.toFixed(2);
+        this.imperialUnit = config.markers.markerInfoIcon.units.imperial.area.acres;
+      } else if (area2 < 404696) {
+        this.imperialArea = acres.toFixed(1);
+        this.imperialUnit = config.markers.markerInfoIcon.units.imperial.area.acres;
+      } else if (area2 < 4046960) {
+        this.imperialArea = acres.toFixed(0);
+        this.imperialUnit = config.markers.markerInfoIcon.units.imperial.area.acres;
+      } else if (area2 < 25900404) {
+        this.imperialArea = miles2.toFixed(2);
+        this.imperialUnit = config.markers.markerInfoIcon.units.imperial.area.miles2;
+      } else if (area2 < 259004040) {
+        this.imperialArea = miles2.toFixed(1);
+        this.imperialUnit = config.markers.markerInfoIcon.units.imperial.area.miles2;
+      } else {
+        this.imperialArea = miles2.toFixed(0);
+        this.imperialUnit = config.markers.markerInfoIcon.units.imperial.area.miles2;
+      }
+    }
+  }
+}
+class TurfHelper {
+  constructor(config) {
+    __publicField(this, "config", defaultConfig);
+    this.config = { ...defaultConfig, ...config };
+  }
+  union(poly1, poly2) {
+    try {
+      const fc = featureCollection$1([poly1, poly2]);
+      const u2 = turf_union_default(fc);
+      return u2 ? this.getTurfPolygon(u2) : null;
     } catch (error) {
-      console.warn(
-        "Buffer polygon creation failed:",
-        error instanceof Error ? error.message : String(error)
-      );
+      if (!isTestEnvironment()) {
+        console.warn("Error in union:", error instanceof Error ? error.message : String(error));
+      }
+      return null;
+    }
+  }
+  /**
+   * Create polygon from drawing trace using configured method
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  createPolygonFromTrace(feature2) {
+    var _a2;
+    const method = ((_a2 = this.config.polygonCreation) == null ? void 0 : _a2.method) || "concaveman";
+    switch (method) {
+      case "concaveman":
+        return this.turfConcaveman(feature2);
+      case "convex":
+        return this.createConvexPolygon(feature2);
+      case "direct":
+        return this.createDirectPolygon(feature2);
+      case "buffer":
+        return this.createBufferedPolygon(feature2);
+      default:
+        if (!isTestEnvironment()) {
+          console.warn(`Unknown polygon creation method: ${method}, falling back to concaveman`);
+        }
+        return this.turfConcaveman(feature2);
+    }
+  }
+  /**
+   * Original concaveman implementation
+   */
+  turfConcaveman(feature2) {
+    const points = turf_explode_default(feature2);
+    const coordinates = points.features.map((f) => f.geometry.coordinates);
+    return multiPolygon$1([[concaveman(coordinates)]]);
+  }
+  /**
+   * Create convex hull polygon (simplest, fewest edges)
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  createConvexPolygon(feature2) {
+    const points = turf_explode_default(feature2);
+    const convexHull = turf_convex_default(points);
+    if (!convexHull) {
+      return this.createDirectPolygon(feature2);
+    }
+    return this.getTurfPolygon(convexHull);
+  }
+  /**
+   * Create polygon directly from line coordinates (moderate edge count)
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  createDirectPolygon(feature2) {
+    let coordinates;
+    if (feature2.geometry.type === "LineString") {
+      coordinates = feature2.geometry.coordinates;
+    } else if (feature2.geometry.type === "Polygon") {
+      coordinates = feature2.geometry.coordinates[0];
+    } else {
+      const points = turf_explode_default(feature2);
+      coordinates = points.features.map((f) => f.geometry.coordinates);
+    }
+    if (coordinates.length > 0) {
+      const first = coordinates[0];
+      const last = coordinates[coordinates.length - 1];
+      if (first[0] !== last[0] || first[1] !== last[1]) {
+        coordinates.push([first[0], first[1]]);
+      }
+    }
+    if (coordinates.length < 4) {
+      if (!isTestEnvironment()) {
+        console.warn("Not enough points for direct polygon, falling back to concaveman");
+      }
+      return this.turfConcaveman(feature2);
+    }
+    return multiPolygon$1([[coordinates]]);
+  }
+  /**
+   * Create polygon using buffer method (smooth curves)
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  createBufferedPolygon(feature2) {
+    try {
+      let line;
+      if (feature2.geometry.type === "LineString") {
+        line = feature2;
+      } else {
+        const points = turf_explode_default(feature2);
+        const coordinates = points.features.map((f) => f.geometry.coordinates);
+        line = lineString$1(coordinates);
+      }
+      const buffered = turf_buffer_default(line, 1e-3, { units: "kilometers" });
+      if (!buffered) {
+        return this.createDirectPolygon(feature2);
+      }
+      return this.getTurfPolygon(buffered);
+    } catch (error) {
+      if (!isTestEnvironment()) {
+        console.warn(
+          "Buffer polygon creation failed:",
+          error instanceof Error ? error.message : String(error)
+        );
+      }
       return this.createDirectPolygon(feature2);
     }
   }
@@ -15972,9 +16321,9 @@ class TurfHelper {
       } else {
         let simplified = turf_simplify_default(polygon2, tolerance);
         const fractionGuard = this.config.simplification.dynamicMode.fractionGuard;
-        const multipiler = this.config.simplification.dynamicMode.multipiler;
+        const multiplier = this.config.simplification.dynamicMode.multiplier;
         while (simplified.geometry.coordinates[0][0].length > 4 && simplified.geometry.coordinates[0][0].length / (numOfEdges + 2) > fractionGuard) {
-          tolerance.tolerance = tolerance.tolerance * multipiler;
+          tolerance.tolerance = tolerance.tolerance * multiplier;
           simplified = turf_simplify_default(polygon2, tolerance);
         }
         return simplified;
@@ -15982,7 +16331,9 @@ class TurfHelper {
     } else if (simplificationMode === "none") {
       return polygon2;
     } else {
-      console.warn(`Unknown simplification mode: ${simplificationMode}, falling back to simple`);
+      if (!isTestEnvironment()) {
+        console.warn(`Unknown simplification mode: ${simplificationMode}, falling back to simple`);
+      }
       const tolerance = {
         tolerance: 1e-4,
         highQuality: false,
@@ -15994,14 +16345,14 @@ class TurfHelper {
   getTurfPolygon(polygon2) {
     let turfPolygon;
     if (polygon2.geometry.type === "Polygon") {
-      turfPolygon = multiPolygon([polygon2.geometry.coordinates]);
+      turfPolygon = multiPolygon$1([polygon2.geometry.coordinates]);
     } else {
-      turfPolygon = multiPolygon(polygon2.geometry.coordinates);
+      turfPolygon = multiPolygon$1(polygon2.geometry.coordinates);
     }
     return turfPolygon;
   }
   getMultiPolygon(polygonArray) {
-    return multiPolygon(polygonArray);
+    return multiPolygon$1(polygonArray);
   }
   getKinks(feature2) {
     try {
@@ -16010,7 +16361,9 @@ class TurfHelper {
       }
       const cleanedFeature = this.removeDuplicateVertices(feature2);
       if (!cleanedFeature || !cleanedFeature.geometry || !cleanedFeature.geometry.coordinates) {
-        console.warn("Feature became invalid after cleaning in getKinks");
+        if (!isTestEnvironment()) {
+          console.warn("Feature became invalid after cleaning in getKinks");
+        }
         return [feature2];
       }
       const hasHoles = this.polygonHasHoles(cleanedFeature);
@@ -16025,15 +16378,17 @@ class TurfHelper {
         return coordinates;
       }
     } catch (error) {
-      console.warn(
-        "Error processing kinks:",
-        error instanceof Error ? error.message : String(error)
-      );
+      if (!isTestEnvironment()) {
+        console.warn(
+          "Error processing kinks:",
+          error instanceof Error ? error.message : String(error)
+        );
+      }
       return [feature2];
     }
   }
   getCoords(feature2) {
-    return getCoords(feature2);
+    return getCoords$1(feature2);
   }
   hasKinks(feature2) {
     const k = turf_kinks_default(feature2);
@@ -16044,13 +16399,15 @@ class TurfHelper {
    */
   getConvexHull(polygon2) {
     try {
-      const fc = featureCollection([polygon2]);
+      const fc = featureCollection$1([polygon2]);
       return turf_convex_default(fc);
     } catch (error) {
-      console.warn(
-        "Error in getConvexHull:",
-        error instanceof Error ? error.message : String(error)
-      );
+      if (!isTestEnvironment()) {
+        console.warn(
+          "Error in getConvexHull:",
+          error instanceof Error ? error.message : String(error)
+        );
+      }
       return null;
     }
   }
@@ -16058,9 +16415,9 @@ class TurfHelper {
    * Calculate midpoint between two LatLngLiteral points
    */
   getMidpoint(point1, point2) {
-    const p1 = point([point1.lng, point1.lat]);
-    const p2 = point([point2.lng, point2.lat]);
-    const mp = turf_midpoint_default(p1, p2);
+    const p1 = point$1([point1.lng, point1.lat]);
+    const p2 = point$1([point2.lng, point2.lat]);
+    const mp = midpoint(p1, p2);
     return {
       lat: mp.geometry.coordinates[1],
       lng: mp.geometry.coordinates[0]
@@ -16069,14 +16426,32 @@ class TurfHelper {
   polygonIntersect(polygon2, latlngs) {
     try {
       if (!polygon2 || !polygon2.geometry || !polygon2.geometry.coordinates || !latlngs || !latlngs.geometry || !latlngs.geometry.coordinates) {
-        console.warn("Invalid features passed to polygonIntersect");
+        if (!isTestEnvironment()) {
+          console.warn("Invalid features passed to polygonIntersect");
+        }
+        return false;
+      }
+      const validateCoordinates = (coords) => {
+        if (!Array.isArray(coords)) return false;
+        for (const ring of coords) {
+          if (!Array.isArray(ring)) return false;
+          for (const coord of ring) {
+            if (!Array.isArray(coord) || coord.length < 2) return false;
+            if (coord.some((c) => c === null || c === void 0 || !isFinite(c))) {
+              return false;
+            }
+          }
+        }
+        return true;
+      };
+      if (!validateCoordinates(polygon2.geometry.coordinates) || !validateCoordinates(latlngs.geometry.coordinates)) {
         return false;
       }
       try {
-        const fc = featureCollection([polygon2, latlngs]);
+        const fc = featureCollection$1([polygon2, latlngs]);
         const intersection3 = turf_intersect_default(fc);
         if (intersection3 && intersection3.geometry && (intersection3.geometry.type === "Polygon" || intersection3.geometry.type === "MultiPolygon")) {
-          const polygonArea2 = turf_area_default(intersection3);
+          const polygonArea2 = area$1(intersection3);
           if (polygonArea2 > 1e-6) {
             return true;
           }
@@ -16099,16 +16474,28 @@ class TurfHelper {
       } catch (error) {
       }
       try {
-        const coords1 = getCoords(polygon2);
-        const coords2 = getCoords(latlngs);
+        const coords1 = getCoords$1(polygon2);
+        const coords2 = getCoords$1(latlngs);
         for (const ring1 of coords1) {
           const outerRing1 = ring1[0];
+          if (!outerRing1 || outerRing1.length < 2) continue;
           for (let i = 0; i < outerRing1.length - 1; i++) {
-            const line1 = lineString([outerRing1[i], outerRing1[i + 1]]);
+            const coord1 = outerRing1[i];
+            const coord2 = outerRing1[i + 1];
+            if (!coord1 || !coord2 || !Array.isArray(coord1) || !Array.isArray(coord2) || coord1.length < 2 || coord2.length < 2 || coord1.some((c) => c === null || c === void 0 || !isFinite(c)) || coord2.some((c) => c === null || c === void 0 || !isFinite(c))) {
+              continue;
+            }
+            const line1 = lineString$1([coord1, coord2]);
             for (const ring2 of coords2) {
               const outerRing2 = ring2[0];
+              if (!outerRing2 || outerRing2.length < 2) continue;
               for (let j = 0; j < outerRing2.length - 1; j++) {
-                const line2 = lineString([outerRing2[j], outerRing2[j + 1]]);
+                const coord3 = outerRing2[j];
+                const coord4 = outerRing2[j + 1];
+                if (!coord3 || !coord4 || !Array.isArray(coord3) || !Array.isArray(coord4) || coord3.length < 2 || coord4.length < 2 || coord3.some((c) => c === null || c === void 0 || !isFinite(c)) || coord4.some((c) => c === null || c === void 0 || !isFinite(c))) {
+                  continue;
+                }
+                const line2 = lineString$1([coord3, coord4]);
                 try {
                   const intersection3 = turf_line_intersect_default(line1, line2);
                   if (intersection3 && intersection3.features && intersection3.features.length > 0) {
@@ -16124,42 +16511,48 @@ class TurfHelper {
       }
       try {
       } catch (error) {
+        if (!isTestEnvironment()) {
+          console.warn(
+            "Error in bounding box check:",
+            error instanceof Error ? error.message : String(error)
+          );
+        }
+      }
+      return false;
+    } catch (error) {
+      if (!isTestEnvironment()) {
         console.warn(
-          "Error in bounding box check:",
+          "Error in polygonIntersect:",
           error instanceof Error ? error.message : String(error)
         );
       }
       return false;
-    } catch (error) {
-      console.warn(
-        "Error in polygonIntersect:",
-        error instanceof Error ? error.message : String(error)
-      );
-      return false;
     }
   }
   getIntersection(poly1, poly2) {
     try {
-      const fc = featureCollection([poly1, poly2]);
+      const fc = featureCollection$1([poly1, poly2]);
       const result = turf_intersect_default(fc);
       if (result && result.geometry && (result.geometry.type === "Polygon" || result.geometry.type === "MultiPolygon")) {
         return result;
       }
       return null;
     } catch (error) {
-      console.warn(
-        "Error in getIntersection:",
-        error instanceof Error ? error.message : String(error)
-      );
+      if (!isTestEnvironment()) {
+        console.warn(
+          "Error in getIntersection:",
+          error instanceof Error ? error.message : String(error)
+        );
+      }
       return null;
     }
   }
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   getDistance(point1, point2) {
-    return turf_distance_default(point1, point2);
+    return distance$1(point1, point2);
   }
   isWithin(polygon1, polygon2) {
-    return turf_boolean_within_default(polygon([polygon1]), polygon([polygon2]));
+    return turf_boolean_within_default(polygon$1([polygon1]), polygon$1([polygon2]));
   }
   /**
    * Check if one polygon is completely within another polygon
@@ -16168,16 +16561,16 @@ class TurfHelper {
     try {
       return turf_boolean_within_default(innerPolygon, outerPolygon);
     } catch (error) {
-      const innerCoords = getCoords(innerPolygon);
-      const outerCoords = getCoords(outerPolygon);
+      const innerCoords = getCoords$1(innerPolygon);
+      const outerCoords = getCoords$1(outerPolygon);
       for (const innerRing of innerCoords) {
         for (const ring of innerRing) {
           for (const coord of ring) {
-            const pt = point(coord);
+            const pt = point$1(coord);
             let isInside = false;
             for (const outerRing of outerCoords) {
               for (const outerRingCoords of outerRing) {
-                const outerPoly = polygon([outerRingCoords]);
+                const outerPoly = polygon$1([outerRingCoords]);
                 if (turf_boolean_point_in_polygon_default(pt, outerPoly)) {
                   isInside = true;
                   break;
@@ -16204,14 +16597,14 @@ class TurfHelper {
       return pt;
     }
     if (Array.isArray(pt) && pt.length >= 2 && typeof pt[0] === "number" && typeof pt[1] === "number") {
-      return point(pt);
+      return point$1(pt);
     }
     if (typeof (pt == null ? void 0 : pt.lat) === "number" && typeof (pt == null ? void 0 : pt.lng) === "number") {
       const p = pt;
-      return point([p.lng, p.lat]);
+      return point$1([p.lng, p.lat]);
     }
     if (((_b2 = pt == null ? void 0 : pt.geometry) == null ? void 0 : _b2.coordinates) && Array.isArray(pt.geometry.coordinates)) {
-      return point(pt.geometry.coordinates);
+      return point$1(pt.geometry.coordinates);
     }
     throw new Error("Unsupported point format provided to toPointFeature");
   }
@@ -16237,12 +16630,12 @@ class TurfHelper {
     return turf_boolean_equal_default(polygon1, polygon2);
   }
   convertToBoundingBoxPolygon(polygon2) {
-    const bboxCoords = turf_bbox_default(polygon2.geometry);
-    const bboxPoly = turf_bbox_polygon_default(bboxCoords);
+    const bboxCoords = bbox$1(polygon2);
+    const bboxPoly = bboxPolygon(bboxCoords);
     return bboxPoly;
   }
   polygonToMultiPolygon(poly) {
-    const multi = multiPolygon([poly.geometry.coordinates]);
+    const multi = multiPolygon$1([poly.geometry.coordinates]);
     return multi;
   }
   injectPointToPolygon(polygon2, point2, ringIndex) {
@@ -16298,15 +16691,17 @@ class TurfHelper {
   }
   polygonDifference(polygon1, polygon2) {
     try {
-      const fc = featureCollection([polygon1, polygon2]);
+      const fc = featureCollection$1([polygon1, polygon2]);
       const diff = turf_difference_default(fc);
       const result = diff ? this.getTurfPolygon(diff) : null;
       return result;
     } catch (error) {
-      console.warn(
-        "Error in polygonDifference:",
-        error instanceof Error ? error.message : String(error)
-      );
+      if (!isTestEnvironment()) {
+        console.warn(
+          "Error in polygonDifference:",
+          error instanceof Error ? error.message : String(error)
+        );
+      }
       return null;
     }
   }
@@ -16332,18 +16727,29 @@ class TurfHelper {
   getCoord(point2) {
     return [point2.lng, point2.lat];
   }
+  /**
+   * Create a GeoJSON polygon feature from coordinates.
+   * This method provides access to the turf polygon helper function
+   * while keeping all turf imports centralized in this file.
+   *
+   * @param coordinates - Array of coordinate rings (outer ring + holes)
+   * @returns GeoJSON Feature<Polygon>
+   */
+  createPolygon(coordinates) {
+    return polygon$1(coordinates);
+  }
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   getFeaturePointCollection(points) {
     const pts = [];
     points.forEach((v) => {
-      const p = point([v.lng, v.lat], {});
+      const p = point$1([v.lng, v.lat], {});
       pts.push(p);
     });
-    const fc = featureCollection(pts);
+    const fc = featureCollection$1(pts);
     return fc;
   }
   getPolygonArea(poly) {
-    const polygonArea2 = turf_area_default(poly);
+    const polygonArea2 = area$1(poly);
     return polygonArea2;
   }
   getPolygonPerimeter(poly) {
@@ -16361,7 +16767,7 @@ class TurfHelper {
       const p1 = points[i];
       const p2 = points[(i + 1) % effectiveLen];
       doubleized.push(new L.LatLng(p1.lat, p1.lng));
-      const midPoint = turf_midpoint_default(point([p1.lng, p1.lat]), point([p2.lng, p2.lat]));
+      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])
       );
@@ -16393,10 +16799,12 @@ class TurfHelper {
       }
       return false;
     } catch (error) {
-      console.warn(
-        "Error checking for holes:",
-        error instanceof Error ? error.message : String(error)
-      );
+      if (!isTestEnvironment()) {
+        console.warn(
+          "Error checking for holes:",
+          error instanceof Error ? error.message : String(error)
+        );
+      }
       return false;
     }
   }
@@ -16458,10 +16866,12 @@ class TurfHelper {
       }
       return [feature2];
     } catch (error) {
-      console.warn(
-        "Error in getKinksWithHolePreservation:",
-        error instanceof Error ? error.message : String(error)
-      );
+      if (!isTestEnvironment()) {
+        console.warn(
+          "Error in getKinksWithHolePreservation:",
+          error instanceof Error ? error.message : String(error)
+        );
+      }
       return [feature2];
     }
   }
@@ -16495,10 +16905,12 @@ class TurfHelper {
       }
       return false;
     } catch (error) {
-      console.warn(
-        "Error checking complete hole traversal:",
-        error instanceof Error ? error.message : String(error)
-      );
+      if (!isTestEnvironment()) {
+        console.warn(
+          "Error checking complete hole traversal:",
+          error instanceof Error ? error.message : String(error)
+        );
+      }
       return false;
     }
   }
@@ -16530,10 +16942,12 @@ class TurfHelper {
       }
       return null;
     } catch (error) {
-      console.warn(
-        "Error finding self-intersection line:",
-        error instanceof Error ? error.message : String(error)
-      );
+      if (!isTestEnvironment()) {
+        console.warn(
+          "Error finding self-intersection line:",
+          error instanceof Error ? error.message : String(error)
+        );
+      }
       return null;
     }
   }
@@ -16545,18 +16959,20 @@ class TurfHelper {
       if (line.length < 2) return false;
       const lineStart = line[0];
       const lineEnd = line[line.length - 1];
-      const holePolygon = polygon([hole]);
-      const startInHole = turf_boolean_point_in_polygon_default(point(lineStart), holePolygon);
-      const endInHole = turf_boolean_point_in_polygon_default(point(lineEnd), holePolygon);
+      const holePolygon = polygon$1([hole]);
+      const startInHole = turf_boolean_point_in_polygon_default(point$1(lineStart), holePolygon);
+      const endInHole = turf_boolean_point_in_polygon_default(point$1(lineEnd), holePolygon);
       if (startInHole !== endInHole) {
         return true;
       }
       return false;
     } catch (error) {
-      console.warn(
-        "Error checking line hole traversal:",
-        error instanceof Error ? error.message : String(error)
-      );
+      if (!isTestEnvironment()) {
+        console.warn(
+          "Error checking line hole traversal:",
+          error instanceof Error ? error.message : String(error)
+        );
+      }
       return false;
     }
   }
@@ -16565,29 +16981,31 @@ class TurfHelper {
    */
   holeIsCutByKinks(outerRing, hole) {
     try {
-      const outerPolygon = polygon([outerRing]);
-      const holePolygon = polygon([hole]);
+      const outerPolygon = polygon$1([outerRing]);
+      const holePolygon = polygon$1([hole]);
       const kinkFeatures = turf_kinks_default(outerPolygon);
       if (kinkFeatures.features.length === 0) return false;
       for (const kink of kinkFeatures.features) {
         const kinkPt = kink.geometry.coordinates;
         try {
-          const d = turf_distance_default(point(kinkPt), turf_centroid_default(holePolygon));
+          const d = distance$1(point$1(kinkPt), centroid$1(holePolygon));
           if (d < 0.01) {
             return true;
           }
-          if (turf_boolean_point_in_polygon_default(point(kinkPt), holePolygon)) {
+          if (turf_boolean_point_in_polygon_default(point$1(kinkPt), holePolygon)) {
             return true;
           }
         } catch {
-          if (turf_boolean_point_in_polygon_default(point(kinkPt), holePolygon)) {
+          if (turf_boolean_point_in_polygon_default(point$1(kinkPt), holePolygon)) {
             return true;
           }
         }
       }
       return false;
     } catch (error) {
-      console.warn("Error checking hole cut by kinks:", error.message);
+      if (!isTestEnvironment()) {
+        console.warn("Error checking hole cut by kinks:", error.message);
+      }
       return false;
     }
   }
@@ -16616,16 +17034,16 @@ class TurfHelper {
       if (holes.length === 0) {
         return false;
       }
-      const outerPolygon = polygon([outerRing]);
+      const outerPolygon = polygon$1([outerRing]);
       for (const hole of holes) {
-        const holePolygon = polygon([hole]);
+        const holePolygon = polygon$1([hole]);
         const intersection3 = this.getIntersection(outerPolygon, holePolygon);
         if (intersection3) {
           return true;
         }
         for (let i = 0; i < outerRing.length - 1; i++) {
           const pt = outerRing[i];
-          const pointInHole = turf_boolean_point_in_polygon_default(point(pt), holePolygon);
+          const pointInHole = turf_boolean_point_in_polygon_default(point$1(pt), holePolygon);
           if (pointInHole) {
             return true;
           }
@@ -16658,10 +17076,12 @@ class TurfHelper {
       });
       return resultPolygons;
     } catch (error) {
-      console.warn(
-        "Error handling complete hole traversal:",
-        error instanceof Error ? error.message : String(error)
-      );
+      if (!isTestEnvironment()) {
+        console.warn(
+          "Error handling complete hole traversal:",
+          error instanceof Error ? error.message : String(error)
+        );
+      }
       try {
         const fallbackPolygon = {
           ...outerPolygon,
@@ -16685,7 +17105,7 @@ class TurfHelper {
     try {
       let resultPolygon = basePolygon;
       for (const hole of holes) {
-        const holePolygon = polygon([hole]);
+        const holePolygon = polygon$1([hole]);
         const intersection3 = this.getIntersection(holePolygon, resultPolygon);
         if (intersection3) {
           const difference22 = this.polygonDifference(resultPolygon, holePolygon);
@@ -16702,7 +17122,7 @@ class TurfHelper {
                   geometry: { type: "Polygon", coordinates: coords },
                   properties: {}
                 };
-                const polygonArea2 = turf_area_default(poly);
+                const polygonArea2 = area$1(poly);
                 if (polygonArea2 > largestArea) {
                   largestArea = polygonArea2;
                   largestPolygon = poly;
@@ -16713,341 +17133,113 @@ class TurfHelper {
               }
             }
           } else {
-          }
-        } else {
-        }
-      }
-      return resultPolygon;
-    } catch (error) {
-      console.warn(
-        "Error subtracting intersecting holes:",
-        error instanceof Error ? error.message : String(error)
-      );
-      return basePolygon;
-    }
-  }
-  /**
-   * Remove duplicate vertices from a polygon to prevent turf errors
-   */
-  removeDuplicateVertices(feature2) {
-    if (!feature2 || !feature2.geometry || !feature2.geometry.coordinates) {
-      console.warn("Invalid feature passed to removeDuplicateVertices");
-      return feature2;
-    }
-    const cleanCoordinates = (coords) => {
-      if (!coords || coords.length < 3) {
-        console.warn("Invalid coordinates array - need at least 3 points for a polygon");
-        return coords || [];
-      }
-      const cleaned = [];
-      const tolerance = 1e-6;
-      for (let i = 0; i < coords.length; i++) {
-        const current = coords[i];
-        const next = coords[(i + 1) % coords.length];
-        if (!current || !Array.isArray(current) || current.length < 2 || !next || !Array.isArray(next) || next.length < 2) {
-          continue;
-        }
-        const latDiff = Math.abs(current[1] - next[1]);
-        const lngDiff = Math.abs(current[0] - next[0]);
-        if (latDiff > tolerance || lngDiff > tolerance) {
-          cleaned.push(current);
-        }
-      }
-      if (cleaned.length < 3) {
-        console.warn("After cleaning, polygon has less than 3 points");
-        return coords;
-      }
-      if (cleaned.length > 0) {
-        const first = cleaned[0];
-        const last = cleaned[cleaned.length - 1];
-        const latDiff = Math.abs(first[1] - last[1]);
-        const lngDiff = Math.abs(first[0] - last[0]);
-        if (latDiff > tolerance || lngDiff > tolerance) {
-          cleaned.push([first[0], first[1]]);
-        }
-      }
-      return cleaned;
-    };
-    try {
-      if (feature2.geometry.type === "Polygon") {
-        const cleanedCoords = feature2.geometry.coordinates.map((ring) => cleanCoordinates(ring));
-        if (cleanedCoords.some((ring) => ring.length < 4)) {
-          console.warn("Cleaned polygon has invalid ring with less than 4 coordinates");
-          return feature2;
-        }
-        return {
-          ...feature2,
-          geometry: {
-            ...feature2.geometry,
-            coordinates: cleanedCoords
-          }
-        };
-      } else if (feature2.geometry.type === "MultiPolygon") {
-        const cleanedCoords = feature2.geometry.coordinates.map(
-          (polygon2) => polygon2.map((ring) => cleanCoordinates(ring))
-        );
-        if (cleanedCoords.some((polygon2) => polygon2.some((ring) => ring.length < 4))) {
-          console.warn("Cleaned multipolygon has invalid ring with less than 4 coordinates");
-          return feature2;
-        }
-        return {
-          ...feature2,
-          geometry: {
-            ...feature2.geometry,
-            coordinates: cleanedCoords
-          }
-        };
-      }
-    } catch (error) {
-      console.warn(
-        "Error in removeDuplicateVertices:",
-        error instanceof Error ? error.message : String(error)
-      );
-      return feature2;
-    }
-    return feature2;
-  }
-}
-const isTouchDevice = () => "ontouchstart" in window || navigator.maxTouchPoints > 0;
-class PolyDrawUtil {
-  /**
-   * Gets the bounds of the polygon with optional padding.
-   * @param polygon Array of LatLng points.
-   * @param padding Padding factor.
-   * @returns The LatLngBounds.
-   */
-  static getBounds(polygon2, padding = 0) {
-    const tmpLatLng = [];
-    polygon2.forEach((ll) => {
-      if (isNaN(ll.lat) || isNaN(ll.lng)) ;
-      tmpLatLng.push(ll);
-    });
-    const polyLine = new L.Polyline(tmpLatLng);
-    const bounds = polyLine.getBounds();
-    if (padding !== 0) {
-      return bounds.pad(padding);
-    }
-    return bounds;
-  }
-}
-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)
-    });
-    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);
-  }
-  getDirection(direction) {
-    switch (direction) {
-      case MarkerPosition.SouthWest:
-        return this.direction.SouthWest;
-      case MarkerPosition.West:
-        return this.direction.West;
-      case MarkerPosition.NorthWest:
-        return this.direction.NorthWest;
-      case MarkerPosition.North:
-        return this.direction.North;
-      case MarkerPosition.NorthEast:
-        return this.direction.NorthEast;
-      case MarkerPosition.East:
-        return this.direction.East;
-      case MarkerPosition.SouthEast:
-        return this.direction.SouthEast;
-      case MarkerPosition.South:
-        return this.direction.South;
-      default:
-        throw new Error();
-    }
-  }
-  getPositions(startPosition = MarkerPosition.SouthWest, clockwise = false, addClosingNode = true) {
-    const positions = [];
-    const posArray = this.getPositionAsArray(startPosition, clockwise);
-    posArray.forEach((v) => {
-      positions.push([v.lng, v.lat]);
-    });
-    if (addClosingNode) {
-      positions.push([posArray[0].lng, posArray[0].lat]);
-    }
-    return positions;
-  }
-  getPositionAsArray(startPosition = MarkerPosition.NorthEast, clockwise = false) {
-    const positions = [];
-    if (clockwise) {
-      positions.push(this.direction.SouthWest);
-      positions.push(this.direction.West);
-      positions.push(this.direction.NorthWest);
-      positions.push(this.direction.North);
-      positions.push(this.direction.NorthEast);
-      positions.push(this.direction.East);
-      positions.push(this.direction.SouthEast);
-      positions.push(this.direction.South);
-    } else {
-      positions.push(this.direction.SouthWest);
-      positions.push(this.direction.South);
-      positions.push(this.direction.SouthEast);
-      positions.push(this.direction.East);
-      positions.push(this.direction.NorthEast);
-      positions.push(this.direction.North);
-      positions.push(this.direction.NorthWest);
-      positions.push(this.direction.West);
-    }
-    if (startPosition !== MarkerPosition.SouthWest) {
-      const chunk = positions.splice(0, startPosition);
-      chunk.forEach((v, i) => {
-        positions.splice(startPosition + i, 0, v);
-      });
-    }
-    return positions;
-  }
-}
-class Perimeter {
-  constructor(length2, config) {
-    __publicField(this, "metricLength", "");
-    __publicField(this, "metricUnit", "");
-    __publicField(this, "imperialLength", "");
-    __publicField(this, "imperialUnit", "");
-    if (length2 !== null || length2 !== void 0) {
-      if (length2 === 0) {
-        if (config.markers.markerInfoIcon.usePerimeterMinValue) {
-          this.metricLength = config.markers.markerInfoIcon.values.min.metric;
-          this.metricUnit = config.markers.markerInfoIcon.units.metric.perimeter.m;
-          this.imperialLength = config.markers.markerInfoIcon.values.min.imperial;
-          this.imperialUnit = config.markers.markerInfoIcon.units.imperial.perimeter.feet;
-        } else {
-          this.metricLength = config.markers.markerInfoIcon.values.unknown.metric;
-          this.metricUnit = config.markers.markerInfoIcon.units.unknownUnit;
-          this.imperialLength = config.markers.markerInfoIcon.values.unknown.imperial;
-          this.imperialUnit = config.markers.markerInfoIcon.units.unknownUnit;
-        }
-      } else if (length2 < 100) {
-        this.metricLength = (Math.ceil(length2 / 10) * 10).toString();
-        this.metricUnit = config.markers.markerInfoIcon.units.metric.perimeter.m;
-      } else if (length2 < 500) {
-        this.metricLength = (Math.ceil(length2 / 50) * 50).toString();
-        this.metricUnit = config.markers.markerInfoIcon.units.metric.perimeter.m;
-      } else if (length2 < 1e3) {
-        this.metricLength = (Math.ceil(length2 / 100) * 100).toString();
-        this.metricUnit = config.markers.markerInfoIcon.units.metric.perimeter.m;
-      } else if (length2 < 1e4) {
-        this.metricLength = (Math.ceil(length2 / 100) * 100 / 1e3).toFixed(1);
-        this.metricUnit = config.markers.markerInfoIcon.units.metric.perimeter.km;
-      } else {
-        this.metricLength = (Math.ceil(length2 / 1e3) * 1e3 / 1e3).toString();
-        this.metricUnit = config.markers.markerInfoIcon.units.metric.perimeter.km;
-      }
-      const inch = length2 / 0.0254;
-      const feet = inch / 12;
-      const yards = feet / 3;
-      const miles = yards / 1760;
-      if (length2 < 1e3 / 2.54) {
-        this.imperialLength = (Math.ceil(feet / 10) * 10).toString();
-        this.imperialUnit = config.markers.markerInfoIcon.units.imperial.perimeter.feet;
-      } else if (length2 < 1e3 / 2.54 * 3) {
-        this.imperialLength = (Math.ceil(yards / 10) * 10).toString();
-        this.imperialUnit = config.markers.markerInfoIcon.units.imperial.perimeter.yards;
-      } else if (length2 < 1609) {
-        this.imperialLength = miles.toFixed(2);
-        this.imperialUnit = config.markers.markerInfoIcon.units.imperial.perimeter.miles;
-      } else if (length2 < 16093) {
-        this.imperialLength = miles.toFixed(1);
-        this.imperialUnit = config.markers.markerInfoIcon.units.imperial.perimeter.miles;
-      } else {
-        this.imperialLength = miles.toFixed(0);
-        this.imperialUnit = config.markers.markerInfoIcon.units.imperial.perimeter.miles;
+          }
+        } else {
+        }
+      }
+      return resultPolygon;
+    } catch (error) {
+      if (!isTestEnvironment()) {
+        console.warn(
+          "Error subtracting intersecting holes:",
+          error instanceof Error ? error.message : String(error)
+        );
       }
+      return basePolygon;
     }
   }
-}
-class Area {
-  constructor(sqrMeterArea, config) {
-    __publicField(this, "metricArea", "");
-    __publicField(this, "metricUnit", "");
-    __publicField(this, "imperialArea", "");
-    __publicField(this, "imperialUnit", "");
-    const area2 = sqrMeterArea;
-    const onlyMetrics = config.markers.markerInfoIcon.units.metric.onlyMetrics;
-    if (area2 !== null || area2 !== void 0) {
-      if (area2 === 0) {
-        this.metricArea = "-";
-        this.metricUnit = config.markers.markerInfoIcon.units.unknownUnit;
-        this.imperialArea = "-";
-        this.imperialUnit = config.markers.markerInfoIcon.units.unknownUnit;
-      } else if (area2 < 1e4) {
-        this.metricArea = Math.round(area2).toString();
-        this.metricUnit = config.markers.markerInfoIcon.units.metric.area.m2;
-      } else if (area2 < 1e5) {
-        if (onlyMetrics) {
-          this.metricArea = (area2 / 1e6).toFixed(2);
-          this.metricUnit = config.markers.markerInfoIcon.units.metric.area.km2;
-        } else {
-          this.metricArea = (area2 / 1e3).toFixed(1);
-          this.metricUnit = config.markers.markerInfoIcon.units.metric.area.daa;
+  /**
+   * Remove duplicate vertices from a polygon to prevent turf errors
+   */
+  removeDuplicateVertices(feature2) {
+    if (!feature2 || !feature2.geometry || !feature2.geometry.coordinates) {
+      if (!isTestEnvironment()) {
+        console.warn("Invalid feature passed to removeDuplicateVertices");
+      }
+      return feature2;
+    }
+    const cleanCoordinates = (coords) => {
+      if (!coords || coords.length < 3) {
+        if (!isTestEnvironment()) {
+          console.warn("Invalid coordinates array - need at least 3 points for a polygon");
         }
-      } else if (area2 < 1e7) {
-        if (onlyMetrics) {
-          this.metricArea = (area2 / 1e6).toFixed(2);
-          this.metricUnit = config.markers.markerInfoIcon.units.metric.area.km2;
-        } else {
-          this.metricArea = Math.round(area2 / 1e3).toString();
-          this.metricUnit = config.markers.markerInfoIcon.units.metric.area.daa;
+        return coords || [];
+      }
+      const cleaned = [];
+      const tolerance = 1e-6;
+      for (let i = 0; i < coords.length; i++) {
+        const current = coords[i];
+        const next = coords[(i + 1) % coords.length];
+        if (!current || !Array.isArray(current) || current.length < 2 || !next || !Array.isArray(next) || next.length < 2) {
+          continue;
         }
-      } else if (area2 < 1e8) {
-        if (onlyMetrics) {
-          this.metricArea = (area2 / 1e6).toFixed(1);
-          this.metricUnit = config.markers.markerInfoIcon.units.metric.area.km2;
-        } else {
-          this.metricArea = Math.round(area2 / 1e4).toString();
-          this.metricUnit = config.markers.markerInfoIcon.units.metric.area.ha;
+        const latDiff = Math.abs(current[1] - next[1]);
+        const lngDiff = Math.abs(current[0] - next[0]);
+        if (latDiff > tolerance || lngDiff > tolerance) {
+          cleaned.push(current);
         }
-      } else {
-        this.metricArea = Math.round(area2 / 1e6).toString();
-        this.metricUnit = config.markers.markerInfoIcon.units.metric.area.km2;
       }
-      const inch2 = area2 * 1550;
-      const feet2 = inch2 * 69444e-7;
-      const yards2 = feet2 * 0.11111;
-      const acres = yards2 * 20661e-8;
-      const miles2 = yards2 * 32283e-11;
-      if (area2 < 92.9) {
-        this.imperialArea = Math.round(feet2).toString();
-        this.imperialUnit = config.markers.markerInfoIcon.units.imperial.area.feet2;
-      } else if (area2 < 836.14) {
-        this.imperialArea = yards2.toFixed(0);
-        this.imperialUnit = config.markers.markerInfoIcon.units.imperial.area.yards2;
-      } else if (area2 < 40469.6) {
-        this.imperialArea = acres.toFixed(2);
-        this.imperialUnit = config.markers.markerInfoIcon.units.imperial.area.acres;
-      } else if (area2 < 404696) {
-        this.imperialArea = acres.toFixed(1);
-        this.imperialUnit = config.markers.markerInfoIcon.units.imperial.area.acres;
-      } else if (area2 < 4046960) {
-        this.imperialArea = acres.toFixed(0);
-        this.imperialUnit = config.markers.markerInfoIcon.units.imperial.area.acres;
-      } else if (area2 < 25900404) {
-        this.imperialArea = miles2.toFixed(2);
-        this.imperialUnit = config.markers.markerInfoIcon.units.imperial.area.miles2;
-      } else if (area2 < 259004040) {
-        this.imperialArea = miles2.toFixed(1);
-        this.imperialUnit = config.markers.markerInfoIcon.units.imperial.area.miles2;
-      } else {
-        this.imperialArea = miles2.toFixed(0);
-        this.imperialUnit = config.markers.markerInfoIcon.units.imperial.area.miles2;
+      if (cleaned.length < 3) {
+        if (!isTestEnvironment()) {
+          console.warn("After cleaning, polygon has less than 3 points");
+        }
+        return coords;
+      }
+      if (cleaned.length > 0) {
+        const first = cleaned[0];
+        const last = cleaned[cleaned.length - 1];
+        const latDiff = Math.abs(first[1] - last[1]);
+        const lngDiff = Math.abs(first[0] - last[0]);
+        if (latDiff > tolerance || lngDiff > tolerance) {
+          cleaned.push([first[0], first[1]]);
+        }
+      }
+      return cleaned;
+    };
+    try {
+      if (feature2.geometry.type === "Polygon") {
+        const cleanedCoords = feature2.geometry.coordinates.map((ring) => cleanCoordinates(ring));
+        if (cleanedCoords.some((ring) => ring.length < 4)) {
+          if (!isTestEnvironment()) {
+            console.warn("Cleaned polygon has invalid ring with less than 4 coordinates");
+          }
+          return feature2;
+        }
+        return {
+          ...feature2,
+          geometry: {
+            ...feature2.geometry,
+            coordinates: cleanedCoords
+          }
+        };
+      } else if (feature2.geometry.type === "MultiPolygon") {
+        const cleanedCoords = feature2.geometry.coordinates.map(
+          (polygon2) => polygon2.map((ring) => cleanCoordinates(ring))
+        );
+        if (cleanedCoords.some((polygon2) => polygon2.some((ring) => ring.length < 4))) {
+          if (!isTestEnvironment()) {
+            console.warn("Cleaned multipolygon has invalid ring with less than 4 coordinates");
+          }
+          return feature2;
+        }
+        return {
+          ...feature2,
+          geometry: {
+            ...feature2.geometry,
+            coordinates: cleanedCoords
+          }
+        };
+      }
+    } catch (error) {
+      if (!isTestEnvironment()) {
+        console.warn(
+          "Error in removeDuplicateVertices:",
+          error instanceof Error ? error.message : String(error)
+        );
       }
+      return feature2;
     }
+    return feature2;
   }
 }
 function createButtons(container, subContainer, config, onActivateToggle, onDrawClick, onSubtractClick, onEraseClick, onPointToPointClick) {
@@ -17117,15 +17309,14 @@ class PolygonUtil {
    * @returns The center LatLng.
    */
   static getCenter(polygon2) {
-    const pi2 = Math.PI;
     let x = 0;
     let y = 0;
     let z = 0;
     polygon2.forEach((v) => {
       let lat1 = v.lat;
       let lon1 = v.lng;
-      lat1 = lat1 * pi2 / 180;
-      lon1 = lon1 * pi2 / 180;
+      lat1 = lat1 * MATH.DEG_TO_RAD;
+      lon1 = lon1 * MATH.DEG_TO_RAD;
       x += Math.cos(lat1) * Math.cos(lon1);
       y += Math.cos(lat1) * Math.sin(lon1);
       z += Math.sin(lat1);
@@ -17133,8 +17324,8 @@ class PolygonUtil {
     let lng = Math.atan2(y, x);
     const hyp = Math.sqrt(x * x + y * y);
     let lat = Math.atan2(z, hyp);
-    lat = lat * 180 / pi2;
-    lng = lng * 180 / pi2;
+    lat = lat * MATH.RAD_TO_DEG;
+    lng = lng * MATH.RAD_TO_DEG;
     const center2 = { lat, lng };
     return center2;
   }
@@ -17690,9 +17881,10 @@ class PolygonDrawManager {
     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,
-        event.touches[0].clientY
+        event.touches[0].clientX - rect.x,
+        event.touches[0].clientY - rect.y
       ]);
       this.tracer.addLatLng(latlng);
     }
@@ -17855,7 +18047,9 @@ class PolygonDrawManager {
         isPointToPoint: true
       });
     } catch (error) {
-      console.warn("Error completing point-to-point polygon:", error);
+      if (!isTestEnvironment()) {
+        console.warn("Error completing point-to-point polygon:", error);
+      }
       this.clearP2pMarkers();
       this.resetTracer();
     }
@@ -19228,7 +19422,9 @@ class PolygonInteractionManager {
   }
   markerDrag(featureGroup) {
     if (!this._activeMarker) {
-      console.warn("No active marker set for dragging.");
+      if (!isTestEnvironment()) {
+        console.warn("No active marker set for dragging.");
+      }
       return;
     }
     const newPos = [];
@@ -19236,6 +19432,12 @@ class PolygonInteractionManager {
     let hole = [];
     const layers = featureGroup.getLayers();
     const polygonLayer = layers.find((l) => l instanceof L.Polygon);
+    if (!polygonLayer) {
+      if (!isTestEnvironment()) {
+        console.warn("No polygon found in feature group for marker drag.");
+      }
+      return;
+    }
     const posarrays = polygonLayer.getLatLngs();
     let length2 = 0;
     const markers2 = layers.filter((layer) => layer instanceof L.Marker);
@@ -19322,14 +19524,20 @@ class PolygonInteractionManager {
             this.eventManager.emit("polydraw:polygon:updated", {
               operation: "markerDrag",
               polygon: this.turfHelper.getTurfPolygon(polygon2),
-              allowMerge: true
+              allowMerge: true,
+              // Allow intelligent merging for intersections
+              intelligentMerge: true
+              // Flag for smart merging logic
             });
           }
         } else {
           this.eventManager.emit("polydraw:polygon:updated", {
             operation: "markerDrag",
             polygon: feature2,
-            allowMerge: true
+            allowMerge: true,
+            // Allow intelligent merging for intersections
+            intelligentMerge: true
+            // Flag for smart merging logic
           });
         }
       }
@@ -19343,14 +19551,16 @@ class PolygonInteractionManager {
           this.eventManager.emit("polydraw:polygon:updated", {
             operation: "markerDrag",
             polygon: this.turfHelper.getTurfPolygon(polygon2),
-            allowMerge: true
+            allowMerge: false
+            // Fixed: prevent merging during vertex drag
           });
         }
       } else {
         this.eventManager.emit("polydraw:polygon:updated", {
           operation: "markerDrag",
           polygon: feature2,
-          allowMerge: true
+          allowMerge: false
+          // Fixed: prevent merging during vertex drag
         });
       }
     }
@@ -19612,7 +19822,9 @@ class PolygonInteractionManager {
               }
             }
           } catch (differenceError) {
-            console.warn("Failed to perform difference operation:", differenceError);
+            if (!isTestEnvironment()) {
+              console.warn("Failed to perform difference operation:", differenceError);
+            }
             this.eventManager.emit("polydraw:polygon:updated", {
               operation: "modifierSubtractFallback",
               polygon: existingPolygon,
@@ -19620,12 +19832,16 @@ class PolygonInteractionManager {
             });
           }
         } catch (error) {
-          console.warn("Error in modifier subtract operation:", error);
+          if (!isTestEnvironment()) {
+            console.warn("Error in modifier subtract operation:", error);
+          }
         }
       });
       this.polygonInformation.createPolygonInformationStorage(this.getFeatureGroups());
     } catch (error) {
-      console.warn("Error in performModifierSubtract:", error);
+      if (!isTestEnvironment()) {
+        console.warn("Error in performModifierSubtract:", error);
+      }
     }
   }
   getEdgeDeletionModifierKey() {
@@ -19944,10 +20160,12 @@ class PolygonInteractionManager {
       }
       return polygonLayer.toGeoJSON();
     } catch (error) {
-      if (error instanceof Error) {
-        console.warn("Error getting polygon GeoJSON from feature group:", error.message);
-      } else {
-        console.warn("Error getting polygon GeoJSON from feature group:", error);
+      if (!isTestEnvironment()) {
+        if (error instanceof Error) {
+          console.warn("Error getting polygon GeoJSON from feature group:", error.message);
+        } else {
+          console.warn("Error getting polygon GeoJSON from feature group:", error);
+        }
       }
       return {
         type: "Feature",
@@ -20006,10 +20224,12 @@ class PolygonInteractionManager {
       }
       return totalPerimeter * 1e3;
     } catch (error) {
-      if (error instanceof Error) {
-        console.warn("Error calculating total polygon perimeter:", error.message);
-      } else {
-        console.warn("Error calculating total polygon perimeter:", error);
+      if (!isTestEnvironment()) {
+        if (error instanceof Error) {
+          console.warn("Error calculating total polygon perimeter:", error.message);
+        } else {
+          console.warn("Error calculating total polygon perimeter:", error);
+        }
       }
       return this.turfHelper.getPolygonPerimeter(polygonGeoJSON) * 1e3;
     }
@@ -20125,9 +20345,13 @@ class PolygonMutationManager {
    */
   async handlePolygonModified(data) {
     const shouldSimplify = data.operation !== "addVertex" && data.operation !== "markerDrag" && data.operation !== "polygonDrag";
+    let allowMerge = data.allowMerge;
+    if (data.intelligentMerge && data.operation === "markerDrag") {
+      allowMerge = this.shouldAllowIntelligentMerge(data.polygon);
+    }
     const options = {
       simplify: shouldSimplify,
-      noMerge: !data.allowMerge,
+      noMerge: !allowMerge,
       visualOptimizationLevel: data.optimizationLevel || 0
     };
     await this.addPolygon(data.polygon, options);
@@ -20187,6 +20411,10 @@ class PolygonMutationManager {
   async addPolygon(latlngs, options = {}) {
     const { noMerge = false } = options;
     try {
+      const isInsideHole = this.isPolygonInsideExistingHole(latlngs);
+      if (isInsideHole) {
+        return await this.addPolygonLayer(latlngs, options);
+      }
       if (this.config.mergePolygons && !noMerge && this.getFeatureGroups().length > 0 && !this.config.kinks) {
         return await this.mergePolygon(latlngs, options);
       } else {
@@ -20290,19 +20518,7 @@ class PolygonMutationManager {
       let markerLatlngs;
       try {
         const rawLatLngs = polygon2.getLatLngs();
-        if (Array.isArray(rawLatLngs) && rawLatLngs.length > 0) {
-          if (Array.isArray(rawLatLngs[0])) {
-            if (Array.isArray(rawLatLngs[0][0])) {
-              markerLatlngs = rawLatLngs[0];
-            } else {
-              markerLatlngs = rawLatLngs;
-            }
-          } else {
-            markerLatlngs = [rawLatLngs];
-          }
-        } else {
-          markerLatlngs = [];
-        }
+        markerLatlngs = this.normalizePolygonCoordinates(rawLatLngs);
       } catch (error) {
         markerLatlngs = [];
       }
@@ -20326,7 +20542,7 @@ class PolygonMutationManager {
             if (ringIndex === 0) {
               this.interactionManager.addMarkers(latLngLiterals, featureGroup);
             } else {
-              const holePolyline = L.polyline(polygonRing, {
+              const holePolyline = L.polyline(latLngLiterals, {
                 color: this.config.colors.hole.border,
                 weight: this.config.holeOptions.weight || 2,
                 opacity: this.config.holeOptions.opacity || 1,
@@ -20459,6 +20675,124 @@ class PolygonMutationManager {
       };
     }
   }
+  /**
+   * Determine if intelligent merging should be allowed for a polygon
+   * This checks if the polygon actually intersects with existing polygons
+   */
+  shouldAllowIntelligentMerge(polygon2) {
+    try {
+      for (const featureGroup of this.getFeatureGroups()) {
+        try {
+          const featureCollection2 = featureGroup.toGeoJSON();
+          if (!featureCollection2 || !featureCollection2.features || !featureCollection2.features[0]) {
+            continue;
+          }
+          const existingFeature = featureCollection2.features[0];
+          if (!existingFeature.geometry || !existingFeature.geometry.coordinates) {
+            continue;
+          }
+          const existingPolygon = this.turfHelper.getTurfPolygon(existingFeature);
+          if (this.geometryManager.checkPolygonIntersection(existingPolygon, polygon2)) {
+            return true;
+          }
+        } catch (error) {
+          continue;
+        }
+      }
+      return false;
+    } catch (error) {
+      return false;
+    }
+  }
+  /**
+   * Check if a polygon is completely inside a hole of an existing polygon
+   * This prevents incorrect merging when drawing polygons inside holes
+   */
+  isPolygonInsideExistingHole(newPolygon) {
+    try {
+      for (const featureGroup of this.getFeatureGroups()) {
+        try {
+          const featureCollection2 = featureGroup.toGeoJSON();
+          if (!featureCollection2 || !featureCollection2.features || !featureCollection2.features[0]) {
+            continue;
+          }
+          const existingFeature = featureCollection2.features[0];
+          if (!existingFeature.geometry || !existingFeature.geometry.coordinates) {
+            continue;
+          }
+          let hasHoles = false;
+          let holes = [];
+          if (existingFeature.geometry.type === "Polygon") {
+            hasHoles = existingFeature.geometry.coordinates.length > 1;
+            if (hasHoles) {
+              holes = existingFeature.geometry.coordinates.slice(1);
+            }
+          } else if (existingFeature.geometry.type === "MultiPolygon") {
+            for (const polygonCoords of existingFeature.geometry.coordinates) {
+              if (polygonCoords.length > 1) {
+                hasHoles = true;
+                holes.push(...polygonCoords.slice(1));
+              }
+            }
+          }
+          if (hasHoles && holes.length > 0) {
+            for (const holeCoords of holes) {
+              try {
+                const holePolygon = this.turfHelper.createPolygon([holeCoords]);
+                if (this.turfHelper.isPolygonCompletelyWithin(newPolygon, holePolygon)) {
+                  return true;
+                }
+              } catch (error) {
+                continue;
+              }
+            }
+          }
+        } catch (error) {
+          continue;
+        }
+      }
+      return false;
+    } catch (error) {
+      return false;
+    }
+  }
+  /**
+   * Normalize polygon coordinates to handle complex nested structures
+   * This fixes the bug where markers are missing when drawing polygons inside holes
+   */
+  normalizePolygonCoordinates(rawLatLngs) {
+    if (!Array.isArray(rawLatLngs) || rawLatLngs.length === 0) {
+      return [];
+    }
+    const isLatLngLike = (obj) => {
+      return obj !== null && typeof obj === "object" && "lat" in obj && "lng" in obj && typeof obj.lat === "number" && typeof obj.lng === "number";
+    };
+    const flattenToRings = (coords) => {
+      if (!Array.isArray(coords)) {
+        return [];
+      }
+      if (coords.length > 0 && isLatLngLike(coords[0])) {
+        return [coords];
+      }
+      const result = [];
+      for (const item of coords) {
+        if (Array.isArray(item)) {
+          if (item.length > 0 && isLatLngLike(item[0])) {
+            result.push(item);
+          } else {
+            const flattened = flattenToRings(item);
+            result.push(...flattened);
+          }
+        }
+      }
+      return result;
+    };
+    try {
+      return flattenToRings(rawLatLngs);
+    } catch (error) {
+      return [];
+    }
+  }
   /**
    * Create a polygon from GeoJSON feature
    */
@@ -20479,11 +20813,16 @@ class PolygonMutationManager {
    */
   getPolygon(latlngs) {
     const polygon2 = L.GeoJSON.geometryToLayer(latlngs);
-    polygon2.setStyle({
+    const polygonStyle = {
       ...this.config.polygonOptions,
       color: this.config.colors.polygon.border,
-      fillColor: this.config.colors.polygon.fill
-    });
+      fillColor: this.config.colors.polygon.fill,
+      // Force these values to ensure they override any default styling
+      weight: this.config.polygonOptions.weight || 2,
+      opacity: this.config.polygonOptions.opacity || 1,
+      fillOpacity: this.config.polygonOptions.fillOpacity || 0.2
+    };
+    polygon2.setStyle(polygonStyle);
     polygon2._polydrawUniqueId = L.Util.stamp(polygon2) + "_" + Date.now();
     delete polygon2._polydrawDragData;
     delete polygon2._polydrawOriginalLatLngs;
@@ -20529,8 +20868,10 @@ class PolygonMutationManager {
       }
       return polygon2.toGeoJSON();
     } catch (error) {
-      if (error instanceof Error) {
-        console.warn("Error getting complete polygon GeoJSON from feature group:", error.message);
+      if (!isTestEnvironment()) {
+        if (error instanceof Error) {
+          console.warn("Error getting complete polygon GeoJSON from feature group:", error.message);
+        }
       }
       return {
         type: "Feature",
@@ -21093,10 +21434,15 @@ class Polydraw extends L.Control {
     L.DomEvent.on(container, "click", L.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.style.maxHeight = "0px";
     this.subContainer.style.overflow = "hidden";
     this.subContainer.style.transition = "max-height 0.3s ease";
+    this.subContainer.style.pointerEvents = "auto";
+    this.subContainer.style.position = "relative";
     createButtons(
       container,
       this.subContainer,
@@ -21107,6 +21453,7 @@ class Polydraw extends L.Control {
       this._handleEraseClick,
       this._handlePointToPointClick
     );
+    this.ensureButtonTouchResponsiveness(container);
     const uiUpdateListener = (mode) => {
       const drawButton = container.querySelector(".icon-draw");
       const subtractButton = container.querySelector(".icon-subtract");
@@ -21345,9 +21692,21 @@ class Polydraw extends L.Control {
    * @param enableScrollWheelZoom - Whether to enable scroll wheel zoom.
    */
   setLeafletMapEvents(enableDragging, enableDoubleClickZoom, enableScrollWheelZoom) {
-    enableDragging ? this.map.dragging.enable() : this.map.dragging.disable();
-    enableDoubleClickZoom ? this.map.doubleClickZoom.enable() : this.map.doubleClickZoom.disable();
-    enableScrollWheelZoom ? this.map.scrollWheelZoom.enable() : this.map.scrollWheelZoom.disable();
+    if (enableDragging) {
+      this.map.dragging.enable();
+    } else {
+      this.map.dragging.disable();
+    }
+    if (enableDoubleClickZoom) {
+      this.map.doubleClickZoom.enable();
+    } else {
+      this.map.doubleClickZoom.disable();
+    }
+    if (enableScrollWheelZoom) {
+      this.map.scrollWheelZoom.enable();
+    } else {
+      this.map.scrollWheelZoom.disable();
+    }
   }
   /**
    * Resets the tracer polyline by clearing its LatLngs.
@@ -21409,9 +21768,10 @@ class Polydraw extends L.Control {
     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,
-        event.touches[0].clientY
+        event.touches[0].clientX - rect.x,
+        event.touches[0].clientY - rect.y
       ]);
     }
     if (!clickLatLng) {
@@ -21435,9 +21795,10 @@ class Polydraw extends L.Control {
     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,
-        event.touches[0].clientY
+        event.touches[0].clientX - rect.x,
+        event.touches[0].clientY - rect.y
       ]);
       this.tracer.addLatLng(latlng);
     }
@@ -21626,6 +21987,25 @@ class Polydraw extends L.Control {
       return event.ctrlKey;
     }
   }
+  /**
+   * Ensures all buttons have proper touch responsiveness for Firefox Android
+   * @param container - The main control container element
+   */
+  ensureButtonTouchResponsiveness(container) {
+    const buttons = container.querySelectorAll("a");
+    buttons.forEach((button) => {
+      button.style.pointerEvents = "auto";
+      button.style.touchAction = "manipulation";
+      button.style.position = "relative";
+      button.style.zIndex = "1";
+      const touchHandler = (e) => {
+        e.stopPropagation();
+        e.target.style.pointerEvents = "auto";
+      };
+      button.addEventListener("touchstart", touchHandler, { passive: true });
+      button.addEventListener("touchend", touchHandler, { passive: true });
+    });
+  }
   /**
    * Updates the visual indicator on the activate button to show if there are active polygons.
    */