@maptiler/sdk 1.0.8 → 1.0.10

package/dist/maptiler-sdk.mjs

@@ -7,9 +7,21 @@ import { config as config$1, MapStyle, mapStylePresetList, expandMapStyle, MapSt
 export { LanguageGeocoding, MapStyle, MapStyleVariant, ReferenceMapStyle, ServiceError, coordinates, data, geocoding, geolocation, staticMaps } from '@maptiler/client';
 
 const Language = {
+  /**
+   * AUTO mode uses the language of the browser
+   */
   AUTO: "auto",
+  /**
+   * Default fallback languages that uses latin charaters
+   */
   LATIN: "latin",
+  /**
+   * Default fallback languages that uses non-latin charaters
+   */
   NON_LATIN: "nonlatin",
+  /**
+   * Labels are in their local language, when available
+   */
   LOCAL: "",
   ALBANIAN: "sq",
   AMHARIC: "am",
@@ -100,30 +112,68 @@ function getBrowserLanguage() {
 class SdkConfig extends EventEmitter {
   constructor() {
     super();
+    /**
+     * The primary language. By default, the language of the web browser is used.
+     */
     this.primaryLanguage = Language.AUTO;
+    /**
+     * The secondary language, to overwrite the default language defined in the map style.
+     * This settings is highly dependant on the style compatibility and may not work in most cases.
+     */
     this.secondaryLanguage = null;
+    /**
+     * Setting on whether of not the SDK runs with a session logic.
+     * A "session" is started at the initialization of the SDK and finished when the browser
+     * page is being refreshed.
+     * When `session` is enabled (default: true), the extra URL param `mtsid` is added to queries
+     * on the MapTiler Cloud API. This allows MapTiler to enable "session based billing".
+     */
     this.session = true;
+    /**
+     * Unit to be used
+     */
     this._unit = "metric";
+    /**
+     * MapTiler Cloud API key
+     */
     this._apiKey = "";
   }
+  /**
+   * Set the unit system
+   */
   set unit(u) {
     this._unit = u;
     this.emit("unit", u);
   }
+  /**
+   * Get the unit system
+   */
   get unit() {
     return this._unit;
   }
+  /**
+   * Set the MapTiler Cloud API key
+   */
   set apiKey(k) {
     this._apiKey = k;
     config$1.apiKey = k;
     this.emit("apiKey", k);
   }
+  /**
+   * Get the MapTiler Cloud API key
+   */
   get apiKey() {
     return this._apiKey;
   }
+  /**
+   * Set a the custom fetch function to replace the default one
+   */
   set fetch(f) {
     config$1.fetch = f;
   }
+  /**
+   * Get the fetch fucntion
+   */
   get fetch() {
     return config$1.fetch;
   }
@@ -142,7 +192,13 @@ const defaults = {
 };
 Object.freeze(defaults);
 
-class MaptilerLogoControl extends maplibregl__default.LogoControl {
+class LogoControl extends maplibregl__default.LogoControl {
+  onAdd(map) {
+    return super.onAdd(map);
+  }
+}
+
+class MaptilerLogoControl extends LogoControl {
   constructor(options = {}) {
     var _a, _b;
     super(options);
@@ -190,6 +246,7 @@ function enableRTL() {
       defaults.rtlPluginURL,
       null,
       true
+      // Lazy load the plugin
     );
   }
 }
@@ -287,7 +344,13 @@ class MaptilerTerrainControl {
   }
 }
 
-class MaptilerNavigationControl extends maplibregl__default.NavigationControl {
+class NavigationControl extends maplibregl__default.NavigationControl {
+  onAdd(map) {
+    return super.onAdd(map);
+  }
+}
+
+class MaptilerNavigationControl extends NavigationControl {
   constructor() {
     super({
       showCompass: true,
@@ -313,11 +376,17 @@ class MaptilerNavigationControl extends maplibregl__default.NavigationControl {
       }
     });
   }
+  /**
+   * Overloading: the button now stores its click callback so that we can later on delete it and replace it
+   */
   _createButton(className, fn) {
     const button = super._createButton(className, fn);
     button.clickFunction = fn;
     return button;
   }
+  /**
+   * Overloading: Limit how flat the compass icon can get
+   */
   _rotateCompassArrow() {
     const rotate = this.options.visualizePitch ? `scale(${Math.min(
       1.5,
@@ -327,6 +396,12 @@ class MaptilerNavigationControl extends maplibregl__default.NavigationControl {
   }
 }
 
+class GeolocateControl extends maplibregl__default.GeolocateControl {
+  onAdd(map) {
+    return super.onAdd(map);
+  }
+}
+
 var __defProp$1 = Object.defineProperty;
 var __defProps$1 = Object.defineProperties;
 var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
@@ -346,14 +421,19 @@ var __spreadValues$1 = (a, b) => {
   return a;
 };
 var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
-const GeolocateControl$1 = maplibregl__default.GeolocateControl;
 const Marker$1 = maplibregl__default.Marker;
 const LngLat$1 = maplibregl__default.LngLat;
-class MaptilerGeolocateControl extends GeolocateControl$1 {
+class MaptilerGeolocateControl extends GeolocateControl {
   constructor() {
     super(...arguments);
     this.lastUpdatedCenter = new LngLat$1(0, 0);
   }
+  /**
+   * Update the camera location to center on the current position
+   *
+   * @param {Position} position the Geolocation API Position
+   * @private
+   */
   _updateCamera(position) {
     const center = new LngLat$1(
       position.coords.longitude,
@@ -372,6 +452,7 @@ class MaptilerGeolocateControl extends GeolocateControl$1 {
     }
     this._map.fitBounds(center.toBounds(radius), options, {
       geolocateSource: true
+      // tag this camera change so it won't cause the control to change to background state
     });
     let hasFittingBeenDisrupted = false;
     const flagFittingDisruption = () => {
@@ -491,6 +572,24 @@ class MaptilerGeolocateControl extends GeolocateControl$1 {
   }
 }
 
+class AttributionControl extends maplibregl__default.AttributionControl {
+  onAdd(map) {
+    return super.onAdd(map);
+  }
+}
+
+class ScaleControl extends maplibregl__default.ScaleControl {
+  onAdd(map) {
+    return super.onAdd(map);
+  }
+}
+
+class FullscreenControl extends maplibregl__default.FullscreenControl {
+  onAdd(map) {
+    return super.onAdd(map);
+  }
+}
+
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
@@ -537,7 +636,7 @@ const GeolocationType = {
 };
 class Map extends maplibregl__default.Map {
   constructor(options) {
-    var _a, _b;
+    var _a, _b, _c;
     if (options.apiKey) {
       config.apiKey = options.apiKey;
     }
@@ -575,16 +674,17 @@ class Map extends maplibregl__default.Map {
         };
       }
     }));
-    this.languageShouldUpdate = false;
-    this.isStyleInitialized = false;
     this.isTerrainEnabled = false;
     this.terrainExaggeration = 1;
     this.primaryLanguage = null;
     this.secondaryLanguage = null;
+    this.terrainGrowing = false;
+    this.terrainFlattening = false;
     this.primaryLanguage = (_a = options.language) != null ? _a : config.primaryLanguage;
     this.secondaryLanguage = config.secondaryLanguage;
+    this.terrainExaggeration = (_b = options.terrainExaggeration) != null ? _b : this.terrainExaggeration;
     this.once("styledata", () => __async(this, null, function* () {
-      if (options.geolocate === false) {
+      if (!options.geolocate) {
         return;
       }
       if (options.center) {
@@ -613,20 +713,35 @@ class Map extends maplibregl__default.Map {
       });
       if (locationResult.state === "granted") {
         navigator.geolocation.getCurrentPosition(
+          // success callback
           (data) => {
             if (ipLocatedCameraHash !== this.getCameraHash()) {
               return;
             }
-            this.easeTo({
-              center: [data.coords.longitude, data.coords.latitude],
-              zoom: options.zoom || 12,
-              duration: 2e3
-            });
+            if (this.terrain) {
+              this.easeTo({
+                center: [data.coords.longitude, data.coords.latitude],
+                zoom: options.zoom || 12,
+                duration: 2e3
+              });
+            } else {
+              this.once("terrain", () => {
+                this.easeTo({
+                  center: [data.coords.longitude, data.coords.latitude],
+                  zoom: options.zoom || 12,
+                  duration: 2e3
+                });
+              });
+            }
           },
+          // error callback
           null,
+          // options
           {
             maximumAge: 24 * 3600 * 1e3,
+            // a day in millisec
             timeout: 5e3,
+            // milliseconds
             enableHighAccuracy: false
           }
         );
@@ -667,14 +782,14 @@ class Map extends maplibregl__default.Map {
           options.logoPosition
         );
         if (options.attributionControl === false) {
-          this.addControl(new maplibregl__default.AttributionControl(options));
+          this.addControl(new AttributionControl(options));
         }
       } else if (options.maptilerLogo) {
         this.addControl(new MaptilerLogoControl(), options.logoPosition);
       }
       if (options.scaleControl) {
         const position = options.scaleControl === true || options.scaleControl === void 0 ? "bottom-right" : options.scaleControl;
-        const scaleControl = new maplibregl__default.ScaleControl({ unit: config.unit });
+        const scaleControl = new ScaleControl({ unit: config.unit });
         this.addControl(scaleControl, position);
         config.on("unit", (unit) => {
           scaleControl.setUnit(unit);
@@ -687,6 +802,7 @@ class Map extends maplibregl__default.Map {
       if (options.geolocateControl !== false) {
         const position = options.geolocateControl === true || options.geolocateControl === void 0 ? "top-right" : options.geolocateControl;
         this.addControl(
+          // new maplibregl.GeolocateControl({
           new MaptilerGeolocateControl({
             positionOptions: {
               enableHighAccuracy: true,
@@ -709,24 +825,104 @@ class Map extends maplibregl__default.Map {
       }
       if (options.fullscreenControl) {
         const position = options.fullscreenControl === true || options.fullscreenControl === void 0 ? "top-right" : options.fullscreenControl;
-        this.addControl(new maplibregl__default.FullscreenControl({}), position);
+        this.addControl(new FullscreenControl({}), position);
       }
     }));
+    let loadEventTriggered = false;
+    let terrainEventTriggered = false;
+    let terrainEventData = null;
+    this.once("load", (_) => {
+      loadEventTriggered = true;
+      if (terrainEventTriggered) {
+        this.fire("loadWithTerrain", terrainEventData);
+      }
+    });
+    const terrainCallback = (evt) => {
+      if (!evt.terrain)
+        return;
+      terrainEventTriggered = true;
+      terrainEventData = {
+        type: "loadWithTerrain",
+        target: this,
+        terrain: evt.terrain
+      };
+      this.off("terrain", terrainCallback);
+      if (loadEventTriggered) {
+        this.fire("loadWithTerrain", terrainEventData);
+      }
+    };
+    this.on("terrain", terrainCallback);
     if (options.terrain) {
       this.enableTerrain(
-        (_b = options.terrainExaggeration) != null ? _b : this.terrainExaggeration
+        (_c = options.terrainExaggeration) != null ? _c : this.terrainExaggeration
       );
     }
   }
+  /**
+   * Awaits for _this_ Map instance to be "loaded" and returns a Promise to the Map.
+   * If _this_ Map instance is already loaded, the Promise is resolved directly,
+   * otherwise, it is resolved as a result of the "load" event.
+   * @returns
+   */
+  onLoadAsync() {
+    return __async(this, null, function* () {
+      return new Promise((resolve, reject) => {
+        if (this.loaded()) {
+          return resolve(this);
+        }
+        this.once("load", (_) => {
+          resolve(this);
+        });
+      });
+    });
+  }
+  /**
+   * Awaits for _this_ Map instance to be "loaded" as well as with terrain being non-null for the first time
+   * and returns a Promise to the Map.
+   * If _this_ Map instance is already loaded with terrain, the Promise is resolved directly,
+   * otherwise, it is resolved as a result of the "loadWithTerrain" event.
+   * @returns
+   */
+  onLoadWithTerrainAsync() {
+    return __async(this, null, function* () {
+      return new Promise((resolve, reject) => {
+        if (this.loaded() && this.terrain) {
+          return resolve(this);
+        }
+        this.once("loadWithTerrain", (_) => {
+          resolve(this);
+        });
+      });
+    });
+  }
+  /**
+   * Update the style of the map.
+   * Can be:
+   * - a full style URL (possibly with API key)
+   * - a shorthand with only the MapTIler style name (eg. `"streets-v2"`)
+   * - a longer form with the prefix `"maptiler://"` (eg. `"maptiler://streets-v2"`)
+   * @param style
+   * @param options
+   * @returns
+   */
   setStyle(style, options) {
     return super.setStyle(styleToStyle(style), options);
   }
+  /**
+   * Define the primary language of the map. Note that not all the languages shorthands provided are available.
+   * This function is a short for `.setPrimaryLanguage()`
+   * @param language
+   */
   setLanguage(language = defaults.primaryLanguage) {
     if (language === Language.AUTO) {
       return this.setLanguage(getBrowserLanguage());
     }
     this.setPrimaryLanguage(language);
   }
+  /**
+   * Define the primary language of the map. Note that not all the languages shorthands provided are available.
+   * @param language
+   */
   setPrimaryLanguage(language = defaults.primaryLanguage) {
     if (!isLanguageSupported(language)) {
       return;
@@ -801,6 +997,11 @@ class Map extends maplibregl__default.Map {
       }
     });
   }
+  /**
+   * Define the secondary language of the map. Note that this is not supported by all the map styles
+   * Note that most styles do not allow a secondary language and this function only works if the style allows (no force adding)
+   * @param language
+   */
   setSecondaryLanguage(language = defaults.secondaryLanguage) {
     if (!isLanguageSupported(language)) {
       return;
@@ -865,38 +1066,111 @@ class Map extends maplibregl__default.Map {
       }
     });
   }
+  /**
+   * Get the primary language
+   * @returns
+   */
   getPrimaryLanguage() {
     return this.primaryLanguage;
   }
+  /**
+   * Get the secondary language
+   * @returns
+   */
   getSecondaryLanguage() {
     return this.secondaryLanguage;
   }
+  /**
+   * Get the exaggeration factor applied to the terrain
+   * @returns
+   */
   getTerrainExaggeration() {
     return this.terrainExaggeration;
   }
+  /**
+   * Know if terrian is enabled or not
+   * @returns
+   */
   hasTerrain() {
     return this.isTerrainEnabled;
   }
+  growTerrain(exaggeration, durationMs = 1e3) {
+    if (!this.terrain) {
+      return;
+    }
+    const startTime = performance.now();
+    const currentExaggeration = this.terrain.exaggeration;
+    const deltaExaggeration = exaggeration - currentExaggeration;
+    const updateExaggeration = () => {
+      if (!this.terrain) {
+        return;
+      }
+      if (this.terrainFlattening) {
+        return;
+      }
+      const positionInLoop = (performance.now() - startTime) / durationMs;
+      if (positionInLoop < 0.99) {
+        const exaggerationFactor = 1 - Math.pow(1 - positionInLoop, 4);
+        const newExaggeration = currentExaggeration + exaggerationFactor * deltaExaggeration;
+        this.terrain.exaggeration = newExaggeration;
+        requestAnimationFrame(updateExaggeration);
+      } else {
+        this.terrainGrowing = false;
+        this.terrainFlattening = false;
+        this.terrain.exaggeration = exaggeration;
+      }
+      this.triggerRepaint();
+    };
+    this.terrainGrowing = true;
+    this.terrainFlattening = false;
+    requestAnimationFrame(updateExaggeration);
+  }
+  /**
+   * Enables the 3D terrain visualization
+   * @param exaggeration
+   * @returns
+   */
   enableTerrain(exaggeration = this.terrainExaggeration) {
     if (exaggeration < 0) {
       console.warn("Terrain exaggeration cannot be negative.");
       return;
     }
-    const terrainInfo = this.getTerrain();
+    const dataEventTerrainGrow = (evt) => __async(this, null, function* () {
+      if (!this.terrain) {
+        return;
+      }
+      if (evt.type !== "data" || evt.dataType !== "source" || !("source" in evt)) {
+        return;
+      }
+      if (evt.sourceId !== "maptiler-terrain") {
+        return;
+      }
+      const source = evt.source;
+      if (source.type !== "raster-dem") {
+        return;
+      }
+      if (!evt.isSourceLoaded) {
+        return;
+      }
+      this.off("data", dataEventTerrainGrow);
+      this.growTerrain(exaggeration);
+    });
     const addTerrain = () => {
       this.isTerrainEnabled = true;
       this.terrainExaggeration = exaggeration;
+      this.on("data", dataEventTerrainGrow);
       this.addSource(defaults.terrainSourceId, {
         type: "raster-dem",
         url: defaults.terrainSourceURL
       });
       this.setTerrain({
         source: defaults.terrainSourceId,
-        exaggeration
+        exaggeration: 0
       });
     };
-    if (terrainInfo) {
-      this.setTerrain(__spreadProps(__spreadValues({}, terrainInfo), { exaggeration }));
+    if (this.getTerrain()) {
+      this.isTerrainEnabled = true;
+      this.growTerrain(exaggeration);
       return;
     }
     if (this.loaded() || this.isTerrainEnabled) {
@@ -910,16 +1184,68 @@ class Map extends maplibregl__default.Map {
       });
     }
   }
+  /**
+   * Disable the 3D terrain visualization
+   */
   disableTerrain() {
+    if (!this.terrain) {
+      return;
+    }
     this.isTerrainEnabled = false;
-    this.setTerrain(null);
-    if (this.getSource(defaults.terrainSourceId)) {
-      this.removeSource(defaults.terrainSourceId);
+    const animationLoopDuration = 1 * 1e3;
+    const startTime = performance.now();
+    const currentExaggeration = this.terrain.exaggeration;
+    const updateExaggeration = () => {
+      if (!this.terrain) {
+        return;
+      }
+      if (this.terrainGrowing) {
+        return;
+      }
+      const positionInLoop = (performance.now() - startTime) / animationLoopDuration;
+      if (positionInLoop < 0.99) {
+        const exaggerationFactor = Math.pow(1 - positionInLoop, 4);
+        const newExaggeration = currentExaggeration * exaggerationFactor;
+        this.terrain.exaggeration = newExaggeration;
+        requestAnimationFrame(updateExaggeration);
+      } else {
+        this.terrain.exaggeration = 0;
+        this.terrainGrowing = false;
+        this.terrainFlattening = false;
+        this.setTerrain(null);
+        if (this.getSource(defaults.terrainSourceId)) {
+          this.removeSource(defaults.terrainSourceId);
+        }
+      }
+      this.triggerRepaint();
+    };
+    this.terrainGrowing = false;
+    this.terrainFlattening = true;
+    requestAnimationFrame(updateExaggeration);
+  }
+  /**
+   * Sets the 3D terrain exageration factor.
+   * If the terrain was not enabled prior to the call of this method,
+   * the method `.enableTerrain()` will be called.
+   * If `animate` is `true`, the terrain transformation will be animated in the span of 1 second.
+   * If `animate` is `false`, no animated transition to the newly defined exaggeration.
+   * @param exaggeration
+   * @param animate
+   */
+  setTerrainExaggeration(exaggeration, animate = true) {
+    if (!animate && this.terrain) {
+      this.terrainExaggeration = exaggeration;
+      this.terrain.exaggeration = exaggeration;
+      this.triggerRepaint();
+    } else {
+      this.enableTerrain(exaggeration);
     }
   }
-  setTerrainExaggeration(exaggeration) {
-    this.enableTerrain(exaggeration);
-  }
+  /**
+   * Perform an action when the style is ready. It could be at the moment of calling this method
+   * or later.
+   * @param cb
+   */
   onStyleReady(cb) {
     if (this.isStyleLoaded()) {
       cb();
@@ -960,14 +1286,91 @@ class Map extends maplibregl__default.Map {
     hashBin[4] = this.getBearing();
     return Base64.fromUint8Array(new Uint8Array(hashBin.buffer));
   }
+  /**
+   * Get the SDK config object.
+   * This is convenient to dispatch the SDK configuration to externally built layers
+   * that do not directly have access to the SDK configuration but do have access to a Map instance.
+   * @returns
+   */
   getSdkConfig() {
     return config;
   }
+  /**
+   * Get the MapTiler session ID. Convenient to dispatch to externaly built component
+   * that do not directly have access to the SDK configuration but do have access to a Map instance.
+   * @returns
+   */
   getMaptilerSessionId() {
     return MAPTILER_SESSION_ID;
   }
 }
 
+class Marker extends maplibregl__default.Marker {
+  addTo(map) {
+    return super.addTo(map);
+  }
+}
+
+class Popup extends maplibregl__default.Popup {
+  addTo(map) {
+    return super.addTo(map);
+  }
+}
+
+class Style extends maplibregl__default.Style {
+  constructor(map, options = {}) {
+    super(map, options);
+  }
+}
+
+class CanvasSource extends maplibregl__default.CanvasSource {
+  onAdd(map) {
+    super.onAdd(map);
+  }
+}
+
+class GeoJSONSource extends maplibregl__default.GeoJSONSource {
+  onAdd(map) {
+    super.onAdd(map);
+  }
+}
+
+class ImageSource extends maplibregl__default.ImageSource {
+  onAdd(map) {
+    super.onAdd(map);
+  }
+}
+
+class RasterTileSource extends maplibregl__default.RasterTileSource {
+  onAdd(map) {
+    super.onAdd(map);
+  }
+}
+
+class RasterDEMTileSource extends maplibregl__default.RasterDEMTileSource {
+  onAdd(map) {
+    super.onAdd(map);
+  }
+}
+
+class VectorTileSource extends maplibregl__default.VectorTileSource {
+  onAdd(map) {
+    super.onAdd(map);
+  }
+}
+
+class VideoSource extends maplibregl__default.VideoSource {
+  onAdd(map) {
+    super.onAdd(map);
+  }
+}
+
+class TerrainControl extends maplibregl__default.TerrainControl {
+  onAdd(map) {
+    return super.onAdd(map);
+  }
+}
+
 class Point {
   constructor(x, y) {
     this.x = x;
@@ -1043,71 +1446,205 @@ class Point {
     this.y = Math.round(this.y);
     return this;
   }
+  /**
+   * Clone this point, returning a new point that can be modified
+   * without affecting the old one.
+   * @return {Point} the clone
+   */
   clone() {
     return new Point(this.x, this.y);
   }
+  /**
+   * Add this point's x & y coordinates to another point,
+   * yielding a new point.
+   * @param {Point} p the other point
+   * @return {Point} output point
+   */
   add(p) {
     return this.clone()._add(p);
   }
+  /**
+   * Subtract this point's x & y coordinates to from point,
+   * yielding a new point.
+   * @param {Point} p the other point
+   * @return {Point} output point
+   */
   sub(p) {
     return this.clone()._sub(p);
   }
+  /**
+   * Multiply this point's x & y coordinates by point,
+   * yielding a new point.
+   * @param {Point} p the other point
+   * @return {Point} output point
+   */
   multByPoint(p) {
     return this.clone()._multByPoint(p);
   }
+  /**
+   * Divide this point's x & y coordinates by point,
+   * yielding a new point.
+   * @param {Point} p the other point
+   * @return {Point} output point
+   */
   divByPoint(p) {
     return this.clone()._divByPoint(p);
   }
+  /**
+   * Multiply this point's x & y coordinates by a factor,
+   * yielding a new point.
+   * @param {Number} k factor
+   * @return {Point} output point
+   */
   mult(k) {
     return this.clone()._mult(k);
   }
+  /**
+   * Divide this point's x & y coordinates by a factor,
+   * yielding a new point.
+   * @param {Point} k factor
+   * @return {Point} output point
+   */
   div(k) {
     return this.clone()._div(k);
   }
+  /**
+   * Rotate this point around the 0, 0 origin by an angle a,
+   * given in radians
+   * @param {Number} a angle to rotate around, in radians
+   * @return {Point} output point
+   */
   rotate(a) {
     return this.clone()._rotate(a);
   }
+  /**
+   * Rotate this point around p point by an angle a,
+   * given in radians
+   * @param {Number} a angle to rotate around, in radians
+   * @param {Point} p Point to rotate around
+   * @return {Point} output point
+   */
   rotateAround(a, p) {
     return this.clone()._rotateAround(a, p);
   }
+  /**
+   * Multiply this point by a 4x1 transformation matrix
+   * @param {Array<Number>} m transformation matrix
+   * @return {Point} output point
+   */
   matMult(m) {
     return this.clone()._matMult(m);
   }
+  /**
+   * Calculate this point but as a unit vector from 0, 0, meaning
+   * that the distance from the resulting point to the 0, 0
+   * coordinate will be equal to 1 and the angle from the resulting
+   * point to the 0, 0 coordinate will be the same as before.
+   * @return {Point} unit vector point
+   */
   unit() {
     return this.clone()._unit();
   }
+  /**
+   * Compute a perpendicular point, where the new y coordinate
+   * is the old x coordinate and the new x coordinate is the old y
+   * coordinate multiplied by -1
+   * @return {Point} perpendicular point
+   */
   perp() {
     return this.clone()._perp();
   }
+  /**
+   * Return a version of this point with the x & y coordinates
+   * rounded to integers.
+   * @return {Point} rounded point
+   */
   round() {
     return this.clone()._round();
   }
+  /**
+   * Return the magnitude of this point: this is the Euclidean
+   * distance from the 0, 0 coordinate to this point's x and y
+   * coordinates.
+   * @return {Number} magnitude
+   */
   mag() {
     return Math.sqrt(this.x * this.x + this.y * this.y);
   }
+  /**
+   * Judge whether this point is equal to another point, returning
+   * true or false.
+   * @param {Point} other the other point
+   * @return {boolean} whether the points are equal
+   */
   equals(other) {
     return this.x === other.x && this.y === other.y;
   }
+  /**
+   * Calculate the distance from this point to another point
+   * @param {Point} p the other point
+   * @return {Number} distance
+   */
   dist(p) {
     return Math.sqrt(this.distSqr(p));
   }
+  /**
+   * Calculate the distance from this point to another point,
+   * without the square root step. Useful if you're comparing
+   * relative distances.
+   * @param {Point} p the other point
+   * @return {Number} distance
+   */
   distSqr(p) {
     const dx = p.x - this.x;
     const dy = p.y - this.y;
     return dx * dx + dy * dy;
   }
+  /**
+   * Get the angle from the 0, 0 coordinate to this point, in radians
+   * coordinates.
+   * @return {Number} angle
+   */
   angle() {
     return Math.atan2(this.y, this.x);
   }
+  /**
+   * Get the angle from this point to another point, in radians
+   * @param {Point} b the other point
+   * @return {Number} angle
+   */
   angleTo(b) {
     return Math.atan2(this.y - b.y, this.x - b.x);
   }
+  /**
+   * Get the angle between this point and another point, in radians
+   * @param {Point} b the other point
+   * @return {Number} angle
+   */
   angleWith(b) {
     return this.angleWithSep(b.x, b.y);
   }
+  /*
+   * Find the angle of the two vectors, solving the formula for
+   * the cross product a x b = |a||b|sin(θ) for θ.
+   * @param {Number} x the x-coordinate
+   * @param {Number} y the y-coordinate
+   * @return {Number} the angle in radians
+   */
   angleWithSep(x, y) {
     return Math.atan2(this.x * y - this.y * x, this.x * x + this.y * y);
   }
+  /**
+   * Construct a point from an array if necessary, otherwise if the input
+   * is already a Point, or an unknown type, return it unchanged
+   * @param {Array<number> | Point} a any kind of input value
+   * @return {Point} constructed point, or passed-through value.
+   * @example
+   * // this
+   * var point = Point.convert([0, 1]);
+   * // is equivalent to
+   * var point = new Point(0, 1);
+   */
   static convert(a) {
     if (a instanceof Point) {
       return a;
@@ -1123,38 +1660,38 @@ const {
   supported,
   setRTLTextPlugin,
   getRTLTextPluginStatus,
-  NavigationControl,
-  GeolocateControl,
-  AttributionControl,
-  LogoControl,
-  ScaleControl,
-  FullscreenControl,
-  TerrainControl,
-  Popup,
-  Marker,
-  Style,
   LngLat,
   LngLatBounds,
   MercatorCoordinate,
   Evented,
   AJAXError,
-  CanvasSource,
-  GeoJSONSource,
-  ImageSource,
-  RasterDEMTileSource,
-  RasterTileSource,
-  VectorTileSource,
-  VideoSource,
   prewarm,
   clearPrewarmedResources,
   version,
   workerCount,
   maxParallelImageRequests,
-  clearStorage,
   workerUrl,
   addProtocol,
   removeProtocol
 } = maplibregl__default;
+const MapMLGL = maplibregl__default.Map;
+const MarkerMLGL = maplibregl__default.Marker;
+const PopupMLGL = maplibregl__default.Popup;
+const StyleMLGL = maplibregl__default.Style;
+const CanvasSourceMLGL = maplibregl__default.CanvasSource;
+const GeoJSONSourceMLGL = maplibregl__default.GeoJSONSource;
+const ImageSourceMLGL = maplibregl__default.ImageSource;
+const RasterTileSourceMLGL = maplibregl__default.RasterTileSource;
+const RasterDEMTileSourceMLGL = maplibregl__default.RasterDEMTileSource;
+const VectorTileSourceMLGL = maplibregl__default.VectorTileSource;
+const VideoSourceMLGL = maplibregl__default.VideoSource;
+maplibregl__default.NavigationControl;
+maplibregl__default.GeolocateControl;
+maplibregl__default.AttributionControl;
+maplibregl__default.LogoControl;
+maplibregl__default.ScaleControl;
+maplibregl__default.FullscreenControl;
+maplibregl__default.TerrainControl;
 
-export { AJAXError, AttributionControl, CanvasSource, Evented, FullscreenControl, GeoJSONSource, GeolocateControl, GeolocationType, ImageSource, Language, LngLat, LngLatBounds, LogoControl, Map, MaptilerGeolocateControl, MaptilerLogoControl, MaptilerTerrainControl, Marker, MercatorCoordinate, NavigationControl, Point, Popup, RasterDEMTileSource, RasterTileSource, ScaleControl, SdkConfig, Style, TerrainControl, VectorTileSource, VideoSource, addProtocol, clearPrewarmedResources, clearStorage, config, getRTLTextPluginStatus, maxParallelImageRequests, prewarm, removeProtocol, setRTLTextPlugin, supported, version, workerCount, workerUrl };
+export { AJAXError, AttributionControl, CanvasSource, CanvasSourceMLGL, Evented, FullscreenControl, GeoJSONSource, GeoJSONSourceMLGL, GeolocateControl, GeolocationType, ImageSource, ImageSourceMLGL, Language, LngLat, LngLatBounds, LogoControl, Map, MapMLGL, MaptilerGeolocateControl, MaptilerLogoControl, MaptilerTerrainControl, Marker, MarkerMLGL, MercatorCoordinate, NavigationControl, Point, Popup, PopupMLGL, RasterDEMTileSource, RasterDEMTileSourceMLGL, RasterTileSource, RasterTileSourceMLGL, ScaleControl, SdkConfig, Style, StyleMLGL, TerrainControl, VectorTileSource, VectorTileSourceMLGL, VideoSource, VideoSourceMLGL, addProtocol, clearPrewarmedResources, config, getRTLTextPluginStatus, maxParallelImageRequests, prewarm, removeProtocol, setRTLTextPlugin, supported, version, workerCount, workerUrl };
 //# sourceMappingURL=maptiler-sdk.mjs.map