@smartmaps/smartmaps-gl 2.0.2

package/dist/smartmaps-gl.js

@@ -0,0 +1,1132 @@
+var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _options, _container, _map, _apiKey, _terrainVisible, _terrainControl, _map2, _options2, _showDropdown, _dropdown, _select, _container2, _button, _LanguageControl_instances, createControlButton_fn, createDropdown_fn, changeLanguage_fn, closeDropdown_fn, toggleDropdown_fn, validateLanguage_fn, getControlLanguage_fn, getLanguageFromEvent_fn, isMobileDevice_fn, isFirefox_fn, _logger, _languageManager, _terrainManager, _colorSchemeManager, _contextmenu, _map3, _contextmenuItems, _contextMenuContainer, _currentCoords, _ContextMenu_instances, createMenuContainer_fn, attachEventListeners_fn, showMenu_fn, createMenuItem_fn, calculateMenuPosition_fn, _container3;
+import { TerrainControl, GeolocateControl as GeolocateControl$1, Map, FullscreenControl, NavigationControl, Marker as Marker$1 } from "maplibre-gl";
+import { LngLat, Point } from "maplibre-gl";
+class DOM {
+  static create(tagName, className, container) {
+    const el = window.document.createElement(tagName);
+    if (className !== void 0) el.className = className;
+    if (container) container.appendChild(el);
+    return el;
+  }
+  static remove(node) {
+    if (node.parentNode) {
+      node.parentNode.removeChild(node);
+    }
+  }
+  static addEventListener(target, type, callback, options = {}) {
+    if ("passive" in options) {
+      target.addEventListener(type, callback, options);
+    } else {
+      target.addEventListener(type, callback, options.capture);
+    }
+  }
+  static removeEventListener(target, type, callback, options = {}) {
+    if ("passive" in options) {
+      target.removeEventListener(type, callback, options);
+    } else {
+      target.removeEventListener(type, callback, options.capture);
+    }
+  }
+  static getElementById(elementId) {
+    return window.document.getElementById(elementId);
+  }
+}
+const DefaultOptions = {
+  className: "",
+  width: 100,
+  height: 26
+};
+class BrandControl {
+  constructor(options = {}) {
+    __privateAdd(this, _options);
+    __privateAdd(this, _container);
+    __privateSet(this, _options, {
+      ...DefaultOptions,
+      ...options
+    });
+  }
+  onAdd(map) {
+    __privateSet(this, _container, DOM.create("div", __privateGet(this, _options).className || "smartmaps-gl-ctrl"));
+    const anchor = DOM.create("a", "smartmaps-gl-ctrl-brand");
+    anchor.target = "_blank";
+    anchor.rel = "noopener nofollow";
+    if (__privateGet(this, _options).link) anchor.href = __privateGet(this, _options).link;
+    anchor.setAttribute("aria-label", "Brand control");
+    anchor.setAttribute("rel", "noopener nofollow");
+    __privateGet(this, _container).style.width = __privateGet(this, _options).width + "px";
+    __privateGet(this, _container).style.height = __privateGet(this, _options).height + "px";
+    if (__privateGet(this, _options).logo) {
+      const logo = DOM.create("img", "smartmaps-gl-ctrl-brand-logo");
+      logo.src = __privateGet(this, _options).logo;
+      logo.style.width = "100%";
+      logo.style.height = "100%";
+      anchor.appendChild(logo);
+    }
+    __privateGet(this, _container).appendChild(anchor);
+    __privateGet(this, _container).style.display = "block";
+    return __privateGet(this, _container);
+  }
+  onRemove() {
+    if (__privateGet(this, _container)) {
+      DOM.remove(__privateGet(this, _container));
+    }
+  }
+  getDefaultPosition() {
+    return "bottom-left";
+  }
+}
+_options = new WeakMap();
+_container = new WeakMap();
+const MapLanguage = {
+  AUTO: "auto",
+  AR: "ar",
+  BG: "bg",
+  CS: "cs",
+  DA: "da",
+  DE: "de",
+  EL: "el",
+  EN: "en",
+  ES: "es",
+  ET: "et",
+  FI: "fi",
+  FR: "fr",
+  GA: "ga",
+  HI: "hi",
+  HR: "hr",
+  HU: "hu",
+  IT: "it",
+  JA: "ja",
+  KO: "ko",
+  LB: "lb",
+  LT: "lt",
+  LV: "lv",
+  MT: "mt",
+  NL: "nl",
+  PL: "pl",
+  PT: "pt",
+  RO: "ro",
+  RU: "ru",
+  SK: "sk",
+  SL: "sl",
+  SV: "sv",
+  TR: "tr",
+  UK: "uk",
+  ZH: "zh",
+  LOCAL: "local"
+};
+const SupportedLanguages = Object.values(MapLanguage);
+const SupportedFallbackLanguages = ["de", "en", "local"];
+class LanguageManager {
+  constructor(map, language = void 0, fallbackLanguage = void 0) {
+    __publicField(this, "map");
+    __publicField(this, "language");
+    __publicField(this, "fallbackLanguage");
+    __publicField(this, "allowedLanguages");
+    this.map = map;
+    this.language = language ?? "default";
+    this.fallbackLanguage = fallbackLanguage ?? "default";
+    this.allowedLanguages = SupportedLanguages;
+    this.setInternalMapLanguage(this.language);
+    this.map.on("styledata", () => this.setInternalMapLanguage(this.language));
+  }
+  setFallbackLanguage(language) {
+    const fallbackLanguage = this.parseFallbackLanguage(language);
+    if (!fallbackLanguage) {
+      return;
+    }
+    if (this.language === "default") {
+      console.warn("Please set a valid language first");
+      return;
+    }
+    this.fallbackLanguage = fallbackLanguage;
+    if (this.map.isStyleLoaded()) {
+      this.applyMapLanguage();
+    } else {
+      this.map.once("styledata", () => this.applyMapLanguage());
+    }
+  }
+  getFallbackLanguage() {
+    return this.fallbackLanguage;
+  }
+  getMapLanguage() {
+    return this.language;
+  }
+  setInternalMapLanguage(language) {
+    if (language == "default") return;
+    return this.setMapLanguage(language);
+  }
+  setMapLanguage(language) {
+    const parsedMapLanguage = this.parseLanguage(language);
+    if (!parsedMapLanguage) return;
+    this.language = parsedMapLanguage === "auto" ? this.determineAutoLanguage() : parsedMapLanguage;
+    if (this.language !== "default" && this.fallbackLanguage === "default") {
+      this.fallbackLanguage = MapLanguage.EN;
+    }
+    if (this.map.isStyleLoaded()) {
+      this.applyMapLanguage();
+    } else {
+      this.map.once("styledata", () => this.applyMapLanguage());
+    }
+  }
+  getMapAllowedLanguages() {
+    return this.allowedLanguages;
+  }
+  setMapAllowedLanguages(languages) {
+    this.allowedLanguages = languages;
+  }
+  parseLanguage(language) {
+    const validLanguages = Object.values(MapLanguage);
+    const mapLanguage = validLanguages.find((v) => v === language.toLowerCase());
+    if (mapLanguage) {
+      const allowedMapLanguage = this.allowedLanguages.find((v) => v === mapLanguage.toLowerCase());
+      if (allowedMapLanguage) {
+        return allowedMapLanguage;
+      }
+      console.warn(
+        `The language '${language}' is supported but has been excluded in the options via selectedLanguages. 
+                The following language is selected '${this.allowedLanguages[0]}'`
+      );
+      return this.allowedLanguages[0];
+    }
+    console.warn(`'${language}' is not supported as language`);
+    return void 0;
+  }
+  parseFallbackLanguage(language) {
+    const fallbackLanguage = SupportedFallbackLanguages.find((v) => v === language.toLowerCase());
+    if (fallbackLanguage) {
+      return fallbackLanguage;
+    }
+    console.warn(`'${language}' is not supported as fallback language`);
+    return void 0;
+  }
+  determineAutoLanguage() {
+    const browserLanguageNotSupported = MapLanguage.EN;
+    const preferredLanguage = this.getPreferredLanguage().split("-")[0];
+    if (preferredLanguage) {
+      return this.parseLanguage(preferredLanguage) ?? browserLanguageNotSupported;
+    }
+    return browserLanguageNotSupported;
+  }
+  applyMapLanguage() {
+    const layers = this.map.getStyle().layers;
+    const language = this.getLanguageProperty(this.language);
+    const fallbackLanguage = this.getFallbackLanguageProperty(this.fallbackLanguage);
+    for (const layer of layers) {
+      const layerId = layer.id;
+      if (this.shouldUpdateLayer(layerId)) {
+        this.map.setLayoutProperty(layerId, "text-field", ["coalesce", language, fallbackLanguage]);
+      }
+    }
+  }
+  getLanguageProperty(language) {
+    return language === MapLanguage.LOCAL ? ["get", "name"] : ["get", `name:${language}`];
+  }
+  getFallbackLanguageProperty(language) {
+    return language === MapLanguage.LOCAL ? ["get", "name"] : ["get", `name_${language}`];
+  }
+  shouldUpdateLayer(layerId) {
+    return layerId.startsWith("label-") && !layerId.includes("shield") && layerId !== "label-address-housenumber";
+  }
+  getPreferredLanguage() {
+    var _a;
+    return ((_a = navigator.languages) == null ? void 0 : _a[0]) || navigator.language;
+  }
+}
+const translations = {
+  en: {
+    auto: "Auto",
+    ar: "Arabic",
+    bg: "Bulgarian",
+    cs: "Czech",
+    da: "Danish",
+    de: "German",
+    el: "Greek",
+    en: "English",
+    es: "Spanish",
+    et: "Estonian",
+    fi: "Finnish",
+    fr: "French",
+    ga: "Irish",
+    hi: "Hindi",
+    hr: "Croatian",
+    hu: "Hungarian",
+    it: "Italian",
+    ja: "Japanese",
+    ko: "Korean",
+    lb: "Luxembourgish",
+    lt: "Lithuanian",
+    lv: "Latvian",
+    mt: "Maltese",
+    nl: "Dutch",
+    pl: "Polish",
+    pt: "Portuguese",
+    ro: "Romanian",
+    ru: "Russian",
+    sk: "Slovak",
+    sl: "Slovenian",
+    sv: "Swedish",
+    tr: "Turkish",
+    uk: "Ukrainian",
+    zh: "Chinese",
+    local: "Local language"
+  },
+  de: {
+    auto: "Auto",
+    ar: "Arabisch",
+    bg: "Bulgarisch",
+    cs: "Tschechisch",
+    da: "Dänisch",
+    de: "Deutsch",
+    el: "Griechisch",
+    en: "Englisch",
+    es: "Spanisch",
+    et: "Estnisch",
+    fi: "Finnisch",
+    fr: "Französisch",
+    ga: "Irisch",
+    hi: "Hindi",
+    hr: "Kroatisch",
+    hu: "Ungarisch",
+    it: "Italienisch",
+    ja: "Japanisch",
+    ko: "Koreanisch",
+    lb: "Luxemburgisch",
+    lt: "Litauisch",
+    lv: "Lettisch",
+    mt: "Maltesisch",
+    nl: "Niederländisch",
+    pl: "Polnisch",
+    pt: "Portugiesisch",
+    ro: "Rumänisch",
+    ru: "Russisch",
+    sk: "Slowakisch",
+    sl: "Slowenisch",
+    sv: "Schwedisch",
+    tr: "Türkisch",
+    uk: "Ukrainisch",
+    zh: "Chinesisch",
+    local: "Landessprache"
+  },
+  fr: {
+    auto: "Auto",
+    ar: "Arabe",
+    bg: "Bulgare",
+    cs: "Tchèque",
+    da: "Danois",
+    de: "Allemand",
+    el: "Grec",
+    en: "Anglais",
+    es: "Espagnol",
+    et: "Estonien",
+    fi: "Finnois",
+    fr: "Français",
+    ga: "Irlandais",
+    hi: "Hindi",
+    hr: "Croate",
+    hu: "Hongrois",
+    it: "Italien",
+    ja: "Japonais",
+    ko: "Coréen",
+    lb: "Luxembourgeois",
+    lt: "Lituanien",
+    lv: "Letton",
+    mt: "Maltais",
+    nl: "Néerlandais",
+    pl: "Polonais",
+    pt: "Portugais",
+    ro: "Roumain",
+    ru: "Russe",
+    sk: "Slovaque",
+    sl: "Slovène",
+    sv: "Suédois",
+    tr: "Turc",
+    uk: "Ukrainien",
+    zh: "Chinois",
+    local: "Langue nationale"
+  },
+  es: {
+    auto: "Auto",
+    ar: "Árabe",
+    bg: "Búlgaro",
+    cs: "Checo",
+    da: "Danés",
+    de: "Alemán",
+    el: "Griego",
+    en: "Inglés",
+    es: "Español",
+    et: "Estonio",
+    fi: "Finlandés",
+    fr: "Francés",
+    ga: "Irlandés",
+    hi: "Hindi",
+    hr: "Croata",
+    hu: "Húngaro",
+    it: "Italiano",
+    ja: "Japonés",
+    ko: "Coreano",
+    lb: "Luxemburgués",
+    lt: "Lituano",
+    lv: "Letón",
+    mt: "Maltés",
+    nl: "Neerlandés",
+    pl: "Polaco",
+    pt: "Portugués",
+    ro: "Rumano",
+    ru: "Ruso",
+    sk: "Eslovaco",
+    sl: "Esloveno",
+    sv: "Sueco",
+    tr: "Turco",
+    uk: "Ucraniano",
+    zh: "Chino",
+    local: "Lengua nacional"
+  }
+};
+const applyDefaultsFn = (defaults) => (s) => {
+  const entries = Object.entries(defaults).map(([key, defaultValue]) => {
+    const keyOfT = key;
+    const valueOfT = s[keyOfT];
+    return [key, valueOfT === void 0 ? defaultValue : valueOfT];
+  });
+  const r = Object.fromEntries(entries);
+  return r;
+};
+function encodeString(s) {
+  try {
+    if (s !== decodeURIComponent(s)) {
+      return s;
+    } else {
+      return encodeURIComponent(s);
+    }
+  } catch {
+    return s;
+  }
+}
+function assertNotNull(obj, msg = "Assertion for not null failed!") {
+  if (obj == null) {
+    throw new Error(msg);
+  }
+}
+function toLatLngLiteral(coordinates) {
+  if (Array.isArray(coordinates)) {
+    const [x2, y2, z2] = coordinates;
+    return {
+      lat: y2,
+      lng: x2,
+      alt: z2 ?? void 0
+    };
+  }
+  const { x, y, z } = coordinates;
+  return {
+    lat: Number(y),
+    lng: Number(x),
+    alt: Number(z) ?? void 0
+  };
+}
+const defaultTerrainOptions = (cp = "top-right") => ({
+  exaggeration: 1,
+  position: cp,
+  activated: false
+});
+class TerrainManager {
+  constructor(map, apiKey) {
+    __privateAdd(this, _map);
+    __privateAdd(this, _apiKey);
+    __privateAdd(this, _terrainVisible, false);
+    __privateAdd(this, _terrainControl);
+    __privateSet(this, _map, map);
+    __privateSet(this, _apiKey, encodeString(apiKey));
+    __privateGet(this, _map).on("styledata", () => {
+      if (__privateGet(this, _terrainControl)) {
+        const terrainSourceExists = __privateGet(this, _map).getSource("terrainSource");
+        const hillshadeSourceExists = __privateGet(this, _map).getSource("hillshade");
+        if (!terrainSourceExists && !hillshadeSourceExists) {
+          this.addTerrainSources();
+          if (__privateGet(this, _terrainVisible)) {
+            __privateGet(this, _terrainControl)._toggleTerrain();
+            __privateGet(this, _terrainControl)._updateTerrainIcon();
+            __privateGet(this, _map).setLayoutProperty("hillshade", "visibility", "visible");
+          }
+        }
+      }
+    });
+  }
+  initialize(options) {
+    if (typeof options === "boolean" && options === false) {
+      return;
+    }
+    __privateGet(this, _map).once("styledata", () => {
+      this.addTerrainSources();
+      const terrainOptions = typeof options === "boolean" ? defaultTerrainOptions() : options;
+      this.addTerrainControl(terrainOptions);
+    });
+  }
+  terrainVisible() {
+    return __privateGet(this, _terrainVisible);
+  }
+  addTerrainSources() {
+    const layers = __privateGet(this, _map).getStyle().layers;
+    let firstSymbolId;
+    for (let layer of layers) {
+      if (layer.type === "symbol") {
+        firstSymbolId = layer.id;
+        break;
+      }
+    }
+    __privateGet(this, _map).addSource("terrainSource", {
+      type: "raster-dem",
+      url: `https://tiles.smartmaps.cloud/tiles/v1/terrain_rgb/tiles.json?apiKey=${__privateGet(this, _apiKey)}`,
+      tileSize: 256
+    });
+    __privateGet(this, _map).addSource("hillshadeSource", {
+      type: "raster-dem",
+      url: `https://tiles.smartmaps.cloud/tiles/v1/terrain_rgb/tiles.json?apiKey=${__privateGet(this, _apiKey)}`,
+      tileSize: 256
+    });
+    __privateGet(this, _map).addLayer(
+      {
+        id: "hillshade",
+        type: "hillshade",
+        source: "hillshadeSource",
+        layout: {
+          visibility: "none"
+        },
+        paint: {
+          "hillshade-shadow-color": "#635d50"
+        }
+      },
+      firstSymbolId
+    );
+  }
+  addTerrainControl(options) {
+    const terrainControl = new TerrainControl({
+      source: "terrainSource",
+      exaggeration: options.exaggeration
+    });
+    __privateSet(this, _terrainControl, terrainControl);
+    __privateGet(this, _map).addControl(terrainControl, options.position);
+    if (options.activated) {
+      terrainControl._toggleTerrain();
+      terrainControl._updateTerrainIcon();
+      __privateGet(this, _map).setLayoutProperty("hillshade", "visibility", "visible");
+      __privateSet(this, _terrainVisible, true);
+    }
+    this.addTerrainControlEventListener(terrainControl._terrainButton);
+  }
+  addTerrainControlEventListener(terrainControlElement) {
+    terrainControlElement.addEventListener("mousedown", () => {
+      __privateSet(this, _terrainVisible, !__privateGet(this, _terrainVisible));
+      __privateGet(this, _map).setLayoutProperty("hillshade", "visibility", __privateGet(this, _terrainVisible) ? "visible" : "none");
+    });
+  }
+}
+_map = new WeakMap();
+_apiKey = new WeakMap();
+_terrainVisible = new WeakMap();
+_terrainControl = new WeakMap();
+const loggerUrls = {
+  prod: "https://www.yellowmap.de",
+  staging: "https://staging.yellowmap.de"
+};
+const tilesUrls = {
+  prod: "https://tiles.smartmaps.cloud",
+  staging: "https://staging.tiles.smartmaps.cloud"
+};
+let useHost = "prod";
+const setHost = (host) => useHost = host;
+const useStagingUrls = () => setHost("staging");
+const useProductionUrls = () => setHost("prod");
+const getTilesUrl = () => tilesUrls[useHost];
+const getLoggerUrl = () => loggerUrls[useHost];
+const MapStyle = {
+  ACCESSIBLE: "accessible",
+  AUTO: "auto",
+  DARK: "dark",
+  ESSENTIAL: "essential",
+  GREY: "grey",
+  LIGHT: "light",
+  SATELLITE: "satellite"
+};
+const defaultMapOptions = {
+  style: MapStyle["LIGHT"],
+  smartmapsLogo: true,
+  channel: null,
+  terrain: false,
+  attributionControl: {
+    compact: true
+  }
+};
+const applyDefaults$1 = (options) => {
+  const defaultsfn = applyDefaultsFn(defaultMapOptions);
+  return { ...options, ...defaultsfn(options) };
+};
+const mapOptions = (options) => {
+  const optionsWithDefaults = applyDefaults$1(options);
+  const { style, apiKey, attributionControl, gestureHandling } = optionsWithDefaults;
+  const result = {
+    ...options,
+    style: isMapStyle(style) ? createStyleURL(style, apiKey) : style,
+    attributionControl,
+    cooperativeGestures: !!gestureHandling,
+    locale: mapGestureHandlingToLocale(gestureHandling)
+  };
+  return result;
+};
+function isMapStyle(style) {
+  if (typeof style != "string") return false;
+  const validStyles = Object.values(MapStyle);
+  const found = validStyles.find((v) => v === style.toLowerCase());
+  return found != null;
+}
+function createStyleURL(mapStyle, apiKey) {
+  let style = mapStyle.toLowerCase();
+  if (style === "auto") {
+    if (window.matchMedia && window.matchMedia("(prefers-color-scheme: dark)").matches) {
+      style = "dark";
+    } else {
+      style = "light";
+    }
+  }
+  const hostname = getTilesUrl();
+  const stylesPath = `styles/v1/smartmaps/${style}/style.json`;
+  const apiKeyQueryString = `apiKey=${encodeString(apiKey)}`;
+  const baseURL = `${hostname}/${stylesPath}`;
+  const styleURL = `${baseURL}?${apiKeyQueryString}`;
+  return styleURL;
+}
+function mapGestureHandlingToLocale(gestureHandling) {
+  var _a, _b, _c;
+  let locale;
+  if (typeof gestureHandling === "object") {
+    if ((_a = gestureHandling.text) == null ? void 0 : _a.windows) {
+      locale = { ...locale, "CooperativeGesturesHandler.WindowsHelpText": gestureHandling.text.windows };
+    }
+    if ((_b = gestureHandling.text) == null ? void 0 : _b.mac) {
+      locale = { ...locale, "CooperativeGesturesHandler.MacHelpText": gestureHandling.text.mac };
+    }
+    if ((_c = gestureHandling.text) == null ? void 0 : _c.touch) {
+      locale = { ...locale, "CooperativeGesturesHandler.MobileHelpText": gestureHandling.text.touch };
+    }
+  }
+  return locale;
+}
+class GeolocateControl extends GeolocateControl$1 {
+  constructor(options) {
+    super(options);
+  }
+  onAdd(map) {
+    super.onAdd(map);
+    this.on("geolocate", (e) => {
+      const { latitude, longitude, altitude } = e.coords;
+      const LatLngLiteral = {
+        lat: latitude,
+        lng: longitude,
+        alt: altitude ?? void 0
+      };
+      map.fire("location-found", { latlng: LatLngLiteral });
+    });
+    this.on("error", (e) => {
+      const locateError = { message: e.message, error: e };
+      map.fire("location-error", { error: locateError });
+    });
+    return this._container;
+  }
+}
+const defaultOptions = {
+  selectedLanguages: SupportedLanguages,
+  controlLanguage: "en"
+};
+const applyDefaults = (options) => {
+  const defaultsfn = applyDefaultsFn(defaultOptions);
+  if ((options == null ? void 0 : options.selectedLanguages) && options.selectedLanguages.length === 0) {
+    options.selectedLanguages = void 0;
+    console.warn("You have specified an invalid list of selectedLanguages. Supported languages are used instead.");
+  }
+  return defaultsfn(options ?? {});
+};
+class LanguageControl {
+  /**
+   * @param options - the control's options
+   */
+  constructor(options) {
+    __privateAdd(this, _LanguageControl_instances);
+    __privateAdd(this, _map2);
+    __privateAdd(this, _options2);
+    __privateAdd(this, _showDropdown, false);
+    __privateAdd(this, _dropdown);
+    __privateAdd(this, _select);
+    __privateAdd(this, _container2);
+    __privateAdd(this, _button);
+    __privateSet(this, _options2, applyDefaults(options));
+    __privateSet(this, _button, __privateMethod(this, _LanguageControl_instances, createControlButton_fn).call(this));
+    __privateSet(this, _dropdown, __privateMethod(this, _LanguageControl_instances, createDropdown_fn).call(this));
+    __privateSet(this, _select, DOM.create("select", "languages"));
+    __privateSet(this, _container2, DOM.create("div", "maplibregl-ctrl maplibregl-ctrl-group"));
+  }
+  onAdd(map) {
+    __privateSet(this, _map2, map);
+    __privateGet(this, _map2).setMapAllowedLanguages(__privateGet(this, _options2).selectedLanguages);
+    let isDropdownOpened = false;
+    let previousLanguage = __privateGet(this, _select).value;
+    __privateGet(this, _select).addEventListener("change", (event) => {
+      __privateMethod(this, _LanguageControl_instances, toggleDropdown_fn).call(this);
+      __privateMethod(this, _LanguageControl_instances, changeLanguage_fn).call(this, __privateMethod(this, _LanguageControl_instances, getLanguageFromEvent_fn).call(this, event));
+    });
+    __privateGet(this, _select).addEventListener("mousedown", () => {
+      if (!__privateMethod(this, _LanguageControl_instances, isMobileDevice_fn).call(this)) {
+        isDropdownOpened = true;
+        previousLanguage = map.getMapLanguage();
+      }
+    });
+    __privateGet(this, _select).addEventListener("click", (event) => {
+      if (!__privateMethod(this, _LanguageControl_instances, isMobileDevice_fn).call(this)) {
+        if (isDropdownOpened) {
+          isDropdownOpened = false;
+          return;
+        }
+        if (map.getMapLanguage() === __privateMethod(this, _LanguageControl_instances, getLanguageFromEvent_fn).call(this, event)) {
+          __privateMethod(this, _LanguageControl_instances, toggleDropdown_fn).call(this);
+        }
+      }
+    });
+    __privateGet(this, _select).addEventListener("click", (event) => {
+      if (__privateMethod(this, _LanguageControl_instances, isFirefox_fn).call(this)) {
+        if (previousLanguage === __privateMethod(this, _LanguageControl_instances, getLanguageFromEvent_fn).call(this, event)) {
+          __privateMethod(this, _LanguageControl_instances, toggleDropdown_fn).call(this);
+        }
+      }
+    });
+    __privateGet(this, _select).addEventListener("touchstart", (event) => {
+      if (__privateMethod(this, _LanguageControl_instances, isMobileDevice_fn).call(this)) {
+        previousLanguage = __privateMethod(this, _LanguageControl_instances, getLanguageFromEvent_fn).call(this, event);
+      }
+    });
+    __privateGet(this, _select).addEventListener("blur", (event) => {
+      if (__privateMethod(this, _LanguageControl_instances, isMobileDevice_fn).call(this)) {
+        if (previousLanguage === __privateMethod(this, _LanguageControl_instances, getLanguageFromEvent_fn).call(this, event)) {
+          __privateMethod(this, _LanguageControl_instances, toggleDropdown_fn).call(this);
+        }
+      }
+    });
+    __privateGet(this, _options2).selectedLanguages.forEach((lang) => {
+      if (__privateMethod(this, _LanguageControl_instances, validateLanguage_fn).call(this, lang)) {
+        const langOption = DOM.create("option");
+        langOption.value = lang;
+        langOption.selected = map.getMapLanguage() === "default" && lang === "local" || map.getMapLanguage() === lang;
+        langOption.textContent = translations[__privateMethod(this, _LanguageControl_instances, getControlLanguage_fn).call(this)][lang];
+        __privateGet(this, _select).appendChild(langOption);
+      }
+    });
+    map.on("click", () => {
+      if (__privateGet(this, _showDropdown)) __privateMethod(this, _LanguageControl_instances, closeDropdown_fn).call(this);
+    });
+    map.on("move", () => {
+      if (__privateGet(this, _showDropdown)) __privateMethod(this, _LanguageControl_instances, closeDropdown_fn).call(this);
+    });
+    __privateGet(this, _dropdown).appendChild(__privateGet(this, _select));
+    __privateGet(this, _container2).appendChild(__privateGet(this, _button));
+    __privateGet(this, _container2).appendChild(__privateGet(this, _dropdown));
+    return __privateGet(this, _container2);
+  }
+  onRemove() {
+    DOM.remove(__privateGet(this, _container2));
+  }
+  /**
+   * Optionally provide a default position for this control. If this method
+   * is implemented and {@link Map#addControl} is called without the `position`
+   * parameter, the value returned by getDefaultPosition will be used as the
+   * control's position.
+   *
+   * @returns a control position, one of the values valid in addControl.
+   */
+  getDefaultPosition() {
+    return "top-right";
+  }
+}
+_map2 = new WeakMap();
+_options2 = new WeakMap();
+_showDropdown = new WeakMap();
+_dropdown = new WeakMap();
+_select = new WeakMap();
+_container2 = new WeakMap();
+_button = new WeakMap();
+_LanguageControl_instances = new WeakSet();
+createControlButton_fn = function() {
+  const button = DOM.create("button", "smartmapsgl-ctrl-language");
+  button.type = "button";
+  button.title = "Switch language";
+  button.setAttribute("aria-label", "Switch language");
+  button.addEventListener("click", () => __privateMethod(this, _LanguageControl_instances, toggleDropdown_fn).call(this));
+  const icon = DOM.create("span", "smartmapsgl-ctrl-language-icon maplibregl-ctrl-icon");
+  icon.setAttribute("aria-hidden", "true");
+  button.appendChild(icon);
+  return button;
+};
+createDropdown_fn = function() {
+  const dropdown = DOM.create("div", "languages-dropdown");
+  dropdown.style.display = "none";
+  return dropdown;
+};
+changeLanguage_fn = function(lang) {
+  assertNotNull(__privateGet(this, _map2), "The map instance must exist in order to be able to change the language!");
+  __privateGet(this, _map2).setMapLanguage(lang);
+};
+closeDropdown_fn = function() {
+  __privateSet(this, _showDropdown, false);
+  __privateGet(this, _dropdown).style.display = "none";
+  __privateGet(this, _button).style.display = "block";
+};
+toggleDropdown_fn = function() {
+  var _a;
+  __privateSet(this, _showDropdown, !__privateGet(this, _showDropdown));
+  __privateGet(this, _dropdown).style.display = __privateGet(this, _showDropdown) ? "block" : "none";
+  __privateGet(this, _button).style.display = !__privateGet(this, _showDropdown) ? "block" : "none";
+  if (__privateGet(this, _showDropdown) && "showPicker" in HTMLSelectElement.prototype) {
+    (_a = __privateGet(this, _select)) == null ? void 0 : _a.showPicker();
+  }
+};
+validateLanguage_fn = function(language) {
+  const validLanguages = Object.values(SupportedLanguages);
+  const mapLanguage = validLanguages.find((v) => v === language.toLowerCase());
+  if (mapLanguage) {
+    return mapLanguage;
+  }
+  console.warn(`'${language}' is not supported as language`);
+  return void 0;
+};
+getControlLanguage_fn = function() {
+  return Object.keys(translations).find((key) => key === __privateGet(this, _options2).controlLanguage.toLowerCase()) ?? defaultOptions.controlLanguage;
+};
+getLanguageFromEvent_fn = function(event) {
+  const target = event.target;
+  const language = target.value;
+  return language;
+};
+isMobileDevice_fn = function() {
+  const regex = /Mobi|Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i;
+  return regex.test(navigator.userAgent) || window.matchMedia("(pointer: coarse)").matches;
+};
+isFirefox_fn = function() {
+  return navigator.userAgent.toLowerCase().indexOf("firefox") > -1;
+};
+class ColorSchemeManager {
+  constructor(map, apiKey) {
+    __publicField(this, "map");
+    __publicField(this, "apiKey");
+    __publicField(this, "mediaQueryList", window.matchMedia("(prefers-color-scheme: dark)"));
+    __publicField(this, "colorSchemeChangeListener", (event) => {
+      if (event.matches) {
+        this.map.setStyle(createStyleURL("dark", this.apiKey), { diff: false });
+      } else {
+        this.map.setStyle(createStyleURL("light", this.apiKey), { diff: false });
+      }
+    });
+    this.map = map;
+    this.apiKey = apiKey;
+  }
+  initialize(style) {
+    if (typeof style !== "string") return;
+    if (style.toLowerCase() === "auto") {
+      this.mediaQueryList.addEventListener("change", this.colorSchemeChangeListener);
+    }
+  }
+}
+class Logger {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  sessionInterval(provider, channel) {
+    this.session(provider, channel).catch(console.error);
+    setTimeout(() => this.sessionInterval(provider, channel), 6e5);
+  }
+  async session(provider, channel) {
+    const rootUrl = getLoggerUrl();
+    const url = new URL(`${rootUrl}/api_rst/api/mapsessiongl?apiKey=${encodeString(this.apiKey)}`);
+    url.searchParams.set("provider", provider);
+    if (channel) {
+      url.searchParams.set("channel", channel);
+    }
+    try {
+      await fetch(url.toString());
+    } catch (message) {
+      console.error(message);
+      throw message;
+    }
+  }
+}
+class SmartmapsGlMap extends Map {
+  constructor(options) {
+    super(mapOptions(options));
+    __privateAdd(this, _logger);
+    __privateAdd(this, _languageManager);
+    __privateAdd(this, _terrainManager);
+    __privateAdd(this, _colorSchemeManager);
+    __privateAdd(this, _contextmenu);
+    const o = applyDefaults$1(options);
+    __privateSet(this, _logger, new Logger(o.apiKey));
+    __privateSet(this, _languageManager, new LanguageManager(this, o.language, o.fallbackLanguage));
+    __privateSet(this, _terrainManager, new TerrainManager(this, o.apiKey));
+    __privateSet(this, _colorSchemeManager, new ColorSchemeManager(this, o.apiKey));
+    this.on("load", () => {
+      __privateGet(this, _logger).sessionInterval("smartmaps", o.channel);
+    });
+    if (o.fullscreenControl) {
+      if (o.fullscreenControl === true) {
+        this.addControl(new FullscreenControl());
+      } else {
+        this.addControl(new FullscreenControl(o.fullscreenControl));
+      }
+    }
+    if (o.smartmapsLogo === true) {
+      this.addControl(new SmartmapsLogoControl());
+    }
+    if (o.zoomControl === true) {
+      this.addControl(new NavigationControl({ showCompass: false }));
+    }
+    if (o.navigationControl) {
+      if (o.navigationControl === true) {
+        this.addControl(new NavigationControl());
+      } else {
+        this.addControl(new NavigationControl(o.navigationControl));
+      }
+    }
+    if (o.geolocateControl) {
+      if (o.geolocateControl === true) {
+        this.addControl(new GeolocateControl({}));
+      } else {
+        this.addControl(new GeolocateControl(o.geolocateControl));
+      }
+    }
+    if (o.languageControl) {
+      if (o.languageControl === true) {
+        this.addControl(new LanguageControl());
+      } else {
+        this.addControl(new LanguageControl(o.languageControl));
+      }
+    }
+    if (o.contextmenu) {
+      if (o.contextmenu === true) {
+        __privateSet(this, _contextmenu, new ContextMenu(this));
+      } else {
+        __privateSet(this, _contextmenu, new ContextMenu(this, o.contextmenu));
+      }
+    }
+    __privateGet(this, _terrainManager).initialize(o.terrain);
+    __privateGet(this, _colorSchemeManager).initialize(o.style);
+  }
+  setMapLanguage(language) {
+    __privateGet(this, _languageManager).setMapLanguage(language);
+  }
+  getMapLanguage() {
+    return __privateGet(this, _languageManager).getMapLanguage();
+  }
+  setFallbackMapLanguage(language) {
+    __privateGet(this, _languageManager).setFallbackLanguage(language);
+  }
+  getFallbackMapLanguage() {
+    return __privateGet(this, _languageManager).getFallbackLanguage();
+  }
+  getMapAllowedLanguages() {
+    return __privateGet(this, _languageManager).getMapAllowedLanguages();
+  }
+  setMapAllowedLanguages(languages) {
+    __privateGet(this, _languageManager).setMapAllowedLanguages(languages);
+  }
+  getContextmenu() {
+    return __privateGet(this, _contextmenu);
+  }
+}
+_logger = new WeakMap();
+_languageManager = new WeakMap();
+_terrainManager = new WeakMap();
+_colorSchemeManager = new WeakMap();
+_contextmenu = new WeakMap();
+const DEFAULT_MARKER_OPTIONS = () => ({
+  color: "#18345c",
+  scale: 1.25,
+  className: "smartmaps-gl-marker"
+});
+class Marker extends Marker$1 {
+  constructor(options) {
+    super({ ...DEFAULT_MARKER_OPTIONS(), ...options });
+  }
+}
+const icons = {
+  zoomIn: `<svg class="smartmaps-gl-context-menu-icon" stroke="currentColor" fill="currentColor" stroke-width="0" viewBox="0 0 448 512"  xmlns="http://www.w3.org/2000/svg"><path d="M416 208H272V64c0-17.67-14.33-32-32-32h-32c-17.67 0-32 14.33-32 32v144H32c-17.67 0-32 14.33-32 32v32c0 17.67 14.33 32 32 32h144v144c0 17.67 14.33 32 32 32h32c17.67 0 32-14.33 32-32V304h144c17.67 0 32-14.33 32-32v-32c0-17.67-14.33-32-32-32z"></path></svg>`,
+  zoomOut: `<svg class="smartmaps-gl-context-menu-icon" stroke="currentColor" fill="currentColor" stroke-width="0" viewBox="0 0 448 512"  xmlns="http://www.w3.org/2000/svg"><path d="M416 208H32c-17.67 0-32 14.33-32 32v32c0 17.67 14.33 32 32 32h384c17.67 0 32-14.33 32-32v-32c0-17.67-14.33-32-32-32z"></path></svg>`
+};
+const defaultContextmenuItems = [
+  {
+    action: "zoomIn",
+    label: `${icons.zoomIn} Zoom in`,
+    handler: (_, map) => map.zoomIn()
+  },
+  {
+    action: "zoomOut",
+    label: `${icons.zoomOut} Zoom out`,
+    handler: (_, map) => map.zoomOut()
+  },
+  {
+    action: "centerMap",
+    label: "Center map here",
+    handler: (coords, map) => map.setCenter(coords)
+  },
+  {
+    action: "addMarker",
+    label: "Add Marker",
+    handler: (coords, map) => new Marker().setLngLat(coords).addTo(map)
+  }
+];
+class ContextMenu {
+  /**
+   * @param options - the control's options
+   */
+  constructor(map, options) {
+    __privateAdd(this, _ContextMenu_instances);
+    __privateAdd(this, _map3);
+    __privateAdd(this, _contextmenuItems, []);
+    __privateAdd(this, _contextMenuContainer);
+    __privateAdd(this, _currentCoords);
+    var _a;
+    __privateSet(this, _map3, map);
+    __privateSet(this, _contextMenuContainer, __privateMethod(this, _ContextMenu_instances, createMenuContainer_fn).call(this));
+    const initialItems = ((_a = options == null ? void 0 : options.contextmenuItems) == null ? void 0 : _a.length) ? options.contextmenuItems : defaultContextmenuItems;
+    initialItems.forEach((item) => this.addItem(item));
+    __privateMethod(this, _ContextMenu_instances, attachEventListeners_fn).call(this);
+  }
+  addItem(options) {
+    const menuItem = __privateMethod(this, _ContextMenu_instances, createMenuItem_fn).call(this, options);
+    __privateGet(this, _contextMenuContainer).appendChild(menuItem);
+    __privateGet(this, _contextmenuItems).push(options);
+  }
+  removeItem(action) {
+    var _a;
+    const itemIndex = __privateGet(this, _contextmenuItems).findIndex((item) => item.action === action);
+    if (itemIndex !== -1) {
+      __privateGet(this, _contextmenuItems).splice(itemIndex, 1);
+      const menuItemElements = __privateGet(this, _contextMenuContainer).querySelectorAll(".smartmaps-gl-context-menu-item");
+      (_a = menuItemElements[itemIndex]) == null ? void 0 : _a.remove();
+    }
+  }
+  hide() {
+    __privateGet(this, _contextMenuContainer).style.display = "none";
+  }
+  removeAllItems() {
+    __privateSet(this, _contextmenuItems, []);
+    __privateGet(this, _contextMenuContainer).innerHTML = "";
+  }
+}
+_map3 = new WeakMap();
+_contextmenuItems = new WeakMap();
+_contextMenuContainer = new WeakMap();
+_currentCoords = new WeakMap();
+_ContextMenu_instances = new WeakSet();
+createMenuContainer_fn = function() {
+  const container = document.createElement("div");
+  container.className = "smartmaps-gl-context-menu";
+  __privateGet(this, _map3).getContainer().appendChild(container);
+  return container;
+};
+attachEventListeners_fn = function() {
+  __privateGet(this, _map3).on("contextmenu", (event) => __privateMethod(this, _ContextMenu_instances, showMenu_fn).call(this, event));
+  __privateGet(this, _map3).on("click", () => this.hide());
+  __privateGet(this, _map3).on("mousedown", () => this.hide());
+  document.addEventListener("click", (e) => {
+    if (!__privateGet(this, _contextMenuContainer).contains(e.target)) {
+      this.hide();
+    }
+  });
+};
+showMenu_fn = function(event) {
+  const { point, lngLat } = event;
+  __privateSet(this, _currentCoords, lngLat);
+  const { left, top } = __privateMethod(this, _ContextMenu_instances, calculateMenuPosition_fn).call(this, point.x, point.y);
+  __privateGet(this, _contextMenuContainer).style.left = `${left}px`;
+  __privateGet(this, _contextMenuContainer).style.top = `${top}px`;
+  __privateGet(this, _contextMenuContainer).style.display = "block";
+};
+createMenuItem_fn = function(options) {
+  const menuItem = document.createElement("div");
+  menuItem.className = "smartmaps-gl-context-menu-item";
+  menuItem.innerHTML = options.label;
+  menuItem.addEventListener("click", () => {
+    if (__privateGet(this, _currentCoords) && options.handler) {
+      options.handler(__privateGet(this, _currentCoords), __privateGet(this, _map3));
+    }
+    this.hide();
+  });
+  return menuItem;
+};
+calculateMenuPosition_fn = function(x, y) {
+  const menuWidth = 160;
+  const menuHeight = 140;
+  const windowWidth = window.innerWidth;
+  const windowHeight = window.innerHeight;
+  let left = x;
+  let top = y;
+  if (x + menuWidth > windowWidth) {
+    left = windowWidth - menuWidth - 10;
+  }
+  if (y + menuHeight > windowHeight) {
+    top = windowHeight - menuHeight - 10;
+  }
+  return { left, top };
+};
+class SmartmapsLogoControl {
+  constructor() {
+    __privateAdd(this, _container3);
+  }
+  onAdd(map) {
+    __privateSet(this, _container3, DOM.create("div", "smartmaps-gl-ctrl"));
+    const anchor = DOM.create("a", "smartmaps-gl-ctrl-logo");
+    anchor.target = "_blank";
+    anchor.rel = "noopener nofollow";
+    anchor.href = "https://smartmaps.net/";
+    anchor.setAttribute("aria-label", "Smartmaps Logo");
+    anchor.setAttribute("rel", "noopener nofollow");
+    __privateGet(this, _container3).appendChild(anchor);
+    __privateGet(this, _container3).style.display = "block";
+    return __privateGet(this, _container3);
+  }
+  onRemove() {
+    if (__privateGet(this, _container3)) {
+      DOM.remove(__privateGet(this, _container3));
+    }
+  }
+  getDefaultPosition() {
+    return "bottom-left";
+  }
+}
+_container3 = new WeakMap();
+export {
+  BrandControl,
+  ContextMenu,
+  GeolocateControl,
+  LanguageControl,
+  LngLat,
+  SmartmapsGlMap as Map,
+  MapLanguage,
+  MapStyle,
+  Marker,
+  Point,
+  SmartmapsLogoControl,
+  applyDefaults,
+  assertNotNull,
+  encodeString,
+  getLoggerUrl,
+  getTilesUrl,
+  toLatLngLiteral,
+  useProductionUrls,
+  useStagingUrls
+};