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

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 gi, EditingToolbar as yi, ElementEditorUIProvider as pi, FloatingToolbar as hi, GeoStoreProvider as mi, MapControllerProvider as vi, StoreContext as xi, useDataStore as wi, useGeoStore as Si, useKeyboardShortcuts as bi, useMapController as Li, useSetMapController as Ei, useUIStore as Pi } 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 Mi } from "@element-editor/core";
+import 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((A) => A.features), n = he((A) => A.groups), o = he((A) => A.selectedIds), r = W((A) => A.editingMode), s = W((A) => A.geometryPreview !== null), i = W((A) => A.bufferCreateNew), l = yr(), u = ke().featureColor, c = vt(), [v, d] = le(() => un(e));
+  K(() => {
+    const A = () => d(un(e));
+    return A(), e.on("styledata", A), () => {
+      e.off("styledata", A);
+    };
+  }, [e, c]);
+  const g = v ? wr : Hn, w = qe(e, g);
+  K(() => {
+    Ne(e, g, w);
+  }, [c]);
+  const P = Tn(), T = $(!1);
+  K(() => {
+    T.current || e.getGlyphs() || (T.current = !0, P == null || P({
+      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, P]);
+  const M = s && (r === "simplify-shape" || r === "smooth-shape" || r === "buffer-shape" && !i) ? o : null;
+  K(() => {
+    const A = e.getSource(ge);
+    if (!A) return;
+    const D = new Set(n.filter((C) => C.hidden).map((C) => C.id)), q = M ? new Set(M) : null, y = t.filter((C) => !(C.hidden || C.groupId && D.has(C.groupId) || q != null && q.has(C.id) && _t(C.geometry.type))), f = [];
+    let b = !0;
+    for (const C of y) {
+      const { _validation: R, ...I } = C, a = l == null ? void 0 : l(C), x = {}, p = (a == null ? void 0 : a.color) ?? u;
+      if (p !== void 0 && (x._color = p), 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)), C.geometry.type === "GeometryCollection") {
+        C.geometry.geometries.length > 1 && (b = !1);
+        for (const m of C.geometry.geometries)
+          f.push({
+            ...I,
+            geometry: m,
+            properties: { ...I.properties, ...x, id: C.id }
+          });
+      } else
+        f.push({
+          ...I,
+          properties: { ...I.properties, ...x, id: C.id }
+        });
+    }
+    A.setData({ type: "FeatureCollection", features: f }), fr(e, f, b);
+  }, [t, n, e, M, l, u, c]);
+  const N = $(/* @__PURE__ */ new Set()), E = $(c);
+  return K(() => {
+    if (!e.getSource(ge)) return;
+    E.current !== c && (E.current = c, N.current = /* @__PURE__ */ new Set());
+    const A = N.current, D = new Set(o);
+    for (const q of A)
+      D.has(q) || e.setFeatureState({ source: ge, id: q }, { selected: !1 });
+    for (const q of D)
+      A.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, P = 0, T = !1, _ = null;
+  const M = r + 1;
+  let N = 1 / 0, E = -1 / 0, A = 1 / 0, D = -1 / 0;
+  for (const [b, C] of [[l - M, u - M], [l + M, u - M], [l - M, u + M], [l + M, u + M]]) {
+    const R = n.unproject([b, C]);
+    R.lng < N && (N = R.lng), R.lng > E && (E = R.lng), R.lat < A && (A = R.lat), R.lat > D && (D = R.lat);
+  }
+  let q = "";
+  function y(b, C = !0) {
+    if (!b || b.length === 0) return;
+    let R = -1, I = 0, a = 0;
+    for (let x = 0; x < b.length; x++) {
+      const p = b[x];
+      if (!(p[0] < N || p[0] > E || p[1] < A || p[1] > D)) {
+        if (R !== x) {
+          const F = n.project(p);
+          I = F.x, a = F.y, R = x;
+        }
+        const m = Math.hypot(l - I, u - a);
+        m < c && (c = m, v = p, d = q);
+      }
+      if (C && x < b.length - 1) {
+        const m = b[x + 1];
+        if (p[0] < N && m[0] < N || p[0] > E && m[0] > E || p[1] < A && m[1] < A || p[1] > D && m[1] > D) continue;
+        if (R !== x) {
+          const k = n.project(p);
+          I = k.x, a = k.y;
+        }
+        const F = I, S = a, L = n.project(m);
+        R = x + 1, I = L.x, a = L.y;
+        const B = (F - L.x) ** 2 + (S - L.y) ** 2;
+        let V = F, j = S;
+        if (B !== 0) {
+          let k = ((l - F) * (L.x - F) + (u - S) * (L.y - S)) / B;
+          k = Math.max(0, Math.min(1, k)), V = F + k * (L.x - F), j = S + k * (L.y - S);
+        }
+        const h = Math.hypot(l - V, u - j);
+        h < g && (g = h, w = V, P = j, T = !0, _ = q);
+      }
+    }
+  }
+  function f(b) {
+    switch (b.type) {
+      case "Point":
+        y([b.coordinates]);
+        break;
+      case "MultiPoint":
+        y(b.coordinates, !1);
+        break;
+      case "LineString":
+        y(b.coordinates);
+        break;
+      case "Polygon":
+      case "MultiLineString":
+        for (const C of b.coordinates) y(C);
+        break;
+      case "MultiPolygon":
+        for (const C of b.coordinates)
+          for (const R of C) y(R);
+        break;
+      case "GeometryCollection":
+        for (const C of b.geometries) f(C);
+        break;
+    }
+  }
+  for (const b of o)
+    if (!s.has(b.id)) {
+      if (b.bbox) {
+        const [C, R, I, a] = b.bbox;
+        if (I < N || C > E || a < A || R > 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, P]);
+    return {
+      lnglat: [b.lng, b.lat],
+      isVertex: !1,
+      featureId: _ ?? 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), P = e.unproject([g, w]);
+  return [P.lng, P.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((y) => y.editingMode), v = W((y) => y.cancelDrawing), d = W((y) => y.routeWaypoints), g = $(d);
+  K(() => {
+    g.current = d;
+  }, [d]);
+  const w = $(null), P = $(null), T = $(null), _ = $(!1), M = $(!1), N = $(!1), E = $(null), A = $(yo()).current, D = $(!1), q = ve(
+    async (y) => {
+      if (!(y.length < 2)) {
+        n.getState().setRoutePreview(null, !0);
+        try {
+          if (!i.current) throw new Error("routing is off");
+          const f = await an(y, 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(y, !1);
+        }
+      }
+    },
+    [n, l]
+  );
+  return K(() => {
+    const y = e.getCanvas();
+    function f() {
+      D.current || (D.current = !0, e.dragPan.enable(), y.style.cursor = "grab");
+    }
+    function b() {
+      if (!D.current) return;
+      D.current = !1;
+      const p = n.getState().editingMode;
+      y.style.cursor = Ge(p), (p === "draw-rect" || p === "draw-circle" || p === "draw-freehand") && e.dragPan.disable();
+    }
+    const C = (p) => {
+      if (p.key === "Shift" && (M.current = !0), !!u(p)) {
+        if (p.code === "Space") {
+          const m = p.target;
+          if (m && (m.tagName === "INPUT" || m.tagName === "TEXTAREA" || m.isContentEditable)) return;
+          p.preventDefault(), n.getState().editingMode !== "none" && f();
+          return;
+        }
+        if (p.key === "Escape") {
+          const { selectedMeasurementId: m, setSelectedMeasurementId: F } = n.getState();
+          if (m) {
+            F(null);
+            return;
+          }
+          v();
+          return;
+        }
+        if (p.key === "Enter") {
+          const m = n.getState();
+          if (m.editingMode === "measure") {
+            m.completeMeasure();
+            return;
+          }
+        }
+        if (p.key === "Backspace" || p.key === "Delete") {
+          const m = n.getState();
+          if (m.selectedMeasurementId) {
+            m.removeMeasurement(m.selectedMeasurementId);
+            return;
+          }
+          const F = m.editingMode;
+          if (F === "measure") {
+            m.removeLastMeasurePoint();
+            return;
+          }
+          if (F === "draw-line" || F === "slice-shape") {
+            m.removeLastLineVertex();
+            return;
+          }
+          if (F === "draw-polygon" || F === "cut-hole") {
+            m.removeLastPolygonVertex();
+            return;
+          }
+          if (F === "draw-route") {
+            m.removeLastRouteWaypoint();
+            return;
+          }
+        }
+      }
+    }, R = (p) => {
+      if (p.code === "Space") {
+        b();
+        return;
+      }
+      p.key === "Shift" && (M.current = !1);
+    }, I = () => b(), a = () => {
+      y.style.cursor = "grabbing";
+    }, x = () => {
+      y.style.cursor = D.current ? "grab" : Ge(n.getState().editingMode);
+    };
+    return window.addEventListener("keydown", C), window.addEventListener("keyup", R), window.addEventListener("blur", I), e.on("dragstart", a), e.on("dragend", x), () => {
+      window.removeEventListener("keydown", C), window.removeEventListener("keyup", R), window.removeEventListener("blur", I), 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(), _.current = !1);
+  }, [c, e]), K(() => (c !== "none" ? e.doubleClickZoom.disable() : e.doubleClickZoom.enable(), () => {
+    e.doubleClickZoom.enable();
+  }), [c, e]), K(() => {
+    var C;
+    if (!ho.includes(c)) return;
+    const y = (C = e.handlers) == null ? void 0 : C._handlersById, f = [y == null ? void 0 : y.mapEvent, y == null ? void 0 : y.mousePan].filter((R) => typeof (R == null ? void 0 : R._clickTolerance) == "number"), b = f.map((R) => R._clickTolerance);
+    for (const R of f) R._clickTolerance = mo;
+    return () => f.forEach((R, I) => {
+      R._clickTolerance = b[I];
+    });
+  }, [c, e]), K(() => (c !== "none" ? e.boxZoom.disable() : e.boxZoom.enable(), () => {
+    e.boxZoom.enable();
+  }), [c, e]), K(() => () => {
+    P.current && clearTimeout(P.current), T.current && T.current.abort();
+  }, []), K(() => {
+    const y = (a) => a.metaKey || a.ctrlKey || a.altKey, f = (a) => {
+      if (!y(a.originalEvent) && !D.current) {
+        if (c === "draw-freehand") {
+          _.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, E.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, E.current = { x: a.point.x, y: a.point.y };
+          return;
+        }
+      }
+    }, b = (a) => {
+      if (c === "draw-freehand" && _.current) {
+        _.current = !1;
+        const F = e.getZoom(), S = 156543.03392 * Math.cos(a.lngLat.lat * Math.PI / 180) / Math.pow(2, F), L = Ir * S / 111320;
+        n.getState().commitFreehand(L), Lt();
+        return;
+      }
+      if (!N.current) return;
+      N.current = !1, e.dragPan.enable();
+      const x = E.current, p = x ? Math.hypot(a.point.x - x.x, a.point.y - x.y) : 0;
+      E.current = null;
+      const m = n.getState();
+      if (c === "draw-rect") {
+        const F = m.rectCorner;
+        if (!F) return;
+        if (p < yn) {
+          n.setState({ rectCorner: null });
+          return;
+        }
+        const S = m.snappedCoord ?? [a.lngLat.lng, a.lngLat.lat], L = M.current || a.originalEvent.shiftKey;
+        m.commitRect(F, S, {}, L), Lt();
+        return;
+      }
+      if (c === "draw-circle") {
+        const F = m.circleCenter;
+        if (!F) return;
+        let S;
+        if (p < 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] - F[0], B = S[1] - F[1];
+        Math.hypot(L, B) >= 1e-6 && (m.commitCircle(F, S, {}), Lt());
+        return;
+      }
+    }, C = (a) => {
+      const x = n.getState();
+      if (c === "draw-freehand" && _.current) {
+        x.addFreehandPoint([a.lngLat.lng, a.lngLat.lat]);
+        return;
+      }
+      if (c === "draw-route" && g.current.length > 0) {
+        const p = [a.lngLat.lng, a.lngLat.lat];
+        x.setRouteCursorPos(p), x.setRouteCursorPreview(null), P.current && clearTimeout(P.current), T.current && T.current.abort();
+        const m = g.current[g.current.length - 1];
+        P.current = setTimeout(async () => {
+          const F = new AbortController();
+          T.current = F;
+          try {
+            if (!i.current) return;
+            const S = await an([m, p], { ...i.current, signal: F.signal });
+            F.signal.aborted || n.getState().setRouteCursorPreview(S);
+          } catch {
+          }
+        }, 400);
+      }
+      if ((c === "draw-polygon" || c === "cut-hole") && x.polygonInProgress.length >= 3) {
+        const p = x.polygonInProgress[0], m = e.project(p), F = Math.hypot(a.point.x - m.x, a.point.y - m.y);
+        e.getCanvas().style.cursor = F <= 48 ? "pointer" : "crosshair";
+      }
+    }, R = (a) => {
+      const x = A.click(a.originalEvent);
+      if (y(a.originalEvent) || kr() || D.current || Gn()) return;
+      const p = n.getState();
+      if (c === "measure") {
+        if (x || Cr()) return;
+        p.selectedMeasurementId && p.setSelectedMeasurementId(null);
+        const S = p.snappedCoord ?? [a.lngLat.lng, a.lngLat.lat];
+        p.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 F = p.snappedCoord ?? [a.lngLat.lng, a.lngLat.lat];
+      if (c === "place-point") {
+        if (x) return;
+        p.commitPoint(F);
+        return;
+      }
+      if (c === "draw-line" || c === "draw-polygon" || c === "draw-route" || c === "cut-hole" || c === "slice-shape") {
+        let S = F;
+        if (M.current || a.originalEvent.shiftKey) {
+          const L = c === "draw-line" || c === "slice-shape" ? p.lineInProgress : p.polygonInProgress;
+          L.length >= 1 && (S = Dt(e, L[L.length - 1], S));
+        }
+        if ((c === "draw-polygon" || c === "cut-hole") && p.polygonInProgress.length >= 2) {
+          const L = p.polygonInProgress[0], B = e.project(L);
+          if (Math.hypot(a.point.x - B.x, a.point.y - B.y) <= 48) {
+            c === "draw-polygon" ? p.commitPolygon({}) : p.commitCutHole();
+            return;
+          }
+        }
+        if (x) return;
+        if (c === "draw-line" || c === "slice-shape") p.addLineVertex(S);
+        else if (c === "draw-polygon" || c === "cut-hole") p.addPolygonVertex(S);
+        else if (c === "draw-route") {
+          w.current = { waypoints: [...g.current], preview: p.routePreview }, P.current && (clearTimeout(P.current), P.current = null), T.current && (T.current.abort(), T.current = null), p.setRouteCursorPos(null), p.setRouteCursorPreview(null), p.addRouteWaypoint(S);
+          const L = [...g.current, S];
+          q(L);
+        }
+        return;
+      }
+    }, I = () => {
+      if (!A.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", C), e.on("click", R), e.on("dblclick", I), () => {
+      e.off("mousedown", f), e.off("mouseup", b), e.off("mousemove", C), e.off("click", R), e.off("dblclick", I);
+    };
+  }, [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 P = [...g, w];
+      d.push({ type: "Feature", properties: {}, geometry: { type: "LineString", coordinates: P } }), g.forEach((T, _) => {
+        d.push({ type: "Feature", properties: { _isFirst: _ === 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 P = [...g, w, g[0]];
+      g.length >= 2 ? d.push({ type: "Feature", properties: {}, geometry: { type: "Polygon", coordinates: [P] } }) : d.push({ type: "Feature", properties: {}, geometry: { type: "LineString", coordinates: P } }), g.forEach((T, _) => {
+        d.push({ type: "Feature", properties: { _isFirst: _ === 0 }, geometry: { type: "Point", coordinates: T } });
+      });
+    }
+    if (c.editingMode === "draw-circle") {
+      const g = c.circleCenter;
+      if (!g) return Fe(e, []);
+      const w = v ?? g, P = vo(g, w, s.current, 64);
+      d.push({ type: "Feature", properties: {}, geometry: { type: "Polygon", coordinates: [P] } }), 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 P = xo(g, v ?? g, s.current, l.current);
+      d.push({ type: "Feature", properties: {}, geometry: { type: "Polygon", coordinates: [P] } });
+    }
+    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 P = c.routeCursorPreview ?? (v ? [g[g.length - 1], v] : null);
+      P && P.length >= 2 && d.push({ type: "Feature", properties: {}, geometry: { type: "LineString", coordinates: P } }), g.forEach((T, _) => {
+        d.push({ type: "Feature", properties: { _isFirst: _ === 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 P = e.project(t);
+      v({ x: P.x, y: P.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, P;
+    (w = d.current) == null || w.focus(), (P = d.current) == null || P.select();
+  }, []);
+  function g() {
+    const w = parseFloat(s), P = parseFloat(l);
+    if (isNaN(w) || isNaN(P)) {
+      r({ type: "warning", message: "Invalid coordinates" });
+      return;
+    }
+    n([w, P]), 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()), [P, T] = le(null), _ = ve(() => T(null), []), [M, N] = le(null);
+  K(() => {
+    d(/* @__PURE__ */ new Set()), T(null), N(null);
+  }, [t.id, u]);
+  const E = $(n);
+  K(() => {
+    n !== E.current && (E.current = n, !(!n || n.length === 0) && d((h) => {
+      const k = new Set(h);
+      for (const O of n) k.add(`0:${O}`);
+      for (const O of n) {
+        const z = w.current.get(`0:${O}`);
+        z && Ct(z, !0);
+      }
+      return k;
+    }));
+  }, [n]);
+  function A(h) {
+    Vt(e, /* @__PURE__ */ new Map([[t.id, h]]));
+  }
+  function D(h) {
+    const k = nt(t.geometry, u, h);
+    o.getState().updateFeature(t.id, So(t, k));
+  }
+  const q = $(!1);
+  K(() => {
+    const h = (k) => {
+      q.current = k.metaKey || k.ctrlKey;
+    };
+    return window.addEventListener("keydown", h), window.addEventListener("keyup", h), () => {
+      window.removeEventListener("keydown", h), window.removeEventListener("keyup", h);
+    };
+  }, []);
+  function y() {
+    Br(), c.current.forEach((z) => z.remove()), c.current = [], w.current = /* @__PURE__ */ new Map(), f.current = [], b.current = null, C.current = !1;
+    const h = Oe(t.geometry, u);
+    if (!h) return;
+    const k = ot(h), O = g.current;
+    I.current = !1, k.forEach((z, G) => {
+      const H = h.type === "Polygon" ? z.slice(0, -1) : z, te = Sn(e, H, (Z) => O.has(`${G}:${Z}`));
+      te.capped && (I.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, C.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);
+          A(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), C.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 && (I.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, C.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);
+            A(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), C.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), C = $(!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;
+    }, k = (z) => {
+      if (C.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;
+      !C.current && !(G instanceof Node && e.getContainer().contains(G)) && h(null);
+    };
+    return e.on("mousemove", k), e.on("mouseout", O), () => {
+      e.off("mousemove", k), e.off("mouseout", O);
+    };
+  }, [e]);
+  const R = $(() => {
+  });
+  R.current = (h) => {
+    var ee, oe;
+    const k = h.originalEvent;
+    if (C.current || k.button !== 0 || k.shiftKey || (oe = (ee = k.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(() => {
+      A(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, C.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), C.current = !1;
+      }
+    };
+    e.on("mousemove", U), window.addEventListener("mouseup", Y);
+  }, K(() => {
+    const h = (k) => R.current(k);
+    return e.on("mousedown", h), () => {
+      e.off("mousedown", h);
+    };
+  }, [e]);
+  const I = $(!1), a = $(y);
+  a.current = y, K(() => {
+    const h = () => {
+      I.current && a.current();
+    };
+    return e.on("moveend", h), () => {
+      e.off("moveend", h);
+    };
+  }, [e]), K(() => (y(), () => {
+    c.current.forEach((h) => h.remove()), c.current = [], w.current = /* @__PURE__ */ new Map();
+  }), [t, e, l, u]);
+  function x(h, k) {
+    const O = Oe(t.geometry, u);
+    if (!O) return;
+    const z = jr(O, h, k);
+    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][k];
+    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 p() {
+    const h = g.current;
+    if (h.size === 0) return;
+    const k = Oe(t.geometry, u);
+    if (!k) 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 (k.type === "LineString") {
+      const z = k.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 (k.type === "MultiPoint") {
+      const z = k.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 (k.type === "Polygon") {
+      const z = k.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 k = /* @__PURE__ */ new Map();
+    for (const U of g.current) {
+      const [Y, ee] = U.split(":"), oe = Number(Y), Q = Number(ee), de = k.get(oe) ?? [];
+      de.push(Q), k.set(oe, de);
+    }
+    if (k.size !== 1) {
+      s({ type: "warning", message: "Selection must stay within one ring/line to simplify" });
+      return;
+    }
+    const [O, z] = Array.from(k.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(k) {
+      if (k.key !== "Delete" && k.key !== "Backspace") return;
+      const O = k.target;
+      O && (O.tagName === "INPUT" || O.tagName === "TEXTAREA" || O.isContentEditable) || i(k) && (k.preventDefault(), k.stopPropagation(), p());
+    }
+    return window.addEventListener("keydown", h, { capture: !0 }), () => window.removeEventListener("keydown", h, { capture: !0 });
+  }, [v]);
+  const F = v.size > 0, S = P && (() => {
+    const h = `${P.ringIdx}:${P.vertIdx}`, k = v.has(h) && v.size > 1;
+    return /* @__PURE__ */ X(
+      Ko,
+      {
+        x: P.x,
+        y: P.y,
+        onClose: _,
+        items: [
+          { label: "Edit coordinates…", icon: /* @__PURE__ */ X(rr, { size: 16 }), onClick: () => N({ ringIdx: P.ringIdx, vertIdx: P.vertIdx }) },
+          { separator: !0 },
+          {
+            label: k ? `Delete ${v.size} points` : "Delete point",
+            icon: /* @__PURE__ */ X(sr, { size: 16 }),
+            onClick: () => k ? p() : x(P.ringIdx, P.vertIdx)
+          }
+        ]
+      }
+    );
+  })(), L = M && Oe(t.geometry, u), B = L && M ? (j = ot(L)[M.ringIdx]) == null ? void 0 : j[M.vertIdx] : void 0, V = M && L && B && /* @__PURE__ */ X(
+    Un,
+    {
+      map: e,
+      coords: B,
+      onSave: (h) => {
+        if (o.getState().takeSnapshot(), D(Mt(L, M.ringIdx, M.vertIdx, h)), L.type === "Polygon" && r.getState().topoEditEnabled) {
+          const k = o.getState();
+          k.updateFeatures(on(k.features, t.id, B, h));
+        }
+      },
+      onClose: () => N(null)
+    },
+    `${M.ringIdx}:${M.vertIdx}`
+  );
+  return /* @__PURE__ */ fe(lt, { children: [
+    S,
+    V,
+    F && /* @__PURE__ */ X(
+      No,
+      {
+        mapContainer: e.getContainer(),
+        count: v.size,
+        onSimplify: m,
+        onDelete: p
+      }
+    )
+  ] });
+}
+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, P = g - i, T = w * u + P * c, _ = -w * c + P * u, M = T * n, N = _ * o, E = M * u - N * c, A = M * c + N * u;
+    return [s + E / v, i + A];
+  });
+}
+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, P = -d * l + g * i, T = w * n, _ = P * n, M = T * i - _ * l, N = T * l + _ * i;
+    return Ot([r[0] + M, 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, P = g * n, T = w * n, _ = P * i - T * l, M = P * l + T * i;
+    return Ot([r[0] + _, r[1] + M]);
+  });
+}
+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, P = g[1] - i, T = w * u + P * c, _ = -w * c + P * u, M = T * n, N = _ * o, E = M * u - N * c, A = M * c + N * u;
+    return [s + E / v, i + A];
+  }
+  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 _ = me(r);
+    l = (M) => {
+      const N = me(M), E = N[0] - _[0], A = N[1] - _[1];
+      return [E * s + A * i, -E * i + A * s];
+    };
+  } else {
+    const _ = Te(r[1]);
+    l = (M) => {
+      const N = (M[0] - r[0]) * _, E = M[1] - r[1];
+      return [N * s + E * i, -N * i + E * 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, P = (_) => Math.abs(_) < 0.01 ? _ < 0 ? -0.01 : 0.01 : _, T = (_, M) => Math.abs(M) > 1e-9 ? _ / M : 1;
+  if (n) {
+    let _;
+    if (g) _ = T(d, c);
+    else if (w) _ = T(v, u);
+    else {
+      const M = u * u + c * c;
+      _ = M > 1e-18 ? (v * u + d * c) / M : 1;
+    }
+    return { origin: r, uniform: !0, factor: P(_) };
+  }
+  return {
+    origin: r,
+    uniform: !1,
+    scaleX: w || !g ? P(T(v, u)) : 1,
+    scaleY: g || !w ? P(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((y) => y.selectedIds), s = W((y) => y.transformActive), i = W((y) => y.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), P = $(null), T = $([]);
+  function _() {
+    T.current.forEach((y) => y.remove()), T.current = [];
+  }
+  function M(y) {
+    const f = /* @__PURE__ */ new Map();
+    for (const b of y) f.set(String(b.id ?? ""), b.geometry);
+    Vt(e, f);
+  }
+  function N(y) {
+    const f = T.current;
+    if (f.length === 9) {
+      for (let b = 0; b < 4; b++) f[b].setLngLat(y.corners[b]);
+      for (let b = 0; b < 4; b++) f[4 + b].setLngLat(y.edges[b]);
+      f[8].setLngLat(y.rotateHandle);
+    }
+  }
+  const E = $(null);
+  K(() => {
+    if (!s || t.length === 0) return;
+    _();
+    const y = v.current ?? it(t), f = ["nw", "ne", "se", "sw"], b = ["n", "e", "s", "w"], C = [];
+    y.corners.forEach((R, I) => {
+      const a = It(f[I]), x = new De.Marker({ element: a, draggable: !1 }).setLngLat(R).addTo(e);
+      a.addEventListener("mousedown", (p) => D(p, I, !1)), C.push(x);
+    }), y.edges.forEach((R, I) => {
+      const a = It(b[I]), x = new De.Marker({ element: a, draggable: !1 }).setLngLat(R).addTo(e);
+      a.addEventListener("mousedown", (p) => D(p, I, !0)), C.push(x);
+    });
+    {
+      const R = It("rotate"), I = new De.Marker({ element: R, anchor: "bottom", draggable: !1 }).setLngLat(y.rotateHandle).addTo(e);
+      R.addEventListener("mousedown", (a) => q(a)), C.push(I);
+    }
+    return T.current = C, () => {
+      _();
+    };
+  }, [s, g, u, e]), K(() => {
+    function y(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(I);
+    let b = null;
+    function C(S) {
+      E.current && (S.preventDefault(), b = { clientX: S.clientX, clientY: S.clientY }, f.schedule(S));
+    }
+    function R(S) {
+      var L;
+      S.key !== "Shift" && S.key !== "Alt" || ((L = E.current) == null ? void 0 : L.type) !== "scale" || !b || (S.preventDefault(), f.schedule({ ...b, shiftKey: S.shiftKey, altKey: S.altKey }));
+    }
+    function I(S) {
+      const L = E.current;
+      if (!L) return;
+      const [B, V] = y(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", k = zr(L.startLngLat, [B, V], h), O = L.initialFeatures.map((H) => ({ ...H, geometry: $t(H.geometry, k, h) })), z = L.initialBbox, G = {
+          corners: st(z.corners, k, h),
+          edges: st(z.edges, k, h),
+          center: st([z.center], k, h)[0],
+          rotateHandle: st([z.rotateHandle], k, h)[0]
+        };
+        w.current = O, P.current = G, M(O), N(G);
+      } else if (L.type === "rotate") {
+        const h = L.center, k = Te(h[1]), O = V - h[1], z = j === "visual" ? (B - h[0]) * k : 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, P.current = Z, M(te), N(Z);
+      } else if (L.type === "scale") {
+        const h = L.rotationAngle, k = 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, k, h);
+        w.current = O.features, P.current = O.box, M(O.features), N(O.box);
+      }
+    }
+    function a() {
+      f.flush();
+      const S = E.current;
+      if (!S) return;
+      const L = w.current, B = P.current, V = S.type === "rotate";
+      if (E.current = null, b = null, w.current = null, P.current = null, e.dragPan.enable(), i(!1), S.type === "move" && L) {
+        const j = e.getContainer(), h = (k) => k.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], k = Te(j[1]), O = (h[0] - j[0]) * k, 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] = y(S), k = B ? V.edges[(L + 2) % 4] : V.corners[(L + 2) % 4];
+      E.current = {
+        type: "scale",
+        initialFeatures: structuredClone(l.current),
+        initialBbox: V,
+        rotationAngle: d.current,
+        origin: k,
+        startLngLat: [j, h],
+        edgeIndex: B ? L : void 0
+      }, i(!0);
+    }
+    function p(S) {
+      S.preventDefault(), S.stopPropagation(), e.dragPan.disable();
+      const L = v.current ?? it(l.current), B = L.center, [V, j] = y(S), h = n.getState().geometryMode, k = Te(B[1]), O = j - B[1], z = h === "visual" ? (V - B[0]) * k : V - B[0];
+      E.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 (E.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((k) => e.project(k)), Xr) && (S.preventDefault(), S.stopPropagation(), e.dragPan.disable(), E.current = {
+        type: "move",
+        initialFeatures: structuredClone(B),
+        initialBbox: V,
+        rotationAngle: d.current,
+        startLngLat: y(S),
+        startPoint: h,
+        moving: !1
+      });
+    }
+    const F = e.getContainer();
+    return F.addEventListener("mousedown", m, !0), A.current.handleScaleStart = x, A.current.handleRotateStart = p, document.addEventListener("mousemove", C), document.addEventListener("mouseup", a), document.addEventListener("keydown", R), document.addEventListener("keyup", R), () => {
+      f.cancel(), F.removeEventListener("mousedown", m, !0), document.removeEventListener("mousemove", C), document.removeEventListener("mouseup", a), document.removeEventListener("keydown", R), document.removeEventListener("keyup", R);
+    };
+  }, [e, n, o, i]);
+  const A = $({
+    handleScaleStart: () => {
+    },
+    handleRotateStart: () => {
+    }
+  });
+  function D(y, f, b) {
+    A.current.handleScaleStart(y, f, b);
+  }
+  function q(y) {
+    A.current.handleRotateStart(y);
+  }
+  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 = (P) => {
+      if (!P.shiftKey || v.current || c.current) return;
+      const T = u.current;
+      if (!T && l.current !== "none") return;
+      P.preventDefault(), e.dragPan.disable(), e.boxZoom.disable();
+      const _ = P.clientX, M = P.clientY, N = g.getBoundingClientRect(), E = [...n.getState().selectedIds], A = document.createElement("div");
+      A.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(A);
+      let D = !1, q = 0;
+      function y(a) {
+        const x = Math.min(_, a.clientX) - N.left, p = Math.min(M, a.clientY) - N.top, m = Math.max(_, a.clientX) - N.left, F = Math.max(M, a.clientY) - N.top, S = e.unproject([x, p]), L = e.unproject([m, F]);
+        return {
+          boxW: S.lng,
+          boxE: L.lng,
+          boxN: S.lat,
+          boxS: L.lat,
+          overlayX: x,
+          overlayY: p,
+          overlayW: m - x,
+          overlayH: F - p
+        };
+      }
+      function f(a) {
+        const { boxW: x, boxE: p, boxN: m, boxS: F } = y(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, F],
+              [p, F],
+              [p, m],
+              [x, m],
+              [x, F]
+            ]]
+          }
+        }, j = [];
+        for (const h of B) {
+          if (h.geometry.type === "Point") {
+            const [te, Z] = h.geometry.coordinates;
+            te >= x && te <= p && Z >= F && Z <= m && j.push(h.id);
+            continue;
+          }
+          const k = h.bbox ?? Nn(h.geometry), [O, z, G, H] = k;
+          if (G >= x && O <= p && H >= F && z <= m) {
+            if (ns(k, x, F, p, 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(E);
+        a.forEach((F) => x.add(F));
+        const p = Array.from(x), m = n.getState();
+        os(m.selectedIds, p) && m.selectedGroupId === null || m.setSelection(p);
+      }
+      function C(a) {
+        const x = n.getState().selectedIds[0];
+        if (!x) return null;
+        const p = n.getState().features.find((j) => j.id === x);
+        if (!p) return null;
+        let m;
+        if (p.geometry.type === "LineString")
+          m = p.geometry.coordinates;
+        else if (p.geometry.type === "Polygon")
+          m = p.geometry.coordinates[0].slice(0, -1);
+        else
+          return null;
+        const { boxW: F, boxE: S, boxN: L, boxS: B } = y(a), V = [];
+        for (let j = 0; j < m.length; j++) {
+          const [h, k] = m[j];
+          h >= F && h <= S && k >= B && k <= L && V.push(j);
+        }
+        return { id: x, indices: V };
+      }
+      const R = (a) => {
+        const x = Math.abs(a.clientX - _), p = Math.abs(a.clientY - M);
+        if (!D && x < 5 && p < 5) return;
+        D = !0;
+        const { overlayX: m, overlayY: F, overlayW: S, overlayH: L } = y(a);
+        A.style.left = `${m}px`, A.style.top = `${F}px`, A.style.width = `${S}px`, A.style.height = `${L}px`, !T && Date.now() - q > 30 && (b(f(a)), q = Date.now());
+      }, I = (a) => {
+        if (A.remove(), e.dragPan.enable(), e.boxZoom.enable(), window.removeEventListener("mousemove", R), window.removeEventListener("mouseup", I), !D) return;
+        if (T) {
+          const p = C(a);
+          p && p.indices.length > 0 && t && t(p.id, p.indices);
+          return;
+        }
+        const x = f(a);
+        if (b(x), x.length === 0 && E.length === 1 && t) {
+          const p = n.getState().features.find((m) => m.id === E[0]);
+          if (p && (p.geometry.type === "LineString" || p.geometry.type === "Polygon")) {
+            const m = C(a);
+            m && m.indices.length > 0 && t(m.id, m.indices);
+          }
+        }
+      };
+      window.addEventListener("mousemove", R), window.addEventListener("mouseup", I);
+    };
+    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, p = Co(x);
+    p && o({ type: "warning", message: p });
+  }, [i, t, o]);
+  const v = $(!1);
+  K(() => {
+    if (!l || v.current) return;
+    const a = t.getState(), x = a.selectedIds.length === 1 ? a.features.find((p) => p.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, P] = le(null), [T, _] = le(null), [M, N] = le(null);
+  K(() => {
+    !i && M && N(null);
+  }, [i, M]);
+  const E = is(c), A = Jo();
+  K(() => {
+    if (c) return;
+    const a = e.getCanvasContainer(), x = (p) => {
+      var k, O;
+      p.preventDefault();
+      const m = a.getBoundingClientRect(), F = [p.clientX - m.left, p.clientY - m.top], S = $e(e, F, Be);
+      if (S.length === 0) return;
+      const L = String(S[0].id ?? ((k = S[0].properties) == null ? void 0 : k.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";
+      A.open(p.clientX, p.clientY, {
+        feature: V,
+        requestPreciseCoords: h ? () => _(L) : void 0
+      });
+    };
+    return a.addEventListener("contextmenu", x), () => {
+      a.removeEventListener("contextmenu", x);
+    };
+  }, [c, t, e, A]), K(() => {
+    const a = u !== "none", x = (F = !0) => {
+      bt(e, null, d.current), d.current = null, F && Pt(e, null), ct(), E.leave(a ? void 0 : "");
+    }, p = (F) => {
+      var V, j;
+      if (e.dragPan.isActive() || (V = g.current) != null && V.dragging) return;
+      const S = $e(e, F.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, F.originalEvent) : ct(), E.enter(e.getCanvas(), F.originalEvent, a ? void 0 : "pointer");
+    };
+    e.on("mousemove", p);
+    const m = () => x();
+    return e.on("mouseout", m), () => {
+      e.off("mousemove", p), e.off("mouseout", m);
+      try {
+        x(!1);
+      } catch {
+      }
+    };
+  }, [u, e, t, n, E]);
+  const D = $(r);
+  K(() => {
+    const a = D.current;
+    if (D.current = r, r.length <= a.length) return;
+    const p = e.getCanvas().getBoundingClientRect(), m = cs();
+    if (m.x < p.left || m.x > p.right || m.y < p.top || m.y > p.bottom) return;
+    const F = new Set(a.map((h) => h.id)), S = new Set(r.filter((h) => !F.has(h.id)).map((h) => h.id)), L = [m.x - p.left, m.y - p.top], B = () => {
+      var h;
+      try {
+        const k = e.unproject(L), O = $e(e, e.project(k), 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(k),
+          lngLat: k,
+          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 p = $e(e, x.point, Be), m = t.getState();
+      if (p.length === 0) {
+        i ? n.getState().setVertexEditActive(!1) : m.clearSelection();
+        return;
+      }
+      const F = p[0], S = String(F.id ?? ((L = F.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 p = $e(e, x.point, Be);
+      if (p.length === 0) return;
+      x.preventDefault();
+      const m = String(p[0].id ?? ((S = p[0].properties) == null ? void 0 : S.id) ?? "");
+      if (!m) return;
+      const F = t.getState().features.find((B) => B.id === m);
+      if (F) {
+        if (((L = F.properties) == null ? void 0 : L._isText) === "true") {
+          t.getState().selectFeature(m), P(m);
+          return;
+        }
+        if (t.getState().selectFeature(m), ht(F.geometry)) {
+          const B = Dr(F.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", p = (m) => {
+      var re;
+      if (m.originalEvent.shiftKey) return;
+      const F = m.originalEvent.altKey, S = m.originalEvent.ctrlKey || m.originalEvent.metaKey;
+      if (x && !F && !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 && !F && !S) return;
+      V.selectedIds.includes(B) || V.selectFeature(B);
+      const h = t.getState().selectedIds, k = h.includes(B) ? h : [B], O = new Map(
+        k.flatMap((J) => {
+          const ce = V.features.find((U) => U.id === J);
+          return ce ? [[J, ce.geometry]] : [];
+        })
+      ), z = F, G = V.geometryMode, H = [m.lngLat.lng, m.lngLat.lat], te = G === "visual" ? me(H) : H;
+      e.dragPan.disable(), g.current = {
+        featureIds: k,
+        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 (E.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", p), () => {
+      e.off("mousedown", p);
+    };
+  }, [c, u, i, t, n, e, E]);
+  const q = s.length === 1 ? r.find((a) => a.id === s[0]) ?? null : null, y = r.filter((a) => s.includes(a.id)), f = A.state && /* @__PURE__ */ X(
+    Bo,
+    {
+      x: A.state.x,
+      y: A.state.y,
+      data: A.state.data,
+      onClose: A.close
+    }
+  ), b = w ? r.find((a) => a.id === w) ?? null : null, C = b && /* @__PURE__ */ X(
+    ts,
+    {
+      map: e,
+      feature: b,
+      onDone: () => P(null)
+    }
+  ), R = T ? r.find((a) => a.id === T) ?? null : null, I = R && R.geometry.type === "Point" && /* @__PURE__ */ X(
+    Un,
+    {
+      map: e,
+      coords: R.geometry.coordinates,
+      onSave: (a) => {
+        t.getState().takeSnapshot(), t.getState().updateFeature(R.id, { geometry: { type: "Point", coordinates: Ve(R.geometry.coordinates, a) } });
+      },
+      onClose: () => _(null)
+    }
+  );
+  return c || u !== "none" ? /* @__PURE__ */ fe(lt, { children: [
+    f,
+    C,
+    I
+  ] }) : /* @__PURE__ */ fe(lt, { children: [
+    i && q && /* @__PURE__ */ X(
+      $r,
+      {
+        map: e,
+        feature: q,
+        initialSelectedIndices: M ?? 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 && y.length >= 1 && /* @__PURE__ */ X(es, { map: e, features: y }),
+    f,
+    C,
+    I
+  ] });
+}
+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 _ = T.originalEvent;
+      if (_.metaKey || _.ctrlKey) {
+        c();
+        return;
+      }
+      const M = _.target;
+      if ((D = M == null ? void 0 : M.closest) != null && D.call(M, ".elm-midpoint-marker")) {
+        c();
+        return;
+      }
+      const N = Gt(), E = Vn(T.lngLat.lng, T.lngLat.lat, e, s, 15, new Set(N ? [N] : []));
+      if (!E) {
+        c();
+        return;
+      }
+      if (i && E.isVertex) {
+        const q = new Set(n.getState().selectedIds);
+        if (E.featureId && q.has(E.featureId)) {
+          c();
+          return;
+        }
+      }
+      t.getState().setSnappedCoord(E.lnglat);
+      const A = e.getSource(Me);
+      A == null || A.setData({
+        type: "FeatureCollection",
+        features: [{
+          type: "Feature",
+          properties: { _kind: E.isVertex ? "vertex" : "edge" },
+          geometry: { type: "Point", coordinates: E.lnglat }
+        }]
+      });
+    }), g = (T) => d.schedule(T), w = () => d.flush(), P = () => {
+      d.cancel(), c();
+    };
+    return e.on("mousemove", g), e.on("mouseout", P), window.addEventListener("pointerdown", w, !0), window.addEventListener("pointerup", w, !0), () => {
+      d.cancel(), e.off("mousemove", g), e.off("mouseout", P), window.removeEventListener("pointerdown", w, !0), window.removeEventListener("pointerup", w, !0);
+    };
+  }, [o, r, s, i, e, t, n, l]), null;
+}
+function ci({ 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((y) => y.editingMode), o = W((y) => y.measurePoints), r = W((y) => y.measureMode), s = W((y) => y.completedMeasurements), i = W((y) => y.selectedMeasurementId), l = W((y) => y.snappedCoord), u = W((y) => y.toggleMeasurementSelection), c = W((y) => y.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 }, [P, T] = le(null), _ = n === "measure", M = _ ? l ?? v : null, N = o.length > 0 ? o[o.length - 1] : null;
+  K(() => {
+    const y = [];
+    for (const f of s) {
+      const b = P === f.id, C = i === f.id;
+      if (f.mode === "distance") {
+        for (let I = 0; I < f.points.length - 1; I++)
+          y.push({
+            type: "Feature",
+            properties: { _kind: "segment", _id: f.id, _segIdx: I, _hovered: b, _selected: C },
+            geometry: { type: "LineString", coordinates: [f.points[I], f.points[I + 1]] }
+          });
+        f.points.forEach((I, a) => {
+          y.push({
+            type: "Feature",
+            properties: { _kind: "dot", _id: f.id, _isFirst: a === 0 },
+            geometry: { type: "Point", coordinates: I }
+          });
+        });
+      } else
+        y.push({
+          type: "Feature",
+          properties: { _kind: "area", _id: f.id, _hovered: b, _selected: C },
+          geometry: { type: "Polygon", coordinates: [f.points] }
+        }), y.push({
+          type: "Feature",
+          properties: { _kind: "segment", _id: f.id, _hovered: b, _selected: C },
+          geometry: { type: "LineString", coordinates: f.points }
+        }), f.points.slice(0, -1).forEach((I, a) => {
+          y.push({
+            type: "Feature",
+            properties: { _kind: "dot", _id: f.id, _isFirst: a === 0 },
+            geometry: { type: "Point", coordinates: I }
+          });
+        });
+    }
+    _ && o.length >= 2 && y.push({
+      type: "Feature",
+      properties: { _kind: "live-line" },
+      geometry: { type: "LineString", coordinates: o }
+    }), _ && r === "area" && o.length >= 3 && y.push({
+      type: "Feature",
+      properties: { _kind: "live-area" },
+      geometry: { type: "Polygon", coordinates: [[...o, o[0]]] }
+    }), _ && M && N && y.push({
+      type: "Feature",
+      properties: { _kind: "ghost" },
+      geometry: { type: "LineString", coordinates: [N, M] }
+    }), _ && r === "area" && M && o.length >= 2 && y.push({
+      type: "Feature",
+      properties: { _kind: "close-hint" },
+      geometry: { type: "LineString", coordinates: [M, o[0]] }
+    }), _ && o.forEach((f, b) => {
+      y.push({
+        type: "Feature",
+        properties: { _kind: "live-dot", _isFirst: b === 0 },
+        geometry: { type: "Point", coordinates: f }
+      });
+    }), ws(e, y);
+  }, [
+    e,
+    _,
+    o,
+    r,
+    s,
+    P,
+    i,
+    M,
+    N,
+    t
+  ]), K(() => {
+    const y = (I) => {
+      var p, m;
+      const a = (p = I.features) == null ? void 0 : p[0];
+      if (!a) return;
+      const x = (m = a.properties) == null ? void 0 : m._id;
+      x && (Pr(), I.originalEvent.stopPropagation(), u(x));
+    }, f = (I) => {
+      var F, S, L, B;
+      const a = (F = I.features) == null ? void 0 : F[0];
+      if (!a) return;
+      const x = (S = a.properties) == null ? void 0 : S._id;
+      if (!x) return;
+      T(x);
+      const p = (L = a.properties) == null ? void 0 : L._kind, m = (B = a.properties) == null ? void 0 : B._segIdx;
+      if (p === "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 k = mt(_e(We([j, h])) * 1e3, g);
+            Ss(`${k.value} ${k.unit}`, I.originalEvent.clientX, I.originalEvent.clientY);
+          }
+        }
+      }
+    }, b = (I) => {
+      var p, m;
+      const a = (p = I.features) == null ? void 0 : p[0];
+      if (!a) return;
+      ((m = a.properties) == null ? void 0 : m._kind) === "segment" && ro(I.originalEvent.clientX, I.originalEvent.clientY);
+    }, C = () => {
+      T(null), Cn();
+    }, R = (I) => {
+      try {
+        e.queryRenderedFeatures(I.point, { layers: Rt }).length === 0 && c(null);
+      } catch {
+      }
+    };
+    for (const I of Rt)
+      e.on("click", I, y), e.on("mouseenter", I, f), e.on("mousemove", I, b), e.on("mouseleave", I, C);
+    return e.on("click", R), () => {
+      for (const I of Rt)
+        e.off("click", I, y), e.off("mouseenter", I, f), e.off("mousemove", I, b), e.off("mouseleave", I, C);
+      e.off("click", R), Cn();
+    };
+  }, [e, u, c, s, g.unit, g.display, g.precision]);
+  const E = r === "distance" ? 1 : 2, A = M && o.length >= E ? [...o, M] : o, D = bs(A, r, g, w), q = M ?? N;
+  return /* @__PURE__ */ fe(lt, { children: [
+    s.map((y) => /* @__PURE__ */ X(Ls, { map: e, m: y }, y.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((y) => y.editingMode), [u, c] = le(null), [v, d] = le(null), g = Oo(), w = An(), P = $(null), T = $(null), _ = $(null), M = $(null);
+  K(() => () => {
+    _.current && (_.current.remove(), _.current = null);
+  }, [e]);
+  const N = vt();
+  K(() => {
+    ks(e, u, v);
+  }, [e, u, v, N]);
+  const E = ve(
+    (y) => Mo(t.getState(), n.getState(), y),
+    [t, n]
+  ), A = ve(() => {
+    _.current && (_.current.remove(), _.current = null);
+  }, []), D = ve(() => {
+    c(null), d(null), P.current = null, A(), T.current && (T.current.abort(), T.current = null);
+  }, [A]), q = ve((y) => {
+    const f = P.current;
+    if (D(), !("pieces" in y)) {
+      E(y);
+      return;
+    }
+    if (!f) return;
+    const b = new AbortController();
+    T.current = b, Fs(y, f).then((C) => {
+      b.signal.aborted || (T.current = null, C && E(C));
+    });
+  }, [E, D]);
+  return K(() => {
+    if (!u && l !== "pick-shape") return;
+    function y(f) {
+      f.key === "Escape" && i(f) && D();
+    }
+    return window.addEventListener("keydown", y), () => window.removeEventListener("keydown", y);
+  }, [u, l, D, i]), K(() => {
+    if (l !== "pick-shape") return;
+    const y = (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 C = f.lngLat.lng, R = f.lngLat.lat;
+      P.current = [C, R], Ps();
+      const I = document.createElement("div");
+      I.style.cssText = "width:64px;height:64px;pointer-events:none;display:flex;align-items:center;justify-content:center;", I.innerHTML = `
+        <div class="elm-osm-pulse-ring" style="position:absolute"></div>
+        <div class="elm-osm-spinner"></div>
+      `, _.current = new De.Marker({ element: I, anchor: "center" }).setLngLat([C, R]).addTo(e);
+      const a = Rs(e, f.point), { overpass: x, fetch: p } = r.current, m = x === !1;
+      (a.length > 0 || m ? Promise.resolve(a) : Qo(R, C, Fo(e.getZoom()), [C, R], { ...x, fetch: p, signal: b.signal })).then((S) => {
+        A(), 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" && (A(), s({ type: "error", code: S instanceof tr ? S.code : "unknown", source: "picker", message: er(S), cause: S }), D());
+      });
+    };
+    return e.on("click", y), () => {
+      e.off("click", y);
+    };
+  }, [l, e, D, A, q, s]), K(() => {
+    if (!u || !P.current) return;
+    const y = P.current;
+    let f;
+    function b() {
+      if (!M.current) {
+        f = requestAnimationFrame(b);
+        return;
+      }
+      const C = e.project(y), R = e.getContainer().getBoundingClientRect();
+      M.current.style.left = `${R.left + C.x + 16}px`, M.current.style.top = `${R.top + C.y - 8}px`, f = requestAnimationFrame(b);
+    }
+    return f = requestAnimationFrame(b), () => cancelAnimationFrame(f);
+  }, [u, e]), K(() => {
+    if (!u) return;
+    const y = (I) => {
+      var m, F;
+      const a = (m = I.features) == null ? void 0 : m[0];
+      if (!a) return;
+      const x = (F = a.properties) == null ? void 0 : F._idx;
+      if (typeof x != "number") return;
+      I.originalEvent.stopPropagation();
+      const p = u[x];
+      p && q(p);
+    }, f = (I) => {
+      var p, m;
+      const a = (p = I.features) == null ? void 0 : p[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);
+    }, C = () => {
+      d(null), b();
+    }, R = ["elm-osm-trace-fill", "elm-osm-trace-line"];
+    for (const I of R)
+      e.on("click", I, y), e.on("mouseenter", I, f), e.on("mouseleave", I, C);
+    return () => {
+      for (const I of R)
+        e.off("click", I, y), e.off("mouseenter", I, f), e.off("mouseleave", I, C);
+      b();
+    };
+  }, [u, e, q, n]), K(() => {
+    l !== "pick-shape" && D();
+  }, [l, D]), u ? Ze(
+    /* @__PURE__ */ X("div", { ref: M, "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((y, f) => /* @__PURE__ */ fe(
+      "button",
+      {
+        onClick: () => q(y),
+        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: y.name || `Unnamed ${y.type.toLowerCase()}` }),
+            /* @__PURE__ */ X("span", { className: "text-xs text-(--elm-text-subtle,var(--color-gray-400))", children: y.type })
+          ] })
+        ]
+      },
+      "key" in y ? y.key : `${y.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: C } = mt(f * 1e3, n);
+    return `${b} ${C}`;
+  }, s = (f) => {
+    const { value: b, unit: C } = Ht(f, o);
+    return `${b} ${C}`;
+  }, 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), P = W((f) => f.freehandClosed), T = W((f) => f.routeWaypoints), _ = oo(e, l, l !== "none"), [M, N] = le(null), E = u ?? _;
+  K(() => {
+    if (!E) {
+      N(null);
+      return;
+    }
+    N(e.project(E));
+    const f = () => N(E ? e.project(E) : null);
+    return e.on("move", f), e.on("zoom", f), () => {
+      e.off("move", f), e.off("zoom", f);
+    };
+  }, [e, E == null ? void 0 : E[0], E == null ? void 0 : E[1]]);
+  const A = $(null), [D, q] = le({ w: 0, h: 0 });
+  if (uo(() => {
+    const f = A.current;
+    f && (f.offsetWidth !== D.w || f.offsetHeight !== D.h) && q({ w: f.offsetWidth, h: f.offsetHeight });
+  }), !i || l === "none" || !E || !M) return null;
+  const y = [];
+  try {
+    if (l === "place-point")
+      y.push({ label: "", value: `${E[1].toFixed(6)}, ${E[0].toFixed(6)}` });
+    else if (l === "draw-line" || l === "slice-shape") {
+      const f = [...c, E];
+      if (f.length >= 2) {
+        const b = We(f);
+        y.push({ label: "Length", value: r(_e(b)) }), y.push({ label: "Segment length", value: r(Pe(f[f.length - 2], f[f.length - 1])) });
+      }
+      y.push({ label: "", value: `${E[1].toFixed(6)}, ${E[0].toFixed(6)}` });
+    } else if (l === "draw-polygon" || l === "cut-hole") {
+      const f = [...v, E];
+      if (f.length >= 3) {
+        const b = [...f, f[0]], C = ut([b]);
+        y.push({ label: "Area", value: s(dt(C)) }), y.push({ label: "Perimeter", value: r(_e(C)) });
+        const R = Bn(C);
+        y.push({ label: "Height", value: r(Pe([R[0], R[1]], [R[0], R[3]])) }), y.push({ label: "Width", value: r(Pe([R[0], R[1]], [R[2], R[1]])) });
+      } else f.length === 2 && y.push({ label: "Segment length", value: r(Pe(f[0], f[1])) });
+      y.push({ label: "", value: `${E[1].toFixed(6)}, ${E[0].toFixed(6)}` });
+    } else if (l === "draw-circle") {
+      if (d) {
+        const f = Pe(d, E);
+        y.push({ label: "Radius", value: r(f) }), y.push({ label: "Area", value: s(Math.PI * (f * 1e3) * (f * 1e3)) });
+      }
+      y.push({ label: "", value: `${E[1].toFixed(6)}, ${E[0].toFixed(6)}` });
+    } else if (l === "draw-rect") {
+      if (g) {
+        const f = Pe([g[0], g[1]], [E[0], g[1]]), b = Pe([g[0], g[1]], [g[0], E[1]]), C = f * b * 1e6;
+        y.push({ label: "Area", value: s(C) }), y.push({ label: "Width", value: r(f) }), y.push({ label: "Height", value: r(b) });
+      }
+      y.push({ label: "", value: `${E[1].toFixed(6)}, ${E[0].toFixed(6)}` });
+    } else if (l === "draw-route") {
+      const f = [...T, E];
+      f.length >= 2 && y.push({ label: "Straight distance", value: r(Pe(f[f.length - 2], f[f.length - 1])) }), y.push({ label: "", value: `${E[1].toFixed(6)}, ${E[0].toFixed(6)}` });
+    } else if (l === "draw-freehand") {
+      if (w.length >= 3 && P) {
+        const f = [...w, w[0]], b = ut([f]);
+        y.push({ label: "Area", value: s(dt(b)) }), y.push({ label: "Perimeter", value: r(_e(b)) });
+      } else if (w.length >= 2) {
+        const f = We(w);
+        y.push({ label: "Length", value: r(_e(f)) });
+      }
+      y.push({ label: "", value: `${E[1].toFixed(6)}, ${E[0].toFixed(6)}` });
+    }
+  } catch {
+  }
+  return y.length === 0 ? null : Ze(
+    /* @__PURE__ */ X(
+      "div",
+      {
+        ref: A,
+        className: "elm-measurement-tooltip",
+        style: {
+          position: "absolute",
+          ...Fn(M.x, M.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: y.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 li() {
+  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
+    ] });
+  }
+), ai = 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-mSgM9UsZ.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 P = (D) => D instanceof Error ? D.message : String(D), T = i.resolveBasemap(t, o), _ = typeof T == "object" && "style" in T && typeof T.style == "string", M = (D) => {
+      N(), v.current = null, u(new Tt(ln(D.error), "basemap", `The basemap could not be loaded (${P(D.error)}).`, { cause: D.error }));
+    }, N = () => {
+      e.off("error", M), e.off("styledata", N);
+    }, E = () => {
+      w || !(e.isStyleLoaded() || e.getSource("elm-features")) || (w = !0, e.off("styledata", E), v.current = g, i.setBasemap(e, t, { theme: o, network: s.current }).then(() => {
+        _ && !A && (e.on("error", M), e.once("styledata", N));
+      }, (D) => {
+        v.current = null, u(new Tt(ln(D), "basemap", `The basemap could not be switched (${P(D)}). The map keeps the previous one.`, { cause: D }));
+      }));
+    };
+    let A = !1;
+    return e.on("styledata", E), E(), () => {
+      w = !0, A = !0, e.off("styledata", E), N();
+    };
+  }, [e, i, t, o]);
+}
+function ui(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), P = lo();
+  K(() => {
+    let a = !0;
+    return zs().then((x) => a && w(x), (x) => {
+      a && !yt && (yt = !0, P(co(x)));
+    }), () => {
+      a = !1;
+    };
+  }, []);
+  const T = ke(), _ = Bt(() => t ?? ["auto", ...$s], [t]), M = _.map(je);
+  (_.filter((a) => typeof a == "object" && !a.id && !a.label && !("url" in a) && typeof a.style != "string").length > 1 || new Set(M).size < M.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 ? _.find((x, p) => je(x, p) === a) : void 0;
+  }), [E, A] = le(N ?? o), [D, q] = le(n !== void 0 || e.defaultValue !== void 0 || N !== void 0), y = n ?? E, f = _.indexOf(y), b = f >= 0 ? M[f] : je(y, -1);
+  Hs(D || n !== void 0 ? v : null, y, {
+    theme: d,
+    initialApplied: D && i && b === je(o, _.indexOf(o))
+  });
+  const C = ve((a) => {
+    const x = M.indexOf(a);
+    if (x < 0) return;
+    const p = _[x];
+    q(!0), n === void 0 && A(p), s && (typeof p == "string" || p.id) && or(s, a, T), r == null || r(p);
+  }, [M, _, n, s, r, T]);
+  if (!g) return null;
+  const R = (a) => {
+    var x;
+    return (x = g.BASEMAPS.find((p) => p.id === a)) == null ? void 0 : x.thumbnail;
+  }, I = _.map((a, x) => {
+    const p = M[x], m = typeof a == "string" ? g.BASEMAPS.find((F) => F.id === a) : void 0;
+    return {
+      id: p,
+      label: a === "auto" ? "Auto" : (m == null ? void 0 : m.label) ?? (typeof a == "object" && a.label || p),
+      // Auto shows both looks it switches between (light → streets, dark → dark).
+      thumbnail: a === "auto" ? [R("streets"), R("dark")].every(Boolean) ? [R("streets"), R("dark")] : void 0 : typeof a == "string" ? R(a) : a.thumbnail
+    };
+  });
+  return /* @__PURE__ */ X(Uo, { options: I, value: b, onChange: C, size: l, tooltipSide: u });
+}
+export {
+  gi as ActiveDrawingToolbar,
+  ui as BasemapControl,
+  ys as BoundaryLayer,
+  rs as BoxSelectHandler,
+  Rr as DrawingLayer,
+  Ar as DrawingPreviewLayer,
+  yi as EditingToolbar,
+  ai as ElementEditorControls,
+  Mi as ElementEditorError,
+  pi as ElementEditorUIProvider,
+  us as FeatureInteractionLayer,
+  Er as FeatureLayer,
+  gr as FeatureStyleProvider,
+  ci as FitBounds,
+  hi as FloatingToolbar,
+  mi as GeoStoreProvider,
+  ms as GeometryProcessingPreview,
+  vi as MapControllerProvider,
+  Es as MeasurePreviewLayer,
+  Ks as MeasurementTooltip,
+  _s as OsmTraceHandler,
+  gs as SnapController,
+  xi as StoreContext,
+  es as TransformControls,
+  $r as VertexEditor,
+  Vn as findSnapPoint,
+  Dt as snapToAngle,
+  Hs as useBasemap,
+  wi as useDataStore,
+  yr as useFeatureStyle,
+  Si as useGeoStore,
+  bi as useKeyboardShortcuts,
+  Li as useMapController,
+  li as useMapLibre,
+  Ei as useSetMapController,
+  Pi as useUIStore
+};