@element-editor/adapter-maplibre 0.0.0-stage → 0.2.1

package/dist/index.es.js

@@ -0,0 +1,3792 @@
+"use client";
+import { jsx as X, jsxs as fe, Fragment as lt } from "react/jsx-runtime";
+import { useContext as pt, createContext as Nt, useEffect as K, useState as le, useRef as $, useCallback as ve, useMemo as Bt, memo as ao, useLayoutEffect as uo, forwardRef as In, useImperativeHandle as fo } from "react";
+import { canProcessShape as _t, warnOnce as Rn, DEFAULT_FEATURE_COLOR_ON_DARK as go, createClickRepeatGuard as yo, routingError as po, CLICK_TOOL_MODES as ho, CLICK_SLOP_PX as mo, makeCircleCoords as vo, makeRectCoords as xo, isMultiGeometry as ht, getPartCount as wo, getPartGeometry as At, placeBox as Fn, commitTopoMove as on, vertexEditPatch as So, commitTopoInsert as wt, commitTopoDelete as rn, rdp as bo, withXY as Ve, setPartGeometry as Lo, insertedPosition as sn, transformUpdates as Eo, getMercatorLatCorrectionRatio as Te, unproject as Ot, project as me, offsetGeometry as $t, applyVisualTransform as Po, toRadians as Ke, mapPositions as _n, vertexEditNotice as Co, fitPadding as jt, addPickedFeature as Mo, OSM_PICK_OVERLAY_COLORS as at, unionPieces as ko, tileCandidateResult as Io, OSM_PICK_MIN_ZOOM as Ro, overpassRadiusForZoom as Fo, tileCandidates as _o, normalizeFitBoundsTarget as Ao, visibleCenterOffset as cn, loadErrorCode as ln } from "@element-editor/core/internal";
+import { useAccentPalette as To, useDataStore as he, useUIStore as W, useElementEditorConfig as ke, useGeoStore as Le, useEmit as Ue, useIsEventForEditor as zt, featureLabel as Do, ContextMenu as Ko, VertexSelectionBar as No, FeatureMapContextMenu as Bo, useAccentStyle as Oo, useTheme as An, runGeometryWorkerOperation as $o, MapControllerProvider as jo, EventProvider as zo, useAdapterControls as Ho, useKeyboardShortcuts as Vo, useApplyAccentToRoot as Xo, useReportThemeFromRoot as Yo, preloadEditorPanelsWhenIdle as Go, useSetMapController as Wo, BasemapPicker as Uo } from "@element-editor/ui";
+import { ActiveDrawingToolbar as fi, EditingToolbar as gi, ElementEditorUIProvider as yi, FloatingToolbar as pi, GeoStoreProvider as hi, MapControllerProvider as mi, StoreContext as vi, useDataStore as xi, useGeoStore as wi, useKeyboardShortcuts as Si, useMapController as bi, useSetMapController as Li, useUIStore as Ei } from "@element-editor/ui";
+import { useOptionalEmit as Tn, useRouting as Zo, applyRootTokens as qo, useContextMenu as Jo } from "@element-editor/ui/internal";
+import { readAccentPalette as Dn, DEFAULT_FEATURE_COLOR as Kn, fetchRoute as an, getGeometryBBox as Nn, formatLength as mt, formatArea as Ht, fetchOverpassFeatures as Qo, overpassErrorMessage as er, OverpassError as tr, readStorage as nr, writeStorage as or, ElementEditorError as Tt } from "@element-editor/core";
+import { ElementEditorError as Ci } from "@element-editor/core";
+import * as De from "maplibre-gl";
+import { Crosshair as rr, Trash as sr } from "@phosphor-icons/react";
+import { createPortal as Ze } from "react-dom";
+import { transformRotate as ir } from "@turf/transform-rotate";
+import { featureCollection as cr, lineString as We, polygon as ut } from "@turf/helpers";
+import { bbox as Bn } from "@turf/bbox";
+import lr from "@turf/boolean-intersects";
+import { length as _e } from "@turf/length";
+import { area as dt } from "@turf/area";
+import { g as ar, r as ur } from "./basemapIds-CVTxeXkr.js";
+import { distance as Pe } from "@turf/distance";
+function Ie() {
+  return { type: "FeatureCollection", features: [] };
+}
+const dr = "elm-features", On = /* @__PURE__ */ new WeakMap();
+function fr(e, t, n) {
+  On.set(e, { features: t, uniqueIds: n });
+}
+function Vt(e, t) {
+  const n = e.getSource(dr), o = On.get(e);
+  if (!(!n || !o || t.size === 0))
+    try {
+      if (o.uniqueIds) {
+        const i = [];
+        let l = !0;
+        for (const [u, c] of t)
+          if (c.type === "GeometryCollection") {
+            if (c.geometries.length !== 1) {
+              l = !1;
+              break;
+            }
+            i.push({ id: u, newGeometry: c.geometries[0] });
+          } else
+            i.push({ id: u, newGeometry: c });
+        if (l) {
+          n.updateData({ update: i });
+          return;
+        }
+      }
+      const r = /* @__PURE__ */ new Map(), s = o.features.map((i) => {
+        var c;
+        const l = (c = i.properties) == null ? void 0 : c.id, u = t.get(l);
+        if (!u) return i;
+        if (u.type === "GeometryCollection") {
+          const v = r.get(l) ?? 0;
+          r.set(l, v + 1);
+          const d = u.geometries[v];
+          return d ? { ...i, geometry: d } : i;
+        }
+        return { ...i, geometry: u };
+      });
+      n.setData({ type: "FeatureCollection", features: s });
+    } catch {
+    }
+}
+const $n = Nt(void 0);
+function gr({
+  getFeatureStyle: e,
+  children: t
+}) {
+  return /* @__PURE__ */ X($n.Provider, { value: e, children: t });
+}
+function yr() {
+  return pt($n);
+}
+function pr(e) {
+  let t, n, o;
+  const r = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(e.trim());
+  if (r) {
+    const i = r[1].length === 3 ? r[1].replace(/./g, (l) => l + l) : r[1];
+    t = parseInt(i.slice(0, 2), 16), n = parseInt(i.slice(2, 4), 16), o = parseInt(i.slice(4, 6), 16);
+  } else {
+    const i = /^rgba?\(\s*([\d.]+)[\s,]+([\d.]+)[\s,]+([\d.]+)/i.exec(e.trim());
+    if (!i) return null;
+    t = +i[1], n = +i[2], o = +i[3];
+  }
+  const s = (i) => {
+    const l = i / 255;
+    return l <= 0.03928 ? l / 12.92 : ((l + 0.055) / 1.055) ** 2.4;
+  };
+  return 0.2126 * s(t) + 0.7152 * s(n) + 0.0722 * s(o);
+}
+function un(e) {
+  var t, n, o;
+  try {
+    const r = (n = (t = e.getStyle()) == null ? void 0 : t.layers) == null ? void 0 : n.find((l) => l.type === "background"), s = (o = r == null ? void 0 : r.paint) == null ? void 0 : o["background-color"];
+    if (typeof s != "string") return !1;
+    const i = pr(s);
+    return i !== null && i < 0.18;
+  } catch {
+    return !1;
+  }
+}
+const jn = Nt(0), vt = () => pt(jn);
+function Ne(e, t, n = Dn(e.getContainer())) {
+  for (const [o, r, s] of t)
+    e.getLayer(o) && e.setPaintProperty(o, r, s(n));
+}
+function qe(e, t) {
+  const n = To(e.getContainer());
+  return K(() => {
+    Ne(e, t, n);
+  }, [e, t, n]), n;
+}
+const ge = "elm-features", Xt = "elm-features-line-hit", hr = 16, ft = ["boolean", ["feature-state", "hovered"], !1], mr = ["boolean", ["feature-state", "fresh"], !1], St = (e, t, n) => [
+  "case",
+  ["boolean", ["feature-state", "selected"], !1],
+  e,
+  ["coalesce", ...t, ["case", ft, n.hover, n.color]]
+], dn = [["get", "_fillColor"], ["get", "_color"]], vr = { color: Kn, hover: "#64748b", casing: "rgba(255, 255, 255, 0.7)" }, xr = { color: go, hover: "#cbd5e1", casing: "rgba(15, 23, 42, 0.5)" }, zn = (e) => [
+  ["elm-features-fill", "fill-color", (t) => St(t[500], dn, e)],
+  ["elm-features-line-casing", "line-color", () => e.casing],
+  ["elm-features-line", "line-color", (t) => St(t[500], [["get", "_color"]], e)],
+  // A fresh point: one accent step darker instead of a snap ring on it.
+  ["elm-features-point", "circle-color", (t) => ["case", mr, t[600], St(t[500], dn, e)]]
+], Hn = zn(vr), wr = zn(xr), Yt = ["in", ["geometry-type"], ["literal", ["LineString", "MultiLineString"]]], fn = ["coalesce", ["get", "_weight"], ["case", Yt, 3.5, 1.8]], gn = [
+  "case",
+  ["boolean", ["feature-state", "selected"], !1],
+  ["case", Yt, 4, 2.5],
+  ft,
+  ["+", fn, 0.7],
+  fn
+], Sr = 1.5;
+function br(e) {
+  e.getSource(ge) || (e.addSource(ge, {
+    type: "geojson",
+    data: Ie(),
+    promoteId: "id"
+    // use each feature's `id` property as the MapLibre feature ID
+  }), e.addLayer({
+    id: "elm-features-fill",
+    type: "fill",
+    source: ge,
+    filter: ["in", ["geometry-type"], ["literal", ["Polygon", "MultiPolygon"]]],
+    paint: {
+      "fill-opacity": [
+        "case",
+        ["boolean", ["feature-state", "selected"], !1],
+        0.28,
+        ft,
+        ["max", ["coalesce", ["get", "_fillOpacity"], 0.13], 0.22],
+        ["coalesce", ["get", "_fillOpacity"], 0.13]
+      ]
+    }
+  }), e.addLayer({
+    id: "elm-features-line-casing",
+    type: "line",
+    source: ge,
+    filter: Yt,
+    paint: {
+      "line-width": ["+", gn, 2 * Sr],
+      "line-opacity": ["coalesce", ["get", "_opacity"], 1]
+    }
+  }), e.addLayer({
+    id: "elm-features-line",
+    type: "line",
+    source: ge,
+    filter: [
+      "in",
+      ["geometry-type"],
+      ["literal", ["LineString", "MultiLineString", "Polygon", "MultiPolygon"]]
+    ],
+    paint: {
+      "line-width": gn,
+      "line-opacity": ["coalesce", ["get", "_opacity"], 1]
+    }
+  }), e.addLayer({
+    id: Xt,
+    type: "line",
+    source: ge,
+    filter: ["in", ["geometry-type"], ["literal", ["LineString", "MultiLineString"]]],
+    paint: { "line-width": hr, "line-color": "#000", "line-opacity": 0 }
+  }), e.addLayer({
+    id: "elm-features-point",
+    type: "circle",
+    source: ge,
+    filter: [
+      "all",
+      ["in", ["geometry-type"], ["literal", ["Point", "MultiPoint"]]],
+      ["!=", ["get", "_isText"], "true"]
+    ],
+    paint: {
+      "circle-radius": [
+        "case",
+        ["boolean", ["feature-state", "selected"], !1],
+        10,
+        ft,
+        9,
+        8
+      ],
+      "circle-opacity": ["coalesce", ["get", "_fillOpacity"], 1],
+      "circle-stroke-width": 2,
+      "circle-stroke-color": "#ffffff"
+    }
+  }), e.getGlyphs() ? e.addLayer({
+    id: "elm-features-text",
+    type: "symbol",
+    source: ge,
+    filter: ["==", ["get", "_isText"], "true"],
+    layout: {
+      "text-field": ["get", "name"],
+      // OpenFreeMap's glyph server only has Noto Sans (Open Sans 404s), see basemaps/index.ts.
+      "text-font": ["Noto Sans Regular"],
+      "text-size": 14,
+      "text-allow-overlap": !0
+    },
+    paint: {
+      "text-color": "#ffffff",
+      "text-halo-color": Kn,
+      "text-halo-width": 2
+    }
+  }) : Rn("maplibre-no-glyphs", 'The map style has no `glyphs`, so Element can\'t show text features. Use a style with glyphs that serve "Noto Sans Regular".'), Ne(e, Hn));
+}
+function Lr(e) {
+  for (const t of ["elm-features-text", "elm-features-point", Xt, "elm-features-line", "elm-features-line-casing", "elm-features-fill"])
+    e.getLayer(t) && e.removeLayer(t);
+  e.getSource(ge) && e.removeSource(ge);
+}
+const Be = ["elm-features-fill", "elm-features-line", Xt, "elm-features-point"];
+function Er({ map: e }) {
+  const t = he((_) => _.features), n = he((_) => _.groups), o = he((_) => _.selectedIds), r = W((_) => _.editingMode), s = W((_) => _.geometryPreview !== null), i = W((_) => _.bufferCreateNew), l = yr(), u = ke().featureColor, c = vt(), [v, d] = le(() => un(e));
+  K(() => {
+    const _ = () => d(un(e));
+    return _(), e.on("styledata", _), () => {
+      e.off("styledata", _);
+    };
+  }, [e, c]);
+  const g = v ? wr : Hn, w = qe(e, g);
+  K(() => {
+    Ne(e, g, w);
+  }, [c]);
+  const C = Tn(), T = $(!1);
+  K(() => {
+    T.current || e.getGlyphs() || (T.current = !0, C == null || C({
+      type: "error",
+      code: "unsupported",
+      source: "basemap",
+      quiet: !0,
+      message: 'The map style has no glyphs, so text features are not shown. Use a style whose glyphs serve "Noto Sans Regular".'
+    }));
+  }, [e, c, C]);
+  const k = s && (r === "simplify-shape" || r === "smooth-shape" || r === "buffer-shape" && !i) ? o : null;
+  K(() => {
+    const _ = e.getSource(ge);
+    if (!_) return;
+    const D = new Set(n.filter((M) => M.hidden).map((M) => M.id)), q = k ? new Set(k) : null, p = t.filter((M) => !(M.hidden || M.groupId && D.has(M.groupId) || q != null && q.has(M.id) && _t(M.geometry.type))), f = [];
+    let b = !0;
+    for (const M of p) {
+      const { _validation: A, ...E } = M, a = l == null ? void 0 : l(M), x = {}, y = (a == null ? void 0 : a.color) ?? u;
+      if (y !== void 0 && (x._color = y), a && (a.fillColor !== void 0 && (x._fillColor = a.fillColor), a.opacity !== void 0 && (x._opacity = a.opacity), a.fillOpacity !== void 0 && (x._fillOpacity = a.fillOpacity), a.weight !== void 0 && (x._weight = a.weight)), M.geometry.type === "GeometryCollection") {
+        M.geometry.geometries.length > 1 && (b = !1);
+        for (const m of M.geometry.geometries)
+          f.push({
+            ...E,
+            geometry: m,
+            properties: { ...E.properties, ...x, id: M.id }
+          });
+      } else
+        f.push({
+          ...E,
+          properties: { ...E.properties, ...x, id: M.id }
+        });
+    }
+    _.setData({ type: "FeatureCollection", features: f }), fr(e, f, b);
+  }, [t, n, e, k, l, u, c]);
+  const N = $(/* @__PURE__ */ new Set()), P = $(c);
+  return K(() => {
+    if (!e.getSource(ge)) return;
+    P.current !== c && (P.current = c, N.current = /* @__PURE__ */ new Set());
+    const _ = N.current, D = new Set(o);
+    for (const q of _)
+      D.has(q) || e.setFeatureState({ source: ge, id: q }, { selected: !1 });
+    for (const q of D)
+      _.has(q) || e.setFeatureState({ source: ge, id: q }, { selected: !0 });
+    N.current = D;
+  }, [o, e, c]), null;
+}
+function bt(e, t, n) {
+  e.getSource(ge) && (n && e.setFeatureState({ source: ge, id: n }, { hovered: !1 }), t && e.setFeatureState({ source: ge, id: t }, { hovered: !0 }));
+}
+function Vn(e, t, n, o, r = 15, s = /* @__PURE__ */ new Set()) {
+  const i = n.project([e, t]), l = i.x, u = i.y;
+  let c = 1 / 0, v = null, d = null, g = 1 / 0, w = 0, C = 0, T = !1, F = null;
+  const k = r + 1;
+  let N = 1 / 0, P = -1 / 0, _ = 1 / 0, D = -1 / 0;
+  for (const [b, M] of [[l - k, u - k], [l + k, u - k], [l - k, u + k], [l + k, u + k]]) {
+    const A = n.unproject([b, M]);
+    A.lng < N && (N = A.lng), A.lng > P && (P = A.lng), A.lat < _ && (_ = A.lat), A.lat > D && (D = A.lat);
+  }
+  let q = "";
+  function p(b, M = !0) {
+    if (!b || b.length === 0) return;
+    let A = -1, E = 0, a = 0;
+    for (let x = 0; x < b.length; x++) {
+      const y = b[x];
+      if (!(y[0] < N || y[0] > P || y[1] < _ || y[1] > D)) {
+        if (A !== x) {
+          const R = n.project(y);
+          E = R.x, a = R.y, A = x;
+        }
+        const m = Math.hypot(l - E, u - a);
+        m < c && (c = m, v = y, d = q);
+      }
+      if (M && x < b.length - 1) {
+        const m = b[x + 1];
+        if (y[0] < N && m[0] < N || y[0] > P && m[0] > P || y[1] < _ && m[1] < _ || y[1] > D && m[1] > D) continue;
+        if (A !== x) {
+          const I = n.project(y);
+          E = I.x, a = I.y;
+        }
+        const R = E, S = a, L = n.project(m);
+        A = x + 1, E = L.x, a = L.y;
+        const B = (R - L.x) ** 2 + (S - L.y) ** 2;
+        let V = R, j = S;
+        if (B !== 0) {
+          let I = ((l - R) * (L.x - R) + (u - S) * (L.y - S)) / B;
+          I = Math.max(0, Math.min(1, I)), V = R + I * (L.x - R), j = S + I * (L.y - S);
+        }
+        const h = Math.hypot(l - V, u - j);
+        h < g && (g = h, w = V, C = j, T = !0, F = q);
+      }
+    }
+  }
+  function f(b) {
+    switch (b.type) {
+      case "Point":
+        p([b.coordinates]);
+        break;
+      case "MultiPoint":
+        p(b.coordinates, !1);
+        break;
+      case "LineString":
+        p(b.coordinates);
+        break;
+      case "Polygon":
+      case "MultiLineString":
+        for (const M of b.coordinates) p(M);
+        break;
+      case "MultiPolygon":
+        for (const M of b.coordinates)
+          for (const A of M) p(A);
+        break;
+      case "GeometryCollection":
+        for (const M of b.geometries) f(M);
+        break;
+    }
+  }
+  for (const b of o)
+    if (!s.has(b.id)) {
+      if (b.bbox) {
+        const [M, A, E, a] = b.bbox;
+        if (E < N || M > P || a < _ || A > D) continue;
+      }
+      q = b.id, f(b.geometry);
+    }
+  if (c <= r && v)
+    return {
+      lnglat: v,
+      isVertex: !0,
+      featureId: d ?? void 0
+    };
+  if (g <= r && T) {
+    const b = n.unproject([w, C]);
+    return {
+      lnglat: [b.lng, b.lat],
+      isVertex: !1,
+      featureId: F ?? void 0
+    };
+  }
+  return null;
+}
+function Dt(e, t, n, o = 15) {
+  const r = e.project(t), s = e.project(n), i = s.x - r.x, l = s.y - r.y, u = Math.hypot(i, l);
+  if (u < 1) return n;
+  const c = Math.atan2(l, i), v = o * Math.PI / 180, d = Math.round(c / v) * v, g = r.x + u * Math.cos(d), w = r.y + u * Math.sin(d), C = e.unproject([g, w]);
+  return [C.lng, C.lat];
+}
+let Kt = !1;
+function Pr() {
+  Kt = !0, Promise.resolve().then(() => {
+    Kt = !1;
+  });
+}
+function Cr() {
+  return Kt;
+}
+let Xn = 0;
+function Mr() {
+  Xn = Date.now();
+}
+function kr() {
+  return Date.now() - Xn < 200;
+}
+let Yn = 0;
+function Lt() {
+  Yn = Date.now();
+}
+function Gn() {
+  return Date.now() - Yn < 200;
+}
+const Ge = (e) => e !== "none" ? "crosshair" : "", Ir = 3, yn = 5;
+function Rr({ map: e, routingApiKey: t }) {
+  const { uiStore: n, dataStore: o } = Le(), r = Zo(t), s = ke().network.fetch, i = $(null);
+  i.current = r === !1 ? null : { ...r, fetch: s };
+  const l = Ue(), u = zt(), c = W((p) => p.editingMode), v = W((p) => p.cancelDrawing), d = W((p) => p.routeWaypoints), g = $(d);
+  K(() => {
+    g.current = d;
+  }, [d]);
+  const w = $(null), C = $(null), T = $(null), F = $(!1), k = $(!1), N = $(!1), P = $(null), _ = $(yo()).current, D = $(!1), q = ve(
+    async (p) => {
+      if (!(p.length < 2)) {
+        n.getState().setRoutePreview(null, !0);
+        try {
+          if (!i.current) throw new Error("routing is off");
+          const f = await an(p, i.current);
+          g.current.length >= 2 && n.getState().setRoutePreview(f, !1);
+        } catch (f) {
+          const b = po(f);
+          l({ type: "error", code: b.code, source: "routing", message: b.message, error: b }), n.getState().setRoutePreview(p, !1);
+        }
+      }
+    },
+    [n, l]
+  );
+  return K(() => {
+    const p = e.getCanvas();
+    function f() {
+      D.current || (D.current = !0, e.dragPan.enable(), p.style.cursor = "grab");
+    }
+    function b() {
+      if (!D.current) return;
+      D.current = !1;
+      const y = n.getState().editingMode;
+      p.style.cursor = Ge(y), (y === "draw-rect" || y === "draw-circle" || y === "draw-freehand") && e.dragPan.disable();
+    }
+    const M = (y) => {
+      if (y.key === "Shift" && (k.current = !0), !!u(y)) {
+        if (y.code === "Space") {
+          const m = y.target;
+          if (m && (m.tagName === "INPUT" || m.tagName === "TEXTAREA" || m.isContentEditable)) return;
+          y.preventDefault(), n.getState().editingMode !== "none" && f();
+          return;
+        }
+        if (y.key === "Escape") {
+          const { selectedMeasurementId: m, setSelectedMeasurementId: R } = n.getState();
+          if (m) {
+            R(null);
+            return;
+          }
+          v();
+          return;
+        }
+        if (y.key === "Enter") {
+          const m = n.getState();
+          if (m.editingMode === "measure") {
+            m.completeMeasure();
+            return;
+          }
+        }
+        if (y.key === "Backspace" || y.key === "Delete") {
+          const m = n.getState();
+          if (m.selectedMeasurementId) {
+            m.removeMeasurement(m.selectedMeasurementId);
+            return;
+          }
+          const R = m.editingMode;
+          if (R === "measure") {
+            m.removeLastMeasurePoint();
+            return;
+          }
+          if (R === "draw-line" || R === "slice-shape") {
+            m.removeLastLineVertex();
+            return;
+          }
+          if (R === "draw-polygon" || R === "cut-hole") {
+            m.removeLastPolygonVertex();
+            return;
+          }
+          if (R === "draw-route") {
+            m.removeLastRouteWaypoint();
+            return;
+          }
+        }
+      }
+    }, A = (y) => {
+      if (y.code === "Space") {
+        b();
+        return;
+      }
+      y.key === "Shift" && (k.current = !1);
+    }, E = () => b(), a = () => {
+      p.style.cursor = "grabbing";
+    }, x = () => {
+      p.style.cursor = D.current ? "grab" : Ge(n.getState().editingMode);
+    };
+    return window.addEventListener("keydown", M), window.addEventListener("keyup", A), window.addEventListener("blur", E), e.on("dragstart", a), e.on("dragend", x), () => {
+      window.removeEventListener("keydown", M), window.removeEventListener("keyup", A), window.removeEventListener("blur", E), e.off("dragstart", a), e.off("dragend", x);
+    };
+  }, [v, n, e, u]), K(() => {
+    e.getCanvas().style.cursor = Ge(c);
+  }, [c, e]), K(() => {
+    c === "draw-freehand" ? e.dragPan.disable() : (e.dragPan.enable(), F.current = !1);
+  }, [c, e]), K(() => (c !== "none" ? e.doubleClickZoom.disable() : e.doubleClickZoom.enable(), () => {
+    e.doubleClickZoom.enable();
+  }), [c, e]), K(() => {
+    var A;
+    if (!ho.includes(c)) return;
+    const p = e, f = (A = p.handlers ?? p._handlerManager) == null ? void 0 : A._handlersById, b = [f == null ? void 0 : f.mapEvent, f == null ? void 0 : f.mousePan].filter((E) => typeof (E == null ? void 0 : E._clickTolerance) == "number"), M = b.map((E) => E._clickTolerance);
+    for (const E of b) E._clickTolerance = mo;
+    return () => b.forEach((E, a) => {
+      E._clickTolerance = M[a];
+    });
+  }, [c, e]), K(() => (c !== "none" ? e.boxZoom.disable() : e.boxZoom.enable(), () => {
+    e.boxZoom.enable();
+  }), [c, e]), K(() => () => {
+    C.current && clearTimeout(C.current), T.current && T.current.abort();
+  }, []), K(() => {
+    const p = (a) => a.metaKey || a.ctrlKey || a.altKey, f = (a) => {
+      if (!p(a.originalEvent) && !D.current) {
+        if (c === "draw-freehand") {
+          F.current = !0, n.getState().clearFreehandPoints(), n.getState().addFreehandPoint([a.lngLat.lng, a.lngLat.lat]);
+          return;
+        }
+        if (c === "draw-rect") {
+          e.dragPan.disable(), o.getState().selectedIds.length > 0 && o.setState({ selectedIds: [] });
+          const x = n.getState().snappedCoord ?? [a.lngLat.lng, a.lngLat.lat];
+          n.getState().setRectCorner(x), N.current = !0, P.current = { x: a.point.x, y: a.point.y };
+          return;
+        }
+        if (c === "draw-circle") {
+          e.dragPan.disable(), o.getState().selectedIds.length > 0 && o.setState({ selectedIds: [] });
+          const x = n.getState().snappedCoord ?? [a.lngLat.lng, a.lngLat.lat];
+          n.getState().setCircleCenter(x), N.current = !0, P.current = { x: a.point.x, y: a.point.y };
+          return;
+        }
+      }
+    }, b = (a) => {
+      if (c === "draw-freehand" && F.current) {
+        F.current = !1;
+        const R = e.getZoom(), S = 156543.03392 * Math.cos(a.lngLat.lat * Math.PI / 180) / Math.pow(2, R), L = Ir * S / 111320;
+        n.getState().commitFreehand(L), Lt();
+        return;
+      }
+      if (!N.current) return;
+      N.current = !1, e.dragPan.enable();
+      const x = P.current, y = x ? Math.hypot(a.point.x - x.x, a.point.y - x.y) : 0;
+      P.current = null;
+      const m = n.getState();
+      if (c === "draw-rect") {
+        const R = m.rectCorner;
+        if (!R) return;
+        if (y < yn) {
+          n.setState({ rectCorner: null });
+          return;
+        }
+        const S = m.snappedCoord ?? [a.lngLat.lng, a.lngLat.lat], L = k.current || a.originalEvent.shiftKey;
+        m.commitRect(R, S, {}, L), Lt();
+        return;
+      }
+      if (c === "draw-circle") {
+        const R = m.circleCenter;
+        if (!R) return;
+        let S;
+        if (y < yn) {
+          const V = e.unproject([a.point.x + 25, a.point.y]);
+          S = [V.lng, V.lat];
+        } else
+          S = m.snappedCoord ?? [a.lngLat.lng, a.lngLat.lat];
+        const L = S[0] - R[0], B = S[1] - R[1];
+        Math.hypot(L, B) >= 1e-6 && (m.commitCircle(R, S, {}), Lt());
+        return;
+      }
+    }, M = (a) => {
+      const x = n.getState();
+      if (c === "draw-freehand" && F.current) {
+        x.addFreehandPoint([a.lngLat.lng, a.lngLat.lat]);
+        return;
+      }
+      if (c === "draw-route" && g.current.length > 0) {
+        const y = [a.lngLat.lng, a.lngLat.lat];
+        x.setRouteCursorPos(y), x.setRouteCursorPreview(null), C.current && clearTimeout(C.current), T.current && T.current.abort();
+        const m = g.current[g.current.length - 1];
+        C.current = setTimeout(async () => {
+          const R = new AbortController();
+          T.current = R;
+          try {
+            if (!i.current) return;
+            const S = await an([m, y], { ...i.current, signal: R.signal });
+            R.signal.aborted || n.getState().setRouteCursorPreview(S);
+          } catch {
+          }
+        }, 400);
+      }
+      if ((c === "draw-polygon" || c === "cut-hole") && x.polygonInProgress.length >= 3) {
+        const y = x.polygonInProgress[0], m = e.project(y), R = Math.hypot(a.point.x - m.x, a.point.y - m.y);
+        e.getCanvas().style.cursor = R <= 48 ? "pointer" : "crosshair";
+      }
+    }, A = (a) => {
+      const x = _.click(a.originalEvent);
+      if (p(a.originalEvent) || kr() || D.current || Gn()) return;
+      const y = n.getState();
+      if (c === "measure") {
+        if (x || Cr()) return;
+        y.selectedMeasurementId && y.setSelectedMeasurementId(null);
+        const S = y.snappedCoord ?? [a.lngLat.lng, a.lngLat.lat];
+        y.addMeasurePoint(S);
+        return;
+      }
+      ["place-point", "draw-line", "draw-polygon", "draw-route", "draw-circle", "draw-rect"].includes(c) && o.getState().selectedIds.length > 0 && o.setState({ selectedIds: [] });
+      const R = y.snappedCoord ?? [a.lngLat.lng, a.lngLat.lat];
+      if (c === "place-point") {
+        if (x) return;
+        y.commitPoint(R);
+        return;
+      }
+      if (c === "draw-line" || c === "draw-polygon" || c === "draw-route" || c === "cut-hole" || c === "slice-shape") {
+        let S = R;
+        if (k.current || a.originalEvent.shiftKey) {
+          const L = c === "draw-line" || c === "slice-shape" ? y.lineInProgress : y.polygonInProgress;
+          L.length >= 1 && (S = Dt(e, L[L.length - 1], S));
+        }
+        if ((c === "draw-polygon" || c === "cut-hole") && y.polygonInProgress.length >= 2) {
+          const L = y.polygonInProgress[0], B = e.project(L);
+          if (Math.hypot(a.point.x - B.x, a.point.y - B.y) <= 48) {
+            c === "draw-polygon" ? y.commitPolygon({}) : y.commitCutHole();
+            return;
+          }
+        }
+        if (x) return;
+        if (c === "draw-line" || c === "slice-shape") y.addLineVertex(S);
+        else if (c === "draw-polygon" || c === "cut-hole") y.addPolygonVertex(S);
+        else if (c === "draw-route") {
+          w.current = { waypoints: [...g.current], preview: y.routePreview }, C.current && (clearTimeout(C.current), C.current = null), T.current && (T.current.abort(), T.current = null), y.setRouteCursorPos(null), y.setRouteCursorPreview(null), y.addRouteWaypoint(S);
+          const L = [...g.current, S];
+          q(L);
+        }
+        return;
+      }
+    }, E = () => {
+      if (!_.isDouble()) return;
+      const a = n.getState();
+      if (c === "measure") {
+        a.completeMeasure();
+        return;
+      }
+      c === "draw-line" ? a.commitLine({}) : c === "draw-polygon" ? a.commitPolygon({}) : c === "cut-hole" ? a.commitCutHole() : c === "slice-shape" ? a.commitSliceShape() : c === "draw-route" && (w.current && (n.setState({
+        routeWaypoints: w.current.waypoints,
+        routePreview: w.current.preview,
+        routeLoading: !1
+      }), w.current = null), a.commitRoute());
+    };
+    return e.on("mousedown", f), e.on("mouseup", b), e.on("mousemove", M), e.on("click", A), e.on("dblclick", E), () => {
+      e.off("mousedown", f), e.off("mouseup", b), e.off("mousemove", M), e.off("click", A), e.off("dblclick", E);
+    };
+  }, [c, e, q, n, o]), null;
+}
+function pn(e) {
+  var t, n;
+  return `${e.editingMode}|${e.lineInProgress.length}|${e.polygonInProgress.length}|${e.circleCenter}|${e.rectCorner}|${e.routeWaypoints.length}|${((t = e.routePreview) == null ? void 0 : t.length) ?? 0}|${((n = e.routeCursorPreview) == null ? void 0 : n.length) ?? 0}|${e.freehandPoints.length}`;
+}
+const Se = "elm-preview", Wn = [
+  ["elm-preview-fill", "fill-color", (e) => e[500]],
+  ["elm-preview-line", "line-color", (e) => e[500]],
+  ["elm-preview-vertex", "circle-color", (e) => e[500]]
+];
+function Fr(e) {
+  e.getSource(Se) || (e.addSource(Se, { type: "geojson", data: Ie() }), e.addLayer({
+    id: "elm-preview-fill",
+    type: "fill",
+    source: Se,
+    filter: ["==", ["geometry-type"], "Polygon"],
+    paint: { "fill-opacity": 0.13 }
+  }), e.addLayer({
+    id: "elm-preview-line",
+    type: "line",
+    source: Se,
+    filter: ["in", ["geometry-type"], ["literal", ["LineString", "Polygon"]]],
+    paint: { "line-width": 2, "line-dasharray": [4, 3] }
+  }), e.addLayer({
+    id: "elm-preview-vertex",
+    type: "circle",
+    source: Se,
+    filter: ["all", ["==", ["geometry-type"], "Point"], ["!=", ["get", "_isFirst"], !0]],
+    paint: {
+      "circle-radius": 5,
+      "circle-stroke-width": 2,
+      "circle-stroke-color": "#ffffff"
+    }
+  }), e.addLayer({
+    id: "elm-preview-first-vertex",
+    type: "circle",
+    source: Se,
+    filter: ["==", ["get", "_isFirst"], !0],
+    paint: {
+      "circle-radius": 7,
+      "circle-color": "#22c55e",
+      "circle-stroke-width": 2,
+      "circle-stroke-color": "#ffffff"
+    }
+  }), Ne(e, Wn));
+}
+function _r(e) {
+  for (const t of ["elm-preview-first-vertex", "elm-preview-vertex", "elm-preview-line", "elm-preview-fill"])
+    e.getLayer(t) && e.removeLayer(t);
+  e.getSource(Se) && e.removeSource(Se);
+}
+function Fe(e, t) {
+  const n = e.getSource(Se);
+  n && n.setData({ type: "FeatureCollection", features: t });
+}
+function Ar({ map: e }) {
+  qe(e, Wn);
+  const { uiStore: t, dataStore: n } = Le(), o = W((c) => c.editingMode), r = he((c) => c.geometryMode), s = $(r);
+  K(() => {
+    s.current = r;
+  }, [r]);
+  const i = $(null), l = $(!1);
+  K(() => {
+    const c = (g) => {
+      i.current = [g.lngLat.lng, g.lngLat.lat], u();
+    }, v = (g) => {
+      g.key === "Shift" && (l.current = !0);
+    }, d = (g) => {
+      g.key === "Shift" && (l.current = !1);
+    };
+    return e.on("mousemove", c), window.addEventListener("keydown", v), window.addEventListener("keyup", d), () => {
+      e.off("mousemove", c), window.removeEventListener("keydown", v), window.removeEventListener("keyup", d);
+    };
+  }, [e]), K(() => {
+    let c = pn(t.getState());
+    return t.subscribe((d) => {
+      const g = pn(d);
+      g !== c && (c = g, u());
+    });
+  }, [t]), K(() => {
+    i.current = null, o === "none" && Fe(e, []);
+  }, [o, e]);
+  function u() {
+    const c = t.getState(), v = i.current, d = [];
+    if (c.editingMode === "draw-line" || c.editingMode === "slice-shape") {
+      const g = c.lineInProgress;
+      if (g.length === 0) return Fe(e, []);
+      let w = v ?? g[g.length - 1];
+      l.current && g.length >= 1 && (w = Dt(e, g[g.length - 1], w));
+      const C = [...g, w];
+      d.push({ type: "Feature", properties: {}, geometry: { type: "LineString", coordinates: C } }), g.forEach((T, F) => {
+        d.push({ type: "Feature", properties: { _isFirst: F === 0 }, geometry: { type: "Point", coordinates: T } });
+      });
+    }
+    if (c.editingMode === "draw-polygon" || c.editingMode === "cut-hole") {
+      const g = c.polygonInProgress;
+      if (g.length === 0) return Fe(e, []);
+      let w = v ?? g[g.length - 1];
+      l.current && g.length >= 1 && (w = Dt(e, g[g.length - 1], w));
+      const C = [...g, w, g[0]];
+      g.length >= 2 ? d.push({ type: "Feature", properties: {}, geometry: { type: "Polygon", coordinates: [C] } }) : d.push({ type: "Feature", properties: {}, geometry: { type: "LineString", coordinates: C } }), g.forEach((T, F) => {
+        d.push({ type: "Feature", properties: { _isFirst: F === 0 }, geometry: { type: "Point", coordinates: T } });
+      });
+    }
+    if (c.editingMode === "draw-circle") {
+      const g = c.circleCenter;
+      if (!g) return Fe(e, []);
+      const w = v ?? g, C = vo(g, w, s.current, 64);
+      d.push({ type: "Feature", properties: {}, geometry: { type: "Polygon", coordinates: [C] } }), d.push({ type: "Feature", properties: { _isFirst: !0 }, geometry: { type: "Point", coordinates: g } }), d.push({ type: "Feature", properties: {}, geometry: { type: "Point", coordinates: w } });
+    }
+    if (c.editingMode === "draw-rect") {
+      const g = c.rectCorner;
+      if (!g) return Fe(e, []);
+      const C = xo(g, v ?? g, s.current, l.current);
+      d.push({ type: "Feature", properties: {}, geometry: { type: "Polygon", coordinates: [C] } });
+    }
+    if (c.editingMode === "draw-route") {
+      const g = c.routeWaypoints;
+      if (g.length === 0) return Fe(e, []);
+      const w = c.routePreview ?? g;
+      w.length >= 2 && d.push({ type: "Feature", properties: {}, geometry: { type: "LineString", coordinates: w } });
+      const C = c.routeCursorPreview ?? (v ? [g[g.length - 1], v] : null);
+      C && C.length >= 2 && d.push({ type: "Feature", properties: {}, geometry: { type: "LineString", coordinates: C } }), g.forEach((T, F) => {
+        d.push({ type: "Feature", properties: { _isFirst: F === 0 }, geometry: { type: "Point", coordinates: T } });
+      });
+    }
+    if (c.editingMode === "draw-freehand") {
+      const g = c.freehandPoints;
+      g.length >= 2 && d.push({ type: "Feature", properties: {}, geometry: { type: "LineString", coordinates: g } });
+    }
+    Fe(e, d);
+  }
+  return null;
+}
+function hn(e, t) {
+  const [n, o] = e;
+  let r = !1;
+  for (let s = 0, i = t.length - 1; s < t.length; i = s++) {
+    const [l, u] = t[s], [c, v] = t[i];
+    u > o != v > o && n < (c - l) * (o - u) / (v - u + 1e-20) + l && (r = !r);
+  }
+  return r;
+}
+function mn(e, t) {
+  if (t.length === 0 || !hn(e, t[0])) return !1;
+  for (let n = 1; n < t.length; n++)
+    if (hn(e, t[n])) return !1;
+  return !0;
+}
+function Tr(e, t, n) {
+  const o = n[0] - t[0], r = n[1] - t[1];
+  if (o === 0 && r === 0) {
+    const v = e[0] - t[0], d = e[1] - t[1];
+    return v * v + d * d;
+  }
+  const s = Math.max(0, Math.min(1, ((e[0] - t[0]) * o + (e[1] - t[1]) * r) / (o * o + r * r))), i = t[0] + s * o, l = t[1] + s * r, u = e[0] - i, c = e[1] - l;
+  return u * u + c * c;
+}
+function tt(e, t) {
+  let n = 1 / 0;
+  for (let o = 0; o < t.length - 1; o++) {
+    const r = Tr(e, t[o], t[o + 1]);
+    r < n && (n = r);
+  }
+  return n;
+}
+function Dr(e, t) {
+  if (!ht(e)) return null;
+  const n = wo(e);
+  if (n === 0) return null;
+  if (e.type === "MultiPolygon") {
+    for (let s = 0; s < n; s++)
+      if (mn(t, e.coordinates[s]))
+        return s;
+    let o = 0, r = 1 / 0;
+    for (let s = 0; s < n; s++) {
+      const i = tt(t, e.coordinates[s][0]);
+      i < r && (r = i, o = s);
+    }
+    return o;
+  }
+  if (e.type === "MultiLineString") {
+    let o = 0, r = 1 / 0;
+    const s = e.coordinates;
+    for (let i = 0; i < n; i++) {
+      const l = tt(t, s[i]);
+      l < r && (r = l, o = i);
+    }
+    return o;
+  }
+  if (e.type === "MultiPoint") {
+    let o = 0, r = 1 / 0;
+    const s = e.coordinates;
+    for (let i = 0; i < n; i++) {
+      const l = t[0] - s[i][0], u = t[1] - s[i][1], c = l * l + u * u;
+      c < r && (r = c, o = i);
+    }
+    return o;
+  }
+  if (e.type === "GeometryCollection") {
+    for (let s = 0; s < n; s++) {
+      const i = At(e, s);
+      if (i.type === "Polygon" && mn(t, i.coordinates))
+        return s;
+    }
+    let o = 0, r = 1 / 0;
+    for (let s = 0; s < n; s++) {
+      const i = At(e, s);
+      let l = 1 / 0;
+      if (i.type === "Point") {
+        const u = t[0] - i.coordinates[0], c = t[1] - i.coordinates[1];
+        l = u * u + c * c;
+      } else i.type === "LineString" ? l = tt(t, i.coordinates) : i.type === "Polygon" && (l = tt(t, i.coordinates[0]));
+      l < r && (r = l, o = s);
+    }
+    return o;
+  }
+  return null;
+}
+function Un({ map: e, coords: t, onSave: n, onClose: o }) {
+  const r = Ue(), [s, i] = le(t[0].toFixed(6)), [l, u] = le(t[1].toFixed(6)), [c, v] = le(() => {
+    const w = e.project(t);
+    return { x: w.x, y: w.y };
+  }), d = $(null);
+  K(() => {
+    const w = () => {
+      const C = e.project(t);
+      v({ x: C.x, y: C.y });
+    };
+    return e.on("move", w), e.on("zoom", w), e.on("resize", w), () => {
+      e.off("move", w), e.off("zoom", w), e.off("resize", w);
+    };
+  }, [e, t]), K(() => {
+    var w, C;
+    (w = d.current) == null || w.focus(), (C = d.current) == null || C.select();
+  }, []);
+  function g() {
+    const w = parseFloat(s), C = parseFloat(l);
+    if (isNaN(w) || isNaN(C)) {
+      r({ type: "warning", message: "Invalid coordinates" });
+      return;
+    }
+    n([w, C]), r({ type: "success", message: "Coordinate updated" }), o();
+  }
+  return Ze(
+    /* @__PURE__ */ X(
+      "div",
+      {
+        "data-elm-theme": !0,
+        style: {
+          position: "absolute",
+          left: c.x,
+          top: c.y - 16,
+          transform: "translate(-50%, -100%)",
+          zIndex: 500,
+          pointerEvents: "auto"
+        },
+        onMouseDown: (w) => w.stopPropagation(),
+        onDoubleClick: (w) => w.stopPropagation(),
+        onContextMenu: (w) => w.stopPropagation(),
+        children: /* @__PURE__ */ fe(
+          "div",
+          {
+            className: "flex flex-col gap-2 min-w-[160px] bg-(--elm-surface,var(--color-white))/95 backdrop-blur-md border border-(--elm-border-strong,var(--color-slate-300)) rounded-elm-control shadow-elm-control p-2 text-(--elm-text,var(--color-slate-800))",
+            onKeyDown: (w) => {
+              w.key === "Enter" ? g() : w.key === "Escape" && o();
+            },
+            children: [
+              /* @__PURE__ */ X("p", { className: "text-xs font-semibold m-0 leading-none", children: "Precise coordinates" }),
+              /* @__PURE__ */ fe("label", { className: "flex items-center gap-2 text-xs text-(--elm-text-muted,var(--color-slate-500))", children: [
+                "Lat:",
+                /* @__PURE__ */ X(
+                  "input",
+                  {
+                    ref: d,
+                    type: "text",
+                    inputMode: "decimal",
+                    value: l,
+                    onChange: (w) => u(w.target.value),
+                    className: "flex-1 w-full min-w-0 border border-(--elm-border,var(--color-slate-200)) rounded-elm-chip px-1.5 py-0.5 text-xs outline-none focus:border-primary-400"
+                  }
+                )
+              ] }),
+              /* @__PURE__ */ fe("label", { className: "flex items-center gap-2 text-xs text-(--elm-text-muted,var(--color-slate-500))", children: [
+                "Lng:",
+                /* @__PURE__ */ X(
+                  "input",
+                  {
+                    type: "text",
+                    inputMode: "decimal",
+                    value: s,
+                    onChange: (w) => i(w.target.value),
+                    className: "flex-1 w-full min-w-0 border border-(--elm-border,var(--color-slate-200)) rounded-elm-chip px-1.5 py-0.5 text-xs outline-none focus:border-primary-400"
+                  }
+                )
+              ] }),
+              /* @__PURE__ */ fe("div", { className: "flex items-center justify-end gap-1 mt-1", children: [
+                /* @__PURE__ */ X(
+                  "button",
+                  {
+                    type: "button",
+                    onClick: o,
+                    className: "px-2 py-1 text-xs text-(--elm-text-muted,var(--color-slate-500)) hover:bg-(--elm-surface-hover,var(--color-slate-100)) rounded-elm-chip transition-colors",
+                    children: "Cancel"
+                  }
+                ),
+                /* @__PURE__ */ X(
+                  "button",
+                  {
+                    type: "button",
+                    onClick: g,
+                    className: "px-2 py-1 text-xs text-white bg-primary-500 hover:bg-primary-600 rounded-elm-chip transition-colors font-medium",
+                    children: "Save"
+                  }
+                )
+              ] })
+            ]
+          }
+        )
+      }
+    ),
+    e.getCanvasContainer()
+  );
+}
+const Et = "elm-features";
+let Xe = null;
+const Gt = () => Xe;
+function Pt(e, t) {
+  Xe !== t && (e.getSource(Et) && (Xe && e.setFeatureState({ source: Et, id: Xe }, { fresh: !1 }), t && e.setFeatureState({ source: Et, id: t }, { fresh: !0 })), Xe = t);
+}
+let ae = null, Wt = !1, Ut = null, Zt = 0, qt = 0;
+function Jt(e) {
+  return e.ctrlKey || e.metaKey || e.altKey;
+}
+function Zn(e) {
+  Jt(e) && ae && (ae.style.display = "none");
+}
+function qn(e) {
+  Jt(e) || Wt || Ut && ae && ae.textContent && (ae.style.display = "", gt(Zt, qt));
+}
+function Jn(e) {
+  if (!ae) return;
+  gt(e.clientX, e.clientY);
+  const t = e.target;
+  !!(t != null && t.closest(".maplibregl-canvas-container, .maplibregl-canvas")) || (ae.style.display = "none");
+}
+function gt(e, t) {
+  if (Zt = e, qt = t, !ae || ae.style.display === "none") return;
+  const { left: n, top: o } = Fn(e, t, ae.offsetWidth, ae.offsetHeight, { x: "center", y: "before", gapY: 12 });
+  ae.style.left = n + "px", ae.style.top = o + "px";
+}
+function Kr() {
+  return ae || (ae = document.createElement("div"), ae.className = "elm-feature-tooltip", ae.style.cssText = "position:fixed;pointer-events:none;z-index:10000;display:none", document.body.appendChild(ae), window.addEventListener("keydown", Zn), window.addEventListener("keyup", qn), document.addEventListener("mousemove", Jn, { passive: !0 })), ae;
+}
+function Nr(e, t, n) {
+  var i, l;
+  if (Wt) return;
+  const o = t.getState();
+  if (!o.showFeatureNameOnHover || o.vertexEditActive || Gt() === e.id) {
+    ct();
+    return;
+  }
+  const r = Do(e);
+  if (!r) return;
+  const s = Kr();
+  s.textContent = r, qo(s, (l = (i = n == null ? void 0 : n.target) == null ? void 0 : i.closest) == null ? void 0 : l.call(i, "[data-elm-theme]")), Ut = e.id, n && gt(n.clientX, n.clientY), n && Jt(n) ? s.style.display = "none" : (s.style.display = "", gt(Zt, qt));
+}
+function ct() {
+  Ut = null, ae && (ae.remove(), ae = null, window.removeEventListener("keydown", Zn), window.removeEventListener("keyup", qn), document.removeEventListener("mousemove", Jn));
+}
+function Ce(e) {
+  Wt = e, e && ae && (ae.style.display = "none");
+}
+function ze(e) {
+  let t = 0, n = null;
+  const o = () => {
+    t = 0;
+    const r = n;
+    n = null, r && e(...r);
+  };
+  return {
+    schedule(...r) {
+      n = r, t || (t = requestAnimationFrame(o));
+    },
+    flush() {
+      t && cancelAnimationFrame(t), o();
+    },
+    cancel() {
+      t && cancelAnimationFrame(t), t = 0, n = null;
+    }
+  };
+}
+function Oe(e, t) {
+  return ht(e) ? t == null ? null : At(e, t) : e;
+}
+function nt(e, t, n) {
+  return ht(e) && t != null ? Lo(e, t, n) : n;
+}
+function ot(e) {
+  return e.type === "Point" ? [[e.coordinates]] : e.type === "MultiPoint" ? [e.coordinates] : e.type === "LineString" ? [e.coordinates] : e.type === "Polygon" ? e.coordinates : [];
+}
+function Ct(e, t) {
+  e.style.background = t ? "var(--color-primary-500)" : "#ffffff", e.style.borderColor = t ? "var(--color-primary-700)" : "var(--color-primary-500)", e.dataset.elmSelected = t ? "1" : "0";
+}
+let vn = !1;
+function Br() {
+  if (vn) return;
+  const e = document.createElement("style");
+  e.textContent = ".elm-midpoint-marker{pointer-events:auto!important}", document.head.appendChild(e), vn = !0;
+}
+function xn(e, t = !1) {
+  if (t) {
+    const o = document.createElement("div");
+    o.classList.add("elm-midpoint-marker"), o.style.cssText = "width:24px;height:24px;display:flex;align-items:center;justify-content:center;cursor:pointer;background:rgba(0,0,0,0.001)";
+    const r = document.createElement("div");
+    return r.style.cssText = [
+      "width:12px",
+      "height:12px",
+      "background:#ffffff",
+      "border:2px solid var(--color-primary-500)",
+      "box-shadow:0 1px 3px rgba(0,0,0,0.35)",
+      "transform:rotate(45deg)",
+      "border-radius:3px",
+      "transition:all 0.1s"
+    ].join(";"), o.appendChild(r), o.addEventListener("mouseenter", () => {
+      r.style.background = "var(--color-primary-100)";
+    }), o.addEventListener("mouseleave", () => {
+      r.style.background = "#ffffff";
+    }), o;
+  }
+  const n = document.createElement("div");
+  return n.classList.add("elm-vertex"), n.style.cssText = [
+    "width:12px",
+    "height:12px",
+    `background:${e ? "var(--color-primary-500)" : "#ffffff"}`,
+    `border:2px solid ${e ? "var(--color-primary-700)" : "var(--color-primary-500)"}`,
+    "border-radius:3px",
+    "cursor:pointer",
+    "box-shadow:0 1px 3px rgba(0,0,0,0.35)",
+    "transition:background 0.15s"
+  ].join(";"), n.dataset.elmSelected = e ? "1" : "0", n.addEventListener("mouseenter", () => {
+    n.style.background = "var(--color-primary-100)";
+  }), n.addEventListener("mouseleave", () => {
+    n.style.background = n.dataset.elmSelected === "1" ? "var(--color-primary-500)" : "#ffffff";
+  }), n;
+}
+const rt = 500, wn = 15;
+function Sn(e, t, n) {
+  const o = t.map((d, g) => g);
+  if (t.length <= rt) return { indices: o, capped: !1 };
+  const r = e.getBounds(), s = o.filter((d) => r.contains(t[d]));
+  if (s.length <= rt) return { indices: s, capped: !0 };
+  const i = [0];
+  let l = e.project(t[s[0]]);
+  for (let d = 1; d < s.length; d++) {
+    const g = e.project(t[s[d]]);
+    i.push(i[d - 1] + Math.hypot(g.x - l.x, g.y - l.y)), l = g;
+  }
+  const u = i[i.length - 1], c = /* @__PURE__ */ new Set();
+  let v = 0;
+  for (let d = 0; d < rt; d++) {
+    const g = u === 0 ? d : d * u / rt;
+    for (; v < i.length - 1 && i[v + 1] < g; ) v++;
+    c.add(s[v]);
+  }
+  for (const d of s) n(d) && c.add(d);
+  return { indices: [...c].sort((d, g) => d - g), capped: !0 };
+}
+function Or(e, t) {
+  const n = (e[0] + t[0]) / 2, o = (i) => Math.log(Math.tan(Math.PI / 4 + i * Math.PI / 180 / 2)), s = ((i) => (2 * Math.atan(Math.exp(i)) - Math.PI / 2) * 180 / Math.PI)((o(e[1]) + o(t[1])) / 2);
+  return [n, s];
+}
+function $r({ map: e, feature: t, initialSelectedIndices: n }) {
+  var j;
+  const { dataStore: o, uiStore: r } = Le(), s = Ue(), i = zt(), l = he((h) => h.selectedIds), u = W((h) => h.selectedPartIndex), c = $([]), [v, d] = le(() => n && n.length > 0 ? new Set(n.map((h) => `0:${h}`)) : /* @__PURE__ */ new Set()), g = $(v);
+  K(() => {
+    g.current = v;
+  }, [v]);
+  const w = $(/* @__PURE__ */ new Map()), [C, T] = le(null), F = ve(() => T(null), []), [k, N] = le(null);
+  K(() => {
+    d(/* @__PURE__ */ new Set()), T(null), N(null);
+  }, [t.id, u]);
+  const P = $(n);
+  K(() => {
+    n !== P.current && (P.current = n, !(!n || n.length === 0) && d((h) => {
+      const I = new Set(h);
+      for (const O of n) I.add(`0:${O}`);
+      for (const O of n) {
+        const z = w.current.get(`0:${O}`);
+        z && Ct(z, !0);
+      }
+      return I;
+    }));
+  }, [n]);
+  function _(h) {
+    Vt(e, /* @__PURE__ */ new Map([[t.id, h]]));
+  }
+  function D(h) {
+    const I = nt(t.geometry, u, h);
+    o.getState().updateFeature(t.id, So(t, I));
+  }
+  const q = $(!1);
+  K(() => {
+    const h = (I) => {
+      q.current = I.metaKey || I.ctrlKey;
+    };
+    return window.addEventListener("keydown", h), window.addEventListener("keyup", h), () => {
+      window.removeEventListener("keydown", h), window.removeEventListener("keyup", h);
+    };
+  }, []);
+  function p() {
+    Br(), c.current.forEach((z) => z.remove()), c.current = [], w.current = /* @__PURE__ */ new Map(), f.current = [], b.current = null, M.current = !1;
+    const h = Oe(t.geometry, u);
+    if (!h) return;
+    const I = ot(h), O = g.current;
+    E.current = !1, I.forEach((z, G) => {
+      const H = h.type === "Polygon" ? z.slice(0, -1) : z, te = Sn(e, H, (Z) => O.has(`${G}:${Z}`));
+      te.capped && (E.current = !0);
+      for (const Z of te.indices) {
+        const ne = H[Z], se = `${G}:${Z}`, ie = xn(O.has(se));
+        w.current.set(se, ie);
+        const re = new De.Marker({ element: ie, draggable: !0 }).setLngLat(ne).addTo(e);
+        let J = !1;
+        ie.addEventListener("click", (Y) => {
+          if (Y.stopPropagation(), Y.preventDefault(), J) {
+            J = !1;
+            return;
+          }
+          Y.shiftKey ? d((ee) => {
+            const oe = new Set(ee);
+            oe.has(se) ? oe.delete(se) : oe.add(se);
+            const Q = w.current.get(se);
+            return Q && Ct(Q, oe.has(se)), oe;
+          }) : (d(/* @__PURE__ */ new Set([se])), w.current.forEach((ee, oe) => Ct(ee, oe === se)));
+        }), re.on("dragstart", () => {
+          J = !0, M.current = !0, o.getState().takeSnapshot(), document.querySelectorAll(".elm-midpoint-marker").forEach((Y) => {
+            Y.style.display = "none";
+          }), Ce(!0);
+        });
+        const ce = [ne[0], ne[1]], U = ze(() => {
+          const Y = re.getLngLat(), ee = [Y.lng, Y.lat], oe = Mt(h, G, Z, ee);
+          _(nt(t.geometry, u, oe));
+        });
+        re.on("drag", () => U.schedule()), re.on("dragend", () => {
+          U.cancel();
+          const Y = re.getLngLat(), ee = [Y.lng, Y.lat], oe = Mt(h, G, Z, ee);
+          if (D(oe), r.getState().topoEditEnabled && !q.current) {
+            const Q = o.getState();
+            Q.updateFeatures(on(
+              Q.features,
+              t.id,
+              ce,
+              ee
+            ));
+          }
+          Ce(!1), M.current = !1, setTimeout(() => {
+            J = !1;
+          }, 50);
+        }), ie.addEventListener("contextmenu", (Y) => {
+          Y.preventDefault(), Y.stopPropagation(), T({ ringIdx: G, vertIdx: Z, x: Y.clientX, y: Y.clientY });
+        }), c.current.push(re);
+      }
+      if (H.length >= 2) {
+        const Z = h.type === "Polygon" ? H.length : H.length - 1, ne = [];
+        for (let ie = 0; ie < Z; ie++) ne.push(Or(H[ie], H[(ie + 1) % H.length]));
+        const se = Sn(e, ne, () => !1);
+        se.capped && (E.current = !0);
+        for (const ie of se.indices) {
+          const re = H[ie], J = H[(ie + 1) % H.length], ce = ne[ie], U = xn(!1, !0);
+          U.style.display = "none", f.current.push({ el: U, a: re, b: J });
+          const Y = new De.Marker({ element: U, draggable: !0 }).setLngLat(ce).addTo(e);
+          let ee = !1;
+          Y.on("dragstart", () => {
+            ee = !0, M.current = !0, o.getState().takeSnapshot(), Ce(!0);
+          });
+          const oe = ze(() => {
+            const Q = Y.getLngLat(), de = [Q.lng, Q.lat], ue = He(h, G, ie + 1, de);
+            _(nt(t.geometry, u, ue));
+          });
+          Y.on("drag", () => oe.schedule()), Y.on("dragend", () => {
+            oe.cancel();
+            const Q = Y.getLngLat(), de = [Q.lng, Q.lat], ue = He(h, G, ie + 1, de);
+            if (D(ue), r.getState().topoEditEnabled) {
+              const Re = o.getState();
+              Re.updateFeatures(wt(
+                Re.features,
+                t.id,
+                re,
+                J,
+                de
+              ));
+            }
+            setTimeout(() => {
+              ee = !1;
+            }, 50), Ce(!1), M.current = !1;
+          }), U.addEventListener("click", (Q) => {
+            if (Q.stopPropagation(), ee) {
+              ee = !1;
+              return;
+            }
+            o.getState().takeSnapshot();
+            const de = He(h, G, ie + 1, ce);
+            if (D(de), r.getState().topoEditEnabled) {
+              const ue = o.getState();
+              ue.updateFeatures(wt(
+                ue.features,
+                t.id,
+                re,
+                J,
+                ce
+              ));
+            }
+          }), c.current.push(Y);
+        }
+      }
+    });
+  }
+  const f = $([]), b = $(null), M = $(!1);
+  K(() => {
+    const h = (z) => {
+      if (z === b.current) return;
+      const G = f.current;
+      b.current !== null && G[b.current] && (G[b.current].el.style.display = "none"), z !== null && (G[z].el.style.display = "flex"), b.current = z;
+    }, I = (z) => {
+      if (M.current) return;
+      const { x: G, y: H } = z.point;
+      let te = -1, Z = 1 / 0;
+      f.current.forEach(({ a: se, b: ie }, re) => {
+        const J = e.project(se), ce = e.project(ie), U = ce.x - J.x, Y = ce.y - J.y, ee = U * U + Y * Y, oe = ee ? Math.max(0, Math.min(1, ((G - J.x) * U + (H - J.y) * Y) / ee)) : 0, Q = (J.x + oe * U - G) ** 2 + (J.y + oe * Y - H) ** 2;
+        Q < Z && (Z = Q, te = re);
+      });
+      const ne = b.current === null ? 22 : 36;
+      h(te >= 0 && Z <= ne * ne ? te : null);
+    }, O = (z) => {
+      const G = z.originalEvent.relatedTarget;
+      !M.current && !(G instanceof Node && e.getContainer().contains(G)) && h(null);
+    };
+    return e.on("mousemove", I), e.on("mouseout", O), () => {
+      e.off("mousemove", I), e.off("mouseout", O);
+    };
+  }, [e]);
+  const A = $(() => {
+  });
+  A.current = (h) => {
+    var ee, oe;
+    const I = h.originalEvent;
+    if (M.current || I.button !== 0 || I.shiftKey || (oe = (ee = I.target) == null ? void 0 : ee.closest) != null && oe.call(ee, ".maplibregl-marker")) return;
+    const O = Oe(t.geometry, u);
+    if (!O || O.type !== "Polygon" && O.type !== "LineString") return;
+    const z = O.type === "Polygon";
+    let G = null, H = wn * wn;
+    if (ot(O).forEach((Q, de) => {
+      const ue = z ? Q.slice(0, -1) : Q, Re = z ? ue.length : ue.length - 1;
+      if (ue.length < 2) return;
+      let xe = e.project(ue[0]);
+      for (let Ee = 0; Ee < Re; Ee++) {
+        const Je = ue[(Ee + 1) % ue.length], xt = e.project(Je), Qe = xt.x - xe.x, et = xt.y - xe.y, en = Qe * Qe + et * et, tn = en ? Math.max(0, Math.min(1, ((h.point.x - xe.x) * Qe + (h.point.y - xe.y) * et) / en)) : 0, nn = (xe.x + tn * Qe - h.point.x) ** 2 + (xe.y + tn * et - h.point.y) ** 2;
+        nn < H && (H = nn, G = { ringIdx: de, seg: Ee, a: ue[Ee], b: Je }), xe = xt;
+      }
+    }), !G) return;
+    const { ringIdx: te, seg: Z, a: ne, b: se } = G;
+    h.preventDefault();
+    const ie = h.point;
+    let re = [h.lngLat.lng, h.lngLat.lat], J = !1;
+    const ce = ze(() => {
+      _(nt(t.geometry, u, He(O, te, Z + 1, re)));
+    }), U = (Q) => {
+      if (!J) {
+        if (Math.hypot(Q.point.x - ie.x, Q.point.y - ie.y) < 3) return;
+        J = !0, M.current = !0, o.getState().takeSnapshot(), document.querySelectorAll(".elm-midpoint-marker").forEach((ue) => {
+          ue.style.display = "none";
+        }), b.current = null, Ce(!0);
+      }
+      re = [Q.lngLat.lng, Q.lngLat.lat];
+      const de = Q.originalEvent.metaKey || Q.originalEvent.ctrlKey;
+      if (r.getState().snapEnabled && !de) {
+        const ue = Vn(re[0], re[1], e, o.getState().features, 15, /* @__PURE__ */ new Set([t.id]));
+        ue && (re = ue.lnglat);
+      }
+      ce.schedule();
+    }, Y = () => {
+      if (e.off("mousemove", U), window.removeEventListener("mouseup", Y), ce.cancel(), !!J) {
+        if (D(He(O, te, Z + 1, re)), z && r.getState().topoEditEnabled) {
+          const Q = o.getState();
+          Q.updateFeatures(wt(Q.features, t.id, ne, se, re));
+        }
+        Ce(!1), M.current = !1;
+      }
+    };
+    e.on("mousemove", U), window.addEventListener("mouseup", Y);
+  }, K(() => {
+    const h = (I) => A.current(I);
+    return e.on("mousedown", h), () => {
+      e.off("mousedown", h);
+    };
+  }, [e]);
+  const E = $(!1), a = $(p);
+  a.current = p, K(() => {
+    const h = () => {
+      E.current && a.current();
+    };
+    return e.on("moveend", h), () => {
+      e.off("moveend", h);
+    };
+  }, [e]), K(() => (p(), () => {
+    c.current.forEach((h) => h.remove()), c.current = [], w.current = /* @__PURE__ */ new Map();
+  }), [t, e, l, u]);
+  function x(h, I) {
+    const O = Oe(t.geometry, u);
+    if (!O) return;
+    const z = jr(O, h, I);
+    if (!z) {
+      s({ type: "warning", message: `Cannot delete: ${O.type === "Polygon" ? "an area needs at least 3" : O.type === "LineString" ? "a line needs at least 2" : "at least 1"} points` });
+      return;
+    }
+    const G = ot(O)[h][I];
+    if (o.getState().takeSnapshot(), D(z), d(/* @__PURE__ */ new Set()), O.type === "Polygon" && r.getState().topoEditEnabled) {
+      const H = o.getState();
+      H.updateFeatures(rn(H.features, t.id, [G]));
+    }
+  }
+  function y() {
+    const h = g.current;
+    if (h.size === 0) return;
+    const I = Oe(t.geometry, u);
+    if (!I) return;
+    const O = /* @__PURE__ */ new Map();
+    for (const z of h) {
+      const [G, H] = z.split(":"), te = Number(G), Z = Number(H), ne = O.get(te) ?? [];
+      ne.push(Z), O.set(te, ne);
+    }
+    if (I.type === "LineString") {
+      const z = I.coordinates, G = new Set(O.get(0) ?? []), H = z.filter((te, Z) => !G.has(Z));
+      if (H.length < 2) {
+        s({ type: "warning", message: "Cannot delete: a line needs at least 2 points" });
+        return;
+      }
+      o.getState().takeSnapshot(), D({ type: "LineString", coordinates: H }), d(/* @__PURE__ */ new Set());
+      return;
+    }
+    if (I.type === "MultiPoint") {
+      const z = I.coordinates, G = new Set(O.get(0) ?? []), H = z.filter((te, Z) => !G.has(Z));
+      if (H.length < 1) {
+        s({ type: "warning", message: "Cannot delete: at least 1 point required" });
+        return;
+      }
+      o.getState().takeSnapshot(), D({ type: "MultiPoint", coordinates: H }), d(/* @__PURE__ */ new Set());
+      return;
+    }
+    if (I.type === "Polygon") {
+      const z = I.coordinates, G = [];
+      for (let H = 0; H < z.length; H++) {
+        const te = z[H], Z = te.slice(0, -1), ne = new Set(O.get(H) ?? []);
+        if (ne.size === 0) {
+          G.push(te);
+          continue;
+        }
+        const se = Z.filter((ie, re) => !ne.has(re));
+        if (se.length < 3) {
+          s({ type: "warning", message: "Cannot delete: an area needs at least 3 points" });
+          return;
+        }
+        G.push([...se, se[0]]);
+      }
+      if (o.getState().takeSnapshot(), D({ type: "Polygon", coordinates: G }), d(/* @__PURE__ */ new Set()), r.getState().topoEditEnabled) {
+        const H = [...O].flatMap(([Z, ne]) => ne.map((se) => z[Z][se])), te = o.getState();
+        te.updateFeatures(rn(te.features, t.id, H));
+      }
+      return;
+    }
+  }
+  function m() {
+    if (g.current.size < 3) {
+      s({ type: "warning", message: "Select at least 3 points to simplify" });
+      return;
+    }
+    const h = Oe(t.geometry, u);
+    if (!h || h.type !== "LineString" && h.type !== "Polygon") return;
+    const I = /* @__PURE__ */ new Map();
+    for (const U of g.current) {
+      const [Y, ee] = U.split(":"), oe = Number(Y), Q = Number(ee), de = I.get(oe) ?? [];
+      de.push(Q), I.set(oe, de);
+    }
+    if (I.size !== 1) {
+      s({ type: "warning", message: "Selection must stay within one ring/line to simplify" });
+      return;
+    }
+    const [O, z] = Array.from(I.entries())[0], G = z.sort((U, Y) => U - Y), H = G[0], te = G[G.length - 1], Z = h.type === "Polygon", ne = Z ? h.coordinates[O].slice(0, -1) : h.coordinates, se = ne.slice(H, te + 1), ie = bo(se, 1e-5), re = se.length - ie.length;
+    if (re === 0) {
+      s({ type: "warning", message: "Nothing to remove: no selected point sits on a straight line" });
+      return;
+    }
+    const J = [...ne.slice(0, H), ...ie, ...ne.slice(te + 1)], ce = Z ? 3 : 2;
+    if (J.length < ce) {
+      s({ type: "warning", message: `Cannot simplify: ${Z ? "an area needs at least 3" : "a line needs at least 2"} points` });
+      return;
+    }
+    if (o.getState().takeSnapshot(), Z) {
+      const U = h.coordinates.map(
+        (Y, ee) => ee === O ? [...J, J[0]] : Y
+      );
+      D({ type: "Polygon", coordinates: U });
+    } else
+      D({ type: "LineString", coordinates: J });
+    d(/* @__PURE__ */ new Set()), s({ type: "success", message: `Removed ${re} extra point${re !== 1 ? "s" : ""}` });
+  }
+  K(() => {
+    if (v.size === 0) return;
+    function h(I) {
+      if (I.key !== "Delete" && I.key !== "Backspace") return;
+      const O = I.target;
+      O && (O.tagName === "INPUT" || O.tagName === "TEXTAREA" || O.isContentEditable) || i(I) && (I.preventDefault(), I.stopPropagation(), y());
+    }
+    return window.addEventListener("keydown", h, { capture: !0 }), () => window.removeEventListener("keydown", h, { capture: !0 });
+  }, [v]);
+  const R = v.size > 0, S = C && (() => {
+    const h = `${C.ringIdx}:${C.vertIdx}`, I = v.has(h) && v.size > 1;
+    return /* @__PURE__ */ X(
+      Ko,
+      {
+        x: C.x,
+        y: C.y,
+        onClose: F,
+        items: [
+          { label: "Edit coordinates…", icon: /* @__PURE__ */ X(rr, { size: 16 }), onClick: () => N({ ringIdx: C.ringIdx, vertIdx: C.vertIdx }) },
+          { separator: !0 },
+          {
+            label: I ? `Delete ${v.size} points` : "Delete point",
+            icon: /* @__PURE__ */ X(sr, { size: 16 }),
+            onClick: () => I ? y() : x(C.ringIdx, C.vertIdx)
+          }
+        ]
+      }
+    );
+  })(), L = k && Oe(t.geometry, u), B = L && k ? (j = ot(L)[k.ringIdx]) == null ? void 0 : j[k.vertIdx] : void 0, V = k && L && B && /* @__PURE__ */ X(
+    Un,
+    {
+      map: e,
+      coords: B,
+      onSave: (h) => {
+        if (o.getState().takeSnapshot(), D(Mt(L, k.ringIdx, k.vertIdx, h)), L.type === "Polygon" && r.getState().topoEditEnabled) {
+          const I = o.getState();
+          I.updateFeatures(on(I.features, t.id, B, h));
+        }
+      },
+      onClose: () => N(null)
+    },
+    `${k.ringIdx}:${k.vertIdx}`
+  );
+  return /* @__PURE__ */ fe(lt, { children: [
+    S,
+    V,
+    R && /* @__PURE__ */ X(
+      No,
+      {
+        mapContainer: e.getContainer(),
+        count: v.size,
+        onSimplify: m,
+        onDelete: y
+      }
+    )
+  ] });
+}
+function Mt(e, t, n, o) {
+  if (e.type === "Point") return { type: "Point", coordinates: Ve(e.coordinates, o) };
+  if (e.type === "MultiPoint") {
+    const r = [...e.coordinates];
+    return r[n] = Ve(r[n], o), { type: "MultiPoint", coordinates: r };
+  }
+  if (e.type === "LineString") {
+    const r = [...e.coordinates];
+    return r[n] = Ve(r[n], o), { type: "LineString", coordinates: r };
+  }
+  return e.type === "Polygon" ? { type: "Polygon", coordinates: e.coordinates.map((s, i) => {
+    if (i !== t) return s;
+    const l = [...s];
+    return l[n] = Ve(l[n], o), n === 0 && (l[l.length - 1] = l[0]), l;
+  }) } : e;
+}
+function jr(e, t, n) {
+  if (e.type === "LineString") {
+    const o = e.coordinates.filter((r, s) => s !== n);
+    return o.length < 2 ? null : { type: "LineString", coordinates: o };
+  }
+  if (e.type === "Polygon") {
+    const r = e.coordinates[t].slice(0, -1);
+    if (r.length <= 3) return null;
+    const s = r.filter((l, u) => u !== n);
+    return { type: "Polygon", coordinates: e.coordinates.map(
+      (l, u) => u === t ? [...s, s[0]] : l
+    ) };
+  }
+  if (e.type === "MultiPoint") {
+    const o = e.coordinates.filter((r, s) => s !== n);
+    return o.length < 1 ? null : { type: "MultiPoint", coordinates: o };
+  }
+  return null;
+}
+function He(e, t, n, o) {
+  if (e.type === "LineString") {
+    const r = [...e.coordinates];
+    return r.splice(n, 0, sn(r[n - 1], r[n], o)), { type: "LineString", coordinates: r };
+  }
+  if (e.type === "Polygon") {
+    const s = e.coordinates[t].slice(0, -1);
+    return s.splice(n, 0, sn(s[n - 1], s[n % s.length], o)), { type: "Polygon", coordinates: e.coordinates.map(
+      (l, u) => u === t ? [...s, s[0]] : l
+    ) };
+  }
+  return e;
+}
+function zr(e, t, n) {
+  if (!n) return [t[0] - e[0], t[1] - e[1]];
+  const o = me(e), r = me(t);
+  return [r[0] - o[0], r[1] - o[1]];
+}
+function st(e, t, n) {
+  return $t({ type: "MultiPoint", coordinates: e }, t, n).coordinates;
+}
+function Hr(e, t, n) {
+  let o = !1;
+  for (let r = 0, s = t.length - 1; r < t.length; s = r++) {
+    const i = t[r], l = t[s];
+    i.y > e.y != l.y > e.y && e.x < (l.x - i.x) * (e.y - i.y) / (l.y - i.y) + i.x && (o = !o);
+    const u = l.x - i.x, c = l.y - i.y, v = u * u + c * c, d = v ? Math.max(0, Math.min(1, ((e.x - i.x) * u + (e.y - i.y) * c) / v)) : 0;
+    if (Math.hypot(i.x + d * u - e.x, i.y + d * c - e.y) <= n) return !0;
+  }
+  return o;
+}
+const Vr = 3, Xr = 8;
+function it(e) {
+  const t = cr(e), [n, o, r, s] = Bn(t), i = (n + r) / 2, l = Zr(o, s);
+  return {
+    corners: [
+      [n, s],
+      [r, s],
+      [r, o],
+      [n, o]
+    ],
+    edges: [
+      [i, s],
+      [r, l],
+      [i, o],
+      [n, l]
+    ],
+    // The box centre (rotation pivot, Alt-scale anchor), not the vertex mean.
+    center: [i, l],
+    rotateHandle: [i, s]
+  };
+}
+function kt(e, t, n) {
+  const [o, r] = t, s = Ke(n), i = Math.cos(s), l = Math.sin(s), u = Te(r);
+  return e.map(([c, v]) => {
+    const d = (c - o) * u, g = v - r;
+    return [
+      o + (d * i - g * l) / u,
+      r + (d * l + g * i)
+    ];
+  });
+}
+function Yr(e, t, n, o, r) {
+  const [s, i] = t, l = Ke(r), u = Math.cos(l), c = Math.sin(l), v = Te(i);
+  return e.map(([d, g]) => {
+    const w = (d - s) * v, C = g - i, T = w * u + C * c, F = -w * c + C * u, k = T * n, N = F * o, P = k * u - N * c, _ = k * c + N * u;
+    return [s + P / v, i + _];
+  });
+}
+function Gr(e, t, n, o) {
+  const r = me(t), s = Ke(o), i = Math.cos(s), l = Math.sin(s);
+  function u(c) {
+    const v = me(c), d = v[0] - r[0], g = v[1] - r[1], w = d * i + g * l, C = -d * l + g * i, T = w * n, F = C * n, k = T * i - F * l, N = T * l + F * i;
+    return Ot([r[0] + k, r[1] + N]);
+  }
+  return { ...e, geometry: _n(e.geometry, u) };
+}
+function Wr(e, t, n, o) {
+  const r = me(t), s = Ke(o), i = Math.cos(s), l = Math.sin(s);
+  return e.map((u) => {
+    const c = me(u), v = c[0] - r[0], d = c[1] - r[1], g = v * i + d * l, w = -v * l + d * i, C = g * n, T = w * n, F = C * i - T * l, k = C * l + T * i;
+    return Ot([r[0] + F, r[1] + k]);
+  });
+}
+function Ur(e, t, n, o, r) {
+  const [s, i] = t, l = Ke(r), u = Math.cos(l), c = Math.sin(l), v = Te(i);
+  function d(g) {
+    const w = (g[0] - s) * v, C = g[1] - i, T = w * u + C * c, F = -w * c + C * u, k = T * n, N = F * o, P = k * u - N * c, _ = k * c + N * u;
+    return [s + P / v, i + _];
+  }
+  return { ...e, geometry: _n(e.geometry, d) };
+}
+function Zr(e, t) {
+  return Ot([0, (me([0, e])[1] + me([0, t])[1]) / 2])[1];
+}
+function qr(e, t, n, o) {
+  const r = o ? e.initialBbox.center : e.origin, s = Math.cos(Ke(e.rotationAngle)), i = Math.sin(Ke(e.rotationAngle));
+  let l;
+  if (n) {
+    const F = me(r);
+    l = (k) => {
+      const N = me(k), P = N[0] - F[0], _ = N[1] - F[1];
+      return [P * s + _ * i, -P * i + _ * s];
+    };
+  } else {
+    const F = Te(r[1]);
+    l = (k) => {
+      const N = (k[0] - r[0]) * F, P = k[1] - r[1];
+      return [N * s + P * i, -N * i + P * s];
+    };
+  }
+  const [u, c] = l(e.startLngLat), [v, d] = l(t), g = e.edgeIndex === 0 || e.edgeIndex === 2, w = e.edgeIndex === 1 || e.edgeIndex === 3, C = (F) => Math.abs(F) < 0.01 ? F < 0 ? -0.01 : 0.01 : F, T = (F, k) => Math.abs(k) > 1e-9 ? F / k : 1;
+  if (n) {
+    let F;
+    if (g) F = T(d, c);
+    else if (w) F = T(v, u);
+    else {
+      const k = u * u + c * c;
+      F = k > 1e-18 ? (v * u + d * c) / k : 1;
+    }
+    return { origin: r, uniform: !0, factor: C(F) };
+  }
+  return {
+    origin: r,
+    uniform: !1,
+    scaleX: w || !g ? C(T(v, u)) : 1,
+    scaleY: g || !w ? C(T(d, c)) : 1
+  };
+}
+function Jr(e, t, n, o) {
+  const r = n.uniform ? (s) => Wr(s, n.origin, n.factor, o) : (s) => Yr(s, n.origin, n.scaleX, n.scaleY, o);
+  return {
+    features: e.map((s) => n.uniform ? Gr(s, n.origin, n.factor, o) : Ur(s, n.origin, n.scaleX, n.scaleY, o)),
+    box: {
+      corners: r(t.corners),
+      edges: r(t.edges),
+      center: r([t.center])[0],
+      rotateHandle: r([t.rotateHandle])[0]
+    }
+  };
+}
+function Qr(e) {
+  return e === "nw" || e === "se" ? "nwse-resize" : e === "ne" || e === "sw" ? "nesw-resize" : e === "n" || e === "s" ? "ns-resize" : e === "e" || e === "w" ? "ew-resize" : "grab";
+}
+function It(e) {
+  const t = document.createElement("div");
+  if (e === "rotate") {
+    t.style.cssText = [
+      "position:relative",
+      "display:flex",
+      "align-items:center",
+      "justify-content:center",
+      "width:16px",
+      "height:32px",
+      "cursor:grab"
+    ].join(";");
+    const n = document.createElement("div");
+    n.style.cssText = "position:absolute;bottom:0;left:50%;transform:translateX(-50%);width:2px;height:24px;background:var(--color-primary-600);", t.appendChild(n);
+    const o = document.createElement("div");
+    o.style.cssText = [
+      "position:absolute",
+      "top:0",
+      "left:50%",
+      "transform:translateX(-50%)",
+      "width:16px",
+      "height:16px",
+      "background:#ffffff",
+      "border:2px solid var(--color-primary-600)",
+      "border-radius:50%",
+      "box-shadow:0 1px 3px rgba(0,0,0,0.35)",
+      "display:flex",
+      "align-items:center",
+      "justify-content:center"
+    ].join(";");
+    const r = document.createElement("div");
+    return r.style.cssText = "width:6px;height:6px;background:var(--color-primary-600);border-radius:50%;", o.appendChild(r), t.appendChild(o), t;
+  }
+  return t.style.cssText = [
+    "width:12px",
+    "height:12px",
+    "background:#ffffff",
+    "border:2px solid var(--color-primary-600)",
+    "border-radius:3px",
+    `cursor:${Qr(e)}`,
+    "box-shadow:0 1px 3px rgba(0,0,0,0.35)"
+  ].join(";"), t;
+}
+function es({ map: e, features: t }) {
+  const { dataStore: n, uiStore: o } = Le(), r = he((p) => p.selectedIds), s = W((p) => p.transformActive), i = W((p) => p.setTransformDragging), l = $(t);
+  l.current = t;
+  const [u, c] = le(null), v = $(null);
+  v.current = u;
+  const d = $(0), g = r.join(",");
+  K(() => {
+    c(null), d.current = 0;
+  }, [g]);
+  const w = $(null), C = $(null), T = $([]);
+  function F() {
+    T.current.forEach((p) => p.remove()), T.current = [];
+  }
+  function k(p) {
+    const f = /* @__PURE__ */ new Map();
+    for (const b of p) f.set(String(b.id ?? ""), b.geometry);
+    Vt(e, f);
+  }
+  function N(p) {
+    const f = T.current;
+    if (f.length === 9) {
+      for (let b = 0; b < 4; b++) f[b].setLngLat(p.corners[b]);
+      for (let b = 0; b < 4; b++) f[4 + b].setLngLat(p.edges[b]);
+      f[8].setLngLat(p.rotateHandle);
+    }
+  }
+  const P = $(null);
+  K(() => {
+    if (!s || t.length === 0) return;
+    F();
+    const p = v.current ?? it(t), f = ["nw", "ne", "se", "sw"], b = ["n", "e", "s", "w"], M = [];
+    p.corners.forEach((A, E) => {
+      const a = It(f[E]), x = new De.Marker({ element: a, draggable: !1 }).setLngLat(A).addTo(e);
+      a.addEventListener("mousedown", (y) => D(y, E, !1)), M.push(x);
+    }), p.edges.forEach((A, E) => {
+      const a = It(b[E]), x = new De.Marker({ element: a, draggable: !1 }).setLngLat(A).addTo(e);
+      a.addEventListener("mousedown", (y) => D(y, E, !0)), M.push(x);
+    });
+    {
+      const A = It("rotate"), E = new De.Marker({ element: A, anchor: "bottom", draggable: !1 }).setLngLat(p.rotateHandle).addTo(e);
+      A.addEventListener("mousedown", (a) => q(a)), M.push(E);
+    }
+    return T.current = M, () => {
+      F();
+    };
+  }, [s, g, u, e]), K(() => {
+    function p(S) {
+      const L = e.getCanvasContainer().getBoundingClientRect(), B = e.unproject([S.clientX - L.left, S.clientY - L.top]);
+      return [B.lng, B.lat];
+    }
+    const f = ze(E);
+    let b = null;
+    function M(S) {
+      P.current && (S.preventDefault(), b = { clientX: S.clientX, clientY: S.clientY }, f.schedule(S));
+    }
+    function A(S) {
+      var L;
+      S.key !== "Shift" && S.key !== "Alt" || ((L = P.current) == null ? void 0 : L.type) !== "scale" || !b || (S.preventDefault(), f.schedule({ ...b, shiftKey: S.shiftKey, altKey: S.altKey }));
+    }
+    function E(S) {
+      const L = P.current;
+      if (!L) return;
+      const [B, V] = p(S), j = n.getState().geometryMode;
+      if (L.type === "move") {
+        if (!L.moving) {
+          const H = e.getCanvasContainer().getBoundingClientRect();
+          if (Math.hypot(S.clientX - H.left - L.startPoint.x, S.clientY - H.top - L.startPoint.y) < Vr) return;
+          L.moving = !0, i(!0);
+        }
+        const h = j === "visual", I = zr(L.startLngLat, [B, V], h), O = L.initialFeatures.map((H) => ({ ...H, geometry: $t(H.geometry, I, h) })), z = L.initialBbox, G = {
+          corners: st(z.corners, I, h),
+          edges: st(z.edges, I, h),
+          center: st([z.center], I, h)[0],
+          rotateHandle: st([z.rotateHandle], I, h)[0]
+        };
+        w.current = O, C.current = G, k(O), N(G);
+      } else if (L.type === "rotate") {
+        const h = L.center, I = Te(h[1]), O = V - h[1], z = j === "visual" ? (B - h[0]) * I : B - h[0], H = (Math.atan2(O, z) - L.initialAngle) * (180 / Math.PI), te = L.initialFeatures.map(
+          (ne) => j === "visual" ? Po(ne, h, 1, 1, H) : ir(ne, H, { pivot: h })
+        ), Z = {
+          corners: kt(L.initialBbox.corners, h, H),
+          edges: kt(L.initialBbox.edges, h, H),
+          center: h,
+          rotateHandle: kt([L.initialBbox.rotateHandle], h, H)[0]
+        };
+        w.current = te, C.current = Z, k(te), N(Z);
+      } else if (L.type === "scale") {
+        const h = L.rotationAngle, I = qr({
+          initialBbox: L.initialBbox,
+          origin: L.origin,
+          startLngLat: L.startLngLat,
+          edgeIndex: L.edgeIndex,
+          rotationAngle: h
+        }, [B, V], S.shiftKey, S.altKey), O = Jr(L.initialFeatures, L.initialBbox, I, h);
+        w.current = O.features, C.current = O.box, k(O.features), N(O.box);
+      }
+    }
+    function a() {
+      f.flush();
+      const S = P.current;
+      if (!S) return;
+      const L = w.current, B = C.current, V = S.type === "rotate";
+      if (P.current = null, b = null, w.current = null, C.current = null, e.dragPan.enable(), i(!1), S.type === "move" && L) {
+        const j = e.getContainer(), h = (I) => I.stopPropagation();
+        j.addEventListener("click", h, !0), setTimeout(() => j.removeEventListener("click", h, !0), 0);
+      }
+      if (L && (n.getState().takeSnapshot(), n.getState().updateFeatures(Eo(
+        n.getState().features,
+        L.flatMap((j) => j.id == null || j.id === "" ? [] : [{ id: String(j.id), geometry: j.geometry }]),
+        o.getState().topoEditEnabled
+      ))), B) {
+        if (V) {
+          const j = B.center, h = B.edges[1], I = Te(j[1]), O = (h[0] - j[0]) * I, z = h[1] - j[1];
+          d.current = Math.atan2(z, O) * (180 / Math.PI);
+        }
+        c(B);
+      }
+    }
+    function x(S, L, B) {
+      S.preventDefault(), S.stopPropagation(), e.dragPan.disable();
+      const V = v.current ?? it(l.current), [j, h] = p(S), I = B ? V.edges[(L + 2) % 4] : V.corners[(L + 2) % 4];
+      P.current = {
+        type: "scale",
+        initialFeatures: structuredClone(l.current),
+        initialBbox: V,
+        rotationAngle: d.current,
+        origin: I,
+        startLngLat: [j, h],
+        edgeIndex: B ? L : void 0
+      }, i(!0);
+    }
+    function y(S) {
+      S.preventDefault(), S.stopPropagation(), e.dragPan.disable();
+      const L = v.current ?? it(l.current), B = L.center, [V, j] = p(S), h = n.getState().geometryMode, I = Te(B[1]), O = j - B[1], z = h === "visual" ? (V - B[0]) * I : V - B[0];
+      P.current = {
+        type: "rotate",
+        initialFeatures: structuredClone(l.current),
+        initialBbox: L,
+        rotationAngle: d.current,
+        center: B,
+        initialAngle: Math.atan2(O, z)
+      }, i(!0);
+    }
+    function m(S) {
+      if (P.current || S.button !== 0 || S.shiftKey || S.altKey || S.ctrlKey || S.metaKey || S.target !== e.getCanvas()) return;
+      const L = o.getState();
+      if (!L.transformActive || L.readonly || L.editingMode !== "none" || L.vertexEditActive) return;
+      const B = l.current;
+      if (B.length === 0) return;
+      const V = v.current ?? it(B), j = e.getCanvasContainer().getBoundingClientRect(), h = { x: S.clientX - j.left, y: S.clientY - j.top };
+      Hr(h, V.corners.map((I) => e.project(I)), Xr) && (S.preventDefault(), S.stopPropagation(), e.dragPan.disable(), P.current = {
+        type: "move",
+        initialFeatures: structuredClone(B),
+        initialBbox: V,
+        rotationAngle: d.current,
+        startLngLat: p(S),
+        startPoint: h,
+        moving: !1
+      });
+    }
+    const R = e.getContainer();
+    return R.addEventListener("mousedown", m, !0), _.current.handleScaleStart = x, _.current.handleRotateStart = y, document.addEventListener("mousemove", M), document.addEventListener("mouseup", a), document.addEventListener("keydown", A), document.addEventListener("keyup", A), () => {
+      f.cancel(), R.removeEventListener("mousedown", m, !0), document.removeEventListener("mousemove", M), document.removeEventListener("mouseup", a), document.removeEventListener("keydown", A), document.removeEventListener("keyup", A);
+    };
+  }, [e, n, o, i]);
+  const _ = $({
+    handleScaleStart: () => {
+    },
+    handleRotateStart: () => {
+    }
+  });
+  function D(p, f, b) {
+    _.current.handleScaleStart(p, f, b);
+  }
+  function q(p) {
+    _.current.handleRotateStart(p);
+  }
+  return null;
+}
+function ts({ map: e, feature: t, onDone: n }) {
+  const o = he((d) => d.updateFeature), [r, s] = le(
+    t.properties.name ?? ""
+  ), [i, l] = le(() => {
+    const d = t.geometry.coordinates, g = e.project(d);
+    return { x: g.x, y: g.y };
+  }), u = $(null);
+  K(() => {
+    const d = t.geometry.coordinates, g = () => {
+      const w = e.project(d);
+      l({ x: w.x, y: w.y });
+    };
+    return e.on("move", g), e.on("zoom", g), e.on("resize", g), () => {
+      e.off("move", g), e.off("zoom", g), e.off("resize", g);
+    };
+  }, [e, t.geometry]), K(() => {
+    const d = setTimeout(() => {
+      var g, w;
+      (g = u.current) == null || g.focus(), (w = u.current) == null || w.select();
+    }, 0);
+    return () => clearTimeout(d);
+  }, []);
+  function c() {
+    const d = r;
+    d !== (t.properties.name ?? "") && o(t.id, {
+      properties: { ...t.properties, name: d }
+    }), n();
+  }
+  const v = e.getCanvasContainer();
+  return Ze(
+    /* @__PURE__ */ X(
+      "div",
+      {
+        "data-elm-theme": !0,
+        style: {
+          position: "absolute",
+          left: i.x,
+          top: i.y,
+          transform: "translate(-50%, -50%)",
+          zIndex: 500,
+          pointerEvents: "auto"
+        },
+        onMouseDown: (d) => d.stopPropagation(),
+        onDoubleClick: (d) => d.stopPropagation(),
+        onContextMenu: (d) => d.stopPropagation(),
+        children: /* @__PURE__ */ fe("div", { className: "grid items-center justify-items-center bg-white/95 backdrop-blur-md border border-slate-800 text-slate-800 rounded px-3 py-1.5 text-sm font-medium shadow-lg", children: [
+          /* @__PURE__ */ X(
+            "div",
+            {
+              className: "invisible whitespace-pre pointer-events-none col-start-1 row-start-1 min-w-[12px] px-[2px] leading-tight",
+              "aria-hidden": !0,
+              children: r + " "
+            }
+          ),
+          /* @__PURE__ */ X(
+            "textarea",
+            {
+              ref: u,
+              value: r,
+              onChange: (d) => s(d.target.value),
+              onKeyDown: (d) => {
+                d.key === "Enter" && !d.shiftKey ? (d.preventDefault(), c()) : d.key === "Escape" && (d.preventDefault(), n());
+              },
+              onBlur: c,
+              className: "col-start-1 row-start-1 bg-transparent outline-none resize-none overflow-hidden whitespace-pre text-center leading-tight min-w-0 min-h-0 px-[2px] w-full h-full m-0 border-none",
+              rows: 1
+            }
+          )
+        ] })
+      }
+    ),
+    v
+  );
+}
+function ns([e, t, n, o], r, s, i, l) {
+  return e >= r && n <= i && t >= s && o <= l;
+}
+function os(e, t) {
+  if (e === t) return !0;
+  if (e.length !== t.length) return !1;
+  const n = new Set(e);
+  return t.every((o) => n.has(o));
+}
+function rs({ map: e, onVertexBoxSelect: t }) {
+  const { dataStore: n } = Le(), o = W((d) => d.editingMode), r = W((d) => d.vertexEditActive), s = W((d) => d.transformActive), i = W((d) => d.readonly), l = $(o), u = $(r), c = $(s), v = $(i);
+  return l.current = o, u.current = r, c.current = s, v.current = i, K(() => {
+    const d = e.getCanvas(), g = e.getContainer(), w = (C) => {
+      if (!C.shiftKey || v.current || c.current) return;
+      const T = u.current;
+      if (!T && l.current !== "none") return;
+      C.preventDefault(), e.dragPan.disable(), e.boxZoom.disable();
+      const F = C.clientX, k = C.clientY, N = g.getBoundingClientRect(), P = [...n.getState().selectedIds], _ = document.createElement("div");
+      _.style.cssText = [
+        "position:absolute",
+        "pointer-events:none",
+        "border:2px solid var(--color-primary-500)",
+        "background:color-mix(in srgb, var(--color-primary-500) 8%, transparent)",
+        "z-index:9999",
+        "border-radius:2px"
+      ].join(";"), g.appendChild(_);
+      let D = !1, q = 0;
+      function p(a) {
+        const x = Math.min(F, a.clientX) - N.left, y = Math.min(k, a.clientY) - N.top, m = Math.max(F, a.clientX) - N.left, R = Math.max(k, a.clientY) - N.top, S = e.unproject([x, y]), L = e.unproject([m, R]);
+        return {
+          boxW: S.lng,
+          boxE: L.lng,
+          boxN: S.lat,
+          boxS: L.lat,
+          overlayX: x,
+          overlayY: y,
+          overlayW: m - x,
+          overlayH: R - y
+        };
+      }
+      function f(a) {
+        const { boxW: x, boxE: y, boxN: m, boxS: R } = p(a), S = n.getState(), L = new Set(S.groups.filter((h) => h.hidden).map((h) => h.id)), B = S.features.filter(
+          (h) => !h.hidden && (!h.groupId || !L.has(h.groupId))
+        ), V = {
+          type: "Feature",
+          properties: {},
+          geometry: {
+            type: "Polygon",
+            coordinates: [[
+              [x, R],
+              [y, R],
+              [y, m],
+              [x, m],
+              [x, R]
+            ]]
+          }
+        }, j = [];
+        for (const h of B) {
+          if (h.geometry.type === "Point") {
+            const [te, Z] = h.geometry.coordinates;
+            te >= x && te <= y && Z >= R && Z <= m && j.push(h.id);
+            continue;
+          }
+          const I = h.bbox ?? Nn(h.geometry), [O, z, G, H] = I;
+          if (G >= x && O <= y && H >= R && z <= m) {
+            if (ns(I, x, R, y, m)) {
+              j.push(h.id);
+              continue;
+            }
+            try {
+              lr(V, h) && j.push(h.id);
+            } catch {
+              j.push(h.id);
+            }
+          }
+        }
+        return j;
+      }
+      function b(a) {
+        const x = new Set(P);
+        a.forEach((R) => x.add(R));
+        const y = Array.from(x), m = n.getState();
+        os(m.selectedIds, y) && m.selectedGroupId === null || m.setSelection(y);
+      }
+      function M(a) {
+        const x = n.getState().selectedIds[0];
+        if (!x) return null;
+        const y = n.getState().features.find((j) => j.id === x);
+        if (!y) return null;
+        let m;
+        if (y.geometry.type === "LineString")
+          m = y.geometry.coordinates;
+        else if (y.geometry.type === "Polygon")
+          m = y.geometry.coordinates[0].slice(0, -1);
+        else
+          return null;
+        const { boxW: R, boxE: S, boxN: L, boxS: B } = p(a), V = [];
+        for (let j = 0; j < m.length; j++) {
+          const [h, I] = m[j];
+          h >= R && h <= S && I >= B && I <= L && V.push(j);
+        }
+        return { id: x, indices: V };
+      }
+      const A = (a) => {
+        const x = Math.abs(a.clientX - F), y = Math.abs(a.clientY - k);
+        if (!D && x < 5 && y < 5) return;
+        D = !0;
+        const { overlayX: m, overlayY: R, overlayW: S, overlayH: L } = p(a);
+        _.style.left = `${m}px`, _.style.top = `${R}px`, _.style.width = `${S}px`, _.style.height = `${L}px`, !T && Date.now() - q > 30 && (b(f(a)), q = Date.now());
+      }, E = (a) => {
+        if (_.remove(), e.dragPan.enable(), e.boxZoom.enable(), window.removeEventListener("mousemove", A), window.removeEventListener("mouseup", E), !D) return;
+        if (T) {
+          const y = M(a);
+          y && y.indices.length > 0 && t && t(y.id, y.indices);
+          return;
+        }
+        const x = f(a);
+        if (b(x), x.length === 0 && P.length === 1 && t) {
+          const y = n.getState().features.find((m) => m.id === P[0]);
+          if (y && (y.geometry.type === "LineString" || y.geometry.type === "Polygon")) {
+            const m = M(a);
+            m && m.indices.length > 0 && t(m.id, m.indices);
+          }
+        }
+      };
+      window.addEventListener("mousemove", A), window.addEventListener("mouseup", E);
+    };
+    return d.addEventListener("mousedown", w), () => d.removeEventListener("mousedown", w);
+  }, [e, n, t]), null;
+}
+function ss(e) {
+  return e && "style" in e ? e : null;
+}
+function is(e) {
+  const t = $(null), n = $(!1), o = $({ value: "", priority: "" });
+  function r(l, u, c = "important") {
+    l.style.setProperty("cursor", u, c);
+  }
+  K(() => {
+    if (e) return;
+    function l(u) {
+      if (!n.current) return;
+      const c = t.current;
+      if (!c) return;
+      const v = u.ctrlKey || u.metaKey, d = u.altKey;
+      v || d ? r(c, d ? "copy" : "move") : r(c, o.current.value, o.current.priority);
+    }
+    return window.addEventListener("keydown", l), window.addEventListener("keyup", l), () => {
+      window.removeEventListener("keydown", l), window.removeEventListener("keyup", l);
+    };
+  }, [e]);
+  const s = ve((l, u, c) => {
+    const v = ss(l), d = v !== null && v === t.current && n.current;
+    t.current = v, n.current = !0, c !== void 0 ? o.current = { value: c, priority: "" } : d || (o.current = {
+      value: (v == null ? void 0 : v.style.getPropertyValue("cursor")) ?? "",
+      priority: (v == null ? void 0 : v.style.getPropertyPriority("cursor")) ?? ""
+    });
+    const g = u;
+    v && g && (g.ctrlKey || g.metaKey || g.altKey) ? r(v, g.altKey ? "copy" : "move") : v && c !== void 0 && r(v, c, "");
+  }, []), i = ve((l) => {
+    n.current = !1, t.current && (l !== void 0 ? r(t.current, l, "") : r(t.current, o.current.value, o.current.priority), t.current = null), o.current = { value: "", priority: "" };
+  }, []);
+  return Bt(() => ({ enter: s, leave: i }), [s, i]);
+}
+let Ye = { x: -1, y: -1, ctrlKey: !1, metaKey: !1, altKey: !1 };
+if (typeof window < "u") {
+  window.addEventListener("mousemove", (n) => {
+    Ye = { x: n.clientX, y: n.clientY, ctrlKey: n.ctrlKey, metaKey: n.metaKey, altKey: n.altKey };
+  }, { capture: !0, passive: !0 });
+  const e = (n) => {
+    Ye = { x: n.clientX, y: n.clientY, ctrlKey: n.ctrlKey, metaKey: n.metaKey, altKey: n.altKey };
+  };
+  window.addEventListener("pointerdown", e, { capture: !0, passive: !0 }), window.addEventListener("mousedown", e, { capture: !0, passive: !0 });
+  const t = (n) => {
+    Ye = { ...Ye, ctrlKey: n.ctrlKey, metaKey: n.metaKey, altKey: n.altKey };
+  };
+  window.addEventListener("keydown", t, { capture: !0 }), window.addEventListener("keyup", t, { capture: !0 });
+}
+function cs() {
+  return Ye;
+}
+function $e(e, t, n) {
+  if (!n.every((o) => e.getLayer(o))) return [];
+  try {
+    return e.queryRenderedFeatures(t, { layers: n });
+  } catch {
+    return [];
+  }
+}
+function ls(e) {
+  const t = "elm-drag-ghost";
+  e.getSource(t) || (e.addSource(t, { type: "geojson", data: { type: "FeatureCollection", features: [] } }), e.addLayer({
+    id: "elm-drag-ghost-fill",
+    type: "fill",
+    source: t,
+    filter: ["in", ["geometry-type"], ["literal", ["Polygon", "MultiPolygon"]]],
+    paint: { "fill-opacity": 0.18 }
+  }), e.addLayer({
+    id: "elm-drag-ghost-line",
+    type: "line",
+    source: t,
+    filter: [
+      "in",
+      ["geometry-type"],
+      ["literal", ["LineString", "MultiLineString", "Polygon", "MultiPolygon"]]
+    ],
+    paint: { "line-opacity": 0.6, "line-width": 2, "line-dasharray": [3, 3] }
+  }), e.addLayer({
+    id: "elm-drag-ghost-point",
+    type: "circle",
+    source: t,
+    filter: ["in", ["geometry-type"], ["literal", ["Point", "MultiPoint"]]],
+    paint: {
+      "circle-radius": 7,
+      "circle-opacity": 0.6,
+      "circle-stroke-color": "#ffffff",
+      "circle-stroke-width": 2
+    }
+  }), Ne(e, Qn));
+}
+function as(e) {
+  for (const t of ["elm-drag-ghost-point", "elm-drag-ghost-line", "elm-drag-ghost-fill"])
+    e.getLayer(t) && e.removeLayer(t);
+  e.getSource("elm-drag-ghost") && e.removeSource("elm-drag-ghost");
+}
+const Qn = [
+  ["elm-drag-ghost-fill", "fill-color", (e) => e[500]],
+  ["elm-drag-ghost-line", "line-color", (e) => e[500]],
+  ["elm-drag-ghost-point", "circle-color", (e) => e[500]]
+];
+function us({ map: e }) {
+  qe(e, Qn);
+  const { dataStore: t, uiStore: n } = Le(), o = Ue(), r = he((a) => a.features), s = he((a) => a.selectedIds), i = W((a) => a.vertexEditActive), l = W((a) => a.transformActive), u = W((a) => a.editingMode), c = W((a) => a.readonly);
+  K(() => {
+    ct();
+  }, [r.length, i]), K(() => {
+    if (!i) return;
+    const a = t.getState(), x = a.selectedIds.length === 1 ? a.features.find((m) => m.id === a.selectedIds[0]) : void 0, y = Co(x);
+    y && o({ type: "warning", message: y });
+  }, [i, t, o]);
+  const v = $(!1);
+  K(() => {
+    if (!l || v.current) return;
+    const a = t.getState(), x = a.selectedIds.length === 1 ? a.features.find((y) => y.id === a.selectedIds[0]) : void 0;
+    (x == null ? void 0 : x._drawType) === "route" && (o({ type: "warning", message: "Transforming may break road alignment." }), v.current = !0);
+  }, [l, s, t, o]);
+  const d = $(null), g = $(null), [w, C] = le(null), [T, F] = le(null), [k, N] = le(null);
+  K(() => {
+    !i && k && N(null);
+  }, [i, k]);
+  const P = is(c), _ = Jo();
+  K(() => {
+    if (c) return;
+    const a = e.getCanvasContainer(), x = (y) => {
+      var I, O;
+      y.preventDefault();
+      const m = a.getBoundingClientRect(), R = [y.clientX - m.left, y.clientY - m.top], S = $e(e, R, Be);
+      if (S.length === 0) return;
+      const L = String(S[0].id ?? ((I = S[0].properties) == null ? void 0 : I.id) ?? "");
+      if (!L) return;
+      const B = t.getState(), V = B.features.find((z) => z.id === L);
+      if (!V) return;
+      const j = B.selectedIds;
+      j.length >= 2 && j.includes(L) || B.selectFeature(L);
+      const h = V.geometry.type === "Point" && ((O = V.properties) == null ? void 0 : O._isText) !== "true";
+      _.open(y.clientX, y.clientY, {
+        feature: V,
+        requestPreciseCoords: h ? () => F(L) : void 0
+      });
+    };
+    return a.addEventListener("contextmenu", x), () => {
+      a.removeEventListener("contextmenu", x);
+    };
+  }, [c, t, e, _]), K(() => {
+    const a = u !== "none", x = (R = !0) => {
+      bt(e, null, d.current), d.current = null, R && Pt(e, null), ct(), P.leave(a ? void 0 : "");
+    }, y = (R) => {
+      var V, j;
+      if (e.dragPan.isActive() || (V = g.current) != null && V.dragging) return;
+      const S = $e(e, R.point, Be), L = S.length > 0 ? String(S[0].id ?? ((j = S[0].properties) == null ? void 0 : j.id)) : null;
+      if (L === d.current) return;
+      if (!L) {
+        x();
+        return;
+      }
+      Gt() !== L && Pt(e, null), a || bt(e, L, d.current), d.current = L;
+      const B = t.getState().features.find((h) => h.id === L);
+      B ? Nr(B, n, R.originalEvent) : ct(), P.enter(e.getCanvas(), R.originalEvent, a ? void 0 : "pointer");
+    };
+    e.on("mousemove", y);
+    const m = () => x();
+    return e.on("mouseout", m), () => {
+      e.off("mousemove", y), e.off("mouseout", m);
+      try {
+        x(!1);
+      } catch {
+      }
+    };
+  }, [u, e, t, n, P]);
+  const D = $(r);
+  K(() => {
+    const a = D.current;
+    if (D.current = r, r.length <= a.length) return;
+    const y = e.getCanvas().getBoundingClientRect(), m = cs();
+    if (m.x < y.left || m.x > y.right || m.y < y.top || m.y > y.bottom) return;
+    const R = new Set(a.map((h) => h.id)), S = new Set(r.filter((h) => !R.has(h.id)).map((h) => h.id)), L = [m.x - y.left, m.y - y.top], B = () => {
+      var h;
+      try {
+        const I = e.unproject(L), O = $e(e, e.project(I), Be)[0], z = O ? String(O.id ?? ((h = O.properties) == null ? void 0 : h.id)) : null;
+        z && S.has(z) && Pt(e, z), e.fire("mousemove", {
+          // A real Point: a plain { x, y } makes every listener's
+          // queryRenderedFeatures(e.point) hit the whole viewport, so the
+          // hover tooltip named whichever feature was on top (not under the cursor).
+          // `map.project` returns the map's own Point class (a `new Point` from the
+          // peer copy fails maplibre's instanceof check when the host bundles its own
+          // maplibre, e.g. MapTiler SDK) and avoids a named import from CJS maplibre-gl.
+          point: e.project(I),
+          lngLat: I,
+          originalEvent: new MouseEvent("mousemove", {
+            clientX: m.x,
+            clientY: m.y,
+            ctrlKey: m.ctrlKey,
+            metaKey: m.metaKey,
+            altKey: m.altKey
+          })
+        });
+      } catch {
+      }
+    };
+    let V = !1;
+    const j = () => {
+      V || B();
+    };
+    return e.once("idle", j), () => {
+      V = !0, e.off("idle", j);
+    };
+  }, [r.length, e]), K(() => {
+    if (c || u !== "none") return;
+    const a = (x) => {
+      var L;
+      if (Gn()) return;
+      const y = $e(e, x.point, Be), m = t.getState();
+      if (y.length === 0) {
+        i ? n.getState().setVertexEditActive(!1) : m.clearSelection();
+        return;
+      }
+      const R = y[0], S = String(R.id ?? ((L = R.properties) == null ? void 0 : L.id) ?? "");
+      if (S)
+        if (x.originalEvent.shiftKey) {
+          const B = m.selectedIds;
+          B.includes(S) ? m.setSelection(B.filter((V) => V !== S)) : m.setSelection([...B, S]);
+        } else
+          m.selectedIds.length === 1 && m.selectedIds[0] === S || m.selectFeature(S);
+    };
+    return e.on("click", a), () => {
+      e.off("click", a);
+    };
+  }, [c, u, i, t, n, e]), K(() => {
+    if (c || u !== "none") return;
+    const a = (x) => {
+      var S, L;
+      const y = $e(e, x.point, Be);
+      if (y.length === 0) return;
+      x.preventDefault();
+      const m = String(y[0].id ?? ((S = y[0].properties) == null ? void 0 : S.id) ?? "");
+      if (!m) return;
+      const R = t.getState().features.find((B) => B.id === m);
+      if (R) {
+        if (((L = R.properties) == null ? void 0 : L._isText) === "true") {
+          t.getState().selectFeature(m), C(m);
+          return;
+        }
+        if (t.getState().selectFeature(m), ht(R.geometry)) {
+          const B = Dr(R.geometry, [x.lngLat.lng, x.lngLat.lat]);
+          n.getState().setSelectedPartIndex(B);
+        } else
+          n.getState().setSelectedPartIndex(null);
+        n.getState().setVertexEditActive(!0);
+      }
+    };
+    return e.on("dblclick", a), () => {
+      e.off("dblclick", a);
+    };
+  }, [c, u, t, n, e]), K(() => {
+    if (c || i) return;
+    const x = u !== "none", y = (m) => {
+      var re;
+      if (m.originalEvent.shiftKey) return;
+      const R = m.originalEvent.altKey, S = m.originalEvent.ctrlKey || m.originalEvent.metaKey;
+      if (x && !R && !S) return;
+      const L = $e(e, m.point, Be);
+      if (L.length === 0) return;
+      const B = String(L[0].id ?? ((re = L[0].properties) == null ? void 0 : re.id) ?? "");
+      if (!B) return;
+      const V = t.getState();
+      if (V.selectedIds.includes(B) && V.selectedIds.length >= 2 && !R && !S) return;
+      V.selectedIds.includes(B) || V.selectFeature(B);
+      const h = t.getState().selectedIds, I = h.includes(B) ? h : [B], O = new Map(
+        I.flatMap((J) => {
+          const ce = V.features.find((U) => U.id === J);
+          return ce ? [[J, ce.geometry]] : [];
+        })
+      ), z = R, G = V.geometryMode, H = [m.lngLat.lng, m.lngLat.lat], te = G === "visual" ? me(H) : H;
+      e.dragPan.disable(), g.current = {
+        featureIds: I,
+        startLngLat: H,
+        startProjected: te,
+        geometryMode: G,
+        startCoords: O,
+        dragging: !1,
+        duplicate: z
+      };
+      const Z = /* @__PURE__ */ new Map(), ne = ze((J, ce) => {
+        const U = g.current;
+        if (!U) return;
+        const Y = J - U.startLngLat[0], ee = ce - U.startLngLat[1];
+        let oe;
+        if (U.geometryMode === "visual") {
+          const Q = [U.startLngLat[0] + Y, U.startLngLat[1] + ee], de = me(Q);
+          oe = [de[0] - U.startProjected[0], de[1] - U.startProjected[1]];
+        } else
+          oe = [Y, ee];
+        for (const Q of U.featureIds) {
+          const de = U.startCoords.get(Q);
+          de && Z.set(Q, $t(de, oe, U.geometryMode === "visual"));
+        }
+        if (U.duplicate) {
+          const Q = e.getSource("elm-drag-ghost");
+          if (Q) {
+            const de = t.getState(), ue = [];
+            for (const Re of U.featureIds) {
+              const xe = de.features.find((Je) => Je.id === Re), Ee = Z.get(Re);
+              xe && Ee && ue.push({
+                type: "Feature",
+                properties: {},
+                geometry: Ee
+              });
+            }
+            try {
+              Q.setData({ type: "FeatureCollection", features: ue });
+            } catch {
+            }
+          }
+        } else
+          Vt(e, Z);
+      }), se = (J) => {
+        const ce = g.current;
+        if (!ce) return;
+        const U = J.lngLat.lng - ce.startLngLat[0], Y = J.lngLat.lat - ce.startLngLat[1], ee = Math.hypot(U, Y);
+        !ce.dragging && ee < 1e-5 || (ce.dragging || (ce.dragging = !0, e.getCanvas().style.cursor = "grabbing", Ce(!0)), ne.schedule(J.lngLat.lng, J.lngLat.lat));
+      }, ie = () => {
+        ne.flush();
+        const J = g.current;
+        if (g.current = null, e.dragPan.enable(), J != null && J.dragging) {
+          const ce = Ge(n.getState().editingMode);
+          if (P.leave(ce), e.getCanvas().style.cursor = ce, bt(e, null, d.current), d.current = null, Ce(!1), Mr(), t.getState().takeSnapshot(), J.duplicate) {
+            const U = [];
+            for (const ee of J.featureIds) {
+              const oe = Z.get(ee);
+              oe && U.push({ sourceId: ee, geometry: oe });
+            }
+            t.getState().duplicateFeaturesAtPosition(U);
+            const Y = e.getSource("elm-drag-ghost");
+            Y == null || Y.setData({ type: "FeatureCollection", features: [] });
+          } else
+            t.getState().updateFeatures(J.featureIds.flatMap((U) => {
+              const Y = Z.get(U);
+              return Y ? [{ id: U, patch: { geometry: Y } }] : [];
+            }));
+        }
+        e.off("mousemove", se), e.off("mouseup", ie);
+      };
+      e.on("mousemove", se), e.on("mouseup", ie);
+    };
+    return e.on("mousedown", y), () => {
+      e.off("mousedown", y);
+    };
+  }, [c, u, i, t, n, e, P]);
+  const q = s.length === 1 ? r.find((a) => a.id === s[0]) ?? null : null, p = r.filter((a) => s.includes(a.id)), f = _.state && /* @__PURE__ */ X(
+    Bo,
+    {
+      x: _.state.x,
+      y: _.state.y,
+      data: _.state.data,
+      onClose: _.close
+    }
+  ), b = w ? r.find((a) => a.id === w) ?? null : null, M = b && /* @__PURE__ */ X(
+    ts,
+    {
+      map: e,
+      feature: b,
+      onDone: () => C(null)
+    }
+  ), A = T ? r.find((a) => a.id === T) ?? null : null, E = A && A.geometry.type === "Point" && /* @__PURE__ */ X(
+    Un,
+    {
+      map: e,
+      coords: A.geometry.coordinates,
+      onSave: (a) => {
+        t.getState().takeSnapshot(), t.getState().updateFeature(A.id, { geometry: { type: "Point", coordinates: Ve(A.geometry.coordinates, a) } });
+      },
+      onClose: () => F(null)
+    }
+  );
+  return c || u !== "none" ? /* @__PURE__ */ fe(lt, { children: [
+    f,
+    M,
+    E
+  ] }) : /* @__PURE__ */ fe(lt, { children: [
+    i && q && /* @__PURE__ */ X(
+      $r,
+      {
+        map: e,
+        feature: q,
+        initialSelectedIndices: k ?? void 0
+      }
+    ),
+    /* @__PURE__ */ X(
+      rs,
+      {
+        map: e,
+        onVertexBoxSelect: (a, x) => {
+          if (i && s.length === 1 && s[0] === a) {
+            N(x);
+            return;
+          }
+          t.getState().selectFeature(a), n.getState().setSelectedPartIndex(null), N(x), n.getState().setVertexEditActive(!0);
+        }
+      }
+    ),
+    l && !i && p.length >= 1 && /* @__PURE__ */ X(es, { map: e, features: p }),
+    f,
+    M,
+    E
+  ] });
+}
+const Me = "elm-snap", eo = [
+  ["elm-snap-vertex", "circle-color", (e) => e[500]]
+];
+function ds(e) {
+  e.getSource(Me) || (e.addSource(Me, { type: "geojson", data: Ie() }), e.addLayer({
+    id: "elm-snap-vertex",
+    type: "circle",
+    source: Me,
+    filter: ["==", ["get", "_kind"], "vertex"],
+    paint: {
+      "circle-radius": 6,
+      "circle-stroke-width": 2,
+      "circle-stroke-color": "#ffffff"
+    }
+  }), e.addLayer({
+    id: "elm-snap-edge",
+    type: "symbol",
+    source: Me,
+    filter: ["==", ["get", "_kind"], "edge"],
+    layout: {
+      "icon-image": "elm-snap-diamond",
+      "icon-size": 1,
+      "icon-allow-overlap": !0,
+      "icon-ignore-placement": !0
+    }
+  }), Ne(e, eo));
+}
+function fs(e) {
+  for (const t of ["elm-snap-edge", "elm-snap-vertex"])
+    e.getLayer(t) && e.removeLayer(t);
+  e.getSource(Me) && e.removeSource(Me);
+}
+const bn = /* @__PURE__ */ new WeakMap();
+function to(e, t) {
+  const n = e.hasImage("elm-snap-diamond");
+  if (n && bn.get(e) === t) return;
+  const o = 16, r = document.createElement("canvas");
+  r.width = o, r.height = o;
+  const s = r.getContext("2d");
+  if (!s) return;
+  s.clearRect(0, 0, o, o), s.save(), s.translate(o / 2, o / 2), s.rotate(Math.PI / 4), s.fillStyle = t, s.strokeStyle = "#ffffff", s.lineWidth = 2;
+  const i = 8;
+  s.fillRect(-i / 2, -i / 2, i, i), s.strokeRect(-i / 2, -i / 2, i, i), s.restore();
+  const l = s.getImageData(0, 0, o, o);
+  n ? e.updateImage("elm-snap-diamond", l) : e.addImage("elm-snap-diamond", l), bn.set(e, t);
+}
+function gs({ map: e }) {
+  const { uiStore: t, dataStore: n } = Le(), o = W((u) => u.editingMode), r = W((u) => u.snapEnabled), s = he((u) => u.features), i = W((u) => u.vertexEditActive), l = qe(e, eo);
+  return K(() => {
+    to(e, l[400]);
+    const u = o !== "none" || i, c = () => {
+      t.getState().snappedCoord && t.getState().setSnappedCoord(null);
+      const T = e.getSource(Me);
+      T == null || T.setData(Ie());
+    };
+    if (!u) {
+      c();
+      return;
+    }
+    const d = ze((T) => {
+      var D;
+      if (!r) {
+        c();
+        return;
+      }
+      const F = T.originalEvent;
+      if (F.metaKey || F.ctrlKey) {
+        c();
+        return;
+      }
+      const k = F.target;
+      if ((D = k == null ? void 0 : k.closest) != null && D.call(k, ".elm-midpoint-marker")) {
+        c();
+        return;
+      }
+      const N = Gt(), P = Vn(T.lngLat.lng, T.lngLat.lat, e, s, 15, new Set(N ? [N] : []));
+      if (!P) {
+        c();
+        return;
+      }
+      if (i && P.isVertex) {
+        const q = new Set(n.getState().selectedIds);
+        if (P.featureId && q.has(P.featureId)) {
+          c();
+          return;
+        }
+      }
+      t.getState().setSnappedCoord(P.lnglat);
+      const _ = e.getSource(Me);
+      _ == null || _.setData({
+        type: "FeatureCollection",
+        features: [{
+          type: "Feature",
+          properties: { _kind: P.isVertex ? "vertex" : "edge" },
+          geometry: { type: "Point", coordinates: P.lnglat }
+        }]
+      });
+    }), g = (T) => d.schedule(T), w = () => d.flush(), C = () => {
+      d.cancel(), c();
+    };
+    return e.on("mousemove", g), e.on("mouseout", C), window.addEventListener("pointerdown", w, !0), window.addEventListener("pointerup", w, !0), () => {
+      d.cancel(), e.off("mousemove", g), e.off("mouseout", C), window.removeEventListener("pointerdown", w, !0), window.removeEventListener("pointerup", w, !0);
+    };
+  }, [o, r, s, i, e, t, n, l]), null;
+}
+function ii({ map: e }) {
+  const t = he((n) => n.features);
+  return K(() => {
+    if (t.length === 0) return;
+    let n = 1 / 0, o = 1 / 0, r = -1 / 0, s = -1 / 0;
+    for (const i of t) {
+      const [l, u, c, v] = i.bbox || Nn(i.geometry);
+      l < n && (n = l), u < o && (o = u), c > r && (r = c), v > s && (s = v);
+    }
+    n !== 1 / 0 && e.fitBounds([[n, o], [r, s]], { padding: jt(e.getContainer()), maxZoom: 16, duration: 600 });
+  }, []), null;
+}
+function ys({ map: e }) {
+  const t = W((o) => o.boundaryAutofitBbox), n = W((o) => o.setBoundaryAutofitBbox);
+  return K(() => {
+    if (!t) return;
+    const [o, r, s, i] = t;
+    e.fitBounds([[s, o], [i, r]], { padding: jt(e.getContainer()), maxZoom: 10, duration: 1 }), n(null);
+  }, [t, n, e]), null;
+}
+const be = "elm-processing-preview", no = [
+  ["elm-processing-preview-fill", "fill-color", (e) => e[500]],
+  ["elm-processing-preview-line", "line-color", (e) => e[500]]
+];
+function ps(e) {
+  e.getSource(be) || (e.addSource(be, { type: "geojson", data: Ie() }), e.addLayer({
+    id: "elm-processing-preview-ghost",
+    type: "fill",
+    source: be,
+    filter: ["==", ["get", "_ghost"], !0],
+    paint: {
+      "fill-color": "#6b7280",
+      "fill-opacity": 0.07
+    }
+  }), e.addLayer({
+    id: "elm-processing-preview-ghost-line",
+    type: "line",
+    source: be,
+    filter: ["==", ["get", "_ghost"], !0],
+    paint: {
+      "line-color": "#6b7280",
+      "line-opacity": 0.35,
+      "line-width": 1.5,
+      "line-dasharray": [4, 4]
+    }
+  }), e.addLayer({
+    id: "elm-processing-preview-fill",
+    type: "fill",
+    source: be,
+    filter: ["!=", ["get", "_ghost"], !0],
+    paint: {
+      "fill-opacity": [
+        "case",
+        ["boolean", ["get", "_bufferNew"], !1],
+        0.12,
+        0.2
+      ]
+    }
+  }), e.addLayer({
+    id: "elm-processing-preview-line",
+    type: "line",
+    source: be,
+    filter: ["!=", ["get", "_ghost"], !0],
+    paint: {
+      "line-width": [
+        "case",
+        ["boolean", ["get", "_bufferNew"], !1],
+        2,
+        2.5
+      ],
+      "line-dasharray": [
+        "case",
+        ["boolean", ["get", "_bufferNew"], !1],
+        ["literal", [8, 5]],
+        ["literal", [1, 0]]
+      ]
+    }
+  }), Ne(e, no));
+}
+function hs(e) {
+  for (const t of [
+    "elm-processing-preview-line",
+    "elm-processing-preview-fill",
+    "elm-processing-preview-ghost-line",
+    "elm-processing-preview-ghost"
+  ])
+    e.getLayer(t) && e.removeLayer(t);
+  e.getSource(be) && e.removeSource(be);
+}
+function Ln(e, t) {
+  return { type: "Feature", properties: t, geometry: e };
+}
+function ms({ map: e }) {
+  qe(e, no);
+  const t = vt(), n = W((l) => l.editingMode), o = W((l) => l.geometryPreview), r = W((l) => l.bufferCreateNew), s = he((l) => l.selectedIds[0] ?? null), i = he((l) => {
+    var u;
+    return s ? ((u = l.features.find((c) => c.id === s)) == null ? void 0 : u.geometry) ?? null : null;
+  });
+  return K(() => {
+    const l = e.getSource(be);
+    if (!l) return;
+    if (!(n === "simplify-shape" || n === "smooth-shape" || n === "buffer-shape") || !o) {
+      l.setData({ type: "FeatureCollection", features: [] });
+      return;
+    }
+    if (!_t(o.type)) {
+      l.setData({ type: "FeatureCollection", features: [] });
+      return;
+    }
+    const c = n === "buffer-shape", v = c && !r && i && _t(i.type), d = [];
+    v && d.push(Ln(i, { _ghost: !0 })), d.push(
+      Ln(o, {
+        _bufferNew: c && r
+      })
+    ), l.setData({ type: "FeatureCollection", features: d });
+  }, [n, o, r, i, e, t]), null;
+}
+function oo(e, t, n) {
+  const [o, r] = le(null), [s, i] = le(t);
+  return s !== t && (i(t), r(null)), K(() => {
+    const l = (c) => {
+      n && r([c.lngLat.lng, c.lngLat.lat]);
+    }, u = () => r(null);
+    return e.on("mousemove", l), e.on("mouseout", u), () => {
+      e.off("mousemove", l), e.off("mouseout", u);
+    };
+  }, [e, n]), o;
+}
+const we = "#e74c3c", En = "#ff2d1a", Pn = "#c0392b", ye = "elm-measure-preview", Rt = [
+  "elm-measure-hit-line",
+  "elm-measure-hit-fill"
+];
+function vs(e) {
+  e.getSource(ye) || (e.addSource(ye, { type: "geojson", data: Ie() }), e.addLayer({
+    id: "elm-measure-area-fill",
+    type: "fill",
+    source: ye,
+    filter: ["all", ["==", ["get", "_kind"], "area"], ["==", ["geometry-type"], "Polygon"]],
+    paint: {
+      "fill-color": [
+        "case",
+        ["boolean", ["get", "_selected"], !1],
+        Pn,
+        ["boolean", ["get", "_hovered"], !1],
+        En,
+        we
+      ],
+      "fill-opacity": [
+        "case",
+        ["boolean", ["get", "_selected"], !1],
+        0.15,
+        ["boolean", ["get", "_hovered"], !1],
+        0.12,
+        0.08
+      ]
+    }
+  }), e.addLayer({
+    id: "elm-measure-live-area",
+    type: "fill",
+    source: ye,
+    filter: ["all", ["==", ["get", "_kind"], "live-area"], ["==", ["geometry-type"], "Polygon"]],
+    paint: { "fill-color": we, "fill-opacity": 0.08 }
+  }), e.addLayer({
+    id: "elm-measure-line",
+    type: "line",
+    source: ye,
+    filter: [
+      "all",
+      ["in", ["get", "_kind"], ["literal", ["segment", "live-line", "live-perimeter", "live-area"]]],
+      ["==", ["geometry-type"], "LineString"]
+    ],
+    paint: {
+      "line-color": [
+        "case",
+        ["boolean", ["get", "_selected"], !1],
+        Pn,
+        ["boolean", ["get", "_hovered"], !1],
+        En,
+        we
+      ],
+      "line-width": 3,
+      "line-opacity": [
+        "case",
+        ["boolean", ["get", "_selected"], !1],
+        1,
+        ["boolean", ["get", "_hovered"], !1],
+        1,
+        0.9
+      ],
+      // MapLibre dash values are MULTIPLES of line-width (not pixels). At
+      // line-width 3, [10, 6] would render as 30px dash / 18px gap — way
+      // longer than Leaflet's pixel-based "10 6". Divide by 3 to match.
+      "line-dasharray": [3.33, 2]
+    }
+  }), e.addLayer({
+    id: "elm-measure-ghost",
+    type: "line",
+    source: ye,
+    filter: ["==", ["get", "_kind"], "ghost"],
+    paint: {
+      "line-color": we,
+      "line-width": 3,
+      "line-opacity": 0.45,
+      // MapLibre dash values are MULTIPLES of line-width (not pixels). At
+      // line-width 3, [10, 6] would render as 30px dash / 18px gap — way
+      // longer than Leaflet's pixel-based "10 6". Divide by 3 to match.
+      "line-dasharray": [3.33, 2]
+    }
+  }), e.addLayer({
+    id: "elm-measure-close-hint",
+    type: "line",
+    source: ye,
+    filter: ["==", ["get", "_kind"], "close-hint"],
+    paint: {
+      "line-color": we,
+      "line-width": 2,
+      "line-opacity": 0.25,
+      // line-width is 2 here; pixel-equivalent of leaflet's "6 6" → [3, 3].
+      "line-dasharray": [3, 3]
+    }
+  }), e.addLayer({
+    id: "elm-measure-hit-line",
+    type: "line",
+    source: ye,
+    filter: ["==", ["get", "_kind"], "segment"],
+    paint: {
+      "line-color": we,
+      "line-width": 16,
+      "line-opacity": 0
+    }
+  }), e.addLayer({
+    id: "elm-measure-hit-fill",
+    type: "fill",
+    source: ye,
+    filter: ["all", ["==", ["get", "_kind"], "area"], ["==", ["geometry-type"], "Polygon"]],
+    paint: { "fill-color": we, "fill-opacity": 0 }
+  }), e.addLayer({
+    id: "elm-measure-vertex",
+    type: "circle",
+    source: ye,
+    filter: [
+      "all",
+      ["==", ["geometry-type"], "Point"],
+      ["!=", ["get", "_isFirst"], !0]
+    ],
+    paint: {
+      "circle-radius": 5,
+      "circle-color": we,
+      "circle-stroke-width": 2,
+      "circle-stroke-color": "#ffffff"
+    }
+  }), e.addLayer({
+    id: "elm-measure-first-vertex",
+    type: "circle",
+    source: ye,
+    filter: [
+      "all",
+      ["==", ["geometry-type"], "Point"],
+      ["==", ["get", "_isFirst"], !0]
+    ],
+    paint: {
+      "circle-radius": 5,
+      "circle-color": "#ffffff",
+      "circle-stroke-width": 2.5,
+      "circle-stroke-color": we
+    }
+  }));
+}
+function xs(e) {
+  for (const t of [
+    "elm-measure-first-vertex",
+    "elm-measure-vertex",
+    "elm-measure-hit-fill",
+    "elm-measure-hit-line",
+    "elm-measure-close-hint",
+    "elm-measure-ghost",
+    "elm-measure-line",
+    "elm-measure-live-area",
+    "elm-measure-area-fill"
+  ])
+    e.getLayer(t) && e.removeLayer(t);
+  e.getSource(ye) && e.removeSource(ye);
+}
+function ws(e, t) {
+  const n = e.getSource(ye);
+  n && n.setData({ type: "FeatureCollection", features: t });
+}
+let pe = null;
+function Ss(e, t, n) {
+  pe || (pe = document.createElement("div"), pe.className = "elm-feature-tooltip", pe.style.cssText = "position:fixed;pointer-events:none;z-index:10000;transform:translate(-50%,-100%);margin-top:-12px", document.body.appendChild(pe)), pe.textContent = e, ro(t, n);
+}
+function ro(e, t) {
+  pe && (pe.style.left = e + "px", pe.style.top = t + "px");
+}
+function Cn() {
+  pe == null || pe.remove(), pe = null;
+}
+function bs(e, t, n, o) {
+  try {
+    if (t === "distance" && e.length >= 2) return mt(_e(We(e)) * 1e3, n);
+    if (t === "area" && e.length >= 3) return Ht(dt(ut([[...e, e[0]]])), o);
+  } catch {
+  }
+  return null;
+}
+function so({
+  map: e,
+  position: t,
+  parts: n,
+  onRemove: o
+}) {
+  const r = $(null), [s] = le(() => document.createElement("div"));
+  return K(() => {
+    const i = new De.Marker({
+      element: s,
+      // 'left' anchor → the host's LEFT edge sits on the latlng. Combined
+      // with the offset, the pill begins 12px right of the underlying point.
+      anchor: "left",
+      offset: [12, 0]
+    }).setLngLat(t).addTo(e);
+    return r.current = i, () => {
+      i.remove(), r.current = null;
+    };
+  }, [e, s]), K(() => {
+    var i;
+    (i = r.current) == null || i.setLngLat(t);
+  }, [t[0], t[1]]), Ze(
+    /* @__PURE__ */ fe(
+      "div",
+      {
+        className: "elm-measure-label",
+        style: {
+          display: "inline-flex",
+          alignItems: "center",
+          gap: 7,
+          pointerEvents: o ? "auto" : "none",
+          userSelect: "none",
+          whiteSpace: "nowrap"
+        },
+        children: [
+          /* @__PURE__ */ fe("span", { children: [
+            /* @__PURE__ */ X("span", { style: { fontWeight: 600 }, children: n.value }),
+            /* @__PURE__ */ fe("span", { style: { fontWeight: 400, opacity: 0.85 }, children: [
+              " ",
+              n.unit
+            ] })
+          ] }),
+          o && /* @__PURE__ */ X(
+            "button",
+            {
+              className: "elm-measure-close",
+              onClick: (i) => {
+                i.stopPropagation(), o();
+              },
+              title: "Clear measurement",
+              style: { marginRight: "-5px" },
+              children: /* @__PURE__ */ fe("svg", { width: "10", height: "10", viewBox: "0 0 10 10", fill: "none", stroke: "rgba(255,255,255,0.8)", strokeWidth: "1.5", strokeLinecap: "round", children: [
+                /* @__PURE__ */ X("line", { x1: "1.5", y1: "1.5", x2: "8.5", y2: "8.5" }),
+                /* @__PURE__ */ X("line", { x1: "8.5", y1: "1.5", x2: "1.5", y2: "8.5" })
+              ] })
+            }
+          )
+        ]
+      }
+    ),
+    s
+  );
+}
+const Ls = ao(function({
+  map: t,
+  m: n
+}) {
+  const o = W((c) => c.removeMeasurement), { units: r } = ke(), s = { unit: r.length, display: r.display, precision: r.precision }, i = { unit: r.area, display: r.display, precision: r.precision }, l = Bt(() => {
+    try {
+      if (n.mode === "distance" && n.points.length >= 2)
+        return mt(_e(We(n.points)) * 1e3, s);
+      if (n.mode === "area" && n.points.length >= 3)
+        return Ht(dt(ut([n.points])), i);
+    } catch {
+    }
+    return null;
+  }, [n, s.unit, s.display, s.precision, i.unit, i.display, i.precision]), u = n.mode === "area" ? n.points[n.points.length - 2] : n.points[n.points.length - 1];
+  return !l || !u ? null : /* @__PURE__ */ X(
+    so,
+    {
+      map: t,
+      position: u,
+      parts: l,
+      onRemove: () => o(n.id)
+    }
+  );
+});
+function Es({ map: e }) {
+  const t = vt(), n = W((p) => p.editingMode), o = W((p) => p.measurePoints), r = W((p) => p.measureMode), s = W((p) => p.completedMeasurements), i = W((p) => p.selectedMeasurementId), l = W((p) => p.snappedCoord), u = W((p) => p.toggleMeasurementSelection), c = W((p) => p.setSelectedMeasurementId), v = oo(e, n, n === "measure"), { units: d } = ke(), g = { unit: d.length, display: d.display, precision: d.precision }, w = { unit: d.area, display: d.display, precision: d.precision }, [C, T] = le(null), F = n === "measure", k = F ? l ?? v : null, N = o.length > 0 ? o[o.length - 1] : null;
+  K(() => {
+    const p = [];
+    for (const f of s) {
+      const b = C === f.id, M = i === f.id;
+      if (f.mode === "distance") {
+        for (let E = 0; E < f.points.length - 1; E++)
+          p.push({
+            type: "Feature",
+            properties: { _kind: "segment", _id: f.id, _segIdx: E, _hovered: b, _selected: M },
+            geometry: { type: "LineString", coordinates: [f.points[E], f.points[E + 1]] }
+          });
+        f.points.forEach((E, a) => {
+          p.push({
+            type: "Feature",
+            properties: { _kind: "dot", _id: f.id, _isFirst: a === 0 },
+            geometry: { type: "Point", coordinates: E }
+          });
+        });
+      } else
+        p.push({
+          type: "Feature",
+          properties: { _kind: "area", _id: f.id, _hovered: b, _selected: M },
+          geometry: { type: "Polygon", coordinates: [f.points] }
+        }), p.push({
+          type: "Feature",
+          properties: { _kind: "segment", _id: f.id, _hovered: b, _selected: M },
+          geometry: { type: "LineString", coordinates: f.points }
+        }), f.points.slice(0, -1).forEach((E, a) => {
+          p.push({
+            type: "Feature",
+            properties: { _kind: "dot", _id: f.id, _isFirst: a === 0 },
+            geometry: { type: "Point", coordinates: E }
+          });
+        });
+    }
+    F && o.length >= 2 && p.push({
+      type: "Feature",
+      properties: { _kind: "live-line" },
+      geometry: { type: "LineString", coordinates: o }
+    }), F && r === "area" && o.length >= 3 && p.push({
+      type: "Feature",
+      properties: { _kind: "live-area" },
+      geometry: { type: "Polygon", coordinates: [[...o, o[0]]] }
+    }), F && k && N && p.push({
+      type: "Feature",
+      properties: { _kind: "ghost" },
+      geometry: { type: "LineString", coordinates: [N, k] }
+    }), F && r === "area" && k && o.length >= 2 && p.push({
+      type: "Feature",
+      properties: { _kind: "close-hint" },
+      geometry: { type: "LineString", coordinates: [k, o[0]] }
+    }), F && o.forEach((f, b) => {
+      p.push({
+        type: "Feature",
+        properties: { _kind: "live-dot", _isFirst: b === 0 },
+        geometry: { type: "Point", coordinates: f }
+      });
+    }), ws(e, p);
+  }, [
+    e,
+    F,
+    o,
+    r,
+    s,
+    C,
+    i,
+    k,
+    N,
+    t
+  ]), K(() => {
+    const p = (E) => {
+      var y, m;
+      const a = (y = E.features) == null ? void 0 : y[0];
+      if (!a) return;
+      const x = (m = a.properties) == null ? void 0 : m._id;
+      x && (Pr(), E.originalEvent.stopPropagation(), u(x));
+    }, f = (E) => {
+      var R, S, L, B;
+      const a = (R = E.features) == null ? void 0 : R[0];
+      if (!a) return;
+      const x = (S = a.properties) == null ? void 0 : S._id;
+      if (!x) return;
+      T(x);
+      const y = (L = a.properties) == null ? void 0 : L._kind, m = (B = a.properties) == null ? void 0 : B._segIdx;
+      if (y === "segment" && typeof m == "number") {
+        const V = s.find((j) => j.id === x);
+        if (V && V.mode === "distance") {
+          const j = V.points[m], h = V.points[m + 1];
+          if (j && h) {
+            const I = mt(_e(We([j, h])) * 1e3, g);
+            Ss(`${I.value} ${I.unit}`, E.originalEvent.clientX, E.originalEvent.clientY);
+          }
+        }
+      }
+    }, b = (E) => {
+      var y, m;
+      const a = (y = E.features) == null ? void 0 : y[0];
+      if (!a) return;
+      ((m = a.properties) == null ? void 0 : m._kind) === "segment" && ro(E.originalEvent.clientX, E.originalEvent.clientY);
+    }, M = () => {
+      T(null), Cn();
+    }, A = (E) => {
+      try {
+        e.queryRenderedFeatures(E.point, { layers: Rt }).length === 0 && c(null);
+      } catch {
+      }
+    };
+    for (const E of Rt)
+      e.on("click", E, p), e.on("mouseenter", E, f), e.on("mousemove", E, b), e.on("mouseleave", E, M);
+    return e.on("click", A), () => {
+      for (const E of Rt)
+        e.off("click", E, p), e.off("mouseenter", E, f), e.off("mousemove", E, b), e.off("mouseleave", E, M);
+      e.off("click", A), Cn();
+    };
+  }, [e, u, c, s, g.unit, g.display, g.precision]);
+  const P = r === "distance" ? 1 : 2, _ = k && o.length >= P ? [...o, k] : o, D = bs(_, r, g, w), q = k ?? N;
+  return /* @__PURE__ */ fe(lt, { children: [
+    s.map((p) => /* @__PURE__ */ X(Ls, { map: e, m: p }, p.id)),
+    D && q && /* @__PURE__ */ X(so, { map: e, position: q, parts: D })
+  ] });
+}
+const Ae = "elm-osm-trace";
+let Mn = !1;
+function Ps() {
+  if (Mn) return;
+  const e = document.createElement("style");
+  e.textContent = `
+    @keyframes elm-osm-pulse {
+      0% { transform: scale(0.6); opacity: 0.7; }
+      100% { transform: scale(3); opacity: 0; }
+    }
+    @keyframes elm-osm-spin {
+      to { transform: rotate(360deg); }
+    }
+    .elm-osm-pulse-ring {
+      width: 64px; height: 64px; border-radius: 50%;
+      background: color-mix(in srgb, var(--color-primary-500) 20%, transparent);
+      animation: elm-osm-pulse 1.4s ease-out infinite;
+      pointer-events: none;
+    }
+    .elm-osm-spinner {
+      width: 24px; height: 24px; border-radius: 50%;
+      border: 4px solid color-mix(in srgb, var(--color-primary-500) 20%, transparent);
+      border-top-color: var(--color-primary-500);
+      animation: elm-osm-spin 0.8s linear infinite;
+      pointer-events: none;
+    }
+  `, document.head.appendChild(e), Mn = !0;
+}
+function Cs(e) {
+  e.getSource(Ae) || (e.addSource(Ae, { type: "geojson", data: Ie() }), e.addLayer({
+    id: "elm-osm-trace-fill",
+    type: "fill",
+    source: Ae,
+    paint: {
+      "fill-color": ["get", "_color"],
+      "fill-opacity": [
+        "case",
+        ["boolean", ["get", "_hovered"], !1],
+        0.3,
+        0.12
+      ]
+    }
+  }), e.addLayer({
+    id: "elm-osm-trace-line",
+    type: "line",
+    source: Ae,
+    paint: {
+      "line-color": ["get", "_color"],
+      "line-width": [
+        "case",
+        ["boolean", ["get", "_hovered"], !1],
+        3,
+        2
+      ],
+      "line-opacity": [
+        "case",
+        ["boolean", ["get", "_hovered"], !1],
+        1,
+        0.7
+      ]
+    }
+  }));
+}
+function Ms(e) {
+  for (const t of ["elm-osm-trace-line", "elm-osm-trace-fill"])
+    e.getLayer(t) && e.removeLayer(t);
+  e.getSource(Ae) && e.removeSource(Ae);
+}
+function ks(e, t, n) {
+  const o = e.getSource(Ae);
+  if (!o) return;
+  if (!t) {
+    o.setData(Ie());
+    return;
+  }
+  const r = t.map((s, i) => ({
+    type: "Feature",
+    properties: {
+      _color: at[i % at.length],
+      _hovered: n === i,
+      _idx: i
+    },
+    geometry: s.geometry
+  }));
+  o.setData({ type: "FeatureCollection", features: r });
+}
+const Is = /* @__PURE__ */ new Set(["building", "landuse", "landcover", "park", "water", "aeroway"]);
+function Rs(e, t) {
+  const n = [], o = /* @__PURE__ */ new Map();
+  for (const s of e.queryRenderedFeatures([t.x, t.y])) {
+    if (!s.sourceLayer || !Is.has(s.sourceLayer) || s.id == null || s.geometry.type !== "Polygon" && s.geometry.type !== "MultiPolygon") continue;
+    n.push({ source: s.source, sourceLayer: s.sourceLayer, id: s.id, properties: s.properties, geometry: s.geometry });
+    const i = `${s.source}
+${s.sourceLayer}`, l = o.get(i);
+    l ? l.ids.add(s.id) : o.set(i, { source: s.source, sourceLayer: s.sourceLayer, ids: /* @__PURE__ */ new Set([s.id]) });
+  }
+  const r = [];
+  for (const { source: s, sourceLayer: i, ids: l } of o.values())
+    for (const u of e.querySourceFeatures(s, { sourceLayer: i, filter: ["in", ["id"], ["literal", [...l]]] }))
+      r.push({ source: s, sourceLayer: i, id: u.id, properties: u.properties, geometry: u.geometry });
+  return _o(n, r);
+}
+async function Fs(e, t) {
+  let n = e.pieces.length === 1 ? e.pieces[0].geometry : null;
+  if (!n)
+    try {
+      n = await $o({ type: "boolean", op: "union", features: e.pieces });
+    } catch {
+      n = await ko(e.pieces);
+    }
+  return Io(e, n, t);
+}
+function _s({ map: e }) {
+  const { dataStore: t, uiStore: n } = Le(), o = ke().network, r = $(o);
+  r.current = o;
+  const s = Ue(), i = zt(), l = W((p) => p.editingMode), [u, c] = le(null), [v, d] = le(null), g = Oo(), w = An(), C = $(null), T = $(null), F = $(null), k = $(null);
+  K(() => () => {
+    F.current && (F.current.remove(), F.current = null);
+  }, [e]);
+  const N = vt();
+  K(() => {
+    ks(e, u, v);
+  }, [e, u, v, N]);
+  const P = ve(
+    (p) => Mo(t.getState(), n.getState(), p),
+    [t, n]
+  ), _ = ve(() => {
+    F.current && (F.current.remove(), F.current = null);
+  }, []), D = ve(() => {
+    c(null), d(null), C.current = null, _(), T.current && (T.current.abort(), T.current = null);
+  }, [_]), q = ve((p) => {
+    const f = C.current;
+    if (D(), !("pieces" in p)) {
+      P(p);
+      return;
+    }
+    if (!f) return;
+    const b = new AbortController();
+    T.current = b, Fs(p, f).then((M) => {
+      b.signal.aborted || (T.current = null, M && P(M));
+    });
+  }, [P, D]);
+  return K(() => {
+    if (!u && l !== "pick-shape") return;
+    function p(f) {
+      f.key === "Escape" && i(f) && D();
+    }
+    return window.addEventListener("keydown", p), () => window.removeEventListener("keydown", p);
+  }, [u, l, D, i]), K(() => {
+    if (l !== "pick-shape") return;
+    const p = (f) => {
+      if (e.getZoom() < Ro) {
+        s({ type: "warning", message: "Zoom in further to use the picker" });
+        return;
+      }
+      f.originalEvent.preventDefault(), D();
+      const b = new AbortController();
+      T.current = b;
+      const M = f.lngLat.lng, A = f.lngLat.lat;
+      C.current = [M, A], Ps();
+      const E = document.createElement("div");
+      E.style.cssText = "width:64px;height:64px;pointer-events:none;display:flex;align-items:center;justify-content:center;", E.innerHTML = `
+        <div class="elm-osm-pulse-ring" style="position:absolute"></div>
+        <div class="elm-osm-spinner"></div>
+      `, F.current = new De.Marker({ element: E, anchor: "center" }).setLngLat([M, A]).addTo(e);
+      const a = Rs(e, f.point), { overpass: x, fetch: y } = r.current, m = x === !1;
+      (a.length > 0 || m ? Promise.resolve(a) : Qo(A, M, Fo(e.getZoom()), [M, A], { ...x, fetch: y, signal: b.signal })).then((S) => {
+        _(), S.length === 0 ? (s({ type: "warning", message: m ? "No shape here in the basemap" : "No features found here" }), D()) : S.length === 1 ? q(S[0]) : c(S);
+      }).catch((S) => {
+        (S == null ? void 0 : S.name) !== "AbortError" && (_(), s({ type: "error", code: S instanceof tr ? S.code : "unknown", source: "picker", message: er(S), cause: S }), D());
+      });
+    };
+    return e.on("click", p), () => {
+      e.off("click", p);
+    };
+  }, [l, e, D, _, q, s]), K(() => {
+    if (!u || !C.current) return;
+    const p = C.current;
+    let f;
+    function b() {
+      if (!k.current) {
+        f = requestAnimationFrame(b);
+        return;
+      }
+      const M = e.project(p), A = e.getContainer().getBoundingClientRect();
+      k.current.style.left = `${A.left + M.x + 16}px`, k.current.style.top = `${A.top + M.y - 8}px`, f = requestAnimationFrame(b);
+    }
+    return f = requestAnimationFrame(b), () => cancelAnimationFrame(f);
+  }, [u, e]), K(() => {
+    if (!u) return;
+    const p = (E) => {
+      var m, R;
+      const a = (m = E.features) == null ? void 0 : m[0];
+      if (!a) return;
+      const x = (R = a.properties) == null ? void 0 : R._idx;
+      if (typeof x != "number") return;
+      E.originalEvent.stopPropagation();
+      const y = u[x];
+      y && q(y);
+    }, f = (E) => {
+      var y, m;
+      const a = (y = E.features) == null ? void 0 : y[0];
+      if (!a) return;
+      const x = (m = a.properties) == null ? void 0 : m._idx;
+      typeof x == "number" && d(x), e.getCanvas().style.cursor = "pointer";
+    }, b = () => {
+      e.getCanvas().style.cursor = Ge(n.getState().editingMode);
+    }, M = () => {
+      d(null), b();
+    }, A = ["elm-osm-trace-fill", "elm-osm-trace-line"];
+    for (const E of A)
+      e.on("click", E, p), e.on("mouseenter", E, f), e.on("mouseleave", E, M);
+    return () => {
+      for (const E of A)
+        e.off("click", E, p), e.off("mouseenter", E, f), e.off("mouseleave", E, M);
+      b();
+    };
+  }, [u, e, q, n]), K(() => {
+    l !== "pick-shape" && D();
+  }, [l, D]), u ? Ze(
+    /* @__PURE__ */ X("div", { ref: k, "data-elm-portal": !0, "data-elm-theme": w, style: { ...g, position: "fixed", zIndex: 1e4 }, children: /* @__PURE__ */ X("div", { className: "bg-elm-surface/95 backdrop-blur-md border border-elm-border/80 text-elm-text-secondary shadow-elm rounded-elm overflow-hidden min-w-[180px] max-w-[280px] text-sm py-1", children: u.map((p, f) => /* @__PURE__ */ fe(
+      "button",
+      {
+        onClick: () => q(p),
+        onMouseEnter: () => d(f),
+        onMouseLeave: () => d(null),
+        className: `w-full text-left px-3 py-2 flex items-center gap-2 transition-colors ${v === f ? "bg-primary-50 dark:bg-white/5" : "hover:bg-(--elm-surface-hover,var(--color-gray-50)) dark:hover:bg-elm-surface-hover"}`,
+        children: [
+          /* @__PURE__ */ X(
+            "span",
+            {
+              className: "w-2.5 h-2.5 rounded-full shrink-0",
+              style: { background: at[f % at.length] }
+            }
+          ),
+          /* @__PURE__ */ fe("span", { className: "flex flex-col min-w-0", children: [
+            /* @__PURE__ */ X("span", { className: "font-medium text-(--elm-text,var(--color-gray-800)) dark:text-(--elm-text,var(--color-gray-100)) truncate", children: p.name || `Unnamed ${p.type.toLowerCase()}` }),
+            /* @__PURE__ */ X("span", { className: "text-xs text-(--elm-text-subtle,var(--color-gray-400))", children: p.type })
+          ] })
+        ]
+      },
+      "key" in p ? p.key : `${p.osmId}/${f}`
+    )) }) }),
+    document.body
+  ) : null;
+}
+const kn = "elm-features";
+function As(e) {
+  br(e), Fr(e), ds(e), ps(e), vs(e), ls(e), Cs(e), to(e, Dn(e.getContainer())[400]);
+}
+function Ts(e) {
+  Ms(e), as(e), Lr(e), _r(e), fs(e), hs(e), xs(e), e.hasImage("elm-snap-diamond") && e.removeImage("elm-snap-diamond");
+}
+function Ds(e, t) {
+  let n, o = !1;
+  const r = () => {
+    if (o) return;
+    const i = e.getSource(kn);
+    if (!(i && i === n)) {
+      o = !0;
+      try {
+        As(e);
+      } catch {
+        return;
+      } finally {
+        o = !1;
+      }
+      (!ar(e) || n && !i) && ur(e, e.getStyle()), n = e.getSource(kn), t();
+    }
+  };
+  r();
+  const s = ["styledata", "style.load", "load"];
+  for (const i of s) e.on(i, r);
+  return () => {
+    for (const i of s) e.off(i, r);
+  };
+}
+function Ks({ map: e }) {
+  const { units: t } = ke(), n = { unit: t.length, display: t.display, precision: t.precision }, o = { unit: t.area, display: t.display, precision: t.precision }, r = (f) => {
+    const { value: b, unit: M } = mt(f * 1e3, n);
+    return `${b} ${M}`;
+  }, s = (f) => {
+    const { value: b, unit: M } = Ht(f, o);
+    return `${b} ${M}`;
+  }, i = W((f) => f.showMeasurements), l = W((f) => f.editingMode), u = W((f) => f.snappedCoord), c = W((f) => f.lineInProgress), v = W((f) => f.polygonInProgress), d = W((f) => f.circleCenter), g = W((f) => f.rectCorner), w = W((f) => f.freehandPoints), C = W((f) => f.freehandClosed), T = W((f) => f.routeWaypoints), F = oo(e, l, l !== "none"), [k, N] = le(null), P = u ?? F;
+  K(() => {
+    if (!P) {
+      N(null);
+      return;
+    }
+    N(e.project(P));
+    const f = () => N(P ? e.project(P) : null);
+    return e.on("move", f), e.on("zoom", f), () => {
+      e.off("move", f), e.off("zoom", f);
+    };
+  }, [e, P == null ? void 0 : P[0], P == null ? void 0 : P[1]]);
+  const _ = $(null), [D, q] = le({ w: 0, h: 0 });
+  if (uo(() => {
+    const f = _.current;
+    f && (f.offsetWidth !== D.w || f.offsetHeight !== D.h) && q({ w: f.offsetWidth, h: f.offsetHeight });
+  }), !i || l === "none" || !P || !k) return null;
+  const p = [];
+  try {
+    if (l === "place-point")
+      p.push({ label: "", value: `${P[1].toFixed(6)}, ${P[0].toFixed(6)}` });
+    else if (l === "draw-line" || l === "slice-shape") {
+      const f = [...c, P];
+      if (f.length >= 2) {
+        const b = We(f);
+        p.push({ label: "Length", value: r(_e(b)) }), p.push({ label: "Segment length", value: r(Pe(f[f.length - 2], f[f.length - 1])) });
+      }
+      p.push({ label: "", value: `${P[1].toFixed(6)}, ${P[0].toFixed(6)}` });
+    } else if (l === "draw-polygon" || l === "cut-hole") {
+      const f = [...v, P];
+      if (f.length >= 3) {
+        const b = [...f, f[0]], M = ut([b]);
+        p.push({ label: "Area", value: s(dt(M)) }), p.push({ label: "Perimeter", value: r(_e(M)) });
+        const A = Bn(M);
+        p.push({ label: "Height", value: r(Pe([A[0], A[1]], [A[0], A[3]])) }), p.push({ label: "Width", value: r(Pe([A[0], A[1]], [A[2], A[1]])) });
+      } else f.length === 2 && p.push({ label: "Segment length", value: r(Pe(f[0], f[1])) });
+      p.push({ label: "", value: `${P[1].toFixed(6)}, ${P[0].toFixed(6)}` });
+    } else if (l === "draw-circle") {
+      if (d) {
+        const f = Pe(d, P);
+        p.push({ label: "Radius", value: r(f) }), p.push({ label: "Area", value: s(Math.PI * (f * 1e3) * (f * 1e3)) });
+      }
+      p.push({ label: "", value: `${P[1].toFixed(6)}, ${P[0].toFixed(6)}` });
+    } else if (l === "draw-rect") {
+      if (g) {
+        const f = Pe([g[0], g[1]], [P[0], g[1]]), b = Pe([g[0], g[1]], [g[0], P[1]]), M = f * b * 1e6;
+        p.push({ label: "Area", value: s(M) }), p.push({ label: "Width", value: r(f) }), p.push({ label: "Height", value: r(b) });
+      }
+      p.push({ label: "", value: `${P[1].toFixed(6)}, ${P[0].toFixed(6)}` });
+    } else if (l === "draw-route") {
+      const f = [...T, P];
+      f.length >= 2 && p.push({ label: "Straight distance", value: r(Pe(f[f.length - 2], f[f.length - 1])) }), p.push({ label: "", value: `${P[1].toFixed(6)}, ${P[0].toFixed(6)}` });
+    } else if (l === "draw-freehand") {
+      if (w.length >= 3 && C) {
+        const f = [...w, w[0]], b = ut([f]);
+        p.push({ label: "Area", value: s(dt(b)) }), p.push({ label: "Perimeter", value: r(_e(b)) });
+      } else if (w.length >= 2) {
+        const f = We(w);
+        p.push({ label: "Length", value: r(_e(f)) });
+      }
+      p.push({ label: "", value: `${P[1].toFixed(6)}, ${P[0].toFixed(6)}` });
+    }
+  } catch {
+  }
+  return p.length === 0 ? null : Ze(
+    /* @__PURE__ */ X(
+      "div",
+      {
+        ref: _,
+        className: "elm-measurement-tooltip",
+        style: {
+          position: "absolute",
+          ...Fn(k.x, k.y, D.w, D.h, {
+            x: "after",
+            y: "center",
+            gapX: 20,
+            bounds: { left: 0, top: 0, right: e.getContainer().clientWidth, bottom: e.getContainer().clientHeight }
+          }),
+          zIndex: 700,
+          pointerEvents: "none",
+          whiteSpace: "nowrap",
+          // Light in both modes by default (an on-map label); follows the design tokens once set.
+          background: "var(--elm-surface, white)",
+          border: "1px solid var(--elm-border, rgb(229, 231, 235))",
+          boxShadow: "var(--elm-shadow-control, 0 10px 15px -3px rgb(0 0 0 / 0.1), 0 4px 6px -4px rgb(0 0 0 / 0.1))",
+          borderRadius: "calc(var(--elm-radius-control, 6px) + 2px)",
+          padding: 12,
+          fontSize: 12,
+          color: "var(--elm-text-secondary, rgb(75, 85, 99))",
+          fontFamily: "var(--elm-font, ui-sans-serif, system-ui, sans-serif)"
+        },
+        children: /* @__PURE__ */ X("div", { style: { display: "flex", flexDirection: "column", gap: 4, textAlign: "left" }, children: p.map((f, b) => /* @__PURE__ */ fe("div", { style: { display: "flex", gap: 8, alignItems: "center", lineHeight: 1.3 }, children: [
+          f.label && /* @__PURE__ */ fe("span", { style: { fontWeight: 600, color: "var(--elm-text, rgb(17, 24, 39))" }, children: [
+            f.label,
+            ":"
+          ] }),
+          /* @__PURE__ */ X("span", { children: f.value })
+        ] }, b)) })
+      }
+    ),
+    e.getContainer()
+  );
+}
+const Qt = Nt(null);
+function ci() {
+  const e = pt(Qt);
+  if (!e) throw new Error("useMapLibre must be used inside ElementEditorControls");
+  return e;
+}
+const Ns = () => pt(Qt);
+function Bs({ map: e }) {
+  const t = Wo();
+  return K(() => {
+    t({
+      // MapController's public contract is `[lat, lng]` (Leaflet convention —
+      // the UI package normalises to that). MapLibre natively uses `[lng, lat]`,
+      // so we swap on the boundary. Search "Go" / LocateButton / ZoomIndicator
+      // all pass [lat, lng]; flipping here restores correct flyTo targets.
+      // `offset`, not `padding`: MapLibre keeps a camera padding for good.
+      // Points land in the middle of the visible map (clear of the open
+      // panels / docked inspector / table), not under them.
+      flyTo: ([n, o], r) => e.flyTo({ center: [o, n], zoom: r, offset: cn(e.getContainer()) }),
+      panTo: ([n, o]) => e.panTo([o, n], { offset: cn(e.getContainer()) }),
+      fitBounds: (n) => {
+        const o = Ao(n);
+        o && e.fitBounds(
+          [[o.minLng, o.minLat], [o.maxLng, o.maxLat]],
+          { padding: jt(e.getContainer()), maxZoom: 16 }
+        );
+      },
+      getCenter: () => {
+        const n = e.getCenter();
+        return [n.lng, n.lat];
+      },
+      setZoom: (n) => {
+        const o = Math.max(e.getMinZoom(), Math.min(e.getMaxZoom(), n));
+        return e.setZoom(o), o;
+      },
+      getZoomBounds: () => ({ min: e.getMinZoom(), max: e.getMaxZoom() }),
+      getMap: () => e
+    });
+  }, [e, t]), null;
+}
+const Os = In(
+  function(t, n) {
+    const { map: o, maxBounds: r } = t, { dataStore: s, uiStore: i } = Le(), l = Ho({
+      initialData: t.initialData,
+      schema: t.schema,
+      layout: t.layout,
+      readonly: t.readonly,
+      tools: t.tools,
+      maxFeatures: t.maxFeatures,
+      engine: "maplibre",
+      onChange: t.onChange,
+      onSubmit: t.onSubmit,
+      onValidationError: t.onValidationError,
+      onFeatureAdd: t.onFeatureAdd,
+      onFeatureUpdate: t.onFeatureUpdate,
+      onFeatureDelete: t.onFeatureDelete,
+      onSelectionChange: t.onSelectionChange,
+      onFeatureSelect: t.onFeatureSelect,
+      onZoomChange: t.onZoomChange,
+      onToolChange: t.onToolChange
+    });
+    return fo(n, () => l, [l]), K(() => {
+    }, [s, i, o]), Vo(o.getContainer()), Xo(o.getContainer()), Yo(o.getContainer()), K(() => {
+      Go();
+    }, []), K(() => {
+      o.setMaxBounds(r ?? null);
+    }, [o, r]), K(() => {
+      const u = () => s.getState().setCurrentZoom(o.getZoom());
+      return s.getState().setCurrentZoom(o.getZoom()), o.on("zoomend", u), () => {
+        o.off("zoomend", u);
+      };
+    }, [o, s]), /* @__PURE__ */ fe(Qt.Provider, { value: o, children: [
+      /* @__PURE__ */ fe(gr, { getFeatureStyle: t.getFeatureStyle, children: [
+        /* @__PURE__ */ X(Bs, { map: o }),
+        /* @__PURE__ */ X(ys, { map: o }),
+        /* @__PURE__ */ X(Er, { map: o }),
+        /* @__PURE__ */ X(us, { map: o }),
+        /* @__PURE__ */ X(Rr, { map: o, routingApiKey: t.routingApiKey }),
+        /* @__PURE__ */ X(Ar, { map: o }),
+        /* @__PURE__ */ X(ms, { map: o }),
+        /* @__PURE__ */ X(Es, { map: o }),
+        /* @__PURE__ */ X(Ks, { map: o }),
+        /* @__PURE__ */ X(_s, { map: o }),
+        /* @__PURE__ */ X(gs, { map: o })
+      ] }),
+      t.children
+    ] });
+  }
+), li = In(
+  function(t, n) {
+    const [o, r] = le(() => t.map.isStyleLoaded()), [s, i] = le(0);
+    K(() => Ds(t.map, () => {
+      r(!0), i((v) => v + 1);
+    }), [t.map]);
+    const l = $(t.onReady);
+    l.current = t.onReady;
+    const u = $(null);
+    if (K(() => {
+      var v;
+      !o || u.current === t.map || (u.current = t.map, (v = l.current) == null || v.call(l, t.map));
+    }, [o, t.map]), K(() => () => {
+      try {
+        Ts(t.map);
+      } catch {
+      }
+    }, [t.map]), !o) return null;
+    const c = /* @__PURE__ */ X(jn.Provider, { value: s, children: /* @__PURE__ */ X(jo, { children: /* @__PURE__ */ X(Os, { ...t, ref: n }) }) });
+    return t.onEvent || t.onError ? /* @__PURE__ */ X(zo, { onEvent: t.onEvent, onError: t.onError, children: c }) : c;
+  }
+), $s = ["streets", "terrain", "light", "dark", "osm"], Ft = /* @__PURE__ */ new WeakMap();
+let js = 0;
+function je(e, t) {
+  if (typeof e == "string") return e;
+  const n = e.id ?? e.label ?? ("url" in e ? e.url : typeof e.style == "string" ? e.style : void 0);
+  return n || (t >= 0 ? `custom-${t}` : (Ft.has(e) || Ft.set(e, `custom-anon-${++js}`), Ft.get(e)));
+}
+const io = () => import("./style-Di9c4u-c.js"), zs = () => Promise.all([io(), import("./catalog-gI-xABuu.js")]).then(([e, t]) => ({ ...e, ...t }));
+let yt = !1;
+const co = (e) => new Tt(
+  "network",
+  "basemap",
+  `The basemap catalog could not be loaded (${e instanceof Error ? e.message : String(e)}). Reload the page to try again.`,
+  { cause: e }
+);
+function lo() {
+  const e = Tn(), t = $(e);
+  return t.current = e, ve((n) => {
+    t.current ? t.current({ type: "error", code: n.code, source: "basemap", message: n.message, error: n }) : console.error(`[element-editor] ${n.message}`);
+  }, []);
+}
+function Hs(e, t, n) {
+  const { theme: o } = n, r = ke().network, s = $(r);
+  s.current = r;
+  const [i, l] = le(null), u = lo();
+  K(() => {
+    let g = !0;
+    return io().then((w) => g && l(w), (w) => {
+      g && !yt && (yt = !0, u(co(w)));
+    }), () => {
+      g = !1;
+    };
+  }, []);
+  const c = (g) => {
+    const w = (i == null ? void 0 : i.resolveBasemap(g, o)) ?? g;
+    return je(w, -1);
+  }, v = $(void 0), d = $(n.initialApplied ? { basemap: t, theme: o } : null);
+  v.current === void 0 && (v.current = d.current ? "" : null), K(() => {
+    if (!e || !i) return;
+    const g = c(t);
+    if (v.current === "" && (v.current = je(i.resolveBasemap(d.current.basemap, d.current.theme), -1)), v.current === g) return;
+    let w = !1;
+    const C = (D) => D instanceof Error ? D.message : String(D), T = i.resolveBasemap(t, o), F = typeof T == "object" && "style" in T && typeof T.style == "string", k = (D) => {
+      N(), v.current = null, u(new Tt(ln(D.error), "basemap", `The basemap could not be loaded (${C(D.error)}).`, { cause: D.error }));
+    }, N = () => {
+      e.off("error", k), e.off("styledata", N);
+    }, P = () => {
+      w || !(e.isStyleLoaded() || e.getSource("elm-features")) || (w = !0, e.off("styledata", P), v.current = g, i.setBasemap(e, t, { theme: o, network: s.current }).then(() => {
+        F && !_ && (e.on("error", k), e.once("styledata", N));
+      }, (D) => {
+        v.current = null, u(new Tt(ln(D), "basemap", `The basemap could not be switched (${C(D)}). The map keeps the previous one.`, { cause: D }));
+      }));
+    };
+    let _ = !1;
+    return e.on("styledata", P), P(), () => {
+      w = !0, _ = !0, e.off("styledata", P), N();
+    };
+  }, [e, i, t, o]);
+}
+function ai(e) {
+  const { basemaps: t, value: n, defaultValue: o = "auto", onChange: r, storageKey: s, initialApplied: i, size: l, tooltipSide: u } = e, c = Ns(), v = e.map ?? c, d = An(), [g, w] = le(null), C = lo();
+  K(() => {
+    let a = !0;
+    return zs().then((x) => a && w(x), (x) => {
+      a && !yt && (yt = !0, C(co(x)));
+    }), () => {
+      a = !1;
+    };
+  }, []);
+  const T = ke(), F = Bt(() => t ?? ["auto", ...$s], [t]), k = F.map(je);
+  (F.filter((a) => typeof a == "object" && !a.id && !a.label && !("url" in a) && typeof a.style != "string").length > 1 || new Set(k).size < k.length) && Rn("basemap-ids", "BasemapControl: give each custom basemap a unique `id` (two entries without one, or with the same id/label, cannot be told apart).");
+  const [N] = le(() => {
+    const a = s ? nr(s, T) : null;
+    return a ? F.find((x, y) => je(x, y) === a) : void 0;
+  }), [P, _] = le(N ?? o), [D, q] = le(n !== void 0 || e.defaultValue !== void 0 || N !== void 0), p = n ?? P, f = F.indexOf(p), b = f >= 0 ? k[f] : je(p, -1);
+  Hs(D || n !== void 0 ? v : null, p, {
+    theme: d,
+    initialApplied: D && i && b === je(o, F.indexOf(o))
+  });
+  const M = ve((a) => {
+    const x = k.indexOf(a);
+    if (x < 0) return;
+    const y = F[x];
+    q(!0), n === void 0 && _(y), s && (typeof y == "string" || y.id) && or(s, a, T), r == null || r(y);
+  }, [k, F, n, s, r, T]);
+  if (!g) return null;
+  const A = (a) => {
+    var x;
+    return (x = g.BASEMAPS.find((y) => y.id === a)) == null ? void 0 : x.thumbnail;
+  }, E = F.map((a, x) => {
+    const y = k[x], m = typeof a == "string" ? g.BASEMAPS.find((R) => R.id === a) : void 0;
+    return {
+      id: y,
+      label: a === "auto" ? "Auto" : (m == null ? void 0 : m.label) ?? (typeof a == "object" && a.label || y),
+      // Auto shows both looks it switches between (light → streets, dark → dark).
+      thumbnail: a === "auto" ? [A("streets"), A("dark")].every(Boolean) ? [A("streets"), A("dark")] : void 0 : typeof a == "string" ? A(a) : a.thumbnail
+    };
+  });
+  return /* @__PURE__ */ X(Uo, { options: E, value: b, onChange: M, size: l, tooltipSide: u });
+}
+export {
+  fi as ActiveDrawingToolbar,
+  ai as BasemapControl,
+  ys as BoundaryLayer,
+  rs as BoxSelectHandler,
+  Rr as DrawingLayer,
+  Ar as DrawingPreviewLayer,
+  gi as EditingToolbar,
+  li as ElementEditorControls,
+  Ci as ElementEditorError,
+  yi as ElementEditorUIProvider,
+  us as FeatureInteractionLayer,
+  Er as FeatureLayer,
+  gr as FeatureStyleProvider,
+  ii as FitBounds,
+  pi as FloatingToolbar,
+  hi as GeoStoreProvider,
+  ms as GeometryProcessingPreview,
+  mi as MapControllerProvider,
+  Es as MeasurePreviewLayer,
+  Ks as MeasurementTooltip,
+  _s as OsmTraceHandler,
+  gs as SnapController,
+  vi as StoreContext,
+  es as TransformControls,
+  $r as VertexEditor,
+  Vn as findSnapPoint,
+  Dt as snapToAngle,
+  Hs as useBasemap,
+  xi as useDataStore,
+  yr as useFeatureStyle,
+  wi as useGeoStore,
+  Si as useKeyboardShortcuts,
+  bi as useMapController,
+  ci as useMapLibre,
+  Li as useSetMapController,
+  Ei as useUIStore
+};