@opendfieldmap/map 0.1.0-alpha.0

package/dist/runtime-ROM65Z24.js

@@ -0,0 +1,1027 @@
+// packages/map/src/runtime.ts
+import L4 from "leaflet";
+import "leaflet.markercluster";
+import {
+  createOEMPointUrl,
+  fetchOEMJson,
+  fromOEMLeafletPosition,
+  getOEMRegion,
+  normalizeOEMLocale,
+  resolveOEMAsset,
+  toOEMLeafletPosition
+} from "@opendfieldmap/core";
+
+// packages/map/src/atlos/smoothTileLayer.ts
+import L from "leaflet";
+var SmoothTileLayer = class extends L.TileLayer {
+  _setZoomTransform(level, center, zoom) {
+    const map = this._map;
+    if (!map)
+      return;
+    const scale = map.getZoomScale(zoom, level.zoom);
+    const translate = level.origin.multiplyBy(scale).subtract(map._getNewPixelOrigin(center, zoom));
+    if (L.Browser.any3d) {
+      L.DomUtil.setTransform(level.el, translate, scale);
+    } else {
+      L.DomUtil.setPosition(level.el, translate);
+    }
+  }
+};
+
+// packages/map/src/atlos/smoothWheelZoom.ts
+import L2 from "leaflet";
+import { WHEEL_GESTURE_IDLE_MS, WheelInputRouter } from "trackpad-input";
+var ZOOM_PER_WHEEL_PIXEL = 3e-3;
+var TRACKPAD_PINCH_ZOOM_PER_PIXEL = 0.01;
+var INERTIA_INITIAL_FACTOR = 0.07;
+var INERTIA_MAX_STEP = 8e-3;
+var INERTIA_FRICTION_PER_FRAME = 0.72;
+var INERTIA_STOP_THRESHOLD = 25e-5;
+var FRAME_DURATION = 1e3 / 60;
+var TRACKPAD_OVERDRAG_MAX_PX = 96;
+var TRACKPAD_OVERDRAG_RESISTANCE = 0.65;
+var TRACKPAD_OVERDRAG_SETTLE_THRESHOLD_PX = 80;
+var TRACKPAD_OVERDRAG_SETTLE_MS = 48;
+var CONTINUOUS_ZOOM_EVENT_DATA = {
+  pinch: true,
+  round: false
+};
+var installSubpixelPixelOrigin = (map) => {
+  map._getNewPixelOrigin = function(center, zoom) {
+    return this.project(center, zoom).subtract(this.getSize().divideBy(2)).add(this._getMapPanePos());
+  };
+  map.latLngToLayerPoint = function(latLng) {
+    return this.project(latLng, this.getZoom()).subtract(this.getPixelOrigin());
+  };
+};
+var SmoothWheelZoom = class {
+  map;
+  container;
+  inertiaEnabled;
+  panEnabled;
+  zoomEnabled;
+  wheelInputRouter;
+  zoomFrame = null;
+  panFrame = null;
+  endTimer = null;
+  panTailTimer = null;
+  targetZoom = null;
+  anchorPoint = null;
+  anchorLatLng = null;
+  zoomVelocity = 0;
+  lastZoomInputTime = null;
+  inertiaStep = 0;
+  lastFrameTime = null;
+  pendingPanOffset = L2.point(0, 0);
+  panRawCenterPoint = null;
+  gestureMode = null;
+  gestureActive = false;
+  trackpadDragging = false;
+  overdragSettling = false;
+  disposed = false;
+  constructor(map, options = {}) {
+    this.map = map;
+    this.container = map.getContainer();
+    this.inertiaEnabled = options.enableInertia ?? true;
+    this.panEnabled = options.panEnabled ?? true;
+    this.zoomEnabled = options.zoomEnabled ?? true;
+    this.wheelInputRouter = new WheelInputRouter({
+      onPan: (event) => this.handleRoutedWheel("pan", event),
+      onZoom: (event) => this.handleRoutedWheel("zoom", event)
+    });
+    installSubpixelPixelOrigin(this.map);
+    map.scrollWheelZoom.disable();
+    this.container.addEventListener("wheel", this.handleWheel, {
+      passive: false
+    });
+    map.once("unload", this.dispose);
+  }
+  dispose = () => {
+    if (this.disposed)
+      return;
+    this.disposed = true;
+    this.container.removeEventListener("wheel", this.handleWheel);
+    this.map.off("unload", this.dispose);
+    this.clearScheduledWork();
+  };
+  handleWheel = (event) => {
+    event.preventDefault();
+    event.stopPropagation();
+    this.finishLeafletZoomAnimation();
+    const gestureMode = this.wheelInputRouter.route(event);
+    if (gestureMode === "pending" && this.overdragSettling) {
+      this.clearOverdragSettlement();
+    }
+  };
+  handleRoutedWheel(gestureMode, event) {
+    if (gestureMode === "pan" && !this.panEnabled || gestureMode === "zoom" && !this.zoomEnabled)
+      return;
+    if (this.overdragSettling && gestureMode === "pan") {
+      this.schedulePanTailRelease();
+      return;
+    }
+    if (this.overdragSettling)
+      this.clearOverdragSettlement();
+    this.routeWheelEvent(gestureMode, event);
+  }
+  routeWheelEvent(gestureMode, event) {
+    if (this.gestureActive && this.gestureMode !== null && this.gestureMode !== gestureMode) {
+      this.finishGesture();
+    }
+    this.gestureMode = gestureMode;
+    if (gestureMode === "pan") {
+      this.handleTrackpadPan(event);
+      return;
+    }
+    this.handleZoom(event);
+  }
+  handleZoom(event) {
+    const wheelDelta = L2.DomEvent.getWheelDelta(event);
+    if (!wheelDelta)
+      return;
+    const zoomDelta = event.ctrlKey && event.deltaMode === 0 ? -event.deltaY * TRACKPAD_PINCH_ZOOM_PER_PIXEL : wheelDelta * ZOOM_PER_WHEEL_PIXEL;
+    const currentTarget = this.targetZoom ?? this.map.getZoom();
+    const nextTarget = this.map._limitZoom(currentTarget + zoomDelta);
+    this.updateAnchor(event);
+    this.targetZoom = nextTarget;
+    if (this.inertiaEnabled) {
+      this.updateZoomVelocity(nextTarget - currentTarget, performance.now());
+      this.inertiaStep = Math.max(-INERTIA_MAX_STEP, Math.min(INERTIA_MAX_STEP, this.zoomVelocity * INERTIA_INITIAL_FACTOR));
+    } else {
+      this.inertiaStep = 0;
+    }
+    if (nextTarget !== this.map.getZoom())
+      this.startGesture(true);
+    if (this.gestureActive && nextTarget !== this.map.getZoom() && this.zoomFrame === null) {
+      this.zoomFrame = requestAnimationFrame(this.applyZoomFrame);
+    }
+    this.scheduleGestureEnd();
+  }
+  handleTrackpadPan(event) {
+    const offset = L2.point(event.deltaX, event.deltaY);
+    if (offset.x === 0 && offset.y === 0) {
+      if (this.gestureActive && !this.overdragSettling) {
+        this.scheduleGestureEnd();
+      }
+      return;
+    }
+    const wasActive = this.gestureActive;
+    this.startGesture(false);
+    if (!wasActive) {
+      this.trackpadDragging = true;
+      this.map.fire("dragstart");
+    }
+    this.pendingPanOffset = this.pendingPanOffset.add(offset);
+    if (this.panFrame === null) {
+      this.panFrame = requestAnimationFrame(this.applyPanFrame);
+    }
+    if (!this.overdragSettling)
+      this.scheduleGestureEnd();
+  }
+  startGesture(zoomChanged) {
+    if (this.gestureActive)
+      return;
+    this.map._stop();
+    this.map._moveStart(zoomChanged, false);
+    this.gestureActive = true;
+  }
+  updateAnchor(event) {
+    const point = this.map.mouseEventToContainerPoint(event);
+    if (this.anchorPoint?.equals(point) && this.anchorLatLng !== null) {
+      return;
+    }
+    this.anchorPoint = point;
+    this.anchorLatLng = this.continuousContainerPointToLatLng(point);
+  }
+  continuousContainerPointToLatLng(point) {
+    const centerPoint = this.map.getSize().divideBy(2);
+    const center = this.map.getCenter();
+    const zoom = this.map.getZoom();
+    return this.map.unproject(this.map.project(center, zoom).add(point.subtract(centerPoint)), zoom);
+  }
+  updateZoomVelocity(delta, timestamp) {
+    if (this.lastZoomInputTime === null || delta * this.zoomVelocity <= 0 || timestamp - this.lastZoomInputTime > WHEEL_GESTURE_IDLE_MS) {
+      this.zoomVelocity = delta;
+    } else {
+      const elapsed = Math.max(8, Math.min(40, timestamp - this.lastZoomInputTime));
+      const frameDelta = delta * (FRAME_DURATION / elapsed);
+      this.zoomVelocity = this.zoomVelocity * 0.65 + frameDelta * 0.35;
+    }
+    this.lastZoomInputTime = timestamp;
+  }
+  applyZoomFrame = (timestamp) => {
+    this.zoomFrame = null;
+    if (!this.gestureActive)
+      return;
+    const elapsed = this.lastFrameTime === null ? FRAME_DURATION : Math.max(8, Math.min(34, timestamp - this.lastFrameTime));
+    this.lastFrameTime = timestamp;
+    const currentZoom = this.map.getZoom();
+    const directTarget = this.targetZoom;
+    let zoom = directTarget ?? currentZoom;
+    this.targetZoom = null;
+    if (this.inertiaEnabled && directTarget === null) {
+      if (Math.abs(this.inertiaStep) < INERTIA_STOP_THRESHOLD) {
+        this.inertiaStep = 0;
+      } else {
+        const zoomBeforeInertia = zoom;
+        zoom = this.map._limitZoom(zoom + this.inertiaStep * (elapsed / FRAME_DURATION));
+        if (zoom === zoomBeforeInertia) {
+          this.inertiaStep = 0;
+        } else {
+          this.inertiaStep *= Math.pow(INERTIA_FRICTION_PER_FRAME, elapsed / FRAME_DURATION);
+        }
+      }
+    }
+    if (zoom !== currentZoom) {
+      this.moveToZoom(zoom);
+    }
+    if (this.targetZoom !== null || this.inertiaEnabled && Math.abs(this.inertiaStep) >= INERTIA_STOP_THRESHOLD) {
+      this.zoomFrame = requestAnimationFrame(this.applyZoomFrame);
+      return;
+    }
+    this.lastFrameTime = null;
+    if (this.endTimer === null) {
+      this.finishGesture();
+    }
+  };
+  applyPanFrame = () => {
+    this.panFrame = null;
+    if (!this.gestureActive || this.gestureMode !== "pan")
+      return;
+    const offset = this.pendingPanOffset;
+    this.pendingPanOffset = L2.point(0, 0);
+    if (offset.x !== 0 || offset.y !== 0) {
+      const overdragAmount = this.applyConstrainedPan(offset);
+      this.map.fire("move").fire("drag");
+      if (overdragAmount >= TRACKPAD_OVERDRAG_SETTLE_THRESHOLD_PX) {
+        this.beginOverdragSettlement();
+      }
+    }
+    if (this.pendingPanOffset.x !== 0 || this.pendingPanOffset.y !== 0) {
+      this.panFrame = requestAnimationFrame(this.applyPanFrame);
+      return;
+    }
+    if (this.endTimer === null) {
+      this.finishGesture();
+    }
+  };
+  applyConstrainedPan(offset) {
+    const zoom = this.map.getZoom();
+    const currentCenterPoint = this.map.project(this.map.getCenter(), zoom);
+    this.panRawCenterPoint ??= currentCenterPoint;
+    this.panRawCenterPoint = this.panRawCenterPoint.add(offset);
+    const configuredBounds = this.map.options.maxBounds;
+    if (!configuredBounds) {
+      this.map._rawPanBy(offset);
+      return 0;
+    }
+    const maxBounds = configuredBounds instanceof L2.LatLngBounds ? configuredBounds : L2.latLngBounds(configuredBounds);
+    const rawCenter = this.map.unproject(this.panRawCenterPoint, zoom);
+    const limitedCenter = this.map._limitCenter(rawCenter, zoom, maxBounds);
+    const limitedCenterPoint = this.map.project(limitedCenter, zoom);
+    const rawOverdrag = this.panRawCenterPoint.subtract(limitedCenterPoint);
+    const visualOverdrag = L2.point(this.resistOverdrag(rawOverdrag.x), this.resistOverdrag(rawOverdrag.y));
+    const visualCenterPoint = limitedCenterPoint.add(visualOverdrag);
+    const visualOffset = visualCenterPoint.subtract(currentCenterPoint);
+    if (visualOffset.x !== 0 || visualOffset.y !== 0) {
+      this.map._rawPanBy(visualOffset);
+    }
+    return Math.max(Math.abs(visualOverdrag.x), Math.abs(visualOverdrag.y));
+  }
+  resistOverdrag(value) {
+    if (value === 0)
+      return 0;
+    const magnitude = TRACKPAD_OVERDRAG_MAX_PX * (1 - Math.exp(-Math.abs(value) * TRACKPAD_OVERDRAG_RESISTANCE / TRACKPAD_OVERDRAG_MAX_PX));
+    return Math.sign(value) * magnitude;
+  }
+  beginOverdragSettlement() {
+    if (this.overdragSettling)
+      return;
+    this.overdragSettling = true;
+    this.schedulePanTailRelease();
+    if (this.endTimer !== null)
+      window.clearTimeout(this.endTimer);
+    this.endTimer = window.setTimeout(this.handleGestureEnd, TRACKPAD_OVERDRAG_SETTLE_MS);
+  }
+  schedulePanTailRelease() {
+    if (this.panTailTimer !== null) {
+      window.clearTimeout(this.panTailTimer);
+    }
+    this.panTailTimer = window.setTimeout(() => {
+      this.panTailTimer = null;
+      this.overdragSettling = false;
+    }, WHEEL_GESTURE_IDLE_MS);
+  }
+  clearOverdragSettlement() {
+    this.overdragSettling = false;
+    if (this.panTailTimer !== null) {
+      window.clearTimeout(this.panTailTimer);
+      this.panTailTimer = null;
+    }
+  }
+  moveToZoom(zoom) {
+    if (this.anchorPoint === null || this.anchorLatLng === null)
+      return;
+    const centerPoint = this.map.getSize().divideBy(2);
+    const cursorOffset = this.anchorPoint.subtract(centerPoint);
+    let center = this.map.unproject(this.map.project(this.anchorLatLng, zoom).subtract(cursorOffset), zoom);
+    const configuredBounds = this.map.options.maxBounds;
+    if (configuredBounds) {
+      const maxBounds = configuredBounds instanceof L2.LatLngBounds ? configuredBounds : L2.latLngBounds(configuredBounds);
+      center = this.map._limitCenter(center, zoom, maxBounds);
+    }
+    this.map._move(center, zoom, CONTINUOUS_ZOOM_EVENT_DATA);
+  }
+  scheduleGestureEnd() {
+    if (this.endTimer !== null) {
+      window.clearTimeout(this.endTimer);
+    }
+    this.endTimer = window.setTimeout(this.handleGestureEnd, WHEEL_GESTURE_IDLE_MS);
+  }
+  handleGestureEnd = () => {
+    this.endTimer = null;
+    if (this.zoomFrame === null && this.panFrame === null && this.targetZoom === null && this.pendingPanOffset.x === 0 && this.pendingPanOffset.y === 0 && (!this.inertiaEnabled || Math.abs(this.inertiaStep) < INERTIA_STOP_THRESHOLD)) {
+      this.finishGesture();
+    }
+  };
+  finishGesture() {
+    if (this.endTimer !== null) {
+      window.clearTimeout(this.endTimer);
+      this.endTimer = null;
+    }
+    if (this.zoomFrame !== null) {
+      cancelAnimationFrame(this.zoomFrame);
+      this.zoomFrame = null;
+    }
+    if (this.panFrame !== null) {
+      cancelAnimationFrame(this.panFrame);
+      this.panFrame = null;
+    }
+    if (!this.gestureActive) {
+      this.resetVisualState();
+      return;
+    }
+    const wasTrackpadDrag = this.trackpadDragging;
+    this.gestureActive = false;
+    this.trackpadDragging = false;
+    if (wasTrackpadDrag)
+      this.map.fire("dragend");
+    this.map._moveEnd(this.gestureMode === "zoom");
+    this.resetVisualState();
+  }
+  finishLeafletZoomAnimation() {
+    if (this.map._animatingZoom) {
+      this.map._onZoomTransitionEnd?.();
+    }
+  }
+  resetVisualState() {
+    this.targetZoom = null;
+    this.anchorPoint = null;
+    this.anchorLatLng = null;
+    this.zoomVelocity = 0;
+    this.lastZoomInputTime = null;
+    this.inertiaStep = 0;
+    this.lastFrameTime = null;
+    this.pendingPanOffset = L2.point(0, 0);
+    this.panRawCenterPoint = null;
+    this.gestureMode = null;
+    this.trackpadDragging = false;
+  }
+  clearScheduledWork() {
+    if (this.zoomFrame !== null) {
+      cancelAnimationFrame(this.zoomFrame);
+      this.zoomFrame = null;
+    }
+    if (this.panFrame !== null) {
+      cancelAnimationFrame(this.panFrame);
+      this.panFrame = null;
+    }
+    if (this.endTimer !== null) {
+      window.clearTimeout(this.endTimer);
+      this.endTimer = null;
+    }
+    this.clearOverdragSettlement();
+    this.gestureActive = false;
+    this.resetVisualState();
+    this.wheelInputRouter.dispose();
+  }
+};
+var enableSmoothWheelZoom = (map, options) => new SmoothWheelZoom(map, options);
+
+// packages/map/src/atlos/mapOverdrag.ts
+import L3 from "leaflet";
+var toMapBounds = (bounds) => {
+  if (!bounds)
+    return null;
+  if (bounds instanceof L3.LatLngBounds)
+    return bounds;
+  return Array.isArray(bounds) && bounds.length === 2 ? L3.latLngBounds(bounds[0], bounds[1]) : null;
+};
+var isMapOverdragged = (map, bounds) => {
+  const constrainedMap = map;
+  const center = map.getCenter();
+  const constrainedCenter = constrainedMap._limitCenter(center, map.getZoom(), bounds);
+  return map.project(center, map.getZoom()).distanceTo(map.project(constrainedCenter, map.getZoom())) > 1;
+};
+
+// packages/map/src/tileVersion.ts
+var lookupOEMTile = (coverage, floor, zoom, x, y) => {
+  const ranges = coverage[String(zoom)]?.[floor.id]?.[String(y)] ?? [];
+  let offset = 0;
+  for (let index = 0; index < ranges.length; index += 2) {
+    const start = ranges[index];
+    const end = ranges[index + 1];
+    if (x >= start && x <= end) {
+      return {
+        covered: true,
+        version: floor.tileVersions?.[String(zoom)]?.[String(y)]?.[offset + x - start]
+      };
+    }
+    offset += end - start + 1;
+  }
+  return { covered: false };
+};
+var appendOEMTileVersion = (url, version) => version ? `${url}${url.includes("?") ? "&" : "?"}v=${encodeURIComponent(version)}` : url;
+
+// packages/map/src/assets/ghicon.svg
+var ghicon_default = '<svg width="83" height="81" viewBox="0 0 83 81" xmlns="http://www.w3.org/2000/svg">\n<path fill-rule="evenodd" clip-rule="evenodd" d="M41.3763 0C18.4963 0 0 18.5625 0 41.5268C0 59.8835 11.8512 75.422 28.292 80.9215C30.3475 81.335 31.1004 80.028 31.1004 78.9286C31.1004 77.9659 31.0327 74.666 31.0327 71.2277C19.5228 73.7032 17.1259 66.2774 17.1259 66.2774C15.2762 61.4647 12.5355 60.2277 12.5355 60.2277C8.76836 57.6838 12.8099 57.6838 12.8099 57.6838C16.9887 57.9589 19.1815 61.9464 19.1815 61.9464C22.8801 68.2712 28.84 66.4841 31.2376 65.3839C31.5798 62.7024 32.6766 60.8462 33.8411 59.8151C24.6612 58.8524 15.0027 55.2774 15.0027 39.3263C15.0027 34.7887 16.6457 31.0762 19.2492 28.1888C18.8385 27.1578 17.3995 22.8943 19.6608 17.188C19.6608 17.188 23.1545 16.0878 31.0318 21.4507C34.4044 20.5417 37.8825 20.0792 41.3763 20.0753C44.87 20.0753 48.4314 20.5571 51.72 21.4507C59.5982 16.0878 63.0919 17.188 63.0919 17.188C65.3532 22.8943 63.9134 27.1578 63.5026 28.1888C66.1747 31.0762 67.75 34.7887 67.75 39.3263C67.75 55.2774 58.0915 58.7832 48.843 59.8151C50.3505 61.1213 51.6514 63.596 51.6514 67.5152C51.6514 73.0839 51.5837 77.5533 51.5837 78.9277C51.5837 80.028 52.3374 81.335 54.3921 80.9224C70.8329 75.4211 82.6841 59.8835 82.6841 41.5268C82.7518 18.5625 64.1878 0 41.3763 0Z"/>\n</svg>\n';
+
+// packages/map/src/runtime.ts
+var mounted = /* @__PURE__ */ new WeakSet();
+var CLUSTER_SUBCATEGORIES = /* @__PURE__ */ new Set(["boss", "collection", "mob", "natural", "valuable", "exploration"]);
+var FEATURE_NAMES = ["points", "labels", "boundaries"];
+var BRAND_URL = "https://oem.re/";
+var GITHUB_URL = "https://github.com/Terra-Online/OEM-SDK";
+var TERMS_URL = "https://blog.opendfieldmap.org/docs/tos#intellectual-property-and-copyright";
+var cloneFilter = (filter) => ({
+  types: filter.types ? [...filter.types] : void 0,
+  subregions: filter.subregions ? [...filter.subregions] : void 0,
+  floorOnly: filter.floorOnly
+});
+var sameList = (left, right) => left === right || !!left && !!right && left.length === right.length && left.every((value, index) => value === right[index]);
+var sameFilter = (left, right) => left.floorOnly === right.floorOnly && sameList(left.types, right.types) && sameList(left.subregions, right.subregions);
+var OEMMarker = class extends L4.Marker {
+  update() {
+    const marker = this;
+    if (marker._icon && marker._map) marker._setPos(marker._map.latLngToLayerPoint(marker._latlng));
+    return this;
+  }
+  _animateZoom(event) {
+    const marker = this;
+    if (marker._map) marker._setPos(marker._map._latLngToNewLayerPoint(marker._latlng, event.zoom, event.center));
+  }
+};
+var CoveredTileLayer = class extends SmoothTileLayer {
+  constructor(url, options, coverage, floor) {
+    super(url, options);
+    this.coverage = coverage;
+    this.floor = floor;
+  }
+  getTileUrl(coords) {
+    const tile = lookupOEMTile(this.coverage, this.floor, coords.z, coords.x, coords.y);
+    return appendOEMTileVersion(super.getTileUrl(coords), tile.version);
+  }
+  _isValidTile(coords) {
+    const prototype = L4.GridLayer.prototype;
+    return prototype._isValidTile.call(this, coords) && lookupOEMTile(this.coverage, this.floor, coords.z, coords.x, coords.y).covered;
+  }
+};
+var OEM = class {
+  constructor(container, manifest, options) {
+    this.container = container;
+    this.manifest = manifest;
+    this.options = options;
+    if (mounted.has(container)) throw new Error("This container already hosts an OEM instance");
+    this.region = getOEMRegion(manifest, options.view?.regionId ?? options.regionId ?? manifest.defaultRegionId);
+    this.filter = cloneFilter(options.pointFilter ?? {});
+    this.markerClustering = options.markerClustering ?? true;
+    const initialFloor = options.view?.floorId ?? options.floorId ?? "M";
+    this.validateFloor(initialFloor);
+    if (options.view) this.validatePosition(options.view);
+    this.locale = options.locale ?? manifest.fallbackLocale;
+    this.resolvedLocale = normalizeOEMLocale(this.locale, Object.keys(manifest.locales), manifest.fallbackLocale);
+    this.root = document.createElement("div");
+    this.root.className = "mapRoot";
+    this.root.dataset.theme = options.theme ?? "light";
+    container.append(this.root);
+    mounted.add(container);
+    this.map = L4.map(this.root, {
+      crs: L4.CRS.Simple,
+      minZoom: 0,
+      maxZoom: 3,
+      zoomControl: false,
+      attributionControl: false,
+      dragging: !options.lockDrag,
+      touchZoom: !options.lockZoom,
+      boxZoom: !options.lockZoom,
+      keyboard: !options.lockZoom,
+      doubleClickZoom: false,
+      scrollWheelZoom: false,
+      zoomAnimation: true,
+      markerZoomAnimation: true,
+      fadeAnimation: true,
+      zoomSnap: 0,
+      zoomDelta: 0.25
+    });
+    this.wheel = enableSmoothWheelZoom(this.map, {
+      enableInertia: true,
+      panEnabled: !options.lockDrag,
+      zoomEnabled: !options.lockZoom
+    });
+    const pane = this.map.createPane("placeLabels");
+    pane.style.zIndex = "650";
+    pane.style.pointerEvents = "none";
+    this.pointsLayer.addTo(this.map);
+    this.labelsLayer.addTo(this.map);
+    this.boundariesLayer.addTo(this.map);
+    const credit = document.createElement("div");
+    credit.className = "attribution";
+    const github = document.createElement("a");
+    github.className = "attributionGithub";
+    github.href = GITHUB_URL;
+    github.target = "_blank";
+    github.rel = "noopener noreferrer";
+    github.setAttribute("aria-label", "GitHub");
+    github.innerHTML = ghicon_default;
+    const githubSvg = github.querySelector("svg");
+    githubSvg?.setAttribute("aria-hidden", "true");
+    githubSvg?.setAttribute("focusable", "false");
+    this.attributionBrand = document.createElement("a");
+    this.attributionBrand.className = "attributionBrand";
+    this.attributionBrand.href = BRAND_URL;
+    const separator = document.createElement("span");
+    separator.className = "attributionSeparator";
+    separator.textContent = "\xB7";
+    separator.setAttribute("aria-hidden", "true");
+    this.attributionLink = document.createElement("a");
+    this.attributionLink.className = "attributionLink";
+    this.attributionLink.href = TERMS_URL;
+    this.attributionLink.target = "_blank";
+    this.attributionLink.rel = "noopener noreferrer";
+    credit.append(github, this.attributionBrand, separator, this.attributionLink);
+    this.updateAttribution();
+    this.root.append(credit);
+    this.applyRegion(options.view);
+    this.setFloor(initialFloor);
+    this.map.on("moveend zoomend", this.emitView);
+    this.map.on("move drag", () => {
+      const bounds = toMapBounds(this.map.options.maxBounds);
+      this.root.classList.toggle("overdrag", !!bounds && isMapOverdragged(this.map, bounds));
+    });
+    this.map.on("moveend dragend zoomstart", () => this.root.classList.remove("overdrag"));
+    if (typeof ResizeObserver !== "undefined") {
+      this.observer = new ResizeObserver(() => this.resize());
+      this.observer.observe(container);
+    }
+    options.signal?.addEventListener("abort", this.destroy, { once: true });
+  }
+  destroyed = false;
+  map;
+  root;
+  region;
+  floorId = "M";
+  features = {};
+  listeners = /* @__PURE__ */ new Map();
+  requests = /* @__PURE__ */ new Map();
+  baseTiles;
+  floorTiles;
+  pointsLayer = L4.layerGroup();
+  pointClusters = /* @__PURE__ */ new Map();
+  labelsLayer = L4.layerGroup();
+  boundariesLayer = L4.layerGroup();
+  points = [];
+  types = {};
+  labels = [];
+  visibleLabelType;
+  messages = {};
+  filter = {};
+  markerClustering;
+  locale;
+  resolvedLocale;
+  attributionBrand;
+  attributionLink;
+  observer;
+  updatingView = false;
+  emittedView;
+  wheel;
+  /** Prevents calls against a released map instance. */
+  assertAlive() {
+    if (this.destroyed) throw new Error("OEM instance has been destroyed");
+  }
+  validateFloor(id) {
+    if (!this.region.floors.some((floor) => floor.id === id)) throw new Error(`Unknown floor ${id} in ${this.region.id}`);
+  }
+  validatePosition(position) {
+    toOEMLeafletPosition(position, this.region);
+  }
+  position(latlng) {
+    return fromOEMLeafletPosition(latlng.lat, latlng.lng, this.region, this.floorId);
+  }
+  emit(event, payload) {
+    this.listeners.get(event)?.forEach((handler) => handler(payload));
+    if (event === "error") this.options.onError?.(payload);
+  }
+  /** Emits one resolved view for duplicate Leaflet move and zoom events. */
+  emitView = () => {
+    if (this.destroyed || this.updatingView) return;
+    const view = this.getView();
+    if (this.emittedView && view.regionId === this.emittedView.regionId && view.floorId === this.emittedView.floorId && view.x === this.emittedView.x && view.y === this.emittedView.y && view.zoom === this.emittedView.zoom) return;
+    this.emittedView = view;
+    this.emit("viewchange", view);
+    this.renderLabels();
+  };
+  /** Resolves the compact attribution without inheriting the map control font. */
+  updateAttribution() {
+    const messages = this.manifest.controls[this.resolvedLocale] ?? this.manifest.controls[this.manifest.fallbackLocale];
+    if (!messages) throw new Error("Missing OEM attribution messages");
+    this.attributionBrand.textContent = messages.brandName;
+    this.attributionLink.textContent = messages.termsOfService;
+  }
+  on(event, handler) {
+    this.assertAlive();
+    const handlers = this.listeners.get(event) ?? /* @__PURE__ */ new Set();
+    handlers.add(handler);
+    this.listeners.set(event, handlers);
+    return () => {
+      handlers.delete(handler);
+    };
+  }
+  /** Rebuilds the base map constraints and main tile layer for one region. */
+  applyRegion(view) {
+    this.updatingView = true;
+    this.baseTiles?.remove();
+    this.floorTiles?.remove();
+    this.floorTiles = void 0;
+    this.floorId = "M";
+    this.map.setMaxBounds(L4.latLngBounds([]));
+    this.map.setMinZoom(this.region.minZoom);
+    this.map.setMaxZoom(this.region.maxZoom);
+    const target = view ?? this.region.initialView;
+    this.map.setView(toOEMLeafletPosition(target, this.region), this.clampZoom(target.zoom), { animate: false });
+    this.map.setMaxBounds(this.regionBounds());
+    this.baseTiles = this.makeTiles("M").addTo(this.map);
+    this.updatingView = false;
+  }
+  /** Converts the region's published pixel extent to Simple CRS bounds. */
+  regionBounds() {
+    const { x, y } = this.region.boundsOffset;
+    return L4.latLngBounds(
+      toOEMLeafletPosition({ regionId: this.region.id, x, y }, this.region),
+      toOEMLeafletPosition({ regionId: this.region.id, x: x + this.region.dimensions[0], y: y + this.region.dimensions[1] }, this.region)
+    );
+  }
+  /** Creates a coverage-aware layer for one region floor. */
+  makeTiles(floorId) {
+    const floor = this.region.floors.find((entry) => entry.id === floorId);
+    const regionId = this.region.id;
+    const layer = new CoveredTileLayer(resolveOEMAsset(this.options.resources.baseUrl, floor.tileTemplate), {
+      tileSize: this.region.tileSize,
+      noWrap: true,
+      bounds: this.regionBounds(),
+      maxNativeZoom: this.region.maxNativeZoom,
+      maxZoom: Math.ceil(this.region.maxZoom)
+    }, this.region.coverage, floor);
+    layer.on("load", () => {
+      if (!this.destroyed && this.region.id === regionId) this.emit("load", { regionId, floorId });
+    });
+    layer.on("tileerror", () => this.emit("error", new Error(`Tile load failed: ${regionId}/${floorId}`)));
+    return layer;
+  }
+  clampZoom(zoom) {
+    if (!Number.isFinite(zoom)) throw new Error("Zoom must be finite");
+    return Math.max(this.region.minZoom, Math.min(this.region.maxZoom, zoom));
+  }
+  /** Returns the current view in the OEM pixel coordinate system. */
+  getView() {
+    this.assertAlive();
+    return { ...this.position(this.map.getCenter()), zoom: this.map.getZoom() };
+  }
+  /** Sets the view without exposing Leaflet's coordinate objects. */
+  setView(view) {
+    this.assertAlive();
+    this.validatePosition(view);
+    const zoom = this.clampZoom(view.zoom);
+    if (view.floorId) this.setFloor(view.floorId);
+    this.map.setView(toOEMLeafletPosition(view, this.region), zoom, { animate: false });
+  }
+  /** Changes zoom around the current center with an optional native transition. */
+  setZoom(zoom, options = {}) {
+    this.assertAlive();
+    this.map.setZoom(this.clampZoom(zoom), { animate: options.animate ?? false });
+  }
+  /** Fits the map to an OEM pixel-coordinate extent. */
+  fitBounds(bounds) {
+    this.assertAlive();
+    this.map.fitBounds(L4.latLngBounds(toOEMLeafletPosition(bounds[0], this.region), toOEMLeafletPosition(bounds[1], this.region)), { animate: false });
+  }
+  /** Switches regions and reloads only the features currently enabled. */
+  async setRegion(regionId) {
+    this.assertAlive();
+    const region = getOEMRegion(this.manifest, regionId);
+    if (region === this.region) return;
+    this.cancelRequests();
+    this.region = region;
+    this.points = [];
+    this.labels = [];
+    this.visibleLabelType = void 0;
+    this.clearPointLayers();
+    this.labelsLayer.clearLayers();
+    this.boundariesLayer.clearLayers();
+    this.applyRegion();
+    this.emit("regionchange", { regionId });
+    this.emit("floorchange", { floorId: "M" });
+    this.emitView();
+    await this.loadFeatures();
+  }
+  /** Switches the rendered floor while retaining the current region view. */
+  setFloor(floorId) {
+    this.assertAlive();
+    this.validateFloor(floorId);
+    if (floorId === this.floorId) return;
+    this.floorTiles?.remove();
+    this.floorTiles = void 0;
+    this.floorId = floorId;
+    const base = this.baseTiles?.getContainer();
+    if (base) base.style.filter = floorId === "M" ? "brightness(1)" : "brightness(0.5)";
+    if (floorId !== "M") this.floorTiles = this.makeTiles(floorId).addTo(this.map);
+    this.renderPoints();
+    this.emit("floorchange", { floorId });
+    this.emitView();
+  }
+  /** Changes label language and applies the manifest fallback chain. */
+  async setLocale(locale) {
+    this.assertAlive();
+    const resolved = normalizeOEMLocale(locale, Object.keys(this.manifest.locales), this.manifest.fallbackLocale);
+    const changed = resolved !== this.resolvedLocale;
+    this.locale = locale;
+    if (!changed) return;
+    this.resolvedLocale = resolved;
+    this.updateAttribution();
+    if (this.features.labels) await this.loadFeature("labels");
+  }
+  /** Returns both the requested and resolved locale values. */
+  getLocale() {
+    return { requested: this.locale, resolved: this.resolvedLocale };
+  }
+  /** Changes only this instance's theme attribute. */
+  setTheme(theme) {
+    this.assertAlive();
+    this.root.dataset.theme = theme;
+  }
+  /** Enables or disables static layers and cancels disabled layer requests. */
+  async setFeatures(features) {
+    this.assertAlive();
+    const loads = [];
+    for (const feature of FEATURE_NAMES) {
+      if (features[feature] === void 0 || features[feature] === this.features[feature]) continue;
+      this.features[feature] = features[feature];
+      this.cancelRequest(feature);
+      if (features[feature]) loads.push(this.loadFeature(feature));
+      else if (feature === "points") {
+        this.points = [];
+        this.clearPointLayers();
+      } else if (feature === "labels") {
+        this.labels = [];
+        this.visibleLabelType = void 0;
+        this.labelsLayer.clearLayers();
+      } else this.boundariesLayer.clearLayers();
+    }
+    await Promise.all(loads);
+  }
+  cancelRequest(feature) {
+    if (!this.requests.has(feature)) return;
+    this.requests.get(feature).abort();
+    this.requests.delete(feature);
+    this.emit("loading", { feature, loading: false });
+  }
+  cancelRequests() {
+    for (const feature of this.requests.keys()) this.cancelRequest(feature);
+  }
+  async loadFeatures() {
+    await Promise.all(FEATURE_NAMES.filter((feature) => this.features[feature]).map((feature) => this.loadFeature(feature)));
+  }
+  /** Loads one feature with a request token so stale responses are ignored. */
+  async loadFeature(feature) {
+    this.cancelRequest(feature);
+    const request = new AbortController();
+    this.requests.set(feature, request);
+    this.emit("loading", { feature, loading: true });
+    const read = (ref) => fetchOEMJson(resolveOEMAsset(this.options.resources.baseUrl, ref.path), request.signal);
+    try {
+      if (feature === "points") {
+        const [groups, types] = await Promise.all([
+          Promise.all(this.region.points.map((ref) => read(ref))),
+          Object.keys(this.types).length ? this.types : read(this.manifest.types)
+        ]);
+        if (request.signal.aborted) return;
+        this.points = groups.flat();
+        this.types = types;
+        this.renderPoints();
+      } else if (feature === "labels") {
+        const [labels, messages] = await Promise.all([
+          this.region.labels ? read(this.region.labels) : Promise.resolve([]),
+          this.manifest.locales[this.resolvedLocale] ? read(this.manifest.locales[this.resolvedLocale]) : Promise.resolve({})
+        ]);
+        if (request.signal.aborted) return;
+        this.labels = labels;
+        this.messages = messages;
+        this.renderLabels(true);
+      } else {
+        const boundaries = this.region.boundaries ? await read(this.region.boundaries) : [];
+        if (request.signal.aborted) return;
+        this.renderBoundaries(boundaries);
+      }
+    } catch (error) {
+      if (!request.signal.aborted) {
+        this.features[feature] = false;
+        this.emit("error", error instanceof Error ? error : new Error(String(error)));
+        throw error;
+      }
+    } finally {
+      if (this.requests.get(feature) === request) {
+        this.requests.delete(feature);
+        this.emit("loading", { feature, loading: false });
+      }
+    }
+  }
+  /** Applies a client-side filter without making another network request. */
+  setPointFilter(filter) {
+    this.assertAlive();
+    const next = cloneFilter(filter);
+    if (sameFilter(this.filter, next)) return;
+    this.filter = next;
+    this.renderPoints();
+  }
+  /** Enables or disables Atlos-style marker clustering without reloading point data. */
+  setMarkerClustering(enabled) {
+    this.assertAlive();
+    if (enabled === this.markerClustering) return;
+    this.markerClustering = enabled;
+    this.renderPoints();
+  }
+  clearPointLayers() {
+    this.pointsLayer.clearLayers();
+    for (const group of this.pointClusters.values()) {
+      group.clearLayers();
+      group.remove();
+    }
+    this.pointClusters.clear();
+  }
+  /** Builds the shared Atlos marker composition for points and cluster summaries. */
+  createMarkerVisual(type, point, count) {
+    const inner = document.createElement(point ? "a" : "div");
+    inner.className = type.noFrame ? "noFrameInner" : "markerInner";
+    if (point) {
+      const link = inner;
+      link.href = createOEMPointUrl(point.id);
+      link.target = "_blank";
+      link.rel = "noopener noreferrer";
+      inner.classList.toggle("offLayer", point.position.floorId !== this.floorId);
+      if (point.tier) inner.dataset.tier = point.position.floorId;
+    }
+    if (count !== void 0) inner.classList.add("clusterMarker");
+    const image = document.createElement("img");
+    image.src = resolveOEMAsset(this.options.resources.baseUrl, type.icon);
+    image.alt = type.key;
+    image.draggable = false;
+    if (type.noFrame) {
+      image.className = "noFrameImage";
+      inner.append(image);
+    } else {
+      const frame = document.createElement("div");
+      frame.className = "frameImage";
+      frame.append(image);
+      inner.append(frame);
+    }
+    if (type.subIcon) {
+      const sub = document.createElement("div");
+      sub.className = "subIconContainer";
+      const subImage = document.createElement("img");
+      subImage.className = "subIcon";
+      subImage.src = resolveOEMAsset(this.options.resources.baseUrl, type.subIcon);
+      subImage.alt = "";
+      sub.append(subImage);
+      inner.append(sub);
+    }
+    if (count !== void 0) {
+      const badge = document.createElement("span");
+      badge.className = "clusterCount";
+      badge.textContent = String(count);
+      inner.append(badge);
+    }
+    return inner;
+  }
+  createPointMarker(point, type) {
+    return new OEMMarker(toOEMLeafletPosition(point.position, this.region), {
+      interactive: true,
+      keyboard: false,
+      bubblingMouseEvents: false,
+      icon: L4.divIcon({
+        html: this.createMarkerVisual(type, point),
+        className: `${type.noFrame ? "noFrameMarkerIcon" : "frameMarkerIcon"} incompleteMarker`,
+        iconSize: type.noFrame ? [50, 50] : [32, 32],
+        iconAnchor: type.noFrame ? [25, 25] : [16, 32]
+      })
+    });
+  }
+  createPointCluster(type) {
+    return L4.markerClusterGroup({
+      showCoverageOnHover: false,
+      zoomToBoundsOnClick: !this.options.lockZoom,
+      spiderfyOnMaxZoom: !this.options.lockZoom,
+      disableClusteringAtZoom: 2,
+      maxClusterRadius: 60,
+      iconCreateFunction: (cluster) => L4.divIcon({
+        html: this.createMarkerVisual(type, void 0, cluster.getChildCount()),
+        className: `${type.noFrame ? "noFrameMarkerIcon" : "frameMarkerIcon"} markerClusterCustom`,
+        iconSize: type.noFrame ? [50, 50] : [32, 32],
+        iconAnchor: type.noFrame ? [25, 25] : [16, 32]
+      })
+    });
+  }
+  /** Rebuilds visible markers and groups eligible types with Atlos clustering rules. */
+  renderPoints() {
+    this.clearPointLayers();
+    const types = this.filter.types ? new Set(this.filter.types) : void 0;
+    const subregions = this.filter.subregions ? new Set(this.filter.subregions) : void 0;
+    for (const point of this.points) {
+      if (types && !types.has(point.type)) continue;
+      if (subregions && !subregions.has(point.subregionId)) continue;
+      if (this.filter.floorOnly && point.position.floorId !== this.floorId) continue;
+      const type = this.types[point.type];
+      if (!type) continue;
+      const marker = this.createPointMarker(point, type);
+      if (this.markerClustering && CLUSTER_SUBCATEGORIES.has(type.category.sub)) {
+        let group = this.pointClusters.get(type.key);
+        if (!group) {
+          group = this.createPointCluster(type);
+          this.pointClusters.set(type.key, group);
+        }
+        group.addLayer(marker);
+      } else marker.addTo(this.pointsLayer);
+    }
+    for (const group of this.pointClusters.values()) if (group.getLayers().length) group.addTo(this.map);
+  }
+  /** Renders Atlos-style fill and dashed stroke layers for published subregions. */
+  renderBoundaries(boundaries) {
+    this.boundariesLayer.clearLayers();
+    for (const boundary of boundaries) {
+      const rings = boundary.rings.map((ring) => ring.map((position) => toOEMLeafletPosition(position, this.region)));
+      L4.polygon(rings, {
+        color: "transparent",
+        fillOpacity: 0.2,
+        interactive: false,
+        className: "subregionBoundaryFill"
+      }).addTo(this.boundariesLayer);
+      L4.polygon(rings, {
+        weight: 2,
+        opacity: 0.8,
+        fill: false,
+        interactive: false,
+        className: "subregionBoundaryStroke"
+      }).addTo(this.boundariesLayer);
+    }
+  }
+  /** Renders Atlos site or subregion labels according to the current zoom. */
+  renderLabels(force = false) {
+    const showSub = this.map.getZoom() <= 0.25 && this.labels.some((label) => label.type === "sub");
+    const visibleType = showSub ? "sub" : "site";
+    if (!force && visibleType === this.visibleLabelType) return;
+    this.visibleLabelType = visibleType;
+    this.labelsLayer.clearLayers();
+    for (const label of this.labels) {
+      if (label.type !== visibleType) continue;
+      const inner = document.createElement("div");
+      inner.className = label.type === "sub" ? "innerSub" : "innerSite";
+      inner.textContent = this.messages[label.textKey] ?? label.id.split("/").at(-1) ?? label.id;
+      new OEMMarker(toOEMLeafletPosition(label.position, this.region), {
+        pane: "placeLabels",
+        interactive: false,
+        keyboard: false,
+        icon: L4.divIcon({ className: "mapLabel", html: inner, iconSize: [0, 0] })
+      }).addTo(this.labelsLayer);
+    }
+  }
+  /** Recalculates Leaflet dimensions after the host element changes size. */
+  resize() {
+    if (!this.destroyed) this.map.invalidateSize({ animate: false });
+  }
+  /** Releases listeners, observers, pending requests, layers and DOM nodes. */
+  destroy = () => {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    this.cancelRequests();
+    this.observer?.disconnect();
+    this.wheel.dispose();
+    this.options.signal?.removeEventListener("abort", this.destroy);
+    this.listeners.clear();
+    this.map.remove();
+    this.root.remove();
+    this.points = [];
+    mounted.delete(this.container);
+  };
+};
+export {
+  OEM
+};
+//# sourceMappingURL=runtime-ROM65Z24.js.map