@artsdatabanken/nbic-map-component 0.3.0

package/dist/index.js

@@ -0,0 +1,3711 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/core/projections.ts
+import proj4 from "proj4";
+import { register } from "ol/proj/proj4";
+import { get as getProjection } from "ol/proj";
+proj4.defs("EPSG:25833", "+proj=utm +zone=33 +ellps=GRS80 +units=m +no_defs +type=crs");
+proj4.defs("EPSG:25832", "+proj=utm +zone=32 +ellps=GRS80 +units=m +no_defs +type=crs");
+proj4.defs("EPSG:25835", "+proj=utm +zone=35 +ellps=GRS80 +units=m +no_defs +type=crs");
+proj4.defs("EPSG:32632", "+proj=utm +zone=32 +datum=WGS84 +units=m +no_defs +type=crs");
+proj4.defs("EPSG:32633", "+proj=utm +zone=33 +datum=WGS84 +units=m +no_defs +type=crs");
+register(proj4);
+var extent32 = [-2e6, 35e5, 3545984, 9045984];
+var extent33 = [-25e5, 35e5, 3045984, 9045984];
+var extent35 = [-35e5, 35e5, 2045984, 9045984];
+var extentGeographic = [-180, -90, 180, 90];
+var extentGoogle = [
+  -2003750834e-2,
+  -2003750834e-2,
+  2003750834e-2,
+  2003750834e-2
+];
+var mapBounds = [
+  {
+    epsg: "EPSG:25832",
+    extent: extent32
+  },
+  {
+    epsg: "EPSG:25833",
+    extent: extent33
+  },
+  {
+    epsg: "EPSG:25835",
+    extent: extent35
+  },
+  {
+    epsg: "EPSG:32632",
+    extent: extent32
+  },
+  {
+    epsg: "EPSG:32633",
+    extent: extent33
+  },
+  {
+    epsg: "EPSG:32635",
+    extent: extent35
+  },
+  {
+    epsg: "EPSG:4326",
+    extent: extentGeographic
+  },
+  {
+    epsg: "EPSG:3857",
+    extent: extentGoogle
+  },
+  {
+    epsg: "EPSG:900913",
+    extent: extentGoogle
+  }
+];
+
+// src/core/state/store.ts
+function createEmitter() {
+  const listeners = {};
+  return {
+    on(type, cb) {
+      (listeners[type] ??= []).push(cb);
+      return () => this.off(type, cb);
+    },
+    once(type, cb) {
+      const wrapper = (payload) => {
+        cb(payload);
+        this.off(type, wrapper);
+      };
+      this.on(type, wrapper);
+    },
+    off(type, cb) {
+      listeners[type] = (listeners[type] ?? []).filter((fn) => fn !== cb);
+    },
+    emit(type, payload) {
+      (listeners[type] ?? []).forEach((fn) => fn(payload));
+    }
+  };
+}
+
+// src/core/ol/OlMapEngine.ts
+import OlMap from "ol/Map";
+import { View } from "ol";
+
+// src/core/ol/adapters/layers.ts
+import VectorSource3 from "ol/source/Vector";
+import VectorLayer from "ol/layer/Vector";
+import TileLayer from "ol/layer/Tile";
+import TileSource from "ol/source/Tile";
+
+// src/core/ol/adapters/sources.ts
+import OSM from "ol/source/OSM";
+import XYZ from "ol/source/XYZ";
+import WMTS from "ol/source/WMTS";
+import VectorSource2 from "ol/source/Vector";
+import GeoJSON2 from "ol/format/GeoJSON";
+
+// src/core/ol/adapters/wmts-grid.ts
+import WMTSTileGrid from "ol/tilegrid/WMTS";
+import { getTopLeft, getWidth } from "ol/extent";
+function makeGridFromExtent(extent, tileSize = 256, levels = 19) {
+  const size = getWidth(extent) / tileSize;
+  const resolutions = Array.from({ length: levels }, (_, z2) => size / Math.pow(2, z2));
+  const matrixIds = Array.from({ length: levels }, (_, z2) => z2.toString());
+  return new WMTSTileGrid({
+    origin: getTopLeft(extent),
+    resolutions,
+    matrixIds,
+    tileSize,
+    extent
+  });
+}
+
+// src/core/ol/adapters/wfs-loader.ts
+import { bbox as bboxStrategy } from "ol/loadingstrategy";
+import VectorSource from "ol/source/Vector";
+import GeoJSON from "ol/format/GeoJSON";
+import GML32 from "ol/format/GML32";
+import GML3 from "ol/format/GML3";
+import { get as getProjection2 } from "ol/proj";
+import { getWidth as getWidth2 } from "ol/extent";
+function zoomFromResolution(resolution, projectionLike) {
+  const proj = getProjection2(projectionLike) || void 0;
+  const baseRes = proj?.getExtent() ? getWidth2(proj.getExtent()) / 256 : 156543.03392804097;
+  const res = resolution > 0 ? resolution : baseRes;
+  const zoom = Math.log2(baseRes / res);
+  return Number.isFinite(zoom) ? zoom : 0;
+}
+function zoomGatedBboxStrategy(minZoom) {
+  return (extent, resolution, projection) => {
+    if (typeof minZoom === "number") {
+      const z2 = zoomFromResolution(resolution, projection);
+      if (z2 < minZoom) return [];
+    }
+    return bboxStrategy(extent, resolution);
+  };
+}
+function buildGetFeatureUrl(o, extent, srsName, format) {
+  const version = o.version ?? "2.0.0";
+  const is20 = version === "2.0.0";
+  const qp = new URLSearchParams({
+    service: "WFS",
+    request: "GetFeature",
+    version,
+    [is20 ? "typenames" : "typename"]: o.typeName,
+    srsName
+  });
+  qp.set("bbox", `${extent.join(",")},${srsName}`);
+  if (format === "json") {
+    qp.set("outputFormat", o.outputFormat ?? "application/json");
+  } else {
+    qp.set("outputFormat", o.outputFormat ?? "text/xml; subtype=gml/3.2.1");
+  }
+  if (is20) {
+    const count = o.maxFeatures ?? o.pageSizeDefault ?? 2e3;
+    qp.set("count", String(count));
+  } else if (o.maxFeatures) {
+    qp.set("maxFeatures", String(o.maxFeatures));
+  }
+  if (o.params) Object.entries(o.params).forEach(([k, v]) => qp.set(k, String(v)));
+  const sep = o.url.includes("?") ? "&" : "?";
+  return `${o.url}${sep}${qp.toString()}`;
+}
+function normalizeGmlXml(xmlText) {
+  const parser = new DOMParser();
+  const xmlDoc = parser.parseFromString(xmlText, "text/xml");
+  const serializer = new XMLSerializer();
+  const normalized = serializer.serializeToString(xmlDoc).replace(/srsdimension/g, "srsDimension").replace(/wfs:member/g, "wfs:featureMember");
+  return parser.parseFromString(normalized, "text/xml");
+}
+var dftCache = /* @__PURE__ */ new Map();
+async function describeFeatureTypeOnce(baseUrl, typeName, version = "2.0.0") {
+  const cacheKey = `${baseUrl}::${version}::${typeName}`;
+  const existing = dftCache.get(cacheKey);
+  if (existing) return existing;
+  const is20 = version === "2.0.0";
+  const qp = new URLSearchParams({
+    service: "WFS",
+    request: "DescribeFeatureType",
+    version,
+    [is20 ? "typenames" : "typename"]: typeName,
+    outputFormat: "application/gml+xml; version=3.2"
+  });
+  const sep = baseUrl.includes("?") ? "&" : "?";
+  const url = `${baseUrl}${sep}${qp.toString()}`;
+  const res = await fetch(url);
+  const text = await res.text();
+  const doc = new DOMParser().parseFromString(text, "application/xml");
+  const schemaEl = doc.querySelector("schema, xs\\:schema");
+  const featureNS = schemaEl?.getAttribute("targetNamespace") || "http://mapserver.gis.umn.edu/mapserver";
+  const local = typeName.includes(":") ? typeName.split(":")[1] : typeName;
+  let geometryName;
+  const elDef = Array.from(doc.querySelectorAll("element, xs\\:element")).find((e) => e.getAttribute("name") === local) || null;
+  const typeRef = elDef?.getAttribute("type") || null;
+  if (typeRef) {
+    const localType = typeRef.includes(":") ? typeRef.split(":")[1] : typeRef;
+    const complex = Array.from(doc.querySelectorAll("complexType, xs\\:complexType")).find((ct) => ct.getAttribute("name") === localType);
+    if (complex) {
+      const propEls = Array.from(complex.querySelectorAll("element, xs\\:element"));
+      const geomProp = propEls.find((pe) => {
+        const t = pe.getAttribute("type") ?? "";
+        return /gml:.*(Geometry|Point|LineString|Curve|Surface|Polygon|Multi)/i.test(t);
+      });
+      if (geomProp) geometryName = geomProp.getAttribute("name") || void 0;
+    }
+  }
+  const info = { featureNS: featureNS ?? "", featureType: local ?? "", geometryName };
+  dftCache.set(cacheKey, info);
+  return info;
+}
+function createWfsVectorSource(opts, viewProjection) {
+  const preferJson = !opts.outputFormat || /json/i.test(opts.outputFormat);
+  const source = new VectorSource({
+    // Gate at the strategy level so OL re-calls the loader automatically when zoom crosses the gate.
+    strategy: zoomGatedBboxStrategy(opts.minZoomToLoad)
+  });
+  source.setLoader(async (extent, _resolution, proj) => {
+    const srs = opts.srsName ?? String(proj ?? viewProjection);
+    const tryOnce = async (fmt) => {
+      const url = buildGetFeatureUrl(opts, extent, srs, fmt);
+      const resp = await fetch(url, { headers: opts.headers });
+      const text = await resp.text();
+      const ct = resp.headers.get("content-type") ?? "";
+      return { ok: resp.ok, text, ct, url };
+    };
+    try {
+      if (preferJson) {
+        const r = await tryOnce("json");
+        const looksXml = r.text.trim().startsWith("<");
+        const notJsonCT = !/json/i.test(r.ct);
+        if (r.ok && !looksXml && !notJsonCT) {
+          const features2 = new GeoJSON({
+            dataProjection: srs,
+            featureProjection: String(proj ?? viewProjection)
+          }).readFeatures(r.text);
+          source.addFeatures(features2);
+          return;
+        }
+      }
+      const r2 = await tryOnce("gml");
+      if (!r2.ok) {
+        throw new Error(`WFS error ${r2.ct} from ${r2.url}: ${r2.text.slice(0, 200)}`);
+      }
+      const xmlDoc = normalizeGmlXml(r2.text);
+      const version = opts.version ?? "2.0.0";
+      const dft = {
+        featureNS: opts.featureNS,
+        featureType: opts.featureType,
+        geometryName: opts.geometryName
+      };
+      if (!dft.featureNS || !dft.featureType) {
+        const info = await describeFeatureTypeOnce(opts.url, opts.typeName, version);
+        dft.featureNS = dft.featureNS ?? info.featureNS;
+        dft.featureType = dft.featureType ?? info.featureType;
+        dft.geometryName = dft.geometryName ?? info.geometryName;
+      }
+      const isGml32 = /gml\/3\.2/i.test(r2.ct) || /version=3\.2/i.test(r2.text) || r2.text.includes("http://www.opengis.net/gml/3.2");
+      const gml = isGml32 ? new GML32({ featureNS: dft.featureNS, featureType: dft.featureType, srsName: srs }) : new GML3({ featureNS: dft.featureNS, featureType: dft.featureType, srsName: srs });
+      const tbl = gml["FEATURE_COLLECTION_PARSERS"];
+      if (tbl && tbl["http://www.opengis.net/gml/3.2"]) {
+        tbl["http://www.opengis.net/gml"] = tbl["http://www.opengis.net/gml/3.2"];
+        tbl["http://www.opengis.net/wfs/2.0"] = tbl["http://www.opengis.net/gml/3.2"];
+      }
+      let features = gml.readFeatures(xmlDoc, {
+        dataProjection: srs,
+        featureProjection: String(proj ?? viewProjection),
+        ...dft.geometryName ? { geometryName: dft.geometryName } : {}
+      });
+      if (!features.length) {
+        const serialized = new XMLSerializer().serializeToString(xmlDoc);
+        features = gml.readFeatures(serialized, {
+          dataProjection: srs,
+          featureProjection: String(proj ?? viewProjection),
+          ...dft.geometryName ? { geometryName: dft.geometryName } : {}
+        });
+      }
+      if (features.length) {
+        source.addFeatures(features);
+      } else {
+        console.warn("[WFS] Parsed 0 features", {
+          url: r2.url,
+          featureNS: dft.featureNS,
+          featureType: dft.featureType,
+          geometryName: dft.geometryName,
+          isGml32
+        });
+      }
+    } catch (err) {
+      console.error("WFS loader error", err);
+    }
+  });
+  return source;
+}
+
+// src/core/ol/adapters/sources.ts
+import { get as getProj } from "ol/proj";
+import WMTSTileGrid2 from "ol/tilegrid/WMTS";
+import { getTopLeft as getTopLeft2, getWidth as getWidth3 } from "ol/extent";
+
+// src/core/ol/adapters/wmts-presets.ts
+function wmtsPreset(key) {
+  const matrixXMin = -5118180;
+  const matrixYMin = 7224500;
+  const matrixWidth = 5545984;
+  const matrixHeight = 2772992;
+  const matrixExtent = [
+    matrixXMin,
+    matrixYMin,
+    matrixXMin + matrixWidth,
+    matrixYMin + matrixHeight
+  ];
+  switch (key) {
+    case "npolar-svalbard-32633": {
+      return {
+        layerExtent: [369976, 8221306, 878234, 9010718],
+        matrixExtent,
+        matrixIds: Array.from({ length: 18 }, (_, z2) => z2.toString())
+      };
+    }
+    case "npolar-janmayen-25833": {
+      return {
+        layerExtent: [-393783, 7978220, 276963, 8084965],
+        matrixExtent,
+        matrixIds: Array.from({ length: 18 }, (_, z2) => z2.toString())
+      };
+    }
+  }
+}
+
+// src/core/ol/adapters/sources.ts
+function resolveOlSource(input, resolveRef = (id) => {
+  throw new Error(`Source ref '${id}' cannot be resolved (no registry wired).`);
+}) {
+  if ("ref" in input) {
+    return resolveRef(input.ref);
+  }
+  return toOlSource(input);
+}
+function toOlSource(def) {
+  switch (def.type) {
+    case "osm":
+      return new OSM();
+    case "xyz": {
+      const opts = def.options;
+      return new XYZ({
+        url: opts.url,
+        minZoom: opts.minZoom,
+        maxZoom: opts.maxZoom,
+        attributions: opts.attributions,
+        tileSize: opts.tileSize
+      });
+    }
+    case "wmts": {
+      let buildGridFromPreset2 = function(p, tileSize2, levels2) {
+        const matrixExtent = p.matrixExtent ?? p.extent;
+        const layerExtent = p.layerExtent ?? p.extent;
+        return new WMTSTileGrid2({
+          origin: getTopLeft2(matrixExtent),
+          resolutions: Array.from(
+            { length: levels2 },
+            (_, z2) => getWidth3(matrixExtent) / tileSize2 / Math.pow(2, z2)
+          ),
+          matrixIds: p.matrixIds,
+          tileSize: tileSize2,
+          extent: layerExtent
+          // clip to visible data
+        });
+      };
+      var buildGridFromPreset = buildGridFromPreset2;
+      const o = def.options;
+      const tileSize = o.tileSize ?? 256;
+      const levels = o.levels ?? 18;
+      let tileGrid;
+      const wantsDefault028 = o.matrixSetId === "default028mm" || o.matrixSet === "default028mm";
+      if (!tileGrid && wantsDefault028) {
+        const presetKeyByProj = {
+          "EPSG:32633": "npolar-svalbard-32633",
+          "EPSG:25833": "npolar-janmayen-25833"
+        };
+        const key = o.projection ? presetKeyByProj[o.projection] : void 0;
+        if (key) {
+          const p = wmtsPreset(key);
+          tileGrid = buildGridFromPreset2(p, tileSize, levels);
+        }
+      }
+      if (!tileGrid) {
+        const proj = o.projection ? getProj(o.projection) : void 0;
+        const extent = o.extent ?? proj?.getExtent() ?? (o.projection ? mapBounds.find((m) => m.epsg === o.projection)?.extent : void 0);
+        if (!extent) {
+          throw new Error(
+            `WMTS ${o.layer}: missing projection extent; set options.extent or ensure projection is registered with an extent.`
+          );
+        }
+        tileGrid = makeGridFromExtent(extent, tileSize, levels);
+      }
+      const isRest = /\/1\.0\.0\/?$/i.test(o.url) || /\/wmts\/1\.0\.0\//i.test(o.url);
+      const baseUrl = o.url.replace(/\/?$/, "/");
+      const src = new WMTS({
+        layer: o.layer,
+        matrixSet: o.matrixSetId ?? o.matrixSet ?? "EPSG:3857",
+        format: o.format ?? "image/png",
+        style: o.style ?? "default",
+        tileGrid,
+        wrapX: o.wrapX ?? false,
+        // UTM usually false
+        transition: 0,
+        attributions: o.attribution,
+        ...o.projection ? { projection: getProj(o.projection) } : {},
+        ...isRest ? { urls: [baseUrl], requestEncoding: "REST" } : { url: o.url, requestEncoding: "KVP" },
+        crossOrigin: "anonymous",
+        tileLoadFunction: o.tileLoadFunction ? (tile, src2) => o.tileLoadFunction(tile, src2) : void 0
+      });
+      if (o.urlParamOverrides && Object.keys(o.urlParamOverrides).length) {
+        const orig = src.getTileUrlFunction();
+        src.setTileUrlFunction((coord, pr, pj) => {
+          const u = new URL(String(orig(coord, pr, pj)), window.location.origin);
+          for (const [k, v] of Object.entries(o.urlParamOverrides)) u.searchParams.set(k, v);
+          return u.toString();
+        });
+      }
+      return src;
+    }
+    case "geojson": {
+      const opts = def.options;
+      if (opts.text && opts.text.trim().length) {
+        const fmt = new GeoJSON2({ dataProjection: opts.dataProjection, featureProjection: opts.featureProjection });
+        const features = fmt.readFeatures(opts.text);
+        const src = new VectorSource2();
+        if (features.length) src.addFeatures(features);
+        return src;
+      }
+      if (opts.url) {
+        return new VectorSource2({
+          url: opts.url,
+          format: new GeoJSON2({ dataProjection: opts.dataProjection, featureProjection: opts.featureProjection })
+        });
+      }
+      throw new Error("geojson source: provide either options.url or options.text");
+    }
+    case "wfs": {
+      const o = def.options;
+      const viewProj = o.srsName ?? "EPSG:3857";
+      return createWfsVectorSource(o, viewProj);
+    }
+    case "memory": {
+      return new VectorSource2();
+    }
+    default: {
+      const type = def.type;
+      throw new Error(`Unknown source type: ${type}`);
+    }
+  }
+}
+
+// src/core/ol/adapters/styles.ts
+import { Style, Fill, Stroke, Circle as CircleStyle, Text, Icon, RegularShape } from "ol/style";
+import { Circle as CircleGeom } from "ol/geom";
+import Point from "ol/geom/Point";
+import * as olColor from "ol/color";
+
+// src/core/ol/adapters/gradient.ts
+import { asArray, asString } from "ol/color";
+function makeGradientRenderer(color, outerScale = 1.4, stops = [[0, 0], [0.6, 0.2], [1, 0.8]], strokeWidth = 1) {
+  const withAlpha = (c, a) => {
+    const arr = asArray(c);
+    arr[3] = a;
+    return asString(arr);
+  };
+  const rf = (pixelCoords, state) => {
+    const coords = pixelCoords;
+    if (!coords || coords.length < 2) return;
+    const center = coords[0];
+    const edge = coords[1];
+    if (!center || !edge || center.length < 2 || edge.length < 2) return;
+    const x = center[0];
+    const y = center[1];
+    const x1 = edge[0];
+    const y1 = edge[1];
+    const ctx = state.context;
+    const dx = x1 - x, dy = y1 - y;
+    const radius = Math.sqrt(dx * dx + dy * dy);
+    const innerRadius = 0;
+    const outerRadius = radius * outerScale;
+    const gradient = ctx.createRadialGradient(x, y, innerRadius, x, y, outerRadius);
+    for (const [stop, alpha] of stops) {
+      gradient.addColorStop(stop, withAlpha(color, alpha));
+    }
+    ctx.beginPath();
+    ctx.arc(x, y, radius, 0, 2 * Math.PI, true);
+    ctx.fillStyle = gradient;
+    ctx.fill();
+    ctx.beginPath();
+    ctx.arc(x, y, radius, 0, 2 * Math.PI, true);
+    ctx.lineWidth = strokeWidth;
+    ctx.strokeStyle = withAlpha(color, 1);
+    ctx.stroke();
+  };
+  return rf;
+}
+
+// src/core/ol/adapters/styles.ts
+var fallback = new Style({
+  fill: new Fill({ color: "rgba(0,0,0,0.1)" }),
+  stroke: new Stroke({ color: "#666", width: 1 })
+});
+var thumbCache = /* @__PURE__ */ new Map();
+function getInnerFeatureFromCluster(feature) {
+  const members = feature.get?.("features");
+  if (members && members.length === 1) {
+    const m0 = members[0];
+    return m0 ?? feature;
+  }
+  return feature;
+}
+function getClusterSize(feature) {
+  const members = feature.get?.("features");
+  return members?.length ?? 0;
+}
+function makeThumbnailMarkerStyle(thumbnail, opts) {
+  const cached = thumbCache.get(thumbnail);
+  if (cached) return cached;
+  const styles = [
+    new Style({
+      image: new RegularShape({
+        stroke: new Stroke({ color: opts.frameBorderColor, width: opts.frameBorderWidth }),
+        fill: new Fill({ color: opts.frameFillColor }),
+        points: 4,
+        radius: opts.frameRadius,
+        angle: Math.PI / 4,
+        displacement: opts.frameDisplacement
+      })
+    }),
+    new Style({
+      image: new RegularShape({
+        fill: new Fill({ color: opts.pinFillColor }),
+        points: 3,
+        radius: opts.pinRadius,
+        rotation: opts.pinRotation,
+        angle: 0
+      })
+    }),
+    new Style({
+      image: new Icon({
+        anchor: [0.52, 1],
+        anchorXUnits: "fraction",
+        anchorYUnits: "fraction",
+        src: thumbnail,
+        opacity: 1,
+        scale: opts.imageScale,
+        offsetOrigin: "top-left",
+        offset: [0, 0],
+        size: opts.imageSize,
+        crossOrigin: opts.crossOrigin
+      })
+    })
+  ];
+  thumbCache.set(thumbnail, styles);
+  return styles;
+}
+function toOlStyle(def, label) {
+  if ("ref" in def) {
+    throw new Error(`Style ref '${def.ref}' cannot be resolved (no StyleRegistry wired).`);
+  }
+  if (def.type === "raw") {
+    const inst = def.options?.instance;
+    return inst ?? fallback;
+  }
+  if (def.type !== "simple") return fallback;
+  const opts = def.options ?? {};
+  if (opts.thumbnailMarker) {
+    const t = opts.thumbnailMarker;
+    const property = t.property ?? "thumbnail";
+    const imageSize = t.imageSize ?? [100, 100];
+    const imageScale = t.imageScale ?? 0.26;
+    const frameRadius = t.frameRadius ?? 22;
+    const frameBorderWidth = t.frameBorderWidth ?? 3;
+    const frameBorderColor = t.frameBorderColor ?? "rgba(255,255,255,1)";
+    const frameFillColor = t.frameFillColor ?? "#ffffff";
+    const frameDisplacement = t.frameDisplacement ?? [-1, 13];
+    const pinRadius = t.pinRadius ?? 10;
+    const pinFillColor = t.pinFillColor ?? "#ffffff";
+    const pinRotation = t.pinRotation ?? Math.PI / 3;
+    const crossOrigin = t.crossOrigin ?? "anonymous";
+    const fill = new Fill({ color: opts.fillColor ?? "rgba(0,0,0,0.2)" });
+    const stroke = new Stroke({ color: opts.strokeColor ?? "#333", width: opts.strokeWidth ?? 1 });
+    const image = opts.circle ? new CircleStyle({
+      radius: opts.circle.radius ?? 4,
+      fill: new Fill({ color: opts.circle.fillColor ?? "#3388ff" }),
+      stroke: new Stroke({ color: opts.circle.strokeColor ?? "#222", width: opts.circle.strokeWidth ?? 1 })
+    }) : void 0;
+    return (feature) => {
+      const size = getClusterSize(feature);
+      if (size > 1) return void 0;
+      const inner = getInnerFeatureFromCluster(feature);
+      const thumb = inner.get?.(property);
+      const url = typeof thumb === "string" ? thumb : "";
+      if (!url) {
+        return new Style({ fill, stroke, image, text });
+      }
+      return makeThumbnailMarkerStyle(url, {
+        frameRadius,
+        frameBorderWidth,
+        frameBorderColor,
+        frameFillColor,
+        frameDisplacement,
+        pinRadius,
+        pinFillColor,
+        pinRotation,
+        imageSize,
+        imageScale,
+        crossOrigin
+      });
+    };
+  }
+  const baseFill = new Fill({ color: opts.fillColor ?? "rgba(0,0,0,0.2)" });
+  const baseStroke = new Stroke({ color: opts.strokeColor ?? "#333", width: opts.strokeWidth ?? 1 });
+  const text = opts.text || label !== void 0 ? new Text({
+    text: opts.text?.label ?? (label != null ? String(label) : ""),
+    font: opts.text?.font ?? "14px sans-serif",
+    fill: new Fill({ color: opts.text?.fillColor ?? "#fff" }),
+    stroke: opts.text?.strokeColor ? new Stroke({ color: opts.text.strokeColor, width: opts.text.strokeWidth ?? 2 }) : void 0,
+    offsetX: opts.text?.offsetX ?? 0,
+    offsetY: opts.text?.offsetY ?? 0
+  }) : void 0;
+  if (opts.icon) {
+    const i = opts.icon;
+    return new Style({
+      image: new Icon({
+        src: i.src,
+        scale: i.scale ?? 1,
+        anchor: i.anchor ?? [0.5, 1],
+        anchorXUnits: i.anchorXUnits ?? "fraction",
+        anchorYUnits: i.anchorYUnits ?? "fraction",
+        size: i.size,
+        rotation: i.rotation ?? 0,
+        opacity: i.opacity ?? 1,
+        color: i.color
+      }),
+      text
+    });
+  }
+  if (opts.circle && opts.circle.units !== "map") {
+    const c = opts.circle;
+    const image = new CircleStyle({
+      radius: c.radius ?? 4,
+      fill: new Fill({ color: c.fillColor ?? "#3388ff" }),
+      stroke: new Stroke({ color: c.strokeColor ?? "#222", width: c.strokeWidth ?? 1 })
+    });
+    return new Style({ image, text, fill: baseFill, stroke: baseStroke });
+  }
+  if (opts.circle?.units === "map") {
+    const c = opts.circle;
+    const circleStroke = new Stroke({
+      color: c.strokeColor ?? opts.strokeColor ?? "#333",
+      width: c.strokeWidth ?? opts.strokeWidth ?? 1
+    });
+    const circleFill = new Fill({
+      color: c.fillColor ?? opts.fillColor ?? "rgba(0,0,0,0.2)"
+    });
+    return (feature) => {
+      const geom = feature.getGeometry();
+      if (!(geom instanceof Point)) {
+        return new Style({ stroke: baseStroke, fill: baseFill, text });
+      }
+      let radius = 0;
+      if (c.radiusProperty) {
+        const v = feature.get(c.radiusProperty);
+        const n = Number(v);
+        if (Number.isFinite(n)) radius = n;
+      }
+      if (!(radius > 0)) radius = c.radius ?? 0;
+      if (!(radius > 0)) return new Style({ stroke: baseStroke, fill: baseFill, text });
+      const circleGeom = new CircleGeom(geom.getCoordinates(), radius);
+      if (c.gradient) {
+        const renderer = makeGradientRenderer(
+          olColor.asArray(c.gradient.color),
+          c.gradient.outerScale ?? 1.4,
+          c.gradient.stops ?? [[0, 0], [0.6, 0.2], [1, 0.8]],
+          c.strokeWidth ?? 1
+        );
+        const s2 = new Style({ renderer, text });
+        s2.setGeometry(circleGeom);
+        return s2;
+      }
+      const s = new Style({ stroke: circleStroke, fill: circleFill, text });
+      s.setGeometry(circleGeom);
+      return s;
+    };
+  }
+  return new Style({ fill: baseFill, stroke: baseStroke, text });
+}
+
+// src/core/ol/adapters/draw-style.ts
+import { Style as Style2, Icon as Icon2, Circle as CircleStyle2, Fill as Fill2, Stroke as Stroke2, Text as Text2 } from "ol/style";
+function makeDrawStyle(opts) {
+  const stroke = new Stroke2({
+    color: opts?.strokeColor ?? "#1f6feb",
+    width: opts?.strokeWidth ?? 2
+  });
+  const fill = new Fill2({
+    color: opts?.fillColor ?? "rgba(31,111,235,0.15)"
+  });
+  const image = new CircleStyle2({
+    radius: opts?.pointRadius ?? 6,
+    fill,
+    stroke
+  });
+  const s = new Style2();
+  s.setImage(image);
+  s.setFill(fill);
+  s.setStroke(stroke);
+  if (opts?.text) {
+    s.setText(
+      new Text2({
+        text: opts.text.label ?? "",
+        font: opts.text.font ?? "14px sans-serif",
+        fill: new Fill2({ color: opts.text.fillColor ?? "#111" }),
+        stroke: opts.text.strokeColor ? new Stroke2({
+          color: opts.text.strokeColor,
+          width: opts.text.strokeWidth ?? 2
+        }) : void 0,
+        offsetX: opts.text.offsetX ?? 0,
+        offsetY: opts.text.offsetY ?? 0
+      })
+    );
+  }
+  if (opts?.icon?.src) {
+    const image2 = new Icon2({
+      src: opts.icon.src,
+      scale: opts.icon.scale ?? 1,
+      size: opts.icon.size,
+      anchor: opts.icon.anchor ?? [0.5, 1],
+      anchorXUnits: opts.icon.anchorXUnits ?? "fraction",
+      anchorYUnits: opts.icon.anchorYUnits ?? "fraction",
+      rotation: opts.icon.rotation ?? 0,
+      opacity: opts.icon.opacity ?? 1,
+      color: opts.icon.color
+    });
+    return new Style2({ image: image2, stroke, fill });
+  }
+  return s;
+}
+function makeUpdatedDrawStyle(opts) {
+  const stroke = new Stroke2({
+    color: opts?.strokeColor ?? "#1f6feb",
+    width: opts?.strokeWidth ?? 2
+  });
+  const fill = new Fill2({
+    color: opts?.fillColor ?? "rgba(31,111,235,0.15)"
+  });
+  const image = new CircleStyle2({
+    radius: opts?.pointRadius ?? 6,
+    fill,
+    stroke
+  });
+  const s = new Style2();
+  s.setImage(image);
+  s.setFill(fill);
+  s.setStroke(stroke);
+  if (opts?.text) {
+    s.setText(
+      new Text2({
+        text: opts.text.label ?? "",
+        font: opts.text.font ?? "14px sans-serif",
+        fill: new Fill2({ color: opts.text.fillColor ?? "#111" }),
+        stroke: opts.text.strokeColor ? new Stroke2({
+          color: opts.text.strokeColor,
+          width: opts.text.strokeWidth ?? 2
+        }) : void 0,
+        offsetX: opts.text.offsetX ?? 0,
+        offsetY: opts.text.offsetY ?? 0
+      })
+    );
+  }
+  return s;
+}
+
+// src/core/ol/adapters/layers.ts
+import { createDefaultStyle } from "ol/style/Style";
+import ClusterSource from "ol/source/Cluster";
+import { Style as Style3, Circle as CircleStyle3, Fill as Fill3, Stroke as Stroke3, Text as Text3 } from "ol/style";
+function styleFromFeature(feature, resolution) {
+  const nbic = typeof feature.get === "function" ? feature.get("nbic:style") : void 0;
+  return nbic ? makeDrawStyle(nbic) : createDefaultStyle(feature, resolution);
+}
+function toOlLayer(def, sourceFn = resolveOlSource, styleFn = toOlStyle) {
+  const src = sourceFn(def.source);
+  let layer;
+  switch (def.kind) {
+    case "tile":
+    case "raster":
+      if (src instanceof TileSource) {
+        layer = new TileLayer({ source: src, visible: def.visible ?? true, opacity: def.opacity ?? 1 });
+      } else {
+        throw new Error("Source for tile/raster layer must be a TileSource");
+      }
+      break;
+    case "vector":
+      if (src instanceof VectorSource3) {
+        let sumCount2 = function(members, field = "count") {
+          if (!members?.length) return 0;
+          let total = 0;
+          for (const m of members) {
+            const v = m.get?.(field);
+            const n = Number(v);
+            total += Number.isFinite(n) ? n : 1;
+          }
+          return total;
+        };
+        var sumCount = sumCount2;
+        const finalSource = def.cluster?.enabled ? new ClusterSource({
+          distance: def.cluster.distance ?? 40,
+          minDistance: def.cluster.minDistance,
+          source: src
+        }) : src;
+        const explicitLayerStyle = def.style ? styleFn(def.style) : void 0;
+        const explicitClusterStyle = def.cluster?.enabled && def.cluster.style ? styleFn(def.cluster.style) : void 0;
+        const countField = def.cluster?.countField ?? "count";
+        const style = (feature, resolution) => {
+          const members = feature.get?.("features");
+          if (def.cluster?.enabled && members) {
+            const total = sumCount2(members, countField) || members.length;
+            if (members.length === 1 && !def.cluster.keepSingleAsCluster) {
+              const inner = members[0];
+              if (inner && typeof explicitLayerStyle === "function") {
+                return explicitLayerStyle(inner, resolution);
+              }
+              if (explicitLayerStyle) {
+                if (typeof explicitLayerStyle === "function" && inner) {
+                  return explicitLayerStyle(inner, resolution);
+                }
+                return typeof explicitLayerStyle === "function" ? inner ? explicitLayerStyle(inner, resolution) : void 0 : explicitLayerStyle;
+              }
+              const innerHasPerFeature = !!inner?.get && !!inner.get("nbic:style");
+              if (innerHasPerFeature) {
+                return styleFromFeature(inner, resolution);
+              }
+              if (inner) {
+                return styleFromFeature(inner, resolution);
+              }
+              return void 0;
+            }
+            if (typeof explicitClusterStyle === "function") {
+              return explicitClusterStyle(feature, resolution);
+            }
+            if (explicitClusterStyle) {
+              if (def.cluster.style) {
+                return styleFn(def.cluster.style, String(def.cluster.maxClusterPoints ? total > def.cluster.maxClusterPoints ? def.cluster.maxClusterPoints + "+" : total : total));
+              } else {
+                return explicitClusterStyle;
+              }
+            }
+            return new Style3({
+              image: new CircleStyle3({
+                radius: 12,
+                fill: new Fill3({ color: "#3399CC" }),
+                stroke: new Stroke3({ color: "#fff", width: 2 })
+              }),
+              text: new Text3({
+                text: String(def.cluster.maxClusterPoints ? total > def.cluster.maxClusterPoints ? def.cluster.maxClusterPoints + "+" : total : total),
+                fill: new Fill3({ color: "#fff" })
+              })
+            });
+          }
+          const hasPerFeature = typeof feature.get === "function" && !!feature.get("nbic:style");
+          if (hasPerFeature) {
+            return styleFromFeature(feature, resolution);
+          }
+          if (typeof explicitLayerStyle === "function") {
+            return explicitLayerStyle(feature, resolution);
+          }
+          if (explicitLayerStyle) {
+            return explicitLayerStyle;
+          }
+          return styleFromFeature(feature, resolution);
+        };
+        layer = new VectorLayer({
+          source: finalSource,
+          visible: def.visible !== false,
+          zIndex: def.zIndexPinned ? def.zIndex : void 0,
+          style,
+          // styleFn as unknown as StyleLike,
+          properties: { id: def.id }
+        });
+        if (def.source && typeof def.source === "object") {
+          const sourceDef = def.source;
+          if (sourceDef.type === "geojson" && sourceDef.options.dataProjection) {
+            layer.set("nbic:dataProjection", sourceDef.options.dataProjection);
+          }
+        }
+      } else {
+        throw new Error("Source for vector layer must be a VectorSource");
+      }
+      break;
+    default:
+      throw new Error(`Unknown layer kind: ${def.kind}`);
+  }
+  layer.set("id", def.id);
+  if (def.hover?.style) layer.set("nbic:hoverStyle", def.hover.style);
+  if (def.hover?.clusterStyle) layer.set("nbic:hoverClusterStyle", def.hover.clusterStyle);
+  if (def.hover?.singleClusterStyle) layer.set("nbic:hoverSingleClusterStyle", def.hover.singleClusterStyle);
+  if (def.hover?.hitTolerance != null) layer.set("nbic:hoverHitTol", def.hover.hitTolerance);
+  if (def.hover?.clusterBehavior) layer.set("nbic:hoverClusterBehavior", def.hover.clusterBehavior);
+  if (def.cluster?.keepSingleAsCluster) layer.set("nbic:keepSingleAsCluster", true);
+  if (def.hover?.cursor) layer.set("nbic:hoverCursor", def.hover.cursor);
+  if (def.minZoom !== void 0 && "setMinZoom" in layer) layer.setMinZoom(def.minZoom);
+  if (def.maxZoom !== void 0 && "setMaxZoom" in layer) layer.setMaxZoom(def.maxZoom);
+  if (def.zIndex !== void 0) layer.set("nbic:declaredZIndex", def.zIndex);
+  if (def.zIndexPinned) layer.set("nbic:zIndexPinned", true);
+  return layer;
+}
+
+// src/core/ol/interactions/HoverInfo.ts
+import { unByKey } from "ol/Observable";
+import VectorLayer2 from "ol/layer/Vector";
+import VectorSource4 from "ol/source/Vector";
+import Feature from "ol/Feature";
+import { Style as Style4, Stroke as Stroke4, Fill as Fill4, Circle as CircleStyle4 } from "ol/style";
+
+// src/api/events.ts
+var MapEvents = {
+  Ready: "ready",
+  Destroy: "destroy",
+  CameraChanged: "camera:changed",
+  ExtentChanged: "extent:changed",
+  LayerAdded: "layer:added",
+  LayerRemoved: "layer:removed",
+  PointerMove: "pointer:move",
+  PointerClick: "pointer:click",
+  BaselayerChanged: "baselayer:changed",
+  BaseChanged: "base:changed",
+  HoverInfo: "hover:info",
+  Error: "error",
+  DrawStart: "draw:start",
+  DrawEnd: "draw:end",
+  DrawImported: "draw:imported",
+  DrawCleared: "draw:cleared",
+  DrawVertex: "draw:vertex",
+  DrawVertexRemoved: "draw:vertexRemoved",
+  GeoPosition: "geo:position",
+  GeoError: "geo:error",
+  FullscreenChange: "fullscreen:change",
+  ScaleLineControl: "controls:scaleline",
+  ZoomControl: "controls:zoom",
+  AttributionControl: "controls:attribution",
+  BufferCreated: "buffer:created",
+  BufferInteractiveStart: "buffer:interactive:start",
+  EditModified: "edit:modified"
+};
+
+// src/core/ol/interactions/HoverInfo.ts
+import { getUid } from "ol/util";
+var DEFAULTS = {
+  hitTolerance: 5,
+  outlineColor: "transparent",
+  outlineWidth: 0,
+  fillColor: "transparent"
+};
+var HoverInfoController = class {
+  map;
+  events;
+  opts = { ...DEFAULTS };
+  hoverLayer = null;
+  hoverSource = null;
+  pointerMoveKey = null;
+  lastHoverKey = null;
+  viewportLeaveHandler = null;
+  defaultCursor = "";
+  setCursor(cursor) {
+    const el = this.map.getTargetElement();
+    if (!el) return;
+    if (!this.defaultCursor) this.defaultCursor = el.style.cursor || "";
+    el.style.cursor = cursor ?? this.defaultCursor;
+  }
+  constructor(map, events) {
+    this.map = map;
+    this.events = events;
+  }
+  activate(options) {
+    if (options) this.opts = { ...this.opts, ...options };
+    this.ensureLayer();
+    this.bindPointerMove();
+    this.bindViewportLeave();
+  }
+  deactivate() {
+    this.unbindPointerMove();
+    this.unbindViewportLeave();
+    this.destroyLayer();
+  }
+  bindViewportLeave() {
+    if (this.viewportLeaveHandler) return;
+    const vp = this.map.getViewport();
+    this.viewportLeaveHandler = () => {
+      if (this.lastHoverKey != null) this.clearHover();
+    };
+    vp.addEventListener("pointerleave", this.viewportLeaveHandler);
+    vp.addEventListener("mouseleave", this.viewportLeaveHandler);
+  }
+  unbindViewportLeave() {
+    if (!this.viewportLeaveHandler) return;
+    const vp = this.map.getViewport();
+    vp.removeEventListener("pointerleave", this.viewportLeaveHandler);
+    vp.removeEventListener("mouseleave", this.viewportLeaveHandler);
+    this.viewportLeaveHandler = null;
+  }
+  setOptions(options) {
+    this.opts = { ...this.opts, ...options };
+  }
+  destroy() {
+    this.deactivate();
+  }
+  // ---- internals ----    
+  ensureLayer() {
+    if (this.hoverLayer) return;
+    this.hoverSource = new VectorSource4();
+    this.hoverLayer = new VectorLayer2({
+      source: this.hoverSource,
+      properties: { "nbic:role": "hover" },
+      zIndex: 9999,
+      updateWhileInteracting: true,
+      style: (f) => {
+        const s = f.get("nbic:hoverStyle");
+        const stroke = new Stroke4({
+          color: s?.strokeColor ?? this.opts.outlineColor,
+          width: s?.strokeWidth ?? this.opts.outlineWidth
+        });
+        const fill = new Fill4({
+          color: s?.fillColor ?? this.opts.fillColor
+        });
+        const g = f.getGeometry();
+        const type = g?.getType();
+        if (type === "Point" || type === "MultiPoint") {
+          const radius = (
+            // let a per-layer hover style override radius if you add it to DrawStyleOptions later
+            s?.pointRadius ?? 8
+          );
+          return new Style4({
+            image: new CircleStyle4({ radius, fill, stroke })
+          });
+        }
+        return new Style4({ stroke, fill });
+      }
+    });
+    this.map.addLayer(this.hoverLayer);
+  }
+  clearHover() {
+    this.lastHoverKey = null;
+    this.hoverSource?.clear(true);
+    this.events.emit("hover:info", null);
+  }
+  destroyLayer() {
+    if (this.hoverLayer) this.map.removeLayer(this.hoverLayer);
+    this.hoverLayer = null;
+    this.hoverSource = null;
+    this.lastHoverKey = null;
+  }
+  bindPointerMove() {
+    if (this.pointerMoveKey) return;
+    this.pointerMoveKey = this.map.on("pointermove", (evt) => {
+      const pixel = evt.pixel;
+      let picked = null;
+      this.map.forEachFeatureAtPixel(
+        pixel,
+        (f, l) => {
+          if (!l) return void 0;
+          picked = { feature: f, layer: l };
+          return f;
+        },
+        {
+          hitTolerance: this.opts.hitTolerance,
+          layerFilter: (l) => l.get("nbic:role") !== "hover"
+        }
+      );
+      if (!picked) {
+        if ((this.hoverSource?.getFeatures().length ?? 0) > 0) this.clearHover();
+        this.setCursor("default");
+        return;
+      }
+      const { feature: top, layer } = picked;
+      const topF = top;
+      const id = topF.getId?.();
+      const key = typeof id === "string" || typeof id === "number" ? id : getUid(topF);
+      if (key === this.lastHoverKey) return;
+      const keepSingleAsCluster = !!layer.get("nbic:keepSingleAsCluster");
+      const hoverBehavior = layer.get("nbic:hoverClusterBehavior");
+      const baseHover = layer.get("nbic:hoverStyle");
+      const clusterHover = layer.get("nbic:hoverClusterStyle");
+      const singleClusterHover = layer.get("nbic:hoverSingleClusterStyle");
+      const cursor = layer.get("nbic:hoverCursor");
+      this.setCursor(cursor ?? null);
+      const members = topF.get("features");
+      let geom = null;
+      let hoverStyleToApply = baseHover;
+      const topHover = topF.get("nbic:hoverStyle");
+      const isCluster = !!members?.length;
+      if (isCluster) {
+        if (members.length >= 2) {
+          geom = topF.getGeometry()?.clone() ?? null;
+          hoverStyleToApply = clusterHover ?? baseHover;
+        } else {
+          const preferBubble = keepSingleAsCluster || hoverBehavior === "bubble";
+          const inner = members[0];
+          const innerHover = inner?.get("nbic:hoverStyle");
+          if (preferBubble) {
+            geom = topF.getGeometry()?.clone() ?? null;
+            hoverStyleToApply = singleClusterHover ?? clusterHover ?? baseHover;
+          } else {
+            geom = inner?.getGeometry()?.clone() ?? null;
+            hoverStyleToApply = innerHover ?? baseHover;
+          }
+        }
+      } else {
+        geom = topF.getGeometry()?.clone() ?? null;
+        hoverStyleToApply = topHover ?? baseHover;
+      }
+      this.clearHover();
+      if (!geom || !this.hoverSource) return;
+      const hf = new Feature({ geometry: geom });
+      if (hoverStyleToApply) hf.set("nbic:hoverStyle", hoverStyleToApply);
+      this.hoverSource.addFeature(hf);
+      this.lastHoverKey = key;
+      this.events.emit(MapEvents.HoverInfo, {
+        coordinate: evt.coordinate,
+        items: [{ feature: topF, layer }]
+      });
+    });
+  }
+  unbindPointerMove() {
+    if (this.pointerMoveKey) {
+      unByKey(this.pointerMoveKey);
+      this.pointerMoveKey = null;
+    }
+    this.clearHover();
+  }
+};
+
+// src/core/ol/OlMapEngine.ts
+import Collection from "ol/Collection";
+
+// src/core/ol/layers/LayerRegistry.ts
+function hasGetSource(obj) {
+  return !!obj && typeof obj.getSource === "function";
+}
+function hasGetFeatures(obj) {
+  return !!obj && typeof obj.getFeatures === "function";
+}
+var LayerRegistry = class {
+  index = /* @__PURE__ */ new Map();
+  add(id, layer) {
+    this.index.set(id, layer);
+  }
+  remove(id) {
+    this.index.delete(id);
+  }
+  get(id) {
+    return this.index.get(id);
+  }
+  clear() {
+    this.index.clear();
+  }
+  getVectorSource(id) {
+    const layer = this.index.get(id);
+    if (!layer || !hasGetSource(layer)) return null;
+    const src0 = layer.getSource();
+    if (!src0) return null;
+    const inner = hasGetSource(src0) ? src0.getSource() : src0;
+    return hasGetFeatures(inner) ? inner : null;
+  }
+  listIds() {
+    return Array.from(this.index.keys());
+  }
+  /** Reorder overlays and bases. You’ll usually call this from BaseLayersController. */
+  reorder(order, bases) {
+    let overlayZ = 0;
+    let baseZ = bases.baseBand;
+    for (const id of order) {
+      const l = this.index.get(id);
+      if (!l) continue;
+      const role = l.get?.("nbic:role");
+      if (role === "hover" || role === "draw" || role === "draw-vertices") continue;
+      const pinned = !!l.get?.("nbic:zIndexPinned");
+      if (pinned) continue;
+      if (bases.isBase(l)) {
+        l.setZIndex(baseZ++);
+      } else {
+        l.setZIndex(overlayZ++);
+      }
+    }
+  }
+};
+
+// src/core/ol/layers/BaseLayerController.ts
+var BaseLayersController = class {
+  constructor(events) {
+    this.events = events;
+  }
+  baseIds = /* @__PURE__ */ new Set();
+  superBaseIds = /* @__PURE__ */ new Set();
+  regionalBaseIds = /* @__PURE__ */ new Set();
+  activeRegional = null;
+  activeSuper = null;
+  _findLayer = () => null;
+  /** zIndex bands (keep bases below overlays) */
+  baseBand = -1e4;
+  superBaseBand = -2e4;
+  isBase(l) {
+    return l.get("nbic:role") === "base";
+  }
+  roleOf(l) {
+    return l.get("nbic:baseRole");
+  }
+  registerBase(layer, role, def) {
+    const id = layer.get("id");
+    layer.set("nbic:role", "base");
+    layer.set("nbic:baseRole", role);
+    this.baseIds.add(id);
+    if (role === "super") this.superBaseIds.add(id);
+    if (role === "regional") this.regionalBaseIds.add(id);
+    if (def.zIndex === void 0) {
+      if (role === "super") layer.setZIndex(this.superBaseBand + this.superBaseIds.size);
+      else layer.setZIndex(this.baseBand + this.regionalBaseIds.size);
+    }
+    if (role === "super") {
+      layer.setVisible(def.visible !== false);
+      if (layer.getVisible()) this.activeSuper = id;
+    } else {
+      const wantsVisible = def.visible ?? layer.getVisible();
+      if (wantsVisible) this.setActiveRegional(id);
+      else this.ensureOneRegionalVisible();
+    }
+    this.emitChanged();
+  }
+  onRemoved(id) {
+    this.baseIds.delete(id);
+    this.superBaseIds.delete(id);
+    this.regionalBaseIds.delete(id);
+    if (this.activeRegional === id) this.activeRegional = null;
+    if (this.activeSuper === id) this.activeSuper = null;
+    this.emitChanged();
+  }
+  setActiveRegional(id) {
+    if (!this.regionalBaseIds.has(id)) return;
+    for (const rid of this.regionalBaseIds) {
+      const lyr = this.findLayer(rid);
+      if (!lyr) continue;
+      lyr.setVisible(rid === id);
+    }
+    this.activeRegional = id;
+    this.emitChanged();
+  }
+  setVisibility(layer, visible) {
+    const id = layer.get("id");
+    const role = this.roleOf(layer);
+    if (role === "super") {
+      layer.setVisible(visible);
+      if (visible) this.activeSuper = id;
+      this.emitChanged();
+      return;
+    }
+    if (visible) this.setActiveRegional(id);
+    else {
+      layer.setVisible(false);
+      this.ensureOneRegionalVisible();
+      this.emitChanged();
+    }
+  }
+  /** Bridge: allow LayerRegistry.reorder to query base-ness. */
+  isBaseLayer = (l) => this.isBase(l);
+  ensureOneRegionalVisible() {
+    let first = null;
+    for (const id of this.regionalBaseIds) {
+      const l = this.findLayer(id);
+      if (!l) continue;
+      if (l.getVisible() && !first) first = id;
+      else l.setVisible(id === first);
+    }
+    this.activeRegional = first;
+  }
+  /** Engine should call this after creation to connect real lookup (e.g. LayerRegistry). */
+  bindFind(fn) {
+    this._findLayer = fn;
+  }
+  findLayer(id) {
+    return this._findLayer(id);
+  }
+  clear() {
+    this.baseIds.clear();
+    this.superBaseIds.clear();
+    this.regionalBaseIds.clear();
+    this.activeRegional = null;
+    this.activeSuper = null;
+    this._findLayer = () => null;
+    this.emitChanged();
+  }
+  emitChanged() {
+    this.events.emit("base:changed", { regional: this.activeRegional, super: this.activeSuper });
+  }
+};
+
+// src/core/ol/interactions/DrawController.ts
+import VectorSource5 from "ol/source/Vector";
+import VectorLayer3 from "ol/layer/Vector";
+import Draw, { createBox } from "ol/interaction/Draw";
+import Modify from "ol/interaction/Modify";
+import Snap from "ol/interaction/Snap";
+import GeoJSON3 from "ol/format/GeoJSON";
+import Point2 from "ol/geom/Point";
+import { Feature as Feature2 } from "ol";
+import { unByKey as unByKey2 } from "ol/Observable";
+import { listen } from "ol/events";
+import buffer from "@turf/buffer";
+import { Style as Style5, Circle as CircleStyle5, Fill as Fill5, Stroke as Stroke5 } from "ol/style";
+import { LineString, Polygon, MultiLineString, MultiPolygon } from "ol/geom";
+import { getUid as getUid2 } from "ol/util";
+function mapKindToDraw(kind) {
+  switch (kind) {
+    case "Point":
+      return { type: "Point" };
+    case "LineString":
+      return { type: "LineString" };
+    case "Polygon":
+      return { type: "Polygon" };
+    case "Circle":
+      return { type: "Circle" };
+    case "Text":
+      return { type: "Point" };
+    case "Box":
+      return { type: "Circle", geometryFunction: createBox() };
+  }
+}
+function vertexCount(geom) {
+  if (geom instanceof Point2) return 1;
+  if (geom instanceof LineString) {
+    const coords = geom.getCoordinates();
+    return coords.length;
+  }
+  if (geom instanceof Polygon) {
+    const rings = geom.getCoordinates();
+    if (rings.length === 0) return 0;
+    const firstRing = rings[0];
+    if (!firstRing) return 0;
+    return Math.max(0, firstRing.length - 1);
+  }
+  return 0;
+}
+function lastVertex(geom) {
+  if (geom instanceof Point2) {
+    const c = geom.getCoordinates();
+    if (!Array.isArray(c) || c.length < 2) return null;
+    return [c[0], c[1]];
+  }
+  if (geom instanceof LineString) {
+    const coords = geom.getCoordinates();
+    if (!Array.isArray(coords) || coords.length === 0) return null;
+    const last = coords[coords.length - 1];
+    if (!Array.isArray(last) || last.length < 2) return null;
+    return [last[0], last[1]];
+  }
+  if (geom instanceof Polygon) {
+    const rings = geom.getCoordinates();
+    if (!Array.isArray(rings) || rings.length === 0) return null;
+    const ring = rings[0];
+    if (!Array.isArray(ring) || ring.length <= 1) return null;
+    const last = ring[ring.length - 2];
+    if (!Array.isArray(last) || last.length < 2) return null;
+    return [last[0], last[1]];
+  }
+  return null;
+}
+function flattenOnce(arr) {
+  const out = [];
+  for (const a of arr) out.push(...a);
+  return out;
+}
+function flattenTwice(arr) {
+  const out = [];
+  for (const a of arr) for (const b of a) out.push(...b);
+  return out;
+}
+var DrawController = class {
+  constructor(events) {
+    this.events = events;
+  }
+  map;
+  source;
+  layer;
+  draw;
+  modify;
+  snap;
+  fmt = new GeoJSON3();
+  currentDrawStyle = makeDrawStyle(void 0);
+  vertexLayer;
+  vertexSrc;
+  attach(map) {
+    this.map = map;
+  }
+  detach() {
+    this.stop();
+    this.map = void 0;
+  }
+  getLayer() {
+    this.ensureLayer();
+    return this.layer;
+  }
+  // --- Modify undo history ---
+  editUndoStack = /* @__PURE__ */ new Map();
+  // key -> snapshots
+  editRedoStack = /* @__PURE__ */ new Map();
+  // optional (keep for future)
+  lastEditedKey = null;
+  featureKey(f) {
+    const id = f.getId();
+    if (typeof id === "string") return id;
+    if (typeof id === "number") return String(id);
+    return String(getUid2(f));
+  }
+  pushGeometrySnapshot(f) {
+    const g = f.getGeometry();
+    if (!g) return;
+    const key = this.featureKey(f);
+    this.lastEditedKey = key;
+    const stack = this.editUndoStack.get(key) ?? [];
+    stack.push(g.clone());
+    const MAX = 50;
+    if (stack.length > MAX) stack.splice(0, stack.length - MAX);
+    this.editUndoStack.set(key, stack);
+    this.editRedoStack.set(key, []);
+  }
+  restoreGeometrySnapshot(f, geom) {
+    f.setGeometry(geom.clone());
+  }
+  // ————— helpers —————
+  ensureLayer() {
+    if (!this.map || this.layer) return;
+    this.source = new VectorSource5();
+    this.layer = new VectorLayer3({
+      source: this.source,
+      properties: { "nbic:role": "draw", id: "draw-layer" },
+      zIndex: 9e3,
+      style: this.currentDrawStyle,
+      updateWhileInteracting: true
+    });
+    this.layer.set("id", "draw-layer");
+    this.map.addLayer(this.layer);
+  }
+  setStyle(f, s) {
+    if (!s) return;
+    f.set("nbic:style", s);
+    f.setStyle(makeDrawStyle(s));
+  }
+  makeVertexStyle(opts) {
+    const strokeColor = opts?.strokeColor ?? "#1976d2";
+    const strokeWidth = opts?.strokeWidth ?? 2;
+    const fillColor = opts?.fillColor ?? "#ffffff";
+    const radius = opts?.pointRadius ?? 5;
+    return new Style5({
+      image: new CircleStyle5({
+        radius,
+        fill: new Fill5({ color: fillColor }),
+        stroke: new Stroke5({ color: strokeColor, width: strokeWidth })
+      })
+    });
+  }
+  ensureVertexLayer(styleOpts) {
+    if (!this.map || this.vertexLayer) return;
+    this.vertexSrc = new VectorSource5();
+    this.vertexLayer = new VectorLayer3({
+      source: this.vertexSrc,
+      properties: { "nbic:role": "draw-vertices" },
+      zIndex: 9001,
+      style: this.makeVertexStyle(styleOpts),
+      updateWhileInteracting: true
+    });
+    this.map.addLayer(this.vertexLayer);
+  }
+  destroyVertexLayer() {
+    if (this.vertexLayer && this.map) this.map.removeLayer(this.vertexLayer);
+    this.vertexLayer = void 0;
+    this.vertexSrc = void 0;
+  }
+  verticesOfGeometry(g) {
+    if (g instanceof LineString) {
+      return g.getCoordinates();
+    }
+    if (g instanceof Polygon) {
+      const rings = g.getCoordinates();
+      return flattenOnce(rings);
+    }
+    if (g instanceof MultiLineString) {
+      const lines = g.getCoordinates();
+      return flattenOnce(lines);
+    }
+    if (g instanceof MultiPolygon) {
+      const polys = g.getCoordinates();
+      return flattenTwice(polys);
+    }
+    return [];
+  }
+  rebuildVertexOverlay() {
+    if (!this.vertexSrc || !this.source) return;
+    this.vertexSrc.clear(true);
+    const feats = this.source.getFeatures();
+    for (const f of feats) {
+      const g = f.getGeometry();
+      if (!g) continue;
+      const verts = this.verticesOfGeometry(g);
+      for (let i = 0; i < verts.length; i++) {
+        const coord = verts[i];
+        if (!coord) continue;
+        const v = new Feature2({ geometry: new Point2(coord) });
+        const pid = f.getId();
+        if (pid != null) v.set("nbic:parentId", pid);
+        v.set("nbic:vertexIndex", i);
+        this.vertexSrc.addFeature(v);
+      }
+    }
+  }
+  createPointFeature(coord, props, style) {
+    const f = new Feature2({ geometry: new Point2(coord) });
+    if (props) Object.entries(props).forEach(([k, v]) => f.set(k, v));
+    this.setStyle(f, style);
+    return f;
+  }
+  // Turf buffer around any feature (returns OL Feature in view projection)
+  async turfBufferFeature(feature, opts) {
+    if (!this.map) return null;
+    const viewProj = String(this.map.getView().getProjection().getCode());
+    const gj = this.fmt.writeFeatureObject(feature, {
+      dataProjection: "EPSG:4326",
+      featureProjection: viewProj
+    });
+    const turfOpts = { units: opts.units ?? "meters", steps: opts.steps ?? 64 };
+    const buffered = buffer(gj, opts.distance, turfOpts);
+    if (!buffered) return null;
+    const out = this.fmt.readFeature(buffered, {
+      dataProjection: "EPSG:4326",
+      featureProjection: viewProj
+    });
+    return out;
+  }
+  // ————— public API —————
+  async start(opts) {
+    if (!this.map) return;
+    const drawParams = mapKindToDraw(opts.kind);
+    this.ensureLayer();
+    this.stop();
+    this.currentDrawStyle = makeDrawStyle(opts.style);
+    this.layer.setStyle(this.currentDrawStyle);
+    this.modify = new Modify({ source: this.source });
+    this.map.addInteraction(this.modify);
+    this.modify.setActive(false);
+    this.draw = new Draw({
+      source: this.source,
+      type: drawParams.type,
+      geometryFunction: drawParams.geometryFunction,
+      style: this.currentDrawStyle
+    });
+    this.map.addInteraction(this.draw);
+    const snapTol = Math.max(2, Math.min(25, 10));
+    if (opts.snap ?? true) {
+      this.snap = new Snap({ source: this.source, pixelTolerance: snapTol });
+      this.map.addInteraction(this.snap);
+    }
+    let keyHandler = null;
+    this.draw.on("drawstart", (e) => {
+      this.events.emit("draw:start", { kind: opts.kind });
+      const sketch = e.feature;
+      const geom = sketch.getGeometry();
+      if (!geom) return;
+      let lastLen = vertexCount(geom);
+      const changeKey = geom.on("change", () => {
+        const len = vertexCount(geom);
+        if (len > lastLen) {
+          const coord = lastVertex(geom);
+          if (coord) {
+            this.events.emit("draw:vertex", {
+              kind: opts.kind,
+              index: len - 1,
+              // 0-based, correct for lines/polygons
+              coordinate: coord
+              // MapCoord
+            });
+          }
+        } else if (len < lastLen) {
+          this.events.emit("draw:vertexRemoved", {
+            kind: opts.kind,
+            index: len
+            // new last index after removal
+          });
+        }
+        lastLen = len;
+      });
+      keyHandler = (ev) => {
+        const ctrlZ = (ev.key === "z" || ev.key === "Z") && (ev.ctrlKey || ev.metaKey);
+        if (ev.key === "Backspace" || ctrlZ) {
+          ev.preventDefault();
+          this.draw?.removeLastPoint();
+        } else if (ev.key === "Enter") {
+          ev.preventDefault();
+          this.draw?.finishDrawing();
+        } else if (ev.key === "Escape") {
+          ev.preventDefault();
+          this.draw.abortDrawing?.();
+        }
+      };
+      window.addEventListener("keydown", keyHandler);
+      const detachPerSketch = () => {
+        unByKey2(changeKey);
+        if (keyHandler) {
+          window.removeEventListener("keydown", keyHandler);
+          keyHandler = null;
+        }
+      };
+      this.draw.once("drawend", detachPerSketch);
+      this.draw.once("drawabort", detachPerSketch);
+    });
+    this.draw.on("drawend", async (e) => {
+      const f = e.feature;
+      if (!f.getId()) {
+        f.setId(crypto.randomUUID());
+      }
+      this.setStyle(f, opts.style);
+      this.modify?.setActive(true);
+      const b = opts.buffer;
+      const wantsInteractive = !!b && (b === true || typeof b === "object" && b.interactive) && ["Point", "LineString", "Polygon"].includes(f.getGeometry()?.getType() || "");
+      if (wantsInteractive && this.map && this.source) {
+        const params = b === true ? {} : b;
+        const g = f.getGeometry();
+        const gType = g.getType();
+        const previewStyle = params.style ?? { strokeColor: "#0080ff", strokeWidth: 2, fillColor: "rgba(0,128,255,0.12)" };
+        let preview = null;
+        let lastDist = 0;
+        const THROTTLE_MS = 90;
+        let lastRun = 0;
+        const distanceToGeometry = (px) => {
+          if (gType === "Point") {
+            const c = g.getCoordinates();
+            const dx2 = px[0] - c[0], dy2 = px[1] - c[1];
+            return Math.sqrt(dx2 * dx2 + dy2 * dy2);
+          }
+          const closest = g.getClosestPoint(px);
+          const dx = px[0] - closest[0], dy = px[1] - closest[1];
+          return Math.sqrt(dx * dx + dy * dy);
+        };
+        this.modify?.setActive(false);
+        this.snap?.setActive?.(false);
+        let moveKey = this.map.on("pointermove", async (evt) => {
+          const now = performance.now();
+          if (now - lastRun < THROTTLE_MS) return;
+          lastRun = now;
+          const dist = distanceToGeometry(evt.coordinate);
+          if (dist <= 0) return;
+          lastDist = dist;
+          const buffered = await this.turfBufferFeature(f, {
+            distance: dist,
+            units: params.units ?? "meters",
+            steps: params.steps ?? 64
+          });
+          if (!buffered) return;
+          buffered.set("nbic:style", previewStyle);
+          buffered.setStyle(makeDrawStyle(previewStyle));
+          if (preview) this.source.removeFeature(preview);
+          preview = buffered;
+          this.source.addFeature(preview);
+        });
+        const pointerDownListener = listen(this.map, "pointerdown", () => finalize());
+        const detach = () => {
+          if (moveKey) {
+            unByKey2(moveKey);
+            moveKey = void 0;
+          }
+          if (pointerDownListener) {
+            unByKey2(pointerDownListener);
+          }
+        };
+        const finalize = () => {
+          detach();
+          if (preview) {
+            if (params.replaceOriginal) this.source.removeFeature(f);
+            this.events.emit("buffer:created", { baseFeature: f, bufferFeature: preview, distance: lastDist, units: params.units ?? "meters" });
+            preview = null;
+          }
+          this.stop();
+        };
+        const esc = (e2) => {
+          if (e2.key !== "Escape") return;
+          if (moveKey) {
+            unByKey2(moveKey);
+            moveKey = void 0;
+          }
+          if (preview) {
+            this.source.removeFeature(preview);
+            preview = null;
+          }
+          window.removeEventListener("keydown", esc);
+          this.modify?.setActive(true);
+          this.snap?.setActive?.(true);
+          this.draw?.setActive(true);
+        };
+        window.addEventListener("keydown", esc);
+        this.events.emit("buffer:interactive:start", { mode: gType });
+        return;
+      }
+      const wantsNonInteractive = !!b && typeof b === "object" && !b.interactive;
+      if (wantsNonInteractive && this.map && this.source) {
+        const bb = b;
+        const buffered = await this.turfBufferFeature(f, {
+          distance: bb.distance ?? 50,
+          units: bb.units ?? "meters",
+          steps: bb.steps ?? 64
+        });
+        if (buffered) {
+          const finalStyle = bb.style ?? { strokeColor: "#0057ff", strokeWidth: 2, fillColor: "rgba(0,87,255,0.16)" };
+          buffered.set("nbic:style", finalStyle);
+          buffered.setStyle(makeDrawStyle(finalStyle));
+          this.source.addFeature(buffered);
+          if (bb.replaceOriginal) this.source.removeFeature(f);
+          this.events.emit("buffer:created", { baseFeature: f, bufferFeature: buffered, distance: bb.distance ?? 0, units: bb.units ?? "meters" });
+        }
+      }
+      this.events.emit("draw:end", { feature: f });
+      if (this.vertexLayer) this.rebuildVertexOverlay();
+    });
+  }
+  stop() {
+    if (!this.map) return;
+    if (this.draw) {
+      this.map.removeInteraction(this.draw);
+      this.draw = void 0;
+    }
+    if (this.modify) {
+      this.map.removeInteraction(this.modify);
+      this.modify = void 0;
+    }
+    if (this.snap) {
+      this.map.removeInteraction(this.snap);
+      this.snap = void 0;
+    }
+  }
+  undoLastPoint() {
+    this.draw?.removeLastPoint();
+  }
+  finishCurrent() {
+    this.draw?.finishDrawing();
+  }
+  abortCurrent() {
+    this.draw?.abortDrawing();
+  }
+  undoEdit(target) {
+    if (!this.source) return;
+    let f = null;
+    if (target && "feature" in target) {
+      f = target.feature;
+    } else if (target && "featureId" in target) {
+      const found = this.source.getFeatureById(target.featureId);
+      f = found ?? null;
+    } else {
+      if (!this.lastEditedKey) return;
+      const feats = this.source.getFeatures();
+      for (const cand of feats) {
+        const key2 = this.featureKey(cand);
+        if (key2 === this.lastEditedKey) {
+          f = cand;
+          break;
+        }
+      }
+    }
+    if (!f) return;
+    const key = this.featureKey(f);
+    const stack = this.editUndoStack.get(key);
+    if (!stack || stack.length === 0) return;
+    const cur = f.getGeometry();
+    if (cur) {
+      const redo = this.editRedoStack.get(key) ?? [];
+      redo.push(cur.clone());
+      this.editRedoStack.set(key, redo);
+    }
+    const prev = stack.pop();
+    if (!prev) return;
+    this.restoreGeometrySnapshot(f, prev);
+    if (this.vertexLayer) this.rebuildVertexOverlay();
+    this.events.emit("edit:undo", { feature: f });
+  }
+  enableEditing(options) {
+    if (!this.map) return;
+    this.ensureLayer();
+    let showHandles = true;
+    let persistent = false;
+    let vertexStyleOpts;
+    if (typeof options === "boolean") {
+      showHandles = options;
+    } else if (options) {
+      showHandles = options.showVertices !== false;
+      persistent = !!options.showVerticesPersistent;
+      vertexStyleOpts = options.vertexStyle;
+    }
+    if (this.modify) {
+      this.map.removeInteraction(this.modify);
+      this.modify = void 0;
+    }
+    const modifyStyle = showHandles ? this.makeVertexStyle(vertexStyleOpts) : () => void 0;
+    this.modify = new Modify({ source: this.source, style: modifyStyle });
+    this.map.addInteraction(this.modify);
+    this.modify.on("modifystart", (e) => {
+      const feats = e.features;
+      for (let i = 0; i < feats.getLength(); i++) {
+        const f = feats.item(i);
+        this.pushGeometrySnapshot(f);
+      }
+    });
+    this.modify.on("modifyend", (e) => {
+      this.events.emit("edit:modified", {
+        count: e.features.getLength(),
+        feature: e.features.item(0)
+      });
+      if (persistent) this.rebuildVertexOverlay();
+    });
+    if (!this.snap) {
+      this.snap = new Snap({ source: this.source });
+      this.map.addInteraction(this.snap);
+    }
+    if (persistent) {
+      this.ensureVertexLayer(vertexStyleOpts);
+      this.rebuildVertexOverlay();
+      this.source.on("addfeature", () => this.rebuildVertexOverlay());
+      this.source.on("removefeature", () => this.rebuildVertexOverlay());
+      this.source.on("changefeature", () => this.rebuildVertexOverlay());
+    } else {
+      this.destroyVertexLayer();
+    }
+  }
+  disableEditing() {
+    if (!this.map) return;
+    if (this.modify) {
+      this.map.removeInteraction(this.modify);
+      this.modify = void 0;
+    }
+    if (this.snap) {
+      this.map.removeInteraction(this.snap);
+      this.snap = void 0;
+    }
+    this.destroyVertexLayer();
+  }
+  clear() {
+    const count = this.source?.getFeatures().length ?? 0;
+    this.source?.clear(true);
+    this.events.emit("draw:cleared", { count });
+    if (this.vertexLayer) this.rebuildVertexOverlay();
+  }
+  exportGeoJSON(map, opts) {
+    const json = this.fmt.writeFeatures(this.source?.getFeatures() ?? [], {
+      featureProjection: String(map.getView().getProjection() ?? "EPSG:3857")
+    });
+    return opts?.pretty ? JSON.stringify(JSON.parse(json), null, 2) : json;
+  }
+  importGeoJSON(map, geojson, opts) {
+    this.ensureLayer();
+    const features = this.fmt.readFeatures(geojson, {
+      featureProjection: String(map.getView().getProjection())
+    });
+    if (opts?.clearExisting) this.source.clear(true);
+    for (const f of features) {
+      const styleOpts = f.get("nbic:style");
+      if (styleOpts) f.setStyle(makeDrawStyle(styleOpts));
+      const label = f.get("label");
+      if (label && styleOpts?.text) f.setStyle(makeDrawStyle({ ...styleOpts, text: { ...styleOpts.text, label } }));
+    }
+    this.source.addFeatures(features);
+    this.events.emit("draw:imported", { count: features.length });
+  }
+  setFeatureStyle(feature, style) {
+    if (!feature) return;
+    feature.set("nbic:style", style);
+    feature.setStyle(makeUpdatedDrawStyle(style));
+  }
+  clearFeatureStyle(feature) {
+    feature.unset("nbic:style", true);
+    feature.setStyle(void 0);
+  }
+};
+
+// src/core/ol/controls/ControlsController.ts
+import Zoom from "ol/control/Zoom";
+import ScaleLine from "ol/control/ScaleLine";
+import Attribution from "ol/control/Attribution";
+import FullScreen from "ol/control/FullScreen";
+var ControlsController = class {
+  map;
+  zoom;
+  scale;
+  attr;
+  fs;
+  custom = /* @__PURE__ */ new Map();
+  attach(map, events, init) {
+    this.map = map;
+    if (init?.zoom) this.ensureZoom(map, events);
+    if (init?.scaleLine) this.ensureScaleLine(map, events);
+    if (init?.attribution) this.ensureAttribution(map, events);
+    if (init?.fullscreen) this.ensureFullScreen(map);
+  }
+  detach() {
+    if (!this.map) return;
+    if (this.zoom) this.map.removeControl(this.zoom);
+    if (this.scale) this.map.removeControl(this.scale);
+    if (this.attr) this.map.removeControl(this.attr);
+    if (this.fs) this.map.removeControl(this.fs);
+    this.zoom = this.scale = this.attr = this.fs = void 0;
+    this.map = void 0;
+  }
+  ensureZoom(map, events) {
+    if (this.zoom) return;
+    this.zoom = new Zoom();
+    map.addControl(this.zoom);
+    events?.emit("controls:zoom", { visible: true });
+  }
+  removeZoom(map, events) {
+    if (!this.zoom) return;
+    map.removeControl(this.zoom);
+    this.zoom = void 0;
+    events?.emit("controls:zoom", { visible: false });
+  }
+  ensureScaleLine(map, events) {
+    if (this.scale) return;
+    this.scale = new ScaleLine();
+    map.addControl(this.scale);
+    events?.emit("controls:scaleline", { visible: true });
+  }
+  removeScaleLine(map, events) {
+    if (!this.scale) return;
+    map.removeControl(this.scale);
+    this.scale = void 0;
+    events?.emit("controls:scaleline", { visible: false });
+  }
+  ensureAttribution(map, events) {
+    if (this.attr) return;
+    this.attr = new Attribution({ collapsible: true, collapsed: false });
+    map.addControl(this.attr);
+    events?.emit("controls:attribution", { visible: true });
+  }
+  removeAttribution(map, events) {
+    if (!this.attr) return;
+    map.removeControl(this.attr);
+    this.attr = void 0;
+    events?.emit("controls:attribution", { visible: false });
+  }
+  ensureFullScreen(map) {
+    if (this.fs) return;
+    this.fs = new FullScreen();
+    map.addControl(this.fs);
+  }
+  removeFullScreen(map) {
+    if (!this.fs) return;
+    map.removeControl(this.fs);
+    this.fs = void 0;
+  }
+  /** Add a custom OL control. Returns the resolved ID. */
+  adopt(control, id) {
+    if (!this.map) throw new Error("ControlsController: map not attached");
+    const existingId = control.get?.("id");
+    const resolved = id ?? existingId ?? `custom:${Math.random().toString(36).slice(2, 10)}`;
+    const old = this.custom.get(resolved);
+    if (old) this.map.removeControl(old);
+    control.set?.("id", resolved);
+    this.map.addControl(control);
+    this.custom.set(resolved, control);
+    return resolved;
+  }
+  /** Remove a custom control by id (no-op if not found). */
+  remove(id) {
+    if (!this.map) return false;
+    const c = this.custom.get(id);
+    if (!c) return false;
+    this.map.removeControl(c);
+    this.custom.delete(id);
+    return true;
+  }
+  /** Get a custom control instance by id. */
+  get(id) {
+    return this.custom.get(id);
+  }
+  /** List all adopted custom control ids. */
+  listIds() {
+    return Array.from(this.custom.keys());
+  }
+};
+
+// src/core/ol/geo/GeoController.ts
+import Geolocation from "ol/Geolocation";
+import VectorSource6 from "ol/source/Vector";
+import VectorLayer4 from "ol/layer/Vector";
+import CircleGeom2 from "ol/geom/Circle";
+import Point3 from "ol/geom/Point";
+import { Style as Style6, Fill as Fill6, Stroke as Stroke6, Circle as CircleStyle6 } from "ol/style";
+import { Feature as Feature3 } from "ol";
+var GeoController = class {
+  constructor(events) {
+    this.events = events;
+  }
+  map;
+  geo;
+  src;
+  layer;
+  follow = false;
+  attach(map) {
+    this.map = map;
+  }
+  detach() {
+    this.deactivate();
+    this.map = void 0;
+  }
+  ensureLayer() {
+    if (!this.map || this.layer) return;
+    this.src = new VectorSource6();
+    this.layer = new VectorLayer4({
+      source: this.src,
+      properties: { "nbic:role": "geolocation" },
+      zIndex: 9998,
+      style: (f) => {
+        const g = f.getGeometry();
+        if (g instanceof CircleGeom2) {
+          return new Style6({
+            fill: new Fill6({ color: "rgba(33,150,243,0.15)" }),
+            stroke: new Stroke6({ color: "#2196f3", width: 1 })
+          });
+        }
+        return new Style6({
+          image: new CircleStyle6({
+            radius: 6,
+            fill: new Fill6({ color: "#2196f3" }),
+            stroke: new Stroke6({ color: "#fff", width: 2 })
+          })
+        });
+      }
+    });
+    this.map.addLayer(this.layer);
+  }
+  activate(follow) {
+    if (!this.map) return;
+    if (!this.geo) {
+      this.geo = new Geolocation({
+        projection: this.map.getView().getProjection(),
+        tracking: false,
+        trackingOptions: { enableHighAccuracy: true, maximumAge: 1e4, timeout: 1e4 }
+      });
+      this.geo.on("change:position", () => {
+        const p = this.geo.getPosition();
+        const acc = this.geo.getAccuracy();
+        if (!p) {
+          this.events.emit("geo:position", null);
+          return;
+        }
+        this.ensureLayer();
+        this.src.clear();
+        this.src.addFeatures([
+          new Feature3({ geometry: new CircleGeom2(p, acc || 0) }),
+          new Feature3({ geometry: new Point3(p) })
+        ]);
+        if (this.follow) this.map.getView().setCenter(p);
+        this.events.emit("geo:position", { coordinate: p, accuracy: acc ?? void 0 });
+      });
+      this.geo.on("error", (e) => {
+        this.events.emit("geo:error", { message: e.message ?? "Geolocation error" });
+      });
+    }
+    this.follow = !!follow;
+    this.geo.setTracking(true);
+  }
+  deactivate() {
+    if (this.geo) this.geo.setTracking(false);
+    if (this.layer && this.map) this.map.removeLayer(this.layer);
+    this.geo = void 0;
+    this.src = void 0;
+    this.layer = void 0;
+  }
+  async zoomToGeolocation(maxZoom = 14) {
+    if (!this.map) return false;
+    this.activate(true);
+    return new Promise((resolve) => {
+      const once = () => {
+        const p = this.geo.getPosition();
+        if (p) {
+          this.ensureLayer();
+          this.map.getView().animate({ center: p, zoom: Math.max(this.map.getView().getZoom() ?? 0, maxZoom), duration: 300 });
+          resolve(true);
+        } else resolve(false);
+        this.geo.un("change:position", once);
+        this.geo.setTracking(false);
+      };
+      this.geo.on("change:position", once);
+    });
+  }
+};
+
+// src/core/ol/zoom/ZoomController.ts
+import VectorSource7 from "ol/source/Vector";
+import { getCenter } from "ol/extent";
+var ZoomController = class {
+  map = null;
+  attach(map) {
+    this.map = map;
+  }
+  detach() {
+    this.map = null;
+  }
+  fitExtent(ext, opts) {
+    if (!this.map) return false;
+    const view = this.map.getView();
+    const size = this.map.getSize();
+    if (!view || !size) return false;
+    const paddingPx = opts?.paddingPx ?? 40;
+    const durationMs = opts?.durationMs ?? 250;
+    const fitOpts = {
+      padding: [paddingPx, paddingPx, paddingPx, paddingPx],
+      duration: durationMs,
+      maxZoom: Infinity
+    };
+    if (typeof opts?.maxZoom === "number") fitOpts.maxZoom = opts.maxZoom;
+    const minSizePx = opts?.minSizePx ?? 64;
+    const res = view.getResolution() ?? 1;
+    const minMapUnits = res * minSizePx;
+    const e = ext.slice();
+    if (e[0] === e[2] || e[1] === e[3]) {
+      const [cx, cy] = getCenter(e);
+      e[0] = cx ?? 0 - minMapUnits / 2;
+      e[2] = cx ?? 0 + minMapUnits / 2;
+      e[1] = cy ?? 0 - minMapUnits / 2;
+      e[3] = cy ?? 0 + minMapUnits / 2;
+    }
+    view.fit(e, fitOpts);
+    return true;
+  }
+  fitGeometry(geom, opts) {
+    return this.fitExtent(geom.getExtent(), opts);
+  }
+  zoomToFeature(layer, featureId, opts) {
+    const src = layer.getSource();
+    if (!src) return false;
+    const feat = src.getFeatureById(featureId);
+    const geom = feat?.getGeometry();
+    return geom ? this.fitGeometry(geom, opts) : false;
+  }
+  zoomToLayer(layer, opts) {
+    const src = layer.getSource();
+    if (!src) return false;
+    if (!(src instanceof VectorSource7)) return console.warn("zoomToLayer: not a vector source"), false;
+    const feats = src.getFeatures();
+    if (!feats.length) return false;
+    let ext = feats[0]?.getGeometry()?.getExtent()?.slice();
+    for (let i = 1; i < feats.length; i++) {
+      const g = feats[i]?.getGeometry();
+      if (!g) continue;
+      const e = g.getExtent();
+      if (!ext) ext = e.slice();
+      else {
+        ext[0] = Math.min(ext[0] ?? Infinity, e[0] ?? Infinity);
+        ext[1] = Math.min(ext[1] ?? Infinity, e[1] ?? Infinity);
+        ext[2] = Math.max(ext[2] ?? -Infinity, e[2] ?? -Infinity);
+        ext[3] = Math.max(ext[3] ?? -Infinity, e[3] ?? -Infinity);
+      }
+    }
+    return ext ? this.fitExtent(ext, opts) : false;
+  }
+  // Convenience by id (uses your registry/lookup)
+  zoomToFeatureById(reg, layerId, featureId, opts) {
+    const l = reg.get(layerId);
+    if (!l) return false;
+    return this.zoomToFeature(l, featureId, opts);
+  }
+  zoomToLayerById(reg, layerId, opts) {
+    const l = reg.get(layerId);
+    if (!l) return false;
+    return this.zoomToLayer(l, opts);
+  }
+  zoomToExtent(ext, opts) {
+    return this.fitExtent(ext, opts);
+  }
+};
+
+// src/core/ol/OlMapEngine.ts
+import GeoJSON4 from "ol/format/GeoJSON";
+import VectorSource8 from "ol/source/Vector";
+import Cluster2 from "ol/source/Cluster";
+
+// src/core/ol/utils/picking.ts
+function isPickableLayer(l) {
+  if (!l || typeof l.get !== "function") return false;
+  const get = l.get.bind(l);
+  const role = get("nbic:role");
+  if (role === "hover") return false;
+  const vis = l.getVisible?.();
+  if (vis === false) return false;
+  if (get("nbic:pickable") === false) return false;
+  return true;
+}
+
+// src/core/ol/utils/coords.ts
+import { transform, transformExtent } from "ol/proj";
+import { getCenter as getCenter2 } from "ol/extent";
+function toViewCoord(map, coord, from) {
+  const viewProj = String(map.getView().getProjection().getCode());
+  if (!from || from === viewProj) return coord;
+  return transform(coord, from, viewProj);
+}
+function toDataCoord(map, coord, to = "EPSG:4326") {
+  const viewProj = String(map.getView().getProjection().getCode());
+  if (to === viewProj) return coord;
+  return transform(coord, viewProj, to);
+}
+function transformCoordsArrayFrom(coords, from, to) {
+  return coords.map((c) => transform(c, from, to));
+}
+function transformCoordsFrom(coords, from, to) {
+  return transform(coords, from, to);
+}
+function transformExtentFrom(extent, from, to) {
+  return transformExtent(extent, from, to);
+}
+function getCenterFromExtent(extent) {
+  return getCenter2(extent);
+}
+
+// src/core/ol/OlMapEngine.ts
+import { getCenter as getCenter3 } from "ol/extent";
+
+// src/core/ol/select/SelectController.ts
+import Cluster from "ol/source/Cluster";
+var SelectController = class {
+  constructor(events) {
+    this.events = events;
+  }
+  map;
+  selected = null;
+  selectedPrevStyle = void 0;
+  selectedPrevNbicStyle = void 0;
+  attach(map) {
+    this.map = map;
+  }
+  detach() {
+    this.clear();
+    this.map = void 0;
+  }
+  getSelection() {
+    return this.selected;
+  }
+  clear(registry) {
+    if (!this.selected) return;
+    if (registry) {
+      const prev = this.findFeatureById(registry, this.selected.layerId, this.selected.featureId, this.selected.coordinates);
+      if (prev) this.restoreFeature(prev);
+    }
+    this.selected = null;
+    this.selectedPrevStyle = void 0;
+    this.selectedPrevNbicStyle = void 0;
+    this.events.emit("select:changed", null);
+  }
+  /** Select feature by its id (restores previous selection automatically). */
+  selectById(registry, layerId, featureId, style, coordinates) {
+    if (!this.map) return false;
+    if (this.selected) {
+      const prev = this.findFeatureById(registry, this.selected.layerId, this.selected.featureId, this.selected.coordinates);
+      if (prev) this.restoreFeature(prev);
+      this.selected = null;
+      this.selectedPrevStyle = void 0;
+      this.selectedPrevNbicStyle = void 0;
+    }
+    const f = this.findFeatureById(registry, layerId, featureId, coordinates);
+    if (!f) return false;
+    this.selected = { layerId, featureId, coordinates };
+    this.selectedPrevStyle = f.getStyle();
+    this.selectedPrevNbicStyle = f.get("nbic:style");
+    if (style) {
+      f.set("nbic:style", style);
+      f.setStyle(makeDrawStyle(style));
+    } else {
+      f.setStyle(
+        makeDrawStyle({
+          strokeColor: "#00c853",
+          strokeWidth: 3,
+          fillColor: "rgba(0,200,83,0.15)"
+        })
+      );
+    }
+    this.events.emit("select:changed", { layerId, featureId });
+    return true;
+  }
+  restoreFeature(feature) {
+    if (this.selectedPrevNbicStyle === void 0) {
+      feature.unset("nbic:style", true);
+    } else {
+      feature.set("nbic:style", this.selectedPrevNbicStyle);
+    }
+    feature.setStyle(this.selectedPrevStyle);
+  }
+  /**
+   * If the clicked thing is a cluster output feature, unwrap single-member clusters
+   * and return the inner feature id for selection.
+   */
+  resolveSelectableIdFromClusterFeature(feature) {
+    const members = feature.get("features");
+    if (!members?.length) return null;
+    if (members.length === 1) {
+      const id = members[0]?.getId();
+      return typeof id === "string" || typeof id === "number" ? id : null;
+    }
+    return null;
+  }
+  // ---- internals ----
+  findFeatureById(registry, layerId, featureId, coordinates) {
+    const src = registry.getVectorSource(layerId);
+    if (!src) return null;
+    if (src instanceof Cluster) {
+      const inner = src.getSource();
+      const f2 = inner?.getFeatureById(featureId);
+      return f2 ?? null;
+    }
+    let f = null;
+    if (coordinates) {
+      const features = src.getFeaturesAtCoordinate(coordinates);
+      f = features ? features[0] : null;
+    } else {
+      f = src.getFeatureById(featureId);
+      if (!f) {
+        f = src.getFeatureByUid(featureId.toString());
+      }
+    }
+    return f ?? null;
+  }
+};
+
+// src/core/ol/OlMapEngine.ts
+function resolveVectorSource(layer) {
+  const src = layer.getSource();
+  if (!src) return null;
+  if (src instanceof Cluster2) {
+    const inner = src.getSource();
+    return inner ?? null;
+  }
+  return src;
+}
+function createOlEngine(events) {
+  let map;
+  let hover = null;
+  const registry = new LayerRegistry();
+  const bases = new BaseLayersController(events);
+  const draw = new DrawController(events);
+  const controls = new ControlsController();
+  const geo = new GeoController(events);
+  const zoom = new ZoomController();
+  const select = new SelectController(events);
+  bases.bindFind((id) => registry.get(id) ?? null);
+  return {
+    async init(init) {
+      const view = new View({
+        projection: init.projection ?? "EPSG:3857",
+        center: init.center ?? [0, 0],
+        zoom: init.zoom ?? 2,
+        minZoom: init.minZoom,
+        maxZoom: init.maxZoom
+      });
+      map = new OlMap({
+        target: init.target,
+        view,
+        controls: new Collection([])
+      });
+      controls.attach(map, events, init.controls);
+      draw.attach(map);
+      const dl = draw.getLayer();
+      if (dl) registry.add("draw-layer", dl);
+      geo.attach(map);
+      zoom.attach(map);
+      select.attach(map);
+      map.on("moveend", () => {
+        if (!map) return;
+        const v = map.getView();
+        const payload = {
+          center: v.getCenter(),
+          zoom: v.getZoom() ?? 0
+        };
+        events.emit("camera:changed", payload);
+        const ex = v.calculateExtent(map.getSize() ?? void 0);
+        events.emit("extent:changed", { extent: ex });
+      });
+      map.on("singleclick", (evt) => {
+        if (!map) return;
+        const features = [];
+        map.forEachFeatureAtPixel(
+          evt.pixel,
+          (f, l) => {
+            if (!f || !isPickableLayer(l)) return void 0;
+            features.push({
+              feature: f,
+              layer: l,
+              featureId: f.getId(),
+              layerId: l.get("id"),
+              properties: f.getProperties()
+            });
+            return void 0;
+          },
+          { hitTolerance: 5, layerFilter: isPickableLayer }
+        );
+        const clickCoordinate = evt.coordinate;
+        events.emit("pointer:click", features.length ? { features, clickCoordinate } : { clickCoordinate, features: null });
+      });
+    },
+    destroy() {
+      draw.detach();
+      geo.detach();
+      controls.detach();
+      map?.setTarget(void 0);
+      map = void 0;
+      registry.clear();
+      bases.clear();
+      select.detach();
+    },
+    getCamera() {
+      const v = map.getView();
+      return {
+        center: v.getCenter(),
+        zoom: v.getZoom() ?? 0
+      };
+    },
+    getExtent() {
+      const v = map.getView();
+      return v.calculateExtent(map.getSize() ?? void 0);
+    },
+    setCenter(center) {
+      map.getView().setCenter(center);
+    },
+    setZoom(zoom2) {
+      map.getView().setZoom(zoom2);
+    },
+    fitExtent(ext, padding) {
+      map.getView().fit(ext, { padding: [padding, padding, padding, padding] });
+    },
+    // layers
+    listLayerIds: () => registry.listIds(),
+    listBaseLayerIds: () => registry.listIds().filter((id) => {
+      const l = registry.get(id);
+      return !!l && bases.isBase(l);
+    }),
+    listOverlayLayerIds: () => registry.listIds().filter((id) => {
+      const l = registry.get(id);
+      return !!l && !bases.isBase(l);
+    }),
+    getLayerById: (id) => registry.get(id) ?? null,
+    addLayer(def) {
+      const layer = toOlLayer(def);
+      layer.set("id", def.id);
+      layer.set("nbic:pickable", def?.pickable !== false);
+      map.addLayer(layer);
+      registry.add(def.id, layer);
+      if (def.base) {
+        const role = def.base === "super" ? "super" : "regional";
+        bases.registerBase(layer, role, def);
+      } else if (def.zIndexPinned && def.zIndex !== void 0) {
+        layer.setZIndex(def.zIndex);
+      }
+    },
+    removeLayer(id) {
+      const l = registry.get(id);
+      if (!l) return;
+      map.removeLayer(l);
+      registry.remove(id);
+      bases.onRemoved(id);
+    },
+    adoptLayer(id, layer, opts) {
+      if (!map || !layer) return;
+      layer.set("id", id);
+      layer.set("nbic:external", true);
+      layer.set("nbic:role", opts?.role ?? "overlay");
+      layer.set("nbic:pickable", opts?.pickable !== false);
+      map.addLayer(layer);
+      registry.add(id, layer);
+      if (opts?.base) {
+        const role = opts.base === "super" ? "super" : "regional";
+        bases.registerBase(layer, role, { id, base: role });
+      } else if (opts?.zIndex !== void 0) {
+        layer.setZIndex(opts.zIndex);
+      }
+    },
+    ejectLayer(id) {
+      const l = registry.get(id);
+      if (!l) return;
+      map.removeLayer(l);
+      registry.remove(id);
+      bases.onRemoved(id);
+    },
+    getFeatureCount(layerId) {
+      const src = registry.getVectorSource(layerId);
+      if (!src) return 0;
+      const feats = src.getFeatures();
+      if (!feats.length) return 0;
+      if (src instanceof Cluster2) {
+        const maybeCluster = src.getSource?.();
+        if (maybeCluster && typeof maybeCluster.getFeatures === "function") {
+          return maybeCluster.getFeatures().length;
+        }
+      }
+      return feats.length;
+    },
+    getFeatures(layerId) {
+      const src = registry.getVectorSource(layerId);
+      if (!src) return [];
+      if (src instanceof Cluster2) {
+        const maybeCluster = src.getSource?.();
+        if (maybeCluster && typeof maybeCluster.getFeatures === "function") {
+          return maybeCluster.getFeatures();
+        }
+      }
+      return src.getFeatures();
+    },
+    adoptControl(control, id) {
+      return controls.adopt(control, id);
+    },
+    removeControl(id) {
+      return controls.remove(id);
+    },
+    listCustomControlIds() {
+      return controls.listIds();
+    },
+    getCustomControl(id) {
+      return controls.get(id);
+    },
+    updateGeoJSONLayer(layerId, geojson, opts) {
+      const layer = registry.get(layerId);
+      if (!map || !layer) return false;
+      const viewProj = String(map.getView().getProjection().getCode());
+      const dataProj = opts?.dataProjection ?? layer.get("nbic:dataProjection") ?? viewProj;
+      const fmt = new GeoJSON4();
+      const text = typeof geojson === "string" ? geojson : JSON.stringify(geojson);
+      const incoming = fmt.readFeatures(text, {
+        dataProjection: dataProj,
+        featureProjection: viewProj
+      });
+      const idProp = opts?.idProperty;
+      if (idProp) {
+        for (const f of incoming) {
+          const id = f.get(idProp);
+          if (id !== void 0) f.setId(id);
+        }
+      }
+      const currentSrc = layer.getSource();
+      const clusterMeta = layer.get("nbic:cluster");
+      const isClustered = currentSrc instanceof Cluster2;
+      const curVector = isClustered ? currentSrc.getSource() : currentSrc;
+      const mode = opts?.mode ?? "replace";
+      let nextVector;
+      if (mode === "replace") {
+        nextVector = new VectorSource8({ features: incoming });
+      } else {
+        const existing = curVector?.getFeatures() ?? [];
+        const byId = /* @__PURE__ */ new Map();
+        for (const f of existing) {
+          const id = f.getId();
+          if (id !== void 0 && id !== null) byId.set(id, f);
+        }
+        const merged = [];
+        const seen = /* @__PURE__ */ new Set();
+        for (const nf of incoming) {
+          const id = nf.getId();
+          if (id === void 0 || id === null) {
+            merged.push(nf);
+            continue;
+          }
+          seen.add(id);
+          const cur = byId.get(id);
+          if (!cur) {
+            merged.push(nf);
+          } else {
+            const g = nf.getGeometry();
+            if (g) cur.setGeometry(g);
+            const props = nf.getProperties();
+            delete props.geometry;
+            cur.setProperties(props);
+            if (!opts?.keepStyles) {
+              const s = nf.get("nbic:style");
+              if (s) cur.setStyle(cur.getStyle());
+            }
+            merged.push(cur);
+          }
+        }
+        for (const f of existing) {
+          const id = f.getId();
+          if (id === void 0 || id === null) merged.push(f);
+        }
+        nextVector = new VectorSource8({ features: merged });
+      }
+      let nextSource;
+      if (isClustered || clusterMeta) {
+        const distance = currentSrc instanceof Cluster2 ? currentSrc.getDistance?.() ?? clusterMeta?.distance ?? 40 : clusterMeta?.distance ?? 40;
+        const minDistance = currentSrc instanceof Cluster2 ? currentSrc.getMinDistance?.() ?? clusterMeta?.minDistance ?? 0 : clusterMeta?.minDistance ?? 0;
+        nextSource = new Cluster2({
+          distance,
+          minDistance,
+          source: nextVector
+        });
+      } else {
+        nextSource = nextVector;
+      }
+      layer.setSource(nextSource);
+      return true;
+    },
+    setLayerVisibility(id, visible) {
+      const l = registry.get(id);
+      if (!l) return;
+      if (!bases.isBase(l)) {
+        l.setVisible(visible);
+        return;
+      }
+      bases.setVisibility(l, visible);
+    },
+    setActiveBase(id) {
+      bases.setActiveRegional(id);
+    },
+    reorderLayers(order) {
+      registry.reorder(order, bases);
+    },
+    // hover info        
+    activateHoverInfo(options) {
+      if (!map) return;
+      if (!hover) hover = new HoverInfoController(map, events);
+      hover.activate(options);
+    },
+    deactivateHoverInfo() {
+      hover?.deactivate();
+    },
+    // picking
+    pickAt(pixel) {
+      if (!map) return null;
+      const coordinate = map.getCoordinateFromPixel(pixel);
+      if (!coordinate) return null;
+      return map.forEachFeatureAtPixel(
+        pixel,
+        (feature, layer) => {
+          if (!isPickableLayer(layer)) return void 0;
+          return {
+            layerId: layer.get("id"),
+            featureId: feature.getId(),
+            properties: feature.getProperties(),
+            coordinate
+          };
+        },
+        { hitTolerance: 5, layerFilter: isPickableLayer }
+      ) ?? null;
+    },
+    // drawing
+    startDrawing: (opts) => draw.start(opts),
+    stopDrawing: () => draw.stop(),
+    enableDrawEditing: (opts) => draw.enableEditing(opts),
+    disableDrawEditing: () => draw.disableEditing(),
+    undoLastPoint: () => draw.undoLastPoint(),
+    undoEdit: () => draw.undoEdit(),
+    finishCurrent: () => draw.finishCurrent(),
+    abortCurrent: () => draw.abortCurrent(),
+    clearDrawn: () => draw.clear(),
+    exportDrawnGeoJSON: (opts) => draw.exportGeoJSON(map, opts),
+    importDrawnGeoJSON: (geojson, opts) => draw.importGeoJSON(map, geojson, opts),
+    setDrawnFeatureStyle: (feature, style) => draw.setFeatureStyle(feature, style),
+    clearDrawnFeatureStyle: (feature) => draw.clearFeatureStyle(feature),
+    setFeatureStyle(layerId, featureId, style) {
+      const layer = registry.get(layerId);
+      if (!layer) return false;
+      const src = resolveVectorSource(layer);
+      if (!src) return false;
+      const feat = src.getFeatureById(featureId);
+      if (!feat) return false;
+      feat.set("nbic:style", style);
+      feat.setStyle(makeDrawStyle(style));
+      return true;
+    },
+    clearFeatureStyle(layerId, featureId) {
+      const layer = registry.get(layerId);
+      if (!layer) return false;
+      const src = resolveVectorSource(layer);
+      if (!src) return false;
+      const feat = src.getFeatureById(featureId);
+      if (!feat) return false;
+      feat.unset("nbic:style", true);
+      feat.setStyle(void 0);
+      return true;
+    },
+    // geometry analysis
+    analyzeSelfIntersections: async (feature) => {
+      if (!map) return { valid: true };
+      const { checkSelfIntersections } = await import("./geometry-analysis-ERCBMJB7.js");
+      return checkSelfIntersections(map, feature);
+    },
+    // full-screen
+    enterFullScreen() {
+      if (!map) return;
+      const el = map.getTargetElement();
+      if (el && !document.fullscreenElement) {
+        void el.requestFullscreen().catch(() => {
+        });
+      }
+    },
+    leaveFullScreen() {
+      if (document.fullscreenElement) {
+        void document.exitFullscreen().catch(() => {
+        });
+      }
+    },
+    // controls
+    showScaleLine: () => controls.ensureScaleLine(map, events),
+    hideScaleLine: () => controls.removeScaleLine(map, events),
+    showZoomControl: () => controls.ensureZoom(map, events),
+    hideZoomControl: () => controls.removeZoom(map, events),
+    showAttribution: () => controls.ensureAttribution(map, events),
+    hideAttribution: () => controls.removeAttribution(map, events),
+    // geolocation
+    activateGeolocation: (follow) => geo.activate(follow),
+    deactivateGeolocation: () => geo.deactivate(),
+    zoomToGeolocation: (maxZoom) => geo.zoomToGeolocation(maxZoom),
+    // vector layers
+    getVectorLayerSource: (layerId) => registry.getVectorSource(layerId),
+    addPoint(layerId, coordinate, props, style, opts) {
+      const src = registry.getVectorSource(layerId);
+      if (!map || !src) return false;
+      const viewCoord = toViewCoord(map, coordinate, opts?.dataProjection);
+      const f = draw.createPointFeature(viewCoord, props, style);
+      src.addFeature(f);
+      return true;
+    },
+    removeAllFromLayer(layerId) {
+      const src = registry.getVectorSource(layerId);
+      if (!src) return false;
+      src.clear(true);
+      return true;
+    },
+    // Transform coordinates        
+    transformCoordsFrom: (coord, from, to) => {
+      return transformCoordsFrom(coord, from, to);
+    },
+    transformCoordsArrayFrom: (coords, from, to) => {
+      return transformCoordsArrayFrom(coords, from, to);
+    },
+    transformExtentFrom: (extent, from, to) => {
+      return transformExtentFrom(extent, from, to);
+    },
+    // Zoom
+    zoomToFeature: (layerId, featureId, opts) => zoom.zoomToFeatureById(registry, layerId, featureId, opts),
+    zoomToLayer: (layerId, opts) => zoom.zoomToLayerById(registry, layerId, opts),
+    zoomToExtent: (extent, opts) => zoom.zoomToExtent(extent, opts),
+    fitGeometry: (geom, opts) => zoom.fitGeometry(geom, opts),
+    // Select
+    selectFeature: (layerId, featureId, style, coordinates) => select.selectById(registry, layerId, featureId, style, coordinates),
+    clearSelection: () => select.clear(registry),
+    getSelection: () => select.getSelection(),
+    // Utils
+    getTargetElement: () => {
+      return map?.getTargetElement() ?? null;
+    },
+    getCenterFromExtent: (extent) => {
+      return getCenter3(extent);
+    }
+  };
+}
+
+// src/api/MapAPI.ts
+var MapAPI = class {
+  engine;
+  events;
+  layerDefs = /* @__PURE__ */ new Map();
+  constructor(init, engine) {
+    this.events = createEmitter();
+    this.engine = engine ?? createOlEngine(this.events);
+    this.engine.init(init).then(() => {
+      this.events.emit("ready", void 0);
+    }).catch((err) => {
+      this.events.emit("error", { scope: "init", message: String(err), detail: err });
+    });
+  }
+  // Explicitly typed pass-throughs (avoid binding issues and keep types)
+  on(type, cb) {
+    return this.events.on(type, cb);
+  }
+  off(type, cb) {
+    return this.events.off(type, cb);
+  }
+  once(type, cb) {
+    return this.events.once(type, cb);
+  }
+  destroy() {
+    this.engine.destroy();
+    this.events.emit("destroy", void 0);
+  }
+  getCamera() {
+    return this.engine.getCamera();
+  }
+  getExtent() {
+    return this.engine.getExtent();
+  }
+  /** Return all layers marked as base (in insertion order). */
+  getBaseLayerIds() {
+    return this.engine.listBaseLayerIds();
+  }
+  getOverlayLayerIds() {
+    return this.engine.listOverlayLayerIds();
+  }
+  /** If you still want full LayerDef[] for config-only layers, keep these: */
+  getBaseLayers() {
+    return Array.from(this.layerDefs.values()).filter((l) => !!l.base);
+  }
+  getOverlayLayers() {
+    return Array.from(this.layerDefs.values()).filter((l) => !l.base);
+  }
+  /** Or add engine-backed variants that return live OL layers: */
+  getLayerById(id) {
+    return this.engine.getLayerById(id);
+  }
+  adoptControl(control, id) {
+    return this.engine.adoptControl(control, id);
+  }
+  removeControl(id) {
+    return this.engine.removeControl(id);
+  }
+  listCustomControlIds() {
+    return this.engine.listCustomControlIds();
+  }
+  getCustomControl(id) {
+    return this.engine.getCustomControl(id);
+  }
+  setCenter(center) {
+    this.engine.setCenter(center);
+  }
+  setZoom(zoom) {
+    this.engine.setZoom(zoom);
+  }
+  fitExtent(extent, padding = 16) {
+    this.engine.fitExtent(extent, padding);
+  }
+  addLayer(layer) {
+    this.layerDefs.set(layer.id, layer);
+    this.engine.addLayer(layer);
+    this.events.emit("layer:added", { layerId: layer.id });
+  }
+  removeLayer(layerId) {
+    this.layerDefs.delete(layerId);
+    this.engine.removeLayer(layerId);
+    this.events.emit("layer:removed", { layerId });
+  }
+  updateGeoJSONLayer(layerId, geojson, opts) {
+    this.engine.updateGeoJSONLayer(layerId, geojson, opts);
+  }
+  setLayerVisibility(layerId, visible) {
+    this.engine.setLayerVisibility(layerId, visible);
+  }
+  reorderLayers(order) {
+    this.engine.reorderLayers(order);
+  }
+  addPoint(layerId, coord, properties, style, opts) {
+    return this.engine.addPoint(layerId, coord, properties, style, opts);
+  }
+  removeAllFromLayer(layerId) {
+    return this.engine.removeAllFromLayer(layerId);
+  }
+  adoptLayer(id, layer, opts) {
+    this.engine.adoptLayer(id, layer, opts);
+  }
+  ejectLayer(id) {
+    this.engine.ejectLayer(id);
+    this.layerDefs.delete(id);
+    this.events.emit("layer:removed", { layerId: id });
+  }
+  getFeatureCount(layerId) {
+    return this.engine.getFeatureCount(layerId);
+  }
+  getFeatures(layerId) {
+    return this.engine.getFeatures(layerId);
+  }
+  activateHoverInfo(options) {
+    this.engine.activateHoverInfo(options);
+  }
+  deactivateHoverInfo() {
+    this.engine.deactivateHoverInfo();
+  }
+  pickAt(pixel) {
+    return this.engine.pickAt(pixel);
+  }
+  startDrawing(opts) {
+    this.engine.startDrawing(opts);
+  }
+  stopDrawing() {
+    this.engine.stopDrawing();
+  }
+  enableDrawEditing(opts) {
+    this.engine.enableDrawEditing(opts);
+  }
+  disableDrawEditing() {
+    this.engine.disableDrawEditing();
+  }
+  setDrawnFeatureStyle(feature, style) {
+    return this.engine.setDrawnFeatureStyle(feature, style);
+  }
+  clearDrawnFeatureStyle(feature) {
+    return this.engine.clearDrawnFeatureStyle(feature);
+  }
+  setFeatureStyle(layerId, featureId, style) {
+    return this.engine.setFeatureStyle(layerId, featureId, style);
+  }
+  clearFeatureStyle(layerId, featureId) {
+    return this.engine.clearFeatureStyle(layerId, featureId);
+  }
+  undoLastPoint() {
+    this.engine.undoLastPoint();
+  }
+  undoEdit() {
+    this.engine.undoEdit();
+  }
+  finishCurrent() {
+    this.engine.finishCurrent();
+  }
+  abortCurrent() {
+    this.engine.abortCurrent();
+  }
+  clearDrawn() {
+    this.engine.clearDrawn();
+  }
+  exportDrawnGeoJSON(opts) {
+    return this.engine.exportDrawnGeoJSON(opts);
+  }
+  importDrawnGeoJSON(text, opts) {
+    this.engine.importDrawnGeoJSON(text, opts);
+  }
+  // Geometry analysis
+  analyzeSelfIntersections(feature) {
+    return this.engine.analyzeSelfIntersections(feature);
+  }
+  enterFullScreen() {
+    this.engine.enterFullScreen();
+  }
+  leaveFullScreen() {
+    this.engine.leaveFullScreen();
+  }
+  showScaleLine() {
+    this.engine.showScaleLine();
+  }
+  hideScaleLine() {
+    this.engine.hideScaleLine();
+  }
+  showZoomControl() {
+    this.engine.showZoomControl();
+  }
+  hideZoomControl() {
+    this.engine.hideZoomControl();
+  }
+  showAttribution() {
+    this.engine.showAttribution();
+  }
+  hideAttribution() {
+    this.engine.hideAttribution();
+  }
+  activateGeolocation(follow) {
+    this.engine.activateGeolocation(follow);
+  }
+  deactivateGeolocation() {
+    this.engine.deactivateGeolocation();
+  }
+  zoomToGeolocation(maxZoom) {
+    return this.engine.zoomToGeolocation(maxZoom);
+  }
+  // Transform coordinates
+  transformCoordsFrom(coord, from, to) {
+    return this.engine.transformCoordsFrom(coord, from, to);
+  }
+  transformCoordsArrayFrom(coords, from, to) {
+    return this.engine.transformCoordsArrayFrom(coords, from, to);
+  }
+  transformExtentFrom(extent, from, to) {
+    return this.engine.transformExtentFrom(extent, from, to);
+  }
+  // Zoom
+  zoomToFeature(layerId, featureId, opts) {
+    return this.engine.zoomToFeature(layerId, featureId, opts);
+  }
+  zoomToLayer(layerId, opts) {
+    return this.engine.zoomToLayer(layerId, opts);
+  }
+  zoomToExtent(extent, opts) {
+    return this.engine.zoomToExtent(extent, opts);
+  }
+  fitGeometry(geom, opts) {
+    return this.engine.fitGeometry(geom, opts);
+  }
+  // Select
+  selectFeature(layerId, featureId, style, coordinates) {
+    return this.engine.selectFeature(layerId, featureId, style, coordinates);
+  }
+  clearSelection() {
+    this.engine.clearSelection();
+  }
+  getSelection() {
+    return this.engine.getSelection();
+  }
+  // Utils
+  getTargetElement() {
+    return this.engine.getTargetElement();
+  }
+  getCenterFromExtent(extent) {
+    return this.engine.getCenterFromExtent(extent);
+  }
+};
+
+// src/api/config.schema.ts
+import { z } from "zod";
+var SourceRefSchema = z.object({ ref: z.string().min(1) });
+var InlineSourceSchema = z.object({
+  type: z.enum(["wmts", "wfs", "osm", "xyz", "geojson"]),
+  options: z.record(z.string(), z.unknown()).optional()
+});
+var MapConfigSchema = z.object({
+  version: z.literal(1),
+  id: z.string().min(1),
+  projection: z.string().default("EPSG:3857"),
+  center: z.tuple([z.number(), z.number()]),
+  zoom: z.number(),
+  minZoom: z.number().optional(),
+  maxZoom: z.number(),
+  size: z.enum(["Large", "Small"]).optional(),
+  tabIndex: z.number().int().optional(),
+  controls: z.object({
+    zoom: z.boolean().optional(),
+    scaleBar: z.boolean().optional(),
+    scaleLine: z.boolean().optional(),
+    geolocation: z.boolean().optional(),
+    attribution: z.boolean().optional(),
+    rotate: z.boolean().optional(),
+    fullscreen: z.boolean().optional(),
+    mousePosition: z.boolean().optional(),
+    draw: z.object({
+      enabled: z.boolean(),
+      polygonType: z.enum(["box", "custom"]).optional()
+    }).optional()
+  }).default({}),
+  wmts: z.array(z.object({
+    id: z.string(),
+    title: z.string().optional(),
+    url: z.string().url(),
+    layer: z.string(),
+    matrixSet: z.string(),
+    format: z.string().optional(),
+    style: z.string().optional(),
+    tileSize: z.number().optional(),
+    origin: z.tuple([z.number(), z.number()]).optional(),
+    resolutions: z.array(z.number()).optional()
+  })).optional(),
+  wfs: z.array(z.object({
+    id: z.string(),
+    title: z.string().optional(),
+    url: z.string().url(),
+    typeName: z.string(),
+    srsName: z.string().optional(),
+    outputFormat: z.string().optional(),
+    strategy: z.enum(["all", "bbox"]).default("bbox").optional(),
+    maxFeatures: z.number().int().optional(),
+    styleId: z.string().optional()
+  })).optional(),
+  layers: z.array(z.object({
+    id: z.string(),
+    kind: z.enum(["tile", "vector", "raster"]),
+    source: z.union([SourceRefSchema, InlineSourceSchema]),
+    // ← key bit
+    style: z.union([
+      z.string(),
+      // style ref id
+      z.object({ type: z.string(), options: z.record(z.string(), z.unknown()).optional() })
+    ]).optional(),
+    visible: z.boolean().optional(),
+    zIndex: z.number().optional(),
+    base: z.boolean().optional()
+  })).optional()
+}).refine((v) => v.minZoom === void 0 || v.minZoom <= v.maxZoom, {
+  path: ["minZoom"],
+  message: "minZoom must be \u2264 maxZoom"
+});
+
+// src/core/registry/SourceRegistry.ts
+var SourceRegistry = class {
+  static registry = /* @__PURE__ */ new Map();
+  static register(id, factory) {
+    this.registry.set(id, factory);
+  }
+  static get(id) {
+    const factory = this.registry.get(id);
+    if (!factory) {
+      throw new Error(`Source '${id}' not found in SourceRegistry`);
+    }
+    return factory();
+  }
+  static clear() {
+    this.registry.clear();
+  }
+};
+
+// src/api/config-loader.ts
+function initMapFromConfig(map, rawJson) {
+  const cfg = MapConfigSchema.parse(rawJson);
+  cfg.wmts?.forEach(
+    (w) => SourceRegistry.register(w.id, () => ({ type: "wmts", options: w }))
+  );
+  cfg.wfs?.forEach(
+    (w) => SourceRegistry.register(w.id, () => ({ type: "wfs", options: w }))
+  );
+  cfg.layers?.forEach((layer) => {
+    const source = "ref" in layer.source ? { ref: layer.source.ref } : (() => {
+      switch (layer.source.type) {
+        case "osm":
+          return { type: "osm" };
+        case "xyz":
+          return { type: "xyz", options: layer.source.options ?? {} };
+        case "wmts":
+          return { type: "wmts", options: layer.source.options ?? {} };
+        case "wfs":
+          return { type: "wfs", options: layer.source.options ?? {} };
+        case "geojson":
+          return { type: "geojson", options: layer.source.options ?? {} };
+        default: {
+          const src = layer.source;
+          const type = typeof src === "object" && src !== null && "type" in src ? src.type : "undefined";
+          throw new Error(`Unknown source type: ${type}`);
+        }
+      }
+    })();
+    const style = typeof layer.style === "string" ? { ref: layer.style } : layer.style;
+    const ld = {
+      id: layer.id,
+      kind: layer.kind,
+      source,
+      style,
+      visible: layer.visible ?? true,
+      zIndex: layer.zIndex,
+      base: layer.base ?? false
+    };
+    map.addLayer(ld);
+  });
+}
+
+// src/factory.ts
+function createMap(target, rawConfig) {
+  const cfg = MapConfigSchema.parse(rawConfig);
+  const map = new MapAPI({
+    target,
+    projection: cfg.projection,
+    center: cfg.center,
+    zoom: cfg.zoom,
+    minZoom: cfg.minZoom,
+    maxZoom: cfg.maxZoom,
+    controls: cfg.controls
+  });
+  initMapFromConfig(map, cfg);
+  return map;
+}
+
+// src/core/geojson/index.ts
+var geojson_exports = {};
+__export(geojson_exports, {
+  sumProperty: () => sumProperty,
+  toFeature: () => toFeature,
+  toFeatureCollection: () => toFeatureCollection
+});
+
+// src/core/geojson/builders.ts
+function isFiniteNumber(n) {
+  return typeof n === "number" && Number.isFinite(n);
+}
+function validLonLat(lon, lat) {
+  return isFiniteNumber(lon) && isFiniteNumber(lat) && lon >= -180 && lon <= 180 && lat >= -90 && lat <= 90;
+}
+function toFeature(item, index, opts) {
+  const skipInvalid = opts.skipInvalid ?? true;
+  let geometry = null;
+  if (opts.kind === "Point") {
+    const p = opts.getPoint(item, index);
+    if (!p || !validLonLat(p.lon, p.lat)) {
+      if (skipInvalid) return null;
+      geometry = { type: "Point", coordinates: [0, 0] };
+    } else {
+      geometry = { type: "Point", coordinates: [p.lon, p.lat] };
+    }
+  } else if (opts.kind === "LineString") {
+    const coords = opts.getLine(item, index);
+    if (!coords || coords.length < 2) {
+      if (skipInvalid) return null;
+      geometry = { type: "LineString", coordinates: [] };
+    } else {
+      geometry = { type: "LineString", coordinates: coords };
+    }
+  } else {
+    const rings = opts.getPolygon(item, index);
+    if (!rings || !rings.length || !rings[0]?.length) {
+      if (skipInvalid) return null;
+      geometry = { type: "Polygon", coordinates: [] };
+    } else {
+      geometry = { type: "Polygon", coordinates: rings };
+    }
+  }
+  const properties = opts.props?.(item, index) ?? {};
+  const f = { type: "Feature", properties, geometry };
+  const id = opts.id?.(item, index);
+  if (id !== void 0) f.id = id;
+  return f;
+}
+function toFeatureCollection(items, opts) {
+  const filterNull = opts.filterNull ?? true;
+  const features = items.map((item, i) => toFeature(item, i, opts)).filter((f) => filterNull ? !!f : true);
+  return { type: "FeatureCollection", features };
+}
+function sumProperty(features, field = "count") {
+  let total = 0;
+  for (const f of features) {
+    const v = f.properties?.[field];
+    const n = Number(v);
+    total += Number.isFinite(n) ? n : 1;
+  }
+  return total;
+}
+
+// src/core/ol/utils/index.ts
+var utils_exports = {};
+__export(utils_exports, {
+  areaFromLonLatRing: () => areaFromLonLatRing,
+  areaToString: () => areaToString,
+  ensureClosedRing: () => ensureClosedRing,
+  getCenterFromExtent: () => getCenterFromExtent,
+  getCenterFromPolygon: () => getCenterFromPolygon,
+  getCentroid: () => getCentroid,
+  getExtentFromPolygon: () => getExtentFromPolygon,
+  isExtentInside: () => isExtentInside,
+  isPointInsideExtent: () => isPointInsideExtent,
+  toDataCoord: () => toDataCoord,
+  toViewCoord: () => toViewCoord,
+  transformCoordsArrayFrom: () => transformCoordsArrayFrom,
+  transformCoordsFrom: () => transformCoordsFrom,
+  transformExtentFrom: () => transformExtentFrom
+});
+
+// src/core/ol/utils/area.ts
+import area from "@turf/area";
+import { Feature as Feature5 } from "ol";
+import { Polygon as Polygon2 } from "ol/geom";
+import { getCenter as getCenter4 } from "ol/extent";
+function ensureClosedRing(ring) {
+  const first = ring[0];
+  const last = ring[ring.length - 1];
+  const isClosed = first[0] === last[0] && first[1] === last[1];
+  return isClosed ? ring : [...ring, first];
+}
+function areaFromLonLatRing(ring) {
+  if (!ring.length) return 0;
+  const coords = ensureClosedRing(ring);
+  const poly = {
+    type: "Feature",
+    properties: {},
+    geometry: {
+      type: "Polygon",
+      coordinates: [coords]
+    }
+  };
+  return area(poly);
+}
+function areaToString(m2) {
+  if (m2 > 1e4) {
+    return Math.round(m2 / 1e6 * 100) / 100 + " km\xB2";
+  } else {
+    return Math.round(m2 * 100) / 100 + " m\xB2";
+  }
+}
+function getCenterFromPolygon(polygonCoordinates) {
+  const closedRing = ensureClosedRing(polygonCoordinates);
+  const polygon = new Feature5({
+    geometry: new Polygon2([closedRing])
+  });
+  if (polygon) {
+    const extent = polygon.getGeometry()?.getExtent();
+    if (extent) {
+      const coordinate = getCenter4(extent);
+      return coordinate;
+    }
+  }
+  return null;
+}
+function getCentroid(coordinates) {
+  if (!coordinates || coordinates.length === 0) {
+    return null;
+  }
+  let sumX = 0;
+  let sumY = 0;
+  for (const point of coordinates) {
+    sumX += point[0];
+    sumY += point[1];
+  }
+  const centroidX = sumX / coordinates.length;
+  const centroidY = sumY / coordinates.length;
+  return [centroidX, centroidY];
+}
+function getExtentFromPolygon(polygonCoordinates) {
+  if (!polygonCoordinates?.length) return null;
+  const closedRing = ensureClosedRing(polygonCoordinates);
+  const polygon = new Feature5({
+    geometry: new Polygon2([closedRing])
+  });
+  return polygon.getGeometry()?.getExtent() ?? null;
+}
+function isExtentInside(inner, outer) {
+  if (inner === void 0 || outer === void 0) return false;
+  if (inner.length !== 4 || outer.length !== 4) return false;
+  return inner[0] >= outer[0] && // minX
+  inner[1] >= outer[1] && // minY
+  inner[2] <= outer[2] && // maxX
+  inner[3] <= outer[3];
+}
+function isPointInsideExtent(coord, extent) {
+  if (coord === void 0 || extent === void 0) return false;
+  if (extent.length !== 4) return false;
+  const [x, y] = coord;
+  return x >= extent[0] && // minX
+  y >= extent[1] && // minY
+  x <= extent[2] && // maxX
+  y <= extent[3];
+}
+
+// src/presets/index.ts
+var presets_exports = {};
+__export(presets_exports, {
+  administrativeEnheterFylke: () => administrativeEnheterFylke,
+  administrativeEnheterKommune: () => administrativeEnheterKommune,
+  janmayenBaseLayer: () => janmayenBaseLayer,
+  nib: () => nib,
+  norwayCoordinate: () => norwayCoordinate,
+  osm: () => osm,
+  svalbardBaseLayer: () => svalbardBaseLayer,
+  topo4graatoneBaseLayer: () => topo4graatoneBaseLayer,
+  topografiskBaseLayer: () => topografiskBaseLayer
+});
+
+// src/presets/layers/base/baseLayers.ts
+var svalbardBaseLayer = {
+  id: "svalbard",
+  kind: "tile",
+  base: "regional",
+  visible: false,
+  opacity: 1,
+  source: {
+    type: "wmts",
+    options: {
+      url: "https://geodata.npolar.no/arcgis/rest/services/Basisdata/NP_Basiskart_Svalbard_WMTS_32633/MapServer/WMTS?",
+      layer: "Basisdata_NP_Basiskart_Svalbard_WMTS_32633",
+      projection: "EPSG:32633",
+      matrixSetId: "default028mm",
+      // critical for ArcGIS service
+      format: "image/jpgpng",
+      style: "default",
+      wrapX: true,
+      // levels: 17,
+      attribution: "\xA9 Kartverket / Norsk Polarinstitutt"
+    }
+  }
+};
+var janmayenBaseLayer = {
+  id: "janmayen",
+  kind: "tile",
+  base: "regional",
+  visible: false,
+  opacity: 1,
+  source: {
+    type: "wmts",
+    options: {
+      url: "https://geodata.npolar.no/arcgis/rest/services/Basisdata/NP_Basiskart_JanMayen_WMTS_25833/MapServer/WMTS?",
+      layer: "NP_Basiskart_JanMayen_WMTS_25833",
+      projection: "EPSG:25833",
+      matrixSetId: "default028mm",
+      // critical for ArcGIS service
+      format: "image/jpgpng",
+      style: "default",
+      // levels: 17,
+      wrapX: true,
+      attribution: "\xA9 Kartverket / Norsk Polarinstitutt"
+    }
+  }
+};
+var topografiskBaseLayer = {
+  id: "topografisk",
+  name: "Topografisk",
+  kind: "tile",
+  base: "regional",
+  visible: true,
+  source: {
+    type: "wmts",
+    options: {
+      url: "https://cache.kartverket.no/v1/service",
+      layer: "topo",
+      format: "image/png",
+      style: "default",
+      matrixSet: "webmercator",
+      //'utm33n',
+      projection: "EPSG:3857",
+      //'EPSG:25833',
+      wrapX: true,
+      opacity: 1,
+      attribution: "Kartverket"
+    }
+  }
+};
+var topo4graatoneBaseLayer = {
+  id: "topo4graatone",
+  name: "Topografisk Gr\xE5tone",
+  kind: "tile",
+  base: "regional",
+  visible: false,
+  source: {
+    type: "wmts",
+    options: {
+      url: "https://cache.kartverket.no/v1/service",
+      layer: "topograatone",
+      format: "image/png",
+      style: "default",
+      matrixSet: "webmercator",
+      //'utm33n',
+      projection: "EPSG:3857",
+      //'EPSG:25833',
+      wrapX: true,
+      opacity: 1,
+      attribution: "Kartverket"
+    }
+  }
+};
+var nib = {
+  id: "nib",
+  name: "Norge i Bilder",
+  kind: "tile",
+  base: "regional",
+  visible: false,
+  source: {
+    type: "wmts",
+    options: {
+      url: "https://tilecache.norgeibilder.no/wmts/webmercator",
+      layer: "Nibcache_web_mercator_v2",
+      format: "image/png",
+      style: "default",
+      matrixSet: "GoogleMapsCompatible",
+      projection: "EPSG:3857",
+      wrapX: true,
+      opacity: 1,
+      attribution: "Kartverket"
+    }
+  }
+};
+var osm = {
+  id: "osm",
+  name: "OSM",
+  kind: "tile",
+  base: "super",
+  visible: true,
+  source: {
+    type: "osm"
+  }
+};
+
+// src/presets/layers/overlay/overlayLayers.ts
+var norwayCoordinate = [10.4, 63.44];
+var administrativeEnheterKommune = {
+  id: "kommune",
+  kind: "vector",
+  visible: true,
+  base: false,
+  source: {
+    type: "wfs",
+    options: {
+      url: "https://wfs.geonorge.no/skwms1/wfs.administrative_enheter",
+      outputFormat: "application/gml+xml; version=3.2",
+      // or 'text/xml; subtype=gml/3.1.1'
+      typeName: "app:Kommune",
+      srsName: "EPSG:3857",
+      minZoomToLoad: 1,
+      strategy: "bbox"
+    }
+  },
+  pickable: false,
+  maxZoom: 14,
+  minZoom: 7,
+  zIndex: -2,
+  zIndexPinned: true,
+  hover: {
+    style: { strokeColor: "transparent", fillColor: "transparent" }
+  },
+  style: { type: "simple", options: { strokeColor: "#6d6099", strokeWidth: 0.5, fillColor: "transparent" } }
+};
+var administrativeEnheterFylke = {
+  id: "fylker",
+  kind: "vector",
+  visible: true,
+  base: false,
+  source: {
+    type: "wfs",
+    options: {
+      url: "https://wfs.geonorge.no/skwms1/wfs.administrative_enheter",
+      outputFormat: "application/gml+xml; version=3.2",
+      // or 'text/xml; subtype=gml/3.1.1'
+      typeName: "app:Fylke",
+      srsName: "EPSG:3857",
+      minZoomToLoad: 1,
+      strategy: "bbox"
+    }
+  },
+  pickable: false,
+  maxZoom: 14,
+  minZoom: 1,
+  zIndex: -1,
+  zIndexPinned: true,
+  hover: {
+    style: { strokeColor: "transparent", fillColor: "transparent" }
+  },
+  style: { type: "simple", options: { strokeColor: "#9e7795", strokeWidth: 1.5, fillColor: "transparent" } }
+};
+
+// src/tokens/nibToken.ts
+var DEFAULT_CONFIG = {
+  tokenUrl: "https://artskart.artsdatabanken.no/appapi/api/token/gettoken2",
+  storageKey: "nbic-map-nib-token",
+  expiryMarginMinutes: 10,
+  retryIntervalMs: 6e4
+};
+function createNibToken(config) {
+  const cfg = { ...DEFAULT_CONFIG, ...config };
+  let currentToken = null;
+  let refreshTimer = null;
+  let isRefreshing = false;
+  let refreshPromise = null;
+  let abortController = null;
+  let initialized = false;
+  const listeners = [];
+  function loadStoredToken() {
+    try {
+      if (typeof localStorage === "undefined") return null;
+      const stored = localStorage.getItem(cfg.storageKey);
+      if (!stored) return null;
+      const parsed = JSON.parse(stored);
+      if (typeof parsed.value === "string" && typeof parsed.expires === "number" && typeof parsed.when === "number") {
+        return parsed;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  function storeToken(token) {
+    try {
+      if (typeof localStorage === "undefined") return;
+      localStorage.setItem(cfg.storageKey, JSON.stringify(token));
+    } catch {
+    }
+  }
+  function isTokenValid(token) {
+    if (!token?.value || !token.expires) return false;
+    const marginMs = cfg.expiryMarginMinutes * 60 * 1e3;
+    return token.expires > Date.now() + marginMs;
+  }
+  async function fetchToken() {
+    abortController = new AbortController();
+    const response = await fetch(cfg.tokenUrl, {
+      method: "GET",
+      headers: {
+        "Accept": "application/json"
+      },
+      signal: abortController.signal
+    });
+    if (!response.ok) {
+      throw new Error(`Token fetch failed: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (!data.TokenValue) {
+      throw new Error("Invalid token response: missing TokenValue");
+    }
+    if (data.ClientId === "Could Not Get Client IP address" || data.TokenValue === "Could Not Get Client IP address") {
+      throw new Error("Server could not determine client IP address for token generation");
+    }
+    return {
+      value: data.TokenValue,
+      expires: new Date(data.ExpireTimestamp).getTime(),
+      when: Date.now()
+    };
+  }
+  function notifyListeners(token) {
+    for (const cb of listeners) {
+      try {
+        cb(token);
+      } catch {
+      }
+    }
+  }
+  function scheduleRefresh() {
+    if (refreshTimer) {
+      clearTimeout(refreshTimer);
+      refreshTimer = null;
+    }
+    if (!currentToken?.expires) return;
+    const marginMs = cfg.expiryMarginMinutes * 60 * 1e3;
+    const refreshIn = Math.max(
+      currentToken.expires - Date.now() - marginMs,
+      cfg.retryIntervalMs
+    );
+    refreshTimer = setTimeout(() => {
+      refreshToken().catch(() => {
+      });
+    }, refreshIn);
+  }
+  async function init() {
+    if (initialized) return;
+    currentToken = loadStoredToken();
+    if (isTokenValid(currentToken)) {
+      initialized = true;
+      scheduleRefresh();
+      return;
+    }
+    try {
+      await refreshToken();
+    } catch {
+    }
+    initialized = true;
+  }
+  function getToken() {
+    return currentToken?.value ?? "";
+  }
+  function getTokenInfo() {
+    return currentToken ? { ...currentToken } : null;
+  }
+  async function refreshToken(force = false) {
+    if (isRefreshing && refreshPromise) {
+      return refreshPromise;
+    }
+    if (!force && currentToken?.when && Date.now() - currentToken.when < cfg.retryIntervalMs) {
+      return currentToken?.value ?? "";
+    }
+    isRefreshing = true;
+    refreshPromise = (async () => {
+      try {
+        const newToken = await fetchToken();
+        currentToken = newToken;
+        storeToken(newToken);
+        notifyListeners(newToken.value);
+        config?.onTokenFetched?.(newToken.value);
+        scheduleRefresh();
+        return newToken.value;
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        config?.onError?.(err);
+        if (currentToken) {
+          scheduleRefresh();
+        }
+        throw err;
+      } finally {
+        isRefreshing = false;
+        refreshPromise = null;
+        abortController = null;
+      }
+    })();
+    return refreshPromise;
+  }
+  function onTokenChange(callback) {
+    listeners.push(callback);
+    return () => {
+      const idx = listeners.indexOf(callback);
+      if (idx >= 0) {
+        listeners.splice(idx, 1);
+      }
+    };
+  }
+  function dispose() {
+    if (refreshTimer) {
+      clearTimeout(refreshTimer);
+      refreshTimer = null;
+    }
+    if (abortController) {
+      abortController.abort();
+      abortController = null;
+    }
+    listeners.length = 0;
+    currentToken = null;
+    refreshPromise = null;
+    isRefreshing = false;
+    initialized = false;
+  }
+  function isInitialized() {
+    return initialized;
+  }
+  return {
+    init,
+    getToken,
+    getTokenInfo,
+    refreshToken,
+    onTokenChange,
+    dispose,
+    isInitialized
+  };
+}
+export {
+  MapEvents,
+  MapAPI as NbicMapComponent,
+  createMap,
+  createNibToken,
+  geojson_exports as nbicMapGeojson,
+  presets_exports as nbicMapPresets,
+  utils_exports as nbicMapUtils
+};