@osm-editor-kit/street-imagery 0.1.0-alpha.0

package/dist/index.js

@@ -0,0 +1,1815 @@
+import { VectorTile } from '@mapbox/vector-tile';
+import { PbfReader } from 'pbf';
+
+// src/config.ts
+var DEFAULT_PANORAMAX_API_BASE = "https://api.panoramax.xyz";
+var activeConfig = null;
+var createStreetImageryConfig = (input) => ({
+  mapillaryToken: input.mapillaryToken,
+  panoramaxApiBase: (input.panoramaxApiBase ?? DEFAULT_PANORAMAX_API_BASE).replace(/\/$/, "")
+});
+var setStreetImageryConfig = (config) => {
+  activeConfig = config;
+};
+var getStreetImageryConfig = () => {
+  if (!activeConfig) {
+    throw new Error(
+      "Street imagery config is not set. Call setStreetImageryConfig(createStreetImageryConfig(...)) before use."
+    );
+  }
+  return activeConfig;
+};
+
+// src/data/geojson.ts
+var photosToFeatureCollection = (photos) => ({
+  type: "FeatureCollection",
+  features: photos.map((photo) => ({
+    type: "Feature",
+    geometry: {
+      type: "Point",
+      coordinates: photo.lngLat
+    },
+    properties: {
+      providerId: photo.providerId,
+      photoId: photo.photoId,
+      sequenceId: photo.sequenceId,
+      capturedAt: photo.capturedAt,
+      isPano: photo.isPano,
+      heading: photo.heading
+    }
+  }))
+});
+var mapFeaturesToFeatureCollection = (features) => ({
+  type: "FeatureCollection",
+  features: features.map((feature) => ({
+    type: "Feature",
+    geometry: {
+      type: "Point",
+      coordinates: feature.lngLat
+    },
+    properties: {
+      providerId: feature.providerId,
+      featureId: feature.featureId,
+      value: feature.value,
+      firstSeenAt: feature.firstSeenAt,
+      lastSeenAt: feature.lastSeenAt
+    }
+  }))
+});
+var sequencesToFeatureCollection = (sequences) => ({
+  type: "FeatureCollection",
+  features: sequences.map((sequence) => ({
+    type: "Feature",
+    geometry: sequence.geometry,
+    properties: {
+      providerId: sequence.providerId,
+      sequenceId: sequence.sequenceId,
+      capturedAt: sequence.capturedAt,
+      isPano: sequence.isPano
+    }
+  }))
+});
+var emptyPointCollection = () => ({
+  type: "FeatureCollection",
+  features: []
+});
+var emptyLineCollection = () => ({
+  type: "FeatureCollection",
+  features: []
+});
+
+// src/filters/searchFilters.ts
+var DAY_MS = 864e5;
+var parseIsoDateStartMs = (isoDate) => {
+  const [year, month, day] = isoDate.split("-").map(Number);
+  return Date.UTC(year, month - 1, day);
+};
+var parseIsoDateEndMs = (isoDate) => parseIsoDateStartMs(isoDate) + DAY_MS - 1;
+var normalizeDateRange = (date) => {
+  if (!date?.from && !date?.to) {
+    return void 0;
+  }
+  const { from, to } = date;
+  if (from && to && from > to) {
+    return { from: to, to: from };
+  }
+  return date;
+};
+var photoTypesFilter = (photoTypes) => {
+  if (!photoTypes || photoTypes.length === 0) {
+    return void 0;
+  }
+  const unique = [...new Set(photoTypes)];
+  if (unique.length >= 2) {
+    return void 0;
+  }
+  return unique;
+};
+var photoMatchesPhotoTypes = (photo, photoTypes) => {
+  const active = photoTypesFilter(photoTypes);
+  if (!active) {
+    return true;
+  }
+  const [onlyType] = active;
+  if (onlyType === "flat") {
+    return photo.isPano === false;
+  }
+  return photo.isPano === true;
+};
+var photoMatchesDateRange = (photo, date) => {
+  const range = normalizeDateRange(date);
+  if (!range) {
+    return true;
+  }
+  const capturedAt = photo.capturedAt;
+  if (capturedAt == null) {
+    return false;
+  }
+  if (range.from && capturedAt < parseIsoDateStartMs(range.from)) {
+    return false;
+  }
+  if (range.to && capturedAt > parseIsoDateEndMs(range.to)) {
+    return false;
+  }
+  return true;
+};
+var photoMatchesFilters = (photo, photoTypes, date) => photoMatchesPhotoTypes(photo, photoTypes) && photoMatchesDateRange(photo, date);
+var mapFeatureMatchesDateRange = (feature, date) => {
+  const range = normalizeDateRange(date);
+  if (!range) {
+    return true;
+  }
+  if (range.from) {
+    const lastSeenAt = feature.lastSeenAt;
+    if (lastSeenAt == null || lastSeenAt < parseIsoDateStartMs(range.from)) {
+      return false;
+    }
+  }
+  if (range.to) {
+    const firstSeenAt = feature.firstSeenAt;
+    if (firstSeenAt == null || firstSeenAt > parseIsoDateEndMs(range.to)) {
+      return false;
+    }
+  }
+  return true;
+};
+var photoTypeLayerFilter = (photoTypes) => {
+  const active = photoTypesFilter(photoTypes);
+  if (!active) {
+    return null;
+  }
+  const [onlyType] = active;
+  return onlyType === "flat" ? ["==", ["get", "isPano"], false] : ["==", ["get", "isPano"], true];
+};
+var photoDateLayerFilter = (date) => {
+  const range = normalizeDateRange(date);
+  if (!range) {
+    return null;
+  }
+  const clauses = [];
+  if (range.from) {
+    clauses.push([">=", ["get", "capturedAt"], parseIsoDateStartMs(range.from)]);
+  }
+  if (range.to) {
+    clauses.push(["<=", ["get", "capturedAt"], parseIsoDateEndMs(range.to)]);
+  }
+  if (clauses.length === 0) {
+    return null;
+  }
+  return clauses.length === 1 ? clauses[0] : ["all", ...clauses];
+};
+var MATCH_ALL = ["boolean", true];
+var buildPhotoLayerFilter = (photoTypes, date) => {
+  const clauses = [photoTypeLayerFilter(photoTypes), photoDateLayerFilter(date)].filter(
+    (clause) => clause != null
+  );
+  if (clauses.length === 0) {
+    return MATCH_ALL;
+  }
+  return clauses.length === 1 ? clauses[0] : ["all", ...clauses];
+};
+var buildMapFeatureLayerFilter = (date) => {
+  const range = normalizeDateRange(date);
+  if (!range) {
+    return MATCH_ALL;
+  }
+  const clauses = [];
+  if (range.from) {
+    clauses.push([">=", ["get", "lastSeenAt"], parseIsoDateStartMs(range.from)]);
+  }
+  if (range.to) {
+    clauses.push(["<=", ["get", "firstSeenAt"], parseIsoDateEndMs(range.to)]);
+  }
+  if (clauses.length === 0) {
+    return MATCH_ALL;
+  }
+  return clauses.length === 1 ? clauses[0] : ["all", ...clauses];
+};
+
+// src/map/viewCone.ts
+var ARC_SEGMENTS = 24;
+var METERS_PER_DEGREE_LAT = 111320;
+var normalizeBearing = (bearingDeg) => (bearingDeg % 360 + 360) % 360;
+var offsetMeters = (lng, lat, bearingDeg, distanceMeters) => {
+  const bearingRad = bearingDeg * Math.PI / 180;
+  const northMeters = Math.cos(bearingRad) * distanceMeters;
+  const eastMeters = Math.sin(bearingRad) * distanceMeters;
+  const cosLat = Math.cos(lat * Math.PI / 180);
+  const metersPerDegreeLng = METERS_PER_DEGREE_LAT * Math.max(cosLat, 1e-6);
+  return [lng + eastMeters / metersPerDegreeLng, lat + northMeters / METERS_PER_DEGREE_LAT];
+};
+var coneRadiusMeters = (zoom) => 50 * 2 ** (14 - zoom);
+var viewConeGeoJson = (lngLat, bearingDeg, fovDeg, radiusMeters) => {
+  const [lng, lat] = lngLat;
+  const centerBearing = normalizeBearing(bearingDeg);
+  const halfFov = Math.max(fovDeg, 0) / 2;
+  const startBearing = centerBearing - halfFov;
+  const coordinates = [[lng, lat]];
+  for (let index = 0; index <= ARC_SEGMENTS; index += 1) {
+    const segmentBearing = startBearing + index / ARC_SEGMENTS * fovDeg;
+    coordinates.push(offsetMeters(lng, lat, segmentBearing, radiusMeters));
+  }
+  coordinates.push([lng, lat]);
+  return {
+    type: "Feature",
+    properties: {},
+    geometry: {
+      type: "Polygon",
+      coordinates: [coordinates]
+    }
+  };
+};
+
+// src/map/viewfields.ts
+var FLAT_VIEWFIELD_FOV_DEG = 55;
+var PANO_VIEWFIELD_FOV_DEG = 360;
+var METERS_PER_DEGREE_LAT2 = 111320;
+var normalizeBearing2 = (bearingDeg) => (bearingDeg % 360 + 360) % 360;
+var offsetMeters2 = (lng, lat, bearingDeg, distanceMeters) => {
+  const bearingRad = bearingDeg * Math.PI / 180;
+  const northMeters = Math.cos(bearingRad) * distanceMeters;
+  const eastMeters = Math.sin(bearingRad) * distanceMeters;
+  const cosLat = Math.cos(lat * Math.PI / 180);
+  const metersPerDegreeLng = METERS_PER_DEGREE_LAT2 * Math.max(cosLat, 1e-6);
+  return [lng + eastMeters / metersPerDegreeLng, lat + northMeters / METERS_PER_DEGREE_LAT2];
+};
+var flatViewfieldTriangle = (lngLat, bearingDeg, fovDeg, radiusMeters) => {
+  const [lng, lat] = lngLat;
+  const center = normalizeBearing2(bearingDeg);
+  const half = Math.max(fovDeg, 0) / 2;
+  const left = offsetMeters2(lng, lat, center - half, radiusMeters);
+  const right = offsetMeters2(lng, lat, center + half, radiusMeters);
+  return {
+    type: "Feature",
+    properties: {},
+    geometry: {
+      type: "Polygon",
+      coordinates: [[[lng, lat], left, right, [lng, lat]]]
+    }
+  };
+};
+var photosToViewfieldsFeatureCollection = (photos, zoom) => {
+  const radius = coneRadiusMeters(zoom);
+  const features = [];
+  for (const photo of photos) {
+    const isPano = photo.isPano === true;
+    if (!isPano && photo.heading == null) continue;
+    const props = {
+      providerId: photo.providerId,
+      photoId: photo.photoId,
+      sequenceId: photo.sequenceId,
+      capturedAt: photo.capturedAt,
+      isPano: photo.isPano,
+      heading: photo.heading
+    };
+    if (isPano) {
+      const bearing = photo.heading ?? 0;
+      const disk = viewConeGeoJson(photo.lngLat, bearing, PANO_VIEWFIELD_FOV_DEG, radius);
+      features.push({ ...disk, properties: props });
+      continue;
+    }
+    const triangle = flatViewfieldTriangle(
+      photo.lngLat,
+      photo.heading,
+      FLAT_VIEWFIELD_FOV_DEG,
+      radius
+    );
+    features.push({ ...triangle, properties: props });
+  }
+  return { type: "FeatureCollection", features };
+};
+var emptyPolygonCollection = () => ({
+  type: "FeatureCollection",
+  features: []
+});
+
+// src/providers/model.ts
+var PROVIDER_IDS = [
+  "mapillary",
+  "panoramax",
+  "kartaview",
+  "mapilio",
+  "streetside",
+  "vegbilder",
+  "streetview",
+  "lookaround",
+  "mapillary-signs",
+  "mapillary-map-features"
+];
+
+// src/providers/tileCache.ts
+var MAX_RESOLVED_ENTRIES = 200;
+var pendingTiles = /* @__PURE__ */ new Map();
+var resolvedTiles = /* @__PURE__ */ new Map();
+var getTileCacheKey = (providerId, tile) => `${providerId}:${tile.z}:${tile.x}:${tile.y}`;
+var subscribe = (key, entry, signal) => {
+  entry.activeSubscribers += 1;
+  const onAbort = () => {
+    entry.activeSubscribers -= 1;
+    if (entry.activeSubscribers === 0 && !entry.settled) {
+      entry.controller.abort();
+      pendingTiles.delete(key);
+    }
+  };
+  if (signal.aborted) {
+    onAbort();
+  } else {
+    signal.addEventListener("abort", onAbort, { once: true });
+  }
+};
+var touchResolved = (key, value) => {
+  resolvedTiles.delete(key);
+  resolvedTiles.set(key, value);
+  while (resolvedTiles.size > MAX_RESOLVED_ENTRIES) {
+    const oldestKey = resolvedTiles.keys().next().value;
+    if (oldestKey === void 0) {
+      break;
+    }
+    resolvedTiles.delete(oldestKey);
+  }
+};
+var fetchTileCached = async (key, fetcher, signal) => {
+  if (resolvedTiles.has(key)) {
+    const value = resolvedTiles.get(key);
+    touchResolved(key, value);
+    return value;
+  }
+  const existing = pendingTiles.get(key);
+  if (existing) {
+    subscribe(key, existing, signal);
+    return existing.promise;
+  }
+  const controller = new AbortController();
+  const entry = {
+    promise: void 0,
+    controller,
+    activeSubscribers: 0,
+    settled: false
+  };
+  entry.promise = fetcher(controller.signal).then(
+    (value) => {
+      entry.settled = true;
+      if (pendingTiles.get(key) === entry) {
+        pendingTiles.delete(key);
+        touchResolved(key, value);
+      }
+      return value;
+    },
+    (error) => {
+      entry.settled = true;
+      if (pendingTiles.get(key) === entry) {
+        pendingTiles.delete(key);
+      }
+      throw error;
+    }
+  );
+  pendingTiles.set(key, entry);
+  subscribe(key, entry, signal);
+  return entry.promise;
+};
+var collectSettledTiles = async (promises) => {
+  const results = await Promise.allSettled(promises);
+  const fulfilled = results.filter((result) => result.status === "fulfilled").map((result) => result.value);
+  if (results.length > 0 && fulfilled.length === 0) {
+    const firstRejected = results.find(
+      (result) => result.status === "rejected"
+    );
+    throw firstRejected?.reason ?? new Error("All tile fetches failed");
+  }
+  return fulfilled;
+};
+var clearTileCache = () => {
+  pendingTiles.clear();
+  resolvedTiles.clear();
+};
+
+// src/providers/tileMath.ts
+var TILE_SIZE = 256;
+var lonToTileX = (lon, z) => Math.floor((lon + 180) / 360 * 2 ** z);
+var latToTileY = (lat, z) => {
+  const latRad = lat * Math.PI / 180;
+  return Math.floor(
+    (1 - Math.log(Math.tan(latRad) + 1 / Math.cos(latRad)) / Math.PI) / 2 * 2 ** z
+  );
+};
+var tileToLon = (x, z) => x / 2 ** z * 360 - 180;
+var tileToLat = (y, z) => {
+  const n = Math.PI - 2 * Math.PI * y / 2 ** z;
+  return 180 / Math.PI * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n)));
+};
+var tileBbox = (tile) => {
+  const west = tileToLon(tile.x, tile.z);
+  const east = tileToLon(tile.x + 1, tile.z);
+  const north = tileToLat(tile.y, tile.z);
+  const south = tileToLat(tile.y + 1, tile.z);
+  return [west, south, east, north];
+};
+var clampZoom = (zoom, min, max) => Math.min(max, Math.max(min, Math.floor(zoom)));
+var isNullIslandTile = (tile) => {
+  const [west, south, east, north] = tileBbox(tile);
+  const centerLon = (west + east) / 2;
+  const centerLat = (south + north) / 2;
+  return Math.abs(centerLon) < 1 && Math.abs(centerLat) < 1;
+};
+var tilesForBbox = (bbox, z, options) => {
+  const [west, south, east, north] = bbox;
+  const tileCount = 2 ** z;
+  let minX = lonToTileX(west, z);
+  let maxX = lonToTileX(east, z);
+  if (minX > maxX || maxX - minX + 1 >= tileCount) {
+    minX = 0;
+    maxX = tileCount - 1;
+  }
+  const minY = Math.max(0, Math.min(tileCount - 1, latToTileY(north, z)));
+  const maxY = Math.max(0, Math.min(tileCount - 1, latToTileY(south, z)));
+  const tiles = [];
+  for (let x = minX; x <= maxX; x += 1) {
+    const wrappedX = (x % tileCount + tileCount) % tileCount;
+    for (let y = minY; y <= maxY; y += 1) {
+      const tile = { z, x: wrappedX, y };
+      if (options?.skipNullIsland && isNullIslandTile(tile)) {
+        continue;
+      }
+      tiles.push(tile);
+    }
+  }
+  return tiles;
+};
+var bboxIntersects = (a, b) => a[0] <= b[2] && a[2] >= b[0] && a[1] <= b[3] && a[3] >= b[1];
+var tilePixelSizeAtZoom = (zoom) => TILE_SIZE * 2 ** zoom;
+
+// src/providers/adapters/kartaview.ts
+var API_URL = "https://kartaview.org/1.0/list/nearby-photos/";
+var TILE_ZOOM = 14;
+var RESULTS_PER_PAGE = 1e3;
+var kartaviewImageUrl = (imagePath) => {
+  const normalizedPath = imagePath.replace(/^\//, "");
+  const storageMatch = normalizedPath.match(/^storage(\d+)\/(.*)$/);
+  const storageUrl = storageMatch ? `https://storage${storageMatch[1]}.openstreetcam.org/${storageMatch[2]}` : `https://kartaview.org/${normalizedPath}`;
+  return `https://cdn.kartaview.org/pr:sharp/${btoa(storageUrl).replace(/=+$/, "")}`;
+};
+var maxPageAtZoom = (z) => {
+  if (z < 15) {
+    return 2;
+  }
+  if (z === 15) {
+    return 5;
+  }
+  if (z === 16) {
+    return 10;
+  }
+  if (z === 17) {
+    return 20;
+  }
+  if (z === 18) {
+    return 40;
+  }
+  return 80;
+};
+var parseKartaviewDate = (value) => {
+  if (typeof value !== "string" || value.length === 0) {
+    return null;
+  }
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? null : parsed;
+};
+var normalizeKartaviewItem = (item) => {
+  const id = item.id;
+  if (id == null) {
+    return null;
+  }
+  const lng = +(item.lng ?? Number.NaN);
+  const lat = +(item.lat ?? Number.NaN);
+  if (Number.isNaN(lng) || Number.isNaN(lat)) {
+    return null;
+  }
+  const headingRaw = item.heading;
+  const heading = headingRaw == null ? null : typeof headingRaw === "number" ? headingRaw : Number.parseFloat(String(headingRaw));
+  const sequenceIndexRaw = item.sequence_index;
+  const sequenceIndex = sequenceIndexRaw == null ? void 0 : typeof sequenceIndexRaw === "number" ? sequenceIndexRaw : Number.parseInt(String(sequenceIndexRaw), 10);
+  const thumbPath = item.lth_name ?? item.name;
+  const thumbUrl = typeof thumbPath === "string" && thumbPath.length > 0 ? kartaviewImageUrl(thumbPath) : void 0;
+  const fullUrl = typeof item.name === "string" && item.name.length > 0 ? kartaviewImageUrl(item.name) : void 0;
+  return {
+    photoId: String(id),
+    sequenceId: item.sequence_id != null ? String(item.sequence_id) : null,
+    sequenceIndex: sequenceIndex != null && !Number.isNaN(sequenceIndex) ? sequenceIndex : void 0,
+    capturedAt: parseKartaviewDate(item.shot_date ?? item.date_added),
+    isPano: null,
+    heading: heading != null && !Number.isNaN(heading) ? heading : null,
+    lngLat: [lng, lat],
+    thumbUrl,
+    fullUrl
+  };
+};
+var MAX_RADIUS_METERS = 1400;
+var tileCenterAndRadius = (tile) => {
+  const [west, south, east, north] = tileBbox(tile);
+  const lng = (west + east) / 2;
+  const lat = (south + north) / 2;
+  const metersPerDegreeLat = 111320;
+  const halfHeight = (north - south) / 2 * metersPerDegreeLat;
+  const halfWidth = (east - west) / 2 * metersPerDegreeLat * Math.cos(lat * Math.PI / 180);
+  const radius = Math.ceil(Math.hypot(halfWidth, halfHeight));
+  return { lng, lat, radius: Math.min(radius, MAX_RADIUS_METERS) };
+};
+var fetchKartaviewTilePhotos = async (tile, maxPages, signal) => {
+  const [west, south, east, north] = tileBbox(tile);
+  const { lng, lat, radius } = tileCenterAndRadius(tile);
+  const photos = [];
+  for (let page = 1; page <= maxPages; page += 1) {
+    const body = new URLSearchParams({
+      ipp: String(RESULTS_PER_PAGE),
+      page: String(page),
+      coordinate: `${lat},${lng}`,
+      radius: String(radius)
+    });
+    const response = await fetch(API_URL, {
+      method: "POST",
+      signal,
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: body.toString()
+    });
+    if (!response.ok) {
+      break;
+    }
+    const data = await response.json();
+    if (data.status?.httpCode !== 200) {
+      break;
+    }
+    const items = data.currentPageItems ?? [];
+    for (const item of items) {
+      const normalized = normalizeKartaviewItem(item);
+      if (!normalized) {
+        continue;
+      }
+      const [photoLng, photoLat] = normalized.lngLat;
+      if (photoLng < west || photoLng > east || photoLat < south || photoLat > north) {
+        continue;
+      }
+      photos.push({ providerId: "kartaview", ...normalized });
+    }
+    if (items.length < RESULTS_PER_PAGE) {
+      break;
+    }
+  }
+  return photos;
+};
+var fetchKartaviewTile = async (tile, maxPages, signal) => {
+  const key = getTileCacheKey(`kartaview:${maxPages}`, tile);
+  return fetchTileCached(
+    key,
+    (innerSignal) => fetchKartaviewTilePhotos(tile, maxPages, innerSignal),
+    signal
+  );
+};
+var fetchPhotos = async (bbox, zoom, signal) => {
+  const maxPages = Math.min(maxPageAtZoom(zoom), 5);
+  const tiles = tilesForBbox(bbox, TILE_ZOOM, { skipNullIsland: true });
+  const tileResults = await collectSettledTiles(
+    tiles.map((tile) => fetchKartaviewTile(tile, maxPages, signal))
+  );
+  return tileResults.flat();
+};
+var kartaviewAdapter = {
+  id: "kartaview",
+  kind: "photo",
+  label: "KartaView",
+  color: "#2563EB",
+  minZoom: 12,
+  fetchPhotos
+};
+
+// src/providers/adapters/lookaround.ts
+var DEFAULT_LOOK_AROUND_ALTITUDE_M = 50;
+var bytesToBase64 = (bytes) => {
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary);
+};
+var encodeLookAroundMvs = (lat, lng, altitudeMeters = DEFAULT_LOOK_AROUND_ALTITUDE_M) => {
+  const inner = new Uint8Array(27);
+  const view = new DataView(inner.buffer);
+  let offset = 0;
+  for (const [field, value] of [
+    [1, lat],
+    [2, lng],
+    [3, altitudeMeters]
+  ]) {
+    inner[offset] = field << 3 | 1;
+    offset += 1;
+    view.setFloat64(offset, value, true);
+    offset += 8;
+  }
+  const raw = new Uint8Array(2 + inner.length);
+  raw[0] = 10;
+  raw[1] = inner.length;
+  raw.set(inner, 2);
+  return bytesToBase64(raw);
+};
+var lookAroundDeepLink = (lat, lng) => {
+  const params = new URLSearchParams({
+    coordinate: `${lat},${lng}`,
+    _mvs: encodeLookAroundMvs(lat, lng)
+  });
+  return `https://maps.apple.com/look-around?${params.toString()}`;
+};
+var lookaroundAdapter = {
+  id: "lookaround",
+  kind: "photo",
+  label: "Apple Look Around",
+  color: "#007AFF",
+  minZoom: 0,
+  defaultEnabled: false
+};
+var pointLngLat = (feature) => {
+  if (feature.geometry.type !== "Point") {
+    return null;
+  }
+  const [lng, lat] = feature.geometry.coordinates;
+  if (lng === void 0 || lat === void 0) {
+    return null;
+  }
+  return [lng, lat];
+};
+var fetchMvt = async (url, tile, signal) => {
+  const response = await fetch(url, { signal });
+  if (!response.ok) {
+    throw new Error(`MVT fetch failed (${response.status}): ${url}`);
+  }
+  const buffer = await response.arrayBuffer();
+  if (buffer.byteLength === 0) {
+    return {};
+  }
+  const vectorTile = new VectorTile(new PbfReader(buffer));
+  const layers = {};
+  for (const layerName of Object.keys(vectorTile.layers)) {
+    const layer = vectorTile.layers[layerName];
+    if (!layer) {
+      continue;
+    }
+    const features = [];
+    for (let i = 0; i < layer.length; i += 1) {
+      const feature = layer.feature(i);
+      features.push(feature.toGeoJSON(tile.x, tile.y, tile.z));
+    }
+    layers[layerName] = features;
+  }
+  return layers;
+};
+
+// src/providers/adapters/mapilio.ts
+var TILE_ZOOM2 = 14;
+var POINTS_LAYER = "mapilio:map_points";
+var ROADS_LAYER = "mapilio:map_roads_line";
+var wmtsUrl = (layer, tile) => `https://geo.mapilio.com/geoserver/gwc/service/wmts?REQUEST=GetTile&SERVICE=WMTS&VERSION=1.0.0&LAYER=${layer}&STYLE=&TILEMATRIX=EPSG:900913:${tile.z}&TILEMATRIXSET=EPSG:900913&FORMAT=application/vnd.mapbox-vector-tile&TILECOL=${tile.x}&TILEROW=${tile.y}`;
+var parseMapilioCaptureTime = (value) => {
+  if (typeof value !== "string" && typeof value !== "number") {
+    return null;
+  }
+  const parsed = Date.parse(String(value));
+  return Number.isNaN(parsed) ? null : parsed;
+};
+var parseMapilioResolution = (resolution) => {
+  if (typeof resolution !== "string") {
+    return null;
+  }
+  const match = resolution.match(/^(\d+)x(\d+)$/i);
+  if (!match) {
+    return null;
+  }
+  const width = Number(match[1]);
+  const height = Number(match[2]);
+  if (!width || !height) {
+    return null;
+  }
+  const max = Math.max(width, height);
+  const min = Math.min(width, height);
+  return max % min === 0;
+};
+var normalizeMapilioPointFeature = (feature) => {
+  const lngLat = pointLngLat(feature);
+  if (!lngLat) {
+    return null;
+  }
+  const props = feature.properties ?? {};
+  const id = props.id;
+  if (id == null) {
+    return null;
+  }
+  const heading = props.heading == null ? null : typeof props.heading === "number" ? props.heading : Number.parseFloat(String(props.heading));
+  return {
+    photoId: String(id),
+    sequenceId: props.sequence_uuid != null ? String(props.sequence_uuid) : null,
+    capturedAt: parseMapilioCaptureTime(props.capture_time),
+    isPano: parseMapilioResolution(props.resolution),
+    heading: heading != null && !Number.isNaN(heading) ? heading : null,
+    lngLat
+  };
+};
+var geometryKey = (geometry) => JSON.stringify(geometry.coordinates);
+var normalizeMapilioRoadFeature = (feature) => {
+  const props = feature.properties ?? {};
+  const sequenceId = props.sequence_uuid;
+  if (sequenceId == null) {
+    return null;
+  }
+  const { geometry } = feature;
+  if (geometry.type !== "LineString" && geometry.type !== "MultiLineString") {
+    return null;
+  }
+  return {
+    sequenceId: String(sequenceId),
+    geometry,
+    capturedAt: parseMapilioCaptureTime(props.capture_time),
+    isPano: parseMapilioResolution(props.resolution)
+  };
+};
+var fetchMapilioTile = async (layer, tile, signal) => {
+  const cacheLayer = layer === POINTS_LAYER ? "points" : "roads";
+  const key = getTileCacheKey(`mapilio:${cacheLayer}`, tile);
+  return fetchTileCached(
+    key,
+    (innerSignal) => fetchMvt(wmtsUrl(layer, tile), tile, innerSignal),
+    signal
+  );
+};
+var fetchMapilioPointTiles = async (bbox, signal) => {
+  const tiles = tilesForBbox(bbox, TILE_ZOOM2, { skipNullIsland: true });
+  return collectSettledTiles(tiles.map((tile) => fetchMapilioTile(POINTS_LAYER, tile, signal)));
+};
+var fetchPhotos2 = async (bbox, _zoom, signal) => {
+  const tileLayers = await fetchMapilioPointTiles(bbox, signal);
+  const photos = [];
+  for (const layers of tileLayers) {
+    const pointFeatures = layers.map_points ?? [];
+    for (const feature of pointFeatures) {
+      const normalized = normalizeMapilioPointFeature(feature);
+      if (normalized) {
+        photos.push({ providerId: "mapilio", ...normalized });
+      }
+    }
+  }
+  return photos;
+};
+var fetchSequences = async (bbox, _zoom, signal) => {
+  const tiles = tilesForBbox(bbox, TILE_ZOOM2, { skipNullIsland: true });
+  const tileLayers = await collectSettledTiles(
+    tiles.map((tile) => fetchMapilioTile(ROADS_LAYER, tile, signal))
+  );
+  const sequences = [];
+  const seenGeometries = /* @__PURE__ */ new Map();
+  for (const layers of tileLayers) {
+    const roadFeatures = layers.map_roads_line ?? [];
+    for (const feature of roadFeatures) {
+      const normalized = normalizeMapilioRoadFeature(feature);
+      if (!normalized) {
+        continue;
+      }
+      const key = geometryKey(normalized.geometry);
+      const seenForSequence = seenGeometries.get(normalized.sequenceId) ?? /* @__PURE__ */ new Set();
+      if (seenForSequence.has(key)) {
+        continue;
+      }
+      seenForSequence.add(key);
+      seenGeometries.set(normalized.sequenceId, seenForSequence);
+      sequences.push({ providerId: "mapilio", ...normalized });
+    }
+  }
+  return sequences;
+};
+var mapilioAdapter = {
+  id: "mapilio",
+  kind: "photo",
+  label: "Mapilio",
+  color: "#0D9488",
+  minZoom: 14,
+  defaultEnabled: false,
+  browserUnavailableReason: "Mapilio\u2019s tile server (geo.mapilio.com) does not allow browser requests from other sites (CORS). Coverage dots cannot load until Mapilio fixes this upstream.",
+  fetchPhotos: fetchPhotos2,
+  fetchSequences
+};
+
+// src/providers/mapillaryShared.ts
+var MAPILLARY_TILE_ZOOM = 14;
+var mapillaryTileUrl = (path, tile) => {
+  const token = getStreetImageryConfig().mapillaryToken;
+  return `https://tiles.mapillary.com/maps/vtp/${path}/2/${tile.z}/${tile.x}/${tile.y}?access_token=${token}`;
+};
+var fetchMapillaryMvtTiles = async (cachePrefix, path, bbox, signal) => {
+  const tiles = tilesForBbox(bbox, MAPILLARY_TILE_ZOOM, { skipNullIsland: true });
+  return collectSettledTiles(
+    tiles.map((tile) => {
+      const key = getTileCacheKey(cachePrefix, tile);
+      return fetchTileCached(
+        key,
+        (innerSignal) => fetchMvt(mapillaryTileUrl(path, tile), tile, innerSignal),
+        signal
+      );
+    })
+  );
+};
+
+// src/providers/adapters/mapillary.ts
+var MVT_PATH = "mly1_public";
+var normalizeMapillaryImageFeature = (feature) => {
+  const lngLat = pointLngLat(feature);
+  if (!lngLat) {
+    return null;
+  }
+  const props = feature.properties ?? {};
+  const id = props.id;
+  if (id === void 0 || id === null) {
+    return null;
+  }
+  return {
+    photoId: String(id),
+    sequenceId: props.sequence_id != null ? String(props.sequence_id) : null,
+    capturedAt: typeof props.captured_at === "number" ? props.captured_at : null,
+    isPano: typeof props.is_pano === "boolean" ? props.is_pano : null,
+    heading: typeof props.compass_angle === "number" ? props.compass_angle : null,
+    lngLat
+  };
+};
+var normalizeMapillarySequenceFeature = (feature) => {
+  const props = feature.properties ?? {};
+  const id = props.id;
+  if (id == null) {
+    return null;
+  }
+  const { geometry } = feature;
+  if (geometry.type !== "LineString" && geometry.type !== "MultiLineString") {
+    return null;
+  }
+  return {
+    sequenceId: String(id),
+    geometry,
+    capturedAt: typeof props.captured_at === "number" ? props.captured_at : null,
+    isPano: typeof props.is_pano === "boolean" ? props.is_pano : null
+  };
+};
+var fetchMapillaryTiles = async (bbox, signal) => fetchMapillaryMvtTiles("mapillary", MVT_PATH, bbox, signal);
+var fetchPhotos3 = async (bbox, _zoom, signal) => {
+  const tileLayers = await fetchMapillaryTiles(bbox, signal);
+  const photos = [];
+  for (const layers of tileLayers) {
+    const imageFeatures = layers.image ?? [];
+    for (const feature of imageFeatures) {
+      const normalized = normalizeMapillaryImageFeature(feature);
+      if (normalized) {
+        photos.push({ providerId: "mapillary", ...normalized });
+      }
+    }
+  }
+  return photos;
+};
+var fetchSequences2 = async (bbox, _zoom, signal) => {
+  const tileLayers = await fetchMapillaryTiles(bbox, signal);
+  const sequences = [];
+  for (const layers of tileLayers) {
+    const sequenceFeatures = layers.sequence ?? [];
+    for (const feature of sequenceFeatures) {
+      const normalized = normalizeMapillarySequenceFeature(feature);
+      if (normalized) {
+        sequences.push({ providerId: "mapillary", ...normalized });
+      }
+    }
+  }
+  return sequences;
+};
+var mapillaryAdapter = {
+  id: "mapillary",
+  kind: "photo",
+  label: "Mapillary",
+  color: "#05CB63",
+  minZoom: 12,
+  fetchPhotos: fetchPhotos3,
+  fetchSequences: fetchSequences2
+};
+
+// src/providers/adapters/mapillary-map-features.ts
+var MVT_PATH2 = "mly_map_feature_point";
+var LAYER_NAME = "point";
+var normalizeMapillaryMapFeature = (feature) => {
+  const lngLat = pointLngLat(feature);
+  if (!lngLat) {
+    return null;
+  }
+  const props = feature.properties ?? {};
+  const id = props.id;
+  if (id === void 0 || id === null) {
+    return null;
+  }
+  const value = props.value;
+  if (typeof value !== "string" || value.length === 0) {
+    return null;
+  }
+  return {
+    featureId: String(id),
+    value,
+    firstSeenAt: typeof props.first_seen_at === "number" ? props.first_seen_at : null,
+    lastSeenAt: typeof props.last_seen_at === "number" ? props.last_seen_at : null,
+    lngLat
+  };
+};
+var fetchMapFeatures = async (bbox, _zoom, signal) => {
+  const tileLayers = await fetchMapillaryMvtTiles("mapillary-map-features", MVT_PATH2, bbox, signal);
+  const features = [];
+  for (const layers of tileLayers) {
+    const pointFeatures = layers[LAYER_NAME] ?? [];
+    for (const feature of pointFeatures) {
+      const normalized = normalizeMapillaryMapFeature(feature);
+      if (normalized) {
+        features.push({ providerId: "mapillary-map-features", ...normalized });
+      }
+    }
+  }
+  return features;
+};
+var mapillaryMapFeaturesAdapter = {
+  id: "mapillary-map-features",
+  kind: "mapFeature",
+  label: "Mapillary map features",
+  color: "#A855F7",
+  minZoom: 12,
+  fetchMapFeatures
+};
+
+// src/providers/adapters/mapillary-signs.ts
+var MVT_PATH3 = "mly_map_feature_traffic_sign";
+var LAYER_NAME2 = "traffic_sign";
+var normalizeMapillaryTrafficSignFeature = (feature) => {
+  const lngLat = pointLngLat(feature);
+  if (!lngLat) {
+    return null;
+  }
+  const props = feature.properties ?? {};
+  const id = props.id;
+  if (id === void 0 || id === null) {
+    return null;
+  }
+  const value = props.value;
+  if (typeof value !== "string" || value.length === 0) {
+    return null;
+  }
+  return {
+    featureId: String(id),
+    value,
+    firstSeenAt: typeof props.first_seen_at === "number" ? props.first_seen_at : null,
+    lastSeenAt: typeof props.last_seen_at === "number" ? props.last_seen_at : null,
+    lngLat
+  };
+};
+var fetchMapFeatures2 = async (bbox, _zoom, signal) => {
+  const tileLayers = await fetchMapillaryMvtTiles("mapillary-signs", MVT_PATH3, bbox, signal);
+  const features = [];
+  for (const layers of tileLayers) {
+    const signFeatures = layers[LAYER_NAME2] ?? [];
+    for (const feature of signFeatures) {
+      const normalized = normalizeMapillaryTrafficSignFeature(feature);
+      if (normalized) {
+        features.push({ providerId: "mapillary-signs", ...normalized });
+      }
+    }
+  }
+  return features;
+};
+var mapillarySignsAdapter = {
+  id: "mapillary-signs",
+  kind: "mapFeature",
+  label: "Mapillary signs",
+  color: "#E11D48",
+  minZoom: 12,
+  fetchMapFeatures: fetchMapFeatures2
+};
+
+// src/providers/adapters/panoramax.ts
+var PHOTO_TILE_MAX_ZOOM = 15;
+var SEQUENCE_TILE_MIN_ZOOM = 10;
+var SEQUENCE_TILE_MAX_ZOOM = 15;
+var tileUrl = (tile) => {
+  const base = getStreetImageryConfig().panoramaxApiBase;
+  return `${base}/api/map/${tile.z}/${tile.x}/${tile.y}.mvt`;
+};
+var parsePanoramaxTimestamp = (value) => {
+  if (typeof value !== "string" || value.length === 0) {
+    return null;
+  }
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? null : parsed;
+};
+var normalizePanoramaxPictureFeature = (feature) => {
+  const lngLat = pointLngLat(feature);
+  if (!lngLat) {
+    return null;
+  }
+  const props = feature.properties ?? {};
+  const id = props.id;
+  if (id == null) {
+    return null;
+  }
+  const heading = props.heading == null ? null : typeof props.heading === "number" ? props.heading : Number.parseInt(String(props.heading), 10);
+  return {
+    photoId: String(id),
+    sequenceId: props.first_sequence != null ? String(props.first_sequence) : null,
+    capturedAt: parsePanoramaxTimestamp(props.ts),
+    isPano: props.type === "equirectangular",
+    heading: heading != null && !Number.isNaN(heading) ? heading : null,
+    lngLat
+  };
+};
+var normalizePanoramaxSequenceFeature = (feature) => {
+  const props = feature.properties ?? {};
+  const id = props.id;
+  if (id == null) {
+    return null;
+  }
+  const { geometry } = feature;
+  if (geometry.type !== "LineString" && geometry.type !== "MultiLineString") {
+    return null;
+  }
+  return {
+    sequenceId: String(id),
+    geometry,
+    capturedAt: parsePanoramaxTimestamp(props.ts ?? props.datetime ?? props.date),
+    isPano: null
+  };
+};
+var fetchPanoramaxTile = async (tile, signal) => {
+  const key = getTileCacheKey("panoramax", tile);
+  return fetchTileCached(key, (innerSignal) => fetchMvt(tileUrl(tile), tile, innerSignal), signal);
+};
+var fetchPanoramaxTiles = async (bbox, zoom, signal) => {
+  const tileZoom = clampZoom(zoom, SEQUENCE_TILE_MIN_ZOOM, SEQUENCE_TILE_MAX_ZOOM);
+  const tiles = tilesForBbox(bbox, tileZoom);
+  return collectSettledTiles(tiles.map((tile) => fetchPanoramaxTile(tile, signal)));
+};
+var fetchPhotos4 = async (bbox, zoom, signal) => {
+  const tileZoom = clampZoom(zoom, PHOTO_TILE_MAX_ZOOM, PHOTO_TILE_MAX_ZOOM);
+  const tiles = tilesForBbox(bbox, tileZoom);
+  const tileLayers = await collectSettledTiles(
+    tiles.map((tile) => fetchPanoramaxTile(tile, signal))
+  );
+  const photos = [];
+  for (const layers of tileLayers) {
+    const pictureFeatures = layers.pictures ?? [];
+    for (const feature of pictureFeatures) {
+      const normalized = normalizePanoramaxPictureFeature(feature);
+      if (normalized) {
+        photos.push({ providerId: "panoramax", ...normalized });
+      }
+    }
+  }
+  return photos;
+};
+var fetchSequences3 = async (bbox, zoom, signal) => {
+  const tileLayers = await fetchPanoramaxTiles(bbox, zoom, signal);
+  const sequences = [];
+  for (const layers of tileLayers) {
+    const sequenceFeatures = layers.sequences ?? [];
+    for (const feature of sequenceFeatures) {
+      const normalized = normalizePanoramaxSequenceFeature(feature);
+      if (normalized) {
+        sequences.push({ providerId: "panoramax", ...normalized });
+      }
+    }
+  }
+  return sequences;
+};
+var panoramaxAdapter = {
+  id: "panoramax",
+  kind: "photo",
+  label: "Panoramax",
+  color: "#7C3AED",
+  minZoom: 15,
+  sequencesMinZoom: 10,
+  fetchPhotos: fetchPhotos4,
+  fetchSequences: fetchSequences3
+};
+
+// src/providers/adapters/streetside.ts
+var BING_MAPS_KEY = "Auk3J0jR9g1_PVQgdmL95zCOKVOc8g-FGq5Zgb5ik7w1Ri5SRyWILV-kksgbw-Gh";
+var STREETSIDE_API = "https://dev.virtualearth.net/REST/v1/Imagery/MetaData/Streetside";
+var TILE_ZOOM3 = 16;
+var MAX_RESULTS = 500;
+var DEFAULT_SUBDOMAINS = ["t0", "t1", "t2", "t3"];
+var parseStreetsideDate = (value) => {
+  if (typeof value !== "string" || value.length === 0) {
+    return null;
+  }
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? null : parsed;
+};
+var normalizeStreetsideBubble = (bubble) => {
+  const lng = +(bubble.lon ?? bubble.longitude ?? Number.NaN);
+  const lat = +(bubble.lat ?? bubble.latitude ?? Number.NaN);
+  if (Number.isNaN(lng) || Number.isNaN(lat)) {
+    return null;
+  }
+  const photoId = bubble.id ?? bubble.imageUrl;
+  if (!photoId) {
+    return null;
+  }
+  const headingRaw = bubble.he ?? bubble.heading;
+  const heading = headingRaw == null ? null : +headingRaw;
+  return {
+    photoId,
+    sequenceId: null,
+    capturedAt: parseStreetsideDate(bubble.vintageEnd),
+    isPano: true,
+    heading: heading != null && !Number.isNaN(heading) ? heading : null,
+    lngLat: [lng, lat],
+    thumbUrl: bubble.imageUrl,
+    streetside: bubble.imageUrl ? {
+      urlTemplate: bubble.imageUrl,
+      subdomains: bubble.imageUrlSubdomains && bubble.imageUrlSubdomains.length > 0 ? bubble.imageUrlSubdomains : DEFAULT_SUBDOMAINS
+    } : void 0
+  };
+};
+var fetchStreetsideTilePhotos = async (tile, signal) => {
+  const [west, south, east, north] = tileBbox(tile);
+  const mapArea = `${south},${west},${north},${east}`;
+  const url = new URL(STREETSIDE_API);
+  url.searchParams.set("mapArea", mapArea);
+  url.searchParams.set("key", BING_MAPS_KEY);
+  url.searchParams.set("count", String(MAX_RESULTS));
+  url.searchParams.set("uriScheme", "https");
+  const response = await fetch(url, { signal });
+  if (!response.ok) {
+    throw new Error(`Streetside fetch failed (${response.status})`);
+  }
+  const data = await response.json();
+  const bubbles = data.resourceSets?.[0]?.resources ?? [];
+  const photos = [];
+  for (const bubble of bubbles) {
+    const normalized = normalizeStreetsideBubble(bubble);
+    if (normalized) {
+      photos.push({ providerId: "streetside", ...normalized });
+    }
+  }
+  return photos;
+};
+var fetchStreetsideTile = async (tile, signal) => {
+  const key = getTileCacheKey("streetside", tile);
+  return fetchTileCached(key, (innerSignal) => fetchStreetsideTilePhotos(tile, innerSignal), signal);
+};
+var fetchPhotos5 = async (bbox, _zoom, signal) => {
+  const tiles = tilesForBbox(bbox, TILE_ZOOM3, { skipNullIsland: true });
+  const tileResults = await collectSettledTiles(
+    tiles.map((tile) => fetchStreetsideTile(tile, signal))
+  );
+  const byId = /* @__PURE__ */ new Map();
+  for (const photos of tileResults) {
+    for (const photo of photos) {
+      byId.set(photo.photoId, photo);
+    }
+  }
+  return [...byId.values()];
+};
+var streetsideAdapter = {
+  id: "streetside",
+  kind: "photo",
+  label: "Bing Streetside",
+  color: "#0891B2",
+  minZoom: 14,
+  fetchPhotos: fetchPhotos5
+};
+
+// src/providers/adapters/streetview.ts
+var STREET_VIEW_METADATA_API = "https://maps.googleapis.com/maps/api/streetview/metadata";
+var getGoogleMapsApiKey = () => {
+  const env = import.meta.env;
+  const key = env?.VITE_GOOGLE_MAPS_API_KEY;
+  return typeof key === "string" && key.length > 0 ? key : void 0;
+};
+var parseStreetViewDate = (value) => {
+  if (typeof value !== "string" || value.length === 0) {
+    return null;
+  }
+  const normalized = /^\d{4}-\d{2}$/.test(value) ? `${value}-01` : value;
+  const parsed = Date.parse(normalized);
+  return Number.isNaN(parsed) ? null : parsed;
+};
+var normalizeStreetViewMetadata = (data, clickLng, clickLat) => {
+  if (data.status !== "OK") {
+    return null;
+  }
+  const lng = data.location?.lng ?? clickLng;
+  const lat = data.location?.lat ?? clickLat;
+  const photoId = data.pano_id ?? `${lat},${lng}`;
+  return {
+    photoId,
+    sequenceId: null,
+    capturedAt: parseStreetViewDate(data.date),
+    isPano: true,
+    heading: null,
+    lngLat: [lng, lat]
+  };
+};
+var fetchStreetViewMetadata = async (lat, lng, signal) => {
+  const apiKey = getGoogleMapsApiKey();
+  if (!apiKey) {
+    return null;
+  }
+  const url = new URL(STREET_VIEW_METADATA_API);
+  url.searchParams.set("location", `${lat},${lng}`);
+  url.searchParams.set("key", apiKey);
+  const response = await fetch(url, { signal });
+  if (!response.ok) {
+    throw new Error(`Google Street View metadata failed (${response.status})`);
+  }
+  const data = await response.json();
+  if (data.status === "ZERO_RESULTS") {
+    return null;
+  }
+  if (data.status !== "OK") {
+    throw new Error(`Google Street View metadata: ${data.status}`);
+  }
+  const normalized = normalizeStreetViewMetadata(data, lng, lat);
+  if (!normalized) {
+    throw new Error("Google Street View metadata: unexpected empty OK response");
+  }
+  return { providerId: "streetview", ...normalized };
+};
+var streetViewAdapter = {
+  id: "streetview",
+  kind: "photo",
+  label: "Google Street View",
+  color: "#EA4335",
+  minZoom: 0,
+  defaultEnabled: false
+};
+
+// src/providers/adapters/vegbilder.ts
+var TILE_ZOOM4 = 14;
+var OWS_BASE = "https://www.vegvesen.no/kart/ogc/vegbilder_1_0/ows";
+var CAPABILITIES_URL = `${OWS_BASE}?service=WFS&request=GetCapabilities&version=2.0.0`;
+var NORWAY_BBOX = [4, 57, 32, 72];
+var LAYER_NAME_REGEX = /vegbilder_1_0:Vegbilder(_360)?_(\d{4})/g;
+var parseVegbilderLayerNames = (capabilitiesXml) => {
+  const layers = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const match of capabilitiesXml.matchAll(LAYER_NAME_REGEX)) {
+    const name = match[0];
+    if (seen.has(name)) {
+      continue;
+    }
+    seen.add(name);
+    layers.push({
+      name,
+      is360: match[1] === "_360",
+      year: Number(match[2])
+    });
+  }
+  return layers;
+};
+var selectVegbilderLayers = (layers, minYear = 2020, maxLayers = 8) => layers.filter((layer) => layer.year >= minYear).sort((a, b) => b.year - a.year || Number(a.is360) - Number(b.is360)).slice(0, maxLayers).map((layer) => layer.name);
+var parseVegbilderTimestamp = (value) => {
+  if (typeof value !== "string" && typeof value !== "number") {
+    return null;
+  }
+  const parsed = Date.parse(String(value));
+  return Number.isNaN(parsed) ? null : parsed;
+};
+var buildVegbilderSequenceId = (props) => {
+  const fylke = props.FYLKENUMMER;
+  const category = props.VEGKATEGORI;
+  const number = props.VEGNUMMER;
+  if (typeof fylke !== "string" && typeof fylke !== "number" || typeof category !== "string" || typeof number !== "string" && typeof number !== "number") {
+    return null;
+  }
+  return `${fylke}-${category}-${number}`;
+};
+var normalizeVegbilderFeature = (feature, layerYear) => {
+  const lngLat = pointLngLat(feature);
+  if (!lngLat) {
+    return null;
+  }
+  const id = feature.id;
+  if (id == null) {
+    return null;
+  }
+  const props = feature.properties ?? {};
+  const heading = props.RETNING == null ? null : typeof props.RETNING === "number" ? props.RETNING : Number.parseFloat(String(props.RETNING));
+  const previewPath = props.URLPREVIEW;
+  const thumbUrl = typeof previewPath === "string" && previewPath.length > 0 ? previewPath : void 0;
+  const fullPath = props.URL;
+  const fullUrl = typeof fullPath === "string" && fullPath.length > 0 ? fullPath : void 0;
+  const yearFromTimestamp = (() => {
+    const capturedAt = parseVegbilderTimestamp(props.TIDSPUNKT);
+    return capturedAt != null ? new Date(capturedAt).getUTCFullYear() : void 0;
+  })();
+  return {
+    photoId: String(id),
+    sequenceId: buildVegbilderSequenceId(props),
+    capturedAt: parseVegbilderTimestamp(props.TIDSPUNKT),
+    isPano: props.BILDETYPE === "360",
+    heading: heading != null && !Number.isNaN(heading) ? heading : null,
+    lngLat,
+    thumbUrl,
+    fullUrl,
+    viewerYear: layerYear ?? yearFromTimestamp
+  };
+};
+var intersectsNorway = (bbox) => bboxIntersects(bbox, NORWAY_BBOX);
+var capabilitiesPromise = null;
+var loadCapabilities = (signal) => {
+  if (!capabilitiesPromise) {
+    capabilitiesPromise = (async () => {
+      const response = await fetch(CAPABILITIES_URL, { signal });
+      if (!response.ok) {
+        throw new Error(`Vegbilder capabilities failed (${response.status})`);
+      }
+      return parseVegbilderLayerNames(await response.text());
+    })().catch((error) => {
+      capabilitiesPromise = null;
+      throw error;
+    });
+  }
+  return capabilitiesPromise;
+};
+var wfsFeatureUrl = (layer, bbox) => {
+  const [west, south, east, north] = bbox;
+  const params = new URLSearchParams({
+    service: "WFS",
+    request: "GetFeature",
+    version: "2.0.0",
+    typenames: layer,
+    bbox: `${south},${west},${north},${east}`,
+    outputFormat: "json"
+  });
+  return `${OWS_BASE}?${params.toString()}`;
+};
+var fetchWfsLayer = async (layer, bbox, signal) => {
+  const response = await fetch(wfsFeatureUrl(layer, bbox), { signal });
+  if (!response.ok) {
+    throw new Error(`Vegbilder WFS failed (${response.status}): ${layer}`);
+  }
+  const data = await response.json();
+  return data.features ?? [];
+};
+var fetchVegbilderTile = async (tile, layers, signal) => {
+  const key = getTileCacheKey("vegbilder", tile);
+  return fetchTileCached(
+    key,
+    async (innerSignal) => {
+      const bbox = tileBbox(tile);
+      return Promise.all(
+        layers.map(async (layer) => ({
+          layer: layer.name,
+          year: layer.year,
+          features: await fetchWfsLayer(layer.name, bbox, innerSignal)
+        }))
+      );
+    },
+    signal
+  );
+};
+var fetchPhotos6 = async (bbox, _zoom, signal) => {
+  if (!intersectsNorway(bbox)) {
+    return [];
+  }
+  const allLayers = await loadCapabilities(signal);
+  const selectedLayerNames = selectVegbilderLayers(allLayers);
+  const layers = allLayers.filter((layer) => selectedLayerNames.includes(layer.name));
+  if (layers.length === 0) {
+    return [];
+  }
+  const tiles = tilesForBbox(bbox, TILE_ZOOM4);
+  const tileFeatures = await collectSettledTiles(
+    tiles.map((tile) => fetchVegbilderTile(tile, layers, signal))
+  );
+  const photos = [];
+  for (const tileLayers of tileFeatures) {
+    for (const { features, year } of tileLayers) {
+      for (const feature of features) {
+        const normalized = normalizeVegbilderFeature(feature, year);
+        if (normalized) {
+          photos.push({ providerId: "vegbilder", ...normalized });
+        }
+      }
+    }
+  }
+  return photos;
+};
+var vegbilderAdapter = {
+  id: "vegbilder",
+  kind: "photo",
+  label: "Vegbilder",
+  color: "#EA580C",
+  minZoom: 14,
+  fetchPhotos: fetchPhotos6
+};
+
+// src/providers/registry.ts
+var PROVIDER_HOMEPAGE_URLS = {
+  mapillary: "https://www.mapillary.com",
+  panoramax: "https://panoramax.xyz",
+  kartaview: "https://kartaview.org",
+  mapilio: "https://mapilio.com",
+  streetside: "https://www.bing.com/maps",
+  vegbilder: "https://vegbilder.atlas.vegvesen.no",
+  streetview: "https://www.google.com/maps",
+  lookaround: "https://www.apple.com/maps/",
+  "mapillary-signs": "https://www.mapillary.com",
+  "mapillary-map-features": "https://www.mapillary.com"
+};
+var PROVIDER_ADAPTERS = [
+  mapillaryAdapter,
+  panoramaxAdapter,
+  kartaviewAdapter,
+  mapilioAdapter,
+  streetsideAdapter,
+  vegbilderAdapter,
+  streetViewAdapter,
+  lookaroundAdapter,
+  mapillarySignsAdapter,
+  mapillaryMapFeaturesAdapter
+];
+var adapterById = Object.fromEntries(
+  PROVIDER_ADAPTERS.map((adapter) => [adapter.id, adapter])
+);
+var PROVIDERS = PROVIDER_ADAPTERS.map((adapter) => ({
+  id: adapter.id,
+  kind: adapter.kind,
+  label: adapter.label,
+  color: adapter.color,
+  minZoom: adapter.minZoom,
+  sequencesMinZoom: adapter.sequencesMinZoom ?? adapter.minZoom,
+  homepageUrl: PROVIDER_HOMEPAGE_URLS[adapter.id],
+  browserUnavailableReason: adapter.browserUnavailableReason
+}));
+var DEFAULT_PROVIDER_IDS = PROVIDER_IDS.filter(
+  (id) => adapterById[id].kind === "photo" && adapterById[id].defaultEnabled !== false
+);
+var isClickOnlyPhotoProvider = (providerId) => {
+  const adapter = adapterById[providerId];
+  return adapter.kind === "photo" && adapter.fetchPhotos == null;
+};
+var isBrowserAvailableProvider = (providerId) => adapterById[providerId].browserUnavailableReason == null;
+var providerById = Object.fromEntries(
+  PROVIDERS.map((provider) => [provider.id, provider])
+);
+var photoLayerId = (providerId) => `photos-${providerId}`;
+var featureLayerId = (providerId) => `features-${providerId}`;
+var sequenceLayerId = (providerId) => `sequences-${providerId}`;
+var viewfieldLayerId = (providerId) => `viewfields-${providerId}`;
+var viewfieldLineLayerId = (providerId) => `viewfields-line-${providerId}`;
+var photoSourceId = (providerId) => `photos-source-${providerId}`;
+var featureSourceId = (providerId) => `features-source-${providerId}`;
+var sequenceSourceId = (providerId) => `sequences-source-${providerId}`;
+var viewfieldSourceId = (providerId) => `viewfields-source-${providerId}`;
+var isPhotoProviderId = (providerId) => adapterById[providerId].kind === "photo";
+var isMapFeatureProviderId = (providerId) => adapterById[providerId].kind === "mapFeature";
+
+// src/viewer/clickRadius.ts
+var EARTH_RADIUS_METERS = 6371e3;
+var haversineDistanceMeters = (lng1, lat1, lng2, lat2) => {
+  const toRadians = (degrees) => degrees * Math.PI / 180;
+  const dLat = toRadians(lat2 - lat1);
+  const dLng = toRadians(lng2 - lng1);
+  const lat1Rad = toRadians(lat1);
+  const lat2Rad = toRadians(lat2);
+  const a = Math.sin(dLat / 2) ** 2 + Math.cos(lat1Rad) * Math.cos(lat2Rad) * Math.sin(dLng / 2) ** 2;
+  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+  return EARTH_RADIUS_METERS * c;
+};
+var clickRadiusMeters = (zoom) => 50 * 2 ** (14 - zoom);
+
+// src/viewer/externalLinks.ts
+var providerExternalLink = (photo) => {
+  const [lng, lat] = photo.lngLat;
+  switch (photo.providerId) {
+    case "mapillary":
+      return `https://www.mapillary.com/app/?pKey=${encodeURIComponent(photo.photoId)}&focus=photo`;
+    case "panoramax":
+      return `${getStreetImageryConfig().panoramaxApiBase}/#pic=${encodeURIComponent(photo.photoId)}&focus=pic`;
+    case "kartaview":
+      if (photo.sequenceId != null && photo.sequenceIndex != null) {
+        return `https://kartaview.org/details/${encodeURIComponent(photo.sequenceId)}/${photo.sequenceIndex}`;
+      }
+      return `https://kartaview.org/photo/${encodeURIComponent(photo.photoId)}`;
+    case "mapilio":
+      return `https://mapilio.com/app?lat=${lat}&lng=${lng}&zoom=17&pId=${encodeURIComponent(photo.photoId)}`;
+    case "streetside":
+      return `https://www.bing.com/maps?cp=${lat}~${lng}&lvl=18&style=x`;
+    case "streetview":
+      return `https://www.google.com/maps/@?api=1&map_action=pano&viewpoint=${lat},${lng}`;
+    case "lookaround":
+      return lookAroundDeepLink(lat, lng);
+    case "vegbilder": {
+      const year = photo.viewerYear ?? new Date(photo.capturedAt ?? Date.now()).getUTCFullYear();
+      return `https://vegbilder.atlas.vegvesen.no/?year=${year}&lat=${lat}&lng=${lng}&view=image&imageId=${encodeURIComponent(photo.photoId)}`;
+    }
+    case "mapillary-map-features":
+    case "mapillary-signs":
+    default:
+      return "#";
+  }
+};
+var mapFeatureExternalLink = (feature) => {
+  const [lng, lat] = feature.lngLat;
+  return `https://www.mapillary.com/app/?lat=${lat}&lng=${lng}&z=17&focus=map`;
+};
+var providerLocationLink = (providerId, lat, lng, zoom = 14) => {
+  switch (providerId) {
+    case "mapillary":
+    case "mapillary-signs":
+    case "mapillary-map-features":
+      return `https://www.mapillary.com/app/?lat=${lat}&lng=${lng}&z=17&focus=map`;
+    case "panoramax":
+      return `${getStreetImageryConfig().panoramaxApiBase}/?focus=map&map=${zoom}/${lat}/${lng}`;
+    case "kartaview":
+      return `https://kartaview.org/map/@${lat},${lng},${zoom}z`;
+    case "mapilio":
+      return `https://mapilio.com/app?lat=${lat}&lng=${lng}&zoom=17`;
+    case "streetside":
+      return `https://www.bing.com/maps?cp=${lat}~${lng}&lvl=18&style=x`;
+    case "streetview":
+      return `https://www.google.com/maps/@?api=1&map_action=pano&viewpoint=${lat},${lng}`;
+    case "lookaround":
+      return lookAroundDeepLink(lat, lng);
+    case "vegbilder": {
+      const year = (/* @__PURE__ */ new Date()).getUTCFullYear();
+      return `https://vegbilder.atlas.vegvesen.no/?year=${year}&lat=${lat}&lng=${lng}`;
+    }
+  }
+};
+
+// src/viewer/groupClickedPhotos.ts
+var sequenceGroupKey = (providerId, sequenceId) => `${providerId}:${sequenceId}`;
+var photoGroupSequenceId = (photo) => photo.sequenceId ?? `photo:${photo.photoId}`;
+var distanceToPhoto = (photo, lng, lat) => haversineDistanceMeters(lng, lat, photo.lngLat[0], photo.lngLat[1]);
+var findNearestPhoto = (photos, lng, lat) => {
+  if (photos.length === 0) {
+    return null;
+  }
+  const first = photos[0];
+  if (!first) {
+    return null;
+  }
+  let nearest = first;
+  let nearestDistance = distanceToPhoto(first, lng, lat);
+  for (let index = 1; index < photos.length; index += 1) {
+    const photo = photos[index];
+    if (!photo) {
+      continue;
+    }
+    const distance = distanceToPhoto(photo, lng, lat);
+    if (distance < nearestDistance) {
+      nearest = photo;
+      nearestDistance = distance;
+    }
+  }
+  return nearest;
+};
+var compareCapturedAt = (left, right) => {
+  const leftTime = left.capturedAt ?? Number.POSITIVE_INFINITY;
+  const rightTime = right.capturedAt ?? Number.POSITIVE_INFINITY;
+  if (leftTime !== rightTime) {
+    return leftTime - rightTime;
+  }
+  return left.photoId.localeCompare(right.photoId);
+};
+var dedupeNearbyPhotos = (photos, minDistanceMeters = 5) => {
+  const sorted = [...photos].sort(compareCapturedAt);
+  const kept = [];
+  for (const photo of sorted) {
+    const tooClose = kept.some(
+      (existing) => haversineDistanceMeters(
+        existing.lngLat[0],
+        existing.lngLat[1],
+        photo.lngLat[0],
+        photo.lngLat[1]
+      ) < minDistanceMeters
+    );
+    if (!tooClose) {
+      kept.push(photo);
+    }
+  }
+  return kept;
+};
+var groupClickedPhotos = (photos, lng, lat) => {
+  const byGroup = /* @__PURE__ */ new Map();
+  for (const photo of photos) {
+    const sequenceId = photoGroupSequenceId(photo);
+    const key = sequenceGroupKey(photo.providerId, sequenceId);
+    const group = byGroup.get(key) ?? [];
+    group.push(photo);
+    byGroup.set(key, group);
+  }
+  const groups = [];
+  for (const [groupKey, groupPhotos] of byGroup) {
+    const deduped = dedupeNearbyPhotos(groupPhotos);
+    const nearest = findNearestPhoto(deduped, lng, lat);
+    if (!nearest) {
+      continue;
+    }
+    const sequenceId = photoGroupSequenceId(nearest);
+    groups.push({
+      providerId: nearest.providerId,
+      sequenceId,
+      groupKey,
+      photos: deduped.sort(compareCapturedAt),
+      distanceMeters: distanceToPhoto(nearest, lng, lat)
+    });
+  }
+  return groups.sort((left, right) => {
+    if (left.distanceMeters !== right.distanceMeters) {
+      return left.distanceMeters - right.distanceMeters;
+    }
+    return left.groupKey.localeCompare(right.groupKey);
+  });
+};
+var findGroupBySelection = (groups, providerId, sequenceId) => groups.find((group) => group.providerId === providerId && group.sequenceId === sequenceId) ?? null;
+var findPhotoIndexInGroup = (group, photoId) => group.photos.findIndex((photo) => photo.photoId === photoId);
+var STREETSIDE_NEARBY_LIMIT = 15;
+var collectNearbyStreetsidePhotos = (groups, activePhoto, limit = STREETSIDE_NEARBY_LIMIT) => {
+  const seen = /* @__PURE__ */ new Set();
+  const all = [];
+  for (const group of groups) {
+    if (group.providerId !== "streetside") {
+      continue;
+    }
+    for (const photo of group.photos) {
+      if (seen.has(photo.photoId)) {
+        continue;
+      }
+      seen.add(photo.photoId);
+      all.push(photo);
+    }
+  }
+  const [lng, lat] = activePhoto.lngLat;
+  const byDistance = (left, right) => distanceToPhoto(left, lng, lat) - distanceToPhoto(right, lng, lat);
+  const nearby = [...all].sort(byDistance).slice(0, limit);
+  if (!nearby.some((photo) => photo.photoId === activePhoto.photoId)) {
+    if (nearby.length >= limit) {
+      nearby.pop();
+    }
+    nearby.push(activePhoto);
+    nearby.sort(byDistance);
+  }
+  return nearby;
+};
+
+// src/viewer/streetsidePreview.ts
+var buildStreetsidePreviewUrl = (imageUrlTemplate) => {
+  if (!imageUrlTemplate || !imageUrlTemplate.includes("{")) {
+    return null;
+  }
+  return imageUrlTemplate.replace("{subdomain}", "t0").replace("{faceId}", "01").replace("{tileId}", "");
+};
+
+// src/viewer/photoThumbnails.ts
+var mapilioCdnUrl = (uploadedHash, filename, size) => `https://cdn.mapilio.com/im/${uploadedHash}/${filename}/${size}`;
+var fetchMapilioSequenceItem = async (sequenceId, photoId) => {
+  const response = await fetch(
+    `https://end.mapilio.com/api/sequence-detail?sequence_uuid=${encodeURIComponent(sequenceId)}`
+  );
+  if (!response.ok) {
+    throw new Error(`Mapilio sequence detail failed (${response.status})`);
+  }
+  const data = await response.json();
+  const items = Array.isArray(data.data) ? data.data : data.data?.data ?? [];
+  const match = items.find((item) => String(item.id) === photoId);
+  return match ?? null;
+};
+var fetchMapillaryThumbnail = async (photoId) => {
+  const url = new URL(`https://graph.mapillary.com/${photoId}`);
+  url.searchParams.set("fields", "thumb_1024_url");
+  url.searchParams.set("access_token", getStreetImageryConfig().mapillaryToken);
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Mapillary thumbnail failed (${response.status})`);
+  }
+  const data = await response.json();
+  return data.thumb_1024_url ?? null;
+};
+var fetchPanoramaxThumbnail = async (sequenceId, photoId) => {
+  const base = getStreetImageryConfig().panoramaxApiBase;
+  const response = await fetch(
+    `${base}/api/collections/${encodeURIComponent(sequenceId)}/items/${encodeURIComponent(photoId)}`
+  );
+  if (!response.ok) {
+    throw new Error(`Panoramax thumbnail failed (${response.status})`);
+  }
+  const data = await response.json();
+  return data.assets?.sd?.href ?? data.assets?.hd?.href ?? null;
+};
+var fetchMapilioThumbnail = async (sequenceId, photoId) => {
+  const match = await fetchMapilioSequenceItem(sequenceId, photoId);
+  if (!match?.uploaded_hash || !match.filename) {
+    return null;
+  }
+  return mapilioCdnUrl(match.uploaded_hash, match.filename, "1080");
+};
+var fetchMapilioFullUrl = async (sequenceId, photoId) => {
+  const match = await fetchMapilioSequenceItem(sequenceId, photoId);
+  if (!match?.uploaded_hash || !match.filename) {
+    return null;
+  }
+  return mapilioCdnUrl(match.uploaded_hash, match.filename, "2080");
+};
+var resolvePhotoFullUrl = async (photo) => {
+  if (photo.providerId === "streetview" || photo.providerId === "lookaround") {
+    return null;
+  }
+  if (photo.fullUrl) {
+    return photo.fullUrl;
+  }
+  switch (photo.providerId) {
+    case "mapilio":
+      if (!photo.sequenceId) {
+        return null;
+      }
+      return fetchMapilioFullUrl(photo.sequenceId, photo.photoId);
+    case "kartaview":
+    case "vegbilder":
+      return photo.thumbUrl ?? null;
+    case "mapillary": {
+      throw new Error('Not implemented yet: "mapillary" case');
+    }
+    case "mapillary-map-features": {
+      throw new Error('Not implemented yet: "mapillary-map-features" case');
+    }
+    case "mapillary-signs": {
+      throw new Error('Not implemented yet: "mapillary-signs" case');
+    }
+    case "panoramax": {
+      throw new Error('Not implemented yet: "panoramax" case');
+    }
+    case "streetside": {
+      throw new Error('Not implemented yet: "streetside" case');
+    }
+    default:
+      return null;
+  }
+};
+var resolvePhotoPanoramaUrl = async (photo) => {
+  const fullUrl = await resolvePhotoFullUrl(photo);
+  if (fullUrl) {
+    return fullUrl;
+  }
+  return photo.thumbUrl ?? null;
+};
+var resolvePhotoThumbnailUrl = async (photo) => {
+  if (photo.providerId === "streetview" || photo.providerId === "lookaround") {
+    return null;
+  }
+  if (photo.thumbUrl) {
+    if (photo.providerId === "streetside") {
+      return buildStreetsidePreviewUrl(photo.thumbUrl);
+    }
+    return photo.thumbUrl;
+  }
+  switch (photo.providerId) {
+    case "mapillary":
+      return fetchMapillaryThumbnail(photo.photoId);
+    case "panoramax":
+      if (!photo.sequenceId) {
+        return null;
+      }
+      return fetchPanoramaxThumbnail(photo.sequenceId, photo.photoId);
+    case "mapilio":
+      if (!photo.sequenceId) {
+        return null;
+      }
+      return fetchMapilioThumbnail(photo.sequenceId, photo.photoId);
+    // These providers deliver thumbUrl with the photo data; without it there is no fallback fetch.
+    case "kartaview":
+    case "streetside":
+    case "vegbilder":
+      return null;
+    case "mapillary-map-features":
+    case "mapillary-signs":
+      return null;
+    default:
+      return null;
+  }
+};
+var photoFullUrlQueryKey = (photo) => ["photo-full-url", photo.providerId, photo.sequenceId, photo.photoId];
+var photoThumbnailQueryKey = (photo) => ["photo-thumbnail", photo.providerId, photo.sequenceId, photo.photoId];
+
+export { DEFAULT_PROVIDER_IDS, FLAT_VIEWFIELD_FOV_DEG, PANO_VIEWFIELD_FOV_DEG, PROVIDERS, PROVIDER_ADAPTERS, PROVIDER_IDS, STREETSIDE_NEARBY_LIMIT, adapterById, bboxIntersects, buildMapFeatureLayerFilter, buildPhotoLayerFilter, buildStreetsidePreviewUrl, clampZoom, clearTileCache, clickRadiusMeters, collectNearbyStreetsidePhotos, collectSettledTiles, coneRadiusMeters, createStreetImageryConfig, dedupeNearbyPhotos, distanceToPhoto, emptyLineCollection, emptyPointCollection, emptyPolygonCollection, featureLayerId, featureSourceId, fetchMapilioFullUrl, fetchMapilioSequenceItem, fetchMapilioThumbnail, fetchMapillaryMvtTiles, fetchMapillaryThumbnail, fetchMvt, fetchPanoramaxThumbnail, fetchStreetViewMetadata, fetchTileCached, findGroupBySelection, findNearestPhoto, findPhotoIndexInGroup, flatViewfieldTriangle, getGoogleMapsApiKey, getStreetImageryConfig, getTileCacheKey, groupClickedPhotos, haversineDistanceMeters, isBrowserAvailableProvider, isClickOnlyPhotoProvider, isMapFeatureProviderId, isNullIslandTile, isPhotoProviderId, latToTileY, lonToTileX, lookAroundDeepLink, mapFeatureExternalLink, mapFeatureMatchesDateRange, mapFeaturesToFeatureCollection, mapillaryTileUrl, normalizeDateRange, parseIsoDateEndMs, parseIsoDateStartMs, photoFullUrlQueryKey, photoGroupSequenceId, photoLayerId, photoMatchesDateRange, photoMatchesFilters, photoMatchesPhotoTypes, photoSourceId, photoThumbnailQueryKey, photoTypesFilter, photosToFeatureCollection, photosToViewfieldsFeatureCollection, pointLngLat, providerById, providerExternalLink, providerLocationLink, resolvePhotoFullUrl, resolvePhotoPanoramaUrl, resolvePhotoThumbnailUrl, sequenceGroupKey, sequenceLayerId, sequenceSourceId, sequencesToFeatureCollection, setStreetImageryConfig, tileBbox, tilePixelSizeAtZoom, tileToLat, tileToLon, tilesForBbox, viewConeGeoJson, viewfieldLayerId, viewfieldLineLayerId, viewfieldSourceId };