leaflet-anvil 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2054 @@
+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);
+
+// src/index.ts
+import * as L22 from "leaflet";
+
+// src/events.ts
+var ANVIL_EVENTS = {
+  CREATED: "anvil:created",
+  EDITED: "anvil:edited",
+  DELETED: "anvil:deleted",
+  SPLIT: "anvil:split",
+  UNION: "anvil:union",
+  SUBTRACT: "anvil:subtract",
+  MODE_CHANGE: "anvil:modechange"
+};
+
+// src/modes/mode-manager.ts
+var ModeManager = class {
+  constructor(map) {
+    this.map = map;
+    __publicField(this, "currentMode", null);
+    __publicField(this, "modes", /* @__PURE__ */ new Map());
+  }
+  addMode(name, mode) {
+    this.modes.set(name, mode);
+  }
+  enable(name) {
+    const mode = this.modes.get(name);
+    if (!mode) {
+      console.warn(`Anvil ModeManager: Mode "${name}" not found.`);
+      return;
+    }
+    if (this.currentMode === mode) return;
+    this.disable();
+    this.currentMode = mode;
+    this.currentMode.enable();
+    this.map.fire(ANVIL_EVENTS.MODE_CHANGE, { mode: name });
+  }
+  disable() {
+    if (this.currentMode) {
+      this.currentMode.disable();
+      this.currentMode = null;
+      this.map.fire(ANVIL_EVENTS.MODE_CHANGE, { mode: null });
+    }
+  }
+};
+
+// src/modes/draw-polygon-mode.ts
+import * as L3 from "leaflet";
+
+// src/utils/snapping.ts
+import * as L from "leaflet";
+function getSnapLatLng(map, latlng, store, options, additionalPoints = [], skipLayer) {
+  if (!options.snapping) return latlng;
+  const snapDistance = options.snapDistance || 10;
+  const basePoint = map.latLngToContainerPoint(latlng);
+  let closestPoint = null;
+  let minDistance = snapDistance;
+  const skipLayers = Array.isArray(skipLayer) ? skipLayer : skipLayer ? [skipLayer] : [];
+  const bounds = map.getBounds().pad(0.1);
+  store.getGroup().eachLayer((layer) => {
+    if (skipLayers.includes(layer)) return;
+    if (layer.getBounds && !bounds.intersects(layer.getBounds())) return;
+    const pointsToCheck = [];
+    if (layer instanceof L.Marker || layer instanceof L.CircleMarker || layer instanceof L.Circle) {
+      pointsToCheck.push(layer.getLatLng());
+    } else if (layer instanceof L.Polyline) {
+      const latlngs = layer.getLatLngs();
+      const flatten5 = (arr) => {
+        let result = [];
+        arr.forEach((item) => {
+          if (Array.isArray(item)) {
+            result = result.concat(flatten5(item));
+          } else if (item instanceof L.LatLng) {
+            result.push(item);
+          }
+        });
+        return result;
+      };
+      pointsToCheck.push(...flatten5(latlngs));
+    }
+    pointsToCheck.forEach((p) => {
+      const containerPoint = map.latLngToContainerPoint(p);
+      const dist = basePoint.distanceTo(containerPoint);
+      if (dist < minDistance) {
+        minDistance = dist;
+        closestPoint = p;
+      }
+    });
+  });
+  additionalPoints.forEach((p) => {
+    const containerPoint = map.latLngToContainerPoint(p);
+    const dist = basePoint.distanceTo(containerPoint);
+    if (dist < minDistance) {
+      minDistance = dist;
+      closestPoint = p;
+    }
+  });
+  return closestPoint || latlng;
+}
+
+// src/utils/geometry.ts
+import * as L2 from "leaflet";
+function segmentsIntersect(a, b, c, d) {
+  const crossProduct = (p1, p2, p3) => {
+    return (p2.y - p1.y) * (p3.x - p2.x) - (p2.x - p1.x) * (p3.y - p2.y);
+  };
+  const cp1 = crossProduct(a, b, c);
+  const cp2 = crossProduct(a, b, d);
+  const cp3 = crossProduct(c, d, a);
+  const cp4 = crossProduct(c, d, b);
+  if ((cp1 > 0 && cp2 < 0 || cp1 < 0 && cp2 > 0) && (cp3 > 0 && cp4 < 0 || cp3 < 0 && cp4 > 0)) {
+    return true;
+  }
+  return false;
+}
+function causesSelfIntersection(map, points, nextPoint, isClosing = false) {
+  if (points.length < 2) return false;
+  const p2 = map.latLngToLayerPoint(nextPoint);
+  const p1 = map.latLngToLayerPoint(points[points.length - 1]);
+  const limit = points.length - 2;
+  for (let i = 0; i < limit; i++) {
+    const a = map.latLngToLayerPoint(points[i]);
+    const b = map.latLngToLayerPoint(points[i + 1]);
+    if (segmentsIntersect(p1, p2, a, b)) {
+      return true;
+    }
+  }
+  if (isClosing) {
+  }
+  return false;
+}
+function isSelfIntersecting(map, latlngs, isPolygon) {
+  const flatten5 = (arr) => {
+    if (!Array.isArray(arr)) return [];
+    if (arr[0] instanceof L2.LatLng) return arr;
+    return arr.reduce((acc, val) => acc.concat(flatten5(val)), []);
+  };
+  const points = flatten5(latlngs);
+  if (points.length < 4) return false;
+  const projectedPoints = points.map((p) => map.latLngToLayerPoint(p));
+  const len = projectedPoints.length;
+  for (let i = 0; i < len; i++) {
+    const a = projectedPoints[i];
+    const b = projectedPoints[(i + 1) % len];
+    if (!isPolygon && i === len - 1) break;
+    for (let j = i + 2; j < len; j++) {
+      if (isPolygon && (j + 1) % len === i) continue;
+      if (!isPolygon && j === len - 1) break;
+      const c = projectedPoints[j];
+      const d = projectedPoints[(j + 1) % len];
+      if (segmentsIntersect(a, b, c, d)) return true;
+    }
+  }
+  return false;
+}
+
+// src/modes/draw-polygon-mode.ts
+var DrawPolygonMode = class {
+  constructor(map, options = {}, store) {
+    this.map = map;
+    this.options = options;
+    this.store = store;
+    __publicField(this, "points", []);
+    __publicField(this, "markers", []);
+    __publicField(this, "polyline", null);
+    __publicField(this, "ghostLine", null);
+  }
+  enable() {
+    this.map.on("click", this.onClick, this);
+    this.map.on("mousemove", this.onMouseMove, this);
+    L3.DomEvent.on(window, "keydown", this.onKeyDown, this);
+    this.map.getContainer().style.cursor = "crosshair";
+  }
+  disable() {
+    this.map.off("click", this.onClick, this);
+    this.map.off("mousemove", this.onMouseMove, this);
+    L3.DomEvent.off(window, "keydown", this.onKeyDown, this);
+    this.map.getContainer().style.cursor = "";
+    this.reset();
+  }
+  onClick(e) {
+    const latlng = this.store ? getSnapLatLng(this.map, e.latlng, this.store, this.options, this.points) : e.latlng;
+    if (this.points.length > 0 && this.isFirstPoint(latlng)) {
+      if (this.options.preventSelfIntersection && causesSelfIntersection(this.map, this.points, this.points[0])) {
+        return;
+      }
+      this.finish();
+      return;
+    }
+    if (this.options.preventSelfIntersection && causesSelfIntersection(this.map, this.points, latlng)) {
+      return;
+    }
+    this.points.push(latlng);
+    this.updateDrawing();
+  }
+  isFirstPoint(latlng) {
+    if (this.points.length < 3) return false;
+    const firstPoint = this.points[0];
+    if (latlng.equals(firstPoint)) return true;
+    const containerPoint = this.map.latLngToContainerPoint(latlng);
+    const firstContainerPoint = this.map.latLngToContainerPoint(firstPoint);
+    return containerPoint.distanceTo(firstContainerPoint) < (this.options.snapDistance || 10);
+  }
+  onMouseMove(e) {
+    if (this.points.length === 0) return;
+    const snapLatLng = this.store ? getSnapLatLng(this.map, e.latlng, this.store, this.options, this.points) : e.latlng;
+    const lastPoint = this.points[this.points.length - 1];
+    if (!this.ghostLine) {
+      this.ghostLine = L3.polyline([lastPoint, snapLatLng], {
+        dashArray: "5, 5",
+        color: "#3388ff",
+        weight: 2
+      }).addTo(this.map);
+    } else {
+      this.ghostLine.setLatLngs([lastPoint, snapLatLng]);
+    }
+  }
+  onKeyDown(e) {
+    if (e.key === "Escape") {
+      this.reset();
+    }
+  }
+  updateDrawing() {
+    if (this.polyline) {
+      this.polyline.setLatLngs(this.points);
+    } else {
+      this.polyline = L3.polyline(this.points, { color: "#3388ff" }).addTo(this.map);
+    }
+    if (this.points.length === 1 && this.markers.length === 0) {
+      const marker4 = L3.circleMarker(this.points[0], {
+        radius: 5,
+        fillColor: "#fff",
+        fillOpacity: 1,
+        color: "#3388ff",
+        weight: 2
+      }).addTo(this.map);
+      marker4.on("click", (e) => {
+        L3.DomEvent.stopPropagation(e);
+        this.finish();
+      });
+      this.markers.push(marker4);
+    }
+  }
+  finish() {
+    if (this.points.length < 3) return;
+    const polygon7 = L3.polygon(this.points).addTo(this.map);
+    this.map.fire(ANVIL_EVENTS.CREATED, { layer: polygon7 });
+    this.reset();
+  }
+  reset() {
+    if (this.polyline) this.map.removeLayer(this.polyline);
+    if (this.ghostLine) this.map.removeLayer(this.ghostLine);
+    this.markers.forEach((m) => this.map.removeLayer(m));
+    this.points = [];
+    this.markers = [];
+    this.polyline = null;
+    this.ghostLine = null;
+  }
+};
+
+// src/modes/draw-polyline-mode.ts
+import * as L4 from "leaflet";
+var DrawPolylineMode = class {
+  constructor(map, options = {}, store) {
+    this.map = map;
+    this.options = options;
+    this.store = store;
+    __publicField(this, "points", []);
+    __publicField(this, "polyline", null);
+    __publicField(this, "ghostLine", null);
+  }
+  enable() {
+    this.map.on("click", this.onClick, this);
+    this.map.on("mousemove", this.onMouseMove, this);
+    this.map.on("dblclick", this.onDoubleClick, this);
+    L4.DomEvent.on(window, "keydown", this.onKeyDown, this);
+    this.map.doubleClickZoom.disable();
+    this.map.getContainer().style.cursor = "crosshair";
+  }
+  disable() {
+    this.map.off("click", this.onClick, this);
+    this.map.off("mousemove", this.onMouseMove, this);
+    this.map.off("dblclick", this.onDoubleClick, this);
+    L4.DomEvent.off(window, "keydown", this.onKeyDown, this);
+    this.map.doubleClickZoom.enable();
+    this.map.getContainer().style.cursor = "";
+    this.reset();
+  }
+  onClick(e) {
+    const latlng = this.store ? getSnapLatLng(this.map, e.latlng, this.store, this.options, this.points) : e.latlng;
+    if (this.options.preventSelfIntersection && causesSelfIntersection(this.map, this.points, latlng)) {
+      return;
+    }
+    this.points.push(latlng);
+    this.updateDrawing();
+  }
+  onMouseMove(e) {
+    if (this.points.length === 0) return;
+    const snapLatLng = this.store ? getSnapLatLng(this.map, e.latlng, this.store, this.options, this.points) : e.latlng;
+    const lastPoint = this.points[this.points.length - 1];
+    if (!this.ghostLine) {
+      this.ghostLine = L4.polyline([lastPoint, e.latlng], {
+        dashArray: "5, 5",
+        color: "#3388ff",
+        weight: 2
+      }).addTo(this.map);
+    } else {
+      this.ghostLine.setLatLngs([lastPoint, snapLatLng]);
+    }
+  }
+  onDoubleClick(e) {
+    L4.DomEvent.stopPropagation(e);
+    this.finish();
+  }
+  onKeyDown(e) {
+    if (e.key === "Escape") {
+      this.reset();
+    } else if (e.key === "Enter") {
+      this.finish();
+    }
+  }
+  updateDrawing() {
+    if (this.polyline) {
+      this.polyline.setLatLngs(this.points);
+    } else {
+      this.polyline = L4.polyline(this.points, { color: "#3388ff" }).addTo(this.map);
+    }
+  }
+  finish() {
+    if (this.points.length < 2) return;
+    const polyline6 = L4.polyline(this.points).addTo(this.map);
+    this.map.fire(ANVIL_EVENTS.CREATED, { layer: polyline6 });
+    this.reset();
+  }
+  reset() {
+    if (this.polyline) this.map.removeLayer(this.polyline);
+    if (this.ghostLine) this.map.removeLayer(this.ghostLine);
+    this.points = [];
+    this.polyline = null;
+    this.ghostLine = null;
+  }
+};
+
+// src/modes/draw-marker-mode.ts
+import * as L5 from "leaflet";
+var DrawMarkerMode = class {
+  constructor(map, options = {}, store) {
+    this.map = map;
+    this.options = options;
+    this.store = store;
+  }
+  enable() {
+    this.map.on("click", this.onClick, this);
+    this.map.getContainer().style.cursor = "crosshair";
+  }
+  disable() {
+    this.map.off("click", this.onClick, this);
+    this.map.getContainer().style.cursor = "";
+  }
+  onClick(e) {
+    const latlng = this.store ? getSnapLatLng(this.map, e.latlng, this.store, this.options) : e.latlng;
+    const marker4 = L5.marker(latlng).addTo(this.map);
+    this.map.fire(ANVIL_EVENTS.CREATED, { layer: marker4 });
+  }
+};
+
+// src/modes/draw-rectangle-mode.ts
+import * as L6 from "leaflet";
+var DrawRectangleMode = class {
+  constructor(map, options = {}, store) {
+    this.map = map;
+    this.options = options;
+    this.store = store;
+    __publicField(this, "rectangle", null);
+    __publicField(this, "startLatLng", null);
+  }
+  enable() {
+    this.map.on("mousedown", this.onMouseDown, this);
+    this.map.on("mousemove", this.onMouseMove, this);
+    this.map.on("mouseup", this.onMouseUp, this);
+    this.map.dragging.disable();
+    this.map.getContainer().style.cursor = "crosshair";
+  }
+  disable() {
+    this.map.off("mousedown", this.onMouseDown, this);
+    this.map.off("mousemove", this.onMouseMove, this);
+    this.map.off("mouseup", this.onMouseUp, this);
+    this.map.dragging.enable();
+    this.map.getContainer().style.cursor = "";
+    this.reset();
+  }
+  onMouseDown(e) {
+    this.startLatLng = this.store ? getSnapLatLng(this.map, e.latlng, this.store, this.options) : e.latlng;
+  }
+  onMouseMove(e) {
+    if (!this.startLatLng) return;
+    const currentLatLng = this.store ? getSnapLatLng(this.map, e.latlng, this.store, this.options) : e.latlng;
+    const bounds = L6.latLngBounds(this.startLatLng, currentLatLng);
+    if (!this.rectangle) {
+      this.rectangle = L6.rectangle(bounds, { color: "#3388ff", weight: 2 }).addTo(this.map);
+    } else {
+      this.rectangle.setBounds(bounds);
+    }
+  }
+  onMouseUp(e) {
+    if (!this.startLatLng) return;
+    const currentLatLng = this.store ? getSnapLatLng(this.map, e.latlng, this.store, this.options) : e.latlng;
+    const bounds = L6.latLngBounds(this.startLatLng, currentLatLng);
+    const rectangle3 = L6.rectangle(bounds).addTo(this.map);
+    this.map.fire(ANVIL_EVENTS.CREATED, { layer: rectangle3 });
+    this.reset();
+  }
+  reset() {
+    if (this.rectangle) this.map.removeLayer(this.rectangle);
+    this.rectangle = null;
+    this.startLatLng = null;
+  }
+};
+
+// src/modes/draw-square-mode.ts
+import * as L7 from "leaflet";
+var DrawSquareMode = class {
+  constructor(map, options = {}, store) {
+    this.map = map;
+    this.options = options;
+    this.store = store;
+    __publicField(this, "rectangle", null);
+    __publicField(this, "startLatLng", null);
+  }
+  enable() {
+    this.map.on("mousedown", this.onMouseDown, this);
+    this.map.on("mousemove", this.onMouseMove, this);
+    this.map.on("mouseup", this.onMouseUp, this);
+    this.map.dragging.disable();
+    this.map.getContainer().style.cursor = "crosshair";
+  }
+  disable() {
+    this.map.off("mousedown", this.onMouseDown, this);
+    this.map.off("mousemove", this.onMouseMove, this);
+    this.map.off("mouseup", this.onMouseUp, this);
+    this.map.dragging.enable();
+    this.map.getContainer().style.cursor = "";
+    this.reset();
+  }
+  onMouseDown(e) {
+    this.startLatLng = this.store ? getSnapLatLng(this.map, e.latlng, this.store, this.options) : e.latlng;
+  }
+  onMouseMove(e) {
+    if (!this.startLatLng) return;
+    const currentLatLng = this.store ? getSnapLatLng(this.map, e.latlng, this.store, this.options) : e.latlng;
+    const squareBounds = this.getSquareBounds(this.startLatLng, currentLatLng);
+    if (!this.rectangle) {
+      this.rectangle = L7.rectangle(squareBounds, { color: "#3388ff", weight: 2 }).addTo(this.map);
+    } else {
+      this.rectangle.setBounds(squareBounds);
+    }
+  }
+  onMouseUp(e) {
+    if (!this.startLatLng) return;
+    const currentLatLng = this.store ? getSnapLatLng(this.map, e.latlng, this.store, this.options) : e.latlng;
+    const squareBounds = this.getSquareBounds(this.startLatLng, currentLatLng);
+    const polygon7 = L7.polygon([
+      squareBounds.getNorthWest(),
+      squareBounds.getNorthEast(),
+      squareBounds.getSouthEast(),
+      squareBounds.getSouthWest()
+    ]).addTo(this.map);
+    this.map.fire(ANVIL_EVENTS.CREATED, { layer: polygon7 });
+    this.reset();
+  }
+  getSquareBounds(start, end) {
+    const startPoint = this.map.latLngToContainerPoint(start);
+    const endPoint = this.map.latLngToContainerPoint(end);
+    const dx = endPoint.x - startPoint.x;
+    const dy = endPoint.y - startPoint.y;
+    const side = Math.max(Math.abs(dx), Math.abs(dy));
+    const newEndPoint = L7.point(
+      startPoint.x + side * Math.sign(dx),
+      startPoint.y + side * Math.sign(dy)
+    );
+    return L7.latLngBounds(start, this.map.containerPointToLatLng(newEndPoint));
+  }
+  reset() {
+    if (this.rectangle) this.map.removeLayer(this.rectangle);
+    this.rectangle = null;
+    this.startLatLng = null;
+  }
+};
+
+// src/modes/draw-triangle-mode.ts
+import * as L8 from "leaflet";
+var DrawTriangleMode = class {
+  constructor(map, options = {}, store) {
+    this.map = map;
+    this.options = options;
+    this.store = store;
+    __publicField(this, "ghostTriangle", null);
+    __publicField(this, "startLatLng", null);
+  }
+  enable() {
+    this.map.on("mousedown", this.onMouseDown, this);
+    this.map.on("mousemove", this.onMouseMove, this);
+    this.map.on("mouseup", this.onMouseUp, this);
+    this.map.dragging.disable();
+    this.map.getContainer().style.cursor = "crosshair";
+  }
+  disable() {
+    this.map.off("mousedown", this.onMouseDown, this);
+    this.map.off("mousemove", this.onMouseMove, this);
+    this.map.off("mouseup", this.onMouseUp, this);
+    this.map.dragging.enable();
+    this.map.getContainer().style.cursor = "";
+    this.reset();
+  }
+  onMouseDown(e) {
+    this.startLatLng = this.store ? getSnapLatLng(this.map, e.latlng, this.store, this.options) : e.latlng;
+  }
+  onMouseMove(e) {
+    if (!this.startLatLng) return;
+    const currentLatLng = this.store ? getSnapLatLng(this.map, e.latlng, this.store, this.options) : e.latlng;
+    const trianglePoints = this.getTrianglePoints(this.startLatLng, currentLatLng);
+    if (!this.ghostTriangle) {
+      this.ghostTriangle = L8.polygon(trianglePoints, { color: "#3388ff", weight: 2 }).addTo(this.map);
+    } else {
+      this.ghostTriangle.setLatLngs(trianglePoints);
+    }
+  }
+  onMouseUp(e) {
+    if (!this.startLatLng) return;
+    const currentLatLng = this.store ? getSnapLatLng(this.map, e.latlng, this.store, this.options) : e.latlng;
+    const trianglePoints = this.getTrianglePoints(this.startLatLng, currentLatLng);
+    const polygon7 = L8.polygon(trianglePoints).addTo(this.map);
+    this.map.fire(ANVIL_EVENTS.CREATED, { layer: polygon7 });
+    this.reset();
+  }
+  getTrianglePoints(start, end) {
+    const midLng = (start.lng + end.lng) / 2;
+    const tip = L8.latLng(end.lat, midLng);
+    const baseLeft = L8.latLng(start.lat, start.lng);
+    const baseRight = L8.latLng(start.lat, end.lng);
+    return [
+      tip,
+      baseRight,
+      baseLeft
+    ];
+  }
+  reset() {
+    if (this.ghostTriangle) this.map.removeLayer(this.ghostTriangle);
+    this.ghostTriangle = null;
+    this.startLatLng = null;
+  }
+};
+
+// src/modes/draw-circle-mode.ts
+import * as L9 from "leaflet";
+var DrawCircleMode = class {
+  constructor(map, options = {}, store) {
+    this.map = map;
+    this.options = options;
+    this.store = store;
+    __publicField(this, "circle", null);
+    __publicField(this, "centerLatLng", null);
+  }
+  enable() {
+    this.map.on("mousedown", this.onMouseDown, this);
+    this.map.on("mousemove", this.onMouseMove, this);
+    this.map.on("mouseup", this.onMouseUp, this);
+    this.map.dragging.disable();
+    this.map.getContainer().style.cursor = "crosshair";
+  }
+  disable() {
+    this.map.off("mousedown", this.onMouseDown, this);
+    this.map.off("mousemove", this.onMouseMove, this);
+    this.map.off("mouseup", this.onMouseUp, this);
+    this.map.dragging.enable();
+    this.map.getContainer().style.cursor = "";
+    this.reset();
+  }
+  onMouseDown(e) {
+    this.centerLatLng = this.store ? getSnapLatLng(this.map, e.latlng, this.store, this.options) : e.latlng;
+  }
+  onMouseMove(e) {
+    if (!this.centerLatLng) return;
+    const currentLatLng = this.store ? getSnapLatLng(this.map, e.latlng, this.store, this.options) : e.latlng;
+    const radius = this.map.distance(this.centerLatLng, currentLatLng);
+    if (!this.circle) {
+      this.circle = L9.circle(this.centerLatLng, { radius, color: "#3388ff", weight: 2 }).addTo(this.map);
+    } else {
+      this.circle.setRadius(radius);
+    }
+  }
+  onMouseUp(e) {
+    if (!this.centerLatLng) return;
+    const currentLatLng = this.store ? getSnapLatLng(this.map, e.latlng, this.store, this.options) : e.latlng;
+    const radius = this.map.distance(this.centerLatLng, currentLatLng);
+    const circle2 = L9.circle(this.centerLatLng, { radius }).addTo(this.map);
+    this.map.fire(ANVIL_EVENTS.CREATED, { layer: circle2 });
+    this.reset();
+  }
+  reset() {
+    if (this.circle) this.map.removeLayer(this.circle);
+    this.circle = null;
+    this.centerLatLng = null;
+  }
+};
+
+// src/modes/freehand-mode.ts
+import * as L10 from "leaflet";
+import * as turf from "@turf/turf";
+var FreehandMode = class {
+  constructor(map, _store, options = {}) {
+    this.map = map;
+    this.options = options;
+    __publicField(this, "points", []);
+    __publicField(this, "polyline", null);
+    __publicField(this, "isDrawing", false);
+  }
+  enable() {
+    this.map.dragging.disable();
+    this.map.on("mousedown", this.onMouseDown, this);
+    this.map.on("mousemove", this.onMouseMove, this);
+    this.map.on("mouseup", this.onMouseUp, this);
+    L10.DomEvent.on(window, "keydown", this.onKeyDown, this);
+    this.map.getContainer().style.cursor = "crosshair";
+  }
+  disable() {
+    this.map.dragging.enable();
+    this.map.off("mousedown", this.onMouseDown, this);
+    this.map.off("mousemove", this.onMouseMove, this);
+    this.map.off("mouseup", this.onMouseUp, this);
+    L10.DomEvent.off(window, "keydown", this.onKeyDown, this);
+    this.map.getContainer().style.cursor = "";
+    this.resetDrawing();
+  }
+  onMouseDown(e) {
+    this.isDrawing = true;
+    this.points = [e.latlng];
+    this.updateDrawing();
+  }
+  onMouseMove(e) {
+    if (!this.isDrawing) return;
+    const lastPoint = this.points[this.points.length - 1];
+    if (lastPoint.distanceTo(e.latlng) > 5) {
+      this.points.push(e.latlng);
+      this.updateDrawing();
+    }
+  }
+  onMouseUp() {
+    if (!this.isDrawing) return;
+    this.finish();
+  }
+  onKeyDown(e) {
+    if (e.key === "Escape") {
+      this.resetDrawing();
+    }
+  }
+  updateDrawing() {
+    if (this.polyline) {
+      this.polyline.setLatLngs(this.points);
+    } else {
+      this.polyline = L10.polyline(this.points, {
+        color: "#3388ff",
+        weight: 3,
+        opacity: 0.8,
+        dashArray: "5, 5"
+      }).addTo(this.map);
+    }
+  }
+  finish() {
+    if (this.points.length < 3) {
+      this.resetDrawing();
+      return;
+    }
+    const lineGeo = L10.polyline(this.points).toGeoJSON();
+    const tolerance = this.options.freehandTolerance || 1e-5;
+    const simplified = turf.simplify(lineGeo, { tolerance, highQuality: true });
+    const finalCoords = turf.getCoords(simplified);
+    if (finalCoords.length > 0 && (finalCoords[0][0] !== finalCoords[finalCoords.length - 1][0] || finalCoords[0][1] !== finalCoords[finalCoords.length - 1][1])) {
+      finalCoords.push(finalCoords[0]);
+    }
+    const finalPolygon = L10.polygon(finalCoords.map((c) => [c[1], c[0]])).addTo(this.map);
+    this.map.fire(ANVIL_EVENTS.CREATED, { layer: finalPolygon });
+    this.resetDrawing();
+  }
+  resetDrawing() {
+    if (this.polyline) this.map.removeLayer(this.polyline);
+    this.polyline = null;
+    this.points = [];
+    this.isDrawing = false;
+  }
+};
+
+// src/modes/cut-mode.ts
+import * as L11 from "leaflet";
+import * as turf2 from "@turf/turf";
+var CutMode = class {
+  constructor(map, store, options = {}) {
+    this.map = map;
+    this.store = store;
+    this.options = options;
+    __publicField(this, "points", []);
+    __publicField(this, "markers", []);
+    __publicField(this, "polyline", null);
+    __publicField(this, "ghostLine", null);
+  }
+  enable() {
+    this.map.on("click", this.onMapClick, this);
+    this.map.on("mousemove", this.onMouseMove, this);
+    L11.DomEvent.on(window, "keydown", this.onKeyDown, this);
+    this.map.getContainer().style.cursor = "crosshair";
+  }
+  disable() {
+    this.map.off("click", this.onMapClick, this);
+    this.map.off("mousemove", this.onMouseMove, this);
+    L11.DomEvent.off(window, "keydown", this.onKeyDown, this);
+    this.resetDrawing();
+    this.map.getContainer().style.cursor = "";
+  }
+  onMapClick(e) {
+    const latlng = getSnapLatLng(this.map, e.latlng, this.store, this.options, this.points);
+    if (this.points.length > 0 && this.isFirstPoint(latlng)) {
+      this.finish();
+      return;
+    }
+    this.points.push(latlng);
+    this.updateDrawing();
+  }
+  isFirstPoint(latlng) {
+    if (this.points.length < 3) return false;
+    const firstPoint = this.points[0];
+    const containerPoint = this.map.latLngToContainerPoint(latlng);
+    const firstContainerPoint = this.map.latLngToContainerPoint(firstPoint);
+    return containerPoint.distanceTo(firstContainerPoint) < 15;
+  }
+  onMouseMove(e) {
+    if (this.points.length === 0) return;
+    const snapLatLng = getSnapLatLng(this.map, e.latlng, this.store, this.options, this.points);
+    const lastPoint = this.points[this.points.length - 1];
+    if (!this.ghostLine) {
+      this.ghostLine = L11.polyline([lastPoint, snapLatLng], {
+        dashArray: "5, 5",
+        color: "#ff0000",
+        weight: 2
+      }).addTo(this.map);
+    } else {
+      this.ghostLine.setLatLngs([lastPoint, snapLatLng]);
+    }
+  }
+  onKeyDown(e) {
+    if (e.key === "Escape") {
+      this.resetDrawing();
+    }
+  }
+  updateDrawing() {
+    if (this.polyline) {
+      this.polyline.setLatLngs(this.points);
+    } else {
+      this.polyline = L11.polyline(this.points, { color: "#ff0000" }).addTo(this.map);
+    }
+    if (this.points.length === 1 && this.markers.length === 0) {
+      const marker4 = L11.circleMarker(this.points[0], {
+        radius: 6,
+        fillColor: "#fff",
+        fillOpacity: 1,
+        color: "#ff0000",
+        weight: 2
+      }).addTo(this.map);
+      marker4.on("click", (e) => {
+        L11.DomEvent.stopPropagation(e);
+        if (this.points.length >= 3) this.finish();
+      });
+      this.markers.push(marker4);
+    }
+  }
+  finish() {
+    if (this.points.length < 3) return;
+    const holeGeo = L11.polygon(this.points).toGeoJSON();
+    const intersectedLayers = [];
+    this.store.getGroup().eachLayer((layer) => {
+      if (layer instanceof L11.Polygon) {
+        const polyGeo = layer.toGeoJSON();
+        if (turf2.booleanIntersects(polyGeo, holeGeo)) {
+          intersectedLayers.push(layer);
+        }
+      }
+    });
+    if (intersectedLayers.length === 0) {
+      this.resetDrawing();
+      return;
+    }
+    intersectedLayers.forEach((polygon7) => {
+      const polyGeo = polygon7.toGeoJSON();
+      const result = turf2.difference(turf2.featureCollection([polyGeo, holeGeo]));
+      if (result) {
+        this.map.fire(ANVIL_EVENTS.DELETED, { layer: polygon7 });
+        this.map.removeLayer(polygon7);
+        const flattened = turf2.flatten(result);
+        flattened.features.forEach((f) => {
+          const l = L11.geoJSON(f).getLayers()[0];
+          l.addTo(this.map);
+          this.map.fire(ANVIL_EVENTS.CREATED, { layer: l });
+        });
+      }
+    });
+    this.resetDrawing();
+  }
+  resetDrawing() {
+    if (this.polyline) this.map.removeLayer(this.polyline);
+    if (this.ghostLine) this.map.removeLayer(this.ghostLine);
+    this.markers.forEach((m) => this.map.removeLayer(m));
+    this.points = [];
+    this.markers = [];
+    this.polyline = null;
+    this.ghostLine = null;
+  }
+};
+
+// src/modes/split-mode.ts
+import * as L12 from "leaflet";
+import * as turf3 from "@turf/turf";
+var SplitMode = class {
+  constructor(map, store, options = {}) {
+    this.map = map;
+    this.store = store;
+    this.options = options;
+    __publicField(this, "points", []);
+    __publicField(this, "markers", []);
+    __publicField(this, "polyline", null);
+    __publicField(this, "ghostLine", null);
+  }
+  enable() {
+    this.map.on("click", this.onMapClick, this);
+    this.map.on("mousemove", this.onMouseMove, this);
+    L12.DomEvent.on(window, "keydown", this.onKeyDown, this);
+    this.map.getContainer().style.cursor = "crosshair";
+  }
+  disable() {
+    this.map.off("click", this.onMapClick, this);
+    this.map.off("mousemove", this.onMouseMove, this);
+    L12.DomEvent.off(window, "keydown", this.onKeyDown, this);
+    this.map.getContainer().style.cursor = "";
+    this.resetDrawing();
+  }
+  onMapClick(e) {
+    const latlng = getSnapLatLng(this.map, e.latlng, this.store, this.options, this.points);
+    if (this.points.length > 0) {
+      const lastPoint = this.points[this.points.length - 1];
+      const p = this.map.latLngToContainerPoint(latlng);
+      const lp = this.map.latLngToContainerPoint(lastPoint);
+      if (p.distanceTo(lp) < 15 && this.points.length >= 2) {
+        this.finish();
+        return;
+      }
+    }
+    this.points.push(latlng);
+    this.updateDrawing();
+  }
+  onMouseMove(e) {
+    if (this.points.length === 0) return;
+    const snapLatLng = getSnapLatLng(this.map, e.latlng, this.store, this.options, this.points);
+    const lastPoint = this.points[this.points.length - 1];
+    if (!this.ghostLine) {
+      this.ghostLine = L12.polyline([lastPoint, snapLatLng], {
+        dashArray: "5, 5",
+        color: "#ff3300",
+        weight: 2
+      }).addTo(this.map);
+    } else {
+      this.ghostLine.setLatLngs([lastPoint, snapLatLng]);
+    }
+  }
+  onKeyDown(e) {
+    if (e.key === "Escape") {
+      this.resetDrawing();
+    }
+  }
+  updateDrawing() {
+    if (this.polyline) {
+      this.polyline.setLatLngs(this.points);
+    } else {
+      this.polyline = L12.polyline(this.points, { color: "#ff3300", weight: 3 }).addTo(this.map);
+    }
+    const lastPoint = this.points[this.points.length - 1];
+    if (this.markers.length === 0) {
+      const marker4 = L12.marker(lastPoint, {
+        icon: L12.divIcon({
+          className: "anvil-split-finish",
+          html: '<div style="width: 10px; height: 10px; background: #ff3300; border: 2px solid white; border-radius: 50%;"></div>',
+          iconSize: [10, 10],
+          iconAnchor: [5, 5]
+        })
+      }).addTo(this.map);
+      marker4.on("click", (e) => {
+        L12.DomEvent.stopPropagation(e);
+        this.finish();
+      });
+      this.markers.push(marker4);
+    } else {
+      this.markers[0].setLatLng(lastPoint);
+    }
+  }
+  finish() {
+    if (this.points.length < 2) {
+      this.resetDrawing();
+      return;
+    }
+    const lineGeo = L12.polyline(this.points).toGeoJSON();
+    const coords = turf3.getCoords(lineGeo);
+    const layersToSplit = [];
+    this.store.getGroup().eachLayer((layer) => {
+      if (layer instanceof L12.Polygon) {
+        const polyGeo = layer.toGeoJSON();
+        const intersections = turf3.lineIntersect(lineGeo, polyGeo);
+        if (intersections.features.length >= 2) {
+          layersToSplit.push(layer);
+        }
+      }
+    });
+    if (layersToSplit.length === 0) {
+      this.resetDrawing();
+      return;
+    }
+    const p1 = coords[0];
+    const p2 = coords[coords.length - 1];
+    const dx = p2[0] - p1[0];
+    const dy = p2[1] - p1[1];
+    const factor = 1e3;
+    const start = [p1[0] - dx * factor, p1[1] - dy * factor];
+    const end = [p2[0] + dx * factor, p2[1] + dy * factor];
+    const angle = Math.atan2(dy, dx);
+    const perp = angle + Math.PI / 2;
+    const width = 1e3;
+    const blade = turf3.polygon([[
+      start,
+      end,
+      [end[0] + Math.cos(perp) * width, end[1] + Math.sin(perp) * width],
+      [start[0] + Math.cos(perp) * width, start[1] + Math.sin(perp) * width],
+      start
+    ]]);
+    layersToSplit.forEach((polygon7) => {
+      const polyGeo = polygon7.toGeoJSON();
+      if (this.options.magnetic) {
+        const intersections = turf3.lineIntersect(lineGeo, polyGeo);
+        this.insertVerticesIntoNeighbors(intersections, polygon7);
+      }
+      const part1 = turf3.difference(turf3.featureCollection([polyGeo, blade]));
+      const part2 = turf3.intersect(turf3.featureCollection([polyGeo, blade]));
+      if (part1 && part2) {
+        const processResult = (result) => {
+          const flattened = turf3.flatten(result);
+          flattened.features.forEach((f) => {
+            const l = L12.geoJSON(f).getLayers()[0];
+            l.addTo(this.map);
+            this.map.fire(ANVIL_EVENTS.CREATED, { layer: l });
+          });
+        };
+        this.map.fire(ANVIL_EVENTS.DELETED, { layer: polygon7 });
+        this.map.removeLayer(polygon7);
+        processResult(part1);
+        processResult(part2);
+      }
+    });
+    this.resetDrawing();
+  }
+  insertVerticesIntoNeighbors(intersections, activePolygon) {
+    const intersectionCoords = intersections.features.map((f) => turf3.getCoord(f));
+    const layers = this.store.getGroup().getLayers();
+    layers.forEach((layer) => {
+      if (!(layer instanceof L12.Polyline) || layer === activePolygon) return;
+      const latlngs = layer.getLatLngs();
+      let changed = false;
+      const processArr = (arr) => {
+        if (arr.length === 0) return;
+        if (arr[0] instanceof L12.LatLng || typeof arr[0].lat === "number") {
+          const ring = arr;
+          const isPolygon = layer instanceof L12.Polygon;
+          const ringLen = ring.length;
+          for (let i = ringLen - 1; i >= 0; i--) {
+            if (i === ringLen - 1 && !isPolygon) continue;
+            const p1 = ring[i];
+            const p2 = ring[(i + 1) % ringLen];
+            const a = this.map.latLngToContainerPoint(p1);
+            const b = this.map.latLngToContainerPoint(p2);
+            intersectionCoords.forEach((coord) => {
+              const intersectLL = L12.latLng(coord[1], coord[0]);
+              const p = this.map.latLngToContainerPoint(intersectLL);
+              const closest = L12.LineUtil.closestPointOnSegment(p, a, b);
+              if (p.distanceTo(closest) < 1) {
+                const alreadyExists = ring.some(
+                  (ll) => this.map.latLngToContainerPoint(ll).distanceTo(p) < 1
+                );
+                if (!alreadyExists) {
+                  ring.splice(i + 1, 0, intersectLL);
+                  changed = true;
+                }
+              }
+            });
+          }
+        } else {
+          arr.forEach((item) => processArr(item));
+        }
+      };
+      processArr(latlngs);
+      if (changed) {
+        layer.setLatLngs(latlngs);
+        if (layer.redraw) layer.redraw();
+        this.map.fire(ANVIL_EVENTS.EDITED, { layer });
+      }
+    });
+  }
+  resetDrawing() {
+    if (this.polyline) this.map.removeLayer(this.polyline);
+    if (this.ghostLine) this.map.removeLayer(this.ghostLine);
+    this.markers.forEach((m) => this.map.removeLayer(m));
+    this.points = [];
+    this.markers = [];
+    this.polyline = null;
+    this.ghostLine = null;
+  }
+};
+
+// src/modes/drag-mode.ts
+import * as L13 from "leaflet";
+var DragMode = class {
+  constructor(map, store, options = {}) {
+    this.map = map;
+    this.store = store;
+    this.options = options;
+    __publicField(this, "draggingLayer", null);
+    __publicField(this, "startLatLng", null);
+    __publicField(this, "initialLatLngs", null);
+  }
+  enable() {
+    this.store.getGroup().eachLayer((layer) => {
+      if (layer instanceof L13.Path || layer instanceof L13.Marker) {
+        layer.on("mousedown", this.onMouseDown, this);
+        layer.getElement()?.style.setProperty("cursor", "move");
+      }
+    });
+  }
+  disable() {
+    this.store.getGroup().eachLayer((layer) => {
+      if (layer instanceof L13.Path || layer instanceof L13.Marker) {
+        layer.off("mousedown", this.onMouseDown, this);
+        layer.getElement()?.style.setProperty("cursor", "");
+      }
+    });
+    this.stopDragging();
+  }
+  onMouseDown(e) {
+    L13.DomEvent.stopPropagation(e);
+    const layer = e.target;
+    if (!this.store.hasLayer(layer)) {
+      return;
+    }
+    this.draggingLayer = layer;
+    this.startLatLng = e.latlng;
+    if (this.draggingLayer instanceof L13.Marker) {
+      this.initialLatLngs = this.draggingLayer.getLatLng();
+    } else if (this.draggingLayer instanceof L13.Path) {
+      if (this.draggingLayer instanceof L13.Circle) {
+        this.initialLatLngs = this.draggingLayer.getLatLng();
+      } else if (this.draggingLayer instanceof L13.Polyline) {
+        this.initialLatLngs = JSON.parse(JSON.stringify(this.draggingLayer.getLatLngs()));
+      }
+      this.draggingLayer.setStyle({ weight: 4, color: "#ffcc00" });
+    }
+    this.map.on("mousemove", this.onMouseMove, this);
+    this.map.on("mouseup", this.onMouseUp, this);
+    this.map.dragging.disable();
+  }
+  onMouseMove(e) {
+    if (!this.draggingLayer || !this.startLatLng) return;
+    const currentLatLng = getSnapLatLng(
+      this.map,
+      e.latlng,
+      this.store,
+      this.options,
+      [],
+      this.draggingLayer
+    );
+    const deltaLat = currentLatLng.lat - this.startLatLng.lat;
+    const deltaLng = currentLatLng.lng - this.startLatLng.lng;
+    if (this.draggingLayer instanceof L13.Marker || this.draggingLayer instanceof L13.Circle) {
+      const start = this.initialLatLngs;
+      this.draggingLayer.setLatLng([start.lat + deltaLat, start.lng + deltaLng]);
+    } else if (this.draggingLayer instanceof L13.Polyline) {
+      const newLatLngs = this.moveLatLngs(this.initialLatLngs, deltaLat, deltaLng);
+      this.draggingLayer.setLatLngs(newLatLngs);
+    }
+  }
+  moveLatLngs(latlngs, deltaLat, deltaLng) {
+    if (Array.isArray(latlngs)) {
+      return latlngs.map((item) => this.moveLatLngs(item, deltaLat, deltaLng));
+    }
+    return L13.latLng(latlngs.lat + deltaLat, latlngs.lng + deltaLng);
+  }
+  onMouseUp() {
+    if (this.draggingLayer) {
+      if (this.draggingLayer instanceof L13.Path) {
+        this.draggingLayer.setStyle({ weight: 3, color: "#3388ff" });
+      }
+      this.map.fire(ANVIL_EVENTS.EDITED, { layer: this.draggingLayer });
+    }
+    this.stopDragging();
+  }
+  stopDragging() {
+    this.map.off("mousemove", this.onMouseMove, this);
+    this.map.off("mouseup", this.onMouseUp, this);
+    this.map.dragging.enable();
+    this.draggingLayer = null;
+    this.startLatLng = null;
+    this.initialLatLngs = null;
+  }
+};
+
+// src/modes/scale-mode.ts
+import * as L14 from "leaflet";
+var ScaleMode = class {
+  constructor(map, store, options) {
+    this.map = map;
+    this.store = store;
+    this.options = options;
+    __publicField(this, "selectedLayer", null);
+    __publicField(this, "centerLatLng", null);
+    __publicField(this, "initialLatLngs", null);
+    __publicField(this, "initialRadius", 0);
+    __publicField(this, "initialDistance", 0);
+  }
+  enable() {
+    this.store.getGroup().eachLayer((layer) => {
+      if (layer instanceof L14.Path) {
+        layer.on("mousedown", this.onMouseDown, this);
+        layer.getElement()?.style.setProperty("cursor", "nwse-resize");
+      }
+    });
+  }
+  disable() {
+    this.store.getGroup().eachLayer((layer) => {
+      if (layer instanceof L14.Path) {
+        layer.off("mousedown", this.onMouseDown, this);
+        layer.getElement()?.style.setProperty("cursor", "");
+      }
+    });
+    this.stopScaling();
+  }
+  onMouseDown(e) {
+    L14.DomEvent.stopPropagation(e);
+    const layer = e.target;
+    if (!this.store.hasLayer(layer)) {
+      return;
+    }
+    this.selectedLayer = layer;
+    if (this.selectedLayer instanceof L14.Circle) {
+      this.centerLatLng = this.selectedLayer.getLatLng();
+      this.initialRadius = this.selectedLayer.getRadius();
+    } else if (this.selectedLayer instanceof L14.Path) {
+      const bounds = this.selectedLayer.getBounds();
+      this.centerLatLng = bounds.getCenter();
+      this.initialLatLngs = JSON.parse(JSON.stringify(this.selectedLayer.getLatLngs()));
+      this.selectedLayer.setStyle({ weight: 4, color: "#ffcc00" });
+    }
+    if (this.centerLatLng) {
+      this.initialDistance = this.map.distance(this.centerLatLng, e.latlng);
+      this.map.on("mousemove", this.onMouseMove, this);
+      this.map.on("mouseup", this.onMouseUp, this);
+      this.map.dragging.disable();
+    }
+  }
+  onMouseMove(e) {
+    if (!this.selectedLayer || !this.centerLatLng || this.initialDistance === 0) return;
+    const currentDistance = this.map.distance(this.centerLatLng, e.latlng);
+    const ratio = currentDistance / this.initialDistance;
+    if (this.selectedLayer instanceof L14.Circle) {
+      this.selectedLayer.setRadius(this.initialRadius * ratio);
+    } else if (this.selectedLayer instanceof L14.Path) {
+      const newLatLngs = this.scaleLatLngs(this.initialLatLngs, this.centerLatLng, ratio);
+      this.selectedLayer.setLatLngs(newLatLngs);
+    }
+  }
+  scaleLatLngs(latlngs, center, ratio) {
+    if (Array.isArray(latlngs)) {
+      return latlngs.map((item) => this.scaleLatLngs(item, center, ratio));
+    }
+    const lat = center.lat + (latlngs.lat - center.lat) * ratio;
+    const lng = center.lng + (latlngs.lng - center.lng) * ratio;
+    return L14.latLng(lat, lng);
+  }
+  onMouseUp() {
+    if (this.selectedLayer) {
+      if (this.selectedLayer instanceof L14.Path) {
+        this.selectedLayer.setStyle({ weight: 3, color: "#3388ff" });
+      }
+      this.map.fire(ANVIL_EVENTS.EDITED, { layer: this.selectedLayer });
+    }
+    this.stopScaling();
+  }
+  stopScaling() {
+    this.map.off("mousemove", this.onMouseMove, this);
+    this.map.off("mouseup", this.onMouseUp, this);
+    this.map.dragging.enable();
+    this.selectedLayer = null;
+    this.centerLatLng = null;
+    this.initialLatLngs = null;
+  }
+};
+
+// src/modes/rotate-mode.ts
+import * as L15 from "leaflet";
+var RotateMode = class {
+  constructor(map, store, options) {
+    this.map = map;
+    this.store = store;
+    this.options = options;
+    __publicField(this, "selectedLayer", null);
+    __publicField(this, "centerLatLng", null);
+    __publicField(this, "initialLatLngs", null);
+    __publicField(this, "startAngle", 0);
+  }
+  enable() {
+    this.store.getGroup().eachLayer((layer) => {
+      if (layer instanceof L15.Path) {
+        layer.on("mousedown", this.onMouseDown, this);
+        layer.getElement()?.style.setProperty("cursor", "crosshair");
+      }
+    });
+  }
+  disable() {
+    this.store.getGroup().eachLayer((layer) => {
+      if (layer instanceof L15.Path) {
+        layer.off("mousedown", this.onMouseDown, this);
+        layer.getElement()?.style.setProperty("cursor", "");
+      }
+    });
+    this.stopRotating();
+  }
+  onMouseDown(e) {
+    L15.DomEvent.stopPropagation(e);
+    const layer = e.target;
+    if (!this.store.hasLayer(layer) || !(layer instanceof L15.Path) || layer instanceof L15.Circle) {
+      return;
+    }
+    const pathLayer = layer;
+    this.selectedLayer = pathLayer;
+    const bounds = pathLayer.getBounds();
+    this.centerLatLng = bounds.getCenter();
+    this.initialLatLngs = JSON.parse(JSON.stringify(pathLayer.getLatLngs()));
+    const point2 = this.map.latLngToContainerPoint(e.latlng);
+    const centerPoint = this.map.latLngToContainerPoint(this.centerLatLng);
+    this.startAngle = Math.atan2(point2.y - centerPoint.y, point2.x - centerPoint.x);
+    pathLayer.setStyle({ weight: 4, color: "#ffcc00" });
+    this.map.on("mousemove", this.onMouseMove, this);
+    this.map.on("mouseup", this.onMouseUp, this);
+    this.map.dragging.disable();
+  }
+  onMouseMove(e) {
+    if (!this.selectedLayer || !this.centerLatLng) return;
+    const point2 = this.map.latLngToContainerPoint(e.latlng);
+    const centerPoint = this.map.latLngToContainerPoint(this.centerLatLng);
+    const currentAngle = Math.atan2(point2.y - centerPoint.y, point2.x - centerPoint.x);
+    const rotationAngle = currentAngle - this.startAngle;
+    const newLatLngs = this.rotateLatLngs(this.initialLatLngs, this.centerLatLng, rotationAngle);
+    this.selectedLayer.setLatLngs(newLatLngs);
+  }
+  rotateLatLngs(latlngs, center, angle) {
+    if (Array.isArray(latlngs)) {
+      return latlngs.map((item) => this.rotateLatLngs(item, center, angle));
+    }
+    const point2 = this.map.latLngToContainerPoint(latlngs);
+    const centerPoint = this.map.latLngToContainerPoint(center);
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    const dx = point2.x - centerPoint.x;
+    const dy = point2.y - centerPoint.y;
+    const nx = dx * cos - dy * sin + centerPoint.x;
+    const ny = dx * sin + dy * cos + centerPoint.y;
+    return this.map.containerPointToLatLng([nx, ny]);
+  }
+  onMouseUp() {
+    if (this.selectedLayer) {
+      this.selectedLayer.setStyle({ weight: 3, color: "#3388ff" });
+      this.map.fire(ANVIL_EVENTS.EDITED, { layer: this.selectedLayer });
+    }
+    this.stopRotating();
+  }
+  stopRotating() {
+    this.map.off("mousemove", this.onMouseMove, this);
+    this.map.off("mouseup", this.onMouseUp, this);
+    this.map.dragging.enable();
+    this.selectedLayer = null;
+    this.centerLatLng = null;
+    this.initialLatLngs = null;
+  }
+};
+
+// src/modes/union-mode.ts
+import * as L16 from "leaflet";
+import * as turf4 from "@turf/turf";
+var UnionMode = class {
+  constructor(map, store, options = {}) {
+    this.map = map;
+    this.store = store;
+    this.options = options;
+    __publicField(this, "firstLayer", null);
+  }
+  enable() {
+    this.store.getGroup().eachLayer((layer) => {
+      if (layer instanceof L16.Polygon) {
+        layer.on("click", this.onLayerClick, this);
+        layer.getElement()?.style.setProperty("cursor", "pointer");
+      }
+    });
+  }
+  disable() {
+    this.store.getGroup().eachLayer((layer) => {
+      if (layer instanceof L16.Polygon) {
+        layer.off("click", this.onLayerClick, this);
+        layer.getElement()?.style.setProperty("cursor", "");
+      }
+    });
+    this.reset();
+  }
+  onLayerClick(e) {
+    L16.DomEvent.stopPropagation(e);
+    const layer = e.target;
+    if (!this.firstLayer) {
+      this.firstLayer = layer;
+      this.firstLayer.setStyle({ color: "#ff00ff", weight: 4 });
+      return;
+    }
+    if (this.firstLayer === layer) {
+      this.reset();
+      return;
+    }
+    const g1 = this.firstLayer.toGeoJSON();
+    const g2 = layer.toGeoJSON();
+    const united = turf4.union(turf4.featureCollection([g1, g2]));
+    if (!united) {
+      console.error("Union failed - results null");
+      this.reset();
+      return;
+    }
+    this.map.fire(ANVIL_EVENTS.DELETED, { layer: this.firstLayer });
+    this.map.fire(ANVIL_EVENTS.DELETED, { layer });
+    this.map.removeLayer(this.firstLayer);
+    this.map.removeLayer(layer);
+    const flattened = turf4.flatten(united);
+    flattened.features.forEach((f) => {
+      const newLayerGroup = L16.geoJSON(f, {
+        style: this.options.pathOptions
+      });
+      const l = newLayerGroup.getLayers()[0];
+      l.addTo(this.map);
+      this.map.fire(ANVIL_EVENTS.CREATED, { layer: l });
+    });
+    this.firstLayer = null;
+  }
+  reset() {
+    if (this.firstLayer) {
+      this.firstLayer.setStyle({ color: "#3388ff", weight: 3, ...this.options.pathOptions });
+      this.firstLayer = null;
+    }
+  }
+};
+
+// src/modes/subtract-mode.ts
+import * as L17 from "leaflet";
+import * as turf5 from "@turf/turf";
+var SubtractMode = class {
+  constructor(map, store, options = {}) {
+    this.map = map;
+    this.store = store;
+    this.options = options;
+    __publicField(this, "baseLayer", null);
+  }
+  enable() {
+    this.store.getGroup().eachLayer((layer) => {
+      if (layer instanceof L17.Polygon) {
+        layer.on("click", this.onLayerClick, this);
+        layer.getElement()?.style.setProperty("cursor", "pointer");
+      }
+    });
+  }
+  disable() {
+    this.store.getGroup().eachLayer((layer) => {
+      if (layer instanceof L17.Polygon) {
+        layer.off("click", this.onLayerClick, this);
+        layer.getElement()?.style.setProperty("cursor", "");
+      }
+    });
+    this.reset();
+  }
+  onLayerClick(e) {
+    L17.DomEvent.stopPropagation(e);
+    const layer = e.target;
+    if (!this.baseLayer) {
+      this.baseLayer = layer;
+      this.baseLayer.setStyle({ color: "#ff0000", weight: 4 });
+      return;
+    }
+    if (this.baseLayer === layer) {
+      this.reset();
+      return;
+    }
+    const g1 = this.baseLayer.toGeoJSON();
+    const g2 = layer.toGeoJSON();
+    const diff = turf5.difference(turf5.featureCollection([g1, g2]));
+    this.map.fire(ANVIL_EVENTS.DELETED, { layer: this.baseLayer });
+    this.map.fire(ANVIL_EVENTS.DELETED, { layer });
+    this.map.removeLayer(this.baseLayer);
+    this.map.removeLayer(layer);
+    if (diff) {
+      const flattened = turf5.flatten(diff);
+      flattened.features.forEach((f) => {
+        const newLayerGroup = L17.geoJSON(f);
+        const l = newLayerGroup.getLayers()[0];
+        l.addTo(this.map);
+        this.map.fire(ANVIL_EVENTS.CREATED, { layer: l });
+      });
+    }
+    this.baseLayer = null;
+  }
+  reset() {
+    if (this.baseLayer) {
+      this.baseLayer.setStyle({ color: "#3388ff", weight: 3 });
+      this.baseLayer = null;
+    }
+  }
+};
+
+// src/modes/edit-mode.ts
+import * as L18 from "leaflet";
+var EditMode = class {
+  constructor(map, store, options = {}) {
+    this.map = map;
+    this.store = store;
+    this.options = options;
+    __publicField(this, "activeLayers", /* @__PURE__ */ new Set());
+    __publicField(this, "markers", []);
+    __publicField(this, "ghostMarker", null);
+    __publicField(this, "segments", []);
+    __publicField(this, "_isDragging", false);
+  }
+  enable() {
+    this.store.getGroup().eachLayer((layer) => {
+      if (layer instanceof L18.Path || layer instanceof L18.Marker) {
+        layer.on("click", this.onLayerClick, this);
+        layer.on("mousemove", this.onMouseMove, this);
+        layer.getElement()?.style.setProperty("cursor", "pointer");
+      }
+    });
+    this.map.on("click", this.onMapClick, this);
+    this.map.on("mousemove", this.onMouseMove, this);
+  }
+  disable() {
+    this.store.getGroup().eachLayer((layer) => {
+      if (layer instanceof L18.Path || layer instanceof L18.Marker) {
+        layer.off("click", this.onLayerClick, this);
+        layer.off("mousemove", this.onMouseMove, this);
+        layer.getElement()?.style.setProperty("cursor", "");
+        if (layer instanceof L18.Path) {
+          layer.setStyle({ color: "#3388ff", weight: 3, fillOpacity: 0.2 });
+        }
+      }
+    });
+    this.map.off("click", this.onMapClick, this);
+    this.map.off("mousemove", this.onMouseMove, this);
+    this.clearMarkers();
+    this.activeLayers.clear();
+  }
+  onLayerClick(e) {
+    L18.DomEvent.stopPropagation(e);
+    const layer = e.target;
+    const isMultiSelect = e.originalEvent.shiftKey || this.options.magnetic;
+    if (!isMultiSelect) {
+      if (this.activeLayers.has(layer) && this.activeLayers.size === 1) return;
+      this.activeLayers.forEach((l) => {
+        if (l instanceof L18.Path) l.setStyle({ color: "#3388ff", weight: 3 });
+      });
+      this.clearMarkers();
+      this.activeLayers.clear();
+      this.activeLayers.add(layer);
+    } else {
+      if (this.activeLayers.has(layer)) {
+        this.activeLayers.delete(layer);
+        if (layer instanceof L18.Path) layer.setStyle({ color: "#3388ff", weight: 3 });
+      } else {
+        this.activeLayers.add(layer);
+      }
+      this.clearMarkers();
+    }
+    this.activeLayers.forEach((l) => {
+      if (l instanceof L18.Path) l.setStyle({ color: "#ff00ff", weight: 4 });
+    });
+    this.createMarkers();
+  }
+  onMapClick() {
+    this.clearMarkers();
+    this.activeLayers.clear();
+  }
+  createMarkers() {
+    this.clearMarkers();
+    if (this.activeLayers.size === 0) return;
+    const vertexMap = /* @__PURE__ */ new Map();
+    this.segments = [];
+    const segmentMap = /* @__PURE__ */ new Map();
+    const getPosKey = (ll) => `${ll.lat.toFixed(6)},${ll.lng.toFixed(6)}`;
+    this.activeLayers.forEach((layer) => {
+      if (layer instanceof L18.Marker) {
+        this.handleMarkerEdit(layer);
+      } else if (layer instanceof L18.Circle) {
+        this.handleCircleEdit(layer);
+      } else if (layer instanceof L18.Polyline) {
+        const latlngs = layer.getLatLngs();
+        const traverse = (arr, currentPath) => {
+          if (!arr) return;
+          if (Array.isArray(arr) && arr.length > 0 && (arr[0] instanceof L18.LatLng || typeof arr[0].lat === "number")) {
+            const isPolygon = layer instanceof L18.Polygon;
+            let ringLen = arr.length;
+            if (isPolygon && ringLen > 1) {
+              if (getPosKey(arr[0]) === getPosKey(arr[ringLen - 1])) {
+                ringLen--;
+              }
+            }
+            arr.forEach((ll, i) => {
+              if (i >= ringLen) return;
+              const key = getPosKey(ll);
+              if (!vertexMap.has(key)) vertexMap.set(key, { latlng: ll, refs: [], marker: null });
+              vertexMap.get(key).refs.push({ layer, path: [...currentPath, i] });
+              if (i < ringLen - 1 || isPolygon) {
+                const nextIndex = (i + 1) % ringLen;
+                const nextLL = arr[nextIndex];
+                if (getPosKey(ll) === getPosKey(nextLL)) return;
+                const k1 = getPosKey(ll);
+                const k2 = getPosKey(nextLL);
+                const midKey = [k1, k2].sort().join("|");
+                if (!segmentMap.has(midKey)) {
+                  segmentMap.set(midKey, { p1: ll, p2: nextLL, refs: [] });
+                }
+                segmentMap.get(midKey).refs.push({ layer, path: [...currentPath, i] });
+              }
+            });
+          } else if (Array.isArray(arr)) {
+            arr.forEach((item, i) => traverse(item, [...currentPath, i]));
+          }
+        };
+        traverse(latlngs, []);
+      }
+    });
+    this.segments = Array.from(segmentMap.values());
+    vertexMap.forEach((group) => {
+      const marker4 = this.createEditMarker(group.latlng);
+      group.marker = marker4;
+      this.markers.push(marker4);
+      marker4.on("dragstart", () => {
+        this._isDragging = true;
+      });
+      marker4.on("drag", (e) => {
+        const mouseEvent = e;
+        const skipLayersArray = Array.from(this.activeLayers);
+        const additionalPoints = [
+          ...this.markers.filter((m) => m !== marker4).map((m) => m.getLatLng()),
+          ...Array.from(this.activeLayers).filter((l) => l instanceof L18.Marker).map((l) => l.getLatLng())
+        ];
+        const snapped = getSnapLatLng(this.map, mouseEvent.latlng, this.store, this.options, additionalPoints, skipLayersArray);
+        if (this.options.preventSelfIntersection) {
+          let wouldIntersect = false;
+          group.refs.forEach((ref) => {
+            const fullStructure = ref.layer.getLatLngs();
+            let target = fullStructure;
+            for (let i = 0; i < ref.path.length - 1; i++) {
+              target = target[ref.path[i]];
+            }
+            const oldPos = target[ref.path[ref.path.length - 1]];
+            target[ref.path[ref.path.length - 1]] = snapped;
+            if (isSelfIntersecting(this.map, fullStructure, ref.layer instanceof L18.Polygon)) {
+              wouldIntersect = true;
+            }
+            target[ref.path[ref.path.length - 1]] = oldPos;
+          });
+          if (wouldIntersect) return;
+        }
+        marker4.setLatLng(snapped);
+        group.latlng = snapped;
+        group.refs.forEach((ref) => {
+          const fullStructure = ref.layer.getLatLngs();
+          let target = fullStructure;
+          for (let i = 0; i < ref.path.length - 1; i++) {
+            target = target[ref.path[i]];
+          }
+          target[ref.path[ref.path.length - 1]] = snapped;
+          ref.layer.setLatLngs(fullStructure);
+          ref.layer.redraw();
+        });
+      });
+      marker4.on("dragend", () => {
+        this._isDragging = false;
+        this.activeLayers.forEach((l) => this.map.fire(ANVIL_EVENTS.EDITED, { layer: l }));
+        this.refreshMarkers();
+      });
+      marker4.on("contextmenu", (e) => {
+        const mouseEvent = e;
+        L18.DomEvent.stopPropagation(mouseEvent);
+        this.deleteVertex(group);
+      });
+    });
+  }
+  deleteVertex(group) {
+    const layersToDelete = /* @__PURE__ */ new Set();
+    group.refs.forEach((ref) => {
+      const fullStructure = ref.layer.getLatLngs();
+      let target = fullStructure;
+      for (let i = 0; i < ref.path.length - 1; i++) {
+        target = target[ref.path[i]];
+      }
+      const index = ref.path[ref.path.length - 1];
+      const isPolygon = ref.layer instanceof L18.Polygon;
+      const minVertices = isPolygon ? 3 : 2;
+      if (target.length > minVertices) {
+        target.splice(index, 1);
+        ref.layer.setLatLngs(fullStructure);
+        ref.layer.redraw();
+        this.map.fire(ANVIL_EVENTS.EDITED, { layer: ref.layer });
+      } else {
+        layersToDelete.add(ref.layer);
+      }
+    });
+    layersToDelete.forEach((layer) => {
+      this.activeLayers.delete(layer);
+      this.map.removeLayer(layer);
+      this.map.fire(ANVIL_EVENTS.DELETED, { layer });
+    });
+    this.refreshMarkers();
+  }
+  onMouseMove(e) {
+    const mouseEvent = e;
+    if (this.activeLayers.size === 0 || this.segments.length === 0 || this._isDragging) {
+      if (!this._isDragging) this.removeGhost();
+      return;
+    }
+    const mousePoint = this.map.latLngToContainerPoint(mouseEvent.latlng);
+    const isOverVertex = this.markers.some((m) => {
+      const p = this.map.latLngToContainerPoint(m.getLatLng());
+      return p.distanceTo(mousePoint) < 15;
+    });
+    if (isOverVertex) {
+      this.removeGhost();
+      return;
+    }
+    let closestSeg = null;
+    let minDistance = 24;
+    let bestLatLng = null;
+    this.segments.forEach((seg) => {
+      const A = this.map.latLngToContainerPoint(seg.p1);
+      const B = this.map.latLngToContainerPoint(seg.p2);
+      const proj = L18.LineUtil.closestPointOnSegment(mousePoint, A, B);
+      const dist = mousePoint.distanceTo(proj);
+      if (dist < minDistance) {
+        minDistance = dist;
+        closestSeg = seg;
+        bestLatLng = this.map.containerPointToLatLng(proj);
+      }
+    });
+    if (closestSeg && bestLatLng) {
+      this.showGhost(bestLatLng, closestSeg);
+    } else {
+      this.removeGhost();
+    }
+  }
+  createEditMarker(latlng) {
+    return L18.marker(latlng, {
+      draggable: true,
+      zIndexOffset: 2e3,
+      icon: L18.divIcon({
+        className: "anvil-edit-marker",
+        html: '<div style="width: 12px; height: 12px; background: #fff; border: 2px solid #ff00ff; border-radius: 50%; box-sizing: border-box; box-shadow: 0 0 4px rgba(0,0,0,0.3);"></div>',
+        iconSize: [12, 12],
+        iconAnchor: [6, 6]
+      })
+    }).addTo(this.map);
+  }
+  showGhost(latlng, segment) {
+    if (this.ghostMarker) {
+      if (!this._isDragging) {
+        this.ghostMarker.setLatLng(latlng);
+        this.ghostMarker._activeSeg = segment;
+      }
+      return;
+    }
+    this.ghostMarker = L18.marker(latlng, {
+      draggable: true,
+      opacity: 0.7,
+      zIndexOffset: 3e3,
+      icon: L18.divIcon({
+        className: "anvil-ghost-marker",
+        html: '<div style="width: 10px; height: 10px; background: #ff00ff; border: 2px solid #fff; border-radius: 50%; box-sizing: border-box; box-shadow: 0 0 4px rgba(0,0,0,0.3);"></div>',
+        iconSize: [10, 10],
+        iconAnchor: [5, 5]
+      })
+    }).addTo(this.map);
+    this.ghostMarker.on("dragstart", () => {
+      this._isDragging = true;
+      const activeSeg = this.ghostMarker._activeSeg || segment;
+      const startLL = this.ghostMarker.getLatLng();
+      activeSeg.refs.forEach((ref) => {
+        const fullStructure = ref.layer.getLatLngs();
+        let target = fullStructure;
+        for (let i = 0; i < ref.path.length - 1; i++) {
+          target = target[ref.path[i]];
+        }
+        target.splice(ref.path[ref.path.length - 1] + 1, 0, startLL);
+        ref.layer.setLatLngs(fullStructure);
+      });
+    });
+    this.ghostMarker.on("drag", (e) => {
+      const mouseEvent = e;
+      const skipLayersArray = Array.from(this.activeLayers);
+      const additionalPoints = [
+        ...this.markers.map((m) => m.getLatLng()),
+        ...Array.from(this.activeLayers).filter((l) => l instanceof L18.Marker).map((l) => l.getLatLng())
+      ];
+      const snapped = getSnapLatLng(this.map, mouseEvent.latlng, this.store, this.options, additionalPoints, skipLayersArray);
+      if (this.options.preventSelfIntersection) {
+        let wouldIntersect = false;
+        const activeSeg2 = this.ghostMarker._activeSeg || segment;
+        activeSeg2.refs.forEach((ref) => {
+          const fullStructure = ref.layer.getLatLngs();
+          let target = fullStructure;
+          for (let i = 0; i < ref.path.length - 1; i++) {
+            target = target[ref.path[i]];
+          }
+          const oldPos = target[ref.path[ref.path.length - 1] + 1];
+          target[ref.path[ref.path.length - 1] + 1] = snapped;
+          if (isSelfIntersecting(this.map, fullStructure, ref.layer instanceof L18.Polygon)) {
+            wouldIntersect = true;
+          }
+          target[ref.path[ref.path.length - 1] + 1] = oldPos;
+        });
+        if (wouldIntersect) return;
+      }
+      this.ghostMarker.setLatLng(snapped);
+      const activeSeg = this.ghostMarker._activeSeg || segment;
+      activeSeg.refs.forEach((ref) => {
+        const fullStructure = ref.layer.getLatLngs();
+        let target = fullStructure;
+        for (let i = 0; i < ref.path.length - 1; i++) {
+          target = target[ref.path[i]];
+        }
+        target[ref.path[ref.path.length - 1] + 1] = snapped;
+        ref.layer.setLatLngs(fullStructure);
+        ref.layer.redraw();
+      });
+    });
+    this.ghostMarker.on("dragend", () => {
+      this._isDragging = false;
+      this.activeLayers.forEach((l) => this.map.fire(ANVIL_EVENTS.EDITED, { layer: l }));
+      this.removeGhost();
+      this.refreshMarkers();
+    });
+  }
+  removeGhost() {
+    if (this.ghostMarker && !this._isDragging) {
+      this.map.removeLayer(this.ghostMarker);
+      this.ghostMarker = null;
+    }
+  }
+  handleMarkerEdit(marker4) {
+    marker4.dragging?.enable();
+    marker4.on("drag", (e) => {
+      const mouseEvent = e;
+      const additionalPoints = this.markers.map((m) => m.getLatLng());
+      const snapped = getSnapLatLng(this.map, mouseEvent.latlng, this.store, this.options, additionalPoints, marker4);
+      marker4.setLatLng(snapped);
+    });
+    marker4.on("dragend", () => {
+      this.map.fire(ANVIL_EVENTS.EDITED, { layer: marker4 });
+    });
+    marker4.on("contextmenu", (e) => {
+      const mouseEvent = e;
+      L18.DomEvent.stopPropagation(mouseEvent);
+      this.activeLayers.delete(marker4);
+      this.map.removeLayer(marker4);
+      this.map.fire(ANVIL_EVENTS.DELETED, { layer: marker4 });
+      this.refreshMarkers();
+    });
+  }
+  handleCircleEdit(circle2) {
+    const marker4 = this.createEditMarker(circle2.getLatLng());
+    marker4.on("drag", (e) => {
+      const mouseEvent = e;
+      const additionalPoints = this.markers.filter((m) => m !== marker4).map((m) => m.getLatLng());
+      const snapped = getSnapLatLng(this.map, mouseEvent.latlng, this.store, this.options, additionalPoints, circle2);
+      marker4.setLatLng(snapped);
+      circle2.setLatLng(snapped);
+    });
+    marker4.on("dragend", () => {
+      this.map.fire(ANVIL_EVENTS.EDITED, { layer: circle2 });
+    });
+    marker4.on("contextmenu", (e) => {
+      const mouseEvent = e;
+      L18.DomEvent.stopPropagation(mouseEvent);
+      this.activeLayers.delete(circle2);
+      this.map.removeLayer(circle2);
+      this.map.fire(ANVIL_EVENTS.DELETED, { layer: circle2 });
+      this.refreshMarkers();
+    });
+    this.markers.push(marker4);
+  }
+  clearMarkers() {
+    this.activeLayers.forEach((layer) => {
+      if (layer instanceof L18.Marker) {
+        layer.dragging?.disable();
+        layer.off("drag");
+        layer.off("dragend");
+        layer.off("contextmenu");
+      }
+    });
+    this.markers.forEach((m) => this.map.removeLayer(m));
+    this.markers = [];
+    this.removeGhost();
+  }
+  refreshMarkers() {
+    this.clearMarkers();
+    this.createMarkers();
+  }
+};
+
+// src/modes/delete-mode.ts
+import * as L19 from "leaflet";
+var DeleteMode = class {
+  constructor(map, store) {
+    this.map = map;
+    this.store = store;
+  }
+  enable() {
+    this.store.getGroup().eachLayer((layer) => {
+      layer.on("click", this.onClick, this);
+      if (layer instanceof L19.Path || layer instanceof L19.Marker) {
+        layer.getElement()?.style.setProperty("cursor", "pointer");
+      }
+    });
+  }
+  disable() {
+    this.store.getGroup().eachLayer((layer) => {
+      layer.off("click", this.onClick, this);
+      if (layer instanceof L19.Path || layer instanceof L19.Marker) {
+        layer.getElement()?.style.setProperty("cursor", "");
+      }
+    });
+  }
+  onClick(e) {
+    L19.DomEvent.stopPropagation(e);
+    const layer = e.target;
+    this.map.removeLayer(layer);
+    this.map.fire(ANVIL_EVENTS.DELETED, { layer });
+  }
+};
+
+// src/layers/layer-store.ts
+import * as L20 from "leaflet";
+var LayerStore = class {
+  constructor(map, layerGroup) {
+    __publicField(this, "group");
+    this.group = layerGroup || L20.featureGroup();
+    this.group.addTo(map);
+  }
+  addLayer(layer) {
+    this.group.addLayer(layer);
+  }
+  removeLayer(layer) {
+    this.group.removeLayer(layer);
+  }
+  hasLayer(layer) {
+    return this.group.hasLayer(layer);
+  }
+  getGroup() {
+    return this.group;
+  }
+};
+
+// src/anvil.ts
+var Anvil = class {
+  constructor(map, options) {
+    this.map = map;
+    __publicField(this, "modeManager");
+    __publicField(this, "store");
+    __publicField(this, "options");
+    this.options = { snapping: false, snapDistance: 10, preventSelfIntersection: false, ...options };
+    this.store = new LayerStore(map, this.options.layerGroup);
+    this.modeManager = new ModeManager(map);
+    this.modeManager.addMode("draw:polygon", new DrawPolygonMode(this.map, this.options, this.store));
+    this.modeManager.addMode("draw:polyline", new DrawPolylineMode(this.map, this.options, this.store));
+    this.modeManager.addMode("draw:marker", new DrawMarkerMode(this.map, this.options, this.store));
+    this.modeManager.addMode("draw:rectangle", new DrawRectangleMode(this.map, this.options, this.store));
+    this.modeManager.addMode("draw:square", new DrawSquareMode(this.map, this.options, this.store));
+    this.modeManager.addMode("draw:triangle", new DrawTriangleMode(this.map, this.options, this.store));
+    this.modeManager.addMode("draw:circle", new DrawCircleMode(this.map, this.options, this.store));
+    this.modeManager.addMode("draw:freehand", new FreehandMode(this.map, this.store, this.options));
+    this.modeManager.addMode("cut", new CutMode(map, this.store, this.options));
+    this.modeManager.addMode("split", new SplitMode(map, this.store, this.options));
+    this.modeManager.addMode("union", new UnionMode(map, this.store, this.options));
+    this.modeManager.addMode("subtract", new SubtractMode(map, this.store, this.options));
+    this.modeManager.addMode("drag", new DragMode(map, this.store, this.options));
+    this.modeManager.addMode("scale", new ScaleMode(map, this.store, this.options));
+    this.modeManager.addMode("rotate", new RotateMode(map, this.store, this.options));
+    this.modeManager.addMode("edit", new EditMode(this.map, this.store, this.options));
+    this.modeManager.addMode("delete", new DeleteMode(map, this.store));
+    this.map.on(ANVIL_EVENTS.CREATED, (e) => {
+      this.store.addLayer(e.layer);
+    });
+    this.map.on(ANVIL_EVENTS.DELETED, (e) => {
+      this.store.removeLayer(e.layer);
+    });
+  }
+  enable(mode) {
+    this.modeManager.enable(mode);
+  }
+  disable() {
+    this.modeManager.disable();
+  }
+  getLayerGroup() {
+    return this.store.getGroup();
+  }
+};
+
+// src/controls/anvil-control.ts
+import * as L21 from "leaflet";
+var SVG_ATTRS = 'xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"';
+var ICONS = {
+  // Marker: Map-Pin mit Punkt in der Mitte
+  "draw:marker": `<svg ${SVG_ATTRS}><path d="M20 10c0 6-8 12-8 12s-8-6-8-12a8 8 0 0 1 16 0Z"/><circle cx="12" cy="10" r="3"/></svg>`,
+  // Polyline: Kurvige Route mit Endpunkten
+  "draw:polyline": `<svg ${SVG_ATTRS}><path d="M9 19h8.5a3.5 3.5 0 0 0 0-7h-11a3.5 3.5 0 0 1 0-7H15"/><circle cx="18" cy="5" r="3"/><circle cx="6" cy="19" r="3"/></svg>`,
+  // Polygon: Klassische unregelmäßige 5-Eck-Form
+  "draw:polygon": `<svg ${SVG_ATTRS}><path d="m12 2 10 7-3 12H5l-3-12Z"/></svg>`,
+  // Rectangle: Horizontales Rechteck
+  "draw:rectangle": `<svg ${SVG_ATTRS}><rect width="20" height="12" x="2" y="6" rx="2"/></svg>`,
+  // Square: Quadratisches Rechteck (1:1)
+  "draw:square": `<svg ${SVG_ATTRS}><rect width="18" height="18" x="3" y="3" rx="2"/></svg>`,
+  // Triangle: Gleichschenkliges Dreieck
+  "draw:triangle": `<svg ${SVG_ATTRS}><path d="m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3Z"/></svg>`,
+  // Circle: Klassischer Kreis
+  "draw:circle": `<svg ${SVG_ATTRS}><circle cx="12" cy="12" r="10"/></svg>`,
+  // Freehand: Geschwungene Signatur-Linie
+  "draw:freehand": `<svg ${SVG_ATTRS}><path d="m3 16 2 2 16-16"/><path d="M7 21h14"/><path d="M3 11c0 2 2 2 2 2z"/></svg>`,
+  // Cut: Offene Schere
+  "cut": `<svg ${SVG_ATTRS}><circle cx="6" cy="6" r="3"/><circle cx="6" cy="18" r="3"/><path d="M20 4 8.12 15.88"/><path d="M14.47 14.48 20 20"/><path d="M8.12 8.12 12 12"/></svg>`,
+  // Split: Linie, die eine Form teilt
+  "split": `<svg ${SVG_ATTRS}><path d="M3 12h18"/><path d="M8 3v18"/><path d="M16 3v18"/><rect width="18" height="18" x="3" y="3" rx="2" stroke-dasharray="4 4" opacity="0.5"/></svg>`,
+  // Union: Zwei verschmolzene Rechtecke
+  "union": `<svg ${SVG_ATTRS}><path d="M8 4H4v4"/><path d="M4 12v4a2 2 0 0 0 2 2h4"/><path d="M14 18h4v-4"/><path d="M20 10V6a2 2 0 0 0-2-2h-4"/><path d="M14 10h-4v4" stroke-dasharray="2 2"/></svg>`,
+  // Subtract: Hauptform mit "ausgeschnittenem" Bereich (Minus-Metapher)
+  "subtract": `<svg ${SVG_ATTRS}><path d="M4 4h16v16H4z"/><path d="M10 10h10v10H10z" stroke-dasharray="2 2" opacity="0.7"/><path d="M15 6h-6"/></svg>`,
+  // Drag: Vier-Wege-Pfeil (Move-Metapher)
+  "drag": `<svg ${SVG_ATTRS}><path d="m5 9-3 3 3 3"/><path d="m9 5 3-3 3 3"/><path d="m15 19 3 3 3-3"/><path d="m19 9 3 3-3 3"/><path d="M2 12h20"/><path d="M12 2v20"/></svg>`,
+  // Scale: Diagonal-Pfeile (Maximize-Metapher)
+  "scale": `<svg ${SVG_ATTRS}><path d="M15 3h6v6"/><path d="M9 21H3v-6"/><path d="M21 3 14 10"/><path d="M3 21l7-7"/></svg>`,
+  // Rotate: Kreispfeil mit Ziel-Icon
+  "rotate": `<svg ${SVG_ATTRS}><path d="M21 12a9 9 0 1 1-9-9c2.52 0 4.93 1 6.74 2.74L21 8"/><path d="M21 3v5h-5"/></svg>`,
+  // Edit: Stift, der über einen Pfad zeichnet
+  "edit": `<svg ${SVG_ATTRS}><path d="M12 20h9"/><path d="M16.5 3.5a2.12 2.12 0 0 1 3 3L7 19l-4 1 1-4Z"/></svg>`,
+  // Delete: Mülleimer mit Deckel und Schlitzen
+  "delete": `<svg ${SVG_ATTRS}><path d="M3 6h18"/><path d="M19 6v14c0 1-1 2-2 2H7c-1 0-2-1-2-2V6"/><path d="M8 6V4c0-1 1-2 2-2h4c1 0 2 1 2 2v2"/><line x1="10" x2="10" y1="11" y2="17"/><line x1="14" x2="14" y1="11" y2="17"/></svg>`,
+  // Off: Durchgestrichener Kreis (Power-Off/Disable Metapher)
+  "off": `<svg ${SVG_ATTRS}><circle cx="12" cy="12" r="10"/><path d="m15 9-6 6"/><path d="m9 9 6 6"/></svg>`
+};
+var AnvilControl = class extends L21.Control {
+  constructor(anvil, options) {
+    super(L21.Util.extend({ position: "topleft" }, options));
+    __publicField(this, "_btns", {});
+    __publicField(this, "_anvil");
+    this._anvil = anvil;
+  }
+  onAdd(map) {
+    console.log("AnvilControl: triggering onAdd");
+    const container = L21.DomUtil.create("div", "leaflet-bar anvil-toolbar");
+    container.style.backgroundColor = "white";
+    container.style.display = "flex";
+    container.style.flexDirection = "column";
+    const modes = [
+      { id: "draw:marker", title: "Marker" },
+      { id: "draw:polyline", title: "Line" },
+      { id: "draw:polygon", title: "Polygon" },
+      { id: "draw:rectangle", title: "Rectangle" },
+      { id: "draw:square", title: "Square" },
+      { id: "draw:triangle", title: "Triangle" },
+      { id: "draw:circle", title: "Circle" },
+      { id: "draw:freehand", title: "Freehand" },
+      { id: "cut", title: "Cut" },
+      { id: "split", title: "Split" },
+      { id: "union", title: "Union" },
+      { id: "subtract", title: "Subtract" },
+      { id: "drag", title: "Drag" },
+      { id: "scale", title: "Scale" },
+      { id: "rotate", title: "Rotate" },
+      { id: "edit", title: "Edit" },
+      { id: "delete", title: "Delete" },
+      { id: "off", title: "Turn Off" }
+    ];
+    modes.forEach((mode) => {
+      const btn = L21.DomUtil.create("a", "anvil-control-btn", container);
+      btn.innerHTML = ICONS[mode.id] || mode.title;
+      btn.href = "#";
+      btn.title = mode.title;
+      btn.style.display = "flex";
+      btn.style.alignItems = "center";
+      btn.style.justifyContent = "center";
+      btn.style.width = "30px";
+      btn.style.height = "30px";
+      btn.style.color = "#333";
+      btn.style.cursor = "pointer";
+      L21.DomEvent.disableClickPropagation(btn);
+      L21.DomEvent.on(btn, "click", (e) => {
+        L21.DomEvent.preventDefault(e);
+        if (mode.id === "off") {
+          this._anvil.disable();
+        } else {
+          this._anvil.enable(mode.id);
+        }
+      });
+      this._btns[mode.id] = btn;
+    });
+    const updateFn = (m) => {
+      for (const id in this._btns) {
+        const active = id === m || id === "off" && !m;
+        this._btns[id].style.backgroundColor = active ? "#eee" : "#fff";
+      }
+    };
+    updateFn(null);
+    map.on(ANVIL_EVENTS.MODE_CHANGE, (e) => updateFn(e.mode), this);
+    return container;
+  }
+};
+function anvilControl(anvil, options) {
+  return new AnvilControl(anvil, options);
+}
+
+// src/index.ts
+var leaflet = L22;
+leaflet.Anvil = Anvil;
+leaflet.anvil = (map, options) => new Anvil(map, options);
+if (leaflet.Control) {
+  leaflet.Control.Anvil = (anvil, options) => anvilControl(anvil, options);
+  leaflet.control.anvil = (anvil, options) => anvilControl(anvil, options);
+}
+export {
+  ANVIL_EVENTS,
+  Anvil,
+  AnvilControl,
+  anvilControl
+};