@mapmap/maps 0.2.0 → 0.3.0

package/dist/index.js

@@ -85,7 +85,7 @@ function watchForAuthFailures(map, apiKey) {
     on.call(map, "error", (ev) => {
       const status = ev?.error?.status;
       const message = ev?.error?.message ?? "";
-      const unauthorised = status === 401 || /\b401\b|unauthori[sz]ed/i.test(message);
+      const unauthorised = status === 401 || /unauthori[sz]ed/i.test(message);
       if (!unauthorised) return;
       report(
         "invalid-api-key",
@@ -96,6 +96,52 @@ function watchForAuthFailures(map, apiKey) {
   }
 }
 
+// src/coords.ts
+function toLngLat(point) {
+  if (Array.isArray(point)) {
+    const [lng2, lat2] = point;
+    assertFinite(lng2, lat2);
+    return [lng2, lat2];
+  }
+  const lng = "lng" in point ? point.lng : point.lon;
+  const lat = point.lat;
+  assertFinite(lng, lat);
+  return [lng, lat];
+}
+function formatCoord(point) {
+  const [lng, lat] = toLngLat(point);
+  return `${lng},${lat}`;
+}
+function formatCoords(points) {
+  if (points.length < 2) {
+    throw new Error("at least two coordinates are required for a route");
+  }
+  return points.map(formatCoord).join(";");
+}
+function unwrapLngs(coordinates) {
+  const out = [];
+  for (const [lng, lat] of coordinates) {
+    const prev = out[out.length - 1];
+    let unwrapped = lng;
+    if (prev) {
+      while (unwrapped - prev[0] > 180) unwrapped -= 360;
+      while (unwrapped - prev[0] < -180) unwrapped += 360;
+    }
+    out.push([unwrapped, lat]);
+  }
+  return out;
+}
+function assertFinite(lng, lat) {
+  if (!Number.isFinite(lng) || !Number.isFinite(lat)) {
+    throw new Error(`invalid coordinate: lng=${lng}, lat=${lat}`);
+  }
+  if (lng < -180 || lng > 180 || lat < -90 || lat > 90) {
+    throw new Error(
+      `coordinate out of range: lng=${lng} (\xB1180), lat=${lat} (\xB190) - check lng/lat order`
+    );
+  }
+}
+
 // src/effects.ts
 var FLOW_COLOUR = "#3a86ff";
 var EARTH_RADIUS_M = 63710088e-1;
@@ -115,7 +161,7 @@ function lngLatToMercator(lngLat) {
 }
 function tessellateRouteRibbon(coordinates) {
   const points = [];
-  for (const lngLat of coordinates) {
+  for (const lngLat of unwrapLngs(coordinates)) {
     const p = lngLatToMercator(lngLat);
     const last = points[points.length - 1];
     if (!last || last[0] !== p[0] || last[1] !== p[1]) points.push(p);
@@ -1481,39 +1527,6 @@ function resolveStyle(style, territoryTilesUrl) {
   return style;
 }
 
-// src/coords.ts
-function toLngLat(point) {
-  if (Array.isArray(point)) {
-    const [lng2, lat2] = point;
-    assertFinite(lng2, lat2);
-    return [lng2, lat2];
-  }
-  const lng = "lng" in point ? point.lng : point.lon;
-  const lat = point.lat;
-  assertFinite(lng, lat);
-  return [lng, lat];
-}
-function formatCoord(point) {
-  const [lng, lat] = toLngLat(point);
-  return `${lng},${lat}`;
-}
-function formatCoords(points) {
-  if (points.length < 2) {
-    throw new Error("at least two coordinates are required for a route");
-  }
-  return points.map(formatCoord).join(";");
-}
-function assertFinite(lng, lat) {
-  if (!Number.isFinite(lng) || !Number.isFinite(lat)) {
-    throw new Error(`invalid coordinate: lng=${lng}, lat=${lat}`);
-  }
-  if (lng < -180 || lng > 180 || lat < -90 || lat > 90) {
-    throw new Error(
-      `coordinate out of range: lng=${lng} (\xB1180), lat=${lat} (\xB190) - check lng/lat order`
-    );
-  }
-}
-
 // src/osrm.ts
 function buildRouteQuery(truck, guidance) {
   const params = new URLSearchParams({
@@ -1587,10 +1600,38 @@ function numberOr(value, fallback) {
 // src/route.ts
 var SIGNAL_BLUE = "#3a86ff";
 var CASING_COLOR = "#1f438a";
+var PROGRESS_COLOR = "#b0b0b0";
+function arrowImage() {
+  const size = 24;
+  const data = new Uint8Array(size * size * 4);
+  const head = 13;
+  const put = (x, y, edge) => {
+    const i = (y * size + x) * 4;
+    const v = edge ? 31 : 255;
+    data[i] = v;
+    data[i + 1] = v;
+    data[i + 2] = edge ? 58 : 255;
+    data[i + 3] = 255;
+  };
+  for (let y = 2; y < head; y++) {
+    const half = Math.round((y - 2) / (head - 3) * 9);
+    for (let x = 11 - half; x <= 12 + half; x++) {
+      put(x, y, x === 11 - half || x === 12 + half || y === 2);
+    }
+  }
+  for (let y = head; y < 22; y++) {
+    for (let x = 9; x <= 14; x++) {
+      put(x, y, x === 9 || x === 14 || y === 21);
+    }
+  }
+  return { width: size, height: size, data };
+}
 var RouteLayer = class {
   constructor(map, options = {}) {
+    this.progress = 0;
     this.handleStyleLoad = () => {
       if (this.lastRoute) this.install(this.lastRoute);
+      else this.installManeuver();
     };
     if (map instanceof MapMapMap) {
       this.map = map.map;
@@ -1611,6 +1652,10 @@ var RouteLayer = class {
     this.sourceId = `${id}-src`;
     this.casingLayerId = `${id}-casing`;
     this.lineLayerId = `${id}-line`;
+    this.maneuverSourceId = `${id}-maneuver-src`;
+    this.maneuverLayerId = `${id}-maneuver`;
+    this.arrowImageId = `${id}-arrow`;
+    this.progressColor = options.progressColor ?? PROGRESS_COLOR;
     this.map.on("style.load", this.handleStyleLoad);
   }
   /**
@@ -1672,9 +1717,11 @@ var RouteLayer = class {
     if (existing) {
       existing.setData(data);
     } else {
-      this.map.addSource(this.sourceId, { type: "geojson", data });
+      this.map.addSource(this.sourceId, { type: "geojson", data, lineMetrics: true });
     }
     if (this.map.getLayer(this.casingLayerId) && this.map.getLayer(this.lineLayerId)) {
+      this.applyProgress();
+      this.installManeuver();
       return;
     }
     const casing = {
@@ -1707,15 +1754,86 @@ var RouteLayer = class {
     };
     if (!this.map.getLayer(this.casingLayerId)) this.map.addLayer(casing);
     if (!this.map.getLayer(this.lineLayerId)) this.map.addLayer(line);
+    this.applyProgress();
+    this.installManeuver();
+  }
+  /**
+   * Sets how much of the route has been travelled, as a fraction in `[0, 1]`
+   * of the line's length. The travelled part dims to `progressColor` (the
+   * "vanishing route line"); `0` restores the untinted line. The value is
+   * remembered across {@link draw} calls and style swaps. Pair with the
+   * guidance module's distance-remaining to derive the fraction.
+   */
+  setProgress(fraction) {
+    this.progress = Math.min(1, Math.max(0, fraction));
+    if (this.map.getLayer(this.lineLayerId)) this.applyProgress();
+  }
+  /** Applies the current progress fraction to the line layer's gradient. */
+  applyProgress() {
+    const routeColor = this.design?.color ?? SIGNAL_BLUE;
+    const gradient = this.progress > 0 ? ["step", ["line-progress"], this.progressColor, this.progress, routeColor] : void 0;
+    this.map.setPaintProperty(this.lineLayerId, "line-gradient", gradient);
+  }
+  /**
+   * Shows (or moves) the upcoming-manoeuvre arrow: a small map-aligned
+   * arrow at `lngLat` rotated to `bearingDeg` (clockwise from north).
+   * Survives style swaps until {@link clearManeuver}.
+   */
+  setManeuver(lngLat, bearingDeg) {
+    this.maneuver = { lngLat, bearingDeg };
+    if (this.map.isStyleLoaded()) this.installManeuver();
+  }
+  /** Hides the manoeuvre arrow. */
+  clearManeuver() {
+    this.maneuver = void 0;
+    if (this.map.getLayer(this.maneuverLayerId)) this.map.removeLayer(this.maneuverLayerId);
+    if (this.map.getSource(this.maneuverSourceId)) this.map.removeSource(this.maneuverSourceId);
+  }
+  /** Add-or-update the manoeuvre arrow source/layer for the current style. */
+  installManeuver() {
+    if (!this.maneuver) return;
+    const data = {
+      type: "Feature",
+      properties: { bearing: this.maneuver.bearingDeg },
+      geometry: { type: "Point", coordinates: this.maneuver.lngLat }
+    };
+    const source = this.map.getSource(this.maneuverSourceId);
+    if (source) {
+      source.setData(data);
+    } else {
+      this.map.addSource(this.maneuverSourceId, { type: "geojson", data });
+    }
+    if (!this.map.hasImage(this.arrowImageId)) {
+      this.map.addImage(this.arrowImageId, arrowImage());
+    }
+    if (!this.map.getLayer(this.maneuverLayerId)) {
+      this.map.addLayer({
+        id: this.maneuverLayerId,
+        type: "symbol",
+        source: this.maneuverSourceId,
+        layout: {
+          "icon-image": this.arrowImageId,
+          "icon-rotate": ["get", "bearing"],
+          "icon-rotation-alignment": "map",
+          "icon-allow-overlap": true,
+          "icon-ignore-placement": true,
+          "icon-size": ["interpolate", ["linear"], ["zoom"], 12, 0.7, 18, 1.4]
+        }
+      });
+    } else {
+      this.map.setLayoutProperty(this.maneuverLayerId, "icon-rotate", ["get", "bearing"]);
+    }
   }
   /** Remove the route's layers and source from the map. */
   clear() {
+    this.clearManeuver();
     for (const layerId of [this.lineLayerId, this.casingLayerId]) {
       if (this.map.getLayer(layerId)) this.map.removeLayer(layerId);
     }
     if (this.map.getSource(this.sourceId)) this.map.removeSource(this.sourceId);
     this.lastRoute = void 0;
     this.owner?.setRouteEffectGeometry(null);
+    this.progress = 0;
   }
   /**
    * Remove the route and detach the layer's `style.load` listener. Call
@@ -1741,6 +1859,12 @@ function effectiveImageUrl(design) {
   }
   return url;
 }
+function shortestArcDeg(fromDeg, toDeg) {
+  const raw = ((toDeg - fromDeg) % 360 + 360) % 360;
+  return raw > 180 ? raw - 360 : raw;
+}
+var MAX_TWEEN_MS = 900;
+var MIN_TWEEN_MS = 100;
 var PositionPuck = class {
   /**
    * Creates the puck (not yet on the map - it appears on the first
@@ -1748,12 +1872,17 @@ var PositionPuck = class {
    * `navDesign.puck` when given a `MapMapMap` whose theme carried an
    * `extra.nav` block, then to the built-in blue puck.
    */
-  constructor(map, design) {
+  constructor(map, design, options) {
     this.added = false;
     this.map = map instanceof MapMapMap ? map.map : map;
     this.design = design ?? (map instanceof MapMapMap ? map.navDesign?.puck : void 0) ?? defaultNavDesign().puck;
     this.element = createPuckElement();
     stylePuckElement(this.element, this.design);
+    this.interpolate = options?.interpolate ?? true;
+    this.now = options?.now ?? Date.now;
+    const g = globalThis;
+    this.requestFrame = options?.requestFrame ?? (g.requestAnimationFrame ? (cb) => g.requestAnimationFrame(() => cb()) : void 0);
+    this.cancelFrame = options?.cancelFrame ?? (g.cancelAnimationFrame ? (h) => g.cancelAnimationFrame(h) : void 0);
     this.marker = new maplibregl.Marker({
       element: this.element,
       rotationAlignment: "map",
@@ -1764,20 +1893,72 @@ var PositionPuck = class {
    * Moves the puck (adding it to the map on the first call). `headingDeg`
    * rotates the whole element - arrow or custom image - clockwise from
    * north; omit it to keep the previous heading.
+   *
+   * With interpolation on (the default) every call after the first glides
+   * from the currently rendered position - a fix arriving mid-tween
+   * retargets smoothly rather than jumping.
    */
   setLocation(location, headingDeg) {
-    this.marker.setLngLat([location.lon, location.lat]);
-    if (headingDeg !== void 0) this.marker.setRotation(headingDeg);
-    if (!this.added) {
+    const first = !this.added;
+    const nowMs = this.now();
+    const interval = this.lastFixAt === void 0 ? MAX_TWEEN_MS : nowMs - this.lastFixAt;
+    this.lastFixAt = nowMs;
+    this.cancelTween();
+    const from = this.rendered;
+    const target = {
+      lat: location.lat,
+      lon: location.lon,
+      heading: headingDeg ?? from?.heading ?? 0
+    };
+    const duration = Math.min(MAX_TWEEN_MS, interval);
+    if (first || !this.interpolate || !this.requestFrame || !from || duration < MIN_TWEEN_MS) {
+      this.render(target);
+    } else {
+      this.tween(from, target, nowMs, duration);
+    }
+    if (first) {
       this.marker.addTo(this.map);
       this.added = true;
     }
   }
-  /** Removes the puck from the map. `setLocation` re-adds it. */
+  /** Removes the puck from the map (cancelling any tween). `setLocation` re-adds it. */
   remove() {
+    this.cancelTween();
     this.marker.remove();
     this.added = false;
   }
+  /** Applies a position/heading to the marker immediately. */
+  render(state) {
+    this.marker.setLngLat([state.lon, state.lat]);
+    this.marker.setRotation(state.heading);
+    this.rendered = state;
+  }
+  /** Runs a linear position lerp + shortest-arc heading tween via rAF. */
+  tween(from, to, startedAt, duration) {
+    const headingDelta = shortestArcDeg(from.heading, to.heading);
+    const step = () => {
+      const t = Math.min(1, (this.now() - startedAt) / duration);
+      this.render({
+        lat: from.lat + (to.lat - from.lat) * t,
+        lon: from.lon + (to.lon - from.lon) * t,
+        heading: from.heading + headingDelta * t
+      });
+      if (t < 1) {
+        this.frameHandle = this.requestFrame(step);
+      } else {
+        this.frameHandle = void 0;
+        this.render(to);
+      }
+    };
+    this.frameHandle = this.requestFrame(step);
+  }
+  /** Cancels an in-flight tween, leaving the marker where it rendered last. */
+  cancelTween() {
+    if (this.frameHandle !== void 0) {
+      this.cancelFrame?.(this.frameHandle);
+      this.frameHandle = void 0;
+    }
+  }
 };
 function createPuckElement() {
   const doc = globalThis.document;
@@ -1826,6 +2007,186 @@ function stylePuckElement(el, puck) {
   dot.style.cssText = `position:absolute;inset:0;border-radius:50%;background:${puck.color};border:2px solid #ffffff;box-shadow:0 1px 6px rgba(0,0,0,0.45)`;
   arrow.style.cssText = puck.headingArrow ? `position:absolute;left:50%;top:${(-s * 0.55).toFixed(1)}px;transform:translateX(-50%);width:0;height:0;border-left:${(s * 0.35).toFixed(1)}px solid transparent;border-right:${(s * 0.35).toFixed(1)}px solid transparent;border-bottom:${(s * 0.6).toFixed(1)}px solid ${puck.color}` : "display:none";
 }
+
+// src/daynight.ts
+var DEG = Math.PI / 180;
+var DAY_MS = 864e5;
+var JULIAN_EPOCH = 24405875e-1;
+var J2000 = 2451545;
+function fromJulian(julian) {
+  return new Date((julian - JULIAN_EPOCH) * DAY_MS);
+}
+function sunTimes(date, lat, lng) {
+  const julianDay = Math.ceil(date.getTime() / DAY_MS + JULIAN_EPOCH - J2000 - 9e-4 + lng / 360);
+  const meanSolarTime = julianDay + 9e-4 - lng / 360;
+  const meanAnomalyDeg = (357.5291 + 0.98560028 * meanSolarTime) % 360;
+  const m = meanAnomalyDeg * DEG;
+  const centreDeg = 1.9148 * Math.sin(m) + 0.02 * Math.sin(2 * m) + 3e-4 * Math.sin(3 * m);
+  const eclipticLngDeg = (meanAnomalyDeg + centreDeg + 180 + 102.9372) % 360;
+  const l = eclipticLngDeg * DEG;
+  const transit = J2000 + meanSolarTime + 53e-4 * Math.sin(m) - 69e-4 * Math.sin(2 * l);
+  const sinDeclination = Math.sin(l) * Math.sin(23.4397 * DEG);
+  const cosDeclination = Math.cos(Math.asin(sinDeclination));
+  const cosHourAngle = (Math.sin(-0.833 * DEG) - Math.sin(lat * DEG) * sinDeclination) / (Math.cos(lat * DEG) * cosDeclination);
+  if (cosHourAngle < -1) return "polarDay";
+  if (cosHourAngle > 1) return "polarNight";
+  const hourAngleDeg = Math.acos(cosHourAngle) / DEG;
+  return {
+    sunrise: fromJulian(transit - hourAngleDeg / 360),
+    sunset: fromJulian(transit + hourAngleDeg / 360)
+  };
+}
+function resolveTheme(date, lat, lng) {
+  const times = sunTimes(date, lat, lng);
+  if (times === "polarDay") return "light";
+  if (times === "polarNight") return "dark";
+  return date >= times.sunrise && date < times.sunset ? "light" : "dark";
+}
+var POLAR_RECHECK_MS = 6 * 36e5;
+var BOUNDARY_MARGIN_MS = 1e3;
+var ThemeScheduler = class {
+  constructor(options) {
+    this.disposed = false;
+    this.lat = options.lat;
+    this.lng = options.lng;
+    this.onLight = options.onLight;
+    this.onDark = options.onDark;
+    this.now = options.now ?? Date.now;
+    this.setTimeoutFn = options.setTimeoutFn ?? ((cb, ms) => setTimeout(cb, ms));
+    this.clearTimeoutFn = options.clearTimeoutFn ?? ((h) => clearTimeout(h));
+    this.evaluate();
+  }
+  /** The theme most recently applied, if any. */
+  get current() {
+    return this.applied;
+  }
+  /** Moves the observer (e.g. a new GPS fix region) and re-evaluates. */
+  setPosition(lat, lng) {
+    this.lat = lat;
+    this.lng = lng;
+    this.evaluate();
+  }
+  /** Stops all future flips. */
+  dispose() {
+    this.disposed = true;
+    if (this.handle !== void 0) this.clearTimeoutFn(this.handle);
+    this.handle = void 0;
+  }
+  /** Applies the theme for now and arms the timer for the next boundary. */
+  evaluate() {
+    if (this.disposed) return;
+    if (this.handle !== void 0) {
+      this.clearTimeoutFn(this.handle);
+      this.handle = void 0;
+    }
+    const nowDate = new Date(this.now());
+    const theme = resolveTheme(nowDate, this.lat, this.lng);
+    if (theme !== this.applied) {
+      this.applied = theme;
+      (theme === "light" ? this.onLight : this.onDark)();
+    }
+    const delay = this.nextBoundaryDelay(nowDate);
+    this.handle = this.setTimeoutFn(() => this.evaluate(), delay);
+  }
+  /** Milliseconds until the next sunrise/sunset (or the polar re-check). */
+  nextBoundaryDelay(nowDate) {
+    const nowMs = nowDate.getTime();
+    for (const dayOffset of [0, 1]) {
+      const times = sunTimes(new Date(nowMs + dayOffset * DAY_MS), this.lat, this.lng);
+      if (times === "polarDay" || times === "polarNight") continue;
+      for (const event of [times.sunrise, times.sunset]) {
+        const delta = event.getTime() - nowMs;
+        if (delta > 0) return delta + BOUNDARY_MARGIN_MS;
+      }
+    }
+    return POLAR_RECHECK_MS;
+  }
+};
+
+// src/language.ts
+var LANGUAGE_TAG = /^[a-z]{2,3}(-[A-Za-z0-9]{2,4})?$/;
+function languageTextField(language) {
+  if (language === null) {
+    return ["coalesce", ["get", "name:en"], ["get", "name"]];
+  }
+  return [
+    "coalesce",
+    ["get", `name:${language}`],
+    ["get", "name:latin"],
+    ["get", "name"]
+  ];
+}
+function isNameTextField(textField) {
+  if (typeof textField === "string") {
+    return /\{name(?::[A-Za-z0-9-]+)?\}/.test(textField);
+  }
+  if (Array.isArray(textField)) {
+    if (textField.length === 2 && textField[0] === "get" && typeof textField[1] === "string") {
+      return textField[1] === "name" || textField[1].startsWith("name:");
+    }
+    return textField.some((part) => isNameTextField(part));
+  }
+  return false;
+}
+function setMapLanguage(map, language) {
+  if (language !== null && !LANGUAGE_TAG.test(language)) {
+    throw new Error(
+      `invalid language tag ${JSON.stringify(language)}; use e.g. "de", "pt-BR", "zh-Hans"`
+    );
+  }
+  const ml = map instanceof MapMapMap ? map.map : map;
+  const layers = ml.getStyle()?.layers ?? [];
+  const changed = [];
+  for (const layer of layers) {
+    if (layer.type !== "symbol") continue;
+    const textField = layer.layout?.["text-field"];
+    if (textField === void 0 || !isNameTextField(textField)) continue;
+    ml.setLayoutProperty(layer.id, "text-field", languageTextField(language));
+    changed.push(layer.id);
+  }
+  return changed;
+}
+
+// src/probe.ts
+function buildProbeUrl(baseUrl) {
+  return `${baseUrl.replace(/\/+$/, "")}/v1/probe`;
+}
+async function uploadProbeBatch(baseUrl, apiKey, body, options = {}) {
+  const doFetch = options.fetch ?? globalThis.fetch;
+  const maxAttempts = options.maxAttempts ?? 4;
+  const backoffMs = options.backoffMs ?? ((attempt) => attempt * 1e3);
+  const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const url = buildProbeUrl(baseUrl);
+  for (let attempt = 1; ; attempt++) {
+    let outcome;
+    try {
+      const response = await doFetch(url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body,
+        signal: options.signal
+      });
+      outcome = classifyStatus(response.status);
+    } catch {
+      outcome = "gaveUp";
+    }
+    if (outcome === "gaveUp" && attempt < maxAttempts) {
+      await sleep(backoffMs(attempt));
+      continue;
+    }
+    return outcome;
+  }
+}
+function classifyStatus(status) {
+  if (status === 202) return "accepted";
+  if (status === 403) return "refused";
+  if (status === 501) return "notEnabled";
+  if (status >= 500 && status <= 599) return "gaveUp";
+  return "rejected";
+}
 var EARTH_RADIUS_M2 = 63710088e-1;
 var CLUSTER_TEXT_FONT = "Noto Sans Regular";
 function placesFromGeoJSON(collection) {
@@ -2464,8 +2825,9 @@ function shortestArcDelta(from, to) {
 }
 var PoseSampler = class {
   constructor(coordinates) {
-    this.points = coordinates.filter(
-      (p, i) => i === 0 || p[0] !== coordinates[i - 1][0] || p[1] !== coordinates[i - 1][1]
+    const unwrapped = unwrapLngs(coordinates);
+    this.points = unwrapped.filter(
+      (p, i) => i === 0 || p[0] !== unwrapped[i - 1][0] || p[1] !== unwrapped[i - 1][1]
     );
     if (this.points.length < 2) {
       throw new Error(
@@ -2576,6 +2938,7 @@ function flythrough(map, route, options = {}) {
     seek(to) {
       if (destroyed) return;
       t = Math.min(1, Math.max(0, to));
+      bearing = void 0;
       applyPose(1 / 60);
     },
     get speed() {
@@ -2748,6 +3111,7 @@ var IsochroneLayer = class {
         this.fillOpacity()
       );
       this.map.setPaintProperty(this.lineLayerId, "line-color", this.lastColor);
+      this.map.setPaintProperty(this.labelLayerId, "text-color", this.lastColor);
       return;
     }
     const fill2 = {
@@ -3138,6 +3502,6 @@ function clampVolume(volume) {
   return Math.min(1, Math.max(0, volume));
 }
 
-export { AdrCheck, DEFAULT_GLYPHS_URL, DEFAULT_TERRITORY_TILES_URL, EFFECTS_METADATA_KEY, FLOW_DEFAULTS, FULL_ATTRIBUTION, FlowRouteEffectLayer, GuidanceBanner, IsochroneLayer, LOGO_SVG, LogoControl, MAX_PUCK_IMAGE_BYTES, MapMapMap, NAV_CAMERA_DEFAULTS, NavigationCamera, OPENMAPTILES_ATTRIBUTION, OSM_ATTRIBUTION, PALETTE_SLOTS, POI_CATEGORY_COLORS, POI_CATEGORY_IDS, POI_CLASS_CATEGORIES, PlacesLayer, PositionPuck, RIBBON_FLOATS_PER_VERTEX, ROUTE_EFFECTS, RouteLayer, SIGNAL_BLUE, SOURCE_LAYERS, VoiceGuidance, applyPoiDesign, bannerLanes, bearingBetween, bindFlythroughToScroll, buildAdrCheckBody, buildRouteQuery, buildRouteUrl, buildStyle, builtInPoiColor, createMap, createRouteEffect, defaultNavDesign, defaultPoiDesign, directionArrow, effectsFromStyleMetadata, extractGuidance, flythrough, flythroughPose, formatCoord, formatCoords, haversineDistanceM, lngLatToMercator, navDesignFromTheme, navDesignFromThemeUrl, parseCssColour, parseNavDesign, parseOsrmRoute, parsePoiDesign, placesFromGeoJSON, poiDesignFromTheme, poiDesignFromThemeUrl, poiDesignIsDefault, poiTextColorExpression, prefersReducedMotion, registerPmtilesProtocol, resetDiagnostics, runMapDiagnostics, severityProsody, shortestArcDelta, speak, ssmlToText, tessellateRouteRibbon, toLngLat, toPmtilesUrl };
+export { AdrCheck, DEFAULT_GLYPHS_URL, DEFAULT_TERRITORY_TILES_URL, EFFECTS_METADATA_KEY, FLOW_DEFAULTS, FULL_ATTRIBUTION, FlowRouteEffectLayer, GuidanceBanner, IsochroneLayer, LOGO_SVG, LogoControl, MAX_PUCK_IMAGE_BYTES, MapMapMap, NAV_CAMERA_DEFAULTS, NavigationCamera, OPENMAPTILES_ATTRIBUTION, OSM_ATTRIBUTION, PALETTE_SLOTS, POI_CATEGORY_COLORS, POI_CATEGORY_IDS, POI_CLASS_CATEGORIES, PlacesLayer, PositionPuck, RIBBON_FLOATS_PER_VERTEX, ROUTE_EFFECTS, RouteLayer, SIGNAL_BLUE, SOURCE_LAYERS, ThemeScheduler, VoiceGuidance, applyPoiDesign, bannerLanes, bearingBetween, bindFlythroughToScroll, buildAdrCheckBody, buildProbeUrl, buildRouteQuery, buildRouteUrl, buildStyle, builtInPoiColor, createMap, createRouteEffect, defaultNavDesign, defaultPoiDesign, directionArrow, effectsFromStyleMetadata, extractGuidance, flythrough, flythroughPose, formatCoord, formatCoords, haversineDistanceM, isNameTextField, languageTextField, lngLatToMercator, navDesignFromTheme, navDesignFromThemeUrl, parseCssColour, parseNavDesign, parseOsrmRoute, parsePoiDesign, placesFromGeoJSON, poiDesignFromTheme, poiDesignFromThemeUrl, poiDesignIsDefault, poiTextColorExpression, prefersReducedMotion, registerPmtilesProtocol, resetDiagnostics, resolveTheme, runMapDiagnostics, setMapLanguage, severityProsody, shortestArcDeg, shortestArcDelta, speak, ssmlToText, sunTimes, tessellateRouteRibbon, toLngLat, toPmtilesUrl, uploadProbeBatch };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map